← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/network/portset_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/network/portset_test.go
 
1
// Copyright 2014 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package network_test
 
5
 
 
6
import (
 
7
        "strconv"
 
8
 
 
9
        jc "github.com/juju/testing/checkers"
 
10
        gc "gopkg.in/check.v1"
 
11
 
 
12
        "github.com/juju/juju/network"
 
13
        "github.com/juju/juju/testing"
 
14
)
 
15
 
 
16
type PortSetSuite struct {
 
17
        testing.BaseSuite
 
18
 
 
19
        portRange1 network.PortRange
 
20
        portRange2 network.PortRange
 
21
        portRange3 network.PortRange
 
22
        portRange4 network.PortRange
 
23
}
 
24
 
 
25
var _ = gc.Suite(&PortSetSuite{})
 
26
 
 
27
func (s *PortSetSuite) SetUpTest(c *gc.C) {
 
28
        s.BaseSuite.SetUpTest(c)
 
29
 
 
30
        portRange1, err := network.ParsePortRange("8000-8099/tcp")
 
31
        c.Assert(err, jc.ErrorIsNil)
 
32
        portRange2, err := network.ParsePortRange("80/tcp")
 
33
        c.Assert(err, jc.ErrorIsNil)
 
34
        portRange3, err := network.ParsePortRange("79-81/tcp")
 
35
        c.Assert(err, jc.ErrorIsNil)
 
36
        portRange4, err := network.ParsePortRange("5000-5123/udp")
 
37
        c.Assert(err, jc.ErrorIsNil)
 
38
 
 
39
        s.portRange1 = portRange1
 
40
        s.portRange2 = portRange2
 
41
        s.portRange3 = portRange3
 
42
        s.portRange4 = portRange4
 
43
}
 
44
 
 
45
func (s *PortSetSuite) getPorts(start, end int) []int {
 
46
        var result []int
 
47
        for i := start; i <= end; i++ {
 
48
                result = append(result, i)
 
49
        }
 
50
        return result
 
51
}
 
52
 
 
53
func (s *PortSetSuite) checkPortSet(c *gc.C, ports network.PortSet, protocol string, expected ...int) {
 
54
        var sexpected []string
 
55
        for _, port := range expected {
 
56
                sexpected = append(sexpected, strconv.Itoa(port))
 
57
        }
 
58
        values := ports.PortStrings(protocol)
 
59
 
 
60
        c.Check(values, jc.SameContents, sexpected)
 
61
}
 
62
 
 
63
func (s *PortSetSuite) checkPortSetTCP(c *gc.C, ports network.PortSet, expected ...int) {
 
64
        c.Check(ports.Protocols(), jc.SameContents, []string{"tcp"})
 
65
        s.checkPortSet(c, ports, "tcp", expected...)
 
66
}
 
67
 
 
68
func (s *PortSetSuite) checkPorts(c *gc.C, ports []network.Port, protocol string, expected ...int) {
 
69
        var found []int
 
70
        for _, port := range ports {
 
71
                c.Check(port.Protocol, gc.Equals, protocol)
 
72
                found = append(found, port.Number)
 
73
        }
 
74
        c.Check(found, jc.SameContents, expected)
 
75
}
 
76
 
 
77
func (s *PortSetSuite) TestNewPortSet(c *gc.C) {
 
78
        portSet := network.NewPortSet(s.portRange1)
 
79
        c.Assert(portSet.IsEmpty(), jc.IsFalse)
 
80
 
 
81
        s.checkPortSetTCP(c, portSet, s.getPorts(8000, 8099)...)
 
82
}
 
83
 
 
84
func (s *PortSetSuite) TestPortSetUnion(c *gc.C) {
 
85
        portSet1 := network.NewPortSet(s.portRange2)
 
86
        portSet2 := network.NewPortSet(s.portRange3)
 
87
        result := portSet1.Union(portSet2)
 
88
 
 
89
        s.checkPortSetTCP(c, result, 79, 80, 81)
 
90
}
 
91
 
 
92
func (s *PortSetSuite) TestPortSetIntersection(c *gc.C) {
 
93
        s.portRange2.ToPort = 83
 
94
        portSet1 := network.NewPortSet(s.portRange2)
 
95
        portSet2 := network.NewPortSet(s.portRange3)
 
96
        result := portSet1.Intersection(portSet2)
 
97
 
 
98
        s.checkPortSetTCP(c, result, 80, 81)
 
99
}
 
100
 
 
101
func (s *PortSetSuite) TestPortSetIntersectionEmpty(c *gc.C) {
 
102
        portSet1 := network.NewPortSet(s.portRange1)
 
103
        portSet2 := network.NewPortSet(s.portRange2)
 
104
        result := portSet1.Intersection(portSet2)
 
105
        isEmpty := result.IsEmpty()
 
106
 
 
107
        c.Check(isEmpty, jc.IsTrue)
 
108
}
 
109
 
 
110
func (s *PortSetSuite) TestPortSetDifference(c *gc.C) {
 
111
        s.portRange2.ToPort = 83
 
112
        portSet1 := network.NewPortSet(s.portRange2)
 
113
        portSet2 := network.NewPortSet(s.portRange3)
 
114
        result := portSet1.Difference(portSet2)
 
115
 
 
116
        s.checkPortSetTCP(c, result, 82, 83)
 
117
}
 
118
 
 
119
func (s *PortSetSuite) TestPortSetDifferenceEmpty(c *gc.C) {
 
120
        portSet1 := network.NewPortSet(s.portRange2)
 
121
        result := portSet1.Difference(portSet1)
 
122
        isEmpty := result.IsEmpty()
 
123
 
 
124
        c.Check(isEmpty, jc.IsTrue)
 
125
}
 
126
 
 
127
func (s *PortSetSuite) TestPortSetSize(c *gc.C) {
 
128
        portSet := network.NewPortSet(s.portRange1)
 
129
        c.Assert(portSet.Size(), gc.Equals, 100)
 
130
}
 
131
 
 
132
func (s *PortSetSuite) TestPortSetIsEmpty(c *gc.C) {
 
133
        portSet := network.NewPortSet()
 
134
        c.Assert(portSet.IsEmpty(), jc.IsTrue)
 
135
}
 
136
 
 
137
func (s *PortSetSuite) TestPortSetIsNotEmpty(c *gc.C) {
 
138
        portSet := network.NewPortSet(s.portRange2)
 
139
        c.Assert(portSet.IsEmpty(), jc.IsFalse)
 
140
}
 
141
 
 
142
func (s *PortSetSuite) TestPortSetAdd(c *gc.C) {
 
143
        portSet := network.NewPortSet(s.portRange2)
 
144
        c.Check(portSet.IsEmpty(), jc.IsFalse)
 
145
        portSet.Add("tcp", 81)
 
146
 
 
147
        s.checkPortSetTCP(c, portSet, 80, 81)
 
148
}
 
149
 
 
150
func (s *PortSetSuite) TestPortSetAddRanges(c *gc.C) {
 
151
        s.portRange2.ToPort = 83
 
152
        portSet := network.NewPortSet(s.portRange2)
 
153
        c.Check(portSet.IsEmpty(), jc.IsFalse)
 
154
        portSet.AddRanges(s.portRange3)
 
155
 
 
156
        s.checkPortSetTCP(c, portSet, s.getPorts(79, 83)...)
 
157
}
 
158
 
 
159
func (s *PortSetSuite) TestPortSetRemove(c *gc.C) {
 
160
        portSet := network.NewPortSet(s.portRange2)
 
161
        portSet.Remove("tcp", 80)
 
162
 
 
163
        c.Assert(portSet.Ports(), gc.HasLen, 0)
 
164
}
 
165
 
 
166
func (s *PortSetSuite) TestPortSetRemoveRanges(c *gc.C) {
 
167
        portSet := network.NewPortSet(s.portRange1)
 
168
        portSet.RemoveRanges(
 
169
                s.portRange2,
 
170
                network.PortRange{7000, 8049, "tcp"},
 
171
                network.PortRange{8051, 8074, "tcp"},
 
172
                network.PortRange{8080, 9000, "tcp"},
 
173
        )
 
174
 
 
175
        s.checkPortSetTCP(c, portSet, 8050, 8075, 8076, 8077, 8078, 8079)
 
176
}
 
177
 
 
178
func (s *PortSetSuite) TestPortSetContains(c *gc.C) {
 
179
        portSet := network.NewPortSet(s.portRange2)
 
180
        isfound := portSet.Contains("tcp", 80)
 
181
 
 
182
        c.Assert(isfound, jc.IsTrue)
 
183
}
 
184
 
 
185
func (s *PortSetSuite) TestPortSetContainsNotFound(c *gc.C) {
 
186
        portSet := network.NewPortSet(s.portRange2)
 
187
        isfound := portSet.Contains("tcp", 81)
 
188
 
 
189
        c.Assert(isfound, jc.IsFalse)
 
190
}
 
191
 
 
192
func (s *PortSetSuite) TestPortSetContainsRangesSingleMatch(c *gc.C) {
 
193
        portSet := network.NewPortSet(s.portRange1)
 
194
        isfound := portSet.ContainsRanges(network.PortRange{8080, 8080, "tcp"})
 
195
 
 
196
        c.Assert(isfound, jc.IsTrue)
 
197
}
 
198
 
 
199
func (s *PortSetSuite) TestPortSetContainsRangesSingleNoMatch(c *gc.C) {
 
200
        portSet := network.NewPortSet(s.portRange1)
 
201
        isfound := portSet.ContainsRanges(s.portRange2)
 
202
 
 
203
        c.Assert(isfound, jc.IsFalse)
 
204
}
 
205
 
 
206
func (s *PortSetSuite) TestPortSetContainsRangesOverlapping(c *gc.C) {
 
207
        portSet := network.NewPortSet(s.portRange1)
 
208
        isfound := portSet.ContainsRanges(network.PortRange{7000, 8049, "tcp"})
 
209
 
 
210
        c.Assert(isfound, jc.IsFalse)
 
211
}
 
212
 
 
213
func (s *PortSetSuite) TestPortSetValues(c *gc.C) {
 
214
        portSet := network.NewPortSet(s.portRange3)
 
215
        ports := portSet.Values()
 
216
 
 
217
        s.checkPorts(c, ports, "tcp", 79, 80, 81)
 
218
}
 
219
 
 
220
func (s *PortSetSuite) TestPortSetProtocols(c *gc.C) {
 
221
        portSet := network.NewPortSet(s.portRange2, s.portRange4)
 
222
        protocols := portSet.Protocols()
 
223
 
 
224
        c.Check(protocols, jc.SameContents, []string{"tcp", "udp"})
 
225
}
 
226
 
 
227
func (s *PortSetSuite) TestPortSetPorts(c *gc.C) {
 
228
        portSet := network.NewPortSet(s.portRange3)
 
229
        ports := portSet.Ports()
 
230
 
 
231
        s.checkPorts(c, ports, "tcp", 79, 80, 81)
 
232
}
 
233
 
 
234
func (s *PortSetSuite) TestPortSetPortNumbers(c *gc.C) {
 
235
        portSet := network.NewPortSet(s.portRange3)
 
236
        ports := portSet.PortNumbers("tcp")
 
237
 
 
238
        c.Check(ports, jc.SameContents, []int{79, 80, 81})
 
239
}
 
240
 
 
241
func (s *PortSetSuite) TestPortSetPortStrings(c *gc.C) {
 
242
        portSet := network.NewPortSet(s.portRange3)
 
243
        ports := portSet.PortStrings("tcp")
 
244
 
 
245
        c.Check(ports, jc.SameContents, []string{"79", "80", "81"})
 
246
}