conditional/lib/test/contains_test.js

A preconditions package based on Google's Preconditions library

(function() {
  var IllegalArgumentError, UnknownValueError, checkContains;

  require('./helpers/test_helper');

  checkContains = preconditions.checkContains, UnknownValueError = preconditions.UnknownValueError, IllegalArgumentError = preconditions.IllegalArgumentError;

  describe('test contains precondition', function() {
    describe('tests with strings', function() {
      it('string array test', function() {
        var wrapper;
        wrapper = function() {
          return checkContains('a', ['a', 'b', 'c']);
        };
        return assert.doesNotThrow(wrapper);
      });
      it('empty string test', function() {
        var wrapper;
        wrapper = function() {
          return checkContains('', ['a', 'b', ''], 'empty string present');
        };
        return assert.doesNotThrow(wrapper);
      });
      it('string and number are different types', function() {
        var wrapper;
        wrapper = function() {
          return checkContains('5', ['a', 'b', 5], '5 not present');
        };
        assert.throws(wrapper, UnknownValueError, '5 not present');
        wrapper = function() {
          return checkContains(5, ['a', 'b', '5'], '5 not present');
        };
        return assert.throws(wrapper, UnknownValueError, '5 not present');
      });
      it('unequal string do not contain each other', function() {
        var wrapper;
        wrapper = function() {
          return checkContains('random', 'string');
        };
        return assert.throws(wrapper, UnknownValueError, "unknown value 'random'");
      });
      it('equal strings also contain each other', function() {
        var wrapper;
        wrapper = function() {
          return checkContains('string', 'string');
        };
        return assert.doesNotThrow;
      });
      it('substring of a string', function() {
        var wrapper;
        wrapper = function() {
          return checkContains('str', 'string');
        };
        return assert.doesNotThrow;
      });
      it('empty string can contain empty string', function() {
        var wrapper;
        wrapper = function() {
          return checkContains('', '');
        };
        return assert.doesNotThrow(wrapper);
      });
      return it('empty string cannot contain non-empty string', function() {
        var wrapper;
        wrapper = function() {
          return checkContains('str', '');
        };
        return assert.throws(wrapper, UnknownValueError, "unknown value 'str'");
      });
    });
    describe('tests for null values', function() {
      it('null value test', function() {
        var wrapper;
        wrapper = function() {
          return checkContains(null, ['a', 'b', 'null'], 'null value missing');
        };
        assert.throws(wrapper, UnknownValueError, 'null value missing');
        wrapper = function() {
          return checkContains(null, ['a', 'b', null], 'null value present');
        };
        return assert.doesNotThrow(wrapper);
      });
      it('null and 0 are not same', function() {
        var wrapper;
        wrapper = function() {
          return checkContains(null, ['a', 'b', 0], 'null not present');
        };
        assert.throws(wrapper, UnknownValueError, 'null not present');
        wrapper = function() {
          return checkContains(0, ['a', 'b', null], '0 not present');
        };
        return assert.throws(wrapper, UnknownValueError, '0 not present');
      });
      it('IllegalArgumentError is thrown for null collection object', function() {
        var wrapper;
        wrapper = function() {
          return checkContains('a', null, 'this message is hidden');
        };
        return assert.throws(wrapper, IllegalArgumentError, 'invalid collection value');
      });
      return it('null is not same as empty string', function() {
        var wrapper;
        wrapper = function() {
          return checkContains(null, '');
        };
        return assert.throws(wrapper, UnknownValueError, "unknown value 'null'");
      });
    });
    describe('tests for objects', function() {
      it('object can be checked in array', function() {
        var obj1, obj2, obj3, wrapper;
        obj1 = [1];
        obj2 = {
          'test': 'test'
        };
        obj3 = null;
        wrapper = function() {
          checkContains(obj1, [obj1, obj2, obj3]);
          checkContains(obj2, [obj1, obj2, obj3]);
          return checkContains(obj3, [obj1, obj2, obj3]);
        };
        return assert.doesNotThrow(wrapper);
      });
      it('a hash map can contain string keys', function() {
        var map, wrapper;
        map = {
          val1: 1,
          val2: 2,
          val3: 3
        };
        wrapper = function() {
          return checkContains('val1', map);
        };
        return assert.doesNotThrow(wrapper);
      });
      return it('a hash map can contain number keys', function() {
        var map, wrapper;
        map = {
          1: 1,
          2: 2,
          3: 3
        };
        wrapper = function() {
          return checkContains(1, map);
        };
        return assert.doesNotThrow(wrapper);
      });
    });
    return describe('tests for numbers', function() {
      it('check number contains another', function() {
        var wrapper;
        wrapper = function() {
          return checkContains(1, 123);
        };
        return assert.doesNotThrow(wrapper);
      });
      it('check number not present in another number', function() {
        var wrapper;
        wrapper = function() {
          return checkContains(4, 123);
        };
        return assert.throws(wrapper, UnknownValueError, "unknown value '4'");
      });
      it('check string contained in number', function() {
        var wrapper;
        wrapper = function() {
          return checkContains('1', 123);
        };
        return assert.doesNotThrow(wrapper);
      });
      return it('check string missing from number', function() {
        var wrapper;
        wrapper = function() {
          return checkContains('4', 123);
        };
        return assert.throws(wrapper, UnknownValueError, "unknown value '4'");
      });
    });
  });

}).call(this);