couchbase-jruby-client 0.2.2-java → 1.0.4-java

data/test/test_bucket.rb

@@ -1,239 +1,25 @@
-# Author:: Couchbase <info@couchbase.com>
-# Copyright:: 2011, 2012 Couchbase, Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require File.join(File.dirname(__FILE__), 'setup')
+require 'helper'
 
 class TestBucket < Minitest::Test
 
-  def test_it_substitute_default_parts_to_url
-    with_configs(:host => 'localhost') do |configs| # pick first free port
-      connections = [
-        Couchbase.new("http://#{configs.host}:#{configs.port}"),
-        Couchbase.new(:port => configs.port),
-        Couchbase.new("http://#{configs.host}:8091", :port => configs.port)
-      ]
-      connections.each do |connection|
-        assert_equal configs.port, connection.port
-        assert_equal "#{configs.host}:#{configs.port}", connection.authority
-        assert_equal "http://#{configs.host}:#{configs.port}/pools/default/buckets/default/", connection.url
-      end
-      connections.each(&:disconnect)
-    end
-
-    with_configs(:host => '127.0.0.1') do |configs|
-      connections = [
-        Couchbase.new("http://#{configs.host}:#{configs.port}"),
-        Couchbase.new(:hostname => configs.host, :port => configs.port),
-        Couchbase.new('http://example.com:8091', :hostname => configs.host, :port => configs.port)
-      ]
-      connections.each do |connection|
-        assert_equal configs.host, connection.hostname
-        assert_equal "#{configs.host}:#{configs.port}", connection.authority
-        assert_equal "http://#{configs.host}:#{configs.port}/pools/default/buckets/default/", connection.url
-      end
-      connections.each(&:disconnect)
-    end
-  end
-
-  def test_it_raises_network_error_if_server_not_found
-    skip 'Exception not being trapped correctly'
-    refute(`netstat -tnl` =~ /12345/)
-    assert_raises Couchbase::Error::Connect do
-      Couchbase.new(:port => 12345)
-    end
-  end
-
-  def test_it_raises_argument_error_for_illegal_url
-    illegal = [
-      "ftp://localhost:8091/",
-      "http:/localhost:8091/",
-      ""
-    ]
-    illegal.each do |url|
-      assert_raises ArgumentError do
-        Couchbase.new(url)
-      end
-    end
-  end
-
-  def test_it_able_to_connect_to_protected_buckets
-    skip
-    with_configs(:buckets_spec => 'protected:secret') do |configs|
-      connection = Couchbase.new(:hostname => configs.host,
-                                 :port => configs.port,
-                                 :bucket => 'protected',
-                                 :username => 'protected',
-                                 :password => 'secret')
-      assert_equal "protected", connection.bucket
-      assert_equal "protected", connection.username
-      assert_equal "secret", connection.password
-      connection.disconnect
-    end
-  end
-
-  def test_it_allows_to_specify_credentials_in_url
-    skip
-    with_configs(:buckets_spec => 'protected:secret') do |configs|
-      connection = Couchbase.new("http://protected:secret@#{configs.host}:#{configs.port}/pools/default/buckets/protected/")
-      assert_equal "protected", connection.bucket
-      assert_equal "protected", connection.username
-      assert_equal "secret", connection.password
-      connection.disconnect
-    end
-  end
-
-  def test_it_raises_error_with_wrong_credentials
-    skip unless $mock.real?
-    with_configs do |configs|
-      assert_raises Couchbase::Error::Auth do
-        Couchbase.new(:hostname => configs.host,
-                      :port => configs.port,
-                      :bucket => 'default',
-                      :username => 'wrong.username',
-                      :password => 'wrong_password')
-      end
-    end
-  end
-
-  def test_it_unable_to_connect_to_protected_buckets_with_wrong_credentials
-    skip
-    with_configs(:buckets_spec => 'protected:secret') do |configs|
-      assert_raises Couchbase::Error::Auth do
-        Couchbase.new(:hostname => configs.host,
-                      :port => configs.port,
-                      :bucket => 'protected',
-                      :username => 'wrong',
-                      :password => 'secret')
-      end
-      assert_raises Couchbase::Error::Auth do
-        Couchbase.new(:hostname => configs.host,
-                      :port => configs.port,
-                      :bucket => 'protected',
-                      :username => 'protected',
-                      :password => 'wrong')
-      end
-    end
-  end
-
-  def test_it_allows_change_quiet_flag
-    with_configs do |configs|
-      connection = Couchbase.new(:hostname => configs.host,
-                                 :port => configs.port)
-
-      refute connection.quiet?
-
-      connection.disconnect
-      connection = Couchbase.new(:hostname => configs.host,
-                                 :port => configs.port,
-                                 :quiet => true)
-      assert connection.quiet?
-
-      connection.quiet = nil
-      assert_equal false, connection.quiet?
-
-      connection.quiet = :foo
-      assert_equal true, connection.quiet?
-      connection.disconnect
-    end
-  end
-
-  def test_it_is_connected
-    with_configs do |configs|
-      connection = Couchbase.new(:hostname => configs.host,
-                                 :port => configs.port)
-      assert connection.connected?
-      connection.disconnect
-    end
+  def test_async_access
+    assert_instance_of com.couchbase.client.java.CouchbaseAsyncBucket,
+                       Couchbase.bucket.async
   end
 
-  def test_it_is_possible_to_disconnect_instance
-    with_configs do |configs|
-      connection = Couchbase.new(:hostname => configs.host,
-                                 :port => configs.port)
-      connection.disconnect
-      refute connection.connected?
-    end
+  def test_legacy_set_and_get
+    obj = { 'a' => 1, 'b' => 'b', 'c' => true, 'd' => [1, 2, 3] }
+    assert Couchbase.bucket.set('a', obj)
+    doc = Couchbase.bucket.get('a')
+    assert_equal obj, doc.to_h
   end
 
-  def test_it_raises_error_on_double_disconnect
-    with_configs do |configs|
-      connection = Couchbase.new(:hostname => configs.host,
-                                 :port => configs.port)
-      connection.disconnect
-      assert_raises Couchbase::Error::Connect do
-        connection.disconnect
-      end
-    end
+  def test_get_and_set_string
+    assert Couchbase.bucket.set('a', 'a')
+    assert_equal 'a', Couchbase.bucket.get('a').to_s
   end
 
-  def test_it_allows_to_reconnect_the_instance
-    with_configs do |configs|
-      connection = Couchbase.new(:hostname => configs.host,
-                                 :port => configs.port)
-      connection.disconnect
-      refute connection.connected?
-      connection.reconnect
-      assert connection.connected?
-      assert connection.set(uniq_id, "foo")
-      connection.disconnect
-    end
+  def test_flush_bucket
+    assert Couchbase.bucket.flush
   end
-
-  def test_it_allows_to_change_configuration_during_reconnect
-    skip
-    with_configs do |configs|
-      connection = Couchbase.new(:quiet => true)
-      assert connection.quiet?
-      connection.disconnect
-
-      connection.reconnect(:quiet => false)
-      refute connection.quiet?
-      connection.disconnect
-    end
-  end
-
-  def test_it_uses_bucket_name_as_username_if_username_is_empty
-    skip
-    with_configs(:buckets_spec => 'protected:secret') do |configs|
-      connection = Couchbase.new(:hostname => configs.host,
-                                 :port => configs.port,
-                                 :bucket => 'protected',
-                                 :password => 'secret')
-      assert connection.connected?
-      connection.disconnect
-    end
-  end
-
-  def test_it_converts_options_keys_to_symbols
-    bucket = Couchbase::Bucket.new('quiet' => true, 'default_ttl' => 10)
-    assert bucket.quiet?
-    assert_equal 10, bucket.default_ttl
-    bucket.disconnect
-  end
-
-  def test_can_flush_bucket
-    skip unless $mock.real?
-    assert cb.flush
-  end
-
-  def test_replaces_nil_password_with_string
-    connection = Couchbase.new(password: nil)
-    assert_equal '', connection.password
-    connection.disconnect
-  end
-
 end

data/test/test_cluster.rb

@@ -1,33 +1,5 @@
-# Author:: Mike Evans <mike@urlgonomics.com>
-# Copyright:: 2013 Urlgonomics LLC.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-require File.join(File.dirname(__FILE__), 'setup')
+require 'helper'
 
 class TestCluster < Minitest::Test
 
-  def setup
-    @cluster = Couchbase::Cluster.new(username: 'admin', password: 'password')
-  end
-
-  def test_that_it_can_connect_to_cluster_manager
-    assert @cluster
-  end
-
-  def test_can_list_buckets
-    assert @cluster.list_buckets.include?('default')
-  end
-
 end

data/test/test_configuration.rb

@@ -0,0 +1,51 @@
+require 'helper'
+
+class TestConfiguration < Minitest::Test
+
+  SINGLE_CONFIG = {
+    host: '127.0.0.1',
+    bucket: 'fu',
+    password: 'abc123'
+  }
+
+  MULTIPLE_HOSTS = {
+    hosts: %w(host1 host2),
+    bucket: 'bar',
+    password: 'abc123'
+  }
+
+  MULTIPLE_BUCKETS = {
+    host: '127.0.0.1',
+    buckets: [
+      { 'name' => 'fu',  'password' => 'abc123' },
+      { 'name' => 'bar', 'password' => 'abc123' }
+    ]
+  }
+
+  def test_default
+    config = Couchbase::Configuration.new
+    assert_equal ['localhost'], config.hosts
+    assert_equal 'default', config.buckets.first.name
+  end
+
+  def test_single_config
+    config = Couchbase::Configuration.new(SINGLE_CONFIG)
+    assert_equal ['127.0.0.1'], config.hosts
+    assert_equal 'fu', config.buckets.first.name
+    assert_equal 'abc123', config.buckets.first.password
+  end
+
+  def test_multiple_hosts
+    config = Couchbase::Configuration.new(MULTIPLE_HOSTS)
+    assert_equal %w(host1 host2), config.hosts
+    assert_equal 'bar', config.buckets[0].name
+    assert_equal 'abc123', config.buckets[0].password
+  end
+
+  def test_multiple_buckets
+    config = Couchbase::Configuration.new(MULTIPLE_BUCKETS)
+    assert_equal ['127.0.0.1'], config.hosts
+    assert_equal 'fu', config.buckets[0].name
+    assert_equal 'bar', config.buckets[1].name
+  end
+end

data/test/test_couchbase.rb

@@ -1,37 +1,37 @@
-# Author:: Couchbase <info@couchbase.com>
-# Copyright:: 2011, 2012 Couchbase, Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require File.join(File.dirname(__FILE__), 'setup')
+require 'helper'
 
 class TestCouchbase < Minitest::Test
 
-  def test_that_it_create_instance_of_bucket
-    with_configs do |configs|
-      connection = Couchbase.new("http://#{configs.host}:#{configs.port}")
-      assert_instance_of Couchbase::Bucket, connection
-      connection.disconnect
-    end
+  def test_couchbase_module
+    assert Couchbase.is_a? Module
+  end
+
+  def test_couchbase_init
+    assert_instance_of Module, Couchbase
+  end
+
+  def test_cluster_access
+    assert_instance_of Couchbase::Cluster, Couchbase.cluster
   end
 
-  def test_global_bucket_access
-    with_configs do |configs|
-      assert_instance_of Couchbase::Bucket, Couchbase.bucket
-      assert_equal Couchbase.bucket, Couchbase.bucket
+  def test_bucket_access
+    assert_instance_of Couchbase::Bucket, Couchbase.bucket
+  end
+
+  def test_connection_status
+    Couchbase.bucket
+    assert Couchbase.connected?
+  end
+
+  def test_configuration_error
+    Couchbase.bucket
+    assert_raises Couchbase::ConfigurationError do
+      Couchbase.connection_options = {}
     end
   end
 
+  def test_multiple_bukets
+    assert_instance_of Couchbase::Bucket, Couchbase.buckets[:default]
+    assert_instance_of Couchbase::Bucket, Couchbase.bucket(:default)
+  end
 end

data/test/test_design_doc.rb

@@ -0,0 +1,29 @@
+require 'helper'
+
+class TestDesignDoc < Minitest::Test
+
+  def test_create_design_doc
+    dd = {
+      by_foo: {
+        map: <<-JS
+          function(doc, meta) {
+            emit(doc.id, null)
+          }
+        JS
+      }
+    }
+
+    design_doc = Couchbase::DesignDoc.new('bar', dd)
+    assert_instance_of com.couchbase.client.java.view.DesignDocument,
+                       design_doc.create
+  end
+
+  def test_incorrect_doc_format
+    dd = {
+      by_fu: ''
+    }
+    assert_raises Couchbase::DesignDocFormatError do
+      Couchbase::DesignDoc.new('bar', dd)
+    end
+  end
+end

data/test/test_document.rb

@@ -0,0 +1,51 @@
+require 'helper'
+
+class TestDocument < Minitest::Test
+  include Couchbase
+
+  java_import com.couchbase.client.java.document.RawJsonDocument
+
+  def setup
+    @json_string = '{"a":1,"b":2,"c":3}'
+    @json_hash = MultiJson.load(@json_string)
+    @document = Document.new(RawJsonDocument.create('doc', 100, @json_string))
+  end
+
+  def test_java_doc_conversion
+    assert_equal 'doc', @document.id
+    assert_equal 0,     @document.cas
+    assert_equal 100,   @document.ttl
+    assert_equal @json_string, @document.content
+    assert_equal @json_string, @document.to_s
+    assert_equal @json_string, "#{@document}"
+  end
+
+  def test_hash_conversion
+    assert_equal @json_hash, @document.to_h
+  end
+
+  def test_array_conversion
+    assert_equal @json_hash, @document.to_a
+  end
+
+  def test_implicit_hash_conversion
+    assert_equal 1, @document['a']
+    assert_equal 2, @document['b']
+    assert_equal 3, @document['c']
+  end
+
+  def test_each
+    @document.each do |pair|
+      assert_instance_of Array, pair
+      assert_instance_of String, pair[0]
+      assert_instance_of Fixnum, pair[1]
+    end
+  end
+
+  def test_each_pair
+    @document.each_pair do |k, v|
+      assert_instance_of String, k
+      assert_instance_of Fixnum, v
+    end
+  end
+end

data/test/test_operations.rb

@@ -0,0 +1,49 @@
+require 'helper'
+
+class TestOperations < Minitest::Test
+
+  def setup
+    @bucket = Couchbase.bucket
+  end
+
+  def test_set_and_get
+    assert @bucket.set(uniq_id, a: 1)
+    assert_equal({ 'a' => 1 }, @bucket.get(uniq_id).to_h)
+  end
+
+  def test_set_and_remove
+    assert @bucket.set(uniq_id, a: 1)
+    assert @bucket.remove(uniq_id)
+  end
+
+  def test_add_and_get
+    assert @bucket.add(uniq_id, a: 1)
+    assert_equal({ 'a' => 1 }, @bucket.get(uniq_id).to_h)
+  end
+
+  def test_set_and_get_plain
+    assert @bucket.set(uniq_id, a: 1)
+    assert_equal '{"a":1}', @bucket.get(uniq_id).to_s
+  end
+
+  def test_set_with_string_and_get_plain
+    assert @bucket.set(uniq_id, '{"a":1}')
+    assert_equal '{"a":1}', @bucket.get(uniq_id).to_s
+  end
+
+  def test_set_with_string_and_get
+    assert @bucket.set(uniq_id, '{"a":1}')
+    assert_equal({ 'a' => 1 }, @bucket.get(uniq_id).to_h)
+  end
+
+  def test_set_with_ttl
+    assert @bucket.set(uniq_id, { a: 1 }, ttl: 1)
+    refute_nil @bucket.get(uniq_id)
+    sleep 2
+    assert_nil @bucket.get(uniq_id)
+  end
+
+  def test_set_with_persist_to
+    assert @bucket.set(uniq_id, { a: 1 }, persist_to: :master)
+  end
+end