← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/api/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/api/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
        "fmt"
 
9
 
 
10
        jc "github.com/juju/testing/checkers"
 
11
        gc "gopkg.in/check.v1"
 
12
        "gopkg.in/juju/names.v2"
 
13
 
 
14
        "github.com/juju/juju/api/base/testing"
 
15
        "github.com/juju/juju/api/diskmanager"
 
16
        "github.com/juju/juju/apiserver/params"
 
17
        "github.com/juju/juju/storage"
 
18
        coretesting "github.com/juju/juju/testing"
 
19
)
 
20
 
 
21
var _ = gc.Suite(&DiskManagerSuite{})
 
22
 
 
23
type DiskManagerSuite struct {
 
24
        coretesting.BaseSuite
 
25
}
 
26
 
 
27
func (s *DiskManagerSuite) TestSetMachineBlockDevices(c *gc.C) {
 
28
        devices := []storage.BlockDevice{{
 
29
                DeviceName: "sda",
 
30
                Size:       123,
 
31
        }, {
 
32
                DeviceName: "sdb",
 
33
                UUID:       "asdadasdasdas",
 
34
        }}
 
35
 
 
36
        var callCount int
 
37
        apiCaller := testing.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
 
38
                c.Check(objType, gc.Equals, "DiskManager")
 
39
                c.Check(version, gc.Equals, 0)
 
40
                c.Check(id, gc.Equals, "")
 
41
                c.Check(request, gc.Equals, "SetMachineBlockDevices")
 
42
                c.Check(arg, gc.DeepEquals, params.SetMachineBlockDevices{
 
43
                        MachineBlockDevices: []params.MachineBlockDevices{{
 
44
                                Machine:      "machine-123",
 
45
                                BlockDevices: devices,
 
46
                        }},
 
47
                })
 
48
                c.Assert(result, gc.FitsTypeOf, &params.ErrorResults{})
 
49
                *(result.(*params.ErrorResults)) = params.ErrorResults{
 
50
                        Results: []params.ErrorResult{{
 
51
                                Error: nil,
 
52
                        }},
 
53
                }
 
54
                callCount++
 
55
                return nil
 
56
        })
 
57
 
 
58
        st := diskmanager.NewState(apiCaller, names.NewMachineTag("123"))
 
59
        err := st.SetMachineBlockDevices(devices)
 
60
        c.Check(err, jc.ErrorIsNil)
 
61
        c.Check(callCount, gc.Equals, 1)
 
62
}
 
63
 
 
64
func (s *DiskManagerSuite) TestSetMachineBlockDevicesNil(c *gc.C) {
 
65
        var callCount int
 
66
        apiCaller := testing.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
 
67
                c.Check(arg, gc.DeepEquals, params.SetMachineBlockDevices{
 
68
                        MachineBlockDevices: []params.MachineBlockDevices{{
 
69
                                Machine: "machine-123",
 
70
                        }},
 
71
                })
 
72
                c.Assert(result, gc.FitsTypeOf, &params.ErrorResults{})
 
73
                *(result.(*params.ErrorResults)) = params.ErrorResults{
 
74
                        Results: []params.ErrorResult{{
 
75
                                Error: nil,
 
76
                        }},
 
77
                }
 
78
                callCount++
 
79
                return nil
 
80
        })
 
81
        st := diskmanager.NewState(apiCaller, names.NewMachineTag("123"))
 
82
        err := st.SetMachineBlockDevices(nil)
 
83
        c.Check(err, jc.ErrorIsNil)
 
84
        c.Check(callCount, gc.Equals, 1)
 
85
}
 
86
 
 
87
func (s *DiskManagerSuite) TestSetMachineBlockDevicesClientError(c *gc.C) {
 
88
        apiCaller := testing.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
 
89
                return errors.New("blargh")
 
90
        })
 
91
        st := diskmanager.NewState(apiCaller, names.NewMachineTag("123"))
 
92
        err := st.SetMachineBlockDevices(nil)
 
93
        c.Check(err, gc.ErrorMatches, "blargh")
 
94
}
 
95
 
 
96
func (s *DiskManagerSuite) TestSetMachineBlockDevicesServerError(c *gc.C) {
 
97
        apiCaller := testing.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
 
98
                *(result.(*params.ErrorResults)) = params.ErrorResults{
 
99
                        Results: []params.ErrorResult{{
 
100
                                Error: &params.Error{Message: "MSG", Code: "621"},
 
101
                        }},
 
102
                }
 
103
                return nil
 
104
        })
 
105
        st := diskmanager.NewState(apiCaller, names.NewMachineTag("123"))
 
106
        err := st.SetMachineBlockDevices(nil)
 
107
        c.Check(err, gc.ErrorMatches, "MSG")
 
108
}
 
109
 
 
110
func (s *DiskManagerSuite) TestSetMachineBlockDevicesResultCountInvalid(c *gc.C) {
 
111
        for _, n := range []int{0, 2} {
 
112
                apiCaller := testing.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
 
113
                        var results []params.ErrorResult
 
114
                        for i := 0; i < n; i++ {
 
115
                                results = append(results, params.ErrorResult{
 
116
                                        Error: &params.Error{Message: "MSG", Code: "621"},
 
117
                                })
 
118
                        }
 
119
                        *(result.(*params.ErrorResults)) = params.ErrorResults{Results: results}
 
120
                        return nil
 
121
                })
 
122
                st := diskmanager.NewState(apiCaller, names.NewMachineTag("123"))
 
123
                err := st.SetMachineBlockDevices(nil)
 
124
                c.Check(err, gc.ErrorMatches, fmt.Sprintf("expected 1 result, got %d", n))
 
125
        }
 
126
}