← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/apiserver/imagemetadata/functions_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/juju/apiserver/imagemetadata/functions_test.go
 
1
// Copyright 2015 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package imagemetadata_test
 
5
 
 
6
import (
 
7
        "fmt"
 
8
 
 
9
        jc "github.com/juju/testing/checkers"
 
10
        "github.com/juju/utils/series"
 
11
        gc "gopkg.in/check.v1"
 
12
 
 
13
        "github.com/juju/juju/apiserver/imagemetadata"
 
14
        "github.com/juju/juju/apiserver/params"
 
15
        "github.com/juju/juju/environs/config"
 
16
        "github.com/juju/juju/state/cloudimagemetadata"
 
17
        "github.com/juju/juju/testing"
 
18
)
 
19
 
 
20
type funcSuite struct {
 
21
        baseImageMetadataSuite
 
22
 
 
23
        cfg      *config.Config
 
24
        expected cloudimagemetadata.Metadata
 
25
}
 
26
 
 
27
var _ = gc.Suite(&funcSuite{})
 
28
 
 
29
func (s *funcSuite) SetUpTest(c *gc.C) {
 
30
        s.baseImageMetadataSuite.SetUpTest(c)
 
31
 
 
32
        cfg, err := config.New(config.NoDefaults, mockConfig())
 
33
        c.Assert(err, jc.ErrorIsNil)
 
34
        s.cfg = cfg
 
35
        s.state = s.constructState(s.cfg, nil)
 
36
 
 
37
        s.expected = cloudimagemetadata.Metadata{
 
38
                cloudimagemetadata.MetadataAttributes{
 
39
                        Stream: "released",
 
40
                        Source: "custom",
 
41
                        Series: series.LatestLts(),
 
42
                        Arch:   "amd64",
 
43
                        Region: "dummy_region",
 
44
                },
 
45
                0,
 
46
                "",
 
47
        }
 
48
}
 
49
 
 
50
func (s *funcSuite) TestParseMetadataNoSource(c *gc.C) {
 
51
        m, err := imagemetadata.ParseMetadataFromParams(s.api, params.CloudImageMetadata{}, s.cfg, "dummy_region")
 
52
        c.Assert(err, jc.ErrorIsNil)
 
53
        c.Assert(m, gc.DeepEquals, s.expected)
 
54
}
 
55
 
 
56
func (s *funcSuite) TestParseMetadataAnySource(c *gc.C) {
 
57
        s.expected.Source = "any"
 
58
        m, err := imagemetadata.ParseMetadataFromParams(s.api, params.CloudImageMetadata{Source: "any"}, s.cfg, "dummy_region")
 
59
        c.Assert(err, jc.ErrorIsNil)
 
60
        c.Assert(m, gc.DeepEquals, s.expected)
 
61
}
 
62
 
 
63
func (s *funcSuite) TestParseMetadataAnyStream(c *gc.C) {
 
64
        stream := "happy stream"
 
65
        s.expected.Stream = stream
 
66
 
 
67
        m, err := imagemetadata.ParseMetadataFromParams(s.api, params.CloudImageMetadata{Stream: stream}, s.cfg, "dummy_region")
 
68
        c.Assert(err, jc.ErrorIsNil)
 
69
        c.Assert(m, gc.DeepEquals, s.expected)
 
70
}
 
71
 
 
72
func (s *funcSuite) TestParseMetadataDefaultStream(c *gc.C) {
 
73
        m, err := imagemetadata.ParseMetadataFromParams(s.api, params.CloudImageMetadata{}, s.cfg, "dummy_region")
 
74
        c.Assert(err, jc.ErrorIsNil)
 
75
        c.Assert(m, gc.DeepEquals, s.expected)
 
76
}
 
77
 
 
78
func (s *funcSuite) TestParseMetadataAnyRegion(c *gc.C) {
 
79
        region := "region"
 
80
        s.expected.Region = region
 
81
 
 
82
        m, err := imagemetadata.ParseMetadataFromParams(s.api, params.CloudImageMetadata{Region: region}, s.cfg, "dummy_region")
 
83
        c.Assert(err, jc.ErrorIsNil)
 
84
        c.Assert(m, gc.DeepEquals, s.expected)
 
85
}
 
86
 
 
87
type funcMetadataSuite struct {
 
88
        testing.BaseSuite
 
89
}
 
90
 
 
91
var _ = gc.Suite(&funcMetadataSuite{})
 
92
 
 
93
func (s *funcMetadataSuite) TestProcessErrorsNil(c *gc.C) {
 
94
        s.assertProcessErrorsNone(c, nil)
 
95
}
 
96
 
 
97
func (s *funcMetadataSuite) TestProcessErrorsEmpty(c *gc.C) {
 
98
        s.assertProcessErrorsNone(c, []params.ErrorResult{})
 
99
}
 
100
 
 
101
func (s *funcMetadataSuite) TestProcessErrorsNilError(c *gc.C) {
 
102
        s.assertProcessErrorsNone(c, []params.ErrorResult{{Error: nil}})
 
103
}
 
104
 
 
105
func (s *funcMetadataSuite) TestProcessErrorsEmptyMessageError(c *gc.C) {
 
106
        s.assertProcessErrorsNone(c, []params.ErrorResult{{Error: &params.Error{Message: ""}}})
 
107
}
 
108
 
 
109
func (s *funcMetadataSuite) TestProcessErrorsFullError(c *gc.C) {
 
110
        msg := "my bad"
 
111
 
 
112
        errs := []params.ErrorResult{{Error: &params.Error{Message: msg}}}
 
113
 
 
114
        expected := fmt.Sprintf(`
 
115
saving some image metadata:
 
116
%v`[1:], msg)
 
117
 
 
118
        s.assertProcessErrors(c, errs, expected)
 
119
}
 
120
 
 
121
func (s *funcMetadataSuite) TestProcessErrorsMany(c *gc.C) {
 
122
        msg1 := "my bad"
 
123
        msg2 := "my good"
 
124
 
 
125
        errs := []params.ErrorResult{
 
126
                {Error: &params.Error{Message: msg1}},
 
127
                {Error: &params.Error{Message: ""}},
 
128
                {Error: nil},
 
129
                {Error: &params.Error{Message: msg2}},
 
130
        }
 
131
 
 
132
        expected := fmt.Sprintf(`
 
133
saving some image metadata:
 
134
%v
 
135
%v`[1:], msg1, msg2)
 
136
 
 
137
        s.assertProcessErrors(c, errs, expected)
 
138
}
 
139
 
 
140
var process = imagemetadata.ProcessErrors
 
141
 
 
142
func (s *funcMetadataSuite) assertProcessErrorsNone(c *gc.C, errs []params.ErrorResult) {
 
143
        c.Assert(process(errs), jc.ErrorIsNil)
 
144
}
 
145
 
 
146
func (s *funcMetadataSuite) assertProcessErrors(c *gc.C, errs []params.ErrorResult, expected string) {
 
147
        c.Assert(process(errs), gc.ErrorMatches, expected)
 
148
}