vid-automation/src/main/java/vid/automation/test/test/NewServiceInstanceTest.java

   1 package vid.automation.test.test;
   2
   3 import static java.util.Collections.emptyList;
   4 import static junit.framework.TestCase.assertNull;
   5 import static org.apache.commons.lang3.RandomStringUtils.randomAlphabetic;
   6 import static org.hamcrest.CoreMatchers.startsWith;
   7 import static org.hamcrest.MatcherAssert.assertThat;
   8 import static org.hamcrest.Matchers.containsInAnyOrder;
   9 import static org.onap.simulator.presetGenerator.presets.aai.PresetAAIGetCloudOwnersByCloudRegionId.PRESET_MTN6_TO_ATT_AIC;
  10 import static org.onap.simulator.presetGenerator.presets.aai.PresetAAIGetCloudOwnersByCloudRegionId.PRESET_SOME_LEGACY_REGION_TO_ATT_AIC;
  11 import static org.onap.simulator.presetGenerator.presets.mso.PresetMSOOrchestrationRequestGet.COMPLETE;
  12 import static org.onap.simulator.presetGenerator.presets.mso.PresetMSOOrchestrationRequestGet.DEFAULT_SERVICE_INSTANCE_ID;
  13 import static org.testng.Assert.assertEquals;
  14 import static org.testng.AssertJUnit.assertTrue;
  15 import static vid.automation.test.infra.Features.FLAG_1902_VNF_GROUPING;
  16 import static vid.automation.test.infra.Features.FLAG_1908_COLLECTION_RESOURCE_NEW_INSTANTIATION_UI;
  17 import static vid.automation.test.infra.Features.FLAG_1908_INFRASTRUCTURE_VPN;
  18 import static vid.automation.test.infra.Features.FLAG_1908_MACRO_NOT_TRANSPORT_NEW_VIEW_EDIT;
  19 import static vid.automation.test.infra.Features.FLAG_1908_TRANSPORT_SERVICE_NEW_INSTANTIATION_UI;
  20 import static vid.automation.test.infra.Features.FLAG_2002_ANY_ALACARTE_BESIDES_EXCLUDED_NEW_INSTANTIATION_UI;
  21 import static vid.automation.test.infra.Features.FLAG_5G_IN_NEW_INSTANTIATION_UI;
  22 import static vid.automation.test.infra.Features.FLAG_ENABLE_WEBPACK_MODERN_UI;
  23 import static vid.automation.test.infra.ModelInfo.aLaCarteNetworkProvider5G;
  24 import static vid.automation.test.infra.ModelInfo.aLaCarteVnfGroupingService;
  25 import static vid.automation.test.infra.ModelInfo.collectionResourceService;
  26 import static vid.automation.test.infra.ModelInfo.infrastructureVpnService;
  27 import static vid.automation.test.infra.ModelInfo.macroSriovNoDynamicFieldsEcompNamingFalseFullModelDetails;
  28 import static vid.automation.test.infra.ModelInfo.macroSriovNoDynamicFieldsEcompNamingFalseFullModelDetailsVnfEcompNamingFalse;
  29 import static vid.automation.test.infra.ModelInfo.macroSriovWithDynamicFieldsEcompNamingFalsePartialModelDetailsVnfEcompNamingFalse;
  30 import static vid.automation.test.infra.ModelInfo.macroSriovWithDynamicFieldsEcompNamingTruePartialModelDetails;
  31 import static vid.automation.test.infra.ModelInfo.pasqualeVmxVpeBvService488Annotations;
  32 import static vid.automation.test.infra.ModelInfo.transportWithPnfsService;
  33 import static vid.automation.test.services.SimulatorApi.RegistrationStrategy.APPEND;
  34 import static vid.automation.test.services.SimulatorApi.registerExpectationFromPreset;
  35 import static vid.automation.test.services.SimulatorApi.registerExpectationFromPresets;
  36 import static vid.automation.test.test.ALaCarteflowTest.AIC;
  37
  38 import com.google.common.collect.ImmutableList;
  39 import com.google.common.collect.ImmutableMap;
  40 import com.google.common.collect.ImmutableSet;
  41 import java.text.ParseException;
  42 import java.text.SimpleDateFormat;
  43 import java.util.ArrayList;
  44 import java.util.Arrays;
  45 import java.util.Collections;
  46 import java.util.Date;
  47 import java.util.HashMap;
  48 import java.util.List;
  49 import java.util.Map;
  50 import java.util.Set;
  51 import java.util.UUID;
  52 import java.util.stream.Collectors;
  53 import org.apache.commons.lang3.mutable.MutableInt;
  54 import org.apache.logging.log4j.LogManager;
  55 import org.apache.logging.log4j.Logger;
  56 import org.hamcrest.Matchers;
  57 import org.jetbrains.annotations.NotNull;
  58 import org.onap.sdc.ci.tests.datatypes.UserCredentials;
  59 import org.onap.sdc.ci.tests.utilities.GeneralUIUtils;
  60 import org.onap.simulator.presetGenerator.presets.aai.PresetAAIGetL3NetworksByCloudRegionSpecificState;
  61 import org.onap.simulator.presetGenerator.presets.aai.PresetAAIGetTenants;
  62 import org.onap.simulator.presetGenerator.presets.aai.PresetAAIGetVpnsByType;
  63 import org.onap.simulator.presetGenerator.presets.aai.PresetAAIPostNamedQueryForViewEdit;
  64 import org.onap.simulator.presetGenerator.presets.mso.PresetMSOBaseCreateInstancePost;
  65 import org.onap.simulator.presetGenerator.presets.mso.PresetMSOCreateNetworkALaCarte5G;
  66 import org.onap.simulator.presetGenerator.presets.mso.PresetMSOCreateServiceInstanceAlacarte;
  67 import org.onap.simulator.presetGenerator.presets.mso.PresetMSOCreateServiceInstanceGen2WithNamesAlacarteGroupingService;
  68 import org.onap.simulator.presetGenerator.presets.mso.PresetMSOCreateServiceInstanceGen2WithNamesEcompNamingFalse;
  69 import org.onap.simulator.presetGenerator.presets.mso.PresetMSOCreateVfModuleALaCarteE2E;
  70 import org.onap.simulator.presetGenerator.presets.mso.PresetMSOCreateVnfALaCarteE2E;
  71 import org.onap.simulator.presetGenerator.presets.mso.PresetMSOOrchestrationRequestGet;
  72 import org.onap.simulator.presetGenerator.presets.mso.PresetMSOOrchestrationRequestsGet5GServiceInstanceAndNetwork;
  73 import org.onap.simulator.presetGenerator.presets.mso.PresetMSOOrchestrationRequestsGet5GServiceInstanceAndNetwork.ResponseDetails;
  74 import org.onap.simulator.presetGenerator.presets.mso.PresetMSOServiceInstanceGen2WithNames.Keys;
  75 import org.onap.simulator.presetGenerator.presets.mso.PresetMsoCreateMacroCommonPre1806;
  76 import org.openqa.selenium.By;
  77 import org.openqa.selenium.WebElement;
  78 import org.openqa.selenium.remote.RemoteWebElement;
  79 import org.testng.Assert;
  80 import org.testng.annotations.AfterClass;
  81 import org.testng.annotations.BeforeClass;
  82 import org.testng.annotations.BeforeMethod;
  83 import org.testng.annotations.Test;
  84 import vid.automation.test.Constants;
  85 import vid.automation.test.Constants.BrowseASDC.NewServicePopup;
  86 import vid.automation.test.infra.Click;
  87 import vid.automation.test.infra.FeatureTogglingTest;
  88 import vid.automation.test.infra.Features;
  89 import vid.automation.test.infra.Get;
  90 import vid.automation.test.infra.Input;
  91 import vid.automation.test.infra.ModelInfo;
  92 import vid.automation.test.infra.ModelInfoWithCustomization;
  93 import vid.automation.test.infra.SelectOption;
  94 import vid.automation.test.infra.Wait;
  95 import vid.automation.test.model.Service;
  96 import vid.automation.test.model.User;
  97 import vid.automation.test.sections.BrowseASDCPage;
  98 import vid.automation.test.sections.DrawingBoardPage;
  99 import vid.automation.test.sections.InstantiationStatusPage;
 100 import vid.automation.test.sections.SideMenu;
 101 import vid.automation.test.sections.VidBasePage;
 102 import vid.automation.test.services.AsyncJobsService;
 103 import vid.automation.test.services.ServicesService;
 104 import vid.automation.test.services.SimulatorApi;
 105 import vid.automation.test.test.NewServiceInstanceTest.ServiceData.IS_GENERATED_NAMING;
 106 import vid.automation.test.utils.ReadFile;
 107
 108 @FeatureTogglingTest(FLAG_ENABLE_WEBPACK_MODERN_UI)
 109 public class NewServiceInstanceTest extends CreateInstanceDialogBaseTest {
 110
 111     public static final String COMPLETED = "COMPLETED";
 112     private static final String IN_PROGRESS = "IN_PROGRESS";
 113     private static final String PENDING = "PENDING";
 114     private final String vfModule0Name = "2017488_pasqualevpe0..2017488PasqualeVpe..PASQUALE_base_vPE_BV..module-0";
 115     private final String vfModule0UUID = "f8360508-3f17-4414-a2ed-6bc71161e8db";
 116     private ServicesService servicesService = new ServicesService();
 117     private DrawingBoardPage drawingBoardPage = new DrawingBoardPage();
 118     List<String> serviceModelLabelList = Arrays.asList("Model version", "Description", "Category", "UUID",
 119             "Invariant UUID", "Service type", "Service role");
 120     List<String> mandatoryServiceModelLabelList = Arrays.asList("Model version", "UUID", "Invariant UUID");
 121     private final VidBasePage vidBasePage = new VidBasePage();
 122     public static final String VNF_SET_BUTTON_TEST_ID = "form-set";
 123     private static final Logger logger = LogManager.getLogger(NewServiceInstanceTest.class);
 124     private static final String NO_MAX_INSTANCES_IN_MODEL = "NO_MAX_INSTANCES_IN_MODEL";
 125
 126     @BeforeClass
 127     protected void dropAllAsyncJobs() {
 128         AsyncJobsService asyncJobsService = new AsyncJobsService();
 129         asyncJobsService.dropAllAsyncJobs();
 130     }
 131
 132     @AfterClass
 133     protected void muteAllAsyncJobs() {
 134         AsyncJobsService asyncJobsService = new AsyncJobsService();
 135         asyncJobsService.muteAllAsyncJobs();
 136     }
 137
 138     @BeforeMethod
 139     protected void goToWelcome() {
 140         SideMenu.navigateToWelcomePage();
 141     }
 142
 143     @Override
 144     protected UserCredentials getUserCredentials() {
 145         String userName = Constants.Users.SILVIA_ROBBINS_TYLER_SILVIA;
 146         User user = usersService.getUser(userName);
 147         return new UserCredentials(user.credentials.userId, user.credentials.password, userName, "", "");
 148     }
 149
 150     @Test
 151     public void createNewServiceInstance_fullModelData_LeftPaneLabelsCorrect() throws Exception {
 152         prepareServicePreset(macroSriovNoDynamicFieldsEcompNamingFalseFullModelDetails, false);
 153         loadServicePopup(macroSriovNoDynamicFieldsEcompNamingFalseFullModelDetails);
 154         assertServiceModelLabelsCorrect(serviceModelLabelList);
 155     }
 156
 157     @Test
 158     public void createNewServiceInstance_partialModelData_LeftPaneLabelsCorrect() throws Exception {
 159         prepareServicePreset(macroSriovWithDynamicFieldsEcompNamingTruePartialModelDetails, false);
 160         loadServicePopup(macroSriovWithDynamicFieldsEcompNamingTruePartialModelDetails);
 161         assertServiceModelLabelsCorrect(mandatoryServiceModelLabelList);
 162     }
 163
 164     @Test
 165     public void createNewServiceInstance_setFieldValue_resetDependenciesListsAndValues() {
 166         resetGetTenantsCache();
 167         try {
 168             BrowseASDCPage browseASDCPage = new BrowseASDCPage();
 169             prepareServicePreset(macroSriovNoDynamicFieldsEcompNamingFalseFullModelDetails, false);
 170             SimulatorApi.registerExpectation(Constants.RegisterToSimulator.CreateNewServiceInstance.GET_SUBSCRIBERS_FOR_CUSTOMER_CAR_2020_ER, SimulatorApi.RegistrationStrategy.APPEND);
 171             registerExpectationFromPreset(
 172                     new PresetAAIGetTenants(
 173                             "CAR_2020_ER",
 174                             "MSO-dev-service-type",
 175                             "registration_to_simulator/create_new_instance/aai_get_tenants_for_customer_CAR_2020_ER.json"),
 176                     SimulatorApi.RegistrationStrategy.APPEND);
 177
 178             loadServicePopup(macroSriovNoDynamicFieldsEcompNamingFalseFullModelDetails);
 179             Wait.waitByClassAndText(Constants.CreateNewInstance.SUBSCRIBER_NAME_OPTION_CLASS, "SILVIA ROBBINS", 30);
 180             VidBasePage.selectSubscriberById("e433710f-9217-458d-a79d-1c7aff376d89");
 181             GeneralUIUtils.ultimateWait();
 182             String serviceType = "TYLER SILVIA";
 183             Wait.waitByClassAndText(Constants.CreateNewInstance.SERVICE_TYPE_OPTION_CLASS, serviceType, 30);
 184             browseASDCPage.selectServiceTypeByName(serviceType);
 185             String lcpRegion = "hvf6";
 186             Wait.waitByClassAndText("lcpRegionOption", lcpRegion, 30);
 187             viewEditPage.selectLcpRegion(lcpRegion, AIC);
 188             browseASDCPage.selectTenant("bae71557c5bb4d5aac6743a4e5f1d054");
 189
 190             VidBasePage.selectSubscriberById("CAR_2020_ER");
 191             assertElementDisabled("lcpRegion-select");
 192             serviceType = "MSO-dev-service-type";
 193             Wait.waitByClassAndText(Constants.CreateNewInstance.SERVICE_TYPE_OPTION_CLASS, serviceType, 30);
 194             browseASDCPage.selectServiceTypeByName(serviceType);
 195             lcpRegion = "CAR_2020_ER";
 196             Wait.waitByClassAndText("lcpRegionOption", lcpRegion, 30);
 197             viewEditPage.selectLcpRegion(lcpRegion, AIC);
 198             browseASDCPage.selectTenant("092eb9e8e4b7412e8787dd091bc58e66");
 199         } finally {
 200             resetGetTenantsCache();
 201         }
 202     }
 203
 204     /**
 205      * asserts that the provided labels list is visible and that no other detail item appears in the model details panel.
 206      */
 207     protected void assertServiceModelLabelsCorrect(List<String> serviceModelLabelList) throws Exception {
 208         WebElement genericPopup = getDriver().findElement(By.tagName("generic-form-popup"));
 209         WebElement modelInformation = genericPopup.findElement(By.id("model-information"));
 210         List<WebElement> modelInformationItems = modelInformation.findElements(By.xpath("./div"));
 211         assertEquals(modelInformationItems.size(), serviceModelLabelList.size());
 212         serviceModelLabelList.forEach(label -> {
 213             WebElement webElement = Get.byTestId("model-item-" + label);
 214             WebElement itemWarpper = webElement.findElements(By.className("wrapper")).get(0);
 215             assertEquals(itemWarpper.findElements(By.tagName("label")).get(0).getText(), label, "model details item label is incorrect.");
 216         });
 217     }
 218
 219     @Test
 220     public void createNewServiceInstance_leftPane_serviceModelDataCorrect() {
 221         Service service = servicesService.getService(macroSriovNoDynamicFieldsEcompNamingFalseFullModelDetails.modelVersionId);
 222         String prefix = NewServicePopup.SERVICE_MODEL_DATA_TEST_ID_VALUE_PREFIX;
 223         prepareServicePreset(macroSriovNoDynamicFieldsEcompNamingFalseFullModelDetails, false);
 224         loadServicePopup(macroSriovNoDynamicFieldsEcompNamingFalseFullModelDetails);
 225         logger.info("Expected service model properties: "+service.toString());
 226         assertModelDataCorrect(NewServicePopup.SERVICE_MODEL_FIELD_TO_DATA_TESTS_ID, prefix, service);
 227     }
 228
 229     @Test
 230     public void createNewServiceInstance_macro_validPopupDataAndUI__ecompNamingFalse() {
 231
 232         ServiceData serviceData = new ServiceData(
 233                 macroSriovNoDynamicFieldsEcompNamingFalseFullModelDetails.modelVersionId,
 234                 new ArrayList<>(),
 235                 IS_GENERATED_NAMING.FALSE, true, true, true,
 236                 "2017-488_PASQUALE-vPE 0",
 237                 "2017488_pasqualevpe0..2017488PasqualeVpe..PASQUALE_vRE_BV..module-1",
 238             0, NO_MAX_INSTANCES_IN_MODEL, new ArrayList<>(), "25284168-24bb-4698-8cb4-3f509146eca5", false);
 239
 240         prepareServicePreset(macroSriovNoDynamicFieldsEcompNamingFalseFullModelDetails, false);
 241
 242         final String serviceInstanceName = createMacroService(serviceData, true);
 243         createVnf(serviceData, true, serviceInstanceName);
 244
 245         createVfModule(serviceData, serviceInstanceName, false, false);
 246
 247     }
 248
 249     @Test(groups = "underDevelopment")
 250     public void createNewServiceInstance_macro_validPopupDataAndUI__dynamicFieldsEcompNamingFalse_DEV() {
 251         /*
 252         Upon failure in test dynamicFieldsEcompNamingFalse_FLESH(), exception will provide
 253         the needed data for this DEV method:
 254
 255           1. "Current step" when the failure occurred
 256           2. "Random alphabetic" that was randomized while test
 257           3. "Starting reduxState" that was on the step that failed.
 258
 259         These data can be used for, accordingly, 1. startInStep param; 2, randomAlphabetic
 260         param; 3. reduxForStep param.
 261          */
 262
 263         // It should be easier to put `reduxForStep` in this file, to avoid Java's code-clutter and json escaping.
 264         final String reduxForStep = ReadFile.loadResourceAsString(
 265                 "NewServiceInstanceTest/createNewServiceInstance_macro_validPopupDataAndUI__dynamicFieldsEcompNamingFalse.json");
 266
 267         createNewServiceInstance_macro_validPopupDataAndUI__dynamicFieldsEcompNamingFalse_FLESH("DEV", 5, reduxForStep, "mCaNk");
 268     }
 269
 270     @Test
 271     public void createNewServiceInstance_macro_validPopupDataAndUI__dynamicFieldsEcompNamingFalse() {
 272         createNewServiceInstance_macro_validPopupDataAndUI__dynamicFieldsEcompNamingFalse_FLESH("RUNTIME", 0, null, randomAlphabetic(5));
 273     }
 274
 275     private void createNewServiceInstance_macro_validPopupDataAndUI__dynamicFieldsEcompNamingFalse_FLESH(String mode, int startInStep, String reduxForStep, String randomAlphabetic) {
 276
 277         MutableInt i = new MutableInt();
 278         Map<String, String> reduxStates = new HashMap<>();
 279
 280         ServiceData serviceData = new ServiceData(
 281                 macroSriovWithDynamicFieldsEcompNamingFalsePartialModelDetailsVnfEcompNamingFalse.modelVersionId,
 282                 Collections.singletonList("2017488 pasqualevpe0 asn:"),
 283                 IS_GENERATED_NAMING.FALSE, false, true, false,
 284                 "2017-488_PASQUALE-vPE 0",
 285                 "2017488_pasqualevpe0..2017488PasqualeVpe..PASQUALE_vRE_BV..module-1", 0,
 286                 NO_MAX_INSTANCES_IN_MODEL, ImmutableList.of("Bandwidth", "Bandwidth units"),
 287                 "25284168-24bb-4698-8cb4-3f509146eca5", false);
 288
 289         // this is the instance-name that createMacroService is going to use
 290         String serviceInstanceName = randomAlphabetic + "instancename";
 291
 292         doReduxStep(reduxStates, randomAlphabetic, startInStep, reduxForStep, i, mode, () -> {
 293             prepareServicePreset(macroSriovWithDynamicFieldsEcompNamingFalsePartialModelDetailsVnfEcompNamingFalse,
 294                     false);
 295             createMacroService(serviceData, false, randomAlphabetic, true, 3);
 296         });
 297
 298         doReduxStep(reduxStates, randomAlphabetic, startInStep, reduxForStep, i, mode, () ->
 299                 createVnf(serviceData, false, serviceInstanceName)
 300         );
 301
 302         final String vnfInstanceName2 = randomAlphabetic + "instanceName";
 303         final String vnfName2 = "2017-388_PASQUALE-vPE";
 304
 305         doReduxStep(reduxStates, randomAlphabetic, startInStep, reduxForStep, i, mode, () ->
 306                 createVnf(new VnfData(vnfName2 + " 0", "afacccf6-397d-45d6-b5ae-94c39734b168", vnfInstanceName2, false),
 307                         false, serviceInstanceName)
 308         );
 309
 310         doReduxStep(reduxStates, randomAlphabetic, startInStep, reduxForStep, i, mode, () ->
 311                 createVfModule(serviceData, serviceInstanceName, false, true)
 312         );
 313
 314         doReduxStep(reduxStates, randomAlphabetic, startInStep, reduxForStep, i, mode, () -> {
 315
 316             editVfModuleAndJustSetName(vfModule0Name, vfModule0UUID);
 317             duplicateVnf(serviceData.vnfData, 2);
 318             vidBasePage.screenshotDeployDialog(serviceInstanceName);
 319         });
 320
 321         doReduxStep(reduxStates, randomAlphabetic, startInStep, reduxForStep, i, mode, () -> {
 322             prepareServicePreset(macroSriovWithDynamicFieldsEcompNamingFalsePartialModelDetailsVnfEcompNamingFalse,
 323                     true);
 324
 325             final String vfModuleName1 = "2017488PasqualeVpe..PASQUALE_base_vPE_BV..module-0";
 326             final String vfModuleName2 = "2017488PasqualeVpe..PASQUALE_vRE_BV..module-1";
 327             final String request1 = PresetMSOBaseCreateInstancePost.DEFAULT_REQUEST_ID;
 328             final String request2 = "ce010256-3fdd-4cb5-aed7-37112a2c6e93";
 329             final ImmutableMap<Keys, String> vars = ImmutableMap.<Keys, String>builder()
 330                     .put(Keys.SERVICE_NAME, serviceInstanceName)
 331                     .put(Keys.VNF_NAME, cleanSeparators("2017-488_PASQUALE-vPE", serviceData.vnfData.vnfInstanceName))
 332                     .put(Keys.VFM_NAME1, cleanSeparators(vfModuleName1 , "VF instance name ZERO"))
 333                     .put(Keys.VFM_NAME2, cleanSeparators(vfModuleName2 , "VF instance name"))
 334                     .put(Keys.VG_NAME, cleanSeparators(vfModuleName2 , "VF instance name") + "_vol_abc")
 335                     .put(Keys.VNF_NAME2, cleanSeparators(vnfName2, vnfInstanceName2))
 336                     .build();
 337             registerExpectationFromPresets(ImmutableList.of(
 338                     // although "some legacy region" is provided for vnf, Service's region "hvf6" overrides it
 339                     PRESET_MTN6_TO_ATT_AIC,
 340                     new PresetMSOCreateServiceInstanceGen2WithNamesEcompNamingFalse(vars, 0, request1),
 341                     new PresetMSOCreateServiceInstanceGen2WithNamesEcompNamingFalse(vars, 1, request2)
 342             ), SimulatorApi.RegistrationStrategy.APPEND);
 343
 344             deployAndVerifyModuleInPendingTableMacro(serviceInstanceName, request1, request2);
 345             verifyOpenAuditInfo(serviceInstanceName);
 346             verifyOpenViewEdit(serviceInstanceName);
 347             verifyDeleteJob(serviceInstanceName);
 348             verifyHideJob(serviceInstanceName);
 349         });
 350     }
 351
 352     @Test
 353     @FeatureTogglingTest(FLAG_1908_INFRASTRUCTURE_VPN)
 354     public void createNewServiceInstance_infraStructureVpn() {
 355         String requestId = uuid();
 356         String instanceId = uuid();
 357
 358         prepareServicePreset(infrastructureVpnService, false);
 359
 360         SimulatorApi.registerExpectationFromPresets(ImmutableList.of(
 361             PRESET_MTN6_TO_ATT_AIC,
 362                 new PresetAAIGetL3NetworksByCloudRegionSpecificState("irma-aic", "hvf6", "bae71557c5bb4d5aac6743a4e5f1d054"),
 363             new PresetAAIGetVpnsByType()
 364         ), APPEND);
 365
 366         ServiceData serviceData = new ServiceData(
 367                 infrastructureVpnService.modelVersionId,
 368                 new ArrayList<>(),
 369                 IS_GENERATED_NAMING.TRUE_BUT_GIVE_NAME_EITHER_WAY, true, true, false,
 370                 null,
 371                 null, 0, null, new ArrayList<>(), null, false);
 372         final String serviceInstanceName = createMacroService(serviceData, false);
 373
 374         SimulatorApi.registerExpectationFromPresets(ImmutableList.of(
 375             PresetMsoCreateMacroCommonPre1806.ofServiceWithVRF(requestId, instanceId, serviceInstanceName),
 376             new PresetMSOOrchestrationRequestGet(COMPLETE, requestId)
 377         ), APPEND);
 378
 379         // Wizard pages of Network and VPN
 380         Click.byTestIdOnceItsAvailable("10a74149-c9d7-4918-bbcf-d5fb9b1799ce", 20);
 381         Click.byTestId("setMembersBtn");
 382         GeneralUIUtils.ultimateWait();
 383
 384         Click.byTestIdOnceItsAvailable("120d39fb-3627-473d-913c-d228dd0f8e5b", 20);
 385         Click.byTestId("setMembersBtn");
 386         GeneralUIUtils.ultimateWait();
 387
 388         Assert.assertEquals(Get.byTestId("node-type-indicator").getText(),"VRF");
 389
 390         drawingBoardPage.deploy();
 391         drawingBoardPage.verifyServiceCompletedOnTime(serviceInstanceName, "Service "+serviceInstanceName);
 392     }
 393
 394     @Test
 395     @FeatureTogglingTest(FLAG_1908_COLLECTION_RESOURCE_NEW_INSTANTIATION_UI)
 396     public void createNewServiceInstance_collectionResource() {
 397         prepareServicePreset(collectionResourceService, false);
 398         String requestId = uuid();
 399         String instanceId = uuid();
 400
 401         SimulatorApi.registerExpectationFromPresets(ImmutableList.of(
 402                 PRESET_MTN6_TO_ATT_AIC,
 403                 PresetMsoCreateMacroCommonPre1806.ofCollectionResource(requestId, instanceId),
 404                 new PresetMSOOrchestrationRequestGet(COMPLETE, requestId)
 405         ), APPEND);
 406
 407         ServiceData serviceData = new ServiceData(
 408                 collectionResourceService.modelVersionId,
 409                 new ArrayList<>(),
 410                 IS_GENERATED_NAMING.TRUE, true, true, false,
 411                 null,
 412                 null, 0, null, new ArrayList<>(), null, false);
 413         createMacroService(serviceData, false, randomAlphabetic(5), true, 1);
 414
 415         drawingBoardPage.deploy();
 416         drawingBoardPage.verifyServiceCompletedOnTime("CR_sanity", "service with collection resource");
 417     }
 418
 419     @Test
 420     @FeatureTogglingTest(FLAG_1908_TRANSPORT_SERVICE_NEW_INSTANTIATION_UI)
 421     public void createNewServiceInstance_transportService() {
 422         prepareServicePreset(transportWithPnfsService, false);
 423         String requestId = uuid();
 424         String instanceId = uuid();
 425
 426         SimulatorApi.registerExpectationFromPresets(ImmutableList.of(
 427                 PresetMsoCreateMacroCommonPre1806.ofTransportService(requestId, instanceId),
 428                 new PresetMSOOrchestrationRequestGet(COMPLETE, requestId)
 429             ), APPEND);
 430
 431         ServiceData serviceData = new ServiceData(
 432                 transportWithPnfsService.modelVersionId,
 433                 new ArrayList<>(),
 434                 IS_GENERATED_NAMING.TRUE, true, true, false,
 435                 null,
 436                 null, 0, null, new ArrayList<>(), null, false);
 437         createMacroService(serviceData, false, randomAlphabetic(5), false, 1);
 438
 439         drawingBoardPage.deploy();
 440         drawingBoardPage.verifyServiceCompletedOnTime("AIM Transport SVC_ym161f", "transport service");
 441     }
 442
 443     @Test
 444     @FeatureTogglingTest(FLAG_1902_VNF_GROUPING)
 445     public void createNewServiceInstance_aLaCarte_VnfGrouping() {
 446
 447         String randomAlphabetic = randomAlphabetic(5);
 448
 449         ServiceData serviceData = new ServiceData(
 450                 aLaCarteVnfGroupingService.modelVersionId,
 451                 ImmutableList.of(),
 452                 IS_GENERATED_NAMING.FALSE, false, true, false,
 453                 null, null, 0, null, ImmutableList.of(), null, false);
 454         prepareServicePreset(aLaCarteVnfGroupingService, false);
 455
 456         createALaCarteService(serviceData, randomAlphabetic);
 457
 458         // this is the instance-name that createALaCarteService is using
 459         String serviceInstanceName = randomAlphabetic + "instancename";
 460
 461         final String requestId = PresetMSOBaseCreateInstancePost.DEFAULT_REQUEST_ID;
 462         final String serviceInstanceId = "d2391436-8d55-4fde-b4d5-72dd2cf13cgh";
 463         final ImmutableMap<Keys, String> names = ImmutableMap.<Keys, String>builder()
 464                 .put(Keys.SERVICE_NAME, serviceInstanceName)
 465                 .build();
 466         SimulatorApi.registerExpectationFromPresets(ImmutableList.of(
 467                 new PresetMSOCreateServiceInstanceGen2WithNamesAlacarteGroupingService(names, 0, requestId, serviceInstanceId, "us16807000"),
 468                 new PresetAAIPostNamedQueryForViewEdit(serviceInstanceId, serviceInstanceName, false, false)
 469         ), SimulatorApi.RegistrationStrategy.APPEND);
 470
 471         drawingBoardPage.deploy();
 472         verifyModuleInPendingTable(serviceInstanceName, requestId, null, ImmutableSet.of(IN_PROGRESS), false, false);
 473         verifyModuleInPendingTable(serviceInstanceName, requestId, null, ImmutableSet.of(COMPLETED), false, true);
 474         InstantiationStatusPage.verifyOpenNewViewEdit(serviceInstanceName, serviceInstanceId, aLaCarteVnfGroupingService.modelVersionId, "TYLER SILVIA", "e433710f-9217-458d-a79d-1c7aff376d89", "EDIT");
 475     }
 476
 477     public interface Invoker{
 478         void invoke();
 479     }
 480
 481     private void doReduxStep(Map<String, String> reduxStates, String randomAlphabetic, int startInStep, String reduxForStep, MutableInt currentStep, String mode, Invoker todo) {
 482         try {
 483             switch (mode) {
 484                 case "DEV":
 485                     if (currentStep.getValue() < startInStep) {
 486                         // skip up to startInStep
 487                         return;
 488                     } else if (currentStep.getValue() == startInStep) {
 489
 490                         vidBasePage.setReduxState(reduxForStep);
 491
 492                         vidBasePage.navigateTo("serviceModels.htm#/servicePlanning?serviceModelId=6b528779-44a3-4472-bdff-9cd15ec93450");
 493                         vidBasePage.goToIframe();
 494                     }
 495
 496                     reduxStates.put(String.valueOf(currentStep), vidBasePage.getReduxState());
 497                     break;
 498
 499                 case "RUNTIME":
 500                 default:
 501                     // log current redux state, before invocation
 502                     reduxStates.put(String.valueOf(currentStep), vidBasePage.getReduxState());
 503                     logger.info("reduxGator runtime reduxState for step {}:\n{}", currentStep, vidBasePage.getReduxState());
 504                     break;
 505             }
 506
 507             try {
 508                 todo.invoke();
 509             } catch (AssertionError | Exception e) {
 510                 throw new AssertionError(String.join("\n",
 511                         "Current step: " + currentStep,
 512                         "Random alphabetic: " + randomAlphabetic,
 513                         "Starting reduxState: " + reduxStates.get(String.valueOf(currentStep)),
 514                         "Current reduxState:  " + vidBasePage.getReduxState()
 515                 ), e);
 516             }
 517         } finally {
 518             logger.info("Cumulative reduxState: {}", reduxStates);
 519             currentStep.increment();
 520         }
 521     }
 522
 523     //@Step("duplicate vnf")
 524     private void duplicateVnf(VnfData vnfData, int count) {
 525         hoverAndClickDuplicateButton(extractNodeToEdit(vnfData));
 526         vidBasePage.screenshotDeployDialog("duplicateVnf-" + vnfData.vnfName);
 527         List<WebElement> options = ((RemoteWebElement)Get.byId("duplicate-select")).findElementsByTagName("option");
 528         assertThat(options.stream().map(x -> x.getText()).collect(Collectors.toList()), Matchers.contains("1","2"));
 529         SelectOption.byIdAndVisibleText("duplicate-select", String.valueOf(count));
 530         Click.byClassAndVisibleText("sdc-button__primary", "DUPLICATE");
 531     }
 532
 533     private String cleanSeparators(String... s) {
 534         return String.join("", s).replace(" ", "");
 535     }
 536
 537     //@Step("edit vf module and just set name")
 538     private void editVfModuleAndJustSetName(String vfModuleName, String vfModuleUUID) {
 539         hoverAndClickEditButton(vfModuleUUID + "-" + vfModuleName);
 540         Input.text("VF instance name ZERO", "instanceName");
 541         Click.byTestId(VNF_SET_BUTTON_TEST_ID);
 542     }
 543
 544     @Test
 545     public void createNewServiceInstance_macro_validPopupDataAndUI__ecompNamingServiceFalseVnfTrue_vgNameFalse() {
 546         ServiceData serviceData = new ServiceData(
 547                 macroSriovNoDynamicFieldsEcompNamingFalseFullModelDetails.modelVersionId,
 548                 new ArrayList<>(),
 549                 IS_GENERATED_NAMING.FALSE, true, false, true,
 550                 "2017-488_PASQUALE-vPE 0",
 551                 vfModule0Name, 1, "1", new ArrayList<>(), vfModule0UUID, false);
 552
 553         prepareServicePreset(macroSriovNoDynamicFieldsEcompNamingFalseFullModelDetails, false);
 554
 555         final String serviceInstanceName = createMacroService(serviceData, true);
 556         createVnf(serviceData, true, serviceInstanceName);
 557         createVfModule(serviceData, serviceInstanceName, true, false);
 558
 559     }
 560
 561     @Test
 562     public void createNewServiceInstance_macro_validPopupDataAndUI__ecompNamingServiceFalseVnfFalse_vgNameFalse() {
 563         ServiceData serviceData = new ServiceData(
 564                 macroSriovNoDynamicFieldsEcompNamingFalseFullModelDetailsVnfEcompNamingFalse.modelVersionId,
 565                 new ArrayList<>(),
 566                 IS_GENERATED_NAMING.FALSE, false, false, false,
 567                 "2017-488_PASQUALE-vPE 0",
 568                 vfModule0Name, 1, "1", new ArrayList<>(), vfModule0UUID, false);
 569
 570         prepareServicePreset(macroSriovNoDynamicFieldsEcompNamingFalseFullModelDetailsVnfEcompNamingFalse, false);
 571
 572         final String serviceInstanceName = createMacroService(serviceData, true);
 573         createVnf(serviceData, true, serviceInstanceName);
 574         createVfModule(serviceData, serviceInstanceName, true, false);
 575
 576     }
 577
 578     @Test
 579     public void createNewServiceInstance_macro_validPopupDataAndUI__ecompNamingServiceFalseVnfFalse_vgNameTrue() throws Exception {
 580         ServiceData serviceData = new ServiceData(
 581                 macroSriovNoDynamicFieldsEcompNamingFalseFullModelDetailsVnfEcompNamingFalse.modelVersionId,
 582                 new ArrayList<>(),
 583                 IS_GENERATED_NAMING.FALSE, false, true, false,
 584                 "2017-488_PASQUALE-vPE 0",
 585                 "2017488_pasqualevpe0..2017488PasqualeVpe..PASQUALE_vRE_BV..module-1", 0,
 586                 NO_MAX_INSTANCES_IN_MODEL, new ArrayList<>(), "25284168-24bb-4698-8cb4-3f509146eca5", false);
 587
 588         prepareServicePreset(macroSriovNoDynamicFieldsEcompNamingFalseFullModelDetailsVnfEcompNamingFalse, false);
 589
 590         final String serviceInstanceName = createMacroService(serviceData, true);
 591         createVnf(serviceData, true, serviceInstanceName);
 592         clickRemoveVfModule(vfModule0UUID, vfModule0Name);
 593         createVfModule(serviceData, serviceInstanceName, false, true);
 594
 595     }
 596
 597     @Test
 598     @FeatureTogglingTest(FLAG_2002_ANY_ALACARTE_BESIDES_EXCLUDED_NEW_INSTANTIATION_UI)
 599     public void createNewServiceInstance_aLaCarte_WithVnf() {
 600         final ModelInfo serviceModelInfo = ModelInfo.aLaCarteServiceCreationNewUI;
 601         String serviceInstanceName = "ALaCarteWithVnf"+randomAlphabetic(5);
 602         String vnfInstanceName= "VnfForALaCarte"+randomAlphabetic(5);
 603         VnfData vnfData = new VnfData("vOCG_1804_VF 0", "aca3f7b1-15f9-45a5-b182-b8b5aca84a76", vnfInstanceName, true);
 604         VfData vfmData = new VfData("vocg_1804_vf0..Vocg1804Vf..base_ocg..module-0", false, 1, "1", emptyList(), "815db6e5-bdfd-4cb6-9575-82c36df8747a", null);
 605         ServiceData serviceData = new ServiceData(IS_GENERATED_NAMING.TRUE, vnfData, vfmData, true);
 606
 607         resetGetServicesCache();
 608
 609         prepareServicePreset(serviceModelInfo, true);
 610
 611         String requestorID = getUserCredentials().getUserId();
 612
 613         String serviceRequestId = uuid();
 614         String serviceInstanceId = uuid();
 615         String vnfRequestId = uuid();
 616         String vnfInstanceId = uuid();
 617         String vfm0RequestId = uuid();
 618         String vfm0InstanceId = uuid();
 619         String vg1RequestId = uuid();
 620         String vg1InstanceId = uuid();
 621         String vfm1RequestId = uuid();
 622         String vfm1InstanceId = uuid();
 623         String vfm12RequestId = uuid();
 624         String vfm12InstanceId = uuid();
 625
 626         ModelInfoWithCustomization vfm0 = new ModelInfoWithCustomization(
 627             "815db6e5-bdfd-4cb6-9575-82c36df8747a",
 628             "e9c795c8-6b98-4db3-bd90-a84b8ca5181b",
 629             "Vocg1804Vf..base_ocg..module-0",
 630             "4",
 631             "vfModule",
 632             "Vocg1804Vf..base_ocg..module-0",
 633             "a7b333d7-7633-4197-b40d-80fcfcadee94");
 634
 635         ModelInfoWithCustomization vg1 = new ModelInfoWithCustomization(
 636             "9c219e70-1177-494b-8977-1395c9f9168c",
 637             "0ad14d60-98b6-4575-a9b8-458a796c3f98",
 638             "Vocg1804Vf..ocgmgr..module-1",
 639             "4",
 640             "volumeGroup",
 641             "Vocg1804Vf..ocgmgr..module-1",
 642             "f332f3ce-434d-4084-a1e7-5261c16d4940"
 643         );
 644
 645         ModelInfoWithCustomization vfm1 = new ModelInfoWithCustomization(
 646             "9c219e70-1177-494b-8977-1395c9f9168c",
 647             "0ad14d60-98b6-4575-a9b8-458a796c3f98",
 648             "Vocg1804Vf..ocgmgr..module-1",
 649             "4",
 650             "vfModule",
 651             "Vocg1804Vf..ocgmgr..module-1",
 652             "f332f3ce-434d-4084-a1e7-5261c16d4940"
 653         );
 654
 655         ModelInfoWithCustomization vfm12 = new ModelInfoWithCustomization(
 656             "b601eef4-62fd-4201-a788-ae30e06a1aec",
 657             "e3cb8b85-7a3c-4897-b20b-70640c26d671",
 658             "Vocg1804Vf..ocgapp_001..module-12",
 659             "2",
 660             "vfModule",
 661             "Vocg1804Vf..ocgapp_001..module-12",
 662             "fcc82961-865e-4d38-9c7a-207c511405b6"
 663         );
 664
 665         final String vgName = "vg_for_module1";
 666
 667         String vgRelatedInstance = ",{\"relatedInstance\": {"
 668             + "                    \"modelInfo\": {"
 669             + "                        \"modelType\": \"volumeGroup\""
 670             + "                    },"
 671             + "                    \"instanceId\": \""+vg1InstanceId+"\","
 672             + "                    \"instanceName\": \""+vgName+"\""
 673             + "                }}";
 674
 675
 676         registerExpectationFromPresets(
 677             ImmutableList.of(
 678                 new PresetMSOCreateServiceInstanceAlacarte(
 679                     ImmutableMap.of(Keys.SERVICE_NAME, serviceInstanceName),
 680                     serviceRequestId, serviceInstanceId,
 681                     requestorID, serviceModelInfo),
 682                 PRESET_SOME_LEGACY_REGION_TO_ATT_AIC,
 683                 new PresetMSOOrchestrationRequestGet(COMPLETE, serviceRequestId),
 684                 new PresetMSOCreateVnfALaCarteE2E(vnfRequestId, serviceInstanceId, vnfInstanceId, "ONAP", requestorID, serviceModelInfo),
 685                 new PresetMSOOrchestrationRequestGet(COMPLETE, vnfRequestId),
 686                 PRESET_MTN6_TO_ATT_AIC,
 687                 new PresetMSOCreateVfModuleALaCarteE2E(vfm0RequestId, vfm0InstanceId, serviceInstanceId, vnfInstanceId, requestorID, serviceModelInfo, null, vfm0, null),
 688                 new PresetMSOOrchestrationRequestGet(COMPLETE, vfm0RequestId),
 689                 new PresetMSOCreateVfModuleALaCarteE2E(vg1RequestId, vg1InstanceId, serviceInstanceId, vnfInstanceId, requestorID, serviceModelInfo, vgName, vg1, null),
 690                 new PresetMSOOrchestrationRequestGet(COMPLETE, vg1RequestId),
 691                 new PresetMSOCreateVfModuleALaCarteE2E(vfm1RequestId, vfm1InstanceId, serviceInstanceId, vnfInstanceId, requestorID, serviceModelInfo, null, vfm1, vgRelatedInstance),
 692                 new PresetMSOOrchestrationRequestGet(COMPLETE, vfm1RequestId),
 693                 new PresetMSOCreateVfModuleALaCarteE2E(vfm12RequestId, vfm12InstanceId, serviceInstanceId, vnfInstanceId, requestorID, serviceModelInfo, null, vfm12, null),
 694                 new PresetMSOOrchestrationRequestGet(COMPLETE, vfm12RequestId)
 695             ),
 696             APPEND
 697         );
 698
 699         loadServicePopup(serviceModelInfo.modelVersionId);
 700         fillALaCarteServicePopup(serviceInstanceName);
 701
 702         createVnf(vnfData, false, serviceInstanceName);
 703         createVfModule(serviceData, serviceInstanceName, true, false);
 704         serviceData.vfData =  new VfData("vocg_1804_vf0..Vocg1804Vf..ocgmgr..module-1", true, 0, NO_MAX_INSTANCES_IN_MODEL, emptyList(), "9c219e70-1177-494b-8977-1395c9f9168c", vgName);
 705         createVfModule(serviceData, serviceInstanceName, false, false);
 706         serviceData.vfData =  new VfData("vocg_1804_vf0..Vocg1804Vf..ocgapp_001..module-12", true, 0, NO_MAX_INSTANCES_IN_MODEL, emptyList(), "b601eef4-62fd-4201-a788-ae30e06a1aec", null);
 707         createVfModule(serviceData, serviceInstanceName, false, false);
 708         drawingBoardPage.deploy();
 709         drawingBoardPage.verifyServiceCompletedOnTime(serviceInstanceName, "service "+serviceInstanceName);
 710     }
 711
 712     @Test
 713     @FeatureTogglingTest(FLAG_5G_IN_NEW_INSTANTIATION_UI)
 714     public void createNewServiceInstance_aLaCarte_withNetwork_validPopupDataAndUI() {
 715         String serviceInstanceName = "NcService"+randomAlphabetic(5);
 716         String networkInstanceName= "NcNetowrk"+randomAlphabetic(5);
 717         String defactoNetworkInstanceName = "ExtVL"+networkInstanceName;
 718
 719         prepareServicePreset(aLaCarteNetworkProvider5G, true);
 720         String serviceRequestId = uuid();
 721         String networkRequestId = uuid();
 722         String requestorID = getUserCredentials().getUserId();
 723         registerExpectationFromPresets(
 724                 ImmutableList.of(
 725                     new PresetMSOCreateServiceInstanceAlacarte(
 726                         ImmutableMap.of(Keys.SERVICE_NAME, serviceInstanceName),
 727                         serviceRequestId, DEFAULT_SERVICE_INSTANCE_ID,
 728                             requestorID, aLaCarteNetworkProvider5G),
 729                     new PresetMSOOrchestrationRequestGet(COMPLETE, serviceRequestId),
 730                     PRESET_SOME_LEGACY_REGION_TO_ATT_AIC,
 731                     new PresetMSOCreateNetworkALaCarte5G(networkRequestId, DEFAULT_SERVICE_INSTANCE_ID, defactoNetworkInstanceName, requestorID),
 732                     new PresetMSOOrchestrationRequestGet(COMPLETE, networkRequestId),
 733                     new PresetMSOOrchestrationRequestsGet5GServiceInstanceAndNetwork(
 734                             new ResponseDetails(serviceInstanceName, serviceRequestId, COMPLETE, "service"),
 735                             new ResponseDetails(defactoNetworkInstanceName, networkRequestId, COMPLETE, "network"),
 736                             DEFAULT_SERVICE_INSTANCE_ID)
 737                 ),
 738             APPEND
 739         );
 740         loadServicePopup(aLaCarteNetworkProvider5G.modelVersionId);
 741         fillALaCarteServicePopup(serviceInstanceName);
 742         VnfData networkData = new VnfData("SR-IOV Provider-1", "840ffc47-e4cf-46de-8e23-525fd8c6fdc3", defactoNetworkInstanceName, false);
 743         createNetwork(networkData, false, false, serviceInstanceName);
 744
 745         drawingBoardPage.deploy();
 746         drawingBoardPage.verifyServiceCompletedOnTime(serviceInstanceName, "service "+serviceInstanceName);
 747     }
 748
 749     private void fillALaCarteServicePopup(String serviceInstanceName) {
 750         BrowseASDCPage browseASDCPage = new BrowseASDCPage();
 751         WebElement instanceNameInput = Get.byId("instanceName");
 752         instanceNameInput.sendKeys(serviceInstanceName);
 753         VidBasePage.selectSubscriberById("e433710f-9217-458d-a79d-1c7aff376d89");
 754         String serviceType = "TYLER SILVIA";
 755         Wait.waitByClassAndText(Constants.CreateNewInstance.SERVICE_TYPE_OPTION_CLASS, serviceType, 30);
 756         browseASDCPage.selectServiceTypeByName(serviceType);
 757         SelectOption.byTestIdAndVisibleText("WayneHolland", (Constants.OwningEntity.OWNING_ENTITY_SELECT_TEST_ID));
 758         SelectOption.byTestIdAndVisibleText("WATKINS", Constants.OwningEntity.PROJECT_SELECT_TEST_ID);
 759         Click.byTestId("form-set");
 760         VidBasePage.goOutFromIframe();
 761         browseASDCPage.goToIframe();
 762     }
 763
 764     @Test
 765     public void createNewServiceInstance_macro_validPopupDataAndUI() {
 766
 767         List<String> serviceDynamicFields = Arrays.asList("2017488 pasqualevpe0 asn:");
 768         ServiceData serviceData = new ServiceData(
 769                 macroSriovWithDynamicFieldsEcompNamingTruePartialModelDetails.modelVersionId,
 770                 serviceDynamicFields,
 771                 IS_GENERATED_NAMING.TRUE, true, true, false,
 772                 "2017-488_PASQUALE-vPE 0",
 773                 "2017488_pasqualevpe0..2017488PasqualeVpe..PASQUALE_vRE_BV..module-1", 0,
 774             NO_MAX_INSTANCES_IN_MODEL, new ArrayList<>(),
 775             "25284168-24bb-4698-8cb4-3f509146eca5", false);
 776
 777         prepareServicePreset(macroSriovWithDynamicFieldsEcompNamingTruePartialModelDetails, false);
 778
 779         final String serviceInstanceName = createMacroService(serviceData, true);
 780         createVnf(serviceData, true, serviceInstanceName);
 781         clickRemoveVfModule(vfModule0UUID, vfModule0Name);
 782         createVfModule(serviceData, serviceInstanceName, false, false);
 783
 784     }
 785
 786     //@Step("deploy and verify module in pending table")
 787     private void deployAndVerifyModuleInPendingTableMacro(String serviceInstanceName, String requestId1, String requestId2) {
 788         drawingBoardPage.deploy();
 789
 790         boolean simulatorUpdated = false;
 791
 792         int[] ids = {0, 0, 1, 2};
 793         String[] statuses = {IN_PROGRESS, COMPLETED, IN_PROGRESS, PENDING};
 794         for (int i = 0; i < ids.length; i++) {
 795             String actualInstanceName = getActualInstanceName(serviceInstanceName, ids[i]);
 796             verifyModuleInPendingTable(actualInstanceName, requestId1, requestId2, ImmutableSet.of(statuses[i]), true, simulatorUpdated);
 797             simulatorUpdated = true;
 798         }
 799         vidBasePage.screenshotDeployDialog(serviceInstanceName);
 800     }
 801
 802     private void verifyModuleInPendingTable(String serviceInstanceName, String requestId1, String requestId2, Set<String> expectedStatuses, boolean isMacro, boolean simulatorUpdated) {
 803         DrawingBoardPage.ServiceStatusChecker serviceStatusChecker = new DrawingBoardPage.ServiceStatusChecker(serviceInstanceName, expectedStatuses);
 804         boolean statusIsShown = Wait.waitFor(serviceStatusChecker, null, 20, 2);
 805         final String assertionMessage = String.format("service %s: none of rowClasses [%s] is in expectedStatuses: [%s]  ",
 806                 serviceInstanceName,
 807                 String.join(",", serviceStatusChecker.getColumnClassesSet()),
 808                 String.join(",", expectedStatuses));
 809
 810         assertTrue(assertionMessage, statusIsShown);
 811
 812         if (isMacro) {
 813             InstantiationStatusPage.assertInstantiationStatusRow(
 814                     serviceInstanceName, expectedRowFields(serviceInstanceName));
 815         } else {
 816             InstantiationStatusPage.assertInstantiationStatusRow(
 817                     serviceInstanceName, expectedALaCarteRowFields(serviceInstanceName));
 818         }
 819
 820         if (!simulatorUpdated) {
 821             if (requestId2 != null) {
 822                 registerExpectationFromPreset(new PresetMSOOrchestrationRequestGet(IN_PROGRESS, requestId2), APPEND);
 823             }
 824             registerExpectationFromPreset(new PresetMSOOrchestrationRequestGet("COMPLETE", requestId1), APPEND);
 825         }
 826         vidBasePage.screenshotDeployDialog(serviceInstanceName);
 827     }
 828
 829     private String getActualInstanceName(String serviceInstanceName, Integer i) {
 830         return i==0 ? serviceInstanceName : serviceInstanceName + "_00" + i;
 831     }
 832
 833     //@Step("verify open view edit")
 834     private void verifyOpenViewEdit(String serviceInstanceName) {
 835         boolean[] openEnabled = {true, false, false};
 836         ImmutableList.of(0, 1, 2).forEach(i -> {
 837             String actualInstanceName = getActualInstanceName(serviceInstanceName, i);
 838             if (Features.FLAG_1902_NEW_VIEW_EDIT.isActive() || FLAG_1908_MACRO_NOT_TRANSPORT_NEW_VIEW_EDIT.isActive()) {
 839                 InstantiationStatusPage.verifyOpenNewViewEdit(actualInstanceName, openEnabled[i], "EDIT");
 840             }
 841             else {
 842                 vidBasePage.verifyOpenOldViewEdit(actualInstanceName, null, openEnabled[i], true, true);
 843             }
 844         });
 845     }
 846
 847     //@Step("verify open audit info")
 848     private void verifyOpenAuditInfo(String serviceInstanceName) {
 849         boolean auditInfoEnabled = true;
 850         String[] statuses = {COMPLETED, IN_PROGRESS, PENDING};
 851         for (Integer i : ImmutableList.of(0, 1, 2)) {
 852             String actualInstanceName = getActualInstanceName(serviceInstanceName, i);
 853             InstantiationStatusPage.checkMenuItem(actualInstanceName, Constants.InstantiationStatus.CONTEXT_MENU_HEADER_AUDIT_INFO_ITEM, auditInfoEnabled, contextMenuOpen -> {
 854                 Click.byTestId(contextMenuOpen);
 855                 checkAuditInfoModal(actualInstanceName, i, statuses);
 856             });
 857             final WebElement row = InstantiationStatusPage.getInstantiationStatusRow(actualInstanceName);
 858             row.findElement(By.id(Constants.InstantiationStatus.TD_JOB_STATUS_ICON + "-" + (i))).click();
 859             checkAuditInfoModal(actualInstanceName, i, statuses);
 860         }
 861     }
 862
 863     private void checkAuditInfoModal(String actualInstanceName, Integer i, String[] statuses) {
 864
 865         Wait.waitByTestId("vidJobStatus", 10);
 866
 867         WebElement webElement = Get.byTestId("model-item-value-serviceInstanceName");
 868         assertEquals(webElement.getText(), actualInstanceName, "Service Instance Name must be equal");
 869
 870         WebElement vidTableElement = Get.byId("service-instantiation-audit-info-vid");
 871         assertEquals(3, vidTableElement.findElement(By.tagName("thead")).findElements(By.tagName("th")).size(), "VID table must contain 3 columns");
 872
 873         List<WebElement> vidStatusesElements = vidTableElement.findElements(By.id("vidJobStatus"));
 874         List<String> vidStatuses = vidStatusesElements.stream()
 875                 .map(s ->
 876                         convertUITextCapitalizeAndFormatPipe(s.getText()))
 877                 .collect(Collectors.toList());
 878
 879         List<String> serviceStatus = Arrays.asList(Arrays.copyOfRange(statuses, i, statuses.length));
 880         assertThat("statuses for " + actualInstanceName + " must be as expected", vidStatuses, containsInAnyOrder(serviceStatus.toArray()));
 881         String dateString = vidTableElement.findElements(By.id("vidStatusTime")).get(0).getText();
 882         assertTrue("vid Status Time column must contains valid date in format : MMM dd, yyyy HH:mm", isDateValid(dateString, "MMM dd, yyyy HH:mm"));
 883
 884         WebElement MSOTableElement = Get.byId("service-instantiation-audit-info-mso");
 885         assertEquals(3, MSOTableElement.findElement(By.tagName("thead")).findElements(By.tagName("th")).size(), "MSO table must contain 3 columns");
 886
 887         if (statuses[i].equals(PENDING)) {
 888             assertEquals(0, MSOTableElement.findElement(By.tagName("tbody")).findElements(By.tagName("tr")).size(), "When status is PENDING MSO table is empty");
 889         }
 890
 891         vidBasePage.screenshotDeployDialog("audit-info-" + actualInstanceName);
 892         Click.byId(Constants.AuditInfoModal.CANCEL_BUTTON);
 893     }
 894
 895     private String convertUITextCapitalizeAndFormatPipe(String text) {
 896         return text.toUpperCase().replace("-", "_");
 897     }
 898
 899     private boolean isDateValid(String dateToValidate, String dateFromat) {
 900
 901         if (dateToValidate == null) {
 902             return false;
 903         }
 904         SimpleDateFormat sdf = new SimpleDateFormat(dateFromat);
 905         sdf.setLenient(false);
 906         try {
 907             //if not valid, it will throw ParseException
 908             Date date = sdf.parse(dateToValidate);
 909
 910         } catch (ParseException e) {
 911             e.printStackTrace();
 912             return false;
 913         }
 914         return true;
 915     }
 916
 917     //@Step("verifyDeleteJob")
 918     private void verifyDeleteJob(String serviceInstanceName) {
 919         boolean[] deleteEnabled = {false, false, true};
 920         String[] statuses = {COMPLETED, IN_PROGRESS, PENDING};
 921         verifyDeleteOrHideOperation(serviceInstanceName, Constants.InstantiationStatus.CONTEXT_MENU_REMOVE, statuses, deleteEnabled, "deleted");
 922     }
 923
 924     //@Step("verify hide job")
 925     private void verifyHideJob(String serviceInstanceName) {
 926         boolean[] hideEnabled = {true, false};
 927         String[] statuses = {COMPLETED, IN_PROGRESS};
 928         verifyDeleteOrHideOperation(serviceInstanceName, Constants.InstantiationStatus.CONTEXT_MENU_HIDE, statuses, hideEnabled, "hidden");
 929     }
 930
 931     private void verifyDeleteOrHideOperation(String serviceInstanceName, String contextMenuItem, String[] statuses, boolean[] operationEnabled, String operationName) {
 932         for (int i = 0; i < statuses.length; i++) {
 933             String actualInstanceName = getActualInstanceName(serviceInstanceName, i);
 934             InstantiationStatusPage.checkMenuItem(actualInstanceName, contextMenuItem, operationEnabled[i], contextMenuDelete -> {
 935                 Click.byTestId(contextMenuDelete);
 936                 GeneralUIUtils.ultimateWait();
 937                 assertNull(actualInstanceName + " should be " + operationName,
 938                         InstantiationStatusPage.getInstantiationStatusRow(actualInstanceName));
 939             });
 940         }
 941         vidBasePage.screenshotDeployDialog(serviceInstanceName);
 942     }
 943
 944     private ImmutableMap<String, String> expectedRowFields(String actualInstanceName) {
 945         return ImmutableMap.<String, String>builder()
 946                 .put("userId", getUserCredentials().getUserId())
 947                 .put("serviceModelName", "action-data")
 948                 .put("serviceInstanceName", actualInstanceName)
 949                 .put("serviceModelVersion", "1.0")
 950                 .put("subscriberName", "SILVIA ROBBINS")
 951                 .put("serviceType", "TYLER SILVIA")
 952                 .put("regionId", "hvf6")
 953                 .put("tenantName", "AIN Web Tool-15-D-testalexandria")
 954                 .put("aicZoneName", "NFTJSSSS-NFT1")
 955                 .put("project", "WATKINS")
 956                 .put("owningEntityName", "WayneHolland")
 957                 .put("pause", "false")
 958                 .build();
 959     }
 960
 961     private ImmutableMap<String, String> expectedALaCarteRowFields(String actualInstanceName) {
 962         return ImmutableMap.<String, String>builder()
 963                 .put("userId", getUserCredentials().getUserId())
 964                 .put("serviceModelName", "Grouping Service for Test")
 965                 .put("serviceInstanceName", actualInstanceName)
 966                 .put("serviceModelVersion", "1.0")
 967                 .put("subscriberName", "SILVIA ROBBINS")
 968                 .put("serviceType", "TYLER SILVIA")
 969                 .put("project", "WATKINS")
 970                 .put("owningEntityName", "WayneHolland")
 971                 .put("pause", "false")
 972                 .build();
 973     }
 974
 975     //@Step("create sriov service")
 976     private String createMacroService(ServiceData serviceData, boolean tryCancelsAndReentries) {
 977         return createMacroService(serviceData, tryCancelsAndReentries, randomAlphabetic(5), true, 3);
 978     }
 979
 980     //@Step("create sriov service")
 981     private String createMacroService(ServiceData serviceData, boolean tryCancelsAndReentries, String randomAlphabetic, boolean fillLcpRegionAndTenantAndZone, int bulkSize) {
 982         BrowseASDCPage browseASDCPage = new BrowseASDCPage();
 983         User user = usersService.getUser(Constants.Users.SILVIA_ROBBINS_TYLER_SILVIA);
 984
 985         // simulate typing with spaces, but expected is without spaces
 986         String serviceInstanceNameWithSpaces = randomAlphabetic + " instance name";
 987         String serviceInstanceName = cleanSeparators(serviceInstanceNameWithSpaces);
 988
 989         List<String> cycles = tryCancelsAndReentries ? ImmutableList.of("WILL_CANCEL", "AFTER_CANCEL") : ImmutableList.of("SINGLE_SHOT");
 990         cycles.forEach(cycle -> {
 991             if ("AFTER_CANCEL".equals(cycle)) {
 992                 loadServicePopupOnBrowseASDCPage(serviceData.modelUuid);
 993             } else {
 994                 loadServicePopup(serviceData.modelUuid);
 995             }
 996
 997             WebElement instanceName = Get.byId("instanceName");
 998             boolean isRequired = isElementByIdRequired("instanceName-label");
 999             if (serviceData.isGeneratedNaming == IS_GENERATED_NAMING.TRUE || serviceData.isGeneratedNaming == IS_GENERATED_NAMING.TRUE_BUT_GIVE_NAME_EITHER_WAY) {
1000                 Assert.assertNotNull(instanceName, "instance name input should be visible when serviceEcompNaming == true.");
1001                 Assert.assertFalse(isRequired,"instance name input should be optional when ecompNaming == true.");
1002             } else {
1003                 Assert.assertTrue(isRequired,"instance name input should be required when serviceEcompNaming == false.");
1004             }
1005
1006             if (serviceData.isGeneratedNaming == IS_GENERATED_NAMING.FALSE || serviceData.isGeneratedNaming == IS_GENERATED_NAMING.TRUE_BUT_GIVE_NAME_EITHER_WAY) {
1007                 instanceName.sendKeys(serviceInstanceName);
1008             }
1009             String setButtonTestId = "form-set";
1010
1011             //serviceType should be dependent on subscriber selection
1012             assertElementDisabled("serviceType-select");
1013             Wait.waitByClassAndText(Constants.CreateNewInstance.SUBSCRIBER_NAME_OPTION_CLASS, "SILVIA ROBBINS", 30);
1014             GeneralUIUtils.ultimateWait();
1015             Click.byTestId(Constants.SUBSCRIBER_NAME_SELECT_TESTS_ID);
1016             if (Features.FLAG_RESTRICTED_SELECT.isActive())
1017                 assertElementExistAccordingTagNameAndTestId("select", Constants.SUBSCRIBER_SELECT_ID);
1018             else{
1019                 assertDropdownPermittedItemsByLabel(user.subscriberNames, Constants.CreateNewInstance.SUBSCRIBER_NAME_OPTION_CLASS);
1020
1021             }
1022             VidBasePage.selectSubscriberById("e433710f-9217-458d-a79d-1c7aff376d89");
1023             //lcpRegion should be dependent on serviceType selection
1024             assertElementDisabled("lcpRegion-select");
1025
1026             String serviceType = "TYLER SILVIA";
1027             Wait.waitByClassAndText(Constants.CreateNewInstance.SERVICE_TYPE_OPTION_CLASS, serviceType, 30);
1028             browseASDCPage.selectServiceTypeByName(serviceType);
1029
1030             String owningEntity = "WayneHolland";
1031             GeneralUIUtils.ultimateWait();
1032             Wait.waitByClassAndText(Constants.CreateNewInstance.OWNING_ENTITY_OPTION, owningEntity, 30);
1033             SelectOption.byTestIdAndVisibleText(owningEntity, (Constants.OwningEntity.OWNING_ENTITY_SELECT_TEST_ID));
1034             assertSetButtonDisabled(setButtonTestId);
1035
1036             SelectOption.byTestIdAndVisibleText("ERICA", Constants.ViewEdit.PRODUCT_FAMILY_SELECT_TESTS_ID);
1037             browseASDCPage.selectProductFamily("e433710f-9217-458d-a79d-1c7aff376d89");
1038
1039             if (fillLcpRegionAndTenantAndZone) {
1040
1041                 //we assume that if fillLcpRegionAndTenantAndZone is true tenant and lcpRegion are required for this service model
1042                 //If you want to fill lcpRegionAndTenant where they are optional you can refactor this test...
1043                 assertSetButtonDisabled(setButtonTestId);
1044
1045                 //tenant should be dependent on lcpRegion selection
1046                 assertElementDisabled("tenant-select");
1047
1048                 String lcpRegion = "hvf6";
1049                 Wait.waitByClassAndText("lcpRegionOption", lcpRegion, 30);
1050                 viewEditPage.selectLcpRegion(lcpRegion, AIC);
1051
1052                 GeneralUIUtils.ultimateWait();
1053                 browseASDCPage.selectTenant("bae71557c5bb4d5aac6743a4e5f1d054");
1054
1055                 browseASDCPage.selectAicZone("NFT1");
1056             }
1057
1058             assertSetButtonEnabled(setButtonTestId);
1059
1060
1061             SelectOption.byTestIdAndVisibleText("WATKINS", Constants.OwningEntity.PROJECT_SELECT_TEST_ID);
1062             if (bulkSize!=1) {
1063                 assertNotificationAreaVisibilityBehaviourAndSetBulkSize(bulkSize);
1064             }
1065
1066             assertPauseOnPausePointsVisibility(serviceData.multiStageDesign);
1067
1068             validateDynamicFields(serviceData.dynamicFields);
1069
1070             vidBasePage.screenshotDeployDialog("createMacroService-" + serviceInstanceName);
1071
1072             if ("WILL_CANCEL".equals(cycle)) {
1073                 Click.byTestId(Constants.CANCEL_BUTTON_TEST_ID);
1074             } else {
1075                 Click.byTestId(setButtonTestId);
1076             }
1077
1078             VidBasePage.goOutFromIframe();
1079
1080             browseASDCPage.goToIframe();
1081
1082         });
1083         return serviceInstanceName;
1084     }
1085
1086     private String createALaCarteService(ServiceData serviceData, String randomAlphabetic) {
1087         BrowseASDCPage browseASDCPage = new BrowseASDCPage();
1088         User user = usersService.getUser(Constants.Users.SILVIA_ROBBINS_TYLER_SILVIA);
1089
1090         // simulate typing with spaces, but expected is without spaces
1091         String serviceInstanceNameWithSpaces = randomAlphabetic + " instance name";
1092         String serviceInstanceName = cleanSeparators(serviceInstanceNameWithSpaces);
1093
1094         loadServicePopup(serviceData.modelUuid);
1095
1096         WebElement instanceName = Get.byId("instanceName");
1097         if (serviceData.isGeneratedNaming == IS_GENERATED_NAMING.TRUE || serviceData.isGeneratedNaming == IS_GENERATED_NAMING.TRUE_BUT_GIVE_NAME_EITHER_WAY) {
1098             Assert.assertNull(instanceName, "instance name input should be invisible when serviceEcompNaming == true.");
1099         }
1100         if (serviceData.isGeneratedNaming == IS_GENERATED_NAMING.FALSE || serviceData.isGeneratedNaming == IS_GENERATED_NAMING.TRUE_BUT_GIVE_NAME_EITHER_WAY) {
1101             instanceName.sendKeys(serviceInstanceName);
1102         }
1103
1104         //serviceType should be dependent on subscriber selection
1105         assertElementDisabled("serviceType-select");
1106         Wait.waitByClassAndText(Constants.CreateNewInstance.SUBSCRIBER_NAME_OPTION_CLASS, "SILVIA ROBBINS", 30);
1107         GeneralUIUtils.ultimateWait();
1108         Click.byTestId(Constants.SUBSCRIBER_NAME_SELECT_TESTS_ID);
1109         if (Features.FLAG_RESTRICTED_SELECT.isActive())
1110             assertElementExistAccordingTagNameAndTestId("select", Constants.SUBSCRIBER_SELECT_ID);
1111         else{
1112             assertDropdownPermittedItemsByLabel(user.subscriberNames, Constants.CreateNewInstance.SUBSCRIBER_NAME_OPTION_CLASS);
1113
1114         }
1115         VidBasePage.selectSubscriberById("e433710f-9217-458d-a79d-1c7aff376d89");
1116
1117         String serviceType = "TYLER SILVIA";
1118         Wait.waitByClassAndText(Constants.CreateNewInstance.SERVICE_TYPE_OPTION_CLASS, serviceType, 30);
1119         browseASDCPage.selectServiceTypeByName(serviceType);
1120
1121         String setButtonTestId = "form-set";
1122         assertSetButtonDisabled(setButtonTestId);
1123
1124         SelectOption.byTestIdAndVisibleText("WayneHolland", (Constants.OwningEntity.OWNING_ENTITY_SELECT_TEST_ID));
1125
1126         SelectOption.byTestIdAndVisibleText("WATKINS", Constants.OwningEntity.PROJECT_SELECT_TEST_ID);
1127
1128         validateDynamicFields(serviceData.dynamicFields);
1129
1130         vidBasePage.screenshotDeployDialog("createALaCarteService-" + serviceInstanceName);
1131
1132         Click.byTestId(setButtonTestId);
1133
1134         VidBasePage.goOutFromIframe();
1135
1136         browseASDCPage.goToIframe();
1137
1138         return serviceInstanceName;
1139     }
1140
1141     private void assertElementExistAccordingTagNameAndTestId(String tag, String testId) {
1142         WebElement webElement = Get.byId(testId);
1143         Assert.assertEquals(webElement.getTagName(), tag);
1144     }
1145
1146     //@Step("create vnf")
1147     private void createVnf(ServiceData serviceData, boolean tryCancelsAndReentries, String serviceInstanceName) {
1148         createVnf(serviceData.vnfData, tryCancelsAndReentries, serviceInstanceName);
1149     }
1150
1151     private void createNetwork(VnfData vnfData, boolean tryCancelsAndReentries, boolean addedByDefault, String serviceInstanceName) {
1152         createVnf(vnfData, tryCancelsAndReentries, addedByDefault, serviceInstanceName, true);
1153     }
1154
1155     private void createVnf(VnfData vnfData, boolean tryCancelsAndReentries, String serviceInstanceName) {
1156         createVnf(vnfData, tryCancelsAndReentries, true, serviceInstanceName, false);
1157     }
1158
1159     private void createVnf(VnfData vnfData, boolean tryCancelsAndReentries, boolean addedByDefault, String serviceInstanceName, boolean isNetwork) {
1160         BrowseASDCPage browseASDCPage = new BrowseASDCPage();
1161
1162         String nodeToEdit = extractNodeToEdit(vnfData);
1163         if (addedByDefault) {
1164             hoverAndClickEditButton(nodeToEdit);
1165         } else {
1166             drawingBoardPage.clickAddButtonByNodeName(vnfData.vnfName);
1167         }
1168
1169         GeneralUIUtils.ultimateWait();
1170
1171         if (vnfData.isGeneratedNaming) {
1172             Assert.assertFalse(isElementByIdRequired("instanceName-label") ,"instance name input should be optional when EcompNaming == true, and required when false.");
1173         } else {
1174             Input.text(vnfData.vnfInstanceName, "instanceName");
1175         }
1176
1177
1178         //tenant should be dependent on lcpRegion selection
1179         assertElementDisabled("tenant-select");
1180
1181         WebElement legacyRegion = Get.byTestId("lcpRegionText");
1182         Assert.assertNull(legacyRegion, "legacy region shouldn't be visible when lcp region isn't AAIAIC25,olson3 or olson5a.");
1183
1184         browseASDCPage.selectLcpRegion("AAIAIC25");
1185
1186         legacyRegion = Get.byTestId("lcpRegionText");
1187         Assert.assertNotNull(legacyRegion, "legacy region should be visible when lcp region is AAIAIC25,olson3 or olson5a.");
1188
1189         browseASDCPage.selectTenant("092eb9e8e4b7412e8787dd091bc58e86");
1190
1191         assertSetButtonDisabled(VNF_SET_BUTTON_TEST_ID);
1192
1193         if(isNetwork){
1194             browseASDCPage.selectPlatform("platform");
1195         }else {
1196             SelectOption.selectOptionsFromMultiselectById("multi-selectPlatform", ImmutableList.of("platform"));
1197         }
1198
1199         browseASDCPage.selectLineOfBusiness("ONAP");
1200         assertSetButtonEnabled(VNF_SET_BUTTON_TEST_ID);
1201
1202         browseASDCPage.setLegacyRegion("some legacy region");
1203
1204
1205         Wait.waitByTestId("model-item-value-subscriberName", 10);
1206         Assert.assertEquals(Get.byTestId("model-item-value-subscriberName").getText(), "SILVIA ROBBINS", "Subscriber name should be shown in vf module");
1207         if (!vnfData.isGeneratedNaming) {
1208             Assert.assertEquals(Get.byTestId("model-item-value-serviceName").getText(), serviceInstanceName, "Subscriber name should be shown in vf module");
1209         }
1210
1211         vidBasePage.screenshotDeployDialog("createVnf-" + serviceInstanceName);
1212         Click.byTestId(VNF_SET_BUTTON_TEST_ID);
1213         if (isNetwork) {
1214             return;
1215         }
1216         if (tryCancelsAndReentries) {
1217             hoverAndClickEditButton(nodeToEdit);
1218
1219             Wait.byText("TYLER SILVIA");
1220             GeneralUIUtils.ultimateWait();
1221             assertThat(Get.selectedOptionText(Constants.ViewEdit.LCP_REGION_SELECT_TESTS_ID), startsWith("AAIAIC25"));
1222             Assert.assertEquals(Get.selectedOptionText(Constants.ViewEdit.TENANT_SELECT_TESTS_ID), "USP-SIP-IC-24335-T-01");
1223             Assert.assertEquals(Get.selectedOptionText(Constants.ViewEdit.LINE_OF_BUSINESS_SELECT_TESTS_ID), "ONAP");
1224
1225             Assert.assertTrue(Get.isOptionSelectedInMultiSelect(Constants.OwningEntity.PLATFORM_MULTI_SELECT_TEST_ID, "platform"));
1226
1227             Click.byTestId(Constants.CANCEL_BUTTON_TEST_ID);
1228             GeneralUIUtils.ultimateWait();
1229         } else {
1230             toggleItemInTree(Constants.DrawingBoard.AVAILABLE_MODELS_TREE);
1231         }
1232         Click.byTestId("node-" + nodeToEdit);
1233     }
1234
1235     private String extractNodeToEdit(VnfData vnfData) {
1236         return vnfData.vnfUuid + "-" + vnfData.vnfName;
1237     }
1238
1239
1240     private void toggleItemInTree(String tree) {
1241         Click.byXpath("//tree-root[@data-tests-id='" + tree + "']//span[@class='" + Constants.DrawingBoard.TOGGLE_CHILDREN + "']");
1242     }
1243
1244     private void hoverAndClickEditButton(String nodeToEdit) {
1245         hoverAndClickButton(nodeToEdit, Constants.DrawingBoard.CONTEXT_MENU_EDIT);
1246     }
1247
1248     private void hoverAndClickDeleteButton(String nodeToEdit) {
1249         hoverAndClickButton(nodeToEdit, Constants.InstantiationStatus.CONTEXT_MENU_REMOVE);
1250     }
1251
1252     private void hoverAndClickDuplicateButton(String nodeToEdit) {
1253         hoverAndClickButton(nodeToEdit, Constants.InstantiationStatus.CONTEXT_MENU_DUPLICATE);
1254     }
1255     private void hoverAndClickButton(String nodeToEdit, String contextMenuItem) {
1256         String nodeOfEdit = Constants.DrawingBoard.NODE_PREFIX + nodeToEdit;
1257         String buttonOfEdit = nodeOfEdit + Constants.DrawingBoard.CONTEXT_MENU_BUTTON;
1258         GeneralUIUtils.hoverOnAreaByTestId(buttonOfEdit);
1259         Click.byTestId(buttonOfEdit);
1260         Click.byTestId(contextMenuItem);
1261     }
1262
1263     private void uploadSupplementaryFile(String inputFileName, boolean isValid, BrowseASDCPage browseASDCPage, String setButtonTestId) {
1264         if (Features.FLAG_SUPPLEMENTARY_FILE.isActive()) {
1265             GeneralUIUtils.ultimateWait();
1266             Input.file("supplementaryFiles/" + inputFileName, "supplementaryFile");
1267             GeneralUIUtils.ultimateWait();
1268             WebElement fileName = Get.byTestId("file-name");
1269             Assert.assertEquals(fileName.getText(),inputFileName);
1270             browseASDCPage.assertButtonState(setButtonTestId, isValid);
1271         }
1272     }
1273
1274     private void deleteSupplementaryFile() {
1275         if (Features.FLAG_SUPPLEMENTARY_FILE.isActive()) {
1276             Click.byTestId("remove-uploaded-file");
1277             GeneralUIUtils.ultimateWait();
1278             WebElement fileName = Get.byTestId("file-name");
1279             Assert.assertEquals(fileName.getText(),"Choose file");
1280         }
1281     }
1282
1283     //@Step("create vf module")
1284     private void createVfModule(ServiceData serviceData, String serviceInstanceName, boolean addedByDefault, boolean addOpensPopup) {
1285         clickAddVfModule(serviceData, addedByDefault);
1286         if (!addOpensPopup) {
1287             clickEditVfModule(serviceData);
1288         }
1289         fillAndSetVfModulePopup(serviceData, serviceInstanceName);
1290     }
1291
1292     private void fillAndSetVfModulePopup(ServiceData serviceData, String serviceInstanceName) {
1293         String setButtonTestId = "form-set";
1294         BrowseASDCPage browseASDCPage = new BrowseASDCPage();
1295
1296         Assert.assertEquals(isElementByIdRequired("instanceName-label"), !serviceData.vnfData.isGeneratedNaming,"instance name input should be optional when EcompNaming == true, and required when false.");
1297
1298         if (!serviceData.vnfData.isGeneratedNaming) {
1299             Input.text("VF instance name", "instanceName");
1300         }
1301
1302         if (!serviceData.vfData.vgEnabled || (!serviceData.isALaCarte && serviceData.vnfData.isGeneratedNaming)) {
1303             Assert.assertNull(Get.byTestId("volumeGroupName"), "volumeGroupName input should be invisible "
1304                 + "when vgEnabled is false or when vgEnabled is true and EcompGenName is true "
1305                 + "(was: serviceData.vfData.vgEnabled=>" + serviceData.vfData.vgEnabled + ", serviceData.isGeneratedNaming=>" + IS_GENERATED_NAMING.FALSE + ")");
1306         }
1307         else {
1308             Assert.assertFalse(isElementByIdRequired("volumeGroupName-label"),
1309                 "volume Group name input should be always optional");
1310             if (serviceData.vfData.vgName!=null) {
1311                 browseASDCPage.setInputText("volumeGroupName", serviceData.vfData.vgName);
1312             }
1313         }
1314
1315
1316         Wait.waitByTestId("model-item-value-subscriberName", 10);
1317         Assert.assertEquals(Get.byTestId("model-item-value-subscriberName").getText(), "SILVIA ROBBINS", "Subscriber name should be shown in vf module");
1318         Assert.assertEquals(Get.byTestId("model-item-value-min").getText(), Integer.toString(serviceData.vfData.vfMin), "Min should be shown");
1319         if (serviceData.vfData.vfMax!=null) {
1320             if (!serviceData.vfData.vfMax.equals(NO_MAX_INSTANCES_IN_MODEL)) {
1321                 Assert.assertEquals(Get.byTestId("model-item-value-max").getText(), serviceData.vfData.vfMax, "Max should be shown");
1322             }
1323             else {
1324                 String defaultMaxText = Features.FLAG_2002_UNLIMITED_MAX.isActive() ? "Unlimited (default)" : "1";
1325                 Assert.assertEquals(Get.byTestId("model-item-value-max").getText(), defaultMaxText, "Max should be shown with default value");
1326             }
1327         }
1328
1329         if (serviceData.isGeneratedNaming!=IS_GENERATED_NAMING.TRUE) {
1330             Wait.byText(serviceInstanceName);
1331             Assert.assertEquals(Get.byTestId("model-item-value-serviceName").getText(), serviceInstanceName, "Service name should be shown in vf module");
1332         }
1333
1334         if (serviceData.isALaCarte) {
1335             String lcpRegion = "hvf6";
1336             Wait.waitByClassAndText("lcpRegionOption", lcpRegion, 30);
1337             viewEditPage.selectLcpRegion(lcpRegion, AIC);
1338             browseASDCPage.selectTenant("bae71557c5bb4d5aac6743a4e5f1d054");
1339         }
1340
1341         validateDynamicFields(serviceData.vfData.dynamicFields);
1342
1343         uploadSupplementaryFile("invalid-file.json", false, browseASDCPage, setButtonTestId);
1344         deleteSupplementaryFile();
1345         uploadSupplementaryFile("sample.json", true, browseASDCPage, setButtonTestId);
1346
1347         browseASDCPage.screenshotDeployDialog("createVfModule-" + serviceInstanceName);
1348         Click.byTestId(setButtonTestId);
1349     }
1350
1351     private void clickEditVfModule(ServiceData serviceData) {
1352         hoverAndClickEditButton(serviceData.vfData.uuid + "-" + serviceData.vfData.vfName);
1353     }
1354
1355     private void clickAddVfModule(ServiceData serviceData, boolean addedByDefault) {
1356         if (addedByDefault) {
1357             return;
1358         }
1359         System.out.println("VFModule should be added 'manually'");
1360
1361         final WebElement vfModuleNode = Get.byTestId(Constants.DrawingBoard.NODE_PREFIX + serviceData.vfData.vfName);
1362
1363         if (vfModuleNode == null || !vfModuleNode.isDisplayed()) {
1364             // expand tree
1365             drawingBoardPage.clickNode(serviceData.vnfData.vnfName);
1366         }
1367         drawingBoardPage.clickAddButtonByNodeName(serviceData.vfData.vfName);
1368     }
1369
1370     private void clickRemoveVfModule(String vfModuleId, String vfModuleName) {
1371         System.out.println("will remove " + vfModule0Name);
1372         hoverAndClickDeleteButton(vfModuleId + "-" + vfModuleName);
1373     }
1374
1375     private void assertPauseOnPausePointsVisibility(boolean visibility) {
1376         WebElement pauseElem = Get.byId("Pause");
1377         final String assertionMessage = "pause on pause points visibility should be " + visibility;
1378         if (visibility) {
1379             Assert.assertNotNull(pauseElem, assertionMessage);
1380         } else {
1381             Assert.assertNull(pauseElem, assertionMessage);
1382         }
1383     }
1384
1385     @NotNull
1386     private String uuid() {
1387         return UUID.randomUUID().toString();
1388     }
1389
1390
1391     private void assertNotificationAreaVisibilityBehaviourAndSetBulkSize(int size) {
1392         WebElement webElement = Get.byId("notification-area");
1393         Assert.assertNull(webElement, "notification area should be invisible if only 1 qty.");
1394
1395         SelectOption.byIdAndVisibleText("quantity-select", String.valueOf(size));
1396
1397         webElement = Get.byId("notification-area");
1398         Assert.assertNotNull(webElement, "notification area should be visible if more then 1 qty.");
1399     }
1400
1401     //@Step("prepare service preset")
1402     private void prepareServicePreset(ModelInfo modelInfo, boolean deploy) {
1403         String subscriberId = "e433710f-9217-458d-a79d-1c7aff376d89";
1404
1405         if (deploy) {
1406             registerExpectationForServiceDeployment(
1407                 ImmutableList.of(
1408                     modelInfo,
1409                     pasqualeVmxVpeBvService488Annotations
1410                 ),
1411                 subscriberId, null);
1412         } else {
1413             registerExpectationForServiceBrowseAndDesign(ImmutableList.of(modelInfo), subscriberId);
1414         }
1415     }
1416
1417     static class ServiceData {
1418
1419         ServiceData(String modelUuid, List<String> dynamicFields, IS_GENERATED_NAMING isServiceGeneratedNaming,
1420             boolean isVnfGeneratedNaming, boolean isVgEnabled, boolean multiStageDesign, String vnfName,
1421             String vfName, int vfMin, String vfMax, List<String> vfModuleDynamicFields, String vfVersionId, boolean isALaCarte) {
1422             this.modelUuid = modelUuid;
1423             this.dynamicFields = dynamicFields;
1424             this.isGeneratedNaming = isServiceGeneratedNaming;
1425             this.multiStageDesign = multiStageDesign;
1426             this.isALaCarte = isALaCarte;
1427             this.vnfData = new VnfData(vnfName, "69e09f68-8b63-4cc9-b9ff-860960b5db09", "VNF instance name", isVnfGeneratedNaming);
1428             this.vfData = new VfData(vfName, isVgEnabled, vfMin, vfMax, vfModuleDynamicFields, vfVersionId, "_abc");
1429         }
1430
1431         public ServiceData(IS_GENERATED_NAMING isGeneratedNaming, VnfData vnfData, VfData vfData, boolean isALaCarte) {
1432             this.isGeneratedNaming = isGeneratedNaming;
1433             this.vnfData = vnfData;
1434             this.vfData = vfData;
1435             this.isALaCarte = isALaCarte;
1436         }
1437
1438         String modelUuid;
1439         List<String> dynamicFields;
1440         IS_GENERATED_NAMING isGeneratedNaming;
1441         boolean multiStageDesign;
1442         VnfData vnfData;
1443         VfData vfData;
1444         boolean isALaCarte;
1445
1446         enum IS_GENERATED_NAMING { TRUE, FALSE, TRUE_BUT_GIVE_NAME_EITHER_WAY}
1447     }
1448
1449     private static class VnfData {
1450         VnfData(String vnfName, String vnfUuid, String vnfInstanceName, boolean isGeneratedNaming) {
1451             this.vnfName = vnfName;
1452             this.vnfUuid = vnfUuid;
1453             this.vnfInstanceName = vnfInstanceName;
1454             this.isGeneratedNaming = isGeneratedNaming;
1455         }
1456
1457         final String vnfName;
1458         final String vnfUuid;
1459         final String vnfInstanceName;
1460         final boolean isGeneratedNaming;
1461     }
1462
1463
1464     private static class VfData {
1465         VfData(String vfName, boolean vgEnabled, int vfMin, String vfMax, List<String> dynamicFields, String uuid, String vgName) {
1466             this.vfName = vfName;
1467             this.vgEnabled = vgEnabled;
1468             this.vfMin = vfMin;
1469             this.vfMax = vfMax;
1470             this.dynamicFields = dynamicFields;
1471             this.uuid = uuid;
1472             this.vgName = vgName;
1473         }
1474
1475         final int vfMin;
1476         final String vfMax;
1477         final String uuid;
1478         final String vfName;
1479         final boolean vgEnabled;
1480         final List<String> dynamicFields;
1481         final String vgName;
1482     }
1483
1484
1485 }