← Back to branch summary

~sidnei/juju-core/lxc-clone-with-overlayfs

« back to all changes in this revision

Viewing changes to worker/uniter/charm/git_test.go

  • Committer: Sidnei da Silva
  • Date: 2013-10-21 18:33:07 UTC
  • mfrom: (1667.1.329 juju-core)
  • Revision ID: sidnei.da.silva@canonical.com-20131021183307-fylyr68s4gtbxr08
- Merge from trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
worker/uniter/charm/git_test.go
5
5
 
6
6
import (
7
7
        "io/ioutil"
8
 
        . "launchpad.net/gocheck"
 
8
        "os"
 
9
        "os/exec"
 
10
        "path/filepath"
 
11
 
 
12
        gc "launchpad.net/gocheck"
 
13
 
9
14
        corecharm "launchpad.net/juju-core/charm"
10
15
        "launchpad.net/juju-core/testing"
11
 
        "launchpad.net/juju-core/testing/checkers"
 
16
        jc "launchpad.net/juju-core/testing/checkers"
 
17
        "launchpad.net/juju-core/testing/testbase"
12
18
        "launchpad.net/juju-core/worker/uniter/charm"
13
 
        "os"
14
 
        "path/filepath"
15
19
)
16
20
 
17
21
var curl = corecharm.MustParseURL("cs:series/blah-blah-123")
18
22
 
19
23
type GitDirSuite struct {
20
24
        testing.GitSuite
21
 
        LoggingSuite testing.LoggingSuite
22
 
        oldLcAll     string
 
25
        LoggingSuite testbase.LoggingSuite
23
26
}
24
27
 
25
 
var _ = Suite(&GitDirSuite{})
 
28
var _ = gc.Suite(&GitDirSuite{})
26
29
 
27
 
func (s *GitDirSuite) SetUpTest(c *C) {
 
30
func (s *GitDirSuite) SetUpTest(c *gc.C) {
28
31
        s.GitSuite.SetUpTest(c)
29
32
        s.LoggingSuite.SetUpTest(c)
30
 
        s.oldLcAll = os.Getenv("LC_ALL")
31
 
        os.Setenv("LC_ALL", "en_US")
 
33
        s.LoggingSuite.PatchEnvironment("LC_ALL", "en_US")
32
34
}
33
35
 
34
 
func (s *GitDirSuite) TearDownTest(c *C) {
35
 
        os.Setenv("LC_ALL", s.oldLcAll)
 
36
func (s *GitDirSuite) TearDownTest(c *gc.C) {
36
37
        s.LoggingSuite.TearDownTest(c)
37
38
        s.GitSuite.TearDownTest(c)
38
39
}
39
40
 
40
 
func (s *GitDirSuite) TestCreate(c *C) {
 
41
func (s *GitDirSuite) TestInitConfig(c *gc.C) {
 
42
        base := c.MkDir()
 
43
        repo := charm.NewGitDir(filepath.Join(base, "repo"))
 
44
        err := repo.Init()
 
45
        c.Assert(err, gc.IsNil)
 
46
 
 
47
        cmd := exec.Command("git", "config", "--list", "--local")
 
48
        cmd.Dir = repo.Path()
 
49
        out, err := cmd.Output()
 
50
        c.Assert(err, gc.IsNil)
 
51
        outstr := string(out)
 
52
        c.Assert(outstr, jc.Contains, "user.email=juju@localhost")
 
53
        c.Assert(outstr, jc.Contains, "user.name=juju")
 
54
}
 
55
 
 
56
func (s *GitDirSuite) TestCreate(c *gc.C) {
41
57
        base := c.MkDir()
42
58
        repo := charm.NewGitDir(filepath.Join(base, "repo"))
43
59
        exists, err := repo.Exists()
44
 
        c.Assert(err, IsNil)
45
 
        c.Assert(exists, Equals, false)
 
60
        c.Assert(err, gc.IsNil)
 
61
        c.Assert(exists, jc.IsFalse)
46
62
 
47
63
        err = ioutil.WriteFile(repo.Path(), nil, 0644)
48
 
        c.Assert(err, IsNil)
 
64
        c.Assert(err, gc.IsNil)
49
65
        _, err = repo.Exists()
50
 
        c.Assert(err, ErrorMatches, `".*/repo" is not a directory`)
 
66
        c.Assert(err, gc.ErrorMatches, `".*/repo" is not a directory`)
51
67
        err = os.Remove(repo.Path())
52
 
        c.Assert(err, IsNil)
 
68
        c.Assert(err, gc.IsNil)
53
69
 
54
70
        err = os.Chmod(base, 0555)
55
 
        c.Assert(err, IsNil)
 
71
        c.Assert(err, gc.IsNil)
56
72
        defer os.Chmod(base, 0755)
57
73
        err = repo.Init()
58
 
        c.Assert(err, ErrorMatches, ".* permission denied")
 
74
        c.Assert(err, gc.ErrorMatches, ".* permission denied")
59
75
        exists, err = repo.Exists()
60
 
        c.Assert(err, IsNil)
61
 
        c.Assert(exists, Equals, false)
 
76
        c.Assert(err, gc.IsNil)
 
77
        c.Assert(exists, jc.IsFalse)
62
78
 
63
79
        err = os.Chmod(base, 0755)
64
 
        c.Assert(err, IsNil)
 
80
        c.Assert(err, gc.IsNil)
65
81
        err = repo.Init()
66
 
        c.Assert(err, IsNil)
 
82
        c.Assert(err, gc.IsNil)
67
83
        exists, err = repo.Exists()
68
 
        c.Assert(err, IsNil)
69
 
        c.Assert(exists, Equals, true)
 
84
        c.Assert(err, gc.IsNil)
 
85
        c.Assert(exists, jc.IsTrue)
70
86
 
71
87
        _, err = charm.ReadCharmURL(repo)
72
 
        c.Assert(err, checkers.Satisfies, os.IsNotExist)
 
88
        c.Assert(err, jc.Satisfies, os.IsNotExist)
73
89
 
74
90
        err = repo.Init()
75
 
        c.Assert(err, IsNil)
 
91
        c.Assert(err, gc.IsNil)
76
92
}
77
93
 
78
 
func (s *GitDirSuite) TestAddCommitPullRevert(c *C) {
 
94
func (s *GitDirSuite) TestAddCommitPullRevert(c *gc.C) {
79
95
        target := charm.NewGitDir(c.MkDir())
80
96
        err := target.Init()
81
 
        c.Assert(err, IsNil)
 
97
        c.Assert(err, gc.IsNil)
82
98
        err = ioutil.WriteFile(filepath.Join(target.Path(), "initial"), []byte("initial"), 0644)
83
 
        c.Assert(err, IsNil)
 
99
        c.Assert(err, gc.IsNil)
84
100
        err = charm.WriteCharmURL(target, curl)
85
 
        c.Assert(err, IsNil)
 
101
        c.Assert(err, gc.IsNil)
86
102
        err = target.AddAll()
87
 
        c.Assert(err, IsNil)
 
103
        c.Assert(err, gc.IsNil)
88
104
        dirty, err := target.Dirty()
89
 
        c.Assert(err, IsNil)
90
 
        c.Assert(dirty, Equals, true)
 
105
        c.Assert(err, gc.IsNil)
 
106
        c.Assert(dirty, jc.IsTrue)
91
107
        err = target.Commitf("initial")
92
 
        c.Assert(err, IsNil)
 
108
        c.Assert(err, gc.IsNil)
93
109
        dirty, err = target.Dirty()
94
 
        c.Assert(err, IsNil)
95
 
        c.Assert(dirty, Equals, false)
 
110
        c.Assert(err, gc.IsNil)
 
111
        c.Assert(dirty, jc.IsFalse)
96
112
 
97
113
        source := newRepo(c)
98
114
        err = target.Pull(source)
99
 
        c.Assert(err, IsNil)
 
115
        c.Assert(err, gc.IsNil)
100
116
        url, err := charm.ReadCharmURL(target)
101
 
        c.Assert(err, IsNil)
102
 
        c.Assert(url, DeepEquals, curl)
 
117
        c.Assert(err, gc.IsNil)
 
118
        c.Assert(url, gc.DeepEquals, curl)
103
119
        fi, err := os.Stat(filepath.Join(target.Path(), "some-dir"))
104
 
        c.Assert(err, IsNil)
105
 
        c.Assert(fi, checkers.Satisfies, os.FileInfo.IsDir)
 
120
        c.Assert(err, gc.IsNil)
 
121
        c.Assert(fi, jc.Satisfies, os.FileInfo.IsDir)
106
122
        data, err := ioutil.ReadFile(filepath.Join(target.Path(), "some-file"))
107
 
        c.Assert(err, IsNil)
108
 
        c.Assert(string(data), Equals, "hello")
 
123
        c.Assert(err, gc.IsNil)
 
124
        c.Assert(string(data), gc.Equals, "hello")
109
125
        dirty, err = target.Dirty()
110
 
        c.Assert(err, IsNil)
111
 
        c.Assert(dirty, Equals, false)
 
126
        c.Assert(err, gc.IsNil)
 
127
        c.Assert(dirty, jc.IsFalse)
112
128
 
113
129
        err = ioutil.WriteFile(filepath.Join(target.Path(), "another-file"), []byte("blah"), 0644)
114
 
        c.Assert(err, IsNil)
 
130
        c.Assert(err, gc.IsNil)
115
131
        dirty, err = target.Dirty()
116
 
        c.Assert(err, IsNil)
117
 
        c.Assert(dirty, Equals, true)
 
132
        c.Assert(err, gc.IsNil)
 
133
        c.Assert(dirty, jc.IsTrue)
118
134
        err = source.AddAll()
119
 
        c.Assert(err, IsNil)
 
135
        c.Assert(err, gc.IsNil)
120
136
        dirty, err = target.Dirty()
121
 
        c.Assert(err, IsNil)
122
 
        c.Assert(dirty, Equals, true)
 
137
        c.Assert(err, gc.IsNil)
 
138
        c.Assert(dirty, jc.IsTrue)
123
139
 
124
140
        err = target.Revert()
125
 
        c.Assert(err, IsNil)
 
141
        c.Assert(err, gc.IsNil)
126
142
        _, err = os.Stat(filepath.Join(target.Path(), "some-file"))
127
 
        c.Assert(err, checkers.Satisfies, os.IsNotExist)
 
143
        c.Assert(err, jc.Satisfies, os.IsNotExist)
128
144
        _, err = os.Stat(filepath.Join(target.Path(), "some-dir"))
129
 
        c.Assert(err, checkers.Satisfies, os.IsNotExist)
 
145
        c.Assert(err, jc.Satisfies, os.IsNotExist)
130
146
        data, err = ioutil.ReadFile(filepath.Join(target.Path(), "initial"))
131
 
        c.Assert(err, IsNil)
132
 
        c.Assert(string(data), Equals, "initial")
 
147
        c.Assert(err, gc.IsNil)
 
148
        c.Assert(string(data), gc.Equals, "initial")
133
149
        dirty, err = target.Dirty()
134
 
        c.Assert(err, IsNil)
135
 
        c.Assert(dirty, Equals, false)
 
150
        c.Assert(err, gc.IsNil)
 
151
        c.Assert(dirty, jc.IsFalse)
136
152
}
137
153
 
138
 
func (s *GitDirSuite) TestClone(c *C) {
 
154
func (s *GitDirSuite) TestClone(c *gc.C) {
139
155
        repo, err := newRepo(c).Clone(c.MkDir())
140
 
        c.Assert(err, IsNil)
 
156
        c.Assert(err, gc.IsNil)
141
157
        _, err = os.Stat(filepath.Join(repo.Path(), "some-file"))
142
 
        c.Assert(err, checkers.Satisfies, os.IsNotExist)
 
158
        c.Assert(err, jc.Satisfies, os.IsNotExist)
143
159
        _, err = os.Stat(filepath.Join(repo.Path(), "some-dir"))
144
 
        c.Assert(err, checkers.Satisfies, os.IsNotExist)
 
160
        c.Assert(err, jc.Satisfies, os.IsNotExist)
145
161
        dirty, err := repo.Dirty()
146
 
        c.Assert(err, IsNil)
147
 
        c.Assert(dirty, Equals, true)
 
162
        c.Assert(err, gc.IsNil)
 
163
        c.Assert(dirty, jc.IsTrue)
148
164
 
149
165
        err = repo.AddAll()
150
 
        c.Assert(err, IsNil)
 
166
        c.Assert(err, gc.IsNil)
151
167
        dirty, err = repo.Dirty()
152
 
        c.Assert(err, IsNil)
153
 
        c.Assert(dirty, Equals, true)
 
168
        c.Assert(err, gc.IsNil)
 
169
        c.Assert(dirty, jc.IsTrue)
154
170
        err = repo.Commitf("blank overwrite")
155
 
        c.Assert(err, IsNil)
 
171
        c.Assert(err, gc.IsNil)
156
172
        dirty, err = repo.Dirty()
157
 
        c.Assert(err, IsNil)
158
 
        c.Assert(dirty, Equals, false)
 
173
        c.Assert(err, gc.IsNil)
 
174
        c.Assert(dirty, jc.IsFalse)
159
175
 
160
176
        lines, err := repo.Log()
161
 
        c.Assert(err, IsNil)
162
 
        c.Assert(lines, HasLen, 2)
163
 
        c.Assert(lines[0], Matches, "[a-f0-9]{7} blank overwrite")
164
 
        c.Assert(lines[1], Matches, "[a-f0-9]{7} im in ur repo committin ur files")
 
177
        c.Assert(err, gc.IsNil)
 
178
        c.Assert(lines, gc.HasLen, 2)
 
179
        c.Assert(lines[0], gc.Matches, "[a-f0-9]{7} blank overwrite")
 
180
        c.Assert(lines[1], gc.Matches, "[a-f0-9]{7} im in ur repo committin ur files")
165
181
}
166
182
 
167
 
func (s *GitDirSuite) TestConflictRevert(c *C) {
 
183
func (s *GitDirSuite) TestConflictRevert(c *gc.C) {
168
184
        source := newRepo(c)
169
185
        updated, err := source.Clone(c.MkDir())
170
 
        c.Assert(err, IsNil)
 
186
        c.Assert(err, gc.IsNil)
171
187
        err = ioutil.WriteFile(filepath.Join(updated.Path(), "some-dir"), []byte("hello"), 0644)
172
 
        c.Assert(err, IsNil)
 
188
        c.Assert(err, gc.IsNil)
173
189
        err = updated.Snapshotf("potential conflict src")
174
 
        c.Assert(err, IsNil)
 
190
        c.Assert(err, gc.IsNil)
175
191
        conflicted, err := updated.Conflicted()
176
 
        c.Assert(err, IsNil)
177
 
        c.Assert(conflicted, Equals, false)
 
192
        c.Assert(err, gc.IsNil)
 
193
        c.Assert(conflicted, jc.IsFalse)
178
194
 
179
195
        target := charm.NewGitDir(c.MkDir())
180
196
        err = target.Init()
181
 
        c.Assert(err, IsNil)
 
197
        c.Assert(err, gc.IsNil)
182
198
        err = target.Pull(source)
183
 
        c.Assert(err, IsNil)
 
199
        c.Assert(err, gc.IsNil)
184
200
        err = ioutil.WriteFile(filepath.Join(target.Path(), "some-dir", "conflicting-file"), []byte("hello"), 0644)
185
 
        c.Assert(err, IsNil)
 
201
        c.Assert(err, gc.IsNil)
186
202
        err = target.Snapshotf("potential conflict dst")
187
 
        c.Assert(err, IsNil)
 
203
        c.Assert(err, gc.IsNil)
188
204
        conflicted, err = target.Conflicted()
189
 
        c.Assert(err, IsNil)
190
 
        c.Assert(conflicted, Equals, false)
 
205
        c.Assert(err, gc.IsNil)
 
206
        c.Assert(conflicted, jc.IsFalse)
191
207
 
192
208
        err = target.Pull(updated)
193
 
        c.Assert(err, Equals, charm.ErrConflict)
 
209
        c.Assert(err, gc.Equals, charm.ErrConflict)
194
210
        conflicted, err = target.Conflicted()
195
 
        c.Assert(err, IsNil)
196
 
        c.Assert(conflicted, Equals, true)
 
211
        c.Assert(err, gc.IsNil)
 
212
        c.Assert(conflicted, jc.IsTrue)
197
213
        dirty, err := target.Dirty()
198
 
        c.Assert(err, IsNil)
199
 
        c.Assert(dirty, Equals, true)
 
214
        c.Assert(err, gc.IsNil)
 
215
        c.Assert(dirty, jc.IsTrue)
200
216
 
201
217
        err = target.Revert()
202
 
        c.Assert(err, IsNil)
 
218
        c.Assert(err, gc.IsNil)
203
219
        conflicted, err = target.Conflicted()
204
 
        c.Assert(err, IsNil)
205
 
        c.Assert(conflicted, Equals, false)
 
220
        c.Assert(err, gc.IsNil)
 
221
        c.Assert(conflicted, jc.IsFalse)
206
222
        dirty, err = target.Dirty()
207
 
        c.Assert(err, IsNil)
208
 
        c.Assert(dirty, Equals, false)
 
223
        c.Assert(err, gc.IsNil)
 
224
        c.Assert(dirty, jc.IsFalse)
209
225
}
210
226
 
211
 
func newRepo(c *C) *charm.GitDir {
 
227
func newRepo(c *gc.C) *charm.GitDir {
212
228
        repo := charm.NewGitDir(c.MkDir())
213
229
        err := repo.Init()
214
 
        c.Assert(err, IsNil)
 
230
        c.Assert(err, gc.IsNil)
215
231
        err = os.Mkdir(filepath.Join(repo.Path(), "some-dir"), 0755)
216
 
        c.Assert(err, IsNil)
 
232
        c.Assert(err, gc.IsNil)
217
233
        err = ioutil.WriteFile(filepath.Join(repo.Path(), "some-file"), []byte("hello"), 0644)
218
 
        c.Assert(err, IsNil)
 
234
        c.Assert(err, gc.IsNil)
219
235
        err = repo.AddAll()
220
 
        c.Assert(err, IsNil)
 
236
        c.Assert(err, gc.IsNil)
221
237
        err = repo.Commitf("im in ur repo committin ur %s", "files")
222
 
        c.Assert(err, IsNil)
 
238
        c.Assert(err, gc.IsNil)
223
239
        return repo
224
240
}