api_test.pebble

{# @pebvariable name="imports" type="java.util.List<java.util.Map<String, String>>" #}
{# @pebvariable name="operations" type="org.openapitools.codegen.model.OperationMap" #}
{# @pebvariable name="authMethods" type="java.util.ArrayList<org.openapitools.codegen.CodegenSecurity>" -#}
import { {{operations.classname}} } from "../../api.js";

{% for import in imports -%}
import { {{import.classname}} } from '../{{import.filename}}.js';
{% endfor %}

import { createServer } from "node:http";
import { deepEqual, equal, ok } from "node:assert";

import { describe, it } from "vitest";

const channel_access_token = "test_channel_access_token";

// This is not a perfect multipart/form-data parser,
// but it works for the purpose of this test.
function parseForm(
  arrayBuffer: ArrayBuffer,
): Record<string, string | Blob> {
  const uint8Array = new Uint8Array(arrayBuffer);
  const text = new TextDecoder().decode(uint8Array);

  const boundary = text.match(/^--[^\r\n]+/)![0];

  // split to parts, and drop first and last empty parts
  const parts = text.split(new RegExp(boundary + "(?:\\r\\n|--)")).slice(1, -1);

  const result: Record<string, string | Blob> = {};

  for (const part of parts) {
    const headerEnd = part.indexOf("\r\n\r\n");
    if (headerEnd === -1) continue;

    const headers = part.slice(0, headerEnd);
    const content = part.slice(headerEnd + 4);

    const nameMatch = headers.match(/name="([^"]+)"/);
    const fileNameMatch = headers.match(/filename="([^"]+)"/);

    if (nameMatch) {
      const name = nameMatch[1];

      if (fileNameMatch) {
        // it's a file
        const contentTypeMatch = headers.match(/Content-Type:\s*(\S+)/i);
        const contentType = contentTypeMatch
          ? contentTypeMatch[1]
          : "application/octet-stream";

        result[name] = new Blob([content.replace(/\r\n$/, "")], {
          type: contentType,
        });
      } else {
        // basic field
        const value = content.trim();
        result[name] = value;
      }
    }
  }

  return result;
}

{% macro paramDummyValue(param) %}
{# @pebvariable name="param" type="org.openapitools.codegen.CodegenParameter" #}
        // {{ param.paramName }}: {{ param.dataType }}
    {% if param.isFile -%}
            new Blob([]), // paramName={{ param.paramName }}
        {% elseif param.isModel -%}
            {} as unknown as {{ param.dataType }}, // paramName={{ param.paramName }}
        {% elseif param.isArray -%}
            new Set(["DUMMY1", "DUMMY2"]) as unknown as {{ param.dataType }},
        {% elseif param.isEnum -%}
            "DUMMY" as unknown as {{ param.dataType }}, // paramName={{ param.paramName }}(enum)
        {% elseif param.isExplode -%}
            "DUMMY" as unknown as {{ param.dataType}}, // paramName={{param.paramName}}(enum)
        {% elseif param.isString -%}
            "DUMMY", // {{param.paramName}}(string)
        {% elseif param.isNumber or param.isInteger or param.isLong -%}
            0, // paramName={{param.paramName}}(number or int or long)
        {% elseif param.isBoolean -%}
            true, // paramName={{param.paramName}}
        {% else -%}
            // UNKNOWN TYPE: paramName={{param.paramName}} {{ param.dataType }}
    {% endif -%}
{% endmacro %}

{% macro paramDummyValueString(param) %}
{# @pebvariable name="param" type="org.openapitools.codegen.CodegenParameter" #}
        // {{ param.paramName }}: {{ param.dataType }}
    {% if param.isFile -%}
            new Blob([]), // paramName={{ param.paramName }}
        {% elseif param.isModel -%}
            {} as unknown as {{ param.dataType }}, // paramName={{ param.paramName }}
        {% elseif param.isArray -%}
            "DUMMY1,DUMMY2" as unknown as {{ param.dataType }},
        {% elseif param.isEnum -%}
            "DUMMY" as unknown as {{ param.dataType }}, // paramName={{ param.paramName }}(enum)
        {% elseif param.isExplode -%}
            "DUMMY" as unknown as {{ param.dataType}}, // paramName={{param.paramName}}(enum)
        {% elseif param.isString -%}
            "DUMMY", // {{param.paramName}}(string)
        {% elseif param.isNumber or param.isInteger or param.isLong -%}
            0, // paramName={{param.paramName}}(number or int or long)
        {% elseif param.isBoolean -%}
            true, // paramName={{param.paramName}}
        {% else -%}
            // UNKNOWN TYPE: paramName={{param.paramName}} {{ param.dataType }}
    {% endif -%}
{% endmacro %}

{% macro renderTest(operations, op, authMethods, withHttpInfo) %}
{# @pebvariable name="withHttpInfo" type="java.lang.Boolean" #}
{# @pebvariable name="op" type="org.openapitools.codegen.CodegenOperation" #}
  it("{{op.nickname}}{% if withHttpInfo %}WithHttpInfo{% endif %}", async () => {
    let requestCount = 0;

    const server = createServer((req, res) => {
      requestCount++;

      equal(req.method, "{{ op.httpMethod }}");
      ok(req.url)
      const reqUrl = new URL(req.url, "http://localhost/");
      equal(reqUrl.pathname, "{{ op.path }}"
        {% for param in op.allParams -%}
    {% if param.isNumber or param.isInteger or param.isLong -%}
                    .replace("{{ "{" + param.paramName + "}" }}", "0") // number
                {% elseif param.isString -%}
                    .replace("{{ "{" + param.paramName + "}" }}", "DUMMY") // string
            {% endif -%}
{% endfor %}{# allParams #}
        );


      {% if op.hasQueryParams %}
      // Query parameters
      const queryParams = new URLSearchParams(reqUrl.search);
          {% for param in op.queryParams -%}
      equal(queryParams.get("{{param.baseName}}"), String({{ paramDummyValueString(param) }}));
          {% endfor %}
{% endif %}
    {% if authMethods != null -%}
      equal(
        req.headers["authorization"],
        `Bearer ${channel_access_token}`,
      );
    {% endif -%}
      equal(
        req.headers["user-agent"],
        "@line/bot-sdk/1.0.0-test",
      );
      {% if op.isMultipart %}
      const contentType = req.headers["content-type"];
      ok(contentType);
      ok(
        contentType
          .startsWith(`multipart/form-data; boundary=`),
      );
      {% endif %}

      {% if op.hasFormParams and op.isMultipart %}
        let data: Buffer[] = [];

        req.on('data', chunk => {
          data.push(chunk);
        });

        req.on('end', () => {
          // Combine the data chunks into a single Buffer
          const buffer = Buffer.concat(data);

          // Convert Buffer to ArrayBuffer
          const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);

          // Form parameters
          const formData = parseForm(arrayBuffer);
          {% for param in op.formParams -%}
          equal(formData["{{param.paramName}}"], String({{ paramDummyValueString(param) }}));
          {% endfor %}

          res.writeHead(200, { "Content-Type": "application/json" });
          res.end(JSON.stringify({}));
        });
      {% else %}
        res.writeHead(200, { "Content-Type": "application/json" });
        res.end(JSON.stringify({}));
      {% endif %}
    });
    await new Promise((resolve) => {
      server.listen(0);
      server.on('listening', resolve);
    });

    const serverAddress = server.address();
    if (typeof serverAddress === "string" || serverAddress === null) {
       throw new Error("Unexpected server address: " + serverAddress);
    }

    const client = new {{operations.classname}}({
    {% if authMethods != null -%}
        channelAccessToken: channel_access_token,
    {% endif -%}
        baseURL: `http://localhost:${String(serverAddress.port)}/`
    });

    const res = await client.{{op.nickname}}{% if withHttpInfo %}WithHttpInfo{% endif %}(
{% for param in op.allParams -%}
{{ paramDummyValue(param) }}
{% endfor %}
    );

    equal(requestCount, 1);
    server.close();
  });

{% endmacro %}

describe("{{operations.classname}}", () => {
{% for op in operations.operation %}
    {{ renderTest(operations, op, authMethods, true) }}
    {{ renderTest(operations, op, authMethods, false) }}
{% endfor %}{# op #}
});