0

I am actively using record_xml_property fixture in my tests, but unfortunately it just does not work with xdsit plugin. I've tried to implement a workaround. Instead of directly add properties to the reporter, I put them to the slaveoutput:

@pytest.fixture
def record_xml_property(request):
    xml = getattr(request.config, "_xml", None)

    if xml is not None:
        node_reporter = xml.node_reporter(request.node.nodeid)
        return node_reporter.add_property

    else:
        def add_property_xdist(name, value):
            request.node.config.slaveoutput.update({'properties': {name: value}})

        return add_property_xdist

And after that I wanted to add this properties to the report in pytest_runtest_logreport hook:

@pytest.hookimpl(tryfirst=True)
def pytest_runtest_logreport(report):
    if report.when != 'teardown':
        return

    node = getattr(report, 'node', None)

    if not node:
        return

    xml = getattr(node.config, '_xml', None)

    if not xml:
        return

    node_reporter = xml.node_reporter(report)
    slaveoutput = getattr(node, 'slaveoutput', None)

    if not slaveoutput:
        return

    node_properties = slaveoutput.get('properties', {})

    for key, value in node_properties.items():
        node_reporter.add_property(key, value)

But the problem is that slaveoutput usually is not available in SlaveController object yet when pytest_runtest_logreport hook is executed. It is available in pytest_testnodedown, SlaveInteractor sends it with "slavefinished" event, but at this moment reports are finalized already. Is there any way to get slaveoutput from slave node earlier?

Ilya
  • 11
  • 2

1 Answers1

1

Finally I decided to avoid using slaveoutput. I was thinking of some solution that involves using shared directrories, but finally I decided to use execnet channel between master and slave nodes. Unfortunately it seems that design of xdist does not allow to easily extend communication between master and slave nodes. I had to do some monkey patching, code duplication and some other nasty things, which I don't like. But at least it works. Here is my solution:

@pytest.fixture
def record_xml_property(request):
    """
    Overrides original record_xml_property fixture from junitxml plugin
    """
    xml = getattr(request.config, "_xml", None)

    if xml is not None:
        node_reporter = xml.node_reporter(request.node.nodeid)
        return node_reporter.add_property
    else:
        pluginmanager = request.node.config.pluginmanager
        plugins = pluginmanager.get_plugins()
        slave_interactor = None

        for plugin in plugins:
            if plugin.__class__.__name__ == 'SlaveInteractor':
                slave_interactor = plugin

        if slave_interactor:
            # if test is running in slave node
            def add_property_xdist(name, value):
                slave_interactor.sendevent("record_xml_property", property=(name, value), nodeid=request.node.nodeid)

            return add_property_xdist

    def add_property_noop(name, value):
        pass

    return add_property_noop


def pytest_configure_node(node):
    xml = getattr(node.config, '_xml', None)

    if xml:
        # monkeypatching SlaveController right after it is created
        # process_from_remote is a callback function which is executed on channel event
        original_process_from_remote = node.process_from_remote

        def process_from_remote(self, eventcall):
            try:
                if eventcall != self.ENDMARK:
                    eventname, kwargs = eventcall

                    # In case of record_xml_property event, process it here. Otherwise process it in original
                    # process_from_remote function
                    if eventname == "record_xml_property":
                        self.log("recording xml property %s(%s)" % (eventname, kwargs))

                        # Report is not yet exists. I should use fake one to get proper reporter
                        class Fakereport:
                            def __init__(self, node, nodeid):
                                self.node = node
                                self.nodeid = nodeid

                        node_reporter = xml.node_reporter(Fakereport(self, kwargs['nodeid']))
                        name, value = kwargs['property']
                        node_reporter.add_property(name, value)
                        return
            except KeyboardInterrupt:
                # should not land in receiver-thread
                raise
            except:
                # the same except as in original process_from_remote method
                excinfo = py.code.ExceptionInfo()
                py.builtin.print_("!" * 20, excinfo)
                self.config.pluginmanager.notify_exception(excinfo)

            return original_process_from_remote(eventcall)

        node.process_from_remote = types.MethodType(process_from_remote, node)
Ilya
  • 11
  • 2