couchbase-jruby-client 0.1.0-java → 0.1.5-java

data/test/test_bucket.rb

@@ -20,31 +20,32 @@ require File.join(File.dirname(__FILE__), 'setup')
 class TestBucket < MiniTest::Test
 
   def test_it_substitute_default_parts_to_url
-
-    with_mock(:host => 'localhost') do |mock| # pick first free port
+    with_configs(:host => 'localhost') do |configs| # pick first free port
       connections = [
-        Couchbase.new("http://#{mock.host}:#{mock.port}"),
-        Couchbase.new(:port => mock.port),
-        Couchbase.new("http://#{mock.host}:8091", :port => mock.port)
+        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 mock.port, connection.port
-        assert_equal "#{mock.host}:#{mock.port}", connection.authority
-        assert_equal "http://#{mock.host}:#{mock.port}/pools/default/buckets/default/", connection.url
+        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_mock(:host => '127.0.0.1') do |mock|
+    with_configs(:host => '127.0.0.1') do |configs|
       connections = [
-        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)
+        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 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
+        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
 
@@ -70,32 +71,36 @@ class TestBucket < MiniTest::Test
   end
 
   def test_it_able_to_connect_to_protected_buckets
-    with_mock(:buckets_spec => 'protected:secret') do |mock|
-      connection = Couchbase.new(:hostname => mock.host,
-                                 :port => mock.port,
+    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
-    with_mock(:buckets_spec => 'protected:secret') do |mock|
-      connection = Couchbase.new("http://protected:secret@#{mock.host}:#{mock.port}/pools/default/buckets/protected/")
+    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
-    with_mock do |mock|
+    with_configs do |configs|
       assert_raises Couchbase::Error::Auth do
-        Couchbase.new(:hostname => mock.host,
-                      :port => mock.port,
+        Couchbase.new(:hostname => configs.host,
+                      :port => configs.port,
                       :bucket => 'default',
                       :username => 'wrong.username',
                       :password => 'wrong_password')
@@ -104,17 +109,18 @@ class TestBucket < MiniTest::Test
   end
 
   def test_it_unable_to_connect_to_protected_buckets_with_wrong_credentials
-    with_mock(:buckets_spec => 'protected:secret') do |mock|
+    skip
+    with_configs(:buckets_spec => 'protected:secret') do |configs|
       assert_raises Couchbase::Error::Auth do
-        Couchbase.new(:hostname => mock.host,
-                      :port => mock.port,
+        Couchbase.new(:hostname => configs.host,
+                      :port => configs.port,
                       :bucket => 'protected',
                       :username => 'wrong',
                       :password => 'secret')
       end
       assert_raises Couchbase::Error::Auth do
-        Couchbase.new(:hostname => mock.host,
-                      :port => mock.port,
+        Couchbase.new(:hostname => configs.host,
+                      :port => configs.port,
                       :bucket => 'protected',
                       :username => 'protected',
                       :password => 'wrong')
@@ -123,14 +129,15 @@ class TestBucket < MiniTest::Test
   end
 
   def test_it_allows_change_quiet_flag
-    with_mock do |mock|
-      connection = Couchbase.new(:hostname => mock.host,
-                                 :port => mock.port)
+    with_configs do |configs|
+      connection = Couchbase.new(:hostname => configs.host,
+                                 :port => configs.port)
 
       refute connection.quiet?
 
-      connection = Couchbase.new(:hostname => mock.host,
-                                 :port => mock.port,
+      connection.disconnect
+      connection = Couchbase.new(:hostname => configs.host,
+                                 :port => configs.port,
                                  :quiet => true)
       assert connection.quiet?
 
@@ -139,30 +146,32 @@ class TestBucket < MiniTest::Test
 
       connection.quiet = :foo
       assert_equal true, connection.quiet?
+      connection.disconnect
     end
   end
 
   def test_it_is_connected
-    with_mock do |mock|
-      connection = Couchbase.new(:hostname => mock.host,
-                                 :port => mock.port)
+    with_configs do |configs|
+      connection = Couchbase.new(:hostname => configs.host,
+                                 :port => configs.port)
       assert connection.connected?
+      connection.disconnect
     end
   end
 
   def test_it_is_possible_to_disconnect_instance
-    with_mock do |mock|
-      connection = Couchbase.new(:hostname => mock.host,
-                                 :port => mock.port)
+    with_configs do |configs|
+      connection = Couchbase.new(:hostname => configs.host,
+                                 :port => configs.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)
+    with_configs do |configs|
+      connection = Couchbase.new(:hostname => configs.host,
+                                 :port => configs.port)
       connection.disconnect
       assert_raises Couchbase::Error::Connect do
         connection.disconnect
@@ -171,43 +180,48 @@ class TestBucket < MiniTest::Test
   end
 
   def test_it_allows_to_reconnect_the_instance
-    with_mock do |mock|
-      connection = Couchbase.new(:hostname => mock.host,
-                                 :port => mock.port)
+    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
   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')
+    skip
+    with_configs do |configs|
+      connection = Couchbase.new(:quiet => true)
+      assert connection.quiet?
       connection.disconnect
-      assert_raises Couchbase::Error::Auth do
-        connection.reconnect(:password => 'incorrect')
-      end
-      refute connection.connected?
 
-      connection.reconnect(:password => 'secret')
-      assert connection.connected?
+      connection.reconnect(:quiet => false)
+      refute connection.quiet?
+      connection.disconnect
     end
   end
 
   def test_it_uses_bucket_name_as_username_if_username_is_empty
-    with_mock(:buckets_spec => 'protected:secret') do |mock|
-      connection = Couchbase.new(:hostname => mock.host,
-                                 :port => mock.port,
+    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
+
 end

data/test/test_cas.rb

@@ -19,33 +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
-    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port,
-                               :default_format => :document)
-    connection.set(uniq_id, {"bar" => 1})
+    skip
+    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
@@ -61,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,13 +16,21 @@
 #
 
 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_configs do |configs|
+      assert_instance_of Couchbase::Bucket, Couchbase.bucket
+      assert_equal Couchbase.bucket, Couchbase.bucket
     end
   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

@@ -0,0 +1,62 @@
+# 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')
+
+class TestDesignDocs < MiniTest::Test
+
+  def test_save_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)
+    end
+  end
+
+  def test_delete_design_doc
+    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']
+  end
+
+  def test_design_doc_missing_access
+    refute cb.design_docs['missing']
+  end
+
+  def design_doc
+    {
+      '_id'      => '_design/blog',
+      'language' => 'javascript',
+      'views' => {
+        'recent_posts' => {
+          'map' => <<-JS
+            function (doc, meta) {
+              emit(doc.name);
+            }
+          JS
+        }
+      }
+    }
+  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