← Back to branch summary

~mvo/snappy/lp1480248-test-reenable

« back to all changes in this revision

Viewing changes to _integration-tests/testutils/build/build_test.go

  • Committer: Michael Vogt
  • Date: 2015-10-16 16:51:10 UTC
  • mfrom: (640.2.136 snappy)
  • Revision ID: michael.vogt@ubuntu.com-20151016165110-djpd75rc5m0roe7c
merged lp:snappy

Show diffs side-by-side

added added

removed removed

Lines of Context:
_integration-tests/testutils/build/build_test.go
34
34
type BuildSuite struct {
35
35
        execCalls        map[string]int
36
36
        execReturnValues []string
37
 
        execReturnIndex  int
38
37
        backExecCommand  func(...string) error
39
38
 
40
39
        mkDirCalls           map[string]int
51
50
 
52
51
        useSnappyFromBranch bool
53
52
        arch                string
 
53
 
 
54
        environ map[string]string
54
55
}
55
56
 
56
57
var _ = check.Suite(&BuildSuite{})
83
84
        s.osRenameCalls = make(map[string]int)
84
85
        s.osSetenvCalls = make(map[string]int)
85
86
        s.osGetenvCalls = make(map[string]int)
 
87
        s.environ = make(map[string]string)
86
88
}
87
89
 
88
90
func (s *BuildSuite) fakeExecCommand(args ...string) (err error) {
101
103
 
102
104
func (s *BuildSuite) fakeOsSetenv(key, value string) (err error) {
103
105
        s.osSetenvCalls[key+" "+value]++
 
106
        s.environ[key] = value
104
107
        return
105
108
}
106
109
 
107
110
func (s *BuildSuite) fakeOsGetenv(key string) (value string) {
108
111
        s.osGetenvCalls[key]++
109
 
        return
 
112
        return s.environ[key]
110
113
}
111
114
 
112
115
func (s *BuildSuite) TestAssetsCallsPrepareDir(c *check.C) {
143
146
 
144
147
func (s *BuildSuite) TestAssetsSetsEnvironmentForGenericArch(c *check.C) {
145
148
        arch := "myarch"
146
 
        // needed for go1.5
147
 
        os.Setenv("GOARCH", arch)
 
149
        originalArch := "originalArch"
 
150
        s.environ["GOARCH"] = originalArch
148
151
        Assets(s.useSnappyFromBranch, arch)
149
152
 
150
153
        setenvGOARCHFirstCall := s.osSetenvCalls["GOARCH "+arch]
151
 
        setenvGOARCHFinalCall := s.osSetenvCalls["GOARCH "+os.Getenv("GOARCH")]
 
154
        setenvGOARCHFinalCall := s.osSetenvCalls["GOARCH "+originalArch]
152
155
 
153
156
        c.Assert(setenvGOARCHFirstCall, check.Equals, 1,
154
157
                check.Commentf("Expected 1 call to os.Setenv with %s, got %d",
155
158
                        "GOARCH "+arch, setenvGOARCHFirstCall))
156
159
        c.Assert(setenvGOARCHFinalCall, check.Equals, 1,
157
160
                check.Commentf("Expected 1 call to os.Setenv with %s, got %d",
158
 
                        "GOARCH "+os.Getenv("GOARCH"), setenvGOARCHFinalCall))
 
161
                        "GOARCH "+originalArch, setenvGOARCHFinalCall))
 
162
}
 
163
 
 
164
var armEnvironmentTests = []struct {
 
165
        envVar string
 
166
        value  string
 
167
}{
 
168
        {"GOARM", defaultGoArm},
 
169
        {"CGO_ENABLED", "1"},
 
170
        {"CC", "arm-linux-gnueabihf-gcc"},
159
171
}
160
172
 
161
173
func (s *BuildSuite) TestAssetsSetsEnvironmentForArm(c *check.C) {
162
174
        arch := "arm"
 
175
        for _, t := range armEnvironmentTests {
 
176
                s.environ[t.envVar] = "original" + t.envVar
 
177
        }
163
178
        Assets(s.useSnappyFromBranch, arch)
164
179
 
165
 
        setenvGOARMFirstCall := s.osSetenvCalls["GOARM "+defaultGoArm]
166
 
        setenvGOARMFinalCall := s.osSetenvCalls["GOARM "+os.Getenv("GOARM")]
 
180
        for _, t := range armEnvironmentTests {
 
181
                firstCall := fmt.Sprintf("%s %s", t.envVar, t.value)
 
182
                setenvFirstCall := s.osSetenvCalls[firstCall]
 
183
                finalCall := fmt.Sprintf("%s %s", t.envVar, "original"+t.envVar)
 
184
                setenvFinalCall := s.osSetenvCalls[finalCall]
167
185
 
168
 
        c.Assert(setenvGOARMFirstCall, check.Equals, 1,
169
 
                check.Commentf("Expected 1 call to os.Setenv with %s, got %d",
170
 
                        "GOARM "+defaultGoArm, setenvGOARMFirstCall))
171
 
        c.Assert(setenvGOARMFinalCall, check.Equals, 1,
172
 
                check.Commentf("Expected 1 call to os.Setenv with %s, got %d",
173
 
                        "GOARM "+os.Getenv("GOARCH"), setenvGOARMFinalCall))
 
186
                c.Assert(setenvFirstCall, check.Equals, 1,
 
187
                        check.Commentf("Expected 1 call to os.Setenv with %s, got %d",
 
188
                                firstCall, setenvFirstCall))
 
189
                c.Assert(setenvFinalCall, check.Equals, 1,
 
190
                        check.Commentf("Expected 1 call to os.Setenv with %s, got %d",
 
191
                                finalCall, setenvFinalCall))
 
192
        }
174
193
}
175
194
 
176
195
func (s *BuildSuite) TestAssetsDoesNotSetEnvironmentForEmptyArch(c *check.C) {
202
221
                        "GOARM "+os.Getenv("GOARCH"), setenvGOARMFinalCall))
203
222
}
204
223
 
205
 
func (s *BuildSuite) TestAssetsBuildsSnappyFromBranch(c *check.C) {
206
 
        buildSnappyFromBranch := true
207
 
        Assets(buildSnappyFromBranch, s.arch)
208
 
 
209
 
        buildCall := s.execCalls[buildSnappyCmd]
210
 
 
211
 
        c.Assert(buildCall, check.Equals, 1,
212
 
                check.Commentf("Expected 1 call to execCommand with %s, got %d",
213
 
                        buildSnappyCmd, buildCall))
214
 
}
215
 
 
216
 
func (s *BuildSuite) TestAssetsDoesNotBuildSnappyFromBranchIfNotInstructedTo(c *check.C) {
217
 
        Assets(s.useSnappyFromBranch, s.arch)
218
 
 
219
 
        buildCall := s.execCalls[buildSnappyCmd]
220
 
 
221
 
        c.Assert(buildCall, check.Equals, 0,
222
 
                check.Commentf("Expected 0 call to execCommand with %s, got %d",
223
 
                        buildSnappyCmd, buildCall))
 
224
func (s *BuildSuite) TestAssetsBuildsSnappyCliFromBranch(c *check.C) {
 
225
        buildSnappyFromBranch := true
 
226
        Assets(buildSnappyFromBranch, s.arch)
 
227
 
 
228
        buildCall := s.execCalls[buildSnappyCliCmd]
 
229
 
 
230
        c.Assert(buildCall, check.Equals, 1,
 
231
                check.Commentf("Expected 1 call to execCommand with %s, got %d",
 
232
                        buildSnappyCliCmd, buildCall))
 
233
}
 
234
 
 
235
func (s *BuildSuite) TestAssetsDoesNotBuildSnappyCliFromBranchIfNotInstructedTo(c *check.C) {
 
236
        Assets(s.useSnappyFromBranch, s.arch)
 
237
 
 
238
        buildCall := s.execCalls[buildSnappyCliCmd]
 
239
 
 
240
        c.Assert(buildCall, check.Equals, 0,
 
241
                check.Commentf("Expected 0 call to execCommand with %s, got %d",
 
242
                        buildSnappyCliCmd, buildCall))
 
243
}
 
244
 
 
245
func (s *BuildSuite) TestAssetsBuildsSnapdFromBranch(c *check.C) {
 
246
        buildSnappyFromBranch := true
 
247
        Assets(buildSnappyFromBranch, s.arch)
 
248
 
 
249
        buildCall := s.execCalls[buildSnapdCmd]
 
250
 
 
251
        c.Assert(buildCall, check.Equals, 1,
 
252
                check.Commentf("Expected 1 call to execCommand with %s, got %d",
 
253
                        buildSnapdCmd, buildCall))
 
254
}
 
255
 
 
256
func (s *BuildSuite) TestAssetsDoesNotBuildSnapdFromBranchIfNotInstructedTo(c *check.C) {
 
257
        Assets(s.useSnappyFromBranch, s.arch)
 
258
 
 
259
        buildCall := s.execCalls[buildSnapdCmd]
 
260
 
 
261
        c.Assert(buildCall, check.Equals, 0,
 
262
                check.Commentf("Expected 0 call to execCommand with %s, got %d",
 
263
                        buildSnapdCmd, buildCall))
224
264
}