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

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