cloudconsolelink 2.1.1__tar.gz → 3.0.1__tar.gz

cloudconsolelink-3.0.1/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include requirements.txt
+include requirements-dev.txt

{cloudconsolelink-2.1.1 → cloudconsolelink-3.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudconsolelink
-Version: 2.1.1
+Version: 3.0.1
 Summary: Generate console links for cloud resources
 Home-page: https://github.com/Cloudanix/cloud-console-links
 Maintainer: Cloudanix

{cloudconsolelink-2.1.1 → cloudconsolelink-3.0.1}/cloudconsolelink/__init__.py

@@ -1,2 +1,2 @@
 # version of the module
-__version__ = "2.1.1"
+__version__ = "3.0.1"

{cloudconsolelink-2.1.1 → cloudconsolelink-3.0.1}/cloudconsolelink/clouds/aws/__init__.py

@@ -137,7 +137,7 @@ class AWSLinker:
             data["resource"] = resource_tokens[0]
             data["hasPath"] = False
 
-        else:
+        else:  # pragma: no cover – defensive; unreachable via str.split
             logger.error(f"Invalid AWS ARN {arn}")
             raise InvalidARNError(f"Invalid AWS ARN {arn}")
 

cloudconsolelink-3.0.1/cloudconsolelink/clouds/oci/__init__.py

@@ -0,0 +1,25 @@
+import logging
+
+from .links import Resource
+
+logger = logging.getLogger(__name__)
+
+
+class OCILinker:
+    def get_console_link(
+        self,
+        resource_name: str = "",
+        **kwargs,
+    ) -> str:
+        if not resource_name:
+            logger.error("resource_name is required")
+            raise ValueError("Invalid parameters provided")
+
+        resource = Resource()
+        method = getattr(resource, resource_name, None)
+
+        if method is None or resource_name.startswith("_") or not callable(method):
+            logger.error(f"Invalid resource_name - {resource_name}")
+            raise ValueError("Invalid parameters provided")
+
+        return method(**kwargs).replace(" ", "")

cloudconsolelink-3.0.1/cloudconsolelink/clouds/oci/links.py

@@ -0,0 +1,467 @@
+import logging
+
+
+logger = logging.getLogger(__name__)
+
+BASE = "https://cloud.oracle.com"
+
+
+class Resource:
+    # --- Compute ---
+    def compute_instance(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/compute/instances/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def compute_image(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/compute/images/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def instance_pool(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/compute/instance-pools/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def boot_volume(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/block-storage/boot-volumes/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def block_volume(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/block-storage/volumes/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def dedicated_vm_host(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/compute/dedicated-vm-hosts/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    # --- Networking ---
+    def vcn(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/networking/vcns/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def subnet(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/networking/subnets/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def security_list(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/networking/security-lists/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def network_security_group(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/networking/network-security-groups/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def route_table(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/networking/route-tables/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def internet_gateway(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/networking/internet-gateways/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def nat_gateway(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/networking/nat-gateways/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def service_gateway(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/networking/service-gateways/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def drg(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/networking/drgs/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def load_balancer(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/networking/load-balancers/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def network_load_balancer(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/networking/network-load-balancers/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def public_ip(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/networking/public-ips/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def dhcp_options(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/networking/dhcp-options/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def local_peering_gateway(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/networking/local-peering-gateways/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def network_firewall(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/network-firewall/firewalls/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def network_firewall_policy(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/network-firewall/firewall-policies/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    # --- Object Storage ---
+    def bucket(self, region: str, namespace: str, bucket_name: str, **kwargs) -> str:
+        if region and namespace and bucket_name:
+            return f"{BASE}/object-storage/buckets/{namespace}/{bucket_name}?region={region}"
+        logger.error("region, namespace, and bucket_name required")
+        raise ValueError("Invalid parameters provided")
+
+    # --- Database ---
+    def db_system(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/db-systems/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def autonomous_database(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/autonomous-database/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def mysql_db_system(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/mysql/db-systems/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def nosql_table(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/nosql/tables/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def postgresql_db_system(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/postgresql/db-systems/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    # --- Identity & Access Management ---
+    def compartment(self, ocid: str, **kwargs) -> str:
+        if ocid:
+            return f"{BASE}/identity/compartments/{ocid}"
+        logger.error("ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def user(self, ocid: str, **kwargs) -> str:
+        if ocid:
+            return f"{BASE}/identity/users/{ocid}"
+        logger.error("ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def group(self, ocid: str, **kwargs) -> str:
+        if ocid:
+            return f"{BASE}/identity/groups/{ocid}"
+        logger.error("ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def policy(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/identity/policies/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def dynamic_group(self, ocid: str, **kwargs) -> str:
+        if ocid:
+            return f"{BASE}/identity/dynamic-groups/{ocid}"
+        logger.error("ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def identity_domain(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/identity/domains/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    # --- Container & Kubernetes ---
+    def oke_cluster(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/containers/clusters/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def container_instance(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/container-instances/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def container_repository(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/container-registry/repositories/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def artifact_repository(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/artifacts/repositories/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    # --- Functions / Serverless ---
+    def functions_application(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/functions/applications/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    # --- Security ---
+    def vault(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/security/vaults/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def key(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/security/keys/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def secret(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/security/vaults/secrets/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def bastion(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/bastion/bastions/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def cloud_guard_target(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/cloud-guard/targets/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def waf_policy(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/waf/policies/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def vulnerability_scanning_target(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/vulnerability-scanning/targets/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    # --- Observability & Management ---
+    def alarm(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/monitoring/alarms/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def notification_topic(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/notification/topics/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def log_group(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/logging/log-groups/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def apm_domain(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/apm/domains/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def streaming(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/streaming/streams/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def connector(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/connector-hub/connectors/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def events_rule(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/events/rules/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    # --- DevOps ---
+    def devops_project(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/devops/projects/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def devops_build_pipeline(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/devops/build-pipelines/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def devops_deploy_pipeline(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/devops/deploy-pipelines/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    # --- Resource Manager ---
+    def stack(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/resource-manager/stacks/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    # --- Data & AI ---
+    def data_science_project(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/data-science/projects/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def data_catalog(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/data-catalog/catalogs/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def data_flow_application(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/data-flow/applications/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def data_integration_workspace(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/data-integration/workspaces/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    # --- API Gateway ---
+    def api_gateway(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/api-gateway/gateways/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def api_deployment(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/api-gateway/deployments/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    # --- DNS ---
+    def dns_zone(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/dns/zones/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    # --- Email ---
+    def email_sender(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/email-delivery/senders/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    # --- File Storage ---
+    def file_system(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/file-storage/file-systems/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    def mount_target(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/file-storage/mount-targets/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    # --- Queue ---
+    def queue(self, region: str, ocid: str, **kwargs) -> str:
+        if region and ocid:
+            return f"{BASE}/queue/queues/{ocid}?region={region}"
+        logger.error("region and ocid required")
+        raise ValueError("Invalid parameters provided")
+
+    # --- Service home pages ---
+    def compute_home(self, region: str, **kwargs) -> str:
+        if region:
+            return f"{BASE}/compute/instances?region={region}"
+        logger.error("region required")
+        raise ValueError("Invalid parameters provided")
+
+    def networking_home(self, region: str, **kwargs) -> str:
+        if region:
+            return f"{BASE}/networking/vcns?region={region}"
+        logger.error("region required")
+        raise ValueError("Invalid parameters provided")
+
+    def object_storage_home(self, region: str, **kwargs) -> str:
+        if region:
+            return f"{BASE}/object-storage/buckets?region={region}"
+        logger.error("region required")
+        raise ValueError("Invalid parameters provided")
+
+    def database_home(self, region: str, **kwargs) -> str:
+        if region:
+            return f"{BASE}/db-systems?region={region}"
+        logger.error("region required")
+        raise ValueError("Invalid parameters provided")
+
+    def identity_home(self, **kwargs) -> str:
+        return f"{BASE}/identity/compartments"
+
+    def oke_home(self, region: str, **kwargs) -> str:
+        if region:
+            return f"{BASE}/containers/clusters?region={region}"
+        logger.error("region required")
+        raise ValueError("Invalid parameters provided")

{cloudconsolelink-2.1.1 → cloudconsolelink-3.0.1}/cloudconsolelink.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudconsolelink
-Version: 2.1.1
+Version: 3.0.1
 Summary: Generate console links for cloud resources
 Home-page: https://github.com/Cloudanix/cloud-console-links
 Maintainer: Cloudanix

{cloudconsolelink-2.1.1 → cloudconsolelink-3.0.1}/cloudconsolelink.egg-info/SOURCES.txt

@@ -1,5 +1,8 @@
 LICENSE
+MANIFEST.in
 README.md
+requirements-dev.txt
+requirements.txt
 setup.cfg
 setup.py
 cloudconsolelink/__init__.py
@@ -15,7 +18,11 @@ cloudconsolelink/clouds/aws/links.py
 cloudconsolelink/clouds/azure/__init__.py
 cloudconsolelink/clouds/gcp/__init__.py
 cloudconsolelink/clouds/gcp/links.py
+cloudconsolelink/clouds/oci/__init__.py
+cloudconsolelink/clouds/oci/links.py
 tests/test_aws.py
 tests/test_azure.py
 tests/test_gcp.py
+tests/test_oci.py
+tests/test_packaging.py
 tests/test_provider_coverage.py

cloudconsolelink-3.0.1/requirements-dev.txt

@@ -0,0 +1,7 @@
+pre-commit~=4.2
+pytest~=8.3
+pytest-cov==2.11
+pytest-mock~=3.14
+
+types-PyYAML~=6.0
+types-requests~=2.32

cloudconsolelink-3.0.1/requirements.txt

@@ -0,0 +1 @@
+# Runtime dependencies are currently empty.

{cloudconsolelink-2.1.1 → cloudconsolelink-3.0.1}/setup.py

@@ -6,13 +6,18 @@ import setuptools
 ROOT = Path(__file__).parent
 
 
-def read_text(path: str) -> str:
-    return (ROOT / path).read_text(encoding="utf-8")
+def read_text(path: str, *, required: bool = True) -> str:
+    file_path = ROOT / path
+    if not file_path.exists():
+        if required:
+            raise FileNotFoundError(file_path)
+        return ""
+    return file_path.read_text(encoding="utf-8")
 
 
 def read_requirements(path: str) -> list[str]:
     lines = []
-    for line in read_text(path).splitlines():
+    for line in read_text(path, required=False).splitlines():
         requirement = line.strip()
         if requirement and not requirement.startswith("#"):
             lines.append(requirement)

{cloudconsolelink-2.1.1 → cloudconsolelink-3.0.1}/tests/test_aws.py

@@ -5,6 +5,7 @@ from cloudconsolelink.clouds.aws import ARNTooShortError
 from cloudconsolelink.clouds.aws import InvalidARNError
 from cloudconsolelink.clouds.aws import InvalidPartitionError
 from cloudconsolelink.clouds.aws import InvalidServiceError
+from cloudconsolelink.clouds.aws import get_service_home_link
 from cloudconsolelink.clouds.aws.links import get_links
 
 aws = AWSLinker()
@@ -250,3 +251,12 @@ def test_aws_links_resource_keys_are_trimmed():
             assert resource_type == resource_type.strip(), (
                 f"{service!r} contains malformed resource key {resource_type!r}"
             )
+
+
+def test_aws_get_service_home_link_returns_empty_when_service_missing():
+    assert get_service_home_link({"service": "", "console": "console.aws.amazon.com"}) == ""
+
+
+def test_aws_get_service_home_link_returns_empty_when_console_missing():
+    assert get_service_home_link({"service": "ec2", "console": ""}) == ""
+

{cloudconsolelink-2.1.1 → cloudconsolelink-3.0.1}/tests/test_gcp.py

@@ -103,3 +103,17 @@ def test_cloud_spanner_database():
     )
 
     assert out_link == expected_link
+
+
+def test_cloud_spanner_database_without_database_name():
+    out_link = gcp.get_console_link(
+        project_id="12345",
+        instance_name="spanner-1",
+        resource_name="cloud_spanner_database",
+    )
+    assert out_link == "https://console.cloud.google.com/spanner/instances/spanner-1/databases?project=12345"
+
+
+def test_cloud_spanner_database_requires_params():
+    with pytest.raises(ValueError):
+        gcp.get_console_link(resource_name="cloud_spanner_database", project_id="12345")

cloudconsolelink-3.0.1/tests/test_oci.py

@@ -0,0 +1,213 @@
+import pytest
+
+from cloudconsolelink.clouds.oci import OCILinker
+
+oci = OCILinker()
+
+REGION = "us-ashburn-1"
+OCID = "ocid1.instance.oc1.iad.abc123"
+
+
+# --- Compute ---
+def test_compute_instance():
+    link = oci.get_console_link(
+        resource_name="compute_instance", region=REGION, ocid=OCID,
+    )
+    assert link == f"https://cloud.oracle.com/compute/instances/{OCID}?region={REGION}"
+
+
+def test_compute_image():
+    ocid = "ocid1.image.oc1.iad.abc123"
+    link = oci.get_console_link(resource_name="compute_image", region=REGION, ocid=ocid)
+    assert link == f"https://cloud.oracle.com/compute/images/{ocid}?region={REGION}"
+
+
+def test_boot_volume():
+    ocid = "ocid1.bootvolume.oc1.iad.abc123"
+    link = oci.get_console_link(resource_name="boot_volume", region=REGION, ocid=ocid)
+    assert link == f"https://cloud.oracle.com/block-storage/boot-volumes/{ocid}?region={REGION}"
+
+
+def test_block_volume():
+    ocid = "ocid1.volume.oc1.iad.abc123"
+    link = oci.get_console_link(resource_name="block_volume", region=REGION, ocid=ocid)
+    assert link == f"https://cloud.oracle.com/block-storage/volumes/{ocid}?region={REGION}"
+
+
+# --- Networking ---
+def test_vcn():
+    ocid = "ocid1.vcn.oc1.iad.abc123"
+    link = oci.get_console_link(resource_name="vcn", region=REGION, ocid=ocid)
+    assert link == f"https://cloud.oracle.com/networking/vcns/{ocid}?region={REGION}"
+
+
+def test_subnet():
+    ocid = "ocid1.subnet.oc1.iad.abc123"
+    link = oci.get_console_link(resource_name="subnet", region=REGION, ocid=ocid)
+    assert link == f"https://cloud.oracle.com/networking/subnets/{ocid}?region={REGION}"
+
+
+def test_security_list():
+    ocid = "ocid1.securitylist.oc1.iad.abc123"
+    link = oci.get_console_link(resource_name="security_list", region=REGION, ocid=ocid)
+    assert link == f"https://cloud.oracle.com/networking/security-lists/{ocid}?region={REGION}"
+
+
+def test_network_security_group():
+    ocid = "ocid1.networksecuritygroup.oc1.iad.abc123"
+    link = oci.get_console_link(resource_name="network_security_group", region=REGION, ocid=ocid)
+    assert link == f"https://cloud.oracle.com/networking/network-security-groups/{ocid}?region={REGION}"
+
+
+def test_load_balancer():
+    ocid = "ocid1.loadbalancer.oc1.iad.abc123"
+    link = oci.get_console_link(resource_name="load_balancer", region=REGION, ocid=ocid)
+    assert link == f"https://cloud.oracle.com/networking/load-balancers/{ocid}?region={REGION}"
+
+
+def test_drg():
+    ocid = "ocid1.drg.oc1.iad.abc123"
+    link = oci.get_console_link(resource_name="drg", region=REGION, ocid=ocid)
+    assert link == f"https://cloud.oracle.com/networking/drgs/{ocid}?region={REGION}"
+
+
+# --- Object Storage ---
+def test_bucket():
+    link = oci.get_console_link(
+        resource_name="bucket", region=REGION, namespace="mytenancy", bucket_name="my-bucket",
+    )
+    assert link == f"https://cloud.oracle.com/object-storage/buckets/mytenancy/my-bucket?region={REGION}"
+
+
+# --- Database ---
+def test_autonomous_database():
+    ocid = "ocid1.autonomousdatabase.oc1.iad.abc123"
+    link = oci.get_console_link(resource_name="autonomous_database", region=REGION, ocid=ocid)
+    assert link == f"https://cloud.oracle.com/autonomous-database/{ocid}?region={REGION}"
+
+
+def test_db_system():
+    ocid = "ocid1.dbsystem.oc1.iad.abc123"
+    link = oci.get_console_link(resource_name="db_system", region=REGION, ocid=ocid)
+    assert link == f"https://cloud.oracle.com/db-systems/{ocid}?region={REGION}"
+
+
+def test_mysql_db_system():
+    ocid = "ocid1.mysqldbsystem.oc1.iad.abc123"
+    link = oci.get_console_link(resource_name="mysql_db_system", region=REGION, ocid=ocid)
+    assert link == f"https://cloud.oracle.com/mysql/db-systems/{ocid}?region={REGION}"
+
+
+# --- IAM ---
+def test_compartment():
+    ocid = "ocid1.compartment.oc1..abc123"
+    link = oci.get_console_link(resource_name="compartment", ocid=ocid)
+    assert link == f"https://cloud.oracle.com/identity/compartments/{ocid}"
+
+
+def test_user():
+    ocid = "ocid1.user.oc1..abc123"
+    link = oci.get_console_link(resource_name="user", ocid=ocid)
+    assert link == f"https://cloud.oracle.com/identity/users/{ocid}"
+
+
+def test_group():
+    ocid = "ocid1.group.oc1..abc123"
+    link = oci.get_console_link(resource_name="group", ocid=ocid)
+    assert link == f"https://cloud.oracle.com/identity/groups/{ocid}"
+
+
+def test_policy():
+    ocid = "ocid1.policy.oc1.iad.abc123"
+    link = oci.get_console_link(resource_name="policy", region=REGION, ocid=ocid)
+    assert link == f"https://cloud.oracle.com/identity/policies/{ocid}?region={REGION}"
+
+
+# --- Containers ---
+def test_oke_cluster():
+    ocid = "ocid1.cluster.oc1.iad.abc123"
+    link = oci.get_console_link(resource_name="oke_cluster", region=REGION, ocid=ocid)
+    assert link == f"https://cloud.oracle.com/containers/clusters/{ocid}?region={REGION}"
+
+
+# --- Security ---
+def test_vault():
+    ocid = "ocid1.vault.oc1.iad.abc123"
+    link = oci.get_console_link(resource_name="vault", region=REGION, ocid=ocid)
+    assert link == f"https://cloud.oracle.com/security/vaults/{ocid}?region={REGION}"
+
+
+def test_secret():
+    ocid = "ocid1.vaultsecret.oc1.iad.abc123"
+    link = oci.get_console_link(resource_name="secret", region=REGION, ocid=ocid)
+    assert link == f"https://cloud.oracle.com/security/vaults/secrets/{ocid}?region={REGION}"
+
+
+def test_bastion():
+    ocid = "ocid1.bastion.oc1.iad.abc123"
+    link = oci.get_console_link(resource_name="bastion", region=REGION, ocid=ocid)
+    assert link == f"https://cloud.oracle.com/bastion/bastions/{ocid}?region={REGION}"
+
+
+# --- Observability ---
+def test_alarm():
+    ocid = "ocid1.alarm.oc1.iad.abc123"
+    link = oci.get_console_link(resource_name="alarm", region=REGION, ocid=ocid)
+    assert link == f"https://cloud.oracle.com/monitoring/alarms/{ocid}?region={REGION}"
+
+
+def test_notification_topic():
+    ocid = "ocid1.onstopic.oc1.iad.abc123"
+    link = oci.get_console_link(resource_name="notification_topic", region=REGION, ocid=ocid)
+    assert link == f"https://cloud.oracle.com/notification/topics/{ocid}?region={REGION}"
+
+
+# --- DevOps ---
+def test_devops_project():
+    ocid = "ocid1.devopsproject.oc1.iad.abc123"
+    link = oci.get_console_link(resource_name="devops_project", region=REGION, ocid=ocid)
+    assert link == f"https://cloud.oracle.com/devops/projects/{ocid}?region={REGION}"
+
+
+# --- API Gateway ---
+def test_api_gateway():
+    ocid = "ocid1.apigateway.oc1.iad.abc123"
+    link = oci.get_console_link(resource_name="api_gateway", region=REGION, ocid=ocid)
+    assert link == f"https://cloud.oracle.com/api-gateway/gateways/{ocid}?region={REGION}"
+
+
+# --- Service home pages ---
+def test_compute_home():
+    link = oci.get_console_link(resource_name="compute_home", region=REGION)
+    assert link == f"https://cloud.oracle.com/compute/instances?region={REGION}"
+
+
+def test_networking_home():
+    link = oci.get_console_link(resource_name="networking_home", region=REGION)
+    assert link == f"https://cloud.oracle.com/networking/vcns?region={REGION}"
+
+
+def test_identity_home():
+    link = oci.get_console_link(resource_name="identity_home")
+    assert link == "https://cloud.oracle.com/identity/compartments"
+
+
+# --- Error cases ---
+def test_invalid_resource_name():
+    with pytest.raises(ValueError):
+        oci.get_console_link(resource_name="nonexistent_resource", region=REGION, ocid=OCID)
+
+
+def test_missing_resource_name():
+    with pytest.raises(ValueError):
+        oci.get_console_link(region=REGION, ocid=OCID)
+
+
+def test_missing_required_params():
+    with pytest.raises(ValueError):
+        oci.get_console_link(resource_name="compute_instance", region="", ocid="")
+
+
+def test_bucket_missing_namespace():
+    with pytest.raises(ValueError):
+        oci.get_console_link(resource_name="bucket", region=REGION, namespace="", bucket_name="my-bucket")

cloudconsolelink-3.0.1/tests/test_packaging.py

@@ -0,0 +1,25 @@
+import subprocess
+import sys
+import tarfile
+from pathlib import Path
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+
+
+def test_sdist_includes_requirement_files(tmp_path):
+    subprocess.run(
+        [sys.executable, "setup.py", "sdist", "--dist-dir", str(tmp_path)],
+        cwd=REPO_ROOT,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+
+    archive_path = next(tmp_path.glob("cloudconsolelink-*.tar.gz"))
+    with tarfile.open(archive_path, "r:gz") as archive:
+        archive_names = set(archive.getnames())
+
+    archive_root = archive_path.name.removesuffix(".tar.gz")
+    assert f"{archive_root}/requirements.txt" in archive_names
+    assert f"{archive_root}/requirements-dev.txt" in archive_names

{cloudconsolelink-2.1.1 → cloudconsolelink-3.0.1}/tests/test_provider_coverage.py

@@ -12,6 +12,8 @@ from cloudconsolelink.clouds.aws import (
 from cloudconsolelink.clouds.azure import AzureLinker
 from cloudconsolelink.clouds.gcp import GCPLinker
 from cloudconsolelink.clouds.gcp.links import Resource
+from cloudconsolelink.clouds.oci import OCILinker
+from cloudconsolelink.clouds.oci.links import Resource as OCIResource
 
 
 GCP_SAMPLE_ARGS = {
@@ -294,3 +296,70 @@ def test_aws_linker_builds_links_for_raw_arn_templates():
         )
         == "https://us-east-1.console.aws.amazon.com/ec2/home?region=us-east-1#TargetGroups:targetGroupArn=arn:aws:elasticloadbalancing:us-east-1:123456789012:targetgroup/demo-group/1234567890abcdef"
     )
+
+
+# ---------------------------------------------------------------------------
+# OCI provider coverage
+# ---------------------------------------------------------------------------
+
+OCI_SAMPLE_ARGS = {
+    "region": "us-ashburn-1",
+    "ocid": "ocid1.test.oc1.iad.abc123",
+    "namespace": "demo-namespace",
+    "bucket_name": "demo-bucket",
+}
+
+
+def _oci_method_kwargs(method_name: str) -> dict[str, str]:
+    resource = OCIResource()
+    signature = inspect.signature(getattr(resource, method_name))
+    kwargs: dict[str, str] = {}
+    for name, parameter in signature.parameters.items():
+        if parameter.kind is inspect.Parameter.VAR_KEYWORD:
+            continue
+        kwargs[name] = OCI_SAMPLE_ARGS[name]
+    return kwargs
+
+
+OCI_RESOURCE_METHODS = sorted(
+    method_name
+    for method_name, member in inspect.getmembers(OCIResource, predicate=inspect.isfunction)
+    if not method_name.startswith("_")
+)
+
+
+@pytest.mark.parametrize("method_name", OCI_RESOURCE_METHODS)
+def test_oci_resource_methods_return_console_urls(method_name: str):
+    resource = OCIResource()
+
+    out_link = getattr(resource, method_name)(**_oci_method_kwargs(method_name))
+
+    assert out_link.startswith("https://cloud.oracle.com/")
+
+
+@pytest.mark.parametrize("method_name", OCI_RESOURCE_METHODS)
+def test_oci_resource_methods_validate_required_parameters(method_name: str):
+    resource = OCIResource()
+    kwargs = _oci_method_kwargs(method_name)
+    if not kwargs:
+        pytest.skip("no required args to blank out")
+    first_arg = next(iter(kwargs))
+    kwargs[first_arg] = ""
+
+    with pytest.raises(ValueError, match="Invalid parameters provided"):
+        getattr(resource, method_name)(**kwargs)
+
+
+@pytest.mark.parametrize("method_name", OCI_RESOURCE_METHODS)
+def test_oci_linker_supports_all_resource_builders(method_name: str):
+    kwargs = _oci_method_kwargs(method_name)
+    expected_link = getattr(OCIResource(), method_name)(**kwargs).replace(" ", "")
+
+    out_link = OCILinker().get_console_link(resource_name=method_name, **kwargs)
+
+    assert out_link == expected_link
+
+
+def test_oci_linker_rejects_unknown_resource_name():
+    with pytest.raises(ValueError, match="Invalid parameters provided"):
+        OCILinker().get_console_link(resource_name="missing_resource", region="us-ashburn-1")