Share kernel context across multiple tests about testbook HOT 7 CLOSED

I like the pattern. It's flexible and clean to read. We'll want to document it well when we get to that step of the project so it's clear how to execute in either mode with isolated or shared kernels.

from testbook.

The following pattern seems promising and is fairly flexible 🎉

import pytest
from testbook import testbook


@pytest.fixture(scope='module')
def notebook():
    # prerun cells here that need to be run just once across all tests in the scope
    with testbook('/path/to/notebook.ipynb', prerun=['some', 'cells']) as tb:
        yield tb

def test_1(notebook):
    assert notebook.value("bar") == 'hello world'
    notebook.inject("bar = 'something else'", run=True)


def test_2(notebook):
    assert notebook.value("bar") == 'something else'

We will want to document this well, perhaps provide tutorials/examples as to how it can be used.

from testbook.

#19 brings this functionality in place as well.
We can let the user create a global instance of notebook_loader, which can then be used across multiple tests - hence sharing the execution context.

Take a look at the following code snippet:

from testbook import notebook_loader

foo = notebook_loader('/path/to/notebook.ipynb', prerun=['tag1', tag2', tag3'])

@foo
def test_notebook_1(notebook):
    assert notebook.cell_output_text('execute_foo') == 'foo\n'


@foo
def test_notebook_1(notebook):
    assert notebook.cell_output_text('some_other_tag') == 'some other output\n'

or..

def test_notebook():
    with foo():
        assert notebook.cell_output_text('execute_foo') == 'foo\n'

def test_notebook_1():
    with foo():
        assert notebook.cell_output_text('some_other_tag') == 'some other output\n'

Of course, it can be named something much clearer than "foo"

UPDATE: The above implementation does not work, it does not preserve the kernel context across multiple tests. More info at #28

from testbook.

Is it possible to replicate the kernel context across multiple tests? For example, let us say that there is a specific set of cells which need to be executed prior to all the tests in a module. Is it possible to always start with the same fresh initial context in every test?

I would imagine that it would involve storing the kernel context somehow and "injecting" it into future kernels? Not sure.

cc @MSeal

from testbook.

Is it possible to always start with the same fresh initial context in every test?

Aren't we making that an option to the testbook decorator via the prerun argument? It does require you decorate each test, so another option would be to follow the top answer from https://stackoverflow.com/questions/22627659/run-code-before-and-after-each-test-in-py-test and document (or provide?) a function for wrapping all tests in a scope with the notebook prep, maybe by generating a fixture within that scope, or more likely, by passing the tb object to each test?

Related: in ipython there's also %reset -f which isn't a perfect solution but it would save a lot of time on kernel reboot times as an optimization for tests against that kernel.

from testbook.

I would imagine that it would involve storing the kernel context somehow and "injecting" it into future kernels? Not sure.

In process state transfers... not a reliable pattern. In some controlled contexts it's technically possible but I would not pursue that path for implementations.

from testbook.

Related: in ipython there's also %reset -f which isn't a perfect solution but it would save a lot of time on kernel reboot times as an optimization for tests against that kernel.

This is actually perfect for speeding up the tests that run on the same notebook. 💯

from testbook.