← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/worker/applicationscaler/manifold_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/worker/applicationscaler/manifold_test.go
 
1
// Copyright 2016 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package applicationscaler_test
 
5
 
 
6
import (
 
7
        "github.com/juju/errors"
 
8
        "github.com/juju/testing"
 
9
        jc "github.com/juju/testing/checkers"
 
10
        gc "gopkg.in/check.v1"
 
11
 
 
12
        "github.com/juju/juju/api/base"
 
13
        "github.com/juju/juju/worker"
 
14
        "github.com/juju/juju/worker/applicationscaler"
 
15
        "github.com/juju/juju/worker/dependency"
 
16
        dt "github.com/juju/juju/worker/dependency/testing"
 
17
)
 
18
 
 
19
type ManifoldSuite struct {
 
20
        testing.IsolationSuite
 
21
}
 
22
 
 
23
var _ = gc.Suite(&ManifoldSuite{})
 
24
 
 
25
func (s *ManifoldSuite) TestInputs(c *gc.C) {
 
26
        manifold := applicationscaler.Manifold(applicationscaler.ManifoldConfig{
 
27
                APICallerName: "washington the terrible",
 
28
        })
 
29
        c.Check(manifold.Inputs, jc.DeepEquals, []string{"washington the terrible"})
 
30
}
 
31
 
 
32
func (s *ManifoldSuite) TestOutput(c *gc.C) {
 
33
        manifold := applicationscaler.Manifold(applicationscaler.ManifoldConfig{})
 
34
        c.Check(manifold.Output, gc.IsNil)
 
35
}
 
36
 
 
37
func (s *ManifoldSuite) TestStartMissingAPICaller(c *gc.C) {
 
38
        manifold := applicationscaler.Manifold(applicationscaler.ManifoldConfig{
 
39
                APICallerName: "api-caller",
 
40
        })
 
41
        context := dt.StubContext(nil, map[string]interface{}{
 
42
                "api-caller": dependency.ErrMissing,
 
43
        })
 
44
 
 
45
        worker, err := manifold.Start(context)
 
46
        c.Check(errors.Cause(err), gc.Equals, dependency.ErrMissing)
 
47
        c.Check(worker, gc.IsNil)
 
48
}
 
49
 
 
50
func (s *ManifoldSuite) TestStartFacadeError(c *gc.C) {
 
51
        expectCaller := &fakeCaller{}
 
52
        manifold := applicationscaler.Manifold(applicationscaler.ManifoldConfig{
 
53
                APICallerName: "api-caller",
 
54
                NewFacade: func(apiCaller base.APICaller) (applicationscaler.Facade, error) {
 
55
                        c.Check(apiCaller, gc.Equals, expectCaller)
 
56
                        return nil, errors.New("blort")
 
57
                },
 
58
        })
 
59
        context := dt.StubContext(nil, map[string]interface{}{
 
60
                "api-caller": expectCaller,
 
61
        })
 
62
 
 
63
        worker, err := manifold.Start(context)
 
64
        c.Check(err, gc.ErrorMatches, "blort")
 
65
        c.Check(worker, gc.IsNil)
 
66
}
 
67
 
 
68
func (s *ManifoldSuite) TestStartWorkerError(c *gc.C) {
 
69
        expectFacade := &fakeFacade{}
 
70
        manifold := applicationscaler.Manifold(applicationscaler.ManifoldConfig{
 
71
                APICallerName: "api-caller",
 
72
                NewFacade: func(_ base.APICaller) (applicationscaler.Facade, error) {
 
73
                        return expectFacade, nil
 
74
                },
 
75
                NewWorker: func(config applicationscaler.Config) (worker.Worker, error) {
 
76
                        c.Check(config.Validate(), jc.ErrorIsNil)
 
77
                        c.Check(config.Facade, gc.Equals, expectFacade)
 
78
                        return nil, errors.New("splot")
 
79
                },
 
80
        })
 
81
        context := dt.StubContext(nil, map[string]interface{}{
 
82
                "api-caller": &fakeCaller{},
 
83
        })
 
84
 
 
85
        worker, err := manifold.Start(context)
 
86
        c.Check(err, gc.ErrorMatches, "splot")
 
87
        c.Check(worker, gc.IsNil)
 
88
}
 
89
 
 
90
func (s *ManifoldSuite) TestSuccess(c *gc.C) {
 
91
        expectWorker := &fakeWorker{}
 
92
        manifold := applicationscaler.Manifold(applicationscaler.ManifoldConfig{
 
93
                APICallerName: "api-caller",
 
94
                NewFacade: func(_ base.APICaller) (applicationscaler.Facade, error) {
 
95
                        return &fakeFacade{}, nil
 
96
                },
 
97
                NewWorker: func(_ applicationscaler.Config) (worker.Worker, error) {
 
98
                        return expectWorker, nil
 
99
                },
 
100
        })
 
101
        context := dt.StubContext(nil, map[string]interface{}{
 
102
                "api-caller": &fakeCaller{},
 
103
        })
 
104
 
 
105
        worker, err := manifold.Start(context)
 
106
        c.Check(err, jc.ErrorIsNil)
 
107
        c.Check(worker, gc.Equals, expectWorker)
 
108
}
 
109
 
 
110
type fakeCaller struct {
 
111
        base.APICaller
 
112
}
 
113
 
 
114
type fakeFacade struct {
 
115
        applicationscaler.Facade
 
116
}
 
117
 
 
118
type fakeWorker struct {
 
119
        worker.Worker
 
120
}