1package deb
2
3import (
4	"errors"
5
6	"github.com/aptly-dev/aptly/database"
7
8	. "gopkg.in/check.v1"
9)
10
11type LocalRepoSuite struct {
12	db      database.Storage
13	list    *PackageList
14	reflist *PackageRefList
15	repo    *LocalRepo
16}
17
18var _ = Suite(&LocalRepoSuite{})
19
20func (s *LocalRepoSuite) SetUpTest(c *C) {
21	s.db, _ = database.NewOpenDB(c.MkDir())
22	s.list = NewPackageList()
23	s.list.Add(&Package{Name: "lib", Version: "1.7", Architecture: "i386"})
24	s.list.Add(&Package{Name: "app", Version: "1.9", Architecture: "amd64"})
25
26	s.reflist = NewPackageRefListFromPackageList(s.list)
27
28	s.repo = NewLocalRepo("lrepo", "Super repo")
29	s.repo.packageRefs = s.reflist
30}
31
32func (s *LocalRepoSuite) TearDownTest(c *C) {
33	s.db.Close()
34}
35
36func (s *LocalRepoSuite) TestString(c *C) {
37	c.Check(NewLocalRepo("lrepo", "My first repo").String(), Equals, "[lrepo]: My first repo")
38	c.Check(NewLocalRepo("lrepo2", "").String(), Equals, "[lrepo2]")
39}
40
41func (s *LocalRepoSuite) TestNumPackages(c *C) {
42	c.Check(NewLocalRepo("lrepo", "My first repo").NumPackages(), Equals, 0)
43	c.Check(s.repo.NumPackages(), Equals, 2)
44}
45
46func (s *LocalRepoSuite) TestRefList(c *C) {
47	c.Check(NewLocalRepo("lrepo", "My first repo").RefList(), IsNil)
48	c.Check(s.repo.RefList(), Equals, s.reflist)
49}
50
51func (s *LocalRepoSuite) TestUpdateRefList(c *C) {
52	s.repo.UpdateRefList(nil)
53	c.Check(s.repo.RefList(), IsNil)
54}
55
56func (s *LocalRepoSuite) TestEncodeDecode(c *C) {
57	repo := &LocalRepo{}
58	err := repo.Decode(s.repo.Encode())
59	c.Assert(err, IsNil)
60
61	c.Check(repo.Name, Equals, s.repo.Name)
62	c.Check(repo.Comment, Equals, s.repo.Comment)
63}
64
65func (s *LocalRepoSuite) TestKey(c *C) {
66	c.Assert(len(s.repo.Key()), Equals, 37)
67	c.Assert(s.repo.Key()[0], Equals, byte('L'))
68}
69
70func (s *LocalRepoSuite) TestRefKey(c *C) {
71	c.Assert(len(s.repo.RefKey()), Equals, 37)
72	c.Assert(s.repo.RefKey()[0], Equals, byte('E'))
73	c.Assert(s.repo.RefKey()[1:], DeepEquals, s.repo.Key()[1:])
74}
75
76type LocalRepoCollectionSuite struct {
77	db         database.Storage
78	collection *LocalRepoCollection
79	list       *PackageList
80	reflist    *PackageRefList
81}
82
83var _ = Suite(&LocalRepoCollectionSuite{})
84
85func (s *LocalRepoCollectionSuite) SetUpTest(c *C) {
86	s.db, _ = database.NewOpenDB(c.MkDir())
87	s.collection = NewLocalRepoCollection(s.db)
88
89	s.list = NewPackageList()
90	s.list.Add(&Package{Name: "lib", Version: "1.7", Architecture: "i386"})
91	s.list.Add(&Package{Name: "app", Version: "1.9", Architecture: "amd64"})
92
93	s.reflist = NewPackageRefListFromPackageList(s.list)
94}
95
96func (s *LocalRepoCollectionSuite) TearDownTest(c *C) {
97	s.db.Close()
98}
99
100func (s *LocalRepoCollectionSuite) TestAddByName(c *C) {
101	_, err := s.collection.ByName("local1")
102	c.Assert(err, ErrorMatches, "*.not found")
103
104	repo := NewLocalRepo("local1", "Comment 1")
105	c.Assert(s.collection.Add(repo), IsNil)
106	c.Assert(s.collection.Add(repo), ErrorMatches, ".*already exists")
107
108	r, err := s.collection.ByName("local1")
109	c.Assert(err, IsNil)
110	c.Assert(r.String(), Equals, repo.String())
111
112	collection := NewLocalRepoCollection(s.db)
113	r, err = collection.ByName("local1")
114	c.Assert(err, IsNil)
115	c.Assert(r.String(), Equals, repo.String())
116}
117
118func (s *LocalRepoCollectionSuite) TestByUUID(c *C) {
119	_, err := s.collection.ByUUID("some-uuid")
120	c.Assert(err, ErrorMatches, "*.not found")
121
122	repo := NewLocalRepo("local1", "Comment 1")
123	c.Assert(s.collection.Add(repo), IsNil)
124
125	r, err := s.collection.ByUUID(repo.UUID)
126	c.Assert(err, IsNil)
127	c.Assert(r, Equals, repo)
128
129	collection := NewLocalRepoCollection(s.db)
130	r, err = collection.ByUUID(repo.UUID)
131	c.Assert(err, IsNil)
132	c.Assert(r.String(), Equals, repo.String())
133}
134
135func (s *LocalRepoCollectionSuite) TestUpdateLoadComplete(c *C) {
136	repo := NewLocalRepo("local1", "Comment 1")
137	c.Assert(s.collection.Update(repo), IsNil)
138
139	collection := NewLocalRepoCollection(s.db)
140	r, err := collection.ByName("local1")
141	c.Assert(err, IsNil)
142	c.Assert(r.packageRefs, IsNil)
143
144	repo.packageRefs = s.reflist
145	c.Assert(s.collection.Update(repo), IsNil)
146
147	collection = NewLocalRepoCollection(s.db)
148	r, err = collection.ByName("local1")
149	c.Assert(err, IsNil)
150	c.Assert(r.packageRefs, IsNil)
151	c.Assert(r.NumPackages(), Equals, 0)
152	c.Assert(s.collection.LoadComplete(r), IsNil)
153	c.Assert(r.NumPackages(), Equals, 2)
154}
155
156func (s *LocalRepoCollectionSuite) TestForEachAndLen(c *C) {
157	repo := NewLocalRepo("local1", "Comment 1")
158	s.collection.Add(repo)
159
160	count := 0
161	err := s.collection.ForEach(func(*LocalRepo) error {
162		count++
163		return nil
164	})
165	c.Assert(count, Equals, 1)
166	c.Assert(err, IsNil)
167
168	c.Check(s.collection.Len(), Equals, 1)
169
170	e := errors.New("c")
171
172	err = s.collection.ForEach(func(*LocalRepo) error {
173		return e
174	})
175	c.Assert(err, Equals, e)
176}
177
178func (s *LocalRepoCollectionSuite) TestDrop(c *C) {
179	repo1 := NewLocalRepo("local1", "Comment 1")
180	s.collection.Add(repo1)
181
182	repo2 := NewLocalRepo("local2", "Comment 2")
183	s.collection.Add(repo2)
184
185	r1, _ := s.collection.ByUUID(repo1.UUID)
186	c.Check(r1, Equals, repo1)
187
188	err := s.collection.Drop(repo1)
189	c.Check(err, IsNil)
190
191	_, err = s.collection.ByUUID(repo1.UUID)
192	c.Check(err, ErrorMatches, "local repo .* not found")
193
194	collection := NewLocalRepoCollection(s.db)
195	_, err = collection.ByName("local1")
196	c.Check(err, ErrorMatches, "local repo .* not found")
197
198	r2, _ := collection.ByName("local2")
199	c.Check(r2.String(), Equals, repo2.String())
200
201	c.Check(func() { s.collection.Drop(repo1) }, Panics, "local repo not found!")
202}
203