flatware 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bfb0b2fec0892b096fda85d7117ecb063ead5624
-  data.tar.gz: be3acf00d8248975adb052c4004bd2017b66c8f8
+  metadata.gz: 00a71ce8a23e22600391980c40aac3425a1efd27
+  data.tar.gz: '082d74e5882c2cb99bfc4af567618e70817bb08d'
 SHA512:
-  metadata.gz: 8154c907e8c51bb3a83771cbfba07e4751b9b284965cfcd5ea634f8dd9563c28ee5da2f6c44ddbd6d326bff5ce440b42e3c30981e3f2ef3131c494037d5086a1
-  data.tar.gz: 4d1d8adb80cb44a973427cb1af117f321c597279246bb804d13c8978e22d33f2b2f367ebc0df7b6247b9423aae49dc1e42f487d5776c3eeafb87d71c4669abf0
+  metadata.gz: c591c042ab1bae59ba7e25309ceae39ca389f60b1d6f340882db31e3b0806e9acd0a8dfaa512e5529a2f1f636c297c9ba5335e247d3de3b65b90e3929b2adbf3
+  data.tar.gz: 33043b7af9e2d929e7a99c8e53c127ac9bbc4bb366f78e74ae32e53432980d64bb2b61aa7eecf818b2611df25da68d12c0ff975a463125b35748c4227d22ab16

data/README.md

@@ -1,83 +1,124 @@
 # Flatware [![Build Status][travis-badge]][travis] [![Code Climate][code-climate-badge]][code-climate]
 
-[travis-badge]: https://travis-ci.org/briandunn/flatware.png
+[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 is a distributed cucumber runner.
+Flatware parallelizes your test suite to significantly reduce test time.
 
 ## Requirements
 
-* ZeroMQ > 2.1
+* ZeroMQ > 4.0
 
 ## Installation
 
-Add this to your Gemfile:
+### ZeroMQ
 
+#### Linux Ubuntu
+
+```sh
+sudo apt-get install -qq libzmq3-dev
 ```
-gem 'flatware'
+
+(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
 ```
 
-and `bundle install`.
+### 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
 
-To run your entire suite with the default cucumber options, just:
+### Cucumber
+
+To run your entire suite with the default cucumber options, add the `flatware-cucumber` gem and just:
 
+```sh
+$ flatware cucumber
 ```
-$ flatware
+
+### 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 options to Flatware. For example, to run only
+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:
+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:
 
-```
-$ flatware
+```sh
+$ flatware rspec && flatware cucumber
 ```
 
 ## Planned Features
 
-* Reliable enough to use as part of your Continuous Integration system
-* Always accounts for every feature you ask it to run
 * Use heuristics to run your slowest tests first
-* speak Cucumber's DRB protocol; if you know how to use Spork you know how to
-  use Flatware
 
 ## Design Goals
 
@@ -86,28 +127,35 @@ $ flatware
 * 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.
+  Cucumber and RSpec.
 
 ### Minimal
 
-* Projects define their own preperation scripts
+* Projects define their own preparation scripts
 * Only distribute to local cores (for now)
-* Only handle cucumber
 
 ### Robust
 
 * Depend on a dedicated messaging library
-* Be acountable for completed work; provide progress report regardless of
+* Be accountable for completed work; provide progress report regardless of
   completing the suite.
 
 ## Tinkering
 
-Flatware is tested with [aruba][]. In order to get a demo cucumber project you
+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.
 
-[aruba]: https://github.com/cucumber/aruba
+## 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
 
@@ -115,18 +163,14 @@ 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
 
-* Check out the latest master to make sure the feature hasn't been implemented
-  or the bug hasn't been fixed yet
-* Check out the issue tracker to make sure someone already hasn't requested it
-  and/or contributed it
-* Fork the project
-* Start a feature/bugfix branch
-* Commit and push until you are happy with your contribution
-* Make sure to add tests for it. This is important so I don't break it in a
-  future version unintentionally.
-* Please try not to mess with the Rakefile, version, or history. If you want to
-  have your own version, or is otherwise necessary, that is fine, but please
-  isolate to its own commit so I can cherry-pick around it.
+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-rspec.rb

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

data/lib/flatware.rb

@@ -1,17 +1,9 @@
 module Flatware
-  require 'flatware/checkpoint'
-  require 'flatware/checkpoint_handler'
   require 'flatware/processor_info'
   require 'flatware/cli'
-  require 'flatware/cucumber'
-  require 'flatware/dispatcher'
-  require 'flatware/fireable'
-  require 'flatware/formatters'
-  require 'flatware/result'
-  require 'flatware/scenario_decorator'
-  require 'flatware/scenario_result'
+  require 'flatware/poller'
   require 'flatware/sink'
   require 'flatware/socket'
-  require 'flatware/step_result'
   require 'flatware/worker'
+  require 'flatware/broadcaster'
 end

data/lib/flatware/broadcaster.rb

@@ -0,0 +1,15 @@
+module Flatware
+  class Broadcaster
+    attr_reader :formatters
+
+    def initialize(formatters)
+      @formatters = formatters
+    end
+
+    def method_missing(name, *args)
+      formatters.each do |formatter|
+        formatter.send name, *args if formatter.respond_to? name
+      end
+    end
+  end
+end

data/lib/flatware/cli.rb

@@ -13,26 +13,6 @@ module Flatware
 
     class_option :log, aliases: "-l", type: :boolean, desc: "Print debug messages to $stderr"
 
-    default_task :default
-    worker_option
-    desc "default [FLATWARE_OPTS]", "parallelizes cucumber with default arguments"
-    def default(*)
-      invoke :cucumber
-    end
-
-    worker_option
-    method_option 'fail-fast', type: :boolean, default: false, desc: "Abort the run on first failure"
-    method_option 'formatters', aliases: "-f", type: :array, default: %w[console], desc: "The formatters to use for output"
-    method_option 'dispatch-endpoint', type: :string, default: 'ipc://dispatch'
-    method_option 'sink-endpoint', type: :string, default: 'ipc://task'
-    desc "[FLATWARE_OPTS] cucumber [CUCUMBER_ARGS]", "parallelizes cucumber with custom arguments"
-    def cucumber(*)
-      jobs = Cucumber.extract_jobs_from_args cucumber_args
-      Worker.spawn workers, Cucumber, options['dispatch-endpoint'], options['sink-endpoint']
-      formatter = Formatters.load_by_name(:cucumber, options['formatters'])
-      start_sink jobs, formatter
-    end
-
     worker_option
     desc "fan [COMMAND]", "executes the given job on all of the workers"
     def fan(*command)
@@ -49,7 +29,6 @@ module Flatware
       Process.waitall
     end
 
-
     desc "clear", "kills all flatware processes"
     def clear
       (Flatware.pids - [$$]).each do |pid|
@@ -59,24 +38,13 @@ module Flatware
 
     private
 
-    def start_sink(jobs, formatter)
+    def start_sink(jobs:, workers:, formatter:)
      $0 = 'flatware sink'
       Process.setpgrp
-      Flatware.verbose = options[:log]
-      Dispatcher.spawn jobs, options['dispatch-endpoint']
-      passed = Sink.start_server jobs, formatter, options['sink-endpoint'], fail_fast: options['fail-fast']
-      Process.waitall
+      passed = Sink.start_server jobs: jobs, formatter: Flatware::Broadcaster.new([formatter]), sink: options['sink-endpoint'], dispatch: options['dispatch-endpoint'], worker_count: workers
       exit passed ? 0 : 1
     end
 
-    def cucumber_args
-      if index = ARGV.index('cucumber')
-        ARGV[index + 1..-1]
-      else
-        []
-      end
-    end
-
     def log(*args)
       Flatware.log(*args)
     end
@@ -86,3 +54,11 @@ module Flatware
     end
   end
 end
+
+flatware_gems = Gem.loaded_specs.keys.grep(/^flatware-/)
+
+if flatware_gems.count > 0
+  flatware_gems.each(&method(:require))
+else
+  puts "The flatware gem is a dependency of flatware runners for rspec and cucumber.  Try adding flatware-rspec or flatware-cucumber to your Gemfile."
+end

data/lib/flatware/cucumber.rb

@@ -1,26 +1,51 @@
 require 'cucumber'
-require 'flatware/cucumber/runtime'
+require 'flatware/cucumber/checkpoint'
+require 'flatware/cucumber/formatter'
+require 'flatware/cucumber/result'
+require 'flatware/cucumber/scenario_result'
+require 'flatware/cucumber/step_result'
+require 'flatware/cucumber/formatters/console'
+require 'flatware/cucumber/cli'
+
 module Flatware
   module Cucumber
+    class Config
+      attr_reader :config, :args
+      def initialize(cucumber_config, args)
+        @config, @args = cucumber_config, args
+      end
 
-    extend self
+      def feature_dir
+        @config.feature_dirs.first
+      end
+
+      def jobs
+        feature_files.map { |file| Job.new file, args }.to_a
+      end
+
+      private
 
-    attr_reader :jobs
+      def feature_files
+        config.feature_files - config.feature_dirs
+      end
+    end
+
+    extend self
 
-    def extract_jobs_from_args(args=[], out_stream=$stdout, error_stream=$stderr)
+    def configure(args, out_stream=$stdout, error_stream=$stderr)
       raw_args = args.dup
-      config = ::Cucumber::Cli::Configuration.new(out_stream, error_stream)
-      config.parse! args
-      options = raw_args - args
-      @jobs = config.feature_files.map { |file| Job.new file, options }
+      cli_config = ::Cucumber::Cli::Configuration.new(out_stream, error_stream)
+      cli_config.parse! args + %w[--format Flatware::Cucumber::Formatter]
+      cucumber_config = ::Cucumber::Configuration.new cli_config
+      Config.new cucumber_config, raw_args
     end
 
-    def run(feature_files=[], options=[])
-      runtime.run feature_files, options
+    def run(feature_files, options)
+      runtime(Array(feature_files) + options).run!
     end
 
-    def runtime
-      @runtime ||= Runtime.new
+    def runtime(args)
+      ::Cucumber::Runtime.new(configure(args).config)
     end
   end
 end

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