Skip to content

User Guide Overview

Welcome to the Robo Appian User Guide! This comprehensive guide will help you master automated testing of Appian applications using the Robo Appian library.

What You'll Learn

This user guide covers everything you need to know to become proficient with Robo Appian:

🏗️ Core Concepts

Understand the fundamental concepts and architecture of Robo Appian, including how it simplifies Appian UI automation.

🎯 Component Mastery

Learn to use each component utility effectively, from simple buttons to complex data tables.

🚀 Advanced Techniques

Discover powerful features like the ComponentDriver, data-driven testing, and complex workflow automation.

📋 Best Practices

Follow industry-proven patterns and practices for maintainable, reliable test automation.

🛠️ Troubleshooting

Master error handling, debugging techniques, and common issue resolution.

Guide Structure

Core Components
Core Components
Detailed guide to all Robo Appian components and their usage
 Advanced Features
Advanced Features
ComponentDriver, data-driven testing, and complex workflows
 Best Practices
Best Practices
Industry best practices for test automation
 Error Handling
Error Handling
Master debugging and error resolution techniques

Getting the Most from This Guide

Prerequisites

Before diving into this guide, make sure you have:

  • [x] Robo Appian installed - See Installation Guide
  • [x] Basic Python knowledge - Understanding of functions, classes, and imports
  • [x] Selenium familiarity - Basic understanding of WebDriver concepts
  • [x] Access to Appian - An Appian application to test against

Reading Approach

This guide is designed to be read in order, but you can also jump to specific sections:

Recommended for beginners

  1. Start with Core Components
  2. Progress through Advanced Features
  3. Study Best Practices
  4. Reference Error Handling as needed

Good for experienced users

  • Use the search function to find specific topics
  • Jump directly to component-specific sections
  • Reference best practices for specific scenarios
  • Consult error handling for troubleshooting

Learning Tips

Hands-on Practice

The best way to learn Robo Appian is by practicing. Try the examples in your own Appian environment.

Code Examples

All code examples are tested and ready to use. Copy and adapt them for your specific needs.

Version Compatibility

This guide is for Robo Appian v0.0.12+. Some features may not be available in older versions.

Core Philosophy

Understanding Robo Appian's design philosophy will help you use it more effectively:

1. Label-Based Interaction

Traditional Selenium: 

element = driver.find_element(By.XPATH, "//div[@class='appian-component']//input[@data-field='username']")
element.send_keys("testuser")

Robo Appian approach: 

InputUtils.setValueByLabelText(wait, "Username", "testuser")

Benefits: - More readable and maintainable - Resilient to UI changes - Business-user friendly

2. Component-Specific Methods

Each UI component type has dedicated utilities:

Component Type Utility Class Purpose
Text Inputs InputUtils Handle text fields, text areas
Buttons ButtonUtils Button interactions
Dropdowns DropdownUtils Dropdown selections
Date Pickers DateUtils Date input handling
Tables TableUtils Data table operations
Tabs TabUtils Tab navigation

3. Progressive Complexity

Start simple and add complexity as needed:

# Simple: Direct component interaction
ButtonUtils.clickByLabelText(wait, "Submit")

# Advanced: Data-driven with ComponentDriver
ComponentDriver.execute(wait, "Button", "Click", "Submit", None)

# Complex: Custom validation and error handling
try:
    ButtonUtils.clickByLabelText(wait, "Submit")
    if ComponentUtils.checkComponentExistsByXpath(wait, "//div[@class='success']"):
        logger.info("Submission successful")
except Exception as e:
    logger.error(f"Submission failed: {e}")
    take_screenshot("submission_error")

Common Use Cases

1. Form Automation

Filling out Appian forms with various field types:

def fill_employee_form(employee_data):
    """Fill out employee form with provided data"""
    InputUtils.setValueByLabelText(wait, "First Name", employee_data["first_name"])
    InputUtils.setValueByLabelText(wait, "Last Name", employee_data["last_name"])
    DateUtils.setValueByLabelText(wait, "Birth Date", employee_data["birth_date"])
    DropdownUtils.selectDropdownValueByLabelText(wait, "Department", employee_data["department"])
    ButtonUtils.clickByLabelText(wait, "Save Employee")

2. Data Validation

Verifying data in tables and forms:

def validate_employee_data(expected_employee):
    """Validate employee appears in the table correctly"""
    table = TableUtils.findTableByColumnName(wait, "Employee ID")
    row_count = TableUtils.rowCount(table)

    for row in range(1, row_count + 1):
        emp_id = TableUtils.findComponentFromTableCell(wait, row, "Employee ID").text
        if emp_id == expected_employee["id"]:
            name = TableUtils.findComponentFromTableCell(wait, row, "Name").text
            assert name == expected_employee["name"]
            return True

    raise AssertionError(f"Employee {expected_employee['id']} not found")

3. Workflow Testing

Testing complete business processes:

def test_employee_onboarding_workflow():
    """Test complete employee onboarding process"""
    # Login
    login_as_hr_manager()

    # Create employee
    create_new_employee(test_employee_data)

    # Assign to department
    assign_employee_to_department(test_employee_data["id"], "Engineering")

    # Set up benefits
    configure_employee_benefits(test_employee_data["id"])

    # Verify completion
    verify_employee_onboarding_complete(test_employee_data["id"])

Integration Patterns

With Testing Frameworks

Robo Appian integrates seamlessly with popular testing frameworks:

import pytest
from selenium import webdriver
from selenium.webdriver.support.ui import WebDriverWait

@pytest.fixture(scope="session")
def driver():
    driver = webdriver.Chrome()
    yield driver
    driver.quit()

@pytest.fixture
def wait(driver):
    return WebDriverWait(driver, 10)

def test_login(driver, wait):
    driver.get("https://your-appian-app.com")
    InputUtils.setValueByLabelText(wait, "Username", "testuser")
    ButtonUtils.clickByLabelText(wait, "Sign In")

import unittest
from selenium import webdriver
from selenium.webdriver.support.ui import WebDriverWait

class TestAppianUI(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Chrome()
        self.wait = WebDriverWait(self.driver, 10)

    def tearDown(self):
        self.driver.quit()

    def test_form_submission(self):
        self.driver.get("https://your-appian-app.com")
        InputUtils.setValueByLabelText(self.wait, "Name", "Test")
        ButtonUtils.clickByLabelText(self.wait, "Submit")

Next Steps

Ready to dive deeper? Choose your path:

Happy testing with Robo Appian! 🚀