Update GDUnit

Author: Structed

addons/gdUnit4/bin/GdUnitCmdTool.gd

@@ -27,7 +27,6 @@ class CLIRunner extends Node:
 	var _runner_config := GdUnitRunnerConfig.new()
 	var _console := CmdConsole.new()
 	var _cs_executor
-	var _rtf :RichTextLabel
 	var _cmd_options: = CmdOptions.new([
 			CmdOption.new("-a, --add", "-a <directory|path of testsuite>", "Adds the given test suite or directory to the execution pipeline.", TYPE_STRING),
 			CmdOption.new("-i, --ignore", "-i <testsuite_name|testsuite_name:test-name>", "Adds the given test suite or test case to the ignore list.", TYPE_STRING),
@@ -62,8 +61,6 @@ class CLIRunner extends Node:
 			push_error("Error checked startup, can't connect executor for 'send_event'")
 			quit(RETURN_ERROR)
 		add_child(_executor)
-		_rtf = RichTextLabel.new()
-		add_child(_rtf)
 
 
 	func _process(_delta):
@@ -93,14 +90,8 @@ class CLIRunner extends Node:
 	func quit(code :int) -> void:
 		if is_instance_valid(_executor):
 			_executor.free()
-		if is_instance_valid(_rtf):
-			_rtf.free()
 		GdUnitTools.dispose_all()
 		await get_tree().physics_frame
-		prints("-Orphan nodes report-----------------------")
-		Window.print_orphan_nodes()
-		prints("-SceneTree report-----------------------")
-		get_tree().root.print_tree_pretty()
 		get_tree().quit(code)
 
 
@@ -308,25 +299,35 @@ class CLIRunner extends Node:
 			GdUnitEvent.STOP:
 				var report_path := _report.write()
 				_report.delete_history(_report_max)
-				JUnitXmlReport.new(_report._report_path, _report.iteration(), _rtf).write(_report)
+				JUnitXmlReport.new(_report._report_path, _report.iteration()).write(_report)
 				_console.prints_color("Total test suites: %s" % _report.suite_count(), Color.DARK_SALMON)
 				_console.prints_color("Total test cases:  %s" % _report.test_count(), Color.DARK_SALMON)
 				_console.prints_color("Total time:        %s" % LocalTime.elapsed(_report.duration()), Color.DARK_SALMON)
 				_console.prints_color("Open Report at: file://%s" % report_path, Color.CORNFLOWER_BLUE)
 			GdUnitEvent.TESTSUITE_BEFORE:
 				_report.add_testsuite_report(GdUnitTestSuiteReport.new(event.resource_path(), event.suite_name()))
 			GdUnitEvent.TESTSUITE_AFTER:
-				_report.update_test_suite_report(event.resource_path(), event.elapsed_time())
+				_report.update_test_suite_report(
+					event.resource_path(),
+					event.elapsed_time(),
+					event.is_error(),
+					event.is_failed(),
+					event.is_warning(),
+					event.is_skipped(),
+					event.skipped_count(),
+					event.failed_count(),
+					event.orphan_nodes(),
+					event.reports())
 			GdUnitEvent.TESTCASE_BEFORE:
-				_report.add_testcase_report(event.resource_path(), GdUnitTestCaseReport.new(_rtf, event.resource_path(), event.suite_name(), event.test_name()))
+				_report.add_testcase_report(event.resource_path(), GdUnitTestCaseReport.new(event.resource_path(), event.suite_name(), event.test_name()))
 			GdUnitEvent.TESTCASE_AFTER:
 				var test_report := GdUnitTestCaseReport.new(
-					_rtf,
 					event.resource_path(),
 					event.suite_name(),
 					event.test_name(),
 					event.is_error(),
 					event.is_failed(),
+					event.failed_count(),
 					event.orphan_nodes(),
 					event.is_skipped(),
 					event.reports(),
@@ -358,17 +359,17 @@ class CLIRunner extends Node:
 				_print_status(event)
 				_print_failure_report(event.reports())
 			GdUnitEvent.TESTSUITE_AFTER:
+				_print_failure_report(event.reports())
 				_print_status(event)
 				_console.prints_color("	| %d total | %d error | %d failed | %d skipped | %d orphans |\n" % [_report.test_count(), _report.error_count(), _report.failure_count(), _report.skipped_count(), _report.orphan_count()], Color.ANTIQUE_WHITE)
 
 
 	func _print_failure_report(reports :Array) -> void:
 		for report in reports:
-			_rtf.clear()
-			_rtf.parse_bbcode(report._to_string())
 			if report.is_failure() or report.is_error() or report.is_warning() or report.is_skipped():
 				_console.prints_color("	Report:", Color.DARK_TURQUOISE, CmdConsole.BOLD|CmdConsole.UNDERLINE)
-				for line in _rtf.get_parsed_text().split("\n"):
+				var text = GdUnitTools.richtext_normalize(report._to_string())
+				for line in text.split("\n"):
 					_console.prints_color("		%s" % line, Color.DARK_TURQUOISE)
 		_console.new_line()
 
@@ -397,3 +398,8 @@ func _initialize():
 func _finalize():
 	prints("Finallize ..")
 	_cli_runner.free()
+	prints("-Orphan nodes report-----------------------")
+	Window.print_orphan_nodes()
+	prints("-SceneTree report-----------------------")
+	root.print_tree_pretty()
+	prints("Finallize .. done")

addons/gdUnit4/plugin.cfg

@@ -3,5 +3,5 @@
 name="gdUnit4"
 description="Unit Testing Framework for Godot Scripts"
 author="Mike Schulze"
-version="4.1.3"
+version="4.1.4"
 script="plugin.gd"

addons/gdUnit4/src/GdUnitGodotErrorAssert.gd

@@ -0,0 +1,46 @@
+## An assertion tool to verify for Godot runtime errors like assert() and push notifications like push_error().
+class_name GdUnitGodotErrorAssert
+extends GdUnitAssert
+
+
+## Verifies if the executed code runs without any runtime errors
+## Usage:
+##     [codeblock]
+##		await assert_error(<callable>).is_success()
+##     [/codeblock]
+func is_success() -> GdUnitGodotErrorAssert:
+	await Engine.get_main_loop().process_frame
+	return self
+
+
+## Verifies if the executed code runs into a runtime error
+## Usage:
+##     [codeblock]
+##		await assert_error(<callable>).is_runtime_error(<expected error message>)
+##     [/codeblock]
+@warning_ignore("unused_parameter")
+func is_runtime_error(expected_error :String) -> GdUnitGodotErrorAssert:
+	await Engine.get_main_loop().process_frame
+	return self
+
+
+## Verifies if the executed code has a push_warning() used
+## Usage:
+##     [codeblock]
+##		await assert_error(<callable>).is_push_warning(<expected push warning message>)
+##     [/codeblock]
+@warning_ignore("unused_parameter")
+func is_push_warning(expected_warning :String) -> GdUnitGodotErrorAssert:
+	await Engine.get_main_loop().process_frame
+	return self
+
+
+## Verifies if the executed code has a push_error() used
+## Usage:
+##     [codeblock]
+##		await assert_error(<callable>).is_push_error(<expected push error message>)
+##     [/codeblock]
+@warning_ignore("unused_parameter")
+func is_push_error(expected_error :String) -> GdUnitGodotErrorAssert:
+	await Engine.get_main_loop().process_frame
+	return self

addons/gdUnit4/src/GdUnitTestSuite.gd

@@ -17,6 +17,11 @@ extends Node
 
 const NO_ARG = GdUnitConstants.NO_ARG
 
+### internal runtime variables that must not be overwritten!!!
+var __is_skipped := false
+var __skip_reason :String = "Unknow."
+
+
 ## This function is called before a test suite starts[br]
 ## You can overwrite to prepare test data or initalizize necessary variables
 func before() -> void:
@@ -41,19 +46,10 @@ func after_test() -> void:
 	pass
 
 
-## Skip the test-suite from execution, it will be ignored
-func skip(skipped :bool) -> void:
-	set_meta("gd_skipped", skipped)
-
-
 func is_failure(_expected_failure :String = NO_ARG) -> bool:
 	return Engine.get_meta("GD_TEST_FAILURE") if Engine.has_meta("GD_TEST_FAILURE") else false
 
 
-func is_skipped() -> bool:
-	return get_meta("gd_skipped") if has_meta("gd_skipped") else false
-
-
 var __active_test_case :String
 func set_active_test_case(test_case :String) -> void:
 	__active_test_case = test_case
@@ -525,15 +521,42 @@ func assert_signal(instance :Object) -> GdUnitSignalAssert:
 	return GdUnitSignalAssertImpl.new(instance)
 
 
-## Verifiys an assertion is failing as expected
-## This assert is only designed for internal use to verify failing asserts working as expected
+## An assertion tool to test for failing assertions.[br]
+## This assert is only designed for internal use to verify failing asserts working as expected.[br]
 ## Usage:
 ##     [codeblock]
 ##		assert_failure(func(): assert_bool(true).is_not_equal(true)) \
-##			.has_message("Expecting:\n 'true'\n not equal to\n 'true'")
+##		    .has_message("Expecting:\n 'true'\n not equal to\n 'true'")
 ##     [/codeblock]
 func assert_failure(assertion :Callable) -> GdUnitFailureAssert:
-	return GdUnitFailureAssertImpl.new(assertion)
+	return GdUnitFailureAssertImpl.new().execute(assertion)
+
+
+## An assertion tool to test for failing assertions.[br]
+## This assert is only designed for internal use to verify failing asserts working as expected.[br]
+## Usage:
+##     [codeblock]
+##		await assert_failure_await(func(): assert_bool(true).is_not_equal(true)) \
+##		    .has_message("Expecting:\n 'true'\n not equal to\n 'true'")
+##     [/codeblock]
+func assert_failure_await(assertion :Callable) -> GdUnitFailureAssert:
+	return await GdUnitFailureAssertImpl.new().execute_and_await(assertion)
+
+
+## An assertion tool to verify for Godot errors.[br]
+## You can use to verify for certain Godot erros like failing assertions, push_error, push_warn.[br]
+## Usage:
+##     [codeblock]
+##		# tests no error was occured during execution the code
+##		await assert_error(func (): return 0 )\
+##		    .is_success()
+##		
+##		# tests an push_error('test error') was occured during execution the code
+##		await assert_error(func (): push_error('test error') )\
+##		    .is_push_error('test error')
+##     [/codeblock]
+func assert_error(current :Callable) -> GdUnitGodotErrorAssert:
+	return GdUnitGodotErrorAssertImpl.new(current)
 
 
 ## Utility to check if a test has failed in a particular line and if there is an error message

addons/gdUnit4/src/asserts/GdAssertMessages.gd

@@ -156,8 +156,21 @@ static func test_timeout(timeout :int) -> String:
 	return "%s\n %s" % [_error("Timeout !"), _colored_value("Test timed out after %s" %  LocalTime.elapsed(timeout))]
 
 
+static func test_suite_skipped(hint :String, skip_count) -> String:
+	return """
+		%s
+		  Tests skipped: %s
+		  Reason: %s
+		""".dedent().trim_prefix("\n")\
+		% [_error("Entire test-suite is skipped!"), _colored_value(skip_count), _colored_value(hint)]
+
+
 static func test_skipped(hint :String) -> String:
-	return "%s\n %s" % [_error("This test is skipped!"), "Reason: %s" % _colored_value(hint)]
+	return """
+		%s
+		  Reason: %s
+		""".dedent().trim_prefix("\n")\
+		% [_error("This test is skipped!"), _colored_value(hint)]
 
 
 static func error_not_implemented() -> String:

addons/gdUnit4/src/asserts/GdAssertReports.gd

@@ -5,8 +5,9 @@ const LAST_ERROR = "last_assert_error_message"
 const LAST_ERROR_LINE = "last_assert_error_line"
 
 
-static func report_success(_line_number :int) -> void:
+static func report_success() -> void:
 	GdUnitSignals.instance().gdunit_set_test_failed.emit(false)
+	GdAssertReports.set_last_error_line_number(-1)
 	Engine.remove_meta(LAST_ERROR)
 
 
@@ -17,6 +18,7 @@ static func report_warning(message :String, line_number :int) -> void:
 
 static func report_error(message:String, line_number :int) -> void:
 	GdUnitSignals.instance().gdunit_set_test_failed.emit(true)
+	GdAssertReports.set_last_error_line_number(line_number)
 	Engine.set_meta(LAST_ERROR, message)
 	# if we expect to fail we handle as success test
 	if is_expect_fail():

addons/gdUnit4/src/asserts/GdUnitAssertImpl.gd

@@ -50,7 +50,7 @@ func __validate_value_type(value, type :Variant.Type) -> bool:
 
 
 func report_success() -> GdUnitAssert:
-	GdAssertReports.report_success(GdUnitAssertImpl._get_line_number())
+	GdAssertReports.report_success()
 	return self
 
 
@@ -67,12 +67,7 @@ func test_fail():
 
 
 static func _normalize_bbcode(message :String) -> String:
-	var rtl := RichTextLabel.new()
-	rtl.bbcode_enabled = true
-	rtl.append_text(message if message else "")
-	var normalized = rtl.get_parsed_text()
-	rtl.free()
-	return normalized.replace("\r", "")
+	return GdUnitTools.richtext_normalize(message).replace("\r", "")
 
 
 func override_failure_message(message :String):

addons/gdUnit4/src/asserts/GdUnitFailureAssertImpl.gd

@@ -1,29 +1,35 @@
 class_name GdUnitFailureAssertImpl
 extends GdUnitFailureAssert
 
-var _gdunit_signals := GdUnitSignals.instance()
-var _current :GdUnitAssert
 var _is_failed := false
 var _failure_message :String
 
 
-func _init(assertion :Callable):
+func execute_and_await(assertion :Callable, do_await := true) -> GdUnitFailureAssert:
 	# do not report any failure from the original assertion we want to test
 	GdAssertReports.expect_fail(true)
 	var thread_context := GdUnitThreadManager.get_current_context()
 	thread_context.set_assert(null)
 	GdUnitSignals.instance().gdunit_set_test_failed.connect(_on_test_failed)
-	
 	# execute the given assertion as callable
-	assertion.call()
+	if do_await:
+		await assertion.call()
+	else:
+		assertion.call()
 	GdAssertReports.expect_fail(false)
 	# get the assert instance from current tread context
-	_current = thread_context.get_assert()
-	if not is_instance_of(_current, GdUnitAssert):
+	var current_assert := thread_context.get_assert()
+	if not is_instance_of(current_assert, GdUnitAssert):
 		_is_failed = true
 		_failure_message = "Invalid Callable! It must be a callable of 'GdUnitAssert'"
 		return
-	_failure_message = _current._failure_message()
+	_failure_message = current_assert._failure_message()
+	return self
+
+
+func execute(assertion :Callable) -> GdUnitFailureAssert:
+	execute_and_await(assertion, false)
+	return self
 
 
 func _on_test_failed(value :bool) -> void:
@@ -89,17 +95,10 @@ func starts_with_message(expected :String) -> GdUnitFailureAssert:
 
 func _report_error(error_message :String, failure_line_number: int = -1) -> GdUnitAssert:
 	var line_number := failure_line_number if failure_line_number != -1 else GdUnitAssertImpl._get_line_number()
-	GdAssertReports.set_last_error_line_number(line_number)
-	GdUnitSignals.instance().gdunit_set_test_failed.emit(true)
-	_send_report(GdUnitReport.new().create(GdUnitReport.FAILURE, line_number, error_message))
+	GdAssertReports.report_error(error_message, line_number)
 	return self
 
 
 func _report_success() -> GdUnitFailureAssert:
-	GdAssertReports.set_last_error_line_number(-1)
-	GdUnitSignals.instance().gdunit_set_test_failed.emit(false)
+	GdAssertReports.report_success()
 	return self
-
-
-func _send_report(report :GdUnitReport)-> void:
-	_gdunit_signals.gdunit_report.emit(report)

addons/gdUnit4/src/asserts/GdUnitFuncAssertImpl.gd

@@ -33,7 +33,7 @@ func _notification(_what):
 
 
 func report_success() -> GdUnitAssert:
-	GdAssertReports.report_success(_line_number)
+	GdAssertReports.report_success()
 	return self