Hocine
Benbara

import { Page } from '@playwright/test';
import { BasePage } from './BasePage';
import { loginLocators } from '../locators/login.locators';

export class LoginPage extends BasePage {

  async gotoLoginPage() {
    await this.goto('/');
  }

  async fillUsername(username: string) {
    await this.page.fill(loginLocators.usernameInput, username);
  }

  async fillPassword(password: string) {
    await this.page.fill(loginLocators.passwordInput, password);
  }

  async clickLogin() {
    await this.page.click(loginLocators.loginButton);
  }

  async login(username: string, password: string) {
    await this.gotoLoginPage();
    await this.fillUsername(username);
    await this.fillPassword(password);
    await this.clickLogin();
  }
}

export const loginLocators = {
  // Login form
  usernameInput: '[data-test-qa-id="txtUserName"]',
  passwordInput: '[data-test-qa-id="txtPassword"]',
  loginButton:   '[data-test-qa-id="btnLogin"]',

  // Logout
  accountIcon:      'span[role="presentation"].icon-user4',
  logoutButton:     'div.content.MuiBox-root:has-text(/Se déconnecter|Logout/)',
  logoutButtonAlt1: 'text=/Se déconnecter|Logout/',
  logoutButtonAlt2: 'div:has-text(/Se déconnecter|Logout/)',

  // Feedback
  errorMessage:     '.error-message',
  successIndicator: '.welcome-message',
};

import { test } from '../../fixtures/baseTest';
import testData from '../../data/testData.json';

test.describe('Login Tests', () => {

  test('Login avec identifiants valides', async ({ loginPage }) => {
    // Arrange
    await loginPage.gotoLoginPage();

    // Act
    await loginPage.fillUsername(testData.validUser.username);
    await loginPage.fillPassword(testData.validUser.password);
    await loginPage.clickLogin();

    // Assert
    await loginPage.getPage.waitForLoadState('networkidle');
  });

  test('Login avec mauvais mot de passe – affiche erreur', async ({ loginPage }) => {
    await loginPage.login(testData.validUser.username, 'wrong_password');
    // Assert: error message visible
  });

});

import { defineConfig, devices } from '@playwright/test';

export default defineConfig({
  reporter: [['html', { outputFolder: 'playwright-report', open: 'always' }]],
  testDir: './tests',
  timeout: 30 * 1000,
  use: {
    headless: false,
    baseURL: process.env.BASE_URL,
    screenshot: 'only-on-failure',
  },
  projects: [{
    name: 'chromium',
    use: { ...devices['Desktop Chrome'] },
  }],
});

/// Wrapper Zephyr Scale — envoie les résultats via API REST.
public class ZephyrHelper
{
    private static readonly HttpClient _client = new HttpClient();
    private readonly string _baseUrl;
    private readonly string _projectKey;

    public ZephyrHelper()
    {
        _baseUrl    = TestConfig.ZephyrBaseUrl;
        _projectKey = TestConfig.ZephyrProjectKey;
        _client.DefaultRequestHeaders.Authorization =
            new AuthenticationHeaderValue("Bearer", TestConfig.ZephyrToken);
    }

    public async Task ReportExecutionAsync(
        string testCaseKey, string status, string comment = "")
    {
        var payload = new { projectKey = _projectKey, testCaseKey, statusName = status, comment };
        var json    = JsonSerializer.Serialize(payload);
        var content = new StringContent(json, Encoding.UTF8, "application/json");
        var response = await _client.PostAsync($"{_baseUrl}/testexecutions", content);
        TestContext.WriteLine(response.IsSuccessStatusCode
            ? $"[ZEPHYR] ✓ '{status}' → {testCaseKey}"
            : $"[ZEPHYR] ✗ {response.StatusCode}");
    }

    public void ReportExecution(string key, string status, string comment = "")
        => ReportExecutionAsync(key, status, comment).GetAwaiter().GetResult();

    public static class Status {
        public const string Pass = "Pass"; public const string Fail = "Fail";
        public const string Blocked = "Blocked"; public const string NotExecuted = "Not Executed";
    }
}

[AttributeUsage(AttributeTargets.Method)]
public class ZephyrTestAttribute : Attribute {
    public string TestCaseKey { get; }
    public ZephyrTestAttribute(string key) => TestCaseKey = key;
}

/// Extension de TestBase avec rapport automatique Zephyr Scale.
[TestFixture]
public abstract class ZephyrTestBase : TestBase
{
    private readonly ZephyrHelper _zephyr = new ZephyrHelper();

    [TearDown]
    public override void TearDown()
    {
        ReportToZephyr();
        base.TearDown();
    }

    private void ReportToZephyr()
    {
        var methodName = TestContext.CurrentContext.Test.MethodName;
        var attr = GetType().GetMethod(methodName)?
            .GetCustomAttribute<ZephyrTestAttribute>();
        if (attr == null) return;
        var outcome = TestContext.CurrentContext.Result.Outcome.Status;
        var status  = outcome == TestStatus.Passed ? ZephyrHelper.Status.Pass
                    : outcome == TestStatus.Failed ? ZephyrHelper.Status.Fail
                    : ZephyrHelper.Status.Blocked;
        _zephyr.ReportExecution(attr.TestCaseKey, status,
            TestContext.CurrentContext.Result.Message ?? "");
    }
}

/// Page Object — Écran de connexion WPF.
public class LoginPage
{
    private readonly Window _window;
    public LoginPage(Window window) => _window = window;

    private TextBox UsernameField =>
        _window.FindFirstDescendant(cf => cf.ByAutomationId("txtUsername"))?.AsTextBox();
    private TextBox PasswordField =>
        _window.FindFirstDescendant(cf => cf.ByAutomationId("txtPassword"))?.AsTextBox();
    private Button LoginButton =>
        _window.FindFirstDescendant(cf => cf.ByAutomationId("btnLogin"))?.AsButton();
    private Label ErrorLabel =>
        _window.FindFirstDescendant(cf => cf.ByAutomationId("lblError"))?.AsLabel();

    public void Login(string username, string password)
    {
        if (UsernameField != null) { UsernameField.Click(); UsernameField.Text = username; }
        if (PasswordField != null) { PasswordField.Click(); PasswordField.Text = password; }
        LoginButton?.Click();
    }

    public bool   IsErrorDisplayed() => ErrorLabel?.IsEnabled == true;
    public string GetErrorMessage()  => ErrorLabel?.Text ?? string.Empty;
}

[TestFixture][Category("Authentication")]
public class LoginSpec : ZephyrTestBase
{
    private LoginPage _loginPage;
    private const string ValidUsername = "admin";
    private const string ValidPassword = "Admin@123";
    private const string WrongPassword = "mauvais_mdp";

    protected override void OnSetUp() => _loginPage = new LoginPage(MainWindow);

    [Test][ZephyrTest("PROJ-T01")]
    [Description("Connexion réussie avec identifiants valides")]
    public void Login_AvecIdentifiantsValides_ConnecteUtilisateur()
    {
        _loginPage.Login(ValidUsername, ValidPassword);
        var dashboard = WaitForElement(() =>
            MainWindow.FindFirstDescendant(cf => cf.ByAutomationId("DashboardPanel")));
        Assert.IsNotNull(dashboard, "Le dashboard doit être visible après connexion.");
    }

    [Test][ZephyrTest("PROJ-T02")]
    public void Login_AvecMauvaisMotDePasse_AfficheErreur()
    {
        _loginPage.Login(ValidUsername, WrongPassword);
        Assert.IsTrue(_loginPage.IsErrorDisplayed());
    }

    [Test][ZephyrTest("PROJ-T03")]
    public void Login_ChampsVides_BoutonDesactiveOuErreur()
    {
        _loginPage.Login("", "");
        Assert.IsTrue(_loginPage.IsErrorDisplayed());
    }
}

public static class TestConfig
{
    public static string AppExecutablePath =>
        Environment.GetEnvironmentVariable("WPFAUTOMATION_EXE_PATH")
        ?? @"C:\Apps\YourWpfApp\YourWpfApp.exe";

    public static string ArtifactsPath =>
        Environment.GetEnvironmentVariable("TEST_ARTIFACTS_PATH")
        ?? Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "TestArtifacts");

    public static int    DefaultTimeoutMs => 10_000;

    public static string ZephyrBaseUrl =>
        Environment.GetEnvironmentVariable("ZEPHYR_BASE_URL")
        ?? "https://api.zephyrscale.smartbear.com/v2";

    public static string ZephyrToken =>
        Environment.GetEnvironmentVariable("ZEPHYR_TOKEN")
        ?? throw new InvalidOperationException("ZEPHYR_TOKEN manquant.");

    public static string ZephyrProjectKey =>
        Environment.GetEnvironmentVariable("ZEPHYR_PROJECT_KEY") ?? "PROJ";
}