text: (function() {
    var Promise, chai, chaiAsPromised, chance, expect, lib, sinon;
  
    chai = require('chai');
  
    expect = chai.expect;
  
    chaiAsPromised = require('chai-as-promised');
  
    chai.use(chaiAsPromised);
  
    chance = require('chance').Chance();
  
    lib = require('../lib/lib')["aws-translators"];
  
    sinon = require('sinon');
  
    Promise = require('bluebird');
  
    describe('aws-translators', function() {
      describe('#getKeySchema', function() {
        it('should parse out a hash key from an aws response', function() {
          var hashKeyName, result;
          hashKeyName = chance.word();
          result = lib.getKeySchema({
            Table: {
              KeySchema: [
                {
                  AttributeName: hashKeyName,
                  KeyType: 'HASH'
                }
              ],
              AttributeDefinitions: [
                {
                  AttributeName: hashKeyName,
                  AttributeType: 'N'
                }
              ]
            }
          });
          expect(result).to.have.property('hashKeyName');
          expect(result.hashKeyName).to.equal(hashKeyName);
          expect(result).to.have.property('hashKeyType');
          return expect(result.hashKeyType).to.equal('N');
        });
        return it('should parse out a range key from an aws response', function() {
          var hashKeyName, rangeKeyName, result;
          hashKeyName = chance.word();
          rangeKeyName = chance.word();
          return result = lib.getKeySchema({
            Table: {
              KeySchema: [
                {
                  AttributeName: hashKeyName,
                  KeyType: 'HASH'
                }, {
                  AttributeName: rangeKeyName,
                  KeyType: 'RANGE'
                }
              ],
              AttributeDefinitions: [
                {
                  AttributeName: hashKeyName,
                  AttributeType: 'S'
                }, {
                  AttributeName: rangeKeyName,
                  AttributeType: 'B'
                }
              ]
            }
          });
        });
      });
      describe('#deleteItem', function() {
        var dynastyTable, sandbox;
        dynastyTable = null;
        sandbox = null;
        beforeEach(function() {
          sandbox = sinon.sandbox.create();
          return dynastyTable = {
            name: chance.name(),
            parent: {
              dynamo: {
                deleteItemAsync: function(params, callback) {
                  return Promise.resolve('lol');
                }
              }
            }
          };
        });
        afterEach(function() {
          return sandbox.restore();
        });
        it('should return an object', function() {
          var promise;
          promise = lib.deleteItem.call(dynastyTable, 'foo', null, null, {
            hashKeyName: 'bar',
            hashKeyType: 'S'
          });
          return expect(promise).to.be.an('object');
        });
        it('should return a promise', function() {
          var promise;
          promise = lib.deleteItem.call(dynastyTable, 'foo', null, null, {
            hashKeyName: 'bar',
            hashKeyType: 'S'
          });
          return promise.then(function(d) {
            return expect(d).to.equal('lol');
          });
        });
        it('should call deleteItem of aws', function() {
          sandbox.spy(dynastyTable.parent.dynamo, "deleteItemAsync");
          lib.deleteItem.call(dynastyTable, 'foo', null, null, {
            hashKeyName: 'bar',
            hashKeyType: 'S'
          });
          return expect(dynastyTable.parent.dynamo.deleteItemAsync.calledOnce);
        });
        it('should send the table name to AWS', function() {
          var promise;
          sandbox.spy(dynastyTable.parent.dynamo, "deleteItemAsync");
          promise = lib.deleteItem.call(dynastyTable, 'foo', null, null, {
            hashKeyName: 'bar',
            hashKeyType: 'S'
          });
          return promise.then(function() {
            var params;
            expect(dynastyTable.parent.dynamo.deleteItemAsync.calledOnce);
            params = dynastyTable.parent.dynamo.deleteItemAsync.getCall(0).args[0];
            return expect(params.TableName).to.equal(dynastyTable.name);
          });
        });
        it('should send the hash key to AWS', function() {
          var params, promise;
          sandbox.spy(dynastyTable.parent.dynamo, "deleteItemAsync");
          promise = lib.deleteItem.call(dynastyTable, 'foo', null, null, {
            hashKeyName: 'bar',
            hashKeyType: 'S'
          });
          expect(dynastyTable.parent.dynamo.deleteItemAsync.calledOnce);
          params = dynastyTable.parent.dynamo.deleteItemAsync.getCall(0).args[0];
          expect(params.Key).to.include.keys('bar');
          expect(params.Key.bar).to.include.keys('S');
          return expect(params.Key.bar.S).to.equal('foo');
        });
        return it('should send the hash and range key to AWS', function() {
          var params, promise;
          sandbox.spy(dynastyTable.parent.dynamo, "deleteItemAsync");
          promise = lib.deleteItem.call(dynastyTable, {
            hash: 'lol',
            range: 'rofl'
          }, null, null, {
            hashKeyName: 'bar',
            hashKeyType: 'S',
            rangeKeyName: 'foo',
            rangeKeyType: 'S'
          });
          expect(dynastyTable.parent.dynamo.deleteItemAsync.calledOnce);
          params = dynastyTable.parent.dynamo.deleteItemAsync.getCall(0).args[0];
          expect(params.Key).to.include.keys('bar');
          expect(params.Key.bar).to.include.keys('S');
          expect(params.Key.bar.S).to.equal('lol');
          expect(params.Key).to.include.keys('foo');
          expect(params.Key.foo).to.include.keys('S');
          return expect(params.Key.foo.S).to.equal('rofl');
        });
      });
      describe('#batchGetItem', function() {
        var dynastyTable, sandbox;
        dynastyTable = null;
        sandbox = null;
        beforeEach(function() {
          var tableName;
          tableName = chance.name();
          sandbox = sinon.sandbox.create();
          return dynastyTable = {
            name: tableName,
            parent: {
              dynamo: {
                batchGetItemAsync: function(params, callback) {
                  var result;
                  result = {};
                  result.Responses = {};
                  result.Responses[tableName] = [
                    {
                      foo: {
                        S: "bar"
                      }
                    }, {
                      foo: {
                        S: "baz"
                      },
                      bazzoo: {
                        N: 123
                      }
                    }
                  ];
                  return Promise.resolve(result);
                }
              }
            }
          };
        });
        afterEach(function() {
          return sandbox.restore();
        });
        return it('should return a sane response', function() {
          return lib.batchGetItem.call(dynastyTable, ['bar', 'baz'], null, {
            hashKeyName: 'foo',
            hashKeyType: 'S'
          }).then(function(data) {
            return expect(data).to.deep.equal([
              {
                foo: 'bar'
              }, {
                foo: 'baz',
                bazzoo: 123
              }
            ]);
          });
        });
      });
      describe('#getItem', function() {
        var dynastyTable, sandbox;
        dynastyTable = null;
        sandbox = null;
        beforeEach(function() {
          sandbox = sinon.sandbox.create();
          return dynastyTable = {
            name: chance.name(),
            parent: {
              dynamo: {
                getItemAsync: function(params, callback) {
                  return Promise.resolve({
                    Item: {
                      rofl: {
                        S: 'lol'
                      }
                    }
                  });
                }
              }
            }
          };
        });
        afterEach(function() {
          return sandbox.restore();
        });
        it('should return an object', function() {
          var promise;
          promise = lib.getItem.call(dynastyTable, 'foo', null, null, {
            hashKeyName: 'bar',
            hashKeyType: 'S'
          });
          return expect(promise).to.be.an('object');
        });
        it('should return a promise', function() {
          return lib.getItem.call(dynastyTable, 'foo', null, null, {
            hashKeyName: 'bar',
            hashKeyType: 'S'
          }).then(function(data) {
            return expect(data).to.deep.equal({
              rofl: 'lol'
            });
          });
        });
        it('should call getItem of aws', function() {
          sandbox.spy(dynastyTable.parent.dynamo, "getItemAsync");
          lib.getItem.call(dynastyTable, 'foo', null, null, {
            hashKeyName: 'bar',
            hashKeyType: 'S'
          });
          expect(dynastyTable.parent.dynamo.getItemAsync.calledOnce);
          return expect(dynastyTable.parent.dynamo.getItemAsync.getCall(0).args[0].TableName).to.equal(dynastyTable.name);
        });
        it('should send the table name to AWS', function() {
          sandbox.spy(dynastyTable.parent.dynamo, "getItemAsync");
          return lib.getItem.call(dynastyTable, 'foo', null, null, {
            hashKeyName: 'bar',
            hashKeyType: 'S'
          }).then(function() {
            var params;
            expect(dynastyTable.parent.dynamo.getItemAsync.calledOnce);
            params = dynastyTable.parent.dynamo.getItemAsync.getCall(0).args[0];
            return expect(params.TableName).to.equal(dynastyTable.name);
          });
        });
        it('should send the hash key to AWS', function() {
          var params, promise;
          sandbox.spy(dynastyTable.parent.dynamo, "getItemAsync");
          promise = lib.getItem.call(dynastyTable, 'foo', null, null, {
            hashKeyName: 'bar',
            hashKeyType: 'S'
          });
          expect(dynastyTable.parent.dynamo.getItemAsync.calledOnce);
          params = dynastyTable.parent.dynamo.getItemAsync.getCall(0).args[0];
          expect(params.Key).to.include.keys('bar');
          expect(params.Key.bar).to.include.keys('S');
          return expect(params.Key.bar.S).to.equal('foo');
        });
        return it('should send the hash and range key to AWS', function() {
          var params, promise;
          sandbox.spy(dynastyTable.parent.dynamo, "getItemAsync");
          promise = lib.getItem.call(dynastyTable, {
            hash: 'lol',
            range: 'rofl'
          }, null, null, {
            hashKeyName: 'bar',
            hashKeyType: 'S',
            rangeKeyName: 'foo',
            rangeKeyType: 'S'
          });
          expect(dynastyTable.parent.dynamo.getItemAsync.calledOnce);
          params = dynastyTable.parent.dynamo.getItemAsync.getCall(0).args[0];
          expect(params.Key).to.include.keys('bar');
          expect(params.Key.bar).to.include.keys('S');
          expect(params.Key.bar.S).to.equal('lol');
          expect(params.Key).to.include.keys('foo');
          expect(params.Key.foo).to.include.keys('S');
          return expect(params.Key.foo.S).to.equal('rofl');
        });
      });
      describe('#scanAsync', function() {
        var dynastyTable, sandbox;
        dynastyTable = null;
        sandbox = null;
        beforeEach(function() {
          sandbox = sinon.sandbox.create();
          return dynastyTable = {
            name: chance.name(),
            parent: {
              dynamo: {
                scanAsync: function(params, callback) {
                  return Promise.resolve({
                    Items: {
                      rofl: {
                        S: 'lol'
                      }
                    }
                  });
                }
              }
            }
          };
        });
        afterEach(function() {
          return sandbox.restore();
        });
        it('should return an object', function() {
          var promise;
          promise = lib.scan.call(dynastyTable, 'foo', null, null, {
            hashKeyName: 'bar',
            hashKeyType: 'S'
          });
          return expect(promise).to.be.an('object');
        });
        it('should return a promise', function() {
          return lib.scan.call(dynastyTable, 'foo', null, null, {
            hashKeyName: 'bar',
            hashKeyType: 'S'
          }).then(function(data) {
            return expect(data).to.deep.equal({
              rofl: 'lol'
            });
          });
        });
        return it('should call scan of aws', function() {
          sandbox.spy(dynastyTable.parent.dynamo, "scanAsync");
          lib.scan.call(dynastyTable, 'foo', null, null, {
            hashKeyName: 'bar',
            hashKeyType: 'S'
          });
          expect(dynastyTable.parent.dynamo.scanAsync.calledOnce);
          return expect(dynastyTable.parent.dynamo.scanAsync.getCall(0).args[0].TableName).to.equal(dynastyTable.name);
        });
      });
      describe('#queryByHashKey', function() {
        var dynastyTable, sandbox;
        dynastyTable = null;
        sandbox = null;
        beforeEach(function() {
          sandbox = sinon.sandbox.create();
          return dynastyTable = {
            name: chance.name(),
            parent: {
              dynamo: {
                queryAsync: function(params, callback) {
                  return Promise.resolve({
                    Items: [
                      {
                        foo: {
                          S: 'bar'
                        },
                        bar: {
                          S: 'baz'
                        }
                      }
                    ]
                  });
                }
              }
            }
          };
        });
        afterEach(function() {
          return sandbox.restore();
        });
        it('should translate the response', function() {
          return lib.queryByHashKey.call(dynastyTable, 'bar', null, {
            hashKeyName: 'foo',
            hashKeyType: 'S',
            rangeKeyName: 'bar',
            rangeKeyType: 'S'
          }).then(function(data) {
            return expect(data).to.deep.equal([
              {
                foo: 'bar',
                bar: 'baz'
              }
            ]);
          });
        });
        it('should call query', function() {
          sandbox.spy(dynastyTable.parent.dynamo, "queryAsync");
          lib.queryByHashKey.call(dynastyTable, 'bar', null, {
            hashKeyName: 'foo',
            hashKeyType: 'S',
            rangeKeyName: 'bar',
            rangeKeyType: 'S'
          });
          expect(dynastyTable.parent.dynamo.queryAsync.calledOnce);
          return expect(dynastyTable.parent.dynamo.queryAsync.getCall(0).args[0]).to.include.keys('TableName', 'KeyConditions');
        });
        return it('should send the table name and hash key to AWS', function() {
          var params, promise;
          sandbox.spy(dynastyTable.parent.dynamo, "queryAsync");
          promise = lib.queryByHashKey.call(dynastyTable, 'bar', null, {
            hashKeyName: 'foo',
            hashKeyType: 'S',
            rangeKeyName: 'bar',
            rangeKeyType: 'S'
          });
          expect(dynastyTable.parent.dynamo.queryAsync.calledOnce);
          params = dynastyTable.parent.dynamo.queryAsync.getCall(0).args[0];
          expect(params.TableName).to.equal(dynastyTable.name);
          expect(params.KeyConditions.foo.ComparisonOperator).to.equal('EQ');
          return expect(params.KeyConditions.foo.AttributeValueList[0].S).to.equal('bar');
        });
      });
      describe('#putItem', function() {
        var dynastyTable, sandbox;
        dynastyTable = null;
        sandbox = null;
        beforeEach(function() {
          sandbox = sinon.sandbox.create();
          return dynastyTable = {
            name: chance.name(),
            parent: {
              dynamo: {
                putItemAsync: function(params, callback) {
                  return Promise.resolve('lol');
                }
              }
            }
          };
        });
        afterEach(function() {
          return sandbox.restore();
        });
        it('should return an object', function() {
          var promise;
          promise = lib.putItem.call(dynastyTable, {
            foo: 'bar'
          }, null, null);
          return expect(promise).to.be.an('object');
        });
        it('should return a promise', function() {
          return lib.putItem.call(dynastyTable, {
            foo: 'bar'
          }, null, null).then(function(data) {
            return expect(data).to.equal('lol');
          });
        });
        it('should call putItem of aws', function() {
          sandbox.spy(dynastyTable.parent.dynamo, "putItemAsync");
          lib.putItem.call(dynastyTable, {
            foo: 'bar'
          }, null, null);
          expect(dynastyTable.parent.dynamo.putItemAsync.calledOnce);
          return expect(dynastyTable.parent.dynamo.putItemAsync.getCall(0).args[0]).to.include.keys('Item', 'TableName');
        });
        it('should send the table name to AWS', function() {
          sandbox.spy(dynastyTable.parent.dynamo, "putItemAsync");
          return lib.putItem.call(dynastyTable, {
            foo: 'bar'
          }, null, null).then(function() {
            var params;
            expect(dynastyTable.parent.dynamo.putItemAsync.calledOnce);
            params = dynastyTable.parent.dynamo.putItemAsync.getCall(0).args[0];
            return expect(params.TableName).to.equal(dynastyTable.name);
          });
        });
        return it('should send the translated object to AWS', function() {
          var params, promise;
          sandbox.spy(dynastyTable.parent.dynamo, "putItemAsync");
          promise = lib.putItem.call(dynastyTable, {
            foo: 'bar'
          }, null, null);
          expect(dynastyTable.parent.dynamo.putItemAsync.calledOnce);
          params = dynastyTable.parent.dynamo.putItemAsync.getCall(0).args[0];
          expect(params.Item).to.be.an('object');
          expect(params.Item.foo).to.be.an('object');
          return expect(params.Item.foo.S).to.equal('bar');
        });
      });
      return describe('#updateItem', function() {
        var dynastyTable, sandbox;
        dynastyTable = null;
        sandbox = null;
        beforeEach(function() {
          sandbox = sinon.sandbox.create();
          return dynastyTable = {
            name: chance.name(),
            parent: {
              dynamo: {
                updateItemAsync: function(params, callback) {
                  return Promise.resolve('lol');
                }
              }
            }
          };
        });
        afterEach(function() {
          return sandbox.restore();
        });
        return it('should automatically setup ExpressionAttributeNames mapping', function() {
          var params, promise;
          sandbox.spy(dynastyTable.parent.dynamo, "updateItemAsync");
          promise = lib.updateItem.call(dynastyTable, {}, {
            foo: 'bar'
          }, null, null, {
            hashKeyName: 'bar',
            hashKeyType: 'S'
          });
          expect(dynastyTable.parent.dynamo.updateItemAsync.calledOnce);
          params = dynastyTable.parent.dynamo.updateItemAsync.getCall(0).args[0];
          return expect(params.ExpressionAttributeNames).to.be.eql({
            "#foo": 'foo'
          });
        });
      });
    });
  
  }).call(this);
  
  (function() {
    var Chance, Dynasty, chai, chaiAsPromised, chance, expect, getCredentials, _;
  
    chai = require('chai');
  
    chaiAsPromised = require('chai-as-promised');
  
    chai.use(chaiAsPromised);
  
    expect = require('chai').expect;
  
    Chance = require('chance');
  
    Dynasty = require('../lib/dynasty');
  
    _ = require('lodash');
  
    chance = new Chance();
  
    getCredentials = function() {
      return {
        accessKeyId: "AKIAIPW4YWLVT3RR5NYA",
        secretAccessKey: "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"
      };
    };
  
    describe('Dynasty', function() {
      describe('Base', function() {
        it('constructor exists and is a function', function() {
          return expect(require('../lib/dynasty')).to.be.a('function');
        });
        it('can construct', function() {
          var dynasty;
          dynasty = Dynasty(getCredentials());
          expect(dynasty).to.exist;
          return expect(dynasty.tables).to.exist;
        });
        it('can retrieve a table object', function() {
          var dynasty, t;
          dynasty = Dynasty(getCredentials());
          t = dynasty.table(chance.name());
          return expect(t).to.be.an('object');
        });
        return describe('create()', function() {
          beforeEach(function() {
            return this.dynasty = Dynasty(getCredentials());
          });
          it('should return an object with valid key_schema', function() {
            var promise;
            promise = this.dynasty.create(chance.name(), {
              key_schema: {
                hash: [chance.name(), 'string']
              }
            });
            return expect(promise).to.be.an('object');
          });
          return it('should accept a hash and range key_schema', function() {
            var promise;
            promise = this.dynasty.create(chance.name(), {
              key_schema: {
                hash: [chance.name(), 'string'],
                range: [chance.name(), 'string']
              }
            });
            return expect(promise).to.be.an('object');
          });
        });
      });
      return describe('Table', function() {
        beforeEach(function() {
          this.dynasty = Dynasty(getCredentials());
          this.table = this.dynasty.table(chance.name());
          return this.dynamo = this.dynasty.dynamo;
        });
        describe('remove()', function() {
          return it('should return an object', function() {
            var promise;
            promise = this.table.remove(chance.name());
            return expect(promise).to.be.an('object');
          });
        });
        describe('batchFind()', function() {
          return it('works with an array of keys', function() {
            var promise;
            promise = this.table.batchFind([chance.name()]);
            return expect(promise).to.be.an('object');
          });
        });
        describe('find()', function() {
          it('works with just a string', function() {
            var promise;
            promise = this.table.find(chance.name());
            return expect(promise).to.be.an('object');
          });
          it('works with an object with just a hash key', function() {
            var promise;
            promise = this.table.find({
              hash: chance.name()
            });
            return expect(promise).to.be.an('object');
          });
          return it('works with an object with both a hash and range key', function() {
            var promise;
            promise = this.table.find({
              hash: chance.name(),
              range: chance.name()
            });
            return expect(promise).to.be.an('object');
          });
        });
        describe('describe()', function() {
          return it('should return an object', function() {
            var promise;
            promise = this.table.describe();
            return expect(promise).to.be.an('object');
          });
        });
        return describe('alter()', function() {
          return it('should return an object', function() {
            var promise;
            promise = this.table.describe();
            return expect(promise).to.be.an('object');
          });
        });
      });
    });
  
  }).call(this);
  
  (function() {
    var Chance, chai, chance, dataTrans, expect, _;
  
    chai = require('chai');
  
    expect = require('chai').expect;
  
    Chance = require('chance');
  
    chance = new Chance();
  
    _ = require('lodash');
  
    dataTrans = require('../lib/lib')['data-translators'];
  
    describe('toDynamo()', function() {
      it('should throw an error if called with no arguments', function() {
        return expect(function() {
          return dataTrans.toDynamo();
        }).to["throw"](/does not support mapping undefined/);
      });
      it('looks right when given a number', function() {
        var converted, num;
        num = chance.integer();
        converted = dataTrans.toDynamo(num);
        expect(converted).to.be.an('object');
        return expect(converted).to.deep.equal({
          'N': num.toString()
        });
      });
      it('looks right when given a string', function() {
        var converted, str;
        str = chance.string();
        converted = dataTrans.toDynamo(str);
        expect(converted).to.be.an('object');
        return expect(converted).to.deep.equal({
          'S': str
        });
      });
      it('looks right when given a long string', function() {
        var converted, str;
        str = chance.string({
          length: 1025
        });
        converted = dataTrans.toDynamo(str);
        expect(converted).to.be.an('object');
        return expect(converted).to.deep.equal({
          'S': str
        });
      });
      it('should convert objects to Maps', function() {
        return expect(dataTrans.toDynamo({
          foo: 'bar'
        })).to.eql({
          M: {
            foo: {
              S: 'bar'
            }
          }
        });
      });
      it('looks right when given an array of numbers', function() {
        var arr, converted;
        arr = [0, 1, 2, 3];
        converted = dataTrans.toDynamo(arr);
        expect(converted).to.be.an('object');
        return expect(converted).to.deep.equal({
          NS: ['0', '1', '2', '3']
        });
      });
      it('looks right when given an array of strings', function() {
        var arr, converted;
        arr = [];
        _.times(10, function() {
          return arr.push(chance.string());
        });
        converted = dataTrans.toDynamo(arr);
        expect(converted).to.be.an('object');
        return expect(converted).to.deep.equal({
          'SS': arr
        });
      });
      it('looks right when given an array of objects', function() {
        var arr, converted;
        arr = [
          {
            foo: 'bar'
          }, {
            bar: 'foo'
          }
        ];
        converted = dataTrans.toDynamo(arr);
        expect(converted).to.be.an('object');
        return expect(converted).to.eql({
          L: [
            {
              M: {
                foo: {
                  S: 'bar'
                }
              }
            }, {
              M: {
                bar: {
                  S: 'foo'
                }
              }
            }
          ]
        });
      });
      it('looks right when given an array of nested objects', function() {
        var arr, converted;
        arr = [
          {
            foo: [1, 2, 3]
          }, {
            bar: {
              amazon: 'aws'
            }
          }
        ];
        converted = dataTrans.toDynamo(arr);
        expect(converted).to.be.an('object');
        return expect(converted).to.eql({
          L: [
            {
              M: {
                foo: {
                  NS: ['1', '2', '3']
                }
              }
            }, {
              M: {
                bar: {
                  M: {
                    amazon: {
                      S: 'aws'
                    }
                  }
                }
              }
            }
          ]
        });
      });
      it('converts an empty array to a list', function() {
        return expect(dataTrans.toDynamo([])).to.eql({
          L: []
        });
      });
      it('should throw an error when given a hetrogeneous array', function() {
        var arr;
        arr = [];
        _.times(10, function(n) {
          if (n % 2) {
            return arr.push(chance.string());
          } else {
            return arr.push(chance.integer());
          }
        });
        return expect(function() {
          return dataTrans.toDynamo(arr);
        }).to["throw"]('Expected homogenous array of numbers or strings');
      });
      it('supports null values', function() {
        return expect(dataTrans.toDynamo({
          foo: null
        })).to.deep.equal({
          'M': {
            foo: {
              'NULL': true
            }
          }
        });
      });
      return it('throws an error for undefined values', function() {
        return expect(function() {
          return dataTrans.toDynamo({
            foo: void 0
          });
        }).to["throw"](/does not support mapping undefined/);
      });
    });
  
    describe('fromDynamo()', function() {
      it('converts dynamo NULLs to javascript nulls', function() {
        return expect(dataTrans.fromDynamo({
          NULL: true
        })).to.be["null"];
      });
      it('converts string lists correctly', function() {
        var dynamoData;
        dynamoData = {
          L: [
            {
              S: 'foo'
            }, {
              S: 'bar'
            }
          ]
        };
        return expect(dataTrans.fromDynamo(dynamoData)).to.eql(['foo', 'bar']);
      });
      return it('converts numbered lists correctly', function() {
        var dynamoData;
        dynamoData = {
          M: {
            foo: {
              L: [
                {
                  N: 0
                }, {
                  N: 1
                }
              ]
            }
          }
        };
        return expect(dataTrans.fromDynamo(dynamoData)).to.eql({
          foo: [0, 1]
        });
      });
    });
  
  }).call(this);
  