How to use JUnitSetupPrinter class

1<?php
2namespace Behat\Behat\Output\Node\Printer\JUnit;
3
4use Behat\Behat\Hook\Scope\StepScope;
5use Behat\Behat\Output\Node\Printer\SetupPrinter;
6use Behat\Testwork\Call\CallResult;
7use Behat\Testwork\Call\CallResults;
8use Behat\Testwork\Exception\ExceptionPresenter;
9use Behat\Testwork\Hook\Call\HookCall;
10use Behat\Testwork\Hook\Tester\Setup\HookedSetup;
11use Behat\Testwork\Hook\Tester\Setup\HookedTeardown;
12use Behat\Testwork\Output\Formatter;
13use Behat\Testwork\Output\Printer\JUnitOutputPrinter;
14use Behat\Testwork\Tester\Setup\Setup;
15use Behat\Testwork\Tester\Setup\Teardown;
16
17/**
18 * @author: Jakob Erdmann <jakob.erdmann@rocket-internet.com>
19 */
20class JUnitSetupPrinter implements SetupPrinter
21{
22
23    /** @var ExceptionPresenter */
24    private $exceptionPresenter;
25
26    public function __construct(ExceptionPresenter $exceptionPresenter)
27    {
28        $this->exceptionPresenter = $exceptionPresenter;
29    }
30
31    /**
32     * {@inheritdoc}
33     */
34    public function printSetup(Formatter $formatter, Setup $setup)
35    {
36        if (!$setup->isSuccessful()) {
37            if ($setup instanceof HookedSetup) {
38                $this->handleHookCalls($formatter, $setup->getHookCallResults(), 'setup');
39            }
40        }
41    }
42
43    /**
44     * {@inheritdoc}
45     */
46    public function printTeardown(Formatter $formatter, Teardown $teardown)
47    {
48        if (!$teardown->isSuccessful()) {
49            if ($teardown instanceof HookedTeardown) {
50                $this->handleHookCalls($formatter, $teardown->getHookCallResults(), 'teardown');
51            }
52        }
53    }
54
55    /**
56     * @param Formatter $formatter
57     * @param CallResults $results
58     * @param string $messageType
59     */
60    private function handleHookCalls(Formatter $formatter, CallResults $results, $messageType)
61    {
62        /** @var CallResult $hookCallResult */
63        foreach ($results as $hookCallResult) {
64            if ($hookCallResult->hasException()) {
65                /** @var HookCall $call */
66                $call = $hookCallResult->getCall();
67                $scope = $call->getScope();
68                /** @var JUnitOutputPrinter $outputPrinter */
69                $outputPrinter = $formatter->getOutputPrinter();
70
71                $message = '';
72                if ($scope instanceof StepScope) {
73                    $message .= $scope->getStep()->getKeyword() . ' ' . $scope->getStep()->getText() . ': ';
74                }
75                $message .= $this->exceptionPresenter->presentException($hookCallResult->getException());
76
77                $attributes = array(
78                    'message' => $message,
79                    'type'    => $messageType,
80                );
81
82                $outputPrinter->addTestcaseChild('failure', $attributes);
83
84            }
85        }
86    }
87}
88

Source: JUnitSetupPrinter.php

<?php
namespace Behat\Behat\Output\Node\Printer\JUnit;

use Behat\Behat\Hook\Scope\StepScope;
use Behat\Behat\Output\Node\Printer\SetupPrinter;
use Behat\Testwork\Call\CallResult;
use Behat\Testwork\Call\CallResults;
use Behat\Testwork\Exception\ExceptionPresenter;
use Behat\Testwork\Hook\Call\HookCall;
use Behat\Testwork\Hook\Tester\Setup\HookedSetup;
use Behat\Testwork\Hook\Tester\Setup\HookedTeardown;
use Behat\Testwork\Output\Formatter;
use Behat\Testwork\Output\Printer\JUnitOutputPrinter;
use Behat\Testwork\Tester\Setup\Setup;
use Behat\Testwork\Tester\Setup\Teardown;

/**
 * @author: Jakob Erdmann <jakob.erdmann@rocket-internet.com>
 */
class JUnitSetupPrinter implements SetupPrinter
{

    /** @var ExceptionPresenter */
    private $exceptionPresenter;

    public function __construct(ExceptionPresenter $exceptionPresenter)
    {
        $this->exceptionPresenter = $exceptionPresenter;
    }

    /**
     * {@inheritdoc}
     */
    public function printSetup(Formatter $formatter, Setup $setup)
    {
        if (!$setup->isSuccessful()) {
            if ($setup instanceof HookedSetup) {
                $this->handleHookCalls($formatter, $setup->getHookCallResults(), 'setup');
            }
        }
    }

    /**
     * {@inheritdoc}
     */
    public function printTeardown(Formatter $formatter, Teardown $teardown)
    {
        if (!$teardown->isSuccessful()) {
            if ($teardown instanceof HookedTeardown) {
                $this->handleHookCalls($formatter, $teardown->getHookCallResults(), 'teardown');
            }
        }
    }

    /**
     * @param Formatter $formatter
     * @param CallResults $results
     * @param string $messageType
     */
    private function handleHookCalls(Formatter $formatter, CallResults $results, $messageType)
    {
        /** @var CallResult $hookCallResult */
        foreach ($results as $hookCallResult) {
            if ($hookCallResult->hasException()) {
                /** @var HookCall $call */
                $call = $hookCallResult->getCall();
                $scope = $call->getScope();
                /** @var JUnitOutputPrinter $outputPrinter */
                $outputPrinter = $formatter->getOutputPrinter();

                $message = '';
                if ($scope instanceof StepScope) {
                    $message .= $scope->getStep()->getKeyword() . ' ' . $scope->getStep()->getText() . ': ';
                }
                $message .= $this->exceptionPresenter->presentException($hookCallResult->getException());

                $attributes = array(
                    'message' => $message,
                    'type'    => $messageType,
                );

                $outputPrinter->addTestcaseChild('failure', $attributes);

            }
        }
    }
}