riak-client 0.9.0.beta → 0.9.0.beta2

data/spec/riak/map_reduce_spec.rb

@@ -104,7 +104,7 @@ describe Riak::MapReduce do
 
     it "should accept a list of key-filters along with a bucket" do
       @mr.add("foo", [[:tokenize, "-", 3], [:string_to_int], [:between, 2009, 2010]])
-      @mr.inputs.should == {:bucket => "foo", :filters => [[:tokenize, "-", 3], [:string_to_int], [:between, 2009, 2010]]}
+      @mr.inputs.should == {:bucket => "foo", :key_filters => [[:tokenize, "-", 3], [:string_to_int], [:between, 2009, 2010]]}
     end
 
     it "should add a bucket and filter list via a builder block" do
@@ -113,7 +113,7 @@ describe Riak::MapReduce do
         string_to_int
         between 2009, 2010
       end
-      @mr.inputs.should == {:bucket => "foo", :filters => [[:tokenize, "-", 3], [:string_to_int], [:between, 2009, 2010]]}
+      @mr.inputs.should == {:bucket => "foo", :key_filters => [[:tokenize, "-", 3], [:string_to_int], [:between, 2009, 2010]]}
     end
   end
 
@@ -250,19 +250,19 @@ describe Riak::MapReduce do
     end
 
     it "should interpret failed requests with JSON content-types as map reduce errors" do
-      @backend.stub!(:mapred).and_raise(Riak::FailedRequest.new(:post, 200, 500, {"content-type" => ["application/json"]}, '{"error":"syntax error"}'))
+      @backend.stub!(:mapred).and_raise(Riak::HTTPFailedRequest.new(:post, 200, 500, {"content-type" => ["application/json"]}, '{"error":"syntax error"}'))
       lambda { @mr.run }.should raise_error(Riak::MapReduceError)
       begin
         @mr.run
       rescue Riak::MapReduceError => mre
-        mre.message.should == '{"error":"syntax error"}'
+        mre.message.should include('{"error":"syntax error"}')
       else
         fail "No exception raised!"
       end
     end
 
     it "should re-raise non-JSON error responses" do
-      @backend.stub!(:mapred).and_raise(Riak::FailedRequest.new(:post, 200, 500, {"content-type" => ["text/plain"]}, 'Oops, you bwoke it.'))
+      @backend.stub!(:mapred).and_raise(Riak::HTTPFailedRequest.new(:post, 200, 500, {"content-type" => ["text/plain"]}, 'Oops, you bwoke it.'))
       lambda { @mr.run }.should raise_error(Riak::FailedRequest)
     end
   end

data/spec/riak/net_http_backend_spec.rb

@@ -25,4 +25,5 @@ describe Riak::Client::NetHTTPBackend do
   end
 
   it_should_behave_like "HTTP backend"
+
 end

data/spec/riak/{object_spec.rb → robject_spec.rb}

@@ -374,7 +374,7 @@ describe Riak::RObject do
     end
 
     it "should pass through a failed request exception" do
-      @backend.should_receive(:delete_object).and_raise(Riak::FailedRequest.new(:delete, [204,404], 500, {}, ""))
+      @backend.should_receive(:delete_object).and_raise(Riak::HTTPFailedRequest.new(:delete, [204,404], 500, {}, ""))
       lambda { @object.delete }.should raise_error(Riak::FailedRequest)
     end
   end

data/spec/riak/stream_parser_spec.rb

@@ -0,0 +1,66 @@
+# 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::Util::Multipart::StreamParser do
+  let(:klass) { Riak::Util::Multipart::StreamParser }
+  let(:block) { mock }
+  it "should detect the initial boundary" do
+    text = "--boundary1\r\nContent-Type: text/plain\r\n\r\nfoo\r\n--boundary1--\r\n"
+    parser = klass.new do |result|
+      result[:headers]['content-type'].should include("text/plain")
+      result[:body].should == "foo"
+    end
+    parser.accept text
+  end
+
+  it "should detect inner multipart bodies" do
+    block.should_receive(:ping).once.and_return(true)
+    parser = klass.new do |result|
+      block.ping
+      result.should have(1).item
+      result.first[:headers]['content-type'].should include("text/plain")
+      result.first[:body].should == "SCP sloooow...."
+    end
+    File.open("spec/fixtures/multipart-with-body.txt", "r") do |f|
+      while chunk = f.read(16)
+        parser.accept chunk
+      end
+    end
+  end
+
+  it "should yield successive complete chunks to the block" do
+    block.should_receive(:ping).twice.and_return(true)
+    parser = klass.new do |result|
+      block.ping
+      result[:headers]['content-type'].should include("application/json")
+      lambda { JSON.parse(result[:body]) }.should_not raise_error
+    end
+    File.open("spec/fixtures/multipart-mapreduce.txt", "r") do |f|
+      while chunk = f.read(16)
+        parser.accept chunk
+      end
+    end
+  end
+
+  it "should yield successive complete bodies to the block, even when multiple bodies are accepted in a single chunk" do
+    block.should_receive(:ping).twice.and_return(true)
+    parser = klass.new do |result|
+      block.ping
+      result[:headers]['content-type'].should include("application/json")
+      lambda { JSON.parse(result[:body]) }.should_not raise_error
+    end
+    parser.accept File.read("spec/fixtures/multipart-mapreduce.txt")
+  end
+end

data/spec/support/drb_mock_server.rb

@@ -7,7 +7,7 @@ module DrbMockServer
   def start_client
     # JRuby doesn't support fork
     if defined? JRUBY_VERSION
-      @server = MockServer.new
+      @server = MockServer.new(2)
       at_exit { @server.stop }
     else
       child_pid = Process.fork do
@@ -17,6 +17,7 @@ module DrbMockServer
       at_exit { Process.kill("HUP", child_pid); Process.wait2 }
       DRb.start_service
       @server = DRbObject.new_with_uri(DRBURI)
+      sleep 1
     end
     true
   end
@@ -29,7 +30,6 @@ module DrbMockServer
     @server.send(meth, *args, &block)
   end
 
-  private
   def start_server
     server = MockServer.new
     DRb.start_service(DRBURI, server)

data/spec/support/http_backend_implementation_examples.rb

@@ -212,4 +212,31 @@ shared_examples_for "HTTP backend" do
       end
     end
   end
+
+  describe "SSL" do
+    it "should be supported" do
+      @client.port = $mock_server.port + 1 unless @client.http_backend == :NetHTTP
+      @client.ssl = true
+      setup_http_mock(:get, @backend.path("/riak/","ssl").to_s, :body => "Success!")
+      response = @backend.get(200, "/riak/","ssl")
+      response[:code].should == 200
+    end
+  end
+
+  describe "HTTP Basic Authentication", :basic_auth => true do
+    it "should add the http basic auth header" do
+      @client.basic_auth = "ripple:rocks"
+      if @client.http_backend == :NetHTTP
+        setup_http_mock(:get, "http://ripple:rocks@127.0.0.1:8098/riak/auth", :body => 'Success!')
+      else
+        @_mock_set = "Basic #{Base64::encode64("ripple:rocks").strip}" 
+        $mock_server.attach do |env|
+          $mock_server.satisfied = env['HTTP_AUTHORIZATION'] == @_mock_set
+          [200, {}, Array('Success!')]
+        end
+      end
+      response = @backend.get(200, "/riak/", "auth")
+      response[:code].should == 200
+    end
+  end
 end

data/spec/support/mock_server.rb

@@ -16,6 +16,9 @@
 # Based on code from Rob Styles and Chris Tierney found at:
 #   http://dynamicorange.com/2009/02/18/ruby-mock-web-server/
 require 'rack'
+require 'openssl'
+require 'webrick/https'
+require 'rack/handler/webrick'
 
 class MockServer
   attr_accessor :port
@@ -25,14 +28,24 @@ class MockServer
     self.port = 4000 + rand(61535)
     @block = nil
     @parent_thread = Thread.current
+    options = {:AccessLog => [], :Logger => NullLogger.new, :Host => '127.0.0.1'}
     @thread = Thread.new do
-      Rack::Handler::WEBrick.run(self, :Port => port, :AccessLog => [], :Logger => NullLogger.new, :Host => '127.0.0.1')
+      Rack::Handler::WEBrick.run(self, options.merge(:Port => port))
+    end
+    @ssl_thread = Thread.new do
+      Rack::Handler::WEBrick.run(self, options.merge(:Port => port+1,
+                                                     :SSLEnable       => true,
+                                                     :SSLVerifyClient => OpenSSL::SSL::VERIFY_NONE,
+                                                     :SSLCertificate  => read_cert,
+                                                     :SSLPrivateKey   => read_pkey,
+                                                     :SSLCertName     => [ [ "CN",'127.0.0.1' ] ]))
     end
     sleep pause # give the server time to fire up… YUK!
   end
 
   def stop
     Thread.kill(@thread)
+    Thread.kill(@ssl_thread)
   end
 
   def expect(status, headers, method, path, query, body)
@@ -64,6 +77,14 @@ class MockServer
     end
   end
 
+  def read_pkey
+    OpenSSL::PKey::RSA.new(File.read(File.expand_path(File.dirname(__FILE__) + '/../fixtures/server.cert.key')), 'ripple')
+  end
+
+  def read_cert
+    OpenSSL::X509::Certificate.new(File.read((File.expand_path(File.dirname(__FILE__) + '/../fixtures/server.cert.crt'))))
+  end
+
   class NullLogger
     def fatal(msg) end
     def error(msg) end

data/spec/support/unified_backend_examples.rb

@@ -0,0 +1,255 @@
+# 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.
+
+shared_examples_for "Unified backend API" do
+  # ping
+  it "should ping the server" do
+    @backend.ping.should be_true
+  end
+
+  # fetch_object
+  context "fetching an object" do
+    before do
+      @robject = Riak::RObject.new(@client.bucket("test"), "fetch")
+      @robject.content_type = "application/json"
+      @robject.data = { "test" => "pass" }
+      @backend.store_object(@robject)
+    end
+
+    it "should find a stored object" do
+      robj = @backend.fetch_object("test", "fetch")
+      robj.should be_kind_of(Riak::RObject)
+      robj.data.should == { "test" => "pass" }
+    end
+
+    it "should raise an error when the object is not found" do
+      begin
+        @backend.fetch_object("test", "notfound")
+      rescue Riak::FailedRequest => exception
+        @exception = exception
+      end
+      @exception.should be_kind_of(Riak::FailedRequest)
+      @exception.should be_not_found
+    end
+
+    [1,2,3,:one,:quorum,:all,:default].each do |q|
+      it "should accept a R value of #{q.inspect} for the request" do
+        robj = @backend.fetch_object("test", "fetch", q)
+        robj.should be_kind_of(Riak::RObject)
+        robj.data.should == { "test" => "pass" }
+      end
+    end
+  end
+
+  # reload_object
+  context "reloading an existing object" do
+    before do
+      @robject = Riak::RObject.new(@client.bucket('test'), 'reload')
+      @robject.content_type = "application/json"
+      @robject.data = {"test" => "pass"}
+      @backend.store_object(@robject)
+      @robject2 = @backend.fetch_object("test", "reload")
+      @robject2.data["test"] = "second"
+      @backend.store_object(@robject2, true)
+    end
+
+    it "should modify the object with the reloaded data" do
+      @backend.reload_object(@robject)
+    end
+
+    [1,2,3,:one,:quorum,:all,:default].each do |q|
+      it "should accept a valid R value of #{q.inspect} for the request" do
+        @backend.reload_object(@robject, q)
+      end
+    end
+
+    after do
+      @robject.vclock.should == @robject2.vclock
+      @robject.data['test'].should == "second"
+    end
+  end
+
+  # store_object
+  context "storing an object" do
+    before do
+      @robject = Riak::RObject.new(@client.bucket('test'), 'store')
+      @robject.content_type = "application/json"
+      @robject.data = {"test" => "pass"}
+    end
+
+    it "should save the object" do
+      @backend.store_object(@robject)
+    end
+
+    it "should modify the object with the returned data if returnbody" do
+      @backend.store_object(@robject, true)
+      @robject.vclock.should be_present
+    end
+
+    [1,2,3,:one,:quorum,:all,:default].each do |q|
+      it "should accept a W value of #{q.inspect} for the request" do
+        @backend.store_object(@robject, false, q)
+        @client.bucket("test").exists?("store").should be_true
+      end
+
+      it "should accept a DW value of #{q.inspect} for the request" do
+        @backend.store_object(@robject, false, nil, q)
+      end
+    end
+
+    after do
+      @client.bucket("test").exists?("store").should be_true
+    end
+  end
+
+  # delete_object
+  context "deleting an object" do
+    before do
+      @obj = Riak::RObject.new(@client.bucket("test"), "delete")
+      @obj.content_type = "application/json"
+      @obj.data = [1]
+      @backend.store_object(@obj)
+    end
+
+    it "should remove the object" do
+      @backend.delete_object("test", "delete")
+      @obj.bucket.exists?("delete").should be_false
+    end
+
+    [1,2,3,:one,:quorum,:all,:default].each do |q|
+      it "should accept an RW value of #{q.inspect} for the request" do
+        @backend.delete_object("test", "delete", q)
+      end
+    end
+
+    after do
+      @obj.bucket.exists?("delete").should be_false
+    end
+  end
+
+  # get_bucket_props
+  context "fetching bucket properties" do
+    it "should fetch a hash of bucket properties" do
+      props = @backend.get_bucket_props("test")
+      props.should be_kind_of(Hash)
+      props.should include("n_val")
+    end
+  end
+
+  # set_bucket_props
+  context "setting bucket properties" do
+    it "should store properties for the bucket" do
+      @backend.set_bucket_props("test", {"n_val" => 3})
+      @backend.get_bucket_props("test")["n_val"].should == 3
+    end
+  end
+
+  # list_keys
+  context "listing keys in a bucket" do
+    before do
+      obj = Riak::RObject.new(@client.bucket("test"), "keys")
+      obj.content_type = "application/json"
+      obj.data = [1]
+      @backend.store_object(obj)
+    end
+
+    it "should fetch an array of string keys" do
+      @backend.list_keys("test").should == ["keys"]
+    end
+
+    context "streaming through a block" do
+      it "should pass an array of keys to the block" do
+        @backend.list_keys("test") do |keys|
+          keys.should == ["keys"] unless keys.empty?
+        end
+      end
+
+      it "should allow requests issued inside the block to execute" do
+        errors = []
+        @backend.list_keys("test") do |keys|
+          keys.each do |key|
+            begin
+              @backend.fetch_object("test", key)
+            rescue => e
+              errors << e
+            end
+          end
+        end
+        errors.should be_empty
+      end
+    end
+  end
+
+  # list_buckets
+  context "listing buckets" do
+    before do
+      obj = Riak::RObject.new(@client.bucket("test"), "buckets")
+      obj.content_type = "application/json"
+      obj.data = [1]
+      @backend.store_object(obj)
+    end
+
+    it "should fetch a list of string bucket names" do
+      list = @backend.list_buckets
+      list.should be_kind_of(Array)
+      list.should include("test")
+    end
+  end
+
+  # mapred
+  context "performing MapReduce" do
+    before do
+      obj = Riak::RObject.new(@client.bucket("test"), "1")
+      obj.content_type = "application/json"
+      obj.data = {"value" => "1" }
+      @backend.store_object(obj)
+      @mapred = Riak::MapReduce.new(@client).add("test").map("Riak.mapValuesJson", :keep => true)
+    end
+
+    it "should perform a simple MapReduce request" do
+      @backend.mapred(@mapred).should == [{"value" => "1"}]
+    end
+
+    context "streaming results through a block" do
+      it "should pass phase number and result to the block" do
+        @backend.mapred(@mapred) do |phase, result|
+          unless result.empty?
+            phase.should == 0
+            result.should == [{"value" => "1"}]
+          end
+        end
+      end
+
+      it "should allow requests issued inside the block to execute" do
+        errors = []
+        @backend.mapred(@mapred) do |phase, result|
+          unless result.empty?
+            result.each do |v|
+              begin
+                @backend.fetch_object("test", v['value'])
+              rescue => e
+                errors << e
+              end
+            end
+          end
+        end
+        errors.should be_empty
+      end
+    end
+  end
+
+  after do
+    $test_server.recycle if $test_server.started?
+  end
+end