right_develop 1.1.0

data/features/step_definitions/http_client_steps.rb

@@ -0,0 +1,27 @@
+When /^a client makes a (buggy )?request to '(.*)'$/ do |buggy, path|
+  t = RightDevelop::Net::HTTPClient::DEFAULT_OPTIONS[:timeout]
+  o = RightDevelop::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 = RightDevelop::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

@@ -0,0 +1,93 @@
+# 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
+      RightDevelop::Net::HTTPClient.new.get(endpoint, {:timeout => 1, :open_timeout => 1})
+      true
+    rescue Exception => e
+      false
+    end
+  end
+
+  @options ||= { :policy => constantize("RightDevelop::Net::LB::" + policy), :health_check => @health_check }
+end
+
+When /^a client makes a (buggy )?load-balanced request to '(.*)'$/ do |buggy, path|
+  t = RightDevelop::Net::HTTPClient::DEFAULT_OPTIONS[:timeout]
+  o = RightDevelop::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 = RightDevelop::Net::RequestBalancer.new(urls)
+  @request_attempts = 0
+  @request_t0 = Time.now
+  @http_client = RightDevelop::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

@@ -0,0 +1,206 @@
+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_develop', :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 RightDevelop::CI::RakeTask$/ do
+  step 'a Rakefile'
+  rakefile = ruby_app_path('Rakefile')
+  File.open(rakefile, 'w') do |file|
+    file.puts "require 'right_develop'"
+    file.puts "RightDevelop::CI::RakeTask.new"
+  end
+end
+
+Given /^the Rakefile contains a RightDevelop::CI::RakeTask with parameter '(.*)'$/ do |ns|
+  step 'a Rakefile'
+  rakefile = ruby_app_path('Rakefile')
+  File.open(rakefile, 'w') do |file|
+    file.puts "require 'right_develop'"
+    file.puts "RightDevelop::CI::RakeTask.new(#{ns})"
+  end
+end
+
+Given /^the Rakefile contains:$/ do |content|
+  step 'a Rakefile'
+  rakefile = ruby_app_path('Rakefile')
+  File.open(rakefile, 'w') do |file|
+    file.puts "require 'right_develop'"
+    content.split("\n").each do |line|
+      file.puts line
+    end
+  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)
+  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
+
+Given /^an RSpec spec named '([A-Za-z0-9_.]+)' with content:$/ do |name, content|
+  spec_dir = ruby_app_path('spec')
+  spec = ruby_app_path('spec', name)
+  FileUtils.mkdir_p(spec_dir)
+  File.open(spec, 'w') do |file|
+    content.split("\n").each do |line|
+      file.puts line
+    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 (not )?exist?$/ do |file, negatory|
+  file = ruby_app_path(file)
+
+  if negatory.nil? || negatory.empty?
+    Pathname.new(file).should exist
+  else
+    Pathname.new(file).should_not exist
+  end
+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

@@ -0,0 +1,96 @@
+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 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 = RightDevelop::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
+    RightDevelop::Data::Serializer::Encoder.load(@serialized_value).should ==
+    RightDevelop::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
+
+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

data/features/step_definitions/server_steps.rb

@@ -0,0 +1,134 @@
+#--  -*- mode: ruby; encoding: utf-8 -*-
+# Copyright: Copyright (c) 2011 RightScale, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# 'Software'), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require 'webrick'
+require 'webrick/httpservlet'
+
+# Mimic a generic HTTP server with various configurable behaviors
+class MockServer < WEBrick::HTTPServer
+  attr_accessor :thread, :port, :url
+
+  # Overridden factory method that will tolerate Errno::EADDRINUSE in case a certain
+  # TCP port is already used
+  def self.new(*args)
+    tries ||= 0
+    super
+  rescue Errno::EADDRINUSE => e
+    tries += 1
+    if tries > 5
+      raise
+    else
+      retry
+    end
+  end
+
+  def initialize(options={})
+    @port = options[:port] || (4096 + rand(32768-4096))
+    @url = "http://localhost:#{@port}"
+
+    logger = WEBrick::Log.new(STDERR, WEBrick::Log::FATAL)
+    super(options.merge(:Port => @port, :AccessLog => [], :Logger=>logger))
+
+    # mount servlets via callback
+    yield(self)
+
+    #Start listening for HTTP in a separate thread
+    @thread = Thread.new do
+      self.start()
+    end
+  end
+end
+
+# Mimic a server that exists but hangs without providing any response, not even
+# ICMP signals e.g. host unreachable or network unreachable. We simulate this
+# by pointing at a port of the RightScale (my) load balancer that is not allowed
+# by the security group, which causes the TCP SYN packets to be dropped with no
+# acknowledgement.
+class BlackholedServer
+  attr_accessor :port, :url
+
+  def initialize(options={})
+    @port = options[:port] || (4096 + rand(4096))
+    @url = "my.rightscale.com:#{@port}"
+  end
+end
+
+Before do
+  @mock_servers = []
+end
+
+# Kill running reposes after test finishes.
+After do
+  @mock_servers.each do |server|
+    if server.is_a?(MockServer)
+      server.thread.kill
+    end
+  end
+end
+
+Given /^(an?|\d+)? (overloaded|blackholed) servers?$/ do |number, behavior|
+  number = 0 if number =~ /no/
+  number = 1 if number =~ /an?/
+  number = number.to_i
+  
+  number.times do
+    case behavior
+      when 'overloaded'
+        proc = Proc.new do
+          sleep(10)
+          'Hi there! I am overloaded.'
+        end
+        server = MockServer.new do |s|
+          s.mount('/', WEBrick::HTTPServlet::ProcHandler.new(proc))
+        end
+      when 'blackholed'
+        server = BlackholedServer.new()
+      else
+        raise ArgumentError, "Unknown server behavior #{behavior}"
+    end
+
+    @mock_servers << server
+  end
+end
+
+Given /^(an?|\d+)? servers? that responds? with ([0-9]+)$/ do |number, status_code|
+  number = 0 if number =~ /no/
+  number = 1 if number =~ /an?/
+  number = number.to_i
+
+  status_code = status_code.to_i
+
+  proc = Proc.new do
+    klass = WEBrick::HTTPStatus::CodeToError[status_code]
+    klass.should_not be_nil
+    raise klass, "Simulated #{status_code} response"
+  end
+
+  number.times do
+    server = MockServer.new do |s|
+      s.mount('/', WEBrick::HTTPServlet::ProcHandler.new(proc))
+    end
+
+    @mock_servers << server
+  end
+end