← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/apiserver/uniter/uniter_test.go

  • Committer: Martin Packman
  • Date: 2016-03-30 19:31:08 UTC
  • mfrom: (1.1.41)
  • Revision ID: martin.packman@canonical.com-20160330193108-h9iz3ak334uk0z5r
Merge new upstream source 2.0~beta3

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/apiserver/uniter/uniter_test.go
24
24
        "github.com/juju/juju/state"
25
25
        "github.com/juju/juju/state/multiwatcher"
26
26
        statetesting "github.com/juju/juju/state/testing"
 
27
        "github.com/juju/juju/status"
27
28
        coretesting "github.com/juju/juju/testing"
28
29
        "github.com/juju/juju/testing/factory"
29
30
        jujuFactory "github.com/juju/juju/testing/factory"
134
135
}
135
136
 
136
137
func (s *uniterSuite) TestSetStatus(c *gc.C) {
137
 
        err := s.wordpressUnit.SetAgentStatus(state.StatusExecuting, "blah", nil)
 
138
        err := s.wordpressUnit.SetAgentStatus(status.StatusExecuting, "blah", nil)
138
139
        c.Assert(err, jc.ErrorIsNil)
139
 
        err = s.mysqlUnit.SetAgentStatus(state.StatusExecuting, "foo", nil)
 
140
        err = s.mysqlUnit.SetAgentStatus(status.StatusExecuting, "foo", nil)
140
141
        c.Assert(err, jc.ErrorIsNil)
141
142
 
142
143
        args := params.SetStatus{
143
144
                Entities: []params.EntityStatusArgs{
144
 
                        {Tag: "unit-mysql-0", Status: params.StatusError, Info: "not really"},
145
 
                        {Tag: "unit-wordpress-0", Status: params.StatusRebooting, Info: "foobar"},
146
 
                        {Tag: "unit-foo-42", Status: params.StatusActive, Info: "blah"},
 
145
                        {Tag: "unit-mysql-0", Status: status.StatusError, Info: "not really"},
 
146
                        {Tag: "unit-wordpress-0", Status: status.StatusRebooting, Info: "foobar"},
 
147
                        {Tag: "unit-foo-42", Status: status.StatusActive, Info: "blah"},
147
148
                }}
148
149
        result, err := s.uniter.SetStatus(args)
149
150
        c.Assert(err, jc.ErrorIsNil)
158
159
        // Verify mysqlUnit - no change.
159
160
        statusInfo, err := s.mysqlUnit.AgentStatus()
160
161
        c.Assert(err, jc.ErrorIsNil)
161
 
        c.Assert(statusInfo.Status, gc.Equals, state.StatusExecuting)
 
162
        c.Assert(statusInfo.Status, gc.Equals, status.StatusExecuting)
162
163
        c.Assert(statusInfo.Message, gc.Equals, "foo")
163
164
        // ...wordpressUnit is fine though.
164
165
        statusInfo, err = s.wordpressUnit.AgentStatus()
165
166
        c.Assert(err, jc.ErrorIsNil)
166
 
        c.Assert(statusInfo.Status, gc.Equals, state.StatusRebooting)
 
167
        c.Assert(statusInfo.Status, gc.Equals, status.StatusRebooting)
167
168
        c.Assert(statusInfo.Message, gc.Equals, "foobar")
168
169
}
169
170
 
170
171
func (s *uniterSuite) TestSetAgentStatus(c *gc.C) {
171
 
        err := s.wordpressUnit.SetAgentStatus(state.StatusExecuting, "blah", nil)
 
172
        err := s.wordpressUnit.SetAgentStatus(status.StatusExecuting, "blah", nil)
172
173
        c.Assert(err, jc.ErrorIsNil)
173
 
        err = s.mysqlUnit.SetAgentStatus(state.StatusExecuting, "foo", nil)
 
174
        err = s.mysqlUnit.SetAgentStatus(status.StatusExecuting, "foo", nil)
174
175
        c.Assert(err, jc.ErrorIsNil)
175
176
 
176
177
        args := params.SetStatus{
177
178
                Entities: []params.EntityStatusArgs{
178
 
                        {Tag: "unit-mysql-0", Status: params.StatusError, Info: "not really"},
179
 
                        {Tag: "unit-wordpress-0", Status: params.StatusExecuting, Info: "foobar"},
180
 
                        {Tag: "unit-foo-42", Status: params.StatusRebooting, Info: "blah"},
 
179
                        {Tag: "unit-mysql-0", Status: status.StatusError, Info: "not really"},
 
180
                        {Tag: "unit-wordpress-0", Status: status.StatusExecuting, Info: "foobar"},
 
181
                        {Tag: "unit-foo-42", Status: status.StatusRebooting, Info: "blah"},
181
182
                }}
182
183
        result, err := s.uniter.SetAgentStatus(args)
183
184
        c.Assert(err, jc.ErrorIsNil)
192
193
        // Verify mysqlUnit - no change.
193
194
        statusInfo, err := s.mysqlUnit.AgentStatus()
194
195
        c.Assert(err, jc.ErrorIsNil)
195
 
        c.Assert(statusInfo.Status, gc.Equals, state.StatusExecuting)
 
196
        c.Assert(statusInfo.Status, gc.Equals, status.StatusExecuting)
196
197
        c.Assert(statusInfo.Message, gc.Equals, "foo")
197
198
        // ...wordpressUnit is fine though.
198
199
        statusInfo, err = s.wordpressUnit.AgentStatus()
199
200
        c.Assert(err, jc.ErrorIsNil)
200
 
        c.Assert(statusInfo.Status, gc.Equals, state.StatusExecuting)
 
201
        c.Assert(statusInfo.Status, gc.Equals, status.StatusExecuting)
201
202
        c.Assert(statusInfo.Message, gc.Equals, "foobar")
202
203
}
203
204
 
204
205
func (s *uniterSuite) TestSetUnitStatus(c *gc.C) {
205
 
        err := s.wordpressUnit.SetStatus(state.StatusActive, "blah", nil)
 
206
        err := s.wordpressUnit.SetStatus(status.StatusActive, "blah", nil)
206
207
        c.Assert(err, jc.ErrorIsNil)
207
 
        err = s.mysqlUnit.SetStatus(state.StatusTerminated, "foo", nil)
 
208
        err = s.mysqlUnit.SetStatus(status.StatusTerminated, "foo", nil)
208
209
        c.Assert(err, jc.ErrorIsNil)
209
210
 
210
211
        args := params.SetStatus{
211
212
                Entities: []params.EntityStatusArgs{
212
 
                        {Tag: "unit-mysql-0", Status: params.StatusError, Info: "not really"},
213
 
                        {Tag: "unit-wordpress-0", Status: params.StatusTerminated, Info: "foobar"},
214
 
                        {Tag: "unit-foo-42", Status: params.StatusActive, Info: "blah"},
 
213
                        {Tag: "unit-mysql-0", Status: status.StatusError, Info: "not really"},
 
214
                        {Tag: "unit-wordpress-0", Status: status.StatusTerminated, Info: "foobar"},
 
215
                        {Tag: "unit-foo-42", Status: status.StatusActive, Info: "blah"},
215
216
                }}
216
217
        result, err := s.uniter.SetUnitStatus(args)
217
218
        c.Assert(err, jc.ErrorIsNil)
226
227
        // Verify mysqlUnit - no change.
227
228
        statusInfo, err := s.mysqlUnit.Status()
228
229
        c.Assert(err, jc.ErrorIsNil)
229
 
        c.Assert(statusInfo.Status, gc.Equals, state.StatusTerminated)
 
230
        c.Assert(statusInfo.Status, gc.Equals, status.StatusTerminated)
230
231
        c.Assert(statusInfo.Message, gc.Equals, "foo")
231
232
        // ...wordpressUnit is fine though.
232
233
        statusInfo, err = s.wordpressUnit.Status()
233
234
        c.Assert(err, jc.ErrorIsNil)
234
 
        c.Assert(statusInfo.Status, gc.Equals, state.StatusTerminated)
 
235
        c.Assert(statusInfo.Status, gc.Equals, status.StatusTerminated)
235
236
        c.Assert(statusInfo.Message, gc.Equals, "foobar")
236
237
}
237
238
 
2079
2080
}
2080
2081
 
2081
2082
func (s *uniterSuite) TestUnitStatus(c *gc.C) {
2082
 
        err := s.wordpressUnit.SetStatus(state.StatusMaintenance, "blah", nil)
 
2083
        err := s.wordpressUnit.SetStatus(status.StatusMaintenance, "blah", nil)
2083
2084
        c.Assert(err, jc.ErrorIsNil)
2084
 
        err = s.mysqlUnit.SetStatus(state.StatusTerminated, "foo", nil)
 
2085
        err = s.mysqlUnit.SetStatus(status.StatusTerminated, "foo", nil)
2085
2086
        c.Assert(err, jc.ErrorIsNil)
2086
2087
 
2087
2088
        args := params.Entities{
2106
2107
        c.Assert(result, gc.DeepEquals, params.StatusResults{
2107
2108
                Results: []params.StatusResult{
2108
2109
                        {Error: apiservertesting.ErrUnauthorized},
2109
 
                        {Status: params.StatusMaintenance, Info: "blah", Data: map[string]interface{}{}},
 
2110
                        {Status: status.StatusMaintenance, Info: "blah", Data: map[string]interface{}{}},
2110
2111
                        {Error: apiservertesting.ErrUnauthorized},
2111
2112
                        {Error: apiservertesting.ErrUnauthorized},
2112
2113
                        {Error: apiservertesting.ServerError(`"invalid" is not a valid tag`)},
2366
2367
 
2367
2368
var _ = gc.Suite(&uniterNetworkConfigSuite{})
2368
2369
 
 
2370
func (s *uniterNetworkConfigSuite) SetUpSuite(c *gc.C) {
 
2371
        s.base.SetUpSuite(c)
 
2372
}
 
2373
 
 
2374
func (s *uniterNetworkConfigSuite) TearDownSuite(c *gc.C) {
 
2375
        s.base.TearDownSuite(c)
 
2376
}
 
2377
 
2369
2378
func (s *uniterNetworkConfigSuite) SetUpTest(c *gc.C) {
2370
2379
        s.base.JujuConnSuite.SetUpTest(c)
2371
2380
 
2394
2403
 
2395
2404
        factory := jujuFactory.NewFactory(s.base.State)
2396
2405
        s.base.wpCharm = factory.MakeCharm(c, &jujuFactory.CharmParams{
2397
 
                Name: "wordpress",
2398
 
                URL:  "cs:quantal/wordpress-3",
 
2406
                Name: "wordpress-extra-bindings",
 
2407
                URL:  "cs:quantal/wordpress-extra-bindings-4",
2399
2408
        })
2400
2409
        s.base.wordpress, err = s.base.State.AddService(state.AddServiceArgs{
2401
2410
                Name:  "wordpress",
2402
2411
                Charm: s.base.wpCharm,
2403
2412
                Owner: s.base.AdminUserTag(c).String(),
2404
2413
                EndpointBindings: map[string]string{
2405
 
                        "db": "internal",
 
2414
                        "db":        "internal", // relation name
 
2415
                        "admin-api": "public",   // extra-binding name
2406
2416
                },
2407
2417
        })
2408
2418
        c.Assert(err, jc.ErrorIsNil)
2465
2475
}
2466
2476
 
2467
2477
func (s *uniterNetworkConfigSuite) TestNetworkConfigPermissions(c *gc.C) {
2468
 
        rel := s.addRelationAndAssertInScope(c)
 
2478
        s.addRelationAndAssertInScope(c)
2469
2479
 
2470
 
        args := params.RelationUnits{RelationUnits: []params.RelationUnit{
2471
 
                {Relation: "relation-42", Unit: "unit-foo-0"},
2472
 
                {Relation: rel.Tag().String(), Unit: "invalid"},
2473
 
                {Relation: rel.Tag().String(), Unit: "unit-mysql-0"},
2474
 
                {Relation: "relation-42", Unit: s.base.wordpressUnit.Tag().String()},
 
2480
        args := params.UnitsNetworkConfig{Args: []params.UnitNetworkConfig{
 
2481
                {BindingName: "foo", UnitTag: "unit-foo-0"},
 
2482
                {BindingName: "db-client", UnitTag: "invalid"},
 
2483
                {BindingName: "juju-info", UnitTag: "unit-mysql-0"},
 
2484
                {BindingName: "", UnitTag: s.base.wordpressUnit.Tag().String()},
 
2485
                {BindingName: "unknown", UnitTag: s.base.wordpressUnit.Tag().String()},
2475
2486
        }}
2476
2487
 
2477
2488
        result, err := s.base.uniter.NetworkConfig(args)
2481
2492
                        {Error: apiservertesting.ErrUnauthorized},
2482
2493
                        {Error: apiservertesting.ServerError(`"invalid" is not a valid tag`)},
2483
2494
                        {Error: apiservertesting.ErrUnauthorized},
2484
 
                        {Error: apiservertesting.ServerError(`"relation-42" is not a valid relation tag`)},
 
2495
                        {Error: apiservertesting.ServerError(`binding name cannot be empty`)},
 
2496
                        {Error: apiservertesting.ServerError(`binding name "unknown" not defined by the unit's charm`)},
2485
2497
                },
2486
2498
        })
2487
2499
}
2488
2500
 
2489
 
func (s *uniterNetworkConfigSuite) addRelationAndAssertInScope(c *gc.C) *state.Relation {
 
2501
func (s *uniterNetworkConfigSuite) addRelationAndAssertInScope(c *gc.C) {
2490
2502
        // Add a relation between wordpress and mysql and enter scope with
2491
2503
        // mysqlUnit.
2492
2504
        rel := s.base.addRelation(c, "wordpress", "mysql")
2495
2507
        err = wpRelUnit.EnterScope(nil)
2496
2508
        c.Assert(err, jc.ErrorIsNil)
2497
2509
        s.base.assertInScope(c, wpRelUnit, true)
2498
 
        return rel
2499
2510
}
2500
2511
 
2501
2512
func (s *uniterNetworkConfigSuite) TestNetworkConfigForExplicitlyBoundEndpoint(c *gc.C) {
2502
 
        rel := s.addRelationAndAssertInScope(c)
 
2513
        s.addRelationAndAssertInScope(c)
2503
2514
 
2504
 
        args := params.RelationUnits{RelationUnits: []params.RelationUnit{
2505
 
                {Relation: rel.Tag().String(), Unit: s.base.wordpressUnit.Tag().String()},
 
2515
        args := params.UnitsNetworkConfig{Args: []params.UnitNetworkConfig{
 
2516
                {BindingName: "db", UnitTag: s.base.wordpressUnit.Tag().String()},
 
2517
                {BindingName: "admin-api", UnitTag: s.base.wordpressUnit.Tag().String()},
2506
2518
        }}
2507
2519
 
2508
2520
        // For the relation "wordpress:db mysql:server" we expect to see only
2509
2521
        // addresses bound to the "internal" space, where the "db" endpoint itself
2510
2522
        // is bound to.
2511
 
        expectedConfig := []params.NetworkConfig{{
 
2523
        expectedConfigWithRelationName := []params.NetworkConfig{{
2512
2524
                Address: "10.0.0.1",
2513
2525
        }, {
2514
2526
                Address: "10.0.0.2",
2515
2527
        }}
 
2528
        // For the "admin-api" extra-binding we expect to see only addresses from
 
2529
        // the "public" space.
 
2530
        expectedConfigWithExtraBindingName := []params.NetworkConfig{{
 
2531
                Address: "8.8.8.8",
 
2532
        }}
2516
2533
 
2517
2534
        result, err := s.base.uniter.NetworkConfig(args)
2518
2535
        c.Assert(err, jc.ErrorIsNil)
2519
2536
        c.Assert(result, jc.DeepEquals, params.UnitNetworkConfigResults{
2520
2537
                Results: []params.UnitNetworkConfigResult{
2521
 
                        {Config: expectedConfig},
 
2538
                        {Config: expectedConfigWithRelationName},
 
2539
                        {Config: expectedConfigWithExtraBindingName},
2522
2540
                },
2523
2541
        })
2524
2542
}
2525
2543
 
2526
2544
func (s *uniterNetworkConfigSuite) TestNetworkConfigForImplicitlyBoundEndpoint(c *gc.C) {
2527
 
        // Since wordpressUnit as explicit binding for "db", switch the API to
 
2545
        // Since wordpressUnit has explicit binding for "db", switch the API to
2528
2546
        // mysqlUnit and check "mysql:server" uses the machine preferred private
2529
2547
        // address.
2530
2548
        s.setupUniterAPIForUnit(c, s.base.mysqlUnit)
2535
2553
        c.Assert(err, jc.ErrorIsNil)
2536
2554
        s.base.assertInScope(c, mysqlRelUnit, true)
2537
2555
 
2538
 
        args := params.RelationUnits{RelationUnits: []params.RelationUnit{
2539
 
                {Relation: rel.Tag().String(), Unit: s.base.mysqlUnit.Tag().String()},
 
2556
        args := params.UnitsNetworkConfig{Args: []params.UnitNetworkConfig{
 
2557
                {BindingName: "server", UnitTag: s.base.mysqlUnit.Tag().String()},
2540
2558
        }}
2541
2559
 
2542
2560
        privateAddress, err := s.base.machine1.PrivateAddress()