datamapper-dm-core 0.9.11 → 0.10.0

data/spec/unit/auto_migrations_spec.rb

@@ -1,111 +0,0 @@
-require 'pathname'
-require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
-
-require DataMapper.root / 'lib' / 'dm-core' / 'repository'
-require DataMapper.root / 'lib' / 'dm-core' / 'resource'
-require DataMapper.root / 'lib' / 'dm-core' / 'auto_migrations'
-
-describe DataMapper::AutoMigrations do
-
-  before :all do
-    @cow = Class.new do
-      include DataMapper::Resource
-
-      property :name, String, :key => true
-      property :age, Integer
-    end
-  end
-
-  before(:each) do
-    DataMapper::Resource.descendants.clear
-  end
-
-  after(:each) do
-    DataMapper::Resource.descendants.clear
-  end
-
-  it "should add the resource class to AutoMigrator's models on a mixin" do
-    @class = Class.new do
-      include DataMapper::Resource
-    end
-
-    DataMapper::Resource.descendants.should include(@class)
-  end
-
-  it "should add the #auto_migrate! method on a mixin" do
-    @cat = Class.new do
-      include DataMapper::Resource
-
-      property :name, String, :key => true
-      property :age, Integer
-    end
-
-    @cat.should respond_to(:auto_migrate!)
-  end
-
-  it "should add the #auto_upgrade! method on a mixin" do
-    @cat = Class.new do
-      include DataMapper::Resource
-
-      property :name, String, :key => true
-      property :age, Integer
-    end
-
-    @cat.should respond_to(:auto_upgrade!)
-  end
-
-  it "should not conflict with other Migrators on a mixin" do
-    migrator_class = Class.new(DataMapper::Migrator)
-
-    included_proc = lambda { |model| migrator_class.models << model }
-
-    migrator_mixin = Module.new do
-      self.class.send(:define_method, :included, &included_proc)
-    end
-
-    model_class = Class.new do
-      include DataMapper::Resource
-      include migrator_mixin
-
-      property :name, String
-      property :age, String
-    end
-
-    DataMapper::Resource.descendants.should include(model_class)
-    migrator_class.models.should include(model_class)
-  end
-
-  describe "#auto_migrate" do
-    before do
-      @repository_name = mock('repository name')
-    end
-
-    it "should call each model's auto_migrate! method" do
-      models = [:cat, :dog, :fish, :cow].map {|m| mock(m)}
-
-      models.each do |model|
-        DataMapper::Resource.descendants << model
-        model.should_receive(:auto_migrate_down!).with(@repository_name)
-        model.should_receive(:auto_migrate_up!).with(@repository_name)
-      end
-
-      DataMapper::AutoMigrator.auto_migrate(@repository_name)
-    end
-  end
-  describe "#auto_upgrade" do
-    before do
-      @repository_name = mock('repository name')
-    end
-
-    it "should call each model's auto_upgrade! method" do
-      models = [:cat, :dog, :fish, :cow].map {|m| mock(m)}
-
-      models.each do |model|
-        DataMapper::Resource.descendants << model
-        model.should_receive(:auto_upgrade!).with(@repository_name)
-      end
-
-      DataMapper::AutoMigrator.auto_upgrade(@repository_name)
-    end
-  end
-end

data/spec/unit/collection_spec.rb

@@ -1,182 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-
-# ensure the Collection is extremely similar to an Array
-# since it will be returned by Respository#all to return
-# multiple resources to the caller
-describe DataMapper::Collection do
-  before do
-    @property = mock('property')
-    @model    = mock('model', :inheritance_property => [ @property ], :key => [ @property ])
-    @query    = mock('query', :kind_of? => true, :fields => [ @property ], :model => @model)
-
-    @collection = DataMapper::Collection.new(@query) {}
-  end
-
-  it 'should provide #<<' do
-    @collection.should respond_to(:<<)
-  end
-
-  it 'should provide #all' do
-    @collection.should respond_to(:all)
-  end
-
-  it 'should provide #at' do
-    @collection.should respond_to(:at)
-  end
-
-  it 'should provide #build' do
-    @collection.should respond_to(:build)
-  end
-
-  it 'should provide #clear' do
-    @collection.should respond_to(:clear)
-  end
-
-  it 'should provide #collect!' do
-    @collection.should respond_to(:collect!)
-  end
-
-  it 'should provide #concat' do
-    @collection.should respond_to(:concat)
-  end
-
-  it 'should provide #create' do
-    @collection.should respond_to(:create)
-  end
-
-  it 'should provide #delete' do
-    @collection.should respond_to(:delete)
-  end
-
-  it 'should provide #delete_at' do
-    @collection.should respond_to(:delete_at)
-  end
-
-  it 'should provide #destroy!' do
-    @collection.should respond_to(:destroy!)
-  end
-
-  it 'should provide #each' do
-    @collection.should respond_to(:each)
-  end
-
-  it 'should provide #each_index' do
-    @collection.should respond_to(:each_index)
-  end
-
-  it 'should provide #eql?' do
-    @collection.should respond_to(:eql?)
-  end
-
-  it 'should provide #fetch' do
-    @collection.should respond_to(:fetch)
-  end
-
-  it 'should provide #first' do
-    @collection.should respond_to(:first)
-  end
-
-  it 'should provide #freeze' do
-    @collection.should respond_to(:freeze)
-  end
-
-  it 'should provide #get' do
-    @collection.should respond_to(:get)
-  end
-
-  it 'should provide #get!' do
-    @collection.should respond_to(:get!)
-  end
-
-  it 'should provide #insert' do
-    @collection.should respond_to(:insert)
-  end
-
-  it 'should provide #last' do
-    @collection.should respond_to(:last)
-  end
-
-  it 'should provide #load' do
-    @collection.should respond_to(:load)
-  end
-
-  it 'should provide #loaded?' do
-    @collection.should respond_to(:loaded?)
-  end
-
-  it 'should provide #pop' do
-    @collection.should respond_to(:pop)
-  end
-
-  it 'should provide #push' do
-    @collection.should respond_to(:push)
-  end
-
-  it 'should provide #properties' do
-    @collection.should respond_to(:properties)
-  end
-
-  it 'should provide #reject' do
-    @collection.should respond_to(:reject)
-  end
-
-  it 'should provide #reject!' do
-    @collection.should respond_to(:reject!)
-  end
-
-  it 'should provide #relationships' do
-    @collection.should respond_to(:relationships)
-  end
-
-  it 'should provide #reload' do
-    @collection.should respond_to(:reload)
-  end
-
-  it 'should provide #reverse' do
-    @collection.should respond_to(:reverse)
-  end
-
-  it 'should provide #reverse!' do
-    @collection.should respond_to(:reverse!)
-  end
-
-  it 'should provide #reverse_each' do
-    @collection.should respond_to(:reverse_each)
-  end
-
-  it 'should provide #select' do
-    @collection.should respond_to(:select)
-  end
-
-  it 'should provide #shift' do
-    @collection.should respond_to(:shift)
-  end
-
-  it 'should provide #slice' do
-    @collection.should respond_to(:slice)
-  end
-
-  it 'should provide #slice!' do
-    @collection.should respond_to(:slice!)
-  end
-
-  it 'should provide #sort' do
-    @collection.should respond_to(:sort)
-  end
-
-  it 'should provide #sort!' do
-    @collection.should respond_to(:sort!)
-  end
-
-  it 'should provide #unshift' do
-    @collection.should respond_to(:unshift)
-  end
-
-  it 'should provide #update!' do
-    @collection.should respond_to(:update!)
-  end
-
-  it 'should provide #values_at' do
-    @collection.should respond_to(:values_at)
-  end
-end

data/spec/unit/data_mapper_spec.rb

@@ -1,35 +0,0 @@
-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

@@ -1,126 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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