denko 0.13.6 → 0.15.0

data/test/test_helper.rb

@@ -12,87 +12,6 @@ end
 require 'bundler/setup'
 require 'denko'
 
-# Touch each class to trigger auto load for simplecov.
-# Analog IO
-Denko::AnalogIO::ADS1118
-Denko::AnalogIO::Input
-Denko::AnalogIO::Output
-Denko::AnalogIO::Potentiometer
-Denko::AnalogIO::Sensor
-
-# Behaviors
-# Not needed, since every behavior will be included by at least one class.
-
-# Board
-# BoardMock inherits from Denko::Board
-
-# Connection
-Denko::Connection::Serial
-Denko::Connection::TCP
-
-# Digital IO
-Denko::DigitalIO::Button
-Denko::DigitalIO::Input
-Denko::DigitalIO::Output
-Denko::DigitalIO::Relay
-Denko::DigitalIO::RotaryEncoder
-
-# Display
-Denko::Display::Canvas
-Denko::Display::HD44780
-Denko::Display::SSD1306
-
-# EEPROM
-Denko::EEPROM::BuiltIn
-
-# I2C
-Denko::I2C::Bus
-Denko::I2C::Peripheral
-
-# LED
-Denko::LED::APA102
-Denko::LED::Base
-Denko::LED::RGB
-Denko::LED::SevenSegment
-Denko::LED::WS2812
-
-# Motor
-Denko::Motor::L298
-Denko::Motor::Servo
-Denko::Motor::Stepper
-
-# OneWire
-Denko::OneWire::Bus
-Denko::OneWire::Peripheral
-Denko::OneWire::Helper
-
-# Pulse IO
-Denko::PulseIO::Buzzer
-Denko::PulseIO::IRTransmitter
-Denko::PulseIO::PWMOutput
-
-# RTC
-Denko::RTC::DS3231
-
-# Sensor
-Denko::Sensor::Temperature
-Denko::Sensor::Humidity
-Denko::Sensor::BME280
-Denko::Sensor::BMP280
-Denko::Sensor::DHT
-Denko::Sensor::DS18B20
-Denko::Sensor::HTU21D
-
-# SPI
-Denko::SPI::BaseRegister
-Denko::SPI::BitBang
-Denko::SPI::Bus
-Denko::SPI::InputRegister
-Denko::SPI::OutputRegister
-
-# UART
-Denko::UART::BitBang
-
 # Helper module to redefine constants quietly.
 module Constants
   def self.redefine(const, value, opts={})
@@ -148,65 +67,69 @@ class ConnectionMock
 end
 
 class BoardMock < Denko::Board
-  def initialize
+  def initialize(connection=nil, options={})
     super(ConnectionMock.new)
-    @read_injection_mutex = Mutex.new
   end
 
-  WAITING_ON_READ_KEYS = [:read, :bus_controller, :board_proxy, :force_udpate]
-
-  def component_exists_for_pin(pin)
-    self.components.each do |component|
-      return component if component.pin == pin
-    end
+  def is_a_register?
     false
   end
 
-  def waiting_on_read(component)
-    WAITING_ON_READ_KEYS.each do |key|
-      return true if component.callbacks[key]
-    end
+  #
+  # Reads are async, in a background thread. This is a way to detect when a Component has
+  # initiated a read, and is waiting on a response that will eventually call its #update.
+  #
+  WAITING_ON_READ_KEYS = [:read, :read_raw, :bus_controller, :board_proxy, :force_update]
+
+  def read_injection_mutex
+    @read_injection_mutex ||= Mutex.new
+  end
+
+  def expects_reading?(component)
+    WAITING_ON_READ_KEYS.each { |key| return true if component.callbacks[key] }
     false
   end
 
+  def wait_for_component_read(component)
+    sleep(0.001) while !component.callbacks
+    sleep(0.001) while !expects_reading?(component)
+  end
+
   #
-  # Inject a message into the Board instance as if it were coming from the phsyical board.
-  # Use this to mock input data for the blocking #read pattern in the Reader behavior.
+  # Inject a message that will call the Component#update directly after it reads,
+  # bypassing Board. Use for testing above the Board interface.
   #
-  def inject_read_for_pin(pin, message)
+  def inject_component_update(component, data)
     Thread.new do
-      # Wait for a component to be added.
-      component = false
-      while !component
-        sleep(0.001)
-        component = component_exists_for_pin(pin)
-      end
-
-      # Wait for the component to have a "WAITING_ON_READ" callback.
-      sleep(0.001) while !component.callback_mutex
-      sleep(0.001) while !component.callbacks
-      sleep(0.001) while !waiting_on_read(component)
+      wait_for_component_read(component)
+      sleep 0.005 unless RUBY_ENGINE == "ruby"
+      read_injection_mutex.synchronize { component.update(data) }
+    end
+  end
 
-      # Then inject the message.
-      @read_injection_mutex.synchronize do
-        self.update("#{pin}:#{message}")
-      end
+  #
+  # We also want to inject readings at the pin or bus level, to test Board itself,
+  # or for integration tests. This waits for a pin to have a Component attached to it.
+  #
+  def wait_for_component_on_pin(pin)
+    component = false
+    while !component
+      sleep(0.001)
+      component = single_pin_components[pin]
     end
+    component
   end
 
   #
-  # Inject a message into the Board instance as if it were coming from the phsyical board.
-  # Use this to mock input data for the blocking #read pattern in the Reader behavior.
+  # Inject a message into the Board instance as if coming from a pin on the phsyical board.
+  # Use for testing Board internals, Board interface, and integration tests.
   #
-  def inject_read_for_component(component, pin, message)
+  def inject_read_for_pin(pin, message)
     Thread.new do
-      # Wait for the component to have a "WAITING_ON_READ" callback.
-      sleep(0.001) while !component.callback_mutex
-      sleep(0.001) while !component.callbacks
-      sleep(0.001) while !waiting_on_read(component)
-
-      # Then inject the message.
-      @read_injection_mutex.synchronize do
+      component = wait_for_component_on_pin(pin)
+      wait_for_component_read(component)
+      sleep 0.005 unless RUBY_ENGINE == "ruby"
+      read_injection_mutex.synchronize do
         self.update("#{pin}:#{message}")
       end
     end