← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/gopkg.in/juju/charmrepo.v2-unstable/csclient/csclient_resources_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/gopkg.in/juju/charmrepo.v2-unstable/csclient/csclient_resources_test.go
 
1
// Copyright 2016 Canonical Ltd.
 
2
// Licensed under the LGPLv3, see LICENCE file for details.
 
3
 
 
4
package csclient
 
5
 
 
6
import (
 
7
        "bytes"
 
8
        "encoding/json"
 
9
        "io"
 
10
        "io/ioutil"
 
11
        "net/http"
 
12
        "strings"
 
13
 
 
14
        "github.com/juju/testing"
 
15
        jc "github.com/juju/testing/checkers"
 
16
        gc "gopkg.in/check.v1"
 
17
        "gopkg.in/juju/charm.v6-unstable"
 
18
        "gopkg.in/juju/charm.v6-unstable/resource"
 
19
 
 
20
        "gopkg.in/juju/charmrepo.v2-unstable/csclient/params"
 
21
)
 
22
 
 
23
type ResourceSuite struct{}
 
24
 
 
25
var _ = gc.Suite(ResourceSuite{})
 
26
 
 
27
func (ResourceSuite) TestListResources(c *gc.C) {
 
28
        data := "somedata"
 
29
        fp, err := resource.GenerateFingerprint(strings.NewReader(data))
 
30
        c.Assert(err, jc.ErrorIsNil)
 
31
 
 
32
        results := map[string][]params.Resource{
 
33
                "cs:quantal/starsay": []params.Resource{
 
34
                        {
 
35
                                Name:        "data",
 
36
                                Type:        "file",
 
37
                                Origin:      "store",
 
38
                                Path:        "data.zip",
 
39
                                Description: "some zip file",
 
40
                                Revision:    1,
 
41
                                Fingerprint: fp.Bytes(),
 
42
                                Size:        int64(len(data)),
 
43
                        },
 
44
                },
 
45
        }
 
46
 
 
47
        b, err := json.Marshal(results)
 
48
        c.Assert(err, jc.ErrorIsNil)
 
49
 
 
50
        f := &fakeClient{
 
51
                Stub: &testing.Stub{},
 
52
                ReturnDoWithBody: &http.Response{
 
53
                        StatusCode: 200,
 
54
                        Body:       ioutil.NopCloser(bytes.NewReader(b)),
 
55
                },
 
56
        }
 
57
 
 
58
        client := Client{bclient: f}
 
59
        url := charm.MustParseURL("cs:quantal/starsay")
 
60
        ret, err := client.ListResources([]*charm.URL{url})
 
61
        c.Assert(err, jc.ErrorIsNil)
 
62
        c.Assert(ret, gc.DeepEquals, results)
 
63
}
 
64
 
 
65
func (ResourceSuite) TestUploadResource(c *gc.C) {
 
66
        data := []byte("boo!")
 
67
        reader := bytes.NewReader(data)
 
68
 
 
69
        result := params.ResourceUploadResponse{Revision: 1}
 
70
        b, err := json.Marshal(result)
 
71
        c.Assert(err, jc.ErrorIsNil)
 
72
 
 
73
        f := &fakeClient{
 
74
                Stub: &testing.Stub{},
 
75
                ReturnDoWithBody: &http.Response{
 
76
                        StatusCode:    200,
 
77
                        Body:          ioutil.NopCloser(bytes.NewReader(b)),
 
78
                        ContentLength: int64(len(b)),
 
79
                },
 
80
        }
 
81
 
 
82
        client := Client{bclient: f}
 
83
        id := charm.MustParseURL("cs:quantal/starsay")
 
84
        rev, err := client.UploadResource(id, "resname", "data.zip", reader)
 
85
        c.Assert(err, jc.ErrorIsNil)
 
86
        c.Assert(rev, gc.Equals, 1)
 
87
        f.CheckCallNames(c, "DoWithBody")
 
88
        req := f.Calls()[0].Args[0].(*http.Request)
 
89
        body := f.Calls()[0].Args[1].(io.ReadSeeker)
 
90
 
 
91
        hash, size, err := readerHashAndSize(reader)
 
92
        c.Assert(err, jc.ErrorIsNil)
 
93
 
 
94
        c.Assert(req.URL.String(), gc.Equals, "/v5/quantal/starsay/resources/resname?hash="+hash+"&filename=data.zip")
 
95
        c.Assert(req.ContentLength, gc.Equals, size)
 
96
        c.Assert(body, gc.DeepEquals, reader)
 
97
}
 
98
 
 
99
func (ResourceSuite) TestGetResource(c *gc.C) {
 
100
        data := []byte("boo!")
 
101
        fp, err := resource.GenerateFingerprint(bytes.NewReader(data))
 
102
        c.Assert(err, jc.ErrorIsNil)
 
103
        body := ioutil.NopCloser(bytes.NewReader(data))
 
104
 
 
105
        resp := &http.Response{
 
106
                StatusCode: 200,
 
107
                Body:       body,
 
108
                Header: http.Header{
 
109
                        params.ResourceRevisionHeader: []string{"1"},
 
110
                        params.ContentHashHeader:      []string{fp.String()},
 
111
                },
 
112
                ContentLength: int64(len(data)),
 
113
        }
 
114
 
 
115
        f := &fakeClient{
 
116
                Stub:             &testing.Stub{},
 
117
                ReturnDoWithBody: resp,
 
118
        }
 
119
 
 
120
        client := Client{bclient: f}
 
121
        id := charm.MustParseURL("cs:quantal/starsay")
 
122
        resdata, err := client.GetResource(id, 1, "data")
 
123
        c.Assert(err, jc.ErrorIsNil)
 
124
        c.Check(resdata, gc.DeepEquals, ResourceData{
 
125
                ReadCloser: body,
 
126
                Revision:   1,
 
127
                Hash:       fp.String(),
 
128
                Size:       int64(len(data)),
 
129
        })
 
130
}
 
131
 
 
132
type fakeClient struct {
 
133
        *testing.Stub
 
134
        ReturnDoWithBody *http.Response
 
135
}
 
136
 
 
137
func (f *fakeClient) DoWithBody(req *http.Request, r io.ReadSeeker) (*http.Response, error) {
 
138
        f.AddCall("DoWithBody", req, r)
 
139
        return f.ReturnDoWithBody, f.NextErr()
 
140
}