Add a method to get intermediate return values from flow

[ftruzzi]

Hi!

It would be nice for testing to have a way to retrieve the intermediate result of a flow, in a way similar to how assert_flow() works but with the return value.

Example:

def do_stuff():
    return flow(0, func_1, bind(func_2))

def test_func_1():
    v = get_function_value(func_1, do_stuff)
    assert v == expected_value

In principle this can be done with sys.setprofile (in the trace function and for return events, arg contains the return value).

Proof of concept example:

def trace_func(function_to_search, frame, event, arg):
    if event == 'return' and frame.f_code.co_name == function_to_search.__name__:
        # modified exception to hold the return value under "value" attr
        raise DesiredValueFound(arg)

def get_function_value(function_to_search, my_flow):
    old_tracer = sys.gettrace()
    sys.setprofile(partial(trace_func, function_to_search))

    try:
         my_flow()
    except DesiredValueFound as e:
        return e.value
    finally:
        sys.settrace(old_tracer)

What do you think?

Thanks :)

[sobolevn]

Can you please tell more about your use-case? What exactly are you testing?

[ftruzzi]

Thanks for asking! I'm building a library to upload files on a website. The core of it is robobrowser interacting with forms until the upload is finished and unfortunately there is some shared state and function arguments and return values are not simple.

My flow is something like this: validate_file -> upload_file -> fetch_new_metadata -> update_metadata -> finish_upload, exposed through a single method e.g. upload

Individually testing the *_metadata functions is quite hard unless I manually save the returned form from upload_file (which is a complex object) for each test case and provide it as an argument together with a manually initialized state. A solution like the one I proposed would allow for much easier testing without having to manage any other data except for vcrpy to save and replay network requests with the data.

[internetimagery]

Perhaps if bind didn't just assume the returned value was the correct monadic instance (returning it directly), and instead attempted a map, then join... a subclass of a monad could be used (and propagated) through the flow, which could be used for assertions etc.