torkify 0.0.1 → 0.0.2

data/lib/torkify.rb

@@ -1,4 +1,5 @@
 require "torkify/version"
+require 'log4r'
 
 # Listen to tork events and execute ruby code when they happen.
 #
@@ -15,6 +16,7 @@ require "torkify/version"
 #   # or listener.start_loop
 #   # or listener.start_with_tork
 module Torkify
+  include Log4r
 
   # Create a listener object and load all required files.
   def self.listener(*args)
@@ -26,9 +28,6 @@ module Torkify
   #
   # Uses Log4r.
   def self.logger
-    require 'log4r'
-    include Log4r
-
     log = Logger['torkify']
     unless log
       log = Logger.new 'torkify'

data/spec/conductor_spec.rb

@@ -1,12 +1,11 @@
 require 'spec_helper'
 require 'torkify/conductor'
-require 'torkify/observer_set'
 
 module Torkify
   describe Conductor do
     before do
       @reader = double
-      @observers = Torkify::ObserverSet.new
+      @observers = Set.new
       @conductor = Conductor.new @observers
     end
 
@@ -38,7 +37,7 @@ module Torkify
       end
 
       it "should call startup and shutdown on each observer and each_line on reader" do
-        @reader.should_receive(:each_line)
+        @reader.should_receive(:gets).and_return nil
         @conductor.start @reader
       end
     end
@@ -46,7 +45,7 @@ module Torkify
     context "when start is called with dummy input" do
       before do
         line = '["test","spec/status_change_event_spec.rb",[],"spec/status_change_event_spec.rb.log",0]'
-        @reader.should_receive(:each_line).and_yield(line)
+        @reader.should_receive(:gets).and_return(line, nil)
         @conductor.observers += [double, double]
       end
 

data/spec/event/basic_event_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'torkify/event/basic_event'
+
+module Torkify::Event
+  describe BasicEvent do
+    context "when type is absorb" do
+      before do
+        @event = BasicEvent.new('absorb')
+      end
+
+      subject { @event }
+
+      its(:type) { should == 'absorb' }
+      its(:to_s) { should == 'absorb' }
+      its(:message) { should == :on_absorb }
+    end
+
+    context "when type is stop" do
+      before do
+        @event = BasicEvent.new('stop')
+      end
+
+      subject { @event }
+
+      its(:type) { should == 'stop' }
+      its(:to_s) { should == 'stop' }
+      its(:message) { should == :on_stop }
+    end
+  end
+end

data/spec/event/dispatcher_spec.rb

@@ -0,0 +1,190 @@
+require 'spec_helper'
+require 'torkify/event/dispatcher'
+require 'torkify/event/basic_event'
+require 'torkify/event/pass_or_fail_event'
+
+module Torkify::Event
+
+  class ExampleObserver
+    def on_stop(event, a1, a2, a3, a4, a5)
+      receive :on_stop, event, a1, a2, a3, a4, a5
+    end
+
+    def on_fail(event, another)
+      receive :on_fail, event, another
+    end
+
+    def on_test(event)
+      receive :on_test, event
+    end
+
+    def method_missing(name, *args)
+      receive name, *args
+    end
+
+    def on_pass
+      receive :on_pass
+    end
+
+    def receive(message, *args)
+      @received = [message, *args]
+    end
+
+    attr_reader :received
+  end
+
+  describe Dispatcher do
+    shared_examples "an observer notification" do
+      it "should send the expected message and event to the observer" do
+        observers.each { |o| o.should_receive(expected_message).with(event) }
+        subject.dispatch event
+      end
+    end
+
+    shared_examples "an observer with a called method" do
+      before { dispatcher.dispatch(event) }
+      subject { observers.first }
+
+      its(:received) { should == expected_call }
+    end
+
+    context "with a single observer" do
+      let(:observers) { [mock] }
+      subject { Dispatcher.new observers }
+
+      context "dispatching an example event" do
+        let(:event) { BasicEvent.new :example }
+        let(:expected_message) { :on_example }
+
+        it_behaves_like "an observer notification"
+      end
+
+      context "dispatching a test event" do
+        let(:event) { BasicEvent.new :test }
+        let(:expected_message) { :on_test }
+
+        it_behaves_like "an observer notification"
+      end
+
+    end
+
+    context "with a concrete observer" do
+      let(:observers)  { [ ExampleObserver.new ] }
+      let(:dispatcher) { Dispatcher.new observers }
+
+      context "dispatching to a method that receives no arguments" do
+        let(:event) { BasicEvent.new :pass }
+        let(:expected_call) { [:on_pass] }
+
+        it_behaves_like "an observer with a called method"
+      end
+
+      context "dispatching to a method that receives one argument" do
+        let(:event) { BasicEvent.new :test }
+        let(:expected_call) { [:on_test, event] }
+
+        it_behaves_like "an observer with a called method"
+      end
+
+      context "dispatching to a method that receives two arguments" do
+        let(:event) { BasicEvent.new :fail }
+        let(:expected_call) { [:on_fail, event, nil] }
+
+        it_behaves_like "an observer with a called method"
+      end
+
+      context "dispatching to a method that receives many arguments" do
+        let(:event) { BasicEvent.new :stop }
+        let(:expected_call) { [:on_stop, event, nil, nil, nil, nil, nil] }
+
+        it_behaves_like "an observer with a called method"
+      end
+
+      context "dispatching to use method missing" do
+        let(:event) { BasicEvent.new :unknown }
+        let(:expected_call) { [:on_unknown, event] }
+
+        it_behaves_like "an observer with a called method"
+      end
+
+      context "dispatching a run all test files event" do
+        let(:event) { BasicEvent.new :run_all_test_files }
+        let(:expected_call) { [:on_run_all_test_files, event] }
+
+        before { dispatcher.dispatch event }
+
+        it_behaves_like "an observer with a called method"
+
+        context "after sending the idle event" do
+          before { dispatcher.dispatch BasicEvent.new :idle }
+
+          subject { observers.first.received }
+
+          its(:first) { should == :on_ran_all_test_files }
+
+          context "the event" do
+            subject { observers.first.received[1] }
+            it { should be_a RanAllTestFilesEvent }
+            its(:passed) { should == [] }
+            its(:failed) { should == [] }
+            its(:time) { should > 0.0 }
+          end
+        end
+
+        context "after sending several pass and fail events" do
+          let(:pass_events) { Array.new(3) { PassOrFailEvent.new(:pass) } }
+          let(:fail_events) { Array.new(3) { PassOrFailEvent.new(:fail) } }
+
+          before do
+            pass_events.each { |e| dispatcher.dispatch e }
+            fail_events.each { |e| dispatcher.dispatch e }
+            dispatcher.dispatch BasicEvent.new :idle
+          end
+
+          subject { observers.first.received }
+
+          its(:first) { should == :on_ran_all_test_files }
+
+          context "the event" do
+            subject { observers.first.received[1] }
+            it { should be_a RanAllTestFilesEvent }
+            its(:passed) { should == pass_events }
+            its(:failed) { should == fail_events }
+            its(:time) { should > 0.0 }
+          end
+        end
+      end
+    end
+
+    context "with an observer that has no methods" do
+      let(:observers) { [Object.new] }
+
+      let(:dispatcher) { Dispatcher.new observers }
+
+      context "dispatching an event" do
+        it "should not raise an exception" do
+          expect { dispatcher.dispatch BasicEvent.new(:missing) }.not_to raise_error
+        end
+      end
+    end
+
+    context "with multiple observers" do
+      let(:observers) { Array.new(3) { mock } }
+      subject { Dispatcher.new observers }
+
+      context "dispatching an absorb event" do
+        let(:event) { BasicEvent.new :absorb }
+        let(:expected_message) { :on_absorb }
+
+        it_behaves_like "an observer notification"
+      end
+
+      context "dispatching a fail event" do
+        let(:event) { BasicEvent.new :fail }
+        let(:expected_message) { :on_fail }
+
+        it_behaves_like "an observer notification"
+      end
+    end
+  end
+end

data/spec/event/echo_event_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'torkify/event/echo_event'
+
+module Torkify::Event
+  describe EchoEvent do
+
+    context "with a pass_now_fail event" do
+      before do
+        @type = 'echo'
+        @arguments = ['a']
+        @event = EchoEvent.new(@type, @arguments)
+      end
+
+      subject { @event }
+
+      its(:type)      { should == @type }
+      its(:arguments) { should == @arguments }
+      its(:args)      { should == @arguments }
+      its(:to_s)      { should == @type }
+    end
+  end
+end

data/spec/event/parser_spec.rb

@@ -0,0 +1,288 @@
+require 'spec_helper'
+require 'torkify/event/parser'
+
+module Torkify::Event
+  shared_examples "a basic event" do |type|
+    it { should be_an BasicEvent }
+    its(:type) { should == type }
+  end
+
+  shared_examples "an echo event" do |args|
+    it { should be_an EchoEvent }
+    its(:type) { should == 'echo' }
+    its(:args) { should == args }
+  end
+
+  shared_examples "an echo event and sub event" do |type, echo_args = nil|
+    its(:length) { should == 2 }
+
+    context "the first event" do
+      subject { @event_list.first }
+
+      it_behaves_like "an echo event", (echo_args || [type])
+    end
+
+    context "the second event" do
+      subject { @event_list[1] }
+
+      it_behaves_like "a basic event", type
+    end
+  end
+
+  describe Parser do
+    before { @parser = Parser.new }
+
+    context "when calling parse on a test event line with no numbers" do
+      before do
+        line = '["test","spec/reader_spec.rb",[],"spec/reader_spec.rb.log",3]'
+        @event_list = @parser.parse line
+      end
+
+      subject { @event_list.first }
+
+      it { should be_a TestEvent }
+
+      its(:file)     { should == 'spec/reader_spec.rb' }
+      its(:lines)    { should == [] }
+      its(:log_file) { should == 'spec/reader_spec.rb.log' }
+      its(:worker)   { should == 3 }
+    end
+
+    context "when calling parse on a test event line with numbers" do
+      before do
+        line = '["test","spec/another_spec.rb",[20, 32, 41],"spec/another_spec.rb.log",6]'
+        @event_list = @parser.parse line
+      end
+
+      subject { @event_list.first }
+
+      it { should be_a TestEvent }
+
+      its(:file)     { should == 'spec/another_spec.rb' }
+      its(:lines)    { should == [20, 32, 41] }
+      its(:log_file) { should == 'spec/another_spec.rb.log' }
+      its(:worker)   { should == 6 }
+    end
+
+    context "when calling parse on a pass event line" do
+      before do
+        line = '["pass","spec/pass_spec.rb",[27],"spec/pass_spec.rb.log",1,0,"#<Process::Status: pid 27490 exit 0>"]'
+        @event_list = @parser.parse line
+      end
+
+      subject { @event_list.first }
+
+      it { should be_a PassOrFailEvent }
+      its(:type)      { should == 'pass' }
+      its(:file)      { should == 'spec/pass_spec.rb' }
+      its(:lines)     { should == [27] }
+      its(:log_file)  { should == 'spec/pass_spec.rb.log' }
+      its(:worker)    { should == 1 }
+      its(:exit_code) { should == 0 }
+      its(:pid)       { should == 27490 }
+    end
+
+    context "when calling parse on a fail event line" do
+      before do
+
+        line = '["fail","spec/fail_spec.rb",[],"spec/fail_spec.rb.log",1,256,"#<Process::Status: pid 23318 exit 1>"]'
+        @event_list = @parser.parse line
+      end
+
+      subject { @event_list.first }
+
+      it { should be_a PassOrFailEvent }
+      its(:type)      { should == 'fail' }
+      its(:file)      { should == 'spec/fail_spec.rb' }
+      its(:lines)     { should == [] }
+      its(:log_file)  { should == 'spec/fail_spec.rb.log' }
+      its(:worker)    { should == 1 }
+      its(:exit_code) { should == 256 }
+      its(:pid)       { should == 23318 }
+    end
+
+    context "when calling parse on an absorb event line" do
+      before do
+        line = '["absorb"]'
+        @event_list = @parser.parse line
+      end
+
+      subject { @event_list.first }
+
+      it_behaves_like "a basic event", 'absorb'
+    end
+
+    context "when calling parse on an unknown event type" do
+      before do
+        line = '["random"]'
+        @event_list = @parser.parse line
+      end
+
+      subject { @event_list.first }
+
+      it_behaves_like "a basic event", 'random'
+    end
+
+    context "when calling parse on a pass now fail event line" do
+      before do
+        line = '["pass_now_fail","spec/status_change_spec.rb",["fail","spec/status_change_spec.rb",[68],"spec/status_change_spec.rb.log",2,256,"#<Process::Status: pid 23819 exit 1>"]]'
+        @event_list = @parser.parse line
+      end
+
+      subject { @event_list.first }
+
+      it { should be_a StatusChangeEvent }
+      its(:type)      { should == 'pass_now_fail' }
+      its(:file)      { should == 'spec/status_change_spec.rb' }
+      its(:event)     { should be_a PassOrFailEvent }
+
+      context "and getting the inner event" do
+        subject { @event_list.first.event }
+
+        its(:type)      { should == 'fail' }
+        its(:file)      { should == 'spec/status_change_spec.rb' }
+        its(:log_file)  { should == 'spec/status_change_spec.rb.log' }
+        its(:lines)     { should == [68] }
+        its(:worker)    { should == 2 }
+        its(:exit_code) { should == 256 }
+        its(:pid)       { should == 23819 }
+      end
+    end
+
+    context "when calling parse on a fail now pass event line" do
+      before do
+        line = '["fail_now_pass","spec/status_change_spec.rb",["pass","spec/status_change_spec.rb",[],"spec/status_change_spec.rb.log",1,0,"#<Process::Status: pid 677 exit 0>"]]'
+        @event_list = @parser.parse line
+      end
+
+      subject { @event_list.first }
+
+      it { should be_a StatusChangeEvent }
+      its(:type)      { should == 'fail_now_pass' }
+      its(:file)      { should == 'spec/status_change_spec.rb' }
+      its(:event)     { should be_a PassOrFailEvent }
+
+      context "and getting the inner event" do
+        subject { @event_list.first.event }
+
+        its(:type)      { should == 'pass' }
+        its(:file)      { should == 'spec/status_change_spec.rb' }
+        its(:log_file)  { should == 'spec/status_change_spec.rb.log' }
+        its(:lines)     { should == [] }
+        its(:worker)    { should == 1 }
+        its(:exit_code) { should == 0 }
+        its(:pid)       { should == 677 }
+      end
+    end
+
+    context "when calling parse on an idle line for an idle event" do
+      before do
+        line = '["idle"]'
+        @event_list = @parser.parse line
+      end
+
+      subject { @event_list }
+
+      its(:length) { should == 1 }
+
+      context "the first event" do
+        subject { @event_list.first }
+
+        it_behaves_like "a basic event", 'idle'
+      end
+    end
+
+    context "when calling parse on an echo line for the idle event" do
+      before do
+        line = '["echo", ["idle"]]'
+        @event_list = @parser.parse line
+      end
+
+      subject { @event_list }
+
+      its(:length) { should == 1 }
+
+      context "the first event" do
+        subject { @event_list.first }
+
+        it_behaves_like "an echo event", ['idle']
+      end
+    end
+
+    context "when calling parse on an echo line for the run_test_files command" do
+      context "with no arguments" do
+        before do
+          line = '["echo", ["run_test_files", []]]'
+          @event_list = @parser.parse line
+        end
+
+        subject { @event_list }
+
+        its(:length) { should == 1 }
+
+        context "the first event" do
+          subject { @event_list.first }
+
+          it_behaves_like "an echo event", ['run_test_files', []]
+        end
+      end
+
+      context "with files as arguments" do
+        before do
+          line = '["echo", ["run_test_files", ["path/to/file1.rb", "path/to/file2.rb"]]]'
+          @event_list = @parser.parse line
+        end
+
+        subject { @event_list }
+
+        it_behaves_like "an echo event and sub event",
+                        'run_test_files',
+                        ["run_test_files", ["path/to/file1.rb", "path/to/file2.rb"]]
+      end
+    end
+
+    context "when calling parse on an echo line for the run_test_file command" do
+      before do
+        line = '["echo", ["run_test_file", "path/to/file.rb"]]'
+        @event_list = @parser.parse line
+      end
+
+      subject { @event_list }
+
+      it_behaves_like "an echo event and sub event", 'run_test_file', ['run_test_file', 'path/to/file.rb']
+    end
+
+    context "when calling parse on an echo line for the run_test_file command" do
+      before do
+        line = '["echo", ["stop_running_test_files"]]'
+        @event_list = @parser.parse line
+      end
+
+      subject { @event_list }
+
+      it_behaves_like "an echo event and sub event", 'stop_running_test_files'
+    end
+
+    context "when calling parse on an echo line for the rerun_passed_test_files command" do
+      before do
+        line = '["echo", ["rerun_passed_test_files"]]'
+        @event_list = @parser.parse line
+      end
+
+      subject { @event_list }
+
+      it_behaves_like "an echo event and sub event", 'rerun_passed_test_files'
+    end
+
+    context "when calling parse on an echo line for a rerun_failed_test_files command" do
+      before do
+        line = '["echo",["rerun_failed_test_files"]]'
+        @event_list = @parser.parse line
+      end
+
+      subject { @event_list }
+
+      it_behaves_like "an echo event and sub event", 'rerun_failed_test_files'
+    end
+  end
+end

data/spec/{pass_or_fail_event_spec.rb → event/pass_or_fail_event_spec.rb}

@@ -1,7 +1,7 @@
 require 'spec_helper'
-require 'torkify/events/pass_or_fail_event'
+require 'torkify/event/pass_or_fail_event'
 
-module Torkify
+module Torkify::Event
   describe PassOrFailEvent do
 
     context "with pass data" do

data/spec/event/ran_all_test_files_event_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'torkify/event/ran_all_test_files_event'
+
+module Torkify::Event
+  describe RanAllTestFilesEvent do
+    context "with no sub events" do
+      subject { RanAllTestFilesEvent.new :all_tests_run }
+
+      its(:type)    { should == :all_tests_run }
+      its(:message) { should == :on_all_tests_run }
+      its(:passed)  { should == [] }
+      its(:failed)  { should == [] }
+      its(:time)  { should > 0.0 }
+    end
+
+    context "with passed and failed events" do
+      let(:passed) { [mock, mock] }
+      let(:failed) { [mock, mock] }
+      subject { RanAllTestFilesEvent.new :all_tests_run, passed, failed }
+
+      its(:type)    { should == :all_tests_run }
+      its(:message) { should == :on_all_tests_run }
+      its(:passed)  { should == passed }
+      its(:failed)  { should == failed }
+      its(:time)    { should > 0.0 }
+    end
+
+    context "after sleeping" do
+      let(:event) { RanAllTestFilesEvent.new :all_tests_run }
+
+      before do
+        event
+        sleep 0.3
+      end
+
+      subject { event }
+
+      its(:time) { should > 0.3 }
+    end
+  end
+end
+

data/spec/{status_change_event_spec.rb → event/status_change_event_spec.rb}

@@ -1,8 +1,8 @@
 require 'spec_helper'
-require 'torkify/events/status_change_event'
-require 'torkify/events/pass_or_fail_event'
+require 'torkify/event/status_change_event'
+require 'torkify/event/pass_or_fail_event'
 
-module Torkify
+module Torkify::Event
   describe StatusChangeEvent do
 
     context "with a pass_now_fail event" do

data/spec/{test_event_spec.rb → event/test_event_spec.rb}

@@ -1,7 +1,7 @@
 require 'spec_helper'
-require 'torkify/events/test_event'
+require 'torkify/event/test_event'
 
-module Torkify
+module Torkify::Event
   describe TestEvent do
 
     context "with typical seed data" do