fix: ref e2e tests
This commit is contained in:
montaghanmy
@@ -1,239 +0,0 @@
|
||||
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
|
||||
// @ts-nocheck
|
||||
import { beforeAll, describe, expect, it } from "@jest/globals";
|
||||
import { init, TestPlatform } from "./setup";
|
||||
import { v1 as uuidv1 } from "uuid";
|
||||
import { CounterAPI } from "../../src/core/platform/services/counter/types";
|
||||
import {
|
||||
WorkspaceCounterEntity,
|
||||
WorkspaceCounterPrimaryKey,
|
||||
WorkspaceCounterType,
|
||||
} from "../../src/services/workspaces/entities/workspace_counters";
|
||||
import { CounterProvider } from "../../src/core/platform/services/counter/provider";
|
||||
import WorkspaceUser, {
|
||||
getInstance as getWorkspaceUserInstance,
|
||||
TYPE as WorkspaceUserEntityType,
|
||||
} from "../../src/services/workspaces/entities/workspace_user";
|
||||
|
||||
import { countRepositoryItems } from "../../src/utils/counters";
|
||||
import { TestDbService } from "./utils.prepare.db";
|
||||
import {
|
||||
ChannelCounterEntity,
|
||||
ChannelCounterPrimaryKey,
|
||||
ChannelUserCounterType,
|
||||
} from "../../src/services/channels/entities/channel-counters";
|
||||
import { ChannelMemberType } from "../../src/services/channels/types";
|
||||
import { getMemberOfChannelInstance, MemberOfChannel } from "../../src/services/channels/entities";
|
||||
import gr from "../../src/services/global-resolver";
|
||||
|
||||
describe("Counters implementation", () => {
|
||||
let platform: TestPlatform;
|
||||
// let database: DatabaseServiceAPI;
|
||||
let counterApi: CounterAPI;
|
||||
let testDbService: TestDbService;
|
||||
|
||||
beforeAll(async ends => {
|
||||
platform = await init();
|
||||
|
||||
testDbService = new TestDbService(platform);
|
||||
|
||||
await gr.database.getConnector().drop();
|
||||
|
||||
counterApi = platform.platform.getProvider<CounterAPI>("counter");
|
||||
expect(counterApi).toBeTruthy();
|
||||
|
||||
ends();
|
||||
});
|
||||
|
||||
afterAll(done => {
|
||||
platform.tearDown().then(done);
|
||||
});
|
||||
|
||||
const getCounter = async (type, entity) => {
|
||||
return counterApi.getCounter<entity>(await testDbService.getRepository<entity>(type, entity));
|
||||
};
|
||||
|
||||
describe("Workspace counters", () => {
|
||||
let counter: CounterProvider;
|
||||
const counterPk = { id: uuidv1(), counter_type: WorkspaceCounterType.MEMBERS };
|
||||
|
||||
beforeAll(async ends => {
|
||||
counter = await getCounter("workspace_counters", WorkspaceCounterEntity);
|
||||
|
||||
const workspaceUserRepository = await testDbService.getRepository(
|
||||
WorkspaceUserEntityType,
|
||||
WorkspaceUser,
|
||||
);
|
||||
|
||||
await workspaceUserRepository.save(
|
||||
getWorkspaceUserInstance({
|
||||
workspaceId: counterPk.id,
|
||||
userId: uuidv1(),
|
||||
id: uuidv1(),
|
||||
}),
|
||||
);
|
||||
|
||||
expect(counter).toBeTruthy();
|
||||
|
||||
ends();
|
||||
});
|
||||
|
||||
it("Initializing empty value", async done => {
|
||||
await counter.increase(counterPk, 0);
|
||||
const val = await counter.get(counterPk);
|
||||
expect(val).toEqual(0);
|
||||
done();
|
||||
});
|
||||
|
||||
it("Adding value", async done => {
|
||||
// adding 1
|
||||
|
||||
await counter.increase(counterPk, 1);
|
||||
let val = await counter.get(counterPk);
|
||||
expect(val).toEqual(1);
|
||||
|
||||
// adding 2
|
||||
|
||||
await counter.increase(counterPk, 2);
|
||||
val = await counter.get(counterPk);
|
||||
expect(val).toEqual(3);
|
||||
|
||||
done();
|
||||
});
|
||||
|
||||
it("Subtracting value", async done => {
|
||||
// Subtracting 2
|
||||
|
||||
await counter.increase(counterPk, -2);
|
||||
let val = await counter.get(counterPk);
|
||||
expect(val).toEqual(1);
|
||||
|
||||
// Subtracting 10
|
||||
|
||||
await counter.increase(counterPk, -10);
|
||||
val = await counter.get(counterPk);
|
||||
expect(val).toEqual(-9);
|
||||
|
||||
done();
|
||||
});
|
||||
|
||||
it("Revising counter", async done => {
|
||||
// Subtracting 2
|
||||
|
||||
const workspaceUserRepository = await testDbService.getRepository(
|
||||
WorkspaceUserEntityType,
|
||||
WorkspaceUser,
|
||||
);
|
||||
|
||||
counter.setReviseCallback(async (pk: WorkspaceCounterPrimaryKey) => {
|
||||
if (pk.counter_type == "members") {
|
||||
return countRepositoryItems(workspaceUserRepository, { workspace_id: pk.id });
|
||||
}
|
||||
}, 4);
|
||||
|
||||
await counter.increase(counterPk, 1);
|
||||
const val = await counter.get(counterPk);
|
||||
expect(val).toEqual(1);
|
||||
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
describe("Channel counters", () => {
|
||||
let counter: CounterProvider;
|
||||
let counterPk: ChannelCounterPrimaryKey;
|
||||
|
||||
beforeAll(async ends => {
|
||||
counterPk = {
|
||||
id: uuidv1(),
|
||||
company_id: uuidv1(),
|
||||
workspace_id: uuidv1(),
|
||||
counter_type: ChannelUserCounterType.MEMBERS,
|
||||
};
|
||||
|
||||
counter = await getCounter("channel_counters", ChannelCounterEntity);
|
||||
|
||||
const memberOfChannelRepository = await testDbService.getRepository(
|
||||
"channel_members",
|
||||
MemberOfChannel,
|
||||
);
|
||||
|
||||
await memberOfChannelRepository.save(
|
||||
getMemberOfChannelInstance({
|
||||
company_id: counterPk.company_id,
|
||||
workspace_id: counterPk.workspace_id,
|
||||
channel_id: counterPk.id,
|
||||
user_id: uuidv1(),
|
||||
}),
|
||||
);
|
||||
|
||||
expect(counter).toBeTruthy();
|
||||
|
||||
ends();
|
||||
});
|
||||
|
||||
it("Initializing empty value", async done => {
|
||||
await counter.increase(counterPk, 0);
|
||||
const val = await counter.get(counterPk);
|
||||
expect(val).toEqual(0);
|
||||
done();
|
||||
});
|
||||
|
||||
it("Adding value", async done => {
|
||||
// adding 1
|
||||
|
||||
await counter.increase(counterPk, 1);
|
||||
let val = await counter.get(counterPk);
|
||||
expect(val).toEqual(1);
|
||||
|
||||
// adding 2
|
||||
|
||||
await counter.increase(counterPk, 2);
|
||||
val = await counter.get(counterPk);
|
||||
expect(val).toEqual(3);
|
||||
|
||||
done();
|
||||
});
|
||||
|
||||
it("Subtracting value", async done => {
|
||||
// Subtracting 2
|
||||
|
||||
await counter.increase(counterPk, -2);
|
||||
let val = await counter.get(counterPk);
|
||||
expect(val).toEqual(1);
|
||||
|
||||
// Subtracting 10
|
||||
|
||||
await counter.increase(counterPk, -10);
|
||||
val = await counter.get(counterPk);
|
||||
expect(val).toEqual(-9);
|
||||
|
||||
done();
|
||||
});
|
||||
|
||||
it("Revising counter", async done => {
|
||||
// Subtracting 2
|
||||
|
||||
const memberOfChannelRepository = await testDbService.getRepository(
|
||||
"channel_members",
|
||||
MemberOfChannel,
|
||||
);
|
||||
|
||||
counter.setReviseCallback(async (pk: ChannelCounterPrimaryKey) => {
|
||||
if (pk.counter_type == ChannelUserCounterType.MEMBERS) {
|
||||
return countRepositoryItems(
|
||||
memberOfChannelRepository,
|
||||
{ channel_id: pk.id, company_id: pk.company_id, workspace_id: pk.workspace_id },
|
||||
{ type: ChannelMemberType.MEMBER },
|
||||
);
|
||||
}
|
||||
}, 4);
|
||||
|
||||
await counter.increase(counterPk, 1);
|
||||
const val = await counter.get(counterPk);
|
||||
expect(val).toEqual(1);
|
||||
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1 +0,0 @@
|
||||
test
|
||||
@@ -1,183 +0,0 @@
|
||||
import { afterAll, afterEach, beforeEach, describe, expect, it } from "@jest/globals";
|
||||
import { deserialize } from "class-transformer";
|
||||
import { AccessInformation } from "../../../src/services/documents/entities/drive-file";
|
||||
import { init, TestPlatform } from "../setup";
|
||||
import { TestDbService } from "../utils.prepare.db";
|
||||
import { e2e_createDocument, e2e_getDocument } from "./utils";
|
||||
|
||||
const url = "/internal/services/documents/v1";
|
||||
|
||||
describe("the Drive Twake tabs feature", () => {
|
||||
let platform: TestPlatform;
|
||||
|
||||
class DriveFileMockClass {
|
||||
id: string;
|
||||
name: string;
|
||||
size: number;
|
||||
added: string;
|
||||
parent_id: string;
|
||||
access_info: AccessInformation;
|
||||
}
|
||||
|
||||
class DriveItemDetailsMockClass {
|
||||
path: string[];
|
||||
item: DriveFileMockClass;
|
||||
children: DriveFileMockClass[];
|
||||
versions: Record<string, unknown>[];
|
||||
}
|
||||
|
||||
beforeEach(async () => {
|
||||
platform = await init({
|
||||
services: [
|
||||
"webserver",
|
||||
"database",
|
||||
"applications",
|
||||
"search",
|
||||
"storage",
|
||||
"message-queue",
|
||||
"user",
|
||||
"search",
|
||||
"files",
|
||||
"websocket",
|
||||
"messages",
|
||||
"auth",
|
||||
"realtime",
|
||||
"channels",
|
||||
"counter",
|
||||
"statistics",
|
||||
"platform-services",
|
||||
"documents",
|
||||
],
|
||||
});
|
||||
});
|
||||
|
||||
afterEach(async () => {
|
||||
await platform.tearDown();
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await platform.app.close();
|
||||
});
|
||||
|
||||
it("did create a tab configuration on Drive side", async done => {
|
||||
await TestDbService.getInstance(platform, true);
|
||||
|
||||
const item = {
|
||||
name: "new tab test file",
|
||||
parent_id: "root",
|
||||
company_id: platform.workspace.company_id,
|
||||
};
|
||||
|
||||
const version = {};
|
||||
|
||||
const response = await e2e_createDocument(platform, item, version);
|
||||
const doc = deserialize<DriveFileMockClass>(DriveFileMockClass, response.body);
|
||||
|
||||
const tab = {
|
||||
company_id: platform.workspace.company_id,
|
||||
tab_id: "1234567890",
|
||||
channel_id: "abcdefghij",
|
||||
item_id: doc.id,
|
||||
level: "write",
|
||||
};
|
||||
|
||||
const token = await platform.auth.getJWTToken();
|
||||
|
||||
const createdTab = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/tabs/${tab.tab_id}`,
|
||||
headers: {
|
||||
authorization: `Bearer ${token}`,
|
||||
},
|
||||
payload: tab,
|
||||
});
|
||||
|
||||
expect(createdTab.statusCode).toBe(200);
|
||||
expect(createdTab.body).toBeDefined();
|
||||
expect(createdTab.json().company_id).toBe(tab.company_id);
|
||||
expect(createdTab.json().tab_id).toBe(tab.tab_id);
|
||||
expect(createdTab.json().item_id).toBe(tab.item_id);
|
||||
|
||||
const getTabResponse = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/tabs/${tab.tab_id}`,
|
||||
headers: {
|
||||
authorization: `Bearer ${token}`,
|
||||
},
|
||||
});
|
||||
|
||||
expect(getTabResponse.statusCode).toBe(200);
|
||||
expect(getTabResponse.body).toBeDefined();
|
||||
expect(getTabResponse.json().company_id).toBe(tab.company_id);
|
||||
expect(getTabResponse.json().tab_id).toBe(tab.tab_id);
|
||||
expect(getTabResponse.json().item_id).toBe(tab.item_id);
|
||||
|
||||
const documentResponse = await e2e_getDocument(platform, doc.id);
|
||||
const documentResult = deserialize<DriveItemDetailsMockClass>(
|
||||
DriveItemDetailsMockClass,
|
||||
documentResponse.body,
|
||||
);
|
||||
|
||||
console.log(documentResult?.item);
|
||||
|
||||
expect(
|
||||
documentResult?.item?.access_info?.entities?.find(
|
||||
a => a?.type === "channel" && a.id === "abcdefghij" && a.level === "write",
|
||||
),
|
||||
).toBeDefined();
|
||||
|
||||
done?.();
|
||||
});
|
||||
|
||||
it("did refuse to create a tab configuration for an item I can't manage", async done => {
|
||||
const dbService = await TestDbService.getInstance(platform, true);
|
||||
const ws0pk = {
|
||||
id: platform.workspace.workspace_id,
|
||||
company_id: platform.workspace.company_id,
|
||||
};
|
||||
const otherUser = await dbService.createUser([ws0pk]);
|
||||
|
||||
const item = {
|
||||
name: "new tab test file",
|
||||
parent_id: "root",
|
||||
company_id: platform.workspace.company_id,
|
||||
access_info: {
|
||||
entities: [
|
||||
{
|
||||
type: "folder",
|
||||
id: "parent",
|
||||
level: "none",
|
||||
} as any,
|
||||
],
|
||||
},
|
||||
};
|
||||
|
||||
const version = {};
|
||||
|
||||
const response = await e2e_createDocument(platform, item, version);
|
||||
const doc = deserialize<DriveFileMockClass>(DriveFileMockClass, response.body);
|
||||
|
||||
const tab = {
|
||||
company_id: platform.workspace.company_id,
|
||||
tab_id: "1234567890",
|
||||
channel_id: "abcdefghij",
|
||||
item_id: doc.id,
|
||||
level: "read",
|
||||
};
|
||||
|
||||
const token = await platform.auth.getJWTToken({ sub: otherUser.id });
|
||||
|
||||
const createdTab = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/tabs/${tab.tab_id}`,
|
||||
headers: {
|
||||
authorization: `Bearer ${token}`,
|
||||
},
|
||||
payload: tab,
|
||||
});
|
||||
|
||||
expect(createdTab.statusCode).toBe(403);
|
||||
|
||||
done?.();
|
||||
});
|
||||
});
|
||||
@@ -1,238 +0,0 @@
|
||||
import { describe, beforeEach, afterEach, it, expect, afterAll } from "@jest/globals";
|
||||
import { deserialize } from "class-transformer";
|
||||
import { File } from "../../../src/services/files/entities/file";
|
||||
import { ResourceUpdateResponse } from "../../../src/utils/types";
|
||||
import { init, TestPlatform } from "../setup";
|
||||
import { TestDbService } from "../utils.prepare.db";
|
||||
import {
|
||||
e2e_createDocument,
|
||||
e2e_createDocumentFile,
|
||||
e2e_createVersion,
|
||||
e2e_deleteDocument,
|
||||
e2e_getDocument,
|
||||
e2e_searchDocument,
|
||||
e2e_updateDocument,
|
||||
} from "./utils";
|
||||
|
||||
describe("the Drive feature", () => {
|
||||
let platform: TestPlatform;
|
||||
|
||||
class DriveFileMockClass {
|
||||
id: string;
|
||||
name: string;
|
||||
size: number;
|
||||
added: string;
|
||||
parent_id: string;
|
||||
}
|
||||
|
||||
class DriveItemDetailsMockClass {
|
||||
path: string[];
|
||||
item: DriveFileMockClass;
|
||||
children: DriveFileMockClass[];
|
||||
versions: Record<string, unknown>[];
|
||||
}
|
||||
|
||||
class SearchResultMockClass {
|
||||
entities: DriveFileMockClass[];
|
||||
}
|
||||
|
||||
beforeEach(async () => {
|
||||
platform = await init({
|
||||
services: [
|
||||
"webserver",
|
||||
"database",
|
||||
"applications",
|
||||
"search",
|
||||
"storage",
|
||||
"message-queue",
|
||||
"user",
|
||||
"search",
|
||||
"files",
|
||||
"websocket",
|
||||
"messages",
|
||||
"auth",
|
||||
"realtime",
|
||||
"channels",
|
||||
"counter",
|
||||
"statistics",
|
||||
"platform-services",
|
||||
"documents",
|
||||
],
|
||||
});
|
||||
});
|
||||
|
||||
afterEach(async () => {
|
||||
await platform.tearDown();
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await platform.app.close();
|
||||
});
|
||||
|
||||
const createItem = async (): Promise<DriveFileMockClass> => {
|
||||
await TestDbService.getInstance(platform, true);
|
||||
|
||||
const item = {
|
||||
name: "new test file",
|
||||
parent_id: "root",
|
||||
company_id: platform.workspace.company_id,
|
||||
};
|
||||
|
||||
const version = {};
|
||||
|
||||
const response = await e2e_createDocument(platform, item, version);
|
||||
return deserialize<DriveFileMockClass>(DriveFileMockClass, response.body);
|
||||
};
|
||||
|
||||
it("did create the drive item", async done => {
|
||||
const result = await createItem();
|
||||
|
||||
expect(result).toBeDefined();
|
||||
expect(result.name).toEqual("new test file");
|
||||
expect(result.added).toBeDefined();
|
||||
|
||||
done?.();
|
||||
});
|
||||
|
||||
it("did fetch the drive item", async done => {
|
||||
await TestDbService.getInstance(platform, true);
|
||||
|
||||
const response = await e2e_getDocument(platform, "");
|
||||
const result = deserialize<DriveItemDetailsMockClass>(DriveItemDetailsMockClass, response.body);
|
||||
|
||||
expect(result.item.name).toEqual("root");
|
||||
|
||||
done?.();
|
||||
});
|
||||
|
||||
it("did fetch the trash", async done => {
|
||||
await TestDbService.getInstance(platform, true);
|
||||
|
||||
const response = await e2e_getDocument(platform, "trash");
|
||||
const result = deserialize<DriveItemDetailsMockClass>(DriveItemDetailsMockClass, response.body);
|
||||
|
||||
expect(result.item.name).toEqual("trash");
|
||||
|
||||
done?.();
|
||||
});
|
||||
|
||||
it("did delete an item", async done => {
|
||||
const createItemResult = await createItem();
|
||||
|
||||
expect(createItemResult.id).toBeDefined();
|
||||
|
||||
const deleteResponse = await e2e_deleteDocument(platform, createItemResult.id);
|
||||
expect(deleteResponse.statusCode).toEqual(200);
|
||||
|
||||
done?.();
|
||||
});
|
||||
|
||||
it("did update an item", async done => {
|
||||
const createItemResult = await createItem();
|
||||
|
||||
expect(createItemResult.id).toBeDefined();
|
||||
|
||||
const update = {
|
||||
name: "somethingelse",
|
||||
};
|
||||
|
||||
const updateItemResponse = await e2e_updateDocument(platform, createItemResult.id, update);
|
||||
const updateItemResult = deserialize<DriveFileMockClass>(
|
||||
DriveFileMockClass,
|
||||
updateItemResponse.body,
|
||||
);
|
||||
|
||||
expect(createItemResult.id).toEqual(updateItemResult.id);
|
||||
expect(updateItemResult.name).toEqual("somethingelse");
|
||||
|
||||
done?.();
|
||||
});
|
||||
|
||||
it("did move an item to trash", async done => {
|
||||
const createItemResult = await createItem();
|
||||
|
||||
expect(createItemResult.id).toBeDefined();
|
||||
|
||||
const moveToTrashResponse = await e2e_deleteDocument(platform, createItemResult.id);
|
||||
expect(moveToTrashResponse.statusCode).toEqual(200);
|
||||
|
||||
const listTrashResponse = await e2e_getDocument(platform, "trash");
|
||||
const listTrashResult = deserialize<DriveItemDetailsMockClass>(
|
||||
DriveItemDetailsMockClass,
|
||||
listTrashResponse.body,
|
||||
);
|
||||
|
||||
expect(listTrashResult.item.name).toEqual("trash");
|
||||
expect(listTrashResult.children.some(({ id }) => id === createItemResult.id)).toBeTruthy();
|
||||
|
||||
done?.();
|
||||
});
|
||||
|
||||
// TODO: wait for elastic search index
|
||||
it("did search for an item", async done => {
|
||||
const createItemResult = await createItem();
|
||||
|
||||
expect(createItemResult.id).toBeDefined();
|
||||
|
||||
await e2e_getDocument(platform, "root");
|
||||
await e2e_getDocument(platform, createItemResult.id);
|
||||
|
||||
await new Promise(resolve => setTimeout(resolve, 3000));
|
||||
|
||||
const searchPayload = {
|
||||
search: "test",
|
||||
};
|
||||
|
||||
const searchResponse = await e2e_searchDocument(platform, searchPayload);
|
||||
const searchResult = deserialize<SearchResultMockClass>(
|
||||
SearchResultMockClass,
|
||||
searchResponse.body,
|
||||
);
|
||||
|
||||
expect(searchResult.entities.length).toBeGreaterThanOrEqual(1);
|
||||
|
||||
done?.();
|
||||
});
|
||||
|
||||
it("did search for an item that doesn't exist", async done => {
|
||||
await createItem();
|
||||
|
||||
const unexistingSeachPayload = {
|
||||
search: "somethingthatdoesn'tandshouldn'texist",
|
||||
};
|
||||
const failSearchResponse = await e2e_searchDocument(platform, unexistingSeachPayload);
|
||||
const failSearchResult = deserialize<SearchResultMockClass>(
|
||||
SearchResultMockClass,
|
||||
failSearchResponse.body,
|
||||
);
|
||||
|
||||
expect(failSearchResult.entities).toHaveLength(0);
|
||||
|
||||
done?.();
|
||||
});
|
||||
|
||||
it("did create a version for a drive item", async done => {
|
||||
const item = await createItem();
|
||||
const fileUploadResponse = await e2e_createDocumentFile(platform);
|
||||
const fileUploadResult = deserialize<ResourceUpdateResponse<File>>(
|
||||
ResourceUpdateResponse,
|
||||
fileUploadResponse.body,
|
||||
);
|
||||
|
||||
const file_metadata = { external_id: fileUploadResult.resource.id };
|
||||
|
||||
await e2e_createVersion(platform, item.id, { filename: "file2", file_metadata });
|
||||
await e2e_createVersion(platform, item.id, { filename: "file3", file_metadata });
|
||||
await e2e_createVersion(platform, item.id, { filename: "file4", file_metadata });
|
||||
|
||||
const fetchItemResponse = await e2e_getDocument(platform, item.id);
|
||||
const fetchItemResult = deserialize<DriveItemDetailsMockClass>(
|
||||
DriveItemDetailsMockClass,
|
||||
fetchItemResponse.body,
|
||||
);
|
||||
|
||||
expect(fetchItemResult.versions).toHaveLength(4);
|
||||
|
||||
done?.();
|
||||
});
|
||||
});
|
||||
@@ -1,116 +0,0 @@
|
||||
import { DriveFile } from "../../../src/services/documents/entities/drive-file";
|
||||
import { FileVersion } from "../../../src/services/documents/entities/file-version";
|
||||
import { TestPlatform } from "../setup";
|
||||
import formAutoContent from "form-auto-content";
|
||||
import fs from "fs";
|
||||
|
||||
const url = "/internal/services/documents/v1";
|
||||
|
||||
export const e2e_createDocument = async (
|
||||
platform: TestPlatform,
|
||||
item: Partial<DriveFile>,
|
||||
version: Partial<FileVersion>,
|
||||
) => {
|
||||
const token = await platform.auth.getJWTToken();
|
||||
|
||||
return await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/item`,
|
||||
headers: {
|
||||
authorization: `Bearer ${token}`,
|
||||
},
|
||||
payload: {
|
||||
item,
|
||||
version,
|
||||
},
|
||||
});
|
||||
};
|
||||
|
||||
export const e2e_getDocument = async (platform: TestPlatform, id: string | "root" | "trash") => {
|
||||
const token = await platform.auth.getJWTToken();
|
||||
|
||||
return await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/item/${id}`,
|
||||
headers: {
|
||||
authorization: `Bearer ${token}`,
|
||||
},
|
||||
});
|
||||
};
|
||||
|
||||
export const e2e_deleteDocument = async (platform: TestPlatform, id: string | "root" | "trash") => {
|
||||
const token = await platform.auth.getJWTToken();
|
||||
|
||||
return await platform.app.inject({
|
||||
method: "DELETE",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/item/${id}`,
|
||||
headers: {
|
||||
authorization: `Bearer ${token}`,
|
||||
},
|
||||
});
|
||||
};
|
||||
|
||||
export const e2e_updateDocument = async (
|
||||
platform: TestPlatform,
|
||||
id: string | "root" | "trash",
|
||||
item: Partial<DriveFile>,
|
||||
) => {
|
||||
const token = await platform.auth.getJWTToken();
|
||||
|
||||
return await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/item/${id}`,
|
||||
headers: {
|
||||
authorization: `Bearer ${token}`,
|
||||
},
|
||||
payload: item,
|
||||
});
|
||||
};
|
||||
|
||||
export const e2e_searchDocument = async (
|
||||
platform: TestPlatform,
|
||||
payload: Record<string, string>,
|
||||
) => {
|
||||
const token = await platform.auth.getJWTToken();
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/search`,
|
||||
headers: {
|
||||
authorization: `Bearer ${token}`,
|
||||
},
|
||||
payload,
|
||||
});
|
||||
|
||||
return response;
|
||||
};
|
||||
|
||||
export const e2e_createVersion = async (
|
||||
platform: TestPlatform,
|
||||
id: string,
|
||||
payload: Partial<FileVersion>,
|
||||
) => {
|
||||
const token = await platform.auth.getJWTToken();
|
||||
|
||||
return await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/item/${id}/version`,
|
||||
headers: {
|
||||
authorization: `Bearer ${token}`,
|
||||
},
|
||||
payload,
|
||||
});
|
||||
};
|
||||
|
||||
export const e2e_createDocumentFile = async (platform: TestPlatform) => {
|
||||
const filePath = `${__dirname}/assets/test.txt`;
|
||||
const token = await platform.auth.getJWTToken();
|
||||
const form = formAutoContent({ file: fs.createReadStream(filePath) });
|
||||
form.headers["authorization"] = `Bearer ${token}`;
|
||||
|
||||
return await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `/internal/services/files/v1/companies/${platform.workspace.company_id}/files`,
|
||||
...form,
|
||||
});
|
||||
};
|
||||
@@ -1,155 +0,0 @@
|
||||
import { afterAll, beforeAll, beforeEach, describe, expect, it } from "@jest/globals";
|
||||
import { init, TestPlatform } from "./setup";
|
||||
|
||||
import { v1 as uuidv1 } from "uuid";
|
||||
import {
|
||||
createMessage,
|
||||
createParticipant,
|
||||
e2e_createMessage,
|
||||
e2e_createThread,
|
||||
} from "./messages/utils";
|
||||
import { Thread } from "../../src/services/messages/entities/threads";
|
||||
import { deserialize } from "class-transformer";
|
||||
import { WorkspaceExecutionContext } from "../../src/services/channels/types";
|
||||
import { ChannelUtils, get as getChannelUtils } from "./channels/utils";
|
||||
import { ResourceUpdateResponse, User } from "../../src/utils/types";
|
||||
import gr from "../../src/services/global-resolver";
|
||||
|
||||
describe("Statistics implementation", () => {
|
||||
let platform: TestPlatform;
|
||||
// let database: DatabaseServiceAPI;
|
||||
let channelUtils: ChannelUtils;
|
||||
|
||||
beforeAll(async ends => {
|
||||
platform = await init({
|
||||
services: ["database", "statistics", "webserver", "auth"],
|
||||
});
|
||||
|
||||
expect(gr.services.statistics).toBeTruthy();
|
||||
|
||||
ends();
|
||||
channelUtils = getChannelUtils(platform);
|
||||
});
|
||||
|
||||
beforeEach(async ends => {
|
||||
await platform.database.getConnector().drop();
|
||||
ends();
|
||||
});
|
||||
|
||||
afterAll(async done => {
|
||||
await platform.tearDown();
|
||||
done();
|
||||
});
|
||||
|
||||
it("Check statistics counters", async done => {
|
||||
console.log(await gr.services.statistics.get(undefined, "counter-test"));
|
||||
|
||||
expect(await gr.services.statistics.get(undefined, "counter-test")).toEqual(0);
|
||||
|
||||
await gr.services.statistics.increase(platform.workspace.company_id, "counter-test");
|
||||
await gr.services.statistics.increase(platform.workspace.company_id, "counter-test");
|
||||
const secondCompanyId = uuidv1();
|
||||
await gr.services.statistics.increase(secondCompanyId, "counter-test");
|
||||
await gr.services.statistics.increase(secondCompanyId, "counter-test");
|
||||
await gr.services.statistics.increase(platform.workspace.company_id, "counter-test2");
|
||||
|
||||
expect(await gr.services.statistics.get(platform.workspace.company_id, "counter-test")).toEqual(
|
||||
2,
|
||||
);
|
||||
expect(await gr.services.statistics.get(secondCompanyId, "counter-test")).toEqual(2);
|
||||
expect(await gr.services.statistics.get(undefined, "counter-test")).toEqual(4);
|
||||
|
||||
expect(
|
||||
await gr.services.statistics.get(platform.workspace.company_id, "counter-test2"),
|
||||
).toEqual(1);
|
||||
expect(await gr.services.statistics.get(secondCompanyId, "counter-test2")).toEqual(0);
|
||||
expect(await gr.services.statistics.get(undefined, "counter-test2")).toEqual(1);
|
||||
|
||||
done();
|
||||
});
|
||||
|
||||
function getContext(user?: User): WorkspaceExecutionContext {
|
||||
return {
|
||||
workspace: platform.workspace,
|
||||
user: user || platform.currentUser,
|
||||
};
|
||||
}
|
||||
|
||||
async function sleep(timeout = 0) {
|
||||
return new Promise(r => setTimeout(r, timeout));
|
||||
}
|
||||
|
||||
describe("On user use messages in channel view", () => {
|
||||
it("should create a message and retrieve it in channel view", async () => {
|
||||
const channel = channelUtils.getChannel();
|
||||
await gr.services.channels.channels.save(channel, {}, getContext());
|
||||
const channelId = channel.id;
|
||||
|
||||
//Reset global value because messages could have been created somewhere else
|
||||
const value = await gr.services.statistics.get(undefined, "messages");
|
||||
await gr.services.statistics.increase(undefined, "messages", -value);
|
||||
|
||||
const response = await e2e_createThread(
|
||||
platform,
|
||||
[
|
||||
createParticipant(
|
||||
{
|
||||
type: "channel",
|
||||
id: channelId,
|
||||
},
|
||||
platform,
|
||||
),
|
||||
],
|
||||
createMessage({ text: "Initial thread 1 message" }),
|
||||
);
|
||||
|
||||
await sleep();
|
||||
|
||||
const result: ResourceUpdateResponse<Thread> = deserialize(
|
||||
ResourceUpdateResponse,
|
||||
response.body,
|
||||
);
|
||||
const threadId = result.resource.id;
|
||||
|
||||
await e2e_createMessage(platform, threadId, createMessage({ text: "Reply 1" }));
|
||||
|
||||
await e2e_createMessage(platform, threadId, createMessage({ text: "Reply 2" }));
|
||||
await e2e_createThread(
|
||||
platform,
|
||||
[
|
||||
createParticipant(
|
||||
{
|
||||
type: "channel",
|
||||
id: channelId,
|
||||
},
|
||||
platform,
|
||||
),
|
||||
],
|
||||
createMessage({ text: "Initial thread 2 message" }),
|
||||
);
|
||||
|
||||
await e2e_createMessage(platform, threadId, createMessage({ text: "Reply 3" }));
|
||||
|
||||
await e2e_createThread(
|
||||
platform,
|
||||
[
|
||||
createParticipant(
|
||||
{
|
||||
type: "channel",
|
||||
id: channelId,
|
||||
},
|
||||
platform,
|
||||
),
|
||||
],
|
||||
createMessage({ text: "Initial thread 3 message" }),
|
||||
);
|
||||
|
||||
await new Promise(r => setTimeout(r, 5000));
|
||||
|
||||
expect(await gr.services.statistics.get(undefined, "messages")).toEqual(6);
|
||||
expect(await gr.services.statistics.get(platform.workspace.company_id, "messages")).toEqual(
|
||||
6,
|
||||
);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,308 +0,0 @@
|
||||
import "reflect-metadata";
|
||||
import { afterAll, beforeAll, describe, expect, it } from "@jest/globals";
|
||||
import { init, TestPlatform } from "../setup";
|
||||
import { TestDbService } from "../utils.prepare.db";
|
||||
import { Tags } from "../../../src/services/tags/entities/tags";
|
||||
import { deserialize } from "class-transformer";
|
||||
import {
|
||||
ResourceCreateResponse,
|
||||
ResourceGetResponse,
|
||||
ResourceListResponse,
|
||||
} from "../../../src/utils/types";
|
||||
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
|
||||
// @ts-ignore
|
||||
|
||||
describe("The Tags feature", () => {
|
||||
const url = "/internal/services/tags/v1";
|
||||
let platform: TestPlatform;
|
||||
let testDbService: TestDbService;
|
||||
const tagIds: string[] = [];
|
||||
|
||||
beforeAll(async ends => {
|
||||
platform = await init({
|
||||
services: ["webserver", "database", "storage", "message-queue", "tags"],
|
||||
});
|
||||
testDbService = await TestDbService.getInstance(platform, true);
|
||||
ends();
|
||||
});
|
||||
|
||||
afterAll(async done => {
|
||||
for (let i = 0; i < tagIds.length; i++) {
|
||||
for (let j = 0; j < tagIds.length; j++) {
|
||||
if (tagIds[j] === tagIds[i] && j !== i) {
|
||||
throw new Error("Tag are not unique");
|
||||
}
|
||||
}
|
||||
}
|
||||
await platform?.tearDown();
|
||||
platform = null;
|
||||
done();
|
||||
});
|
||||
|
||||
describe("Create tag", () => {
|
||||
it("should 201 if creator is a company admin", async done => {
|
||||
const user = await testDbService.createUser([testDbService.defaultWorkspace()], {
|
||||
companyRole: "admin",
|
||||
});
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: user.id });
|
||||
|
||||
for (let i = 0; i < 3; i++) {
|
||||
const createTag = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/tags`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
payload: {
|
||||
name: `test${i}`,
|
||||
colour: `#00000${i}`,
|
||||
},
|
||||
});
|
||||
|
||||
const tagResult: ResourceCreateResponse<Tags> = deserialize(
|
||||
ResourceCreateResponse,
|
||||
createTag.body,
|
||||
);
|
||||
expect(createTag.statusCode).toBe(201);
|
||||
expect(tagResult.resource).toBeDefined();
|
||||
expect(tagResult.resource.name).toBe(`test${i}`);
|
||||
expect(tagResult.resource.colour).toBe(`#00000${i}`);
|
||||
expect(tagResult.resource.company_id).toBe(platform.workspace.company_id);
|
||||
expect(tagResult.resource.tag_id).toBe(`test${i}`);
|
||||
|
||||
const getTag = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/tags/${tagResult.resource.tag_id}`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
});
|
||||
expect(getTag.statusCode).toBe(200);
|
||||
|
||||
tagIds.push(tagResult.resource.tag_id);
|
||||
}
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 401 if creator is not a company admin", async done => {
|
||||
const user = await testDbService.createUser([testDbService.defaultWorkspace()], {
|
||||
companyRole: "member",
|
||||
});
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: user.id });
|
||||
const createTag = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/tags`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
payload: {
|
||||
name: "testNotAdmin",
|
||||
colour: "#000000",
|
||||
},
|
||||
});
|
||||
expect(createTag.statusCode).toBe(401);
|
||||
|
||||
const tagResult: ResourceCreateResponse<Tags> = deserialize(
|
||||
ResourceCreateResponse,
|
||||
createTag.body,
|
||||
);
|
||||
expect(tagResult.resource).toBe(undefined);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
describe("Get tag", () => {
|
||||
it("should 200 get a tag", async done => {
|
||||
const user = await testDbService.createUser([testDbService.defaultWorkspace()], {
|
||||
companyRole: "member",
|
||||
});
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: user.id });
|
||||
const getTag = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/tags/${tagIds[0]}`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
});
|
||||
expect(getTag.statusCode).toBe(200);
|
||||
|
||||
const getResult: ResourceGetResponse<Tags> = deserialize(ResourceGetResponse, getTag.body);
|
||||
expect(getResult.resource).toBeDefined();
|
||||
expect(getResult.resource.name).toBe("test0");
|
||||
expect(getResult.resource.colour).toBe("#000000");
|
||||
expect(getResult.resource.company_id).toBe(platform.workspace.company_id);
|
||||
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 200 tag does not exist", async done => {
|
||||
const user = await testDbService.createUser([testDbService.defaultWorkspace()], {
|
||||
companyRole: "member",
|
||||
});
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: user.id });
|
||||
const getTag = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/tags/NonExistingTag`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
});
|
||||
expect(getTag.statusCode).toBe(200);
|
||||
|
||||
const getResult: ResourceGetResponse<Tags> = deserialize(ResourceGetResponse, getTag.body);
|
||||
expect(getResult.resource).toBe(null);
|
||||
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
describe("Update tag", () => {
|
||||
it("Should 204 if user is admin", async done => {
|
||||
const user = await testDbService.createUser([testDbService.defaultWorkspace()], {
|
||||
companyRole: "admin",
|
||||
});
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: user.id });
|
||||
const updateTag = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/tags`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
payload: {
|
||||
name: "test1",
|
||||
colour: "#000003",
|
||||
},
|
||||
});
|
||||
expect(updateTag.statusCode).toBe(201);
|
||||
|
||||
const tagUpdatedResult: ResourceCreateResponse<Tags> = deserialize(
|
||||
ResourceCreateResponse,
|
||||
updateTag.body,
|
||||
);
|
||||
expect(tagUpdatedResult.resource).toBeDefined();
|
||||
expect(tagUpdatedResult.resource.name).toBe("test1");
|
||||
expect(tagUpdatedResult.resource.colour).toBe("#000003");
|
||||
expect(tagUpdatedResult.resource.company_id).toBe(platform.workspace.company_id);
|
||||
expect(tagUpdatedResult.resource.tag_id).toBe("test1");
|
||||
|
||||
const getUpdatedTag = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/tags/${tagUpdatedResult.resource.tag_id}`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
});
|
||||
expect(getUpdatedTag.statusCode).toBe(200);
|
||||
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 401 if creator is not a company admin", async done => {
|
||||
const user = await testDbService.createUser([testDbService.defaultWorkspace()], {
|
||||
companyRole: "member",
|
||||
});
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: user.id });
|
||||
const createTag = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/tags/testNotAdmin`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
payload: {
|
||||
name: "testNotAdmin",
|
||||
colour: "#000000",
|
||||
},
|
||||
});
|
||||
expect(createTag.statusCode).toBe(401);
|
||||
|
||||
const tagResult: ResourceCreateResponse<Tags> = deserialize(
|
||||
ResourceCreateResponse,
|
||||
createTag.body,
|
||||
);
|
||||
console.log("tagResult2", tagResult, jwtToken);
|
||||
expect(tagResult.resource).toBe(undefined);
|
||||
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
describe("List tags", () => {
|
||||
it("should 200 list a tag", async done => {
|
||||
const user = await testDbService.createUser([testDbService.defaultWorkspace()], {
|
||||
companyRole: "member",
|
||||
});
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: user.id });
|
||||
const listTag = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/tags`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
});
|
||||
expect(listTag.statusCode).toBe(200);
|
||||
|
||||
const tagResult: ResourceListResponse<Tags> = deserialize(ResourceListResponse, listTag.body);
|
||||
expect(tagResult.resources).toBeDefined();
|
||||
for (const tag of tagResult.resources) {
|
||||
expect(tag.name).toBeDefined();
|
||||
expect(tag.colour).toBeDefined();
|
||||
expect(tag.company_id).toBe(platform.workspace.company_id);
|
||||
expect(tag.tag_id).toBeDefined();
|
||||
}
|
||||
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
describe("Delete tag", () => {
|
||||
it("should 200 if admin delete a tag", async done => {
|
||||
const user = await testDbService.createUser([testDbService.defaultWorkspace()], {
|
||||
companyRole: "admin",
|
||||
});
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: user.id });
|
||||
const deleteTag = await platform.app.inject({
|
||||
method: "DELETE",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/tags/${tagIds[0]}`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
});
|
||||
expect(deleteTag.statusCode).toBe(200);
|
||||
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 200 if tag does not exist", async done => {
|
||||
const user = await testDbService.createUser([testDbService.defaultWorkspace()], {
|
||||
companyRole: "admin",
|
||||
});
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: user.id });
|
||||
const deleteTag = await platform.app.inject({
|
||||
method: "DELETE",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/tags/NonExistingTag`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
});
|
||||
expect(deleteTag.statusCode).toBe(200);
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 401 if not admin", async done => {
|
||||
const user = await testDbService.createUser([testDbService.defaultWorkspace()], {
|
||||
companyRole: "member",
|
||||
});
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: user.id });
|
||||
const deleteTag = await platform.app.inject({
|
||||
method: "DELETE",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/tags/${tagIds[0]}`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
});
|
||||
expect(deleteTag.statusCode).toBe(401);
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,149 +0,0 @@
|
||||
import { afterEach, beforeEach, describe, expect, it } from "@jest/globals";
|
||||
import { init, TestPlatform } from "../setup";
|
||||
import { TestDbService } from "../utils.prepare.db";
|
||||
import { v1 as uuidv1 } from "uuid";
|
||||
|
||||
describe("The /users API", () => {
|
||||
const url = "/internal/services/users/v1";
|
||||
let platform: TestPlatform;
|
||||
|
||||
beforeEach(async ends => {
|
||||
platform = await init({
|
||||
services: [
|
||||
"database",
|
||||
"search",
|
||||
"message-queue",
|
||||
"websocket",
|
||||
"webserver",
|
||||
"user",
|
||||
"auth",
|
||||
"applications",
|
||||
"storage",
|
||||
"counter",
|
||||
"workspaces",
|
||||
"console",
|
||||
"statistics",
|
||||
"platform-services",
|
||||
],
|
||||
});
|
||||
ends();
|
||||
});
|
||||
|
||||
afterEach(async ends => {
|
||||
platform && (await platform.tearDown());
|
||||
platform = null;
|
||||
ends();
|
||||
});
|
||||
|
||||
describe("The GET /users/?search=... route", () => {
|
||||
it("Should find the searched users", async done => {
|
||||
const testDbService = new TestDbService(platform);
|
||||
await testDbService.createCompany(platform.workspace.company_id);
|
||||
const workspacePk = {
|
||||
id: platform.workspace.workspace_id,
|
||||
company_id: platform.workspace.company_id,
|
||||
};
|
||||
const workspacePk2 = {
|
||||
id: uuidv1(),
|
||||
company_id: uuidv1(),
|
||||
};
|
||||
await testDbService.createWorkspace(workspacePk);
|
||||
await testDbService.createWorkspace(workspacePk2);
|
||||
await testDbService.createUser([workspacePk], {
|
||||
firstName: "Ha",
|
||||
lastName: "Nguyen",
|
||||
email: "hnguyen@twake.app",
|
||||
});
|
||||
await testDbService.createUser([workspacePk], {
|
||||
firstName: "Harold",
|
||||
lastName: "Georges",
|
||||
email: "hgeorges@twake.app",
|
||||
});
|
||||
await testDbService.createUser([workspacePk], {
|
||||
firstName: "Bob",
|
||||
lastName: "Smith",
|
||||
email: "bob@twake.app",
|
||||
});
|
||||
await testDbService.createUser([workspacePk], {
|
||||
firstName: "Bob",
|
||||
lastName: "Rabiot",
|
||||
email: "rabiot.b@twake.app",
|
||||
});
|
||||
await testDbService.createUser([workspacePk, workspacePk2], {
|
||||
firstName: "Bob",
|
||||
lastName: "Smith-Rabiot",
|
||||
email: "rbs@twake.app",
|
||||
});
|
||||
await testDbService.createUser([workspacePk], {
|
||||
firstName: "Alexïs",
|
||||
lastName: "Goélâns",
|
||||
email: "alexis.goelans@twake.app",
|
||||
});
|
||||
|
||||
//Wait for indexation to happen
|
||||
await new Promise(r => setTimeout(r, 5000));
|
||||
|
||||
let resources = await search("ha");
|
||||
expect(resources.length).toBe(2);
|
||||
|
||||
resources = await search("bob rabiot");
|
||||
|
||||
expect(resources.map(e => e.email).includes("rabiot.b@twake.app")).toBe(true);
|
||||
expect(resources.map(e => e.email).includes("rbs@twake.app")).toBe(true);
|
||||
expect(resources.map(e => e.email).includes("bob@twake.app")).toBe(true);
|
||||
|
||||
resources = await search("alexis");
|
||||
expect(resources[0].email).toBe("alexis.goelans@twake.app");
|
||||
|
||||
resources = await search("ALEXIS");
|
||||
expect(resources[0].email).toBe("alexis.goelans@twake.app");
|
||||
|
||||
resources = await search("AleXis");
|
||||
expect(resources[0].email).toBe("alexis.goelans@twake.app");
|
||||
|
||||
resources = await search("alex");
|
||||
expect(resources[0].email).toBe("alexis.goelans@twake.app");
|
||||
|
||||
resources = await search("àlèXïs");
|
||||
expect(resources[0].email).toBe("alexis.goelans@twake.app");
|
||||
|
||||
resources = await search("rbs");
|
||||
expect(resources[0].email).toBe("rbs@twake.app");
|
||||
|
||||
resources = await search("rbs@twake.app");
|
||||
expect(resources[0].email).toBe("rbs@twake.app");
|
||||
|
||||
resources = await search("bob", workspacePk2.company_id);
|
||||
expect(resources.length).toBe(1);
|
||||
|
||||
resources = await search("rbs@twake.app", workspacePk.company_id);
|
||||
expect(resources[0].email).toBe("rbs@twake.app");
|
||||
|
||||
resources = await search("rbs@twake.app", uuidv1());
|
||||
expect(resources.length).toBe(0);
|
||||
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
async function search(search: string, companyId?: string): Promise<any[]> {
|
||||
const jwtToken = await platform.auth.getJWTToken();
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/users`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
query: {
|
||||
search: search,
|
||||
...(companyId ? { search_company_id: companyId } : {}),
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const json = response.json();
|
||||
expect(json).toMatchObject({ resources: expect.any(Array) });
|
||||
const resources = json.resources;
|
||||
return resources;
|
||||
}
|
||||
});
|
||||
@@ -1,645 +0,0 @@
|
||||
import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "@jest/globals";
|
||||
import { init, TestPlatform } from "../setup";
|
||||
import { TestDbService } from "../utils.prepare.db";
|
||||
import { v1 as uuidv1 } from "uuid";
|
||||
import { CompanyLimitsEnum, UserObject } from "../../../src/services/user/web/types";
|
||||
import { ChannelVisibility } from "../../../src/services/channels/types";
|
||||
import gr from "../../../src/services/global-resolver";
|
||||
import { ResourceListResponse, Workspace } from "../../../src/utils/types";
|
||||
import { ChannelSaveOptions } from "../../../src/services/channels/web/types";
|
||||
import { createMessage, e2e_createThread } from "../messages/utils";
|
||||
import { deserialize } from "class-transformer";
|
||||
import { get as getChannelUtils } from "../channels/utils";
|
||||
|
||||
describe("The /users API", () => {
|
||||
const url = "/internal/services/users/v1";
|
||||
let platform: TestPlatform;
|
||||
|
||||
let testDbService: TestDbService;
|
||||
|
||||
const nonExistentId = uuidv1();
|
||||
|
||||
beforeEach(async ends => {
|
||||
platform = await init();
|
||||
ends();
|
||||
});
|
||||
afterEach(async ends => {
|
||||
await platform.tearDown();
|
||||
platform = null;
|
||||
ends();
|
||||
});
|
||||
|
||||
beforeAll(async ends => {
|
||||
const platform = await init({
|
||||
services: [
|
||||
"database",
|
||||
"search",
|
||||
"message-queue",
|
||||
"websocket",
|
||||
"applications",
|
||||
"webserver",
|
||||
"user",
|
||||
"auth",
|
||||
"storage",
|
||||
"counter",
|
||||
"console",
|
||||
"workspaces",
|
||||
"statistics",
|
||||
"platform-services",
|
||||
],
|
||||
});
|
||||
|
||||
testDbService = await TestDbService.getInstance(platform);
|
||||
await testDbService.createCompany();
|
||||
const workspacePk = { id: uuidv1(), company_id: testDbService.company.id };
|
||||
await testDbService.createWorkspace(workspacePk);
|
||||
await testDbService.createUser([workspacePk], {
|
||||
workspaceRole: "moderator",
|
||||
companyRole: "admin",
|
||||
email: "admin@admin.admin",
|
||||
username: "adminuser",
|
||||
firstName: "admin",
|
||||
});
|
||||
await testDbService.createUser([workspacePk]);
|
||||
|
||||
ends();
|
||||
});
|
||||
|
||||
afterAll(async ends => {
|
||||
ends();
|
||||
});
|
||||
|
||||
describe("The GET /users/:id route", () => {
|
||||
it("should 401 when not authenticated", async done => {
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/users/1`,
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(401);
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 404 when user does not exists", async done => {
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: testDbService.users[0].id });
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/users/${nonExistentId}`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(404);
|
||||
expect(response.json()).toEqual({
|
||||
error: "Not Found",
|
||||
message: `User ${nonExistentId} not found`,
|
||||
statusCode: 404,
|
||||
});
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 200 and big response for myself", async done => {
|
||||
const myId = testDbService.users[0].id;
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: myId });
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/users/${myId}`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
|
||||
const resource = response.json()["resource"];
|
||||
|
||||
expect(resource).toMatchObject({
|
||||
id: myId,
|
||||
provider: expect.any(String),
|
||||
provider_id: expect.any(String),
|
||||
email: expect.any(String),
|
||||
is_verified: expect.any(Boolean),
|
||||
picture: expect.any(String),
|
||||
first_name: expect.any(String),
|
||||
last_name: expect.any(String),
|
||||
created_at: expect.any(Number),
|
||||
deleted: expect.any(Boolean),
|
||||
status: expect.any(String),
|
||||
last_activity: expect.any(Number),
|
||||
|
||||
//Below is only if this is myself
|
||||
|
||||
preference: expect.objectContaining({
|
||||
locale: expect.any(String),
|
||||
timezone: expect.any(Number),
|
||||
}),
|
||||
});
|
||||
|
||||
expect(resource["companies"]).toEqual(
|
||||
expect.arrayContaining([
|
||||
expect.objectContaining({
|
||||
role: expect.stringMatching(/owner|admin|member|guest/),
|
||||
status: expect.stringMatching(/active|deactivated|invited/),
|
||||
company: {
|
||||
id: expect.any(String),
|
||||
name: expect.any(String),
|
||||
logo: expect.any(String),
|
||||
},
|
||||
}),
|
||||
]),
|
||||
);
|
||||
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 200 and short response for another user", async done => {
|
||||
const myId = testDbService.users[0].id;
|
||||
const anotherUserId = testDbService.users[1].id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: myId });
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/users/${anotherUserId}`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
|
||||
const resource = response.json()["resource"];
|
||||
|
||||
expect(resource).toMatchObject({
|
||||
id: anotherUserId,
|
||||
provider: expect.any(String),
|
||||
provider_id: expect.any(String),
|
||||
email: expect.any(String),
|
||||
is_verified: expect.any(Boolean),
|
||||
picture: expect.any(String),
|
||||
first_name: expect.any(String),
|
||||
last_name: expect.any(String),
|
||||
created_at: expect.any(Number),
|
||||
deleted: expect.any(Boolean),
|
||||
status: expect.any(String),
|
||||
last_activity: expect.any(Number),
|
||||
});
|
||||
|
||||
expect(resource).not.toMatchObject({
|
||||
locale: expect.anything(),
|
||||
timezone: expect.anything(),
|
||||
companies: expect.anything(),
|
||||
});
|
||||
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
describe("The GET /users route", () => {
|
||||
it("should 401 when user is not authenticated", async done => {
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/users`,
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(401);
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 200 with array of users", async done => {
|
||||
const myId = testDbService.users[0].id;
|
||||
const anotherUserId = testDbService.users[1].id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: myId });
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/users`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
query: {
|
||||
user_ids: `${myId},${anotherUserId}`,
|
||||
company_ids: "fd96c8a8-ae77-11eb-a1a1-0242ac120005",
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const json = response.json();
|
||||
expect(json).toMatchObject({ resources: expect.any(Array) });
|
||||
const resources = json.resources;
|
||||
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
describe("The GET /users/:user_id/companies route", () => {
|
||||
it("should 401 when not authenticated", async done => {
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/users/1/companies`,
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(401);
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 404 when user does not exists", async done => {
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: testDbService.users[0].id });
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/users/${nonExistentId}/companies`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(404);
|
||||
expect(response.json()).toEqual({
|
||||
error: "Not Found",
|
||||
message: `User ${nonExistentId} not found`,
|
||||
statusCode: 404,
|
||||
});
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 200 and on correct request", async done => {
|
||||
const myId = testDbService.users[0].id;
|
||||
const anotherUserId = testDbService.users[1].id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: myId });
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/users/${anotherUserId}/companies`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
|
||||
const resources = response.json()["resources"];
|
||||
expect(resources.length).toBeGreaterThan(0);
|
||||
|
||||
for (const resource of resources) {
|
||||
expect(resource).toMatchObject({
|
||||
id: expect.any(String),
|
||||
name: expect.any(String),
|
||||
logo: expect.any(String),
|
||||
role: expect.stringMatching(/owner|admin|member|guest/),
|
||||
status: expect.stringMatching(/active|deactivated|invited/),
|
||||
});
|
||||
|
||||
if (resource.plan) {
|
||||
expect(resource.plan).toMatchObject({
|
||||
name: expect.any(String),
|
||||
limits: expect.objectContaining({
|
||||
[CompanyLimitsEnum.CHAT_MESSAGE_HISTORY_LIMIT]: expect.any(Number || undefined),
|
||||
[CompanyLimitsEnum.COMPANY_MEMBERS_LIMIT]: expect.any(Number || undefined),
|
||||
}),
|
||||
});
|
||||
}
|
||||
if (resources.stats) {
|
||||
expect(resource.plan).toMatchObject({
|
||||
created_at: expect.any(Number),
|
||||
total_members: expect.any(Number),
|
||||
total_guests: expect.any(Number),
|
||||
});
|
||||
}
|
||||
}
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
describe("The GET /companies/:company_id route", () => {
|
||||
it("should 404 when company does not exists", async done => {
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/11111111-1111-1111-1111-111111111111`,
|
||||
});
|
||||
expect(response.statusCode).toBe(404);
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 200 when company exists", async done => {
|
||||
const companyId = testDbService.company.id;
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${companyId}`,
|
||||
});
|
||||
expect(response.statusCode).toBe(200);
|
||||
|
||||
const json = response.json();
|
||||
|
||||
expect(json.resource).toMatchObject({
|
||||
id: expect.any(String),
|
||||
name: expect.any(String),
|
||||
logo: expect.any(String),
|
||||
});
|
||||
|
||||
if (json.resource.plan) {
|
||||
expect(json.resource.plan).toMatchObject({
|
||||
name: expect.any(String),
|
||||
limits: expect.objectContaining({
|
||||
[CompanyLimitsEnum.CHAT_MESSAGE_HISTORY_LIMIT]: expect.any(Number || undefined),
|
||||
[CompanyLimitsEnum.COMPANY_MEMBERS_LIMIT]: expect.any(Number || undefined),
|
||||
}),
|
||||
});
|
||||
}
|
||||
|
||||
expect(json.resource.stats).toMatchObject({
|
||||
created_at: expect.any(Number),
|
||||
total_members: expect.any(Number),
|
||||
total_guests: expect.any(Number),
|
||||
total_messages: expect.any(Number),
|
||||
});
|
||||
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
describe("User's device management", () => {
|
||||
const deviceToken = "testDeviceToken";
|
||||
|
||||
describe("Register device (POST)", () => {
|
||||
it("should 400 when type is not FCM", async done => {
|
||||
const myId = testDbService.users[0].id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: myId });
|
||||
const response = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/devices`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
payload: {
|
||||
resource: {
|
||||
type: "another",
|
||||
value: "value",
|
||||
version: "version",
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
const resp = response.json();
|
||||
expect(response.statusCode).toBe(400);
|
||||
expect(resp).toMatchObject({
|
||||
statusCode: 400,
|
||||
error: "Bad Request",
|
||||
message: "Type should be FCM only",
|
||||
});
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 200 when ok", async done => {
|
||||
const firstId = testDbService.users[0].id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: firstId });
|
||||
const response = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/devices`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
payload: {
|
||||
resource: {
|
||||
type: "FCM",
|
||||
value: deviceToken,
|
||||
version: "1",
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
const resp = response.json();
|
||||
expect(response.statusCode).toBe(200);
|
||||
|
||||
expect(resp.resource).toMatchObject({
|
||||
type: "FCM",
|
||||
value: deviceToken,
|
||||
version: "1",
|
||||
});
|
||||
|
||||
const user = await testDbService.getUserFromDb({ id: firstId });
|
||||
expect(user.devices).toMatchObject([deviceToken]);
|
||||
const device = await testDbService.getDeviceFromDb(deviceToken);
|
||||
expect(device).toMatchObject({
|
||||
id: deviceToken,
|
||||
user_id: firstId,
|
||||
type: "FCM",
|
||||
version: "1",
|
||||
});
|
||||
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 200 when register token to another person", async done => {
|
||||
const firstId = testDbService.users[0].id;
|
||||
const secondId = testDbService.users[1].id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: secondId });
|
||||
const response = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/devices`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
payload: {
|
||||
resource: {
|
||||
type: "FCM",
|
||||
value: deviceToken,
|
||||
version: "1",
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
const resp = response.json();
|
||||
expect(response.statusCode).toBe(200);
|
||||
|
||||
expect(resp.resource).toMatchObject({
|
||||
type: "FCM",
|
||||
value: deviceToken,
|
||||
version: "1",
|
||||
});
|
||||
|
||||
// second user should have now this token
|
||||
let user = await testDbService.getUserFromDb({ id: secondId });
|
||||
expect(user.devices).toMatchObject([deviceToken]);
|
||||
const device = await testDbService.getDeviceFromDb(deviceToken);
|
||||
expect(device).toMatchObject({
|
||||
id: deviceToken,
|
||||
user_id: secondId,
|
||||
type: "FCM",
|
||||
version: "1",
|
||||
});
|
||||
|
||||
// and first — not
|
||||
|
||||
user = await testDbService.getUserFromDb({ id: firstId });
|
||||
expect(user.devices).toMatchObject([]);
|
||||
|
||||
done();
|
||||
});
|
||||
});
|
||||
describe("List registered devices (GET)", () => {
|
||||
it("should 200 when request devices", async done => {
|
||||
const myId = testDbService.users[1].id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: myId });
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/devices`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
});
|
||||
|
||||
const resp = response.json();
|
||||
expect(response.statusCode).toBe(200);
|
||||
expect(resp).toMatchObject({
|
||||
resources: [
|
||||
{
|
||||
type: "FCM",
|
||||
value: "testDeviceToken",
|
||||
version: "1",
|
||||
},
|
||||
],
|
||||
});
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
describe("De-register device (DELETE)", () => {
|
||||
it("should 200 when device not found for the user", async done => {
|
||||
const myId = testDbService.users[1].id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: myId });
|
||||
const response = await platform.app.inject({
|
||||
method: "DELETE",
|
||||
url: `${url}/devices/somethingRandom`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
});
|
||||
expect(response.statusCode).toBe(204);
|
||||
|
||||
const user = await testDbService.getUserFromDb({ id: myId });
|
||||
expect(user.devices).toMatchObject([deviceToken]);
|
||||
const device = await testDbService.getDeviceFromDb(deviceToken);
|
||||
expect(device).toMatchObject({
|
||||
id: deviceToken,
|
||||
user_id: myId,
|
||||
type: "FCM",
|
||||
version: "1",
|
||||
});
|
||||
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 200 when device found and device should be removed", async done => {
|
||||
const myId = testDbService.users[1].id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: myId });
|
||||
const response = await platform.app.inject({
|
||||
method: "DELETE",
|
||||
url: `${url}/devices/${deviceToken}`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
});
|
||||
expect(response.statusCode).toBe(204);
|
||||
|
||||
const user = await testDbService.getUserFromDb({ id: myId });
|
||||
expect(user.devices).toMatchObject([]);
|
||||
const device = await testDbService.getDeviceFromDb(deviceToken);
|
||||
expect(device).toBeFalsy();
|
||||
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("Recent contacts", () => {
|
||||
it("should return list of recent contacts of user", async done => {
|
||||
// api = new Api(platform);
|
||||
const channelUtils = getChannelUtils(platform);
|
||||
|
||||
await testDbService.createDefault(platform);
|
||||
|
||||
const channels = [];
|
||||
|
||||
for (let i = 0; i < 5; i++) {
|
||||
// const channel = channelUtils.getChannel();
|
||||
const directChannelIn = channelUtils.getDirectChannel();
|
||||
|
||||
const nextUser = await testDbService.createUser(
|
||||
[{ id: platform.workspace.workspace_id, company_id: platform.workspace.company_id }],
|
||||
{ firstName: "FirstName" + i, lastName: "LastName" + i },
|
||||
);
|
||||
|
||||
const members = [platform.currentUser.id, nextUser.id];
|
||||
const directWorkspace: Workspace = {
|
||||
company_id: platform.workspace.company_id,
|
||||
workspace_id: ChannelVisibility.DIRECT,
|
||||
};
|
||||
await Promise.all([
|
||||
// gr.services.channels.channels.save(channel, {}, getContext()),
|
||||
gr.services.channels.channels.save<ChannelSaveOptions>(
|
||||
directChannelIn,
|
||||
{
|
||||
members,
|
||||
},
|
||||
{
|
||||
...{
|
||||
workspace: platform.workspace,
|
||||
user: platform.currentUser,
|
||||
},
|
||||
...{ workspace: directWorkspace },
|
||||
},
|
||||
),
|
||||
]);
|
||||
channels.push(directChannelIn);
|
||||
}
|
||||
|
||||
await new Promise(resolve => setTimeout(resolve, 1000));
|
||||
|
||||
await e2e_createThread(
|
||||
platform,
|
||||
[
|
||||
{
|
||||
company_id: platform.workspace.company_id,
|
||||
created_at: 0,
|
||||
created_by: "",
|
||||
id: channels[2].id,
|
||||
type: "channel",
|
||||
workspace_id: "direct",
|
||||
},
|
||||
],
|
||||
createMessage({ text: "Some message" }),
|
||||
);
|
||||
|
||||
await new Promise(resolve => setTimeout(resolve, 1000));
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken();
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/users/recent`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
|
||||
const result: ResourceListResponse<UserObject> = deserialize(
|
||||
ResourceListResponse,
|
||||
response.body,
|
||||
);
|
||||
|
||||
expect(result.resources.length).toEqual(5);
|
||||
expect(result.resources[0].first_name).toEqual("FirstName2");
|
||||
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,90 +0,0 @@
|
||||
import { afterEach, beforeEach, describe, it } from "@jest/globals";
|
||||
import { init, TestPlatform } from "../setup";
|
||||
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
|
||||
// @ts-ignore
|
||||
import io from "socket.io-client";
|
||||
|
||||
describe("The Websocket authentication", () => {
|
||||
let platform: TestPlatform;
|
||||
let socket: SocketIOClient.Socket;
|
||||
|
||||
beforeEach(async ends => {
|
||||
platform = await init({
|
||||
services: [
|
||||
"webserver",
|
||||
"database",
|
||||
"search",
|
||||
"storage",
|
||||
"message-queue",
|
||||
"user",
|
||||
"websocket",
|
||||
"webserver",
|
||||
"applications",
|
||||
"auth",
|
||||
"realtime",
|
||||
"channels" /* FIXME: platform is not started if a business service is not in dependencies */,
|
||||
"counter",
|
||||
"statistics",
|
||||
"platform-services",
|
||||
],
|
||||
});
|
||||
|
||||
socket = io.connect("http://localhost:3000", { path: "/socket" });
|
||||
|
||||
ends();
|
||||
});
|
||||
|
||||
afterEach(async ends => {
|
||||
platform && (await platform.tearDown());
|
||||
platform = null;
|
||||
socket && socket.close();
|
||||
socket = null;
|
||||
ends();
|
||||
});
|
||||
|
||||
describe("JWT-based Authentication", () => {
|
||||
it("should not be able to connect without a JWT token", done => {
|
||||
socket.connect();
|
||||
socket.on("connect", () => {
|
||||
socket
|
||||
.emit("authenticate", {})
|
||||
.on("authenticated", () => {
|
||||
done(new Error("Should not occur"));
|
||||
})
|
||||
.on("unauthorized", (msg: any) => {
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it("should not be able to connect with something which is not a JWT token", done => {
|
||||
socket.connect();
|
||||
socket.on("connect", () => {
|
||||
socket
|
||||
.emit("authenticate", { token: "Not a JWT token" })
|
||||
.on("authenticated", () => {
|
||||
done(new Error("Should not occur"));
|
||||
})
|
||||
.on("unauthorized", (msg: any) => {
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it("should be able to connect with a JWT token", async done => {
|
||||
const token = await platform.auth.getJWTToken();
|
||||
|
||||
socket.connect();
|
||||
socket.on("connect", () => {
|
||||
socket
|
||||
.emit("authenticate", { token })
|
||||
.on("authenticated", () => {
|
||||
done();
|
||||
})
|
||||
.on("unauthorized", () => {
|
||||
done(new Error("Should not occur"));
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,157 +0,0 @@
|
||||
import { afterEach, beforeEach, describe, expect, it } from "@jest/globals";
|
||||
import { init, TestPlatform } from "../setup";
|
||||
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
|
||||
// @ts-ignore
|
||||
import io from "socket.io-client";
|
||||
|
||||
describe("The Realtime API", () => {
|
||||
let platform: TestPlatform;
|
||||
let socket: SocketIOClient.Socket;
|
||||
|
||||
beforeEach(async ends => {
|
||||
platform = await init({
|
||||
services: [
|
||||
"webserver",
|
||||
"database",
|
||||
"search",
|
||||
"storage",
|
||||
"message-queue",
|
||||
"applications",
|
||||
"user",
|
||||
"auth",
|
||||
"websocket",
|
||||
"realtime",
|
||||
"channels" /* FIXME: platform is not started if a business service is not in dependencies */,
|
||||
"counter",
|
||||
"statistics",
|
||||
"platform-services",
|
||||
],
|
||||
});
|
||||
|
||||
socket = io.connect("http://localhost:3000", { path: "/socket" });
|
||||
|
||||
ends();
|
||||
});
|
||||
|
||||
afterEach(async ends => {
|
||||
await platform.tearDown();
|
||||
platform = null;
|
||||
socket && socket.close();
|
||||
socket = null;
|
||||
|
||||
ends();
|
||||
});
|
||||
|
||||
describe("Joining rooms", () => {
|
||||
it("should fail when token is not defined", async done => {
|
||||
const token = await platform.auth.getJWTToken();
|
||||
const name = "/ping";
|
||||
|
||||
socket.on("connect", () => {
|
||||
socket
|
||||
.emit("authenticate", { token })
|
||||
.on("authenticated", () => {
|
||||
socket.emit("realtime:join", { name });
|
||||
socket.on("realtime:join:error", (event: any) => {
|
||||
expect(event.name).toEqual(name);
|
||||
done();
|
||||
});
|
||||
socket.on("realtime:join:success", () => done(new Error("Should not occur")));
|
||||
})
|
||||
.on("unauthorized", () => {
|
||||
done(new Error("Should not occur"));
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it("should fail when token is not valid", async done => {
|
||||
const token = await platform.auth.getJWTToken();
|
||||
const name = "/ping";
|
||||
const roomToken = "invalid token";
|
||||
|
||||
socket.on("connect", () => {
|
||||
socket
|
||||
.emit("authenticate", { token })
|
||||
.on("authenticated", () => {
|
||||
socket.emit("realtime:join", { name, token: roomToken });
|
||||
socket.on("realtime:join:error", (event: any) => {
|
||||
expect(event.name).toEqual(name);
|
||||
done();
|
||||
});
|
||||
socket.on("realtime:join:success", () => done(new Error("Should not occur")));
|
||||
})
|
||||
.on("unauthorized", () => {
|
||||
done(new Error("Should not occur"));
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it("should receive a realtime:join:success when token is valid and room has been joined", async done => {
|
||||
const token = await platform.auth.getJWTToken();
|
||||
const name = "test";
|
||||
const roomToken = "twake";
|
||||
|
||||
socket.on("connect", () => {
|
||||
socket
|
||||
.emit("authenticate", { token })
|
||||
.on("authenticated", () => {
|
||||
socket.emit("realtime:join", { name, token: roomToken });
|
||||
socket.on("realtime:join:error", () => done(new Error("Should not occur")));
|
||||
socket.on("realtime:join:success", (event: any) => {
|
||||
expect(event.name).toEqual(name);
|
||||
done();
|
||||
});
|
||||
})
|
||||
.on("unauthorized", () => {
|
||||
done(new Error("Should not occur"));
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("Leaving rooms", () => {
|
||||
it("should not fail when room has not been joined first", async done => {
|
||||
const token = await platform.auth.getJWTToken();
|
||||
const name = "roomtest";
|
||||
|
||||
socket.on("connect", () => {
|
||||
socket
|
||||
.emit("authenticate", { token })
|
||||
.on("authenticated", () => {
|
||||
socket.emit("realtime:leave", { name });
|
||||
socket.on("realtime:leave:error", () => done(new Error("should not fail")));
|
||||
socket.on("realtime:leave:success", (event: any) => {
|
||||
expect(event.name).toEqual(name);
|
||||
done();
|
||||
});
|
||||
})
|
||||
.on("unauthorized", () => {
|
||||
done(new Error("Should not occur"));
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it("should send success when room has been joined first", async done => {
|
||||
const token = await platform.auth.getJWTToken();
|
||||
const roomToken = "twake";
|
||||
const name = "roomtest";
|
||||
|
||||
socket.on("connect", () => {
|
||||
socket
|
||||
.emit("authenticate", { token })
|
||||
.on("authenticated", () => {
|
||||
socket.emit("realtime:join", { name, token: roomToken });
|
||||
socket.emit("realtime:leave", { name });
|
||||
socket.on("realtime:leave:error", () => done(new Error("should not fail")));
|
||||
socket.on("realtime:leave:success", (event: any) => {
|
||||
expect(event.name).toEqual(name);
|
||||
done();
|
||||
});
|
||||
})
|
||||
.on("unauthorized", () => {
|
||||
done(new Error("Should not occur"));
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user