couchbase 0.9.8 → 1.0.0

data/test/support/sample_design_doc.json

@@ -1,9 +0,0 @@
-{
-  "_id": "_design/test_it_creates_design_doc_from_io",
-  "language": "javascript",
-  "views": {
-    "all": {
-      "map": "function(doc){ if(doc.msg){ emit(doc._id, doc.msg) } }"
-    }
-  }
-}

data/test/test_couchdb.rb

@@ -1,98 +0,0 @@
-require File.join(File.dirname(__FILE__), 'setup')
-
-class TestCouchdb < MiniTest::Unit::TestCase
-  def setup
-    @bucket = Couchbase.new('http://localhost:8091/pools/default')
-  end
-
-  def test_that_it_could_connect_to_couchdb
-    server_uri = @bucket.next_node.couch_api_base[/http:\/\/[^\/]+/]
-    assert_equal %w(couchbase couchdb version), @bucket.http_get(server_uri).keys.sort
-  end
-
-  def test_that_it_raises_error_if_couch_api_isnt_implemented
-    bucket = Couchbase.new('http://localhost:8091/pools/default')
-    bucket.nodes.each{|node| node.couch_api_base = nil}
-    assert_raises(Couchbase::NotImplemented) do
-      bucket.design_docs
-    end
-  end
-
-  def test_that_it_could_create_doc_using_memcached_api
-    # cleanup
-    @bucket.delete(test_id) rescue Memcached::NotFound
-    @bucket.delete_design_doc(test_id)
-
-    @bucket[test_id] = {'msg' => 'hello world'}
-    @bucket.save_design_doc('_id' => "_design/#{test_id}",
-                            'views' => {'all' => {'map' => 'function(doc){if(doc.msg){emit(doc._id, doc.msg)}}'}})
-    assert_operation_completed { database_ready(@bucket) }
-    ddoc = @bucket.design_docs[test_id]
-    assert ddoc, "design document '_design/#{test_id}' not found"
-    doc = ddoc.all.detect{|doc| doc['id'] == test_id && doc['value'] == 'hello world'}
-    assert doc, "object '#{test_id}' not found"
-  end
-
-  def test_that_it_could_remove_design_doc
-    @bucket.delete_design_doc(test_id)
-    @bucket[test_id] = {'msg' => 'hello world'}
-    @bucket.save_design_doc('_id' => "_design/#{test_id}",
-                            'views' => {'all' => {'map' => 'function(doc){if(doc.msg){emit(doc._id, doc.msg)}}'}})
-    assert_operation_completed { database_ready(@bucket) }
-    ddoc = @bucket.design_docs[test_id]
-    assert ddoc, "design document '_design/#{test_id}' not found"
-    @bucket.delete_design_doc("_design/#{test_id}")
-    ddoc = @bucket.design_docs[test_id]
-    refute ddoc, "design document '_design/#{test_id}' still here"
-  end
-
-  def test_it_creates_design_doc_from_string
-    doc = <<-EOD
-      {
-        "_id": "_design/#{test_id}",
-        "language": "javascript",
-        "views": {
-          "all": {
-            "map": "function(doc){ if(doc.msg){ emit(doc._id, doc.msg) } }"
-          }
-        }
-      }
-    EOD
-
-    @bucket.delete_design_doc(test_id)
-    @bucket.save_design_doc(doc)
-    assert_operation_completed { database_ready(@bucket) }
-    assert @bucket.design_docs[test_id], "design document '_design/#{test_id}' not found"
-  end
-
-  def test_it_creates_design_doc_from_io
-    doc = File.open(File.join(File.dirname(__FILE__), 'support', 'sample_design_doc.json'))
-    @bucket.delete_design_doc(test_id)
-    @bucket.save_design_doc(doc)
-    assert_operation_completed { database_ready(@bucket) }
-    assert @bucket.design_docs[test_id], "design document '_design/#{test_id}' not found"
-  end
-
-  def test_it_creates_design_doc_from_hash
-    doc = {
-      "_id" => "_design/#{test_id}",
-      "language" => "javascript",
-      "views" => {
-        "all" => {
-          "map" => "function(doc){ if(doc.msg){ emit(doc._id, doc.msg) } }"
-        }
-      }
-    }
-
-    @bucket.delete_design_doc(test_id)
-    @bucket.save_design_doc(doc)
-    assert_operation_completed { database_ready(@bucket) }
-    assert @bucket.design_docs[test_id], "design document '_design/#{test_id}' not found"
-  end
-
-  protected
-
-  def test_id
-    name = caller.first[/.*[` ](.*)'/, 1]
-  end
-end

data/test/test_document.rb

@@ -1,11 +0,0 @@
-require 'minitest/autorun'
-require 'couchbase'
-
-class TestView < MiniTest::Unit::TestCase
-  def test_that_it_defines_views_for_design_documents_only
-    design_doc = Couchbase::Document.new(:mock, {'_id' => '_design/foo', 'views' => {'all' => {'map' => 'function(doc){}'}}})
-    assert_respond_to(design_doc, :all)
-    regular_doc = Couchbase::Document.new(:mock, {'_id' => 'foo', 'views' => {'all' => {'map' => 'function(doc){}'}}})
-    refute_respond_to(regular_doc, :all)
-  end
-end

data/test/test_latch.rb

@@ -1,88 +0,0 @@
-require File.join(File.dirname(__FILE__), 'setup')
-
-class TestLatch < MiniTest::Unit::TestCase
-    def test_properly_initialize
-      l = Couchbase::Latch.new(true, false)
-      assert_equal(true, l.state)
-      assert_equal(false, l.target)
-    end
-
-    def test_basic_latch_usage
-      latch = Couchbase::Latch.new(:dirty, :ready)
-      obj = "bar"
-      Thread.new do
-        obj = "foo"
-        latch.toggle
-      end
-      latch.wait
-      assert_equal(:ready, latch.state)
-      assert_equal("foo", obj)
-    end
-
-    def test_basic_latch_usage_inverted
-      latch = Couchbase::Latch.new(:dirty, :ready)
-      obj = "bar"
-      Thread.new do
-        latch.wait
-        assert_equal(:ready, latch.state)
-        assert_equal("foo", obj)
-      end
-      obj = "foo"
-      latch.toggle
-    end
-
-    def test_latch_with_identical_values_skips_wait
-      latch = Couchbase::Latch.new(:ready, :ready)
-      latch.wait
-      assert_equal(:ready, latch.state)
-    end
-
-    def test_toggle_with_two_chained_threads
-      latch = Couchbase::Latch.new(:start, :end)
-      name = "foo"
-      Thread.new do
-        Thread.new do
-          name = "bar"
-          latch.toggle
-        end
-      end
-      latch.wait
-      assert_equal(:end, latch.state)
-      assert_equal("bar", name)
-    end
-
-    def test_toggle_with_multiple_waiters
-      proceed_latch = Couchbase::Latch.new(:start, :end)
-      result = :bar
-      Thread.new do
-        proceed_latch.wait
-        assert_equal(:foo, result)
-      end
-      Thread.new do
-        proceed_latch.wait
-        assert_equal(:foo, result)
-      end
-      assert_equal(:bar, result)
-      proceed_latch.toggle
-      assert_equal(:end, proceed_latch.state)
-    end
-
-    def test_interleaved_latches
-      check_latch = Couchbase::Latch.new(:dirty, :ready)
-      change_1_latch = Couchbase::Latch.new(:dirty, :ready)
-      change_2_latch = Couchbase::Latch.new(:dirty, :ready)
-      name = "foo"
-      Thread.new do
-        name = "bar"
-        change_1_latch.toggle
-        check_latch.wait
-        name = "man"
-        change_2_latch.toggle
-      end
-      change_1_latch.wait
-      assert_equal("bar", name)
-      check_latch.toggle
-      change_2_latch.wait
-      assert_equal("man", name)
-    end
-end

data/test/test_memcached.rb

@@ -1,59 +0,0 @@
-require File.join(File.dirname(__FILE__), 'setup')
-
-class TestMemcached < MiniTest::Unit::TestCase
-
-  def test_race_absence_during_initialization
-    session = connect
-    assert_raises(Memcached::NotFound) do
-      session.get(test_id)
-    end
-  end
-
-  def test_experimental_features_is_always_on
-    assert_respond_to connect, :touch
-    assert_respond_to connect(:experimental_features => false), :touch
-    assert_respond_to connect('experimental_features' => false), :touch
-  end
-
-  def test_single_get
-    session = connect
-    session.set(test_id, "foo")
-    assert "foo", session.get(test_id)
-  end
-
-  def test_single_get_missing
-    assert_raises(Memcached::NotFound) do
-      connect.get("missing-key")
-    end
-  end
-
-  def test_multi_get
-    session = connect
-    session.set(test_id(1), "foo")
-    session.set(test_id(2), "bar")
-    expected = {test_id(1) => "foo", test_id(2) => "bar"}
-    assert expected, session.get(test_id(1), test_id(2))
-    ids = [1, 2].map{|n| test_id(n)}
-    assert expected, session.get(ids)
-  end
-
-  def test_multi_get_missing
-    session = connect
-    session.set(test_id(1), "foo")
-    expected = {test_id(1) => "foo"}
-    assert expected, session.get(test_id(1), test_id(2))
-    ids = [1, 2].map{|n| test_id(n)}
-    assert expected, session.get(ids)
-  end
-
-  protected
-
-  def connect(options = {})
-    uri = options.delete(:pool_uri) || "http://localhost:8091/pools/default"
-    Couchbase.new(uri, options)
-  end
-
-  def test_id(suffix = nil)
-    "#{caller.first[/.*[` ](.*)'/, 1]}#{suffix}"
-  end
-end

data/test/test_rest_client.rb

@@ -1,14 +0,0 @@
-require 'minitest/autorun'
-require 'couchbase'
-
-class TestRestClient < MiniTest::Unit::TestCase
-  class RestClientMock
-    extend Couchbase::RestClient
-  end
-
-  def test_that_build_uri_duplicates_string
-    uri = "http://example.com/"
-    assert_equal "http://example.com/?foo=bar", RestClientMock.send(:build_query, uri, {'foo' => 'bar'})
-    assert_equal "http://example.com/", uri
-  end
-end

data/test/test_view.rb

@@ -1,98 +0,0 @@
-require File.join(File.dirname(__FILE__), 'setup')
-
-class TestView < MiniTest::Unit::TestCase
-  def test_pagination
-    connection = populate_database
-    view = connection.design_docs['test_view'].all
-
-    # fetch all records
-    collection = view.fetch(:limit => 10)
-    assert_equal 10, collection.size
-    assert_equal 100, collection.total_entries
-
-    # fetch with reduce
-    view = connection.design_docs['test_view'].sum
-    docs = view.fetch(:limit => 2, :group => true)
-    assert_equal 2, docs.size
-    assert_equal nil, docs.total_entries
-
-    assert_instance_of Couchbase::View, connection.all_docs
-  end
-
-  def test_when_stream_has_errors_it_raises_error_by_default
-    response = <<-EOR
-      {
-        "total_rows": 0,
-        "rows": [ ],
-        "errors": [
-          {
-            "from": "127.0.0.1:5984",
-            "reason": "Design document `_design/testfoobar` missing in database `test_db_b`."
-          },
-          {
-            "from": "http:// localhost:5984/_view_merge/",
-            "reason": "Design document `_design/testfoobar` missing in database `test_db_c`."
-          }
-        ]
-      }
-    EOR
-    view = Couchbase::View.new(stub(:curl_easy => response),
-                               "http://localhost:5984/default/_design/test/_view/all")
-    assert_raises(Couchbase::ViewError) do
-      view.fetch
-    end
-  end
-
-  def test_when_stream_has_errors_and_error_callback_provided_it_executes_the_callback
-    response = <<-EOR
-      {
-        "total_rows": 0,
-        "rows": [ ],
-        "errors": [
-          {
-            "from": "127.0.0.1:5984",
-            "reason": "Design document `_design/testfoobar` missing in database `test_db_b`."
-          },
-          {
-            "from": "http:// localhost:5984/_view_merge/",
-            "reason": "Design document `_design/testfoobar` missing in database `test_db_c`."
-          }
-        ]
-      }
-    EOR
-    view = Couchbase::View.new(stub(:curl_easy => response),
-                               "http://localhost:5984/default/_design/test/_view/all")
-    errcount = 0
-    view.on_error{|from, reason| errcount += 1}
-    view.fetch
-    assert 2, errcount
-  end
-
-  protected
-
-  def populate_database
-    connection = Couchbase.new('http://localhost:8091/pools/default')
-    # clear storage
-    connection.flush
-    # save 100 documents
-    toys = %w(buzz rex bo hamm slink potato)
-    100.times do |t|
-      connection["test_view_#{t}"]= {:counter => t+1, :toy => toys[t%6]}
-    end
-
-    connection.delete_design_doc('test_view')
-    connection.save_design_doc('_id' => '_design/test_view',
-                               'views' => {
-                                 'all' => {'map' => 'function(doc){if(doc.counter){emit(doc._id, doc)}}'},
-                                 'sum' => {'map' => 'function(doc){if(doc.counter){emit(doc.toy, doc.counter)}}',
-                                           'reduce' => 'function(keys,values,rereduce){return sum(values)}'}})
-
-    assert connection.design_docs['test_view']
-
-    assert_operation_completed do
-      database_ready(connection) && connection.all_docs.count > 100
-    end
-    connection
-  end
-
-end