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