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