active_data 0.1.0 → 0.2.0

data/lib/active_data/model.rb

@@ -18,12 +18,9 @@ module ActiveData
 
     included do
       include ActiveModel::Conversion
-      include ActiveModel::Dirty
       include ActiveModel::Validations
-      include ActiveModel::MassAssignmentSecurity
       include ActiveModel::Serialization
       include ActiveModel::Serializers::JSON
-      include ActiveModel::Serializers::Xml
 
       include Attributable
       include Localizable
@@ -31,7 +28,6 @@ module ActiveData
       include Associations
       include NestedAttributes
       include Parameterizable
-      extend ActiveModel::Callbacks
       extend ActiveModel::Naming
       extend ActiveModel::Translation
 
@@ -46,17 +42,28 @@ module ActiveData
       def self.i18n_scope
         :active_data
       end
+
+      def serializable_hash *args
+        super(*args).stringify_keys!
+      end
     end
 
     module ClassMethods
-      def instantiate attributes
-        return attributes if attributes.instance_of? self
+      def instantiate data
+        return data if data.class.include? ActiveData::Model
 
+        data = data.symbolize_keys
         instance = allocate
 
-        instance.instance_variable_set(:@attributes, initialize_attributes)
+        attributes = initialize_attributes
+        attributes.merge!(data.slice(*attributes.keys))
+
+        data.slice(*association_names.map(&:to_sym)).each do |association, data|
+          instance.send(:"#{association}=", data)
+        end
+
+        instance.instance_variable_set(:@attributes, attributes)
         instance.instance_variable_set(:@new_record, false)
-        instance.attributes = attributes
 
         instance
       end
@@ -74,9 +81,8 @@ module ActiveData
       other.instance_of?(self.class) && other.attributes == attributes
     end
 
-    def assign_attributes(attributes, options = {})
-      super(sanitize_for_mass_assignment((attributes.presence || {}), options[:as]))
+    def inspect
+      "#<#{self.class} #{attributes.map { |name, value| "#{name}: #{value.inspect}" }.join(' ')}>"
     end
-
   end
 end

data/lib/active_data/validations/associated.rb

@@ -0,0 +1,17 @@
+module ActiveData
+  module Validations
+    class AssociatedValidator < ActiveModel::EachValidator #:nodoc:
+      def validate_each(record, attribute, value)
+        if Array.wrap(value).reject { |r| r.respond_to?(:valid?) && r.valid?(record.validation_context) }.any?
+          record.errors.add(attribute, :invalid, options.merge(:value => value))
+        end
+      end
+    end
+
+    module ClassMethods
+      def validates_associated(*attr_names)
+        validates_with AssociatedValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/lib/active_data/validations.rb

@@ -0,0 +1,7 @@
+require 'active_data/validations/associated'
+
+module ActiveData
+  module Validations
+    extend ActiveSupport::Concern
+  end
+end

data/lib/active_data/version.rb

@@ -1,3 +1,3 @@
 module ActiveData
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/active_data.rb

@@ -1,9 +1,9 @@
 require 'active_support/concern'
 require 'active_support/core_ext'
-require 'active_support/hash_with_indifferent_access'
 require 'active_model'
 require 'active_data/version'
 require 'active_data/model'
+require 'active_data/validations'
 
 module ActiveData
 end

data/spec/lib/active_data/model/associations/embeds_many_spec.rb

@@ -0,0 +1,93 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe ActiveData::Model::Associations::EmbedsMany do
+
+  class ManyAssoc
+    include ActiveData::Model
+
+    attribute :name
+  end
+
+  let(:noassoc) do
+    Class.new do
+      include ActiveData::Model
+
+      attribute :name
+    end
+  end
+
+  let(:klass) do
+    Class.new(noassoc) do
+      embeds_many :many_assocs
+    end
+  end
+
+  let(:inherited1) do
+    Class.new(klass) do
+      embeds_many :many_assocs_inherited1, class_name: ManyAssoc
+    end
+  end
+
+  let(:inherited2) do
+    Class.new(noassoc) do
+      embeds_many :many_assocs_inherited2, class_name: ManyAssoc
+    end
+  end
+
+  subject { klass.new(name: 'world') }
+
+  context do
+    specify { subject.many_assocs.should be_empty }
+    specify { subject.many_assocs.should be_instance_of ManyAssoc.collection_class }
+    specify { subject.many_assocs.count.should == 0 }
+  end
+
+  context 'accessor with objects' do
+    before { subject.many_assocs = [ManyAssoc.new(name: 'foo'), ManyAssoc.new(name: 'bar')] }
+    specify { subject.many_assocs.count.should == 2 }
+    specify { subject.many_assocs[0].name.should == 'foo' }
+    specify { subject.many_assocs[1].name.should == 'bar' }
+  end
+
+  context 'accessor with attributes' do
+    before { subject.many_assocs = [{ name: 'foo' }, { name: 'bar' }] }
+    specify { subject.many_assocs.count.should == 2 }
+    specify { subject.many_assocs[0].name.should == 'foo' }
+    specify { subject.many_assocs[1].name.should == 'bar' }
+  end
+
+  context 'inheritance' do
+    specify { noassoc.association_names.should == [] }
+    specify { klass.association_names.should == %w(many_assocs) }
+    specify { inherited1.association_names.should == %w(many_assocs many_assocs_inherited1) }
+    specify { inherited2.association_names.should == %w(many_assocs_inherited2) }
+  end
+
+  describe '#instantiate' do
+    subject { klass.instantiate name: 'Root', many_assocs: [{ name: 'foo' }, { name: 'bar' }] }
+
+    its('many_assocs.count') { should == 2 }
+  end
+
+  describe '#==' do
+    let(:instance) { klass.new(name: 'world') }
+    before { subject.many_assocs = [ManyAssoc.new(name: 'foo'), ManyAssoc.new(name: 'bar')] }
+    specify { subject.should_not == instance }
+
+    context do
+      before { instance.many_assocs = [ManyAssoc.new(name: 'foo')] }
+      specify { subject.should_not == instance }
+    end
+
+    context do
+      before { instance.many_assocs = [ManyAssoc.new(name: 'foo1'), ManyAssoc.new(name: 'bar')] }
+      specify { subject.should_not == instance }
+    end
+
+    context do
+      before { instance.many_assocs = [ManyAssoc.new(name: 'foo'), ManyAssoc.new(name: 'bar')] }
+      specify { subject.should == instance }
+    end
+  end
+end

data/spec/lib/active_data/model/associations/embeds_one_spec.rb

@@ -0,0 +1,57 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe ActiveData::Model::Associations::EmbedsMany do
+
+  class OneAssoc
+    include ActiveData::Model
+
+    attribute :name
+  end
+
+  let(:klass) do
+    Class.new do
+      include ActiveData::Model
+
+      attribute :name
+      embeds_one :one_assoc
+    end
+  end
+
+  subject { klass.new(name: 'world') }
+
+  its(:one_assoc) { should be_nil }
+
+  context 'accessor with objects' do
+    before { subject.one_assoc = OneAssoc.new(name: 'foo') }
+    specify { subject.one_assoc.should be_instance_of OneAssoc }
+    specify { subject.one_assoc.name.should == 'foo' }
+  end
+
+  context 'accessor with attributes' do
+    before { subject.one_assoc = { name: 'foo' } }
+    specify { subject.one_assoc.should be_instance_of OneAssoc }
+    specify { subject.one_assoc.name.should == 'foo' }
+  end
+
+  context 'accessor with nothing' do
+    before { subject.one_assoc = nil }
+    specify { subject.one_assoc.should be_nil }
+  end
+
+  describe '#==' do
+    let(:instance) { klass.new(name: 'world') }
+    before { subject.one_assoc = { name: 'foo' } }
+    specify { subject.should_not == instance }
+
+    context do
+      before { instance.one_assoc = { name: 'foo1' } }
+      specify { subject.should_not == instance }
+    end
+
+    context do
+      before { instance.one_assoc = { name: 'foo' } }
+      specify { subject.should == instance }
+    end
+  end
+end

data/spec/lib/active_data/model/attributable_spec.rb

@@ -9,6 +9,7 @@ describe ActiveData::Model::Attributable do
       attr_reader :name
 
       attribute :hello
+      attribute :string, type: String, default_blank: true, default: ->(record){ record.name }
       attribute :count, type: Integer, default: 10
       attribute(:calc, type: Integer) { 2 + 3 }
       attribute :enum, type: Integer, in: [1, 2, 3]
@@ -23,8 +24,8 @@ describe ActiveData::Model::Attributable do
   context do
     subject { klass.new('world') }
     specify { klass.enum_values == [1, 2, 3] }
-    its(:attributes) { should ==  { "hello"=>nil, "count"=>10, "calc"=>5, "enum" => nil }  }
-    its(:present_attributes) { should ==  { "count"=>10, "calc"=>5 }  }
+    its(:attributes) { should ==  { hello: nil, count: 10, calc: 5, enum: nil, string: 'world' }  }
+    its(:present_attributes) { should ==  { count: 10, calc: 5, string: 'world' }  }
     its(:name) { should == 'world' }
     its(:hello) { should be_nil }
     its(:count) { should == 10 }
@@ -34,4 +35,119 @@ describe ActiveData::Model::Attributable do
     specify { expect { subject.calc = 15 } .to change { subject.calc } .from(5).to(15) }
   end
 
+  context 'calculating default values' do
+    let(:klass) do
+      Class.new do
+        include ActiveData::Model::Attributable
+
+        attribute(:rand, type: String) { SecureRandom.uuid }
+
+        def initialize
+          @attributes = self.class.initialize_attributes
+        end
+      end
+    end
+
+    subject { klass.new }
+    specify { subject.rand.should == subject.rand }
+    specify { subject.rand.should_not == klass.new.rand }
+  end
+
+  context 'default_blank' do
+    let(:klass) do
+      Class.new do
+        include ActiveData::Model::Attributable
+
+        attribute :string1, type: String, default_blank: true, default: 'default'
+        attribute :string2, type: String, default: 'default'
+
+        def initialize attributes = {}
+          @attributes = self.class.initialize_attributes
+          self.attributes = attributes
+        end
+      end
+    end
+
+    specify { klass.new.string1.should == 'default' }
+    specify { klass.new.string2.should == 'default' }
+    specify { klass.new(string1: '').string1.should == 'default' }
+    specify { klass.new(string2: '').string2.should == '' }
+    specify { klass.new(string1: 'hello').string1.should == 'hello' }
+    specify { klass.new(string2: 'hello').string2.should == 'hello' }
+  end
+
+  context 'attribute caching' do
+    subject { klass.new('world') }
+
+    context do
+      before do
+        subject.send(:attributes_cache).should_not_receive(:[])
+      end
+
+      specify { subject.hello }
+    end
+
+    context do
+      before do
+        subject.hello
+        subject.send(:attributes_cache).should_receive(:[]).with(:hello).once
+      end
+
+      specify { subject.hello }
+    end
+
+    context 'attribute cache reset' do
+      before do
+        subject.hello = 'blabla'
+        subject.hello
+        subject.hello = 'newnewnew'
+      end
+
+      specify { subject.hello.should == 'newnewnew' }
+    end
+  end
+
+  context 'inheritance' do
+    let!(:ancestor) do
+      Class.new do
+        include ActiveData::Model::Attributable
+        attribute :foo
+      end
+    end
+
+    let!(:descendant1) do
+      Class.new ancestor do
+        attribute :bar
+      end
+    end
+
+    let!(:descendant2) do
+      Class.new ancestor do
+        attribute :baz
+        attribute :moo
+      end
+    end
+
+    specify { ancestor._attributes.keys.should == [:foo] }
+    specify { ancestor.instance_methods.should include :foo, :foo= }
+    specify { ancestor.instance_methods.should_not include :bar, :bar=, :baz, :baz= }
+    specify { descendant1._attributes.keys.should == [:foo, :bar] }
+    specify { descendant1.instance_methods.should include :foo, :foo=, :bar, :bar= }
+    specify { descendant1.instance_methods.should_not include :baz, :baz= }
+    specify { descendant2._attributes.keys.should == [:foo, :baz, :moo] }
+    specify { descendant2.instance_methods.should include :foo, :foo=, :baz, :baz=, :moo, :moo= }
+    specify { descendant2.instance_methods.should_not include :bar, :bar= }
+  end
+
+  context '#write_attributes' do
+    subject { klass.new('world') }
+
+    specify { expect { subject.write_attributes(strange: 'value') }.to raise_error NoMethodError }
+
+    context do
+      before { subject.write_attributes('hello' => 'blabla', count: 20) }
+      specify { subject.attributes.should == { hello: 'blabla', count: 20, calc: 5, enum: nil, string: 'world' } }
+    end
+  end
+
 end

data/spec/lib/active_data/model/attributes/localized_spec.rb

@@ -42,6 +42,7 @@ describe Localized do
         I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
         I18n.fallbacks.map(en: :ru)
       end
+      after { I18n.fallbacks = false }
       its(:name) { should == 'Привет' }
     end
   end

data/spec/lib/active_data/model/collectionizable_spec.rb

@@ -13,22 +13,48 @@ describe ActiveData::Model::Collectionizable do
       end
 
       def self.no_mars
-        delete_if{|i| i.name == 'Mars'}
+        delete_if { |i| i.name == 'Mars' }
       end
     end
   end
-  let(:collection){klass.collection([{:name => 'Hello'}, {:name => 'World'}, {:name => 'Mars'}])}
-
-  specify{klass.const_defined?('Collection').should be_true}
-  specify{klass.collection_class.should == klass.const_get(:Collection)}
-  specify{klass.collection_class.collectible.should == klass}
-  specify{klass.collection_class.new.should be_empty}
-
-  specify{collection.should be_instance_of klass.collection_class}
-  specify{collection.except_first.should be_instance_of klass.collection_class}
-  specify{collection.no_mars.should be_instance_of klass.collection_class}
-  specify{collection.except_first.should == klass.collection([{:name => 'World'}, {:name => 'Mars'}])}
-  specify{collection.no_mars.should == klass.collection([{:name => 'Hello'}, {:name => 'World'}])}
-  specify{collection.except_first.no_mars.should == klass.collection([{:name => 'World'}])}
-  specify{collection.no_mars.except_first.should == klass.collection([{:name => 'World'}])}
+
+  class CollectionizableTest
+    include ActiveData::Model
+  end
+
+  let(:collection) { klass.collection([{ name: 'Hello' }, { name: 'World' }, { name: 'Mars' }]) }
+
+  specify { klass.collection_class.should_not be_nil }
+  specify { klass.collection_class.collectible.should == klass }
+  specify { klass.collection_class.new.should be_empty }
+  specify { CollectionizableTest.collection_class.should < Array }
+
+  specify { collection.should be_instance_of klass.collection_class }
+  specify { collection.except_first.should be_instance_of klass.collection_class }
+  specify { collection.no_mars.should be_instance_of klass.collection_class }
+  specify { collection.except_first.should == klass.collection([{ name: 'World' }, { name: 'Mars' }]) }
+  specify { collection.no_mars.should == klass.collection([{ name: 'Hello' }, { name: 'World' }]) }
+  specify { collection.except_first.no_mars.should == klass.collection([{ name: 'World' }]) }
+  specify { collection.no_mars.except_first.should == klass.collection([{ name: 'World' }]) }
+
+  context do
+    let!(:ancestor) do
+      Class.new do
+        include ActiveData::Model
+      end
+    end
+
+    let!(:descendant1) do
+      Class.new ancestor
+    end
+
+    let!(:descendant2) do
+      Class.new ancestor
+    end
+
+    specify { descendant1.collection_class.should < Array }
+    specify { descendant2.collection_class.should < Array }
+    specify { ancestor.collection_class.should_not == descendant1.collection_class }
+    specify { descendant1.collection_class.should_not == descendant2.collection_class }
+  end
 end

data/spec/lib/active_data/model/nested_attributes_spec.rb

@@ -3,44 +3,65 @@ require 'spec_helper'
 
 describe ActiveData::Model::Associations do
 
-  class Assoc
+  class NestedAssoc
     include ActiveData::Model
 
     attribute :name
   end
 
-  let(:klass) do
-    Class.new do
-      include ActiveData::Model
+  context do
+    let(:klass) do
+      Class.new do
+        include ActiveData::Model
 
-      attribute :name
-      embeds_many :assocs
+        attribute :name
+        embeds_one :assoc, class_name: NestedAssoc
 
-      accepts_nested_attributes_for :assocs
+        accepts_nested_attributes_for :assoc
+      end
     end
-  end
+    let(:instance) { klass.new( name: 'world') }
 
-  let(:instance){klass.new(:name => 'world')}
-
-  context do
-    before { instance.assocs_attributes = [{:name => 'foo'}, {:name => 'bar'}] }
-    specify { instance.assocs.count.should == 2 }
-    specify { instance.assocs.first.name.should == 'foo' }
-    specify { instance.assocs.last.name.should == 'bar' }
+    context do
+      before { instance.assoc_attributes = { name: 'foo'} }
+      specify { instance.assoc.should be_instance_of NestedAssoc }
+      specify { instance.assoc.name.should == 'foo' }
+    end
   end
 
   context do
-    before { instance.assocs_attributes = {1 => {:name => 'baz'}, 2 => {:name => 'foo'}} }
-    specify { instance.assocs.count.should == 2 }
-    specify { instance.assocs.first.name.should == 'baz' }
-    specify { instance.assocs.last.name.should == 'foo' }
-  end
+    let(:klass) do
+      Class.new do
+        include ActiveData::Model
 
-  context do
-    before { instance.assocs_attributes = {1 => {:name => 'baz'}, 2 => {:name => 'foo'}} }
-    specify { instance.to_params.should == {
-      "name" => "world",
-      "assocs_attributes" => {'0' => {"name" => "baz"}, '1' => {"name" => "foo"}}
-    } }
+        attribute :name
+        embeds_many :assocs, class_name: NestedAssoc
+
+        accepts_nested_attributes_for :assocs
+      end
+    end
+    let(:instance) { klass.new(name: 'world') }
+
+    context do
+      before { instance.assocs_attributes = [{ name: 'foo' }, { name: 'bar' }] }
+      specify { instance.assocs.count.should == 2 }
+      specify { instance.assocs.first.name.should == 'foo' }
+      specify { instance.assocs.last.name.should == 'bar' }
+    end
+
+    context do
+      before { instance.assocs_attributes = {1 => { name: 'baz' }, 2 => { name: 'foo' }} }
+      specify { instance.assocs.count.should == 2 }
+      specify { instance.assocs.first.name.should == 'baz' }
+      specify { instance.assocs.last.name.should == 'foo' }
+    end
+
+    context do
+      before { instance.assocs_attributes = {1 => { name: 'baz' }, 2 => { name: 'foo' }} }
+      specify { instance.to_params.should == {
+        "name" => "world",
+        "assocs_attributes" => {'0' => {"name" => "baz"}, '1' => {"name" => "foo"}}
+      } }
+    end
   end
 end

data/spec/lib/active_data/model/type_cast_spec.rb

@@ -2,7 +2,6 @@
 require 'spec_helper'
 
 describe 'typecasting' do
-
   let(:klass) do
     Class.new do
       include ActiveData::Model::Attributable
@@ -14,6 +13,9 @@ describe 'typecasting' do
       attribute :big_decimal, type: BigDecimal
       attribute :boolean, type: Boolean
       attribute :array, type: Array
+      attribute :date, type: Date
+      attribute :datetime, type: DateTime
+      attribute :time, type: Time
 
       def initialize name = nil
         @attributes = self.class.initialize_attributes
@@ -45,7 +47,7 @@ describe 'typecasting' do
     specify{subject.tap{|s| s.float = 'hello'}.float.should == nil}
     specify{subject.tap{|s| s.float = '123hello'}.float.should == nil}
     specify{subject.tap{|s| s.float = '123'}.float.should == 123.0}
-    specify{subject.tap{|s| s.float = '123.'}.float.should == 123.0}
+    specify{subject.tap{|s| s.float = '123.'}.float.should == nil}
     specify{subject.tap{|s| s.float = '123.5'}.float.should == 123.5}
     specify{subject.tap{|s| s.float = 123}.float.should == 123.0}
     specify{subject.tap{|s| s.float = 123.5}.float.should == 123.5}
@@ -57,7 +59,7 @@ describe 'typecasting' do
     specify{subject.tap{|s| s.big_decimal = 'hello'}.big_decimal.should == nil}
     specify{subject.tap{|s| s.big_decimal = '123hello'}.big_decimal.should == nil}
     specify{subject.tap{|s| s.big_decimal = '123'}.big_decimal.should == BigDecimal.new('123.0')}
-    specify{subject.tap{|s| s.big_decimal = '123.'}.big_decimal.should == BigDecimal.new('123.0')}
+    specify{subject.tap{|s| s.big_decimal = '123.'}.big_decimal.should == nil}
     specify{subject.tap{|s| s.big_decimal = '123.5'}.big_decimal.should == BigDecimal.new('123.5')}
     specify{subject.tap{|s| s.big_decimal = 123}.big_decimal.should == BigDecimal.new('123.0')}
     specify{subject.tap{|s| s.big_decimal = 123.5}.big_decimal.should == BigDecimal.new('123.5')}
@@ -85,4 +87,30 @@ describe 'typecasting' do
     specify{subject.tap{|s| s.array = 10}.array.should == nil}
   end
 
+  context 'date' do
+    let(:date) { Date.new(2013, 6, 13) }
+    specify{subject.tap{|s| s.date = nil}.date.should == nil}
+    specify{subject.tap{|s| s.date = '2013-06-13'}.date.should == date}
+    specify{subject.tap{|s| s.date = '2013-55-55'}.date.should == nil}
+    specify{subject.tap{|s| s.date = DateTime.new(2013, 6, 13, 23, 13)}.date.should == date}
+    specify{subject.tap{|s| s.date = Time.new(2013, 6, 13, 23, 13)}.date.should == date}
+  end
+
+  context 'datetime' do
+    let(:datetime) { DateTime.new(2013, 6, 13, 23, 13) }
+    specify{subject.tap{|s| s.datetime = nil}.datetime.should == nil}
+    specify{subject.tap{|s| s.datetime = '2013-06-13 23:13'}.datetime.should == datetime}
+    specify{subject.tap{|s| s.datetime = '2013-55-55 55:55'}.datetime.should == nil}
+    specify{subject.tap{|s| s.datetime = Date.new(2013, 6, 13)}.datetime.should == DateTime.new(2013, 6, 13, 0, 0)}
+    specify{subject.tap{|s| s.datetime = Time.utc_time(2013, 6, 13, 23, 13).utc}.datetime.should == DateTime.new(2013, 6, 13, 23, 13)}
+  end
+
+  context 'time' do
+    let(:time) { Time.utc_time(2013, 6, 13, 23, 13) }
+    specify{subject.tap{|s| s.time = nil}.time.should == nil}
+    specify{subject.tap{|s| s.time = '2013-06-13 23:13'}.time.should == time}
+    specify{subject.tap{|s| s.time = '2013-55-55 55:55'}.time.should == nil}
+    specify{subject.tap{|s| s.time = Date.new(2013, 6, 13)}.time.should == Time.new(2013, 6, 13, 0, 0)}
+    specify{subject.tap{|s| s.time = DateTime.new(2013, 6, 13, 23, 13)}.time.should == time}
+  end
 end

data/spec/lib/active_data/model_spec.rb

@@ -2,7 +2,6 @@
 require 'spec_helper'
 
 describe ActiveData::Model do
-
   let(:model) do
     Class.new do
       include ActiveData::Model
@@ -12,12 +11,32 @@ describe ActiveData::Model do
     end
   end
 
-  specify{model.i18n_scope.should == :active_data}
-  specify{model.new.should_not be_persisted}
-  specify{model.instantiate({}).should be_an_instance_of model}
-  specify{model.instantiate({}).should be_persisted}
+  specify { expect { model.blablabla }.to raise_error NoMethodError }
+  specify { model.i18n_scope.should == :active_data }
+  specify { model.new.should_not be_persisted }
+  specify { model.instantiate({}).should be_an_instance_of model }
+  specify { model.instantiate({}).should be_persisted }
 
   context 'Fault tolerance' do
-    specify{ expect { model.new(:foo => 'bar') }.not_to raise_error }
+    specify{ expect { model.new(foo: 'bar') }.not_to raise_error }
+  end
+
+  describe '#instantiate' do
+    context do
+      subject(:instance) { model.instantiate(name: 'Hello', foo: 'Bar') }
+
+      specify { subject.instance_variable_get(:@attributes).should == { name: 'Hello', count: nil } }
+    end
+  end
+
+  describe '#==' do
+    subject { model.new name: 'hello', count: 42 }
+    it { should_not == nil }
+    it { should_not == 'hello' }
+    it { should_not == Object.new }
+    it { should_not == model.new }
+    it { should_not == model.new(name: 'hello1', count: 42) }
+    it { should_not == model.new(name: 'hello', count: 42.1) }
+    it { should == model.new(name: 'hello', count: 42) }
   end
-end
+end