← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/apiserver/common/remove_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/apiserver/common/remove_test.go
 
1
// Copyright 2013 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package common_test
 
5
 
 
6
import (
 
7
        "fmt"
 
8
 
 
9
        jc "github.com/juju/testing/checkers"
 
10
        gc "gopkg.in/check.v1"
 
11
        "gopkg.in/juju/names.v2"
 
12
 
 
13
        "github.com/juju/juju/apiserver/common"
 
14
        "github.com/juju/juju/apiserver/params"
 
15
        apiservertesting "github.com/juju/juju/apiserver/testing"
 
16
        "github.com/juju/juju/state"
 
17
)
 
18
 
 
19
type removeSuite struct{}
 
20
 
 
21
var _ = gc.Suite(&removeSuite{})
 
22
 
 
23
type fakeRemover struct {
 
24
        state.Entity
 
25
        life          state.Life
 
26
        errEnsureDead error
 
27
        errRemove     error
 
28
        fetchError
 
29
}
 
30
 
 
31
func (r *fakeRemover) EnsureDead() error {
 
32
        return r.errEnsureDead
 
33
}
 
34
 
 
35
func (r *fakeRemover) Remove() error {
 
36
        return r.errRemove
 
37
}
 
38
 
 
39
func (r *fakeRemover) Life() state.Life {
 
40
        return r.life
 
41
}
 
42
 
 
43
func (*removeSuite) TestRemove(c *gc.C) {
 
44
        st := &fakeState{
 
45
                entities: map[names.Tag]entityWithError{
 
46
                        u("x/0"): &fakeRemover{life: state.Dying, errEnsureDead: fmt.Errorf("x0 EnsureDead fails")},
 
47
                        u("x/1"): &fakeRemover{life: state.Dying, errRemove: fmt.Errorf("x1 Remove fails")},
 
48
                        u("x/2"): &fakeRemover{life: state.Alive},
 
49
                        u("x/3"): &fakeRemover{life: state.Dying},
 
50
                        u("x/4"): &fakeRemover{life: state.Dead},
 
51
                        u("x/5"): &fakeRemover{fetchError: "x5 error"},
 
52
                },
 
53
        }
 
54
        getCanModify := func() (common.AuthFunc, error) {
 
55
                u0 := u("x/0")
 
56
                u1 := u("x/1")
 
57
                u2 := u("x/2")
 
58
                u3 := u("x/3")
 
59
                u5 := u("x/5")
 
60
                return func(tag names.Tag) bool {
 
61
                        return tag == u0 || tag == u1 || tag == u2 || tag == u3 || tag == u5
 
62
                }, nil
 
63
        }
 
64
 
 
65
        r := common.NewRemover(st, true, getCanModify)
 
66
        entities := params.Entities{[]params.Entity{
 
67
                {"unit-x-0"}, {"unit-x-1"}, {"unit-x-2"}, {"unit-x-3"}, {"unit-x-4"}, {"unit-x-5"}, {"unit-x-6"},
 
68
        }}
 
69
        result, err := r.Remove(entities)
 
70
        c.Assert(err, jc.ErrorIsNil)
 
71
        c.Assert(result, gc.DeepEquals, params.ErrorResults{
 
72
                Results: []params.ErrorResult{
 
73
                        {&params.Error{Message: "x0 EnsureDead fails"}},
 
74
                        {&params.Error{Message: "x1 Remove fails"}},
 
75
                        {&params.Error{Message: `cannot remove entity "unit-x-2": still alive`}},
 
76
                        {nil},
 
77
                        {apiservertesting.ErrUnauthorized},
 
78
                        {&params.Error{Message: "x5 error"}},
 
79
                        {apiservertesting.ErrUnauthorized},
 
80
                },
 
81
        })
 
82
 
 
83
        // Make sure when callEnsureDead is false EnsureDead() doesn't
 
84
        // get called.
 
85
        r = common.NewRemover(st, false, getCanModify)
 
86
        entities = params.Entities{[]params.Entity{{"unit-x-0"}, {"unit-x-1"}}}
 
87
        result, err = r.Remove(entities)
 
88
        c.Assert(err, jc.ErrorIsNil)
 
89
        c.Assert(result, gc.DeepEquals, params.ErrorResults{
 
90
                Results: []params.ErrorResult{
 
91
                        {nil},
 
92
                        {&params.Error{Message: "x1 Remove fails"}},
 
93
                },
 
94
        })
 
95
}
 
96
 
 
97
func (*removeSuite) TestRemoveError(c *gc.C) {
 
98
        getCanModify := func() (common.AuthFunc, error) {
 
99
                return nil, fmt.Errorf("pow")
 
100
        }
 
101
        r := common.NewRemover(&fakeState{}, true, getCanModify)
 
102
        _, err := r.Remove(params.Entities{[]params.Entity{{"x0"}}})
 
103
        c.Assert(err, gc.ErrorMatches, "pow")
 
104
}
 
105
 
 
106
func (*removeSuite) TestRemoveNoArgsNoError(c *gc.C) {
 
107
        getCanModify := func() (common.AuthFunc, error) {
 
108
                return nil, fmt.Errorf("pow")
 
109
        }
 
110
        r := common.NewRemover(&fakeState{}, true, getCanModify)
 
111
        result, err := r.Remove(params.Entities{})
 
112
        c.Assert(err, jc.ErrorIsNil)
 
113
        c.Assert(result.Results, gc.HasLen, 0)
 
114
}