feat: adds boilerplate for config with factories.

.coveragerc

@@ -0,0 +1,2 @@
+[report]
+    fail_under = 100

Justfile

@@ -34,6 +34,7 @@ clean:
     #!/usr/bin/env bash
     {{ OPTIONS }}
 
+    find . -name "*.egg-info" -exec rm -rf {} +
     find . -name "*.pyc" -exec rm -f {} +
     find . -name "__pycache__" -exec rm -rf {} +
     rm -rf\

pyproject.toml

@@ -19,7 +19,7 @@ classifiers = [
 ]
 dynamic = ["version"]
 dependencies = [
-    "requests==2.31.0"
+    "requests>=2.31.0,<3"
 ]
 
 [project.optional-dependencies]

src/posit/auth.py

@@ -0,0 +1,11 @@
+from requests import PreparedRequest
+from requests.auth import AuthBase
+
+
+class Auth(AuthBase):
+    def __init__(self, key) -> None:
+        self.key = key
+
+    def __call__(self, r: PreparedRequest) -> PreparedRequest:
+        r.headers["Authorization"] = f"Key {self.key}"
+        return r

src/posit/auth_test.py

@@ -0,0 +1,13 @@
+from unittest.mock import Mock
+
+from .auth import Auth
+
+
+class TestAuth:
+    def test_auth_headers(self):
+        key = "foobar"
+        auth = Auth(key=key)
+        r = Mock()
+        r.headers = {}
+        auth(r)
+        assert r.headers == {"Authorization": f"Key {key}"}

src/posit/client.py

@@ -0,0 +1,22 @@
+from requests import Session
+from typing import Optional
+
+from .auth import Auth
+from .config import ConfigBuilder
+
+
+class Client:
+    def __init__(
+        self, endpoint: Optional[str] = None, api_key: Optional[str] = None
+    ) -> None:
+        builder = ConfigBuilder()
+        builder.set_api_key(api_key)
+        builder.set_endpoint(endpoint)
+        self._config = builder.build()
+        self._session = Session()
+        self._session.auth = Auth(self._config.api_key)
+
+    def get(self, endpoint: str, *args, **kwargs):  # pragma: no cover
+        return self._session.request(
+            "GET", f"{self._config.endpoint}/{endpoint}", *args, **kwargs
+        )

src/posit/client_test.py

@@ -0,0 +1,26 @@
+from unittest.mock import MagicMock, Mock, patch
+
+from .client import Client
+
+
+class TestClient:
+    @patch("posit.client.Session")
+    @patch("posit.client.ConfigBuilder")
+    @patch("posit.client.Auth")
+    def test_init(self, Auth: MagicMock, ConfigBuilder: MagicMock, Session: MagicMock):
+        api_key = "foobar"
+        endpoint = "http://foo.bar"
+        config = Mock()
+        config.api_key = api_key
+        builder = ConfigBuilder.return_value
+        builder.set_api_key = Mock()
+        builder.set_endpoint = Mock()
+        builder.build = Mock(return_value=config)
+        client = Client(api_key=api_key, endpoint=endpoint)
+        ConfigBuilder.assert_called_once()
+        builder.set_api_key.assert_called_once_with(api_key)
+        builder.set_endpoint.assert_called_once_with(endpoint)
+        builder.build.assert_called_once()
+        Session.assert_called_once()
+        Auth.assert_called_once_with(api_key)
+        assert client._config == config

src/posit/config.py

@@ -0,0 +1,54 @@
+import os
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import List, Optional
+
+
+@dataclass
+class Config:
+    api_key: Optional[str] = None
+    endpoint: Optional[str] = None
+
+
+class ConfigProvider(ABC):
+    @abstractmethod
+    def get_value(self, key: str) -> Optional[str]:
+        raise NotImplementedError  # pragma: no cover
+
+
+class EnvironmentConfigProvider(ConfigProvider):
+    def get_value(self, key: str) -> Optional[str]:
+        if key == "api_key":
+            return os.environ.get("CONNECT_API_KEY")
+
+        if key == "endpoint":
+            return os.environ.get("CONNECT_ENDPOINT")
+
+        return None
+
+
+class ConfigBuilder:
+    def __init__(
+        self, providers: List[ConfigProvider] = [EnvironmentConfigProvider()]
+    ) -> None:
+        self._config = Config()
+        self._providers = providers
+
+    def build(self) -> Config:
+        for key in Config.__annotations__:
+            if not getattr(self._config, key):
+                setattr(
+                    self._config,
+                    key,
+                    next(
+                        (provider.get_value(key) for provider in self._providers), None
+                    ),
+                )
+        return self._config
+
+    def set_api_key(self, api_key: Optional[str]):
+        self._config.api_key = api_key
+
+    def set_endpoint(self, endpoint: Optional[str]):
+        self._config.endpoint = endpoint

src/posit/config_test.py

@@ -0,0 +1,46 @@
+from unittest.mock import Mock, patch
+
+from .config import Config, ConfigBuilder, EnvironmentConfigProvider
+
+
+class TestEnvironmentConfigProvider:
+    @patch.dict("os.environ", {"CONNECT_API_KEY": "foobar"})
+    def test_get_api_key(self):
+        provider = EnvironmentConfigProvider()
+        api_key = provider.get_value("api_key")
+        assert api_key == "foobar"
+
+    @patch.dict("os.environ", {"CONNECT_ENDPOINT": "http://foo.bar"})
+    def test_get_endpoint(self):
+        provider = EnvironmentConfigProvider()
+        endpoint = provider.get_value("endpoint")
+        assert endpoint == "http://foo.bar"
+
+    def test_get_value_miss(self):
+        provider = EnvironmentConfigProvider()
+        value = provider.get_value("foobar")
+        assert value == None
+
+
+class TestConfigBuilder:
+    def test_build(self):
+        builder = ConfigBuilder()
+        assert builder._config == Config()
+
+    def test_build_with_provider(self):
+        provider = Mock()
+        provider.get_value = Mock()
+        builder = ConfigBuilder([provider])
+        builder.build()
+        for key in Config.__annotations__:
+            provider.get_value.assert_any_call(key)
+
+    def test_set_api_key(self):
+        builder = ConfigBuilder()
+        builder.set_api_key("foobar")
+        assert builder._config.api_key == "foobar"
+
+    def test_set_endpoint(self):
+        builder = ConfigBuilder()
+        builder.set_endpoint("http://foo.bar")
+        assert builder._config.endpoint == "http://foo.bar"