plugins/network-elements/nuage-vsp/src/test/java/com/cloud/NuageTest.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;

import java.util.ArrayList;

import net.nuage.vsp.acs.client.api.model.NetworkRelatedVsdIds;
import net.nuage.vsp.acs.client.api.model.VspAclRule;
import net.nuage.vsp.acs.client.api.model.VspDhcpDomainOption;
import net.nuage.vsp.acs.client.api.model.VspDhcpVMOption;
import net.nuage.vsp.acs.client.api.model.VspDomain;
import net.nuage.vsp.acs.client.api.model.VspNetwork;
import net.nuage.vsp.acs.client.api.model.VspNic;
import net.nuage.vsp.acs.client.api.model.VspStaticNat;
import net.nuage.vsp.acs.client.api.model.VspVm;

import org.apache.cloudstack.framework.config.ConfigKey;
import org.apache.cloudstack.framework.config.impl.ConfigDepotImpl;
import org.apache.cloudstack.framework.config.impl.ConfigurationVO;
import org.junit.Before;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import com.google.common.collect.Lists;

import org.apache.cloudstack.framework.config.dao.ConfigurationDao;

import com.cloud.dc.VlanVO;
import com.cloud.domain.Domain;
import com.cloud.network.Network;
import com.cloud.network.NetworkModel;
import com.cloud.network.dao.IPAddressVO;
import com.cloud.network.rules.FirewallRule;
import com.cloud.network.vpc.NetworkACLItem;
import com.cloud.util.NuageVspEntityBuilder;
import com.cloud.vm.NicProfile;
import com.cloud.vm.NicVO;
import com.cloud.vm.VirtualMachine;

import static com.cloud.network.manager.NuageVspManager.NuageVspIsolatedNetworkDomainTemplateName;
import static com.cloud.network.manager.NuageVspManager.NuageVspSharedNetworkDomainTemplateName;
import static com.cloud.network.manager.NuageVspManager.NuageVspVpcDomainTemplateName;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyBoolean;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.when;

public class NuageTest {

    protected static final long NETWORK_ID = 42L;

    @Mock protected NetworkModel _networkModel;
    @Mock protected ConfigurationDao _configDao;
    @Mock protected NuageVspEntityBuilder _nuageVspEntityBuilder;

    @InjectMocks
    ConfigDepotImpl configDepot = new ConfigDepotImpl();

    @Before
    public void setUp() throws Exception {
        MockitoAnnotations.initMocks(this);

        // Standard responses
        when(_networkModel.isProviderForNetwork(Network.Provider.NuageVsp, NETWORK_ID)).thenReturn(true);

        mockConfigValue(NuageVspIsolatedNetworkDomainTemplateName, "IsolatedDomainTemplate");
        mockConfigValue(NuageVspVpcDomainTemplateName, "VpcDomainTemplate");
        mockConfigValue(NuageVspSharedNetworkDomainTemplateName, "SharedDomainTemplate");

        ConfigKey.init(configDepot);

        when(_nuageVspEntityBuilder.buildVspDomain(any(Domain.class))).thenReturn(buildVspDomain());

        VspNetwork vspNetwork = buildVspNetwork();
        when(_nuageVspEntityBuilder.buildVspNetwork(any(Network.class))).thenReturn(vspNetwork);
        when(_nuageVspEntityBuilder.buildVspNetwork(anyLong(), any(Network.class))).thenReturn(vspNetwork);

        when(_nuageVspEntityBuilder.buildVspVm(any(VirtualMachine.class), any(Network.class))).thenReturn(buildVspVm());

        when(_nuageVspEntityBuilder.buildVspNic(anyString(), any(NicProfile.class))).thenReturn(buildVspNic());
        when(_nuageVspEntityBuilder.buildVspNic(any(NicVO.class))).thenReturn(buildVspNic());

        when(_nuageVspEntityBuilder.buildVspStaticNat(anyBoolean(), any(IPAddressVO.class), any(VlanVO.class), any(NicVO.class))).thenReturn(buildVspStaticNat());
        when(_nuageVspEntityBuilder.buildVspAclRule(any(FirewallRule.class), any(Network.class))).thenReturn(buildVspAclRule());
        when(_nuageVspEntityBuilder.buildVspAclRule(any(NetworkACLItem.class))).thenReturn(buildVspAclRule());
    }

    protected  <T> void mockConfigValue(ConfigKey<T> configKey, T value) {
        ConfigurationVO vo = new ConfigurationVO("test", configKey);
        vo.setValue(value.toString());
        when(_configDao.getValue(configKey.key())).thenReturn(value.toString());
        when(_configDao.findById(configKey.key())).thenReturn(vo);
    }

    protected VspDomain buildVspDomain() {
        return new VspDomain.Builder()
                .uuid("domainUuid")
                .name("domainName")
                .path("domainPath")
                .build();
    }

    protected VspNetwork buildVspNetwork() {
        return new VspNetwork.Builder()
                .id(NETWORK_ID)
                .uuid("networkUuid")
                .name("networkName")
                .domain(buildVspDomain())
                .accountUuid("networkAccountUuid")
                .accountName("networkAccountName")
                .vpcUuid("vpcUuid")
                .vpcName("vpcName")
                .networkType(VspNetwork.NetworkType.L3)
                .firewallServiceSupported(true)
                .egressDefaultPolicy(true)
                .domainTemplateName("domainTemplateName")
                .cidr("networkCidr")
                .gateway("networkGateway")
                .virtualRouterIp("virtualRouterIp")
                .networkRelatedVsdIds(buildNetworkRelatedIds())
                .build();
    }

    protected NetworkRelatedVsdIds buildNetworkRelatedIds() {
        return new NetworkRelatedVsdIds.Builder()
                .vsdZoneId("vsdZoneId")
                .vsdDomainId("vsdDomainId")
                .vsdSubnetId("vsdSubnetId")
                .build();
    }

    protected VspVm buildVspVm() {
        return new VspVm.Builder()
                .state(VspVm.State.Running)
                .uuid("vmUuid")
                .name("vmName")
                .domainRouter(true)
                .domainRouterIp("domainRouterIp")
                .build();
    }

    protected VspNic buildVspNic() {
        return new VspNic.Builder()
                .uuid("nicUuid")
                .macAddress("macAddress")
                .useStaticIp(true)
                .ip("ip")
                .build();
    }

    protected VspStaticNat buildVspStaticNat() {
        return new VspStaticNat.Builder()
                .state(VspStaticNat.State.Allocating)
                .ipUuid("ipUuid")
                .ipAddress("ipAddress")
                .nic(buildVspNic())
                .revoke(false)
                .oneToOneNat(true)
                .vlanUuid("vlanUuid")
                .vlanGateway("vlanGateway")
                .vlanNetmask("vlanNetmask")
                .build();
    }

    protected VspAclRule buildVspAclRule() {
        return new VspAclRule.Builder()
                .uuid("aclRuleUuid")
                .protocol("protcol")
                .startPort(1)
                .endPort(9)
                .state(VspAclRule.ACLState.Add)
                .trafficType(VspAclRule.ACLTrafficType.Ingress)
                .action(VspAclRule.ACLAction.Allow)
                .sourceIpAddress("sourceIpAddress")
                .sourceCidrList(new ArrayList<String>())
                .priority(1)
                .type(VspAclRule.ACLType.NetworkACL)
                .build();
    }

    protected VspDhcpDomainOption buildspDhcpDomainOption () {
        return new VspDhcpDomainOption.Builder()
                .vrIsDnsProvider(true)
                .networkDomain("networkDomain")
                .dnsServers(Lists.newArrayList("10.10.10.10", "20.20.20.20"))
                .build();
    }

    protected VspDhcpVMOption buildspDhcpVMOption () {
        return new VspDhcpVMOption.Builder()
                .defaultHasDns(true)
                .hostname("VMx")
                .networkHasDns(true)
                .isDefaultInterface(true)
                .domainRouter(false)
                .nicUuid("aaaa-bbbbbbbb-ccccccc")
                .build();
    }

}