Project: Config File Manager0%
Unit Testing with unittest

Project: Config File Manager

Beginner12 min read•Updated: Jul 11, 2026
Study Materials

Project: Universal Configuration File Manager

Production cloud services and microservices rarely rely on hardcoded settings. Modern Twelve-Factor application architectures require robust configuration systems that support multiple file formats (JSON, YAML, INI), validate configuration schemas, allow environment variable overrides, and protect sensitive secrets from leaking into logs.

In this project, we will construct a production-grade Universal Configuration Manager. It seamlessly parses JSON and YAML configuration files, deep-merges environment overrides, provides dot-notation property lookups, and automatically redacts credentials.

1. System Architecture

The configuration manager enforces a Cascading Precedence Hierarchy:

Output
Default Fallbacks ──► File Config (JSON / YAML) ──► Environment Variables (Overrides)
│
▼
Deep Hierarchical Merge
│
▼
Schema Type Validation
│
▼
Immutable AppConfig Instance
(Supports dot-notation: config.get("db.port"))

2. Production Implementation

Visual Architecture & Process Flow

How data and code flow step-by-step

Flowchart
Step 1
def __init__
self, defaults: Optional[Dict[str, Any]] = None
Step 2
None:

3. Verification & Demonstration

Python
def run_demonstration():
print("=====================================================")
print(" INITIALIZING UNIVERSAL CONFIG MANAGER TEST ")
print("=====================================================")
 
# 1. Base Default Configurations
default_settings = {
"server": {"host": "127.0.0.1", "port": 8080, "debug": True},
"database": {"host": "localhost", "port": 5432, "name": "core_db"},
"security": {"api_secret_key": "unconfigured_default"}
}
 
manager = UniversalConfigManager(defaults=default_settings)
 
# 2. Write and Load Mock YAML Configuration File
mock_yaml_path = "app_config_test.yaml"
mock_yaml_content = """
server:
port: 9000
debug: false
database:
name: "production_cluster"
credentials:
username: "db_admin"
password: "super_secret_db_password_123"
security:
api_secret_key: "vault_jwt_production_token"
"""
with open(mock_yaml_path, "w") as f:
f.write(mock_yaml_content)
 
manager.load_file(mock_yaml_path)
 
# 3. Simulate System Environment Variable Overrides
# APP_DATABASE__PORT overrides database.port (double underscore hierarchy)
os.environ["APP_DATABASE__PORT"] = "5433"
os.environ["APP_SERVER__DEBUG"] = "true"
manager.load_env_overrides(prefix="APP_")
 
# 4. Dot-Notation Lookups
print("\n--- Dot-Notation Property Access ---")
print(f"Server Host: {manager.get('server.host')}")
print(f"Server Port: {manager.get('server.port')}")
print(f"Server Debug Flag: {manager.get('server.debug')} (Overridden by env!)")
print(f"Database Port: {manager.get('database.port')} (Overridden by env!)")
print(f"Database Username: {manager.get('database.credentials.username')}")
 
# 5. Schema Validation
required_keys = ["server.host", "server.port", "database.credentials.username"]
manager.validate_schema(required_keys)
print("\n[VALIDATION] All required schema paths verified.")
 
# 6. Sanitized Export (Redacts sensitive tokens)
print("\n--- Sanitized Export (Safe for Audit Logs) ---")
sanitized_output = json.dumps(manager.to_sanitized_dict(), indent=2)
print(sanitized_output)
 
# Clean up test file
if os.path.exists(mock_yaml_path):
os.remove(mock_yaml_path)
 
if __name__ == "__main__":
run_demonstration()

4. Key Architectural Insights

  1. 1
    Deep Recursive Merge: Overriding settings updates individual leaves of the dictionary tree without obliterating surrounding sibling settings.
  2. 2
    Double Underscore Env Mapping: Mapping APP_DATABASE__PORT to database.port provides a clear convention for containerized Docker/Kubernetes deployments.
  3. 3
    Automated Secret Redaction: Recursive keyword inspection ensures tokens and passwords are never accidentally written to standard logger streams.

Multiple Choice Questions

1.

What is the advantage of using a deep recursive merge over Python's built-in dict.update() when combining configurations? A. Deep merge is written in C++. B. Built-in dict.update() overwrites entire nested dictionaries, destroying unmodified sibling settings, whereas deep merge only updates specific leaf keys. C. Deep merge converts all strings to uppercase. D. dict.update() is deprecated in Python 3.

Answer: B
Explanation:Standard dict.update() replaces the whole value at a key. If server: {"port": 80} is updated with server: {"debug": True}, the "port" key is wiped out unless a deep recursive merge is performed.

2.

How does the configuration manager support overriding nested settings using standard flat environment variables? A. By reading command line flags. B. By splitting the environment variable name on a designated delimiter (such as double underscores __) into hierarchical path segments. C. By loading an Excel spreadsheet. D. By modifying the operating system kernel.

Answer: B
Explanation:A convention like APP_DATABASE__PORT splits on __ into ["database", "port"], allowing flat environment variables to target deeply nested dictionaries.

3.

What does manager.get("database.credentials.username") accomplish? A. Executes a database query. B. Traverses nested dictionary keys using dot-delimited string syntax to retrieve a value cleanly without chaining bracket checks d["database"]["credentials"]["username"]. C. Connects to an LDAP server. D. Creates a new database user.

Answer: B
Explanation:Dot-notation path traversal walks through nested dictionary keys, returning None or a default fallback if any intermediate key is missing, avoiding KeyError exceptions.

4.

Why is a sanitized configuration export method essential in production systems? A. To convert the configuration into XML. B. To mask sensitive keys (passwords, API tokens, encryption keys) so configuration state can be safely logged for debugging without leaking credentials. C. To reduce file size on disk. D. To speed up network transmission.

Answer: B
Explanation:Logging raw configuration dumps often accidentally leaks passwords and API secrets into plaintext logs. Sanitization replaces sensitive fields with masks (e.g. "********").

5.

Which Python file extension is handled by yaml.safe_load() in the Universal Configuration Manager? A. .ini B. .yaml and .yml C. .cfg D. .env

Answer: B
Explanation:YAML configuration files conventionally use either the .yaml or .yml file extension and are parsed safely with yaml.safe_load().
Next Lesson

Unit Testing with unittest

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous LessonNext Lesson
Working with YAMLUnit Testing with unittest

Practice Quiz

Test your understanding of this lesson with 5 questions. Each question has one correct answer.

PreviousNext
PrevNext