updated tests

test_helper.py

@@ -1,24 +1,14 @@
-import json
 import glob
+import json
 import os
 
 
 def load_fixtures(test_case):
-    tests = []
+    tests = [] 
     fixture_path = 'testdata/' + test_case + "/2DCode/raw/*.json"
     print("Loading test data from: " + fixture_path)
     for filename in glob.glob(fixture_path):
         with open(os.path.join(os.getcwd(), filename), 'r') as f:
-            tests.append(json.load(f))
+            tests.append((filename, json.load(f)))
 
     return tests
-
-
-def create_certdata_from_str(string):
-    every = 64
-    lines = []
-    for i in range(0, len(string), every):
-        lines.append(string[i:i+every])
-    data = '\n'.join(lines)
-    data = "-----BEGIN CERTIFICATE-----\n" + data + "\n-----END CERTIFICATE-----"
-    return data.encode()

test_occv.py

@@ -2,9 +2,9 @@
 
 from fastapi.testclient import TestClient
 
-from occv import DEV_MODE, app
+from occv import app
 
-DEV_MODE = True;
+DEV_MODE = True
 
 client = TestClient(app)
 

test_validator.py

@@ -1,13 +1,14 @@
-from datetime import datetime
 import json
 import unittest
+from datetime import datetime
+
 import dateutil
-from cert_loaders.helper import create_cose_key
+from cwt.helpers.hcert import load_pem_hcert_dsc
+from freezegun import freeze_time
 
+from cert_loaders.helper import create_chunked_cert
+from test_helper import load_fixtures
 from validator import DCCValidator
-from test_helper import load_fixtures, create_certdata_from_str
-from cryptography.x509 import load_pem_x509_certificate
-from freezegun import freeze_time
 
 
 class DCCTests(unittest.TestCase):
@@ -16,57 +17,66 @@ def test_generator(self):
         """
         Generate test cases
         """
-        test_countries = ["AE", "BE", "BG", "CY", "CZ", "DE", "DK", "EE", "FI",
-                          "GB", "GR", "HR", "IE", "IT", "LU", "LV", "MT", "NL",
-                          "PL", "PT", "RO", "SI", "SK", "SM", "common"]
+        test_countries = ["AE", "BE", "BG", "CH", "CY", "CZ", "DE", "DK", "EE", "ES", "FI", "FR", "GE",  "GB", "GR", "HR", "HU", "IE",
+                          "IS", "IT", "LI", "LT", "LU", "LV", "MA", "MT", "NL", "NO", "PL", "PT", "RO", "SE", "SG", "SI", "SK", "SM", "UA", "VA", "common"]
         for test_country in test_countries:
             test_fixtures = load_fixtures(test_country)
             for test_case in test_fixtures:
-                print("TESTING: " + test_country)
-                test_description = test_case["TESTCTX"].get(
+                test_filename = test_case[0]
+                test_data = test_case[1]
+                test_description = test_data["TESTCTX"].get(
                     "DESCRIPTION",
                     "DESCRIPTION MISSING")
-                test_time = test_case["TESTCTX"].get("VALIDATIONCLOCK")
-                test_time = dateutil.parser.parse(test_time)
 
-                test_expected_results = test_case.get("EXPECTEDRESULTS")
-                test_title = test_country + ": " + test_description
-                with self.subTest(test_title, test_case=test_case):
+                try:
+                    test_title = test_filename + "\nDESCRIPTION: " + test_description
+                except:
+                    test_title = test_filename
+                with self.subTest(test_title, test_data=test_data):
+                    test_time = test_data["TESTCTX"].get("VALIDATIONCLOCK")
+                    test_time = dateutil.parser.parse(test_time)
                     with freeze_time(test_time):
                         self.maxDiff = None
-                        test_dcc = test_case.get("PREFIX")
+                        print("TESTING: " + test_title)
+                        print("TESTTIME: " + str(datetime.now()))
+                        test_expected_results = test_data.get(
+                            "EXPECTEDRESULTS")
+                        test_dcc = test_data.get("PREFIX")
                         test_verify = test_expected_results.get(
-                            "EXPECTEDVERIFY",
-                            False)
+                            "EXPECTEDVERIFY"
+                            )
+                        test_decode = test_expected_results.get(
+                            "EXPECTEDDECODE"                            )
                         print("Expected to verify: " + str(test_verify))
+                        print("Expected to decode: " + str(test_decode))
                         print("Simulated time: " + datetime.now().isoformat())
-                        if (not test_verify):
-                            continue
-                        test_cert_data = create_certdata_from_str(
-                            test_case["TESTCTX"]["CERTIFICATE"])
                         certs = []
-                        x509 = load_pem_x509_certificate(test_cert_data)
-                        certs.append(create_cose_key(x509))
+                        cert_data = create_chunked_cert(
+                            test_data["TESTCTX"]["CERTIFICATE"])
+                        certs.append(load_pem_hcert_dsc(cert_data))
 
                         dcc_validator = DCCValidator(
                             country="XX", certs=certs, dev_mode=False)
-                        valid = False
+                        valid = None
                         content = None
-                        cert_data = None
+                        hcert = None
                         valid, content = dcc_validator.validate(test_dcc)
                         self.assertIsNotNone(content)
+                        if (test_verify is not None):
+                            if (test_verify):
+                                self.assertTrue(valid)
+                            else:
+                                self.assertFalse(valid)
 
-                        if (test_verify):
-                            self.assertTrue(valid)
-                            test_json = test_case.get("JSON")
-                            cert_data = content[-260][1]
-                            self.assertEqual(cert_data, test_json)
-                        else:
-                            self.assertFalse(valid)
+                        if (test_decode is not None):
+                            if (test_decode):
+                                test_json = test_data.get("JSON")
+                                hcert = content[-260][1]
+                                self.assertEqual(hcert, test_json)
 
                         print("VALID:   " + str(valid))
                         print("CONTENT: " + json.dumps(content))
-                        print("CERT: " + json.dumps(cert_data))
+                        print("CERT: " + json.dumps(hcert))
                         print("JSON: " + json.dumps(test_json))