This code unit tests an Eloqua import service, verifying its ability to obtain a valid OAuth token, create a bulk import instance, and successfully upload data to Eloqua. It uses Sinon.js for mocking dependencies and assert for making assertions about the test results.

Run example

npm run import -- "test eloqua import service"

test eloqua import service

var assert = require('assert');
var sinon = require('sinon');
var importer = require('../Core');
var request = importer.import("http request polyfill");
var {
    eloquaOauth,
    createImportDefinition,
    startBulkImportData,
    completeBulkImportSync
} = importer.import("eloqua import service");

var {
    getEloquaConfig,
    getOauthToken,
    getImportData
} = importer.import("eloqua import blueprints");

var eloquaConfig = getEloquaConfig();
var eloquaToken = getOauthToken();
var sandbox = sinon.createSandbox();

describe('eloqua bulk upload', () => {
        
    afterEach(() => {
        sandbox.restore();
    })

    it('should get a valid oauth token', () => {
        
        const requestStub = sandbox.stub(request, "request")
            .returns(Promise.resolve({ body: {expires_in: 1000 } }));
        
        return eloquaOauth(eloquaConfig)
            .then(r => {
                assert(r.expires > (new Date()).getTime());
                assert(requestStub.calledOnce, 'request should only be called once');
            })
    })
    
    it('should create a bulk import instance', () => {
        
        const requestStub = sandbox.stub(request, "request")
            .returns(Promise.resolve({ body: {uri: '/imports/123' } }));
        
        return createImportDefinition(60, eloquaToken, eloquaConfig)
            .then(r => {
                assert(r.includes('/imports/'));
                assert(requestStub.calledOnce, 'request should only be called once');
            })
    })
    
    it('should update data to eloqua', () => {
        
        const requestStub = sandbox.stub(request, "request")
            .returns(Promise.resolve({ body: {uri: '/imports/123' }, statusCode: 204 }));
        
        return startBulkImportData([getImportData()], '/imports/123', eloquaToken, eloquaConfig)
            .then(r => {
                assert(r.statusCode === 204, 'invalid status recieved from import ' + r.statusCode);
                assert(requestStub.calledOnce, 'request should only be called once');
            })
    })
    
    it('should verify upload was successful', () => {
        var importUri;
        
        const requestStub = sandbox.stub(request, "request")
            .returns(Promise.resolve({ body: {uri: '/imports/123', status: 'success' } }));
        
        return completeBulkImportSync(importUri, eloquaToken, eloquaConfig)
            .then(r => {
                assert(r === true);
                assert(requestStub.called, 'request should only be called once');
            })
    })
    
})

// Import required modules
const assert = require('assert');
const sinon = require('sinon');
const importer = require('../Core');
const { httpPolyfill } = importer.import('http request polyfill');
const { eloquaImportService } = importer.import('eloqua import service');
const { eloquaImportBlueprints } = importer.import('eloqua import blueprints');

// Define constants
const EloquaConfig = importer.import('eloquaConfig');
const EloquaToken = importer.import('eloquaToken');
const ImportData = importer.import('importData');

// Create a sandbox for testing
const sandbox = sinon.createSandbox();

// Define a function to restore the sandbox after each test
afterEach(() => {
  sandbox.restore();
});

// Define a function to test the eloqua bulk upload functionality
describe('Eloqua Bulk Upload', () => {
  // Test that a valid oauth token is obtained
  it('should get a valid oauth token', () => {
    // Mock the request function to return a valid oauth token
    const requestStub = sandbox.stub(httpPolyfill,'request')
     .returns(Promise.resolve({ body: { expires_in: 1000 } }));

    // Call the eloquaOauth function and assert that the token is valid
    return eloquaImportService.eloquaOauth(EloquaConfig)
     .then((token) => {
        assert(token.expires > Date.now());
        assert(requestStub.calledOnce,'request should only be called once');
      });
  });

  // Test that a bulk import instance is created
  it('should create a bulk import instance', () => {
    // Mock the request function to return the import instance
    const requestStub = sandbox.stub(httpPolyfill,'request')
     .returns(Promise.resolve({ body: { uri: '/imports/123' } }));

    // Call the createImportDefinition function and assert that the import instance is created
    return eloquaImportService.createImportDefinition(60, EloquaToken, EloquaConfig)
     .then((importInstance) => {
        assert(importInstance.includes('/imports/'));
        assert(requestStub.calledOnce,'request should only be called once');
      });
  });

  // Test that data is updated to eloqua
  it('should update data to eloqua', () => {
    // Mock the request function to return the updated data
    const requestStub = sandbox.stub(httpPolyfill,'request')
     .returns(Promise.resolve({ body: { uri: '/imports/123' }, statusCode: 204 }));

    // Call the startBulkImportData function and assert that the data is updated
    return eloquaImportService.startBulkImportData([ImportData], '/imports/123', EloquaToken, EloquaConfig)
     .then((response) => {
        assert(response.statusCode === 204, 'invalid status recieved from import'+ response.statusCode);
        assert(requestStub.calledOnce,'request should only be called once');
      });
  });

  // Test that the upload is verified to be successful
  it('should verify upload was successful', () => {
    let importUri;
    // Mock the request function to return the verification response
    const requestStub = sandbox.stub(httpPolyfill,'request')
     .returns(Promise.resolve({ body: { uri: '/imports/123', status:'success' } }));

    // Call the completeBulkImportSync function and assert that the upload is successful
    return eloquaImportService.completeBulkImportSync(importUri, EloquaToken, EloquaConfig)
     .then((result) => {
        assert(result === true);
        assert(requestStub.called,'request should only be called once');
      });
  });
});

This code defines a set of unit tests for an Eloqua import service.

Here's a breakdown:

1. Setup:

   • It imports necessary modules, including assert for assertions, sinon for mocking, and Eloqua-specific modules for authentication, import operations, and data retrieval.
   • It sets up a sandbox for mocking dependencies and retrieves Eloqua configuration and an OAuth token.

2. Test Cases:

   • should get a valid oauth token:
     • Mocks the request function to simulate a successful OAuth token request.
     • Asserts that the returned token has a valid expiration time and that the request function was called only once.
   • should create a bulk import instance:
     • Mocks the request function to simulate a successful import definition creation.
     • Asserts that the returned import URI includes the expected path and that the request function was called only once.
   • should update data to eloqua:
     • Mocks the request function to simulate a successful bulk import data upload.
     • Asserts that the response status code is 204 (No Content) and that the request function was called only once.

3. Cleanup:

   • Restores the sandbox after each test case.