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