Hey guys! 👋 Today, let's dive into automating PSEi (Philippine Stock Exchange Index) API tests using Playwright. If you're working with financial data or building applications that rely on PSEi data, having robust automated tests is super crucial. This guide will walk you through setting up Playwright, writing API tests, and ensuring your data is accurate and reliable. Let's get started!

Why Automate PSEi API Tests?

Before we jump into the how-to, let's quickly cover why automating your PSEi API tests is a smart move. In the fast-paced world of finance, data accuracy and reliability are paramount. Automated tests ensure that your application consistently receives and processes the correct data from the PSEi API. By automating these tests, you can catch discrepancies early, reduce manual effort, and deploy updates with confidence. Imagine manually checking API responses every time there's a new release—sounds like a nightmare, right? Automation to the rescue!

First and foremost, automation saves time. Manual testing is repetitive and time-consuming. With Playwright, you can set up tests that run automatically, freeing up your time for more important tasks like building new features or optimizing existing ones. Secondly, automation improves accuracy. Humans make mistakes; machines, when programmed correctly, do not. Automated tests provide consistent and reliable results, reducing the risk of human error. Thirdly, automation enhances test coverage. You can easily create a comprehensive suite of tests that cover various scenarios and edge cases, ensuring that your application is thoroughly tested. Finally, automation enables continuous integration and continuous deployment (CI/CD). Automated tests can be integrated into your CI/CD pipeline, allowing you to automatically test your application whenever changes are made, ensuring that new code doesn't break existing functionality.

Setting Up Playwright

Okay, let's get our hands dirty! First, you'll need to set up Playwright in your project. If you haven't already, make sure you have Node.js installed. Then, open your terminal and run:

npm init -y
npm install -D @playwright/test
npx playwright install

This will initialize a new Node.js project, install Playwright, and download the necessary browsers. Once that's done, you're ready to start writing your first test.

Configuring Playwright

Next, you might want to configure Playwright to suit your project's needs. Create a playwright.config.js file in your project root. Here’s a basic configuration:

// playwright.config.js
/** @type {import('@playwright/test').PlaywrightTestConfig} */
const config = {
  use: {
    baseURL: 'https://your-psei-api-endpoint.com',
    headless: true, // Run tests in headless mode for CI/CD
    viewport: { width: 1280, height: 720 },
    ignoreHTTPSErrors: true,
  },
  reporter: 'list',
};

module.exports = config;

Replace 'https://your-psei-api-endpoint.com' with the actual base URL of the PSEi API you're testing. Setting headless: true is great for CI/CD environments, as it runs tests without a visible browser. The reporter: 'list' option provides a detailed list of test results in the console.

Writing Your First API Test

Now for the fun part: writing your first API test! Create a new file, psei.spec.js, and add the following code:

// psei.spec.js
const { test, expect } = require('@playwright/test');

test('Get PSEi data', async ({ request }) => {
  const response = await request.get('/api/psei');
  expect(response.status()).toBe(200);
  const responseBody = await response.json();
  expect(responseBody).toBeDefined();
  expect(Array.isArray(responseBody)).toBe(true);
});

In this test, we're sending a GET request to the /api/psei endpoint and asserting that the response status is 200 (OK). We're also checking that the response body is defined and is an array. This is a basic test, but it gives you an idea of how to structure your tests.

Running Your Test

To run your test, simply execute:

npx playwright test

Playwright will run the test and output the results in the console. If everything is set up correctly, you should see a passing test!

Advanced API Testing with Playwright

So, you've got the basics down. Now, let's crank things up a notch! Playwright is more than just making simple GET requests. You can handle different HTTP methods, validate response schemas, and even mock API endpoints. Here's how:

Handling Different HTTP Methods

APIs often use various HTTP methods like POST, PUT, DELETE, etc. Playwright makes it easy to handle these. For example, to send a POST request, you can do:

test('Post data to PSEi API', async ({ request }) => {
  const payload = { key: 'value' };
  const response = await request.post('/api/psei', { data: payload });
  expect(response.status()).toBe(201); // Assuming 201 Created
  const responseBody = await response.json();
  expect(responseBody.id).toBeDefined();
});

Here, we're sending a POST request to /api/psei with a JSON payload. We're asserting that the response status is 201 (Created) and that the response body contains an id field.

Validating Response Schemas

Ensuring that the API response follows a specific schema is crucial. You can use libraries like ajv (Another JSON Validator) to validate the response against a JSON schema. First, install ajv:

npm install ajv

Then, in your test:

const Ajv = require('ajv');
const ajv = new Ajv();

test('Validate PSEi data schema', async ({ request }) => {
  const response = await request.get('/api/psei');
  const responseBody = await response.json();

  const schema = {
    type: 'array',
    items: {
      type: 'object',
      properties: {
        symbol: { type: 'string' },
        price: { type: 'number' },
        volume: { type: 'integer' },
      },
      required: ['symbol', 'price', 'volume'],
    },
  };

  const validate = ajv.compile(schema);
  const valid = validate(responseBody);
  expect(valid).toBe(true);
  if (!valid) console.log(validate.errors);
});

In this test, we're defining a JSON schema that the API response should adhere to. We then use ajv to validate the response body against this schema. If the response doesn't match the schema, the test will fail, and the errors will be logged.

Mocking API Endpoints

Sometimes, you might want to mock API endpoints to simulate different scenarios or to test your application in isolation. Playwright provides a powerful API mocking feature. Here’s how you can use it:

test('Mock PSEi API response', async ({ page }) => {
  await page.route('/api/psei', async route => {
    await route.fulfill({
      status: 200,
      contentType: 'application/json',
      body: JSON.stringify([
        { symbol: 'TEL', price: 1200, volume: 1000 },
        { symbol: 'ALI', price: 40, volume: 5000 },
      ]),
    });
  });

  // Navigate to a page that uses the API
  await page.goto('/your-page');

  // Assert that the data is displayed correctly
  await expect(page.locator('.symbol').first()).toHaveText('TEL');
});

In this test, we're using page.route to intercept requests to /api/psei and fulfill them with a mocked response. This allows you to test your application's behavior without actually hitting the real API.

Best Practices for API Automation

Alright, you're practically a Playwright pro now! Let's wrap up with some best practices to ensure your API automation efforts are top-notch:

Keep Tests Isolated

Each test should be independent and not rely on the state of other tests. This makes your tests more reliable and easier to debug. Use setup and teardown hooks to ensure a clean state before and after each test.

Use Descriptive Test Names

Your test names should clearly describe what the test is verifying. This makes it easier to understand the purpose of each test and to identify failures.

Parameterize Tests

If you need to test the same functionality with different inputs, use parameterized tests. This reduces code duplication and makes your tests more maintainable.

Store API Keys and Secrets Securely

Never hardcode API keys or secrets in your tests. Use environment variables or a secure configuration management system to store sensitive information.

Monitor Test Performance

Keep an eye on how long your tests take to run. Slow tests can slow down your development process. Optimize your tests to run as quickly as possible.

Conclusion

So there you have it, folks! Automating your PSEi API tests with Playwright can significantly improve the reliability and accuracy of your applications. By following the steps and best practices outlined in this guide, you'll be well on your way to building a robust and efficient testing framework. Happy testing, and may your APIs always return the correct data! 😉

Remember, the key to successful automation is continuous learning and adaptation. As Playwright evolves and your application grows, keep refining your tests to stay ahead of the game. Good luck!