server/src/test/java/com/cloud/network/NetworkServiceImplTest.java - cloudstack - Git at Google


            
            // 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.network;


            import static org.junit.Assert.assertEquals;

            
            import static org.mockito.ArgumentMatchers.any;

            
            import static org.mockito.ArgumentMatchers.anyBoolean;

            
            import static org.mockito.ArgumentMatchers.anyLong;

            
            import static org.mockito.ArgumentMatchers.eq;

            
            import static org.mockito.ArgumentMatchers.nullable;

            
            import static org.mockito.Mockito.doNothing;

            
            import static org.mockito.Mockito.doReturn;

            
            import static org.mockito.Mockito.doThrow;

            
            import static org.mockito.Mockito.mock;

            
            import static org.mockito.Mockito.times;

            
            import static org.mockito.Mockito.when;


            import java.lang.reflect.Field;

            
            import java.net.URI;

            
            import java.util.ArrayList;

            
            import java.util.Arrays;

            
            import java.util.Calendar;

            
            import java.util.Collections;

            
            import java.util.Date;

            
            import java.util.HashMap;

            
            import java.util.List;

            
            import java.util.Map;

            
            import java.util.UUID;


            import org.apache.cloudstack.alert.AlertService;

            
            import org.apache.cloudstack.api.command.admin.network.AssociateNetworkToNicCmd;

            
            import org.apache.cloudstack.api.command.admin.network.ChangeNicPrimaryNetworkCmd;

            
            import org.apache.cloudstack.api.command.admin.network.DisassociateNetworkFromNicCmd;

            
            import org.apache.cloudstack.api.command.admin.network.CreateNetworkCmdByAdmin;

            
            import org.apache.cloudstack.api.command.user.address.UpdateQuarantinedIpCmd;

            
            import org.apache.cloudstack.api.command.user.network.CreateNetworkCmd;

            
            import org.apache.cloudstack.api.command.user.network.UpdateNetworkCmd;

            
            import org.apache.cloudstack.context.CallContext;

            
            import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;

            
            import org.apache.cloudstack.framework.config.ConfigKey;

            
            import org.apache.cloudstack.network.RoutedIpv4Manager;

            
            import org.apache.cloudstack.storage.template.VnfTemplateManager;

            
            import org.junit.After;

            
            import org.junit.Assert;

            
            import org.junit.Before;

            
            import org.junit.BeforeClass;

            
            import org.junit.Test;

            
            import org.junit.runner.RunWith;

            
            import org.mockito.ArgumentMatchers;

            
            import org.mockito.InjectMocks;

            
            import org.mockito.Mock;

            
            import org.mockito.MockedStatic;

            
            import org.mockito.Mockito;

            
            import org.mockito.MockitoAnnotations;

            
            import org.mockito.junit.MockitoJUnitRunner;

            
            import org.springframework.beans.factory.NoSuchBeanDefinitionException;

            
            import org.springframework.test.util.ReflectionTestUtils;


            import com.cloud.agent.AgentManager;

            
            import com.cloud.agent.api.UpdateNicVlanMembershipAnswer;

            
            import com.cloud.agent.api.to.IpAddressTO;

            
            import com.cloud.agent.api.to.NicTO;

            
            import com.cloud.hypervisor.Hypervisor;

            
            import com.cloud.hypervisor.HypervisorGuru;

            
            import com.cloud.hypervisor.HypervisorGuruManager;

            
            import com.cloud.alert.AlertManager;

            
            import com.cloud.bgp.BGPService;

            
            import com.cloud.configuration.ConfigurationManager;

            
            import com.cloud.dc.DataCenter;

            
            import com.cloud.dc.DataCenterVO;

            
            import com.cloud.dc.dao.DataCenterDao;

            
            import com.cloud.domain.Domain;

            
            import com.cloud.domain.DomainVO;

            
            import com.cloud.event.EventTypes;

            
            import com.cloud.event.UsageEventUtils;

            
            import com.cloud.event.UsageEventVO;

            
            import com.cloud.domain.dao.DomainDao;

            
            import com.cloud.exception.ConcurrentOperationException;

            
            import com.cloud.exception.InsufficientAddressCapacityException;

            
            import com.cloud.exception.InsufficientCapacityException;

            
            import com.cloud.exception.InvalidParameterValueException;

            
            import com.cloud.exception.PermissionDeniedException;

            
            import com.cloud.exception.ResourceAllocationException;

            
            import com.cloud.host.DetailVO;

            
            import com.cloud.host.Host;

            
            import com.cloud.host.dao.HostDao;

            
            import com.cloud.host.dao.HostDetailsDao;

            
            import com.cloud.network.dao.FirewallRulesDao;

            
            import com.cloud.network.dao.IPAddressDao;

            
            import com.cloud.network.dao.LoadBalancerDao;

            
            import com.cloud.network.rules.dao.PortForwardingRulesDao;

            
            import com.cloud.network.dao.IPAddressVO;

            
            import com.cloud.network.dao.NetworkDao;

            
            import com.cloud.network.dao.NetworkVO;

            
            import com.cloud.network.dao.NsxProviderDao;

            
            import com.cloud.network.dao.PhysicalNetworkDao;

            
            import com.cloud.network.dao.PhysicalNetworkVO;

            
            import com.cloud.network.dao.PublicIpQuarantineDao;

            
            import com.cloud.network.nsx.NsxService;

            
            import com.cloud.network.router.CommandSetupHelper;

            
            import com.cloud.network.router.NetworkHelper;

            
            import com.cloud.network.vo.PublicIpQuarantineVO;

            
            import com.cloud.vm.UserVmVO;

            
            import com.cloud.vm.dao.NicNetworkMapDao;

            
            import com.cloud.vm.dao.NicNetworkMapVO;

            
            import com.cloud.vm.dao.UserVmDao;

            
            import com.cloud.network.vpc.VpcManager;

            
            import com.cloud.network.vpc.VpcVO;

            
            import com.cloud.network.vpc.dao.VpcDao;

            
            import com.cloud.offering.NetworkOffering;

            
            import com.cloud.offering.ServiceOffering;

            
            import com.cloud.offerings.NetworkOfferingVO;

            
            import com.cloud.offerings.dao.NetworkOfferingDao;

            
            import com.cloud.offerings.dao.NetworkOfferingServiceMapDao;

            
            import com.cloud.org.Grouping;

            
            import com.cloud.service.ServiceOfferingVO;

            
            import com.cloud.service.dao.ServiceOfferingDao;

            
            import com.cloud.storage.VMTemplateVO;

            
            import com.cloud.storage.dao.VMTemplateDao;

            
            import com.cloud.user.Account;

            
            import com.cloud.user.AccountManager;

            
            import com.cloud.user.AccountService;

            
            import com.cloud.user.AccountVO;

            
            import com.cloud.user.User;

            
            import com.cloud.user.UserVO;

            
            import com.cloud.user.dao.AccountDao;

            
            import com.cloud.user.dao.UserDao;

            
            import com.cloud.utils.Pair;

            
            import com.cloud.utils.component.ComponentContext;

            
            import com.cloud.utils.db.EntityManager;

            
            import com.cloud.utils.db.SearchCriteria;

            
            import com.cloud.utils.exception.CloudRuntimeException;

            
            import com.cloud.utils.net.Ip;

            
            import com.cloud.utils.net.NetUtils;

            
            import com.cloud.vm.DomainRouterVO;

            
            import com.cloud.vm.Nic;

            
            import com.cloud.vm.NicVO;

            
            import com.cloud.vm.VirtualMachine;

            
            import com.cloud.vm.dao.DomainRouterDao;

            
            import com.cloud.vm.dao.NicDao;


            @RunWith(MockitoJUnitRunner.class)

            
            public class NetworkServiceImplTest {

            
                @Mock

            
                Object job;

            
                @Mock

            
                Object _responseObject;


                @Mock

            
                AccountManager accountManager;

            
                @Mock

            
                NetworkOfferingDao networkOfferingDao;

            
                @Mock

            
                PhysicalNetworkDao physicalNetworkDao;

            
                @Mock

            
                DataCenterDao dataCenterDao;

            
                @Mock

            
                NetworkOrchestrationService networkOrchestrationService;

            
                @Mock

            
                Ipv6Service ipv6Service;

            
                @Mock

            
                NetworkModel networkModel;

            
                @Mock

            
                AgentManager agentMgr;

            
                @Mock

            
                HypervisorGuruManager hvGuruMgr;

            
                @Mock

            
                HypervisorGuru hypervisorGuru;

            
                @Mock

            
                NetworkOfferingServiceMapDao networkOfferingServiceMapDao;

            
                @Mock

            
                EntityManager entityMgr;

            
                @Mock

            
                NetworkService networkService;

            
                @Mock

            
                VpcManager vpcMgr;

            
                @Mock

            
                NetworkOrchestrationService _networkMgr;

            
                @Mock

            
                AlertManager alertManager;

            
                @Mock

            
                DataCenterDao _dcDao;

            
                @Mock

            
                UserDao userDao;

            
                @Mock

            
                NetworkDao networkDao;

            
                @Mock

            
                NicDao nicDao;

            
                @Mock

            
                UserVmDao userVmDao;

            
                @Mock

            
                HostDao hostDao;

            
                @Mock

            
                HostDetailsDao hostDetailsDao;

            
                @Mock

            
                NicNetworkMapDao nicNetworkMapDao;

            
                @Mock

            
                Ipv6AddressManager ipv6AddressManager;

            
                @Mock

            
                IPAddressDao ipAddressDao;

            
                @Mock

            
                FirewallRulesDao firewallRulesDao;

            
                @Mock

            
                PortForwardingRulesDao portForwardingRulesDao;

            
                @Mock

            
                LoadBalancerDao loadBalancerDao;

            
                @Mock

            
                VMTemplateDao templateDao;

            
                @Mock

            
                VnfTemplateManager vnfTemplateManagerMock;

            
                @Mock

            
                ConfigurationManager configMgr;

            
                @Mock

            
                ConfigKey<Integer> publicMtuKey;

            
                @Mock

            
                ConfigKey<Boolean> userChangeMtuKey;

            
                @Mock

            
                VpcDao vpcDao;

            
                @Mock

            
                DomainRouterDao routerDao;

            
                @Mock

            
                AccountService _accountService;

            
                @Mock

            
                NetworkHelper networkHelper;

            
                @Mock

            
                ServiceOfferingDao serviceOfferingDaoMock;

            
                @Mock

            
                ServiceOfferingVO serviceOfferingVoMock;


                @Mock

            
                ConfigKey<Integer> privateMtuKey;

            
                @Mock

            
                private CallContext callContextMock;

            
                @InjectMocks

            
                CreateNetworkCmd createNetworkCmd = new CreateNetworkCmd();


                @InjectMocks

            
                UpdateNetworkCmd updateNetworkCmd = new UpdateNetworkCmd();

            
                @Mock

            
                CommandSetupHelper commandSetupHelper;

            
                @Mock

            
                private Account accountMock;


                @Mock

            
                private AccountVO accountVOMock;

            
                @Mock

            
                private DomainVO domainVOMock;

            
                @InjectMocks

            
                NetworkServiceImpl service;


                @Mock

            
                DomainDao domainDaoMock;


                @Mock

            
                AccountDao accountDaoMock;


                @Mock

            
                UpdateQuarantinedIpCmd updateQuarantinedIpCmdMock;


                @Mock

            
                PublicIpQuarantineDao publicIpQuarantineDaoMock;


                @Mock

            
                private PublicIpQuarantineVO publicIpQuarantineVOMock;


                @Mock

            
                private IPAddressVO ipAddressVOMock;


                @Mock

            
                private IpAddressManager ipAddressManagerMock;


                @Mock

            
                private RoutedIpv4Manager routedIpv4Manager;


                @Mock

            
                BGPService bgpService;


                @Mock

            
                private Ip ipMock;

            
                @Mock

            
                private NsxProviderDao nsxProviderDao;


                private static Date beforeDate;


                private static Date afterDate;


                private final Long publicIpId = 1L;


                private final String dummyIpAddress = "192.168.0.1";


                private static final String VLAN_ID_900 = "900";

            
                private static final String VLAN_ID_901 = "901";

            
                private static final String VLAN_ID_902 = "902";

            
                public static final long ACCOUNT_ID = 1;


                private static final String IP4_GATEWAY = "10.0.16.1";

            
                private static final String IP4_NETMASK = "255.255.255.0";

            
                private static final String IP6_GATEWAY = "fd17:ac56:1234:2000::1";

            
                private static final String IP6_CIDR = "fd17:ac56:1234:2000::/64";

            
                final String[] ip4Dns = {"5.5.5.5", "6.6.6.6"};

            
                final String[] ip6Dns = {"2001:4860:4860::5555", "2001:4860:4860::6666"};


                private AccountVO account;

            
                private UserVO user;

            
                private NetworkOfferingVO offering;

            
                private DataCenterVO dc;

            
                private Network network;

            
                private  PhysicalNetworkVO phyNet;

            
                private VpcVO vpc;


                private MockedStatic<CallContext> callContextMocked;

            
                private MockedStatic<UsageEventUtils> usageEventUtilsMocked;


                private AutoCloseable closeable;


                private NetworkOfferingVO networkOfferingVO;

            
                private Long zoneId = 10L;

            
                private Long networkId = 11L;


                @BeforeClass

            
                public static void setUpBeforeClass() {

            
                    Date date = new Date();

            
                    Calendar calendar = Calendar.getInstance();


                    calendar.setTime(date);

            
                    calendar.add(Calendar.DATE, -1);

            
                    beforeDate = calendar.getTime();


                    calendar.setTime(date);

            
                    calendar.add(Calendar.DATE, 1);

            
                    afterDate = calendar.getTime();

            
                }


                private void registerCallContext() {

            
                    account = new AccountVO("testaccount", 1L, "networkdomain", Account.Type.NORMAL, "uuid");

            
                    account.setId(ACCOUNT_ID);

            
                    user = new UserVO(1, "testuser", "password", "firstname", "lastName", "email", "timezone",

            
                            UUID.randomUUID().toString(), User.Source.UNKNOWN);

            
                    CallContext.register(user, account);

            
                }


                Class<InvalidParameterValueException> expectedException = InvalidParameterValueException.class;


                @Before

            
                public void setup() throws Exception {

            
                    closeable = MockitoAnnotations.openMocks(this);

            
                    overrideDefaultConfigValue(NetworkService.AllowUsersToSpecifyVRMtu, "_defaultValue", "true");

            
                    overrideDefaultConfigValue(NetworkOrchestrationService.MultiNetworkNicEnabled, "_defaultValue", "true");

            
                    offering = Mockito.mock(NetworkOfferingVO.class);

            
                    network = Mockito.mock(Network.class);

            
                    dc = Mockito.mock(DataCenterVO.class);

            
                    phyNet = Mockito.mock(PhysicalNetworkVO.class);

            
                    vpc = Mockito.mock(VpcVO.class);

            
                    service._networkOfferingDao = networkOfferingDao;

            
                    service._physicalNetworkDao = physicalNetworkDao;

            
                    service._accountMgr = accountManager;

            
                    service.alertManager = alertManager;

            
                    service._configMgr = configMgr;

            
                    service._vpcDao = vpcDao;

            
                    service._vpcMgr = vpcMgr;

            
                    service._networksDao = networkDao;

            
                    service._nicDao = nicDao;

            
                    Mockito.when(nicDao.acquireInLockTable(Mockito.anyLong())).thenReturn(Mockito.mock(NicVO.class));

            
                    Mockito.when(networkDao.acquireInLockTable(Mockito.anyLong(), Mockito.anyInt())).thenReturn(Mockito.mock(NetworkVO.class));

            
                    service._ipAddressDao = ipAddressDao;

            
                    service.routerDao = routerDao;

            
                    service.commandSetupHelper = commandSetupHelper;

            
                    service.networkHelper = networkHelper;

            
                    service._ipAddrMgr = ipAddressManagerMock;

            
                    service.nsxProviderDao = nsxProviderDao;

            
                    service._userVmDao = userVmDao;

            
                    service._hostDao = hostDao;

            
                    service._hostDetailsDao = hostDetailsDao;

            
                    service._nicNetworkMapDao = nicNetworkMapDao;

            
                    service.ipv6AddrMgr = ipv6AddressManager;

            
                    service._networkModel = networkModel;

            
                    service._entityMgr = entityMgr;

            
                    service._networkMgr = _networkMgr;

            
                    service._templateDao = templateDao;

            
                    service.vnfTemplateManager = vnfTemplateManagerMock;

            
                    callContextMocked = Mockito.mockStatic(CallContext.class);

            
                    // stubbed as a no-op by default: persistAssociations publishes a real UsageEventUtils call on every

            
                    // first-time trunk conversion, which this class' tests don't otherwise need to know about

            
                    usageEventUtilsMocked = Mockito.mockStatic(UsageEventUtils.class);

            
                    CallContext callContextMock = Mockito.mock(CallContext.class);

            
                    callContextMocked.when(CallContext::current).thenReturn(callContextMock);

            
                    accountMock = Mockito.mock(Account.class);

            
                    Mockito.when(service._accountMgr.finalizeOwner(any(Account.class), nullable(String.class), nullable(Long.class), nullable(Long.class))).thenReturn(accountMock);

            
                    Mockito.when(callContextMock.getCallingAccount()).thenReturn(accountMock);

            
                    NetworkOffering networkOffering = Mockito.mock(NetworkOffering.class);

            
                    Mockito.when(entityMgr.findById(NetworkOffering.class, 1L)).thenReturn(networkOffering);

            
                    Mockito.when(networkOfferingDao.findById(1L)).thenReturn(offering);

            
                    Mockito.when(physicalNetworkDao.findById(Mockito.anyLong())).thenReturn(phyNet);

            
                    Mockito.when(_dcDao.findById(Mockito.anyLong())).thenReturn(dc);

            
                    Mockito.when(accountManager.isRootAdmin(accountMock.getId())).thenReturn(true);

            
                }


                @After

            
                public void tearDown() throws Exception {

            
                    callContextMocked.close();

            
                    usageEventUtilsMocked.close();

            
                    closeable.close();

            
                }


                private void overrideDefaultConfigValue(final ConfigKey configKey, final String name, final Object o) throws IllegalAccessException, NoSuchFieldException {

            
                    Field f = ConfigKey.class.getDeclaredField(name);

            
                    f.setAccessible(true);

            
                    f.set(configKey, o);

            
                }


                @Test

            
                public void testGetPrivateVlanPairNoVlans() {

            
                    Pair<String, Network.PVlanType> pair = service.getPrivateVlanPair(null, null, null);

            
                    Assert.assertNull(pair.first());

            
                    Assert.assertNull(pair.second());

            
                }


                @Test

            
                public void testGetPrivateVlanPairVlanPrimaryOnly() {

            
                    Pair<String, Network.PVlanType> pair = service.getPrivateVlanPair(null, null, VLAN_ID_900);

            
                    Assert.assertNull(pair.first());

            
                    Assert.assertNull(pair.second());

            
                }


                @Test

            
                public void testGetPrivateVlanPairVlanPrimaryPromiscuousType() {

            
                    Pair<String, Network.PVlanType> pair = service.getPrivateVlanPair(null, Network.PVlanType.Promiscuous.toString(), VLAN_ID_900);

            
                    Assert.assertEquals(VLAN_ID_900, pair.first());

            
                    Assert.assertEquals(Network.PVlanType.Promiscuous, pair.second());

            
                }


                @Test

            
                public void testGetPrivateVlanPairPromiscuousType() {

            
                    Pair<String, Network.PVlanType> pair = service.getPrivateVlanPair(VLAN_ID_900, Network.PVlanType.Promiscuous.toString(), VLAN_ID_900);

            
                    Assert.assertEquals(VLAN_ID_900, pair.first());

            
                    Assert.assertEquals(Network.PVlanType.Promiscuous, pair.second());

            
                }


                @Test

            
                public void testGetPrivateVlanPairPromiscuousTypeOnSecondaryVlanId() {

            
                    Pair<String, Network.PVlanType> pair = service.getPrivateVlanPair(VLAN_ID_900, "promiscuous", VLAN_ID_900);

            
                    Assert.assertEquals(VLAN_ID_900, pair.first());

            
                    Assert.assertEquals(Network.PVlanType.Promiscuous, pair.second());

            
                }


                @Test

            
                public void testGetPrivateVlanPairIsolatedType() {

            
                    Pair<String, Network.PVlanType> pair = service.getPrivateVlanPair(VLAN_ID_901, Network.PVlanType.Isolated.toString(), VLAN_ID_900);

            
                    Assert.assertEquals(VLAN_ID_901, pair.first());

            
                    Assert.assertEquals(Network.PVlanType.Isolated, pair.second());

            
                }


                @Test

            
                public void testGetPrivateVlanPairIsolatedTypeOnSecondaryVlanId() {

            
                    Pair<String, Network.PVlanType> pair = service.getPrivateVlanPair(VLAN_ID_901, "isolated", VLAN_ID_900);

            
                    Assert.assertEquals(VLAN_ID_901, pair.first());

            
                    Assert.assertEquals(Network.PVlanType.Isolated, pair.second());

            
                }


                @Test

            
                public void testGetPrivateVlanPairCommunityType() {

            
                    Pair<String, Network.PVlanType> pair = service.getPrivateVlanPair(VLAN_ID_902, Network.PVlanType.Community.toString(), VLAN_ID_900);

            
                    Assert.assertEquals(VLAN_ID_902, pair.first());

            
                    Assert.assertEquals(Network.PVlanType.Community, pair.second());

            
                }


                @Test

            
                public void testGetPrivateVlanPairCommunityTypeOnSecondaryVlanId() {

            
                    Pair<String, Network.PVlanType> pair = service.getPrivateVlanPair(VLAN_ID_902, "community", VLAN_ID_900);

            
                    Assert.assertEquals(VLAN_ID_902, pair.first());

            
                    Assert.assertEquals(Network.PVlanType.Community, pair.second());

            
                }


                @Test(expected = CloudRuntimeException.class)

            
                public void testPerformBasicChecksPromiscuousTypeExpectedIsolatedSet() {

            
                    service.performBasicPrivateVlanChecks(VLAN_ID_900, VLAN_ID_900, Network.PVlanType.Isolated);

            
                }


                @Test(expected = CloudRuntimeException.class)

            
                public void testPerformBasicChecksPromiscuousTypeExpectedCommunitySet() {

            
                    service.performBasicPrivateVlanChecks(VLAN_ID_900, VLAN_ID_900, Network.PVlanType.Community);

            
                }


                @Test(expected = CloudRuntimeException.class)

            
                public void testPerformBasicChecksPromiscuousTypeExpectedSecondaryVlanNullIsolatedSet() {

            
                    service.performBasicPrivateVlanChecks(VLAN_ID_900, null, Network.PVlanType.Isolated);

            
                }


                @Test(expected = CloudRuntimeException.class)

            
                public void testPerformBasicChecksPromiscuousTypeExpectedSecondaryVlanNullCommunitySet() {

            
                    service.performBasicPrivateVlanChecks(VLAN_ID_900, null, Network.PVlanType.Community);

            
                }


                @Test(expected = CloudRuntimeException.class)

            
                public void testPerformBasicChecksPromiscuousTypeExpectedDifferentVlanIds() {

            
                    service.performBasicPrivateVlanChecks(VLAN_ID_900, VLAN_ID_901, Network.PVlanType.Promiscuous);

            
                }


                @Test

            
                public void testCreateGuestNetwork() throws InsufficientCapacityException, ResourceAllocationException {

            
                    Integer publicMtu = 2450;

            
                    Integer privateMtu = 1200;

            
                    ReflectionTestUtils.setField(createNetworkCmd, "name", "testNetwork");

            
                    ReflectionTestUtils.setField(createNetworkCmd, "displayText", "Test Network");

            
                    ReflectionTestUtils.setField(createNetworkCmd, "networkOfferingId", 1L);

            
                    ReflectionTestUtils.setField(createNetworkCmd, "zoneId", 1L);

            
                    ReflectionTestUtils.setField(createNetworkCmd, "publicMtu", publicMtu);

            
                    ReflectionTestUtils.setField(createNetworkCmd, "privateMtu", privateMtu);

            
                    ReflectionTestUtils.setField(createNetworkCmd, "physicalNetworkId", null);

            
                    Mockito.when(offering.isSystemOnly()).thenReturn(false);

            
                    Mockito.when(dc.getId()).thenReturn(1L);

            
                    Mockito.when(dc.getAllocationState()).thenReturn(Grouping.AllocationState.Enabled);

            
                    Map<String, String> networkProvidersMap = new HashMap<String, String>();

            
                    Mockito.when(_networkMgr.finalizeServicesAndProvidersForNetwork(ArgumentMatchers.any(NetworkOffering.class), anyLong())).thenReturn(networkProvidersMap);

            
                    Mockito.when(configMgr.isOfferingForVpc(offering)).thenReturn(false);

            
                    Mockito.when(offering.isInternalLb()).thenReturn(false);


                    service.createGuestNetwork(createNetworkCmd);

            
                    Mockito.verify(_networkMgr, times(1)).createGuestNetwork(1L, "testNetwork", "Test Network", null,

            
                            null, null, false, null, accountMock, null, phyNet,

            
                            1L, null, null, null, null, null,

            
                            true, null, null, null, null, null,

            
                            null, null, null, null, new Pair<>(1500, privateMtu), null, true);

            
                }

            
                @Test

            
                public void testValidateMtuConfigWhenMtusExceedThreshold() {

            
                    Integer publicMtu = 2450;

            
                    Integer privateMtu = 1500;

            
                    Long zoneId = 1L;

            
                    Pair<Integer, Integer> interfaceMtus = service.validateMtuConfig(publicMtu, privateMtu, zoneId);

            
                    Assert.assertNotNull(interfaceMtus);

            
                    Assert.assertEquals(NetworkService.DEFAULT_MTU, interfaceMtus.first());

            
                    Assert.assertEquals(NetworkService.DEFAULT_MTU, interfaceMtus.second());

            
                    Mockito.verify(alertManager, Mockito.times(1)).sendAlert(Mockito.any(AlertService.AlertType.class),

            
                            Mockito.anyLong(), nullable(Long.class), Mockito.anyString(), Mockito.anyString());

            
                }


                @Test

            
                public void testValidatePrivateMtuExceedingThreshold() {

            
                    Integer publicMtu = 1500;

            
                    Integer privateMtu = 2500;

            
                    Long zoneId = 1L;

            
                    Pair<Integer, Integer> interfaceMtus = service.validateMtuConfig(publicMtu, privateMtu, zoneId);

            
                    Assert.assertNotNull(interfaceMtus);

            
                    Assert.assertEquals(NetworkService.DEFAULT_MTU, interfaceMtus.first());

            
                    Assert.assertEquals(NetworkService.DEFAULT_MTU, interfaceMtus.second());

            
                    Mockito.verify(alertManager, Mockito.times(1)).sendAlert(Mockito.any(AlertService.AlertType.class),

            
                            Mockito.anyLong(), nullable(Long.class), Mockito.anyString(), Mockito.anyString());

            
                }


                @Test

            
                public void testValidateBypassingPublicMtuPassedDuringNetworkTierCreationForVpcs() throws InsufficientCapacityException, ResourceAllocationException {

            
                    Integer publicMtu = 1250;

            
                    Integer privateMtu = 1000;

            
                    Long zoneId = 1L;

            
                    ReflectionTestUtils.setField(createNetworkCmd, "name", "testNetwork");

            
                    ReflectionTestUtils.setField(createNetworkCmd, "displayText", "Test Network");

            
                    ReflectionTestUtils.setField(createNetworkCmd, "networkOfferingId", 1L);

            
                    ReflectionTestUtils.setField(createNetworkCmd, "zoneId", zoneId);

            
                    ReflectionTestUtils.setField(createNetworkCmd, "publicMtu", publicMtu);

            
                    ReflectionTestUtils.setField(createNetworkCmd, "privateMtu", privateMtu);

            
                    ReflectionTestUtils.setField(createNetworkCmd, "physicalNetworkId", null);

            
                    ReflectionTestUtils.setField(createNetworkCmd, "vpcId", 1L);

            
                    Mockito.when(dc.getId()).thenReturn(1L);

            
                    Mockito.when(configMgr.isOfferingForVpc(offering)).thenReturn(true);

            
                    Mockito.when(vpcDao.findById(anyLong())).thenReturn(vpc);


                    service.createGuestNetwork(createNetworkCmd);

            
                    Mockito.verify(vpcMgr, times(1)).createVpcGuestNetwork(1L, "testNetwork", "Test Network", null,

            
                            null, null, null, accountMock, null, phyNet,

            
                            1L, null, null, 1L, null, accountMock,

            
                            true, null, null, null, null, null, null, null, new Pair<>(0, 1000), null);


                }


                @Test

            
                public void testUpdateSharedNetworkMtus() throws Exception {

            
                    Integer publicMtu = 1250;

            
                    Integer privateMtu = 1000;

            
                    Long networkId = 1L;

            
                    Long zoneId = 1L;

            
                    ReflectionTestUtils.setField(updateNetworkCmd, "id", networkId);

            
                    ReflectionTestUtils.setField(updateNetworkCmd, "publicMtu", publicMtu);

            
                    ReflectionTestUtils.setField(updateNetworkCmd, "privateMtu", privateMtu);


                    User callingUser = mock(User.class);

            
                    UserVO userVO = mock(UserVO.class);

            
                    Account callingAccount = mock(Account.class);

            
                    NetworkVO networkVO = mock(NetworkVO.class);

            
                    NicVO nicVO = mock(NicVO.class);

            
                    List<IPAddressVO> addresses = new ArrayList<>();

            
                    List<IpAddressTO> ips = new ArrayList<>();

            
                    List<DomainRouterVO> routers = new ArrayList<>();

            
                    DomainRouterVO routerPrimary = Mockito.mock(DomainRouterVO.class);

            
                    routers.add(routerPrimary);


                    CallContext.register(callingUser, callingAccount);

            
                    Mockito.when(CallContext.current()).thenReturn(callContextMock);

            
                    Mockito.when(networkVO.getVpcId()).thenReturn(null);


                    Pair<Integer, Integer> updatedMtus = service.validateMtuOnUpdate(networkVO, zoneId, publicMtu, privateMtu);

            
                    Assert.assertEquals(publicMtu, updatedMtus.first());

            
                    Assert.assertEquals(privateMtu, updatedMtus.second());

            
                }


                @Test

            
                public void testUpdatePublicInterfaceMtuViaNetworkTiersForVpcNetworks() {

            
                    Integer vpcMtu = 1450;

            
                    Integer publicMtu = 1250;

            
                    Integer privateMtu = 1000;

            
                    Long vpcId = 1L;

            
                    Long zoneId = 1L;

            
                    ReflectionTestUtils.setField(createNetworkCmd, "name", "testNetwork");

            
                    ReflectionTestUtils.setField(createNetworkCmd, "displayText", "Test Network");

            
                    ReflectionTestUtils.setField(createNetworkCmd, "networkOfferingId", 1L);

            
                    ReflectionTestUtils.setField(createNetworkCmd, "zoneId", zoneId);

            
                    ReflectionTestUtils.setField(createNetworkCmd, "publicMtu", publicMtu);

            
                    ReflectionTestUtils.setField(createNetworkCmd, "privateMtu", privateMtu);

            
                    ReflectionTestUtils.setField(createNetworkCmd, "physicalNetworkId", null);

            
                    ReflectionTestUtils.setField(createNetworkCmd, "vpcId", vpcId);


                    VpcVO vpcVO = Mockito.mock(VpcVO.class);

            
                    Mockito.when(vpcDao.findById(anyLong())).thenReturn(vpcVO);

            
                    Mockito.when(vpcVO.getPublicMtu()).thenReturn(vpcMtu);


                    Pair<Integer, Integer> updatedMtus = service.validateMtuConfig(publicMtu, privateMtu, zoneId);

            
                    service.mtuCheckForVpcNetwork(vpcId, updatedMtus, publicMtu);

            
                    Assert.assertEquals(vpcMtu, updatedMtus.first());

            
                    Assert.assertEquals(privateMtu, updatedMtus.second());

            
                }


                private void prepareCreateNetworkDnsMocks(CreateNetworkCmd cmd, Network.GuestType guestType, boolean ipv6, boolean isVpc, boolean dnsServiceSupported) {

            
                    long networkOfferingId = 1L;

            
                    Mockito.when(cmd.getNetworkOfferingId()).thenReturn(networkOfferingId);

            
                    networkOfferingVO = Mockito.mock(NetworkOfferingVO.class);

            
                    Mockito.when(networkOfferingVO.getId()).thenReturn(networkOfferingId);

            
                    Mockito.when(networkOfferingVO.getGuestType()).thenReturn(guestType);

            
                    Mockito.when(networkOfferingDao.findById(networkOfferingId)).thenReturn(networkOfferingVO);

            
                    if (Network.GuestType.Shared.equals(guestType)) {

            
                        Mockito.when(networkModel.isProviderForNetworkOffering(Mockito.any(), Mockito.anyLong())).thenReturn(true);

            
                        Mockito.when(cmd.getGateway()).thenReturn(IP4_GATEWAY);

            
                        Mockito.when(cmd.getNetmask()).thenReturn(IP4_NETMASK);

            
                    }

            
                    Mockito.when(physicalNetworkDao.findById(Mockito.anyLong())).thenReturn(Mockito.mock(PhysicalNetworkVO.class));

            
                    Mockito.when(networkOfferingServiceMapDao.areServicesSupportedByNetworkOffering(networkOfferingId, Network.Service.Dns)).thenReturn(dnsServiceSupported);

            
                    if(ipv6 && Network.GuestType.Isolated.equals(guestType)) {

            
                        Mockito.when(networkOfferingDao.isIpv6Supported(networkOfferingId)).thenReturn(true);

            
                        try {

            
                            Mockito.when(ipv6Service.preAllocateIpv6SubnetForNetwork(Mockito.any())).thenReturn(new Pair<>(IP6_GATEWAY, IP6_CIDR));

            
                        } catch (ResourceAllocationException e) {

            
                            Assert.fail(String.format("failure with exception: %s", e.getMessage()));

            
                        }

            
                    }

            
                    Mockito.when(cmd.getSubdomainAccess()).thenReturn(null);

            
                    Mockito.when(cmd.getAssociatedNetworkId()).thenReturn(null);

            
                    if (isVpc) {

            
                        Mockito.when(cmd.getVpcId()).thenReturn(1L);

            
                    } else {

            
                        Mockito.when(cmd.getVpcId()).thenReturn(null);

            
                    }

            
                }


                @Test(expected = InvalidParameterValueException.class)

            
                public void testCreateL2NetworkDnsFailure() {

            
                    registerCallContext();

            
                    CreateNetworkCmd cmd = Mockito.mock(CreateNetworkCmd.class);

            
                    prepareCreateNetworkDnsMocks(cmd, Network.GuestType.L2, false, false, true);

            
                    Mockito.when(cmd.getIp4Dns1()).thenReturn(ip4Dns[0]);

            
                    try {

            
                        service.createGuestNetwork(cmd);

            
                    } catch (InsufficientCapacityException | ResourceAllocationException e) {

            
                        Assert.fail(String.format("failure with exception: %s", e.getMessage()));

            
                    }

            
                }


                @Test

            
                public void testCreateNetworkDnsVpcFailure() {

            
                    registerCallContext();

            
                    CreateNetworkCmd cmd = Mockito.mock(CreateNetworkCmd.class);

            
                    prepareCreateNetworkDnsMocks(cmd, Network.GuestType.Isolated, false, false, true);

            
                    Mockito.when(cmd.getIp4Dns1()).thenReturn(ip4Dns[0]);

            
                    Mockito.when(cmd.getCidrSize()).thenReturn(null);

            
                    try {

            
                        service.createGuestNetwork(cmd);

            
                    } catch (InsufficientCapacityException | ResourceAllocationException e) {

            
                        Assert.fail(String.format("failure with exception: %s", e.getMessage()));

            
                    }

            
                }


                @Test(expected = CloudRuntimeException.class)

            
                public void testCreateNetworkDnsOfferingServiceFailure() {

            
                    registerCallContext();

            
                    CreateNetworkCmd cmd = Mockito.mock(CreateNetworkCmd.class);

            
                    Mockito.when(cmd.getDomainId()).thenReturn(null);

            
                    Mockito.when(cmd.getProjectId()).thenReturn(null);

            
                    prepareCreateNetworkDnsMocks(cmd, Network.GuestType.Isolated, false, false, false);

            
                    Mockito.when(cmd.getIp4Dns1()).thenReturn(ip4Dns[0]);

            
                    try {

            
                        service.createGuestNetwork(cmd);

            
                    } catch (InsufficientCapacityException | ResourceAllocationException e) {

            
                        Assert.fail(String.format("failure with exception: %s", e.getMessage()));

            
                    }

            
                }


                @Test(expected = CloudRuntimeException.class)

            
                public void testCreateIp4NetworkIp6DnsFailure() {

            
                    registerCallContext();

            
                    CreateNetworkCmd cmd = Mockito.mock(CreateNetworkCmd.class);

            
                    prepareCreateNetworkDnsMocks(cmd, Network.GuestType.Isolated, false, false, true);

            
                    Mockito.when(cmd.getIp6Dns1()).thenReturn(ip4Dns[0]);

            
                    try {

            
                        service.createGuestNetwork(cmd);

            
                    } catch (InsufficientCapacityException | ResourceAllocationException e) {

            
                        Assert.fail(String.format("failure with exception: %s", e.getMessage()));

            
                    }

            
                }


                @Test

            
                public void testCheckAndUpdateNetworkNoUpdate() {

            
                    Assert.assertFalse(service.checkAndUpdateNetworkDns(Mockito.mock(NetworkVO.class), Mockito.mock(NetworkOffering.class), null, null, null, null));

            
                    NetworkVO network1 = Mockito.mock(NetworkVO.class);

            
                    Mockito.when(network1.getDns1()).thenReturn(ip4Dns[0]);

            
                    Long offeringId = 1L;

            
                    NetworkOffering offering = Mockito.mock(NetworkOffering.class);

            
                    Mockito.when(offering.getId()).thenReturn(offeringId);

            
                    Mockito.when(networkOfferingServiceMapDao.areServicesSupportedByNetworkOffering(offeringId, Network.Service.Dns)).thenReturn(true);

            
                    Assert.assertFalse(service.checkAndUpdateNetworkDns(network1, offering, null, null, null, null));

            
                    Assert.assertFalse(service.checkAndUpdateNetworkDns(network1, Mockito.mock(NetworkOffering.class), ip4Dns[0], null, null, null));

            
                    Mockito.when(network1.getIp6Dns1()).thenReturn(ip6Dns[0]);

            
                    Assert.assertFalse(service.checkAndUpdateNetworkDns(network1, Mockito.mock(NetworkOffering.class), ip4Dns[0], null, ip6Dns[0], null));

            
                }


                @Test

            
                public void testCheckAndUpdateNetworkOfferingChangeReset() {

            
                    NetworkVO networkVO = new NetworkVO();

            
                    networkVO.setDns1(ip4Dns[0]);

            
                    Long offeringId = 1L;

            
                    NetworkOffering offering = Mockito.mock(NetworkOffering.class);

            
                    Mockito.when(offering.getId()).thenReturn(offeringId);

            
                    Mockito.when(networkOfferingServiceMapDao.areServicesSupportedByNetworkOffering(offeringId, Network.Service.Dns)).thenReturn(false);

            
                    Assert.assertTrue(service.checkAndUpdateNetworkDns(networkVO, offering, null, null, null, null));

            
                    Assert.assertNull(networkVO.getDns1());

            
                    Assert.assertNull(networkVO.getDns2());

            
                    Assert.assertNull(networkVO.getIp6Dns1());

            
                    Assert.assertNull(networkVO.getIp6Dns2());

            
                }


                @Test(expected = InvalidParameterValueException.class)

            
                public void testCheckAndUpdateNetworkDnsL2NetworkFailure() {

            
                    NetworkVO networkVO = Mockito.mock(NetworkVO.class);

            
                    NetworkOffering offering = Mockito.mock(NetworkOffering.class);

            
                    Mockito.when(offering.getGuestType()).thenReturn(Network.GuestType.L2);

            
                    service.checkAndUpdateNetworkDns(networkVO, offering, ip4Dns[0], null, null, null);

            
                }


                @Test(expected = InvalidParameterValueException.class)

            
                public void testCheckAndUpdateNetworkDnsVpcTierFailure() {

            
                    NetworkVO networkVO = Mockito.mock(NetworkVO.class);

            
                    Mockito.when(networkVO.getVpcId()).thenReturn(1L);

            
                    NetworkOffering offering = Mockito.mock(NetworkOffering.class);

            
                    Mockito.when(offering.getGuestType()).thenReturn(Network.GuestType.Shared);

            
                    service.checkAndUpdateNetworkDns(networkVO, offering, ip4Dns[0], null, null, null);

            
                }


                @Test(expected = InvalidParameterValueException.class)

            
                public void testCheckAndUpdateNetworkDnsServiceFailure() {

            
                    NetworkVO networkVO = Mockito.mock(NetworkVO.class);

            
                    Mockito.when(networkVO.getVpcId()).thenReturn(null);

            
                    Long offeringId = 1L;

            
                    NetworkOffering offering = Mockito.mock(NetworkOffering.class);

            
                    Mockito.when(offering.getId()).thenReturn(offeringId);

            
                    Mockito.when(offering.getGuestType()).thenReturn(Network.GuestType.Shared);

            
                    Mockito.when(networkOfferingServiceMapDao.areServicesSupportedByNetworkOffering(offeringId, Network.Service.Dns)).thenReturn(false);

            
                    service.checkAndUpdateNetworkDns(networkVO, offering, ip4Dns[0], null, null, null);

            
                }


                @Test(expected = InvalidParameterValueException.class)

            
                public void testCheckAndUpdateNetworkNotSharedIp6Failure() {

            
                    NetworkVO networkVO = Mockito.mock(NetworkVO.class);

            
                    Mockito.when(networkVO.getVpcId()).thenReturn(null);

            
                    Mockito.when(networkVO.getIp6Cidr()).thenReturn(null);

            
                    Mockito.when(networkVO.getGuestType()).thenReturn(Network.GuestType.Shared);

            
                    Long offeringId = 1L;

            
                    NetworkOffering offering = Mockito.mock(NetworkOffering.class);

            
                    Mockito.when(offering.getId()).thenReturn(offeringId);

            
                    Mockito.when(networkOfferingServiceMapDao.areServicesSupportedByNetworkOffering(offeringId, Network.Service.Dns)).thenReturn(true);

            
                    service.checkAndUpdateNetworkDns(networkVO, offering, null, null, ip6Dns[0], null);

            
                }


                @Test(expected = InvalidParameterValueException.class)

            
                public void testCheckAndUpdateNetworkNotIsolatedIp6Failure() {

            
                    NetworkVO networkVO = Mockito.mock(NetworkVO.class);

            
                    Mockito.when(networkVO.getVpcId()).thenReturn(null);

            
                    Mockito.when(networkVO.getGuestType()).thenReturn(Network.GuestType.Isolated);

            
                    Long offeringId = 1L;

            
                    NetworkOffering offering = Mockito.mock(NetworkOffering.class);

            
                    Mockito.when(offering.getId()).thenReturn(offeringId);

            
                    Mockito.when(networkOfferingDao.isIpv6Supported(offeringId)).thenReturn(false);

            
                    Mockito.when(networkOfferingServiceMapDao.areServicesSupportedByNetworkOffering(offeringId, Network.Service.Dns)).thenReturn(true);

            
                    service.checkAndUpdateNetworkDns(networkVO, offering, null, null, ip6Dns[0], null);

            
                }


                @Test

            
                public void testCheckAndUpdateNetworkSuccess() {

            
                    NetworkVO networkVO = new NetworkVO();

            
                    networkVO.setVpcId(null);

            
                    try {

            
                        Field id = networkVO.getClass().getDeclaredField("guestType");

            
                        id.setAccessible(true);

            
                        id.set(networkVO, Network.GuestType.Shared);

            
                    } catch (NoSuchFieldException | IllegalAccessException e) {

            
                        Assert.fail(String.format("Unable to set network guestType, %s", e.getMessage()));

            
                    }

            
                    networkVO.setIp6Cidr("cidr");

            
                    Long offeringId = 1L;

            
                    NetworkOffering offering = Mockito.mock(NetworkOffering.class);

            
                    Mockito.when(offering.getId()).thenReturn(offeringId);

            
                    Mockito.when(networkOfferingServiceMapDao.areServicesSupportedByNetworkOffering(offeringId, Network.Service.Dns)).thenReturn(true);

            
                    boolean updated = service.checkAndUpdateNetworkDns(networkVO, offering, ip4Dns[0], null, ip6Dns[0], null);

            
                    Assert.assertTrue(updated);

            
                    Assert.assertEquals(ip4Dns[0], networkVO.getDns1());

            
                    Assert.assertNull(networkVO.getDns2());

            
                    Assert.assertEquals(ip6Dns[0], networkVO.getIp6Dns1());

            
                    Assert.assertNull(networkVO.getIp6Dns2());

            
                }


                @Test

            
                public void testCreateIpv4RoutedNetwork() {

            
                    registerCallContext();

            
                    CreateNetworkCmd cmd = Mockito.mock(CreateNetworkCmd.class);

            
                    Mockito.when(cmd.getCidrSize()).thenReturn(24);

            
                    prepareCreateNetworkDnsMocks(cmd, Network.GuestType.Isolated, false, false, true);

            
                    when(networkOfferingVO.getNetworkMode()).thenReturn(NetworkOffering.NetworkMode.ROUTED);

            
                    when(networkOfferingVO.getRoutingMode()).thenReturn(NetworkOffering.RoutingMode.Static);

            
                    when(routedIpv4Manager.isRoutedNetworkVpcEnabled(nullable(Long.class))).thenReturn(true);

            
                    when(routedIpv4Manager.isVirtualRouterGateway(networkOfferingVO)).thenReturn(true);

            
                    doNothing().when(routedIpv4Manager).assignIpv4SubnetToNetwork(nullable(Network.class));


                    DataCenterVO zone = Mockito.mock(DataCenterVO.class);

            
                    when(cmd.getZoneId()).thenReturn(zoneId);

            
                    when(_dcDao.findById(zoneId)).thenReturn(zone);

            
                    when(zone.getId()).thenReturn(zoneId);


                    try {

            
                        service.createGuestNetwork(cmd);

            
                    } catch (InsufficientCapacityException | ResourceAllocationException e) {

            
                        Assert.fail(String.format("failure with exception: %s", e.getMessage()));

            
                    }


                    Mockito.verify(routedIpv4Manager).assignIpv4SubnetToNetwork(nullable(Network.class));

            
                }


                @Test

            
                public void testCreateVpcTier() throws InsufficientCapacityException, ResourceAllocationException, NoSuchFieldException, IllegalAccessException {

            
                    Integer privateMtu = 1200;

            
                    Long networkOfferingId = 1L;

            
                    Long vpcId = 2L;


                    ReflectionTestUtils.setField(createNetworkCmd, "name", "testNetwork");

            
                    ReflectionTestUtils.setField(createNetworkCmd, "displayText", "Test Network");

            
                    ReflectionTestUtils.setField(createNetworkCmd, "networkOfferingId", networkOfferingId);

            
                    ReflectionTestUtils.setField(createNetworkCmd, "zoneId", zoneId);

            
                    ReflectionTestUtils.setField(createNetworkCmd, "privateMtu", privateMtu);

            
                    ReflectionTestUtils.setField(createNetworkCmd, "vpcId", vpcId);


                    dc = Mockito.mock(DataCenterVO.class);

            
                    Mockito.when(_dcDao.findById(zoneId)).thenReturn(dc);

            
                    Mockito.when(dc.getId()).thenReturn(zoneId);

            
                    vpc = Mockito.mock(VpcVO.class);

            
                    Mockito.when(vpc.getName()).thenReturn("Vpc 1");

            
                    Mockito.when(vpcDao.findById(vpcId)).thenReturn(vpc);

            
                    networkOfferingVO = Mockito.mock(NetworkOfferingVO.class);

            
                    Mockito.when(networkOfferingDao.findById(networkOfferingId)).thenReturn(networkOfferingVO);

            
                    Mockito.when(configMgr.isOfferingForVpc(networkOfferingVO)).thenReturn(true);


                    overrideDefaultConfigValue(VpcManager.VpcTierNamePrepend, "_defaultValue", "true");

            
                    overrideDefaultConfigValue(VpcManager.VpcTierNamePrependDelimiter, "_defaultValue", " -- ");


                    service.createGuestNetwork(createNetworkCmd);


                    overrideDefaultConfigValue(VpcManager.VpcTierNamePrepend, "_defaultValue", "false");


                    Mockito.verify(vpcMgr, times(1)).createVpcGuestNetwork(networkOfferingId, "Vpc 1 -- testNetwork", "Test Network", null, null,

            
                            null, null, accountMock, null, phyNet, zoneId, null, null, vpcId, null, accountMock, true,

            
                            null, null, null, null, null, null, null, new Pair<>(0, privateMtu), null);

            
                }


                public void testCreateIpv4RoutedNetworkWithBgpPeersFailure1() {

            
                    registerCallContext();

            
                    CreateNetworkCmdByAdmin cmd = Mockito.mock(CreateNetworkCmdByAdmin.class);

            
                    Mockito.when(cmd.getCidrSize()).thenReturn(24);

            
                    List<Long> bgpPeerIds = Arrays.asList(11L, 12L);

            
                    Mockito.when(cmd.getBgpPeerIds()).thenReturn(bgpPeerIds);


                    prepareCreateNetworkDnsMocks(cmd, Network.GuestType.Isolated, false, true, true);

            
                    when(networkOfferingVO.getNetworkMode()).thenReturn(NetworkOffering.NetworkMode.ROUTED);

            
                    when(networkOfferingVO.getRoutingMode()).thenReturn(NetworkOffering.RoutingMode.Static);

            
                    when(routedIpv4Manager.isRoutedNetworkVpcEnabled(nullable(Long.class))).thenReturn(true);

            
                    when(routedIpv4Manager.isVirtualRouterGateway(networkOfferingVO)).thenReturn(true);


                    DataCenterVO zone = Mockito.mock(DataCenterVO.class);

            
                    when(cmd.getZoneId()).thenReturn(zoneId);

            
                    when(_dcDao.findById(zoneId)).thenReturn(zone);

            
                    when(zone.getId()).thenReturn(zoneId);


                    try {

            
                        service.createGuestNetwork(cmd);

            
                    } catch (InsufficientCapacityException | ResourceAllocationException e) {

            
                        Assert.fail(String.format("failure with exception: %s", e.getMessage()));

            
                    } catch (InvalidParameterValueException ex) {

            
                        Assert.assertEquals("The BGP peers of VPC tiers will inherit from the VPC, do not add separately.", ex.getMessage());

            
                    }

            
                }


                @Test

            
                public void testCreateIpv4RoutedNetworkWithBgpPeersFailure2() {

            
                    registerCallContext();

            
                    CreateNetworkCmdByAdmin cmd = Mockito.mock(CreateNetworkCmdByAdmin.class);

            
                    Mockito.when(cmd.getCidrSize()).thenReturn(24);

            
                    List<Long> bgpPeerIds = Arrays.asList(11L, 12L);

            
                    Mockito.when(cmd.getBgpPeerIds()).thenReturn(bgpPeerIds);


                    prepareCreateNetworkDnsMocks(cmd, Network.GuestType.Isolated, false, false, true);

            
                    when(networkOfferingVO.getNetworkMode()).thenReturn(NetworkOffering.NetworkMode.ROUTED);

            
                    when(networkOfferingVO.getRoutingMode()).thenReturn(NetworkOffering.RoutingMode.Static);

            
                    when(routedIpv4Manager.isRoutedNetworkVpcEnabled(nullable(Long.class))).thenReturn(true);

            
                    when(routedIpv4Manager.isVirtualRouterGateway(networkOfferingVO)).thenReturn(true);


                    DataCenterVO zone = Mockito.mock(DataCenterVO.class);

            
                    when(cmd.getZoneId()).thenReturn(zoneId);

            
                    when(_dcDao.findById(zoneId)).thenReturn(zone);

            
                    when(zone.getId()).thenReturn(zoneId);


                    try {

            
                        service.createGuestNetwork(cmd);

            
                    } catch (InsufficientCapacityException | ResourceAllocationException e) {

            
                        Assert.fail(String.format("failure with exception: %s", e.getMessage()));

            
                    } catch (InvalidParameterValueException ex) {

            
                        Assert.assertEquals("The network offering does not support Dynamic routing", ex.getMessage());

            
                    }

            
                }


                @Test

            
                public void testCreateIpv4RoutedNetworkWithBgpPeersFailure3() {

            
                    registerCallContext();

            
                    CreateNetworkCmdByAdmin cmd = Mockito.mock(CreateNetworkCmdByAdmin.class);

            
                    Mockito.when(cmd.getCidrSize()).thenReturn(24);

            
                    List<Long> bgpPeerIds = Arrays.asList(11L, 12L);

            
                    Mockito.when(cmd.getBgpPeerIds()).thenReturn(bgpPeerIds);


                    prepareCreateNetworkDnsMocks(cmd, Network.GuestType.Isolated, false, false, true);

            
                    when(networkOfferingVO.getNetworkMode()).thenReturn(NetworkOffering.NetworkMode.ROUTED);

            
                    when(networkOfferingVO.getRoutingMode()).thenReturn(NetworkOffering.RoutingMode.Static);

            
                    when(routedIpv4Manager.isRoutedNetworkVpcEnabled(nullable(Long.class))).thenReturn(true);

            
                    when(routedIpv4Manager.isVirtualRouterGateway(networkOfferingVO)).thenReturn(true);

            
                    when(routedIpv4Manager.isDynamicRoutedNetwork(networkOfferingVO)).thenReturn(true);

            
                    doThrow(new InvalidParameterValueException("validation error")).when(routedIpv4Manager).validateBgpPeers(nullable(Account.class), nullable(Long.class), any(List.class));


                    DataCenterVO zone = Mockito.mock(DataCenterVO.class);

            
                    when(cmd.getZoneId()).thenReturn(zoneId);

            
                    when(_dcDao.findById(zoneId)).thenReturn(zone);

            
                    when(zone.getId()).thenReturn(zoneId);


                    try {

            
                        service.createGuestNetwork(cmd);

            
                    } catch (InsufficientCapacityException | ResourceAllocationException e) {

            
                        Assert.fail(String.format("failure with exception: %s", e.getMessage()));

            
                    } catch (InvalidParameterValueException ex) {

            
                        Assert.assertEquals("validation error", ex.getMessage());

            
                    }

            
                }


                @Test

            
                public void testCheckAndUpdateNetworkResetSuccess() {

            
                    NetworkVO networkVO = new NetworkVO();

            
                    networkVO.setVpcId(null);

            
                    networkVO.setDns1(ip4Dns[0]);

            
                    networkVO.setIp6Dns1(ip6Dns[0]);

            
                    try {

            
                        Field id = networkVO.getClass().getDeclaredField("guestType");

            
                        id.setAccessible(true);

            
                        id.set(networkVO, Network.GuestType.Shared);

            
                    } catch (NoSuchFieldException | IllegalAccessException e) {

            
                        Assert.fail(String.format("Unable to set network guestType, %s", e.getMessage()));

            
                    }

            
                    networkVO.setIp6Cidr("cidr");

            
                    NetworkOffering offering = Mockito.mock(NetworkOffering.class);

            
                    boolean updated = service.checkAndUpdateNetworkDns(networkVO, offering, "", null, "", null);

            
                    Assert.assertTrue(updated);

            
                    Assert.assertNull(networkVO.getDns1());

            
                    Assert.assertNull(networkVO.getDns2());

            
                    Assert.assertNull(networkVO.getIp6Dns1());

            
                    Assert.assertNull(networkVO.getIp6Dns2());

            
                }

            
                @Test

            
                public void validateIfServiceOfferingIsActiveAndSystemVmTypeIsDomainRouterTestMustThrowInvalidParameterValueExceptionWhenServiceOfferingIsNull() {

            
                    doReturn(null).when(serviceOfferingDaoMock).findById(anyLong());


                    String expectedMessage = String.format("Could not find specified service offering [%s].", 1l);

            
                    InvalidParameterValueException assertThrows = Assert.assertThrows(expectedException, () -> {

            
                        service.validateIfServiceOfferingIsActiveAndSystemVmTypeIsDomainRouter(1l);

            
                    });


                    Assert.assertEquals(expectedMessage, assertThrows.getMessage());

            
                }


                @Test

            
                public void validateIfServiceOfferingIsActiveAndSystemVmTypeIsDomainRouterTestMustThrowInvalidParameterValueExceptionWhenServiceOfferingStateIsInactive() {

            
                    doReturn(serviceOfferingVoMock).when(serviceOfferingDaoMock).findById(anyLong());

            
                    doReturn(ServiceOffering.State.Inactive).when(serviceOfferingVoMock).getState();


                    String expectedMessage = String.format("The specified service offering [%s] is inactive.", serviceOfferingVoMock);

            
                    InvalidParameterValueException assertThrows = Assert.assertThrows(expectedException, () -> {

            
                        service.validateIfServiceOfferingIsActiveAndSystemVmTypeIsDomainRouter(1l);

            
                    });


                    Assert.assertEquals(expectedMessage, assertThrows.getMessage());

            
                }


                @Test

            
                public void validateIfServiceOfferingIsActiveAndSystemVmTypeIsDomainRouterTestMustThrowInvalidParameterValueExceptionWhenSystemVmTypeIsNotDomainRouter() {

            
                    doReturn(serviceOfferingVoMock).when(serviceOfferingDaoMock).findById(anyLong());

            
                    doReturn(ServiceOffering.State.Active).when(serviceOfferingVoMock).getState();

            
                    doReturn(VirtualMachine.Type.ElasticLoadBalancerVm.toString()).when(serviceOfferingVoMock).getVmType();


                    String expectedMessage = String.format("The specified service offering [%s] is of type [%s]. Virtual routers can only be created with service offering of type [%s].",

            
                            serviceOfferingVoMock, serviceOfferingVoMock.getVmType(), VirtualMachine.Type.DomainRouter.toString().toLowerCase());

            
                    InvalidParameterValueException assertThrows = Assert.assertThrows(expectedException, () -> {

            
                        service.validateIfServiceOfferingIsActiveAndSystemVmTypeIsDomainRouter(1l);

            
                    });


                    Assert.assertEquals(expectedMessage, assertThrows.getMessage());

            
                }


                @Test

            
                public void validateIfServiceOfferingIsActiveAndSystemVmTypeIsDomainRouterTestMustNotThrowInvalidParameterValueExceptionWhenSystemVmTypeIsDomainRouter() {

            
                    NetworkServiceImpl networkServiceImplMock = mock(NetworkServiceImpl.class);


                    networkServiceImplMock.validateIfServiceOfferingIsActiveAndSystemVmTypeIsDomainRouter(1l);

            
                }


                @Test

            
                public void updatePublicIpAddressInQuarantineTestQuarantineIsAlreadyExpiredShouldThrowCloudRuntimeException() {

            
                    Mockito.when(updateQuarantinedIpCmdMock.getId()).thenReturn(publicIpId);

            
                    Mockito.when(updateQuarantinedIpCmdMock.getEndDate()).thenReturn(afterDate);

            
                    Mockito.when(publicIpQuarantineDaoMock.findById(Mockito.anyLong())).thenReturn(publicIpQuarantineVOMock);

            
                    Mockito.when(accountDaoMock.findById(Mockito.anyLong())).thenReturn(accountVOMock);

            
                    Mockito.when(domainDaoMock.findById(Mockito.anyLong())).thenReturn(domainVOMock);

            
                    Mockito.doNothing().when(accountManager).checkAccess(Mockito.any(Account.class), Mockito.any(Domain.class));

            
                    Mockito.when(ipAddressDao.findById(Mockito.anyLong())).thenReturn(ipAddressVOMock);

            
                    Mockito.when(ipAddressVOMock.getAddress()).thenReturn(ipMock);

            
                    Mockito.when(ipMock.toString()).thenReturn(dummyIpAddress);

            
                    Mockito.when(publicIpQuarantineVOMock.getEndDate()).thenReturn(beforeDate);

            
                    String expectedMessage = String.format("The quarantine for the public IP address [%s] is no longer active; thus, it cannot be updated.", dummyIpAddress);

            
                    CloudRuntimeException assertThrows = Assert.assertThrows(CloudRuntimeException.class,

            
                            () -> service.updatePublicIpAddressInQuarantine(updateQuarantinedIpCmdMock));


                    Assert.assertEquals(expectedMessage, assertThrows.getMessage());

            
                }


                @Test

            
                public void updatePublicIpAddressInQuarantineTestGivenEndDateIsBeforeCurrentDateShouldThrowInvalidParameterValueException() {

            
                    Mockito.when(updateQuarantinedIpCmdMock.getId()).thenReturn(publicIpId);

            
                    Mockito.when(updateQuarantinedIpCmdMock.getEndDate()).thenReturn(beforeDate);


                    String expectedMessage = String.format("The given end date [%s] is invalid as it is before the current date.", beforeDate);

            
                    InvalidParameterValueException assertThrows = Assert.assertThrows(InvalidParameterValueException.class,

            
                            () -> service.updatePublicIpAddressInQuarantine(updateQuarantinedIpCmdMock));


                    Assert.assertEquals(expectedMessage, assertThrows.getMessage());

            
                }


                @Test

            
                public void updatePublicIpAddressInQuarantineTestQuarantineIsStillValidAndGivenEndDateIsAfterCurrentDateShouldWork() {

            
                    Calendar calendar = Calendar.getInstance();

            
                    calendar.setTime(afterDate);

            
                    calendar.add(Calendar.DATE, 5);

            
                    Date expectedNewEndDate = calendar.getTime();


                    Mockito.when(updateQuarantinedIpCmdMock.getId()).thenReturn(publicIpId);

            
                    Mockito.when(updateQuarantinedIpCmdMock.getEndDate()).thenReturn(expectedNewEndDate);

            
                    Mockito.when(publicIpQuarantineDaoMock.findById(Mockito.anyLong())).thenReturn(publicIpQuarantineVOMock);

            
                    Mockito.when(accountDaoMock.findById(Mockito.anyLong())).thenReturn(accountVOMock);

            
                    Mockito.when(domainDaoMock.findById(Mockito.anyLong())).thenReturn(domainVOMock);

            
                    Mockito.doNothing().when(accountManager).checkAccess(Mockito.any(Account.class), Mockito.any(Domain.class));

            
                    Mockito.when(ipAddressDao.findById(Mockito.anyLong())).thenReturn(ipAddressVOMock);

            
                    Mockito.when(ipAddressDao.findById(Mockito.anyLong())).thenReturn(ipAddressVOMock);

            
                    Mockito.when(ipAddressVOMock.getAddress()).thenReturn(ipMock);

            
                    Mockito.when(ipMock.toString()).thenReturn(dummyIpAddress);

            
                    Mockito.when(publicIpQuarantineVOMock.getEndDate()).thenReturn(afterDate);

            
                    Mockito.when(ipAddressManagerMock.updatePublicIpAddressInQuarantine(anyLong(), Mockito.any(Date.class))).thenReturn(publicIpQuarantineVOMock);


                    PublicIpQuarantine actualPublicIpQuarantine = service.updatePublicIpAddressInQuarantine(updateQuarantinedIpCmdMock);

            
                    Mockito.when(actualPublicIpQuarantine.getEndDate()).thenReturn(expectedNewEndDate);


                    Assert.assertEquals(expectedNewEndDate , actualPublicIpQuarantine.getEndDate());

            
                }


                @Test(expected = CloudRuntimeException.class)

            
                public void retrievePublicIpQuarantineTestIpIdNullAndIpAddressNullShouldThrowException() {

            
                    service.retrievePublicIpQuarantine(null, null);

            
                }


                @Test

            
                public void retrievePublicIpQuarantineTestValidIpIdShouldReturnPublicQuarantine() {

            
                    Mockito.when(publicIpQuarantineDaoMock.findById(Mockito.anyLong())).thenReturn(publicIpQuarantineVOMock);


                    service.retrievePublicIpQuarantine(1L, null);

            
                    Mockito.verify(publicIpQuarantineDaoMock, Mockito.times(1)).findById(Mockito.anyLong());

            
                    Mockito.verify(publicIpQuarantineDaoMock, Mockito.times(0)).findByIpAddress(Mockito.anyString());

            
                }


                @Test(expected = CloudRuntimeException.class)

            
                public void retrievePublicIpQuarantineTestInvalidIpIdShouldThrowException() {

            
                    Mockito.when(publicIpQuarantineDaoMock.findById(Mockito.anyLong())).thenReturn(null);


                    service.retrievePublicIpQuarantine(1L, null);

            
                    Mockito.verify(publicIpQuarantineDaoMock, Mockito.times(1)).findById(Mockito.anyLong());

            
                    Mockito.verify(publicIpQuarantineDaoMock, Mockito.times(0)).findByIpAddress(Mockito.anyString());

            
                }


                @Test

            
                public void retrievePublicIpQuarantineTestValidIpAddressShouldReturnPublicQuarantine() {

            
                    Mockito.when(publicIpQuarantineDaoMock.findByIpAddress(Mockito.anyString())).thenReturn(publicIpQuarantineVOMock);


                    service.retrievePublicIpQuarantine(null, "10.1.1.1");

            
                    Mockito.verify(publicIpQuarantineDaoMock, Mockito.times(0)).findById(Mockito.anyLong());

            
                    Mockito.verify(publicIpQuarantineDaoMock, Mockito.times(1)).findByIpAddress(Mockito.anyString());

            
                }


                @Test(expected = CloudRuntimeException.class)

            
                public void retrievePublicIpQuarantineTestInvalidIpAddressShouldThrowException() {

            
                    Mockito.when(publicIpQuarantineDaoMock.findByIpAddress(Mockito.anyString())).thenReturn(null);


                    service.retrievePublicIpQuarantine(null, "10.1.1.1");

            
                    Mockito.verify(publicIpQuarantineDaoMock, Mockito.times(0)).findById(Mockito.anyLong());

            
                    Mockito.verify(publicIpQuarantineDaoMock, Mockito.times(1)).findByIpAddress(Mockito.anyString());

            
                }


                @Test

            
                public void retrievePublicIpQuarantineTestIpIdAndAddressInformedShouldUseId() {

            
                    Mockito.when(publicIpQuarantineDaoMock.findById(Mockito.anyLong())).thenReturn(publicIpQuarantineVOMock);


                    service.retrievePublicIpQuarantine(1L, "10.1.1.1");

            
                    Mockito.verify(publicIpQuarantineDaoMock, Mockito.times(1)).findById(Mockito.anyLong());

            
                    Mockito.verify(publicIpQuarantineDaoMock, Mockito.times(0)).findByIpAddress(Mockito.anyString());

            
                }


                @Test

            
                public void validateNotSharedNetworkRouterIPv4() {

            
                    NetworkOffering ntwkOff = Mockito.mock(NetworkOffering.class);

            
                    when(ntwkOff.getGuestType()).thenReturn(Network.GuestType.L2);

            
                    service.validateSharedNetworkRouterIPs(null, null, null, null, null, null, null, null, null, ntwkOff);

            
                }


                @Test

            
                public void validateSharedNetworkRouterIPs() {

            
                    String startIP = "10.0.16.2";

            
                    String endIP = "10.0.16.100";

            
                    String routerIPv4 = "10.0.16.100";

            
                    String routerPv6 = "fd17:ac56:1234:2000::fb";

            
                    String startIPv6 = "fd17:ac56:1234:2000::1";

            
                    String endIPv6 = "fd17:ac56:1234:2000::fc";

            
                    NetworkOffering ntwkOff = Mockito.mock(NetworkOffering.class);

            
                    when(ntwkOff.getGuestType()).thenReturn(Network.GuestType.Shared);

            
                    service.validateSharedNetworkRouterIPs(IP4_GATEWAY, startIP, endIP, IP4_NETMASK, routerIPv4, routerPv6, startIPv6, endIPv6, IP6_CIDR, ntwkOff);

            
                }


                @Test

            
                public void validateSharedNetworkWrongRouterIPv4() {

            
                    String startIP = "10.0.16.2";

            
                    String endIP = "10.0.16.100";

            
                    String routerIPv4 = "10.0.16.101";

            
                    String routerPv6 = "fd17:ac56:1234:2000::fb";

            
                    String startIPv6 = "fd17:ac56:1234:2000::1";

            
                    String endIPv6 = "fd17:ac56:1234:2000::fc";

            
                    NetworkOffering ntwkOff = Mockito.mock(NetworkOffering.class);

            
                    when(ntwkOff.getGuestType()).thenReturn(Network.GuestType.Shared);

            
                    boolean passing = false;

            
                    try {

            
                        service.validateSharedNetworkRouterIPs(IP4_GATEWAY, startIP, endIP, IP4_NETMASK, routerIPv4, routerPv6, startIPv6, endIPv6, IP6_CIDR, ntwkOff);

            
                    } catch (CloudRuntimeException e) {

            
                        Assert.assertTrue(e.getMessage().contains("Router IPv4 IP provided is not within the specified range: "));

            
                        passing = true;

            
                    }

            
                    Assert.assertTrue(passing);

            
                }


                @Test

            
                public void validateSharedNetworkNoEndOfIPv6Range() {

            
                    String startIP = null;

            
                    String endIP = null;

            
                    String routerIPv4 = null;

            
                    String routerPv6 = "fd17:ac56:1234:2000::1";

            
                    String startIPv6 = "fd17:ac56:1234:2000::1";

            
                    String endIPv6 = null;

            
                    NetworkOffering ntwkOff = Mockito.mock(NetworkOffering.class);

            
                    when(ntwkOff.getGuestType()).thenReturn(Network.GuestType.Shared);

            
                    service.validateSharedNetworkRouterIPs(IP4_GATEWAY, startIP, endIP, IP4_NETMASK, routerIPv4, routerPv6, startIPv6, endIPv6, IP6_CIDR, ntwkOff);

            
                }


                @Test

            
                public void validateSharedNetworkIPv6RouterNotInRange() {

            
                    String routerIPv4 = null;

            
                    String routerIPv6 = "fd17:ac56:1234:2001::1";

            
                    NetworkOffering ntwkOff = Mockito.mock(NetworkOffering.class);

            
                    when(ntwkOff.getGuestType()).thenReturn(Network.GuestType.Shared);

            
                    boolean passing = true;

            
                    try {

            
                        service.validateSharedNetworkRouterIPs(IP4_GATEWAY, null, null, IP4_NETMASK, routerIPv4, routerIPv6, null, null, IP6_CIDR, ntwkOff);

            
                        passing = false;

            
                    } catch (CloudRuntimeException e) {

            
                        Assert.assertTrue(e.getMessage().contains("Router IPv6 address provided is not with the network range"));

            
                    }

            
                    Assert.assertTrue(passing);

            
                }


                @Test

            
                public void invalidateSharedNetworkIPv6RouterAddress() {

            
                    String routerIPv6 = "fd17:ac56:1234:2000::fg";

            
                    NetworkOffering ntwkOff = Mockito.mock(NetworkOffering.class);

            
                    when(ntwkOff.getGuestType()).thenReturn(Network.GuestType.Shared);

            
                    boolean passing = false;

            
                    try {

            
                        service.validateSharedNetworkRouterIPs(IP4_GATEWAY, null, null, IP4_NETMASK, null, routerIPv6, null, null, IP6_CIDR, ntwkOff);

            
                    } catch (CloudRuntimeException e) {

            
                        Assert.assertTrue(e.getMessage().contains("Router IPv6 address provided is of incorrect format"));

            
                        passing = true;

            
                    }

            
                    Assert.assertTrue(passing);

            
                }


                @Test

            
                public void invalidateSharedNetworkIPv4RouterAddress() {

            
                    String routerIPv4 = "10.100.1000.1";

            
                    NetworkOffering ntwkOff = Mockito.mock(NetworkOffering.class);

            
                    when(ntwkOff.getGuestType()).thenReturn(Network.GuestType.Shared);

            
                    boolean passing = false;

            
                    try {

            
                        service.validateSharedNetworkRouterIPs(IP4_GATEWAY, null, null, IP4_NETMASK, routerIPv4, null, null, null, IP6_CIDR, ntwkOff);

            
                    } catch (CloudRuntimeException e) {

            
                        Assert.assertTrue(e.getMessage().contains("Router IPv4 IP provided is of incorrect format"));

            
                        passing = true;

            
                    }

            
                    Assert.assertTrue(passing);

            
                }


                @Test

            
                public void checkAndDontSetSourceNatIp() {

            
                    CreateNetworkCmd cmd = new CreateNetworkCmd();

            
                    try {

            
                        service.checkAndSetRouterSourceNatIp(account, cmd, null);

            
                    } catch (InsufficientAddressCapacityException | ResourceAllocationException e) {

            
                        Assert.fail(e.getMessage());

            
                    }

            
                }


                @Test

            
                public void checkAndSetSourceNatIp() {

            
                    String srcNatIp = "10.100.1000.10000";

            
                    Long networkOfferingId = 2l;

            
                    Long zoneId = 3l;

            
                    registerCallContext();

            
                    ReflectionTestUtils.setField(createNetworkCmd, "networkOfferingId", networkOfferingId);

            
                    ReflectionTestUtils.setField(createNetworkCmd, "sourceNatIP", srcNatIp);

            
                    ReflectionTestUtils.setField(createNetworkCmd, "zoneId", zoneId);

            
                    ReflectionTestUtils.setField(createNetworkCmd, "physicalNetworkId", null);

            
                    NetworkVO networkVO = Mockito.spy(NetworkVO.class);

            
                    IpAddress ipAddress = Mockito.mock(IPAddressVO.class);

            
                    NetworkOffering ntwkOff = Mockito.mock(NetworkOffering.class);

            
                    Long networkId = 7l;

            
                    when(networkVO.getId()).thenReturn(networkId);

            
                    when(networkVO.getGuestType()).thenReturn(Network.GuestType.Isolated);

            
                    when(networkDao.findById(networkId)).thenReturn(networkVO);

            
                    when(entityMgr.findById(NetworkOffering.class, networkOfferingId)).thenReturn(ntwkOff);

            
                    when(entityMgr.findById(eq(DataCenter.class), anyLong())).thenReturn(dc);

            
                    when(ipAddress.getId()).thenReturn(5l);

            
                    when(networkVO.getId()).thenReturn(networkId);

            
                    when(networkVO.getGuestType()).thenReturn(Network.GuestType.Isolated);

            
                    try {

            
                        when(ipAddressManagerMock.allocateIp(any(), anyBoolean(), any(), any(), any(), any(), eq(srcNatIp))).thenReturn(ipAddress);

            
                        service.checkAndSetRouterSourceNatIp(account, createNetworkCmd, networkVO);

            
                    } catch (InsufficientAddressCapacityException | ResourceAllocationException e) {

            
                        Assert.fail(e.getMessage());

            
                    }

            
                }


                @Test

            
                public void testGetNicVlanValueForExternalVm_NonNsx() {

            
                    NicTO nic = mock(NicTO.class);

            
                    String broadcastUri = "vlan://123";

            
                    when(nic.getBroadcastUri()).thenReturn(URI.create(broadcastUri));

            
                    String result = service.getNicVlanValueForExternalVm(nic);

            
                    assertEquals("123", result);

            
                }


                @Test

            
                public void testGetNicVlanValueForExternalVm_Nsx() {

            
                    NicTO nic = mock(NicTO.class);

            
                    NetworkVO networkVO = mock(NetworkVO.class);

            
                    NsxService nsxService = mock(NsxService.class);

            
                    String broadcastUri = "nsx://segment";

            
                    when(nic.getBroadcastUri()).thenReturn(URI.create(broadcastUri));

            
                    when(nic.getNetworkId()).thenReturn(42L);

            
                    when(networkDao.findById(42L)).thenReturn(networkVO);

            
                    when(networkVO.getDomainId()).thenReturn(1L);

            
                    when(networkVO.getDataCenterId()).thenReturn(2L);

            
                    when(networkVO.getAccountId()).thenReturn(3L);

            
                    when(networkVO.getVpcId()).thenReturn(4L);

            
                    when(networkVO.getId()).thenReturn(5L);

            
                    when(nsxService.getSegmentId(1L, 2L, 3L, 4L, 5L)).thenReturn("segment-123");

            
                    try (MockedStatic<ComponentContext> ignored = Mockito.mockStatic(ComponentContext.class)) {

            
                        when(ComponentContext.getDelegateComponentOfType(NsxService.class)).thenReturn(nsxService);

            
                        String result = service.getNicVlanValueForExternalVm(nic);

            
                        assertEquals("segment-123", result);

            
                    }

            
                }


                @Test(expected = CloudRuntimeException.class)

            
                public void testGetNicVlanValueForExternalVm_Nsx_NoBean() {

            
                    NicTO nic = mock(NicTO.class);

            
                    NetworkVO networkVO = mock(NetworkVO.class);

            
                    String broadcastUri = "nsx://segment";

            
                    when(nic.getBroadcastUri()).thenReturn(URI.create(broadcastUri));

            
                    when(nic.getNetworkId()).thenReturn(42L);

            
                    when(networkDao.findById(42L)).thenReturn(networkVO);

            
                    try (MockedStatic<ComponentContext> ignored = Mockito.mockStatic(ComponentContext.class)) {

            
                        when(ComponentContext.getDelegateComponentOfType(NsxService.class)).thenThrow(NoSuchBeanDefinitionException.class);

            
                        service.getNicVlanValueForExternalVm(nic);

            
                    }

            
                }


                @Test

            
                public void testGetIpAddressesFromIps() {

            
                    // Test with valid IPv4, IPv6 and MAC address

            
                    Network.IpAddresses result = service.getIpAddressesFromIps("192.168.1.1", "2001:db8::1", "00:11:22:33:44:55");

            
                    Assert.assertEquals("192.168.1.1", result.getIp4Address());

            
                    Assert.assertEquals("2001:db8::1", result.getIp6Address());

            
                    Assert.assertEquals("00:11:22:33:44:55", result.getMacAddress());


                    // Test with all null values

            
                    result = service.getIpAddressesFromIps(null, null, null);

            
                    Assert.assertNull(result.getIp4Address());

            
                    Assert.assertNull(result.getIp6Address());

            
                    Assert.assertNull(result.getMacAddress());


                    // Test with invalid MAC address (non-unicast)

            
                    try {

            
                        service.getIpAddressesFromIps(null, null, "ff:ff:ff:ff:ff:ff");

            
                        Assert.fail("Expected InvalidParameterValueException for non-unicast MAC address");

            
                    } catch (InvalidParameterValueException e) {

            
                        Assert.assertEquals("Mac address is not unicast: ff:ff:ff:ff:ff:ff", e.getMessage());

            
                    }


                    // Test with invalid MAC address (invalid format)

            
                    try {

            
                        service.getIpAddressesFromIps(null, null, "invalid-mac");

            
                        Assert.fail("Expected InvalidParameterValueException for invalid MAC address format");

            
                    } catch (InvalidParameterValueException e) {

            
                        Assert.assertEquals("Mac address is not valid: invalid-mac", e.getMessage());

            
                    }

            
                }


                @Test

            
                public void addProjectNetworksConditionToSearch_includesProjectNetworksWhenNotSkipped() {

            
                    SearchCriteria<NetworkVO> sc = Mockito.mock(SearchCriteria.class);

            
                    SearchCriteria accountJoin = Mockito.mock(SearchCriteria.class);

            
                    Mockito.when(sc.getJoin("account")).thenReturn(accountJoin);

            
                    service.addProjectNetworksConditionToSearch(sc, false, -1L);

            
                    Mockito.verify(accountJoin).addAnd("type", SearchCriteria.Op.NNULL);

            
                    Mockito.verify(sc).addAnd("id", SearchCriteria.Op.SC, accountJoin);

            
                }


                @Test

            
                public void addProjectNetworksConditionToSearch_excludesProjectNetworksWhenSkipped() {

            
                    SearchCriteria<NetworkVO> sc = Mockito.mock(SearchCriteria.class);

            
                    SearchCriteria accountJoin = Mockito.mock(SearchCriteria.class);

            
                    Mockito.when(sc.getJoin("account")).thenReturn(accountJoin);

            
                    service.addProjectNetworksConditionToSearch(sc, true, -1L);

            
                    Mockito.verify(accountJoin).addAnd("type", SearchCriteria.Op.NEQ, Account.Type.PROJECT);

            
                    Mockito.verify(sc).addAnd("id", SearchCriteria.Op.SC, accountJoin);

            
                }


                @Test

            
                public void addProjectNetworksConditionToSearch_includesSpecificProjectWhenProjectIdProvided() {

            
                    SearchCriteria<NetworkVO> sc = Mockito.mock(SearchCriteria.class);

            
                    SearchCriteria accountJoin = Mockito.mock(SearchCriteria.class);

            
                    Mockito.when(sc.getJoin("account")).thenReturn(accountJoin);

            
                    service.addProjectNetworksConditionToSearch(sc, false, 123L);

            
                    Mockito.verify(accountJoin).addAnd("type", SearchCriteria.Op.EQ, Account.Type.PROJECT);

            
                    Mockito.verify(sc).addAnd("id", SearchCriteria.Op.SC, accountJoin);

            
                }


                @Test(expected = InvalidParameterValueException.class)

            
                public void getAndValidateSupportForKeepMacAddressOnPublicNicParameterTestThrowExceptionWhenParamIsSpecifiedOnTiersCreation() {

            
                    networkOfferingVO = Mockito.mock(NetworkOfferingVO.class);

            
                    Mockito.when(networkOfferingVO.isForVpc()).thenReturn(true);


                    service.getAndValidateSupportForKeepMacAddressOnPublicNicParameter(true, networkOfferingVO);

            
                }


                @Test

            
                public void getAndValidateSupportForKeepMacAddressOnPublicNicParameterTestReturnTrueByDefaultOnTiersCreation() {

            
                    networkOfferingVO = Mockito.mock(NetworkOfferingVO.class);

            
                    Mockito.when(networkOfferingVO.isForVpc()).thenReturn(true);


                    Assert.assertTrue(service.getAndValidateSupportForKeepMacAddressOnPublicNicParameter(null, networkOfferingVO));

            
                }


                @Test(expected = InvalidParameterValueException.class)

            
                public void getAndValidateSupportForKeepMacAddressOnPublicNicParameterTestThrowExceptionWhenParamIsSpecifiedOnNonIsolatedNetworksCreation() {

            
                    networkOfferingVO = Mockito.mock(NetworkOfferingVO.class);

            
                    Mockito.when(networkOfferingVO.getGuestType()).thenReturn(Network.GuestType.Shared);


                    service.getAndValidateSupportForKeepMacAddressOnPublicNicParameter(true, networkOfferingVO);

            
                }


                @Test

            
                public void getAndValidateSupportForKeepMacAddressOnPublicNicParameterTestReturnTrueByDefaultOnNonIsolatedNetworksCreation() {

            
                    networkOfferingVO = Mockito.mock(NetworkOfferingVO.class);

            
                    Mockito.when(networkOfferingVO.getGuestType()).thenReturn(Network.GuestType.L2);


                    Assert.assertTrue(service.getAndValidateSupportForKeepMacAddressOnPublicNicParameter(null, networkOfferingVO));

            
                }


                @Test

            
                public void getAndValidateSupportForKeepMacAddressOnPublicNicParameterTestReturnTrueByDefaultOnIsolatedNetworksCreation() {

            
                    networkOfferingVO = Mockito.mock(NetworkOfferingVO.class);

            
                    Mockito.when(networkOfferingVO.getGuestType()).thenReturn(Network.GuestType.Isolated);


                    Assert.assertTrue(service.getAndValidateSupportForKeepMacAddressOnPublicNicParameter(null, networkOfferingVO));

            
                }


                @Test

            
                public void getAndValidateSupportForKeepMacAddressOnPublicNicParameterTestReturnSpecifiedValueOnIsolatedNetworksCreation() {

            
                    networkOfferingVO = Mockito.mock(NetworkOfferingVO.class);

            
                    Mockito.when(networkOfferingVO.getGuestType()).thenReturn(Network.GuestType.Isolated);


                    Assert.assertFalse(service.getAndValidateSupportForKeepMacAddressOnPublicNicParameter(false, networkOfferingVO));

            
                }


                private NicVO mockNic(long nicId, long instanceId, long networkId, boolean multiNetwork) {

            
                    NicVO nic = Mockito.mock(NicVO.class);

            
                    Mockito.when(nic.getId()).thenReturn(nicId);

            
                    Mockito.when(nic.getInstanceId()).thenReturn(instanceId);

            
                    Mockito.when(nic.getNetworkId()).thenReturn(networkId);

            
                    Mockito.when(nic.getVmType()).thenReturn(VirtualMachine.Type.User);

            
                    Mockito.when(nic.getUuid()).thenReturn("nic-uuid");

            
                    Mockito.when(nic.getMultiNetwork()).thenReturn(multiNetwork);

            
                    return nic;

            
                }


                private NetworkVO mockNetwork(long networkId, Network.GuestType guestType, long physicalNetworkId, long dataCenterId, Long vpcId,

            
                        Networks.BroadcastDomainType broadcastType, URI broadcastUri) {

            
                    NetworkVO network = Mockito.mock(NetworkVO.class);

            
                    Mockito.when(network.getId()).thenReturn(networkId);

            
                    Mockito.when(network.getUuid()).thenReturn("network-uuid-" + networkId);

            
                    Mockito.when(network.getGuestType()).thenReturn(guestType);

            
                    Mockito.when(network.getPhysicalNetworkId()).thenReturn(physicalNetworkId);

            
                    Mockito.when(network.getDataCenterId()).thenReturn(dataCenterId);

            
                    Mockito.lenient().when(network.getVpcId()).thenReturn(vpcId);

            
                    Mockito.when(network.getBroadcastDomainType()).thenReturn(broadcastType);

            
                    Mockito.when(network.getBroadcastUri()).thenReturn(broadcastUri);

            
                    Mockito.when(network.getState()).thenReturn(Network.State.Implemented);

            
                    return network;

            
                }


                private UserVmVO mockVm(VirtualMachine.State state, Long hostId) {

            
                    UserVmVO vm = Mockito.mock(UserVmVO.class);

            
                    Mockito.when(vm.getState()).thenReturn(state);

            
                    Mockito.when(vm.getHostId()).thenReturn(hostId);

            
                    return vm;

            
                }


                private AssociateNetworkToNicCmd mockAssociateCmd(long nicId, List<Long> networkIds) {

            
                    AssociateNetworkToNicCmd cmd = Mockito.mock(AssociateNetworkToNicCmd.class);

            
                    Mockito.when(cmd.getNicId()).thenReturn(nicId);

            
                    Mockito.when(cmd.getNetworkIds()).thenReturn(networkIds);

            
                    Mockito.when(cmd.getIpAddressesMap()).thenReturn(new HashMap<>());

            
                    return cmd;

            
                }


                @Test(expected = InvalidParameterValueException.class)

            
                public void associateNetworkToNicFailsWhenNicNotFound() throws Exception {

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(null);


                    service.associateNetworkToNic(mockAssociateCmd(11L, Arrays.asList(206L)));

            
                }


                @Test(expected = InvalidParameterValueException.class)

            
                public void associateNetworkToNicFailsWhenNicIsNotOnAUserVm() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nic.getVmType()).thenReturn(VirtualMachine.Type.DomainRouter);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);


                    service.associateNetworkToNic(mockAssociateCmd(11L, Arrays.asList(206L)));

            
                }


                @Test

            
                public void associateNetworkToNicFailsWhenFeatureDisabledInZone() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);


                    overrideDefaultConfigValue(NetworkOrchestrationService.MultiNetworkNicEnabled, "_defaultValue", "false");

            
                    try {

            
                        service.associateNetworkToNic(mockAssociateCmd(11L, Arrays.asList(206L)));

            
                        Assert.fail("expected InvalidParameterValueException");

            
                    } catch (InvalidParameterValueException e) {

            
                        Assert.assertTrue(e.getMessage().contains("not enabled"));

            
                    } finally {

            
                        overrideDefaultConfigValue(NetworkOrchestrationService.MultiNetworkNicEnabled, "_defaultValue", "true");

            
                    }

            
                }


                @Test(expected = InvalidParameterValueException.class)

            
                public void associateNetworkToNicFailsWhenOwningVmNotFound() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(null);


                    service.associateNetworkToNic(mockAssociateCmd(11L, Arrays.asList(206L)));

            
                }


                @Test(expected = InvalidParameterValueException.class)

            
                public void associateNetworkToNicFailsWhenRunningVmHostIsNotVlanFilteringReady() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Running, 1L);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    Mockito.when(hostDetailsDao.findDetail(1L, Host.HOST_VLAN_FILTERING_ENABLED)).thenReturn(null);


                    service.associateNetworkToNic(mockAssociateCmd(11L, Arrays.asList(206L)));

            
                }


                @Test

            
                public void associateNetworkToNicUpdatesLiveVlanMembershipOnARunningVmWhenHostIsReady() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Running, 1L);

            
                    Mockito.when(vm.getHypervisorType()).thenReturn(Hypervisor.HypervisorType.KVM);

            
                    Mockito.when(vm.getInstanceName()).thenReturn("i-2-11-VM");

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    DetailVO readyDetail = Mockito.mock(DetailVO.class);

            
                    Mockito.when(readyDetail.getValue()).thenReturn("true");

            
                    Mockito.when(hostDetailsDao.findDetail(1L, Host.HOST_VLAN_FILTERING_ENABLED)).thenReturn(readyDetail);

            
                    NetworkVO primaryNetwork = mockNetwork(205L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1174));

            
                    Mockito.when(networkDao.findById(205L)).thenReturn(primaryNetwork);

            
                    Mockito.when(nicNetworkMapDao.listByNicId(11L)).thenReturn(new ArrayList<>());

            
                    NetworkVO requestedNetwork = mockNetwork(206L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1180));

            
                    Mockito.when(networkDao.findById(206L)).thenReturn(requestedNetwork);

            
                    Mockito.when(ipAddressManagerMock.allocateGuestIP(requestedNetwork, null)).thenReturn("10.1.1.50");

            
                    Mockito.when(networkModel.getNicProfile(Mockito.eq(vm), Mockito.eq(nic), Mockito.any())).thenReturn(null);

            
                    Mockito.when(hvGuruMgr.getGuru(Hypervisor.HypervisorType.KVM)).thenReturn(hypervisorGuru);

            
                    Mockito.when(hypervisorGuru.toNicTO(null)).thenReturn(Mockito.mock(NicTO.class));

            
                    Mockito.when(agentMgr.easySend(Mockito.eq(1L), Mockito.any())).thenReturn(new UpdateNicVlanMembershipAnswer(null, true, "success"));

            
                    DomainRouterVO router = Mockito.mock(DomainRouterVO.class);

            
                    Mockito.when(router.getState()).thenReturn(VirtualMachine.State.Running);

            
                    Mockito.when(routerDao.findByNetwork(205L)).thenReturn(Arrays.asList(router));


                    Nic result = service.associateNetworkToNic(mockAssociateCmd(11L, Arrays.asList(206L)));


                    Assert.assertNotNull(result);

            
                    Mockito.verify(agentMgr).easySend(Mockito.eq(1L), Mockito.any());

            
                    Mockito.verify(commandSetupHelper).createVmDataCommand(Mockito.eq(router), Mockito.eq(vm), Mockito.eq(nic), Mockito.any(), Mockito.any());

            
                    Mockito.verify(networkHelper).sendCommandsToRouter(Mockito.eq(router), Mockito.any());

            
                }


                @Test

            
                public void associateNetworkToNicPushesDhcpEntryForNewlyAssociatedNetworkOnARunningVm() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Running, 1L);

            
                    Mockito.when(vm.getHypervisorType()).thenReturn(Hypervisor.HypervisorType.KVM);

            
                    Mockito.when(vm.getInstanceName()).thenReturn("i-2-11-VM");

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    DetailVO readyDetail = Mockito.mock(DetailVO.class);

            
                    Mockito.when(readyDetail.getValue()).thenReturn("true");

            
                    Mockito.when(hostDetailsDao.findDetail(1L, Host.HOST_VLAN_FILTERING_ENABLED)).thenReturn(readyDetail);

            
                    NetworkVO primaryNetwork = mockNetwork(205L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1174));

            
                    Mockito.when(networkDao.findById(205L)).thenReturn(primaryNetwork);

            
                    Mockito.when(nicNetworkMapDao.listByNicId(11L)).thenReturn(new ArrayList<>());

            
                    NetworkVO requestedNetwork = mockNetwork(206L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1180));

            
                    Mockito.when(networkDao.findById(206L)).thenReturn(requestedNetwork);

            
                    Mockito.when(ipAddressManagerMock.allocateGuestIP(requestedNetwork, null)).thenReturn("10.1.1.50");

            
                    Mockito.when(nicNetworkMapDao.findByNicIdAndNetworkId(11L, 206L)).thenReturn(new NicNetworkMapVO(11L, 206L, "10.1.1.50", null));

            
                    Mockito.when(networkModel.getNicProfile(Mockito.eq(vm), Mockito.eq(nic), Mockito.any())).thenReturn(null);

            
                    Mockito.when(hvGuruMgr.getGuru(Hypervisor.HypervisorType.KVM)).thenReturn(hypervisorGuru);

            
                    Mockito.when(hypervisorGuru.toNicTO(null)).thenReturn(Mockito.mock(NicTO.class));

            
                    Mockito.when(agentMgr.easySend(Mockito.eq(1L), Mockito.any())).thenReturn(new UpdateNicVlanMembershipAnswer(null, true, "success"));

            
                    Mockito.when(routerDao.findByNetwork(205L)).thenReturn(new ArrayList<>());

            
                    DomainRouterVO associatedNetworkRouter = Mockito.mock(DomainRouterVO.class);

            
                    Mockito.when(associatedNetworkRouter.getState()).thenReturn(VirtualMachine.State.Running);

            
                    Mockito.when(routerDao.findByNetwork(206L)).thenReturn(Arrays.asList(associatedNetworkRouter));


                    service.associateNetworkToNic(mockAssociateCmd(11L, Arrays.asList(206L)));


                    Mockito.verify(commandSetupHelper).createDhcpEntryCommand(Mockito.eq(associatedNetworkRouter), Mockito.eq(vm), Mockito.any(), Mockito.eq("10.1.1.50"),

            
                            Mockito.any(), Mockito.any(), Mockito.any(), Mockito.eq(206L), Mockito.eq(false), Mockito.eq(false), Mockito.any());

            
                    Mockito.verify(networkHelper).sendCommandsToRouter(Mockito.eq(associatedNetworkRouter), Mockito.any());

            
                }


                @Test

            
                public void associateNetworkToNicDoesNotPushDhcpEntryOnAStoppedVm() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    NetworkVO primaryNetwork = mockNetwork(205L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1174));

            
                    Mockito.when(networkDao.findById(205L)).thenReturn(primaryNetwork);

            
                    Mockito.when(nicNetworkMapDao.listByNicId(11L)).thenReturn(new ArrayList<>());

            
                    NetworkVO requestedNetwork = mockNetwork(206L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1180));

            
                    Mockito.when(networkDao.findById(206L)).thenReturn(requestedNetwork);

            
                    Mockito.when(ipAddressManagerMock.allocateGuestIP(requestedNetwork, null)).thenReturn("10.1.1.50");


                    service.associateNetworkToNic(mockAssociateCmd(11L, Arrays.asList(206L)));


                    Mockito.verify(commandSetupHelper, Mockito.never()).createDhcpEntryCommand(Mockito.any(), Mockito.any(), Mockito.anyString(), Mockito.anyString(),

            
                            Mockito.any(), Mockito.any(), Mockito.any(), Mockito.anyLong(), Mockito.anyBoolean(), Mockito.anyBoolean(), Mockito.any());

            
                }


                @Test

            
                public void associateNetworkToNicDoesNotRefreshMetadataOnRoutersThatAreNotRunning() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Running, 1L);

            
                    Mockito.when(vm.getHypervisorType()).thenReturn(Hypervisor.HypervisorType.KVM);

            
                    Mockito.when(vm.getInstanceName()).thenReturn("i-2-11-VM");

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    DetailVO readyDetail = Mockito.mock(DetailVO.class);

            
                    Mockito.when(readyDetail.getValue()).thenReturn("true");

            
                    Mockito.when(hostDetailsDao.findDetail(1L, Host.HOST_VLAN_FILTERING_ENABLED)).thenReturn(readyDetail);

            
                    NetworkVO primaryNetwork = mockNetwork(205L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1174));

            
                    Mockito.when(networkDao.findById(205L)).thenReturn(primaryNetwork);

            
                    Mockito.when(nicNetworkMapDao.listByNicId(11L)).thenReturn(new ArrayList<>());

            
                    NetworkVO requestedNetwork = mockNetwork(206L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1180));

            
                    Mockito.when(networkDao.findById(206L)).thenReturn(requestedNetwork);

            
                    Mockito.when(ipAddressManagerMock.allocateGuestIP(requestedNetwork, null)).thenReturn("10.1.1.50");

            
                    Mockito.when(networkModel.getNicProfile(Mockito.eq(vm), Mockito.eq(nic), Mockito.any())).thenReturn(null);

            
                    Mockito.when(hvGuruMgr.getGuru(Hypervisor.HypervisorType.KVM)).thenReturn(hypervisorGuru);

            
                    Mockito.when(hypervisorGuru.toNicTO(null)).thenReturn(Mockito.mock(NicTO.class));

            
                    Mockito.when(agentMgr.easySend(Mockito.eq(1L), Mockito.any())).thenReturn(new UpdateNicVlanMembershipAnswer(null, true, "success"));

            
                    DomainRouterVO stoppedRouter = Mockito.mock(DomainRouterVO.class);

            
                    Mockito.when(stoppedRouter.getState()).thenReturn(VirtualMachine.State.Stopped);

            
                    Mockito.when(routerDao.findByNetwork(205L)).thenReturn(Arrays.asList(stoppedRouter));


                    service.associateNetworkToNic(mockAssociateCmd(11L, Arrays.asList(206L)));


                    Mockito.verify(commandSetupHelper, Mockito.never()).createVmDataCommand(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());

            
                }


                @Test(expected = CloudRuntimeException.class)

            
                public void associateNetworkToNicFailsWhenLiveUpdateCommandFails() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Running, 1L);

            
                    Mockito.when(vm.getHypervisorType()).thenReturn(Hypervisor.HypervisorType.KVM);

            
                    Mockito.when(vm.getInstanceName()).thenReturn("i-2-11-VM");

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    DetailVO readyDetail = Mockito.mock(DetailVO.class);

            
                    Mockito.when(readyDetail.getValue()).thenReturn("true");

            
                    Mockito.when(hostDetailsDao.findDetail(1L, Host.HOST_VLAN_FILTERING_ENABLED)).thenReturn(readyDetail);

            
                    NetworkVO primaryNetwork = mockNetwork(205L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1174));

            
                    Mockito.when(networkDao.findById(205L)).thenReturn(primaryNetwork);

            
                    Mockito.when(nicNetworkMapDao.listByNicId(11L)).thenReturn(new ArrayList<>());

            
                    NetworkVO requestedNetwork = mockNetwork(206L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1180));

            
                    Mockito.when(networkDao.findById(206L)).thenReturn(requestedNetwork);

            
                    Mockito.when(ipAddressManagerMock.allocateGuestIP(requestedNetwork, null)).thenReturn("10.1.1.50");

            
                    Mockito.when(networkModel.getNicProfile(Mockito.eq(vm), Mockito.eq(nic), Mockito.any())).thenReturn(null);

            
                    Mockito.when(hvGuruMgr.getGuru(Hypervisor.HypervisorType.KVM)).thenReturn(hypervisorGuru);

            
                    Mockito.when(hypervisorGuru.toNicTO(null)).thenReturn(Mockito.mock(NicTO.class));

            
                    Mockito.when(agentMgr.easySend(Mockito.eq(1L), Mockito.any())).thenReturn(new UpdateNicVlanMembershipAnswer(null, false, "boom"));


                    service.associateNetworkToNic(mockAssociateCmd(11L, Arrays.asList(206L)));

            
                }


                @Test(expected = PermissionDeniedException.class)

            
                public void associateNetworkToNicChecksAccessBeforeRevealingAlreadyAssociatedState() throws Exception {

            
                    // requesting the primary network again would normally fail with "already associated" -

            
                    // access must be checked first, so a caller without access gets PermissionDeniedException instead,

            
                    // never learning whether the network is already associated

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    NetworkVO primaryNetwork = mockNetwork(205L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1174));

            
                    Mockito.when(networkDao.findById(205L)).thenReturn(primaryNetwork);

            
                    Mockito.when(nicNetworkMapDao.listByNicId(11L)).thenReturn(new ArrayList<>());

            
                    Mockito.when(vm.getAccountId()).thenReturn(5L);

            
                    Mockito.when(accountManager.getAccount(5L)).thenReturn(accountMock);

            
                    Mockito.doThrow(new PermissionDeniedException("no access to network 205"))

            
                            .when(networkModel).checkNetworkPermissions(accountMock, primaryNetwork);


                    service.associateNetworkToNic(mockAssociateCmd(11L, Arrays.asList(205L)));

            
                }


                @Test(expected = InvalidParameterValueException.class)

            
                public void associateNetworkToNicFailsWhenAlreadyAssociatedWithPrimaryNetwork() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    NetworkVO primaryNetwork = mockNetwork(205L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1174));

            
                    Mockito.when(networkDao.findById(205L)).thenReturn(primaryNetwork);

            
                    Mockito.when(nicNetworkMapDao.listByNicId(11L)).thenReturn(new ArrayList<>());


                    service.associateNetworkToNic(mockAssociateCmd(11L, Arrays.asList(205L)));

            
                }


                @Test(expected = InvalidParameterValueException.class)

            
                public void associateNetworkToNicFailsWhenRequestedNetworkIsADifferentGuestType() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    NetworkVO primaryNetwork = mockNetwork(205L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1174));

            
                    Mockito.when(networkDao.findById(205L)).thenReturn(primaryNetwork);

            
                    Mockito.when(nicNetworkMapDao.listByNicId(11L)).thenReturn(new ArrayList<>());

            
                    NetworkVO sharedNetwork = mockNetwork(206L, Network.GuestType.Shared, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1180));

            
                    Mockito.when(networkDao.findById(206L)).thenReturn(sharedNetwork);


                    service.associateNetworkToNic(mockAssociateCmd(11L, Arrays.asList(206L)));

            
                }


                @Test(expected = InvalidParameterValueException.class)

            
                public void associateNetworkToNicFailsWhenRequestedNetworkCidrOverlapsPrimaryNetworkCidr() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    NetworkVO primaryNetwork = mockNetwork(205L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1174));

            
                    Mockito.when(primaryNetwork.getCidr()).thenReturn("10.1.1.0/24");

            
                    Mockito.when(networkDao.findById(205L)).thenReturn(primaryNetwork);

            
                    Mockito.when(nicNetworkMapDao.listByNicId(11L)).thenReturn(new ArrayList<>());

            
                    NetworkVO requestedNetwork = mockNetwork(206L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1180));

            
                    Mockito.when(requestedNetwork.getCidr()).thenReturn("10.1.1.0/24");

            
                    Mockito.when(networkDao.findById(206L)).thenReturn(requestedNetwork);


                    service.associateNetworkToNic(mockAssociateCmd(11L, Arrays.asList(206L)));

            
                }


                @Test

            
                public void associateNetworkToNicSucceedsWhenRequestedNetworkCidrDoesNotOverlapPrimaryNetworkCidr() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    NetworkVO primaryNetwork = mockNetwork(205L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1174));

            
                    Mockito.when(primaryNetwork.getCidr()).thenReturn("10.1.1.0/24");

            
                    Mockito.when(networkDao.findById(205L)).thenReturn(primaryNetwork);

            
                    Mockito.when(nicNetworkMapDao.listByNicId(11L)).thenReturn(new ArrayList<>());

            
                    NetworkVO requestedNetwork = mockNetwork(206L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1180));

            
                    Mockito.when(requestedNetwork.getCidr()).thenReturn("10.1.2.0/24");

            
                    Mockito.when(networkDao.findById(206L)).thenReturn(requestedNetwork);

            
                    Mockito.when(ipAddressManagerMock.allocateGuestIP(requestedNetwork, null)).thenReturn("10.1.2.50");


                    Nic result = service.associateNetworkToNic(mockAssociateCmd(11L, Arrays.asList(206L)));


                    Assert.assertNotNull(result);

            
                }


                @Test

            
                public void associateNetworkToNicChecksVmOwnerPermissionsOnRequestedNetwork() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    Mockito.when(vm.getAccountId()).thenReturn(5L);

            
                    Mockito.when(accountManager.getAccount(5L)).thenReturn(accountMock);

            
                    NetworkVO primaryNetwork = mockNetwork(205L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1174));

            
                    Mockito.when(primaryNetwork.getCidr()).thenReturn("10.1.1.0/24");

            
                    Mockito.when(networkDao.findById(205L)).thenReturn(primaryNetwork);

            
                    Mockito.when(nicNetworkMapDao.listByNicId(11L)).thenReturn(new ArrayList<>());

            
                    NetworkVO requestedNetwork = mockNetwork(206L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1180));

            
                    Mockito.when(requestedNetwork.getCidr()).thenReturn("10.1.2.0/24");

            
                    Mockito.when(networkDao.findById(206L)).thenReturn(requestedNetwork);

            
                    Mockito.when(ipAddressManagerMock.allocateGuestIP(requestedNetwork, null)).thenReturn("10.1.2.50");


                    service.associateNetworkToNic(mockAssociateCmd(11L, Arrays.asList(206L)));


                    Mockito.verify(networkModel).checkNetworkPermissions(accountMock, requestedNetwork);

            
                }


                @Test(expected = PermissionDeniedException.class)

            
                public void associateNetworkToNicFailsWhenVmOwnerLacksAccessToRequestedNetwork() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    Mockito.when(vm.getAccountId()).thenReturn(5L);

            
                    Mockito.when(accountManager.getAccount(5L)).thenReturn(accountMock);

            
                    NetworkVO primaryNetwork = mockNetwork(205L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1174));

            
                    Mockito.when(networkDao.findById(205L)).thenReturn(primaryNetwork);

            
                    Mockito.when(nicNetworkMapDao.listByNicId(11L)).thenReturn(new ArrayList<>());

            
                    NetworkVO requestedNetwork = mockNetwork(206L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1180));

            
                    Mockito.when(networkDao.findById(206L)).thenReturn(requestedNetwork);

            
                    Mockito.doThrow(new PermissionDeniedException("no access to network 206"))

            
                            .when(networkModel).checkNetworkPermissions(accountMock, requestedNetwork);


                    service.associateNetworkToNic(mockAssociateCmd(11L, Arrays.asList(206L)));

            
                }


                @Test(expected = InvalidParameterValueException.class)

            
                public void associateNetworkToNicFailsWhenRequestedNetworkIsOnADifferentPhysicalNetwork() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    NetworkVO primaryNetwork = mockNetwork(205L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1174));

            
                    Mockito.when(networkDao.findById(205L)).thenReturn(primaryNetwork);

            
                    Mockito.when(nicNetworkMapDao.listByNicId(11L)).thenReturn(new ArrayList<>());

            
                    NetworkVO otherPhysicalNetwork = mockNetwork(206L, Network.GuestType.Isolated, 2L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1180));

            
                    Mockito.when(networkDao.findById(206L)).thenReturn(otherPhysicalNetwork);


                    service.associateNetworkToNic(mockAssociateCmd(11L, Arrays.asList(206L)));

            
                }


                @Test(expected = InvalidParameterValueException.class)

            
                public void associateNetworkToNicFailsWhenRequestedNetworkIsInADifferentZone() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    NetworkVO primaryNetwork = mockNetwork(205L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1174));

            
                    Mockito.when(networkDao.findById(205L)).thenReturn(primaryNetwork);

            
                    Mockito.when(nicNetworkMapDao.listByNicId(11L)).thenReturn(new ArrayList<>());

            
                    NetworkVO otherZoneNetwork = mockNetwork(206L, Network.GuestType.Isolated, 1L, 2L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1180));

            
                    Mockito.when(networkDao.findById(206L)).thenReturn(otherZoneNetwork);


                    service.associateNetworkToNic(mockAssociateCmd(11L, Arrays.asList(206L)));

            
                }


                @Test

            
                public void associateNetworkToNicAllowsRequestedIsolatedNetworkInADifferentVpc() throws Exception {

            
                    // same-VPC restriction was dropped: caller access (checkAccess) is the real authorization boundary here,

            
                    // identical to the one ordinary addNicToVirtualMachine already relies on, so a tier of an unrelated VPC

            
                    // (or a non-VPC network) is just as valid an association as a tier of the primary network's own VPC.

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    NetworkVO primaryNetwork = mockNetwork(205L, Network.GuestType.Isolated, 1L, 1L, 900L, Networks.BroadcastDomainType.Vlan, vlanUri(1174));

            
                    Mockito.when(networkDao.findById(205L)).thenReturn(primaryNetwork);

            
                    Mockito.when(nicNetworkMapDao.listByNicId(11L)).thenReturn(new ArrayList<>());

            
                    NetworkVO otherVpcNetwork = mockNetwork(206L, Network.GuestType.Isolated, 1L, 1L, 901L, Networks.BroadcastDomainType.Vlan, vlanUri(1180));

            
                    Mockito.when(networkDao.findById(206L)).thenReturn(otherVpcNetwork);

            
                    Mockito.when(ipAddressManagerMock.allocateGuestIP(otherVpcNetwork, null)).thenReturn("10.1.1.51");


                    Nic result = service.associateNetworkToNic(mockAssociateCmd(11L, Arrays.asList(206L)));


                    Assert.assertNotNull(result);

            
                    Mockito.verify(nicNetworkMapDao).persist(Mockito.argThat(map ->

            
                            map.getNicId() == 11L && map.getNetworkId() == 206L && "10.1.1.51".equals(map.getIp4Address())));

            
                }


                @Test(expected = InvalidParameterValueException.class)

            
                public void associateNetworkToNicFailsWhenRequestedNetworkIsSecurityGroupEnabled() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    NetworkVO primaryNetwork = mockNetwork(205L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1174));

            
                    Mockito.when(networkDao.findById(205L)).thenReturn(primaryNetwork);

            
                    Mockito.when(nicNetworkMapDao.listByNicId(11L)).thenReturn(new ArrayList<>());

            
                    NetworkVO sgNetwork = mockNetwork(206L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1180));

            
                    Mockito.when(networkDao.findById(206L)).thenReturn(sgNetwork);

            
                    Mockito.when(networkModel.isSecurityGroupSupportedInNetwork(sgNetwork)).thenReturn(true);


                    service.associateNetworkToNic(mockAssociateCmd(11L, Arrays.asList(206L)));

            
                }


                @Test(expected = InvalidParameterValueException.class)

            
                public void associateNetworkToNicFailsWhenRequestedNetworkSharesVlanWithAnExistingAssociation() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Running, 1L);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    DetailVO readyDetail = Mockito.mock(DetailVO.class);

            
                    Mockito.when(readyDetail.getValue()).thenReturn("true");

            
                    Mockito.when(hostDetailsDao.findDetail(1L, Host.HOST_VLAN_FILTERING_ENABLED)).thenReturn(readyDetail);

            
                    NetworkVO primaryNetwork = mockNetwork(205L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1174));

            
                    Mockito.when(networkDao.findById(205L)).thenReturn(primaryNetwork);

            
                    Mockito.when(nicNetworkMapDao.listByNicId(11L)).thenReturn(new ArrayList<>());

            
                    NetworkVO sameVlanNetwork = mockNetwork(206L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1174));

            
                    Mockito.when(networkDao.findById(206L)).thenReturn(sameVlanNetwork);


                    service.associateNetworkToNic(mockAssociateCmd(11L, Arrays.asList(206L)));

            
                }


                @Test

            
                public void associateNetworkToNicPersistsAssociationAndSetsMultiNetworkOnAStoppedVm() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    NetworkVO primaryNetwork = mockNetwork(205L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1174));

            
                    Mockito.when(networkDao.findById(205L)).thenReturn(primaryNetwork);

            
                    Mockito.when(nicNetworkMapDao.listByNicId(11L)).thenReturn(new ArrayList<>());

            
                    NetworkVO requestedNetwork = mockNetwork(206L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1180));

            
                    Mockito.when(networkDao.findById(206L)).thenReturn(requestedNetwork);

            
                    Mockito.when(ipAddressManagerMock.allocateGuestIP(requestedNetwork, null)).thenReturn("10.1.1.50");


                    Nic result = service.associateNetworkToNic(mockAssociateCmd(11L, Arrays.asList(206L)));


                    Assert.assertNotNull(result);

            
                    Mockito.verify(nicNetworkMapDao).persist(Mockito.argThat(map ->

            
                            map.getNicId() == 11L && map.getNetworkId() == 206L && "10.1.1.50".equals(map.getIp4Address())));

            
                    Mockito.verify(nic).setMultiNetwork(true);

            
                    Mockito.verify(nicDao).update(Mockito.eq(11L), Mockito.eq(nic));

            
                }


                @Test

            
                public void associateNetworksToNicPersistsAssociationWithNoExplicitIpAddresses() throws Exception {

            
                    // the deploy-time path (persistAdditionalNicNetworkAssociations -> associateNetworksToNic) calls this with

            
                    // no ipAddresses map at all - must not NPE when that's passed through as a literal null

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    NetworkVO primaryNetwork = mockNetwork(205L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1174));

            
                    Mockito.when(networkDao.findById(205L)).thenReturn(primaryNetwork);

            
                    Mockito.when(nicNetworkMapDao.listByNicId(11L)).thenReturn(new ArrayList<>());

            
                    NetworkVO requestedNetwork = mockNetwork(206L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1180));

            
                    Mockito.when(networkDao.findById(206L)).thenReturn(requestedNetwork);

            
                    Mockito.when(ipAddressManagerMock.allocateGuestIP(requestedNetwork, null)).thenReturn("10.1.1.60");


                    service.associateNetworksToNic(nic, Arrays.asList(206L), null);


                    Mockito.verify(nicNetworkMapDao).persist(Mockito.argThat(map ->

            
                            map.getNicId() == 11L && map.getNetworkId() == 206L && "10.1.1.60".equals(map.getIp4Address())));

            
                    Mockito.verify(nic).setMultiNetwork(true);

            
                }


                @Test

            
                public void associateNetworksToNicUsesRequestedIpForAssociatedNetwork() throws Exception {

            
                    // deploy-time path (nicnetworkslist[N].ip4addresses) - a requested ip for an associated network must

            
                    // reach allocateGuestIP as the requested value, not be silently ignored/auto-allocated

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    NetworkVO primaryNetwork = mockNetwork(205L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1174));

            
                    Mockito.when(networkDao.findById(205L)).thenReturn(primaryNetwork);

            
                    Mockito.when(nicNetworkMapDao.listByNicId(11L)).thenReturn(new ArrayList<>());

            
                    NetworkVO requestedNetwork = mockNetwork(206L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1180));

            
                    Mockito.when(networkDao.findById(206L)).thenReturn(requestedNetwork);

            
                    Mockito.when(ipAddressManagerMock.allocateGuestIP(requestedNetwork, "10.1.1.99")).thenReturn("10.1.1.99");


                    service.associateNetworksToNic(nic, Arrays.asList(206L), Collections.singletonMap(206L, new Network.IpAddresses("10.1.1.99", null)));


                    Mockito.verify(ipAddressManagerMock).allocateGuestIP(requestedNetwork, "10.1.1.99");

            
                    Mockito.verify(nicNetworkMapDao).persist(Mockito.argThat(map ->

            
                            map.getNicId() == 11L && map.getNetworkId() == 206L && "10.1.1.99".equals(map.getIp4Address())));

            
                }


                @Test

            
                public void associateNetworksToNicDerivesEui64Ipv6ForIsolatedDualStackNetwork() throws Exception {

            
                    // Isolated has no ip6_range - must not go through the range-based allocator.

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nic.getMacAddress()).thenReturn("06:7a:88:00:00:8b");

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    NetworkVO primaryNetwork = mockNetwork(205L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1174));

            
                    Mockito.when(networkDao.findById(205L)).thenReturn(primaryNetwork);

            
                    Mockito.when(nicNetworkMapDao.listByNicId(11L)).thenReturn(new ArrayList<>());

            
                    NetworkVO requestedNetwork = mockNetwork(206L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1180));

            
                    Mockito.when(requestedNetwork.getIp6Cidr()).thenReturn("2001:db8:100::/64");

            
                    Mockito.when(networkDao.findById(206L)).thenReturn(requestedNetwork);

            
                    Mockito.when(ipAddressManagerMock.allocateGuestIP(requestedNetwork, null)).thenReturn("10.1.1.60");

            
                    String expectedIp6 = NetUtils.EUI64Address("2001:db8:100::/64", "06:7a:88:00:00:8b").toString();


                    service.associateNetworksToNic(nic, Arrays.asList(206L), null);


                    Mockito.verify(nicNetworkMapDao).persist(Mockito.argThat(map ->

            
                            map.getNicId() == 11L && map.getNetworkId() == 206L && expectedIp6.equals(map.getIp6Address())));

            
                    Mockito.verifyNoInteractions(ipv6AddressManager);

            
                }


                @Test

            
                public void associateNetworksToNicDerivesEui64Ipv6ForSharedDualStackNetworkToo() throws Exception {

            
                    // Shared nics get v6 the same way - EUI-64, never the range-based allocator.

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nic.getMacAddress()).thenReturn("06:7a:88:00:00:8b");

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    NetworkVO primaryNetwork = mockNetwork(205L, Network.GuestType.Shared, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1174));

            
                    Mockito.when(networkDao.findById(205L)).thenReturn(primaryNetwork);

            
                    Mockito.when(nicNetworkMapDao.listByNicId(11L)).thenReturn(new ArrayList<>());

            
                    NetworkVO requestedNetwork = mockNetwork(206L, Network.GuestType.Shared, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1180));

            
                    Mockito.when(requestedNetwork.getIp6Cidr()).thenReturn("2001:db8:100::/64");

            
                    Mockito.when(networkDao.findById(206L)).thenReturn(requestedNetwork);

            
                    Mockito.when(entityMgr.findById(DataCenter.class, 1L)).thenReturn(dc);

            
                    Mockito.when(ipAddressManagerMock.allocatePublicIpForGuestNic(Mockito.eq(requestedNetwork), Mockito.isNull(), Mockito.any(), Mockito.isNull()))

            
                            .thenReturn("10.1.1.60");

            
                    String expectedIp6 = NetUtils.EUI64Address("2001:db8:100::/64", "06:7a:88:00:00:8b").toString();


                    service.associateNetworksToNic(nic, Arrays.asList(206L), null);


                    Mockito.verify(nicNetworkMapDao).persist(Mockito.argThat(map ->

            
                            map.getNicId() == 11L && map.getNetworkId() == 206L && expectedIp6.equals(map.getIp6Address())));

            
                    Mockito.verifyNoInteractions(ipv6AddressManager);

            
                }


                @Test(expected = InvalidParameterValueException.class)

            
                public void associateNetworksToNicRejectsVnfManagementNic() throws Exception {

            
                    // the live associate-network-to-nic path must reject trunking a VNF template's management nic, same as

            
                    // the deploy-time nicnetworkslist path already does via validateVnfApplianceTrunkNics

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(vm.getTemplateId()).thenReturn(99L);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    NetworkVO primaryNetwork = mockNetwork(205L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1174));

            
                    Mockito.when(networkDao.findById(205L)).thenReturn(primaryNetwork);

            
                    VMTemplateVO template = Mockito.mock(VMTemplateVO.class);

            
                    Mockito.when(templateDao.findByIdIncludingRemoved(99L)).thenReturn(template);

            
                    Mockito.doThrow(new InvalidParameterValueException("VNF nic is the management interface"))

            
                            .when(vnfTemplateManagerMock).validateVnfApplianceTrunkNic(template, 0L);


                    service.associateNetworksToNic(nic, Arrays.asList(206L), null);

            
                }


                @Test(expected = InvalidParameterValueException.class)

            
                public void associateNetworksToNicRejectsNetworkAlreadyOnAnotherNic() throws Exception {

            
                    // vm has a second, ordinary nic (208L) whose primary is network 206L - trying to associate 206L onto

            
                    // nic 11L too must be rejected, since a network can only be reachable through one of the vm's nics

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(vm.getId()).thenReturn(5L);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    NetworkVO primaryNetwork = mockNetwork(205L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1174));

            
                    Mockito.when(networkDao.findById(205L)).thenReturn(primaryNetwork);

            
                    Mockito.when(nicNetworkMapDao.listByNicId(11L)).thenReturn(new ArrayList<>());


                    NicVO otherNic = mockNic(12L, 5L, 206L, false);

            
                    Mockito.when(nicDao.listByVmId(5L)).thenReturn(Arrays.asList(nic, otherNic));

            
                    Mockito.when(nicNetworkMapDao.listByNicId(12L)).thenReturn(new ArrayList<>());


                    service.associateNetworksToNic(nic, Arrays.asList(206L), null);

            
                }


                @Test

            
                public void associateNetworksToNicPublishesBackfillEventOnFirstConversionToTrunk() throws Exception {

            
                    // nic is not yet a trunk nic (multiNetwork=false) - this is the first association, so the nic's own

            
                    // still-open, pre-existing usage row(s) for its primary network need a one-time network_id backfill.

            
                    // The backfill itself runs later, on the usage job's own thread (see UsageManagerImpl) - this request

            
                    // thread only ever publishes the event, since it already has an ambient `cloud` DB transaction open

            
                    // and cloud_usage is a separate database.

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    NetworkVO primaryNetwork = mockNetwork(205L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1174));

            
                    Mockito.when(networkDao.findById(205L)).thenReturn(primaryNetwork);

            
                    Mockito.when(nicNetworkMapDao.listByNicId(11L)).thenReturn(new ArrayList<>());

            
                    NetworkVO requestedNetwork = mockNetwork(206L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1180));

            
                    Mockito.when(networkDao.findById(206L)).thenReturn(requestedNetwork);

            
                    Mockito.when(ipAddressManagerMock.allocateGuestIP(requestedNetwork, null)).thenReturn("10.1.1.60");


                    service.associateNetworksToNic(nic, Arrays.asList(206L), null);


                    usageEventUtilsMocked.verify(() -> UsageEventUtils.publishUsageEvent(

            
                            Mockito.eq(EventTypes.EVENT_NIC_NETWORK_ID_BACKFILL), Mockito.anyLong(), Mockito.anyLong(), Mockito.eq(11L), Mockito.eq("11"),

            
                            Mockito.isNull(), Mockito.isNull(), Mockito.isNull(), Mockito.anyString(), Mockito.any(),

            
                            Mockito.argThat(details -> "205".equals(details.get(UsageEventVO.DynamicParameters.networkId.name())))), Mockito.times(1));

            
                }


                @Test

            
                public void associateNetworksToNicDoesNotPublishBackfillEventWhenNicIsAlreadyATrunkNic() throws Exception {

            
                    // nic is already a trunk nic - this is a further association on top of an existing one, not the

            
                    // first-time conversion, so the one-time backfill must not fire again

            
                    NicVO nic = mockNic(11L, 5L, 205L, true);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    NetworkVO primaryNetwork = mockNetwork(205L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1174));

            
                    Mockito.when(networkDao.findById(205L)).thenReturn(primaryNetwork);

            
                    Mockito.when(nicNetworkMapDao.listByNicId(11L)).thenReturn(new ArrayList<>());

            
                    NetworkVO requestedNetwork = mockNetwork(207L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1190));

            
                    Mockito.when(networkDao.findById(207L)).thenReturn(requestedNetwork);

            
                    Mockito.when(ipAddressManagerMock.allocateGuestIP(requestedNetwork, null)).thenReturn("10.1.1.70");


                    service.associateNetworksToNic(nic, Arrays.asList(207L), null);


                    usageEventUtilsMocked.verify(() -> UsageEventUtils.publishUsageEvent(

            
                            Mockito.eq(EventTypes.EVENT_NIC_NETWORK_ID_BACKFILL), Mockito.anyLong(), Mockito.anyLong(), Mockito.anyLong(), Mockito.anyString(),

            
                            Mockito.isNull(), Mockito.isNull(), Mockito.isNull(), Mockito.anyString(), Mockito.any(), Mockito.anyMap()), Mockito.never());

            
                }


                @Test(expected = CloudRuntimeException.class)

            
                public void associateNetworksToNicFailsWhenVmNotStopped() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, false);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Running, 1L);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);


                    service.associateNetworksToNic(nic, Arrays.asList(206L), null);

            
                }


                private DisassociateNetworkFromNicCmd mockDisassociateCmd(long nicId, long networkId) {

            
                    DisassociateNetworkFromNicCmd cmd = Mockito.mock(DisassociateNetworkFromNicCmd.class);

            
                    Mockito.when(cmd.getNicId()).thenReturn(nicId);

            
                    Mockito.when(cmd.getNetworkId()).thenReturn(networkId);

            
                    return cmd;

            
                }


                @Test

            
                public void disassociateNetworkFromNicFailsWhenFeatureDisabledInZone() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, true);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);


                    overrideDefaultConfigValue(NetworkOrchestrationService.MultiNetworkNicEnabled, "_defaultValue", "false");

            
                    try {

            
                        service.disassociateNetworkFromNic(mockDisassociateCmd(11L, 206L));

            
                        Assert.fail("expected InvalidParameterValueException");

            
                    } catch (InvalidParameterValueException e) {

            
                        Assert.assertTrue(e.getMessage().contains("not enabled"));

            
                    } finally {

            
                        overrideDefaultConfigValue(NetworkOrchestrationService.MultiNetworkNicEnabled, "_defaultValue", "true");

            
                    }

            
                }


                @Test(expected = ConcurrentOperationException.class)

            
                public void disassociateNetworkFromNicFailsWhenNicLockCannotBeAcquired() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, true);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    Mockito.when(nicDao.acquireInLockTable(11L)).thenReturn(null);


                    service.disassociateNetworkFromNic(mockDisassociateCmd(11L, 206L));

            
                }


                @Test(expected = InvalidParameterValueException.class)

            
                public void disassociateNetworkFromNicFailsWhenTargetIsPrimaryNetwork() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, true);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);


                    service.disassociateNetworkFromNic(mockDisassociateCmd(11L, 205L));

            
                }


                @Test(expected = InvalidParameterValueException.class)

            
                public void disassociateNetworkFromNicFailsWhenNotAssociated() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, true);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    Mockito.when(nicNetworkMapDao.findByNicIdAndNetworkId(11L, 206L)).thenReturn(null);


                    service.disassociateNetworkFromNic(mockDisassociateCmd(11L, 206L));

            
                }


                @Test(expected = InvalidParameterValueException.class)

            
                public void disassociateNetworkFromNicFailsWhenAssociationIpHasActiveStaticNat() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, true);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(vm.getId()).thenReturn(5L);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    NicNetworkMapVO association = new NicNetworkMapVO(11L, 206L, "10.3.1.25", null);

            
                    Mockito.when(nicNetworkMapDao.findByNicIdAndNetworkId(11L, 206L)).thenReturn(association);

            
                    IPAddressVO staticNatIp = Mockito.mock(IPAddressVO.class);

            
                    Mockito.when(ipAddressDao.findByAssociatedVmIdAndVmIp(5L, "10.3.1.25")).thenReturn(staticNatIp);


                    service.disassociateNetworkFromNic(mockDisassociateCmd(11L, 206L));

            
                }


                @Test

            
                public void disassociateNetworkFromNicRemovesAssociationOnAStoppedVm() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, true);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    NicNetworkMapVO association = new NicNetworkMapVO(11L, 206L, "10.1.1.50", null);

            
                    Mockito.when(nicNetworkMapDao.findByNicIdAndNetworkId(11L, 206L)).thenReturn(association);

            
                    Mockito.when(nicNetworkMapDao.listByNicId(11L)).thenReturn(Collections.emptyList());


                    Nic result = service.disassociateNetworkFromNic(mockDisassociateCmd(11L, 206L));


                    Assert.assertNotNull(result);

            
                    Mockito.verify(nicNetworkMapDao).remove(association.getId());

            
                    Mockito.verify(agentMgr, Mockito.never()).easySend(Mockito.anyLong(), Mockito.any());

            
                    Mockito.verify(nic).setMultiNetwork(false);

            
                    Mockito.verify(nicDao).update(11L, nic);

            
                }


                @Test

            
                public void disassociateNetworkFromNicKeepsMultiNetworkFlagWhenOtherAssociationsRemain() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, true);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    NicNetworkMapVO association = new NicNetworkMapVO(11L, 206L, "10.1.1.50", null);

            
                    Mockito.when(nicNetworkMapDao.findByNicIdAndNetworkId(11L, 206L)).thenReturn(association);

            
                    NicNetworkMapVO remainingAssociation = new NicNetworkMapVO(11L, 207L, "10.1.1.60", null);

            
                    Mockito.when(nicNetworkMapDao.listByNicId(11L)).thenReturn(Arrays.asList(remainingAssociation));


                    Nic result = service.disassociateNetworkFromNic(mockDisassociateCmd(11L, 206L));


                    Assert.assertNotNull(result);

            
                    Mockito.verify(nicNetworkMapDao).remove(association.getId());

            
                    Mockito.verify(nic, Mockito.never()).setMultiNetwork(Mockito.anyBoolean());

            
                    Mockito.verify(nicDao, Mockito.never()).update(Mockito.eq(11L), Mockito.any());

            
                }


                @Test

            
                public void disassociateNetworkFromNicUpdatesLiveVlanMembershipOnARunningVm() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, true);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Running, 1L);

            
                    Mockito.when(vm.getHypervisorType()).thenReturn(Hypervisor.HypervisorType.KVM);

            
                    Mockito.when(vm.getInstanceName()).thenReturn("i-2-11-VM");

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    DetailVO readyDetail = Mockito.mock(DetailVO.class);

            
                    Mockito.when(readyDetail.getValue()).thenReturn("true");

            
                    Mockito.when(hostDetailsDao.findDetail(1L, Host.HOST_VLAN_FILTERING_ENABLED)).thenReturn(readyDetail);

            
                    NicNetworkMapVO association = new NicNetworkMapVO(11L, 206L, "10.1.1.50", null);

            
                    Mockito.when(nicNetworkMapDao.findByNicIdAndNetworkId(11L, 206L)).thenReturn(association);

            
                    Mockito.when(networkModel.getNicProfile(Mockito.eq(vm), Mockito.eq(nic), Mockito.any())).thenReturn(null);

            
                    Mockito.when(hvGuruMgr.getGuru(Hypervisor.HypervisorType.KVM)).thenReturn(hypervisorGuru);

            
                    Mockito.when(hypervisorGuru.toNicTO(null)).thenReturn(Mockito.mock(NicTO.class));

            
                    Mockito.when(agentMgr.easySend(Mockito.eq(1L), Mockito.any())).thenReturn(new UpdateNicVlanMembershipAnswer(null, true, "success"));

            
                    DomainRouterVO router = Mockito.mock(DomainRouterVO.class);

            
                    Mockito.when(router.getState()).thenReturn(VirtualMachine.State.Running);

            
                    Mockito.when(routerDao.findByNetwork(205L)).thenReturn(Arrays.asList(router));


                    Nic result = service.disassociateNetworkFromNic(mockDisassociateCmd(11L, 206L));


                    Assert.assertNotNull(result);

            
                    Mockito.verify(nicNetworkMapDao).remove(association.getId());

            
                    Mockito.verify(agentMgr).easySend(Mockito.eq(1L), Mockito.any());

            
                    Mockito.verify(commandSetupHelper).createVmDataCommand(Mockito.eq(router), Mockito.eq(vm), Mockito.eq(nic), Mockito.any(), Mockito.any());

            
                    Mockito.verify(networkHelper).sendCommandsToRouter(Mockito.eq(router), Mockito.any());

            
                }


                @Test

            
                public void disassociateNetworkFromNicRemovesDhcpEntryOnARunningVm() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, true);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Running, 1L);

            
                    Mockito.when(vm.getHypervisorType()).thenReturn(Hypervisor.HypervisorType.KVM);

            
                    Mockito.when(vm.getInstanceName()).thenReturn("i-2-11-VM");

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    DetailVO readyDetail = Mockito.mock(DetailVO.class);

            
                    Mockito.when(readyDetail.getValue()).thenReturn("true");

            
                    Mockito.when(hostDetailsDao.findDetail(1L, Host.HOST_VLAN_FILTERING_ENABLED)).thenReturn(readyDetail);

            
                    NicNetworkMapVO association = new NicNetworkMapVO(11L, 206L, "10.1.1.50", null);

            
                    Mockito.when(nicNetworkMapDao.findByNicIdAndNetworkId(11L, 206L)).thenReturn(association);

            
                    NetworkVO associatedNetwork = mockNetwork(206L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1180));

            
                    Mockito.when(networkDao.findById(206L)).thenReturn(associatedNetwork);

            
                    Mockito.when(networkModel.getNicProfile(Mockito.eq(vm), Mockito.eq(nic), Mockito.any())).thenReturn(null);

            
                    Mockito.when(hvGuruMgr.getGuru(Hypervisor.HypervisorType.KVM)).thenReturn(hypervisorGuru);

            
                    Mockito.when(hypervisorGuru.toNicTO(null)).thenReturn(Mockito.mock(NicTO.class));

            
                    Mockito.when(agentMgr.easySend(Mockito.eq(1L), Mockito.any())).thenReturn(new UpdateNicVlanMembershipAnswer(null, true, "success"));

            
                    Mockito.when(routerDao.findByNetwork(205L)).thenReturn(new ArrayList<>());

            
                    DomainRouterVO associatedNetworkRouter = Mockito.mock(DomainRouterVO.class);

            
                    Mockito.when(associatedNetworkRouter.getState()).thenReturn(VirtualMachine.State.Running);

            
                    Mockito.when(routerDao.findByNetwork(206L)).thenReturn(Arrays.asList(associatedNetworkRouter));


                    service.disassociateNetworkFromNic(mockDisassociateCmd(11L, 206L));


                    Mockito.verify(commandSetupHelper).createDhcpEntryCommand(Mockito.eq(associatedNetworkRouter), Mockito.eq(vm), Mockito.any(), Mockito.eq("10.1.1.50"),

            
                            Mockito.any(), Mockito.any(), Mockito.any(), Mockito.eq(206L), Mockito.eq(false), Mockito.eq(true), Mockito.any());

            
                    Mockito.verify(networkHelper).sendCommandsToRouter(Mockito.eq(associatedNetworkRouter), Mockito.any());

            
                }


                @Test

            
                public void disassociateNetworkFromNicDoesNotRemoveDhcpEntryOnAStoppedVm() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, true);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    NicNetworkMapVO association = new NicNetworkMapVO(11L, 206L, "10.1.1.50", null);

            
                    Mockito.when(nicNetworkMapDao.findByNicIdAndNetworkId(11L, 206L)).thenReturn(association);


                    service.disassociateNetworkFromNic(mockDisassociateCmd(11L, 206L));


                    Mockito.verify(commandSetupHelper, Mockito.never()).createDhcpEntryCommand(Mockito.any(), Mockito.any(), Mockito.anyString(), Mockito.anyString(),

            
                            Mockito.any(), Mockito.any(), Mockito.any(), Mockito.anyLong(), Mockito.anyBoolean(), Mockito.anyBoolean(), Mockito.any());

            
                }


                @Test

            
                public void disassociateNetworkFromNicSucceedsWhenMetadataRefreshFails() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, true);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Running, 1L);

            
                    Mockito.when(vm.getHypervisorType()).thenReturn(Hypervisor.HypervisorType.KVM);

            
                    Mockito.when(vm.getInstanceName()).thenReturn("i-2-11-VM");

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    DetailVO readyDetail = Mockito.mock(DetailVO.class);

            
                    Mockito.when(readyDetail.getValue()).thenReturn("true");

            
                    Mockito.when(hostDetailsDao.findDetail(1L, Host.HOST_VLAN_FILTERING_ENABLED)).thenReturn(readyDetail);

            
                    NicNetworkMapVO association = new NicNetworkMapVO(11L, 206L, "10.1.1.50", null);

            
                    Mockito.when(nicNetworkMapDao.findByNicIdAndNetworkId(11L, 206L)).thenReturn(association);

            
                    Mockito.when(networkModel.getNicProfile(Mockito.eq(vm), Mockito.eq(nic), Mockito.any())).thenReturn(null);

            
                    Mockito.when(hvGuruMgr.getGuru(Hypervisor.HypervisorType.KVM)).thenReturn(hypervisorGuru);

            
                    Mockito.when(hypervisorGuru.toNicTO(null)).thenReturn(Mockito.mock(NicTO.class));

            
                    Mockito.when(agentMgr.easySend(Mockito.eq(1L), Mockito.any())).thenReturn(new UpdateNicVlanMembershipAnswer(null, true, "success"));

            
                    DomainRouterVO router = Mockito.mock(DomainRouterVO.class);

            
                    Mockito.when(router.getState()).thenReturn(VirtualMachine.State.Running);

            
                    Mockito.when(routerDao.findByNetwork(205L)).thenReturn(Arrays.asList(router));

            
                    Mockito.when(networkHelper.sendCommandsToRouter(Mockito.eq(router), Mockito.any())).thenThrow(new CloudRuntimeException("router unreachable"));


                    Nic result = service.disassociateNetworkFromNic(mockDisassociateCmd(11L, 206L));


                    Assert.assertNotNull(result);

            
                    Mockito.verify(nicNetworkMapDao).remove(association.getId());

            
                }


                private ChangeNicPrimaryNetworkCmd mockChangePrimaryCmd(long nicId, long networkId) {

            
                    ChangeNicPrimaryNetworkCmd cmd = Mockito.mock(ChangeNicPrimaryNetworkCmd.class);

            
                    Mockito.when(cmd.getNicId()).thenReturn(nicId);

            
                    Mockito.when(cmd.getNetworkId()).thenReturn(networkId);

            
                    return cmd;

            
                }


                @Test

            
                public void changeNicPrimaryNetworkFailsWhenFeatureDisabledInZone() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, true);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);


                    overrideDefaultConfigValue(NetworkOrchestrationService.MultiNetworkNicEnabled, "_defaultValue", "false");

            
                    try {

            
                        service.changeNicPrimaryNetwork(mockChangePrimaryCmd(11L, 206L));

            
                        Assert.fail("expected InvalidParameterValueException");

            
                    } catch (InvalidParameterValueException e) {

            
                        Assert.assertTrue(e.getMessage().contains("not enabled"));

            
                    } finally {

            
                        overrideDefaultConfigValue(NetworkOrchestrationService.MultiNetworkNicEnabled, "_defaultValue", "true");

            
                    }

            
                }


                @Test(expected = InvalidParameterValueException.class)

            
                public void changeNicPrimaryNetworkFailsWhenVmNotStopped() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, true);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Running, 1L);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);


                    service.changeNicPrimaryNetwork(mockChangePrimaryCmd(11L, 206L));

            
                }


                @Test(expected = ConcurrentOperationException.class)

            
                public void changeNicPrimaryNetworkFailsWhenNicLockCannotBeAcquired() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, true);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    Mockito.when(nicDao.acquireInLockTable(11L)).thenReturn(null);


                    service.changeNicPrimaryNetwork(mockChangePrimaryCmd(11L, 206L));

            
                }


                @Test(expected = InvalidParameterValueException.class)

            
                public void changeNicPrimaryNetworkFailsWhenTargetIsCurrentPrimary() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, true);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);


                    service.changeNicPrimaryNetwork(mockChangePrimaryCmd(11L, 205L));

            
                }


                @Test(expected = InvalidParameterValueException.class)

            
                public void changeNicPrimaryNetworkFailsWhenTargetNotAssociated() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, true);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    Mockito.when(nicNetworkMapDao.findByNicIdAndNetworkId(11L, 206L)).thenReturn(null);


                    service.changeNicPrimaryNetwork(mockChangePrimaryCmd(11L, 206L));

            
                }


                @Test

            
                public void changeNicPrimaryNetworkSwapsPrimaryAndDemotesOldPrimaryToAssociation() throws Exception {

            
                    NicVO nic = mockNic(11L, 5L, 205L, true);

            
                    Mockito.when(nic.getIPv4Address()).thenReturn("10.1.1.10");

            
                    Mockito.when(nic.getIPv6Address()).thenReturn(null);

            
                    Mockito.when(nicDao.findById(11L)).thenReturn(nic);

            
                    UserVmVO vm = mockVm(VirtualMachine.State.Stopped, null);

            
                    Mockito.when(userVmDao.findById(5L)).thenReturn(vm);

            
                    NicNetworkMapVO association = new NicNetworkMapVO(11L, 206L, "10.1.1.50", null);

            
                    Mockito.when(nicNetworkMapDao.findByNicIdAndNetworkId(11L, 206L)).thenReturn(association);

            
                    NetworkVO newPrimaryNetwork = mockNetwork(206L, Network.GuestType.Isolated, 1L, 1L, null, Networks.BroadcastDomainType.Vlan, vlanUri(1180));

            
                    Mockito.when(newPrimaryNetwork.getGateway()).thenReturn("10.1.2.1");

            
                    Mockito.when(newPrimaryNetwork.getCidr()).thenReturn("10.1.2.0/24");

            
                    Mockito.when(networkDao.findById(206L)).thenReturn(newPrimaryNetwork);

            
                    Mockito.when(networkModel.getValidNetworkCidr(newPrimaryNetwork)).thenReturn("10.1.2.0/24");


                    Nic result = service.changeNicPrimaryNetwork(mockChangePrimaryCmd(11L, 206L));


                    Assert.assertNotNull(result);

            
                    Mockito.verify(nicNetworkMapDao).remove(association.getId());

            
                    Mockito.verify(nicNetworkMapDao).persist(Mockito.argThat(map ->

            
                            map.getNicId() == 11L && map.getNetworkId() == 205L && "10.1.1.10".equals(map.getIp4Address())));

            
                    Mockito.verify(nic).setNetworkId(206L);

            
                    Mockito.verify(nic).setIPv4Address("10.1.1.50");

            
                    Mockito.verify(nic).setIPv6Address(null);

            
                    Mockito.verify(nic).setIPv4Gateway("10.1.2.1");

            
                    Mockito.verify(nic).setIPv4Netmask(NetUtils.cidr2Netmask("10.1.2.0/24"));

            
                    Mockito.verify(nic).setBroadcastUri(vlanUri(1180));

            
                    Mockito.verify(nic).setIsolationUri(vlanUri(1180));

            
                    Mockito.verify(nicDao).update(Mockito.eq(11L), Mockito.eq(nic));

            
                }


                private URI vlanUri(int vlanId) {

            
                    return Networks.BroadcastDomainType.Vlan.toUri(vlanId);

            
                }

            
            }