@skillswaveca/nova-shared-libraries 1.12.2

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

@@ -0,0 +1,118 @@
+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

@@ -0,0 +1,211 @@
+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();
+    });
+  });
+
+});

package/packages/drivers/test/wave.test.js

@@ -0,0 +1,109 @@
+import { restore, stub } from 'sinon';
+
+import { expect } from 'chai';
+import { WaveDriver } from '../src/wave.js'; // Adjust the import path as necessary
+
+describe('WaveDriver', () => {
+  let waveDriver;
+  let httpPostStub;
+
+  beforeEach(() => {
+
+    // Initialize WaveDriver with a fake configuration
+    waveDriver = new WaveDriver({
+      enabled: true,
+      baseUrl: 'https://wave.example.com',
+      secretName: 'wave-secret',
+      oauth : {
+        auth: {
+          tokenHost: 'https://token.host',
+          tokenPath: '/token',
+        },
+        client: {
+          id: 'fake-client-id',
+        },
+      },
+    });
+    waveDriver.secretsManager = {
+      getSecret: stub().resolves('fake-api-key'),
+    };
+    stub(waveDriver, 'getHeaders').resolves({});
+    // Stub the HttpDriver's post method, which is inherited by WaveDriver
+    httpPostStub = stub(waveDriver, '_fetch').resolves({
+      status: 200,
+      json: async() => ({ success: true }),
+      text: async() => 'Success',
+    });
+  });
+
+  afterEach(() => {
+    // Restore all stubs
+    restore();
+  });
+
+  it('should successfully upsert users when enabled', async() => {
+    const users = [{ tenantId: '1', name: 'User 1' }];
+
+    const result = await waveDriver.upsertUsers(users);
+
+    expect(httpPostStub.calledOnce).to.be.true;
+    expect(result).to.deep.equal(undefined);
+  });
+
+  it('should not attempt to upsert users when disabled', async() => {
+    waveDriver.enabled = false; // Disable the driver
+    const users = [{ tenantId: '1', name: 'User 1' }];
+
+    let errMsg = '';
+    try {
+      await waveDriver.upsertUsers(users);
+    } catch (err) {
+      errMsg = err.message;
+    }
+    expect(httpPostStub.called).to.be.false;
+    expect(errMsg).to.equal('Failed to upsert users in Wave:  Driver is disabled');
+  });
+
+  it('should refuse to upsert users from multiple tenants', async() => {
+    const users = [
+      { tenantId: '1', name: 'User 1' },
+      { tenantId: '2', name: 'User 2' },
+    ];
+
+    const result = await waveDriver.upsertUsers(users);
+
+    expect(httpPostStub.called).to.be.false;
+    expect(result).to.be.undefined;
+  });
+  // Test for network errors during upsert
+  it('should handle network errors gracefully', async() => {
+    httpPostStub.rejects(new Error('Network Error'));
+    const users = [{ tenantId: '1', name: 'User 1' }];
+
+    try {
+      await waveDriver.upsertUsers(users);
+      throw new Error('Expected to throw an error for network issues');
+    } catch (error) {
+      expect(error.message).to.equal('Failed to upsert users in Wave:  Network Error');
+    }
+  });
+
+  // Test for unsuccessful response status
+  it('should log an error for unsuccessful upsert response', async() => {
+    httpPostStub.resolves({
+      status: 400,
+      json: async() => ({}),
+      text: async() => 'Bad Request',
+    });
+    const users = [{ tenantId: '1', name: 'User 1' }];
+
+    try {
+      await waveDriver.upsertUsers(users);
+      throw new Error('Expected to throw an error for unsuccessful response');
+    } catch (error) {
+      expect(error.message).to.include('Failed to upsert users in Wave');
+    }
+  });
+
+  // More tests can be added here for different scenarios, such as handling errors from SecretsManager or the HTTP post method
+});

package/packages/nova-middleware/README.md

@@ -0,0 +1,5 @@
+# nova-middleware
+
+## Description
+A collection of middleware used by nova projects
+