Dynamoid 0.0.1

data/spec/dynamoid/adapter/local_spec.rb

@@ -0,0 +1,150 @@
+require 'dynamoid/adapter/local'
+require File.expand_path(File.dirname(__FILE__) + '../../../spec_helper')
+
+describe Dynamoid::Adapter::Local do
+
+  unless ENV['ACCESS_KEY'] && ENV['SECRET_KEY']
+  
+    # BatchGetItem
+    it 'performs BatchGetItem with singular keys' do
+      Dynamoid::Adapter.create_table('table1', :id)
+      Dynamoid::Adapter.put_item('table1', {:id => '1', :name => 'Josh'})
+      Dynamoid::Adapter.create_table('table2', :id)
+      Dynamoid::Adapter.put_item('table2', {:id => '1', :name => 'Justin'})    
+    
+      results = Dynamoid::Adapter.batch_get_item('table1' => '1', 'table2' => '1')
+      results.size.should == 2
+      results['table1'].should include({:name => 'Josh', :id => '1'})
+      results['table2'].should include({:name => 'Justin', :id => '1'})
+    end
+  
+    it 'performs BatchGetItem with multiple keys' do
+      Dynamoid::Adapter.create_table('table1', :id)
+      Dynamoid::Adapter.put_item('table1', {:id => '1', :name => 'Josh'})
+      Dynamoid::Adapter.put_item('table1', {:id => '2', :name => 'Justin'})
+    
+      results = Dynamoid::Adapter.batch_get_item('table1' => ['1', '2'])
+      results.size.should == 1
+      results['table1'].should include({:name => 'Josh', :id => '1'})
+      results['table1'].should include({:name => 'Justin', :id => '2'})
+    end
+  
+    # CreateTable
+    it 'performs CreateTable' do
+      Dynamoid::Adapter.create_table('Test Table', :id)
+    
+      Dynamoid::Adapter.list_tables.should include 'Test Table'
+    end
+  
+    # DeleteItem
+    it 'performs DeleteItem' do
+      Dynamoid::Adapter.create_table('table1', :id)
+      Dynamoid::Adapter.put_item('table1', {:id => '1', :name => 'Josh'})
+    
+      Dynamoid::Adapter.delete_item('table1', '1')
+    
+      Dynamoid::Adapter.data['table1'][:data].should be_empty
+    end
+  
+    it 'performs DeleteItem for an item that does not exist' do
+      Dynamoid::Adapter.create_table('table1', :id)
+    
+      Dynamoid::Adapter.delete_item('table1', '1')
+    
+      Dynamoid::Adapter.data['table1'][:data].should be_empty
+    end
+  
+    # DeleteTable
+    it 'performs DeleteTable' do
+      Dynamoid::Adapter.create_table('table1', :id)
+    
+      Dynamoid::Adapter.delete_table('table1')
+    
+      Dynamoid::Adapter.data['table1'].should be_nil
+    end
+  
+    # DescribeTable
+  
+    # GetItem
+    it "performs GetItem for an item that does not exist" do
+      Dynamoid::Adapter.create_table('Test Table', :id)
+    
+      Dynamoid::Adapter.get_item('Test Table', '1').should be_nil
+    end
+  
+    it "performs GetItem for an item that does exist" do
+      Dynamoid::Adapter.create_table('Test Table', :id)
+      Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Josh'})
+    
+      Dynamoid::Adapter.get_item('Test Table', '1').should == {:id => '1', :name => 'Josh'}
+    end
+  
+    # ListTables
+    it 'performs ListTables' do
+      Dynamoid::Adapter.create_table('Table1', :id)
+      Dynamoid::Adapter.create_table('Table2', :id)
+    
+      Dynamoid::Adapter.list_tables.should include 'Table1'
+      Dynamoid::Adapter.list_tables.should include 'Table2'
+    end
+  
+    # PutItem
+    it 'performs PutItem for an item that does not exist' do
+      Dynamoid::Adapter.create_table('Test Table', :id)
+      Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Josh'})
+    
+      Dynamoid::Adapter.data['Test Table'].should == { :id => :id, :data => { '1' => { :id=> '1', :name=>"Josh" }}}
+    end
+  
+    # Query
+    it 'performs query on a table and returns items' do
+      Dynamoid::Adapter.create_table('Test Table', :id)
+      Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Josh'})
+    
+      Dynamoid::Adapter.query('Test Table', '1').should == { :id=> '1', :name=>"Josh" }
+    end
+  
+    it 'performs query on a table and returns items if there are multiple items' do
+      Dynamoid::Adapter.create_table('Test Table', :id)
+      Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Josh'})
+      Dynamoid::Adapter.put_item('Test Table', {:id => '2', :name => 'Justin'})
+    
+      Dynamoid::Adapter.query('Test Table', '1').should == { :id=> '1', :name=>"Josh" }
+    end
+  
+    # Scan
+    it 'performs scan on a table and returns items' do
+      Dynamoid::Adapter.create_table('Test Table', :id)
+      Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Josh'})
+    
+      Dynamoid::Adapter.scan('Test Table', :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.create_table('Test Table', :id)
+      Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Josh'})
+      Dynamoid::Adapter.put_item('Test Table', {:id => '2', :name => 'Justin'})
+    
+      Dynamoid::Adapter.scan('Test Table', :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.create_table('Test Table', :id)
+      Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Josh'})
+      Dynamoid::Adapter.put_item('Test Table', {:id => '2', :name => 'Josh'})
+    
+      Dynamoid::Adapter.scan('Test Table', :name => 'Josh').should == [{ :id=> '1', :name=>"Josh" }, { :id=> '2', :name=>"Josh" }]
+    end
+  
+    # UpdateItem
+  
+    # UpdateTable
+  
+    protected
+  
+    def setup_value(table, key, value)
+      Dynamoid::Adapter.data[table][key] = value
+    end
+    
+  end
+end

data/spec/dynamoid/adapter_spec.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Dynamoid::Adapter" do
+  
+  it 'extends itself automatically' do
+    lambda {Dynamoid::Adapter.list_tables}.should_not raise_error
+  end
+  
+  it 'raises nomethod if we try a method that is not on the child' do
+    lambda {Dynamoid::Adapter.foobar}.should raise_error
+  end
+
+end

data/spec/dynamoid/attributes_spec.rb

@@ -0,0 +1,31 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Dynamoid::Attributes" do
+
+  before do
+    @address = Address.new
+  end
+
+  it 'should write an attribute correctly' do
+    @address.write_attribute(:city, 'Chicago')
+  end
+  
+  it 'should write an attribute with the alias' do
+    @address[:city] = 'Chicago'
+  end
+  
+  it 'should read a written attribute' do
+    @address.write_attribute(:city, 'Chicago')
+    @address.read_attribute(:city).should == 'Chicago'
+  end
+  
+  it 'should read a written attribute with the alias' do
+    @address.write_attribute(:city, 'Chicago')
+    @address[:city].should == 'Chicago'
+  end
+  
+  it 'returns all attributes' do
+    Address.attributes.should == [:id, :city]
+  end
+
+end

data/spec/dynamoid/document_spec.rb

@@ -0,0 +1,38 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Dynamoid::Document" do
+
+  it 'initializes a new document' do
+    @address = Address.new
+    
+    @address.new_record.should be_true
+    @address.attributes.should == {:id => nil, :city => nil}
+  end
+  
+  it 'initializes a new document with attributes' do
+    @address = Address.new(:city => 'Chicago')
+    
+    @address.new_record.should be_true
+    
+    @address.attributes.should == {:id => nil, :city => 'Chicago'}
+  end
+  
+  it 'creates a new document' do
+    @address = Address.create(:city => 'Chicago')
+    
+    @address.new_record.should be_false
+    @address.id.should_not be_nil
+  end
+  
+  it 'tests equivalency with itself' do
+    @addres.should == @address
+  end
+  
+  it 'is not equivalent to another document' do
+    @address.should_not == Address.create
+  end
+  
+  it 'is not equivalent to another object' do
+    @address.should_not == "test"
+  end
+end

data/spec/dynamoid/fields_spec.rb

@@ -0,0 +1,26 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Dynamoid::Fields" do
+
+  before do
+    @address = Address.new
+  end
+
+  it 'declares read attributes' do
+    @address.city.should be_nil
+  end
+  
+  it 'declares write attributes' do
+    @address.city = 'Chicago' 
+    @address.city.should == 'Chicago'
+  end
+  
+  it 'declares a query attribute' do
+    @address.city?.should be_false
+    
+    @address.city = 'Chicago'
+    
+    @address.city?.should be_true
+  end
+  
+end

data/spec/dynamoid/finders_spec.rb

@@ -0,0 +1,110 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Dynamoid::Finders" do
+
+  before do
+    @address = Address.create(:city => 'Chicago')
+  end
+
+  it 'finds an existing address' do
+    found = Address.find(@address.id)
+    
+    found.should == @address
+    found.city.should == 'Chicago'
+  end
+  
+  it 'is not a new object' do
+    found = Address.find(@address.id)
+    
+    found.new_record.should_not be_true
+  end
+  
+  it 'finds multiple ids' do
+    @address2 = Address.create(:city => 'Illinois')
+    
+    Address.find(@address.id, @address2.id).should include @address, @address2
+  end  
+  
+  context 'with users' do
+    before do
+      User.create_indexes
+    end
+    
+    it 'finds using method_missing for attributes' do
+      array = Address.find_by_city('Chicago')
+
+      array.should == @address
+    end
+
+    it 'finds using method_missing for multiple attributes' do
+      @user = User.create(:name => 'Josh', :email => 'josh@joshsymonds.com')
+
+      array = User.find_all_by_name_and_email('Josh', 'josh@joshsymonds.com')
+
+      array.should == [@user]
+    end
+
+    it 'finds using method_missing for single attributes and multiple results' do
+      @user1 = User.create(:name => 'Josh', :email => 'josh@joshsymonds.com')
+      @user2 = User.create(:name => 'Josh', :email => 'josh@joshsymonds.com')
+
+      array = User.find_all_by_name('Josh')
+
+      array.size.should == 2
+      array.should include @user1
+      array.should include @user2
+    end
+
+    it 'finds using method_missing for multiple attributes and multiple results' do
+      @user1 = User.create(:name => 'Josh', :email => 'josh@joshsymonds.com')
+      @user2 = User.create(:name => 'Josh', :email => 'josh@joshsymonds.com')
+
+      array = User.find_all_by_name_and_email('Josh', 'josh@joshsymonds.com')
+
+      array.size.should == 2
+      array.should include @user1
+      array.should include @user2
+    end
+
+    it 'finds using method_missing for multiple attributes and no results' do
+      @user1 = User.create(:name => 'Josh', :email => 'josh@joshsymonds.com')
+      @user2 = User.create(:name => 'Justin', :email => 'justin@joshsymonds.com')
+
+      array = User.find_all_by_name_and_email('Gaga','josh@joshsymonds.com')
+
+      array.should be_empty
+    end
+    
+    it 'finds using method_missing for a single attribute and no results' do
+      @user1 = User.create(:name => 'Josh', :email => 'josh@joshsymonds.com')
+      @user2 = User.create(:name => 'Justin', :email => 'justin@joshsymonds.com')
+
+      array = User.find_all_by_name('Gaga')
+
+      array.should be_empty
+    end
+
+    it 'should find on a query that is not indexed' do
+      @user = User.create(:password => 'Test')
+
+      array = User.find_all_by_password('Test')
+
+      array.should == [@user]
+    end
+
+    it 'should find on a query on multiple attributes that are not indexed' do
+      @user = User.create(:password => 'Test', :name => 'Josh')
+
+      array = User.find_all_by_password_and_name('Test', 'Josh')
+
+      array.should == [@user]
+    end
+    
+    it 'should return an empty array when fields exist but nothing is found' do
+      array = User.find_all_by_password('Test')
+      
+      array.should be_empty
+    end
+
+  end
+end

data/spec/dynamoid/indexes_spec.rb

@@ -0,0 +1,54 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Dynamoid::Indexes" do
+  
+  before do
+    User.create_indexes
+  end
+
+  it 'raises an error if a field does not exist' do
+    lambda {User.send(:index, :test)}.should raise_error(Dynamoid::Errors::InvalidField)
+  end
+  
+  it 'adds indexes to the index array' do
+    User.indexes.should == [[:name], [:email], [:email, :name]]
+  end
+  
+  it 'reorders index names alphabetically' do
+    User.indexes.last.should == [:email, :name]
+  end
+  
+  it 'creates a name for a table index' do
+    User.index_table_name([:email, :name]).should == 'dynamoid_tests_index_user_emails_and_names'
+  end
+  
+  it 'creates a key name for a table index' do
+    User.index_key_name([:email, :name]).should == 'user_emails_and_names'
+  end
+  
+  it 'creates a table after an index is created' do
+    User.send(:index, :password)
+    
+    User.table_exists?(User.index_table_name([:password])).should be_true
+  end
+  
+  it 'assembles a hashed value for the key of an index' do
+    @user = User.create(:name => 'Josh', :email => 'josh@joshsymonds.com')
+    
+    @user.key_for_index([:email, :name]).should == (Digest::SHA2.new << 'Josh' << 'josh@joshsymonds.com').to_s
+  end
+  
+  it 'saves indexes to their tables' do
+    @user = User.create(:name => 'Josh')
+    
+    Dynamoid::Adapter.get_item("dynamoid_tests_index_user_names", @user.key_for_index([:name])).should == {@user.class.index_key_name([:name]).to_sym => @user.key_for_index([:name]), :ids => Set[@user.id]}
+  end
+  
+  it 'saves multiple indexes with the same value as an array' do
+    @user1 = User.create(:name => 'Josh')
+    @user2 = User.create(:name => 'Josh')
+    
+    Dynamoid::Adapter.get_item("dynamoid_tests_index_user_names", @user1.key_for_index([:name])).should == {@user1.class.index_key_name([:name]).to_sym => @user1.key_for_index([:name]), :ids => Set[@user2.id, @user1.id]}
+  end
+    
+end

data/spec/dynamoid/persistence_spec.rb

@@ -0,0 +1,55 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Dynamoid::Persistence" do
+  
+  before do
+    @address = Address.new
+  end
+  
+  context 'without AWS keys' do
+    unless ENV['ACCESS_KEY'] && ENV['SECRET_KEY']
+      before do
+        Dynamoid::Adapter.delete_table(Address.table_name) if Dynamoid::Adapter.list_tables.include?(Address.table_name)
+      end
+    
+      it 'creates a table' do
+        Address.create_table(Address.table_name)
+
+        Dynamoid::Adapter.list_tables.should include 'dynamoid_tests_addresses'
+      end
+
+      it 'checks if a table already exists' do
+        Address.create_table(Address.table_name)
+
+        Address.table_exists?(Address.table_name).should be_true
+        Address.table_exists?('crazytable').should be_false
+      end
+    end
+  end
+  
+  
+  it 'assigns itself an id on save' do
+    @address.save
+    
+    Dynamoid::Adapter.get_item("dynamoid_tests_addresses", @address.id)[:id].should == @address.id
+  end
+  
+  it 'assigns itself an id on save only if it does not have one' do
+    @address.id = 'test123'
+    @address.save
+    
+    Dynamoid::Adapter.get_item("dynamoid_tests_addresses", 'test123').should_not be_empty
+  end
+  
+  it 'has a table name' do
+    Address.table_name.should == 'dynamoid_tests_addresses'
+  end
+    
+  it 'saves indexes along with itself' do
+    @user = User.new(:name => 'Josh')
+    
+    @user.expects(:save_indexes).once.returns(true)
+    @user.save
+  end
+
+end