258 lines
8.4 KiB
GDScript
258 lines
8.4 KiB
GDScript
class_name GutInternalTester
|
|
extends GutTest
|
|
|
|
# Created from @GlobalScope properties documentation
|
|
var verbose = false
|
|
|
|
const DOUBLE_ME_PATH = 'res://test/resources/doubler_test_objects/double_me.gd'
|
|
var DoubleMe = GutUtils.WarningsManager.load_script_ignoring_all_warnings(DOUBLE_ME_PATH)
|
|
|
|
const DOUBLE_ME_SCENE_PATH = 'res://test/resources/doubler_test_objects/double_me_scene.tscn'
|
|
var DoubleMeScene = GutUtils.WarningsManager.load_script_ignoring_all_warnings(DOUBLE_ME_SCENE_PATH)
|
|
|
|
const DOUBLE_EXTENDS_NODE2D = 'res://test/resources/doubler_test_objects/double_extends_node2d.gd'
|
|
var DoubleExtendsNode2D = GutUtils.WarningsManager.load_script_ignoring_all_warnings(DOUBLE_EXTENDS_NODE2D)
|
|
|
|
const DOUBLE_EXTENDS_WINDOW_DIALOG = 'res://test/resources/doubler_test_objects/double_extends_window_dialog.gd'
|
|
var DoubleExtendsWindowDialog = GutUtils.WarningsManager.load_script_ignoring_all_warnings(DOUBLE_EXTENDS_WINDOW_DIALOG)
|
|
|
|
const INNER_CLASSES_PATH = 'res://test/resources/doubler_test_objects/inner_classes.gd'
|
|
var InnerClasses = GutUtils.WarningsManager.load_script_ignoring_all_warnings(INNER_CLASSES_PATH)
|
|
|
|
var Gut = load('res://addons/gut/gut.gd')
|
|
var Test = load('res://addons/gut/test.gd')
|
|
var GutLogger = load('res://addons/gut/logger.gd')
|
|
var Spy = load('res://addons/gut/spy.gd')
|
|
var TestCollector = load('res://addons/gut/test_collector.gd')
|
|
|
|
|
|
func _get_logger_from_obj(obj):
|
|
var to_return = null
|
|
if(is_instance_of(obj, GutLogger)):
|
|
to_return = obj
|
|
if(obj.has_method('get_logger')):
|
|
to_return = obj.get_logger()
|
|
elif(obj.get('logger') != null):
|
|
to_return = obj.logger
|
|
return to_return
|
|
|
|
|
|
func _assert_log_count(entries, type, count):
|
|
if(count == -1):
|
|
assert_gt(entries.size(), 0, str('There should be at least 1 ' + type))
|
|
else:
|
|
assert_eq(entries.size(), count, str('There should be ', count, ' ', type))
|
|
|
|
|
|
const SHOULD_PASS = &"Should pass"
|
|
const SHOULD_FAIL = &"Should fail"
|
|
|
|
func print_fail_pass_text(t):
|
|
for i in range(t._fail_pass_text.size()):
|
|
gut.p('sub-test: ' + t._fail_pass_text[i], gut.LOG_LEVEL_FAIL_ONLY)
|
|
|
|
|
|
func assert_logger_warn(obj, times=1):
|
|
var lgr = _get_logger_from_obj(obj)
|
|
if(lgr != null):
|
|
_assert_log_count(lgr.get_warnings(), 'warnings', times)
|
|
else:
|
|
_fail(str('Cannot assert_errored, ', obj, ' does not have get_logger method or logger property'))
|
|
|
|
|
|
func assert_logger_errored(obj, times=1):
|
|
var things_lgr = _get_logger_from_obj(obj)
|
|
if(things_lgr != null):
|
|
_assert_log_count(things_lgr.get_errors(), 'errors', times)
|
|
else:
|
|
_fail(str('Cannot assert_errored, ', obj, ' does not have get_logger method or logger property'))
|
|
|
|
|
|
func assert_deprecated(obj, times=1):
|
|
var lgr = _get_logger_from_obj(obj)
|
|
if(lgr != null):
|
|
_assert_log_count(lgr.get_deprecated(), 'deprecated', times)
|
|
else:
|
|
_fail(str('Cannot assert_errored, ', obj, ' does not have get_logger method or logger property'))
|
|
|
|
|
|
func assert_has_logger(obj):
|
|
assert_has_method(obj, 'get_logger')
|
|
assert_has_method(obj, 'set_logger')
|
|
if(obj.has_method('get_logger')):
|
|
assert_not_null(obj.get_logger(), 'Default logger not null.')
|
|
if(obj.has_method('set_logger')):
|
|
var l = double(GutLogger).new()
|
|
obj.set_logger(l)
|
|
assert_eq(obj.get_logger(), l, 'Set/get works')
|
|
|
|
|
|
func assert_fail_pass(t, fail_count, pass_count, msg=''):
|
|
var self_fail_count = get_fail_count()
|
|
assert_eq(t.get_fail_count(), fail_count, 'Bad FAIL COUNT: ' + msg)
|
|
assert_eq(t.get_pass_count(), pass_count, 'Bad PASS COUNT: ' + msg)
|
|
if(get_fail_count() != self_fail_count or verbose):
|
|
print_fail_pass_text(t)
|
|
|
|
# convenience method to assert the number of failures on the gr.test_gut object.
|
|
func assert_fail(t, count=1, msg=''):
|
|
var self_fail_count = get_fail_count()
|
|
assert_eq(t.get_fail_count(), count, 'Expected FAIL COUNT: ' + msg)
|
|
if(t.get_pass_count() > 0 and count != t.get_assert_count()):
|
|
assert_eq(t.get_pass_count(), 0, 'When checking for failures there should be no passing')
|
|
if(get_fail_count() != self_fail_count or verbose):
|
|
print_fail_pass_text(t)
|
|
|
|
# convenience method to assert the number of passes on the gr.test_gut object.
|
|
func assert_pass(t, count=1, msg=''):
|
|
var self_fail_count = get_fail_count()
|
|
assert_eq(t.get_pass_count(), count, 'Expected PASS COUNT: ' + msg)
|
|
if(t.get_fail_count() != 0 and count != t.get_assert_count()):
|
|
assert_eq(t.get_fail_count(), 0, 'When checking for passes there should be no failures.')
|
|
if(get_fail_count() != self_fail_count or verbose):
|
|
print_fail_pass_text(t)
|
|
|
|
func assert_fail_msg_contains(t, text):
|
|
if(t.get_fail_count() != 1):
|
|
assert_fail(t, 1, 'assert_fail_msg_contains requires single failing assert.')
|
|
elif(t.get_pass_count() != 0):
|
|
assert_pass(t, 0, 'assert_fail_msg_contains requires no passing asserts.')
|
|
else:
|
|
assert_string_contains(t._fail_pass_text[0], text)
|
|
|
|
func get_error_count(obj):
|
|
return obj.logger.get_errors().size()
|
|
|
|
func _setup_test_gut(g, print_sub_tests):
|
|
g.logger.disable_all_printers(true)
|
|
|
|
g.log_level = 3
|
|
if(print_sub_tests):
|
|
g.logger.disable_printer("terminal", false)
|
|
g.logger._min_indent_level = 1
|
|
g.logger.dec_indent()
|
|
g.logger.set_indent_string(new_gut_indent_string)
|
|
g.logger.disable_formatting(!print_sub_tests)
|
|
g.logger.set_type_enabled(g.logger.types.debug, true)
|
|
|
|
g._should_print_versions = false
|
|
g._should_print_summary = false
|
|
g.error_tracker = GutErrorTracker.new()
|
|
# Default is .5 which takes 180s
|
|
# .1 takes 145s
|
|
# .05 takes 139s
|
|
# Lower numbers could cause false positive orphans, but none were listed
|
|
# for a full run.
|
|
g._time_to_wait_for_final_queue_free = .05
|
|
|
|
|
|
var new_gut_indent_string = "| "
|
|
func new_gut(print_sub_tests=false):
|
|
var g = Gut.new(GutLogger.new())
|
|
_setup_test_gut(g, print_sub_tests)
|
|
return g
|
|
|
|
|
|
func new_partial_double_gut(print_sub_tests=false):
|
|
var g = partial_double(Gut).new(GutLogger.new())
|
|
_setup_test_gut(g, print_sub_tests)
|
|
return g
|
|
|
|
|
|
func new_no_print_logger(override=!verbose):
|
|
var to_return = GutLogger.new()
|
|
to_return.disable_all_printers(override)
|
|
return to_return
|
|
|
|
|
|
func new_wired_test(gut_instance):
|
|
var t = GutTest.new()
|
|
t.gut = gut_instance
|
|
t.set_logger(gut_instance.logger)
|
|
return t
|
|
|
|
# ----------------------------
|
|
# Not used yet, but will be used eventually
|
|
|
|
# func new_test_double():
|
|
# var t = double(GutTest).new()
|
|
# var logger = double(GutUtils.GutLogger).new()
|
|
# stub(t, 'set_logger').to_call_super()
|
|
# stub(t, 'get_logger').to_call_super()
|
|
# t.set_logger(logger)
|
|
# return t
|
|
# ----------------------------
|
|
func _print_errors_if_failing(error_tracker):
|
|
if(is_failing()):
|
|
var errors = error_tracker.get_current_test_errors()
|
|
for err in errors:
|
|
gut.p(str(" - ", err.code))
|
|
|
|
|
|
|
|
func find_method_meta(methods, method_name):
|
|
return GutUtils.find_method_meta(methods, method_name)
|
|
|
|
|
|
func _get_tracker_from(thing):
|
|
var tracker = null
|
|
if(thing is GutMain):
|
|
tracker = thing.error_tracker
|
|
elif(thing is GutTest):
|
|
tracker = thing.gut.error_tracker
|
|
else:
|
|
var lgr = _get_logger_from_obj(thing)
|
|
if(lgr != null):
|
|
tracker = lgr.get_gut().error_tracker
|
|
|
|
return tracker
|
|
|
|
func assert_tracked_gut_error(thing=gut, count=1):
|
|
var consumed_count = 0
|
|
var errors = _get_tracker_from(thing).get_current_test_errors()
|
|
for err in errors:
|
|
if(err.is_gut_error()):
|
|
err.handled = true
|
|
consumed_count += 1
|
|
assert_eq(consumed_count, count, "gut error was found.")
|
|
_print_errors_if_failing(_get_tracker_from(thing))
|
|
|
|
func assert_tracked_gut_error_text(thing, text):
|
|
var consumed_count = 0
|
|
var errors = _get_tracker_from(thing).get_current_test_errors()
|
|
for err in errors:
|
|
if(err.is_gut_error() and err.code.find(text) != -1):
|
|
err.handled = true
|
|
consumed_count += 1
|
|
assert_eq(consumed_count, 1, "gut error with text. '" + text + "'")
|
|
_print_errors_if_failing(_get_tracker_from(thing))
|
|
|
|
|
|
func assert_tracked_push_error(thing=gut, count=1):
|
|
var consumed_count = 0
|
|
var errors = _get_tracker_from(thing).get_current_test_errors()
|
|
for err in errors:
|
|
if(err.is_push_error()):
|
|
err.handled = true
|
|
consumed_count += 1
|
|
assert_eq(consumed_count, count, "push_error error was found.")
|
|
_print_errors_if_failing(_get_tracker_from(thing))
|
|
|
|
|
|
func assert_tracked_engine_error(thing=gut, count=1):
|
|
var consumed_count = 0
|
|
var errors = _get_tracker_from(thing).get_current_test_errors()
|
|
for err in errors:
|
|
if(err.is_engine_error()):
|
|
err.handled = true
|
|
consumed_count += 1
|
|
assert_eq(consumed_count, count, "engine error was found.")
|
|
_print_errors_if_failing(_get_tracker_from(thing))
|
|
|
|
|
|
func skip_if_debugger_active():
|
|
if(EngineDebugger.is_active()):
|
|
return "Script skipped when debugger active"
|
|
else:
|
|
return false
|