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))