right_support 2.11.3 → 2.12.1

data/features/serialization.feature

@@ -1,113 +0,0 @@
-Feature: JSON serialization
-  In order to facilitate Ruby apps' use of external JSON data stores
-  RightSupport should cleanly serialize arbitrary Ruby objects to JSON without data loss or semantic ambiguity
-  So app code can be idiomatic and focus on the business problem, not the encoding details
-
-  Background:
-    Given a serializer named 'RightSupport::Data::Serializer'
-    And a stateful Ruby class named 'GotState'
-
-  Scenario Outline: Ruby types with a native JSON representation
-    When I serialize the Ruby value: <ruby>
-    Then the serialized value should be: <json>
-    And the serialized value should round-trip cleanly
-
-  Examples:
-    | ruby                                  | json                               |
-    | true                                  | true                               |
-    | false                                 | false                              |
-    | nil                                   | null                               |
-    | 0                                     | 0                                  |
-    | 42                                    | 42                                 |
-    | -32                                   | -32                                |
-    | 3.1415926535                          | 3.1415926535                       |
-    | 0xFFFFFFFFFFFFFFFFFFFFFFFF            | 79228162514264337593543950335      |
-    | "hello, world!"                       | "hello, world!"                    |
-    | [0,true,nil,['a',false]]              | [0,true,null,["a",false]]          |
-    | {"one"=>2}                            | {"one":2}                          |
-    | {"hash"=>{"lucky"=>777,"seq"=>[2,3]}} | {"hash":{"lucky":777,"seq":[2,3]}} |
-
-  Scenario: complex Ruby structures with a native JSON representation
-    When I serialize a complex random data structure
-    Then the serialized value should round-trip cleanly
-
-  Scenario: invalid UTF-8 characters
-    When I serialize the Ruby value: "\xC0\xBCscript>\xC0\xBC/script>"
-    Then the serialized value should have no invalid characters
-
-  Scenario: valid UTF-8 characters
-    When I serialize the Ruby value: "onê"
-    Then the serialized value should be: "onê"
-    And the serialized value should round-trip cleanly
-
-  Scenario Outline: object-escaped Symbol
-    When I serialize the Ruby value: <ruby>
-    Then the serialized value should be: <json>
-    And the serialized value should round-trip cleanly
-
-  Examples:
-    | ruby            | json            |
-    | :my_symbol      | ":my_symbol"    |
-    | :'weird symbol' | ":weird symbol" |
-
-  Scenario Outline: object-escaped Time
-    When I serialize the Ruby value: <ruby>
-    Then the serialized value should be: <json>
-    And the serialized value should round-trip cleanly
-
-  Examples:
-    | ruby                                                 | json                   |
-    | Time.at(1234567890)                                  | "2009-02-13T23:31:30Z" |
-    | Time.at(1234567890).utc                              | "2009-02-13T23:31:30Z" |
-
-  Scenario Outline: object-escaped String
-    When I serialize the Ruby value: <ruby>
-    Then the serialized value should be: <json>
-    And the serialized value should round-trip cleanly
-
-  Examples:
-    | ruby            | json                                             |
-    | ":not_a_symbol" | {"_ruby_class":"String","value":":not_a_symbol"} |
-
-  Scenario Outline: Ruby Class and Module types
-
-  Scenario Outline: Ruby Class and Module types
-    When I serialize the Ruby value: <ruby>
-    Then the serialized value should be a JSON object
-    And the serialized value should round-trip cleanly
-
-  Examples:
-    | ruby                              |
-    | String                            |
-    | RightSupport::Ruby::EasySingleton |
-    | RightSupport::Net::HTTPClient     |
-    | Hash                              |
-    | Kernel                            |
-
-  Scenario Outline: arbitrary Ruby objects
-    When I serialize the Ruby value: <ruby>
-    Then the serialized value should be a JSON object
-    And the serialized value should have a suitable _ruby_class
-
-  Examples:
-    | ruby                                   |
-    | RightSupport::Crypto::SignedHash.new() |
-    | GotState.new                           |
-
-  Scenario: arbitrary Ruby object round-trip, happy path
-    When I serialize the Ruby value: GotState.new
-    Then the serialized value should round-trip cleanly
-
-  Scenario: arbitrary Ruby object round-trip, sad path
-    When I serialize the Ruby value: GotState.new
-    And an eldritch force deletes a key from the serialized value
-    And the serialized value should fail to round-trip
-
-  Scenario: unrecognized Ruby object class
-    When I unserialize the JSON value: {"_ruby_class":"DoesNotExist","hello":"world"}
-    Then the unserialized object should be an RightSupport::Data::UnknownType
-    And the unserialized object should have a "hello" attribute with value: "world"
-
-  Scenario: unrecognized Ruby object class
-    When I serialize the Ruby value: RightSupport::Data::UnknownType.new("DoesNotExist", {"hello" => "world"})
-    Then the serialized value should be: {"_ruby_class":"DoesNotExist","hello":"world"}

data/features/step_definitions/hash_tools_steps.rb

@@ -1,41 +0,0 @@
-require 'json'
-
-Given /^a hash map with the form (.*)$/ do |hash|
-  @hash = JSON.parse(hash)
-end
-
-Given /^a path array (.*)$/ do |path|
-  @path = JSON.parse(path)
-end
-
-Given /^a value (.*)$/ do |value|
-  @value = value
-end
-
-When /^I call the deep_get method$/ do
-  @deep_get_value = RightSupport::Data::HashTools.deep_get(@hash, @path)
-end
-
-When /^I call the deep_set! method$/ do
-  RightSupport::Data::HashTools.deep_set!(@hash, @path, @value)
-end
-
-When /^I call the deep_merge! method with the source: (.*)$/ do |source|
-  RightSupport::Data::HashTools.deep_merge!(@hash, JSON.parse(source))
-end
-
-When /^I call the deep_remove! method with the source: (.*)$/ do |source|
-  RightSupport::Data::HashTools.deep_remove!(@hash, JSON.parse(source))
-end
-
-Then /^The hash should be: (.*)$/ do |hash|
-  @hash == JSON.parse(hash)
-end
-
-Then /^The deep_get method response should be: (.*)$/ do |expression|
-  @deep_get_value == expression
-end
-
-Then /^The generate method response should be: (.*)$/ do |expression|
-  @generated_value == expression
-end

data/features/step_definitions/http_client_steps.rb

@@ -1,27 +0,0 @@
-When /^a client makes a (buggy )?request to '(.*)'$/ do |buggy, path|
-  t = RightSupport::Net::HTTPClient::DEFAULT_OPTIONS[:timeout]
-  o = RightSupport::Net::HTTPClient::DEFAULT_OPTIONS[:open_timeout]
-  When "a client makes a #{buggy}request to '#{path}' with timeout #{t} and open_timeout #{o}"
-end
-
-
-When /^a client makes a (buggy )?request to '(.*)' with timeout (\d+) and open_timeout (\d+)$/ do |buggy, path, timeout, open_timeout|
-  buggy = !(buggy.nil? || buggy.empty?)
-
-  @mock_servers.should_not be_nil
-  @mock_servers.size.should == 1
-
-  timeout = timeout.to_i
-  open_timeout = open_timeout.to_i
-  url = @mock_servers.first.url
-
-  @http_client = RightSupport::Net::HTTPClient.new(:timeout=>timeout, :open_timeout=>open_timeout)
-  @request_t0 = Time.now
-  begin
-    raise ArgumentError, "Fall down go boom!" if buggy
-    @http_client.get("#{url}#{path}", {:timeout => timeout, :open_timeout => open_timeout})
-  rescue Exception => e
-    @request_error = e
-  end
-  @request_t1 = Time.now
-end

data/features/step_definitions/request_balancer_steps.rb

@@ -1,93 +0,0 @@
-# Rails' constantize method to convert passed in policy to the actual class
-def constantize(camel_cased_word)
-  names = camel_cased_word.split('::')
-  names.shift if names.empty? || names.first.empty?
-
-  constant = Object
-  names.each do |name|
-    constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
-  end
-  constant
-end
-
-Given /^(\w+) balancing policy$/ do |policy|
-  @health_check = Proc.new do |endpoint|
-    begin
-      RightSupport::Net::HTTPClient.new.get(endpoint, {:timeout => 1, :open_timeout => 1})
-      true
-    rescue Exception => e
-      false
-    end
-  end
-
-  @options ||= { :policy => constantize("RightSupport::Net::LB::" + policy), :health_check => @health_check }
-end
-
-When /^a client makes a (buggy )?load-balanced request to '(.*)'$/ do |buggy, path|
-  t = RightSupport::Net::HTTPClient::DEFAULT_OPTIONS[:timeout]
-  o = RightSupport::Net::HTTPClient::DEFAULT_OPTIONS[:open_timeout]
-  step "a client makes a #{buggy}load-balanced request to '#{path}' with timeout #{t} and open_timeout #{o}"
-end
-
-When /^a client makes a (buggy )?load-balanced request to '(.*)' with timeout (\d+) and open_timeout (\d+)$/ do |buggy, path, timeout, open_timeout|
-  buggy = !(buggy.nil? || buggy.empty?)
-
-  @mock_servers.should_not be_nil
-  @mock_servers.empty?.should be_false
-
-  timeout = timeout.to_i
-  open_timeout = open_timeout.to_i
-  urls = @mock_servers.map { |s| s.url }
-  @request_balancer = RightSupport::Net::RequestBalancer.new(urls)
-  @request_attempts = 0
-  @request_t0 = Time.now
-  @http_client = RightSupport::Net::HTTPClient.new
-  begin
-    @request_balancer.request do |url|
-      @request_attempts += 1
-      raise ArgumentError, "Fall down go boom!" if buggy
-      @http_client.get("#{url}#{path}", {:timeout => timeout, :open_timeout => open_timeout})
-    end
-  rescue Exception => e
-    @request_error = e
-  end
-  @request_t1 = Time.now
-end
-
-Then /^the request should (\w+ ?\w*)$/ do |behavior|
-  case behavior
-    when 'complete'
-      error_expected = false
-    when 'raise'
-      error_expected = true
-    when /raise (\w+)/
-      error_expected = true
-      error_class_expected = /raise (\w+)/.match(behavior)[1]
-    else
-      raise ArgumentError, "Unknown request behavior #{behavior}"
-  end
-
-  if !error_expected && @request_error
-    puts '!' * 80
-    puts @request_error.class.inspect
-    puts @request_error.class.superclass.inspect
-    puts '!' * 80
-  end
-  @request_error.should be_nil unless error_expected
-  @request_error.should_not be_nil if error_expected
-  @request_error.class.name.should =~ Regexp.new(error_class_expected) if error_class_expected
-end
-
-Then /^the request should (\w+ ?\w*) in less than (\d+) seconds?$/ do |behavior, time|
-  step "the request should #{behavior}"
-  #allow 10% margin of error due to Ruby/OS scheduler variance
-  (@request_t1.to_f - @request_t0.to_f).should <= (time.to_f * 1.10)
-end
-
-Then /^the request should be attempted once$/ do
-  @request_attempts.should == 1
-end
-
-Then /^the request should be attempted ([0-9]+) times$/ do |n|
-  @request_attempts.should == n.to_i
-end

data/features/step_definitions/ruby_steps.rb

@@ -1,176 +0,0 @@
-require 'nokogiri'
-
-Given /^a Ruby application$/ do
-  ruby_app_root.should_not be_nil
-end
-
-Given /^a Gemfile$/ do
-  gemfile = ruby_app_path('Gemfile')
-  unless File.exist?(gemfile)
-    basedir = File.expand_path('../../..', __FILE__)
-    File.open(gemfile, 'w') do |file|
-      file.puts "gem 'right_support', :path=>'#{basedir}'"
-    end
-  end
-end
-
-Given /^a gem dependency on '(.*)'$/ do |dependency|
-  step 'a Gemfile'
-  gem, version = dependency.split(/\s+/, 2)
-  gemfile = ruby_app_path('Gemfile')
-  File.open(gemfile, 'a') do |file|
-    file.puts "gem '#{gem}', '#{version}'"
-  end
-end
-
-Given /^a Rakefile$/ do
-  rakefile = ruby_app_path('Rakefile')
-  unless File.exist?(rakefile)
-    File.open(rakefile, 'w') do |file|
-      file.puts "# Auto-generated by #{__FILE__}"
-    end
-  end
-end
-
-Given /^the Rakefile contains a RightSupport::CI::RakeTask$/ do
-  step 'a Rakefile'
-  rakefile = ruby_app_path('Rakefile')
-  File.open(rakefile, 'w') do |file|
-    file.puts "require 'right_support/ci/rake_task'"
-    file.puts "RightSupport::CI::RakeTask.new"
-  end
-end
-
-Given /^the Rakefile contains a RightSupport::CI::RakeTask with parameter '(.*)'$/ do |ns|
-  step 'a Rakefile'
-  rakefile = ruby_app_path('Rakefile')
-  File.open(rakefile, 'w') do |file|
-    file.puts "require 'right_support/ci/rake_task'"
-    file.puts "RightSupport::CI::RakeTask.new(#{ns})"
-  end
-end
-
-Given /^a trivial (failing )?RSpec spec$/ do |failing|
-  spec_dir = ruby_app_path('spec')
-  spec = ruby_app_path('spec', 'trivial_spec.rb')
-  FileUtils.mkdir_p(spec_dir)
-  unless File.exist?(spec)
-    File.open(spec, 'w') do |file|
-      file.puts "describe String do"
-      file.puts "  it 'has a size' do"
-      file.puts "    'joe'.size.should == 3"
-      file.puts "  end"
-      file.puts
-      file.puts "  it 'is stringy' do"
-      file.puts "    pending"
-      file.puts "  end"
-      unless failing.nil?
-        file.puts
-        file.puts "it 'meets an impossible ideal' do"
-        file.puts "  raise NotImplementedError, 'inconceivable!'"
-        file.puts "end"
-      end
-      file.puts "end"
-    end
-  end
-end
-
-Given /^a trivial (failing )?Cucumber feature$/ do |failing|
-  features_dir = ruby_app_path('features')
-  steps_dir    = ruby_app_path('features', 'step_definitions')
-  feature      = ruby_app_path('features', 'trivial.feature')
-  steps        = ruby_app_path('features', 'step_definitions', 'trivial_steps.rb')
-  FileUtils.mkdir_p(features_dir)
-  FileUtils.mkdir_p(steps_dir)
-
-  unless File.exist?(steps)
-    File.open(steps, 'w') do |file|
-      file.puts "When /^the night has come and the land is dark$/ do; end"
-      file.puts "When /^the moon is the only light we see$/ do; end"
-      file.puts "Then /^I won't be afraid.*$/ do; end"
-      file.puts "Then /^as long as you stand.*by me$/ do; end"
-      file.puts "Then /^you run away as fast as you can$/ do; raise NotImplementedError; end"
-    end
-  end
-  unless File.exist?(feature)
-    File.open(feature, 'w') do |file|
-      file.puts "Feature: Song Lyrics from the 1950s"
-      file.puts
-      file.puts "  Scenario: Stand By Me"
-      file.puts "    When the night has come and the land is dark"
-      file.puts "    And the moon is the only light we see"
-      file.puts "    Then I won't be afraid, oh, I won't be afraid"
-      if failing.nil?
-        file.puts "    And as long as you stand, stand by me"
-      else
-        file.puts "    And you run away as fast as you can"
-      end
-    end
-  end
-end
-
-When /^I install the bundle$/ do
-  ruby_app_shell('bundle install')
-end
-
-When /^I rake '(.*)'$/ do |task|
-  @ruby_app_output = ruby_app_shell("bundle exec rake #{task} --trace ", :ignore_errors => true)
-end
-
-When /^I debug the app shell$/ do
-  STDOUT.puts "Opening shell in a separate window."
-  if RUBY_PLATFORM =~ /darwin/
-    ruby_app_shell("open -a Terminal .")
-  else
-    raise "Don't know how to open an app shell for #{RUBY_PLATFORM}; please contribute your knowledge to #{__FILE__}"
-  end
-  STDOUT.puts "Press Enter to continue Cucumber execution..."
-  STDOUT.flush
-  STDIN.readline
-end
-
-Then /^the output should contain '(.*)'$/ do |expected_output|
-  @ruby_app_output.should include(expected_output)
-end
-
-Then /^the output should not contain '(.*)'$/ do |expected_output|
-  @ruby_app_output.should_not include(expected_output)
-end
-
-Then /^the directory '(.*)' should contain files/ do |dir|
-  dir = ruby_app_path(dir)
-  File.directory?(dir).should be_true
-  Dir[File.join(dir, '*')].should_not be_empty
-end
-
-Then /^the file '(.*)' should mention ([0-9]) (passing|failing) test cases?$/ do |file, n, pass_fail|
-  file = ruby_app_path(file)
-  n = Integer(n)
-
-  Pathname.new(file).should exist
-
-  doc = Nokogiri.XML(File.open(file, 'r'))
-
-  all_testcases = doc.css('testcase').size
-  failing_testcases = doc.css('testcase failure').size
-  passing_testcases = all_testcases - failing_testcases
-
-  case pass_fail
-  when 'passing'
-    passing_testcases.should == n
-  when 'failing'
-    failing_testcases.should == n
-  else
-    raise NotImplementedError, "WTF #{pass_fail}"
-  end
-end
-
-Then /^the command should (succeed|fail)$/ do |success|
-  if success == 'succeed'
-    $?.exitstatus.should == 0
-  elsif success == 'fail'
-    $?.exitstatus.should_not == 0
-  else
-    raise NotImplementedError, "Unknown expectation #{success}"
-  end
-end

data/features/step_definitions/serialization_steps.rb

@@ -1,133 +0,0 @@
-Given /^a serializer named '(.+)'$/ do |klass|
-  @serializer = klass.to_const
-end
-
-Given /^a stateful Ruby class named '(.*)'$/ do |name|
-  name = name.to_sym
-  ivars = 1 + rand(10)
-
-
-  Kernel.__send__(:remove_const, name) if Kernel.const_defined?(name)
-
-  @stateful_ruby_class = Class.new(Object)
-  Kernel.__send__(:const_set, name, @stateful_ruby_class)
-
-  @stateful_ruby_class.instance_eval do
-    define_method(:initialize) do
-      ivars.times do
-        self.instance_variable_set("@instance_variable_#{random_value(Integer)}", random_value(nil, [String]))
-      end
-    end
-
-    define_method(:==) do |other|
-      result = (Set.new(self.instance_variables) == Set.new(other.instance_variables))
-
-      self.instance_variables.each do |ivar|
-        result &&= (self.instance_variable_get(ivar) == other.instance_variable_get(ivar))
-      end
-
-      result
-    end
-  end
-end
-
-When /^I serialize the Ruby value: (.*)$/ do |expression|
-  @ruby_value = eval(expression)
-  @serialized_value = @serializer.dump(@ruby_value)
-end
-
-When /^I unserialize the JSON value: (.*)$/ do |value|
-  @serialized_value = value
-  @ruby_value = @serializer.load(@serialized_value)
-end
-
-When /^I serialize a complex random data structure$/ do
-  @ruby_value = random_value(nil, [String])
-  @serialized_value = @serializer.dump(@ruby_value)
-end
-
-When /^an eldritch force deletes a key from the serialized value$/ do
-  hash = RightSupport::Data::Serializer::Encoder.load(@serialized_value)
-  hash.delete(hash.keys[rand(hash.keys.size)])
-  @serialized_value = @serializer.dump(hash)
-end
-
-Then /^the serialized value should be: (.*)$/ do |expression|
-  if (@serialized_value =~ /^\{/) || (expression =~ /^\{/)
-    # Hash: ordering of JSON representation is unimportant; load as pure JSON and compare values
-    RightSupport::Data::Serializer::Encoder.load(@serialized_value).should ==
-    RightSupport::Data::Serializer::Encoder.load(expression)
-  else
-    # Any other data: exact comparison
-    @serialized_value.should == expression
-  end
-end
-
-Then /^the serialized value should round-trip cleanly$/ do
-  case @ruby_value
-  when Float
-    # Floating-point numbers lose some precision due to truncation
-    @serializer.load(@serialized_value).should be_within(0.000001).of(@ruby_value)
-  when Time
-    # Times are stored with accuracy ~ 1 sec
-    @serializer.load(@serialized_value).to_i.should == @ruby_value.to_i
-  else
-    # Everything else should compare identical
-    @serializer.load(@serialized_value).should == @ruby_value
-  end
-end
-
-Then /^the serialized value should have no invalid characters$/ do
-  if @serialized_value.respond_to?(:valid_encoding?)
-    # modern Rubies
-    @serialized_value.valid_encoding?.should be_true
-  else
-    # Ruby 1.8
-    raised = false
-    begin
-      iconv = Iconv.new('UTF-8', 'UTF-8')
-      iconv.iconv(@serialized_value)
-    rescue Exception => e
-      raised = true
-    end
-
-    raised.should be_false
-  end
-end
-
-When /^the serialized value should fail to round\-trip$/ do
-  @serializer.load(@serialized_value).should_not == @ruby_value
-end
-
-Then /^the serialized value should be a JSON (.*)$/ do |json_type|
-  case json_type
-    when 'object'
-      @serialized_value.should =~ /^\{.*\}$/
-    when 'string'
-      @serialized_value.should =~ /^".*"$/
-    when 'number'
-      @serialized_value.should =~ /^".*"$/
-    when 'true', 'false', 'null'
-      @serialized_value.should == json_type
-    else
-      raise NotImplementedError, "Unknown JSON type"
-  end
-end
-
-Then /^the serialized value should have a suitable _ruby_class$/ do
-  @serialized_value.should =~ /"_ruby_class":"#{Regexp.escape(@ruby_value.class.name)}"/
-end
-
-Then /^the unserialized object should be an? (.*)$/ do |class_name|
-  klass = class_name.to_const
-  klass.should_not be_nil
-  @ruby_value.should be_a(klass)
-end
-
-Then /^the unserialized object should have a "(.*)" attribute with value: (.*)$/ do |attr, value|
-  attr = attr.to_sym
-  value = eval(value)
-
-  @ruby_value.should respond_to(attr)
-  @ruby_value.__send__(attr).should == value
-end