couchbase 1.0.0 → 1.1.0

data/test/test_async.rb

@@ -39,7 +39,7 @@ class TestAsync < MiniTest::Unit::TestCase
   end
 
   def test_it_requires_block_for_running_loop
-    connection = Couchbase.new(:port => @mock.port)
+    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
     refute connection.async?
     assert_raises(LocalJumpError) do
       connection.run
@@ -50,40 +50,40 @@ class TestAsync < MiniTest::Unit::TestCase
   end
 
   def test_it_resets_async_flag_when_raising_exception_from_callback
-    connection = Couchbase.new(:port => @mock.port)
+    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
 
     assert_raises(RuntimeError) do
       connection.run do |conn|
-        conn.set(test_id, "foo") { raise }
+        conn.set(uniq_id, "foo") { raise }
       end
     end
     refute connection.async?
   end
 
   def test_nested_async_get_set
-    connection = Couchbase.new(:port => @mock.port)
-    connection.set(test_id, {"bar" => 1})
-    connection.set(test_id(:hit), 0)
+    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
+    connection.set(uniq_id, {"bar" => 1})
+    connection.set(uniq_id(:hit), 0)
 
     connection.run do |conn|
-      conn.get(test_id) do
-        conn.get(test_id(:hit)) do |res|
-          conn.set(test_id(:hit), res.value + 1)
+      conn.get(uniq_id) do
+        conn.get(uniq_id(:hit)) do |res|
+          conn.set(uniq_id(:hit), res.value + 1)
         end
       end
     end
 
-    val = connection.get(test_id(:hit))
+    val = connection.get(uniq_id(:hit))
     assert_equal 1, val
   end
 
   def test_nested_async_set_get
-    connection = Couchbase.new(:port => @mock.port)
+    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
     val = nil
 
     connection.run do |conn|
-      conn.set(test_id, "foo") do
-        conn.get(test_id) do |res|
+      conn.set(uniq_id, "foo") do
+        conn.get(uniq_id) do |res|
           val = res.value
         end
       end
@@ -93,15 +93,15 @@ class TestAsync < MiniTest::Unit::TestCase
   end
 
   def test_nested_async_touch_get
-    connection = Couchbase.new(:port => @mock.port)
-    connection.set(test_id, "foo")
+    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
+    connection.set(uniq_id, "foo")
     success = false
     val = nil
 
     connection.run do |conn|
-      conn.touch(test_id, :ttl => 1) do |res1|
+      conn.touch(uniq_id, :ttl => 1) do |res1|
         success = res1.success?
-        conn.get(test_id) do |res2|
+        conn.get(uniq_id) do |res2|
           val = res2.value
         end
       end
@@ -109,20 +109,20 @@ class TestAsync < MiniTest::Unit::TestCase
 
     assert success
     assert_equal "foo", val
-    sleep(1)
-    refute connection.get(test_id)
+    sleep(2)
+    refute connection.get(uniq_id)
   end
 
   def test_nested_async_delete_get
-    connection = Couchbase.new(:port => @mock.port)
-    cas = connection.set(test_id, "foo")
+    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
+    cas = connection.set(uniq_id, "foo")
     success = false
     val = :unknown
 
     connection.run do |conn|
-      conn.delete(test_id, :cas => cas) do |res1|
+      conn.delete(uniq_id, :cas => cas) do |res1|
         success = res1.success?
-        conn.get(test_id) do |res2|
+        conn.get(uniq_id) do |res2|
           val = res2.value
         end
       end
@@ -133,12 +133,12 @@ class TestAsync < MiniTest::Unit::TestCase
   end
 
   def test_nested_async_stats_set
-    connection = Couchbase.new(:port => @mock.port)
+    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
     stats = {}
 
     connection.run do |conn|
       conn.stats do |res1|
-        id = test_id(res1.node, res1.key)
+        id = uniq_id(res1.node, res1.key)
         stats[id] = false
         conn.set(id, res1.value) do |res2|
           stats[id] = res2.cas
@@ -152,14 +152,14 @@ class TestAsync < MiniTest::Unit::TestCase
   end
 
   def test_nested_async_flush_set
-    connection = Couchbase.new(:port => @mock.port)
-    cas = connection.set(test_id, "foo")
+    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
+    cas = connection.set(uniq_id, "foo")
     res = {}
 
     connection.run do |conn|
       conn.flush do |res1|
         assert res1.success?
-        id = test_id(res1.node)
+        id = uniq_id(res1.node)
         res[id] = false
         conn.set(id, true) do |res2|
           res[id] = res2.cas
@@ -167,7 +167,7 @@ class TestAsync < MiniTest::Unit::TestCase
       end
     end
 
-    refute connection.get(test_id)
+    refute connection.get(uniq_id)
     res.keys.each do |key|
       assert res[key].is_a?(Numeric)
       assert connection.get(key)
@@ -175,13 +175,13 @@ class TestAsync < MiniTest::Unit::TestCase
   end
 
   def test_nested_async_incr_get
-    connection = Couchbase.new(:port => @mock.port)
-    cas = connection.set(test_id, 1)
+    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
+    cas = connection.set(uniq_id, 1)
     val = nil
 
     connection.run do |conn|
-      conn.incr(test_id) do
-        conn.get(test_id) do |res|
+      conn.incr(uniq_id) do
+        conn.get(uniq_id) do |res|
           val = res.value
         end
       end
@@ -191,21 +191,45 @@ class TestAsync < MiniTest::Unit::TestCase
   end
 
   def test_it_doesnt_accept_callbacks_in_synchronous_mode
-    connection = Couchbase.new(:port => @mock.port)
+    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
     refute connection.async?
 
-    assert_raises(ArgumentError) { connection.add(test_id, "foo") {} }
-    assert_raises(ArgumentError) { connection.set(test_id, "foo") {} }
-    assert_raises(ArgumentError) { connection.replace(test_id, "foo") {} }
-    assert_raises(ArgumentError) { connection.get(test_id) {} }
-    assert_raises(ArgumentError) { connection.touch(test_id) {} }
-    assert_raises(ArgumentError) { connection.incr(test_id) {} }
-    assert_raises(ArgumentError) { connection.decr(test_id) {} }
-    assert_raises(ArgumentError) { connection.delete(test_id) {} }
-    assert_raises(ArgumentError) { connection.append(test_id, "bar") {} }
-    assert_raises(ArgumentError) { connection.prepend(test_id, "bar") {} }
+    assert_raises(ArgumentError) { connection.add(uniq_id, "foo") {} }
+    assert_raises(ArgumentError) { connection.set(uniq_id, "foo") {} }
+    assert_raises(ArgumentError) { connection.replace(uniq_id, "foo") {} }
+    assert_raises(ArgumentError) { connection.get(uniq_id) {} }
+    assert_raises(ArgumentError) { connection.touch(uniq_id) {} }
+    assert_raises(ArgumentError) { connection.incr(uniq_id) {} }
+    assert_raises(ArgumentError) { connection.decr(uniq_id) {} }
+    assert_raises(ArgumentError) { connection.delete(uniq_id) {} }
+    assert_raises(ArgumentError) { connection.append(uniq_id, "bar") {} }
+    assert_raises(ArgumentError) { connection.prepend(uniq_id, "bar") {} }
     assert_raises(ArgumentError) { connection.flush {} }
     assert_raises(ArgumentError) { connection.stats {} }
   end
 
+  def test_it_disallow_nested_run
+    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
+    assert_raises(Couchbase::Error::Invalid) do
+      connection.run do
+        connection.run do
+        end
+      end
+    end
+  end
+
+  def test_it_extends_timeout_in_async_mode_if_needed
+    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
+    connection.set(uniq_id, "foo")
+
+    connection.timeout = 100  # 100 us
+    connection.run do
+      connection.get(uniq_id) do |ret|
+        assert ret.success?
+        assert_equal "foo", ret.value
+      end
+      sleep(1.5)
+    end
+  end
+
 end

data/test/test_bucket.rb

@@ -20,64 +20,63 @@ require File.join(File.dirname(__FILE__), 'setup')
 class TestBucket < MiniTest::Unit::TestCase
 
   def test_it_substitute_default_parts_to_url
-    with_mock(:port => 8091, :buckets_spec => 'default,foo') do
-      connections = [
-        Couchbase.new,
-        Couchbase.new('http://localhost'),
-        Couchbase.new('http://localhost:8091'),
-        Couchbase.new('http://localhost:8091/pools/default'),
-        Couchbase.new(:hostname => 'localhost'),
-        Couchbase.new(:hostname => 'localhost', :port => 8091)
-      ]
-      connections.each do |connection|
-        assert_equal 'localhost', connection.hostname
-        assert_equal 8091, connection.port
-        assert_equal "localhost:8091", connection.authority
-        assert_equal 'default', connection.bucket
-        assert_equal 'http://localhost:8091/pools/default/buckets/default/', connection.url
-      end
+#   with_mock(:host => 'localhost', :port => 8091, :buckets_spec => 'default,foo') do |mock|
+#     connections = [
+#       Couchbase.new,
+#       Couchbase.new("http://#{mock.host}:8091"),
+#       Couchbase.new("http://#{mock.host}:8091/pools/default"),
+#       Couchbase.new(:hostname => mock.host),
+#       Couchbase.new(:hostname => mock.host, :port => 8091)
+#     ]
+#     connections.each do |connection|
+#       assert_equal mock.host, connection.hostname
+#       assert_equal 8091, connection.port
+#       assert_equal "#{mock.host}:8091", connection.authority
+#       assert_equal 'default', connection.bucket
+#       assert_equal "http://#{mock.host}:8091/pools/default/buckets/default/", connection.url
+#     end
 
-      connections = [
-        Couchbase.new('http://localhost:8091/pools/default/buckets/foo'),
-        Couchbase.new(:bucket => 'foo'),
-        Couchbase.new('http://localhost:8091/pools/default/buckets/default', :bucket => 'foo')
-      ]
-      connections.each do |connection|
-        assert_equal 'foo', connection.bucket
-        assert_equal 'http://localhost:8091/pools/default/buckets/foo/', connection.url
-      end
-    end
+#     connections = [
+#       Couchbase.new("http://#{mock.host}:8091/pools/default/buckets/foo"),
+#       Couchbase.new(:bucket => 'foo'),
+#       Couchbase.new("http://#{mock.host}:8091/pools/default/buckets/default", :bucket => 'foo')
+#     ]
+#     connections.each do |connection|
+#       assert_equal 'foo', connection.bucket
+#       assert_equal "http://#{mock.host}:8091/pools/default/buckets/foo/", connection.url
+#     end
+#   end
 
-    with_mock do |mock| # pick first free port
+    with_mock(:host => 'localhost') do |mock| # pick first free port
       connections = [
-        Couchbase.new("http://localhost:#{mock.port}"),
+        Couchbase.new("http://#{mock.host}:#{mock.port}"),
         Couchbase.new(:port => mock.port),
-        Couchbase.new('http://localhost:8091', :port => mock.port)
+        Couchbase.new("http://#{mock.host}:8091", :port => mock.port)
       ]
       connections.each do |connection|
         assert_equal mock.port, connection.port
-        assert_equal "localhost:#{mock.port}", connection.authority
-        assert_equal "http://localhost:#{mock.port}/pools/default/buckets/default/", connection.url
+        assert_equal "#{mock.host}:#{mock.port}", connection.authority
+        assert_equal "http://#{mock.host}:#{mock.port}/pools/default/buckets/default/", connection.url
       end
     end
 
     with_mock(:host => '127.0.0.1') do |mock|
       connections = [
-        Couchbase.new("http://127.0.0.1:#{mock.port}"),
-        Couchbase.new(:hostname => '127.0.0.1', :port => mock.port),
-        Couchbase.new('http://localhost:8091', :hostname => '127.0.0.1', :port => mock.port)
+        Couchbase.new("http://#{mock.host}:#{mock.port}"),
+        Couchbase.new(:hostname => mock.host, :port => mock.port),
+        Couchbase.new('http://example.com:8091', :hostname => mock.host, :port => mock.port)
       ]
       connections.each do |connection|
-        assert_equal '127.0.0.1', connection.hostname
-        assert_equal "127.0.0.1:#{mock.port}", connection.authority
-        assert_equal "http://127.0.0.1:#{mock.port}/pools/default/buckets/default/", connection.url
+        assert_equal mock.host, connection.hostname
+        assert_equal "#{mock.host}:#{mock.port}", connection.authority
+        assert_equal "http://#{mock.host}:#{mock.port}/pools/default/buckets/default/", connection.url
       end
     end
   end
 
   def test_it_raises_network_error_if_server_not_found
     refute(`netstat -tnl` =~ /12345/)
-    assert_raises Couchbase::Error::Network do
+    assert_raises Couchbase::Error::Connect do
       Couchbase.new(:port => 12345)
     end
   end
@@ -97,7 +96,8 @@ class TestBucket < MiniTest::Unit::TestCase
 
   def test_it_able_to_connect_to_protected_buckets
     with_mock(:buckets_spec => 'protected:secret') do |mock|
-      connection = Couchbase.new(:port => mock.port,
+      connection = Couchbase.new(:hostname => mock.host,
+                                 :port => mock.port,
                                  :bucket => 'protected',
                                  :username => 'protected',
                                  :password => 'secret')
@@ -107,16 +107,39 @@ class TestBucket < MiniTest::Unit::TestCase
     end
   end
 
+  def test_it_allows_to_specify_credentials_in_url
+    with_mock(:buckets_spec => 'protected:secret') do |mock|
+      connection = Couchbase.new("http://protected:secret@#{mock.host}:#{mock.port}/pools/default/buckets/protected/")
+      assert_equal "protected", connection.bucket
+      assert_equal "protected", connection.username
+      assert_equal "secret", connection.password
+    end
+  end
+
   def test_it_raises_error_with_wrong_credentials
+    with_mock do |mock|
+      assert_raises Couchbase::Error::Auth do
+        Couchbase.new(:hostname => mock.host,
+                      :port => mock.port,
+                      :bucket => 'default',
+                      :username => 'wrong.username',
+                      :password => 'wrong_password')
+      end
+    end
+  end
+
+  def test_it_unable_to_connect_to_protected_buckets_with_wrond_credentials
     with_mock(:buckets_spec => 'protected:secret') do |mock|
-      assert_raises Couchbase::Error::Libcouchbase do
-        Couchbase.new(:port => mock.port,
+      assert_raises Couchbase::Error::Auth do
+        Couchbase.new(:hostname => mock.host,
+                      :port => mock.port,
                       :bucket => 'protected',
                       :username => 'wrong',
                       :password => 'secret')
       end
-      assert_raises Couchbase::Error::Libcouchbase do
-        Couchbase.new(:port => mock.port,
+      assert_raises Couchbase::Error::Auth do
+        Couchbase.new(:hostname => mock.host,
+                      :port => mock.port,
                       :bucket => 'protected',
                       :username => 'protected',
                       :password => 'wrong')
@@ -126,10 +149,13 @@ class TestBucket < MiniTest::Unit::TestCase
 
   def test_it_allows_change_quiet_flag
     with_mock do |mock|
-      connection = Couchbase.new(:port => mock.port)
+      connection = Couchbase.new(:hostname => mock.host,
+                                 :port => mock.port)
       assert connection.quiet?
 
-      connection = Couchbase.new(:port => mock.port, :quiet => true)
+      connection = Couchbase.new(:hostname => mock.host,
+                                 :port => mock.port,
+                                 :quiet => true)
       assert connection.quiet?
 
       connection.quiet = nil
@@ -139,4 +165,63 @@ class TestBucket < MiniTest::Unit::TestCase
       assert_equal true, connection.quiet?
     end
   end
+
+  def test_it_is_connected
+    with_mock do |mock|
+      connection = Couchbase.new(:hostname => mock.host,
+                                 :port => mock.port)
+      assert connection.connected?
+    end
+  end
+
+  def test_it_is_possible_to_disconnect_instance
+    with_mock do |mock|
+      connection = Couchbase.new(:hostname => mock.host,
+                                 :port => mock.port)
+      connection.disconnect
+      refute connection.connected?
+    end
+  end
+
+  def test_it_raises_error_on_double_disconnect
+    with_mock do |mock|
+      connection = Couchbase.new(:hostname => mock.host,
+                                 :port => mock.port)
+      connection.disconnect
+      assert_raises Couchbase::Error::Connect do
+        connection.disconnect
+      end
+    end
+  end
+
+  def test_it_allows_to_reconnect_the_instance
+    with_mock do |mock|
+      connection = Couchbase.new(:hostname => mock.host,
+                                 :port => mock.port)
+      connection.disconnect
+      refute connection.connected?
+      connection.reconnect
+      assert connection.connected?
+      assert connection.set(uniq_id, "foo")
+    end
+  end
+
+  def test_it_allows_to_change_configuration_during_reconnect
+    with_mock(:buckets_spec => 'protected:secret') do |mock|
+      connection = Couchbase.new(:hostname => mock.host,
+                                 :port => mock.port,
+                                 :bucket => 'protected',
+                                 :username => 'protected',
+                                 :password => 'secret')
+      connection.disconnect
+      assert_raises Couchbase::Error::Auth do
+        connection.reconnect(:password => 'incorrect')
+      end
+      refute connection.connected?
+
+      connection.reconnect(:password => 'secret')
+      assert connection.connected?
+    end
+  end
+
 end