hypercuke 0.4.1

data/spec/cli_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+=begin
+
+  All commands should begin with "cucumber".
+  (Assume that the --require business is handled in cucumber.yml.)
+
+  Some sample HCu commands and their expected outputs:
+  $ hcu core      # cucumber --tags @core_ok
+  $ hcu model     # cucumber --tags @model_ok
+  $ hcu core wip  # cucumber --tags @model_wip --profile wip
+  $ hcu core ok   # cucumber --tags @core_ok
+
+  If the user specifies a --profile tag, assume they know what they're doing...
+  $ hcu core --profile emperor_penguin     # cucumber --tags @core_ok --profile emperor_penguin
+  $ hcu core wip --profile emperor_penguin # cucumber --tags @core_wip --profile emperor_penguin
+  ...even if they use the "-p" tag instead...
+  $ hcu core -p emperor_penguin     # cucumber --tags @core_ok --profile emperor_penguin
+  $ hcu core wip -p emperor_penguin # cucumber --tags @core_wip --profile emperor_penguin
+
+  Everything else should just get passed through to Cucumber unmangled.
+  $ hcu core --wibble # cucumber --tags @core_ok --wibble
+
+  Also, the '-h' flag should display HCu help (TBD)
+  ( TODO: WRITE THIS EXAMPLE? )
+
+=end
+
+describe Hypercuke::CLI do
+
+  def cli_for(hcu_command, *args)
+    described_class.new(hcu_command, *args)
+  end
+
+  describe "cucumber command line generation" do
+    shared_examples_for "command line builder" do |shared_example_opts|
+      let(:cmd_base) { shared_example_opts[:cmd_base] }
+
+      def expect_command_line(hcu_command, expected_output)
+        argv = hcu_command.split(/\s+/)
+        actual_output = cli_for(argv).cucumber_command
+
+        expect( actual_output ).to eq( expected_output ), <<-EOF
+Transforming command '#{hcu_command}':
+expected: #{expected_output.inspect}
+     got: #{actual_output.inspect}
+        EOF
+      end
+
+      it "ignores the 0th 'hcu' argument in its various forms (does this even happen?)" do
+        expect_command_line 'hcu core',     "#{cmd_base} --tags @core_ok"
+        expect_command_line 'bin/hcu core', "#{cmd_base} --tags @core_ok"
+      end
+
+      it "treats the first argument as a layer name and adds the appropriate --tags flag" do
+        expect_command_line 'core',  "#{cmd_base} --tags @core_ok"
+        expect_command_line 'model', "#{cmd_base} --tags @model_ok"
+      end
+
+      it "barfs if the layer name is not given" do
+        expect{ cli_for('hcu').cucumber_command }.to raise_error( "Layer name is required" )
+        expect{ cli_for('').cucumber_command }.to raise_error( "Layer name is required" )
+      end
+
+      it "treats the second argument as a mode (assuming it doesn't start with a dash)" do
+        expect_command_line 'core ok',  "#{cmd_base} --tags @core_ok"
+      end
+
+      it "adds '--profile wip' when the mode is 'wip'" do
+        expect_command_line 'core wip',  "#{cmd_base} --tags @core_wip --profile wip"
+      end
+
+      it "ignores most other arguments and just hands them off to Cucumber" do
+        expect_command_line 'core --wibble',    "#{cmd_base} --tags @core_ok --wibble"
+        expect_command_line 'core ok --wibble', "#{cmd_base} --tags @core_ok --wibble"
+      end
+
+      it "doesn't override a profile if the user explicitly specifies one (using either -p or --profile)" do
+        expect_command_line 'core --dingbat --profile emperor_penguin',     "#{cmd_base} --tags @core_ok --profile emperor_penguin --dingbat"
+        expect_command_line 'core --dingbat -p emperor_penguin',            "#{cmd_base} --tags @core_ok --profile emperor_penguin --dingbat"
+      end
+
+      it "doesn't override a user-specified profile, even in wip mode when it would normally use the wip profile" do
+        expect_command_line 'core wip --profile emperor_penguin', "#{cmd_base} --tags @core_wip --profile emperor_penguin"
+        expect_command_line 'core wip -p emperor_penguin',        "#{cmd_base} --tags @core_wip --profile emperor_penguin"
+      end
+    end
+
+    context "when Bundler IS NOT present" do
+      before do
+        allow( described_class ).to receive(:bundler_present?).and_return(false)
+      end
+
+      it_behaves_like "command line builder", cmd_base: 'cucumber'
+    end
+
+    context "when Bundler IS present" do
+      before do
+        allow( described_class ).to receive(:bundler_present?).and_return(true)
+      end
+
+      it_behaves_like "command line builder", cmd_base: 'bundle exec cucumber'
+    end
+  end
+
+  describe "layer_name" do
+    it "matches the layer argument to 'hcu'" do
+      expect( cli_for('hcu core') .layer_name ).to eq( 'core' )
+      expect( cli_for('hcu model').layer_name ).to eq( 'model' )
+      expect( cli_for('hcu ui')   .layer_name ).to eq( 'ui' )
+    end
+  end
+
+  describe "#run!" do
+    let(:cli) { cli_for('fudge_ripple', output, environment, kernel) }
+    let(:output) { double('output', puts: nil) }
+    let(:kernel) { double('Kernel', exec: nil) }
+    let(:environment) { { 'foo' => 'bar' } }
+
+    it "prints the generated Cucumber command to output" do
+      expect(output).to receive(:puts).with(cli.cucumber_command_for_display)
+      cli.run!
+    end
+
+    it "uses exec to run the Cucumber command, passing in the layer name to the environment" do
+      layer = Hypercuke::LAYER_NAME_ENV_VAR
+      expected_env = {
+        'foo' => 'bar',
+        layer => 'fudge_ripple'
+      }
+      expect(kernel).to receive(:exec).with(expected_env, cli.cucumber_command)
+      cli.run!
+    end
+  end
+end

data/spec/context_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Hypercuke::Context do
+  subject { Hypercuke::Context.new }
+
+  it "allows square-bracket setting and getting, same as a Hash" do
+    expect( subject[:wibble] ).to be nil
+    subject[:wibble] = 'wibble'
+    expect( subject[:wibble] ).to eq( 'wibble' )
+  end
+
+  let(:ransom_1960s) { "one MILLION dollars" }
+  let(:ransom_1990s) { "one hundred billion dollars" }
+
+  it "behaves like a Hash with regard to #fetch" do
+    subject[:demand] = ransom_1960s
+    expect( subject.fetch(:demand) ).to eq( ransom_1960s )
+
+    expect{ subject.fetch(:updated_demand) }
+      .to raise_error( KeyError )
+    result = subject.fetch(:updated_demand) { ransom_1990s }
+    expect( result ).to eq( ransom_1990s )
+  end
+
+  describe "#fetch_or_default" do
+    before do
+      subject[:demand] = ransom_1960s 
+    end
+
+    describe "when asked for a key that exists" do
+      it "returns the value without calling the block" do
+        result = subject.fetch_or_default(:demand) { fail "this block should not be called" }
+        expect( result ).to eq( ransom_1960s )
+      end
+    end
+
+    describe "when asked for a key that does not exist" do
+      it "calls the block, sets the key, and returns the value" do
+        result = subject.fetch_or_default(:updated_demand) { ransom_1990s }
+        expect( result ).to eq( ransom_1990s )
+        result = subject.fetch_or_default(:updated_demand) { fail "this block should not be called" }
+        expect( result ).to eq( ransom_1990s )
+      end
+    end
+  end
+end

data/spec/hypercuke_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Hypercuke do
+  around do |example|
+    layer = Hypercuke.current_layer
+    begin
+      example.run
+    ensure
+      Hypercuke.current_layer = layer
+    end
+  end
+
+  describe "current layer" do
+    it "can be set" do
+      Hypercuke.current_layer = 'wibble'
+      expect( Hypercuke.current_layer ).to eq( :wibble )
+    end
+
+    it "defaults to an environment variable" do
+      expect( Hypercuke.current_layer ).to be nil
+      begin
+        ENV['HYPERCUKE_LAYER'] = 'flapjack_adjustment_station'
+        expect( Hypercuke.current_layer ).to eq( :flapjack_adjustment_station )
+      ensure
+        ENV['HYPERCUKE_LAYER'] = nil
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require_relative '../lib/hypercuke'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect # I hate Kernel#should with the fire of a thousand suns
+  end
+
+  config.after do
+    Hypercuke.reset!
+  end
+end

data/spec/step_adapter_definition_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+describe "step adapter definition API" do
+  subject { Hypercuke }
+
+  # NAMING THINGS
+  #
+  # Top-level object available as #driver: Step Driver
+  # Area of domain: Topic
+  # Layer of application: Layer
+  # Intersection of the two:  StepAdapter
+  # Name of generated step adapter: Hypercuke::StepAdapters::<Topic>::<Layer>
+  #
+  #     L               T O P I C S
+  #     A |       | Cheese     | Wine | Bread |
+  #     Y | Core  | SA*        | SA*  | SA*   |
+  #     E | Model | SA*        | SA*  | SA*   |
+  #     R | UI    | SA*        | SA*  | SA*   |
+  #     S
+  #           * SA = StepAdapter
+
+  context "when empty" do
+    it "has no layers when it starts" do
+      expect( subject.layers ).to be_empty
+    end
+    it "has no topics when it starts" do
+      expect( subject.topics ).to be_empty
+    end
+    it "has no step adapters when it starts" do
+      expect( subject::StepAdapters.constants ).to be_empty
+    end
+  end
+
+  context "with a single adapter in a single layer" do
+    before do
+      subject.topic :cheese do
+        layer :core do
+          def select_variety
+            "It's hard to go wrong with cheddar."
+          end
+        end
+      end
+    end
+
+    let(:sd_class) { subject.step_adapter_class( :cheese, :core ) }
+
+    it "defines a cheese topic" do
+      expect( subject.topic_names ).to eq( [:cheese] )
+    end
+
+    it "defines a core layer" do
+      expect( subject.layer_names ).to eq( [:core] )
+    end
+
+    it "defines a step adapter class for the cheese/core combo" do
+      expect( sd_class ).to_not be_nil
+      expect( sd_class.superclass ).to be( Hypercuke::StepAdapter )
+      expect( sd_class.instance_methods(false) ).to eq( [ :select_variety ] )
+    end
+
+    it "allows the step adapter to be reopened" do
+      subject.topic :cheese do
+        layer :core do
+          def pair_with(wine)
+            "I probably should pick an example I know more about"
+          end
+        end
+      end
+
+      expect( sd_class.instance_methods(false).sort ).to eq( [ :select_variety, :pair_with ].sort )
+    end
+
+    it "gives the step adapter class a reasonable name" do
+      expect( sd_class.name ).to eq( "Hypercuke::StepAdapters::Cheese::Core" )
+    end
+  end
+
+  context "with two topics and three layers" do
+    before do
+      subject.topic :wibble do
+        layer :spam  do ; def wibble ; "wibble spam"  ; end ; end
+        layer :eggs  do ; def wibble ; "wibble eggs"  ; end ; end
+        layer :bacon do ; def wibble ; "wibble bacon" ; end ; end
+      end
+      subject.topic :yak do
+        layer :spam  do ; def shave ; "s*MOO*th spam"  ; end ; end
+        layer :eggs  do ; def shave ; "s*MOO*th eggs"  ; end ; end
+      end
+    end
+
+    it "defines topic names" do
+      expect( subject.topic_names ).to eq( [:wibble, :yak] )
+    end
+
+    it "defines layer names" do
+      expect( subject.layer_names ).to eq( [:spam, :eggs, :bacon] )
+    end
+
+    it "defines step adapter classes with reasonable class names" do
+      expect( Hypercuke::StepAdapters::Wibble::Spam .superclass ).to be( Hypercuke::StepAdapter )
+      expect( Hypercuke::StepAdapters::Wibble::Eggs .superclass ).to be( Hypercuke::StepAdapter )
+      expect( Hypercuke::StepAdapters::Wibble::Bacon.superclass ).to be( Hypercuke::StepAdapter )
+
+      expect( Hypercuke::StepAdapters::Yak::Spam .superclass ).to be( Hypercuke::StepAdapter )
+      expect( Hypercuke::StepAdapters::Yak::Eggs .superclass ).to be( Hypercuke::StepAdapter )
+      expect{ Hypercuke::StepAdapters::Yak::Bacon }.to raise_error(NameError)
+    end
+  end
+
+  context "naming conflicts" do
+    it "works when a topic name resolves to something outside the Hypercuke namespace" do
+      Hypercuke.topic :array do
+        layer :core do
+          def metasyntactic_variables ; %w[ foo bar yak shed ] ; end
+        end
+      end
+
+      expect( Hypercuke::StepAdapters::Array::Core .superclass ).to be( Hypercuke::StepAdapter )
+    end
+
+    it "works when a layer name resolves to something outside the Hypercuke namespace" do
+      Hypercuke.topic :absurdity do
+        layer :array do
+          def metasyntactic_variables ; %w[ foo bar yak shed ] ; end
+        end
+      end
+
+      expect( Hypercuke::StepAdapters::Absurdity::Array .superclass ).to be( Hypercuke::StepAdapter )
+    end
+  end
+end

data/spec/step_driver_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe Hypercuke::StepDriver do
+  before do
+    Hypercuke.topic :wibble do
+      layer :spam  do ; def wibble ; "wibble spam"  ; end ; end
+      layer :eggs  do ; def wibble ; "wibble eggs"  ; end ; end
+      layer :bacon do ; def wibble ; "wibble bacon" ; end ; end
+    end
+    Hypercuke.topic :yak do
+      layer :spam  do ; def shave ; "s*MOO*th spam"  ; end ; end
+      layer :eggs  do ; def shave ; "s*MOO*th eggs"  ; end ; end
+      # Is yak bacon even a thing?  ...wait, don't answer that.
+    end
+    Hypercuke.current_layer = :spam
+  end
+
+
+  subject(:step_driver) { described_class.new }
+
+  describe "step adapter retrieval" do
+
+    it "asks Hypercuke for the current layer" do
+      Hypercuke.current_layer = :bacon
+      expect( step_driver.layer_name ).to eq( :bacon )
+    end
+
+    it "can return a step adapter for each layer" do
+      expect( step_driver.wibble.wibble ).to eq( "wibble spam" )
+      expect( step_driver.yak.shave ).to eq( "s*MOO*th spam" )
+    end
+
+    it "explodes when asked for a topic that isn't defined" do
+      expect{ step_driver.heffalump }.to raise_error( Hypercuke::TopicNotDefinedError, "Topic not defined: heffalump" )
+    end
+
+    it "explodes when asked for a layer that isn't defined" do
+      Hypercuke.current_layer = :booOOoogus
+      expect{ step_driver.wibble }.to raise_error( Hypercuke::LayerNotDefinedError, "Layer not defined: booOOoogus" )
+    end
+
+    it "explodes when asked for a step adapter that isn't defined at the current layer" do
+      Hypercuke.current_layer = :bacon
+      expect( step_driver.wibble ).to be_kind_of( Hypercuke::StepAdapters::Wibble::Bacon )
+      expect{ step_driver.yak }.to raise_error( Hypercuke::StepAdapterNotDefinedError, "Step adapter not defined: 'Hypercuke::StepAdapters::Yak::Bacon'" )
+    end
+
+    it "can return a step adapter for each layer (even when the layer is changed)" do
+      [ :spam, :eggs, :bacon ].each do |layer|
+        Hypercuke.current_layer = layer
+        expect( step_driver.wibble.wibble ).to eq( "wibble #{layer}" )
+        expect( step_driver.yak.shave ).to eq( "s*MOO*th #{layer}" ) unless :bacon == layer
+      end
+    end
+
+  end
+
+  describe "context management" do
+    let(:sd_context) { step_driver.send(:__context__) }
+
+    specify "step driver has a context" do
+      expect( sd_context ).to be_kind_of( Hypercuke::Context )
+    end
+
+    specify "step driver passes its context to any step adapter it creates" do
+      step_adapter_context = step_driver.wibble.__send__(:context)
+      expect( step_adapter_context ).to be( sd_context )
+    end
+  end
+
+  describe "inter-adapter dependencies" do
+    before do
+      Hypercuke.reset!
+      Hypercuke.topic :bikeshed do
+        layer :distraction do
+          def color ; "blue" ; end
+        end
+        layer :planet_ruby do
+          def color ; "ruby red" ; end # HINT: the herring is red, too...
+        end
+      end
+      Hypercuke.topic :yak do
+        layer :distraction do
+          def bikeshed_color
+            step_driver.bikeshed.color
+          end
+        end
+      end
+      Hypercuke.current_layer = :distraction
+    end
+
+    let(:step_driver) { described_class.new }
+
+    specify "step adapters within the same layer may access one another through the step driver" do
+      expect( step_driver.yak.bikeshed_color ).to eq( "blue" )
+    end
+  end
+
+end