libcouchbase-mapo 1.4.1

data/spec/connection_spec.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require 'libcouchbase'
+
+
+describe Libcouchbase::Connection do
+    before :each do
+        @log = []
+        expect(@log).to eq([])
+        @reactor = ::Libuv::Reactor.default
+    end
+
+    after :each do
+        @reactor = nil
+        @log = nil
+    end
+
+    it "should connect and disconnect from the default bucket" do
+        @reactor.run { |reactor|
+            connection = Libcouchbase::Connection.new
+            connection.connect.then {
+                @log << true
+            }.finally { connection.destroy }
+        }
+
+        expect(@log).to eq([true])
+    end
+
+    it "should store a key on the default bucket" do
+        @reactor.run { |reactor|
+            connection = Libcouchbase::Connection.new
+            connection.connect.then do
+                connection.store('sometestkey', {"json" => "data"}).then(proc {|resp|
+                    @log << resp.callback
+                }, proc { |error|
+                    @log << error
+                }).finally { connection.destroy }
+            end
+        }
+
+        expect(@log).to eq([:callback_store])
+    end
+
+    it "should durably store a key on the default bucket" do
+        @reactor.run { |reactor|
+            connection = Libcouchbase::Connection.new
+            connection.connect.then do
+                connection.store('sometestkey', {"json" => "data2"}, persist_to: -1, replicate_to: -1).then(proc {|resp|
+                    @log << resp.callback
+                }, proc { |error|
+                    @log << error
+                }).finally { connection.destroy }
+            end
+        }
+
+        expect(@log).to eq([:callback_storedur])
+    end
+
+    it "should fetch a key from the default bucket" do
+        @reactor.run { |reactor|
+            connection = Libcouchbase::Connection.new
+            connection.connect.then do
+                connection.get('sometestkey').then(proc {|resp|
+                    @log << resp.value
+                }, proc { |error|
+                    @log << error
+                }).finally { connection.destroy }
+            end
+        }
+
+        expect(@log).to eq([{json: "data2"}])
+    end
+
+    it "should unlock a key on the default bucket" do
+
+        @reactor.run { |reactor|
+            connection = Libcouchbase::Connection.new
+            connection.connect.then do
+                connection.get('sometestkey', lock: 2).then(proc {|resp|
+                    @log << resp.callback
+                    connection.unlock('sometestkey', cas: resp.cas).then(proc {|resp|
+                        @log << resp.callback
+                    }, proc { |error|
+                        @log << error
+                    })
+                }, proc { |error|
+                    @log << error
+                }).finally { connection.destroy }
+            end
+        }
+
+        expect(@log).to eq([:callback_get, :callback_unlock])
+    end
+
+    it "should remove a key on the default bucket" do
+        @reactor.run { |reactor|
+            connection = Libcouchbase::Connection.new
+            connection.connect.then do
+                connection.remove('sometestkey').then(proc {|resp|
+                    @log << :success
+                }, proc { |error|
+                    @log << error
+                }).finally { connection.destroy }
+            end
+        }
+
+        expect(@log).to eq([:success])
+    end
+
+    it "should allow settings to be configured" do
+        @reactor.run { |reactor|
+            connection = Libcouchbase::Connection.new
+            connection.connect.then do
+                expect(connection.configure(:operation_timeout, 1500000).value).to be(connection)
+                expect { connection.configure(:bob, 1500000).value }.to raise_error(Libcouchbase::Error)
+                @log << :success
+                connection.destroy
+            end
+        }
+
+        expect(@log).to eq([:success])
+    end
+
+    it "should return the server list" do
+        @reactor.run { |reactor|
+            begin
+                connection = Libcouchbase::Connection.new
+                connection.connect.value
+                @log = connection.get_server_list.value
+            ensure
+                connection.destroy
+            end
+        }
+
+        expect(@log).to eq(['127.0.0.1:11210'])
+    end
+
+    it "should support counter operations" do
+        @reactor.run { |reactor|
+            connection = Libcouchbase::Connection.new
+            connection.connect.then do
+                connection.counter('testcount', initial: 10, expire_in: 2)
+                .then(proc { |resp|
+                    @log << resp.value
+                    connection.get('testcount').then do |resp|
+                        @log << resp.value
+                    end
+                }, proc { |error|
+                    @log << error
+                }).finally { connection.destroy }
+            end
+        }
+
+        expect(@log).to eq([10, 10])
+    end
+
+    it "should support touch operations" do
+        @reactor.run { |reactor|
+            connection = Libcouchbase::Connection.new
+            connection.connect.then do
+                connection.store('testtouch', 34).then(proc {|resp|
+                    @log << resp.value
+                    connection.touch('testtouch', expire_in: 1).then(proc {
+                        @log << 'set'
+                        sleep 2
+                        connection.get('testtouch').catch do |err|
+                            @log << err.is_a?(Libcouchbase::Error::KeyNotFound)
+                        end
+                    })
+                }, proc { |error|
+                    @log << error
+                }).finally { connection.destroy }
+            end
+        }
+
+        expect(@log).to eq([34, 'set', true])
+    end
+
+    it "should fail to flush unless the connection specifies it is enabled" do
+        @reactor.run { |reactor|
+            connection = Libcouchbase::Connection.new
+            connection.connect.then do
+                begin
+                    connection.flush.then(proc {
+                        @log << :error
+                    }, proc {
+                        @log << :error
+                    }).finally { connection.destroy }
+                rescue => e
+                    @log << :success
+                    connection.destroy
+                end
+            end
+        }
+
+        expect(@log).to eq([:success])
+    end
+
+    it "should flush when enabled explicitly", flush: true do
+        @reactor.run { |reactor|
+            connection = Libcouchbase::Connection.new(bucket: :test, username: 'tester', password: 'password123')
+            connection.connect(flush_enabled: true).then do
+                begin
+                    connection.flush.then(proc { |resp|
+                        @log << resp.callback
+                    }, proc { |error|
+                        @log << error
+                    }).finally { connection.destroy }
+                rescue => e
+                    @log << e
+                    connection.destroy
+                end
+            end
+        }
+
+        expect(@log).to eq([:callback_cbflush])
+    end
+
+    it "should perform a HTTP request" do
+        @reactor.run { |reactor|
+            connection = Libcouchbase::Connection.new
+            connection.connect.then do
+                connection.http("/pools/default/buckets/#{connection.bucket}/ddocs", type: :management).then(
+                    proc { |resp|
+                        @log << resp.headers.empty?
+                        @log << resp.body.empty?
+                    },
+                    proc { |err|
+                        @log << err
+                    }
+                ).finally { connection.destroy }
+            end
+        }
+
+        expect(@log).to eq([false, false])
+    end
+
+    it "should fail a HTTP request" do
+        @reactor.run { |reactor|
+            connection = Libcouchbase::Connection.new
+            connection.connect.then do
+                connection.http("/pools/default/buckets/#{connection.bucket}/ddocs").then(
+                    proc { |resp|
+                        @log << resp.headers.empty?
+                        @log << resp.body.empty?
+                    },
+                    proc { |err|
+                        @log << err.message
+                        @log << err.code
+                    }
+                ).finally { connection.destroy }
+            end
+        }
+
+        expect(@log).to eq(['non success response for /pools/default/buckets/default/ddocs', 400])
+    end
+end

data/spec/design_docs_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require 'libcouchbase'
+
+
+describe Libcouchbase::DesignDocs, design_docs: true 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
+
+    it "should provide access to view configuration" do
+        config = @ddoc.design("user").view_config
+        expect(config.keys).to eq([:is_sys_admin])
+
+        config = @ddoc[:user].view_config
+        expect(config.keys).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,135 @@
+# 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
+
+    after :each do
+        @bucket = nil
+        @reactor = nil
+        @log = nil
+    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