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

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