rr 1.1.1 → 3.0.0

data/spec/support/adapter.rb

@@ -0,0 +1,22 @@
+require 'appraisal/file'
+
+class Adapter
+  attr_reader :name
+
+  def initialize(name)
+    @name = name
+  end
+
+  def appraisal_name
+    parts = []
+    parts << 'ruby_19'
+    parts << name
+    parts.join('_')
+  end
+
+  def appraisal
+    @appraisal ||= Appraisal::File.new.appraisals.find do |appraisal|
+      appraisal.name == appraisal_name
+    end
+  end
+end

data/spec/support/adapter_tests/base.rb

@@ -0,0 +1,45 @@
+require 'set'
+
+module AdapterTests
+  module Base
+    private
+
+    def assert_stubs_work
+      subject = Object.new
+      stub(subject).foobar { :baz }
+      assert_equal :baz, subject.foobar("any", "thing")
+    end
+
+    def assert_mocks_work
+      subject = Object.new
+      mock(subject).foobar(1, 2) { :baz }
+      assert_equal :baz, subject.foobar(1, 2)
+    end
+
+    def assert_stub_proxies_work
+      subject = Object.new
+      def subject.foobar; :baz; end
+      stub.proxy(subject).foobar
+      assert_equal :baz, subject.foobar
+    end
+
+    def assert_mock_proxies_work
+      subject = Object.new
+      def subject.foobar; :baz; end
+      mock.proxy(subject).foobar
+      assert_equal :baz, subject.foobar
+    end
+
+    def assert_times_called_verifications_work
+      subject = Object.new
+      mock(subject).foobar(1, 2) { :baz }
+      assert_raises RR::Errors.error_class(:TimesCalledError) do
+        RR.verify
+      end
+    end
+
+    def assert_adapters_loaded(matching_adapters)
+      assert_subset Set.new(matching_adapters), Set.new(RR.loaded_adapter_names)
+    end
+  end
+end

data/spec/support/adapter_tests/minitest.rb

@@ -0,0 +1,7 @@
+require File.expand_path('../test_unit', __FILE__)
+
+module AdapterTests
+  module Minitest
+    include TestUnit
+  end
+end

data/spec/support/adapter_tests/rspec.rb

@@ -0,0 +1,70 @@
+require File.expand_path('../base', __FILE__)
+require File.expand_path('../../matchers/be_a_subset_of_matcher', __FILE__)
+
+module AdapterTests
+  module RSpec
+    include Base
+
+    def self.included(base)
+      base.class_eval do
+        specify 'stubs work' do
+          assert_stubs_work
+        end
+
+        specify 'mocks work' do
+          assert_mocks_work
+        end
+
+        specify 'stub proxies work' do
+          assert_stub_proxies_work
+        end
+
+        specify 'mock proxies work' do
+          assert_mock_proxies_work
+        end
+
+        specify 'times-called verifications work' do
+          assert_times_called_verifications_work
+        end
+
+        specify 'have_received works' do
+          subject = Object.new
+          stub(subject).foobar(1, 2)
+          subject.foobar(1, 2)
+          subject.should have_received.foobar(1, 2)
+
+          expect {
+            subject.should have_received.foobar(1, 2, 3)
+          }.to raise_error(
+            expectation_not_met_error,
+            /Expected foobar\(1, 2, 3\).+to be called 1 time/m
+          )
+        end
+      end
+    end
+
+    def expectation_not_met_error
+      if defined?(::RSpec)
+        ::RSpec::Expectations::ExpectationNotMetError
+      else
+        Spec::Expectations::ExpectationNotMetError
+      end
+    end
+
+    def assert_equal(expected, actual)
+      expected.should be == actual
+    end
+
+    def assert_subset(subset, set)
+      subset.should be_a_subset_of(set)
+    end
+
+    def assert_raises(error, &block)
+      expect(&block).to raise_error(error)
+    end
+
+    def be_a_subset_of(set)
+      BeASubsetOfMatcher.new(set)
+    end
+  end
+end

data/spec/support/adapter_tests/test_unit.rb

@@ -0,0 +1,47 @@
+require File.expand_path('../base', __FILE__)
+
+module AdapterTests
+  module TestUnit
+    include Base
+
+    def test_that_stubs_work
+      assert_stubs_work
+    end
+
+    def test_that_mocks_work
+      assert_mocks_work
+    end
+
+    def test_that_stub_proxies_work
+      assert_stub_proxies_work
+    end
+
+    def test_that_mock_proxies_work
+      assert_mock_proxies_work
+    end
+
+    def test_that_times_called_verifications_work
+      assert_times_called_verifications_work
+    end
+
+    def test_using_assert_received
+      subject = Object.new
+      stub(subject).foobar(1, 2)
+      subject.foobar(1, 2)
+      assert_received(subject) {|s| s.foobar(1, 2) }
+
+      error_class = RR::Errors.error_class(
+        RR::Errors::SpyVerificationErrors::InvocationCountError
+      )
+      assert_raises(error_class) do
+        assert_received(subject) {|s| s.foobar(1, 2, 3) }
+      end
+    end
+
+    def assert_subset(subset, set)
+      value = (subset - set).empty?
+      message = "Set 1 was not a subset of set 2.\nSet 1: #{subset.inspect}\nSet 2: #{set.inspect}"
+      assert value, message
+    end
+  end
+end

data/spec/support/command_runner.rb

@@ -0,0 +1,105 @@
+require 'open3'
+
+class CommandRunner
+  # http://stackoverflow.com/questions/6407141/how-can-i-have-ruby-logger-log-output-to-stdout-as-well-as-file
+  class MultiIO
+    def initialize(*targets)
+       @targets = targets
+    end
+
+    def write(*args)
+      @targets.each {|t| t.write(*args) }
+    end
+    alias_method :<<, :write
+
+    def close
+      @targets.each(&:close)
+    end
+  end
+
+  def self.call(command, options={})
+    new(command, options).call
+  end
+
+  attr_reader :command, :output, :exit_status
+
+  def initialize(command, options)
+    @command = command
+    #@command << " 2>&1" unless @command =~ / 2>&1$/
+    @output = ""
+  end
+
+  def call
+    @stdout_buffer = StringIO.new
+
+    puts "Running: #{@command}"
+
+    if defined?(JRUBY_VERSION)
+      call_using_popen4
+    else
+      call_using_spawn
+    end
+
+    if RR.debug?
+      puts "~ Output from `#{@command}` ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
+      puts @output
+      puts "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
+    end
+
+    self
+  end
+
+  def success?
+    @exit_status == 0
+  end
+
+  private
+
+  def call_using_session
+    reader, writer = IO.pipe
+    require 'session'
+    session = Session::Bash.new
+    session.execute(@command, :stdout => writer, :stderr => writer)
+    writer.close
+    @exit_status = session.exit_status
+    @output = reader.read
+  end
+
+  def call_using_popen4
+    reader, writer = IO.pipe
+
+    # Using popen4 here without a block will always result in an Errno::ECHILD
+    # error under JRuby: <http://jira.codehaus.org/browse/JRUBY-5684>
+    block = lambda { |pid, _, stdout, _| writer.write(stdout.read) }
+
+    if defined?(JRUBY_VERSION)
+      IO.popen4("#{@command} 2>&1", &block)
+    else
+      require 'open4'
+      Open4.popen4("#{@command} 2>&1", &block)
+    end
+
+    writer.close
+    @exit_status = $?.exitstatus
+    @output = reader.read
+  end
+
+  def call_using_spawn
+    reader, writer = IO.pipe
+    args = [@command, {[:out, :err] => writer}]
+    require 'posix-spawn'
+    pid = POSIX::Spawn.spawn(*args)
+    Process.waitpid(pid)
+    writer.close
+    @exit_status = $?.exitstatus
+    @output = reader.read
+  end
+
+  def build_stdout
+    ios = [@stdout_buffer]
+    #if RR.debug?
+    #  ios << $stdout
+    #end
+    MultiIO.new(*ios)
+  end
+end

data/spec/support/generator.rb

@@ -0,0 +1,56 @@
+module Generator
+  module ClassMethods
+    attr_reader :configurators
+
+    def factory
+      klass = Class.new(self)
+      yield klass if block_given?
+      klass
+    end
+
+    def call(*args, &block)
+      new(*args, &block).tap { |object| object.call }
+    end
+
+    def generate(&block)
+      factory.call(&block)
+    end
+
+    def mixin(mod)
+      include mod
+    end
+
+    def configure(&block)
+      configurators << block
+    end
+
+    def configurators
+      @configurators ||= []
+    end
+  end
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  def initialize(*args)
+    setup(*args)
+    run_configurators
+    configure(*args)
+    yield self if block_given?
+  end
+
+  def setup(*args)
+  end
+
+  def configure(*args)
+  end
+
+  private
+
+  def run_configurators
+    self.class.configurators.each do |configurator|
+      configurator.call(self)
+    end
+  end
+end

data/spec/support/integration_tests/base.rb

@@ -0,0 +1,64 @@
+require File.expand_path('../../project/generator', __FILE__)
+
+module IntegrationTests
+  module Base
+    class FailWithOutputMatcher < Struct.new(:pattern)
+      def matches?(result)
+        result.output =~ pattern
+      end
+
+      def description
+        "fail with output #{pattern.inspect}"
+      end
+
+      def failure_message_for_should
+        "Expected running the test to produce output #{pattern.inspect} but it didn't"
+      end
+
+      def failure_message_for_should_not
+        "Expected running the test to not produce output #{pattern.inspect} but it did"
+      end
+    end
+
+    class HaveErrorsOrFailuresMatcher
+      def matches?(result)
+        match = result.output.match(/(\d+) error|(\d+) failure/)
+        match && match.captures.any? {|value| value && value.to_i > 0 }
+      end
+
+      def description
+        "have errors or failures"
+      end
+
+      def failure_message_for_should
+        "Expected running the test to result in errors or failures but it did not"
+      end
+
+      def failure_message_for_should_not
+        "Expected running the test to not result in errors or failures, but it did "
+      end
+    end
+
+    def build_project_generator
+      Project::Generator.factory do |project_generator|
+        configure_project_generator(project_generator)
+        yield project_generator if block_given?
+      end
+    end
+
+    def generate_project(&block)
+      build_project_generator.call(&block)
+    end
+
+    def configure_project_generator(generator)
+    end
+
+    def fail_with_output(pattern)
+      FailWithOutputMatcher.new(pattern)
+    end
+
+    def have_errors_or_failures
+      HaveErrorsOrFailuresMatcher.new
+    end
+  end
+end

data/spec/support/integration_tests/rails.rb

@@ -0,0 +1,60 @@
+require File.expand_path('../base', __FILE__)
+require File.expand_path('../../project/rails', __FILE__)
+
+module IntegrationTests
+  module Rails
+    class LeaveDatabaseTableClearMatcher < Struct.new(:project, :table_name)
+      def matches?(block)
+        @old_number_of_rows = number_of_rows
+        block.call
+        @new_number_of_rows = number_of_rows
+        @old_number_of_rows == 0 && @new_number_of_rows == 0
+      end
+
+      def description
+        "leave the database table #{table_name} unchanged"
+      end
+
+      def failure_message_for_should
+        "Expected for database table #{table_name} to have been left clear, but it was changed (there are now #{@new_number_of_rows} rows)"
+      end
+
+      def failure_message_for_should_not
+        "Expected for database table #{table_name} to not have been left clear, but it was"
+      end
+
+      private
+
+      def number_of_rows
+        result = project.exec!("echo 'select count(*) from #{table_name};' | sqlite3 #{project.database_file_path}")
+        result.output.chomp.to_i
+      end
+    end
+
+    include Base
+
+    def configure_project_generator(project_generator)
+      super
+      configure_rails_project_generator(project_generator)
+    end
+
+    def build_rails_project_generator
+      Project::Generator.factory do |project_generator|
+        configure_rails_project_generator(project_generator)
+        yield project_generator if block_given?
+      end
+    end
+
+    def generate_rails_project(&block)
+      build_rails_project_generator.call(&block)
+    end
+
+    def configure_rails_project_generator(project_generator)
+      project_generator.mixin Project::Rails
+    end
+
+    def leave_database_table_clear(project, table_name)
+      LeaveDatabaseTableClearMatcher.new(project, table_name)
+    end
+  end
+end