Java InstanceStatus.setInstanceProvisioningRequired方法代码示例

import org.oscm.app.data.InstanceStatus; //导入方法依赖的package包/类
@Test
public void testActivateInstance() throws Exception {
    final String instanceId = createService(ProvisioningStatus.COMPLETED);
    final BaseResult result = new BaseResult();
    result.setDesc("Ok");

    doReturn(result).when(provServiceMock).activateInstance(instanceId,
            null);

    InstanceStatus mockStatus = new InstanceStatus();
    mockStatus.setInstanceProvisioningRequired(true);
    when(
            controllerMock.activateInstance(anyString(),
                    any(ProvisioningSettings.class)))
            .thenReturn(mockStatus);

    BaseResult br = runTX(new Callable<BaseResult>() {
        @Override
        public BaseResult call() {
            return proxy.activateInstance(instanceId, null);
        }
    });
    verify(provServiceMock).activateInstance(instanceId, null);
    Assert.assertEquals(result.getDesc(), br.getDesc());
    Assert.assertEquals(result.getRc(), br.getRc());
}
 

import org.oscm.app.data.InstanceStatus; //导入方法依赖的package包/类
@Test
public void testDeactivateInstance() throws Exception {
    final String instanceId = createService(ProvisioningStatus.COMPLETED);
    final BaseResult result = new BaseResult();
    result.setDesc("Ok");
    doReturn(result).when(provServiceMock).deactivateInstance(instanceId,
            null);

    InstanceStatus mockStatus = new InstanceStatus();
    mockStatus.setInstanceProvisioningRequired(true);
    when(
            controllerMock.deactivateInstance(anyString(),
                    any(ProvisioningSettings.class)))
            .thenReturn(mockStatus);

    BaseResult br = runTX(new Callable<BaseResult>() {
        @Override
        public BaseResult call() {
            return proxy.deactivateInstance(instanceId, null);
        }
    });
    verify(provServiceMock).deactivateInstance(instanceId, null);
    Assert.assertEquals(result.getDesc(), br.getDesc());
    Assert.assertEquals(result.getRc(), br.getRc());
}
 

import org.oscm.app.data.InstanceStatus; //导入方法依赖的package包/类
@Test
public void testHandleTimerOneCreatingServiceInstance_withInstProv()
        throws Exception {

    // given
    createServiceInstance(ProvisioningStatus.WAITING_FOR_SYSTEM_CREATION,
            InstanceParameter.PUBLIC_IP);

    InstanceStatus status = new InstanceStatus();
    List<LocalizedText> list = new ArrayList<>();
    list.add(new LocalizedText("en", "finished"));
    status.setDescription(list);
    status.setIsReady(true);
    status.setChangedParameters(null);
    status.setInstanceProvisioningRequired(true);
    when(controller.getInstanceStatus(matches("appInstanceId"),
            any(ProvisioningSettings.class))).thenReturn(status);

    // when
    handleTimer();

    // then
    validateServiceInstanceStatus(
            ProvisioningStatus.WAITING_FOR_SYSTEM_CREATION);
    validateServiceInstanceFlags(null, new Boolean[] { Boolean.TRUE },
            new Boolean[] { Boolean.TRUE });
}
 

import org.oscm.app.data.InstanceStatus; //导入方法依赖的package包/类
@Test
public void testHandleTimerOneModifyingServiceInstance_Ready()
        throws Exception {
    // given
    requestInstanceProvisioning = false;
    setControllerReady = false;
    createServiceInstance(
            ProvisioningStatus.WAITING_FOR_SYSTEM_MODIFICATION,
            InstanceParameter.PUBLIC_IP);
    InstanceStatus status1 = new InstanceStatus();
    status1.setIsReady(false);
    status1.setInstanceProvisioningRequired(true);
    InstanceStatus status2 = new InstanceStatus();
    status2.setIsReady(true);
    status2.setInstanceProvisioningRequired(false);

    when(controller.getInstanceStatus(anyString(),
            any(ProvisioningSettings.class))).thenReturn(status1, status2);

    // when
    handleTimer();
    handleTimer();
    handleTimer();

    // then
    verify(provFactoryBean, timeout(1))
            .getInstance(any(ServiceInstance.class));
    validateServiceInstanceStatus(ProvisioningStatus.COMPLETED);
    validateServiceInstanceFlags(null, new Boolean[] { Boolean.FALSE },
            new Boolean[] { Boolean.TRUE });
}
 

import org.oscm.app.data.InstanceStatus; //导入方法依赖的package包/类
@Test
public void testHandleTimerReadyButNoPublicIP() throws Exception {
    // given
    createServiceInstance(ProvisioningStatus.WAITING_FOR_SYSTEM_CREATION);

    InstanceStatus status = new InstanceStatus();
    status.setIsReady(true);
    status.setInstanceProvisioningRequired(true);
    HashMap<String, Setting> parameters = new HashMap<>();
    parameters.put(InstanceParameter.PUBLIC_IP,
            new Setting(InstanceParameter.PUBLIC_IP, ""));
    status.setChangedParameters(parameters);
    List<LocalizedText> list = new ArrayList<>();
    list.add(new LocalizedText("en", "nextStep"));
    status.setDescription(list);
    when(controller.getInstanceStatus(anyString(),
            any(ProvisioningSettings.class))).thenReturn(status);

    ServiceInstance si = getServiceInstance();
    Assert.assertTrue(si.getRunWithTimer());

    // when
    handleTimer();

    // then
    verify(mailService).sendMail(anyListOf(String.class), anyString(),
            anyString());
    si = getServiceInstance();
    Assert.assertFalse(si.getRunWithTimer());
    validateServiceInstanceStatus(
            ProvisioningStatus.WAITING_FOR_SYSTEM_CREATION);
}
 

import org.oscm.app.data.InstanceStatus; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
@Test
public void testUpdateUsers() throws Exception {
    final String instanceId = createService(ProvisioningStatus.COMPLETED);
    final List<User> users = new ArrayList<>();
    final BaseResult result = new BaseResult();
    result.setDesc("Ok");

    doReturn(result).when(provServiceMock).updateUsers(instanceId, users,
            null);

    InstanceStatus mockStatus = new InstanceStatus();
    mockStatus.setInstanceProvisioningRequired(true);
    when(
            controllerMock.updateUsers(anyString(),
                    any(ProvisioningSettings.class), any(List.class)))
            .thenReturn(mockStatus);

    BaseResult br = runTX(new Callable<BaseResult>() {
        @Override
        public BaseResult call() {
            return proxy.updateUsers(instanceId, users, null);
        }
    });
    Assert.assertEquals(result.getDesc(), br.getDesc());
    Assert.assertEquals(result.getRc(), br.getRc());
    verify(provServiceMock).updateUsers(instanceId, users, null);
}
 

import org.oscm.app.data.InstanceStatus; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
@Test
public void testDeleteUsers() throws Exception {
    final String instanceId = createService(ProvisioningStatus.COMPLETED);
    final List<User> users = new ArrayList<>();
    final BaseResult result = new BaseResult();
    result.setDesc("Ok");

    doReturn(result).when(provServiceMock).deleteUsers(instanceId, users,
            null);

    InstanceStatus mockStatus = new InstanceStatus();
    mockStatus.setInstanceProvisioningRequired(true);
    when(
            controllerMock.deleteUsers(anyString(),
                    any(ProvisioningSettings.class), any(List.class)))
            .thenReturn(mockStatus);

    BaseResult br = runTX(new Callable<BaseResult>() {
        @Override
        public BaseResult call() {
            return proxy.deleteUsers(instanceId, users, null);
        }
    });
    Assert.assertEquals(result.getDesc(), br.getDesc());
    Assert.assertEquals(result.getRc(), br.getRc());
    verify(provServiceMock).deleteUsers(instanceId, users, null);
}
 

import org.oscm.app.data.InstanceStatus; //导入方法依赖的package包/类
@Test
public void modifySubscription_ProductFailure() throws Exception {
    final String instanceId = createService(ProvisioningStatus.COMPLETED);
    final String subscriptionId = "";
    final BaseResult result = new BaseResult();
    result.setRc(1);

    doReturn(result).when(provServiceMock).modifySubscription(instanceId,
            subscriptionId, "referenceId",
            new ArrayList<ServiceParameter>(),
            new ArrayList<ServiceAttribute>(), null);

    InstanceStatus mockStatus = new InstanceStatus();
    mockStatus.setInstanceProvisioningRequired(true);
    when(
            controllerMock.modifyInstance(anyString(),
                    any(ProvisioningSettings.class),
                    any(ProvisioningSettings.class)))
            .thenReturn(mockStatus);

    BaseResult br = runTX(new Callable<BaseResult>() {
        @Override
        public BaseResult call() {
            return proxy.asyncModifySubscription(instanceId,
                    subscriptionId, "referenceId",
                    new ArrayList<ServiceParameter>(),
                    new ArrayList<ServiceAttribute>(), null);
        }
    });
    Assert.assertEquals(result.getDesc(), br.getDesc());
    Assert.assertEquals(result.getRc(), br.getRc());
    verify(provServiceMock).modifySubscription(instanceId, subscriptionId,
            "referenceId", new ArrayList<ServiceParameter>(),
            new ArrayList<ServiceAttribute>(), null);
}
 

import org.oscm.app.data.InstanceStatus; //导入方法依赖的package包/类
@Test
public void testDeleteInstance() throws Exception {
    // given
    final String instanceId = createService(ProvisioningStatus.COMPLETED);
    final BaseResult result = new BaseResult();
    result.setDesc("Ok");
    doReturn(result).when(provServiceMock).deleteInstance(eq(instanceId),
            anyString(), anyString(), any(User.class));

    InstanceStatus mockStatus = new InstanceStatus();
    mockStatus.setInstanceProvisioningRequired(true);
    when(
            controllerMock.deleteInstance(anyString(),
                    any(ProvisioningSettings.class)))
            .thenReturn(mockStatus);

    // when
    BaseResult br = runTX(new Callable<BaseResult>() {
        @Override
        public BaseResult call() {
            return proxy.deleteInstance(instanceId, organizationId,
                    subscriptionId, null);
        }
    });

    // then
    verify(provServiceMock).deleteInstance(instanceId, organizationId,
            subscriptionId, null);
    assertEquals(result.getRc(), br.getRc());
    assertEquals(result.getDesc(), br.getDesc());
}
 

import org.oscm.app.data.InstanceStatus; //导入方法依赖的package包/类
@Test
public void upgradeSubscription() throws Exception {
    final List<ServiceParameter> parameters = new ArrayList<>();
    final List<ServiceAttribute> attributes = new ArrayList<>();

    ServiceParameter p1 = new ServiceParameter();
    p1.setParameterId("param1");
    p1.setValue("value1");
    parameters.add(p1);
    ServiceParameter p2 = new ServiceParameter();
    p2.setParameterId("APP_param2");
    p2.setValue("xxxx");
    parameters.add(p2);

    ServiceAttribute a1 = new ServiceAttribute();
    a1.setAttributeId("attr1");
    a1.setValue("value1");
    attributes.add(a1);

    final List<ServiceParameter> filteredParameters = new ArrayList<>();
    filteredParameters.add(p1);

    final String subscriptionId = "subscriptionId_new";
    InstanceStatus mockStatus = new InstanceStatus();
    mockStatus.setInstanceProvisioningRequired(false);

    final String instanceId = createService(ProvisioningStatus.COMPLETED,
            "param1", "1", "APP_param2", "xyz");

    when(
            controllerMock.modifyInstance(anyString(),
                    any(ProvisioningSettings.class),
                    any(ProvisioningSettings.class)))
            .thenReturn(mockStatus);
    final BaseResult result = runTX(new Callable<BaseResult>() {
        @Override
        public BaseResult call() {
            return proxy.asyncUpgradeSubscription(instanceId,
                    subscriptionId, "referenceId", parameters, attributes,
                    null);
        }
    });

    final ServiceInstance si = runTX(new Callable<ServiceInstance>() {
        @Override
        public ServiceInstance call()
                throws ServiceInstanceNotFoundException {
            return instanceDAO.getInstanceById(instanceId);
        }
    });
    assertEquals(subscriptionId, si.getSubscriptionId());
    assertEquals(0, result.getRc());
    assertEquals("Ok", result.getDesc());

    ArgumentCaptor<String> stringCaptor = ArgumentCaptor
            .forClass(String.class);
    ArgumentCaptor<ProvisioningSettings> oldCaptor = ArgumentCaptor
            .forClass(ProvisioningSettings.class);
    ArgumentCaptor<ProvisioningSettings> newCaptor = ArgumentCaptor
            .forClass(ProvisioningSettings.class);
    verify(controllerMock, times(1)).modifyInstance(stringCaptor.capture(),
            oldCaptor.capture(), newCaptor.capture());
    assertEquals("appId123", stringCaptor.getValue());
    final Map<String, String> expectedNew = new HashMap<>();
    expectedNew.put("param1", "value1");
    expectedNew.put("APP_param2", "xxxx");
    Map<String, Setting> params = newCaptor.getValue().getParameters();
    assertEquals("value1", params.get("param1").getValue());
    assertEquals("xxxx", params.get("APP_param2").getValue());
    final Map<String, String> expectedOld = new HashMap<>();
    expectedOld.put("param1", "1");
    expectedOld.put("APP_param2", "xyz");
    params = oldCaptor.getValue().getParameters();
    assertEquals("1", params.get("param1").getValue());
    assertEquals("xyz", params.get("APP_param2").getValue());
}