Python Configuration Profiles for Test Automation

in

Alright, something that’s near and dear to every test automation engineer’s heart: configuration profiles! You know what I’m talking about those ***** little files that you have to create for each environment or project you work on. They can be a real pain in the *****, but don’t worry bro! my friends, because today we’re going to make your life easier with some Python magic.

To start: why do we need configuration profiles? Well, let’s say you have an application that needs to run tests against multiple environments dev, staging, and production. Each environment has its own unique settings, like database URLs or API keys. If you hardcode these values into your test scripts, you’re going to have a bad time when it comes to maintenance and updates. That’s where configuration profiles come in handy!

So how do we create them? Let’s start with the basics: creating a profile for our dev environment. First, let’s create a new file called `dev_config.py` (you can name it whatever you want). Inside this file, add your environment-specific settings like so:

# Creating a configuration profile for a development environment

# First, we create a new file called `dev_config.py` to store our environment-specific settings
# Note: The name of the file can be changed to anything desired

# We define the database URL for our development environment
DB_URL = 'postgresql://localhost/myapp_dev'

# We also define an API key for our development environment
API_KEY = 'abc123'

# Note: Configuration profiles are useful for storing environment-specific settings, such as database URLs and API keys. 
# They allow us to easily switch between different environments without having to manually change the settings each time.

Now that we have our dev profile set up, let’s create a script to load it. Let’s call this file `load_config.py`. Inside this file, add the following code:

# Import necessary libraries
import os # Importing the os library to access operating system functionalities
from dotenv import load_dotenv # Importing the load_dotenv function from the dotenv library

# Load environment-specific settings from .env file (if available)
load_dotenv() # Calling the load_dotenv function to load environment-specific settings from a .env file

# Set default values for missing or overridden variables
DB_URL = 'postgresql://localhost/myapp' # Setting a default value for the DB_URL variable
API_KEY = '' # Setting a default value for the API_KEY variable

# Load configuration profile based on current environment
profile = os.environ['ENVIRONMENT'] # Accessing the value of the ENVIRONMENT variable from the operating system environment
config_file = f"{profile}_config.py" # Creating a string with the name of the configuration file based on the current environment
if os.path.exists(config_file): # Checking if the configuration file exists
    import imp # Importing the imp library to load the configuration file
    config = imp.load_source('config', config_file) # Loading the configuration file as a module named 'config'
    globals().update(config.__dict__) # Updating the global namespace with the variables and functions defined in the configuration file

Let’s break this down:
– We first load any environment variables from a `.env` file using the dotenv library (which we’ll create in a moment). This is optional, but it can be useful for storing sensitive information like API keys or database passwords that you don’t want to commit to your codebase.
– Next, we set default values for any variables that are missing or overridden by the configuration profile (in this case, `DB_URL` and `API_KEY`). This ensures that our tests will always have some value assigned to these variables, even if they’re not defined in the current environment.
– Finally, we load the appropriate configuration profile based on the current environment using the `os.environ[‘ENVIRONMENT’]` variable (which you can set manually or via a shell script). If the file exists, we use Python’s built-in `imp` module to import it and update our global variables with its contents.

Now that we have our load_config.py script in place, let’s create some environment variables for each of our environments:

# Set environment variable for dev environment
# The following line sets the environment variable "ENVIRONMENT" to "dev"
export ENVIRONMENT=dev

# Set environment variable for staging environment (replace 'stg' with your own value)
# The following line sets the environment variable "ENVIRONMENT" to "stg"
export ENVIRONMENT=stg

# Set environment variable for production environment (replace 'prod' with your own value)
# The following line sets the environment variable "ENVIRONMENT" to "prod"
export ENVIRONMENT=prod

And that’s it! Now you can run your tests using the load_config.py script, and it will automatically load the appropriate configuration profile based on your current environment. No more hardcoding values or dealing with multiple scripts for each environment hooray!

Of course, this is just a basic example, but you can customize it to fit your specific needs. You could add additional checks to ensure that required variables are set before running tests, or even create a script to automatically generate configuration profiles based on your application’s settings. The possibilities are endless so go forth and automate!

SICORPS