← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/apiserver/diskmanager/diskmanager_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/diskmanager/diskmanager_test.go
 
1
// Copyright 2014 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package diskmanager_test
 
5
 
 
6
import (
 
7
        "errors"
 
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/diskmanager"
 
15
        "github.com/juju/juju/apiserver/params"
 
16
        apiservertesting "github.com/juju/juju/apiserver/testing"
 
17
        "github.com/juju/juju/state"
 
18
        "github.com/juju/juju/storage"
 
19
        coretesting "github.com/juju/juju/testing"
 
20
)
 
21
 
 
22
var _ = gc.Suite(&DiskManagerSuite{})
 
23
 
 
24
type DiskManagerSuite struct {
 
25
        coretesting.BaseSuite
 
26
        resources  *common.Resources
 
27
        authorizer *apiservertesting.FakeAuthorizer
 
28
        st         *mockState
 
29
        api        *diskmanager.DiskManagerAPI
 
30
}
 
31
 
 
32
func (s *DiskManagerSuite) SetUpTest(c *gc.C) {
 
33
        s.BaseSuite.SetUpTest(c)
 
34
        s.resources = common.NewResources()
 
35
        tag := names.NewMachineTag("0")
 
36
        s.authorizer = &apiservertesting.FakeAuthorizer{Tag: tag}
 
37
        s.st = &mockState{}
 
38
        diskmanager.PatchState(s, s.st)
 
39
 
 
40
        var err error
 
41
        s.api, err = diskmanager.NewDiskManagerAPI(nil, nil, s.authorizer)
 
42
        c.Assert(err, jc.ErrorIsNil)
 
43
}
 
44
 
 
45
func (s *DiskManagerSuite) TestSetMachineBlockDevices(c *gc.C) {
 
46
        devices := []storage.BlockDevice{{DeviceName: "sda"}, {DeviceName: "sdb"}}
 
47
        results, err := s.api.SetMachineBlockDevices(params.SetMachineBlockDevices{
 
48
                MachineBlockDevices: []params.MachineBlockDevices{{
 
49
                        Machine:      "machine-0",
 
50
                        BlockDevices: devices,
 
51
                }},
 
52
        })
 
53
        c.Assert(err, jc.ErrorIsNil)
 
54
        c.Assert(results, gc.DeepEquals, params.ErrorResults{
 
55
                Results: []params.ErrorResult{{Error: nil}},
 
56
        })
 
57
}
 
58
 
 
59
func (s *DiskManagerSuite) TestSetMachineBlockDevicesEmptyArgs(c *gc.C) {
 
60
        results, err := s.api.SetMachineBlockDevices(params.SetMachineBlockDevices{})
 
61
        c.Assert(err, jc.ErrorIsNil)
 
62
        c.Assert(results.Results, gc.HasLen, 0)
 
63
}
 
64
 
 
65
func (s *DiskManagerSuite) TestNewDiskManagerAPINonMachine(c *gc.C) {
 
66
        tag := names.NewUnitTag("mysql/0")
 
67
        s.authorizer = &apiservertesting.FakeAuthorizer{Tag: tag}
 
68
        _, err := diskmanager.NewDiskManagerAPI(nil, nil, s.authorizer)
 
69
        c.Assert(err, gc.ErrorMatches, "permission denied")
 
70
}
 
71
 
 
72
func (s *DiskManagerSuite) TestSetMachineBlockDevicesInvalidTags(c *gc.C) {
 
73
        results, err := s.api.SetMachineBlockDevices(params.SetMachineBlockDevices{
 
74
                MachineBlockDevices: []params.MachineBlockDevices{{
 
75
                        Machine: "machine-0",
 
76
                }, {
 
77
                        Machine: "machine-1",
 
78
                }, {
 
79
                        Machine: "unit-mysql-0",
 
80
                }},
 
81
        })
 
82
        c.Assert(err, jc.ErrorIsNil)
 
83
        c.Assert(results, gc.DeepEquals, params.ErrorResults{
 
84
                Results: []params.ErrorResult{{
 
85
                        Error: nil,
 
86
                }, {
 
87
                        Error: &params.Error{Message: "permission denied", Code: "unauthorized access"},
 
88
                }, {
 
89
                        Error: &params.Error{Message: "permission denied", Code: "unauthorized access"},
 
90
                }},
 
91
        })
 
92
        c.Assert(s.st.calls, gc.Equals, 1)
 
93
}
 
94
 
 
95
func (s *DiskManagerSuite) TestSetMachineBlockDevicesStateError(c *gc.C) {
 
96
        s.st.err = errors.New("boom")
 
97
        results, err := s.api.SetMachineBlockDevices(params.SetMachineBlockDevices{
 
98
                MachineBlockDevices: []params.MachineBlockDevices{{
 
99
                        Machine: "machine-0",
 
100
                }},
 
101
        })
 
102
        c.Assert(err, jc.ErrorIsNil)
 
103
        c.Assert(results, gc.DeepEquals, params.ErrorResults{
 
104
                Results: []params.ErrorResult{{
 
105
                        Error: &params.Error{Message: "boom", Code: ""},
 
106
                }},
 
107
        })
 
108
}
 
109
 
 
110
type mockState struct {
 
111
        calls   int
 
112
        devices map[string][]state.BlockDeviceInfo
 
113
        err     error
 
114
}
 
115
 
 
116
func (st *mockState) SetMachineBlockDevices(machineId string, devices []state.BlockDeviceInfo) error {
 
117
        st.calls++
 
118
        if st.devices == nil {
 
119
                st.devices = make(map[string][]state.BlockDeviceInfo)
 
120
        }
 
121
        st.devices[machineId] = devices
 
122
        return st.err
 
123
}