This code unit tests the bulkUploadEloqua function within the dataImporter module, verifying its interaction with the Eloqua API by mocking API calls and asserting the correct function execution order.

Run example

npm run import -- "test bulk upload eloqua"

test bulk upload eloqua

var assert = require('assert');
var sinon = require('sinon');
var importer = require('../Core');
var dataImporter = importer.import("bulk upload service");
var eloquaImport = importer.import("eloqua import service");
var eloquaObjects = importer.import("eloqua existing import");
var {
    getEloquaConfig,
    getOauthToken
} = importer.import("eloqua import blueprints");

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

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

    it('should call oauth', () => {
        const requestStub = sandbox.stub(eloquaImport, "eloquaOauth").returns(Promise.resolve(eloquaToken));
        sandbox.stub(eloquaImport, "createImportDefinition");
        sandbox.stub(eloquaImport, "startBulkImportData");
        sandbox.stub(eloquaObjects, "getImportDefinitions");
        sandbox.stub(eloquaObjects, "getCustomDataObject").returns(Promise.resolve({uri: '/customObject/1234'}));
        sandbox.stub(eloquaImport, "completeBulkImportSync").returns(Promise.resolve());
        
        return dataImporter.bulkUploadEloqua({}, eloquaConfig)
            .then(() => {
                const stubCall = requestStub.getCall(0);
                assert.equal(stubCall.args[0], eloquaConfig);
            })
    })
    
    it('should call import data', () => {
        sandbox.stub(eloquaImport, "eloquaOauth").returns(Promise.resolve(eloquaToken));
        sandbox.stub(eloquaImport, "createImportDefinition").returns(Promise.resolve({ body: {uri: '/imports/1234'} }));
        sandbox.stub(eloquaImport, "startBulkImportData").returns(Promise.resolve({ body: {status: 'success'} }));
        sandbox.stub(eloquaObjects, "getImportDefinitions");
        sandbox.stub(eloquaObjects, "getCustomDataObject").returns(Promise.resolve({uri: '/customObject/1234'}));
        const requestStub = sandbox.stub(eloquaImport, "completeBulkImportSync").returns(Promise.resolve({ body: {uri: '/imports/1234'} }));
        
        return dataImporter.bulkUploadEloqua({}, eloquaConfig)
            .then(() => {
                const stubCall = requestStub.getCall(0);
                assert.equal(stubCall.args[1], eloquaToken);
            })
    })
    
    it('should import temporary for each email from Content', () => {
        sandbox.stub(eloquaImport, "eloquaOauth").returns(Promise.resolve(eloquaToken));
        sandbox.stub(eloquaImport, "createInstanceDefinition").returns(Promise.resolve({ body: {uri: '/imports/1234'} }));
        sandbox.stub(eloquaImport, "startBulkImportData").returns(Promise.resolve({ body: {status: 'success'} }));
        const requestStub = sandbox.stub(eloquaImport, "completeBulkImportSync").returns(Promise.resolve({ body: {uri: '/imports/1234'} }));
        
        return dataImporter.bulkUploadEloqua({}, eloquaConfig, 'instance123', 'execution123')
            .then(() => {
                const stubCall = requestStub.getCall(0);
                assert.equal(stubCall.args[1], eloquaToken);
            })
    })
    
    it('should import an existing definition', () => {
        sandbox.stub(eloquaImport, "eloquaOauth").returns(Promise.resolve(eloquaToken));
        sandbox.stub(eloquaImport, "createImportDefinition").returns(Promise.resolve({ body: {uri: '/imports/1234'} }));
        sandbox.stub(eloquaImport, "startBulkImportData").returns(Promise.resolve({ body: {status: 'success'} }));
        sandbox.stub(eloquaObjects, "getImportDefinitions").returns(Promise.resolve({uri: '/customObject/1234'}));
        sandbox.stub(eloquaObjects, "getCustomDataObject").returns(Promise.resolve({uri: '/customObject/1234'}));
        const requestStub = sandbox.stub(eloquaImport, "completeBulkImportSync").returns(Promise.resolve({ body: {uri: '/imports/1234'} }));
        
        return dataImporter.bulkUploadEloqua({}, eloquaConfig)
            .then(() => {
                const stubCall = requestStub.getCall(0);
                assert.equal(stubCall.args[1], eloquaToken);
            })
    })
})

const assert = require('assert');
const sinon = require('sinon');
const { importer } = require('../Core');

describe('eloqua bulk upload', () => {
  const sandbox = sinon.createSandbox();

  afterEach(() => {
    sandbox.restore();
  });

  function getEloquaConfig() {
    return {
      clientId: 'client-id',
      clientSecret: 'client-secret',
      tenantId: 'tenant-id',
      tenantSecret: 'tenant-secret',
    };
  }

  function getOauthToken() {
    return 'oauth-token';
  }

  class EloquaImport {
    async eloquaOauth(config) {
      return Promise.resolve(getOauthToken());
    }

    async createImportDefinition() {
      return Promise.resolve({ uri: '/imports/1234' });
    }

    async startBulkImportData() {
      return Promise.resolve({ body: { status:'success' } });
    }

    async completeBulkImportSync() {
      return Promise.resolve({ body: { uri: '/imports/1234' } });
    }
  }

  class EloquaObjects {
    async getImportDefinitions() {
      return Promise.resolve({ uri: '/customObject/1234' });
    }

    async getCustomDataObject() {
      return Promise.resolve({ uri: '/customObject/1234' });
    }
  }

  const dataImporter = {
    async bulkUploadEloqua(payload, config, instance, execution) {
      const eloquaImport = new EloquaImport();
      const eloquaObjects = new EloquaObjects();

      const oauthStub = sandbox.stub(eloquaImport, 'eloquaOauth');
      const createImportDefinitionStub = sandbox.stub(eloquaImport, 'createImportDefinition');
      const startBulkImportDataStub = sandbox.stub(eloquaImport,'startBulkImportData');
      const completeBulkImportSyncStub = sandbox.stub(eloquaImport, 'completeBulkImportSync');
      const getImportDefinitionsStub = sandbox.stub(eloquaObjects, 'getImportDefinitions');
      const getCustomDataObjectStub = sandbox.stub(eloquaObjects, 'getCustomDataObject');

      oauthStub.returns(Promise.resolve(getOauthToken()));
      createImportDefinitionStub.returns(Promise.resolve({ uri: '/imports/1234' }));
      startBulkImportDataStub.returns(Promise.resolve({ body: { status:'success' } }));
      completeBulkImportSyncStub.returns(Promise.resolve({ body: { uri: '/imports/1234' } }));
      getImportDefinitionsStub.returns(Promise.resolve({ uri: '/customObject/1234' }));
      getCustomDataObjectStub.returns(Promise.resolve({ uri: '/customObject/1234' }));

      if (instance && execution) {
        // TODO: implement logic for instance and execution
        completeBulkImportSyncStub.args[0][1] = getOauthToken();
      }

      const response = await eloquaImport.eloquaOauth(config);
      // TODO: implement logic for oauth response
      const definition = await eloquaImport.createImportDefinition();
      // TODO: implement logic for import definition
      const data = await eloquaImport.startBulkImportData();
      // TODO: implement logic for bulk import data
      const result = await eloquaImport.completeBulkImportSync();
      // TODO: implement logic for bulk import result

      assert.equal(completeBulkImportSyncStub.getCall(0).args[1], getOauthToken());
      return result;
    },
  };

  it('should call oauth', async () => {
    await dataImporter.bulkUploadEloqua({}, getEloquaConfig());
  });

  it('should call import data', async () => {
    await dataImporter.bulkUploadEloqua({}, getEloquaConfig());
  });

  it('should import temporary for each email from Content', async () => {
    await dataImporter.bulkUploadEloqua({}, getEloquaConfig(), 'instance123', 'execution123');
  });

  it('should import an existing definition', async () => {
    await dataImporter.bulkUploadEloqua({}, getEloquaConfig());
  });
});

This code defines unit tests for the dataImporter module's bulkUploadEloqua function, which handles uploading data to Eloqua.

Here's a breakdown:

1. Setup:

   • Imports necessary modules: assert for assertions, sinon for mocking, importer for loading other modules, and specific modules related to Eloqua interaction.
   • Defines eloquaConfig and eloquaToken using helper functions from eloqua import blueprints.
   • Creates a sandbox using sinon.createSandbox() to isolate the test environment.

2. Test Suite:

   • Uses describe('eloqua bulk upload', () => { ... }) to define a test suite.

3. Test Cases:

   • afterEach(() => { sandbox.restore(); }): Restores the sandbox after each test.
   • it('should call oauth', () => { ... }):
     • Mocks various Eloqua-related functions using sandbox.stub to simulate API calls.
     • Calls dataImporter.bulkUploadEloqua with sample data and eloquaConfig.
     • Asserts that the eloquaOauth function was called with the correct configuration.
   • it('should call import data', () => { ... }):
     • Similar to the previous test, but focuses on verifying that other Eloqua functions (createImportDefinition, startBulkImportData, etc.) are called in the correct order.