dynamoid 0.7.1 → 1.0.0

data/lib/dynamoid/indexes/index.rb

@@ -1,103 +0,0 @@
-# encoding: utf-8
-module Dynamoid #:nodoc:
-  module Indexes
-
-    # The class contains all the information an index contains, including its keys and which attributes it covers.
-    class Index
-      attr_accessor :source, :name, :hash_keys, :range_keys
-      alias_method :range_key?, :range_keys
-      
-      # Create a new index. Pass either :range => true or :range => :column_name to create a ranged index on that column.
-      #
-      # @param [Class] source the source class for the index
-      # @param [Symbol] name the name of the index
-      #
-      # @since 0.2.0      
-      def initialize(source, name, options = {})
-        @source = source
-        
-        if options.delete(:range)
-          @range_keys = sort(name)
-        elsif options[:range_key]
-          @range_keys = sort(options[:range_key])
-        end
-        @hash_keys = sort(name)
-        @name = sort([hash_keys, range_keys])
-        
-        raise Dynamoid::Errors::InvalidField, 'A key specified for an index is not a field' unless keys.all?{|n| source.attributes.include?(n)}
-      end
-      
-      # Sort objects into alphabetical strings, used for composing index names correctly (since we always assume they're alphabetical).
-      #
-      # @example find all users by first and last name
-      #   sort([:gamma, :alpha, :beta, :omega]) # => [:alpha, :beta, :gamma, :omega]
-      #
-      # @since 0.2.0         
-      def sort(objs)
-        Array(objs).flatten.compact.uniq.collect(&:to_s).sort.collect(&:to_sym)
-      end
-
-      # Return the array of keys this index uses for its table.
-      #
-      # @since 0.2.0      
-      def keys
-        [Array(hash_keys) + Array(range_keys)].flatten.uniq
-      end
-      
-      # Return the table name for this index.
-      #
-      # @since 0.2.0
-      def table_name
-        "#{Dynamoid::Config.namespace}_index_" + source.table_name.sub("#{Dynamoid::Config.namespace}_", '').singularize + "_#{name.collect(&:to_s).collect(&:pluralize).join('_and_')}"
-      end
-
-      # Given either an object or a list of attributes, generate a hash key and a range key for the index. Optionally pass in 
-      # true to changed_attributes for a list of all the object's dirty attributes in convenient index form (for deleting stale 
-      # information from the indexes).
-      #
-      # @param [Object] attrs either an object that responds to :attributes, or a hash of attributes
-      #
-      # @return [Hash] a hash with the keys :hash_value and :range_value
-      #
-      # @since 0.2.0
-      def values(attrs, changed_attributes = false)
-        if changed_attributes
-          hash = {}
-          attrs.changes.each {|k, v| hash[k.to_sym] = (v.first || v.last)}
-          attrs = hash
-        end
-        attrs = attrs.send(:attributes) if attrs.respond_to?(:attributes)
-        {}.tap do |hash|
-          hash[:hash_value] = hash_keys.collect{|key| attrs[key]}.join('.')
-          hash[:range_value] = range_keys.inject(0.0) {|sum, key| sum + attrs[key].to_f} if self.range_key?
-        end
-      end
-      
-      # Save an object to this index, merging it with existing ids if there's already something present at this index location.
-      # First, though, delete this object from its old indexes (so the object isn't listed in an erroneous index).
-      #
-      # @since 0.2.0
-      def save(obj)
-        self.delete(obj, true)
-        values = values(obj)
-        return true if values[:hash_value].blank? || (!values[:range_value].nil? && values[:range_value].blank?)
-        existing = Dynamoid::Adapter.read(self.table_name, values[:hash_value], { :range_key => values[:range_value] })
-        ids = ((existing and existing[:ids]) or Set.new)
-        Dynamoid::Adapter.write(self.table_name, {:id => values[:hash_value], :ids => ids.merge([obj.id]), :range => values[:range_value]})
-      end
-
-      # Delete an object from this index, preserving existing ids if there are any, and failing gracefully if for some reason the 
-      # index doesn't already have this object in it.
-      #
-      # @since 0.2.0      
-      def delete(obj, changed_attributes = false)
-        values = values(obj, changed_attributes)
-        return true if values[:hash_value].blank? || (!values[:range_value].nil? && values[:range_value].blank?)
-        existing = Dynamoid::Adapter.read(self.table_name, values[:hash_value], { :range_key => values[:range_value]})
-        return true unless existing && existing[:ids] && existing[:ids].include?(obj.id)
-        Dynamoid::Adapter.write(self.table_name, {:id => values[:hash_value], :ids => (existing[:ids] - Set[obj.id]), :range => values[:range_value]})
-      end
-      
-    end
-  end
-end

data/spec/app/models/address.rb

@@ -1,13 +0,0 @@
-class Address
-  include Dynamoid::Document
-  
-  field :city
-  field :options, :serialized
-  field :deliverable, :boolean
-  
-  field :lock_version, :integer #Provides Optimistic Locking
-
-  def zip_code=(zip_code)
-    self.city = "Chicago"
-  end
-end

data/spec/app/models/camel_case.rb

@@ -1,34 +0,0 @@
-class CamelCase
-  include Dynamoid::Document
-
-  field :color
-
-  belongs_to :magazine
-  has_many :users
-  has_one :sponsor
-  has_and_belongs_to_many :subscriptions
-  
-  before_create :doing_before_create
-  after_create :doing_after_create
-  before_update :doing_before_update
-  after_update :doing_after_update
-  
-  private
-  
-  def doing_before_create
-    true
-  end
-  
-  def doing_after_create
-    true
-  end
-
-  def doing_before_update
-    true
-  end
-
-  def doing_after_update
-    true
-  end
-
-end

data/spec/app/models/car.rb

@@ -1,6 +0,0 @@
-require_relative 'vehicle'
-
-class Car < Vehicle
-  
-  field :power_locks, :boolean
-end

data/spec/app/models/magazine.rb

@@ -1,11 +0,0 @@
-class Magazine
-  include Dynamoid::Document
-  
-  field :title
-  
-  has_many :subscriptions
-  has_many :camel_cases
-  has_one :sponsor
-
-  belongs_to :owner, :class_name => 'User', :inverse_of => :books
-end

data/spec/app/models/message.rb

@@ -1,9 +0,0 @@
-class Message
-  include Dynamoid::Document
-
-  table name: :messages, key: :message_id, read_capacity: 200, write_capacity: 200
-
-  range :time, :datetime
-
-  field :text
-end

data/spec/app/models/nuclear_submarine.rb

@@ -1,5 +0,0 @@
-require_relative 'vehicle'
-class NuclearSubmarine < Vehicle
-  
-  field :torpedoes, :integer
-end

data/spec/app/models/sponsor.rb

@@ -1,8 +0,0 @@
-class Sponsor
-  include Dynamoid::Document
-  
-  belongs_to :magazine
-  has_many :subscriptions
-
-  belongs_to :camel_case
-end

data/spec/app/models/subscription.rb

@@ -1,12 +0,0 @@
-class Subscription
-  include Dynamoid::Document
-
-  field :length, :integer
-
-  belongs_to :magazine
-  has_and_belongs_to_many :users
-
-  belongs_to :customer, :class_name => 'User', :inverse_of => :monthly
-
-  has_and_belongs_to_many :camel_cases
-end

data/spec/app/models/tweet.rb

@@ -1,12 +0,0 @@
-class Tweet
-  include Dynamoid::Document
-
-  table name: :twitters, key: :tweet_id, read_capacity: 200, write_capacity: 200
-
-  range :group, :string
-
-  field :msg
-  field :count, :integer
-  field :tags, :set
-  field :user_name
-end

data/spec/app/models/user.rb

@@ -1,26 +0,0 @@
-class User
-  include Dynamoid::Document
-  
-  field :name
-  field :email
-  field :password
-  field :last_logged_in_at, :datetime
-  
-  index :name
-  index :email
-  index [:name, :email]
-  index :name, :range_key => :created_at
-  index :name, :range_key => :last_logged_in_at
-  index :created_at, :range => true
-  
-  has_and_belongs_to_many :subscriptions
-
-  has_many :books, :class_name => 'Magazine', :inverse_of => :owner
-  has_one :monthly, :class_name => 'Subscription', :inverse_of => :customer
-
-  has_and_belongs_to_many :followers, :class_name => 'User', :inverse_of => :following
-  has_and_belongs_to_many :following, :class_name => 'User', :inverse_of => :followers
-
-  belongs_to :camel_case
-
-end

data/spec/app/models/vehicle.rb

@@ -1,7 +0,0 @@
-class Vehicle
-  include Dynamoid::Document
-  
-  field :type
-  
-  field :description
-end

data/spec/dynamoid/adapter/aws_sdk_spec.rb

@@ -1,376 +0,0 @@
-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
-
-  #
-  # 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
-
-    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).to_a.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 in a range with :select option' do
-      Dynamoid::Adapter.query(test_table3, :hash_value => '1', :range_value => 0.0..3.0, :select => :all).to_a.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(test_table3, :hash_value => '1', :range_greater_than => 1.0).to_a.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(test_table3, :hash_value => '1', :range_less_than => 2.0).to_a.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(test_table3, :hash_value => '1', :range_gte => 1.0).to_a.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(test_table3, :hash_value => '1', :range_lte => 3.0).to_a.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 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).to_a
-      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).to_a
-      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.connection.tables.collect{|t| t.name}.should include 'CreateTable'
-
-      Dynamoid::Adapter.delete_table('CreateTable')
-    end
-  end
-
-
-  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
-
-    it "performs GetItem for an item that does exist" do
-      Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
-
-      Dynamoid::Adapter.get_item(test_table1, '1').should == {:name => 'Josh', :id => '1'}
-
-      Dynamoid::Adapter.delete_item(test_table1, '1')
-
-      Dynamoid::Adapter.get_item(test_table1, '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})
-
-      Dynamoid::Adapter.get_item(test_table3, '1', :range_key => 2.0).should == {:name => 'Josh', :id => '1', :range => 2.0}
-
-      Dynamoid::Adapter.delete_item(test_table3, '1', :range_key => 2.0)
-
-      Dynamoid::Adapter.get_item(test_table3, '1', :range_key => 2.0).should be_nil
-    end
-
-    it 'performs DeleteItem for an item that does not exist' do
-      Dynamoid::Adapter.delete_item(test_table1, '1')
-
-      Dynamoid::Adapter.get_item(test_table1, '1').should be_nil
-    end
-
-    it 'performs PutItem for an item that does not exist' do
-      Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
-
-      Dynamoid::Adapter.get_item(test_table1, '1').should == {:id => '1', :name => 'Josh'}
-    end
-
-    # BatchGetItem
-    it 'passes options to underlying BatchGet call' do
-      AWS::DynamoDB::BatchGet.any_instance.expects(:table).with(test_table1, :all, ['1', '2'], :consistent_read => true)
-      described_class.batch_get_item({test_table1 => ['1', '2']}, :consistent_read => true)
-    end
-
-    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'})
-
-      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'})
-
-      Dynamoid::Adapter.batch_delete_item(test_table1 => ['1'], test_table2 => ['1'])
-      
-      results = Dynamoid::Adapter.batch_get_item(test_table1 => '1', test_table2 => '1')
-      results.size.should == 0
-      
-      results[test_table1].should_not include({:name => 'Josh', :id => '1'})
-      results[test_table2].should_not include({:name => 'Justin', :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
-      
-      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').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', :name => 'Josh'})
-      Dynamoid::Adapter.put_item(test_table1, {:id => '2', :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', :name => 'Josh'})
-
-      Dynamoid::Adapter.scan(test_table1, :name => 'Josh').to_a.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').to_a.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