vmsim 0.2.3

data/test/hardware/cash_register_test.rb

@@ -0,0 +1,157 @@
+require File.join(File.dirname(__FILE__),'..','test_helper')
+require 'mocha'
+require 'hardware'
+require 'hardware_adapter'
+
+module Hardware
+  RIGHT_AWAY = 0
+  class CashRegisterDroppingCoinsInBin < Test::Unit::TestCase
+    attr_reader :register, :bin
+    def setup
+      @bin = mock('bin')
+      @register = CashRegister.new(bin, Adapter::SensorCollection.null, nil)
+      register.fill(Coin.two_euro, 1, RIGHT_AWAY)
+    end
+
+    def test_drops_coin_in_bin
+      bin.expects(:receive).with(Coin.two_euro)
+      register.drop_coin(Coin.two_euro, RIGHT_AWAY)
+    end
+
+    def test_drops_nohting_when_empty
+      bin.expects(:receive).with(Coin.two_euro).never
+      register.drop_coin(Coin.one_euro, RIGHT_AWAY)
+    end
+    
+    def test_drops_eventually_empties_the_coin_stock
+      bin.expects(:receive).with(Coin.two_euro).once
+      register.drop_coin(Coin.two_euro, RIGHT_AWAY)
+      register.drop_coin(Coin.two_euro, RIGHT_AWAY)
+    end
+    
+    def test_filling_coins_adds_to_stock
+      register.fill(Coin.two_euro, 1, 0)
+      bin.expects(:receive).with(Coin.two_euro).twice
+      register.drop_coin(Coin.two_euro, RIGHT_AWAY)
+      register.drop_coin(Coin.two_euro, RIGHT_AWAY)
+      register.drop_coin(Coin.two_euro, RIGHT_AWAY)
+    end
+
+    def test_insert_coin_adds_it_to_stock
+      register.insert_coin(Coin.two_euro)
+      bin.expects(:receive).with(Coin.two_euro).twice
+      register.drop_coin(Coin.two_euro, RIGHT_AWAY)
+      register.drop_coin(Coin.two_euro, RIGHT_AWAY)
+      register.drop_coin(Coin.two_euro, RIGHT_AWAY)
+    end
+    
+  end
+  
+  class CashRegisterSensorFiringTest < Test::Unit::TestCase
+    attr_reader :register, :bin, :sensor_collection
+
+    def setup 
+      @bin = stub('bin', :receive)
+      @sensor_collection = mock('sensor_collection')
+      @register = CashRegister.new(bin, sensor_collection, nil)
+    end
+    
+    def test_insert_two_euros_fires_cash_insert_200
+      sensor_collection.expects(:fire).with(:cash_insert_200)
+      register.insert_coin(Coin.two_euro)
+    end
+    
+    def test_insert_one_euro_fires_cash_insert_100
+      sensor_collection.expects(:fire).with(:cash_insert_100)
+      register.insert_coin(Coin.one_euro)
+    end
+    
+    def test_insert_fifty_cents_fires_cash_insert_50
+      sensor_collection.expects(:fire).with(:cash_insert_50)
+      register.insert_coin(Coin.fifty_cents)
+    end
+    
+    def test_filling_two_euros_fires_cash_fills_200
+      sensor_collection.expects(:fire).with(:cash_fill_200).twice
+      register.fill(Coin.two_euro, 2, RIGHT_AWAY)
+    end
+    
+    def test_filling_one_euro_fires_cash_fills_100
+      sensor_collection.expects(:fire).with(:cash_fill_100).once
+      register.fill(Coin.one_euro, 1, RIGHT_AWAY)
+    end
+    
+    def test_filling_fifty_cents_fires_cash_fills_50
+      sensor_collection.expects(:fire).with(:cash_fill_50).twice
+      register.fill(Coin.fifty_cents, 2, RIGHT_AWAY)
+    end
+  end  
+
+  class CashRegisterConfigureTest < Test::Unit::TestCase
+    attr_reader :sensor_collection, :actuator_collection, :register
+    def setup
+      @sensor_collection = mock('sensor_collection')
+      @actuator_collection = mock('actuator_collection')
+      @register = CashRegister.new(nil, sensor_collection, actuator_collection)
+    end
+    
+    def test_configures_sensors_for_coins_insertions_and_actuators_for_coin_drops
+      sensor_collection.expects(:create_sensor_for).with(:cash_insert_200)
+      sensor_collection.expects(:create_sensor_for).with(:cash_insert_100)
+      sensor_collection.expects(:create_sensor_for).with(:cash_insert_50)
+      sensor_collection.expects(:create_sensor_for).with(:cash_fill_200)
+      sensor_collection.expects(:create_sensor_for).with(:cash_fill_100)
+      sensor_collection.expects(:create_sensor_for).with(:cash_fill_50)
+      actuator_collection.expects(:create_actuator_for).with(:cash_drop_200)
+      actuator_collection.expects(:create_actuator_for).with(:cash_drop_100)
+      actuator_collection.expects(:create_actuator_for).with(:cash_drop_50)
+      
+      register.configure()
+    end
+  end
+  
+
+  class MyCashRegister < CashRegister
+    def drop_coin(coin)
+      @coin = coin
+    end
+    def coin_dropped?(coin)
+      @coin == coin
+    end
+  end
+
+  class CashRegisterRespondingToActuatorsTest < Test::Unit::TestCase
+    attr_reader :sensor_collection, :actuator_collection, :register
+    def setup
+      @sensor_collection = mock('sensor_collection')
+      @actuator_collection = mock('actuator_collection')
+      @register = MyCashRegister.new(nil, sensor_collection, actuator_collection)
+      sensor_collection.stubs(:create_sensor_for)
+      actuator_collection.stubs(:create_actuator_for)
+    end
+    
+    def test_actuating_drop_200_drops_two_euro_coin_in_bin
+      actuator_collection.stubs(:create_actuator_for).with(:cash_drop_200).yields
+      
+      register.configure()
+      
+      assert register.coin_dropped?(Coin.two_euro), "two euro should be dropped"
+    end
+    
+    def test_actuating_drop_100_drops_one_euro_coin_in_bin
+      actuator_collection.stubs(:create_actuator_for).with(:cash_drop_100).yields
+      
+      register.configure()
+      
+      assert register.coin_dropped?(Coin.one_euro), "one euro should be dropped"
+    end
+    
+    def test_actuating_drop_50_drops_fifty_cents_coin_in_bin
+      actuator_collection.stubs(:create_actuator_for).with(:cash_drop_50).yields
+      
+      register.configure()
+      
+      assert register.coin_dropped?(Coin.fifty_cents), "fifty cents should be dropped"
+    end
+  end
+end

data/test/hardware/component_test.rb

@@ -0,0 +1,37 @@
+require File.join(File.dirname(__FILE__),'..','test_helper')
+require 'hardware'
+
+module Hardware
+  class MyComponent < Component
+    def changed # published protected method
+      super
+    end 
+  end
+  
+  class ComponentMonitorChangesTest < Test::Unit::TestCase
+    attr_reader :component, :changed_block_called
+    def setup
+      @component = MyComponent.new(nil,nil)
+      @changed_block_called = 'changed_block_not_called'
+      component.monitor_changes do
+        @changed_block_called = 'changed_block_called'
+      end
+    end
+
+    def test_changes_block_initially_not_called
+      assert_equal 'changed_block_not_called', changed_block_called
+    end
+    
+    def test_changes_block_initially_called_when_changed
+      component.changed
+      assert_equal 'changed_block_called', changed_block_called
+    end
+
+    def test_changed_ignored_when_block_not_registered
+      @component = MyComponent.new(nil,nil)
+      component.changed
+      assert_equal 'changed_block_not_called', changed_block_called
+    end
+
+  end
+end

data/test/hardware/display_test.rb

@@ -0,0 +1,94 @@
+require File.join(File.dirname(__FILE__),'..','test_helper')
+require 'mocha'
+require 'hardware'
+require 'hardware_adapter'
+
+module Hardware 
+  class DisplayTest < Test::Unit::TestCase
+    attr_reader :display
+    
+    def setup
+      @display = Display.new(Adapter::ActuatorCollection.null)
+    end
+    
+    def test_can_display_text_on_first_line
+      display.show(0, "line 1")      
+      assert_equal "line 1", display.line_one
+      assert_equal "", display.line_two
+    end
+    
+    def test_can_display_text_on_second_line
+      display.show(1, "line 2")      
+      assert_equal "", display.line_one
+      assert_equal "line 2", display.line_two
+    end
+    
+    def test_displaying_on_higher_line_is_ignored
+      display.show(3, "blah")      
+      assert_equal "", display.line_one
+      assert_equal "", display.line_two
+    end
+
+    def test_displaying_on_negative_line_is_ignored
+      display.show(-1, "blah")      
+      assert_equal "", display.line_one
+      assert_equal "", display.line_two
+    end
+
+    def test_displaying_with_string_as_index_is_ignored
+      display.show("0", "blah")      
+      assert_equal "", display.line_one
+      assert_equal "", display.line_two
+    end
+
+    def test_line_will_be_limited_to_16
+      display.show(0, "much longer than sixteen chars")      
+      assert_equal "much longer than", display.line_one 
+      display.show(1, "much longer than sixteen chars")      
+      assert_equal "much longer than", display.line_two 
+    end
+
+
+    def test_display_updates_ui_when_show_is_called
+      ui_contains = 'nothing'
+      display.monitor_changes do
+        ui_contains = [display.line_one, display.line_two].join('-')
+      end
+      display.show(1, 'blah')
+      assert_equal '-blah',  ui_contains
+    end
+    
+    def test_display_updates_ui_when_nothing_shown
+      ui_contains = 'nothing'
+      display.monitor_changes do
+        ui_contains = [display.line_one, display.line_two].join('-')
+      end
+      display.show(-1, 'blah') # error - nothing shown
+      assert_equal 'nothing', ui_contains
+    end
+  end
+  
+  class DisplayConfigureTest < Test::Unit::TestCase
+    attr_reader :display, :actuator_collection
+    
+    def setup
+      @actuator_collection = mock('actuator_collection')
+      @display = Display.new(actuator_collection)
+    end
+    
+    def test_configure_configures_actuator_for_display
+      actuator_collection.expects(:create_actuator_for).with(:display_show)
+      display.configure   
+    end
+    
+    def test_firing_actuator_will_call_show
+      actuator_collection.expects(:create_actuator_for).
+        with(:display_show).
+        yields(0, 'line one')
+      
+      display.configure  
+      assert_equal "line one", display.line_one
+      assert_equal "", display.line_two
+    end
+  end
+end

data/test/hardware/drawer_test.rb

@@ -0,0 +1,100 @@
+require File.expand_path File.join(File.dirname(__FILE__),'..','test_helper')
+require 'mocha'
+require 'hardware'
+
+module Hardware
+  RIGHT_AWAY = 0
+  class DrawerDroppingTest < Test::Unit::TestCase
+    attr_reader :drawer, :bin
+
+    def setup 
+      @bin = mock('bin')
+      @drawer = Drawer.new(bin)
+      @drawer.fill(Can.cola, 1, RIGHT_AWAY)
+    end
+    
+    def test_drops_item_to_bin
+      bin.expects(:receive).with(Can.cola)
+      drawer.drop(RIGHT_AWAY)
+      bin.expects(:receive).with(Can.fanta)
+      Drawer.new(bin).fill(Can.fanta, 1, RIGHT_AWAY).drop(RIGHT_AWAY)
+    end
+   
+    def test_dropping_reduces_the_stock
+      bin.stubs(:receive)
+      drawer.drop(RIGHT_AWAY)
+      assert_equal [], drawer.stock 
+    end
+
+    def test_dropping_more_than_you_have_has_no_effect
+      bin.expects(:receive).with(Can.cola).once
+      drawer.drop(RIGHT_AWAY)
+      drawer.drop(RIGHT_AWAY)
+    end
+    
+    def test_filling_adds_a_number_of_cans_in_stock
+      drawer.fill(Can.cola, 2, RIGHT_AWAY)
+      assert_equal([Can.cola, Can.cola, Can.cola], drawer.stock)
+    end
+  end
+  
+  class DrawerSensorTest < Test::Unit::TestCase
+    attr_reader :drawer, :bin, :sensor_collection
+
+    def setup 
+      @bin = stub('bin', :receive)
+      @sensor_collection = mock('sensor_collection')
+      @drawer = Drawer.new(bin, sensor_collection)
+    end
+    
+    def test_dropping_a_can_fires_a_sensor_event
+      @sensor_collection.stubs(:fire).with(:drawer_fill_can_0)
+      @drawer.fill(Can.cola, 1, RIGHT_AWAY)
+      @sensor_collection.expects(:fire).with(:drawer_drop_can_0)
+      @drawer.drop(RIGHT_AWAY)
+    end
+    
+    def test_filling_fires_fill_can_event_for_each_can
+      @sensor_collection.expects(:fire).with(:drawer_fill_can_0).times(3)
+      @drawer.fill(Can.cola, 3, RIGHT_AWAY)
+    end
+  
+  end
+
+  class ConfiguringDrawerTest < Test::Unit::TestCase
+    attr_reader :drawer, :bin, :sensor_collection, :actuator_collection
+    
+    def setup
+      @sensor_collection = mock('sensor_collection')
+      @actuator_collection = mock('mock_collection')
+      @bin = mock('bin')
+      
+      @drawer = Drawer.new(bin, sensor_collection, actuator_collection, 1)
+    end
+    
+    def test_configure_sensors_configures_drop_and_fill_can
+      sensor_collection.expects(:create_sensor_for).with(:drawer_drop_can_1)
+      sensor_collection.expects(:create_sensor_for).with(:drawer_fill_can_1)
+      actuator_collection.expects(:create_actuator_for).with(:drawer_drop_can_1)
+
+      drawer.configure
+    end
+    
+    def test_fired_actuator_drops_can
+      sensor_collection.stubs(:create_sensor_for)
+      # YIELD is what happens when the actuator is fired
+      actuator_collection.expects(:create_actuator_for).with(:drawer_drop_can_1).yields
+
+      def drawer.drop
+        @drop_called = true
+      end
+      def drawer.drop_called
+        @drop_called
+      end
+
+      drawer.configure
+      
+      assert drawer.drop_called, "drop should be called as result of yield of actuator"
+    end
+  end
+end

data/test/hardware/enum_test.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), '..','test_helper')
+require 'hardware/enum'
+module Hardware
+  class EnumTest < Test::Unit::TestCase
+    class MyEnum < Enum
+      values :first, :second
+    end
+    
+    def test_enum_value_is_accessible_with_class_method
+      assert_nothing_raised do 
+        MyEnum.first
+      end
+    end
+    
+    def test_non_existing_value_raises_exception
+      assert_raises RuntimeError do 
+        MyEnum.blah
+      end
+    end
+    
+    def test_enum_values_are_exactly_same
+        assert_same MyEnum.first, MyEnum.first
+    end
+    
+    def test_different_enum_values_are_exactly_same
+        assert_not_same MyEnum.second, MyEnum.first
+    end
+    
+    def test_inspecting_a_value_returns_a_readable_string
+        assert_equal 'Hardware::EnumTest::MyEnum.first', MyEnum.first.inspect
+    end
+  end
+end

data/test/hardware/simulator_test.rb

@@ -0,0 +1,189 @@
+require File.join(File.dirname(__FILE__),'..','test_helper')
+require 'mocha'
+require 'hardware'
+
+module Hardware 
+  class SimulatorAssembleABinTest < Test::Unit::TestCase
+    def test_attaches_a_sensor_to_receiving_an_item
+      sensors = Adapter::SensorCollection.new
+      simulator = Simulator.new
+      bin = Bin.new(sensors)
+      simulator.assemble_hardware_component(:bin, bin)
+      sensor_called = false
+      sensors.on(:bin_entry) do
+        sensor_called = true
+      end 
+      bin.receive("some_object")
+      assert sensor_called, "bin_entry sensor should be fired"
+    end
+  end
+  
+  class SimulatorAssembleHardwareComponents < Test::Unit::TestCase
+    attr_reader :sensors, :simulator, :component
+    def setup
+      @sensors = Adapter::SensorCollection.new
+      @simulator = Simulator.new
+      @component = mock("hardware_component")
+    end
+      
+    def test_configuring_a_hardware_component_configures_the_component
+      component.expects(:configure).with().once
+      simulator.assemble_hardware_component(:bin, component)
+    end
+
+    def test_configuring_a_list_of_similar_hardware_components_configures_them_all
+      component.expects(:configure).with().twice
+      simulator.assemble_hardware_components(:drawer, [component, component])
+    end
+
+    def test_configured_hardware_component_is_available_by_name
+      bin = stub('bin', :configure)
+      simulator.assemble_hardware_component(:bin, bin)
+      assert_same bin, simulator.component(:bin)
+    end
+
+    def test_configured_hardware_components_are_available_by_name
+      drawer0 = stub('drawer0', :configure)
+      drawer1 = stub('drawer1', :configure)
+
+      simulator.assemble_hardware_components(:drawer, [drawer0, drawer1])
+      
+      assert_same drawer0, simulator.component(:drawer_0)
+      assert_same drawer1, simulator.component(:drawer_1)
+    end
+
+    def test_monitor_changes_delegates_to_the_appropriate_hardware_component
+      component.stubs(:configure)
+      simulator.assemble_hardware_component(:my_comp, component)
+
+      component.expects(:monitor_changes).yields()
+      block_given = 'block not given'
+      simulator.monitor_changes(:my_comp) do
+        block_given = 'block_given'
+      end
+      
+      assert_equal 'block_given', block_given
+    end
+  end
+
+  class SimulatorAssembleHardware < Test::Unit::TestCase 
+    attr_reader :actuators, :sensors, :simulator
+    def setup
+      @actuators = Adapter::ActuatorCollection.new
+      @sensors = Adapter::SensorCollection.new
+      @simulator = Simulator.new(actuators, sensors) 
+    end
+
+    def test_assembles_one_bin 
+      simulator.assemble_hardware
+      assert_equal(Bin, simulator.bin.class)
+      assert sensors.list.include?(:bin_entry)
+      assert sensors.list.include?(:bin_fetch_all)
+    end
+
+    def test_assembles_one_display 
+      simulator.assemble_hardware
+      assert_equal(Display, simulator.display.class)
+      assert actuators.list.include?(:display_show)
+    end
+
+    def test_assembles_4_drawers
+      simulator.assemble_hardware
+      assert_equal(Drawer, simulator.drawer(0).class)
+      assert_equal(Drawer, simulator.drawer(1).class)
+      assert_equal(Drawer, simulator.drawer(2).class)
+      assert_equal(Drawer, simulator.drawer(3).class)
+      assert actuators.list.include?(:drawer_drop_can_0)
+      assert actuators.list.include?(:drawer_drop_can_1)
+      assert actuators.list.include?(:drawer_drop_can_2)
+      assert actuators.list.include?(:drawer_drop_can_3)
+      assert sensors.list.include?(:drawer_drop_can_0)
+      assert sensors.list.include?(:drawer_drop_can_1)
+      assert sensors.list.include?(:drawer_drop_can_2)
+      assert sensors.list.include?(:drawer_drop_can_3)
+      assert sensors.list.include?(:drawer_fill_can_0)
+      assert sensors.list.include?(:drawer_fill_can_1)
+      assert sensors.list.include?(:drawer_fill_can_2)
+      assert sensors.list.include?(:drawer_fill_can_3)
+    end
+    def test_assembles_4_buttons
+      simulator.assemble_hardware
+      assert_equal(Button, simulator.button(0).class)
+      assert_equal(Button, simulator.button(1).class)
+      assert_equal(Button, simulator.button(2).class)
+      assert_equal(Button, simulator.button(3).class)
+      assert sensors.list.include?(:button_press_0)
+      assert sensors.list.include?(:button_press_1)
+      assert sensors.list.include?(:button_press_2)
+      assert sensors.list.include?(:button_press_3)
+    end
+
+    def test_assembles_cash_register
+      simulator.assemble_hardware
+      assert_equal(CashRegister, simulator.component(:cash_register).class)
+      assert actuators.list.include?(:cash_drop_100)
+      assert actuators.list.include?(:cash_drop_200)
+      assert actuators.list.include?(:cash_drop_50)
+      assert sensors.list.include?(:cash_fill_100)
+      assert sensors.list.include?(:cash_fill_200)
+      assert sensors.list.include?(:cash_fill_50)
+      assert sensors.list.include?(:cash_insert_100)
+      assert sensors.list.include?(:cash_insert_200)
+      assert sensors.list.include?(:cash_insert_50)
+    end
+  end
+
+  class SimulatorReset < Test::Unit::TestCase
+    attr_reader :actuators, :sensors, :simulator
+    def setup
+      @actuators = Adapter::ActuatorCollection.new
+      @sensors = Adapter::SensorCollection.new
+      @simulator = Simulator.new(actuators, sensors) 
+      simulator.assemble_hardware
+    end
+
+    def test_empties_drawers
+      simulator.drawer(0).fill(Hardware::Can.cola, 2, 0)
+      simulator.reset
+      assert simulator.drawer(0).empty?
+    end
+
+    def test_empties_cash_register
+      simulator.cash_register.fill(Hardware::Coin.one_euro, 2, 0)
+      simulator.reset
+      assert simulator.cash_register.empty?
+    end
+
+    def test_removes_sensor_listeners
+      bin_entry_called = "was not called"
+      sensors.on(:bin_entry) { bin_entry_called = "was called" }
+      simulator.reset
+      sensors.fire(:bin_entry) 
+
+      assert_equal "was not called",  bin_entry_called
+    end
+
+    def test_fires_start_boot_block
+      boot_block = "was not called"
+      simulator.on_boot { boot_block = "was called" }
+      simulator.reset
+      assert_equal "was called", boot_block
+    end
+  end
+
+  class SimulatorBoot < Test::Unit::TestCase
+    attr_reader :simulator
+    def setup
+      @simulator = Simulator.new(Adapter::ActuatorCollection.null, Adapter::SensorCollection.null)
+      simulator.assemble_hardware
+    end
+
+    def test_fires_start_boot_block
+      boot_block = "was not called"
+      simulator.on_boot { boot_block = "was called" }
+      simulator.boot
+      assert_equal "was called", boot_block
+    end
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+require 'test/unit'
+require 'rubygems'
+module Hardware
+end
+$: << 'lib'