ellington 0.0.2 → 0.0.3

data/test/example.rb

@@ -25,128 +25,128 @@ end
 
 # stations -----------------------------------------------------------------
 class Add10 < Ellington::Station
-  def engage(passenger, options)
+  def engage(number, options)
     raise if rand(100) == 0
     if rand(100) > 5
-      passenger.calc :+, 10
-      pass passenger
+      number.calc :+, 10
+      pass_passenger number
     else
-      fail passenger
+      fail_passenger number
     end
   rescue
-    error passenger
+    error_passenger number
   end
 end
 
 class Add100 < Ellington::Station
-  def engage(passenger, options)
+  def engage(number, options)
     raise if rand(100) == 0
     if rand(100) > 5
-      passenger.calc :+, 100
-      pass passenger
+      number.calc :+, 100
+      pass_passenger number
     else
-      fail passenger
+      fail_passenger number
     end
   rescue
-    error passenger
+    error_passenger number
   end
 end
 
 class Add1000 < Ellington::Station
-  def engage(passenger, options)
+  def engage(number, options)
     raise if rand(100) == 0
     if rand(100) > 5
-      passenger.calc :+, 1000
-      pass passenger
+      number.calc :+, 1000
+      pass_passenger number
     else
-      fail passenger
+      fail_passenger number
     end
   rescue
-    error passenger
+    error_passenger number
   end
 end
 
 class MultiplyBy10 < Ellington::Station
-  def engage(passenger, options)
+  def engage(number, options)
     raise if rand(100) == 0
     if rand(100) > 5
-      passenger.calc :*, 10
-      pass passenger
+      number.calc :*, 10
+      pass_passenger number
     else
-      fail passenger
+      fail_passenger number
     end
   rescue
-    error passenger
+    error_passenger number
   end
 end
 
 class MultiplyBy100 < Ellington::Station
-  def engage(passenger, options)
+  def engage(number, options)
     raise if rand(100) == 0
     if rand(100) > 5
-      passenger.calc :*, 100
-      pass passenger
+      number.calc :*, 100
+      pass_passenger number
     else
-      fail passenger
+      fail_passenger number
     end
   rescue
-    error passenger
+    error_passenger number
   end
 end
 
 class MultiplyBy1000 < Ellington::Station
-  def engage(passenger, options)
+  def engage(number, options)
     raise if rand(100) == 0
     if rand(100) > 5
-      passenger.calc :*, 1000
-      pass passenger
+      number.calc :*, 1000
+      pass_passenger number
     else
-      fail passenger
+      fail_passenger number
     end
   rescue
-    error passenger
+    error_passenger number
   end
 end
 
 class DivideBy10 < Ellington::Station
-  def engage(passenger, options)
+  def engage(number, options)
     raise if rand(100) == 0
     if rand(100) > 5
-      passenger.calc :/, 10.0
-      pass passenger
+      number.calc :/, 10.0
+      pass_passenger number
     else
-      fail passenger
+      fail_passenger number
     end
   rescue
-    error passenger
+    error_passenger number
   end
 end
 
 class DivideBy100 < Ellington::Station
-  def engage(passenger, options)
+  def engage(number, options)
     raise if rand(100) == 0
     if rand(100) > 5
-      passenger.calc :/, 100.0
-      pass passenger
+      number.calc :/, 100.0
+      pass_passenger number
     else
-      fail passenger
+      fail_passenger number
     end
   rescue
-    error passenger
+    error_passenger number
   end
 end
 
 class DivideBy1000 < Ellington::Station
-  def engage(passenger, options)
+  def engage(number, options)
     raise if rand(100) == 0
     if rand(100) > 5
-      passenger.calc :/, 1000.0
-      pass passenger
+      number.calc :/, 1000.0
+      pass_passenger number
     else
-      fail passenger
+      fail_passenger number
     end
   rescue
-    error passenger
+    error_passenger number
   end
 end
 
@@ -184,8 +184,8 @@ class BasicMath < Ellington::Route
 
   goal division.passed, multiplication.passed
 
-  connect_to division, :if => addition.passed
-  connect_to multiplication, :if => addition.failed
+  connect_to division, :if_any => addition.passed
+  connect_to multiplication, :if_any => addition.failed
 
   log_passenger_attrs :original_value, :current_value
 end
@@ -194,6 +194,7 @@ end
 class NumberConductor < Ellington::Conductor
 
   def gather_passengers
+    sleep 1
     (0..999).to_a.sample(10).map do |num|
       num = NumberWithHistory.new(num)
       passenger = Ellington::Passenger.new(num, route)
@@ -209,4 +210,7 @@ if ENV["START"]
   route = BasicMath.new
   conductor = NumberConductor.new(route)
   conductor.start
+  #conductor.wait
+  sleep 5
+  conductor.stop
 end

data/test/line_info_test.rb

@@ -0,0 +1,78 @@
+require_relative "test_helper"
+
+class LineInfoTest < MicroTest::Test
+
+  before do
+    @route = BasicMath.new
+    @line = @route.lines.first
+    @station = @line.stations.first
+    @passenger = Ellington::Passenger.new(NumberWithHistory.new(0), @route)
+    @options = { :foo => :bar }
+    @transition_info = Ellington::TransitionInfo.new(@passenger, @route.initial_state, @station.passed)
+    @station_info = Ellington::StationInfo.new(@station, @passenger, @transition_info, @options)
+    @line_info = Ellington::LineInfo.new(@line, @station_info)
+  end
+
+  test "line" do
+    assert @line_info.line == @line
+  end
+
+  test "station_info" do
+    assert @line_info.station_info == @station_info
+  end
+
+  test "station" do
+    assert @line_info.station == @station
+  end
+
+  test "passenger" do
+    assert @line_info.passenger == @passenger
+  end
+
+  test "transition" do
+    assert @line_info.transition == @transition_info
+  end
+
+  test "options" do
+    assert @line_info.options == @options
+  end
+
+  test "station_full_name" do
+    assert @line_info.station_full_name == "Add10::Addition::BasicMath"
+  end
+
+  test "log_message" do
+    assert @line_info.log_message == "[original_value:0] [current_value:0]"
+  end
+
+  test "log_message with station_completed pass" do
+    @passenger.current_state = @station.passed
+    expected = "[STATION COMPLETED] [PASS] [Add10::Addition::BasicMath] [original_value:0] [current_value:0]"
+    assert @line_info.log_message(:station_completed => true) == expected
+  end
+
+  test "log_message with station_completed fail" do
+    @passenger.current_state = @station.failed
+    expected = "[STATION COMPLETED] [FAIL] [Add10::Addition::BasicMath] [original_value:0] [current_value:0]"
+    assert @line_info.log_message(:station_completed => true) == expected
+  end
+
+  test "log_message with station_completed error" do
+    @passenger.current_state = @station.errored
+    expected = "[STATION COMPLETED] [ERROR] [Add10::Addition::BasicMath] [original_value:0] [current_value:0]"
+    assert @line_info.log_message(:station_completed => true) == expected
+  end
+
+  test "log_message with line_completed pass" do
+    @passenger.current_state = @line.stations.last.passed
+    expected = "[LINE COMPLETED] [PASS] [Addition::BasicMath] [original_value:0] [current_value:0]"
+    assert @line_info.log_message(:line_completed => true) == expected
+  end
+
+  test "log_message with line_completed fail" do
+    @passenger.current_state = @line.stations.last.failed
+    expected = "[LINE COMPLETED] [FAIL] [Addition::BasicMath] [original_value:0] [current_value:0]"
+    assert @line_info.log_message(:line_completed => true) == expected
+  end
+
+end

data/test/line_test.rb

@@ -5,6 +5,28 @@ class LineTest < MicroTest::Test
   before do
     @route = BasicMath.new
     @line = @route.lines.first
+    @passenger = Ellington::Passenger.new(NumberWithHistory.new(0), @route)
+  end
+
+  test "must declare stations" do
+    class NoStationsLine < Ellington::Line
+    end
+    begin
+      NoStationsLine.new
+    rescue Ellington::NoStationsDeclared => e
+    end
+    assert !e.nil?
+  end
+
+  test "must declare goal" do
+    class NoGoalLine < Ellington::Line
+      stations << Add10.new
+    end
+    begin
+      NoGoalLine.new
+    rescue Ellington::NoGoalDeclared => e
+    end
+    assert !e.nil?
   end
 
   test "stations on class" do
@@ -31,7 +53,7 @@ class LineTest < MicroTest::Test
 
   test "stations are assigned line" do
     @line.stations.each do |station|
-      assert station.line == @line.class
+      assert station.line == @line
     end
   end
 
@@ -92,4 +114,41 @@ class LineTest < MicroTest::Test
     assert line.fail_target == expected
   end
 
+  test "passed" do
+    assert @line.passed == ["PASS Add1000::Addition"]
+  end
+
+  test "state pass" do
+    @passenger.current_state = @line.passed.first
+    assert @line.state(@passenger) == "PASS"
+  end
+
+  test "failed" do
+    assert @line.failed == [
+      "PASS Add10::Addition",
+      "FAIL Add10::Addition",
+      "PASS Add100::Addition",
+      "FAIL Add100::Addition",
+      "FAIL Add1000::Addition"
+    ]
+  end
+
+  test "state fail" do
+    @passenger.current_state = @line.failed.first
+    assert @line.state(@passenger) == "FAIL"
+  end
+
+  test "errored" do
+    assert @line.errored == [
+      "ERROR Add10::Addition", 
+      "ERROR Add100::Addition", 
+      "ERROR Add1000::Addition"
+    ]
+  end
+
+  test "state error" do
+    @passenger.current_state = @line.errored.first
+    assert @line.state(@passenger) == "ERROR"
+  end
+
 end

data/test/logger_test.rb

@@ -0,0 +1,20 @@
+require_relative "test_helper"
+require "logger"
+
+class LoggerTest < MicroTest::Test
+
+  before do
+    @orig_logger = Ellington.logger
+    @logger = Logger.new(STDOUT)
+    Ellington.logger = @logger
+  end
+
+  after do
+    Ellington.logger = @orig_logger
+  end
+
+  test "logger attr" do
+    assert Ellington.logger == @logger
+  end
+
+end

data/test/passenger_test.rb

@@ -70,4 +70,13 @@ class PassengerTest < MicroTest::Test
     assert watcher.info.new_state == "PASS Add10::Addition"
   end
 
+  test "state_history" do
+    @passenger.lock
+    @passenger.current_state = @route.initial_state
+    @passenger.transition_to @route.lines[0].states.keys.first
+    @passenger.transition_to @route.lines[2].states.keys.first
+    @passenger.unlock
+    assert @passenger.state_history == ["PASS Add10::Addition", "PASS MultiplyBy10::Multiplication"]
+  end
+
 end

data/test/route_info_test.rb

@@ -0,0 +1,63 @@
+require_relative "test_helper"
+
+class RouteInfoTest < MicroTest::Test
+
+  before do
+    @route = BasicMath.new
+    @line = @route.lines.first
+    @station = @line.stations.first
+    @passenger = Ellington::Passenger.new(NumberWithHistory.new(0), @route)
+    @passenger.current_state = @route.lines.last.passed.first
+    @options = { :foo => :bar }
+    @transition_info = Ellington::TransitionInfo.new(@passenger, @route.initial_state, @station.passed)
+    @station_info = Ellington::StationInfo.new(@station, @passenger, @transition_info, @options)
+    @line_info = Ellington::LineInfo.new(@line, @station_info)
+    @route_info = Ellington::RouteInfo.new(@route, @line_info)
+  end
+
+  test "route" do
+    assert @route_info.route == @route
+  end
+
+  test "line" do
+    assert @route_info.line == @line
+  end
+
+  test "line_info" do
+    assert @route_info.line_info == @line_info
+  end
+
+  test "station_info" do
+    assert @route_info.station_info == @station_info
+  end
+
+  test "station" do
+    assert @route_info.station == @station
+  end
+
+  test "passenger" do
+    assert @route_info.passenger == @passenger
+  end
+
+  test "transition" do
+    assert @route_info.transition == @transition_info
+  end
+
+  test "options" do
+    assert @route_info.options == @options
+  end
+
+  test "station_full_name" do
+    assert @route_info.station_full_name == "Add10::Addition::BasicMath"
+  end
+
+  test "log_message route pass" do
+    assert @route_info.log_message == "[ROUTE COMPLETED] [PASS] [BasicMath] [original_value:0] [current_value:0]"
+  end
+
+  test "log_message route fail" do
+    @passenger.current_state = @station.failed
+    assert @route_info.log_message == "[ROUTE COMPLETED] [FAIL] [BasicMath] [original_value:0] [current_value:0]"
+  end
+
+end

data/test/route_test.rb

@@ -4,6 +4,28 @@ class RouteTest < MicroTest::Test
 
   before do
     @route = BasicMath.new
+    @passenger = Ellington::Passenger.new(NumberWithHistory.new(0), @route)
+  end
+
+  test "must declare lines" do
+    class NoLinesRoute < Ellington::Route
+    end
+    begin
+      NoLinesRoute.new
+    rescue Ellington::NoLinesDeclared => e
+    end
+    assert !e.nil?
+  end
+
+  test "must declare goal" do
+    class NoGoalRoute < Ellington::Route
+      lines << Addition.new
+    end
+    begin
+      NoGoalRoute.new
+    rescue Ellington::NoGoalDeclared => e
+    end
+    assert !e.nil?
   end
 
   test "lines on class" do
@@ -48,4 +70,62 @@ class RouteTest < MicroTest::Test
     assert @route.connections.last.states == @route.lines[0].fail_target
   end
 
+  test "passed" do
+    assert @route.passed == [
+      "PASS DivideBy1000::Division", 
+      "PASS MultiplyBy1000::Multiplication"
+    ]
+  end
+
+  test "state pass" do
+    @passenger.current_state = @route.passed.first
+    assert @route.state(@passenger) == "PASS"
+  end
+
+  test "failed" do
+    assert @route.failed == [
+      "PRE BasicMath",
+      "PASS Add10::Addition",
+      "FAIL Add10::Addition",
+      "PASS Add100::Addition",
+      "FAIL Add100::Addition",
+      "PASS Add1000::Addition",
+      "FAIL Add1000::Addition",
+      "PASS DivideBy10::Division",
+      "FAIL DivideBy10::Division",
+      "PASS DivideBy100::Division",
+      "FAIL DivideBy100::Division",
+      "FAIL DivideBy1000::Division",
+      "PASS MultiplyBy10::Multiplication",
+      "FAIL MultiplyBy10::Multiplication",
+      "PASS MultiplyBy100::Multiplication",
+      "FAIL MultiplyBy100::Multiplication",
+      "FAIL MultiplyBy1000::Multiplication"
+    ]
+  end
+
+  test "state fail" do
+    @passenger.current_state = @route.failed.first
+    assert @route.state(@passenger) == "FAIL"
+  end
+
+  test "errored" do
+    assert @route.errored == [
+      "ERROR Add10::Addition",
+      "ERROR Add100::Addition",
+      "ERROR Add1000::Addition",
+      "ERROR DivideBy10::Division",
+      "ERROR DivideBy100::Division",
+      "ERROR DivideBy1000::Division",
+      "ERROR MultiplyBy10::Multiplication",
+      "ERROR MultiplyBy100::Multiplication",
+      "ERROR MultiplyBy1000::Multiplication"
+    ]
+  end
+
+  test "state error" do
+    @passenger.current_state = @route.errored.first
+    assert @route.state(@passenger) == "ERROR"
+  end
+
 end

data/test/station_info_test.rb

@@ -0,0 +1,31 @@
+require_relative "test_helper"
+
+class StationInfoTest < MicroTest::Test
+
+  before do
+    @route = BasicMath.new
+    @line = @route.lines.first
+    @station = @line.stations.first
+    @passenger = Ellington::Passenger.new(NumberWithHistory.new(0), @route)
+    @options = { :foo => :bar }
+    @transition_info = Ellington::TransitionInfo.new(@passenger, @route.initial_state, @station.passed)
+    @station_info = Ellington::StationInfo.new(@station, @passenger, @transition_info, @options)
+  end
+
+  test "station" do
+    assert @station_info.station == @station
+  end
+
+  test "passenger" do
+    assert @station_info.passenger == @passenger
+  end
+
+  test "transition" do
+    assert @station_info.transition == @transition_info
+  end
+
+  test "options" do
+    assert @station_info.options == @options
+  end
+
+end

data/test/station_test.rb

@@ -61,19 +61,19 @@ class StationTest < MicroTest::Test
 
   test "pass properly transitions passenger's state" do
     @passenger.current_state = @route.initial_state
-    @station.pass @passenger
+    @station.pass_passenger @passenger
     assert @passenger.current_state == @station.passed
   end
 
   test "fail properly transitions passenger's state" do
     @passenger.current_state = @route.initial_state
-    @station.fail @passenger
+    @station.fail_passenger @passenger
     assert @passenger.current_state == @station.failed
   end
 
   test "error properly transitions passenger's state" do
     @passenger.current_state = @route.initial_state
-    @station.error @passenger
+    @station.error_passenger @passenger
     assert @passenger.current_state == @station.errored
   end
 
@@ -91,8 +91,8 @@ class StationTest < MicroTest::Test
 
   test "engage" do
     @passenger.current_state = @route.initial_state
-    @station.engage(@passenger, :pass => true)
-    assert @passenger.current_state == @station.passed
+    @station.engage(@passenger, nil)
+    assert @passenger.current_state != @route.initial_state
   end
 
   test "observers are notified after a station completes" do
@@ -103,13 +103,13 @@ class StationTest < MicroTest::Test
     end
     @station.add_observer observer
     @passenger.current_state = @route.initial_state
-    @station.call(@passenger, :pass => true)
+    @station.call(@passenger)
     assert observer.callbacks.length == 1
     info = observer.callbacks.first
     assert info.station == @station
     assert info.passenger == @passenger
     assert info.transition.old_state == @route.initial_state
-    assert info.transition.new_state == @station.passed
+    assert info.transition.new_state != @route.initial_state
   end
 
 end

data/test/test_helper.rb

@@ -1,6 +1,5 @@
 require "logger"
 require "delegate"
-require 'pry-exception_explorer'
 require_relative "../lib/ellington"
 require_relative "example"
 

data/test/transition_info_test.rb

@@ -0,0 +1,25 @@
+require_relative "test_helper"
+
+class TransitionInfoTest < MicroTest::Test
+
+  before do
+    @route = BasicMath.new
+    @line = @route.lines.first
+    @station = @line.stations.first
+    @passenger = Ellington::Passenger.new(NumberWithHistory.new(0), @route)
+    @transition_info = Ellington::TransitionInfo.new(@passenger, @route.initial_state, @station.passed)
+  end
+
+  test "passenger" do
+    assert @transition_info.passenger == @passenger
+  end
+
+  test "old_state" do
+    assert @transition_info.old_state == @route.initial_state
+  end
+
+  test "new_state" do
+    assert @transition_info.new_state == @station.passed
+  end
+
+end

data/test/unique_type_array_test.rb

@@ -0,0 +1,32 @@
+require_relative "test_helper"
+
+class UniqueTypeArrayTest < MicroTest::Test
+
+  before do
+    @list = Ellington::UniqueTypeArray.new
+  end
+
+  test "accepts values of different types" do
+    @list.push 1
+    @list.push 1.0
+    @list.push true
+    @list.push "hi"
+    @list.push :foo
+  end
+
+  test "can only push 1 entry with the same type" do
+    @list.push 1
+    begin
+      @list.push 2
+    rescue Ellington::ListAlreadyContainsType => e
+    end
+    assert !e.nil?
+  end
+
+  test "contains_a?" do
+    @list.push :foo
+    assert @list.contains_a?(Symbol)
+  end
+
+end
+