Bedrockを使って作成したコードのテストケースとテストコードを生成してみる

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.handler = void 0;
const client_s3_1 = require("@aws-sdk/client-s3");
const client_bedrock_runtime_1 = require("@aws-sdk/client-bedrock-runtime");
const stream_1 = require("stream");
// 環境変数の取得
const REGION = process.env.REGION;
const MODELID = process.env.MODELID;
const VERSION = process.env.VERSION;
const BUCKET_NAME = process.env.BUCKET_NAME;
// 変数定義
const basePrompt = () => {
    return `
      # 指示文
      - 以下の条件に基づいて入力されたTypeScriptのコードのテストケースとテストコードを生成してください。

      # 条件
      - 入力されたコードが不正な場合は、resultはfalseとしてください。正常な場合はtrueとしてください。
      - テストケースは以下の項目を出力してください。（）内は説明のため出力時には不要です。
      - テスト項目件名（テストの件名）
      - テスト条件（インプットのパラメタやテスト環境の条件設定）
      - テスト結果（実行した結果の予想される復帰値やメッセージ json形式ではなく文章でわかるようにしてください。）
      - 分岐網羅 (C1カバレッジ)でテストケースを生成してください。
      - テストコードはJestを使ってください
      - 処理内で関数を使う場合、mockを使ってください。
      - テストケースで洗い出しをした項目をテストコードとしてください。
      - 結果はJSONの出力形式で復帰してください。その他のメッセージは不要です。
      - エスケープが必要な文字列はエスケープしてください。
      - NodeJsのSON.parseを使って文字列をオブジェクト化するのでparseできるように文字列をエスケープしてください。
      - jsonのキーと値は"key": "value"といったように「"」でくくってください。
      - json値に「"」は使わず、「'」を使ってください。例）"key": "value: 'message text'"
      - テストコード内の改行コード（\n）はjson形式で識別できるように「\\n」で出力してください。

      # 出力形式
      {
        "result": 【true or false】
        "items": [
          {
            "title": "【テスト項目件名】",
            "condition": "【テスト条件】",
            "prediction": "【テスト結果】",
          },
          ・
          ・
          ・
        ],
        "code": "【テストコード】"
      }
    `;
};
// Clientの初期化
const s3Client = new client_s3_1.S3Client({ region: REGION });
const bedrockRuntimeClient = new client_bedrock_runtime_1.BedrockRuntimeClient({ region: REGION });
// handler関数の定義
const handler = async (event) => {
    try {
        // インプットチェック
        console.log("----- インプットチェック -----");
        if (!(event &&
            event.Records &&
            event.Records.length > 0 &&
            event.Records[0].s3 &&
            event.Records[0].s3.bucket &&
            event.Records[0].s3.bucket.name &&
            event.Records[0].s3.object &&
            event.Records[0].s3.object.key)) {
            throw new Error("eventの構造が不正です");
        }
        const inputBucketName = event.Records[0].s3.bucket.name;
        const inputObjectKey = decodeURIComponent(event.Records[0].s3.object.key.replace(/\+/g, ' '));
        const inputFileName = inputObjectKey.split('/').pop() || '';
        const lastDotIndex = inputFileName.lastIndexOf('.');
        let fileName = '';
        let extension = '';
        if (lastDotIndex === -1) {
            // 拡張子が存在しない場合
            fileName = inputFileName;
            extension = '';
        }
        else {
            fileName = inputFileName.substring(0, lastDotIndex);
            extension = inputFileName.substring(lastDotIndex + 1);
        }
        if (extension != 'ts') {
            throw new Error("拡張子が不正でｋす");
        }
        console.log("----------");
        // オブジェクトの読み込み
        console.log("----- オブジェクトの読み込み -----");
        const getObjectParams = {
            Bucket: inputBucketName,
            Key: inputObjectKey,
        };
        const getObjectCommand = new client_s3_1.GetObjectCommand(getObjectParams);
        const s3Response = await s3Client.send(getObjectCommand);
        console.log("----------");
        // 読み込んだオブジェクトのチェック
        console.log("----- 読み込んだオブジェクトのチェック -----");
        if (!s3Response.Body || !(s3Response.Body instanceof stream_1.Readable)) {
            throw new Error("アップロードされたオブジェクトが不正です");
        }
        const chunks = [];
        for await (const chunk of s3Response.Body) {
            chunks.push(chunk);
        }
        const fileContent = Buffer.concat(chunks).toString('utf-8');
        if (!fileContent) {
            throw new Error("アップロードされたテキストが空白です。");
        }
        if (fileContent.length > 5000) {
            throw new Error("解析するプログラム5000文字以内にしてください。");
        }
        console.log("解析するプログラム：\n" + fileContent);
        console.log("----------");
        // Bedrock実行パラメタの定義
        console.log("----- Bedrock実行パラメタの定義 -----");
        const payload = {
            anthropic_version: VERSION,
            max_tokens: 5000,
            system: basePrompt(),
            messages: [
                {
                    role: "user",
                    content: [
                        { type: "text", text: fileContent }
                    ],
                }
            ],
        };
        console.log("payload:");
        console.log(payload);
        console.log("----------");
        // Claudeで実行
        console.log("----- Claudeで実行 -----");
        const command = new client_bedrock_runtime_1.InvokeModelCommand({
            contentType: "application/json",
            body: JSON.stringify(payload),
            accept: "application/json",
            modelId: MODELID,
        });
        console.log("command:");
        console.log(command);
        const response = await bedrockRuntimeClient.send(command);
        console.log("----------");
        // Bedrock復帰処理
        console.log("----- Bedrock復帰処理 -----");
        const decodedResponseBody = new TextDecoder().decode(response.body);
        const responseBody = JSON.parse(decodedResponseBody);
        console.log("responseBody: ");
        console.log(responseBody);
        console.log("responseBody.content[0].text.replace: ");
        console.log(responseBody.content[0].text.replace(/\\n/g, "\\\\n"));
        const contentTextJson = JSON.parse(responseBody.content[0].text
            .replace(/\\n/g, "\\\\n"));
        console.log("contentTextJson: ");
        console.log(contentTextJson);
        console.log("----------");
        // テスト項目確認
        console.log("----- テスト項目・テストコード確認 -----");
        if (!(contentTextJson &&
            contentTextJson.result &&
            contentTextJson.items &&
            contentTextJson.items.length > 0 &&
            contentTextJson.code)) {
            console.log(contentTextJson);
            console.log(contentTextJson.result);
            console.log(contentTextJson.items);
            console.log(contentTextJson.items.length > 0);
            console.log(contentTextJson.code);
            throw new Error("contentTextJsonの構造が不正です");
        }
        console.log("----------");
        // テスト項目json→csv変換
        console.log("----- テスト項目json→csv変換 -----");
        const testItems = contentTextJson.items;
        const headers = ['title', 'condition', 'prediction'];
        const csvRows = [headers.join(', ')];
        testItems.forEach((item) => {
            const row = [item.title, item.condition, item.prediction];
            csvRows.push(row.join(', '));
        });
        const csvData = csvRows.join('\n');
        console.log("----------");
        // テストコード改行コード変換
        console.log("----- テストコード改行コード変換 -----");
        const testCode = contentTextJson.code.replace(/\\\\n/g, "\n");
        console.log("testCode: ");
        console.log(testCode);
        console.log("----------");
        // S3にアップロード
        console.log("----- S3にアップロード -----");
        const testItemsKey = 'testItems/' + fileName + '.csv';
        const testCodeKey = 'testcode/' + fileName + '.spec.ts';
        const uploadTestItemsParams = {
            Bucket: BUCKET_NAME,
            Key: testItemsKey,
            Body: csvData,
            ContentType: "text/csv",
        };
        await s3Client.send(new client_s3_1.PutObjectCommand(uploadTestItemsParams));
        const uploadTestCodeParams = {
            Bucket: BUCKET_NAME,
            Key: testCodeKey,
            Body: contentTextJson.code.replace(/\\n/g, "\n"),
            ContentType: "text/ts",
        };
        await s3Client.send(new client_s3_1.PutObjectCommand(uploadTestCodeParams));
        console.log("----------");
    }
    catch (error) {
        console.error("Error invoking Bedrock model:", error);
    }
};
exports.handler = handler;

続いてS3のファイルアップロードをトリガーに、Lambda関数を起動する設定をします。
「トリガーの追加」を選択します。

以下を入力し、追加を選択します。

トリガーにS3が追加されています。

これでLambda関数の作成は完了です。

3. Lambda関数のロール設定

{
    "Version": "2012-10-17",
    "Statement": [
	{
		"Effect": "Allow",
		"Action": "s3:GetObject",
		"Resource": "arn:aws:s3:::【作成したTypeScriptのプログラムを格納するバケット】/*.ts"
	},
	{
		"Effect": "Allow",
		"Action": "s3:PutObject",
		"Resource": "arn:aws:s3:::【生成したテストコードを格納するバケット】/*"
	},
        {
            "Effect": "Allow",
            "Action": "bedrock:InvokeModel",
            "Resource": [
                "arn:aws:bedrock:ap-northeast-1::foundation-model/anthropic.claude-3-5-sonnet-20240620-v1:0"
            ]
        }
    ]
}

import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3";
import { APIGatewayProxyHandlerV2 } from "aws-lambda";

const s3Client = new S3Client({ region: process.env.AWS_REGION });
const BUCKET_NAME = process.env.BUCKET_NAME;

export const handler: APIGatewayProxyHandlerV2 = async (event) => {
    try {
        // Validate query parameters
        const { queryStringParameters } = event;
        if (!queryStringParameters) {
            return {
                statusCode: 400,
                body: JSON.stringify({ message: "Missing query parameters" }),
            };
        }

        const { filename, content } = queryStringParameters;

        if (!filename || !content) {
            return {
                statusCode: 400,
                body: JSON.stringify({ message: "Both 'filename' and 'content' parameters are required" }),
            };
        }

        // Upload content to S3
        const uploadParams = {
            Bucket: BUCKET_NAME,
            Key: filename,
            Body: content,
            ContentType: "text/plain",
        };

        await s3Client.send(new PutObjectCommand(uploadParams));

        return {
            statusCode: 200,
            body: JSON.stringify({
                message: "File uploaded successfully",
                filename,
            }),
        };
    } catch (error) {
        console.error("Error uploading file to S3:", error);

        return {
            statusCode: 500,
            body: JSON.stringify({
                message: "Internal Server Error",
                error: error instanceof Error ? error.message : "Unknown error",
            }),
        };
    }
};

import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
import { APIGatewayProxyHandlerV2 } from 'aws-lambda';
import { handler } from './your-handler-file';

jest.mock('@aws-sdk/client-s3');

describe('S3 Upload Lambda Function', () => {
  const mockS3Send = jest.fn();
  S3Client.prototype.send = mockS3Send;

  beforeEach(() => {
    jest.clearAllMocks();
    process.env.BUCKET_NAME = 'test-bucket';
  });

  test('正常系: クエリパラメータが正しく設定されている場合', async () => {
    const event = {
      queryStringParameters: {
        filename: 'test.txt',
        content: 'Hello, World!'
      }
    };

    mockS3Send.mockResolvedValue({});

    const response = await handler(event as any);

    expect(response.statusCode).toBe(200);
    expect(JSON.parse(response.body)).toEqual({
      message: 'File uploaded successfully',
      filename: 'test.txt'
    });
    expect(mockS3Send).toHaveBeenCalledWith(
      expect.objectContaining({
        input: expect.objectContaining({
          Bucket: 'test-bucket',
          Key: 'test.txt',
          Body: 'Hello, World!',
          ContentType: 'text/plain'
        })
      })
    );
  });

  test('異常系: クエリパラメータが存在しない場合', async () => {
    const event = {};

    const response = await handler(event as any);

    expect(response.statusCode).toBe(400);
    expect(JSON.parse(response.body)).toEqual({
      message: 'Missing query parameters'
    });
    expect(mockS3Send).not.toHaveBeenCalled();
  });

  test('異常系: filename パラメータが欠落している場合', async () => {
    const event = {
      queryStringParameters: {
        content: 'Hello, World!'
      }
    };

    const response = await handler(event as any);

    expect(response.statusCode).toBe(400);
    expect(JSON.parse(response.body)).toEqual({
      message: 'Both 'filename' and 'content' parameters are required'
    });
    expect(mockS3Send).not.toHaveBeenCalled();
  });

  test('異常系: content パラメータが欠落している場合', async () => {
    const event = {
      queryStringParameters: {
        filename: 'test.txt'
      }
    };

    const response = await handler(event as any);

    expect(response.statusCode).toBe(400);
    expect(JSON.parse(response.body)).toEqual({
      message: 'Both 'filename' and 'content' parameters are required'
    });
    expect(mockS3Send).not.toHaveBeenCalled();
  });

  test('異常系: S3へのアップロードでエラーが発生した場合', async () => {
    const event = {
      queryStringParameters: {
        filename: 'test.txt',
        content: 'Hello, World!'
      }
    };

    mockS3Send.mockRejectedValue(new Error('S3 Upload Error'));

    const response = await handler(event as any);

    expect(response.statusCode).toBe(500);
    expect(JSON.parse(response.body)).toEqual({
      message: 'Internal Server Error',
      error: 'S3 Upload Error'
    });
    expect(mockS3Send).toHaveBeenCalled();
  });
});

import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
import { APIGatewayProxyHandlerV2, APIGatewayProxyResult, Context } from 'aws-lambda';
import { handler } from './../src/handler';

jest.mock("@aws-sdk/client-s3", () => {
  const mockS3Client = {
      send: jest.fn(),
  };
  return {
      S3Client: jest.fn(() => mockS3Client),
      PutObjectCommand: jest.fn((params) => params),
  };
});

describe('S3 Upload Lambda Function', () => {
  const mockS3Client = new S3Client({});

  const mockContext: Context = {
    awsRequestId: "test-request-id",
    callbackWaitsForEmptyEventLoop: false,
    functionName: "test-function",
    functionVersion: "$LATEST",
    invokedFunctionArn: "arn:aws:lambda:us-east-1:123456789012:function:test-function",
    logGroupName: "/aws/lambda/test-function",
    logStreamName: "test-log-stream",
    memoryLimitInMB: "128",
    getRemainingTimeInMillis: () => 3000,
    done: () => {},
    fail: () => {},
    succeed: () => {},
} as Context;

  beforeEach(() => {
    jest.clearAllMocks();
    process.env.BUCKET_NAME = 'test-bucket';
  });

  test('正常系: クエリパラメータが正しく設定されている場合', async () => {
    const event = {
      queryStringParameters: {
        filename: 'test.txt',
        content: 'Hello, World!'
      }
    } as any;

    (mockS3Client.send as jest.Mock).mockImplementation((command) => {
      return Promise.resolve(command.input);
    });

    const response = (await handler(event, mockContext, () => {})) as APIGatewayProxyResult;

    expect(response.statusCode).toBe(200);
    expect(JSON.parse(response.body)).toEqual({
      message: 'File uploaded successfully',
      filename: 'test.txt'
    });
    expect(mockS3Client.send).toHaveBeenCalledWith(
      expect.objectContaining({
        Bucket: 'test-bucket',
        Key: 'test.txt',
        Body: 'Hello, World!',
        ContentType: 'text/plain'
      })
    );
  });

  test('異常系: クエリパラメータが存在しない場合', async () => {
    const event = {} as any;

    const response = (await handler(event, mockContext, () => {})) as APIGatewayProxyResult;

    expect(response.statusCode).toBe(400);
    expect(JSON.parse(response.body)).toEqual({
      message: 'Missing query parameters'
    });
    expect(mockS3Client.send).not.toHaveBeenCalled();
  });

  test('異常系: filename パラメータが欠落している場合', async () => {
    const event = {
      queryStringParameters: {
        content: 'Hello, World!'
      }
    } as any;

    const response = (await handler(event, mockContext, () => {})) as APIGatewayProxyResult;

    expect(response.statusCode).toBe(400);
    expect(JSON.parse(response.body)).toEqual({
      message: 'Both \'filename\' and \'content\' parameters are required'
    });
    expect(mockS3Client.send).not.toHaveBeenCalled();
  });

  test('異常系: content パラメータが欠落している場合', async () => {
    const event = {
      queryStringParameters: {
        filename: 'test.txt'
      }
    } as any;

    const response = (await handler(event, mockContext, () => {})) as APIGatewayProxyResult;

    expect(response.statusCode).toBe(400);
    expect(JSON.parse(response.body)).toEqual({
      message: 'Both \'filename\' and \'content\' parameters are required'
    });
    expect(mockS3Client.send).not.toHaveBeenCalled();
  });

  test('異常系: S3へのアップロードでエラーが発生した場合', async () => {
    const event = {
      queryStringParameters: {
        filename: 'test.txt',
        content: 'Hello, World!'
      }
    } as any;

    (mockS3Client.send as jest.Mock).mockRejectedValue(new Error('S3 Upload Error'));

    const response = (await handler(event, mockContext, () => {})) as APIGatewayProxyResult;

    expect(response.statusCode).toBe(500);
    expect(JSON.parse(response.body)).toEqual({
      message: 'Internal Server Error',
      error: 'S3 Upload Error'
    });
    expect(mockS3Client.send).toHaveBeenCalled();
  });
});