← Back to branch summary

~james-page/ubuntu/wily/juju-core/mir-fixes

« back to all changes in this revision

Viewing changes to src/launchpad.net/juju-core/state/state_test.go

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2014-03-28 08:58:42 UTC
  • mfrom: (1.1.21)
  • Revision ID: package-import@ubuntu.com-20140328085842-cyzrgc120bdfxwj0
Tags: 1.17.7-0ubuntu1
https://launchpad.net/bugs/1294776
https://launchpad.net/bugs/1297077
* New upstream point release, including fixes for:
  - no debug log with all providers on Ubuntu 14.04 (LP: #1294776).
* d/control: Add cpu-checker dependency to juju-local (LP: #1297077).

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/launchpad.net/juju-core/state/state_test.go
964
964
 
965
965
func (s *StateSuite) TestAddService(c *gc.C) {
966
966
        charm := s.AddTestingCharm(c, "dummy")
967
 
        _, err := s.State.AddService("haha/borken", "user-admin", charm)
 
967
        _, err := s.State.AddService("haha/borken", "user-admin", charm, nil, nil)
968
968
        c.Assert(err, gc.ErrorMatches, `cannot add service "haha/borken": invalid name`)
969
969
        _, err = s.State.Service("haha/borken")
970
970
        c.Assert(err, gc.ErrorMatches, `"haha/borken" is not a valid service name`)
971
971
 
972
972
        // set that a nil charm is handled correctly
973
 
        _, err = s.State.AddService("umadbro", "user-admin", nil)
 
973
        _, err = s.State.AddService("umadbro", "user-admin", nil, nil, nil)
974
974
        c.Assert(err, gc.ErrorMatches, `cannot add service "umadbro": charm is nil`)
975
975
 
976
 
        wordpress, err := s.State.AddService("wordpress", "user-admin", charm)
 
976
        wordpress, err := s.State.AddService("wordpress", "user-admin", charm, nil, nil)
977
977
        c.Assert(err, gc.IsNil)
978
978
        c.Assert(wordpress.Name(), gc.Equals, "wordpress")
979
 
        mysql, err := s.State.AddService("mysql", "user-admin", charm)
 
979
        mysql, err := s.State.AddService("mysql", "user-admin", charm, nil, nil)
980
980
        c.Assert(err, gc.IsNil)
981
981
        c.Assert(mysql.Name(), gc.Equals, "mysql")
982
982
 
1003
1003
        c.Assert(err, gc.IsNil)
1004
1004
        err = env.Destroy()
1005
1005
        c.Assert(err, gc.IsNil)
1006
 
        _, err = s.State.AddService("s1", "user-admin", charm)
 
1006
        _, err = s.State.AddService("s1", "user-admin", charm, nil, nil)
1007
1007
        c.Assert(err, gc.ErrorMatches, `cannot add service "s1": environment is no longer alive`)
1008
1008
}
1009
1009
 
1018
1018
                c.Assert(env.Life(), gc.Equals, state.Alive)
1019
1019
                c.Assert(env.Destroy(), gc.IsNil)
1020
1020
        }).Check()
1021
 
        _, err = s.State.AddService("s1", "user-admin", charm)
 
1021
        _, err = s.State.AddService("s1", "user-admin", charm, nil, nil)
1022
1022
        c.Assert(err, gc.ErrorMatches, `cannot add service "s1": environment is no longer alive`)
1023
1023
}
1024
1024
 
1030
1030
 
1031
1031
func (s *StateSuite) TestAddServiceNoTag(c *gc.C) {
1032
1032
        charm := s.AddTestingCharm(c, "dummy")
1033
 
        _, err := s.State.AddService("wordpress", state.AdminUser, charm)
 
1033
        _, err := s.State.AddService("wordpress", state.AdminUser, charm, nil, nil)
1034
1034
        c.Assert(err, gc.ErrorMatches, "cannot add service \"wordpress\": Invalid ownertag admin")
1035
1035
}
1036
1036
 
1037
1037
func (s *StateSuite) TestAddServiceNotUserTag(c *gc.C) {
1038
1038
        charm := s.AddTestingCharm(c, "dummy")
1039
 
        _, err := s.State.AddService("wordpress", "machine-3", charm)
 
1039
        _, err := s.State.AddService("wordpress", "machine-3", charm, nil, nil)
1040
1040
        c.Assert(err, gc.ErrorMatches, "cannot add service \"wordpress\": Invalid ownertag machine-3")
1041
1041
}
1042
1042
 
1043
1043
func (s *StateSuite) TestAddServiceNonExistentUser(c *gc.C) {
1044
1044
        charm := s.AddTestingCharm(c, "dummy")
1045
 
        _, err := s.State.AddService("wordpress", "user-notAuser", charm)
 
1045
        _, err := s.State.AddService("wordpress", "user-notAuser", charm, nil, nil)
1046
1046
        c.Assert(err, gc.ErrorMatches, "cannot add service \"wordpress\": user notAuser doesn't exist")
1047
1047
}
1048
1048
 
1053
1053
        c.Assert(len(services), gc.Equals, 0)
1054
1054
 
1055
1055
        // Check that after adding services the result is ok.
1056
 
        _, err = s.State.AddService("wordpress", "user-admin", charm)
 
1056
        _, err = s.State.AddService("wordpress", "user-admin", charm, nil, nil)
1057
1057
        c.Assert(err, gc.IsNil)
1058
1058
        services, err = s.State.AllServices()
1059
1059
        c.Assert(err, gc.IsNil)
1060
1060
        c.Assert(len(services), gc.Equals, 1)
1061
1061
 
1062
 
        _, err = s.State.AddService("mysql", "user-admin", charm)
 
1062
        _, err = s.State.AddService("mysql", "user-admin", charm, nil, nil)
1063
1063
        c.Assert(err, gc.IsNil)
1064
1064
        services, err = s.State.AllServices()
1065
1065
        c.Assert(err, gc.IsNil)
2524
2524
        // Add a service and 4 units: one with a different version, one
2525
2525
        // with an empty version, one with the current version, and one
2526
2526
        // with the new version.
2527
 
        service, err := s.State.AddService("wordpress", "user-admin", s.AddTestingCharm(c, "wordpress"))
 
2527
        service, err := s.State.AddService("wordpress", "user-admin", s.AddTestingCharm(c, "wordpress"), nil, nil)
2528
2528
        c.Assert(err, gc.IsNil)
2529
2529
        unit0, err := service.AddUnit()
2530
2530
        c.Assert(err, gc.IsNil)
2574
2574
        // Add a machine and a unit with the current version.
2575
2575
        machine, err := s.State.AddMachine("series", state.JobHostUnits)
2576
2576
        c.Assert(err, gc.IsNil)
2577
 
        service, err := s.State.AddService("wordpress", "user-admin", s.AddTestingCharm(c, "wordpress"))
 
2577
        service, err := s.State.AddService("wordpress", "user-admin", s.AddTestingCharm(c, "wordpress"), nil, nil)
2578
2578
        c.Assert(err, gc.IsNil)
2579
2579
        unit, err := service.AddUnit()
2580
2580
        c.Assert(err, gc.IsNil)
2850
2850
        return &i
2851
2851
}
2852
2852
 
 
2853
func (s *StateSuite) TestStateServingInfo(c *gc.C) {
 
2854
        info, err := s.State.StateServingInfo()
 
2855
        c.Assert(info, jc.DeepEquals, params.StateServingInfo{})
 
2856
        // no error because empty doc created by default
 
2857
        c.Assert(err, gc.IsNil)
 
2858
 
 
2859
        data := params.StateServingInfo{
 
2860
                APIPort:      69,
 
2861
                StatePort:    80,
 
2862
                Cert:         "Some cert",
 
2863
                PrivateKey:   "Some key",
 
2864
                SharedSecret: "Some Keyfile",
 
2865
        }
 
2866
        err = s.State.SetStateServingInfo(data)
 
2867
        c.Assert(err, gc.IsNil)
 
2868
 
 
2869
        info, err = s.State.StateServingInfo()
 
2870
        c.Assert(err, gc.IsNil)
 
2871
        c.Assert(info, jc.DeepEquals, data)
 
2872
}
 
2873
 
 
2874
func (s *StateSuite) TestOpenCreatesStateServingInfoDoc(c *gc.C) {
 
2875
        // Delete the stateServers collection to pretend this
 
2876
        // is an older environment that had not created it
 
2877
        // already.
 
2878
        err := s.stateServers.DropCollection()
 
2879
        c.Assert(err, gc.IsNil)
 
2880
 
 
2881
        st, err := state.Open(state.TestingStateInfo(), state.TestingDialOpts(), state.Policy(nil))
 
2882
        c.Assert(err, gc.IsNil)
 
2883
        defer st.Close()
 
2884
 
 
2885
        info, err := st.StateServingInfo()
 
2886
        c.Assert(err, gc.IsNil)
 
2887
        c.Assert(info, gc.DeepEquals, params.StateServingInfo{})
 
2888
}
 
2889
 
2853
2890
func (s *StateSuite) TestSetAPIHostPorts(c *gc.C) {
2854
2891
        addrs, err := s.State.APIHostPorts()
2855
2892
        c.Assert(err, gc.IsNil)