← Back to branch summary

~juju-qa/ubuntu/xenial/juju/xenial-2.0-beta3

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/resource/api/client/client_upload_test.go

  • Committer: Martin Packman
  • Date: 2016-03-30 19:31:08 UTC
  • mfrom: (1.1.41)
  • Revision ID: martin.packman@canonical.com-20160330193108-h9iz3ak334uk0z5r
Merge new upstream source 2.0~beta3

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/resource/api/client/client_upload_test.go
14
14
        jc "github.com/juju/testing/checkers"
15
15
        "github.com/juju/utils"
16
16
        gc "gopkg.in/check.v1"
 
17
        "gopkg.in/juju/charm.v6-unstable"
17
18
        charmresource "gopkg.in/juju/charm.v6-unstable/resource"
18
19
 
19
20
        "github.com/juju/juju/resource/api/client"
27
28
 
28
29
func (s *UploadSuite) TestOkay(c *gc.C) {
29
30
        data := "<data>"
 
31
        reader := &stubFile{stub: s.stub}
 
32
        reader.returnRead = strings.NewReader(data)
 
33
        cl := client.NewClient(s.facade, s, s.facade)
 
34
 
30
35
        _, s.response.Resource = newResource(c, "spam", "a-user", data)
 
36
 
 
37
        err := cl.Upload("a-service", "spam", "foo.zip", reader)
 
38
        c.Assert(err, jc.ErrorIsNil)
 
39
 
31
40
        fp, err := charmresource.GenerateFingerprint(strings.NewReader(data))
32
41
        c.Assert(err, jc.ErrorIsNil)
33
42
        req, err := http.NewRequest("PUT", "/services/a-service/resources/spam", nil)
35
44
        req.Header.Set("Content-Type", "application/octet-stream")
36
45
        req.Header.Set("Content-SHA384", fp.String())
37
46
        req.Header.Set("Content-Length", fmt.Sprint(len(data)))
 
47
        req.Header.Set("Content-Disposition", "form-data; filename=foo.zip")
38
48
        req.ContentLength = int64(len(data))
39
 
        reader := &stubFile{stub: s.stub}
40
 
        reader.returnRead = strings.NewReader(data)
41
 
        cl := client.NewClient(s.facade, s, s.facade)
42
 
 
43
 
        err = cl.Upload("a-service", "spam", reader)
44
 
        c.Assert(err, jc.ErrorIsNil)
45
49
 
46
50
        s.stub.CheckCallNames(c, "Read", "Read", "Seek", "Do")
47
51
        s.stub.CheckCall(c, 3, "Do", req, reader, s.response)
50
54
func (s *UploadSuite) TestBadService(c *gc.C) {
51
55
        cl := client.NewClient(s.facade, s, s.facade)
52
56
 
53
 
        err := cl.Upload("???", "spam", nil)
 
57
        err := cl.Upload("???", "spam", "file.zip", nil)
54
58
 
55
59
        c.Check(err, gc.ErrorMatches, `.*invalid service.*`)
56
60
        s.stub.CheckNoCalls(c)
62
66
        failure := errors.New("<failure>")
63
67
        s.stub.SetErrors(failure)
64
68
 
65
 
        err := cl.Upload("a-service", "spam", reader)
 
69
        err := cl.Upload("a-service", "spam", "file.zip", reader)
66
70
 
67
71
        c.Check(errors.Cause(err), gc.Equals, failure)
68
72
        s.stub.CheckCallNames(c, "Read")
75
79
        failure := errors.New("<failure>")
76
80
        s.stub.SetErrors(nil, nil, nil, failure)
77
81
 
78
 
        err := cl.Upload("a-service", "spam", reader)
 
82
        err := cl.Upload("a-service", "spam", "file.zip", reader)
79
83
 
80
84
        c.Check(errors.Cause(err), gc.Equals, failure)
81
85
        s.stub.CheckCallNames(c, "Read", "Read", "Seek", "Do")
82
86
}
83
87
 
84
 
func (s *UploadSuite) TestPendingOkay(c *gc.C) {
 
88
func (s *UploadSuite) TestPendingResources(c *gc.C) {
 
89
        res, apiResult := newResourceResult(c, "a-service", "spam")
 
90
        resources := []charmresource.Resource{res[0].Resource}
 
91
        uuid, err := utils.NewUUID()
 
92
        c.Assert(err, jc.ErrorIsNil)
 
93
        expected := []string{uuid.String()}
 
94
        s.response.Resource = apiResult.Resources[0]
 
95
        s.facade.pendingIDs = expected
 
96
        cURL := charm.MustParseURL("cs:~a-user/trusty/spam-5")
 
97
        cl := client.NewClient(s.facade, s, s.facade)
 
98
 
 
99
        pendingIDs, err := cl.AddPendingResources(client.AddPendingResourcesArgs{
 
100
                ServiceID: "a-service",
 
101
                CharmURL:  cURL,
 
102
                Resources: resources,
 
103
        })
 
104
        c.Assert(err, jc.ErrorIsNil)
 
105
 
 
106
        s.stub.CheckCallNames(c, "FacadeCall")
 
107
        //s.stub.CheckCall(c, 0, "FacadeCall", "AddPendingResources", args, result)
 
108
        c.Check(pendingIDs, jc.DeepEquals, expected)
 
109
}
 
110
 
 
111
func (s *UploadSuite) TestPendingResourceOkay(c *gc.C) {
85
112
        res, apiResult := newResourceResult(c, "a-service", "spam")
86
113
        uuid, err := utils.NewUUID()
87
114
        c.Assert(err, jc.ErrorIsNil)
88
115
        expected := uuid.String()
89
116
        s.response.Resource = apiResult.Resources[0]
90
117
        data := "<data>"
 
118
        reader := &stubFile{stub: s.stub}
 
119
        reader.returnRead = strings.NewReader(data)
 
120
        s.facade.pendingIDs = []string{expected}
 
121
        cl := client.NewClient(s.facade, s, s.facade)
 
122
 
 
123
        uploadID, err := cl.AddPendingResource("a-service", res[0].Resource, "file.zip", reader)
 
124
        c.Assert(err, jc.ErrorIsNil)
 
125
 
 
126
        s.stub.CheckCallNames(c,
 
127
                "FacadeCall",
 
128
                "Read",
 
129
                "Read",
 
130
                "Seek",
 
131
                "Do",
 
132
        )
 
133
 
91
134
        fp, err := charmresource.GenerateFingerprint(strings.NewReader(data))
92
135
        c.Assert(err, jc.ErrorIsNil)
93
136
        req, err := http.NewRequest("PUT", "/services/a-service/resources/spam", nil)
97
140
        req.Header.Set("Content-Length", fmt.Sprint(len(data)))
98
141
        req.ContentLength = int64(len(data))
99
142
        req.URL.RawQuery = "pendingid=" + expected
100
 
        reader := &stubFile{stub: s.stub}
101
 
        reader.returnRead = strings.NewReader(data)
102
 
        s.facade.pendingIDs = []string{expected}
103
 
        cl := client.NewClient(s.facade, s, s.facade)
104
 
 
105
 
        uploadID, err := cl.AddPendingResource("a-service", res[0].Resource, reader)
106
 
        c.Assert(err, jc.ErrorIsNil)
107
 
 
108
 
        s.stub.CheckCallNames(c,
109
 
                "FacadeCall",
110
 
                "Read",
111
 
                "Read",
112
 
                "Seek",
113
 
                "Do",
114
 
        )
 
143
        req.Header.Set("Content-Disposition", "form-data; filename=file.zip")
 
144
 
115
145
        s.stub.CheckCall(c, 4, "Do", req, reader, s.response)
116
146
        c.Check(uploadID, gc.Equals, expected)
117
147
}
118
148
 
119
 
func (s *UploadSuite) TestPendingNoFile(c *gc.C) {
 
149
func (s *UploadSuite) TestPendingResourceNoFile(c *gc.C) {
120
150
        res, apiResult := newResourceResult(c, "a-service", "spam")
121
151
        uuid, err := utils.NewUUID()
122
152
        c.Assert(err, jc.ErrorIsNil)
125
155
        s.facade.pendingIDs = []string{expected}
126
156
        cl := client.NewClient(s.facade, s, s.facade)
127
157
 
128
 
        uploadID, err := cl.AddPendingResource("a-service", res[0].Resource, nil)
 
158
        uploadID, err := cl.AddPendingResource("a-service", res[0].Resource, "file.zip", nil)
129
159
        c.Assert(err, jc.ErrorIsNil)
130
160
 
131
161
        s.stub.CheckCallNames(c,
134
164
        c.Check(uploadID, gc.Equals, expected)
135
165
}
136
166
 
137
 
func (s *UploadSuite) TestPendingBadService(c *gc.C) {
 
167
func (s *UploadSuite) TestPendingResourceBadService(c *gc.C) {
138
168
        res, _ := newResourceResult(c, "a-service", "spam")
139
169
        s.facade.FacadeCallFn = nil
140
170
        cl := client.NewClient(s.facade, s, s.facade)
141
171
 
142
 
        _, err := cl.AddPendingResource("???", res[0].Resource, nil)
 
172
        _, err := cl.AddPendingResource("???", res[0].Resource, "file.zip", nil)
143
173
 
144
174
        c.Check(err, gc.ErrorMatches, `.*invalid service.*`)
145
175
        s.stub.CheckNoCalls(c)
146
176
}
147
177
 
148
 
func (s *UploadSuite) TestPendingBadRequest(c *gc.C) {
 
178
func (s *UploadSuite) TestPendingResourceBadRequest(c *gc.C) {
149
179
        res, _ := newResource(c, "spam", "", "")
150
180
        chRes := res.Resource
151
181
        reader := &stubFile{stub: s.stub}
154
184
        failure := errors.New("<failure>")
155
185
        s.stub.SetErrors(nil, failure)
156
186
 
157
 
        _, err := cl.AddPendingResource("a-service", chRes, reader)
 
187
        _, err := cl.AddPendingResource("a-service", chRes, "file.zip", reader)
158
188
 
159
189
        c.Check(errors.Cause(err), gc.Equals, failure)
160
190
        s.stub.CheckCallNames(c, "FacadeCall", "Read")
161
191
}
162
192
 
163
 
func (s *UploadSuite) TestPendingRequestFailed(c *gc.C) {
 
193
func (s *UploadSuite) TestPendingResourceRequestFailed(c *gc.C) {
164
194
        res, _ := newResourceResult(c, "a-service", "spam")
165
195
        reader := &stubFile{stub: s.stub}
166
196
        reader.returnRead = strings.NewReader("<data>")
169
199
        failure := errors.New("<failure>")
170
200
        s.stub.SetErrors(nil, nil, nil, nil, failure)
171
201
 
172
 
        _, err := cl.AddPendingResource("a-service", res[0].Resource, reader)
 
202
        _, err := cl.AddPendingResource("a-service", res[0].Resource, "file.zip", reader)
173
203
 
174
204
        c.Check(errors.Cause(err), gc.Equals, failure)
175
205
        s.stub.CheckCallNames(c,