Simplifying your test runs with ‘make’

The ‘make’ command has been around since 1976 and was originally used to build executable programs. In this talk I want to show how this powerful tool can greatly reduce complexity and eliminate stumbling blocks of running your automated tests. This applies to both CI pipelines and local test runs on developer or QA machines.

 
 

Outline/Structure of the Case Study

  • Description of our old way to run tests (via Maven) and its drawbacks
    • Passing a lot of parameters
    • Disallowed parameter combinations
    • Required installation of Java and Maven on all machines
    • Steep learning curve
  • Brief history of make
  • How make works and its original purpose
  • Walk through some techniques of our make file
    • One way of running tests in different environments
    • Verification of parameters
    • Invocation of parallel test runs
    • Triggering of complex scripts
    • Wrap complex internals into a simplified CLI tool
  • Summary

Learning Outcome

  • Understand how automation engineers can simplify test runs using ‘make’
  • See the benefits of Makefiles for different use cases
  • Realize that “old” technology can be used to solve new problems

Target Audience

Automation engineers, developers, QA

Prerequisites for Attendees

Basic understanding of CI and build management

schedule Submitted 4 months ago

Public Feedback

comment Suggest improvements to the Speaker
  • Maaret Pyhajarvi
    By Maaret Pyhajarvi  ~  2 months ago
    reply Reply

    20 minute talk to lead from how some folks use maven (whereas some are in different language ecosystems where maven would not be an obvious choice) to specific techniques you use on your makefile leads me to two questions your abstract could answer better:

    1. What are those techniques: is there one, several, can you name them? Should I care what is in that box and why?

    2. 20 minutes could be ok for a very specific technique, but then your old way is over detailed and the new way is under detailed in the outline. 

    • Benjamin Bischoff
      By Benjamin Bischoff  ~  2 months ago
      reply Reply

      Very good points that I will change and clarify further. The beauty of makefile is that it wraps away the complexity of the underlying system. Since I use Maven, I took this as a base. But this could also be replaced with a more general (blackbox) system. If it is alright, I will update the proposal tomorrow morning.


  • Liked Benjamin Bischoff
    keyboard_arrow_down

    Benjamin Bischoff - Smoke tests and mirrors - magic principles in test automation

    45 Mins
    Talk
    Beginner

    Having been a hobbyist magician for 34 years, I started noticing that some close-up and stage magic principles and theories don't only apply to magic tricks but also to software testing.

    An example of this is the application of the KISS principle (Keep It Simple, Stupid) in software development. This helps to avoid unnecessary code complexity and make it easy to understandable and follow. In magic, this applies as well. Magicians strive for clarity and simplicity by creating effects that are easy to follow for spectators.

    In this sessions, I will try to connect those two worlds and thus combine two of my passions. Also, I will try my best to illustrate the magic side of things with demonstrations. This is a challenge I set for myself - let’s see how it goes.

  • Liked Khanh Do
    keyboard_arrow_down

    Khanh Do - Leveraging Artificial Intelligence to create self-healing tests

    Khanh Do
    Khanh Do
    QA Architect
    Kobiton
    schedule 4 months ago
    Sold Out!
    45 Mins
    Tutorial
    Intermediate

    A key requirement for successful test automation is to get past the brittle or fragile nature of test scripts. Any Selenium (or Appium) developer has encountered the dreaded "NoSuchElement Exception". A locator that worked yesterday may fail today. What's a test engineer to do?

    Fortunately the field of AI provides promising solutions and allows for the creation of self-healing tests. Tests that can find elements across all environments. Tests that can learn from "human-in-the-loop" intervention and work perfectly thereafter. Imagine automated tests that "just work"!

    This session will look at how to apply the latest in AI and Machine Learning technologies to improve your test scripts. With the plethora of new open source AI libraries made available by companies such as Google, the ability to leverage AI in your applications is more accessible than ever.

    This session will be a primer on AI technologies and how they can be utilized for perfect test automation.