@autobe/utils 0.10.0

package/src/test/AutoBeTestStatementValidator.ts

@@ -0,0 +1,72 @@
+import { AutoBeTest } from "@autobe/interface";
+
+import { IAutoBeTextValidateContext } from "./IAutoBeTextValidateContext";
+import { validateTestApiOperateStatement } from "./validateTestApiOperateStatement";
+import { validateTestExpression } from "./validateTestExpression";
+import { validateTestStatement } from "./validateTestStatement";
+
+export namespace AutoBeTestStatementValidator {
+  export const block = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IBlock,
+    path: string,
+  ): void => {
+    item.statements.forEach((stmt, i) =>
+      validateTestStatement(ctx, stmt, `${path}.statements[${i}]`),
+    );
+  };
+
+  export const apiOperateStatement = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IApiOperateStatement,
+    path: string,
+  ): void => {
+    validateTestApiOperateStatement(ctx, item, path);
+  };
+
+  export const expressionStatement = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IExpressionStatement,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.expression, `${path}.expression`);
+  };
+
+  export const ifStatement = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IIfStatement,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.condition, `${path}.condition`);
+    block(ctx, item.thenStatement, `${path}.thenStatement`);
+    if (!!item.elseStatement)
+      if (item.elseStatement.type === "block")
+        block(ctx, item.elseStatement, `${path}.elseStatement`);
+      else
+        validateTestStatement(ctx, item.elseStatement, `${path}.elseStatement`);
+  };
+
+  export const returnStatement = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IReturnStatement,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.expression, `${path}.expression`);
+  };
+
+  export const throwStatement = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IThrowStatement,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.expression, `${path}.expression`);
+  };
+
+  // export const variableDeclaration = (
+  //   ctx: IAutoBeTextValidateContext,
+  //   item: AutoBeTest.IVariableDeclaration,
+  //   path: string,
+  // ): void => {
+  //   validateTestExpression(ctx, item.initializer, `${path}.initializer`);
+  // };
+}

package/src/test/IAutoBeTextValidateContext.ts

@@ -0,0 +1,10 @@
+import { AutoBeOpenApi, AutoBeTest } from "@autobe/interface";
+import { HashMap } from "tstl";
+import { IValidation } from "typia";
+
+export interface IAutoBeTextValidateContext {
+  function: AutoBeTest.IFunction;
+  document: AutoBeOpenApi.IDocument;
+  endpoints: HashMap<AutoBeOpenApi.IEndpoint, AutoBeOpenApi.IOperation>;
+  errors: IValidation.IError[];
+}

package/src/test/index.ts

@@ -0,0 +1,2 @@
+export * from "./validateTestFunction";
+export * from "./IAutoBeTextValidateContext";

package/src/test/validateTestApiOperateStatement.ts

@@ -0,0 +1,92 @@
+import { AutoBeOpenApi, AutoBeTest } from "@autobe/interface";
+import { HashMap } from "tstl";
+import typia from "typia";
+
+import { IAutoBeTextValidateContext } from "./IAutoBeTextValidateContext";
+
+export const validateTestApiOperateStatement = (
+  ctx: IAutoBeTextValidateContext,
+  stmt: AutoBeTest.IApiOperateStatement,
+  path: string,
+): void => {
+  // Check API endpoint
+  const it: HashMap.Iterator<
+    AutoBeOpenApi.IEndpoint,
+    AutoBeOpenApi.IOperation
+  > = ctx.endpoints.find(stmt.endpoint);
+  if (it.equals(ctx.endpoints.end()) === true) {
+    ctx.errors.push({
+      path: `${path}.endpoint`,
+      value: stmt.endpoint,
+      expected: ctx.document.operations
+        .map((o) => `AutoBeOpenApi.IEndpoint<"${o.method}", "${o.path}">`)
+        .join(" | "),
+      description: [
+        "You can use only endpoints defined in the OpenAPI document.",
+        "",
+        ctx.document.operations
+          .map((o) => `- { method: "${o.method}", path: "${o.path}" }`)
+          .join("\n"),
+      ].join("\n"),
+    });
+    return;
+  }
+  const operation: AutoBeOpenApi.IOperation = it.second;
+
+  // Check function argument
+  const needArgument: boolean =
+    operation.requestBody !== null || operation.parameters.length !== 0;
+  if (!!stmt.argument !== needArgument) {
+    // required argument, but is not
+    // or not required, but is provided
+    ctx.errors.push({
+      path: `${path}.argument`,
+      value: stmt.argument,
+      expected:
+        needArgument === true
+          ? typia.reflect.name<AutoBeTest.IObjectLiteralExpression>()
+          : "null",
+    });
+  } else if (!!stmt.argument) {
+    // check properties
+    const keys: Set<string> = new Set(
+      stmt.argument.properties.map((p) => p.name),
+    );
+    for (const p of operation.parameters) // path parameters
+      if (keys.has(p.name) === false)
+        ctx.errors.push({
+          path: `${path}.argument.${p.name}`,
+          value: undefined,
+          expected: JSON.stringify(p.schema),
+          description: `Parameter "${p.name}" is required, and its type is ${JSON.stringify(p.schema)}. However, you did not provide it.`,
+        });
+    if (operation.requestBody !== null && keys.has("body") === false) {
+      // request body is not provided
+      ctx.errors.push({
+        path: `${path}.argument.body`,
+        value: undefined,
+        expected: operation.requestBody.typeName,
+        description: `Request body is required, and its type is "${operation.requestBody.typeName}". However, you did not provide it.`,
+      });
+    }
+  }
+
+  // Check function return type
+  if (!!stmt.variableName !== !!operation.responseBody) {
+    ctx.errors.push({
+      path: `${path}.variableName`,
+      value: stmt.variableName,
+      ...(stmt.variableName === null || stmt.variableName === undefined
+        ? {
+            expected: "string",
+            description:
+              "You have to provide variable name. Every API operations that returning value require it, and it is used to store the response body.",
+          }
+        : {
+            expected: typia.reflect.name<AutoBeTest.IIdentifier>(),
+            description:
+              "You don't have to provide variable name. The API operation does not return any value, so it is not needed.",
+          }),
+    });
+  }
+};

package/src/test/validateTestExpression.ts

@@ -0,0 +1,10 @@
+import { AutoBeTest } from "@autobe/interface";
+
+import { AutoBeTestExpressionValidator } from "./AutoBeTestExpressionValidator";
+import { IAutoBeTextValidateContext } from "./IAutoBeTextValidateContext";
+
+export const validateTestExpression = (
+  ctx: IAutoBeTextValidateContext,
+  item: AutoBeTest.IExpression,
+  path: string,
+): void => AutoBeTestExpressionValidator[item.type](ctx, item as any, path);

package/src/test/validateTestFunction.ts

@@ -0,0 +1,7 @@
+import { IAutoBeTextValidateContext } from "./IAutoBeTextValidateContext";
+import { validateTestStatement } from "./validateTestStatement";
+
+export const validateTestFunction = (ctx: IAutoBeTextValidateContext): void =>
+  ctx.function.statements.forEach((stmt, i) =>
+    validateTestStatement(ctx, stmt, `$input.function.statements[${i}]`),
+  );

package/src/test/validateTestStatement.ts

@@ -0,0 +1,10 @@
+import { AutoBeTest } from "@autobe/interface";
+
+import { AutoBeTestStatementValidator } from "./AutoBeTestStatementValidator";
+import { IAutoBeTextValidateContext } from "./IAutoBeTextValidateContext";
+
+export const validateTestStatement = (
+  ctx: IAutoBeTextValidateContext,
+  item: AutoBeTest.IStatement,
+  path: string,
+): void => AutoBeTestStatementValidator[item.type](ctx, item as any, path);