func (s *InstancePollerSuite) TestInstanceStatusSuccess(c *gc.C) {
s.st.SetMachineInfo(c, machineInfo{id: "1", instanceStatus: statusInfo("foo")})
s.st.SetMachineInfo(c, machineInfo{id: "2", instanceStatus: statusInfo("")})
result, err := s.api.InstanceStatus(s.mixedEntities)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, jc.DeepEquals, params.StatusResults{
Results: []params.StatusResult{
{Status: "foo"},
{Status: ""},
{Error: apiservertesting.NotFoundError("machine 42")},
{Error: apiservertesting.ServerError(`"application-unknown" is not a valid machine tag`)},
{Error: apiservertesting.ServerError(`"invalid-tag" is not a valid tag`)},
{Error: apiservertesting.ServerError(`"unit-missing-1" is not a valid machine tag`)},
{Error: apiservertesting.ServerError(`"" is not a valid tag`)},
{Error: apiservertesting.ServerError(`"42" is not a valid tag`)},
},
},
)
s.st.CheckFindEntityCall(c, 0, "1")
s.st.CheckCall(c, 1, "InstanceStatus")
s.st.CheckFindEntityCall(c, 2, "2")
s.st.CheckCall(c, 3, "InstanceStatus")
s.st.CheckFindEntityCall(c, 4, "42")
}
func (s *InstancePollerSuite) TestProviderAddressesSuccess(c *gc.C) {
addrs := network.NewAddresses("0.1.2.3", "127.0.0.1", "8.8.8.8")
expectedAddresses := params.FromNetworkAddresses(addrs...)
s.st.SetMachineInfo(c, machineInfo{id: "1", providerAddresses: addrs})
s.st.SetMachineInfo(c, machineInfo{id: "2", providerAddresses: nil})
result, err := s.api.ProviderAddresses(s.mixedEntities)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, jc.DeepEquals, params.MachineAddressesResults{
Results: []params.MachineAddressesResult{
{Addresses: expectedAddresses},
{Addresses: nil},
{Error: apiservertesting.NotFoundError("machine 42")},
{Error: apiservertesting.ServerError(`"application-unknown" is not a valid machine tag`)},
{Error: apiservertesting.ServerError(`"invalid-tag" is not a valid tag`)},
{Error: apiservertesting.ServerError(`"unit-missing-1" is not a valid machine tag`)},
{Error: apiservertesting.ServerError(`"" is not a valid tag`)},
{Error: apiservertesting.ServerError(`"42" is not a valid tag`)},
}},
)
s.st.CheckFindEntityCall(c, 0, "1")
s.st.CheckCall(c, 1, "ProviderAddresses")
s.st.CheckFindEntityCall(c, 2, "2")
s.st.CheckCall(c, 3, "ProviderAddresses")
s.st.CheckFindEntityCall(c, 4, "42")
}
func (s *InstancePollerSuite) TestAreManuallyProvisionedFailure(c *gc.C) {
s.st.SetErrors(
errors.New("pow!"), // m1 := FindEntity("1")
nil, // m2 := FindEntity("2")
errors.New("FAIL"), // m2.IsManual()
errors.NotProvisionedf("machine 42"), // FindEntity("3") (ensure wrapping is preserved)
)
s.st.SetMachineInfo(c, machineInfo{id: "1", isManual: true})
s.st.SetMachineInfo(c, machineInfo{id: "2", isManual: false})
result, err := s.api.AreManuallyProvisioned(s.machineEntities)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, jc.DeepEquals, params.BoolResults{
Results: []params.BoolResult{
{Error: apiservertesting.ServerError("pow!")},
{Error: apiservertesting.ServerError("FAIL")},
{Error: apiservertesting.NotProvisionedError("42")},
}},
)
s.st.CheckFindEntityCall(c, 0, "1")
s.st.CheckFindEntityCall(c, 1, "2")
s.st.CheckCall(c, 2, "IsManual")
s.st.CheckFindEntityCall(c, 3, "3")
}
func (s *InstancePollerSuite) TestAreManuallyProvisionedSuccess(c *gc.C) {
s.st.SetMachineInfo(c, machineInfo{id: "1", isManual: true})
s.st.SetMachineInfo(c, machineInfo{id: "2", isManual: false})
result, err := s.api.AreManuallyProvisioned(s.mixedEntities)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, jc.DeepEquals, params.BoolResults{
Results: []params.BoolResult{
{Result: true},
{Result: false},
{Error: apiservertesting.NotFoundError("machine 42")},
{Error: apiservertesting.ServerError(`"application-unknown" is not a valid machine tag`)},
{Error: apiservertesting.ServerError(`"invalid-tag" is not a valid tag`)},
{Error: apiservertesting.ServerError(`"unit-missing-1" is not a valid machine tag`)},
{Error: apiservertesting.ServerError(`"" is not a valid tag`)},
{Error: apiservertesting.ServerError(`"42" is not a valid tag`)},
}},
)
s.st.CheckFindEntityCall(c, 0, "1")
s.st.CheckCall(c, 1, "IsManual")
s.st.CheckFindEntityCall(c, 2, "2")
s.st.CheckCall(c, 3, "IsManual")
s.st.CheckFindEntityCall(c, 4, "42")
}
func (s *InstancePollerSuite) TestStatusFailure(c *gc.C) {
s.st.SetErrors(
errors.New("pow!"), // m1 := FindEntity("1"); Status not called
nil, // m2 := FindEntity("2")
errors.New("FAIL"), // m2.Status()
errors.NotProvisionedf("machine 42"), // FindEntity("3") (ensure wrapping is preserved)
)
s.st.SetMachineInfo(c, machineInfo{id: "1"})
s.st.SetMachineInfo(c, machineInfo{id: "2"})
result, err := s.api.Status(s.machineEntities)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, jc.DeepEquals, params.StatusResults{
Results: []params.StatusResult{
{Error: apiservertesting.ServerError("pow!")},
{Error: apiservertesting.ServerError("FAIL")},
{Error: apiservertesting.NotProvisionedError("42")},
}},
)
s.st.CheckFindEntityCall(c, 0, "1")
s.st.CheckFindEntityCall(c, 1, "2")
s.st.CheckCall(c, 2, "Status")
s.st.CheckFindEntityCall(c, 3, "3")
}
func (s *InstancePollerSuite) TestLifeFailure(c *gc.C) {
s.st.SetErrors(
errors.New("pow!"), // m1 := FindEntity("1"); Life not called
nil, // m2 := FindEntity("2")
errors.New("FAIL"), // m2.Life() - unused
errors.NotProvisionedf("machine 42"), // FindEntity("3") (ensure wrapping is preserved)
)
s.st.SetMachineInfo(c, machineInfo{id: "1", life: state.Alive})
s.st.SetMachineInfo(c, machineInfo{id: "2", life: state.Dead})
s.st.SetMachineInfo(c, machineInfo{id: "3", life: state.Dying})
result, err := s.api.Life(s.machineEntities)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, jc.DeepEquals, params.LifeResults{
Results: []params.LifeResult{
{Error: apiservertesting.ServerError("pow!")},
{Life: params.Dead},
{Error: apiservertesting.NotProvisionedError("42")},
}},
)
s.st.CheckFindEntityCall(c, 0, "1")
s.st.CheckFindEntityCall(c, 1, "2")
s.st.CheckCall(c, 2, "Life")
s.st.CheckFindEntityCall(c, 3, "3")
}
func (s *AddresserSuite) TestIPAddressesServerError(c *gc.C) {
tag1 := names.NewIPAddressTag("11111111-0000-0000-0000-000000000000")
tag2 := names.NewIPAddressTag("22222222-0000-0000-0000-000000000000")
var called int
args := params.Entities{
Entities: []params.Entity{
{Tag: tag1.String()},
{Tag: tag2.String()},
},
}
results := params.LifeResults{
Results: []params.LifeResult{
{params.Alive, nil},
{"", apiservertesting.ServerError("server failure")},
},
}
apiCaller := successAPICaller(c, "Life", args, results, &called)
api := addresser.NewAPI(apiCaller)
ipAddresses, err := api.IPAddresses(tag1, tag2)
c.Assert(len(ipAddresses), gc.Equals, 2)
c.Assert(ipAddresses[0].Tag().String(), gc.Equals, tag1.String())
c.Assert(ipAddresses[1], gc.IsNil)
c.Assert(err, gc.Equals, common.ErrPartialResults)
c.Assert(called, gc.Equals, 1)
}
func (s *uniterV2Suite) TestUnitStatus(c *gc.C) {
err := s.wordpressUnit.SetStatus(state.StatusMaintenance, "blah", nil)
c.Assert(err, jc.ErrorIsNil)
err = s.mysqlUnit.SetStatus(state.StatusTerminated, "foo", nil)
c.Assert(err, jc.ErrorIsNil)
args := params.Entities{
Entities: []params.Entity{
{Tag: "unit-mysql-0"},
{Tag: "unit-wordpress-0"},
{Tag: "unit-foo-42"},
{Tag: "machine-1"},
{Tag: "invalid"},
}}
result, err := s.uniter.UnitStatus(args)
c.Assert(err, jc.ErrorIsNil)
// Zero out the updated timestamps so we can easily check the results.
for i, statusResult := range result.Results {
r := statusResult
if r.Status != "" {
c.Assert(r.Since, gc.NotNil)
}
r.Since = nil
result.Results[i] = r
}
c.Assert(result, gc.DeepEquals, params.StatusResults{
Results: []params.StatusResult{
{Error: apiservertesting.ErrUnauthorized},
{Status: params.StatusMaintenance, Info: "blah", Data: map[string]interface{}{}},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ServerError(`"invalid" is not a valid tag`)},
},
})
}
func (s *firewallerSuite) TestGetMachinePorts(c *gc.C) {
s.openPorts(c)
subnetTag := names.NewSubnetTag("10.20.30.0/24").String()
args := params.MachinePortsParams{
Params: []params.MachinePorts{
{MachineTag: s.machines[0].Tag().String(), SubnetTag: ""},
{MachineTag: s.machines[0].Tag().String(), SubnetTag: subnetTag},
{MachineTag: s.machines[1].Tag().String(), SubnetTag: ""},
{MachineTag: s.machines[2].Tag().String(), SubnetTag: ""},
{MachineTag: s.machines[0].Tag().String(), SubnetTag: "invalid"},
{MachineTag: "machine-42", SubnetTag: ""},
{MachineTag: s.machines[0].Tag().String(), SubnetTag: "subnet-bad"},
},
}
unit0Tag := s.units[0].Tag().String()
expectPortsMachine0NoSubnet := []params.MachinePortRange{
{UnitTag: unit0Tag, PortRange: params.PortRange{
FromPort: 4321, ToPort: 4321, Protocol: "tcp",
}},
}
expectPortsMachine0WithSubnet := []params.MachinePortRange{
{UnitTag: unit0Tag, PortRange: params.PortRange{
FromPort: 1234, ToPort: 1400, Protocol: "tcp",
}},
}
unit2Tag := s.units[2].Tag().String()
expectPortsMachine2 := []params.MachinePortRange{
{UnitTag: unit2Tag, PortRange: params.PortRange{
FromPort: 1111, ToPort: 2222, Protocol: "udp",
}},
}
result, err := s.firewaller.GetMachinePorts(args)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, jc.DeepEquals, params.MachinePortsResults{
Results: []params.MachinePortsResult{
{Ports: expectPortsMachine0NoSubnet},
{Ports: expectPortsMachine0WithSubnet},
{Error: nil, Ports: nil},
{Ports: expectPortsMachine2},
{Error: apiservertesting.ServerError(`"invalid" is not a valid tag`)},
{Error: apiservertesting.NotFoundError("machine 42")},
{Error: apiservertesting.ServerError(`"subnet-bad" is not a valid subnet tag`)},
},
})
}
func (s *firewallerSuite) TestGetMachineActiveSubnets(c *gc.C) {
s.openPorts(c)
subnetTag := names.NewSubnetTag("10.20.30.0/24").String()
args := addFakeEntities(params.Entities{Entities: []params.Entity{
{Tag: s.machines[0].Tag().String()},
{Tag: s.machines[1].Tag().String()},
{Tag: s.machines[2].Tag().String()},
{Tag: s.service.Tag().String()},
{Tag: s.units[0].Tag().String()},
}})
expectResultsMachine0 := []string{subnetTag, ""}
expectResultsMachine2 := []string{""}
result, err := s.firewaller.GetMachineActiveSubnets(args)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, jc.DeepEquals, params.StringsResults{
Results: []params.StringsResult{
{Result: expectResultsMachine0},
{Result: nil, Error: nil},
{Result: expectResultsMachine2},
{Error: apiservertesting.ServerError(`"application-wordpress" is not a valid machine tag`)},
{Error: apiservertesting.ServerError(`"unit-wordpress-0" is not a valid machine tag`)},
{Error: apiservertesting.NotFoundError("machine 42")},
{Error: apiservertesting.ServerError(`"unit-foo-0" is not a valid machine tag`)},
{Error: apiservertesting.ServerError(`"application-bar" is not a valid machine tag`)},
{Error: apiservertesting.ServerError(`"user-foo" is not a valid machine tag`)},
{Error: apiservertesting.ServerError(`"foo-bar" is not a valid tag`)},
{Error: apiservertesting.ServerError(`"" is not a valid tag`)},
},
})
}
func (s *MachineSuite) TestServerError(c *gc.C) {
err := apiservertesting.ServerError("server error!")
expected := err.Error()
for i, test := range machineErrorTests {
c.Logf("test #%d: %s", i, test.method)
results := MakeResultsWithErrors(test.resultsRef, err, 1)
s.CheckServerError(c, test.wrapper, expected, results)
}
}
func (s *prepareSuite) TestErrorWithHostInsteadOfContainer(c *gc.C) {
s.newAPI(c, true, false)
args := s.makeArgs(s.machines[0])
s.assertCall(c, args, s.makeErrors(
apiservertesting.ServerError(
`cannot allocate address for "machine-0": not a container`,
),
), "")
}
func (s *MachineSuite) TestTooManyResultsServerError(c *gc.C) {
err := apiservertesting.ServerError("some error")
expected := "expected 1 result, got 2"
for i, test := range machineErrorTests {
c.Logf("test #%d: %s", i, test.method)
results := MakeResultsWithErrors(test.resultsRef, err, 2)
s.CheckServerError(c, test.wrapper, expected, results)
}
}
func (s *releaseSuite) TestErrorWithHostInsteadOfContainer(c *gc.C) {
s.newAPI(c, true, false)
args := s.makeArgs(s.machines[0])
err := s.assertCall(c, args, s.makeErrors(
apiservertesting.ServerError(
`cannot mark addresses for removal for "machine-0": not a container`,
),
), "")
c.Assert(err, jc.ErrorIsNil)
}
func (s *InstancePollerSuite) TestStatusSuccess(c *gc.C) {
now := time.Now()
s1 := status.StatusInfo{
Status: status.Error,
Message: "not really",
Data: map[string]interface{}{
"price": 4.2,
"bool": false,
"bar": []string{"a", "b"},
},
Since: &now,
}
s2 := status.StatusInfo{}
s.st.SetMachineInfo(c, machineInfo{id: "1", status: s1})
s.st.SetMachineInfo(c, machineInfo{id: "2", status: s2})
result, err := s.api.Status(s.mixedEntities)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, jc.DeepEquals, params.StatusResults{
Results: []params.StatusResult{
{
Status: status.Error.String(),
Info: s1.Message,
Data: s1.Data,
Since: s1.Since,
},
{Status: "", Info: "", Data: nil, Since: nil},
{Error: apiservertesting.NotFoundError("machine 42")},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ServerError(`"invalid-tag" is not a valid tag`)},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ServerError(`"" is not a valid tag`)},
{Error: apiservertesting.ServerError(`"42" is not a valid tag`)},
}},
)
s.st.CheckFindEntityCall(c, 0, "1")
s.st.CheckCall(c, 1, "Status")
s.st.CheckFindEntityCall(c, 2, "2")
s.st.CheckCall(c, 3, "Status")
s.st.CheckFindEntityCall(c, 4, "42")
}
func (s *releaseSuite) TestErrorWithNoFeatureFlag(c *gc.C) {
s.SetFeatureFlags() // clear the flags.
s.newAPI(c, true, false)
args := s.makeArgs(s.machines[0])
expectedError := `cannot mark addresses for removal for "machine-0": not a container`
s.assertCall(c, args, ¶ms.ErrorResults{
Results: []params.ErrorResult{{
Error: apiservertesting.ServerError(expectedError),
}},
}, "")
}
func (s *prepareSuite) TestErrorWithProvisionedContainer(c *gc.C) {
container := s.newAPI(c, true, true)
err := container.SetProvisioned("i-foo", "fake_nonce", nil)
c.Assert(err, jc.ErrorIsNil)
args := s.makeArgs(container)
s.assertCall(c, args, s.makeErrors(
apiservertesting.ServerError(
`container "0/lxc/0" already provisioned as "i-foo"`,
),
), "")
}
func (s *keyManagerSuite) TestDeleteKeysNotJujuInternal(c *gc.C) {
key1 := sshtesting.ValidKeyOne.Key + " juju-client-key"
key2 := sshtesting.ValidKeyTwo.Key + " juju-system-key"
key3 := sshtesting.ValidKeyThree.Key + " a user key"
initialKeys := []string{key1, key2, key3}
s.setAuthorisedKeys(c, strings.Join(initialKeys, "\n"))
args := params.ModifyUserSSHKeys{
User: s.AdminUserTag(c).Name(),
Keys: []string{"juju-client-key", "juju-system-key"},
}
results, err := s.keymanager.DeleteKeys(args)
c.Check(results, gc.DeepEquals, params.ErrorResults{
Results: []params.ErrorResult{
{Error: apiservertesting.ServerError("may not delete internal key: juju-client-key")},
{Error: apiservertesting.ServerError("may not delete internal key: juju-system-key")},
},
})
c.Assert(err, jc.ErrorIsNil)
s.assertEnvironKeys(c, initialKeys)
}
func (s *keyManagerSuite) TestDeleteKeys(c *gc.C) {
key1 := sshtesting.ValidKeyOne.Key + " user@host"
key2 := sshtesting.ValidKeyTwo.Key
initialKeys := []string{key1, key2, "bad key"}
s.setAuthorisedKeys(c, strings.Join(initialKeys, "\n"))
args := params.ModifyUserSSHKeys{
User: s.AdminUserTag(c).Name(),
Keys: []string{sshtesting.ValidKeyTwo.Fingerprint, sshtesting.ValidKeyThree.Fingerprint, "invalid-key"},
}
results, err := s.keymanager.DeleteKeys(args)
c.Assert(err, jc.ErrorIsNil)
c.Assert(results, gc.DeepEquals, params.ErrorResults{
Results: []params.ErrorResult{
{Error: nil},
{Error: apiservertesting.ServerError("invalid ssh key: " + sshtesting.ValidKeyThree.Fingerprint)},
{Error: apiservertesting.ServerError("invalid ssh key: invalid-key")},
},
})
s.assertEnvironKeys(c, []string{key1, "bad key"})
}
func (s *AddresserSuite) TestCleanupIPAddressesServerError(c *gc.C) {
var called int
expectedResult := params.ErrorResult{
Error: apiservertesting.ServerError("server boom!"),
}
apiCaller := successAPICaller(c, "CleanupIPAddresses", nil, expectedResult, &called)
api := addresser.NewAPI(apiCaller)
err := api.CleanupIPAddresses()
c.Assert(err, gc.ErrorMatches, "server boom!")
c.Assert(called, gc.Equals, 1)
}
func (s *prepareSuite) TestErrorsWithNonMachineOrInvalidTags(c *gc.C) {
s.newAPI(c, true, false)
args := params.Entities{Entities: []params.Entity{
{Tag: "unit-wordpress-0"},
{Tag: "service-wordpress"},
{Tag: "network-foo"},
{Tag: "anything-invalid"},
{Tag: "42"},
{Tag: "machine-42"},
{Tag: ""},
}}
s.assertCall(c, args, s.makeErrors(
apiservertesting.ServerError(
`"unit-wordpress-0" is not a valid machine tag`),
apiservertesting.ServerError(
`"service-wordpress" is not a valid machine tag`),
apiservertesting.ServerError(
`"network-foo" is not a valid machine tag`),
apiservertesting.ServerError(
`"anything-invalid" is not a valid tag`),
apiservertesting.ServerError(
`"42" is not a valid tag`),
apiservertesting.ErrUnauthorized,
apiservertesting.ServerError(
`"" is not a valid tag`),
), "")
}
func (s *InstancePollerSuite) TestWatchEnvironMachinesServerError(c *gc.C) {
var called int
expectedResults := params.StringsWatchResult{
Error: apiservertesting.ServerError("server boom!"),
}
apiCaller := successAPICaller(c, "WatchEnvironMachines", nil, expectedResults, &called)
api := instancepoller.NewAPI(apiCaller)
w, err := api.WatchEnvironMachines()
c.Assert(err, gc.ErrorMatches, "server boom!")
c.Assert(called, gc.Equals, 1)
c.Assert(w, gc.IsNil)
}
func (s *keyManagerSuite) TestAddKeys(c *gc.C) {
key1 := sshtesting.ValidKeyOne.Key + " user@host"
key2 := sshtesting.ValidKeyTwo.Key
initialKeys := []string{key1, key2, "bad key"}
s.setAuthorisedKeys(c, strings.Join(initialKeys, "\n"))
newKey := sshtesting.ValidKeyThree.Key + " newuser@host"
args := params.ModifyUserSSHKeys{
User: s.AdminUserTag(c).Name(),
Keys: []string{key2, newKey, "invalid-key"},
}
results, err := s.keymanager.AddKeys(args)
c.Assert(err, jc.ErrorIsNil)
c.Assert(results, gc.DeepEquals, params.ErrorResults{
Results: []params.ErrorResult{
{Error: apiservertesting.ServerError(fmt.Sprintf("duplicate ssh key: %s", key2))},
{Error: nil},
{Error: apiservertesting.ServerError("invalid ssh key: invalid-key")},
},
})
s.assertEnvironKeys(c, append(initialKeys, newKey))
}
func (s *AddresserSuite) TestWatchIPAddressesServerError(c *gc.C) {
var called int
expectedResult := params.EntitiesWatchResult{
Error: apiservertesting.ServerError("server boom!"),
}
apiCaller := successAPICaller(c, "WatchIPAddresses", nil, expectedResult, &called)
api := addresser.NewAPI(apiCaller)
w, err := api.WatchIPAddresses()
c.Assert(w, jc.ErrorIsNil)
c.Assert(err, gc.ErrorMatches, "server boom!")
c.Assert(called, gc.Equals, 1)
}
func (s *AddresserSuite) TestCanDeallocateAddressesServerError(c *gc.C) {
var called int
expectedResult := params.BoolResult{
Error: apiservertesting.ServerError("server boom!"),
}
apiCaller := successAPICaller(c, "CanDeallocateAddresses", nil, expectedResult, &called)
api := addresser.NewAPI(apiCaller)
ok, err := api.CanDeallocateAddresses()
c.Assert(err, gc.ErrorMatches, "server boom!")
c.Assert(ok, jc.IsFalse)
c.Assert(called, gc.Equals, 1)
}
func (s *InstancePollerSuite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
s.authoriser = apiservertesting.FakeAuthorizer{
EnvironManager: true,
}
s.resources = common.NewResources()
s.AddCleanup(func(*gc.C) { s.resources.StopAll() })
s.st = NewMockState()
instancepoller.PatchState(s, s.st)
var err error
s.clock = jujutesting.NewClock(time.Now())
s.api, err = instancepoller.NewInstancePollerAPI(nil, s.resources, s.authoriser, s.clock)
c.Assert(err, jc.ErrorIsNil)
s.machineEntities = params.Entities{
Entities: []params.Entity{
{Tag: "machine-1"},
{Tag: "machine-2"},
{Tag: "machine-3"},
}}
s.machineErrorResults = params.ErrorResults{
Results: []params.ErrorResult{
{Error: apiservertesting.ServerError("pow!")},
{Error: apiservertesting.ServerError("FAIL")},
{Error: apiservertesting.NotProvisionedError("42")},
}}
s.mixedEntities = params.Entities{
Entities: []params.Entity{
{Tag: "machine-1"},
{Tag: "machine-2"},
{Tag: "machine-42"},
{Tag: "application-unknown"},
{Tag: "invalid-tag"},
{Tag: "unit-missing-1"},
{Tag: ""},
{Tag: "42"},
}}
s.mixedErrorResults = params.ErrorResults{
Results: []params.ErrorResult{
{Error: nil},
{Error: nil},
{Error: apiservertesting.NotFoundError("machine 42")},
{Error: apiservertesting.ServerError(`"application-unknown" is not a valid machine tag`)},
{Error: apiservertesting.ServerError(`"invalid-tag" is not a valid tag`)},
{Error: apiservertesting.ServerError(`"unit-missing-1" is not a valid machine tag`)},
{Error: apiservertesting.ServerError(`"" is not a valid tag`)},
{Error: apiservertesting.ServerError(`"42" is not a valid tag`)},
}}
}
// Because at present all user are admins problems could be caused by allowing
// users to change other users passwords. For the time being we only allow
// the password of the current user to be changed
func (s *userManagerSuite) TestSetPasswordOnDifferentUser(c *gc.C) {
s.Factory.MakeUser(c, &factory.UserParams{Name: "foobar"})
args := usermanager.ModifyUsers{
Changes: []usermanager.ModifyUser{{
Username: "******",
DisplayName: "Foo Bar",
Password: "******",
}}}
results, err := s.usermanager.SetPassword(args)
c.Assert(err, gc.IsNil)
c.Assert(results.Results, gc.HasLen, 1)
expectedError := apiservertesting.ServerError("Can only change the password of the current user (admin@local)")
c.Assert(results.Results[0], gc.DeepEquals, params.ErrorResult{Error: expectedError})
}
func (s *keyManagerSuite) TestImportKeys(c *gc.C) {
s.PatchValue(&keymanager.RunSSHImportId, keymanagertesting.FakeImport)
key1 := sshtesting.ValidKeyOne.Key + " user@host"
key2 := sshtesting.ValidKeyTwo.Key
key3 := sshtesting.ValidKeyThree.Key
initialKeys := []string{key1, key2, "bad key"}
s.setAuthorisedKeys(c, strings.Join(initialKeys, "\n"))
args := params.ModifyUserSSHKeys{
User: s.AdminUserTag(c).Name(),
Keys: []string{"lp:existing", "lp:validuser", "invalid-key"},
}
results, err := s.keymanager.ImportKeys(args)
c.Assert(err, gc.IsNil)
c.Assert(results, gc.DeepEquals, params.ErrorResults{
Results: []params.ErrorResult{
{Error: apiservertesting.ServerError(fmt.Sprintf("duplicate ssh key: %s", key2))},
{Error: nil},
{Error: apiservertesting.ServerError("invalid ssh key id: invalid-key")},
},
})
s.assertEnvironKeys(c, append(initialKeys, key3))
}
func (s *AddresserSuite) TestIPAddressesServerError(c *gc.C) {
var called int
tag := names.NewIPAddressTag("00000000-0000-0000-0000-000000000000")
args := params.Entities{
Entities: []params.Entity{{Tag: tag.String()}},
}
results := params.LifeResults{
Results: []params.LifeResult{{"", apiservertesting.ServerError("server boom!")}},
}
apiCaller := successAPICaller(c, "Life", args, results, &called)
api := addresser.NewAPI(apiCaller)
ipAddress, err := api.IPAddress(tag)
c.Assert(ipAddress, gc.IsNil)
c.Assert(err, gc.ErrorMatches, "server boom!")
c.Assert(called, gc.Equals, 1)
}
func (s *AddresserSuite) TestRemoveServerError(c *gc.C) {
var called int
tag := names.NewIPAddressTag("00000000-0000-0000-0000-000000000000")
args := params.Entities{
Entities: []params.Entity{{Tag: tag.String()}},
}
results := params.ErrorResults{
Results: []params.ErrorResult{{apiservertesting.ServerError("server boom!")}},
}
apiCaller := successAPICaller(c, "Remove", args, results, &called)
api := addresser.NewAPI(apiCaller)
ipAddress := addresser.NewIPAddress(api, tag, params.Alive)
err := ipAddress.Remove()
c.Assert(err, gc.ErrorMatches, "server boom!")
c.Assert(called, gc.Equals, 1)
}