flatware-rc 1.0.0.rc

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 29c812dd64d84ce34e23384de23597028e1d2f3e
+  data.tar.gz: d9c9b115efee14671c92f00d7a260e3689baf57f
+SHA512:
+  metadata.gz: 61bc760e517826f5961a65ef6fc5461038e02038d251af85326665ee36592ba14d213bd5185a6ce4056c2a019c9546407d332be8edb9a6698ac0748da4106c0b
+  data.tar.gz: 0671c7421a9668fc9fb59751b13336170b8ca00d3239f81a7ae3df92d82c9c532977577845f900c0b22fac0ab31449e44cca582554f079d135865f8691c6cca7

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,132 @@
+# Flatware [![Build Status][travis-badge]][travis] [![Code Climate][code-climate-badge]][code-climate]
+
+[travis-badge]: https://travis-ci.org/briandunn/flatware.png
+[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.
+
+## Requirements
+
+* ZeroMQ > 2.1
+
+## Installation
+
+Add this to your Gemfile:
+
+```
+gem 'flatware'
+```
+
+and `bundle install`.
+
+## Usage
+
+To run your entire suite with the default cucumber options, just:
+
+```
+$ flatware
+```
+
+If you'd like to limit the number of forked workers, you can pass the 'w' flag:
+
+```
+$ flatware -w 3
+```
+
+You can also pass most cucumber options to Flatware. For example, to run only
+features that are not tagged 'javascript', you can:
+
+```
+$ flatware cucumber -t ~@javascript
+```
+
+## Typical Usage in a Rails App
+
+Add the following to your config/database.yml:
+
+```
+test:
+  database: foo_test
+```
+
+becomes:
+
+```
+test:
+  database: foo_test<%=ENV['TEST_ENV_NUMBER']%>
+```
+
+Run the following:
+
+```
+$ rake db:setup # if not already done
+$ flatware fan rake db:test:prepare
+```
+
+Now you are ready to rock:
+
+```
+$ flatware
+```
+
+## 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
+
+### 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.
+
+### Minimal
+
+* Projects define their own preperation 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
+  completing the suite.
+
+## Tinkering
+
+Flatware is tested with [aruba][]. 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
+
+## 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
+
+## 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.

data/bin/flatware

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+lib = File.expand_path('../../lib', __FILE__)
+$:.unshift lib unless $:.include? lib
+
+require 'flatware'
+Flatware::CLI.start

data/lib/flatware.rb

@@ -0,0 +1,10 @@
+module Flatware
+  require 'flatware/checkpoint_handler'
+  require 'flatware/processor_info'
+  require 'flatware/cli'
+  require 'flatware/poller'
+  require 'flatware/formatters'
+  require 'flatware/sink'
+  require 'flatware/socket'
+  require 'flatware/worker'
+end

data/lib/flatware/checkpoint_handler.rb

@@ -0,0 +1,34 @@
+module Flatware
+  class CheckpointHandler
+    attr_reader :formatter, :checkpoints
+
+    def initialize(formatter, fails_fast)
+      @fail_fast = fails_fast
+      @formatter = formatter
+      @checkpoints = []
+    end
+
+    def handle!(checkpoint)
+      checkpoints << checkpoint
+      if checkpoint.failures? && fail_fast?
+        @done = true
+      end
+    end
+
+    def done?
+      @done
+    end
+
+    def fail_fast?
+      @fail_fast
+    end
+
+    def summarize
+      formatter.summarize(checkpoints)
+    end
+
+    def had_failures?
+      checkpoints.any? &:failures?
+    end
+  end
+end

data/lib/flatware/cli.rb

@@ -0,0 +1,89 @@
+require 'thor'
+require 'flatware/pids'
+module Flatware
+  class CLI < Thor
+
+    default_command :cucumber
+
+    def self.processors
+      @processors ||= ProcessorInfo.count
+    end
+
+    def self.worker_option
+      method_option :workers, aliases: "-w", type: :numeric, default: processors, desc: "Number of concurent processes to run"
+    end
+
+    class_option :log, aliases: "-l", type: :boolean, desc: "Print debug messages to $stderr"
+
+    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 "cucumber [FLATWARE_OPTS] [CUCUMBER_ARGS]", "parallelizes cucumber with custom arguments"
+    def cucumber(*args)
+      require 'flatware/cucumber'
+      jobs = Cucumber.extract_jobs_from_args args
+      Flatware.verbose = options[:log]
+      worker_count = [workers, jobs.size].min
+      Worker.spawn worker_count, Cucumber, options['dispatch-endpoint'], options['sink-endpoint']
+      start_sink jobs: jobs, workers: worker_count
+    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 "rspec [FLATWARE_OPTS]", "parallelizes rspec"
+    def rspec(*rspec_args)
+      require 'flatware/rspec'
+      jobs = RSpec.extract_jobs_from_args rspec_args, workers: workers
+      Flatware.verbose = options[:log]
+      Worker.spawn workers, RSpec, options['dispatch-endpoint'], options['sink-endpoint']
+      start_sink jobs: jobs, workers: workers
+    end
+
+    worker_option
+    desc "fan [COMMAND]", "executes the given job on all of the workers"
+    def fan(*command)
+      Flatware.verbose = options[:log]
+
+      command = command.join(" ")
+      puts "Running '#{command}' on #{workers} workers"
+
+      workers.times do |i|
+        fork do
+          exec({"TEST_ENV_NUMBER" => i.to_s}, command)
+        end
+      end
+      Process.waitall
+    end
+
+
+    desc "clear", "kills all flatware processes"
+    def clear
+      (Flatware.pids - [$$]).each do |pid|
+        Process.kill 6, pid
+      end
+    end
+
+    private
+
+    def start_sink(jobs:, workers:, runner: current_command_chain.first)
+     $0 = 'flatware sink'
+      Process.setpgrp
+      formatter = Formatters.load_by_name(runner, options['formatters'])
+      passed = Sink.start_server jobs: jobs, formatter: formatter, sink: options['sink-endpoint'], dispatch: options['dispatch-endpoint'], fail_fast: options['fail-fast'], worker_count: workers
+      exit passed ? 0 : 1
+    end
+
+    def log(*args)
+      Flatware.log(*args)
+    end
+
+    def workers
+      options[:workers]
+    end
+  end
+end

data/lib/flatware/cucumber.rb

@@ -0,0 +1,34 @@
+require 'cucumber'
+require 'flatware/cucumber/checkpoint'
+require 'flatware/cucumber/formatter'
+require 'flatware/cucumber/result'
+require 'flatware/cucumber/runtime'
+require 'flatware/cucumber/scenario_decorator'
+require 'flatware/cucumber/scenario_result'
+require 'flatware/cucumber/step_result'
+require 'flatware/formatters/cucumber/console'
+
+module Flatware
+  module Cucumber
+
+    extend self
+
+    attr_reader :jobs
+
+    def extract_jobs_from_args(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 }.to_a
+    end
+
+    def run(feature_files=[], options=[])
+      runtime.run feature_files, options
+    end
+
+    def runtime
+      @runtime ||= Runtime.new
+    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/formatter.rb

@@ -0,0 +1,112 @@
+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
+        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)
+        end
+      end
+
+      def respond_to?(x)
+        super
+      end
+
+      def before_outline_table(*)
+        @in_examples = true
+      end
+
+      def after_outline_table(*)
+        @in_examples = false
+      end
+
+      def before_table_cell(*)
+        @in_a_step = @in_examples
+      end
+
+      def after_table_cell(*)
+        @in_a_step = ! @in_examples
+      end
+
+      def after_table_row(table_row)
+        exception(table_row.exception, :failed) if table_row.exception
+      end
+
+      def before_step(*)
+        @in_a_step = true
+      end
+
+      def after_step(*)
+        @in_a_step = false
+      end
+
+      def scenario_name(_, name, file_colon_line, *)
+        scenarios.push OpenStruct.new file_colon_line: file_colon_line, name: name
+      end
+
+      private
+      attr_reader :collector, :scenarios
+
+      def current_scenario
+        scenarios.last
+      end
+
+      def send_progress(status)
+        Sink::client.progress Result.new status
+      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
+      end
+    end
+  end
+end