You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cloudstack.apache.org by ek...@apache.org on 2015/05/27 16:20:49 UTC
[02/10] git commit: updated refs/heads/master to b155129
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/b155129a/plugins/hypervisors/xenserver/test/com/cloud/hypervisor/xenserver/resource/wrapper/xenbase/CitrixRequestWrapperTest.java
----------------------------------------------------------------------
diff --git a/plugins/hypervisors/xenserver/test/com/cloud/hypervisor/xenserver/resource/wrapper/xenbase/CitrixRequestWrapperTest.java b/plugins/hypervisors/xenserver/test/com/cloud/hypervisor/xenserver/resource/wrapper/xenbase/CitrixRequestWrapperTest.java
new file mode 100644
index 0000000..1071485
--- /dev/null
+++ b/plugins/hypervisors/xenserver/test/com/cloud/hypervisor/xenserver/resource/wrapper/xenbase/CitrixRequestWrapperTest.java
@@ -0,0 +1,1842 @@
+// 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.hypervisor.xenserver.resource.wrapper.xenbase;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Hashtable;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.cloudstack.storage.command.AttachAnswer;
+import org.apache.cloudstack.storage.command.AttachCommand;
+import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
+import org.apache.cloudstack.storage.to.VolumeObjectTO;
+import org.apache.xmlrpc.XmlRpcException;
+import org.apache.xmlrpc.client.XmlRpcClient;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.powermock.api.mockito.PowerMockito;
+
+import com.cloud.agent.api.Answer;
+import com.cloud.agent.api.AttachIsoCommand;
+import com.cloud.agent.api.AttachVolumeCommand;
+import com.cloud.agent.api.CheckHealthCommand;
+import com.cloud.agent.api.CheckNetworkCommand;
+import com.cloud.agent.api.CheckOnHostCommand;
+import com.cloud.agent.api.CheckVirtualMachineCommand;
+import com.cloud.agent.api.CleanupNetworkRulesCmd;
+import com.cloud.agent.api.ClusterVMMetaDataSyncCommand;
+import com.cloud.agent.api.Command;
+import com.cloud.agent.api.CreateStoragePoolCommand;
+import com.cloud.agent.api.CreateVMSnapshotCommand;
+import com.cloud.agent.api.DeleteStoragePoolCommand;
+import com.cloud.agent.api.DeleteVMSnapshotCommand;
+import com.cloud.agent.api.GetHostStatsCommand;
+import com.cloud.agent.api.GetStorageStatsCommand;
+import com.cloud.agent.api.GetVmDiskStatsCommand;
+import com.cloud.agent.api.GetVmStatsCommand;
+import com.cloud.agent.api.GetVncPortCommand;
+import com.cloud.agent.api.MaintainCommand;
+import com.cloud.agent.api.MigrateCommand;
+import com.cloud.agent.api.ModifySshKeysCommand;
+import com.cloud.agent.api.ModifyStoragePoolCommand;
+import com.cloud.agent.api.NetworkRulesSystemVmCommand;
+import com.cloud.agent.api.NetworkRulesVmSecondaryIpCommand;
+import com.cloud.agent.api.OvsCreateGreTunnelCommand;
+import com.cloud.agent.api.OvsCreateTunnelCommand;
+import com.cloud.agent.api.OvsDeleteFlowCommand;
+import com.cloud.agent.api.OvsDestroyBridgeCommand;
+import com.cloud.agent.api.OvsDestroyTunnelCommand;
+import com.cloud.agent.api.OvsFetchInterfaceCommand;
+import com.cloud.agent.api.OvsSetTagAndFlowCommand;
+import com.cloud.agent.api.OvsSetupBridgeCommand;
+import com.cloud.agent.api.OvsVpcPhysicalTopologyConfigCommand;
+import com.cloud.agent.api.OvsVpcRoutingPolicyConfigCommand;
+import com.cloud.agent.api.PerformanceMonitorCommand;
+import com.cloud.agent.api.PingTestCommand;
+import com.cloud.agent.api.PlugNicCommand;
+import com.cloud.agent.api.PrepareForMigrationCommand;
+import com.cloud.agent.api.PvlanSetupCommand;
+import com.cloud.agent.api.ReadyCommand;
+import com.cloud.agent.api.RebootAnswer;
+import com.cloud.agent.api.RebootCommand;
+import com.cloud.agent.api.RebootRouterCommand;
+import com.cloud.agent.api.RevertToVMSnapshotCommand;
+import com.cloud.agent.api.ScaleVmCommand;
+import com.cloud.agent.api.SecurityGroupRulesCmd;
+import com.cloud.agent.api.SetupCommand;
+import com.cloud.agent.api.StartCommand;
+import com.cloud.agent.api.StopCommand;
+import com.cloud.agent.api.UnPlugNicCommand;
+import com.cloud.agent.api.UpdateHostPasswordCommand;
+import com.cloud.agent.api.UpgradeSnapshotCommand;
+import com.cloud.agent.api.VMSnapshotTO;
+import com.cloud.agent.api.check.CheckSshCommand;
+import com.cloud.agent.api.proxy.CheckConsoleProxyLoadCommand;
+import com.cloud.agent.api.proxy.WatchConsoleProxyLoadCommand;
+import com.cloud.agent.api.routing.IpAssocCommand;
+import com.cloud.agent.api.routing.IpAssocVpcCommand;
+import com.cloud.agent.api.storage.CreateAnswer;
+import com.cloud.agent.api.storage.CreateCommand;
+import com.cloud.agent.api.storage.DestroyCommand;
+import com.cloud.agent.api.storage.PrimaryStorageDownloadCommand;
+import com.cloud.agent.api.storage.ResizeVolumeCommand;
+import com.cloud.agent.api.to.DataStoreTO;
+import com.cloud.agent.api.to.DiskTO;
+import com.cloud.agent.api.to.IpAddressTO;
+import com.cloud.agent.api.to.NicTO;
+import com.cloud.agent.api.to.StorageFilerTO;
+import com.cloud.agent.api.to.VirtualMachineTO;
+import com.cloud.agent.resource.virtualnetwork.VirtualRoutingResource;
+import com.cloud.host.HostEnvironment;
+import com.cloud.hypervisor.xenserver.resource.CitrixResourceBase;
+import com.cloud.hypervisor.xenserver.resource.XsHost;
+import com.cloud.hypervisor.xenserver.resource.XsLocalNetwork;
+import com.cloud.network.Networks.TrafficType;
+import com.cloud.network.PhysicalNetworkSetupInfo;
+import com.cloud.storage.Storage.ImageFormat;
+import com.cloud.storage.Storage.StoragePoolType;
+import com.cloud.storage.VMTemplateStorageResourceAssoc;
+import com.cloud.storage.resource.StorageSubsystemCommandHandler;
+import com.cloud.vm.DiskProfile;
+import com.cloud.vm.VirtualMachine;
+import com.xensource.xenapi.Connection;
+import com.xensource.xenapi.Host;
+import com.xensource.xenapi.Marshalling;
+import com.xensource.xenapi.Network;
+import com.xensource.xenapi.PIF;
+import com.xensource.xenapi.Pool;
+import com.xensource.xenapi.Types.BadServerResponse;
+import com.xensource.xenapi.Types.XenAPIException;
+
+
+@RunWith(MockitoJUnitRunner.class)
+public class CitrixRequestWrapperTest {
+
+ @Mock
+ private CitrixResourceBase citrixResourceBase;
+ @Mock
+ private RebootAnswer rebootAnswer;
+ @Mock
+ private CreateAnswer createAnswer;
+
+ @Test
+ public void testWrapperInstance() {
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+ }
+
+ @Test
+ public void testUnknownCommand() {
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ try {
+ wrapper.execute(new NotAValidCommand(), citrixResourceBase);
+ } catch (final Exception e) {
+ assertTrue(e instanceof NullPointerException);
+ }
+ }
+
+ @Test
+ public void testExecuteRebootRouterCommand() {
+ final RebootRouterCommand rebootRouterCommand = new RebootRouterCommand("Test", "127.0.0.1");
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(rebootRouterCommand, citrixResourceBase);
+
+ verify(citrixResourceBase, times(2)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testExecuteCreateCommand() {
+ final StoragePoolVO poolVO = Mockito.mock(StoragePoolVO.class);
+ final DiskProfile diskProfile = Mockito.mock(DiskProfile.class);
+ final CreateCommand createCommand = new CreateCommand(diskProfile, "", poolVO, false);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(createCommand, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testCheckConsoleProxyLoadCommand() {
+ final CheckConsoleProxyLoadCommand consoleProxyCommand = new CheckConsoleProxyLoadCommand();
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(consoleProxyCommand, citrixResourceBase);
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testWatchConsoleProxyLoadCommand() {
+ final WatchConsoleProxyLoadCommand watchConsoleProxyCommand = new WatchConsoleProxyLoadCommand(0, 0, "", "", 0);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(watchConsoleProxyCommand, citrixResourceBase);
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testReadyCommand() {
+ final ReadyCommand readyCommand = new ReadyCommand();
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(readyCommand, citrixResourceBase);
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testGetHostStatsCommand() {
+ final GetHostStatsCommand statsCommand = new GetHostStatsCommand(null, null, 0);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(statsCommand, citrixResourceBase);
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testGetVmStatsCommand() {
+ final GetVmStatsCommand statsCommand = new GetVmStatsCommand(new ArrayList<String>(), null, null);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(statsCommand, citrixResourceBase);
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testGetVmDiskStatsCommand() {
+ final GetVmDiskStatsCommand diskStatsCommand = new GetVmDiskStatsCommand(new ArrayList<String>(), null, null);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(diskStatsCommand, citrixResourceBase);
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testCheckHealthCommand() {
+ final CheckHealthCommand checkHealthCommand = new CheckHealthCommand();
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(checkHealthCommand, citrixResourceBase);
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testStopCommand() {
+ final StopCommand stopCommand = new StopCommand("Test", false, false);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(stopCommand, citrixResourceBase);
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testRebootCommand() {
+ final RebootCommand rebootCommand = new RebootCommand("Test");
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(rebootCommand, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testCheckVirtualMachineCommand() {
+ final CheckVirtualMachineCommand virtualMachineCommand = new CheckVirtualMachineCommand("Test");
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(virtualMachineCommand, citrixResourceBase);
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testPrepareForMigrationCommand() {
+ final VirtualMachineTO machineTO = Mockito.mock(VirtualMachineTO.class);
+ final PrepareForMigrationCommand prepareCommand = new PrepareForMigrationCommand(machineTO);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(prepareCommand, citrixResourceBase);
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testMigrateCommand() {
+ final VirtualMachineTO machineTO = Mockito.mock(VirtualMachineTO.class);
+ final MigrateCommand migrateCommand = new MigrateCommand("Test", "127.0.0.1", false, machineTO, false);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(migrateCommand, citrixResourceBase);
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testDestroyCommand() {
+
+ final VMTemplateStorageResourceAssoc templateStorage = Mockito.mock(VMTemplateStorageResourceAssoc.class);
+ final StoragePoolVO poolVO = Mockito.mock(StoragePoolVO.class);
+
+ final DestroyCommand destroyCommand = new DestroyCommand(poolVO, templateStorage);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(destroyCommand, citrixResourceBase);
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testCreateStoragePoolCommand() {
+ final StoragePoolVO poolVO = Mockito.mock(StoragePoolVO.class);
+ final XsHost xsHost = Mockito.mock(XsHost.class);
+
+ final CreateStoragePoolCommand createStorageCommand = new CreateStoragePoolCommand(false, poolVO);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getHost()).thenReturn(xsHost);
+
+ final Answer answer = wrapper.execute(createStorageCommand, citrixResourceBase);
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testModifyStoragePoolCommand() {
+ final StoragePoolVO poolVO = Mockito.mock(StoragePoolVO.class);
+ final XsHost xsHost = Mockito.mock(XsHost.class);
+
+ final ModifyStoragePoolCommand modifyStorageCommand = new ModifyStoragePoolCommand(false, poolVO);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getHost()).thenReturn(xsHost);
+
+ final Answer answer = wrapper.execute(modifyStorageCommand, citrixResourceBase);
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testDeleteStoragePoolCommand() {
+ final StoragePoolVO poolVO = Mockito.mock(StoragePoolVO.class);
+ final XsHost xsHost = Mockito.mock(XsHost.class);
+
+ final DeleteStoragePoolCommand deleteStorageCommand = new DeleteStoragePoolCommand(poolVO);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getHost()).thenReturn(xsHost);
+
+ final Answer answer = wrapper.execute(deleteStorageCommand, citrixResourceBase);
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testResizeVolumeCommand() {
+ final StorageFilerTO pool = Mockito.mock(StorageFilerTO.class);
+
+ final ResizeVolumeCommand resizeCommand = new ResizeVolumeCommand("Test", pool, 1l, 3l, false, "Tests-1");
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(resizeCommand, citrixResourceBase);
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testAttachVolumeCommand() {
+ final AttachVolumeCommand attachCommand = new AttachVolumeCommand(false, true, "Test", StoragePoolType.LVM, "/", "DATA", 100l, 1l, "123");
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(attachCommand, citrixResourceBase);
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testAttachIsoCommand() {
+ final AttachIsoCommand attachCommand = new AttachIsoCommand("Test", "/", true);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(attachCommand, citrixResourceBase);
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testUpgradeSnapshotCommand() {
+ final StoragePoolVO poolVO = Mockito.mock(StoragePoolVO.class);
+
+ final UpgradeSnapshotCommand upgradeSnapshotCommand = new UpgradeSnapshotCommand(poolVO, "http", 1l, 1l, 1l, 1l, 1l, "/", "58c5778b-7dd1-47cc-a7b5-f768541bf278", "Test",
+ "2.1");
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(upgradeSnapshotCommand, citrixResourceBase);
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testUpgradeSnapshotCommandNo21() {
+ final StoragePoolVO poolVO = Mockito.mock(StoragePoolVO.class);
+
+ final UpgradeSnapshotCommand upgradeSnapshotCommand = new UpgradeSnapshotCommand(poolVO, "http", 1l, 1l, 1l, 1l, 1l, "/", "58c5778b-7dd1-47cc-a7b5-f768541bf278", "Test",
+ "3.1");
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(upgradeSnapshotCommand, citrixResourceBase);
+ verify(citrixResourceBase, times(0)).getConnection();
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testGetStorageStatsCommand() {
+ final XsHost xsHost = Mockito.mock(XsHost.class);
+ final DataStoreTO store = Mockito.mock(DataStoreTO.class);
+
+ final GetStorageStatsCommand storageStatsCommand = new GetStorageStatsCommand(store);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getHost()).thenReturn(xsHost);
+
+ final Answer answer = wrapper.execute(storageStatsCommand, citrixResourceBase);
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testPrimaryStorageDownloadCommand() {
+ final XsHost xsHost = Mockito.mock(XsHost.class);
+ final StoragePoolVO poolVO = Mockito.mock(StoragePoolVO.class);
+
+ final PrimaryStorageDownloadCommand storageDownloadCommand = new PrimaryStorageDownloadCommand("Test", "http://127.0.0.1", ImageFormat.VHD, 1l, poolVO, 200);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getHost()).thenReturn(xsHost);
+
+ final Answer answer = wrapper.execute(storageDownloadCommand, citrixResourceBase);
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testGetVncPortCommand() {
+ final GetVncPortCommand vncPortCommand = new GetVncPortCommand(1l, "Test");
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(vncPortCommand, citrixResourceBase);
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testSetupCommand() {
+ final XsHost xsHost = Mockito.mock(XsHost.class);
+ final HostEnvironment env = Mockito.mock(HostEnvironment.class);
+
+ final SetupCommand setupCommand = new SetupCommand(env);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getHost()).thenReturn(xsHost);
+
+ final Answer answer = wrapper.execute(setupCommand, citrixResourceBase);
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testMaintainCommand() {
+ // This test needs further work.
+
+ final String uuid = "befc4dcd-f5c6-4015-8791-3c18622b7c7f";
+
+ final Connection conn = Mockito.mock(Connection.class);
+ final XsHost xsHost = Mockito.mock(XsHost.class);
+ final XmlRpcClient client = Mockito.mock(XmlRpcClient.class);
+
+ // final Host.Record hr = PowerMockito.mock(Host.Record.class);
+ // final Host host = PowerMockito.mock(Host.class);
+
+ final MaintainCommand maintainCommand = new MaintainCommand();
+
+ final Map<String, Object> map = new Hashtable<String, Object>();
+ map.put("Value", "Xen");
+
+ final Map<String, Object> spiedMap = spy(map);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ when(citrixResourceBase.getHost()).thenReturn(xsHost);
+ when(xsHost.getUuid()).thenReturn(uuid);
+ when(conn.getSessionReference()).thenReturn("befc4dcd");
+
+ try {
+ final Object[] params = { Marshalling.toXMLRPC("befc4dcd"), Marshalling.toXMLRPC(uuid) };
+ when(client.execute("host.get_by_uuid", new Object[] { "befc4dcd", uuid })).thenReturn(spiedMap);
+ PowerMockito.when(conn, "dispatch", "host.get_by_uuid", params).thenReturn(spiedMap);
+ } catch (final Exception e) {
+ fail(e.getMessage());
+ }
+
+ // try {
+ // PowerMockito.mockStatic(Host.class);
+ // //BDDMockito.given(Host.getByUuid(conn,
+ // xsHost.getUuid())).willReturn(host);
+ // PowerMockito.when(Host.getByUuid(conn,
+ // xsHost.getUuid())).thenReturn(host);
+ // PowerMockito.verifyStatic(times(1));
+ // } catch (final BadServerResponse e) {
+ // fail(e.getMessage());
+ // } catch (final XenAPIException e) {
+ // fail(e.getMessage());
+ // } catch (final XmlRpcException e) {
+ // fail(e.getMessage());
+ // }
+ //
+ // PowerMockito.mockStatic(Types.class);
+ // PowerMockito.when(Types.toHostRecord(spiedMap)).thenReturn(hr);
+ // PowerMockito.verifyStatic(times(1));
+ //
+ // try {
+ // PowerMockito.mockStatic(Host.Record.class);
+ // when(host.getRecord(conn)).thenReturn(hr);
+ // verify(host, times(1)).getRecord(conn);
+ // } catch (final BadServerResponse e) {
+ // fail(e.getMessage());
+ // } catch (final XenAPIException e) {
+ // fail(e.getMessage());
+ // } catch (final XmlRpcException e) {
+ // fail(e.getMessage());
+ // }
+
+ final Answer answer = wrapper.execute(maintainCommand, citrixResourceBase);
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testPingTestCommandHostIp() {
+ final PingTestCommand pingTestCommand = new PingTestCommand("127.0.0.1");
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(pingTestCommand, citrixResourceBase);
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testPingTestCommandRouterPvtIps() {
+ final PingTestCommand pingTestCommand = new PingTestCommand("127.0.0.1", "192.168.0.1");
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(pingTestCommand, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testCheckOnHostCommand() {
+ final com.cloud.host.Host host = Mockito.mock(com.cloud.host.Host.class);
+ final CheckOnHostCommand onHostCommand = new CheckOnHostCommand(host);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(onHostCommand, citrixResourceBase);
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testModifySshKeysCommand() {
+ final ModifySshKeysCommand sshKeysCommand = new ModifySshKeysCommand("", "");
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(sshKeysCommand, citrixResourceBase);
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testStartCommand() {
+ final VirtualMachineTO vm = Mockito.mock(VirtualMachineTO.class);
+ final com.cloud.host.Host host = Mockito.mock(com.cloud.host.Host.class);
+
+ final StartCommand startCommand = new StartCommand(vm, host, false);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(startCommand, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testOvsSetTagAndFlowCommand() {
+ final Network network = Mockito.mock(Network.class);
+ final Connection conn = Mockito.mock(Connection.class);
+
+ final OvsSetTagAndFlowCommand tagAndFlowCommand = new OvsSetTagAndFlowCommand("Test", "tag", "vlan://1", "123", 1l);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ when(citrixResourceBase.setupvSwitchNetwork(conn)).thenReturn(network);
+ try {
+ when(network.getBridge(conn)).thenReturn("br0");
+ } catch (final BadServerResponse e) {
+ fail(e.getMessage());
+ } catch (final XenAPIException e) {
+ fail(e.getMessage());
+ } catch (final XmlRpcException e) {
+ fail(e.getMessage());
+ }
+
+ final Answer answer = wrapper.execute(tagAndFlowCommand, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+ verify(citrixResourceBase, times(1)).setupvSwitchNetwork(conn);
+ verify(citrixResourceBase, times(1)).setIsOvs(true);
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testCheckSshCommand() {
+ final CheckSshCommand sshCommand = new CheckSshCommand("Test", "127.0.0.1", 22);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(sshCommand, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testSecurityGroupRulesCommand() {
+ final Connection conn = Mockito.mock(Connection.class);
+ final XsHost xsHost = Mockito.mock(XsHost.class);
+
+ final SecurityGroupRulesCmd sshCommand = new SecurityGroupRulesCmd();
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ when(citrixResourceBase.getHost()).thenReturn(xsHost);
+
+ final Answer answer = wrapper.execute(sshCommand, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testOvsFetchInterfaceCommand() {
+ final String label = "[abc]";
+ final String uuid = "befc4dcd-f5c6-4015-8791-3c18622b7c7f";
+
+ final Connection conn = Mockito.mock(Connection.class);
+ final XsLocalNetwork network = Mockito.mock(XsLocalNetwork.class);
+ final Network network2 = Mockito.mock(Network.class);
+ final PIF pif = Mockito.mock(PIF.class);
+ final PIF.Record pifRec = Mockito.mock(PIF.Record.class);
+
+ final XsHost xsHost = Mockito.mock(XsHost.class);
+
+ final OvsFetchInterfaceCommand fetchInterCommand = new OvsFetchInterfaceCommand(label);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.isXcp()).thenReturn(true);
+ when(citrixResourceBase.getLabel()).thenReturn("[abc]");
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ when(citrixResourceBase.getHost()).thenReturn(xsHost);
+
+ try {
+ when(network.getNetwork()).thenReturn(network2);
+ when(network.getPif(conn)).thenReturn(pif);
+ when(network.getPif(conn)).thenReturn(pif);
+ when(pif.getRecord(conn)).thenReturn(pifRec);
+ when(network.getNetwork().getUuid(conn)).thenReturn(uuid);
+ when(citrixResourceBase.getNetworkByName(conn, label)).thenReturn(network);
+ } catch (final XenAPIException e) {
+ fail(e.getMessage());
+ } catch (final XmlRpcException e) {
+ fail(e.getMessage());
+ }
+
+ final Answer answer = wrapper.execute(fetchInterCommand, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testOvsCreateGreTunnelCommand() {
+ final String bridge = "gre";
+ final Connection conn = Mockito.mock(Connection.class);
+ final Network network = Mockito.mock(Network.class);
+ final XsHost xsHost = Mockito.mock(XsHost.class);
+
+ final OvsCreateGreTunnelCommand createGreCommand = new OvsCreateGreTunnelCommand("172.0.0.1", "KEY", 1l, 2l);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ when(citrixResourceBase.getHost()).thenReturn(xsHost);
+ when(citrixResourceBase.setupvSwitchNetwork(conn)).thenReturn(network);
+ try {
+ when(network.getBridge(conn)).thenReturn(bridge);
+ when(
+ citrixResourceBase.callHostPlugin(conn, "ovsgre", "ovs_create_gre", "bridge", bridge, "remoteIP", createGreCommand.getRemoteIp(), "greKey",
+ createGreCommand.getKey(), "from", Long.toString(createGreCommand.getFrom()), "to", Long.toString(createGreCommand.getTo()))).thenReturn("1:2");
+
+ } catch (final BadServerResponse e) {
+ fail(e.getMessage());
+ } catch (final XenAPIException e) {
+ fail(e.getMessage());
+ } catch (final XmlRpcException e) {
+ fail(e.getMessage());
+ }
+
+ final Answer answer = wrapper.execute(createGreCommand, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+ verify(citrixResourceBase, times(1)).setIsOvs(true);
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testOvsDeleteFlowCommandSuccess() {
+ final String bridge = "gre";
+ final Connection conn = Mockito.mock(Connection.class);
+ final Network network = Mockito.mock(Network.class);
+
+ final OvsDeleteFlowCommand deleteFlowCommand = new OvsDeleteFlowCommand("Test");
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ when(citrixResourceBase.setupvSwitchNetwork(conn)).thenReturn(network);
+ try {
+ when(network.getBridge(conn)).thenReturn(bridge);
+ when(citrixResourceBase.callHostPlugin(conn, "ovsgre", "ovs_delete_flow", "bridge", bridge, "vmName", deleteFlowCommand.getVmName())).thenReturn("SUCCESS");
+
+ } catch (final BadServerResponse e) {
+ fail(e.getMessage());
+ } catch (final XenAPIException e) {
+ fail(e.getMessage());
+ } catch (final XmlRpcException e) {
+ fail(e.getMessage());
+ }
+
+ final Answer answer = wrapper.execute(deleteFlowCommand, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+ verify(citrixResourceBase, times(1)).setIsOvs(true);
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testOvsDeleteFlowCommandFailure() {
+ final String bridge = "gre";
+ final Connection conn = Mockito.mock(Connection.class);
+ final Network network = Mockito.mock(Network.class);
+
+ final OvsDeleteFlowCommand deleteFlowCommand = new OvsDeleteFlowCommand("Test");
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ when(citrixResourceBase.setupvSwitchNetwork(conn)).thenReturn(network);
+ try {
+ when(network.getBridge(conn)).thenReturn(bridge);
+ when(citrixResourceBase.callHostPlugin(conn, "ovsgre", "ovs_delete_flow", "bridge", bridge, "vmName", deleteFlowCommand.getVmName())).thenReturn("FAILED");
+
+ } catch (final BadServerResponse e) {
+ fail(e.getMessage());
+ } catch (final XenAPIException e) {
+ fail(e.getMessage());
+ } catch (final XmlRpcException e) {
+ fail(e.getMessage());
+ }
+
+ final Answer answer = wrapper.execute(deleteFlowCommand, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+ verify(citrixResourceBase, times(1)).setIsOvs(true);
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testOvsVpcPhysicalTopologyConfigCommand() {
+ final String bridge = "gre";
+ final Connection conn = Mockito.mock(Connection.class);
+ final Network network = Mockito.mock(Network.class);
+
+ final OvsVpcPhysicalTopologyConfigCommand.Host[] hosts = new OvsVpcPhysicalTopologyConfigCommand.Host[0];
+ final OvsVpcPhysicalTopologyConfigCommand.Tier[] tiers = new OvsVpcPhysicalTopologyConfigCommand.Tier[0];
+ final OvsVpcPhysicalTopologyConfigCommand.Vm[] vms = new OvsVpcPhysicalTopologyConfigCommand.Vm[0];
+
+ final OvsVpcPhysicalTopologyConfigCommand physicalTopology = new OvsVpcPhysicalTopologyConfigCommand(hosts, tiers, vms, "10.0.0.1/24");
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ try {
+ when(citrixResourceBase.findOrCreateTunnelNetwork(conn, physicalTopology.getBridgeName())).thenReturn(network);
+ when(network.getBridge(conn)).thenReturn(bridge);
+
+ when(
+ citrixResourceBase.callHostPlugin(conn, "ovstunnel", "configure_ovs_bridge_for_network_topology", "bridge", bridge, "config",
+ physicalTopology.getVpcConfigInJson(), "host-id", ((Long) physicalTopology.getHostId()).toString(), "seq-no", Long.toString(1))).thenReturn("SUCCESS");
+
+ } catch (final BadServerResponse e) {
+ fail(e.getMessage());
+ } catch (final XenAPIException e) {
+ fail(e.getMessage());
+ } catch (final XmlRpcException e) {
+ fail(e.getMessage());
+ }
+
+ final Answer answer = wrapper.execute(physicalTopology, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testOvsVpcRoutingPolicyConfigCommand() {
+ final String bridge = "gre";
+ final Connection conn = Mockito.mock(Connection.class);
+ final Network network = Mockito.mock(Network.class);
+
+ final OvsVpcRoutingPolicyConfigCommand.Acl[] acls = new OvsVpcRoutingPolicyConfigCommand.Acl[0];
+ final OvsVpcRoutingPolicyConfigCommand.Tier[] tiers = new OvsVpcRoutingPolicyConfigCommand.Tier[0];
+
+ final OvsVpcRoutingPolicyConfigCommand routingPolicy = new OvsVpcRoutingPolicyConfigCommand("v1", "10.0.0.1/24", acls, tiers);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ try {
+ when(citrixResourceBase.findOrCreateTunnelNetwork(conn, routingPolicy.getBridgeName())).thenReturn(network);
+ when(network.getBridge(conn)).thenReturn(bridge);
+
+ when(
+ citrixResourceBase.callHostPlugin(conn, "ovstunnel", "configure_ovs_bridge_for_routing_policies", "bridge", bridge, "host-id",
+ ((Long) routingPolicy.getHostId()).toString(), "config", routingPolicy.getVpcConfigInJson(), "seq-no", Long.toString(1))).thenReturn("SUCCESS");
+
+ } catch (final BadServerResponse e) {
+ fail(e.getMessage());
+ } catch (final XenAPIException e) {
+ fail(e.getMessage());
+ } catch (final XmlRpcException e) {
+ fail(e.getMessage());
+ }
+
+ final Answer answer = wrapper.execute(routingPolicy, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testCleanupNetworkRulesCmd() {
+ final Connection conn = Mockito.mock(Connection.class);
+ final XsHost xsHost = Mockito.mock(XsHost.class);
+
+ final CleanupNetworkRulesCmd cleanupNets = new CleanupNetworkRulesCmd(20);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.canBridgeFirewall()).thenReturn(true);
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ when(citrixResourceBase.getHost()).thenReturn(xsHost);
+ when(citrixResourceBase.getVMInstanceName()).thenReturn("VM");
+ when(citrixResourceBase.callHostPlugin(conn, "vmops", "cleanup_rules", "instance", citrixResourceBase.getVMInstanceName())).thenReturn("1");
+
+ final Answer answer = wrapper.execute(cleanupNets, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testCleanupNetworkRulesCmdLTZ() {
+ final Connection conn = Mockito.mock(Connection.class);
+ final XsHost xsHost = Mockito.mock(XsHost.class);
+
+ final CleanupNetworkRulesCmd cleanupNets = new CleanupNetworkRulesCmd(20);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.canBridgeFirewall()).thenReturn(true);
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ when(citrixResourceBase.getHost()).thenReturn(xsHost);
+ when(citrixResourceBase.getVMInstanceName()).thenReturn("VM");
+ when(citrixResourceBase.callHostPlugin(conn, "vmops", "cleanup_rules", "instance", citrixResourceBase.getVMInstanceName())).thenReturn("-1");
+
+ final Answer answer = wrapper.execute(cleanupNets, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+ verify(xsHost, times(1)).getIp();
+
+ assertFalse(answer.getResult());
+ assertEquals(answer.getDetails(), "-1");
+ }
+
+ @Test
+ public void testCleanupNetworkRulesCmdNullDetails() {
+ final CleanupNetworkRulesCmd cleanupNets = new CleanupNetworkRulesCmd(20);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.canBridgeFirewall()).thenReturn(false);
+ final Answer answer = wrapper.execute(cleanupNets, citrixResourceBase);
+
+ assertTrue(answer.getResult());
+ assertNull(answer.getDetails());
+ }
+
+ @Test
+ public void testNetworkRulesSystemVmCommand() {
+ final Connection conn = Mockito.mock(Connection.class);
+
+ final NetworkRulesSystemVmCommand netRules = new NetworkRulesSystemVmCommand("Test", VirtualMachine.Type.User);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+
+ final Answer answer = wrapper.execute(netRules, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testNetworkRulesSystemVmCommandNonUser() {
+ final Connection conn = Mockito.mock(Connection.class);
+
+ final NetworkRulesSystemVmCommand netRules = new NetworkRulesSystemVmCommand("Test", VirtualMachine.Type.DomainRouter);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ when(citrixResourceBase.callHostPlugin(conn, "vmops", "default_network_rules_systemvm", "vmName", netRules.getVmName())).thenReturn("true");
+
+ final Answer answer = wrapper.execute(netRules, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testNetworkRulesSystemVmCommandNonUserFalse() {
+ final Connection conn = Mockito.mock(Connection.class);
+
+ final NetworkRulesSystemVmCommand netRules = new NetworkRulesSystemVmCommand("Test", VirtualMachine.Type.DomainRouter);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ when(citrixResourceBase.callHostPlugin(conn, "vmops", "default_network_rules_systemvm", "vmName", netRules.getVmName())).thenReturn("false");
+
+ final Answer answer = wrapper.execute(netRules, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testOvsCreateTunnelCommandSuccess() {
+ final String bridge = "tunnel";
+ final Connection conn = Mockito.mock(Connection.class);
+ final Network network = Mockito.mock(Network.class);
+
+ final OvsCreateTunnelCommand createTunnel = new OvsCreateTunnelCommand("127.0.0.1", 1, 1l, 2l, 1l, "127.0.1.1", "net01", "cd84c713-f448-48c9-ba25-e6740d4a9003");
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ try {
+ when(citrixResourceBase.findOrCreateTunnelNetwork(conn, createTunnel.getNetworkName())).thenReturn(network);
+ when(network.getBridge(conn)).thenReturn(bridge);
+
+ when(citrixResourceBase.callHostPlugin(conn, "ovstunnel", "create_tunnel", "bridge", bridge, "remote_ip", createTunnel.getRemoteIp(),
+ "key", createTunnel.getKey().toString(), "from",
+ createTunnel.getFrom().toString(), "to", createTunnel.getTo().toString(), "cloudstack-network-id",
+ createTunnel.getNetworkUuid())).thenReturn("SUCCESS:0");
+
+ } catch (final BadServerResponse e) {
+ fail(e.getMessage());
+ } catch (final XenAPIException e) {
+ fail(e.getMessage());
+ } catch (final XmlRpcException e) {
+ fail(e.getMessage());
+ }
+
+ final Answer answer = wrapper.execute(createTunnel, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+ verify(citrixResourceBase, times(1)).configureTunnelNetwork(conn, createTunnel.getNetworkId(), createTunnel.getFrom(), createTunnel.getNetworkName());
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testOvsCreateTunnelCommandFail() {
+ final String bridge = "tunnel";
+ final Connection conn = Mockito.mock(Connection.class);
+ final Network network = Mockito.mock(Network.class);
+
+ final OvsCreateTunnelCommand createTunnel = new OvsCreateTunnelCommand("127.0.0.1", 1, 1l, 2l, 1l, "127.0.1.1", "net01", "cd84c713-f448-48c9-ba25-e6740d4a9003");
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ try {
+ when(citrixResourceBase.findOrCreateTunnelNetwork(conn, createTunnel.getNetworkName())).thenReturn(network);
+ when(network.getBridge(conn)).thenReturn(bridge);
+
+ when(citrixResourceBase.callHostPlugin(conn, "ovstunnel", "create_tunnel", "bridge", bridge, "remote_ip", createTunnel.getRemoteIp(),
+ "key", createTunnel.getKey().toString(), "from",
+ createTunnel.getFrom().toString(), "to", createTunnel.getTo().toString(), "cloudstack-network-id",
+ createTunnel.getNetworkUuid())).thenReturn("FAIL:1");
+
+ } catch (final BadServerResponse e) {
+ fail(e.getMessage());
+ } catch (final XenAPIException e) {
+ fail(e.getMessage());
+ } catch (final XmlRpcException e) {
+ fail(e.getMessage());
+ }
+
+ final Answer answer = wrapper.execute(createTunnel, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+ verify(citrixResourceBase, times(1)).configureTunnelNetwork(conn, createTunnel.getNetworkId(), createTunnel.getFrom(), createTunnel.getNetworkName());
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testOvsCreateTunnelCommandNoNet() {
+ final Connection conn = Mockito.mock(Connection.class);
+
+ final OvsCreateTunnelCommand createTunnel = new OvsCreateTunnelCommand("127.0.0.1", 1, 1l, 2l, 1l, "127.0.1.1", "net01", "cd84c713-f448-48c9-ba25-e6740d4a9003");
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ when(citrixResourceBase.findOrCreateTunnelNetwork(conn, createTunnel.getNetworkName())).thenReturn(null);
+
+ final Answer answer = wrapper.execute(createTunnel, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testOvsSetupBridgeCommand() {
+ final Connection conn = Mockito.mock(Connection.class);
+
+ final OvsSetupBridgeCommand setupBridge = new OvsSetupBridgeCommand("Test", 1l, 1l);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+
+
+ final Answer answer = wrapper.execute(setupBridge, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+ verify(citrixResourceBase, times(1)).findOrCreateTunnelNetwork(conn, setupBridge.getBridgeName());
+ verify(citrixResourceBase, times(1)).configureTunnelNetwork(conn, setupBridge.getNetworkId(), setupBridge.getHostId(), setupBridge.getBridgeName());
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testOvsDestroyBridgeCommand() {
+ final Connection conn = Mockito.mock(Connection.class);
+ final Network network = Mockito.mock(Network.class);
+
+ final OvsDestroyBridgeCommand destroyBridge = new OvsDestroyBridgeCommand(1l, "bridge", 1l);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ when(citrixResourceBase.findOrCreateTunnelNetwork(conn, destroyBridge.getBridgeName())).thenReturn(network);
+
+ final Answer answer = wrapper.execute(destroyBridge, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+ try {
+ verify(citrixResourceBase, times(1)).cleanUpTmpDomVif(conn, network);
+ } catch (final XenAPIException e) {
+ fail(e.getMessage());
+ } catch (final XmlRpcException e) {
+ fail(e.getMessage());
+ }
+ verify(citrixResourceBase, times(1)).destroyTunnelNetwork(conn, network, destroyBridge.getHostId());
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testOvsDestroyTunnelCommandSuccess() {
+ final String bridge = "tunnel";
+ final Connection conn = Mockito.mock(Connection.class);
+ final Network network = Mockito.mock(Network.class);
+
+ final OvsDestroyTunnelCommand destroyTunnel = new OvsDestroyTunnelCommand(1l, "net01", "port11");
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ try {
+ when(citrixResourceBase.findOrCreateTunnelNetwork(conn, destroyTunnel.getBridgeName())).thenReturn(network);
+ when(network.getBridge(conn)).thenReturn(bridge);
+
+ when(citrixResourceBase.callHostPlugin(conn, "ovstunnel", "destroy_tunnel", "bridge", bridge, "in_port", destroyTunnel.getInPortName())).thenReturn("SUCCESS");
+
+ } catch (final BadServerResponse e) {
+ fail(e.getMessage());
+ } catch (final XenAPIException e) {
+ fail(e.getMessage());
+ } catch (final XmlRpcException e) {
+ fail(e.getMessage());
+ }
+
+ final Answer answer = wrapper.execute(destroyTunnel, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testOvsDestroyTunnelCommandFailed() {
+ final String bridge = "tunnel";
+ final Connection conn = Mockito.mock(Connection.class);
+ final Network network = Mockito.mock(Network.class);
+
+ final OvsDestroyTunnelCommand destroyTunnel = new OvsDestroyTunnelCommand(1l, "net01", "port11");
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ try {
+ when(citrixResourceBase.findOrCreateTunnelNetwork(conn, destroyTunnel.getBridgeName())).thenReturn(network);
+ when(network.getBridge(conn)).thenReturn(bridge);
+
+ when(citrixResourceBase.callHostPlugin(conn, "ovstunnel", "destroy_tunnel", "bridge", bridge, "in_port", destroyTunnel.getInPortName())).thenReturn("FAILED");
+
+ } catch (final BadServerResponse e) {
+ fail(e.getMessage());
+ } catch (final XenAPIException e) {
+ fail(e.getMessage());
+ } catch (final XmlRpcException e) {
+ fail(e.getMessage());
+ }
+
+ final Answer answer = wrapper.execute(destroyTunnel, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testUpdateHostPasswordCommand() {
+ final UpdateHostPasswordCommand updatePwd = new UpdateHostPasswordCommand("test", "123");
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(updatePwd, citrixResourceBase);
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testClusterVMMetaDataSyncCommand() {
+ final String uuid = "6172d8b7-ba10-4a70-93f9-ecaf41f51d53";
+
+ final Connection conn = Mockito.mock(Connection.class);
+ final XsHost xsHost = Mockito.mock(XsHost.class);
+
+ final Pool pool = PowerMockito.mock(Pool.class);
+ final Pool.Record poolr = Mockito.mock(Pool.Record.class);
+ final Host.Record hostr = Mockito.mock(Host.Record.class);
+ final Host master = Mockito.mock(Host.class);
+
+ final ClusterVMMetaDataSyncCommand vmDataSync = new ClusterVMMetaDataSyncCommand(10, 1l);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ try {
+ when(citrixResourceBase.getHost()).thenReturn(xsHost);
+ when(citrixResourceBase.getHost().getUuid()).thenReturn(uuid);
+
+ PowerMockito.mockStatic(Pool.Record.class);
+
+ when(pool.getRecord(conn)).thenReturn(poolr);
+ poolr.master = master;
+ when(poolr.master.getRecord(conn)).thenReturn(hostr);
+ hostr.uuid = uuid;
+
+ } catch (final BadServerResponse e) {
+ fail(e.getMessage());
+ } catch (final XenAPIException e) {
+ fail(e.getMessage());
+ } catch (final XmlRpcException e) {
+ fail(e.getMessage());
+ }
+
+ final Answer answer = wrapper.execute(vmDataSync, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testCheckNetworkCommandSuccess() {
+ final List<PhysicalNetworkSetupInfo> setupInfos = new ArrayList<PhysicalNetworkSetupInfo>();
+
+ final CheckNetworkCommand checkNet = new CheckNetworkCommand(setupInfos);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(checkNet, citrixResourceBase);
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testCheckNetworkCommandFailure() {
+ final PhysicalNetworkSetupInfo info = new PhysicalNetworkSetupInfo();
+
+ final List<PhysicalNetworkSetupInfo> setupInfos = new ArrayList<PhysicalNetworkSetupInfo>();
+ setupInfos.add(info);
+
+ final CheckNetworkCommand checkNet = new CheckNetworkCommand(setupInfos);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(checkNet, citrixResourceBase);
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testPlugNicCommand() {
+ final NicTO nicTO = Mockito.mock(NicTO.class);
+ final Connection conn = Mockito.mock(Connection.class);
+
+ final PlugNicCommand plugNic = new PlugNicCommand(nicTO, "Test", VirtualMachine.Type.User);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+
+ final Answer answer = wrapper.execute(plugNic, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testUnPlugNicCommand() {
+ final NicTO nicTO = Mockito.mock(NicTO.class);
+ final Connection conn = Mockito.mock(Connection.class);
+
+ final UnPlugNicCommand unplugNic = new UnPlugNicCommand(nicTO, "Test");
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+
+ final Answer answer = wrapper.execute(unplugNic, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testCreateVMSnapshotCommand() {
+ final Connection conn = Mockito.mock(Connection.class);
+
+ final VMSnapshotTO snapshotTO = Mockito.mock(VMSnapshotTO.class);
+ final List<VolumeObjectTO> volumeTOs = new ArrayList<VolumeObjectTO>();
+
+ final CreateVMSnapshotCommand vmSnapshot = new CreateVMSnapshotCommand("Test", snapshotTO, volumeTOs, "Debian");
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+
+ final Answer answer = wrapper.execute(vmSnapshot, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testDeleteVMSnapshotCommand() {
+ final Connection conn = Mockito.mock(Connection.class);
+
+ final VMSnapshotTO snapshotTO = Mockito.mock(VMSnapshotTO.class);
+ final List<VolumeObjectTO> volumeTOs = new ArrayList<VolumeObjectTO>();
+
+ final DeleteVMSnapshotCommand vmSnapshot = new DeleteVMSnapshotCommand("Test", snapshotTO, volumeTOs, "Debian");
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+
+ final Answer answer = wrapper.execute(vmSnapshot, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testRevertToVMSnapshotCommand() {
+ final Connection conn = Mockito.mock(Connection.class);
+
+ final VMSnapshotTO snapshotTO = Mockito.mock(VMSnapshotTO.class);
+ final List<VolumeObjectTO> volumeTOs = new ArrayList<VolumeObjectTO>();
+
+ final RevertToVMSnapshotCommand vmSnapshot = new RevertToVMSnapshotCommand("Test", snapshotTO, volumeTOs, "Debian");
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+
+ final Answer answer = wrapper.execute(vmSnapshot, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testNetworkRulesVmSecondaryIpCommandSuccess() {
+ final Connection conn = Mockito.mock(Connection.class);
+
+ final NetworkRulesVmSecondaryIpCommand rulesVm = new NetworkRulesVmSecondaryIpCommand("Test", VirtualMachine.Type.User);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ when(citrixResourceBase.callHostPlugin(conn, "vmops", "network_rules_vmSecondaryIp", "vmName", rulesVm.getVmName(), "vmMac", rulesVm.getVmMac(),
+ "vmSecIp", rulesVm.getVmSecIp(), "action", rulesVm.getAction())).thenReturn("true");
+
+ final Answer answer = wrapper.execute(rulesVm, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testNetworkRulesVmSecondaryIpCommandFailure() {
+ final Connection conn = Mockito.mock(Connection.class);
+
+ final NetworkRulesVmSecondaryIpCommand rulesVm = new NetworkRulesVmSecondaryIpCommand("Test", VirtualMachine.Type.User);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ when(citrixResourceBase.callHostPlugin(conn, "vmops", "network_rules_vmSecondaryIp", "vmName", rulesVm.getVmName(), "vmMac", rulesVm.getVmMac(),
+ "vmSecIp", rulesVm.getVmSecIp(), "action", rulesVm.getAction())).thenReturn("false");
+
+ final Answer answer = wrapper.execute(rulesVm, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testScaleVmCommand() {
+ final String uuid = "6172d8b7-ba10-4a70-93f9-ecaf41f51d53";
+
+ final VirtualMachineTO machineTO = Mockito.mock(VirtualMachineTO.class);
+ final Connection conn = Mockito.mock(Connection.class);
+ final XsHost xsHost = Mockito.mock(XsHost.class);
+ final Host host = Mockito.mock(Host.class);
+
+ final ScaleVmCommand scaleVm = new ScaleVmCommand(machineTO);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ when(citrixResourceBase.getHost()).thenReturn(xsHost);
+ when(citrixResourceBase.getHost().getUuid()).thenReturn(uuid);
+
+ try {
+ when(citrixResourceBase.isDmcEnabled(conn, host)).thenReturn(true);
+ } catch (final XenAPIException e) {
+ fail(e.getMessage());
+ } catch (final XmlRpcException e) {
+ fail(e.getMessage());
+ }
+
+ final Answer answer = wrapper.execute(scaleVm, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testPvlanSetupCommandDhcpSuccess() {
+ final String label = "net";
+
+ final Connection conn = Mockito.mock(Connection.class);
+ final XsLocalNetwork network = Mockito.mock(XsLocalNetwork.class);
+ final Network network2 = Mockito.mock(Network.class);
+
+ final PvlanSetupCommand lanSetup = PvlanSetupCommand.createDhcpSetup("add", URI.create("http://127.0.0.1"), "tag", "dhcp", "0:0:0:0:0:0", "127.0.0.1");
+
+ final String primaryPvlan = lanSetup.getPrimary();
+ final String isolatedPvlan = lanSetup.getIsolated();
+ final String op = lanSetup.getOp();
+ final String dhcpName = lanSetup.getDhcpName();
+ final String dhcpMac = lanSetup.getDhcpMac();
+ final String dhcpIp = lanSetup.getDhcpIp();
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ try {
+ when(citrixResourceBase.getNativeNetworkForTraffic(conn, TrafficType.Guest, "tag")).thenReturn(network);
+ when(network.getNetwork()).thenReturn(network2);
+ when(network2.getNameLabel(conn)).thenReturn(label);
+ } catch (final XenAPIException e) {
+ fail(e.getMessage());
+ } catch (final XmlRpcException e) {
+ fail(e.getMessage());
+ }
+
+ when(citrixResourceBase.callHostPlugin(conn, "ovs-pvlan", "setup-pvlan-dhcp", "op", op, "nw-label", label, "primary-pvlan", primaryPvlan, "isolated-pvlan",
+ isolatedPvlan, "dhcp-name", dhcpName, "dhcp-ip", dhcpIp, "dhcp-mac", dhcpMac)).thenReturn("true");
+
+ final Answer answer = wrapper.execute(lanSetup, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testPvlanSetupCommandDhcpFailure() {
+ final String label = "net";
+
+ final Connection conn = Mockito.mock(Connection.class);
+ final XsLocalNetwork network = Mockito.mock(XsLocalNetwork.class);
+ final Network network2 = Mockito.mock(Network.class);
+
+ final PvlanSetupCommand lanSetup = PvlanSetupCommand.createDhcpSetup("add", URI.create("http://127.0.0.1"), "tag", "dhcp", "0:0:0:0:0:0", "127.0.0.1");
+
+ final String primaryPvlan = lanSetup.getPrimary();
+ final String isolatedPvlan = lanSetup.getIsolated();
+ final String op = lanSetup.getOp();
+ final String dhcpName = lanSetup.getDhcpName();
+ final String dhcpMac = lanSetup.getDhcpMac();
+ final String dhcpIp = lanSetup.getDhcpIp();
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ try {
+ when(citrixResourceBase.getNativeNetworkForTraffic(conn, TrafficType.Guest, "tag")).thenReturn(network);
+ when(network.getNetwork()).thenReturn(network2);
+ when(network2.getNameLabel(conn)).thenReturn(label);
+ } catch (final XenAPIException e) {
+ fail(e.getMessage());
+ } catch (final XmlRpcException e) {
+ fail(e.getMessage());
+ }
+
+ when(citrixResourceBase.callHostPlugin(conn, "ovs-pvlan", "setup-pvlan-dhcp", "op", op, "nw-label", label, "primary-pvlan", primaryPvlan, "isolated-pvlan",
+ isolatedPvlan, "dhcp-name", dhcpName, "dhcp-ip", dhcpIp, "dhcp-mac", dhcpMac)).thenReturn("false");
+
+ final Answer answer = wrapper.execute(lanSetup, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testPvlanSetupCommandVmSuccess() {
+ final String label = "net";
+
+ final Connection conn = Mockito.mock(Connection.class);
+ final XsLocalNetwork network = Mockito.mock(XsLocalNetwork.class);
+ final Network network2 = Mockito.mock(Network.class);
+
+ final PvlanSetupCommand lanSetup = PvlanSetupCommand.createVmSetup("add", URI.create("http://127.0.0.1"), "tag", "0:0:0:0:0:0");
+
+ final String primaryPvlan = lanSetup.getPrimary();
+ final String isolatedPvlan = lanSetup.getIsolated();
+ final String op = lanSetup.getOp();
+ final String vmMac = lanSetup.getVmMac();
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ try {
+ when(citrixResourceBase.getNativeNetworkForTraffic(conn, TrafficType.Guest, "tag")).thenReturn(network);
+ when(network.getNetwork()).thenReturn(network2);
+ when(network2.getNameLabel(conn)).thenReturn(label);
+ } catch (final XenAPIException e) {
+ fail(e.getMessage());
+ } catch (final XmlRpcException e) {
+ fail(e.getMessage());
+ }
+
+ when(citrixResourceBase.callHostPlugin(conn, "ovs-pvlan", "setup-pvlan-vm", "op", op, "nw-label", label, "primary-pvlan", primaryPvlan, "isolated-pvlan",
+ isolatedPvlan, "vm-mac", vmMac)).thenReturn("true");
+
+ final Answer answer = wrapper.execute(lanSetup, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testPvlanSetupCommandVmFailure() {
+ final String label = "net";
+
+ final Connection conn = Mockito.mock(Connection.class);
+ final XsLocalNetwork network = Mockito.mock(XsLocalNetwork.class);
+ final Network network2 = Mockito.mock(Network.class);
+
+ final PvlanSetupCommand lanSetup = PvlanSetupCommand.createVmSetup("add", URI.create("http://127.0.0.1"), "tag", "0:0:0:0:0:0");
+
+ final String primaryPvlan = lanSetup.getPrimary();
+ final String isolatedPvlan = lanSetup.getIsolated();
+ final String op = lanSetup.getOp();
+ final String vmMac = lanSetup.getVmMac();
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ try {
+ when(citrixResourceBase.getNativeNetworkForTraffic(conn, TrafficType.Guest, "tag")).thenReturn(network);
+ when(network.getNetwork()).thenReturn(network2);
+ when(network2.getNameLabel(conn)).thenReturn(label);
+ } catch (final XenAPIException e) {
+ fail(e.getMessage());
+ } catch (final XmlRpcException e) {
+ fail(e.getMessage());
+ }
+
+ when(citrixResourceBase.callHostPlugin(conn, "ovs-pvlan", "setup-pvlan-vm", "op", op, "nw-label", label, "primary-pvlan", primaryPvlan, "isolated-pvlan",
+ isolatedPvlan, "vm-mac", vmMac)).thenReturn("false");
+
+ final Answer answer = wrapper.execute(lanSetup, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testPerformanceMonitorCommandSuccess() {
+ final Connection conn = Mockito.mock(Connection.class);
+
+ final PerformanceMonitorCommand performanceMonitor = new PerformanceMonitorCommand(new Hashtable<String, String>(), 200);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ when(citrixResourceBase.getPerfMon(conn, performanceMonitor.getParams(), performanceMonitor.getWait())).thenReturn("performance");
+
+ final Answer answer = wrapper.execute(performanceMonitor, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testPerformanceMonitorCommandFailure() {
+ final Connection conn = Mockito.mock(Connection.class);
+
+ final PerformanceMonitorCommand performanceMonitor = new PerformanceMonitorCommand(new Hashtable<String, String>(), 200);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getConnection()).thenReturn(conn);
+ when(citrixResourceBase.getPerfMon(conn, performanceMonitor.getParams(), performanceMonitor.getWait())).thenReturn(null);
+
+ final Answer answer = wrapper.execute(performanceMonitor, citrixResourceBase);
+
+ verify(citrixResourceBase, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+
+ @Test
+ public void testIpAssocVpcCommand() {
+ final VirtualRoutingResource routingResource = Mockito.mock(VirtualRoutingResource.class);
+ final IpAddressTO [] ips = new IpAddressTO[0];
+
+ final IpAssocVpcCommand ipAssociation = new IpAssocVpcCommand(ips);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getVirtualRoutingResource()).thenReturn(routingResource);
+
+ final Answer answer = wrapper.execute(ipAssociation, citrixResourceBase);
+
+ verify(routingResource, times(1)).executeRequest(ipAssociation);
+
+ // Requires more testing, but the VirtualResourceRouting is quite big.
+ assertNull(answer);
+ }
+
+ @Test
+ public void testIpAssocCommand() {
+ final VirtualRoutingResource routingResource = Mockito.mock(VirtualRoutingResource.class);
+ final IpAddressTO [] ips = new IpAddressTO[0];
+
+ final IpAssocCommand ipAssociation = new IpAssocCommand(ips);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(citrixResourceBase.getVirtualRoutingResource()).thenReturn(routingResource);
+
+ final Answer answer = wrapper.execute(ipAssociation, citrixResourceBase);
+
+ verify(routingResource, times(1)).executeRequest(ipAssociation);
+
+ // Requires more testing, but the VirtualResourceRouting is quite big.
+ assertNull(answer);
+ }
+
+ @Test
+ public void testStorageSubSystemCommand() {
+ final DiskTO disk = Mockito.mock(DiskTO.class);
+ final String vmName = "Test";
+ final AttachCommand command = new AttachCommand(disk, vmName);
+
+ final StorageSubsystemCommandHandler handler = Mockito.mock(StorageSubsystemCommandHandler.class);
+ when(citrixResourceBase.getStorageHandler()).thenReturn(handler);
+
+ when(handler.handleStorageCommands(command)).thenReturn(new AttachAnswer(disk));
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ final Answer answer = wrapper.execute(command, citrixResourceBase);
+ assertTrue(answer.getResult());
+ }
+}
+
+class NotAValidCommand extends Command {
+
+ @Override
+ public boolean executeInSequence() {
+ return false;
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/b155129a/plugins/hypervisors/xenserver/test/com/cloud/hypervisor/xenserver/resource/wrapper/xenbase/XcpServerWrapperTest.java
----------------------------------------------------------------------
diff --git a/plugins/hypervisors/xenserver/test/com/cloud/hypervisor/xenserver/resource/wrapper/xenbase/XcpServerWrapperTest.java b/plugins/hypervisors/xenserver/test/com/cloud/hypervisor/xenserver/resource/wrapper/xenbase/XcpServerWrapperTest.java
new file mode 100644
index 0000000..6b9f9a9
--- /dev/null
+++ b/plugins/hypervisors/xenserver/test/com/cloud/hypervisor/xenserver/resource/wrapper/xenbase/XcpServerWrapperTest.java
@@ -0,0 +1,116 @@
+// 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.hypervisor.xenserver.resource.wrapper.xenbase;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import com.cloud.agent.api.Answer;
+import com.cloud.agent.api.NetworkUsageCommand;
+import com.cloud.hypervisor.xenserver.resource.XcpServerResource;
+import com.cloud.utils.exception.CloudRuntimeException;
+import com.xensource.xenapi.Connection;
+
+@RunWith(PowerMockRunner.class)
+public class XcpServerWrapperTest {
+
+ @Mock
+ protected XcpServerResource XcpServerResource;
+
+
+ @Test
+ public void testNetworkUsageCommandCreate() {
+ final Connection conn = Mockito.mock(Connection.class);
+
+ final String privateIP = "192.168.0.10";
+ final String domRName = "dom";
+ final String option = "create";
+ final boolean forVpc = true;
+
+ final NetworkUsageCommand usageCommand = new NetworkUsageCommand(privateIP, domRName, option, forVpc);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(XcpServerResource.getConnection()).thenReturn(conn);
+ when(XcpServerResource.networkUsage(conn, usageCommand.getPrivateIP(), "create", null)).thenReturn("success");
+
+ final Answer answer = wrapper.execute(usageCommand, XcpServerResource);
+
+ verify(XcpServerResource, times(1)).getConnection();
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testNetworkUsageCommandGet() {
+ final Connection conn = Mockito.mock(Connection.class);
+
+ final String privateIP = "192.168.0.10";
+ final String domRName = "dom";
+ final boolean forVpc = true;
+ final String gatewayIp = "172.16.0.10";
+
+ final NetworkUsageCommand usageCommand = new NetworkUsageCommand(privateIP, domRName, forVpc, gatewayIp);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(XcpServerResource.getConnection()).thenReturn(conn);
+ when(XcpServerResource.getNetworkStats(conn, usageCommand.getPrivateIP())).thenReturn(new long[]{1l, 1l});
+
+ final Answer answer = wrapper.execute(usageCommand, XcpServerResource);
+
+ verify(XcpServerResource, times(1)).getConnection();
+
+ assertTrue(answer.getResult());
+ }
+
+ @Test
+ public void testNetworkUsageCommandExceptiopn() {
+ final Connection conn = Mockito.mock(Connection.class);
+
+ final String privateIP = "192.168.0.10";
+ final String domRName = "dom";
+ final String option = null;
+ final boolean forVpc = true;
+
+ final NetworkUsageCommand usageCommand = new NetworkUsageCommand(privateIP, domRName, option, forVpc);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(XcpServerResource.getConnection()).thenReturn(conn);
+ when(XcpServerResource.networkUsage(conn, usageCommand.getPrivateIP(), "create", null)).thenThrow(new CloudRuntimeException("FAILED"));
+
+ final Answer answer = wrapper.execute(usageCommand, XcpServerResource);
+
+ verify(XcpServerResource, times(1)).getConnection();
+
+ assertFalse(answer.getResult());
+ }
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/b155129a/plugins/hypervisors/xenserver/test/com/cloud/hypervisor/xenserver/resource/wrapper/xenbase/XenServer56FP1WrapperTest.java
----------------------------------------------------------------------
diff --git a/plugins/hypervisors/xenserver/test/com/cloud/hypervisor/xenserver/resource/wrapper/xenbase/XenServer56FP1WrapperTest.java b/plugins/hypervisors/xenserver/test/com/cloud/hypervisor/xenserver/resource/wrapper/xenbase/XenServer56FP1WrapperTest.java
new file mode 100644
index 0000000..0901275
--- /dev/null
+++ b/plugins/hypervisors/xenserver/test/com/cloud/hypervisor/xenserver/resource/wrapper/xenbase/XenServer56FP1WrapperTest.java
@@ -0,0 +1,65 @@
+// 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.hypervisor.xenserver.resource.wrapper.xenbase;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import com.cloud.agent.api.Answer;
+import com.cloud.agent.api.FenceCommand;
+import com.cloud.host.Host;
+import com.cloud.hypervisor.xenserver.resource.XenServer56FP1Resource;
+import com.cloud.vm.VMInstanceVO;
+import com.xensource.xenapi.Connection;
+
+@RunWith(PowerMockRunner.class)
+public class XenServer56FP1WrapperTest {
+
+ @Mock
+ private XenServer56FP1Resource xenServer56Resource;
+
+ @Test
+ public void testFenceCommand() {
+ final VMInstanceVO vm = Mockito.mock(VMInstanceVO.class);
+ final Host host = Mockito.mock(Host.class);
+
+ final Connection conn = Mockito.mock(Connection.class);
+
+ final FenceCommand fenceCommand = new FenceCommand(vm, host);
+
+ final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
+ assertNotNull(wrapper);
+
+ when(xenServer56Resource.getConnection()).thenReturn(conn);
+
+ final Answer answer = wrapper.execute(fenceCommand, xenServer56Resource);
+
+ verify(xenServer56Resource, times(1)).getConnection();
+ verify(xenServer56Resource, times(1)).checkHeartbeat(fenceCommand.getHostGuid());
+
+ assertFalse(answer.getResult());
+ }
+}
\ No newline at end of file