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

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