← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/apiserver/common/cloudspec/cloudspec_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/common/cloudspec/cloudspec_test.go
 
1
// Copyright 2016 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package cloudspec_test
 
5
 
 
6
import (
 
7
        "errors"
 
8
 
 
9
        "github.com/juju/testing"
 
10
        jc "github.com/juju/testing/checkers"
 
11
        "github.com/juju/utils"
 
12
        gc "gopkg.in/check.v1"
 
13
        names "gopkg.in/juju/names.v2"
 
14
 
 
15
        "github.com/juju/juju/apiserver/common"
 
16
        "github.com/juju/juju/apiserver/common/cloudspec"
 
17
        "github.com/juju/juju/apiserver/params"
 
18
        "github.com/juju/juju/cloud"
 
19
        "github.com/juju/juju/environs"
 
20
        coretesting "github.com/juju/juju/testing"
 
21
)
 
22
 
 
23
type CloudSpecSuite struct {
 
24
        testing.IsolationSuite
 
25
        testing.Stub
 
26
        result   environs.CloudSpec
 
27
        authFunc common.AuthFunc
 
28
        api      cloudspec.CloudSpecAPI
 
29
}
 
30
 
 
31
var _ = gc.Suite(&CloudSpecSuite{})
 
32
 
 
33
func (s *CloudSpecSuite) SetUpTest(c *gc.C) {
 
34
        s.IsolationSuite.SetUpTest(c)
 
35
        s.Stub.ResetCalls()
 
36
 
 
37
        s.authFunc = func(tag names.Tag) bool {
 
38
                s.AddCall("Auth", tag)
 
39
                return tag == coretesting.ModelTag
 
40
        }
 
41
        s.api = cloudspec.NewCloudSpec(func(tag names.ModelTag) (environs.CloudSpec, error) {
 
42
                s.AddCall("CloudSpec", tag)
 
43
                return s.result, s.NextErr()
 
44
        }, func() (common.AuthFunc, error) {
 
45
                s.AddCall("GetAuthFunc")
 
46
                return s.authFunc, s.NextErr()
 
47
        })
 
48
 
 
49
        credential := cloud.NewCredential(
 
50
                "auth-type",
 
51
                map[string]string{"k": "v"},
 
52
        )
 
53
        s.result = environs.CloudSpec{
 
54
                "type",
 
55
                "name",
 
56
                "region",
 
57
                "endpoint",
 
58
                "storage-endpoint",
 
59
                &credential,
 
60
        }
 
61
}
 
62
 
 
63
func (s *CloudSpecSuite) TestCloudSpec(c *gc.C) {
 
64
        otherModelTag := names.NewModelTag(utils.MustNewUUID().String())
 
65
        machineTag := names.NewMachineTag("42")
 
66
        result, err := s.api.CloudSpec(params.Entities{Entities: []params.Entity{
 
67
                {coretesting.ModelTag.String()},
 
68
                {otherModelTag.String()},
 
69
                {machineTag.String()},
 
70
        }})
 
71
        c.Assert(err, jc.ErrorIsNil)
 
72
        c.Assert(result.Results, jc.DeepEquals, []params.CloudSpecResult{{
 
73
                Result: &params.CloudSpec{
 
74
                        "type",
 
75
                        "name",
 
76
                        "region",
 
77
                        "endpoint",
 
78
                        "storage-endpoint",
 
79
                        &params.CloudCredential{
 
80
                                "auth-type",
 
81
                                map[string]string{"k": "v"},
 
82
                        },
 
83
                },
 
84
        }, {
 
85
                Error: &params.Error{
 
86
                        Code:    params.CodeUnauthorized,
 
87
                        Message: "permission denied",
 
88
                },
 
89
        }, {
 
90
                Error: &params.Error{
 
91
                        Message: `"machine-42" is not a valid model tag`,
 
92
                },
 
93
        }})
 
94
        s.CheckCalls(c, []testing.StubCall{
 
95
                {"GetAuthFunc", nil},
 
96
                {"Auth", []interface{}{coretesting.ModelTag}},
 
97
                {"CloudSpec", []interface{}{coretesting.ModelTag}},
 
98
                {"Auth", []interface{}{otherModelTag}},
 
99
        })
 
100
}
 
101
 
 
102
func (s *CloudSpecSuite) TestCloudSpecNilCredential(c *gc.C) {
 
103
        s.result.Credential = nil
 
104
        result, err := s.api.CloudSpec(params.Entities{
 
105
                Entities: []params.Entity{{coretesting.ModelTag.String()}},
 
106
        })
 
107
        c.Assert(err, jc.ErrorIsNil)
 
108
        c.Assert(result.Results, jc.DeepEquals, []params.CloudSpecResult{{
 
109
                Result: &params.CloudSpec{
 
110
                        "type",
 
111
                        "name",
 
112
                        "region",
 
113
                        "endpoint",
 
114
                        "storage-endpoint",
 
115
                        nil,
 
116
                },
 
117
        }})
 
118
}
 
119
 
 
120
func (s *CloudSpecSuite) TestCloudSpecGetAuthFuncError(c *gc.C) {
 
121
        expect := errors.New("bewm")
 
122
        s.SetErrors(expect)
 
123
        result, err := s.api.CloudSpec(params.Entities{
 
124
                Entities: []params.Entity{{coretesting.ModelTag.String()}},
 
125
        })
 
126
        c.Assert(err, gc.Equals, expect)
 
127
        c.Assert(result, jc.DeepEquals, params.CloudSpecResults{})
 
128
}
 
129
 
 
130
func (s *CloudSpecSuite) TestCloudSpecCloudSpecError(c *gc.C) {
 
131
        s.SetErrors(nil, errors.New("bewm"))
 
132
        result, err := s.api.CloudSpec(params.Entities{
 
133
                Entities: []params.Entity{{coretesting.ModelTag.String()}},
 
134
        })
 
135
        c.Assert(err, jc.ErrorIsNil)
 
136
        c.Assert(result, jc.DeepEquals, params.CloudSpecResults{Results: []params.CloudSpecResult{{
 
137
                Error: &params.Error{Message: "bewm"},
 
138
        }}})
 
139
}