dino 0.8

data/spec/lib/components/base_component_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+module Dino
+  module Components
+    describe BaseComponent do
+      it 'should initialize with board and pin' do
+        pin = "a pin"
+        board = "a board"
+        component = BaseComponent.new(pin: pin, board: board)
+
+        component.pin.should == pin
+        component.board.should == board
+      end
+
+      it 'should assign pins' do
+        pins = {red: 'red', green: 'green', blue: 'blue'}
+        board = "a board"
+        component = BaseComponent.new(pins: pins, board: board)
+
+        component.pins.should == pins
+      end
+
+      it 'should require a pin or pins' do
+        expect {
+          BaseComponent.new(board: 'some board')
+        }.to raise_exception
+      end
+
+      it 'should require a board' do
+        expect {
+          BaseComponent.new(pin: 'some pin')
+        }.to raise_exception
+      end
+    end
+  end
+end
+

data/spec/lib/components/button_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+module Dino
+  module Components
+    describe Button do
+      describe '#initialize' do
+        it 'should raise if it does not receive a pin' do
+          expect {
+            Button.new(board: 'a board')
+          }.to raise_exception
+        end
+
+        it 'should raise if it does not receive a board' do
+          expect {
+            Button.new(pin: 'a pin')
+          }.to raise_exception
+        end
+
+        it 'should add itself to the board and start reading' do
+          board = mock(:board)
+          board.should_receive(:add_digital_hardware)
+          board.should_receive(:start_read)
+          Button.new(board: board, pin: 'a pin')
+        end
+      end
+
+      context 'callbacks' do
+        let(:board) { mock(:board, add_digital_hardware: true, start_read: true) }
+        let(:button) {Button.new(board: board, pin: mock)}
+        describe '#down' do
+          it 'should add a callback to the down_callbacks array' do
+            button.down(callback_mock = mock)
+            button.instance_variable_get(:@down_callbacks).should include callback_mock
+          end
+        end
+
+        describe '#up' do
+          it 'should add a callback to the up_callbacks array' do
+            button.up(callback_mock = mock)
+            button.instance_variable_get(:@up_callbacks).should include callback_mock
+          end
+        end
+
+        describe '#update' do
+          it 'should call the down callbacks' do
+            button.down(callback_mock1 = mock)
+            button.down(callback_mock2 = mock)
+            callback_mock1.should_receive(:call)
+            callback_mock2.should_receive(:call)
+            button.update(Button::DOWN)
+          end
+
+          it 'should call the up callbacks' do
+            button.up(callback_mock1 = mock)
+            button.up(callback_mock2 = mock)
+
+            button.instance_variable_set(:@state, Button::DOWN)
+
+            callback_mock1.should_receive(:call)
+            callback_mock2.should_receive(:call)
+            button.update(Button::UP)
+          end
+
+          it 'should not call the callbacks if the state has not changed' do
+            button.up(callback_mock = mock)
+
+            callback_mock.should_not_receive(:call)
+            button.update(Button::UP)
+            button.update(Button::UP)
+          end
+
+          it 'should not call the callbacks if the data is not UP or DOWN' do
+            button.up(callback_mock1 = mock)
+            button.down(callback_mock2 = mock)
+
+            callback_mock1.should_not_receive(:call)
+            callback_mock2.should_not_receive(:call)
+            button.update('foobarred')
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/components/led_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+module Dino
+  module Components
+    describe Led do
+      let(:board) { mock(:board, digital_write: true, set_pin_mode: true) }
+
+      describe '#initialize' do
+        it 'should raise if it does not receive a pin' do
+          expect {
+            Led.new(board: board)
+          }.to raise_exception
+        end
+
+        it 'should raise if it does not receive a board' do
+          expect {
+            Led.new(pins: {})
+          }.to raise_exception
+        end
+
+        it 'should set the pin to out' do
+          board.should_receive(:set_pin_mode).with(13, :out)
+          Led.new(pin: 13, board: board)
+        end
+
+        it 'should set the pin to low' do
+          board.should_receive(:digital_write).with(13, Board::LOW)
+          Led.new(pin: 13, board: board)
+        end
+      end
+
+      describe '#on' do
+        it 'should send a high to the board with the pin' do
+          @led = Led.new(pin: 13, board: board)
+          board.should_receive(:digital_write).with(13, Board::HIGH)
+          @led.on
+        end
+      end
+
+      describe '#off' do
+        it 'should send a high to the board with the pin' do
+          @led = Led.new(pin: 13, board: board)
+          board.should_receive(:digital_write).with(13, Board::LOW)
+          @led.off
+        end
+      end
+
+      describe '#blink' do
+        it 'should turn the led off if it is on'
+        it 'should not block'
+      end
+    end
+  end
+end

data/spec/lib/components/rgb_led_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+module Dino
+  module Components
+    describe RgbLed do
+      let(:board) { mock(:board, analog_write: true, set_pin_mode: true) }
+      let(:pins) { {red: 1, green: 2, blue: 3} }
+      let!(:rgb) {RgbLed.new(pins: pins, board: board)}
+
+      describe '#initialize' do
+        it 'should raise if it does not receive a pin' do
+          expect {
+            RgbLed.new(board: 'a board')
+          }.to raise_exception
+        end
+
+        it 'should raise if it does not receive a board' do
+          expect {
+            RgbLed.new(pins: pins)
+          }.to raise_exception
+        end
+
+        it 'should set the pin to out' do
+          board.should_receive(:set_pin_mode).with(1, :out)
+          board.should_receive(:set_pin_mode).with(2, :out)
+          board.should_receive(:set_pin_mode).with(3, :out)
+
+          RgbLed.new(pins: pins, board: board)
+        end
+
+        it 'should set the pin to low' do
+          board.should_receive(:analog_write).with(1, Board::LOW)
+          board.should_receive(:analog_write).with(2, Board::LOW)
+          board.should_receive(:analog_write).with(3, Board::LOW)
+
+          RgbLed.new(pins: pins, board: board)
+        end
+      end
+
+      describe '#red' do
+        it 'should set red to high, blue and green to low' do
+          board.should_receive(:analog_write).with(1, Board::HIGH)
+          board.should_receive(:analog_write).with(2, Board::LOW)
+          board.should_receive(:analog_write).with(3, Board::LOW)
+          rgb.red
+        end
+      end
+
+      describe '#green' do
+        it 'should set green to high, red and blue to low' do
+          board.should_receive(:analog_write).with(1, Board::LOW)
+          board.should_receive(:analog_write).with(2, Board::HIGH)
+          board.should_receive(:analog_write).with(3, Board::LOW)
+          rgb.green
+        end
+      end
+
+      describe '#blue' do
+        it 'should set blue to high, red and green to low' do
+          board.should_receive(:analog_write).with(1, Board::LOW)
+          board.should_receive(:analog_write).with(2, Board::LOW)
+          board.should_receive(:analog_write).with(3, Board::HIGH)
+          rgb.blue
+        end
+      end
+
+      describe '#blinky' do
+        it 'should set blue to high, red and green to low' do
+          Array.any_instance.should_receive(:cycle).and_yield(:red).and_yield(:green).and_yield(:blue)
+          rgb.should_receive(:red)
+          rgb.should_receive(:green)
+          rgb.should_receive(:blue)
+          rgb.blinky
+        end
+      end
+    end
+  end
+end

data/spec/lib/components/sensor_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+module Dino
+  module Components
+    describe Sensor do
+
+      let(:board){mock(:board).as_null_object}
+
+      describe '#initalize' do
+        it 'should raise if it does not receive a pin' do
+          expect {
+            Sensor.new(board: 'a board')
+          }.to raise_exception
+        end
+
+        it 'should raise if it does not receive a board' do
+          expect {
+            Sensor.new(pin: 'a pin')
+          }.to raise_exception
+        end
+
+        it 'should add itself to the board and start reading' do
+          board.should_receive(:add_analog_hardware)
+          board.should_receive(:start_read)
+          Sensor.new(board: board, pin: 'a pin')
+        end
+
+        it 'should initalize data_callbacks' do
+          sensor = Sensor.new(board: board, pin: 'a pin')
+          sensor.instance_variable_get(:@data_callbacks).should == []
+        end
+      end
+
+      describe '#when_data_received' do
+        it 'should add a callback back to the list of callbacks' do
+          sensor = Sensor.new(board: board, pin: 'a pin')
+          sensor.when_data_received 'Foo'
+          sensor.instance_variable_get(:@data_callbacks).should == ['Foo']
+        end
+      end
+
+      describe '#update' do
+        it 'should call all callbacks passing in the given data' do
+          first_callback, second_callback = mock, mock
+          first_callback.should_receive(:call).with('Some data')
+          second_callback.should_receive(:call).with('Some data')
+
+          sensor = Sensor.new(board: board, pin: 'a pin')
+
+          sensor.when_data_received first_callback
+          sensor.when_data_received second_callback
+
+          sensor.update('Some data')
+        end
+      end
+    end
+  end
+end

data/spec/lib/components/servo_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+module Dino
+  module Components
+    describe Servo do
+      let(:board) { mock(:board, analog_write: true, set_pin_mode: true) }
+
+      describe '#initialize' do
+        it 'should raise if it does not receive a pin' do
+          expect {
+            Servo.new(board: board)
+          }.to raise_exception
+        end
+
+        it 'should raise if it does not receive a board' do
+          expect {
+            Servo.new(pin: 13)
+          }.to raise_exception
+        end
+
+        it 'should set the pins to out' do
+          board.should_receive(:set_pin_mode).with(13, :out)
+          Servo.new(pin: 13, board: board)
+        end
+
+        it 'should set the inital position to 0' do
+          servo =  Servo.new(pin: 13, board: board)
+          servo.instance_variable_get(:@position).should == 0
+        end
+      end
+
+      describe '#position' do
+        let(:servo) {servo =  Servo.new(pin: 13, board: board)}
+
+        it 'should set the position of the Servo' do
+          servo.position = 90
+          servo.instance_variable_get(:@position).should == 90
+        end
+
+        it 'should modulate the position at 180' do
+          servo.position = 190
+          servo.instance_variable_get(:@position).should == 10
+        end
+
+        it 'should write the new position to the board' do
+          servo.should_receive(:analog_write).with(10)
+          servo.position = 190
+        end
+      end
+    end
+  end
+end
+

data/spec/lib/components/stepper_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+module Dino
+  module Components
+    describe Stepper do
+      let(:board) { mock(:board, digital_write: true, set_pin_mode: true) }
+
+      describe '#initialize' do
+        it 'should raise if it does not receive a step pin' do
+          expect {
+            Stepper.new(board: board)
+          }.to raise_exception
+        end
+
+        it 'should raise if it does not receive a direction pin' do
+          expect {
+            Stepper.new(board: board)
+          }.to raise_exception
+        end
+
+        it 'should raise if it does not receive a board' do
+          expect {
+            Stepper.new(pins: {step: 12, direction: 13})
+          }.to raise_exception
+        end
+
+        it 'should set the pins to out' do
+          board.should_receive(:set_pin_mode).with(13, :out)
+          board.should_receive(:set_pin_mode).with(12, :out)
+          Stepper.new(pins: {step: 13, direction: 12}, board: board)
+        end
+
+        it 'should set the step pin to low' do
+          board.should_receive(:digital_write).with(13, Board::LOW)
+          Stepper.new(pins: {step: 13, direction: 12}, board: board)
+        end
+      end
+
+      describe '#step_cc' do
+        it 'should send a high to the board with the pin' do
+          @stepper = Stepper.new(pins: {step: 13, direction: 12}, board: board)
+          board.should_receive(:digital_write).with(12, Board::HIGH)
+          board.should_receive(:digital_write).with(13, Board::HIGH)
+          board.should_receive(:digital_write).with(13, Board::LOW)
+          @stepper.step_cc
+        end
+      end
+
+      describe '#step_cw' do
+        it 'should send a high to the board with the pin' do
+          @stepper = Stepper.new(pins: {step: 13, direction: 12}, board: board)
+          board.should_receive(:digital_write).with(12, Board::LOW)
+          board.should_receive(:digital_write).with(13, Board::HIGH)
+          board.should_receive(:digital_write).with(13, Board::LOW)
+          @stepper.step_cw
+        end
+      end
+    end
+  end
+end

data/spec/lib/tx_rx_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+module Dino
+  describe TxRx do
+    it { should be }
+
+    describe '#initialize' do
+      it 'should set first_write to false' do
+        TxRx.new.instance_variable_get(:@first_write).should == true
+      end
+    end
+
+    describe '#io' do
+      it 'should instantiate a new SerialPort for each usb tty device found' do
+        subject.should_receive(:tty_devices).and_return(['cu.usb', 'tty1.usb', 'tty2.usb'])
+        SerialPort.should_receive(:new).with('/dev/tty1.usb', TxRx::BAUD).and_return(mock_serial = mock)
+        SerialPort.should_receive(:new).with('/dev/tty2.usb', TxRx::BAUD).and_return(mock)
+
+        subject.io.should == mock_serial
+      end
+
+      it 'should use the existing io instance if set' do
+        subject.should_not_receive(:tty_devices)
+        SerialPort.stub(:new).and_return(mock_serial = mock)
+
+        subject.io = '/dev/tty1.usb'
+        subject.io.should == mock_serial
+      end
+    end
+
+    describe '#io=' do
+      it 'should set io to a new serial port with the specified device' do
+        SerialPort.should_receive(:new).with('/dev/tty1.usb', TxRx::BAUD).and_return(mock_serial = mock)
+        subject.io = '/dev/tty1.usb'
+        subject.instance_variable_get(:@io).should == mock_serial
+      end
+    end
+
+    describe '#read' do
+      it 'should create a new thread' do
+        Thread.should_receive :new
+        subject.read
+      end
+
+      it 'should get messages from the device' do
+        subject.stub(:io).and_return(mock_serial = mock)
+
+        IO.should_receive(:select).and_return(true)
+        Thread.should_receive(:new).and_yield
+        subject.should_receive(:loop).and_yield
+        mock_serial.should_receive(:gets).and_return("foo::bar\n")
+        subject.should_receive(:changed).and_return(true)
+        subject.should_receive(:notify_observers).with('foo','bar')
+
+        subject.read
+      end
+    end
+
+    describe '#close_read' do
+      it 'should kill the reading thread' do
+        subject.instance_variable_set(:@thread, mock_thread = mock)
+        Thread.should_receive(:kill).with(mock_thread)
+        subject.read
+        subject.close_read
+      end
+    end
+
+    describe '#write' do
+      it 'should write to the device' do
+        IO.should_receive(:select).and_return(true)
+
+        subject.stub(:io).and_return(mock_serial = mock)
+        mock_serial.should_receive(:puts).with('a message')
+        subject.write('a message')
+      end
+    end
+  end
+end