hash_test.js

new Test.Unit.Runner({
  testSet: function() {
    var h = $H({a: 'A'})

    this.assertEqual('B', h.set('b', 'B'));
    this.assertHashEqual({a: 'A', b: 'B'}, h);
    this.assertUndefined(h.set('c'));
    this.assertHashEqual({a: 'A', b: 'B', c: undefined}, h);
  },

  testGet: function() {
    var h = $H({a: 'A'});
    this.assertEqual('A', h.get('a'));
    this.assertUndefined(h.a);
    this.assertUndefined($H({}).get('a'));

    this.assertUndefined($H({}).get('toString'));
    this.assertUndefined($H({}).get('constructor'));
  },
  
  testUnset: function() {
    var hash = $H(Fixtures.many);
    this.assertEqual('B', hash.unset('b'));
    this.assertHashEqual({a:'A', c: 'C', d:'D#'}, hash);
    this.assertUndefined(hash.unset('z'));
    this.assertHashEqual({a:'A', c: 'C', d:'D#'}, hash);
    // not equivalent to Hash#remove
    this.assertEqual('A', hash.unset('a', 'c'));
    this.assertHashEqual({c: 'C', d:'D#'}, hash);
  },
  
  testToObject: function() {
    var hash = $H(Fixtures.many), object = hash.toObject();
    this.assertInstanceOf(Object, object);
    this.assertHashEqual(Fixtures.many, object);
    this.assertNotIdentical(Fixtures.many, object);
    hash.set('foo', 'bar');
    this.assertHashNotEqual(object, hash.toObject());
  },
  
  testConstruct: function() {
    var object = Object.clone(Fixtures.one);
    var h = new Hash(object), h2 = $H(object);
    this.assertInstanceOf(Hash, h);
    this.assertInstanceOf(Hash, h2);
    
    this.assertHashEqual({}, new Hash());
    this.assertHashEqual(object, h);
    this.assertHashEqual(object, h2);
    
    h.set('foo', 'bar');
    this.assertHashNotEqual(object, h);
    
    var clone = $H(h);
    this.assertInstanceOf(Hash, clone);
    this.assertHashEqual(h, clone);
    h.set('foo', 'foo');
    this.assertHashNotEqual(h, clone);
    this.assertIdentical($H, Hash.from);
  },
  
  testKeys: function() {
    this.assertEnumEqual([],               $H({}).keys());
    this.assertEnumEqual(['a'],            $H(Fixtures.one).keys());
    this.assertEnumEqual($w('a b c d'),    $H(Fixtures.many).keys().sort());
    this.assertEnumEqual($w('plus quad'),  $H(Fixtures.functions).keys().sort());
  },
  
  testValues: function() {
    this.assertEnumEqual([],             $H({}).values());
    this.assertEnumEqual(['A#'],         $H(Fixtures.one).values());
    this.assertEnumEqual($w('A B C D#'), $H(Fixtures.many).values().sort());
    this.assertEnumEqual($w('function function'),
      $H(Fixtures.functions).values().map(function(i){ return typeof i }));
    this.assertEqual(9, $H(Fixtures.functions).get('quad')(3));
    this.assertEqual(6, $H(Fixtures.functions).get('plus')(3));
  },
  
  testIndex: function() {
    this.assertUndefined($H().index('foo'));
    
    this.assert('a', $H(Fixtures.one).index('A#'));
    this.assert('a', $H(Fixtures.many).index('A'));
    this.assertUndefined($H(Fixtures.many).index('Z'))
  
    var hash = $H({a:1,b:'2',c:1});
    this.assert(['a','c'].include(hash.index(1)));
    this.assertUndefined(hash.index('1'));
  },
    
  testMerge: function() {
    var h = $H(Fixtures.many);
    this.assertNotIdentical(h, h.merge());
    this.assertNotIdentical(h, h.merge({}));
    this.assertInstanceOf(Hash, h.merge());
    this.assertInstanceOf(Hash, h.merge({}));
    this.assertHashEqual(h, h.merge());
    this.assertHashEqual(h, h.merge({}));
    this.assertHashEqual(h, h.merge($H()));
    this.assertHashEqual({a:'A',  b:'B', c:'C', d:'D#', aaa:'AAA' }, h.merge({aaa: 'AAA'}));
    this.assertHashEqual({a:'A#', b:'B', c:'C', d:'D#' }, h.merge(Fixtures.one));
  },
  
  testUpdate: function() {
    var h = $H(Fixtures.many);
    this.assertIdentical(h, h.update());
    this.assertIdentical(h, h.update({}));
    this.assertHashEqual(h, h.update());
    this.assertHashEqual(h, h.update({}));
    this.assertHashEqual(h, h.update($H()));
    this.assertHashEqual({a:'A',  b:'B', c:'C', d:'D#', aaa:'AAA' }, h.update({aaa: 'AAA'}));
    this.assertHashEqual({a:'A#', b:'B', c:'C', d:'D#', aaa:'AAA' }, h.update(Fixtures.one));
  },
  
  testToQueryString: function() {
    this.assertEqual('',                   $H({}).toQueryString());
    this.assertEqual('a%23=A',             $H({'a#': 'A'}).toQueryString());
    this.assertEqual('a=A%23',             $H(Fixtures.one).toQueryString());
    this.assertEqual('a=A&b=B&c=C&d=D%23', $H(Fixtures.many).toQueryString());
    this.assertEqual("a=b&c",              $H(Fixtures.value_undefined).toQueryString());
    this.assertEqual("a=b&c",              $H("a=b&c".toQueryParams()).toQueryString());
    this.assertEqual("a=b&c=",             $H(Fixtures.value_null).toQueryString());
    this.assertEqual("a=b&c=0",            $H(Fixtures.value_zero).toQueryString());
    this.assertEqual("color=r&color=g&color=b", $H(Fixtures.multiple).toQueryString());
    this.assertEqual("color=r&color=&color=g&color&color=0", $H(Fixtures.multiple_nil).toQueryString());
    this.assertEqual("color=&color",       $H(Fixtures.multiple_all_nil).toQueryString());
    this.assertEqual("",                   $H(Fixtures.multiple_empty).toQueryString());
    this.assertEqual("",                   $H({foo: {}, bar: {}}).toQueryString());
    this.assertEqual("stuff%5B%5D=%24&stuff%5B%5D=a&stuff%5B%5D=%3B", $H(Fixtures.multiple_special).toQueryString());
    this.assertHashEqual(Fixtures.multiple_special, $H(Fixtures.multiple_special).toQueryString().toQueryParams());
    this.assertIdentical(Object.toQueryString, Hash.toQueryString);
    
    // Serializing newlines and spaces is weird. See:
    // http://www.w3.org/TR/1999/REC-html401-19991224/interact/forms.html#h-17.13.4.1
    var complex = "an arbitrary line\n\'something in single quotes followed by a newline\'\r\n" +
     "and more text eventually";
    var queryString = $H({ val: complex }).toQueryString();
    var expected = "val=an+arbitrary+line%0D%0A'something+in+single+quotes+followed+by+a+" + 
     "newline'%0D%0Aand+more+text+eventually";
    this.assertEqual(expected, queryString, "newlines and spaces should be properly encoded");
  },
  
  testInspect: function() {
    this.assertEqual('#<Hash:{}>',              $H({}).inspect());
    this.assertEqual("#<Hash:{'a': 'A#'}>",     $H(Fixtures.one).inspect());
    this.assertEqual("#<Hash:{'a': 'A', 'b': 'B', 'c': 'C', 'd': 'D#'}>", $H(Fixtures.many).inspect());
  },

  testClone: function() {
    var h = $H(Fixtures.many);
    this.assertHashEqual(h, h.clone());
    this.assertInstanceOf(Hash, h.clone());
    this.assertNotIdentical(h, h.clone());
  },
  
  testToJSON: function() {
    this.assertEqual('{\"b\":[null,false,true,null],\"c\":{\"a\":\"hello!\"}}',
      Object.toJSON({b: [undefined, false, true, undefined], c: {a: 'hello!'}}));
  },
  
  testAbilityToContainAnyKey: function() {
    var h = $H({ _each: 'E', map: 'M', keys: 'K', pluck: 'P', unset: 'U' });
    this.assertEnumEqual($w('_each keys map pluck unset'), h.keys().sort());
    this.assertEqual('U', h.unset('unset'));
    this.assertHashEqual({ _each: 'E', map: 'M', keys: 'K', pluck: 'P' }, h);
  },
  
  testHashToTemplateReplacements: function() {
    var template = new Template("#{a} #{b}"), hash = $H({ a: "hello", b: "world" });
    this.assertEqual("hello world", template.evaluate(hash.toObject()));
    this.assertEqual("hello world", template.evaluate(hash));
    this.assertEqual("hello", "#{a}".interpolate(hash));
  },
  
  testPreventIterationOverShadowedProperties: function() {
    // redundant now that object is systematically cloned.
    var FooMaker = function(value) {
      this.key = value;
    };
    FooMaker.prototype.key = 'foo';
    var foo = new FooMaker('bar');
    this.assertEqual("key=bar", new Hash(foo).toQueryString());
    this.assertEqual("key=bar", new Hash(new Hash(foo)).toQueryString());
  },

  testIterationWithEach: function()  {
    var h = $H({a:1, b:2});
    var result = []
    h.each(function(kv, i){
      result.push(i);
    });
   this.assertEnumEqual([0,1], result);
  },

  testIterationWithEachKey: function() {
    var hash = $H({a:1, b:2, c:3});
    var keys = [];
    hash.eachKey(function(key) {
      keys.push(key);
    });
    this.assertEnumEqual(['a', 'b', 'c'], keys);
  },

  testIterationWithEachValue: function() {
    var hash = $H({a:1, b:2, c:3});
    var values = [];
    hash.eachValue(function(value) {
      values.push(value);
    });
    this.assertEnumEqual([1, 2, 3], values);
  },

  testIterationWithEachPair: function() {
    var hash = $H({a:1, b:2, c:3});
    var keys = [];
    var values = [];
    hash.eachPair(function(key, value) {
      keys.push(key);
      values.push(value);
    });
    this.assertEnumEqual([1, 2, 3], values);
    this.assertEnumEqual(['a', 'b', 'c'], keys);
  }
  
});