Returning true/false for all assert_* methods

[guildem]

Maybe I'm not using Gut the right way, but I didn't found any alternative in the docs no duplicate in the opened or closed issues. Sorry if I misunderstood the concept.

I have sometimes tests like that :

func test_example() -> void:
    var object = MyClass.make_object() # can return either an object instanciated from MyClass or null
    
    assert_is(object, MyClass, "should be MyClass")
    if object is MyClass:
        assert_true(object.my_class_function(), "should be true)

If I don't check that object is from MyClass before I do my second test, and object is null, then the Engine crash, because it doesn't find the function.

It would be better to check only one time, by returning the test result from the test, to write something like that :

func test_example() -> void:
    var object = MyClass.make_object() # can return either an object instanciated from MyClass or null
    
    if assert_is(object, MyClass, "should be MyClass"):
        assert_true(object.my_class_function(), "should be true)

Each assert_* method would return a bool, with by default a return false at the end, and return true after each pass() call. I even may be able to make the PR myself. And it should be retrocompatible, because no assert* returns anything.

[bitwes]

You can use is_passing() or is_failing()to check the status of the current test. I'm a firm believer that asserts should not be used as if conditions.

For this situation I'd make one test to assert that I get a MyClass instance given a certain setup and then use that setup in all other tests. The setup could be repeated in each test or you could put it in a helper method, before_all or before_each.

then the Engine crash

If the "crash" is that the debugger is being invoked then you can use the Run Mode button

to run tests externally (I almost always run tests using "Externally - blocking"). This way your tests just fail when an error occurs and the run continues. The dialog explains how the various run modes behave.

Given

func returns_null():
	return null

func test_this_thing():
	var inst = returns_null()
	assert_true(inst.some_method())

If I run that test through the editor using "Externally-Blocking" mode then the run completes and this is the output:

* test_this_thing
SCRIPT ERROR: Invalid call. Nonexistent function 'some_method' in base 'Nil'.
          at: test_this_thing (res://test/unit/test_example.gd:119)
          GDScript backtrace (most recent call first):
              [0] test_this_thing (res://test/unit/test_example.gd:119)
              [1] _run_test (res://addons/gut/gut.gd:622)
              [2] _test_the_scripts (res://addons/gut/gut.gd:835)
              [3] test_scripts (res://addons/gut/gut.gd:1045)
              [4] run_tests (res://addons/gut/gui/GutRunner.gd:198)
    [Failed]:  Unexpected Errors:
    [1] <engine-2>Invalid call. Nonexistent function 'some_method' in base 'Nil'.
      at line -1
0/1 passed.

If you expect tests to create errors you can skip test scripts when the debugger is active using should_skip_script. The script will be reported as risky at the end of the run. If you want to assert that errors are happening and prevent them from failing a test read Error Tracking.