Removing published repos & matching files.

debian/publish_test.go

@@ -45,7 +45,7 @@ func (s *PublishedRepoSuite) SetUpTest(c *C) {
 
 	s.snapshot, _ = NewSnapshotFromRepository("snap", repo)
 
-	s.repo = NewPublishedRepo("ppa", "squeeze", "main", nil, s.snapshot)
+	s.repo, _ = NewPublishedRepo("ppa", "squeeze", "main", nil, s.snapshot)
 
 	s.packageCollection = NewPackageCollection(s.db)
 	s.packageCollection.Update(s.p1)
@@ -63,6 +63,71 @@ func (s *PublishedRepoSuite) TearDownTest(c *C) {
 	s.db.Close()
 }
 
+func (s *PublishedRepoSuite) TestPrefixNormalization(c *C) {
+
+	for _, t := range []struct {
+		prefix        string
+		expected      string
+		errorExpected string
+	}{
+		{
+			prefix:   "ppa",
+			expected: "ppa",
+		},
+		{
+			prefix:   "",
+			expected: ".",
+		},
+		{
+			prefix:   "/",
+			expected: ".",
+		},
+		{
+			prefix:   "//",
+			expected: ".",
+		},
+		{
+			prefix:   "//ppa/",
+			expected: "ppa",
+		},
+		{
+			prefix:   "ppa/..",
+			expected: ".",
+		},
+		{
+			prefix:   "ppa/ubuntu/",
+			expected: "ppa/ubuntu",
+		},
+		{
+			prefix:   "ppa/../ubuntu/",
+			expected: "ubuntu",
+		},
+		{
+			prefix:        "../ppa/",
+			errorExpected: "invalid prefix .*",
+		},
+		{
+			prefix:        "../ppa/../ppa/",
+			errorExpected: "invalid prefix .*",
+		},
+		{
+			prefix:        "ppa/dists",
+			errorExpected: "invalid prefix .*",
+		},
+		{
+			prefix:        "ppa/pool",
+			errorExpected: "invalid prefix .*",
+		},
+	} {
+		repo, err := NewPublishedRepo(t.prefix, "squeeze", "main", nil, s.snapshot)
+		if t.errorExpected != "" {
+			c.Check(err, ErrorMatches, t.errorExpected)
+		} else {
+			c.Check(repo.Prefix, Equals, t.expected)
+		}
+	}
+}
+
 func (s *PublishedRepoSuite) TestPublish(c *C) {
 	err := s.repo.Publish(s.packageRepo, s.packageCollection, &NullSigner{})
 	c.Assert(err, IsNil)
@@ -103,9 +168,11 @@ func (s *PublishedRepoSuite) TestPublish(c *C) {
 func (s *PublishedRepoSuite) TestString(c *C) {
 	c.Check(s.repo.String(), Equals,
 		"ppa/squeeze (main) publishes [snap]: Snapshot from mirror [yandex]: http://mirror.yandex.ru/debian/ squeeze")
-	c.Check(NewPublishedRepo("", "squeeze", "main", nil, s.snapshot).String(), Equals,
+	repo, _ := NewPublishedRepo("", "squeeze", "main", nil, s.snapshot)
+	c.Check(repo.String(), Equals,
 		"./squeeze (main) publishes [snap]: Snapshot from mirror [yandex]: http://mirror.yandex.ru/debian/ squeeze")
-	c.Check(NewPublishedRepo("", "squeeze", "main", []string{"i386", "amd64"}, s.snapshot).String(), Equals,
+	repo, _ = NewPublishedRepo("", "squeeze", "main", []string{"i386", "amd64"}, s.snapshot)
+	c.Check(repo.String(), Equals,
 		"./squeeze (main) [i386, amd64] publishes [snap]: Snapshot from mirror [yandex]: http://mirror.yandex.ru/debian/ squeeze")
 }
 
@@ -145,9 +212,9 @@ func (s *PublishedRepoCollectionSuite) SetUpTest(c *C) {
 	s.snapshotCollection.Add(s.snap1)
 	s.snapshotCollection.Add(s.snap2)
 
-	s.repo1 = NewPublishedRepo("ppa", "anaconda", "main", []string{}, s.snap1)
-	s.repo2 = NewPublishedRepo("", "anaconda", "main", []string{}, s.snap2)
-	s.repo3 = NewPublishedRepo("ppa", "anaconda", "main", []string{}, s.snap2)
+	s.repo1, _ = NewPublishedRepo("ppa", "anaconda", "main", []string{}, s.snap1)
+	s.repo2, _ = NewPublishedRepo("", "anaconda", "main", []string{}, s.snap2)
+	s.repo3, _ = NewPublishedRepo("ppa", "anaconda", "main", []string{}, s.snap2)
 
 	s.collection = NewPublishedRepoCollection(s.db)
 }
@@ -228,3 +295,163 @@ func (s *PublishedRepoCollectionSuite) TestForEachAndLen(c *C) {
 	})
 	c.Assert(err, Equals, e)
 }
+
+type pathExistsChecker struct {
+	*CheckerInfo
+}
+
+var PathExists = &pathExistsChecker{
+	&CheckerInfo{Name: "PathExists", Params: []string{"path"}},
+}
+
+func (checker *pathExistsChecker) Check(params []interface{}, names []string) (result bool, error string) {
+	_, err := os.Stat(params[0].(string))
+	return err == nil, ""
+}
+
+type PublishedRepoRemoveSuite struct {
+	PackageListMixinSuite
+	db                         database.Storage
+	snapshotCollection         *SnapshotCollection
+	collection                 *PublishedRepoCollection
+	packageRepo                *Repository
+	snap1                      *Snapshot
+	repo1, repo2, repo3, repo4 *PublishedRepo
+}
+
+var _ = Suite(&PublishedRepoRemoveSuite{})
+
+func (s *PublishedRepoRemoveSuite) SetUpTest(c *C) {
+	s.db, _ = database.OpenDB(c.MkDir())
+
+	s.snapshotCollection = NewSnapshotCollection(s.db)
+
+	s.snap1 = NewSnapshotFromPackageList("snap1", []*Snapshot{}, NewPackageList(), "desc1")
+
+	s.snapshotCollection.Add(s.snap1)
+
+	s.repo1, _ = NewPublishedRepo("ppa", "anaconda", "main", []string{}, s.snap1)
+	s.repo2, _ = NewPublishedRepo("", "anaconda", "main", []string{}, s.snap1)
+	s.repo3, _ = NewPublishedRepo("ppa", "meduza", "main", []string{}, s.snap1)
+	s.repo4, _ = NewPublishedRepo("ppa", "osminog", "contrib", []string{}, s.snap1)
+
+	s.collection = NewPublishedRepoCollection(s.db)
+	s.collection.Add(s.repo1)
+	s.collection.Add(s.repo2)
+	s.collection.Add(s.repo3)
+	s.collection.Add(s.repo4)
+
+	s.packageRepo = NewRepository(c.MkDir())
+	s.packageRepo.MkDir("ppa/dists/anaconda")
+	s.packageRepo.MkDir("ppa/dists/meduza")
+	s.packageRepo.MkDir("ppa/dists/osminog")
+	s.packageRepo.MkDir("ppa/pool/main")
+	s.packageRepo.MkDir("ppa/pool/contrib")
+	s.packageRepo.MkDir("dists/anaconda")
+	s.packageRepo.MkDir("pool/main")
+}
+
+func (s *PublishedRepoRemoveSuite) TearDownTest(c *C) {
+	s.db.Close()
+}
+
+func (s *PublishedRepoRemoveSuite) TestRemoveFilesOnlyDist(c *C) {
+	s.repo1.RemoveFiles(s.packageRepo, false, false)
+
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/dists/anaconda"), Not(PathExists))
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/dists/meduza"), PathExists)
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/dists/osminog"), PathExists)
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/pool/main"), PathExists)
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/pool/contrib"), PathExists)
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "dists/anaconda"), PathExists)
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "pool/main"), PathExists)
+}
+
+func (s *PublishedRepoRemoveSuite) TestRemoveFilesWithPool(c *C) {
+	s.repo1.RemoveFiles(s.packageRepo, false, true)
+
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/dists/anaconda"), Not(PathExists))
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/dists/meduza"), PathExists)
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/dists/osminog"), PathExists)
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/pool/main"), Not(PathExists))
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/pool/contrib"), PathExists)
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "dists/anaconda"), PathExists)
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "pool/main"), PathExists)
+}
+
+func (s *PublishedRepoRemoveSuite) TestRemoveFilesWithPrefix(c *C) {
+	s.repo1.RemoveFiles(s.packageRepo, true, true)
+
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/dists/anaconda"), Not(PathExists))
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/dists/meduza"), Not(PathExists))
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/dists/osminog"), Not(PathExists))
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/pool/main"), Not(PathExists))
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/pool/contrib"), Not(PathExists))
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "dists/anaconda"), PathExists)
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "pool/main"), PathExists)
+}
+
+func (s *PublishedRepoRemoveSuite) TestRemoveFilesWithPrefixRoot(c *C) {
+	s.repo2.RemoveFiles(s.packageRepo, true, true)
+
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/dists/anaconda"), PathExists)
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/dists/meduza"), PathExists)
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/pool/main"), PathExists)
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/pool/contrib"), PathExists)
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "dists/anaconda"), Not(PathExists))
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "pool/main"), Not(PathExists))
+}
+
+func (s *PublishedRepoRemoveSuite) TestRemoveRepo1and2(c *C) {
+	err := s.collection.Remove(s.packageRepo, "ppa", "anaconda")
+	c.Check(err, IsNil)
+
+	_, err = s.collection.ByPrefixDistribution("ppa", "anaconda")
+	c.Check(err, ErrorMatches, ".*not found")
+
+	collection := NewPublishedRepoCollection(s.db)
+	_, err = collection.ByPrefixDistribution("ppa", "anaconda")
+	c.Check(err, ErrorMatches, ".*not found")
+
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/dists/anaconda"), Not(PathExists))
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/dists/meduza"), PathExists)
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/dists/osminog"), PathExists)
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/pool/main"), PathExists)
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/pool/contrib"), PathExists)
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "dists/anaconda"), PathExists)
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "pool/main"), PathExists)
+
+	err = s.collection.Remove(s.packageRepo, "ppa", "anaconda")
+	c.Check(err, ErrorMatches, ".*not found")
+
+	err = s.collection.Remove(s.packageRepo, "ppa", "meduza")
+	c.Check(err, IsNil)
+
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/dists/anaconda"), Not(PathExists))
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/dists/meduza"), Not(PathExists))
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/dists/osminog"), PathExists)
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/pool/main"), Not(PathExists))
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/pool/contrib"), PathExists)
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "dists/anaconda"), PathExists)
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "pool/main"), PathExists)
+}
+
+func (s *PublishedRepoRemoveSuite) TestRemoveRepo3(c *C) {
+	err := s.collection.Remove(s.packageRepo, ".", "anaconda")
+	c.Check(err, IsNil)
+
+	_, err = s.collection.ByPrefixDistribution(".", "anaconda")
+	c.Check(err, ErrorMatches, ".*not found")
+
+	collection := NewPublishedRepoCollection(s.db)
+	_, err = collection.ByPrefixDistribution(".", "anaconda")
+	c.Check(err, ErrorMatches, ".*not found")
+
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/dists/anaconda"), PathExists)
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/dists/meduza"), PathExists)
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/dists/osminog"), PathExists)
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/pool/main"), PathExists)
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "ppa/pool/contrib"), PathExists)
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "dists/"), Not(PathExists))
+	c.Check(filepath.Join(s.packageRepo.PublicPath(), "pool/"), Not(PathExists))
+}