← Back to branch summary

~rogpeppe/juju-core/azure

« back to all changes in this revision

Viewing changes to testing/environ.go

  • Committer: Roger Peppe
  • Date: 2011-12-07 17:03:34 UTC
  • mto: (25.3.4 go-trunk)
  • mto: This revision was merged to the branch mainline in revision 27.
  • Revision ID: roger.peppe@canonical.com-20111207170334-soasb88g2x5mpkf5
add cloudinit package

Show diffs side-by-side

added added

removed removed

Lines of Context:
testing/environ.go
1
 
// Copyright 2013 Canonical Ltd.
2
 
// Licensed under the AGPLv3, see LICENCE file for details.
3
 
 
4
 
package testing
5
 
 
6
 
import (
7
 
        "io/ioutil"
8
 
        "os"
9
 
        "path/filepath"
10
 
 
11
 
        . "launchpad.net/gocheck"
12
 
 
13
 
        "launchpad.net/juju-core/environs/config"
14
 
)
15
 
 
16
 
// EnvironConfig returns a default environment configuration suitable for
17
 
// testing.
18
 
func EnvironConfig(c *C) *config.Config {
19
 
        cfg, err := config.New(map[string]interface{}{
20
 
                "type":            "test",
21
 
                "name":            "test-name",
22
 
                "default-series":  "test-series",
23
 
                "authorized-keys": "test-keys",
24
 
                "agent-version":   "9.9.9.9",
25
 
                "ca-cert":         CACert,
26
 
                "ca-private-key":  "",
27
 
        })
28
 
        c.Assert(err, IsNil)
29
 
        return cfg
30
 
}
31
 
 
32
 
const SampleEnvName = "erewhemos"
33
 
const EnvDefault = "default:\n  " + SampleEnvName + "\n"
34
 
 
35
 
// Environment names below are explicit as it makes them more readable.
36
 
const SingleEnvConfigNoDefault = `
37
 
environments:
38
 
    erewhemos:
39
 
        type: dummy
40
 
        state-server: true
41
 
        authorized-keys: i-am-a-key
42
 
        admin-secret: conn-from-name-secret
43
 
`
44
 
 
45
 
const SingleEnvConfig = EnvDefault + SingleEnvConfigNoDefault
46
 
 
47
 
const MultipleEnvConfigNoDefault = `
48
 
environments:
49
 
    erewhemos:
50
 
        type: dummy
51
 
        state-server: true
52
 
        authorized-keys: i-am-a-key
53
 
        admin-secret: conn-from-name-secret
54
 
    erewhemos-2:
55
 
        type: dummy
56
 
        state-server: true
57
 
        authorized-keys: i-am-a-key
58
 
        admin-secret: conn-from-name-secret
59
 
`
60
 
 
61
 
const MultipleEnvConfig = EnvDefault + MultipleEnvConfigNoDefault
62
 
 
63
 
const SampleCertName = "erewhemos"
64
 
 
65
 
type TestFile struct {
66
 
        Name, Data string
67
 
}
68
 
 
69
 
type FakeHome struct {
70
 
        oldHomeEnv     string
71
 
        oldJujuEnv     string
72
 
        oldJujuHomeEnv string
73
 
        oldJujuHome    string
74
 
        files          []TestFile
75
 
}
76
 
 
77
 
// MakeFakeHomeNoEnvironments creates a new temporary directory through the
78
 
// test checker, and overrides the HOME environment variable to point to this
79
 
// new temporary directory.
80
 
//
81
 
// No ~/.juju/environments.yaml exists, but CAKeys are written for each of the
82
 
// 'certNames' specified, and the id_rsa.pub file is written to to the .ssh
83
 
// dir.
84
 
func MakeFakeHomeNoEnvironments(c *C, certNames ...string) *FakeHome {
85
 
        fake := MakeEmptyFakeHome(c)
86
 
 
87
 
        for _, name := range certNames {
88
 
                err := ioutil.WriteFile(config.JujuHomePath(name+"-cert.pem"), []byte(CACert), 0600)
89
 
                c.Assert(err, IsNil)
90
 
                err = ioutil.WriteFile(config.JujuHomePath(name+"-private-key.pem"), []byte(CAKey), 0600)
91
 
                c.Assert(err, IsNil)
92
 
        }
93
 
 
94
 
        err := os.Mkdir(HomePath(".ssh"), 0777)
95
 
        c.Assert(err, IsNil)
96
 
        err = ioutil.WriteFile(HomePath(".ssh", "id_rsa.pub"), []byte("auth key\n"), 0666)
97
 
        c.Assert(err, IsNil)
98
 
 
99
 
        return fake
100
 
}
101
 
 
102
 
// MakeFakeHome creates a new temporary directory through the test checker,
103
 
// and overrides the HOME environment variable to point to this new temporary
104
 
// directory.
105
 
//
106
 
// A new ~/.juju/environments.yaml file is created with the content of the
107
 
// `envConfig` parameter, and CAKeys are written for each of the 'certNames'
108
 
// specified.
109
 
func MakeFakeHome(c *C, envConfig string, certNames ...string) *FakeHome {
110
 
        fake := MakeFakeHomeNoEnvironments(c, certNames...)
111
 
 
112
 
        envs := config.JujuHomePath("environments.yaml")
113
 
        err := ioutil.WriteFile(envs, []byte(envConfig), 0644)
114
 
        c.Assert(err, IsNil)
115
 
 
116
 
        return fake
117
 
}
118
 
 
119
 
func MakeEmptyFakeHome(c *C) *FakeHome {
120
 
        fake := MakeEmptyFakeHomeWithoutJuju(c)
121
 
        err := os.Mkdir(config.JujuHome(), 0700)
122
 
        c.Assert(err, IsNil)
123
 
        return fake
124
 
}
125
 
 
126
 
func MakeEmptyFakeHomeWithoutJuju(c *C) *FakeHome {
127
 
        oldHomeEnv := os.Getenv("HOME")
128
 
        oldJujuHomeEnv := os.Getenv("JUJU_HOME")
129
 
        oldJujuEnv := os.Getenv("JUJU_ENV")
130
 
        fakeHome := c.MkDir()
131
 
        os.Setenv("HOME", fakeHome)
132
 
        os.Setenv("JUJU_HOME", "")
133
 
        os.Setenv("JUJU_ENV", "")
134
 
        jujuHome := filepath.Join(fakeHome, ".juju")
135
 
        oldJujuHome := config.SetJujuHome(jujuHome)
136
 
        return &FakeHome{
137
 
                oldHomeEnv:     oldHomeEnv,
138
 
                oldJujuEnv:     oldJujuEnv,
139
 
                oldJujuHomeEnv: oldJujuHomeEnv,
140
 
                oldJujuHome:    oldJujuHome,
141
 
                files:          []TestFile{},
142
 
        }
143
 
}
144
 
 
145
 
func HomePath(names ...string) string {
146
 
        all := append([]string{os.Getenv("HOME")}, names...)
147
 
        return filepath.Join(all...)
148
 
}
149
 
 
150
 
func (h *FakeHome) Restore() {
151
 
        config.SetJujuHome(h.oldJujuHome)
152
 
        os.Setenv("JUJU_ENV", h.oldJujuEnv)
153
 
        os.Setenv("JUJU_HOME", h.oldJujuHomeEnv)
154
 
        os.Setenv("HOME", h.oldHomeEnv)
155
 
}
156
 
 
157
 
func (h *FakeHome) AddFiles(c *C, files []TestFile) {
158
 
        for _, f := range files {
159
 
                path := HomePath(f.Name)
160
 
                err := os.MkdirAll(filepath.Dir(path), 0700)
161
 
                c.Assert(err, IsNil)
162
 
                err = ioutil.WriteFile(path, []byte(f.Data), 0666)
163
 
                c.Assert(err, IsNil)
164
 
                h.files = append(h.files, f)
165
 
        }
166
 
}
167
 
 
168
 
// FileContents returns the test file contents for the
169
 
// given specified path (which may be relative, so
170
 
// we compare with the base filename only).
171
 
func (h *FakeHome) FileContents(c *C, path string) string {
172
 
        for _, f := range h.files {
173
 
                if filepath.Base(f.Name) == filepath.Base(path) {
174
 
                        return f.Data
175
 
                }
176
 
        }
177
 
        c.Fatalf("path attribute holds unknown test file: %q", path)
178
 
        panic("unreachable")
179
 
}
180
 
 
181
 
// FileExists returns if the given relative file path exists
182
 
// in the fake home.
183
 
func (h *FakeHome) FileExists(path string) bool {
184
 
        for _, f := range h.files {
185
 
                if f.Name == path {
186
 
                        return true
187
 
                }
188
 
        }
189
 
        return false
190
 
}
191
 
 
192
 
func MakeFakeHomeWithFiles(c *C, files []TestFile) *FakeHome {
193
 
        fake := MakeEmptyFakeHome(c)
194
 
        fake.AddFiles(c, files)
195
 
        return fake
196
 
}
197
 
 
198
 
func MakeSampleHome(c *C) *FakeHome {
199
 
        return MakeFakeHome(c, SingleEnvConfig, SampleCertName)
200
 
}
201
 
 
202
 
func MakeMultipleEnvHome(c *C) *FakeHome {
203
 
        return MakeFakeHome(c, MultipleEnvConfig, SampleCertName, "erewhemos-2")
204
 
}