← Back to branch summary

~juju-qa/ubuntu/yakkety/juju/juju-1.25.8

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/environs/tools/validation_test.go

  • Committer: Nicholas Skaggs
  • Date: 2016-12-02 17:28:37 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161202172837-jkrbdlyjcxtrii2n
Initial commit of 1.25.6

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/environs/tools/validation_test.go
 
1
// Copyright 2012, 2013 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package tools
 
5
 
 
6
import (
 
7
        "path"
 
8
 
 
9
        jc "github.com/juju/testing/checkers"
 
10
        "github.com/juju/utils"
 
11
        gc "gopkg.in/check.v1"
 
12
 
 
13
        "github.com/juju/juju/environs/filestorage"
 
14
        "github.com/juju/juju/environs/simplestreams"
 
15
        "github.com/juju/juju/testing"
 
16
)
 
17
 
 
18
type ValidateSuite struct {
 
19
        testing.BaseSuite
 
20
        metadataDir string
 
21
}
 
22
 
 
23
var _ = gc.Suite(&ValidateSuite{})
 
24
 
 
25
func (s *ValidateSuite) makeLocalMetadata(c *gc.C, stream, version, series string) error {
 
26
        tm := []*ToolsMetadata{{
 
27
                Version:  version,
 
28
                Release:  series,
 
29
                Arch:     "amd64",
 
30
                Path:     "/tools/tools.tar.gz",
 
31
                Size:     1234,
 
32
                FileType: "tar.gz",
 
33
                SHA256:   "f65a92b3b41311bdf398663ee1c5cd0c",
 
34
        }}
 
35
 
 
36
        stor, err := filestorage.NewFileStorageWriter(s.metadataDir)
 
37
        c.Assert(err, jc.ErrorIsNil)
 
38
        streamMetadata := map[string][]*ToolsMetadata{
 
39
                stream: tm,
 
40
        }
 
41
        err = WriteMetadata(stor, streamMetadata, []string{stream}, false)
 
42
        c.Assert(err, jc.ErrorIsNil)
 
43
        return nil
 
44
}
 
45
 
 
46
func (s *ValidateSuite) SetUpTest(c *gc.C) {
 
47
        s.BaseSuite.SetUpTest(c)
 
48
        s.metadataDir = c.MkDir()
 
49
}
 
50
 
 
51
func (s *ValidateSuite) toolsURL() string {
 
52
        return utils.MakeFileURL(path.Join(s.metadataDir, "tools"))
 
53
}
 
54
 
 
55
func (s *ValidateSuite) TestExactVersionMatch(c *gc.C) {
 
56
        s.makeLocalMetadata(c, "released", "1.11.2", "raring")
 
57
        params := &ToolsMetadataLookupParams{
 
58
                Version: "1.11.2",
 
59
                MetadataLookupParams: simplestreams.MetadataLookupParams{
 
60
                        Region:        "region-2",
 
61
                        Series:        "raring",
 
62
                        Architectures: []string{"amd64"},
 
63
                        Endpoint:      "some-auth-url",
 
64
                        Stream:        "released",
 
65
                        Sources: []simplestreams.DataSource{
 
66
                                simplestreams.NewURLDataSource("test", s.toolsURL(), utils.VerifySSLHostnames)},
 
67
                },
 
68
        }
 
69
        versions, resolveInfo, err := ValidateToolsMetadata(params)
 
70
        c.Assert(err, jc.ErrorIsNil)
 
71
        c.Assert(versions, gc.DeepEquals, []string{"1.11.2-raring-amd64"})
 
72
        c.Check(resolveInfo, gc.DeepEquals, &simplestreams.ResolveInfo{
 
73
                Source:    "test",
 
74
                Signed:    false,
 
75
                IndexURL:  utils.MakeFileURL(path.Join(s.metadataDir, "tools/streams/v1/index2.json")),
 
76
                MirrorURL: "",
 
77
        })
 
78
}
 
79
 
 
80
func (s *ValidateSuite) TestMajorVersionMatch(c *gc.C) {
 
81
        s.makeLocalMetadata(c, "released", "1.11.2", "raring")
 
82
        params := &ToolsMetadataLookupParams{
 
83
                Major: 1,
 
84
                Minor: -1,
 
85
                MetadataLookupParams: simplestreams.MetadataLookupParams{
 
86
                        Region:        "region-2",
 
87
                        Series:        "raring",
 
88
                        Architectures: []string{"amd64"},
 
89
                        Endpoint:      "some-auth-url",
 
90
                        Stream:        "released",
 
91
                        Sources: []simplestreams.DataSource{
 
92
                                simplestreams.NewURLDataSource("test", s.toolsURL(), utils.VerifySSLHostnames)},
 
93
                },
 
94
        }
 
95
        versions, resolveInfo, err := ValidateToolsMetadata(params)
 
96
        c.Assert(err, jc.ErrorIsNil)
 
97
        c.Assert(versions, gc.DeepEquals, []string{"1.11.2-raring-amd64"})
 
98
        c.Check(resolveInfo, gc.DeepEquals, &simplestreams.ResolveInfo{
 
99
                Source:    "test",
 
100
                Signed:    false,
 
101
                IndexURL:  utils.MakeFileURL(path.Join(s.metadataDir, "tools/streams/v1/index2.json")),
 
102
                MirrorURL: "",
 
103
        })
 
104
}
 
105
 
 
106
func (s *ValidateSuite) TestMajorMinorVersionMatch(c *gc.C) {
 
107
        s.makeLocalMetadata(c, "released", "1.11.2", "raring")
 
108
        params := &ToolsMetadataLookupParams{
 
109
                Major: 1,
 
110
                Minor: 11,
 
111
                MetadataLookupParams: simplestreams.MetadataLookupParams{
 
112
                        Region:        "region-2",
 
113
                        Series:        "raring",
 
114
                        Architectures: []string{"amd64"},
 
115
                        Endpoint:      "some-auth-url",
 
116
                        Stream:        "released",
 
117
                        Sources: []simplestreams.DataSource{
 
118
                                simplestreams.NewURLDataSource("test", s.toolsURL(), utils.VerifySSLHostnames)},
 
119
                },
 
120
        }
 
121
        versions, resolveInfo, err := ValidateToolsMetadata(params)
 
122
        c.Assert(err, jc.ErrorIsNil)
 
123
        c.Assert(versions, gc.DeepEquals, []string{"1.11.2-raring-amd64"})
 
124
        c.Check(resolveInfo, gc.DeepEquals, &simplestreams.ResolveInfo{
 
125
                Source:    "test",
 
126
                Signed:    false,
 
127
                IndexURL:  utils.MakeFileURL(path.Join(s.metadataDir, "tools/streams/v1/index2.json")),
 
128
                MirrorURL: "",
 
129
        })
 
130
}
 
131
 
 
132
func (s *ValidateSuite) TestNoMatch(c *gc.C) {
 
133
        s.makeLocalMetadata(c, "released", "1.11.2", "raring")
 
134
        params := &ToolsMetadataLookupParams{
 
135
                Version: "1.11.2",
 
136
                MetadataLookupParams: simplestreams.MetadataLookupParams{
 
137
                        Region:        "region-2",
 
138
                        Series:        "precise",
 
139
                        Architectures: []string{"amd64"},
 
140
                        Endpoint:      "some-auth-url",
 
141
                        Stream:        "released",
 
142
                        Sources: []simplestreams.DataSource{
 
143
                                simplestreams.NewURLDataSource("test", s.toolsURL(), utils.VerifySSLHostnames)},
 
144
                },
 
145
        }
 
146
        _, _, err := ValidateToolsMetadata(params)
 
147
        c.Assert(err, gc.Not(gc.IsNil))
 
148
}
 
149
 
 
150
func (s *ValidateSuite) TestStreamsNoMatch(c *gc.C) {
 
151
        s.makeLocalMetadata(c, "proposed", "1.11.2", "raring")
 
152
        params := &ToolsMetadataLookupParams{
 
153
                Version: "1.11.2",
 
154
                MetadataLookupParams: simplestreams.MetadataLookupParams{
 
155
                        Region:        "region-2",
 
156
                        Series:        "raring",
 
157
                        Architectures: []string{"amd64"},
 
158
                        Endpoint:      "some-auth-url",
 
159
                        Stream:        "testing",
 
160
                        Sources: []simplestreams.DataSource{
 
161
                                simplestreams.NewURLDataSource("test", s.toolsURL(), utils.VerifySSLHostnames)},
 
162
                },
 
163
        }
 
164
        _, _, err := ValidateToolsMetadata(params)
 
165
        c.Assert(err, gc.Not(gc.IsNil))
 
166
}