عملکردهای نظارت مصنوعی لاجورد با نمایشنامه نویس: راهنمای کامل – قسمت 1

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   Azure Timer   │    │  Azure Function │    │   Playwright    │
│   Trigger       │───▶│   (Runtime)     │───▶│   Test Runner   │
│  (Scheduled)    │    │                 │    │                 │
└─────────────────┘    └─────────────────┘    └─────────────────┘
                                                        │
                                                        ▼
                                              ┌─────────────────┐
                                              │  Test Results   │
                                              │   Processing    │
                                              └─────────────────┘
                                                        │
                                              ┌─────────┴─────────┐
                                              ▼                   ▼
                                     ┌─────────────────┐ ┌─────────────────┐
                                     │ Application     │ │   Azure Blob    │
                                     │ Insights        │ │   Storage       │
                                     │ (Telemetry)     │ │ (Artifacts)     │
                                     └─────────────────┘ └─────────────────┘

# Create project directory
mkdir synthetic-monitoring
cd synthetic-monitoring

# Initialize Node.js project
npm init -y

# Install core dependencies
npm install @azure/functions @playwright/test playwright
npm install @azure/storage-blob applicationinsights archiver dotenv

# Install development dependencies
npm install -D typescript @types/node @types/archiver

synthetic-monitoring/
├── src/
│   ├── functions/
│   │   └── synthetic-monitor.ts      # Timer-triggered function
│   ├── support/
│   │   ├── azure/
│   │   │   ├── app-insights-client.ts
│   │   │   ├── app-insights.ts
│   │   │   ├── blob-storage-client.ts
│   │   │   └── blob-storage.ts
│   │   ├── logger/
│   │   │   └── logger.ts
│   │   ├── pages/                    # Page Object Models
│   │   ├── reporter/
│   │   │   ├── appinsights-reporter.ts
│   │   │   └── utils.ts
│   │   └── services/                 # Authentication services
│   ├── tests/
│   │   └── marketplace-integration.spec.ts
│   └── index.ts                      # Main entry point
├── host.json                         # Azure Functions configuration
├── local.settings.json              # Local environment variables
├── package.json
├── playwright.config.ts             # Playwright configuration
└── tsconfig.json                    # TypeScript configuration

import { app, InvocationContext, Timer } from '@azure/functions';
import { runPlaywrightTests } from '../index';

app.timer('syntheticMonitor', {
  schedule: process.env.SYNTHETIC_MONITOR_SCHEDULE || '|| '0 0 * * * *',
  handler: async (myTimer: Timer, context: InvocationContext) => {
    try {
      context.log("🚀 Executing synthetic monitoring tests...");
      await runPlaywrightTests(context);
      context.log("✅ Synthetic monitoring tests completed successfully!");
    } catch (error) {
      context.log("❌ Error in synthetic monitoring tests:", error);
      throw error; // Ensure the function fails for monitoring purposes
    } finally {
      context.log("🔄 Synthetic monitoring cycle completed.");
    }
  }
});

import { spawn } from 'child_process';
import { setLoggerContext } from './support/logger/logger';
import { InvocationContext } from '@azure/functions';
import path from 'path';

// Import the function to register it
import './functions/synthetic-monitor';

export async function runPlaywrightTests(context: InvocationContext): Promisevoid> {
  setLoggerContext(context);

  return new Promise((resolve, reject) => {
    context.log('▶️ Running Playwright tests via CLI...');

    // Use full path to playwright binary
    const playwrightPath = path.join(process.cwd(), 'node_modules', '.bin', 'playwright.cmd');
    const command = \`"\${playwrightPath}" test\`;

    context.log(\`📍 Using command: \${command}\`);
    const child = spawn(command, { 
      shell: true,
      env: {
        ...process.env,
        // Add any environment variables your tests need
        NODE_ENV: 'production'
      }
    });

    child.stdout.on('data', (data) => {
      context.log(data.toString());
    });

    child.stderr.on('data', (data) => {
      context.log(data.toString());
    });

    child.on('error', (error) => {
      context.log(\`❌ Playwright tests failed: \${error.message}\`);
      reject(error);
    });

    child.on('close', (code) => {
      if (code === 0) {
        context.log('✅ Playwright tests completed.');
        resolve();
      } else {
        context.log(\`❌ Playwright tests exited with code \${code}\`);
        reject(new Error(\`Playwright tests failed with code \${code}\`));
      }
    });
  });
}

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

const tmpDir = os.tmpdir();
const outputPath = process.env.PLAYWRIGHT_OUTPUT_DIR || path.join(tmpDir, 'playwright-artifacts');
const htmlReportPath = process.env.PLAYWRIGHT_HTML_REPORT || path.join(tmpDir, 'playwright-html-report');

// Ensure directories exist
if (!fs.existsSync(outputPath)) {
  fs.mkdirSync(outputPath, { recursive: true });
}
if (!fs.existsSync(htmlReportPath)) {
  fs.mkdirSync(htmlReportPath, { recursive: true });
}

export default defineConfig({
  testDir: './src/tests',
  timeout: 180 * 1000,  // 3 minutes per test
  retries: 1,           // Retry failed tests once
  fullyParallel: true,
  workers: 3,           // Adjust based on your Azure Function plan
  outputDir: outputPath,

  use: {
    headless: true,     // Always run headless in Azure Functions
    viewport: { width: 1280, height: 720 },
    baseURL: process.env.baseUrl,
    screenshot: 'only-on-failure',
    trace: 'retain-on-failure',
    actionTimeout: 30000,
  },

  reporter: [
    ['html', { outputFolder: htmlReportPath, open: 'never' }],
    ['junit', { outputFile: path.join(outputPath, 'junit-report.xml') }],
    ['list'], 
    ['./src/support/reporter/appinsights-reporter.ts'] // Custom reporter
  ],

  projects: [
    {
      name: 'chromium',
      use: { 
        ...devices['Desktop Chrome']
      },
    }
  ],
});

{
  "version": "2.0",
  "logging": {
    "applicationInsights": {
      "samplingSettings": {
        "isEnabled": true,
        "excludedTypes": "Request"
      }
    },
    "logLevel": {
      "default": "Information"
    }
  },
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[4.*, 5.0.0)"
  }
}

import { test, expect, BrowserContext, Page } from '@playwright/test';

const aadUsername: string = process.env['username'] || '';
const aadPassword: string = process.env['password'] || '';
const baseURL: string = process.env['baseUrl'] || '';

let context: BrowserContext;
let page: Page;

test.beforeEach(async ({ browser: bro }) => {
    context = await bro.newContext();
    page = await context.newPage();
    // Init all pages here

    await page.goto(baseURL);

}); 

test('User should be able to do somethinng', { tag: ['@some-tag', ] }, async () => {
    // All the test implemention here

    //Arrange
    //Act
    //Assert
});

test.afterEach(async () => {
  await page.close();
  await context.close();
});

{
  "AzureWebJobsStorage": "DefaultEndpointsProtocol=https;AccountName=;AccountKey=",
  "FUNCTIONS_WORKER_RUNTIME": "node",
  "FUNCTIONS_EXTENSION_VERSION": "~4",

  //ScheduleTime
   "SYNTHETIC_MONITOR_SCHEDULE": "0 */10 * * * *",

  // Test Configuration
  "username": "",
  "password": "",
  "baseUrl": "",

  // Azure Services
  "APPLICATIONINSIGHTS_CONNECTION_STRING": "",
  "APPINSIGHTS_INSTRUMENTATIONKEY": "",
  "AZURE_BLOB_CONNECTION_STRING": "",
  "AZURE_BLOB_CONTAINER_NAME": "",
}

{
  "scripts": {
    "build": "tsc",
    "start": "func start --typescript",
    "test:local": "npx playwright test",
    "install:browsers": "npx playwright install"
  }
}