In the Design Patterns for Scalable Test Automationwebinar we discussed the importance of adapting proper patterns for the scaling and maintaining of E-E tests. A duet of additional important aspects for End-to-End (E-E) test stability are:

• Environment-agnostic exam - Tests should be independent, self-contained units, and should run against any environment without code modification, and with no dependency on anything else (apart from the runner)

• Test information - How to foreclose tests miscarry because wait data wasn ’ t available in the scheme

In the circumstance of a web app (not bequest, thick-client applications), let ’ s lead a looking at how to deal with these challenges.

Environment-agnostic Tests

E-E test need environment-specific constellation information such as the URL, role, user gens, password, etc. Needless to say, hardcoding these portion of the test is not a good practice. It makes updates and maintenance difficult. A better solution would be to tokenize, continue the key/value pair separate and use them as piece of the test flow. Different technologies offer different tactics to handle the motivation.

For example, in the case of C # (and .NET), app.config is a good selection for carrying all the configuration tokens and values. However, the challenge demonstrate up when you want to be able to update the app.config seamlessly before executing. For exemplar, URL for DEV is different than TEST. How do you find and replace them in the config? There are a couple of ways to handle the position:

1. Create multiple app.configs per environs severally (dev.app.config, test.app.config, ..)

2. Maintain one depository, maintain one app.config, and update the app.config simply before test executing

Both approaches work in practice. However, I prefer the second approach, because it eliminates multiple sources of truth (app.config). A single rootage of truth is always better.

Tooling

For autonomous testing across multiple user personas, check out SUSATest — it explores your app like 10 different real users.

We could roll up a quick usefulness to find and replace values in app.config. However, I desire to inclose a utility that can facilitate with this:xmlpreprocess.exe. It & # x27; s a Windows-only tool, but it is self-contained, easygoing to use, and its able to integrate the CLI with CI/CD systems. Usage is bare:

1. Create app.config

2. Create an xml to cater values for each surround

3. xmlpreprocess CLI will take the values from your xml input and update the app.config

Explore more documentation and exampleshere. In the case ofWebdriverIOor early JS frameworks, we could keep them in a mere .json file and import them for use.

For example, in mysample repo, I ’ ve followed a composition model, which seem like this:

1. master.conf.js- Carries all common config across environments

2. local/wdio.conf.js- Carries local examination executing configurations, which will be immix with the master config before execution

3. saucelabs/wdio.conf.sauce.js- Carries Sauce Labs-specific shape which will be blend with the master config before execution

Similarly we could create separate configs per environment inside the Sauce Labs folder. I ’ ve yet to find a xmlpreprocess.exe like the one for JS world.

These are just few maneuver I ’ ve used, and I ’ m sure there are many early ways to achieve the goal as well. The advantages that these approaches offer are a clean separation of care between test config and code, as well as easy care and the ability to dynamically update the config as needed. So, give it a try.

Test Data Management

Here again, I ’ m speak about web application E-E examination, not thick-client applications. There are some heavyweight tools that offer professional test datum management to rejuvenate information from product, scrub the sensible data, dissemble the sensitive data and set up information on the target environs for non-prod testing, etc. However, there are a few ways to tackle the problem within the test automation codification. They include:

CRUD flow- Try to combine scenario for meaningful end-user behaviors. For example, let & # x27; s take that you are testing a Wordpress blogging application (create blog post, view the blog situation, verify visitor, view by geographics, delete the post, etc). If we logically grouping the end-user actions for that persona (i.e., generator) and group them in Create, Read, Update and Delete flow, the data needed for the adjacent step (Read) is likely created by the late step (Create). We might end up prove a larger flow at the like clip that necessary information is generated by the application constituent of the process. Data necessary for Create would hold been created by the previous workflow. We don ’ t run into the cold data sit in the system or data direction topic where code refactoring expected a new field in the dataset, but we didn ’ t get a hazard to update the test data generation script. In improver, if each one of the actions (Create, Read, Update and Delete) is an self-governing scenario, potentially some steps are repeated (i.e., launching the browser, navigate to website, login, navigate to situation page, etc). By form CRUD flow, repeated steps are optimized, and as a result, tryout finish faster.

Generate and clean up the test datum as part of the exam- Another approach is to call up your backend REST termination to return the necessary information part of trial setup. It ’ s similar to how we approach Unit examination, setup and teardown. Depending on the language of pick, there are libraries that can help in making calls to the backend and setup of the datum. At the end, clean up the data as necessary. Another approaching might be to use creature like JMeter to input necessary data before E-E suite executing.

Service virtualization- This is another coming that we leverage, typically when we ask to interact with third-party services and every hit cost something, or in event where a third party merely can ’ t stand up matching environments for all our non-prod environments. We use some tools likewiremock.org or mountebankor some commercial tools to help make the virtual services. These serve lots like disk and replay, if the dependant service is available at least erstwhile, or we can handcraft the request/responses as well. So, erst these nub are make, we need to run these virtual services in our data center and configure the UI to go through this. (There is an interesting walk-throughhere.) This will offer some stability, but we necessitate to be cognizant about keeping the nub up to date; otherwise we might run into issues.

While the commercial TDM puppet might offer much more sophisticated features, it ’ s worth trying these approaches as a initiatory step.