@studyportals/campaign-management-api-interface 0.12.0 → 0.13.1

package/.vscode/launch.json

@@ -0,0 +1,36 @@
+{
+	"version": "0.2.0",
+	"configurations": [
+		{
+			"type": "node",
+			"request": "launch",
+			"name": "Jest watch current file",
+			"program": "${workspaceFolder}/node_modules/jest-cli/bin/jest",
+			"args": [
+				"${fileBasename}",
+				"--verbose",
+				"-i",
+				"--no-cache",
+				"--watchAll"
+			],
+			"console": "integratedTerminal",
+			"internalConsoleOptions": "neverOpen"
+		},
+		{
+			"name": "TypeScript - All Tests Files",
+			"type": "node",
+			"request": "launch",
+			"program": "${workspaceRoot}/node_modules/mocha/bin/_mocha",
+			"args": [
+				"--require",
+				"ts-node/register",
+				"--colors",
+				"${relativeFile}",
+				"--no-timeouts",
+				"src/*-tests/*.test.ts"
+			],
+			"cwd": "${workspaceRoot}",
+			"protocol": "inspector"
+		}
+	]
+}

package/.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+    "typescript.preferences.importModuleSpecifier": "relative",
+    "javascript.preferences.importModuleSpecifier": "relative"
+}

package/.vscode/tasks.json

@@ -0,0 +1,41 @@
+{
+	"version": "2.0.0",
+	"tasks": [
+		{
+			"label": "runCurrentTest",
+			"type": "shell",
+			"command": "cross-env NODE_ENV=tst npx jest -c jest.config.single-file.json --maxWorkers=1 \"${relativeFile}\"",
+			"group": "test",
+			"presentation": {
+				"echo": true,
+				"reveal": "always",
+				"focus": true,
+				"panel": "dedicated"
+			}
+		},
+		{
+			"label": "runCurrentTestWatch",
+			"type": "shell",
+			"command": "npx jest -c jest.config.unit.json --maxWorkers=1 --watch \"${relativeFile}\"",
+			"group": "test",
+			"presentation": {
+				"echo": true,
+				"reveal": "always",
+				"focus": true,
+				"panel": "dedicated"
+			}
+		},
+		{
+			"label": "runCurrentTestClearCache",
+			"type": "shell",
+			"command": "npx jest -c jest.config.unit.json --maxWorkers=1 --clearCache",
+			"group": "test",
+			"presentation": {
+				"echo": true,
+				"reveal": "always",
+				"focus": true,
+				"panel": "dedicated"
+			}
+		},
+	]
+}

package/README.md

@@ -0,0 +1,2 @@
+# Campaign-Management-API-Interface
+This is the front-end client for the CMA (Campaign Management API) and it's interfaces.

package/{index.d.ts → index.ts}

@@ -6,4 +6,24 @@ import { GetAuditorDto } from "./src/domain/auditor/get-auditor.dto";
 import { CampaignsEntitiesConfigDto } from "./src/domain/campaign/CampaignsEntitiesConfig.dto";
 import { NumberMap, Pricing, ICampaignAuditorData } from "./src/domain/auditor/campaigns/geotargeting.entities";
 import { PrivateCampaignManagementAPIClient } from "./src/private-campaign-management-api.client";
-export { AuditorCampaignManagementAPIClient, CampaignManagementAPIClient, PrivateCampaignManagementAPIClient, AuditorEntityType, AuditorOperation, GetAuditorDto, CampaignsEntitiesConfigDto, NumberMap, Pricing, ICampaignAuditorData };
+
+export {
+    // Clients
+    AuditorCampaignManagementAPIClient,
+    CampaignManagementAPIClient,
+    PrivateCampaignManagementAPIClient,
+
+    // Enums
+    AuditorEntityType,
+    AuditorOperation,
+
+    // Output Dto
+    GetAuditorDto,
+
+    // Input Dto
+    CampaignsEntitiesConfigDto,
+
+    NumberMap,
+    Pricing,
+    ICampaignAuditorData
+}

package/jest.config.single-file.json

@@ -0,0 +1,20 @@
+{
+	"moduleFileExtensions": [
+		"js",
+		"json",
+		"ts"
+	],
+	"rootDir": "",
+	"transform": {
+		"^.+\\.(t|j)s$": "ts-jest"
+	},
+	"collectCoverageFrom": [
+		"src/**/*.(t|j)s"
+	],
+	"coverageDirectory": "../coverage",
+	"testEnvironment": "node",
+	"testMatch": [
+		"<rootDir>/tests-u/**/*\\.(spec|test)\\.ts",
+		"<rootDir>/tests-i/**/*\\.(spec|test)\\.ts"
+	]
+}

package/jest.config.unit.json

@@ -0,0 +1,19 @@
+{
+	"moduleFileExtensions": [
+		"js",
+		"json",
+		"ts"
+	],
+	"rootDir": "",
+	"transform": {
+		"^.+\\.(t|j)s$": "ts-jest"
+	},
+	"collectCoverageFrom": [
+		"src/**/*.(t|j)s"
+	],
+	"coverageDirectory": "../coverage",
+	"testEnvironment": "node",
+	"testMatch": [
+		"<rootDir>/tests-u/**/*\\.(spec|test)\\.ts"
+	]
+}

package/package.json

@@ -1,12 +1,12 @@
 {
 	"name": "@studyportals/campaign-management-api-interface",
-	"version": "0.12.0",
+	"version": "0.13.1",
 	"scripts": {
 		"compile": "rm -fR bin && npx tsc",
 		"test-u": "jest -c jest.config.unit.json --silent --maxWorkers=1",
 		"test-i": "nyc mocha src tests-i",
 		"prepare-deployment": "npm run test-u && npm run compile && cp package.json bin/package.json && rm -fR bin/tests-u",
-		"deploy": "npm run prepare-deployment && npm publish bin --access=public",
+		"deploy": "npm run prepare-deployment && npm publish --access=public",
 		"deploy-patch": "npm version patch && npm run deploy",
 		"deploy-minor": "npm version minor && npm run deploy",
 		"deploy-major": "npm version major && npm run deploy",

package/src/auditor-campaign-management-api.client.ts

@@ -0,0 +1,54 @@
+import "reflect-metadata";
+
+import { SuperAgentRequest } from "superagent";
+import { GetAuditorDto } from "./domain/auditor/get-auditor.dto";
+import { AuditorOperation } from "./domain/auditor/enums/auditor-operation.enum";
+import { injectable } from "inversify";
+
+import * as superagent from "superagent";
+
+@injectable()
+export class AuditorCampaignManagementAPIClient {
+    public constructor(
+        private readonly baseUrl: string
+    ) { }
+
+    public async getCampaignAuditorData(campaignID: number, jwt = ""): Promise<GetAuditorDto[]> {
+        const result = await this.getRequest(`auditor/campaigns/${campaignID}`, jwt);
+        const getAuditorDtos = result.body as GetAuditorDto[];
+
+        return getAuditorDtos;
+    }
+
+    public async storeCampaignAuditorData(operation: AuditorOperation, campaignID: number, username: string, isUserAction: boolean, data: any, jwt = ""): Promise<GetAuditorDto> {
+        const sendData = {
+            "operation": operation,
+            "entityID": campaignID,
+            "username": username,
+            "isUserAction": isUserAction,
+            "data": data
+        };
+
+        const result = await this.postRequest(`auditor/campaigns`, sendData, jwt);
+
+        return result.body as GetAuditorDto;
+    }
+
+
+    private async getRequest(relative: string = "", jwt = ""): Promise<SuperAgentRequest> {
+        return await superagent.get(this.buildBaseUrl(relative))
+            .set("Content-Type", "application/json")
+            .set("Authorization", jwt);
+    }
+
+    private async postRequest(relative: string = "", data: any, jwt = ""): Promise<SuperAgentRequest> {
+        return await superagent.post(this.buildBaseUrl(relative))
+            .set("Content-Type", "application/json")
+            .set("Authorization", jwt)
+            .send(data);
+    }
+
+    private buildBaseUrl(relative: string): string {
+        return `${this.baseUrl}/${relative}`;
+    }
+}

package/src/campaign-management-api.client.ts

@@ -0,0 +1,68 @@
+import "reflect-metadata";
+
+import { SuperAgentRequest } from "superagent";
+import { injectable } from "inversify";
+import { CampaignsEntitiesConfigDto } from "./domain/campaign/CampaignsEntitiesConfig.dto";
+
+import * as superagent from "superagent";
+
+@injectable()
+export class CampaignManagementAPIClient {
+	public constructor(
+		private readonly baseUrl: string
+	) {	}
+
+	public async addCampaignsEntitiesConfigs(campaignID: number, campaignsEntitiesConfigs: CampaignsEntitiesConfigDto[]): Promise<any> {
+		const path = `campaigns/add-campaigns-entities-configs`;
+		const data = {
+			campaignsEntitiesConfigs: campaignsEntitiesConfigs,
+			campaignID: campaignID
+		};
+
+		return await this.postRequest(path, data);
+	}
+
+	public async removeCampaignsEntitiesConfigsByID(campaignID: number, campaignsEntitiesConfigsIDs: number[]): Promise<any> {
+		const path = `campaigns/remove-campaigns-entities-configs`;
+		const data = { campaignsEntitiesConfigsIDs: campaignsEntitiesConfigsIDs, campaignID: campaignID };
+
+		return await this.postRequest(path, data);
+	}
+
+	public async clearCampaignsEntitiesConfigsByCampaignID(campaignID: number): Promise<any> {
+		const path = `campaigns/clear-campaigns-entities-configs`;
+		const data = { campaignID: campaignID };
+
+		return await this.postRequest(path, data);
+	}
+
+	public async setEntitiesBasic(campaignID: number, organisationIDs: number[], studyIDs: number[]): Promise<any> {
+		const path = `campaigns/set-entities-basic`;
+		const data = { 
+			organisationIDs: organisationIDs, 
+			studyIDs: studyIDs,
+			campaignID: campaignID
+		};
+
+		return await this.postRequest(path, data);
+	}
+
+	public async setEntitiesPremium(campaignID: number, organisationIDs: number[], studyIDs: number[]): Promise<any> {
+		const path = `campaigns/set-entities-premium`;
+		const data = { 
+			organisationIDs: organisationIDs, 
+			studyIDs: studyIDs,
+			campaignID: campaignID 
+		};
+
+		return await this.postRequest(path, data);
+	}
+
+	private async postRequest(relative: string = "", data: any): Promise<SuperAgentRequest> {
+        return await superagent.post(this.buildBaseUrl(relative)).set("Content-Type", "application/json").send(data);
+	}
+
+	private buildBaseUrl(relative: string): string {
+		return `${this.baseUrl}/${relative}`;
+	}
+}

package/src/domain/auditor/campaigns/geotargeting.entities.ts

@@ -0,0 +1,20 @@
+interface NumberMap { [key: string]: number; }
+
+interface ICampaignAuditorData {
+    geo: any[];
+    pricing: Pricing;
+    geo_remainders: NumberMap;
+}
+
+class Pricing {
+    public constructor(
+        public s: NumberMap = {},
+        public o: NumberMap = {}
+    ) {}
+}
+
+export {
+    ICampaignAuditorData,
+    NumberMap,
+    Pricing
+};

package/src/domain/auditor/enums/auditor-entity-type.enum.ts

@@ -0,0 +1,3 @@
+export enum AuditorEntityType {
+    CAMPAIGN = "campaign"
+}

package/src/domain/auditor/enums/{auditor-operation.enum.d.ts → auditor-operation.enum.ts}

@@ -1,4 +1,4 @@
-export declare enum AuditorOperation {
+export enum AuditorOperation {
     CLEANUP = "cleanup",
     UPDATE = "update",
     CREATE = "create",
@@ -6,4 +6,4 @@ export declare enum AuditorOperation {
     UNLINK = "unlink",
     DELETE = "delete",
     ENDOR = "endor"
-}
+}

package/src/domain/auditor/get-auditor.dto.ts

@@ -0,0 +1,33 @@
+import { AuditorEntityType } from "./enums/auditor-entity-type.enum";
+import { AuditorOperation } from "./enums/auditor-operation.enum";
+
+export class GetAuditorDto {
+    public readonly id: number;
+    public readonly auditTime: string
+    public readonly operation: AuditorOperation
+    public readonly entityID: number
+    public readonly entityType: AuditorEntityType
+    public readonly username: string
+    public readonly isUserAction: boolean
+    public readonly data: any
+
+    public constructor(
+        id: number,
+        auditTime: string,
+        operation: AuditorOperation,
+        entityID: number,
+        entityType: AuditorEntityType,
+        username: string,
+        isUserAction: boolean,
+        data: any
+    ) {
+        this.id = id;
+        this.auditTime = auditTime;
+        this.operation = operation;
+        this.entityID = entityID;
+        this.entityType = entityType;
+        this.username = username;
+        this.isUserAction = isUserAction;
+        this.data = data;
+    }
+}

package/src/domain/campaign/CampaignsEntitiesConfig.dto.ts

@@ -0,0 +1,7 @@
+export class CampaignsEntitiesConfigDto {
+    public campaign_id: number;
+    public sp_id: number;
+    public product_id: number;
+    public product2_id: number | null = null;
+    public type: string;
+}

package/src/private-campaign-management-api.client.ts

@@ -0,0 +1,80 @@
+import "reflect-metadata";
+
+import { SuperAgentRequest } from "superagent";
+import { injectable } from "inversify";
+import { CampaignsEntitiesConfigDto } from "./domain/campaign/CampaignsEntitiesConfig.dto";
+import { ISuperAgentRequestFactory, SignedRequestSender } from "@studyportals/mb-platform-http-requests";
+
+@injectable()
+export class PrivateCampaignManagementAPIClient {
+	public constructor(
+        private readonly superAgentRequestFactory: ISuperAgentRequestFactory,
+        private readonly requestSender: SignedRequestSender,
+		private readonly baseUrl: string
+	) {	}
+
+	public async addCampaignsEntitiesConfigs(campaignID: number, campaignsEntitiesConfigs: CampaignsEntitiesConfigDto[]): Promise<any> {
+		const path = `private/campaigns/add-campaigns-entities-configs`;
+		const data = {
+			campaignsEntitiesConfigs: campaignsEntitiesConfigs,
+			campaignID: campaignID
+		};
+
+		return await this.postRequest(path, data);
+	}
+
+	public async removeCampaignsEntitiesConfigsByID(campaignID: number, campaignsEntitiesConfigsIDs: number[]): Promise<any> {
+		const path = `private/campaigns/remove-campaigns-entities-configs`;
+		const data = { campaignsEntitiesConfigsIDs: campaignsEntitiesConfigsIDs, campaignID: campaignID };
+
+		return await this.postRequest(path, data);
+	}
+
+	public async clearCampaignsEntitiesConfigsByCampaignID(campaignID: number): Promise<any> {
+		const path = `private/campaigns/clear-campaigns-entities-configs`;
+		const data = { campaignID: campaignID };
+
+		return await this.postRequest(path, data);
+	}
+
+	public async setEntitiesBasic(campaignID: number, organisationIDs: number[], studyIDs: number[]): Promise<any> {
+		const path = `private/campaigns/set-entities-basic`;
+		const data = { 
+			organisationIDs: organisationIDs, 
+			studyIDs: studyIDs,
+			campaignID: campaignID
+		};
+
+		return await this.postRequest(path, data);
+	}
+
+	public async setEntitiesPremium(campaignID: number, organisationIDs: number[], studyIDs: number[]): Promise<any> {
+		const path = `private/campaigns/set-entities-premium`;
+		const data = { 
+			organisationIDs: organisationIDs, 
+			studyIDs: studyIDs,
+			campaignID: campaignID
+		};
+
+		return await this.postRequest(path, data);
+	}
+
+	private async postRequest(relative: string = "", data: any): Promise<any> {
+        const request = this.createPostRequest(relative);
+		return await this.sendRequest(request, data);
+	}
+
+    private createPostRequest(relative: string = ""): SuperAgentRequest {
+		const url = this.buildBaseUrl(relative);
+		return this.superAgentRequestFactory.post(url);
+	}
+
+    private async sendRequest(request: SuperAgentRequest, payload: any): Promise<any> {
+		request.send(payload);
+		return await this.requestSender.send(request);
+	}
+
+	private buildBaseUrl(relative: string): string {
+		return `${this.baseUrl}/${relative}`;
+	}
+}

package/tests-u/domain/auditor/auditor-campaign-management-api-client.test.ts

@@ -0,0 +1,99 @@
+import { suite, test } from "@testdeck/jest";
+import { MockProxy, mock } from "jest-mock-extended";
+import { assert } from "chai";
+import { AuditorCampaignManagementAPIClient } from "../../../src/auditor-campaign-management-api.client";
+import { IRequestSender, ISuperAgentRequestFactory, RequestSender } from "@studyportals/mb-platform-http-requests";
+import { SuperAgentRequest } from "superagent";
+import { AuditorOperation } from "../../../src/domain/auditor/enums/auditor-operation.enum";
+import * as superagent from "superagent";
+
+
+const superagentMock = require("superagent-mocker")(superagent);
+
+@suite
+class AuditorCampaignManagementAPIClientTest {
+    private auditorCampaignManagementAPIClient: AuditorCampaignManagementAPIClient;
+    private mockedRequestSender: MockProxy<IRequestSender> = mock<IRequestSender>();
+    private mockedRequest: MockProxy<SuperAgentRequest> = mock<SuperAgentRequest>();
+    private mockedSuperAgentRequestFactory: MockProxy<ISuperAgentRequestFactory> = mock<ISuperAgentRequestFactory>();
+    private mockedBaseUrl = "SomeBaseUrl";
+
+    public before() {
+        this.mockedSuperAgentRequestFactory.get.mockReturnValue(this.mockedRequest);
+        this.mockedSuperAgentRequestFactory.post.mockReturnValue(this.mockedRequest);
+
+        this.auditorCampaignManagementAPIClient = new AuditorCampaignManagementAPIClient(this.mockedBaseUrl);
+    }
+
+    @test()
+    public async getCampaignAuditorData__CorrectlyCalled() {
+        const receivedAuditorData = [
+            {
+                "id": 17428964,
+                "auditTime": "2023-00-00 13:55:09",
+                "operation": "update",
+                "entityID": 1,
+                "entityType": "campaign",
+                "username": "Jens Testing",
+                "isUserAction": true,
+                "data": "{\"geo\":[{\"s\":10000,\"o\":10000,\"c\":{\"sp\":1000,\"lp\":2000,\"p\":3000,\"b\":4000}},{\"s\":10000,\"o\":10000,\"c\":{\"sp\":1000,\"lp\":2000,\"p\":3000,\"b\":4000}},{\"s\":10000,\"o\":10000,\"c\":{\"sp\":1000,\"lp\":2000,\"p\":3000,\"b\":4000}}],\"pricing\":{\"s\":{\"100\":1000,\"200\":2000,\"300\":3000,\"400\":3000,\"500\":3000},\"o\":{\"100\":1000,\"200\":2000,\"300\":3000,\"400\":3000,\"500\":3000}},\"cpm\":{\"s\":{\"p\":1000,\"b\":2000},\"o\":{\"p\":1000,\"b\":2000}}}"
+            },
+            {
+                "id": 17428967,
+                "auditTime": "2023-00-00 14:55:54",
+                "operation": "update",
+                "entityID": 1,
+                "entityType": "campaign",
+                "username": "Jens Testing",
+                "isUserAction": true,
+                "data": "{\"geo\":[{\"s\":10000,\"o\":10000,\"c\":{\"sp\":1000,\"lp\":2000,\"p\":3000,\"b\":4000}},{\"s\":10000,\"o\":10000,\"c\":{\"sp\":1000,\"lp\":2000,\"p\":3000,\"b\":4000}},{\"s\":10000,\"o\":10000,\"c\":{\"sp\":1000,\"lp\":2000,\"p\":3000,\"b\":4000}}],\"pricing\":{\"s\":{\"100\":1000,\"200\":2000,\"300\":3000,\"400\":3000,\"500\":3000},\"o\":{\"100\":1000,\"200\":2000,\"300\":3000,\"400\":3000,\"500\":3000}},\"cpm\":{\"s\":{\"p\":1000,\"b\":2000},\"o\":{\"p\":1000,\"b\":2000}}}"
+            }
+        ];
+        this.mockedRequestSender.sendAndExtractBody.mockResolvedValue(receivedAuditorData);
+
+        const campaignID = 1;
+        superagentMock.get(`${this.mockedBaseUrl}/auditor/campaigns/${campaignID}`, () => {
+            return {
+                body: receivedAuditorData
+            }
+        });
+
+        const result = await this.auditorCampaignManagementAPIClient.getCampaignAuditorData(campaignID);
+
+        assert.equal(result[0].id, receivedAuditorData[0].id);
+        assert.equal(result[1].id, receivedAuditorData[1].id);
+    }
+
+    @test()
+    public async storeCampaignAuditorData__CorrectlyCalled() {
+        const sendData = {
+            "operation": "update",
+            "entityID": 1,
+            "username": "SomeName",
+            "isUserAction": true,
+            "data": {"some":"data"}
+        };
+
+        const id = 17428967;
+        const receivedData = {
+            "id": id,
+            "auditTime": "2023-00-00 14:55:54",
+            "operation": "update",
+            "entityID": 1,
+            "entityType": "campaign",
+            "username": "Jens Testing",
+            "isUserAction": true,
+            "data": "{\"geo\":[{\"s\":10000,\"o\":10000,\"c\":{\"sp\":1000,\"lp\":2000,\"p\":3000,\"b\":4000}},{\"s\":10000,\"o\":10000,\"c\":{\"sp\":1000,\"lp\":2000,\"p\":3000,\"b\":4000}},{\"s\":10000,\"o\":10000,\"c\":{\"sp\":1000,\"lp\":2000,\"p\":3000,\"b\":4000}}],\"pricing\":{\"s\":{\"100\":1000,\"200\":2000,\"300\":3000,\"400\":3000,\"500\":3000},\"o\":{\"100\":1000,\"200\":2000,\"300\":3000,\"400\":3000,\"500\":3000}},\"cpm\":{\"s\":{\"p\":1000,\"b\":2000},\"o\":{\"p\":1000,\"b\":2000}}}"
+        }
+
+        superagentMock.post(`${this.mockedBaseUrl}/auditor/campaigns`, () => {
+            return {
+                body: receivedData
+            }
+        });
+
+        const result = await this.auditorCampaignManagementAPIClient.storeCampaignAuditorData(AuditorOperation.UPDATE, sendData.entityID, sendData.username, sendData.isUserAction, sendData.data);
+
+        assert.equal(result.id, id);
+    }
+}

package/tests-u/domain/auditor/enums/auditor-entity-type-enum.test.ts

@@ -0,0 +1,22 @@
+import { suite, test } from "@testdeck/jest";
+import { assert } from "chai";
+import { AuditorEntityType } from "../../../../src/domain/auditor/enums/auditor-entity-type.enum";
+
+@suite
+class AuditorEntityTypeEnumTest {
+    @test()
+    public hasEnumValues_ExpectedValues_Successful() {
+        const auditorEntityKeys = this.getAllEntityKeys();
+
+        assert.isTrue(auditorEntityKeys.length === 1);
+        
+        assert.isTrue(AuditorEntityType.CAMPAIGN === "campaign");
+    }
+
+
+    private getAllEntityKeys(): string[] {
+        return [
+            "CAMPAIGN"
+        ]
+    }
+}

package/tests-u/domain/auditor/enums/auditor-operation-enum.test.ts

@@ -0,0 +1,34 @@
+import { suite, test } from "@testdeck/jest";
+import { assert } from "chai";
+import { AuditorOperation } from "../../../../src/domain/auditor/enums/auditor-operation.enum";
+
+@suite
+class AuditorOperationEnumTest {
+    @test()
+    public hasEnumValues_ExpectedValues_Successful() {
+        const auditorEntityKeys = this.getAllEntityKeys();
+
+        assert.isTrue(auditorEntityKeys.length === 7);
+        
+        assert.isTrue(AuditorOperation.CLEANUP === "cleanup");
+        assert.isTrue(AuditorOperation.UPDATE === "update");
+        assert.isTrue(AuditorOperation.CREATE === "create");
+        assert.isTrue(AuditorOperation.LINK === "link");
+        assert.isTrue(AuditorOperation.UNLINK === "unlink");
+        assert.isTrue(AuditorOperation.DELETE === "delete");
+        assert.isTrue(AuditorOperation.ENDOR === "endor");
+    }
+
+
+    private getAllEntityKeys(): string[] {
+        return [
+            "CLEANUP",
+            "UPDATE",
+            "CREATE",
+            "LINK",
+            "UNLINK",
+            "DELETE",
+            "ENDOR"
+        ]
+    }
+}

package/tests-u/domain/auditor/get-auditor-entity.test.ts

@@ -0,0 +1,34 @@
+import { UTCDateTime } from "@studyportals/mb-platform-date-time";
+import { suite, test } from "@testdeck/jest";
+import { assert } from "chai";
+import { AuditorEntityType } from "../../../src/domain/auditor/enums/auditor-entity-type.enum";
+import { AuditorOperation } from "../../../src/domain/auditor/enums/auditor-operation.enum";
+import { GetAuditorDto } from "../../../src/domain/auditor/get-auditor.dto";
+
+@suite
+class GetAuditorEntityTest {
+    @test()
+    public hasEnumValues_ExpectedValues_Successful() {
+        const id = 1;
+        const auditTime = UTCDateTime.now().toString();
+        const operation = AuditorOperation.CREATE;
+        const entityID = 2;
+        const entityType = AuditorEntityType.CAMPAIGN;
+        const username = "SomeUser";
+        const isUserAction = true;
+        const data = {
+            "SomeDataKey": "SomeDataValue"
+        };
+
+        const getAuditorEntity = new GetAuditorDto(id, auditTime, operation, entityID, entityType, username, isUserAction, data);
+
+        assert.equal(getAuditorEntity.id, id);
+        assert.equal(getAuditorEntity.auditTime, auditTime);
+        assert.equal(getAuditorEntity.operation, operation);
+        assert.equal(getAuditorEntity.entityID, entityID);
+        assert.equal(getAuditorEntity.entityType, entityType);
+        assert.equal(getAuditorEntity.username, username);
+        assert.equal(getAuditorEntity.isUserAction, isUserAction);
+        assert.equal(getAuditorEntity.data, data);
+    }
+}