p - Code Metrics - s-s-boika/obdlib - Measure and Improve Code Quality continuously with Scrutinizer

p A
last analyzed 2017-02-09 09:22 UTC

↳ Parent: TestOBDScanner.test_get_basic_info()

Complexity

Total Complexity

Size/Duplication

Total Lines	11
Duplicated Lines	0 %

Importance

Changes	3
Bugs	0	Features	0

Metric	Value
wmc	2
c	3
b	0
f	0
dl	0
loc	11
rs	10

import unittest
import sys

if sys.version_info[0] < 3:
    import mock
else:
    import unittest.mock as mock

import obdlib.scanner as scanner


class TestOBDScanner(unittest.TestCase):
    def setUp(self):
        self.scan = scanner.OBDScanner("/dev/null")

    @mock.patch('obdlib.scanner.OBDScanner.is_port')
    @mock.patch('obdlib.scanner.OBDScanner.initialize')
    @mock.patch('obdlib.uart.UART.connection')
    def test_connection(self, mock_uart, mock_init, mock_is_port):
        mock_is_port.return_value = True
        self.scan.connect()
        self.assertEqual(mock_init.call_count, 1)
        self.assertEqual(mock_uart.call_count, 1)
        self.assertEqual(mock_init.call_args_list[0][0], ())
        self.assertEqual(mock_uart.call_args_list[0][0], ('/dev/null',))
        self.assertEqual(mock_uart.call_args_list[0][1], {'baudrate': 38400})

    def test_is_port(self):
        # False
        self.scan.uart_port = None
        is_port = self.scan.is_port()
        self.assertFalse(is_port)
        # True
        self.scan.uart_port = object
        is_port = self.scan.is_port()
        self.assertTrue(is_port)

    @mock.patch('obdlib.scanner.OBDScanner.vehicle_id_number')
    @mock.patch('obdlib.scanner.OBDScanner.battery_voltage')
    def test_get_basic_info(self, mock_voltage, mock_vin):
        mock_vin.return_value = {'E8': '2312KJLKJHLKJ43L34323'}
        mock_voltage.return_value = 12.7
        self.scan.sensor = mock.MagicMock()

        class p(object):
            def __init__(self, n):
                if int(n, 16) == 28:
                    self.values = {'E8': 'OBD and OBD-II'}
                if int(n, 16) == 81:
                    self.values = {'E8': 'Gasoline'}

            @property
            def gen(self):
                for ecu, value in self.values.items():
                    yield (ecu, value)

        def mode(a):
            def pid(n):
                pid.ecus = p(n).gen
                if int(n, 16) == 28:
                    pid.title = 'OBD'
                if int(n, 16) == 81:
                    pid.title = 'FUEL_TYPE'
                return pid

            return pid

        self.scan.sensor.__getitem__.side_effect = mode
        info = self.scan.get_basic_info()
        self.assertEqual(mock_vin.call_count, 1)
        self.assertEqual(mock_vin.call_args_list[0][0], ())
        self.assertEqual(info,
                         {
                             'BATTERY_VOLTAGE': 12.7,
                             'OBD': {'E8': 'OBD and OBD-II'},
                             'VIN': {'E8': '2312KJLKJHLKJ43L34323'},
                             'FUEL_TYPE': {'E8': 'Gasoline'}
                         })

    @mock.patch('obdlib.scanner.OBDScanner.send')
    def test_battery_voltage(self, mock_send):
        volt = self.scan.battery_voltage()
        self.assertEqual(mock_send.call_count, 1)
        self.assertEqual(mock_send.call_args_list[0][0], ('ATRV',))

    @mock.patch('obdlib.scanner.OBDScanner.reset')
    @mock.patch('obdlib.scanner.OBDScanner.is_port')
    def test_disconnect(self, mock_is_port, mock_reset):
        # is_port True
        mock_is_port.return_value = True
        self.scan.uart_port = mock.Mock()
        self.scan.disconnect()
        self.assertEqual(mock_is_port.call_count, 1)
        self.assertEqual(mock_is_port.call_args_list[0][0], ())
        self.assertEqual(mock_reset.call_count, 1)
        self.assertEqual(mock_reset.call_args_list[0][0], ())
        self.assertEqual(self.scan.uart_port.close.call_count, 1)
        self.assertEqual(self.scan.uart_port.close.call_args_list[0][0], ())
        # is_port False
        mock_is_port.reset_mock()
        mock_reset.reset_mock()
        self.scan.uart_port.reset_mock()
        mock_is_port.return_value = False
        self.scan.disconnect()
        self.assertEqual(mock_is_port.call_count, 1)
        self.assertEqual(mock_is_port.call_args_list[0][0], ())
        self.assertEqual(mock_reset.call_count, 0)
        self.assertEqual(self.scan.uart_port.close.call_count, 0)

    @mock.patch('sys.stdout')
    @mock.patch('obdlib.scanner.sensors.Command')
    @mock.patch('obdlib.scanner.OBDScanner.send')
    @mock.patch('obdlib.scanner.OBDScanner.echo_off')
    @mock.patch('obdlib.scanner.OBDScanner.reset')
    def test_initialize(self, mock_reset, mock_echo, mock_send, mock_sensor, mock_out):
        exception = ''

        def send(data):
            class r_v():
                raw_value = r_value
                at_value = a_value

            return r_v

        # if connected, each request returns OK
        mock_echo.return_value = ['OK']
        r_value = ['OK']
        a_value = 'A5'
        send.counter = 0
        mock_send.side_effect = send
        self.scan.initialize()

        self.assertEqual(mock_reset.call_count, 1)
        self.assertEqual(mock_reset.call_args_list[0][0], ())

        self.assertEqual(mock_echo.call_count, 1)
        self.assertEqual(mock_echo.call_args_list[0][0], ())

        self.assertEqual(mock_send.call_count, 6)
        self.assertEqual(mock_sensor.call_args_list[0][0], (mock_send, 0))

        # if not connected
        mock_reset.reset_mock()
        mock_echo.reset_mock()
        mock_send.reset_mock()
        mock_sensor.reset_mock()
        mock_echo.return_value = ['OK']
        r_value = ['OK']
        a_value = 'A5'
        self.scan.sensor.check_pids.return_value = False
        with self.assertRaises(Exception) as cm:
            self.scan.initialize()
        self.assertEqual(cm.exception.__str__(), 'Failed connection to the OBD2 interface!')

        # Exception, check Echo
        mock_reset.reset_mock()
        mock_echo.reset_mock()
        mock_send.reset_mock()
        mock_sensor.reset_mock()

        mock_echo.return_value = ['']
        r_value = ['']
        a_value = 'A5'
        send.counter = 0
        mock_send.side_effect = send
        with self.assertRaises(Exception) as cm:
            self.scan.initialize()
        self.assertEqual(cm.exception.__str__(), 'Echo command did not completed')

        mock_reset.reset_mock()
        mock_echo.reset_mock()
        mock_send.reset_mock()
        mock_sensor.reset_mock()

        mock_echo.return_value = ['OK']
        r_value = ['']
        a_value = 'A5'
        mock_send.side_effect = send

        with self.assertRaises(Exception) as cm:
            self.scan.initialize()
        self.assertEqual(cm.exception.__str__(), "Set protocol command did not completed")

    def test_get_proto_num(self):
        self.scan.obd_protocol = 'AA'
        num = self.scan.get_proto_num()
        self.assertEqual(num, 10)

    @mock.patch('obdlib.scanner.OBDScanner.get_proto_num')
    @mock.patch('obdlib.scanner.OBDScanner.is_port')
    def test_receive(self, mock_is_port, mock_proto_num):
        from obdlib.response import Response

        buffer = 'ATZ\r\x00\n>'

        def read_character(n):
            """
                Emulate UART buffer
            """
            r = buffer[read_character.counter]
            read_character.counter += n
            return r.encode()

        # if connection
        mock_is_port.return_value = True
        mock_proto_num.return_value = 5
        self.scan.uart_port = mock.Mock()

        read_character.counter = 0
        self.scan.uart_port.read.side_effect = read_character
        response = self.scan.receive()
        self.assertIsInstance(response, Response)
        self.assertEqual(self.scan.uart_port.read.call_count, len(buffer))
        self.assertEqual(self.scan.uart_port.read.call_args_list[0][0], (1,))

        # if have not connection
        mock_is_port.reset_mock()
        mock_proto_num.reset_mock()
        mock_is_port.return_value = False
        with self.assertRaises(Exception) as cm:
            self.scan.receive()
        self.assertEqual(cm.exception.__str__(), 'Cannot read when unconnected')

        # if connection but nothing were received
        mock_is_port.reset_mock()
        mock_proto_num.reset_mock()
        mock_is_port.return_value = True
        mock_proto_num.return_value = 5
        self.scan.uart_port = mock.Mock()

        self.scan.uart_port.read.return_value = b''
        response = self.scan.receive()
        self.assertIsInstance(response, Response)
        self.assertEqual(self.scan.uart_port.read.call_count, 11)
        self.assertEqual(self.scan.uart_port.read.call_args_list[0][0], (1,))

    @mock.patch('obdlib.scanner.OBDScanner.send')
    @mock.patch('obdlib.scanner.OBDScanner.is_port')
    def test_reset(self, mock_is_port, mock_send):
        mock_is_port.return_value = True
        self.scan.reset()
        self.assertEqual(mock_is_port.call_count, 1)
        self.assertEqual(mock_is_port.call_args_list[0][0], ())
        self.assertEqual(mock_send.call_count, 1)
        self.assertEqual(mock_send.call_args_list[0][0], ('ATZ', 1))

    @mock.patch('obdlib.scanner.OBDScanner.receive')
    @mock.patch('obdlib.scanner.OBDScanner._write')
    @mock.patch('obdlib.scanner.OBDScanner.is_port')
    @mock.patch('obdlib.scanner.time.sleep')
    def test_send(self, mock_sleep, mock_is_port, mock_write, mock_receive):
        from obdlib.response import Response

        mock_is_port.return_value = True
        mock_receive.return_value = Response()
        resp = self.scan.send('0100')

        self.assertEqual(mock_is_port.call_count, 1)
        self.assertEqual(mock_is_port.call_args_list[0][0], ())

        self.assertEqual(mock_sleep.call_count, 0)

        self.assertEqual(mock_write.call_count, 1)
        self.assertEqual(mock_write.call_args_list[0][0], ('0100',))

        self.assertEqual(mock_receive.call_count, 1)
        self.assertEqual(mock_receive.call_args_list[0][0], ())

        self.assertIsInstance(resp, Response)

        mock_is_port.reset_mock()
        mock_write.reset_mock()
        mock_receive.reset_mock()
        resp = self.scan.send('0100', 1)

        self.assertEqual(mock_is_port.call_count, 1)
        self.assertEqual(mock_is_port.call_args_list[0][0], ())

        self.assertEqual(mock_sleep.call_count, 1)
        self.assertEqual(mock_sleep.call_args_list[0][0], (1,))

        self.assertEqual(mock_write.call_count, 1)
        self.assertEqual(mock_write.call_args_list[0][0], ('0100',))

        self.assertEqual(mock_receive.call_count, 1)
        self.assertEqual(mock_receive.call_args_list[0][0], ())

        self.assertIsInstance(resp, Response)

    def test_vehicle_id_number(self):
        self.scan.sensor = mock.MagicMock()

        class p(object):
            @property
            def gen(self):
                for ecu, value in {'E8': '2312KJLKJHLKJ43L34323'}.items():
                    yield (ecu, value)

        def mode(a):
            def pid(n):
                pid.ecus = p().gen
                return pid

            return pid

        self.scan.sensor.__getitem__.side_effect = mode
        vin = self.scan.vehicle_id_number()
        self.assertEqual(vin, {'E8': '2312KJLKJHLKJ43L34323'})

    @mock.patch('sys.stdout')
    @mock.patch('obdlib.scanner.OBDScanner.send')
    def test_clear_trouble_codes(self, mock_send, mock_out):
        def send(data):
            class r_v():
                raw_value = value

            return r_v

        # Return OK
        value = ['OK']
        mock_send.side_effect = send
        resp = self.scan.clear_trouble_codes()

        self.assertEqual(mock_send.call_count, 1)
        self.assertEqual(mock_send.call_args_list[0][0], ('04',))

        self.assertIsNone(resp)

        # Do not return OK
        mock_send.reset_mock()
        value = ['?']
        mock_send.side_effect = send
        resp = self.scan.clear_trouble_codes()

        self.assertEqual(mock_send.call_count, 1)
        self.assertEqual(mock_send.call_args_list[0][0], ('04',))

        self.assertIsNone(resp)

    @mock.patch('obdlib.scanner.OBDScanner.send')
    def test_echo_off(self, mock_send):
        def send(data):
            class r_v():
                raw_value = value

            return r_v

        value = ['OK']
        mock_send.side_effect = send
        resp = self.scan.echo_off()
        self.assertEqual(mock_send.call_count, 1)
        self.assertEqual(mock_send.call_args_list[0][0], ('ATE0',))
        self.assertEqual(resp, ['OK'])

    def test__check_response(self):
        resp = self.scan._check_response(['OK'])
        self.assertTrue(resp)

        resp = self.scan._check_response(['?'])
        self.assertFalse(resp)

    def test__write(self):
        self.scan.uart_port = mock.Mock()
        self.scan._write('ATH1')

        self.assertEqual(self.scan.uart_port.flushOutput.call_count, 1)
        self.assertEqual(self.scan.uart_port.flushOutput.call_args_list[0][0], ())

        self.assertEqual(self.scan.uart_port.flushInput.call_count, 1)
        self.assertEqual(self.scan.uart_port.flushInput.call_args_list[0][0], ())

        self.assertEqual(self.scan.uart_port.write.call_count, 1)
        self.assertEqual(self.scan.uart_port.write.call_args_list[0][0], (b'ATH1\r\n',))


if __name__ == '__main__':
    suite = unittest.TestLoader().loadTestsFromTestCase(TestOBDScanner)
    unittest.TextTestRunner(verbosity=2).run(suite)



1			import unittest
2			import sys
3
4			if sys.version_info[0] < 3:
5			import mock
6			else:
7			import unittest.mock as mock
8
9			import obdlib.scanner as scanner
10
11
12			class TestOBDScanner(unittest.TestCase):
13			def setUp(self):
14			self.scan = scanner.OBDScanner("/dev/null")
15
16			@mock.patch('obdlib.scanner.OBDScanner.is_port')
17			@mock.patch('obdlib.scanner.OBDScanner.initialize')
18			@mock.patch('obdlib.uart.UART.connection')
19			def test_connection(self, mock_uart, mock_init, mock_is_port):
20			mock_is_port.return_value = True
21			self.scan.connect()
22			self.assertEqual(mock_init.call_count, 1)
23			self.assertEqual(mock_uart.call_count, 1)
24			self.assertEqual(mock_init.call_args_list[0][0], ())
25			self.assertEqual(mock_uart.call_args_list[0][0], ('/dev/null',))
26			self.assertEqual(mock_uart.call_args_list[0][1], {'baudrate': 38400})
27
28			def test_is_port(self):
29			# False
30			self.scan.uart_port = None
31			is_port = self.scan.is_port()
32			self.assertFalse(is_port)
33			# True
34			self.scan.uart_port = object
35			is_port = self.scan.is_port()
36			self.assertTrue(is_port)
37
38			@mock.patch('obdlib.scanner.OBDScanner.vehicle_id_number')
39			@mock.patch('obdlib.scanner.OBDScanner.battery_voltage')
40			def test_get_basic_info(self, mock_voltage, mock_vin):
41			mock_vin.return_value = {'E8': '2312KJLKJHLKJ43L34323'}
42			mock_voltage.return_value = 12.7
43			self.scan.sensor = mock.MagicMock()
44
45			class p(object):
46			def __init__(self, n):
47			if int(n, 16) == 28:
48			self.values = {'E8': 'OBD and OBD-II'}
49			if int(n, 16) == 81:
50			self.values = {'E8': 'Gasoline'}
51
52			@property
53			def gen(self):
54			for ecu, value in self.values.items():
55			yield (ecu, value)
56
57			def mode(a):
58			def pid(n):
59			pid.ecus = p(n).gen
60			if int(n, 16) == 28:
61			pid.title = 'OBD'
62			if int(n, 16) == 81:
63			pid.title = 'FUEL_TYPE'
64			return pid
65
66			return pid
67
68			self.scan.sensor.__getitem__.side_effect = mode
69			info = self.scan.get_basic_info()
70			self.assertEqual(mock_vin.call_count, 1)
71			self.assertEqual(mock_vin.call_args_list[0][0], ())
72			self.assertEqual(info,
73			{
74			'BATTERY_VOLTAGE': 12.7,
75			'OBD': {'E8': 'OBD and OBD-II'},
76			'VIN': {'E8': '2312KJLKJHLKJ43L34323'},
77			'FUEL_TYPE': {'E8': 'Gasoline'}
78			})
79
80			@mock.patch('obdlib.scanner.OBDScanner.send')
81			def test_battery_voltage(self, mock_send):
82			volt = self.scan.battery_voltage()
83			self.assertEqual(mock_send.call_count, 1)
84			self.assertEqual(mock_send.call_args_list[0][0], ('ATRV',))
85
86			@mock.patch('obdlib.scanner.OBDScanner.reset')
87			@mock.patch('obdlib.scanner.OBDScanner.is_port')
88			def test_disconnect(self, mock_is_port, mock_reset):
89			# is_port True
90			mock_is_port.return_value = True
91			self.scan.uart_port = mock.Mock()
92			self.scan.disconnect()
93			self.assertEqual(mock_is_port.call_count, 1)
94			self.assertEqual(mock_is_port.call_args_list[0][0], ())
95			self.assertEqual(mock_reset.call_count, 1)
96			self.assertEqual(mock_reset.call_args_list[0][0], ())
97			self.assertEqual(self.scan.uart_port.close.call_count, 1)
98			self.assertEqual(self.scan.uart_port.close.call_args_list[0][0], ())
99			# is_port False
100			mock_is_port.reset_mock()
101			mock_reset.reset_mock()
102			self.scan.uart_port.reset_mock()
103			mock_is_port.return_value = False
104			self.scan.disconnect()
105			self.assertEqual(mock_is_port.call_count, 1)
106			self.assertEqual(mock_is_port.call_args_list[0][0], ())
107			self.assertEqual(mock_reset.call_count, 0)
108			self.assertEqual(self.scan.uart_port.close.call_count, 0)
109
110			@mock.patch('sys.stdout')
111			@mock.patch('obdlib.scanner.sensors.Command')
112			@mock.patch('obdlib.scanner.OBDScanner.send')
113			@mock.patch('obdlib.scanner.OBDScanner.echo_off')
114			@mock.patch('obdlib.scanner.OBDScanner.reset')
115			def test_initialize(self, mock_reset, mock_echo, mock_send, mock_sensor, mock_out):
116			exception = ''
117
118			def send(data):
119			class r_v():
120			raw_value = r_value
121			at_value = a_value
122
123			return r_v
124
125			# if connected, each request returns OK
126			mock_echo.return_value = ['OK']
127			r_value = ['OK']
128			a_value = 'A5'
129			send.counter = 0
130			mock_send.side_effect = send
131			self.scan.initialize()
132
133			self.assertEqual(mock_reset.call_count, 1)
134			self.assertEqual(mock_reset.call_args_list[0][0], ())
135
136			self.assertEqual(mock_echo.call_count, 1)
137			self.assertEqual(mock_echo.call_args_list[0][0], ())
138
139			self.assertEqual(mock_send.call_count, 6)
140			self.assertEqual(mock_sensor.call_args_list[0][0], (mock_send, 0))
141
142			# if not connected
143			mock_reset.reset_mock()
144			mock_echo.reset_mock()
145			mock_send.reset_mock()
146			mock_sensor.reset_mock()
147			mock_echo.return_value = ['OK']
148			r_value = ['OK']
149			a_value = 'A5'
150			self.scan.sensor.check_pids.return_value = False
151			with self.assertRaises(Exception) as cm:
152			self.scan.initialize()
153			self.assertEqual(cm.exception.__str__(), 'Failed connection to the OBD2 interface!')
154
155			# Exception, check Echo
156			mock_reset.reset_mock()
157			mock_echo.reset_mock()
158			mock_send.reset_mock()
159			mock_sensor.reset_mock()
160
161			mock_echo.return_value = ['']
162			r_value = ['']
163			a_value = 'A5'
164			send.counter = 0
165			mock_send.side_effect = send
166			with self.assertRaises(Exception) as cm:
167			self.scan.initialize()
168			self.assertEqual(cm.exception.__str__(), 'Echo command did not completed')
169
170			mock_reset.reset_mock()
171			mock_echo.reset_mock()
172			mock_send.reset_mock()
173			mock_sensor.reset_mock()
174
175			mock_echo.return_value = ['OK']
176			r_value = ['']
177			a_value = 'A5'
178			mock_send.side_effect = send
179
180			with self.assertRaises(Exception) as cm:
181			self.scan.initialize()
182			self.assertEqual(cm.exception.__str__(), "Set protocol command did not completed")
183
184			def test_get_proto_num(self):
185			self.scan.obd_protocol = 'AA'
186			num = self.scan.get_proto_num()
187			self.assertEqual(num, 10)
188
189			@mock.patch('obdlib.scanner.OBDScanner.get_proto_num')
190			@mock.patch('obdlib.scanner.OBDScanner.is_port')
191			def test_receive(self, mock_is_port, mock_proto_num):
192			from obdlib.response import Response
193
194			buffer = 'ATZ\r\x00\n>'
195
196			def read_character(n):
197			"""
198			Emulate UART buffer
199			"""
200			r = buffer[read_character.counter]
201			read_character.counter += n
202			return r.encode()
203
204			# if connection
205			mock_is_port.return_value = True
206			mock_proto_num.return_value = 5
207			self.scan.uart_port = mock.Mock()
208
209			read_character.counter = 0
210			self.scan.uart_port.read.side_effect = read_character
211			response = self.scan.receive()
212			self.assertIsInstance(response, Response)
213			self.assertEqual(self.scan.uart_port.read.call_count, len(buffer))
214			self.assertEqual(self.scan.uart_port.read.call_args_list[0][0], (1,))
215
216			# if have not connection
217			mock_is_port.reset_mock()
218			mock_proto_num.reset_mock()
219			mock_is_port.return_value = False
220			with self.assertRaises(Exception) as cm:
221			self.scan.receive()
222			self.assertEqual(cm.exception.__str__(), 'Cannot read when unconnected')
223
224			# if connection but nothing were received
225			mock_is_port.reset_mock()
226			mock_proto_num.reset_mock()
227			mock_is_port.return_value = True
228			mock_proto_num.return_value = 5
229			self.scan.uart_port = mock.Mock()
230
231			self.scan.uart_port.read.return_value = b''
232			response = self.scan.receive()
233			self.assertIsInstance(response, Response)
234			self.assertEqual(self.scan.uart_port.read.call_count, 11)
235			self.assertEqual(self.scan.uart_port.read.call_args_list[0][0], (1,))
236
237			@mock.patch('obdlib.scanner.OBDScanner.send')
238			@mock.patch('obdlib.scanner.OBDScanner.is_port')
239			def test_reset(self, mock_is_port, mock_send):
240			mock_is_port.return_value = True
241			self.scan.reset()
242			self.assertEqual(mock_is_port.call_count, 1)
243			self.assertEqual(mock_is_port.call_args_list[0][0], ())
244			self.assertEqual(mock_send.call_count, 1)
245			self.assertEqual(mock_send.call_args_list[0][0], ('ATZ', 1))
246
247			@mock.patch('obdlib.scanner.OBDScanner.receive')
248			@mock.patch('obdlib.scanner.OBDScanner._write')
249			@mock.patch('obdlib.scanner.OBDScanner.is_port')
250			@mock.patch('obdlib.scanner.time.sleep')
251			def test_send(self, mock_sleep, mock_is_port, mock_write, mock_receive):
252			from obdlib.response import Response
253
254			mock_is_port.return_value = True
255			mock_receive.return_value = Response()
256			resp = self.scan.send('0100')
257
258			self.assertEqual(mock_is_port.call_count, 1)
259			self.assertEqual(mock_is_port.call_args_list[0][0], ())
260
261			self.assertEqual(mock_sleep.call_count, 0)
262
263			self.assertEqual(mock_write.call_count, 1)
264			self.assertEqual(mock_write.call_args_list[0][0], ('0100',))
265
266			self.assertEqual(mock_receive.call_count, 1)
267			self.assertEqual(mock_receive.call_args_list[0][0], ())
268
269			self.assertIsInstance(resp, Response)
270
271			mock_is_port.reset_mock()
272			mock_write.reset_mock()
273			mock_receive.reset_mock()
274			resp = self.scan.send('0100', 1)
275
276			self.assertEqual(mock_is_port.call_count, 1)
277			self.assertEqual(mock_is_port.call_args_list[0][0], ())
278
279			self.assertEqual(mock_sleep.call_count, 1)
280			self.assertEqual(mock_sleep.call_args_list[0][0], (1,))
281
282			self.assertEqual(mock_write.call_count, 1)
283			self.assertEqual(mock_write.call_args_list[0][0], ('0100',))
284
285			self.assertEqual(mock_receive.call_count, 1)
286			self.assertEqual(mock_receive.call_args_list[0][0], ())
287
288			self.assertIsInstance(resp, Response)
289
290			def test_vehicle_id_number(self):
291			self.scan.sensor = mock.MagicMock()
292
293			class p(object):
294			@property
295			def gen(self):
296			for ecu, value in {'E8': '2312KJLKJHLKJ43L34323'}.items():
297			yield (ecu, value)
298
299			def mode(a):
300			def pid(n):
301			pid.ecus = p().gen
302			return pid
303
304			return pid
305
306			self.scan.sensor.__getitem__.side_effect = mode
307			vin = self.scan.vehicle_id_number()
308			self.assertEqual(vin, {'E8': '2312KJLKJHLKJ43L34323'})
309
310			@mock.patch('sys.stdout')
311			@mock.patch('obdlib.scanner.OBDScanner.send')
312			def test_clear_trouble_codes(self, mock_send, mock_out):
313			def send(data):
314			class r_v():
315			raw_value = value
316
317			return r_v
318
319			# Return OK
320			value = ['OK']
321			mock_send.side_effect = send
322			resp = self.scan.clear_trouble_codes()
323
324			self.assertEqual(mock_send.call_count, 1)
325			self.assertEqual(mock_send.call_args_list[0][0], ('04',))
326
327			self.assertIsNone(resp)
328
329			# Do not return OK
330			mock_send.reset_mock()
331			value = ['?']
332			mock_send.side_effect = send
333			resp = self.scan.clear_trouble_codes()
334
335			self.assertEqual(mock_send.call_count, 1)
336			self.assertEqual(mock_send.call_args_list[0][0], ('04',))
337
338			self.assertIsNone(resp)
339
340			@mock.patch('obdlib.scanner.OBDScanner.send')
341			def test_echo_off(self, mock_send):
342			def send(data):
343			class r_v():
344			raw_value = value
345
346			return r_v
347
348			value = ['OK']
349			mock_send.side_effect = send
350			resp = self.scan.echo_off()
351			self.assertEqual(mock_send.call_count, 1)
352			self.assertEqual(mock_send.call_args_list[0][0], ('ATE0',))
353			self.assertEqual(resp, ['OK'])
354
355			def test__check_response(self):
356			resp = self.scan._check_response(['OK'])
357			self.assertTrue(resp)
358
359			resp = self.scan._check_response(['?'])
360			self.assertFalse(resp)
361
362			def test__write(self):
363			self.scan.uart_port = mock.Mock()
364			self.scan._write('ATH1')
365
366			self.assertEqual(self.scan.uart_port.flushOutput.call_count, 1)
367			self.assertEqual(self.scan.uart_port.flushOutput.call_args_list[0][0], ())
368
369			self.assertEqual(self.scan.uart_port.flushInput.call_count, 1)
370			self.assertEqual(self.scan.uart_port.flushInput.call_args_list[0][0], ())
371
372			self.assertEqual(self.scan.uart_port.write.call_count, 1)
373			self.assertEqual(self.scan.uart_port.write.call_args_list[0][0], (b'ATH1\r\n',))
374
375
376			if __name__ == '__main__':
377			suite = unittest.TestLoader().loadTestsFromTestCase(TestOBDScanner)
378			unittest.TextTestRunner(verbosity=2).run(suite)
379
380

s-s-boika / obdlib

p A last analyzed 2017-02-09 09:22 UTC

Complexity

Size/Duplication

Importance

Duplication Side-by-Side

Filter issues like

p A
last analyzed 2017-02-09 09:22 UTC