Pull request #199: Created test to add new version of AccessTokens,...

Pull request #199: Created test to add new version of AccessTokens, Certificates, DomainsPage, EditResourcePage, UsersPage, added necessary components for that

Merge in EDELIVERY/smp from EDELIVERY-14281-Automate-UI-tests-for-the-DomiSMP-project---Part1 to development

* commit '008f97d5':
  added tests for DomainsPage
  Created test to add new version of AccessTokens, Certificates, DomainsPage, EditResourcePage, UsersPage, added necessary components for that
  Created test to add new version of AccessTokens, Certificates, DomainsPage, EditResourcePage, UsersPage, added necessary components for that

domismp-tests/domismp-tests-ui/src/main/java/ddsl/dcomponents/SideNavigationComponent.java

@@ -22,6 +22,8 @@ import pages.systemSettings.domainsPage.DomainsPage;
 import pages.systemSettings.keyStorePage.KeystorePage;
 import pages.systemSettings.propertiesPage.PropertiesPage;
 import pages.userSettings.ProfilePage;
+import pages.userSettings.accessTokensPage.AccessTokensPage;
+import pages.userSettings.certificatesPage.accessTokensPage.CertificatesPage;
 
 import java.util.Objects;
 /**
@@ -168,14 +170,17 @@ public class SideNavigationComponent extends DomiSMPPage {
         if (page == Pages.USER_SETTINGS_PROFILE) {
             openSubmenu(userSettingsExpand, profileLnk);
             return (T) new ProfilePage(driver);
-//            case USER_SETTINGS_ACCESS_TOKEN:
-//                //expandSection(userSettingsExpand);
-//                //accessTokensLnk.click();
-//                return new ProfilePage(driver);
-//            case USER_SETTINGS_CERTIFICATES:
-//                expandSection(userSettingsExpand);
-//                return new DLink(driver, certificatesLnk);
+
+        }
+        if (page == Pages.USER_SETTINGS_ACCESS_TOKEN) {
+            openSubmenu(userSettingsExpand, accessTokensLnk);
+            return (T) new AccessTokensPage(driver);
         }
+        if (page == Pages.USER_SETTINGS_CERTIFICATES) {
+            openSubmenu(userSettingsExpand, certificatesLnk);
+            return (T) new CertificatesPage(driver);
+        }
+
         return null;
     }
 

domismp-tests/domismp-tests-ui/src/main/java/pages/administration/editResourcesPage/SubresourceTab.java

@@ -27,5 +27,9 @@ public class SubresourceTab extends SubcategoryTabComponent {
         return new EditSubresourceDocumentPage(driver);
     }
 
+    public void deleteSubresouceDocument(SubresourceModel subresourceModel) {
+        delete("Identifier", subresourceModel.getIdentifierValue());
+    }
+
 }
 

domismp-tests/domismp-tests-ui/src/main/java/pages/systemSettings/UsersPage.java

 package pages.systemSettings;
 
 import ddsl.CommonPageWithTabsAndGrid;
+import ddsl.dcomponents.ConfirmationDialog;
 import ddsl.dcomponents.Grid.SmallGrid;
 import ddsl.dcomponents.commonComponents.UserDataCommonComponent;
 import ddsl.dobjects.DButton;
@@ -21,7 +22,9 @@ public class UsersPage extends CommonPageWithTabsAndGrid {
     @FindBy(id = "role_id")
     private WebElement applicationRoleDdl;
     @FindBy(id = "active_id")
-    private WebElement isActive;
+    private WebElement isActiveCheckBox;
+    @FindBy(id = "saveButton")
+    private WebElement saveBtn;
 
 
     public UsersPage(WebDriver driver) {
@@ -39,6 +42,12 @@ public class UsersPage extends CommonPageWithTabsAndGrid {
         return new DButton(driver, addBtn);
     }
 
+    public String deleteAndConfirm() {
+        weToDButton(deleteBtn).click();
+        new ConfirmationDialog(driver).confirm();
+        return getAlertMessageAndClose();
+    }
+
     public String fillNewUserDataAndSave(UserModel newUserData) {
         LOG.debug("Filling user data...");
         try {
@@ -63,7 +72,7 @@ public class UsersPage extends CommonPageWithTabsAndGrid {
 
     public Boolean isSelectedUserActive() {
         try {
-            return weToDInput(isActive).getAttribute("class").contains("checked");
+            return weToDInput(isActiveCheckBox).getAttribute("class").contains("checked");
 
         } catch (Exception e) {
             throw new RuntimeException(e);
@@ -82,5 +91,30 @@ public class UsersPage extends CommonPageWithTabsAndGrid {
         return userData.getSelectedLocale();
     }
 
+    public void changeApplicationRole(String role) {
+        try {
+            weToDSelect(applicationRoleDdl).selectByVisibleText(role);
+            weToDButton(saveBtn).click();
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public String modifyIsActiveForUser(Boolean isActive) throws Exception {
+        if (isActive) {
+            weToDChecked(isActiveCheckBox).check();
+
+        } else {
+            weToDChecked(isActiveCheckBox).uncheck();
+
+        }
+        if (weToDButton(saveBtn).isEnabled()) ;
+        {
+            LOG.debug("Changing active value of access token to: [{}]", isActive);
+
+            weToDButton(saveBtn).click();
+            return getAlertArea().getAlertMessage();
+        }
+    }
 
 }

domismp-tests/domismp-tests-ui/src/main/java/pages/systemSettings/domainsPage/DomainsPage.java

 package pages.systemSettings.domainsPage;
 
 import ddsl.CommonPageWithTabsAndGrid;
+import ddsl.dcomponents.ConfirmationDialog;
 import ddsl.dcomponents.Grid.SmallGrid;
 import ddsl.dobjects.DButton;
 import org.openqa.selenium.WebDriver;
@@ -57,5 +58,13 @@ public class DomainsPage extends CommonPageWithTabsAndGrid {
         return warningLabel.getText();
     }
 
+    public void deleteandConfirm() {
+        weToDButton(deleteBtn).click();
+        ConfirmationDialog confirmationDialog = new ConfirmationDialog(driver);
+        confirmationDialog.confirm();
+    }
 
+    public DButton getDeleteBtn() {
+        return weToDButton(deleteBtn);
+    }
 }

domismp-tests/domismp-tests-ui/src/main/java/pages/systemSettings/domainsPage/SMLIntegrationTab.java

@@ -33,6 +33,8 @@ public class SMLIntegrationTab extends DComponent {
 
     @FindBy(id = "registerButton")
     private WebElement registerBtn;
+    @FindBy(id = "unregisterButton")
+    private WebElement unregisterBtn;
 
     public SMLIntegrationTab(WebDriver driver) {
         super(driver);
@@ -90,4 +92,19 @@ public class SMLIntegrationTab extends DComponent {
 
     }
 
+    public void unregisterToSML() throws Exception {
+        try {
+            if (weToDButton(unregisterBtn).isEnabled()) {
+                weToDButton(unregisterBtn).click();
+                ConfirmationDialog confirmationDialog = new ConfirmationDialog(driver);
+                confirmationDialog.confirm();
+            }
+
+        } catch (Exception e) {
+            LOG.error("Unregister button is not enabled");
+            throw new Exception(e);
+        }
+
+    }
+
 }

domismp-tests/domismp-tests-ui/src/main/java/pages/userSettings/accessTokensPage/AccessTokensPage.java

+package pages.userSettings.accessTokensPage;
+
+import ddsl.DomiSMPPage;
+import ddsl.dcomponents.ConfirmationDialog;
+import ddsl.dcomponents.Grid.GridPagination;
+import org.openqa.selenium.By;
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.WebElement;
+import org.openqa.selenium.support.FindBy;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.NoSuchElementException;
+
+public class AccessTokensPage extends DomiSMPPage {
+    protected static final By nameLocator = By.cssSelector("input:first-of-type");
+    protected static final By deleteBtnLocator = By.id("deleteButton");
+    protected static final By saveBtnLocator = By.id("saveButton");
+    protected static final By descriptionLocator = By.cssSelector("input[formcontrolname=\"description\"]");
+    protected static final By isActiveLocator = By.cssSelector("mat-checkbox");
+    protected static final By startDateLocator = By.cssSelector("input[formcontrolname=\"activeFrom\"");
+    protected static final By endDateLocator = By.cssSelector("input[formcontrolname=\"expireOn\"]");
+    protected static final By sequenceFailedAttempsLocator = By.id("sequentialTokenLoginFailureCount_id");
+    protected static final By lastFailedAttemptLocator = By.id("LastFailedAttempt_id");
+    protected static final By suspendedUtilLocator = By.id("SuspendedUtil_id");
+    protected static final By pagination = By.id("tokens-paginator");
+    private final static Logger LOG = LoggerFactory.getLogger(AccessTokensPage.class);
+    GridPagination gridPagination = new GridPagination(driver, driver.findElement(pagination));
+    @FindBy(id = "createAccessTokenButton")
+    private WebElement createBtn;
+    @FindBy(css = "td access-token-panel")
+    private List<WebElement> accessTokens;
+
+    public AccessTokensPage(WebDriver driver) {
+        super(driver);
+        LOG.debug("Access Tokens page has loaded");
+
+    }
+
+    public CreateNewAccessTokenDialog clickCreateAccessTokenBtn() {
+        weToDButton(createBtn).click();
+        return new CreateNewAccessTokenDialog(driver);
+    }
+
+    private WebElement getAccessToken(String accessTokenName) {
+        for (int i = 0; i <= gridPagination.getTotalPageNumber(); i++) {
+            for (WebElement accessToken : accessTokens) {
+                String currentElementName = weToDInput(accessToken.findElement(nameLocator)).getText();
+                if (currentElementName.equals(accessTokenName)) {
+                    LOG.debug("Access Token [{}] has been found on page  [{}].", accessTokenName, i);
+
+                    return accessToken;
+                }
+
+            }
+            gridPagination.goToNextPage();
+        }
+        throw new NoSuchElementException();
+    }
+
+    public Boolean isAccessTokenPresent(String accessTokenName) {
+        WebElement accessToken = getAccessToken(accessTokenName);
+
+
+        return accessToken != null;
+    }
+
+    public HashMap<String, String> getAccessTokenInfo(String accessTokenName) throws Exception {
+        HashMap<String, String> accessTokenInfo = new HashMap<>();
+        WebElement accessToken = getAccessToken(accessTokenName);
+
+        accessToken.findElement(By.cssSelector("mat-expansion-panel")).click();
+
+        accessTokenInfo.put("Description", weToDInput(accessToken.findElement(descriptionLocator)).getText());
+        accessTokenInfo.put("Active", String.valueOf(weToDChecked(accessToken.findElement(isActiveLocator)).isChecked()));
+        accessTokenInfo.put("StartDate", weToDInput(accessToken.findElement(startDateLocator)).getText());
+        accessTokenInfo.put("EndDate", weToDInput(accessToken.findElement(endDateLocator)).getText());
+        accessTokenInfo.put("SequenceFailedAttempts", weToDInput(accessToken.findElement(sequenceFailedAttempsLocator)).getText());
+        accessTokenInfo.put("LastFailedAttempts", weToDInput(accessToken.findElement(lastFailedAttemptLocator)).getText());
+        accessTokenInfo.put("SuspendedUntil", weToDInput(accessToken.findElement(suspendedUtilLocator)).getText());
+        return accessTokenInfo;
+
+    }
+
+    public String deleteAccessToken(String accessTokenName) {
+
+        WebElement accessToken = getAccessToken(accessTokenName);
+
+        accessToken.findElement(By.cssSelector("mat-expansion-panel")).click();
+        weToDButton(accessToken.findElement(deleteBtnLocator)).click();
+        new ConfirmationDialog(driver).confirm();
+        return getAlertArea().getAlertMessage();
+    }
+
+    public String modifyIsActiveForAccessToken(String accessTokenName, boolean isActive) throws Exception {
+
+        WebElement accessToken = getAccessToken(accessTokenName);
+
+        accessToken.findElement(By.cssSelector("mat-expansion-panel")).click();
+        if (isActive) {
+            weToDChecked(accessToken.findElement(isActiveLocator)).check();
+
+        } else {
+            weToDChecked(accessToken.findElement(isActiveLocator)).uncheck();
+
+        }
+        if (weToDButton(accessToken.findElement(saveBtnLocator)).isEnabled()) ;
+        {
+            LOG.debug("Changing active value of access token to: [{}]", isActive);
+
+            weToDButton(accessToken.findElement(saveBtnLocator)).click();
+            new ConfirmationDialog(driver).confirm();
+            return getAlertArea().getAlertMessage();
+        }
+    }
+
+}

domismp-tests/domismp-tests-ui/src/main/java/pages/userSettings/accessTokensPage/CreateNewAccessTokenDialog.java

+package pages.userSettings.accessTokensPage;
+
+import ddsl.dcomponents.DComponent;
+import ddsl.dobjects.DButton;
+import ddsl.dobjects.DInput;
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.WebElement;
+import org.openqa.selenium.support.FindBy;
+import org.openqa.selenium.support.PageFactory;
+import org.openqa.selenium.support.pagefactory.AjaxElementLocatorFactory;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class CreateNewAccessTokenDialog extends DComponent {
+    @FindBy(css = "mat-dialog-content mat-form-field input[formcontrolname=\"description\"]")
+    private WebElement descriptionInput;
+    @FindBy(css = "mat-dialog-content mat-form-field input[placeholder=\"Start date\"]")
+    private WebElement startDateInput;
+    @FindBy(css = "mat-dialog-content mat-form-field input[placeholder=\"End date\"]")
+    private WebElement enddateInput;
+    @FindBy(css = "mat-dialog-content mat-checkbox")
+    private WebElement activeCheckbox;
+    @FindBy(id = "generatedAccessTokenButton")
+    private WebElement generateTokenBtn;
+    @FindBy(id = "alertmessage_id")
+    private WebElement accesstokenGeneratedMessage;
+    @FindBy(id = "closeDialogButton")
+    private WebElement closeBtn;
+
+
+    public CreateNewAccessTokenDialog(WebDriver driver) {
+
+        super(driver);
+        PageFactory.initElements(new AjaxElementLocatorFactory(driver, data.getWaitTimeShort()), this);
+
+    }
+
+    public DInput getDescriptionInput() {
+        return new DInput(driver, descriptionInput);
+    }
+
+    public DInput getStartDateInput() {
+        return new DInput(driver, startDateInput);
+    }
+
+    public DInput getEndDateInput() {
+        return new DInput(driver, enddateInput);
+    }
+
+    public DButton getCreateNewTokenBtn() {
+        return new DButton(driver, generateTokenBtn);
+    }
+
+    public String getTokenIdAndCloseDialog() {
+        String message = accesstokenGeneratedMessage.getText();
+        String pattern = "ID: \"([^\"]+)\"";
+        Pattern regex = Pattern.compile(pattern);
+        Matcher matcher = regex.matcher(message);
+        if (matcher.find()) {
+            String tokenId = matcher.group(1);
+            if (!tokenId.isEmpty()) {
+                weToDButton(closeBtn).click();
+                return tokenId;
+            }
+        }
+
+        return null;
+    }
+
+
+}

domismp-tests/domismp-tests-ui/src/main/java/pages/userSettings/certificatesPage/accessTokensPage/CertificateDetailsDialog.java

+package pages.userSettings.certificatesPage.accessTokensPage;
+
+import ddsl.dcomponents.DComponent;
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.WebElement;
+import org.openqa.selenium.support.FindBy;
+import org.openqa.selenium.support.PageFactory;
+import org.openqa.selenium.support.pagefactory.AjaxElementLocatorFactory;
+
+import java.util.HashMap;
+
+public class CertificateDetailsDialog extends DComponent {
+    @FindBy(id = "certificateId_id")
+    private WebElement smpCertificateId;
+    @FindBy(id = "subject_id")
+    private WebElement subjectName;
+    @FindBy(css = "keystore-certificate-dialog input[placeholder=\"Valid from date\"]")
+    private WebElement validFrom;
+    @FindBy(css = "mat-dialog-content mat-form-field input[placeholder=\"Valid to date\"]")
+    private WebElement validTo;
+    @FindBy(id = "issuer_id")
+    private WebElement issuerName;
+    @FindBy(id = "servialNumber_id")
+    private WebElement serialNumber;
+    @FindBy(id = "closeDialogButton")
+    private WebElement closeBtn;
+
+
+    public CertificateDetailsDialog(WebDriver driver) {
+        super(driver);
+        PageFactory.initElements(new AjaxElementLocatorFactory(driver, data.getWaitTimeShort()), this);
+    }
+
+    public HashMap<String, String> getCertificateDetails() {
+        HashMap<String, String> certificateDetailsInfo = new HashMap<>();
+        certificateDetailsInfo.put("SmpCertificateId", weToDInput(smpCertificateId).getText());
+        certificateDetailsInfo.put("SubjectName", weToDInput(subjectName).getText());
+        certificateDetailsInfo.put("ValidFromDate", weToDInput(validFrom).getText());
+        certificateDetailsInfo.put("ValidToDate", weToDInput(validTo).getText());
+        certificateDetailsInfo.put("Issuer", weToDInput(issuerName).getText());
+        certificateDetailsInfo.put("SerialNumber", weToDInput(serialNumber).getText());
+        return certificateDetailsInfo;
+    }
+
+}

domismp-tests/domismp-tests-ui/src/main/java/pages/userSettings/certificatesPage/accessTokensPage/CertificatesPage.java

+package pages.userSettings.certificatesPage.accessTokensPage;
+
+import ddsl.DomiSMPPage;
+import ddsl.dcomponents.ConfirmationDialog;
+import ddsl.dcomponents.Grid.GridPagination;
+import org.openqa.selenium.By;
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.WebElement;
+import org.openqa.selenium.support.FindBy;
+import org.openqa.selenium.support.PageFactory;
+import org.openqa.selenium.support.pagefactory.AjaxElementLocatorFactory;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.HashMap;
+import java.util.List;
+
+public class CertificatesPage extends DomiSMPPage {
+    protected static final By nameLocator = By.cssSelector("input:first-of-type");
+    protected static final By deleteBtnLocator = By.id("deleteButton");
+    protected static final By showDetailsBtnLocator = By.id("showButton");
+    protected static final By descriptionLocator = By.cssSelector("input[formcontrolname=\"description\"]");
+    protected static final By isActiveLocator = By.cssSelector("mat-checkbox");
+    protected static final By startDateLocator = By.cssSelector("input[formcontrolname=\"activeFrom\"");
+    protected static final By endDateLocator = By.cssSelector("input[formcontrolname=\"expireOn\"]");
+    protected static final By pagination = By.id("tokens-paginator");
+    private final static Logger LOG = LoggerFactory.getLogger(CertificatesPage.class);
+    GridPagination gridPagination = new GridPagination(driver, driver.findElement(pagination));
+    @FindBy(id = "importNewCertificateButton")
+    private WebElement importBtn;
+    @FindBy(css = "td user-certificate-panel")
+    private List<WebElement> certificateList;
+
+    public CertificatesPage(WebDriver driver) {
+        super(driver);
+        LOG.debug("Certificate page has loaded");
+        PageFactory.initElements(new AjaxElementLocatorFactory(driver, data.getWaitTimeShort()), this);
+
+    }
+
+    public ImportNewCertificatesDialog clickOnImportNewCertificate() {
+        weToDButton(importBtn).click();
+        return new ImportNewCertificatesDialog(driver);
+    }
+
+    private WebElement getCertificate(String certificateName) {
+        for (int i = 0; i <= gridPagination.getTotalPageNumber(); i++) {
+            for (WebElement accessToken : certificateList) {
+                String currentElementName = weToDInput(accessToken.findElement(nameLocator)).getText();
+                if (currentElementName.equals(certificateName)) {
+                    LOG.debug("Certificate [{}] has been found on page  [{}].", certificateName, i);
+
+                    return accessToken;
+                }
+
+            }
+            gridPagination.goToNextPage();
+        }
+        return null;
+    }
+
+    public Boolean isCertificatePresent(String certificateId) {
+        WebElement certificate = getCertificate(certificateId);
+
+
+        return certificate != null;
+    }
+
+    public HashMap<String, String> getCertificateInfo(String certificateId) throws Exception {
+        HashMap<String, String> certificateIdInfo = new HashMap<>();
+        WebElement accessToken = getCertificate(certificateId);
+
+        accessToken.findElement(By.cssSelector("mat-expansion-panel")).click();
+
+        certificateIdInfo.put("Description", weToDInput(accessToken.findElement(descriptionLocator)).getText());
+        certificateIdInfo.put("Active", String.valueOf(weToDChecked(accessToken.findElement(isActiveLocator)).isChecked()));
+        certificateIdInfo.put("StartDate", weToDInput(accessToken.findElement(startDateLocator)).getText());
+        certificateIdInfo.put("EndDate", weToDInput(accessToken.findElement(endDateLocator)).getText());
+        return certificateIdInfo;
+
+    }
+
+    public HashMap<String, String> getCertificateDetailsInfo(String certificateId) {
+        WebElement accessToken = getCertificate(certificateId);
+        accessToken.findElement(By.cssSelector("mat-expansion-panel")).click();
+        accessToken.findElement(showDetailsBtnLocator).click();
+        return new CertificateDetailsDialog(driver).getCertificateDetails();
+    }
+
+
+    public String deleteCertificate(String certificateId) {
+
+        WebElement certificate = getCertificate(certificateId);
+
+        certificate.findElement(By.cssSelector("mat-expansion-panel")).click();
+        weToDButton(certificate.findElement(deleteBtnLocator)).click();
+        new ConfirmationDialog(driver).confirm();
+        return getAlertArea().getAlertMessage();
+    }
+
+}

domismp-tests/domismp-tests-ui/src/main/java/pages/userSettings/certificatesPage/accessTokensPage/ImportNewCertificatesDialog.java

+package pages.userSettings.certificatesPage.accessTokensPage;
+
+import ddsl.dcomponents.DComponent;
+import ddsl.dobjects.DButton;
+import ddsl.dobjects.DInput;
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.WebElement;
+import org.openqa.selenium.support.FindBy;
+import org.openqa.selenium.support.PageFactory;
+import org.openqa.selenium.support.pagefactory.AjaxElementLocatorFactory;
+
+public class ImportNewCertificatesDialog extends DComponent {
+    @FindBy(css = "mat-dialog-content mat-form-field input[formcontrolname=\"description\"]")
+    private WebElement descriptionInput;
+    @FindBy(css = "mat-dialog-content mat-form-field input[placeholder=\"Start date\"]")
+    private WebElement startDateInput;
+    @FindBy(css = "mat-dialog-content mat-form-field input[placeholder=\"End date\"]")
+    private WebElement enddateInput;
+    @FindBy(css = "mat-dialog-content mat-checkbox")
+    private WebElement activeCheckbox;
+    @FindBy(id = "custom-file-upload")
+    private WebElement importBtn;
+    @FindBy(css = "mat-dialog-content mat-form-field input[formcontrolname=\"certificateId\"]")
+    private WebElement smpCertificateId;
+    @FindBy(css = "mat-dialog-content mat-form-field input[formcontrolname=\"subject\"]")
+    private WebElement subjectName;
+    @FindBy(css = "mat-dialog-content mat-form-field input[formcontrolname=\"validFrom\"]")
+    private WebElement validFrom;
+    @FindBy(css = "mat-dialog-content mat-form-field input[formcontrolname=\"validTo\"]")
+    private WebElement validTo;
+    @FindBy(css = "mat-dialog-content mat-form-field input[formcontrolname=\"issuer\"]")
+    private WebElement issuerName;
+    @FindBy(css = "mat-dialog-content mat-form-field input[formcontrolname=\"serialNumber\"]")
+    private WebElement serialNumber;
+    @FindBy(id = "storeCertificateCredentialsButton")
+    private WebElement saveCertificateBtn;
+    @FindBy(id = "closeDialogButton")
+    private WebElement closeBtn;
+    @FindBy(css = "mat-dialog-content div[id=\"alertmessage_id\"]")
+    private WebElement alertMessage;
+
+
+    public ImportNewCertificatesDialog(WebDriver driver) {
+
+        super(driver);
+        PageFactory.initElements(new AjaxElementLocatorFactory(driver, data.getWaitTimeShort()), this);
+
+    }
+
+    public DInput getDescriptionInput() {
+        return new DInput(driver, descriptionInput);
+    }
+
+    public void importCertificate(String filePath) {
+        importBtn.sendKeys(filePath);
+    }
+
+    public DButton getSaveCertificateBtn() {
+        return new DButton(driver, saveCertificateBtn);
+    }
+
+    public String getAlertMessage() {
+        return alertMessage.getText();
+    }
+}

domismp-tests/domismp-tests-ui/src/main/java/utils/Utils.java

@@ -2,6 +2,9 @@ package utils;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
 import java.util.Random;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -29,4 +32,11 @@ public class Utils {
         LOG.error("No alias found in the message: "+message);
         throw new NullPointerException("No alias found in the message: "+message);
     }
+
+    public static String getCurrentDate(String pattern) {
+        SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);
+        Date currentDate = new Date();
+        return dateFormat.format(currentDate);
+
+    }
 }

domismp-tests/domismp-tests-ui/src/test/java/domiSMPTests/ui/AccessTokensPgTests.java

+package domiSMPTests.ui;
+
+import ddsl.DomiSMPPage;
+import ddsl.enums.Pages;
+import domiSMPTests.SeleniumTest;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+import org.testng.asserts.SoftAssert;
+import pages.LoginPage;
+import pages.userSettings.accessTokensPage.AccessTokensPage;
+import pages.userSettings.accessTokensPage.CreateNewAccessTokenDialog;
+import rest.models.UserModel;
+import utils.Generator;
+import utils.Utils;
+
+import java.util.HashMap;
+
+
+public class AccessTokensPgTests extends SeleniumTest {
+
+    SoftAssert soft;
+    DomiSMPPage homePage;
+    LoginPage loginPage;
+    AccessTokensPage accessTokensPage;
+    UserModel normalUser;
+
+    @BeforeMethod(alwaysRun = true)
+    public void beforeTest() throws Exception {
+        soft = new SoftAssert();
+        homePage = new DomiSMPPage(driver);
+        loginPage = homePage.goToLoginPage();
+        loginPage.login(data.getAdminUser().get("username"), data.getAdminUser().get("password"));
+        accessTokensPage = homePage.getSidebar().navigateTo(Pages.USER_SETTINGS_ACCESS_TOKEN);
+
+        normalUser = UserModel.generateUserWithUSERrole();
+        rest.users().createUser(normalUser);
+
+    }
+
+    @Test(description = "ACCTOK-01 User is able to create valid Access Token")
+    public void userIsAbleToCreateValidAccessToken() throws Exception {
+        String currentDate = Utils.getCurrentDate("MM/dd/yyyy");
+        String description = Generator.randomAlphaNumericValue(10);
+        //Create new token
+        CreateNewAccessTokenDialog createNewAccessTokenDialog = accessTokensPage.clickCreateAccessTokenBtn();
+        createNewAccessTokenDialog.getDescriptionInput().fill(description);
+        createNewAccessTokenDialog.getStartDateInput().fill(currentDate);
+        createNewAccessTokenDialog.getEndDateInput().fill(currentDate);
+        createNewAccessTokenDialog.getCreateNewTokenBtn().click();
+        String tokenID = createNewAccessTokenDialog.getTokenIdAndCloseDialog();
+
+
+        soft.assertTrue(accessTokensPage.isAccessTokenPresent(tokenID), "Access Token ID is not correct");
+        HashMap<String, String> accessTokenInfo = accessTokensPage.getAccessTokenInfo(tokenID);
+        soft.assertEquals(accessTokenInfo.get("Description"), description, "Access Token description is not correct");
+        soft.assertEquals(accessTokenInfo.get("Active"), "true", "Access Token active status is not correct");
+        soft.assertEquals(accessTokenInfo.get("StartDate"), currentDate, "Access Token start date is not correct");
+        soft.assertEquals(accessTokenInfo.get("EndDate"), currentDate, "Access Token end date is not correct");
+        soft.assertEquals(accessTokenInfo.get("SequenceFailedAttempts"), "0", "Access Token SequenceFailedAttempts is not correct");
+        soft.assertEquals(accessTokenInfo.get("LastFailedAttempts"), "---", "Access Token LastFailedAttempts is not correct");
+        soft.assertEquals(accessTokenInfo.get("SuspendedUntil"), "---", "Access Token SuspendedUntil is not correct");
+
+        //Check if user role can create access tokens
+        accessTokensPage.logout();
+        loginPage.login(normalUser.getUsername(), data.getNewPassword());
+        accessTokensPage = homePage.getSidebar().navigateTo(Pages.USER_SETTINGS_ACCESS_TOKEN);
+        description = Generator.randomAlphaNumericValue(10);
+        //Create new token
+        createNewAccessTokenDialog = accessTokensPage.clickCreateAccessTokenBtn();
+        createNewAccessTokenDialog.getDescriptionInput().fill(description);
+        createNewAccessTokenDialog.getStartDateInput().fill(currentDate);
+        createNewAccessTokenDialog.getEndDateInput().fill(currentDate);
+        createNewAccessTokenDialog.getCreateNewTokenBtn().click();
+        tokenID = createNewAccessTokenDialog.getTokenIdAndCloseDialog();
+
+
+        soft.assertTrue(accessTokensPage.isAccessTokenPresent(tokenID), "Access Token ID is not correct");
+        accessTokenInfo = accessTokensPage.getAccessTokenInfo(tokenID);
+        soft.assertEquals(accessTokenInfo.get("Description"), description, "Access Token description is not correct");
+        soft.assertEquals(accessTokenInfo.get("Active"), "true", "Access Token active status is not correct");
+        soft.assertEquals(accessTokenInfo.get("StartDate"), currentDate, "Access Token start date is not correct");
+        soft.assertEquals(accessTokenInfo.get("EndDate"), currentDate, "Access Token end date is not correct");
+        soft.assertEquals(accessTokenInfo.get("SequenceFailedAttempts"), "0", "Access Token SequenceFailedAttempts is not correct");
+        soft.assertEquals(accessTokenInfo.get("LastFailedAttempts"), "---", "Access Token LastFailedAttempts is not correct");
+        soft.assertEquals(accessTokenInfo.get("SuspendedUntil"), "---", "Access Token SuspendedUntil is not correct");
+
+
+        soft.assertAll();
+    }
+
+    @Test(description = "ACCTOK-04 User is able to Delete access token")
+    public void userIsAbleToDeleteAccessToken() {
+        String currentDate = Utils.getCurrentDate("MM/dd/yyyy");
+        String description = Generator.randomAlphaNumericValue(10);
+        //Create new token
+        CreateNewAccessTokenDialog createNewAccessTokenDialog = accessTokensPage.clickCreateAccessTokenBtn();
+        createNewAccessTokenDialog.getDescriptionInput().fill(description);
+        createNewAccessTokenDialog.getStartDateInput().fill(currentDate);
+        createNewAccessTokenDialog.getEndDateInput().fill(currentDate);
+        createNewAccessTokenDialog.getCreateNewTokenBtn().click();
+        String tokenID = createNewAccessTokenDialog.getTokenIdAndCloseDialog();
+        String alertMessage = accessTokensPage.deleteAccessToken(tokenID);
+
+        soft.assertEquals(alertMessage, "Access token \"" + tokenID + "\" has been deleted!", "Access Token ID is not correct");
+        soft.assertTrue(accessTokensPage.isAccessTokenPresent(tokenID));
+        soft.assertAll();
+    }
+
+    @Test(description = "ACCTOK-04 User is able to activate/inactivate existing access token")
+    public void userIsAbleToActivateDeactivateExistingAccessToken() throws Exception {
+        String currentDate = Utils.getCurrentDate("MM/dd/yyyy");
+        String description = Generator.randomAlphaNumericValue(10);
+        //Create new token
+        CreateNewAccessTokenDialog createNewAccessTokenDialog = accessTokensPage.clickCreateAccessTokenBtn();
+        createNewAccessTokenDialog.getDescriptionInput().fill(description);
+        createNewAccessTokenDialog.getStartDateInput().fill(currentDate);
+        createNewAccessTokenDialog.getEndDateInput().fill(currentDate);
+        createNewAccessTokenDialog.getCreateNewTokenBtn().click();
+
+        String tokenID = createNewAccessTokenDialog.getTokenIdAndCloseDialog();
+        String alertMessage = accessTokensPage.modifyIsActiveForAccessToken(tokenID, false);
+        //Set accesss token to inactive
+        soft.assertEquals(alertMessage, "Access token \"" + tokenID + "\" has been updated!", "Access Token ID is not correct");
+        HashMap<String, String> accessTokenInfo = accessTokensPage.getAccessTokenInfo(tokenID);
+        soft.assertEquals(accessTokenInfo.get("Active"), "false", "Access Token active status is not correct");
+
+        //Set accesss token to active
+
+        accessTokensPage.modifyIsActiveForAccessToken(tokenID, true);
+        accessTokenInfo = accessTokensPage.getAccessTokenInfo(tokenID);
+        soft.assertEquals(accessTokenInfo.get("Active"), "true", "Access Token active status is not correct");
+
+        //Check if user role can create inactivate tokens
+
+        accessTokensPage.logout();
+        loginPage.login(normalUser.getUsername(), data.getNewPassword());
+        accessTokensPage = homePage.getSidebar().navigateTo(Pages.USER_SETTINGS_ACCESS_TOKEN);
+
+        description = Generator.randomAlphaNumericValue(10);
+        //Create new token
+        createNewAccessTokenDialog = accessTokensPage.clickCreateAccessTokenBtn();
+        createNewAccessTokenDialog.getDescriptionInput().fill(description);
+        createNewAccessTokenDialog.getStartDateInput().fill(currentDate);
+        createNewAccessTokenDialog.getEndDateInput().fill(currentDate);
+        createNewAccessTokenDialog.getCreateNewTokenBtn().click();
+
+        tokenID = createNewAccessTokenDialog.getTokenIdAndCloseDialog();
+        alertMessage = accessTokensPage.modifyIsActiveForAccessToken(tokenID, false);
+        //Set accesss token to inactive
+        soft.assertEquals(alertMessage, "Access token \"" + tokenID + "\" has been updated!", "Access Token ID is not correct");
+        accessTokenInfo = accessTokensPage.getAccessTokenInfo(tokenID);
+        soft.assertEquals(accessTokenInfo.get("Active"), "false", "Access Token active status is not correct");
+
+        soft.assertAll();
+    }
+
+}

domismp-tests/domismp-tests-ui/src/test/java/domiSMPTests/ui/CertificatesPgTests.java

+package domiSMPTests.ui;
+
+import ddsl.DomiSMPPage;
+import ddsl.enums.Pages;
+import domiSMPTests.SeleniumTest;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+import org.testng.asserts.SoftAssert;
+import pages.LoginPage;
+import pages.userSettings.certificatesPage.accessTokensPage.CertificatesPage;
+import pages.userSettings.certificatesPage.accessTokensPage.ImportNewCertificatesDialog;
+import rest.models.UserModel;
+import utils.FileUtils;
+import utils.Generator;
+
+import java.util.HashMap;
+
+
+public class CertificatesPgTests extends SeleniumTest {
+
+    SoftAssert soft;
+    DomiSMPPage homePage;
+    LoginPage loginPage;
+    CertificatesPage certificatePage;
+    UserModel normalUser;
+
+    @BeforeMethod(alwaysRun = true)
+    public void beforeTest() throws Exception {
+        soft = new SoftAssert();
+        homePage = new DomiSMPPage(driver);
+        loginPage = homePage.goToLoginPage();
+        loginPage.login(data.getAdminUser().get("username"), data.getAdminUser().get("password"));
+        certificatePage = homePage.getSidebar().navigateTo(Pages.USER_SETTINGS_CERTIFICATES);
+
+        normalUser = UserModel.generateUserWithUSERrole();
+        rest.users().createUser(normalUser);
+
+    }
+
+    @Test(description = "CERT-01 Users are able to import valid certificate")
+    public void usersAreAbleToImportValidCertificate() throws Exception {
+        String description = Generator.randomAlphaNumericValue(10);
+        String path = FileUtils.getAbsoluteTruststorePath("validCertificate.cer");
+        String certificateId = "CN=red_gw,O=eDelivery,C=BE:00000000110fa0d8";
+        //Delete certificate if exists
+        try {
+            certificatePage.deleteCertificate(certificateId);
+        } catch (Exception ignored) {
+
+        }
+        //Import new certificate
+        ImportNewCertificatesDialog importNewCertificatesDialog = certificatePage.clickOnImportNewCertificate();
+        importNewCertificatesDialog.getDescriptionInput().fill(description);
+
+        importNewCertificatesDialog.importCertificate(path);
+        importNewCertificatesDialog.getSaveCertificateBtn().click();
+        soft.assertTrue(certificatePage.isCertificatePresent(certificateId));
+
+        HashMap<String, String> certificateInfo = certificatePage.getCertificateInfo(certificateId);
+        soft.assertEquals(certificateInfo.get("Description"), description, "Access Token description is not correct");
+        soft.assertEquals(certificateInfo.get("Active"), "true", "Access Token active status is not correct");
+        soft.assertEquals(certificateInfo.get("StartDate"), "3/23/2023", "Access Token start date is not correct");
+        soft.assertEquals(certificateInfo.get("EndDate"), "3/22/2033", "Access Token end date is not correct");
+        //Validate certificate details
+        HashMap<String, String> certificateIDetailsnfo = certificatePage.getCertificateDetailsInfo(certificateId);
+        soft.assertEquals(certificateIDetailsnfo.get("SmpCertificateId"), "CN=red_gw,O=eDelivery,C=BE:00000000110fa0d8", "Certificate id is not correct");
+        soft.assertEquals(certificateIDetailsnfo.get("SubjectName"), "C=BE,O=eDelivery,CN=red_gw", "Certificate subject is not correct");
+        soft.assertTrue(certificateIDetailsnfo.get("ValidFromDate").startsWith("3/23/23"), "Certificate start date is not correct");
+        soft.assertTrue(certificateIDetailsnfo.get("ValidToDate").startsWith("3/22/33"), "Certificate end date is not correct");
+        soft.assertEquals(certificateIDetailsnfo.get("Issuer"), "C=BE,O=eDelivery,CN=red_gw", "Certificate issuer is not correct");
+        soft.assertEquals(certificateIDetailsnfo.get("SerialNumber"), "110fa0d8", "Certificate serial number is not correct");
+        soft.assertAll();
+    }
+
+    @Test(description = "CERT-03 User is not able to add duplicated certificate")
+    public void userIsNotAbleToAddDuplicatedCertificate() {
+
+        String description = Generator.randomAlphaNumericValue(10);
+        String path = FileUtils.getAbsoluteTruststorePath("validCertificate.cer");
+        String certificateId = "CN=red_gw,O=eDelivery,C=BE:00000000110fa0d8";
+        //Delete certificate if exists
+        try {
+            certificatePage.deleteCertificate(certificateId);
+        } catch (Exception ignored) {
+
+        }
+        //Import new certificate
+        ImportNewCertificatesDialog importNewCertificatesDialog = certificatePage.clickOnImportNewCertificate();
+        importNewCertificatesDialog.getDescriptionInput().fill(description);
+
+        importNewCertificatesDialog.importCertificate(path);
+        importNewCertificatesDialog.getSaveCertificateBtn().click();
+        soft.assertTrue(certificatePage.isCertificatePresent(certificateId));
+
+        //Try to import duplicated certificate
+        //Import new certificate
+        importNewCertificatesDialog = certificatePage.clickOnImportNewCertificate();
+        importNewCertificatesDialog.getDescriptionInput().fill(description);
+
+        importNewCertificatesDialog.importCertificate(path);
+        soft.assertEquals(importNewCertificatesDialog.getAlertMessage(), "Certificate with the same Subject is already registered!");
+        soft.assertFalse(importNewCertificatesDialog.getSaveCertificateBtn().isEnabled());
+
+        soft.assertAll();
+    }
+
+    @Test(description = "CERT-04 User is able to delete certificate")
+    public void userIsAbleToDeleteCertificate() {
+
+        String description = Generator.randomAlphaNumericValue(10);
+        String path = FileUtils.getAbsoluteTruststorePath("validCertificate.cer");
+        String certificateId = "CN=red_gw,O=eDelivery,C=BE:00000000110fa0d8";
+        //Delete certificate if exists
+        try {
+            certificatePage.deleteCertificate(certificateId);
+        } catch (Exception ignored) {
+
+        }
+        //Import new certificate
+        ImportNewCertificatesDialog importNewCertificatesDialog = certificatePage.clickOnImportNewCertificate();
+        importNewCertificatesDialog.getDescriptionInput().fill(description);
+
+        importNewCertificatesDialog.importCertificate(path);
+        importNewCertificatesDialog.getSaveCertificateBtn().click();
+        soft.assertTrue(certificatePage.isCertificatePresent(certificateId));
+        String deleteAlert = certificatePage.deleteCertificate(certificateId);
+        soft.assertEquals(deleteAlert, "Certificate \"" + certificateId + "\" has been deleted!", "Certificate has not been deleted");
+        soft.assertFalse(certificatePage.isCertificatePresent(certificateId));
+
+        soft.assertAll();
+    }
+
+
+}

domismp-tests/domismp-tests-ui/src/test/java/domiSMPTests/ui/DomainsPgTests.java

 package domiSMPTests.ui;
 
+import com.fasterxml.jackson.core.JsonProcessingException;
 import ddsl.DomiSMPPage;
 import ddsl.dcomponents.commonComponents.domanPropertyEditDialog.DomainPropertyEditDialog;
 import ddsl.enums.Pages;
@@ -14,9 +15,7 @@ import pages.LoginPage;
 import pages.SmlPage;
 import pages.administration.editDomainsPage.EditDomainsPage;
 import pages.systemSettings.domainsPage.DomainsPage;
-import rest.models.DomainModel;
-import rest.models.MemberModel;
-import rest.models.UserModel;
+import rest.models.*;
 import utils.TestRunData;
 
 import java.util.Arrays;
@@ -25,10 +24,7 @@ import java.util.List;
 /**
  * This class has the tests against Domains Page
  */
-//@Ignore("DomainsPgTests:beforeTest Failing tests: org.openqa.selenium.ElementClickInterceptedException: Element <select id=\"signatureKeyAlias_id\" " +
-//        "class=\"mat-mdc-input-element mat-mdc-tooltip-trigger ng-tns-c1205077789-11 ng-untouched ng-pristine ng-valid " +
-//        "mat-mdc-form-field-input-control mdc-text-field__input cdk-text-field-autofill-monitored cdk-focused cdk-program-focused\"> " +
-//        "is not clickable at point (1014,364) because another element <mat-label class=\"ng-tns-c1205077789-11\"> obscures it" )
+
 public class DomainsPgTests extends SeleniumTest {
     DomiSMPPage homePage;
     LoginPage loginPage;
@@ -180,6 +176,107 @@ public class DomainsPgTests extends SeleniumTest {
         soft.assertAll();
     }
 
+    @Test(description = "DOM-04 System admin is not able to create duplicated Domains")
+    public void systemAdminIsAbleToDeleteDomainsWithoutResources() throws JsonProcessingException {
+        DomainModel domainModel = DomainModel.generatePublicDomainModelWithSML();
+
+        MemberModel superMember = new MemberModel();
+        superMember.setUsername(TestRunData.getInstance().getAdminUsername());
+        superMember.setRoleType("ADMIN");
+
+        //create domain
+        domainModel = rest.domains().createDomain(domainModel);
+
+        //add users to domain
+        rest.domains().addMembersToDomain(domainModel, superMember);
+        domainsPage.refreshPage();
+        domainsPage
+                .getLeftSideGrid().searchAndClickElementInColumn("Domain code", domainModel.getDomainCode());
+        domainsPage.deleteandConfirm();
+        soft.assertEquals(domainsPage.getAlertArea().getAlertMessage(), "Domain: [" + domainModel.getDomainCode() + "] is removed!", "Alert message is wrong");
+
+        soft.assertFalse(domainsPage
+                .getLeftSideGrid().isValuePresentInColumn("Domain code", domainModel.getDomainCode()));
+        soft.assertAll();
+    }
+
+    @Test(description = "DOM-04 System admin is not able to create duplicated Domains")
+    public void systemAdminIsNotAbleToDeleteDomainsWithResources() throws JsonProcessingException {
+        DomainModel domainModel = DomainModel.generatePublicDomainModelWithSML();
+        GroupModel groupModel = GroupModel.generatePublicGroup();
+        ResourceModel resourceModel = ResourceModel.generatePublicResourceUnregisteredToSML();
+
+
+        MemberModel superMember = new MemberModel();
+        superMember.setUsername(TestRunData.getInstance().getAdminUsername());
+        superMember.setRoleType("ADMIN");
+
+
+        //create domain
+        domainModel = rest.domains().createDomain(domainModel);
+
+        //add users to domain
+        rest.domains().addMembersToDomain(domainModel, superMember);
+
+        //add resources to domain
+        List<ResourceTypes> resourcesToBeAdded = Arrays.asList(ResourceTypes.OASIS1, ResourceTypes.OASIS3, ResourceTypes.OASIS2);
+        domainModel = rest.domains().addResourcesToDomain(domainModel, resourcesToBeAdded);
+
+        //create group for domain
+        groupModel = rest.domains().createGroupForDomain(domainModel, groupModel);
+
+
+        //add resource to group
+        rest.resources().createResourceForGroup(domainModel, groupModel, resourceModel);
+
+
+        domainsPage.refreshPage();
+        domainsPage
+                .getLeftSideGrid().searchAndClickElementInColumn("Domain code", domainModel.getDomainCode());
+        domainsPage.deleteandConfirm();
+        soft.assertEquals(domainsPage.getAlertArea().getAlertMessage(), "Can not delete domain because it has resources [1]! Delete resources first!", "Alert message is wrong");
+        soft.assertTrue(domainsPage
+                .getLeftSideGrid().isValuePresentInColumn("Domain code", domainModel.getDomainCode()));
+        soft.assertAll();
+    }
+
+    @Test(description = "DOM-07 System admin can delete only unregister SML domains")
+    public void systemAdminCanDeleteOnlyUnregisterSMLDomains() throws Exception {
+        DomainModel domainModelGenerated = DomainModel.generatePublicDomainModelWithSML();
+
+        MemberModel superMember = new MemberModel();
+        superMember.setUsername(TestRunData.getInstance().getAdminUsername());
+        superMember.setRoleType("ADMIN");
+
+
+        //create domain
+        DomainModel domainModel = rest.domains().createDomain(domainModelGenerated);
+
+        //add users to domain
+        rest.domains().addMembersToDomain(domainModel, superMember);
+        //add resources to domain
+        List<ResourceTypes> resourcesToBeAdded = Arrays.asList(ResourceTypes.OASIS1, ResourceTypes.OASIS3, ResourceTypes.OASIS2);
+        domainModel = rest.domains().addResourcesToDomain(domainModel, resourcesToBeAdded);
+
+        domainsPage.refreshPage();
+
+        domainsPage.getLeftSideGrid().searchAndGetElementInColumn("Domain code", domainModel.getDomainCode()).click();
+        domainsPage.goToTab("SML integration");
+        domainsPage.getSMLIntegrationTab().fillSMLIntegrationTab(domainModelGenerated);
+        domainsPage.getSMLIntegrationTab().saveChanges();
+        domainsPage.getSMLIntegrationTab().registerToSML();
+
+        String alert = domainsPage.getAlertMessageAndClose();
+        soft.assertEquals(alert, "Domain [" + domainModel.getDomainCode() + "] registered to SML!");
+        soft.assertFalse(domainsPage.getDeleteBtn().isEnabled(), "Delete button is enabled!");
+
+        domainsPage.getSMLIntegrationTab().unregisterToSML();
+        domainsPage.deleteandConfirm();
+        soft.assertFalse(domainsPage.getLeftSideGrid().isValuePresentInColumn("Domain code", domainModel.getDomainCode()), "Deleted domain is still in the grid");
+
+
+        soft.assertAll();
+    }
 
     @Test(description = "DOM-19 - Domain admins are able to change default properties for domains")
     public void systemAdminsAreAbleToChangeDefaultPropertiesForDomains() throws Exception {

domismp-tests/domismp-tests-ui/src/test/java/domiSMPTests/ui/EditResourcePgTests.java

@@ -25,6 +25,7 @@ import utils.XMLUtils;
 import javax.xml.parsers.ParserConfigurationException;
 import java.util.Arrays;
 import java.util.List;
+import java.util.NoSuchElementException;
 
 public class EditResourcePgTests extends SeleniumTest {
     DomiSMPPage homePage;
@@ -272,6 +273,40 @@ public class EditResourcePgTests extends SeleniumTest {
         soft.assertAll();
     }
 
+    @Test(description = "EDTRES-11 Resource admin is able to delete subresource", priority = 1)
+    public void resourceAdminsIsAbleToDeleteSubResource() throws Exception {
+
+        ResourceModel resourceModelOasis1 = ResourceModel.generatePublicResourceWithReview(ResourceTypes.OASIS1);
+        SubresourceModel subresourceModel = SubresourceModel.generatePublicSubResource();
+
+        //add resource to group
+        resourceModelOasis1 = rest.resources().createResourceForGroup(domainModel, groupModel, resourceModelOasis1);
+        rest.resources().addMembersToResource(domainModel, groupModel, resourceModelOasis1, adminMember);
+
+        editResourcePage.refreshPage();
+        editResourcePage.selectDomain(domainModel, groupModel, resourceModelOasis1);
+
+        editResourcePage.goToTab("Subresources");
+        CreateSubresourceDetailsDialog createSubresourceDetailsDialog = editResourcePage.getSubresourceTab().createSubresource();
+        createSubresourceDetailsDialog.fillResourceDetails(subresourceModel);
+        createSubresourceDetailsDialog.tryClickOnSave();
+        editResourcePage.getSubresourceTab().deleteSubresouceDocument(subresourceModel);
+        String deleteResourceAlert = editResourcePage.getAlertMessageAndClose();
+
+
+        soft.assertEquals(deleteResourceAlert, "Subresource with scheme [" + subresourceModel.getIdentifierScheme() + "] and identifier: [" + subresourceModel.getIdentifierValue() + "] deleted.");
+        soft.assertFalse(editResourcePage.getSubresourceTab().getGrid().isValuePresentInColumn("Identifier", subresourceModel.getIdentifierValue()), "Deleted subresource is stil in the grid.");
+        ResourcesPage resourcesPage = editResourcePage.getSidebar().navigateTo(Pages.SEARCH_RESOURCES);
+        try {
+            resourcesPage.openURLSubResouceDocument(resourceModelOasis1.getIdentifierValue(), resourceModelOasis1.getIdentifierScheme(), subresourceModel.getIdentifierValue());
+            soft.assertTrue(false);
+        } catch (NoSuchElementException e) {
+            soft.assertTrue(true);
+        }
+        soft.assertAll();
+
+    }
+
     @Test(description = "EDTRES-15 - Resource Administrator can publish resource documents with approve status", priority = 1)
     public void resourceAdministratorsCanPublisResourceDocumentsWithApproveStatus() throws JsonProcessingException {
 
@@ -317,7 +352,7 @@ public class EditResourcePgTests extends SeleniumTest {
 
     }
 
-    @Test(description = "EDTRES-15 - Resource Administrator can publish subresource documents with approve status", priority = 1)
+    @Test(description = "EDTRES-16 - Resource Administrator can publish SubResource documents with approve status", priority = 1)
 
     public void resourceAdministratorsCanPublisSUBResourceDocumentsWithApproveStatus() throws Exception {
 

domismp-tests/domismp-tests-ui/src/test/java/domiSMPTests/ui/UsersPgTests.java

 package domiSMPTests.ui;
 
 import ddsl.DomiSMPPage;
+import ddsl.dcomponents.SetChangePasswordDialog;
 import ddsl.dobjects.DWait;
+import ddsl.enums.ApplicationRoles;
 import ddsl.enums.Pages;
 import domiSMPTests.SeleniumTest;
 import org.openqa.selenium.WebElement;
@@ -11,6 +13,7 @@ import org.testng.asserts.SoftAssert;
 import pages.LoginPage;
 import pages.ResetCredentialsPage;
 import pages.systemSettings.UsersPage;
+import pages.userSettings.ProfilePage;
 import rest.InbucketRestClient;
 import rest.models.UserModel;
 
@@ -53,10 +56,9 @@ public class UsersPgTests extends SeleniumTest {
         soft.assertEquals(usersPage.getSelectedLocaleValue(), "en");
 
         soft.assertAll();
-
-
     }
 
+
     @Test(description = "USR-02 System admin is not able to create duplicated user")
     public void systemAdminIsNotAbleToCreateDuplicatedUser() throws Exception {
 
@@ -74,8 +76,129 @@ public class UsersPgTests extends SeleniumTest {
         soft.assertAll();
     }
 
+    @Test(description = "USR-03 System admin is able to delete user")
+    public void systemAdminIsAbleToDeleteUser() throws Exception {
+        UserModel newNormalUser = UserModel.generateUserWithUSERrole();
+
+        String normalUserId = rest.users().createUser(newNormalUser).getString("userId");
+        rest.users().changePassword(normalUserId, data.getNewPassword());
+
+        loginPage.login(data.getAdminUser().get("username"), data.getAdminUser().get("password"));
+        UsersPage usersPage = homePage.getSidebar().navigateTo(Pages.SYSTEM_SETTINGS_USERS);
+        WebElement newUser = usersPage.getLeftSideGrid().searchAndGetElementInColumn("Username", newNormalUser.getUsername());
+        newUser.click();
+        String deleteAlert = usersPage.deleteAndConfirm();
+        soft.assertEquals(deleteAlert, "User [" + newNormalUser.getUsername() + "] has been deleted!", "Delete user alert message is wrong");
+        soft.assertFalse(usersPage.getLeftSideGrid().isValuePresentInColumn("Username", newNormalUser.getUsername()));
+        loginPage.logout();
+        loginPage.login(newNormalUser.getUsername(), data.getNewPassword());
+        soft.assertEquals(loginPage.getAlertArea().getAlertMessage(), "Login failed; Invalid userID or password!", "Login failed alert message is not correct");
+        soft.assertAll();
+    }
+
+    @Test(description = "USR-04 System admin is able to change the password of selected user")
+    public void systemAdminIsAbleToChangePasswordOfSelectedUser() throws Exception {
+        String newPassword = "@#$#asdddersPasswordValue12";
+        UserModel newNormalUser = UserModel.generateUserWithUSERrole();
+        rest.users().createUser(newNormalUser).getString("userId");
+
+        loginPage.login(data.getAdminUser().get("username"), data.getAdminUser().get("password"));
+        UsersPage usersPage = homePage.getSidebar().navigateTo(Pages.SYSTEM_SETTINGS_USERS);
+        WebElement newUser = usersPage.getLeftSideGrid().searchAndGetElementInColumn("Username", newNormalUser.getUsername());
+        newUser.click();
+
+        SetChangePasswordDialog setChangePasswordDialog = usersPage.userData.clickOnChangePassword();
+        setChangePasswordDialog.fillChangePassword(data.getAdminUser().get("password"), newPassword);
+        setChangePasswordDialog.TryClickOnChangePassword();
+
+        loginPage.logout();
+        loginPage.login(newNormalUser.getUsername(), newPassword);
+        homePage.getSidebar().navigateTo(Pages.USER_SETTINGS_PROFILE);
+        soft.assertEquals(homePage.getBreadcrump().getCurrentPage(), "Profile");
+        soft.assertAll();
+    }
+
+    @Test(description = "USR-05 System admin can modify user's data")
+    public void systemAdminCanModifyUserData() throws Exception {
+        UserModel newNormalUser = UserModel.generateUserWithUSERrole();
+
+        String normalUserId = rest.users().createUser(newNormalUser).getString("userId");
+        rest.users().changePassword(normalUserId, data.getNewPassword());
+
+        loginPage.login(data.getAdminUser().get("username"), data.getAdminUser().get("password"));
+        UsersPage usersPage = homePage.getSidebar().navigateTo(Pages.SYSTEM_SETTINGS_USERS);
+        WebElement newUser = usersPage.getLeftSideGrid().searchAndGetElementInColumn("Username", newNormalUser.getUsername());
+        newUser.click();
+
+        String newEmail = "newemail@email.com";
+        String newFullname = "AUT_NewFullName";
+        String newTheme = "Blue theme";
+        String newLocale = "Romanian";
+        usersPage.userData.fillUserProfileData(newEmail, newFullname, newTheme, newLocale);
+
+        loginPage.logout();
+        loginPage.login(newNormalUser.getUsername(), data.getNewPassword());
+        ProfilePage profilePage = homePage.getSidebar().navigateTo(Pages.USER_SETTINGS_PROFILE);
+        soft.assertEquals(profilePage.profileData.getEmailAddress(), newEmail, "Email is not updated!");
+        soft.assertEquals(profilePage.profileData.getFullName(), newFullname, "Fullname is not updated!");
+        soft.assertEquals(profilePage.profileData.getSelectedTheme(), newTheme, "Theme is not updated!");
+        soft.assertEquals(profilePage.profileData.getSelectedLocale(), "ro", "Locale is not updated!");
+        soft.assertAll();
+    }
+
+    @Test(description = "USR-06 System admin is able to change the role of an user")
+    public void systemAdminIsAbleToChangeTheRoleOfUsers() throws Exception {
+        UserModel newNormalUser = UserModel.generateUserWithUSERrole();
+
+        String normalUserId = rest.users().createUser(newNormalUser).getString("userId");
+        rest.users().changePassword(normalUserId, data.getNewPassword());
+
+        loginPage.login(data.getAdminUser().get("username"), data.getAdminUser().get("password"));
+        UsersPage usersPage = homePage.getSidebar().navigateTo(Pages.SYSTEM_SETTINGS_USERS);
+        WebElement newUser = usersPage.getLeftSideGrid().searchAndGetElementInColumn("Username", newNormalUser.getUsername());
+        newUser.click();
+        usersPage.changeApplicationRole(ApplicationRoles.SYSTEM_ADMIN);
+
+        loginPage.logout();
+        loginPage.login(newNormalUser.getUsername(), data.getNewPassword());
+        homePage.getSidebar().navigateTo(Pages.SYSTEM_SETTINGS_DOMAINS);
+        soft.assertEquals(homePage.getBreadcrump().getCurrentPage(), "Domain");
+        soft.assertAll();
+    }
+
+    @Test(description = "USR-07 System admin is able to active/deactivate users")
+    public void systemAdminIsAbleToActivatDeactivateUser() throws Exception {
+        UserModel newNormalUser = UserModel.generateUserWithUSERrole();
+
+        String normalUserId = rest.users().createUser(newNormalUser).getString("userId");
+        rest.users().changePassword(normalUserId, data.getNewPassword());
+        //Deactivate user
+        loginPage.login(data.getAdminUser().get("username"), data.getAdminUser().get("password"));
+        UsersPage usersPage = homePage.getSidebar().navigateTo(Pages.SYSTEM_SETTINGS_USERS);
+        WebElement newUser = usersPage.getLeftSideGrid().searchAndGetElementInColumn("Username", newNormalUser.getUsername());
+        newUser.click();
+        usersPage.modifyIsActiveForUser(false);
+
+        loginPage.logout();
+        loginPage.login(newNormalUser.getUsername(), data.getNewPassword());
+        soft.assertEquals(loginPage.getAlertArea().getAlertMessage(), "Login failed; Invalid userID or password!", "Login failed alert message is not correct");
+        //Activate user
+
+        loginPage.login(data.getAdminUser().get("username"), data.getAdminUser().get("password"));
+        usersPage = homePage.getSidebar().navigateTo(Pages.SYSTEM_SETTINGS_USERS);
+        newUser = usersPage.getLeftSideGrid().searchAndGetElementInColumn("Username", newNormalUser.getUsername());
+        newUser.click();
+        usersPage.modifyIsActiveForUser(true);
+
+        loginPage.logout();
+        loginPage.login(newNormalUser.getUsername(), data.getNewPassword());
+        homePage.getSidebar().navigateTo(Pages.USER_SETTINGS_PROFILE);
+        soft.assertEquals(homePage.getBreadcrump().getCurrentPage(), "Profile");
+        soft.assertAll();
+    }
+
     @Test(description = "LGN-32 - User is able to reset password")
-    public void userIsAbleToResetHisPassword() throws Exception {
+    public void userIsAbleToResetPassword() throws Exception {
 
         UserModel newAdminUser = UserModel.generateUserWithADMINrole();
         UserModel newNormalUser = UserModel.generateUserWithUSERrole();
@@ -255,4 +378,5 @@ public class UsersPgTests extends SeleniumTest {
         soft.assertAll();
     }
 
+
 }
\ No newline at end of file