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

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);
   });
 });

package/test/utils/validateData.test.ts

@@ -27,40 +27,55 @@ describe('validateData', () => {
                 close: 1.3,
               },
             ],
+      pipsLocation: 0,
     },
   });
 
   const createMockOrderPositionData = (
     books?: Array<{
-      bucketWidth: number;
-      price?: number | null;
+      __typename?: 'OrderPositionData';
       time: string;
-      buckets: Array<{ price: number; sentiment: number }>;
-    } | null>
+      price?: number | null;
+      buckets: Array<{
+        __typename?: 'OrderPositionBucket';
+        price: number;
+        sentiment?: number | null;
+      } | null>;
+    }>
   ): GetOrderPositionBooksQuery => ({
-    orderPositionBooks:
-      books !== undefined
-        ? books
-        : [
-            {
-              bucketWidth: 0.0005,
-              price: 1.0,
-              time: '2025-01-01',
-              buckets: [{ price: 1.0, sentiment: 0.2 }],
-            },
-          ],
+    orderPositionBooks: {
+      books:
+        books !== undefined
+          ? books
+          : [
+              {
+                time: '2025-01-01T00:00:00Z',
+                price: 1.0,
+                buckets: [{ price: 1.0, sentiment: 0.2 }],
+              },
+            ],
+      bucketWidth: 0.0005,
+      sentimentThresholdMin: 0.15,
+      sentimentThresholdMax: 0.55,
+    },
   });
 
   it('should return null when all data is valid', () => {
     const priceCandlesData = createMockPriceCandlesData();
     const orderPositionData = createMockOrderPositionData();
-    const result = validateData(priceCandlesData, orderPositionData, true);
+    const result = validateData(
+      priceCandlesData,
+      orderPositionData,
+      true,
+      true,
+      true
+    );
     expect(result).toBeNull();
   });
 
   it('should return error when priceCandlesData is undefined', () => {
     const orderPositionData = createMockOrderPositionData();
-    const result = validateData(undefined, orderPositionData, true);
+    const result = validateData(undefined, orderPositionData, true, true, true);
     expect(result).toBeInstanceOf(Error);
     expect(result?.message).toBe('Insufficient price candle data');
   });
@@ -70,7 +85,13 @@ describe('validateData', () => {
       priceCandles: {} as any,
     };
     const orderPositionData = createMockOrderPositionData();
-    const result = validateData(priceCandlesData, orderPositionData, true);
+    const result = validateData(
+      priceCandlesData,
+      orderPositionData,
+      true,
+      true,
+      true
+    );
     expect(result).toBeInstanceOf(Error);
     expect(result?.message).toBe('Insufficient price candle data');
   });
@@ -78,7 +99,13 @@ describe('validateData', () => {
   it('should return error when candle array is empty', () => {
     const priceCandlesData = createMockPriceCandlesData([]);
     const orderPositionData = createMockOrderPositionData();
-    const result = validateData(priceCandlesData, orderPositionData, true);
+    const result = validateData(
+      priceCandlesData,
+      orderPositionData,
+      true,
+      true,
+      true
+    );
     expect(result).toBeInstanceOf(Error);
     expect(result?.message).toBe('Insufficient price candle data');
   });
@@ -89,24 +116,41 @@ describe('validateData', () => {
     // The hasValidCandles parameter handles content validation
     const priceCandlesData = createMockPriceCandlesData([null, null]);
     const orderPositionData = createMockOrderPositionData();
-    const result = validateData(priceCandlesData, orderPositionData, true);
-    // Array length >= 1, so it passes length check, but hasValidCandles should be false
+    const result = validateData(
+      priceCandlesData,
+      orderPositionData,
+      true,
+      true,
+      true
+    );
+    // Array length >= 1, so it passes length check
     expect(result).toBeNull();
   });
 
   it('should return error when orderPositionData is undefined', () => {
     const priceCandlesData = createMockPriceCandlesData();
-    const result = validateData(priceCandlesData, undefined, true);
+    const result = validateData(priceCandlesData, undefined, true, true, true);
     expect(result).toBeInstanceOf(Error);
     expect(result?.message).toBe('Insufficient order position data');
   });
 
-  it('should return error when orderPositionBooks is empty', () => {
+  it('should return error when orderPositionBooks.books is empty', () => {
     const priceCandlesData = createMockPriceCandlesData();
     const orderPositionData: GetOrderPositionBooksQuery = {
-      orderPositionBooks: [],
+      orderPositionBooks: {
+        books: [],
+        bucketWidth: 0.0005,
+        sentimentThresholdMin: 0.15,
+        sentimentThresholdMax: 0.55,
+      },
     };
-    const result = validateData(priceCandlesData, orderPositionData, true);
+    const result = validateData(
+      priceCandlesData,
+      orderPositionData,
+      true,
+      true,
+      true
+    );
     expect(result).toBeInstanceOf(Error);
     expect(result?.message).toBe('Insufficient order position data');
   });
@@ -114,30 +158,75 @@ describe('validateData', () => {
   it('should return error when hasValidCandles is false', () => {
     const priceCandlesData = createMockPriceCandlesData();
     const orderPositionData = createMockOrderPositionData();
-    const result = validateData(priceCandlesData, orderPositionData, false);
+    const result = validateData(
+      priceCandlesData,
+      orderPositionData,
+      false,
+      true,
+      true
+    );
     expect(result).toBeInstanceOf(Error);
     expect(result?.message).toBe('Invalid candle data');
   });
 
+  it('should return error when hasValidBooks is false', () => {
+    const priceCandlesData = createMockPriceCandlesData();
+    const orderPositionData = createMockOrderPositionData();
+    const result = validateData(
+      priceCandlesData,
+      orderPositionData,
+      true,
+      false,
+      true
+    );
+    expect(result).toBeInstanceOf(Error);
+    expect(result?.message).toBe('Invalid book data');
+  });
+
+  it('should return error when hasValidSentiments is false', () => {
+    const priceCandlesData = createMockPriceCandlesData();
+    const orderPositionData = createMockOrderPositionData();
+    const result = validateData(
+      priceCandlesData,
+      orderPositionData,
+      true,
+      true,
+      false
+    );
+    expect(result).toBeInstanceOf(Error);
+    expect(result?.message).toBe('Invalid sentiment data');
+  });
+
   it('should prioritize price candle error over order position error', () => {
     const orderPositionData: GetOrderPositionBooksQuery = {
-      orderPositionBooks: [],
+      orderPositionBooks: {
+        books: [],
+        bucketWidth: 0.0005,
+        sentimentThresholdMin: 0.15,
+        sentimentThresholdMax: 0.55,
+      },
     };
-    const result = validateData(undefined, orderPositionData, true);
+    const result = validateData(undefined, orderPositionData, true, true, true);
     expect(result).toBeInstanceOf(Error);
     expect(result?.message).toBe('Insufficient price candle data');
   });
 
   it('should prioritize price candle error over hasValidCandles error', () => {
     const orderPositionData = createMockOrderPositionData();
-    const result = validateData(undefined, orderPositionData, false);
+    const result = validateData(
+      undefined,
+      orderPositionData,
+      false,
+      true,
+      true
+    );
     expect(result).toBeInstanceOf(Error);
     expect(result?.message).toBe('Insufficient price candle data');
   });
 
   it('should prioritize order position error over hasValidCandles error', () => {
     const priceCandlesData = createMockPriceCandlesData();
-    const result = validateData(priceCandlesData, undefined, false);
+    const result = validateData(priceCandlesData, undefined, false, true, true);
     expect(result).toBeInstanceOf(Error);
     expect(result?.message).toBe('Insufficient order position data');
   });
@@ -154,13 +243,18 @@ describe('validateData', () => {
     ]);
     const orderPositionData = createMockOrderPositionData([
       {
-        bucketWidth: 0.0005,
+        time: '2025-01-01T00:00:00Z',
         price: 1.0,
-        time: '2025-01-01',
         buckets: [{ price: 1.0, sentiment: 0.2 }],
       },
     ]);
-    const result = validateData(priceCandlesData, orderPositionData, true);
+    const result = validateData(
+      priceCandlesData,
+      orderPositionData,
+      true,
+      true,
+      true
+    );
     expect(result).toBeNull();
   });
 
@@ -183,19 +277,23 @@ describe('validateData', () => {
     ]);
     const orderPositionData = createMockOrderPositionData([
       {
-        bucketWidth: 0.0005,
+        time: '2025-01-01T00:00:00Z',
         price: 1.0,
-        time: '2025-01-01',
         buckets: [{ price: 1.0, sentiment: 0.2 }],
       },
       {
-        bucketWidth: 0.0005,
+        time: '2025-01-01T01:00:00Z',
         price: 1.1,
-        time: '2025-01-02',
         buckets: [{ price: 1.1, sentiment: 0.3 }],
       },
     ]);
-    const result = validateData(priceCandlesData, orderPositionData, true);
+    const result = validateData(
+      priceCandlesData,
+      orderPositionData,
+      true,
+      true,
+      true
+    );
     expect(result).toBeNull();
   });
 });