datamapper-dm-core 0.9.11

data/spec/unit/data_mapper_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe DataMapper do
+  describe ".dependency_queue" do
+    before(:all) do
+      @q = DataMapper.dependency_queue
+    end
+
+    it "should return a dependency queue" do
+      @q.should be_a_kind_of(DataMapper::DependencyQueue)
+    end
+
+    it "should only create one dependency queue" do
+      @q.should == DataMapper.dependency_queue
+    end
+  end
+
+  describe ".prepare" do
+    it "should pass the default repository to the block if no argument is given" do
+      DataMapper.should_receive(:repository).with(no_args).and_return :default_repo
+
+      DataMapper.prepare do |r|
+        r.should == :default_repo
+      end
+    end
+
+    it "should allow custom type maps to be defined inside the prepare block" do
+      lambda {
+        DataMapper.prepare do |r|
+          r.map(String).to(:VARCHAR).with(:size => 1000)
+        end
+      }.should_not raise_error
+    end
+  end
+end

data/spec/unit/identity_map_spec.rb

@@ -0,0 +1,126 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe "DataMapper::IdentityMap" do
+  before(:all) do
+    class ::Cow
+      include DataMapper::Resource
+      property :id, Integer, :key => true
+      property :name, String
+    end
+
+    class ::Chicken
+      include DataMapper::Resource
+      property :name, String
+    end
+
+    class ::Pig
+      include DataMapper::Resource
+      property :id, Integer, :key => true
+      property :composite, Integer, :key => true
+      property :name, String
+    end
+  end
+
+  it "should use a second level cache if created with on"
+
+  it "should return nil on #get when it does not find the requested instance" do
+    map = DataMapper::IdentityMap.new
+    map.get([23]).should be_nil
+  end
+
+  it "should return an instance on #get when it finds the requested instance" do
+    betsy = Cow.new({:id=>23,:name=>'Betsy'})
+    map = DataMapper::IdentityMap.new
+    map.set(betsy.key, betsy)
+    map.get([23]).should == betsy
+  end
+
+  it "should store an instance on #set" do
+    betsy = Cow.new({:id=>23,:name=>'Betsy'})
+    map = DataMapper::IdentityMap.new
+    map.set(betsy.key, betsy)
+    map.get([23]).should == betsy
+  end
+
+  it "should store instances with composite keys on #set" do
+    pig = Pig.new({:id=>1,:composite=>1,:name=> 'Pig'})
+    piggy = Pig.new({:id=>1,:composite=>2,:name=>'Piggy'})
+
+    map = DataMapper::IdentityMap.new
+    map.set(pig.key, pig)
+    map.set(piggy.key, piggy)
+
+    map.get([1,1]).should == pig
+    map.get([1,2]).should == piggy
+  end
+
+  it "should remove an instance on #delete" do
+    betsy = Cow.new({:id=>23,:name=>'Betsy'})
+    map = DataMapper::IdentityMap.new
+    map.set(betsy.key, betsy)
+    map.delete([23])
+    map.get([23]).should be_nil
+  end
+end
+
+describe "Second Level Caching" do
+
+  before :all do
+    @mock_class = Class.new do
+      def get(key);           raise NotImplementedError end
+      def set(key, instance); raise NotImplementedError end
+      def delete(key);        raise NotImplementedError end
+    end
+  end
+
+  it 'should expose a standard API' do
+    cache = @mock_class.new
+    cache.should respond_to(:get)
+    cache.should respond_to(:set)
+    cache.should respond_to(:delete)
+  end
+
+  it 'should provide values when the first level cache entry is empty' do
+    cache = @mock_class.new
+    key   = %w[ test ]
+
+    cache.should_receive(:get).with(key).and_return('resource')
+
+    map = DataMapper::IdentityMap.new(cache)
+    map.get(key).should == 'resource'
+  end
+
+  it 'should be set when the first level cache entry is set' do
+    cache = @mock_class.new
+    betsy = Cow.new(:id => 23, :name => 'Betsy')
+
+    cache.should_receive(:set).with(betsy.key, betsy).and_return(betsy)
+
+    map = DataMapper::IdentityMap.new(cache)
+    map.set(betsy.key, betsy).should == betsy
+  end
+
+  it 'should be deleted when the first level cache entry is deleted' do
+    cache = @mock_class.new
+    betsy = Cow.new(:id => 23, :name => 'Betsy')
+
+    cache.stub!(:set)
+    cache.should_receive(:delete).with(betsy.key).and_return(betsy)
+
+    map = DataMapper::IdentityMap.new(cache)
+    map.set(betsy.key, betsy).should == betsy
+    map.delete(betsy.key).should == betsy
+  end
+
+  it 'should not provide values when the first level cache entry is full' do
+    cache = @mock_class.new
+    betsy = Cow.new(:id => 23, :name => 'Betsy')
+
+    cache.stub!(:set)
+    cache.should_not_receive(:get)
+
+    map = DataMapper::IdentityMap.new(cache)
+    map.set(betsy.key, betsy).should == betsy
+    map.get(betsy.key).should == betsy
+  end
+end

data/spec/unit/is_spec.rb

@@ -0,0 +1,80 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe "DataMapper::Is" do
+  describe ".is" do
+
+    module ::DataMapper
+
+      module Is
+        module Example
+
+          def is_example(*args)
+            @args = args
+
+            extend DataMapper::Is::Example::ClassMethods
+          end
+
+          def is_example_args
+            @args
+          end
+
+          module ClassMethods
+            def example_class_method
+
+            end
+          end
+
+        end
+      end
+
+      module Model
+        include DataMapper::Is::Example
+      end # module Model
+    end # module DataMapper
+
+    class ::House
+      include DataMapper::Resource
+    end
+
+    class ::Cabin
+      include DataMapper::Resource
+    end
+
+    it "should raise error unless it finds the plugin" do
+      lambda do
+        class ::House
+          is :no_plugin_by_this_name
+        end
+      end.should raise_error(DataMapper::PluginNotFoundError)
+    end
+
+    it "should call plugin is_* method" do
+      lambda do
+        class ::House
+          is :example
+        end
+      end.should_not raise_error
+    end
+
+    it "should pass through arguments to plugin is_* method" do
+      class ::House
+        is :example ,:option1 => :ping, :option2 => :pong
+      end
+
+      House.is_example_args.length.should == 1
+      House.is_example_args.first[:option2].should == :pong
+    end
+
+    it "should not add class_methods before the plugin is activated" do
+      Cabin.respond_to?(:example_class_method).should be_false
+
+      class ::Cabin
+        is :example
+      end
+
+      Cabin.respond_to?(:example_class_method).should be_true
+
+    end
+
+  end
+end

data/spec/unit/migrator_spec.rb

@@ -0,0 +1,33 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
+
+describe DataMapper::Migrator do
+  before(:each) do
+    DataMapper::Migrator.subclasses.clear
+  end
+
+  after(:each) do
+    DataMapper::Migrator.subclasses.clear
+  end
+
+  it "should keep track of subclasses" do
+    lambda { Class.new(DataMapper::Migrator) }.should change{ DataMapper::Migrator.subclasses.size }.by(1)
+  end
+
+  it "should define a class level 'models' method for each subclass" do
+    klass = Class.new(DataMapper::Migrator)
+
+    klass.should respond_to(:models)
+  end
+
+  it "should keep subclass models seperated" do
+    klass_a = Class.new(DataMapper::Migrator)
+    klass_b = Class.new(DataMapper::Migrator)
+
+    klass_a.models << :foo
+
+    klass_b.models.should be_empty
+
+    klass_a.models.should == [:foo]
+  end
+end

data/spec/unit/model_spec.rb

@@ -0,0 +1,321 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe 'DataMapper::Model' do
+  before do
+    Object.send(:remove_const, :ModelSpec) if defined?(ModelSpec)
+    module ModelSpec
+      class Resource
+        include DataMapper::Resource
+
+        storage_names[:legacy] = 'legacy_resource'
+
+        property :id,   Serial
+        property :name, String
+        property :type, Discriminator
+      end
+    end
+  end
+
+  it 'should provide .new' do
+    meta_class = class << ModelSpec::Resource; self end
+    meta_class.should respond_to(:new)
+  end
+
+  describe '.new' do
+    it 'should require a default storage name and accept a block' do
+      pluto = DataMapper::Model.new('planets') do
+        property :name, String, :key => true
+      end
+
+      pluto.storage_name(:default).should == 'planets'
+      pluto.storage_name(:legacy).should == 'planets'
+      pluto.properties[:name].should_not be_nil
+    end
+  end
+
+  it 'should provide #transaction' do
+    ModelSpec::Resource.should respond_to(:transaction)
+  end
+
+  describe '#transaction' do
+    it 'should return a new Transaction with Model as argument' do
+      transaction = mock("transaction")
+      DataMapper::Transaction.should_receive(:new).with(ModelSpec::Resource).and_return(transaction)
+      ModelSpec::Resource.transaction.should == transaction
+    end
+  end
+
+  it 'should provide #before' do
+    ModelSpec::Resource.should respond_to(:before)
+  end
+
+  it 'should provide #after' do
+    ModelSpec::Resource.should respond_to(:after)
+  end
+
+  it 'should provide #repository' do
+    ModelSpec::Resource.should respond_to(:repository)
+  end
+
+  describe '#repository' do
+    it 'should delegate to DataMapper.repository' do
+      repository = mock('repository')
+      DataMapper.should_receive(:repository).with(:legacy).and_return(repository)
+      ModelSpec::Resource.repository(:legacy).should == repository
+    end
+
+    it 'should use default repository when not passed any arguments' do
+      ModelSpec::Resource.repository.name.should == ModelSpec::Resource.repository(:default).name
+    end
+  end
+
+  it 'should provide #storage_name' do
+    ModelSpec::Resource.should respond_to(:storage_name)
+  end
+
+  describe '#storage_name' do
+    it 'should map a repository to the storage location' do
+      ModelSpec::Resource.storage_name(:legacy).should == 'legacy_resource'
+    end
+
+    it 'should use default repository when not passed any arguments' do
+      ModelSpec::Resource.storage_name.object_id.should == ModelSpec::Resource.storage_name(:default).object_id
+    end
+  end
+
+  it 'should provide #storage_names' do
+    ModelSpec::Resource.should respond_to(:storage_names)
+  end
+
+  describe '#storage_names' do
+    it 'should return a Hash mapping each repository to a storage location' do
+      ModelSpec::Resource.storage_names.should be_kind_of(Hash)
+      ModelSpec::Resource.storage_names.should == { :legacy => 'legacy_resource' }
+    end
+  end
+
+  it 'should provide #property' do
+    ModelSpec::Resource.should respond_to(:property)
+  end
+
+  describe '#property' do
+    it 'should raise a SyntaxError when the name contains invalid characters' do
+      lambda {
+        ModelSpec::Resource.property(:"with space", TrueClass)
+      }.should raise_error(SyntaxError)
+    end
+  end
+
+  it 'should provide #properties' do
+    ModelSpec::Resource.should respond_to(:properties)
+  end
+
+  describe '#properties' do
+    it 'should return an PropertySet' do
+      ModelSpec::Resource.properties(:legacy).should be_kind_of(DataMapper::PropertySet)
+      ModelSpec::Resource.properties(:legacy).should have(3).entries
+    end
+
+    it 'should use default repository when not passed any arguments' do
+      ModelSpec::Resource.properties.object_id.should == ModelSpec::Resource.properties(:default).object_id
+    end
+  end
+
+  it 'should provide #key' do
+    ModelSpec::Resource.should respond_to(:key)
+  end
+
+  describe '#key' do
+    it 'should return an Array of Property objects' do
+      ModelSpec::Resource.key(:legacy).should be_kind_of(Array)
+      ModelSpec::Resource.key(:legacy).should have(1).entries
+      ModelSpec::Resource.key(:legacy).first.should be_kind_of(DataMapper::Property)
+    end
+
+    it 'should use default repository when not passed any arguments' do
+      ModelSpec::Resource.key.should == ModelSpec::Resource.key(:default)
+    end
+
+    it 'should not cache the key value' do
+      class GasGiant < ModelSpec::Resource
+      end
+
+      GasGiant.key.object_id.should_not == ModelSpec::Resource.key(:default)
+
+      # change the key and make sure the Array changes
+      GasGiant.key == GasGiant.properties.slice(:id)
+      GasGiant.property(:new_prop, String, :key => true)
+      GasGiant.key.object_id.should_not == ModelSpec::Resource.key(:default)
+      GasGiant.key == GasGiant.properties.slice(:id, :new_prop)
+    end
+  end
+
+  it 'should provide #get' do
+    ModelSpec::Resource.should respond_to(:get)
+  end
+
+  it 'should provide #first' do
+    ModelSpec::Resource.should respond_to(:first)
+  end
+
+  it 'should provide #all' do
+    ModelSpec::Resource.should respond_to(:all)
+  end
+
+  it 'should provide #storage_exists?' do
+    ModelSpec::Resource.should respond_to(:storage_exists?)
+  end
+
+  describe '#storage_exists?' do
+    it 'should return whether or not the storage exists' do
+      ModelSpec::Resource.storage_exists?.should == false
+    end
+  end
+
+  it 'should provide #default_order' do
+    ModelSpec::Resource.should respond_to(:default_order)
+  end
+
+  describe '#default_order' do
+    it 'should be equal to #key by default' do
+      ModelSpec::Resource.default_order.should == [ DataMapper::Query::Direction.new(ModelSpec::Resource.properties[:id], :asc) ]
+    end
+  end
+
+  describe '#append_inclusions' do
+    before(:all) do
+      @standard_resource_inclusions = DataMapper::Resource.instance_variable_get('@extra_inclusions')
+      @standard_model_extensions = DataMapper::Model.instance_variable_get('@extra_extensions')
+    end
+
+    before(:each) do
+      DataMapper::Resource.instance_variable_set('@extra_inclusions', [])
+      DataMapper::Model.instance_variable_set('@extra_extensions', [])
+
+      @module = Module.new do
+        def greet
+          hi_mom!
+        end
+      end
+
+      @another_module = Module.new do
+        def hello
+          hi_dad!
+        end
+      end
+
+      @class = Class.new
+
+      @class_code = %{
+        include DataMapper::Resource
+        property :id, Serial
+      }
+    end
+
+    after(:each) do
+      DataMapper::Resource.instance_variable_set('@extra_inclusions', @standard_resource_inclusions)
+      DataMapper::Model.instance_variable_set('@extra_extensions', @standard_model_extensions)
+    end
+
+    it "should append the module to be included in resources" do
+      DataMapper::Resource.append_inclusions @module
+      @class.class_eval(@class_code)
+
+      instance = @class.new
+      instance.should_receive(:hi_mom!)
+      instance.greet
+    end
+
+    it "should append the module to all resources" do
+      DataMapper::Resource.append_inclusions @module
+
+      objects = (1..5).map do
+        the_class = Class.new
+        the_class.class_eval(@class_code)
+
+        instance = the_class.new
+        instance.should_receive(:hi_mom!)
+        instance
+      end
+
+      objects.each { |obj| obj.greet }
+    end
+
+    it "should append multiple modules to be included in resources" do
+      DataMapper::Resource.append_inclusions @module, @another_module
+      @class.class_eval(@class_code)
+
+      instance = @class.new
+      instance.should_receive(:hi_mom!)
+      instance.should_receive(:hi_dad!)
+      instance.greet
+      instance.hello
+    end
+
+    it "should include the appended modules in order" do
+      module_one = Module.new do
+        def self.included(base); base.hi_mom!; end;
+      end
+
+      module_two = Module.new do
+        def self.included(base); base.hi_dad!; end;
+      end
+
+      DataMapper::Resource.append_inclusions module_two, module_one
+
+      @class.should_receive(:hi_dad!).once.ordered
+      @class.should_receive(:hi_mom!).once.ordered
+
+      @class.class_eval(@class_code)
+    end
+
+    it "should append the module to extend resources with" do
+      DataMapper::Model.append_extensions @module
+      @class.class_eval(@class_code)
+
+      @class.should_receive(:hi_mom!)
+      @class.greet
+    end
+
+    it "should extend all resources with the module" do
+      DataMapper::Model.append_extensions @module
+
+      classes = (1..5).map do
+        the_class = Class.new
+        the_class.class_eval(@class_code)
+        the_class.should_receive(:hi_mom!)
+        the_class
+      end
+
+      classes.each { |cla| cla.greet }
+    end
+
+    it "should append multiple modules to extend resources with" do
+      DataMapper::Model.append_extensions @module, @another_module
+      @class.class_eval(@class_code)
+
+      @class.should_receive(:hi_mom!)
+      @class.should_receive(:hi_dad!)
+      @class.greet
+      @class.hello
+    end
+
+    it "should extend the resource in the order that the modules were appended" do
+      @module.class_eval do
+        def self.extended(base); base.hi_mom!; end;
+      end
+
+      @another_module.class_eval do
+        def self.extended(base); base.hi_dad!; end;
+      end
+
+      DataMapper::Model.append_extensions @another_module, @module
+
+      @class.should_receive(:hi_dad!).once.ordered
+      @class.should_receive(:hi_mom!).once.ordered
+
+      @class.class_eval(@class_code)
+    end
+
+  end
+end