cf 0.6.1.rc4 → 0.6.1.rc5

data/spec/console_app_specker/specker_runner_spec.rb

@@ -1,167 +0,0 @@
-require 'spec_helper'
-
-describe SpeckerRunner, :ruby19 => true do
-  def asset(file)
-    File.expand_path("../../assets/specker_runner/#{file}", __FILE__)
-  end
-
-  let(:timeout) { 1 }
-
-  describe "running a command" do
-    let(:file) do
-      file = Tempfile.new('test-specker-runner')
-      sleep 1  # wait one second to make sure touching the file does something measurable
-      file
-    end
-
-    after { file.unlink }
-
-    it "runs a command" do
-      run("touch -a #{file.path}") do |runner|
-        runner.wait_for_exit
-        file.stat.atime.should > file.stat.mtime
-      end
-    end
-  end
-
-  describe "#expect" do
-    context "when the expected output shows up" do
-      it "returns a truthy value" do
-        run("echo -n foo") do |runner|
-          expect(runner.expect('foo')).to be_true
-        end
-      end
-    end
-
-    context "when the expected output never shows up" do
-      it "returns nil" do
-        run("echo the spanish inquisition") do |runner|
-          expect(runner.expect("something else", 0.5)).to be_nil
-        end
-      end
-    end
-
-    context "when the output eventually shows up" do
-      it "returns a truthy value" do
-        run("ruby #{asset("specker_runner_pause.rb")}") do |runner|
-          expect(runner.expect("finished")).to be_true
-        end
-      end
-    end
-
-    context "backspace" do
-      it "respects the backspace character" do
-        run("ruby -e 'puts \"foo a\\bbar\"'") do |runner|
-          expect(runner.expect("foo bar")).to be_true
-        end
-      end
-
-      it "does not go beyond the beginning of the line" do
-        run("ruby -e 'print \"foo abc\nx\\b\\bd\"'") do |runner|
-          expect(runner.expect("foo abc\nd")).to be_true
-        end
-      end
-
-      it "does not go beyond the beginning of the string" do
-        run("ruby -e 'print \"f\\b\\bbar\"'") do |runner|
-          expect(runner.expect("bar")).to be_true
-        end
-      end
-
-      it "leaves backspaced characters in the buffer until they're overwritten" do
-        run("ruby -e 'print \"foo abc\\b\\bd\"'") do |runner|
-          expect(runner.expect("foo adc")).to be_true
-        end
-      end
-    end
-
-    context "ansi escape sequences" do
-      it "filters ansi color sequences" do
-        run("ruby -e 'puts \"\\e[36mblue\\e[0m thing\"'") do |runner|
-          expect(runner.expect("blue thing")).to be_true
-        end
-      end
-    end
-
-    context "expecting multiple branches" do
-      context "and one of them matches" do
-        it "can be passed a hash of values with callbacks, and returns the matched key" do
-          run("echo 1 3") do |runner|
-            branches = {
-              "1" => proc { 1 },
-              "2" => proc { 2 },
-              "3" => proc { 3 }
-            }
-
-            expect(runner.expect(branches)).to eq "1"
-            expect(runner.expect(branches)).to eq "3"
-          end
-        end
-
-        it "calls the matched callback" do
-          callback = mock!
-          run("echo 1 3") do |runner|
-            branches = {
-              "1" => proc { callback }
-            }
-            runner.expect(branches)
-          end
-        end
-      end
-
-      context "and none of them match" do
-        it "returns nil when none of the branches match" do
-          run("echo not_a_number") do |runner|
-            expect(runner.expect({"1" => proc { 1 }}, timeout)).to be_nil
-          end
-        end
-      end
-    end
-  end
-
-  describe "#output" do
-    it "makes the entire command output (so far) available" do
-      run("echo 0 1 2 3") do |runner|
-        runner.expect("1")
-        runner.expect("3")
-        expect(runner.output).to eq "0 1 2 3"
-      end
-
-    end
-  end
-
-  describe "#send_keys" do
-    it "sends input and expects more output afterward" do
-      run("ruby #{asset("specker_runner_input.rb")}") do |runner|
-        expect(runner.expect("started")).to be_true
-        runner.send_keys("foo")
-        expect(runner.expect("foo")).to be_true
-      end
-    end
-  end
-
-  context "#exit_code" do
-    it "returns the exit code" do
-      run("ruby -e 'exit 42'") do |runner|
-        runner.wait_for_exit
-        expect(runner.exit_code).to eq(42)
-      end
-    end
-
-    context "when the command is still running" do
-      it "waits for the command to exit" do
-        run("sleep 0.5") do |runner|
-          expect(runner.exit_code).to eq(0)
-        end
-      end
-    end
-  end
-
-  context "#exited?" do
-    it "returns false if the command is still running" do
-      run("sleep 10") do |runner|
-        expect(runner.exited?).to eq false
-      end
-    end
-  end
-end

data/spec/support/console_app_specker_matchers.rb

@@ -1,86 +0,0 @@
-module ConsoleAppSpeckerMatchers
-  class InvalidInputError < StandardError; end
-
-  class ExpectOutputMatcher
-    attr_reader :timeout
-
-    def initialize(expected_output, timeout = 30)
-      @expected_output = expected_output
-      @timeout = timeout
-    end
-
-    def matches?(runner)
-      raise InvalidInputError unless runner.respond_to?(:expect)
-      @matched = runner.expect(@expected_output, @timeout)
-      @full_output = runner.output
-      !!@matched
-    end
-
-    def failure_message
-      if @expected_output.is_a?(Hash)
-        expected_keys = @expected_output.keys.map{|key| "'#{key}'"}.join(', ')
-        "expected one of #{expected_keys} to be printed, but it wasn't. full output:\n#@full_output"
-      else
-        "expected '#{@expected_output}' to be printed, but it wasn't. full output:\n#@full_output"
-      end
-    end
-
-    def negative_failure_message
-      if @expected_output.is_a?(Hash)
-        match = @matched
-      else
-        match = @expected_output
-      end
-
-      "expected '#{match}' to not be printed, but it was. full output:\n#@full_output"
-    end
-  end
-
-
-  class ExitCodeMatcher
-    def initialize(expected_code)
-      @expected_code = expected_code
-    end
-
-    def matches?(runner)
-      raise InvalidInputError unless runner.respond_to?(:exit_code)
-
-      begin
-        Timeout.timeout(5) do
-          @actual_code = runner.exit_code
-        end
-
-        @actual_code == @expected_code
-      rescue Timeout::Error
-        @timed_out = true
-        false
-      end
-    end
-
-    def failure_message
-      if @timed_out
-        "expected process to exit with status #@expected_code, but it did not exit within 5 seconds"
-      else
-        "expected process to exit with status #{@expected_code}, but it exited with status #{@actual_code}"
-      end
-    end
-
-    def negative_failure_message
-      if @timed_out
-        "expected process to exit with status #@expected_code, but it did not exit within 5 seconds"
-      else
-        "expected process to not exit with status #{@expected_code}, but it did"
-      end
-    end
-  end
-
-  def say(expected_output, timeout = 30)
-    ExpectOutputMatcher.new(expected_output, timeout)
-  end
-
-  def have_exited_with(expected_code)
-    ExitCodeMatcher.new(expected_code)
-  end
-
-  alias :exit_with :have_exited_with
-end

data/spec/support/shared_examples/populate_organization.rb

@@ -1,6 +0,0 @@
-shared_examples_for "a_command_that_populates_organization" do
-  it "calls the organization populator" do
-    mock(CF::Populators::Organization).new(instance_of(Mothership::Inputs)) { mock!.populate_and_save! }
-    subject
-  end
-end

data/spec/support/specker_runner.rb

@@ -1,80 +0,0 @@
-require "pty"
-
-class SpeckerRunner
-  def initialize(*args)
-    @stdout, slave = PTY.open
-    system("stty raw", :in => slave)
-    read, @stdin = IO.pipe
-
-    @pid = spawn(*(args.push(:in => read, :out => slave, :err => slave)))
-
-    @expector = TrackingExpector.new(@stdout, ENV["DEBUG_BACON"])
-
-    yield self
-  end
-
-  def expect(matcher, timeout = 30)
-    case matcher
-    when Hash
-      expect_branches(matcher, timeout)
-    else
-      @expector.expect(matcher, timeout)
-    end
-  end
-
-  def send_keys(text_to_send)
-    @stdin.puts(text_to_send)
-  end
-
-  def exit_code
-    return @status if @status
-
-    status = nil
-    Timeout.timeout(5) do
-      _, status = Process.waitpid2(@pid)
-    end
-
-    @status = numeric_exit_code(status)
-  end
-
-  alias_method :wait_for_exit, :exit_code
-
-  def exited?
-    !running?
-  end
-
-  def running?
-    !!Process.getpgid(@pid)
-  end
-
-  def output
-    @expector.output
-  end
-
-  def debug
-    @expector.debug
-  end
-
-  def debug=(x)
-    @expector.debug = x
-  end
-
-  private
-
-  def expect_branches(branches, timeout)
-    branch_names = /#{branches.keys.collect { |k| Regexp.quote(k) }.join("|")}/
-    expected = @expector.expect(branch_names, timeout)
-    return unless expected
-
-    data = expected.first.match(/(#{branch_names})$/)
-    matched = data[1]
-    branches[matched].call
-    matched
-  end
-
-  def numeric_exit_code(status)
-    status.exitstatus
-  rescue NoMethodError
-    status
-  end
-end

data/spec/support/tracking_expector.rb

@@ -1,71 +0,0 @@
-class TrackingExpector
-  attr_reader :output
-
-  def initialize(out, debug = false)
-    @out = out
-    @debug = debug
-    @unused = ""
-    @output = ""
-  end
-
-  def expect(pattern, timeout = 5)
-    buffer = ''
-
-    case pattern
-    when String
-      pattern = Regexp.new(Regexp.quote(pattern))
-    when Regexp
-    else
-      raise TypeError, "unsupported pattern class: #{pattern.class}"
-    end
-
-    result = nil
-    position = 0
-    @unused ||= ""
-
-    while true
-      if !@unused.empty?
-        c = @unused.slice!(0).chr
-      elsif output_ended?(timeout)
-        @unused = buffer
-        break
-      else
-        c = @out.getc.chr
-      end
-
-      STDOUT.putc c if @debug
-
-      # wear your flip flops
-      unless (c == "\e") .. (c == "m")
-        if c == "\b"
-          if position > 0 && buffer[position - 1] && buffer[position - 1].chr != "\n"
-            position -= 1
-          end
-        else
-          if buffer.size > position
-            buffer[position] = c
-          else
-            buffer << c
-          end
-
-          position += 1
-        end
-      end
-
-      if matches = pattern.match(buffer)
-        result = [buffer, *matches.to_a[1..-1]]
-        break
-      end
-    end
-
-    @output << buffer
-
-    result
-  end
-
-  private
-
-  def output_ended?(timeout)
-    (@out.is_a?(IO) && !IO.select([@out], nil, nil, timeout)) || @out.eof?
-  end
-end