flatware 0.3.2 → 0.4.0

data/lib/flatware/cucumber/formatter.rb

@@ -1,113 +1,65 @@
-require 'flatware/checkpoint'
-require 'flatware/scenario_decorator'
+require 'cucumber'
 require 'flatware/sink'
 require 'ostruct'
 module Flatware
   module Cucumber
     class Formatter
-
-      def initialize(step_mother, *)
-        @collector = Collector.new step_mother
-        @scenarios = []
-        @in_a_step = false
-      end
-
-      def after_features(*)
-        checkpoint = collector.checkpoint
-        scenarios.select(&:exception).map(&:file_colon_line).each do |file_colon_line|
-          scenario = checkpoint.scenarios.detect do |scenario|
-            scenario.file_colon_line == file_colon_line
-          end
-          scenario.failed_outside_step!(file_colon_line) if scenario
+      Checkpoint = Struct.new :steps, :scenarios do
+        def failures?
+          scenarios.any? &:failed?
         end
-        Sink::client.checkpoint checkpoint
-      end
-
-      def after_step_result(_, _, _, status, *)
-        send_progress(status)
-      end
-
-      def table_cell_value(_, status)
-        send_progress(status) if status
       end
 
-      def exception(exception, status)
-        unless @in_a_step
-          current_scenario.exception = exception
-          send_progress(status)
+      Scenario = Struct.new :name, :file_colon_line, :status do
+        def failed?
+          status == :failed
         end
-      end
-
-      def respond_to?(x)
-        super
-      end
 
-      def before_outline_table(*)
-        @in_examples = true
-      end
-
-      def after_outline_table(*)
-        @in_examples = false
+        def failed_outside_step?
+          false
+        end
       end
 
-      def before_table_cell(*)
-        @in_a_step = @in_examples
+      def initialize(config)
+        config.on_event :after_test_case,  &method(:on_after_test_case)
+        config.on_event :after_test_step,  &method(:on_after_test_step)
+        config.on_event :finished_testing, &method(:on_finished_testing)
+        config.on_event :step_match,       &method(:on_step_match)
+        reset
       end
 
-      def after_table_cell(*)
-        @in_a_step = ! @in_examples
-      end
+      private
 
-      def after_table_row(table_row)
-        exception(table_row.exception, :failed) if table_row.exception
+      def reset
+        @steps = []
+        @scenarios = []
+        @matched_steps = Set.new
       end
 
-      def before_step(*)
-        @in_a_step = true
-      end
+      attr_reader :steps, :scenarios, :matched_steps
 
-      def after_step(*)
-        @in_a_step = false
+      def on_after_test_case(event)
+        scenarios << Scenario.new(event.test_case.name, event.test_case.location.to_s, event.result.to_sym)
       end
 
-      def scenario_name(_, name, file_colon_line, *)
-        scenarios.push OpenStruct.new file_colon_line: file_colon_line, name: name
+      def on_step_match(event)
+        @matched_steps << event.step_match.location.to_s
       end
 
-      private
-      attr_reader :collector, :scenarios
-
-      def current_scenario
-        scenarios.last
+      def on_after_test_step(event)
+        if really_a_step?(event.test_step) or event.result.undefined?
+          steps << StepResult.new(event.result.to_sym, event.result.failed? && event.result.exception)
+          Sink::client.progress Result.new event.result.to_sym
+        end
       end
 
-      def send_progress(status)
-        Sink::client.progress Result.new status
+      def on_finished_testing(*)
+        Sink::client.checkpoint Checkpoint.new steps, scenarios
+        reset
       end
 
-      class Collector
-        attr_reader :step_mother
-        def initialize(step_mother)
-          @step_mother = step_mother
-          snapshot
-        end
-
-        def checkpoint
-          Checkpoint.new(step_mother.steps - @ran_steps, decorate_scenarios(step_mother.scenarios - @ran_scenarios)).tap do
-            snapshot
-          end
-        end
-
-        private
-
-        def snapshot
-          @ran_steps = step_mother.steps.dup
-          @ran_scenarios = step_mother.scenarios.dup
-        end
-
-        def decorate_scenarios(scenarios)
-          scenarios.map { |scenario| ScenarioDecorator.new(scenario) }
-        end
+      def really_a_step?(step)
+        matched_steps.include?(step.action_location.to_s)
       end
     end
   end

data/lib/flatware/{formatters/cucumber → cucumber/formatters}/console.rb

@@ -1,7 +1,7 @@
-require 'flatware/formatters/cucumber/console/summary'
+require 'flatware/cucumber/formatters/console/summary'
 require 'cucumber/formatter/console'
 
-module Flatware::Formatters::Cucumber
+module Flatware::Cucumber::Formatters
   class Console
     #for format_string
     include ::Cucumber::Formatter::Console
@@ -26,7 +26,9 @@ module Flatware::Formatters::Cucumber
       out.print format result.progress
     end
 
-    def summarize(steps, scenarios)
+    def summarize(checkpoints)
+      steps = checkpoints.flat_map(&:steps)
+      scenarios = checkpoints.flat_map(&:scenarios)
       Summary.new(steps, scenarios, out).summarize
     end
 

data/lib/flatware/{formatters/cucumber → cucumber/formatters}/console/summary.rb

@@ -1,8 +1,8 @@
 require 'cucumber/formatter/console'
-require 'flatware/formatters/cucumber/console'
-require 'flatware/checkpoint'
+require 'flatware/cucumber/formatters/console'
+require 'flatware/cucumber/checkpoint'
 
-module Flatware::Formatters::Cucumber
+module Flatware::Cucumber::Formatters
   class Console
     class Summary
       include ::Cucumber::Formatter::Console

data/lib/flatware/cucumber/result.rb

@@ -0,0 +1,27 @@
+module Flatware
+  module Cucumber
+    class Result
+      attr_reader :progress, :worker
+
+      def initialize(progress)
+        @progress = progress
+        @worker   = ENV['TEST_ENV_NUMBER'].to_i
+      end
+
+      class << self
+        def step(*args)
+          step = StepResult.new *args
+          new step.progress, [step]
+        end
+
+        def status(status)
+          new status
+        end
+
+        def background(status, exception)
+          new '', [StepResult.new(status, exception)]
+        end
+      end
+    end
+  end
+end

data/lib/flatware/cucumber/scenario_result.rb

@@ -0,0 +1,38 @@
+require 'flatware/serialized_exception'
+module Flatware
+  module Cucumber
+    class ScenarioResult
+      attr_reader :status, :file_colon_line, :name
+      def initialize(status, file_colon_line, name, e)
+        @status = status
+        @file_colon_line = file_colon_line
+        @name = name
+        @exception = SerializedException.new(e.class, e.message, e.backtrace) if e
+        @failed_outside_step = false
+      end
+
+      def passed?
+        status == :passed
+      end
+
+      def failed?
+        status == :failed
+      end
+
+      def failed_outside_step!(file_colon_line)
+        @failed_outside_step = file_colon_line
+      end
+
+      def failed_outside_step?
+        !!@failed_outside_step
+      end
+
+      def exception
+        @exception.tap do |e|
+          e.backtrace = e.backtrace.grep(Regexp.new(Dir.pwd)).map { |line| line[Dir.pwd.size..-1] }
+          e.backtrace = e.backtrace + [@failed_outside_step] if failed_outside_step?
+        end
+      end
+    end
+  end
+end

data/lib/flatware/cucumber/step_result.rb

@@ -0,0 +1,30 @@
+require 'flatware/serialized_exception'
+module Flatware
+  module Cucumber
+    class StepResult
+      attr_reader :status, :exception
+
+      def initialize(status, exception)
+        @status, @exception = status, (serialized(exception) if exception)
+      end
+
+      def passed?
+        status == :passed
+      end
+
+      def failed?
+        status == :failed
+      end
+
+      def progress
+        Cucumber::ProgressString.format(status)
+      end
+
+      private
+      def serialized(e)
+        e.backtrace and e.backtrace.unshift e.backtrace.shift.sub(Dir.pwd, '.')
+        SerializedException.new(e.class, e.message, e.backtrace)
+      end
+    end
+  end
+end

data/lib/flatware/poller.rb

@@ -21,14 +21,14 @@ module Flatware
     def find_wrapped_socket
       ->(s) do
         sockets.find do |socket|
-          socket.s == s
+          socket.socket == s
         end
       end
     end
 
     def register_sockets
       sockets.each do |socket|
-        zmq_poller.register_readable socket.s
+        zmq_poller.register_readable socket.socket
       end
     end
   end

data/lib/flatware/rspec.rb

@@ -0,0 +1,28 @@
+require 'rspec/core'
+require 'rspec/expectations'
+require 'flatware/rspec/cli'
+
+module Flatware
+  module RSpec
+    require 'flatware/rspec/formatters/console'
+    require 'flatware/rspec/formatter'
+
+    def self.extract_jobs_from_args(args, workers:)
+
+      options = ::RSpec::Core::ConfigurationOptions.new(args)
+      configuration = ::RSpec::Core::Configuration.new
+      def configuration.command() 'rspec' end
+      options.configure(configuration)
+      configuration.files_to_run.uniq.map do |file|
+        Job.new(file, args)
+      end
+    end
+
+    def self.run(job, options={})
+      runner = ::RSpec::Core::Runner
+      def runner.trap_interrupt() end
+
+      runner.run(%w[--format Flatware::RSpec::Formatter] + Array(job), $stderr, $stdout)
+    end
+  end
+end

data/lib/flatware/rspec/checkpoint.rb

@@ -0,0 +1,29 @@
+require 'flatware/rspec/examples_notification'
+
+module Flatware
+  module RSpec
+    class Checkpoint
+      attr_reader :summary, :failures_notification
+
+      def initialize(summary, failures_notification)
+        @summary, @failures_notification = summary, ExamplesNotification.new(failures_notification.failure_notifications)
+      end
+
+      def +(other)
+        self.class.new summary + other.summary, failures_notification + other.failures_notification
+      end
+
+      def failures?
+        summary.failure_count > 0
+      end
+
+      def failure_notifications
+        failures_notification.failure_notifications
+      end
+
+      def fully_formatted_failed_examples(*args)
+        failures_notification.fully_formatted_failed_examples(*args)
+      end
+    end
+  end
+end

data/lib/flatware/rspec/cli.rb

@@ -0,0 +1,16 @@
+require 'flatware/cli'
+
+module Flatware
+  class CLI
+    worker_option
+    method_option 'dispatch-endpoint', type: :string, default: 'ipc://dispatch'
+    method_option 'sink-endpoint', type: :string, default: 'ipc://task'
+    desc "rspec [FLATWARE_OPTS]", "parallelizes rspec"
+    def rspec(*rspec_args)
+      jobs = RSpec.extract_jobs_from_args rspec_args, workers: workers
+      Flatware.verbose = options[:log]
+      Worker.spawn count: workers, runner: RSpec, dispatch: options['dispatch-endpoint'], sink: options['sink-endpoint']
+      start_sink jobs: jobs, workers: workers, formatter: Flatware::RSpec::Formatters::Console.new($stdout, $stderr)
+    end
+  end
+end

data/lib/flatware/rspec/example_notification.rb

@@ -0,0 +1,21 @@
+require 'rspec/core/formatters/console_codes'
+
+module Flatware
+  module RSpec
+    class ExampleNotification
+      attr_reader :formatted
+      def initialize(notification)
+        @formatted = notification.fully_formatted '!', default_colorizer
+      end
+
+      def fully_formatted(i, _=nil)
+        formatted.sub '!', i.to_s
+      end
+
+      private
+      def default_colorizer
+        ::RSpec::Core::Formatters::ConsoleCodes
+      end
+    end
+  end
+end

data/lib/flatware/rspec/examples_notification.rb

@@ -0,0 +1,24 @@
+require 'flatware/rspec/example_notification'
+module Flatware
+  module RSpec
+    class ExamplesNotification
+      attr_reader :failure_notifications
+
+      def initialize(failure_notifications)
+        @failure_notifications = failure_notifications.map(&ExampleNotification.method(:new))
+      end
+
+      def +(other)
+        self.class.new failure_notifications + other.failure_notifications
+      end
+
+      def fully_formatted_failed_examples(*)
+        formatted = "\n\nFailures:\n"
+        failure_notifications.each_with_index do |failure, index|
+          formatted << failure.fully_formatted(index.next)
+        end
+        formatted
+      end
+    end
+  end
+end

data/lib/flatware/rspec/formatter.rb

@@ -0,0 +1,50 @@
+require 'flatware/rspec/checkpoint'
+require 'flatware/rspec/summary'
+require 'rspec/core/formatters/console_codes'
+
+module Flatware
+  module RSpec
+    ProgressMessage = Struct.new(:progress)
+
+    class Formatter
+      attr_reader :summary, :output
+
+      def initialize(stdout)
+        @output = stdout
+      end
+
+      def example_passed(example)
+        send_progress :passed
+      end
+
+      def example_failed(example)
+        send_progress :failed
+      end
+
+      def example_pending(example)
+        send_progress :pending
+      end
+
+      def dump_summary(summary)
+        @summary = Summary.from_notification(summary)
+      end
+
+      def dump_failures(failure_notification)
+        @failure_notification = failure_notification
+      end
+
+      def close(*)
+        Sink::client.checkpoint Checkpoint.new(summary, @failure_notification)
+        @failure_notification = nil
+      end
+
+      private
+
+      def send_progress(status)
+        Sink::client.progress ProgressMessage.new status
+      end
+    end
+
+    ::RSpec::Core::Formatters.register Formatter, :example_passed, :example_failed, :example_pending, :dump_summary, :dump_failures, :close
+  end
+end