Prototyper/test/test.rethinkData.js

'use strict';
//noinspection JSUnresolvedVariable
var libPath = process.env.PROTOTYPER_COV ? '../lib-cov' : '../lib';
var chai = require('chai');
chai.config.includeStack = true; // defaults to false
chai.config.showDiff = false; // defaults to false
var expect = chai.expect;

var rethink = require('rethinkdb');
var reConnection = null

var rethinkData = require(libPath + '/rethinkData.js');
var config = {
  debug: function () {
    //console.log(arguments);
  },
  info: function () {
    //console.log(arguments);
  },
  warn: function () {
    //console.error(arguments);
  },
  error: function () {
    console.error(arguments);
  }
};

describe('rethinkData', function () {
  beforeEach(function (done) {
    var config = {
      host: 'localhost',
      port: 28015,
      db: 'PrototyperTest'
    };
    rethink.connect(config, function connection_result(err, connection) {
      reConnection = connection
      if (err) {
        return done(err)
      }
      rethink.dbList()
        .contains(config.db)
        .do(function (containsDb) {
          return rethink.branch(
            containsDb,
            {created: 0},
            rethink.dbCreate(config.db)
          );
        })
        .run(connection, function (err) {
          return done(err);
        })
    });
  });

  afterEach(function (done) {
    reConnection.close(done)
  })

  describe('getContent', function () {

    var r = {
      contains_collection: '',
      query: null,
      tableList: function () {
        return this;
      },
      contains: function (collection) {
        this.contains_collection = collection
        this.query = null
        return this;
      },
      do: function () {
        return this;
      },
      run: function (c, callback) {
        if (this.query === null) {

          // first time run
          switch (this.contains_collection) {
            default:
              return callback(new Error('default'));
            case 'test_error':
              return callback(new Error('test_error'));
            case 'col':
              return callback(null, {exists: true});
          }
        }
        // second time run
        switch (this.query.id) {
          case 'id':
            return callback(new Error('bad_di'))
        }
      },
      filter: function (query) {
        this.query = query
      }
    };
    var option_list = [
      {}, // no collection
      {query: 'q'}, // no collection
      {collection: 'no_query'}, // no query
      {
        collection: 'no_col', // collection does not exist
        query: {id: 'id'} // not a hexString
      },
      {
        collection: 'no_hex',
        query: {id: 'id'} // not a hexString
      },
      {
        collection: 'no_col', // trigger findOne error
        query: {id: '123456789012345678901234'}
      },
      {
        collection: 'col', // trigger null result
        query: {id: '234567890123456789012345'}
      },
      {
        collection: 'col', // trigger '' result
        query: {id: '345678901234567890123456'}
      },
      {
        collection: 'ok', // trigger 'ok' result
        query: {id: '456789012345678901234567'}
      }
    ];
    var i;

    function testArguments(options, testNumber) {
      return function (done) {
        var dataInstance = rethinkData(config,
          rethink,
          reConnection);

        function handleResult(err, result) {
          // if (result === 'ok') {
          // 	expect(result).to.equal('ok');
          // 	expect(err).to.not.be.ok;
          // 	done();
          // } else {

          switch (testNumber) {
            case 0:
            case 1:
              expect(err).to.be.instanceOf(Error);
              expect(err.message).to.be.equal('Data not found / missing collection');
              expect(result).to.not.be.ok;
              return done();
            case 2:
              expect(err).to.be.instanceOf(Error);
              expect(err.message).to.be.equal('Data not found no_query / missing query');
              expect(result).to.not.be.ok;
              return done();
            case 3:
              expect(err).to.be.instanceOf(Error);
              expect(err.message).to.be.equal('Data not found no_col / {"id":"id"}');
              expect(result).to.not.be.ok;
              return done();
            case 4:
              expect(err).to.be.instanceOf(Error);
              expect(err.message).to.be.equal('Data not found no_hex / {"id":"id"}');
              expect(result).to.not.be.ok;
              return done();
            default:
              console.log('------------------------------')
              console.log('testNumber', testNumber);
              console.log('options', options);
              console.log('err', err);
              console.log('result', result);
              return done(new Error('unknown testnumber' + testNumber));
          }
        }

        switch (testNumber) {
          case 0:
          case 1:
          case 2:
          case 3:
          default:
            dataInstance.getContent(options, handleResult);
            break;
          case 4:
            dataInstance.setContent({}, options, function (err, result) {
              if (err) {
                return done(err);
              }
              dataInstance.getContent(options, handleResult);
            })
            break;
        }
      };
    }

    for (i = 0; i < option_list.length; i += 1) {
      it('should handle arguments correctly ' + JSON.stringify(option_list[i]),
        testArguments(option_list[i], i)
      );
    }
  });

  describe('getContentAttribute', function () {
    var ok = {
      id: '345678901234567890123456',
      parent: '456789012345678901234567',
      name: 'test.content_attribute'
    };

    function findOne(q, cb) {
      if (q._id && q._id.toString() === '123456789012345678901234') {
        return cb(null, {
          id: '123456789012345678901234',
          name: 'test',
          error_attribute: {
            guid: '234567890123456789012345'
          },
          content_attribute: {
            guid: '345678901234567890123456'
          }
        });
      }
      if (q.id && q.id === '234567890123456789012345') {
        return cb(new Error(q));
      }
      if (q.id && q.id === '345678901234567890123456') {
        return cb(null, ok);
      }
      if (q.id && q.id === '456789012345678901234567') {
        return cb(null, {
          id: '456789012345678901234567',
          name: 'test'
        });
      }
      if (q.parent && q.parent.toString() === '456789012345678901234567') {
        if (q.name === 'test.content_attribute') {
          return cb(null, ok);
        } else {
          return cb(new Error(q));
        }
      }
      throw new Error('fail:' + JSON.stringify(arguments));
    }

    var col = {findOne: findOne};
    var r = {
      contains_collection: '',
      tableList: function () {
        return this;
      },
      contains: function (collection) {
        this.contains_collection = collection
        return this;
      },
      do: function () {
        return this;
      },
      run: function (c, callback) {
        return callback(new Error('db fails'));
      }
    };
    var option_list = [
      {}, // no collection
      {query: 'q'}, // no collection
      {collection: 'col'}, // no query
      {
        collection: 'no_attr',
        query: {id: '123456789012345678901234'} // no attribute
      },
      {
        collection: 'col', // trigger null result
        query: {id: '123456789012345678901234'},
        attribute: 'error_attribute'
      },
      {
        collection: 'ok', // trigger 'ok' result
        query: {id: '123456789012345678901234'},
        attribute: 'content_attribute'

      },
      {
        collection: 'col', // trigger error result
        query: {id: '456789012345678901234567'},
        attribute: 'error_attribute'
      },
      {
        collection: 'ok', // trigger 'ok' result
        query: {id: '456789012345678901234567'},
        attribute: 'content_attribute'
      }
    ];
    var dataInstance = rethinkData(config, r, {});
    var i;

    function testArguments(options) {
      return function (done) {
        dataInstance.getAttribute(options, function (err, result) {
          if (options.collection === 'ok') {
            console.log('result', result);
            console.log('err', err);
            console.log('options', options);
            expect(result).to.equal(ok);
            expect(err).to.not.be.ok;
            done();
          } else {
            //console.log('err',err);
            expect(err).to.be.instanceOf(Error);
            expect(result).to.not.be.ok;
            done();
          }
        });
      };
    }

    for (i = 0; i < option_list.length; i += 1) {
      it('should handle arguments correctly ' + JSON.stringify(option_list[i]),
        testArguments(option_list[i])
      );
    }
  });
});