Help designing unit tests?

How do people write unit tests with Ignition? I have finally, FINALLY, refactored this project and completely decoupled the business logic from the GUI and so the first thing I want to do is write some unit tests so anytime we make a change, we can check all the usual processes and make sure nothing unexpectedly broke, move away from the "production is the QA environment" paradigm we have going on now.

This app is 99% CRUD routes for various db forms. So right now I am writing functions that are testing the creation/update/deleting of records and checking I get the appropriate result.

Here's my first attempt -

def customerTests():
	# Create a new customer, customer name TestCustomer1000
	newCustomer = {...}
	newCreateResult = forms2.Forms.Customer.create(newCustomer)
	print 'creating customer'
	assert newCreateResult.success == True
	print 'passed'
	# Update the new customer to TestCustomer1001
	updateCustomerData = {...}
	# newCreateResult.result is the idx of the newly created one
	customerUpdateResult = forms2.Forms.Customer.update(updateCustomerData, newCustomer, newCreateResult.result)
	print 'updating..'
	assert customerUpdateResult.success == True
	print 'passed'
	# Try to update customer name to existing Customer Name- this should fail
	updateToExistingCustomerName = {...}
	shouldFailUpdate = forms2.Forms.Customer.update(updateToMesser, updateCustomerData, newCreateResult.result)
	print 'trying fail update'
	assert shouldFailUpdate.success == False
	print 'passed'
	# Delete the new customer
	newDeleteResult = forms2.Forms.Customer.delete(newCreateResult.result)
	print 'deleting..'
	assert newDeleteResult.success == True
	print 'passed'

And then I would call this and just make sure no assertion error comes up. I am wondering if this is how most people do it or if there is other better methods for writing unit tests specifically within the context of Ignition.

While this won't make you design better tests, it can be helpful to write them.

click for code
import ast

Basic test helper

Import test in your file: from utils.test import test

Decorate your functions to be tested:
def test_foo():
    foo = "foo"
    bar = get_bar()
    assert foo == bar, "expected {}, got {}".format(foo, bar)

Call the function individually, or use run_tests() to run all the marked functions in modules:
run_tests(module_1, module_b)

class TestFinder(ast.NodeVisitor):
	def visit_Module(self, node):
		self.test_funcs = []

	def visit_FunctionDef(self, node):
		if "test" in ( for deco in node.decorator_list):
	def get_testfuncs(self):
		return self.test_funcs

def test(func):
	Decorator to mark functions to be tested.
	Simply import the decorator (from Tests.utils import test) and add @test before the function

	def wrapper():
		except AssertionError as e:
			message = "failed ({})".format(e)
			message = "passed"
		return message
	return wrapper

def run_tests(*modules):
	Run all the functions marked as tests (with the test decorator) in every packages passed as parameter.
	for m in modules:
		print("{}\ntesting functions in {}...".format("-"*20,

		tree = ast.parse(m.code)
		f = TestFinder()
		funcs = f.get_testfuncs()

		if not funcs:
			print("No functions marked for testing found in {}".format(
		for f in funcs:
				message = getattr(m, f)()
				print("{:.<40}{}".format(f, message))
			except BaseException as e:


Write your tests as simple functions, decorate them with @test, then run run_test(module1, module2, etc) wherever you want (usually the script console though).
I haven't used it in a while, and if I remember correctly there were a few quirks. I may or may not have fixed them.

edit: forgot to format code :X

note: You can use run_tests() to run all the tests in the modules passed as arguments, or just call a function that's decorated with @test directly


Something went wrong with your code formatting there.

What went wrong with the formatting was that there was no formatting :smiley: