denko 0.13.0

data/test/behaviors/input_pin_test.rb

@@ -0,0 +1,42 @@
+require_relative '../test_helper'
+
+class InputComponent
+  include Denko::Behaviors::InputPin
+end
+
+class InputPinTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= InputComponent.new(board: board, pin: 1)
+  end
+
+  def test_mode_and_pullup
+    mock = Minitest::Mock.new
+    mock.expect :call, nil, [1, :input]
+    mock.expect :call, nil, [2, :input_pulldown]
+    mock.expect :call, nil, [3, :input_pullup]
+    mock.expect :call, nil, [4, :input_output]
+    
+    board.stub(:set_pin_mode, mock) do
+      part
+      InputComponent.new(board: board, pin: 2, pulldown: true)
+      InputComponent.new(board: board, pin: 3, pullup: true)
+      InputComponent.new(board: board, pin: 4, mode: :input_output)
+    end
+    mock.verify
+    
+    assert_equal :input, part.mode
+  end
+
+  def test_stop_listener
+    mock = Minitest::Mock.new
+    mock.expect :call, nil, [1]
+    board.stub(:stop_listener, mock) do
+      part._stop_listener
+    end
+    mock.verify
+  end
+end

data/test/behaviors/listener_test.rb

@@ -0,0 +1,60 @@
+require_relative '../test_helper'
+
+class ListenerComponent
+  include Denko::Behaviors::Component
+  include Denko::Behaviors::Listener
+
+  def _listen(divider=nil); end
+  def _stop_listener; end
+end
+
+class ListenerTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= ListenerComponent.new(board: board, pin: 1)
+  end
+
+  def test_include_callbacks
+    assert_includes ListenerComponent.ancestors,
+                    Denko::Behaviors::Callbacks
+  end
+  
+  def test_divider_save_and_read
+    part.listen(4)
+    assert_equal part.divider, 4
+  end
+
+  def test_call_stop_before_listening
+    mock = MiniTest::Mock.new.expect :call, nil
+    part.stub(:stop, mock) { part.listen }
+    mock.verify
+  end
+
+  def test_call__listen
+    mock = MiniTest::Mock.new
+    mock.expect :call, nil, [nil]
+    mock.expect :call, nil, [32]
+    part.stub(:_listen, mock) do
+      part.listen
+      part.listen(32)
+    end
+    mock.verify
+  end
+
+  def test_call__stop_listener
+    mock = MiniTest::Mock.new.expect :call, nil
+    part.stub(:_stop_listener, mock) { part.stop }
+    mock.verify
+  end
+
+  def test_add_and_remove_callback
+    callback = Proc.new{}
+    part.listen(&callback)
+    assert_equal [callback], part.callbacks[:listen]
+    part.stop
+    assert_nil part.callbacks[:listen]
+  end
+end

data/test/behaviors/multi_pin_test.rb

@@ -0,0 +1,70 @@
+require_relative '../test_helper'
+
+class MultiPinComponent
+  include Denko::Behaviors::MultiPin
+  
+  def initialize_pins(options={})
+    require_pin :one
+    proxy_pin   :two,   Denko::DigitalIO::Output
+    proxy_pin   :maybe, Denko::DigitalIO::Input, optional: true
+  end
+end
+
+class MultiPinTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= MultiPinComponent.new board: board,
+                                    pins: { one: 9, two: 10, maybe: 11 }
+  end
+
+  def test_validate_pins
+    assert_raises(ArgumentError) do
+      MultiPinComponent.new board: board, pins: { one: 9, maybe: 11 }
+    end
+    assert_raises(ArgumentError) do
+      MultiPinComponent.new board: board, pins: { two: 10, maybe: 11 }
+    end
+    MultiPinComponent.new board: board, pins: { one: 9, two:10 }
+  end
+  
+  def test_has_nil_pin
+    assert_nil part.pin
+  end
+
+  def test_build_proxies
+    assert_equal Denko::DigitalIO::Output, part.proxies[:two].class
+    assert_equal Denko::DigitalIO::Input, part.proxies[:maybe].class
+  end
+  
+  def attr_reader_exists_for_optional_pins
+    part = MultiPinComponent.new board: board, pins: { one: 9, two:10 }
+    assert_nil part.maybe
+  end
+
+  def test_proxy_reader_methods
+    assert_equal part.proxies[:two], part.two
+    assert_equal part.proxies[:maybe], part.maybe
+  end
+
+  def test_pins_mapped_correctly
+    assert_equal 10, part.two.pin
+    assert_equal 11, part.maybe.pin
+  end
+
+  def test_proxy_states
+    part.two.high
+    assert_equal({two: board.high, maybe: nil}, part.proxy_states)
+
+    part2 = MultiPinComponent.new board: board, pins: { one: 'A1', two:12 }
+    part2.two.low
+    assert_equal({two: board.low}, part2.proxy_states)
+  end
+
+  def test_required_but_not_proxied_pin_conversion
+    part = MultiPinComponent.new board: board, pins: { one: 'A0', two:10 }
+    assert_equal 14, part.pins[:one]
+  end
+end

data/test/behaviors/output_pin_test.rb

@@ -0,0 +1,27 @@
+require_relative '../test_helper'
+
+class OutputComponent
+  include Denko::Behaviors::OutputPin
+end
+
+class OutputPinTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= OutputComponent.new(board: board, pin: 1)
+  end
+
+  def test_set_mode
+    mock = Minitest::Mock.new
+    mock.expect :call, nil, [1, :output]
+    
+    board.stub(:set_pin_mode, mock) do
+      part
+    end
+    mock.verify
+    
+    assert_equal :output, part.mode
+  end
+end

data/test/behaviors/poller_test.rb

@@ -0,0 +1,64 @@
+require_relative '../test_helper'
+
+class PollerComponent
+  include Denko::Behaviors::Component
+  include Denko::Behaviors::Poller
+  def _read; end
+end
+
+class PollerTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= PollerComponent.new(board: board, pin: 1)
+  end
+
+  def inject(data, wait_for_callbacks = true)
+    Thread.new do
+      if wait_for_callbacks
+        while (!part.callbacks[:read]) do; sleep 0.01; end
+      end
+      loop do
+        sleep 0.01
+        part.update(data)
+        break unless part.callbacks[:read]
+      end
+    end
+  end
+
+  def test_include_callbacks_and_threaded
+    assert_includes PollerComponent.ancestors,
+                    Denko::Behaviors::Callbacks
+
+    assert_includes PollerComponent.ancestors,
+                    Denko::Behaviors::Threaded
+  end
+
+  def test_call_stop_before_polling
+    mock = MiniTest::Mock.new.expect :call, nil
+    part.stub(:stop, mock) { part.poll(1) }
+    mock.verify
+  end
+
+  def test_uses_threaded_loop
+    mock = MiniTest::Mock.new.expect :call, nil
+    part.stub(:threaded_loop, mock) { part.poll(1) }
+    mock.verify
+  end
+
+  def test_add_and_remove_callback
+    callback = Proc.new{}
+    part.poll(1, &callback)
+    assert_equal part.callbacks[:poll], [callback]
+    part.stop
+    assert_nil part.callbacks[:poll]
+  end
+
+  def test_stop_kills_thread
+    mock = MiniTest::Mock.new.expect :call, nil
+    part.stub(:stop_thread, mock) { part.stop }
+    mock.verify
+  end
+end

data/test/behaviors/reader_test.rb

@@ -0,0 +1,68 @@
+require_relative '../test_helper'
+
+class ReaderComponent
+  include Denko::Behaviors::Component
+  include Denko::Behaviors::Reader
+  def _read; end
+end
+
+class ReaderTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= ReaderComponent.new(board: board, pin: 1)
+  end
+
+  def inject(data, wait_for_callbacks = true)
+    Thread.new do
+      if wait_for_callbacks
+        while (!part.callbacks[:read]) do; sleep 0.01; end
+      end
+      loop do
+        sleep 0.01
+        part.update(data)
+        break unless part.callbacks[:read]
+      end
+    end
+
+    # Give the thread some to get into its loop.
+    sleep 0.05
+  end
+
+  def test_include_callbacks
+    assert_includes ReaderComponent.ancestors,
+                    Denko::Behaviors::Callbacks
+  end
+
+  def test_read_once
+    mock = MiniTest::Mock.new.expect :call, nil
+    inject(1)
+    
+    part.stub(:_read, mock) do
+      part.read
+    end
+    mock.verify
+  end
+
+  def test_return_value
+    inject(42)
+    assert_equal part.read, 42
+  end
+  
+  def test_read_using
+    inject(1)
+    reader = MiniTest::Mock.new.expect :call, nil
+    part.read_using -> { reader.call }
+    reader.verify
+  end
+
+  def test_add_run_remove_callback
+    cb = MiniTest::Mock.new.expect :call, nil
+    inject(1)
+    part.read { cb.call }
+    assert_nil part.callbacks[:read]
+    cb.verify
+  end
+end

data/test/behaviors/single_pin_test.rb

@@ -0,0 +1,41 @@
+require_relative '../test_helper'
+
+class SinglePinComponent
+  include Denko::Behaviors::SinglePin
+end
+
+class SinglePinTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= SinglePinComponent.new(board: board, pin: 1)
+  end
+
+  def test_requires_pin
+    assert_raises(ArgumentError) { SinglePinComponent.new(board: board) }
+  end
+  
+  def test_mode=
+    mock = Minitest::Mock.new
+    mock.expect :call, nil, [1, :some_mode] 
+
+    board.stub(:set_pin_mode, mock) do
+      part.mode = :some_mode
+    end
+    mock.verify
+    
+    assert_equal :some_mode, part.mode
+  end
+
+  def test_converts_pin_before_saving
+    c1 = SinglePinComponent.new(board: board, pin: :DAC0)
+    c2 = SinglePinComponent.new(board: board, pin: :A1)
+    c3 = SinglePinComponent.new(board: board, pin: :SDA)
+
+    assert_equal 14, c1.pin
+    assert_equal 15, c2.pin
+    assert_equal 20, c3.pin
+  end
+end

data/test/behaviors/subcomponents_test.rb

@@ -0,0 +1,75 @@
+require_relative '../test_helper'
+
+class PinlessComponentMock
+  def stop
+  end
+end
+
+class SinglePinComponentMock
+  def pin
+    1
+  end
+end
+
+class MultiPinComponentMock
+  def pin
+    {a: 1, b: 2}
+  end
+end 
+
+class SubcomponentsTest < Minitest::Test
+  def connection
+    @connection ||= ConnectionMock.new
+  end
+
+  def board
+    @board ||= Denko::Board.new(connection)
+  end
+
+  def test_add_remove_pinless
+    pinless = PinlessComponentMock.new
+
+    board.add_component(pinless)
+    assert_equal [pinless], board.components
+    assert_empty board.single_pin_components
+
+    board.remove_component(pinless)
+    assert_empty board.components
+  end
+
+  def test_add_remove_single_pin
+    single_pin = SinglePinComponentMock.new
+
+    board.add_component(single_pin)
+    test_hash = {1 => single_pin}
+    assert_equal [single_pin], board.components
+    assert_equal test_hash,    board.single_pin_components
+
+    board.remove_component(single_pin)
+    assert_empty board.components
+    refute board.single_pin_components[1]
+  end
+
+  def test_add_remove_multi_pin
+    multi_pin = MultiPinComponentMock.new
+
+    board.add_component(multi_pin)
+    assert_equal [multi_pin], board.components
+    assert_empty board.single_pin_components
+
+    board.remove_component(multi_pin)
+    assert_empty board.components
+  end
+  
+  def test_calls_stop_on_remove
+    pinless = PinlessComponentMock.new
+    board.add_component(pinless)
+
+    mock = MiniTest::Mock.new.expect(:call, nil)
+    pinless.stub(:stop, mock) do
+      board.remove_component(pinless)
+    end
+
+    mock.verify
+  end
+end

data/test/behaviors/threaded_test.rb

@@ -0,0 +1,98 @@
+require_relative '../test_helper'
+
+class ThreadedComponent
+  include Denko::Behaviors::Component
+  include Denko::Behaviors::Threaded
+  def foo(str="test")
+    @bar = str
+  end
+  attr_reader :bar
+  interrupt_with :foo
+end
+
+class ThreadedTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= ThreadedComponent.new(board: board, pin: 1)
+  end
+
+  def test_add_interrupts_using_interrupt_with
+    assert_equal ThreadedComponent.class_variable_get(:@@interrupts), [:foo]
+  end
+
+  def test_threaded_stops_threads
+    mock = MiniTest::Mock.new.expect :call, nil
+    part.stub(:stop_thread, mock) { part.threaded {} }
+    mock.verify
+  end
+
+  def test_threaded_enables_interrupts
+    mock = MiniTest::Mock.new.expect :call, nil
+    part.stub(:enable_interrupts, mock) { part.threaded {} }
+    mock.verify
+  end
+
+  def test_threaded_calls_block_given
+    mock = MiniTest::Mock.new.expect :call, nil
+    part.threaded { mock.call }
+    sleep 0.1 # Should find a better way to do this.
+    mock.verify
+  end
+
+  def test_thread_stored_in_instance_variable
+    thread = Thread.current
+    part.threaded {}
+    refute_equal(thread, part.instance_variable_get(:@thread))
+  end
+
+  def test_threaded_loop_calls_block_repeatedly
+    mock = MiniTest::Mock.new.expect(:call, nil).expect(:call, nil)
+    part.stub(:foo, mock) do
+      part.threaded_loop do
+        part.foo
+        sleep 0.05
+      end
+      sleep 0.07 # And this.
+    end
+    mock.verify
+  end
+
+  def test_stop_thread_kills_thread
+    mock = MiniTest::Mock.new.expect(:kill, nil)
+    part.instance_variable_set(:@thread, mock)
+    part.stop_thread
+    mock.verify
+  end
+
+  def test_interrupts_override_singleton_only
+    second_part = ThreadedComponent.new(board: BoardMock.new, pin: 2)
+    before_class = second_part.method(:foo)
+    before_instance = part.method(:foo)
+
+    part.enable_interrupts
+    after_class = second_part.method(:foo)
+    after_instance = part.method(:foo)
+
+    assert_equal before_class, after_class
+    refute_equal before_instance, after_instance
+  end
+
+  def test_original_method_called_when_interrupts_enabled
+    mock = MiniTest::Mock.new.expect(:call, nil, ["denko"])
+    part.stub(:foo, mock) do
+      part.enable_interrupts
+      part.foo("denko")
+    end
+    mock.verify
+  end
+
+  def test_interrupt_stops_thread
+    part.enable_interrupts
+    mock = MiniTest::Mock.new.expect :call, nil
+    part.stub(:stop_thread, mock) { part. foo }
+    mock.verify
+  end
+end

data/test/board/board_test.rb

@@ -0,0 +1,130 @@
+require_relative '../test_helper'
+
+class BoardTest < Minitest::Test
+  def connection
+    @connection ||= ConnectionMock.new
+  end
+
+  def board
+    @board ||= Denko::Board.new(connection)
+  end
+
+  def test_require_a_connection_object
+    assert_raises(Exception) { Denko::Board.new }
+  end
+
+  def test_starts_observing_connection
+    io = ConnectionMock.new
+    mock = MiniTest::Mock.new.expect(:call, nil, [Denko::Board])
+    io.stub(:add_observer, mock) do
+      Denko::Board.new(io)
+    end
+    mock.verify
+  end
+
+  def test_calls_handshake_on_connection
+    mock = MiniTest::Mock.new.expect(:call, Constants::ACK)
+    connection.stub(:handshake, mock) do
+      Denko::Board.new(connection)
+    end
+    mock.verify
+  end
+
+  def test_set_aux_limit
+    assert_equal 527, board.aux_limit
+  end
+
+  def test_set_eeprom_length
+    assert_equal 1024, board.eeprom_length
+  end
+
+  def test_set_low_high
+    assert_equal 0, board.low
+    assert_equal 1, board.high
+  end
+  
+  def test_analog_resolution
+    assert_equal 255, board.analog_write_high
+    assert_equal 8,   board.analog_write_resolution
+    assert_equal 1023, board.analog_read_high
+    assert_equal 10,   board.analog_read_resolution
+    
+    mock = MiniTest::Mock.new
+    mock.expect(:call, nil, [Denko::Message.encode(command:96, value:12)])
+    mock.expect(:call, nil, [Denko::Message.encode(command:97, value:12)])
+    board.stub(:write, mock) do
+      board.analog_write_resolution = 12
+      board.analog_read_resolution = 12
+    end
+    mock.verify
+    
+    assert_equal 0,    board.low
+    assert_equal 12,   board.analog_write_resolution
+    assert_equal 4095, board.analog_write_high
+    assert_equal 12,   board.analog_read_resolution
+    assert_equal 4095, board.analog_read_high
+  end
+  
+  def test_eeprom
+    mock = MiniTest::Mock.new.expect(:call, "test eeprom", [], board: board)
+    Denko::EEPROM::BuiltIn.stub(:new, mock) do
+      board.eeprom
+    end
+    mock.verify
+  end
+
+  def test_write
+    board
+    mock = MiniTest::Mock.new.expect(:call, nil, ["message"])
+    connection.stub(:write, mock) do
+      board.write("message")
+    end
+    mock.verify
+  end
+
+  def test_update_passes_messages_to_correct_components
+    mock1 = MiniTest::Mock.new.expect(:update, nil, ["data"])
+    3.times { mock1.expect(:pin, 1) }
+    
+    # Make sure lines are split only on the first colon.
+    # Tests for string based pine names too.
+    mock2 = MiniTest::Mock.new.expect(:update, nil, ["with:colon"])
+    3.times { mock2.expect(:pin, 14) }
+    
+    # Special EEPROM mock.
+    mock3 = MiniTest::Mock.new.expect(:update, nil, ["bytes"])
+    3.times { mock3.expect(:pin, 254) }
+     
+    board.add_component(mock1)
+    board.add_component(mock2)
+    board.add_component(mock3)
+    board.update("1:data")
+    board.update("14:with:colon")
+    board.update("3:ignore")
+    board.update("254:bytes")
+    mock1.verify
+    mock2.verify
+    mock3.verify
+  end
+
+  def test_convert_pin
+    assert_equal 9,     board.convert_pin(9)
+    assert_equal 13,    board.convert_pin(:LED_BUILTIN)
+    assert_equal 13,    board.convert_pin('13')
+    assert_equal 12,    board.convert_pin(12.0)
+    assert_equal 11,    board.convert_pin('11.0')
+    assert_equal 15,    board.convert_pin('A1')
+    assert_equal 15,    board.convert_pin(:A1)
+    assert_equal 14,    board.convert_pin('DAC0')
+  end
+
+  def test_convert_pin_incorrect
+    assert_raises { board.convert_pin "DAC20"}
+    assert_raises { board.convert_pin :DAC20 }
+  end
+
+  def test_pin_uniqueness_for_single_pin_components
+    led = Denko::LED.new(board: board, pin:13)
+    assert_raises { Denko::Led.new(board: board, pin: 13) }
+  end
+end