dynamoid 0.6.0 → 0.6.1

data/Dynamoid.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "dynamoid"
-  s.version = "0.6.0"
+  s.version = "0.6.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Josh Symonds"]
-  s.date = "2012-12-19"
+  s.date = "2013-01-09"
   s.description = "Dynamoid is an ORM for Amazon's DynamoDB that supports offline development, associations, querying, and everything else you'd expect from an ActiveRecord-style replacement."
   s.email = "josh@joshsymonds.com"
   s.extra_rdoc_files = [
@@ -139,7 +139,7 @@ Gem::Specification.new do |s|
   s.homepage = "http://github.com/Veraticus/Dynamoid"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.24"
+  s.rubygems_version = "1.8.23"
   s.summary = "Dynamoid is an ORM for Amazon's DynamoDB"
 
   if s.respond_to? :specification_version then

data/VERSION

@@ -1 +1 @@
-0.6.0
+0.6.1

data/lib/dynamoid/persistence.rb

@@ -69,7 +69,7 @@ module Dynamoid
           self.attributes.each do |attribute, options|
             hash[attribute] = undump_field(incoming[attribute], options)
           end
-          incoming.each {|attribute, value| hash[attribute] ||= value }
+          incoming.each {|attribute, value| hash[attribute] = value unless hash.has_key? attribute }
         end
       end
 
@@ -118,6 +118,8 @@ module Dynamoid
           else
             raise ArgumentError, "Boolean column neither true nor false"
           end
+        else
+          raise ArgumentError, "Unknown type #{options[:type]}"
         end
       end
 

data/spec/dynamoid/adapter/aws_sdk_spec.rb

@@ -2,382 +2,366 @@ require 'dynamoid/adapter/aws_sdk'
 require File.expand_path(File.dirname(__FILE__) + '../../../spec_helper')
 
 describe Dynamoid::Adapter::AwsSdk do
+  before(:each) do
+    pending "You must have an active DynamoDB connection" unless ENV['ACCESS_KEY'] && ENV['SECRET_KEY']
+  end
 
-  if ENV['ACCESS_KEY'] && ENV['SECRET_KEY']
+  #
+  # These let() definitions create tables "dynamoid_tests_TestTable<N>" and return the
+  # name of the table. An after(:each) handler drops any tables created this way after each test
+  #
+  # Name => Constructor args
+  {
+    1 => [:id],
+    2 => [:id],
+    3 => [:id, {:range_key => {:range => :number}}],
+    4 => [:id, {:range_key => {:range => :number}}]
+  }.each do |n, args|
+    name = "dynamoid_tests_TestTable#{n}"
+    let(:"test_table#{n}") do
+      Dynamoid::Adapter.create_table(name, *args)
+      @created_tables << name
+      name
+    end
+  end
+  
+  before(:each) { @created_tables = [] }
+  after(:each) do
+    @created_tables.each do |t|
+      Dynamoid::Adapter.delete_table(t)
+    end
+  end
+  
+  #
+  # Returns a random key parition if partitioning is on, or an empty string if
+  # it is off, useful for shared examples where partitioning may or may not be on
+  #
+  def key_partition
+    Dynamoid::Config.partitioning? ? ".#{Random.rand(Dynamoid::Config.partition_size)}" : ''
+  end
+    
+  #
+  # Tests adapter against ranged tables
+  #
+  shared_examples 'range queries' do
+    before do
+      Dynamoid::Adapter.put_item(test_table3, {:id => "1#{key_partition}", :range => 1.0})
+      Dynamoid::Adapter.put_item(test_table3, {:id => "1#{key_partition}", :range => 3.0})
+    end
 
-    context 'without a preexisting table' do
-      # CreateTable and DeleteTable
-      it 'performs CreateTable and DeleteTable' do
-        table = Dynamoid::Adapter.create_table('CreateTable', :id, :range_key =>  { :created_at => :number })
+    it 'performs query on a table with a range and selects items in a range' do
+      Dynamoid::Adapter.query(test_table3, :hash_value => '1', :range_value => 0.0..3.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
+    end
 
-        Dynamoid::Adapter.connection.tables.collect{|t| t.name}.should include 'CreateTable'
+    it 'performs query on a table with a range and selects items greater than' do
+      Dynamoid::Adapter.query(test_table3, :hash_value => '1', :range_greater_than => 1.0).should =~ [{:id => '1', :range => BigDecimal.new(3)}]
+    end
 
-        Dynamoid::Adapter.delete_table('CreateTable')
-      end
+    it 'performs query on a table with a range and selects items less than' do
+      Dynamoid::Adapter.query(test_table3, :hash_value => '1', :range_less_than => 2.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}]
     end
 
-    context 'with a preexisting table without paritioning' do
-      before(:all) do
-        Dynamoid::Adapter.create_table('dynamoid_tests_TestTable1', :id) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable1')
-        Dynamoid::Adapter.create_table('dynamoid_tests_TestTable2', :id) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable2')
-        Dynamoid::Adapter.create_table('dynamoid_tests_TestTable3', :id, :range_key => { :range => :number }) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable3')
-        Dynamoid::Adapter.create_table('dynamoid_tests_TestTable4', :id, :range_key => { :range => :number }) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable4')
-      end
+    it 'performs query on a table with a range and selects items gte' do
+      Dynamoid::Adapter.query(test_table3, :hash_value => '1', :range_gte => 1.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
+    end
 
-      # GetItem, PutItem and DeleteItem
-      it "performs GetItem for an item that does not exist" do
-        Dynamoid::Adapter.get_item('dynamoid_tests_TestTable1', '1').should be_nil
-      end
+    it 'performs query on a table with a range and selects items lte' do
+      Dynamoid::Adapter.query(test_table3, :hash_value => '1', :range_lte => 3.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
+    end
+  end
+  
+  #
+  # Tests scan_index_forwards flag behavior on range queries
+  #
+  shared_examples 'correct ordering' do
+    before(:each) do
+      pending "Order is not preserved on paritioned tables" if(Dynamoid::Config.partitioning?)
+      Dynamoid::Adapter.put_item(test_table4, {:id => "1#{key_partition}", :order => 1, :range => 1.0})
+      Dynamoid::Adapter.put_item(test_table4, {:id => "1#{key_partition}", :order => 2, :range => 2.0})
+      Dynamoid::Adapter.put_item(test_table4, {:id => "1#{key_partition}", :order => 3, :range => 3.0})
+      Dynamoid::Adapter.put_item(test_table4, {:id => "1#{key_partition}", :order => 4, :range => 4.0})
+      Dynamoid::Adapter.put_item(test_table4, {:id => "1#{key_partition}", :order => 5, :range => 5.0})
+      Dynamoid::Adapter.put_item(test_table4, {:id => "1#{key_partition}", :order => 6, :range => 6.0})
+    end
 
-      it "performs GetItem for an item that does exist" do
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
+    it 'performs query on a table with a range and selects items less than that is in the correct order, scan_index_forward true' do
+      query = Dynamoid::Adapter.query(test_table4, :hash_value => '1', :range_greater_than => 0, :scan_index_forward => true)
+      query[0].should == {:id => '1', :order => 1, :range => BigDecimal.new(1)}
+      query[1].should == {:id => '1', :order => 2, :range => BigDecimal.new(2)}
+      query[2].should == {:id => '1', :order => 3, :range => BigDecimal.new(3)}
+      query[3].should == {:id => '1', :order => 4, :range => BigDecimal.new(4)}
+      query[4].should == {:id => '1', :order => 5, :range => BigDecimal.new(5)}
+      query[5].should == {:id => '1', :order => 6, :range => BigDecimal.new(6)}
+    end
+    
+    it 'performs query on a table with a range and selects items less than that is in the correct order, scan_index_forward false' do
+      query = Dynamoid::Adapter.query(test_table4, :hash_value => '1', :range_greater_than => 0, :scan_index_forward => false)
+      query[5].should == {:id => '1', :order => 1, :range => BigDecimal.new(1)}
+      query[4].should == {:id => '1', :order => 2, :range => BigDecimal.new(2)}
+      query[3].should == {:id => '1', :order => 3, :range => BigDecimal.new(3)}
+      query[2].should == {:id => '1', :order => 4, :range => BigDecimal.new(4)}
+      query[1].should == {:id => '1', :order => 5, :range => BigDecimal.new(5)}
+      query[0].should == {:id => '1', :order => 6, :range => BigDecimal.new(6)}
+    end
+  end
+  
+  
+  context 'without a preexisting table' do
+    # CreateTable and DeleteTable
+    it 'performs CreateTable and DeleteTable' do
+      table = Dynamoid::Adapter.create_table('CreateTable', :id, :range_key =>  { :created_at => :number })
 
-        Dynamoid::Adapter.get_item('dynamoid_tests_TestTable1', '1').should == {:name => 'Josh', :id => '1'}
+      Dynamoid::Adapter.connection.tables.collect{|t| t.name}.should include 'CreateTable'
 
-        Dynamoid::Adapter.delete_item('dynamoid_tests_TestTable1', '1')
+      Dynamoid::Adapter.delete_table('CreateTable')
+    end
+  end
 
-        Dynamoid::Adapter.get_item('dynamoid_tests_TestTable1', '1').should be_nil
-      end
 
-      it 'performs GetItem for an item that does exist with a range key' do
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1', :name => 'Josh', :range => 2.0})
+  context 'with a preexisting table without paritioning' do
+    # GetItem, PutItem and DeleteItem
+    it "performs GetItem for an item that does not exist" do
+      Dynamoid::Adapter.get_item(test_table1, '1').should be_nil
+    end
 
-        Dynamoid::Adapter.get_item('dynamoid_tests_TestTable3', '1', :range_key => 2.0).should == {:name => 'Josh', :id => '1', :range => 2.0}
+    it "performs GetItem for an item that does exist" do
+      Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
 
-        Dynamoid::Adapter.delete_item('dynamoid_tests_TestTable3', '1', :range_key => 2.0)
+      Dynamoid::Adapter.get_item(test_table1, '1').should == {:name => 'Josh', :id => '1'}
 
-        Dynamoid::Adapter.get_item('dynamoid_tests_TestTable3', '1', :range_key => 2.0).should be_nil
-      end
+      Dynamoid::Adapter.delete_item(test_table1, '1')
 
-      it 'performs DeleteItem for an item that does not exist' do
-        Dynamoid::Adapter.delete_item('dynamoid_tests_TestTable1', '1')
+      Dynamoid::Adapter.get_item(test_table1, '1').should be_nil
+    end
 
-        Dynamoid::Adapter.get_item('dynamoid_tests_TestTable1', '1').should be_nil
-      end
+    it 'performs GetItem for an item that does exist with a range key' do
+      Dynamoid::Adapter.put_item(test_table3, {:id => '1', :name => 'Josh', :range => 2.0})
 
-      it 'performs PutItem for an item that does not exist' do
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
+      Dynamoid::Adapter.get_item(test_table3, '1', :range_key => 2.0).should == {:name => 'Josh', :id => '1', :range => 2.0}
 
-        Dynamoid::Adapter.get_item('dynamoid_tests_TestTable1', '1').should == {:id => '1', :name => 'Josh'}
-      end
+      Dynamoid::Adapter.delete_item(test_table3, '1', :range_key => 2.0)
 
-      # BatchGetItem
-      it "performs BatchGetItem with singular keys" do
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable2', {:id => '1', :name => 'Justin'})
+      Dynamoid::Adapter.get_item(test_table3, '1', :range_key => 2.0).should be_nil
+    end
 
-        results = Dynamoid::Adapter.batch_get_item('dynamoid_tests_TestTable1' => '1', 'dynamoid_tests_TestTable2' => '1')
-        results.size.should == 2
-        results['dynamoid_tests_TestTable1'].should include({:name => 'Josh', :id => '1'})
-        results['dynamoid_tests_TestTable2'].should include({:name => 'Justin', :id => '1'})
-      end
+    it 'performs DeleteItem for an item that does not exist' do
+      Dynamoid::Adapter.delete_item(test_table1, '1')
 
-      it "performs BatchGetItem with multiple keys" do
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2', :name => 'Justin'})
+      Dynamoid::Adapter.get_item(test_table1, '1').should be_nil
+    end
 
-        results = Dynamoid::Adapter.batch_get_item('dynamoid_tests_TestTable1' => ['1', '2'])
-        results.size.should == 1
-        results['dynamoid_tests_TestTable1'].should include({:name => 'Josh', :id => '1'})
-        results['dynamoid_tests_TestTable1'].should include({:name => 'Justin', :id => '2'})
-      end
+    it 'performs PutItem for an item that does not exist' do
+      Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
 
-      it 'performs BatchGetItem with one ranged key' do
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1', :name => 'Josh', :range => 1.0})
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '2', :name => 'Justin', :range => 2.0})
+      Dynamoid::Adapter.get_item(test_table1, '1').should == {:id => '1', :name => 'Josh'}
+    end
 
-        results = Dynamoid::Adapter.batch_get_item('dynamoid_tests_TestTable3' => [['1', 1.0]])
-        results.size.should == 1
-        results['dynamoid_tests_TestTable3'].should include({:name => 'Josh', :id => '1', :range => 1.0})
-      end
+    # BatchGetItem
+    it "performs BatchGetItem with singular keys" do
+      Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
+      Dynamoid::Adapter.put_item(test_table2, {:id => '1', :name => 'Justin'})
 
-      it 'performs BatchGetItem with multiple ranged keys' do
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1', :name => 'Josh', :range => 1.0})
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '2', :name => 'Justin', :range => 2.0})
+      results = Dynamoid::Adapter.batch_get_item(test_table1 => '1', test_table2 => '1')
+      results.size.should == 2
+      results[test_table1].should include({:name => 'Josh', :id => '1'})
+      results[test_table2].should include({:name => 'Justin', :id => '1'})
+    end
+
+    it "performs BatchGetItem with multiple keys" do
+      Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
+      Dynamoid::Adapter.put_item(test_table1, {:id => '2', :name => 'Justin'})
+
+      results = Dynamoid::Adapter.batch_get_item(test_table1 => ['1', '2'])
+      results.size.should == 1
+      results[test_table1].should include({:name => 'Josh', :id => '1'})
+      results[test_table1].should include({:name => 'Justin', :id => '2'})
+    end
+
+    it 'performs BatchGetItem with one ranged key' do
+      Dynamoid::Adapter.put_item(test_table3, {:id => '1', :name => 'Josh', :range => 1.0})
+      Dynamoid::Adapter.put_item(test_table3, {:id => '2', :name => 'Justin', :range => 2.0})
+
+      results = Dynamoid::Adapter.batch_get_item(test_table3 => [['1', 1.0]])
+      results.size.should == 1
+      results[test_table3].should include({:name => 'Josh', :id => '1', :range => 1.0})
+    end
+
+    it 'performs BatchGetItem with multiple ranged keys' do
+      Dynamoid::Adapter.put_item(test_table3, {:id => '1', :name => 'Josh', :range => 1.0})
+      Dynamoid::Adapter.put_item(test_table3, {:id => '2', :name => 'Justin', :range => 2.0})
+
+      results = Dynamoid::Adapter.batch_get_item(test_table3 => [['1', 1.0],['2', 2.0]])
+      results.size.should == 1
+      results[test_table3].should include({:name => 'Josh', :id => '1', :range => 1.0})
+      results[test_table3].should include({:name => 'Justin', :id => '2', :range => 2.0})
+    end
+    
+    # BatchDeleteItem
+    it "performs BatchDeleteItem with singular keys" do
+      Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
+      Dynamoid::Adapter.put_item(test_table2, {:id => '1', :name => 'Justin'})
 
-        results = Dynamoid::Adapter.batch_get_item('dynamoid_tests_TestTable3' => [['1', 1.0],['2', 2.0]])
-        results.size.should == 1
-        results['dynamoid_tests_TestTable3'].should include({:name => 'Josh', :id => '1', :range => 1.0})
-        results['dynamoid_tests_TestTable3'].should include({:name => 'Justin', :id => '2', :range => 2.0})
-      end
+      Dynamoid::Adapter.batch_delete_item(test_table1 => ['1'], test_table2 => ['1'])
       
-      # BatchDeleteItem
-      it "performs BatchDeleteItem with singular keys" do
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable2', {:id => '1', :name => 'Justin'})
-
-        Dynamoid::Adapter.batch_delete_item('dynamoid_tests_TestTable1' => ['1'], 'dynamoid_tests_TestTable2' => ['1'])
-        
-        results = Dynamoid::Adapter.batch_get_item('dynamoid_tests_TestTable1' => '1', 'dynamoid_tests_TestTable2' => '1')
-        results.size.should == 0
-        
-        results['dynamoid_tests_TestTable1'].should_not include({:name => 'Josh', :id => '1'})
-        results['dynamoid_tests_TestTable2'].should_not include({:name => 'Justin', :id => '1'})
-      end
-
-      it "performs BatchDeleteItem with multiple keys" do
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2', :name => 'Justin'})
-
-        Dynamoid::Adapter.batch_delete_item('dynamoid_tests_TestTable1' => ['1', '2'])
-        
-        results = Dynamoid::Adapter.batch_get_item('dynamoid_tests_TestTable1' => ['1', '2'])
-        results.size.should == 0
-        
-        results['dynamoid_tests_TestTable1'].should_not include({:name => 'Josh', :id => '1'})
-        results['dynamoid_tests_TestTable1'].should_not include({:name => 'Justin', :id => '2'})
-      end
-
-      it 'performs BatchDeleteItem with one ranged key' do
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1', :name => 'Josh', :range => 1.0})
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '2', :name => 'Justin', :range => 2.0})
-
-        Dynamoid::Adapter.batch_delete_item('dynamoid_tests_TestTable3' => [['1', 1.0]])
-        results = Dynamoid::Adapter.batch_get_item('dynamoid_tests_TestTable3' => [['1', 1.0]])
-        results.size.should == 0
-
-        results['dynamoid_tests_TestTable3'].should_not include({:name => 'Josh', :id => '1', :range => 1.0})
-      end
-
-      it 'performs BatchDeleteItem with multiple ranged keys' do
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1', :name => 'Josh', :range => 1.0})
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '2', :name => 'Justin', :range => 2.0})
-
-        Dynamoid::Adapter.batch_delete_item('dynamoid_tests_TestTable3' => [['1', 1.0],['2', 2.0]])
-        results = Dynamoid::Adapter.batch_get_item('dynamoid_tests_TestTable3' => [['1', 1.0],['2', 2.0]])
-        results.size.should == 0
-         
-        results['dynamoid_tests_TestTable3'].should_not include({:name => 'Josh', :id => '1', :range => 1.0})
-        results['dynamoid_tests_TestTable3'].should_not include({:name => 'Justin', :id => '2', :range => 2.0})
-      end
-
-      # ListTables
-      it 'performs ListTables' do
-        Dynamoid::Adapter.list_tables.should include 'dynamoid_tests_TestTable1'
-        Dynamoid::Adapter.list_tables.should include 'dynamoid_tests_TestTable2'
-      end
-
-      # Query
-      it 'performs query on a table and returns items' do
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
-
-        Dynamoid::Adapter.query('dynamoid_tests_TestTable1', :hash_value => '1').should == { :id=> '1', :name=>"Josh" }
-      end
-
-      it 'performs query on a table and returns items if there are multiple items' do
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2', :name => 'Justin'})
-
-        Dynamoid::Adapter.query('dynamoid_tests_TestTable1', :hash_value => '1').should == { :id=> '1', :name=>"Josh" }
-      end
-
-      context 'range queries' do
-        before do
-          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1', :range => 1.0})
-          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1', :range => 3.0})
-        end
-
-        it 'performs query on a table with a range and selects items in a range' do
-          Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_value => 0.0..3.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
-        end
-
-        it 'performs query on a table with a range and selects items greater than' do
-          Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_greater_than => 1.0).should =~ [{:id => '1', :range => BigDecimal.new(3)}]
-        end
-
-        it 'performs query on a table with a range and selects items less than' do
-          Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_less_than => 2.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}]
-        end
-
-        it 'performs query on a table with a range and selects items gte' do
-          Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_gte => 1.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
-        end
-
-        it 'performs query on a table with a range and selects items lte' do
-          Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_lte => 3.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
-        end
-      end
-
-      # Scan
-      it 'performs scan on a table and returns items' do
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
-
-        Dynamoid::Adapter.scan('dynamoid_tests_TestTable1', :name => 'Josh').should == [{ :id=> '1', :name=>"Josh" }]
-      end
-
-      it 'performs scan on a table and returns items if there are multiple items but only one match' do
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2', :name => 'Justin'})
-
-        Dynamoid::Adapter.scan('dynamoid_tests_TestTable1', :name => 'Josh').should == [{ :id=> '1', :name=>"Josh" }]
-      end
-
-      it 'performs scan on a table and returns multiple items if there are multiple matches' do
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2', :name => 'Josh'})
-
-        Dynamoid::Adapter.scan('dynamoid_tests_TestTable1', :name => 'Josh').should include({:name=>"Josh", :id=>"2"}, {:name=>"Josh", :id=>"1"})
-      end
-
-      it 'performs scan on a table and returns all items if no criteria are specified' do
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2', :name => 'Josh'})
-
-        Dynamoid::Adapter.scan('dynamoid_tests_TestTable1', {}).should include({:name=>"Josh", :id=>"2"}, {:name=>"Josh", :id=>"1"})
-      end
+      results = Dynamoid::Adapter.batch_get_item(test_table1 => '1', test_table2 => '1')
+      results.size.should == 0
       
-      context 'correct ordering ' do
-        before do
-          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1', :order => 1, :range => 1.0})
-          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1', :order => 2, :range => 2.0})
-          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1', :order => 3, :range => 3.0})
-          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1', :order => 4, :range => 4.0})
-          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1', :order => 5, :range => 5.0})
-          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1', :order => 6, :range => 6.0})
-        end
-
-        it 'performs query on a table with a range and selects items less than that is in the correct order, scan_index_forward true' do
-          query = Dynamoid::Adapter.query('dynamoid_tests_TestTable4', :hash_value => '1', :range_greater_than => 0, :scan_index_forward => true)
-          query[0].should == {:id => '1', :order => 1, :range => BigDecimal.new(1)}
-          query[1].should == {:id => '1', :order => 2, :range => BigDecimal.new(2)}
-          query[2].should == {:id => '1', :order => 3, :range => BigDecimal.new(3)}
-          query[3].should == {:id => '1', :order => 4, :range => BigDecimal.new(4)}
-          query[4].should == {:id => '1', :order => 5, :range => BigDecimal.new(5)}
-          query[5].should == {:id => '1', :order => 6, :range => BigDecimal.new(6)}
-        end
-        
-        it 'performs query on a table with a range and selects items less than that is in the correct order, scan_index_forward false' do
-          query = Dynamoid::Adapter.query('dynamoid_tests_TestTable4', :hash_value => '1', :range_greater_than => 0, :scan_index_forward => false)
-          query[5].should == {:id => '1', :order => 1, :range => BigDecimal.new(1)}
-          query[4].should == {:id => '1', :order => 2, :range => BigDecimal.new(2)}
-          query[3].should == {:id => '1', :order => 3, :range => BigDecimal.new(3)}
-          query[2].should == {:id => '1', :order => 4, :range => BigDecimal.new(4)}
-          query[1].should == {:id => '1', :order => 5, :range => BigDecimal.new(5)}
-          query[0].should == {:id => '1', :order => 6, :range => BigDecimal.new(6)}
-        end
-      end
+      results[test_table1].should_not include({:name => 'Josh', :id => '1'})
+      results[test_table2].should_not include({:name => 'Justin', :id => '1'})
     end
-    
-    context 'with a preexisting table with paritioning' do
-      before(:all) do
-        @previous_value = Dynamoid::Config.partitioning
-        Dynamoid::Config.partitioning = true
-        
-        Dynamoid::Adapter.create_table('dynamoid_tests_TestTable1', :id) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable1')
-        Dynamoid::Adapter.create_table('dynamoid_tests_TestTable2', :id) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable2')
-        Dynamoid::Adapter.create_table('dynamoid_tests_TestTable3', :id, :range_key => { :range => :number }) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable3')
-      end
-
-      after(:all) do
-        Dynamoid::Config.partitioning = @previous_value
-      end
-
-      # Query
-      it 'performs query on a table and returns items' do
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1.1', :name => 'Josh'})
-
-        Dynamoid::Adapter.query('dynamoid_tests_TestTable1', :hash_value => '1').first.should == { :id=> '1', :name=>"Josh" }
-      end
-
-      it 'performs query on a table and returns items if there are multiple items' do
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1.1', :name => 'Josh'})
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2.1', :name => 'Justin'})
-
-        Dynamoid::Adapter.query('dynamoid_tests_TestTable1', :hash_value => '1').first.should == { :id=> '1', :name=>"Josh" }
-      end
-
-      context 'range queries' do
-        before do
-          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1.1', :range => 1.0})
-          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1.1', :range => 3.0})
-        end
-
-        it 'performs query on a table with a range and selects items in a range' do
-          Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_value => 0.0..3.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
-        end
-
-        it 'performs query on a table with a range and selects items greater than' do
-          Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_greater_than => 1.0).should =~ [{:id => '1', :range => BigDecimal.new(3)}]
-        end
-
-        it 'performs query on a table with a range and selects items less than' do
-          Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_less_than => 2.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}]
-        end
-
-        it 'performs query on a table with a range and selects items gte' do
-          Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_gte => 1.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
-        end
-
-        it 'performs query on a table with a range and selects items lte' do
-          Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_lte => 3.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
-        end
-      end
-
-      # Scan
-      it 'performs scan on a table and returns items' do
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1.1', :name => 'Josh'})
-
-        Dynamoid::Adapter.scan('dynamoid_tests_TestTable1', :name => 'Josh').should == [{ :id=> '1', :name=>"Josh" }]
-      end
-
-      it 'performs scan on a table and returns items if there are multiple items but only one match' do
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1.1', :name => 'Josh'})
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2.1', :name => 'Justin'})
-
-        Dynamoid::Adapter.scan('dynamoid_tests_TestTable1', :name => 'Josh').should == [{ :id=> '1', :name=>"Josh" }]
-      end
-
-      it 'performs scan on a table and returns multiple items if there are multiple matches' do
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1.1', :name => 'Josh'})
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2.1', :name => 'Josh'})
-
-        Dynamoid::Adapter.scan('dynamoid_tests_TestTable1', :name => 'Josh').should include({:name=>"Josh", :id=>"2"}, {:name=>"Josh", :id=>"1"})
-      end
-
-      it 'performs scan on a table and returns all items if no criteria are specified' do
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1.1', :name => 'Josh'})
-        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2.1', :name => 'Josh'})
-
-        Dynamoid::Adapter.scan('dynamoid_tests_TestTable1', {}).should include({:name=>"Josh", :id=>"2"}, {:name=>"Josh", :id=>"1"})
-      end
+
+    it "performs BatchDeleteItem with multiple keys" do
+      Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
+      Dynamoid::Adapter.put_item(test_table1, {:id => '2', :name => 'Justin'})
+
+      Dynamoid::Adapter.batch_delete_item(test_table1 => ['1', '2'])
+      
+      results = Dynamoid::Adapter.batch_get_item(test_table1 => ['1', '2'])
+      results.size.should == 0
       
-      context 'correct ordering ' do
-        before do
-          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1.1', :range => 1.0})
-          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1.2', :range => 2.0})
-          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1.3', :range => 3.0})
-          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1.4', :range => 4.0})
-          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1.5', :range => 5.0})
-          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1.6', :range => 6.0})
-        end
-
-        it 'performs query on a table with a range and selects items less than that is in the correct order, scan_index_forward true' do
-          query = Dynamoid::Adapter.query('dynamoid_tests_TestTable4', :hash_value => '1', :range_greater_than => 0, :scan_index_forward => true)
-          query[0].should == {:id => '1', :range => BigDecimal.new(1)}
-          query[1].should == {:id => '1', :range => BigDecimal.new(2)}
-          query[2].should == {:id => '1', :range => BigDecimal.new(3)}
-          query[3].should == {:id => '1', :range => BigDecimal.new(4)}
-          query[4].should == {:id => '1', :range => BigDecimal.new(5)}
-          query[5].should == {:id => '1', :range => BigDecimal.new(6)}
-        end
-        
-        it 'performs query on a table with a range and selects items less than that is in the correct order, scan_index_forward false' do
-          query = Dynamoid::Adapter.query('dynamoid_tests_TestTable4', :hash_value => '1', :range_greater_than => 0, :scan_index_forward => false)
-          query[5].should == {:id => '1', :range => BigDecimal.new(1)}
-          query[4].should == {:id => '1', :range => BigDecimal.new(2)}
-          query[3].should == {:id => '1', :range => BigDecimal.new(3)}
-          query[2].should == {:id => '1', :range => BigDecimal.new(4)}
-          query[1].should == {:id => '1', :range => BigDecimal.new(5)}
-          query[0].should == {:id => '1', :range => BigDecimal.new(6)}
-        end
-      end
-    end
-
-    # DescribeTable
-
-    # UpdateItem
-
-    # UpdateTable
+      results[test_table1].should_not include({:name => 'Josh', :id => '1'})
+      results[test_table1].should_not include({:name => 'Justin', :id => '2'})
+    end
+
+    it 'performs BatchDeleteItem with one ranged key' do
+      Dynamoid::Adapter.put_item(test_table3, {:id => '1', :name => 'Josh', :range => 1.0})
+      Dynamoid::Adapter.put_item(test_table3, {:id => '2', :name => 'Justin', :range => 2.0})
+
+      Dynamoid::Adapter.batch_delete_item(test_table3 => [['1', 1.0]])
+      results = Dynamoid::Adapter.batch_get_item(test_table3 => [['1', 1.0]])
+      results.size.should == 0
+
+      results[test_table3].should_not include({:name => 'Josh', :id => '1', :range => 1.0})
+    end
+
+    it 'performs BatchDeleteItem with multiple ranged keys' do
+      Dynamoid::Adapter.put_item(test_table3, {:id => '1', :name => 'Josh', :range => 1.0})
+      Dynamoid::Adapter.put_item(test_table3, {:id => '2', :name => 'Justin', :range => 2.0})
+
+      Dynamoid::Adapter.batch_delete_item(test_table3 => [['1', 1.0],['2', 2.0]])
+      results = Dynamoid::Adapter.batch_get_item(test_table3 => [['1', 1.0],['2', 2.0]])
+      results.size.should == 0
+       
+      results[test_table3].should_not include({:name => 'Josh', :id => '1', :range => 1.0})
+      results[test_table3].should_not include({:name => 'Justin', :id => '2', :range => 2.0})
+    end
+
+    # ListTables
+    it 'performs ListTables' do
+      #Force creation of the tables
+      test_table1; test_table2; test_table3; test_table4
 
+      Dynamoid::Adapter.list_tables.should include test_table1
+      Dynamoid::Adapter.list_tables.should include test_table2
+    end
+
+    # Query
+    it 'performs query on a table and returns items' do
+      Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
+
+      Dynamoid::Adapter.query(test_table1, :hash_value => '1').should == { :id=> '1', :name=>"Josh" }
+    end
+
+    it 'performs query on a table and returns items if there are multiple items' do
+      Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
+      Dynamoid::Adapter.put_item(test_table1, {:id => '2', :name => 'Justin'})
+
+      Dynamoid::Adapter.query(test_table1, :hash_value => '1').should == { :id=> '1', :name=>"Josh" }
+    end
+    
+    it_behaves_like 'range queries'
+
+    # Scan
+    it 'performs scan on a table and returns items' do
+      Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
+
+      Dynamoid::Adapter.scan(test_table1, :name => 'Josh').should == [{ :id=> '1', :name=>"Josh" }]
+    end
+
+    it 'performs scan on a table and returns items if there are multiple items but only one match' do
+      Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
+      Dynamoid::Adapter.put_item(test_table1, {:id => '2', :name => 'Justin'})
+
+      Dynamoid::Adapter.scan(test_table1, :name => 'Josh').should == [{ :id=> '1', :name=>"Josh" }]
+    end
+
+    it 'performs scan on a table and returns multiple items if there are multiple matches' do
+      Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
+      Dynamoid::Adapter.put_item(test_table1, {:id => '2', :name => 'Josh'})
+
+      Dynamoid::Adapter.scan(test_table1, :name => 'Josh').should include({:name=>"Josh", :id=>"2"}, {:name=>"Josh", :id=>"1"})
+    end
+
+    it 'performs scan on a table and returns all items if no criteria are specified' do
+      Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
+      Dynamoid::Adapter.put_item(test_table1, {:id => '2', :name => 'Josh'})
+
+      Dynamoid::Adapter.scan(test_table1, {}).should include({:name=>"Josh", :id=>"2"}, {:name=>"Josh", :id=>"1"})
+    end
+    
+    it_behaves_like 'correct ordering'
+  end
+  
+  context 'with a preexisting table with paritioning' do
+    before(:all) do
+      @previous_value = Dynamoid::Config.partitioning
+      Dynamoid::Config.partitioning = true
+    end
+
+    after(:all) do
+      Dynamoid::Config.partitioning = @previous_value
+    end
+
+    # Query
+    it 'performs query on a table and returns items' do
+      Dynamoid::Adapter.put_item(test_table1, {:id => '1.1', :name => 'Josh'})
+
+      Dynamoid::Adapter.query(test_table1, :hash_value => '1').first.should == { :id=> '1', :name=>"Josh" }
+    end
+
+    it 'performs query on a table and returns items if there are multiple items' do
+      Dynamoid::Adapter.put_item(test_table1, {:id => '1.1', :name => 'Josh'})
+      Dynamoid::Adapter.put_item(test_table1, {:id => '2.1', :name => 'Justin'})
+
+      Dynamoid::Adapter.query(test_table1, :hash_value => '1').first.should == { :id=> '1', :name=>"Josh" }
+    end
+
+    it_behaves_like 'range queries'
+
+    # Scan
+    it 'performs scan on a table and returns items' do
+      Dynamoid::Adapter.put_item(test_table1, {:id => '1.1', :name => 'Josh'})
+
+      Dynamoid::Adapter.scan(test_table1, :name => 'Josh').should == [{ :id=> '1', :name=>"Josh" }]
+    end
+
+    it 'performs scan on a table and returns items if there are multiple items but only one match' do
+      Dynamoid::Adapter.put_item(test_table1, {:id => '1.1', :name => 'Josh'})
+      Dynamoid::Adapter.put_item(test_table1, {:id => '2.1', :name => 'Justin'})
+
+      Dynamoid::Adapter.scan(test_table1, :name => 'Josh').should == [{ :id=> '1', :name=>"Josh" }]
+    end
+
+    it 'performs scan on a table and returns multiple items if there are multiple matches' do
+      Dynamoid::Adapter.put_item(test_table1, {:id => '1.1', :name => 'Josh'})
+      Dynamoid::Adapter.put_item(test_table1, {:id => '2.1', :name => 'Josh'})
+
+      Dynamoid::Adapter.scan(test_table1, :name => 'Josh').should include({:name=>"Josh", :id=>"2"}, {:name=>"Josh", :id=>"1"})
+    end
+
+    it 'performs scan on a table and returns all items if no criteria are specified' do
+      Dynamoid::Adapter.put_item(test_table1, {:id => '1.1', :name => 'Josh'})
+      Dynamoid::Adapter.put_item(test_table1, {:id => '2.1', :name => 'Josh'})
+
+      Dynamoid::Adapter.scan(test_table1, {}).should include({:name=>"Josh", :id=>"2"}, {:name=>"Josh", :id=>"1"})
+    end
+
+    it_behaves_like 'correct ordering'
   end
+
+  # DescribeTable
+
+  # UpdateItem
+
+  # UpdateTable
 end

data/spec/dynamoid/persistence_spec.rb

@@ -90,9 +90,11 @@ describe "Dynamoid::Persistence" do
     Address.undump(@address.send(:dump))[:options].should == hash
   end
   
-  it 'dumps a boolean field' do
-    @address.deliverable = true
-    Address.undump(@address.send(:dump))[:deliverable].should == true
+  [true, false].each do |bool|
+    it "dumps a #{bool} boolean field" do
+      @address.deliverable = bool
+      Address.undump(@address.send(:dump))[:deliverable].should == bool
+    end
   end
   
   it 'raises on an invalid boolean value' do
@@ -158,21 +160,33 @@ describe "Dynamoid::Persistence" do
     end
   end
 
-  it 'raises when dumping a column with an unknown field type' do
-    clazz = Class.new do
-      include Dynamoid::Document
-      table :name => :addresses
+  context 'unknown fields' do
+    let(:clazz) do
+      Class.new do
+        include Dynamoid::Document
+        table :name => :addresses
 
-      field :city
-      field :options, :serialized
-      field :deliverable, :bad_type_specifier
+        field :city
+        field :options, :serialized
+        field :deliverable, :bad_type_specifier
+      end
     end
-    
-    expect do
-      clazz.new(:deliverable => true).dump
-    end.to raise_error(ArgumentError)
-  end
 
+    it 'raises when undumping a column with an unknown field type' do
+      expect do
+        clazz.new(:deliverable => true) #undump is called here
+      end.to raise_error(ArgumentError)
+    end
+  
+    it 'raises when dumping a column with an unknown field type' do
+      doc = clazz.new
+      doc.deliverable = true
+      expect do
+        doc.dump
+      end.to raise_error(ArgumentError)
+    end
+  end
+  
   context 'update' do
 
     before :each do

data/spec/spec_helper.rb

@@ -7,17 +7,21 @@ require 'rspec'
 require 'dynamoid'
 require 'pry'
 require 'mocha'
+require 'aws-sdk'
 
 ENV['ACCESS_KEY'] ||= 'abcd'
 ENV['SECRET_KEY'] ||= '1234'
 
+AWS.config({
+    :access_key_id => ENV['ACCESS_KEY'],
+    :secret_access_key => ENV['SECRET_KEY'],
+    :dynamo_db_endpoint => 'localhost',
+    :dynamo_db_port => '4567',
+    :use_ssl => false
+})
+
 Dynamoid.configure do |config|
   config.adapter = 'aws_sdk'
-  config.access_key = ENV['ACCESS_KEY']
-  config.secret_key = ENV['SECRET_KEY']
-  config.endpoint = 'localhost'
-  config.port = '4567'
-  config.use_ssl = false
   config.namespace = 'dynamoid_tests'
   config.warn_on_scan = false
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynamoid
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-19 00:00:00.000000000 Z
+date: 2013-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -362,7 +362,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1769474617671935621
+      hash: 4089934294152976145
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -371,7 +371,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Dynamoid is an ORM for Amazon's DynamoDB