Руководство по тестированию Serverless: AWS Lambda и Azure Functions

# Установить SAM CLI
brew install aws-sam-cli

# Инициализировать SAM приложение
sam init --runtime nodejs18.x --name my-lambda-app

# Собрать приложение
sam build

# Запустить локально
sam local start-api

// handler.js
exports.handler = async (event) => {
  const body = JSON.parse(event.body);

  return {
    statusCode: 200,
    body: JSON.stringify({
      message: 'Успех',
      input: body
    })
  };
};

// handler.test.js
const { handler } = require('./handler');

describe('Lambda Handler', () => {
  test('должен корректно обработать событие', async () => {
    const event = {
      body: JSON.stringify({ name: 'Тестовый пользователь' })
    };

    const result = await handler(event);
    const body = JSON.parse(result.body);

    expect(result.statusCode).toBe(200);
    expect(body.input.name).toBe('Тестовый пользователь');
  });
});

# Установить Azure Functions Core Tools
brew install azure-functions-core-tools@4

# Создать новое приложение функций
func init MyFunctionApp --javascript

# Создать функцию с HTTP триггером
func new --name HttpTrigger --template "HTTP trigger"

# Запустить локально
func start

// HttpTrigger/index.js
module.exports = async function (context, req) {
  context.log('HTTP-триггер функция обработала запрос');

  const name = req.query.name || (req.body && req.body.name);

  context.res = {
    status: 200,
    body: { message: `Привет, ${name}` }
  };
};

// HttpTrigger/index.test.js
const httpTrigger = require('./index');

describe('Функция HTTP-триггера', () => {
  let context;

  beforeEach(() => {
    context = {
      log: jest (как обсуждается в [API Testing Architecture: From Monoliths to Microservices](/blog/api-testing-architecture-microservices)).fn(),
      res: {}
    };
  });

  test('должна ответить приветствием', async () => {
    const req = {
      query: { name: 'Alice' }
    };

    await httpTrigger(context, req);

    expect(context.res.status).toBe(200);
    expect(context.res.body.message).toBe('Привет, Alice');
  });
});

# docker-compose.yml
version: '3.8'
services:
  localstack:
    image: localstack/localstack
    ports:
      - "4566:4566"
    environment:
      - SERVICES=lambda,s3,dynamodb,sqs
      - DEBUG=1
    volumes:
      - "./localstack:/tmp/localstack"
      - "/var/run/docker.sock:/var/run/docker.sock"

const AWS = require('aws-sdk');

// Настроить AWS SDK для LocalStack
const s3 = new AWS.S3({
  endpoint: 'http://localhost:4566',
  s3ForcePathStyle: true,
  accessKeyId: 'test',
  secretAccessKey: 'test'
});

describe('Интеграция Lambda S3', () => {
  beforeAll(async () => {
    await s3.createBucket({ Bucket: 'test-bucket' }).promise();
  });

  test('должна загрузить файл в S3', async () => {
    const params = {
      Bucket: 'test-bucket',
      Key: 'test-file.txt',
      Body: 'Тестовое содержимое'
    };

    await s3.putObject(params).promise();

    const result = await s3.getObject({
      Bucket: 'test-bucket',
      Key: 'test-file.txt'
    }).promise();

    expect(result.Body.toString()).toBe('Тестовое содержимое');
  });
});

// cold-start-test.js
const AWS (как обсуждается в [Cross-Platform Mobile Testing: Strategies for Multi-Device Success](/blog/cross-platform-mobile-testing)) = require('aws-sdk');
const lambda = new AWS.Lambda({ region: 'us-east-1' });

async function measureColdStart(functionName, iterations = 10) {
  const results = {
    coldStarts: [],
    warmStarts: []
  };

  for (let i = 0; i < iterations; i++) {
    const startTime = Date.now();

    const response = await lambda.invoke({
      FunctionName: functionName,
      InvocationType: 'RequestResponse',
      Payload: JSON.stringify({ iteration: i })
    }).promise();

    const duration = Date.now() - startTime;

    if (i === 0) {
      results.coldStarts.push(duration);
    } else {
      results.warmStarts.push(duration);
    }

    // Ждать холодного старта на следующей итерации
    if (i < iterations - 1) {
      await new Promise(resolve => setTimeout(resolve, 600000)); // 10 мин
    }
  }

  return {
    avgColdStart: average(results.coldStarts),
    avgWarmStart: average(results.warmStarts),
    coldStartOverhead: average(results.coldStarts) - average(results.warmStarts)
  };
}

function average(arr) {
  return arr.reduce((a, b) => a + b, 0) / arr.length;
}

// timeout-handler.js
exports.handler = async (event, context) => {
  const timeoutBuffer = 5000; // буфер 5 секунд
  const remainingTime = context.getRemainingTimeInMillis();

  if (remainingTime < timeoutBuffer) {
    throw new Error('Недостаточно времени для обработки запроса');
  }

  // Долгоиграющая операция
  const result = await processLargeDataset(event.data, {
    maxTime: remainingTime - timeoutBuffer
  });

  return {
    statusCode: 200,
    body: JSON.stringify(result)
  };
};

async function processLargeDataset(data, options) {
  const startTime = Date.now();
  const results = [];

  for (const item of data) {
    if (Date.now() - startTime > options.maxTime) {
      // Вернуть частичные результаты
      return {
        processed: results,
        remaining: data.length - results.length,
        timeout: true
      };
    }

    results.push(await processItem(item));
  }

  return { processed: results, timeout: false };
}

describe('Обработка таймаута', () => {
  test('должна грамотно обработать близость к таймауту', async () => {
    const mockContext = {
      getRemainingTimeInMillis: () => 3000 // 3 секунды осталось
    };

    const event = {
      data: Array(1000).fill({ value: 'test' })
    };

    await expect(
      handler(event, mockContext)
    ).rejects.toThrow('Недостаточно времени для обработки запроса');
  });

  test('должна обработать при достаточном времени', async () => {
    const mockContext = {
      getRemainingTimeInMillis: () => 60000 // 60 секунд
    };

    const event = {
      data: [{ value: 'test1' }, { value: 'test2' }]
    };

    const result = await handler(event, mockContext);
    const body = JSON.parse(result.body);

    expect(body.timeout).toBe(false);
    expect(body.processed).toHaveLength(2);
  });
});

// iam-test.js
const AWS = require('aws-sdk');

async function testS3Permissions(functionRole) {
  const iam = new AWS.IAM();

  // Получить политики роли
  const attachedPolicies = await iam.listAttachedRolePolicies({
    RoleName: functionRole
  }).promise();

  // Проверить доступ на чтение S3
  const hasS3Read = attachedPolicies.AttachedPolicies.some(policy =>
    policy.PolicyName.includes('S3Read')
  );

  expect(hasS3Read).toBe(true);

  // Проверить фактический доступ к S3
  const s3 = new AWS.S3();

  try {
    await s3.listBuckets().promise();
    // Должно выполниться успешно с правильными разрешениями
  } catch (error) {
    if (error.code === 'AccessDenied') {
      throw new Error('Разрешения S3 не настроены должным образом');
    }
  }
}

describe('Разрешения IAM', () => {
  test('Lambda должна иметь разрешения на чтение S3', async () => {
    await testS3Permissions('MyLambdaExecutionRole');
  });

  test('Lambda НЕ должна иметь разрешения на удаление S3', async () => {
    const s3 = new AWS.S3();

    await expect(
      s3.deleteObject({
        Bucket: 'protected-bucket',
        Key: 'important-file.txt'
      }).promise()
    ).rejects.toThrow('AccessDenied');
  });
});

// dynamodb-integration.test.js
const AWS = require('aws-sdk');
const { handler } = require('./dynamodb-handler');

describe('Интеграция DynamoDB', () => {
  let documentClient;
  const tableName = 'TestTable';

  beforeAll(async () => {
    documentClient = new AWS.DynamoDB.DocumentClient({
      endpoint: 'http://localhost:4566'
    });

    // Создать тестовую таблицу
    const dynamodb = new AWS.DynamoDB({ endpoint: 'http://localhost:4566' });
    await dynamodb.createTable({
      TableName: tableName,
      KeySchema: [{ AttributeName: 'id', KeyType: 'HASH' }],
      AttributeDefinitions: [{ AttributeName: 'id', AttributeType: 'S' }],
      BillingMode: 'PAY_PER_REQUEST'
    }).promise();
  });

  test('должна записать и прочитать из DynamoDB', async () => {
    const event = {
      body: JSON.stringify({
        id: '123',
        name: 'Тестовый элемент'
      })
    };

    // Lambda записывает в DynamoDB
    await handler(event);

    // Проверить что данные записаны
    const result = await documentClient.get({
      TableName: tableName,
      Key: { id: '123' }
    }).promise();

    expect(result.Item.name).toBe('Тестовый элемент');
  });

  afterAll(async () => {
    const dynamodb = new AWS.DynamoDB({ endpoint: 'http://localhost:4566' });
    await dynamodb.deleteTable({ TableName: tableName }).promise();
  });
});

// Тестирование чистой бизнес-логики
function calculateDiscount(price, userTier) {
  const discounts = {
    bronze: 0.05,
    silver: 0.10,
    gold: 0.15
  };

  return price * (1 - (discounts[userTier] || 0));
}

describe('Модульные тесты бизнес-логики', () => {
  test('должна применить правильную скидку для уровня gold', () => {
    expect(calculateDiscount(100, 'gold')).toBe(85);
  });

  test('должна применить отсутствие скидки для неизвестного уровня', () => {
    expect(calculateDiscount(100, 'platinum')).toBe(100);
  });
});

// Сквозной serverless workflow
describe('Интеграция обработки заказа', () => {
  test('полный поток заказа', async () => {
    // 1. API Gateway получает заказ
    const orderEvent = {
      httpMethod: 'POST',
      body: JSON.stringify({ items: ['item1'], userId: 'user123' })
    };

    // 2. Lambda обрабатывает заказ
    const response = await orderHandler(orderEvent);
    expect(response.statusCode).toBe(200);

    // 3. Проверить запись DynamoDB
    const order = await getOrder(JSON.parse(response.body).orderId);
    expect(order.status).toBe('pending');

    // 4. Проверить отправку сообщения SQS
    const messages = await getSQSMessages('order-queue');
    expect(messages).toHaveLength(1);

    // 5. Обработать сообщение из очереди
    await processOrderMessage(messages[0]);

    // 6. Проверить финальное состояние
    const processedOrder = await getOrder(order.id);
    expect(processedOrder.status).toBe('confirmed');
  });
});

// Тестировать функциональность общего слоя
describe('Lambda Layer', () => {
  test('должна загрузить общие утилиты', () => {
    const { validateEmail } = require('/opt/nodejs/utils');

    expect(validateEmail('test@example.com')).toBe(true);
    expect(validateEmail('invalid-email')).toBe(false);
  });

  test('должна получить доступ к общим зависимостям', () => {
    const lodash = require('/opt/nodejs/node_modules/lodash');
    expect(lodash.VERSION).toBeDefined();
  });
});

// Тестирование события S3
const s3Event = {
  Records: [{
    s3: {
      bucket: { name: 'test-bucket' },
      object: { key: 'uploads/file.jpg' }
    }
  }]
};

describe('Обработчик событий S3', () => {
  test('должна обработать событие загрузки S3', async () => {
    const result = await s3Handler(s3Event);

    expect(result.processed).toBe(true);
    expect(result.thumbnailKey).toBe('thumbnails/file.jpg');
  });
});