← 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/provider/joyent/storage_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/provider/joyent/storage_test.go
1
 
// Copyright 2013 Joyent Inc.
2
 
// Licensed under the AGPLv3, see LICENCE file for details.
3
 
 
4
 
package joyent_test
5
 
 
6
 
import (
7
 
        "fmt"
8
 
        "io/ioutil"
9
 
        "math/rand"
10
 
        "net/http"
11
 
        "net/url"
12
 
        "strings"
13
 
 
14
 
        "github.com/joyent/gocommon/errors"
15
 
        jujuerrors "github.com/juju/errors"
16
 
        jc "github.com/juju/testing/checkers"
17
 
        gc "gopkg.in/check.v1"
18
 
 
19
 
        "github.com/juju/juju/provider/joyent"
20
 
        jp "github.com/juju/juju/provider/joyent"
21
 
)
22
 
 
23
 
type storageSuite struct {
24
 
        providerSuite
25
 
        localMantaServer
26
 
}
27
 
 
28
 
const (
29
 
        storageName     = "testStorage"
30
 
        fileName        = "testFile"
31
 
        fileBlobContent = "Juju Joyent Provider Storage - Test"
32
 
)
33
 
 
34
 
var _ = gc.Suite(&storageSuite{})
35
 
 
36
 
func (s *storageSuite) SetUpSuite(c *gc.C) {
37
 
        s.providerSuite.SetUpSuite(c)
38
 
        s.localMantaServer.setupServer(c)
39
 
        jp.RegisterMachinesEndpoint()
40
 
        s.AddSuiteCleanup(func(*gc.C) { jp.UnregisterMachinesEndpoint() })
41
 
}
42
 
 
43
 
func (s *storageSuite) TearDownSuite(c *gc.C) {
44
 
        s.localMantaServer.destroyServer()
45
 
        s.providerSuite.TearDownSuite(c)
46
 
}
47
 
 
48
 
// makeStorage creates a Manta storage object for the running test.
49
 
func (s *storageSuite) makeStorage(name string, c *gc.C) *jp.JoyentStorage {
50
 
        stor := joyent.MakeStorage(c, GetFakeConfig("test://test.api.joyentcloud.com", s.localMantaServer.Server.URL))
51
 
        return stor.(*jp.JoyentStorage)
52
 
}
53
 
 
54
 
func (s *storageSuite) assertContainer(storage *jp.JoyentStorage, c *gc.C) {
55
 
        err := jp.CreateContainer(storage)
56
 
        c.Assert(err, jc.ErrorIsNil)
57
 
}
58
 
 
59
 
func (s *storageSuite) assertFile(storage *jp.JoyentStorage, c *gc.C) {
60
 
        err := storage.Put(fileName, strings.NewReader(fileBlobContent), int64(len(fileBlobContent)))
61
 
        c.Assert(err, jc.ErrorIsNil)
62
 
}
63
 
 
64
 
// makeRandomBytes returns an array of arbitrary byte values.
65
 
func makeRandomBytes(length int) []byte {
66
 
        data := make([]byte, length)
67
 
        for index := range data {
68
 
                data[index] = byte(rand.Intn(256))
69
 
        }
70
 
        return data
71
 
}
72
 
 
73
 
func makeResponse(content string, status int) *http.Response {
74
 
        return &http.Response{
75
 
                Status:     fmt.Sprintf("%d", status),
76
 
                StatusCode: status,
77
 
                Body:       ioutil.NopCloser(strings.NewReader(content)),
78
 
        }
79
 
}
80
 
 
81
 
func (s *storageSuite) TestList(c *gc.C) {
82
 
        mantaStorage := s.makeStorage(storageName, c)
83
 
        s.assertContainer(mantaStorage, c)
84
 
        s.assertFile(mantaStorage, c)
85
 
 
86
 
        names, err := mantaStorage.List("")
87
 
        c.Assert(err, jc.ErrorIsNil)
88
 
        c.Check(names, gc.DeepEquals, []string{fileName})
89
 
}
90
 
 
91
 
func (s *storageSuite) TestListWithPrefix(c *gc.C) {
92
 
        mantaStorage := s.makeStorage(storageName, c)
93
 
        s.assertContainer(mantaStorage, c)
94
 
        s.assertFile(mantaStorage, c)
95
 
        err := mantaStorage.Put("pr/fileName", strings.NewReader(fileBlobContent), int64(len(fileBlobContent)))
96
 
        c.Assert(err, jc.ErrorIsNil)
97
 
 
98
 
        names, err := mantaStorage.List("p")
99
 
        c.Assert(err, jc.ErrorIsNil)
100
 
        c.Check(names, gc.DeepEquals, []string{"pr/fileName"})
101
 
}
102
 
 
103
 
func (s *storageSuite) TestGet(c *gc.C) {
104
 
        mantaStorage := s.makeStorage(storageName, c)
105
 
        s.assertFile(mantaStorage, c)
106
 
 
107
 
        reader, err := mantaStorage.Get(fileName)
108
 
        c.Assert(err, jc.ErrorIsNil)
109
 
        c.Assert(reader, gc.NotNil)
110
 
        defer reader.Close()
111
 
 
112
 
        data, err := ioutil.ReadAll(reader)
113
 
        c.Assert(err, jc.ErrorIsNil)
114
 
        c.Check(string(data), gc.Equals, fileBlobContent)
115
 
}
116
 
 
117
 
func (s *storageSuite) TestGetFileNotExists(c *gc.C) {
118
 
        mantaStorage := s.makeStorage(storageName, c)
119
 
 
120
 
        _, err := mantaStorage.Get("noFile")
121
 
        c.Assert(err, gc.NotNil)
122
 
        c.Assert(err, jc.Satisfies, jujuerrors.IsNotFound)
123
 
}
124
 
 
125
 
func (s *storageSuite) TestPut(c *gc.C) {
126
 
        mantaStorage := s.makeStorage(storageName, c)
127
 
 
128
 
        s.assertFile(mantaStorage, c)
129
 
}
130
 
 
131
 
func (s *storageSuite) TestRemove(c *gc.C) {
132
 
        mantaStorage := s.makeStorage(storageName, c)
133
 
        s.assertFile(mantaStorage, c)
134
 
 
135
 
        err := mantaStorage.Remove(fileName)
136
 
        c.Assert(err, jc.ErrorIsNil)
137
 
}
138
 
 
139
 
func (s *storageSuite) TestRemoveFileNotExists(c *gc.C) {
140
 
        mantaStorage := s.makeStorage(storageName, c)
141
 
 
142
 
        err := mantaStorage.Remove("nofile")
143
 
        c.Assert(err, jc.ErrorIsNil)
144
 
}
145
 
 
146
 
func (s *storageSuite) TestRemoveAll(c *gc.C) {
147
 
        mantaStorage := s.makeStorage(storageName, c)
148
 
 
149
 
        err := mantaStorage.RemoveAll()
150
 
        c.Assert(err, jc.ErrorIsNil)
151
 
}
152
 
 
153
 
func (s *storageSuite) TestURL(c *gc.C) {
154
 
        mantaStorage := s.makeStorage(storageName, c)
155
 
 
156
 
        URL, err := mantaStorage.URL(fileName)
157
 
        c.Assert(err, jc.ErrorIsNil)
158
 
        parsedURL, err := url.Parse(URL)
159
 
        c.Assert(err, jc.ErrorIsNil)
160
 
        c.Check(parsedURL.Host, gc.Matches, mantaStorage.GetMantaUrl()[strings.LastIndex(mantaStorage.GetMantaUrl(), "/")+1:])
161
 
        c.Check(parsedURL.Path, gc.Matches, fmt.Sprintf("/%s/stor/%s/%s", mantaStorage.GetMantaUser(), mantaStorage.GetContainerName(), fileName))
162
 
}
163
 
 
164
 
func (s *storageSuite) TestCreateContainer(c *gc.C) {
165
 
        mantaStorage := s.makeStorage(storageName, c)
166
 
 
167
 
        s.assertContainer(mantaStorage, c)
168
 
}
169
 
 
170
 
func (s *storageSuite) TestCreateContainerAlreadyExists(c *gc.C) {
171
 
        mantaStorage := s.makeStorage(storageName, c)
172
 
 
173
 
        s.assertContainer(mantaStorage, c)
174
 
        s.assertContainer(mantaStorage, c)
175
 
}
176
 
 
177
 
func (s *storageSuite) TestDeleteContainer(c *gc.C) {
178
 
        mantaStorage := s.makeStorage(storageName, c)
179
 
        s.assertContainer(mantaStorage, c)
180
 
 
181
 
        err := mantaStorage.DeleteContainer(mantaStorage.GetContainerName())
182
 
        c.Assert(err, jc.ErrorIsNil)
183
 
}
184
 
 
185
 
func (s *storageSuite) TestDeleteContainerNotEmpty(c *gc.C) {
186
 
        mantaStorage := s.makeStorage(storageName, c)
187
 
        s.assertContainer(mantaStorage, c)
188
 
        s.assertFile(mantaStorage, c)
189
 
 
190
 
        err := mantaStorage.DeleteContainer(mantaStorage.GetContainerName())
191
 
        c.Assert(err, gc.NotNil)
192
 
        c.Assert(err, jc.Satisfies, errors.IsBadRequest)
193
 
}
194
 
 
195
 
func (s *storageSuite) TestDeleteContainerNotExists(c *gc.C) {
196
 
        mantaStorage := s.makeStorage(storageName, c)
197
 
 
198
 
        err := mantaStorage.DeleteContainer("noContainer")
199
 
        c.Assert(err, gc.NotNil)
200
 
        c.Assert(err, jc.Satisfies, jujuerrors.IsNotFound)
201
 
}