bigrecord 0.0.5

data/spec/unit/br_associations_spec.rb

@@ -0,0 +1,58 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe BigRecord::BrAssociations do
+
+  # Clear the tables before and after these tests
+  before(:all) do
+    Animal.delete_all
+    Employee.delete_all
+    Zoo.delete_all
+  end
+
+  it "should list associations in #reflections" do
+    Animal.reflections.should have_key(:zoo)
+    Animal.reflections.should have_key(:books)
+
+    Animal.reflections[:zoo].macro.should == :belongs_to_big_record
+    Animal.reflections[:books].macro.should == :belongs_to_many
+
+    Employee.reflections.should have_key(:company)
+    Employee.reflections[:company].macro.should == :belongs_to_big_record
+
+    Zoo.reflections.should have_key(:animals)
+    Zoo.reflections[:animals].macro.should == :belongs_to_many
+  end
+
+  it "should mixin all the helper methods into the model for :belongs_to associations" do
+    animal = Animal.new
+
+    animal.should respond_to(:zoo)
+    animal.should respond_to(:zoo=)
+    animal.should respond_to(:build_zoo)
+    animal.should respond_to(:create_zoo)
+  end
+
+  it "should mixin all the helper methods into the model for :belongs_to_many associations" do
+    zoo = Zoo.new
+
+    zoo.should respond_to(:animals)
+    zoo.should respond_to(:animals=)
+    zoo.should respond_to(:animal_ids)
+    zoo.should respond_to(:animal_ids=)
+    zoo.animals.should respond_to(:<<)
+    zoo.animals.should respond_to(:delete)
+    zoo.animals.should respond_to(:clear)
+    zoo.animals.should respond_to(:empty?)
+    zoo.animals.should respond_to(:size)
+  end
+
+  it "should mixin build() and create() methods into collection assocations" do
+    pending "This needs to be implemented"
+
+    zoo = Zoo.new
+
+    zoo.animals.should respond_to(:build)
+    zoo.animals.should respond_to(:create)
+  end
+
+end

data/spec/unit/embedded_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'abstract_base_spec'))
+
+describe BigRecord::Embedded do
+
+  # Clear the tables before and after these tests
+  before(:all) do
+    Zoo.delete_all
+  end
+
+  after(:all) do
+    Zoo.delete_all
+  end
+
+  it_should_behave_like "BigRecord::AbstractBase"
+
+  describe "embedded within a BigRecord::Base model" do
+
+    it "should save successfully" do
+      zoo = Zoo.new(  :name => "African Lion Safari",
+                      :address => "RR #1 Cambridge, Ontario Canada\nN1R 5S2",
+                      :description => "Canada's Original Safari Adventure")
+
+      zoo.weblink = Embedded::WebLink.new(:title => "African Lion Safari - Wikipedia", :url => "http://en.wikipedia.org/wiki/African_Lion_Safari")
+      zoo.save.should be_true
+      zoo.reload
+
+      zoo.weblink.should_not be_nil
+      zoo.weblink.should be_a_kind_of(Embedded::WebLink)
+      zoo.weblink.title.should == "African Lion Safari - Wikipedia"
+      zoo.weblink.url.should == "http://en.wikipedia.org/wiki/African_Lion_Safari"
+
+      zoo.weblink = Embedded::WebLink.new(:title => "African Lion Safari", :url => "http://www.lionsafari.com/")
+      zoo.save.should be_true
+      zoo.reload
+
+      zoo.weblink.title.should == "African Lion Safari"
+      zoo.weblink.url.should == "http://www.lionsafari.com/"
+    end
+
+  end
+
+end

data/spec/unit/find_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe BigRecord::Base do
+
+  describe "#find" do
+
+    it "should dispatch properly to #find_every when given :first" do
+      zoo = Zoo.new
+
+      Zoo.should_receive(:find_every).with(hash_including(:limit => 1)).and_return([zoo])
+
+      Zoo.find(:first).should == zoo
+    end
+
+    it "should dispatch properly to #find_every when given :all" do
+      zoo = Zoo.new
+
+      Zoo.should_receive(:find_every).and_return([zoo])
+
+      Zoo.find(:all).should == [zoo]
+    end
+
+    it "should dispatch properly to #find_from_ids when given anything else" do
+      zoo = Zoo.new
+      id = "c6e2cf62-332d-44f0-a558-dfdfe2c7ee1e"
+
+      Zoo.should_receive(:find_from_ids).with([id], an_instance_of(Hash)).and_return([zoo])
+
+      Zoo.find(id).should == [zoo]
+    end
+
+  end
+
+end

data/spec/unit/hash_helper_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+# Not exactly the most comprehensive testing for this function.
+describe Hash do
+
+  before(:each) do
+    @hash1 = { :key1 => "value1", :key2 => "value2", :key3 => "value3" }
+    @hash2 = { :key1 => "value1", :key2 => "value2", :key3 => "value3", :key4 => "value4" }
+    @hash3 = { :key1 => "value4", :key2 => "value3", :key3 => "value1", :key4 => "value2" }
+    @hash4 = { :key2 => "value2", :key3 => "value3" }
+  end
+
+  it "#subset_of? should compare 2 hashes correctly (when one really is a subset of the other)" do
+    @hash1.subset_of?(@hash2).should be_true
+    @hash2.subset_of?(@hash1).should be_false
+  end
+
+  it "#superset_of? should compare 2 hashes correctly (when one really is a superset of the other)" do
+    @hash1.superset_of?(@hash2).should be_false
+    @hash2.superset_of?(@hash1).should be_true
+  end
+
+  it "#subset_of? and #superset_of? should be true when comparing the same hash to itself" do
+    @hash1.subset_of?(@hash1).should be_true
+    @hash1.superset_of?(@hash1).should be_true
+
+    @hash2.subset_of?(@hash2).should be_true
+    @hash2.superset_of?(@hash2).should be_true
+  end
+
+  it "should return false when there's a mismatch of key/value pairs" do
+    @hash2.subset_of?(@hash3).should be_false
+    @hash2.superset_of?(@hash3).should be_false
+  end
+
+  it "should compare properly with missing keys in one of the hashes (even if all the other pairs match)" do
+    # false because @hash4 is missing :key1
+    @hash1.subset_of?(@hash4).should be_false
+
+    # it is a superset because all of the key/value pairs of @hash4 are contained within @hash1
+    @hash1.superset_of?(@hash4).should be_true
+  end
+
+end

data/spec/unit/migration_spec.rb

@@ -0,0 +1,144 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe BigRecord::Migration do
+
+  before(:each) do
+    @migrations_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib", "migrations"))
+    @migration_files = Dir["#{@migrations_path}/[0-9]*_*.rb"]
+
+    @broken_migrations_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib", "broken_migrations"))
+    @broken_migration_files = Dir["#{@broken_migrations_path}/[0-9]*_*.rb"]
+
+    # It doesn't matter whether the adapter works for this spec, so we'll mock it
+    @mock_connection = mock(BigRecord::ConnectionAdapters::AbstractAdapter, :null_object => true)
+    @mock_connection.stub!(:supports_ddl_transactions?).and_return(false)
+
+    # Replace BigRecord::Base.connection to always return the mock_connection
+    BigRecord::Base.stub!(:connection).and_return(@mock_connection)
+
+    # We don't want it outputting to stdout
+    BigRecord::Migration.verbose = false
+  end
+
+  describe "class methods and initialization" do
+
+    it "#proper_table_name should return the corresponding table name for the data store (with different arguments types)" do
+      # Check that it works with a symbol, BigRecord model, or string.
+      BigRecord::Migrator.proper_table_name(:animals).should == "animals"
+      BigRecord::Migrator.proper_table_name(Animal).should == "animals"
+      BigRecord::Migrator.proper_table_name("animals").should == "animals"
+    end
+
+    it "#get_all_versions should query from the data store" do
+      @mock_connection.should_receive(:get_all_schema_versions).and_return(["version1"])
+
+      BigRecord::Migrator.get_all_versions.should == ["version1"]
+    end
+
+    it "should initialize the migrator given a directory of migration files" do
+      # Assuming that the adapter supports migrations
+      @mock_connection.should_receive(:supports_migrations?).and_return(true)
+
+      # Setting up the migrator will initialize the schema migration table
+      @mock_connection.should_receive(:initialize_schema_migrations_table)
+
+      # Initializing the migrator
+      migrator = BigRecord::Migrator.new(:up, @migrations_path)
+
+      # Now assuming that the adapter doesn't supports migrations
+      @mock_connection.should_receive(:supports_migrations?).and_return(false)
+
+      # Setting up the migrator should not initialize the schema migration table
+      @mock_connection.should_not_receive(:initialize_schema_migrations_table)
+
+      lambda{
+        migrator = BigRecord::Migrator.new(:up, @migrations_path)
+      }.should raise_error(StandardError)
+    end
+
+  end
+
+  describe "migrator methods" do
+
+    before(:each) do
+      # Setting up the migrator will initialize the schema migration table
+      @mock_connection.should_receive(:initialize_schema_migrations_table)
+    end
+
+    it "should show all the pending migrations" do
+      # Initializing the migrator
+      @migrator = BigRecord::Migrator.new(:up, @migrations_path)
+
+      # And request all the schema versions currently within the data store
+      @mock_connection.should_receive(:get_all_schema_versions).and_return([])
+
+      # Verify that our migrations are listed as pending
+      @migration_files.each do |migration_file|
+        @migrator.pending_migrations.map(&:filename).should include(migration_file)
+      end
+    end
+
+    it "should run the migrations and update the schema migration table in the data store" do
+      # Initializing the migrator
+      @migrator = BigRecord::Migrator.new(:up, @migrations_path)
+
+      # And request all the schema versions currently within the data store
+      @mock_connection.should_receive(:get_all_schema_versions).and_return([])
+
+      # The data store will be updated once for each migration file
+      @mock_connection.should_receive(:update).exactly(@migration_files.size).times.and_return(true)
+      result = @migrator.migrate
+
+      # The pending migrations should now be listed in the migrated #migrated method and removed from #pending_migrations
+      result.size.should == @migration_files.size
+      @migrator.migrated.size.should == @migration_files.size
+      @migrator.pending_migrations.should be_empty
+    end
+
+    it "should call the appropriate adapter connection methods when migrating :up" do
+      # Initializing the migrator
+      @migrator = BigRecord::Migrator.new(:up, @migrations_path, 20090706182535) # Hard-coded target. Don't change the migration!
+
+      # And request all the schema versions currently within the data store
+      @mock_connection.should_receive(:get_all_schema_versions).and_return([])
+
+      @mock_connection.should_receive(:create_table).with("animals", {:force => true}).once.and_return(true)
+      @migrator.migrate
+    end
+
+    it "should call the appropriate adapter connection methods when reverting :down" do
+      # Initializing the migrator
+      @migrator = BigRecord::Migrator.new(:down, @migrations_path) # Hard-coded target. Don't change the migration!
+
+      # And request all the schema versions currently within the data store.
+      @mock_connection.should_receive(:get_all_schema_versions).and_return([20090706182535]) # Hard-coded target. Don't change the migration!
+
+      @mock_connection.should_receive(:drop_table).with("animals").once.and_return(true)
+      @migrator.migrate
+    end
+
+  end
+
+  describe "error handling" do
+
+    it "should raise an error on duplicate version numbers" do
+      # Initializing the migrator
+      @migrator = BigRecord::Migrator.new(:up, @broken_migrations_path+"/duplicate_version")
+
+      lambda {
+        @migrator.migrations
+      }.should raise_error(BigRecord::DuplicateMigrationVersionError)
+    end
+
+    it "should raise an error on duplicate migration names" do
+      # Initializing the migrator
+      @migrator = BigRecord::Migrator.new(:up, @broken_migrations_path+"/duplicate_name")
+
+      lambda {
+        @migrator.migrations
+      }.should raise_error(BigRecord::DuplicateMigrationNameError)
+    end
+
+  end
+
+end

data/spec/unit/model_spec.rb

@@ -0,0 +1,315 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe BigRecord::Base do
+
+  # Clear the tables before and after these tests
+  before(:all) do
+    Book.delete_all
+  end
+
+  after(:all) do
+    Book.delete_all
+  end
+
+  it "should provide .id" do
+    Book.new.should respond_to(:id)
+  end
+
+  it "should provide hash-like attribute accessors, i.e. [] and []=" do
+    Book.new.should respond_to(:[])
+    Book.new.should respond_to(:[]=)
+  end
+
+  it 'should provide #create' do
+    Book.should respond_to(:create)
+  end
+
+  describe '#create' do
+
+    it 'should create a new record in the data store' do
+      book = Book.create(:title => "I Am Legend", :author => "Richard Matheson")
+
+      book.should be_a_kind_of(Book)
+      book.id.should_not be_nil
+      book.new_record?.should be_false
+
+      book_confirm = Book.find(book.id)
+
+      book_confirm.title.should == "I Am Legend"
+      book_confirm.author.should == "Richard Matheson"
+    end
+
+    it 'should return the unsaved object even if a record could not be created' do
+      attributes = {:title => "I Am Legend", :author => "Richard Matheson"}
+      book = Book.new(attributes)
+
+      # Mocking the #create method in Base to return a specific book object we define
+      Book.should_receive(:new).and_return(book)
+
+      # When #save is called on our book object, it'll return false.
+      book.should_receive(:save).and_return(false)
+
+      # Now we'll try the #create method on the Book class
+      created_book = Book.create(attributes)
+
+      # The save shouldn't have succeeded
+      created_book.new_record?.should be_true
+
+      # But we should still receive a book object that's the same
+      created_book.should == book
+    end
+
+  end
+
+  # Protected instance method called by .save (different than Class#create)
+  it 'should provide .create' do
+    Book.new.should respond_to(:create)
+  end
+
+  # Protected instance method called by .save
+  it 'should provide .update' do
+    Book.new.should respond_to(:update)
+  end
+
+  it 'should provide .save and .save!' do
+    Book.new.should respond_to(:save)
+    Book.new.should respond_to(:save!)
+  end
+
+  describe '.save and .save!' do
+
+    describe 'with a new resource' do
+
+      it 'should create new entries in the data store' do
+        # Create a new object
+        book = Book.new(  :title => "I Am Legend",
+                          :author => "Richard Matheson",
+                          :description => "The most clever and riveting vampire novel since Dracula.")
+
+        book.new_record?.should be_true
+        book.id.should be_nil
+        book.save.should be_true
+
+        book.new_record?.should be_false
+        book.id.should_not be_nil
+
+        # Verify that the object was saved
+        book2 = Book.find(book.id)
+
+        book2.title.should == "I Am Legend"
+        book2.author.should == "Richard Matheson"
+        book2.description.should == "The most clever and riveting vampire novel since Dracula."
+      end
+
+      it 'should raise an exception with .save! if a record was not saved or true if successful' do
+        book = Book.new(  :title => "I Am Legend",
+                          :author => "Richard Matheson",
+                          :description => "The most clever and riveting vampire novel since Dracula.")
+
+        # The actual method that's called just before the data store write is #update_big_record, which returns
+        # a boolean. We're going to mock this method and have it return false.
+        book.should_receive(:update_bigrecord).and_return(false)
+
+        # Verify that an exception is raised
+        lambda { book.save! }.should raise_error(BigRecord::RecordNotSaved)
+
+        # Verify that true gets returned on success
+        book.should_receive(:update_bigrecord).and_return(true)
+        book.save.should be_true
+      end
+
+    end
+
+    describe 'with an existing record' do
+
+      before(:each) do
+        # Just want to verify that the book is created properly everytime
+        new_book = Book.new(  :title => "I Am Legend",
+                              :author => "Richard Matheson",
+                              :description => "The most clever and riveting vampire novel since Dracula.")
+
+        new_book.save.should be_true
+
+        # Maybe a little paranoid...
+        new_book.new_record?.should be_false
+        new_book.id.should_not be_nil
+
+        # Grab the entry from the data store and verify
+        @book = Book.find(new_book)
+        @book.title.should == "I Am Legend"
+        @book.author.should == "Richard Matheson"
+        @book.description.should == "The most clever and riveting vampire novel since Dracula."
+      end
+
+      it 'should update that record' do
+        @book.description = "One of the Ten All-Time Best Novels of Vampirism."
+        @book.save.should be_true
+
+        book_verify = Book.find(@book)
+        book_verify.description.should == "One of the Ten All-Time Best Novels of Vampirism."
+        book_verify.id.should == @book.id
+      end
+
+    end
+
+  end
+
+  describe 'modified attribute tracking' do
+
+    it "should not mark attributes as modified if they are similar" do
+      pending "attribute tracking needs to be implemented in BigRecord::Base"
+
+      attributes =  {   :title => "I Am Legend",
+                        :author => "Richard Matheson",
+                        :description => "The most clever and riveting vampire novel since Dracula." }
+
+      book = Book.new(attributes)
+      book.save.should be_true
+
+      book.attributes = attributes
+
+      book.modified_attributes.should be_empty
+    end
+
+    it "should track modified attributes" do
+      pending "attribute tracking needs to be implemented in BigRecord::Base"
+
+      attributes =  {   :title => "I Am Legend",
+                        :author => "Richard Matheson",
+                        :description => "The most clever and riveting vampire novel since Dracula." }
+
+      book = Book.new(attributes)
+      book.save.should be_true
+
+      book.attributes = {:description => "One of the Ten All-Time Best Novels of Vampirism."}
+
+      book.modified_attributes.has_key?(:description).should be_true
+    end
+
+  end
+
+  describe 'attribute functionality' do
+
+    it "should return a list of attribute names with .attribute_names" do
+      (Book.new.attribute_names & ["attribute:author", "attribute:description", "attribute:links", "attribute:title"]).should == ["attribute:author", "attribute:description", "attribute:links", "attribute:title"]
+    end
+
+    it "should provide hash-like attribute accessors, i.e. [] and []=" do
+      Book.new.should respond_to(:[])
+      Book.new.should respond_to(:[]=)
+    end
+
+    it "should provide attribute accessing with .read_attribute" do
+      book = Book.new(  :title => "I Am Legend",
+                        :author => "Richard Matheson",
+                        :description => "The most clever and riveting vampire novel since Dracula.")
+
+      book.save.should be_true
+
+      book.read_attribute("attribute:title").should == "I Am Legend"
+      book.read_attribute("attribute:author").should == "Richard Matheson"
+      book.read_attribute("attribute:description").should == "The most clever and riveting vampire novel since Dracula."
+    end
+
+    it "should determine whether an attribute is present with .has_attribute?" do
+      book = Book.new
+
+      ["attribute:author", "attribute:description", "attribute:links", "attribute:title"].each do |attr|
+        book.has_attribute?(attr).should be_true
+      end
+    end
+
+    it "should determine whether an attribute is present (i.e. set either by the user or db) with .attribute_present?" do
+      book = Book.new
+
+      # Initially they should all be false
+      ["attribute:author", "attribute:description", "attribute:title"].each do |attr|
+        book.attribute_present?(attr).should be_false
+      end
+
+      book.attributes = { :title => "I Am Legend", :author => "Richard Matheson", :description => "The most clever and riveting vampire novel since Dracula." }
+
+      ["attribute:author", "attribute:description", "attribute:title"].each do |attr|
+        book.attribute_present?(attr).should be_true
+      end
+    end
+
+    it '.update_attribute(nil) should raise an exception' do
+      lambda {
+        Book.new.update_attribute(nil)
+      }.should raise_error(ArgumentError)
+    end
+
+    it ".update_attribute should update a single attribute of a record" do
+      book = Book.new(  :title => "I Am Legend",
+                        :author => "Richard Matheson",
+                        :description => "The most clever and riveting vampire novel since Dracula.")
+
+      book.new_record?.should be_true
+      book.id.should be_nil
+      book.save.should be_true
+
+      book.update_attribute(:description, "One of the Ten All-Time Best Novels of Vampirism.")
+
+      book.description.should == "One of the Ten All-Time Best Novels of Vampirism."
+    end
+
+    it ".update_attribute should return false if the attribute could not be updated" do
+      book = Book.new(  :title => "I Am Legend",
+                        :author => "Richard Matheson",
+                        :description => "The most clever and riveting vampire novel since Dracula.")
+
+      book.new_record?.should be_true
+      book.id.should be_nil
+      book.save.should be_true
+
+      book.should_receive(:save).and_return(false)
+      book.update_attribute(:description, "One of the Ten All-Time Best Novels of Vampirism.").should be_false
+    end
+
+    describe '' do
+
+      before(:each) do
+        @book = Book.new( :title => "I Am Legend",
+                          :author => "Richard Matheson",
+                          :description => "The most clever and riveting vampire novel since Dracula.")
+
+        @book.new_record?.should be_true
+        @book.id.should be_nil
+        @book.save.should be_true
+
+        @new_attributes = {:title => "A Stir of Echoes", :description => "One of the most important writers of the twentieth century."}
+      end
+
+      it ".update_attributes should update all attributes of a record" do
+        @book.update_attributes(@new_attributes).should be_true
+
+        @new_attributes.each do |key, value|
+          @book.send(key).should == value
+        end
+      end
+
+      it ".update_attributes should return false if the record couldn't be updated with those attributes" do
+        @book.should_receive(:save).and_return(false)
+        @book.update_attributes(@new_attributes).should be_false
+      end
+
+      it ".update_attributes! should update all attributes of a record" do
+        @book.update_attributes(@new_attributes).should be_true
+
+        @new_attributes.each do |key, value|
+          @book.send(key).should == value
+        end
+      end
+
+      it ".update_attributes! should raise an error when the record couldn't be updated" do
+        @book.should_receive(:save!).and_raise(BigRecord::RecordNotSaved)
+
+        lambda { @book.update_attributes!(@new_attributes) }.should raise_error(BigRecord::RecordNotSaved)
+      end
+
+    end
+
+  end
+
+end