@skillswaveca/nova-shared-libraries 3.3.1 → 3.5.5

package/packages/drivers/test/.eslintrc.yaml

@@ -1,27 +0,0 @@
-extends:
-  - brightspace/testing-config
-
-rules:
-  indent:
-    - error
-    - 2
-    - SwitchCase: 1
-  no-console:
-    - off
-  sort-imports:
-    - error
-    - ignoreCase: true
-      ignoreDeclarationSort: false
-      ignoreMemberSort: false
-      memberSyntaxSortOrder:
-        - none
-        - all
-        - multiple
-        - single
-      allowSeparatedGroups: true
-  import/no-extraneous-dependencies:
-    - error
-    - devDependencies:
-        - "**/test/**/*.js"
-        - "**/*.spec.js"
-        - "**/*.test.js"

package/packages/drivers/test/aws/dynamodb.test.js

@@ -1,119 +0,0 @@
-import { expect } from 'chai';
-
-// eslint-disable-next-line import/no-extraneous-dependencies
-import sinon from 'sinon';
-
-import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
-import { DynamoDbDriver } from '../../src/aws/dynamodb.js';
-
-describe('DynamoDb', () => {
-  let dynamoDbInstance;
-  let sandbox;
-  let mockClient;
-
-  beforeEach(() => {
-    sandbox = sinon.createSandbox();
-    mockClient = {
-      send: sandbox.stub().resolves({}),
-    };
-    sandbox.stub(DynamoDBDocumentClient, 'from').returns(mockClient);
-    dynamoDbInstance = new DynamoDbDriver({});
-  });
-
-  afterEach(() => {
-    sandbox.restore();
-  });
-
-  describe('put', () => {
-    it('should call the put method of the DynamoDB client', async() => {
-      const params = { TableName: 'testTable', Item: { id: '1', value: 'test' } };
-
-      await dynamoDbInstance.put(params);
-
-      expect(mockClient.send.calledOnce).to.be.true;
-      // Ensure the PutCommand was instantiated with the correct parameters
-      const [putCommand] = mockClient.send.firstCall.args;
-      expect(putCommand.input).to.deep.equal(params);
-    });
-  });
-
-  describe('get', () => {
-    it('should call the get method of the DynamoDB client', async() => {
-      const params = { TableName: 'testTable', Key: { id: '1' } };
-
-      await dynamoDbInstance.get(params);
-
-      expect(mockClient.send.calledOnce).to.be.true;
-      const [getCommand] = mockClient.send.firstCall.args;
-      expect(getCommand.input).to.deep.equal(params);
-    });
-  });
-
-  describe('batchGet', () => {
-    it('should process batch get requests', async() => {
-      const params = {
-        RequestItems: {
-          'testTable': {
-            Keys: [{ id: '1' }, { id: '2' }],
-          },
-        },
-      };
-      mockClient.send.resolves({
-        Responses: { 'testTable': [{ id: '1', value: 'item1' }, { id: '2', value: 'item2' }] },
-        UnprocessedKeys: {},
-      });
-
-      const result = await dynamoDbInstance.batchGet(params);
-
-      expect(result).to.have.property('Responses').that.is.an('object');
-      expect(result.Responses['testTable']).to.have.lengthOf(2);
-    });
-  });
-
-  describe('delete', () => {
-    it('should call the delete method of the DynamoDB client', async() => {
-      const params = { TableName: 'testTable', Key: { id: '1' } };
-
-      await dynamoDbInstance.delete(params);
-
-      expect(mockClient.send.calledOnce).to.be.true;
-      const [deleteCommand] = mockClient.send.firstCall.args;
-      expect(deleteCommand.input).to.deep.equal(params);
-    });
-  });
-
-  describe('query', () => {
-    it('should call the query method of the DynamoDB client', async() => {
-      const params = { TableName: 'testTable', KeyConditionExpression: 'id = :id', ExpressionAttributeValues: { ':id': '1' } };
-
-      await dynamoDbInstance.query(params);
-
-      expect(mockClient.send.calledOnce).to.be.true;
-      const [queryCommand] = mockClient.send.firstCall.args;
-      expect(queryCommand.input).to.deep.equal(params);
-    });
-  });
-
-  describe('getAllResultsRecursive', () => {
-    it('should recursively fetch all items', async() => {
-      const params = { TableName: 'testTable', KeyConditionExpression: 'id = :id', ExpressionAttributeValues: { ':id': '1' } };
-      const itemsPage1 = Array(10).fill(null).map((_, index) => ({ id: `1-${index}` }));
-      const itemsPage2 = Array(5).fill(null).map((_, index) => ({ id: `2-${index}` }));
-
-      // Setup stub to simulate paginated response
-      mockClient.send.onFirstCall().resolves({
-        Items: itemsPage1,
-        LastEvaluatedKey: { id: '1-9' },
-      }).onSecondCall().resolves({
-        Items: itemsPage2,
-        LastEvaluatedKey: null, // Indicate no more pages
-      });
-
-      const results = await dynamoDbInstance.getAllResultsRecursive(params, [], undefined, 0, 0);
-
-      expect(results.length).to.equal(15);
-      expect(results).to.deep.include.members(itemsPage1);
-      expect(results).to.deep.include.members(itemsPage2);
-    });
-  });
-});

package/packages/drivers/test/aws/secrets-manager.js

@@ -1,146 +0,0 @@
-// Import the necessary libraries
-import { expect } from 'chai';
-import sinon from 'sinon';
-import { GetSecretValueCommand, SecretsManagerClient } from '@aws-sdk/client-secrets-manager';
-
-import { SecretsManager } from '../../src/aws/secrets-manager.js';
-
-describe('SecretsManager', () => {
-  let secretsManager;
-  let stubSend;
-
-  beforeEach(() => {
-    // Initialize the SecretsManager instance
-    secretsManager = new SecretsManager();
-
-    // Stub the send method of SecretsManagerClient
-    stubSend = sinon.stub(SecretsManagerClient.prototype, 'send');
-  });
-
-  afterEach(() => {
-    // Restore the stubbed send method to its original state
-    sinon.restore();
-  });
-
-  it('should fetch and return the correct secret value', async() => {
-    const secretName = 'testSecret';
-    const secretValue = 'secretValue';
-    const secretString = JSON.stringify({ [secretValue]: 'TestValue' });
-
-    stubSend.resolves({
-      SecretString: secretString,
-    });
-
-    const result = await secretsManager.getSecret(secretName);
-    expect(result).to.equal('TestValue');
-  });
-
-  it('should throw an error if secretName is not provided', async() => {
-    try {
-      await secretsManager.getSecret();
-    } catch (error) {
-      expect(error.message).to.equal('Missing secret name to fetch secret');
-    }
-  });
-
-  it('should handle and rethrow AWS SDK errors', async() => {
-    const secretName = 'invalidSecret';
-    stubSend.rejects(new Error('The requested secret does not exist'));
-
-    try {
-      await secretsManager.getSecret(secretName);
-    } catch (error) {
-      expect(error.message).to.include('SecretsManager: The requested secret does not exist');
-    }
-  });
-
-  it('should return the entire secret object if keyId is "allKeys"', async() => {
-    const secretName = 'complexSecret';
-    const secretObject = { key1: 'value1', key2: 'value2', key3: 'value3' };
-    const secretString = JSON.stringify(secretObject);
-
-    stubSend.resolves({
-      SecretString: secretString,
-    });
-
-    const result = await secretsManager.getSecret(secretName, 'allKeys');
-    expect(result).to.deep.equal(secretObject);
-  });
-
-  it('should return a specific key-value pair from the secret', async() => {
-    const secretName = 'specificKeySecret';
-    const secretObject = { specificKey: 'specificValue', otherKey: 'otherValue' };
-    const secretString = JSON.stringify(secretObject);
-
-    stubSend.resolves({
-      SecretString: secretString,
-    });
-
-    const result = await secretsManager.getSecret(secretName, 'specificKey');
-    expect(result).to.equal('specificValue');
-  });
-
-  it('should return the prod specific value if in production environment', async() => {
-    // Simulate production environment
-    secretsManager.isProdEnvironment = true;
-    const secretName = 'envSpecificSecret';
-    const secretObject = { dev: 'devValue', prod: 'prodValue' };
-    const secretString = JSON.stringify(secretObject);
-
-    stubSend.resolves({
-      SecretString: secretString,
-    });
-
-    const result = await secretsManager.getSecret(secretName);
-    expect(result).to.equal('prodValue');
-  });
-
-  it('should return the dev specific value if not in production environment', async() => {
-    // Ensure non-production environment
-    secretsManager.isProdEnvironment = false;
-    const secretName = 'envSpecificSecret';
-    const secretObject = { dev: 'devValue', unused: 'unusedValue' };
-    const secretString = JSON.stringify(secretObject);
-
-    stubSend.resolves({
-      SecretString: secretString,
-    });
-
-    const result = await secretsManager.getSecret(secretName);
-    expect(result).to.equal('devValue');
-  });
-
-  it('should throw an error if the specified keyId does not exist in the secret', async() => {
-    const secretName = 'missingKeySecret';
-    const secretObject = { existingKey: 'existingValue' };
-    const secretString = JSON.stringify(secretObject);
-
-    stubSend.resolves({
-      SecretString: secretString,
-    });
-
-    try {
-      await secretsManager.getSecret(secretName, 'nonExistingKey');
-    } catch (error) {
-      expect(error.message).to.equal('SecretsManager: nonExistingKey does not exist');
-    }
-  });
-
-  it('should log the error before rethrowing', async() => {
-    const secretName = 'erroredSecret';
-    const errorMessage = 'Simulated failure';
-    stubSend.rejects(new Error(errorMessage));
-
-    const logSpy = sinon.spy(console, 'log');
-
-    try {
-      await secretsManager.getSecret(secretName);
-    } catch (error) {
-      // The error should be logged before being rethrown
-      sinon.assert.calledWith(logSpy, sinon.match.instanceOf(Error));
-      expect(error.message).to.include(`SecretsManager: ${errorMessage}`);
-    } finally {
-      logSpy.restore();
-    }
-  });
-});

package/packages/drivers/test/http.test.js

@@ -1,118 +0,0 @@
-import { match, restore, stub } from 'sinon';
-
-import * as chai from 'chai';
-import sinonChai from 'sinon-chai';
-
-import { HttpDriver } from '../../drivers/src/http.js';
-
-chai.use(sinonChai);
-const expect = chai.expect;
-
-describe('HttpDriver', () => {
-  let httpDriver;
-  let stubFetch;
-  const baseUrl = 'http://example.com';
-  const configOverrides = { enabled: true };
-
-  beforeEach(() => {
-    httpDriver = new HttpDriver(baseUrl, configOverrides);
-    stubFetch = stub(httpDriver, '_fetch'); // Stubbing fetch
-  });
-
-  afterEach(() => {
-    restore(); // Restore original fetch function
-  });
-
-  const mockSuccess = () => {
-    return Promise.resolve({
-      status: 200,
-      json: () => Promise.resolve({ success: true }),
-    });
-  };
-
-  describe('post', () => {
-
-    const path = '/test';
-    const body = { key: 'value' };
-    const headers = { 'Custom-Header': 'HeaderValue', 'Content-Type': 'application/json' };
-
-    it('should send a POST request and return response', async() => {
-      const mockResponse = mockSuccess();
-
-      stubFetch.returns(mockResponse);
-
-      const response = await httpDriver.post(path, body, headers);
-      expect(stubFetch).to.be.calledWith(`${baseUrl}${path}`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'Custom-Header': 'HeaderValue',
-        },
-        body: JSON.stringify(body),
-      });
-      expect(response.success).to.be.true;
-    });
-
-    it('should handle a successful POST request', async() => {
-      const mockResponse = Promise.resolve({
-        status: 200,
-        json: () => Promise.resolve({ success: true, data: 'response data' }),
-      });
-      stubFetch.returns(mockResponse);
-
-      const response = await httpDriver.post(path, body, headers);
-
-      expect(stubFetch).to.have.been.calledWith(`${baseUrl}${path}`, match.has('method', 'POST'));
-      expect(response).to.deep.include({ success: true, body: { success: true, data: 'response data' } });
-    });
-
-    it('should handle a failed POST request with non-2xx status', async() => {
-      const mockResponse = Promise.resolve({
-        status: 400,
-        text: () => Promise.resolve('Bad Request'),
-      });
-      stubFetch.returns(mockResponse);
-
-      const response = await httpDriver.post(path, body, headers);
-
-      expect(response).to.deep.include({ success: false, error: 'Bad Request' });
-    });
-
-    it('should handle network or fetch errors gracefully', async() => {
-      stubFetch.rejects(new Error('Network Error'));
-
-      const response = await httpDriver.post(path, body, headers);
-
-      expect(response).to.deep.include({ success: false, error: 'Network Error' });
-    });
-
-    it('should send the correct headers and body with the POST request', async() => {
-      const mockResponse = Promise.resolve({ status: 200, json: () => Promise.resolve({ success: true }) });
-      stubFetch.returns(mockResponse);
-
-      await httpDriver.post(path, body, headers);
-
-      expect(stubFetch).to.have.been.calledWithMatch(`${baseUrl}${path}`, {
-        headers: match({
-          'Content-Type': 'application/json',
-          'Custom-Header': 'HeaderValue',
-        }),
-        body: JSON.stringify(body),
-        method: 'POST',
-      });
-    });
-
-    it('should correctly serialize JSON body for the POST request', async() => {
-      const mockResponse = Promise.resolve({ status: 200, json: () => Promise.resolve({ success: true }) });
-      stubFetch.returns(mockResponse);
-
-      const complexBody = { key: 'value', nested: { a: 1, b: true } };
-      await httpDriver.post(path, complexBody, headers);
-
-      expect(stubFetch).to.have.been.calledWithMatch(`${baseUrl}${path}`, {
-        body: JSON.stringify(complexBody),
-      });
-    });
-
-  });
-});

package/packages/drivers/test/oauth.test.js

@@ -1,211 +0,0 @@
-import { ClientCredentials } from 'simple-oauth2';
-import { expect } from 'chai';
-import { mock, restore } from 'sinon';
-
-import { apiTokenRepo } from '../../nova-model/src/repo/api-token.js';
-import { OAuthDriver } from '../src/oauth.js';
-
-describe('OAuthDriver', () => {
-  let oauthDriver;
-  let clientCredentialsMock;
-  let apiTokenRepoMock;
-
-  beforeEach(() => {
-    // Resetting stubs and mocks before each test
-    restore(); // This ensures that the environment is clean for each test.
-
-    // Mocking the client credentials instance and its methods
-    clientCredentialsMock = mock(ClientCredentials.prototype);
-    apiTokenRepoMock = mock(apiTokenRepo);
-
-    // Example tokenConfig and clientConfig for instantiation
-    const oauth = {
-      client: {
-        id: 'client-id',
-      },
-      auth: {
-        tokenHost: 'https://token.host',
-        tokenPath: '/token',
-      },
-    };
-    const tokenConfig = {};
-    const apiIdentifier = 'test-api';
-    const baseUrl = 'https://test.nova.dev.brightspace.com';
-
-    oauthDriver = new OAuthDriver(apiIdentifier, { baseUrl, oauth, tokenConfig });
-  });
-
-  afterEach(() => {
-    // Restore the default sandbox here
-    restore();
-  });
-
-  describe('getNewToken', () => {
-    it('should retrieve a new token successfully', async() => {
-      const fakeToken = {
-        token: {
-          access_token: 'access-token',
-          token_type: 'Bearer',
-          expires_in: 3600,
-        },
-      };
-
-      clientCredentialsMock.expects('getToken').once().resolves(fakeToken);
-
-      const token = await oauthDriver.getNewToken();
-      expect(token).to.deep.equal(fakeToken);
-
-      clientCredentialsMock.verify();
-    });
-  });
-
-  describe('getStoredToken', () => {
-    it('should retrieve a stored token successfully', async() => {
-      const storedTokenData = {
-        token: JSON.stringify({
-          access_token: 'stored-access-token',
-          token_type: 'Bearer',
-          expires_in: 3600,
-          expires_at: new Date(Date.now() + 3600 * 1000), // expires in 1 hour
-        }),
-      };
-
-      apiTokenRepoMock.expects('get').withArgs({ apiIdentifier: 'test-api' }).resolves(storedTokenData);
-      clientCredentialsMock.expects('createToken').once().returns(storedTokenData);
-
-      const storedToken = await oauthDriver.getStoredToken();
-      expect(storedToken).to.deep.equal(storedTokenData);
-
-      apiTokenRepoMock.verify();
-      clientCredentialsMock.verify();
-    });
-  });
-
-  describe('storeToken', () => {
-    it('should store the token successfully', async() => {
-      const tokenToStore = {
-        token: {
-          access_token: 'new-access-token',
-          token_type: 'Bearer',
-          expires_in: 3600,
-        },
-      };
-
-      apiTokenRepoMock.expects('save').once().resolves();
-
-      await oauthDriver.storeToken(tokenToStore);
-
-      apiTokenRepoMock.verify();
-    });
-  });
-
-  describe('ensureAccessToken', () => {
-    it('should use the existing token if it is not expired', async() => {
-      const existingToken = {
-        expired: () => false,
-        token: {
-          access_token: 'valid-access-token',
-          token_type: 'Bearer',
-          expires_in: 3600,
-        },
-      };
-
-      // Directly assigning a non-expired token to the instance
-      oauthDriver.accessToken = existingToken;
-
-      const accessToken = await oauthDriver.ensureAccessToken();
-      expect(accessToken).to.deep.equal(existingToken);
-    });
-
-    it('should retrieve a stored token if the current token is expired', async() => {
-      oauthDriver.accessToken = {
-        expired: () => true,
-      };
-
-      const storedToken = {
-        expired: () => false,
-        token: JSON.stringify({
-          access_token: 'stored-access-token',
-          token_type: 'Bearer',
-          expires_in: 3600,
-        }),
-      };
-
-      apiTokenRepoMock.expects('get').once().resolves(storedToken);
-      clientCredentialsMock.expects('createToken').once().returns(storedToken);
-
-      const accessToken = await oauthDriver.ensureAccessToken();
-      expect(accessToken).to.deep.equal(storedToken);
-
-      apiTokenRepoMock.verify();
-      clientCredentialsMock.verify();
-    });
-
-    it('should retrieve a new token if no valid token is available', async() => {
-      oauthDriver.accessToken = null;
-
-      const newToken = {
-        token: {
-          access_token: 'new-access-token',
-          token_type: 'Bearer',
-          expires_in: 3600,
-        },
-      };
-
-      apiTokenRepoMock.expects('get').once().resolves(null);
-      clientCredentialsMock.expects('getToken').once().resolves(newToken);
-      apiTokenRepoMock.expects('save').once().resolves();
-
-      const accessToken = await oauthDriver.ensureAccessToken();
-      expect(accessToken).to.deep.equal(newToken);
-
-      apiTokenRepoMock.verify();
-      clientCredentialsMock.verify();
-    });
-  });
-
-  describe('getHeaders', () => {
-    it('should return the correct authorization headers', async() => {
-      oauthDriver.accessToken = {
-        expired: () => false,
-        token: {
-          access_token: 'access-token',
-          token_type: 'Bearer',
-          expires_in: 3600,
-        },
-      }; // Assuming accessToken is already available
-
-      const headers = await oauthDriver.getHeaders();
-      expect(headers).to.deep.equal({
-        'Content-Type': 'application/json',
-        Authorization: 'Bearer access-token',
-      });
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('should throw an error when getting a new token fails', async() => {
-      clientCredentialsMock.expects('getToken').once().rejects(new Error('Token retrieval failed'));
-      let response;
-      try {
-        await oauthDriver.getNewToken();
-        response = 'success';
-      } catch (error) {
-        response = error.message;
-      }
-
-      expect(response).to.equal('Token retrieval failed');
-      clientCredentialsMock.verify();
-    });
-
-    it('should return undefined when stored token retrieval fails', async() => {
-      apiTokenRepoMock.expects('get').once().rejects(new Error('Token retrieval failed'));
-
-      const storedToken = await oauthDriver.getStoredToken();
-      expect(storedToken).to.be.undefined;
-
-      apiTokenRepoMock.verify();
-    });
-  });
-
-});