Specs/Types/Hash.js

   1 /*
   2 ---
   3 name: Hash
   4 requires: ~
   5 provides: ~
   6 ...
   7 */
   8
   9 //<1.2compat>
  10 (function(){
  11
  12 var hash2 = new Hash({ a: 'string', b: 233, c: {} });
  13
  14 describe('Hash Method', function(){
  15
  16         describe('Hash.constructor', function(){
  17
  18                 it('should return a new hash', function(){
  19                         expect(Hash.type(new Hash())).to.equal(true);
  20                 });
  21
  22                 it('should return a copy of a hash', function(){
  23                         var hash = new Hash({a: 1, b: 2, c: 3});
  24                         var copy = new Hash(hash);
  25                         expect(copy).to.not.equal(hash);
  26                         expect(copy).to.eql(hash);
  27                 });
  28
  29         });
  30
  31         describe('Hash.erase', function(){
  32
  33                 it('should remove a key and its value from the hash', function(){
  34                         var hash = new Hash({a: 1, b: 2, c: 3});
  35                         expect(hash.erase('a')).to.eql(new Hash({b:2, c:3}));
  36                         expect(hash.erase('d')).to.eql(new Hash({b:2, c:3}));
  37
  38                         hash = new Hash({a: 1, b: 2, c: 3});
  39                         expect(hash.erase('a')).to.eql(new Hash({b:2, c:3}));
  40                         expect(hash.erase('d')).to.eql(new Hash({b:2, c:3}));
  41                 });
  42
  43         });
  44
  45         describe('Hash.get', function(){
  46
  47                 it('should return the value corresponding to the specified key otherwise null', function(){
  48                         var hash = new Hash({a: 1, b: 2, c: 3});
  49                         expect(hash.get('c')).to.equal(3);
  50                         expect(hash.get('d')).to.equal(null);
  51                 });
  52
  53         });
  54
  55         describe('Hash.set', function(){
  56
  57                 it('should set the key with the corresponding value', function(){
  58                         var myHash = new Hash({a: 1, b: 2, c: 3}).set('c', 7).set('d', 8);
  59                         expect(myHash).to.eql(new Hash({a:1, b:2, c:7, d:8}));
  60                 });
  61
  62         });
  63
  64         describe('Hash.empty', function(){
  65
  66                 it('should empty the hash', function(){
  67                         var hash = new Hash({a: 1, b: 2, c: 3});
  68                         expect(hash.empty()).to.eql(new Hash());
  69                 });
  70
  71         });
  72
  73         describe('Hash.include', function(){
  74
  75                 it('should include a key value if the hash does not have the key otherwise ignore', function(){
  76                         var hash = new Hash({a: 1, b: 2, c: 3});
  77                         expect(hash.include('e', 7)).to.eql(new Hash({a:1, b:2, c:3, e:7}));
  78                         expect(hash.include('a', 7)).to.eql(new Hash({a:1, b:2, c:3, e:7}));
  79                 });
  80
  81         });
  82
  83         describe('Hash.keyOf | Hash.indexOf', function(){
  84
  85                 it('should return the key of the value or null if not found', function(){
  86                         var hash = new Hash({a: 1, b: 2, c: 3, d: 1});
  87                         expect(hash.keyOf(1)).to.equal('a');
  88                         expect(hash.keyOf('not found')).to.equal(null);
  89
  90                         expect(hash.indexOf(1)).to.equal('a');
  91                         expect(hash.indexOf('not found')).to.equal(null);
  92                 });
  93
  94         });
  95
  96         describe('Hash.has', function(){
  97
  98                 it('should return true if the hash has the key otherwise false', function(){
  99                         var hash = new Hash({a: 1, b: 2, c: 3});
 100                         expect(hash.has('a')).to.equal(true);
 101                         expect(hash.has('d')).to.equal(false);
 102                 });
 103
 104         });
 105
 106         describe('Hash.hasValue | Hash.contains', function(){
 107
 108                 it('should return true if the hash hasValue otherwise false', function(){
 109                         var hash = new Hash({a: 1, b: 2, c: 3});
 110                         expect(hash.hasValue(1)).to.equal(true);
 111                         expect(hash.hasValue('not found')).to.equal(false);
 112
 113                         expect(hash.contains(1)).to.equal(true);
 114                         expect(hash.contains('not found')).to.equal(false);
 115                 });
 116
 117         });
 118
 119         describe('Hash.getClean', function(){
 120
 121                 it('should getClean JavaScript object', function(){
 122                         var hash = new Hash({a: 1, b: 2, c: 3});
 123                         expect(hash.getClean()).to.eql({a:1, b:2, c:3});
 124                 });
 125
 126         });
 127
 128         describe('Hash.extend', function(){
 129
 130                 it('should extend a Hash with an object', function(){
 131                         var hash = new Hash({a: 1, b: 2, c: 3});
 132                         expect(hash.extend({a:4, d:7, e:8})).to.eql(new Hash({a:4, b:2, c:3, d:7, e:8}));
 133                 });
 134
 135                 it('should extend a Hash with another Hash', function(){
 136                         var hash = new Hash({a: 1, b: 2, c: 3});
 137                         expect(hash.extend(new Hash({a:4, d:7, e:8}))).to.eql(new Hash({a:4, b:2, c:3, d:7, e:8}));
 138                 });
 139
 140         });
 141
 142         describe('Hash.combine', function(){
 143
 144                 it('should merge a Hash with an object', function(){
 145                         var hash = new Hash({a: 1, b: 2, c: 3});
 146                         expect(hash.combine({a:4, d:7, e:8})).to.eql(new Hash({a:1, b:2, c:3, d:7, e:8}));
 147                 });
 148
 149                 it('should merge a Hash with another Hash', function(){
 150                         var hash = new Hash({a: 1, b: 2, c: 3});
 151                         expect(hash.combine(new Hash({a:4, d:7, e:8}))).to.eql(new Hash({a:1, b:2, c:3, d:7, e:8}));
 152                 });
 153
 154         });
 155
 156         describe('Hash.each', function(){
 157
 158                 it('should iterate through each property', function(){
 159                         var newHash = new Hash();
 160                         var hash = new Hash({a: 1, b: 2, c: 3});
 161                         hash.each(function(value, key){
 162                                 newHash.set(key, value);
 163                         });
 164                         expect(newHash).to.eql(hash);
 165                 });
 166
 167         });
 168
 169         describe('Hash.map', function(){
 170
 171                 it('should map a new Hash according to the comparator', function(){
 172                         expect(hash2.map(Number.type)).to.eql(new Hash({a:false, b:true, c:false}));
 173                 });
 174
 175         });
 176
 177         describe('Hash.filter', function(){
 178
 179                 it('should filter the Hash according to the comparator', function(){
 180                         expect(hash2.filter(Number.type)).to.eql(new Hash({b:233}));
 181                 });
 182
 183         });
 184
 185         describe('Hash.every', function(){
 186
 187                 it('should return true if every value matches the comparator, otherwise false', function(){
 188                         expect(hash2.every($defined)).to.equal(true);
 189                         expect(hash2.every(Number.type)).to.equal(false);
 190                 });
 191
 192         });
 193
 194         describe('Hash.some', function(){
 195
 196                 it('should return true if some of the values match the comparator, otherwise false', function(){
 197                         expect(hash2.some(Number.type)).to.equal(true);
 198                         expect(hash2.some(Array.type)).to.equal(false);
 199                 });
 200
 201         });
 202
 203         describe('Hash.getKeys', function(){
 204
 205                 it('getKeys should return an empty array', function(){
 206                         expect(new Hash().getKeys()).to.eql([]);
 207                 });
 208
 209                 it('should return an array containing the keys of the hash', function(){
 210                         expect(hash2.getKeys()).to.eql(['a', 'b', 'c']);
 211                 });
 212
 213         });
 214
 215         describe('Hash.getValues', function(){
 216
 217                 it('getValues should return an empty array', function(){
 218                         expect(new Hash().getValues()).to.eql([]);
 219                 });
 220
 221                 it('should return an array with the values of the hash', function(){
 222                         expect(hash2.getValues()).to.eql(['string', 233, {}]);
 223                 });
 224
 225         });
 226
 227         describe('Hash.toQueryString', function(){
 228
 229                 it('should return a query string', function(){
 230                         var myHash = new Hash({apple: 'red', lemon: 'yellow'});
 231                         expect(myHash.toQueryString()).to.equal('apple=red&lemon=yellow');
 232
 233                         var myHash2 = new Hash({apple: ['red', 'yellow'], lemon: ['green', 'yellow']});
 234                         expect(myHash2.toQueryString()).to.equal('apple[0]=red&apple[1]=yellow&lemon[0]=green&lemon[1]=yellow');
 235
 236                         var myHash3 = new Hash({fruits: {apple: ['red', 'yellow'], lemon: ['green', 'yellow']}});
 237                         expect(myHash3.toQueryString()).to.equal('fruits[apple][0]=red&fruits[apple][1]=yellow&fruits[lemon][0]=green&fruits[lemon][1]=yellow');
 238                 });
 239
 240         });
 241
 242 });
 243
 244 })();
 245 //</1.2compat>