eduvia/workavia-drive
11
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

✅ Test refactoring, make test more stable (#374)

Browse Source 
- Move copy-pasted code to User API
- Clean the database after each test
- Refactor documents search test
This commit is contained in:
Anton Shepilov
2024-02-26 00:04:04 +01:00
committed by GitHub
parent 488aafe284
commit e0aca9dcd5
20 changed files with 719 additions and 909 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tdrive/backend/node/test/e2e/documents/documents-browser.spec.ts
+11 -11
View File
@@ -1,11 +1,11 @@
import { describe, beforeEach, afterEach, it, expect, afterAll } from "@jest/globals";
import { init, TestPlatform } from "../setup";
import { TestDbService } from "../utils.prepare.db";
import TestHelpers from "../common/common_test_helpers";
import UserApi from "../common/user-api";
describe("The Documents Browser Window and API", () => {
let platform: TestPlatform;
let currentUser: TestHelpers;
let currentUser: UserApi;
let dbService: TestDbService;
beforeEach(async () => {
@@ -26,7 +26,7 @@ describe("The Documents Browser Window and API", () => {
"documents",
],
});
currentUser = await TestHelpers.getInstance(platform);
currentUser = await UserApi.getInstance(platform);
dbService = await TestDbService.getInstance(platform, true);
});
@@ -43,25 +43,25 @@ describe("The Documents Browser Window and API", () => {
expect(result).toBeDefined();
expect(result.entries()).toBeDefined();
expect(Array.from(result.entries())).toHaveLength(TestHelpers.ALL_FILES.length);
expect(Array.from(result.entries())).toHaveLength(UserApi.ALL_FILES.length);
const docs = await currentUser.browseDocuments(myDriveId, {});
expect(docs).toBeDefined();
expect(docs.children).toBeDefined();
expect(docs.children.length).toEqual(TestHelpers.ALL_FILES.length)
expect(docs.children.length).toEqual(UserApi.ALL_FILES.length)
});
it("Should not be visible for other users", async () => {
const myDriveId = "user_" + currentUser.user.id;
const anotherUser = await TestHelpers.getInstance(platform, true, {companyRole: "admin"});
const anotherUser = await UserApi.getInstance(platform, true, {companyRole: "admin"});
await currentUser.uploadAllFilesOneByOne(myDriveId);
await new Promise(r => setTimeout(r, 5000));
const docs = await currentUser.browseDocuments(myDriveId, {});
expect(docs).toBeDefined();
expect(docs.children).toBeDefined();
expect(docs.children.length).toEqual(TestHelpers.ALL_FILES.length)
expect(docs.children.length).toEqual(UserApi.ALL_FILES.length)
const anotherUserDocs = await anotherUser.searchDocument({});
expect(anotherUserDocs).toBeDefined();
@@ -77,13 +77,13 @@ describe("The Documents Browser Window and API", () => {
const result = await currentUser.uploadAllFilesOneByOne("root");
expect(result).toBeDefined();
expect(result.entries()).toBeDefined();
expect(Array.from(result.entries())).toHaveLength(TestHelpers.ALL_FILES.length);
expect(Array.from(result.entries())).toHaveLength(UserApi.ALL_FILES.length);
const docs = await currentUser.browseDocuments("root", {});
expect(docs).toBeDefined();
expect(docs.children).toBeDefined();
expect(docs.children.length).toEqual(TestHelpers.ALL_FILES.length);
expect(docs.children.length).toEqual(UserApi.ALL_FILES.length);
});
});
@@ -107,8 +107,8 @@ describe("The Documents Browser Window and API", () => {
it("Should contain files that were shared with the user", async () => {
const sharedWIthMeFolder = "shared_with_me";
const oneUser = await TestHelpers.getInstance(platform, true, {companyRole: "admin"});
const anotherUser = await TestHelpers.getInstance(platform, true, {companyRole: "admin"});
const oneUser = await UserApi.getInstance(platform, true, {companyRole: "admin"});
const anotherUser = await UserApi.getInstance(platform, true, {companyRole: "admin"});
let files = await oneUser.uploadAllFilesOneByOne();
await new Promise(r => setTimeout(r, 5000));
tdrive/backend/node/test/e2e/documents/documents-notifications.spec.ts
+8 -23
View File
@@ -1,13 +1,11 @@
import { describe, beforeEach, it, expect, afterAll, jest } from "@jest/globals";
import { init, TestPlatform } from "../setup";
import TestHelpers from "../common/common_test_helpers";
import UserApi from "../common/user-api";
import { DocumentsEngine } from "../../../src/services/documents/services/engine";
import { deserialize } from "class-transformer";
import { File } from "../../../src/services/files/entities/file";
import { ResourceUpdateResponse } from "../../../src/utils/types";
import { e2e_createDocument, e2e_createDocumentFile, e2e_createVersion } from "./utils";
import { DriveFileMockClass } from "../common/entities/mock_entities";
import { TestDbService } from "../utils.prepare.db";
import { e2e_createDocumentFile, e2e_createVersion } from "./utils";
describe("the Drive feature", () => {
let platform: TestPlatform;
@@ -16,6 +14,7 @@ describe("the Drive feature", () => {
DocumentsEngine.prototype,
"notifyDocumentVersionUpdated",
);
let currentUser: UserApi;
beforeEach(async () => {
platform = await init({
@@ -40,7 +39,8 @@ describe("the Drive feature", () => {
"documents",
],
});
}, 300000000);
currentUser = await UserApi.getInstance(platform);
});
afterAll(async () => {
await platform?.tearDown();
@@ -49,27 +49,12 @@ describe("the Drive feature", () => {
platform = null;
});
const createItem = async (): Promise<DriveFileMockClass> => {
await TestDbService.getInstance(platform, true);
const scope: "personal" | "shared" = "shared";
const item = {
name: "new test file",
parent_id: "root",
company_id: platform.workspace.company_id,
scope,
};
const version = {};
const response = await e2e_createDocument(platform, item, version);
return deserialize<DriveFileMockClass>(DriveFileMockClass, response.body);
};
it("Did notify the user after sharing a file.", async () => {
// jest.setTimeout(20000);
//given:: user uploaded one doc and give permission to another user
const oneUser = await TestHelpers.getInstance(platform, true, { companyRole: "admin" });
const anotherUser = await TestHelpers.getInstance(platform, true, { companyRole: "admin" });
const oneUser = await UserApi.getInstance(platform, true, { companyRole: "admin" });
const anotherUser = await UserApi.getInstance(platform, true, { companyRole: "admin" });
//upload files
const doc = await oneUser.uploadRandomFileAndCreateDocument();
await new Promise(r => setTimeout(r, 3000));
@@ -88,7 +73,7 @@ describe("the Drive feature", () => {
});
it("Did notify the user after creating a new version for a file.", async () => {
const item = await createItem();
const item = await currentUser.createDefaultDocument();
const fileUploadResponse = await e2e_createDocumentFile(platform);
const fileUploadResult = deserialize<ResourceUpdateResponse<File>>(
ResourceUpdateResponse,
tdrive/backend/node/test/e2e/documents/documents-search.spec.ts
+250
View File
@@ -0,0 +1,250 @@
import { describe, it, expect, afterAll } from "@jest/globals";
import { init, TestPlatform } from "../setup";
import UserApi from "../common/user-api";
import { DriveFileMockClass } from "../common/entities/mock_entities";
import { DriveFile } from "../../../src/services/documents/entities/drive-file";
describe("the Drive Search feature", () => {
let platform: TestPlatform;
let userOne: UserApi;
let start: number;
let end: number;
let userTwo: UserApi;
const uploadedByUserOne = [];
const uploadedByUserTwo = [];
beforeAll(async () => {
platform = await init({
services: [
"webserver",
"database",
"applications",
"search",
"storage",
"message-queue",
"user",
"search",
"files",
"websocket",
"messages",
"auth",
"realtime",
"channels",
"statistics",
"platform-services",
"documents",
],
});
});
afterAll(async () => {
await platform?.tearDown();
platform = null;
});
// Create data for all test at once, due not to have a lot of setTimeouts,
// And test basic searches at once
//TODO[ASH] refactor this after refactoring events handling in enittymanager
it("Crete test data", async () => {
//create one document for default user
// await currentUser.createDefaultDocument(); // 1
// await currentUser.uploadAllFilesOneByOne(); // 6
userOne = await UserApi.getInstance(platform, true, {companyRole: "admin"});
userTwo = await UserApi.getInstance(platform, true, {companyRole: "admin"});
//user one upload 6 file to the personal folder
uploadedByUserOne.push(...(await userOne.uploadAllFilesOneByOne("user_" + userOne.user.id)));
start = new Date().getTime();
//user on uploaded 6 files to the root folder
uploadedByUserOne.push(...(await userOne.uploadAllFilesOneByOne("root")));
end = new Date().getTime();
//another user uploaded 6 files to the personal folder
uploadedByUserTwo.push(...(await userTwo.uploadAllFilesOneByOne("user_" + userTwo.user.id)));
//another user uploaded 6 files to the root folder
uploadedByUserTwo.push(...(await userTwo.uploadAllFilesOneByOne("root")));
await new Promise(resolve => setTimeout(resolve, 3000));
//user one give permissions to user two to one of the documents from personal folder
const doc = uploadedByUserOne[0]
doc.access_info.entities.push({
type: "user",
id: userTwo.user.id,
level: "read",
grantor: null,
});
await userOne.updateDocument(doc.id, doc);
await new Promise(resolve => setTimeout(resolve, 10000));
});
it("did search for an item", async () => {
const searchPayload = {
search: "sample",
};
const searchResult = await userOne.searchDocument(searchPayload);
expect(searchResult.entities.length).toBeGreaterThanOrEqual(6);
});
it("did search for an item and check that all the fields for 'shared_with_me' view", async () => {
// jest.setTimeout(20000);
//when:: user search for a doc
const searchResponse = await userOne.searchDocument({ view: "shared_with_me" });
//then::
expect(searchResponse.entities?.length).toEqual(UserApi.ALL_FILES.length * 3);
const docs = searchResponse.entities.filter(e => e.id === uploadedByUserOne[0].id)
expect(docs.length).toEqual(1)
expectSharedDoc( docs[0], uploadedByUserOne[0]);
});
it("'shared_with_me' shouldn't return files uploaded by me", async () => {
//when:: user search for a doc
const searchResponse = await userTwo.sharedWithMeDocuments({});
//then::
expect(searchResponse.entities?.length).toEqual(1);
})
it("did search for an item that doesn't exist", async () => {
const unexistingSeachPayload = {
search: "somethingthatdoesn'tandshouldn'texist",
};
const failSearchResult = await userOne.searchDocument(unexistingSeachPayload);
expect(failSearchResult.entities).toHaveLength(0);
});
it("did search by mime type", async () => {
const filters = {
mime_type: "application/pdf",
};
//when
let documents = await userOne.searchDocument(filters);
//then
expect(documents.entities).toHaveLength(3);
expect(documents.entities[0].name.includes("pdf")).toBeTruthy();
expect(documents.entities[1].name.includes("pdf")).toBeTruthy();
expect(documents.entities[2].name.includes("pdf")).toBeTruthy();
});
it("did search by last modified", async () => {
//then:: only file uploaded in the [start, end] interval are shown in the search results
const filters = {
last_modified_gt: start.toString(),
last_modified_lt: end.toString(),
};
const documents = await userOne.searchDocument(filters);
expect(documents.entities).toHaveLength(UserApi.ALL_FILES.length);
});
it("did search a file shared by another user", async () => {
//then file become searchable
expect((await userTwo.sharedWithMeDocuments({})).entities).toHaveLength(1);
});
it("did search a file by file owner", async () => {
//and searchable for user that have
expect(
(
await userTwo.searchDocument({
creator: userOne.user.id,
})
).entities,
).toHaveLength(7);
});
it("did search by 'added' date", async () => {
//then:: only file uploaded in the [start, end] interval are shown in the search results
const filters = {
added_gt: start.toString(),
added_lt: end.toString(),
};
const documents = await userOne.searchDocument(filters);
expect(documents.entities).toHaveLength(UserApi.ALL_FILES.length);
});
it("did search order by name", async () => {
//when:: sort files by name is ascending order
const options = {
sort: {
name_keyword: "asc",
},
};
const documents = await userOne.searchDocument(options);
//then all the files are sorted properly by name
let actualNames = documents.entities.map(e => e.name);
expect(actualNames).toEqual(actualNames.slice().sort());
});
it("did search order by name desc", async () => {
//when:: sort files by name is ascending order
const options = {
sort: {
name_keyword: "desc",
},
};
const documents = await userOne.searchDocument(options);
//then all the files are sorted properly by name
let actualNames = documents.entities.map(e => e.name);
expect(actualNames).toEqual(actualNames.slice().sort().reverse());
});
it("did search order by added date", async () => {
//when:: ask to sort files by the 'added' field
const options = {
sort: {
added: "asc",
},
};
const documents = await userOne.searchDocument(options);
//then:: files should be sorted properly
let actualDocs = documents.entities;
let expectedDocs = actualDocs.slice()
.sort((a, b) => a.added - b.added)
.map(d => d.name);
expect(actualDocs.map(d => d.name)).toEqual(expectedDocs);
});
it("did search order by added date desc", async () => {
//when:: ask to sort files by the 'added' field desc
const options = {
sort: {
added: "desc",
},
};
const documents = await userOne.searchDocument(options);
//then:: files should be sorted properly
let actualDocs = documents.entities;
let expectedDocs = actualDocs.slice()
.sort((a, b) => a.added - b.added)
.map(d => d.name)
.reverse();
expect(actualDocs.map(d => d.name)).toEqual(expectedDocs);
});
function expectSharedDoc(actual: DriveFileMockClass, doc: DriveFile) {
expect(actual.name).toEqual(doc.name);
//file type
expect(actual.extension).toEqual(doc.extension);
expect(actual.id).toEqual(doc.id);
expect(actual.is_directory).toEqual(doc.is_directory);
expect(actual.last_modified).toEqual(doc.last_modified);
expect(actual.added).toEqual(doc.added);
expect(actual.parent_id).toEqual(doc.parent_id);
expect(actual.created_by?.id).toEqual(userOne.user.id);
expect(actual.created_by?.first_name).toEqual(userOne.user.first_name);
expect(actual.shared_by?.id).toEqual(userOne.user.id);
expect(actual.shared_by?.first_name).toEqual(userOne.user.first_name);
}
});
tdrive/backend/node/test/e2e/documents/documents-tab.spec.ts
+7 -32
View File
@@ -1,14 +1,15 @@
import { afterAll, afterEach, beforeEach, describe, expect, it } from "@jest/globals";
import { afterAll, 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";
import UserApi from "../common/user-api";
const url = "/internal/services/documents/v1";
describe("the Drive Tdrive tabs feature", () => {
let platform: TestPlatform;
let currentUser: UserApi;
class DriveFileMockClass {
id: string;
@@ -49,6 +50,7 @@ describe("the Drive Tdrive tabs feature", () => {
"documents",
],
});
currentUser = await UserApi.getInstance(platform);
});
afterAll(async () => {
@@ -59,16 +61,7 @@ describe("the Drive Tdrive tabs feature", () => {
it("did create a tab configuration on Drive side", async () => {
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 doc = await currentUser.createDefaultDocument();
const tab = {
company_id: platform.workspace.company_id,
@@ -109,7 +102,7 @@ describe("the Drive Tdrive tabs feature", () => {
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 documentResponse = await currentUser.getDocument(doc.id);
const documentResult = deserialize<DriveItemDetailsMockClass>(
DriveItemDetailsMockClass,
documentResponse.body,
@@ -132,25 +125,7 @@ describe("the Drive Tdrive tabs feature", () => {
};
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 doc = await currentUser.createDefaultDocument();
const tab = {
company_id: platform.workspace.company_id,
tdrive/backend/node/test/e2e/documents/documents.spec.ts
+13 -353
View File
@@ -5,25 +5,20 @@ 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";
import TestHelpers from "../common/common_test_helpers";
import UserApi from "../common/user-api";
import {
DriveFileMockClass,
DriveItemDetailsMockClass,
SearchResultMockClass,
} from "../common/entities/mock_entities";
describe("the Drive feature", () => {
let platform: TestPlatform;
let currentUser: TestHelpers;
let dbService: TestDbService;
let currentUser: UserApi;
beforeEach(async () => {
platform = await init({
@@ -48,33 +43,17 @@ describe("the Drive feature", () => {
"documents",
],
});
currentUser = await TestHelpers.getInstance(platform);
dbService = await TestDbService.getInstance(platform, true);
}, 300000000);
currentUser = await UserApi.getInstance(platform);
});
afterAll(async () => {
await platform?.tearDown();
platform = null;
});
const createItem = async (): Promise<DriveFileMockClass> => {
await TestDbService.getInstance(platform, true);
const scope: "personal" | "shared" = "shared";
const item = {
name: "new test file",
parent_id: "root",
company_id: platform.workspace.company_id,
scope,
};
const version = {};
const response = await e2e_createDocument(platform, item, version);
return deserialize<DriveFileMockClass>(DriveFileMockClass, response.body);
};
it("did create the drive item", async () => {
const result = await createItem();
const result = await currentUser.createDefaultDocument();
expect(result).toBeDefined();
expect(result.name).toEqual("new test file");
@@ -84,7 +63,7 @@ describe("the Drive feature", () => {
it("did fetch the drive item", async () => {
await TestDbService.getInstance(platform, true);
const response = await e2e_getDocument(platform, "");
const response = await currentUser.getDocument("");
const result = deserialize<DriveItemDetailsMockClass>(DriveItemDetailsMockClass, response.body);
expect(result.item.id).toEqual("root");
@@ -94,7 +73,7 @@ describe("the Drive feature", () => {
it("did fetch the trash", async () => {
await TestDbService.getInstance(platform, true);
const response = await e2e_getDocument(platform, "trash");
const response = await currentUser.getDocument("trash");
const result = deserialize<DriveItemDetailsMockClass>(DriveItemDetailsMockClass, response.body);
expect(result.item.id).toEqual("trash");
@@ -102,7 +81,7 @@ describe("the Drive feature", () => {
});
it("did delete an item", async () => {
const createItemResult = await createItem();
const createItemResult = await currentUser.createDefaultDocument();
expect(createItemResult.id).toBeDefined();
@@ -111,7 +90,7 @@ describe("the Drive feature", () => {
});
it("did update an item", async () => {
const createItemResult = await createItem();
const createItemResult = await currentUser.createDefaultDocument();
expect(createItemResult.id).toBeDefined();
@@ -130,14 +109,14 @@ describe("the Drive feature", () => {
});
it("did move an item to trash", async () => {
const createItemResult = await createItem();
const createItemResult = await currentUser.createDefaultDocument();
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 listTrashResponse = await currentUser.getDocument("trash");
const listTrashResult = deserialize<DriveItemDetailsMockClass>(
DriveItemDetailsMockClass,
listTrashResponse.body,
@@ -148,115 +127,8 @@ describe("the Drive feature", () => {
expect(listTrashResult.children.some(({ id }) => id === createItemResult.id)).toBeTruthy();
});
it("did search for an item", async () => {
// jest.setTimeout(10000);
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);
});
it("did search for an item and check that all the fields for 'shared_with_me' view", async () => {
// jest.setTimeout(20000);
//given:: user uploaded one doc and give permission to another user
const oneUser = await TestHelpers.getInstance(platform, true, {companyRole: "admin"});
const anotherUser = await TestHelpers.getInstance(platform, true, {companyRole: "admin"});
//upload files
const doc = await oneUser.uploadRandomFileAndCreateDocument();
await new Promise(r => setTimeout(r, 3000));
//give permissions to the file
doc.access_info.entities.push({
type: "user",
id: anotherUser.user.id,
level: "read",
grantor: null,
});
await oneUser.updateDocument(doc.id, doc);
await new Promise(resolve => setTimeout(resolve, 5000));
//when:: user search for a doc
const searchResponse = await anotherUser.searchDocument({ view: "shared_with_me" });
//then::
expect(searchResponse.entities?.length).toEqual(1);
const actual = searchResponse.entities[0];
//file name
expect(actual.name).toEqual(doc.name);
//file type
expect(actual.extension).toEqual(doc.extension);
expect(actual.id).toEqual(doc.id);
expect(actual.is_directory).toEqual(doc.is_directory);
expect(actual.last_modified).toEqual(doc.last_modified);
expect(actual.added).toEqual(doc.added);
expect(actual.parent_id).toEqual(doc.parent_id);
expect(actual.created_by?.id).toEqual(oneUser.user.id);
expect(actual.created_by?.first_name).toEqual(oneUser.user.first_name);
expect(actual.shared_by?.id).toEqual(oneUser.user.id);
expect(actual.shared_by?.first_name).toEqual(oneUser.user.first_name);
});
it("'shared_with_me' shouldn't return files uploaded by me", async () => {
// jest.setTimeout(20000);
//given:: user uploaded one doc and give permission to another user
const oneUser = await TestHelpers.getInstance(platform, true, {companyRole: "admin"});
const anotherUser = await TestHelpers.getInstance(platform, true, {companyRole: "admin"});
const doc = await oneUser.uploadRandomFileAndCreateDocument();
await new Promise(r => setTimeout(r, 3000));
//give permissions to the file
doc.access_info.entities.push({
type: "user",
id: anotherUser.user.id,
level: "read",
grantor: null,
});
await oneUser.updateDocument(doc.id, doc);
//another user also uploaded several files
await anotherUser.uploadRandomFileAndCreateDocument();
await new Promise(resolve => setTimeout(resolve, 5000));
//when:: user search for a doc
const searchResponse = await anotherUser.sharedWithMeDocuments({});
//then::
expect(searchResponse.entities?.length).toEqual(1);
})
it("did search for an item that doesn't exist", async () => {
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);
});
it("did create a version for a drive item", async () => {
const item = await createItem();
const item = await currentUser.createDefaultDocument();
const fileUploadResponse = await e2e_createDocumentFile(platform);
const fileUploadResult = deserialize<ResourceUpdateResponse<File>>(
ResourceUpdateResponse,
@@ -269,7 +141,7 @@ describe("the Drive feature", () => {
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 fetchItemResponse = await currentUser.getDocument(item.id);
const fetchItemResult = deserialize<DriveItemDetailsMockClass>(
DriveItemDetailsMockClass,
fetchItemResponse.body,
@@ -278,216 +150,4 @@ describe("the Drive feature", () => {
expect(fetchItemResult.versions).toHaveLength(4);
});
it("did search by mime type", async () => {
// jest.setTimeout(10000);
// given:: all the sample files uploaded and documents for them created
await currentUser.uploadAllFilesOneByOne();
const filters = {
mime_type: "application/pdf",
};
await new Promise(r => setTimeout(r, 5000));
let documents = await currentUser.searchDocument(filters);
expect(documents.entities).toHaveLength(1);
const actualFile = documents.entities[0];
expect(actualFile.name).toEqual("sample.pdf");
});
it("did search by last modified", async () => {
// jest.setTimeout(10000);
const user = await TestHelpers.getInstance(platform, true, {companyRole: "admin"});
// given:: all the sample files uploaded and documents for them created
const start = new Date().getTime();
await user.uploadAllFilesOneByOne();
const end = new Date().getTime();
await user.uploadAllFilesOneByOne();
//wait for putting docs to elastic and its indexing
await new Promise(r => setTimeout(r, 5000));
//then:: all the files are searchable without filters
let documents = await user.searchDocument({});
expect(documents.entities).toHaveLength(TestHelpers.ALL_FILES.length * 2);
//then:: only file uploaded in the [start, end] interval are shown in the search results
const filters = {
last_modified_gt: start.toString(),
last_modified_lt: end.toString(),
};
documents = await user.searchDocument(filters);
expect(documents.entities).toHaveLength(TestHelpers.ALL_FILES.length);
});
it("did search a file shared by another user", async () => {
//given:
const oneUser = await TestHelpers.getInstance(platform, true, {companyRole: "admin"});
const anotherUser = await TestHelpers.getInstance(platform, true, {companyRole: "admin"});
//upload files
let files = await oneUser.uploadAllFilesOneByOne();
await new Promise(r => setTimeout(r, 5000));
//then:: files are not searchable for user without permissions
expect((await anotherUser.sharedWithMeDocuments({})).entities).toHaveLength(0);
//and searchable for user that have
expect((await oneUser.searchDocument({})).entities).toHaveLength(TestHelpers.ALL_FILES.length);
//give permissions to the file
files[0].access_info.entities.push({
type: "user",
id: anotherUser.user.id,
level: "read",
grantor: null,
});
await oneUser.updateDocument(files[0].id, files[0]);
await new Promise(r => setTimeout(r, 3000));
//then file become searchable
expect((await anotherUser.sharedWithMeDocuments({})).entities).toHaveLength(1);
}, 30000000);
it("did search a file by file owner", async () => {
// jest.setTimeout(30000);
//given:
const oneUser = await TestHelpers.getInstance(platform, true, {companyRole: "admin"});
const anotherUser = await TestHelpers.getInstance(platform, true, {companyRole: "admin"});
//upload files
let files = await oneUser.uploadAllFilesOneByOne();
await anotherUser.uploadAllFilesOneByOne();
//give permissions for all files to 'another user'
await Promise.all(
files.map(f => {
f.access_info.entities.push({
type: "user",
id: anotherUser.user.id,
level: "read",
grantor: null,
});
return oneUser.updateDocument(f.id, f);
}),
);
await new Promise(r => setTimeout(r, 5000));
//then:: all files are searchable for 'another user'
expect((await anotherUser.searchDocument({})).entities).toHaveLength(
TestHelpers.ALL_FILES.length * 2,
);
//and searchable for user that have
expect(
(
await oneUser.searchDocument({
creator: oneUser.user.id,
})
).entities,
).toHaveLength(TestHelpers.ALL_FILES.length);
});
it("did search by 'added' date", async () => {
// jest.setTimeout(10000);
const user = await TestHelpers.getInstance(platform, true, {companyRole: "admin"});
// given:: all the sample files uploaded and documents for them created
await user.uploadRandomFileAndCreateDocument();
const start = new Date().getTime();
await user.uploadAllFilesAndCreateDocuments();
const end = new Date().getTime();
await user.uploadRandomFileAndCreateDocument();
//wait for putting docs to elastic and its indexing
await new Promise(r => setTimeout(r, 3000));
//then:: all the files are searchable without filters
let documents = await user.searchDocument({});
expect(documents.entities).toHaveLength(TestHelpers.ALL_FILES.length + 2);
//then:: only file uploaded in the [start, end] interval are shown in the search results
const filters = {
added_gt: start.toString(),
added_lt: end.toString(),
};
documents = await user.searchDocument(filters);
expect(documents.entities).toHaveLength(TestHelpers.ALL_FILES.length);
});
it("did search order by name", async () => {
const user = await TestHelpers.getInstance(platform, true, {companyRole: "admin"});
// given:: all the sample files uploaded and documents for them created
await user.uploadAllFilesAndCreateDocuments();
//wait for putting docs to elastic and its indexing
await new Promise(r => setTimeout(r, 5000));
//when:: sort files by name is ascending order
const options = {
sort: {
name_keyword: "asc",
},
};
const documents = await user.searchDocument(options);
//then all the files are sorted properly by name
expect(documents.entities.map(e => e.name)).toEqual(TestHelpers.ALL_FILES.sort());
}, 30000);
it("did search order by name desc", async () => {
// jest.setTimeout(10000);
const user = await TestHelpers.getInstance(platform, true, {companyRole: "admin"});
// given:: all the sample files uploaded and documents for them created
await user.uploadAllFilesOneByOne();
//wait for putting docs to elastic and its indexing
await new Promise(r => setTimeout(r, 5000));
//when:: sort files by name is ascending order
const options = {
sort: {
name_keyword: "desc",
},
};
const documents = await user.searchDocument(options);
//then all the files are sorted properly by name
expect(documents.entities.map(e => e.name)).toEqual(TestHelpers.ALL_FILES.sort().reverse());
});
it("did search order by added date", async () => {
// jest.setTimeout(10000);
const user = await TestHelpers.getInstance(platform, true, {companyRole: "admin"});
// given:: all the sample files uploaded and documents for them created
await user.uploadAllFilesOneByOne();
//wait for putting docs to elastic and its indexing
await new Promise(r => setTimeout(r, 5000));
//when:: ask to sort files by the 'added' field
const options = {
sort: {
added: "asc",
},
};
const documents = await user.searchDocument(options);
//then:: files should be sorted properly
expect(documents.entities.map(e => e.name)).toEqual(TestHelpers.ALL_FILES);
});
it("did search order by added date desc", async () => {
// jest.setTimeout(10000);
const user = await TestHelpers.getInstance(platform, true, {companyRole: "admin"});
// given:: all the sample files uploaded and documents for them created
await user.uploadAllFilesOneByOne();
//wait for putting docs to elastic and its indexing
await new Promise(r => setTimeout(r, 5000));
//when:: ask to sort files by the 'added' field desc
const options = {
sort: {
added: "desc",
},
};
const documents = await user.searchDocument(options);
//then:: files should be sorted properly
expect(documents.entities.map(e => e.name)).toEqual(TestHelpers.ALL_FILES.reverse());
});
});
tdrive/backend/node/test/e2e/documents/my-drive.spec.ts
+6 -13
View File
@@ -1,21 +1,16 @@
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";
import UserApi from "../common/user-api";
import { DriveFile } from "../../../src/services/documents/entities/drive-file";
describe("the My Drive feature", () => {
let platform: TestPlatform;
let currentUser: UserApi;
class DriveFileMockClass {
id: string;
@@ -60,6 +55,7 @@ describe("the My Drive feature", () => {
"documents",
],
});
currentUser = await UserApi.getInstance(platform);
});
afterAll(async () => {
@@ -67,7 +63,7 @@ describe("the My Drive feature", () => {
platform = null;
});
const createItem = async (): Promise<DriveFileMockClass> => {
const createItem = async (): Promise<DriveFile> => {
await TestDbService.getInstance(platform, true);
const item = {
@@ -76,10 +72,7 @@ describe("the My Drive feature", () => {
company_id: platform.workspace.company_id,
};
const version = {};
const response = await e2e_createDocument(platform, item, version);
return deserialize<DriveFileMockClass>(DriveFileMockClass, response.body);
return await currentUser.createDocument(item, {});
};
it("did create the drive item in my user folder", async () => {
tdrive/backend/node/test/e2e/documents/public-links.spec.ts
+8 -21
View File
@@ -4,14 +4,15 @@ import { AccessInformation, DriveFile } from "../../../src/services/documents/en
import { FileVersion } from "../../../src/services/documents/entities/file-version";
import { DriveFileAccessLevel, DriveItemDetails } from "../../../src/services/documents/types";
import { init, TestPlatform } from "../setup";
import { e2e_createDocument, e2e_updateDocument } from "./utils";
import TestHelpers from "../common/common_test_helpers";
import { e2e_updateDocument } from "./utils";
import UserApi from "../common/user-api";
import { AccessTokenMockClass } from "../common/entities/mock_entities";
const url = "/internal/services/documents/v1";
describe("the public links feature", () => {
let platform: TestPlatform;
let currentUser: UserApi;
class DriveFileMockClass {
id: string;
@@ -54,6 +55,7 @@ describe("the public links feature", () => {
"documents",
],
});
currentUser = await UserApi.getInstance(platform);
});
afterAll(async () => {
@@ -62,29 +64,14 @@ describe("the public links feature", () => {
});
describe("Basic Flow", () => {
const createItem = async (): Promise<DriveFileMockClass> => {
await TestHelpers.getInstance(platform, true, { companyRole: "admin" });
const item = {
name: "public 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);
};
let publicFile: DriveFileMockClass;
it("did create the drive item", async () => {
const result = await createItem();
const result = await currentUser.createDefaultDocument();
publicFile = result;
expect(result).toBeDefined();
expect(result.name).toEqual("public file");
expect(result.name).toEqual("new test file");
expect(result.added).toBeDefined();
expect(result.access_info).toBeDefined();
});
@@ -283,8 +270,8 @@ describe("the public links feature", () => {
describe("Download Folder from shared link", () => {
it("Share folder", async () => {
const user = await TestHelpers.getInstance(platform, true);
const anotherUser = await TestHelpers.getInstance(platform, true);
const user = await UserApi.getInstance(platform, true);
const anotherUser = await UserApi.getInstance(platform, true);
//create directory in "My Drive" and upload a file
const directory = await user.createDirectory("user_" + user.user.id);
tdrive/backend/node/test/e2e/documents/utils.ts
-47
View File
@@ -6,38 +6,6 @@ import * as 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();
@@ -67,21 +35,6 @@ export const e2e_updateDocument = async (
});
};
export const e2e_searchDocument = async (
platform: TestPlatform,
payload: Record<string, string>,
) => {
const token = await platform.auth.getJWTToken();
return await platform.app.inject({
method: "POST",
url: `${url}/companies/${platform.workspace.company_id}/search`,
headers: {
authorization: `Bearer ${token}`,
},
payload,
});
};
export const e2e_createVersion = async (
platform: TestPlatform,