couchbase-orm 1.1.1 → 2.0.0

data/lib/ext/query_n1ql.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+module MTLibcouchbase
+    class QueryN1QL
+        N1P_QUERY_STATEMENT = 1
+        N1P_CONSISTENCY_REQUEST = 2
+
+        def initialize(connection, reactor, n1ql, **_opts)
+            @connection = connection
+            @reactor = reactor
+
+            @n1ql = n1ql
+            @request_handle = FFI::MemoryPointer.new :pointer, 1
+        end
+
+        attr_reader :connection, :n1ql
+
+        def get_count(metadata)
+            metadata[:metrics][:resultCount]
+        end
+
+        def perform(limit: nil, **_options, &blk)
+            raise 'not connected' unless @connection.handle
+            raise 'query already in progress' if @query_text
+            raise 'callback required' unless block_given?
+
+            # customise the size based on the request being made
+            orig_limit = @n1ql.limit
+            begin
+                if orig_limit && limit
+                    @n1ql.limit = limit if orig_limit > limit
+                end
+                @query_text = @n1ql.to_s
+            rescue StandardError
+                @query_text = nil
+                raise
+            ensure
+                @n1ql.limit = orig_limit
+            end
+
+            @reactor.schedule do
+                @error = nil
+                @callback = blk
+
+                @cmd = Ext::CMDN1QL.new
+                @params = Ext.n1p_new
+                err = Ext.n1p_setconsistency(@params, N1P_CONSISTENCY_REQUEST)
+                if err == :success
+                    err = Ext.n1p_setquery(@params, @query_text, @query_text.bytesize, N1P_QUERY_STATEMENT)
+                    if err == :success
+
+                        err = Ext.n1p_mkcmd(@params, @cmd)
+                        if err == :success
+                            pointer = @cmd.to_ptr
+                            @connection.requests[pointer.address] = self
+
+                            @cmd[:callback] = @connection.get_callback(:n1ql_callback)
+                            @cmd[:handle] = @request_handle
+
+                            err = Ext.n1ql_query(@connection.handle, pointer, @cmd)
+                            if err != :success
+                                error(Error.lookup(err).new('full text search not scheduled'))
+                            end
+                        else
+                            error(Error.lookup(err).new('failed to build full text search command'))
+                        end
+                    else
+                        error(Error.lookup(err).new('failed to build full text search query structure'))
+                    end
+                else
+                    error(Error.lookup(err).new('failed set consistency value'))
+                end
+            end
+        end
+
+        # Row is JSON value representing the result
+        def received(row)
+            return if @error
+
+            @callback.call(false, row)
+        rescue StandardError => e
+            @error = e
+            cancel
+        end
+
+        # Example metadata
+        # {:requestID=>"36162fce-ef39-4821-bf03-449e4073185d", :signature=>{:*=>"*"}, :results=>[], :status=>"success",
+        #  :metrics=>{:elapsedTime=>"15.298243ms", :executionTime=>"15.256975ms", :resultCount=>12, :resultSize=>8964}}
+        def received_final(metadata)
+            @query_text = nil
+
+            @connection.requests.delete(@cmd.to_ptr.address)
+            @cmd = nil
+
+            Ext.n1p_free(@params)
+            @params = nil
+
+            if @error
+                if @error == :cancelled
+                    @callback.call(:final, metadata)
+                else
+                    @callback.call(:error, @error)
+                end
+            else
+                @callback.call(:final, metadata)
+            end
+        end
+
+        def error(obj)
+            @error = obj
+            received_final(nil)
+        end
+
+        def cancel
+            @error ||= :cancelled
+            @reactor.schedule do
+                if @connection.handle && @cmd
+                    Ext.n1ql_cancel(@connection.handle, @handle_ptr.get_pointer(0))
+                    received_final(nil)
+                end
+            end
+        end
+    end
+end

data/lib/rails/generators/couchbase_orm/config/templates/couchbase.yml

@@ -1,5 +1,6 @@
 common: &common
-  hosts: localhost
+  connection_string: couchbase://localhost
+  bucket: <%= bucket_name || app_name %>
   username: <%= username || bucket_name || app_name %>
   password: <%= password %>
 
@@ -13,7 +14,7 @@ test:
 
 # set these environment variables on your production server
 production:
-  hosts: <%%= ENV['COUCHBASE_HOST'] || ENV['COUCHBASE_HOSTS'] %>
+  connection_string: <%%= ENV['COUCHBASE_CONNECTION_STRING'] %>
   bucket: <%%= ENV['COUCHBASE_BUCKET'] %>
   username: <%%= ENV['COUCHBASE_USER'] %>
   password: <%%= ENV['COUCHBASE_PASSWORD'] %>

data/spec/associations_spec.rb

@@ -5,6 +5,13 @@ require File.expand_path("../support", __FILE__)
 
 class Parent < CouchbaseOrm::Base
     attribute :name
+    has_and_belongs_to_many :children
+end
+
+class StrictLoadingParent < CouchbaseOrm::Base
+    attribute :name
+    has_and_belongs_to_many :children
+    self.strict_loading_by_default = true
 end
 
 class RandomOtherType < CouchbaseOrm::Base
@@ -17,77 +24,239 @@ class Child < CouchbaseOrm::Base
     belongs_to :parent, dependent: :destroy
 end
 
+class Assembly < CouchbaseOrm::Base
+    attribute :name
+
+    has_and_belongs_to_many :parts, autosave: true
+end
+
+class Part < CouchbaseOrm::Base
+    attribute :name
+
+    has_and_belongs_to_many :assemblies, dependent: :destroy, autosave: true
+end
+
 
 describe CouchbaseOrm::Associations do
-    it "should work with dependent associations" do
-        parent = Parent.create!(name: 'joe')
-        child  = Child.create!(name: 'bob', parent_id: parent.id)
+    describe 'belongs_to' do
+        it "should work with dependent associations" do
+            parent = Parent.create!(name: 'joe')
+            child  = Child.create!(name: 'bob', parent_id: parent.id)
 
-        expect(parent.persisted?).to be(true)
-        expect(child.persisted?).to be(true)
-        id = parent.id
+            expect(parent.persisted?).to be(true)
+            expect(child.persisted?).to be(true)
+            id = parent.id
+            
+            child.destroy
+            expect(child.destroyed?).to be(true)
+            expect(parent.destroyed?).to be(false)
 
-        child.destroy
-        expect(child.destroyed?).to be(true)
-        expect(parent.destroyed?).to be(false)
+            # Ensure that parent has been destroyed
+            expect { Parent.find(id) }.to raise_error(Couchbase::Error::DocumentNotFound)
+            
+            expect(Parent.find_by_id(id)).to be(nil)
 
-        # Ensure that parent has been destroyed
-        expect { Parent.find(id) }.to raise_error(Libcouchbase::Error::KeyNotFound)
-        expect(Parent.find_by_id(id)).to be(nil)
+            expect { parent.reload }.to raise_error(Couchbase::Error::DocumentNotFound)
 
-        expect { parent.reload }.to raise_error(Libcouchbase::Error::KeyNotFound)
+            # Save will always return true unless the model is changed (won't touch the database)
+            parent.name = 'should fail'
+            expect { parent.save  }.to raise_error(Couchbase::Error::DocumentNotFound)
+            expect { parent.save! }.to raise_error(Couchbase::Error::DocumentNotFound)
+        end
 
-        # Save will always return true unless the model is changed (won't touch the database)
-        parent.name = 'should fail'
-        expect { parent.save  }.to raise_error(Libcouchbase::Error::KeyNotFound)
-        expect { parent.save! }.to raise_error(Libcouchbase::Error::KeyNotFound)
-    end
+        it "should cache associations" do
+            parent = Parent.create!(name: 'joe')
+            child  = Child.create!(name: 'bob', parent_id: parent.id)
 
-    it "should cache associations" do
-        parent = Parent.create!(name: 'joe')
-        child  = Child.create!(name: 'bob', parent_id: parent.id)
+            id = child.parent.__id__
+            expect(parent.__id__).not_to eq(child.parent.__id__)
+            expect(parent).to eq(child.parent)
+            expect(child.parent.__id__).to eq(id)
 
-        id = child.parent.__id__
-        expect(parent.__id__).not_to eq(child.parent.__id__)
-        expect(parent).to eq(child.parent)
-        expect(child.parent.__id__).to eq(id)
+            child.reload
+            expect(parent).to eq(child.parent)
+            expect(child.parent.__id__).not_to eq(id)
 
-        child.reload
-        expect(parent).to eq(child.parent)
-        expect(child.parent.__id__).not_to eq(id)
+            child.destroy
+        end
 
-        child.destroy
-    end
+        it "should ignore associations when delete is used" do
+            parent = Parent.create!(name: 'joe')
+            child  = Child.create!(name: 'bob', parent_id: parent.id)
 
-    it "should ignore associations when delete is used" do
-        parent = Parent.create!(name: 'joe')
-        child  = Child.create!(name: 'bob', parent_id: parent.id)
+            id = child.id
+            child.delete
 
-        id = child.id
-        child.delete
+            expect(Child.exists?(id)).to be(false) # this is flaky
+            expect(Parent.exists?(parent.id)).to be(true)
 
-        expect(Child.exists?(id)).to be(false)
-        expect(Parent.exists?(parent.id)).to be(true)
+            id = parent.id
+            parent.delete
+            expect(Parent.exists?(id)).to be(false)
+        end
+
+        it "should raise an error if an invalid type is being assigned" do
+            begin
+                parent = RandomOtherType.create!(name: 'joe')
+                expect { Child.create!(name: 'bob', parent: parent) }.to raise_error(ArgumentError)
+            ensure
+                parent.delete
+            end
+        end
 
-        id = parent.id
-        parent.delete
-        expect(Parent.exists?(id)).to be(false)
+        describe Parent do
+            it_behaves_like "ActiveModel"
+        end
+
+        describe Child do
+            it_behaves_like "ActiveModel"
+        end
     end
 
-    it "should raise an error if an invalid type is being assigned" do
-        begin
-            parent = RandomOtherType.create!(name: 'joe')
-            expect { Child.create!(name: 'bob', parent: parent) }.to raise_error(ArgumentError)
-        ensure
-            parent.delete
+    describe 'has_and_belongs_to_many' do
+        it "should work with dependent associations" do
+            assembly = Assembly.create!(name: 'a1')
+            part = Part.create!(name: 'p1', assemblies: [assembly])
+            assembly.reload
+
+            expect(assembly.persisted?).to be(true)
+            expect(part.persisted?).to be(true)
+
+            part.destroy
+            expect(part.destroyed?).to be(true)
+            expect(assembly.destroyed?).to be(true)
+        end
+
+        it "should cache associations" do
+            assembly = Assembly.create!(name: 'a1')
+            part = Part.create!(name: 'p1', assembly_ids: [assembly.id])
+            assembly.reload
+
+            id = part.assemblies.first.__id__
+            expect(assembly.__id__).not_to eq(part.assemblies.first.__id__)
+            expect(assembly).to eq(part.assemblies.first)
+            expect(part.assemblies.first.__id__).to eq(id)
+
+            part.reload
+            expect(assembly).to eq(part.assemblies.first)
+            expect(part.assemblies.first.__id__).not_to eq(id)
+
+            part.destroy
+        end
+
+        it "should ignore associations when delete is used" do
+            assembly = Assembly.create!(name: 'a1')
+            part = Part.create!(name: 'p1', assembly_ids: [assembly.id])
+            assembly.reload
+
+            id = part.id
+            part.delete
+
+            expect(Part.exists?(id)).to be(false)
+            expect(Assembly.exists?(assembly.id)).to be(true)
+
+            id = assembly.id
+            assembly.delete
+            expect(Assembly.exists?(id)).to be(false)
+        end
+
+        it "should raise an error if an invalid type is being assigned" do
+            begin
+                assembly = RandomOtherType.create!(name: 'a1')
+                expect { Part.create!(name: 'p1', assemblies: [assembly]) }.to raise_error(ArgumentError)
+            ensure
+                assembly.delete
+            end
+        end
+
+        it "should add association with single" do
+            assembly = Assembly.create!(name: 'a1')
+            part = Part.create!(name: 'p1', assemblies: [assembly])
+
+            expect(assembly.reload.parts.map(&:id)).to match_array([part.id])
+        end
+
+        it 'should add association with multiple' do
+            assembly = Assembly.create!(name: 'a1')
+            part1 = Part.create!(name: 'p1', assemblies: [assembly])
+            part2 = Part.create!(name: 'p2', assemblies: [assembly])
+
+            expect(assembly.reload.parts.map(&:id)).to match_array([part1.id, part2.id])
+        end
+
+        it "should remove association with single" do
+            assembly1 = Assembly.create!(name: 'a1')
+            assembly2 = Assembly.create!(name: 'a2')
+            part = Part.create!(name: 'p1', assemblies: [assembly1])
+            part.assemblies = [assembly2]
+            part.save!
+
+            expect(assembly1.reload.parts.map(&:id)).to be_empty
+            expect(assembly2.reload.parts.map(&:id)).to match_array([part.id])
+        end
+
+        it 'should remove association with multiple' do
+            assembly1 = Assembly.create!(name: 'a1')
+            assembly2 = Assembly.create!(name: 'a2')
+            part1 = Part.create!(name: 'p1', assemblies: [assembly1])
+            part2 = Part.create!(name: 'p2', assemblies: [assembly2])
+
+            part1.assemblies = part1.assemblies + [assembly2]
+            part1.save!
+
+            expect(assembly1.reload.parts.map(&:id)).to match_array([part1.id])
+            expect(assembly2.reload.parts.map(&:id)).to match_array([part1.id, part2.id])
+        end
+
+        describe Assembly do
+            it_behaves_like "ActiveModel"
+        end
+
+        describe Part do
+            it_behaves_like "ActiveModel"
         end
     end
 
-    describe Parent do
-        it_behaves_like "ActiveModel"
+    describe 'strict_loading' do
+        let(:parent) {Parent.create!(name: 'joe')}
+        let(:child) {Child.create!(name: 'bob', parent_id: parent.id)}
+        context 'instance strict loading' do
+            it 'raises StrictLoadingViolationError on lazy loading child relation' do
+                expect {child.parent.id}.not_to raise_error
+                expect_strict_loading_error_on_calling_parent(Child.find(child.id).tap{|child| child.strict_loading!})
+            end
+        end
+        context 'scope strict loading' do
+            it 'raises StrictLoadingViolationError on lazy loading child relation' do
+                expect_strict_loading_error_on_calling_parent(Child.where(id: child.id).strict_loading.first)
+                expect_strict_loading_error_on_calling_parent(Child.strict_loading.where(id: child.id).first)
+                expect_strict_loading_error_on_calling_parent(Child.strict_loading.where(id: child.id).last)
+                expect_strict_loading_error_on_calling_parent(Child.strict_loading.where(id: child.id).to_a.first)
+                expect_strict_loading_error_on_calling_parent(Child.strict_loading.all.to_a.first)
+            end
+
+            it 'does not raise StrictLoadingViolationError on lazy loading child relation without declaring it' do
+                expect_strict_loading_error_on_calling_parent(Child.strict_loading.where(id: child.id).first)
+                expect { Child.where(id: child.id).last.parent}.not_to raise_error
+            end
+
+            it 'raises StrictLoadingViolationError on lazy loading habtm relation' do
+                expect {Parent.strict_loading.where(id: parent.id).first.children}.to raise_error(CouchbaseOrm::StrictLoadingViolationError)
+                # NB any action called on model class breaks find return type (find return an enumerator instead of a record)
+                expect {Parent.strict_loading.find(parent.id).first.children}.to raise_error(CouchbaseOrm::StrictLoadingViolationError)
+            end
+
+            it 'raises StrictLoadingViolationError on lazy loading relation when model is by default strict_loading' do
+                strict_loading_parent = StrictLoadingParent.create!(name: 'joe')
+                expect {StrictLoadingParent.where(id: strict_loading_parent.id).first.children}.to raise_error(CouchbaseOrm::StrictLoadingViolationError)
+                expect {Parent.find(parent.id).children}.not_to raise_error
+                # NB any action called on model class breaks find return type (find return an enumerator instead of a record)
+                expect {Parent.strict_loading.find(strict_loading_parent.id).first.children}.to raise_error(CouchbaseOrm::StrictLoadingViolationError)
+            end
+        end
     end
 
-    describe Child do
-        it_behaves_like "ActiveModel"
+    def expect_strict_loading_error_on_calling_parent(child_instance)
+      expect {child_instance.parent}.to raise_error(CouchbaseOrm::StrictLoadingViolationError)
     end
 end