memory_model 0.0.2 → 0.1.0

data/spec/memory_model/base/{actionable_spec.rb → actions_spec.rb}

@@ -1,8 +1,9 @@
 require 'spec_helper'
 
-describe MemoryModel::Base::Actionable do
+describe MemoryModel::Base::Actions do
   let(:model) do
     Class.new(MemoryModel::Base) do
+      set_primary_key :id
       field :foo
     end
   end
@@ -14,8 +15,8 @@ describe MemoryModel::Base::Actionable do
 
   describe '.create' do
     it 'should be persisted' do
-    instance = model.create
-    instance.should be_persisted
+      instance = model.create
+      instance.should be_persisted
     end
 
     it 'should call the save method' do
@@ -26,12 +27,9 @@ describe MemoryModel::Base::Actionable do
 
   describe '.delete_all' do
     it 'should call delete on each item' do
-      collection_mock = 10.times.map { mock }
-      model.stub(:all).and_return(collection_mock)
-      model.all.each do |instance|
-        instance.should_receive(:delete).and_return(instance)
-        instance.should_receive(:deleted?).and_return(true)
-      end
+      collection_mock = 10.times.map { double }
+      collection_mock.should_receive(:clear)
+      allow(model).to receive(:collection).and_return(collection_mock)
       model.delete_all
     end
     it 'should return true' do
@@ -43,11 +41,10 @@ describe MemoryModel::Base::Actionable do
 
   describe '.destroy_all' do
     it 'should call delete on each item' do
-      collection_mock = 10.times.map { mock }
-      model.stub(:all).and_return(collection_mock)
+      collection_mock = 10.times.map { double }
+      allow(model).to receive(:all).and_return(collection_mock)
       model.all.each do |instance|
         instance.should_receive(:destroy).and_return(instance)
-        instance.should_receive(:deleted?).and_return(true)
       end
       model.destroy_all
     end
@@ -60,44 +57,13 @@ describe MemoryModel::Base::Actionable do
 
   describe '#commit' do
     it 'should save to the collection' do
-      expect { instance.commit }.to change { model.all }
-    end
-
-    it 'should always be the latest record' do
-      instance.commit
-      instance.commit.timestamp.should == model.find(instance.id).timestamp
-    end
-
-    it 'should have a timestamp' do
-      instance.commit
-      instance.timestamp.should be_present
-    end
-
-    it 'should have unfrozen attributes' do
-      instance.commit
-      instance.instance_variable_get(:@attributes).should_not be_frozen
+      expect { instance.send(:commit) }.to change { model.all.to_a }
     end
   end
 
   describe '#delete' do
     it 'should be frozen' do
-      instance.commit.delete.should be_frozen
-    end
-  end
-
-  describe '#deleted_at' do
-    context 'when deleted' do
-      it 'should have a timestamp' do
-        deleted_instance = instance.commit.delete
-        instance.deleted_at.should == deleted_instance.timestamp
-      end
-    end
-
-    context 'when not deleted' do
-      it 'should be nil' do
-        instance.commit
-        instance.deleted_at.should be_nil
-      end
+      instance.send(:commit).delete.should be_frozen
     end
   end
 
@@ -152,59 +118,23 @@ describe MemoryModel::Base::Actionable do
     end
   end
 
-  describe '#dup' do
-    it 'should perform a deep_dup' do
-      instance.should_receive(:deep_dup)
-      instance.dup
-    end
-  end
-
-  describe '#deep_dup' do
-    it 'should not be frozen' do
-      dup = instance.freeze.deep_dup
-      instance.should be_frozen
-      dup.should_not be_frozen
-    end
-
-    it 'should return a new object' do
-      dup = instance.deep_dup
-      dup.object_id.should_not == instance.object_id
-    end
-  end
-
-  describe '#freeze' do
-    it 'should remove invalid ivars' do
-      ivar = :@foo
-      instance.instance_variable_set ivar, 'bar'
-      instance.freeze
-      instance.instance_variables.should_not include ivar
-    end
-
-    it 'should be frozen' do
-      instance.freeze
-      instance.should be_frozen
-    end
-  end
-
-  describe '#restore' do
-    it 'should not be deleted' do
-      instance.commit.delete
-      restored_instance = instance.restore
-      restored_instance.should_not be_deleted
-    end
-  end
-
   describe '#save' do
-    it 'should call delete' do
+    it 'should call commit' do
       instance.should_receive(:commit)
       instance.save
     end
+  end
 
+  describe '#save!' do
+    pending
+  end
+
+  describe 'ActiveModel::Callbacks' do
     context 'with a before_save callback' do
       it 'should run the callback' do
         model.before_save :test_method
         instance.should_receive(:test_method) do
-          instance.should_receive(:commit).and_return(true)
+          expect(model.collection).to receive(:transact)
         end
         instance.save
       end
@@ -212,7 +142,7 @@ describe MemoryModel::Base::Actionable do
       it 'should execution if the callback returns false' do
         model.before_save :test_method
         instance.should_receive(:test_method).and_return(false)
-        instance.should_not_receive(:commit)
+        expect(model.collection).to_not receive(:transact)
         instance.save
       end
     end
@@ -220,8 +150,8 @@ describe MemoryModel::Base::Actionable do
     context 'with an after_save callback' do
       it 'should run the callback' do
         model.after_save :test_method
-        instance.should_receive(:commit) do
-          instance.should_receive(:test_method)
+        expect(model.collection).to receive(:transact) do
+          expect(instance).to receive(:test_method)
         end
         instance.save
       end
@@ -236,7 +166,7 @@ describe MemoryModel::Base::Actionable do
           test_method_b
         end
         instance.should_receive(:test_method_a) do
-          instance.should_receive(:commit) do
+          expect(model.collection).to receive(:transact) do
             instance.should_receive(:test_method_b)
           end
         end
@@ -249,7 +179,7 @@ describe MemoryModel::Base::Actionable do
         it 'should run the callback' do
           model.before_create :test_method
           instance.should_receive(:test_method) do
-            instance.should_receive(:commit).and_return(true)
+            expect(model.collection).to receive(:transact)
           end
           instance.save
         end
@@ -257,7 +187,7 @@ describe MemoryModel::Base::Actionable do
         it 'should execution if the callback returns false' do
           model.before_create :test_method
           instance.should_receive(:test_method).and_return(false)
-          instance.should_not_receive(:commit)
+          instance.class.should_not_receive(:transact)
           instance.save
         end
       end
@@ -265,7 +195,7 @@ describe MemoryModel::Base::Actionable do
       context 'with an after_create callback' do
         it 'should run the callback' do
           model.after_create :test_method
-          instance.should_receive(:commit) do
+          expect(model.collection).to receive(:transact) do
             instance.should_receive(:test_method)
           end
           instance.save
@@ -281,7 +211,7 @@ describe MemoryModel::Base::Actionable do
             test_method_b
           end
           instance.should_receive(:test_method_a) do
-            instance.should_receive(:commit) do
+            expect(model.collection).to receive(:transact) do
               instance.should_receive(:test_method_b)
             end
           end
@@ -300,12 +230,12 @@ describe MemoryModel::Base::Actionable do
     end
 
     context 'with an existing record' do
-      before(:each) { instance.commit }
+      before(:each) { instance.save }
       context 'with a before_update callback' do
         it 'should run the callback' do
           model.before_update :test_method
           instance.should_receive(:test_method) do
-            instance.should_receive(:commit).and_return(true)
+            expect(model.collection).to receive(:transact)
           end
           instance.save
         end
@@ -313,7 +243,7 @@ describe MemoryModel::Base::Actionable do
         it 'should execution if the callback returns false' do
           model.before_update :test_method
           instance.should_receive(:test_method).and_return(false)
-          instance.should_not_receive(:commit)
+          instance.class.should_not_receive(:transact)
           instance.save
         end
       end
@@ -321,7 +251,7 @@ describe MemoryModel::Base::Actionable do
       context 'with an after_update callback' do
         it 'should run the callback' do
           model.after_update :test_method
-          instance.should_receive(:commit) do
+          expect(model.collection).to receive(:transact) do
             instance.should_receive(:test_method)
           end
           instance.save
@@ -337,7 +267,7 @@ describe MemoryModel::Base::Actionable do
             test_method_b
           end
           instance.should_receive(:test_method_a) do
-            instance.should_receive(:commit) do
+            expect(model.collection).to receive(:transact) do
               instance.should_receive(:test_method_b)
             end
           end
@@ -348,11 +278,12 @@ describe MemoryModel::Base::Actionable do
       context 'it should not call an create callback' do
         it 'should run the callback' do
           model.before_create :test_method
-          instance.should_receive(:commit)
+          expect(model.collection).to receive(:transact)
           instance.should_not_receive(:test_method)
           instance.save
         end
       end
+
     end
   end
 

data/spec/memory_model/base/{attributable_spec.rb → attributes_spec.rb}

@@ -1,12 +1,13 @@
 require 'spec_helper'
 
-describe MemoryModel::Base::Attributable do
+describe MemoryModel::Base::Attributes do
 
   let(:model) do
-    Class.new(MemoryModel::Base) do
+    klass = Class.new(MemoryModel::Base) do
       field :foo
       field :bar
     end
+    stub_const 'MyModel', klass
   end
   let(:instance) do
     model.new
@@ -48,7 +49,7 @@ describe MemoryModel::Base::Attributable do
       end
     end
 
-    context 'given an emtpy Hash' do
+    context 'given an empty Hash' do
       it 'should be true' do
         instance.foo = {}
         instance.has_attribute?(:foo).should be_false
@@ -68,9 +69,6 @@ describe MemoryModel::Base::Attributable do
       end
     end
 
-    it 'should read not initialized' do
-      model.allocate.inspect.should match /not initialized/
-    end
   end
 
   describe '#read_attribute' do

data/spec/memory_model/base/{collectable_spec.rb → collectible_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe MemoryModel::Base::Collectable do
+describe MemoryModel::Base::Collectible do
 
   let(:model) do
     Class.new(MemoryModel::Base) do

data/spec/memory_model/base/fieldable/field_set_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
-describe MemoryModel::Base::Fieldable::FieldSet do
+describe MemoryModel::Base::Fields::FieldSet do
 
-  let(:klass) { MemoryModel::Base::Fieldable::FieldSet }
+  let(:klass) { MemoryModel::Base::Fields::FieldSet }
   subject(:field_set) { klass.new }
 
   describe '.new' do
-    it "should have an empty array of fields" do
-      field_set.instance_variable_get(:@fields).should be_a Array
+    it "should have an empty set of fields" do
+      field_set.should be_a Set
       field_set.size.should == 0
     end
   end
@@ -20,20 +20,14 @@ describe MemoryModel::Base::Fieldable::FieldSet do
     end
   end
 
-  describe '#<<' do
-    it 'should add a field with the symbol' do
-      expect { field_set << :foo }.to change { field_set.fields }
-    end
-  end
-
   describe '#add' do
     it "should add a field" do
-      expect { field_set.add(:foo) }.to change { field_set.fields }
+      expect { field_set.add(:foo) }.to change { field_set }
     end
 
     it "should add a field with options" do
       options = { foo: :bar }
-      expect { field_set.add(:foo, options) }.to change { field_set.fields }
+      expect { field_set.add(:foo, options) }.to change { field_set }
       field_set[:foo].options[:foo].should == :bar
     end
   end
@@ -48,30 +42,22 @@ describe MemoryModel::Base::Fieldable::FieldSet do
     end
   end
 
-  describe '#inspect' do
-    it 'should delegate inspect to #to_a' do
-      names_mock = mock
-      names_mock.should_receive(:inspect)
-      field_set.stub(:to_a).and_return(names_mock)
-      field_set.inspect
-    end
-  end
-
-  describe '#default_values' do
-    let(:mock_model) { mock }
+  describe '#set_default_values' do
+    let(:mock_model) { double }
+    before { allow(mock_model).to receive(:attributes=) { |hash| hash.with_indifferent_access } }
 
     context 'with a symbol' do
       it 'should call the method on the model' do
-        mock_model.should_receive :foo_val
+        mock_model.should_receive(:foo_val).and_return('some_value')
         field_set.add :foo, default: :foo_val
-        field_set.default_values(mock_model)
+        field_set.set_default_values(mock_model)
       end
     end
 
     context 'with a string' do
       it 'should set the string' do
         field_set.add :foo, default: 'foo_val'
-        defaults = field_set.default_values(mock_model)
+        defaults = field_set.set_default_values(mock_model)
         defaults[:foo].should == 'foo_val'
       end
     end
@@ -79,22 +65,22 @@ describe MemoryModel::Base::Fieldable::FieldSet do
     context 'with a lambda with an arity of 0' do
       it 'should evaluate the block' do
         field_set.add :foo, default: -> { 5 + 5 }
-        field_set.default_values(mock_model)[:foo].should == 10
+        field_set.set_default_values(mock_model)[:foo].should == 10
       end
     end
 
     context 'with a lambda with an arity of 1' do
       it 'should evaluate the block' do
-        mock_model.should_receive :foo_val
+        mock_model.should_receive(:foo_val).and_return('some value')
         field_set.add :foo, default: ->(model) { model.foo_val }
-        field_set.default_values(mock_model)
+        field_set.set_default_values(mock_model)
       end
     end
 
     context 'with a lambda with an arity of 2' do
       it 'should raise an error' do
         field_set.add :foo, default: ->(model, other_var) { nil }
-        expect { field_set.default_values(mock_model) }.to raise_error ArgumentError
+        expect { field_set.set_default_values(mock_model) }.to raise_error ArgumentError
       end
     end
 
@@ -102,36 +88,36 @@ describe MemoryModel::Base::Fieldable::FieldSet do
       it 'should evaluate the block' do
         mock_model.should_receive :foo_val
         field_set.add :foo, default: proc { foo_val }
-        field_set.default_values(mock_model)
+        field_set.set_default_values(mock_model)
       end
     end
 
     context 'with a proc with an arity of 1' do
       it 'should evaluate the block' do
-        mock_model.should_receive :foo_val
+        mock_model.should_receive(:foo_val).and_return('Foo')
         field_set.add :foo, default: proc { |model| model.foo_val }
-        field_set.default_values(mock_model)
+        field_set.set_default_values(mock_model)
       end
     end
 
     context 'with a proc with an arity of 2' do
       it 'should raise an error' do
         field_set.add :foo, default: proc { |model, other_var| model.foo_val }
-        expect { field_set.default_values(mock_model) }.to raise_error ArgumentError
+        expect { field_set.set_default_values(mock_model) }.to raise_error ArgumentError
       end
     end
 
     context 'with a nil value' do
       it 'should return nil' do
         field_set.add :foo
-        field_set.default_values(mock_model)[:foo].should be_nil
+        field_set.set_default_values(mock_model)[:foo].should be_nil
       end
     end
 
     context 'when an invalid object' do
       it 'should raise an error' do
         field_set.add :foo, default: Object.new
-        expect { field_set.default_values(mock_model) }.to raise_error ArgumentError
+        expect { field_set.set_default_values(mock_model) }.to raise_error ArgumentError
       end
     end
   end
@@ -146,7 +132,7 @@ describe MemoryModel::Base::Fieldable::FieldSet do
 
   describe '#method_missing' do
     it 'should delegate off to #to_a' do
-      mock_array = mock
+      mock_array = double
       mock_array.should_receive :fubar
       field_set.stub(:to_a).and_return(mock_array)
       field_set.fubar

data/spec/memory_model/base/fieldable/field_spec.rb

@@ -1,21 +1,21 @@
 require 'spec_helper'
 
-describe MemoryModel::Base::Fieldable::Field do
+describe MemoryModel::Base::Fields::Field do
 
-  subject(:field) { MemoryModel::Base::Fieldable::Field.new(:foo) }
+  subject(:field) { MemoryModel::Base::Fields::Field.new(:foo) }
 
   describe '.new' do
     it 'should not raise an error' do
-      expect { MemoryModel::Base::Fieldable::Field.new(:foo) }.to_not raise_error
+      expect { MemoryModel::Base::Fields::Field.new(:foo) }.to_not raise_error
     end
 
     it 'should have default options' do
-      field = MemoryModel::Base::Fieldable::Field.new(:foo)
+      field = MemoryModel::Base::Fields::Field.new(:foo)
       field.options.should be_present
     end
 
     it 'should set_options' do
-      field = MemoryModel::Base::Fieldable::Field.new(:foo, bar: :baz)
+      field = MemoryModel::Base::Fields::Field.new(:foo, bar: :baz)
       field.options[:bar].should == :baz
     end
   end
@@ -23,27 +23,27 @@ describe MemoryModel::Base::Fieldable::Field do
   describe '#==' do
     context 'given a field' do
       it 'should be equal to an object with the same name' do
-        field_a = MemoryModel::Base::Fieldable::Field.new(:foo, comparable: true)
-        field_b = MemoryModel::Base::Fieldable::Field.new(:foo, comparable: false)
+        field_a = MemoryModel::Base::Fields::Field.new(:foo, comparable: true)
+        field_b = MemoryModel::Base::Fields::Field.new(:foo, comparable: false)
         (field_a == field_b).should be_true
       end
 
       it 'should not be equal to an object with a different name' do
-        field_a = MemoryModel::Base::Fieldable::Field.new(:foo)
-        field_b = MemoryModel::Base::Fieldable::Field.new(:bar)
+        field_a = MemoryModel::Base::Fields::Field.new(:foo)
+        field_b = MemoryModel::Base::Fields::Field.new(:bar)
         (field_a == field_b).should be_false
       end
     end
 
     context 'given a symbol' do
       it 'should be equal to an object with the same name' do
-        field_a = MemoryModel::Base::Fieldable::Field.new(:foo, comparable: true)
+        field_a = MemoryModel::Base::Fields::Field.new(:foo, comparable: true)
         field_b = :foo
         (field_a == field_b).should be_true
       end
 
       it 'should not be equal to an object with a different name' do
-        field_a = MemoryModel::Base::Fieldable::Field.new(:foo)
+        field_a = MemoryModel::Base::Fields::Field.new(:foo)
         field_b = :bar
         (field_a == field_b).should be_false
       end
@@ -52,31 +52,31 @@ describe MemoryModel::Base::Fieldable::Field do
 
   describe '#comparable?' do
     it 'should return true' do
-      field = MemoryModel::Base::Fieldable::Field.new(:foo, comparable: true)
+      field = MemoryModel::Base::Fields::Field.new(:foo, comparable: true)
       field.comparable?.should be_true
     end
 
     it 'should return false' do
-      field = MemoryModel::Base::Fieldable::Field.new(:foo, comparable: false)
+      field = MemoryModel::Base::Fields::Field.new(:foo, comparable: false)
       field.comparable?.should be_false
     end
   end
 
   describe '#default' do
     it 'should return the default value' do
-      field = MemoryModel::Base::Fieldable::Field.new(:foo, default: 'foo')
+      field = MemoryModel::Base::Fields::Field.new(:foo, default: 'foo')
       field.default.should == 'foo'
     end
   end
 
   describe '#readonly?' do
     it 'should return true' do
-      field = MemoryModel::Base::Fieldable::Field.new(:foo, readonly: true)
+      field = MemoryModel::Base::Fields::Field.new(:foo, readonly: true)
       field.readonly?.should be_true
     end
 
     it 'should return false' do
-      field = MemoryModel::Base::Fieldable::Field.new(:foo, readonly: false)
+      field = MemoryModel::Base::Fields::Field.new(:foo, readonly: false)
       field.readonly?.should be_false
     end
   end

data/spec/memory_model/base/{fieldable_spec.rb → fields_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe MemoryModel::Base::Fieldable do
+describe MemoryModel::Base::Fields do
 
   let(:model_a) { Class.new(MemoryModel::Base) }
   let(:model_b) { Class.new(MemoryModel::Base) }

data/spec/memory_model/base/{comparable_spec.rb → operations/comparisons_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe MemoryModel::Base::Comparable do
+describe MemoryModel::Base::Operations::Comparisons do
   let(:model) do
     Class.new(MemoryModel::Base) do
       field :foo
@@ -47,7 +47,7 @@ describe MemoryModel::Base::Comparable do
     end
 
     context 'given an instance of a different class' do
-      let(:other_class) { Class.new(MemoryModel::Base) }
+      let(:other_class) { model.dup }
       let(:valid_instance) { other_class.new(foo: value) }
       let(:invalid_instance) { other_class.new(foo: 'baz') }
       it 'should be true when given a valid instance' do
@@ -98,7 +98,7 @@ describe MemoryModel::Base::Comparable do
     end
 
     context 'given an instance of a different class' do
-      let(:other_class) { Class.new(MemoryModel::Base) }
+      let(:other_class) { model.dup }
       let(:valid_instance) { other_class.new(foo: value) }
       let(:invalid_instance) { other_class.new(foo: 'baz') }
       it 'should be true when given a valid instance' do
@@ -145,7 +145,7 @@ describe MemoryModel::Base::Comparable do
     end
 
     context 'given an instance of a different class' do
-      let(:other_class) { Class.new(MemoryModel::Base) }
+      let(:other_class) { model.dup }
       let(:other_instance) { other_class.new(foo: value) }
       it 'should be false' do
         (instance === other_instance).should be_false

data/spec/memory_model/base/persistence_spec.rb

@@ -14,7 +14,7 @@ describe MemoryModel::Base::Persistence do
 
   describe '#persisted?' do
     it 'should be true if persisted' do
-      instance.commit
+      instance.save
       instance.persisted?.should be_true
     end
 
@@ -25,7 +25,7 @@ describe MemoryModel::Base::Persistence do
 
   describe '#new_record?' do
     it 'should be true unless persisted' do
-      instance.commit
+      instance.save
       instance.new_record?.should be_false
     end
 

data/spec/memory_model/base_spec.rb

@@ -25,11 +25,7 @@ describe MemoryModel::Base do
     end
 
     it 'should have a field set' do
-      model.fields.should be_a MemoryModel::Base::Fieldable::FieldSet
-    end
-
-    it 'should have an id field' do
-      model.fields.should include :id
+      model.fields.should be_a MemoryModel::Base::Fields::FieldSet
     end
   end
 
@@ -39,12 +35,17 @@ describe MemoryModel::Base do
         field :foo
       end
     end
-    let(:value) { 'bar' }
-    subject(:instance) { model.new(foo: value) }
+    let(:attributes) { { foo: 'bar' } }
+    subject(:instance) { model.new(attributes) }
 
     describe '.new' do
-      it 'should have an id' do
-        model.new.id.should be_present
+      it 'should set the default values' do
+        expect_any_instance_of(MemoryModel::Base::Fields::FieldSet).to receive(:set_default_values).with(an_instance_of(model), attributes)
+        instance
+      end
+
+      it 'should run initialize callbacks' do
+        pending
       end
     end
   end