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         clickToCloseModal("setMembersBtn");
 382
 383         Click.byTestIdOnceItsAvailable("120d39fb-3627-473d-913c-d228dd0f8e5b", 20);
 384         clickToCloseModal("setMembersBtn");
 385
 386         Assert.assertEquals(Get.byTestId("node-type-indicator").getText(),"VRF");
 387
 388         drawingBoardPage.deploy();
 389         drawingBoardPage.verifyServiceCompletedOnTime(serviceInstanceName, "Service "+serviceInstanceName);
 390     }
 391
 392     @Test
 393     @FeatureTogglingTest(FLAG_1908_COLLECTION_RESOURCE_NEW_INSTANTIATION_UI)
 394     public void createNewServiceInstance_collectionResource() {
 395         prepareServicePreset(collectionResourceService, false);
 396         String requestId = uuid();
 397         String instanceId = uuid();
 398
 399         SimulatorApi.registerExpectationFromPresets(ImmutableList.of(
 400                 PRESET_MTN6_TO_ATT_AIC,
 401                 PresetMsoCreateMacroCommonPre1806.ofCollectionResource(requestId, instanceId),
 402                 new PresetMSOOrchestrationRequestGet(COMPLETE, requestId)
 403         ), APPEND);
 404
 405         ServiceData serviceData = new ServiceData(
 406                 collectionResourceService.modelVersionId,
 407                 new ArrayList<>(),
 408                 IS_GENERATED_NAMING.TRUE, true, true, false,
 409                 null,
 410                 null, 0, null, new ArrayList<>(), null, false);
 411         createMacroService(serviceData, false, randomAlphabetic(5), true, 1);
 412
 413         drawingBoardPage.deploy();
 414         drawingBoardPage.verifyServiceCompletedOnTime("CR_sanity", "service with collection resource");
 415     }
 416
 417     @Test
 418     @FeatureTogglingTest(FLAG_1908_TRANSPORT_SERVICE_NEW_INSTANTIATION_UI)
 419     public void createNewServiceInstance_transportService() {
 420         prepareServicePreset(transportWithPnfsService, false);
 421         String requestId = uuid();
 422         String instanceId = uuid();
 423
 424         SimulatorApi.registerExpectationFromPresets(ImmutableList.of(
 425                 PresetMsoCreateMacroCommonPre1806.ofTransportService(requestId, instanceId),
 426                 new PresetMSOOrchestrationRequestGet(COMPLETE, requestId)
 427             ), APPEND);
 428
 429         ServiceData serviceData = new ServiceData(
 430                 transportWithPnfsService.modelVersionId,
 431                 new ArrayList<>(),
 432                 IS_GENERATED_NAMING.TRUE, true, true, false,
 433                 null,
 434                 null, 0, null, new ArrayList<>(), null, false);
 435         createMacroService(serviceData, false, randomAlphabetic(5), false, 1);
 436
 437         drawingBoardPage.deploy();
 438         drawingBoardPage.verifyServiceCompletedOnTime("AIM Transport SVC_ym161f", "transport service");
 439     }
 440
 441     @Test
 442     @FeatureTogglingTest(FLAG_1902_VNF_GROUPING)
 443     public void createNewServiceInstance_aLaCarte_VnfGrouping() {
 444
 445         String randomAlphabetic = randomAlphabetic(5);
 446
 447         ServiceData serviceData = new ServiceData(
 448                 aLaCarteVnfGroupingService.modelVersionId,
 449                 ImmutableList.of(),
 450                 IS_GENERATED_NAMING.FALSE, false, true, false,
 451                 null, null, 0, null, ImmutableList.of(), null, false);
 452         prepareServicePreset(aLaCarteVnfGroupingService, false);
 453
 454         createALaCarteService(serviceData, randomAlphabetic);
 455
 456         // this is the instance-name that createALaCarteService is using
 457         String serviceInstanceName = randomAlphabetic + "instancename";
 458
 459         final String requestId = PresetMSOBaseCreateInstancePost.DEFAULT_REQUEST_ID;
 460         final String serviceInstanceId = "d2391436-8d55-4fde-b4d5-72dd2cf13cgh";
 461         final ImmutableMap<Keys, String> names = ImmutableMap.<Keys, String>builder()
 462                 .put(Keys.SERVICE_NAME, serviceInstanceName)
 463                 .build();
 464         SimulatorApi.registerExpectationFromPresets(ImmutableList.of(
 465                 new PresetMSOCreateServiceInstanceGen2WithNamesAlacarteGroupingService(names, 0, requestId, serviceInstanceId, "us16807000"),
 466                 new PresetAAIPostNamedQueryForViewEdit(serviceInstanceId, serviceInstanceName, false, false)
 467         ), SimulatorApi.RegistrationStrategy.APPEND);
 468
 469         drawingBoardPage.deploy();
 470         verifyModuleInPendingTable(serviceInstanceName, requestId, null, ImmutableSet.of(IN_PROGRESS), false, false);
 471         verifyModuleInPendingTable(serviceInstanceName, requestId, null, ImmutableSet.of(COMPLETED), false, true);
 472         InstantiationStatusPage.verifyOpenNewViewEdit(serviceInstanceName, serviceInstanceId, aLaCarteVnfGroupingService.modelVersionId, "TYLER SILVIA", "e433710f-9217-458d-a79d-1c7aff376d89", "EDIT");
 473     }
 474
 475     public interface Invoker{
 476         void invoke();
 477     }
 478
 479     private void doReduxStep(Map<String, String> reduxStates, String randomAlphabetic, int startInStep, String reduxForStep, MutableInt currentStep, String mode, Invoker todo) {
 480         try {
 481             switch (mode) {
 482                 case "DEV":
 483                     if (currentStep.getValue() < startInStep) {
 484                         // skip up to startInStep
 485                         return;
 486                     } else if (currentStep.getValue() == startInStep) {
 487
 488                         vidBasePage.setReduxState(reduxForStep);
 489
 490                         vidBasePage.navigateTo("serviceModels.htm#/servicePlanning?serviceModelId=6b528779-44a3-4472-bdff-9cd15ec93450");
 491                         vidBasePage.goToIframe();
 492                     }
 493
 494                     reduxStates.put(String.valueOf(currentStep), vidBasePage.getReduxState());
 495                     break;
 496
 497                 case "RUNTIME":
 498                 default:
 499                     // log current redux state, before invocation
 500                     reduxStates.put(String.valueOf(currentStep), vidBasePage.getReduxState());
 501                     logger.info("reduxGator runtime reduxState for step {}:\n{}", currentStep, vidBasePage.getReduxState());
 502                     break;
 503             }
 504
 505             try {
 506                 todo.invoke();
 507             } catch (AssertionError | Exception e) {
 508                 throw new AssertionError(String.join("\n",
 509                         "Current step: " + currentStep,
 510                         "Random alphabetic: " + randomAlphabetic,
 511                         "Starting reduxState: " + reduxStates.get(String.valueOf(currentStep)),
 512                         "Current reduxState:  " + vidBasePage.getReduxState()
 513                 ), e);
 514             }
 515         } finally {
 516             logger.info("Cumulative reduxState: {}", reduxStates);
 517             currentStep.increment();
 518         }
 519     }
 520
 521     //@Step("duplicate vnf")
 522     private void duplicateVnf(VnfData vnfData, int count) {
 523         hoverAndClickDuplicateButton(extractNodeToEdit(vnfData));
 524         vidBasePage.screenshotDeployDialog("duplicateVnf-" + vnfData.vnfName);
 525         List<WebElement> options = ((RemoteWebElement)Get.byId("duplicate-select")).findElementsByTagName("option");
 526         assertThat(options.stream().map(x -> x.getText()).collect(Collectors.toList()), Matchers.contains("1","2"));
 527         SelectOption.byIdAndVisibleText("duplicate-select", String.valueOf(count));
 528         Click.byClassAndVisibleText("sdc-button__primary", "DUPLICATE");
 529     }
 530
 531     private String cleanSeparators(String... s) {
 532         return String.join("", s).replace(" ", "");
 533     }
 534
 535     //@Step("edit vf module and just set name")
 536     private void editVfModuleAndJustSetName(String vfModuleName, String vfModuleUUID) {
 537         hoverAndClickEditButton(vfModuleUUID + "-" + vfModuleName);
 538         Input.text("VF instance name ZERO", "instanceName");
 539         clickToCloseModal(VNF_SET_BUTTON_TEST_ID);
 540     }
 541
 542     @Test
 543     public void createNewServiceInstance_macro_validPopupDataAndUI__ecompNamingServiceFalseVnfTrue_vgNameFalse() {
 544         ServiceData serviceData = new ServiceData(
 545                 macroSriovNoDynamicFieldsEcompNamingFalseFullModelDetails.modelVersionId,
 546                 new ArrayList<>(),
 547                 IS_GENERATED_NAMING.FALSE, true, false, true,
 548                 "2017-488_PASQUALE-vPE 0",
 549                 vfModule0Name, 1, "1", new ArrayList<>(), vfModule0UUID, false);
 550
 551         prepareServicePreset(macroSriovNoDynamicFieldsEcompNamingFalseFullModelDetails, false);
 552
 553         final String serviceInstanceName = createMacroService(serviceData, true);
 554         createVnf(serviceData, true, serviceInstanceName);
 555         createVfModule(serviceData, serviceInstanceName, true, false);
 556
 557     }
 558
 559     @Test
 560     public void createNewServiceInstance_macro_validPopupDataAndUI__ecompNamingServiceFalseVnfFalse_vgNameFalse() {
 561         ServiceData serviceData = new ServiceData(
 562                 macroSriovNoDynamicFieldsEcompNamingFalseFullModelDetailsVnfEcompNamingFalse.modelVersionId,
 563                 new ArrayList<>(),
 564                 IS_GENERATED_NAMING.FALSE, false, false, false,
 565                 "2017-488_PASQUALE-vPE 0",
 566                 vfModule0Name, 1, "1", new ArrayList<>(), vfModule0UUID, false);
 567
 568         prepareServicePreset(macroSriovNoDynamicFieldsEcompNamingFalseFullModelDetailsVnfEcompNamingFalse, false);
 569
 570         final String serviceInstanceName = createMacroService(serviceData, true);
 571         createVnf(serviceData, true, serviceInstanceName);
 572         createVfModule(serviceData, serviceInstanceName, true, false);
 573
 574     }
 575
 576     @Test
 577     public void createNewServiceInstance_macro_validPopupDataAndUI__ecompNamingServiceFalseVnfFalse_vgNameTrue() throws Exception {
 578         ServiceData serviceData = new ServiceData(
 579                 macroSriovNoDynamicFieldsEcompNamingFalseFullModelDetailsVnfEcompNamingFalse.modelVersionId,
 580                 new ArrayList<>(),
 581                 IS_GENERATED_NAMING.FALSE, false, true, false,
 582                 "2017-488_PASQUALE-vPE 0",
 583                 "2017488_pasqualevpe0..2017488PasqualeVpe..PASQUALE_vRE_BV..module-1", 0,
 584                 NO_MAX_INSTANCES_IN_MODEL, new ArrayList<>(), "25284168-24bb-4698-8cb4-3f509146eca5", false);
 585
 586         prepareServicePreset(macroSriovNoDynamicFieldsEcompNamingFalseFullModelDetailsVnfEcompNamingFalse, false);
 587
 588         final String serviceInstanceName = createMacroService(serviceData, true);
 589         createVnf(serviceData, true, serviceInstanceName);
 590         clickRemoveVfModule(vfModule0UUID, vfModule0Name);
 591         createVfModule(serviceData, serviceInstanceName, false, true);
 592
 593     }
 594
 595     @Test
 596     @FeatureTogglingTest(FLAG_2002_ANY_ALACARTE_BESIDES_EXCLUDED_NEW_INSTANTIATION_UI)
 597     public void createNewServiceInstance_aLaCarte_WithVnf() {
 598         final ModelInfo serviceModelInfo = ModelInfo.aLaCarteServiceCreationNewUI;
 599         String serviceInstanceName = "ALaCarteWithVnf"+randomAlphabetic(5);
 600         String vnfInstanceName= "VnfForALaCarte"+randomAlphabetic(5);
 601         VnfData vnfData = new VnfData("vOCG_1804_VF 0", "aca3f7b1-15f9-45a5-b182-b8b5aca84a76", vnfInstanceName, true);
 602         VfData vfmData = new VfData("vocg_1804_vf0..Vocg1804Vf..base_ocg..module-0", false, 1, "1", emptyList(), "815db6e5-bdfd-4cb6-9575-82c36df8747a", null);
 603         ServiceData serviceData = new ServiceData(IS_GENERATED_NAMING.TRUE, vnfData, vfmData, true);
 604
 605         resetGetServicesCache();
 606
 607         prepareServicePreset(serviceModelInfo, true);
 608
 609         String requestorID = getUserCredentials().getUserId();
 610
 611         String serviceRequestId = uuid();
 612         String serviceInstanceId = uuid();
 613         String vnfRequestId = uuid();
 614         String vnfInstanceId = uuid();
 615         String vfm0RequestId = uuid();
 616         String vfm0InstanceId = uuid();
 617         String vg1RequestId = uuid();
 618         String vg1InstanceId = uuid();
 619         String vfm1RequestId = uuid();
 620         String vfm1InstanceId = uuid();
 621         String vfm12RequestId = uuid();
 622         String vfm12InstanceId = uuid();
 623
 624         ModelInfoWithCustomization vfm0 = new ModelInfoWithCustomization(
 625             "815db6e5-bdfd-4cb6-9575-82c36df8747a",
 626             "e9c795c8-6b98-4db3-bd90-a84b8ca5181b",
 627             "Vocg1804Vf..base_ocg..module-0",
 628             "4",
 629             "vfModule",
 630             "Vocg1804Vf..base_ocg..module-0",
 631             "a7b333d7-7633-4197-b40d-80fcfcadee94");
 632
 633         ModelInfoWithCustomization vg1 = new ModelInfoWithCustomization(
 634             "9c219e70-1177-494b-8977-1395c9f9168c",
 635             "0ad14d60-98b6-4575-a9b8-458a796c3f98",
 636             "Vocg1804Vf..ocgmgr..module-1",
 637             "4",
 638             "volumeGroup",
 639             "Vocg1804Vf..ocgmgr..module-1",
 640             "f332f3ce-434d-4084-a1e7-5261c16d4940"
 641         );
 642
 643         ModelInfoWithCustomization vfm1 = new ModelInfoWithCustomization(
 644             "9c219e70-1177-494b-8977-1395c9f9168c",
 645             "0ad14d60-98b6-4575-a9b8-458a796c3f98",
 646             "Vocg1804Vf..ocgmgr..module-1",
 647             "4",
 648             "vfModule",
 649             "Vocg1804Vf..ocgmgr..module-1",
 650             "f332f3ce-434d-4084-a1e7-5261c16d4940"
 651         );
 652
 653         ModelInfoWithCustomization vfm12 = new ModelInfoWithCustomization(
 654             "b601eef4-62fd-4201-a788-ae30e06a1aec",
 655             "e3cb8b85-7a3c-4897-b20b-70640c26d671",
 656             "Vocg1804Vf..ocgapp_001..module-12",
 657             "2",
 658             "vfModule",
 659             "Vocg1804Vf..ocgapp_001..module-12",
 660             "fcc82961-865e-4d38-9c7a-207c511405b6"
 661         );
 662
 663         final String vgName = "vg_for_module1";
 664
 665         String vgRelatedInstance = ",{\"relatedInstance\": {"
 666             + "                    \"modelInfo\": {"
 667             + "                        \"modelType\": \"volumeGroup\""
 668             + "                    },"
 669             + "                    \"instanceId\": \""+vg1InstanceId+"\","
 670             + "                    \"instanceName\": \""+vgName+"\""
 671             + "                }}";
 672
 673
 674         registerExpectationFromPresets(
 675             ImmutableList.of(
 676                 new PresetMSOCreateServiceInstanceAlacarte(
 677                     ImmutableMap.of(Keys.SERVICE_NAME, serviceInstanceName),
 678                     serviceRequestId, serviceInstanceId,
 679                     requestorID, serviceModelInfo),
 680                 PRESET_SOME_LEGACY_REGION_TO_ATT_AIC,
 681                 new PresetMSOOrchestrationRequestGet(COMPLETE, serviceRequestId),
 682                 new PresetMSOCreateVnfALaCarteE2E(vnfRequestId, serviceInstanceId, vnfInstanceId, "ONAP", requestorID, serviceModelInfo),
 683                 new PresetMSOOrchestrationRequestGet(COMPLETE, vnfRequestId),
 684                 PRESET_MTN6_TO_ATT_AIC,
 685                 new PresetMSOCreateVfModuleALaCarteE2E(vfm0RequestId, vfm0InstanceId, serviceInstanceId, vnfInstanceId, requestorID, serviceModelInfo, null, vfm0, null),
 686                 new PresetMSOOrchestrationRequestGet(COMPLETE, vfm0RequestId),
 687                 new PresetMSOCreateVfModuleALaCarteE2E(vg1RequestId, vg1InstanceId, serviceInstanceId, vnfInstanceId, requestorID, serviceModelInfo, vgName, vg1, null),
 688                 new PresetMSOOrchestrationRequestGet(COMPLETE, vg1RequestId),
 689                 new PresetMSOCreateVfModuleALaCarteE2E(vfm1RequestId, vfm1InstanceId, serviceInstanceId, vnfInstanceId, requestorID, serviceModelInfo, null, vfm1, vgRelatedInstance),
 690                 new PresetMSOOrchestrationRequestGet(COMPLETE, vfm1RequestId),
 691                 new PresetMSOCreateVfModuleALaCarteE2E(vfm12RequestId, vfm12InstanceId, serviceInstanceId, vnfInstanceId, requestorID, serviceModelInfo, null, vfm12, null),
 692                 new PresetMSOOrchestrationRequestGet(COMPLETE, vfm12RequestId)
 693             ),
 694             APPEND
 695         );
 696
 697         loadServicePopup(serviceModelInfo.modelVersionId);
 698         fillALaCarteServicePopup(serviceInstanceName);
 699
 700         createVnf(vnfData, false, serviceInstanceName);
 701         createVfModule(serviceData, serviceInstanceName, true, false);
 702         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);
 703         createVfModule(serviceData, serviceInstanceName, false, false);
 704         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);
 705         createVfModule(serviceData, serviceInstanceName, false, false);
 706         drawingBoardPage.deploy();
 707         drawingBoardPage.verifyServiceCompletedOnTime(serviceInstanceName, "service "+serviceInstanceName);
 708     }
 709
 710     @Test
 711     @FeatureTogglingTest(FLAG_5G_IN_NEW_INSTANTIATION_UI)
 712     public void createNewServiceInstance_aLaCarte_withNetwork_validPopupDataAndUI() {
 713         String serviceInstanceName = "NcService"+randomAlphabetic(5);
 714         String networkInstanceName= "NcNetowrk"+randomAlphabetic(5);
 715         String defactoNetworkInstanceName = "ExtVL"+networkInstanceName;
 716
 717         prepareServicePreset(aLaCarteNetworkProvider5G, true);
 718         String serviceRequestId = uuid();
 719         String networkRequestId = uuid();
 720         String requestorID = getUserCredentials().getUserId();
 721         registerExpectationFromPresets(
 722                 ImmutableList.of(
 723                     new PresetMSOCreateServiceInstanceAlacarte(
 724                         ImmutableMap.of(Keys.SERVICE_NAME, serviceInstanceName),
 725                         serviceRequestId, DEFAULT_SERVICE_INSTANCE_ID,
 726                             requestorID, aLaCarteNetworkProvider5G),
 727                     new PresetMSOOrchestrationRequestGet(COMPLETE, serviceRequestId),
 728                     PRESET_SOME_LEGACY_REGION_TO_ATT_AIC,
 729                     new PresetMSOCreateNetworkALaCarte5G(networkRequestId, DEFAULT_SERVICE_INSTANCE_ID, defactoNetworkInstanceName, requestorID),
 730                     new PresetMSOOrchestrationRequestGet(COMPLETE, networkRequestId),
 731                     new PresetMSOOrchestrationRequestsGet5GServiceInstanceAndNetwork(
 732                             new ResponseDetails(serviceInstanceName, serviceRequestId, COMPLETE, "service"),
 733                             new ResponseDetails(defactoNetworkInstanceName, networkRequestId, COMPLETE, "network"),
 734                             DEFAULT_SERVICE_INSTANCE_ID)
 735                 ),
 736             APPEND
 737         );
 738         loadServicePopup(aLaCarteNetworkProvider5G.modelVersionId);
 739         fillALaCarteServicePopup(serviceInstanceName);
 740         VnfData networkData = new VnfData("SR-IOV Provider-1", "840ffc47-e4cf-46de-8e23-525fd8c6fdc3", defactoNetworkInstanceName, false);
 741         createNetwork(networkData, false, false, serviceInstanceName);
 742
 743         drawingBoardPage.deploy();
 744         drawingBoardPage.verifyServiceCompletedOnTime(serviceInstanceName, "service "+serviceInstanceName);
 745     }
 746
 747     private void fillALaCarteServicePopup(String serviceInstanceName) {
 748         BrowseASDCPage browseASDCPage = new BrowseASDCPage();
 749         WebElement instanceNameInput = Get.byId("instanceName");
 750         instanceNameInput.sendKeys(serviceInstanceName);
 751         VidBasePage.selectSubscriberById("e433710f-9217-458d-a79d-1c7aff376d89");
 752         String serviceType = "TYLER SILVIA";
 753         Wait.waitByClassAndText(Constants.CreateNewInstance.SERVICE_TYPE_OPTION_CLASS, serviceType, 30);
 754         browseASDCPage.selectServiceTypeByName(serviceType);
 755         SelectOption.byTestIdAndVisibleText("WayneHolland", (Constants.OwningEntity.OWNING_ENTITY_SELECT_TEST_ID));
 756         SelectOption.byTestIdAndVisibleText("WATKINS", Constants.OwningEntity.PROJECT_SELECT_TEST_ID);
 757         Click.byTestId("form-set");
 758         VidBasePage.goOutFromIframe();
 759         browseASDCPage.goToIframe();
 760     }
 761
 762     @Test
 763     public void createNewServiceInstance_macro_validPopupDataAndUI() {
 764
 765         List<String> serviceDynamicFields = Arrays.asList("2017488 pasqualevpe0 asn:");
 766         ServiceData serviceData = new ServiceData(
 767                 macroSriovWithDynamicFieldsEcompNamingTruePartialModelDetails.modelVersionId,
 768                 serviceDynamicFields,
 769                 IS_GENERATED_NAMING.TRUE, true, true, false,
 770                 "2017-488_PASQUALE-vPE 0",
 771                 "2017488_pasqualevpe0..2017488PasqualeVpe..PASQUALE_vRE_BV..module-1", 0,
 772             NO_MAX_INSTANCES_IN_MODEL, new ArrayList<>(),
 773             "25284168-24bb-4698-8cb4-3f509146eca5", false);
 774
 775         prepareServicePreset(macroSriovWithDynamicFieldsEcompNamingTruePartialModelDetails, false);
 776
 777         final String serviceInstanceName = createMacroService(serviceData, true);
 778         createVnf(serviceData, true, serviceInstanceName);
 779         clickRemoveVfModule(vfModule0UUID, vfModule0Name);
 780         createVfModule(serviceData, serviceInstanceName, false, false);
 781
 782     }
 783
 784     //@Step("deploy and verify module in pending table")
 785     private void deployAndVerifyModuleInPendingTableMacro(String serviceInstanceName, String requestId1, String requestId2) {
 786         drawingBoardPage.deploy();
 787
 788         boolean simulatorUpdated = false;
 789
 790         int[] ids = {0, 0, 1, 2};
 791         String[] statuses = {IN_PROGRESS, COMPLETED, IN_PROGRESS, PENDING};
 792         for (int i = 0; i < ids.length; i++) {
 793             String actualInstanceName = getActualInstanceName(serviceInstanceName, ids[i]);
 794             verifyModuleInPendingTable(actualInstanceName, requestId1, requestId2, ImmutableSet.of(statuses[i]), true, simulatorUpdated);
 795             simulatorUpdated = true;
 796         }
 797         vidBasePage.screenshotDeployDialog(serviceInstanceName);
 798     }
 799
 800     private void verifyModuleInPendingTable(String serviceInstanceName, String requestId1, String requestId2, Set<String> expectedStatuses, boolean isMacro, boolean simulatorUpdated) {
 801         DrawingBoardPage.ServiceStatusChecker serviceStatusChecker = new DrawingBoardPage.ServiceStatusChecker(serviceInstanceName, expectedStatuses);
 802         boolean statusIsShown = Wait.waitFor(serviceStatusChecker, null, 20, 2);
 803         final String assertionMessage = String.format("service %s: none of rowClasses [%s] is in expectedStatuses: [%s]  ",
 804                 serviceInstanceName,
 805                 String.join(",", serviceStatusChecker.getColumnClassesSet()),
 806                 String.join(",", expectedStatuses));
 807
 808         assertTrue(assertionMessage, statusIsShown);
 809
 810         if (isMacro) {
 811             InstantiationStatusPage.assertInstantiationStatusRow(
 812                     serviceInstanceName, expectedRowFields(serviceInstanceName));
 813         } else {
 814             InstantiationStatusPage.assertInstantiationStatusRow(
 815                     serviceInstanceName, expectedALaCarteRowFields(serviceInstanceName));
 816         }
 817
 818         if (!simulatorUpdated) {
 819             if (requestId2 != null) {
 820                 registerExpectationFromPreset(new PresetMSOOrchestrationRequestGet(IN_PROGRESS, requestId2), APPEND);
 821             }
 822             registerExpectationFromPreset(new PresetMSOOrchestrationRequestGet("COMPLETE", requestId1), APPEND);
 823         }
 824         vidBasePage.screenshotDeployDialog(serviceInstanceName);
 825     }
 826
 827     private String getActualInstanceName(String serviceInstanceName, Integer i) {
 828         return i==0 ? serviceInstanceName : serviceInstanceName + "_00" + i;
 829     }
 830
 831     //@Step("verify open view edit")
 832     private void verifyOpenViewEdit(String serviceInstanceName) {
 833         boolean[] openEnabled = {true, false, false};
 834         ImmutableList.of(0, 1, 2).forEach(i -> {
 835             String actualInstanceName = getActualInstanceName(serviceInstanceName, i);
 836             if (Features.FLAG_1902_NEW_VIEW_EDIT.isActive() || FLAG_1908_MACRO_NOT_TRANSPORT_NEW_VIEW_EDIT.isActive()) {
 837                 InstantiationStatusPage.verifyOpenNewViewEdit(actualInstanceName, openEnabled[i], "EDIT");
 838             }
 839             else {
 840                 vidBasePage.verifyOpenOldViewEdit(actualInstanceName, null, openEnabled[i], true, true);
 841             }
 842         });
 843     }
 844
 845     //@Step("verify open audit info")
 846     private void verifyOpenAuditInfo(String serviceInstanceName) {
 847         boolean auditInfoEnabled = true;
 848         String[] statuses = {COMPLETED, IN_PROGRESS, PENDING};
 849         for (Integer i : ImmutableList.of(0, 1, 2)) {
 850             String actualInstanceName = getActualInstanceName(serviceInstanceName, i);
 851             InstantiationStatusPage.checkMenuItem(actualInstanceName, Constants.InstantiationStatus.CONTEXT_MENU_HEADER_AUDIT_INFO_ITEM, auditInfoEnabled, contextMenuOpen -> {
 852                 Click.byTestId(contextMenuOpen);
 853                 checkAuditInfoModal(actualInstanceName, i, statuses);
 854             });
 855             final WebElement row = InstantiationStatusPage.getInstantiationStatusRow(actualInstanceName);
 856             row.findElement(By.id(Constants.InstantiationStatus.TD_JOB_STATUS_ICON + "-" + (i))).click();
 857             checkAuditInfoModal(actualInstanceName, i, statuses);
 858         }
 859     }
 860
 861     private void checkAuditInfoModal(String actualInstanceName, Integer i, String[] statuses) {
 862
 863         Wait.waitByTestId("vidJobStatus", 10);
 864
 865         WebElement webElement = Get.byTestId("model-item-value-serviceInstanceName");
 866         assertEquals(webElement.getText(), actualInstanceName, "Service Instance Name must be equal");
 867
 868         WebElement vidTableElement = Get.byId("service-instantiation-audit-info-vid");
 869         assertEquals(3, vidTableElement.findElement(By.tagName("thead")).findElements(By.tagName("th")).size(), "VID table must contain 3 columns");
 870
 871         List<WebElement> vidStatusesElements = vidTableElement.findElements(By.id("vidJobStatus"));
 872         List<String> vidStatuses = vidStatusesElements.stream()
 873                 .map(s ->
 874                         convertUITextCapitalizeAndFormatPipe(s.getText()))
 875                 .collect(Collectors.toList());
 876
 877         List<String> serviceStatus = Arrays.asList(Arrays.copyOfRange(statuses, i, statuses.length));
 878         assertThat("statuses for " + actualInstanceName + " must be as expected", vidStatuses, containsInAnyOrder(serviceStatus.toArray()));
 879         String dateString = vidTableElement.findElements(By.id("vidStatusTime")).get(0).getText();
 880         assertTrue("vid Status Time column must contains valid date in format : MMM dd, yyyy HH:mm", isDateValid(dateString, "MMM dd, yyyy HH:mm"));
 881
 882         WebElement MSOTableElement = Get.byId("service-instantiation-audit-info-mso");
 883         assertEquals(3, MSOTableElement.findElement(By.tagName("thead")).findElements(By.tagName("th")).size(), "MSO table must contain 3 columns");
 884
 885         if (statuses[i].equals(PENDING)) {
 886             assertEquals(0, MSOTableElement.findElement(By.tagName("tbody")).findElements(By.tagName("tr")).size(), "When status is PENDING MSO table is empty");
 887         }
 888
 889         vidBasePage.screenshotDeployDialog("audit-info-" + actualInstanceName);
 890         Click.byId(Constants.AuditInfoModal.CANCEL_BUTTON);
 891     }
 892
 893     private String convertUITextCapitalizeAndFormatPipe(String text) {
 894         return text.toUpperCase().replace("-", "_");
 895     }
 896
 897     private boolean isDateValid(String dateToValidate, String dateFromat) {
 898
 899         if (dateToValidate == null) {
 900             return false;
 901         }
 902         SimpleDateFormat sdf = new SimpleDateFormat(dateFromat);
 903         sdf.setLenient(false);
 904         try {
 905             //if not valid, it will throw ParseException
 906             Date date = sdf.parse(dateToValidate);
 907
 908         } catch (ParseException e) {
 909             e.printStackTrace();
 910             return false;
 911         }
 912         return true;
 913     }
 914
 915     //@Step("verifyDeleteJob")
 916     private void verifyDeleteJob(String serviceInstanceName) {
 917         boolean[] deleteEnabled = {false, false, true};
 918         String[] statuses = {COMPLETED, IN_PROGRESS, PENDING};
 919         verifyDeleteOrHideOperation(serviceInstanceName, Constants.InstantiationStatus.CONTEXT_MENU_REMOVE, statuses, deleteEnabled, "deleted");
 920     }
 921
 922     //@Step("verify hide job")
 923     private void verifyHideJob(String serviceInstanceName) {
 924         boolean[] hideEnabled = {true, false};
 925         String[] statuses = {COMPLETED, IN_PROGRESS};
 926         verifyDeleteOrHideOperation(serviceInstanceName, Constants.InstantiationStatus.CONTEXT_MENU_HIDE, statuses, hideEnabled, "hidden");
 927     }
 928
 929     private void verifyDeleteOrHideOperation(String serviceInstanceName, String contextMenuItem, String[] statuses, boolean[] operationEnabled, String operationName) {
 930         for (int i = 0; i < statuses.length; i++) {
 931             String actualInstanceName = getActualInstanceName(serviceInstanceName, i);
 932             InstantiationStatusPage.checkMenuItem(actualInstanceName, contextMenuItem, operationEnabled[i], contextMenuDelete -> {
 933                 Click.byTestId(contextMenuDelete);
 934                 GeneralUIUtils.ultimateWait();
 935                 assertNull(actualInstanceName + " should be " + operationName,
 936                         InstantiationStatusPage.getInstantiationStatusRow(actualInstanceName));
 937             });
 938         }
 939         vidBasePage.screenshotDeployDialog(serviceInstanceName);
 940     }
 941
 942     private ImmutableMap<String, String> expectedRowFields(String actualInstanceName) {
 943         return ImmutableMap.<String, String>builder()
 944                 .put("userId", getUserCredentials().getUserId())
 945                 .put("serviceModelName", "action-data")
 946                 .put("serviceInstanceName", actualInstanceName)
 947                 .put("serviceModelVersion", "1.0")
 948                 .put("subscriberName", "SILVIA ROBBINS")
 949                 .put("serviceType", "TYLER SILVIA")
 950                 .put("regionId", "hvf6")
 951                 .put("tenantName", "AIN Web Tool-15-D-testalexandria")
 952                 .put("aicZoneName", "NFTJSSSS-NFT1")
 953                 .put("project", "WATKINS")
 954                 .put("owningEntityName", "WayneHolland")
 955                 .put("pause", "false")
 956                 .build();
 957     }
 958
 959     private ImmutableMap<String, String> expectedALaCarteRowFields(String actualInstanceName) {
 960         return ImmutableMap.<String, String>builder()
 961                 .put("userId", getUserCredentials().getUserId())
 962                 .put("serviceModelName", "Grouping Service for Test")
 963                 .put("serviceInstanceName", actualInstanceName)
 964                 .put("serviceModelVersion", "1.0")
 965                 .put("subscriberName", "SILVIA ROBBINS")
 966                 .put("serviceType", "TYLER SILVIA")
 967                 .put("project", "WATKINS")
 968                 .put("owningEntityName", "WayneHolland")
 969                 .put("pause", "false")
 970                 .build();
 971     }
 972
 973     //@Step("create sriov service")
 974     private String createMacroService(ServiceData serviceData, boolean tryCancelsAndReentries) {
 975         return createMacroService(serviceData, tryCancelsAndReentries, randomAlphabetic(5), true, 3);
 976     }
 977
 978     //@Step("create sriov service")
 979     private String createMacroService(ServiceData serviceData, boolean tryCancelsAndReentries, String randomAlphabetic, boolean fillLcpRegionAndTenantAndZone, int bulkSize) {
 980         BrowseASDCPage browseASDCPage = new BrowseASDCPage();
 981         User user = usersService.getUser(Constants.Users.SILVIA_ROBBINS_TYLER_SILVIA);
 982
 983         // simulate typing with spaces, but expected is without spaces
 984         String serviceInstanceNameWithSpaces = randomAlphabetic + " instance name";
 985         String serviceInstanceName = cleanSeparators(serviceInstanceNameWithSpaces);
 986
 987         List<String> cycles = tryCancelsAndReentries ? ImmutableList.of("WILL_CANCEL", "AFTER_CANCEL") : ImmutableList.of("SINGLE_SHOT");
 988         cycles.forEach(cycle -> {
 989             if ("AFTER_CANCEL".equals(cycle)) {
 990                 loadServicePopupOnBrowseASDCPage(serviceData.modelUuid);
 991             } else {
 992                 loadServicePopup(serviceData.modelUuid);
 993             }
 994
 995             WebElement instanceName = Get.byId("instanceName");
 996             boolean isRequired = isElementByIdRequired("instanceName-label");
 997             if (serviceData.isGeneratedNaming == IS_GENERATED_NAMING.TRUE || serviceData.isGeneratedNaming == IS_GENERATED_NAMING.TRUE_BUT_GIVE_NAME_EITHER_WAY) {
 998                 Assert.assertNotNull(instanceName, "instance name input should be visible when serviceEcompNaming == true.");
 999                 Assert.assertFalse(isRequired,"instance name input should be optional when ecompNaming == true.");
1000             } else {
1001                 Assert.assertTrue(isRequired,"instance name input should be required when serviceEcompNaming == false.");
1002             }
1003
1004             if (serviceData.isGeneratedNaming == IS_GENERATED_NAMING.FALSE || serviceData.isGeneratedNaming == IS_GENERATED_NAMING.TRUE_BUT_GIVE_NAME_EITHER_WAY) {
1005                 instanceName.sendKeys(serviceInstanceName);
1006             }
1007             String setButtonTestId = "form-set";
1008
1009             //serviceType should be dependent on subscriber selection
1010             assertElementDisabled("serviceType-select");
1011             Wait.waitByClassAndText(Constants.CreateNewInstance.SUBSCRIBER_NAME_OPTION_CLASS, "SILVIA ROBBINS", 30);
1012             GeneralUIUtils.ultimateWait();
1013             Click.byTestId(Constants.SUBSCRIBER_NAME_SELECT_TESTS_ID);
1014             if (Features.FLAG_RESTRICTED_SELECT.isActive())
1015                 assertElementExistAccordingTagNameAndTestId("select", Constants.SUBSCRIBER_SELECT_ID);
1016             else{
1017                 assertDropdownPermittedItemsByLabel(user.subscriberNames, Constants.CreateNewInstance.SUBSCRIBER_NAME_OPTION_CLASS);
1018
1019             }
1020             VidBasePage.selectSubscriberById("e433710f-9217-458d-a79d-1c7aff376d89");
1021             //lcpRegion should be dependent on serviceType selection
1022             assertElementDisabled("lcpRegion-select");
1023
1024             String serviceType = "TYLER SILVIA";
1025             Wait.waitByClassAndText(Constants.CreateNewInstance.SERVICE_TYPE_OPTION_CLASS, serviceType, 30);
1026             browseASDCPage.selectServiceTypeByName(serviceType);
1027
1028             String owningEntity = "WayneHolland";
1029             GeneralUIUtils.ultimateWait();
1030             Wait.waitByClassAndText(Constants.CreateNewInstance.OWNING_ENTITY_OPTION, owningEntity, 30);
1031             SelectOption.byTestIdAndVisibleText(owningEntity, (Constants.OwningEntity.OWNING_ENTITY_SELECT_TEST_ID));
1032             assertSetButtonDisabled(setButtonTestId);
1033
1034             SelectOption.byTestIdAndVisibleText("ERICA", Constants.ViewEdit.PRODUCT_FAMILY_SELECT_TESTS_ID);
1035             browseASDCPage.selectProductFamily("e433710f-9217-458d-a79d-1c7aff376d89");
1036
1037             if (fillLcpRegionAndTenantAndZone) {
1038
1039                 //we assume that if fillLcpRegionAndTenantAndZone is true tenant and lcpRegion are required for this service model
1040                 //If you want to fill lcpRegionAndTenant where they are optional you can refactor this test...
1041                 assertSetButtonDisabled(setButtonTestId);
1042
1043                 //tenant should be dependent on lcpRegion selection
1044                 assertElementDisabled("tenant-select");
1045
1046                 String lcpRegion = "hvf6";
1047                 Wait.waitByClassAndText("lcpRegionOption", lcpRegion, 30);
1048                 viewEditPage.selectLcpRegion(lcpRegion, AIC);
1049
1050                 GeneralUIUtils.ultimateWait();
1051                 browseASDCPage.selectTenant("bae71557c5bb4d5aac6743a4e5f1d054");
1052
1053                 browseASDCPage.selectAicZone("NFT1");
1054             }
1055
1056             assertSetButtonEnabled(setButtonTestId);
1057
1058
1059             SelectOption.byTestIdAndVisibleText("WATKINS", Constants.OwningEntity.PROJECT_SELECT_TEST_ID);
1060             if (bulkSize!=1) {
1061                 assertNotificationAreaVisibilityBehaviourAndSetBulkSize(bulkSize);
1062             }
1063
1064             assertPauseOnPausePointsVisibility(serviceData.multiStageDesign);
1065
1066             validateDynamicFields(serviceData.dynamicFields);
1067
1068             vidBasePage.screenshotDeployDialog("createMacroService-" + serviceInstanceName);
1069
1070             if ("WILL_CANCEL".equals(cycle)) {
1071                 Click.byTestId(Constants.CANCEL_BUTTON_TEST_ID);
1072             } else {
1073                 Click.byTestId(setButtonTestId);
1074             }
1075
1076             VidBasePage.goOutFromIframe();
1077
1078             browseASDCPage.goToIframe();
1079
1080         });
1081         return serviceInstanceName;
1082     }
1083
1084     private String createALaCarteService(ServiceData serviceData, String randomAlphabetic) {
1085         BrowseASDCPage browseASDCPage = new BrowseASDCPage();
1086         User user = usersService.getUser(Constants.Users.SILVIA_ROBBINS_TYLER_SILVIA);
1087
1088         // simulate typing with spaces, but expected is without spaces
1089         String serviceInstanceNameWithSpaces = randomAlphabetic + " instance name";
1090         String serviceInstanceName = cleanSeparators(serviceInstanceNameWithSpaces);
1091
1092         loadServicePopup(serviceData.modelUuid);
1093
1094         WebElement instanceName = Get.byId("instanceName");
1095         if (serviceData.isGeneratedNaming == IS_GENERATED_NAMING.TRUE || serviceData.isGeneratedNaming == IS_GENERATED_NAMING.TRUE_BUT_GIVE_NAME_EITHER_WAY) {
1096             Assert.assertNull(instanceName, "instance name input should be invisible when serviceEcompNaming == true.");
1097         }
1098         if (serviceData.isGeneratedNaming == IS_GENERATED_NAMING.FALSE || serviceData.isGeneratedNaming == IS_GENERATED_NAMING.TRUE_BUT_GIVE_NAME_EITHER_WAY) {
1099             instanceName.sendKeys(serviceInstanceName);
1100         }
1101
1102         //serviceType should be dependent on subscriber selection
1103         assertElementDisabled("serviceType-select");
1104         Wait.waitByClassAndText(Constants.CreateNewInstance.SUBSCRIBER_NAME_OPTION_CLASS, "SILVIA ROBBINS", 30);
1105         GeneralUIUtils.ultimateWait();
1106         Click.byTestId(Constants.SUBSCRIBER_NAME_SELECT_TESTS_ID);
1107         if (Features.FLAG_RESTRICTED_SELECT.isActive())
1108             assertElementExistAccordingTagNameAndTestId("select", Constants.SUBSCRIBER_SELECT_ID);
1109         else{
1110             assertDropdownPermittedItemsByLabel(user.subscriberNames, Constants.CreateNewInstance.SUBSCRIBER_NAME_OPTION_CLASS);
1111
1112         }
1113         VidBasePage.selectSubscriberById("e433710f-9217-458d-a79d-1c7aff376d89");
1114
1115         String serviceType = "TYLER SILVIA";
1116         Wait.waitByClassAndText(Constants.CreateNewInstance.SERVICE_TYPE_OPTION_CLASS, serviceType, 30);
1117         browseASDCPage.selectServiceTypeByName(serviceType);
1118
1119         String setButtonTestId = "form-set";
1120         assertSetButtonDisabled(setButtonTestId);
1121
1122         SelectOption.byTestIdAndVisibleText("WayneHolland", (Constants.OwningEntity.OWNING_ENTITY_SELECT_TEST_ID));
1123
1124         SelectOption.byTestIdAndVisibleText("WATKINS", Constants.OwningEntity.PROJECT_SELECT_TEST_ID);
1125
1126         validateDynamicFields(serviceData.dynamicFields);
1127
1128         vidBasePage.screenshotDeployDialog("createALaCarteService-" + serviceInstanceName);
1129
1130         Click.byTestId(setButtonTestId);
1131
1132         VidBasePage.goOutFromIframe();
1133
1134         browseASDCPage.goToIframe();
1135
1136         return serviceInstanceName;
1137     }
1138
1139     private void assertElementExistAccordingTagNameAndTestId(String tag, String testId) {
1140         WebElement webElement = Get.byId(testId);
1141         Assert.assertEquals(webElement.getTagName(), tag);
1142     }
1143
1144     //@Step("create vnf")
1145     private void createVnf(ServiceData serviceData, boolean tryCancelsAndReentries, String serviceInstanceName) {
1146         createVnf(serviceData.vnfData, tryCancelsAndReentries, serviceInstanceName);
1147     }
1148
1149     private void createNetwork(VnfData vnfData, boolean tryCancelsAndReentries, boolean addedByDefault, String serviceInstanceName) {
1150         createVnf(vnfData, tryCancelsAndReentries, addedByDefault, serviceInstanceName, true);
1151     }
1152
1153     private void createVnf(VnfData vnfData, boolean tryCancelsAndReentries, String serviceInstanceName) {
1154         createVnf(vnfData, tryCancelsAndReentries, true, serviceInstanceName, false);
1155     }
1156
1157     private void createVnf(VnfData vnfData, boolean tryCancelsAndReentries, boolean addedByDefault, String serviceInstanceName, boolean isNetwork) {
1158         BrowseASDCPage browseASDCPage = new BrowseASDCPage();
1159
1160         String nodeToEdit = extractNodeToEdit(vnfData);
1161         if (addedByDefault) {
1162             hoverAndClickEditButton(nodeToEdit);
1163         } else {
1164             drawingBoardPage.clickAddButtonByNodeName(vnfData.vnfName);
1165         }
1166
1167         GeneralUIUtils.ultimateWait();
1168
1169         if (vnfData.isGeneratedNaming) {
1170             Assert.assertFalse(isElementByIdRequired("instanceName-label") ,"instance name input should be optional when EcompNaming == true, and required when false.");
1171         } else {
1172             Input.text(vnfData.vnfInstanceName, "instanceName");
1173         }
1174
1175
1176         //tenant should be dependent on lcpRegion selection
1177         assertElementDisabled("tenant-select");
1178
1179         WebElement legacyRegion = Get.byTestId("lcpRegionText");
1180         Assert.assertNull(legacyRegion, "legacy region shouldn't be visible when lcp region isn't AAIAIC25,olson3 or olson5a.");
1181
1182         browseASDCPage.selectLcpRegion("AAIAIC25");
1183
1184         legacyRegion = Get.byTestId("lcpRegionText");
1185         Assert.assertNotNull(legacyRegion, "legacy region should be visible when lcp region is AAIAIC25,olson3 or olson5a.");
1186
1187         browseASDCPage.selectTenant("092eb9e8e4b7412e8787dd091bc58e86");
1188
1189         assertSetButtonDisabled(VNF_SET_BUTTON_TEST_ID);
1190
1191         if(isNetwork){
1192             browseASDCPage.selectPlatform("platform");
1193         }else {
1194             SelectOption.selectOptionsFromMultiselectById("multi-selectPlatform", ImmutableList.of("platform"));
1195         }
1196
1197         browseASDCPage.selectLineOfBusiness("ONAP");
1198         assertSetButtonEnabled(VNF_SET_BUTTON_TEST_ID);
1199
1200         browseASDCPage.setLegacyRegion("some legacy region");
1201
1202
1203         Wait.waitByTestId("model-item-value-subscriberName", 10);
1204         Assert.assertEquals(Get.byTestId("model-item-value-subscriberName").getText(), "SILVIA ROBBINS", "Subscriber name should be shown in vf module");
1205         if (!vnfData.isGeneratedNaming) {
1206             Assert.assertEquals(Get.byTestId("model-item-value-serviceName").getText(), serviceInstanceName, "Subscriber name should be shown in vf module");
1207         }
1208
1209         vidBasePage.screenshotDeployDialog("createVnf-" + serviceInstanceName);
1210         clickToCloseModal(VNF_SET_BUTTON_TEST_ID);
1211         if (isNetwork) {
1212             return;
1213         }
1214         if (tryCancelsAndReentries) {
1215             hoverAndClickEditButton(nodeToEdit);
1216
1217             Wait.byText("TYLER SILVIA");
1218             GeneralUIUtils.ultimateWait();
1219             assertThat(Get.selectedOptionText(Constants.ViewEdit.LCP_REGION_SELECT_TESTS_ID), startsWith("AAIAIC25"));
1220             Assert.assertEquals(Get.selectedOptionText(Constants.ViewEdit.TENANT_SELECT_TESTS_ID), "USP-SIP-IC-24335-T-01");
1221             Assert.assertEquals(Get.selectedOptionText(Constants.ViewEdit.LINE_OF_BUSINESS_SELECT_TESTS_ID), "ONAP");
1222
1223             Assert.assertTrue(Get.isOptionSelectedInMultiSelect(Constants.OwningEntity.PLATFORM_MULTI_SELECT_TEST_ID, "platform"));
1224
1225             clickToCloseModal(Constants.CANCEL_BUTTON_TEST_ID);
1226         } else {
1227             toggleItemInTree(Constants.DrawingBoard.AVAILABLE_MODELS_TREE);
1228         }
1229         Click.byTestId("node-" + nodeToEdit);
1230     }
1231
1232     private String extractNodeToEdit(VnfData vnfData) {
1233         return vnfData.vnfUuid + "-" + vnfData.vnfName;
1234     }
1235
1236
1237     private void toggleItemInTree(String tree) {
1238         Click.byXpath("//tree-root[@data-tests-id='" + tree + "']//span[@class='" + Constants.DrawingBoard.TOGGLE_CHILDREN + "']");
1239     }
1240
1241     private void hoverAndClickEditButton(String nodeToEdit) {
1242         hoverAndClickButton(nodeToEdit, Constants.DrawingBoard.CONTEXT_MENU_EDIT);
1243     }
1244
1245     private void hoverAndClickDeleteButton(String nodeToEdit) {
1246         hoverAndClickButton(nodeToEdit, Constants.InstantiationStatus.CONTEXT_MENU_REMOVE);
1247     }
1248
1249     private void hoverAndClickDuplicateButton(String nodeToEdit) {
1250         hoverAndClickButton(nodeToEdit, Constants.InstantiationStatus.CONTEXT_MENU_DUPLICATE);
1251     }
1252     private void hoverAndClickButton(String nodeToEdit, String contextMenuItem) {
1253         String nodeOfEdit = Constants.DrawingBoard.NODE_PREFIX + nodeToEdit;
1254         String buttonOfEdit = nodeOfEdit + Constants.DrawingBoard.CONTEXT_MENU_BUTTON;
1255         GeneralUIUtils.hoverOnAreaByTestId(buttonOfEdit);
1256         Click.byTestId(buttonOfEdit);
1257         Click.byTestId(contextMenuItem);
1258     }
1259
1260     private void uploadSupplementaryFile(String inputFileName, boolean isValid, BrowseASDCPage browseASDCPage, String setButtonTestId) {
1261         if (Features.FLAG_SUPPLEMENTARY_FILE.isActive()) {
1262             GeneralUIUtils.ultimateWait();
1263             Input.file("supplementaryFiles/" + inputFileName, "supplementaryFile");
1264             GeneralUIUtils.ultimateWait();
1265             WebElement fileName = Get.byTestId("file-name");
1266             Assert.assertEquals(fileName.getText(),inputFileName);
1267             browseASDCPage.assertButtonState(setButtonTestId, isValid);
1268         }
1269     }
1270
1271     private void deleteSupplementaryFile() {
1272         if (Features.FLAG_SUPPLEMENTARY_FILE.isActive()) {
1273             Click.byTestId("remove-uploaded-file");
1274             GeneralUIUtils.ultimateWait();
1275             WebElement fileName = Get.byTestId("file-name");
1276             Assert.assertEquals(fileName.getText(),"Choose file");
1277         }
1278     }
1279
1280     //@Step("create vf module")
1281     private void createVfModule(ServiceData serviceData, String serviceInstanceName, boolean addedByDefault, boolean addOpensPopup) {
1282         clickAddVfModule(serviceData, addedByDefault);
1283         if (!addOpensPopup) {
1284             clickEditVfModule(serviceData);
1285         }
1286         fillAndSetVfModulePopup(serviceData, serviceInstanceName);
1287     }
1288
1289     private void fillAndSetVfModulePopup(ServiceData serviceData, String serviceInstanceName) {
1290         String setButtonTestId = "form-set";
1291         BrowseASDCPage browseASDCPage = new BrowseASDCPage();
1292
1293         Assert.assertEquals(isElementByIdRequired("instanceName-label"), !serviceData.vnfData.isGeneratedNaming,"instance name input should be optional when EcompNaming == true, and required when false.");
1294
1295         if (!serviceData.vnfData.isGeneratedNaming) {
1296             Input.text("VF instance name", "instanceName");
1297         }
1298
1299         if (!serviceData.vfData.vgEnabled || (!serviceData.isALaCarte && serviceData.vnfData.isGeneratedNaming)) {
1300             Assert.assertNull(Get.byTestId("volumeGroupName"), "volumeGroupName input should be invisible "
1301                 + "when vgEnabled is false or when vgEnabled is true and EcompGenName is true "
1302                 + "(was: serviceData.vfData.vgEnabled=>" + serviceData.vfData.vgEnabled + ", serviceData.isGeneratedNaming=>" + IS_GENERATED_NAMING.FALSE + ")");
1303         }
1304         else {
1305             Assert.assertFalse(isElementByIdRequired("volumeGroupName-label"),
1306                 "volume Group name input should be always optional");
1307             if (serviceData.vfData.vgName!=null) {
1308                 browseASDCPage.setInputText("volumeGroupName", serviceData.vfData.vgName);
1309             }
1310         }
1311
1312
1313         Wait.waitByTestId("model-item-value-subscriberName", 10);
1314         Assert.assertEquals(Get.byTestId("model-item-value-subscriberName").getText(), "SILVIA ROBBINS", "Subscriber name should be shown in vf module");
1315         Assert.assertEquals(Get.byTestId("model-item-value-min").getText(), Integer.toString(serviceData.vfData.vfMin), "Min should be shown");
1316         if (serviceData.vfData.vfMax!=null) {
1317             if (!serviceData.vfData.vfMax.equals(NO_MAX_INSTANCES_IN_MODEL)) {
1318                 Assert.assertEquals(Get.byTestId("model-item-value-max").getText(), serviceData.vfData.vfMax, "Max should be shown");
1319             }
1320             else {
1321                 String defaultMaxText = Features.FLAG_2002_UNLIMITED_MAX.isActive() ? "Unlimited (default)" : "1";
1322                 Assert.assertEquals(Get.byTestId("model-item-value-max").getText(), defaultMaxText, "Max should be shown with default value");
1323             }
1324         }
1325
1326         if (serviceData.isGeneratedNaming!=IS_GENERATED_NAMING.TRUE) {
1327             Wait.byText(serviceInstanceName);
1328             Assert.assertEquals(Get.byTestId("model-item-value-serviceName").getText(), serviceInstanceName, "Service name should be shown in vf module");
1329         }
1330
1331         if (serviceData.isALaCarte) {
1332             String lcpRegion = "hvf6";
1333             Wait.waitByClassAndText("lcpRegionOption", lcpRegion, 30);
1334             viewEditPage.selectLcpRegion(lcpRegion, AIC);
1335             browseASDCPage.selectTenant("bae71557c5bb4d5aac6743a4e5f1d054");
1336         }
1337
1338         validateDynamicFields(serviceData.vfData.dynamicFields);
1339
1340         uploadSupplementaryFile("invalid-file.json", false, browseASDCPage, setButtonTestId);
1341         deleteSupplementaryFile();
1342         uploadSupplementaryFile("sample.json", true, browseASDCPage, setButtonTestId);
1343
1344         browseASDCPage.screenshotDeployDialog("createVfModule-" + serviceInstanceName);
1345         clickToCloseModal(setButtonTestId);
1346     }
1347
1348     private void clickToCloseModal(String setOrCancelButtonTestId) {
1349         Click.byTestId(setOrCancelButtonTestId);
1350         GeneralUIUtils.ultimateWait();
1351     }
1352
1353     private void clickEditVfModule(ServiceData serviceData) {
1354         hoverAndClickEditButton(serviceData.vfData.uuid + "-" + serviceData.vfData.vfName);
1355     }
1356
1357     private void clickAddVfModule(ServiceData serviceData, boolean addedByDefault) {
1358         if (addedByDefault) {
1359             return;
1360         }
1361         System.out.println("VFModule should be added 'manually'");
1362
1363         final WebElement vfModuleNode = Get.byTestId(Constants.DrawingBoard.NODE_PREFIX + serviceData.vfData.vfName);
1364
1365         if (vfModuleNode == null || !vfModuleNode.isDisplayed()) {
1366             // expand tree
1367             drawingBoardPage.clickNode(serviceData.vnfData.vnfName);
1368         }
1369         drawingBoardPage.clickAddButtonByNodeName(serviceData.vfData.vfName);
1370     }
1371
1372     private void clickRemoveVfModule(String vfModuleId, String vfModuleName) {
1373         System.out.println("will remove " + vfModule0Name);
1374         hoverAndClickDeleteButton(vfModuleId + "-" + vfModuleName);
1375     }
1376
1377     private void assertPauseOnPausePointsVisibility(boolean visibility) {
1378         WebElement pauseElem = Get.byId("Pause");
1379         final String assertionMessage = "pause on pause points visibility should be " + visibility;
1380         if (visibility) {
1381             Assert.assertNotNull(pauseElem, assertionMessage);
1382         } else {
1383             Assert.assertNull(pauseElem, assertionMessage);
1384         }
1385     }
1386
1387     @NotNull
1388     private String uuid() {
1389         return UUID.randomUUID().toString();
1390     }
1391
1392
1393     private void assertNotificationAreaVisibilityBehaviourAndSetBulkSize(int size) {
1394         WebElement webElement = Get.byId("notification-area");
1395         Assert.assertNull(webElement, "notification area should be invisible if only 1 qty.");
1396
1397         SelectOption.byIdAndVisibleText("quantity-select", String.valueOf(size));
1398
1399         webElement = Get.byId("notification-area");
1400         Assert.assertNotNull(webElement, "notification area should be visible if more then 1 qty.");
1401     }
1402
1403     //@Step("prepare service preset")
1404     private void prepareServicePreset(ModelInfo modelInfo, boolean deploy) {
1405         String subscriberId = "e433710f-9217-458d-a79d-1c7aff376d89";
1406
1407         if (deploy) {
1408             registerExpectationForServiceDeployment(
1409                 ImmutableList.of(
1410                     modelInfo,
1411                     pasqualeVmxVpeBvService488Annotations
1412                 ),
1413                 subscriberId, null);
1414         } else {
1415             registerExpectationForServiceBrowseAndDesign(ImmutableList.of(modelInfo), subscriberId);
1416         }
1417     }
1418
1419     static class ServiceData {
1420
1421         ServiceData(String modelUuid, List<String> dynamicFields, IS_GENERATED_NAMING isServiceGeneratedNaming,
1422             boolean isVnfGeneratedNaming, boolean isVgEnabled, boolean multiStageDesign, String vnfName,
1423             String vfName, int vfMin, String vfMax, List<String> vfModuleDynamicFields, String vfVersionId, boolean isALaCarte) {
1424             this.modelUuid = modelUuid;
1425             this.dynamicFields = dynamicFields;
1426             this.isGeneratedNaming = isServiceGeneratedNaming;
1427             this.multiStageDesign = multiStageDesign;
1428             this.isALaCarte = isALaCarte;
1429             this.vnfData = new VnfData(vnfName, "69e09f68-8b63-4cc9-b9ff-860960b5db09", "VNF instance name", isVnfGeneratedNaming);
1430             this.vfData = new VfData(vfName, isVgEnabled, vfMin, vfMax, vfModuleDynamicFields, vfVersionId, "_abc");
1431         }
1432
1433         public ServiceData(IS_GENERATED_NAMING isGeneratedNaming, VnfData vnfData, VfData vfData, boolean isALaCarte) {
1434             this.isGeneratedNaming = isGeneratedNaming;
1435             this.vnfData = vnfData;
1436             this.vfData = vfData;
1437             this.isALaCarte = isALaCarte;
1438         }
1439
1440         String modelUuid;
1441         List<String> dynamicFields;
1442         IS_GENERATED_NAMING isGeneratedNaming;
1443         boolean multiStageDesign;
1444         VnfData vnfData;
1445         VfData vfData;
1446         boolean isALaCarte;
1447
1448         enum IS_GENERATED_NAMING { TRUE, FALSE, TRUE_BUT_GIVE_NAME_EITHER_WAY}
1449     }
1450
1451     private static class VnfData {
1452         VnfData(String vnfName, String vnfUuid, String vnfInstanceName, boolean isGeneratedNaming) {
1453             this.vnfName = vnfName;
1454             this.vnfUuid = vnfUuid;
1455             this.vnfInstanceName = vnfInstanceName;
1456             this.isGeneratedNaming = isGeneratedNaming;
1457         }
1458
1459         final String vnfName;
1460         final String vnfUuid;
1461         final String vnfInstanceName;
1462         final boolean isGeneratedNaming;
1463     }
1464
1465
1466     private static class VfData {
1467         VfData(String vfName, boolean vgEnabled, int vfMin, String vfMax, List<String> dynamicFields, String uuid, String vgName) {
1468             this.vfName = vfName;
1469             this.vgEnabled = vgEnabled;
1470             this.vfMin = vfMin;
1471             this.vfMax = vfMax;
1472             this.dynamicFields = dynamicFields;
1473             this.uuid = uuid;
1474             this.vgName = vgName;
1475         }
1476
1477         final int vfMin;
1478         final String vfMax;
1479         final String uuid;
1480         final String vfName;
1481         final boolean vgEnabled;
1482         final List<String> dynamicFields;
1483         final String vgName;
1484     }
1485
1486
1487 }