Ipv6AddressManagerTest.java

// 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.mockito.Mockito.mock;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;

import com.cloud.dc.DataCenter;
import com.cloud.exception.InsufficientAddressCapacityException;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.network.IpAddress.State;
import com.cloud.network.Network.IpAddresses;
import com.cloud.network.dao.IPAddressDaoImpl;
import com.cloud.network.dao.IPAddressVO;
import com.cloud.network.dao.UserIpv6AddressDaoImpl;
import com.cloud.user.Account;
import com.cloud.utils.Pair;
import com.cloud.utils.net.NetUtils;
import com.cloud.vm.NicProfile;
import com.cloud.vm.dao.NicSecondaryIpDaoImpl;
import com.cloud.vm.dao.NicSecondaryIpVO;

public class Ipv6AddressManagerTest {

    @InjectMocks
    Ipv6AddressManagerImpl ip6Manager = Mockito.spy(new Ipv6AddressManagerImpl());

    @InjectMocks
    NicSecondaryIpDaoImpl nicSecondaryIpDao = Mockito.spy(new NicSecondaryIpDaoImpl());

    @InjectMocks
    UserIpv6AddressDaoImpl ipv6Dao = Mockito.spy(new UserIpv6AddressDaoImpl());

    @InjectMocks
    IpAddressManagerImpl ipAddressManager = Mockito.spy(new IpAddressManagerImpl());

    @InjectMocks
    NetworkModelImpl networkModel = Mockito.mock(NetworkModelImpl.class);// = Mockito.spy(new NetworkModelImpl());

    @InjectMocks
    IPAddressDaoImpl ipAddressDao = Mockito.spy(new IPAddressDaoImpl());

    private Network network = mockNetwork();

    @Before
    public void setup() {
        MockitoAnnotations.initMocks(this);
    }

    @Test
    public void isIp6TakenTestNoNull() {
        setIsIp6TakenTest(new UserIpv6AddressVO(), new NicSecondaryIpVO(0l, "ipaddr", 0l, 0l, 0l, 0l));
        boolean result = ip6Manager.isIp6Taken(network, "requestedIpv6");
        assertAndVerifyIsIp6Taken(true, result);
    }

    @Test
    public void isIp6TakenTestSecIpNull() {
        setIsIp6TakenTest(new UserIpv6AddressVO(), null);
        boolean result = ip6Manager.isIp6Taken(network, "requestedIpv6");
        assertAndVerifyIsIp6Taken(true, result);
    }

    @Test
    public void isIp6TakenTestUserIpv6AddressNull() {
        setIsIp6TakenTest(null, new NicSecondaryIpVO(0l, "ipaddr", 0l, 0l, 0l, 0l));
        boolean result = ip6Manager.isIp6Taken(network, "requestedIpv6");
        assertAndVerifyIsIp6Taken(true, result);
    }

    @Test
    public void isIp6TakenTestAllNull() {
        setIsIp6TakenTest(null, null);
        boolean result = ip6Manager.isIp6Taken(network, "requestedIpv6");
        assertAndVerifyIsIp6Taken(false, result);
    }

    private void assertAndVerifyIsIp6Taken(boolean expected, boolean result) {
        Assert.assertEquals(expected, result);
        Mockito.verify(ipv6Dao).findByNetworkIdAndIp(Mockito.anyLong(), Mockito.anyString());
        Mockito.verify(nicSecondaryIpDao).findByIp6AddressAndNetworkId(Mockito.anyString(), Mockito.anyLong());
    }

    private void setIsIp6TakenTest(UserIpv6AddressVO userIpv6, NicSecondaryIpVO nicSecondaryIp) {
        Mockito.doReturn(userIpv6).when(ipv6Dao).findByNetworkIdAndIp(Mockito.anyLong(), Mockito.anyString());
        Mockito.doReturn(nicSecondaryIp).when(nicSecondaryIpDao).findByIp6AddressAndNetworkId(Mockito.anyString(), Mockito.anyLong());
    }

    private Network mockNetwork() {
        Network network = mock(Network.class);
        Mockito.when(network.getId()).thenReturn(0l);
        Mockito.when(network.getIp6Cidr()).thenReturn("2001:db8::/32");
        return network;
    }

    @Test
    public void allocatePublicIp6ForGuestNicTestNoException() throws InsufficientAddressCapacityException {
        Account owner = Mockito.mock(Account.class);
        String requestedIpv6 = setCheckIfCanAllocateIpv6AddresscTest("2001:db8::10", false, false);

        String returnedIp = ip6Manager.allocatePublicIp6ForGuestNic(network, 0l, owner, requestedIpv6);

        Mockito.verify(ip6Manager).checkIfCanAllocateIpv6Address(network, requestedIpv6);
        Assert.assertEquals(requestedIpv6, returnedIp);
    }

    @Test(expected = InsufficientAddressCapacityException.class)
    public void checkIfCanAllocateIpv6AddressTestIp6IsTaken() throws InsufficientAddressCapacityException {
        String requestedIpv6 = setCheckIfCanAllocateIpv6AddresscTest("2001:db8::10", true, false);

        ip6Manager.checkIfCanAllocateIpv6Address(network, requestedIpv6);

        verifyCheckIfCanAllocateIpv6AddressTest(network, requestedIpv6, 1, 0);
    }

    @Test(expected = InvalidParameterValueException.class)
    public void checkIfCanAllocateIpv6AddressTestIpIsIpEqualsGatewayOrNetworkOfferingsEmpty() throws InsufficientAddressCapacityException {
        String requestedIpv6 = setCheckIfCanAllocateIpv6AddresscTest("2001:db8::10", false, true);

        ip6Manager.checkIfCanAllocateIpv6Address(network, requestedIpv6);

        verifyCheckIfCanAllocateIpv6AddressTest(network, requestedIpv6, 1, 1);
    }

    @Test(expected = InvalidParameterValueException.class)
    public void checkIfCanAllocateIpv6AddressTestIpINotInTheNetwork() throws InsufficientAddressCapacityException {
        String requestedIpv6 = "2002:db8::10";
        setCheckIfCanAllocateIpv6AddresscTest(requestedIpv6, false, false);

        ip6Manager.checkIfCanAllocateIpv6Address(network, requestedIpv6);

        verifyCheckIfCanAllocateIpv6AddressTest(network, requestedIpv6, 1, 1);
    }

    private void verifyCheckIfCanAllocateIpv6AddressTest(Network network, String requestedIpv6, int isIp6TakenTimes, int isIpEqualsGatewayTimes) {
        Mockito.verify(ip6Manager, Mockito.times(isIp6TakenTimes)).isIp6Taken(network, requestedIpv6);
        Mockito.verify(ipAddressManager, Mockito.times(isIpEqualsGatewayTimes)).isIpEqualsGatewayOrNetworkOfferingsEmpty(network, requestedIpv6);
    }

    private String setCheckIfCanAllocateIpv6AddresscTest(String requestedIpv6, boolean isIp6Taken, boolean isIpEqualsGatewayOrNetworkOfferingsEmpty) {
        Mockito.doReturn(isIp6Taken).when(ip6Manager).isIp6Taken(Mockito.eq(network), Mockito.anyString());
        Mockito.doReturn(isIpEqualsGatewayOrNetworkOfferingsEmpty).when(ipAddressManager).isIpEqualsGatewayOrNetworkOfferingsEmpty(network, requestedIpv6);
        NetUtils.isIp6InNetwork(requestedIpv6, network.getIp6Cidr());
        return requestedIpv6;
    }

    @Test
    public void acquireGuestIpv6AddressTest() throws InsufficientAddressCapacityException {
        setAcquireGuestIpv6AddressTest(true, State.Free);
        String requestedIpv6 = setCheckIfCanAllocateIpv6AddresscTest("2001:db8::10", false, false);

        ip6Manager.acquireGuestIpv6Address(network, requestedIpv6);

        verifyAcquireGuestIpv6AddressTest();
    }

    private void verifyAcquireGuestIpv6AddressTest() {
        Mockito.verify(networkModel).areThereIPv6AddressAvailableInNetwork(Mockito.anyLong());
        Mockito.verify(networkModel).checkRequestedIpAddresses(Mockito.anyLong(), Mockito.any(IpAddresses.class));
        Mockito.verify(ipAddressDao).findByIpAndSourceNetworkId(Mockito.anyLong(), Mockito.anyString());
    }

    @Test(expected = InsufficientAddressCapacityException.class)
    public void acquireGuestIpv6AddressTestUnavailableIp() throws InsufficientAddressCapacityException {
        setAcquireGuestIpv6AddressTest(false, State.Free);
        String requestedIpv6 = setCheckIfCanAllocateIpv6AddresscTest("2001:db8::10", false, false);

        ip6Manager.acquireGuestIpv6Address(network, requestedIpv6);

        verifyAcquireGuestIpv6AddressTest();
    }

    @Test(expected = InsufficientAddressCapacityException.class)
    public void acquireGuestIpv6AddressTestStateAllocating() throws InsufficientAddressCapacityException {
        setAcquireGuestIpv6AddressTest(false, State.Allocating);
        String requestedIpv6 = setCheckIfCanAllocateIpv6AddresscTest("2001:db8::10", false, false);

        ip6Manager.acquireGuestIpv6Address(network, requestedIpv6);

        verifyAcquireGuestIpv6AddressTest();
    }

    @Test(expected = InsufficientAddressCapacityException.class)
    public void acquireGuestIpv6AddressTestStateAllocated() throws InsufficientAddressCapacityException {
        setAcquireGuestIpv6AddressTest(false, State.Allocated);
        String requestedIpv6 = setCheckIfCanAllocateIpv6AddresscTest("2001:db8::10", false, false);

        ip6Manager.acquireGuestIpv6Address(network, requestedIpv6);

        verifyAcquireGuestIpv6AddressTest();
    }

    @Test(expected = InsufficientAddressCapacityException.class)
    public void acquireGuestIpv6AddressTestStateReleasing() throws InsufficientAddressCapacityException {
        setAcquireGuestIpv6AddressTest(false, State.Releasing);
        String requestedIpv6 = setCheckIfCanAllocateIpv6AddresscTest("2001:db8::10", false, false);

        ip6Manager.acquireGuestIpv6Address(network, requestedIpv6);

        verifyAcquireGuestIpv6AddressTest();
    }

    private void setAcquireGuestIpv6AddressTest(boolean isIPAvailable, State state) {
        mockNetwork();
        IPAddressVO ipVo = Mockito.mock(IPAddressVO.class);
        Mockito.doReturn(isIPAvailable).when(networkModel).areThereIPv6AddressAvailableInNetwork(Mockito.anyLong());
        Mockito.doReturn(ipVo).when(ipAddressDao).findByIpAndSourceNetworkId(Mockito.anyLong(), Mockito.anyString());
        Mockito.when(ipVo.getState()).thenReturn(state);
    }

    @Test
    public void setNICIPv6AddressTest() throws InsufficientAddressCapacityException {
        NicProfile nic = new NicProfile();
        Network network = mock(Network.class);
        DataCenter dc = mock(DataCenter.class);

        nic.setMacAddress("1e:00:b1:00:0a:f6");

        Mockito.when(network.getIp6Cidr()).thenReturn("2001:db8:100::/64");
        Mockito.when(network.getIp6Gateway()).thenReturn("2001:db8:100::1");

        Mockito.when(networkModel.getNetworkIp6Dns(network, dc)).thenReturn(new Pair<>("2001:db8::53:1", "2001:db8::53:2"));

        String expected = "2001:db8:100:0:1c00:b1ff:fe00:af6";

        ip6Manager.setNicIp6Address(nic, dc, network);

        Assert.assertEquals(expected, nic.getIPv6Address());
    }

    @Test(expected = InsufficientAddressCapacityException.class)
    public void acquireGuestIpv6AddressEUI64Test() throws InsufficientAddressCapacityException {
        setAcquireGuestIpv6AddressTest(true, State.Free);
        String requestedIpv6 = setCheckIfCanAllocateIpv6AddresscTest("2001:db8:13f::1c00:4aff:fe00:fe", false, false);
        ip6Manager.acquireGuestIpv6Address(network, requestedIpv6);
    }
}