All tests for clf.sense() method.

src/nfc/clf/__init__.py

@@ -863,7 +863,7 @@ def sense_dep(target):
                         if self.target is not None:
                             log.debug("found {0}".format(self.target))
                             return self.target
-                if len(targets):
+                if len(targets) > 0:
                     self.device.mute()  # deactivate the rf field
                 if i < options.get('iterations', 1) - 1:
                     elapsed = time.time() - started

tests/test_clf_init.py

@@ -15,7 +15,7 @@
 
 
 def HEX(s):
-    return bytearray.fromhex(s)
+    return bytearray.fromhex(s) if s is not None else None
 
 
 def test_print_data():
@@ -40,11 +40,19 @@ def clf(self, device_connect, device):
         device_connect.assert_called_once_with('test')
         assert isinstance(clf, nfc.clf.ContactlessFrontend)
         assert isinstance(clf.device, nfc.clf.device.Device)
+        clf.device.sense_tta.return_value = None
+        clf.device.sense_ttb.return_value = None
+        clf.device.sense_ttf.return_value = None
+        clf.device.sense_dep.return_value = None
+        clf.device.listen_tta.return_value = None
+        clf.device.listen_ttb.return_value = None
+        clf.device.listen_ttf.return_value = None
+        clf.device.listen_dep.return_value = None
         return clf
 
     @pytest.fixture()  # noqa: F811
     def terminate(self, mocker):
-        return mocker.Mock(return_value=True)
+        return mocker.Mock(return_value=False)
 
     def test_init(self, device_connect):
         device_connect.return_value = None
@@ -71,6 +79,10 @@ def test_close(self, clf):
         clf.device.close.side_effect = IOError
         clf.close()
 
+    #
+    # CONNECT
+    #
+
     def test_connect_without_device(self, clf):
         clf.device = None
         with pytest.raises(IOError) as excinfo:
@@ -96,32 +108,22 @@ def test_connect_with_startup_false(self, clf):
         assert clf.connect(card={'on-startup': lambda llc: False}) is None
 
     def test_connect_with_terminate_true(self, clf, terminate):
+        terminate.return_value = True
         assert clf.connect(llcp={}, terminate=terminate) is None
         assert clf.connect(rdwr={}, terminate=terminate) is None
         assert clf.connect(card={}, terminate=terminate) is None
 
     def test_connect_llcp_initiator(self, clf, terminate):
         terminate.side_effect = [False, True]
-        clf.device.sense_tta.return_value = None
-        clf.device.sense_ttb.return_value = None
-        clf.device.sense_ttf.return_value = None
-        clf.device.sense_dep.return_value = None
-        llcp_options = {'role': 'initiator'}
-        assert clf.connect(llcp=llcp_options, terminate=terminate) is None
+        assert clf.connect(llcp={}, terminate=terminate) is None
 
     def test_connect_rdwr_defaults(self, clf, terminate):
         terminate.side_effect = [False, True]
-        clf.device.sense_tta.return_value = None
-        clf.device.sense_ttb.return_value = None
-        clf.device.sense_ttf.return_value = None
         rdwr_options = {'iterations': 1}
         assert clf.connect(rdwr=rdwr_options, terminate=terminate) is None
 
     def test_connect_card_defaults(self, clf, terminate):
         terminate.side_effect = [False, True]
-        clf.device.listen_tta.return_value = None
-        clf.device.listen_ttb.return_value = None
-        clf.device.listen_ttf.return_value = None
         card_options = {'on-startup': lambda _: nfc.clf.LocalTarget('212F')}
         assert clf.connect(card=card_options, terminate=terminate) is None
 
@@ -136,6 +138,111 @@ def test_connect_false_on_error(self, clf, error):
         llcp_options = {'role': 'initiator'}
         assert clf.connect(llcp=llcp_options) is False
 
+    def test_connect_rdwr_found_tta_target(self, clf, terminate):
+        terminate.side_effect = [False, True]
+        target = nfc.clf.RemoteTarget('106A')
+        target.rid_res = HEX('1148 B2565400')
+        target.sens_res = HEX('000C')
+        clf.device.sense_tta.return_value = target
+        rdwr_options = {'iterations': 1, 'targets': ['106A']}
+        assert clf.connect(rdwr=rdwr_options, terminate=terminate) is True
+
+    #
+    # SENSE
+    #
+
+    def test_sense_without_targets(self, clf):
+        assert clf.sense() is None
+
+    def test_sense_without_device(self, clf):
+        clf.device = None
+        with pytest.raises(IOError) as excinfo:
+            clf.sense(nfc.clf.RemoteTarget('106A'))
+        assert excinfo.value.errno == errno.ENODEV
+
+    def test_sense_with_invalid_targets(self, clf):
+        with pytest.raises(ValueError) as excinfo:
+            clf.sense(nfc.clf.RemoteTarget('106A'), nfc.clf.LocalTarget())
+        assert str(excinfo.value).startswith("invalid target argument type")
+
+    def test_sense_with_unknown_technology(self, clf):
+        valid_target = nfc.clf.RemoteTarget('106A')
+        wrong_target = nfc.clf.RemoteTarget('106X')
+        with pytest.raises(nfc.clf.UnsupportedTargetError) as excinfo:
+            clf.sense(wrong_target)
+        assert str(excinfo.value) == "unknown technology type in '106X'"
+        assert clf.sense(wrong_target, valid_target) is None
+        clf.device.sense_tta.assert_called_once_with(valid_target)
+
+    def test_sense_with_communication_error(self, clf):
+        clf.device.sense_tta.side_effect = nfc.clf.CommunicationError
+        target = nfc.clf.RemoteTarget('106A')
+        assert clf.sense(target) is None
+        clf.device.sense_tta.assert_called_once_with(target)
+
+    @pytest.mark.parametrize("sens, sel, sdd, rid", [
+        ('000C', None, None, '1148B2565400'),
+        ('4400', '00', '0416C6C2D73881', None),
+        ('E00C', '00', '0416C6C2D73881', '1148B2565400'),
+    ])
+    def test_sense_tta_found_valid_target(self, clf, sens, sel, sdd, rid):
+        req_target = nfc.clf.RemoteTarget('106A')
+        res_target = nfc.clf.RemoteTarget('106A')
+        res_target.sens_res = HEX(sens)
+        res_target.sel_res = HEX(sel)
+        res_target.sdd_res = HEX(sdd)
+        res_target.rid_res = HEX(rid)
+        clf.device.sense_tta.return_value = res_target
+        res_target = clf.sense(req_target)
+        assert isinstance(res_target, nfc.clf.RemoteTarget)
+        clf.device.sense_tta.assert_called_once_with(req_target)
+
+    @pytest.mark.parametrize("sens, sel, sdd, rid", [
+        ('E00C', '00', '0416C6C2D73881', '000000000000'),
+        ('E00C', '00', '0416C6C2D73881', '0000000000'),
+        ('E00C', '00', '0416C6C2D73881', None),
+        ('E000', '00', '0416C6C2D73881', '100000000000'),
+        ('E00000', '00', '0416C6C2D73881', None),
+        ('E0', '00', '0416C6C2D73881', None),
+    ])
+    def test_sense_tta_found_error_target(self, clf, sens, sel, sdd, rid):
+        req_target = nfc.clf.RemoteTarget('106A')
+        res_target = nfc.clf.RemoteTarget('106A')
+        res_target.sens_res = HEX(sens)
+        res_target.sel_res = HEX(sel)
+        res_target.sdd_res = HEX(sdd)
+        res_target.rid_res = HEX(rid)
+        clf.device.sense_tta.return_value = res_target
+        assert clf.sense(req_target) is None
+        clf.device.sense_tta.assert_called_once_with(req_target)
+
+    def test_sense_tta_invalid_sel_req(self, clf):
+        target = nfc.clf.RemoteTarget('106A')
+        target.sel_req = HEX('0011')
+        with pytest.raises(ValueError) as excinfo:
+            clf.sense(target)
+        assert str(excinfo.value) == "sel_req must be 4, 7, or 10 byte"
+
+    def test_sense_dep_invalid_atr_req(self, clf):
+        target = nfc.clf.RemoteTarget('106A')
+        target.atr_req = bytearray(15)
+        with pytest.raises(ValueError) as excinfo:
+            clf.sense(target)
+        assert str(excinfo.value) == "minimum atr_req length is 16 byte"
+        target.atr_req = bytearray(65)
+        with pytest.raises(ValueError) as excinfo:
+            clf.sense(target)
+        assert str(excinfo.value) == "maximum atr_req length is 64 byte"
+
+    def test_sense_ttb_found_tt4_target(self, clf):
+        req_target = nfc.clf.RemoteTarget('106B')
+        res_target = nfc.clf.RemoteTarget('106B')
+        res_target.sensb_res = HEX('50E8253EEC00000011008185')
+        clf.device.sense_ttb.return_value = res_target
+        res_target = clf.sense(req_target)
+        assert isinstance(res_target, nfc.clf.RemoteTarget)
+        clf.device.sense_ttb.assert_called_once_with(req_target)
+
 
 class TestRemoteTarget(object):
     @pytest.mark.parametrize("brty, send, recv, kwargs", [