← Back to branch summary

~nskaggs/+junk/juju-packaging-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/api/service/client_test.go

  • Committer: Nicholas Skaggs
  • Date: 2016-10-27 20:23:11 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161027202311-sux4jk2o73p1d6rg
Re-add src

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/api/service/client_test.go
 
1
// Copyright 2014 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package service_test
 
5
 
 
6
import (
 
7
        jc "github.com/juju/testing/checkers"
 
8
        gc "gopkg.in/check.v1"
 
9
        "gopkg.in/juju/charm.v6-unstable"
 
10
 
 
11
        "github.com/juju/juju/api/service"
 
12
        "github.com/juju/juju/apiserver/common"
 
13
        "github.com/juju/juju/apiserver/params"
 
14
        "github.com/juju/juju/constraints"
 
15
        "github.com/juju/juju/instance"
 
16
        jujutesting "github.com/juju/juju/juju/testing"
 
17
        "github.com/juju/juju/storage"
 
18
)
 
19
 
 
20
type serviceSuite struct {
 
21
        jujutesting.JujuConnSuite
 
22
 
 
23
        client *service.Client
 
24
}
 
25
 
 
26
var _ = gc.Suite(&serviceSuite{})
 
27
 
 
28
func (s *serviceSuite) SetUpTest(c *gc.C) {
 
29
        s.JujuConnSuite.SetUpTest(c)
 
30
        s.client = service.NewClient(s.APIState)
 
31
        c.Assert(s.client, gc.NotNil)
 
32
}
 
33
 
 
34
func (s *serviceSuite) TestSetServiceMetricCredentials(c *gc.C) {
 
35
        var called bool
 
36
        service.PatchFacadeCall(s, s.client, func(request string, a, response interface{}) error {
 
37
                called = true
 
38
                c.Assert(request, gc.Equals, "SetMetricCredentials")
 
39
                args, ok := a.(params.ServiceMetricCredentials)
 
40
                c.Assert(ok, jc.IsTrue)
 
41
                c.Assert(args.Creds, gc.HasLen, 1)
 
42
                c.Assert(args.Creds[0].ServiceName, gc.Equals, "serviceA")
 
43
                c.Assert(args.Creds[0].MetricCredentials, gc.DeepEquals, []byte("creds 1"))
 
44
 
 
45
                result := response.(*params.ErrorResults)
 
46
                result.Results = make([]params.ErrorResult, 1)
 
47
                return nil
 
48
        })
 
49
        err := s.client.SetMetricCredentials("serviceA", []byte("creds 1"))
 
50
        c.Assert(err, jc.ErrorIsNil)
 
51
        c.Assert(called, jc.IsTrue)
 
52
}
 
53
 
 
54
func (s *serviceSuite) TestSetServiceMetricCredentialsFails(c *gc.C) {
 
55
        var called bool
 
56
        service.PatchFacadeCall(s, s.client, func(request string, args, response interface{}) error {
 
57
                called = true
 
58
                c.Assert(request, gc.Equals, "SetMetricCredentials")
 
59
                result := response.(*params.ErrorResults)
 
60
                result.Results = make([]params.ErrorResult, 1)
 
61
                result.Results[0].Error = common.ServerError(common.ErrPerm)
 
62
                return result.OneError()
 
63
        })
 
64
        err := s.client.SetMetricCredentials("service", []byte("creds"))
 
65
        c.Assert(err, gc.ErrorMatches, "permission denied")
 
66
        c.Assert(called, jc.IsTrue)
 
67
}
 
68
 
 
69
func (s *serviceSuite) TestSetServiceMetricCredentialsNoMocks(c *gc.C) {
 
70
        service := s.Factory.MakeService(c, nil)
 
71
        err := s.client.SetMetricCredentials(service.Name(), []byte("creds"))
 
72
        c.Assert(err, jc.ErrorIsNil)
 
73
        err = service.Refresh()
 
74
        c.Assert(err, jc.ErrorIsNil)
 
75
        c.Assert(service.MetricCredentials(), gc.DeepEquals, []byte("creds"))
 
76
}
 
77
 
 
78
func (s *serviceSuite) TestSetServiceDeploy(c *gc.C) {
 
79
        var called bool
 
80
        service.PatchFacadeCall(s, s.client, func(request string, a, response interface{}) error {
 
81
                called = true
 
82
                c.Assert(request, gc.Equals, "Deploy")
 
83
                args, ok := a.(params.ServicesDeploy)
 
84
                c.Assert(ok, jc.IsTrue)
 
85
                c.Assert(args.Services, gc.HasLen, 1)
 
86
                c.Assert(args.Services[0].CharmUrl, gc.Equals, "charmURL")
 
87
                c.Assert(args.Services[0].ServiceName, gc.Equals, "serviceA")
 
88
                c.Assert(args.Services[0].Series, gc.Equals, "series")
 
89
                c.Assert(args.Services[0].NumUnits, gc.Equals, 2)
 
90
                c.Assert(args.Services[0].ConfigYAML, gc.Equals, "configYAML")
 
91
                c.Assert(args.Services[0].Constraints, gc.DeepEquals, constraints.MustParse("mem=4G"))
 
92
                c.Assert(args.Services[0].Placement, gc.DeepEquals, []*instance.Placement{{"scope", "directive"}})
 
93
                c.Assert(args.Services[0].EndpointBindings, gc.DeepEquals, map[string]string{"foo": "bar"})
 
94
                c.Assert(args.Services[0].Storage, gc.DeepEquals, map[string]storage.Constraints{"data": storage.Constraints{Pool: "pool"}})
 
95
                c.Assert(args.Services[0].Resources, gc.DeepEquals, map[string]string{"foo": "bar"})
 
96
 
 
97
                result := response.(*params.ErrorResults)
 
98
                result.Results = make([]params.ErrorResult, 1)
 
99
                return nil
 
100
        })
 
101
 
 
102
        args := service.DeployArgs{
 
103
                CharmURL:         "charmURL",
 
104
                ServiceName:      "serviceA",
 
105
                Series:           "series",
 
106
                NumUnits:         2,
 
107
                ConfigYAML:       "configYAML",
 
108
                Cons:             constraints.MustParse("mem=4G"),
 
109
                Placement:        []*instance.Placement{{"scope", "directive"}},
 
110
                Networks:         []string{"neta"},
 
111
                Storage:          map[string]storage.Constraints{"data": storage.Constraints{Pool: "pool"}},
 
112
                Resources:        map[string]string{"foo": "bar"},
 
113
                EndpointBindings: map[string]string{"foo": "bar"},
 
114
        }
 
115
        err := s.client.Deploy(args)
 
116
        c.Assert(err, jc.ErrorIsNil)
 
117
        c.Assert(called, jc.IsTrue)
 
118
}
 
119
 
 
120
func (s *serviceSuite) TestServiceGetCharmURL(c *gc.C) {
 
121
        var called bool
 
122
        service.PatchFacadeCall(s, s.client, func(request string, a, response interface{}) error {
 
123
                called = true
 
124
                c.Assert(request, gc.Equals, "GetCharmURL")
 
125
                args, ok := a.(params.ServiceGet)
 
126
                c.Assert(ok, jc.IsTrue)
 
127
                c.Assert(args.ServiceName, gc.Equals, "service")
 
128
 
 
129
                result := response.(*params.StringResult)
 
130
                result.Result = "curl"
 
131
                return nil
 
132
        })
 
133
        curl, err := s.client.GetCharmURL("service")
 
134
        c.Assert(err, jc.ErrorIsNil)
 
135
        c.Assert(curl, gc.DeepEquals, charm.MustParseURL("curl"))
 
136
        c.Assert(called, jc.IsTrue)
 
137
}
 
138
 
 
139
func (s *serviceSuite) TestServiceSetCharm(c *gc.C) {
 
140
        var called bool
 
141
        service.PatchFacadeCall(s, s.client, func(request string, a, response interface{}) error {
 
142
                called = true
 
143
                c.Assert(request, gc.Equals, "SetCharm")
 
144
                args, ok := a.(params.ServiceSetCharm)
 
145
                c.Assert(ok, jc.IsTrue)
 
146
                c.Assert(args.ServiceName, gc.Equals, "service")
 
147
                c.Assert(args.CharmUrl, gc.Equals, "charmURL")
 
148
                c.Assert(args.ForceSeries, gc.Equals, true)
 
149
                c.Assert(args.ForceUnits, gc.Equals, true)
 
150
                return nil
 
151
        })
 
152
        cfg := service.SetCharmConfig{
 
153
                ServiceName: "service",
 
154
                CharmUrl:    "charmURL",
 
155
                ForceSeries: true,
 
156
                ForceUnits:  true,
 
157
        }
 
158
        err := s.client.SetCharm(cfg)
 
159
        c.Assert(err, jc.ErrorIsNil)
 
160
        c.Assert(called, jc.IsTrue)
 
161
}