couchbase-orm 3.1.0 → 3.3.0

data/spec/base_spec.rb

@@ -22,6 +22,33 @@ class BaseTestWithIgnoredProperties < CouchbaseOrm::Base
     attribute :job, :string
 end
 
+class BaseTestWithUnknownAttributesAllowed < CouchbaseOrm::Base
+    self.raise_on_unknown_attributes = false
+    attribute :name, :string
+    attribute :job, :string
+end
+
+class NestedDocWithUnknownAttributesAllowed < CouchbaseOrm::NestedDocument
+    self.raise_on_unknown_attributes = false
+    attribute :title, :string
+    attribute :value, :integer
+end
+
+class NestedDocWithDefaultBehavior < CouchbaseOrm::NestedDocument
+    attribute :title, :string
+    attribute :value, :integer
+end
+
+class ParentDocWithNestedUnknownAllowed < CouchbaseOrm::Base
+    attribute :name, :string
+    attribute :nested_item, :nested, type: NestedDocWithUnknownAttributesAllowed
+end
+
+class ParentDocWithNestedDefault < CouchbaseOrm::Base
+    attribute :name, :string
+    attribute :nested_item, :nested, type: NestedDocWithDefaultBehavior
+end
+
 class BaseTestWithPropertiesAlwaysExistsInDocument < CouchbaseOrm::Base
     self.properties_always_exists_in_document = true
     attribute :name, :string
@@ -349,6 +376,116 @@ describe CouchbaseOrm::Base do
         end
     end
 
+    describe 'handling unknown attributes' do
+        context 'when raise_on_unknown_attributes is set to false' do
+            it 'returns false when queried' do
+                expect(BaseTestWithUnknownAttributesAllowed.raise_on_unknown_attributes).to be(false)
+            end
+
+            it 'silently ignores unknown attributes in new' do
+                model = BaseTestWithUnknownAttributesAllowed.new(name: 'test', job: 'dev', unknown_attr: 'value')
+                expect(model.name).to eq('test')
+                expect(model.job).to eq('dev')
+                expect(model.respond_to?(:unknown_attr)).to be(false)
+            end
+
+            it 'silently ignores unknown attributes in assign_attributes' do
+                model = BaseTestWithUnknownAttributesAllowed.new(name: 'test')
+                expect {
+                    model.assign_attributes(name: 'updated', job: 'engineer', foo: 'bar', baz: 'qux')
+                }.not_to raise_error
+                expect(model.name).to eq('updated')
+                expect(model.job).to eq('engineer')
+                expect(model.respond_to?(:foo)).to be(false)
+                expect(model.respond_to?(:baz)).to be(false)
+            end
+
+            it 'only stores known attributes' do
+                model = BaseTestWithUnknownAttributesAllowed.new(
+                    name: 'Alice',
+                    job: 'Developer',
+                    unknown_field_1: 'value1',
+                    unknown_field_2: 'value2'
+                )
+                # Only known attributes should be stored
+                expect(model.name).to eq('Alice')
+                expect(model.job).to eq('Developer')
+                expect(model.respond_to?(:unknown_field_1)).to be(false)
+                expect(model.respond_to?(:unknown_field_2)).to be(false)
+            end
+        end
+
+        context 'default behavior (raise_on_unknown_attributes = true)' do
+            it 'returns true by default' do
+                expect(BaseTest.raise_on_unknown_attributes).to be(true)
+            end
+
+            it 'raises ActiveModel::UnknownAttributeError on unknown attributes in new' do
+                expect {
+                    BaseTest.new(name: 'bob', job: 'dev', foo: 'bar')
+                }.to raise_error(ActiveModel::UnknownAttributeError)
+            end
+
+            it 'raises ActiveModel::UnknownAttributeError on unknown attributes in assign_attributes' do
+                model = BaseTest.new(name: 'bob')
+                expect {
+                    model.assign_attributes(job: 'dev', foo: 'bar')
+                }.to raise_error(ActiveModel::UnknownAttributeError)
+            end
+        end
+
+        context 'for NestedDocument classes' do
+            it 'returns false when queried on NestedDocument with raise_on_unknown_attributes = false' do
+                expect(NestedDocWithUnknownAttributesAllowed.raise_on_unknown_attributes).to be(false)
+            end
+
+            it 'returns true by default on NestedDocument' do
+                expect(NestedDocWithDefaultBehavior.raise_on_unknown_attributes).to be(true)
+            end
+
+            it 'silently ignores unknown attributes in NestedDocument when disabled' do
+                nested = NestedDocWithUnknownAttributesAllowed.new(title: 'Test', value: 42, unknown: 'ignored')
+                expect(nested.title).to eq('Test')
+                expect(nested.value).to eq(42)
+                expect(nested.respond_to?(:unknown)).to be(false)
+            end
+
+            it 'raises error for unknown attributes in NestedDocument when enabled' do
+                expect {
+                    NestedDocWithDefaultBehavior.new(title: 'Test', value: 42, unknown: 'error')
+                }.to raise_error(ActiveModel::UnknownAttributeError)
+            end
+
+            it 'silently ignores unknown attributes in nested documents within parent' do
+                parent = ParentDocWithNestedUnknownAllowed.new(name: 'Parent')
+                nested = NestedDocWithUnknownAttributesAllowed.new(title: 'Nested', value: 100, extra: 'ignored')
+                parent.nested_item = nested
+
+                expect(parent.nested_item.title).to eq('Nested')
+                expect(parent.nested_item.value).to eq(100)
+                expect(parent.nested_item.respond_to?(:extra)).to be(false)
+            end
+
+            it 'raises error for unknown attributes in nested documents with default behavior' do
+                parent = ParentDocWithNestedDefault.new(name: 'Parent')
+                expect {
+                    NestedDocWithDefaultBehavior.new(title: 'Nested', value: 100, extra: 'error')
+                }.to raise_error(ActiveModel::UnknownAttributeError)
+            end
+
+            it 'works with assign_attributes on NestedDocument' do
+                nested = NestedDocWithUnknownAttributesAllowed.new(title: 'Initial')
+                expect {
+                    nested.assign_attributes(title: 'Updated', value: 50, unknown_field: 'ignored')
+                }.not_to raise_error
+
+                expect(nested.title).to eq('Updated')
+                expect(nested.value).to eq(50)
+                expect(nested.respond_to?(:unknown_field)).to be(false)
+            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)

data/spec/couchbase-orm/active_record_compat_spec.rb

@@ -3,6 +3,18 @@ require './lib/couchbase-orm/active_record_compat'
 class Foo
   include CouchbaseOrm::ActiveRecordCompat
 
+  def self.attribute_names
+    %w[id compute_age]
+  end
+
+  def self.attribute_types
+    { 'id' => :string }
+  end
+
+  def attribute_names
+    self.class.attribute_names
+  end
+
   def compute_age
     10 + 32
   end
@@ -21,4 +33,65 @@ describe CouchbaseOrm::ActiveRecordCompat do
       expect(foo.values_at([:compute_age])).to eq([42])
     end
   end
+
+  describe '.primary_key' do
+    it 'is always "id"' do
+      expect(Foo.primary_key).to eq('id')
+    end
+  end
+
+  describe '.base_class?' do
+    it 'is always true' do
+      expect(Foo.base_class?).to be true
+    end
+  end
+
+  describe '.column_names' do
+    it 'delegates to .attribute_names' do
+      expect(Foo.column_names).to eq(%w[id compute_age])
+    end
+  end
+
+  describe '.abstract_class?' do
+    it 'is always false' do
+      expect(Foo.abstract_class?).to be false
+    end
+  end
+
+  describe '.connected?' do
+    it 'is always true' do
+      expect(Foo.connected?).to be true
+    end
+  end
+
+  describe '.table_exists?' do
+    it 'is always true' do
+      expect(Foo.table_exists?).to be true
+    end
+  end
+
+  describe '._reflect_on_association' do
+    it 'is always false' do
+      expect(Foo._reflect_on_association(:anything)).to be false
+    end
+  end
+
+  describe '.type_for_attribute' do
+    it 'delegates to .attribute_types' do
+      expect(Foo.type_for_attribute('id')).to eq(:string)
+    end
+  end
+
+  describe '#_has_attribute?' do
+    it 'checks membership in #attribute_names' do
+      expect(foo._has_attribute?(:compute_age)).to be true
+      expect(foo._has_attribute?(:unknown)).to be false
+    end
+  end
+
+  describe '#attribute_for_inspect' do
+    it 'inspects the value returned by the named method' do
+      expect(foo.attribute_for_inspect(:compute_age)).to eq('42')
+    end
+  end
 end

data/spec/couchbase-orm/changeable_spec.rb

@@ -13,4 +13,41 @@ describe 'CouchbaseOrm::Changeable' do
     doc = Doc.find(doc.id)
     expect(doc.changes).to be_empty
   end
+
+  describe 'per-attribute dirty methods generated by create_dirty_methods' do
+    # `changes_applied` runs the same in-memory bookkeeping create/update
+    # triggers after a save (no DB round trip needed to exercise it).
+    let(:doc) do
+      Doc.new(title: 'initial').tap do |d|
+        d.title = 'Test'
+        d.changes_applied
+      end
+    end
+
+    it 'exposes the change made in the last save' do
+      expect(doc.changed?).to be false # cleared by changes_applied
+      expect(doc.title_change).to be_nil # no change pending right now
+      expect(doc.will_save_change_to_title?).to be false
+      expect(doc.title_previously_was).to eq('initial')
+      expect(doc.title_before_last_save).to be_nil # only set by a real save, not by changes_applied alone
+      expect(doc.title_previously_changed?).to be true
+      expect(doc.title_previous_change).to eq(['initial', 'Test'])
+    end
+
+    it 'exposes the change during the save that triggered it, with an explicit from/to' do
+      expect(doc.saved_change_to_title?(from: 'initial')).to be true
+      expect(doc.saved_change_to_title?(to: 'Test')).to be true
+      expect(doc.saved_change_to_title?(from: 'initial', to: 'Test')).to be true
+      expect(doc.saved_change_to_title?(from: 'nope')).to be false
+    end
+
+    it 'can flag an attribute as about to change, and reset it back' do
+      expect { doc.title_will_change! }.not_to raise_error
+      expect { doc.reset_title! }.not_to raise_error
+    end
+
+    it 'falls back to nil for an attribute that was never saved' do
+      expect(Doc.new.title_previously_was).to be_nil
+    end
+  end
 end

data/spec/n1ql_spec.rb

@@ -196,6 +196,25 @@ describe CouchbaseOrm::N1ql do
         end
     end
 
+    it "should use adhoc: true by default (no prepared statement plan caching)" do
+        expect(Couchbase::Options::Query).to receive(:new).with(hash_including(adhoc: true)).and_call_original
+        N1QLTest.by_rating_reverse()
+    end
+
+    it "should allow overriding adhoc per call to enable plan caching" do
+        expect(Couchbase::Options::Query).to receive(:new).with(hash_including(adhoc: false)).and_call_original
+        N1QLTest.by_rating_reverse(adhoc: false)
+    end
+
+    it "should respect N1ql.config adhoc setting" do
+        default_config = CouchbaseOrm::N1ql.config
+        CouchbaseOrm::N1ql.config({ adhoc: false })
+        expect(Couchbase::Options::Query).to receive(:new).with(hash_including(adhoc: false)).and_call_original
+        N1QLTest.by_rating_reverse()
+    ensure
+        CouchbaseOrm::N1ql.config(default_config)
+    end
+
     after(:all) do
         N1QLTest.delete_all
     end

data/spec/proxies/bucket_proxy_spec.rb

@@ -0,0 +1,53 @@
+require 'couchbase-orm/proxies/bucket_proxy'
+require 'couchbase-orm/proxies/n1ql_proxy'
+require 'couchbase-orm/proxies/results_proxy'
+
+RSpec.describe CouchbaseOrm::BucketProxy do
+    let(:proxyfied) { double('bucket') }
+
+    it 'raises when asked to proxy nil' do
+        expect { CouchbaseOrm::BucketProxy.new(nil) }.to raise_error(ArgumentError)
+    end
+
+    it 'delegates unknown methods to the proxyfied object' do
+        allow(proxyfied).to receive(:name).and_return('my_bucket')
+        expect(CouchbaseOrm::BucketProxy.new(proxyfied).name).to eq('my_bucket')
+    end
+
+    it 'delegates unknown methods with args, kwargs and a block' do
+        allow(proxyfied).to receive(:default_collection).with('a', b: 1).and_yield(:yielded)
+        CouchbaseOrm::BucketProxy.new(proxyfied).default_collection('a', b: 1) do |arg|
+            expect(arg).to eq(:yielded)
+        end
+    end
+
+    it 'wraps #n1ql in a N1qlProxy' do
+        allow(proxyfied).to receive(:n1ql).and_return(:the_n1ql)
+        expect(CouchbaseOrm::BucketProxy.new(proxyfied).n1ql).to be_a(CouchbaseOrm::N1qlProxy)
+    end
+
+    describe '#view' do
+        it 'wraps the result in a ResultsProxy and caches it for the same design/view' do
+            allow(proxyfied).to receive(:view).with('design', 'view').and_return([:row1, :row2])
+            proxy = CouchbaseOrm::BucketProxy.new(proxyfied)
+
+            first = proxy.view('design', 'view')
+            second = proxy.view('design', 'view')
+
+            expect(first).to be_a(CouchbaseOrm::ResultsProxy)
+            expect(second).to be(first)
+            expect(proxyfied).to have_received(:view).once
+        end
+
+        it 'requeries when the design/view pair changes' do
+            allow(proxyfied).to receive(:view).with('design', 'view').and_return([:row1])
+            allow(proxyfied).to receive(:view).with('design', 'other').and_return([:row2])
+            proxy = CouchbaseOrm::BucketProxy.new(proxyfied)
+
+            proxy.view('design', 'view')
+            proxy.view('design', 'other')
+
+            expect(proxyfied).to have_received(:view).twice
+        end
+    end
+end

data/spec/relation_spec.rb

@@ -501,5 +501,38 @@ describe CouchbaseOrm::Relation do
             end
         end
     end
+
+    it "should use adhoc: true by default (no prepared statement plan caching)" do
+        expect(Couchbase::Options::Query).to receive(:new).with(hash_including(adhoc: true)).and_call_original
+        RelationModel.where(active: true).ids
+    end
+
+    describe "adhoc option via with" do
+        it "should return a relation when calling with(adhoc:)" do
+            expect(RelationModel.all.with(adhoc: false)).to be_a(CouchbaseOrm::Relation::CouchbaseOrm_Relation)
+        end
+
+        it "should pass adhoc: false to query options when set on the relation" do
+            expect(Couchbase::Options::Query).to receive(:new).with(hash_including(adhoc: false)).and_call_original
+            RelationModel.where(active: true).with(adhoc: false).ids
+        end
+
+        it "should override N1ql.config adhoc when set on the relation" do
+            default_config = CouchbaseOrm::N1ql.config
+            CouchbaseOrm::N1ql.config(adhoc: false)
+            expect(Couchbase::Options::Query).to receive(:new).with(hash_including(adhoc: true)).and_call_original
+            RelationModel.where(active: true).with(adhoc: true).ids
+        ensure
+            CouchbaseOrm::N1ql.config(default_config)
+        end
+
+        it "should be chainable with other relation methods" do
+            m1 = RelationModel.create!(active: true, age: 10)
+            _m2 = RelationModel.create!(active: false, age: 20)
+            expect(Couchbase::Options::Query).to receive(:new).with(hash_including(adhoc: false)).and_call_original
+            result = RelationModel.where(active: true).order(:age).with(adhoc: false).to_a
+            expect(result).to match_array([m1])
+        end
+    end
 end
 

data/spec/type_encrypted_spec.rb

@@ -25,6 +25,16 @@ describe CouchbaseOrm::Types::Encrypted do
     let(:the_secret) { "\x17`\x1F\xEE\el\xE0\x9F<\x94\xFE\x8A.\x1A\x92\xB9\xC3@\x86\x9Cp\xBEl\x86\x0E\x8CJ\tB\x97*U)\x96\x06\xA3\xE9\x84\xA6xW%\xDCT\x8C^\xEA\t\xC7\xD8\xFC\xF1\xD3\xD3\xE2\xEA\x89\xCBuUs\xB3\xFF'W>\xDE\x9CP\xA9\xDE%\xA2\xDE\x11\xFD\b\x9C\xD4\x87J,\x91\x02f\x16R\xDE\x908\x05\x1C\xF9\xDF{\x0F\xB3e\xB2\xB2\x96\xD7\xCC\x16As\xD3I\x02w\xE0\x8FL\xC6S\xEFP\xAC\x15\e^\xC4!\x15\"KF1\x17\x06\xA0N\x00\x18\xBA\x87\xEA?H\xD4<\xB5\xBCV\xB50\fc\xC9F\"\xF0B\eg%\x8E\x88\xD0\x9Bc\xE4\x93\t\x98\xC8\x87\xCB4]\xD9K\xA3\xDF\x13Q\xC0T\xCA\x91;\b\x9Cp\xE0\x7FR h\xDA\xB7\xD5\x869\f\xCA\x80\x802\x19\x19\xDD\x9DO\xAE}\xCA\eX\xA3\xA8\xBE\xE1\xBCW0g\x19@5n\r\xD8\xF3\x05\x7F4\x9CI\x1F3\xC0\xBDQJyG\v\xED!s\xD5\xD0&\xC1\x1A\xBC\x17\xFD\x9Cd\xB5\xAF\xB6U\x8A" }
     let(:base64_secret) { Base64.strict_encode64(the_secret) }
 
+    describe "#serialize" do
+        it "returns nil for a nil value" do
+            expect(CouchbaseOrm::Types::Encrypted.new.serialize(nil)).to be_nil
+        end
+
+        it "returns the value unchanged otherwise (wrapping happens in Encrypt#encode_encrypted_attributes)" do
+            expect(CouchbaseOrm::Types::Encrypted.new.serialize(base64_secret)).to eq(base64_secret)
+        end
+    end
+
     it "prefix attribute on serialization" do
         obj = TypeEncryptedTest.new(secret: base64_secret, secret2: "a secret")
         expect_serialized_secret(obj)
@@ -50,6 +60,16 @@ describe CouchbaseOrm::Types::Encrypted do
         expect(obj.as_json["secret2"]).to eq "a secret"
     end
 
+    it "raises when serializing a non-String value for an encrypted attribute" do
+        obj = TypeEncryptedTest.new(secret: 12345)
+        expect { obj.send(:serialized_attributes) }.to raise_error(/Can not serialize value/)
+    end
+
+    it "raises from #as_json when a non-String value is held by an encrypted attribute" do
+        obj = TypeEncryptedTest.new(secret: 12345)
+        expect { obj.as_json }.to raise_error(/Can not serialize value/)
+    end
+
     it "prefix with custom algo" do
         obj = SpecificAlgoTest.new(secret: base64_secret)
         expect(obj.send(:serialized_attributes)["encrypted$secret"]).to eq({alg:"3DES", ciphertext: base64_secret})

data/spec/type_nested_spec.rb

@@ -18,6 +18,18 @@ class TypeNestedTest < CouchbaseOrm::Base
 end
 
 describe CouchbaseOrm::Types::Nested do
+    describe "#serialize" do
+        it "builds an instance from a raw Hash before serializing it, filtering ignored properties" do
+            # `serialize` is normally called with an already-built NestedDocument
+            # instance (see the specs below); this exercises its Hash branch
+            # directly, using string keys to match the shape a real document
+            # (and thus `ignored_properties`, which stores string names) has.
+            type = CouchbaseOrm::Types::Nested.new(type: SubTypeWithIgnoredProperties)
+            serialized = type.serialize("name" => "Nested", "value" => "Valid", "deprecated_property" => "should be dropped")
+            expect(serialized).to eq("name" => "Nested", "value" => "Valid")
+        end
+    end
+
     it "should be able to store and retrieve a nested object" do
         obj = TypeNestedTest.new
         obj.main = SubTypeTest.new
@@ -255,4 +267,84 @@ describe CouchbaseOrm::Types::Nested do
             expect(parent.nested.value).to eq("Parent Value")
         end
     end
+
+    describe "raise_on_unknown_attributes" do
+        class SubTypeWithUnknownAttributesAllowed < CouchbaseOrm::NestedDocument
+            self.raise_on_unknown_attributes = false
+            attribute :label, :string
+        end
+
+        class SubTypeWithDefaultUnknownAttributes < CouchbaseOrm::NestedDocument
+            attribute :label, :string
+        end
+
+        class ParentWithNestedUnknownAttributesAllowed < CouchbaseOrm::Base
+            self.raise_on_unknown_attributes = false
+            attribute :title, :string
+            attribute :main, :nested, type: SubTypeWithUnknownAttributesAllowed
+            attribute :others, :array, type: SubTypeWithUnknownAttributesAllowed
+        end
+
+        class ParentWithStrictNestedUnknownAttributes < CouchbaseOrm::Base
+            self.raise_on_unknown_attributes = false
+            attribute :title, :string
+            attribute :main, :nested, type: SubTypeWithDefaultUnknownAttributes
+        end
+
+        it "tolerates an unknown key in a nested document assigned as a Hash, via Types::Nested#cast" do
+            # This is the path the actual document-loading code takes; assigning an
+            # already-built NestedDocument *instance* (as opposed to a Hash) never
+            # reaches Types::Nested#cast at all.
+            parent = ParentWithNestedUnknownAttributesAllowed.new(title: "Parent")
+            parent.main = SubTypeWithUnknownAttributesAllowed.new(label: "Main")
+            parent.save!
+
+            doc_id = parent.id
+            raw_doc = ParentWithNestedUnknownAttributesAllowed.bucket.default_collection.get(doc_id).content
+            raw_doc["main"]["legacy"] = "should be ignored"
+            ParentWithNestedUnknownAttributesAllowed.bucket.default_collection.replace(doc_id, raw_doc)
+
+            parent.reload
+            expect(parent.main.label).to eq("Main")
+            expect(parent.main.attributes.keys).not_to include("legacy")
+
+            # Same assertion via `find` - a different code path (the GetResult
+            # branch of Document#initialize) than `reload`.
+            reloaded = ParentWithNestedUnknownAttributesAllowed.find(doc_id)
+            expect(reloaded.main.label).to eq("Main")
+            expect(reloaded.main.attributes.keys).not_to include("legacy")
+        end
+
+        it "tolerates an unknown key in a nested document inside a Types::Array, assigned as Hashes" do
+            parent = ParentWithNestedUnknownAttributesAllowed.new(title: "Parent")
+            parent.others = [
+                SubTypeWithUnknownAttributesAllowed.new(label: "First"),
+                SubTypeWithUnknownAttributesAllowed.new(label: "Second")
+            ]
+            parent.save!
+
+            doc_id = parent.id
+            raw_doc = ParentWithNestedUnknownAttributesAllowed.bucket.default_collection.get(doc_id).content
+            raw_doc["others"][0]["legacy"] = "should be ignored"
+            ParentWithNestedUnknownAttributesAllowed.bucket.default_collection.replace(doc_id, raw_doc)
+
+            parent.reload
+            expect(parent.others.map(&:label)).to eq(["First", "Second"])
+            expect(parent.others[0].attributes.keys).not_to include("legacy")
+            expect(parent.others[1].attributes.keys).not_to include("legacy")
+        end
+
+        it "is per nested class: a tolerant parent does not make a strict nested document tolerant" do
+            parent = ParentWithStrictNestedUnknownAttributes.new(title: "Parent")
+            parent.main = SubTypeWithDefaultUnknownAttributes.new(label: "Main")
+            parent.save!
+
+            doc_id = parent.id
+            raw_doc = ParentWithStrictNestedUnknownAttributes.bucket.default_collection.get(doc_id).content
+            raw_doc["main"]["legacy"] = "should raise"
+            ParentWithStrictNestedUnknownAttributes.bucket.default_collection.replace(doc_id, raw_doc)
+
+            expect { parent.reload }.to raise_error(ActiveModel::UnknownAttributeError)
+        end
+    end
 end