Mike Kolesnik has uploaded a new change for review.
Change subject: engine: Network validator tests use assertThat
......................................................................
engine: Network validator tests use assertThat
Refactored the network validator's tests to use assertThat syntax with
the newly introduced matchers for ValidationResult.
Change-Id: Ic8bfd0e15f0204f4a4a099a322fa78d8b33aec85
Signed-off-by: Mike Kolesnik <mkole...@redhat.com>
---
M
backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/network/cluster/NetworkClusterValidatorTest.java
M
backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/validator/NetworkValidatorTest.java
M
backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/validator/VmNicValidatorTest.java
3 files changed, 97 insertions(+), 81 deletions(-)
git pull ssh://gerrit.ovirt.org:29418/ovirt-engine refs/changes/62/13062/1
diff --git
a/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/network/cluster/NetworkClusterValidatorTest.java
b/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/network/cluster/NetworkClusterValidatorTest.java
index c0942cf..65970a8 100644
---
a/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/network/cluster/NetworkClusterValidatorTest.java
+++
b/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/network/cluster/NetworkClusterValidatorTest.java
@@ -1,9 +1,13 @@
package org.ovirt.engine.core.bll.network.cluster;
-import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+import static org.junit.matchers.JUnitMatchers.both;
+import static org.junit.matchers.JUnitMatchers.hasItem;
+import static
org.ovirt.engine.core.bll.validator.ValidationResultMatchers.failsWith;
+import static
org.ovirt.engine.core.bll.validator.ValidationResultMatchers.isValid;
+import static
org.ovirt.engine.core.bll.validator.ValidationResultMatchers.replacements;
import org.junit.Test;
-import org.ovirt.engine.core.bll.ValidationResult;
import org.ovirt.engine.core.common.businessentities.network.NetworkCluster;
import org.ovirt.engine.core.dal.VdcBllMessages;
import org.ovirt.engine.core.utils.RandomUtils;
@@ -24,14 +28,15 @@
public void managementNetworkAttachmentValid() throws Exception {
networkCluster.setRequired(true);
- assertEquals(ValidationResult.VALID,
validator.managementNetworkAttachment(NETWORK_NAME));
+ assertThat(validator.managementNetworkAttachment(NETWORK_NAME),
isValid());
}
@Test
public void managementNetworkAttachmentInvalid() throws Exception {
networkCluster.setRequired(false);
- assertEquals(new
ValidationResult(VdcBllMessages.ACTION_TYPE_FAILED_MANAGEMENT_NETWORK_REQUIRED,
NETWORK_NAME_REPLACEMENT),
- validator.managementNetworkAttachment(NETWORK_NAME));
+ assertThat(validator.managementNetworkAttachment(NETWORK_NAME),
+
both(failsWith(VdcBllMessages.ACTION_TYPE_FAILED_MANAGEMENT_NETWORK_REQUIRED))
+ .and(replacements(hasItem(NETWORK_NAME_REPLACEMENT))));
}
}
diff --git
a/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/validator/NetworkValidatorTest.java
b/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/validator/NetworkValidatorTest.java
index eccdb19..d1b2361 100644
---
a/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/validator/NetworkValidatorTest.java
+++
b/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/validator/NetworkValidatorTest.java
@@ -1,16 +1,19 @@
package org.ovirt.engine.core.bll.validator;
-import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
-import static org.mockito.Mockito.doReturn;
+import static
org.ovirt.engine.core.bll.validator.ValidationResultMatchers.failsWith;
+import static
org.ovirt.engine.core.bll.validator.ValidationResultMatchers.isValid;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import org.hamcrest.Matcher;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
@@ -90,136 +93,135 @@
@Test
public void networkSet() throws Exception {
- assertEquals(ValidationResult.VALID, validator.networkIsSet());
+ assertThat(validator.networkIsSet(), isValid());
}
@Test
public void networkNull() throws Exception {
validator = new NetworkValidator(null);
- assertEquals(new ValidationResult(VdcBllMessages.NETWORK_NOT_EXISTS),
validator.networkIsSet());
+ assertThat(validator.networkIsSet(),
failsWith(VdcBllMessages.NETWORK_NOT_EXISTS));
}
@Test
public void dataCenterDoesntExist() throws Exception {
when(dataCenterDao.get(any(Guid.class))).thenReturn(null);
- assertEquals(new
ValidationResult(VdcBllMessages.ACTION_TYPE_FAILED_STORAGE_POOL_NOT_EXIST),
- validator.dataCenterExists());
+ assertThat(validator.dataCenterExists(),
failsWith(VdcBllMessages.ACTION_TYPE_FAILED_STORAGE_POOL_NOT_EXIST));
}
@Test
public void dataCenterExists() throws Exception {
- assertEquals(ValidationResult.VALID, validator.dataCenterExists());
+ assertThat(validator.dataCenterExists(), isValid());
}
- private void vmNetworkSetupTest(ValidationResult expected, boolean
vmNetwork, boolean featureSupported) {
+ private void vmNetworkSetupTest(Matcher<ValidationResult> matcher, boolean
vmNetwork, boolean featureSupported) {
mockConfigRule.mockConfigValue(ConfigValues.NonVmNetworkSupported,
dataCenter.getcompatibility_version(),
featureSupported);
when(network.isVmNetwork()).thenReturn(vmNetwork);
- assertEquals(expected, validator.vmNetworkSetCorrectly());
+ assertThat(validator.vmNetworkSetCorrectly(), matcher);
}
@Test
public void vmNetworkWhenSupported() throws Exception {
- vmNetworkSetupTest(ValidationResult.VALID, true, true);
+ vmNetworkSetupTest(isValid(), true, true);
}
@Test
public void vmNetworkWhenNotSupported() throws Exception {
- vmNetworkSetupTest(ValidationResult.VALID, true, false);
+ vmNetworkSetupTest(isValid(), true, false);
}
@Test
public void nonVmNetworkWhenSupported() throws Exception {
- vmNetworkSetupTest(ValidationResult.VALID, false, true);
+ vmNetworkSetupTest(isValid(), false, true);
}
@Test
public void nonVmNetworkWhenNotSupported() throws Exception {
- vmNetworkSetupTest(new
ValidationResult(VdcBllMessages.NON_VM_NETWORK_NOT_SUPPORTED_FOR_POOL_LEVEL),
+
vmNetworkSetupTest(failsWith(VdcBllMessages.NON_VM_NETWORK_NOT_SUPPORTED_FOR_POOL_LEVEL),
false,
false);
}
- private void stpTest(ValidationResult expected, boolean vmNetwork, boolean
stp) {
+ private void stpTest(Matcher<ValidationResult> matcher, boolean vmNetwork,
boolean stp) {
when(network.isVmNetwork()).thenReturn(vmNetwork);
when(network.getStp()).thenReturn(stp);
- assertEquals(expected, validator.stpForVmNetworkOnly());
+ assertThat(validator.stpForVmNetworkOnly(), matcher);
}
@Test
public void stpWhenVmNetwork() throws Exception {
- stpTest(ValidationResult.VALID, true, true);
+ stpTest(isValid(), true, true);
}
@Test
public void noStpWhenVmNetwork() throws Exception {
- stpTest(ValidationResult.VALID, true, false);
+ stpTest(isValid(), true, false);
}
@Test
public void stpWhenNonVmNetwork() throws Exception {
- stpTest(new
ValidationResult(VdcBllMessages.NON_VM_NETWORK_CANNOT_SUPPORT_STP), false,
true);
+ stpTest(failsWith(VdcBllMessages.NON_VM_NETWORK_CANNOT_SUPPORT_STP),
false, true);
}
@Test
public void noStpWhenNonVmNetwork() throws Exception {
- stpTest(ValidationResult.VALID, false, false);
+ stpTest(isValid(), false, false);
}
- private void mtuValidTest(ValidationResult expected, int mtu, boolean
featureSupported) {
+ private void mtuValidTest(Matcher<ValidationResult> matcher, int mtu,
boolean featureSupported) {
mockConfigRule.mockConfigValue(ConfigValues.MTUOverrideSupported,
dataCenter.getcompatibility_version(),
featureSupported);
when(network.getMtu()).thenReturn(mtu);
- assertEquals(expected, validator.mtuValid());
+ assertThat(validator.mtuValid(), matcher);
}
@Test
public void nonZeroMtuWhenSupported() throws Exception {
- mtuValidTest(ValidationResult.VALID, 1, true);
+ mtuValidTest(isValid(), 1, true);
}
@Test
public void nonZeroMtuWhenNotSupported() throws Exception {
- mtuValidTest(new
ValidationResult(VdcBllMessages.NETWORK_MTU_OVERRIDE_NOT_SUPPORTED), 1, false);
+
mtuValidTest(failsWith(VdcBllMessages.NETWORK_MTU_OVERRIDE_NOT_SUPPORTED), 1,
false);
}
@Test
public void zeroMtuWhenSupported() throws Exception {
- mtuValidTest(ValidationResult.VALID, 0, true);
+ mtuValidTest(isValid(), 0, true);
}
@Test
public void zeroMtuWhenNotSupported() throws Exception {
- mtuValidTest(ValidationResult.VALID, 0, false);
+ mtuValidTest(isValid(), 0, false);
}
- private void networkPrefixValidTest(ValidationResult expected, String
networkName) {
+ private void networkPrefixValidTest(Matcher<ValidationResult> matcher,
String networkName) {
when(network.getName()).thenReturn(networkName);
- assertEquals(expected, validator.networkPrefixValid());
+ assertThat(validator.networkPrefixValid(), matcher);
}
@Test
public void networkPrefixBond() throws Exception {
- networkPrefixValidTest(new
ValidationResult(VdcBllMessages.NETWORK_CANNOT_CONTAIN_BOND_NAME), "bond0");
+
networkPrefixValidTest(failsWith(VdcBllMessages.NETWORK_CANNOT_CONTAIN_BOND_NAME),
"bond0");
}
@Test
public void networkPrefixInnocent() throws Exception {
- networkPrefixValidTest(ValidationResult.VALID, DEFAULT_NETWORK_NAME);
+ networkPrefixValidTest(isValid(), DEFAULT_NETWORK_NAME);
}
- private void vlanIdAvailableTest(ValidationResult expected, List<Network>
networks) {
+ private void vlanIdAvailableTest(Matcher<ValidationResult> matcher,
List<Network> networks) {
this.networks.addAll(networks);
when(network.getVlanId()).thenReturn(DEFAULT_VLAN_ID);
when(network.getId()).thenReturn(DEFAULT_GUID);
- assertEquals(expected.getMessage(),
validator.vlanIdNotUsed().getMessage());
+ assertThat(validator.vlanIdNotUsed(), matcher);
}
private List<Network> getSingletonVlanNetworkList(int vlanId, Guid
networkId) {
@@ -231,31 +233,31 @@
@Test
public void vlanIdNoNetworks() throws Exception {
- vlanIdAvailableTest(ValidationResult.VALID, Collections.<Network>
emptyList());
+ vlanIdAvailableTest(isValid(), Collections.<Network> emptyList());
}
@Test
public void vlanIdAvailable() throws Exception {
- vlanIdAvailableTest(ValidationResult.VALID,
getSingletonVlanNetworkList(OTHER_VLAN_ID, OTHER_GUID));
+ vlanIdAvailableTest(isValid(),
getSingletonVlanNetworkList(OTHER_VLAN_ID, OTHER_GUID));
}
@Test
public void vlanIdTakenByDifferentNetwork() throws Exception {
- vlanIdAvailableTest(new
ValidationResult(VdcBllMessages.NETWORK_VLAN_IN_USE),
+ vlanIdAvailableTest(failsWith(VdcBllMessages.NETWORK_VLAN_IN_USE),
getSingletonVlanNetworkList(DEFAULT_VLAN_ID, OTHER_GUID));
}
@Test
public void vlanIdTakenBySameNetwork() throws Exception {
- vlanIdAvailableTest(ValidationResult.VALID,
getSingletonVlanNetworkList(DEFAULT_VLAN_ID, DEFAULT_GUID));
+ vlanIdAvailableTest(isValid(),
getSingletonVlanNetworkList(DEFAULT_VLAN_ID, DEFAULT_GUID));
}
- private void networkNameAvailableTest(ValidationResult expected,
List<Network> networks) {
+ private void networkNameAvailableTest(Matcher<ValidationResult> matcher,
List<Network> networks) {
this.networks.addAll(networks);
when(network.getName()).thenReturn(DEFAULT_NETWORK_NAME);
when(network.getId()).thenReturn(DEFAULT_GUID);
- assertEquals(expected, validator.networkNameNotUsed());
+ assertThat(validator.networkNameNotUsed(), matcher);
}
private List<Network> getSingletonNamedNetworkList(String networkName,
Guid networkId) {
@@ -267,42 +269,46 @@
@Test
public void networkNameNoNetworks() throws Exception {
- networkNameAvailableTest(ValidationResult.VALID, Collections.<Network>
emptyList());
+ networkNameAvailableTest(isValid(), Collections.<Network> emptyList());
}
@Test
public void networkNameAvailable() throws Exception {
- networkNameAvailableTest(ValidationResult.VALID,
getSingletonNamedNetworkList(OTHER_NETWORK_NAME, OTHER_GUID));
+ networkNameAvailableTest(isValid(),
getSingletonNamedNetworkList(OTHER_NETWORK_NAME, OTHER_GUID));
}
@Test
public void networkNameTakenByDifferentNetwork() throws Exception {
- networkNameAvailableTest(new
ValidationResult(VdcBllMessages.ACTION_TYPE_FAILED_NETWORK_NAME_IN_USE),
+
networkNameAvailableTest(failsWith(VdcBllMessages.ACTION_TYPE_FAILED_NETWORK_NAME_IN_USE),
getSingletonNamedNetworkList(DEFAULT_NETWORK_NAME,
OTHER_GUID));
}
@Test
public void networkNameTakenCaseSensitivelyByDifferentNetwork() throws
Exception {
- networkNameAvailableTest(ValidationResult.VALID,
+ networkNameAvailableTest(isValid(),
getSingletonNamedNetworkList(DEFAULT_NETWORK_NAME.toUpperCase(), OTHER_GUID));
}
@Test
public void networkNameTakenBySameNetwork() throws Exception {
- networkNameAvailableTest(ValidationResult.VALID,
+ networkNameAvailableTest(isValid(),
getSingletonNamedNetworkList(DEFAULT_NETWORK_NAME,
DEFAULT_GUID));
}
- private void networkNotUsedByVmsTest(ValidationResult expected, List<VM>
vms) {
+ private Matcher<ValidationResult> failsWithNetworkInUse() {
+ return failsWith(VdcBllMessages.ACTION_TYPE_FAILED_NETWORK_IN_USE);
+ }
+
+ private void networkNotUsedByVmsTest(Matcher<ValidationResult> matcher,
List<VM> vms) {
VmDAO vmDao = mock(VmDAO.class);
when(vmDao.getAllForNetwork(any(Guid.class))).thenReturn(vms);
when(dbFacade.getVmDao()).thenReturn(vmDao);
- assertEquals(expected.getMessage(),
validator.networkNotUsedByVms().getMessage());
+ assertThat(validator.networkNotUsedByVms(), matcher);
}
@Test
public void networkNotInUseByVms() throws Exception {
- networkNotUsedByVmsTest(ValidationResult.VALID, Collections.<VM>
emptyList());
+ networkNotUsedByVmsTest(isValid(), Collections.<VM> emptyList());
}
@Test
@@ -310,20 +316,19 @@
VM vm = mock(VM.class);
when(vm.getName()).thenReturn(NAMEABLE_NAME);
- networkNotUsedByVmsTest(new
ValidationResult(VdcBllMessages.ACTION_TYPE_FAILED_NETWORK_IN_USE),
- Collections.singletonList(vm));
+ networkNotUsedByVmsTest(failsWithNetworkInUse(),
Collections.singletonList(vm));
}
- private void networkNotUsedByHostsTest(ValidationResult expected,
List<VDS> hosts) {
+ private void networkNotUsedByHostsTest(Matcher<ValidationResult> matcher,
List<VDS> hosts) {
VdsDAO hostDao = mock(VdsDAO.class);
when(hostDao.getAllForNetwork(any(Guid.class))).thenReturn(hosts);
when(dbFacade.getVdsDao()).thenReturn(hostDao);
- assertEquals(expected.getMessage(),
validator.networkNotUsedByHosts().getMessage());
+ assertThat(validator.networkNotUsedByHosts(), matcher);
}
@Test
public void networkNotInUseByHosts() throws Exception {
- networkNotUsedByHostsTest(ValidationResult.VALID, Collections.<VDS>
emptyList());
+ networkNotUsedByHostsTest(isValid(), Collections.<VDS> emptyList());
}
@Test
@@ -331,20 +336,19 @@
VDS host = mock(VDS.class);
when(host.getName()).thenReturn(NAMEABLE_NAME);
- networkNotUsedByHostsTest(new
ValidationResult(VdcBllMessages.ACTION_TYPE_FAILED_NETWORK_IN_USE),
- Collections.singletonList(host));
+ networkNotUsedByHostsTest(failsWithNetworkInUse(),
Collections.singletonList(host));
}
- private void networkNotUsedByTemplatesTest(ValidationResult expected,
List<VmTemplate> templates) {
+ private void networkNotUsedByTemplatesTest(Matcher<ValidationResult>
matcher, List<VmTemplate> templates) {
VmTemplateDAO templateDao = mock(VmTemplateDAO.class);
when(templateDao.getAllForNetwork(any(Guid.class))).thenReturn(templates);
when(dbFacade.getVmTemplateDao()).thenReturn(templateDao);
- assertEquals(expected.getMessage(),
validator.networkNotUsedByTemplates().getMessage());
+ assertThat(validator.networkNotUsedByTemplates(), matcher);
}
@Test
public void networkNotInUseByTemplates() throws Exception {
- networkNotUsedByTemplatesTest(ValidationResult.VALID,
Collections.<VmTemplate> emptyList());
+ networkNotUsedByTemplatesTest(isValid(), Collections.<VmTemplate>
emptyList());
}
@Test
@@ -352,7 +356,6 @@
VmTemplate template = mock(VmTemplate.class);
when(template.getName()).thenReturn(NAMEABLE_NAME);
- networkNotUsedByTemplatesTest(new
ValidationResult(VdcBllMessages.ACTION_TYPE_FAILED_NETWORK_IN_USE),
- Collections.singletonList(template));
+ networkNotUsedByTemplatesTest(failsWithNetworkInUse(),
Collections.singletonList(template));
}
}
diff --git
a/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/validator/VmNicValidatorTest.java
b/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/validator/VmNicValidatorTest.java
index 8563e81..f0de4cc 100644
---
a/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/validator/VmNicValidatorTest.java
+++
b/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/validator/VmNicValidatorTest.java
@@ -1,8 +1,14 @@
package org.ovirt.engine.core.bll.validator;
-import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+import static org.junit.matchers.JUnitMatchers.both;
+import static org.junit.matchers.JUnitMatchers.hasItem;
import static org.mockito.Mockito.when;
+import static
org.ovirt.engine.core.bll.validator.ValidationResultMatchers.failsWith;
+import static
org.ovirt.engine.core.bll.validator.ValidationResultMatchers.isValid;
+import static
org.ovirt.engine.core.bll.validator.ValidationResultMatchers.replacements;
+import org.hamcrest.Matcher;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
@@ -44,86 +50,88 @@
@Test
public void unlinkedWhenUnlinkingNotSupported() throws Exception {
- unlinkingTest(new
ValidationResult(VdcBllMessages.UNLINKING_IS_NOT_SUPPORTED,
CLUSTER_VERSION_REPLACEMENT),
+
unlinkingTest(both(failsWith(VdcBllMessages.UNLINKING_IS_NOT_SUPPORTED))
+ .and(replacements(hasItem(CLUSTER_VERSION_REPLACEMENT))),
false,
false);
}
@Test
public void linkedWhenUnlinkingNotSupported() throws Exception {
- unlinkingTest(ValidationResult.VALID, false, true);
+ unlinkingTest(isValid(), false, true);
}
@Test
public void unlinkedWhenUnlinkingSupported() throws Exception {
- unlinkingTest(ValidationResult.VALID, true, false);
+ unlinkingTest(isValid(), true, false);
}
@Test
public void linkedWhenUnlinkingSupported() throws Exception {
- unlinkingTest(ValidationResult.VALID, true, true);
+ unlinkingTest(isValid(), true, true);
}
@Test
public void nullNetworkNameWhenUnlinkingNotSupported() throws Exception {
- networkNameTest(new
ValidationResult(VdcBllMessages.NULL_NETWORK_IS_NOT_SUPPORTED,
CLUSTER_VERSION_REPLACEMENT),
+
networkNameTest(both(failsWith(VdcBllMessages.NULL_NETWORK_IS_NOT_SUPPORTED))
+ .and(replacements(hasItem(CLUSTER_VERSION_REPLACEMENT))),
false,
null);
}
@Test
public void validNetworkNameWhenUnlinkingNotSupported() throws Exception {
- networkNameTest(ValidationResult.VALID, false, "net");
+ networkNameTest(isValid(), false, "net");
}
@Test
public void nullNetworkNameWhenUnlinkingSupported() throws Exception {
- networkNameTest(ValidationResult.VALID, true, null);
+ networkNameTest(isValid(), true, null);
}
@Test
public void validNetworkNameWhenUnlinkingSupported() throws Exception {
- networkNameTest(ValidationResult.VALID, true, "net");
+ networkNameTest(isValid(), true, "net");
}
@Test
public void validNetworkWhenPortMirroring() throws Exception {
- portMirroringTest(ValidationResult.VALID, "net", true);
+ portMirroringTest(isValid(), "net", true);
}
@Test
public void nullNetworkWhenPortMirroring() throws Exception {
- portMirroringTest(new
ValidationResult(VdcBllMessages.PORT_MIRRORING_REQUIRES_NETWORK), null, true);
+
portMirroringTest(failsWith(VdcBllMessages.PORT_MIRRORING_REQUIRES_NETWORK),
null, true);
}
@Test
public void validNetworkWhenNoPortMirroring() throws Exception {
- portMirroringTest(ValidationResult.VALID, "net", false);
+ portMirroringTest(isValid(), "net", false);
}
@Test
public void nullNetworkWhenNoPortMirroring() throws Exception {
- portMirroringTest(ValidationResult.VALID, null, false);
+ portMirroringTest(isValid(), null, false);
}
- private void unlinkingTest(ValidationResult expected, boolean
networkLinkingSupported, boolean nicLinked) {
+ private void unlinkingTest(Matcher<ValidationResult> matcher, boolean
networkLinkingSupported, boolean nicLinked) {
mockConfigRule.mockConfigValue(ConfigValues.NetworkLinkingSupported,
version, networkLinkingSupported);
when(nic.isLinked()).thenReturn(nicLinked);
- assertEquals(expected, validator.linkedCorrectly());
+ assertThat(validator.linkedCorrectly(), matcher);
}
- private void networkNameTest(ValidationResult expected, boolean
networkLinkingSupported, String networkName) {
+ private void networkNameTest(Matcher<ValidationResult> matcher, boolean
networkLinkingSupported, String networkName) {
mockConfigRule.mockConfigValue(ConfigValues.NetworkLinkingSupported,
version, networkLinkingSupported);
when(nic.getNetworkName()).thenReturn(networkName);
- assertEquals(expected, validator.networkNameValid());
+ assertThat(validator.networkNameValid(), matcher);
}
- private void portMirroringTest(ValidationResult expected, String
networkName, boolean portMirroring) {
+ private void portMirroringTest(Matcher<ValidationResult> matcher, String
networkName, boolean portMirroring) {
when(nic.getNetworkName()).thenReturn(networkName);
when(nic.isPortMirroring()).thenReturn(portMirroring);
- assertEquals(expected, validator.networkProvidedForPortMirroring());
+ assertThat(validator.networkProvidedForPortMirroring(), matcher);
}
}
--
To view, visit http://gerrit.ovirt.org/13062
To unsubscribe, visit http://gerrit.ovirt.org/settings
Gerrit-MessageType: newchange
Gerrit-Change-Id: Ic8bfd0e15f0204f4a4a099a322fa78d8b33aec85
Gerrit-PatchSet: 1
Gerrit-Project: ovirt-engine
Gerrit-Branch: master
Gerrit-Owner: Mike Kolesnik <mkole...@redhat.com>
_______________________________________________
Engine-patches mailing list
Engine-patches@ovirt.org
http://lists.ovirt.org/mailman/listinfo/engine-patches
