ghost_dm-core 1.3.0.beta

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.class.hash ^ 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

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

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'dm-core/support/ordered_set'
+require 'unit/data_mapper/ordered_set/shared/merge_spec'
+
+describe 'DataMapper::OrderedSet#merge' do
+
+  context 'when merging two empty sets' do
+    subject { ordered_set.merge([]) }
+
+    let(:ordered_set) { set                        }
+    let(:set)         { DataMapper::OrderedSet.new }
+
+    it_should_behave_like 'DataMapper::OrderedSet#merge when merging two empty sets'
+  end
+
+  context 'when merging a set with already present entries' do
+    subject { ordered_set.merge([ entry ]) }
+
+    let(:ordered_set) { set                                   }
+    let(:set)         { DataMapper::OrderedSet.new([ entry ]) }
+    let(:entry)       { 1                                     }
+
+    it_should_behave_like 'DataMapper::OrderedSet#merge when merging a set with already present entries'
+  end
+
+  context 'when merging a set with not yet present entries' do
+    subject { ordered_set.merge([ entry2 ]) }
+
+    let(:ordered_set) { set                                    }
+    let(:set)         { DataMapper::OrderedSet.new([ entry1 ]) }
+    let(:entry1)      { 1                                      }
+    let(:entry2)      { 2                                      }
+
+    it_should_behave_like 'DataMapper::OrderedSet#merge when merging a set with not yet present entries'
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+shared_examples_for 'DataMapper::OrderedSet#<< when appending a not yet included entry' do
+  its(:size   ) { should == 2            }
+  its(:entries) { should include(entry1) }
+  its(:entries) { should include(entry2) }
+
+  it 'should not alter the position of the existing entry' do
+    subject.entries.index(entry1).should == @old_index
+  end
+
+  it 'should append columns at the end of the set' do
+    subject.entries.index(entry2).should == @old_index + 1
+  end
+end
+
+shared_examples_for 'DataMapper::OrderedSet#<< when updating an already included entry' do
+  its(:size   ) { should == 1            }
+  its(:entries) { should include(entry2) }
+
+  it 'should not alter the position of the existing entry' do
+    subject.entries.index(entry2).should == @old_index
+  end
+end

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

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+shared_examples_for 'DataMapper::OrderedSet#clear when no entries are present' do
+  it { should be_empty }
+end
+
+shared_examples_for 'DataMapper::OrderedSet#clear when entries are present' do
+  it { should be_empty }
+end

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

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+shared_examples_for 'DataMapper::OrderedSet#delete when deleting an already included entry' do
+  its(:entries) { should_not include(entry1) }
+  its(:entries) { should     include(entry2) }
+  its(:entries) { should     include(entry3) }
+
+  it 'should correct the index' do
+    ordered_set.index(entry1).should be_nil
+    ordered_set.index(entry2).should == 0
+    ordered_set.index(entry3).should == 1
+  end
+end
+
+shared_examples_for 'DataMapper::OrderedSet#delete when deleting a not yet included entry' do
+  its(:entries) { should include(entry1) }
+  its(:entries) { should include(entry2) }
+  its(:entries) { should include(entry3) }
+
+  it 'should not alter the index' do
+    ordered_set.index(entry1).should == 0
+    ordered_set.index(entry2).should == 1
+    ordered_set.index(entry3).should == 2
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+shared_examples_for 'DataMapper::OrderedSet' do
+  it { should be_kind_of(Enumerable) }
+
+  it 'case matches Enumerable' do
+    (Enumerable === subject).should be(true)
+  end
+end
+
+shared_examples_for 'DataMapper::OrderedSet#each' do
+  it { should equal(set) }
+
+  it 'yields each column' do
+    expect { subject }.to change { yields.dup }.from([]).to([ entry ])
+  end
+end

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

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+shared_examples_for 'DataMapper::OrderedSet#empty? with no entries in it' do
+  it { should be(true) }
+end
+
+shared_examples_for 'DataMapper::OrderedSet#empty? with entries in it' do
+  it { should be(false) }
+end

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

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+shared_examples_for 'DataMapper::OrderedSet#entries with no entries' do
+  it { should be_empty }
+end
+
+shared_examples_for 'DataMapper::OrderedSet#entries with entries' do
+  it { should include(entry) }
+end