Use pytest marker for workflows

Fix import CLI unit tests

test/cli/test_imports.py

 import json
 from pathlib import Path
+from unittest.mock import patch
 
 import pytest
-from orchestrator.db import SubscriptionTable
-from orchestrator.services.subscriptions import retrieve_subscription_by_subscription_instance_value
 
 from gso.cli.imports import (
     import_iptrunks,
@@ -12,15 +11,10 @@ from gso.cli.imports import (
     import_sites,
     import_super_pop_switches,
 )
-from gso.products import ProductType, Router, Site
+from gso.products import Router, Site
 from gso.products.product_blocks.iptrunk import IptrunkType, PhysicalPortCapacity
 from gso.products.product_blocks.router import RouterRole
 from gso.products.product_blocks.site import SiteTier
-from gso.services.subscriptions import (
-    get_active_iptrunk_subscriptions,
-    get_active_router_subscriptions,
-    get_subscriptions,
-)
 from gso.utils.helpers import iso_from_ipv4
 from gso.utils.shared_enums import Vendor
 
@@ -186,34 +180,31 @@ def office_router_data(temp_file, faker, site_subscription_factory):
 ###########
 
 
-@pytest.mark.workflow()
-def test_import_iptrunk_success(iptrunk_data):
-    assert len(get_active_iptrunk_subscriptions()) == 0
+@patch("gso.cli.imports.start_process")
+def test_import_iptrunk_success(mock_start_process, iptrunk_data):
     import_iptrunks(iptrunk_data()["path"])
+    assert mock_start_process.call_count == 1
 
-    assert len(get_subscriptions([ProductType.IMPORTED_IP_TRUNK])) == 0
-    assert len(get_active_iptrunk_subscriptions()) == 1
 
+@patch("gso.cli.imports.start_process")
+def test_import_site_success(mock_start_process, site_data):
+    import_sites(site_data()["path"])
+    assert mock_start_process.call_count == 1
 
-@pytest.mark.workflow()
-def test_import_site_success(site_data):
-    assert SubscriptionTable.query.all() == []
-    mock_site_data = site_data()
-    import_sites(mock_site_data["path"])
 
-    assert len(get_subscriptions([ProductType.IMPORTED_SITE])) == 0
-    subscription = retrieve_subscription_by_subscription_instance_value(
-        resource_type="site_name", value=mock_site_data["data"]["site_name"]
+@patch("gso.cli.imports.start_process")
+def test_import_site_twice(mock_start_process, site_data, site_subscription_factory, capfd):
+    site_import_data = site_data()
+    #  Create an initial site
+    site_subscription_factory(
+        site_bgp_community_id=site_import_data["data"]["site_bgp_community_id"],
+        site_internal_id=site_import_data["data"]["site_internal_id"],
+        site_ts_address=site_import_data["data"]["site_ts_address"],
+        site_name=site_import_data["data"]["site_name"],
     )
-    assert subscription is not None
-
 
-@pytest.mark.workflow()
-def test_import_site_twice(site_data, capfd):
-    path_location = site_data()["path"]
-    import_sites(path_location)
     #  Second identical import should print ValidationError to stdout
-    import_sites(path_location)
+    import_sites(site_import_data["path"])
 
     out, _ = capfd.readouterr()
     assert (
@@ -228,15 +219,14 @@ site_name
   site_name must be unique (type=value_error)"""
         in out
     )
-    assert SubscriptionTable.query.count() == 1
+    assert mock_start_process.call_count == 0
 
 
-@pytest.mark.workflow()
-def test_import_site_with_invalid_data(site_data, capfd):
+@patch("gso.cli.imports.start_process")
+def test_import_site_with_invalid_data(mock_start_process, site_data, capfd):
     # invalid data, missing site_latitude and invalid site_longitude
     incorrect_site_data = site_data(site_latitude=None, site_longitude="broken")
 
-    assert SubscriptionTable.query.count() == 0
     import_sites(incorrect_site_data["path"])
 
     out, _ = capfd.readouterr()
@@ -248,24 +238,20 @@ site_longitude
   value is not a valid float (type=type_error.float)"""
         in out
     )
-    assert SubscriptionTable.query.count() == 0
+    assert mock_start_process.call_count == 0
 
 
-@pytest.mark.workflow()
-def test_import_router_success(site_subscription_factory, router_data):
-    assert SubscriptionTable.query.count() == 0
+@patch("gso.cli.imports.start_process")
+def test_import_router_success(mock_start_process, site_subscription_factory, router_data):
     import_routers(router_data()["path"])
-
-    assert len(get_active_router_subscriptions()) == 1
+    assert mock_start_process.call_count == 1
 
 
-@pytest.mark.workflow()
-def test_import_router_with_invalid_data(router_data, capfd):
+@patch("gso.cli.imports.start_process")
+def test_import_router_with_invalid_data(mock_start_process, router_data, capfd):
     broken_data = router_data(hostname="", router_lo_ipv6_address="Not an IP address")
     import_routers(broken_data["path"])
 
-    #  Only a Site has been added, no Router
-    assert SubscriptionTable.query.count() == 1
     out, _ = capfd.readouterr()
     #  The extra space at the end of the next line is required, and not dangling by accident.
     assert "Validation error: 1 validation error for RouterImportModel" in out
@@ -274,25 +260,21 @@ def test_import_router_with_invalid_data(router_data, capfd):
   value is not a valid IPv6 address (type=value_error.ipv6address)"""
         in out
     )
+    assert mock_start_process.call_count == 0
 
 
-@pytest.mark.workflow()
-def test_import_iptrunk_successful(iptrunk_data):
-    assert SubscriptionTable.query.count() == 0
+@patch("gso.cli.imports.start_process")
+def test_import_iptrunk_successful(mock_start_process, iptrunk_data):
     import_iptrunks(iptrunk_data()["path"])
+    assert mock_start_process.call_count == 1
 
-    assert SubscriptionTable.query.count() == 5
-    assert len(get_active_iptrunk_subscriptions()) == 1
 
-
-@pytest.mark.workflow()
-def test_import_iptrunk_invalid_router_id_side_a_and_b(iptrunk_data, capfd):
+@patch("gso.cli.imports.start_process")
+def test_import_iptrunk_invalid_router_id_side_a_and_b(mock_start_process, iptrunk_data, capfd):
     broken_data = iptrunk_data(side_a_node="Doesn't exist", side_b_node="Also doesn't exist")
     import_iptrunks(broken_data["path"])
 
     out, _ = capfd.readouterr()
-    assert SubscriptionTable.query.count() == 4
-    assert len(get_active_iptrunk_subscriptions()) == 0
     assert (
         """Validation error: 2 validation errors for IptrunkImportModel
 side_a_node_id
@@ -301,10 +283,11 @@ side_b_node_id
   Router  not found (type=value_error)"""
         in out
     )
+    assert mock_start_process.call_count == 0
 
 
-@pytest.mark.workflow()
-def test_import_iptrunk_non_unique_members_side_a_and_b(iptrunk_data, faker, capfd):
+@patch("gso.cli.imports.start_process")
+def test_import_iptrunk_non_unique_members_side_a_and_b(mock_start_process, iptrunk_data, faker, capfd):
     duplicate_interface = {"interface_name": faker.network_interface(), "interface_description": faker.sentence()}
     side_a_members = [duplicate_interface for _ in range(5)]
     side_b_members = [duplicate_interface for _ in range(5)]
@@ -312,8 +295,6 @@ def test_import_iptrunk_non_unique_members_side_a_and_b(iptrunk_data, faker, cap
     import_iptrunks(broken_data["path"])
 
     out, _ = capfd.readouterr()
-    assert SubscriptionTable.query.count() == 4
-    assert len(get_active_iptrunk_subscriptions()) == 0
     assert (
         """Validation error: 3 validation errors for IptrunkImportModel
 side_a_ae_members
@@ -322,10 +303,11 @@ side_b_ae_members
   Items must be unique (type=value_error)"""
         in out
     )
+    assert mock_start_process.call_count == 0
 
 
-@pytest.mark.workflow()
-def test_import_iptrunk_side_a_member_count_mismatch(iptrunk_data, faker, capfd):
+@patch("gso.cli.imports.start_process")
+def test_import_iptrunk_side_a_member_count_mismatch(mock_start_process, iptrunk_data, faker, capfd):
     side_a_members = [
         {"interface_name": faker.network_interface(), "interface_description": faker.sentence()} for _ in range(5)
     ]
@@ -336,31 +318,22 @@ def test_import_iptrunk_side_a_member_count_mismatch(iptrunk_data, faker, capfd)
     import_iptrunks(broken_data["path"])
 
     out, _ = capfd.readouterr()
-    assert SubscriptionTable.query.count() == 4
-    assert len(get_active_iptrunk_subscriptions()) == 0
     assert (
         """Validation error: 1 validation error for IptrunkImportModel
 __root__
   Mismatch between Side A and B members (type=value_error)"""
         in out
     )
+    assert mock_start_process.call_count == 0
 
 
-@pytest.mark.workflow()
-def test_import_office_router_success(office_router_data):
-    assert SubscriptionTable.query.count() == 0
+@patch("gso.cli.imports.start_process")
+def test_import_office_router_success(mock_start_process, office_router_data):
     import_office_routers(office_router_data()["path"])
-
-    assert SubscriptionTable.query.count() == 2
-    assert len(get_subscriptions([ProductType.IMPORTED_OFFICE_ROUTER])) == 0
-    assert len(get_subscriptions([ProductType.OFFICE_ROUTER])) == 1
+    assert mock_start_process.call_count == 1
 
 
-@pytest.mark.workflow()
-def test_import_super_pop_switch_success(super_pop_switch_data):
-    assert SubscriptionTable.query.count() == 0
+@patch("gso.cli.imports.start_process")
+def test_import_super_pop_switch_success(mock_start_process, super_pop_switch_data):
     import_super_pop_switches(super_pop_switch_data()["path"])
-
-    assert SubscriptionTable.query.count() == 2
-    assert len(get_subscriptions([ProductType.IMPORTED_SUPER_POP_SWITCH])) == 0
-    assert len(get_subscriptions([ProductType.SUPER_POP_SWITCH])) == 1
+    assert mock_start_process.call_count == 1