Create test suite from reading Excel

[JonesKenzie]

Hello everyone,

How are you all?
I'm working on a project that requires a Excel to be read in order to define the test suite. The excel will contain actions:

• Login with USERNAME PASSWORD
• Click on CSS-SELECTOR
• Search for TEXT
• Look for CSS-SELECTOR and CONFIRM | NOT FOUND
• Click on CSS-SELECTOR

I want to transform these in pytest tests dynamically. I was inspiring myself on documentation. I want to create these steps separetely : create a function that Login, create a functon that click on a certain element, etc. and only assemble the steps. The thing is there is a clash when I try to use ExcelReport together.

The error says :

INTERNALERROR> AttributeError: 'ExcelTestItem' object has no attribute 'funcargs'

The function that throws the error is here

@pytest.hookimpl(tryfirst=True, hookwrapper=True)
def pytest_runtest_makereport(item, call):
    # execute all other hooks to obtain the report object
    outcome = yield
    rep = outcome.get_result()

    # set a report attribute for each phase of a call, which can
    # be "setup", "call", "teardown"

    setattr(item, "rep_" + rep.when, rep)

    if item.rep_setup.failed:
        print("setting up a test failed!", request.node.nodeid)
    elif item.rep_setup.passed:
        if rep.when == "call":
            if "browser" in item.funcargs:
                driver = item.funcargs['browser']
                fname = take_screenshot(driver, item.nodeid)
                setattr(rep,"failed_screenshot", fname)

And the whole conftest.py. Any help is welcome!

import time
from datetime import datetime    
import pytest
import os
from selenium import webdriver
from selenium.common.exceptions import WebDriverException
from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.firefox.options import Options
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import Select
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.common.by import By
import re
from _pytest.mark.structures import Mark
import xlsxwriter
# import openpyxl

_py_ext_re = re.compile(r"\.py$")



def pytest_collect_file(parent, path):
    if path.ext == ".xlsx" and path.basename.startswith("test"):
        return ExcelTestPlan.from_parent(parent,fspath = path)

class ExcelTestPlan(pytest.File):
    def collect(self):
        # We need a yaml parser, e.g. PyYAML.
    
        # raw = openpyxl.load_(self.fspath.open())

        raw = [
            ["suite", ["step1" , "step2", "step3"]]
        ]
        for tests in raw:
            name, spec = tests
            yield ExcelTestItem.from_parent(self, name=name, spec=spec)
    
class ExcelTestItem(pytest.Item):
    def __init__(self, name, parent, spec):
        print(f"{name=}")
        print(f"{parent=}")
        print(f"{spec=}")
        super().__init__(name, parent)
        self.spec = spec
    
    def runtest(self):
        for name, value in sorted(self.spec.items()):
            # Some custom test execution (dumb example follows).
            print(spec)
        


# set up webdriver fixture
@pytest.fixture(scope='session')
def browser(request):
    binary = r"C:\Users\ss7f0830\AppData\Local\Mozilla Firefox\firefox.exe"
    options = Options()

    options.binary = binary
    cap = DesiredCapabilities().FIREFOX
    cap["marionette"] = True #optional

    myprofile = webdriver.FirefoxProfile(r"C:\Users\ss7f0830\AppData\Roaming\Mozilla\Firefox\Profiles\hwq70a28.Work")
    browser = webdriver.Firefox(firefox_profile=myprofile, options=options, capabilities=cap, executable_path=r"geckodriver.exe")
    wait = WebDriverWait(browser, 30)

    yield browser
    browser.quit()

# set up a hook to be able to check if a test has failed
@pytest.hookimpl(tryfirst=True, hookwrapper=True)
def pytest_runtest_makereport(item, call):
    # execute all other hooks to obtain the report object
    outcome = yield
    rep = outcome.get_result()

    # set a report attribute for each phase of a call, which can
    # be "setup", "call", "teardown"

    setattr(item, "rep_" + rep.when, rep)

    if item.rep_setup.failed:
        print("setting up a test failed!", request.node.nodeid)
    elif item.rep_setup.passed:
        if rep.when == "call":
            if "browser" in item.funcargs:
                driver = item.funcargs['browser']
                fname = take_screenshot(driver, item.nodeid)
                setattr(rep,"failed_screenshot", fname)
 

def pytest_addoption(parser):
    group = parser.getgroup("terminal reporting")
    group.addoption("--excel", "--excel-report", action = "store", dest="excelpath", metavar="path", default = None, help = "compile the output report")

def pytest_configure(config):
    excelpath = config.option.excelpath
    if excelpath:
        config._excel = ExcelReporter(excelpath)
        config.pluginmanager.register(config._excel)

def pytest_unconfigure(config):
    excel = getattr(config, '_excel', None)
    if excel:
        del config._excel
        config.pluginmanager.unregister(excel)


# make a screenshot with a name of the test, date and time
def take_screenshot(driver, nodeid):
    time.sleep(1)
    file_name = f'{nodeid}_{datetime.today().strftime("%Y-%m-%d_%H_%M")}.png'.replace("/","_").replace("::","__")
    driver.save_screenshot(file_name)
    return file_name

from collections import OrderedDict

def mangle_test_address(address):
    path, possible_open_bracket, params = address.partition('[')
    names = path.split("::")
    try:
        names.remove('()')
    except ValueError:
        pass

    names[0] = names[0].replace("/", '.')
    names[0] = _py_ext_re.sub("", names[0])
    names[-1] += possible_open_bracket + params
    return names


class ExcelReporter:

    def __init__(self, path):
        self.path = path
        self.results = []
        print("Called this badboy")
    
    def append(self, result):
        self.results.append(result)
    
    def build_result(self, report, status, message):

        result = OrderedDict()
        names = mangle_test_address(report.nodeid)

        result['suite_name'] = names[-2]
        result['test_name'] = names[-1]
        if report.test_doc is None:
          result['description'] = report.test_doc
        else:
          result['description'] = report.test_doc.strip()

        result['result'] = status
        result['duration'] = getattr(report, 'duration', 0.0)
        result['timestamp'] = datetime.now().strftime('%Y-%m-%dT%H:%M:%S')
        result['message'] = report.longreprtext
        result['file_name'] = report.location[0]
        result['markers'] = report.test_marker
        result["screenshots"] = report.failed_screenshot
        self.append(result)
    
    def build_tests(self, item):

        result = OrderedDict()
        names = mangle_test_address(item.nodeid)

        result['suite_name'] = names[-2]
        result['test_name'] = names[-1]
        if item.obj.__doc__ is None:
          result['description'] = item.obj.__doc__
        else:
          result['description'] = item.obj.__doc__.strip()
        result['file_name'] = item.location[0]
        test_marker = []
        test_message = []
        for k, v in item.keywords.items():
            if isinstance(v, list):
                for x in v:
                    if isinstance(x, Mark):
                        if x.name != 'usefixtures':
                            test_marker.append(x.name)
                        if x.kwargs:
                            test_message.append(x.kwargs.get('reason'))

        test_markers = ', '.join(test_marker)
        result['markers'] = test_markers

        test_messages = ', '.join(test_message)
        result['message'] = test_messages
        self.append(result)

    def append_pass(self, report):
        status = "PASSED"
        message = None
        self.build_result(report, status, message)


    def append_failure(self, report):

        if hasattr(report, "wasxfail"):
            status = "XPASSED"
            message = "xfail-marked test passes Reason: %s " % report.wasxfail

        else:
            if hasattr(report.longrepr, "reprcrash"):
                message = report.longrepr.reprcrash.message
            elif isinstance(report.longrepr, (unicode, str)):
                message = report.longrepr
            else:
                message = str(report.longrepr)

            status = "FAILED"

        self.build_result(report, status, message)


    def append_error(self, report):

        message = report.longrepr
        status = "ERROR"
        self.build_result(report, status, message)
    

    def append_skipped(self, report):

        if hasattr(report, "wasxfail"):
            status = "XFAILED"
            message = "expected test failure Reason: %s " % report.wasxfail

        else:
            status = "SKIPPED"
            _, _, message = report.longrepr
            if message.startswith("Skipped: "):
                message = message[9:]

        self.build_result(report, status, message)

    def append_tests(self,item):
        self.build_tests(item)

    @pytest.mark.trylast
    def pytest_collection_modifyitems(self, session, config, items):
        """ called after collection has been performed, may filter or re-order
        the items in-place."""
        if session.config.option.collectonly:
            for item in items:
                self.append_tests(item)


    @pytest.mark.hookwrapper
    def pytest_runtest_makereport(self, item, call):

        outcome = yield

        report = outcome.get_result()
        report.test_doc = item.obj.__doc__
        test_marker = []
        for k, v in item.keywords.items():
            if isinstance(v,list):
                for x in v:
                    if isinstance(x,Mark):
                        test_marker.append(x.name)
        report.test_marker = ', '.join(test_marker)
    
    def pytest_runtest_logreport(self, report):

        if report.passed:
            if report.when == "call":  # ignore setup/teardown
                self.append_pass(report)

        elif report.failed:
            if report.when == "call":
                self.append_failure(report)

            else:
                self.append_error(report)

        elif report.skipped:
            self.append_skipped(report)


    def pytest_sessionfinish(self, session):
        if not hasattr(session.config, 'slaveinput'):
            if self.results:
                fieldnames = list(self.results[0])
                workbook = xlsxwriter.Workbook(self.path)
                worksheet = workbook.add_worksheet()

                row = 0 
                col = 0
                for item in self.results:
                    for key, value in item.items():
                        if "screenshot" not in key:
                            worksheet.write(row,col, value)
                        else:
                            worksheet.insert_image(row, col, value, {"x_scale" : 0.1, "y_scale" : 0.1})
                        col += 1
                    row += 1
                
                workbook.close()


    def pytest_terminal_summary(self, terminalreporter):
        if self.results:
            terminalreporter.write_sep("-", "excel report: %s" % (self.path))

[The-Compiler]

Your pytest_runtest_makereport does if "browser" in item.funcargs:, but this isn't something available for all nodes. You'll need to fix that code so that it doesn't try to get that non-existing attribute from your ExcelTestItem.

[The-Compiler]

So store your webdriver / browser object in some other way, e.g. as an attribute in your ExcelTestItem. You will need to have access to it anyways to run your test, I suppose. Then in your pytest_runtest_makereport, access that.

[JonesKenzie]

In fact I was thinking of creating steps dynamically based on this. The code for now can execute the functions step1 to step3. ideally these functions should normal tests, with assertions and all, in order to be captured in the reporting. I just checked ExcelTestItem is suite.

def step1():
    return  "Login" 
def step2():
    return "Clicked"
def step3():
    return "Commented"
class ExcelTestItem(pytest.Item):
    def __init__(self, name, parent, spec):
        print(f"{name=}")
        print(f"{parent=}")
        print(f"{spec=}")
        super().__init__(name, parent)
        
        self.spec = spec
    
    
    def runtest(self):
        for funcs in self.spec:
            res = globals()[funcs]()
            print(res)
            

    def repr_failure(self, excinfo):
        """Called when self.runtest() raises an exception."""
        if isinstance(excinfo.value, YamlException):
            return "\n".join(
                [
                    "usecase execution failed",
                    "   spec failed: {1!r}: {2!r}".format(*excinfo.value.args),
                    "   no further details known at this point.",
                ]
            )

    def reportinfo(self):
        return self.fspath, 0, f"usecase: {self.name}"

[The-Compiler]

I don't see how that changes anything - your step functions will still need to have access to the browser object, so you will need to save it in ExcelTestItem somewhere, so that you can then pass it on to the functions.

[JonesKenzie]

Yes, but how can I pass it as a fixture similarly as the others? Sorry I'm might be missing something that's simple

[The-Compiler]

If you implement a custom test item (for non-Python tests), you don't get to use fixtures (which are for pytest's "direct" Python tests only). They aren't exposed in any way you could sanely use them in your own plugin test code.

Instead, pass it as a normal function argument - if you want to make it optional, you could even use Python's inspect module to look at the test function's arguments.