couchbase-jruby-client 0.1.7-java → 0.1.8-java

data/test/test_async.rb

@@ -29,268 +29,271 @@ class TestAsync < MiniTest::Test
     assert obj.respond_to?(:cas)
   end
 
-  def test_it_requires_block_for_running_loop
-    refute cb.async?
-    assert_raises(LocalJumpError) do
-      cb.run
-    end
-    cb.run do |conn|
-      assert conn.async?
-    end
+  def method_name
+    
   end
 
-  def test_it_resets_async_flag_when_raising_exception_from_callback
-    assert_raises(RuntimeError) do
-      cb.run do |conn|
-        conn.set(uniq_id, "foo") { raise }
-      end
-    end
-    refute cb.async?
-  end
-
-  def test_nested_async_get_set
-    cb.set(uniq_id, {"bar" => 1})
-    cb.set(uniq_id(:hit), 0)
-
-    cb.run do |conn|
-      conn.get(uniq_id) do
-        conn.get(uniq_id(:hit)) do |res|
-          conn.set(uniq_id(:hit), res.value + 1)
-        end
-      end
-    end
-
-    val = cb.get(uniq_id(:hit))
-    assert_equal 1, val
-  end
-
-  def test_nested_async_set_get
-    val = nil
-
-    cb.run do |conn|
-      conn.set(uniq_id, "foo") do
-        conn.get(uniq_id) do |res|
-          val = res.value
-        end
-      end
-    end
-
-    assert_equal "foo", val
-  end
-
-  def test_nested_async_touch_get
-    cb.set(uniq_id, "foo")
-    success = false
-    val = nil
-
-    cb.run do |conn|
-      conn.touch(uniq_id, :ttl => 1) do |res1|
-        success = res1.success?
-        conn.get(uniq_id) do |res2|
-          val = res2.value
-        end
-      end
-    end
-
-    assert success
-    assert_equal "foo", val
-    sleep(2)
-    assert_raises(Couchbase::Error::NotFound) do
-      cb.get(uniq_id)
-    end
-  end
-
-  def test_nested_async_delete_get
-    cas = cb.set(uniq_id, "foo")
-    success = false
-    val = :unknown
-
-    cb.run do |conn|
-      conn.delete(uniq_id, :cas => cas) do |res1|
-        success = res1.success?
-        conn.get(uniq_id, :quiet => true) do |res2|
-          val = res2.value
-        end
-      end
-    end
-
-    assert success
-    refute val
-  end
-
-  def test_nested_async_stats_set
-    skip
-    stats = {}
-
-    cb.run do |conn|
-      conn.stats do |res1|
-        id = uniq_id(res1.node, res1.key)
-        stats[id] = false
-        conn.set(id, res1.value) do |res2|
-          stats[id] = res2.cas
-        end
-      end
-    end
-
-    stats.keys.each do |key|
-      assert stats[key].is_a?(Numeric)
-    end
-  end
-
-  def test_nested_async_flush_set
-    skip
-    cas = cb.set(uniq_id, "foo")
-    res = {}
-
-    cb.run do |conn|
-      conn.flush do |res1|
-        assert res1.success?, "Expected: successful status code.\nActual: #{res1.error.inspect}"
-        id = uniq_id(res1.node)
-        res[id] = false
-        conn.set(id, true) do |res2|
-          res[id] = res2.cas
-        end
-      end
-    end
-
-    assert_raises(Couchbase::Error::NotFound) do
-      cb.get(uniq_id)
-    end
-    res.keys.each do |key|
-      assert res[key].is_a?(Numeric)
-      assert cb.get(key)
-    end
-  end
-
-  def test_nested_async_incr_get
-    skip
-    cas = cb.set(uniq_id, 1)
-    val = nil
-
-    cb.run do |conn|
-      conn.incr(uniq_id) do
-        conn.get(uniq_id) do |res|
-          val = res.value
-        end
-      end
-    end
-
-    assert_equal 2, val
-  end
-
-  def test_it_doesnt_accept_callbacks_in_synchronous_mode
-    refute cb.async?
-
-    assert_raises(ArgumentError) { cb.add(uniq_id, "foo") {} }
-    assert_raises(ArgumentError) { cb.set(uniq_id, "foo") {} }
-    assert_raises(ArgumentError) { cb.replace(uniq_id, "foo") {} }
-    assert_raises(ArgumentError) { cb.get(uniq_id) {} }
-    assert_raises(ArgumentError) { cb.touch(uniq_id) {} }
-    assert_raises(ArgumentError) { cb.incr(uniq_id) {} }
-    assert_raises(ArgumentError) { cb.decr(uniq_id) {} }
-    assert_raises(ArgumentError) { cb.delete(uniq_id) {} }
-    assert_raises(ArgumentError) { cb.append(uniq_id, "bar") {} }
-    assert_raises(ArgumentError) { cb.prepend(uniq_id, "bar") {} }
-    assert_raises(ArgumentError) { cb.flush {} }
-    assert_raises(ArgumentError) { cb.stats {} }
-  end
-
-  def test_it_disallow_nested_run
-    assert_raises(Couchbase::Error::Invalid) do
-      cb.run do
-        cb.run do
-        end
-      end
-    end
-  end
-
-  def test_it_extends_timeout_in_async_mode_if_needed
-    skip
-    cb.set(uniq_id, "foo")
-
-    cb.timeout = 100_000  # 100_000 us
-    cb.run do
-      cb.get(uniq_id) do |ret|
-        assert ret.success?
-        assert_equal "foo", ret.value
-      end
-      sleep(1.5)  # 1_500_000 us
-    end
-  end
-
-  def test_send_threshold
-    skip
-    sent = false
-    cb.run(:send_threshold => 100) do # 100 bytes
-      cb.set(uniq_id, "foo" * 100) {|r| sent = true}
-      assert sent
-    end
-  end
-
-  def test_asynchronous_connection
-    skip
-    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port, :async => true)
-    refute cb.connected?, "new asynchronous connection must be disconnected"
-    cb.on_connect do |res|
-      assert res.success?, "on_connect called with error #{res.error.inspect}"
-      assert_same connection, res.bucket
-    end
-    cb.run {}
-    assert cb.connected?, "it should be connected after first run"
-  end
-
-  def test_it_calls_callback_immediately_if_connected_sync
-    skip
-    assert cb.connected?, "connection wasn't established in sync mode"
-    called = false
-    cb.on_connect do |res|
-      assert res.success?, "on_connect called with error #{res.error.inspect}"
-      called = true
-    end
-    assert called, "the callback hasn't been called on set"
-    called = false
-    cb.on_connect do |res|
-      assert res.success?, "on_connect called with error #{res.error.inspect}"
-      called = true
-    end
-    refute called, "the callback must not be called on subsequent sets"
-  end
-
-  def test_it_calls_callback_immediately_if_connected_async
-    skip
-    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port, :async => true)
-    refute cb.connected?, "new asynchronous connection must be disconnected"
-    called = false
-    cb.run {}
-    assert cb.connected?, "the connection must be established"
-    cb.run do
-      cb.on_connect do |res|
-        assert res.success?, "on_connect called with error #{res.error.inspect}"
-        called = true
-      end
-    end
-    assert called, "the callback hasn't been called on set"
-    called = false
-    cb.run do
-      cb.on_connect do |res|
-        assert res.success?, "on_connect called with error #{res.error.inspect}"
-        called = true
-      end
-    end
-    refute called, "the callback must not be called on subsequent sets"
-  end
-
-  def test_it_returns_error_if_user_start_work_on_disconnected_instance_outside_on_connect_callback
-    skip
-    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port, :async => true)
-    refute cb.connected?, "new asynchronous connection must be disconnected"
-    error = nil
-    cb.on_error do |ex|
-      error = ex
-    end
-    cb.run do |c|
-      c.set("foo", "bar")
-    end
-    assert_instance_of(Couchbase::Error::Connect, error)
-  end
+  # def test_it_requires_block_for_running_loop
+  #   refute cb.async?
+  #   assert_raises(LocalJumpError) do
+  #     cb.run
+  #   end
+  #   cb.run do |conn|
+  #     assert conn.async?
+  #   end
+  # end
+
+  # def test_it_resets_async_flag_when_raising_exception_from_callback
+  #   assert_raises(RuntimeError) do
+  #     cb.run do |conn|
+  #       conn.set(uniq_id, "foo") { raise }
+  #     end
+  #   end
+  #   refute cb.async?
+  # end
+
+  # def test_nested_async_get_set
+  #   cb.set(uniq_id, {"bar" => 1})
+  #   cb.set(uniq_id(:hit), 0)
+
+  #   cb.run do |conn|
+  #     conn.get(uniq_id) do
+  #       conn.get(uniq_id(:hit)) do |res|
+  #         conn.set(uniq_id(:hit), res.value + 1)
+  #       end
+  #     end
+  #   end
+
+  #   val = cb.get(uniq_id(:hit))
+  #   assert_equal 1, val
+  # end
+
+  # def test_nested_async_set_get
+  #   val = nil
+
+  #   cb.run do |conn|
+  #     conn.set(uniq_id, "foo") do
+  #       conn.get(uniq_id) do |res|
+  #         val = res.value
+  #       end
+  #     end
+  #   end
+
+  #   assert_equal "foo", val
+  # end
+
+  # def test_nested_async_touch_get
+  #   cb.set(uniq_id, "foo")
+  #   success = false
+  #   val = nil
+
+  #   cb.run do |conn|
+  #     conn.touch(uniq_id, :ttl => 1) do |res1|
+  #       success = res1.success?
+  #       conn.get(uniq_id) do |res2|
+  #         val = res2.value
+  #       end
+  #     end
+  #   end
+
+  #   assert success
+  #   assert_equal "foo", val
+  #   sleep(2)
+  #   assert_raises(Couchbase::Error::NotFound) do
+  #     cb.get(uniq_id)
+  #   end
+  # end
+
+  # def test_nested_async_delete_get
+  #   cas = cb.set(uniq_id, "foo")
+  #   success = false
+  #   val = :unknown
+
+  #   cb.run do |conn|
+  #     conn.delete(uniq_id, :cas => cas) do |res1|
+  #       success = res1.success?
+  #       conn.get(uniq_id, :quiet => true) do |res2|
+  #         val = res2.value
+  #       end
+  #     end
+  #   end
+
+  #   assert success
+  #   refute val
+  # end
+
+  # def test_nested_async_stats_set
+  #   skip
+  #   stats = {}
+
+  #   cb.run do |conn|
+  #     conn.stats do |res1|
+  #       id = uniq_id(res1.node, res1.key)
+  #       stats[id] = false
+  #       conn.set(id, res1.value) do |res2|
+  #         stats[id] = res2.cas
+  #       end
+  #     end
+  #   end
+
+  #   stats.keys.each do |key|
+  #     assert stats[key].is_a?(Numeric)
+  #   end
+  # end
+
+  # def test_nested_async_flush_set
+  #   skip
+  #   cas = cb.set(uniq_id, "foo")
+  #   res = {}
+
+  #   cb.run do |conn|
+  #     conn.flush do |res1|
+  #       assert res1.success?, "Expected: successful status code.\nActual: #{res1.error.inspect}"
+  #       id = uniq_id(res1.node)
+  #       res[id] = false
+  #       conn.set(id, true) do |res2|
+  #         res[id] = res2.cas
+  #       end
+  #     end
+  #   end
+
+  #   assert_raises(Couchbase::Error::NotFound) do
+  #     cb.get(uniq_id)
+  #   end
+  #   res.keys.each do |key|
+  #     assert res[key].is_a?(Numeric)
+  #     assert cb.get(key)
+  #   end
+  # end
+
+  # def test_nested_async_incr_get
+  #   skip
+  #   cas = cb.set(uniq_id, 1)
+  #   val = nil
+
+  #   cb.run do |conn|
+  #     conn.incr(uniq_id) do
+  #       conn.get(uniq_id) do |res|
+  #         val = res.value
+  #       end
+  #     end
+  #   end
+
+  #   assert_equal 2, val
+  # end
+
+  # def test_it_doesnt_accept_callbacks_in_synchronous_mode
+  #   refute cb.async?
+
+  #   assert_raises(ArgumentError) { cb.add(uniq_id, "foo") {} }
+  #   assert_raises(ArgumentError) { cb.set(uniq_id, "foo") {} }
+  #   assert_raises(ArgumentError) { cb.replace(uniq_id, "foo") {} }
+  #   assert_raises(ArgumentError) { cb.get(uniq_id) {} }
+  #   assert_raises(ArgumentError) { cb.touch(uniq_id) {} }
+  #   assert_raises(ArgumentError) { cb.incr(uniq_id) {} }
+  #   assert_raises(ArgumentError) { cb.decr(uniq_id) {} }
+  #   assert_raises(ArgumentError) { cb.delete(uniq_id) {} }
+  #   assert_raises(ArgumentError) { cb.append(uniq_id, "bar") {} }
+  #   assert_raises(ArgumentError) { cb.prepend(uniq_id, "bar") {} }
+  #   assert_raises(ArgumentError) { cb.stats {} }
+  # end
+
+  # def test_it_disallow_nested_run
+  #   assert_raises(Couchbase::Error::Invalid) do
+  #     cb.run do
+  #       cb.run do
+  #       end
+  #     end
+  #   end
+  # end
+
+  # def test_it_extends_timeout_in_async_mode_if_needed
+  #   skip
+  #   cb.set(uniq_id, "foo")
+
+  #   cb.timeout = 100_000  # 100_000 us
+  #   cb.run do
+  #     cb.get(uniq_id) do |ret|
+  #       assert ret.success?
+  #       assert_equal "foo", ret.value
+  #     end
+  #     sleep(1.5)  # 1_500_000 us
+  #   end
+  # end
+
+  # def test_send_threshold
+  #   skip
+  #   sent = false
+  #   cb.run(:send_threshold => 100) do # 100 bytes
+  #     cb.set(uniq_id, "foo" * 100) {|r| sent = true}
+  #     assert sent
+  #   end
+  # end
+
+  # def test_asynchronous_connection
+  #   skip
+  #   connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port, :async => true)
+  #   refute cb.connected?, "new asynchronous connection must be disconnected"
+  #   cb.on_connect do |res|
+  #     assert res.success?, "on_connect called with error #{res.error.inspect}"
+  #     assert_same connection, res.bucket
+  #   end
+  #   cb.run {}
+  #   assert cb.connected?, "it should be connected after first run"
+  # end
+
+  # def test_it_calls_callback_immediately_if_connected_sync
+  #   skip
+  #   assert cb.connected?, "connection wasn't established in sync mode"
+  #   called = false
+  #   cb.on_connect do |res|
+  #     assert res.success?, "on_connect called with error #{res.error.inspect}"
+  #     called = true
+  #   end
+  #   assert called, "the callback hasn't been called on set"
+  #   called = false
+  #   cb.on_connect do |res|
+  #     assert res.success?, "on_connect called with error #{res.error.inspect}"
+  #     called = true
+  #   end
+  #   refute called, "the callback must not be called on subsequent sets"
+  # end
+
+  # def test_it_calls_callback_immediately_if_connected_async
+  #   skip
+  #   connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port, :async => true)
+  #   refute cb.connected?, "new asynchronous connection must be disconnected"
+  #   called = false
+  #   cb.run {}
+  #   assert cb.connected?, "the connection must be established"
+  #   cb.run do
+  #     cb.on_connect do |res|
+  #       assert res.success?, "on_connect called with error #{res.error.inspect}"
+  #       called = true
+  #     end
+  #   end
+  #   assert called, "the callback hasn't been called on set"
+  #   called = false
+  #   cb.run do
+  #     cb.on_connect do |res|
+  #       assert res.success?, "on_connect called with error #{res.error.inspect}"
+  #       called = true
+  #     end
+  #   end
+  #   refute called, "the callback must not be called on subsequent sets"
+  # end
+
+  # def test_it_returns_error_if_user_start_work_on_disconnected_instance_outside_on_connect_callback
+  #   skip
+  #   connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port, :async => true)
+  #   refute cb.connected?, "new asynchronous connection must be disconnected"
+  #   error = nil
+  #   cb.on_error do |ex|
+  #     error = ex
+  #   end
+  #   cb.run do |c|
+  #     c.set("foo", "bar")
+  #   end
+  #   assert_instance_of(Couchbase::Error::Connect, error)
+  # end
 end

data/test/test_bucket.rb

@@ -97,6 +97,7 @@ class TestBucket < MiniTest::Test
   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,
@@ -224,4 +225,15 @@ class TestBucket < MiniTest::Test
     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_delete.rb

@@ -21,12 +21,26 @@ class TestDelete < MiniTest::Test
 
   def test_trivial_delete
     cb.set(uniq_id, "bar")
-    assert cb.delete(uniq_id)
+    assert cas = cb.delete(uniq_id)
+
     assert_raises(Couchbase::Error::NotFound) do
       cb.delete(uniq_id)
     end
   end
 
+  def test_trivial_async_delete
+    cb.set(uniq_id, 'fu')
+    ret = nil
+    future = cb.async_delete(uniq_id) { |res| ret = res }
+    future.get
+    sleep 0.1
+
+    assert ret.is_a?(Couchbase::Result)
+    assert ret.success?
+    assert_equal :delete, ret.operation
+    assert ret.cas.is_a?(Numeric)
+  end
+
   def test_delete_missing
     assert_raises(Couchbase::Error::NotFound) do
       cb.delete(uniq_id(:missing))
@@ -38,10 +52,9 @@ class TestDelete < MiniTest::Test
   end
 
   def test_delete_with_cas
-    skip
     cas = cb.set(uniq_id, "bar")
     missing_cas = cas - 1
-    assert_raises(Couchbase::Error::KeyExists) do
+    assert_raises(Couchbase::Error::NotFound) do
       cb.delete(uniq_id, :cas => missing_cas)
     end
     assert cb.delete(uniq_id, :cas => cas)

data/test/test_design_docs.rb

@@ -20,26 +20,31 @@ require File.join(File.dirname(__FILE__), 'setup')
 class TestDesignDocs < MiniTest::Test
 
   def test_save_design_doc
+    skip unless $mock.real?
     assert cb.save_design_doc(design_doc)
   end
 
   def test_save_design_doc_with_bad_data
+    skip unless $mock.real?
     assert_raises ArgumentError do
       cb.save_design_doc(123)
     end
   end
 
   def test_delete_design_doc
+    skip unless $mock.real?
     cb.save_design_doc(design_doc)
     assert cb.delete_design_doc('blog')
   end
 
   def test_design_doc_access
+    skip unless $mock.real?
     cb.save_design_doc(design_doc)
     assert cb.design_docs['blog']
   end
 
   def test_design_doc_missing_access
+    skip unless $mock.real?
     refute cb.design_docs['missing']
   end
 

data/test/test_errors.rb

@@ -26,6 +26,7 @@ class TestErrors < MiniTest::Test
   end
 
   def test_graceful_add_with_collision
+    skip
     msg1 = {"author" => "foo", "message" => "hi all", "time" => "2012-01-12 11:29:09"}
     key1 = uniq_id(genkey(msg1))
     msg2 = {"author" => "foo", "message" => "hi all", "time" => "2012-01-12 11:29:30"}