← Back to branch summary

~juju-qa/ubuntu/xenial/juju/xenial-2.0-beta3

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/core/description/ports_test.go

  • Committer: Martin Packman
  • Date: 2016-03-30 19:31:08 UTC
  • mfrom: (1.1.41)
  • Revision ID: martin.packman@canonical.com-20160330193108-h9iz3ak334uk0z5r
Merge new upstream source 2.0~beta3

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/core/description/ports_test.go
 
1
// Copyright 2016 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package description
 
5
 
 
6
import (
 
7
        jc "github.com/juju/testing/checkers"
 
8
        gc "gopkg.in/check.v1"
 
9
        "gopkg.in/yaml.v2"
 
10
)
 
11
 
 
12
type PortRangeCheck struct{}
 
13
 
 
14
func (*PortRangeCheck) AssertPortRange(c *gc.C, pr PortRange, args PortRangeArgs) {
 
15
        c.Assert(pr.UnitName(), gc.Equals, args.UnitName)
 
16
        c.Assert(pr.FromPort(), gc.Equals, args.FromPort)
 
17
        c.Assert(pr.ToPort(), gc.Equals, args.ToPort)
 
18
        c.Assert(pr.Protocol(), gc.Equals, args.Protocol)
 
19
}
 
20
 
 
21
type NetworkPortsSerializationSuite struct {
 
22
        SliceSerializationSuite
 
23
        PortRangeCheck
 
24
}
 
25
 
 
26
var _ = gc.Suite(&NetworkPortsSerializationSuite{})
 
27
 
 
28
func (s *NetworkPortsSerializationSuite) SetUpTest(c *gc.C) {
 
29
        s.SliceSerializationSuite.SetUpTest(c)
 
30
        s.importName = "network-ports"
 
31
        s.sliceName = "network-ports"
 
32
        s.importFunc = func(m map[string]interface{}) (interface{}, error) {
 
33
                return importNetworkPorts(m)
 
34
        }
 
35
        s.testFields = func(m map[string]interface{}) {
 
36
                m["network-ports"] = []interface{}{}
 
37
        }
 
38
}
 
39
 
 
40
func (s *NetworkPortsSerializationSuite) TestNewNetworkPorts(c *gc.C) {
 
41
        args := NetworkPortsArgs{
 
42
                NetworkName: "special",
 
43
                OpenPorts: []PortRangeArgs{
 
44
                        PortRangeArgs{
 
45
                                UnitName: "magic/0",
 
46
                                FromPort: 1234,
 
47
                                ToPort:   2345,
 
48
                                Protocol: "tcp",
 
49
                        },
 
50
                        PortRangeArgs{
 
51
                                UnitName: "magic/0",
 
52
                                FromPort: 1234,
 
53
                                ToPort:   2345,
 
54
                                Protocol: "udp",
 
55
                        },
 
56
                },
 
57
        }
 
58
 
 
59
        ports := newNetworkPorts(args)
 
60
        c.Assert(ports.NetworkName(), gc.Equals, args.NetworkName)
 
61
        opened := ports.OpenPorts()
 
62
        c.Assert(opened, gc.HasLen, 2)
 
63
        s.AssertPortRange(c, opened[0], args.OpenPorts[0])
 
64
        s.AssertPortRange(c, opened[1], args.OpenPorts[1])
 
65
}
 
66
 
 
67
func (*NetworkPortsSerializationSuite) TestParsingSerializedData(c *gc.C) {
 
68
        initial := &versionedNetworkPorts{
 
69
                Version: 1,
 
70
                NetworkPorts_: []*networkPorts{
 
71
                        &networkPorts{
 
72
                                NetworkName_: "storage",
 
73
                                OpenPorts_: &portRanges{
 
74
                                        Version: 1,
 
75
                                        OpenPorts_: []*portRange{
 
76
                                                &portRange{
 
77
                                                        UnitName_: "magic/0",
 
78
                                                        FromPort_: 1234,
 
79
                                                        ToPort_:   2345,
 
80
                                                        Protocol_: "tcp",
 
81
                                                },
 
82
                                        },
 
83
                                },
 
84
                        },
 
85
                        &networkPorts{
 
86
                                NetworkName_: "workload",
 
87
                                OpenPorts_: &portRanges{
 
88
                                        Version: 1,
 
89
                                        OpenPorts_: []*portRange{
 
90
                                                &portRange{
 
91
                                                        UnitName_: "unicorn/0",
 
92
                                                        FromPort_: 80,
 
93
                                                        ToPort_:   80,
 
94
                                                        Protocol_: "tcp",
 
95
                                                },
 
96
                                        },
 
97
                                },
 
98
                        },
 
99
                },
 
100
        }
 
101
 
 
102
        bytes, err := yaml.Marshal(initial)
 
103
        c.Assert(err, jc.ErrorIsNil)
 
104
 
 
105
        var source map[string]interface{}
 
106
        err = yaml.Unmarshal(bytes, &source)
 
107
        c.Assert(err, jc.ErrorIsNil)
 
108
 
 
109
        imported, err := importNetworkPorts(source)
 
110
        c.Assert(err, jc.ErrorIsNil)
 
111
 
 
112
        c.Assert(imported, jc.DeepEquals, initial.NetworkPorts_)
 
113
}
 
114
 
 
115
type PortRangeSerializationSuite struct {
 
116
        SliceSerializationSuite
 
117
        PortRangeCheck
 
118
}
 
119
 
 
120
var _ = gc.Suite(&PortRangeSerializationSuite{})
 
121
 
 
122
func (s *PortRangeSerializationSuite) SetUpTest(c *gc.C) {
 
123
        s.SliceSerializationSuite.SetUpTest(c)
 
124
        s.importName = "port-range"
 
125
        s.sliceName = "open-ports"
 
126
        s.importFunc = func(m map[string]interface{}) (interface{}, error) {
 
127
                return importPortRanges(m)
 
128
        }
 
129
        s.testFields = func(m map[string]interface{}) {
 
130
                m["open-ports"] = []interface{}{}
 
131
        }
 
132
}
 
133
 
 
134
func (s *PortRangeSerializationSuite) TestNewPortRange(c *gc.C) {
 
135
        args := PortRangeArgs{
 
136
                UnitName: "magic/0",
 
137
                FromPort: 1234,
 
138
                ToPort:   2345,
 
139
                Protocol: "tcp",
 
140
        }
 
141
        pr := newPortRange(args)
 
142
        s.AssertPortRange(c, pr, args)
 
143
}
 
144
 
 
145
func (*PortRangeSerializationSuite) TestParsingSerializedData(c *gc.C) {
 
146
        initial := &portRanges{
 
147
                Version: 1,
 
148
                OpenPorts_: []*portRange{
 
149
                        &portRange{
 
150
                                UnitName_: "magic/0",
 
151
                                FromPort_: 1234,
 
152
                                ToPort_:   2345,
 
153
                                Protocol_: "tcp",
 
154
                        },
 
155
                        &portRange{
 
156
                                UnitName_: "unicorn/1",
 
157
                                FromPort_: 8080,
 
158
                                ToPort_:   8080,
 
159
                                Protocol_: "tcp",
 
160
                        },
 
161
                },
 
162
        }
 
163
 
 
164
        bytes, err := yaml.Marshal(initial)
 
165
        c.Assert(err, jc.ErrorIsNil)
 
166
 
 
167
        var source map[string]interface{}
 
168
        err = yaml.Unmarshal(bytes, &source)
 
169
        c.Assert(err, jc.ErrorIsNil)
 
170
 
 
171
        imported, err := importPortRanges(source)
 
172
        c.Assert(err, jc.ErrorIsNil)
 
173
 
 
174
        c.Assert(imported, jc.DeepEquals, initial.OpenPorts_)
 
175
}