libcouchbase 0.0.1

data/spec/design_docs_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require 'libcouchbase'
+
+
+describe Libcouchbase::DesignDocs do
+    before :each do
+        @ddoc = Libcouchbase::Bucket.new.design_docs
+    end
+
+    it "should list the available designs" do
+        designs = @ddoc.designs
+        expect(designs.count).to eq(23)
+    end
+
+    it "should list the available views" do
+        views = @ddoc.design("user").views
+        expect(views).to eq([:is_sys_admin])
+
+        views = @ddoc[:user].views
+        expect(views).to eq([:is_sys_admin])
+    end
+end

data/spec/error_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require 'libcouchbase'
+
+
+describe Libcouchbase::Error do
+    it "define the error classes" do
+        expect(Libcouchbase::Error::MapChanged.new.is_a? StandardError).to be(true)
+    end
+
+    it "should be able to look up errors" do
+        expect(Libcouchbase::Error::Lookup[:empty_key]).to   be(Libcouchbase::Error::EmptyKey)
+        expect(Libcouchbase::Error.lookup(:empty_key)).to    be(Libcouchbase::Error::EmptyKey)
+        expect(Libcouchbase::Error.lookup(:whatwhat_key)).to be(Libcouchbase::Error::UnknownError)
+        expect(Libcouchbase::Error.lookup(2)).to             be(Libcouchbase::Error::AuthError)
+        expect(Libcouchbase::Error.lookup(-2)).to            be(Libcouchbase::Error::UnknownError)
+    end
+
+    it "should be able to catch generic errors" do
+        begin
+            raise ::Libcouchbase::Error::NoMemory, 'what what'
+        rescue ::Libcouchbase::Error => e
+            expect(e.message).to eq('what what')
+        end
+    end
+end

data/spec/fts_spec.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require 'libcouchbase'
+
+
+describe Libcouchbase::QueryFullText, full_text_search: true do
+    before :each do
+        # This will load the couchbase connection on a different thread
+        @bucket = Libcouchbase::Bucket.new
+        @reactor = ::Libuv::Reactor.default
+        @log = []
+    end
+
+    describe 'perform native queries' do
+        it "should iterate a full text search with results" do
+            results = @bucket.full_text_search(:default, 'Toshiba')
+            @log << results.to_a.count
+            @log << results.count
+            @log << results.collect { |res| res.value.nil? }
+            expect(@log).to eq([4, 4, [false, false, false, false]])
+        end
+
+        it "should iterate a full text search without results" do
+            results = @bucket.full_text_search(:default, 'Toshiba', include_docs: false)
+            @log << results.to_a.count
+            @log << results.count
+            @log << results.collect { |res| res.value.nil? }
+            expect(@log).to eq([4, 4, [true, true, true, true]])
+        end
+
+        it "should cancel a full text search when an error occurs" do
+            results = @bucket.full_text_search(:default, 'Toshiba')
+            begin
+                count = 0
+                results.collect { |res|
+                    raise 'err' if count > 0
+                    @log << res.value.nil?
+                    count += 1
+                }
+            rescue => e
+                @log << :error
+            end
+            expect(@log).to eq([false, :error])
+        end
+    end
+
+    describe 'perform queries in libuv reactor' do
+        it "should iterate a full text search with results" do
+            @reactor.run { |reactor|
+                results = @bucket.full_text_search(:default, 'Toshiba')
+                @log << results.to_a.count
+                @log << results.count
+                @log << results.collect { |res| res.value.nil? }
+            }
+            expect(@log).to eq([4, 4, [false, false, false, false]])
+        end
+
+        it "should iterate a full text search without results" do
+            @reactor.run { |reactor|
+                results = @bucket.full_text_search(:default, 'Toshiba', include_docs: false)
+                @log << results.to_a.count
+                @log << results.count
+                @log << results.collect { |res| res.value.nil? }
+            }
+            expect(@log).to eq([4, 4, [true, true, true, true]])
+        end
+
+        it "should cancel a full text search when an error occurs" do
+            @reactor.run { |reactor|
+                results = @bucket.full_text_search(:default, 'Toshiba')
+                begin
+                    count = 0
+                    results.collect { |res|
+                        raise 'err' if count > 0
+                        @log << res.value.nil?
+                        count += 1
+                    }
+                rescue => e
+                    @log << :error
+                end
+            }
+            expect(@log).to eq([false, :error])
+        end
+    end
+
+    describe 'perform queries in event machine' do
+        require 'em-synchrony'
+        
+        it "should iterate a full text search with results" do
+            EM.synchrony {
+                results = @bucket.full_text_search(:default, 'Toshiba')
+                @log << results.to_a.count
+                @log << results.count
+                @log << results.collect { |res| res.value.nil? }
+                EM.stop
+            }
+            expect(@log).to eq([4, 4, [false, false, false, false]])
+        end
+
+        it "should iterate a full text search without results" do
+            EM.synchrony {
+                results = @bucket.full_text_search(:default, 'Toshiba', include_docs: false)
+                @log << results.to_a.count
+                @log << results.count
+                @log << results.collect { |res| res.value.nil? }
+                EM.stop
+            }
+            expect(@log).to eq([4, 4, [true, true, true, true]])
+        end
+
+        it "should cancel a full text search when an error occurs" do
+            EM.synchrony {
+                results = @bucket.full_text_search(:default, 'Toshiba')
+                begin
+                    count = 0
+                    results.collect { |res|
+                        raise 'err' if count > 0
+                        @log << res.value.nil?
+                        count += 1
+                    }
+                rescue => e
+                    @log << :error
+                end
+                EM.stop
+            }
+            expect(@log).to eq([false, :error])
+        end
+    end
+end

data/spec/n1ql_spec.rb

@@ -0,0 +1,201 @@
+# 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
+
+    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,229 @@
+# 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
+        @query = MockQuery.new(@log)
+        @view = Libcouchbase::ResultsLibuv.new(@query)
+        expect(@log).to eq([])
+    end
+
+    it "should stream the response" do
+        @reactor.run { |reactor|
+            @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([:new_row, 0, :new_row, 1, :new_row, 2, :new_row, 3])
+    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