dm-core 1.0.2 → 1.1.0.rc1

data/spec/semipublic/resource/state/clean_spec.rb

@@ -1,5 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper'))
-
+require 'spec_helper'
 describe DataMapper::Resource::State::Clean do
   before :all do
     class ::Author

data/spec/semipublic/resource/state/deleted_spec.rb

@@ -1,5 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper'))
-
+require 'spec_helper'
 describe DataMapper::Resource::State::Deleted do
   before :all do
     class ::Author

data/spec/semipublic/resource/state/dirty_spec.rb

@@ -1,5 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper'))
-
+require 'spec_helper'
 describe DataMapper::Resource::State::Dirty do
   before :all do
     class ::Author

data/spec/semipublic/resource/state/immutable_spec.rb

@@ -1,5 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper'))
-
+require 'spec_helper'
 describe DataMapper::Resource::State::Immutable do
   before :all do
     class ::Author

data/spec/semipublic/resource/state/transient_spec.rb

@@ -1,5 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper'))
-
+require 'spec_helper'
 describe DataMapper::Resource::State::Transient do
   before :all do
     class ::Author
@@ -48,6 +47,12 @@ describe DataMapper::Resource::State::Transient do
       end
 
       it 'should set the child key if the parent key changes' do
+        # SqlServer does not allow updating IDENTITY columns.
+        if defined?(DataMapper::Adapters::SqlserverAdapter) &&
+           @adapter.kind_of?(DataMapper::Adapters::SqlserverAdapter)
+          return
+        end
+
         original_id = @parent.id
         @parent.update(:id => 42).should be(true)
         method(:subject).should change(@resource, :parent_id).from(original_id).to(42)

data/spec/semipublic/resource/state_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+require 'spec_helper'
 
 describe DataMapper::Resource::State do
   before :all do

data/spec/semipublic/resource_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+require 'spec_helper'
 
 describe DataMapper::Resource do
   before :all do

data/spec/unit/array_spec.rb

@@ -1,3 +1,4 @@
+require 'spec_helper'
 require 'dm-core/core_ext/array'
 
 begin

data/spec/unit/data_mapper/ordered_set/append_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'dm-core/support/ordered_set'
+require 'unit/data_mapper/ordered_set/shared/append_spec'
+
+describe 'DataMapper::OrderedSet#<<' do
+  subject { set << entry2 }
+
+  let(:set)    { DataMapper::OrderedSet.new([ entry1 ]) }
+  let(:entry1) { Object.new                             }
+
+  before do
+    @old_index = set.index(entry1)
+  end
+
+  context 'when appending a not yet included entry' do
+    let(:entry2) { Object.new }
+
+    it_should_behave_like 'DataMapper::OrderedSet#<< when appending a not yet included entry'
+  end
+
+  context 'when updating an already included entry' do
+    let(:entry2) { entry1 }
+
+    it_should_behave_like 'DataMapper::OrderedSet#<< when updating an already included entry'
+  end
+end

data/spec/unit/data_mapper/ordered_set/clear_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'dm-core/support/ordered_set'
+require 'unit/data_mapper/ordered_set/shared/clear_spec'
+
+describe 'DataMapper::OrderedSet#clear' do
+  subject { ordered_set.clear }
+
+  let(:ordered_set) { DataMapper::OrderedSet.new(entries) }
+
+  let(:entry1) { 1 }
+  let(:entry2) { 2 }
+
+  context 'when no entries are present' do
+    let(:entries) { [] }
+
+    it_should_behave_like 'DataMapper::OrderedSet#clear when no entries are present'
+  end
+
+  context 'when entries are present' do
+    let(:entries) { [ entry1, entry2 ] }
+
+    it_should_behave_like 'DataMapper::OrderedSet#clear when entries are present'
+  end
+end

data/spec/unit/data_mapper/ordered_set/delete_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'dm-core/support/ordered_set'
+require 'unit/data_mapper/ordered_set/shared/delete_spec'
+
+describe 'DataMapper::OrderedSet#delete' do
+  subject { ordered_set }
+
+  let(:ordered_set) { DataMapper::OrderedSet.new([ entry1, entry2, entry3 ]) }
+  let(:entry1)      { 1                                                      }
+  let(:entry2)      { 2                                                      }
+  let(:entry3)      { 3                                                      }
+
+  before do
+    ordered_set.delete(entry)
+  end
+
+  context 'when deleting an already included entry' do
+    let(:entry) { entry1 }
+
+    it_should_behave_like 'DataMapper::OrderedSet#delete when deleting an already included entry'
+  end
+
+  context 'when deleting a not yet included entry' do
+    let(:entry) { 4 }
+
+    it_should_behave_like 'DataMapper::OrderedSet#delete when deleting a not yet included entry'
+  end
+end

data/spec/unit/data_mapper/ordered_set/each_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'dm-core/support/ordered_set'
+require 'unit/data_mapper/ordered_set/shared/each_spec'
+
+describe 'DataMapper::OrderedSet' do
+  subject { DataMapper::OrderedSet.new }
+
+  it_should_behave_like 'DataMapper::OrderedSet'
+end
+
+describe 'DataMapper::OrderedSet#each' do
+  subject { set.each { |entry| yields << entry } }
+
+  let(:set)    { DataMapper::OrderedSet.new([ entry ]) }
+  let(:entry)  { 1                                     }
+  let(:yields) { []                                    }
+
+  it_should_behave_like 'DataMapper::OrderedSet#each'
+end

data/spec/unit/data_mapper/ordered_set/empty_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'dm-core/support/ordered_set'
+require 'unit/data_mapper/ordered_set/shared/empty_spec'
+
+describe 'DataMapper::OrderedSet#empty?' do
+  subject { set.empty? }
+
+  context 'with no entries in it' do
+    let(:set) { DataMapper::OrderedSet.new }
+
+    it_should_behave_like 'DataMapper::OrderedSet#empty? with no entries in it'
+  end
+
+  context 'with entries in it' do
+    let(:set)   { DataMapper::OrderedSet.new([ entry ]) }
+    let(:entry) { 1                                     }
+
+    it_should_behave_like 'DataMapper::OrderedSet#empty? with entries in it'
+  end
+end

data/spec/unit/data_mapper/ordered_set/entries_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'dm-core/support/ordered_set'
+require 'unit/data_mapper/ordered_set/shared/entries_spec'
+
+describe 'DataMapper::OrderedSet#entries' do
+  subject { ordered_set.entries }
+
+  let(:ordered_set) { set }
+
+  context 'with no entries' do
+    let(:set) { DataMapper::OrderedSet.new }
+
+    it_should_behave_like 'DataMapper::OrderedSet#entries with no entries'
+  end
+
+  context 'with entries' do
+    let(:set)   { DataMapper::OrderedSet.new([ entry ]) }
+    let(:entry) { 1                                     }
+
+    it_should_behave_like 'DataMapper::OrderedSet#entries with entries'
+  end
+end

data/spec/unit/data_mapper/ordered_set/eql_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'dm-core/support/ordered_set'
+
+describe 'DataMapper::OrderedSet#eql?' do
+  subject { ordered_set.eql?(other) }
+
+  let(:original_entry)  { 1                                              }
+  let(:ordered_set)     { DataMapper::OrderedSet.new([ original_entry ]) }
+
+  context 'with the same ordered_set' do
+    let(:other) { ordered_set }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.eql?(ordered_set)
+    end
+  end
+
+  context 'with equivalent ordered_set' do
+    let(:other) { ordered_set.dup }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.eql?(ordered_set)
+    end
+  end
+
+  context 'with both containing no ordered_set' do
+    let(:ordered_set) { DataMapper::OrderedSet.new }
+    let(:other)       { DataMapper::OrderedSet.new }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.eql?(ordered_set)
+    end
+  end
+
+  context 'with different ordered_set' do
+    let(:different_entry) { 2                                               }
+    let(:other)           { DataMapper::OrderedSet.new([ different_entry ]) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == other.eql?(ordered_set)
+    end
+  end
+end

data/spec/unit/data_mapper/ordered_set/equal_value_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+require 'dm-core/support/ordered_set'
+
+module DataMapper::Specs
+
+  # Used to test duck typing behavior
+  class OrderedSetDuck
+    attr_reader :entries
+
+    def initialize(columns = [])
+      @entries = DataMapper::OrderedSet.new
+    end
+  end
+end
+
+describe 'DataMapper::OrderedSet#==' do
+  subject { ordered_set == other }
+
+  let(:original_entry)  { 1                                              }
+  let(:ordered_set)     { DataMapper::OrderedSet.new([ original_entry ]) }
+
+  context 'with the same ordered_set' do
+    let(:other) { ordered_set }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == (other == ordered_set)
+    end
+  end
+
+  context 'with equivalent ordered_set' do
+    let(:other) { ordered_set.dup }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == (other == ordered_set)
+    end
+  end
+
+  # TODO This probably needs more thought
+  context 'with a class that quacks like OrderedSet and is equivalent otherwise' do
+    let(:other) { DataMapper::Specs::OrderedSetDuck.new([ original_entry ]) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == (other == ordered_set)
+    end
+  end
+
+  context 'with a subclass that is equivalent otherwise' do
+    let(:other) { Class.new(DataMapper::OrderedSet).new([ original_entry ]) }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == (other == ordered_set)
+    end
+  end
+
+  context 'with both containing no ordered_set' do
+    let(:ordered_set) { DataMapper::OrderedSet.new }
+    let(:other)       { DataMapper::OrderedSet.new }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == (other == ordered_set)
+    end
+  end
+
+  context 'with different ordered_set' do
+    let(:different_entry) { 2                                               }
+    let(:other)           { DataMapper::OrderedSet.new([ different_entry ]) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == (other == ordered_set)
+    end
+  end
+end

data/spec/unit/data_mapper/ordered_set/hash_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+require 'dm-core/support/ordered_set'
+
+describe 'DataMapper::OrderedSet#hash' do
+  subject { ordered_set.hash }
+
+  let(:entry)       { 1                                     }
+  let(:ordered_set) { DataMapper::OrderedSet.new([ entry ]) }
+
+  it { should be_kind_of(Integer) }
+  it { should == ordered_set.entries.hash }
+end

data/spec/unit/data_mapper/ordered_set/include_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'dm-core/support/ordered_set'
+require 'unit/data_mapper/ordered_set/shared/include_spec'
+
+describe 'DataMapper::OrderedSet#include?' do
+  subject { ordered_set.include?(entry) }
+
+  let(:ordered_set) { set }
+
+  context 'when the entry is present' do
+    let(:set)   { DataMapper::OrderedSet.new([ entry ]) }
+    let(:entry) { 1                                     }
+
+    it_should_behave_like 'DataMapper::OrderedSet#include? when the entry is present'
+  end
+
+  context 'when the entry is not present' do
+    let(:set)   { DataMapper::OrderedSet.new }
+    let(:entry) { 1                          }
+
+    it_should_behave_like 'DataMapper::OrderedSet#include? when the entry is not present'
+  end
+end

data/spec/unit/data_mapper/ordered_set/index_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'dm-core/support/ordered_set'
+require 'unit/data_mapper/ordered_set/shared/index_spec'
+
+describe 'DataMapper::OrderedSet#index' do
+  subject { ordered_set.index(entry) }
+
+  context 'when the entry is not present' do
+    let(:ordered_set) { DataMapper::OrderedSet.new }
+    let(:entry)       { 1                          }
+
+    it_should_behave_like 'DataMapper::OrderedSet#index when the entry is not present'
+  end
+
+  context 'when 1 entry is present' do
+    let(:ordered_set) { DataMapper::OrderedSet.new([ entry ]) }
+    let(:entry)       { 1                                     }
+
+    it_should_behave_like 'DataMapper::OrderedSet#index when 1 entry is present'
+  end
+
+  context 'when 2 entries are present' do
+    let(:ordered_set) { DataMapper::OrderedSet.new([ 2, entry ]) }
+    let(:entry)       { 1                                        }
+
+    it_should_behave_like 'DataMapper::OrderedSet#index when 2 entries are present'
+  end
+end

data/spec/unit/data_mapper/ordered_set/initialize_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'dm-core/support/ordered_set'
+require 'unit/data_mapper/ordered_set/shared/initialize_spec'
+
+describe 'DataMapper::OrderedSet#initialize' do
+
+  context 'when no entries are given' do
+    subject { DataMapper::OrderedSet.new }
+
+    it_should_behave_like 'DataMapper::OrderedSet#initialize when no entries are given'
+  end
+
+  context 'when entries are given' do
+    subject { DataMapper::OrderedSet.new(entries) }
+
+    context 'and they do not contain duplicates' do
+      let(:entries) { [ entry1, entry2 ] }
+      let(:entry1)  { 1                  }
+      let(:entry2)  { 2                  }
+
+      it_should_behave_like 'DataMapper::OrderedSet#initialize when entries are given and they do not contain duplicates'
+    end
+
+    context 'and they contain duplicates' do
+      let(:entries) { [ entry1, entry2 ] }
+      let(:entry1)  { 1                  }
+      let(:entry2)  { 1                  }
+
+      it_should_behave_like 'DataMapper::OrderedSet#initialize when entries are given and they contain duplicates'
+    end
+  end
+end