Integrate NUnit test with Universal Agent

In this article, we will walk you through an example to integrate, execute, and schedule test executions for your NUnit test project with the Universal Agent

Create and Integrate an Agent with an NUnit Framework Video

For highest quality, watch the video in full-screen mode.

Notes

The test project used in this article is stored on github at https://github.com/QASymphony/dotnet-samples containing:

  • Dotnet core test projects that target .NET.Core 2.2+: xUnitSample, MSTest.ample, NUnitSample

  • Dotnet project that targets .NET.4.5 (Windows only): UnitTestSample

This article will integrate NUnitTestSample project with Universal Agent

Prerequisites

  1. Activate Automation Integrations

  2. Install and Register the Automation Host

  3. Your machine needs to have .NET.Core 2.2+ installed.

  4. Your machine needs to have git installed.

  5. This article uses a Selenium example that opens a Chrome browser, so make sure you also install Google Chrome on the machine where your Automation Host is running.

Step 1: Create a new Universal Agentfor your NUnit test project

Access your Automation Host UI. Select Add to create a new agent. The New Agent dialog displays.

Next, enter the following to the "New Agent" dialog:

General Information

  • Agent Name: enter the name of the agent, e.g. NUnit Agent

  • qTest Manager Project: select a qTest Manager project from which the agent is going to execute scheduled tests, e.g. qConnect Sample Project

  • Agent Type: select Universal Agent/strong>

Pre-Execute Script

Next, we are going to configure a pre-execute script to either clone the sample code from github or pull the latest updates of that repo if it already exists in the host machine.

Enter the script below in the Pre-Execute Script editor, which is specific to the Operating System that the Automation Host is running:

Windows

if not exist "C:\dotnet-samples" (
 cd /d C:\
 git clone https://github.com/QASymphony/dotnet-samples
) else (
 cd /d "C:\dotnet-samples"
 git pull --all
)

Linux or Mac

#!/bin/bash if [ ! -d "/usr/local/var/dotnet-samples" ] then  cd "/usr/local/var"  git clone https://github.com/QASymphony/dotnet-samples else  cd /usr/local/var/dotnet-samples  git pull --all fi

Execute Command

Executor: select node as the script executor

Working Directory: 

  • If your host machine is running on Linux or Mac. enter /usr/local/var/dotnet-samples

  • If your host machine is running on Windows. enter C:\dotnet-samples

Execute Command

We are going to create a script written in NodeJS to:

  • obtain the automation content(s) of scheduled test runs by resolving the value of magic variable TESTCASES_AC. Refer to Using Magic Variables in Universal Agent to learn more about Magic Variables in Universal Agent

  • if the value of the TESTCASES_AC variable is empty, meaning there are no test runs being scheduled for execution (e.g. when this Universal Agentis executed in the first time), we will let the agent execute whole tests in our NUnitSample project and then create test run logs within qTest Manager as the execution result.

  • if TESTCASES_AC variable has value, these being the automation contents of scheduled test runs, we will instruct Universal Agentto only execute tests that match those automation contents.

Enter the code snippet below to the Execute Command editor.

// sample Execute Command for executing .NET.core test with node executor

const fs = require('fs');
const path = require('path');
const { execSync } = require('child_process');

let isWin = process.platform == "win32";

// process.env.WORKING_DIR holds the value of Working Directory configured in Universal Agent
// if you did not specify Working Directory in Universal Agent make sure you enter it here
let SOLUTION_DIR = process.env.WORKING_DIR || ``;
// validate the existence of SOLUTION_DIR, it it does not exist, print error and stop execution
if (!fs.existsSync(SOLUTION_DIR)) {
    console.error('No working directory found.');
    return;
}

// change .NET.core version to fit your need
let TARGET_DOTNETCORE_VERSION = '2.2';

// path to test project, change it to reflect yours
let TEST_PROJECT_NAME = 'NUnitTestSample';
let TEST_PROJECT_DIR = path.resolve (SOLUTION_DIR, 'DotnetCore', TEST_PROJECT_NAME);
let TEST_PROJECT_PATH = path.resolve(TEST_PROJECT_DIR, `${TEST_PROJECT_NAME}.csproj`);

// possible value for configuration: Debug or Release
let CONFIGURATION = 'Debug';
// we are going to execute published test
let PUBLISH_DIR = path.resolve(TEST_PROJECT_DIR, 'bin', CONFIGURATION, `netcoreapp${TARGET_DOTNETCORE_VERSION}`, 'publish');
// path to the test project output
let TEST_PROJECT_PUBLISHED_PATH = path.resolve(PUBLISH_DIR, `${TEST_PROJECT_NAME}.dll`);

// this is the full path to dotnet command
// make sure you change it to reflect your environment
let DO.NET.EXECUTABLE_PATH = isWin ? 'C:/Program Files/dotnet/dotnet.exe' : '/usr/local/bin/dotnet/dotnet';

// by default, the result folder will be created at  ${SOLUTION_DIR}/TestResults
let RESULT_DIR = path.resolve(`${SOLUTION_DIR}`, 'TestResults');
// this is the path to XML test result
let PATH_TO_XML_RESULT = path.resolve(`${RESULT_DIR}`, 'Results.xml');

// delete result dir if it exists
if (fs.existsSync(RESULT_DIR)) {
    if (isWin) {
        execSync(`rmdir /s /q "${RESULT_DIR}"`);
    } else {
        execSync(`rm -rf "${RESULT_DIR}"`);
    }
}

// the shell command builder
var commandBuilder = [];
// set DO.NET.CLI_HOME environment var to working directory for dotnet command to work properly if (!isWin) {   commandBuilder.push(`export DO.NET.CLI_HOME="${SOLUTION_DIR}"`); }

// execute `dotnet publish` command to publish the test project,
// the published results will be stored in PUBLISH_DIR
commandBuilder.push(`"${DO.NET.EXECUTABLE_PATH}" publish "${TEST_PROJECT_PATH}"`);

// copy the chromedriver to the PUBLISH_DIR dir for the Selenium test to run properly
// remove these commands if you're not running Selenium tests and so there will be no chromedriver in the output
let CHROME_DRIVER_NAME = isWin ? 'chromedriver.exe' : 'chromedriver';
let COPY_COMMAND = isWin ? 'copy' : 'cp';
let PATH_TO_CHROME_DRIVER = path.resolve(TEST_PROJECT_DIR, 'bin', CONFIGURATION, `netcoreapp${TARGET_DO.NET.ORE_VERSION}`, CHROME_DRIVER_NAME);
commandBuilder.push(`${COPY_COMMAND} "${PATH_TO_CHROME_DRIVER}" "${PUBLISH_DIR}"`);

// resolve TESTCASES_AC magic var to get the scheduled test runs
let testcases_AC = $TESTCASES_AC;
testcases_AC = testcases_AC ? testcases_AC.split(',') : [];

/**
 * Kicks off the test. What it does is to resolve the value of `testcases_AC` variable and validate:
 * Case 1: if that variable has value, meaning there is/are test run(s) being scheduled in qTest Manager
 *   -- executes the the test method whose name matching the automation content
 * Case 2: the value of testcases_AC is empty, meaning no test runs being scheduled when the Universal Agentis executed in the first time
 *   -- executes all the tests within the project output DLL
 */
var testMethods = '';
if (testcases_AC && testcases_AC.length > 0) {
    testMethods = '/Tests:';
    for (let testcase_AC of testcases_AC) {
        testMethods += `${testcase_AC},`;
    }
    testMethods = testMethods.slice(0, -1);// remove the last ','
}

if (testMethods != '') {
    // run specific test methods, change the log file path if possible
    commandBuilder.push(`"${DO.NET.EXECUTABLE_PATH}" vstest "${TEST_PROJECT_PUBLISHED_PATH}" ${testMethods} --logger:"nunit;LogFilePath=${PATH_TO_XML_RESULT}"`);
} else {
    // run all tests, change the log file path if possible
    commandBuilder.push(`"${DO.NET.EXECUTABLE_PATH}" vstest "${TEST_PROJECT_PUBLISHED_PATH}" --logger:"nunit;LogFilePath=${PATH_TO_XML_RESULT}"`);
}

// wrap the command execution in a try catch to make sure the execute command is fully executed
// even when there is error happens.
try {
    // Build the shell command
    let command = isWin ? commandBuilder.join(' && ') : commandBuilder.join('\n');
    // execute the shell command
    execSync(command, { stdio: "inherit" });
} catch (err) {
    console.error(`*** Test execution error ***`);
    console.error(err.message || err);
    console.error(`*** End Test Execution error ***`);
}

Path to Results

Enter the value below to specify the path to the test results generated when the execution completes:

  • If your host machine is running on Linux or Mac: /usr/local/var/dotnet-samples/TestResults

  • If your host machine is running on Windows. C:\dotnet-samples\TestResults

Result Parser

Select NUnit as the Result Parser.

Note: if you do not find the NUnit parser in the Result Parser list, follow the below steps to make it available to the Universal Agent

  1. Temporarily save the NUnit agent. You'll be returned back to the Automation Host dashboard.

  2. Download NUnit parser HERE.

  3. Access qTest Launch. and refer to Upload the Parser to qTest Launch to upload the Parser to qTest Launch.

  4. Go back to Automation Host UI and refresh the page so to load the new parsers.

  5. Select to edit NUnit agent and you'll find the NUnit parser from the Result Parser list.

  6. Select SAVE to finish creating the agent. Below is how NUnit Agent looks like, on Mac.

Step 2: Execute the Agent

From the Agents list, locate the NUnit Agent and select Run Now.

The agent execution dialog will display:

Select Execute to execute the agent. Once the execution completes, the Console Log shows all that test results have been submitted to qTest Manager, as highlighted in the screenshot below.

Next, access qTest Manager. Select qConnect Sample Project and then access the Test Execution module. You'll see the test results submitted to qTest Manager as Test Runs under a Test Suite named "Automation YYYY-MM-DD," where YYYY-MM-DD is the date the agent is executed, as below.

Now we are going to schedule Test Execution for some selected test runs with the NUnit Agent and verify that it only executes tests that match the scheduled test runs as well as submitting the test run results.

Step 3: Schedule Test Execution for Specific Test Runs

From qTest Manager, select the project qConnect Sample Project and select the Test Execution tab. Then, do the following:

  1. Select the newly created test suite. In our example, it is Automation 2019-01-15.

  2. From the test run list on the right, select the first four (4) test runs.

  3. Select MORE, and choose Schedule from the drop-down menu.

In the SCHEDULE AUTOMATION TEST EXECUTION dialog, enter the following:

  1. Name: name of the schedule, e.g. Execute NUnit Test with Universal Agent/strong>

  2. Agent: select the NUnit Agent 

  3. Select OK to complete Test Execution scheduling for the selected three test runs.

Now go back to the Automation Host UI. Select Poll Now.

At this stage, the Automation Host does the following:

  • immediately polls to qTest Manager to load schedule jobs and

  • executes the job execution for the test methods in the NUnitTestSample project that match the automation content of the four scheduled test runs

Wait for the execution completes. Then, select the View Log icon to view the execution log.

A log screen will display that shows the laTest Execution logs. Verify that the log reported only two (2) tests being executed.

Now, access the Test Execution module of the qConnect Sample Project in qTest Manager. Select each test run that was scheduled to be executed and you'll see that the Execution History of each test run was updated with 2 test run logs: one test log created when the agent was first executed and one test log from the scheduled execution.

You have successfully scheduled a Test Execution for specific tests in your NUnit test project using the Universal Agentand had it reported the Test Execution to qTest Manager.