dm-core 1.0.2 → 1.1.0.rc1

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

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

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+shared_examples_for 'DataMapper::OrderedSet#include? when the entry is present' do
+  it { should be(true) }
+end
+
+shared_examples_for 'DataMapper::OrderedSet#include? when the entry is not present' do
+  it { should be(false) }
+end

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

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+shared_examples_for 'DataMapper::OrderedSet#index when the entry is not present' do
+  it { should be(nil) }
+end
+
+shared_examples_for 'DataMapper::OrderedSet#index when 1 entry is present' do
+  it { should == 0 }
+end
+
+shared_examples_for 'DataMapper::OrderedSet#index when 2 entries are present' do
+  it { should == 1 }
+end

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

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+shared_examples_for 'DataMapper::OrderedSet#initialize when no entries are given' do
+  it { should be_empty }
+
+  its(:entries) { should be_empty }
+  its(:size)    { should == 0     }
+end
+
+shared_examples_for 'DataMapper::OrderedSet#initialize when entries are given and they do not contain duplicates' do
+  it { should_not be_empty    }
+  it { should include(entry1) }
+  it { should include(entry2) }
+
+  its(:size) { should ==  2 }
+
+  it 'should retain insertion order' do
+    subject.index(entry1).should == 0
+    subject.index(entry2).should == 1
+  end
+end
+
+shared_examples_for 'DataMapper::OrderedSet#initialize when entries are given and they contain duplicates' do
+  it { should_not be_empty    }
+  it { should include(entry1) }
+
+  its(:size) { should ==  1 }
+end

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

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+shared_examples_for 'DataMapper::OrderedSet#merge when merging two empty sets' do
+  it { should be_instance_of(set.class) }
+  it { should equal(set)                }
+  it { should == set                    }
+end
+
+shared_examples_for 'DataMapper::OrderedSet#merge when merging a set with already present entries' do
+  it { should equal(set)     }
+  it { should == set         }
+  it { should include(entry) }
+
+  it 'does not add an entry to the set' do
+    expect { subject }.to_not change { set.size }
+  end
+end
+
+shared_examples_for 'DataMapper::OrderedSet#merge when merging a set with not yet present entries' do
+  it { should equal(set)      }
+  it { should != set          }
+  it { should include(entry1) }
+  it { should include(entry2) }
+
+  it 'adds an entry to the set' do
+    expect { subject }.to change { set.size }.from(1).to(2)
+  end
+end

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

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+shared_examples_for 'DataMapper::OrderedSet#size when no entry is present' do
+  it { should == 0 }
+end
+
+shared_examples_for 'DataMapper::OrderedSet#size when 1 entry is present' do
+  it { should == 1 }
+end
+
+shared_examples_for 'DataMapper::OrderedSet#size when more than 1 entry is present' do
+  it { should == expected_size }
+end

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

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

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

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'dm-core/support/ordered_set'
+require 'unit/data_mapper/ordered_set/shared/size_spec'
+
+describe 'DataMapper::OrderedSet#size' do
+  subject { ordered_set.size }
+
+  context 'when no entry is present' do
+    let(:ordered_set) { DataMapper::OrderedSet.new }
+
+    it_should_behave_like 'DataMapper::OrderedSet#size when no entry is present'
+  end
+
+  context 'when 1 entry is present' do
+    let(:ordered_set) { DataMapper::OrderedSet.new([ 1 ]) }
+
+    it_should_behave_like 'DataMapper::OrderedSet#size when 1 entry is present'
+  end
+
+  context 'when more than 1 entry is present' do
+    let(:ordered_set)   { DataMapper::OrderedSet.new(entries) }
+    let(:entries)       { [ 1, 2 ]                            }
+    let(:expected_size) { entries.size                        }
+
+    it_should_behave_like 'DataMapper::OrderedSet#size when more than 1 entry is present'
+  end
+end

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

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'dm-core/support/ordered_set'
+require 'unit/data_mapper/ordered_set/shared/to_ary_spec'
+
+describe 'DataMapper::OrderedSet#to_ary' do
+  subject { ordered_set.to_ary }
+
+  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#to_ary when no entries are present'
+  end
+
+  context 'when entries are present' do
+    let(:entries) { [ entry1, entry2 ] }
+
+    it_should_behave_like 'DataMapper::OrderedSet#to_ary when entries are present'
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'dm-core/support/subject_set'
+require 'unit/data_mapper/subject_set/shared/append_spec'
+
+describe 'DataMapper::SubjectSet#<<' do
+  before :all do
+
+    class ::Person
+      attr_reader :name
+      attr_reader :hobby
+      def initialize(name, hobby)
+        @name  = name
+        @hobby = hobby
+      end
+    end
+
+  end
+
+  before do
+    @old_size  = set.size
+    @old_index = set.entries.index(entry1)
+  end
+
+  subject { set << entry2 }
+
+  let(:set)    { DataMapper::SubjectSet.new([ entry1 ]) }
+  let(:entry1) { Person.new('snusnu', 'programming')    }
+  let(:entry2) { Person.new('snusnu', 'tabletennis')    }
+
+  context 'when appending a not yet included entry' do
+    let(:entry2) { Person.new('Alice', 'cryptography') }
+
+    it_should_behave_like 'DataMapper::SubjectSet#<< when appending a not yet included entry'
+  end
+
+  context 'when updating an entry with the same cache key' do
+    context 'and the new entry is already included' do
+      let(:entry2) { entry1 }
+
+      it_should_behave_like 'DataMapper::SubjectSet#<< when updating an entry with the same cache key and the new entry is already included'
+    end
+
+    context 'and the new entry is not yet included' do
+      it_should_behave_like 'DataMapper::SubjectSet#<< when updating an entry with the same cache key and the new entry is not yet included'
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'dm-core/support/subject_set'
+require 'unit/data_mapper/subject_set/shared/clear_spec'
+
+describe 'DataMapper::SubjectSet#clear' do
+  before :all do
+
+    class ::Person
+      attr_reader :name
+      def initialize(name)
+        @name = name
+      end
+    end
+
+  end
+
+  subject { set.clear }
+
+  let(:set)    { DataMapper::SubjectSet.new(entries) }
+  let(:entry1) { Person.new('Alice') }
+  let(:entry2) { Person.new('Bob'  ) }
+
+  context 'when no entries are present' do
+    let(:entries) { [] }
+
+    it_should_behave_like 'DataMapper::SubjectSet#clear when no entries are present'
+  end
+
+  context 'when entries are present' do
+    let(:entries) { [ entry1, entry2 ] }
+
+    it_should_behave_like 'DataMapper::SubjectSet#clear when entries are present'
+  end
+end

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

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'dm-core/support/subject_set'
+require 'unit/data_mapper/subject_set/shared/delete_spec'
+
+describe 'DataMapper::SubjectSet#delete' do
+  before :all do
+
+    class ::Person
+      attr_reader :name
+      def initialize(name)
+        @name = name
+      end
+    end
+
+  end
+
+  subject { set }
+
+  let(:set)         { DataMapper::SubjectSet.new([ entry1, entry2, entry3 ]) }
+  let(:ordered_set) { set.entries                                            }
+  let(:entry1)      { Person.new('Alice')                                    }
+  let(:entry2)      { Person.new('John' )                                    }
+  let(:entry3)      { Person.new('Jane' )                                    }
+
+  before do
+    set.delete(entry)
+  end
+
+  context 'when deleting an already included entry' do
+    let(:entry) { entry1 }
+
+    it_should_behave_like 'DataMapper::SubjectSet#delete when deleting an already included entry'
+  end
+
+  context 'when deleting a not yet included entry' do
+    let(:entry) { Person.new('Bob') }
+
+    it_should_behave_like 'DataMapper::SubjectSet#delete when deleting a not yet included entry'
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'dm-core/support/subject_set'
+require 'unit/data_mapper/subject_set/shared/each_spec'
+
+describe 'DataMapper::SubjectSet' do
+  subject { DataMapper::SubjectSet.new }
+
+  it_should_behave_like 'DataMapper::SubjectSet'
+end
+
+describe 'DataMapper::SubjectSet#each' do
+  before :all do
+
+    class ::Person
+      attr_reader :name
+      def initialize(name)
+        @name = name
+      end
+    end
+
+  end
+
+  subject { set.each { |entry| yields << entry } }
+
+  let(:set)    { DataMapper::SubjectSet.new([ entry ]) }
+  let(:entry)  { Person.new('Alice')                   }
+  let(:yields) { []                                    }
+
+  it_should_behave_like 'DataMapper::SubjectSet#each'
+end