sam-dm-core 0.9.6

data/spec/unit/associations/one_to_one_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+describe "DataMapper::Associations::OneToOne" do
+
+  it "should allow a declaration" do
+  end
+end

data/spec/unit/associations/relationship_spec.rb

@@ -0,0 +1,71 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+describe DataMapper::Associations::Relationship do
+
+  load_models_for_metaphor :vehicles
+
+  it "should describe an association" do
+    belongs_to = DataMapper::Associations::Relationship.new(
+      :manufacturer,
+      :mock,
+      'Vehicle',
+      'Manufacturer',
+      { :child_key => [ :manufacturer_id ] }
+    )
+
+    belongs_to.should respond_to(:name)
+    belongs_to.should respond_to(:with_repository)
+    belongs_to.should respond_to(:child_key)
+    belongs_to.should respond_to(:parent_key)
+  end
+
+  it "should map properties explicitly when an association method passes them in its options" do
+    belongs_to = DataMapper::Associations::Relationship.new(
+      :manufacturer,
+      :mock,
+      'Vehicle',
+      'Manufacturer',
+      { :child_key => [ :manufacturer_id ], :parent_key => [ :id ] }
+    )
+
+    belongs_to.name.should == :manufacturer
+    belongs_to.with_repository do |r|
+      r.name.should == :mock
+    end
+
+    belongs_to.child_key.should be_a_kind_of(DataMapper::PropertySet)
+    belongs_to.parent_key.should be_a_kind_of(DataMapper::PropertySet)
+
+    belongs_to.child_key.to_a.should == Vehicle.properties(:mock).slice(:manufacturer_id)
+    belongs_to.parent_key.to_a.should == Manufacturer.properties(:mock).key
+  end
+
+  it "should infer properties when options aren't passed" do
+    has_many = DataMapper::Associations::Relationship.new(
+      :models,
+      :mock,
+      'Vehicle',
+      'Manufacturer',
+      { :child_key => [:model_id] }
+    )
+
+    has_many.name.should == :models
+    has_many.with_repository do |r|
+      r.name.should == :mock
+    end
+
+    has_many.child_key.should be_a_kind_of(DataMapper::PropertySet)
+    has_many.parent_key.should be_a_kind_of(DataMapper::PropertySet)
+    # Vehicle.has n, :models, :class_name => 'Manufacturer', :child_key => "models_id"
+    has_many.child_key.to_a.should == Vehicle.properties(:mock).slice(:model_id)
+    has_many.parent_key.to_a.should == Manufacturer.properties(:mock).key
+  end
+
+  it "should generate child properties with a safe subset of the parent options" do
+    pending
+    # For example, :size would be an option you'd want a generated child Property to copy,
+    # but :serial or :key obviously not. So need to take a good look at Property::OPTIONS to
+    # see what applies and what doesn't.
+  end
+
+end

data/spec/unit/associations_spec.rb

@@ -0,0 +1,242 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe "DataMapper::Associations" do
+
+  load_models_for_metaphor :vehicles
+
+  before do
+    @relationship = mock(DataMapper::Associations::Relationship)
+    @n = 1.0/0
+
+    Manufacturer.mock_relationship = Vehicle.mock_relationship = @relationship
+  end
+
+  describe "#many_to_one_relationships" do
+    before :all do
+      module MTORelationships
+        class A
+          include DataMapper::Resource
+          def self.default_repository_name
+            :a_db
+          end
+          repository(:b_db) do
+            belongs_to :b
+          end
+          repository(:c_db) do
+            belongs_to :c
+          end
+        end
+        class B
+          include DataMapper::Resource
+          def self.default_repository_name
+            :b_db
+          end
+        end
+        class C
+          include DataMapper::Resource
+          def self.default_repository_name
+            :c_db
+          end
+        end
+      end
+    end
+    it "should list all relationships that are one-to-many" do
+      MTORelationships::A.many_to_one_relationships.sort_by { |r| r.name.to_s }.should == [MTORelationships::A.relationships(:b_db)[:b], MTORelationships::A.relationships(:c_db)[:c]]
+    end
+  end
+
+  describe ".relationships" do
+    class B
+      include DataMapper::Resource
+    end
+
+    class C
+      include DataMapper::Resource
+
+      repository(:mock) do
+        has 1, :b
+      end
+    end
+
+    class D
+      include DataMapper::Resource
+      has 1, :b
+    end
+
+    class E < D
+    end
+
+    class F < D
+      has 1, :a
+    end
+
+    it "should assume the default repository when no arguments are passed" do
+      lambda do
+        C.relationships
+      end.should_not raise_error
+    end
+
+    it "should return the right set of relationships given the repository name" do
+      C.relationships.should be_empty
+      C.relationships(:mock).should_not be_empty
+    end
+
+    it "should return the right set of relationships given the inheritance" do
+      E.relationships.should have(1).entries
+      D.relationships.should have(1).entries
+      F.relationships.should have(2).entries
+    end
+  end
+
+  describe ".has" do
+
+    it "should allow a declaration" do
+      lambda do
+        class Manufacturer
+          has 1, :halo_car
+        end
+      end.should_not raise_error
+    end
+
+    it "should not allow a constraint that is not an Integer, Range or Infinity" do
+      lambda do
+        class Manufacturer
+          has '1', :halo_car
+        end
+      end.should raise_error(ArgumentError)
+    end
+
+    it "should not allow a constraint where the min is larger than the max" do
+      lambda do
+        class Manufacturer
+          has 1..0, :halo_car
+        end
+      end.should raise_error(ArgumentError)
+    end
+
+    it "should not allow overwriting of the auto assigned min/max values with keys" do
+      DataMapper::Associations::OneToMany.should_receive(:setup).
+        with(:vehicles, Manufacturer, { :min => 1, :max => 2 }).
+        and_return(@relationship)
+
+      class Manufacturer
+        has(1..2, :vehicles, :min => 5, :max => 10).should == mock_relationship
+      end
+    end
+
+    describe "one-to-one syntax" do
+      it "should create a basic one-to-one association with fixed constraint" do
+        DataMapper::Associations::OneToOne.should_receive(:setup).
+          with(:halo_car, Manufacturer, { :min => 1, :max => 1 }).
+          and_return(@relationship)
+
+        class Manufacturer
+          has(1, :halo_car).should == mock_relationship
+        end
+      end
+
+      it "should create a basic one-to-one association with min/max constraints" do
+        DataMapper::Associations::OneToOne.should_receive(:setup).
+          with(:halo_car, Manufacturer, { :min => 0, :max => 1 }).
+          and_return(@relationship)
+
+        class Manufacturer
+          has(0..1, :halo_car).should == mock_relationship
+        end
+      end
+
+      it "should create a one-to-one association with options" do
+        DataMapper::Associations::OneToOne.should_receive(:setup).
+          with(:halo_car, Manufacturer, { :min => 1, :max => 1, :class_name => 'Car' }).
+          and_return(@relationship)
+
+        class Manufacturer
+          has(1, :halo_car, :class_name => 'Car').should == mock_relationship
+        end
+      end
+    end
+
+    describe "one-to-many syntax" do
+      it "should create a basic one-to-many association with no constraints" do
+        DataMapper::Associations::OneToMany.should_receive(:setup).
+          with(:vehicles, Manufacturer, { :min => 0, :max => @n }).
+          and_return(@relationship)
+
+        class Manufacturer
+          has(n, :vehicles).should == mock_relationship
+        end
+      end
+
+      it "should create a one-to-many association with fixed constraint" do
+        DataMapper::Associations::OneToMany.should_receive(:setup).
+          with(:vehicles, Manufacturer, { :min => 4, :max => 4 }).
+          and_return(@relationship)
+
+        class Manufacturer
+          has(4, :vehicles).should == mock_relationship
+        end
+      end
+
+      it "should create a one-to-many association with min/max constraints" do
+        DataMapper::Associations::OneToMany.should_receive(:setup).
+          with(:vehicles, Manufacturer, { :min => 2, :max => 4 }).
+          and_return(@relationship)
+
+        class Manufacturer
+          has(2..4, :vehicles).should == mock_relationship
+        end
+      end
+
+      it "should create a one-to-many association with options" do
+        DataMapper::Associations::OneToMany.should_receive(:setup).
+          with(:vehicles, Manufacturer, { :min => 1, :max => @n, :class_name => 'Car' }).
+          and_return(@relationship)
+
+        class Manufacturer
+          has(1..n, :vehicles, :class_name => 'Car').should == mock_relationship
+        end
+      end
+
+      # do not remove or change this spec.
+      it "should raise an exception when n..n is used for the cardinality" do
+        lambda do
+          class Manufacturer
+            has n..n, :subsidiaries, :class_name => 'Manufacturer'
+          end
+        end.should raise_error(ArgumentError)
+      end
+
+      it "should create one-to-many association and pass the :through option if specified" do
+        DataMapper::Associations::OneToMany.should_receive(:setup).
+          with(:suppliers, Vehicle, { :min => 0, :max => @n, :through => :manufacturers }).
+          and_return(@relationship)
+
+        class Vehicle
+          has(n, :suppliers, :through => :manufacturers).should == mock_relationship
+        end
+      end
+    end
+  end
+
+  describe ".belongs_to" do
+    it "should create a basic many-to-one association" do
+      DataMapper::Associations::ManyToOne.should_receive(:setup).
+        with(:vehicle, Manufacturer, {}).
+        and_return(@relationship)
+
+      class Manufacturer
+        belongs_to(:vehicle).should == mock_relationship
+      end
+    end
+
+    it "should create a many-to-one association with options" do
+      DataMapper::Associations::ManyToOne.should_receive(:setup).
+        with(:vehicle, Manufacturer, { :class_name => 'Car' }).
+        and_return(@relationship)
+
+      class Manufacturer
+        belongs_to(:vehicle, :class_name => 'Car').should == mock_relationship
+      end
+    end
+  end
+end

data/spec/unit/auto_migrations_spec.rb

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

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