← Back to branch summary

~juju-qa/ubuntu/yakkety/juju/juju-1.25.8

« back to all changes in this revision

Viewing changes to src/gopkg.in/amz.v3/exp/sdb/sdb_test.go

  • Committer: Nicholas Skaggs
  • Date: 2016-12-02 17:28:37 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161202172837-jkrbdlyjcxtrii2n
Initial commit of 1.25.6

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gopkg.in/amz.v3/exp/sdb/sdb_test.go
 
1
package sdb_test
 
2
 
 
3
import (
 
4
        "testing"
 
5
 
 
6
        . "gopkg.in/check.v1"
 
7
 
 
8
        "gopkg.in/amz.v3/aws"
 
9
        "gopkg.in/amz.v3/exp/sdb"
 
10
        "gopkg.in/amz.v3/testutil"
 
11
)
 
12
 
 
13
func Test(t *testing.T) {
 
14
        TestingT(t)
 
15
}
 
16
 
 
17
var _ = Suite(&S{})
 
18
 
 
19
type S struct {
 
20
        sdb *sdb.SDB
 
21
}
 
22
 
 
23
var testServer = testutil.NewHTTPServer()
 
24
 
 
25
func (s *S) SetUpSuite(c *C) {
 
26
        testServer.Start()
 
27
        auth := aws.Auth{"abc", "123"}
 
28
        s.sdb = sdb.New(auth, aws.Region{SDBEndpoint: testServer.URL})
 
29
}
 
30
 
 
31
func (s *S) TearDownSuite(c *C) {
 
32
        testServer.Stop()
 
33
}
 
34
 
 
35
func (s *S) TearDownTest(c *C) {
 
36
        testServer.Flush()
 
37
}
 
38
 
 
39
func (s *S) TestCreateDomainOK(c *C) {
 
40
        testServer.Response(200, nil, TestCreateDomainXmlOK)
 
41
 
 
42
        domain := s.sdb.Domain("domain")
 
43
        resp, err := domain.CreateDomain()
 
44
        req := testServer.WaitRequest()
 
45
 
 
46
        c.Assert(req.Method, Equals, "GET")
 
47
        c.Assert(req.URL.Path, Equals, "/")
 
48
        c.Assert(req.Header["Date"], Not(Equals), "")
 
49
 
 
50
        c.Assert(resp.ResponseMetadata.RequestId, Equals, "63264005-7a5f-e01a-a224-395c63b89f6d")
 
51
        c.Assert(resp.ResponseMetadata.BoxUsage, Equals, 0.0055590279)
 
52
 
 
53
        c.Assert(err, IsNil)
 
54
}
 
55
 
 
56
func (s *S) TestListDomainsOK(c *C) {
 
57
        testServer.Response(200, nil, TestListDomainsXmlOK)
 
58
 
 
59
        resp, err := s.sdb.ListDomains()
 
60
        req := testServer.WaitRequest()
 
61
 
 
62
        c.Assert(req.Method, Equals, "GET")
 
63
        c.Assert(req.URL.Path, Equals, "/")
 
64
        c.Assert(req.Header["Date"], Not(Equals), "")
 
65
 
 
66
        c.Assert(resp.ResponseMetadata.RequestId, Equals, "15fcaf55-9914-63c2-21f3-951e31193790")
 
67
        c.Assert(resp.ResponseMetadata.BoxUsage, Equals, 0.0000071759)
 
68
        c.Assert(resp.Domains, DeepEquals, []string{"Account", "Domain", "Record"})
 
69
 
 
70
        c.Assert(err, IsNil)
 
71
}
 
72
 
 
73
func (s *S) TestListDomainsWithNextTokenXmlOK(c *C) {
 
74
        testServer.Response(200, nil, TestListDomainsWithNextTokenXmlOK)
 
75
 
 
76
        resp, err := s.sdb.ListDomains()
 
77
        req := testServer.WaitRequest()
 
78
 
 
79
        c.Assert(req.Method, Equals, "GET")
 
80
        c.Assert(req.URL.Path, Equals, "/")
 
81
        c.Assert(req.Header["Date"], Not(Equals), "")
 
82
 
 
83
        c.Assert(resp.ResponseMetadata.RequestId, Equals, "eb13162f-1b95-4511-8b12-489b86acfd28")
 
84
        c.Assert(resp.ResponseMetadata.BoxUsage, Equals, 0.0000219907)
 
85
        c.Assert(resp.Domains, DeepEquals, []string{"Domain1-200706011651", "Domain2-200706011652"})
 
86
        c.Assert(resp.NextToken, Equals, "TWV0ZXJpbmdUZXN0RG9tYWluMS0yMDA3MDYwMTE2NTY=")
 
87
 
 
88
        c.Assert(err, IsNil)
 
89
}
 
90
 
 
91
func (s *S) TestDeleteDomainOK(c *C) {
 
92
        testServer.Response(200, nil, TestDeleteDomainXmlOK)
 
93
 
 
94
        domain := s.sdb.Domain("domain")
 
95
        resp, err := domain.DeleteDomain()
 
96
        req := testServer.WaitRequest()
 
97
 
 
98
        c.Assert(req.Method, Equals, "GET")
 
99
        c.Assert(req.URL.Path, Equals, "/")
 
100
        c.Assert(req.Header["Date"], Not(Equals), "")
 
101
 
 
102
        c.Assert(resp.ResponseMetadata.RequestId, Equals, "039e1e25-9a64-2a74-93da-2fda36122a97")
 
103
        c.Assert(resp.ResponseMetadata.BoxUsage, Equals, 0.0055590278)
 
104
 
 
105
        c.Assert(err, IsNil)
 
106
}
 
107
 
 
108
func (s *S) TestPutAttrsOK(c *C) {
 
109
        testServer.Response(200, nil, TestPutAttrsXmlOK)
 
110
 
 
111
        domain := s.sdb.Domain("MyDomain")
 
112
        item := domain.Item("Item123")
 
113
 
 
114
        putAttrs := new(sdb.PutAttrs)
 
115
        putAttrs.Add("FirstName", "john")
 
116
        putAttrs.Add("LastName", "smith")
 
117
        putAttrs.Replace("MiddleName", "jacob")
 
118
 
 
119
        putAttrs.IfValue("FirstName", "john")
 
120
        putAttrs.IfMissing("FirstName")
 
121
 
 
122
        resp, err := item.PutAttrs(putAttrs)
 
123
        req := testServer.WaitRequest()
 
124
        c.Assert(req.Method, Equals, "GET")
 
125
        c.Assert(req.URL.Path, Equals, "/")
 
126
        c.Assert(req.Form["Action"], DeepEquals, []string{"PutAttributes"})
 
127
        c.Assert(req.Form["ItemName"], DeepEquals, []string{"Item123"})
 
128
        c.Assert(req.Form["DomainName"], DeepEquals, []string{"MyDomain"})
 
129
        c.Assert(req.Form["Attribute.1.Name"], DeepEquals, []string{"FirstName"})
 
130
        c.Assert(req.Form["Attribute.1.Value"], DeepEquals, []string{"john"})
 
131
        c.Assert(req.Form["Attribute.2.Name"], DeepEquals, []string{"LastName"})
 
132
        c.Assert(req.Form["Attribute.2.Value"], DeepEquals, []string{"smith"})
 
133
        c.Assert(req.Form["Attribute.3.Name"], DeepEquals, []string{"MiddleName"})
 
134
        c.Assert(req.Form["Attribute.3.Value"], DeepEquals, []string{"jacob"})
 
135
        c.Assert(req.Form["Attribute.3.Replace"], DeepEquals, []string{"true"})
 
136
 
 
137
        c.Assert(req.Form["Expected.1.Name"], DeepEquals, []string{"FirstName"})
 
138
        c.Assert(req.Form["Expected.1.Value"], DeepEquals, []string{"john"})
 
139
        c.Assert(req.Form["Expected.1.Exists"], DeepEquals, []string{"false"})
 
140
 
 
141
        c.Assert(err, IsNil)
 
142
        c.Assert(resp.ResponseMetadata.RequestId, Equals, "490206ce-8292-456c-a00f-61b335eb202b")
 
143
        c.Assert(resp.ResponseMetadata.BoxUsage, Equals, 0.0000219907)
 
144
 
 
145
}
 
146
 
 
147
func (s *S) TestAttrsOK(c *C) {
 
148
        testServer.Response(200, nil, TestAttrsXmlOK)
 
149
 
 
150
        domain := s.sdb.Domain("MyDomain")
 
151
        item := domain.Item("Item123")
 
152
 
 
153
        resp, err := item.Attrs(nil, true)
 
154
        req := testServer.WaitRequest()
 
155
 
 
156
        c.Assert(req.Method, Equals, "GET")
 
157
        c.Assert(req.URL.Path, Equals, "/")
 
158
        c.Assert(req.Header["Date"], Not(Equals), "")
 
159
        c.Assert(req.Form["Action"], DeepEquals, []string{"GetAttributes"})
 
160
        c.Assert(req.Form["ItemName"], DeepEquals, []string{"Item123"})
 
161
        c.Assert(req.Form["DomainName"], DeepEquals, []string{"MyDomain"})
 
162
        c.Assert(req.Form["ConsistentRead"], DeepEquals, []string{"true"})
 
163
 
 
164
        c.Assert(resp.Attrs[0].Name, Equals, "Color")
 
165
        c.Assert(resp.Attrs[0].Value, Equals, "Blue")
 
166
        c.Assert(resp.Attrs[1].Name, Equals, "Size")
 
167
        c.Assert(resp.Attrs[1].Value, Equals, "Med")
 
168
        c.Assert(resp.ResponseMetadata.RequestId, Equals, "b1e8f1f7-42e9-494c-ad09-2674e557526d")
 
169
        c.Assert(resp.ResponseMetadata.BoxUsage, Equals, 0.0000219942)
 
170
 
 
171
        c.Assert(err, IsNil)
 
172
}
 
173
 
 
174
func (s *S) TestAttrsSelectOK(c *C) {
 
175
        testServer.Response(200, nil, TestAttrsXmlOK)
 
176
 
 
177
        domain := s.sdb.Domain("MyDomain")
 
178
        item := domain.Item("Item123")
 
179
 
 
180
        resp, err := item.Attrs([]string{"Color", "Size"}, true)
 
181
        req := testServer.WaitRequest()
 
182
 
 
183
        c.Assert(req.Method, Equals, "GET")
 
184
        c.Assert(req.URL.Path, Equals, "/")
 
185
        c.Assert(req.Header["Date"], Not(Equals), "")
 
186
        c.Assert(req.Form["Action"], DeepEquals, []string{"GetAttributes"})
 
187
        c.Assert(req.Form["ItemName"], DeepEquals, []string{"Item123"})
 
188
        c.Assert(req.Form["DomainName"], DeepEquals, []string{"MyDomain"})
 
189
        c.Assert(req.Form["ConsistentRead"], DeepEquals, []string{"true"})
 
190
        c.Assert(req.Form["AttributeName.1"], DeepEquals, []string{"Color"})
 
191
        c.Assert(req.Form["AttributeName.2"], DeepEquals, []string{"Size"})
 
192
 
 
193
        c.Assert(resp.Attrs[0].Name, Equals, "Color")
 
194
        c.Assert(resp.Attrs[0].Value, Equals, "Blue")
 
195
        c.Assert(resp.Attrs[1].Name, Equals, "Size")
 
196
        c.Assert(resp.Attrs[1].Value, Equals, "Med")
 
197
        c.Assert(resp.ResponseMetadata.RequestId, Equals, "b1e8f1f7-42e9-494c-ad09-2674e557526d")
 
198
        c.Assert(resp.ResponseMetadata.BoxUsage, Equals, 0.0000219942)
 
199
 
 
200
        c.Assert(err, IsNil)
 
201
}
 
202
 
 
203
func (s *S) TestSelectOK(c *C) {
 
204
        testServer.Response(200, nil, TestSelectXmlOK)
 
205
 
 
206
        resp, err := s.sdb.Select("select Color from MyDomain where Color like 'Blue%'", true)
 
207
        req := testServer.WaitRequest()
 
208
 
 
209
        c.Assert(req.Method, Equals, "GET")
 
210
        c.Assert(req.URL.Path, Equals, "/")
 
211
        c.Assert(req.Header["Date"], Not(Equals), "")
 
212
        c.Assert(req.Form["Action"], DeepEquals, []string{"Select"})
 
213
        c.Assert(req.Form["ConsistentRead"], DeepEquals, []string{"true"})
 
214
 
 
215
        c.Assert(resp.ResponseMetadata.RequestId, Equals, "b1e8f1f7-42e9-494c-ad09-2674e557526d")
 
216
        c.Assert(resp.ResponseMetadata.BoxUsage, Equals, 0.0000219907)
 
217
        c.Assert(len(resp.Items), Equals, 2)
 
218
        c.Assert(resp.Items[0].Name, Equals, "Item_03")
 
219
        c.Assert(resp.Items[1].Name, Equals, "Item_06")
 
220
        c.Assert(resp.Items[0].Attrs[0].Name, Equals, "Category")
 
221
        c.Assert(resp.Items[0].Attrs[0].Value, Equals, "Clothes")
 
222
 
 
223
        c.Assert(err, IsNil)
 
224
}