denko 0.13.0

data/test/board/spi_test.rb

@@ -0,0 +1,97 @@
+# encoding: ascii-8bit
+# For convenience when validating longer data types.
+
+require_relative '../test_helper'
+
+class APISPITest < Minitest::Test
+  include TestPacker
+  
+  def connection
+    @connection ||= ConnectionMock.new
+  end
+
+  def board
+    @board ||= Denko::Board.new(connection)
+  end
+  
+  def test_spi_modes
+    # Start with mode = 0.
+    args = [[], 0, 1000000, 0, :msbfirst]
+    assert_equal (pack :uint8, 0b10000000), board.spi_header(*args)[0]
+
+    args[3] = 1
+    assert_equal (pack :uint8, 0b10000001), board.spi_header(*args)[0]
+
+    args[3] = 2
+    assert_equal (pack :uint8, 0b10000010), board.spi_header(*args)[0]
+
+    args[3] = 3
+    assert_equal (pack :uint8, 0b10000011), board.spi_header(*args)[0]
+
+    # Invalid mode = 4.
+    assert_raises(ArgumentError) { board.spi_header(*args[3] = 4) }
+  end
+  
+  def test_spi_lsbfirst
+    args = [[], 0, 1000000, 0, :lsbfirst]
+    assert_equal (pack :uint8, 0b00000000), board.spi_header(*args)[0]
+  end
+
+  def test_spi_frequency
+    args = [[], 0, 1000000, 0, :msbfirst]
+    assert_equal (pack :uint32, 1000000), board.spi_header(*args)[3..6]
+
+    args[2] = 8000000
+    assert_equal (pack :uint32, 8000000), board.spi_header(*args)[3..6]
+  end
+  
+  def test_spi_too_many_bytes
+    assert_raises(ArgumentError) { board.spi_header(read: 256) }
+    assert_raises(ArgumentError) { board.spi_header(write: Array.new(256){0})}
+  end
+  
+  def test_spi_no_bytes
+    assert_raises(ArgumentError) { board.spi_transfer(3, read: 0) }
+    assert_raises(ArgumentError) { board.spi_listen(3, read: 0) }
+  end
+
+  def test_spi_bad_frequency
+    assert_raises(ArgumentError) { board.spi_transfer(3, read: 0, frequency: "string") }
+  end
+  
+  def test_spi_transfer
+    board
+    bytes = [1,2,3,4]
+    header = board.spi_header(bytes, 4, 8000000, 2, :lsbfirst)
+    aux = header + pack(:uint8, bytes)
+    mock = MiniTest::Mock.new.expect  :call, nil,
+                                      [Denko::Message.encode(command: 26, pin: 3, aux_message: aux)]
+    
+    board.stub(:write, mock) do
+      args = { write: [1,2,3,4], read: 4, bit_order: :lsbfirst, frequency: 8000000, mode: 2 }
+      board.spi_transfer(3, **args)
+    end
+    mock.verify
+  end
+  
+  def test_spi_listen
+    board
+    header = board.spi_header([], 8, 1000000, 0, :lsbfirst)
+    mock = MiniTest::Mock.new.expect  :call, nil,
+                                      [Denko::Message.encode(command: 27, pin: 3, aux_message: header)]
+    
+    board.stub(:write, mock) do
+      board.spi_listen(3, read: 8, bit_order: :lsbfirst)
+    end
+    mock.verify
+  end
+  
+  def test_spi_stop
+    board
+    mock = MiniTest::Mock.new.expect :call, nil, [Denko::Message.encode(command: 28, pin: 3)]
+    board.stub(:write, mock) do
+      board.spi_stop(3)
+    end
+    mock.verify
+  end
+end

data/test/board/tone_test.rb

@@ -0,0 +1,42 @@
+require_relative '../test_helper'
+
+class APIToneTest < Minitest::Test
+  include TestPacker
+  
+  def connection
+    @connection ||= ConnectionMock.new
+  end
+
+  def board
+    @board ||= Denko::Board.new(connection)
+  end
+
+  def test_tone
+    mock = MiniTest::Mock.new
+    aux1 = pack(:uint16, 150) + pack(:uint16, 2000)
+    aux2 = pack(:uint16, 300)
+    
+    mock.expect :call, nil, [Denko::Message.encode(command: 17, pin: 10, value: 1, aux_message: aux1)]
+    mock.expect :call, nil, [Denko::Message.encode(command: 17, pin: 10, value: 0, aux_message: aux2)]
+
+    board.stub(:write, mock) do
+      board.tone(10, 150, 2000)
+      board.tone(10, 300)
+    end
+    mock.verify
+  end
+  
+  def test_tone_prevents_low_frequencies
+    assert_raises(ArgumentError, /freq/i) { board.tone(4, 30, 3000) }
+  end
+
+  def test_no_tone
+    mock = MiniTest::Mock.new
+    mock.expect :call, nil, [Denko::Message.encode(command: 18, pin: 10)]
+
+    board.stub(:write, mock) do
+      board.no_tone(10)
+    end
+    mock.verify
+  end
+end

data/test/connection/serial_test.rb

@@ -0,0 +1,172 @@
+require_relative '../test_helper'
+
+require "rubyserial"
+
+class SerialConnectionTest < Minitest::Test
+  def mock_tty_device
+    "/dev/mock_serial"
+  end
+
+  def connection
+    @connection ||= Denko::Connection::Serial.new
+  end
+
+  def io
+    suppress_output do
+      connection.send(:io)
+    end
+  end
+  
+  def test_connect_with_device_specified
+    mock = MiniTest::Mock.new.expect(:call, "SerialMock", ["/dev/ttyACM0", 9600])
+    ::Serial.stub(:new, mock) do
+      connection = Denko::Connection::Serial.new(device: "/dev/ttyACM0", baud: 9600)
+      assert_equal "SerialMock", suppress_output { connection.send(:io) }
+    end
+    mock.verify
+  end
+
+  def test_connect_with_no_devices
+    connection.stub(:tty_devices, []) do
+      assert_raises(Denko::Connection::SerialConnectError) { io }
+    end
+  end
+
+  def test_connect_on_unix
+    connection.stub(:tty_devices, ['/dev/ttyACM0', '/dev/tty.usbmodem1']) do
+      mock =  MiniTest::Mock.new
+      # Raise error for first device
+      mock.expect(:call, nil) { raise RubySerial::Error }
+      mock.expect :call, "serial-obj", ['/dev/tty.usbmodem1', Denko::Connection::Serial::BAUD]
+
+      ::Serial.stub(:new, mock) do
+        assert_equal "serial-obj", io
+      end
+      mock.verify
+    end
+  end
+
+  def test_connect_on_windows
+    # Simulate being on Windows
+    Constants.redefine(:RUBY_PLATFORM, "mswin", :on => Object)
+
+    mock =  MiniTest::Mock.new
+    # Raise error for COM1
+    mock.expect(:call, nil) { raise RubySerial::Error }
+    mock.expect :call, "serial-obj", ["COM2", Denko::Connection::Serial::BAUD]
+
+    ::Serial.stub(:new, mock) do
+      assert_equal "serial-obj", io
+    end
+    mock.verify
+
+    # Set platform back to original value
+    Constants.redefine(:RUBY_PLATFORM, Constants::ORIGINAL_RUBY_PLATFORM, :on => Object)
+  end
+
+  def test_io_reset
+    flush_mock = MiniTest::Mock.new.expect :call, true
+    r_stop_mock = MiniTest::Mock.new.expect :call, true
+    r_start_mock = MiniTest::Mock.new.expect :call, true
+    w_stop_mock = MiniTest::Mock.new.expect :call, true
+    w_start_mock = MiniTest::Mock.new.expect :call, true
+
+    connection.stub(:flush_read, flush_mock) do
+      connection.stub(:stop_read, r_stop_mock) do
+        connection.stub(:start_read, r_start_mock) do
+          connection.stub(:stop_write, w_stop_mock) do
+            connection.stub(:start_write, w_start_mock) do
+              connection.send(:io_reset)
+            end
+          end
+        end
+      end
+    end
+    
+    flush_mock.verify
+    r_stop_mock.verify
+    r_start_mock.verify
+    w_start_mock.verify
+    w_start_mock.verify
+  end
+
+  def test_read
+    connection.stub(:_read, "02:00:00") do
+      line = connection.send(:read)
+      assert_equal line, "02:00:00"
+    end
+  end
+  
+  def test_parse
+    mock = MiniTest::Mock.new.expect :call, nil, ['02:00:00']
+    connection.stub(:changed, true) do
+      connection.stub(:notify_observers, mock) do
+        connection.send(:parse, '02:00:00')
+      end
+      mock.verify
+    end
+  end
+
+  def test_stop_read
+    thread = Thread.new { sleep }
+    connection.instance_variable_set(:@read_thread, thread)
+    connection.send(:stop_write)
+    assert_nil connection.instance_variable_get(:@write_thread)
+  end
+  
+  def test_stop_write
+    thread = Thread.new { sleep }
+    connection.instance_variable_set(:@write_thread, thread)
+    connection.send(:stop_write)
+    assert_nil connection.instance_variable_get(:@write_thread)
+  end
+
+  def test_write_adds_to_buffer
+    connection.send(:stop_write)
+    connection.write('message')
+    assert_equal connection.instance_variable_get("@write_buffer"), "message"
+  end
+
+  def test_write_thread_removes_from_buffer
+    connection.send(:stop_write)
+    connection.write('message')
+
+    # Message is written from buffer when we start the write thread.
+    mock = MiniTest::Mock.new.expect :call, nil, ['message']
+    connection.stub(:_write, mock) do
+      # Start the write thread and wait for the buffer to empty.
+      connection.send(:start_write)  
+      sleep 0.100 while connection.instance_variable_get("@write_buffer") != ""
+    end
+    mock.verify
+
+    assert_equal connection.instance_variable_get("@write_buffer"), ""
+  end
+
+  def test_io_read_single_chars_until_newline_and_strips_it
+    mock = MiniTest::Mock.new
+    mock.expect :read, "line\n", [64]
+    connection.stub(:io, mock) do
+      assert_equal "line", connection.send(:read)
+    end
+    mock.verify
+  end
+
+  def test_io_read_handles_escaped_newlines_and_backslashes
+    mock = MiniTest::Mock.new
+    mock.expect :read, "l1\\\nl2\\\\\n", [64]
+    connection.stub(:io, mock) do
+      assert_equal "l1\nl2\\", connection.send(:read)
+    end
+    mock.verify
+  end
+
+  def test_io_read_returns_empty_string_if_just_newline
+    mock = MiniTest::Mock.new
+    mock.expect :read, "\n", [64]
+    connection.stub(:io, mock) do
+      assert_equal "", connection.send(:read)
+    end
+    mock.verify
+  end
+end

data/test/connection/tcp_test.rb

@@ -0,0 +1,37 @@
+require_relative '../test_helper'
+
+class TCPConnectionTest < Minitest::Test
+  # Force autoload.
+  Denko::Connection::TCP
+
+  def test_connect_raises_if_server_unavailable
+    assert_raises(Denko::Connection::TCPConnectError) do
+      suppress_output do
+        io = Denko::Connection::TCP.new("127.0.0.1", 3466).send(:io)
+      end
+    end
+  end
+
+  def test_connect
+    server = TCPServer.new("127.0.0.1", 3467)
+    io = nil
+    suppress_output do
+      io = Denko::Connection::TCP.new("127.0.0.1", 3467).send(:io)
+    end
+    assert_equal TCPSocket, io.class
+    server.close
+  end
+
+  def test_io_doesnt_reconnect
+    server = TCPServer.new("127.0.0.1", 3468)
+    connection = nil
+    io = nil
+    suppress_output do
+      connection = Denko::Connection::TCP.new("127.0.0.1", 3468)
+      io = connection.send(:io)
+    end
+    socket = io
+    assert_equal socket, connection.send(:io)
+    server.close
+  end
+end

data/test/digital_io/input_test.rb

@@ -0,0 +1,65 @@
+require_relative '../test_helper'
+
+class DigitalIOInputTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= Denko::DigitalIO::Input.new(board: board, pin: 14)
+  end
+
+  def test_start_listening_immediately
+    mock = MiniTest::Mock.new.expect :call, nil, [14, 4]
+    board.stub(:digital_listen, mock) do
+      part
+    end
+    mock.verify
+  end
+  
+  def test_converts_to_integer
+    part
+    part.update("1")
+    assert_equal part.state, 1
+  end
+
+  def test__read
+    mock = MiniTest::Mock.new.expect :call, nil, [14]
+    board.stub(:digital_read, mock) do
+      part._read
+    end
+    mock.verify
+  end
+
+  def test__listen
+    part
+    mock = MiniTest::Mock.new
+    mock.expect :call, nil, [14, 4]
+    mock.expect :call, nil, [14, 32]
+    board.stub(:digital_listen, mock) do
+      part._listen
+      part._listen(32)
+    end
+    mock.verify
+  end
+
+  def test_on_low
+    low_cb  = MiniTest::Mock.new.expect :call, nil
+    high_cb = MiniTest::Mock.new
+    part.on_low { low_cb.call }
+    part.on_high { high_cb.call }
+    part.update(board.low)
+    low_cb.verify
+    high_cb.verify
+  end
+
+  def test_on_high
+    low_cb  = MiniTest::Mock.new
+    high_cb = MiniTest::Mock.new.expect :call, nil
+    part.on_low { low_cb.call }
+    part.on_high { high_cb.call }
+    part.update(board.high)
+    low_cb.verify
+    high_cb.verify
+  end
+end

data/test/digital_io/output_test.rb

@@ -0,0 +1,64 @@
+require_relative '../test_helper'
+
+class DigitalIOOutputTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= Denko::DigitalIO::Output.new(board: board, pin: 14)
+  end
+
+  def test_read_state_on_initialize
+    mock = MiniTest::Mock.new.expect :call, nil, [14]
+    board.stub(:digital_read, mock) do
+      part
+    end
+    mock.verify
+  end
+
+  def test_digital_write
+    part
+    mock = MiniTest::Mock.new
+    mock.expect :call, nil, [14, board.high]
+    mock.expect :call, nil, [14, board.low]
+    mock.expect :call, nil, [14, board.low]
+    mock.expect :call, nil, [14, board.high]
+    board.stub(:digital_write, mock) do
+      part.digital_write(board.high)
+      part.digital_write(board.low)
+      part.digital_write(0)
+      part.digital_write(1)
+    end
+    mock.verify
+    assert_equal board.high, part.state
+  end
+
+  def test_high_and_low
+    part
+    mock = MiniTest::Mock.new
+    mock.expect :call, nil, [board.high]
+    mock.expect :call, nil, [board.low]
+    part.stub(:digital_write, mock) do
+      part.high
+      part.low
+    end
+    mock.verify
+  end
+
+  def test_toggle
+    part.low
+    mock = MiniTest::Mock.new.expect :call, nil
+    part.stub(:high, mock) do
+      part.toggle
+    end
+    mock.verify
+
+    part.high
+    mock = MiniTest::Mock.new.expect :call, nil
+    part.stub(:low, mock) do
+      part.toggle
+    end
+    mock.verify
+  end
+end

data/test/digital_io/rotary_encoder_test.rb

@@ -0,0 +1,99 @@
+require_relative '../test_helper'
+
+class RotaryEncoderTest < MiniTest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= Denko::DigitalIO::RotaryEncoder.new board: board, pins: {data:3, clock: 4}
+  end
+
+  def test_sets_steps_per_revolution
+    assert_equal 30,      part.steps_per_revolution
+    assert_equal 12.to_f, part.instance_variable_get(:@degrees_per_step)
+  end
+  
+  def test_resets_on_initialize
+    assert_equal part.state, {steps: 0, angle: 0}
+  end
+  
+  def test_calls_listen_on_both_pins_with_given_divider
+    clock_mock = MiniTest::Mock.new.expect(:call, nil, [1])
+    clock_mock.expect(:call, nil, [2])
+    data_mock = MiniTest::Mock.new.expect(:call, nil, [1])
+    data_mock.expect(:call, nil, [2])
+    
+    part.clock.stub(:listen, clock_mock) do
+      part.data.stub(:listen, data_mock) do
+        part.send(:after_initialize)
+        part.send(:after_initialize, divider: 2)
+      end
+    end
+  end
+  
+  def test_observes_on_initialize
+    mock = MiniTest::Mock.new.expect(:call, nil)
+    part.stub(:observe_pins, mock) do
+      part.send(:after_initialize)
+    end
+  end
+  
+  def test_observes_the_right_pin
+    refute_empty part.clock.callbacks
+    assert_empty part.data.callbacks
+        
+    part2 = Denko::DigitalIO::RotaryEncoder.new board: board, pins: {data:6, clock: 5}
+    
+    refute_empty part2.data.callbacks
+    assert_empty part2.clock.callbacks
+  end
+  
+  def test_goes_the_right_direction
+    part.data.send(:update, 1)
+    part.clock.send(:update, 1)
+    assert_equal({ steps: -1, angle: 348.0 }, part.state)
+    
+    part.reset
+    
+    part.data.send(:update, 1)
+    part.clock.send(:update, 0)
+    assert_equal({ steps: 1, angle: 12.0 }, part.state)
+  end
+
+  def test_reverse
+    part.reverse
+    assert part.reversed
+
+    part.data.send(:update, 1)
+    part.clock.send(:update, 1)
+    assert_equal({ steps: 1, angle: 12.0 }, part.state)
+  end
+
+  def test_swapped_pins
+    part2 = Denko::DigitalIO::RotaryEncoder.new board: board, pins: {data:4, clock: 3}
+
+    part2.clock.send(:update, 1)
+    part2.data.send(:update, 1)
+    assert_equal({ steps: 1, angle: 12.0 }, part2.state)
+  end
+  
+  def test_callback_prefilter
+    part.data.send(:update, 1)
+    part.clock.send(:update, 0)
+    callback_value = nil
+    part.add_callback do |value|
+      callback_value = value.dup
+    end
+    part.data.send(:update, 1)
+    part.clock.send(:update, 0)
+    
+    assert_equal({change: 1, steps: 2, angle: 24.0}, callback_value)
+  end
+  
+  def test_update_state_removes_change
+    part.data.send(:update, 1)
+    part.clock.send(:update, 1)
+    assert_nil part.state[:change]
+  end
+end

data/test/display/hd44780_test.rb

@@ -0,0 +1,23 @@
+require_relative '../test_helper'
+
+class HD44780Test < MiniTest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= Denko::Display::HD44780.new cols: 16, rows: 2,
+                                            board: board,
+                                            pins: { rs: 8, enable: 9,
+                                                    d4: 4, d5: 5, d6: 6, d7: 7 }
+  end
+  
+  def test_pin_validation
+    # Only given one pin out of d0-d3.
+    assert_raises do
+      Denko::Display::HD44780.new board: board, pins: { rs: 12, enable: 11,
+                                                      d4: 5, d5: 4, d6: 3, d7: 2, d3: 1 }
+    
+    end 
+  end
+end

data/test/eeprom/built_in_test.rb

@@ -0,0 +1,61 @@
+require_relative '../test_helper'
+
+class BoardMock < Denko::Board
+  attr_reader :eeprom_stub
+  
+  def eeprom_read(start_address, length)
+    # Initialize a fake EEPROM
+    @eeprom_stub ||= Array.new(eeprom_length){255}
+    
+    # Pack it up like a string coming from the board.
+    string = @eeprom_stub[start_address, length].map{ |x| x.to_s }.join(",")
+    
+    # Update ourselves with it.
+    self.update("254:#{start_address}-#{string}\n")
+  end
+
+  def eeprom_write(start_address, bytes)
+    @eeprom_stub[start_address, bytes.length] = bytes
+  end
+end
+
+class BuiltInEEPROMTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= board.eeprom
+  end
+  
+  def test_pin_ee
+    assert_equal part.pin, 254
+  end
+
+  def test_loads_on_initialize_and_updates_correctly
+    assert_equal part.state, Array.new(board.eeprom_length){255}
+  end
+  
+  def test_delegates_to_state_array
+    mock = MiniTest::Mock.new
+    mock.expect(:[], 255, [0])
+    mock.expect(:[]=, 128, [1, 128])
+    mock.expect(:each, nil)
+    mock.expect(:each_with_index, nil)
+    
+    part.stub(:state, mock) do
+      part[0]
+      part[1] = 128
+      part.each { |el| el }
+      part.each_with_index { |el| el }
+    end
+  end
+  
+  def test_saves_to_the_board
+    part[0] = 128
+    part[part.length] = 127
+    part.save
+    assert_equal board.eeprom_stub[0], 128
+    assert_equal board.eeprom_stub[board.eeprom_length], 127
+  end
+end