laplace-api 4.0.0 → 4.1.0

package/src/test/live-price.test.ts

@@ -1,18 +1,14 @@
 import { Logger } from "winston";
 import { LaplaceConfiguration } from "../utilities/configuration";
 import "./client_test_suite";
-import { LivePriceClient } from "../client/live-price";
-import {
-  BISTStockLiveData,
-  LivePriceFeed,
-  LivePriceWebSocketClient,
-  USStockLiveData,
-} from "../client/live-price-web-socket";
+import { BISTStockStreamData, LivePriceClient, OrderbookLiveData } from "../client/live-price";
 
 describe("LivePrice", () => {
-  let livePriceUrlClient: LivePriceClient;
-  let url: string;
-  let ws: LivePriceWebSocketClient;
+  let client: LivePriceClient;
+  let config: LaplaceConfiguration;
+  let logger: Logger;
+  let activeConnections: any[] = [];
+  let activeTimeouts: NodeJS.Timeout[] = [];
 
   const TEST_CONSTANTS = {
     JEST_TIMEOUT: 15000,
@@ -20,95 +16,460 @@ describe("LivePrice", () => {
   };
 
   beforeAll(async () => {
-    const config = (global as any).testSuite.config as LaplaceConfiguration;
-    const logger: Logger = {
+    config = (global as any).testSuite.config as LaplaceConfiguration;
+    logger = {
       info: jest.fn(),
       error: jest.fn(),
       warn: jest.fn(),
       debug: jest.fn(),
     } as unknown as Logger;
 
-    livePriceUrlClient = new LivePriceClient(config, logger);
-    url = await livePriceUrlClient.getWebSocketUrl("2459", [
-      LivePriceFeed.LiveBist,
-    ]);
+    client = new LivePriceClient(config, logger);
+  });
 
-    ws = new LivePriceWebSocketClient({
-      enableLogging: true,
-    });
+  afterEach(async () => {
+    // Clear all active timeouts
+    for (const timeout of activeTimeouts) {
+      clearTimeout(timeout);
+    }
+    activeTimeouts = [];
 
-    await ws.connect(url);
+    // Clean up all active connections
+    for (const connection of activeConnections) {
+      try {
+        connection.close();
+      } catch (error) {
+        console.log("Error closing connection:", error);
+      }
+    }
+    activeConnections = [];
   });
 
   afterAll(async () => {
-    try {
-      await ws.close();
-    } catch (error) {
-      console.error("Error closing websocket connection", error);
+    // Final cleanup
+    for (const timeout of activeTimeouts) {
+      clearTimeout(timeout);
+    }
+    for (const connection of activeConnections) {
+      try {
+        connection.close();
+      } catch (error) {
+        console.log("Error closing connection in afterAll:", error);
+      }
     }
   });
 
-  describe("BIST Live Price Tests", () => {
-    const symbols = ["TUPRS", "SASA", "THYAO", "GARAN", "YKBNK"];
+  describe("GetLivePriceForBIST", () => {
+    it(
+      "should receive BIST live price data",
+      async () => {
+        const symbols = ["AKBNK"];
+        let receivedData: BISTStockStreamData | null = null;
+        let receivedError: Error | null = null;
+
+        const lc = client.getLivePriceForBIST(symbols);
+        activeConnections.push(lc);
+
+        try {
+          const receiveChan = lc.receive();
+
+          // Set a timeout to avoid hanging
+          const timeoutPromise = new Promise<void>((_, reject) => {
+            const timeout = setTimeout(
+              () => reject(new Error("Timeout waiting for data")),
+              TEST_CONSTANTS.MAIN_TIMEOUT
+            );
+            activeTimeouts.push(timeout);
+          });
+
+          const dataPromise = (async () => {
+            try {
+              for await (const data of receiveChan) {
+                receivedData = data;
+                break; // Get first data and exit
+              }
+            } catch (error) {
+              console.log("Error in data stream:", error);
+            }
+          })();
+
+          await Promise.race([dataPromise, timeoutPromise]);
 
+          if (receivedData) {
+            const tempReceivedData = (receivedData as BISTStockStreamData).d;
+            console.log("Received BIST data:", tempReceivedData);
+            expect(tempReceivedData.s).toBeDefined();
+            expect(typeof tempReceivedData.s).toBe("string");
+            expect(typeof tempReceivedData.p).toBe("number");
+            expect(typeof tempReceivedData.ch).toBe("number");
+            expect(typeof tempReceivedData.d).toBe("number");
+          } else {
+            console.log("Timeout waiting for BIST data");
+          }
+        } catch (error) {
+          receivedError = error as Error;
+          console.log("Received error:", receivedError.message);
+        } finally {
+          lc.close();
+        }
+      },
+      TEST_CONSTANTS.JEST_TIMEOUT
+    );
+  });
+
+  describe("GetLivePriceForUS", () => {
     it(
-      "should receive data for initial and updated symbols",
+      "should receive US live price data",
       async () => {
-        const receivedData: BISTStockLiveData[] = [];
-
-        let unsubscribe: (() => void) | null =
-          ws.subscribe<LivePriceFeed.LiveBist>(
-            symbols,
-            LivePriceFeed.LiveBist,
-            (data) => {
-              console.log("RECEIVED DATA", data);
-              receivedData.push(data);
+        const symbols = ["AAPL"];
+        let receivedData: any = null;
+        let receivedError: Error | null = null;
+
+        const lc = client.getLivePriceForUS(symbols);
+        activeConnections.push(lc);
+
+        try {
+          const receiveChan = lc.receive();
+
+          // Set a timeout to avoid hanging
+          const timeoutPromise = new Promise<void>((_, reject) => {
+            const timeout = setTimeout(
+              () => reject(new Error("Timeout waiting for data")),
+              TEST_CONSTANTS.MAIN_TIMEOUT
+            );
+            activeTimeouts.push(timeout);
+          });
+
+          const dataPromise = (async () => {
+            try {
+              for await (const data of receiveChan) {
+                receivedData = data;
+                break; // Get first data and exit
+              }
+            } catch (error) {
+              console.log("Error in data stream:", error);
             }
-          );
+          })();
 
-        await new Promise((resolve) => setTimeout(resolve, TEST_CONSTANTS.MAIN_TIMEOUT));
+          await Promise.race([dataPromise, timeoutPromise]);
 
-        for (const symbol of symbols) {
-          const symbolData = receivedData.filter(
-            (data) => data.symbol === symbol
-          );
-          expect(symbolData.length).toBeGreaterThan(0);
+          if (receivedData) {
+            console.log("Received US data:", receivedData);
+            expect(receivedData.s).toBeDefined();
+            expect(typeof receivedData.s).toBe("string");
+            expect(typeof receivedData.p).toBe("number");
+            expect(typeof receivedData.d).toBe("number");
+          } else {
+            console.log("Timeout waiting for US data");
+          }
+        } catch (error) {
+          receivedError = error as Error;
+          console.log("Received error:", receivedError.message);
+        } finally {
+          lc.close();
         }
+      },
+      TEST_CONSTANTS.JEST_TIMEOUT
+    );
+  });
+
+  describe("LivePriceSubscribe", () => {
+    it(
+      "should handle subscription changes",
+      async () => {
+        const initialSymbols = ["AKBNK"];
+        const newSymbols = ["TUPRS", "ASELS"];
+        const receivedData: string[] = [];
+        let switchOccurred = false;
+
+        const lc = client.getLivePriceForBIST(initialSymbols);
+        activeConnections.push(lc);
+
+        try {
+          const receiveChan = lc.receive();
+
+          // Start receiving data
+          const dataPromise = (async () => {
+            try {
+              for await (const data of receiveChan) {
+                receivedData.push(data.d.s);
+
+                // Switch symbols after 5 seconds
+                if (!switchOccurred && receivedData.length > 0) {
+                  const switchTimeout = setTimeout(async () => {
+                    try {
+                      await lc.subscribe(newSymbols);
+                      receivedData.push("SWITCH");
+                      switchOccurred = true;
+
+                      // Close after another 5 seconds
+                      const closeTimeout = setTimeout(() => {
+                        lc.close();
+                      }, 5000);
+                      activeTimeouts.push(closeTimeout);
+                    } catch (error) {
+                      console.error("Error switching symbols:", error);
+                    }
+                  }, 5000);
+                  activeTimeouts.push(switchTimeout);
+                }
+              }
+            } catch (error) {
+              console.log("Error in subscription test:", error);
+            }
+          })();
 
-        unsubscribe();
+          // Set overall timeout
+          const timeoutPromise = new Promise<void>((_, reject) => {
+            const timeout = setTimeout(
+              () => reject(new Error("Test timeout")),
+              TEST_CONSTANTS.JEST_TIMEOUT
+            );
+            activeTimeouts.push(timeout);
+          });
+
+          await Promise.race([dataPromise, timeoutPromise]);
+
+          // Verify we received data
+          expect(receivedData.length).toBeGreaterThan(0);
+
+          const switchIndex = receivedData.indexOf("SWITCH");
+          if (switchIndex > 0) {
+            const beforeSwitch = receivedData.slice(0, switchIndex);
+            expect(beforeSwitch.some((symbol) => symbol === "AKBNK")).toBe(
+              true
+            );
+          }
+
+          if (switchIndex >= 0 && switchIndex < receivedData.length - 1) {
+            const afterSwitch = receivedData.slice(switchIndex + 1);
+            expect(afterSwitch.some((symbol) => symbol === "TUPRS")).toBe(true);
+            expect(afterSwitch.some((symbol) => symbol === "ASELS")).toBe(true);
+          }
+        } catch (error) {
+          console.log("Test error:", error);
+        } finally {
+          lc.close();
+        }
       },
       TEST_CONSTANTS.JEST_TIMEOUT
     );
   });
 
-  describe("US Live Price Tests", () => {
-    const symbols = ["AAPL"];
+  describe("LivePriceClose", () => {
+    it(
+      "should close connection properly",
+      async () => {
+        const symbols = ["AKBNK"];
+        const lc = client.getLivePriceForBIST(symbols);
+        activeConnections.push(lc);
+
+        try {
+          // Close immediately
+          lc.close();
+
+          // Try to receive data after close
+          const receiveChan = lc.receive();
+          let receivedAfterClose = false;
+
+          try {
+            for await (const data of receiveChan) {
+              receivedAfterClose = true;
+              break;
+            }
+          } catch (error) {
+            // Expected to throw after close
+            console.log("Expected error after close:", error);
+          }
 
+          // Should not receive data after close
+          expect(receivedAfterClose).toBe(false);
+        } catch (error) {
+          console.error("Close test error:", error);
+        }
+      },
+      TEST_CONSTANTS.JEST_TIMEOUT
+    );
+  });
+
+  describe("GetDelayedPriceForBIST", () => {
     it(
-      "should receive data for initial and updated symbols for us",
+      "should receive BIST delayed price data",
       async () => {
-        const receivedData: USStockLiveData[] = [];
-
-        let unsubscribe: (() => void) | null =
-          ws.subscribe<LivePriceFeed.LiveUs>(
-            symbols,
-            LivePriceFeed.LiveUs,
-            (data) => {
-              console.log("RECEIVED DATA FOR US", data);
-              receivedData.push(data);
+        const symbols = ["AKBNK"];
+        let receivedData: BISTStockStreamData | null = null; 
+        let receivedError: Error | null = null;
+
+        const lc = client.getDelayedPriceForBIST(symbols);
+        activeConnections.push(lc);
+
+        try {
+          const receiveChan = lc.receive();
+
+          const timeoutPromise = new Promise<void>((_, reject) => {
+            const timeout = setTimeout(
+              () => reject(new Error("Timeout waiting for delayed data")),
+              TEST_CONSTANTS.MAIN_TIMEOUT
+            );
+            activeTimeouts.push(timeout);
+          });
+
+          const dataPromise = (async () => {
+            try {
+              for await (const data of receiveChan) {
+                receivedData = data;
+                break;
+              }
+            } catch (error) {
+              console.log("Error in delayed data stream:", error);
             }
-          );
+          })();
 
-        await new Promise((resolve) => setTimeout(resolve, TEST_CONSTANTS.MAIN_TIMEOUT));
+          await Promise.race([dataPromise, timeoutPromise]);
 
-        for (const symbol of symbols) {
-          const symbolData = receivedData.filter(
-            (data) => data.symbol === symbol
-          );
-          expect(symbolData.length).toBeGreaterThan(0);
+          if (receivedData != null) {
+            const tempReceivedData = (receivedData as BISTStockStreamData).d;
+            console.log("Received BIST delayed data:", tempReceivedData);
+            expect(tempReceivedData.s).toBeDefined();
+            expect(typeof tempReceivedData.s).toBe("string");
+            expect(typeof tempReceivedData.p).toBe("number");
+            expect(typeof tempReceivedData.ch).toBe("number");
+            expect(typeof tempReceivedData.d).toBe("number");
+          } else {
+            console.log("Timeout waiting for BIST delayed data");
+          }
+        } catch (error) {
+          receivedError = error as Error;
+          console.log("Received delayed error:", receivedError.message);
+        } finally {
+          lc.close();
         }
+      },
+      TEST_CONSTANTS.JEST_TIMEOUT
+    );
+  });
+
+  describe("GetOrderbookForBIST", () => {
+    it(
+      "should receive BIST orderbook data",
+      async () => {
+        const symbols = ["AKBNK"];
+        let receivedData: OrderbookLiveData | null = null;
+        let receivedError: Error | null = null;
+
+        const lc = client.getOrderbookForBIST(symbols);
+        activeConnections.push(lc);
+
+        try {
+          const receiveChan = lc.receive();
+
+          const timeoutPromise = new Promise<void>((_, reject) => {
+            const timeout = setTimeout(
+              () => reject(new Error("Timeout waiting for orderbook data")),
+              TEST_CONSTANTS.MAIN_TIMEOUT
+            );
+            activeTimeouts.push(timeout);
+          });
+
+          const dataPromise = (async () => {
+            try {
+              for await (const data of receiveChan) {
+                console.log(data);
+                receivedData = data;
+                break;
+              }
+            } catch (error) {
+              console.log("Error in orderbook data stream:", error);
+            }
+          })();
+
+          await Promise.race([dataPromise, timeoutPromise]);
 
-        unsubscribe();
+          if (receivedData != null) {
+            const tempReceivedData = receivedData as OrderbookLiveData;
+            console.log("Received BIST orderbook data:", tempReceivedData);
+            expect(tempReceivedData.symbol).toBeDefined();
+            expect(typeof tempReceivedData.symbol).toBe("string");
+
+            if (tempReceivedData.updated != null) {
+              expect(Array.isArray(tempReceivedData.updated)).toBe(true);
+
+              if (tempReceivedData.updated.length > 0) {
+                const firsData = tempReceivedData.updated[0];
+                console.log("updated first data:", firsData)
+                expect(typeof firsData.level).toBe("number");
+                expect(typeof firsData.vol).toBe("number");
+                expect(typeof firsData.orders).toBe("number");
+                expect(typeof firsData.p).toBe("number");
+                expect(typeof firsData.side).toBe("string");
+              }
+            }
+
+            if (tempReceivedData.deleted != null) {
+              expect(Array.isArray(tempReceivedData.deleted)).toBe(true);
+
+              if (tempReceivedData.deleted.length > 0) {
+                const firsData = tempReceivedData.deleted[0];
+                console.log("deleted first data:", firsData)
+                expect(typeof firsData.level).toBe("number");
+                expect(typeof firsData.side).toBe("string");
+              }
+            }
+          } else {
+            console.log("Timeout waiting for BIST orderbook data");
+          }
+        } catch (error) {
+          receivedError = error as Error;
+          console.log("Received orderbook error:", receivedError.message);
+        } finally {
+          lc.close();
+        }
+      },
+      TEST_CONSTANTS.JEST_TIMEOUT
+    );
+  });
+
+  describe("Client Methods", () => {
+    it(
+      "should work with client methods",
+      async () => {
+        const symbols = ["THYAO"];
+        let receivedData: any = null;
+
+        const lc = client.getLivePriceForBIST(symbols);
+        activeConnections.push(lc);
+
+        try {
+          const receiveChan = lc.receive();
+
+          const timeoutPromise = new Promise<void>((_, reject) => {
+            const timeout = setTimeout(
+              () => reject(new Error("Timeout")),
+              TEST_CONSTANTS.MAIN_TIMEOUT
+            );
+            activeTimeouts.push(timeout);
+          });
+
+          const dataPromise = (async () => {
+            try {
+              for await (const data of receiveChan) {
+                receivedData = data;
+                break;
+              }
+            } catch (error) {
+              console.log("Error in client methods test:", error);
+            }
+          })();
+
+          await Promise.race([dataPromise, timeoutPromise]);
+
+          if (receivedData) {
+            expect(receivedData.s).toBeDefined();
+            expect(typeof receivedData.s).toBe("string");
+          }
+        } finally {
+          lc.close();
+        }
       },
       TEST_CONSTANTS.JEST_TIMEOUT
     );