Merge pull request #329 from crocs-muni/feat/cert-entry-mapping

Add CC scheme and FIPS IUT/MIP matching

21 files changed, 602 insertions, 451 deletions

diff --git a/tests/cc/__init__.py b/tests/cc/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/tests/cc/__init__.py
diff --git a/tests/cc/conftest.py b/tests/cc/conftest.py
new file mode 100644
index 00000000..8d5d388a
--- /dev/null
+++ b/tests/cc/conftest.py
@@ -0,0 +1,90 @@
+import shutil
+from datetime import date
+from pathlib import Path
+
+import pytest
+
+import tests.data.cc.analysis
+import tests.data.cc.certificate
+import tests.data.cc.dataset
+from sec_certs.dataset.cc import CCDataset
+from sec_certs.sample.cc import CCCertificate, ProtectionProfile
+
+
+@pytest.fixture(scope="module")
+def dataset_data_dir() -> Path:
+    return Path(tests.data.cc.dataset.__path__[0])
+
+
+@pytest.fixture
+def toy_dataset(dataset_data_dir: Path) -> CCDataset:
+    return CCDataset.from_json(dataset_data_dir / "toy_dataset.json")
+
+
+@pytest.fixture(scope="module")
+def cert_data_dir() -> Path:
+    return Path(tests.data.cc.certificate.__path__[0])
+
+
+@pytest.fixture(scope="module")
+def vulnerable_certificate(tmp_path_factory) -> CCCertificate:
+    tmp_dir = tmp_path_factory.mktemp("dset")
+    dset_json_path = Path(tests.data.cc.analysis.__path__[0]) / "vulnerable_dataset.json"
+    data_dir_path = dset_json_path.parent
+    shutil.copytree(data_dir_path, tmp_dir, dirs_exist_ok=True)
+    cc_dset = CCDataset.from_json(tmp_dir / "vulnerable_dataset.json")
+    cc_dset.download_all_artifacts()
+    cc_dset.convert_all_pdfs()
+
+    return list(cc_dset.certs.values())[0]
+
+
+@pytest.fixture(scope="module")
+def cert_one() -> CCCertificate:
+    return CCCertificate(
+        "active",
+        "Access Control Devices and Systems",
+        "NetIQ Identity Manager 4.7",
+        "NetIQ Corporation",
+        "SE",
+        {"ALC_FLR.2", "EAL3+"},
+        date(2020, 6, 15),
+        date(2025, 6, 15),
+        "https://www.commoncriteriaportal.org/files/epfiles/Certification%20Report%20-%20NetIQ®%20Identity%20Manager%204.7.pdf",
+        "https://www.commoncriteriaportal.org/files/epfiles/ST%20-%20NetIQ%20Identity%20Manager%204.7.pdf",
+        "https://www.commoncriteriaportal.org/files/epfiles/Certifikat%20CCRA%20-%20NetIQ%20Identity%20Manager%204.7_signed.pdf",
+        "https://www.netiq.com/",
+        set(),
+        set(),
+        None,
+        None,
+        None,
+    )
+
+
+@pytest.fixture(scope="module")
+def cert_two() -> CCCertificate:
+    pp = ProtectionProfile("sample_pp", None, pp_link="https://sample.pp")
+    update = CCCertificate.MaintenanceReport(
+        date(1900, 1, 1), "Sample maintenance", "https://maintenance.up", "https://maintenance.up"
+    )
+
+    return CCCertificate(
+        "archived",
+        "Sample category",
+        "Sample certificate name",
+        "Sample manufacturer",
+        "Sample scheme",
+        {"Sample security level"},
+        date(1900, 1, 2),
+        date(1900, 1, 3),
+        "https://path.to/report/link",
+        "https://path.to/st/link",
+        "https://path.to/cert/link",
+        "https://path.to/manufacturer/web",
+        {pp},
+        {update},
+        None,
+        None,
+        None,
+    )
diff --git a/tests/cc/test_cc_analysis.py b/tests/cc/test_cc_analysis.py
index a5088338..45b4214e 100644
--- a/tests/cc/test_cc_analysis.py
+++ b/tests/cc/test_cc_analysis.py
@@ -4,11 +4,11 @@ import shutil
 from pathlib import Path
 
 import pytest
-import tests.data.cc.analysis
 from dateutil.parser import isoparse
 
+import tests.data.cc.analysis
 from sec_certs.cert_rules import SARS_IMPLIED_FROM_EAL
-from sec_certs.dataset import CCDataset
+from sec_certs.dataset.cc import CCDataset
 from sec_certs.dataset.cpe import CPEDataset
 from sec_certs.dataset.cve import CVEDataset
 from sec_certs.sample.cc import CCCertificate
diff --git a/tests/cc/test_cc_certificate.py b/tests/cc/test_cc_certificate.py
index 2a5ff222..35482e8a 100644
--- a/tests/cc/test_cc_certificate.py
+++ b/tests/cc/test_cc_certificate.py
@@ -1,84 +1,7 @@
 import json
-import shutil
-from datetime import date
 from pathlib import Path
 
-import pytest
-import tests.data.cc.analysis
-import tests.data.cc.certificate
-
-from sec_certs.dataset import CCDataset
-from sec_certs.sample import CCCertificate
-from sec_certs.sample.protection_profile import ProtectionProfile
-
-
-@pytest.fixture(scope="module")
-def data_dir() -> Path:
-    return Path(tests.data.cc.certificate.__path__[0])
-
-
-@pytest.fixture(scope="module")
-def vulnerable_certificate(tmp_path_factory) -> CCCertificate:
-    tmp_dir = tmp_path_factory.mktemp("dset")
-    dset_json_path = Path(tests.data.cc.analysis.__path__[0]) / "vulnerable_dataset.json"
-    data_dir_path = dset_json_path.parent
-    shutil.copytree(data_dir_path, tmp_dir, dirs_exist_ok=True)
-    cc_dset = CCDataset.from_json(tmp_dir / "vulnerable_dataset.json")
-    cc_dset.download_all_artifacts()
-    cc_dset.convert_all_pdfs()
-
-    return list(cc_dset.certs.values())[0]
-
-
-@pytest.fixture(scope="module")
-def cert_one() -> CCCertificate:
-    return CCCertificate(
-        "active",
-        "Access Control Devices and Systems",
-        "NetIQ Identity Manager 4.7",
-        "NetIQ Corporation",
-        "SE",
-        {"ALC_FLR.2", "EAL3+"},
-        date(2020, 6, 15),
-        date(2025, 6, 15),
-        "https://www.commoncriteriaportal.org/files/epfiles/Certification%20Report%20-%20NetIQ®%20Identity%20Manager%204.7.pdf",
-        "https://www.commoncriteriaportal.org/files/epfiles/ST%20-%20NetIQ%20Identity%20Manager%204.7.pdf",
-        "https://www.commoncriteriaportal.org/files/epfiles/Certifikat%20CCRA%20-%20NetIQ%20Identity%20Manager%204.7_signed.pdf",
-        "https://www.netiq.com/",
-        set(),
-        set(),
-        None,
-        None,
-        None,
-    )
-
-
-@pytest.fixture(scope="module")
-def cert_two() -> CCCertificate:
-    pp = ProtectionProfile("sample_pp", None, pp_link="https://sample.pp")
-    update = CCCertificate.MaintenanceReport(
-        date(1900, 1, 1), "Sample maintenance", "https://maintenance.up", "https://maintenance.up"
-    )
-
-    return CCCertificate(
-        "archived",
-        "Sample category",
-        "Sample certificate name",
-        "Sample manufacturer",
-        "Sample scheme",
-        {"Sample security level"},
-        date(1900, 1, 2),
-        date(1900, 1, 3),
-        "https://path.to/report/link",
-        "https://path.to/st/link",
-        "https://path.to/cert/link",
-        "https://path.to/manufacturer/web",
-        {pp},
-        {update},
-        None,
-        None,
-        None,
-    )
+from sec_certs.sample.cc import CCCertificate
 
 
 def test_extract_metadata(vulnerable_certificate: CCCertificate):
@@ -118,18 +41,18 @@ def test_cert_link_escaping(cert_one: CCCertificate):
     )
 
 
-def test_cert_to_json(cert_two: CCCertificate, tmp_path: Path, data_dir: Path):
+def test_cert_to_json(cert_two: CCCertificate, tmp_path: Path, cert_data_dir: Path):
     cert_two.to_json(tmp_path / "crt_two.json")
 
     with (tmp_path / "crt_two.json").open("r") as handle:
         data = json.load(handle)
 
-    with (data_dir / "fictional_cert.json").open("r") as handle:
+    with (cert_data_dir / "fictional_cert.json").open("r") as handle:
         template_data = json.load(handle)
 
     assert data == template_data
 
 
-def test_cert_from_json(cert_two: CCCertificate, data_dir: Path):
-    crt = CCCertificate.from_json(data_dir / "fictional_cert.json")
+def test_cert_from_json(cert_two: CCCertificate, cert_data_dir: Path):
+    crt = CCCertificate.from_json(cert_data_dir / "fictional_cert.json")
     assert cert_two == crt
diff --git a/tests/cc/test_cc_dataset.py b/tests/cc/test_cc_dataset.py
index 2b37c2f8..43749494 100644
--- a/tests/cc/test_cc_dataset.py
+++ b/tests/cc/test_cc_dataset.py
@@ -1,51 +1,16 @@
 import json
 import shutil
-from datetime import date
 from pathlib import Path
 from tempfile import TemporaryDirectory
 
 import pytest
-import tests.data.cc.dataset
 
 from sec_certs import constants
-from sec_certs.dataset import CCDataset
+from sec_certs.dataset.cc import CCDataset
 from sec_certs.sample.cc import CCCertificate
 
 
-@pytest.fixture(scope="module")
-def data_dir() -> Path:
-    return Path(tests.data.cc.dataset.__path__[0])
-
-
-@pytest.fixture(scope="module")
-def crt() -> CCCertificate:
-    return CCCertificate(
-        "active",
-        "Access Control Devices and Systems",
-        "NetIQ Identity Manager 4.7",
-        "NetIQ Corporation",
-        "SE",
-        {"ALC_FLR.2", "EAL3+"},
-        date(2020, 6, 15),
-        date(2025, 6, 15),
-        "https://www.commoncriteriaportal.org/files/epfiles/Certification%20Report%20-%20NetIQ®%20Identity%20Manager%204.7.pdf",
-        "https://www.commoncriteriaportal.org/files/epfiles/ST%20-%20NetIQ%20Identity%20Manager%204.7.pdf",
-        "https://www.commoncriteriaportal.org/files/epfiles/Certifikat%20CCRA%20-%20NetIQ%20Identity%20Manager%204.7_signed.pdf",
-        "https://www.netiq.com/",
-        set(),
-        set(),
-        None,
-        None,
-        None,
-    )
-
-
-@pytest.fixture
-def toy_dataset(data_dir: Path) -> CCDataset:
-    return CCDataset.from_json(data_dir / "toy_dataset.json")
-
-
-def test_download_and_convert_pdfs(toy_dataset: CCDataset, data_dir: Path):
+def test_download_and_convert_pdfs(toy_dataset: CCDataset, dataset_data_dir: Path):
     template_report_pdf_hashes = {
         "309ac2fd7f2dcf17": "774c41fbba980191ca40ae610b2f61484c5997417b3325b6fd68b345173bde52",
         "8cf86948f02f047d": "533a5995ef8b736cc48cfda30e8aafec77d285511471e0e5a9e8007c8750203a",
@@ -84,8 +49,8 @@ def test_download_and_convert_pdfs(toy_dataset: CCDataset, data_dir: Path):
             assert cert.state.report_txt_path.exists()
             assert cert.state.st_txt_path.exists()
 
-        template_report_txt_path = data_dir / "report_309ac2fd7f2dcf17.txt"
-        template_st_txt_path = data_dir / "target_309ac2fd7f2dcf17.txt"
+        template_report_txt_path = dataset_data_dir / "report_309ac2fd7f2dcf17.txt"
+        template_st_txt_path = dataset_data_dir / "target_309ac2fd7f2dcf17.txt"
         assert (
             abs(toy_dataset["309ac2fd7f2dcf17"].state.st_txt_path.stat().st_size - template_st_txt_path.stat().st_size)
             < 1000
@@ -99,13 +64,13 @@ def test_download_and_convert_pdfs(toy_dataset: CCDataset, data_dir: Path):
         )
 
 
-def test_dataset_to_json(toy_dataset: CCDataset, data_dir: Path, tmp_path: Path):
+def test_dataset_to_json(toy_dataset: CCDataset, dataset_data_dir: Path, tmp_path: Path):
     toy_dataset.to_json(tmp_path / "dset.json")
 
     with (tmp_path / "dset.json").open("r") as handle:
         data = json.load(handle)
 
-    with (data_dir / "toy_dataset.json").open("r") as handle:
+    with (dataset_data_dir / "toy_dataset.json").open("r") as handle:
         template_data = json.load(handle)
 
     del data["timestamp"]
@@ -113,8 +78,8 @@ def test_dataset_to_json(toy_dataset: CCDataset, data_dir: Path, tmp_path: Path)
     assert data == template_data
 
 
-def test_dataset_from_json(toy_dataset: CCDataset, data_dir: Path):
-    assert toy_dataset == CCDataset.from_json(data_dir / "toy_dataset.json")
+def test_dataset_from_json(toy_dataset: CCDataset, dataset_data_dir: Path):
+    assert toy_dataset == CCDataset.from_json(dataset_data_dir / "toy_dataset.json")
 
 
 def test_build_empty_dataset():
@@ -128,12 +93,12 @@ def test_build_empty_dataset():
     assert not dset.state.certs_analyzed
 
 
-def test_build_dataset(data_dir: Path, crt: CCCertificate, toy_dataset: CCDataset):
+def test_build_dataset(dataset_data_dir: Path, cert_one: CCCertificate, toy_dataset: CCDataset):
     with TemporaryDirectory() as tmp_dir:
         dataset_path = Path(tmp_dir)
         (dataset_path / "web").mkdir()
-        shutil.copyfile(data_dir / "cc_products_active.csv", dataset_path / "web" / "cc_products_active.csv")
-        shutil.copyfile(data_dir / "cc_products_active.html", dataset_path / "web" / "cc_products_active.html")
+        shutil.copyfile(dataset_data_dir / "cc_products_active.csv", dataset_path / "web" / "cc_products_active.csv")
+        shutil.copyfile(dataset_data_dir / "cc_products_active.html", dataset_path / "web" / "cc_products_active.html")
 
         dset = CCDataset({}, dataset_path, "sample_dataset", "sample dataset description")
         dset.get_certs_from_web(
@@ -142,7 +107,7 @@ def test_build_dataset(data_dir: Path, crt: CCCertificate, toy_dataset: CCDatase
 
         assert len(list(dataset_path.iterdir())) == 0
         assert len(dset) == 3
-        assert crt in dset
+        assert cert_one in dset
         assert dset == toy_dataset
 
 
diff --git a/tests/cc/test_cc_maintenance_updates.py b/tests/cc/test_cc_maintenance_updates.py
index 254df45c..cf7a1644 100644
--- a/tests/cc/test_cc_maintenance_updates.py
+++ b/tests/cc/test_cc_maintenance_updates.py
@@ -2,26 +2,17 @@ import json
 from pathlib import Path
 
 import pytest
-import tests.data.cc.dataset
 
-from sec_certs.dataset import CCDataset, CCDatasetMaintenanceUpdates
+from sec_certs.dataset.cc import CCDatasetMaintenanceUpdates
 from sec_certs.sample.cc_maintenance_update import CCMaintenanceUpdate
 
 
-@pytest.fixture(scope="module")
-def data_dir() -> Path:
-    return Path(tests.data.cc.dataset.__path__[0])
-
-
-@pytest.fixture(scope="module")
-def cc_dset(data_dir: Path) -> CCDataset:
-    return CCDataset.from_json(data_dir / "toy_dataset.json")
-
-
 @pytest.fixture
-def mu_dset(data_dir: Path, tmp_path_factory) -> CCDatasetMaintenanceUpdates:
+def mu_dset(dataset_data_dir: Path, tmp_path_factory) -> CCDatasetMaintenanceUpdates:
     tmp_dir = tmp_path_factory.mktemp("mu_dset")
-    dset = CCDatasetMaintenanceUpdates.from_json(data_dir / "auxiliary_datasets/maintenances/maintenance_updates.json")
+    dset = CCDatasetMaintenanceUpdates.from_json(
+        dataset_data_dir / "auxiliary_datasets/maintenances/maintenance_updates.json"
+    )
     dset.copy_dataset(tmp_dir)
     return dset
 
@@ -52,13 +43,13 @@ def test_download_artifacts(mu_dset: CCDatasetMaintenanceUpdates):
     assert mu.state.st_pdf_hash == "d42e4364d037ba742fcd4050a9a84d0e6300f93eb68bcfe8c61f72c429c9ceca"
 
 
-def test_dataset_to_json(mu_dset: CCDatasetMaintenanceUpdates, data_dir: Path, tmp_path: Path):
+def test_dataset_to_json(mu_dset: CCDatasetMaintenanceUpdates, dataset_data_dir: Path, tmp_path: Path):
     mu_dset.to_json(tmp_path / "dset.json")
 
     with (tmp_path / "dset.json").open("r") as handle:
         data = json.load(handle)
 
-    with (data_dir / "auxiliary_datasets/maintenances/maintenance_updates.json").open("r") as handle:
+    with (dataset_data_dir / "auxiliary_datasets/maintenances/maintenance_updates.json").open("r") as handle:
         template_data = json.load(handle)
 
     del template_data["timestamp"]
@@ -66,9 +57,9 @@ def test_dataset_to_json(mu_dset: CCDatasetMaintenanceUpdates, data_dir: Path, t
     assert data == template_data
 
 
-def test_dataset_from_json(mu_dset: CCDatasetMaintenanceUpdates, data_dir: Path):
+def test_dataset_from_json(mu_dset: CCDatasetMaintenanceUpdates, dataset_data_dir: Path):
     assert mu_dset == CCDatasetMaintenanceUpdates.from_json(
-        data_dir / "auxiliary_datasets/maintenances/maintenance_updates.json"
+        dataset_data_dir / "auxiliary_datasets/maintenances/maintenance_updates.json"
     )
 
 
diff --git a/tests/cc/test_cc_schemes.py b/tests/cc/test_cc_schemes.py
index 078a3190..939f77b5 100644
--- a/tests/cc/test_cc_schemes.py
+++ b/tests/cc/test_cc_schemes.py
@@ -1,99 +1,229 @@
+from urllib.parse import urlparse
+
 import pytest
+from requests import RequestException
+
+import sec_certs.sample.cc_scheme as CCSchemes
+from sec_certs.dataset.cc import CCDataset
+from sec_certs.model.cc_matching import CCSchemeMatcher
+from sec_certs.sample.cc import CCCertificate
+
 
-from sec_certs.dataset import CCSchemeDataset
+def absolute_urls(results):
+    for result in results:
+        for key, value in result.items():
+            if "url" in key or "link" in key and value is not None:
+                parsed = urlparse(value)
+                assert bool(parsed.netloc)
+    return True
 
 
-@pytest.mark.xfail(reason="May fail due to server errors.")
+@pytest.mark.xfail(reason="May fail due to server errors.", raises=RequestException)
+@pytest.mark.slow
 def test_australia():
-    assert len(CCSchemeDataset.get_australia_in_evaluation()) != 0
+    ineval = CCSchemes.get_australia_in_evaluation()
+    assert len(ineval) != 0
+    assert absolute_urls(ineval)
 
 
-@pytest.mark.xfail(reason="May fail due to server errors.")
-def test_canada():
-    assert len(CCSchemeDataset.get_canada_certified()) != 0
-    assert len(CCSchemeDataset.get_canada_in_evaluation()) != 0
+@pytest.mark.xfail(reason="May fail due to server errors.", raises=RequestException)
+@pytest.fixture
+def canada_certified():
+    return CCSchemes.get_canada_certified()
 
 
-@pytest.mark.xfail(reason="May fail due to server errors.")
+@pytest.mark.xfail(reason="May fail due to server errors.", raises=RequestException)
+@pytest.mark.slow
+def test_canada(canada_certified):
+    assert len(canada_certified) != 0
+    assert absolute_urls(canada_certified)
+    ineval = CCSchemes.get_canada_in_evaluation()
+    assert len(ineval) != 0
+    assert absolute_urls(ineval)
+
+
+@pytest.mark.xfail(reason="May fail due to server errors.", raises=RequestException)
+@pytest.mark.slow
 def test_anssi():
-    assert len(CCSchemeDataset.get_france_certified()) != 0
+    certified = CCSchemes.get_france_certified()
+    assert len(certified) != 0
+    assert absolute_urls(certified)
 
 
-@pytest.mark.xfail(reason="May fail due to server errors.")
+@pytest.mark.xfail(reason="May fail due to server errors.", raises=RequestException)
+@pytest.mark.slow
 def test_bsi():
-    assert len(CCSchemeDataset.get_germany_certified()) != 0
+    certified = CCSchemes.get_germany_certified()
+    assert len(certified) != 0
+    assert absolute_urls(certified)
 
 
-@pytest.mark.xfail(reason="May fail due to server errors.")
+@pytest.mark.xfail(reason="May fail due to server errors.", raises=RequestException)
+@pytest.mark.slow
 def test_india():
-    assert len(CCSchemeDataset.get_india_certified()) != 0
-    assert len(CCSchemeDataset.get_india_archived()) != 0
+    certified = CCSchemes.get_india_certified()
+    assert len(certified) != 0
+    assert absolute_urls(certified)
+    archived = CCSchemes.get_india_archived()
+    assert len(archived) != 0
+    assert absolute_urls(archived)
 
 
-@pytest.mark.xfail(reason="May fail due to server errors.")
+@pytest.mark.xfail(reason="May fail due to server errors.", raises=RequestException)
+@pytest.mark.slow
 def test_italy():
-    assert len(CCSchemeDataset.get_italy_certified()) != 0
-    assert len(CCSchemeDataset.get_italy_in_evaluation()) != 0
+    certified = CCSchemes.get_italy_certified()
+    assert len(certified) != 0
+    assert absolute_urls(certified)
+    ineval = CCSchemes.get_italy_in_evaluation()
+    assert len(ineval) != 0
+    assert absolute_urls(ineval)
 
 
-@pytest.mark.xfail(reason="May fail due to server errors.")
+@pytest.mark.xfail(reason="May fail due to server errors.", raises=RequestException)
+@pytest.mark.slow
 def test_japan():
-    assert len(CCSchemeDataset.get_japan_certified()) != 0
-    assert len(CCSchemeDataset.get_japan_archived()) != 0
-    assert len(CCSchemeDataset.get_japan_in_evaluation()) != 0
+    certified = CCSchemes.get_japan_certified()
+    assert len(certified) != 0
+    assert absolute_urls(certified)
+    archived = CCSchemes.get_japan_archived()
+    assert len(archived) != 0
+    assert absolute_urls(archived)
+    ineval = CCSchemes.get_japan_in_evaluation()
+    assert len(ineval) != 0
+    assert absolute_urls(ineval)
 
 
-@pytest.mark.xfail(reason="May fail due to server errors.")
+@pytest.mark.xfail(reason="May fail due to server errors.", raises=RequestException)
+@pytest.mark.slow
 def test_malaysia():
-    assert len(CCSchemeDataset.get_malaysia_certified()) != 0
-    assert len(CCSchemeDataset.get_malaysia_in_evaluation()) != 0
+    certified = CCSchemes.get_malaysia_certified()
+    assert len(certified) != 0
+    assert absolute_urls(certified)
+    ineval = CCSchemes.get_malaysia_in_evaluation()
+    assert len(ineval) != 0
+    assert absolute_urls(ineval)
 
 
-@pytest.mark.xfail(reason="May fail due to server errors.")
+@pytest.mark.xfail(reason="May fail due to server errors.", raises=RequestException)
+@pytest.mark.slow
 def test_netherlands():
-    assert len(CCSchemeDataset.get_netherlands_certified()) != 0
-    assert len(CCSchemeDataset.get_netherlands_in_evaluation()) != 0
+    certified = CCSchemes.get_netherlands_certified()
+    assert len(certified) != 0
+    # assert absolute_urls(certified)
+    ineval = CCSchemes.get_netherlands_in_evaluation()
+    assert len(ineval) != 0
+    assert absolute_urls(ineval)
 
 
-@pytest.mark.xfail(reason="May fail due to server errors.")
+@pytest.mark.xfail(reason="May fail due to server errors.", raises=RequestException)
+@pytest.mark.slow
 def test_norway():
-    assert len(CCSchemeDataset.get_norway_certified()) != 0
-    assert len(CCSchemeDataset.get_norway_archived()) != 0
+    certified = CCSchemes.get_norway_certified()
+    assert len(certified) != 0
+    assert absolute_urls(certified)
+    archived = CCSchemes.get_norway_archived()
+    assert len(archived) != 0
+    assert absolute_urls(archived)
 
 
-@pytest.mark.xfail(reason="May fail due to server errors.")
+@pytest.mark.xfail(reason="May fail due to server errors.", raises=RequestException)
+@pytest.mark.slow
 def test_korea():
-    assert len(CCSchemeDataset.get_korea_certified()) != 0
-    CCSchemeDataset.get_korea_suspended()
-    assert len(CCSchemeDataset.get_korea_archived()) != 0
+    certified = CCSchemes.get_korea_certified()
+    assert len(certified) != 0
+    assert absolute_urls(certified)
+    archived = CCSchemes.get_korea_archived()
+    assert len(archived) != 0
+    assert absolute_urls(archived)
 
 
-@pytest.mark.xfail(reason="May fail due to server errors.")
+@pytest.mark.xfail(reason="May fail due to server errors.", raises=RequestException)
+@pytest.mark.slow
 def test_singapore():
-    assert len(CCSchemeDataset.get_singapore_certified()) != 0
-    assert len(CCSchemeDataset.get_singapore_archived()) != 0
-    assert len(CCSchemeDataset.get_singapore_in_evaluation()) != 0
+    certified = CCSchemes.get_singapore_certified()
+    assert len(certified) != 0
+    assert absolute_urls(certified)
+    archived = CCSchemes.get_singapore_archived()
+    assert len(archived) != 0
+    assert absolute_urls(archived)
+    ineval = CCSchemes.get_singapore_in_evaluation()
+    assert len(ineval) != 0
+    assert absolute_urls(ineval)
 
 
-@pytest.mark.xfail(reason="May fail due to server errors.")
+@pytest.mark.xfail(reason="May fail due to server errors.", raises=RequestException)
+@pytest.mark.slow
 def test_spain():
-    assert len(CCSchemeDataset.get_spain_certified()) != 0
+    certified = CCSchemes.get_spain_certified()
+    assert len(certified) != 0
+    assert absolute_urls(certified)
 
 
-@pytest.mark.xfail(reason="May fail due to server errors.")
+@pytest.mark.xfail(reason="May fail due to server errors.", raises=RequestException)
 def test_sweden():
-    assert len(CCSchemeDataset.get_sweden_certified()) != 0
-    assert len(CCSchemeDataset.get_sweden_in_evaluation()) != 0
-    assert len(CCSchemeDataset.get_sweden_archived()) != 0
+    certified = CCSchemes.get_sweden_certified()
+    assert len(certified) != 0
+    assert absolute_urls(certified)
+    archived = CCSchemes.get_sweden_archived()
+    assert len(archived) != 0
+    assert absolute_urls(archived)
+    ineval = CCSchemes.get_sweden_in_evaluation()
+    assert len(ineval) != 0
+    assert absolute_urls(ineval)
 
 
-@pytest.mark.xfail(reason="May fail due to server errors.")
+@pytest.mark.xfail(reason="May fail due to server errors.", raises=RequestException)
+@pytest.mark.slow
 def test_turkey():
-    assert len(CCSchemeDataset.get_turkey_certified()) != 0
+    certified = CCSchemes.get_turkey_certified()
+    assert len(certified) != 0
+    assert absolute_urls(certified)
 
 
-@pytest.mark.xfail(reason="May fail due to server errors.")
+@pytest.mark.xfail(reason="May fail due to server errors.", raises=RequestException)
+@pytest.mark.slow
 def test_usa():
-    assert len(CCSchemeDataset.get_usa_certified()) != 0
-    assert len(CCSchemeDataset.get_usa_in_evaluation()) != 0
-    assert len(CCSchemeDataset.get_usa_archived()) != 0
+    certified = CCSchemes.get_usa_certified()
+    assert len(certified) != 0
+    assert absolute_urls(certified)
+    archived = CCSchemes.get_usa_archived()
+    assert len(archived) != 0
+    assert absolute_urls(archived)
+    ineval = CCSchemes.get_usa_in_evaluation()
+    assert len(ineval) != 0
+    assert absolute_urls(ineval)
+
+
+def test_single_match(cert_one: CCCertificate):
+    entry = {
+        "product": "NetIQ Identity Manager 4.7",
+        "url": "https://www.fmv.se/verksamhet/ovrig-verksamhet/csec/certifikat-utgivna-av-csec/netiq-identity-manager-4.7/",
+        "enhanced": {
+            "title": "NetIQ Identity Manager 4.7",
+            "cert_id": "CSEC2018013",
+            "mutual_recognition": "CCRA, SOGIS-MRA, EA-MLA",
+            "product": "NetIQ Identity Manager 4.7Software Version: Identity Applications (RBPM) 4.7.3.0.1109, Identity Manager Engine 4.7.3.0.AE, Identity Reporting Module 6.5.0. F14508F, Sentinel Log Management for Identity Governance and Administration 8.2.2.0_5415, One SSO Provider (OSP) 6.3.3.0, Self Service Password Reset (SSPR) 4.4.0.2 B366 r39762",
+            "category": "Identity Manager",
+            "target_link": "https://www.fmv.se/globalassets/csec/netiq-identity-manager-4.7/st---netiq-identity-manager-4.7.pdf",
+            "assurance_level": "EAL3 + ALC_FLR.2",
+            "certification_date": "2020-06-15",
+            "report_link": "https://www.fmv.se/globalassets/csec/netiq-identity-manager-4.7/certification-report---netiq-identity-manager-4.7.pdf",
+            "cert_link": "https://www.fmv.se/globalassets/csec/netiq-identity-manager-4.7/certifikat-ccra---netiq-identity-manager-4.7.pdf",
+            "sponsor": "NetIQ Corporation",
+            "developer": "NetIQ Corporation",
+            "evaluation_facility": "Combitech AB and EWA-Canada",
+        },
+    }
+    matcher = CCSchemeMatcher(entry, "SE")
+    assert matcher.match(cert_one) > 95
+
+
+def test_matching(toy_dataset: CCDataset, canada_certified):
+    matches = CCSchemeMatcher.match_all(canada_certified, "CA", toy_dataset)
+    assert len(matches) == 1
+
+
+def test_process_dataset(toy_dataset: CCDataset):
+    toy_dataset.process_schemes(True, only_schemes={"CA"})
+    assert toy_dataset["8a5e6bcda602920c"].heuristics.scheme_data is not None
diff --git a/tests/data/cc/certificate/fictional_cert.json b/tests/data/cc/certificate/fictional_cert.json
index 5d5a0499..7cf04d2d 100644
--- a/tests/data/cc/certificate/fictional_cert.json
+++ b/tests/data/cc/certificate/fictional_cert.json
@@ -89,7 +89,8 @@
             "directly_referencing": null,
             "indirectly_referenced_by": null,
             "indirectly_referencing": null
-        }
+        },
+        "scheme_data": null
     },
     "report_link": "https://path.to/report/link",
     "st_link": "https://path.to/st/link",
diff --git a/tests/data/cc/dataset/auxiliary_datasets/maintenances/maintenance_updates.json b/tests/data/cc/dataset/auxiliary_datasets/maintenances/maintenance_updates.json
index fd21471b..8a087e2b 100644
--- a/tests/data/cc/dataset/auxiliary_datasets/maintenances/maintenance_updates.json
+++ b/tests/data/cc/dataset/auxiliary_datasets/maintenances/maintenance_updates.json
@@ -70,7 +70,8 @@
                 },
                 "extracted_sars": null,
                 "direct_transitive_cves": null,
-                "indirect_transitive_cves": null
+                "indirect_transitive_cves": null,
+                "scheme_data": null
             },
             "related_cert_digest": "8a5e6bcda602920c",
             "maintenance_date": "2019-08-26"
diff --git a/tests/data/cc/dataset/toy_dataset.json b/tests/data/cc/dataset/toy_dataset.json
index dec802f7..b425235e 100644
--- a/tests/data/cc/dataset/toy_dataset.json
+++ b/tests/data/cc/dataset/toy_dataset.json
@@ -93,7 +93,8 @@
                     "directly_referencing": null,
                     "indirectly_referenced_by": null,
                     "indirectly_referencing": null
-                }
+                },
+                "scheme_data": null
             }
         },
         {
@@ -180,7 +181,8 @@
                     "directly_referencing": null,
                     "indirectly_referenced_by": null,
                     "indirectly_referencing": null
-                }
+                },
+                "scheme_data": null
             }
         },
         {
@@ -275,7 +277,8 @@
                     "directly_referencing": null,
                     "indirectly_referenced_by": null,
                     "indirectly_referencing": null
-                }
+                },
+                "scheme_data": null
             }
         }
     ]
diff --git a/tests/fips/__init__.py b/tests/fips/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/tests/fips/__init__.py
diff --git a/tests/fips/conftest.py b/tests/fips/conftest.py
new file mode 100644
index 00000000..3f4f4fda
--- /dev/null
+++ b/tests/fips/conftest.py
@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+from typing import Any
+
+import pytest
+from dateutil.parser import isoparse
+
+import tests.data.fips.certificate
+import tests.data.fips.dataset
+from sec_certs.dataset.cpe import CPEDataset
+from sec_certs.dataset.cve import CVEDataset
+from sec_certs.dataset.fips import FIPSDataset
+from sec_certs.dataset.fips_algorithm import FIPSAlgorithmDataset
+from sec_certs.sample.cpe import CPE, CPEConfiguration
+from sec_certs.sample.cve import CVE
+from sec_certs.sample.fips import FIPSCertificate
+
+
+@pytest.fixture(scope="module")
+def alg_dset_path() -> Path:
+    return Path(tests.data.fips.dataset.__path__[0]) / "alg_dataset.json"
+
+
+@pytest.fixture(scope="module")
+def alg_dset(alg_dset_path: Path) -> FIPSAlgorithmDataset:
+    return FIPSAlgorithmDataset.from_json(alg_dset_path)
+
+
+@pytest.fixture(scope="module")
+def alg_dict() -> dict[str, Any]:
+    return {
+        "alg_number": "2902",
+        "algorithm_type": "AES",
+        "vendor": "Hewlett-Packard Development Company, L.P.",
+        "implementation_name": "HP Secure Encryption Engine v1.0",
+        "validation_date": "7/10/2014",
+    }
+
+
+@pytest.fixture(scope="module")
+def cert_data_dir() -> Path:
+    return Path(tests.data.fips.certificate.__path__[0])
+
+
+@pytest.fixture
+def certificate(tmp_path_factory) -> FIPSCertificate:
+    tmp_dir = tmp_path_factory.mktemp("dset")
+    dset_json_path = Path(tests.data.fips.dataset.__path__[0]) / "toy_dataset.json"
+    data_dir_path = dset_json_path.parent
+    shutil.copytree(data_dir_path, tmp_dir, dirs_exist_ok=True)
+    fips_dset = FIPSDataset.from_json(tmp_dir / "toy_dataset.json")
+
+    crt = fips_dset["184097a88a9b4ad9"]
+    fips_dset.certs = {crt.dgst: crt}
+    fips_dset.download_all_artifacts()
+    fips_dset.convert_all_pdfs()
+
+    return crt
+
+
+@pytest.fixture(scope="module")
+def dataset_data_dir() -> Path:
+    return Path(tests.data.fips.dataset.__path__[0])
+
+
+@pytest.fixture(scope="module")
+def toy_dataset(dataset_data_dir: Path) -> FIPSDataset:
+    return FIPSDataset.from_json(dataset_data_dir / "toy_dataset.json")
+
+
+@pytest.fixture(scope="module")
+def vulnerable_cpe() -> CPE:
+    return CPE("cpe:2.3:o:redhat:enterprise_linux:7.1:*:*:*:*:*:*:*", "Red Hat Enterprise Linux 7.1")
+
+
+@pytest.fixture(scope="module")
+def some_random_cpe() -> CPE:
+    return CPE(
+        "cpe:2.3:a:ibm:security_key_lifecycle_manager:2.6.0.1:*:*:*:*:*:*:*",
+        "IBM Security Key Lifecycle Manager 2.6.0.1",
+    )
+
+
+@pytest.fixture(scope="module")
+def cve(vulnerable_cpe: CPE) -> CVE:
+    return CVE(
+        "CVE-1234-123456",
+        [vulnerable_cpe],
+        [],
+        CVE.Impact(10, "HIGH", 10, 10),
+        isoparse("2021-05-26T04:15Z"),
+        {"CWE-200"},
+    )
+
+
+@pytest.fixture(scope="module")
+def some_other_cve(some_random_cpe: CPE) -> CVE:
+    return CVE(
+        "CVE-2019-4513",
+        [some_random_cpe],
+        [],
+        CVE.Impact(8.2, "HIGH", 3.9, 4.2),
+        isoparse("2000-05-26T04:15Z"),
+        {"CVE-611"},
+    )
+
+
+@pytest.fixture(scope="module")
+def ibm_cpe_configuration() -> CPEConfiguration:
+    return CPEConfiguration(
+        CPE("cpe:2.3:o:ibm:zos:*:*:*:*:*:*:*:*"),
+        [
+            CPE("cpe:2.3:a:ibm:websphere_application_server:7.0.0.1:*:*:*:*:*:*:*"),
+            CPE("cpe:2.3:a:ibm:websphere_application_server:7.0:*:*:*:*:*:*:*"),
+            CPE("cpe:2.3:a:ibm:websphere_application_server:7.0.0.2:*:*:*:*:*:*:*"),
+            CPE("cpe:2.3:a:ibm:websphere_application_server:7.0.0.3:*:*:*:*:*:*:*"),
+            CPE("cpe:2.3:a:ibm:websphere_application_server:7.0.0.4:*:*:*:*:*:*:*"),
+            CPE("cpe:2.3:a:ibm:websphere_application_server:7.0.0.5:*:*:*:*:*:*:*"),
+            CPE("cpe:2.3:a:ibm:websphere_application_server:7.0.0.6:*:*:*:*:*:*:*"),
+            CPE("cpe:2.3:a:ibm:websphere_application_server:7.0.0.7:*:*:*:*:*:*:*"),
+            CPE("cpe:2.3:a:ibm:websphere_application_server:7.0.0.8:*:*:*:*:*:*:*"),
+            CPE("cpe:2.3:a:ibm:websphere_application_server:7.0.0.9:*:*:*:*:*:*:*"),
+            CPE("cpe:2.3:a:ibm:websphere_application_server:*:*:*:*:*:*:*:*"),
+        ],
+    )
+
+
+@pytest.fixture(scope="module")
+def cpes_ibm_websphere_app_with_platform() -> set[CPE]:
+    return {
+        CPE("cpe:2.3:o:ibm:zos:*:*:*:*:*:*:*:*", "IBM zOS"),
+        CPE("cpe:2.3:a:ibm:websphere_application_server:*:*:*:*:*:*:*:*", "IBM WebSphere Application Server"),
+    }
+
+
+@pytest.fixture(scope="module")
+def ibm_xss_cve(ibm_cpe_configuration: CPEConfiguration) -> CVE:
+    return CVE(
+        "CVE-2010-2325",
+        [],
+        [ibm_cpe_configuration],
+        CVE.Impact(4.3, "MEDIUM", 2.9, 8.6),
+        isoparse("2000-06-18T04:15Z"),
+        {"CWE-79"},
+    )
+
+
+@pytest.fixture(scope="module")
+def cpe_dataset(
+    vulnerable_cpe: CPE, some_random_cpe: CPE, cpes_ibm_websphere_app_with_platform: set[CPE]
+) -> CPEDataset:
+    cpes = {
+        vulnerable_cpe,
+        some_random_cpe,
+        CPE(
+            "cpe:2.3:a:semperplugins:all_in_one_seo_pack:1.3.6.4:*:*:*:*:wordpress:*:*",
+            "Semper Plugins All in One SEO Pack 1.3.6.4 for WordPress",
+        ),
+        CPE(
+            "cpe:2.3:a:tracker-software:pdf-xchange_lite_printer:6.0.320.0:*:*:*:*:*:*:*",
+            "Tracker Software PDF-XChange Lite Printer 6.0.320.0",
+        ),
+        *cpes_ibm_websphere_app_with_platform,
+    }
+
+    return CPEDataset(False, {x.uri: x for x in cpes})
+
+
+@pytest.fixture(scope="module")
+def cve_dataset(cve: CVE, some_other_cve: CVE, ibm_xss_cve: CVE) -> CVEDataset:
+    cves = {cve, some_other_cve, ibm_xss_cve}
+    cve_dset = CVEDataset({x.cve_id: x for x in cves})
+    cve_dset.build_lookup_dict(use_nist_mapping=False)
+    return cve_dset
+
+
+@pytest.fixture(scope="module")
+def processed_dataset(
+    toy_dataset: FIPSDataset, cpe_dataset: CPEDataset, cve_dataset: CVEDataset, tmp_path_factory
+) -> FIPSDataset:
+    tmp_dir = tmp_path_factory.mktemp("fips_dset")
+    toy_dataset.copy_dataset(tmp_dir)
+
+    tested_certs = [
+        toy_dataset["3095"],
+        toy_dataset["3093"],
+        toy_dataset["3197"],
+        toy_dataset["2441"],
+    ]
+    toy_dataset.certs = {x.dgst: x for x in tested_certs}
+
+    toy_dataset.download_all_artifacts()
+    toy_dataset.convert_all_pdfs()
+    toy_dataset.extract_data()
+    toy_dataset._compute_references(keep_unknowns=True)
+
+    toy_dataset.auxiliary_datasets.cpe_dset = cpe_dataset
+    toy_dataset.auxiliary_datasets.cve_dset = cve_dataset
+    toy_dataset.compute_cpe_heuristics()
+    toy_dataset.compute_related_cves()
+    toy_dataset._compute_transitive_vulnerabilities()
+
+    return toy_dataset
diff --git a/tests/fips/test_fips_algorithm_dataset.py b/tests/fips/test_fips_algorithm_dataset.py
index 1d45e67c..137ac575 100644
--- a/tests/fips/test_fips_algorithm_dataset.py
+++ b/tests/fips/test_fips_algorithm_dataset.py
@@ -1,10 +1,8 @@
 from __future__ import annotations
 
-from pathlib import Path
 from typing import Any
 
 import pytest
-import tests.data.fips.dataset
 
 from sec_certs.dataset.fips_algorithm import FIPSAlgorithmDataset
 from sec_certs.sample.fips_algorithm import FIPSAlgorithm
@@ -22,27 +20,6 @@ def test_alg_dset_from_web(tmp_path):
     assert len(dset) > 30000
 
 
-@pytest.fixture(scope="module")
-def alg_dset_path() -> Path:
-    return Path(tests.data.fips.dataset.__path__[0]) / "alg_dataset.json"
-
-
-@pytest.fixture(scope="module")
-def alg_dset(alg_dset_path: Path) -> FIPSAlgorithmDataset:
-    return FIPSAlgorithmDataset.from_json(alg_dset_path)
-
-
-@pytest.fixture(scope="module")
-def alg_dict() -> dict[str, Any]:
-    return {
-        "alg_number": "2902",
-        "algorithm_type": "AES",
-        "vendor": "Hewlett-Packard Development Company, L.P.",
-        "implementation_name": "HP Secure Encryption Engine v1.0",
-        "validation_date": "7/10/2014",
-    }
-
-
 def test_alg_dset_lookup_dict(alg_dset: FIPSAlgorithmDataset):
     alg = alg_dset["AES2902"]
     assert alg_dset.alg_number_to_algs["2902"] == {alg}
diff --git a/tests/fips/test_fips_analysis.py b/tests/fips/test_fips_analysis.py
index 90de70f0..8183a63e 100644
--- a/tests/fips/test_fips_analysis.py
+++ b/tests/fips/test_fips_analysis.py
@@ -1,162 +1,13 @@
 from __future__ import annotations
 
-from pathlib import Path
-
 import pytest
-import tests.data.fips.dataset
-from dateutil.parser import isoparse
 
-from sec_certs.dataset import CPEDataset, CVEDataset
+from sec_certs.dataset.cve import CVEDataset
 from sec_certs.dataset.fips import FIPSDataset
-from sec_certs.sample.cpe import CPE, CPEConfiguration
+from sec_certs.sample.cpe import CPE
 from sec_certs.sample.cve import CVE
 
 
-@pytest.fixture(scope="module")
-def data_dir() -> Path:
-    return Path(tests.data.fips.dataset.__path__[0])
-
-
-@pytest.fixture(scope="module")
-def vulnerable_cpe() -> CPE:
-    return CPE("cpe:2.3:o:redhat:enterprise_linux:7.1:*:*:*:*:*:*:*", "Red Hat Enterprise Linux 7.1")
-
-
-@pytest.fixture(scope="module")
-def some_random_cpe() -> CPE:
-    return CPE(
-        "cpe:2.3:a:ibm:security_key_lifecycle_manager:2.6.0.1:*:*:*:*:*:*:*",
-        "IBM Security Key Lifecycle Manager 2.6.0.1",
-    )
-
-
-@pytest.fixture(scope="module")
-def cve(vulnerable_cpe: CPE) -> CVE:
-    return CVE(
-        "CVE-1234-123456",
-        [vulnerable_cpe],
-        [],
-        CVE.Impact(10, "HIGH", 10, 10),
-        isoparse("2021-05-26T04:15Z"),
-        {"CWE-200"},
-    )
-
-
-@pytest.fixture(scope="module")
-def some_other_cve(some_random_cpe: CPE) -> CVE:
-    return CVE(
-        "CVE-2019-4513",
-        [some_random_cpe],
-        [],
-        CVE.Impact(8.2, "HIGH", 3.9, 4.2),
-        isoparse("2000-05-26T04:15Z"),
-        {"CVE-611"},
-    )
-
-
-@pytest.fixture(scope="module")
-def ibm_cpe_configuration() -> CPEConfiguration:
-    return CPEConfiguration(
-        CPE("cpe:2.3:o:ibm:zos:*:*:*:*:*:*:*:*"),
-        [
-            CPE("cpe:2.3:a:ibm:websphere_application_server:7.0.0.1:*:*:*:*:*:*:*"),
-            CPE("cpe:2.3:a:ibm:websphere_application_server:7.0:*:*:*:*:*:*:*"),
-            CPE("cpe:2.3:a:ibm:websphere_application_server:7.0.0.2:*:*:*:*:*:*:*"),
-            CPE("cpe:2.3:a:ibm:websphere_application_server:7.0.0.3:*:*:*:*:*:*:*"),
-            CPE("cpe:2.3:a:ibm:websphere_application_server:7.0.0.4:*:*:*:*:*:*:*"),
-            CPE("cpe:2.3:a:ibm:websphere_application_server:7.0.0.5:*:*:*:*:*:*:*"),
-            CPE("cpe:2.3:a:ibm:websphere_application_server:7.0.0.6:*:*:*:*:*:*:*"),
-            CPE("cpe:2.3:a:ibm:websphere_application_server:7.0.0.7:*:*:*:*:*:*:*"),
-            CPE("cpe:2.3:a:ibm:websphere_application_server:7.0.0.8:*:*:*:*:*:*:*"),
-            CPE("cpe:2.3:a:ibm:websphere_application_server:7.0.0.9:*:*:*:*:*:*:*"),
-            CPE("cpe:2.3:a:ibm:websphere_application_server:*:*:*:*:*:*:*:*"),
-        ],
-    )
-
-
-@pytest.fixture(scope="module")
-def cpes_ibm_websphere_app_with_platform() -> set[CPE]:
-    return {
-        CPE("cpe:2.3:o:ibm:zos:*:*:*:*:*:*:*:*", "IBM zOS"),
-        CPE("cpe:2.3:a:ibm:websphere_application_server:*:*:*:*:*:*:*:*", "IBM WebSphere Application Server"),
-    }
-
-
-@pytest.fixture(scope="module")
-def ibm_xss_cve(ibm_cpe_configuration: CPEConfiguration) -> CVE:
-    return CVE(
-        "CVE-2010-2325",
-        [],
-        [ibm_cpe_configuration],
-        CVE.Impact(4.3, "MEDIUM", 2.9, 8.6),
-        isoparse("2000-06-18T04:15Z"),
-        {"CWE-79"},
-    )
-
-
-@pytest.fixture(scope="module")
-def cpe_dataset(
-    vulnerable_cpe: CPE, some_random_cpe: CPE, cpes_ibm_websphere_app_with_platform: set[CPE]
-) -> CPEDataset:
-    cpes = {
-        vulnerable_cpe,
-        some_random_cpe,
-        CPE(
-            "cpe:2.3:a:semperplugins:all_in_one_seo_pack:1.3.6.4:*:*:*:*:wordpress:*:*",
-            "Semper Plugins All in One SEO Pack 1.3.6.4 for WordPress",
-        ),
-        CPE(
-            "cpe:2.3:a:tracker-software:pdf-xchange_lite_printer:6.0.320.0:*:*:*:*:*:*:*",
-            "Tracker Software PDF-XChange Lite Printer 6.0.320.0",
-        ),
-        *cpes_ibm_websphere_app_with_platform,
-    }
-
-    return CPEDataset(False, {x.uri: x for x in cpes})
-
-
-@pytest.fixture(scope="module")
-def cve_dataset(cve: CVE, some_other_cve: CVE, ibm_xss_cve: CVE) -> CVEDataset:
-    cves = {cve, some_other_cve, ibm_xss_cve}
-    cve_dset = CVEDataset({x.cve_id: x for x in cves})
-    cve_dset.build_lookup_dict(use_nist_mapping=False)
-    return cve_dset
-
-
-@pytest.fixture(scope="module")
-def toy_static_dataset(data_dir: Path) -> FIPSDataset:
-    return FIPSDataset.from_json(data_dir / "toy_dataset.json")
-
-
-@pytest.fixture(scope="module")
-def processed_dataset(
-    toy_static_dataset: FIPSDataset, cpe_dataset: CPEDataset, cve_dataset: CVEDataset, tmp_path_factory
-) -> FIPSDataset:
-    tmp_dir = tmp_path_factory.mktemp("fips_dset")
-    toy_static_dataset.copy_dataset(tmp_dir)
-
-    tested_certs = [
-        toy_static_dataset["3095"],
-        toy_static_dataset["3093"],
-        toy_static_dataset["3197"],
-        toy_static_dataset["2441"],
-    ]
-    toy_static_dataset.certs = {x.dgst: x for x in tested_certs}
-
-    toy_static_dataset.download_all_artifacts()
-    toy_static_dataset.convert_all_pdfs()
-    toy_static_dataset.extract_data()
-    toy_static_dataset._compute_references(keep_unknowns=True)
-
-    toy_static_dataset.auxiliary_datasets.cpe_dset = cpe_dataset
-    toy_static_dataset.auxiliary_datasets.cve_dset = cve_dataset
-    toy_static_dataset.compute_cpe_heuristics()
-    toy_static_dataset.compute_related_cves()
-    toy_static_dataset._compute_transitive_vulnerabilities()
-
-    return toy_static_dataset
-
-
 @pytest.mark.parametrize(
     "input_dgst, expected_refs",
     [
diff --git a/tests/fips/test_fips_certificate.py b/tests/fips/test_fips_certificate.py
index 8f68238e..e8f1c9c8 100644
--- a/tests/fips/test_fips_certificate.py
+++ b/tests/fips/test_fips_certificate.py
@@ -1,36 +1,11 @@
+from __future__ import annotations
+
 import json
-import shutil
 from pathlib import Path
 
-import pytest
-import tests.data.fips.certificate
-import tests.data.fips.dataset
-
-from sec_certs.dataset.fips import FIPSDataset
 from sec_certs.sample.fips import FIPSCertificate
 
 
-@pytest.fixture(scope="module")
-def data_dir() -> Path:
-    return Path(tests.data.fips.certificate.__path__[0])
-
-
-@pytest.fixture
-def certificate(tmp_path_factory) -> FIPSCertificate:
-    tmp_dir = tmp_path_factory.mktemp("dset")
-    dset_json_path = Path(tests.data.fips.dataset.__path__[0]) / "toy_dataset.json"
-    data_dir_path = dset_json_path.parent
-    shutil.copytree(data_dir_path, tmp_dir, dirs_exist_ok=True)
-    fips_dset = FIPSDataset.from_json(tmp_dir / "toy_dataset.json")
-
-    crt = fips_dset["184097a88a9b4ad9"]
-    fips_dset.certs = {crt.dgst: crt}
-    fips_dset.download_all_artifacts()
-    fips_dset.convert_all_pdfs()
-
-    return crt
-
-
 def test_extract_metadata(certificate: FIPSCertificate):
     pass
 
@@ -49,18 +24,18 @@ def test_keyword_extraction():
     pass
 
 
-def test_cert_to_json(certificate: FIPSCertificate, tmp_path: Path, data_dir: Path):
+def test_cert_to_json(certificate: FIPSCertificate, tmp_path: Path, cert_data_dir: Path):
     certificate.to_json(tmp_path / "crt.json")
 
     with (tmp_path / "crt.json").open("r") as handle:
         data = json.load(handle)
 
-    with (data_dir / "fictional_cert.json").open("r") as handle:
+    with (cert_data_dir / "fictional_cert.json").open("r") as handle:
         template_data = json.load(handle)
 
     assert template_data == data
 
 
-def test_cert_from_json(certificate: FIPSCertificate, data_dir: Path):
-    crt = FIPSCertificate.from_json(data_dir / "fictional_cert.json")
+def test_cert_from_json(certificate: FIPSCertificate, cert_data_dir: Path):
+    crt = FIPSCertificate.from_json(cert_data_dir / "fictional_cert.json")
     assert certificate == crt
diff --git a/tests/fips/test_fips_dataset.py b/tests/fips/test_fips_dataset.py
index 99dc57af..8a28c322 100644
--- a/tests/fips/test_fips_dataset.py
+++ b/tests/fips/test_fips_dataset.py
@@ -1,33 +1,24 @@
+from __future__ import annotations
+
 import json
 import shutil
 from pathlib import Path
 from tempfile import TemporaryDirectory
 
 import pytest
-import tests.data.fips.dataset
 
 from sec_certs import constants
 from sec_certs.dataset.fips import FIPSDataset
 from sec_certs.sample.fips import FIPSCertificate
 
 
-@pytest.fixture(scope="module")
-def data_dir() -> Path:
-    return Path(tests.data.fips.dataset.__path__[0])
-
-
-@pytest.fixture
-def toy_dataset(data_dir: Path) -> FIPSDataset:
-    return FIPSDataset.from_json(data_dir / "toy_dataset.json")
-
-
-def test_dataset_to_json(toy_dataset: FIPSDataset, data_dir: Path, tmp_path: Path):
+def test_dataset_to_json(toy_dataset: FIPSDataset, dataset_data_dir: Path, tmp_path: Path):
     toy_dataset.to_json(tmp_path / "dset.json")
 
     with (tmp_path / "dset.json").open("r") as handle:
         data = json.load(handle)
 
-    with (data_dir / "toy_dataset.json").open("r") as handle:
+    with (dataset_data_dir / "toy_dataset.json").open("r") as handle:
         template_data = json.load(handle)
 
     del data["timestamp"]
@@ -35,8 +26,8 @@ def test_dataset_to_json(toy_dataset: FIPSDataset, data_dir: Path, tmp_path: Pat
     assert data == template_data
 
 
-def test_dataset_from_json(toy_dataset: FIPSDataset, data_dir: Path):
-    assert toy_dataset == FIPSDataset.from_json(data_dir / "toy_dataset.json")
+def test_dataset_from_json(toy_dataset: FIPSDataset, dataset_data_dir: Path):
+    assert toy_dataset == FIPSDataset.from_json(dataset_data_dir / "toy_dataset.json")
 
 
 def test_build_empty_dataset():
@@ -49,15 +40,19 @@ def test_build_empty_dataset():
     assert not dset.state.certs_analyzed
 
 
-def test_build_dataset(data_dir: Path, toy_dataset: FIPSDataset):
+def test_build_dataset(dataset_data_dir: Path, toy_dataset: FIPSDataset):
     with TemporaryDirectory() as tmp_dir:
         dataset_path = Path(tmp_dir)
         (dataset_path / "web").mkdir()
-        shutil.copyfile(data_dir / "fips_modules_active.html", dataset_path / "web" / "fips_modules_active.html")
         shutil.copyfile(
-            data_dir / "fips_modules_historical.html", dataset_path / "web" / "fips_modules_historical.html"
+            dataset_data_dir / "fips_modules_active.html", dataset_path / "web" / "fips_modules_active.html"
+        )
+        shutil.copyfile(
+            dataset_data_dir / "fips_modules_historical.html", dataset_path / "web" / "fips_modules_historical.html"
+        )
+        shutil.copyfile(
+            dataset_data_dir / "fips_modules_revoked.html", dataset_path / "web" / "fips_modules_revoked.html"
         )
-        shutil.copyfile(data_dir / "fips_modules_revoked.html", dataset_path / "web" / "fips_modules_revoked.html")
 
         dset = FIPSDataset(root_dir=dataset_path)
         dset.get_certs_from_web(to_download=False)
@@ -81,7 +76,7 @@ def test_download_meta_html_files():
         assert (dset.web_dir / "fips_modules_revoked.html").stat().st_size > constants.MIN_FIPS_HTML_SIZE
 
 
-def test_download_and_convert_artifacts(toy_dataset: FIPSDataset, data_dir: Path):
+def test_download_and_convert_artifacts(toy_dataset: FIPSDataset, dataset_data_dir: Path):
     crt = toy_dataset["184097a88a9b4ad9"]
     toy_dataset.certs = {crt.dgst: crt}
     with TemporaryDirectory() as tmp_dir:
@@ -98,7 +93,7 @@ def test_download_and_convert_artifacts(toy_dataset: FIPSDataset, data_dir: Path
     assert crt.state.policy_pdf_hash == "36b63890182f0aed29b305a0b4acc0d70b657262516f4be69138c70c2abdb1f1"
     assert crt.state.policy_txt_path.exists()
 
-    template_policy_txt_path = data_dir / "template_policy_184097a88a9b4ad9.txt"
+    template_policy_txt_path = dataset_data_dir / "template_policy_184097a88a9b4ad9.txt"
     assert abs(crt.state.policy_txt_path.stat().st_size - template_policy_txt_path.stat().st_size) < 1000
 
 
diff --git a/tests/fips/test_fips_iut.py b/tests/fips/test_fips_iut.py
index 1dca086c..b4279985 100644
--- a/tests/fips/test_fips_iut.py
+++ b/tests/fips/test_fips_iut.py
@@ -1,10 +1,15 @@
+from __future__ import annotations
+
+import datetime
 from pathlib import Path
 
 import pytest
-import tests.data.fips.iut
 
-from sec_certs.dataset import IUTDataset
-from sec_certs.sample import IUTSnapshot
+import tests.data.fips.iut
+from sec_certs.dataset.fips import FIPSDataset
+from sec_certs.dataset.fips_iut import IUTDataset
+from sec_certs.model.fips_matching import FIPSProcessMatcher
+from sec_certs.sample.fips_iut import IUTEntry, IUTSnapshot
 
 
 @pytest.fixture(scope="module")
@@ -37,3 +42,23 @@ def test_iut_snapshot_from_web():
 
 def test_iut_snapshot_from_web_latest():
     assert IUTSnapshot.from_web_latest()
+
+
+def test_iut_matching(processed_dataset: FIPSDataset):
+    entry = IUTEntry(
+        module_name="Red Hat Enterprise Linux 7.1 OpenSSL Module",
+        vendor_name="Red Hat(R), Inc.",
+        standard="FIPS 140-2",
+        iut_date=datetime.date(2014, 1, 1),
+    )
+    matcher = FIPSProcessMatcher(entry)
+    scores = [matcher.match(cert) for cert in processed_dataset]
+    assert len(list(filter(lambda x: x > 90, scores))) == 1
+
+
+def test_iut_snapshot_match(processed_dataset: FIPSDataset, data_dump_path: Path):
+    snapshot = IUTSnapshot.from_dump(data_dump_path)
+    # Move snapshot date back so that there are matches
+    snapshot.timestamp = datetime.datetime(2014, 1, 2)
+    matches = FIPSProcessMatcher.match_snapshot(snapshot, processed_dataset)
+    assert matches
diff --git a/tests/fips/test_fips_mip.py b/tests/fips/test_fips_mip.py
index 4918a4c6..6153dbca 100644
--- a/tests/fips/test_fips_mip.py
+++ b/tests/fips/test_fips_mip.py
@@ -1,10 +1,15 @@
+from __future__ import annotations
+
+import datetime
 from pathlib import Path
 
 import pytest
-import tests.data.fips.mip
 
-from sec_certs.dataset import MIPDataset
-from sec_certs.sample import MIPSnapshot
+import tests.data.fips.mip
+from sec_certs.dataset.fips import FIPSDataset
+from sec_certs.dataset.fips_mip import MIPDataset
+from sec_certs.model.fips_matching import FIPSProcessMatcher
+from sec_certs.sample.fips_mip import MIPEntry, MIPSnapshot, MIPStatus
 
 
 @pytest.fixture(scope="module")
@@ -23,8 +28,9 @@ def test_mip_dataset_from_dumps(data_dir: Path):
     assert len(dset) == 3
 
 
-def test_mip_dataset_from_dataset_latest():
-    assert MIPDataset.from_web_latest()
+def test_mip_flows():
+    dset = MIPDataset.from_web_latest()
+    assert dset.compute_flows()
 
 
 def test_mip_snapshot_from_dump(data_dump_path: Path):
@@ -37,3 +43,24 @@ def test_from_web():
 
 def test_from_web_latest():
     assert MIPSnapshot.from_web_latest()
+
+
+def test_mip_matching(processed_dataset: FIPSDataset):
+    entry = MIPEntry(
+        module_name="Red Hat Enterprise Linux 7.1 OpenSSL Module",
+        vendor_name="Red Hat(R), Inc.",
+        standard="FIPS 140-2",
+        status=MIPStatus.IN_REVIEW,
+        status_since=datetime.date(2014, 1, 1),
+    )
+    matcher = FIPSProcessMatcher(entry)
+    scores = [matcher.match(cert) for cert in processed_dataset]
+    assert len(list(filter(lambda x: x > 90, scores))) == 1
+
+
+def test_mip_snapshot_match(processed_dataset: FIPSDataset, data_dump_path: Path):
+    snapshot = MIPSnapshot.from_dump(data_dump_path)
+    # Move snapshot date back so that there are matches
+    snapshot.timestamp = datetime.datetime(2014, 1, 2)
+    matches = FIPSProcessMatcher.match_snapshot(snapshot, processed_dataset)
+    assert matches
diff --git a/tests/test_config.py b/tests/test_config.py
index 39102111..cd673c15 100644
--- a/tests/test_config.py
+++ b/tests/test_config.py
@@ -8,13 +8,6 @@ import pytest
 import yaml
 
 import sec_certs.configuration as config_module
-import tests.data
-
-
-@pytest.fixture(autouse=True)
-def load_test_config():
-    pth = Path(tests.data.__path__[0]) / "settings_tests.yml"
-    config_module.config.load_from_yaml(pth)
 
 
 @pytest.fixture
diff --git a/tests/test_cpe.py b/tests/test_cpe.py
index 52b5acb0..cfd82e3b 100644
--- a/tests/test_cpe.py
+++ b/tests/test_cpe.py
@@ -7,8 +7,9 @@ import pytest
 
 import tests.data.cc.analysis.auxiliary_datasets
 from sec_certs import constants
-from sec_certs.dataset import CPEDataset, CVEDataset
-from sec_certs.sample import CPE, CPEConfiguration
+from sec_certs.dataset.cpe import CPEDataset
+from sec_certs.dataset.cve import CVEDataset
+from sec_certs.sample.cpe import CPE, CPEConfiguration
 from sec_certs.serialization.json import SerializationError
 
 
@@ -38,7 +39,6 @@ def cpe_dict() -> dict[str, Any]:
 
 
 @pytest.mark.slow
-@pytest.mark.monitor_test
 @pytest.mark.xfail(reason="May fail due to errors with NIST server.")
 @pytest.mark.skip(reason="Too much memory consumed.")
 def test_cpe_dset_from_web(tmp_path: Path):
diff --git a/tests/test_cve.py b/tests/test_cve.py
index 7d21f2cd..f7b8010a 100644
--- a/tests/test_cve.py
+++ b/tests/test_cve.py
@@ -7,9 +7,9 @@ import pytest
 from dateutil.parser import isoparse
 
 import tests.data.cc.analysis.auxiliary_datasets
-from sec_certs.dataset import CVEDataset
-from sec_certs.sample import CVE
+from sec_certs.dataset.cve import CVEDataset
 from sec_certs.sample.cpe import CPE
+from sec_certs.sample.cve import CVE
 from sec_certs.serialization.json import SerializationError
 
 
@@ -103,7 +103,6 @@ def cves(cve_2010_2325_cpe_configs) -> list[CVE]:
 
 
 @pytest.mark.slow
-@pytest.mark.monitor_test
 @pytest.mark.xfail(reason="May fail due to errors on NIST server.")
 def test_from_web():
     dset = CVEDataset.from_web()