couchbase-jruby-client 0.1.2 → 0.1.3

data/test/test_cas.rb

@@ -19,34 +19,22 @@ require File.join(File.dirname(__FILE__), 'setup')
 
 class TestCas < MiniTest::Test
 
-  def setup
-    @mock = start_mock
-  end
-
-  def teardown
-    stop_mock(@mock)
-  end
-
   def test_compare_and_swap
-    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port,
-                               :default_format => :document)
-    connection.set(uniq_id, {"bar" => 1})
-    connection.cas(uniq_id) do |val|
+    cb.set(uniq_id, {"bar" => 1})
+    cb.cas(uniq_id) do |val|
       val["baz"] = 2
       val
     end
-    val = connection.get(uniq_id)
+    val = cb.get(uniq_id)
     expected = {"bar" => 1, "baz" => 2}
     assert_equal expected, val
   end
 
   def test_compare_and_swap_async
     skip
-    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port,
-                               :default_format => :document)
-    connection.set(uniq_id, {"bar" => 1})
+    cb.set(uniq_id, {"bar" => 1})
     calls = 0
-    connection.run do |conn|
+    cb.run do |conn|
       conn.cas(uniq_id) do |ret|
         calls += 1
         case ret.operation
@@ -62,18 +50,16 @@ class TestCas < MiniTest::Test
       end
     end
     assert_equal 2, calls
-    val = connection.get(uniq_id)
+    val = cb.get(uniq_id)
     expected = {"bar" => 1, "baz" => 2}
     assert_equal expected, val
   end
 
   def test_flags_replication
     skip
-    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port,
-                               :default_format => :document)
-    connection.set(uniq_id, "bar", :flags => 0x100)
-    connection.cas(uniq_id) { "baz" }
-    _, flags, _ = connection.get(uniq_id, :extended => true)
+    cb.set(uniq_id, "bar", :flags => 0x100)
+    cb.cas(uniq_id) { "baz" }
+    _, flags, _ = cb.get(uniq_id, :extended => true)
     assert_equal 0x100, flags
   end
 end

data/test/test_couchbase.rb

@@ -16,18 +16,19 @@
 #
 
 require File.join(File.dirname(__FILE__), 'setup')
-require 'minitest/mock'
 
 class TestCouchbase < MiniTest::Test
 
   def test_that_it_create_instance_of_bucket
-    with_mock do |mock|
-      assert_instance_of Couchbase::Bucket, Couchbase.new("http://#{mock.host}:#{mock.port}")
+    with_configs do |configs|
+      connection = Couchbase.new("http://#{configs.host}:#{configs.port}")
+      assert_instance_of Couchbase::Bucket, connection
+      connection.disconnect
     end
   end
 
   def test_global_bucket_access
-    with_mock do |mock|
+    with_configs do |configs|
       assert_instance_of Couchbase::Bucket, Couchbase.bucket
       assert_equal Couchbase.bucket, Couchbase.bucket
     end

data/test/test_delete.rb

@@ -19,107 +19,105 @@ require File.join(File.dirname(__FILE__), 'setup')
 
 class TestStore < MiniTest::Test
 
-  def setup
-    @mock = start_mock
-  end
-
-  def teardown
-    stop_mock(@mock)
-  end
-
   def test_trivial_delete
-    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
-    connection.set(uniq_id, "bar")
-    assert connection.delete(uniq_id)
+    cb.set(uniq_id, "bar")
+    assert cb.delete(uniq_id)
     assert_raises(Couchbase::Error::NotFound) do
-      connection.delete(uniq_id)
+      cb.delete(uniq_id)
     end
   end
 
   def test_delete_missing
-    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
     assert_raises(Couchbase::Error::NotFound) do
-      connection.delete(uniq_id(:missing))
+      cb.delete(uniq_id(:missing))
     end
-    refute connection.delete(uniq_id(:missing), :quiet => true)
-    refute connection.quiet?
-    connection.quiet = true
-    refute connection.delete(uniq_id(:missing))
+    refute cb.delete(uniq_id(:missing), :quiet => true)
+    refute cb.quiet?
+    cb.quiet = true
+    refute cb.delete(uniq_id(:missing))
   end
 
   def test_delete_with_cas
     skip
-    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
-    cas = connection.set(uniq_id, "bar")
+    cas = cb.set(uniq_id, "bar")
     missing_cas = cas - 1
     assert_raises(Couchbase::Error::KeyExists) do
-      connection.delete(uniq_id, :cas => missing_cas)
+      cb.delete(uniq_id, :cas => missing_cas)
     end
-    assert connection.delete(uniq_id, :cas => cas)
+    assert cb.delete(uniq_id, :cas => cas)
   end
 
   def test_allow_fixnum_as_cas_parameter
-    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
-    cas = connection.set(uniq_id, "bar")
-    assert connection.delete(uniq_id, cas)
+    cas = cb.set(uniq_id, "bar")
+    assert cb.delete(uniq_id, cas)
   end
 
   def test_delete_with_prefix
     skip
     connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port, :key_prefix => "prefix:")
-    connection.set(uniq_id(:foo), "bar")
-    assert connection.delete(uniq_id(:foo))
+    cb.set(uniq_id(:foo), "bar")
+    assert cb.delete(uniq_id(:foo))
     assert_raises(Couchbase::Error::NotFound) do
-      connection.get(uniq_id(:foo))
+      cb.get(uniq_id(:foo))
     end
   end
 
   def test_simple_multi_delete
-    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port, :quiet => true)
-    connection.set(uniq_id(1) => "bar", uniq_id(2) => "foo")
-    res = connection.delete(uniq_id(1), uniq_id(2))
+    cb.quiet = true
+    cb.set(uniq_id(1) => "bar", uniq_id(2) => "foo")
+    res = cb.delete(uniq_id(1), uniq_id(2))
     assert res.is_a?(Hash)
     assert res[uniq_id(1)]
     assert res[uniq_id(2)]
+  ensure
+    cb.quiet = false
   end
 
   def test_simple_multi_delete_missing
-    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port, :quiet => true)
-    connection.set(uniq_id(1) => "bar", uniq_id(2) => "foo")
-    res = connection.delete(uniq_id(1), uniq_id(:missing), :quiet => true)
+    cb.quiet = true
+    cb.set(uniq_id(1) => "bar", uniq_id(2) => "foo")
+    res = cb.delete(uniq_id(1), uniq_id(:missing), :quiet => true)
     assert res.is_a?(Hash)
     assert res[uniq_id(1)]
     refute res[uniq_id(:missing)]
+  ensure
+    cb.quiet = false
   end
 
   def test_multi_delete_with_cas_check
     skip
-    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port, :quiet => true)
-    cas = connection.set(uniq_id(1) => "bar", uniq_id(2) => "foo")
-    res = connection.delete(uniq_id(1) => cas[uniq_id(1)], uniq_id(2) => cas[uniq_id(2)])
+    cb.quiet = true
+    cas = cb.set(uniq_id(1) => "bar", uniq_id(2) => "foo")
+    res = cb.delete(uniq_id(1) => cas[uniq_id(1)], uniq_id(2) => cas[uniq_id(2)])
     assert res.is_a?(Hash)
     assert res[uniq_id(1)]
     assert res[uniq_id(2)]
+  ensure
+    cb.quiet = false
   end
 
   def test_multi_delete_missing_with_cas_check
     skip
-    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port, :quiet => true)
-    cas = connection.set(uniq_id(1) => "bar", uniq_id(2) => "foo")
-    res = connection.delete(uniq_id(1) => cas[uniq_id(1)], uniq_id(:missing) => cas[uniq_id(2)])
+    cb.quiet = true
+    cas = cb.set(uniq_id(1) => "bar", uniq_id(2) => "foo")
+    res = cb.delete(uniq_id(1) => cas[uniq_id(1)], uniq_id(:missing) => cas[uniq_id(2)])
     assert res.is_a?(Hash)
     assert res[uniq_id(1)]
     refute res[uniq_id(:missing)]
+  ensure
+    cb.quiet = false
   end
 
   def test_multi_delete_with_cas_check_mismatch
     skip
-    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port, :quiet => true)
-    cas = connection.set(uniq_id(1) => "bar", uniq_id(2) => "foo")
+    cb.quiet = true
+    cas = cb.set(uniq_id(1) => "bar", uniq_id(2) => "foo")
 
     assert_raises(Couchbase::Error::KeyExists) do
-      connection.delete(uniq_id(1) => cas[uniq_id(1)] + 1,
+      cb.delete(uniq_id(1) => cas[uniq_id(1)] + 1,
                         uniq_id(2) => cas[uniq_id(2)])
     end
+  ensure
+    cb.quiet = false
   end
 end

data/test/test_design_docs.rb

@@ -19,38 +19,28 @@ require File.join(File.dirname(__FILE__), 'setup')
 
 class TestDesignDocs < MiniTest::Test
 
-  def setup
-    @mock = start_mock
-    @cb = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
-  end
-
-  def teardown
-    stop_mock(@mock)
-    @cb.disconnect
-  end
-
   def test_save_design_doc
-    assert @cb.save_design_doc(design_doc)
+    assert cb.save_design_doc(design_doc)
   end
 
   def test_save_design_doc_with_bad_data
     assert_raises ArgumentError do
-      @cb.save_design_doc(123)
+      cb.save_design_doc(123)
     end
   end
 
   def test_delete_design_doc
-    @cb.save_design_doc(design_doc)
-    assert @cb.delete_design_doc('blog')
+    cb.save_design_doc(design_doc)
+    assert cb.delete_design_doc('blog')
   end
 
   def test_design_doc_access
-    @cb.save_design_doc(design_doc)
-    assert @cb.design_docs['blog']
+    cb.save_design_doc(design_doc)
+    assert cb.design_docs['blog']
   end
 
   def test_design_doc_missing_access
-    refute @cb.design_docs['missing']
+    refute cb.design_docs['missing']
   end
 
   def design_doc
@@ -69,4 +59,4 @@ class TestDesignDocs < MiniTest::Test
     }
   end
 
-end
+end

data/test/test_errors.rb

@@ -20,63 +20,54 @@ require 'digest/md5'
 
 class TestErrors < MiniTest::Test
 
-  def setup
-    @mock = start_mock
-  end
-
-  def teardown
-    stop_mock(@mock)
-  end
-
   def genkey(item)
     tuple = [item["author"], item["message"]]
     Digest::MD5.hexdigest(tuple.join('-'))
   end
 
   def test_graceful_add_with_collision
-    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
     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"}
     key2 = uniq_id(genkey(msg2))
 
-    connection.add(key1, msg1)
+    cb.add(key1, msg1)
     begin
-      connection.add(key2, msg2)
+      cb.add(key2, msg2)
     rescue Couchbase::Error::KeyExists => ex
       # using info from exception
       # it could be done with cas operation, but we can save one request
       # here (in real world cas operation will be more consistent because it
       # fetch fresh version from the cluster)
       #
-      # connection.cas(key2) do |msg|
+      # cb.cas(key2) do |msg|
       #   msg.merge("time" => [msg["time"], msg2["time"]])
       # end
       msg2 = msg1.merge("time" => [msg1["time"], msg2["time"]])
-      connection.set(key2, msg2, :cas => ex.cas)
+      cb.set(key2, msg2, :cas => ex.cas)
     end
 
     msg3 = {"author" => "foo", "message" => "hi all",
                 "time" => ["2012-01-12 11:29:09", "2012-01-12 11:29:30"]}
     key3 = uniq_id(genkey(msg3))
-    assert_equal msg3, connection.get(key3)
+    assert_equal msg3, cb.get(key3)
 
-    connection.run do |conn|
+    cb.run do |conn|
       msg4 = {"author" => "foo", "message" => "hi all", "time" => "2012-01-12 11:45:34"}
       key4 = uniq_id(genkey(msg4))
 
-      connection.add(key4, msg4) do |ret|
+      cb.add(key4, msg4) do |ret|
         assert_equal :add, ret.operation
         assert_equal key4, ret.key
         msg4 = msg3.merge("time" => msg3["time"] + [msg4["time"]])
-        connection.set(ret.key, msg4, :cas => ret.cas)
+        cb.set(ret.key, msg4, :cas => ret.cas)
       end
     end
 
     msg5 = {"author" => "foo", "message" => "hi all",
                 "time" => ["2012-01-12 11:29:09", "2012-01-12 11:29:30", "2012-01-12 11:45:34"]}
     key5 = uniq_id(genkey(msg5))
-    assert_equal msg5, connection.get(key5)
+    assert_equal msg5, cb.get(key5)
   end
 
 end

data/test/test_format.rb

@@ -25,20 +25,11 @@ class TestFormat < MiniTest::Test
     undef to_json rescue nil
   end
 
-  def setup
-    @mock = start_mock
-  end
-
-  def teardown
-    stop_mock(@mock)
-  end
-
   def test_default_document_format
     orig_doc = {'name' => 'Twoflower', 'role' => 'The tourist'}
-    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
-    assert_equal :document, connection.default_format
-    connection.set(uniq_id, orig_doc)
-    doc, flags, cas = connection.get(uniq_id, :extended => true)
+    assert_equal :document, cb.default_format
+    cb.set(uniq_id, orig_doc)
+    doc, flags, cas = cb.get(uniq_id, :extended => true)
     # assert_equal 0x00, flags & 0x11
     assert doc.is_a?(Hash)
     assert_equal 'Twoflower', doc['name']
@@ -51,9 +42,8 @@ class TestFormat < MiniTest::Test
       refute orig_doc.respond_to?(:to_s)
       refute orig_doc.respond_to?(:to_json)
 
-      connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port, :default_format => :document)
       assert_raises(Couchbase::Error::ValueFormat) do
-        connection.set(uniq_id, orig_doc)
+        cb.set(uniq_id, orig_doc)
       end
 
       class << orig_doc
@@ -61,7 +51,7 @@ class TestFormat < MiniTest::Test
           MultiJson.dump(:name => name, :role => role)
         end
       end
-      connection.set(uniq_id, orig_doc) # OK
+      cb.set(uniq_id, orig_doc) # OK
 
       class << orig_doc
         undef to_json
@@ -69,15 +59,14 @@ class TestFormat < MiniTest::Test
           MultiJson.dump(:name => name, :role => role)
         end
       end
-      connection.set(uniq_id, orig_doc) # OK
+      cb.set(uniq_id, orig_doc) # OK
     end
   end
 
   def test_it_could_dump_arbitrary_class_using_marshal_format
     orig_doc = ArbitraryClass.new("Twoflower", "The tourist")
-    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
-    connection.set(uniq_id, orig_doc, :format => :marshal)
-    doc, flags, cas = connection.get(uniq_id, :extended => true)
+    cb.set(uniq_id, orig_doc, :format => :marshal)
+    doc, flags, cas = cb.get(uniq_id, :extended => true)
     # assert_equal Couchbase::Bucket::FMT_MARSHAL, flags & Couchbase::Bucket::FMT_MASK
     assert doc.is_a?(ArbitraryClass)
     assert_equal 'Twoflower', doc.name
@@ -85,32 +74,34 @@ class TestFormat < MiniTest::Test
   end
 
   def test_it_accepts_only_string_in_plain_mode
+    skip
     connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port, :default_format => :plain)
-    connection.set(uniq_id, "1")
+    cb.set(uniq_id, "1")
 
     assert_raises(Couchbase::Error::ValueFormat) do
-      connection.set(uniq_id, 1)
+      cb.set(uniq_id, 1)
     end
 
     assert_raises(Couchbase::Error::ValueFormat) do
-      connection.set(uniq_id, {:foo => "bar"})
+      cb.set(uniq_id, {:foo => "bar"})
     end
   end
 
   def test_bignum_conversion
+    skip
     connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port, :default_format => :plain)
     cas = 0xffff_ffff_ffff_ffff
     assert cas.is_a?(Bignum)
     assert_raises(Couchbase::Error::NotFound) do
-      connection.delete(uniq_id => cas)
+      cb.delete(uniq_id => cas)
     end
   end
 
   def test_it_allows_to_turn_off_transcoder
     skip
     connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port, :transcoder => nil)
-    connection.set(uniq_id, "value", :flags => 0xffff_ffff)
-    doc, flags, _ = connection.get(uniq_id, :extended => true)
+    cb.set(uniq_id, "value", :flags => 0xffff_ffff)
+    doc, flags, _ = cb.get(uniq_id, :extended => true)
     assert_equal "value", doc
     assert_equal 0xffff_ffff, flags
   end
@@ -147,14 +138,13 @@ class TestFormat < MiniTest::Test
 
   def test_it_can_use_custom_transcoder
     skip
-    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
-    connection.transcoder = ZlibTranscoder.new(Couchbase::Transcoder::Document)
-    connection.set(uniq_id, {"foo" => "bar"})
-    doc, flags, _ = connection.get(uniq_id, :extended => true)
+    cb.transcoder = ZlibTranscoder.new(Couchbase::Transcoder::Document)
+    cb.set(uniq_id, {"foo" => "bar"})
+    doc, flags, _ = cb.get(uniq_id, :extended => true)
     assert_equal({"foo" => "bar"}, doc)
     assert_equal(ZlibTranscoder::FMT_ZLIB|Couchbase::Bucket::FMT_DOCUMENT, flags)
-    connection.transcoder = nil
-    doc = connection.get(uniq_id)
+    cb.transcoder = nil
+    doc = cb.get(uniq_id)
     assert_equal "x\x01\xABVJ\xCB\xCFW\xB2RJJ,R\xAA\x05\0\x1Dz\x044", doc
   end