← Back to branch summary

~gz/juju-core/trunk

« back to all changes in this revision

Viewing changes to cmd/plugins/juju-metadata/validatetoolsmetadata_test.go

[r=wallyworld] Parse and validate tools metadata

Tools metadata in simplestreams format can be parsed and
validated. A new environs/tools package is created, and the
existing environs/tools.go is moved there, and the new
simplestreams support added also. The agent/tools package
is disambiguated as agenttools where there were clashes.

The metadata plugin is extended to support validating tools
metadata in the same way as image metadata. The next branches
will support using the tools metadata when finding tools to
bootstrap with.

https://codereview.appspot.com/12833043/

Show diffs side-by-side

added added

removed removed

Lines of Context:
cmd/plugins/juju-metadata/validatetoolsmetadata_test.go
 
1
// Copyright 2012, 2013 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package main
 
5
 
 
6
import (
 
7
        "bytes"
 
8
        "strings"
 
9
 
 
10
        "launchpad.net/goamz/aws"
 
11
        gc "launchpad.net/gocheck"
 
12
 
 
13
        "launchpad.net/juju-core/cmd"
 
14
        "launchpad.net/juju-core/environs/config"
 
15
        "launchpad.net/juju-core/environs/simplestreams"
 
16
        "launchpad.net/juju-core/environs/tools"
 
17
        coretesting "launchpad.net/juju-core/testing"
 
18
        "launchpad.net/juju-core/version"
 
19
)
 
20
 
 
21
type ValidateToolsMetadataSuite struct {
 
22
        home *coretesting.FakeHome
 
23
}
 
24
 
 
25
var _ = gc.Suite(&ValidateToolsMetadataSuite{})
 
26
 
 
27
func runValidateToolsMetadata(c *gc.C, args ...string) error {
 
28
        _, err := coretesting.RunCommand(c, &ValidateToolsMetadataCommand{}, args)
 
29
        return err
 
30
}
 
31
 
 
32
var validateInitToolsErrorTests = []struct {
 
33
        args []string
 
34
        err  string
 
35
}{
 
36
        {
 
37
                args: []string{"-p", "ec2", "-s", "series", "-d", "dir"},
 
38
                err:  `region required if provider type is specified`,
 
39
        }, {
 
40
                args: []string{"-p", "ec2", "-s", "series", "-r", "region"},
 
41
                err:  `metadata directory required if provider type is specified`,
 
42
        },
 
43
}
 
44
 
 
45
func (s *ValidateToolsMetadataSuite) TestInitErrors(c *gc.C) {
 
46
        for i, t := range validateInitToolsErrorTests {
 
47
                c.Logf("test %d", i)
 
48
                err := coretesting.InitCommand(&ValidateToolsMetadataCommand{}, t.args)
 
49
                c.Check(err, gc.ErrorMatches, t.err)
 
50
        }
 
51
}
 
52
 
 
53
func (s *ValidateToolsMetadataSuite) TestInvalidProviderError(c *gc.C) {
 
54
        err := runValidateToolsMetadata(c, "-p", "foo", "-s", "series", "-r", "region", "-d", "dir")
 
55
        c.Check(err, gc.ErrorMatches, `no registered provider for "foo"`)
 
56
}
 
57
 
 
58
func (s *ValidateToolsMetadataSuite) TestUnsupportedProviderError(c *gc.C) {
 
59
        err := runValidateToolsMetadata(c, "-p", "local", "-s", "series", "-r", "region", "-d", "dir")
 
60
        c.Check(err, gc.ErrorMatches, `local provider does not support tools metadata validation`)
 
61
}
 
62
 
 
63
func (s *ValidateToolsMetadataSuite) makeLocalMetadata(c *gc.C, version, region, series, endpoint string) error {
 
64
        tm := tools.ToolsMetadata{
 
65
                Version: version,
 
66
                Arch:    "amd64",
 
67
                Release: series,
 
68
        }
 
69
        cloudSpec := simplestreams.CloudSpec{
 
70
                Region:   region,
 
71
                Endpoint: endpoint,
 
72
        }
 
73
        _, err := tools.MakeBoilerplate("", series, &tm, &cloudSpec, false)
 
74
        if err != nil {
 
75
                return err
 
76
        }
 
77
        return nil
 
78
}
 
79
 
 
80
func (s *ValidateToolsMetadataSuite) SetUpTest(c *gc.C) {
 
81
        s.home = coretesting.MakeFakeHome(c, metadataTestEnvConfig)
 
82
}
 
83
 
 
84
func (s *ValidateToolsMetadataSuite) TearDownTest(c *gc.C) {
 
85
        s.home.Restore()
 
86
}
 
87
 
 
88
func (s *ValidateToolsMetadataSuite) setupEc2LocalMetadata(c *gc.C, region string) {
 
89
        ec2Region, ok := aws.Regions[region]
 
90
        if !ok {
 
91
                c.Fatalf("unknown ec2 region %q")
 
92
        }
 
93
        endpoint := ec2Region.EC2Endpoint
 
94
        s.makeLocalMetadata(c, "1.11.4", region, "precise", endpoint)
 
95
}
 
96
 
 
97
func (s *ValidateToolsMetadataSuite) TestEc2LocalMetadataUsingEnvironment(c *gc.C) {
 
98
        s.setupEc2LocalMetadata(c, "us-east-1")
 
99
        ctx := coretesting.Context(c)
 
100
        metadataDir := config.JujuHomePath("")
 
101
        code := cmd.Main(
 
102
                &ValidateToolsMetadataCommand{}, ctx, []string{"-e", "ec2", "-j", "1.11.4", "-d", metadataDir},
 
103
        )
 
104
        c.Assert(code, gc.Equals, 0)
 
105
        errOut := ctx.Stdout.(*bytes.Buffer).String()
 
106
        strippedOut := strings.Replace(errOut, "\n", "", -1)
 
107
        c.Check(strippedOut, gc.Matches, `matching tools versions:.*`)
 
108
}
 
109
 
 
110
func (s *ValidateToolsMetadataSuite) TestEc2LocalMetadataWithManualParams(c *gc.C) {
 
111
        s.setupEc2LocalMetadata(c, "us-west-1")
 
112
        ctx := coretesting.Context(c)
 
113
        metadataDir := config.JujuHomePath("")
 
114
        code := cmd.Main(
 
115
                &ValidateToolsMetadataCommand{}, ctx, []string{
 
116
                        "-p", "ec2", "-s", "precise", "-r", "us-west-1", "-j", "1.11.4",
 
117
                        "-u", "https://ec2.us-west-1.amazonaws.com", "-d", metadataDir},
 
118
        )
 
119
        c.Assert(code, gc.Equals, 0)
 
120
        errOut := ctx.Stdout.(*bytes.Buffer).String()
 
121
        strippedOut := strings.Replace(errOut, "\n", "", -1)
 
122
        c.Check(strippedOut, gc.Matches, `matching tools versions:.*`)
 
123
}
 
124
 
 
125
func (s *ValidateToolsMetadataSuite) TestEc2LocalMetadataNoMatch(c *gc.C) {
 
126
        s.setupEc2LocalMetadata(c, "us-east-1")
 
127
        ctx := coretesting.Context(c)
 
128
        metadataDir := config.JujuHomePath("")
 
129
        code := cmd.Main(
 
130
                &ValidateToolsMetadataCommand{}, ctx, []string{
 
131
                        "-p", "ec2", "-s", "raring", "-r", "us-west-1",
 
132
                        "-u", "https://ec2.us-west-1.amazonaws.com", "-d", metadataDir},
 
133
        )
 
134
        c.Assert(code, gc.Equals, 1)
 
135
        code = cmd.Main(
 
136
                &ValidateToolsMetadataCommand{}, ctx, []string{
 
137
                        "-p", "ec2", "-s", "precise", "-r", "region",
 
138
                        "-u", "https://ec2.region.amazonaws.com", "-d", metadataDir},
 
139
        )
 
140
        c.Assert(code, gc.Equals, 1)
 
141
}
 
142
 
 
143
func (s *ValidateToolsMetadataSuite) TestOpenstackLocalMetadataWithManualParams(c *gc.C) {
 
144
        s.makeLocalMetadata(c, "1.11.4", "region-2", "raring", "some-auth-url")
 
145
        ctx := coretesting.Context(c)
 
146
        metadataDir := config.JujuHomePath("")
 
147
        code := cmd.Main(
 
148
                &ValidateToolsMetadataCommand{}, ctx, []string{
 
149
                        "-p", "openstack", "-s", "raring", "-r", "region-2", "-j", "1.11.4",
 
150
                        "-u", "some-auth-url", "-d", metadataDir},
 
151
        )
 
152
        c.Assert(code, gc.Equals, 0)
 
153
        errOut := ctx.Stdout.(*bytes.Buffer).String()
 
154
        strippedOut := strings.Replace(errOut, "\n", "", -1)
 
155
        c.Check(strippedOut, gc.Matches, `matching tools versions:.*`)
 
156
}
 
157
 
 
158
func (s *ValidateToolsMetadataSuite) TestOpenstackLocalMetadataNoMatch(c *gc.C) {
 
159
        s.makeLocalMetadata(c, "1.11.4", "region-2", "raring", "some-auth-url")
 
160
        ctx := coretesting.Context(c)
 
161
        metadataDir := config.JujuHomePath("")
 
162
        code := cmd.Main(
 
163
                &ValidateToolsMetadataCommand{}, ctx, []string{
 
164
                        "-p", "openstack", "-s", "precise", "-r", "region-2",
 
165
                        "-u", "some-auth-url", "-d", metadataDir},
 
166
        )
 
167
        c.Assert(code, gc.Equals, 1)
 
168
        code = cmd.Main(
 
169
                &ValidateToolsMetadataCommand{}, ctx, []string{
 
170
                        "-p", "openstack", "-s", "raring", "-r", "region-3",
 
171
                        "-u", "some-auth-url", "-d", metadataDir},
 
172
        )
 
173
        c.Assert(code, gc.Equals, 1)
 
174
}
 
175
 
 
176
func (s *ValidateToolsMetadataSuite) TestDefaultVersion(c *gc.C) {
 
177
        s.makeLocalMetadata(c, version.CurrentNumber().String(), "region-2", "raring", "some-auth-url")
 
178
        ctx := coretesting.Context(c)
 
179
        metadataDir := config.JujuHomePath("")
 
180
        code := cmd.Main(
 
181
                &ValidateToolsMetadataCommand{}, ctx, []string{
 
182
                        "-p", "openstack", "-s", "raring", "-r", "region-2",
 
183
                        "-u", "some-auth-url", "-d", metadataDir},
 
184
        )
 
185
        c.Assert(code, gc.Equals, 0)
 
186
        errOut := ctx.Stdout.(*bytes.Buffer).String()
 
187
        strippedOut := strings.Replace(errOut, "\n", "", -1)
 
188
        c.Check(strippedOut, gc.Matches, `matching tools versions:.*`)
 
189
}