Update integration test setup

package.json

@@ -18,9 +18,8 @@
     "format": "prettier --write .",
     "lint": "eslint src/ --ext .ts",
     "repl": "npm run build && node utils/replInit.ts",
-    "test:legacy": "jest --runInBand --detectOpenHandles tests/legacy-integration/",
-    "test:integration": "jest tests/integration/ --setupFilesAfterEnv ./utils/globalIntegrationTestSetup.ts",
-    "test:unit": "jest src/ --setupFilesAfterEnv ./utils/globalUnitTestSetup.ts"
+    "test:integration": "jest src/integration --setupFilesAfterEnv ./utils/globalIntegrationTestSetup.ts",
+    "test:unit": "jest src/ --setupFilesAfterEnv ./utils/globalUnitTestSetup.ts --testPathIgnorePatterns src/integration"
   },
   "engines": {
     "node": ">=14.0.0"

src/__tests__/pinecone.test.ts

@@ -1,5 +1,13 @@
 import { Pinecone } from '../pinecone';
 import type { PineconeConfiguration } from '../data';
+import crossFetch from 'cross-fetch';
+
+jest.mock('cross-fetch', () => {
+  return {
+    __esModule: true,
+    default: jest.fn(),
+  };
+});
 
 jest.mock('../data/fetch');
 jest.mock('../data/upsert');
@@ -96,7 +104,7 @@ describe('Pinecone', () => {
         const client = new Pinecone();
 
         expect(client.getConfig().projectId).toEqual('test-project');
-        expect(global.fetch).not.toHaveBeenCalled();
+        expect(crossFetch).not.toHaveBeenCalled();
       });
 
       test('config object should take precedence when both config object and environment variables are provided', () => {

src/data/__tests__/projectIdSingleton.test.ts

@@ -1,4 +1,12 @@
 import { ProjectIdSingleton } from '../projectIdSingleton';
+import crossFetch from 'cross-fetch';
+
+jest.mock('cross-fetch', () => {
+  return {
+    __esModule: true,
+    default: jest.fn(),
+  };
+});
 
 describe('ProjectIdSingleton', () => {
   afterEach(() => {
@@ -7,12 +15,10 @@ describe('ProjectIdSingleton', () => {
 
   test('issues whoami requests for unknown projectId', async () => {
     // @ts-ignore
-    global.fetch = jest.fn(() =>
-      Promise.resolve({
-        status: 200,
-        json: () => Promise.resolve({ project_name: 'abcdef' }),
-      })
-    );
+    crossFetch.mockResolvedValue({
+      status: 200,
+      json: () => Promise.resolve({ project_name: 'abcdef' }),
+    });
 
     const testApiKey = 'api-key-1';
     const testConfig = {
@@ -23,7 +29,7 @@ describe('ProjectIdSingleton', () => {
     const id = await ProjectIdSingleton.getProjectId(testConfig);
 
     expect(id).toEqual('abcdef');
-    expect(global.fetch).toHaveBeenCalledWith(
+    expect(crossFetch).toHaveBeenCalledWith(
       'https://controller.gcp-free.pinecone.io/actions/whoami',
       {
         headers: {
@@ -38,12 +44,10 @@ describe('ProjectIdSingleton', () => {
 
   test('only makes API call once per api key', async () => {
     // @ts-ignore
-    global.fetch = jest.fn(() =>
-      Promise.resolve({
-        status: 200,
-        json: () => Promise.resolve({ project_name: 'xyzxyz' }),
-      })
-    );
+    crossFetch.mockResolvedValue({
+      status: 200,
+      json: () => Promise.resolve({ project_name: 'xyzxyz' }),
+    });
 
     const testApiKey = 'api-key-2';
     const testConfig2 = {
@@ -53,15 +57,15 @@ describe('ProjectIdSingleton', () => {
 
     const id = await ProjectIdSingleton.getProjectId(testConfig2);
     expect(id).toEqual('xyzxyz');
-    expect(global.fetch).toHaveBeenCalledTimes(1);
+    expect(crossFetch).toHaveBeenCalledTimes(1);
 
     const id2 = await ProjectIdSingleton.getProjectId(testConfig2);
     expect(id2).toEqual('xyzxyz');
-    expect(global.fetch).toHaveBeenCalledTimes(1);
+    expect(crossFetch).toHaveBeenCalledTimes(1);
 
     await ProjectIdSingleton.getProjectId(testConfig2);
     await ProjectIdSingleton.getProjectId(testConfig2);
     await ProjectIdSingleton.getProjectId(testConfig2);
-    expect(global.fetch).toHaveBeenCalledTimes(1);
+    expect(crossFetch).toHaveBeenCalledTimes(1);
   });
 });

src/data/projectIdSingleton.ts

@@ -6,6 +6,7 @@ import {
 } from '../errors';
 import type { PineconeConfiguration } from './types';
 import { buildUserAgent } from '../utils';
+import fetch from 'cross-fetch';
 
 // We only ever want to call whoami a maximum of once per API key, even if there
 // are multiple instantiations of the Index class. So we use a singleton here

src/data/vectorOperationsProvider.ts

@@ -6,6 +6,7 @@ import {
 } from '../pinecone-generated-ts-fetch';
 import { queryParamsStringify, buildUserAgent } from '../utils';
 import { ProjectIdSingleton } from './projectIdSingleton';
+import fetch from 'cross-fetch';
 
 const basePath = (config: PineconeConfiguration, indexName: string) =>
   `https://${indexName}-${config.projectId}.svc.${config.environment}.pinecone.io`;
@@ -51,6 +52,7 @@ export class VectorOperationsProvider {
       headers: {
         'User-Agent': buildUserAgent(false),
       },
+      fetchApi: fetch,
     };
 
     const indexConfiguration = new Configuration(indexConfigurationParameters);

src/errors/config.ts

@@ -30,7 +30,7 @@ export class PineconeEnvironmentVarsNotSupportedError extends BasePineconeError
 export class PineconeUnknownRequestFailure extends BasePineconeError {
   constructor(url: string, underlyingError: Error) {
     const message = `Something went wrong while attempting to call ${url}. Please check your configuration and try again later. Underlying error was ${JSON.stringify(
-      underlyingError
+      underlyingError.message
     )}`;
     super(message);
     this.name = 'PineconeUnknownRequestFailure';

src/integration/data/deleteMany.test.ts

@@ -0,0 +1,89 @@
+import { Pinecone, Index } from '../../index';
+import {
+  randomString,
+  createIndexIfDoesNotExist,
+  generateRecords,
+} from '../test-helpers';
+
+describe('deleteMany', () => {
+  const INDEX_NAME = 'ts-integration';
+  let pinecone: Pinecone, index: Index, ns: Index, namespace: string;
+
+  beforeAll(async () => {
+    pinecone = new Pinecone();
+
+    await createIndexIfDoesNotExist(pinecone, INDEX_NAME);
+
+    namespace = randomString(16);
+    index = pinecone.index(INDEX_NAME);
+    ns = index.namespace(namespace);
+  });
+
+  afterAll(async () => {
+    await pinecone.listIndexes();
+    await ns.deleteAll();
+  });
+
+  test('verify deleteMany with ids', async () => {
+    const recordsToUpsert = generateRecords(5, 3);
+    await ns.upsert(recordsToUpsert);
+
+    // Check records got upserted
+    let stats = await ns.describeIndexStats();
+    if (stats.namespaces) {
+      expect(stats.namespaces[namespace].recordCount).toEqual(3);
+    } else {
+      fail('Expected namespaces to be defined');
+    }
+
+    // Look more closely at one of the records to make sure values set
+    const fetchResult = await ns.fetch(['0']);
+    const records = fetchResult.records;
+    if (records) {
+      expect(records['0'].id).toEqual('0');
+      expect(records['0'].values.length).toEqual(5);
+    } else {
+      fail(
+        'Did not find expected records. Fetch result was ' +
+          JSON.stringify(fetchResult)
+      );
+    }
+
+    // Try deleting 2 of 3 vectors
+    await ns.deleteMany(['0', '2']);
+    stats = await ns.describeIndexStats();
+    if (stats.namespaces) {
+      expect(stats.namespaces[namespace].recordCount).toEqual(1);
+    } else {
+      fail(
+        'Expected namespaces to be defined (second call). Stats were ' +
+          JSON.stringify(stats)
+      );
+    }
+
+    // Check that record 1 still exists
+    const fetchResult2 = await ns.fetch(['1']);
+    const records2 = fetchResult2.records;
+    if (records2) {
+      expect(records2['1']).not.toBeUndefined();
+    } else {
+      fail(
+        'Expected record 2 to be defined. Fetch result was ' +
+          JSON.stringify(fetchResult2)
+      );
+    }
+
+    // deleting non-existent indexes should not throw
+    await ns.deleteMany(['0', '1', '2', '3']);
+
+    // Verify all are now removed
+    stats = await ns.describeIndexStats();
+    if (stats.namespaces) {
+      expect(stats.namespaces[namespace]).toBeUndefined();
+    } else {
+      // no-op. This should actually happen unless there
+      // are leftover namespaces from previous runs that
+      // failed or stopped without proper cleanup.
+    }
+  });
+});

tests/integration/initialization.test.ts → src/integration/initialization.test.ts

@@ -1,4 +1,4 @@
-import { Pinecone } from '../../dist';
+import { Pinecone } from '../index';
 
 describe('Client initialization', () => {
   test('can accept a config object', () => {

src/integration/test-helpers.ts

@@ -0,0 +1,76 @@
+import { Pinecone } from '../index';
+import type { PineconeRecord, RecordSparseValues } from '../index';
+
+export const randomString = (length) => {
+  const characters =
+    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+  let result = '';
+
+  for (let i = 0; i < length; i++) {
+    const randomIndex = Math.floor(Math.random() * characters.length);
+    result += characters.charAt(randomIndex);
+  }
+
+  return result;
+};
+
+export const createIndexIfDoesNotExist = async (
+  pinecone: Pinecone,
+  indexName: string
+) => {
+  const indexList = await pinecone.listIndexes();
+  let found = false;
+  indexList.forEach((i) => {
+    if (i.name === indexName) {
+      found = true;
+    }
+  });
+  if (!found) {
+    await pinecone.createIndex({
+      name: indexName,
+      dimension: 5,
+      waitUntilReady: true,
+    });
+  }
+};
+
+export const generateRecords = (
+  dimension: number,
+  quantity: number,
+  withSparseValues?: boolean
+): PineconeRecord[] => {
+  const vectors: PineconeRecord[] = [];
+  for (let i = 0; i < quantity; i++) {
+    const values: number[] = [];
+    for (let j = 0; j < dimension; j++) {
+      values.push(Math.random());
+    }
+    let vector: PineconeRecord = {
+      id: i.toString(),
+      values,
+    };
+    if (withSparseValues) {
+      vector = {
+        ...vector,
+        sparseValues: generateSparseValues(dimension),
+      };
+    }
+
+    vectors.push(vector);
+  }
+  return vectors;
+};
+
+export const generateSparseValues = (dimension: number): RecordSparseValues => {
+  const values: number[] = [];
+  const indecies: number[] = [];
+  for (let j = 0; j < dimension; j++) {
+    values.push(Math.random());
+    indecies.push(j);
+  }
+  const sparseValues: RecordSparseValues = {
+    indices: indecies,
+    values: values,
+  };
+  return sparseValues;
+};

src/pinecone.ts

@@ -22,6 +22,7 @@ import { Index, PineconeConfigurationSchema } from './data';
 import { buildValidator } from './validator';
 import { queryParamsStringify, buildUserAgent } from './utils';
 import type { PineconeConfiguration, RecordMetadata } from './data';
+import fetch from 'cross-fetch';
 
 /**
  * @example
@@ -62,6 +63,7 @@ export class Pinecone {
       headers: {
         'User-Agent': buildUserAgent(false),
       },
+      fetchApi: fetch,
     };
     const api = new IndexOperationsApi(new ApiConfiguration(apiConfig));