riak-client 2.5.0 → 2.6.0

data/spec/riak/search/index_spec.rb

@@ -1,72 +0,0 @@
-require 'spec_helper'
-require 'riak/search/index'
-
-describe Riak::Search::Index do
-  let(:index_name){ 'index_name' }
-  let(:schema_name){ 'schema_name' }
-
-  let(:index_exists_expectation) do
-    expect(backend).to receive(:get_search_index).
-      with(index_name).
-      and_return(index_exists_response)
-  end
-
-  let(:index_exists_response) do
-    instance_double(
-                    'Riak::Client::BeefcakeProtobuffsBackend::RpbYokozunaIndexGetResp',
-                    index: [{ name: index_name, schema: schema_name, n_val: 3 }]
-                    )
-  end
-
-  let(:client){ instance_double 'Riak::Client' }
-  let(:backend) do
-    be = instance_double 'Riak::Client::BeefcakeProtobuffsBackend'
-    allow(client).to receive(:backend).and_yield(be)
-    be
-  end
-
-  subject { described_class.new client, index_name }
-
-  it 'creates index objects with a client and index name' do
-    expect{ described_class.new client, index_name }.to_not raise_error
-  end
-
-  it 'tests for index existence' do
-    index_exists_expectation
-    expect(subject).to be_exists
-  end
-
-  it 'permits index creation' do
-    expect(backend).to receive(:get_search_index).
-      with(index_name).
-      and_raise(Riak::ProtobuffsFailedRequest.new(:not_found, 'not found'))
-
-    expect(backend).to receive(:create_search_index).
-      with(index_name, nil, nil, nil)
-
-    expect{ subject.create! }.to_not raise_error
-  end
-
-  it 'raises an error when creating an index that already exists' do
-    index_exists_expectation
-
-    expect{ subject.create! }.
-      to raise_error(Riak::SearchError::IndexExistsError)
-  end
-
-    it "spawns a query" do
-      t = "some query term"
-      expect(subject).to receive(:exists?).and_return(true)
-      expect(query = subject.query(t)).to be_a Riak::Search::Query
-      expect(query.term).to eq t
-      expect(query.index).to eq subject
-      expect(query.client).to eq subject.client
-    end
-
-  it 'returns data about the index' do
-    index_exists_expectation
-
-    expect(subject.n_val).to eq 3
-    expect(subject.schema).to eq schema_name
-  end
-end

data/spec/riak/search/query_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-require 'riak/search/query'
-
-describe Riak::Search::Query do
-  let(:client) do
-    instance_double('Riak::Client').tap do |c|
-      allow(c).to receive(:backend).and_yield(backend)
-    end
-  end
-  let(:index) do
-    instance_double(
-                    'Riak::Search::Index',
-                    name: index_name,
-                    'exists?' => true).tap do |i|
-      allow(i).to receive(:is_a?).with(String).and_return(false)
-      allow(i).to receive(:is_a?).with(Riak::Search::Index).and_return(true)
-    end
-  end
-  let(:backend){ instance_double 'Riak::Client::BeefcakeProtobuffsBackend' }
-
-  let(:index_name){ 'yokozuna' }
-  let(:term){ 'bitcask' }
-
-  let(:raw_results) do
-    {
-      "max_score"=>0.7729485034942627,
-      "num_found"=>3,
-      "docs"=>[
-               {"score"=>"7.72948500000000038312e-01",
-                 "_yz_rb"=>"search_test-1419261439-ew70sak2qr",
-                 "_yz_rt"=>"yokozuna",
-                 "_yz_rk"=>"bitcask-10"},
-               {"score"=>"2.35808490000000009479e-01",
-                 "_yz_rb"=>"search_test-1419261439-ew70sak2qr",
-                 "_yz_rt"=>"yokozuna",
-                 "_yz_rk"=>"bitcask-9"},
-               {"score"=>"6.73738599999999937529e-02",
-                 "_yz_rb"=>"search_test-1419261439-ew70sak2qr",
-                 "_yz_rt"=>"yokozuna",
-                 "_yz_rk"=>"bitcask-4"}
-              ]
-    }
-  end
-
-  subject { described_class.new client, index, term }
-
-  it 'creates query objects with a client, index, and query string' do
-    expect{ described_class.new client, index, term }.to_not raise_error
-  end
-
-  it 'creates query objects with a client, index name, and query string' do
-    class_double('Riak::Search::Index', new: index).as_stubbed_const
-    allow(index).to receive(:is_a?).with(Riak::Search::Index).and_return(true)
-
-    expect{ described_class.new client, index_name, term }.to_not raise_error
-  end
-
-  it 'errors when querying with a non-existent index' do
-    expect(index).to receive(:exists?).and_return(false)
-    expect{ described_class.new client, index, term }.to raise_error(Riak::SearchError::IndexNonExistError)
-  end
-
-  it 'allows specifying other query options on creation' do
-    expect(backend).to receive(:search).
-      with(index_name, term, hash_including(rows: 5)).
-      and_return(raw_results)
-
-    q = described_class.new client, index, term, rows: 5
-    expect{ q.results }.to_not raise_error
-  end
-
-  it 'allows specifying query options with accessors' do
-    expect(backend).to receive(:search).
-      with(index_name, term, hash_including(rows: 5)).
-      and_return(raw_results)
-
-    subject.rows = 5
-    expect{ subject.results }.to_not raise_error
-  end
-
-  it 'returns a ResultCollection' do
-    expect(backend).to receive(:search).
-      with(index_name, term, instance_of(Hash)).
-      and_return(raw_results)
-
-    expect(subject.results).to be_a Riak::Search::ResultCollection
-  end
-end

data/spec/riak/search/result_collection_spec.rb

@@ -1,89 +0,0 @@
-require 'spec_helper'
-require 'riak/search/result_collection'
-
-describe Riak::Search::ResultCollection, crdt_search_fixtures: true do
-  let(:client) do
-    instance_double('Riak::Client').tap do |c|
-      allow(c).to receive(:bucket_type).
-        with(bucket_type_name).
-        and_return(bucket_type)
-    end
-  end
-
-  let(:bucket_type) do
-    instance_double('Riak::BucketType').tap do |bt|
-      allow(bt).to receive(:bucket).
-        with(bucket_name).
-        and_return(bucket)
-    end
-  end
-
-  let(:bucket) do
-    instance_double('Riak::BucketTyped::Bucket')
-  end
-
-  let(:backend) do
-    instance_double('Riak::Client::BeefcakeProtobuffsBackend').tap do |be|
-      allow(client).to receive(:backend).and_yield(be)
-    end
-  end
-
-  let(:results_hash) do
-    {
-      "max_score"=>0.7729485034942627,
-      "num_found"=>3,
-      "docs"=>[
-               {"score"=>"7.72948500000000038312e-01",
-                 "_yz_rb"=>"search_test-1419261439-ew70sak2qr",
-                 "_yz_rt"=>"yokozuna",
-                 "_yz_rk"=>"bitcask-10"},
-               {"score"=>"2.35808490000000009479e-01",
-                 "_yz_rb"=>"search_test-1419261439-ew70sak2qr",
-                 "_yz_rt"=>"yokozuna",
-                 "_yz_rk"=>"bitcask-9"},
-               {"score"=>"6.73738599999999937529e-02",
-                 "_yz_rb"=>"search_test-1419261439-ew70sak2qr",
-                 "_yz_rt"=>"yokozuna",
-                 "_yz_rk"=>"bitcask-4"},
-               map_raw
-              ]
-    }
-  end
-
-  let(:bucket_name){ 'search_test-1419261439-ew70sak2qr' }
-  let(:bucket_type_name){ 'yokozuna' }
-  let(:first_key){ 'bitcask-10' }
-  let(:first_result) do
-    instance_double('Riak::RObject').tap do |o|
-      allow(o).to receive(:key).and_return(first_key)
-    end
-  end
-
-  let(:fetch_first_expectation) do
-    expect(bucket).to receive(:get).with(first_key).and_return(first_result)
-  end
-
-  subject{ described_class.new client, results_hash }
-
-  it 'is creatable with a search results hash' do
-    expect{ described_class.new client, results_hash }.to_not raise_error
-  end
-
-  it 'exposes the raw search results hash' do
-    expect(subject.raw).to eq results_hash
-  end
-
-  it 'exposes the max score and entry scores' do
-    expect(subject.max_score).to eq results_hash['max_score']
-    expect(subject.docs.first.score).to eq Float(
-                                                 results_hash['docs'].
-                                                 first['score'])
-  end
-
-  it 'fetches individual documents on demand' do
-    fetch_first_expectation
-    allow(bucket_type).to receive(:data_type_class).and_return nil
-
-    expect(subject.first).to eq first_result
-  end
-end

data/spec/riak/search/result_document_spec.rb

@@ -1,106 +0,0 @@
-require 'spec_helper'
-require 'riak/search/result_document'
-
-describe Riak::Search::ResultDocument, crdt_search_fixtures: true do
-  let(:key){ 'bitcask-10' }
-  let(:bucket_name){ 'search_test' }
-  let(:bucket_type_name){ 'yokozuna' }
-  let(:score){ 43.21 }
-  let(:other_field){ 'banana' }
-
-  let(:client) do
-    instance_double('Riak::Client').tap do |c|
-      allow(c).to receive(:bucket_type).
-                   with(bucket_type_name).
-                   and_return(bucket_type)
-      allow(c).to receive(:bucket_type).
-                   with(maps_type_name).
-                   and_return(maps_bucket_type)
-    end
-  end
-
-  let(:bucket_type) do
-    instance_double('Riak::BucketType').tap do |bt|
-      allow(bt).to receive(:bucket).
-                    with(bucket_name).
-                    and_return(bucket)
-      allow(bt).to receive(:data_type_class).
-                    and_return(nil)
-    end
-  end
-
-  let(:bucket) do
-    instance_double('Riak::BucketTyped::Bucket').tap do |b|
-      allow(b).to receive(:get).
-        with(key).
-        and_return(robject)
-    end
-  end
-
-  let(:robject){ instance_double 'Riak::RObject' }
-
-  let(:raw) do
-    {
-      "score"=>score,
-      "_yz_rb"=>bucket_name,
-      "_yz_rt"=>bucket_type_name,
-      "_yz_rk"=>key,
-      'other_field'=>other_field
-    }
-  end
-
-  subject{ described_class.new client, raw }
-
-  it 'has key, bucket, bucket type, and score accessors' do
-    expect(subject.key).to eq key
-    expect(subject.bucket).to eq bucket
-    expect(subject.bucket_type).to eq bucket_type
-    expect(subject.score).to eq score
-  end
-
-  it 'makes other yz fields available' do
-    expect(subject[:other_field]).to eq other_field
-  end
-
-  describe 'identifying a key-value object' do
-    it 'fetches the robject it identifies' do
-      expect(subject.robject).to eq robject
-    end
-
-    it 'returns the data type class the document is' do
-      expect(subject.type_class).to eq Riak::RObject
-    end
-
-    it 'refuses to return a CRDT' do
-      expect{ subject.crdt }.to raise_error Riak::CrdtError::NotACrdt
-    end
-  end
-
-  describe 'identifying a CRDT map object' do
-    subject { map_results }
-
-    it 'returns the data type class the document is' do
-      expect(subject.type_class).to eq Riak::Crdt::Map
-    end
-
-    let(:fake_map){ instance_double 'Riak::Crdt::Map' }
-
-    it 'fetches the map it identifies' do
-      expect(Riak::Crdt::Map).
-        to receive(:new).
-            with(map_bucket, 'map-key', maps_bucket_type).
-            and_return(fake_map).
-            twice
-
-      expect(subject.map).to eq fake_map
-      expect(subject.crdt).to eq fake_map
-    end
-
-    it 'refuses to fetch a counter or set' do
-      expect{ subject.counter }.
-        to raise_error Riak::CrdtError::UnexpectedDataType
-      expect{ subject.set }.
-        to raise_error Riak::CrdtError::UnexpectedDataType
-    end
-  end
-end

data/spec/riak/search/schema_spec.rb

@@ -1,63 +0,0 @@
-require 'spec_helper'
-require 'riak/search/schema'
-
-describe Riak::Search::Schema do
-  let(:schema_name){ 'schema_name' }
-  let(:schema_content){ '<xml />' }
-
-  let(:schema_exists_expectation) do
-    expect(backend).to receive(:get_search_schema).
-      with(schema_name).
-      and_return(schema_exists_response)
-  end
-
-  let(:schema_exists_response) do
-    resp = instance_double 'Riak::Client::BeefcakeProtobuffsBackend::RpbYokozunaSchema'
-    allow(resp).to receive(:name).and_return(schema_name)
-    allow(resp).to receive(:content).and_return(schema_content)
-
-    resp
-  end
-
-  let(:client){ instance_double 'Riak::Client' }
-  let(:backend) do
-    be = instance_double 'Riak::Client::BeefcakeProtobuffsBackend'
-    allow(client).to receive(:backend).and_yield be
-    be
-  end
-
-  subject { described_class.new client, schema_name }
-
-  it 'creates schema objects with a client and schema name' do
-    expect{ described_class.new client, schema_name }.to_not raise_error
-  end
-
-  it 'tests for schema existence' do
-    schema_exists_expectation
-    expect(subject).to be_exists
-  end
-
-  it 'permits schema creation' do
-    expect(backend).to receive(:get_search_schema).
-      with(schema_name).
-      and_return(nil)
-
-    expect(backend).to receive(:create_search_schema).
-      with(schema_name, schema_content).
-      and_return(true)
-
-    expect{ subject.create! schema_content }.to_not raise_error
-  end
-
-  it 'raises an error when creating a schema that already exists' do
-    schema_exists_expectation
-
-    expect{ subject.create! schema_content }.to raise_error(Riak::SearchError::SchemaExistsError)
-  end
-
-  it 'returns data about the schema' do
-    schema_exists_expectation
-
-    expect(subject.content).to eq schema_content
-  end
-end

data/spec/riak/search_spec.rb

@@ -1,107 +0,0 @@
-require 'spec_helper'
-require 'rexml/document'
-
-describe "Search features" do
-  describe Riak::Client do
-    before :each do
-      @client = Riak::Client.new
-      @pb = double(Riak::Client::BeefcakeProtobuffsBackend)
-      allow(@client).to receive(:backend).and_yield(@pb)
-    end
-
-    describe "searching" do
-      it "searches the default index" do
-        expect(@pb).to receive(:search).with(nil, "foo", {}).and_return({})
-        @client.search("foo")
-      end
-
-      it "searches the default index with additional options" do
-        expect(@pb).to receive(:search).with(nil, 'foo', 'rows' => 30).and_return({})
-        @client.search("foo", 'rows' => 30)
-      end
-
-      it "searches the specified index" do
-        expect(@pb).to receive(:search).with('search', 'foo', {}).and_return({})
-        @client.search("search", "foo")
-      end
-    end
-  end
-
-  describe Riak::Bucket do
-    before :each do
-      @client = Riak::Client.new
-      @bucket = Riak::Bucket.new(@client, "foo")
-    end
-
-    def load_without_index_hook
-      @bucket.instance_variable_set(:@props, {"precommit" => [], "search" => false})
-    end
-
-    def load_with_index_hook
-      @bucket.instance_variable_set(:@props, {"precommit" => [{"mod" => "riak_search_kv_hook", "fun" => "precommit"}], "search" => true})
-    end
-
-    it "detects whether the indexing hook is installed" do
-      load_without_index_hook
-      expect(@bucket.is_indexed?).to be_falsey
-
-      load_with_index_hook
-      expect(@bucket.is_indexed?).to be_truthy
-    end
-
-    describe "enabling indexing" do
-      it "adds the index hook when not present" do
-        load_without_index_hook
-        expect(@bucket).to receive(:props=).with({"precommit" => [Riak::Bucket::SEARCH_PRECOMMIT_HOOK], "search" => true})
-        @bucket.enable_index!
-      end
-
-      it "doesn't modify the precommit when the hook is present" do
-        load_with_index_hook
-        expect(@bucket).not_to receive(:props=)
-        @bucket.enable_index!
-      end
-    end
-
-    describe "disabling indexing" do
-      it "removes the index hook when present" do
-        load_with_index_hook
-        expect(@bucket).to receive(:props=).with({"precommit" => [], "search" => false})
-        @bucket.disable_index!
-      end
-
-      it "doesn't modify the precommit when the hook is missing" do
-        load_without_index_hook
-        expect(@bucket).not_to receive(:props=)
-        @bucket.disable_index!
-      end
-    end
-  end
-
-  describe Riak::MapReduce do
-    before :each do
-      @client = Riak::Client.new
-      @mr = Riak::MapReduce.new(@client)
-    end
-
-    describe "using a search query as inputs" do
-      it "accepts a index name and query" do
-        @mr.search("foo", "bar OR baz")
-        expect(@mr.inputs).to eq({:module => "yokozuna", :function => "mapred_search", :arg => ["foo", "bar OR baz"]})
-      end
-
-      it "accepts a Riak::Search::Index and query" do
-        @mr.search(Riak::Search::Index.new(@client, "foo"), "bar OR baz")
-        expect(@mr.inputs).to eq({:module => "yokozuna", :function => "mapred_search", :arg => ["foo", "bar OR baz"]})
-      end
-
-      it "emits the Erlang function and arguments" do
-        @mr.search("foo", "bar OR baz")
-        expect(@mr.to_json).to include('"inputs":{')
-        expect(@mr.to_json).to include('"module":"yokozuna"')
-        expect(@mr.to_json).to include('"function":"mapred_search"')
-        expect(@mr.to_json).to include('"arg":["foo","bar OR baz"]')
-      end
-    end
-  end
-end