← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/cmd/filevar_test.go

  • Committer: Nicholas Skaggs
  • Date: 2016-10-24 20:56:05 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161024205605-z8lta0uvuhtxwzwl
Initi with beta15

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/cmd/filevar_test.go
 
1
// Copyright 2012, 2013 Canonical Ltd.
 
2
// Licensed under the LGPLv3, see LICENSE file for details.
 
3
 
 
4
package cmd_test
 
5
 
 
6
import (
 
7
        "bytes"
 
8
        "io"
 
9
        "io/ioutil"
 
10
        "os"
 
11
        "path/filepath"
 
12
 
 
13
        gitjujutesting "github.com/juju/testing"
 
14
        jc "github.com/juju/testing/checkers"
 
15
        "github.com/juju/utils"
 
16
        gc "gopkg.in/check.v1"
 
17
        "launchpad.net/gnuflag"
 
18
 
 
19
        "github.com/juju/cmd"
 
20
        "github.com/juju/cmd/cmdtesting"
 
21
)
 
22
 
 
23
type FileVarSuite struct {
 
24
        gitjujutesting.FakeHomeSuite
 
25
        ctx         *cmd.Context
 
26
        ValidPath   string
 
27
        InvalidPath string // invalid path refers to a file which is not readable
 
28
}
 
29
 
 
30
var _ = gc.Suite(&FileVarSuite{})
 
31
 
 
32
func (s *FileVarSuite) SetUpTest(c *gc.C) {
 
33
        s.FakeHomeSuite.SetUpTest(c)
 
34
        s.ctx = cmdtesting.Context(c)
 
35
        s.ValidPath = s.ctx.AbsPath("valid.yaml")
 
36
        s.InvalidPath = s.ctx.AbsPath("invalid.yaml")
 
37
        f, err := os.Create(s.ValidPath)
 
38
        c.Assert(err, gc.IsNil)
 
39
        f.Close()
 
40
        f, err = os.Create(s.InvalidPath)
 
41
        c.Assert(err, gc.IsNil)
 
42
        f.Close()
 
43
        err = os.Chmod(s.InvalidPath, 0) // make unreadable
 
44
        c.Assert(err, gc.IsNil)
 
45
}
 
46
 
 
47
func (s *FileVarSuite) TestSetStdin(c *gc.C) {
 
48
        var config cmd.FileVar
 
49
        c.Assert(config.Path, gc.Equals, "")
 
50
        c.Assert(config.StdinMarkers, jc.DeepEquals, []string{})
 
51
 
 
52
        config.SetStdin()
 
53
        c.Assert(config.Path, gc.Equals, "")
 
54
        c.Assert(config.StdinMarkers, jc.DeepEquals, []string{"-"})
 
55
 
 
56
        config.SetStdin("<>", "@")
 
57
        c.Assert(config.Path, gc.Equals, "")
 
58
        c.Assert(config.StdinMarkers, jc.DeepEquals, []string{"<>", "@"})
 
59
}
 
60
 
 
61
func (s *FileVarSuite) TestIsStdin(c *gc.C) {
 
62
        var config cmd.FileVar
 
63
        c.Check(config.IsStdin(), jc.IsFalse)
 
64
 
 
65
        config.StdinMarkers = []string{"-"}
 
66
        c.Check(config.IsStdin(), jc.IsFalse)
 
67
 
 
68
        config.Path = "spam"
 
69
        c.Check(config.IsStdin(), jc.IsFalse)
 
70
 
 
71
        config.Path = "-"
 
72
        c.Check(config.IsStdin(), jc.IsTrue)
 
73
 
 
74
        config.StdinMarkers = nil
 
75
        c.Check(config.IsStdin(), jc.IsFalse)
 
76
 
 
77
        config.StdinMarkers = []string{"<>", "@"}
 
78
        c.Check(config.IsStdin(), jc.IsFalse)
 
79
 
 
80
        config.Path = "<>"
 
81
        c.Check(config.IsStdin(), jc.IsTrue)
 
82
 
 
83
        config.Path = "@"
 
84
        c.Check(config.IsStdin(), jc.IsTrue)
 
85
}
 
86
 
 
87
func (FileVarSuite) checkOpen(c *gc.C, file io.ReadCloser, expected string) {
 
88
        defer file.Close()
 
89
 
 
90
        data, err := ioutil.ReadAll(file)
 
91
        c.Assert(err, jc.ErrorIsNil)
 
92
        c.Check(string(data), gc.Equals, expected)
 
93
}
 
94
 
 
95
func (s *FileVarSuite) TestOpenTilde(c *gc.C) {
 
96
        path := filepath.Join(utils.Home(), "config.yaml")
 
97
        err := ioutil.WriteFile(path, []byte("abc"), 0644)
 
98
        c.Assert(err, gc.IsNil)
 
99
 
 
100
        var config cmd.FileVar
 
101
        config.Set("~/config.yaml")
 
102
        file, err := config.Open(s.ctx)
 
103
        c.Assert(err, gc.IsNil)
 
104
 
 
105
        s.checkOpen(c, file, "abc")
 
106
}
 
107
 
 
108
func (s *FileVarSuite) TestOpenStdin(c *gc.C) {
 
109
        s.ctx.Stdin = bytes.NewBufferString("abc")
 
110
 
 
111
        var config cmd.FileVar
 
112
        config.SetStdin()
 
113
        config.Set("-")
 
114
        file, err := config.Open(s.ctx)
 
115
        c.Assert(err, gc.IsNil)
 
116
        s.checkOpen(c, file, "abc")
 
117
}
 
118
 
 
119
func (s *FileVarSuite) TestOpenNotStdin(c *gc.C) {
 
120
        var config cmd.FileVar
 
121
        config.Set("-")
 
122
        _, err := config.Open(s.ctx)
 
123
 
 
124
        c.Check(err, jc.Satisfies, os.IsNotExist)
 
125
}
 
126
 
 
127
func (s *FileVarSuite) TestOpenValid(c *gc.C) {
 
128
        fs, config := fs()
 
129
        err := fs.Parse(false, []string{"--config", s.ValidPath})
 
130
        c.Assert(err, gc.IsNil)
 
131
        c.Assert(config.Path, gc.Equals, s.ValidPath)
 
132
        _, err = config.Open(s.ctx)
 
133
        c.Assert(err, gc.IsNil)
 
134
}
 
135
 
 
136
func (s *FileVarSuite) TestOpenInvalid(c *gc.C) {
 
137
        fs, config := fs()
 
138
        err := fs.Parse(false, []string{"--config", s.InvalidPath})
 
139
        c.Assert(config.Path, gc.Equals, s.InvalidPath)
 
140
        _, err = config.Open(s.ctx)
 
141
        c.Assert(err, gc.ErrorMatches, "*permission denied")
 
142
}
 
143
 
 
144
func (s *FileVarSuite) TestReadTilde(c *gc.C) {
 
145
        path := filepath.Join(utils.Home(), "config.yaml")
 
146
        err := ioutil.WriteFile(path, []byte("abc"), 0644)
 
147
        c.Assert(err, gc.IsNil)
 
148
 
 
149
        var config cmd.FileVar
 
150
        config.Set("~/config.yaml")
 
151
        file, err := config.Read(s.ctx)
 
152
        c.Assert(err, gc.IsNil)
 
153
        c.Assert(string(file), gc.Equals, "abc")
 
154
}
 
155
 
 
156
func (s *FileVarSuite) TestReadStdin(c *gc.C) {
 
157
        s.ctx.Stdin = bytes.NewBufferString("abc")
 
158
 
 
159
        var config cmd.FileVar
 
160
        config.SetStdin()
 
161
        config.Set("-")
 
162
        file, err := config.Read(s.ctx)
 
163
        c.Assert(err, gc.IsNil)
 
164
        c.Assert(string(file), gc.Equals, "abc")
 
165
}
 
166
 
 
167
func (s *FileVarSuite) TestReadNotStdin(c *gc.C) {
 
168
        var config cmd.FileVar
 
169
        config.Set("-")
 
170
        _, err := config.Read(s.ctx)
 
171
 
 
172
        c.Check(err, jc.Satisfies, os.IsNotExist)
 
173
}
 
174
 
 
175
func (s *FileVarSuite) TestReadValid(c *gc.C) {
 
176
        fs, config := fs()
 
177
        err := fs.Parse(false, []string{"--config", s.ValidPath})
 
178
        c.Assert(err, gc.IsNil)
 
179
        c.Assert(config.Path, gc.Equals, s.ValidPath)
 
180
        _, err = config.Read(s.ctx)
 
181
        c.Assert(err, gc.IsNil)
 
182
}
 
183
 
 
184
func (s *FileVarSuite) TestReadInvalid(c *gc.C) {
 
185
        fs, config := fs()
 
186
        err := fs.Parse(false, []string{"--config", s.InvalidPath})
 
187
        c.Assert(config.Path, gc.Equals, s.InvalidPath)
 
188
        _, err = config.Read(s.ctx)
 
189
        c.Assert(err, gc.ErrorMatches, "*permission denied")
 
190
}
 
191
 
 
192
func fs() (*gnuflag.FlagSet, *cmd.FileVar) {
 
193
        var config cmd.FileVar
 
194
        fs := cmdtesting.NewFlagSet()
 
195
        fs.Var(&config, "config", "the config")
 
196
        return fs, &config
 
197
}