Update unit tests

ocket8888 · Jan 23, 2024 · 3dbd650 · 3dbd650
1 parent 2e11cca
commit 3dbd650
Show file tree

Hide file tree

Showing 5 changed files with 198 additions and 8 deletions.
diff --git a/experimental/traffic-portal/src/app/api/server.service.spec.ts b/experimental/traffic-portal/src/app/api/server.service.spec.ts
@@ -14,7 +14,7 @@
  */
 import { HttpClientTestingModule, HttpTestingController } from "@angular/common/http/testing";
 import { TestBed } from "@angular/core/testing";
-import { type ResponseServer } from "trafficops-types";
+import { ResponseServerCapability, type ResponseServer } from "trafficops-types";
 
 import { ServerService } from "./server.service";
 
@@ -154,7 +154,15 @@ describe("ServerService", () => {
 			await expectAsync(resp).toBeResolvedTo(server);
 		});
 
-		it("delete a server", async ()  => {
+		it("throws an error for invalid call signatures to updateServer", async () => {
+			const responseP = (service as unknown as {updateServer: (id: number) => Promise<ResponseServer>}).updateServer(
+				server.id
+			);
+			httpTestingController.expectNone({method: "PUT"});
+			await expectAsync(responseP).toBeRejected();
+		});
+
+		it("deletes a server", async ()  => {
 			const resp = service.deleteServer(server);
 			const req = httpTestingController.expectOne(`/api/${service.apiVersion}/servers/${server.id}`);
 			expect(req.request.method).toBe("DELETE");
@@ -164,7 +172,7 @@ describe("ServerService", () => {
 			await expectAsync(resp).toBeResolvedTo(server);
 		});
 
-		it("delete a server by ID", async ()  => {
+		it("deletes a server by ID", async ()  => {
 			const resp = service.deleteServer(server.id);
 			const req = httpTestingController.expectOne(`/api/${service.apiVersion}/servers/${server.id}`);
 			expect(req.request.method).toBe("DELETE");
@@ -264,6 +272,77 @@ describe("ServerService", () => {
 		});
 	});
 
+	describe("Capability-related methods", () => {
+		const capability: ResponseServerCapability = {
+			lastUpdated: new Date(),
+			name: "testquest",
+		};
+
+		it("sends requests for multiple capabilities", async () => {
+			const responseP = service.getCapabilities();
+			const req = httpTestingController.expectOne(`/api/${service.apiVersion}/server_capabilities`);
+			expect(req.request.method).toBe("GET");
+			req.flush({response: [capability]});
+			await expectAsync(responseP).toBeResolvedTo([capability]);
+		});
+		it("sends requests for a single capability by name", async () => {
+			const responseP = service.getCapabilities(capability.name);
+			const req = httpTestingController.expectOne(r => r.url === `/api/${service.apiVersion}/server_capabilities`);
+			expect(req.request.params.keys().length).toBe(1);
+			expect(req.request.params.get("name")).toBe(capability.name);
+			expect(req.request.method).toBe("GET");
+			req.flush({response: [capability]});
+			await expectAsync(responseP).toBeResolvedTo(capability);
+		});
+		it("throws an error when fetching a non-existent capability", async () => {
+			const responseP = service.getCapabilities(capability.name);
+			const req = httpTestingController.expectOne(r => r.url === `/api/${service.apiVersion}/server_capabilities`);
+			expect(req.request.params.keys().length).toBe(1);
+			expect(req.request.params.get("name")).toBe(capability.name);
+			expect(req.request.method).toBe("GET");
+			req.flush({response: []});
+			await expectAsync(responseP).toBeRejected();
+		});
+		it("creates a new capability", async () => {
+			const responseP = service.createCapability(capability);
+			const req = httpTestingController.expectOne(`/api/${service.apiVersion}/server_capabilities`);
+			expect(req.request.method).toBe("POST");
+			expect(req.request.body).toEqual(capability);
+			req.flush({response: capability});
+			await expectAsync(responseP).toBeResolvedTo(capability);
+		});
+		it("updates an existing capability", async () => {
+			const responseP = service.updateCapability(capability.name, capability);
+			const req = httpTestingController.expectOne(r => r.url === `/api/${service.apiVersion}/server_capabilities`);
+			expect(req.request.method).toBe("PUT");
+			expect(req.request.params.keys().length).toBe(1);
+			expect(req.request.params.get("name")).toBe(capability.name);
+			expect(req.request.body).toEqual(capability);
+			req.flush({response: capability});
+			await expectAsync(responseP).toBeResolvedTo(capability);
+		});
+		it("deletes server_capabilities", async () => {
+			const responseP = service.deleteCapability(capability);
+			const req = httpTestingController.expectOne(r => r.url === `/api/${service.apiVersion}/server_capabilities`);
+			expect(req.request.method).toBe("DELETE");
+			expect(req.request.params.keys().length).toBe(1);
+			expect(req.request.params.get("name")).toBe(capability.name);
+			expect(req.request.body).toBeNull();
+			req.flush({alerts: []});
+			await expectAsync(responseP).toBeResolved();
+		});
+		it("deletes server_capabilities by name", async () => {
+			const responseP = service.deleteCapability(capability.name);
+			const req = httpTestingController.expectOne(r => r.url === `/api/${service.apiVersion}/server_capabilities`);
+			expect(req.request.method).toBe("DELETE");
+			expect(req.request.params.keys().length).toBe(1);
+			expect(req.request.params.get("name")).toBe(capability.name);
+			expect(req.request.body).toBeNull();
+			req.flush({alerts: []});
+			await expectAsync(responseP).toBeResolved();
+		});
+	});
+
 	describe("other methods", () => {
 		const serverCheck = {
 			adminState: "ONLINE",
@@ -312,6 +391,42 @@ describe("ServerService", () => {
 			req.flush({response});
 			await expectAsync(responseP).toBeResolvedTo(response);
 		});
+		it("queues revalidations on a server", async () => {
+			const responseP = service.queueReval(server);
+			const req = httpTestingController.expectOne(r => r.url === `/api/${service.apiVersion}/servers/${server.id}/update`);
+			expect(req.request.method).toBe("POST");
+			expect(req.request.params.get("reval_updated")).toBe("true");
+			expect(req.request.body).toBeNull();
+			req.flush({alerts: []});
+			await expectAsync(responseP).toBeResolved();
+		});
+		it("queues revalidations on a server by ID", async () => {
+			const responseP = service.queueReval(server.id);
+			const req = httpTestingController.expectOne(r => r.url === `/api/${service.apiVersion}/servers/${server.id}/update`);
+			expect(req.request.method).toBe("POST");
+			expect(req.request.params.get("reval_updated")).toBe("true");
+			expect(req.request.body).toBeNull();
+			req.flush({alerts: []});
+			await expectAsync(responseP).toBeResolved();
+		});
+		it("de-queues revalidations on a server", async () => {
+			const responseP = service.clearReval(server);
+			const req = httpTestingController.expectOne(r => r.url === `/api/${service.apiVersion}/servers/${server.id}/update`);
+			expect(req.request.method).toBe("POST");
+			expect(req.request.params.get("reval_updated")).toBe("false");
+			expect(req.request.body).toBeNull();
+			req.flush({alerts: []});
+			await expectAsync(responseP).toBeResolved();
+		});
+		it("de-queues revalidations on a server by ID", async () => {
+			const responseP = service.clearReval(server.id);
+			const req = httpTestingController.expectOne(r => r.url === `/api/${service.apiVersion}/servers/${server.id}/update`);
+			expect(req.request.method).toBe("POST");
+			expect(req.request.params.get("reval_updated")).toBe("false");
+			expect(req.request.body).toBeNull();
+			req.flush({alerts: []});
+			await expectAsync(responseP).toBeResolved();
+		});
 		it("sends a request for multiple Serverchecks", async () => {
 			const responseP = service.getServerChecks();
 			const req = httpTestingController.expectOne(`/api/${service.apiVersion}/servercheck`);

diff --git a/experimental/traffic-portal/src/app/api/server.service.ts b/experimental/traffic-portal/src/app/api/server.service.ts
@@ -225,7 +225,7 @@ export class ServerService extends APIService {
 	 * @returns The 'response' property of the TO server's response. See TO API
 	 * docs.
 	 */
-	public async queueReval(server: number | ResponseServer): Promise<ServerQueueResponse> {
+	public async queueReval(server: number | ResponseServer): Promise<void> {
 		const id = typeof(server) === "number" ? server : server.id;
 		const params = {
 			// This param casing is in the API specification, so it must have
@@ -235,7 +235,7 @@ export class ServerService extends APIService {
 			// TODO: This is really confusing; `reval_updated = true` means that
 			// revalidations **haven't** been updated, and need to be done.
 		};
-		return this.post<ServerQueueResponse>(`servers/${id}/update`, undefined, params).toPromise();
+		return this.post(`servers/${id}/update`, undefined, params).toPromise();
 	}
 
 	/**
@@ -246,7 +246,7 @@ export class ServerService extends APIService {
 	 * @returns The 'response' property of the TO server's response. See TO API
 	 * docs.
 	 */
-	public async clearReval(server: number | ResponseServer): Promise<ServerQueueResponse> {
+	public async clearReval(server: number | ResponseServer): Promise<void> {
 		const id = typeof(server) === "number" ? server : server.id;
 		const params = {
 			// This param casing is in the API specification, so it must have
@@ -257,7 +257,7 @@ export class ServerService extends APIService {
 			// that revalidations **have** been updated, and no longer need to
 			// be done.
 		};
-		return this.post<ServerQueueResponse>(`servers/${id}/update`, undefined, params).toPromise();
+		return this.post(`servers/${id}/update`, undefined, params).toPromise();
 	}
 
 	/**

diff --git a/experimental/traffic-portal/src/app/api/testing/server.service.ts b/experimental/traffic-portal/src/app/api/testing/server.service.ts
@@ -310,6 +310,42 @@ export class ServerService {
 		return {action: "dequeue", serverId: id};
 	}
 
+	/**
+	 * Queues revalidations on a single server.
+	 *
+	 * @param server Either the server on which revalidations will be queued, or
+	 * its integral, unique identifier.
+	 * @returns The 'response' property of the TO server's response. See TO API
+	 * docs.
+	 */
+	public async queueReval(server: number | ResponseServer): Promise<void> {
+		const id = typeof(server) === "number" ? server : server.id;
+		const srv = this.servers.find(s=>s.id===id);
+		if (!srv) {
+			throw new Error(`no such Server: #${id}`);
+		}
+
+		srv.revalPending = true;
+	}
+
+	/**
+	 * Clears pending revalidations on a single server.
+	 *
+	 * @param server Either the server for which pending revalidations will be
+	 * cleared, or its integral, unique identifier.
+	 * @returns The 'response' property of the TO server's response. See TO API
+	 * docs.
+	 */
+	public async clearReval(server: number | ResponseServer): Promise<void> {
+		const id = typeof(server) === "number" ? server : server.id;
+		const srv = this.servers.find(s=>s.id===id);
+		if (!srv) {
+			throw new Error(`no such Server: #${id}`);
+		}
+
+		srv.revalPending = false;
+	}
+
 	/**
 	 * Updates a server's status.
 	 *

diff --git a/...imental/traffic-portal/src/app/core/servers/servers-table/servers-table.component.spec.ts b/...imental/traffic-portal/src/app/core/servers/servers-table/servers-table.component.spec.ts
@@ -274,22 +274,61 @@ describe("ServersTableComponent", () => {
 		const service = TestBed.inject(ServerService);
 		const queueSpy = spyOn(service, "queueUpdates");
 		const clearSpy = spyOn(service, "clearUpdates");
+		const revalSpy = spyOn(service, "queueReval");
+		const clearRevalSpy = spyOn(service, "clearReval");
+
 		expect(queueSpy).not.toHaveBeenCalled();
 		expect(clearSpy).not.toHaveBeenCalled();
+		expect(revalSpy).not.toHaveBeenCalled();
+		expect(clearRevalSpy).not.toHaveBeenCalled();
 
 		component.handleContextMenu({action: "queue", data: server});
 		expect(queueSpy).toHaveBeenCalledTimes(1);
 		expect(clearSpy).not.toHaveBeenCalled();
+		expect(revalSpy).not.toHaveBeenCalled();
+		expect(clearRevalSpy).not.toHaveBeenCalled();
 
 		component.handleContextMenu({action: "queue", data: [server, server]});
 		expect(queueSpy).toHaveBeenCalledTimes(3);
+		expect(clearSpy).not.toHaveBeenCalled();
+		expect(revalSpy).not.toHaveBeenCalled();
+		expect(clearRevalSpy).not.toHaveBeenCalled();
 
 		component.handleContextMenu({action: "dequeue", data: server});
 		expect(queueSpy).toHaveBeenCalledTimes(3);
 		expect(clearSpy).toHaveBeenCalledTimes(1);
+		expect(revalSpy).not.toHaveBeenCalled();
+		expect(clearRevalSpy).not.toHaveBeenCalled();
 
 		component.handleContextMenu({action: "dequeue", data: [server, server]});
+		expect(queueSpy).toHaveBeenCalledTimes(3);
+		expect(clearSpy).toHaveBeenCalledTimes(3);
+		expect(revalSpy).not.toHaveBeenCalled();
+		expect(clearRevalSpy).not.toHaveBeenCalled();
+
+		component.handleContextMenu({action: "reval", data: server});
+		expect(queueSpy).toHaveBeenCalledTimes(3);
+		expect(clearSpy).toHaveBeenCalledTimes(3);
+		expect(revalSpy).toHaveBeenCalledTimes(1);
+		expect(clearRevalSpy).not.toHaveBeenCalled();
+
+		component.handleContextMenu({action: "reval", data: [server, server]});
+		expect(queueSpy).toHaveBeenCalledTimes(3);
+		expect(clearSpy).toHaveBeenCalledTimes(3);
+		expect(revalSpy).toHaveBeenCalledTimes(3);
+		expect(clearRevalSpy).not.toHaveBeenCalled();
+
+		component.handleContextMenu({action: "unreval", data: server});
+		expect(queueSpy).toHaveBeenCalledTimes(3);
+		expect(clearSpy).toHaveBeenCalledTimes(3);
+		expect(revalSpy).toHaveBeenCalledTimes(3);
+		expect(clearRevalSpy).toHaveBeenCalledTimes(1);
+
+		component.handleContextMenu({action: "unreval", data: [server, server]});
+		expect(queueSpy).toHaveBeenCalledTimes(3);
 		expect(clearSpy).toHaveBeenCalledTimes(3);
+		expect(revalSpy).toHaveBeenCalledTimes(3);
+		expect(clearRevalSpy).toHaveBeenCalledTimes(3);
 
 		expectAsync(component.handleContextMenu({action: "not a real action", data: []})).toBeRejected();
 	}));

diff --git a/experimental/traffic-portal/src/app/core/servers/servers-table/servers-table.component.ts b/experimental/traffic-portal/src/app/core/servers/servers-table/servers-table.component.ts
@@ -416,7 +416,7 @@ export class ServersTableComponent implements OnInit {
 				);
 				const result = await ref.afterClosed().toPromise();
 				if (typeof(result) === "number") {
-					if (data.title.indexOf("Clear") > -1) {
+					if (data.title.includes("Clear")) {
 						await this.cdn.dequeueServerUpdates(result);
 					} else {
 						await this.cdn.queueServerUpdates(result);