riak-client 1.4.5 → 2.0.0.rc1

data/spec/support/mock_server.rb

@@ -1,81 +0,0 @@
-# -*- 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

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

data/spec/support/riak_test.rb

@@ -1,77 +0,0 @@
-require 'riak/test_server'
-
-# This class is used for running the integration suite against
-# existing Riak nodes that have been preconfigured for test mode, e.g.
-# as part of the riak_test integration suite. This is only supported
-# on Riak versions > 1.2, with the KV backend set to memory with the
-# 'test' flag, and the Search backend set to the backend bundled with
-# the client (called riak_search_test_backend).
-class PrebuiltTestServer
-  def self.valid?
-    %W{RIAK_ROOT_DIR RIAK_NODE_NAME HTTP_PORT PB_PORT RIAK_VERSION}.all? {|e| ENV[e] }
-  end
-
-  attr_reader :http_port, :pb_port, :version, :root, :name
-
-  def initialize
-    @root = Pathname(ENV['RIAK_ROOT_DIR'])
-    @name = ENV['RIAK_NODE_NAME'].dup
-    @version = ENV['RIAK_VERSION'].dup[/\d+\.\d+\.\d+/, 0]
-    @http_port = ENV['HTTP_PORT'].to_i
-    @pb_port = ENV['PB_PORT'].to_i
-  end
-
-  def pipe
-    # Have to remove leading slash on root
-    @pipe ||= Pathname("/tmp") + @root.to_s[1..-1]
-  end
-
-  def exist?; true; end
-  def stop; end
-  def start; end
-  def started?; true; end
-
-  def drop
-    begin
-      maybe_attach
-      @console.command "riak_kv_memory_backend:reset()."
-      @console.command "riak_search_test_backend:reset()."
-    rescue IOError
-      retry
-    end
-  end
-
-  def attach
-    Riak::Node::Console.open self
-  end
-
-  protected
-  # Tries to reattach the console if it's closed
-  def maybe_attach
-    unless open?
-      @console.close if @console && !@console.frozen?
-      @console = attach
-    end
-  end
-
-  def open?
-    @console && @console.open?
-  end
-end
-
-module PrebuiltTestServerSupport
-  def test_server
-    unless $test_server
-      if PrebuiltTestServer.valid?
-        $test_server = PrebuiltTestServer.new
-      else
-        super
-      end
-    end
-    $test_server
-  end
-end
-
-RSpec.configure do |config|
-  config.include PrebuiltTestServerSupport, :integration => true
-end

data/spec/support/sometimes.rb

@@ -1,46 +0,0 @@
-# Emulates the QuickCheck ?SOMETIMES macro.
-
-module Sometimes
-  def run_with_retries(example_to_run, retries)
-    self.example.metadata[:retries] ||= retries
-    retries.times do |t|
-      self.example.metadata[:retried] = t + 1
-      self.example.instance_variable_set(:@exception, nil)
-      example_to_run.run
-      break unless self.example.exception
-    end
-    if e = self.example.exception
-      new_exception = e.exception(e.message + "[Retried #{retries} times]")
-      new_exception.set_backtrace e.backtrace
-      self.example.instance_variable_set(:@exception, new_exception)
-    end
-  end
-end
-
-RSpec.configure do |config|
-  config.include Sometimes
-  config.alias_example_to :sometimes, :sometimes => true
-  config.add_setting :sometimes_retry_count, :default => 3
-
-  config.around(:each, :sometimes => true) do |example|
-    retries = example.metadata[:retries] || RSpec.configuration.sometimes_retry_count
-    run_with_retries(example, retries)
-  end
-
-  config.after(:suite) do
-    formatter = RSpec.configuration.formatters.first
-    color = lambda {|tint, msg| formatter.send(tint, msg) }
-    retried_examples = RSpec.world.example_groups.map do |g|
-      g.descendants.map do |d|
-        d.filtered_examples.select {|e| e.metadata[:sometimes] && e.metadata[:retried] > 1 }
-      end
-    end.flatten
-    formatter.message color[retried_examples.empty? ? :success_color : :pending_color, "\n\nRetried examples: #{retried_examples.count}"]
-    unless retried_examples.empty?
-      retried_examples.each do |e|
-        formatter.message "  #{e.full_description}"
-        formatter.message(color[:pending_color, "  [#{e.metadata[:retried]}/#{e.metadata[:retries]}] "] + RSpec::Core::Metadata::relative_path(e.location))
-      end
-    end
-  end
-end

data/spec/support/test_server.rb

@@ -1,61 +0,0 @@
-require 'riak/test_server'
-
-module TestServerSupport
-  def test_server
-    unless $test_server
-      begin
-        require 'yaml'
-        config = YAML.load_file(File.expand_path("../test_server.yml", __FILE__))
-        $test_server = Riak::TestServer.create(:root => config['root'],
-                                         :source => config['source'],
-                                         :min_port => config['min_port'] || 15000)
-      rescue SocketError => e
-        warn "Couldn't connect to Riak TestServer! #{$test_server.inspect}"
-        warn "Skipping remaining integration tests."
-        warn_crash_log
-        $test_server_fatal = e
-      rescue => e
-        warn "Can't run integration specs without the test server. Please create/verify spec/support/test_server.yml."
-        warn "Skipping remaining integration tests."
-        warn e.inspect
-        warn_crash_log
-        $test_server_fatal = e
-      end
-    end
-    $test_server
-  end
-
-  def test_server_fatal
-    $test_server_fatal
-  end
-
-  def warn_crash_log
-    if $test_server && crash_log = $test_server.log + 'crash.log'
-      warn crash_log.read if crash_log.exist?
-    end
-  end
-end
-
-RSpec.configure do |config|
-  config.include TestServerSupport, :integration => true
-
-  config.before(:each, :integration => true) do
-    fail "Test server not working: #{test_server_fatal}" if test_server_fatal
-    if example.metadata[:test_server] == false
-      test_server.stop
-    else
-      test_server.create unless test_server.exist?
-      test_server.start
-    end
-  end
-
-  config.after(:each, :integration => true) do
-    if test_server && !test_server_fatal && test_server.started? && example.metadata[:test_server] != false
-      test_server.drop
-    end
-  end
-
-  config.after(:suite) do
-    $test_server.stop if $test_server
-  end
-end

data/spec/support/test_server.yml.example

@@ -1,14 +0,0 @@
-# This is where the test server node will be generated. Something on
-# /tmp is usually ok.
-root: /tmp/riak-client-test-server
-
-# This is where Riak is installed on your system, that is, the path to
-# the 'riak' and 'riak-admin' scripts. I use a self-built node, but
-# here's where it will generally be on various platforms:
-#
-#                Linux:  /usr/sbin
-#  Solaris/OpenSolaris:  /opt/riak/bin
-#  Mac OS/X (Homebrew):  /usr/local/bin
-#    Source/Self built:  /path/to/your/install/rel/riak/bin
-#
-source: /Users/sean/Development/riak/rel/riak/bin