← Back to branch summary

~juju-qa/ubuntu/xenial/juju/2.0-rc2

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/cmd/modelcmd/credentials_test.go

  • Committer: Nicholas Skaggs
  • Date: 2016-09-30 14:39:30 UTC
  • mfrom: (1.8.1)
  • Revision ID: nicholas.skaggs@canonical.com-20160930143930-vwwhrefh6ftckccy
import upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/cmd/modelcmd/credentials_test.go
4
4
package modelcmd_test
5
5
 
6
6
import (
 
7
        "fmt"
 
8
 
7
9
        jc "github.com/juju/testing/checkers"
8
10
        gc "gopkg.in/check.v1"
9
11
 
42
44
        }
43
45
        return map[cloud.AuthType]cloud.CredentialSchema{
44
46
                cloud.UserPassAuthType: schema,
45
 
        }
 
47
                "interactive": cloud.CredentialSchema{
 
48
                        {"username", cloud.CredentialAttr{}},
 
49
                },
 
50
        }
 
51
}
 
52
 
 
53
func (mockProvider) FinalizeCredential(
 
54
        ctx environs.FinalizeCredentialContext,
 
55
        args environs.FinalizeCredentialParams,
 
56
) (*cloud.Credential, error) {
 
57
        if args.Credential.AuthType() == "interactive" {
 
58
                username := args.Credential.Attributes()["username"]
 
59
                fmt.Fprintf(ctx.GetStderr(), "generating credential for %q\n", username)
 
60
                out := cloud.NewCredential(cloud.UserPassAuthType, map[string]string{
 
61
                        "username": username,
 
62
                        "password": "sekret",
 
63
                        "key":      "value",
 
64
                })
 
65
                return &out, nil
 
66
        }
 
67
        return &args.Credential, nil
46
68
}
47
69
 
48
70
type credentialsSuite struct {
49
71
        testing.FakeJujuXDGDataHomeSuite
 
72
        cloud cloud.Cloud
 
73
        store *jujuclienttesting.MemStore
50
74
}
51
75
 
52
76
var _ = gc.Suite(&credentialsSuite{})
53
77
 
54
 
func (s *credentialsSuite) assertGetCredentials(c *gc.C, region string) {
 
78
func (s *credentialsSuite) SetUpTest(c *gc.C) {
 
79
        s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
 
80
        s.cloud = cloud.Cloud{
 
81
                Type: "fake",
 
82
                Regions: []cloud.Region{
 
83
                        {Name: "first-region"},
 
84
                        {Name: "second-region"},
 
85
                },
 
86
        }
 
87
 
55
88
        dir := c.MkDir()
56
89
        keyFile := filepath.Join(dir, "keyfile")
57
90
        err := ioutil.WriteFile(keyFile, []byte("value"), 0600)
58
91
        c.Assert(err, jc.ErrorIsNil)
59
92
 
60
 
        store := jujuclienttesting.NewMemStore()
61
 
        store.Credentials["cloud"] = cloud.CloudCredential{
62
 
                DefaultRegion: "default-region",
 
93
        s.store = jujuclienttesting.NewMemStore()
 
94
        s.store.Credentials["cloud"] = cloud.CloudCredential{
 
95
                DefaultRegion: "second-region",
63
96
                AuthCredentials: map[string]cloud.Credential{
 
97
                        "interactive": cloud.NewCredential("interactive", map[string]string{
 
98
                                "username": "user",
 
99
                        }),
64
100
                        "secrets": cloud.NewCredential(cloud.UserPassAuthType, map[string]string{
65
101
                                "username": "user",
66
102
                                "password": "sekret",
68
104
                        }),
69
105
                },
70
106
        }
 
107
}
71
108
 
 
109
func (s *credentialsSuite) assertGetCredentials(c *gc.C, cred, region string) {
72
110
        credential, credentialName, regionName, err := modelcmd.GetCredentials(
73
 
                store, region, "secrets", "cloud", "fake",
 
111
                testing.Context(c), s.store, modelcmd.GetCredentialsParams{
 
112
                        Cloud:          s.cloud,
 
113
                        CloudName:      "cloud",
 
114
                        CloudRegion:    region,
 
115
                        CredentialName: cred,
 
116
                },
74
117
        )
75
118
        c.Assert(err, jc.ErrorIsNil)
76
119
        expectedRegion := region
77
120
        if expectedRegion == "" {
78
 
                expectedRegion = "default-region"
 
121
                expectedRegion = s.store.Credentials["cloud"].DefaultRegion
 
122
                if expectedRegion == "" && len(s.cloud.Regions) > 0 {
 
123
                        expectedRegion = "first-region"
 
124
                }
79
125
        }
80
126
        c.Assert(regionName, gc.Equals, expectedRegion)
81
 
        c.Assert(credentialName, gc.Equals, "secrets")
 
127
        c.Assert(credentialName, gc.Equals, cred)
82
128
        c.Assert(credential.Attributes(), jc.DeepEquals, map[string]string{
83
129
                "key":      "value",
84
130
                "username": "user",
86
132
        })
87
133
}
88
134
 
89
 
func (s *credentialsSuite) TestGetCredentialsDefaultRegion(c *gc.C) {
90
 
        s.assertGetCredentials(c, "")
 
135
func (s *credentialsSuite) TestGetCredentialsUserDefaultRegion(c *gc.C) {
 
136
        s.assertGetCredentials(c, "secrets", "")
 
137
}
 
138
 
 
139
func (s *credentialsSuite) TestGetCredentialsCloudDefaultRegion(c *gc.C) {
 
140
        creds := s.store.Credentials["cloud"]
 
141
        creds.DefaultRegion = ""
 
142
        s.store.Credentials["cloud"] = creds
 
143
        s.assertGetCredentials(c, "secrets", "")
 
144
}
 
145
 
 
146
func (s *credentialsSuite) TestGetCredentialsNoRegion(c *gc.C) {
 
147
        creds := s.store.Credentials["cloud"]
 
148
        creds.DefaultRegion = ""
 
149
        s.store.Credentials["cloud"] = creds
 
150
        s.cloud.Regions = nil
 
151
        s.assertGetCredentials(c, "secrets", "")
91
152
}
92
153
 
93
154
func (s *credentialsSuite) TestGetCredentials(c *gc.C) {
94
 
        s.assertGetCredentials(c, "region")
 
155
        s.cloud.Regions = append(s.cloud.Regions, cloud.Region{Name: "third-region"})
 
156
        s.assertGetCredentials(c, "secrets", "third-region")
 
157
}
 
158
 
 
159
func (s *credentialsSuite) TestGetCredentialsProviderFinalizeCredential(c *gc.C) {
 
160
        s.assertGetCredentials(c, "interactive", "")
95
161
}