riak-client-noenc 1.0.0

data/spec/riak/search/index_spec.rb

@@ -0,0 +1,72 @@
+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

@@ -0,0 +1,88 @@
+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

@@ -0,0 +1,89 @@
+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

@@ -0,0 +1,106 @@
+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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,107 @@
+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 bucket name and query" do
+        @mr.search("foo", "bar OR baz")
+        expect(@mr.inputs).to eq({:module => "riak_search", :function => "mapred_search", :arg => ["foo", "bar OR baz"]})
+      end
+
+      it "accepts a Riak::Bucket and query" do
+        @mr.search(Riak::Bucket.new(@client, "foo"), "bar OR baz")
+        expect(@mr.inputs).to eq({:module => "riak_search", :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":"riak_search"')
+        expect(@mr.to_json).to include('"function":"mapred_search"')
+        expect(@mr.to_json).to include('"arg":["foo","bar OR baz"]')
+      end
+    end
+  end
+end