github.com/makyo/juju@v0.0.0-20160425123129-2608902037e9/environs/storage/storage_test.go (about) 1 // Copyright 2013 Canonical Ltd. 2 // Licensed under the AGPLv3, see LICENCE file for details. 3 4 package storage_test 5 6 import ( 7 "bytes" 8 "fmt" 9 "io" 10 "io/ioutil" 11 stdtesting "testing" 12 13 jc "github.com/juju/testing/checkers" 14 "github.com/juju/utils" 15 gc "gopkg.in/check.v1" 16 17 "github.com/juju/juju/environs/filestorage" 18 "github.com/juju/juju/environs/simplestreams" 19 "github.com/juju/juju/environs/storage" 20 "github.com/juju/juju/testing" 21 ) 22 23 func TestPackage(t *stdtesting.T) { 24 gc.TestingT(t) 25 } 26 27 var _ = gc.Suite(&datasourceSuite{}) 28 29 type datasourceSuite struct { 30 testing.FakeJujuXDGDataHomeSuite 31 stor storage.Storage 32 baseURL string 33 } 34 35 func (s *datasourceSuite) SetUpTest(c *gc.C) { 36 s.FakeJujuXDGDataHomeSuite.SetUpTest(c) 37 38 storageDir := c.MkDir() 39 stor, err := filestorage.NewFileStorageWriter(storageDir) 40 c.Assert(err, jc.ErrorIsNil) 41 s.stor = stor 42 s.baseURL, err = s.stor.URL("") 43 c.Assert(err, jc.ErrorIsNil) 44 } 45 46 func (s *datasourceSuite) TestFetch(c *gc.C) { 47 sampleData := "hello world" 48 s.stor.Put("foo/bar/data.txt", bytes.NewReader([]byte(sampleData)), int64(len(sampleData))) 49 ds := storage.NewStorageSimpleStreamsDataSource("test datasource", s.stor, "", simplestreams.DEFAULT_CLOUD_DATA, false) 50 rc, url, err := ds.Fetch("foo/bar/data.txt") 51 c.Assert(err, jc.ErrorIsNil) 52 defer rc.Close() 53 c.Assert(url, gc.Equals, s.baseURL+"/foo/bar/data.txt") 54 data, err := ioutil.ReadAll(rc) 55 c.Assert(data, gc.DeepEquals, []byte(sampleData)) 56 } 57 58 func (s *datasourceSuite) TestFetchWithBasePath(c *gc.C) { 59 sampleData := "hello world" 60 s.stor.Put("base/foo/bar/data.txt", bytes.NewReader([]byte(sampleData)), int64(len(sampleData))) 61 ds := storage.NewStorageSimpleStreamsDataSource("test datasource", s.stor, "base", simplestreams.DEFAULT_CLOUD_DATA, false) 62 rc, url, err := ds.Fetch("foo/bar/data.txt") 63 c.Assert(err, jc.ErrorIsNil) 64 defer rc.Close() 65 c.Assert(url, gc.Equals, s.baseURL+"/base/foo/bar/data.txt") 66 data, err := ioutil.ReadAll(rc) 67 c.Assert(data, gc.DeepEquals, []byte(sampleData)) 68 } 69 70 func (s *datasourceSuite) TestFetchWithRetry(c *gc.C) { 71 stor := &fakeStorage{shouldRetry: true} 72 ds := storage.NewStorageSimpleStreamsDataSource("test datasource", stor, "base", simplestreams.DEFAULT_CLOUD_DATA, false) 73 ds.SetAllowRetry(true) 74 _, _, err := ds.Fetch("foo/bar/data.txt") 75 c.Assert(err, gc.ErrorMatches, "an error") 76 c.Assert(stor.getName, gc.Equals, "base/foo/bar/data.txt") 77 c.Assert(stor.invokeCount, gc.Equals, 10) 78 } 79 80 func (s *datasourceSuite) TestFetchWithNoRetry(c *gc.C) { 81 // NB shouldRetry below is true indicating the fake storage is capable of 82 // retrying, not that it will retry. 83 stor := &fakeStorage{shouldRetry: true} 84 ds := storage.NewStorageSimpleStreamsDataSource("test datasource", stor, "base", simplestreams.DEFAULT_CLOUD_DATA, false) 85 _, _, err := ds.Fetch("foo/bar/data.txt") 86 c.Assert(err, gc.ErrorMatches, "an error") 87 c.Assert(stor.getName, gc.Equals, "base/foo/bar/data.txt") 88 c.Assert(stor.invokeCount, gc.Equals, 1) 89 } 90 91 func (s *datasourceSuite) TestURL(c *gc.C) { 92 sampleData := "hello world" 93 s.stor.Put("bar/data.txt", bytes.NewReader([]byte(sampleData)), int64(len(sampleData))) 94 ds := storage.NewStorageSimpleStreamsDataSource("test datasource", s.stor, "", simplestreams.DEFAULT_CLOUD_DATA, false) 95 url, err := ds.URL("bar") 96 c.Assert(err, jc.ErrorIsNil) 97 expectedURL, _ := s.stor.URL("bar") 98 c.Assert(url, gc.Equals, expectedURL) 99 } 100 101 func (s *datasourceSuite) TestURLWithBasePath(c *gc.C) { 102 sampleData := "hello world" 103 s.stor.Put("base/bar/data.txt", bytes.NewReader([]byte(sampleData)), int64(len(sampleData))) 104 ds := storage.NewStorageSimpleStreamsDataSource("test datasource", s.stor, "base", simplestreams.DEFAULT_CLOUD_DATA, false) 105 url, err := ds.URL("bar") 106 c.Assert(err, jc.ErrorIsNil) 107 expectedURL, _ := s.stor.URL("base/bar") 108 c.Assert(url, gc.Equals, expectedURL) 109 } 110 111 var _ = gc.Suite(&storageSuite{}) 112 113 type storageSuite struct{} 114 115 type fakeStorage struct { 116 getName string 117 listPrefix string 118 invokeCount int 119 shouldRetry bool 120 } 121 122 func (s *fakeStorage) Get(name string) (io.ReadCloser, error) { 123 s.getName = name 124 s.invokeCount++ 125 return nil, fmt.Errorf("an error") 126 } 127 128 func (s *fakeStorage) List(prefix string) ([]string, error) { 129 s.listPrefix = prefix 130 s.invokeCount++ 131 return nil, fmt.Errorf("an error") 132 } 133 134 func (s *fakeStorage) URL(name string) (string, error) { 135 return "", nil 136 } 137 138 func (s *fakeStorage) DefaultConsistencyStrategy() utils.AttemptStrategy { 139 return utils.AttemptStrategy{Min: 10} 140 } 141 142 func (s *fakeStorage) ShouldRetry(error) bool { 143 return s.shouldRetry 144 } 145 146 func (s *storageSuite) TestGetWithRetry(c *gc.C) { 147 stor := &fakeStorage{shouldRetry: true} 148 attempt := utils.AttemptStrategy{Min: 5} 149 storage.GetWithRetry(stor, "foo", attempt) 150 c.Assert(stor.getName, gc.Equals, "foo") 151 c.Assert(stor.invokeCount, gc.Equals, 5) 152 } 153 154 func (s *storageSuite) TestGet(c *gc.C) { 155 stor := &fakeStorage{shouldRetry: true} 156 storage.Get(stor, "foo") 157 c.Assert(stor.getName, gc.Equals, "foo") 158 c.Assert(stor.invokeCount, gc.Equals, 10) 159 } 160 161 func (s *storageSuite) TestGetNoRetryAllowed(c *gc.C) { 162 stor := &fakeStorage{} 163 storage.Get(stor, "foo") 164 c.Assert(stor.getName, gc.Equals, "foo") 165 c.Assert(stor.invokeCount, gc.Equals, 1) 166 } 167 168 func (s *storageSuite) TestListWithRetry(c *gc.C) { 169 stor := &fakeStorage{shouldRetry: true} 170 attempt := utils.AttemptStrategy{Min: 5} 171 storage.ListWithRetry(stor, "foo", attempt) 172 c.Assert(stor.listPrefix, gc.Equals, "foo") 173 c.Assert(stor.invokeCount, gc.Equals, 5) 174 } 175 176 func (s *storageSuite) TestList(c *gc.C) { 177 stor := &fakeStorage{shouldRetry: true} 178 storage.List(stor, "foo") 179 c.Assert(stor.listPrefix, gc.Equals, "foo") 180 c.Assert(stor.invokeCount, gc.Equals, 10) 181 } 182 183 func (s *storageSuite) TestListNoRetryAllowed(c *gc.C) { 184 stor := &fakeStorage{} 185 storage.List(stor, "foo") 186 c.Assert(stor.listPrefix, gc.Equals, "foo") 187 c.Assert(stor.invokeCount, gc.Equals, 1) 188 }