riak-client 0.9.0.beta → 0.9.0.beta2

data/spec/riak/excon_backend_spec.rb

@@ -23,14 +23,14 @@ else
 
   describe Riak::Client::ExconBackend do
     def setup_http_mock(method, uri, options={})
-      method = method.to_s.upcase
-      uri = URI.parse(uri)
-      path = uri.path || "/"
-      query = uri.query || ""
-      status = options[:status] ? Array(options[:status]).first.to_i : 200
-      body = options[:body] || []
+      method  = method.to_s.upcase
+      uri     = URI.parse(uri)
+      path    = uri.path          || "/"
+      query   = uri.query         || ""
+      body    = options[:body]    || []
       headers = options[:headers] || {}
-      headers['Content-Type'] ||= "text/plain"
+      headers['Content-Type']     ||= "text/plain"
+      status  = options[:status] ? Array(options[:status]).first.to_i : 200
       @_mock_set = [status, headers, method, path, query, body]
       $mock_server.expect(*@_mock_set)
     end
@@ -73,4 +73,5 @@ else
       end.should_not raise_error
     end
   end
+
 end

data/spec/riak/http_backend/configuration_spec.rb

@@ -0,0 +1,64 @@
+# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
+#
+#    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.expand_path("../../spec_helper", File.dirname(__FILE__))
+
+describe Riak::Client::HTTPBackend::Configuration do
+  before do
+    @client = Riak::Client.new
+    @backend = Riak::Client::HTTPBackend.new(@client)
+  end
+
+  it "should memoize the server config" do
+    @backend.should_receive(:get).with(200, "/", {}, {}).once.and_return(:headers => {'link' => ['</riak>; rel="riak_kv_wm_link_walker",</mapred>; rel="riak_kv_wm_mapred",</ping>; rel="riak_kv_wm_ping",</riak>; rel="riak_kv_wm_raw",</stats>; rel="riak_kv_wm_stats"']})
+    @backend.send(:riak_kv_wm_link_walker).should == "/riak"
+    @backend.send(:riak_kv_wm_raw).should == "/riak"
+  end
+
+  {
+    :riak_kv_wm_raw => :prefix,
+    :riak_kv_wm_link_walker => :prefix,
+    :riak_kv_wm_mapred => :mapred
+  }.each do |resource, alternate|
+    it "should detect the #{resource} resource from the configuration URL" do
+      @backend.should_receive(:get).with(200, "/", {}, {}).and_return(:headers => {'link' => [%Q{</path>; rel="#{resource}"}]})
+      @backend.send(resource).should == "/path"
+    end
+    it "should fallback to client.#{alternate} if the #{resource} resource is not found" do
+      @backend.should_receive(:get).with(200, "/", {}, {}).and_return(:headers => {'link' => ['</>; rel="top"']})
+      @backend.send(resource).should == @client.send(alternate)
+    end
+    it "should fallback to client.#{alternate} if request fails" do
+      @backend.should_receive(:get).with(200, "/", {}, {}).and_raise(Riak::HTTPFailedRequest.new(:get, 200, 404, {}, ""))
+      @backend.send(resource).should == @client.send(alternate)
+    end
+  end
+
+  {
+    :riak_kv_wm_ping => "/ping",
+    :riak_kv_wm_stats => "/stats"
+  }.each do |resource, default|
+    it "should detect the #{resource} resource from the configuration URL" do
+      @backend.should_receive(:get).with(200, "/", {}, {}).and_return(:headers => {'link' => [%Q{</path>; rel="#{resource}"}]})
+      @backend.send(resource).should == "/path"
+    end
+    it "should fallback to #{default.inspect} if the #{resource} resource is not found" do
+      @backend.should_receive(:get).with(200, "/", {}, {}).and_return(:headers => {'link' => ['</>; rel="top"']})
+      @backend.send(resource).should == default
+    end
+    it "should fallback to #{default.inspect} if request fails" do
+      @backend.should_receive(:get).with(200, "/", {}, {}).and_raise(Riak::HTTPFailedRequest.new(:get, 200, 404, {}, ""))
+      @backend.send(resource).should == default
+    end
+  end
+end

data/spec/riak/http_backend/object_methods_spec.rb

@@ -84,7 +84,7 @@ describe Riak::Client::HTTPBackend::ObjectMethods do
     end
 
     it "should parse and escape the location header into the key when present" do
-      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"], "location" => ["/riak/foo/%5Bbaz%5D"]}})
+      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"], "location" => ["/riak/foo/%5Bbaz%5D?vtag=1234"]}})
       @object.key.should == "[baz]"
     end
 

data/spec/riak/http_backend/transport_methods_spec.rb

@@ -0,0 +1,129 @@
+# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
+#
+#    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.expand_path("../../spec_helper", File.dirname(__FILE__))
+
+describe Riak::Client::HTTPBackend::TransportMethods do
+  before :each do
+    @client = Riak::Client.new
+    @backend = Riak::Client::HTTPBackend.new(@client)
+    @backend.instance_variable_set(:@server_config, {})
+  end
+
+  it "should generate default headers for requests based on the client settings" do
+    @client.client_id = "testing"
+    @backend.default_headers.should == {"X-Riak-ClientId" => "testing", "Accept" => "multipart/mixed, application/json;q=0.7, */*;q=0.5"}
+  end
+
+  it "should generate a root URI based on the client settings" do
+    @backend.root_uri.should be_kind_of(URI)
+    @backend.root_uri.to_s.should == "http://127.0.0.1:8098"
+  end
+
+  it "should compute a URI from a relative resource path" do
+    @backend.path("baz").should be_kind_of(URI)
+    @backend.path("foo").to_s.should == "http://127.0.0.1:8098/foo"
+    @backend.path("foo", "bar").to_s.should == "http://127.0.0.1:8098/foo/bar"
+    @backend.path("/foo/bar").to_s.should == "http://127.0.0.1:8098/foo/bar"
+  end
+
+  it "should compute a URI from a relative resource path with a hash of query parameters" do
+    @backend.path("baz", :r => 2).to_s.should == "http://127.0.0.1:8098/baz?r=2"
+  end
+
+  it "should raise an error if a resource path is too short" do
+    lambda { @backend.verify_path!(["/riak/"]) }.should raise_error(ArgumentError)
+    lambda { @backend.verify_path!(["/riak/", "foo"]) }.should_not raise_error
+    lambda { @backend.verify_path!(["/mapred"]) }.should_not raise_error
+  end
+
+  describe "verify_path_and_body!" do
+    it "should separate the path and body from given arguments" do
+      uri, data = @backend.verify_path_and_body!(["/riak/", "foo", "This is the body."])
+      uri.should == ["/riak/", "foo"]
+      data.should == "This is the body."
+    end
+
+    it "should raise an error if the body is not a string or IO" do
+      lambda { @backend.verify_path_and_body!(["/riak/", "foo", nil]) }.should raise_error(ArgumentError)
+      lambda { @backend.verify_path_and_body!(["/riak/", "foo", File.open("spec/fixtures/cat.jpg")]) }.should_not raise_error(ArgumentError)
+    end
+
+    it "should raise an error if a body is not given" do
+      lambda { @backend.verify_path_and_body!(["/riak/", "foo"])}.should raise_error(ArgumentError)
+    end
+
+    it "should raise an error if a path is not given" do
+      lambda { @backend.verify_path_and_body!(["/riak/"])}.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "detecting valid response codes" do
+    it "should accept strings or integers for either argument" do
+      @backend.should be_valid_response("300", "300")
+      @backend.should be_valid_response(300, "300")
+      @backend.should be_valid_response("300", 300)
+    end
+
+    it "should accept an array of strings or integers for the expected code" do
+      @backend.should be_valid_response([200,304], "200")
+      @backend.should be_valid_response(["200",304], "200")
+      @backend.should be_valid_response([200,"304"], "200")
+      @backend.should be_valid_response(["200","304"], "200")
+      @backend.should be_valid_response([200,304], 200)
+    end
+
+    it "should be false when none of the response codes match" do
+      @backend.should_not be_valid_response(200, 404)
+      @backend.should_not be_valid_response(["200","304"], 404)
+      @backend.should_not be_valid_response([200,304], 404)
+    end
+  end
+
+  describe "detecting whether a body should be returned" do
+    it "should be false when the method is :head" do
+      @backend.should_not be_return_body(:head, 200, false)
+    end
+
+    it "should be false when the response code is 204, 205, or 304" do
+      @backend.should_not be_return_body(:get, 204, false)
+      @backend.should_not be_return_body(:get, 205, false)
+      @backend.should_not be_return_body(:get, 304, false)
+    end
+
+    it "should be false when a streaming block was passed" do
+      @backend.should_not be_return_body(:get, 200, true)
+    end
+
+    it "should be true when the method is not head, a code other than 204, 205, or 304 was given, and there was no streaming block" do
+      [:get, :put, :post, :delete].each do |method|
+        [100,101,200,201,202,203,206,300,301,302,303,305,307,400,401,
+         402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,
+         500,501,502,503,504,505].each do |code|
+          @backend.should be_return_body(method, code, false)
+          @backend.should be_return_body(method, code.to_s, false)
+        end
+      end
+    end
+  end
+
+  it "should force subclasses to implement the perform method" do
+    lambda { @backend.send(:perform, :get, "/foo", {}, 200) }.should raise_error(NotImplementedError)
+  end
+
+  it "should allow using the https protocol" do
+    @client  = Riak::Client.new(:protocol => 'https')
+    @backend = Riak::Client::HTTPBackend.new(@client)
+    @backend.root_uri.to_s.should eq("https://127.0.0.1:8098")
+  end
+end

data/spec/riak/http_backend_spec.rb

@@ -76,7 +76,7 @@ describe Riak::Client::HTTPBackend do
     end
 
     it "should raise an exception when the response code is not 200 or 304" do
-      @backend.should_receive(:get).and_raise(Riak::FailedRequest.new(:get, 200, 500, {}, ''))
+      @backend.should_receive(:get).and_raise(Riak::HTTPFailedRequest.new(:get, 200, 500, {}, ''))
       lambda { @backend.reload_object(@object) }.should raise_error(Riak::FailedRequest)
     end
 
@@ -227,6 +227,18 @@ describe Riak::Client::HTTPBackend do
       @backend.stub!(:post).and_return(response)
       @backend.mapred(@mr).should == response
     end
+
+    it "should stream results through the block" do
+      data = File.read("spec/fixtures/multipart-mapreduce.txt")
+      @backend.should_receive(:post).with(200, "/mapred", {:chunked => true}, @mr.to_json, hash_including("Content-Type" => "application/json")).and_yield(data)
+      block = mock
+      block.should_receive(:ping).twice.and_return(true)
+      @backend.mapred(@mr) do |phase, data|
+        block.ping
+        phase.should == 0
+        data.should have(1).item
+      end
+    end
   end
 
   context "getting statistics" do

data/spec/riak/map_reduce/filter_builder_spec.rb

@@ -0,0 +1,45 @@
+# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
+#
+#    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.expand_path("../../spec_helper", File.dirname(__FILE__))
+
+describe Riak::MapReduce::FilterBuilder do
+  subject { Riak::MapReduce::FilterBuilder.new }
+  it "should evaluate the passed block on initialization" do
+    subject.class.new do
+      matches "foo"
+    end.to_a.should == [[:matches, "foo"]]
+  end
+
+  it "should add filters to the list" do
+    subject.to_lower
+    subject.similar_to("ripple", 3)
+    subject.to_a.should == [[:to_lower],[:similar_to, "ripple", 3]]
+  end
+
+  it "should add a logical operation with a block" do
+    subject.OR do
+      starts_with "foo"
+      ends_with "bar"
+    end
+    subject.to_a.should == [[:or, [[:starts_with, "foo"],[:ends_with, "bar"]]]]
+  end
+
+  it "should raise an error on a filter arity mismatch" do
+    lambda { subject.less_than }.should raise_error(ArgumentError)
+  end
+
+  it "should raise an error when a block is not given to a logical operation" do
+    lambda { subject._or }.should raise_error(ArgumentError)
+  end
+end

data/spec/riak/map_reduce/phase_spec.rb

@@ -0,0 +1,149 @@
+# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
+#
+#    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.expand_path("../../spec_helper", File.dirname(__FILE__))
+
+describe Riak::MapReduce::Phase do
+  before :each do
+    @fun = "function(v,_,_){ return v['values'][0]['data']; }"
+  end
+
+  it "should initialize with a type and a function" do
+    phase = Riak::MapReduce::Phase.new(:type => :map, :function => @fun, :language => "javascript")
+    phase.type.should == :map
+    phase.function.should == @fun
+    phase.language.should == "javascript"
+  end
+
+  it "should initialize with a type and an MF" do
+    phase = Riak::MapReduce::Phase.new(:type => :map, :function => ["module", "function"], :language => "erlang")
+    phase.type.should == :map
+    phase.function.should == ["module", "function"]
+    phase.language.should == "erlang"
+  end
+
+  it "should initialize with a type and a bucket/key" do
+    phase = Riak::MapReduce::Phase.new(:type => :map, :function => {:bucket => "funs", :key => "awesome_map"}, :language => "javascript")
+    phase.type.should == :map
+    phase.function.should == {:bucket => "funs", :key => "awesome_map"}
+    phase.language.should == "javascript"
+  end
+
+  it "should assume the language is erlang when the function is an array" do
+    phase = Riak::MapReduce::Phase.new(:type => :map, :function => ["module", "function"])
+    phase.language.should == "erlang"
+  end
+
+  it "should assume the language is javascript when the function is a string" do
+    phase = Riak::MapReduce::Phase.new(:type => :map, :function => @fun)
+    phase.language.should == "javascript"
+  end
+
+  it "should assume the language is javascript when the function is a hash" do
+    phase = Riak::MapReduce::Phase.new(:type => :map, :function => {:bucket => "jobs", :key => "awesome_map"})
+    phase.language.should == "javascript"
+  end
+
+  it "should accept a WalkSpec for the function when a link phase" do
+    phase = Riak::MapReduce::Phase.new(:type => :link, :function => Riak::WalkSpec.new({}))
+    phase.function.should be_kind_of(Riak::WalkSpec)
+  end
+
+  it "should raise an error if a WalkSpec is given for a phase type other than :link" do
+    lambda { Riak::MapReduce::Phase.new(:type => :map, :function => Riak::WalkSpec.new({})) }.should raise_error(ArgumentError)
+  end
+
+  describe "converting to JSON for the job" do
+    before :each do
+      @phase = Riak::MapReduce::Phase.new(:type => :map, :function => "")
+    end
+
+    [:map, :reduce].each do |type|
+      describe "when a #{type} phase" do
+        before :each do
+          @phase.type = type
+        end
+
+        it "should be an object with a single key of '#{type}'" do
+          @phase.to_json.should =~ /^\{"#{type}":/
+        end
+
+        it "should include the language" do
+          @phase.to_json.should =~ /"language":/
+        end
+
+        it "should include the keep value" do
+          @phase.to_json.should =~ /"keep":false/
+          @phase.keep = true
+          @phase.to_json.should =~ /"keep":true/
+        end
+
+        it "should include the function source when the function is a source string" do
+          @phase.function = "function(v,_,_){ return v; }"
+          @phase.to_json.should include(@phase.function)
+          @phase.to_json.should =~ /"source":/
+        end
+
+        it "should include the function name when the function is not a lambda" do
+          @phase.function = "Riak.mapValues"
+          @phase.to_json.should include('"name":"Riak.mapValues"')
+          @phase.to_json.should_not include('"source"')
+        end
+
+        it "should include the bucket and key when referring to a stored function" do
+          @phase.function = {:bucket => "design", :key => "wordcount_map"}
+          @phase.to_json.should include('"bucket":"design"')
+          @phase.to_json.should include('"key":"wordcount_map"')
+        end
+
+        it "should include the module and function when invoking an Erlang function" do
+          @phase.function = ["riak_mapreduce", "mapreduce_fun"]
+          @phase.to_json.should include('"module":"riak_mapreduce"')
+          @phase.to_json.should include('"function":"mapreduce_fun"')
+        end
+      end
+    end
+
+    describe "when a link phase" do
+      before :each do
+        @phase.type = :link
+        @phase.function = {}
+      end
+
+      it "should be an object of a single key 'link'" do
+        @phase.to_json.should =~ /^\{"link":/
+      end
+
+      it "should include the bucket" do
+        @phase.to_json.should =~ /"bucket":"_"/
+        @phase.function[:bucket] = "foo"
+        @phase.to_json.should =~ /"bucket":"foo"/
+      end
+
+      it "should include the tag" do
+        @phase.to_json.should =~ /"tag":"_"/
+        @phase.function[:tag] = "parent"
+        @phase.to_json.should =~ /"tag":"parent"/
+      end
+
+      it "should include the keep value" do
+        @phase.to_json.should =~ /"keep":false/
+        @phase.keep = true
+        @phase.to_json.should =~ /"keep":true/
+        @phase.keep = false
+        @phase.function[:keep] = true
+        @phase.to_json.should =~ /"keep":true/
+      end
+    end
+  end
+end