content: // 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.router;
  
  import com.cloud.agent.AgentManager;
  import com.cloud.agent.api.CheckS2SVpnConnectionsAnswer;
  import com.cloud.agent.api.CheckS2SVpnConnectionsCommand;
  import com.cloud.agent.api.Command;
  import com.cloud.agent.manager.Commands;
  import com.cloud.alert.AlertManager;
  import com.cloud.bgp.BGPService;
  import com.cloud.cluster.dao.ManagementServerHostDao;
  import com.cloud.dc.dao.ClusterDao;
  import com.cloud.dc.dao.DataCenterDao;
  import com.cloud.dc.dao.HostPodDao;
  import com.cloud.dc.dao.VlanDao;
  import com.cloud.host.Host;
  import com.cloud.host.HostVO;
  import com.cloud.host.Status;
  import com.cloud.host.dao.HostDao;
  import com.cloud.hypervisor.Hypervisor;
  import com.cloud.network.Network;
  import com.cloud.network.NetworkModel;
  import com.cloud.network.Site2SiteVpnConnection;
  import com.cloud.network.dao.FirewallRulesDao;
  import com.cloud.network.dao.IPAddressDao;
  import com.cloud.network.dao.LoadBalancerDao;
  import com.cloud.network.dao.LoadBalancerVMMapDao;
  import com.cloud.network.dao.LoadBalancerVO;
  import com.cloud.network.dao.MonitoringServiceDao;
  import com.cloud.network.dao.NetworkDao;
  import com.cloud.network.dao.NetworkVO;
  import com.cloud.network.dao.OpRouterMonitorServiceDao;
  import com.cloud.network.dao.PhysicalNetworkServiceProviderDao;
  import com.cloud.network.dao.RemoteAccessVpnDao;
  import com.cloud.network.dao.Site2SiteCustomerGatewayDao;
  import com.cloud.network.dao.Site2SiteCustomerGatewayVO;
  import com.cloud.network.dao.Site2SiteVpnConnectionDao;
  import com.cloud.network.dao.Site2SiteVpnConnectionVO;
  import com.cloud.network.dao.Site2SiteVpnGatewayDao;
  import com.cloud.network.dao.UserIpv6AddressDao;
  import com.cloud.network.dao.VirtualRouterProviderDao;
  import com.cloud.network.dao.VpnUserDao;
  import com.cloud.network.lb.LoadBalancingRule;
  import com.cloud.network.lb.LoadBalancingRulesManager;
  import com.cloud.network.rules.dao.PortForwardingRulesDao;
  import com.cloud.network.vpc.VpcVO;
  import com.cloud.network.vpc.dao.VpcDao;
  import com.cloud.network.vpn.Site2SiteVpnManager;
  import com.cloud.offerings.dao.NetworkOfferingDao;
  import com.cloud.service.dao.ServiceOfferingDao;
  import com.cloud.storage.Storage;
  import com.cloud.storage.dao.GuestOSDao;
  import com.cloud.storage.dao.VMTemplateDao;
  import com.cloud.storage.dao.VolumeDao;
  import com.cloud.user.dao.UserDao;
  import com.cloud.user.dao.UserStatisticsDao;
  import com.cloud.user.dao.UserStatsLogDao;
  import com.cloud.utils.net.NetUtils;
  import com.cloud.vm.DomainRouterVO;
  import com.cloud.vm.VirtualMachine;
  import com.cloud.vm.VirtualMachineManager;
  import com.cloud.vm.dao.DomainRouterDao;
  import com.cloud.vm.dao.NicDao;
  import com.cloud.vm.dao.NicIpAliasDao;
  import com.cloud.vm.dao.UserVmDao;
  import com.cloud.vm.dao.VMInstanceDetailsDao;
  import com.cloud.vm.dao.VMInstanceDao;
  import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
  import org.apache.cloudstack.network.BgpPeer;
  import org.apache.cloudstack.network.RoutedIpv4Manager;
  import org.apache.cloudstack.utils.identity.ManagementServerNode;
  import org.junit.Assert;
  import org.junit.Test;
  import org.junit.runner.RunWith;
  import org.mockito.InjectMocks;
  import org.mockito.Mock;
  import org.mockito.Mockito;
  import org.mockito.junit.MockitoJUnitRunner;
  
  import java.util.ArrayList;
  import java.util.Date;
  import java.util.List;
  
  import static org.junit.Assert.assertEquals;
  import static org.mockito.ArgumentMatchers.nullable;
  import static org.mockito.ArgumentMatchers.any;
  import static org.mockito.ArgumentMatchers.anyLong;
  import static org.mockito.ArgumentMatchers.anyString;
  import static org.mockito.Mockito.doReturn;
  import static org.mockito.Mockito.lenient;
  import static org.mockito.Mockito.when;
  
  
  
  @RunWith(MockitoJUnitRunner.class)
  public class VirtualNetworkApplianceManagerImplTest {
      @Mock
      private ClusterDao _clusterDao;
  
      @Mock
      private ConfigurationDao _configDao;
  
      @Mock
      private DataCenterDao _dcDao;
  
      @Mock
      private GuestOSDao _guestOSDao;
  
      @Mock
      private HostDao _hostDao;
  
      @Mock
      private IPAddressDao _ipAddressDao;
  
      @Mock
      private UserIpv6AddressDao _ipv6Dao;
  
      @Mock
      private LoadBalancerDao _loadBalancerDao;
  
      @Mock
      private LoadBalancerVMMapDao _loadBalancerVMMapDao;
  
      @Mock
      private MonitoringServiceDao _monitorServiceDao;
  
      @Mock
      private ManagementServerHostDao _msHostDao;
  
      @Mock
      private NetworkDao _networkDao;
  
      @Mock
      private NetworkOfferingDao _networkOfferingDao;
  
      @Mock
      private NicDao _nicDao;
  
      @Mock
      private NicIpAliasDao _nicIpAliasDao;
  
      @Mock
      private OpRouterMonitorServiceDao _opRouterMonitorServiceDao;
  
      @Mock
      private PortForwardingRulesDao _pfRulesDao;
  
      @Mock
      private PhysicalNetworkServiceProviderDao _physicalProviderDao;
  
      @Mock
      private HostPodDao _podDao;
  
      @Mock
      private DomainRouterDao _routerDao;
  
      @Mock
      private FirewallRulesDao _rulesDao;
  
      @Mock
      private Site2SiteCustomerGatewayDao _s2sCustomerGatewayDao;
  
      @Mock
      private Site2SiteVpnConnectionDao _s2sVpnConnectionDao;
  
      @Mock
      private Site2SiteVpnGatewayDao _s2sVpnGatewayDao;
  
      @Mock
      private ServiceOfferingDao _serviceOfferingDao;
  
      @Mock
      private VMTemplateDao _templateDao;
  
      @Mock
      private UserDao _userDao;
  
      @Mock
      private UserStatisticsDao _userStatsDao;
  
      @Mock
      private UserStatsLogDao _userStatsLogDao;
  
      @Mock
      private UserVmDao _userVmDao;
  
      @Mock
      private VlanDao _vlanDao;
  
      @Mock
      private VMInstanceDao _vmDao;
  
      @Mock
      private VMInstanceDetailsDao _vmDetailsDao;
  
      @Mock
      private VolumeDao _volumeDao;
  
      @Mock
      private RemoteAccessVpnDao _vpnDao;
  
      @Mock
      private VpnUserDao _vpnUsersDao;
  
      @Mock
      private VirtualRouterProviderDao _vrProviderDao;
  
      //@Mock private AccountManager _accountMgr;
  
      @Mock private VirtualMachineManager _itMgr;
  
      @Mock
      private AgentManager _agentMgr;
  
      @Mock
      private CheckS2SVpnConnectionsCommand _s2sConnCommand;
  
      @Mock
      private CheckS2SVpnConnectionsAnswer _s2sVpnAnswer;
  
      @Mock
      private DomainRouterVO _router;
  
      @Mock
      private AlertManager _alertMgr;
  
      @Mock
      private Site2SiteVpnManager _s2sVpnMgr;
  
      @Mock
      private RouterControlHelper _routerControlHelper;
  
      @InjectMocks
      private VirtualNetworkApplianceManagerImpl virtualNetworkApplianceManagerImpl;
  
      @Mock
      private NetworkModel _networkModel;
  
      @Mock
      private RoutedIpv4Manager routedIpv4Manager;
  
      @Mock
      private CommandSetupHelper _commandSetupHelper;
  
      @Mock
      private VpcDao _vpcDao;
  
      @Mock
      private BGPService bgpService;
  
      @Mock
      private LoadBalancingRulesManager _lbMgr;
  
      //    @InjectMocks
      //    private VirtualNetworkApplianceManagerImpl virtualNetworkApplianceManagerImpl;
  
      @Test
      public void testDestroyRouter() throws Exception {
          //        VirtualRouter r = new DomainRouterVO(1L, 0L, 0L, "router", 0L, HypervisorType.Any, 0L, 0L,
          //                1L, false, 0, false, RedundantState.UNKNOWN, false, false, null);
          //        when(_routerDao.findById(1L)).thenReturn((DomainRouterVO)r);
          //        VirtualRouter vr = virtualNetworkApplianceManagerImpl.destroyRouter(1L, new AccountVO(1L), 0L);
          //        assertNotEquals(vr, null);
      }
  
      @Test
      public void testDeployRouterNotRedundant() throws Exception {
          //        DataCenter dc = new DataCenterVO(1L, "name", "description", "dns", null, null, null, "cidr", "domain", null,
          //                NetworkType.Basic, "zoneToken", "domainSuffix");
          //        when(_routerDao.getNextInSequence(Long.class, "id")).thenReturn(1L);
          //        when(_resourceMgr.getDefaultHypervisor(1L)).thenReturn(HypervisorType.Any);
          //        DeploymentPlan plan = new DataCenterDeployment(1L);
          //        VirtualRouter vr = virtualNetworkApplianceManagerImpl.deployRouter(new AccountVO(1L), new DeployDestination(dc,null,null,null), plan, null, false,
          //                new VirtualRouterProviderVO(), 0L, null, new LinkedHashMap<Network, List<? extends NicProfile>> (), true /* start the router */,
          //                null);
          //        // TODO: more elaborate mocking needed to have a vr returned
          //assertEquals(vr, null);
      }
  
      @Test
      public void testUpdateSite2SiteVpnConnectionState() throws Exception{
  
          DomainRouterVO router = new DomainRouterVO(1L, 1L, 1L, "First testing router", 1L, Hypervisor.HypervisorType.XenServer, 1L, 1L, 1L, 1L, false, VirtualRouter.RedundantState.PRIMARY, true, true, 1L);
          router.setState(VirtualMachine.State.Running);
          router.setPrivateIpAddress("192.168.50.15");
  
          List<DomainRouterVO> routers = new ArrayList<DomainRouterVO>();
          routers.add(router);
  
          Site2SiteVpnConnectionVO conn = new Site2SiteVpnConnectionVO(1L, 1L, 1L, 1L, false);
          Site2SiteVpnConnectionVO conn1 = new Site2SiteVpnConnectionVO(1L, 1L, 1L, 1L, false);
          conn.setState(Site2SiteVpnConnection.State.Disconnected);
          conn1.setState(Site2SiteVpnConnection.State.Disconnected);
          List<Site2SiteVpnConnectionVO> conns = new ArrayList<Site2SiteVpnConnectionVO>();
          conns.add(conn);
          conns.add(conn1);
  
          Site2SiteCustomerGatewayVO gw = new Site2SiteCustomerGatewayVO("Testing gateway", 1L, 1L, "192.168.50.15", "Guest List", "ipsecPsk", "ikePolicy", "espPolicy", 1L, 1L, true, true, false, "ike");
          HostVO hostVo = new HostVO(1L, "Testing host", Host.Type.Routing, "192.168.50.15", "privateNetmask", "privateMacAddress", "publicIpAddress", "publicNetmask", "publicMacAddress", "storageIpAddress", "storageNetmask", "storageMacAddress", "deuxStorageIpAddress", "duxStorageNetmask", "deuxStorageMacAddress", "guid", Status.Up, "version", "iqn", new Date() , 1L, 1L, 1L, 1L, "parent", 20L, Storage.StoragePoolType.Gluster);
          hostVo.setManagementServerId(ManagementServerNode.getManagementServerId());
  
          ArrayList<String> ipList = new ArrayList<>();
          ipList.add("192.168.50.15");
  
          _s2sConnCommand = new CheckS2SVpnConnectionsCommand(ipList);
  
          when(_s2sVpnMgr.getConnectionsForRouter(router)).thenReturn(conns);
          when(_s2sVpnConnectionDao.persist(conn)).thenReturn(null);
          when(_s2sCustomerGatewayDao.findById(conn.getCustomerGatewayId())).thenReturn(gw);
          when(_hostDao.findById(router.getHostId())).thenReturn(hostVo);
          when(_routerControlHelper.getRouterControlIp(router.getId())).thenReturn("192.168.50.15");
          doReturn(_s2sVpnAnswer).when(_agentMgr).easySend(nullable(Long.class), nullable(CheckS2SVpnConnectionsCommand.class));
          when(_s2sVpnAnswer.getResult()).thenReturn(true);
          when(_s2sVpnConnectionDao.acquireInLockTable(conn.getId())).thenReturn(conn);
          when(_s2sVpnAnswer.isIPPresent("192.168.50.15")).thenReturn(true);
          when(_s2sVpnAnswer.isConnected("192.168.50.15")).thenReturn(true);
          lenient().doNothing().when(_alertMgr).sendAlert(any(AlertManager.AlertType.class), anyLong(), anyLong(), anyString(), anyString());
  
          virtualNetworkApplianceManagerImpl.updateSite2SiteVpnConnectionState(routers);
  
          for(Site2SiteVpnConnection connection : conns){
              assertEquals(Site2SiteVpnConnection.State.Connected, connection.getState());
          }
      }
  
      @Test
      public void checkLogrotateTimerPatternTestDoNotMatchWithRegex(){
          String foo = "non-sense";
          boolean result = virtualNetworkApplianceManagerImpl.checkLogrotateTimerPattern(foo);
          Assert.assertFalse(result);
          foo = "*";
          result = virtualNetworkApplianceManagerImpl.checkLogrotateTimerPattern(foo);
          Assert.assertFalse(result);
      }
  
      @Test
      public void checkLogrotateTimerPatternTestMatchesWithRegex(){
          String foo = "hourly";
          boolean result = virtualNetworkApplianceManagerImpl.checkLogrotateTimerPattern(foo);
          Assert.assertTrue(result);
          foo = "*:00:00";
          result = virtualNetworkApplianceManagerImpl.checkLogrotateTimerPattern(foo);
          Assert.assertTrue(result);
          foo = "*:*:00";
          result = virtualNetworkApplianceManagerImpl.checkLogrotateTimerPattern(foo);
          Assert.assertTrue(result);
      }
  
      @Test
      public void testFinalizeNetworkRulesForNetwork() {
          Long guestNetworkId = 10L;
          Commands cmds = new Commands(Command.OnError.Stop);
          DomainRouterVO router = Mockito.mock(DomainRouterVO.class);
  
          NetworkVO network = Mockito.mock(NetworkVO.class);
          when(_networkDao.findById(guestNetworkId)).thenReturn(network);
          when(network.getVpcId()).thenReturn(null);
          when(routedIpv4Manager.isDynamicRoutedNetwork(network)).thenReturn(true);
          List<? extends BgpPeer> bgpPeers = Mockito.mock(List.class);
          doReturn(bgpPeers).when(bgpService).getBgpPeersForNetwork(network);
          virtualNetworkApplianceManagerImpl.finalizeNetworkRulesForNetwork(cmds, router, Network.Provider.VirtualRouter, guestNetworkId);
  
          Mockito.verify(_commandSetupHelper).createBgpPeersCommands(bgpPeers, router, cmds, network);
      }
  
      @Test
      public void testFinalizeNetworkRulesForVpcNetwork() {
          Long guestNetworkId = 10L;
          Long vpcId = 11L;
          Commands cmds = new Commands(Command.OnError.Stop);
          DomainRouterVO router = Mockito.mock(DomainRouterVO.class);
  
          NetworkVO network = Mockito.mock(NetworkVO.class);
          when(_networkDao.findById(guestNetworkId)).thenReturn(network);
          when(network.getVpcId()).thenReturn(vpcId);
          VpcVO vpc = Mockito.mock(VpcVO.class);
          when(_vpcDao.findById(vpcId)).thenReturn(vpc);
          when(routedIpv4Manager.isDynamicRoutedVpc(vpc)).thenReturn(true);
          List<? extends BgpPeer> bgpPeers = Mockito.mock(List.class);
          doReturn(bgpPeers).when(bgpService).getBgpPeersForVpc(vpc);
  
          virtualNetworkApplianceManagerImpl.finalizeNetworkRulesForNetwork(cmds, router, Network.Provider.VirtualRouter, guestNetworkId);
  
          Mockito.verify(_commandSetupHelper).createBgpPeersCommands(bgpPeers, router, cmds, network);
      }
  
      @Test
      public void testUpdateWithLbRuleSslCertificates() {
          StringBuilder loadBalancingData = new StringBuilder();
          LoadBalancerVO loadBalancer = Mockito.mock(LoadBalancerVO.class);
          when(loadBalancer.getLbProtocol()).thenReturn(NetUtils.SSL_PROTO);
          when(loadBalancer.getId()).thenReturn(1L);
          when(loadBalancer.getSourcePortStart()).thenReturn(443);
          LoadBalancingRule.LbSslCert lbSslCert = Mockito.mock(LoadBalancingRule.LbSslCert.class);
          when(lbSslCert.isRevoked()).thenReturn(false);
          when(_lbMgr.getLbSslCert(1L)).thenReturn(lbSslCert);
          String sourceIp = "1.2.3.4";
  
          virtualNetworkApplianceManagerImpl.updateWithLbRuleSslCertificates(loadBalancingData, loadBalancer, sourceIp);
  
          Assert.assertEquals(",sslcert=1_2_3_4-443.pem",  loadBalancingData.toString());
      }
  }
  