← Back to branch summary

~james-page/ubuntu/saucy/juju-core/1.16.5

« back to all changes in this revision

Viewing changes to src/launchpad.net/juju-core/environs/filestorage/filestorage_test.go

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-10-10 18:07:45 UTC
  • mfrom: (1.1.10)
  • Revision ID: package-import@ubuntu.com-20131010180745-wuo0vv7hq7faavdk
Tags: 1.16.0-0ubuntu1
https://launchpad.net/bugs/1219879
New upstream stable release (LP: #1219879).

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/launchpad.net/juju-core/environs/filestorage/filestorage_test.go
 
1
// Copyright 2013 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package filestorage_test
 
5
 
 
6
// The filestorage structs are used as stubs in tests.
 
7
// The tests defined herein are simple smoke tests for the
 
8
// required reader and writer functionality.
 
9
 
 
10
import (
 
11
        "bytes"
 
12
        "io/ioutil"
 
13
        "os"
 
14
        "path/filepath"
 
15
        "testing"
 
16
 
 
17
        gc "launchpad.net/gocheck"
 
18
 
 
19
        "launchpad.net/juju-core/environs/filestorage"
 
20
        "launchpad.net/juju-core/environs/storage"
 
21
        coreerrors "launchpad.net/juju-core/errors"
 
22
        jc "launchpad.net/juju-core/testing/checkers"
 
23
)
 
24
 
 
25
func TestPackage(t *testing.T) {
 
26
        gc.TestingT(t)
 
27
}
 
28
 
 
29
type filestorageSuite struct {
 
30
        dir    string
 
31
        reader storage.StorageReader
 
32
        writer storage.StorageWriter
 
33
}
 
34
 
 
35
var _ = gc.Suite(&filestorageSuite{})
 
36
 
 
37
func (s *filestorageSuite) SetUpTest(c *gc.C) {
 
38
        s.dir = c.MkDir()
 
39
        var err error
 
40
        s.reader, err = filestorage.NewFileStorageReader(s.dir)
 
41
        c.Assert(err, gc.IsNil)
 
42
        s.writer, err = filestorage.NewFileStorageWriter(s.dir, filestorage.UseDefaultTmpDir)
 
43
        c.Assert(err, gc.IsNil)
 
44
}
 
45
 
 
46
func (s *filestorageSuite) createFile(c *gc.C, name string) (fullpath string, data []byte) {
 
47
        fullpath = filepath.Join(s.dir, name)
 
48
        dir := filepath.Dir(fullpath)
 
49
        c.Assert(os.MkdirAll(dir, 0755), gc.IsNil)
 
50
        data = []byte{1, 2, 3, 4, 5}
 
51
        err := ioutil.WriteFile(fullpath, data, 0644)
 
52
        c.Assert(err, gc.IsNil)
 
53
        return fullpath, data
 
54
}
 
55
 
 
56
func (s *filestorageSuite) TestList(c *gc.C) {
 
57
        names := []string{
 
58
                "a/b/c",
 
59
                "a/bb",
 
60
                "a/c",
 
61
                "aa",
 
62
                "b/c/d",
 
63
        }
 
64
        for _, name := range names {
 
65
                s.createFile(c, name)
 
66
        }
 
67
        type test struct {
 
68
                prefix   string
 
69
                expected []string
 
70
        }
 
71
        for i, test := range []test{
 
72
                {"a", []string{"a/b/c", "a/bb", "a/c", "aa"}},
 
73
                {"a/b", []string{"a/b/c", "a/bb"}},
 
74
                {"a/b/c", []string{"a/b/c"}},
 
75
                {"", names},
 
76
        } {
 
77
                c.Logf("test %d: prefix=%q", i, test.prefix)
 
78
                files, err := storage.List(s.reader, test.prefix)
 
79
                c.Assert(err, gc.IsNil)
 
80
                c.Assert(files, gc.DeepEquals, test.expected)
 
81
        }
 
82
}
 
83
 
 
84
func (s *filestorageSuite) TestURL(c *gc.C) {
 
85
        expectedpath, _ := s.createFile(c, "test-file")
 
86
        _, file := filepath.Split(expectedpath)
 
87
        url, err := s.reader.URL(file)
 
88
        c.Assert(err, gc.IsNil)
 
89
        c.Assert(url, gc.Equals, "file://"+expectedpath)
 
90
}
 
91
 
 
92
func (s *filestorageSuite) TestGet(c *gc.C) {
 
93
        expectedpath, data := s.createFile(c, "test-file")
 
94
        _, file := filepath.Split(expectedpath)
 
95
        rc, err := storage.Get(s.reader, file)
 
96
        c.Assert(err, gc.IsNil)
 
97
        defer rc.Close()
 
98
        c.Assert(err, gc.IsNil)
 
99
        b, err := ioutil.ReadAll(rc)
 
100
        c.Assert(err, gc.IsNil)
 
101
        c.Assert(b, gc.DeepEquals, data)
 
102
 
 
103
        // Get on a non-existant path returns NotFoundError
 
104
        _, err = s.reader.Get("nowhere")
 
105
        c.Assert(err, jc.Satisfies, coreerrors.IsNotFoundError)
 
106
 
 
107
        // Get on a directory returns NotFoundError
 
108
        s.createFile(c, "dir/file")
 
109
        _, err = s.reader.Get("dir")
 
110
        c.Assert(err, jc.Satisfies, coreerrors.IsNotFoundError)
 
111
}
 
112
 
 
113
func (s *filestorageSuite) TestPut(c *gc.C) {
 
114
        data := []byte{1, 2, 3, 4, 5}
 
115
        err := s.writer.Put("test-write", bytes.NewReader(data), int64(len(data)))
 
116
        c.Assert(err, gc.IsNil)
 
117
        b, err := ioutil.ReadFile(filepath.Join(s.dir, "test-write"))
 
118
        c.Assert(err, gc.IsNil)
 
119
        c.Assert(b, gc.DeepEquals, data)
 
120
}
 
121
 
 
122
func (s *filestorageSuite) TestRemove(c *gc.C) {
 
123
        expectedpath, _ := s.createFile(c, "test-file")
 
124
        _, file := filepath.Split(expectedpath)
 
125
        err := s.writer.Remove(file)
 
126
        c.Assert(err, gc.IsNil)
 
127
        _, err = ioutil.ReadFile(expectedpath)
 
128
        c.Assert(err, gc.Not(gc.IsNil))
 
129
}
 
130
 
 
131
func (s *filestorageSuite) TestRemoveAll(c *gc.C) {
 
132
        expectedpath, _ := s.createFile(c, "test-file")
 
133
        err := s.writer.RemoveAll()
 
134
        c.Assert(err, gc.IsNil)
 
135
        _, err = ioutil.ReadFile(expectedpath)
 
136
        c.Assert(err, gc.Not(gc.IsNil))
 
137
}
 
138
 
 
139
func (s *filestorageSuite) TestPutTmpDir(c *gc.C) {
 
140
        // Put should create and clean up the temporary directory if
 
141
        // tmpdir==UseDefaultTmpDir.
 
142
        err := s.writer.Put("test-write", bytes.NewReader(nil), 0)
 
143
        c.Assert(err, gc.IsNil)
 
144
        _, err = os.Stat(s.dir + ".tmp")
 
145
        c.Assert(err, jc.Satisfies, os.IsNotExist)
 
146
 
 
147
        // To deal with recovering from hard failure, UseDefaultTmpDir
 
148
        // doesn't care if the temporary directory already exists. It
 
149
        // still removes it, though.
 
150
        err = os.Mkdir(s.dir+".tmp", 0755)
 
151
        c.Assert(err, gc.IsNil)
 
152
        err = s.writer.Put("test-write", bytes.NewReader(nil), 0)
 
153
        c.Assert(err, gc.IsNil)
 
154
        _, err = os.Stat(s.dir + ".tmp")
 
155
        c.Assert(err, jc.Satisfies, os.IsNotExist)
 
156
 
 
157
        // If we explicitly set the temporary directory, it must already exist.
 
158
        s.writer, err = filestorage.NewFileStorageWriter(s.dir, s.dir+".tmp")
 
159
        c.Assert(err, gc.IsNil)
 
160
        err = s.writer.Put("test-write", bytes.NewReader(nil), 0)
 
161
        c.Assert(err, jc.Satisfies, os.IsNotExist)
 
162
        err = os.Mkdir(s.dir+".tmp", 0755)
 
163
        c.Assert(err, gc.IsNil)
 
164
        err = s.writer.Put("test-write", bytes.NewReader(nil), 0)
 
165
        c.Assert(err, gc.IsNil)
 
166
        // Temporary directory should not have been moved.
 
167
        _, err = os.Stat(s.dir + ".tmp")
 
168
        c.Assert(err, gc.IsNil)
 
169
}