couchbase-orm 1.1.0 → 2.0.0

data/spec/base_spec.rb

@@ -2,20 +2,71 @@
 
 require File.expand_path("../support", __FILE__)
 
-
 class BaseTest < CouchbaseOrm::Base
-    attribute :name, :job
+    attribute :name, :string
+    attribute :job, :string
 end
 
 class CompareTest < CouchbaseOrm::Base
-    attribute :age
+    attribute :age, :integer
+end
+
+class TimestampTest < CouchbaseOrm::Base
+    attribute :created_at, :datetime, precision: 6
+    attribute :updated_at, :datetime, precision: 6
+end
+
+class BaseTestWithIgnoredProperties < CouchbaseOrm::Base
+    self.ignored_properties += [:deprecated_property]
+    attribute :name, :string
+    attribute :job, :string
+end
+
+class BaseTestWithPropertiesAlwaysExistsInDocument < CouchbaseOrm::Base
+    self.properties_always_exists_in_document = true
+    attribute :name, :string
 end
 
+class BaseTestWithTimeframe < CouchbaseOrm::Base
+    attribute :name, :string
+    attribute :start_date, :datetime
+    attribute :age, :integer
+end
+
+class DocInvalidOnUpdate < CouchbaseOrm::Base
+    attribute :title
+    validate :foo, on: :update
 
+    def foo
+      errors.add(:title, 'should not be updated')
+    end
+  end
 
 describe CouchbaseOrm::Base do
+
+    it 'should have clean model after find' do
+        base = BaseTest.create!(name: 'joe')
+        base = BaseTest.find base.id
+        expect(base.changed?).to be false
+    end
+
+    it 'stores not stringified changes' do
+        compare = CompareTest.create!
+        compare.age = '42'
+        compare.save!
+        expect(compare.saved_change_to_age).to eq [nil, 42]
+    end
+
+    it 'should update changed_attributes after update' do
+        base = BaseTest.create!(name: 'joe')
+        base = BaseTest.find base.id
+        base.name = 'toto'
+        base.save!
+        expect(base.saved_change_to_name?).to be true
+        expect(base.saved_change_to_name).to eq ["joe", "toto"]
+    end
     it "should be comparable to other objects" do
-        base  = BaseTest.create!(name: 'joe')
+        base = BaseTest.create!(name: 'joe')
         base2 = BaseTest.create!(name: 'joe')
         base3 = BaseTest.create!(ActiveSupport::HashWithIndifferentAccess.new(name: 'joe'))
 
@@ -33,14 +84,19 @@ describe CouchbaseOrm::Base do
         base3.delete
     end
 
+    it "should be inspectable" do
+        base = BaseTest.create!(name: 'joe')
+        expect(base.inspect).to eq("#<BaseTest id: \"#{base.id}\", name: \"joe\", job: nil>")
+    end
+
     it "should load database responses" do
         base = BaseTest.create!(name: 'joe')
-        resp = BaseTest.bucket.get(base.id, extended: true)
+        resp = BaseTest.bucket.default_collection.get(base.id)
 
-        expect(resp.key).to eq(base.id)
+        base_loaded = BaseTest.new(resp, id: base.id)
 
-        base_loaded = BaseTest.new(resp)
-        expect(base_loaded).to     eq(base)
+        expect(base_loaded.id).to eq(base.id)
+        expect(base_loaded).to eq(base)
         expect(base_loaded).not_to be(base)
 
         base.destroy
@@ -49,17 +105,44 @@ describe CouchbaseOrm::Base do
     it "should not load objects if there is a type mismatch" do
         base = BaseTest.create!(name: 'joe')
 
-        expect { CompareTest.find_by_id(base.id) }.to raise_error(RuntimeError)
+        expect { CompareTest.find_by_id(base.id) }.to raise_error(CouchbaseOrm::Error::TypeMismatchError)
 
         base.destroy
     end
 
+    it "raises ActiveModel::UnknownAttributeError on loading objects with unexpected properties" do
+        too_much_properties_doc = {
+            type: BaseTest.design_document,
+            name: 'Pierre',
+            job: 'dev',
+            age: '42'
+        }
+        BaseTest.bucket.default_collection.upsert 'doc_1', too_much_properties_doc
+
+        expect { BaseTest.find_by_id('doc_1') }.to raise_error(ActiveModel::UnknownAttributeError)
+
+        BaseTest.bucket.default_collection.remove 'doc_1'
+    end
+
+    it "loads objects even if there is a missing property in doc" do
+        missing_properties_doc = {
+            type: BaseTest.design_document,
+            name: 'Pierre'
+        }
+        BaseTest.bucket.default_collection.upsert 'doc_1', missing_properties_doc
+        base = BaseTest.find('doc_1')
+
+        expect(base.name).to eq('Pierre')
+        expect(base.job).to be_nil
+        base.destroy
+    end
+
     it "should support serialisation" do
         base = BaseTest.create!(name: 'joe')
 
         base_id = base.id
-        expect(base.to_json).to eq({name: 'joe', job: nil, id: base_id}.to_json)
-        expect(base.to_json(only: :name)).to eq({name: 'joe'}.to_json)
+        expect(base.to_json).to eq({ id: base_id, name: 'joe', job: nil }.to_json)
+        expect(base.to_json(only: :name)).to eq({ name: 'joe' }.to_json)
 
         base.destroy
     end
@@ -73,21 +156,27 @@ describe CouchbaseOrm::Base do
             base.name = 'change'
             expect(base.changes.empty?).to be(false)
 
-            base = BaseTest.new({name: 'bob'})
+            # Attributes are set by key
+            base = BaseTest.new
+            base[:name] = 'bob'
+            expect(base.changes.empty?).to be(false)
+
+            # Attributes are set by initializer from hash
+            base = BaseTest.new({ name: 'bob' })
             expect(base.changes.empty?).to be(false)
             expect(base.previous_changes.empty?).to be(true)
 
             # A saved model should have no changes
             base = BaseTest.create!(name: 'joe')
             expect(base.changes.empty?).to be(true)
-            expect(base.previous_changes.empty?).to be(false)
+            expect(base.previous_changes.empty?).to be(true)
 
             # Attributes are copied from the existing model
             base = BaseTest.new(base)
             expect(base.changes.empty?).to be(false)
             expect(base.previous_changes.empty?).to be(true)
         ensure
-            base.destroy if base.id
+            base.destroy if base.persisted?
         end
     end
 
@@ -101,6 +190,85 @@ describe CouchbaseOrm::Base do
         end
     end
 
+    it "should be able to create model with a custom ID" do
+        begin
+            base = BaseTest.create!(id: 'custom_id', name: 'joe')
+            expect(base.id).to eq('custom_id')
+
+            base = BaseTest.find('custom_id')
+            expect(base.id).to eq('custom_id')
+        ensure
+            base&.destroy
+        end
+    end
+
+
+    it "should try to load a model with nothing but single-multiple ID" do
+        begin
+            bases = [BaseTest.create!(name: 'joe')]
+            objs = CouchbaseOrm.try_load(bases.map(&:id))
+            expect(objs).to match_array(bases)
+        ensure
+            bases.each(&:destroy)
+        end
+    end
+
+    it "should try to load a model with nothing but multiple ID" do
+        begin
+            bases = [BaseTest.create!(name: 'joe'), CompareTest.create!(age: 12)]
+            objs = CouchbaseOrm.try_load(bases.map(&:id))
+            expect(objs).to match_array(bases)
+        ensure
+            bases.each(&:destroy)
+        end
+    end
+
+    it "should set the attribute on creation" do
+        base = BaseTest.create!(name: 'joe')
+        expect(base.name).to eq('joe')
+    ensure
+        base.destroy
+    end
+
+    it "should support getting the attribute by key" do
+        base = BaseTest.create!(name: 'joe')
+        expect(base[:name]).to eq('joe')
+    ensure
+        base.destroy
+    end
+
+    it "cannot change the id of a loaded object" do
+        base = BaseTest.create!(name: 'joe')
+        expect(base.id).to_not be_nil
+        expect{base.id = "foo"}.to raise_error(RuntimeError, 'ID cannot be changed')
+    end
+
+    it "should generate a timestamp on creation" do
+        base = TimestampTest.create!
+        expect(base.created_at).to be_a(Time)
+    end
+
+    it "should find multiple ids at same time" do
+        base1 = BaseTest.create!(name: 'joe1')
+        base2 = BaseTest.create!(name: 'joe2')
+        base3 = BaseTest.create!(name: 'joe3')
+        expect(BaseTest.find([base1.id, base2.id, base3.id])).to eq([base1, base2, base3])
+    end
+
+    it "should find multiple ids at same time with a not found id with exception" do
+        base1 = BaseTest.create!(name: 'joe1')
+        base2 = BaseTest.create!(name: 'joe2')
+        base3 = BaseTest.create!(name: 'joe3')
+        expect { BaseTest.find([base1.id, 't', base3.id]) }.to raise_error(Couchbase::Error::DocumentNotFound)
+    end
+
+    it "should find multiple ids at same time with a not found id without exception" do
+        base1 = BaseTest.create!(name: 'joe1')
+        base2 = BaseTest.create!(name: 'joe2')
+        base3 = BaseTest.create!(name: 'joe3')
+        expect(BaseTest.find([base1.id, 't', 't', base2.id, base3.id], quiet: true)).to eq([base1, base2, base3])
+    end
+
     describe BaseTest do
         it_behaves_like "ActiveModel"
     end
@@ -108,4 +276,118 @@ describe CouchbaseOrm::Base do
     describe CompareTest do
         it_behaves_like "ActiveModel"
     end
+
+    it 'does not expose callbacks for nested that wont never be called' do
+        expect{
+            class InvalidNested < CouchbaseOrm::NestedDocument
+                before_save {p "this should raise on loading class"}
+            end
+
+        }.to raise_error NoMethodError
+    end
+
+    it 'should unassign attributes on validation error' do
+        doc = DocInvalidOnUpdate.new(title: 'Test')
+        doc.save
+        expect(doc.title).to eq('Test')
+        expect { doc.update!(title: 'changed wich assignation should not stay after raise') }.to raise_error(CouchbaseOrm::Error::RecordInvalid)
+        expect(doc.title_was).to eq('Test') # raising in master with "changed wich assignation should not stay after raise"
+        expect(doc.title).not_to eq(doc.title_was)
+        expect(doc.title).to eq('changed wich assignation should not stay after raise')
+    end
+
+    describe '.ignored_properties' do
+        it 'returns an array of ignored properties' do
+            expect(BaseTestWithIgnoredProperties.ignored_properties).to eq(['deprecated_property'])
+        end
+
+        context 'given a document with ignored properties' do
+            let(:doc_id) { 'doc_1' }
+            let(:document_properties) do
+                {
+                    'type' => BaseTestWithIgnoredProperties.design_document,
+                    'name' => 'Pierre',
+                    'job' => 'dev',
+                    'deprecated_property' => 'depracted that could be removed on next save'
+                }
+            end
+            let(:loaded_model) { BaseTestWithIgnoredProperties.find(doc_id) }
+
+            before { BaseTestWithIgnoredProperties.bucket.default_collection.upsert doc_id, document_properties }
+            after { BaseTestWithIgnoredProperties.bucket.default_collection.remove doc_id }
+
+            it 'ignores the ignored properties on load from db (and dont raise)' do
+                expect(loaded_model.attributes.keys).not_to include('deprecated_property')
+                expect(loaded_model.name).to eq('Pierre')
+                expect(BaseTestWithIgnoredProperties.bucket.default_collection.get(doc_id).content).to include(document_properties)
+            end
+
+            it 'delete the ignored properties on save' do
+                loaded_model.name = 'Updated Name'
+                expect{ loaded_model.save }.to change { BaseTestWithIgnoredProperties.bucket.default_collection.get(doc_id).content.keys.sort }.
+                    from(%w[deprecated_property job name type]).
+                    to(%w[job name type])
+            end
+
+            it 'does not raise for reload' do
+                expect{ loaded_model.reload }.not_to raise_error
+            end
+        end
+    end
+
+    describe '.properties_always_exists_in_document' do
+        it 'Uses NOT VALUED when properties_always_exists_in_document = false' do
+            where_clause = BaseTest.where(name: nil)
+            expect(where_clause.to_n1ql).to include("AND name IS NOT VALUED")
+        end
+
+        it 'Uses VALUED when properties_always_exists_in_document = false' do
+            where_clause = BaseTest.where.not(name: nil)
+            expect(where_clause.to_n1ql).to include("AND name IS VALUED")
+        end
+
+        it 'Uses IS NULL when properties_always_exists_in_document = true' do
+            where_clause = BaseTestWithPropertiesAlwaysExistsInDocument.where(name: nil)
+            expect(where_clause.to_n1ql).to include("AND name IS NULL")
+        end
+
+        it 'Uses IS NOT NULL when properties_always_exists_in_document = true' do
+            where_clause = BaseTestWithPropertiesAlwaysExistsInDocument.where.not(name: nil)
+            expect(where_clause.to_n1ql).to include("AND name IS NOT NULL")
+        end
+    end
+
+    describe 'With a range in the where clause' do
+        before do
+            BaseTestWithTimeframe.delete_all
+            BaseTestWithTimeframe.create!(name: 'january', start_date: DateTime.new(2020, 1, 1, 10, 0, 0), age: 10)
+            BaseTestWithTimeframe.create!(name: 'midjanuary', start_date: DateTime.new(2020, 1, 15,11, 0, 0), age: 15)
+            BaseTestWithTimeframe.create!(name: 'february', start_date: DateTime.new(2020, 2, 1,15, 0, 0), age: 20)
+        end
+
+        it 'manages the datetime range correctly' do
+            result = BaseTestWithTimeframe.where(start_date: DateTime.new(2020, 1, 1, 11, 0,0)..DateTime.new(2020, 1, 31)).pluck(:name)
+            expect(result).to eq(%w[midjanuary])
+        end
+
+        it 'manages the date range correctly' do
+            result = BaseTestWithTimeframe.where(start_date: Date.new(2020, 1, 1)..Date.new(2020, 1, 31)).pluck(:name)
+            expect(result).to eq(%w[january midjanuary])
+        end
+
+        it 'manages the time range correctly' do
+            result = BaseTestWithTimeframe.where(start_date: Time.new(2020, 1, 1, 14, 35, 0)..Time.new(2020, 1, 31, 16, 35, 0)).pluck(:name)
+            expect(result).to eq(%w[midjanuary])
+        end
+
+        it 'manages the integer range correctly' do
+            result = BaseTestWithTimeframe.where(age: 12..25).pluck(:name)
+            expect(result).to eq(%w[midjanuary february])
+        end
+
+        it 'manages the exclude end correctly' do
+            result = BaseTestWithTimeframe.where(age: 10...15).pluck(:name)
+            expect(result).to eq(%w[january])
+        end
+    end
 end

data/spec/collection_proxy_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path("../support", __FILE__)
+require File.expand_path("../../lib/couchbase-orm/proxies/collection_proxy", __FILE__)
+
+class Proxyfied
+    def get(key, options = nil)
+       raise Couchbase::Error::DocumentNotFound
+    end
+    def remove(key, options = nil)
+        raise Couchbase::Error::DocumentNotFound
+    end
+end
+
+describe CouchbaseOrm::CollectionProxy do
+    it "should raise an error when get is called with bang version" do
+        expect { CouchbaseOrm::CollectionProxy.new(Proxyfied.new).get!('key') }.to raise_error(Couchbase::Error::DocumentNotFound)
+    end
+
+    it "should not raise an error when get is called with non bang version" do
+        expect { CouchbaseOrm::CollectionProxy.new(Proxyfied.new).get('key') }.to_not raise_error
+    end
+
+    it "should raise an error when remove is called with bang version" do
+        expect { CouchbaseOrm::CollectionProxy.new(Proxyfied.new).remove!('key') }.to raise_error(Couchbase::Error::DocumentNotFound)
+    end
+
+    it "should not raise an error when remove is called with non bang version" do
+        expect { CouchbaseOrm::CollectionProxy.new(Proxyfied.new).remove('key') }.to_not raise_error
+    end
+end

data/spec/connection_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require File.expand_path("../support", __FILE__)
+
+class ConnectedModel < CouchbaseOrm::Base
+  attribute :name, :string
+end
+
+# disabled by default because a little hacky
+# and test couchbase ruby client not couchbase orm
+
+return unless ENV["TEST_DOCKER_CONTAINER"]
+
+describe CouchbaseOrm::Base do
+    it "should reconnect after a disconnection" do
+      s = ConnectedModel.create!(name: "foo")
+      `docker stop #{ENV["TEST_DOCKER_CONTAINER"]}`
+      sleep 3
+      expect {ConnectedModel.find(s.id)}.to raise_error(Couchbase::Error::UnambiguousTimeout)
+      `docker start #{ENV["TEST_DOCKER_CONTAINER"]}`
+      sleep 10
+      s2 = ConnectedModel.find(s.id)
+      expect(s2.name).to eq (s.name)
+    ensure
+      `docker start #{ENV["TEST_DOCKER_CONTAINER"]}`
+    end
+end

data/spec/couchbase-orm/active_record_compat_spec.rb

@@ -0,0 +1,24 @@
+require './lib/couchbase-orm/active_record_compat'
+
+class Foo
+  include CouchbaseOrm::ActiveRecordCompat
+
+  def compute_age
+    10 + 32
+  end
+end
+
+describe CouchbaseOrm::ActiveRecordCompat do
+  let(:foo) { Foo.new }
+  describe '#slice' do
+    it 'creates a hash with method names as keys and results as values' do
+      expect(foo.slice(:compute_age).to_h).to eq(HashWithIndifferentAccess.new({ compute_age: 42 }))
+    end
+  end
+
+  describe '#values_at' do
+    it 'creates an array of results from given method names' do
+      expect(foo.values_at([:compute_age])).to eq([42])
+    end
+  end
+end

data/spec/couchbase-orm/changeable_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'couchbase-orm'
+
+class Doc < CouchbaseOrm::Base
+  attribute :title
+end
+
+describe 'CouchbaseOrm::Changeable' do
+  it 'should have empty changes after loading a record from db' do
+    doc = Doc.create(title: 'Test')
+    expect(doc.changes).to be_empty
+    doc = Doc.find(doc.id)
+    expect(doc.changes).to be_empty
+  end
+end

data/spec/couchbase-orm/json_schema/validation_spec.rb

@@ -0,0 +1,23 @@
+require 'couchbase-orm/json_schema/validation'
+
+class DummyClass
+  extend CouchbaseOrm::JsonSchema::Validation
+  validate_json_schema
+end
+
+class DummyClass2
+  extend CouchbaseOrm::JsonSchema::Validation
+end
+
+RSpec.describe CouchbaseOrm::JsonSchema::Validation do
+  describe '#validate_json_schema' do
+    it 'sets @validate_json_schema to true' do
+      expect(DummyClass.json_validation_config[:enabled]).to be_truthy
+    end
+
+    it 'does not mixup @validate_json_schema between classes' do
+      expect(DummyClass.json_validation_config[:enabled]).to be_truthy
+      expect(DummyClass2.json_validation_config[:enabled]).to be_falsey
+    end
+  end
+end

data/spec/couchbase-orm/json_schema/validator_spec.rb

@@ -0,0 +1,13 @@
+require 'couchbase-orm/json_schema/validator'
+
+RSpec.describe CouchbaseOrm::JsonSchema::Validator do
+  describe '#validate_entity' do
+    context 'when mode is set to an unknown value' do
+      let(:json_validation_config) { { mode: :unknown } }
+      let(:validator) { CouchbaseOrm::JsonSchema::Validator.new(json_validation_config) }
+      it 'raises an error' do
+        expect { validator.validate_entity({}, '') }.to raise_error('Unknown validation mode unknown')
+      end
+    end
+  end
+end

data/spec/couchbase-orm/timestamps_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+require 'couchbase-orm'
+require 'couchbase-orm/timestamps_spec_models'
+
+describe CouchbaseOrm::Timestamps do
+  context 'simple document' do
+    describe 'without any related attributes' do
+      let(:doc) { DocWithoutTimestamps.new }
+      it 'does not run timestamp callbacks on create' do
+        expect(doc).not_to receive(:updated_at=)
+        expect(doc).not_to receive(:created_at=)
+        doc.save
+      end
+      it 'does not run timestamp callbacks on update' do
+        doc.save
+        expect(doc).not_to receive(:updated_at=)
+        expect(doc).not_to receive(:created_at=)
+        doc.title = 'New title'
+        doc.save
+      end
+    end
+
+    describe 'with only created_at attribute' do
+      let(:doc) { DocWithCreatedAt.new }
+      it 'runs created_at timestamp callback on create' do
+        expect(doc).to receive(:created_at=)
+        expect(doc).not_to receive(:updated_at=)
+        doc.save
+      end
+      it 'does not run timestamp callback on update' do
+        doc.save
+        expect(doc).not_to receive(:created_at=)
+        expect(doc).not_to receive(:updated_at=)
+        doc.title = 'New title'
+        doc.save
+      end
+    end
+
+    describe 'with only updated_at attribute' do
+      let(:doc) { DocWithUpdatedAt.new }
+      it 'does run timestamp callback on create only for updated_at' do
+        expect(doc).not_to receive(:created_at=)
+        expect(doc).to receive(:updated_at=)
+        doc.save
+      end
+      it 'runs updated_at timestamp callback on update' do
+        doc.save
+        expect(doc).to receive(:updated_at=)
+        expect(doc).not_to receive(:created_at=)
+        doc.title = 'New title'
+        doc.save
+      end
+    end
+
+    describe 'with both created_at and updated_at attributes' do
+      let(:doc) { DocWithBothTimestampsAttributes.new }
+      it 'runs created_at timestamp callback on create' do
+        expect(doc).to receive(:created_at=)
+        expect(doc).to receive(:updated_at=)
+        doc.save
+      end
+      it 'runs updated_at timestamp callback on update' do
+        doc.save
+        expect(doc).to receive(:updated_at=)
+        doc.title = 'New title'
+        doc.save
+      end
+    end
+  end
+
+  context 'with nested documents' do
+    let(:nested_doc) { SimpleNestedDoc.new }
+    describe 'when parent document has both timestamp attributes' do
+      let(:doc) { DocWithBothTimestampsAttributesAndNested.new }
+      # nested document is not saved, so it does not have created_at
+      it 'runs created_at timestamp callback on create only for parent document' do
+        expect(doc).to receive(:created_at=)
+        expect(doc).to receive(:updated_at=)
+        doc.sub = nested_doc
+        expect(nested_doc).not_to receive(:created_at=)
+        doc.save
+      end
+    end
+  end
+end

data/spec/couchbase-orm/timestamps_spec_models.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+require 'couchbase-orm/base'
+
+class DocWithoutTimestamps < CouchbaseOrm::Base
+  attribute :title
+end
+
+class DocWithCreatedAt < CouchbaseOrm::Base
+  attribute :title
+  attribute :created_at, :datetime
+end
+
+class DocWithUpdatedAt < CouchbaseOrm::Base
+  attribute :title
+  attribute :updated_at, :datetime
+end
+
+class DocWithBothTimestampsAttributes < CouchbaseOrm::Base
+  attribute :title
+  attribute :created_at, :datetime
+  attribute :updated_at, :datetime
+end
+
+class SimpleNestedDoc < CouchbaseOrm::NestedDocument
+  attribute :sub_title
+  attribute :created_at, :datetime
+  attribute :updated_at, :datetime
+end
+
+class DocWithBothTimestampsAttributesAndNested < CouchbaseOrm::Base
+  attribute :title
+  attribute :created_at, :datetime
+  attribute :updated_at, :datetime
+  attribute :sub, :nested, type: SimpleNestedDoc
+  attribute :subs, :array, type: SimpleNestedDoc
+end

data/spec/enum_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require File.expand_path("../support", __FILE__)
+
+class EnumTest < CouchbaseOrm::Base
+    enum rating: [:awesome, :good, :okay, :bad], default: :okay
+    enum color: [:red, :green, :blue]
+end
+
+describe CouchbaseOrm::Base do
+    it "should create an attribute" do
+        base  = EnumTest.create!(rating: :good, color: :red)
+        expect(base.attribute_names).to eq(["id", "rating", "color"])
+    end
+
+    it "should set the attribute" do
+        base  = EnumTest.create!(rating: :good, color: :red)
+        expect(base.rating).to_not be_nil
+        expect(base.color).to_not be_nil
+    end
+
+    it "should convert it to an int" do
+        base  = EnumTest.create!(rating: :good, color: :red)
+        expect(base.rating).to eq 2
+        expect(base.color).to eq 1
+    end
+
+    it "should use default value" do
+        base  = EnumTest.create!
+        expect(base.rating).to eq 3
+        expect(base.color).to eq 1
+    end
+end
+