external-services-automation 1.0.0

package/README.md

@@ -0,0 +1,216 @@
+# External Services Automation Library
+
+A TypeScript library for test automation with Playwright, focused on integrations with external services like Kinde (authentication) and Stripe (payments).
+
+## Setup
+
+This library is designed to be used as a Git submodule. Follow these steps to integrate it into your project:
+
+### 1. Add Submodule
+
+```bash
+# Add the submodule
+git submodule add https://bitbucket.org/connectist/external-services-automation.git external-services
+
+# Initialize and update
+git submodule update --init --recursive
+```
+
+### 2. Build Library
+
+```bash
+cd external-services
+npm install
+npm run build
+cd ..
+```
+
+### 3. Configure Your Test Framework
+
+The library can be used with any test framework. Here's an example for Playwright:
+
+```typescript
+// playwright.config.ts
+import { defineConfig } from '@playwright/test';
+
+export default defineConfig({
+  testDir: './tests',
+  use: {
+    baseURL: process.env.BASE_URL || 'https://your-app.com',
+  },
+});
+```
+
+## Usage
+
+### Import Components
+
+```typescript
+import { 
+  ExternalServicesWorld,
+  LoginPage,
+  RegisterPage,
+  KindeAuthService,
+  StripeService,
+  GuerrillaMailClient
+} from './external-services/dist/index';
+```
+
+### Use Services and Page Objects
+
+```typescript
+// Authentication with Kinde
+const authService = new KindeAuthService();
+await authService.login(email, password);
+
+// Payment processing with Stripe
+const stripeService = new StripeService();
+await stripeService.upgradeSubscription(planType);
+
+// Page interactions
+const loginPage = new LoginPage(page);
+await loginPage.fillCredentials(email, password);
+```
+
+## Available Components
+
+### Services
+
+#### KindeAuthService
+- `login(email: string, password: string)` - Authenticates user with Kinde
+- `register(email: string, firstName: string, lastName: string)` - Creates new account
+- `verifyEmail(code: string)` - Verifies email with confirmation code
+
+#### StripeService
+- `upgradeSubscription(planType: string)` - Upgrades subscription to specified plan
+- `updatePaymentMethod(cardDetails: object)` - Updates payment method
+- `getCurrentSubscription()` - Retrieves current subscription details
+
+### Page Objects
+
+#### Kinde Pages
+- **LoginPage** - Handles login form interactions
+- **RegisterPage** - Manages account registration
+- **ConfirmCodePage** - Email verification code entry
+- **PasswordSetupPage** - Password creation and setup
+
+#### Stripe Pages
+- **CurrentSubscriptionPage** - Displays current subscription details
+- **UpdateSubscriptionPage** - Subscription plan selection
+- **UpdatePaymentMethodPage** - Payment method management
+- **ConfirmUpdatePage** - Confirmation dialogs
+- **LeftPanelPage** - Navigation and sidebar interactions
+
+### Utilities
+- **GuerrillaMailClient** - Temporary email handling for account verification
+  - `createTempEmail()` - Creates temporary email address
+  - `getVerificationCode()` - Retrieves verification emails
+  - `cleanup()` - Cleans up temporary email resources
+
+### World Extension
+- **ExternalServicesWorld** - Shared state management for test scenarios
+
+## Example Implementation
+
+```typescript
+// In your test files
+import { test, expect } from '@playwright/test';
+import { KindeAuthService, StripeService, GuerrillaMailClient } from './external-services/dist/index';
+
+test.describe('External Services Integration', () => {
+  let authService: KindeAuthService;
+  let stripeService: StripeService;
+  let tempEmail: GuerrillaMailClient;
+
+  test.beforeEach(async () => {
+    authService = new KindeAuthService();
+    stripeService = new StripeService();
+  });
+
+  test('should create account and upgrade subscription', async () => {
+    // Create temporary email for account verification
+    tempEmail = new GuerrillaMailClient();
+    const email = await tempEmail.createTempEmail();
+    
+    // Register new account
+    await authService.register(email, 'John', 'Doe');
+    
+    // Verify email
+    const verificationCode = await tempEmail.getVerificationCode();
+    await authService.verifyEmail(verificationCode);
+    
+    // Upgrade subscription
+    await stripeService.upgradeSubscription('premium');
+    
+    // Verify subscription status
+    const subscription = await stripeService.getCurrentSubscription();
+    expect(subscription.status).toBe('active');
+    
+    // Cleanup
+    await tempEmail.cleanup();
+  });
+
+  test('should handle login with existing account', async () => {
+    const result = await authService.login('user@example.com', 'password123');
+    expect(result.success).toBe(true);
+  });
+});
+```
+
+## Update Submodule
+
+```bash
+# Update to latest
+git submodule update --remote external-services
+
+# Build updated library
+cd external-services && npm run build && cd ..
+
+# Commit update
+git add external-services
+git commit -m "Update external-services submodule"
+```
+
+## CI/CD
+
+### Bitbucket Pipelines
+
+```yaml
+script:
+  - git submodule update --init --recursive
+  - npm install
+  - cd external-services && npm install && npm run build && cd ..
+  - npm test
+```
+
+## Dependencies
+
+The library requires the following peer dependencies:
+- `@playwright/test` ^1.40.0
+- `axios-cookiejar-support` ^6.0.2
+- `dotenv` ^16.4.5
+- `tough-cookie` ^5.1.2
+
+## Troubleshooting
+
+### Submodule Not Found
+```bash
+git submodule update --init --recursive
+```
+
+### Import Errors
+```bash
+cd external-services && npm run build && cd ..
+```
+
+### Missing Dependencies
+```bash
+npm install @playwright/test axios-cookiejar-support dotenv tough-cookie
+```
+
+## Development
+
+```bash
+npm install
+npm run build
+``` 

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { KindeAuthService } from './services/KindeAuthService';
+export { StripeService } from './services/StripeService';
+export { LoginPage } from './pages/kinde/LoginPage';
+export { RegisterPage } from './pages/kinde/RegisterPage';
+export { PasswordSetupPage } from './pages/kinde/PasswordSetupPage';
+export { ConfirmCodePage } from './pages/kinde/ConfirmCodePage';
+export { CurrentSubscriptionPage } from './pages/stripe/CurrentSubscriptionPage';
+export { UpdateSubscriptionPage, PlanType } from './pages/stripe/UpdateSubscriptionPage';
+export { UpdatePaymentMethodPage } from './pages/stripe/UpdatePaymentMethodPage';
+export { ConfirmUpdatePage } from './pages/stripe/ConfirmUpdatePage';
+export { LeftPanelPage } from './pages/stripe/LeftPanelPage';
+export { GuerrillaMailClient } from './utils/temp-email-utils';
+export type { Page, BrowserContext, Locator } from 'playwright/test';

package/dist/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuerrillaMailClient = exports.LeftPanelPage = exports.ConfirmUpdatePage = exports.UpdatePaymentMethodPage = exports.UpdateSubscriptionPage = exports.CurrentSubscriptionPage = exports.ConfirmCodePage = exports.PasswordSetupPage = exports.RegisterPage = exports.LoginPage = exports.StripeService = exports.KindeAuthService = void 0;
+// Export services
+var KindeAuthService_1 = require("./services/KindeAuthService");
+Object.defineProperty(exports, "KindeAuthService", { enumerable: true, get: function () { return KindeAuthService_1.KindeAuthService; } });
+var StripeService_1 = require("./services/StripeService");
+Object.defineProperty(exports, "StripeService", { enumerable: true, get: function () { return StripeService_1.StripeService; } });
+// Export all Kinde pages
+var LoginPage_1 = require("./pages/kinde/LoginPage");
+Object.defineProperty(exports, "LoginPage", { enumerable: true, get: function () { return LoginPage_1.LoginPage; } });
+var RegisterPage_1 = require("./pages/kinde/RegisterPage");
+Object.defineProperty(exports, "RegisterPage", { enumerable: true, get: function () { return RegisterPage_1.RegisterPage; } });
+var PasswordSetupPage_1 = require("./pages/kinde/PasswordSetupPage");
+Object.defineProperty(exports, "PasswordSetupPage", { enumerable: true, get: function () { return PasswordSetupPage_1.PasswordSetupPage; } });
+var ConfirmCodePage_1 = require("./pages/kinde/ConfirmCodePage");
+Object.defineProperty(exports, "ConfirmCodePage", { enumerable: true, get: function () { return ConfirmCodePage_1.ConfirmCodePage; } });
+// Export all Stripe pages
+var CurrentSubscriptionPage_1 = require("./pages/stripe/CurrentSubscriptionPage");
+Object.defineProperty(exports, "CurrentSubscriptionPage", { enumerable: true, get: function () { return CurrentSubscriptionPage_1.CurrentSubscriptionPage; } });
+var UpdateSubscriptionPage_1 = require("./pages/stripe/UpdateSubscriptionPage");
+Object.defineProperty(exports, "UpdateSubscriptionPage", { enumerable: true, get: function () { return UpdateSubscriptionPage_1.UpdateSubscriptionPage; } });
+var UpdatePaymentMethodPage_1 = require("./pages/stripe/UpdatePaymentMethodPage");
+Object.defineProperty(exports, "UpdatePaymentMethodPage", { enumerable: true, get: function () { return UpdatePaymentMethodPage_1.UpdatePaymentMethodPage; } });
+var ConfirmUpdatePage_1 = require("./pages/stripe/ConfirmUpdatePage");
+Object.defineProperty(exports, "ConfirmUpdatePage", { enumerable: true, get: function () { return ConfirmUpdatePage_1.ConfirmUpdatePage; } });
+var LeftPanelPage_1 = require("./pages/stripe/LeftPanelPage");
+Object.defineProperty(exports, "LeftPanelPage", { enumerable: true, get: function () { return LeftPanelPage_1.LeftPanelPage; } });
+// Export utilities
+var temp_email_utils_1 = require("./utils/temp-email-utils");
+Object.defineProperty(exports, "GuerrillaMailClient", { enumerable: true, get: function () { return temp_email_utils_1.GuerrillaMailClient; } });

package/dist/pages/kinde/ConfirmCodePage.d.ts

@@ -0,0 +1,12 @@
+import { Page, Locator } from '@playwright/test';
+export declare class ConfirmCodePage {
+    readonly page: Page;
+    readonly pageTitle: Locator;
+    readonly codeInput: Locator;
+    readonly continueButton: Locator;
+    constructor(page: Page);
+    enterConfirmationCode(code: string): Promise<void>;
+    clickContinue(): Promise<void>;
+    submitConfirmationCode(code: string): Promise<void>;
+    isOnConfirmCodePage(): Promise<void>;
+}

package/dist/pages/kinde/ConfirmCodePage.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfirmCodePage = void 0;
+const test_1 = require("@playwright/test");
+class ConfirmCodePage {
+    constructor(page) {
+        this.page = page;
+        this.pageTitle = page.locator('h1:has-text("Almost there — check your inbox")');
+        this.codeInput = page.locator('input[name="p_confirmation_code"]');
+        this.continueButton = page.locator('button[type="submit"]:has-text("Continue")');
+    }
+    async enterConfirmationCode(code) {
+        await this.codeInput.fill(code);
+    }
+    async clickContinue() {
+        await this.continueButton.click();
+    }
+    async submitConfirmationCode(code) {
+        await this.enterConfirmationCode(code);
+        await this.clickContinue();
+    }
+    async isOnConfirmCodePage() {
+        await (0, test_1.expect)(this.pageTitle).toBeVisible();
+        await (0, test_1.expect)(this.codeInput).toBeVisible();
+        await (0, test_1.expect)(this.continueButton).toBeVisible();
+    }
+}
+exports.ConfirmCodePage = ConfirmCodePage;

package/dist/pages/kinde/LoginPage.d.ts

@@ -0,0 +1,16 @@
+import { Locator, Page } from '@playwright/test';
+export declare class LoginPage {
+    readonly page: Page;
+    readonly emailInput: Locator;
+    readonly nextButton: Locator;
+    readonly passwordInput: Locator;
+    readonly email_not_exists: Locator;
+    readonly createAccountLink: Locator;
+    constructor(page: Page);
+    navigate(): Promise<void>;
+    enterEmail(email: string): Promise<void>;
+    enterPassword(password: string): Promise<void>;
+    getEmailNotExistsMessage(): Promise<string | null>;
+    login(email: string, password?: string): Promise<void>;
+    goToRegisterPage(): Promise<void>;
+}

package/dist/pages/kinde/LoginPage.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoginPage = void 0;
+class LoginPage {
+    constructor(page) {
+        this.page = page;
+        this.emailInput = page.locator('#sign_up_sign_in_credentials_p_email');
+        this.nextButton = page.locator('.kinde-button.kinde-button-variant-primary');
+        this.passwordInput = page.locator('#verify_password_p_password');
+        this.email_not_exists = page.locator('#sign_up_sign_in_credentials_p_email_error_msg');
+        this.createAccountLink = page.locator('.kinde-text-link[href*="register"]');
+    }
+    async navigate() {
+        await this.page.goto('/login');
+    }
+    async enterEmail(email) {
+        await this.emailInput.fill(email);
+        await this.nextButton.click();
+        await this.page.waitForTimeout(2000);
+    }
+    async enterPassword(password) {
+        await this.passwordInput.fill(password);
+        await this.nextButton.click();
+        await this.page.waitForTimeout(3000);
+    }
+    async getEmailNotExistsMessage() {
+        return await this.email_not_exists.textContent();
+    }
+    async login(email, password) {
+        if (!email) {
+            throw new Error(`${email} is not set`);
+        }
+        await this.enterEmail(email);
+        if (password) {
+            await this.enterPassword(password);
+        }
+    }
+    async goToRegisterPage() {
+        await this.createAccountLink.click();
+    }
+}
+exports.LoginPage = LoginPage;

package/dist/pages/kinde/PasswordSetupPage.d.ts

@@ -0,0 +1,14 @@
+import { Page, Locator } from '@playwright/test';
+export declare class PasswordSetupPage {
+    readonly page: Page;
+    readonly pageTitle: Locator;
+    readonly passwordInput: Locator;
+    readonly confirmPasswordInput: Locator;
+    readonly continueButton: Locator;
+    constructor(page: Page);
+    enterPassword(password: string): Promise<void>;
+    enterConfirmPassword(password: string): Promise<void>;
+    clickContinue(): Promise<void>;
+    submitPasswordForm(password: string): Promise<void>;
+    isOnPasswordSetupPage(): Promise<void>;
+}

package/dist/pages/kinde/PasswordSetupPage.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PasswordSetupPage = void 0;
+const test_1 = require("@playwright/test");
+class PasswordSetupPage {
+    constructor(page) {
+        this.page = page;
+        this.pageTitle = page.locator('h1:has-text("Password setup")');
+        this.passwordInput = page.locator('input[name="p_first_password"]');
+        this.confirmPasswordInput = page.locator('input[name="p_second_password"]');
+        this.continueButton = page.locator('button[type="submit"]:has-text("Continue")');
+    }
+    async enterPassword(password) {
+        await this.passwordInput.fill(password);
+    }
+    async enterConfirmPassword(password) {
+        await this.confirmPasswordInput.fill(password);
+    }
+    async clickContinue() {
+        await this.continueButton.click();
+    }
+    async submitPasswordForm(password) {
+        await this.enterPassword(password);
+        await this.enterConfirmPassword(password);
+        await this.clickContinue();
+    }
+    async isOnPasswordSetupPage() {
+        await (0, test_1.expect)(this.pageTitle).toBeVisible();
+        await (0, test_1.expect)(this.passwordInput).toBeVisible();
+        await (0, test_1.expect)(this.confirmPasswordInput).toBeVisible();
+        await (0, test_1.expect)(this.continueButton).toBeVisible();
+    }
+}
+exports.PasswordSetupPage = PasswordSetupPage;

package/dist/pages/kinde/RegisterPage.d.ts

@@ -0,0 +1,20 @@
+import { Page, Locator } from '@playwright/test';
+export declare class RegisterPage {
+    readonly page: Page;
+    readonly firstNameInput: Locator;
+    readonly lastNameInput: Locator;
+    readonly emailInput: Locator;
+    readonly marketingOptInCheckbox: Locator;
+    readonly acceptPoliciesCheckbox: Locator;
+    readonly createAccountButton: Locator;
+    constructor(page: Page);
+    navigate(): Promise<void>;
+    enterFirstName(firstName: string): Promise<void>;
+    enterLastName(lastName: string): Promise<void>;
+    enterEmail(email: string): Promise<void>;
+    checkMarketingOptIn(): Promise<void>;
+    checkAcceptPolicies(): Promise<void>;
+    clickCreateAccount(): Promise<void>;
+    fillAndSubmitCreateAccountForm(firstName: string, lastName: string, email: string, acceptMarketing?: boolean): Promise<void>;
+    isOnRegisterPage(): Promise<void>;
+}

package/dist/pages/kinde/RegisterPage.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegisterPage = void 0;
+const test_1 = require("@playwright/test");
+class RegisterPage {
+    constructor(page) {
+        this.page = page;
+        this.firstNameInput = page.locator('input[name="p_first_name"]');
+        this.lastNameInput = page.locator('input[name="p_last_name"]');
+        this.emailInput = page.locator('input[name="p_email"]');
+        this.marketingOptInCheckbox = page.locator('input[name="p_kp_usr_is_marketing_opt_in"]');
+        this.acceptPoliciesCheckbox = page.locator('input[name="p_has_clickwrap_accepted"]');
+        this.createAccountButton = page.locator('button[type="submit"]:has-text("Create your account")');
+    }
+    async navigate() {
+        await this.page.goto('/auth/register');
+        await this.isOnRegisterPage();
+    }
+    async enterFirstName(firstName) {
+        await this.firstNameInput.fill(firstName);
+    }
+    async enterLastName(lastName) {
+        await this.lastNameInput.fill(lastName);
+    }
+    async enterEmail(email) {
+        await this.emailInput.fill(email);
+    }
+    async checkMarketingOptIn() {
+        await this.marketingOptInCheckbox.check();
+    }
+    async checkAcceptPolicies() {
+        await this.acceptPoliciesCheckbox.check();
+    }
+    async clickCreateAccount() {
+        await this.createAccountButton.click();
+    }
+    async fillAndSubmitCreateAccountForm(firstName, lastName, email, acceptMarketing = false) {
+        await this.enterFirstName(firstName);
+        await this.enterLastName(lastName);
+        await this.enterEmail(email);
+        if (acceptMarketing) {
+            await this.checkMarketingOptIn();
+        }
+        await this.checkAcceptPolicies();
+        await this.clickCreateAccount();
+    }
+    async isOnRegisterPage() {
+        await (0, test_1.expect)(this.firstNameInput).toBeVisible();
+        await (0, test_1.expect)(this.lastNameInput).toBeVisible();
+        await (0, test_1.expect)(this.emailInput).toBeVisible();
+        await (0, test_1.expect)(this.marketingOptInCheckbox).toBeVisible();
+        await (0, test_1.expect)(this.acceptPoliciesCheckbox).toBeVisible();
+        await (0, test_1.expect)(this.createAccountButton).toBeVisible();
+    }
+}
+exports.RegisterPage = RegisterPage;

package/dist/pages/stripe/ConfirmUpdatePage.d.ts

@@ -0,0 +1,9 @@
+import { Page, Locator } from '@playwright/test';
+export declare class ConfirmUpdatePage {
+    readonly page: Page;
+    readonly pageContainer: Locator;
+    readonly confirmButton: Locator;
+    constructor(page: Page);
+    clickConfirm(): Promise<void>;
+    isOnConfirmUpdatePage(): Promise<void>;
+}

package/dist/pages/stripe/ConfirmUpdatePage.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfirmUpdatePage = void 0;
+const test_1 = require("@playwright/test");
+class ConfirmUpdatePage {
+    constructor(page) {
+        this.page = page;
+        this.pageContainer = page
+            .locator('[data-testid="page-container-main"], .Box-root, [data-testid="confirm-container"]')
+            .first();
+        this.confirmButton = page.locator('button:has-text("Confirm"), ' +
+            '[data-testid="confirm-button"], ' +
+            '[data-test="confirm-button"], ' +
+            'a:has-text("Confirm"), ' +
+            'button[type="submit"]:has-text("Confirm"), ' +
+            '.confirm-button, ' +
+            '#confirm-button');
+    }
+    async clickConfirm() {
+        await this.confirmButton.click();
+    }
+    async isOnConfirmUpdatePage() {
+        await (0, test_1.expect)(this.pageContainer).toBeVisible();
+        await (0, test_1.expect)(this.confirmButton).toBeVisible();
+    }
+}
+exports.ConfirmUpdatePage = ConfirmUpdatePage;

package/dist/pages/stripe/CurrentSubscriptionPage.d.ts

@@ -0,0 +1,11 @@
+import { Page, Locator } from '@playwright/test';
+export declare class CurrentSubscriptionPage {
+    readonly page: Page;
+    readonly pageContainer: Locator;
+    readonly planName: Locator;
+    readonly updateSubscriptionButton: Locator;
+    readonly currentSubscriptionPageTitle: Locator;
+    constructor(page: Page);
+    navigateToUpdateSubscription(): Promise<void>;
+    isOnCurrentSubscriptionPage(): Promise<void>;
+}

package/dist/pages/stripe/CurrentSubscriptionPage.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CurrentSubscriptionPage = void 0;
+const test_1 = require("@playwright/test");
+class CurrentSubscriptionPage {
+    constructor(page) {
+        this.page = page;
+        this.pageContainer = page.locator('[data-testid="page-container-main"]');
+        this.planName = page.locator('[class*="Text-fontSize--20"]:has-text("plan")').first();
+        this.updateSubscriptionButton = page.locator('[data-test="update-subscription"]');
+        this.currentSubscriptionPageTitle = page.locator('//span[text()= "Current subscription"]');
+    }
+    async navigateToUpdateSubscription() {
+        await this.updateSubscriptionButton.click();
+    }
+    async isOnCurrentSubscriptionPage() {
+        await (0, test_1.expect)(this.currentSubscriptionPageTitle).toBeVisible();
+    }
+}
+exports.CurrentSubscriptionPage = CurrentSubscriptionPage;

package/dist/pages/stripe/LeftPanelPage.d.ts

@@ -0,0 +1,11 @@
+import { Page, Locator } from '@playwright/test';
+export declare class LeftPanelPage {
+    readonly page: Page;
+    readonly panelContainer: Locator;
+    readonly emailAwesomeLogo: Locator;
+    readonly sandboxIndicator: Locator;
+    readonly businessTitle: Locator;
+    readonly returnToBusinessButton: Locator;
+    constructor(page: Page);
+    navigateBackToEmailAwesome(): Promise<void>;
+}

package/dist/pages/stripe/LeftPanelPage.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeftPanelPage = void 0;
+class LeftPanelPage {
+    constructor(page) {
+        this.page = page;
+        this.panelContainer = page.locator('div[style*="background-color: rgb(232, 245, 233)"]');
+        this.emailAwesomeLogo = page.locator('img[data-test="logo-img"]');
+        this.sandboxIndicator = page.locator('span:has-text("Sandbox")');
+        this.businessTitle = page.locator('span:has-text("Email Awesome")').first();
+        this.returnToBusinessButton = page.locator('[data-testid="return-to-business-link"]');
+    }
+    async navigateBackToEmailAwesome() {
+        await this.returnToBusinessButton.click();
+    }
+}
+exports.LeftPanelPage = LeftPanelPage;

package/dist/pages/stripe/UpdatePaymentMethodPage.d.ts

@@ -0,0 +1,11 @@
+import { Page, Locator } from '@playwright/test';
+export declare class UpdatePaymentMethodPage {
+    readonly page: Page;
+    readonly pageContainer: Locator;
+    readonly stripeIframe: Locator;
+    readonly continueButton: Locator;
+    constructor(page: Page);
+    clickContinue(): Promise<void>;
+    isOnUpdatePaymentMethodPage(): Promise<void>;
+    fillCardInformation(): Promise<void>;
+}

package/dist/pages/stripe/UpdatePaymentMethodPage.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdatePaymentMethodPage = void 0;
+const test_1 = require("@playwright/test");
+class UpdatePaymentMethodPage {
+    constructor(page) {
+        this.page = page;
+        this.pageContainer = page.locator('[data-testid="page-container-main"]').first();
+        this.stripeIframe = page.locator('iframe[src*="stripe.com"]').first();
+        this.continueButton = page.locator('button[data-testid="confirm"]');
+    }
+    async clickContinue() {
+        await this.continueButton.click();
+    }
+    async isOnUpdatePaymentMethodPage() {
+        await (0, test_1.expect)(this.pageContainer).toBeVisible();
+        await (0, test_1.expect)(this.stripeIframe).toBeVisible();
+        await (0, test_1.expect)(this.continueButton).toBeVisible();
+    }
+    async fillCardInformation() {
+        const cardNumber = '4242424242424242';
+        const expirationDate = '12/34';
+        const securityCode = '567';
+        try {
+            await this.stripeIframe.waitFor({ state: 'visible' });
+            // Get the iframe element and switch to it
+            const iframeElement = await this.stripeIframe.elementHandle();
+            if (!iframeElement) {
+                throw new Error('Stripe iframe not found');
+            }
+            // Switch to the iframe context
+            const iframePage = await iframeElement.contentFrame();
+            if (!iframePage) {
+                throw new Error('Could not access iframe content');
+            }
+            const cardNumberField = iframePage.locator('input[name="number"]');
+            const expirationDateField = iframePage.locator('input[name="expiry"]');
+            const securityCodeField = iframePage.locator('input[name="cvc"]');
+            await cardNumberField.fill(cardNumber);
+            await expirationDateField.fill(expirationDate);
+            await securityCodeField.fill(securityCode);
+            await this.page.bringToFront();
+        }
+        catch (error) {
+            console.error('Error filling card information:', error);
+            if (!cardNumber || !expirationDate || !securityCode) {
+                throw new Error(`Cannot use keyboard fallback - missing data: cardNumber=${cardNumber}, expirationDate=${expirationDate}, securityCode=${securityCode}`);
+            }
+            throw error;
+        }
+    }
+}
+exports.UpdatePaymentMethodPage = UpdatePaymentMethodPage;

package/dist/pages/stripe/UpdateSubscriptionPage.d.ts

@@ -0,0 +1,14 @@
+import { Page, Locator } from '@playwright/test';
+export type PlanType = 'lite' | 'basic' | 'growth' | 'pro' | 'business' | 'enterprise';
+export declare class UpdateSubscriptionPage {
+    readonly page: Page;
+    readonly pageContainer: Locator;
+    readonly planCardsContainer: Locator;
+    readonly continueButton: Locator;
+    readonly backButton: Locator;
+    readonly selectPlanButton: (planType: PlanType) => Locator;
+    constructor(page: Page);
+    selectPlan(planType: PlanType): Promise<void>;
+    clickContinue(): Promise<void>;
+    isOnUpdateSubscriptionPage(): Promise<void>;
+}

package/dist/pages/stripe/UpdateSubscriptionPage.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateSubscriptionPage = void 0;
+const test_1 = require("@playwright/test");
+class UpdateSubscriptionPage {
+    constructor(page) {
+        this.page = page;
+        this.pageContainer = page.locator('[data-testid="page-container-main"], .Box-root').first();
+        this.planCardsContainer = page.locator('[data-testid="pricing-table"]');
+        this.continueButton = page.locator('button:has-text("Continue"), [data-testid="continue-button"], a:has-text("Continue"), a[role="button"]:has-text("Continue")');
+        this.backButton = page.locator('button:has-text("Back"), [data-testid="back-button"], a:has-text("Back"), a[role="button"]:has-text("Back")');
+        this.selectPlanButton = (planType) => this.page.locator(`//div[contains(text(),'${planType.charAt(0).toUpperCase() + planType.slice(1)}')]/ancestor::div[@data-testid='pricing-table-card']//span[text()='Select']`);
+    }
+    async selectPlan(planType) {
+        await this.selectPlanButton(planType).click();
+    }
+    async clickContinue() {
+        await this.continueButton.click();
+    }
+    async isOnUpdateSubscriptionPage() {
+        await (0, test_1.expect)(this.pageContainer).toBeVisible();
+        await (0, test_1.expect)(this.planCardsContainer).toBeVisible();
+    }
+}
+exports.UpdateSubscriptionPage = UpdateSubscriptionPage;

package/dist/services/KindeAuthService.d.ts

@@ -0,0 +1,13 @@
+import { Page } from 'playwright/test';
+export declare class KindeAuthService {
+    private tempEmail?;
+    private verificationCode?;
+    private emailClient?;
+    private loginPage;
+    private registerPage;
+    private confirmCodePage;
+    private passwordSetupPage;
+    constructor(page: Page);
+    createAccountWithEmailVerification(): Promise<void>;
+    deleteTemporaryEmail(): Promise<void>;
+}

package/dist/services/KindeAuthService.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KindeAuthService = void 0;
+const ConfirmCodePage_1 = require("../pages/kinde/ConfirmCodePage");
+const LoginPage_1 = require("../pages/kinde/LoginPage");
+const PasswordSetupPage_1 = require("../pages/kinde/PasswordSetupPage");
+const RegisterPage_1 = require("../pages/kinde/RegisterPage");
+const temp_email_utils_1 = require("../utils/temp-email-utils");
+class KindeAuthService {
+    constructor(page) {
+        this.loginPage = new LoginPage_1.LoginPage(page);
+        this.registerPage = new RegisterPage_1.RegisterPage(page);
+        this.confirmCodePage = new ConfirmCodePage_1.ConfirmCodePage(page);
+        this.passwordSetupPage = new PasswordSetupPage_1.PasswordSetupPage(page);
+    }
+    async createAccountWithEmailVerification() {
+        await this.loginPage.navigate();
+        await this.loginPage.goToRegisterPage();
+        await this.registerPage.isOnRegisterPage();
+        this.emailClient = temp_email_utils_1.GuerrillaMailClient.createIsolatedClient();
+        this.tempEmail = await this.emailClient.createMail();
+        const firstName = 'Test';
+        const lastName = 'User';
+        await this.registerPage.fillAndSubmitCreateAccountForm(firstName, lastName, this.tempEmail, false // Don't accept marketing emails
+        );
+        await this.confirmCodePage.isOnConfirmCodePage();
+        const emailData = await this.emailClient.readMailBySubject(/Email verification code/i, 120000, // 2 minutes timeout
+        5000 // Check every 5 seconds
+        );
+        const codeMatch = emailData.mail_body?.match(/\b\d{6}\b/);
+        if (codeMatch) {
+            this.verificationCode = codeMatch[0];
+            await this.confirmCodePage.submitConfirmationCode(this.verificationCode);
+        }
+        else {
+            throw new Error('Could not extract verification code from email');
+        }
+        await this.passwordSetupPage.isOnPasswordSetupPage();
+        const password = 'TestPassword123!';
+        await this.passwordSetupPage.submitPasswordForm(password);
+    }
+    async deleteTemporaryEmail() {
+        if (this.tempEmail) {
+            try {
+                this.tempEmail = undefined;
+                this.verificationCode = undefined;
+                this.emailClient = undefined;
+            }
+            catch (error) {
+                console.warn("Could not clean up temporary email:", error);
+            }
+        }
+    }
+}
+exports.KindeAuthService = KindeAuthService;

package/dist/services/StripeService.d.ts

@@ -0,0 +1,12 @@
+import { Page } from 'playwright/test';
+export declare class StripeService {
+    private page;
+    private stripeCurrentSubscriptionPage;
+    private stripeUpdateSubscriptionPage;
+    private stripeConfirmUpdatePage;
+    private stripeUpdatePaymentMethodPage;
+    private stripeLeftPanelPage;
+    constructor(page: Page);
+    upgradePlan(planType: string): Promise<void>;
+    completePayment(): Promise<void>;
+}

package/dist/services/StripeService.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StripeService = void 0;
+const test_1 = require("playwright/test");
+const ConfirmUpdatePage_1 = require("../pages/stripe/ConfirmUpdatePage");
+const CurrentSubscriptionPage_1 = require("../pages/stripe/CurrentSubscriptionPage");
+const LeftPanelPage_1 = require("../pages/stripe/LeftPanelPage");
+const UpdatePaymentMethodPage_1 = require("../pages/stripe/UpdatePaymentMethodPage");
+const UpdateSubscriptionPage_1 = require("../pages/stripe/UpdateSubscriptionPage");
+class StripeService {
+    constructor(page) {
+        this.page = page;
+        this.stripeCurrentSubscriptionPage = new CurrentSubscriptionPage_1.CurrentSubscriptionPage(page);
+        this.stripeUpdateSubscriptionPage = new UpdateSubscriptionPage_1.UpdateSubscriptionPage(page);
+        this.stripeConfirmUpdatePage = new ConfirmUpdatePage_1.ConfirmUpdatePage(page);
+        this.stripeUpdatePaymentMethodPage = new UpdatePaymentMethodPage_1.UpdatePaymentMethodPage(page);
+        this.stripeLeftPanelPage = new LeftPanelPage_1.LeftPanelPage(page);
+    }
+    async upgradePlan(planType) {
+        await (0, test_1.expect)(this.page).toHaveURL(/billing\.stripe\.com/, { timeout: 20000 });
+        await this.page.waitForLoadState('domcontentloaded');
+        await this.stripeCurrentSubscriptionPage.navigateToUpdateSubscription();
+        await this.stripeUpdateSubscriptionPage.isOnUpdateSubscriptionPage();
+        const planTypeFormatted = planType.toLowerCase();
+        await this.stripeUpdateSubscriptionPage.selectPlan(planTypeFormatted);
+        await this.stripeUpdateSubscriptionPage.clickContinue();
+        await this.stripeConfirmUpdatePage.isOnConfirmUpdatePage();
+        await this.stripeConfirmUpdatePage.clickConfirm();
+    }
+    async completePayment() {
+        await (0, test_1.expect)(this.page).toHaveURL(/update-payment-method/, { timeout: 10000 });
+        await this.stripeUpdatePaymentMethodPage.isOnUpdatePaymentMethodPage();
+        await this.stripeUpdatePaymentMethodPage.fillCardInformation();
+        await this.stripeUpdatePaymentMethodPage.clickContinue();
+        await this.stripeCurrentSubscriptionPage.isOnCurrentSubscriptionPage();
+        await this.stripeLeftPanelPage.navigateBackToEmailAwesome();
+        await (0, test_1.expect)(this.page).toHaveURL(/emailawesome\.com/, { timeout: 10000 });
+        await (0, test_1.expect)(this.page).not.toHaveURL(/stripe\.com/);
+    }
+}
+exports.StripeService = StripeService;

package/dist/utils/temp-email-utils.d.ts

@@ -0,0 +1,49 @@
+/** Structure returned by Guerrilla Mail for a single message */
+export interface GuerrillaEmail {
+    mail_id: string;
+    mail_subject: string;
+    mail_from: string;
+    mail_excerpt?: string;
+    mail_body?: string;
+    mail_timestamp: number;
+}
+declare class GuerrillaMailClient {
+    private readonly API_URL;
+    private readonly ip;
+    private readonly agent;
+    private seq;
+    private emailAddress;
+    private client;
+    constructor();
+    /**
+     * Function 1: Crea un email temporal. Si se pasa un alias se fuerza ese usuario.
+     * @param alias Nombre de usuario deseado (sin dominio).
+     * @returns Dirección de email completa.
+     */
+    createMail(alias?: string): Promise<string>;
+    /**
+     * Function 2: Lee la bandeja y devuelve el email MÁS RECIENTE cuyo subject matchee con subjectRegex.
+     * Hace polling hasta timeout.
+     * @param subjectRegex Expresión regular a matchear con el asunto.
+     * @param timeoutMs Tiempo máximo a esperar (ms).
+     * @param pollMs Intervalo entre consultas (ms).
+     */
+    readMailBySubject(subjectRegex: RegExp, timeoutMs?: number, pollMs?: number): Promise<GuerrillaEmail>;
+    /**
+     * Function 3: Elimina un correo específico del servidor.
+     * @param mailId ID retornado por la API (mail_id).
+     */
+    deleteMail(mailId: string): Promise<void>;
+    /** Helper interno para descargar cuerpo completo */
+    private fetchEmail;
+    /**
+     * Function 4: Crea una nueva instancia de email client para aislamiento entre escenarios
+     */
+    static createIsolatedClient(): GuerrillaMailClient;
+    /**
+     * Function 5: Elimina todos los emails del buzón actual
+     */
+    clearInbox(): Promise<void>;
+}
+export declare const email: GuerrillaMailClient;
+export { GuerrillaMailClient };

package/dist/utils/temp-email-utils.js

@@ -0,0 +1,147 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuerrillaMailClient = exports.email = void 0;
+const axios_1 = __importDefault(require("axios"));
+const axios_cookiejar_support_1 = require("axios-cookiejar-support");
+const tough_cookie_1 = require("tough-cookie");
+class GuerrillaMailClient {
+    constructor() {
+        this.API_URL = 'https://api.guerrillamail.com/ajax.php';
+        this.ip = '127.0.0.1';
+        this.agent = encodeURIComponent('qa-automation-utils/1.0');
+        this.seq = 0;
+        this.emailAddress = '';
+        const jar = new tough_cookie_1.CookieJar();
+        this.client = (0, axios_cookiejar_support_1.wrapper)(axios_1.default.create({
+            jar,
+            withCredentials: true,
+            headers: {
+                // Recommended to identify politely
+                'User-Agent': 'qa-automation-utils/1.0',
+            },
+        }));
+    }
+    /**
+     * Function 1: Crea un email temporal. Si se pasa un alias se fuerza ese usuario.
+     * @param alias Nombre de usuario deseado (sin dominio).
+     * @returns Dirección de email completa.
+     */
+    async createMail(alias) {
+        if (alias) {
+            const { data } = await this.client.get(this.API_URL, {
+                params: {
+                    f: 'set_email_user',
+                    email_user: alias,
+                    ip: this.ip,
+                    agent: this.agent,
+                },
+            });
+            this.emailAddress = data.email_addr;
+        }
+        else {
+            const { data } = await this.client.get(this.API_URL, {
+                params: {
+                    f: 'get_email_address',
+                    ip: this.ip,
+                    agent: this.agent,
+                },
+            });
+            this.emailAddress = data.email_addr;
+        }
+        return this.emailAddress;
+    }
+    /**
+     * Function 2: Lee la bandeja y devuelve el email MÁS RECIENTE cuyo subject matchee con subjectRegex.
+     * Hace polling hasta timeout.
+     * @param subjectRegex Expresión regular a matchear con el asunto.
+     * @param timeoutMs Tiempo máximo a esperar (ms).
+     * @param pollMs Intervalo entre consultas (ms).
+     */
+    async readMailBySubject(subjectRegex, timeoutMs = 60000, pollMs = 5000) {
+        const start = Date.now();
+        while (Date.now() - start < timeoutMs) {
+            const { data } = await this.client.get(this.API_URL, {
+                params: {
+                    f: 'check_email',
+                    seq: this.seq,
+                    ip: this.ip,
+                    agent: this.agent,
+                },
+            });
+            this.seq = data.seq ?? this.seq;
+            const list = data.list ?? [];
+            // Filtrar emails que matchean el subject
+            const matches = list.filter(m => subjectRegex.test(m.mail_subject));
+            if (matches.length > 0) {
+                // Ordenar por timestamp descendente (más reciente primero)
+                matches.sort((a, b) => b.mail_timestamp - a.mail_timestamp);
+                // Tomar el más reciente
+                const mostRecent = matches[0];
+                const full = await this.fetchEmail(mostRecent.mail_id);
+                return full;
+            }
+            await new Promise(r => setTimeout(r, pollMs));
+        }
+        throw new Error(`Timeout (${timeoutMs} ms) esperando un email con asunto que matchee ${subjectRegex}`);
+    }
+    /**
+     * Function 3: Elimina un correo específico del servidor.
+     * @param mailId ID retornado por la API (mail_id).
+     */
+    async deleteMail(mailId) {
+        await this.client.get(this.API_URL, {
+            params: {
+                f: 'del_email',
+                email_ids: `[${mailId}]`, // formato aceptado por la API
+                ip: this.ip,
+                agent: this.agent,
+            },
+        });
+    }
+    /** Helper interno para descargar cuerpo completo */
+    async fetchEmail(mailId) {
+        const { data } = await this.client.get(this.API_URL, {
+            params: {
+                f: 'fetch_email',
+                email_id: mailId,
+                ip: this.ip,
+                agent: this.agent,
+            },
+        });
+        return data;
+    }
+    /**
+     * Function 4: Crea una nueva instancia de email client para aislamiento entre escenarios
+     */
+    static createIsolatedClient() {
+        return new GuerrillaMailClient();
+    }
+    /**
+     * Function 5: Elimina todos los emails del buzón actual
+     */
+    async clearInbox() {
+        const { data } = await this.client.get(this.API_URL, {
+            params: {
+                f: 'check_email',
+                seq: this.seq,
+                ip: this.ip,
+                agent: this.agent,
+            },
+        });
+        const list = data.list ?? [];
+        // Eliminar todos los emails uno por uno
+        for (const email of list) {
+            try {
+                await this.deleteMail(email.mail_id);
+            }
+            catch (error) {
+                console.warn(`Could not delete email ${email.mail_id}:`, error);
+            }
+        }
+    }
+}
+exports.GuerrillaMailClient = GuerrillaMailClient;
+exports.email = new GuerrillaMailClient();

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "external-services-automation",
+  "version": "1.0.0",
+  "description": "External services automation library for Playwright and Cucumber",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/",
+    "README.md",
+    "package.json"
+  ],
+  "keywords": [
+    "playwright",
+    "automation",
+    "testing",
+    "kinde",
+    "stripe",
+    "external-services"
+  ],
+  "author": "Email Awesome Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://bitbucket.org/connectist/external-services-automation.git"
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "clean": "rm -rf dist",
+    "prebuild": "npm run clean",
+    "test": "echo \"No tests specified\" && exit 0",
+    "prepublishOnly": "npm run build"
+  },
+  "peerDependencies": {
+    "@playwright/test": "^1.40.0",
+    "axios-cookiejar-support": "^6.0.2",
+    "dotenv": "^16.4.5",
+    "tough-cookie": "^5.1.2"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.40.0",
+    "@types/node": "^22.5.4",
+    "typescript": "^5.5.4"
+  }
+}