← Back to branch summary

~themue/pyjuju/go-state-auth

« back to all changes in this revision

Viewing changes to state/state_test.go

  • Committer: Frank Mueller
  • Date: 2011-12-20 10:52:07 UTC
  • mto: This revision was merged to the branch mainline in revision 33.
  • Revision ID: frank.mueller@canonical.com-20111220105207-4trmfrtjxzqu3nq5
Initial adding of state for review.

Show diffs side-by-side

added added

removed removed

Lines of Context:
state/state_test.go
 
1
// launchpad.net/juju/go/state
 
2
//
 
3
// Copyright (c) 2011 Canonical Ltd.
 
4
 
 
5
package state
 
6
 
 
7
// --------------------
 
8
// IMPORT
 
9
// --------------------
 
10
 
 
11
import (
 
12
        "errors"
 
13
        "fmt"
 
14
        . "launchpad.net/gocheck"
 
15
        "launchpad.net/goyaml"
 
16
        "launchpad.net/gozk/zookeeper"
 
17
        "testing"
 
18
        "time"
 
19
)
 
20
 
 
21
// --------------------
 
22
// TEST DATA
 
23
// --------------------
 
24
 
 
25
// testTopology is a topology as YAML string.
 
26
const testTopology = `
 
27
services:
 
28
    s-0:
 
29
        name: service-zero
 
30
        charm: my-charm-zero
 
31
        units:
 
32
            u-0:
 
33
                sequence: 0
 
34
            u-1:
 
35
                sequence: 1
 
36
    s-1:
 
37
        name: service-one
 
38
        charm: my-charm-one
 
39
        units:
 
40
    s-2:
 
41
        name: service-two
 
42
        charm: my-charm-two
 
43
        units:
 
44
unit-sequence:
 
45
    service-zero: 2
 
46
    service-one: 0
 
47
    service-two: 0
 
48
`
 
49
 
 
50
// unmarshalTestTopology returns the testTopology as
 
51
// topologyNodes.
 
52
func unmarshalTestTopology(c *C) topologyNodes {
 
53
        tn := newTopologyNodes()
 
54
 
 
55
        if err := goyaml.Unmarshal([]byte(testTopology), &tn); err != nil {
 
56
                c.Fail()
 
57
 
 
58
                return nil
 
59
        }
 
60
 
 
61
        return tn
 
62
}
 
63
 
 
64
// setTestTopology sets the topology nodes in ZooKeeper.
 
65
func setTestTopology(zkc *zookeeper.Conn, c *C) {
 
66
        _, err := zkc.Create("/topology", testTopology, zookeeper.EPHEMERAL, zookeeper.WorldACL(zookeeper.PERM_ALL))
 
67
 
 
68
        if err != nil {
 
69
                c.Fatal("Cannot set test topology in ZooKeeper: ", err)
 
70
        }
 
71
}
 
72
 
 
73
// --------------------
 
74
// TESTING
 
75
// --------------------
 
76
 
 
77
func TestPackage(t *testing.T) {
 
78
        TestingT(t)
 
79
}
 
80
 
 
81
// --------------------
 
82
// TOPOLOGY NODE
 
83
// --------------------
 
84
 
 
85
// TopologyNodeSuite for topologyNode.
 
86
type TopologyNodeSuite struct{}
 
87
 
 
88
var _ = Suite(&TopologyNodeSuite{})
 
89
 
 
90
// TestFind tests the find method of the topologyNodes.
 
91
func (tn TopologyNodeSuite) TestFind(c *C) {
 
92
        n := unmarshalTestTopology(c)
 
93
 
 
94
        var data interface{}
 
95
        var err error
 
96
 
 
97
        data, err = n.find([]string{"services", "s-0", "name"})
 
98
 
 
99
        c.Assert(data, Equals, "service-zero")
 
100
        c.Assert(err, IsNil)
 
101
 
 
102
        data, err = n.find([]string{"services", "s-0"})
 
103
 
 
104
        c.Assert(data, FitsTypeOf, newTopologyNodes())
 
105
        c.Assert(err, IsNil)
 
106
 
 
107
        data, err = n.find([]string{"unknown", "path", "with", "no", "result"})
 
108
 
 
109
        c.Assert(data, IsNil)
 
110
        c.Assert(err, FitsTypeOf, errors.New(""))
 
111
}
 
112
 
 
113
// TestGetString tests the getString method of the topologyNodes.
 
114
func (tn TopologyNodeSuite) TestGetString(c *C) {
 
115
        n := unmarshalTestTopology(c)
 
116
 
 
117
        var data string
 
118
        var err error
 
119
 
 
120
        data, err = n.getString("/services/s-0/name/")
 
121
 
 
122
        c.Assert(data, Equals, "service-zero")
 
123
        c.Assert(err, IsNil)
 
124
 
 
125
        data, err = n.getString("/services/s-0")
 
126
 
 
127
        c.Assert(data, Equals, "")
 
128
        c.Assert(err, FitsTypeOf, errors.New(""))
 
129
 
 
130
        data, err = n.getString("/unknown/path/with/no/result")
 
131
 
 
132
        c.Assert(data, Equals, "")
 
133
        c.Assert(err, FitsTypeOf, errors.New(""))
 
134
}
 
135
 
 
136
// TestGetNodes tests the getNodes method of the topologyNodes.
 
137
func (tn TopologyNodeSuite) TestGetNodes(c *C) {
 
138
        n := unmarshalTestTopology(c)
 
139
 
 
140
        var data topologyNodes
 
141
        var err error
 
142
 
 
143
        data, err = n.getNodes("/services/s-0/name/")
 
144
 
 
145
        c.Assert(data, IsNil)
 
146
        c.Assert(err, FitsTypeOf, errors.New(""))
 
147
 
 
148
        data, err = n.getNodes("/services/s-0")
 
149
 
 
150
        c.Assert(data, FitsTypeOf, newTopologyNodes())
 
151
        c.Assert(err, IsNil)
 
152
 
 
153
        data, err = n.getNodes("/unknown/path/with/no/result")
 
154
 
 
155
        c.Assert(data, IsNil)
 
156
        c.Assert(err, FitsTypeOf, errors.New(""))
 
157
}
 
158
 
 
159
// TestSearch tests the search method of the topologyNodes.
 
160
func (tn TopologyNodeSuite) TestSearch(c *C) {
 
161
        n := unmarshalTestTopology(c)
 
162
 
 
163
        path, value, err := n.search(func(p []string, v interface{}) bool {
 
164
                if len(p) == 3 && p[0] == "services" && p[len(p)-1] == "name" && v == "service-one" {
 
165
                        return true
 
166
                }
 
167
 
 
168
                return false
 
169
        })
 
170
 
 
171
        c.Assert(err, IsNil)
 
172
        c.Assert(path[1], Equals, "s-1")
 
173
        c.Assert(value, Not(IsNil))
 
174
}
 
175
 
 
176
// --------------------
 
177
// STATE
 
178
// --------------------
 
179
 
 
180
// StateSuite for State and the related types.
 
181
type StateSuite struct {
 
182
        zkServer   *zookeeper.Server
 
183
        zkConn     *zookeeper.Conn
 
184
        zkTestRoot string
 
185
        zkTestPort int
 
186
        zkAddr     string
 
187
}
 
188
 
 
189
var _ = Suite(&StateSuite{})
 
190
 
 
191
// SetUpSuite starts and inits ZooKeeper.
 
192
func (s *StateSuite) SetUpSuite(c *C) {
 
193
        var err error
 
194
 
 
195
        // Start server.
 
196
        s.zkTestRoot = c.MkDir() + "/zookeeper"
 
197
        s.zkTestPort = 21812
 
198
        s.zkAddr = fmt.Sprint("localhost:", s.zkTestPort)
 
199
 
 
200
        s.zkServer, err = zookeeper.CreateServer(s.zkTestPort, s.zkTestRoot, "")
 
201
 
 
202
        if err != nil {
 
203
                c.Fatal("Cannot set up ZooKeeper server environment: ", err)
 
204
        }
 
205
 
 
206
        err = s.zkServer.Start()
 
207
 
 
208
        if err != nil {
 
209
                c.Fatal("Cannot start ZooKeeper server: ", err)
 
210
        }
 
211
 
 
212
        // Establish connection after around a minute."
 
213
        time.Sleep(60e9)
 
214
 
 
215
        s.zkConn, _, err = zookeeper.Dial(s.zkAddr, 5e9)
 
216
 
 
217
        if err != nil {
 
218
                c.Fatal("Cannot establish ZooKeeper connection: ", err)
 
219
        }
 
220
 
 
221
        setTestTopology(s.zkConn, c)
 
222
}
 
223
 
 
224
// TearDownSuite stops ZooKeeper.
 
225
func (s *StateSuite) TearDownSuite(c *C) {
 
226
        if s.zkServer != nil {
 
227
                if s.zkConn != nil {
 
228
                        // s.zkConn.Close()
 
229
                }
 
230
 
 
231
                s.zkServer.Destroy()
 
232
        }
 
233
}
 
234
 
 
235
// TestService tests the Service  method of the State.
 
236
func (s StateSuite) TestService(c *C) {
 
237
        var err error
 
238
        var state *State
 
239
        var service *Service
 
240
 
 
241
        state, err = Open(s.zkConn)
 
242
 
 
243
        c.Assert(err, IsNil)
 
244
        c.Assert(state, Not(IsNil))
 
245
 
 
246
        service, err = state.Service("service-one")
 
247
 
 
248
        c.Assert(err, IsNil)
 
249
        c.Assert(service, Not(IsNil))
 
250
        c.Assert(service.CharmId(), Equals, "my-charm-one")
 
251
}
 
252
 
 
253
// EOF