Remove unnecessary comments

Author: technocidal

packages/testcontainers/src/generic-container/inspect-container-util-ports-exposed.test.ts

@@ -118,7 +118,6 @@ test("handles multiple ports with different protocols", async () => {
 });
 
 test("fails when protocol doesn't match exposed port", async () => {
-  // Container exposes TCP port but we're looking for UDP
   const data = mockInspectResult({ "8080/tcp": [{ HostIp: "0.0.0.0", HostPort: "45000" }] });
   const inspectFn = vi.fn().mockResolvedValue(data.inspectResult);
 
@@ -135,7 +134,6 @@ test("ignores ports with wrong protocol", async () => {
   const data = mockInspectResult(ports);
   const inspectFn = vi.fn().mockResolvedValueOnce(data.inspectResult);
 
-  // Should only match the UDP port
   const result = await inspectContainerUntilPortsExposed(inspectFn, ["8080/udp"], "container-id");
 
   expect(result).toEqual(data);
@@ -152,25 +150,16 @@ test("handles mixed protocol specifications in different formats", async () => {
 
   const result = await inspectContainerUntilPortsExposed(
     inspectFn,
-    [
-      8080, // number (default tcp)
-      "9090/udp", // string with protocol
-      { container: 7070, host: 47000 }, // object (default tcp)
-    ],
+    [8080, "9090/udp", { container: 7070, host: 47000 }],
     "container-id"
   );
 
   expect(result).toEqual(data);
 });
 
 test("retry with gradually exposed ports of different protocols", async () => {
-  // First call: No ports exposed
   const data1 = mockInspectResult({});
-
-  // Second call: Only TCP port exposed
   const data2 = mockInspectResult({ "8080/tcp": [{ HostIp: "0.0.0.0", HostPort: "45000" }] });
-
-  // Third call: Both TCP and UDP ports exposed
   const data3 = mockInspectResult({
     "8080/tcp": [{ HostIp: "0.0.0.0", HostPort: "45000" }],
     "8080/udp": [{ HostIp: "0.0.0.0", HostPort: "46000" }],
@@ -182,11 +171,7 @@ test("retry with gradually exposed ports of different protocols", async () => {
     .mockResolvedValueOnce(data2.inspectResult)
     .mockResolvedValueOnce(data3.inspectResult);
 
-  const result = await inspectContainerUntilPortsExposed(
-    inspectFn,
-    [8080, "8080/udp"], // Need both TCP and UDP ports
-    "container-id"
-  );
+  const result = await inspectContainerUntilPortsExposed(inspectFn, [8080, "8080/udp"], "container-id");
 
   expect(result).toEqual(data3);
   expect(inspectFn).toHaveBeenCalledTimes(3);

packages/testcontainers/src/utils/bound-ports.test.ts

@@ -15,9 +15,7 @@ describe("BoundPorts", () => {
     boundPorts.setBinding(1, 1000, "tcp");
     boundPorts.setBinding(1, 2000, "udp");
 
-    // Default protocol is tcp
     expect(boundPorts.getBinding(1)).toBe(1000);
-    // Can explicitly specify protocol
     expect(boundPorts.getBinding(1, "tcp")).toBe(1000);
     expect(boundPorts.getBinding(1, "udp")).toBe(2000);
   });
@@ -29,7 +27,6 @@ describe("BoundPorts", () => {
 
     expect(boundPorts.getBinding("8080/tcp")).toBe(1000);
     expect(boundPorts.getBinding("8080/udp")).toBe(2000);
-    // Can also specify as number + protocol
     expect(boundPorts.getBinding(8080, "tcp")).toBe(1000);
     expect(boundPorts.getBinding(8080, "udp")).toBe(2000);
   });
@@ -79,10 +76,8 @@ describe("BoundPorts", () => {
 
       const boundPorts = BoundPorts.fromInspectResult(hostIps, inspectResult as InspectResult);
 
-      // Default to TCP
       expect(boundPorts.getBinding(8080)).toBe(10000);
       expect(boundPorts.getBinding(8081)).toBe(10001);
-      // Explicitly specify protocol
       expect(boundPorts.getBinding(8080, "tcp")).toBe(10000);
       expect(boundPorts.getBinding(8080, "udp")).toBe(10002);
     });
@@ -104,30 +99,21 @@ describe("BoundPorts", () => {
       boundPorts.setBinding(8080, 2000, "udp");
       boundPorts.setBinding(9090, 3000, "tcp");
 
-      // Create a simplified filter test
-      let filtered = boundPorts.filter([8080]); // Just filter TCP port
-
-      // Should only include the TCP binding
+      let filtered = boundPorts.filter([8080]);
       expect(filtered.getBinding(8080)).toBe(1000);
       expect(() => filtered.getBinding(8080, "udp")).toThrowError("No port binding found for :8080/udp");
       expect(() => filtered.getBinding(9090)).toThrowError("No port binding found for :9090/tcp");
 
-      // Now filter only the UDP port
       filtered = boundPorts.filter(["8080/udp"]);
-
-      // Should only include the UDP binding
       expect(filtered.getBinding(8080, "udp")).toBe(2000);
       expect(() => filtered.getBinding(8080, "tcp")).toThrowError("No port binding found for :8080/tcp");
     });
 
     it("should handle case-insensitive protocols", () => {
       const boundPorts = new BoundPorts();
       boundPorts.setBinding(8080, 1000, "tcp");
-
-      // Should be able to retrieve with uppercase protocol
       expect(boundPorts.getBinding(8080, "TCP")).toBe(1000);
 
-      // Also works with uppercase in the key
       boundPorts.setBinding("9090/TCP", 2000);
       expect(boundPorts.getBinding(9090, "tcp")).toBe(2000);
       expect(boundPorts.getBinding("9090/tcp")).toBe(2000);

packages/testcontainers/src/utils/bound-ports.ts

@@ -10,8 +10,6 @@ export class BoundPorts {
     const normalizedProtocol = protocol.toLowerCase();
     const key = typeof port === "string" ? port : `${port}/${normalizedProtocol}`;
     let binding = this.ports.get(key);
-
-    // Try case-insensitive lookup if not found and port is a string that might contain a protocol
     if (!binding && typeof port === "string" && port.includes("/")) {
       const [portNumber, portProtocol] = port.split("/");
       const normalizedKey = `${portNumber}/${portProtocol.toLowerCase()}`;
@@ -36,16 +34,13 @@ export class BoundPorts {
   }
 
   public setBinding(key: string | number, value: number, protocol: string = "tcp"): void {
-    // Normalize protocol to lowercase for consistency
     const normalizedProtocol = protocol.toLowerCase();
 
     if (typeof key === "string" && key.includes("/")) {
-      // If key contains protocol, normalize it
       const [portNumber, portProtocol] = key.split("/");
       const normalizedKey = `${portNumber}/${portProtocol.toLowerCase()}`;
       this.ports.set(normalizedKey, value);
     } else {
-      // Otherwise use the provided key/protocol
       const portKey = typeof key === "string" ? key : `${key}/${normalizedProtocol}`;
       this.ports.set(portKey, value);
     }
@@ -57,8 +52,6 @@ export class BoundPorts {
 
   public filter(ports: PortWithOptionalBinding[]): BoundPorts {
     const boundPorts = new BoundPorts();
-
-    // Create map of port to protocol for lookup
     const containerPortsWithProtocol = new Map<number, string>();
     ports.forEach((port) => {
       const containerPort = getContainerPort(port);
@@ -69,8 +62,6 @@ export class BoundPorts {
     for (const [internalPortWithProtocol, hostPort] of this.iterator()) {
       const [internalPortStr, protocol] = internalPortWithProtocol.split("/");
       const internalPort = parseInt(internalPortStr, 10);
-
-      // Case-insensitive protocol comparison
       if (
         containerPortsWithProtocol.has(internalPort) &&
         containerPortsWithProtocol.get(internalPort)?.toLowerCase() === protocol?.toLowerCase()

packages/testcontainers/src/utils/port.test.ts

@@ -67,16 +67,14 @@ describe("port utilities", () => {
     });
 
     test("maintains backward compatibility", () => {
-      // Original usage patterns should still work
-      expect(getProtocol(8080)).toBe("tcp"); // Number defaults to TCP
-      expect(getProtocol("8080")).toBe("tcp"); // Simple string defaults to TCP
-      expect(getProtocol({ container: 8080, host: 49000 })).toBe("tcp"); // Object without protocol defaults to TCP
+      expect(getProtocol(8080)).toBe("tcp");
+      expect(getProtocol("8080")).toBe("tcp");
+      expect(getProtocol({ container: 8080, host: 49000 })).toBe("tcp");
     });
 
     test("supports protocol specification in all formats", () => {
-      // New usage patterns with protocols
-      expect(getProtocol("8080/udp")).toBe("udp"); // String with protocol
-      expect(getProtocol({ container: 8080, host: 49000, protocol: "udp" })).toBe("udp"); // Object with protocol
+      expect(getProtocol("8080/udp")).toBe("udp");
+      expect(getProtocol({ container: 8080, host: 49000, protocol: "udp" })).toBe("udp");
     });
 
     test("note about UDP port checks", () => {

packages/testcontainers/src/wait-strategies/utils/port-check.test.ts

@@ -31,8 +31,6 @@ describe.sequential("PortCheck", () => {
       // @ts-ignore
       client = new ContainerRuntimeClient();
       portCheck = new InternalPortCheck(client, mockContainer);
-
-      // Make sure logging is enabled to capture all logs
       mockLogger.enabled.mockImplementation(() => true);
     });
 

packages/testcontainers/src/wait-strategies/utils/port-check.ts

@@ -11,7 +11,6 @@ export class HostPortCheck implements PortCheck {
   constructor(private readonly client: ContainerRuntimeClient) {}
 
   public isBound(port: number | string): Promise<boolean> {
-    // Skip check for UDP ports as they can't be verified with a TCP socket connection
     if (typeof port === "string" && port.toLowerCase().includes("/udp")) {
       log.debug(`Skipping host port check for UDP port ${port} (UDP port checks not supported)`);
       return Promise.resolve(true);
@@ -48,7 +47,6 @@ export class InternalPortCheck implements PortCheck {
   ) {}
 
   public async isBound(port: number | string): Promise<boolean> {
-    // Skip check for UDP ports as they require different verification methods
     if (typeof port === "string" && port.toLowerCase().includes("/udp")) {
       log.debug(`Skipping internal port check for UDP port ${port} (UDP port checks not supported)`, {
         containerId: this.container.id,