Work on #87

Implement a test suite, including Travis-CI integration

tests/test_boards.py

@@ -0,0 +1,17 @@
+from __future__ import (
+    unicode_literals,
+    absolute_import,
+    print_function,
+    division,
+    )
+str = type('')
+
+
+import pytest
+
+from gpiozero.pins.mock import MockPin
+from gpiozero import *
+
+
+# TODO boards tests!
+

tests/test_devices.py

@@ -0,0 +1,17 @@
+from __future__ import (
+    unicode_literals,
+    absolute_import,
+    print_function,
+    division,
+    )
+str = type('')
+
+
+import pytest
+
+from gpiozero.pins.mock import MockPin
+from gpiozero import *
+
+
+# TODO devices tests!
+

tests/test_inputs.py

@@ -0,0 +1,16 @@
+from __future__ import (
+    unicode_literals,
+    absolute_import,
+    print_function,
+    division,
+    )
+str = type('')
+
+
+import pytest
+
+from gpiozero.pins.mock import MockPin
+from gpiozero import *
+
+
+# TODO input_devices tests!

tests/test_mock_pin.py

@@ -0,0 +1,74 @@
+from __future__ import (
+    unicode_literals,
+    absolute_import,
+    print_function,
+    division,
+    )
+str = type('')
+
+
+from threading import Event
+
+import pytest
+
+from gpiozero.pins.mock import MockPin, MockPWMPin
+from gpiozero import *
+
+
+# Some rough tests to make sure our MockPin is up to snuff. This is just
+# enough to get reasonable coverage but it's by no means comprehensive...
+
+def test_mock_pin_init():
+    with pytest.raises(ValueError):
+        MockPin(60)
+    assert MockPin(2).number == 2
+
+def test_mock_pin_frequency_unsupported():
+    with pytest.raises(AttributeError):
+        pin = MockPin(3)
+        pin.frequency = 100
+
+def test_mock_pin_frequency_supported():
+    pin = MockPWMPin(3)
+    pin.function = 'output'
+    assert pin.frequency is None
+    pin.frequency = 100
+    pin.state = 0.5
+    pin.frequency = None
+    assert not pin.state
+
+def test_mock_pin_pull():
+    pin = MockPin(4)
+    pin.function = 'input'
+    assert pin.pull == 'floating'
+    pin.pull = 'up'
+    assert pin.state
+    pin.pull = 'down'
+    assert not pin.state
+
+def test_mock_pin_edges():
+    pin = MockPin(5)
+    assert pin.when_changed is None
+    fired = Event()
+    pin.function = 'input'
+    pin.edges = 'both'
+    assert pin.edges == 'both'
+    pin.drive_low()
+    assert not pin.state
+    def changed():
+        fired.set()
+    pin.when_changed = changed
+    pin.drive_high()
+    assert pin.state
+    assert fired.wait(0)
+    fired.clear()
+    pin.edges = 'falling'
+    pin.drive_low()
+    assert not pin.state
+    assert fired.wait(0)
+    fired.clear()
+    pin.drive_high()
+    assert pin.state
+    assert not fired.wait(0)
+    assert pin.edges == 'falling'
+

tests/test_outputs.py

@@ -0,0 +1,460 @@
+from __future__ import (
+    unicode_literals,
+    absolute_import,
+    print_function,
+    division,
+    )
+str = type('')
+
+
+try:
+    from math import isclose
+except ImportError:
+    from gpiozero.compat import isclose
+
+import pytest
+from time import sleep
+
+from gpiozero.pins.mock import MockPin, MockPWMPin
+from gpiozero import *
+
+
+def test_output_initial_values():
+    pin = MockPin(2)
+    device = OutputDevice(pin, initial_value=False)
+    assert pin.function == 'output'
+    assert not pin.state
+    device.close()
+    device = OutputDevice(pin, initial_value=True)
+    assert pin.state
+    device.close()
+    state = pin.state
+    device = OutputDevice(pin, initial_value=None)
+    assert state == pin.state
+
+def test_output_write_active_high():
+    pin = MockPin(2)
+    device = OutputDevice(pin)
+    device.on()
+    assert pin.state
+    device.off()
+    assert not pin.state
+
+def test_output_write_active_low():
+    pin = MockPin(2)
+    device = OutputDevice(pin, active_high=False)
+    device.on()
+    assert not pin.state
+    device.off()
+    assert pin.state
+
+def test_output_write_closed():
+    device = OutputDevice(MockPin(2))
+    device.close()
+    with pytest.raises(GPIODeviceClosed):
+        device.on()
+
+def test_output_write_silly():
+    pin = MockPin(2)
+    device = OutputDevice(pin)
+    pin.function = 'input'
+    with pytest.raises(AttributeError):
+        device.on()
+
+def test_output_value():
+    pin = MockPin(2)
+    device = OutputDevice(pin)
+    assert not device.value
+    assert not pin.state
+    device.on()
+    assert device.value
+    assert pin.state
+    device.value = False
+    assert not device.value
+    assert not pin.state
+
+def test_output_digital_toggle():
+    pin = MockPin(2)
+    device = DigitalOutputDevice(pin)
+    assert not device.value
+    assert not pin.state
+    device.toggle()
+    assert device.value
+    assert pin.state
+    device.toggle()
+    assert not device.value
+    assert not pin.state
+
+def test_output_blink_background():
+    pin = MockPin(2)
+    device = DigitalOutputDevice(pin)
+    device.blink(0.1, 0.1, n=2)
+    device._blink_thread.join() # naughty, but ensures no arbitrary waits in the test
+    pin.assert_states_and_times([
+        (0.0, False),
+        (0.0, True),
+        (0.1, False),
+        (0.1, True),
+        (0.1, False)
+        ])
+
+def test_output_blink_foreground():
+    pin = MockPin(2)
+    device = DigitalOutputDevice(pin)
+    device.blink(0.1, 0.1, n=2, background=False)
+    pin.assert_states_and_times([
+        (0.0, False),
+        (0.0, True),
+        (0.1, False),
+        (0.1, True),
+        (0.1, False)
+        ])
+
+def test_output_blink_interrupt_on():
+    pin = MockPin(2)
+    device = DigitalOutputDevice(pin)
+    device.blink(1, 0.1)
+    sleep(0.2)
+    device.off() # should interrupt while on
+    pin.assert_states([False, True, False])
+
+def test_output_blink_interrupt_off():
+    pin = MockPin(2)
+    device = DigitalOutputDevice(pin)
+    device.blink(0.1, 1)
+    sleep(0.2)
+    device.off() # should interrupt while off
+    pin.assert_states([False, True, False])
+
+def test_output_pwm_bad_initial_value():
+    with pytest.raises(ValueError):
+        PWMOutputDevice(MockPin(2), initial_value=2)
+
+def test_output_pwm_not_supported():
+    with pytest.raises(AttributeError):
+        PWMOutputDevice(MockPin(2))
+
+def test_output_pwm_states():
+    pin = MockPWMPin(2)
+    device = PWMOutputDevice(pin)
+    device.value = 0.1
+    device.value = 0.2
+    device.value = 0.0
+    pin.assert_states([0.0, 0.1, 0.2, 0.0])
+
+def test_output_pwm_read():
+    pin = MockPWMPin(2)
+    device = PWMOutputDevice(pin, frequency=100)
+    assert device.frequency == 100
+    device.value = 0.1
+    assert isclose(device.value, 0.1)
+    assert isclose(pin.state, 0.1)
+    assert device.is_active
+    device.frequency = None
+    assert not device.value
+    assert not device.is_active
+    assert device.frequency is None
+
+def test_output_pwm_write():
+    pin = MockPWMPin(2)
+    device = PWMOutputDevice(pin)
+    device.on()
+    device.off()
+    pin.assert_states([False, True, False])
+
+def test_output_pwm_toggle():
+    pin = MockPWMPin(2)
+    device = PWMOutputDevice(pin)
+    device.toggle()
+    device.value = 0.5
+    device.value = 0.1
+    device.toggle()
+    device.off()
+    pin.assert_states([False, True, 0.5, 0.1, 0.9, False])
+
+def test_output_pwm_active_high_read():
+    pin = MockPWMPin(2)
+    device = PWMOutputDevice(pin, active_high=False)
+    device.value = 0.1
+    assert isclose(device.value, 0.1)
+    assert isclose(pin.state, 0.9)
+    device.frequency = None
+    assert device.value
+
+def test_output_pwm_bad_value():
+    with pytest.raises(ValueError):
+        PWMOutputDevice(MockPWMPin(2)).value = 2
+
+def test_output_pwm_write_closed():
+    device = PWMOutputDevice(MockPWMPin(2))
+    device.close()
+    with pytest.raises(GPIODeviceClosed):
+        device.on()
+
+def test_output_pwm_write_silly():
+    pin = MockPWMPin(2)
+    device = PWMOutputDevice(pin)
+    pin.function = 'input'
+    with pytest.raises(AttributeError):
+        device.off()
+
+def test_output_pwm_blink_background():
+    pin = MockPWMPin(2)
+    device = PWMOutputDevice(pin)
+    device.blink(0.1, 0.1, n=2)
+    device._blink_thread.join()
+    pin.assert_states_and_times([
+        (0.0, 0),
+        (0.0, 1),
+        (0.1, 0),
+        (0.1, 1),
+        (0.1, 0)
+        ])
+
+def test_output_pwm_blink_foreground():
+    pin = MockPWMPin(2)
+    device = PWMOutputDevice(pin)
+    device.blink(0.1, 0.1, n=2, background=False)
+    pin.assert_states_and_times([
+        (0.0, 0),
+        (0.0, 1),
+        (0.1, 0),
+        (0.1, 1),
+        (0.1, 0)
+        ])
+
+def test_output_pwm_fade_background():
+    pin = MockPWMPin(2)
+    device = PWMOutputDevice(pin)
+    device.blink(0, 0, 0.1, 0.1, n=2)
+    device._blink_thread.join()
+    pin.assert_states_and_times([
+        (0.0, 0),
+        (0.02, 0.2),
+        (0.02, 0.4),
+        (0.02, 0.6),
+        (0.02, 0.8),
+        (0.02, 1),
+        (0.02, 0.8),
+        (0.02, 0.6),
+        (0.02, 0.4),
+        (0.02, 0.2),
+        (0.02, 0),
+        (0.02, 0.2),
+        (0.02, 0.4),
+        (0.02, 0.6),
+        (0.02, 0.8),
+        (0.02, 1),
+        (0.02, 0.8),
+        (0.02, 0.6),
+        (0.02, 0.4),
+        (0.02, 0.2),
+        (0.02, 0),
+        ])
+
+def test_output_pwm_fade_foreground():
+    pin = MockPWMPin(2)
+    device = PWMOutputDevice(pin)
+    device.blink(0, 0, 0.1, 0.1, n=2, background=False)
+    pin.assert_states_and_times([
+        (0.0, 0),
+        (0.02, 0.2),
+        (0.02, 0.4),
+        (0.02, 0.6),
+        (0.02, 0.8),
+        (0.02, 1),
+        (0.02, 0.8),
+        (0.02, 0.6),
+        (0.02, 0.4),
+        (0.02, 0.2),
+        (0.02, 0),
+        (0.02, 0.2),
+        (0.02, 0.4),
+        (0.02, 0.6),
+        (0.02, 0.8),
+        (0.02, 1),
+        (0.02, 0.8),
+        (0.02, 0.6),
+        (0.02, 0.4),
+        (0.02, 0.2),
+        (0.02, 0),
+        ])
+
+def test_output_pwm_blink_interrupt():
+    pin = MockPWMPin(2)
+    device = PWMOutputDevice(pin)
+    device.blink(1, 0.1)
+    sleep(0.2)
+    device.off() # should interrupt while on
+    pin.assert_states([0, 1, 0])
+
+def test_rgbled_missing_pins():
+    with pytest.raises(ValueError):
+        RGBLED()
+
+def test_rgbled_initial_value():
+    r, g, b = (MockPWMPin(i) for i in (1, 2, 3))
+    device = RGBLED(r, g, b, initial_value=(0.1, 0.2, 0))
+    assert r.frequency
+    assert g.frequency
+    assert b.frequency
+    assert isclose(r.state, 0.1)
+    assert isclose(g.state, 0.2)
+    assert isclose(b.state, 0.0)
+
+def test_rgbled_value():
+    r, g, b = (MockPWMPin(i) for i in (1, 2, 3))
+    device = RGBLED(r, g, b)
+    assert not device.is_active
+    assert device.value == (0, 0, 0)
+    device.on()
+    assert device.is_active
+    assert device.value == (1, 1, 1)
+    device.off()
+    assert not device.is_active
+    assert device.value == (0, 0, 0)
+
+def test_rgbled_toggle():
+    r, g, b = (MockPWMPin(i) for i in (1, 2, 3))
+    device = RGBLED(r, g, b)
+    assert not device.is_active
+    assert device.value == (0, 0, 0)
+    device.toggle()
+    assert device.is_active
+    assert device.value == (1, 1, 1)
+    device.toggle()
+    assert not device.is_active
+    assert device.value == (0, 0, 0)
+
+def test_rgbled_blink_background():
+    r, g, b = (MockPWMPin(i) for i in (1, 2, 3))
+    device = RGBLED(r, g, b)
+    device.blink(0.1, 0.1, n=2)
+    device._blink_thread.join()
+    expected = [
+        (0.0, 0),
+        (0.0, 1),
+        (0.1, 0),
+        (0.1, 1),
+        (0.1, 0)
+        ]
+    r.assert_states_and_times(expected)
+    g.assert_states_and_times(expected)
+    b.assert_states_and_times(expected)
+
+def test_rgbled_blink_foreground():
+    r, g, b = (MockPWMPin(i) for i in (1, 2, 3))
+    device = RGBLED(r, g, b)
+    device.blink(0.1, 0.1, n=2, background=False)
+    expected = [
+        (0.0, 0),
+        (0.0, 1),
+        (0.1, 0),
+        (0.1, 1),
+        (0.1, 0)
+        ]
+    r.assert_states_and_times(expected)
+    g.assert_states_and_times(expected)
+    b.assert_states_and_times(expected)
+
+def test_rgbled_fade_background():
+    r, g, b = (MockPWMPin(i) for i in (1, 2, 3))
+    device = RGBLED(r, g, b)
+    device.blink(0, 0, 0.1, 0.1, n=2)
+    device._blink_thread.join()
+    expected = [
+        (0.0, 0),
+        (0.02, 0.2),
+        (0.02, 0.4),
+        (0.02, 0.6),
+        (0.02, 0.8),
+        (0.02, 1),
+        (0.02, 0.8),
+        (0.02, 0.6),
+        (0.02, 0.4),
+        (0.02, 0.2),
+        (0.02, 0),
+        (0.02, 0.2),
+        (0.02, 0.4),
+        (0.02, 0.6),
+        (0.02, 0.8),
+        (0.02, 1),
+        (0.02, 0.8),
+        (0.02, 0.6),
+        (0.02, 0.4),
+        (0.02, 0.2),
+        (0.02, 0),
+        ]
+    r.assert_states_and_times(expected)
+    g.assert_states_and_times(expected)
+    b.assert_states_and_times(expected)
+
+def test_output_rgbled_blink_interrupt():
+    r, g, b = (MockPWMPin(i) for i in (1, 2, 3))
+    device = RGBLED(r, g, b)
+    device.blink(1, 0.1)
+    sleep(0.2)
+    device.off() # should interrupt while on
+    r.assert_states([0, 1, 0])
+    g.assert_states([0, 1, 0])
+    b.assert_states([0, 1, 0])
+
+def test_motor_missing_pins():
+    with pytest.raises(ValueError):
+        Motor()
+
+def test_motor_pins():
+    f = MockPWMPin(1)
+    b = MockPWMPin(2)
+    device = Motor(f, b)
+    assert device.forward_device.pin is f
+    assert device.backward_device.pin is b
+
+def test_motor_close():
+    f = MockPWMPin(1)
+    b = MockPWMPin(2)
+    device = Motor(f, b)
+    device.close()
+    assert device.closed
+    assert device.forward_device.pin is None
+    assert device.backward_device.pin is None
+
+def test_motor_value():
+    f = MockPWMPin(1)
+    b = MockPWMPin(2)
+    device = Motor(f, b)
+    device.value = -1
+    assert device.is_active
+    assert device.value == -1
+    assert b.state == 1 and f.state == 0
+    device.value = 1
+    assert device.is_active
+    assert device.value == 1
+    assert b.state == 0 and f.state == 1
+    device.value = 0.5
+    assert device.is_active
+    assert device.value == 0.5
+    assert b.state == 0 and f.state == 0.5
+    device.value = 0
+    assert not device.is_active
+    assert not device.value
+    assert b.state == 0 and f.state == 0
+
+def test_motor_bad_value():
+    f = MockPWMPin(1)
+    b = MockPWMPin(2)
+    device = Motor(f, b)
+    with pytest.raises(ValueError):
+        device.value = 2
+
+def test_motor_reverse():
+    f = MockPWMPin(1)
+    b = MockPWMPin(2)
+    device = Motor(f, b)
+    device.forward()
+    assert device.value == 1
+    assert b.state == 0 and f.state == 1
+    device.reverse()
+    assert device.value == -1
+    assert b.state == 1 and f.state == 0
+