couchbase 0.9.8 → 1.0.0

data/test/test_arithmetic.rb

@@ -0,0 +1,98 @@
+# 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')
+
+class TestArithmetic < MiniTest::Unit::TestCase
+
+  def setup
+    @mock = start_mock
+  end
+
+  def teardown
+    stop_mock(@mock)
+  end
+
+  def test_trivial_incr_decr
+    connection = Couchbase.new(:port => @mock.port)
+
+    connection.set(test_id, 1)
+    val = connection.incr(test_id)
+    assert_equal 2, val
+    val = connection.get(test_id)
+    assert_equal 2, val
+
+    connection.set(test_id, 7)
+    val = connection.decr(test_id)
+    assert_equal 6, val
+    val = connection.get(test_id)
+    assert_equal 6, val
+  end
+
+  def test_it_fails_to_incr_decr_missing_key
+    connection = Couchbase.new(:port => @mock.port)
+
+    assert_raises(Couchbase::Error::NotFound) do
+      connection.incr(test_id(:missing))
+    end
+    assert_raises(Couchbase::Error::NotFound) do
+      connection.decr(test_id(:missing))
+    end
+  end
+
+  def test_it_creates_missing_key_when_initial_value_specified
+    connection = Couchbase.new(:port => @mock.port)
+
+    val = connection.incr(test_id(:missing), :initial => 5)
+    assert_equal 5, val
+    val = connection.incr(test_id(:missing), :initial => 5)
+    assert_equal 6, val
+    val = connection.get(test_id(:missing))
+    assert_equal 6, val
+  end
+
+  def test_it_uses_zero_as_default_value_for_missing_keys
+    connection = Couchbase.new(:port => @mock.port)
+
+    val = connection.incr(test_id(:missing), :create => true)
+    assert_equal 0, val
+    val = connection.incr(test_id(:missing), :create => true)
+    assert_equal 1, val
+    val = connection.get(test_id(:missing))
+    assert_equal 1, val
+  end
+
+  def test_it_allows_custom_ttl
+    connection = Couchbase.new(:port => @mock.port)
+
+    val = connection.incr(test_id(:missing), :create => true, :ttl => 1)
+    assert_equal 0, val
+    val = connection.incr(test_id(:missing), :create => true)
+    assert_equal 1, val
+    sleep(1)
+    refute connection.get(test_id(:missing))
+  end
+
+  def test_it_allows_custom_delta
+    connection = Couchbase.new(:port => @mock.port)
+
+    connection.set(test_id, 12)
+    val = connection.incr(test_id, 10)
+    assert_equal 22, val
+  end
+
+end

data/test/test_async.rb

@@ -0,0 +1,211 @@
+# 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')
+
+class TestAsync < MiniTest::Unit::TestCase
+
+  def setup
+    @mock = start_mock
+  end
+
+  def teardown
+    stop_mock(@mock)
+  end
+
+  def test_result_object_provides_enough_info
+    obj = Couchbase::Result.new
+    assert obj.respond_to?(:success?)
+    assert obj.respond_to?(:error)
+    assert obj.respond_to?(:key)
+    assert obj.respond_to?(:value)
+    assert obj.respond_to?(:node)
+    assert obj.respond_to?(:cas)
+    assert obj.respond_to?(:flags)
+  end
+
+  def test_it_requires_block_for_running_loop
+    connection = Couchbase.new(:port => @mock.port)
+    refute connection.async?
+    assert_raises(LocalJumpError) do
+      connection.run
+    end
+    connection.run do |conn|
+      assert conn.async?
+    end
+  end
+
+  def test_it_resets_async_flag_when_raising_exception_from_callback
+    connection = Couchbase.new(:port => @mock.port)
+
+    assert_raises(RuntimeError) do
+      connection.run do |conn|
+        conn.set(test_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.run do |conn|
+      conn.get(test_id) do
+        conn.get(test_id(:hit)) do |res|
+          conn.set(test_id(:hit), res.value + 1)
+        end
+      end
+    end
+
+    val = connection.get(test_id(:hit))
+    assert_equal 1, val
+  end
+
+  def test_nested_async_set_get
+    connection = Couchbase.new(:port => @mock.port)
+    val = nil
+
+    connection.run do |conn|
+      conn.set(test_id, "foo") do
+        conn.get(test_id) do |res|
+          val = res.value
+        end
+      end
+    end
+
+    assert_equal "foo", val
+  end
+
+  def test_nested_async_touch_get
+    connection = Couchbase.new(:port => @mock.port)
+    connection.set(test_id, "foo")
+    success = false
+    val = nil
+
+    connection.run do |conn|
+      conn.touch(test_id, :ttl => 1) do |res1|
+        success = res1.success?
+        conn.get(test_id) do |res2|
+          val = res2.value
+        end
+      end
+    end
+
+    assert success
+    assert_equal "foo", val
+    sleep(1)
+    refute connection.get(test_id)
+  end
+
+  def test_nested_async_delete_get
+    connection = Couchbase.new(:port => @mock.port)
+    cas = connection.set(test_id, "foo")
+    success = false
+    val = :unknown
+
+    connection.run do |conn|
+      conn.delete(test_id, :cas => cas) do |res1|
+        success = res1.success?
+        conn.get(test_id) do |res2|
+          val = res2.value
+        end
+      end
+    end
+
+    assert success
+    refute val
+  end
+
+  def test_nested_async_stats_set
+    connection = Couchbase.new(:port => @mock.port)
+    stats = {}
+
+    connection.run do |conn|
+      conn.stats do |res1|
+        id = test_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
+    connection = Couchbase.new(:port => @mock.port)
+    cas = connection.set(test_id, "foo")
+    res = {}
+
+    connection.run do |conn|
+      conn.flush do |res1|
+        assert res1.success?
+        id = test_id(res1.node)
+        res[id] = false
+        conn.set(id, true) do |res2|
+          res[id] = res2.cas
+        end
+      end
+    end
+
+    refute connection.get(test_id)
+    res.keys.each do |key|
+      assert res[key].is_a?(Numeric)
+      assert connection.get(key)
+    end
+  end
+
+  def test_nested_async_incr_get
+    connection = Couchbase.new(:port => @mock.port)
+    cas = connection.set(test_id, 1)
+    val = nil
+
+    connection.run do |conn|
+      conn.incr(test_id) do
+        conn.get(test_id) do |res|
+          val = res.value
+        end
+      end
+    end
+
+    assert_equal 2, val
+  end
+
+  def test_it_doesnt_accept_callbacks_in_synchronous_mode
+    connection = Couchbase.new(: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.flush {} }
+    assert_raises(ArgumentError) { connection.stats {} }
+  end
+
+end

data/test/test_bucket.rb

@@ -1,39 +1,142 @@
+# 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')
 
 class TestBucket < MiniTest::Unit::TestCase
-  def setup
-    config_fixture = json_fixture('buckets-config.json')
-    Couchbase::Bucket.any_instance.stubs(:http_get).returns(config_fixture)
-    Couchbase::Bucket.class_eval do
-      alias :listen_for_config_changes_orig :listen_for_config_changes
-      define_method :listen_for_config_changes do
-        setup(config_fixture.first)
+
+  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
+
+      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
+
+    with_mock do |mock| # pick first free port
+      connections = [
+        Couchbase.new("http://localhost:#{mock.port}"),
+        Couchbase.new(:port => mock.port),
+        Couchbase.new('http://localhost: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
+      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)
+      ]
+      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
+      end
+    end
+  end
+
+  def test_it_raises_network_error_if_server_not_found
+    refute(`netstat -tnl` =~ /12345/)
+    assert_raises Couchbase::Error::Network do
+      Couchbase.new(:port => 12345)
+    end
   end
 
-  def teardown
-    Couchbase::Bucket.class_eval do
-      alias :listen_for_config_changes :listen_for_config_changes_orig
+  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_should_defaults_to_default_bucket_in_production_mode
-    bucket = Couchbase.new('http://localhost:8091/pools/default')
-    assert_equal 'default', bucket.name
-    assert_equal :production, bucket.environment
+  def test_it_able_to_connect_to_protected_buckets
+    with_mock(:buckets_spec => 'protected:secret') do |mock|
+      connection = Couchbase.new(:port => mock.port,
+                                 :bucket => 'protected',
+                                 :username => 'protected',
+                                 :password => 'secret')
+      assert_equal "protected", connection.bucket
+      assert_equal "protected", connection.username
+      assert_equal "secret", connection.password
+    end
   end
 
-  def test_it_should_initialize_itself_from_config
-    bucket = Couchbase.new('http://localhost:8091/pools/default')
-    assert_equal 'http://localhost:8091/pools/default/buckets/default', bucket.uri.to_s
-    assert_equal 'membase', bucket.type
-    assert_equal 1, bucket.nodes.size
-    assert_equal 256, bucket.vbuckets.size
+  def test_it_raises_error_with_wrong_credentials
+    with_mock(:buckets_spec => 'protected:secret') do |mock|
+      assert_raises Couchbase::Error::Libcouchbase do
+        Couchbase.new(:port => mock.port,
+                      :bucket => 'protected',
+                      :username => 'wrong',
+                      :password => 'secret')
+      end
+      assert_raises Couchbase::Error::Libcouchbase do
+        Couchbase.new(:port => mock.port,
+                      :bucket => 'protected',
+                      :username => 'protected',
+                      :password => 'wrong')
+      end
+    end
   end
 
-  def test_initialization_low_level_drivers
-    bucket = Couchbase.new('http://localhost:8091/pools/default', :format => :plain)
-    assert_equal :plain, bucket.default_format
+  def test_it_allows_change_quiet_flag
+    with_mock do |mock|
+      connection = Couchbase.new(:port => mock.port)
+      assert connection.quiet?
+
+      connection = Couchbase.new(:port => mock.port, :quiet => true)
+      assert connection.quiet?
+
+      connection.quiet = nil
+      assert_equal false, connection.quiet?
+
+      connection.quiet = :foo
+      assert_equal true, connection.quiet?
+    end
   end
 end