entropy-data 0.3.2__tar.gz → 0.3.3__tar.gz

{entropy_data-0.3.2 → entropy_data-0.3.3}/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [Unreleased]
+
+## [0.3.3]
+
+- Add `entropy-data organization get` to fetch organization settings (vanity URL, host, full name, plan, SSO) for the API key in use. Backed by the new `GET /api/organization/settings` endpoint.
+- Add `entropy-data connection get [name]` to inspect a stored connection. API key is masked by default; pass `--show-api-key` to print it in clear text. Use `-o json` for scripting.
+- `entropy-data connection add` auto-fetches the organization vanity URL via `/api/organization/settings` and stores it on the connection. Best-effort: older servers or network errors fall back to no vanity URL.
+- `connection list` surfaces the stored vanity URL.
+
 ## [0.3.2]
 
 - Add `git-connection` subcommands to `dataproducts` and `datacontracts`

{entropy_data-0.3.2 → entropy_data-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: entropy-data
-Version: 0.3.2
+Version: 0.3.3
 Summary: CLI for Entropy Data
 Project-URL: Homepage, https://entropy-data.com
 Project-URL: Documentation, https://docs.entropy-data.com

{entropy_data-0.3.2 → entropy_data-0.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "entropy-data"
-version = "0.3.2"
+version = "0.3.3"
 description = "CLI for Entropy Data"
 requires-python = ">=3.11"
 license = "MIT"

{entropy_data-0.3.2 → entropy_data-0.3.3}/src/entropy_data/cli.py

@@ -103,6 +103,7 @@ from entropy_data.commands.events import events_app  # noqa: E402
 from entropy_data.commands.example_data import example_data_app  # noqa: E402
 from entropy_data.commands.import_export import import_app  # noqa: E402
 from entropy_data.commands.lineage import lineage_app  # noqa: E402
+from entropy_data.commands.organization import organization_app  # noqa: E402
 from entropy_data.commands.search import search_app  # noqa: E402
 from entropy_data.commands.settings import settings_app  # noqa: E402
 from entropy_data.commands.sourcesystems import sourcesystems_app  # noqa: E402
@@ -125,6 +126,7 @@ app.add_typer(costs_app, name="costs", help="Manage costs.")
 app.add_typer(assets_app, name="assets", help="Manage data assets.")
 app.add_typer(tags_app, name="tags", help="Manage tags.")
 app.add_typer(api_keys_app, name="api-keys", help="Manage API keys.")
+app.add_typer(organization_app, name="organization", help="Get organization details.")
 app.add_typer(settings_app, name="settings", help="Manage organization settings.")
 app.add_typer(events_app, name="events", help="Poll events.")
 app.add_typer(lineage_app, name="lineage", help="Manage lineage (OpenLineage events).")

entropy_data-0.3.3/src/entropy_data/commands/connection.py

@@ -0,0 +1,190 @@
+"""Connection management commands."""
+
+import json
+from typing import Annotated, Optional
+
+import typer
+from rich.table import Table
+
+from entropy_data import config as cfg
+from entropy_data.output import OutputFormat, console, print_error, print_success
+
+connection_app = typer.Typer(no_args_is_help=True)
+
+
+def _mask_api_key(api_key: str) -> str:
+    """Mask an API key for display (first/last 4 visible)."""
+    if len(api_key) > 8:
+        return api_key[:4] + "..." + api_key[-4:]
+    return "****"
+
+
+def _fetch_vanity_url(api_key: str, host: str) -> str | None:
+    """Best-effort fetch of the org vanity URL via /api/organization/settings.
+
+    Returns None on any failure (older server, network error, etc.) so callers
+    can fall back to None instead of failing the whole `connection add`.
+    """
+    from entropy_data.client import REQUEST_TIMEOUT, EntropyDataClient
+
+    try:
+        client = EntropyDataClient(cfg.ConnectionConfig(api_key=api_key, host=host))
+        response = client.session.get(
+            f"{client.base_url}/api/organization/settings",
+            timeout=REQUEST_TIMEOUT,
+        )
+        if response.ok:
+            return response.json().get("vanityUrl")
+    except Exception:
+        return None
+    return None
+
+
+@connection_app.command("list")
+def list_connections() -> None:
+    """List all configured connections."""
+    connections = cfg.list_connections()
+    if not connections:
+        console.print("No connections configured. Run: entropy-data connection add <name>")
+        return
+
+    table = Table(show_header=True)
+    table.add_column("Name")
+    table.add_column("Host")
+    table.add_column("Vanity URL")
+    table.add_column("API Key")
+    table.add_column("Default")
+    for conn in connections:
+        table.add_row(
+            conn["name"],
+            conn["host"],
+            conn.get("vanity_url") or "",
+            conn["api_key"],
+            "*" if conn["default"] else "",
+        )
+    console.print(table)
+
+
+@connection_app.command("get")
+def get_connection(
+    name: Annotated[
+        Optional[str],
+        typer.Argument(help="Connection name. Defaults to the default connection."),
+    ] = None,
+    show_api_key: Annotated[
+        bool,
+        typer.Option("--show-api-key", help="Print the API key in clear text (default: masked)."),
+    ] = False,
+    output: Annotated[
+        Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")
+    ] = None,
+) -> None:
+    """Get details of a named connection (use --show-api-key to reveal the key)."""
+    from entropy_data.cli import get_output_format
+
+    config = cfg.load_config()
+    connections = config.get("connections", {})
+
+    resolved_name = name or config.get("default_connection_name")
+    if resolved_name is None:
+        print_error(
+            "No connection specified and no default set. "
+            "Run: entropy-data connection set-default <name>"
+        )
+        raise typer.Exit(1)
+    if resolved_name not in connections:
+        print_error(f"Connection '{resolved_name}' not found.")
+        raise typer.Exit(1)
+
+    conn = connections[resolved_name]
+    api_key_value = conn.get("api_key", "")
+    displayed_key = api_key_value if show_api_key else _mask_api_key(api_key_value)
+    is_default = config.get("default_connection_name") == resolved_name
+
+    fmt = output or get_output_format()
+    if fmt == OutputFormat.json:
+        payload = {
+            "name": resolved_name,
+            "host": conn.get("host", cfg.DEFAULT_HOST),
+            "vanity_url": conn.get("vanity_url"),
+            "api_key": displayed_key,
+            "default": is_default,
+        }
+        console.print_json(json.dumps(payload))
+        return
+
+    table = Table(show_header=False)
+    table.add_column("Field", style="cyan")
+    table.add_column("Value")
+    table.add_row("name", resolved_name)
+    table.add_row("host", conn.get("host", cfg.DEFAULT_HOST))
+    if conn.get("vanity_url"):
+        table.add_row("vanity_url", conn["vanity_url"])
+    table.add_row("api_key", displayed_key)
+    if is_default:
+        table.add_row("default", "yes")
+    console.print(table)
+
+
+@connection_app.command("add")
+def add_connection(
+    name: Annotated[str, typer.Argument(help="Connection name.")],
+    api_key: Annotated[str, typer.Option("--api-key", prompt="API key", help="The API key.")] = None,
+    host: Annotated[
+        str, typer.Option("--host", prompt="Host", prompt_required=False, help="API host URL.")
+    ] = cfg.DEFAULT_HOST,
+) -> None:
+    """Add or update a named connection.
+
+    The organization vanity URL is read from /api/organization/settings using the
+    provided API key. Fetching is best-effort: older servers or network errors
+    fall back to no vanity URL on the stored connection.
+    """
+    try:
+        vanity_url = _fetch_vanity_url(api_key, host)
+        if vanity_url:
+            console.print(f"Fetched organization vanity URL '[cyan]{vanity_url}[/cyan]' from {host}.")
+        cfg.add_connection(name, api_key, host, vanity_url=vanity_url)
+        print_success(f"Connection '{name}' saved.")
+    except cfg.ConfigurationError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+
+@connection_app.command("remove")
+def remove_connection(
+    name: Annotated[str, typer.Argument(help="Connection name to remove.")],
+) -> None:
+    """Remove a named connection."""
+    try:
+        cfg.remove_connection(name)
+        print_success(f"Connection '{name}' removed.")
+    except cfg.ConfigurationError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+
+@connection_app.command("set-default")
+def set_default(
+    name: Annotated[str, typer.Argument(help="Connection name to set as default.")],
+) -> None:
+    """Set the default connection."""
+    try:
+        cfg.set_default_connection(name)
+        print_success(f"Default connection set to '{name}'.")
+    except cfg.ConfigurationError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+
+@connection_app.command("test")
+def test_connection() -> None:
+    """Test the current connection by calling the API."""
+    from entropy_data.cli import get_client, handle_error
+
+    try:
+        client = get_client()
+        client.list_resources("teams", params={"p": "0"})
+        print_success("Connection successful.")
+    except Exception as e:
+        handle_error(e)

entropy_data-0.3.3/src/entropy_data/commands/organization.py

@@ -0,0 +1,51 @@
+"""Organization commands."""
+
+import json
+from typing import Annotated, Optional
+
+import typer
+from rich.table import Table
+
+from entropy_data.output import OutputFormat, console
+
+organization_app = typer.Typer(no_args_is_help=True)
+
+
+@organization_app.command("get")
+def get_organization(
+    output: Annotated[Optional[OutputFormat], typer.Option("--output", "-o", help="Output format.")] = None,
+) -> None:
+    """Get settings of the organization the current API key is bound to."""
+    from entropy_data.cli import get_client, get_output_format, handle_error
+    from entropy_data.client import REQUEST_TIMEOUT, _raise_for_status
+
+    fmt = output or get_output_format()
+    try:
+        client = get_client()
+        response = client.session.get(
+            f"{client.base_url}/api/organization/settings",
+            timeout=REQUEST_TIMEOUT,
+        )
+        _raise_for_status(response)
+        data = response.json()
+        if fmt == OutputFormat.json:
+            console.print_json(json.dumps(data))
+            return
+
+        table = Table(show_header=False)
+        table.add_column("Field", style="cyan")
+        table.add_column("Value")
+        for key in ("vanityUrl", "host", "fullName", "logoUrl", "supportEmailAddress", "brand", "plan"):
+            value = data.get(key)
+            if value:
+                table.add_row(key, str(value))
+        sso = data.get("sso")
+        if sso:
+            table.add_row("sso.issuer", sso.get("issuer", ""))
+            if sso.get("tenant"):
+                table.add_row("sso.tenant", sso["tenant"])
+            if sso.get("autoJoin") is not None:
+                table.add_row("sso.autoJoin", str(sso["autoJoin"]))
+        console.print(table)
+    except Exception as e:
+        handle_error(e)

{entropy_data-0.3.2 → entropy_data-0.3.3}/src/entropy_data/config.py

@@ -21,6 +21,7 @@ class ConfigurationError(Exception):
 class ConnectionConfig:
     api_key: str
     host: str = DEFAULT_HOST
+    vanity_url: str | None = None
 
 
 def load_config() -> dict:
@@ -47,6 +48,7 @@ def resolve_connection(
     """Resolve connection with precedence: CLI options > env vars > config file."""
     api_key = cli_api_key
     host = cli_host
+    vanity_url: str | None = None
 
     # Layer 2: environment variables
     if api_key is None:
@@ -68,6 +70,7 @@ def resolve_connection(
                 api_key = conn.get("api_key")
             if host is None:
                 host = conn.get("host")
+            vanity_url = conn.get("vanity_url")
 
     # Default host
     if host is None:
@@ -78,17 +81,20 @@ def resolve_connection(
             "No API key found. Set ENTROPY_DATA_API_KEY, use --api-key, or run: entropy-data connection add <name>"
         )
 
-    return ConnectionConfig(api_key=api_key, host=host)
+    return ConnectionConfig(api_key=api_key, host=host, vanity_url=vanity_url)
 
 
-def add_connection(name: str, api_key: str, host: str = DEFAULT_HOST) -> None:
+def add_connection(name: str, api_key: str, host: str = DEFAULT_HOST, vanity_url: str | None = None) -> None:
     """Add or update a named connection."""
     if not name or not name.strip():
         raise ConfigurationError("Connection name must not be empty.")
     config = load_config()
     if "connections" not in config:
         config["connections"] = {}
-    config["connections"][name] = {"api_key": api_key, "host": host}
+    entry: dict = {"api_key": api_key, "host": host}
+    if vanity_url:
+        entry["vanity_url"] = vanity_url
+    config["connections"][name] = entry
     # Set as default if it's the first connection
     if "default_connection_name" not in config:
         config["default_connection_name"] = name
@@ -134,6 +140,7 @@ def list_connections() -> list[dict]:
             {
                 "name": name,
                 "host": conn.get("host", DEFAULT_HOST),
+                "vanity_url": conn.get("vanity_url"),
                 "api_key": masked,
                 "default": name == default_name,
             }

entropy_data-0.3.3/tests/commands/test_connection.py

@@ -0,0 +1,176 @@
+"""Tests for connection commands."""
+
+import json
+
+import responses
+from typer.testing import CliRunner
+
+import entropy_data.config as cfg
+from entropy_data.cli import app
+
+runner = CliRunner()
+BASE_URL = "https://api.entropy-data.com"
+ORG_SETTINGS_URL = f"{BASE_URL}/api/organization/settings"
+
+
+def test_connection_list_empty(tmp_path, monkeypatch):
+    monkeypatch.setattr(cfg, "CONFIG_DIR", tmp_path)
+    monkeypatch.setattr(cfg, "CONFIG_FILE", tmp_path / "config.toml")
+    result = runner.invoke(app, ["connection", "list"])
+    assert result.exit_code == 0
+    assert "No connections" in result.output
+
+
+@responses.activate
+def test_connection_add_and_list(tmp_path, monkeypatch):
+    monkeypatch.setattr(cfg, "CONFIG_DIR", tmp_path)
+    monkeypatch.setattr(cfg, "CONFIG_FILE", tmp_path / "config.toml")
+    # Auto-fetch fails (no responses registered) — connection still saves without vanity
+    result = runner.invoke(app, ["connection", "add", "prod", "--api-key", "mykey123456", "--host", BASE_URL])
+    assert result.exit_code == 0
+    assert "saved" in result.output
+
+    result = runner.invoke(app, ["connection", "list"])
+    assert result.exit_code == 0
+    assert "prod" in result.output
+    assert "*" in result.output  # default marker
+
+
+@responses.activate
+def test_connection_add_fetches_vanity_url(tmp_path, monkeypatch):
+    monkeypatch.setattr(cfg, "CONFIG_DIR", tmp_path)
+    monkeypatch.setattr(cfg, "CONFIG_FILE", tmp_path / "config.toml")
+    responses.add(
+        responses.GET,
+        ORG_SETTINGS_URL,
+        json={"vanityUrl": "acme", "host": BASE_URL, "fullName": "Acme Corp", "logoUrl": ""},
+        status=200,
+    )
+    result = runner.invoke(app, ["connection", "add", "prod", "--api-key", "mykey", "--host", BASE_URL])
+    assert result.exit_code == 0
+    assert "saved" in result.output
+    assert "acme" in result.output  # mentioned in the fetch confirmation line
+
+    result = runner.invoke(app, ["connection", "list"])
+    assert result.exit_code == 0
+    assert "acme" in result.output
+
+
+@responses.activate
+def test_connection_add_handles_fetch_failure(tmp_path, monkeypatch):
+    monkeypatch.setattr(cfg, "CONFIG_DIR", tmp_path)
+    monkeypatch.setattr(cfg, "CONFIG_FILE", tmp_path / "config.toml")
+    # Older server / endpoint missing → 404
+    responses.add(responses.GET, ORG_SETTINGS_URL, json={"detail": "Not found"}, status=404)
+    result = runner.invoke(app, ["connection", "add", "prod", "--api-key", "mykey", "--host", BASE_URL])
+    assert result.exit_code == 0
+    assert "saved" in result.output
+
+    result = runner.invoke(app, ["connection", "list"])
+    assert result.exit_code == 0
+    assert "prod" in result.output
+
+
+@responses.activate
+def test_connection_remove(tmp_path, monkeypatch):
+    monkeypatch.setattr(cfg, "CONFIG_DIR", tmp_path)
+    monkeypatch.setattr(cfg, "CONFIG_FILE", tmp_path / "config.toml")
+    runner.invoke(app, ["connection", "add", "prod", "--api-key", "key1", "--host", BASE_URL])
+    result = runner.invoke(app, ["connection", "remove", "prod"])
+    assert result.exit_code == 0
+    assert "removed" in result.output
+
+
+@responses.activate
+def test_connection_set_default(tmp_path, monkeypatch):
+    monkeypatch.setattr(cfg, "CONFIG_DIR", tmp_path)
+    monkeypatch.setattr(cfg, "CONFIG_FILE", tmp_path / "config.toml")
+    runner.invoke(app, ["connection", "add", "prod", "--api-key", "key1", "--host", BASE_URL])
+    runner.invoke(app, ["connection", "add", "dev", "--api-key", "key2", "--host", "http://localhost:8080"])
+    result = runner.invoke(app, ["connection", "set-default", "dev"])
+    assert result.exit_code == 0
+    assert "dev" in result.output
+
+
+@responses.activate
+def test_connection_test_success(tmp_path, monkeypatch):
+    monkeypatch.setattr(cfg, "CONFIG_DIR", tmp_path)
+    monkeypatch.setattr(cfg, "CONFIG_FILE", tmp_path / "config.toml")
+    runner.invoke(app, ["connection", "add", "prod", "--api-key", "key1", "--host", BASE_URL])
+    responses.add(responses.GET, f"{BASE_URL}/api/teams", json=[], status=200)
+    result = runner.invoke(app, ["connection", "test"])
+    assert result.exit_code == 0
+    assert "successful" in result.output
+
+
+@responses.activate
+def test_connection_get_masked_by_default(tmp_path, monkeypatch):
+    monkeypatch.setattr(cfg, "CONFIG_DIR", tmp_path)
+    monkeypatch.setattr(cfg, "CONFIG_FILE", tmp_path / "config.toml")
+    runner.invoke(app, ["connection", "add", "prod", "--api-key", "abcd1234efgh5678", "--host", BASE_URL])
+    result = runner.invoke(app, ["connection", "get", "prod"])
+    assert result.exit_code == 0
+    assert "abcd...5678" in result.output
+    assert "abcd1234efgh5678" not in result.output
+
+
+@responses.activate
+def test_connection_get_show_api_key(tmp_path, monkeypatch):
+    monkeypatch.setattr(cfg, "CONFIG_DIR", tmp_path)
+    monkeypatch.setattr(cfg, "CONFIG_FILE", tmp_path / "config.toml")
+    runner.invoke(app, ["connection", "add", "prod", "--api-key", "abcd1234efgh5678", "--host", BASE_URL])
+    result = runner.invoke(app, ["connection", "get", "prod", "--show-api-key"])
+    assert result.exit_code == 0
+    assert "abcd1234efgh5678" in result.output
+
+
+@responses.activate
+def test_connection_get_uses_default(tmp_path, monkeypatch):
+    monkeypatch.setattr(cfg, "CONFIG_DIR", tmp_path)
+    monkeypatch.setattr(cfg, "CONFIG_FILE", tmp_path / "config.toml")
+    runner.invoke(app, ["connection", "add", "prod", "--api-key", "abcd1234efgh5678", "--host", BASE_URL])
+    result = runner.invoke(app, ["connection", "get"])
+    assert result.exit_code == 0
+    assert "prod" in result.output
+    assert "default" in result.output
+
+
+@responses.activate
+def test_connection_get_json(tmp_path, monkeypatch):
+    monkeypatch.setattr(cfg, "CONFIG_DIR", tmp_path)
+    monkeypatch.setattr(cfg, "CONFIG_FILE", tmp_path / "config.toml")
+    runner.invoke(app, ["connection", "add", "prod", "--api-key", "abcd1234efgh5678", "--host", BASE_URL])
+    result = runner.invoke(app, ["connection", "get", "prod", "--show-api-key", "-o", "json"])
+    assert result.exit_code == 0
+    payload = json.loads(result.output)
+    assert payload["name"] == "prod"
+    assert payload["host"] == BASE_URL
+    assert payload["api_key"] == "abcd1234efgh5678"
+    assert payload["default"] is True
+
+
+def test_connection_get_not_found(tmp_path, monkeypatch):
+    monkeypatch.setattr(cfg, "CONFIG_DIR", tmp_path)
+    monkeypatch.setattr(cfg, "CONFIG_FILE", tmp_path / "config.toml")
+    result = runner.invoke(app, ["connection", "get", "nope"])
+    assert result.exit_code == 1
+    assert "not found" in result.output.lower()
+
+
+def test_connection_get_no_default(tmp_path, monkeypatch):
+    monkeypatch.setattr(cfg, "CONFIG_DIR", tmp_path)
+    monkeypatch.setattr(cfg, "CONFIG_FILE", tmp_path / "config.toml")
+    result = runner.invoke(app, ["connection", "get"])
+    assert result.exit_code == 1
+    assert "no default" in result.output.lower() or "no connection specified" in result.output.lower()
+
+
+def test_connection_help():
+    result = runner.invoke(app, ["connection", "--help"])
+    assert result.exit_code == 0
+    assert "list" in result.output
+    assert "get" in result.output
+    assert "add" in result.output
+    assert "remove" in result.output
+    assert "set-default" in result.output
+    assert "test" in result.output

entropy_data-0.3.3/tests/commands/test_organization.py

@@ -0,0 +1,85 @@
+"""Tests for organization commands."""
+
+import json
+
+import responses
+from typer.testing import CliRunner
+
+import entropy_data.config as cfg
+from entropy_data.cli import app
+
+runner = CliRunner()
+BASE_URL = "https://api.entropy-data.com"
+ORG_SETTINGS_URL = f"{BASE_URL}/api/organization/settings"
+
+ORG_PAYLOAD = {
+    "vanityUrl": "acme",
+    "host": "https://acme.entropy-data.com",
+    "fullName": "Acme Corp",
+    "logoUrl": "https://example.com/logo.png",
+    "supportEmailAddress": "support@acme.com",
+    "brand": "default",
+    "plan": "enterprise",
+    "sso": {
+        "issuer": "azuresso",
+        "tenant": "tenant-id",
+        "autoJoin": True,
+    },
+}
+
+
+@responses.activate
+def test_organization_get_table(monkeypatch, tmp_path):
+    monkeypatch.setattr(cfg, "CONFIG_FILE", tmp_path / "config.toml")
+    monkeypatch.setenv("ENTROPY_DATA_API_KEY", "test-key")
+    responses.add(responses.GET, ORG_SETTINGS_URL, json=ORG_PAYLOAD, status=200)
+    result = runner.invoke(app, ["organization", "get"])
+    assert result.exit_code == 0
+    assert "acme" in result.output
+    assert "Acme Corp" in result.output
+    assert "enterprise" in result.output
+    assert "azuresso" in result.output
+
+
+@responses.activate
+def test_organization_get_json(monkeypatch, tmp_path):
+    monkeypatch.setattr(cfg, "CONFIG_FILE", tmp_path / "config.toml")
+    monkeypatch.setenv("ENTROPY_DATA_API_KEY", "test-key")
+    responses.add(responses.GET, ORG_SETTINGS_URL, json=ORG_PAYLOAD, status=200)
+    result = runner.invoke(app, ["organization", "get", "--output", "json"])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert data["vanityUrl"] == "acme"
+    assert data["plan"] == "enterprise"
+    assert data["sso"]["issuer"] == "azuresso"
+
+
+@responses.activate
+def test_organization_get_minimal_payload(monkeypatch, tmp_path):
+    """Org without SSO / optional fields renders cleanly."""
+    monkeypatch.setattr(cfg, "CONFIG_FILE", tmp_path / "config.toml")
+    monkeypatch.setenv("ENTROPY_DATA_API_KEY", "test-key")
+    responses.add(
+        responses.GET,
+        ORG_SETTINGS_URL,
+        json={
+            "vanityUrl": "minimal",
+            "host": "https://minimal.entropy-data.com",
+            "fullName": "Minimal",
+            "logoUrl": "",
+            "supportEmailAddress": None,
+            "brand": None,
+            "plan": None,
+            "sso": None,
+        },
+        status=200,
+    )
+    result = runner.invoke(app, ["organization", "get"])
+    assert result.exit_code == 0
+    assert "minimal" in result.output
+
+
+def test_organization_help():
+    result = runner.invoke(app, ["organization", "--help"])
+    assert result.exit_code == 0
+    assert "get" in result.output

{entropy_data-0.3.2 → entropy_data-0.3.3}/tests/test_config.py

@@ -104,6 +104,29 @@ def test_resolve_from_config(config_dir):
     conn = resolve_connection()
     assert conn.api_key == "mykey"
     assert conn.host == "https://custom.host"
+    assert conn.vanity_url is None
+
+
+def test_add_and_resolve_with_vanity_url(config_dir):
+    add_connection("prod", "mykey", "https://custom.host", vanity_url="acme")
+    conn = resolve_connection()
+    assert conn.vanity_url == "acme"
+    config = load_config()
+    assert config["connections"]["prod"]["vanity_url"] == "acme"
+
+
+def test_add_without_vanity_url_omits_key(config_dir):
+    add_connection("prod", "mykey")
+    config = load_config()
+    assert "vanity_url" not in config["connections"]["prod"]
+
+
+def test_list_connections_includes_vanity_url(config_dir):
+    add_connection("prod", "abcd1234efgh5678", vanity_url="acme")
+    add_connection("dev", "key2")
+    result = {row["name"]: row for row in list_connections()}
+    assert result["prod"]["vanity_url"] == "acme"
+    assert result["dev"]["vanity_url"] is None
 
 
 def test_resolve_env_overrides_config(config_dir, monkeypatch):

entropy_data-0.3.2/src/entropy_data/commands/connection.py

@@ -1,90 +0,0 @@
-"""Connection management commands."""
-
-from typing import Annotated
-
-import typer
-from rich.table import Table
-
-from entropy_data import config as cfg
-from entropy_data.output import console, print_error, print_success
-
-connection_app = typer.Typer(no_args_is_help=True)
-
-
-@connection_app.command("list")
-def list_connections() -> None:
-    """List all configured connections."""
-    connections = cfg.list_connections()
-    if not connections:
-        console.print("No connections configured. Run: entropy-data connection add <name>")
-        return
-
-    table = Table(show_header=True)
-    table.add_column("Name")
-    table.add_column("Host")
-    table.add_column("API Key")
-    table.add_column("Default")
-    for conn in connections:
-        table.add_row(
-            conn["name"],
-            conn["host"],
-            conn["api_key"],
-            "*" if conn["default"] else "",
-        )
-    console.print(table)
-
-
-@connection_app.command("add")
-def add_connection(
-    name: Annotated[str, typer.Argument(help="Connection name.")],
-    api_key: Annotated[str, typer.Option("--api-key", prompt="API key", help="The API key.")] = None,
-    host: Annotated[
-        str, typer.Option("--host", prompt="Host", prompt_required=False, help="API host URL.")
-    ] = cfg.DEFAULT_HOST,
-) -> None:
-    """Add or update a named connection."""
-    try:
-        cfg.add_connection(name, api_key, host)
-        print_success(f"Connection '{name}' saved.")
-    except cfg.ConfigurationError as e:
-        print_error(str(e))
-        raise typer.Exit(1)
-
-
-@connection_app.command("remove")
-def remove_connection(
-    name: Annotated[str, typer.Argument(help="Connection name to remove.")],
-) -> None:
-    """Remove a named connection."""
-    try:
-        cfg.remove_connection(name)
-        print_success(f"Connection '{name}' removed.")
-    except cfg.ConfigurationError as e:
-        print_error(str(e))
-        raise typer.Exit(1)
-
-
-@connection_app.command("set-default")
-def set_default(
-    name: Annotated[str, typer.Argument(help="Connection name to set as default.")],
-) -> None:
-    """Set the default connection."""
-    try:
-        cfg.set_default_connection(name)
-        print_success(f"Default connection set to '{name}'.")
-    except cfg.ConfigurationError as e:
-        print_error(str(e))
-        raise typer.Exit(1)
-
-
-@connection_app.command("test")
-def test_connection() -> None:
-    """Test the current connection by calling the API."""
-    from entropy_data.cli import get_client, handle_error
-
-    try:
-        client = get_client()
-        client.list_resources("teams", params={"p": "0"})
-        print_success("Connection successful.")
-    except Exception as e:
-        handle_error(e)

entropy_data-0.3.2/tests/commands/test_connection.py

@@ -1,71 +0,0 @@
-"""Tests for connection commands."""
-
-import responses
-from typer.testing import CliRunner
-
-import entropy_data.config as cfg
-from entropy_data.cli import app
-
-runner = CliRunner()
-BASE_URL = "https://api.entropy-data.com"
-
-
-def test_connection_list_empty(tmp_path, monkeypatch):
-    monkeypatch.setattr(cfg, "CONFIG_DIR", tmp_path)
-    monkeypatch.setattr(cfg, "CONFIG_FILE", tmp_path / "config.toml")
-    result = runner.invoke(app, ["connection", "list"])
-    assert result.exit_code == 0
-    assert "No connections" in result.output
-
-
-def test_connection_add_and_list(tmp_path, monkeypatch):
-    monkeypatch.setattr(cfg, "CONFIG_DIR", tmp_path)
-    monkeypatch.setattr(cfg, "CONFIG_FILE", tmp_path / "config.toml")
-    result = runner.invoke(app, ["connection", "add", "prod", "--api-key", "mykey123456", "--host", BASE_URL])
-    assert result.exit_code == 0
-    assert "saved" in result.output
-
-    result = runner.invoke(app, ["connection", "list"])
-    assert result.exit_code == 0
-    assert "prod" in result.output
-    assert "*" in result.output  # default marker
-
-
-def test_connection_remove(tmp_path, monkeypatch):
-    monkeypatch.setattr(cfg, "CONFIG_DIR", tmp_path)
-    monkeypatch.setattr(cfg, "CONFIG_FILE", tmp_path / "config.toml")
-    runner.invoke(app, ["connection", "add", "prod", "--api-key", "key1", "--host", BASE_URL])
-    result = runner.invoke(app, ["connection", "remove", "prod"])
-    assert result.exit_code == 0
-    assert "removed" in result.output
-
-
-def test_connection_set_default(tmp_path, monkeypatch):
-    monkeypatch.setattr(cfg, "CONFIG_DIR", tmp_path)
-    monkeypatch.setattr(cfg, "CONFIG_FILE", tmp_path / "config.toml")
-    runner.invoke(app, ["connection", "add", "prod", "--api-key", "key1", "--host", BASE_URL])
-    runner.invoke(app, ["connection", "add", "dev", "--api-key", "key2", "--host", "http://localhost:8080"])
-    result = runner.invoke(app, ["connection", "set-default", "dev"])
-    assert result.exit_code == 0
-    assert "dev" in result.output
-
-
-@responses.activate
-def test_connection_test_success(tmp_path, monkeypatch):
-    monkeypatch.setattr(cfg, "CONFIG_DIR", tmp_path)
-    monkeypatch.setattr(cfg, "CONFIG_FILE", tmp_path / "config.toml")
-    runner.invoke(app, ["connection", "add", "prod", "--api-key", "key1", "--host", BASE_URL])
-    responses.add(responses.GET, f"{BASE_URL}/api/teams", json=[], status=200)
-    result = runner.invoke(app, ["connection", "test"])
-    assert result.exit_code == 0
-    assert "successful" in result.output
-
-
-def test_connection_help():
-    result = runner.invoke(app, ["connection", "--help"])
-    assert result.exit_code == 0
-    assert "list" in result.output
-    assert "add" in result.output
-    assert "remove" in result.output
-    assert "set-default" in result.output
-    assert "test" in result.output