Revision 8b312c1d test/ganeti.netutils_unittest.py
| b/test/ganeti.netutils_unittest.py | ||
|---|---|---|
| 140 | 140 |
netutils.HostInfo.NormalizeName(value) |
| 141 | 141 |
|
| 142 | 142 |
|
| 143 |
class TestIsValidIP4(unittest.TestCase): |
|
| 144 |
def test(self): |
|
| 145 |
self.assert_(netutils.IsValidIP4("127.0.0.1"))
|
|
| 146 |
self.assert_(netutils.IsValidIP4("0.0.0.0"))
|
|
| 147 |
self.assert_(netutils.IsValidIP4("255.255.255.255"))
|
|
| 148 |
self.assertFalse(netutils.IsValidIP4("0"))
|
|
| 149 |
self.assertFalse(netutils.IsValidIP4("1"))
|
|
| 150 |
self.assertFalse(netutils.IsValidIP4("1.1.1"))
|
|
| 151 |
self.assertFalse(netutils.IsValidIP4("255.255.255.256"))
|
|
| 152 |
self.assertFalse(netutils.IsValidIP4("::1"))
|
|
| 153 |
|
|
| 154 |
|
|
| 155 |
class TestIsValidIP6(unittest.TestCase): |
|
| 156 |
def test(self): |
|
| 157 |
self.assert_(netutils.IsValidIP6("::"))
|
|
| 158 |
self.assert_(netutils.IsValidIP6("::1"))
|
|
| 159 |
self.assert_(netutils.IsValidIP6("1" + (":1" * 7)))
|
|
| 160 |
self.assert_(netutils.IsValidIP6("ffff" + (":ffff" * 7)))
|
|
| 161 |
self.assertFalse(netutils.IsValidIP6("0"))
|
|
| 162 |
self.assertFalse(netutils.IsValidIP6(":1"))
|
|
| 163 |
self.assertFalse(netutils.IsValidIP6("f" + (":f" * 6)))
|
|
| 164 |
self.assertFalse(netutils.IsValidIP6("fffg" + (":ffff" * 7)))
|
|
| 165 |
self.assertFalse(netutils.IsValidIP6("fffff" + (":ffff" * 7)))
|
|
| 166 |
self.assertFalse(netutils.IsValidIP6("1" + (":1" * 8)))
|
|
| 167 |
self.assertFalse(netutils.IsValidIP6("127.0.0.1"))
|
|
| 168 |
|
|
| 169 |
|
|
| 170 |
class TestIsValidIP(unittest.TestCase): |
|
| 171 |
def test(self): |
|
| 172 |
self.assert_(netutils.IsValidIP("0.0.0.0"))
|
|
| 173 |
self.assert_(netutils.IsValidIP("127.0.0.1"))
|
|
| 174 |
self.assert_(netutils.IsValidIP("::"))
|
|
| 175 |
self.assert_(netutils.IsValidIP("::1"))
|
|
| 176 |
self.assertFalse(netutils.IsValidIP("0"))
|
|
| 177 |
self.assertFalse(netutils.IsValidIP("1.1.1.256"))
|
|
| 178 |
self.assertFalse(netutils.IsValidIP("a:g::1"))
|
|
| 179 |
|
|
| 143 |
class TestIPAddress(unittest.TestCase): |
|
| 144 |
def testIsValid(self): |
|
| 145 |
self.assert_(netutils.IPAddress.IsValid("0.0.0.0"))
|
|
| 146 |
self.assert_(netutils.IPAddress.IsValid("127.0.0.1"))
|
|
| 147 |
self.assert_(netutils.IPAddress.IsValid("::"))
|
|
| 148 |
self.assert_(netutils.IPAddress.IsValid("::1"))
|
|
| 149 |
|
|
| 150 |
def testNotIsValid(self): |
|
| 151 |
self.assertFalse(netutils.IPAddress.IsValid("0"))
|
|
| 152 |
self.assertFalse(netutils.IPAddress.IsValid("1.1.1.256"))
|
|
| 153 |
self.assertFalse(netutils.IPAddress.IsValid("a:g::1"))
|
|
| 154 |
|
|
| 155 |
|
|
| 156 |
def testGetAddressFamily(self): |
|
| 157 |
fn = netutils.IPAddress.GetAddressFamily |
|
| 158 |
self.assertEqual(fn("127.0.0.1"), socket.AF_INET)
|
|
| 159 |
self.assertEqual(fn("10.2.0.127"), socket.AF_INET)
|
|
| 160 |
self.assertEqual(fn("::1"), socket.AF_INET6)
|
|
| 161 |
self.assertEqual(fn("2001:db8::1"), socket.AF_INET6)
|
|
| 162 |
self.assertRaises(errors.IPAddressError, fn, "0") |
|
| 180 | 163 |
|
| 181 |
class TestGetAddressFamily(unittest.TestCase): |
|
| 182 |
def test(self): |
|
| 183 |
self.assertEqual(netutils.GetAddressFamily("127.0.0.1"), socket.AF_INET)
|
|
| 184 |
self.assertEqual(netutils.GetAddressFamily("10.2.0.127"), socket.AF_INET)
|
|
| 185 |
self.assertEqual(netutils.GetAddressFamily("::1"), socket.AF_INET6)
|
|
| 186 |
self.assertEqual(netutils.GetAddressFamily("fe80::a00:27ff:fe08:5048"),
|
|
| 187 |
socket.AF_INET6) |
|
| 188 |
self.assertRaises(errors.GenericError, netutils.GetAddressFamily, "0") |
|
| 164 |
def testOwnLoopback(self): |
|
| 165 |
# FIXME: In a pure IPv6 environment this is no longer true |
|
| 166 |
self.assert_(netutils.IPAddress.Own("127.0.0.1"),
|
|
| 167 |
"Should own 127.0.0.1 address") |
|
| 168 |
|
|
| 169 |
def testNotOwnAddress(self): |
|
| 170 |
self.assertFalse(netutils.IPAddress.Own("2001:db8::1"),
|
|
| 171 |
"Should not own IP address 2001:db8::1") |
|
| 172 |
self.assertFalse(netutils.IPAddress.Own("192.0.2.1"),
|
|
| 173 |
"Should not own IP address 192.0.2.1") |
|
| 174 |
|
|
| 175 |
|
|
| 176 |
class TestIP4Address(unittest.TestCase): |
|
| 177 |
def testGetIPIntFromString(self): |
|
| 178 |
fn = netutils.IP4Address._GetIPIntFromString |
|
| 179 |
self.assertEqual(fn("0.0.0.0"), 0)
|
|
| 180 |
self.assertEqual(fn("0.0.0.1"), 1)
|
|
| 181 |
self.assertEqual(fn("127.0.0.1"), 2130706433)
|
|
| 182 |
self.assertEqual(fn("192.0.2.129"), 3221226113)
|
|
| 183 |
self.assertEqual(fn("255.255.255.255"), 2**32 - 1)
|
|
| 184 |
self.assertNotEqual(fn("0.0.0.0"), 1)
|
|
| 185 |
self.assertNotEqual(fn("0.0.0.0"), 1)
|
|
| 186 |
|
|
| 187 |
def testIsValid(self): |
|
| 188 |
self.assert_(netutils.IP4Address.IsValid("0.0.0.0"))
|
|
| 189 |
self.assert_(netutils.IP4Address.IsValid("127.0.0.1"))
|
|
| 190 |
self.assert_(netutils.IP4Address.IsValid("192.0.2.199"))
|
|
| 191 |
self.assert_(netutils.IP4Address.IsValid("255.255.255.255"))
|
|
| 192 |
|
|
| 193 |
def testNotIsValid(self): |
|
| 194 |
self.assertFalse(netutils.IP4Address.IsValid("0"))
|
|
| 195 |
self.assertFalse(netutils.IP4Address.IsValid("1"))
|
|
| 196 |
self.assertFalse(netutils.IP4Address.IsValid("1.1.1"))
|
|
| 197 |
self.assertFalse(netutils.IP4Address.IsValid("255.255.255.256"))
|
|
| 198 |
self.assertFalse(netutils.IP4Address.IsValid("::1"))
|
|
| 199 |
|
|
| 200 |
def testInNetwork(self): |
|
| 201 |
self.assert_(netutils.IP4Address.InNetwork("127.0.0.0/8", "127.0.0.1"))
|
|
| 202 |
|
|
| 203 |
def testNotInNetwork(self): |
|
| 204 |
self.assertFalse(netutils.IP4Address.InNetwork("192.0.2.0/24",
|
|
| 205 |
"127.0.0.1")) |
|
| 206 |
|
|
| 207 |
def testIsLoopback(self): |
|
| 208 |
self.assert_(netutils.IP4Address.IsLoopback("127.0.0.1"))
|
|
| 209 |
|
|
| 210 |
def testNotIsLoopback(self): |
|
| 211 |
self.assertFalse(netutils.IP4Address.IsLoopback("192.0.2.1"))
|
|
| 212 |
|
|
| 213 |
|
|
| 214 |
class TestIP6Address(unittest.TestCase): |
|
| 215 |
def testGetIPIntFromString(self): |
|
| 216 |
fn = netutils.IP6Address._GetIPIntFromString |
|
| 217 |
self.assertEqual(fn("::"), 0)
|
|
| 218 |
self.assertEqual(fn("::1"), 1)
|
|
| 219 |
self.assertEqual(fn("2001:db8::1"),
|
|
| 220 |
42540766411282592856903984951653826561L) |
|
| 221 |
self.assertEqual(fn("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"), 2**128-1)
|
|
| 222 |
self.assertNotEqual(netutils.IP6Address._GetIPIntFromString("::2"), 1)
|
|
| 223 |
|
|
| 224 |
def testIsValid(self): |
|
| 225 |
self.assert_(netutils.IP6Address.IsValid("::"))
|
|
| 226 |
self.assert_(netutils.IP6Address.IsValid("::1"))
|
|
| 227 |
self.assert_(netutils.IP6Address.IsValid("1" + (":1" * 7)))
|
|
| 228 |
self.assert_(netutils.IP6Address.IsValid("ffff" + (":ffff" * 7)))
|
|
| 229 |
self.assert_(netutils.IP6Address.IsValid("::"))
|
|
| 230 |
|
|
| 231 |
def testNotIsValid(self): |
|
| 232 |
self.assertFalse(netutils.IP6Address.IsValid("0"))
|
|
| 233 |
self.assertFalse(netutils.IP6Address.IsValid(":1"))
|
|
| 234 |
self.assertFalse(netutils.IP6Address.IsValid("f" + (":f" * 6)))
|
|
| 235 |
self.assertFalse(netutils.IP6Address.IsValid("fffg" + (":ffff" * 7)))
|
|
| 236 |
self.assertFalse(netutils.IP6Address.IsValid("fffff" + (":ffff" * 7)))
|
|
| 237 |
self.assertFalse(netutils.IP6Address.IsValid("1" + (":1" * 8)))
|
|
| 238 |
self.assertFalse(netutils.IP6Address.IsValid("127.0.0.1"))
|
|
| 239 |
|
|
| 240 |
def testInNetwork(self): |
|
| 241 |
self.assert_(netutils.IP6Address.InNetwork("::1/128", "::1"))
|
|
| 242 |
|
|
| 243 |
def testNotInNetwork(self): |
|
| 244 |
self.assertFalse(netutils.IP6Address.InNetwork("2001:db8::1/128", "::1"))
|
|
| 245 |
|
|
| 246 |
def testIsLoopback(self): |
|
| 247 |
self.assert_(netutils.IP6Address.IsLoopback("::1"))
|
|
| 248 |
|
|
| 249 |
def testNotIsLoopback(self): |
|
| 250 |
self.assertFalse(netutils.IP6Address.IsLoopback("2001:db8::1"))
|
|
| 189 | 251 |
|
| 190 | 252 |
|
| 191 | 253 |
class _BaseTcpPingTest: |
| ... | ... | |
| 323 | 385 |
_BaseTcpPingDeafTest.tearDown(self) |
| 324 | 386 |
|
| 325 | 387 |
|
| 326 |
class TestOwnIpAddress(unittest.TestCase): |
|
| 327 |
"""Testcase for OwnIpAddress""" |
|
| 328 |
|
|
| 329 |
def testOwnLoopback(self): |
|
| 330 |
"""check having the loopback ip""" |
|
| 331 |
self.failUnless(netutils.OwnIpAddress(constants.IP4_ADDRESS_LOCALHOST), |
|
| 332 |
"Should own the loopback address") |
|
| 333 |
|
|
| 334 |
def testNowOwnAddress(self): |
|
| 335 |
"""check that I don't own an address""" |
|
| 336 |
|
|
| 337 |
# Network 192.0.2.0/24 is reserved for test/documentation as per |
|
| 338 |
# RFC 5737, so we *should* not have an address of this range... if |
|
| 339 |
# this fails, we should extend the test to multiple addresses |
|
| 340 |
DST_IP = "192.0.2.1" |
|
| 341 |
self.failIf(netutils.OwnIpAddress(DST_IP), |
|
| 342 |
"Should not own IP address %s" % DST_IP) |
|
| 343 |
|
|
| 344 |
|
|
| 345 | 388 |
if __name__ == "__main__": |
| 346 | 389 |
testutils.GanetiTestProgram() |
Also available in: Unified diff