etan39
/
cloudstack
mirror of https://github.com/apache/cloudstack.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fixed unit tests

This commit is contained in:
Alex Huang 2013-09-05 19:36:27 -07:00
parent 8f556e6d88
commit 1f5699b29f
10 changed files with 181 additions and 514 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
engine/storage/integration-test/test/org/apache/cloudstack/storage/test/EndpointSelectorTest.java
View File

@ -58,10 +58,6 @@ import org.apache.cloudstack.storage.datastore.db.SnapshotDataStoreDao;
import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
import com.cloud.agent.AgentManager;
<<<<<<< HEAD
import com.cloud.server.LockMasterListener;
=======
>>>>>>> Made changes to configuration. Eliminated ConfigValue and only use ConfigKey
import com.cloud.dc.ClusterVO;
import com.cloud.dc.DataCenter;
import com.cloud.dc.DataCenterVO;

6
framework/config/src/org/apache/cloudstack/framework/config/ConfigKey.java
View File

@ -139,7 +139,11 @@ public class ConfigKey<T> {
return _value;
}
public T valueIn(long id) {
public T valueIn(Long id) {
if (id == null) {
return value();
}
String value = s_depot != null ? s_depot.scoped(this).getConfigValue(id, this) : null;
if (value == null) {
return value();

5
plugins/network-elements/internal-loadbalancer/src/org/apache/cloudstack/network/lb/InternalLoadBalancerVMManagerImpl.java
View File

@ -29,7 +29,6 @@ import javax.naming.ConfigurationException;
import org.apache.log4j.Logger;
import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
import org.apache.cloudstack.framework.config.ConfigDepot;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.apache.cloudstack.lb.ApplicationLoadBalancerRuleVO;
import org.apache.cloudstack.lb.dao.ApplicationLoadBalancerRuleDao;
@ -88,7 +87,6 @@ import com.cloud.offering.NetworkOffering;
import com.cloud.offering.ServiceOffering;
import com.cloud.offerings.dao.NetworkOfferingDao;
import com.cloud.resource.ResourceManager;
import com.cloud.server.ConfigurationServer;
import com.cloud.service.ServiceOfferingVO;
import com.cloud.service.dao.ServiceOfferingDao;
import com.cloud.storage.VMTemplateVO;
@ -148,9 +146,6 @@ public class InternalLoadBalancerVMManagerImpl extends ManagerBase implements In
@Inject NetworkOfferingDao _networkOfferingDao;
@Inject VMTemplateDao _templateDao;
@Inject ResourceManager _resourceMgr;
@Inject ConfigurationServer _configServer;
@Inject
ConfigDepot _configDepot;
@Override
public boolean finalizeVirtualMachineProfile(VirtualMachineProfile profile,

1
plugins/network-elements/internal-loadbalancer/test/org/apache/cloudstack/internallbvmmgr/InternalLBVMServiceTest.java
View File

@ -61,7 +61,6 @@ import com.cloud.vm.dao.DomainRouterDao;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:/lb_svc.xml")
@SuppressWarnings("unchecked")
public class InternalLBVMServiceTest extends TestCase {
//The interface to test
@Inject InternalLoadBalancerVMService _lbVmSvc;

6
server/src/com/cloud/configuration/ConfigurationManagerImpl.java
View File

@ -25,7 +25,6 @@ import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
@ -35,10 +34,6 @@ import java.util.UUID;
import javax.ejb.Local;
import javax.inject.Inject;
import javax.naming.ConfigurationException;
import javax.naming.Context;
import javax.naming.NamingException;
import javax.naming.directory.DirContext;
import javax.naming.directory.InitialDirContext;
import org.apache.log4j.Logger;
@ -191,7 +186,6 @@ import com.cloud.utils.NumbersUtil;
import com.cloud.utils.Pair;
import com.cloud.utils.StringUtils;
import com.cloud.utils.component.ManagerBase;
import com.cloud.utils.crypt.DBEncryptionUtil;
import com.cloud.utils.db.DB;
import com.cloud.utils.db.EntityManager;
import com.cloud.utils.db.Filter;

2
server/src/com/cloud/vm/UserVmManagerImpl.java
View File

@ -1521,7 +1521,7 @@ public class UserVmManagerImpl extends ManagerBase implements UserVmManager, Vir
VirtualMachine.State.getStateMachine().registerListener(
new UserVmStateListener(_usageEventDao, _networkDao, _nicDao));
value = _configDao.getValue(Config.SetVmInternalNameUsingDisplayName.key());
String value = _configDao.getValue(Config.SetVmInternalNameUsingDisplayName.key());
_instanceNameFlag = (value == null)?false:Boolean.parseBoolean(value);
_scaleRetry = NumbersUtil.parseInt(configs.get(Config.ScaleRetry.key()), 2);

6
server/test/com/cloud/vpc/NetworkACLServiceTest.java
View File

@ -147,7 +147,7 @@ public class NetworkACLServiceTest extends TestCase{
@Test
public void testCreateACL() throws Exception {
Mockito.when(_entityMgr.findById(Vpc.class, Mockito.anyLong())).thenReturn(new VpcVO());
Mockito.when(_entityMgr.findById(Mockito.eq(Vpc.class), Mockito.anyLong())).thenReturn(new VpcVO());
Mockito.when(_networkAclMgr.createNetworkACL("acl_new", "acl desc", 1L)).thenReturn(acl);
assertNotNull(_aclService.createNetworkACL("acl_new", "acl desc", 1L));
}
@ -161,7 +161,7 @@ public class NetworkACLServiceTest extends TestCase{
@Test
public void testCreateACLItem() throws Exception {
Mockito.when(_entityMgr.findById(Vpc.class, Mockito.anyLong())).thenReturn(new VpcVO());
Mockito.when(_entityMgr.findById(Mockito.eq(Vpc.class), Mockito.anyLong())).thenReturn(new VpcVO());
Mockito.when(_networkAclMgr.getNetworkACL(Mockito.anyLong())).thenReturn(acl);
Mockito.when(_networkAclMgr.createNetworkACLItem(Mockito.anyInt(), Mockito.anyInt(), Mockito.anyString(), Mockito.anyList(), Mockito.anyInt(), Mockito.anyInt(),
Mockito.any(NetworkACLItem.TrafficType.class), Mockito.anyLong(), Mockito.anyString(), Mockito.anyInt())).thenReturn(new NetworkACLItemVO());
@ -171,7 +171,7 @@ public class NetworkACLServiceTest extends TestCase{
@Test(expected = InvalidParameterValueException.class)
public void testCreateACLItemDuplicateNumber() throws Exception {
Mockito.when(_entityMgr.findById(Vpc.class, Mockito.anyLong())).thenReturn(new VpcVO());
Mockito.when(_entityMgr.findById(Mockito.eq(Vpc.class), Mockito.anyLong())).thenReturn(new VpcVO());
Mockito.when(_networkAclMgr.getNetworkACL(Mockito.anyLong())).thenReturn(acl);
Mockito.when(_networkACLItemDao.findByAclAndNumber(Mockito.anyLong(), Mockito.anyInt())).thenReturn(new NetworkACLItemVO());
_aclService.createNetworkACLItem(createACLItemCmd);

286
server/test/com/cloud/vpc/VpcTest.java
View File

@ -1,286 +0,0 @@
// Licensed to the Apache Software Foundation (ASF) under one or more
// contributor license agreements. See the NOTICE file distributed with
// this work for additional information regarding copyright ownership.
// The ASF licenses this file to You under the Apache License, Version 2.0
// (the "License"); you may not use this file except in compliance with
// the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package com.cloud.vpc;
import java.io.IOException;
import java.util.UUID;
import javax.inject.Inject;
import junit.framework.TestCase;
import org.apache.log4j.Logger;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.TypeFilter;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.support.AnnotationConfigContextLoader;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.apache.cloudstack.test.utils.SpringUtils;
import com.cloud.configuration.ConfigurationManager;
import com.cloud.dc.dao.DataCenterDao;
import com.cloud.dc.dao.VlanDao;
import com.cloud.network.NetworkModel;
import com.cloud.network.NetworkService;
import com.cloud.network.dao.FirewallRulesDao;
import com.cloud.network.dao.IPAddressDao;
import com.cloud.network.dao.NetworkDao;
import com.cloud.network.dao.PhysicalNetworkDao;
import com.cloud.network.dao.Site2SiteVpnGatewayDao;
import com.cloud.network.vpc.NetworkACLManager;
import com.cloud.network.vpc.Vpc;
import com.cloud.network.vpc.VpcManager;
import com.cloud.network.vpc.VpcOfferingVO;
import com.cloud.network.vpc.VpcService;
import com.cloud.network.vpc.VpcVO;
import com.cloud.network.vpc.dao.PrivateIpDao;
import com.cloud.network.vpc.dao.StaticRouteDao;
import com.cloud.network.vpc.dao.VpcDao;
import com.cloud.network.vpc.dao.VpcGatewayDao;
import com.cloud.network.vpc.dao.VpcOfferingDao;
import com.cloud.network.vpc.dao.VpcOfferingServiceMapDao;
import com.cloud.network.vpc.dao.VpcServiceMapDao;
import com.cloud.network.vpn.Site2SiteVpnManager;
import com.cloud.offerings.dao.NetworkOfferingServiceMapDao;
import com.cloud.server.ConfigurationServer;
import com.cloud.tags.dao.ResourceTagDao;
import com.cloud.user.Account;
import com.cloud.user.AccountManager;
import com.cloud.user.AccountVO;
import com.cloud.user.ResourceLimitService;
import com.cloud.user.UserVO;
import com.cloud.utils.component.ComponentContext;
import com.cloud.vm.dao.DomainRouterDao;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(loader = AnnotationConfigContextLoader.class)
public class VpcTest extends TestCase {
@Inject
VpcService _vpcService;
@Inject
AccountManager _accountMgr;
@Inject
VpcManager _vpcMgr;
@Inject
VpcDao _vpcDao;
@Inject
VpcOfferingDao _vpcOfferinDao;
private VpcVO vpc;
private static final Logger s_logger = Logger.getLogger(VpcTest.class);
@Override
@Before
public void setUp() {
ComponentContext.initComponentsLifeCycle();
Account account = new AccountVO("testaccount", 1, "testdomain", (short) 0, UUID.randomUUID().toString());
UserVO user = new UserVO(1, "testuser", "password", "firstname", "lastName", "email", "timezone", UUID.randomUUID().toString());
CallContext.register(user, account);
vpc = new VpcVO(1, "myvpc", "myvpc", 2, 1, 1, "10.0.1.0/16", "mydomain");
}
@Override
@After
public void tearDown() {
CallContext.unregister();
}
@Test
public void testCreateVpc() throws Exception {
Mockito.when(
_vpcService.createVpc(Mockito.anyLong(), Mockito.anyLong(), Mockito.anyLong(), Mockito.anyString(),
Mockito.anyString(), Mockito.anyString(), Mockito.anyString())).thenReturn(vpc);
Mockito.when(_vpcOfferinDao.persist(Mockito.any(VpcOfferingVO.class))).thenReturn(
new VpcOfferingVO("test", "test", 1L));
Vpc vpc1 = _vpcService.createVpc(1, 1, 1, "myVpc", "my Vpc", "10.0.0.0/16", "test");
assertNotNull("Vpc is created", vpc1);
}
@Configuration
@ComponentScan(basePackageClasses = { VpcManager.class }, includeFilters = { @ComponentScan.Filter(value = VpcTestConfiguration.Library.class, type = FilterType.CUSTOM) }, useDefaultFilters = false)
public static class VpcTestConfiguration extends SpringUtils.CloudStackTestConfiguration {
@Bean
public AccountManager accountManager() {
return Mockito.mock(AccountManager.class);
}
@Bean
public NetworkOrchestrationService networkManager() {
return Mockito.mock(NetworkOrchestrationService.class);
}
@Bean
public NetworkModel networkModel() {
return Mockito.mock(NetworkModel.class);
}
@Bean
public VpcManager vpcManager() {
return Mockito.mock(VpcManager.class);
}
@Bean
public ResourceTagDao resourceTagDao() {
return Mockito.mock(ResourceTagDao.class);
}
@Bean
public VpcDao VpcDao() {
return Mockito.mock(VpcDao.class);
}
@Bean
public VpcOfferingDao vpcOfferingDao() {
return Mockito.mock(VpcOfferingDao.class);
}
@Bean
public VpcOfferingServiceMapDao vpcOfferingServiceMapDao() {
return Mockito.mock(VpcOfferingServiceMapDao.class);
}
@Bean
public ConfigurationDao configurationDao() {
return Mockito.mock(ConfigurationDao.class);
}
@Bean
public ConfigurationManager configurationManager() {
return Mockito.mock(ConfigurationManager.class);
}
@Bean
public NetworkDao networkDao() {
return Mockito.mock(NetworkDao.class);
}
@Bean
public NetworkACLManager networkACLManager() {
return Mockito.mock(NetworkACLManager.class);
}
@Bean
public IPAddressDao ipAddressDao() {
return Mockito.mock(IPAddressDao.class);
}
@Bean
public DomainRouterDao domainRouterDao() {
return Mockito.mock(DomainRouterDao.class);
}
@Bean
public VpcGatewayDao vpcGatewayDao() {
return Mockito.mock(VpcGatewayDao.class);
}
@Bean
public PrivateIpDao privateIpDao() {
return Mockito.mock(PrivateIpDao.class);
}
@Bean
public StaticRouteDao staticRouteDao() {
return Mockito.mock(StaticRouteDao.class);
}
@Bean
public NetworkOfferingServiceMapDao networkOfferingServiceMapDao() {
return Mockito.mock(NetworkOfferingServiceMapDao.class);
}
@Bean
public PhysicalNetworkDao physicalNetworkDao() {
return Mockito.mock(PhysicalNetworkDao.class);
}
@Bean
public FirewallRulesDao firewallRulesDao() {
return Mockito.mock(FirewallRulesDao.class);
}
@Bean
public Site2SiteVpnGatewayDao site2SiteVpnGatewayDao() {
return Mockito.mock(Site2SiteVpnGatewayDao.class);
}
@Bean
public Site2SiteVpnManager site2SiteVpnManager() {
return Mockito.mock(Site2SiteVpnManager.class);
}
@Bean
public VlanDao vlanDao() {
return Mockito.mock(VlanDao.class);
}
@Bean
public ResourceLimitService resourceLimitService() {
return Mockito.mock(ResourceLimitService.class);
}
@Bean
public VpcServiceMapDao vpcServiceMapDao() {
return Mockito.mock(VpcServiceMapDao.class);
}
@Bean
public NetworkService networkService() {
return Mockito.mock(NetworkService.class);
}
@Bean
public DataCenterDao dataCenterDao() {
return Mockito.mock(DataCenterDao.class);
}
@Bean
public ConfigurationServer configurationServer() {
return Mockito.mock(ConfigurationServer.class);
}
public static class Library implements TypeFilter {
@Override
public boolean match(MetadataReader mdr, MetadataReaderFactory arg1) throws IOException {
mdr.getClassMetadata().getClassName();
ComponentScan cs = VpcTestConfiguration.class.getAnnotation(ComponentScan.class);
return SpringUtils.includedInBasePackageClasses(mdr.getClassMetadata().getClassName(), cs);
}
}
}
}

268
server/test/org/apache/cloudstack/lb/ApplicationLoadBalancerTest.java
View File

@ -16,6 +16,7 @@
// under the License.
package org.apache.cloudstack.lb;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
@ -29,13 +30,24 @@ import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.TypeFilter;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.support.AnnotationConfigContextLoader;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
import org.apache.cloudstack.lb.dao.ApplicationLoadBalancerRuleDao;
import org.apache.cloudstack.network.lb.ApplicationLoadBalancerManagerImpl;
import org.apache.cloudstack.network.lb.ApplicationLoadBalancerRule;
import org.apache.cloudstack.test.utils.SpringUtils;
import com.cloud.event.dao.UsageEventDao;
import com.cloud.exception.InsufficientAddressCapacityException;
@ -43,6 +55,7 @@ import com.cloud.exception.InsufficientVirtualNetworkCapcityException;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.exception.NetworkRuleConflictException;
import com.cloud.exception.UnsupportedServiceException;
import com.cloud.network.IpAddressManager;
import com.cloud.network.Network;
import com.cloud.network.Network.Capability;
import com.cloud.network.Network.Service;
@ -55,6 +68,7 @@ import com.cloud.network.lb.LoadBalancingRulesManager;
import com.cloud.network.lb.LoadBalancingRulesService;
import com.cloud.network.rules.FirewallRuleVO;
import com.cloud.network.rules.LoadBalancerContainer.Scheme;
import com.cloud.tags.dao.ResourceTagDao;
import com.cloud.user.AccountManager;
import com.cloud.user.AccountVO;
import com.cloud.user.UserVO;
@ -69,36 +83,40 @@ import com.cloud.utils.net.NetUtils;
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:/appLoadBalancer.xml")
public class ApplicationLoadBalancerTest extends TestCase{
@ContextConfiguration(loader = AnnotationConfigContextLoader.class)
public class ApplicationLoadBalancerTest extends TestCase {
//The interface to test
@Inject ApplicationLoadBalancerManagerImpl _appLbSvc;
@Inject
ApplicationLoadBalancerManagerImpl _appLbSvc;
//The interfaces below are mocked
@Inject ApplicationLoadBalancerRuleDao _lbDao;
@Inject LoadBalancingRulesManager _lbMgr;
@Inject NetworkModel _ntwkModel;
@Inject AccountManager _accountMgr;
@Inject FirewallRulesDao _firewallDao;
@Inject UsageEventDao _usageEventDao;
@Inject
ApplicationLoadBalancerRuleDao _lbDao;
@Inject
LoadBalancingRulesManager _lbMgr;
@Inject
NetworkModel _ntwkModel;
@Inject
AccountManager _accountMgr;
@Inject
FirewallRulesDao _firewallDao;
@Inject
UsageEventDao _usageEventDao;
@Inject
LoadBalancingRulesService _lbService;
public static long existingLbId = 1L;
public static long nonExistingLbId = 2L;
public static long validGuestNetworkId = 1L;
public static long invalidGuestNetworkId = 2L;
public static long validPublicNetworkId = 3L;
public static long validAccountId = 1L;
public static long invalidAccountId = 2L;
public String validRequestedIp = "10.1.1.1";
@Override
@Before
public void setUp() {
@ -106,20 +124,18 @@ public class ApplicationLoadBalancerTest extends TestCase{
//mockito for .getApplicationLoadBalancer tests
Mockito.when(_lbDao.findById(1L)).thenReturn(new ApplicationLoadBalancerRuleVO());
Mockito.when(_lbDao.findById(2L)).thenReturn(null);
//mockito for .deleteApplicationLoadBalancer tests
Mockito.when(_lbService.deleteLoadBalancerRule(existingLbId, true)).thenReturn(true);
Mockito.when(_lbService.deleteLoadBalancerRule(nonExistingLbId, true)).thenReturn(false);
//mockito for .createApplicationLoadBalancer tests
NetworkVO guestNetwork = new NetworkVO(TrafficType.Guest, null, null, 1,
null, 1, 1L);
NetworkVO guestNetwork = new NetworkVO(TrafficType.Guest, null, null, 1, null, 1, 1L);
setId(guestNetwork, validGuestNetworkId);
guestNetwork.setCidr("10.1.1.1/24");
NetworkVO publicNetwork = new NetworkVO(TrafficType.Public, null, null, 1,
null, 1, 1L);
NetworkVO publicNetwork = new NetworkVO(TrafficType.Public, null, null, 1, null, 1, 1L);
Mockito.when(_ntwkModel.getNetwork(validGuestNetworkId)).thenReturn(guestNetwork);
Mockito.when(_ntwkModel.getNetwork(invalidGuestNetworkId)).thenReturn(null);
Mockito.when(_ntwkModel.getNetwork(validPublicNetworkId)).thenReturn(publicNetwork);
@ -128,30 +144,29 @@ public class ApplicationLoadBalancerTest extends TestCase{
Mockito.when(_accountMgr.getAccount(invalidAccountId)).thenReturn(null);
Mockito.when(_ntwkModel.areServicesSupportedInNetwork(validGuestNetworkId, Service.Lb)).thenReturn(true);
Mockito.when(_ntwkModel.areServicesSupportedInNetwork(invalidGuestNetworkId, Service.Lb)).thenReturn(false);
ApplicationLoadBalancerRuleVO lbRule = new ApplicationLoadBalancerRuleVO("new", "new", 22, 22, "roundrobin",
validGuestNetworkId, validAccountId, 1L, new Ip(validRequestedIp), validGuestNetworkId, Scheme.Internal);
ApplicationLoadBalancerRuleVO lbRule = new ApplicationLoadBalancerRuleVO("new", "new", 22, 22, "roundrobin", validGuestNetworkId, validAccountId, 1L, new Ip(
validRequestedIp), validGuestNetworkId, Scheme.Internal);
Mockito.when(_lbDao.persist(Mockito.any(ApplicationLoadBalancerRuleVO.class))).thenReturn(lbRule);
Mockito.when(_lbMgr.validateLbRule(Mockito.any(LoadBalancingRule.class))).thenReturn(true);
Mockito.when(_firewallDao.setStateToAdd(Mockito.any(FirewallRuleVO.class))).thenReturn(true);
Mockito.when(_accountMgr.getSystemUser()).thenReturn(new UserVO(1));
Mockito.when(_accountMgr.getSystemAccount()).thenReturn(new AccountVO(2));
CallContext.register(_accountMgr.getSystemUser(), _accountMgr.getSystemAccount());
Mockito.when(_ntwkModel.areServicesSupportedInNetwork(Mockito.anyLong(), Mockito.any(Network.Service.class))).thenReturn(true);
Map<Network.Capability, String> caps = new HashMap<Network.Capability, String>();
caps.put(Capability.SupportedProtocols, NetUtils.TCP_PROTO);
Mockito.when(_ntwkModel.getNetworkServiceCapabilities(Mockito.anyLong(), Mockito.any(Network.Service.class))).thenReturn(caps);
Mockito.when(_lbDao.countBySourceIp(new Ip(validRequestedIp), validGuestNetworkId)).thenReturn(1L);
}
@Override
@After
public void tearDown() {
@ -161,17 +176,19 @@ public class ApplicationLoadBalancerTest extends TestCase{
/**
* TESTS FOR .getApplicationLoadBalancer
*/
@Test
//Positive test - retrieve existing lb
public void searchForExistingLoadBalancer() {
public
void searchForExistingLoadBalancer() {
ApplicationLoadBalancerRule rule = _appLbSvc.getApplicationLoadBalancer(existingLbId);
assertNotNull("Couldn't find existing application load balancer", rule);
}
@Test
//Negative test - try to retrieve non-existing lb
public void searchForNonExistingLoadBalancer() {
public
void searchForNonExistingLoadBalancer() {
boolean notFound = false;
ApplicationLoadBalancerRule rule = null;
try {
@ -182,18 +199,18 @@ public class ApplicationLoadBalancerTest extends TestCase{
} catch (InvalidParameterValueException ex) {
notFound = true;
}
assertTrue("Found non-existing load balancer; no invalid parameter value exception was thrown", notFound);
}
/**
* TESTS FOR .deleteApplicationLoadBalancer
*/
@Test
//Positive test - delete existing lb
public void deleteExistingLoadBalancer() {
public
void deleteExistingLoadBalancer() {
boolean result = false;
try {
result = _appLbSvc.deleteApplicationLoadBalancer(existingLbId);
@ -201,11 +218,11 @@ public class ApplicationLoadBalancerTest extends TestCase{
assertTrue("Couldn't delete existing application load balancer", result);
}
}
@Test
//Negative test - try to delete non-existing lb
public void deleteNonExistingLoadBalancer() {
public
void deleteNonExistingLoadBalancer() {
boolean result = true;
try {
result = _appLbSvc.deleteApplicationLoadBalancer(nonExistingLbId);
@ -213,79 +230,72 @@ public class ApplicationLoadBalancerTest extends TestCase{
assertFalse("Didn't fail when try to delete non-existing load balancer", result);
}
}
/**
* TESTS FOR .createApplicationLoadBalancer
* @throws NetworkRuleConflictException
* @throws InsufficientVirtualNetworkCapcityException
* @throws InsufficientAddressCapacityException
*/
@Test (expected = CloudRuntimeException.class)
@Test(expected = CloudRuntimeException.class)
//Positive test
public void createValidLoadBalancer() throws InsufficientAddressCapacityException,
InsufficientVirtualNetworkCapcityException, NetworkRuleConflictException {
_appLbSvc.createApplicationLoadBalancer("alena", "alena", Scheme.Internal, validGuestNetworkId, validRequestedIp,
22, 22, "roundrobin", validGuestNetworkId, validAccountId);
public
void createValidLoadBalancer() throws InsufficientAddressCapacityException, InsufficientVirtualNetworkCapcityException, NetworkRuleConflictException {
_appLbSvc.createApplicationLoadBalancer("alena", "alena", Scheme.Internal, validGuestNetworkId, validRequestedIp, 22, 22, "roundrobin", validGuestNetworkId, validAccountId);
}
@Test(expected = UnsupportedServiceException.class)
//Negative test - only internal scheme value is supported in the current release
public void createPublicLoadBalancer() throws InsufficientAddressCapacityException,
InsufficientVirtualNetworkCapcityException, NetworkRuleConflictException {
_appLbSvc.createApplicationLoadBalancer("alena", "alena", Scheme.Public, validGuestNetworkId, validRequestedIp,
22, 22, "roundrobin", validGuestNetworkId, validAccountId);
public
void createPublicLoadBalancer() throws InsufficientAddressCapacityException, InsufficientVirtualNetworkCapcityException, NetworkRuleConflictException {
_appLbSvc.createApplicationLoadBalancer("alena", "alena", Scheme.Public, validGuestNetworkId, validRequestedIp, 22, 22, "roundrobin", validGuestNetworkId, validAccountId);
}
@Test(expected = InvalidParameterValueException.class)
//Negative test - invalid SourcePort
public void createWithInvalidSourcePort() throws InsufficientAddressCapacityException,
InsufficientVirtualNetworkCapcityException, NetworkRuleConflictException {
_appLbSvc.createApplicationLoadBalancer("alena", "alena", Scheme.Internal, validGuestNetworkId, validRequestedIp,
65536, 22, "roundrobin", validGuestNetworkId, validAccountId);
public
void createWithInvalidSourcePort() throws InsufficientAddressCapacityException, InsufficientVirtualNetworkCapcityException, NetworkRuleConflictException {
_appLbSvc.createApplicationLoadBalancer("alena", "alena", Scheme.Internal, validGuestNetworkId, validRequestedIp, 65536, 22, "roundrobin", validGuestNetworkId,
validAccountId);
}
@Test(expected = InvalidParameterValueException.class)
//Negative test - invalid instancePort
public void createWithInvalidInstandePort() throws InsufficientAddressCapacityException,
InsufficientVirtualNetworkCapcityException, NetworkRuleConflictException {
_appLbSvc.createApplicationLoadBalancer("alena", "alena", Scheme.Internal, validGuestNetworkId, validRequestedIp,
22, 65536, "roundrobin", validGuestNetworkId, validAccountId);
public
void createWithInvalidInstandePort() throws InsufficientAddressCapacityException, InsufficientVirtualNetworkCapcityException, NetworkRuleConflictException {
_appLbSvc.createApplicationLoadBalancer("alena", "alena", Scheme.Internal, validGuestNetworkId, validRequestedIp, 22, 65536, "roundrobin", validGuestNetworkId,
validAccountId);
}
@Test(expected = InvalidParameterValueException.class)
//Negative test - invalid algorithm
public void createWithInvalidAlgorithm() throws InsufficientAddressCapacityException, InsufficientVirtualNetworkCapcityException, NetworkRuleConflictException {
public
void createWithInvalidAlgorithm() throws InsufficientAddressCapacityException, InsufficientVirtualNetworkCapcityException, NetworkRuleConflictException {
String expectedExcText = null;
_appLbSvc.createApplicationLoadBalancer("alena", "alena", Scheme.Internal, validGuestNetworkId, validRequestedIp,
22, 22, "invalidalgorithm", validGuestNetworkId, validAccountId);
_appLbSvc.createApplicationLoadBalancer("alena", "alena", Scheme.Internal, validGuestNetworkId, validRequestedIp, 22, 22, "invalidalgorithm", validGuestNetworkId,
validAccountId);
}
@Test(expected = InvalidParameterValueException.class)
//Negative test - invalid sourceNetworkId (of Public type, which is not supported)
public void createWithInvalidSourceIpNtwk() throws InsufficientAddressCapacityException,
InsufficientVirtualNetworkCapcityException, NetworkRuleConflictException {
_appLbSvc.createApplicationLoadBalancer("alena", "alena", Scheme.Internal, validPublicNetworkId, validRequestedIp,
22, 22, "roundrobin", validGuestNetworkId, validAccountId);
public
void createWithInvalidSourceIpNtwk() throws InsufficientAddressCapacityException, InsufficientVirtualNetworkCapcityException, NetworkRuleConflictException {
_appLbSvc.createApplicationLoadBalancer("alena", "alena", Scheme.Internal, validPublicNetworkId, validRequestedIp, 22, 22, "roundrobin", validGuestNetworkId,
validAccountId);
}
@Test(expected = InvalidParameterValueException.class)
//Negative test - invalid requested IP (outside of guest network cidr range)
public void createWithInvalidRequestedIp() throws InsufficientAddressCapacityException,
InsufficientVirtualNetworkCapcityException, NetworkRuleConflictException {
_appLbSvc.createApplicationLoadBalancer("alena", "alena", Scheme.Internal, validGuestNetworkId, "10.2.1.1",
22, 22, "roundrobin", validGuestNetworkId, validAccountId);
public
void createWithInvalidRequestedIp() throws InsufficientAddressCapacityException, InsufficientVirtualNetworkCapcityException, NetworkRuleConflictException {
_appLbSvc.createApplicationLoadBalancer("alena", "alena", Scheme.Internal, validGuestNetworkId, "10.2.1.1", 22, 22, "roundrobin", validGuestNetworkId, validAccountId);
}
private static NetworkVO setId(NetworkVO vo, long id) {
NetworkVO voToReturn = vo;
Class<?> c = voToReturn.getClass();
@ -294,11 +304,77 @@ public class ApplicationLoadBalancerTest extends TestCase{
f.setAccessible(true);
f.setLong(voToReturn, id);
} catch (NoSuchFieldException ex) {
return null;
return null;
} catch (IllegalAccessException ex) {
return null;
}
return voToReturn;
}
@Configuration
@ComponentScan(basePackageClasses = {NetUtils.class, ApplicationLoadBalancerManagerImpl.class}, includeFilters = {@Filter(value = TestConfiguration.Library.class, type = FilterType.CUSTOM)}, useDefaultFilters = false)
public static class TestConfiguration extends SpringUtils.CloudStackTestConfiguration {
@Bean
public ApplicationLoadBalancerRuleDao applicationLoadBalancerDao() {
return Mockito.mock(ApplicationLoadBalancerRuleDao.class);
}
@Bean
IpAddressManager ipAddressManager() {
return Mockito.mock(IpAddressManager.class);
}
@Bean
public NetworkModel networkModel() {
return Mockito.mock(NetworkModel.class);
}
@Bean
public AccountManager accountManager() {
return Mockito.mock(AccountManager.class);
}
@Bean
public LoadBalancingRulesManager loadBalancingRulesManager() {
return Mockito.mock(LoadBalancingRulesManager.class);
}
@Bean
public LoadBalancingRulesService loadBalancingRulesService() {
return Mockito.mock(LoadBalancingRulesService.class);
}
@Bean
public FirewallRulesDao firewallRulesDao() {
return Mockito.mock(FirewallRulesDao.class);
}
@Bean
public ResourceTagDao resourceTagDao() {
return Mockito.mock(ResourceTagDao.class);
}
@Bean
public NetworkOrchestrationService networkManager() {
return Mockito.mock(NetworkOrchestrationService.class);
}
@Bean
public UsageEventDao UsageEventDao() {
return Mockito.mock(UsageEventDao.class);
}
public static class Library implements TypeFilter {
@Override
public boolean match(MetadataReader mdr, MetadataReaderFactory arg1) throws IOException {
mdr.getClassMetadata().getClassName();
ComponentScan cs = TestConfiguration.class.getAnnotation(ComponentScan.class);
return SpringUtils.includedInBasePackageClasses(mdr.getClassMetadata().getClassName(), cs);
}
}
}
}

111
server/test/org/apache/cloudstack/lb/ChildTestConfiguration.java
View File

@ -1,111 +0,0 @@
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
package org.apache.cloudstack.lb;
import java.io.IOException;
import org.mockito.Mockito;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.TypeFilter;
import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
import org.apache.cloudstack.lb.dao.ApplicationLoadBalancerRuleDao;
import org.apache.cloudstack.test.utils.SpringUtils;
import com.cloud.event.dao.UsageEventDao;
import com.cloud.network.IpAddressManager;
import com.cloud.network.NetworkModel;
import com.cloud.network.dao.FirewallRulesDao;
import com.cloud.network.lb.LoadBalancingRulesManager;
import com.cloud.tags.dao.ResourceTagDao;
import com.cloud.user.AccountManager;
import com.cloud.utils.net.NetUtils;
@Configuration
@ComponentScan(
basePackageClasses={
NetUtils.class
},
includeFilters={@Filter(value=ChildTestConfiguration.Library.class, type=FilterType.CUSTOM)},
useDefaultFilters=false
)
public class ChildTestConfiguration {
public static class Library implements TypeFilter {
@Bean
public ApplicationLoadBalancerRuleDao applicationLoadBalancerDao() {
return Mockito.mock(ApplicationLoadBalancerRuleDao.class);
}
@Bean
IpAddressManager ipAddressManager() {
return Mockito.mock(IpAddressManager.class);
}
@Bean
public NetworkModel networkModel() {
return Mockito.mock(NetworkModel.class);
}
@Bean
public AccountManager accountManager() {
return Mockito.mock(AccountManager.class);
}
@Bean
public LoadBalancingRulesManager loadBalancingRulesManager() {
return Mockito.mock(LoadBalancingRulesManager.class);
}
@Bean
public FirewallRulesDao firewallRulesDao() {
return Mockito.mock(FirewallRulesDao.class);
}
@Bean
public ResourceTagDao resourceTagDao() {
return Mockito.mock(ResourceTagDao.class);
}
@Bean
public NetworkOrchestrationService networkManager() {
return Mockito.mock(NetworkOrchestrationService.class);
}
@Bean
public UsageEventDao UsageEventDao() {
return Mockito.mock(UsageEventDao.class);
}
@Override
public boolean match(MetadataReader mdr, MetadataReaderFactory arg1) throws IOException {
mdr.getClassMetadata().getClassName();
ComponentScan cs = ChildTestConfiguration.class.getAnnotation(ComponentScan.class);
return SpringUtils.includedInBasePackageClasses(mdr.getClassMetadata().getClassName(), cs);
}
}
}