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