323 lines
9 KiB
TypeScript
323 lines
9 KiB
TypeScript
import { afterAll, beforeAll, describe, expect, it, onTestFailed } from "vitest";
|
|
import { PrismaClient } from "@prisma/client";
|
|
|
|
import { isDateString } from "./lib";
|
|
|
|
const prisma = new PrismaClient({
|
|
datasourceUrl: process.env.TEST_DATABASE_URL || process.env.DATABASE_URL,
|
|
});
|
|
const baseUrl = process.env.TEST_BASE_URL || "http://localhost";
|
|
const record: Record<string, any> = {
|
|
code: "CMT",
|
|
taxNo: "1052299402851",
|
|
name: "Chamomind",
|
|
nameEN: "Chamomind",
|
|
email: "contact@chamomind.com",
|
|
lineId: "@chamomind",
|
|
telephoneNo: "0988929248",
|
|
contactName: "John",
|
|
webUrl: "https://chamomind.com",
|
|
latitude: "",
|
|
longitude: "",
|
|
virtual: false,
|
|
permitNo: "1135182804792",
|
|
permitIssueDate: "2025-01-01T00:00:00.000Z",
|
|
permitExpireDate: "2030-01-01T00:00:00.000Z",
|
|
address: "11/3",
|
|
addressEN: "11/3",
|
|
soi: "1",
|
|
soiEN: "1",
|
|
moo: "2",
|
|
mooEN: "2",
|
|
street: "Straight",
|
|
streetEN: "Straight",
|
|
provinceId: "50",
|
|
districtId: "5001",
|
|
subDistrictId: "500107",
|
|
};
|
|
const recordList: Record<string, any>[] = [];
|
|
|
|
let token: string;
|
|
|
|
beforeAll(async () => {
|
|
const body = new URLSearchParams();
|
|
|
|
body.append("grant_type", "password");
|
|
body.append("client_id", "app");
|
|
body.append("username", process.env.TEST_USERNAME || "");
|
|
body.append("password", process.env.TEST_PASSWORD || "");
|
|
body.append("scope", "openid");
|
|
|
|
const res = await fetch(
|
|
process.env.KC_URL + "/realms/" + process.env.KC_REALM + "/protocol/openid-connect/token",
|
|
{
|
|
method: "POST",
|
|
body: body,
|
|
},
|
|
);
|
|
|
|
expect(res.ok).toBe(true);
|
|
|
|
await res.json().then((data) => {
|
|
token = data["access_token"];
|
|
});
|
|
});
|
|
|
|
afterAll(async () => {
|
|
if (!record["id"]) return;
|
|
|
|
await prisma.branch.deleteMany({
|
|
where: { id: { in: [record, ...recordList].map((v) => v["id"]) } },
|
|
});
|
|
await prisma.runningNo.deleteMany({
|
|
where: {
|
|
key: { in: [record, ...recordList].map((v) => `MAIN_BRANCH_${v["code"].slice(0, -5)}`) },
|
|
},
|
|
});
|
|
});
|
|
|
|
describe("branch management", () => {
|
|
it("create branch without required fields", async () => {
|
|
const requiredFields = [
|
|
"taxNo",
|
|
"name",
|
|
"nameEN",
|
|
"permitNo",
|
|
"telephoneNo",
|
|
"address",
|
|
"addressEN",
|
|
"email",
|
|
];
|
|
onTestFailed(() => console.log("Field:", requiredFields, "is required."));
|
|
|
|
for await (const field of requiredFields) {
|
|
const res = await fetch(baseUrl + "/api/v1/branch", {
|
|
method: "POST",
|
|
headers: {
|
|
["Content-Type"]: "application/json",
|
|
["Authorization"]: "Bearer " + token,
|
|
},
|
|
body: JSON.stringify({ ...record, [field]: undefined }),
|
|
});
|
|
|
|
if (res.ok) recordList.push(await res.json());
|
|
|
|
expect(res.ok).toBe(false);
|
|
expect(res.status).toBe(400);
|
|
}
|
|
});
|
|
|
|
it("create branch", async () => {
|
|
const res = await fetch(baseUrl + "/api/v1/branch", {
|
|
method: "POST",
|
|
headers: {
|
|
["Content-Type"]: "application/json",
|
|
["Authorization"]: "Bearer " + token,
|
|
},
|
|
body: JSON.stringify(record),
|
|
});
|
|
if (!res.ok) {
|
|
const text = await res.text();
|
|
try {
|
|
console.log(JSON.parse(text));
|
|
} catch (e) {
|
|
console.log(text);
|
|
}
|
|
}
|
|
|
|
expect(res.ok).toBe(true);
|
|
|
|
const data = await res.json();
|
|
|
|
record["id"] = data["id"]; // This field is auto generated
|
|
record["code"] = data["code"]; // This field is auto generated
|
|
|
|
recordList.push(data);
|
|
|
|
expect(data).toMatchObject(record);
|
|
});
|
|
|
|
it("get branch list", async () => {
|
|
const res = await fetch(baseUrl + "/api/v1/branch", {
|
|
method: "GET",
|
|
headers: {
|
|
["Authorization"]: "Bearer " + token,
|
|
},
|
|
});
|
|
if (!res.ok) {
|
|
const text = await res.text();
|
|
try {
|
|
console.log(JSON.parse(text));
|
|
} catch (e) {
|
|
console.log(text);
|
|
}
|
|
}
|
|
|
|
expect(res.ok).toBe(true);
|
|
|
|
const data = await res.json();
|
|
|
|
expect(data).toHaveProperty("result");
|
|
expect(data).toHaveProperty("total");
|
|
expect(data).toHaveProperty("page");
|
|
expect(data).toHaveProperty("pageSize");
|
|
expect(data.result).toEqual(
|
|
expect.arrayContaining([
|
|
expect.objectContaining({
|
|
id: expect.any(String),
|
|
code: expect.any(String),
|
|
virtual: expect.any(Boolean),
|
|
name: expect.any(String),
|
|
nameEN: expect.any(String),
|
|
email: expect.any(String),
|
|
taxNo: expect.any(String),
|
|
telephoneNo: expect.any(String),
|
|
latitude: expect.any(String),
|
|
longitude: expect.any(String),
|
|
contactName: expect.toBeOneOf([expect.any(String), null]),
|
|
lineId: expect.toBeOneOf([expect.any(String), null]),
|
|
webUrl: expect.toBeOneOf([expect.any(String), null]),
|
|
remark: expect.toBeOneOf([expect.any(String), null]),
|
|
selectedImage: expect.toBeOneOf([expect.any(String), null]),
|
|
|
|
isHeadOffice: expect.any(Boolean),
|
|
|
|
permitNo: expect.any(String),
|
|
permitIssueDate: expect.toSatisfy(isDateString(true)),
|
|
permitExpireDate: expect.toSatisfy(isDateString(true)),
|
|
|
|
address: expect.any(String),
|
|
addressEN: expect.any(String),
|
|
moo: expect.toBeOneOf([expect.any(String), null]),
|
|
mooEN: expect.toBeOneOf([expect.any(String), null]),
|
|
street: expect.toBeOneOf([expect.any(String), null]),
|
|
streetEN: expect.toBeOneOf([expect.any(String), null]),
|
|
provinceId: expect.any(String),
|
|
province: expect.objectContaining({
|
|
id: expect.any(String),
|
|
name: expect.any(String),
|
|
nameEN: expect.any(String),
|
|
}),
|
|
districtId: expect.any(String),
|
|
district: expect.objectContaining({
|
|
id: expect.any(String),
|
|
name: expect.any(String),
|
|
nameEN: expect.any(String),
|
|
}),
|
|
subDistrictId: expect.any(String),
|
|
subDistrict: expect.objectContaining({
|
|
id: expect.any(String),
|
|
name: expect.any(String),
|
|
nameEN: expect.any(String),
|
|
zipCode: expect.any(String),
|
|
}),
|
|
|
|
status: expect.toBeOneOf(["CREATED", "ACTIVE", "INACTIVE"]),
|
|
statusOrder: expect.toBeOneOf([1, 0]),
|
|
|
|
createdAt: expect.toSatisfy(isDateString()),
|
|
createdByUserId: expect.toBeOneOf([expect.any(String), null]),
|
|
createdBy: expect.objectContaining({
|
|
id: expect.any(String),
|
|
username: expect.any(String),
|
|
firstName: expect.any(String),
|
|
lastName: expect.any(String),
|
|
firstNameEN: expect.any(String),
|
|
lastNameEN: expect.any(String),
|
|
}),
|
|
updatedAt: expect.toSatisfy(isDateString()),
|
|
updatedByUserId: expect.toBeOneOf([expect.any(String), null]),
|
|
updatedBy: expect.objectContaining({
|
|
id: expect.any(String),
|
|
username: expect.any(String),
|
|
firstName: expect.any(String),
|
|
lastName: expect.any(String),
|
|
firstNameEN: expect.any(String),
|
|
lastNameEN: expect.any(String),
|
|
}),
|
|
|
|
_count: expect.objectContaining({
|
|
branch: expect.any(Number),
|
|
}),
|
|
}),
|
|
]),
|
|
);
|
|
});
|
|
|
|
it("get branch by id", async () => {
|
|
const res = await fetch(baseUrl + "/api/v1/branch/" + record["id"], {
|
|
method: "GET",
|
|
headers: {
|
|
["Authorization"]: "Bearer " + token,
|
|
},
|
|
});
|
|
if (!res.ok) {
|
|
const text = await res.text();
|
|
try {
|
|
console.log(JSON.parse(text));
|
|
} catch (e) {
|
|
console.log(text);
|
|
}
|
|
}
|
|
|
|
expect(res.ok).toBe(true);
|
|
|
|
const data = await res.json();
|
|
|
|
expect(data).toMatchObject(record);
|
|
});
|
|
|
|
it("update branch by id", async () => {
|
|
const res = await fetch(baseUrl + "/api/v1/branch/" + record["id"], {
|
|
method: "PUT",
|
|
headers: {
|
|
["Content-Type"]: "application/json",
|
|
["Authorization"]: "Bearer " + token,
|
|
},
|
|
body: JSON.stringify({ name: "Chamomind Intl.", nameEN: "Chamomind Intl." }),
|
|
});
|
|
|
|
record["name"] = "Chamomind Intl.";
|
|
record["nameEN"] = "Chamomind Intl.";
|
|
|
|
expect(res.ok).toBe(true);
|
|
|
|
const data = await res.json();
|
|
|
|
expect(data).toMatchObject(record);
|
|
});
|
|
|
|
it("delete branch by id", async () => {
|
|
const res = await fetch(baseUrl + "/api/v1/branch/" + record["id"], {
|
|
method: "DELETE",
|
|
headers: {
|
|
["Content-Type"]: "application/json",
|
|
["Authorization"]: "Bearer " + token,
|
|
},
|
|
});
|
|
if (!res.ok) {
|
|
const text = await res.text();
|
|
try {
|
|
console.log(JSON.parse(text));
|
|
} catch (e) {
|
|
console.log(text);
|
|
}
|
|
}
|
|
expect(res.ok).toBe(true);
|
|
|
|
const data = await res.json();
|
|
|
|
expect(data).toMatchObject(record);
|
|
});
|
|
|
|
it("get deleted branch by id", async () => {
|
|
const res = await fetch(baseUrl + "/api/v1/branch/" + record["id"], {
|
|
method: "GET",
|
|
headers: {
|
|
["Authorization"]: "Bearer " + token,
|
|
},
|
|
});
|
|
|
|
expect(res.ok).toBe(false);
|
|
});
|
|
});
|