Don't check for udev rules in unit tests

bessman · bessman · commit 7fb518392499 · 2020-10-13T11:45:47.000+02:00
diff --git a/tests/test_packet_handler.py b/tests/test_packet_handler.py
@@ -23,140 +23,134 @@ def mock_serial(mocker):
     return serial_patch
 
 
+@pytest.fixture
+def mock_handler(mocker, mock_serial):
+    mocker.patch("PSL.packet_handler.Handler._check_udev")
+    return Handler()
+
+
 @pytest.fixture
 def mock_list_ports(mocker):
     return mocker.patch("PSL.packet_handler.list_ports")
 
 
-def test_connect_scan_port(mock_serial, mock_list_ports):
+def test_connect_scan_port(mocker, mock_serial, mock_list_ports):
     mock_serial().is_open = False
     mock_list_ports.grep.return_value = mock_ListPortInfo()
+    mocker.patch("PSL.packet_handler.Handler._check_udev")
     Handler()
     mock_serial().open.assert_called()
 
 
-def test_connect_scan_failure(mock_serial, mock_list_ports):
+def test_connect_scan_failure(mocker, mock_serial, mock_list_ports):
     mock_serial().is_open = False
     mock_list_ports.grep.return_value = mock_ListPortInfo(found=False)
+    mocker.patch("PSL.packet_handler.Handler._check_udev")
     with pytest.raises(SerialException):
         Handler()
 
 
-def test_disconnect(mock_serial):
-    H = Handler()
-    H.disconnect()
+def test_disconnect(mock_serial, mock_handler):
+    mock_handler.disconnect()
     mock_serial().close.assert_called()
 
 
-def test_reconnect(mock_serial):
-    H = Handler()
-    H.reconnect()
+def test_reconnect(mock_serial, mock_handler):
+    mock_handler.reconnect()
     mock_serial().close.assert_called()
 
 
-def test_get_version(mock_serial):
-    H = Handler()
+def test_get_version(mock_serial, mock_handler):
+    mock_handler.get_version()
     mock_serial().write.assert_called_with(CP.GET_VERSION)
-    assert H.version == VERSION
+    assert mock_handler.version == VERSION
 
 
-def test_get_ack_success(mock_serial):
+def test_get_ack_success(mock_serial, mock_handler):
     H = Handler()
     success = 1
     mock_serial().read.return_value = CP.Byte.pack(success)
     assert H.get_ack() == success
 
 
-def test_get_ack_burst_mode(mock_serial):
-    H = Handler()
+def test_get_ack_burst_mode(mock_serial, mock_handler):
     success = 1
-    H.load_burst = True
-    queue_size = H.input_queue_size
+    mock_handler.load_burst = True
+    queue_size = mock_handler.input_queue_size
     mock_serial().read.return_value = b""
 
-    assert H.get_ack() == success
-    assert H.input_queue_size == queue_size + 1
+    assert mock_handler.get_ack() == success
+    assert mock_handler.input_queue_size == queue_size + 1
 
 
-def test_get_ack_failure(mock_serial):
-    H = Handler()
+def test_get_ack_failure(mock_serial, mock_handler):
     error = 3
     mock_serial().read.return_value = b""
-    assert H.get_ack() == error
+    assert mock_handler.get_ack() == error
 
 
-def test_send_bytes(mock_serial):
-    H = Handler()
-    H.send_byte(CP.Byte.pack(0xFF))
+def test_send_bytes(mock_serial, mock_handler):
+    mock_handler.send_byte(CP.Byte.pack(0xFF))
     mock_serial().write.assert_called_with(CP.Byte.pack(0xFF))
 
 
-def test_send_byte(mock_serial):
-    H = Handler()
-    H.send_byte(0xFF)
+def test_send_byte(mock_serial, mock_handler):
+    mock_handler.send_byte(0xFF)
     mock_serial().write.assert_called_with(CP.Byte.pack(0xFF))
 
 
-def test_send_byte_burst_mode(mock_serial):
-    H = Handler()
-    H.load_burst = True
-    H.send_byte(0xFF)
-    assert H.burst_buffer == CP.Byte.pack(0xFF)
+def test_send_byte_burst_mode(mock_serial, mock_handler):
+    mock_handler.load_burst = True
+    mock_handler.send_byte(0xFF)
+    assert mock_handler.burst_buffer == CP.Byte.pack(0xFF)
 
 
-def test_receive(mock_serial):
-    H = Handler()
+def test_receive(mock_serial, mock_handler):
     mock_serial().read.return_value = CP.Byte.pack(0xFF)
-    r = H.get_byte()
+    r = mock_handler.get_byte()
     mock_serial().read.assert_called_with(1)
     assert r == 0xFF
 
 
-def test_receive_failure(mock_serial):
-    H = Handler()
+def test_receive_failure(mock_serial, mock_handler):
     mock_serial().read.return_value = b""
-    r = H.get_byte()
+    r = mock_handler.get_byte()
     mock_serial().read.assert_called_with(1)
     assert r == -1
 
 
-def test_wait_for_data(mock_serial):
-    H = Handler()
+def test_wait_for_data(mock_serial, mock_handler):
     mock_serial().in_waiting = True
-    assert H.wait_for_data()
+    assert mock_handler.wait_for_data()
 
 
-def test_wait_for_data_timeout(mock_serial):
-    H = Handler()
+def test_wait_for_data_timeout(mock_serial, mock_handler):
     mock_serial().in_waiting = False
-    assert not H.wait_for_data()
+    assert not mock_handler.wait_for_data()
 
 
-def test_send_burst(mock_serial):
-    H = Handler()
-    H.load_burst = True
+def test_send_burst(mock_serial, mock_handler):
+    mock_handler.load_burst = True
 
     for b in b"abc":
-        H.send_byte(b)
-        H.get_ack()
+        mock_handler.send_byte(b)
+        mock_handler.get_ack()
 
     mock_serial().read.return_value = b"\x01\x01\x01"
-    acks = H.send_burst()
+    acks = mock_handler.send_burst()
 
     mock_serial().write.assert_called_with(b"abc")
     mock_serial().read.assert_called_with(3)
-    assert not H.load_burst
-    assert H.burst_buffer == b""
-    assert H.input_queue_size == 0
+    assert not mock_handler.load_burst
+    assert mock_handler.burst_buffer == b""
+    assert mock_handler.input_queue_size == 0
     assert acks == [1, 1, 1]
 
 
-def test_get_integer_unsupported_size(mock_serial):
-    H = Handler()
+def test_get_integer_unsupported_size(mock_serial, mock_handler):
     with pytest.raises(ValueError):
-        H._get_integer_type(size=3)
+        mock_handler._get_integer_type(size=3)
 
 
-def test_list_ports(mock_serial):
-    H = Handler()
-    assert isinstance(H._list_ports(), list)
+def test_list_ports(mock_serial, mock_handler):
+    assert isinstance(mock_handler._list_ports(), list)
