laplace-api 4.7.0 → 5.1.0

package/src/test/funds.test.ts

@@ -5,87 +5,73 @@ import {
   FundsClient,
   FundType,
   HistoricalFundPricePeriod,
-  Fund,
-  FundStats,
-  FundDistribution,
-  FundAssetCategory,
-  FundHistoricalPrice,
-  FundContentType
 } from "../client/funds";
 import { Region } from "../client/collections";
-import { AssetType } from "../client/stocks";
 
-const mockFundsResponse: Fund[] = [
+const mockFundsResponse= [
   {
-    assetType: AssetType.Stock,
-    name: "Ak Portföy BIST 30 Endeksi Hisse Senedi Fonu",
-    symbol: "SPP",
-    active: true,
-    managementFee: 0.003,
-    riskLevel: 6,
-    fundType: FundType.STOCK_UMBRELLA_FUND,
-    ownerSymbol: "AKP"
-  },
-  {
-    assetType: AssetType.Stock,
-    name: "İş Portföy BIST 30 Endeksi Hisse Senedi Fonu",
-    symbol: "TI3",
-    active: true,
-    managementFee: 0.0035,
-    riskLevel: 6,
-    fundType: FundType.STOCK_UMBRELLA_FUND,
-    ownerSymbol: "IYP"
+    "assetType": "fund",
+    "name": "NEO PORTFÖY KATILIM HİSSE SENEDİ FONU (HİSSE SENEDİ YOĞUN FON)",
+    "symbol": "NKM",
+    "active": true,
+    "managementFee": 2.8,
+    "riskLevel": 0,
+    "fundType": "STOCK_UMBRELLA_FUND",
+    "ownerSymbol": "VVP"
   }
 ];
 
-const mockFundStatsResponse: FundStats = {
-  yearBeta: 0.95,
-  yearStdev: 0.12,
-  ytdReturn: 0.15,
-  yearMomentum: 0.08,
-  yearlyReturn: 0.25,
-  monthlyReturn: 0.03,
-  fiveYearReturn: 1.85,
-  sixMonthReturn: 0.18,
-  threeYearReturn: 0.95,
-  threeMonthReturn: 0.09
+const mockFundStatsResponse = {
+  "monthlyReturn": -2.3367,
+  "threeMonthReturn": 3.8059,
+  "sixMonthReturn": 12.3031,
+  "ytdReturn": -0.8037,
+  "yearlyReturn": 31.9956,
+  "threeYearReturn": 281.8466,
+  "fiveYearReturn": 867.6593,
+  "yearMomentum": 0,
+  "yearBeta": 0.000068,
+  "yearStdev": 0.077
 };
 
-const mockFundDistributionResponse: FundDistribution = {
-  categories: [
+const mockFundDistributionResponse = {
+  "categories": [
     {
-      category: FundAssetCategory.EQUITY,
-      percentage: 95.5,
-      assets: [
+      "assets": [
+        {
+          "type": "BIST_STOCK",
+          "symbol": "ASELS",
+          "wholePercentage": 30,
+          "categoryPercentage": 60
+        },
         {
-          type: FundContentType.BIST_STOCK,
-          symbol: "GARAN",
-          wholePercentage: 9.8,
-          categoryPercentage: 10.26
+          "type": "OTHER_STOCK",
+          "symbol": "NVDA",
+          "wholePercentage": 20,
+          "categoryPercentage": 40
         }
-      ]
+      ],
+      "category": "EQUITY",
+      "percentage": 50
+    },
+    {
+      "category": "GOVERNMENT_BOND",
+      "percentage": 30
     },
     {
-      category: FundAssetCategory.LIQUID_DEPOSIT,
-      percentage: 4.5
+      "category": "CURRENCY",
+      "percentage": 20
     }
   ]
 };
 
-const mockHistoricalPricesResponse: FundHistoricalPrice[] = [
-  {
-    price: 15.25,
-    aum: 1250000000,
-    date: "2024-03-14T10:00:00Z",
-    shareCount: 82000000,
-    investorCount: 25000
-  },
+const mockHistoricalPricesResponse = [
   {
-    price: 15.15,
-    aum: 1245000000,
-    date: "2024-03-13T10:00:00Z",
-    shareCount: 82180000,
-    investorCount: 24950
+    "date": "2026-02-20T00:00:00Z",
+    "price": 1.004711,
+    "aum": 5242278660.64,
+    "investorCount": 48900,
+    "shareCount": 5217695760
   }
 ];
 
@@ -119,6 +105,7 @@ describe("Funds Client", () => {
         expect(typeof fund.assetType).toBe("string");
         expect(typeof fund.managementFee).toBe("number");
         expect(typeof fund.riskLevel).toBe("number");
+        expect(typeof fund.active).toBe("boolean");
         expect(typeof fund.ownerSymbol).toBe("string");
         expect(Object.values(FundType)).toContain(fund.fundType);
       });
@@ -191,127 +178,209 @@ describe("Funds Client", () => {
   });
 
   describe("Mock Tests", () => {
+    let client: FundsClient;
+    let cli: { request: jest.Mock };
+  
     beforeEach(() => {
-      jest.clearAllMocks();
+      cli = { request: jest.fn() };
+  
+      const config = (global as any).testSuite.config as LaplaceConfiguration;
+      const logger: Logger = {
+        info: jest.fn(),
+        error: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+      } as unknown as Logger;
+  
+      client = new FundsClient(config, logger, cli as any);
     });
-
+  
     describe("getFunds", () => {
-      test("should return funds list with mock data", async () => {
-        jest.spyOn(client, 'getFunds').mockResolvedValue(mockFundsResponse);
-
-        const resp = await client.getFunds(Region.Tr, 1, 10);
-
-        expect(resp).toHaveLength(2);
-        
-        const firstFund = resp[0];
-        expect(firstFund.symbol).toBe("SPP");
-        expect(firstFund.name).toBe("Ak Portföy BIST 30 Endeksi Hisse Senedi Fonu");
-        expect(firstFund.assetType).toBe(AssetType.Stock);
-        expect(firstFund.managementFee).toBe(0.003);
-        expect(firstFund.riskLevel).toBe(6);
-        expect(firstFund.fundType).toBe(FundType.STOCK_UMBRELLA_FUND);
-        expect(firstFund.ownerSymbol).toBe("AKP");
-
-        expect(client.getFunds).toHaveBeenCalledWith(Region.Tr, 1, 10);
+      test("calls correct endpoint/params (without page) and matches raw response", async () => {
+        cli.request.mockResolvedValueOnce({ data: mockFundsResponse });
+  
+        const resp = await client.getFunds(Region.Tr, 10);
+  
+        expect(cli.request).toHaveBeenCalledTimes(1);
+        const call = cli.request.mock.calls[0][0];
+  
+        expect(call.method).toBe("GET");
+        expect(call.url).toBe("/api/v1/fund");
+        expect(call.params).toEqual({
+          region: Region.Tr,
+          pageSize: 10,
+        });
+  
+        expect(resp).toHaveLength(1);
+  
+        const f = resp[0];
+        expect(f.assetType).toBe("fund");
+        expect(f.name).toBe(
+          "NEO PORTFÖY KATILIM HİSSE SENEDİ FONU (HİSSE SENEDİ YOĞUN FON)"
+        );
+        expect(f.symbol).toBe("NKM");
+        expect(f.active).toBe(true);
+        expect(f.managementFee).toBe(2.8);
+        expect(f.riskLevel).toBe(0);
+        expect(f.fundType).toBe("STOCK_UMBRELLA_FUND");
+        expect(f.ownerSymbol).toBe("VVP");
       });
-
-      test("should handle pagination with mock data", async () => {
-        jest.spyOn(client, 'getFunds').mockResolvedValue([mockFundsResponse[0]]);
-
-        const resp = await client.getFunds(Region.Tr, 1, 1);
-
+  
+      test("calls correct endpoint/params (with page) and matches raw response", async () => {
+        cli.request.mockResolvedValueOnce({ data: mockFundsResponse });
+  
+        const resp = await client.getFunds(Region.Tr, 10, 2);
+  
+        expect(cli.request).toHaveBeenCalledTimes(1);
+        const call = cli.request.mock.calls[0][0];
+  
+        expect(call.method).toBe("GET");
+        expect(call.url).toBe("/api/v1/fund");
+        expect(call.params).toEqual({
+          region: Region.Tr,
+          pageSize: 10,
+          page: 2,
+        });
+  
         expect(resp).toHaveLength(1);
-        expect(resp[0].symbol).toBe("SPP");
-
-        expect(client.getFunds).toHaveBeenCalledWith(Region.Tr, 1, 1);
+        expect(resp[0].symbol).toBe("NKM");
+      });
+  
+      test("bubbles up request error", async () => {
+        cli.request.mockRejectedValueOnce(new Error("Bad request"));
+  
+        await expect(client.getFunds(Region.Tr, 10)).rejects.toThrow("Bad request");
       });
     });
-
+  
     describe("getFundStats", () => {
-      test("should return fund statistics with mock data", async () => {
-        jest.spyOn(client, 'getFundStats').mockResolvedValue(mockFundStatsResponse);
-
-        const resp = await client.getFundStats("SPP", Region.Tr);
-
-        expect(resp.yearBeta).toBe(0.95);
-        expect(resp.yearStdev).toBe(0.12);
-        expect(resp.ytdReturn).toBe(0.15);
-        expect(resp.yearMomentum).toBe(0.08);
-        expect(resp.yearlyReturn).toBe(0.25);
-        expect(resp.monthlyReturn).toBe(0.03);
-        expect(resp.fiveYearReturn).toBe(1.85);
-        expect(resp.sixMonthReturn).toBe(0.18);
-        expect(resp.threeYearReturn).toBe(0.95);
-        expect(resp.threeMonthReturn).toBe(0.09);
-
-        expect(client.getFundStats).toHaveBeenCalledWith("SPP", Region.Tr);
+      test("calls correct endpoint/params and matches raw response", async () => {
+        cli.request.mockResolvedValueOnce({ data: mockFundStatsResponse });
+  
+        const resp = await client.getFundStats("NKM", Region.Tr);
+  
+        expect(cli.request).toHaveBeenCalledTimes(1);
+        const call = cli.request.mock.calls[0][0];
+  
+        expect(call.method).toBe("GET");
+        expect(call.url).toBe("/api/v1/fund/stats");
+        expect(call.params).toEqual({ symbol: "NKM", region: Region.Tr });
+  
+        expect(resp.monthlyReturn).toBe(-2.3367);
+        expect(resp.threeMonthReturn).toBe(3.8059);
+        expect(resp.sixMonthReturn).toBe(12.3031);
+        expect(resp.ytdReturn).toBe(-0.8037);
+        expect(resp.yearlyReturn).toBe(31.9956);
+        expect(resp.threeYearReturn).toBe(281.8466);
+        expect(resp.fiveYearReturn).toBe(867.6593);
+        expect(resp.yearMomentum).toBe(0);
+        expect(resp.yearBeta).toBe(0.000068);
+        expect(resp.yearStdev).toBe(0.077);
       });
-
-      test("should handle invalid fund symbol error", async () => {
-        jest.spyOn(client, 'getFundStats').mockRejectedValue(new Error("Fund not found"));
-
-        await expect(client.getFundStats("INVALID_FUND", Region.Tr))
-          .rejects.toThrow("Fund not found");
+  
+      test("bubbles up request error", async () => {
+        cli.request.mockRejectedValueOnce(new Error("Fund not found"));
+  
+        await expect(client.getFundStats("INVALID", Region.Tr)).rejects.toThrow(
+          "Fund not found"
+        );
       });
     });
-
+  
     describe("getFundDistribution", () => {
-      test("should return fund distribution with mock data", async () => {
-        jest.spyOn(client, 'getFundDistribution').mockResolvedValue(mockFundDistributionResponse);
-
-        const resp = await client.getFundDistribution("SPP", Region.Tr);
-
-        expect(resp.categories).toHaveLength(2);
-        
-        const equityCategory = resp.categories[0];
-        expect(equityCategory.category).toBe(FundAssetCategory.EQUITY);
-        expect(equityCategory.percentage).toBe(95.5);
-        expect(equityCategory.assets).toBeDefined();
-        expect(equityCategory.assets![0].symbol).toBe("GARAN");
-
-        const liquidCategory = resp.categories[1];
-        expect(liquidCategory.category).toBe(FundAssetCategory.LIQUID_DEPOSIT);
-        expect(liquidCategory.percentage).toBe(4.5);
-
-        expect(client.getFundDistribution).toHaveBeenCalledWith("SPP", Region.Tr);
+      test("calls correct endpoint/params and matches raw response", async () => {
+        cli.request.mockResolvedValueOnce({ data: mockFundDistributionResponse });
+  
+        const resp = await client.getFundDistribution("NKM", Region.Tr);
+  
+        expect(cli.request).toHaveBeenCalledTimes(1);
+        const call = cli.request.mock.calls[0][0];
+  
+        expect(call.method).toBe("GET");
+        expect(call.url).toBe("/api/v1/fund/distribution");
+        expect(call.params).toEqual({ symbol: "NKM", region: Region.Tr });
+  
+        expect(resp.categories).toHaveLength(3);
+  
+        const c0 = resp.categories[0];
+        expect(c0.category).toBe("EQUITY");
+        expect(c0.percentage).toBe(50);
+        expect(Array.isArray(c0.assets)).toBe(true);
+        expect(c0.assets!).toHaveLength(2);
+  
+        expect(c0.assets![0].type).toBe("BIST_STOCK");
+        expect(c0.assets![0].symbol).toBe("ASELS");
+        expect(c0.assets![0].wholePercentage).toBe(30);
+        expect(c0.assets![0].categoryPercentage).toBe(60);
+  
+        expect(c0.assets![1].type).toBe("OTHER_STOCK");
+        expect(c0.assets![1].symbol).toBe("NVDA");
+        expect(c0.assets![1].wholePercentage).toBe(20);
+        expect(c0.assets![1].categoryPercentage).toBe(40);
+  
+        const c1 = resp.categories[1];
+        expect(c1.category).toBe("GOVERNMENT_BOND");
+        expect(c1.percentage).toBe(30);
+        expect(c1.assets).toBeUndefined();
+  
+        const c2 = resp.categories[2];
+        expect(c2.category).toBe("CURRENCY");
+        expect(c2.percentage).toBe(20);
+        expect(c2.assets).toBeUndefined();
+      });
+  
+      test("bubbles up request error", async () => {
+        cli.request.mockRejectedValueOnce(new Error("Invalid symbol"));
+  
+        await expect(client.getFundDistribution("INVALID", Region.Tr)).rejects.toThrow(
+          "Invalid symbol"
+        );
       });
     });
-
+  
     describe("getHistoricalFundPrices", () => {
-      test("should return historical prices with mock data", async () => {
-        jest.spyOn(client, 'getHistoricalFundPrices').mockResolvedValue(mockHistoricalPricesResponse);
-
+      test("calls correct endpoint/params and matches raw response", async () => {
+        cli.request.mockResolvedValueOnce({ data: mockHistoricalPricesResponse });
+  
         const resp = await client.getHistoricalFundPrices(
-          "SPP",
-          Region.Tr,
-          HistoricalFundPricePeriod.OneMonth
-        );
-
-        expect(resp).toHaveLength(2);
-        
-        const firstPrice = resp[0];
-        expect(firstPrice.price).toBe(15.25);
-        expect(firstPrice.aum).toBe(1250000000);
-        expect(firstPrice.date).toBe("2024-03-14T10:00:00Z");
-        expect(firstPrice.shareCount).toBe(82000000);
-        expect(firstPrice.investorCount).toBe(25000);
-
-        expect(client.getHistoricalFundPrices).toHaveBeenCalledWith(
-          "SPP",
+          "NKM",
           Region.Tr,
           HistoricalFundPricePeriod.OneMonth
         );
+  
+        expect(cli.request).toHaveBeenCalledTimes(1);
+        const call = cli.request.mock.calls[0][0];
+  
+        expect(call.method).toBe("GET");
+        expect(call.url).toBe("/api/v1/fund/price");
+        expect(call.params).toEqual({
+          symbol: "NKM",
+          region: Region.Tr,
+          period: HistoricalFundPricePeriod.OneMonth,
+        });
+  
+        expect(resp).toHaveLength(1);
+  
+        const p = resp[0];
+        expect(p.date).toBe("2026-02-20T00:00:00Z");
+        expect(p.price).toBe(1.004711);
+        expect(p.aum).toBe(5242278660.64);
+        expect(p.investorCount).toBe(48900);
+        expect(p.shareCount).toBe(5217695760);
       });
-
-      test("should handle invalid period error", async () => {
-        jest.spyOn(client, 'getHistoricalFundPrices').mockRejectedValue(new Error("Invalid period"));
-
-        await expect(client.getHistoricalFundPrices(
-          "SPP",
-          Region.Tr,
-          "INVALID_PERIOD" as HistoricalFundPricePeriod
-        )).rejects.toThrow("Invalid period");
+  
+      test("bubbles up request error", async () => {
+        cli.request.mockRejectedValueOnce(new Error("Invalid period"));
+  
+        await expect(
+          client.getHistoricalFundPrices(
+            "NKM",
+            Region.Tr,
+            "INVALID_PERIOD" as HistoricalFundPricePeriod
+          )
+        ).rejects.toThrow("Invalid period");
       });
     });
   });
+  
 });

package/src/test/helpers.ts

@@ -1,4 +1,5 @@
 import { Collection, CollectionDetail } from "../client/collections";
+import { Stock } from "../client/stocks";
 
 export const validateCollection = (collection: Collection) => {
     expect(typeof collection.id).toBe("string");
@@ -17,27 +18,19 @@ export const validateCollection = (collection: Collection) => {
         expect(typeof region).toBe("string");
       });
     }
-    
-    if (collection.assetClass !== undefined) {
-      expect(typeof collection.assetClass).toBe("string");
-    }
-    
-    if (collection.image !== undefined) {
-      expect(typeof collection.image).toBe("string");
-    }
-    
-    if (collection.order !== undefined) {
-      expect(typeof collection.order).toBe("number");
+
+    if (collection.locale != null) {
+      expect(typeof collection.locale).toBe("string");
     }
     
-    if (collection.status !== undefined) {
-      expect(typeof collection.status).toBe("string");
+    if (collection.assetClass != null) {
+      expect(typeof collection.assetClass).toBe("string");
     }
     
-    if (collection.metaData !== undefined) {
-      expect(typeof collection.metaData).toBe("object");
-      expect(collection.metaData).not.toBeNull();
-    }
+    if (collection.image != null) expect(typeof collection.image).toBe("string");
+    if (collection.order != null) expect(typeof collection.order).toBe("number");
+    if (collection.status != null) expect(typeof collection.status).toBe("string");
+    if (collection.metaData != null) expect(typeof collection.metaData).toBe("object");
   };
   
   export const validateCollectionDetail = (collectionDetail: CollectionDetail) => {
@@ -46,13 +39,16 @@ export const validateCollection = (collection: Collection) => {
     expect(Array.isArray(collectionDetail.stocks)).toBe(true);
     expect(collectionDetail.stocks.length).toBeGreaterThan(0);
     
-    const firstStock = collectionDetail.stocks[0];
-    expect(typeof firstStock.id).toBe("string");
-    expect(typeof firstStock.assetType).toBe("string");
-    expect(typeof firstStock.name).toBe("string");
-    expect(typeof firstStock.symbol).toBe("string");
-    expect(typeof firstStock.sectorId).toBe("string");
-    expect(typeof firstStock.industryId).toBe("string");
-    expect(typeof firstStock.updatedDate).toBe("string");
-    expect(typeof firstStock.active).toBe("boolean");
-  };
+    collectionDetail.stocks.forEach(validateStockLite);
+  };
+
+  function validateStockLite(s: Stock) {
+    expect(typeof s.id).toBe("string");
+    expect(typeof s.assetType).toBe("string");
+    expect(typeof s.name).toBe("string");
+    expect(typeof s.symbol).toBe("string");
+    expect(typeof s.sectorId).toBe("string");
+    expect(typeof s.industryId).toBe("string");
+    expect(typeof s.updatedDate).toBe("string");
+    expect(typeof s.active).toBe("boolean");
+  }

package/src/test/key-insight.test.ts

@@ -1,15 +1,15 @@
 import { Logger } from "winston";
 import { LaplaceConfiguration } from "../utilities/configuration";
 import "./client_test_suite";
-import { KeyInsightClient, KeyInsight } from "../client/key-insights";
+import { KeyInsightClient } from "../client/key-insights";
 import { Region } from "../client/collections";
 
-const mockTRKeyInsightResponse: KeyInsight = {
+const mockTRKeyInsightResponse = {
   symbol: "TOASO",
   insight: "Tofaş'ın net kârı, güçlü operasyonel performans ve yüksek ihracat gelirleri sayesinde geçen yılın aynı dönemine göre %85 artış gösterdi."
 };
 
-const mockUSKeyInsightResponse: KeyInsight = {
+const mockUSKeyInsightResponse = {
   symbol: "AAPL",
   insight: "Apple's revenue growth was driven by strong iPhone sales and continued expansion in services, with significant market share gains in emerging markets."
 };
@@ -59,52 +59,87 @@ describe("Key Insight", () => {
   });
 
   describe("Mock Tests", () => {
+    let client: KeyInsightClient;
+    let cli: { request: jest.Mock };
+  
     beforeEach(() => {
-      jest.clearAllMocks();
+      cli = { request: jest.fn() };
+  
+      const config = (global as any).testSuite.config as LaplaceConfiguration;
+      const logger: Logger = {
+        info: jest.fn(),
+        error: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+      } as unknown as Logger;
+  
+      client = new KeyInsightClient(config, logger, cli as any);
     });
-
+  
     describe("getKeyInsights", () => {
-      test("should return TR key insights with mock data", async () => {
-        jest.spyOn(client, 'getKeyInsights').mockResolvedValue(mockTRKeyInsightResponse);
-
+      test("TR: calls correct endpoint/params and matches raw response", async () => {
+        cli.request.mockResolvedValueOnce({ data: mockTRKeyInsightResponse });
+  
         const resp = await client.getKeyInsights("TOASO", Region.Tr);
-
-        expect(resp).toBeDefined();
+  
+        expect(cli.request).toHaveBeenCalledTimes(1);
+        const call = cli.request.mock.calls[0][0];
+  
+        expect(call.method).toBe("GET");
+        expect(call.url).toBe("/api/v1/key-insights");
+        expect(call.params).toEqual({
+          symbol: "TOASO",
+          region: Region.Tr,
+        });
+  
         expect(resp.symbol).toBe("TOASO");
         expect(resp.insight).toBe(mockTRKeyInsightResponse.insight);
-
-        expect(client.getKeyInsights).toHaveBeenCalledWith("TOASO", Region.Tr);
       });
-
-      test("should return US key insights with mock data", async () => {
-        jest.spyOn(client, 'getKeyInsights').mockResolvedValue(mockUSKeyInsightResponse);
-
+  
+      test("US: calls correct endpoint/params and matches raw response", async () => {
+        cli.request.mockResolvedValueOnce({ data: mockUSKeyInsightResponse });
+  
         const resp = await client.getKeyInsights("AAPL", Region.Us);
-
-        expect(resp).toBeDefined();
+  
+        expect(cli.request).toHaveBeenCalledTimes(1);
+        const call = cli.request.mock.calls[0][0];
+  
+        expect(call.method).toBe("GET");
+        expect(call.url).toBe("/api/v1/key-insights");
+        expect(call.params).toEqual({
+          symbol: "AAPL",
+          region: Region.Us,
+        });
+  
         expect(resp.symbol).toBe("AAPL");
         expect(resp.insight).toBe(mockUSKeyInsightResponse.insight);
-
-        expect(client.getKeyInsights).toHaveBeenCalledWith("AAPL", Region.Us);
       });
-
-      test("should handle invalid symbol error", async () => {
-        jest.spyOn(client, 'getKeyInsights').mockRejectedValue(new Error("Symbol not found"));
-
-        await expect(client.getKeyInsights("INVALID_SYMBOL", Region.Tr))
-          .rejects.toThrow("Symbol not found");
-
-        expect(client.getKeyInsights).toHaveBeenCalledWith("INVALID_SYMBOL", Region.Tr);
+  
+      test("bubbles up request error", async () => {
+        cli.request.mockRejectedValueOnce(new Error("Symbol not found"));
+  
+        await expect(client.getKeyInsights("INVALID_SYMBOL", Region.Tr)).rejects.toThrow(
+          "Symbol not found"
+        );
+  
+        expect(cli.request).toHaveBeenCalledTimes(1);
       });
-
-      test("should handle empty symbol error", async () => {
-        jest.spyOn(client, 'getKeyInsights').mockRejectedValue(new Error("Symbol cannot be empty"));
-
-        await expect(client.getKeyInsights("", Region.Tr))
-          .rejects.toThrow("Symbol cannot be empty");
-
-        expect(client.getKeyInsights).toHaveBeenCalledWith("", Region.Tr);
+  
+      test("empty symbol: bubbles up request error", async () => {
+        cli.request.mockRejectedValueOnce(new Error("Symbol cannot be empty"));
+  
+        await expect(client.getKeyInsights("", Region.Tr)).rejects.toThrow(
+          "Symbol cannot be empty"
+        );
+  
+        expect(cli.request).toHaveBeenCalledTimes(1);
+        const call = cli.request.mock.calls[0][0];
+  
+        expect(call.method).toBe("GET");
+        expect(call.url).toBe("/api/v1/key-insights");
+        expect(call.params).toEqual({ symbol: "", region: Region.Tr });
       });
     });
   });
+  
 });