← Back to branch summary

~ubuntu-branches/ubuntu/saucy/juju-core/saucy-proposed

« back to all changes in this revision

Viewing changes to src/launchpad.net/juju-core/cmd/juju/imagemetadata_test.go

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-07-11 17:18:27 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20130711171827-vjqkg40r0dlf7ys2
Tags: 1.11.2-0ubuntu1
https://launchpad.net/bugs/1190634
https://launchpad.net/bugs/1172505
* New upstream release.
* Make juju-core the default juju (LP: #1190634):
  - d/control: Add virtual package juju -> juju-core.
  - d/juju-core.postinst.in: Bump priority of alternatives over that of
    python juju packages.
* Enable for all architectures (LP: #1172505):
  - d/control: Version BD on golang-go to >= 2:1.1.1 to ensure CGO
    support for non-x86 archs, make juju-core Arch: any.
  - d/README.source: Dropped - no longer required.
* d/watch: Updated for new upstream tarball naming.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/launchpad.net/juju-core/cmd/juju/imagemetadata_test.go
 
1
// Copyright 2013 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package main
 
5
 
 
6
import (
 
7
        "bytes"
 
8
        "encoding/json"
 
9
        "fmt"
 
10
        "io/ioutil"
 
11
        . "launchpad.net/gocheck"
 
12
        "launchpad.net/juju-core/cmd"
 
13
        "launchpad.net/juju-core/testing"
 
14
        "os"
 
15
        "strings"
 
16
)
 
17
 
 
18
type ImageMetadataSuite struct {
 
19
        environ []string
 
20
}
 
21
 
 
22
var _ = Suite(&ImageMetadataSuite{})
 
23
 
 
24
func (s *ImageMetadataSuite) SetUpSuite(c *C) {
 
25
        s.environ = os.Environ()
 
26
}
 
27
 
 
28
func (s *ImageMetadataSuite) SetUpTest(c *C) {
 
29
        os.Clearenv()
 
30
}
 
31
 
 
32
func (s *ImageMetadataSuite) TearDownTest(c *C) {
 
33
        for _, envstring := range s.environ {
 
34
                kv := strings.SplitN(envstring, "=", 2)
 
35
                os.Setenv(kv[0], kv[1])
 
36
        }
 
37
}
 
38
 
 
39
var seriesVersions map[string]string = map[string]string{
 
40
        "precise": "12.04",
 
41
        "raring":  "13.04",
 
42
}
 
43
 
 
44
func (*ImageMetadataSuite) assertCommandOutput(c *C, errOut, series, arch, indexFileName, imageFileName string) {
 
45
        strippedOut := strings.Replace(errOut, "\n", "", -1)
 
46
        c.Check(strippedOut, Matches, `Boilerplate image metadata files.*have been written.*Copy the files.*`)
 
47
        indexpath := testing.HomePath(".juju", indexFileName)
 
48
        data, err := ioutil.ReadFile(indexpath)
 
49
        c.Assert(err, IsNil)
 
50
        var indices interface{}
 
51
        err = json.Unmarshal(data, &indices)
 
52
        c.Assert(err, IsNil)
 
53
        c.Assert(indices.(map[string]interface{})["format"], Equals, "index:1.0")
 
54
        prodId := fmt.Sprintf("com.ubuntu.cloud:server:%s:%s", seriesVersions[series], arch)
 
55
        c.Assert(strings.Contains(string(data), prodId), Equals, true)
 
56
        c.Assert(strings.Contains(string(data), `"region": "region"`), Equals, true)
 
57
        c.Assert(strings.Contains(string(data), `"endpoint": "endpoint"`), Equals, true)
 
58
        c.Assert(strings.Contains(string(data), fmt.Sprintf(`"path": "streams/v1/%s"`, imageFileName)), Equals, true)
 
59
 
 
60
        imagepath := testing.HomePath(".juju", imageFileName)
 
61
        data, err = ioutil.ReadFile(imagepath)
 
62
        c.Assert(err, IsNil)
 
63
        var images interface{}
 
64
        err = json.Unmarshal(data, &images)
 
65
        c.Assert(err, IsNil)
 
66
        c.Assert(images.(map[string]interface{})["format"], Equals, "products:1.0")
 
67
        c.Assert(strings.Contains(string(data), prodId), Equals, true)
 
68
        c.Assert(strings.Contains(string(data), `"id": "1234"`), Equals, true)
 
69
}
 
70
 
 
71
const (
 
72
        defaultIndexFileName = "index.json"
 
73
        defaultImageFileName = "imagemetadata.json"
 
74
)
 
75
 
 
76
func (s *ImageMetadataSuite) TestImageMetadataFilesNoEnv(c *C) {
 
77
        defer testing.MakeEmptyFakeHome(c).Restore()
 
78
 
 
79
        ctx := testing.Context(c)
 
80
        code := cmd.Main(
 
81
                &ImageMetadataCommand{}, ctx, []string{"-i", "1234", "-r", "region", "-a", "arch", "-e", "endpoint", "-s", "raring"})
 
82
        c.Assert(code, Equals, 0)
 
83
        errOut := ctx.Stdout.(*bytes.Buffer).String()
 
84
        s.assertCommandOutput(c, errOut, "raring", "arch", defaultIndexFileName, defaultImageFileName)
 
85
}
 
86
 
 
87
func (s *ImageMetadataSuite) TestImageMetadataFilesWithName(c *C) {
 
88
        defer testing.MakeEmptyFakeHome(c).Restore()
 
89
 
 
90
        ctx := testing.Context(c)
 
91
        code := cmd.Main(
 
92
                &ImageMetadataCommand{}, ctx, []string{"-n", "foo", "-i", "1234", "-r", "region", "-a", "arch", "-e", "endpoint", "-s", "raring"})
 
93
        c.Assert(code, Equals, 0)
 
94
        errOut := ctx.Stdout.(*bytes.Buffer).String()
 
95
        s.assertCommandOutput(c, errOut, "raring", "arch", "foo-"+defaultIndexFileName, "foo-"+defaultImageFileName)
 
96
}
 
97
 
 
98
func (s *ImageMetadataSuite) TestImageMetadataFilesDefaultArch(c *C) {
 
99
        defer testing.MakeEmptyFakeHome(c).Restore()
 
100
 
 
101
        ctx := testing.Context(c)
 
102
        code := cmd.Main(
 
103
                &ImageMetadataCommand{}, ctx, []string{"-i", "1234", "-r", "region", "-e", "endpoint", "-s", "raring"})
 
104
        c.Assert(code, Equals, 0)
 
105
        errOut := ctx.Stdout.(*bytes.Buffer).String()
 
106
        s.assertCommandOutput(c, errOut, "raring", "amd64", defaultIndexFileName, defaultImageFileName)
 
107
}
 
108
 
 
109
func (s *ImageMetadataSuite) TestImageMetadataFilesDefaultSeries(c *C) {
 
110
        defer testing.MakeEmptyFakeHome(c).Restore()
 
111
 
 
112
        ctx := testing.Context(c)
 
113
        code := cmd.Main(
 
114
                &ImageMetadataCommand{}, ctx, []string{"-i", "1234", "-r", "region", "-a", "arch", "-e", "endpoint"})
 
115
        c.Assert(code, Equals, 0)
 
116
        errOut := ctx.Stdout.(*bytes.Buffer).String()
 
117
        s.assertCommandOutput(c, errOut, "precise", "arch", defaultIndexFileName, defaultImageFileName)
 
118
}
 
119
 
 
120
func (s *ImageMetadataSuite) TestImageMetadataFilesUsingEnvRegion(c *C) {
 
121
        defer testing.MakeEmptyFakeHome(c).Restore()
 
122
 
 
123
        os.Setenv("OS_REGION_NAME", "region")
 
124
        ctx := testing.Context(c)
 
125
        code := cmd.Main(
 
126
                &ImageMetadataCommand{}, ctx, []string{"-i", "1234", "-e", "endpoint"})
 
127
        c.Assert(code, Equals, 0)
 
128
        errOut := ctx.Stdout.(*bytes.Buffer).String()
 
129
        s.assertCommandOutput(c, errOut, "precise", "amd64", defaultIndexFileName, defaultImageFileName)
 
130
}
 
131
 
 
132
func (s *ImageMetadataSuite) TestImageMetadataFilesUsingEnvEndpoint(c *C) {
 
133
        defer testing.MakeEmptyFakeHome(c).Restore()
 
134
 
 
135
        os.Setenv("OS_AUTH_URL", "endpoint")
 
136
        ctx := testing.Context(c)
 
137
        code := cmd.Main(
 
138
                &ImageMetadataCommand{}, ctx, []string{"-i", "1234", "-r", "region"})
 
139
        c.Assert(code, Equals, 0)
 
140
        errOut := ctx.Stdout.(*bytes.Buffer).String()
 
141
        s.assertCommandOutput(c, errOut, "precise", "amd64", defaultIndexFileName, defaultImageFileName)
 
142
}
 
143
 
 
144
type errTestParams struct {
 
145
        args []string
 
146
}
 
147
 
 
148
var errTests = []errTestParams{
 
149
        {
 
150
                // Missing image id
 
151
                args: []string{"-r", "region", "-a", "arch", "-e", "endpoint", "-s", "precise"},
 
152
        },
 
153
        {
 
154
                // Missing region
 
155
                args: []string{"-i", "1234", "-a", "arch", "-e", "endpoint", "-s", "precise"},
 
156
        },
 
157
        {
 
158
                // Missing endpoint
 
159
                args: []string{"-i", "1234", "-e", "endpoint", "-a", "arch", "-s", "precise"},
 
160
        },
 
161
}
 
162
 
 
163
func (s *ImageMetadataSuite) TestImageMetadataBadArgs(c *C) {
 
164
        defer testing.MakeEmptyFakeHome(c).Restore()
 
165
        for i, t := range errTests {
 
166
                c.Logf("test: %d", i)
 
167
                ctx := testing.Context(c)
 
168
                code := cmd.Main(&ImageMetadataCommand{}, ctx, t.args)
 
169
                c.Check(code, Equals, 2)
 
170
        }
 
171
}