node-deadline/test/jobs.js

Module to interface with Deadline Compute Management System by Thinkbox Software

/*jshint jasmine: true*/

var jobs = require( "../lib/jobs/jobs" ),
    enums = require( "../lib/utils/enums" ),
    test = require( "../lib/test/test" ),
    settings = require( "../lib/settings" );

describe( "option parsing", function() {

  beforeAll( function() {

    settings.test = true;

    //respond to any request with valid obj for extra info parsing
    test.onRequest = function( db, coll, query, callback ) {
      callback(
        null,
        [ test.responses.networkSettings ]
      );
    };
  } );

  afterAll( function() {
    settings.test = false;
  } );

  it( "should properly parse a bitwise enum query", function( done ) {

    //test the enum style query
    jobs.parseQuery(
      { status: enums.COMPLETED | enums.UNKNOWN },
      function( err, query ) {
        expect( query.length ).toBe( 1 );
        expect( query[ 0 ].$or ).toBeDefined();
        expect( query[ 0 ].$or.length ).toBe( 2 );
        expect( query[ 0 ].$or[ 0 ].Stat ).toBeDefined();
        done();
      } );
  } );

  it( "should properly parse a single query", function( done ) {

    //test the simple single/array queries
    jobs.parseQuery( { id: "myid" }, function( err, query ) {
      expect( query[ 0 ]._id ).toEqual( "myid" );
      done();
    } );
  } );

  it( "should properly parse an array query", function( done ) {

    jobs.parseQuery( { id: [ "myid1", "myid2" ] }, function( err, query ) {
      expect( query[ 0 ].$or ).toBeDefined();
      expect( query[ 0 ].$or[ 0 ]._id ).toEqual( "myid1" );
      expect( query[ 0 ].$or[ 1 ]._id ).toEqual( "myid2" );
      done();
    } );
  } );

  it( "should properly combine single pool queries", function( done ) {

    jobs.parseQuery( { eitherPool: "poolName" }, function( err, query ) {
      expect( query[ 0 ].$or ).toBeDefined();
      expect( query[ 0 ].$or.length ).toBe( 2 );
      done();
    } );
  } );

  it( "should properly expand array pool queries", function( done ) {

    jobs.parseQuery( { eitherPool: [ "pool1", "pool2" ] }, function( err, query ) {
      expect( query[ 0 ].$or ).toBeDefined();
      expect( query[ 0 ].$or.length ).toBe( 4 );
      done();
    } );
  } );

  it( "should parse extra info queries and understand common names", function( done ) {

    jobs.parseQuery(
      { extraInfo: { Ex0: "ex0", Ex1: [ "ex1A", "ex1B" ], "Extra Info 0": "myex" } },
      function( err, query ) {

        //the Ex0s should be translated and combined
        expect( query[ 0 ].$and[ 0 ].$or ).toEqual(
          [ { "Props.Ex0": "ex0" }, { "Props.Ex0": "myex" } ]
        );

        //the ex1s should be combined as usual
        expect( query[ 0 ].$and[ 1 ].$or ).toEqual(
          [ { "Props.Ex1": "ex1A" }, { "Props.Ex1": "ex1B" } ]
        );
        done();
      }
    );
  } );

  it( "should parse updated time queries", function( done ) {

    var before = new Date(),
        after = new Date();

    jobs.parseQuery(
      { updated: { before: before, after: after } },
      function( err, query ) {

        expect( query ).toEqual( [
          { LastWriteTime: { $lt: before } },
          { LastWriteTime: { $gt: after } }
        ] );

        done();
      }
    );
  } );

  it( "should return an error when given an unknown property", function( done ) {

    jobs.parseQuery( { uknownProperty: null }, function( err, query ) {
      expect( err ).not.toBe( null );
      done();
    } );

  } );
} );

describe( "data setting functionality", function() {

  beforeAll( function() {

    settings.test = true;

    //respond to any request with valid obj for extra info parsing
    test.onRequest = function( db, coll, query, callback ) {
      callback(
        null,
        [ test.responses.job ]
      );
    };
  } );

  afterAll( function() {
    settings.test = false;
  } );

  it( "should properly compile the updated object", function( done ) {

    //get a job
    jobs.get( {}, function( err, res ) {

      var changes, job = res[ 0 ];

      //make a change and compile
      job.priority = 0;
      changes = job._calcChanges();

      expect( changes[ "Props.Pri" ] ).toBe( 0 );
      done();

    } );

  } );

  it( "should throw an error when changing a static property", function( done ) {

    //get a job
    jobs.get( {}, function( err, res ) {

      var job = res[ 0 ];

      //errors is not allowed to be edited
      job.errors = 10;

      //wrap a function to pass jasmine
      function calc() {
        job._calcChanges();
      }

      expect( calc ).toThrow();
      done();

    } );
  } );

  it( "should produce the right call to mongo", function( done ) {

    //get a job
    jobs.get( {}, function( err, res ) {

      var job = res[ 0 ];

      //set the new response funciton
      test.onRequest = function( db, coll, query, props, callback ) {
        expect( query._id ).toEqual( test.responses.job._id );
        expect( props ).toBeDefined();
        done();
      };

      //change something and update it
      job.priority = 0;
      jobs.set( job, function( err, res ) {} );

    } );
  } );
} );