riak-client 1.4.5 → 2.0.0.rc1

data/spec/riak/instrumentation_spec.rb

@@ -1,167 +0,0 @@
-require 'spec_helper'
-
-describe Riak::Client do
-
-  before do
-    @client = Riak::Client.new
-    @backend = mock("Backend")
-    @client.stub!(:backend).and_yield(@backend)
-    @client.stub!(:http).and_yield(@backend)
-    @bucket = Riak::Bucket.new(@client, "foo")
-
-    @events = []
-    @notifier = ActiveSupport::Notifications.notifier
-    @notifier.subscribe { |*args| (@events ||= []) << event(*args) }
-  end
-
-  describe "instrumentation", instrumentation: true do
-
-    it "should notify on the 'buckets' operation" do
-      @backend.should_receive(:list_buckets).and_return(%w{test test2})
-      test_client_event(@client, 'riak.list_buckets') do
-        @client.buckets
-      end
-    end
-
-    it "should notify on the 'list_buckets' operation" do
-      @backend.should_receive(:list_buckets).and_return(%w{test test2})
-      test_client_event(@client, 'riak.list_buckets') do
-        @client.list_buckets
-      end
-    end
-
-    it "should notify on the 'list_keys' operation" do
-      @backend.should_receive(:list_keys).and_return(%w{test test2})
-      test_client_event(@client, 'riak.list_keys') do
-        @client.list_keys(@bucket)
-      end
-    end
-
-    it "should notify on the 'get_bucket_props' operation" do
-      @backend.should_receive(:get_bucket_props).and_return({})
-      test_client_event(@client, 'riak.get_bucket_props') do
-        @client.get_bucket_props(@bucket)
-      end
-    end
-
-    it "should notify on the 'set_bucket_props' operation" do
-      @backend.should_receive(:set_bucket_props).and_return({})
-      test_client_event(@client, 'riak.set_bucket_props') do
-        @client.set_bucket_props(@bucket, {})
-      end
-    end
-
-    it "should notify on the 'clear_bucket_props' operation" do
-      @backend.should_receive(:clear_bucket_props).and_return({})
-      test_client_event(@client, 'riak.clear_bucket_props') do
-        @client.clear_bucket_props(@bucket)
-      end
-    end
-
-    it "should notify on the 'get_index' operation" do
-      @backend.should_receive(:get_index).and_return({})
-      test_client_event(@client, 'riak.get_index') do
-        @client.get_index(@bucket, 'index', 'query', {})
-      end
-    end
-
-    it "should notify on the 'get_object' operation" do
-      @backend.should_receive(:fetch_object).and_return(nil)
-      test_client_event(@client, 'riak.get_object') do
-        @client.get_object(@bucket, 'bar')
-      end
-    end
-
-    it "should notify on the 'store_object' operation" do
-      @backend.should_receive(:store_object).and_return(nil)
-      test_client_event(@client, 'riak.store_object') do
-        @client.store_object(Object.new)
-      end
-    end
-
-    it "should notify on the 'reload_object' operation" do
-      @backend.should_receive(:reload_object).and_return(nil)
-      test_client_event(@client, 'riak.reload_object') do
-        @client.reload_object(Object.new)
-      end
-    end
-
-    it "should notify on the 'delete_object' operation" do
-      @backend.should_receive(:delete_object).and_return(nil)
-      test_client_event(@client, 'riak.delete_object') do
-        @client.delete_object(@bucket, 'bar')
-      end
-    end
-
-    it "should notify on the 'store_file' operation" do
-      @backend.should_receive(:store_file).and_return(nil)
-      test_client_event(@client, 'riak.store_file') do
-        @client.store_file('filename')
-      end
-    end
-
-    it "should notify on the 'get_file' operation" do
-      @backend.should_receive(:get_file).and_return(nil)
-      test_client_event(@client, 'riak.get_file') do
-        @client.get_file('filename')
-      end
-    end
-
-    it "should notify on the 'delete_file' operation" do
-      @backend.should_receive(:delete_file).and_return(nil)
-      test_client_event(@client, 'riak.delete_file') do
-        @client.delete_file('filename')
-      end
-    end
-
-    it "should notify on the 'file_exists' operation" do
-      @backend.should_receive(:file_exists?).and_return(nil)
-      test_client_event(@client, 'riak.file_exists') do
-        @client.file_exists?('filename')
-      end
-    end
-
-    it "should notify on the 'file_exist' operation" do
-      @backend.should_receive(:file_exists?).and_return(nil)
-      test_client_event(@client, 'riak.file_exists') do
-        @client.file_exist?('filename')
-      end
-    end
-
-    it "should notify on the 'link_walk' operation" do
-      @backend.should_receive(:link_walk).and_return(nil)
-      test_client_event(@client, 'riak.link_walk') do
-        @client.link_walk(Object.new, [Riak::WalkSpec.new(:bucket => 'foo')])
-      end
-    end
-
-    it "should notify on the 'mapred' operation" do
-      @mapred = Riak::MapReduce.new(@client).add('test').map("function(){}").map("function(){}")
-      @backend.should_receive(:mapred).and_return(nil)
-      test_client_event(@client, 'riak.map_reduce') do
-        @client.mapred(@mapred)
-      end
-    end
-
-    it "should notify on the 'ping' operation" do
-      @backend.should_receive(:ping).and_return(nil)
-      test_client_event(@client, 'riak.ping') do
-        @client.ping
-      end
-    end
-  end
-end
-
-def test_client_event(client, event_name, &block)
-  block.call
-  @events.size.should == 1
-  event = @events.first
-  event.name.should == event_name
-  event.payload[:protocol].should == client.protocol
-  event.payload[:client_id].should == client.client_id
-end
-
-# name, start, finish, id, payload
-def event(*args)
-  ActiveSupport::Notifications::Event.new(*args)
-end

data/spec/riak/multipart_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-describe Riak::Util::Multipart do
-  it "should extract the boundary string from a header value" do
-    Riak::Util::Multipart.extract_boundary("multipart/mixed; boundary=123446677890").should == "123446677890"
-  end
-
-  it "should parse an empty multipart body into empty arrays" do
-    data = File.read(File.expand_path("#{File.dirname(__FILE__)}/../fixtures/multipart-blank.txt"))
-    Riak::Util::Multipart.parse(data, "73NmmA8dJxSB5nL2dVerpFIi8ze").should == [[]]
-  end
-
-  it "should parse multipart body into nested arrays with response-like results" do
-    data = File.read(File.expand_path("#{File.dirname(__FILE__)}/../fixtures/multipart-with-body.txt"))
-    results = Riak::Util::Multipart.parse(data, "5EiMOjuGavQ2IbXAqsJPLLfJNlA")
-    results.should be_kind_of(Array)
-    results.first.should be_kind_of(Array)
-    obj = results.first.first
-    obj.should be_kind_of(Hash)
-    obj.should have_key(:headers)
-    obj.should have_key(:body)
-  end
-end

data/spec/riak/net_http_backend_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-describe Riak::Client::NetHTTPBackend do
-  before :each do
-    @client = Riak::Client.new(:http_backend => :NetHTTP)
-    @backend = @client.new_http_backend
-    FakeWeb.allow_net_connect = false
-  end
-
-  def setup_http_mock(method, uri, options={})
-    FakeWeb.register_uri(method, uri, options)
-  end
-
-  it_should_behave_like "HTTP backend"
-end

data/spec/riak/stream_parser_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-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 { Riak::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 { Riak::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

@@ -1,39 +0,0 @@
-require 'drb/drb'
-DRBURI="druby://localhost:8787"
-
-module DrbMockServer
-  extend self
-
-  def start_client
-    # JRuby doesn't support fork
-    if defined? JRUBY_VERSION
-      @server = MockServer.new(2)
-      at_exit { @server.stop }
-    else
-      child_pid = Process.fork do
-        start_server
-      end
-      sleep 1
-      at_exit { Process.kill("HUP", child_pid); Process.wait2 }
-      DRb.start_service
-      @server = DRbObject.new_with_uri(DRBURI)
-      sleep 1
-    end
-    true
-  end
-
-  def maybe_start
-    start_client unless @server
-  end
-
-  def method_missing(meth, *args, &block)
-    @server.send(meth, *args, &block)
-  end
-
-  def start_server
-    server = MockServer.new
-    DRb.start_service(DRBURI, server)
-    Signal.trap("HUP") { server.stop; exit }
-    DRb.thread.join
-  end
-end

data/spec/support/http_backend_implementation_examples.rb

@@ -1,253 +0,0 @@
-shared_examples_for "HTTP backend" do
-  let(:resource){ @backend.path("/riak/","foo") }
-
-  describe "HEAD requests" do
-    before :each do
-      setup_http_mock(:head, resource.to_s, :body => "")
-    end
-
-    it "should return only the headers when the request succeeds" do
-      response = @backend.head(200, resource)
-      response.should_not have_key(:body)
-      response[:headers].should be_kind_of(Hash)
-      response[:code].should == 200
-    end
-
-    it "should raise a FailedRequest exception when the request fails" do
-      lambda { @backend.head(301, resource) }.should raise_error(Riak::FailedRequest)
-    end
-
-    it "should not raise a FailedRequest if one of the expected response codes matches" do
-      lambda { @backend.head([200, 301], resource) }.should_not raise_error(Riak::FailedRequest)
-    end
-  end
-
-  describe "GET requests" do
-    before :each do
-      setup_http_mock(:get, resource.to_s, :body => "Success!")
-    end
-
-    it "should return the response body and headers when the request succeeds" do
-      response = @backend.get(200, resource)
-      response[:body].should == "Success!"
-      response[:headers].should be_kind_of(Hash)
-      response[:code].should == 200
-    end
-
-    it "should raise a FailedRequest exception when the request fails" do
-      lambda { @backend.get(304, resource) }.should raise_error(Riak::FailedRequest)
-    end
-
-    it "should not raise a FailedRequest if one of the expected response codes matches" do
-      lambda { @backend.get([200, 301], resource) }.should_not raise_error(Riak::FailedRequest)
-    end
-
-    it "should yield successive chunks of the response to the given block but not return the entire body" do
-      chunks = ""
-      response = @backend.get(200, resource) do |chunk|
-        chunks << chunk
-      end
-      chunks.should == "Success!"
-      response.should_not have_key(:body)
-      response[:headers].should be_kind_of(Hash)
-      response[:code].should == 200
-    end
-  end
-
-  describe "DELETE requests" do
-    before :each do
-      setup_http_mock(:delete, resource.to_s, :body => "Success!")
-    end
-
-    it "should return the response body and headers when the request succeeds" do
-      response = @backend.delete(200, resource)
-      response[:body].should == "Success!"
-      response[:headers].should be_kind_of(Hash)
-    end
-
-    it "should raise a FailedRequest exception when the request fails" do
-      lambda { @backend.delete(304, resource) }.should raise_error(Riak::FailedRequest)
-    end
-
-    it "should not raise a FailedRequest if one of the expected response codes matches" do
-      lambda { @backend.delete([200, 301], resource) }.should_not raise_error(Riak::FailedRequest)
-    end
-
-    it "should yield successive chunks of the response to the given block but not return the entire body" do
-      chunks = ""
-      response = @backend.delete(200, resource) do |chunk|
-        chunks << chunk
-      end
-      chunks.should == "Success!"
-      response.should_not have_key(:body)
-      response[:headers].should be_kind_of(Hash)
-      response[:code].should == 200
-    end
-  end
-
-  describe "PUT requests" do
-    before :each do
-      setup_http_mock(:put, resource.to_s, :body => "Success!")
-    end
-
-    it "should return the response body, headers, and code when the request succeeds" do
-      response = @backend.put(200, resource, "This is the body.")
-      response[:body].should == "Success!"
-      response[:headers].should be_kind_of(Hash)
-      response[:code].should == 200
-    end
-
-    it "should raise a FailedRequest exception when the request fails" do
-      lambda { @backend.put(204, resource, "This is the body.") }.should raise_error(Riak::FailedRequest)
-    end
-
-    it "should not raise a FailedRequest if one of the expected response codes matches" do
-      lambda { @backend.put([200, 204], resource, "This is the body.") }.should_not raise_error(Riak::FailedRequest)
-    end
-
-
-    it "should yield successive chunks of the response to the given block but not return the entire body" do
-      chunks = ""
-      response = @backend.put(200, resource, "This is the body.") do |chunk|
-        chunks << chunk
-      end
-      chunks.should == "Success!"
-      response.should_not have_key(:body)
-      response[:headers].should be_kind_of(Hash)
-      response[:code].should == 200
-    end
-
-
-    it "should raise an error if no body data is given" do
-      lambda { @backend.put(200, resource) }.should raise_error(ArgumentError)
-    end
-
-    it "should raise an error if the body is not a string or IO" do
-      lambda { @backend.put(200, resource, 123) }.should raise_error(ArgumentError)
-    end
-  end
-
-  describe "POST requests" do
-    before :each do
-      setup_http_mock(:post, resource.to_s, :body => "Success!")
-    end
-
-    it "should return the response body, headers, and code when the request succeeds" do
-      response = @backend.post(200, resource, "This is the body.")
-      response[:body].should == "Success!"
-      response[:headers].should be_kind_of(Hash)
-      response[:code].should == 200
-    end
-
-    it "should raise a FailedRequest exception when the request fails" do
-      lambda { @backend.post(204, resource, "This is the body.") }.should raise_error(Riak::FailedRequest)
-    end
-
-    it "should not raise a FailedRequest if one of the expected response codes matches" do
-      lambda { @backend.post([200, 204], resource, "This is the body.") }.should_not raise_error(Riak::FailedRequest)
-    end
-
-    it "should yield successive chunks of the response to the given block but not return the entire body" do
-      chunks = ""
-      response = @backend.post(200, resource, "This is the body.") do |chunk|
-        chunks << chunk
-      end
-      chunks.should == "Success!"
-      response.should_not have_key(:body)
-      response[:headers].should be_kind_of(Hash)
-      response[:code].should == 200
-    end
-
-    it "should raise an error if no body data is given" do
-      lambda { @backend.post(200, resource) }.should raise_error(ArgumentError)
-    end
-
-    it "should raise an error if the body is not a string or IO" do
-      lambda { @backend.post(200, resource, 123) }.should raise_error(ArgumentError)
-    end
-  end
-
-  describe "Responses with no body" do
-    [204, 205, 304].each do |code|
-      [:get, :post, :put, :delete].each do |method|
-        it "should not return a body on #{method.to_s.upcase} for #{code}" do
-          setup_http_mock(method, resource.to_s, :status => code)
-          response = if method == :post || method == :put
-                       @backend.send(method, code, resource, "This is the body")
-                     else
-                       @backend.send(method, code, resource)
-                     end
-          response.should_not have_key(:body)
-        end
-      end
-    end
-  end
-
-  describe "SSL" do
-    it "should be supported" do
-      unless @client.http_backend == :NetHTTP
-        @client.nodes.each do |node|
-          node.http_port = $mock_server.port + 1
-        end
-      end
-      @client.ssl = true
-      setup_http_mock(:get, @backend.path("/riak/","ssl").to_s, :body => "Success!")
-      response = @backend.get(200,  @backend.path("/riak/","ssl"))
-      response[:code].should == 200
-    end
-  end
-
-  describe "HTTP Basic Authentication", :basic_auth => true do
-    sometimes "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, @backend.path("/riak/", "auth"))
-      response[:code].should == 200
-    end
-  end
-
-  describe "Invalid responses" do
-
-    def bad_request(method)
-      if method == :post || method == :put
-        @backend.send(method, 200, resource, "body")
-      else
-        @backend.send(method, 200, resource)
-      end
-    end
-
-    [:get, :post, :put, :delete].each do |method|
-      context method.to_s do
-
-        before(:each) do
-          setup_http_mock(method, resource.to_s, :body => "Failure!", :status => 400, 'Content-Type' => 'text/plain' )
-        end
-
-        it "raises an HTTPFailedRequest exeption" do
-          lambda { bad_request(method) }.should raise_error(Riak::HTTPFailedRequest)
-        end
-
-        it "should normalize the response header keys to lower case" do
-          begin
-            bad_request(method)
-          rescue Riak::HTTPFailedRequest => fr
-            fr.headers.keys.should =~ fr.headers.keys.collect(&:downcase)
-          else
-            fail "No exception raised!"
-          end
-        end
-
-      end
-    end
-
-  end
-
-end