robotframework-env-manage-library 0.1.0__tar.gz

robotframework_env_manage_library-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 EnvManageLibrary Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

robotframework_env_manage_library-0.1.0/PKG-INFO

@@ -0,0 +1,162 @@
+Metadata-Version: 2.4
+Name: robotframework-env-manage-library
+Version: 0.1.0
+Summary: Robot Framework library to override test variables from .env files
+License-Expression: MIT
+Project-URL: Repository, https://github.com/Non-Spk/robotframework-env-manage-library
+Project-URL: Issues, https://github.com/Non-Spk/robotframework-env-manage-library/issues
+Keywords: robotframework,env,testing,yaml,dotenv
+Classifier: Framework :: Robot Framework
+Classifier: Framework :: Robot Framework :: Library
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: robotframework>=5.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# EnvManageLibrary
+
+Robot Framework keyword library that overrides test variables with values from `.env` files.
+
+Variables loaded via Robot Framework's `Variables` directive (from YAML files) are automatically matched against `.env` entries and overridden at test-case scope.
+
+## Installation
+
+### Option 1: From PyPI
+
+```bash
+pip install robotframework-env-manage-library
+```
+
+### Option 2: From local .whl / .tar.gz file
+
+```bash
+pip install robotframework_env_manage_library-0.1.0-py3-none-any.whl
+```
+
+### Option 3: From local packages directory (offline)
+
+```bash
+pip install --no-index --find-links=./packages robotframework-env-manage-library
+```
+
+## .env Naming Convention
+
+The dot (`.`) separator distinguishes nested dict keys from flat variable names containing underscores.
+
+| .env Key | RF Variable | Type |
+|---|---|---|
+| `USER=value` | `${user}` | Flat |
+| `DB_HOST=value` | `${db_host}` | Flat |
+| `AUTHEN.USER=value` | `${authen}[user]` | Nested dict |
+| `DB.CONN.HOST=value` | `${db}[conn][host]` | Deep nested dict |
+
+## Usage
+
+### YAML data files
+
+```yaml
+# data/credentials.yaml
+user: testuser
+pass: "default_pass"
+```
+
+```yaml
+# data/config.yaml
+db:
+  host: localhost
+  port: "5432"
+```
+
+### .env file
+
+```env
+# Flat overrides
+USER=admin
+PASS=S3cretK3y!
+
+# Nested dict overrides (use dot separator)
+DB.HOST=prod-db.example.com
+DB.PORT=5433
+```
+
+### Robot Framework test
+
+```robot
+*** Settings ***
+Library    EnvManageLibrary
+Variables  ${CURDIR}/data/credentials.yaml
+Variables  ${CURDIR}/data/config.yaml
+
+*** Test Cases ***
+Verify Credentials Override
+    Override Variables From Env    path/to/.env
+    Should Be Equal    ${user}    admin
+    Should Be Equal    ${pass}    S3cretK3y!
+
+Verify Config Override
+    Override Variables From Env    path/to/.env
+    Should Be Equal    ${db}[host]    prod-db.example.com
+    Should Be Equal    ${db}[port]    5433
+
+Values Reset Between Tests
+    # No override called - original YAML values are intact
+    Should Be Equal    ${user}    testuser
+    Should Be Equal    ${db}[host]    localhost
+```
+
+## How It Works
+
+1. Robot Framework loads YAML files via `Variables`, creating RF variables
+2. `Override Variables From Env` parses the `.env` file
+3. For each RF variable, it checks for a matching `.env` key:
+   - Flat string variables: YAML key `user` matches env key `USER`
+   - Dict variables: YAML key `db` with child `host` matches env key `DB.HOST`
+4. Matched values are overridden using `Set Test Variable` (scoped to current test only)
+5. Original YAML values remain intact for other test cases
+
+## Key Behaviors
+
+- Override scope is per test case - original values reset between tests
+- If `.env` file doesn't exist, all variables keep their YAML values
+- Case insensitive - YAML `user` matches env `USER`
+- Flat keys with underscores (`DB_HOST`) only override flat RF variables (`${db_host}`), not nested dicts
+- Dict values are deep-copied before override to prevent mutation
+
+## Development
+
+```bash
+git clone https://github.com/Non-Spk/robotframework-env-manage-library.git
+cd robotframework-env-manage-library
+python -m venv venv
+
+# Windows
+venv\Scripts\pip install -e ".[dev]"
+venv\Scripts\pytest -v
+
+# macOS / Linux
+source venv/bin/activate
+pip install -e ".[dev]"
+pytest -v
+```
+
+## Building
+
+```bash
+pip install build
+python -m build
+```
+
+This produces `dist/robotframework_env_manage-0.1.0-py3-none-any.whl` and `dist/robotframework_env_manage-0.1.0.tar.gz`.
+
+## License
+
+MIT

robotframework_env_manage_library-0.1.0/README.md

@@ -0,0 +1,138 @@
+# EnvManageLibrary
+
+Robot Framework keyword library that overrides test variables with values from `.env` files.
+
+Variables loaded via Robot Framework's `Variables` directive (from YAML files) are automatically matched against `.env` entries and overridden at test-case scope.
+
+## Installation
+
+### Option 1: From PyPI
+
+```bash
+pip install robotframework-env-manage-library
+```
+
+### Option 2: From local .whl / .tar.gz file
+
+```bash
+pip install robotframework_env_manage_library-0.1.0-py3-none-any.whl
+```
+
+### Option 3: From local packages directory (offline)
+
+```bash
+pip install --no-index --find-links=./packages robotframework-env-manage-library
+```
+
+## .env Naming Convention
+
+The dot (`.`) separator distinguishes nested dict keys from flat variable names containing underscores.
+
+| .env Key | RF Variable | Type |
+|---|---|---|
+| `USER=value` | `${user}` | Flat |
+| `DB_HOST=value` | `${db_host}` | Flat |
+| `AUTHEN.USER=value` | `${authen}[user]` | Nested dict |
+| `DB.CONN.HOST=value` | `${db}[conn][host]` | Deep nested dict |
+
+## Usage
+
+### YAML data files
+
+```yaml
+# data/credentials.yaml
+user: testuser
+pass: "default_pass"
+```
+
+```yaml
+# data/config.yaml
+db:
+  host: localhost
+  port: "5432"
+```
+
+### .env file
+
+```env
+# Flat overrides
+USER=admin
+PASS=S3cretK3y!
+
+# Nested dict overrides (use dot separator)
+DB.HOST=prod-db.example.com
+DB.PORT=5433
+```
+
+### Robot Framework test
+
+```robot
+*** Settings ***
+Library    EnvManageLibrary
+Variables  ${CURDIR}/data/credentials.yaml
+Variables  ${CURDIR}/data/config.yaml
+
+*** Test Cases ***
+Verify Credentials Override
+    Override Variables From Env    path/to/.env
+    Should Be Equal    ${user}    admin
+    Should Be Equal    ${pass}    S3cretK3y!
+
+Verify Config Override
+    Override Variables From Env    path/to/.env
+    Should Be Equal    ${db}[host]    prod-db.example.com
+    Should Be Equal    ${db}[port]    5433
+
+Values Reset Between Tests
+    # No override called - original YAML values are intact
+    Should Be Equal    ${user}    testuser
+    Should Be Equal    ${db}[host]    localhost
+```
+
+## How It Works
+
+1. Robot Framework loads YAML files via `Variables`, creating RF variables
+2. `Override Variables From Env` parses the `.env` file
+3. For each RF variable, it checks for a matching `.env` key:
+   - Flat string variables: YAML key `user` matches env key `USER`
+   - Dict variables: YAML key `db` with child `host` matches env key `DB.HOST`
+4. Matched values are overridden using `Set Test Variable` (scoped to current test only)
+5. Original YAML values remain intact for other test cases
+
+## Key Behaviors
+
+- Override scope is per test case - original values reset between tests
+- If `.env` file doesn't exist, all variables keep their YAML values
+- Case insensitive - YAML `user` matches env `USER`
+- Flat keys with underscores (`DB_HOST`) only override flat RF variables (`${db_host}`), not nested dicts
+- Dict values are deep-copied before override to prevent mutation
+
+## Development
+
+```bash
+git clone https://github.com/Non-Spk/robotframework-env-manage-library.git
+cd robotframework-env-manage-library
+python -m venv venv
+
+# Windows
+venv\Scripts\pip install -e ".[dev]"
+venv\Scripts\pytest -v
+
+# macOS / Linux
+source venv/bin/activate
+pip install -e ".[dev]"
+pytest -v
+```
+
+## Building
+
+```bash
+pip install build
+python -m build
+```
+
+This produces `dist/robotframework_env_manage-0.1.0-py3-none-any.whl` and `dist/robotframework_env_manage-0.1.0.tar.gz`.
+
+## License
+
+MIT

robotframework_env_manage_library-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "robotframework-env-manage-library"
+version = "0.1.0"
+description = "Robot Framework library to override test variables from .env files"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.8"
+dependencies = ["robotframework>=5.0"]
+keywords = ["robotframework", "env", "testing", "yaml", "dotenv"]
+classifiers = [
+    "Framework :: Robot Framework",
+    "Framework :: Robot Framework :: Library",
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: MacOS",
+    "Topic :: Software Development :: Testing",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0"]
+
+[project.urls]
+Repository = "https://github.com/Non-Spk/robotframework-env-manage-library"
+Issues = "https://github.com/Non-Spk/robotframework-env-manage-library/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

robotframework_env_manage_library-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

robotframework_env_manage_library-0.1.0/src/EnvManageLibrary/__init__.py

@@ -0,0 +1,6 @@
+"""EnvManageLibrary - Robot Framework library for .env variable overrides."""
+
+from .env_manage_library import EnvManageLibrary
+
+__all__ = ["EnvManageLibrary"]
+__version__ = "0.1.0"

robotframework_env_manage_library-0.1.0/src/EnvManageLibrary/env_manage_library.py

@@ -0,0 +1,140 @@
+"""
+EnvManageLibrary - Robot Framework keyword library.
+
+Scans existing RF variables and overrides their values with matching
+entries from a .env file, scoped to the current test case.
+
+.env naming convention:
+    - Flat variable ``${user}``            -> ``USER=value``
+    - Flat variable ``${authen_key_user}`` -> ``AUTHEN_KEY_USER=value``
+    - Nested dict ``${authen_key}[user]``  -> ``AUTHEN_KEY.USER=value``
+
+The dot (``.``) separator distinguishes nested dict keys from flat
+variable names that contain underscores.
+
+Usage in Robot Framework:
+    Library    EnvManageLibrary
+    Variables  ${CURDIR}/data/authen.yaml
+
+    EnvManageLibrary.Override Variables From Env    .env
+"""
+
+import copy
+from pathlib import Path
+from robot.api.deco import keyword
+from robot.libraries.BuiltIn import BuiltIn
+
+_SKIP_VARS = frozenset((
+    "None", "True", "False", "null", "true", "false",
+    "EMPTY", "SPACE", "\\n",
+))
+
+
+def _load_dotenv(env_path):
+    """Parse a .env file into a dict."""
+    env_vars = {}
+    path = Path(env_path)
+    if not path.is_file():
+        return env_vars
+    for line in path.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+        if "=" not in line:
+            continue
+        key, _, value = line.partition("=")
+        env_vars[key.strip()] = value.strip().strip("'\"")
+    return env_vars
+
+
+def _build_nested_overrides(env_vars):
+    """Build a lookup for nested dict overrides from dot-notation env keys.
+
+    Returns a dict like: ``{"authen_key": {"user": "val", "pass": "val"}}``
+    from env keys like ``AUTHEN_KEY.USER=val``, ``AUTHEN_KEY.PASS=val``.
+    """
+    nested = {}
+    for env_key, env_value in env_vars.items():
+        if "." not in env_key:
+            continue
+        parts = env_key.split(".")
+        var_name = parts[0].lower()
+        remaining = [p.lower() for p in parts[1:]]
+
+        current = nested.setdefault(var_name, {})
+        for part in remaining[:-1]:
+            current = current.setdefault(part, {})
+        current[remaining[-1]] = env_value
+    return nested
+
+
+def _apply_nested_overrides(data, overrides):
+    """Apply nested overrides to a dict. Returns True if anything changed."""
+    changed = False
+    for key in data:
+        if key not in overrides:
+            continue
+        override = overrides[key]
+        if isinstance(data[key], dict) and isinstance(override, dict):
+            if _apply_nested_overrides(data[key], override):
+                changed = True
+        else:
+            data[key] = override
+            changed = True
+    return changed
+
+
+class EnvManageLibrary:
+    """Robot Framework library for overriding variables from .env files."""
+
+    ROBOT_LIBRARY_SCOPE = "GLOBAL"
+
+    @keyword("Override Variables From Env")
+    def override_variables_from_env(self, env_path=".env"):
+        """Override current RF variables with values from a .env file.
+
+        Naming convention in .env:
+            - ``USER=value``            -> overrides flat ``${user}``
+            - ``AUTHEN_KEY_USER=value`` -> overrides flat ``${authen_key_user}``
+            - ``AUTHEN_KEY.USER=value`` -> overrides nested ``${authen_key}[user]``
+
+        Overrides are scoped to the current test case (``Set Test Variable``).
+        If .env file is missing, nothing changes.
+        """
+        builtin = BuiltIn()
+        dot_env = _load_dotenv(env_path)
+
+        if not dot_env:
+            return
+
+        flat_env = {k: v for k, v in dot_env.items() if "." not in k}
+        nested_overrides = _build_nested_overrides(dot_env)
+
+        rf_vars = builtin.get_variables()
+
+        seen = set()
+        for rf_name, rf_value in rf_vars.items():
+            if len(rf_name) < 4 or rf_name[1] != "{" or not rf_name.endswith("}"):
+                continue
+
+            var_name = rf_name[2:-1]
+            if var_name in seen:
+                continue
+            seen.add(var_name)
+
+            if var_name.startswith((" ", "/", "{")):
+                continue
+            if var_name in _SKIP_VARS:
+                continue
+            if var_name.upper() == var_name and var_name not in flat_env:
+                continue
+
+            if isinstance(rf_value, dict):
+                if var_name in nested_overrides:
+                    new_value = copy.deepcopy(rf_value)
+                    if _apply_nested_overrides(new_value, nested_overrides[var_name]):
+                        builtin.set_test_variable(f"${{{var_name}}}", new_value)
+            elif isinstance(rf_value, str):
+                env_value = flat_env.get(var_name.upper())
+                if env_value is not None:
+                    builtin.set_test_variable(f"${{{var_name}}}", env_value)

robotframework_env_manage_library-0.1.0/src/robotframework_env_manage_library.egg-info/PKG-INFO

@@ -0,0 +1,162 @@
+Metadata-Version: 2.4
+Name: robotframework-env-manage-library
+Version: 0.1.0
+Summary: Robot Framework library to override test variables from .env files
+License-Expression: MIT
+Project-URL: Repository, https://github.com/Non-Spk/robotframework-env-manage-library
+Project-URL: Issues, https://github.com/Non-Spk/robotframework-env-manage-library/issues
+Keywords: robotframework,env,testing,yaml,dotenv
+Classifier: Framework :: Robot Framework
+Classifier: Framework :: Robot Framework :: Library
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: robotframework>=5.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# EnvManageLibrary
+
+Robot Framework keyword library that overrides test variables with values from `.env` files.
+
+Variables loaded via Robot Framework's `Variables` directive (from YAML files) are automatically matched against `.env` entries and overridden at test-case scope.
+
+## Installation
+
+### Option 1: From PyPI
+
+```bash
+pip install robotframework-env-manage-library
+```
+
+### Option 2: From local .whl / .tar.gz file
+
+```bash
+pip install robotframework_env_manage_library-0.1.0-py3-none-any.whl
+```
+
+### Option 3: From local packages directory (offline)
+
+```bash
+pip install --no-index --find-links=./packages robotframework-env-manage-library
+```
+
+## .env Naming Convention
+
+The dot (`.`) separator distinguishes nested dict keys from flat variable names containing underscores.
+
+| .env Key | RF Variable | Type |
+|---|---|---|
+| `USER=value` | `${user}` | Flat |
+| `DB_HOST=value` | `${db_host}` | Flat |
+| `AUTHEN.USER=value` | `${authen}[user]` | Nested dict |
+| `DB.CONN.HOST=value` | `${db}[conn][host]` | Deep nested dict |
+
+## Usage
+
+### YAML data files
+
+```yaml
+# data/credentials.yaml
+user: testuser
+pass: "default_pass"
+```
+
+```yaml
+# data/config.yaml
+db:
+  host: localhost
+  port: "5432"
+```
+
+### .env file
+
+```env
+# Flat overrides
+USER=admin
+PASS=S3cretK3y!
+
+# Nested dict overrides (use dot separator)
+DB.HOST=prod-db.example.com
+DB.PORT=5433
+```
+
+### Robot Framework test
+
+```robot
+*** Settings ***
+Library    EnvManageLibrary
+Variables  ${CURDIR}/data/credentials.yaml
+Variables  ${CURDIR}/data/config.yaml
+
+*** Test Cases ***
+Verify Credentials Override
+    Override Variables From Env    path/to/.env
+    Should Be Equal    ${user}    admin
+    Should Be Equal    ${pass}    S3cretK3y!
+
+Verify Config Override
+    Override Variables From Env    path/to/.env
+    Should Be Equal    ${db}[host]    prod-db.example.com
+    Should Be Equal    ${db}[port]    5433
+
+Values Reset Between Tests
+    # No override called - original YAML values are intact
+    Should Be Equal    ${user}    testuser
+    Should Be Equal    ${db}[host]    localhost
+```
+
+## How It Works
+
+1. Robot Framework loads YAML files via `Variables`, creating RF variables
+2. `Override Variables From Env` parses the `.env` file
+3. For each RF variable, it checks for a matching `.env` key:
+   - Flat string variables: YAML key `user` matches env key `USER`
+   - Dict variables: YAML key `db` with child `host` matches env key `DB.HOST`
+4. Matched values are overridden using `Set Test Variable` (scoped to current test only)
+5. Original YAML values remain intact for other test cases
+
+## Key Behaviors
+
+- Override scope is per test case - original values reset between tests
+- If `.env` file doesn't exist, all variables keep their YAML values
+- Case insensitive - YAML `user` matches env `USER`
+- Flat keys with underscores (`DB_HOST`) only override flat RF variables (`${db_host}`), not nested dicts
+- Dict values are deep-copied before override to prevent mutation
+
+## Development
+
+```bash
+git clone https://github.com/Non-Spk/robotframework-env-manage-library.git
+cd robotframework-env-manage-library
+python -m venv venv
+
+# Windows
+venv\Scripts\pip install -e ".[dev]"
+venv\Scripts\pytest -v
+
+# macOS / Linux
+source venv/bin/activate
+pip install -e ".[dev]"
+pytest -v
+```
+
+## Building
+
+```bash
+pip install build
+python -m build
+```
+
+This produces `dist/robotframework_env_manage-0.1.0-py3-none-any.whl` and `dist/robotframework_env_manage-0.1.0.tar.gz`.
+
+## License
+
+MIT

robotframework_env_manage_library-0.1.0/src/robotframework_env_manage_library.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+src/EnvManageLibrary/__init__.py
+src/EnvManageLibrary/env_manage_library.py
+src/robotframework_env_manage_library.egg-info/PKG-INFO
+src/robotframework_env_manage_library.egg-info/SOURCES.txt
+src/robotframework_env_manage_library.egg-info/dependency_links.txt
+src/robotframework_env_manage_library.egg-info/requires.txt
+src/robotframework_env_manage_library.egg-info/top_level.txt
+tests/test_env_manage_library.py

robotframework_env_manage_library-0.1.0/src/robotframework_env_manage_library.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

robotframework_env_manage_library-0.1.0/src/robotframework_env_manage_library.egg-info/requires.txt

@@ -0,0 +1,4 @@
+robotframework>=5.0
+
+[dev]
+pytest>=7.0

robotframework_env_manage_library-0.1.0/src/robotframework_env_manage_library.egg-info/top_level.txt

@@ -0,0 +1 @@
+EnvManageLibrary

robotframework_env_manage_library-0.1.0/tests/test_env_manage_library.py

@@ -0,0 +1,124 @@
+"""Unit tests for env_manage_library helper functions."""
+
+import sys
+import os
+import pytest
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src"))
+
+from EnvManageLibrary.env_manage_library import (
+    _load_dotenv,
+    _build_nested_overrides,
+    _apply_nested_overrides,
+)
+
+
+# ---------------------------------------------------------------------------
+# _load_dotenv
+# ---------------------------------------------------------------------------
+class TestLoadDotenv:
+    def test_basic_key_value(self, tmp_path):
+        env_file = tmp_path / ".env"
+        env_file.write_text("USER=admin\nPASS=secret\n")
+        result = _load_dotenv(str(env_file))
+        assert result == {"USER": "admin", "PASS": "secret"}
+
+    def test_strips_quotes(self, tmp_path):
+        env_file = tmp_path / ".env"
+        env_file.write_text("A='single'\nB=\"double\"\n")
+        result = _load_dotenv(str(env_file))
+        assert result == {"A": "single", "B": "double"}
+
+    def test_skips_comments_and_blanks(self, tmp_path):
+        env_file = tmp_path / ".env"
+        env_file.write_text("# comment\n\n  \nKEY=val\n")
+        result = _load_dotenv(str(env_file))
+        assert result == {"KEY": "val"}
+
+    def test_skips_lines_without_equals(self, tmp_path):
+        env_file = tmp_path / ".env"
+        env_file.write_text("NOEQUALS\nKEY=val\n")
+        result = _load_dotenv(str(env_file))
+        assert result == {"KEY": "val"}
+
+    def test_missing_file_returns_empty(self):
+        result = _load_dotenv("nonexistent.env")
+        assert result == {}
+
+    def test_value_with_equals_sign(self, tmp_path):
+        env_file = tmp_path / ".env"
+        env_file.write_text("URL=https://example.com?a=1&b=2\n")
+        result = _load_dotenv(str(env_file))
+        assert result == {"URL": "https://example.com?a=1&b=2"}
+
+    def test_strips_whitespace(self, tmp_path):
+        env_file = tmp_path / ".env"
+        env_file.write_text("  KEY  =  value  \n")
+        result = _load_dotenv(str(env_file))
+        assert result == {"KEY": "value"}
+
+
+# ---------------------------------------------------------------------------
+# _build_nested_overrides
+# ---------------------------------------------------------------------------
+class TestBuildNestedOverrides:
+    def test_single_level_dot(self):
+        env = {"AUTHEN_KEY.USER": "admin", "AUTHEN_KEY.PASS": "secret"}
+        result = _build_nested_overrides(env)
+        assert result == {"authen_key": {"user": "admin", "pass": "secret"}}
+
+    def test_multi_level_dot(self):
+        env = {"DB.CONN.HOST": "localhost", "DB.CONN.PORT": "5432"}
+        result = _build_nested_overrides(env)
+        assert result == {"db": {"conn": {"host": "localhost", "port": "5432"}}}
+
+    def test_ignores_flat_keys(self):
+        env = {"USER": "admin", "AUTHEN_KEY.USER": "nested"}
+        result = _build_nested_overrides(env)
+        assert "user" not in result
+        assert result == {"authen_key": {"user": "nested"}}
+
+    def test_empty_dict(self):
+        assert _build_nested_overrides({}) == {}
+
+    def test_case_insensitive_lowered(self):
+        env = {"MyVar.SubKey": "val"}
+        result = _build_nested_overrides(env)
+        assert result == {"myvar": {"subkey": "val"}}
+
+
+# ---------------------------------------------------------------------------
+# _apply_nested_overrides
+# ---------------------------------------------------------------------------
+class TestApplyNestedOverrides:
+    def test_overrides_matching_keys(self):
+        data = {"user": "old", "pass": "old"}
+        overrides = {"user": "new", "pass": "new"}
+        changed = _apply_nested_overrides(data, overrides)
+        assert changed is True
+        assert data == {"user": "new", "pass": "new"}
+
+    def test_no_match_returns_false(self):
+        data = {"user": "old"}
+        overrides = {"other": "val"}
+        changed = _apply_nested_overrides(data, overrides)
+        assert changed is False
+        assert data == {"user": "old"}
+
+    def test_nested_dict_override(self):
+        data = {"conn": {"host": "old", "port": "old"}}
+        overrides = {"conn": {"host": "new"}}
+        changed = _apply_nested_overrides(data, overrides)
+        assert changed is True
+        assert data == {"conn": {"host": "new", "port": "old"}}
+
+    def test_partial_override_keeps_others(self):
+        data = {"user": "old", "email": "old"}
+        overrides = {"user": "new"}
+        _apply_nested_overrides(data, overrides)
+        assert data == {"user": "new", "email": "old"}
+
+    def test_empty_overrides(self):
+        data = {"user": "old"}
+        changed = _apply_nested_overrides(data, {})
+        assert changed is False