def test_test_with_device(self):
self.driver.read.return_value = [0xFF]
device_present = self.i2c.test(0x50)
assert_that(self.driver.write_cmd, called_once_with(0x58, [0xA0]))
assert_that(self.driver.read, called_once_with(1))
assert_that(device_present, is_(True))
def test_expected_client_calls():
container = {'Id': 'zoidberg'}
handle = {'Id': 'execute'}
info = {'ExitCode': 0}
cmd = 'command'
client = mock.Mock()
client.exec_create.return_value = handle
client.exec_start.return_value = []
client.exec_inspect.return_value = info
execute(client, container, cmd, logging.getLogger('test-execute'))
assert_that(
client.exec_create,
called_once_with(container='zoidberg',
cmd=['/bin/bash', '-c', 'command'])
)
assert_that(
client.exec_start,
called_once_with(exec_id='execute')
)
assert_that(
client.exec_inspect,
called_once_with(exec_id='execute')
)
def test_read_iss_mode_with_serial(self):
self.driver.read.return_value = [0x07, 0x02, 0x71]
result = self.usb_iss.read_iss_mode()
assert_that(result, is_(defs.Mode.SERIAL_I2C_H_400KHZ))
assert_that(self.driver.write_cmd, called_once_with(0x5A, [0x01]))
assert_that(self.driver.read, called_once_with(3))
def test_read_fw_version(self):
self.driver.read.return_value = [0x07, 0x02, 0x40]
result = self.usb_iss.read_fw_version()
assert_that(result, is_(0x02))
assert_that(self.driver.write_cmd, called_once_with(0x5A, [0x01]))
assert_that(self.driver.read, called_once_with(3))
def test_read_single(self):
self.driver.read.return_value = [0x42]
data = self.i2c.read_single(0x20)
assert_that(self.driver.write_cmd, called_once_with(0x53, [0x41]))
assert_that(self.driver.read, called_once_with(1))
assert_that(data, is_(0x42))
def test_read_ad0(self):
self.driver.read.return_value = [0x11, 0x22]
data = self.i2c.read_ad0(0x78, 2)
assert_that(self.driver.write_cmd, called_once_with(0x54, [0xF1, 2]))
assert_that(self.driver.read, called_once_with(2))
assert_that(data, is_([0x11, 0x22]))
def test_get_ad(self):
self.driver.read.return_value = [0x02, 0xA6]
data = self.io.get_ad(1)
assert_that(self.driver.write_cmd, called_once_with(0x65, [1]))
assert_that(self.driver.read, called_once_with(2))
assert_that(data, is_(0x02A6))
def test_get_pins(self):
self.driver.read.return_value = [0x0E]
data = self.io.get_pins()
assert_that(self.driver.write_cmd, called_once_with(0x64))
assert_that(self.driver.read, called_once_with(1))
assert_that(data, is_([0, 1, 1, 1]))
def test_read_iss_mode(self):
self.driver.read.return_value = [0x07, 0x02, 0x40]
result = self.usb_iss.read_iss_mode()
assert_that(result, is_(defs.Mode.I2C_S_100KHZ))
assert_that(self.driver.write_cmd, called_once_with(0x5A, [0x01]))
assert_that(self.driver.read, called_once_with(3))
def test_transfer(self):
self.driver.read.return_value = [0x11, 0x22]
result = self.spi.transfer([0x01, 0x41])
assert_that(result, is_([0x11, 0x22]))
assert_that(self.driver.write_cmd,
called_once_with(0x61, [0x01, 0x41]))
assert_that(self.driver.read, called_once_with(2))
def test_read_ad2(self):
self.driver.read.return_value = [0x11, 0x22]
data = self.i2c.read_ad2(0x50, 0x4321, 2)
assert_that(self.driver.write_cmd,
called_once_with(0x56, [0xA1, 0x43, 0x21, 2]))
assert_that(self.driver.read, called_once_with(2))
assert_that(data, is_([0x11, 0x22]))
def test_transfer_max_length(self):
self.driver.read.return_value = list(range(62))
result = self.spi.transfer(list(range(62)))
assert_that(result, is_(list(range(62))))
assert_that(self.driver.write_cmd,
called_once_with(0x61, list(range(62))))
assert_that(self.driver.read, called_once_with(62))
def test_read_serial_number(self):
self.driver.read.return_value = [
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31]
result = self.usb_iss.read_serial_number()
assert_that(result, is_("00000001"))
assert_that(self.driver.write_cmd, called_once_with(0x5A, [0x03]))
assert_that(self.driver.read, called_once_with(8))
def test_read(self):
self.driver.read.return_value = [0x11, 0x22]
data = self.i2c.read(0x60, 0x02, 2)
assert_that(self.driver.write_cmd,
called_once_with(0x55, [0xC1, 0x02, 2]))
assert_that(self.driver.read, called_once_with(2))
assert_that(data, is_([0x11, 0x22]))
def test_read_ad2_large_data(self):
expected_data = list(range(64))
self.driver.read.return_value = expected_data
data = self.i2c.read_ad2(0x50, 0x4321, 64)
assert_that(self.driver.write_cmd,
called_once_with(0x56, [0xA1, 0x43, 0x21, 64]))
assert_that(self.driver.read, called_once_with(64))
assert_that(data, is_(expected_data))
def test_read_large_data(self):
expected_data = list(range(60))
self.driver.read.return_value = expected_data
data = self.i2c.read(0x60, 0x02, 60)
assert_that(self.driver.write_cmd,
called_once_with(0x55, [0xC1, 0x02, 60]))
assert_that(self.driver.read, called_once_with(60))
assert_that(data, is_(expected_data))
def test_setup_i2c_serial_default_values(self):
self.usb_iss.setup_i2c_serial()
assert_that(
self.driver.write_cmd,
called_once_with(
0x5A, [0x02, defs.Mode.I2C_H_400KHZ.value | 0x01, 0x01, 0x37]))
def test_transmit(self):
self.driver.read.side_effect = EMPTY_READS
self.serial.transmit([0x48, 0x65, 0x6c, 0x6c, 0x6f])
assert_that(self.driver.write_cmd,
called_once_with(0x62, [0x48, 0x65, 0x6c, 0x6c, 0x6f]))
def test_calls_subscribed(source, listener):
sentinel = object()
source.spam.subscribe(listener.spam_cb)
source.spam(s=sentinel)
assert_that(listener.spam_cb, called_once_with(s=sentinel))
def test_write_large_data(self):
expected_data = list(range(60))
self.i2c.write(0x70, 0x00, expected_data)
assert_that(self.driver.write_cmd,
called_once_with(0x55, [0xE0, 0x00, 60] + expected_data))
def test_setup_i2c_serial_overflow(self):
self.usb_iss.setup_i2c_serial(baud_rate=1)
assert_that(
self.driver.write_cmd,
called_once_with(
0x5A, [0x02, defs.Mode.I2C_H_400KHZ.value | 0x01, 0xFF, 0xFF]))
def test_calls_subscribed(broker, listener):
event = "test"
sentinel = object()
broker.subscribe(event, listener.test_cb)
broker.publish(event, s=sentinel)
assert_that(listener.test_cb, called_once_with(s=sentinel))
def test_calls_subscribed(broker, listener):
event = 'test'
sentinel = object()
broker.subscribe(event, listener.test_cb)
broker.publish(event, s=sentinel)
assert_that(listener.test_cb, called_once_with(s=sentinel))
def test_get_rx_count(self):
self.driver.read.return_value = [0xFF, 0x1E, 0x00]
rx_count = self.serial.get_rx_count()
assert_that(rx_count, is_(0))
assert_that(self.driver.read, called_once_with(3))
def test_write_cmd_with_data(self, serial):
driver = Driver().open('PORTNAME')
driver.write_cmd(0x88, [0x01, 0x02])
assert_that(serial().write, called_once_with(bytes([0x88, 0x01,
0x02])))
def test_setup_i2c_failure(self):
self.driver.check_ack_error_code.side_effect = UsbIssError
assert_that(calling(self.usb_iss.setup_i2c),
raises(UsbIssError))
assert_that(self.driver.check_ack_error_code,
called_once_with(defs.ModeError))
def test_write_ad2_large_data(self):
expected_data = list(range(59))
self.i2c.write_ad2(0x50, 0x1234, expected_data)
assert_that(self.driver.write_cmd,
called_once_with(0x56, [
0xA0, 0x12, 0x34, 59] + expected_data))
def test_change_io(self):
self.usb_iss.change_io(io1_type=defs.IOType.OUTPUT_LOW,
io2_type=defs.IOType.OUTPUT_HIGH,
io3_type=defs.IOType.ANALOGUE_INPUT,
io4_type=defs.IOType.DIGITAL_INPUT)
assert_that(self.driver.write_cmd,
called_once_with(0x5A, [0x02, 0x10, 0xB4]))
def test_fetch(self):
location = "http://stub/foo"
self._order.location = location
self._order.fetch()
assert_that(self._connector.apply,
called_once_with("GET", self._order,
{"url": location}))
def test_setup_serial_default_values(self):
self.usb_iss.setup_serial()
assert_that(self.driver.write_cmd,
called_once_with(0x5A,
[0x02, 0x01, 0x01, 0x37,
defs.IOType.DIGITAL_INPUT.value << 6 |
defs.IOType.DIGITAL_INPUT.value << 4]))
def test_create(self):
location = "http://stub/checkout/orders"
self._order.base_uri = location
data = {"foo": "boo"}
self._order.create(data)
assert_that(self._connector.apply,
called_once_with("POST", self._order,
{"url": location, "data": data}))
def test_update(self):
data = {"foo": "boo"}
location = "http://klarna.com/foo/bar/13"
self._order.location = location
self._order.update(data)
assert_that(self._connector.apply,
called_once_with("POST", self._order,
{"url": location, "data": data}))
def test_setup_i2c_default_values(self):
self.usb_iss.setup_i2c()
assert_that(self.driver.write_cmd,
called_once_with(0x5A, [
0x02,
defs.Mode.I2C_H_400KHZ.value,
defs.IOType.DIGITAL_INPUT.value << 2 |
defs.IOType.DIGITAL_INPUT.value]))
def test_calls_subscribed():
sentinel = object()
source = Source()
listener = mock.Mock()
subscribe(source, 'spam', listener.spam_cb)
publish(source, 'spam', s=sentinel)
assert_that(listener.spam_cb, called_once_with(s=sentinel))
def test_subscribe_signal_publish_boundsignal(mixed, listener):
# Supporting this in a general way might be a bit to intrusive as
# boundmethod and function and other things implementing the descriptor
# protocol would be consider equal as well.
sentinel = object()
mixed.subscribe(Mixed.spam, listener.spam_cb)
mixed.publish(mixed.spam, s=sentinel)
assert_that(listener.spam_cb, called_once_with(s=sentinel))
def test_free_signal():
sentinel = object()
source = Source()
listener = mock.Mock()
sig = signal('spam')
subscribe(source, 'spam', listener.spam_cb)
sig(source, s=sentinel)
assert_that(listener.spam_cb, called_once_with(s=sentinel))
def test_subscribe_generic():
s = Source()
l = mock.Mock()
sentinel = object()
change = signal('change', 'attribute')
p = change('name')
change.subscribe(s, l)
p.publish(s, s=sentinel)
assert_that(l, called_once_with(s=sentinel))
def test_subscribe_on_bound(source, listener):
bsignal = source.spam
bsignal.subscribe(listener.spam_cb)
source.spam()
assert_that(listener.spam_cb, called_once_with())
def test_publish_on_bound(source, listener):
source.spam.subscribe(listener.spam_cb)
bsignal = source.spam
bsignal()
assert_that(listener.spam_cb, called_once_with())
def test_subscribe_on_static(source, listener):
Source.spam.subscribe(source, listener.spam_cb)
source.spam()
assert_that(listener.spam_cb, called_once_with())
def test_subscribe_broker_publish_signal(mixed, listener):
sentinel = object()
mixed.subscribe(mixed.spam, listener.spam_cb)
mixed.spam(s=sentinel)
assert_that(listener.spam_cb, called_once_with(s=sentinel))
def test_subscribe_broker_publish_signal_with_name(mixed, listener):
sentinel = object()
mixed.subscribe(mixed.egg, listener.egg_cb)
mixed.egg(s=sentinel)
assert_that(listener.egg_cb, called_once_with(s=sentinel))
def test_subscribe_by_name(mixed, listener):
sentinel = object()
mixed.subscribe('egg', listener.egg_cb)
mixed.egg(s=sentinel)
assert_that(listener.egg_cb, called_once_with(s=sentinel))
def test_publish_override(mixed, listener):
sentinel = object()
mixed.publish = mock.Mock(wraps=mixed.publish)
mixed.egg(s=sentinel)
assert_that(mixed.publish, called_once_with(mixed.egg, s=sentinel))
