← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/featuretests/cmd_juju_model_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/featuretests/cmd_juju_model_test.go
 
1
// Copyright 2015 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package featuretests
 
5
 
 
6
import (
 
7
        "strings"
 
8
 
 
9
        "github.com/juju/cmd"
 
10
        "github.com/juju/errors"
 
11
        "github.com/juju/loggo"
 
12
        jc "github.com/juju/testing/checkers"
 
13
        gc "gopkg.in/check.v1"
 
14
        "gopkg.in/juju/names.v2"
 
15
 
 
16
        "github.com/juju/juju/cmd/juju/commands"
 
17
        "github.com/juju/juju/core/description"
 
18
        jujutesting "github.com/juju/juju/juju/testing"
 
19
        "github.com/juju/juju/state"
 
20
        "github.com/juju/juju/testing"
 
21
        "github.com/juju/juju/testing/factory"
 
22
)
 
23
 
 
24
type cmdModelSuite struct {
 
25
        jujutesting.RepoSuite
 
26
}
 
27
 
 
28
func (s *cmdModelSuite) SetUpTest(c *gc.C) {
 
29
        s.RepoSuite.SetUpTest(c)
 
30
}
 
31
 
 
32
func (s *cmdModelSuite) run(c *gc.C, args ...string) *cmd.Context {
 
33
        context := testing.Context(c)
 
34
        jujuCmd := commands.NewJujuCommand(context)
 
35
        err := testing.InitCommand(jujuCmd, args)
 
36
        c.Assert(err, jc.ErrorIsNil)
 
37
        err = jujuCmd.Run(context)
 
38
        c.Assert(err, jc.ErrorIsNil)
 
39
        return context
 
40
}
 
41
 
 
42
func (s *cmdModelSuite) TestGrantModelCmdStack(c *gc.C) {
 
43
        username := "bar@ubuntuone"
 
44
        context := s.run(c, "grant", username, "controller")
 
45
        obtained := strings.Replace(testing.Stdout(context), "\n", "", -1)
 
46
        expected := ""
 
47
        c.Assert(obtained, gc.Equals, expected)
 
48
 
 
49
        user := names.NewUserTag(username)
 
50
        modelUser, err := s.State.UserAccess(user, s.State.ModelTag())
 
51
        c.Assert(err, jc.ErrorIsNil)
 
52
        c.Assert(modelUser.UserName, gc.Equals, user.Canonical())
 
53
        c.Assert(modelUser.CreatedBy.Canonical(), gc.Equals, s.AdminUserTag(c).Canonical())
 
54
        lastConn, err := s.State.LastModelConnection(modelUser.UserTag)
 
55
        c.Assert(err, jc.Satisfies, state.IsNeverConnectedError)
 
56
        c.Assert(lastConn.IsZero(), jc.IsTrue)
 
57
}
 
58
 
 
59
func (s *cmdModelSuite) TestRevokeModelCmdStack(c *gc.C) {
 
60
        // Firstly share a model with a user
 
61
        username := "bar@ubuntuone"
 
62
        s.Factory.MakeModelUser(c, &factory.ModelUserParams{
 
63
                User: username, Access: description.ReadAccess})
 
64
 
 
65
        // Because we are calling into juju through the main command,
 
66
        // and the main command adds a warning logging writer, we need
 
67
        // to clear the logging writers here.
 
68
        loggo.RemoveWriter("warning")
 
69
 
 
70
        // Then test that the unshare command stack is hooked up
 
71
        context := s.run(c, "revoke", username, "controller")
 
72
        obtained := strings.Replace(testing.Stdout(context), "\n", "", -1)
 
73
        expected := ""
 
74
        c.Assert(obtained, gc.Equals, expected)
 
75
 
 
76
        user := names.NewUserTag(username)
 
77
        modelUser, err := s.State.UserAccess(user, s.State.ModelTag())
 
78
        c.Assert(errors.IsNotFound(err), jc.IsTrue)
 
79
        c.Assert(modelUser, gc.DeepEquals, description.UserAccess{})
 
80
}
 
81
 
 
82
func (s *cmdModelSuite) TestModelUsersCmd(c *gc.C) {
 
83
        // Firstly share an model with a user
 
84
        username := "bar@ubuntuone"
 
85
        context := s.run(c, "grant", username, "controller")
 
86
        user := names.NewUserTag(username)
 
87
        modelUser, err := s.State.UserAccess(user, s.State.ModelTag())
 
88
        c.Assert(err, jc.ErrorIsNil)
 
89
        c.Assert(modelUser, gc.NotNil)
 
90
 
 
91
        // Because we are calling into juju through the main command,
 
92
        // and the main command adds a warning logging writer, we need
 
93
        // to clear the logging writers here.
 
94
        loggo.RemoveWriter("warning")
 
95
 
 
96
        context = s.run(c, "list-shares")
 
97
        c.Assert(err, jc.ErrorIsNil)
 
98
        c.Assert(testing.Stdout(context), gc.Equals, ""+
 
99
                "NAME                 ACCESS  LAST CONNECTION\n"+
 
100
                "admin@local (admin)  admin   just now\n"+
 
101
                "bar@ubuntuone        read    never connected\n"+
 
102
                "\n")
 
103
 
 
104
}
 
105
 
 
106
func (s *cmdModelSuite) TestGet(c *gc.C) {
 
107
        err := s.State.UpdateModelConfig(map[string]interface{}{"special": "known"}, nil, nil)
 
108
        c.Assert(err, jc.ErrorIsNil)
 
109
 
 
110
        context := s.run(c, "get-model-config", "special")
 
111
        c.Assert(testing.Stdout(context), gc.Equals, "known\n")
 
112
}
 
113
 
 
114
func (s *cmdModelSuite) TestSet(c *gc.C) {
 
115
        s.run(c, "set-model-config", "special=known")
 
116
        s.assertEnvValue(c, "special", "known")
 
117
}
 
118
 
 
119
func (s *cmdModelSuite) TestUnset(c *gc.C) {
 
120
        err := s.State.UpdateModelConfig(map[string]interface{}{"special": "known"}, nil, nil)
 
121
        c.Assert(err, jc.ErrorIsNil)
 
122
 
 
123
        s.run(c, "unset-model-config", "special")
 
124
        s.assertEnvValueMissing(c, "special")
 
125
}
 
126
 
 
127
func (s *cmdModelSuite) TestRetryProvisioning(c *gc.C) {
 
128
        s.Factory.MakeMachine(c, &factory.MachineParams{
 
129
                Jobs: []state.MachineJob{state.JobManageModel},
 
130
        })
 
131
        ctx := s.run(c, "retry-provisioning", "0")
 
132
        output := testing.Stderr(ctx)
 
133
        stripped := strings.Replace(output, "\n", "", -1)
 
134
        c.Check(stripped, gc.Equals, `machine 0 is not in an error state`)
 
135
}
 
136
 
 
137
func (s *cmdModelSuite) assertEnvValue(c *gc.C, key string, expected interface{}) {
 
138
        envConfig, err := s.State.ModelConfig()
 
139
        c.Assert(err, jc.ErrorIsNil)
 
140
        value, found := envConfig.AllAttrs()[key]
 
141
        c.Assert(found, jc.IsTrue)
 
142
        c.Assert(value, gc.Equals, expected)
 
143
}
 
144
 
 
145
func (s *cmdModelSuite) assertEnvValueMissing(c *gc.C, key string) {
 
146
        envConfig, err := s.State.ModelConfig()
 
147
        c.Assert(err, jc.ErrorIsNil)
 
148
        _, found := envConfig.AllAttrs()[key]
 
149
        c.Assert(found, jc.IsFalse)
 
150
}