playwright-snowflake.md

playwright-snowflake.md

1. Cài đặt dependencies

npm install @playwright/test playwright
npm install snowflake-sdk
npm install dotenv
npm install --save-dev @types/snowflake-sdk @types/node typescript

2. Kết nối Snowflake với snowflake-sdk

// snowflake-connection.ts
import * as snowflake from 'snowflake-sdk';
import dotenv from 'dotenv';

dotenv.config();

interface SnowflakeConfig {
  account: string;
  username: string;
  password: string;
  warehouse?: string;
  database?: string;
  schema?: string;
  role?: string;
}

export class SnowflakeClient {
  private connection: snowflake.Connection | null = null;
  private config: SnowflakeConfig;

  constructor(config?: SnowflakeConfig) {
    this.config = config || {
      account: process.env.SNOWFLAKE_ACCOUNT!,
      username: process.env.SNOWFLAKE_USER!,
      password: process.env.SNOWFLAKE_PASSWORD!,
      warehouse: process.env.SNOWFLAKE_WAREHOUSE,
      database: process.env.SNOWFLAKE_DATABASE,
      schema: process.env.SNOWFLAKE_SCHEMA,
      role: process.env.SNOWFLAKE_ROLE
    };
  }

  async connect(): Promise<void> {
    return new Promise((resolve, reject) => {
      this.connection = snowflake.createConnection(this.config);
      
      this.connection.connect((err, conn) => {
        if (err) {
          console.error('Unable to connect: ' + err.message);
          reject(err);
        } else {
          console.log('Successfully connected to Snowflake');
          resolve();
        }
      });
    });
  }

  async executeQuery<T = any>(query: string): Promise<T[]> {
    return new Promise((resolve, reject) => {
      if (!this.connection) {
        reject(new Error('Not connected to Snowflake'));
        return;
      }

      this.connection.execute({
        sqlText: query,
        complete: (err, stmt, rows) => {
          if (err) {
            console.error('Failed to execute statement: ' + err.message);
            reject(err);
          } else {
            resolve(rows as T[]);
          }
        }
      });
    });
  }

  async disconnect(): Promise<void> {
    return new Promise((resolve) => {
      if (this.connection) {
        this.connection.destroy((err) => {
          if (err) {
            console.error('Error disconnecting: ' + err.message);
          }
          resolve();
        });
      } else {
        resolve();
      }
    });
  }
}

3. Tích hợp với Playwright Test

// tests/snowflake-playwright.spec.ts
import { test, expect, Page } from '@playwright/test';
import { SnowflakeClient } from '../snowflake-connection';

interface TestData {
  id: number;
  name: string;
  email: string;
  status: string;
}

test.describe('Snowflake + Playwright Tests', () => {
  let snowflakeClient: SnowflakeClient;
  let testData: TestData[];

  test.beforeAll(async () => {
    // Kết nối Snowflake và lấy data
    snowflakeClient = new SnowflakeClient();
    await snowflakeClient.connect();
    
    // Lấy test data từ Snowflake
    testData = await snowflakeClient.executeQuery<TestData>(
      'SELECT id, name, email, status FROM users_table LIMIT 10'
    );
  });

  test.afterAll(async () => {
    await snowflakeClient.disconnect();
  });

  test('Verify data from Snowflake displays correctly on UI', async ({ page }) => {
    await page.goto('https://your-app.com/users');
    
    // Verify từng record
    for (const record of testData) {
      const row = page.locator(`tr[data-id="${record.id}"]`);
      await expect(row).toBeVisible();
      
      // Verify các fields
      await expect(row.locator('.name-cell')).toContainText(record.name);
      await expect(row.locator('.email-cell')).toContainText(record.email);
      await expect(row.locator('.status-cell')).toContainText(record.status);
    }
  });

  test('Submit form with Snowflake data', async ({ page }) => {
    await page.goto('https://your-app.com/form');
    
    // Sử dụng data từ Snowflake để điền form
    const firstRecord = testData[0];
    
    await page.fill('#name', firstRecord.name);
    await page.fill('#email', firstRecord.email);
    await page.selectOption('#status', firstRecord.status);
    
    await page.click('button[type="submit"]');
    
    // Verify submission
    await expect(page.locator('.success-message')).toBeVisible();
  });
});