vmsim 0.2.4 → 1.0.0

data/test/adapter/actuator_collection_test.rb

@@ -1,106 +0,0 @@
-require File.join(File.dirname(__FILE__),'..','test_helper')
-require 'hardware_adapter'
-
-module Adapter
-  class ActuatorCollectionTest < Test::Unit::TestCase
-    attr_reader :actuator_collection, :actuator_called, :other_actuator_called
-    def setup
-      @actuator_collection = ActuatorCollection.new(SynchronousFirer)
-      @actuator_called = false
-      @other_actuator_called = false
-      actuator_collection.create_actuator_for('some_actuator') do
-        @actuator_called = true
-      end
-      actuator_collection.create_actuator_for(:some_other_actuator) do
-        @other_actuator_called = true
-      end
-    end
-    
-    def test_list_lists_actuators 
-      assert_equal [:some_actuator, :some_other_actuator], actuator_collection.list
-    end
-    
-    def test_actuators_not_called_if_not_fired
-      assert_equal false, actuator_called, "this actuator should not be called yet"
-      assert_equal false, other_actuator_called, "this actuator should not be called yet"
-    end
-    
-    def test_calls_block_given_for_any_actuator
-      actuator_collection.fire(:some_actuator)
-      actuator_collection.fire(:some_other_actuator)
-      
-      assert actuator_called, "actuator should be called on fire"
-      assert other_actuator_called, "actuator should be called on fire"
-    end
-    
-    def test_actuator_block_can_accept_parameters
-      int_val = -1
-      string_val = ""
-      actuator_collection.create_actuator_for(:parametarized_actuator) do |param1, param2|
-        int_val = param1
-        string_val = param2
-      end
-      actuator_collection.fire(:parametarized_actuator, 34, "gijs")
-      
-      assert_equal 34, int_val
-      assert_equal "gijs", string_val
-    end
-
-    def test_actuator_block_may_skip_parameters
-      int_val = -1
-      string_val = ""
-      actuator_collection.create_actuator_for(:parametarized_actuator) do |param1, param2|
-        int_val = param1
-        string_val = param2
-      end
-      actuator_collection.fire(:parametarized_actuator, 34, "gijs", "truus")
-      
-      assert_equal 34, int_val
-      assert_equal "gijs", string_val
-    end
-    
-    def test_raises_exception_on_firing_unknown_actuator
-      assert_raises NoSuchActuatorException do
-        actuator_collection.fire(:unknown_actuator)
-      end
-    end
-    
-    def test_raises_exception_on_no_block_given
-      assert_raises NoActuatorBlockGiven do
-        actuator_collection.create_actuator_for(:actuator_no_block)
-      end
-    end
-    
-    def test_raises_exception_on_duplicate_actuator
-      assert_raises DuplicateActuatorException do
-        actuator_collection.create_actuator_for(:some_actuator) {}
-      end
-    end
-  end
-  
-  class AsynchronousFirerTest < Test::Unit::TestCase
-    def test_fires_on_other_thread
-      fired = false
-      firer = AsynchronousFirer.new do
-        sleep(0.1)
-        fired = true 
-      end
-      t = firer.fire
-      assert_equal false, fired, "should not be fired"
-      t.join
-      assert fired, "should be fired"
-    end
-    
-    def test_fires_on_other_thread_with_parameters
-      fired = ''
-      firer = AsynchronousFirer.new do |value|
-        sleep(0.1)
-        fired = value
-      end
-      t = firer.fire('passed string value')
-      assert_equal '', fired, "should not be fired"
-      t.join
-      assert_equal 'passed string value', fired, "should be fired"
-    end
-  end
-end

data/test/adapter/sensor_collection_test.rb

@@ -1,51 +0,0 @@
-require File.join(File.dirname(__FILE__),'..','test_helper')
-require 'hardware_adapter'
-
-module Adapter
-
-  class SensorCollectionFireTest  < Test::Unit::TestCase
-    attr_reader :sensors
-    def setup
-      @sensors = SensorCollection.new
-      sensors.create_sensor_for(:bin_entry)
-    end
-    
-    def test_list_lists_sensor
-      sensors.create_sensor_for(:something_entry)
-      assert_equal [:bin_entry, :something_entry], sensors.list
-    end
-    
-    def test_calls_block_given_for_a_sensor
-      bin_entry_fired = false
-      sensors.on(:bin_entry) do
-        bin_entry_fired = true
-      end
-      sensors.fire(:bin_entry)
-      assert bin_entry_fired, "bin_entry should be fired"
-    end
-    
-    def test_swallows_fire_silently_when_no_handler_defined
-      sensors.fire(:bin_entry) 
-    end
-    
-  end
-  
-  class SensorCollectionFireWithoutReceptorsCreatedTest  < Test::Unit::TestCase
-    attr_reader :sensors
-    def setup
-      @sensors = SensorCollection.new
-    end
-    
-    def test_swallows_fire_silently_when_no_handler_defined
-      sensors.fire(:bin_entry) 
-    end
-    
-    def test_on_raises_a_no_such_sensor_exception
-      assert_raises NoSuchSensorException do 
-        sensors.on(:bin_entry) {}
-      end
-    end
-    
-  end
-
-end

data/test/deploy/deployer_test.rb

@@ -1,114 +0,0 @@
-require File.join(File.dirname(__FILE__),'..','test_helper')
-require 'deploy'
-require 'tmpdir'
-require 'archive_builder'
-
-module Deploy
-  module DeployerTestHelper 
-    attr_reader :deployer
-    def create_deployer
-      @deployer =  Deployer.new(File.expand_path(File.join(File.dirname(__FILE__), 'was_run.sh')))
-    end
-    def deploy(archive) 
-      create_deployer
-      deployer.deploy archive
-    end
-    def is_running(pid)
-      begin
-        Process.kill(0, pid)
-        return true
-      rescue 
-        return false
-      end
-    end
-  end
-
-  class DeployerDeployTest < Test::Unit::TestCase
-    include ArchiveBuilder
-    include DeployerTestHelper
-    include FileUtils
-    def teardown
-      rm_r './tmp' if File.exists?('./tmp')
-    end
-
-    def test_unzips_the_archive_and_fires_the_executable
-      deploy an_archive('controlcode.pkg') {
-        a_file("main.rb").with("puts 'was unpacked'")
-      }
-      assert is_running(deployer.current_pid)
-      assert_match /was started.*was unpacked/m, deployer.wait_for.run_log
-    end
-
-    def test_unzips_the_archive_with_relative_path_and_fires_the_executable
-      deploy an_archive('controlcode.pkg', 'tmp') {
-        a_file("main.rb").with("puts 'was unpacked'")
-      }
-      assert is_running(deployer.current_pid)
-      assert_match /was started.*was unpacked/m, deployer.wait_for.run_log
-    end
-
-    def test_clears_current_pid_on_exit
-      deploy an_archive('controlcode.pkg') {
-        a_file("main.rb").with("puts 'was unpacked'")
-      }
-      assert_nil deployer.wait_for.current_pid
-      assert !File.exists?(Deployer::PIDFILE), "PIDFILE should be gone"
-    end
-
-    def test_removes_previous_files
-      deploy an_archive('controlcode.pkg') {  
-        a_file("loaded_class.rb").with("class LoadedClass; end")
-        a_file("main.rb").with("require 'loaded_class'")
-      }
-      
-      deploy an_archive('controlcode.pkg') {  
-        a_file("main.rb").with("puts 'was unpacked'")
-      }
-
-      assert !File.exists?(File.join(Deployer::DEPLOYED_DIR, 'loaded_class.rb')), "loaded class should be removed"
-    end
-
-    def test_removes_previous_directories
-      deploy an_archive('controlcode.pkg') {  
-        a_file("lib/loaded_class.rb").with("class LoadedClass; end")
-        a_file("main.rb").with("require 'lib/loaded_class'")
-      }
-      
-      deploy an_archive('controlcode.pkg') {  
-        a_file("main.rb").with("puts 'was unpacked'")
-      }
-
-      assert !File.exists?(File.join(Deployer::DEPLOYED_DIR, 'loaded_class.rb')), "loaded class should be removed"
-    end
-
-    def test_kills_the_current_running_process_and_starts_new_one
-      deploy an_archive('controlcode.pkg') { 
-        a_file("main.rb").with("sleep 1")
-      }
-      old_process_id = deployer.current_pid
-
-      deploy an_archive('controlcode.pkg') { 
-        a_file("main.rb").with("puts 'was unpacked'")
-      }
-
-      assert !is_running(old_process_id), "process should be stopped before starting new"
-    end
-
-  end
-
-  class DeployerKillTest < Test::Unit::TestCase
-    include ArchiveBuilder
-    include DeployerTestHelper
-
-    def test_kills_the_current_running_process
-      deploy an_archive('controlcode.pkg') { 
-        a_file("main.rb").with("sleep 20")
-      }
-      process_id = deployer.current_pid
-      create_deployer
-      deployer.kill
-      assert !is_running(process_id), "process should be stopped"
-    end
-  end
-end
-

data/test/deploy/was_run.sh

@@ -1,5 +0,0 @@
-#!/usr/bin/env ruby
-$: << File.expand_path('~/.vendingmachine/control')
-puts "was started"
-
-require 'main'

data/test/devices/devices_test.rb

@@ -1,78 +0,0 @@
-require File.join(File.dirname(__FILE__),'..','test_helper')
-require 'mocha'
-require 'devices'
-
-module Devices
-  class DevicesTest < Test::Unit::TestCase
-    attr_reader :actuators, :sensors, :devices, :handler
-    def setup
-      @actuators = mock('actuatorcollection')
-      @sensors = mock('sensorcollection')
-      @devices = Devices.new(actuators, sensors)
-      @handler = 'not called'
-    end
-
-    def test_display_show
-      actuators.expects(:fire).with(:display_show, 1, "test message")
-      devices.display_show(1, "test message")
-    end
-
-    def test_button_on_press
-      sensors.expects(:on).with(:button_press_1).yields
-      devices.on_button_pressed(1) { handler_called }
-      assert_equal 'called', handler
-    end
-
-    def test_bin_entry
-      sensors.expects(:on).with(:bin_entry).yields
-      devices.on_bin_entry { handler_called }
-      assert_equal 'called', handler
-    end
-
-    def test_bin_fetch_all
-      sensors.expects(:on).with(:bin_fetch_all).yields
-      devices.on_bin_fetch_all { handler_called }
-      assert_equal 'called', handler
-    end
-
-    def test_cash_register_fill_money
-      sensors.expects(:on).with(:cash_fill_100).yields
-      devices.on_cash_filled(100) { handler_called }
-      assert_equal 'called', handler
-    end
-
-    def test_cash_register_insert_money
-      sensors.expects(:on).with(:cash_insert_100).yields
-      devices.on_cash_inserted(100) { handler_called }
-      assert_equal 'called', handler
-    end
-
-    def test_cash_drop_drops_coin
-      actuators.expects(:fire).with(:cash_drop_100)
-      devices.cash_drop_coin(100)
-    end
-
-    def test_drawer_register_can_dropped
-      sensors.expects(:on).with(:drawer_drop_can_0).yields
-      devices.on_drawer_dropped(0) { handler_called }
-      assert_equal 'called', handler
-    end
-
-    def test_drawer_register_can_filled
-      sensors.expects(:on).with(:drawer_fill_can_0).yields
-      devices.on_drawer_filled(0) { handler_called }
-      assert_equal 'called', handler
-    end
-
-    def test_drawer_drop_drops_can
-      actuators.expects(:fire).with(:drawer_drop_can_1)
-      devices.drawer_drop_can(1)
-    end
-
-    private 
-
-    def handler_called
-      @handler = 'called'
-    end
-  end
-end

data/test/hardware/bin_test.rb

@@ -1,57 +0,0 @@
-require File.join(File.dirname(__FILE__),'..','test_helper')
-require 'mocha'
-require 'hardware'
-require 'hardware_adapter'
-
-module Hardware
-  class BinTest < Test::Unit::TestCase
-    attr_reader :bin, :sensor_collection
-    def setup
-      @sensor_collection = mock('sensor_collection')
-      @bin = Bin.new(sensor_collection)
-    end
-    
-    def test_receive_fills_the_bin_with_the_item
-      sensor_collection.expects(:fire).with(:bin_entry)
-      bin.receive('some_object')
-      assert_equal(['some_object'], bin.contents)
-    end
-    
-    def test_fetch_the_stuff_empties_the_bin
-      sensor_collection.stubs(:fire).with(:bin_entry) # firing :bin_entry tested above
-      bin.receive('some_object')
-      bin.receive('some_object')
-      
-      sensor_collection.expects(:fire).with(:bin_fetch_all)
-      bin.fetch_all
-      
-      assert_equal([], bin.contents)
-    end
-    
-    def test_configure_configures_the_sensor_in_the_sensor_collection
-      sensor_collection.expects(:create_sensor_for).with(:bin_entry)
-      sensor_collection.expects(:create_sensor_for).with(:bin_fetch_all)
-      bin.configure 
-    end
-    
-    def test_updates_ui_when_receiving_something
-      bin = Bin.new(Adapter::SensorCollection.null)
-      change_called = false
-      bin.monitor_changes do
-        change_called = true
-      end
-      bin.receive('some_object')
-      assert change_called, 'change was not called'
-    end
-    
-    def test_updates_ui_when_fetching_all
-      bin = Bin.new(Adapter::SensorCollection.null)
-      change_called = false
-      bin.monitor_changes do
-        change_called = true
-      end
-      bin.fetch_all
-      assert change_called, 'change was not called'
-    end
-  end
-end

data/test/hardware/button_test.rb

@@ -1,23 +0,0 @@
-require File.join(File.dirname(__FILE__),'..','test_helper')
-require 'mocha'
-require 'hardware'
-
-module Hardware
-  class ButtonTest < Test::Unit::TestCase
-    attr_reader :sensor_collection, :button
-    def setup
-      @sensor_collection = mock('sensor_collection')
-      @button = Button.new(sensor_collection, 1)
-    end
-    
-    def test_press_fires_sensor
-      sensor_collection.expects(:fire).with(:button_press_1)
-      button.press
-    end
-    
-    def test_configure_configures_sensor_for_button_press
-      sensor_collection.expects(:create_sensor_for).with(:button_press_1)
-      button.configure
-    end
-  end
-end

data/test/hardware/can_test.rb

@@ -1,11 +0,0 @@
-require File.join(File.dirname(__FILE__),'..','test_helper')
-require 'hardware'
-
-module Hardware
-  class CanTest < Test::Unit::TestCase
-    def test_to_s_shows_can_name
-      assert_equal 'can of cola', Can.cola.to_s
-      assert_equal 'can of fanta', Can.fanta.to_s
-    end
-  end
-end 

data/test/hardware/cash_register_test.rb

@@ -1,157 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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