This code unit tests the exporter module, which handles Zuora API interactions for data export, by mocking API responses and verifying expected behavior in retrieving queries and initiating exports.

Run example

npm run import -- "test zuora export month"

test zuora export month

var assert = require('assert');
var sinon = require('sinon');
var exporter = importer.import("zuora export month");
var zuoraExport = importer.import("zuora to eloqua.ipynb[0");
var renewalsQuery = importer.import("zuora renewals query");

var sandbox = sinon.createSandbox();
var zuoraConfig = {
    "rest_api_user":"devteam@fakepage.com",
    "rest_api_password":"pass",
    "rest_api_url": "http://localhost:18888"
};

describe('zuora export month', () => {
    
    afterEach(() => {
        sandbox.restore();
    })
    
    it('should get the query', () => {
        const dummyQuery = 'test query';
        
        sandbox.stub(zuoraExport, "createBulkExportJob").returns(Promise.resolve(''));
        sandbox.stub(zuoraExport, "getBulkExportJobStatus");
        sandbox.stub(zuoraExport, "getBulkExportFile");
        sandbox.stub(zuoraExport, "csvToJson").returns(Promise.resolve([]));
        const queryStub = sandbox.stub(renewalsQuery, "getQuery")
            .returns({ Query: dummyQuery });

        return exporter.getZuoraMonth(0, zuoraConfig).then(result => {
                assert.equal(result.length, 0);
                assert(queryStub.calledOnce, 'getQuery should only be called once');
                const stubCall = queryStub.getCall(0);
                assert.equal(new Date(stubCall.args[0]).getMonth(), (new Date()).getMonth());
        });
    })
    
    it('should call bulk export service', () => {
        const dummyQuery = 'test query';
        
        const exportStub = sandbox.stub(zuoraExport, "createBulkExportJob").returns(Promise.resolve(''));
        sandbox.stub(zuoraExport, "getBulkExportJobStatus");
        sandbox.stub(zuoraExport, "getBulkExportFile");
        sandbox.stub(zuoraExport, "csvToJson").returns(Promise.resolve([]));
        sandbox.stub(renewalsQuery, "getQuery")
            .returns({ Query: dummyQuery });

        return exporter.getZuoraMonth(0, zuoraConfig).then(result => {
                assert.equal(result.length, 0);
                assert(exportStub.calledOnce, 'createBulkExportJob should only be called once');
                const stubCall = exportStub.getCall(0);
                assert.equal(stubCall.args[0].Query, dummyQuery);
        });
    })
    
    it('should convert csv dump to json', () => {
        const dummyCsv = 'this,is,a,test\n1,2,3,4';
        
        sandbox.stub(zuoraExport, "createBulkExportJob").returns(Promise.resolve(''));
        sandbox.stub(zuoraExport, "getBulkExportJobStatus");
        sandbox.stub(zuoraExport, "getBulkExportFile").returns(Promise.resolve(dummyCsv));
        sandbox.stub(renewalsQuery, "getQuery").returns({ Query: 'test query' });
        
        return exporter.getZuoraMonth(0, zuoraConfig).then(result => {
                assert.equal(result[0].test, 4);
        });
    })
})

// Import required modules
const sinon = require('sinon');
const assert = require('assert');
const importer = require('./importer');

// Import required scripts
const zuoraExportMonth = importer.import('zuora export month');
const zuoraToEloqua = importer.import('zuora to eloqua.ipynb[0]');
const renewalsQuery = importer.import('zuora renewals query');

// Define constants
const ZUORA_CONFIG_KEY = 'zuoraConfig';

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

// Define the test suite
describe('Zuora Export Month', () => {
  // Clean up the sandbox after each test
  afterEach(() => {
    sandbox.restore();
  });

  // Define a helper function to get the Zuora config
  function getConfig(key = ZUORA_CONFIG_KEY) {
    return sinon.stub(zuoraExportMonth, `getConfig`).returns({ [key]: {} });
  }

  // Define a helper function to get the Zuora month data
  function getZuoraMonth(query = 'test query', config = {}, expectedLength = 0) {
    // Stub the createBulkExportJob method
    const createBulkExportJobStub = sandbox.stub(zuoraToEloqua, 'createBulkExportJob').returns(Promise.resolve(''));
    // Stub the getBulkExportJobStatus method
    sandbox.stub(zuoraToEloqua, 'getBulkExportJobStatus');
    // Stub the getBulkExportFile method
    sandbox.stub(zuoraToEloqua, 'getBulkExportFile').returns(Promise.resolve(''));
    // Stub the csvToJson method
    sandbox.stub(zuoraToEloqua, 'csvToJson').returns(Promise.resolve([]));
    // Stub the getQuery method
    sandbox.stub(renewalsQuery, 'getQuery').returns({ Query: query });

    // Call the getZuoraMonth method
    return zuoraExportMonth.getZuoraMonth(0, config).then((result) => {
      // Assert the result
      assert.equal(result.length, expectedLength);
    });
  }

  // Define a test to get the query
  it('should get the query', () => {
    // Call the getZuoraMonth method
    return getZuoraMonth().then(() => {
      // Assert that the getQuery method was called once
      const queryStub = sandbox.stub(renewalsQuery, 'getQuery');
      assert.equal(queryStub.callCount, 1);
      const stubCall = queryStub.getCall(0);
      // Assert that the query is the current month
      assert.equal(new Date(stubCall.args[0]).getMonth(), (new Date()).getMonth());
    });
  });

  // Define a test to call the bulk export service
  it('should call bulk export service', () => {
    // Call the getZuoraMonth method
    return getZuoraMonth().then(() => {
      // Assert that the createBulkExportJob method was called once
      const createBulkExportJobStub = sandbox.stub(zuoraToEloqua, 'createBulkExportJob');
      assert.equal(createBulkExportJobStub.callCount, 1);
      const stubCall = createBulkExportJobStub.getCall(0);
      // Assert that the query is the test query
      assert.equal(stubCall.args[0].Query, 'test query');
    });
  });

  // Define a test to convert the CSV dump to JSON
  it('should convert CSV dump to JSON', () => {
    // Stub the getBulkExportFile method to return a CSV string
    const csvStub = sandbox.stub(zuoraToEloqua, 'getBulkExportFile').returns(Promise.resolve('this,is,a,test\n1,2,3,4'));
    // Call the getZuoraMonth method
    return getZuoraMonth().then((result) => {
      // Assert that the result is an array with the expected length
      assert.equal(result.length, 1);
      // Assert that the first element of the result has the expected properties
      assert.equal(result[0].test, 4);
    });
  });
});

This code defines unit tests for a module named exporter that interacts with the Zuora API to export data.

Here's a breakdown:

1. Setup:

   • Imports necessary modules: assert for assertions, sinon for mocking, and modules related to Zuora API interaction (exporter, zuoraExport, renewalsQuery).
   • Creates a sandbox using sinon.createSandbox() to isolate the test environment.
   • Defines a sample zuoraConfig object with placeholder credentials.

2. Test Suite:

   • Uses describe('zuora export month', () => { ... }) to define a test suite.

3. Test Cases:

   • afterEach(() => { sandbox.restore(); }): Restores the sandbox after each test to avoid interference.
   • it('should get the query', () => { ... }):
     • Mocks functions within zuoraExport and renewalsQuery to simulate API calls and data retrieval.
     • Calls exporter.getZuoraMonth(0, zuoraConfig) to test the function.
     • Asserts that the returned result is empty and that the getQuery function was called once with the correct parameters.
   • it('should call bulk export service', () => { ... }):
     • Similar to the previous test, but focuses on verifying that the createBulkExportJob function is called once with the correct query.

4. Conclusion:

   These tests verify the functionality of the exporter module by mocking API responses and asserting the expected behavior. They cover aspects like query retrieval, API calls, and data processing.