ATF Test-Driven Development Pattern for…

advancedTested on Xanadu

The ATF Test-Driven Development (TDD) pattern involves writing Automated Test Framework tests before implementing features, following the red-green-refactor cycle. This approach ensures that code meets requirements from the start and maintains high test coverage throughout development.

This pattern addresses the challenge of maintaining code quality and reducing regression bugs in ServiceNow implementations. By writing tests first, developers are forced to think through requirements clearly and design more testable, modular code. The pattern includes organizing test suites logically, setting up test data through records rather than hardcoded values, using impersonation to test role-based functionality, and integrating tests into CI/CD pipelines for automated validation.

The implementation involves creating test suites organized by feature areas, using data-driven test approaches with setup and teardown methods, leveraging ATF's impersonation capabilities for security testing, and configuring automated test execution through REST APIs or Update Sets in deployment pipelines.

Chrome Extension

Sourdough: ServiceNow Monitoring and Analytics

A Chrome extension for ServiceNow Admins and Developers with essential tools, analytics, graphs and monitoring features.

Instance HealthGraphs & ChartsAPI HealthDeveloper ToolsQuick SearchInstance Switcher

Add to Chrome

Free to install. Pro $5/month after a 14-day no-card trial.
Pro requires the ServiceNow admin role. Upgrade inside the extension.

Overview

Tasks

CMDB

API

Metrics

Monitor

Internals

Instance:sourdoughdev·Version:Yokohama

Instance StateONLINE

System StatusFully Operational

Session Timeout90 minutes

Logged-In Sessions2 (20 active)

Build Nameyokohama-12-18-2024_p1

IP Address10.159.128.43

Instance HealthHealth Score: 90%

🔥 5dSourdough (Chrome Plugin)Dark Mode

Use This When

Use this pattern when developing new features or major enhancements where requirements are well-defined and code quality is critical. It's particularly valuable for complex business logic, integrations, or functionality that will be maintained by multiple developers over time.

Avoid When

Avoid this pattern for rapid prototyping, simple configuration changes, or when requirements are highly volatile and changing frequently. The upfront time investment in writing tests may not be justified for throwaway proof-of-concepts or very simple customizations.

Implementation

Server-side

// Test Suite Setup Script Include
var TestDataManager = Class.create();
TestDataManager.prototype = {
    initialize: function() {
        this.testDataPrefix = 'ATF_TEST_';
        this.createdRecords = [];
    },
    
    createTestIncident: function(properties) {
        var incident = new GlideRecord('incident');
        incident.initialize();
        incident.short_description = this.testDataPrefix + (properties.short_description || 'Test Incident');
        incident.description = properties.description || 'Created by ATF test';
        incident.priority = properties.priority || '3';
        incident.urgency = properties.urgency || '3';
        incident.category = properties.category || 'software';
        incident.caller_id = properties.caller_id || this.getTestUser();
        var sysId = incident.insert();
        this.createdRecords.push({table: 'incident', sys_id: sysId});
        return sysId;
    },
    
    createTestUser: function(roles) {
        var user = new GlideRecord('sys_user');
        user.initialize();
        user.user_name = this.testDataPrefix + 'user_' + gs.generateGUID().substring(0, 8);
        user.first_name = 'Test';
        user.last_name = 'User';
        user.email = user.user_name + '@test.com';
        user.active = true;
        var userSysId = user.insert();
        this.createdRecords.push({table: 'sys_user', sys_id: userSysId});
        
        // Add roles if specified
        if (roles) {
            for (var i = 0; i < roles.length; i++) {
                this.addRoleToUser(userSysId, roles[i]);
            }
        }
        return userSysId;
    },
    
    addRoleToUser: function(userSysId, roleName) {
        var roleGr = new GlideRecord('sys_user_role');
        roleGr.addQuery('name', roleName);
        roleGr.query();
        if (roleGr.next()) {
            var userRole = new GlideRecord('sys_user_has_role');
            userRole.initialize();
            userRole.user = userSysId;
            userRole.role = roleGr.sys_id;
            var userRoleSysId = userRole.insert();
            this.createdRecords.push({table: 'sys_user_has_role', sys_id: userRoleSysId});
        }
    },
    
    getTestUser: function() {
        var user = new GlideRecord('sys_user');
        user.addQuery('user_name', 'CONTAINS', this.testDataPrefix);
        user.query();
        if (user.next()) {
            return user.sys_id;
        }
        return this.createTestUser(['itil']);
    },
    
    cleanupTestData: function() {
        gs.info('Cleaning up ' + this.createdRecords.length + ' test records');
        for (var i = this.createdRecords.length - 1; i >= 0; i--) {
            var record = this.createdRecords[i];
            var gr = new GlideRecord(record.table);
            if (gr.get(record.sys_id)) {
                gr.deleteRecord();
            }
        }
        this.createdRecords = [];
    },
    
    type: 'TestDataManager'
};

// Example Business Rule to Test
var IncidentEscalationRule = Class.create();
IncidentEscalationRule.prototype = {
    initialize: function() {},
    
    checkEscalation: function(incidentGr) {
        if (!incidentGr || !incidentGr.isValidRecord()) {
            return false;
        }
        
        // Escalate P1 incidents that are unassigned for more than 15 minutes
        if (incidentGr.priority == '1' && !incidentGr.assigned_to) {
            var created = new GlideDateTime(incidentGr.sys_created_on);
            var now = new GlideDateTime();
            var diffMinutes = gs.dateDiff(created.toString(), now.toString(), true) / (1000 * 60);
            
            if (diffMinutes > 15) {
                this.escalateIncident(incidentGr);
                return true;
            }
        }
        return false;
    },
    
    escalateIncident: function(incidentGr) {
        incidentGr.state = '2'; // In Progress
        incidentGr.urgency = '1'; // High urgency
        incidentGr.work_notes = 'Auto-escalated: P1 incident unassigned for over 15 minutes';
        incidentGr.update();
        gs.info('Incident ' + incidentGr.number + ' auto-escalated');
    },
    
    type: 'IncidentEscalationRule'
};

Client-side

// ATF Test Step - Client Script for UI Testing
function testIncidentFormValidation() {
    // This would be used in an ATF UI test step
    var shortDesc = g_form.getValue('short_description');
    var category = g_form.getValue('category');
    
    // Validate required fields
    if (!shortDesc || shortDesc.length < 10) {
        g_form.addErrorMessage('Short description must be at least 10 characters');
        return false;
    }
    
    if (!category) {
        g_form.addErrorMessage('Category is required');
        return false;
    }
    
    // Test auto-population logic
    if (category === 'hardware') {
        g_form.setValue('subcategory', 'computer');
        g_form.setValue('assignment_group', 'Hardware Support');
    }
    
    return true;
}

// ATF REST Test - Query test results
function queryATFResults(testSuiteSysId) {
    var ga = new GlideAjax('ATFResultsAjax');
    ga.addParam('sysparm_name', 'getTestResults');
    ga.addParam('sysparm_test_suite_id', testSuiteSysId);
    ga.getXMLAnswer(function(response) {
        var results = JSON.parse(response);
        console.log('Test Results: ' + results.passed + ' passed, ' + results.failed + ' failed');
    });
}

The code demonstrates a complete TDD setup with a TestDataManager class for creating and cleaning up test data, and an IncidentEscalationRule class representing the business logic under test. The TestDataManager tracks all created records for proper cleanup and provides methods for creating realistic test scenarios with users, roles, and incidents. The client code shows how to implement UI validation tests and query ATF results programmatically.

Alternatives

Manual Testing with ATF

Write ATF tests after implementation for regression testing rather than driving development. Faster initial development but higher risk of missing edge cases and less testable code architecture.

Unit Testing with Jasmine

Use ServiceNow's Jasmine framework for pure JavaScript unit tests without UI interaction. Faster test execution and better isolation but cannot test ServiceNow-specific APIs or platform integration points.

Integration Testing Only

Focus on end-to-end integration tests through REST APIs or web services without internal unit tests. Better coverage of real-world scenarios but slower feedback loop and harder debugging when tests fail.

Test Your Knowledge

Quick 3-question quiz — see how your ServiceNow skills stack up.

Question 1 of 3Performance

A list view on a table with millions of records is slow. Best fix?

Select an answer to continue