libcouchbase-mapo 1.4.1

data/spec/n1ql_spec.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require 'libcouchbase'
+
+
+describe Libcouchbase::N1QL, n1ql_query: true do
+    before :each do
+        @bucket = Libcouchbase::Bucket.new
+        @n1ql = @bucket.n1ql
+        @log = []
+    end
+
+    after :each do
+        @bucket = nil
+        @log = nil
+    end
+
+    it "should build a basic query" do
+        @n1ql.select('*').from(:default).where('port == 10001')
+        expect(@n1ql.to_s).to eq("SELECT *\nFROM default\nWHERE port == 10001\n")
+    end
+
+    describe 'perform native queries' do
+        before :each do
+            @n1ql.select('*').from(:default).where('type == "mod"')
+        end
+
+        it "should iterate results" do
+            results = @n1ql.results
+            @log << results.to_a.count
+            @log << results.count
+            @log << results.collect { |res| res.nil? }
+            expect(@log).to eq([12, 12,
+                [false, false, false, false, false,
+                 false, false, false, false, false,
+                 false, false
+                ]])
+        end
+
+        it "should cancel iteration when an error occurs" do
+            results = @n1ql.results
+            begin
+                count = 0
+                results.collect { |res|
+                    raise 'err' if count > 0
+                    @log << res.nil?
+                    count += 1
+                }
+            rescue => e
+                @log << :error
+            end
+            @log << results.count
+            expect(@log).to eq([false, :error, 12])
+        end
+
+        it "should cancel iteration when an error occurs in row modifer" do
+            count = 0
+            results = @n1ql.results do |row|
+                raise 'err' if count > 0
+                count += 1
+                row
+            end
+
+            begin
+                count = 0
+                results.collect { |res|
+                    @log << res.nil?
+                }
+            rescue => e
+                @log << e.message
+            end
+            expect(@log).to eq([false, 'err'])
+        end
+    end
+
+    describe 'perform queries in libuv reactor' do
+        before :each do
+            @n1ql.select('*').from(:default).where('type == "mod"')
+            @reactor = ::Libuv::Reactor.default
+        end
+
+        it "should iterate results" do
+            @reactor.run { |reactor|
+                results = @n1ql.results
+                @log << results.to_a.count
+                @log << results.count
+                @log << results.collect { |res| res.nil? }
+            }
+
+            expect(@log).to eq([12, 12,
+                [false, false, false, false, false,
+                 false, false, false, false, false,
+                 false, false
+                ]]
+            )
+        end
+
+        it "should cancel iteration when an error occurs" do
+            @reactor.run { |reactor|
+                results = @n1ql.results
+                begin
+                    count = 0
+                    results.collect { |res|
+                        raise 'err' if count > 0
+                        @log << res.nil?
+                        count += 1
+                    }
+                rescue => e
+                    @log << :error
+                end
+                @log << results.count
+            }
+            expect(@log).to eq([false, :error, 12])
+        end
+
+        it "should cancel iteration when an error occurs in row modifer" do
+            @reactor.run { |reactor|
+                count = 0
+                results = @n1ql.results do |row|
+                    raise 'err' if count > 0
+                    count += 1
+                    row
+                end
+
+                begin
+                    count = 0
+                    results.collect { |res|
+                        @log << res.nil?
+                    }
+                rescue => e
+                    @log << e.message
+                end
+            }
+            expect(@log).to eq([false, 'err'])
+        end
+    end
+
+    describe 'perform queries in event machine' do
+        require 'em-synchrony'
+
+        before :each do
+            @n1ql.select('*').from(:default).where('type == "mod"')
+        end
+
+        it "should iterate results" do
+            EM.synchrony {
+                results = @n1ql.results
+                @log << results.to_a.count
+                @log << results.count
+                @log << results.collect { |res| res.nil? }
+
+                EM.stop
+            }
+
+            expect(@log).to eq([12, 12,
+                [false, false, false, false, false,
+                 false, false, false, false, false,
+                 false, false
+                ]]
+            )
+        end
+
+        it "should cancel iteration when an error occurs" do
+            EM.synchrony {
+                results = @n1ql.results
+                begin
+                    count = 0
+                    results.collect { |res|
+                        raise 'err' if count > 0
+                        @log << res.nil?
+                        count += 1
+                    }
+                rescue => e
+                    @log << :error
+                end
+                @log << results.count
+
+                EM.stop
+            }
+            expect(@log).to eq([false, :error, 12])
+        end
+
+        it "should cancel iteration when an error occurs in row modifer" do
+            EM.synchrony {
+                count = 0
+                results = @n1ql.results do |row|
+                    raise 'err' if count > 0
+                    count += 1
+                    row
+                end
+
+                begin
+                    count = 0
+                    results.collect { |res|
+                        @log << res.nil?
+                    }
+                rescue => e
+                    @log << e.message
+                end
+
+                EM.stop
+            }
+            expect(@log).to eq([false, 'err'])
+        end
+    end
+end

data/spec/results_libuv_spec.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require 'libcouchbase'
+require 'uv-rays'
+
+
+class MockQuery
+    def initialize(log, preloaded = 0)
+        @count = 4
+        @preloaded = preloaded
+        @log = log
+    end
+
+    attr_accessor :preloaded
+
+    def get_count(metadata)
+        metadata[:total_rows]
+    end
+
+    def perform(limit: @count, **options, &blk)
+        @curr = 0
+        @callback = blk
+        @limit = limit
+        
+        if @sched
+            @sched.cancel
+            @sched = nil
+        end
+        @error = nil
+
+        preloaded.times { |i| blk.call(false, i) }
+        next_item(preloaded)
+    end
+
+    def next_item(i = 0)
+        if i == @limit
+            @sched = reactor.scheduler.in(50) do
+                @callback.call(:final, {total_rows: @count})
+            end
+        else
+            @sched = reactor.scheduler.in(100) do
+                @log << :new_row
+                next_item(i + 1)
+                @callback.call(false, i)
+            end
+        end
+    end
+
+    def cancel
+        return if @error
+        if @sched
+            @sched.cancel
+            @sched = nil
+        end
+        @error = :cancelled
+        @sched = reactor.scheduler.in(50) do
+            @callback.call(:final, {total_rows: @count})
+        end
+    end
+end
+
+
+describe Libcouchbase::ResultsLibuv do
+    before :each do
+        @log = []
+        @reactor = ::Libuv::Reactor.default
+        @reactor.notifier do |err|
+            @reactor.stop
+            @log << err
+        end
+        @timeout = @reactor.timer do
+            @timeout.close
+            @reactor.stop
+            @log << "test timed out"
+        end
+        @timeout.start(5000)
+        @timeout.unref
+        @query = MockQuery.new(@log)
+        @view = Libcouchbase::ResultsLibuv.new(@query)
+        expect(@log).to eq([])
+    end
+
+    after :each do
+        @timeout.close
+    end
+
+    it "should stream the response" do
+        @reactor.run { |reactor|
+            @view.each {|i| @log << i }
+        }
+
+        expect(@log).to eq([:new_row, 0, :new_row, 1, :new_row, 2, :new_row, 3])
+        expect(@view.complete_result_set).to be(true)
+        expect(@view.query_in_progress).to be(false)
+        expect(@view.query_completed).to be(true)
+    end
+
+    it "should continue to stream the response even if some has already been loaded" do
+        @reactor.run { |reactor|
+            @query.preloaded = 2
+            @view.each {|i| @log << i }
+        }
+
+        expect(@view.complete_result_set).to be(true)
+        expect(@view.query_in_progress).to be(false)
+        expect(@view.query_completed).to be(true)
+        expect(@log).to eq([0, 1, :new_row, 2, :new_row, 3])
+    end
+
+    it "should only load what is required" do
+        @reactor.run { |reactor|
+            @log << @view.take(2)
+            @log << @view.first
+            expect(@view.complete_result_set).to be(false)
+            expect(@view.query_in_progress).to be(false)
+            expect(@view.query_completed).to be(true)
+            @log << @view.to_a
+        }
+
+        expect(@view.complete_result_set).to be(true)
+        expect(@view.query_in_progress).to be(false)
+        expect(@view.query_completed).to be(true)
+        expect(@log).to eq([:new_row, :new_row, [0, 1], 0, :new_row, :new_row, :new_row, :new_row, [0, 1, 2, 3]])
+    end
+
+    it "should load only once" do
+        @reactor.run { |reactor|
+            @log << @view.to_a
+            @log << @view.to_a
+        }
+
+        expect(@log).to eq([:new_row, :new_row, :new_row, :new_row, [0, 1, 2, 3], [0, 1, 2, 3]])
+    end
+
+    it "should work as an enumerable" do
+        @reactor.run { |reactor|
+            enum = @view.each
+            @log << enum.next
+            @log << enum.next
+        }
+
+        expect(@log).to eq([:new_row, :new_row, :new_row, :new_row, 0, 1])
+    end
+
+    it "should return count" do
+        @reactor.run { |reactor|
+            @log << @view.count
+            @log << @view.count
+        }
+
+        expect(@log).to eq([:new_row, 4, 4])
+    end
+
+    it "should handle exceptions" do
+        @reactor.run { |reactor|
+            begin
+                @view.each {|i|
+                    @log << i
+                    raise 'what what'
+                }
+            rescue => e
+                @log << e.message
+            end
+        }
+
+        expect(@log).to eq([:new_row, 0, 'what what'])
+    end
+
+    it "should handle row modifier exceptions" do
+        count = 0
+
+        @view = Libcouchbase::ResultsLibuv.new(@query) { |view|
+            if count == 1
+                raise 'what what'
+            end
+            count += 1
+            view
+        }
+
+        @reactor.run { |reactor|
+            begin
+                @view.each {|i| @log << i }
+            rescue => e
+                @log << e.message
+            end
+        }
+
+        expect(@log).to eq([:new_row, 0, :new_row, 'what what'])
+    end
+
+    it "should handle row modifier exceptions on a short query" do
+        count = 0
+
+        @view = Libcouchbase::ResultsLibuv.new(@query) { |view|
+            raise 'what what'
+        }
+
+        @reactor.run { |reactor|
+            begin
+                @view.first
+            rescue => e
+                @log << e.message
+            end
+        }
+
+        expect(@log).to eq([:new_row, 'what what'])
+    end
+
+    it "should handle multiple exceptions" do
+        count = 0
+
+        @view = Libcouchbase::ResultsLibuv.new(@query) { |view|
+            if count == 1
+                raise 'second'
+            end
+            count += 1
+            view
+        }
+
+        @reactor.run { |reactor|
+            begin
+                @view.each {|i|
+                    @log << i
+                    raise 'first'
+                }
+            rescue => e
+                @log << e.message
+            end
+        }
+
+        expect(@log).to eq([:new_row, 0, 'first'])
+    end
+
+    it "should support streaming the response so results are not all stored in memory" do
+        @reactor.run { |reactor|
+            @view.stream {|i| @log << i }
+        }
+
+        expect(@view.complete_result_set).to be(false)
+        expect(@view.query_in_progress).to be(false)
+        expect(@view.query_completed).to be(true)
+        expect(@log).to eq([:new_row, 0, :new_row, 1, :new_row, 2, :new_row, 3])
+    end
+end

data/spec/results_native_spec.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require 'libcouchbase'
+require 'uv-rays'
+
+
+class NativeMockQuery
+    def initialize(log, thread = nil, preloaded = 0)
+        @count = 4
+        @preloaded = preloaded
+        @log = log
+        @thread = thread
+    end
+
+    attr_accessor :preloaded
+
+    def get_count(metadata)
+        metadata[:total_rows]
+    end
+
+    def perform(limit: @count, **options, &blk)
+        @wait = Thread.new do
+            @thread.run {
+                @curr = 0
+                @callback = blk
+                @limit = limit
+                @error = nil
+
+                preloaded.times { |i| blk.call(false, i) }
+                next_item(preloaded)
+            }
+        end
+    end
+
+    def wait_join
+        @wait.join
+    end
+
+    def next_item(i = 0)
+        if i == @limit
+            @sched = @thread.scheduler.in(50) do
+                @sched = nil
+                @callback.call(:final, {total_rows: @count})
+            end
+        else
+            @sched = @thread.scheduler.in(100) do
+                @log << :new_row
+                next_item(i + 1)
+                @callback.call(false, i)
+            end
+        end
+    end
+
+    def cancel
+        return if @error
+        @error = :cancelled
+
+        @thread.schedule {
+            if @sched
+                @sched.cancel
+                @sched = @thread.scheduler.in(50) do
+                    @sched = nil
+                    @callback.call(:final, {total_rows: @count})
+                end
+            end
+        }
+    end
+end
+
+
+describe Libcouchbase::ResultsNative do
+    before :each do
+        reactor = ::Libuv::Reactor.default
+        @qlog = []
+        @query = NativeMockQuery.new(@qlog, reactor)
+        @log = []
+        @view = Libcouchbase::ResultsNative.new(@query)
+        expect(@log).to eq([])
+    end
+
+    it "should stream the response" do
+        @view.each {|i| @log << i }
+
+        @query.wait_join
+
+        expect(@view.complete_result_set).to be(true)
+        expect(@view.query_in_progress).to be(false)
+        expect(@view.query_completed).to be(true)
+        expect(@qlog).to eq([:new_row, :new_row, :new_row, :new_row])
+        expect(@log).to eq([0, 1, 2, 3])
+    end
+
+    it "should continue to stream the response even if some has already been loaded" do
+        @query.preloaded = 2
+        @view.each {|i| @log << i }
+
+        @query.wait_join
+
+        expect(@view.complete_result_set).to be(true)
+        expect(@view.query_in_progress).to be(false)
+        expect(@view.query_completed).to be(true)
+        expect(@qlog).to eq([:new_row, :new_row])
+        expect(@log).to eq([0, 1, 2, 3])
+    end
+
+    it "should only load what is required" do
+        @log << @view.take(2)
+        expect(@view.complete_result_set).to be(false)
+        expect(@view.query_in_progress).to be(false)
+        expect(@view.query_completed).to be(true)
+
+        @log << @view.first
+        expect(@view.complete_result_set).to be(false)
+        expect(@view.query_in_progress).to be(false)
+        expect(@view.query_completed).to be(true)
+
+        # Wait join here as the default loop will
+        # be started again on a new thread
+        # without this wait we might end up in a deadlock...
+        # Don't worry, the test is sound - seriously
+        @query.wait_join
+
+        @log << @view.to_a
+        expect(@view.complete_result_set).to be(true)
+        expect(@view.query_in_progress).to be(false)
+        expect(@view.query_completed).to be(true)
+
+        @query.wait_join
+        
+        expect(@qlog).to eq([:new_row, :new_row, :new_row, :new_row, :new_row, :new_row])
+        expect(@log).to eq([[0, 1], 0, [0, 1, 2, 3]])
+    end
+
+    it "should load only once" do
+        @log << @view.to_a
+        @log << @view.to_a
+
+        @query.wait_join
+        expect(@qlog).to eq([:new_row, :new_row, :new_row, :new_row])
+        expect(@log).to eq([[0, 1, 2, 3], [0, 1, 2, 3]])
+    end
+
+    it "should work as an enumerable" do
+        enum = @view.each
+        @log << enum.next
+        @log << enum.next
+
+        @query.wait_join
+
+        expect(@qlog).to eq([:new_row, :new_row, :new_row, :new_row])
+        expect(@log).to eq([0, 1])
+    end
+
+    it "should return count" do
+        @log << @view.count
+        @log << @view.count
+
+        @query.wait_join
+
+        expect(@qlog).to eq([:new_row])
+        expect(@log).to eq([4, 4])
+    end
+
+    it "should handle exceptions" do
+        begin
+            @view.each {|i|
+                @log << i
+                raise 'what what'
+            }
+        rescue => e
+            @log << e.message
+        end
+
+        @query.wait_join
+
+        expect(@qlog).to eq([:new_row])
+        expect(@log).to eq([0, 'what what'])
+    end
+
+    it "should handle row modifier exceptions" do
+        count = 0
+
+        @view = Libcouchbase::ResultsNative.new(@query) { |view|
+            if count == 1
+                raise 'what what'
+            end
+            count += 1
+            view
+        }
+
+        begin
+            @view.each {|i| @log << i }
+        rescue => e
+            @log << e.message
+        end
+
+        @query.wait_join
+
+        expect(@qlog).to eq([:new_row, :new_row])
+        expect(@log).to eq([0, 'what what'])
+    end
+
+    it "should handle row modifier exceptions on a short query" do
+        count = 0
+
+        @view = Libcouchbase::ResultsNative.new(@query) { |view|
+            raise 'what what'
+        }
+
+        begin
+            @view.first
+        rescue => e
+            @log << e.message
+        end
+
+        @query.wait_join
+
+        expect(@qlog).to eq([:new_row])
+        expect(@log).to eq(['what what'])
+    end
+
+    it "should handle multiple exceptions" do
+        count = 0
+
+        @view = Libcouchbase::ResultsNative.new(@query) { |view|
+            if count == 1
+                raise 'second'
+            end
+            count += 1
+            view
+        }
+
+        begin
+            @view.each {|i|
+                @log << i
+                raise 'first'
+            }
+        rescue => e
+            @log << e.message
+        end
+
+        @query.wait_join
+
+        expect(@qlog).to eq([:new_row])
+        expect(@log).to eq([0, 'first'])
+    end
+
+    it "should support streaming the response so results are not all stored in memory" do
+        @view.stream {|i| @log << i }
+
+        @query.wait_join
+
+        expect(@view.complete_result_set).to be(false)
+        expect(@view.query_in_progress).to be(false)
+        expect(@view.query_completed).to be(true)
+        expect(@qlog).to eq([:new_row, :new_row, :new_row, :new_row])
+        expect(@log).to eq([0, 1, 2, 3])
+    end
+end