flatware-cucumber 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: af10de976bd3f5ab9978612d0eca4303fce90326
+  data.tar.gz: 06c0102f0d981ac87c918a77a346b35abd9dbd8f
+SHA512:
+  metadata.gz: f54ab4f38b3b837151349f8d453ef39f27a3855fada7cffd042c07c0afc7e54c60cf2f806f4725896d7c0a8311d87fd0f6ad96eee5103e212ed91e54f53304be
+  data.tar.gz: 1f3b63d49b7ffb911bfc49fec675f9e8b54e87b9756716d48a85dd64e862f185dce981955c6d8de32d774daa2e103f18d5a579edc92c0083a2a690835343bbfc

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Brian Dunn
+
+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.

data/README.md

@@ -0,0 +1,176 @@
+# Flatware [![Build Status][travis-badge]][travis] [![Code Climate][code-climate-badge]][code-climate]
+
+[travis-badge]: https://travis-ci.org/briandunn/flatware.svg?branch=master
+[travis]: http://travis-ci.org/briandunn/flatware
+[code-climate-badge]: https://codeclimate.com/github/briandunn/flatware.png
+[code-climate]: https://codeclimate.com/github/briandunn/flatware
+
+Flatware parallelizes your test suite to significantly reduce test time.
+
+## Requirements
+
+* ZeroMQ > 4.0
+
+## Installation
+
+### ZeroMQ
+
+#### Linux Ubuntu
+
+```sh
+sudo apt-get install -qq libzmq3-dev
+```
+
+(Never you mind the 3. This package contains ZMQ version 4.)
+
+#### Mac OSX
+
+Ruby FFI isn't getting along with the latest ZMQ formula. A tweaked verson is available in the Hashrocket tap.
+
+```sh
+brew tap hashrocket/formulas
+brew install hashrocket/formulas/zeromq
+brew install zeromq
+```
+
+### Flatware
+
+Add the runners you need to your Gemfile:
+
+```ruby
+gem 'flatware-rspec'    # one
+gem 'flatware-cucumber' # or both
+```
+
+then run
+
+```sh
+bundle install
+```
+
+## Usage
+
+### Cucumber
+
+To run your entire suite with the default cucumber options, add the `flatware-cucumber` gem and just:
+
+```sh
+$ flatware cucumber
+```
+
+### RSpec
+
+To run your entire suite with the default rspec options add the `flatware-rspec` gem and just:
+
+```sh
+$ flatware rspec
+```
+
+### Options
+
+If you'd like to limit the number of forked workers, you can pass the 'w' flag:
+
+```sh
+$ flatware -w 3
+```
+
+You can also pass most cucumber/rspec options to Flatware. For example, to run only
+features that are not tagged 'javascript', you can:
+
+```sh
+$ flatware cucumber -t ~@javascript
+```
+
+Additionally, for either cucumber or rspec you can specify a directory:
+
+```sh
+$ flatware rspec spec/features
+```
+
+## Typical Usage in a Rails App
+
+Add the following to your `config/database.yml`:
+
+```yml
+test:
+  database: foo_test
+```
+
+becomes:
+
+```yml
+test:
+  database: foo_test<%=ENV['TEST_ENV_NUMBER']%>
+```
+
+Run the following:
+
+```sh
+$ rake db:setup # if not already done
+$ flatware fan rake db:test:prepare
+```
+
+Now you are ready to rock:
+
+```sh
+$ flatware rspec && flatware cucumber
+```
+
+## Planned Features
+
+* Use heuristics to run your slowest tests first
+
+## Design Goals
+
+### Maintainable
+
+* Fully test at an integration level. Don't be afraid to change the code. If you
+  break it you'll know.
+* Couple as loosely as possible, and only to the most stable/public bits of
+  Cucumber and RSpec.
+
+### Minimal
+
+* Projects define their own preparation scripts
+* Only distribute to local cores (for now)
+
+### Robust
+
+* Depend on a dedicated messaging library
+* Be accountable for completed work; provide progress report regardless of
+  completing the suite.
+
+## Tinkering
+
+Flatware integration tests use [aruba][a]. In order to get a demo cucumber project you
+can add the `@no-clobber` tag to `features/flatware.feature` and run the test
+with `cucumber features/flatware.feature`. Now you should have a `./tmp/aruba`
+directory. CD there and `flatware` will be in your path so you can tinker away.
+
+## How it works
+
+Flatware relies on a message passing system to enable concurrency.
+The main process declares a worker for each cpu in the computer. Each
+worker forks from the main process and is then assigned a portion of the
+test suite.  As the worker runs the test suite it sends progress
+messages to the main process.  These messages are collected and when
+the last worker is finished the main process provides a report on the
+collected progress messages.
+
+## Resources
+
+To learn more about the messaging system that Flatware uses, take a look at the
+[excellent ZeroMQ guide][z].
+
+[z]: http://zguide.zeromq.org/page:all
+[a]: https://github.com/cucumber/aruba
+
+## Contributing to Flatware
+
+Do whatever you want. I'd love to help make sure Flatware meets your needs.
+
+## About
+
+[![Hashrocket logo](https://hashrocket.com/hashrocket_logo.svg)](https://hashrocket.com)
+
+Flatware is supported by the team at [Hashrocket](https://hashrocket.com), a multidisciplinary design & development consultancy. If you'd like to [work with us](https://hashrocket.com/contact-us/hire-us) or [join our team](https://hashrocket.com/contact-us/jobs), don't hesitate to get in touch.

data/lib/flatware-cucumber.rb

@@ -0,0 +1 @@
+require 'flatware/cucumber'

data/lib/flatware/cucumber/checkpoint.rb

@@ -0,0 +1,28 @@
+module Flatware
+  module Cucumber
+    class Checkpoint
+      attr_reader :steps, :scenarios
+      def initialize(steps, scenarios)
+        @steps, @scenarios = serialize_steps(steps), serialize_scenarios(scenarios)
+      end
+
+      def failures?
+        scenarios.any? &:failed?
+      end
+
+      private
+
+      def serialize_steps(steps)
+        steps.map do |step|
+          StepResult.new step.status, step.exception
+        end
+      end
+
+      def serialize_scenarios(scenarios)
+        scenarios.map do |scenario|
+          ScenarioResult.new scenario.status, scenario.file_colon_line, scenario.name, scenario.exception
+        end
+      end
+    end
+  end
+end

data/lib/flatware/cucumber/cli.rb

@@ -0,0 +1,22 @@
+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 "cucumber [FLATWARE_OPTS] [CUCUMBER_ARGS]", "parallelizes cucumber with custom arguments"
+    def cucumber(*args)
+      config = Cucumber.configure args
+
+      unless config.jobs.any?
+        puts "Please create some feature files in the #{config.feature_dir} directory."
+        exit 1
+      end
+
+      Flatware.verbose = options[:log]
+      Worker.spawn count: workers, runner: Cucumber, dispatch: options['dispatch-endpoint'], sink: options['sink-endpoint']
+      start_sink jobs: config.jobs, workers: workers, formatter: Flatware::Cucumber::Formatters::Console.new($stdout, $stderr)
+    end
+  end
+end

data/lib/flatware/cucumber/formatter.rb

@@ -0,0 +1,66 @@
+require 'cucumber'
+require 'flatware/sink'
+require 'ostruct'
+module Flatware
+  module Cucumber
+    class Formatter
+      Checkpoint = Struct.new :steps, :scenarios do
+        def failures?
+          scenarios.any? &:failed?
+        end
+      end
+
+      Scenario = Struct.new :name, :file_colon_line, :status do
+        def failed?
+          status == :failed
+        end
+
+        def failed_outside_step?
+          false
+        end
+      end
+
+      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
+
+      private
+
+      def reset
+        @steps = []
+        @scenarios = []
+        @matched_steps = Set.new
+      end
+
+      attr_reader :steps, :scenarios, :matched_steps
+
+      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 on_step_match(event)
+        @matched_steps << event.step_match.location.to_s
+      end
+
+      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 on_finished_testing(*)
+        Sink::client.checkpoint Checkpoint.new steps, scenarios
+        reset
+      end
+
+      def really_a_step?(step)
+        matched_steps.include?(step.action_location.to_s)
+      end
+    end
+  end
+end

data/lib/flatware/cucumber/formatters/console.rb

@@ -0,0 +1,48 @@
+require 'flatware/cucumber/formatters/console/summary'
+require 'cucumber/formatter/console'
+
+module Flatware::Cucumber::Formatters
+  class Console
+    #for format_string
+    include ::Cucumber::Formatter::Console
+
+    FORMATS = {
+      passed:    '.',
+      failed:    'F',
+      undefined: 'U',
+      pending:   'P',
+      skipped:   '-'
+    }
+
+    STATUSES = FORMATS.keys
+
+    attr_reader :out, :err
+
+    def initialize(stdout, stderr)
+      @out, @err = stdout, stderr
+    end
+
+    def progress(result)
+      out.print format result.progress
+    end
+
+    def summarize(checkpoints)
+      steps = checkpoints.flat_map(&:steps)
+      scenarios = checkpoints.flat_map(&:scenarios)
+      Summary.new(steps, scenarios, out).summarize
+    end
+
+    def summarize_remaining(remaining_jobs)
+      out.puts
+      out.puts "The following features have not been run:"
+      for job in remaining_jobs
+        out.puts job.id
+      end
+    end
+
+    private
+    def format(status)
+      format_string FORMATS[status], status
+    end
+  end
+end

data/lib/flatware/cucumber/formatters/console/summary.rb

@@ -0,0 +1,66 @@
+require 'cucumber/formatter/console'
+require 'flatware/cucumber/formatters/console'
+require 'flatware/cucumber/checkpoint'
+
+module Flatware::Cucumber::Formatters
+  class Console
+    class Summary
+      include ::Cucumber::Formatter::Console
+      attr_reader :io, :steps, :scenarios
+
+      def initialize(steps, scenarios=[], io=StringIO.new)
+        @io = io
+        @steps = steps
+        @scenarios = scenarios
+      end
+
+      def summarize
+        2.times { io.puts }
+        print_failures(steps, 'step')
+        print_failures(scenarios.select(&:failed_outside_step?), 'scenario')
+        print_failed_scenarios scenarios
+        print_counts 'scenario', scenarios
+        print_counts 'step', steps
+      end
+
+      private
+
+      def print_failed_scenarios(scenarios)
+        return unless scenarios.any? &with_status(:failed)
+
+        io.puts format_string "Failing Scenarios:", :failed
+        scenarios.select(&with_status(:failed)).sort_by(&:file_colon_line).each do |scenario|
+          io.puts format_string(scenario.file_colon_line, :failed) + format_string(" # Scenario: " + scenario.name, :comment)
+        end
+        io.puts
+      end
+
+      def print_failures(collection, label)
+        failures = collection.select(&with_status(:failed))
+        print_elements failures, :failed, pluralize(label, failures.size)
+      end
+
+      def print_counts(label, collection)
+        io.puts pluralize(label, collection.size) + count_summary(collection)
+      end
+
+      def pluralize(word, number)
+        "#{number} #{number == 1 ? word : word + 's'}"
+      end
+
+      def with_status(status)
+        proc {|r| r.status == status}
+      end
+
+      def count_summary(results)
+        return "" unless results.any?
+        status_counts = STATUSES.map do |status|
+          count = results.select(&with_status(status)).size
+          format_string "#{count} #{status}", status if count > 0
+        end.compact.join ", "
+
+        " (#{status_counts})"
+      end
+    end
+  end
+end

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/runtime.rb

@@ -0,0 +1,36 @@
+require 'cucumber'
+
+module Flatware
+  module Cucumber
+    class Runtime < ::Cucumber::Runtime
+
+      attr_accessor :configuration, :loader
+      attr_reader :out, :err
+      attr_reader :visitor
+
+      def initialize(out=StringIO.new, err=out)
+        @out, @err = out, err
+        super(default_configuration)
+        load_step_definitions
+        @results = Results.new(configuration)
+      end
+
+      def default_configuration
+        config = ::Cucumber::Cli::Configuration.new
+        config.parse! []
+        config
+      end
+
+      def run(feature_files=[], options=[])
+        @loader = nil
+        options = Array(feature_files) + %w[--format Flatware::Cucumber::Formatter] + options
+
+        configure(::Cucumber::Cli::Main.new(options, out, err).configuration)
+
+        self.visitor = configuration.build_tree_walker(self)
+        visitor.visit_features(features)
+        results
+      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

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: flatware-cucumber
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: ruby
+authors:
+- Brian Dunn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-01-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: flatware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: A distributed cucumber runner
+email: brian@hashrocket.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- LICENSE.txt
+- README.md
+- lib/flatware-cucumber.rb
+- lib/flatware/cucumber/checkpoint.rb
+- lib/flatware/cucumber/cli.rb
+- lib/flatware/cucumber/formatter.rb
+- lib/flatware/cucumber/formatters/console.rb
+- lib/flatware/cucumber/formatters/console/summary.rb
+- lib/flatware/cucumber/result.rb
+- lib/flatware/cucumber/runtime.rb
+- lib/flatware/cucumber/scenario_result.rb
+- lib/flatware/cucumber/step_result.rb
+homepage: http://github.com/briandunn/flatware
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: A distributed cucumber runner
+test_files: []