@oanda/labs-crowd-view-widget 1.0.52 → 1.0.53

package/test/utils/processOrderPositionBooks.test.ts

@@ -3,125 +3,242 @@ import type { GetOrderPositionBooksQuery } from '../../src/gql/types/graphql';
 
 describe('processOrderPositionBooks', () => {
   const createMockOrderPositionBook = (time: string) => ({
-    bucketWidth: 0.0005,
-    price: 1.0,
     time,
-    buckets: [{ price: 1.0, sentiment: 0.2 }],
+    price: 1.0,
+    buckets: [
+      { price: 1.0, sentiment: 0.2 },
+      { price: 1.0005, sentiment: -0.3 },
+    ],
   });
 
-  it('should return empty array when orderPositionData is undefined', () => {
-    const candleMap = new Map();
-    expect(processOrderPositionBooks(undefined, candleMap)).toEqual([]);
+  it('should return empty arrays when orderPositionData is undefined', () => {
+    const result = processOrderPositionBooks(undefined, []);
+    expect(result).toEqual({
+      bookPrices: [],
+      bookIndexes: [],
+      buckets: [],
+      bucketWidth: 0,
+      sentimentThresholdMin: 0,
+      sentimentThresholdMax: 0,
+      hasValidBooks: false,
+    });
   });
 
-  it('should return empty array when orderPositionBooks is empty', () => {
+  it('should return empty arrays when orderPositionBooks is undefined', () => {
     const mockData: GetOrderPositionBooksQuery = {
-      orderPositionBooks: [],
+      orderPositionBooks: {} as any,
     };
-    const candleMap = new Map();
-    expect(processOrderPositionBooks(mockData, candleMap)).toEqual([]);
+    const result = processOrderPositionBooks(mockData, []);
+    expect(result).toEqual({
+      bookPrices: [],
+      bookIndexes: [],
+      buckets: [],
+      bucketWidth: 0,
+      sentimentThresholdMin: 0,
+      sentimentThresholdMax: 0,
+      hasValidBooks: false,
+    });
   });
 
-  it('should filter out null books', () => {
+  it('should return empty arrays when books array is empty', () => {
     const mockData: GetOrderPositionBooksQuery = {
-      orderPositionBooks: [null, createMockOrderPositionBook('2025-01-01')],
+      orderPositionBooks: {
+        books: [],
+        bucketWidth: 0.0005,
+        sentimentThresholdMin: 0.15,
+        sentimentThresholdMax: 0.55,
+      },
     };
-    const candleMap = new Map();
-    const result = processOrderPositionBooks(mockData, candleMap);
-    expect(result).toHaveLength(1);
-    expect(result[0]).toEqual(['2025-01-01', null, 0]);
+    const result = processOrderPositionBooks(mockData, []);
+    expect(result).toEqual({
+      bookPrices: [],
+      bookIndexes: [],
+      buckets: [],
+      bucketWidth: 0,
+      sentimentThresholdMin: 0,
+      sentimentThresholdMax: 0,
+      hasValidBooks: false,
+    });
   });
 
-  it('should filter out books with no buckets', () => {
+  it('should return empty arrays when sentimentThresholdMin is missing', () => {
     const mockData: GetOrderPositionBooksQuery = {
-      orderPositionBooks: [
-        {
-          bucketWidth: 0.0005,
-          price: 1.0,
-          time: '2025-01-01',
-          buckets: [],
-        },
-        createMockOrderPositionBook('2025-01-02'),
-      ],
+      orderPositionBooks: {
+        books: [createMockOrderPositionBook('2025-01-01T00:00:00Z')],
+        bucketWidth: 0.0005,
+        sentimentThresholdMin: null as any,
+        sentimentThresholdMax: 0.55,
+      },
     };
-    const candleMap = new Map();
-    const result = processOrderPositionBooks(mockData, candleMap);
-    expect(result).toHaveLength(1);
-    expect(result[0]).toEqual(['2025-01-02', null, 0]);
+    const result = processOrderPositionBooks(mockData, [
+      '2025-01-01T00:00:00Z',
+    ]);
+    expect(result.hasValidBooks).toBe(false);
   });
 
-  it('should use candle high price when available in map', () => {
+  it('should process valid order position books and match with dates', () => {
+    const dates = [
+      '2025-01-01T00:00:00Z',
+      '2025-01-01T01:00:00Z',
+      '2025-01-01T02:00:00Z',
+    ];
     const mockData: GetOrderPositionBooksQuery = {
-      orderPositionBooks: [
-        createMockOrderPositionBook('2025-01-01'),
-        createMockOrderPositionBook('2025-01-02'),
-      ],
+      orderPositionBooks: {
+        books: [
+          createMockOrderPositionBook('2025-01-01T00:00:00Z'),
+          createMockOrderPositionBook('2025-01-01T01:00:00Z'),
+        ],
+        bucketWidth: 0.0005,
+        sentimentThresholdMin: 0.15,
+        sentimentThresholdMax: 0.55,
+      },
     };
-    const candleMap = new Map([
-      ['2025-01-01', { high: 1.1234 }],
-      ['2025-01-02', { high: 1.5678 }],
-    ]);
-    const result = processOrderPositionBooks(mockData, candleMap);
-    expect(result).toHaveLength(2);
-    expect(result[0]).toEqual(['2025-01-01', 1.1234, 0]);
-    expect(result[1]).toEqual(['2025-01-02', 1.5678, 1]);
+    const result = processOrderPositionBooks(mockData, dates);
+    expect(result.hasValidBooks).toBe(true);
+    expect(result.bucketWidth).toBe(0.0005);
+    expect(result.sentimentThresholdMin).toBe(0.15);
+    expect(result.sentimentThresholdMax).toBe(0.55);
+    expect(result.bookPrices).toHaveLength(3);
+    expect(result.bookIndexes).toHaveLength(3);
+    expect(result.buckets).toHaveLength(3);
+    expect(result.bookPrices[0]).toBe(1.0);
+    expect(result.bookPrices[1]).toBe(1.0);
+    expect(result.bookPrices[2]).toBeNull();
+    expect(result.bookIndexes).toEqual([0, 1, 2]);
+    expect(result.buckets[0]).toHaveLength(2);
+    expect(result.buckets[1]).toHaveLength(2);
+    expect(result.buckets[2]).toEqual([]);
   });
 
-  it('should use null when candle is not in map', () => {
+  it('should handle dates that do not match any book', () => {
+    const dates = [
+      '2025-01-01T00:00:00Z',
+      '2025-01-01T01:00:00Z',
+      '2025-01-01T02:00:00Z',
+    ];
     const mockData: GetOrderPositionBooksQuery = {
-      orderPositionBooks: [createMockOrderPositionBook('2025-01-01')],
+      orderPositionBooks: {
+        books: [createMockOrderPositionBook('2025-01-01T00:00:00Z')],
+        bucketWidth: 0.0005,
+        sentimentThresholdMin: 0.15,
+        sentimentThresholdMax: 0.55,
+      },
     };
-    const candleMap = new Map();
-    const result = processOrderPositionBooks(mockData, candleMap);
-    expect(result).toHaveLength(1);
-    expect(result[0]).toEqual(['2025-01-01', null, 0]);
+    const result = processOrderPositionBooks(mockData, dates);
+    expect(result.bookPrices).toEqual([1.0, null, null]);
+    expect(result.buckets[0]).toHaveLength(2);
+    expect(result.buckets[1]).toEqual([]);
+    expect(result.buckets[2]).toEqual([]);
   });
 
-  it('should use null when candle high is undefined', () => {
+  it('should handle books with null price', () => {
+    const dates = ['2025-01-01T00:00:00Z'];
     const mockData: GetOrderPositionBooksQuery = {
-      orderPositionBooks: [createMockOrderPositionBook('2025-01-01')],
+      orderPositionBooks: {
+        books: [
+          {
+            time: '2025-01-01T00:00:00Z',
+            price: null,
+            buckets: [{ price: 1.0, sentiment: 0.2 }],
+          },
+        ],
+        bucketWidth: 0.0005,
+        sentimentThresholdMin: 0.15,
+        sentimentThresholdMax: 0.55,
+      },
     };
-    const candleMap = new Map([
-      ['2025-01-01', { low: 1.0 }], // no high property
+    const result = processOrderPositionBooks(mockData, dates);
+    expect(result.bookPrices[0]).toBeNull();
+    expect(result.buckets[0]).toHaveLength(1);
+  });
+
+  it('should correctly map buckets structure', () => {
+    const dates = ['2025-01-01T00:00:00Z'];
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: {
+        books: [
+          {
+            time: '2025-01-01T00:00:00Z',
+            price: 1.0,
+            buckets: [
+              { price: 1.0, sentiment: 0.2 },
+              { price: 1.0005, sentiment: -0.3 },
+              { price: 1.001, sentiment: 0.5 },
+            ],
+          },
+        ],
+        bucketWidth: 0.0005,
+        sentimentThresholdMin: 0.15,
+        sentimentThresholdMax: 0.55,
+      },
+    };
+    const result = processOrderPositionBooks(mockData, dates);
+    expect(result.buckets[0]).toEqual([
+      { price: 1.0, sentiment: 0.2 },
+      { price: 1.0005, sentiment: -0.3 },
+      { price: 1.001, sentiment: 0.5 },
     ]);
-    const result = processOrderPositionBooks(mockData, candleMap);
-    expect(result).toHaveLength(1);
-    expect(result[0]).toEqual(['2025-01-01', null, 0]);
   });
 
-  it('should correctly assign index to each book', () => {
+  it('should handle duplicate time values in books array (last one wins)', () => {
+    const dates = ['2025-01-01T00:00:00Z'];
     const mockData: GetOrderPositionBooksQuery = {
-      orderPositionBooks: [
-        createMockOrderPositionBook('2025-01-01'),
-        createMockOrderPositionBook('2025-01-02'),
-        createMockOrderPositionBook('2025-01-03'),
-      ],
+      orderPositionBooks: {
+        books: [
+          {
+            time: '2025-01-01T00:00:00Z',
+            price: 1.0,
+            buckets: [{ price: 1.0, sentiment: 0.2 }],
+          },
+          {
+            time: '2025-01-01T00:00:00Z',
+            price: 1.5,
+            buckets: [{ price: 1.5, sentiment: 0.8 }],
+          },
+        ],
+        bucketWidth: 0.0005,
+        sentimentThresholdMin: 0.15,
+        sentimentThresholdMax: 0.55,
+      },
     };
-    const candleMap = new Map();
-    const result = processOrderPositionBooks(mockData, candleMap);
-    expect(result).toHaveLength(3);
-    expect(result[0][2]).toBe(0);
-    expect(result[1][2]).toBe(1);
-    expect(result[2][2]).toBe(2);
+    const result = processOrderPositionBooks(mockData, dates);
+    // Last entry should win
+    expect(result.bookPrices[0]).toBe(1.5);
+    expect(result.buckets[0]).toEqual([{ price: 1.5, sentiment: 0.8 }]);
   });
 
-  it('should handle mixed cases with and without candles', () => {
+  it('should return empty arrays when dates array is empty', () => {
     const mockData: GetOrderPositionBooksQuery = {
-      orderPositionBooks: [
-        createMockOrderPositionBook('2025-01-01'),
-        createMockOrderPositionBook('2025-01-02'),
-        createMockOrderPositionBook('2025-01-03'),
-      ],
+      orderPositionBooks: {
+        books: [createMockOrderPositionBook('2025-01-01T00:00:00Z')],
+        bucketWidth: 0.0005,
+        sentimentThresholdMin: 0.15,
+        sentimentThresholdMax: 0.55,
+      },
     };
-    const candleMap = new Map([
-      ['2025-01-01', { high: 1.1111 }],
-      // 2025-01-02 missing from map
-      ['2025-01-03', { high: 1.3333 }],
-    ]);
-    const result = processOrderPositionBooks(mockData, candleMap);
-    expect(result).toHaveLength(3);
-    expect(result[0]).toEqual(['2025-01-01', 1.1111, 0]);
-    expect(result[1]).toEqual(['2025-01-02', null, 1]);
-    expect(result[2]).toEqual(['2025-01-03', 1.3333, 2]);
+    const result = processOrderPositionBooks(mockData, []);
+    expect(result).toEqual({
+      bookPrices: [],
+      bookIndexes: [],
+      buckets: [],
+      bucketWidth: 0,
+      sentimentThresholdMin: 0,
+      sentimentThresholdMax: 0,
+      hasValidBooks: false,
+    });
+  });
+
+  it('should return empty arrays when dates is not an array', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: {
+        books: [createMockOrderPositionBook('2025-01-01T00:00:00Z')],
+        bucketWidth: 0.0005,
+        sentimentThresholdMin: 0.15,
+        sentimentThresholdMax: 0.55,
+      },
+    };
+    // @ts-expect-error - Testing invalid input
+    const result = processOrderPositionBooks(mockData, null);
+    expect(result.hasValidBooks).toBe(false);
   });
 });

package/test/utils/processPriceCandles.test.ts

@@ -7,9 +7,13 @@ describe('processPriceCandles', () => {
     expect(result).toEqual({
       minPrice: 0,
       maxPrice: 0,
+      pipsLocation: 0,
       hasValidCandles: false,
-      candleMap: new Map(),
-      candles: [],
+      candlesOpen: [],
+      candlesClose: [],
+      candlesLow: [],
+      candlesHigh: [],
+      dates: [],
     });
   });
 
@@ -21,9 +25,13 @@ describe('processPriceCandles', () => {
     expect(result).toEqual({
       minPrice: 0,
       maxPrice: 0,
+      pipsLocation: 0,
       hasValidCandles: false,
-      candleMap: new Map(),
-      candles: [],
+      candlesOpen: [],
+      candlesClose: [],
+      candlesLow: [],
+      candlesHigh: [],
+      dates: [],
     });
   });
 
@@ -31,15 +39,20 @@ describe('processPriceCandles', () => {
     const mockData: GetPriceCandlesQuery = {
       priceCandles: {
         candle: [],
+        pipsLocation: 0,
       },
     };
     const result = processPriceCandles(mockData);
     expect(result).toEqual({
       minPrice: 0,
       maxPrice: 0,
+      pipsLocation: 0,
       hasValidCandles: false,
-      candleMap: new Map(),
-      candles: [],
+      candlesOpen: [],
+      candlesClose: [],
+      candlesLow: [],
+      candlesHigh: [],
+      dates: [],
     });
   });
 
@@ -69,14 +82,24 @@ describe('processPriceCandles', () => {
             close: 1.2,
           },
         ],
+        pipsLocation: 4,
       },
     };
     const result = processPriceCandles(mockData);
     expect(result.hasValidCandles).toBe(true);
     expect(result.minPrice).toBe(0.9);
     expect(result.maxPrice).toBe(1.8);
-    expect(result.candles).toHaveLength(3);
-    expect(result.candleMap.size).toBe(3);
+    expect(result.pipsLocation).toBe(4);
+    expect(result.dates).toHaveLength(3);
+    expect(result.candlesOpen).toHaveLength(3);
+    expect(result.candlesClose).toHaveLength(3);
+    expect(result.candlesLow).toHaveLength(3);
+    expect(result.candlesHigh).toHaveLength(3);
+    expect(result.dates[0]).toBe('2025-01-01T00:00:00Z');
+    expect(result.candlesOpen[0]).toBe(1.2);
+    expect(result.candlesClose[0]).toBe(1.3);
+    expect(result.candlesLow[0]).toBe(1.0);
+    expect(result.candlesHigh[0]).toBe(1.5);
   });
 
   it('should filter out null candles', () => {
@@ -100,73 +123,28 @@ describe('processPriceCandles', () => {
             close: 1.6,
           },
         ],
+        pipsLocation: 4,
       },
     };
     const result = processPriceCandles(mockData);
     expect(result.hasValidCandles).toBe(true);
     expect(result.minPrice).toBe(1.0);
     expect(result.maxPrice).toBe(1.8);
-    expect(result.candles).toHaveLength(4); // nulls are still in the array
-    expect(result.candleMap.size).toBe(2); // but not in the map
+    expect(result.pipsLocation).toBe(4);
+    expect(result.dates).toHaveLength(2);
+    expect(result.candlesOpen).toHaveLength(2);
   });
 
-  it('should populate candleMap with point as key', () => {
+  it('should return default values when all candles are null', () => {
     const mockData: GetPriceCandlesQuery = {
       priceCandles: {
-        candle: [
-          {
-            point: '2025-01-01T00:00:00Z',
-            high: 1.5,
-            low: 1.0,
-            open: 1.2,
-            close: 1.3,
-          },
-          {
-            point: '2025-01-01T01:00:00Z',
-            high: 1.8,
-            low: 1.1,
-            open: 1.4,
-            close: 1.6,
-          },
-        ],
+        candle: [null, null],
+        pipsLocation: 0,
       },
     };
     const result = processPriceCandles(mockData);
-    expect(result.candleMap.has('2025-01-01T00:00:00Z')).toBe(true);
-    expect(result.candleMap.has('2025-01-01T01:00:00Z')).toBe(true);
-    expect(result.candleMap.get('2025-01-01T00:00:00Z')).toEqual({
-      point: '2025-01-01T00:00:00Z',
-      high: 1.5,
-      low: 1.0,
-      open: 1.2,
-      close: 1.3,
-    });
-  });
-
-  it('should not add candles without point to candleMap', () => {
-    const mockData: GetPriceCandlesQuery = {
-      priceCandles: {
-        candle: [
-          {
-            point: '2025-01-01T00:00:00Z',
-            high: 1.5,
-            low: 1.0,
-            open: 1.2,
-            close: 1.3,
-          },
-          {
-            point: undefined as any,
-            high: 1.8,
-            low: 1.1,
-            open: 1.4,
-            close: 1.6,
-          },
-        ],
-      },
-    };
-    const result = processPriceCandles(mockData);
-    expect(result.candleMap.size).toBe(1);
-    expect(result.candleMap.has('2025-01-01T00:00:00Z')).toBe(true);
+    expect(result.hasValidCandles).toBe(false);
+    expect(result.dates).toHaveLength(0);
   });
 
   it('should handle candles with extreme price values', () => {
@@ -181,11 +159,13 @@ describe('processPriceCandles', () => {
             close: 750.0,
           },
         ],
+        pipsLocation: 3,
       },
     };
     const result = processPriceCandles(mockData);
     expect(result.minPrice).toBe(0.001);
     expect(result.maxPrice).toBe(1000.0);
+    expect(result.pipsLocation).toBe(3);
   });
 
   it('should handle single candle correctly', () => {
@@ -200,17 +180,19 @@ describe('processPriceCandles', () => {
             close: 1.3,
           },
         ],
+        pipsLocation: 4,
       },
     };
     const result = processPriceCandles(mockData);
     expect(result.hasValidCandles).toBe(true);
     expect(result.minPrice).toBe(1.0);
     expect(result.maxPrice).toBe(1.5);
-    expect(result.candles).toHaveLength(1);
-    expect(result.candleMap.size).toBe(1);
+    expect(result.pipsLocation).toBe(4);
+    expect(result.dates).toHaveLength(1);
+    expect(result.candlesOpen).toHaveLength(1);
   });
 
-  it('should update min/max when processing candles in sequence', () => {
+  it('should maintain order of candles', () => {
     const mockData: GetPriceCandlesQuery = {
       priceCandles: {
         candle: [
@@ -223,8 +205,8 @@ describe('processPriceCandles', () => {
           },
           {
             point: '2025-01-01T01:00:00Z',
-            high: 3.0, // new max
-            low: 0.5, // new min
+            high: 3.0,
+            low: 0.5,
             open: 2.0,
             close: 2.5,
           },
@@ -236,10 +218,54 @@ describe('processPriceCandles', () => {
             close: 1.6,
           },
         ],
+        pipsLocation: 4,
       },
     };
     const result = processPriceCandles(mockData);
     expect(result.minPrice).toBe(0.5);
     expect(result.maxPrice).toBe(3.0);
+    expect(result.pipsLocation).toBe(4);
+    expect(result.dates[0]).toBe('2025-01-01T00:00:00Z');
+    expect(result.dates[1]).toBe('2025-01-01T01:00:00Z');
+    expect(result.dates[2]).toBe('2025-01-01T02:00:00Z');
+  });
+
+  it('should handle all null candles gracefully', () => {
+    const mockData: GetPriceCandlesQuery = {
+      priceCandles: {
+        candle: [null, null, null],
+        pipsLocation: 0,
+      },
+    };
+    const result = processPriceCandles(mockData);
+    expect(result.hasValidCandles).toBe(false);
+    expect(result.dates).toHaveLength(0);
+    expect(result.minPrice).toBe(0);
+    expect(result.maxPrice).toBe(0);
+  });
+
+  it('should handle large arrays without stack overflow', () => {
+    // Create a large array of candles
+    const largeCandles = Array.from({ length: 10000 }, (_, i) => ({
+      point: `2025-01-01T${String(i).padStart(2, '0')}:00:00Z`,
+      high: 1.5 + i * 0.0001,
+      low: 1.0 + i * 0.0001,
+      open: 1.2 + i * 0.0001,
+      close: 1.3 + i * 0.0001,
+    }));
+
+    const mockData: GetPriceCandlesQuery = {
+      priceCandles: {
+        candle: largeCandles,
+        pipsLocation: 4,
+      },
+    };
+    const result = processPriceCandles(mockData);
+    expect(result.hasValidCandles).toBe(true);
+    expect(result.pipsLocation).toBe(4);
+    expect(result.dates).toHaveLength(10000);
+    // Should calculate min/max without stack overflow
+    expect(result.minPrice).toBeGreaterThan(0);
+    expect(result.maxPrice).toBeGreaterThan(result.minPrice);
   });
 });