seomoz-riak-client 1.0.0.pre

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'rubygems' # Use the gems path only for the spec suite
+require 'riak'
+require 'rspec'
+require 'fakeweb'
+
+# Only the tests should really get away with this.
+Riak.disable_list_keys_warnings = true
+
+begin
+  require 'yaml'
+  require 'riak/test_server'
+  config = YAML.load_file("spec/support/test_server.yml")
+  $test_server = Riak::TestServer.new(config.symbolize_keys)
+  $test_server.prepare!
+  $test_server.start
+  at_exit { $test_server.cleanup }
+rescue => e
+  warn "Can't run Riak::TestServer specs. Specify the location of your Riak installation in spec/support/test_server.yml. See Riak::TestServer docs for more info."
+  warn e.inspect
+end
+
+Dir[File.join(File.dirname(__FILE__), "support", "*.rb")].sort.each {|f| require f }
+
+
+RSpec.configure do |config|
+  config.debug = true
+  config.mock_with :rspec
+  
+  config.before(:each) do
+    Riak::RObject.on_conflict_hooks.clear
+    FakeWeb.clean_registry
+  end
+
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+end

data/spec/support/drb_mock_server.rb

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

@@ -0,0 +1,266 @@
+shared_examples_for "HTTP backend" do
+  describe "HEAD requests" do
+    before :each do
+      setup_http_mock(:head, @backend.path("/riak/","foo").to_s, :body => "")
+    end
+
+    it "should return only the headers when the request succeeds" do
+      response = @backend.head(200, "/riak/","foo")
+      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, "/riak/", "foo") }.should raise_error(Riak::FailedRequest)
+    end
+
+    it "should raise an error if an invalid resource path is given" do
+      lambda { @backend.head(200, "/riak/") }.should raise_error(ArgumentError)
+    end
+
+    it "should not raise a FailedRequest if one of the expected response codes matches" do
+      lambda { @backend.head([200, 301], "/riak/", "foo") }.should_not raise_error(Riak::FailedRequest)
+    end
+  end
+
+  describe "GET requests" do
+    before :each do
+      setup_http_mock(:get, @backend.path("/riak/","foo").to_s, :body => "Success!")
+    end
+
+    it "should return the response body and headers when the request succeeds" do
+      response = @backend.get(200, "/riak/","foo")
+      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, "/riak/","foo") }.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], "/riak/","foo") }.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, "/riak/","foo") 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 an invalid resource path is given" do
+      lambda { @backend.get(200, "/riak/") }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "DELETE requests" do
+    before :each do
+      setup_http_mock(:delete, @backend.path("/riak/","foo").to_s, :body => "Success!")
+    end
+
+    it "should return the response body and headers when the request succeeds" do
+      response = @backend.delete(200, "/riak/","foo")
+      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, "/riak/","foo") }.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], "/riak/","foo") }.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, "/riak/","foo") 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 an invalid resource path is given" do
+      lambda { @backend.delete(200, "/riak/") }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "PUT requests" do
+    before :each do
+      setup_http_mock(:put, @backend.path("/riak/","foo").to_s, :body => "Success!")
+    end
+
+    it "should return the response body, headers, and code when the request succeeds" do
+      response = @backend.put(200, "/riak/","foo", "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, "/riak/","foo", "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], "/riak/","foo", "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, "/riak/","foo", "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 an invalid resource path is given" do
+      lambda { @backend.put(200, "/riak/") }.should raise_error(ArgumentError)
+    end
+
+    it "should raise an error if no body data is given" do
+      lambda { @backend.put(200, "/riak/","foo") }.should raise_error(ArgumentError)
+    end
+
+    it "should raise an error if the body is not a string" do
+      lambda { @backend.put(200, "/riak/","foo", 123) }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "POST requests" do
+    before :each do
+      setup_http_mock(:post, @backend.path("/riak/","foo").to_s, :body => "Success!")
+    end
+
+    it "should return the response body, headers, and code when the request succeeds" do
+      response = @backend.post(200, "/riak/","foo", "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, "/riak/", "foo", "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], "/riak/", "foo", "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, "/riak/", "foo", "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 an invalid resource path is given" do
+      lambda { @backend.post(200, "/riak/") }.should raise_error(ArgumentError)
+    end
+
+    it "should raise an error if no body data is given" do
+      lambda { @backend.post(200, "/riak/", "foo") }.should raise_error(ArgumentError)
+    end
+
+    it "should raise an error if the body is not a string" do
+      lambda { @backend.post(200, "/riak/", "foo", 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, @backend.path("/riak/","foo").to_s, :status => code)
+          response = if method == :post || method == :put
+                       @backend.send(method, code,"/riak/","foo", "This is the body")
+                     else
+                       @backend.send(method, code, "/riak/", "foo")
+                     end
+          response.should_not have_key(:body)
+        end
+      end
+    end
+  end
+
+  describe "SSL" do
+    it "should be supported" do
+      @client.http_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
+
+  describe "Invalid responses" do
+
+    def bad_request(method)
+      if method == :post || method == :put
+        @backend.send(method, 200, "/riak/","foo", "body")
+      else
+        @backend.send(method, 200, "/riak/","foo")
+      end
+    end
+
+    [:get, :post, :put, :delete].each do |method|
+      context method.to_s do
+
+        before(:each) do
+          setup_http_mock(method, @backend.path("/riak/","foo").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

data/spec/support/integration_setup.rb

@@ -0,0 +1,10 @@
+# auto-tag all integration specs with :integration => true
+module IntegrationSpecs
+  def self.included(klass)
+    klass.metadata[:integration] = true
+  end
+end
+
+RSpec.configure do |config|
+  config.include IntegrationSpecs, :example_group => { :file_path => %r{spec/integration} }
+end

data/spec/support/mock_server.rb

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+# 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
+  attr_accessor :satisfied
+
+  def initialize(pause = 1)
+    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, 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)
+    attach do |env|
+      @satisfied = (env["REQUEST_METHOD"] == method &&
+                    env["PATH_INFO"] == path &&
+                    env["QUERY_STRING"] == query)
+      [status, headers, Array(body)]
+    end
+  end
+
+  def attach(&block)
+    @block = block
+  end
+
+  def detach()
+    @block = nil
+  end
+
+  def call(env)
+    begin
+      raise "Specify a handler for the request using attach(block), the block should return a valid rack response and can test expectations" unless @block
+      @block.call(env)
+    rescue Exception => e
+      @satisfied = false
+      # @parent_thread.raise e
+      body = "Bad test code\n#{e.inspect}\n#{e.backtrace}"
+      [ 500, { 'Content-Type' => 'text/plain', 'Content-Length' => body.length.to_s }, [ body ]]
+    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
+    def warn(msg)  end
+    def info(msg)  end
+    def debug(msg) end
+  end
+end

data/spec/support/mocks.rb

@@ -0,0 +1,4 @@
+
+def mock_response(overrides={})
+  {:headers => {"content-type" => ["application/json"]}, :body => '{}'}.merge(overrides)
+end

data/spec/support/test_server.yml.example

@@ -0,0 +1,2 @@
+bin_dir: /Users/sean/Development/riak/rel/riak/bin
+temp_dir: /Users/sean/Development/ripple/.riaktest