package FSWEP_LoginP;

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import java.time.Duration;

public class BaseTest {

    protected WebDriver driver;
    protected WebDriverWait wait;
    protected long startTime;

    @BeforeMethod
    public void setUp() {

        startTime = System.currentTimeMillis();

        System.setProperty("webdriver.chrome.silentOutput", "true");

        java.util.logging.Logger
                .getLogger("org.openqa.selenium")
                .setLevel(java.util.logging.Level.SEVERE);

        driver = new ChromeDriver();

        driver.manage().window().maximize();

        wait = new WebDriverWait(driver, Duration.ofSeconds(10));
    }

    @AfterMethod
    public void tearDown() {

        if (driver != null) {
            driver.quit();
        }
    }

    public WebDriver getDriver() {
        return driver;
    }

    public long getStartTime() {
        return startTime;
    }
}

package FSWEP_LoginP;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

import static org.openqa.selenium.devtools.v120.animation.Animation.getCurrentTime;

public class LoggerUtility {

    private static int stepNumber = 1;

    public static void resetStepCounter() {
        stepNumber = 1;
    }

    private static String getCurrentTime() {

        DateTimeFormatter formatter =
                DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

        return LocalDateTime.now().format(formatter);
    }

    private static final DateTimeFormatter formatter =
            DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    public static void logTestCase(
            String testCaseId,
            String testCase,
            String objective,
            String expected,
            String expectedMessage) {

        resetStepCounter();

        System.out.println("\n============================================================");
        System.out.println("TEST CASE ID     : " + testCaseId);
        System.out.println("TEST CASE        : " + testCase);
        System.out.println("OBJECTIVE        : " + objective);
        System.out.println("EXPECTED RESULT  : " + expected);

        if (!expectedMessage.isBlank()) {
            System.out.println("EXPECTED MESSAGE : " + expectedMessage);
        }

        System.out.println("STARTED          : " + getCurrentTime());
        System.out.println("============================================================");
    }

    public static void logStep(String stepDescription) {

        System.out.println();
        System.out.println("STEP " + stepNumber + " : " + stepDescription);
        System.out.println("----------------------------------------------");

        stepNumber++;
    }

    public static void logPass(String message) {

        System.out.println("[PASS] " + message);
    }

    public static void logFail(String message) {

        System.out.println("[FAIL] " + message);
    }

    public static void logInfo(String message) {

        System.out.println("[INFO] " + message);
    }

    public static void logTestComplete(String message) {

        System.out.println("[PASS] " + message);
        System.out.println();

    }

    public static void logSummary(
            String testCase,
            boolean passed,
            double durationSeconds) {

        System.out.println();
        System.out.println("============================================================");
        System.out.println("TEST EXECUTION SUMMARY");
        System.out.println("============================================================");

        System.out.println("RESULT            : "
                + (passed ? "PASS" : "FAIL"));

        System.out.println("TEST CASE         : " + testCase);

        System.out.printf("DURATION          : %.2f seconds%n",
                durationSeconds);

        System.out.println("FINISHED          : " + getCurrentTime());

        System.out.println("============================================================");
        System.out.println();
    }

    // Log executive summary test case duration
    public static void logExecutionSummary(
            String testCase,
            long startTime) {

        long endTime =
                System.currentTimeMillis();

        double durationSeconds =
                (endTime - startTime) / 1000.0;

        logSummary(
                testCase,
                true,
                durationSeconds);
    }

}

package FSWEP_LoginP;

public class LoginData {

    private String testCaseId;
    private String testCase;
    private String objective;
    private String username;
    private String password;
    private String expected;
    private String expectedMessage;

    public LoginData() {
    }

    public String getTestCaseId() {
        return testCaseId;
    }

    public void setTestCaseId(String testCaseId) {
        this.testCaseId = testCaseId;
    }

    public String getTestCase() {
        return testCase;
    }

    public void setTestCase(String testCase) {
        this.testCase = testCase;
    }

    public String getObjective() {
        return objective;
    }

    public void setObjective(String objective) {
        this.objective = objective;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getExpected() {
        return expected;
    }

    public void setExpected(String expected) {
        this.expected = expected;
    }

    public String getExpectedMessage() {
        return expectedMessage;
    }

    public void setExpectedMessage(String expectedMessage) {
        this.expectedMessage = expectedMessage;
    }

    @Override
    public String toString() {

        return testCaseId
                + " - "
                + testCase;
    }
}

package FSWEP_LoginP;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.testng.annotations.DataProvider;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class LoginDataProvider {

    @DataProvider(name = "loginData")
    public Object[][] getLoginData() throws Exception {

        ObjectMapper mapper =
                new ObjectMapper();

        // -------------------------------------------------
        // Select the JSON data source.
        //
        // Default:
        // testdata/loginData-regression.json
        //
        // Retest pipeline can override this with:
        // -DtestDataFile=testdata/loginData-retest.json
        // -------------------------------------------------

        String testDataFile =
                System.getProperty(
                        "testDataFile",
                        "testdata/loginData-regression.json");

        InputStream input =
                getClass()
                        .getClassLoader()
                        .getResourceAsStream(testDataFile);

        if (input == null) {

            throw new IllegalArgumentException(
                    "Test data file was not found: "
                            + testDataFile);
        }

        List<LoginData> allData =
                Arrays.asList(
                        mapper.readValue(
                                input,
                                LoginData[].class));

        // -------------------------------------------------
        // Optional Test Case filter.
        //
        // Full regression:
        // no testCaseIds property
        // → run every row in the selected JSON file.
        //
        // Retest:
        // -DtestCaseIds=TC006
        //
        // Multiple:
        // -DtestCaseIds=TC006,TC007
        // -------------------------------------------------

        String testCaseIds =
                System.getProperty(
                        "testCaseIds",
                        "");

        List<LoginData> selectedData =
                new ArrayList<>();

        if (testCaseIds.isBlank()) {

            selectedData.addAll(allData);
        }
        else {

            List<String> requestedIds =
                    Arrays.asList(
                            testCaseIds.split(","));

            for (LoginData data : allData) {

                boolean selected =
                        requestedIds.stream()
                                .map(String::trim)
                                .anyMatch(
                                        id ->
                                                id.equalsIgnoreCase(
                                                        data.getTestCaseId()));

                if (selected) {
                    selectedData.add(data);
                }
            }
        }

        if (selectedData.isEmpty()) {

            throw new IllegalArgumentException(
                    "No Test Cases matched testCaseIds='"
                            + testCaseIds
                            + "' in "
                            + testDataFile);
        }

        System.out.println();
        System.out.println(
                "Test data file: "
                        + testDataFile);

        System.out.println(
                "Test Cases selected for execution: "
                        + selectedData.size());

        for (LoginData data : selectedData) {

            System.out.println(
                    "  "
                            + data.getTestCaseId()
                            + " - "
                            + data.getTestCase());
        }

        Object[][] result =
                new Object[selectedData.size()][1];

        for (int i = 0; i < selectedData.size(); i++) {

            result[i][0] =
                    selectedData.get(i);
        }

        return result;
    }
}

package FSWEP_LoginP;

import java.util.List;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;

public class LoginPage {

    private static final String LOGIN_URL =
            "https://emploisfp-psjobs.cfp-psc.gc.ca/psrs-srfp/applicant/page1710";

    private static final String LOGIN_PAGE_TITLE =
            "Login to your account";

    private WebDriver driver;
    private WebDriverWait wait;

    public void open() {

        driver.get(LOGIN_URL);

        wait.until(
                ExpectedConditions.titleIs(
                        LOGIN_PAGE_TITLE));
    }

    public String getPageTitle() {

        return driver.getTitle();
    }



    private By usernameField =
            By.id("UserNumber");

    private By passwordField =
            By.id("Password");

    private By loginButton =
            By.name("LOGIN");

    private static final By INVALID_LOGIN_ERROR =
            By.cssSelector("strong.mandatory");

    private static final By REQUIRED_FIELDS_ERROR =
            By.cssSelector("p.mandatory");



    public LoginPage(WebDriver driver, WebDriverWait wait) {

        this.driver = driver;
        this.wait = wait;
    }


    public void enterUsername(String username) {

        WebElement usernameElement =
                wait.until(
                        ExpectedConditions.visibilityOfElementLocated(
                                usernameField));

        usernameElement.sendKeys(username);
    }


    public void enterPassword(String password) {

        WebElement passwordElement =
                wait.until(
                        ExpectedConditions.visibilityOfElementLocated(
                                passwordField));

        passwordElement.sendKeys(password);
    }


    public void clickLogin() {

        WebElement loginElement =
                wait.until(
                        ExpectedConditions.elementToBeClickable(
                                loginButton));

        loginElement.click();
    }


    public boolean isSuccessfulLogin() {

        return driver.getTitle().equals("My jobs menu")
                || driver.getTitle().equals("Enter access code");
    }


    public boolean hasLoginError() {

        return !driver.findElements(INVALID_LOGIN_ERROR).isEmpty()
                || !driver.findElements(REQUIRED_FIELDS_ERROR).isEmpty();
    }


    public String getDisplayedErrorMessage() {

        List<WebElement> invalidLogin =
                driver.findElements(INVALID_LOGIN_ERROR);

        if (!invalidLogin.isEmpty()) {

            return invalidLogin.get(0)
                    .getText()
                    .trim();
        }

        List<WebElement> requiredFields =
                driver.findElements(REQUIRED_FIELDS_ERROR);

        if (!requiredFields.isEmpty()) {

            return requiredFields.get(0)
                    .getText()
                    .trim();
        }

        return "";
    }


    public LoginResult getLoginResult() {

        wait.until(ExpectedConditions.or(

                ExpectedConditions.titleIs("My jobs menu"),

                ExpectedConditions.titleIs("Enter access code"),

                ExpectedConditions.visibilityOfElementLocated(
                        INVALID_LOGIN_ERROR),

                ExpectedConditions.visibilityOfElementLocated(
                        REQUIRED_FIELDS_ERROR)
        ));

        String pageTitle = driver.getTitle();

        if (pageTitle.equals("My jobs menu")
                || pageTitle.equals("Enter access code")) {

            return new LoginResult(
                    "SUCCESS",
                    "");
        }

        String actualMessage =
                getDisplayedErrorMessage();

        return new LoginResult(
                "FAIL",
                actualMessage);
    }
}

package FSWEP_LoginP;

public class LoginResult {

    private final String actualResult;
    private final String actualMessage;

    public LoginResult(String actualResult, String actualMessage) {
        this.actualResult = actualResult;
        this.actualMessage = actualMessage;
    }

    public String getActualResult() {
        return actualResult;
    }

    public String getActualMessage() {
        return actualMessage;
    }


}

package FSWEP_LoginP;

import org.testng.Assert;

public class LoginValidator {

    public static void validate(
            LoginData data,
            LoginResult result) {

        LoggerUtility.logStep(
                "Comparing Expected and Actual Results");

        LoggerUtility.logInfo(
                "EXPECTED RESULT: "
                        + data.getExpected());

        LoggerUtility.logInfo(
                "ACTUAL RESULT: "
                        + result.getActualResult());

        if (result.getActualResult()
                .equals(data.getExpected())) {

            LoggerUtility.logPass(
                    "✓ Result matches expected value.");
        }

        Assert.assertEquals(
                result.getActualResult(),
                data.getExpected(),
                "Incorrect login result for "
                        + data.getTestCaseId()
                        + " - "
                        + data.getTestCase());

        if ("FAIL".equals(data.getExpected())) {

            LoggerUtility.logInfo(
                    "EXPECTED MESSAGE: "
                            + data.getExpectedMessage());

            LoggerUtility.logInfo(
                    "ACTUAL MESSAGE: "
                            + result.getActualMessage());

            if (result.getActualMessage()
                    .equals(data.getExpectedMessage())) {

                LoggerUtility.logPass(
                        "✓ Message matches expected value.");
            }

            Assert.assertEquals(
                    result.getActualMessage(),
                    data.getExpectedMessage(),
                    "Incorrect error message for "
                            + data.getTestCaseId()
                            + " - "
                            + data.getTestCase());
        }
    }
}

package FSWEP_LoginP;

import org.openqa.selenium.OutputType;
import org.openqa.selenium.TakesScreenshot;
import org.openqa.selenium.WebDriver;
import java.nio.file.Path;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class ScreenshotUtility {

    public static void captureScreenshot(
            WebDriver driver,
            String testCaseName) {

        try {

            Files.createDirectories(Path.of("Screenshots"));

            File source =
                    ((TakesScreenshot) driver)
                            .getScreenshotAs(OutputType.FILE);

            String timestamp =
                    LocalDateTime.now()
                            .format(DateTimeFormatter.ofPattern(
                                    "yyyy-MM-dd_HH-mm-ss"));

            File destination =
                    new File("Screenshots/"
                            + testCaseName.replace(" ", "_")
                            + "_"
                            + timestamp
                            + ".png");

            Files.copy(source.toPath(), destination.toPath());

            LoggerUtility.logInfo(
                    "Screenshot saved to: "
                            + destination.getAbsolutePath());

        } catch (IOException e) {

            LoggerUtility.logFail(
                    "Unable to save screenshot.");

            e.printStackTrace();
        }

    }
}

package FSWEP_LoginP;

import org.testng.Reporter;
import org.testng.annotations.Listeners;
import org.testng.annotations.Test;

@Listeners(TestListener.class)
public class SeleniumLoginDataDrivenTest extends BaseTest {

    private static final String LOGIN_URL =
            "https://emploisfp-psjobs.cfp-psc.gc.ca/psrs-srfp/applicant/page1710";

    @Test(
            dataProvider = "loginData",
            dataProviderClass = LoginDataProvider.class
    )
    public void testLogin(LoginData data) {

        LoggerUtility.logTestCase(
                data.getTestCaseId(),
                data.getTestCase(),
                data.getObjective(),
                data.getExpected(),
                data.getExpectedMessage());

        Reporter.getCurrentTestResult()
                .getTestContext()
                .setAttribute("testCaseName", data.getTestCase());

        Reporter.getCurrentTestResult()
                .getTestContext()
                .setAttribute("testCaseId", data.getTestCaseId());

        // Create the LoginPage object
        LoginPage loginPage =
                new LoginPage(driver, wait);

        // Open login page
        LoggerUtility.logStep("Opening login page.");

        loginPage.open();

        LoggerUtility.logPass(
                "✓ Successfully navigated to the login page.");

        LoggerUtility.logPass(
                "Page Title: " + loginPage.getPageTitle());

        // Enter username
        LoggerUtility.logStep("Entering username.");

        loginPage.enterUsername(data.getUsername());

        LoggerUtility.logPass("Username entered.");

        // Enter password
        LoggerUtility.logStep("Entering password.");

        loginPage.enterPassword(data.getPassword());

        LoggerUtility.logPass("Password entered.");

        // Click Login button
        LoggerUtility.logStep("Click Login Button");

        loginPage.clickLogin();

        LoggerUtility.logPass("Login button clicked.");

        // Get the actual login result
        LoginResult result =
                loginPage.getLoginResult();

        // Validate expected and actual results
        LoginValidator.validate(data, result);

        // Execution summary
        LoggerUtility.logExecutionSummary(
                data.getTestCase(),
                getStartTime());

    } // testLogin() ends here


} // class ends here

package FSWEP_LoginP;

import org.testng.ITestListener;
import org.testng.ITestResult;

public class TestListener implements ITestListener {

    @Override
    public void onTestSuccess(ITestResult result) {

        String testCaseId =
                (String) result.getTestContext()
                        .getAttribute("testCaseId");

        String testCaseName =
                (String) result.getTestContext()
                        .getAttribute("testCaseName");

        LoggerUtility.logPass(
                "TEST CASE PASSED: "
                        + testCaseId
                        + " - "
                        + testCaseName);

        System.out.println();
    }

    @Override
    public void onTestFailure(ITestResult result) {

        String testCaseId =
                (String) result.getTestContext()
                        .getAttribute("testCaseId");

        String testCaseName =
                (String) result.getTestContext()
                        .getAttribute("testCaseName");

        LoggerUtility.logFail(
                "TEST CASE FAILED: "
                        + testCaseId
                        + " - "
                        + testCaseName);

        BaseTest testInstance =
                (BaseTest) result.getInstance();

        ScreenshotUtility.captureScreenshot(
                testInstance.getDriver(),
                testCaseId + " - " + testCaseName);

        System.out.println();
    }
}