test: add, refactor ipv6 network, vpc tests

api/src/main/java/org/apache/cloudstack/api/response/VpcResponse.java

@@ -253,4 +253,8 @@ public void setResourceIconResponse(ResourceIconResponse icon) {
     public void setIpv6Routes(Set<Ipv6RouteResponse> ipv6Routes) {
         this.ipv6Routes = ipv6Routes;
     }
+
+    public Set<Ipv6RouteResponse> getIpv6Routes() {
+        return ipv6Routes;
+    }
 }

engine/schema/src/main/java/com/cloud/offerings/dao/NetworkOfferingDaoImpl.java

@@ -279,7 +279,7 @@ public NetUtils.InternetProtocol getNetworkOfferingInternetProtocol(long offerin
     }
 
     @Override
-    public NetUtils.InternetProtocol getNetworkOfferingInternetProtocol(long offeringId,NetUtils.InternetProtocol defaultProtocol) {
+    public NetUtils.InternetProtocol getNetworkOfferingInternetProtocol(long offeringId, NetUtils.InternetProtocol defaultProtocol) {
         NetUtils.InternetProtocol protocol = getNetworkOfferingInternetProtocol(offeringId);
         if (protocol == null) {
             return defaultProtocol;

engine/schema/src/test/java/com/cloud/offerings/dao/NetworkOfferingDaoImplTest.java

@@ -0,0 +1,93 @@
+// 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.offerings.dao;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+
+import com.cloud.offering.NetworkOffering;
+import com.cloud.utils.net.NetUtils;
+
+public class NetworkOfferingDaoImplTest {
+    @Mock
+    NetworkOfferingDetailsDao detailsDao;
+
+    @InjectMocks
+    NetworkOfferingDaoImpl networkOfferingDao = new NetworkOfferingDaoImpl();
+
+    final long offeringId = 1L;
+
+    @Before
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+    }
+
+    @Test
+    public void testGetNetworkOfferingInternetProtocol() {
+        Mockito.when(detailsDao.getDetail(offeringId, NetworkOffering.Detail.internetProtocol)).thenReturn(null);
+        NetUtils.InternetProtocol protocol = networkOfferingDao.getNetworkOfferingInternetProtocol(offeringId);
+        Assert.assertNull(protocol);
+
+        Mockito.when(detailsDao.getDetail(offeringId, NetworkOffering.Detail.internetProtocol)).thenReturn("IPv4");
+        protocol = networkOfferingDao.getNetworkOfferingInternetProtocol(offeringId);
+        Assert.assertEquals(NetUtils.InternetProtocol.IPv4, protocol);
+
+        Mockito.when(detailsDao.getDetail(offeringId, NetworkOffering.Detail.internetProtocol)).thenReturn("IPv6");
+        protocol = networkOfferingDao.getNetworkOfferingInternetProtocol(offeringId);
+        Assert.assertEquals(NetUtils.InternetProtocol.IPv6, protocol);
+
+        Mockito.when(detailsDao.getDetail(offeringId, NetworkOffering.Detail.internetProtocol)).thenReturn("DualStack");
+        protocol = networkOfferingDao.getNetworkOfferingInternetProtocol(offeringId);
+        Assert.assertEquals(NetUtils.InternetProtocol.DualStack, protocol);
+    }
+
+    @Test
+    public void testGetNetworkOfferingInternetProtocolWithDefault() {
+        Mockito.when(detailsDao.getDetail(offeringId, NetworkOffering.Detail.internetProtocol)).thenReturn(null);
+        NetUtils.InternetProtocol protocol = networkOfferingDao.getNetworkOfferingInternetProtocol(offeringId, NetUtils.InternetProtocol.IPv4);
+        Assert.assertEquals(NetUtils.InternetProtocol.IPv4, protocol);
+
+        Mockito.when(detailsDao.getDetail(offeringId, NetworkOffering.Detail.internetProtocol)).thenReturn("IPv6");
+        protocol = networkOfferingDao.getNetworkOfferingInternetProtocol(offeringId, NetUtils.InternetProtocol.IPv4);
+        Assert.assertEquals(NetUtils.InternetProtocol.IPv6, protocol);
+    }
+
+    @Test
+    public void testIsIpv6Supported() {
+        Mockito.when(detailsDao.getDetail(offeringId, NetworkOffering.Detail.internetProtocol)).thenReturn("");
+        boolean result = networkOfferingDao.isIpv6Supported(offeringId);
+        Assert.assertFalse(result);
+
+        Mockito.when(detailsDao.getDetail(offeringId, NetworkOffering.Detail.internetProtocol)).thenReturn("IPv4");
+        result = networkOfferingDao.isIpv6Supported(offeringId);
+        Assert.assertFalse(result);
+
+        Mockito.when(detailsDao.getDetail(offeringId, NetworkOffering.Detail.internetProtocol)).thenReturn("IPv6");
+        result = networkOfferingDao.isIpv6Supported(offeringId);
+        Assert.assertTrue(result);
+
+        Mockito.when(detailsDao.getDetail(offeringId, NetworkOffering.Detail.internetProtocol)).thenReturn("DualStack");
+        result = networkOfferingDao.isIpv6Supported(offeringId);
+        Assert.assertTrue(result);
+    }
+}

server/src/test/java/com/cloud/configuration/ConfigurationManagerTest.java

@@ -39,6 +39,11 @@
 import java.util.Random;
 import java.util.UUID;
 
+import org.apache.cloudstack.api.command.admin.network.CreateGuestNetworkIpv6PrefixCmd;
+import org.apache.cloudstack.api.command.admin.network.CreateNetworkOfferingCmd;
+import org.apache.cloudstack.api.command.admin.network.DeleteGuestNetworkIpv6PrefixCmd;
+import org.apache.cloudstack.api.command.admin.network.ListGuestNetworkIpv6PrefixesCmd;
+import org.apache.cloudstack.api.command.admin.vlan.CreateVlanIpRangeCmd;
 import org.apache.cloudstack.api.command.admin.vlan.DedicatePublicIpRangeCmd;
 import org.apache.cloudstack.api.command.admin.vlan.ReleasePublicIpRangeCmd;
 import org.apache.cloudstack.api.command.user.network.ListNetworkOfferingsCmd;
@@ -58,34 +63,44 @@
 import org.mockito.Mockito;
 import org.mockito.MockitoAnnotations;
 import org.mockito.Spy;
+import org.mockito.stubbing.Answer;
 
 import com.cloud.api.query.dao.NetworkOfferingJoinDao;
 import com.cloud.api.query.vo.NetworkOfferingJoinVO;
 import com.cloud.configuration.Resource.ResourceType;
 import com.cloud.dc.AccountVlanMapVO;
 import com.cloud.dc.ClusterVO;
 import com.cloud.dc.DataCenter.NetworkType;
+import com.cloud.dc.DataCenterGuestIpv6Prefix;
+import com.cloud.dc.DataCenterGuestIpv6PrefixVO;
 import com.cloud.dc.DataCenterVO;
 import com.cloud.dc.HostPodVO;
 import com.cloud.dc.Vlan;
 import com.cloud.dc.VlanVO;
 import com.cloud.dc.dao.AccountVlanMapDao;
 import com.cloud.dc.dao.ClusterDao;
 import com.cloud.dc.dao.DataCenterDao;
+import com.cloud.dc.dao.DataCenterGuestIpv6PrefixDao;
 import com.cloud.dc.dao.DataCenterIpAddressDao;
 import com.cloud.dc.dao.DomainVlanMapDao;
 import com.cloud.dc.dao.HostPodDao;
 import com.cloud.dc.dao.VlanDao;
+import com.cloud.exception.InsufficientCapacityException;
 import com.cloud.exception.InvalidParameterValueException;
+import com.cloud.exception.ResourceAllocationException;
+import com.cloud.exception.ResourceUnavailableException;
 import com.cloud.host.HostVO;
 import com.cloud.host.dao.HostDao;
 import com.cloud.network.IpAddressManager;
+import com.cloud.network.Ipv6GuestPrefixSubnetNetworkMapVO;
 import com.cloud.network.Network;
 import com.cloud.network.Network.Capability;
 import com.cloud.network.NetworkModel;
+import com.cloud.network.Networks;
 import com.cloud.network.dao.FirewallRulesDao;
 import com.cloud.network.dao.IPAddressDao;
 import com.cloud.network.dao.IPAddressVO;
+import com.cloud.network.dao.Ipv6GuestPrefixSubnetNetworkMapDao;
 import com.cloud.network.dao.PhysicalNetworkDao;
 import com.cloud.network.dao.PhysicalNetworkVO;
 import com.cloud.projects.ProjectManager;
@@ -104,6 +119,7 @@
 import com.cloud.utils.db.TransactionLegacy;
 import com.cloud.utils.exception.CloudRuntimeException;
 import com.cloud.utils.net.Ip;
+import com.cloud.utils.net.NetUtils;
 import com.cloud.vm.VMInstanceVO;
 import com.cloud.vm.dao.VMInstanceDao;
 
@@ -169,6 +185,10 @@ public class ConfigurationManagerTest {
     ConfigurationDao _configDao;
     @Mock
     DiskOfferingVO diskOfferingVOMock;
+    @Mock
+    DataCenterGuestIpv6PrefixDao dataCenterGuestIpv6PrefixDao;
+    @Mock
+    Ipv6GuestPrefixSubnetNetworkMapDao ipv6GuestPrefixSubnetNetworkMapDao;
 
     VlanVO vlan = new VlanVO(Vlan.VlanType.VirtualNetwork, "vlantag", "vlangateway", "vlannetmask", 1L, "iprange", 1L, 1L, null, null, null);
 
@@ -1002,4 +1022,152 @@ public void updateDiskOfferingTagsIfIsNotNullTestWhenTagsIsNotNull(){
         this.configurationMgr.updateOfferingTagsIfIsNotNull(tags, diskOfferingVOMock);
         Mockito.verify(configurationMgr, Mockito.times(1)).updateOfferingTagsIfIsNotNull(tags, diskOfferingVOMock);
     }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testInvalidCreateDataCenterGuestIpv6Prefix() {
+        CreateGuestNetworkIpv6PrefixCmd cmd = Mockito.mock(CreateGuestNetworkIpv6PrefixCmd.class);
+        Mockito.when(cmd.getZoneId()).thenReturn(1L);
+        Mockito.when(cmd.getPrefix()).thenReturn("Invalid");
+        Mockito.when(_zoneDao.findById(Mockito.anyLong())).thenReturn(Mockito.mock(DataCenterVO.class));
+        configurationMgr.createDataCenterGuestIpv6Prefix(cmd);
+    }
+
+    @Test(expected = InvalidParameterValueException.class)
+    public void testWrongCreateDataCenterGuestIpv6Prefix() {
+        CreateGuestNetworkIpv6PrefixCmd cmd = Mockito.mock(CreateGuestNetworkIpv6PrefixCmd.class);
+        Mockito.when(cmd.getZoneId()).thenReturn(1L);
+        Mockito.when(cmd.getPrefix()).thenReturn("fd17:5:8a43:e2a4:c000::/66");
+        Mockito.when(_zoneDao.findById(Mockito.anyLong())).thenReturn(Mockito.mock(DataCenterVO.class));
+        configurationMgr.createDataCenterGuestIpv6Prefix(cmd);
+    }
+
+    @Test(expected = InvalidParameterValueException.class)
+    public void testConflictingCreateDataCenterGuestIpv6Prefix() {
+        CreateGuestNetworkIpv6PrefixCmd cmd = Mockito.mock(CreateGuestNetworkIpv6PrefixCmd.class);
+        Mockito.when(cmd.getZoneId()).thenReturn(1L);
+        Mockito.when(cmd.getPrefix()).thenReturn("fd17:5:8a43:e2a5::/64");
+        Mockito.when(_zoneDao.findById(Mockito.anyLong())).thenReturn(Mockito.mock(DataCenterVO.class));
+        DataCenterGuestIpv6PrefixVO prefix = Mockito.mock(DataCenterGuestIpv6PrefixVO.class);
+        Mockito.when(prefix.getPrefix()).thenReturn("fd17:5:8a43:e2a4::/62");
+        Mockito.when(dataCenterGuestIpv6PrefixDao.listByDataCenterId(Mockito.anyLong())).thenReturn(List.of(prefix));
+        configurationMgr.createDataCenterGuestIpv6Prefix(cmd);
+    }
+
+    @Test
+    public void testCreateDataCenterGuestIpv6Prefix() {
+        final Long zoneId = 1L;
+        final String prefix = "fd17:5:8a43:e2a5::/64";
+        CreateGuestNetworkIpv6PrefixCmd cmd = Mockito.mock(CreateGuestNetworkIpv6PrefixCmd.class);
+        Mockito.when(cmd.getZoneId()).thenReturn(zoneId);
+        Mockito.when(cmd.getPrefix()).thenReturn(prefix);
+        Mockito.when(_zoneDao.findById(Mockito.anyLong())).thenReturn(Mockito.mock(DataCenterVO.class));
+        Mockito.when(dataCenterGuestIpv6PrefixDao.listByDataCenterId(Mockito.anyLong())).thenReturn(new ArrayList<>());
+        final List<DataCenterGuestIpv6PrefixVO> persistedPrefix = new ArrayList<>();
+        Mockito.when(dataCenterGuestIpv6PrefixDao.persist(Mockito.any(DataCenterGuestIpv6PrefixVO.class))).thenAnswer((Answer<DataCenterGuestIpv6PrefixVO>) invocation -> {
+            DataCenterGuestIpv6PrefixVO prefixVO = (DataCenterGuestIpv6PrefixVO)invocation.getArgument(0);
+            persistedPrefix.add(prefixVO);
+            return prefixVO;
+        });
+        configurationMgr.createDataCenterGuestIpv6Prefix(cmd);
+        Assert.assertEquals(1, persistedPrefix.size());
+        DataCenterGuestIpv6PrefixVO prefixVO = persistedPrefix.get(0);
+        Assert.assertEquals(zoneId, prefixVO.getDataCenterId());
+        Assert.assertEquals(prefix, prefixVO.getPrefix());
+    }
+
+    @Test
+    public void testListDataCenterGuestIpv6Prefixes() {
+        ListGuestNetworkIpv6PrefixesCmd cmd = Mockito.mock(ListGuestNetworkIpv6PrefixesCmd.class);
+        Mockito.when(cmd.getId()).thenReturn(1L);
+        Mockito.when(cmd.getZoneId()).thenReturn(1L);
+        Mockito.when(_zoneDao.findById(Mockito.anyLong())).thenReturn(Mockito.mock(DataCenterVO.class));
+        Mockito.when(dataCenterGuestIpv6PrefixDao.findById(Mockito.anyLong())).thenReturn(Mockito.mock(DataCenterGuestIpv6PrefixVO.class));
+        Mockito.when(dataCenterGuestIpv6PrefixDao.listByDataCenterId(Mockito.anyLong()))
+                .thenReturn(List.of(Mockito.mock(DataCenterGuestIpv6PrefixVO.class), Mockito.mock(DataCenterGuestIpv6PrefixVO.class)));
+        Mockito.when(dataCenterGuestIpv6PrefixDao.listAll())
+                .thenReturn(List.of(Mockito.mock(DataCenterGuestIpv6PrefixVO.class),
+                        Mockito.mock(DataCenterGuestIpv6PrefixVO.class),
+                        Mockito.mock(DataCenterGuestIpv6PrefixVO.class)));
+        List<? extends DataCenterGuestIpv6Prefix> prefixes = configurationMgr.listDataCenterGuestIpv6Prefixes(cmd);
+        Assert.assertEquals(1, prefixes.size());
+        ListGuestNetworkIpv6PrefixesCmd cmd1 = Mockito.mock(ListGuestNetworkIpv6PrefixesCmd.class);
+        Mockito.when(cmd1.getId()).thenReturn(null);
+        Mockito.when(cmd1.getZoneId()).thenReturn(1L);
+        prefixes = configurationMgr.listDataCenterGuestIpv6Prefixes(cmd1);
+        Assert.assertEquals(2, prefixes.size());
+        ListGuestNetworkIpv6PrefixesCmd cmd2 = Mockito.mock(ListGuestNetworkIpv6PrefixesCmd.class);
+        Mockito.when(cmd2.getId()).thenReturn(null);
+        Mockito.when(cmd2.getZoneId()).thenReturn(null);
+        prefixes = configurationMgr.listDataCenterGuestIpv6Prefixes(cmd2);
+        Assert.assertEquals(3, prefixes.size());
+    }
+
+    @Test(expected = InvalidParameterValueException.class)
+    public void testInvalidDeleteDataCenterGuestIpv6Prefix() {
+        DeleteGuestNetworkIpv6PrefixCmd cmd = Mockito.mock(DeleteGuestNetworkIpv6PrefixCmd.class);
+        Mockito.when(cmd.getId()).thenReturn(1L);
+        Mockito.when(dataCenterGuestIpv6PrefixDao.findById(Mockito.anyLong())).thenReturn(null);
+        configurationMgr.deleteDataCenterGuestIpv6Prefix(cmd);
+    }
+
+    @Test(expected = CloudRuntimeException.class)
+    public void testUsedDeleteDataCenterGuestIpv6Prefix() {
+        final Long prefixId = 1L;
+        DeleteGuestNetworkIpv6PrefixCmd cmd = Mockito.mock(DeleteGuestNetworkIpv6PrefixCmd.class);
+        Mockito.when(cmd.getId()).thenReturn(prefixId);
+        DataCenterGuestIpv6PrefixVO prefixVO = Mockito.mock(DataCenterGuestIpv6PrefixVO.class);
+        Mockito.when(prefixVO.getId()).thenReturn(prefixId);
+        Mockito.when(dataCenterGuestIpv6PrefixDao.findById(Mockito.anyLong())).thenReturn(prefixVO);
+        Mockito.when(ipv6GuestPrefixSubnetNetworkMapDao.listUsedByPrefix(Mockito.anyLong()))
+                .thenReturn(List.of(Mockito.mock(Ipv6GuestPrefixSubnetNetworkMapVO.class)));
+        configurationMgr.deleteDataCenterGuestIpv6Prefix(cmd);
+    }
+
+    @Test
+    public void testDeleteDataCenterGuestIpv6Prefix() {
+        final Long prefixId = 1L;
+        DeleteGuestNetworkIpv6PrefixCmd cmd = Mockito.mock(DeleteGuestNetworkIpv6PrefixCmd.class);
+        Mockito.when(cmd.getId()).thenReturn(prefixId);
+        DataCenterGuestIpv6PrefixVO prefixVO = Mockito.mock(DataCenterGuestIpv6PrefixVO.class);
+        Mockito.when(prefixVO.getId()).thenReturn(prefixId);
+        Mockito.when(dataCenterGuestIpv6PrefixDao.findById(Mockito.anyLong())).thenReturn(prefixVO);
+        Mockito.when(ipv6GuestPrefixSubnetNetworkMapDao.listUsedByPrefix(Mockito.anyLong())).thenReturn(new ArrayList<>());
+        final List<Long> removedPrefix = new ArrayList<>();
+        Mockito.when(dataCenterGuestIpv6PrefixDao.remove(Mockito.anyLong())).thenAnswer((Answer<Boolean>) invocation -> {
+            removedPrefix.add(invocation.getArgument(0));
+            return true;
+        });
+        configurationMgr.deleteDataCenterGuestIpv6Prefix(cmd);
+        Assert.assertEquals(1, removedPrefix.size());
+        Assert.assertEquals(prefixId, removedPrefix.get(0));
+    }
+
+    @Test(expected = InvalidParameterValueException.class)
+    public void testInvalidNetworkTypeCreateIpv6NetworkOffering() {
+        CreateNetworkOfferingCmd cmd = Mockito.mock(CreateNetworkOfferingCmd.class);
+        Mockito.when(cmd.getTraffictype()).thenReturn(Networks.TrafficType.Guest.toString());
+        Mockito.when(cmd.getGuestIpType()).thenReturn(Network.GuestType.L2.toString());
+        Mockito.when(cmd.getInternetProtocol()).thenReturn(NetUtils.InternetProtocol.DualStack.toString());
+        configurationMgr.createNetworkOffering(cmd);
+    }
+
+    @Test(expected = InvalidParameterValueException.class)
+    public void testDisabledConfigCreateIpv6NetworkOffering() {
+        CreateNetworkOfferingCmd cmd = Mockito.mock(CreateNetworkOfferingCmd.class);
+        Mockito.when(cmd.getTraffictype()).thenReturn(Networks.TrafficType.Guest.toString());
+        Mockito.when(cmd.getGuestIpType()).thenReturn(Network.GuestType.Isolated.toString());
+        Mockito.when(cmd.getInternetProtocol()).thenReturn(NetUtils.InternetProtocol.DualStack.toString());
+        configurationMgr.createNetworkOffering(cmd);
+    }
+
+    @Test(expected = InvalidParameterValueException.class)
+    public void testWrongIpv6CreateVlanAndPublicIpRange() {
+        CreateVlanIpRangeCmd cmd = Mockito.mock(CreateVlanIpRangeCmd.class);
+        Mockito.when(cmd.getIp6Cidr()).thenReturn("fd17:5:8a43:e2a4:c000::/66");
+        try {
+            configurationMgr.createVlanAndPublicIpRange(cmd);
+        } catch (InsufficientCapacityException | ResourceUnavailableException | ResourceAllocationException e) {
+            throw new RuntimeException(e);
+        }
+    }
 }