apache/cloudstack
1
0
Fork 0
mirror of https://github.com/apache/cloudstack.git synced 2025-10-26 08:42:29 +01:00
Code Issues Packages Projects Releases Wiki Activity

NetUtils testing

Browse Source 
- Refactor tests:
  - Upgrade tests to use jUnit4
  - Add hamcrest dependency (contribution of by Laszio Hornyak)
  - Break big tests in small unit tests
  - Replace assertTrue/False with complex conditions by assertThat with
specific matchers
- Remove dead code:
  - Private static method never called locally
- Add test for method that validates cidrs

Signed-off-by: Laszlo Hornyak <laszlo.hornyak@gmail.com>
This commit is contained in:
miguelaferreira 2014-02-21 17:18:23 +01:00 committed by Laszlo Hornyak
parent 169cd6f939
commit ef547108dd
3 changed files with 170 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
pom.xml
View File

@ -49,7 +49,9 @@
<cs.logging.version>1.1.1</cs.logging.version> <cs.logging.version>1.1.1</cs.logging.version>
<cs.discovery.version>0.5</cs.discovery.version> <cs.discovery.version>0.5</cs.discovery.version>
<cs.ejb.version>3.0</cs.ejb.version> <cs.ejb.version>3.0</cs.ejb.version>
<cs.junit.version>4.10</cs.junit.version> <!-- do not forget to also upgrade hamcrest library with junit -->
<cs.junit.version>4.11</cs.junit.version>
<cs.hamcrest.version>1.3</cs.hamcrest.version>
<cs.bcprov.version>1.46</cs.bcprov.version> <cs.bcprov.version>1.46</cs.bcprov.version>
<cs.jsch.version>0.1.42</cs.jsch.version> <cs.jsch.version>0.1.42</cs.jsch.version>
<cs.jpa.version>2.0.0</cs.jpa.version> <cs.jpa.version>2.0.0</cs.jpa.version>
@ -413,6 +415,12 @@
<version>${cs.junit.version}</version> <version>${cs.junit.version}</version>
<scope>test</scope> <scope>test</scope>
</dependency> </dependency>
<dependency>
<groupId>org.hamcrest</groupId>
<artifactId>hamcrest-library</artifactId>
<version>${cs.hamcrest.version}</version>
<scope>test</scope>
</dependency>
<dependency> <dependency>
<groupId>org.mockito</groupId> <groupId>org.mockito</groupId>
<artifactId>mockito-all</artifactId> <artifactId>mockito-all</artifactId>

15
utils/src/com/cloud/utils/net/NetUtils.java
View File

@ -44,13 +44,12 @@ import org.apache.commons.lang.SystemUtils;
import org.apache.commons.net.util.SubnetUtils; import org.apache.commons.net.util.SubnetUtils;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import com.googlecode.ipv6.IPv6Address;
import com.googlecode.ipv6.IPv6AddressRange;
import com.googlecode.ipv6.IPv6Network;
import com.cloud.utils.IteratorUtil; import com.cloud.utils.IteratorUtil;
import com.cloud.utils.Pair; import com.cloud.utils.Pair;
import com.cloud.utils.script.Script; import com.cloud.utils.script.Script;
import com.googlecode.ipv6.IPv6Address;
import com.googlecode.ipv6.IPv6AddressRange;
import com.googlecode.ipv6.IPv6Network;
public class NetUtils { public class NetUtils {
protected final static Logger s_logger = Logger.getLogger(NetUtils.class); protected final static Logger s_logger = Logger.getLogger(NetUtils.class);
@ -158,14 +157,6 @@ public class NetUtils {
return cidrList.toArray(new String[0]); return cidrList.toArray(new String[0]);
} }
private static boolean isWindows() {
String os = System.getProperty("os.name");
if (os != null && os.startsWith("Windows"))
return true;
return false;
}
public static String getDefaultHostIp() { public static String getDefaultHostIp() {
if (SystemUtils.IS_OS_WINDOWS) { if (SystemUtils.IS_OS_WINDOWS) {
Pattern pattern = Pattern.compile("\\s*0.0.0.0\\s*0.0.0.0\\s*(\\S*)\\s*(\\S*)\\s*"); Pattern pattern = Pattern.compile("\\s*0.0.0.0\\s*0.0.0.0\\s*(\\S*)\\s*(\\S*)\\s*");

231
utils/test/com/cloud/utils/net/NetUtilsTest.java
View File

@ -19,54 +19,90 @@
package com.cloud.utils.net; package com.cloud.utils.net;
import static org.hamcrest.Matchers.anyOf;
import static org.hamcrest.Matchers.contains;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.greaterThanOrEqualTo;
import static org.hamcrest.Matchers.lessThanOrEqualTo;
import static org.hamcrest.Matchers.not;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import java.math.BigInteger; import java.math.BigInteger;
import java.net.URI;
import java.util.SortedSet; import java.util.SortedSet;
import java.util.TreeSet; import java.util.TreeSet;
import junit.framework.TestCase;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import org.junit.Test; import org.junit.Test;
import com.googlecode.ipv6.IPv6Address; import com.googlecode.ipv6.IPv6Address;
public class NetUtilsTest extends TestCase { public class NetUtilsTest {
private static final Logger s_logger = Logger.getLogger(NetUtilsTest.class); private static final Logger s_logger = Logger.getLogger(NetUtilsTest.class);
@Test @Test
public void testGetRandomIpFromCidr() { public void testGetRandomIpFromCidrWithSize24() throws Exception {
String cidr = "192.168.124.1"; String cidr = "192.168.124.1";
long ip = NetUtils.getRandomIpFromCidr(cidr, 24, new TreeSet<Long>()); int size = 24;
assertEquals("The ip " + NetUtils.long2Ip(ip) + " retrieved must be within the cidr " + cidr + "/24", cidr.substring(0, 12), NetUtils.long2Ip(ip) int netCharacters = 12;
.substring(0, 12));
ip = NetUtils.getRandomIpFromCidr(cidr, 16, new TreeSet<Long>()); long ip = NetUtils.getRandomIpFromCidr(cidr, size, new TreeSet<Long>());
assertEquals("The ip " + NetUtils.long2Ip(ip) + " retrieved must be within the cidr " + cidr + "/16", cidr.substring(0, 8), NetUtils.long2Ip(ip).substring(0, 8));
ip = NetUtils.getRandomIpFromCidr(cidr, 8, new TreeSet<Long>()); assertThat("The ip " + NetUtils.long2Ip(ip) + " retrieved must be within the cidr " + cidr + "/" + size, cidr.substring(0, netCharacters), equalTo(NetUtils.long2Ip(ip)
assertEquals("The ip " + NetUtils.long2Ip(ip) + " retrieved must be within the cidr " + cidr + "/8", cidr.substring(0, 4), NetUtils.long2Ip(ip).substring(0, 4)); .substring(0, netCharacters)));
}
@Test
public void testGetRandomIpFromCidrWithSize16() throws Exception {
String cidr = "192.168.124.1";
int size = 16;
int netCharacters = 8;
long ip = NetUtils.getRandomIpFromCidr(cidr, 16, new TreeSet<Long>());
assertThat("The ip " + NetUtils.long2Ip(ip) + " retrieved must be within the cidr " + cidr + "/" + size, cidr.substring(0, netCharacters), equalTo(NetUtils.long2Ip(ip)
.substring(0, netCharacters)));
}
@Test
public void testGetRandomIpFromCidrWithSize8() throws Exception {
String cidr = "192.168.124.1";
int size = 8;
int netCharacters = 4;
long ip = NetUtils.getRandomIpFromCidr(cidr, 16, new TreeSet<Long>());
assertThat("The ip " + NetUtils.long2Ip(ip) + " retrieved must be within the cidr " + cidr + "/" + size, cidr.substring(0, netCharacters), equalTo(NetUtils.long2Ip(ip)
.substring(0, netCharacters)));
}
@Test
public void testGetRandomIpFromCidrUsignAvoid() throws Exception {
String cidr = "192.168.124.1";
int size = 30;
SortedSet<Long> avoid = new TreeSet<Long>(); SortedSet<Long> avoid = new TreeSet<Long>();
ip = NetUtils.getRandomIpFromCidr(cidr, 30, avoid); long ip = NetUtils.getRandomIpFromCidr(cidr, size, avoid);
assertTrue("We should be able to retrieve an ip on the first call.", ip != -1); assertThat("We should be able to retrieve an ip on the first call.", ip, not(equalTo(-1L)));
avoid.add(ip); avoid.add(ip);
ip = NetUtils.getRandomIpFromCidr(cidr, 30, avoid); ip = NetUtils.getRandomIpFromCidr(cidr, size, avoid);
assertTrue("We should be able to retrieve an ip on the second call.", ip != -1); assertThat("We should be able to retrieve an ip on the second call.", ip, not(equalTo(-1L)));
assertTrue("ip returned is not in the avoid list", !avoid.contains(ip)); assertThat("ip returned is not in the avoid list", avoid, not(contains(ip)));
avoid.add(ip); avoid.add(ip);
ip = NetUtils.getRandomIpFromCidr(cidr, 30, avoid); ip = NetUtils.getRandomIpFromCidr(cidr, size, avoid);
assertTrue("We should be able to retrieve an ip on the third call.", ip != -1); assertThat("We should be able to retrieve an ip on the third call.", ip, not(equalTo(-1L)));
assertTrue("ip returned is not in the avoid list", !avoid.contains(ip)); assertThat("ip returned is not in the avoid list", avoid, not(contains(ip)));
avoid.add(ip); avoid.add(ip);
ip = NetUtils.getRandomIpFromCidr(cidr, size, avoid);
ip = NetUtils.getRandomIpFromCidr(cidr, 30, avoid);
assertEquals("This should be -1 because we ran out of ip addresses: " + ip, ip, -1); assertEquals("This should be -1 because we ran out of ip addresses: " + ip, ip, -1);
} }
@Test @Test
public void testVpnPolicy() { public void testIsValidS2SVpnPolicy() {
assertTrue(NetUtils.isValidS2SVpnPolicy("aes128-sha1")); assertTrue(NetUtils.isValidS2SVpnPolicy("aes128-sha1"));
assertTrue(NetUtils.isValidS2SVpnPolicy("3des-sha1")); assertTrue(NetUtils.isValidS2SVpnPolicy("3des-sha1"));
assertTrue(NetUtils.isValidS2SVpnPolicy("3des-sha1,aes256-sha1")); assertTrue(NetUtils.isValidS2SVpnPolicy("3des-sha1,aes256-sha1"));
@ -81,22 +117,12 @@ public class NetUtilsTest extends TestCase {
assertFalse(NetUtils.isValidS2SVpnPolicy(",aes;modp1536,,,")); assertFalse(NetUtils.isValidS2SVpnPolicy(",aes;modp1536,,,"));
} }
public void testIpv6() { @Test
assertTrue(NetUtils.isValidIpv6("fc00::1")); public void testGetIp6FromRange() {
assertFalse(NetUtils.isValidIpv6(""));
assertFalse(NetUtils.isValidIpv6(null));
assertFalse(NetUtils.isValidIpv6("1234:5678::1/64"));
assertTrue(NetUtils.isValidIp6Cidr("1234:5678::1/64"));
assertFalse(NetUtils.isValidIp6Cidr("1234:5678::1"));
assertEquals(NetUtils.getIp6CidrSize("1234:5678::1/32"), 32);
assertEquals(NetUtils.getIp6CidrSize("1234:5678::1"), 0);
BigInteger two = new BigInteger("2");
assertEquals(NetUtils.countIp6InRange("1234:5678::1-1234:5678::2"), two);
assertEquals(NetUtils.countIp6InRange("1234:5678::2-1234:5678::0"), null);
assertEquals(NetUtils.getIp6FromRange("1234:5678::1-1234:5678::1"), "1234:5678::1"); assertEquals(NetUtils.getIp6FromRange("1234:5678::1-1234:5678::1"), "1234:5678::1");
for (int i = 0; i < 5; i++) { for (int i = 0; i < 5; i++) {
String ip = NetUtils.getIp6FromRange("1234:5678::1-1234:5678::2"); String ip = NetUtils.getIp6FromRange("1234:5678::1-1234:5678::2");
assertTrue(ip.equals("1234:5678::1") || ip.equals("1234:5678::2")); assertThat(ip, anyOf(equalTo("1234:5678::1"), equalTo("1234:5678::2")));
s_logger.info("IP is " + ip); s_logger.info("IP is " + ip);
} }
String ipString = null; String ipString = null;
@ -106,49 +132,104 @@ public class NetUtilsTest extends TestCase {
ipString = NetUtils.getIp6FromRange(ipStart.toString() + "-" + ipEnd.toString()); ipString = NetUtils.getIp6FromRange(ipStart.toString() + "-" + ipEnd.toString());
s_logger.info("IP is " + ipString); s_logger.info("IP is " + ipString);
IPv6Address ip = IPv6Address.fromString(ipString); IPv6Address ip = IPv6Address.fromString(ipString);
assertTrue(ip.compareTo(ipStart) >= 0); assertThat(ip, greaterThanOrEqualTo(ipStart));
assertTrue(ip.compareTo(ipEnd) <= 0); assertThat(ip, lessThanOrEqualTo(ipEnd));
} }
//Test isIp6RangeOverlap }
assertFalse(NetUtils.isIp6RangeOverlap("1234:5678::1-1234:5678::ffff", "1234:5678:1::1-1234:5678:1::ffff"));
assertTrue(NetUtils.isIp6RangeOverlap("1234:5678::1-1234:5678::ffff", "1234:5678::2-1234:5678::f")); @Test
assertTrue(NetUtils.isIp6RangeOverlap("1234:5678::f-1234:5678::ffff", "1234:5678::2-1234:5678::f")); public void testCountIp6InRange() {
assertFalse(NetUtils.isIp6RangeOverlap("1234:5678::f-1234:5678::ffff", "1234:5678::2-1234:5678::e")); assertEquals(NetUtils.countIp6InRange("1234:5678::1-1234:5678::2"), new BigInteger("2"));
assertFalse(NetUtils.isIp6RangeOverlap("1234:5678::f-1234:5678::f", "1234:5678::2-1234:5678::e")); assertEquals(NetUtils.countIp6InRange("1234:5678::2-1234:5678::0"), null);
//Test getNextIp6InRange }
String range = "1234:5678::1-1234:5678::8000:0000";
assertEquals(NetUtils.getNextIp6InRange("1234:5678::8000:0", range), "1234:5678::1"); @Test
assertEquals(NetUtils.getNextIp6InRange("1234:5678::7fff:ffff", range), "1234:5678::8000:0"); public void testGetIp6CidrSize() {
assertEquals(NetUtils.getNextIp6InRange("1234:5678::1", range), "1234:5678::2"); assertEquals(NetUtils.getIp6CidrSize("1234:5678::1/32"), 32);
range = "1234:5678::1-1234:5678::ffff:ffff:ffff:ffff"; assertEquals(NetUtils.getIp6CidrSize("1234:5678::1"), 0);
assertEquals(NetUtils.getNextIp6InRange("1234:5678::ffff:ffff:ffff:ffff", range), "1234:5678::1"); }
//Test isIp6InNetwork
assertFalse(NetUtils.isIp6InNetwork("1234:5678:abcd::1", "1234:5678::/64")); @Test
assertTrue(NetUtils.isIp6InNetwork("1234:5678::1", "1234:5678::/64")); public void testIsValidIp6Cidr() {
assertTrue(NetUtils.isIp6InNetwork("1234:5678::ffff:ffff:ffff:ffff", "1234:5678::/64")); assertTrue(NetUtils.isValidIp6Cidr("1234:5678::1/64"));
assertTrue(NetUtils.isIp6InNetwork("1234:5678::", "1234:5678::/64")); assertFalse(NetUtils.isValidIp6Cidr("1234:5678::1"));
//Test isIp6InRange }
@Test
public void testIsValidIpv6() {
assertTrue(NetUtils.isValidIpv6("fc00::1"));
assertFalse(NetUtils.isValidIpv6(""));
assertFalse(NetUtils.isValidIpv6(null));
assertFalse(NetUtils.isValidIpv6("1234:5678::1/64"));
}
@Test
public void testIsIp6InRange() {
assertTrue(NetUtils.isIp6InRange("1234:5678:abcd::1", "1234:5678:abcd::1-1234:5678:abcd::1")); assertTrue(NetUtils.isIp6InRange("1234:5678:abcd::1", "1234:5678:abcd::1-1234:5678:abcd::1"));
assertFalse(NetUtils.isIp6InRange("1234:5678:abcd::1", "1234:5678:abcd::2-1234:5678:abcd::1")); assertFalse(NetUtils.isIp6InRange("1234:5678:abcd::1", "1234:5678:abcd::2-1234:5678:abcd::1"));
assertFalse(NetUtils.isIp6InRange("1234:5678:abcd::1", null)); assertFalse(NetUtils.isIp6InRange("1234:5678:abcd::1", null));
assertTrue(NetUtils.isIp6InRange("1234:5678:abcd::1", "1234:5678::1-1234:5679::1")); assertTrue(NetUtils.isIp6InRange("1234:5678:abcd::1", "1234:5678::1-1234:5679::1"));
} }
public void testPvlan() { @Test
URI uri = NetUtils.generateUriForPvlan("123", "456"); public void testIsIp6InNetwork() {
assertTrue(uri.toString().equals("pvlan://123-i456")); assertFalse(NetUtils.isIp6InNetwork("1234:5678:abcd::1", "1234:5678::/64"));
assertTrue(NetUtils.getPrimaryPvlanFromUri(uri).equals("123")); assertTrue(NetUtils.isIp6InNetwork("1234:5678::1", "1234:5678::/64"));
assertTrue(NetUtils.getIsolatedPvlanFromUri(uri).equals("456")); assertTrue(NetUtils.isIp6InNetwork("1234:5678::ffff:ffff:ffff:ffff", "1234:5678::/64"));
assertTrue(NetUtils.isIp6InNetwork("1234:5678::", "1234:5678::/64"));
} }
public void testIsSameIpRange() { @Test
//Test to check IP Range of 2 CIDRs public void testGetNextIp6InRange() {
String range = "1234:5678::1-1234:5678::8000:0000";
assertEquals(NetUtils.getNextIp6InRange("1234:5678::8000:0", range), "1234:5678::1");
assertEquals(NetUtils.getNextIp6InRange("1234:5678::7fff:ffff", range), "1234:5678::8000:0");
assertEquals(NetUtils.getNextIp6InRange("1234:5678::1", range), "1234:5678::2");
range = "1234:5678::1-1234:5678::ffff:ffff:ffff:ffff";
assertEquals(NetUtils.getNextIp6InRange("1234:5678::ffff:ffff:ffff:ffff", range), "1234:5678::1");
}
@Test
public void testIsIp6RangeOverlap() {
assertFalse(NetUtils.isIp6RangeOverlap("1234:5678::1-1234:5678::ffff", "1234:5678:1::1-1234:5678:1::ffff"));
assertTrue(NetUtils.isIp6RangeOverlap("1234:5678::1-1234:5678::ffff", "1234:5678::2-1234:5678::f"));
assertTrue(NetUtils.isIp6RangeOverlap("1234:5678::f-1234:5678::ffff", "1234:5678::2-1234:5678::f"));
assertFalse(NetUtils.isIp6RangeOverlap("1234:5678::f-1234:5678::ffff", "1234:5678::2-1234:5678::e"));
assertFalse(NetUtils.isIp6RangeOverlap("1234:5678::f-1234:5678::f", "1234:5678::2-1234:5678::e"));
}
@Test
public void testGenerateUriForPvlan() {
assertEquals("pvlan://123-i456", NetUtils.generateUriForPvlan("123", "456").toString());
}
@Test
public void testGetPrimaryPvlanFromUri() {
assertEquals("123", NetUtils.getPrimaryPvlanFromUri(NetUtils.generateUriForPvlan("123", "456")));
}
@Test
public void testGetIsolatedPvlanFromUri() {
assertEquals("456", NetUtils.getIsolatedPvlanFromUri(NetUtils.generateUriForPvlan("123", "456")));
}
@Test
public void testIsValidCIDR() throws Exception {
//Test to check IP Range of 2 CIDR
String cidrFirst = "10.0.144.0/20"; String cidrFirst = "10.0.144.0/20";
String cidrSecond = "10.0.151.0/20"; String cidrSecond = "10.0.151.0/20";
String cidrThird = "10.0.144.0/21"; String cidrThird = "10.0.144.0/21";
assertTrue(NetUtils.isValidCIDR(cidrFirst)); assertTrue(NetUtils.isValidCIDR(cidrFirst));
assertTrue(NetUtils.isValidCIDR(cidrSecond)); assertTrue(NetUtils.isValidCIDR(cidrSecond));
assertTrue(NetUtils.isValidCIDR(cidrThird)); assertTrue(NetUtils.isValidCIDR(cidrThird));
}
@Test
public void testIsSameIpRange() {
String cidrFirst = "10.0.144.0/20";
String cidrSecond = "10.0.151.0/20";
String cidrThird = "10.0.144.0/21";
//Check for exactly same CIDRs //Check for exactly same CIDRs
assertTrue(NetUtils.isSameIpRange(cidrFirst, cidrFirst)); assertTrue(NetUtils.isSameIpRange(cidrFirst, cidrFirst));
@ -160,17 +241,14 @@ public class NetUtilsTest extends TestCase {
assertFalse(NetUtils.isSameIpRange(cidrFirst, "10.3.6.5/50")); assertFalse(NetUtils.isSameIpRange(cidrFirst, "10.3.6.5/50"));
} }
public void testMacGenerateion() { @Test
public void testGenerateMacOnIncrease() {
String mac = "06:01:23:00:45:67"; String mac = "06:01:23:00:45:67";
String newMac = NetUtils.generateMacOnIncrease(mac, 2); assertEquals("06:01:25:00:45:67", NetUtils.generateMacOnIncrease(mac, 2));
assertTrue(newMac.equals("06:01:25:00:45:67")); assertEquals("06:01:33:00:45:67", NetUtils.generateMacOnIncrease(mac, 16));
newMac = NetUtils.generateMacOnIncrease(mac, 16);
assertTrue(newMac.equals("06:01:33:00:45:67"));
mac = "06:ff:ff:00:45:67"; mac = "06:ff:ff:00:45:67";
newMac = NetUtils.generateMacOnIncrease(mac, 1); assertEquals("06:00:00:00:45:67", NetUtils.generateMacOnIncrease(mac, 1));
assertTrue(newMac.equals("06:00:00:00:45:67")); assertEquals("06:00:0f:00:45:67", NetUtils.generateMacOnIncrease(mac, 16));
newMac = NetUtils.generateMacOnIncrease(mac, 16);
assertTrue(newMac.equals("06:00:0f:00:45:67"));
} }
@Test @Test
@ -187,4 +265,11 @@ public class NetUtilsTest extends TestCase {
assertFalse(NetUtils.isSameIsolationId("2", "vlan://3")); assertFalse(NetUtils.isSameIsolationId("2", "vlan://3"));
assertFalse(NetUtils.isSameIsolationId("bla", null)); assertFalse(NetUtils.isSameIsolationId("bla", null));
} }
@Test
public void testValidateGuestCidr() throws Exception {
String guestCidr = "192.168.1.0/24";
assertTrue(NetUtils.validateGuestCidr(guestCidr));
}
} }