highline-test 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in highline-test.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Joe Yates
+
+MIT License
+
+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,84 @@
+# Highline::Test
+
+A micro framework to help you test your HighLine applications.
+
+HighLine allows you to supply your own input and output streams (instead of the
+default STDIN and STDOUT). This fact facilitates testing, allowing you to use
+StringIO objects for input and output.
+
+The problem with this approach is that it is hard to seperate the test, which pushes
+data to the input stream, and the application which reads that data.
+
+HighLine::Test resolves this problem by forking the test process.
+One fork runs the tests, the other runs the application.
+The two processes communicate via pipes.
+
+HighLine::test can be used with any testing framework, e.g.
+
+* RSpec
+* Test::Unit
+* Cucumber
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'highline-test'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install highline-test
+
+## Usage
+
+```ruby
+require 'highline/test'
+
+before do
+  # Before running a test, create a HighLine::Test::Client
+  @client = HighLine::Test::Client.new
+
+  # The application itself is started in a block passed to the #run method
+  @client.run do |driver|
+    # This block is run in a child process
+
+    # The HighLine instance used by the application *must* be the one supplied by
+    # the client.
+    HighLine.stub(:new).and_return(@client.high_line)
+
+    # Do any other setup (e.g. stubbing) here
+
+    # Start the application under test
+    MyApp.new.run
+
+    # If this block ever completes, the child process will be killed by
+    # HighLine::Test
+  end
+end
+
+after do
+  # Ensure the child process is cleaned up
+  @client.cleanup
+end
+
+it 'says Hello' do
+  # Send text input to the application
+  @client.type 'Fred'
+
+  # Test application output
+  expect(@client.output).to include('Hello Fred!')
+end
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+task :default => :spec
+
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+end
+

data/highline-test.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'highline/test/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'highline-test'
+  spec.version       = Highline::Test::VERSION
+  spec.authors       = ['Joe Yates']
+  spec.email         = ['joe.g.yates@gmail.com']
+  spec.description   = %q{Test HighLine applications}
+  spec.summary       = %q{A micro framework that sets up tests for HighLine applications}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(spec)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'highline'
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'bourne'
+  spec.add_development_dependency 'shoulda-matchers'
+end
+

data/lib/highline/test.rb

@@ -0,0 +1,11 @@
+class HighLine
+  module Test
+    PIPE_BUFFER_SIZE = 4096
+  end
+end
+
+require 'highline/test/version'
+require 'highline/test/partial_reader'
+require 'highline/test/driver'
+require 'highline/test/client'
+

data/lib/highline/test/client.rb

@@ -0,0 +1,90 @@
+module HighLine::Test
+  class Client
+    DEFAULT_POST_INPUT_DELAY = 0.1
+
+    # The delay in milliseconds that the client waits after sending text via
+    # the #type method
+    attr_accessor :delay
+    attr_accessor :child_pid
+
+    def initialize
+      @delay = DEFAULT_POST_INPUT_DELAY
+      setup
+    end
+
+    def run
+      raise "Supply a block to provide a context in which the application is run" unless block_given?
+
+      create_pipes
+
+      @child_pid = fork
+
+      if child_pid.nil?
+        partial_reader = PartialReader.new(@input_read)
+        driver = Driver.new(partial_reader, @output_write)
+        yield driver
+
+        # if the subject ever returns, kill the child process
+        Process.kill(:KILL, Process.pid)
+      end
+    end
+
+    def cleanup
+      return unless running?
+
+      kill_child_process
+      close_pipes
+      setup
+    end
+
+    def running?
+      not child_pid.nil?
+    end
+
+    def type(text)
+      raise 'Client is not running' unless running?
+
+      @input_write << "#{text}\n"
+      sleep delay
+    end
+
+    def output
+      return @output if @output
+      @output_write.close unless @output_write.closed?
+      @output = @output_read.readpartial(PIPE_BUFFER_SIZE)
+    end
+
+    private
+
+    def setup
+      @input_read   = nil
+      @input_write  = nil
+      @output_read  = nil
+      @output_write = nil
+      @output       = nil
+      @child_pid    = nil
+    end
+
+    def create_pipes
+      @input_read, @input_write = IO.pipe
+      @output_read, @output_write = IO.pipe
+    end
+
+    def kill_child_process
+      return if child_pid.nil?
+
+      Process.kill(:KILL, child_pid)
+    rescue Errno::ESRCH => e
+      # swallow errors if the child process has already been killed
+    ensure
+      @child_pid = nil
+    end
+
+    def close_pipes
+      [@input_read, @input_write, @output_read, @output_write].each do |stream|
+        stream.close unless stream.closed?
+      end
+    end
+  end
+end
+

data/lib/highline/test/driver.rb

@@ -0,0 +1,26 @@
+require 'highline'
+
+module HighLine::Test
+  class Driver
+    attr_reader :input_stream
+    attr_reader :output_stream
+
+    def initialize(input_stream, output_stream)
+      @input_stream = input_stream
+      @output_stream = output_stream
+    end
+
+    # Creates and returns a HighLine instance, set up to use the supplied streams
+    def high_line
+      return @high_line if @high_line
+      HighLine.track_eof = false
+      @high_line = HighLine.new(input_stream, output_stream)
+    end
+
+    # Adds text to the output stream
+    def inject(text)
+      @output_stream << text
+    end
+  end
+end
+

data/lib/highline/test/partial_reader.rb

@@ -0,0 +1,15 @@
+module HighLine::Test
+  # Wraps a pipe, supplying a non-blocking #gets method
+  class PartialReader
+    attr_reader :stream
+
+    def initialize(stream)
+      @stream = stream
+    end
+
+    def gets
+      stream.readpartial(PIPE_BUFFER_SIZE)
+    end
+  end
+end
+

data/lib/highline/test/version.rb

@@ -0,0 +1,5 @@
+module Highline
+  module Test
+    VERSION = "0.0.1"
+  end
+end

data/spec/lib/highline/test/client_spec.rb

@@ -0,0 +1,215 @@
+require 'spec_helper'
+
+module HighLine::Test
+  describe Client do
+    let(:input_read) { double('IO input pipe - read end', closed?: true) }
+    let(:input_write) { double('IO input pipe - write end', closed?: true) }
+    let(:output_read) { double('IO output pipe - read end', closed?: true) }
+    let(:output_write) { double('IO output pipe - write end', closed?: true) }
+    let(:input_pipe) { [input_read, input_write] }
+    let(:output_pipe) { [output_read, output_write] }
+    let(:streams) { input_pipe + output_pipe }
+    let(:child_pid) { 'child_pid' }
+    let(:running_subject) do
+      subject.run {}
+      subject
+    end
+
+    before do
+      subject.stub(:fork).and_return(child_pid)
+      IO.stub(:pipe).and_return(input_pipe, output_pipe)
+      Process.stub(:kill)
+    end
+
+    describe '#delay' do
+      it 'defaults to 0.1' do
+       expect(subject.delay).to eq(0.1)
+      end
+    end
+
+    describe '#delay=' do
+      it 'sets the delay value' do
+        subject.delay = 0.3
+
+        expect(subject.delay).to eq(0.3)
+      end
+    end
+
+    describe '#run' do
+      it 'fails if no block is passed' do
+        expect {
+          subject.run
+        }.to raise_error(RuntimeError, /Supply a block/)
+      end
+
+      it 'creates two pipes' do
+        subject.run {}
+
+        expect(IO).to have_received(:pipe).twice
+      end
+
+      it 'forks' do
+        subject.run {}
+
+        expect(subject).to have_received(:fork)
+      end
+
+      context 'child process' do
+        let(:partial_reader) { double('PartialReader') }
+        let(:driver) { double('Driver') }
+
+        before do
+          subject.stub(:fork).and_return(nil)
+          PartialReader.stub(:new).and_return(partial_reader)
+          Driver.stub(:new).with(partial_reader, output_write).and_return(driver)
+          Process.stub(:pid).and_return(child_pid)
+        end
+
+        it 'wraps the input stream in a class with a non-blocking #gets method' do
+          subject.run {}
+
+          expect(PartialReader).to have_received(:new).with(input_read)
+        end
+
+        it 'sets up a driver' do
+          subject.run {}
+
+          expect(Driver).to have_received(:new).with(partial_reader, output_write)
+        end
+
+        it 'calls the block' do
+          calls = 0
+          p = proc { calls += 1 }
+
+          subject.run(&p)
+
+          expect(calls).to eq(1)
+        end
+
+        it 'kills the child process if the block returns' do
+          subject.run {}
+
+          expect(Process).to have_received(:pid)
+          expect(Process).to have_received(:kill).with(:KILL, child_pid)
+        end
+      end
+
+      context 'parent process' do
+        before do
+          PartialReader.stub(:new)
+        end
+
+        it 'returns immediately' do
+          subject.run {}
+
+          expect(PartialReader).to_not have_received(:new)
+        end
+      end
+    end
+
+    describe '#cleanup' do
+      it 'kills the child process' do
+        running_subject.cleanup
+
+        expect(Process).to have_received(:kill).with(:KILL, child_pid)
+      end
+
+      it 'does nothing if not running' do
+        subject.cleanup
+
+        expect(Process).to_not have_received(:kill)
+      end
+
+      it "doesn't fail if the child process has terminated" do
+        Process.stub(:kill).and_raise(Errno::ESRCH)
+
+        expect {
+          running_subject.cleanup
+        }.not_to raise_error
+      end
+
+      it 'closes pipes' do
+        streams.each do |stream|
+          stream.stub(closed?: false)
+          stream.stub(:close)
+        end
+
+        running_subject.cleanup
+
+        streams.each do |stream|
+          expect(stream).to have_received(:close)
+        end
+      end
+    end
+
+    describe '#running?' do
+      it 'is true in the parent after #run is called' do
+        expect(running_subject.running?).to be_true
+      end
+
+      it 'is false after #cleanup' do
+        running_subject.cleanup
+
+        expect(subject.running?).to be_false
+      end
+    end
+
+    describe '#type' do
+      before do
+        input_write.stub(:<<)
+        subject.stub(:sleep)
+      end
+
+      it 'expects a parameter' do
+        expect {
+          subject.type
+        }.to raise_error(ArgumentError, /0 for 1/)
+      end
+
+      it 'fails if not running' do
+        expect {
+          subject.type 'Ciao'
+        }.to raise_error(RuntimeError, /not running/)
+      end
+
+      it 'appends the text and a new line to the input write stream' do
+        running_subject.type 'Ciao'
+
+        expect(input_write).to have_received(:<<).with("Ciao\n")
+      end
+
+      it 'sleeps for #delay seconds' do
+        running_subject.type 'Ciao'
+
+        expect(running_subject).to have_received(:sleep).with(0.1)
+      end
+    end
+
+    describe '#output' do
+      before do
+        streams.each do |stream|
+          stream.stub(closed?: false)
+          stream.stub(:close)
+        end
+        output_read.stub(:readpartial).with(4096).and_return('Foo')
+      end
+
+      it 'closes the output write stream' do
+        running_subject.output
+
+        expect(output_write).to have_received(:close)
+      end
+
+      it 'gets the output from HighLine' do
+        running_subject.output
+
+        expect(output_read).to have_received(:readpartial).with(4096)
+      end
+
+      it 'returns the output' do
+        expect(running_subject.output).to eq('Foo')
+      end
+    end
+  end
+end
+

data/spec/lib/highline/test/driver_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+module HighLine::Test
+  describe Driver do
+    let(:input_stream) { double('IO input') }
+    let(:output_stream) { double('IO output') }
+
+    subject { Driver.new(input_stream, output_stream) }
+
+    describe '#initialize' do
+      it 'expects an input and an output stream' do
+        expect {
+          Driver.new
+        }.to raise_error(ArgumentError, /0 for 2/)
+      end
+    end
+
+    describe '#input_stream' do
+      it 'returns the supplied input stream' do
+        expect(subject.input_stream).to eq(input_stream)
+      end
+    end
+
+    describe '#output_stream' do
+      it 'returns the supplied output stream' do
+        expect(subject.output_stream).to eq(output_stream)
+      end
+    end
+
+    describe '#high_line' do
+      let(:high_line) { double('HighLine') }
+
+      before do
+        HighLine.stub(:track_eof=)
+        HighLine.stub(:new).and_return(high_line)
+      end
+
+      it 'stops HighLine tracking eof' do
+        subject.high_line
+
+        expect(HighLine).to have_received(:track_eof=).with(false)
+      end
+
+      it 'sets up a HighLine instance with the supplied streams' do
+        subject.high_line
+
+        expect(HighLine).to have_received(:new).with(input_stream, output_stream)
+      end
+
+      it 'returns the HighLine instance' do
+        expect(subject.high_line).to eq(high_line)
+      end
+
+      it 'only creates one instance' do
+        subject.high_line
+        subject.high_line
+
+        expect(HighLine).to have_received(:new).once.with(input_stream, output_stream)
+      end
+    end
+
+    describe '#inject' do
+      before do
+        output_stream.stub(:<<)
+      end
+
+      it 'adds text to the output stream' do
+        subject.inject('foo')
+
+        expect(output_stream).to have_received(:<<).with('foo')
+      end
+    end
+  end
+end
+

data/spec/lib/highline/test/partial_reader_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+module HighLine::Test
+  describe PartialReader do
+    let(:stream) { double('IO') }
+
+    subject { PartialReader.new(stream) }
+
+    describe '#initialize' do
+      it 'expects a stream parameter' do
+        expect {
+          PartialReader.new
+        }.to raise_error(ArgumentError, /0 for 1/)
+      end
+    end
+
+    describe '#stream' do
+      it 'returns the stream' do
+        expect(subject.stream).to eq(stream)
+      end
+    end
+
+    describe '#gets' do
+      let(:output) { 'Hi there' }
+
+      before do
+        stream.stub(:readpartial).and_return(output)
+      end
+
+      it 'performs a non-blocking read' do
+        subject.gets
+
+        expect(stream).to have_received(:readpartial).with(4096)
+      end
+
+      it 'returns the result' do
+        expect(subject.gets).to eq(output)
+      end
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'rspec'
+require 'bourne'
+require 'highline/test'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.order = 'random'
+end
+

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: highline-test
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Joe Yates
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bourne
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: shoulda-matchers
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Test HighLine applications
+email:
+- joe.g.yates@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- highline-test.gemspec
+- lib/highline/test.rb
+- lib/highline/test/client.rb
+- lib/highline/test/driver.rb
+- lib/highline/test/partial_reader.rb
+- lib/highline/test/version.rb
+- spec/lib/highline/test/client_spec.rb
+- spec/lib/highline/test/driver_spec.rb
+- spec/lib/highline/test/partial_reader_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A micro framework that sets up tests for HighLine applications
+test_files:
+- spec/lib/highline/test/client_spec.rb
+- spec/lib/highline/test/driver_spec.rb
+- spec/lib/highline/test/partial_reader_spec.rb
+- spec/spec_helper.rb
+has_rdoc: