├── report
    └── .gitignore
├── .gitignore
├── behat.yml
├── composer.json
├── src
    ├── Classes
    │   ├── Suite.php
    │   ├── Scenario.php
    │   ├── Step.php
    │   └── Feature.php
    ├── Context
    │   └── ScreenshotContext.php
    ├── BehatHTMLFormatterExtension.php
    ├── Renderer
    │   ├── RendererInterface.php
    │   ├── TwigRenderer.php
    │   ├── MinimalRenderer.php
    │   ├── BaseRenderer.php
    │   └── Behat2Renderer.php
    ├── Printer
    │   └── FileOutputPrinter.php
    └── Formatter
    │   └── BehatHTMLFormatter.php
├── LICENSE
├── assets
    └── Twig
    │   └── css
    │       ├── callout.css
    │       ├── callout.less
    │       ├── style.less
    │       └── style.css
├── .travis.yml
├── features
    ├── twig_renderer.feature
    └── bootstrap
    │   └── FeatureContext.php
├── templates
    ├── index.backup.html.twig
    └── index.html.twig
└── README.md


/report/.gitignore:
--------------------------------------------------------------------------------
1 | *
2 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | composer.lock
2 | vendor/
3 | build/
4 | .idea
5 | 


--------------------------------------------------------------------------------
/behat.yml:
--------------------------------------------------------------------------------
 1 | default:
 2 |     formatters:
 3 |         html:
 4 |             output_path: %paths.base%/report
 5 |         pretty: ~
 6 | 
 7 |     extensions:
 8 |         emuse\BehatHTMLFormatter\BehatHTMLFormatterExtension:
 9 |             name: html
10 |             renderer: Twig
11 |             file_name: index
12 |             print_args: true
13 |             print_outp: true
14 |             loop_break: true
15 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "emuse/behat-html-formatter",
 3 |     "description": "This will create a html formatter for Behat.",
 4 |     "license": "MIT",
 5 |     "authors": [
 6 |         {
 7 |             "name": "Neal Vanmeert",
 8 |             "email": "neal@emuse.be"
 9 |         }
10 |     ],
11 |     "require": {
12 |         "php": ">=5.3.0",
13 |         "twig/twig":"~1.5|~2.0",
14 |         "behat/behat": "~3.0",
15 |         "behat/gherkin": "~4.2"
16 |     },
17 |     "require-dev": {
18 |         "symfony/process": ">2.3,<4.0",
19 |         "phpunit/phpunit": "~4.1"
20 |     },
21 |     "autoload": {
22 |         "psr-4": {
23 |             "emuse\\BehatHTMLFormatter\\": "src/"
24 |         }
25 |     },
26 |     "extra": {
27 |         "branch-alias": {
28 |             "dev-master": "0.1.x-dev"
29 |         }
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Classes/Suite.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace emuse\BehatHTMLFormatter\Classes;
 4 | 
 5 | class Suite
 6 | {
 7 |     private $name;
 8 |     private $features;
 9 | 
10 |     /**
11 |      * @return mixed
12 |      */
13 |     public function getName()
14 |     {
15 |         return $this->name;
16 |     }
17 | 
18 |     /**
19 |      * @param mixed $name
20 |      */
21 |     public function setName($name)
22 |     {
23 |         $this->name = $name;
24 |     }
25 | 
26 |     /**
27 |      * @return mixed
28 |      */
29 |     public function getFeatures()
30 |     {
31 |         return $this->features;
32 |     }
33 | 
34 |     /**
35 |      * @param mixed $features
36 |      */
37 |     public function setFeatures($features)
38 |     {
39 |         $this->features = $features;
40 |     }
41 | 
42 |     public function addFeature($feature)
43 |     {
44 |         $this->features[] = $feature;
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2015 Neal Vanmeert
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy
 4 | of this software and associated documentation files (the "Software"), to deal
 5 | in the Software without restriction, including without limitation the rights
 6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 7 | copies of the Software, and to permit persons to whom the Software is
 8 | furnished to do so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in all
11 | copies or substantial portions of the Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
19 | SOFTWARE.
20 | 


--------------------------------------------------------------------------------
/assets/Twig/css/callout.css:
--------------------------------------------------------------------------------
 1 | .bs-callout {
 2 |   padding: 20px;
 3 |   margin: 20px 0;
 4 |   border: 1px solid #eee;
 5 |   border-left-width: 5px;
 6 |   border-radius: 3px;
 7 | }
 8 | .bs-callout h4 {
 9 |   margin-top: 0;
10 |   margin-bottom: 5px;
11 | }
12 | .bs-callout p:last-child {
13 |   margin-bottom: 0;
14 | }
15 | .bs-callout code {
16 |   border-radius: 3px;
17 | }
18 | .bs-callout + .bs-callout {
19 |   margin-top: -5px;
20 | }
21 | .bs-callout-default {
22 |   border-left-color: #777;
23 | }
24 | .bs-callout-default h4 {
25 |   color: #777;
26 | }
27 | .bs-callout-primary {
28 |   border-left-color: #428bca;
29 | }
30 | .bs-callout-primary h4 {
31 |   color: #428bca;
32 | }
33 | .bs-callout-success {
34 |   border-left-color: #5cb85c;
35 | }
36 | .bs-callout-success h4 {
37 |   color: #5cb85c;
38 | }
39 | .bs-callout-danger {
40 |   border-left-color: #d9534f;
41 | }
42 | .bs-callout-danger h4 {
43 |   color: #d9534f;
44 | }
45 | .bs-callout-warning {
46 |   border-left-color: #f0ad4e;
47 | }
48 | .bs-callout-warning h4 {
49 |   color: #f0ad4e;
50 | }
51 | .bs-callout-info {
52 |   border-left-color: #5bc0de;
53 | }
54 | .bs-callout-info h4 {
55 |   color: #5bc0de;
56 | }
57 | 


--------------------------------------------------------------------------------
/assets/Twig/css/callout.less:
--------------------------------------------------------------------------------
 1 | .bs-callout {
 2 |   padding: 20px;
 3 |   margin: 20px 0;
 4 |   border: 1px solid #eee;
 5 |   border-left-width: 5px;
 6 |   border-radius: 3px;
 7 | }
 8 | .bs-callout h4 {
 9 |   margin-top: 0;
10 |   margin-bottom: 5px;
11 | }
12 | .bs-callout p:last-child {
13 |   margin-bottom: 0;
14 | }
15 | .bs-callout code {
16 |   border-radius: 3px;
17 | }
18 | .bs-callout+.bs-callout {
19 |   margin-top: -5px;
20 | }
21 | .bs-callout-default {
22 |   border-left-color: #777;
23 | }
24 | .bs-callout-default h4 {
25 |   color: #777;
26 | }
27 | .bs-callout-primary {
28 |   border-left-color: #428bca;
29 | }
30 | .bs-callout-primary h4 {
31 |   color: #428bca;
32 | }
33 | .bs-callout-success {
34 |   border-left-color: #5cb85c;
35 | }
36 | .bs-callout-success h4 {
37 |   color: #5cb85c;
38 | }
39 | .bs-callout-danger {
40 |   border-left-color: #d9534f;
41 | }
42 | .bs-callout-danger h4 {
43 |   color: #d9534f;
44 | }
45 | .bs-callout-warning {
46 |   border-left-color: #f0ad4e;
47 | }
48 | .bs-callout-warning h4 {
49 |   color: #f0ad4e;
50 | }
51 | .bs-callout-info {
52 |   border-left-color: #5bc0de;
53 | }
54 | .bs-callout-info h4 {
55 |   color: #5bc0de;
56 | }
57 | 


--------------------------------------------------------------------------------
/src/Context/ScreenshotContext.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace emuse\BehatHTMLFormatter\Context;
 4 | 
 5 | use Behat\MinkExtension\Context\RawMinkContext;
 6 | 
 7 | class ScreenshotContext extends RawMinkContext
 8 | {
 9 |     private $currentScenario;
10 |     private $screenshotDir;
11 | 
12 |     public function __construct($screenshotDir)
13 |     {
14 |         $this->screenshotDir = $screenshotDir;
15 |     }
16 | 
17 |     /**
18 |      * @BeforeScenario
19 |      *
20 |      * @param BeforeScenarioScope $scope
21 |      */
22 |     public function setUpTestEnvironment($scope)
23 |     {
24 |         $this->currentScenario = $scope->getScenario();
25 |     }
26 | 
27 |     /**
28 |      * @AfterStep
29 |      *
30 |      * @param AfterStepScope $scope
31 |      */
32 |     public function afterStep($scope)
33 |     {
34 |         // if test is passed, skip taking screenshot
35 |         if ($scope->getTestResult()->isPassed()) {
36 |             return;
37 |         }
38 | 
39 |         // create filename string
40 |         $featureFolder = preg_replace('/\W/', '', $scope->getFeature()->getTitle());
41 | 
42 |         $scenarioName = $this->currentScenario->getTitle();
43 |         $fileName = preg_replace('/\W/', '', $scenarioName).'.png';
44 | 
45 |         // create screenshots directory if it doesn't exist
46 |         if (!file_exists($this->screenshotDir.'/'.$featureFolder)) {
47 |             mkdir($this->screenshotDir.'/'.$featureFolder, 0777, true);
48 |         }
49 | 
50 |         $this->saveScreenshot($fileName, $this->screenshotDir.'/'.$featureFolder.'/');
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: php
 2 | 
 3 | sudo: false
 4 | 
 5 | cache:
 6 |   directories:
 7 |     - $HOME/.composer
 8 | 
 9 | php:
10 |   - 5.3
11 |   - 5.4
12 |   - 5.5
13 |   - 5.6
14 |   - 7.0
15 |   - nightly
16 |   - hhvm
17 | 
18 | env:
19 |   - DEPS='low'
20 |   - DEPS='dev'
21 |   - DEPS='normal'
22 | 
23 | matrix:
24 |   fast_finish: true
25 |   allow_failures:
26 |     - env: DEPS='dev'
27 |     - php: nightly
28 | 
29 | before_install:
30 |   - if [ "$TRAVIS_PHP_VERSION" != "hhvm" ]; then cat $HOME/.phpenv/versions/$TRAVIS_PHP_VERSION/etc/conf.d/xdebug.ini > ./xdebug.ini ; fi
31 |   - if [ "$TRAVIS_PHP_VERSION" != "hhvm" ]; then phpenv config-rm xdebug.ini ; fi
32 |   - if [ "$DEPS" == "normal" ] && [ "$TRAVIS_PHP_VERSION" == "5.6" ] ; then export COVERALLS=true; fi
33 |   - if [ "$COVERALLS" == "true" ] ; then echo "Will try to generate coveralls"; fi
34 |   - echo "CRONTAB before tests"
35 |   - echo "`crontab -l`"
36 |   - echo "Using in php version $TRAVIS_PHP_VERSION"
37 |   - echo "Preparing blackfire"
38 |   - travis_retry composer selfupdate
39 |   - echo '#!/bin/bash' > install.sh
40 |   - echo -n "composer update" >> install.sh
41 |   - echo -n " --prefer-dist" >> install.sh
42 |   - if [ "$DEPS" == "low" ]; then echo -n " --prefer-lowest" >> install.sh; fi;
43 |   - if [ "$DEPS" == "normal" ]; then echo -n " --prefer-stable" >> install.sh; fi;
44 |   - sed -n '/prefer-stable/!p' composer.json > tmp.json && mv tmp.json composer.json;
45 | 
46 | install:
47 |   - travis_retry composer global require kherge/box --prefer-dist
48 |   - travis_retry composer global require phing/phing --prefer-dist
49 |   - travis_retry composer global require satooshi/php-coveralls --prefer-dist
50 |   - $HOME/.composer/vendor/bin/box --version
51 |   - $HOME/.composer/vendor/bin/phing -v
52 |   - export COMPOSER_ROOT_VERSION=dev-master
53 |   - travis_retry /bin/bash ./install.sh
54 | 
55 | before_script:
56 |   - echo "<?php if (defined('HHVM_VERSION')) { echo ',@hhvm'; } else { if (PHP_VERSION_ID >= 50400) echo ',@php5.4'; if (PHP_VERSION_ID >= 70000) echo ',@php7'; }" > php_version_tags.php
57 |   - if [ "$TRAVIS_PHP_VERSION" != "hhvm" ]; then phpenv config-add xdebug.ini ; fi
58 | 
59 | script:
60 |   - ./vendor/bin/behat
61 | 


--------------------------------------------------------------------------------
/src/BehatHTMLFormatterExtension.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace emuse\BehatHTMLFormatter;
 4 | 
 5 | use Behat\Testwork\ServiceContainer\Extension as ExtensionInterface;
 6 | use Behat\Testwork\ServiceContainer\ExtensionManager;
 7 | use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
 8 | use Symfony\Component\DependencyInjection\ContainerBuilder;
 9 | use Symfony\Component\DependencyInjection\Definition;
10 | 
11 | /**
12 |  * Class BehatHTMLFormatterExtension.
13 |  */
14 | class BehatHTMLFormatterExtension implements ExtensionInterface
15 | {
16 |     /**
17 |      * You can modify the container here before it is dumped to PHP code.
18 |      *
19 |      * @param ContainerBuilder $container
20 |      *
21 |      * @api
22 |      */
23 |     public function process(ContainerBuilder $container)
24 |     {
25 |     }
26 | 
27 |     /**
28 |      * Returns the extension config key.
29 |      *
30 |      * @return string
31 |      */
32 |     public function getConfigKey()
33 |     {
34 |         return 'emusehtml';
35 |     }
36 | 
37 |     /**
38 |      * Initializes other extensions.
39 |      *
40 |      * This method is called immediately after all extensions are activated but
41 |      * before any extension `configure()` method is called. This allows extensions
42 |      * to hook into the configuration of other extensions providing such an
43 |      * extension point.
44 |      *
45 |      * @param ExtensionManager $extensionManager
46 |      */
47 |     public function initialize(ExtensionManager $extensionManager)
48 |     {
49 |     }
50 | 
51 |     /**
52 |      * Setups configuration for the extension.
53 |      *
54 |      * @param ArrayNodeDefinition $builder
55 |      */
56 |     public function configure(ArrayNodeDefinition $builder)
57 |     {
58 |         $builder->children()->scalarNode('name')->defaultValue('emusehtml');
59 |         $builder->children()->scalarNode('renderer')->defaultValue('Twig');
60 |         $builder->children()->scalarNode('file_name')->defaultValue('generated');
61 |         $builder->children()->scalarNode('print_args')->defaultValue('false');
62 |         $builder->children()->scalarNode('print_outp')->defaultValue('false');
63 |         $builder->children()->scalarNode('loop_break')->defaultValue('false');
64 |     }
65 | 
66 |     /**
67 |      * Loads extension services into temporary container.
68 |      *
69 |      * @param ContainerBuilder $container
70 |      * @param array            $config
71 |      */
72 |     public function load(ContainerBuilder $container, array $config)
73 |     {
74 |         $definition = new Definition('emuse\\BehatHTMLFormatter\\Formatter\\BehatHTMLFormatter');
75 |         $definition->addArgument($config['name']);
76 |         $definition->addArgument($config['renderer']);
77 |         $definition->addArgument($config['file_name']);
78 |         $definition->addArgument($config['print_args']);
79 |         $definition->addArgument($config['print_outp']);
80 |         $definition->addArgument($config['loop_break']);
81 | 
82 |         $definition->addArgument('%paths.base%');
83 |         $container->setDefinition('html.formatter', $definition)
84 |       ->addTag('output.formatter');
85 |     }
86 | }
87 | 


--------------------------------------------------------------------------------
/src/Renderer/RendererInterface.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace emuse\BehatHTMLFormatter\Renderer;
  4 | 
  5 | interface RendererInterface
  6 | {
  7 |     /**
  8 |      * Renders before an exercice.
  9 |      *
 10 |      * @param object : BehatHTMLFormatter object
 11 |      *
 12 |      * @return string : HTML generated
 13 |      */
 14 |     public function renderBeforeExercise($obj);
 15 | 
 16 |     /**
 17 |      * Renders after an exercice.
 18 |      *
 19 |      * @param object : BehatHTMLFormatter object
 20 |      *
 21 |      * @return string : HTML generated
 22 |      */
 23 |     public function renderAfterExercise($obj);
 24 | 
 25 |     /**
 26 |      * Renders before a suite.
 27 |      *
 28 |      * @param object : BehatHTMLFormatter object
 29 |      *
 30 |      * @return string : HTML generated
 31 |      */
 32 |     public function renderBeforeSuite($obj);
 33 | 
 34 |     /**
 35 |      * Renders after a suite.
 36 |      *
 37 |      * @param object : BehatHTMLFormatter object
 38 |      *
 39 |      * @return string : HTML generated
 40 |      */
 41 |     public function renderAfterSuite($obj);
 42 | 
 43 |     /**
 44 |      * Renders before a feature.
 45 |      *
 46 |      * @param object : BehatHTMLFormatter object
 47 |      *
 48 |      * @return string : HTML generated
 49 |      */
 50 |     public function renderBeforeFeature($obj);
 51 | 
 52 |     /**
 53 |      * Renders after a feature.
 54 |      *
 55 |      * @param object : BehatHTMLFormatter object
 56 |      *
 57 |      * @return string : HTML generated
 58 |      */
 59 |     public function renderAfterFeature($obj);
 60 | 
 61 |     /**
 62 |      * Renders before a scenario.
 63 |      *
 64 |      * @param object : BehatHTMLFormatter object
 65 |      *
 66 |      * @return string : HTML generated
 67 |      */
 68 |     public function renderBeforeScenario($obj);
 69 | 
 70 |     /**
 71 |      * Renders after a scenario.
 72 |      *
 73 |      * @param object : BehatHTMLFormatter object
 74 |      *
 75 |      * @return string : HTML generated
 76 |      */
 77 |     public function renderAfterScenario($obj);
 78 | 
 79 |     /**
 80 |      * Renders before an outline.
 81 |      *
 82 |      * @param object : BehatHTMLFormatter object
 83 |      *
 84 |      * @return string : HTML generated
 85 |      */
 86 |     public function renderBeforeOutline($obj);
 87 | 
 88 |     /**
 89 |      * Renders after an outline.
 90 |      *
 91 |      * @param object : BehatHTMLFormatter object
 92 |      *
 93 |      * @return string : HTML generated
 94 |      */
 95 |     public function renderAfterOutline($obj);
 96 | 
 97 |     /**
 98 |      * Renders before a step.
 99 |      *
100 |      * @param object : BehatHTMLFormatter object
101 |      *
102 |      * @return string : HTML generated
103 |      */
104 |     public function renderBeforeStep($obj);
105 | 
106 |     /**
107 |      * Renders after a step.
108 |      *
109 |      * @param object : BehatHTMLFormatter object
110 |      *
111 |      * @return string : HTML generated
112 |      */
113 |     public function renderAfterStep($obj);
114 | 
115 |     /**
116 |      * To include CSS.
117 |      *
118 |      * @return string : HTML generated
119 |      */
120 |     public function getCSS();
121 | 
122 |     /**
123 |      * To include JS.
124 |      *
125 |      * @return string : HTML generated
126 |      */
127 |     public function getJS();
128 | }
129 | 


--------------------------------------------------------------------------------
/assets/Twig/css/style.less:
--------------------------------------------------------------------------------
  1 | @import url(https://fonts.googleapis.com/css?family=Source+Sans+Pro:300,400,700);
  2 | @import "callout.less";
  3 | 
  4 | @color-failed: #F56956;
  5 | @color-passed: #00a65a;
  6 | @color-pending: #e38d13;
  7 | 
  8 | body {
  9 |   background-color: #f9f9f9;
 10 |   font-family: 'Source Sans Pro', sans-serif;
 11 | }
 12 | 
 13 | .card {
 14 |   position: relative;
 15 |   background: #ffffff;
 16 |   margin-bottom: 20px;
 17 |   -webkit-border-radius: 3px;
 18 |   -moz-border-radius: 3px;
 19 |   border-radius: 3px;
 20 |   width: 100%;
 21 |   box-shadow: 0px 1px 3px rgba(0, 0, 0, 0.1);
 22 | 
 23 |   &:hover {
 24 |     cursor: pointer;
 25 |   }
 26 | 
 27 |   &.passed {
 28 |     .header {
 29 |       background-color: @color-passed;
 30 |     }
 31 |   }
 32 | 
 33 |   &.failed {
 34 |     .header {
 35 |       background-color: @color-failed;
 36 |     }
 37 |   }
 38 | 
 39 |   .header {
 40 |     color: #fff;
 41 |     border-top-left-radius: 3px;
 42 |     border-top-right-radius: 3px;
 43 |     border-bottom-right-radius: 0;
 44 |     border-bottom-left-radius: 0;
 45 |     border-bottom: 0px solid #f4f4f4;
 46 | 
 47 |     &:before, &:after {
 48 |       display: table;
 49 |       content: " ";
 50 |     }
 51 |     h2 {
 52 |       display: inline-block;
 53 |       padding: 10px 10px 10px 10px;
 54 |       margin: 0;
 55 |       font-size: 20px;
 56 |       font-weight: 400;
 57 |       cursor: default;
 58 |     }
 59 |   }
 60 | 
 61 |   .info {
 62 |     padding: 10px;
 63 |     height: 130px;
 64 |     overflow: auto;
 65 |   }
 66 | 
 67 |   .footer {
 68 |     border-top: 1px solid #f4f4f4;
 69 |     -webkit-border-top-left-radius: 0;
 70 |     -webkit-border-top-right-radius: 0;
 71 |     -webkit-border-bottom-right-radius: 3px;
 72 |     -webkit-border-bottom-left-radius: 3px;
 73 |     -moz-border-radius-topleft: 0;
 74 |     -moz-border-radius-topright: 0;
 75 |     -moz-border-radius-bottomright: 3px;
 76 |     -moz-border-radius-bottomleft: 3px;
 77 |     border-top-left-radius: 0;
 78 |     border-top-right-radius: 0;
 79 |     border-bottom-right-radius: 3px;
 80 |     border-bottom-left-radius: 3px;
 81 |     padding: 10px;
 82 |     background-color: #ffffff;
 83 | 
 84 |     .progress {
 85 |       margin-bottom: 0px;
 86 |     }
 87 |   }
 88 | 
 89 | }
 90 | 
 91 | .progress {
 92 |   height: 20px;
 93 |   overflow: hidden;
 94 |   background-color: #f5f5f5;
 95 |   border-radius: 4px;
 96 |   -webkit-box-shadow: inset 0 1px 2px rgba(0, 0, 0, .1);
 97 |   box-shadow: inset 0 1px 2px rgba(0, 0, 0, .1);
 98 | 
 99 |   .progress-bar-green {
100 |     background-color: @color-passed !important;
101 |     background-image: none !important;
102 |   }
103 | 
104 |   .progress-bar-red {
105 |     background-color: #f56954 !important;
106 |     background-image: none !important;
107 |   }
108 | }
109 | 
110 | #feature-overview {
111 | }
112 | 
113 | #scenario-overview {
114 |   display: none;
115 | 
116 |   .feature {
117 |     display: none;
118 |     &.selected {
119 |       display: block;
120 |     }
121 | 
122 |     .details {
123 |       .panel {
124 |         &.passed {
125 |           > .panel-heading {
126 |             color: white;
127 |             background-color: @color-passed;
128 |             background-image: none;
129 |           }
130 |         }
131 |         &.pending {
132 |           > .panel-heading {
133 |             color: white;
134 |             background-color: @color-pending;
135 |             background-image: none;
136 |           }
137 |         }
138 |         &.failed {
139 |           > .panel-heading {
140 |             color: white;
141 |             background-color: @color-failed;
142 |             background-image: none;
143 |           }
144 |         }
145 |       }
146 |     }
147 |   }
148 | }
149 | 


--------------------------------------------------------------------------------
/features/twig_renderer.feature:
--------------------------------------------------------------------------------
  1 |   Feature: Twig Renderer
  2 | 
  3 |   Background:
  4 |     Given a file named "behat.yml" with:
  5 |       """
  6 |       default:
  7 |         formatters:
  8 |             html:
  9 |                 output_path: %paths.base%/build
 10 |         extensions:
 11 |             emuse\BehatHTMLFormatter\BehatHTMLFormatterExtension:
 12 |                 name: html
 13 |                 renderer: Twig
 14 |                 file_name: Index
 15 |                 print_args: true
 16 |                 print_outp: true
 17 |                 loop_break: true
 18 |         suites:
 19 |             suite1:
 20 |                 paths:    [ "%paths.base%/features/suite1" ]
 21 |             suite2:
 22 |                 paths:    [ "%paths.base%/features/suite2" ]
 23 |             suite3:
 24 |                 paths:    [ "%paths.base%/features/suite3" ]
 25 |       """
 26 |     Given a file named "features/bootstrap/FeatureContext.php" with:
 27 |       """
 28 |       <?php
 29 |         use Behat\Behat\Context\CustomSnippetAcceptingContext,
 30 |             Behat\Behat\Tester\Exception\PendingException;
 31 |         class FeatureContext implements CustomSnippetAcceptingContext
 32 |         {
 33 |             public static function getAcceptedSnippetType() { return 'regex'; }
 34 |             /** @When /^I give a passing step$/ */
 35 |             public function passingStep() { 
 36 |               PHPUnit_Framework_Assert::assertEquals(2, 2);
 37 |             }
 38 |             /** @When /^I give a failing step$/ */
 39 |             public function failingStep() { 
 40 |               PHPUnit_Framework_Assert::assertEquals(1, 2);
 41 |             }
 42 |             /** * @When /^I give a pending step$/ */
 43 |             public function somethingNotDoneYet() {
 44 |                 throw new PendingException();
 45 |             }
 46 |         }
 47 |       """
 48 | 
 49 |  Scenario: Multiple Suites with multiple results
 50 |     Given a file named "features/suite1/suite_failing_with_passing.feature" with:
 51 |       """
 52 |       Feature: Suite failing with passing scenarios
 53 |         Scenario: Passing scenario
 54 |           Then I give a passing step
 55 |         Scenario: One Failing step
 56 |           Then I give a failing step
 57 |         Scenario: One Pending step
 58 |           Then I give a pending step
 59 |         Scenario: Passing and Pending steps
 60 |           Then I give a passing step
 61 |           Then I give a pending step
 62 |         Scenario: Passing and Failing steps
 63 |           Then I give a passing step
 64 |           Then I give a failing step
 65 |       """
 66 |     Given a file named "features/suite2/suite_passing.feature" with:
 67 |       """
 68 |       Feature: Suite passing
 69 |         Scenario: Passing scenario
 70 |           Then I give a passing step
 71 |       """
 72 |     Given a file named "features/suite3/suite_pending.feature" with:
 73 |       """
 74 |       Feature: Suite with pending scenario
 75 |         Scenario: One pending step
 76 |           Then I give a pending step
 77 |       """
 78 |     When I run "behat --no-colors"
 79 |     Then process output should be:
 80 |       """
 81 | 
 82 |       --- FeatureContext has missing steps. Define them with these snippets:
 83 | 
 84 |           /**
 85 |            * @Then /^I give a pending step$/
 86 |            */
 87 |           public function iGiveAPendingStep()
 88 |           {
 89 |               throw new PendingException();
 90 |           }
 91 | 
 92 | 
 93 |       """
 94 |     And report file should exists
 95 |     And report file should contain:
 96 |       """
 97 |       2 features failed of 3
 98 |       """
 99 |     And report file should contain:
100 |       """
101 |       5 scenarios failed of 7
102 |       """
103 |     And report file should contain:
104 |       """
105 |       2 steps failed of 6
106 |       """
107 | 
108 | 


--------------------------------------------------------------------------------
/assets/Twig/css/style.css:
--------------------------------------------------------------------------------
  1 | @import url(https://fonts.googleapis.com/css?family=Source+Sans+Pro:300,400,700);
  2 | .bs-callout {
  3 |   padding: 20px;
  4 |   margin: 20px 0;
  5 |   border: 1px solid #eee;
  6 |   border-left-width: 5px;
  7 |   border-radius: 3px;
  8 | }
  9 | .bs-callout h4 {
 10 |   margin-top: 0;
 11 |   margin-bottom: 5px;
 12 | }
 13 | .bs-callout p:last-child {
 14 |   margin-bottom: 0;
 15 | }
 16 | .bs-callout code {
 17 |   border-radius: 3px;
 18 | }
 19 | .bs-callout + .bs-callout {
 20 |   margin-top: -5px;
 21 | }
 22 | .bs-callout-default {
 23 |   border-left-color: #777;
 24 | }
 25 | .bs-callout-default h4 {
 26 |   color: #777;
 27 | }
 28 | .bs-callout-primary {
 29 |   border-left-color: #428bca;
 30 | }
 31 | .bs-callout-primary h4 {
 32 |   color: #428bca;
 33 | }
 34 | .bs-callout-success {
 35 |   border-left-color: #5cb85c;
 36 | }
 37 | .bs-callout-success h4 {
 38 |   color: #5cb85c;
 39 | }
 40 | .bs-callout-danger {
 41 |   border-left-color: #d9534f;
 42 | }
 43 | .bs-callout-danger h4 {
 44 |   color: #d9534f;
 45 | }
 46 | .bs-callout-warning {
 47 |   border-left-color: #f0ad4e;
 48 | }
 49 | .bs-callout-warning h4 {
 50 |   color: #f0ad4e;
 51 | }
 52 | .bs-callout-info {
 53 |   border-left-color: #5bc0de;
 54 | }
 55 | .bs-callout-info h4 {
 56 |   color: #5bc0de;
 57 | }
 58 | body {
 59 |   background-color: #f9f9f9;
 60 |   font-family: 'Source Sans Pro', sans-serif;
 61 | }
 62 | .card {
 63 |   position: relative;
 64 |   background: #ffffff;
 65 |   margin-bottom: 20px;
 66 |   -webkit-border-radius: 3px;
 67 |   -moz-border-radius: 3px;
 68 |   border-radius: 3px;
 69 |   width: 100%;
 70 |   box-shadow: 0px 1px 3px rgba(0, 0, 0, 0.1);
 71 | }
 72 | .card:hover {
 73 |   cursor: pointer;
 74 | }
 75 | .card.passed .header {
 76 |   background-color: #00a65a;
 77 | }
 78 | .card.failed .header {
 79 |   background-color: #f56956;
 80 | }
 81 | .card .header {
 82 |   color: #fff;
 83 |   border-top-left-radius: 3px;
 84 |   border-top-right-radius: 3px;
 85 |   border-bottom-right-radius: 0;
 86 |   border-bottom-left-radius: 0;
 87 |   border-bottom: 0px solid #f4f4f4;
 88 | }
 89 | .card .header:before,
 90 | .card .header:after {
 91 |   display: table;
 92 |   content: " ";
 93 | }
 94 | .card .header h2 {
 95 |   display: inline-block;
 96 |   padding: 10px 10px 10px 10px;
 97 |   margin: 0;
 98 |   font-size: 20px;
 99 |   font-weight: 400;
100 |   cursor: default;
101 | }
102 | .card .info {
103 |   padding: 10px;
104 |   height: 130px;
105 |   overflow: auto;
106 | }
107 | .card .footer {
108 |   border-top: 1px solid #f4f4f4;
109 |   -webkit-border-top-left-radius: 0;
110 |   -webkit-border-top-right-radius: 0;
111 |   -webkit-border-bottom-right-radius: 3px;
112 |   -webkit-border-bottom-left-radius: 3px;
113 |   -moz-border-radius-topleft: 0;
114 |   -moz-border-radius-topright: 0;
115 |   -moz-border-radius-bottomright: 3px;
116 |   -moz-border-radius-bottomleft: 3px;
117 |   border-top-left-radius: 0;
118 |   border-top-right-radius: 0;
119 |   border-bottom-right-radius: 3px;
120 |   border-bottom-left-radius: 3px;
121 |   padding: 10px;
122 |   background-color: #ffffff;
123 | }
124 | .card .footer .progress {
125 |   margin-bottom: 0px;
126 | }
127 | .progress {
128 |   height: 20px;
129 |   overflow: hidden;
130 |   background-color: #f5f5f5;
131 |   border-radius: 4px;
132 |   -webkit-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1);
133 |   box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1);
134 | }
135 | .progress .progress-bar-green {
136 |   background-color: #00a65a !important;
137 |   background-image: none !important;
138 | }
139 | .progress .progress-bar-red {
140 |   background-color: #f56954 !important;
141 |   background-image: none !important;
142 | }
143 | #scenario-overview {
144 |   display: none;
145 | }
146 | #scenario-overview .feature {
147 |   display: none;
148 | }
149 | #scenario-overview .feature.selected {
150 |   display: block;
151 | }
152 | #scenario-overview .feature .details .panel.passed > .panel-heading {
153 |   color: white;
154 |   background-color: #00a65a;
155 |   background-image: none;
156 | }
157 | #scenario-overview .feature .details .panel.pending > .panel-heading {
158 |   color: white;
159 |   background-color: #e38d13;
160 |   background-image: none;
161 | }
162 | #scenario-overview .feature .details .panel.failed > .panel-heading {
163 |   color: white;
164 |   background-color: #f56956;
165 |   background-image: none;
166 | }
167 | .list-group-item.break {
168 |   padding: 1px;
169 |   background-color: #808080;
170 | }


--------------------------------------------------------------------------------
/src/Classes/Scenario.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace emuse\BehatHTMLFormatter\Classes;
  4 | 
  5 | class Scenario
  6 | {
  7 |     /**
  8 |      * @var int
  9 |      */
 10 |     private $id;
 11 |     private $name;
 12 |     private $line;
 13 |     private $tags;
 14 |     private $loopCount;
 15 |     private $screenshotName;
 16 | 
 17 |     /**
 18 |      * @var bool
 19 |      */
 20 |     private $passed;
 21 | 
 22 |     /**
 23 |      * @var bool
 24 |      */
 25 |     private $pending;
 26 | 
 27 |     /**
 28 |      * @var Step[]
 29 |      */
 30 |     private $steps;
 31 |     private $screenshotPath;
 32 | 
 33 |     /**
 34 |      * @return mixed
 35 |      */
 36 |     public function getName()
 37 |     {
 38 |         return $this->name;
 39 |     }
 40 | 
 41 |     /**
 42 |      * @param mixed $name
 43 |      */
 44 |     public function setName($name)
 45 |     {
 46 |         $this->name = $name;
 47 |     }
 48 | 
 49 |     public function getScreenshotName()
 50 |     {
 51 |         return $this->screenshotName;
 52 |     }
 53 | 
 54 |     public function setScreenshotName($scenarioName)
 55 |     {
 56 |         $this->screenshotName = preg_replace('/\W/', '', $scenarioName).'.png';
 57 |     }
 58 | 
 59 |     /**
 60 |      * @return int
 61 |      */
 62 |     public function getLoopCount()
 63 |     {
 64 |         return $this->loopCount;
 65 |     }
 66 | 
 67 |     /**
 68 |      * @param int $loopCount
 69 |      */
 70 |     public function setLoopCount($loopCount)
 71 |     {
 72 |         $this->loopCount = $loopCount;
 73 |     }
 74 | 
 75 |     /**
 76 |      * @return mixed
 77 |      */
 78 |     public function getLine()
 79 |     {
 80 |         return $this->line;
 81 |     }
 82 | 
 83 |     /**
 84 |      * @param mixed $line
 85 |      */
 86 |     public function setLine($line)
 87 |     {
 88 |         $this->line = $line;
 89 |     }
 90 | 
 91 |     /**
 92 |      * @return mixed
 93 |      */
 94 |     public function getTags()
 95 |     {
 96 |         return $this->tags;
 97 |     }
 98 | 
 99 |     /**
100 |      * @param mixed $tags
101 |      */
102 |     public function setTags($tags)
103 |     {
104 |         $this->tags = $tags;
105 |     }
106 | 
107 |     /**
108 |      * @return bool
109 |      */
110 |     public function isPassed()
111 |     {
112 |         return $this->passed;
113 |     }
114 | 
115 |     /**
116 |      * @param bool $passed
117 |      */
118 |     public function setPassed($passed)
119 |     {
120 |         $this->passed = $passed;
121 |     }
122 | 
123 |     /**
124 |      * @return bool
125 |      */
126 |     public function isPending()
127 |     {
128 |         return $this->pending;
129 |     }
130 | 
131 |     /**
132 |      * @param bool $pending
133 |      */
134 |     public function setPending($pending)
135 |     {
136 |         $this->pending = $pending;
137 |     }
138 | 
139 |     /**
140 |      * @return Step[]
141 |      */
142 |     public function getSteps()
143 |     {
144 |         return $this->steps;
145 |     }
146 | 
147 |     /**
148 |      * @param Step[] $steps
149 |      */
150 |     public function setSteps($steps)
151 |     {
152 |         $this->steps = $steps;
153 |     }
154 | 
155 |     /**
156 |      * @param Step $step
157 |      */
158 |     public function addStep($step)
159 |     {
160 |         $this->steps[] = $step;
161 |     }
162 | 
163 |     /**
164 |      * @return int
165 |      */
166 |     public function getId()
167 |     {
168 |         return $this->id;
169 |     }
170 | 
171 |     /**
172 |      * @param int $id
173 |      */
174 |     public function setId($id)
175 |     {
176 |         $this->id = $id;
177 |     }
178 | 
179 |     public function getLoopSize()
180 |     {
181 |         //behat
182 |         return $this->loopCount > 0 ? sizeof($this->steps) / $this->loopCount : sizeof($this->steps);
183 |     }
184 | 
185 |     public function setScreenshotPath($string)
186 |     {
187 |         $this->screenshotPath = $string;
188 |     }
189 | 
190 |     /**
191 |      * @return mixed
192 |      */
193 |     public function getScreenshotPath()
194 |     {
195 |         return $this->screenshotPath;
196 |     }
197 | 
198 |     /**
199 |      * Gets relative path for screenshot.
200 |      *
201 |      * @return bool|string
202 |      */
203 |     public function getRelativeScreenshotPath()
204 |     {
205 |         if (!isset($this->screenshotPath) || !file_exists($this->screenshotPath)) {
206 |             return false;
207 |         }
208 | 
209 |         return '.'.substr($this->screenshotPath, strpos($this->screenshotPath, '/assets/screenshots'));
210 |     }
211 | }
212 | 


--------------------------------------------------------------------------------
/src/Classes/Step.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace emuse\BehatHTMLFormatter\Classes;
  4 | 
  5 | use Behat\Behat\Tester\Result\StepResult;
  6 | 
  7 | class Step
  8 | {
  9 |     private $keyword;
 10 |     private $text;
 11 |     private $arguments;
 12 |     private $line;
 13 |     private $result;
 14 |     private $resultCode;
 15 |     private $exception;
 16 |     private $output;
 17 |     private $definition;
 18 |     private $argumentType;
 19 | 
 20 |     /**
 21 |      * @return mixed
 22 |      */
 23 |     public function getKeyword()
 24 |     {
 25 |         return $this->keyword;
 26 |     }
 27 | 
 28 |     /**
 29 |      * @param mixed $keyword
 30 |      */
 31 |     public function setKeyword($keyword)
 32 |     {
 33 |         $this->keyword = $keyword;
 34 |     }
 35 | 
 36 |     /**
 37 |      * @return mixed
 38 |      */
 39 |     public function getText()
 40 |     {
 41 |         return $this->text;
 42 |     }
 43 | 
 44 |     /**
 45 |      * @param mixed $text
 46 |      */
 47 |     public function setText($text)
 48 |     {
 49 |         $this->text = $text;
 50 |     }
 51 | 
 52 |     /**
 53 |      * @return mixed
 54 |      */
 55 |     public function getArgumentType()
 56 |     {
 57 |         return $this->argumentType;
 58 |     }
 59 | 
 60 |     /**
 61 |      * @param mixed $arguments
 62 |      */
 63 |     public function setArgumentType($argumentType)
 64 |     {
 65 |         $this->argumentType = $argumentType;
 66 |     }
 67 | 
 68 |     /**
 69 |      * @return mixed
 70 |      */
 71 |     public function getArguments()
 72 |     {
 73 |         return $this->arguments;
 74 |     }
 75 | 
 76 |     /**
 77 |      * @param mixed $arguments
 78 |      */
 79 |     public function setArguments($arguments)
 80 |     {
 81 |         $this->arguments = $arguments;
 82 |     }
 83 | 
 84 |     /**
 85 |      * @return mixed
 86 |      */
 87 |     public function getLine()
 88 |     {
 89 |         return $this->line;
 90 |     }
 91 | 
 92 |     /**
 93 |      * @param mixed $line
 94 |      */
 95 |     public function setLine($line)
 96 |     {
 97 |         $this->line = $line;
 98 |     }
 99 | 
100 |     /**
101 |      * @return mixed
102 |      */
103 |     public function getResult()
104 |     {
105 |         return $this->result;
106 |     }
107 | 
108 |     /**
109 |      * @param mixed $result
110 |      */
111 |     public function setResult($result)
112 |     {
113 |         $this->result = $result;
114 |     }
115 | 
116 |     /**
117 |      * @return mixed
118 |      */
119 |     public function getException()
120 |     {
121 |         return $this->exception;
122 |     }
123 | 
124 |     /**
125 |      * @param mixed $exception
126 |      */
127 |     public function setException($exception)
128 |     {
129 |         $this->exception = $exception;
130 |     }
131 | 
132 |     /**
133 |      * @return mixed
134 |      */
135 |     public function getDefinition()
136 |     {
137 |         return $this->definition;
138 |     }
139 | 
140 |     /**
141 |      * @param mixed $definition
142 |      */
143 |     public function setDefinition($definition)
144 |     {
145 |         $this->definition = $definition;
146 |     }
147 | 
148 |     /**
149 |      * @return mixed
150 |      */
151 |     public function getOutput()
152 |     {
153 |         return $this->output;
154 |     }
155 | 
156 |     /**
157 |      * @param mixed $output
158 |      */
159 |     public function setOutput($output)
160 |     {
161 |         $this->output = $output;
162 |     }
163 | 
164 |     /**
165 |      * @return mixed
166 |      */
167 |     public function getResultCode()
168 |     {
169 |         return $this->resultCode;
170 |     }
171 | 
172 |     /**
173 |      * @param mixed $resultCode
174 |      */
175 |     public function setResultCode($resultCode)
176 |     {
177 |         $this->resultCode = $resultCode;
178 |     }
179 | 
180 |     /**
181 |      * @return bool
182 |      */
183 |     public function isPassed()
184 |     {
185 |         return StepResult::PASSED == $this->resultCode;
186 |     }
187 | 
188 |     /**
189 |      * @return bool
190 |      */
191 |     public function isSkipped()
192 |     {
193 |         return StepResult::SKIPPED == $this->resultCode;
194 |     }
195 | 
196 |     /**
197 |      * @return bool
198 |      */
199 |     public function isPending()
200 |     {
201 |         return StepResult::PENDING == $this->resultCode || StepResult::UNDEFINED == $this->resultCode;
202 |     }
203 | 
204 |     /**
205 |      * @return bool
206 |      */
207 |     public function isFailed()
208 |     {
209 |         return StepResult::FAILED == $this->resultCode;
210 |     }
211 | }
212 | 


--------------------------------------------------------------------------------
/templates/index.backup.html.twig:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |     <meta charset="utf-8">
 5 |     <meta http-equiv="X-UA-Compatible" content="IE=edge">
 6 |     <meta name="viewport" content="width=device-width, initial-scale=1">
 7 |     <title>Behat report</title>
 8 | 
 9 |     <!-- Bootstrap -->
10 |     <!-- Latest compiled and minified CSS -->
11 |     <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.1/css/bootstrap.min.css">
12 | 
13 |     <!-- Optional theme -->
14 |     <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.1/css/bootstrap-theme.min.css">
15 | 
16 |     <!-- HTML5 shim and Respond.js for IE8 support of HTML5 elements and media queries -->
17 |     <!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
18 |     <!--[if lt IE 9]>
19 |     <script src="https://oss.maxcdn.com/html5shiv/3.7.2/html5shiv.min.js"></script>
20 |     <script src="https://oss.maxcdn.com/respond/1.4.2/respond.min.js"></script>
21 |     <![endif]-->
22 | </head>
23 | <body role="document" style="margin-top: 70px;">
24 | 
25 | <!-- Fixed navbar -->
26 | <nav class="navbar navbar-inverse navbar-fixed-top">
27 |     <div class="container">
28 |         <div class="navbar-header">
29 |             <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar"
30 |                     aria-expanded="false" aria-controls="navbar">
31 |                 <span class="sr-only">Toggle navigation</span>
32 |                 <span class="icon-bar"></span>
33 |                 <span class="icon-bar"></span>
34 |                 <span class="icon-bar"></span>
35 |             </button>
36 |             <a class="navbar-brand" href="#">Behat report</a>
37 |         </div>
38 |         <div id="navbar" class="navbar-collapse collapse">
39 |             <ul class="nav navbar-nav">
40 |                 {#<li class="active"><a href="#">Home</a></li>#}
41 |             </ul>
42 |         </div>
43 |         <!--/.nav-collapse -->
44 |     </div>
45 | </nav>
46 | 
47 | <div class="container theme-showcase" role="main">
48 |     <div class="row">
49 |         <div class="col-sm-4">
50 |             {{ failedScenarios|length }} scenarios failed of {{ (failedScenarios|length) + (passedScenarios|length) }}
51 |             scenarios
52 |         </div>
53 |         <div class="col-sm-4">
54 |             {{ failedSteps|length }} steps failed of {{ (failedSteps|length) + (passedSteps|length) }}
55 |         </div>
56 |     </div>
57 |     <hr>
58 |     {% for suite in suites %}
59 |         <div class="row">
60 |             <div class="col-sm-12">
61 |                 <h2>{% trans %}Suite: {% endtrans %}{{ suite.name }}</h2>
62 |                 {% for feature in suite.features %}
63 |                     <h2>{% trans %}Feature: {% endtrans %}{{ feature.name }}</h2>
64 |                     {% for tag in feature.tags %}
65 |                         <span class="badge">{{ tag }}</span>
66 |                     {% endfor %}
67 |                     <p>{{ feature.description|raw|nl2br }}</p>
68 |                     {% for scenario in feature.scenarios %}
69 |                         <div class="row">
70 |                             <div class="col-sm-8">
71 |                                 <h3>{% trans %}Scenario: {% endtrans %}{{ scenario.name }}</h3>
72 |                                 {% for tag in scenario.tags %}
73 |                                     <span class="badge">{{ tag }}</span>
74 |                                 {% endfor %}
75 |                             </div>
76 |                             <div class="col-sm-4 small">{{ feature.file }}: {{ scenario.line }}</div>
77 |                             {% for step in scenario.steps %}
78 |                                 <div class="col-sm-12">
79 |                                     <div class="alert alert-{% if step.passed %}success{% else %}danger{% endif %}">
80 |                                         <b>{{ step.keyword }}</b> {{ step.text }}
81 |                                     </div>
82 |                                 </div>
83 |                             {% endfor %}
84 |                         </div>
85 |                     {% endfor %}
86 |                 {% endfor %}
87 |             </div>
88 |         </div>
89 |         <hr>
90 |     {% endfor %}
91 | </div>
92 | <!-- /container -->
93 | <!-- jQuery (necessary for Bootstrap's JavaScript plugins) -->
94 | <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
95 | <!-- Include all compiled plugins (below), or include individual files as needed -->
96 | <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.1/js/bootstrap.min.js"></script>
97 | </body>
98 | </html>
99 | 


--------------------------------------------------------------------------------
/src/Renderer/TwigRenderer.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace emuse\BehatHTMLFormatter\Renderer;
  4 | 
  5 | use emuse\BehatHTMLFormatter\Formatter\BehatHTMLFormatter;
  6 | use Twig_Environment;
  7 | use Twig_Loader_Filesystem;
  8 | 
  9 | /**
 10 |  * Twig renderer for Behat report.
 11 |  *
 12 |  * Class TwigRenderer
 13 |  */
 14 | class TwigRenderer
 15 | {
 16 |     /**
 17 |      * Renders before an exercise.
 18 |      *
 19 |      * @param BehatHTMLFormatter $obj
 20 |      *
 21 |      * @return string : HTML generated
 22 |      */
 23 |     public function renderBeforeExercise(BehatHTMLFormatter $obj)
 24 |     {
 25 |         return '';
 26 |     }
 27 | 
 28 |     /**
 29 |      * Renders after an exercise.
 30 |      *
 31 |      * @param BehatHTMLFormatter $obj
 32 |      *
 33 |      * @return string : HTML generated
 34 |      */
 35 |     public function renderAfterExercise(BehatHTMLFormatter $obj)
 36 |     {
 37 |         $templatePath = dirname(__FILE__).'/../../templates';
 38 |         $loader = new Twig_Loader_Filesystem($templatePath);
 39 |         $twig = new Twig_Environment($loader, array());
 40 |         $print = $twig->render('index.html.twig',
 41 |             array(
 42 |                 'suites' => $obj->getSuites(),
 43 |                 'failedScenarios' => $obj->getFailedScenarios(),
 44 |                 'pendingScenarios' => $obj->getPendingScenarios(),
 45 |                 'passedScenarios' => $obj->getPassedScenarios(),
 46 |                 'failedSteps' => $obj->getFailedSteps(),
 47 |                 'passedSteps' => $obj->getPassedSteps(),
 48 |                 'skippedSteps' => $obj->getSkippedSteps(),
 49 |                 'failedFeatures' => $obj->getFailedFeatures(),
 50 |                 'passedFeatures' => $obj->getPassedFeatures(),
 51 |                 'printStepArgs' => $obj->getPrintArguments(),
 52 |                 'printStepOuts' => $obj->getPrintOutputs(),
 53 |                 'printLoopBreak' => $obj->getPrintLoopBreak(),
 54 |             )
 55 |         );
 56 | 
 57 |         return $print;
 58 |     }
 59 | 
 60 |     /**
 61 |      * Renders before a suite.
 62 |      *
 63 |      * @param BehatHTMLFormatter $obj
 64 |      *
 65 |      * @return string : HTML generated
 66 |      */
 67 |     public function renderBeforeSuite(BehatHTMLFormatter $obj)
 68 |     {
 69 |         return '';
 70 |     }
 71 | 
 72 |     /**
 73 |      * Renders after a suite.
 74 |      *
 75 |      * @param BehatHTMLFormatter $obj
 76 |      *
 77 |      * @return string : HTML generated
 78 |      */
 79 |     public function renderAfterSuite(BehatHTMLFormatter $obj)
 80 |     {
 81 |         return '';
 82 |     }
 83 | 
 84 |     /**
 85 |      * Renders before a feature.
 86 |      *
 87 |      * @param BehatHTMLFormatter $obj
 88 |      *
 89 |      * @return string : HTML generated
 90 |      */
 91 |     public function renderBeforeFeature(BehatHTMLFormatter $obj)
 92 |     {
 93 |         return '';
 94 |     }
 95 | 
 96 |     /**
 97 |      * Renders after a feature.
 98 |      *
 99 |      * @param BehatHTMLFormatter $obj
100 |      *
101 |      * @return string : HTML generated
102 |      */
103 |     public function renderAfterFeature(BehatHTMLFormatter $obj)
104 |     {
105 |         return '';
106 |     }
107 | 
108 |     /**
109 |      * Renders before a scenario.
110 |      *
111 |      * @param BehatHTMLFormatter $obj
112 |      *
113 |      * @return string : HTML generated
114 |      */
115 |     public function renderBeforeScenario(BehatHTMLFormatter $obj)
116 |     {
117 |         return '';
118 |     }
119 | 
120 |     /**
121 |      * Renders after a scenario.
122 |      *
123 |      * @param BehatHTMLFormatter $obj
124 |      *
125 |      * @return string : HTML generated
126 |      */
127 |     public function renderAfterScenario(BehatHTMLFormatter $obj)
128 |     {
129 |         return '';
130 |     }
131 | 
132 |     /**
133 |      * Renders before an outline.
134 |      *
135 |      * @param BehatHTMLFormatter $obj
136 |      *
137 |      * @return string : HTML generated
138 |      */
139 |     public function renderBeforeOutline(BehatHTMLFormatter $obj)
140 |     {
141 |         return '';
142 |     }
143 | 
144 |     /**
145 |      * Renders after an outline.
146 |      *
147 |      * @param BehatHTMLFormatter $obj
148 |      *
149 |      * @return string : HTML generated
150 |      */
151 |     public function renderAfterOutline(BehatHTMLFormatter $obj)
152 |     {
153 |         return '';
154 |     }
155 | 
156 |     /**
157 |      * Renders before a step.
158 |      *
159 |      * @param BehatHTMLFormatter $obj
160 |      *
161 |      * @return string : HTML generated
162 |      */
163 |     public function renderBeforeStep(BehatHTMLFormatter $obj)
164 |     {
165 |         return '';
166 |     }
167 | 
168 |     /**
169 |      * Renders after a step.
170 |      *
171 |      * @param BehatHTMLFormatter $obj
172 |      *
173 |      * @return string : HTML generated
174 |      */
175 |     public function renderAfterStep(BehatHTMLFormatter $obj)
176 |     {
177 |         return '';
178 |     }
179 | 
180 |     /**
181 |      * To include CSS.
182 |      *
183 |      * @return string : HTML generated
184 |      */
185 |     public function getCSS()
186 |     {
187 |         return '';
188 |     }
189 | 
190 |     /**
191 |      * To include JS.
192 |      *
193 |      * @return string : HTML generated
194 |      */
195 |     public function getJS()
196 |     {
197 |         return '';
198 |     }
199 | }
200 | 


--------------------------------------------------------------------------------
/src/Renderer/MinimalRenderer.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Behat2 renderer for Behat report.
  4 |  *
  5 |  * @author DaSayan <glennwall@free.fr>
  6 |  */
  7 | 
  8 | namespace emuse\BehatHTMLFormatter\Renderer;
  9 | 
 10 | class MinimalRenderer
 11 | {
 12 |     private $extension = 'csv';
 13 | 
 14 |     public function __construct()
 15 |     {
 16 |     }
 17 | 
 18 |     public function getExtension($renderer)
 19 |     {
 20 |         return $this->rendererList[$renderer]->getExtension();
 21 |     }
 22 | 
 23 |     /**
 24 |      * Renders before an exercice.
 25 |      *
 26 |      * @param object   : BehatHTMLFormatter object
 27 |      *
 28 |      * @return string : HTML generated
 29 |      */
 30 |     public function renderBeforeExercise($obj)
 31 |     {
 32 |         return '';
 33 |     }
 34 | 
 35 |     /**
 36 |      * Renders after an exercice.
 37 |      *
 38 |      * @param object   : BehatHTMLFormatter object
 39 |      *
 40 |      * @return string : HTML generated
 41 |      */
 42 |     public function renderAfterExercise($obj)
 43 |     {
 44 |         $strFeatPassed = count($obj->getPassedFeatures());
 45 |         $strFeatFailed = count($obj->getFailedFeatures());
 46 |         $strScePassed = count($obj->getPassedScenarios());
 47 |         $strScePending = count($obj->getPendingScenarios());
 48 |         $strSceFailed = count($obj->getFailedScenarios());
 49 |         $strStepsPassed = count($obj->getPassedSteps());
 50 |         $strStepsPending = count($obj->getPendingSteps());
 51 |         $strStepsSkipped = count($obj->getSkippedSteps());
 52 |         $strStepsFailed = count($obj->getFailedSteps());
 53 | 
 54 |         $featTotal = (count($obj->getFailedFeatures()) + count($obj->getPassedFeatures()));
 55 |         $sceTotal = (count($obj->getFailedScenarios()) + count($obj->getPendingScenarios()) + count($obj->getPassedScenarios()));
 56 |         $stepsTotal = (count($obj->getFailedSteps()) + count($obj->getPassedSteps()) + count($obj->getSkippedSteps()) + count($obj->getPendingSteps()));
 57 | 
 58 |         $print = $featTotal.','.$strFeatPassed.','.$strFeatFailed."\n";
 59 |         $print .= $sceTotal.','.$strScePassed.','.$strScePending.','.$strSceFailed."\n";
 60 |         $print .= $stepsTotal.','.$strStepsPassed.','.$strStepsFailed.','.$strStepsSkipped.','.$strStepsPending."\n";
 61 |         $print .= $obj->getTimer().','.$obj->getMemory()."\n";
 62 | 
 63 |         return $print;
 64 |     }
 65 | 
 66 |     /**
 67 |      * Renders before a suite.
 68 |      *
 69 |      * @param object   : BehatHTMLFormatter object
 70 |      *
 71 |      * @return string : HTML generated
 72 |      */
 73 |     public function renderBeforeSuite($obj)
 74 |     {
 75 |         return '';
 76 |     }
 77 | 
 78 |     /**
 79 |      * Renders after a suite.
 80 |      *
 81 |      * @param object   : BehatHTMLFormatter object
 82 |      *
 83 |      * @return string : HTML generated
 84 |      */
 85 |     public function renderAfterSuite($obj)
 86 |     {
 87 |         return '';
 88 |     }
 89 | 
 90 |     /**
 91 |      * Renders before a feature.
 92 |      *
 93 |      * @param object   : BehatHTMLFormatter object
 94 |      *
 95 |      * @return string : HTML generated
 96 |      */
 97 |     public function renderBeforeFeature($obj)
 98 |     {
 99 |         return '';
100 |     }
101 | 
102 |     /**
103 |      * Renders after a feature.
104 |      *
105 |      * @param object   : BehatHTMLFormatter object
106 |      *
107 |      * @return string : HTML generated
108 |      */
109 |     public function renderAfterFeature($obj)
110 |     {
111 |         return '';
112 |     }
113 | 
114 |     /**
115 |      * Renders before a scenario.
116 |      *
117 |      * @param object   : BehatHTMLFormatter object
118 |      *
119 |      * @return string : HTML generated
120 |      */
121 |     public function renderBeforeScenario($obj)
122 |     {
123 |         return '';
124 |     }
125 | 
126 |     /**
127 |      * Renders after a scenario.
128 |      *
129 |      * @param object   : BehatHTMLFormatter object
130 |      *
131 |      * @return string : HTML generated
132 |      */
133 |     public function renderAfterScenario($obj)
134 |     {
135 |         return '';
136 |     }
137 | 
138 |     /**
139 |      * Renders before an outline.
140 |      *
141 |      * @param object   : BehatHTMLFormatter object
142 |      *
143 |      * @return string : HTML generated
144 |      */
145 |     public function renderBeforeOutline($obj)
146 |     {
147 |         return '';
148 |     }
149 | 
150 |     /**
151 |      * Renders after an outline.
152 |      *
153 |      * @param object   : BehatHTMLFormatter object
154 |      *
155 |      * @return string : HTML generated
156 |      */
157 |     public function renderAfterOutline($obj)
158 |     {
159 |         return '';
160 |     }
161 | 
162 |     /**
163 |      * Renders before a step.
164 |      *
165 |      * @param object   : BehatHTMLFormatter object
166 |      *
167 |      * @return string : HTML generated
168 |      */
169 |     public function renderBeforeStep($obj)
170 |     {
171 |         return '';
172 |     }
173 | 
174 |     /**
175 |      * Renders after a step.
176 |      *
177 |      * @param object   : BehatHTMLFormatter object
178 |      *
179 |      * @return string : HTML generated
180 |      */
181 |     public function renderAfterStep($obj)
182 |     {
183 |         return '';
184 |     }
185 | 
186 |     /**
187 |      * To include CSS.
188 |      *
189 |      * @return string : HTML generated
190 |      */
191 |     public function getCSS()
192 |     {
193 |         return '';
194 |     }
195 | 
196 |     /**
197 |      * To include JS.
198 |      *
199 |      * @return string : HTML generated
200 |      */
201 |     public function getJS()
202 |     {
203 |         return '';
204 |     }
205 | }
206 | 


--------------------------------------------------------------------------------
/src/Classes/Feature.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace emuse\BehatHTMLFormatter\Classes;
  4 | 
  5 | class Feature
  6 | {
  7 |     //<editor-fold desc="Variables">
  8 |     private $id;
  9 |     private $name;
 10 |     private $description;
 11 |     private $tags;
 12 |     private $file;
 13 |     private $screenshotFolder;
 14 |     private $failedScenarios = 0;
 15 |     private $pendingScenarios = 0;
 16 |     private $passedScenarios = 0;
 17 |     private $scenarioCounter = 1;
 18 | 
 19 |     /**
 20 |      * @var Scenario[]
 21 |      */
 22 |     private $scenarios;
 23 |     //</editor-fold>
 24 | 
 25 |     //<editor-fold desc="Getters/Setters">
 26 | 
 27 |     /**
 28 |      * @return mixed
 29 |      */
 30 |     public function getName()
 31 |     {
 32 |         return $this->name;
 33 |     }
 34 | 
 35 |     /**
 36 |      * @param mixed $name
 37 |      */
 38 |     public function setName($name)
 39 |     {
 40 |         $this->name = $name;
 41 |     }
 42 | 
 43 |     /**
 44 |      * @return mixed
 45 |      */
 46 |     public function getDescription()
 47 |     {
 48 |         return $this->description;
 49 |     }
 50 | 
 51 |     /**
 52 |      * @param mixed $description
 53 |      */
 54 |     public function setDescription($description)
 55 |     {
 56 |         $this->description = $description;
 57 |     }
 58 | 
 59 |     /**
 60 |      * @return mixed
 61 |      */
 62 |     public function getTags()
 63 |     {
 64 |         return $this->tags;
 65 |     }
 66 | 
 67 |     /**
 68 |      * @param mixed $tags
 69 |      */
 70 |     public function setTags($tags)
 71 |     {
 72 |         $this->tags = $tags;
 73 |     }
 74 | 
 75 |     /**
 76 |      * @return mixed
 77 |      */
 78 |     public function getFile()
 79 |     {
 80 |         return $this->file;
 81 |     }
 82 | 
 83 |     /**
 84 |      * @param mixed $file
 85 |      */
 86 |     public function setFile($file)
 87 |     {
 88 |         $this->file = $file;
 89 |     }
 90 | 
 91 |     /**
 92 |      * @return mixed
 93 |      */
 94 |     public function getScreenshotFolder()
 95 |     {
 96 |         return $this->screenshotFolder;
 97 |     }
 98 | 
 99 |     /**
100 |      * @param string $featureName
101 |      */
102 |     public function setScreenshotFolder($featureName)
103 |     {
104 |         $this->screenshotFolder = preg_replace('/\W/', '', $featureName);
105 |     }
106 | 
107 |     /**
108 |      * @return Scenario[]
109 |      */
110 |     public function getScenarios()
111 |     {
112 |         return $this->scenarios;
113 |     }
114 | 
115 |     /**
116 |      * @param Scenario[] $scenarios
117 |      */
118 |     public function setScenarios($scenarios)
119 |     {
120 |         $this->scenarios = $scenarios;
121 |     }
122 | 
123 |     /**
124 |      * @param $scenario Scenario
125 |      */
126 |     public function addScenario($scenario)
127 |     {
128 |         $scenario->setId($this->scenarioCounter);
129 |         ++$this->scenarioCounter;
130 |         $this->scenarios[] = $scenario;
131 |     }
132 | 
133 |     /**
134 |      * @return mixed
135 |      */
136 |     public function getFailedScenarios()
137 |     {
138 |         return $this->failedScenarios;
139 |     }
140 | 
141 |     /**
142 |      * @param mixed $failedScenarios
143 |      */
144 |     public function setFailedScenarios($failedScenarios)
145 |     {
146 |         $this->failedScenarios = $failedScenarios;
147 |     }
148 | 
149 |     public function addFailedScenario($number = 1)
150 |     {
151 |         $this->failedScenarios += $number;
152 |     }
153 | 
154 |     /**
155 |      * @return mixed
156 |      */
157 |     public function getPendingScenarios()
158 |     {
159 |         return $this->pendingScenarios;
160 |     }
161 | 
162 |     /**
163 |      * @param mixed $pendingScenarios
164 |      */
165 |     public function setPendingScenarios($pendingScenarios)
166 |     {
167 |         $this->pendingScenarios = $pendingScenarios;
168 |     }
169 | 
170 |     public function addPendingScenario($number = 1)
171 |     {
172 |         $this->pendingScenarios += $number;
173 |     }
174 | 
175 |     /**
176 |      * @return mixed
177 |      */
178 |     public function getPassedScenarios()
179 |     {
180 |         return $this->passedScenarios;
181 |     }
182 | 
183 |     /**
184 |      * @param mixed $passedScenarios
185 |      */
186 |     public function setPassedScenarios($passedScenarios)
187 |     {
188 |         $this->passedScenarios = $passedScenarios;
189 |     }
190 | 
191 |     public function addPassedScenario($number = 1)
192 |     {
193 |         $this->passedScenarios += $number;
194 |     }
195 | 
196 |     /**
197 |      * @return mixed
198 |      */
199 |     public function getId()
200 |     {
201 |         return $this->id;
202 |     }
203 | 
204 |     /**
205 |      * @param mixed $id
206 |      */
207 |     public function setId($id)
208 |     {
209 |         $this->id = $id;
210 |     }
211 | 
212 |     //</editor-fold>
213 | 
214 |     //<editor-fold desc="Function">
215 |     public function allPassed()
216 |     {
217 |         if (0 == $this->failedScenarios) {
218 |             return true;
219 |         }
220 | 
221 |         return false;
222 |     }
223 | 
224 |     public function getPassedClass()
225 |     {
226 |         if ($this->allPassed()) {
227 |             return 'passed';
228 |         }
229 | 
230 |         return 'failed';
231 |     }
232 | 
233 |     public function getPercentPassed()
234 |     {
235 |         return ($this->getPassedScenarios() / ($this->getTotalAmountOfScenarios())) * 100;
236 |     }
237 | 
238 |     public function getPercentPending()
239 |     {
240 |         return ($this->getPendingScenarios() / ($this->getTotalAmountOfScenarios())) * 100;
241 |     }
242 | 
243 |     public function getPercentFailed()
244 |     {
245 |         return ($this->getFailedScenarios() / ($this->getTotalAmountOfScenarios())) * 100;
246 |     }
247 | 
248 |     public function getTotalAmountOfScenarios()
249 |     {
250 |         return $this->getPassedScenarios() + $this->getPendingScenarios() + $this->getFailedScenarios();
251 |     }
252 | 
253 |     //</editor-fold>
254 | }
255 | 


--------------------------------------------------------------------------------
/src/Renderer/BaseRenderer.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Base renderer for Behat report.
  4 |  *
  5 |  * @author DaSayan <glennwall@free.fr>
  6 |  */
  7 | 
  8 | namespace emuse\BehatHTMLFormatter\Renderer;
  9 | 
 10 | class BaseRenderer
 11 | {
 12 |     /**
 13 |      * @var : List of the renderer names
 14 |      */
 15 |     private $nameList;
 16 | 
 17 |     /**
 18 |      * @var : List of the renderer objects
 19 |      */
 20 |     private $rendererList;
 21 | 
 22 |     /**
 23 |      * Constructor : load the renderers.
 24 |      *
 25 |      * @param string : list of the renderer
 26 |      * @param string : base_path
 27 |      */
 28 |     public function __construct($renderer, $base_path)
 29 |     {
 30 |         $rendererList = explode(',', $renderer);
 31 | 
 32 |         $this->nameList = array();
 33 |         $this->rendererList = array();
 34 | 
 35 |         //let's load the renderer dynamically
 36 |         foreach ($rendererList as $renderer) {
 37 |             $this->nameList[] = $renderer;
 38 |             if (in_array($renderer, array('Behat2', 'Twig', 'Minimal'))) {
 39 |                 $className = __NAMESPACE__.'\\'.$renderer.'Renderer';
 40 |             } else {
 41 |                 $className = $renderer;
 42 |             }
 43 |             $this->rendererList[$renderer] = new $className();
 44 |         }
 45 |     }
 46 | 
 47 |     /**
 48 |      * Return the list of the name of the renderers.
 49 |      *
 50 |      * @return array
 51 |      */
 52 |     public function getNameList()
 53 |     {
 54 |         return $this->nameList;
 55 |     }
 56 | 
 57 |     /**
 58 |      * Renders before an exercice.
 59 |      *
 60 |      * @param object : BehatHTMLFormatter object
 61 |      *
 62 |      * @return string : HTML generated
 63 |      */
 64 |     public function renderBeforeExercise($obj)
 65 |     {
 66 |         $print = array();
 67 |         foreach ($this->rendererList as $name => $renderer) {
 68 |             $print[$name] = $renderer->renderBeforeExercise($obj);
 69 |         }
 70 | 
 71 |         return $print;
 72 |     }
 73 | 
 74 |     /**
 75 |      * Renders after an exercice.
 76 |      *
 77 |      * @param object : BehatHTMLFormatter object
 78 |      *
 79 |      * @return string : HTML generated
 80 |      */
 81 |     public function renderAfterExercise($obj)
 82 |     {
 83 |         $print = array();
 84 |         foreach ($this->rendererList as $name => $renderer) {
 85 |             $print[$name] = $renderer->renderAfterExercise($obj);
 86 |         }
 87 | 
 88 |         return $print;
 89 |     }
 90 | 
 91 |     /**
 92 |      * Renders before a suite.
 93 |      *
 94 |      * @param object : BehatHTMLFormatter object
 95 |      *
 96 |      * @return string : HTML generated
 97 |      */
 98 |     public function renderBeforeSuite($obj)
 99 |     {
100 |         $print = array();
101 |         foreach ($this->rendererList as $name => $renderer) {
102 |             $print[$name] = $renderer->renderBeforeSuite($obj);
103 |         }
104 | 
105 |         return $print;
106 |     }
107 | 
108 |     /**
109 |      * Renders after a suite.
110 |      *
111 |      * @param object : BehatHTMLFormatter object
112 |      *
113 |      * @return string : HTML generated
114 |      */
115 |     public function renderAfterSuite($obj)
116 |     {
117 |         $print = array();
118 |         foreach ($this->rendererList as $name => $renderer) {
119 |             $print[$name] = $renderer->renderAfterSuite($obj);
120 |         }
121 | 
122 |         return $print;
123 |     }
124 | 
125 |     /**
126 |      * Renders before a feature.
127 |      *
128 |      * @param object : BehatHTMLFormatter object
129 |      *
130 |      * @return string : HTML generated
131 |      */
132 |     public function renderBeforeFeature($obj)
133 |     {
134 |         $print = array();
135 |         foreach ($this->rendererList as $name => $renderer) {
136 |             $print[$name] = $renderer->renderBeforeFeature($obj);
137 |         }
138 | 
139 |         return $print;
140 |     }
141 | 
142 |     /**
143 |      * Renders after a feature.
144 |      *
145 |      * @param object : BehatHTMLFormatter object
146 |      *
147 |      * @return string : HTML generated
148 |      */
149 |     public function renderAfterFeature($obj)
150 |     {
151 |         $print = array();
152 |         foreach ($this->rendererList as $name => $renderer) {
153 |             $print[$name] = $renderer->renderAfterFeature($obj);
154 |         }
155 | 
156 |         return $print;
157 |     }
158 | 
159 |     /**
160 |      * Renders before a scenario.
161 |      *
162 |      * @param object : BehatHTMLFormatter object
163 |      *
164 |      * @return string : HTML generated
165 |      */
166 |     public function renderBeforeScenario($obj)
167 |     {
168 |         $print = array();
169 |         foreach ($this->rendererList as $name => $renderer) {
170 |             $print[$name] = $renderer->renderBeforeScenario($obj);
171 |         }
172 | 
173 |         return $print;
174 |     }
175 | 
176 |     /**
177 |      * Renders after a scenario.
178 |      *
179 |      * @param object : BehatHTMLFormatter object
180 |      *
181 |      * @return string : HTML generated
182 |      */
183 |     public function renderAfterScenario($obj)
184 |     {
185 |         $print = array();
186 |         foreach ($this->rendererList as $name => $renderer) {
187 |             $print[$name] = $renderer->renderAfterScenario($obj);
188 |         }
189 | 
190 |         return $print;
191 |     }
192 | 
193 |     /**
194 |      * Renders before an outline.
195 |      *
196 |      * @param object : BehatHTMLFormatter object
197 |      *
198 |      * @return string : HTML generated
199 |      */
200 |     public function renderBeforeOutline($obj)
201 |     {
202 |         $print = array();
203 |         foreach ($this->rendererList as $name => $renderer) {
204 |             $print[$name] = $renderer->renderBeforeOutline($obj);
205 |         }
206 | 
207 |         return $print;
208 |     }
209 | 
210 |     /**
211 |      * Renders after an outline.
212 |      *
213 |      * @param object : BehatHTMLFormatter object
214 |      *
215 |      * @return string : HTML generated
216 |      */
217 |     public function renderAfterOutline($obj)
218 |     {
219 |         $print = array();
220 |         foreach ($this->rendererList as $name => $renderer) {
221 |             $print[$name] = $renderer->renderAfterOutline($obj);
222 |         }
223 | 
224 |         return $print;
225 |     }
226 | 
227 |     /**
228 |      * Renders before a step.
229 |      *
230 |      * @param object : BehatHTMLFormatter object
231 |      *
232 |      * @return string : HTML generated
233 |      */
234 |     public function renderBeforeStep($obj)
235 |     {
236 |         $print = array();
237 |         foreach ($this->rendererList as $name => $renderer) {
238 |             $print[$name] = $renderer->renderBeforeStep($obj);
239 |         }
240 | 
241 |         return $print;
242 |     }
243 | 
244 |     /**
245 |      * Renders after a step.
246 |      *
247 |      * @param object : BehatHTMLFormatter object
248 |      *
249 |      * @return string : HTML generated
250 |      */
251 |     public function renderAfterStep($obj)
252 |     {
253 |         $print = array();
254 |         foreach ($this->rendererList as $name => $renderer) {
255 |             $print[$name] = $renderer->renderAfterStep($obj);
256 |         }
257 | 
258 |         return $print;
259 |     }
260 | }
261 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | ## BehatHtmlFormatterPlugin
  2 | 
  3 | Behat 3 extension for generating HTML reports from your test results.
  4 | 
  5 | [![Latest Stable Version](https://poser.pugx.org/emuse/behat-html-formatter/v/stable)](https://packagist.org/packages/emuse/behat-html-formatter) [![Total Downloads](https://poser.pugx.org/emuse/behat-html-formatter/downloads)](https://packagist.org/packages/emuse/behat-html-formatter) [![Latest Unstable Version](https://poser.pugx.org/emuse/behat-html-formatter/v/unstable)](https://packagist.org/packages/emuse/behat-html-formatter) [![License](https://poser.pugx.org/emuse/behat-html-formatter/license)](https://packagist.org/packages/emuse/behat-html-formatter)
  6 | 
  7 | ### Twig report
  8 | 
  9 | ![Twig Screenshot](http://i.imgur.com/o0zCqiB.png)
 10 | 
 11 | ### Behat 2 report
 12 | 
 13 | ![Behat2 Screenshot](http://i57.tinypic.com/287g942.jpg)
 14 | 
 15 | 
 16 | ## How?
 17 | 
 18 | * The tool can be installed easily with composer.
 19 | * Defining the formatter in the `behat.yml` file
 20 | * Modifying the settings in the `behat.yml`file
 21 | 
 22 | ## Installation
 23 | 
 24 | ### Prerequisites
 25 | 
 26 | This extension requires:
 27 | 
 28 | * PHP 5.3.x or higher
 29 | * Behat 3.x or higher
 30 | 
 31 | ### Through composer
 32 | 
 33 | The easiest way to keep your suite updated is to use [Composer](http://getcomposer.org>):
 34 | 
 35 | #### Install with composer:
 36 | 
 37 | ```bash
 38 | $ composer require --dev emuse/behat-html-formatter
 39 | ```
 40 | 
 41 | #### Install using `composer.json`
 42 | 
 43 | Add BehatHtmlFormatterPlugin to the list of dependencies inside your `composer.json`.
 44 | 
 45 | ```json
 46 | {
 47 |     "require": {
 48 |         "behat/behat": "3.*@stable",
 49 |         "emuse/behat-html-formatter": "0.1.*",
 50 |     },
 51 |     "minimum-stability": "dev",
 52 |     "config": {
 53 |         "bin-dir": "bin/"
 54 |     }
 55 | }
 56 | ```
 57 | 
 58 | Then simply install it with composer:
 59 | 
 60 | ```bash
 61 | $ composer install --dev --prefer-dist
 62 | ```
 63 | 
 64 | You can read more about Composer on its [official webpage](http://getcomposer.org).
 65 | 
 66 | ## Basic usage
 67 | 
 68 | Activate the extension by specifying its class in your `behat.yml`:
 69 | 
 70 | ```json
 71 | # behat.yml
 72 | default:
 73 |   suites:
 74 |     default:
 75 |        contexts:
 76 |           - emuse\BehatHTMLFormatter\Context\ScreenshotContext:
 77 |                screenshotDir: build/html/behat/assets/screenshots
 78 |     ... # All your awesome suites come here
 79 |   formatters:
 80 |     html:
 81 |       output_path: %paths.base%/build/html/behat
 82 | 
 83 |   extensions:
 84 |     emuse\BehatHTMLFormatter\BehatHTMLFormatterExtension:
 85 |       name: html
 86 |       renderer: Twig,Behat2
 87 |       file_name: index
 88 |       print_args: true
 89 |       print_outp: true
 90 |       loop_break: true
 91 | ```
 92 | 
 93 | ### Command line options
 94 | 
 95 | Add the following to your behat command to print a report:
 96 | 
 97 | `behat --format html --out MYDIRECTORY`
 98 | 
 99 | Setting the format to html will output the various reports that you configure below (Behat2, Twig, Minimal, etc.)
100 | 
101 | You also need to specify the output directory for the reports as MYDIRECTORY.
102 | 
103 | ## Configuration
104 | 
105 | ### Formatter configuration
106 | 
107 | * `output_path` - The location where Behat will save the HTML reports. Use `%paths.base%` to build the full path.
108 | 
109 | ### Extension configuration
110 | 
111 | * `renderer` - The engine that Behat will use for rendering, thus the types of report format Behat should output (multiple report formats are allowed, separate them by commas). Allowed values are:
112 |  * *Behat2* for generating HTML reports like they were generated in Behat 2.
113 |  * *Twig* A new and more modern format based on Twig.
114 |  * *Minimal* An ultra minimal HTML output.
115 | * `file_name` - (Optional) Behat will use a fixed filename and overwrite the same file after each build. By default, Behat will create a new HTML file using a random name (*"renderer name"*_*"date hour"*).
116 | * `print_args` - (Optional) If set to `true`, Behat will add all arguments for each step to the report. (E.g. Tables).
117 | * `print_outp` - (Optional) If set to `true`, Behat will add the output of each step to the report. (E.g. Exceptions).
118 | * `loop_break` - (Optional) If set to `true`, Behat will add a separating break line after each execution when printing Scenario Outlines.
119 | 
120 | ## Screenshot
121 | 
122 | The facility exists to embed a screenshot into test failures.
123 | 
124 | Currently png is the only supported image format.
125 | 
126 | In order to embed a screenshot, you will need to take a screenshot using your favourite webdriver and store it in the following filepath format:
127 | 
128 | results/html/assets/screenshots/{{feature_name}}/{{scenario_name}}.png
129 | 
130 | The feature_name and scenario_name variables will need to be the relevant item names without spaces.
131 | 
132 | Below is an example of FeatureContext methods which will produce an image file in the above format:
133 | 
134 | ```php
135 | 
136 |         /**
137 |          * @BeforeScenario
138 |          *
139 |          * @param BeforeScenarioScope $scope
140 |          *
141 |          */
142 |         public function setUpTestEnvironment($scope)
143 |         {
144 |             $this->currentScenario = $scope->getScenario();
145 |         }
146 | 
147 |         /**
148 |          * @AfterStep
149 |          *
150 |          * @param AfterStepScope $scope
151 |          */
152 |         public function afterStep($scope)
153 |         {
154 |             //if test has failed, and is not an api test, get screenshot
155 |             if(!$scope->getTestResult()->isPassed())
156 |             {
157 |                 //create filename string
158 | 
159 |                $featureFolder = preg_replace('/\W/', '', $scope->getFeature()->getTitle());
160 |                   
161 |                               $scenarioName = $this->currentScenario->getTitle();
162 |                               $fileName = preg_replace('/\W/', '', $scenarioName) . '.png';
163 | 
164 |                 //create screenshots directory if it doesn't exist
165 |                 if (!file_exists('results/html/assets/screenshots/' . $featureFolder)) {
166 |                     mkdir('results/html/assets/screenshots/' . $featureFolder);
167 |                 }
168 | 
169 |                 //take screenshot and save as the previously defined filename
170 |                 $this->driver->takeScreenshot('results/html/assets/screenshots/' . $featureFolder . '/' . $fileName);
171 |                 // For Selenium2 Driver you can use:
172 |                 // file_put_contents('results/html/assets/screenshots/' . $featureFolder . '/' . $fileName, $this->getSession()->getDriver()->getScreenshot());
173 |             }
174 |         }
175 | 
176 | ```
177 | 
178 | Note that the currentScenario variable will need to be at class level and generated in the @BeforeScenario method as Behat does not currently support obtaining the current Scenario in the @AfterStep method, where the screenshot is generated
179 | 
180 | ## Issue Submission
181 | 
182 | When you need additional support or you discover something *strange*, feel free to [Create a new issue](https://github.com/dutchiexl/BehatHtmlFormatterPlugin/issues/new).
183 | 
184 | ## License and Authors
185 | 
186 | Authors: https://github.com/dutchiexl/BehatHtmlFormatterPlugin/contributors
187 | 
188 | 
189 | 


--------------------------------------------------------------------------------
/src/Printer/FileOutputPrinter.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Very simple FileOutputPrinter for BehatHTMLFormatter.
  4 |  *
  5 |  * @author David Raison <david@tentwentyfour.lu>
  6 |  */
  7 | 
  8 | namespace emuse\BehatHTMLFormatter\Printer;
  9 | 
 10 | use Behat\Testwork\Output\Exception\BadOutputPathException;
 11 | use Behat\Testwork\Output\Printer\OutputPrinter as PrinterInterface;
 12 | 
 13 | class FileOutputPrinter implements PrinterInterface
 14 | {
 15 |     /**
 16 |      * @param  $outputPath where to save the generated report file
 17 |      */
 18 |     private $outputPath;
 19 | 
 20 |     /**
 21 |      * @param  $base_path Behat base path
 22 |      */
 23 |     private $base_path;
 24 | 
 25 |     /**
 26 |      * @param  $rendererFiles List of the filenames for the renderers
 27 |      */
 28 |     private $rendererFiles;
 29 | 
 30 |     /**
 31 |      * @param $rendererList
 32 |      * @param $filename
 33 |      * @param $base_path
 34 |      */
 35 |     public function __construct($rendererList, $filename, $base_path)
 36 |     {
 37 |         //let's generate the filenames for the renderers
 38 |         $this->rendererFiles = array();
 39 |         foreach ($rendererList as $renderer) {
 40 |             if ('generated' == $filename) {
 41 |                 $date = date('YmdHis');
 42 |                 $this->rendererFiles[$renderer] = $renderer.'_'.$date;
 43 |             } else {
 44 |                 $this->rendererFiles[$renderer] = $filename;
 45 |             }
 46 |         }
 47 | 
 48 |         $this->base_path = $base_path;
 49 |     }
 50 | 
 51 |     /**
 52 |      * Verify that the specified output path exists or can be created,
 53 |      * then sets the output path.
 54 |      *
 55 |      * @param string $path Output path relative to %paths.base%
 56 |      */
 57 |     public function setOutputPath($path)
 58 |     {
 59 |         $outpath = $path;
 60 |         if (!file_exists($outpath)) {
 61 |             if (!mkdir($outpath, 0755, true)) {
 62 |                 throw new BadOutputPathException(
 63 |           sprintf(
 64 |             'Output path %s does not exist and could not be created!',
 65 |             $outpath
 66 |           ),
 67 |           $outpath
 68 |         );
 69 |             }
 70 |         } else {
 71 |             if (!is_dir(realpath($outpath))) {
 72 |                 throw new BadOutputPathException(
 73 |           sprintf(
 74 |             'The argument to `output` is expected to the a directory, but got %s!',
 75 |             $outpath
 76 |           ),
 77 |           $outpath
 78 |         );
 79 |             }
 80 |         }
 81 |         $this->outputPath = $outpath;
 82 |     }
 83 | 
 84 |     /**
 85 |      * Returns output path.
 86 |      *
 87 |      * @return string output path
 88 |      */
 89 |     public function getOutputPath()
 90 |     {
 91 |         return $this->outputPath;
 92 |     }
 93 | 
 94 |     /**
 95 |      * Sets output styles.
 96 |      *
 97 |      * @param array $styles
 98 |      */
 99 |     public function setOutputStyles(array $styles)
100 |     {
101 |     }
102 | 
103 |     /**
104 |      * Returns output styles.
105 |      *
106 |      * @return array
107 |      */
108 |     public function getOutputStyles()
109 |     {
110 |     }
111 | 
112 |     /**
113 |      * Forces output to be decorated.
114 |      *
115 |      * @param bool $decorated
116 |      */
117 |     public function setOutputDecorated($decorated)
118 |     {
119 |     }
120 | 
121 |     /**
122 |      * Returns output decoration status.
123 |      *
124 |      * @return null|bool
125 |      */
126 |     public function isOutputDecorated()
127 |     {
128 |         return true;
129 |     }
130 | 
131 |     /**
132 |      * Sets output verbosity level.
133 |      *
134 |      * @param int $level
135 |      */
136 |     public function setOutputVerbosity($level)
137 |     {
138 |     }
139 | 
140 |     /**
141 |      * Returns output verbosity level.
142 |      *
143 |      * @return int
144 |      */
145 |     public function getOutputVerbosity()
146 |     {
147 |     }
148 | 
149 |     /**
150 |      * Writes message(s) to output console.
151 |      *
152 |      * @param string|array $messages message or array of messages
153 |      */
154 |     public function write($messages = array())
155 |     {
156 |         //Write it for each message = each renderer
157 |         foreach ($messages as $key => $message) {
158 |             $file = $this->outputPath.DIRECTORY_SEPARATOR.$this->rendererFiles[$key].'.html';
159 |             file_put_contents($file, $message);
160 |             $this->copyAssets($key);
161 |         }
162 |     }
163 | 
164 |     /**
165 |      * Writes newlined message(s) to output console.
166 |      *
167 |      * @param string|array $messages message or array of messages
168 |      */
169 |     public function writeln($messages = array())
170 |     {
171 |         //Write it for each message = each renderer
172 |         foreach ($messages as $key => $message) {
173 |             $file = $this->outputPath.DIRECTORY_SEPARATOR.$this->rendererFiles[$key].'.html';
174 |             file_put_contents($file, $message, FILE_APPEND);
175 |         }
176 |     }
177 | 
178 |     /**
179 |      * Writes  message(s) at start of the output console.
180 |      *
181 |      * @param string|array $messages message or array of messages
182 |      */
183 |     public function writeBeginning($messages = array())
184 |     {
185 |         //Write it for each message = each renderer
186 |         foreach ($messages as $key => $message) {
187 |             $file = $this->outputPath.DIRECTORY_SEPARATOR.$this->rendererFiles[$key].'.html';
188 |             $fileContents = file_get_contents($file);
189 |             file_put_contents($file, $message.$fileContents);
190 |         }
191 |     }
192 | 
193 |     /**
194 |      * Copies the assets folder to the report destination.
195 |      *
196 |      * @param string : the renderer
197 |      */
198 |     public function copyAssets($renderer)
199 |     {
200 |         // If the assets folder doesn' exist in the output path for this renderer, copy it
201 |         $source = realpath(dirname(__FILE__));
202 |         $assets_source = realpath($source.'/../../assets/'.$renderer);
203 |         if (false === $assets_source) {
204 |             //There is no assets to copy for this renderer
205 |             return;
206 |         }
207 | 
208 |         //first create the assets dir
209 |         $destination = $this->outputPath.DIRECTORY_SEPARATOR.'assets';
210 |         @mkdir($destination);
211 | 
212 |         $this->recurse_copy($assets_source, $destination.DIRECTORY_SEPARATOR.$renderer);
213 |     }
214 | 
215 |     /**
216 |      * Recursivly copy a path.
217 |      *
218 |      * @param $src
219 |      * @param $dst
220 |      */
221 |     private function recurse_copy($src, $dst)
222 |     {
223 |         $dir = opendir($src);
224 |         @mkdir($dst);
225 |         while (false !== ($file = readdir($dir))) {
226 |             if (('.' != $file) && ('..' != $file)) {
227 |                 if (is_dir($src.'/'.$file)) {
228 |                     $this->recurse_copy($src.'/'.$file, $dst.'/'.$file);
229 |                 } else {
230 |                     copy($src.'/'.$file, $dst.'/'.$file);
231 |                 }
232 |             }
233 |         }
234 |         closedir($dir);
235 |     }
236 | 
237 |     /**
238 |      * Clear output console, so on next write formatter will need to init (create) it again.
239 |      */
240 |     public function flush()
241 |     {
242 |     }
243 | }
244 | 


--------------------------------------------------------------------------------
/features/bootstrap/FeatureContext.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /*
  4 |  * This file is part of the Behat.
  5 |  * (c) Konstantin Kudryashov <ever.zet@gmail.com>
  6 |  *
  7 |  * For the full copyright and license information, please view the LICENSE
  8 |  * file that was distributed with this source code.
  9 |  */
 10 | 
 11 | use Behat\Behat\Tester\Exception\PendingException;
 12 | use Behat\Behat\Context\Context;
 13 | use Behat\Gherkin\Node\PyStringNode;
 14 | use Symfony\Component\Process\PhpExecutableFinder;
 15 | use Symfony\Component\Process\Process;
 16 | use Behat\Behat\Context\SnippetAcceptingContext;
 17 | 
 18 | /**
 19 |  * Behat test suite context.
 20 |  *
 21 |  * @author Konstantin Kudryashov <ever.zet@gmail.com>
 22 |  */
 23 | class FeatureContext implements Context, SnippetAcceptingContext
 24 | {
 25 |     /**
 26 |      * @var string
 27 |      */
 28 |     private $phpBin;
 29 |     /**
 30 |      * @var Process
 31 |      */
 32 |     private $process;
 33 |     /**
 34 |      * @var string
 35 |      */
 36 |     private $workingDir;
 37 |     /**
 38 |      * @var string
 39 |      */
 40 |     private $output;
 41 |     /**
 42 |      * @var string
 43 |      */
 44 |     private $reportDir;
 45 | 
 46 |     /**
 47 |      * Cleans test folders in the temporary directory.
 48 |      *
 49 |      * @BeforeSuite
 50 |      * @After Suite
 51 |      */
 52 |     public static function cleanTestFolders()
 53 |     {
 54 |         if (is_dir($dir = sys_get_temp_dir() . DIRECTORY_SEPARATOR . 'behat')) {
 55 |             self::clearDirectory($dir);
 56 |         }
 57 |     }
 58 | 
 59 |     /**
 60 |      * @AfterScenario
 61 |      */
 62 |     public function copyResultingTemplateToProjectRoot()
 63 |     {
 64 |         shell_exec('rm -rf '.__DIR__.'/../../build');
 65 |         mkdir(__DIR__.'/../../build');
 66 |         shell_exec('cp -R '.$this->workingDir.'/build/* '.__DIR__.'/../../build');
 67 |     }
 68 | 
 69 |     /**
 70 |      * Prepares test folders in the temporary directory.
 71 |      *
 72 |      * @BeforeScenario
 73 |      */
 74 |     public function prepareTestFolders()
 75 |     {
 76 |         $dir = sys_get_temp_dir() . DIRECTORY_SEPARATOR . 'behat' . DIRECTORY_SEPARATOR .
 77 |             md5(microtime() * rand(0, 10000));
 78 | 
 79 |         mkdir($dir . '/features/bootstrap/i18n', 0777, true);
 80 |         mkdir($dir . '/junit');
 81 | 
 82 |         $phpFinder = new PhpExecutableFinder();
 83 |         if (false === $php = $phpFinder->find()) {
 84 |             throw new \RuntimeException('Unable to find the PHP executable.');
 85 |         }
 86 |         $this->workingDir = $dir;
 87 |         $this->phpBin = $php;
 88 |         $this->process = new Process(null);
 89 |         $this->reportDir = $this->workingDir . '/build/';
 90 |     }
 91 | 
 92 |     /**
 93 |      * Creates a file with specified name and context in current workdir.
 94 |      *
 95 |      * @Given /^(?:there is )?a file named "([^"]*)" with:$/
 96 |      *
 97 |      * @param string       $filename name of the file (relative path)
 98 |      * @param PyStringNode $content  PyString string instance
 99 |      */
100 |     public function aFileNamedWith($filename, PyStringNode $content)
101 |     {
102 |         $content = strtr((string) $content, array("'''" => '"""'));
103 |         $this->createFile($this->workingDir . '/' . $filename, $content);
104 |     }
105 | 
106 |     /**
107 |      * Moves user to the specified path.
108 |      *
109 |      * @Given /^I am in the "([^"]*)" path$/
110 |      *
111 |      * @param string $path
112 |      */
113 |     public function iAmInThePath($path)
114 |     {
115 |         $this->moveToNewPath($path);
116 |     }
117 | 
118 |     /**
119 |      * Checks whether a file at provided path exists.
120 |      *
121 |      * @Given /^file "([^"]*)" should exist$/
122 |      *
123 |      * @param   string $path
124 |      */
125 |     public function fileShouldExist($path)
126 |     {
127 |         PHPUnit_Framework_Assert::assertFileExists($this->workingDir . DIRECTORY_SEPARATOR . $path);
128 |     }
129 | 
130 |     /**
131 |      * Sets specified ENV variable
132 |      *
133 |      * @When /^"BEHAT_PARAMS" environment variable is set to:$/
134 |      *
135 |      * @param PyStringNode $value
136 |      */
137 |     public function iSetEnvironmentVariable(PyStringNode $value)
138 |     {
139 |         $this->process->setEnv(array('BEHAT_PARAMS' => (string) $value));
140 |     }
141 | 
142 |     /**
143 |      * Runs behat command with provided parameters
144 |      *
145 |      * @When /^I run "behat(?: ((?:\"|[^"])*))?"$/
146 |      *
147 |      * @param string $argumentsString
148 |      */
149 |     public function iRunBehat($argumentsString = '')
150 |     {
151 |         $argumentsString = strtr($argumentsString, array('\'' => '"'));
152 | 
153 |         $this->process->setWorkingDirectory($this->workingDir);
154 |         $this->process->setCommandLine(
155 |             sprintf(
156 |                 '%s %s %s %s',
157 |                 $this->phpBin,
158 |                 escapeshellarg(BEHAT_BIN_PATH),
159 |                 $argumentsString,
160 |                 strtr('--format-settings=\'{"timer": false}\'', array('\'' => '"', '"' => '\"'))
161 |             )
162 |         );
163 | 
164 |         // Don't reset the LANG variable on HHVM, because it breaks HHVM itself
165 |         if (!defined('HHVM_VERSION')) {
166 |             $env = $this->process->getEnv();
167 |             $env['LANG'] = 'en'; // Ensures that the default language is en, whatever the OS locale is.
168 |             $this->process->setEnv($env);
169 |         }
170 | 
171 |         $this->process->run();
172 | 
173 |         $this->output = $this->process->getOutput();
174 |     }
175 | 
176 |     /**
177 |      * Checks whether previously ran command passes|fails with provided output.
178 |      *
179 |      * @Then /^it should (fail|pass) with:$/
180 |      *
181 |      * @param string       $success "fail" or "pass"
182 |      * @param PyStringNode $text    PyString text instance
183 |      */
184 |     public function itShouldPassWith($success, PyStringNode $text)
185 |     {
186 |         $this->itShouldFail($success);
187 |         $this->theOutputShouldContain($text);
188 |     }
189 | 
190 |     /**
191 |      * Checks whether previously runned command passes|failes with no output.
192 |      *
193 |      * @Then /^it should (fail|pass) with no output$/
194 |      *
195 |      * @param string $success "fail" or "pass"
196 |      */
197 |     public function itShouldPassWithNoOutput($success)
198 |     {
199 |         $this->itShouldFail($success);
200 |         PHPUnit_Framework_Assert::assertEmpty($this->getOutput());
201 |     }
202 | 
203 |     /**
204 |      * Checks whether specified file exists and contains specified string.
205 |      *
206 |      * @Then /^"([^"]*)" file should contain:$/
207 |      *
208 |      * @param string       $path file path
209 |      * @param PyStringNode $text file content
210 |      */
211 |     public function fileShouldContain($path, PyStringNode $text)
212 |     {
213 |         $path = $this->workingDir . '/' . $path;
214 |         PHPUnit_Framework_Assert::assertFileExists($path);
215 | 
216 |         $fileContent = trim(file_get_contents($path));
217 |         // Normalize the line endings in the output
218 |         if ("\n" !== PHP_EOL) {
219 |             $fileContent = str_replace(PHP_EOL, "\n", $fileContent);
220 |         }
221 | 
222 |         PHPUnit_Framework_Assert::assertEquals($this->getExpectedOutput($text), $fileContent);
223 |     }
224 | 
225 |     /**
226 |      * Checks whether specified content and structure of the xml is correct without worrying about layout.
227 |      *
228 |      * @Then /^"([^"]*)" file xml should be like:$/
229 |      *
230 |      * @param string       $path file path
231 |      * @param PyStringNode $text file content
232 |      */
233 |     public function fileXmlShouldBeLike($path, PyStringNode $text)
234 |     {
235 |         $path = $this->workingDir . '/' . $path;
236 |         PHPUnit_Framework_Assert::assertFileExists($path);
237 | 
238 |         $fileContent = trim(file_get_contents($path));
239 | 
240 |         $dom = new DOMDocument();
241 |         $dom->loadXML($text);
242 |         $dom->formatOutput = true;
243 | 
244 |         PHPUnit_Framework_Assert::assertEquals(trim($dom->saveXML(null, LIBXML_NOEMPTYTAG)), $fileContent);
245 |     }
246 | 
247 | 
248 |     /**
249 |      * Checks whether last command output contains provided string.
250 |      *
251 |      * @Then the output should contain:
252 |      *
253 |      * @param PyStringNode $text PyString text instance
254 |      */
255 |     public function theOutputShouldContain(PyStringNode $text)
256 |     {
257 |         PHPUnit_Framework_Assert::assertContains($this->getExpectedOutput($text), $this->getOutput());
258 |     }
259 | 
260 |     private function getExpectedOutput(PyStringNode $expectedText)
261 |     {
262 |         $text = strtr($expectedText, array('\'\'\'' => '"""', '%%TMP_DIR%%' => sys_get_temp_dir() . DIRECTORY_SEPARATOR));
263 | 
264 |         // windows path fix
265 |         if ('/' !== DIRECTORY_SEPARATOR) {
266 |             $text = preg_replace_callback(
267 |                 '/[ "]features\/[^\n "]+/', function ($matches) {
268 |                     return str_replace('/', DIRECTORY_SEPARATOR, $matches[0]);
269 |                 }, $text
270 |             );
271 |             $text = preg_replace_callback(
272 |                 '/\<span class\="path"\>features\/[^\<]+/', function ($matches) {
273 |                     return str_replace('/', DIRECTORY_SEPARATOR, $matches[0]);
274 |                 }, $text
275 |             );
276 |             $text = preg_replace_callback(
277 |                 '/\+[fd] [^ ]+/', function ($matches) {
278 |                     return str_replace('/', DIRECTORY_SEPARATOR, $matches[0]);
279 |                 }, $text
280 |             );
281 |         }
282 | 
283 |         return $text;
284 |     }
285 | 
286 |     /**
287 |      * Checks whether previously ran command failed|passed.
288 |      *
289 |      * @Then /^it should (fail|pass)$/
290 |      *
291 |      * @param string $success "fail" or "pass"
292 |      */
293 |     public function itShouldFail($success)
294 |     {
295 |         if ('fail' === $success) {
296 |             if (0 === $this->getExitCode()) {
297 |                 echo 'Actual output:' . PHP_EOL . PHP_EOL . $this->getOutput();
298 |             }
299 | 
300 |             PHPUnit_Framework_Assert::assertNotEquals(0, $this->getExitCode());
301 |         } else {
302 |             if (0 !== $this->getExitCode()) {
303 |                 echo 'Actual output:' . PHP_EOL . PHP_EOL . $this->getOutput();
304 |             }
305 | 
306 |             PHPUnit_Framework_Assert::assertEquals(0, $this->getExitCode());
307 |         }
308 |     }
309 | 
310 |     /**
311 |      * Checks whether the file is valid according to an XML schema.
312 |      *
313 |      * @Then /^the file "([^"]+)" should be a valid document according to "([^"]+)"$/
314 |      *
315 |      * @param string $xmlFile
316 |      * @param string $schemaPath relative to features/bootstrap/schema
317 |      */
318 |     public function xmlShouldBeValid($xmlFile, $schemaPath)
319 |     {
320 |         $dom = new DomDocument();
321 |         $dom->load($this->workingDir . '/' . $xmlFile);
322 | 
323 |         $dom->schemaValidate(__DIR__ . '/schema/' . $schemaPath);
324 |     }
325 | 
326 |     /**
327 |      * @Then process output should be:
328 |      *
329 |      * @param PyStringNode $expected
330 |      */
331 |     public function processOutputShouldBe(PyStringNode $expected)
332 |     {
333 |         PHPUnit_Framework_Assert::assertEquals($expected->getRaw(), $this->output);
334 |     }
335 | 
336 | 
337 |     /**
338 |      * @Given report file should exists
339 |      */
340 |     public function reportFileShouldExists()
341 |     {
342 |         $files = array(
343 |             $this->reportDir . 'Index.html',
344 |             $this->reportDir . 'assets/Twig/css/style.css',
345 |             $this->reportDir . 'assets/Twig/css/style.less',
346 |         );
347 | 
348 |         foreach ($files as $file) {
349 |             PHPUnit_Framework_Assert::assertFileExists($file);
350 |         }
351 |     }
352 | 
353 |     /**
354 |      * @Given report file should contain:
355 |      *
356 |      * @param PyStringNode $string
357 |      */
358 |     public function reportFileShouldContain(PyStringNode $string)
359 |     {
360 |         $index = $this->reportDir . 'Index.html';
361 | 
362 |         PHPUnit_Framework_Assert::assertContains($string->getRaw(), file_get_contents($index));
363 |     }
364 | 
365 |     private function getExitCode()
366 |     {
367 |         return $this->process->getExitCode();
368 |     }
369 | 
370 |     private function getOutput()
371 |     {
372 |         $output = $this->process->getErrorOutput() . $this->process->getOutput();
373 | 
374 |         // Normalize the line endings in the output
375 |         if ("\n" !== PHP_EOL) {
376 |             $output = str_replace(PHP_EOL, "\n", $output);
377 |         }
378 | 
379 |         // Replace wrong warning message of HHVM
380 |         $output = str_replace('Notice: Undefined index: ', 'Notice: Undefined offset: ', $output);
381 | 
382 |         return trim(preg_replace("/ +$/m", '', $output));
383 |     }
384 | 
385 |     private function createFile($filename, $content)
386 |     {
387 |         $path = dirname($filename);
388 |         $this->createDirectory($path);
389 | 
390 |         file_put_contents($filename, $content);
391 |     }
392 | 
393 |     private function createDirectory($path)
394 |     {
395 |         if (!is_dir($path)) {
396 |             mkdir($path, 0777, true);
397 |         }
398 |     }
399 | 
400 |     private function moveToNewPath($path)
401 |     {
402 |         $newWorkingDir = $this->workingDir . '/' . $path;
403 |         if (!file_exists($newWorkingDir)) {
404 |             mkdir($newWorkingDir, 0777, true);
405 |         }
406 | 
407 |         $this->workingDir = $newWorkingDir;
408 |     }
409 | 
410 |     private static function clearDirectory($path)
411 |     {
412 |         $files = scandir($path);
413 |         array_shift($files);
414 |         array_shift($files);
415 | 
416 |         foreach ($files as $file) {
417 |             $file = $path . DIRECTORY_SEPARATOR . $file;
418 |             if (is_dir($file)) {
419 |                 self::clearDirectory($file);
420 |             } else {
421 |                 unlink($file);
422 |             }
423 |         }
424 | 
425 |         rmdir($path);
426 |     }
427 | }
428 | 


--------------------------------------------------------------------------------
/templates/index.html.twig:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en">
  3 | <head>
  4 |     <meta charset="utf-8">
  5 |     <meta http-equiv="X-UA-Compatible" content="IE=edge">
  6 |     <meta name="viewport" content="width=device-width, initial-scale=1">
  7 |     <title>Behat Tests</title>
  8 | 
  9 |     <!-- Bootstrap -->
 10 |     <!-- Latest compiled and minified CSS -->
 11 |     <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.1/css/bootstrap.min.css">
 12 | 
 13 |     <!-- Optional theme -->
 14 |     <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.1/css/bootstrap-theme.min.css">
 15 | 
 16 |     <!-- Optional theme -->
 17 |     <link rel="stylesheet" href="assets/Twig/css/style.css">
 18 | 
 19 |     <!-- HTML5 shim and Respond.js for IE8 support of HTML5 elements and media queries -->
 20 |     <!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
 21 |     <!--[if lt IE 9]>
 22 |     <script src="https://oss.maxcdn.com/html5shiv/3.7.2/html5shiv.min.js"></script>
 23 |     <script src="https://oss.maxcdn.com/respond/1.4.2/respond.min.js"></script>
 24 |     <![endif]-->
 25 | 
 26 |     <script src="https://cdnjs.cloudflare.com/ajax/libs/Chart.js/2.7.3/Chart.min.js"></script>
 27 | </head>
 28 | <body role="document" style="margin-top: 70px;">
 29 | 
 30 | <!-- Fixed navbar -->
 31 | <nav class="navbar navbar-inverse navbar-fixed-top">
 32 |     <div class="container">
 33 |         <div class="navbar-header">
 34 |             <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar"
 35 |                     aria-expanded="false" aria-controls="navbar">
 36 |                 <span class="sr-only">Toggle navigation</span>
 37 |                 <span class="icon-bar"></span>
 38 |                 <span class="icon-bar"></span>
 39 |                 <span class="icon-bar"></span>
 40 |             </button>
 41 |             <a class="navbar-brand" href="#">Automated test report - {{ "now"|date('d/m/Y H:i:s') }}</a>
 42 |         </div>
 43 |         <div id="navbar" class="navbar-collapse collapse">
 44 |             <ul class="nav navbar-nav">
 45 |                 {#<li class="active"><a href="#">Home</a></li>#}
 46 |             </ul>
 47 |         </div>
 48 |         <!--/.nav-collapse -->
 49 |     </div>
 50 | </nav>
 51 | 
 52 | <div class="container theme-showcase" role="main">
 53 |     <div class="row charts">
 54 |         <div class="col-sm-4">
 55 |             <div class="canvas-holder">
 56 |                 <canvas id="chart-features" width="300" height="300"/>
 57 |             </div>
 58 |             <div class="chart-summary title">
 59 |                 {{ (failedFeatures|length) + (passedFeatures|length) }} Features:
 60 |             </div>
 61 |             <div class="chart-summary failed">{{ failedFeatures|length }} failed</div>
 62 |         </div>
 63 |         <div class="col-sm-4">
 64 |             <div class="canvas-holder">
 65 |                 <canvas id="chart-scenarios" width="300" height="300"/>
 66 |             </div>
 67 |             <div class="chart-summary title">
 68 |                 {{ (failedScenarios|length) + (passedScenarios|length) + (skippedScenarios|length) + (undefinedScenarios|length) }}
 69 |                 Scenarios:
 70 |             </div>
 71 |             <div class="chart-summary failed">{{ failedScenarios|length }} failed</div>
 72 |             <div class="chart-summary undefined">{{ undefinedScenarios|length }} undefined</div>
 73 |             <div class="chart-summary skipped">{{ skippedScenarios|length }} skipped</div>
 74 |         </div>
 75 |         <div class="col-sm-4">
 76 |             <div class="canvas-holder">
 77 |                 <canvas id="chart-steps" width="300" height="300"/>
 78 |             </div>
 79 |             <div class="chart-summary title">
 80 |                 {{ (failedSteps|length) + (passedSteps|length) + (skippedSteps|length) + (undefinedSteps|length) }}
 81 |                 Steps:
 82 |             </div>
 83 |             <div class="chart-summary failed">{{ failedSteps|length }} failed</div>
 84 |             <div class="chart-summary undefined">{{ undefinedSteps|length }} undefined</div>
 85 |             <div class="chart-summary skipped">{{ skippedSteps|length }} skipped</div>
 86 |         </div>
 87 |     </div>
 88 |     <hr>
 89 |     <div class="filters">
 90 |         <a class="btn btn-default" id="feature-all-filter" role="button">All</a>
 91 |         <a class="btn btn-success" id="feature-passed-filter" role="button">Passed</a>
 92 |         <a class="btn btn-danger" id="feature-failed-filter" role="button">Failed</a>
 93 |     </div>
 94 |     <hr>
 95 |     <div id="feature-overview">
 96 |         {% for suite in suites %}
 97 |             <div class="row">
 98 |                 <div class="col-sm-12">
 99 |                     <h2>Suite: {{ suite.name }}</h2>
100 | 
101 |                     <div class="row">
102 |                         {% for feature in suite.features %}
103 |                             <div class="col-sm-4 feature" data-id="feature-{{ feature.id }}">
104 |                                 <div class="card {{ feature.getPassedClass }}">
105 |                                     <div class="header">
106 |                                         <h2>Feature: {{ feature.name }}</h2>
107 |                                     </div>
108 |                                     <div class="info">
109 |                                         <p>{{ feature.description|raw|nl2br }}</p>
110 |                                     </div>
111 |                                     <div class="footer">
112 |                                         <div class="tags">
113 |                                             {% for tag in feature.tags %}
114 |                                                 <span class="badge">{{ tag }}</span>
115 |                                             {% endfor %}
116 |                                         </div>
117 |                                         {% if feature.getTotalAmountOfScenarios > 0 %}
118 |                                             <div class="progress">
119 |                                                 <div class="progress-bar progress-bar-green" role="progressbar"
120 |                                                      style="width: {{ feature.getPercentPassed }}%">
121 |                                                     <span class="sr-only">40% Complete (success)</span>
122 |                                                 </div>
123 |                                                 <div class="progress-bar progress-bar-warning" role="progressbar"
124 |                                                      style="width: {{ feature.getPercentPending }}%">
125 |                                                     <span class="sr-only">40% Complete (success)</span>
126 |                                                 </div>
127 |                                                 <div class="progress-bar progress-bar-red" role="progressbar"
128 |                                                      style="width: {{ feature.getPercentFailed }}%">
129 |                                                     <span class="sr-only">40% Complete (success)</span>
130 |                                                 </div>
131 |                                             </div>
132 |                                         {% endif %}
133 |                                     </div>
134 |                                 </div>
135 |                             </div>
136 |                         {% endfor %}
137 |                     </div>
138 |                 </div>
139 |             </div>
140 |             <hr>
141 |         {% endfor %}
142 |     </div>
143 |     <div id="scenario-overview" class="row">
144 |         {% for suite in suites %}
145 |             {% for feature in suite.features %}
146 |                 <div class="feature" data-id="feature-{{ feature.id }}">
147 |                     <div class="col-sm-4">
148 |                         <div class="card {{ feature.getPassedClass }}">
149 |                             <div class="header">
150 |                                 <h2>Feature: {{ feature.name }}</h2>
151 |                             </div>
152 |                             <div class="info">
153 |                                 <p>{{ feature.description|raw|nl2br }}</p>
154 |                             </div>
155 |                             <div class="footer">
156 |                                 <div class="tags">
157 |                                     {% for tag in feature.tags %}
158 |                                         <span class="badge">{{ tag }}</span>
159 |                                     {% endfor %}
160 |                                 </div>
161 |                                 {% if feature.getTotalAmountOfScenarios > 0 %}
162 |                                     <div class="progress">
163 |                                         <div class="progress-bar progress-bar-green" role="progressbar"
164 |                                              style="width: {{ feature.getPercentPassed }}%">
165 |                                             <span class="sr-only">40% Complete (success)</span>
166 |                                         </div>
167 |                                         <div class="progress-bar progress-bar-warning" role="progressbar"
168 |                                              style="width: {{ feature.getPercentPending }}%">
169 |                                             <span class="sr-only">40% Complete (success)</span>
170 |                                         </div>
171 |                                         <div class="progress-bar progress-bar-red" role="progressbar"
172 |                                              style="width: {{ feature.getPercentFailed }}%">
173 |                                             <span class="sr-only">40% Complete (success)</span>
174 |                                         </div>
175 |                                     </div>
176 |                                 {% endif %}
177 |                             </div>
178 |                         </div>
179 |                     </div>
180 |                     <div class="col-sm-8 details panel-group" role="tablist" aria-multiselectable="true">
181 |                         {% for scenario in feature.scenarios %}
182 |                             <div class="panel panel-default {% if scenario.isPassed %}passed{% elseif scenario.isPending %}pending{% else %}failed{% endif %}">
183 |                                 <div class="panel-heading" role="tab">
184 |                                     <h4 class="panel-title">
185 |                                         <a data-toggle="collapse" data-parent="#accordion"
186 |                                            href="#scenario-{{ feature.id }}-{{ scenario.id }}"
187 |                                            aria-expanded="true"
188 |                                            aria-controls="scenario-{{ feature.id }}-{{ scenario.id }}">
189 |                                             Scenario: {{ scenario.name }}
190 |                                         </a>
191 | 
192 |                                         <div class="tags pull-right">
193 |                                             {% for tag in scenario.tags %}
194 |                                                 <span class="badge">{{ tag }}</span>
195 |                                             {% endfor %}
196 |                                             {% if scenario.getRelativeScreenshotPath() %}
197 |                                             <a class="label label-default" href="{{ scenario.getRelativeScreenshotPath() }}" target="_blank">Screenshot</a>
198 |                                             {% endif %}
199 |                                         </div>
200 |                                     </h4>
201 |                                 </div>
202 |                                 <div id="scenario-{{ feature.id }}-{{ scenario.id }}" class="panel-collapse collapse in"
203 |                                      role="tabpanel"
204 |                                      aria-labelledby="headingOne">
205 |                                     <ul class="list-group">
206 |                                         {% for step in scenario.steps %}
207 |                                             <li class="list-group-item alert alert-{% if step.isPassed %}success{% elseif step.isSkipped %}info{% elseif step.isPending %}warning{% else %}danger{% endif %}">
208 |                                                 <b>{{ step.keyword }}</b> {{ step.text }}
209 |                                                 {% if printStepArgs is not null %}
210 |                                                     {% for argument in step.arguments %}
211 |                                                         <p style="padding-left:0.5em; overflow-x:scroll; white-space:nowrap; font-family:monospace">
212 |                                                             |{% for subarg in argument %} {{ subarg | nl2br}} | {% endfor %}
213 |                                                         </p>
214 |                                                     {% endfor %}
215 |                                                 {% endif %}
216 |                                                 {% if step.exception is not null %}
217 |                                                     <br>
218 |                                                     <p style="padding-left:2em ; color:gray">({{ step.exception }})</p>
219 |                                                 {% endif %}
220 |                                                 {% if step.output is not null %}
221 |                                                     <br>
222 |                                                     <p style="padding-left:2em ; color:black">| {{ step.output }}</p>
223 |                                                 {% endif %}
224 |                                                 {% if printLoopBreak is not null and ( loop.index % scenario.getLoopSize ) == 0 and loop.last != true  %}
225 |                                                     </li><li class="list-group-item break">
226 |                                                 {% endif %}
227 |                                             </li>
228 |                                             {#<div class="bs-callout bs-callout-{% if step.passed %}success{% else %}danger{% endif %}" id="callout-collapse-accessibility">#}
229 |                                             {#<b>{{ step.keyword }}</b> {{ step.text }}#}
230 |                                             {#</div>#}
231 |                                         {% endfor %}
232 |                                     </ul>
233 |                                 </div>
234 |                             </div>
235 |                         {% endfor %}
236 |                     </div>
237 |                 </div>
238 |             {% endfor %}
239 |         {% endfor %}
240 |     </div>
241 | </div>
242 | <!-- /container -->
243 | <!-- jQuery (necessary for Bootstrap's JavaScript plugins) -->
244 | <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
245 | <!-- Include all compiled plugins (below), or include individual files as needed -->
246 | <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.1/js/bootstrap.min.js"></script>
247 | 
248 | <script type="text/javascript">
249 |     window.onload = function () {
250 |         var featureChart = document.getElementById("chart-features").getContext("2d");
251 |         var scenarioChart = document.getElementById("chart-scenarios").getContext("2d");
252 |         var stepChart = document.getElementById("chart-steps").getContext("2d");
253 |         new Chart(featureChart, {type: 'doughnut', options: {legend: {display: false}}, data: {
254 |                 labels: ['Failed', 'Passed'],
255 |                 datasets: [{
256 |                     data: [{{ failedFeatures|length }}, {{ passedFeatures|length }}],
257 |                     backgroundColor: ["#F7464A", "#00a65a"],
258 |                 }],
259 |             }});
260 |         new Chart(scenarioChart, {type: 'doughnut', options: {legend: {display: false}}, data: {
261 |                 labels: ['Failed', 'Pending', 'Passed'],
262 |                 datasets: [{
263 |                     data: [{{ failedScenarios|length }}, {{ pendingScenarios|length }}, {{ passedScenarios|length }}],
264 |                     backgroundColor: ['#F7464A', 'e38d13', '#00a65a'],
265 |                 }],
266 |             }});
267 |         new Chart(stepChart, {type: 'doughnut', options: {legend: {display: false}}, data: {
268 |                 labels: ['Failed','Passed'],
269 |                 datasets: [{
270 |                     data: [{{ failedSteps|length }}, {{ passedSteps|length }}],
271 |                     backgroundColor: ["#F7464A", "#00a65a"],
272 |                 }],
273 |             }});
274 |     };
275 | </script>
276 | <script type="text/javascript">
277 |     function showOverview() {
278 |         $("#feature-overview").show();
279 |         $("#scenario-overview").hide();
280 |     }
281 |     function showDetails() {
282 |         $("#feature-overview").hide();
283 |         $("#scenario-overview").show();
284 |     }
285 |     function showFeatureDetail(featureId) {
286 |         $("#scenario-overview .feature").hide();
287 |         $("#scenario-overview .feature[data-id='" + featureId + "']").show();
288 |     }
289 |     $(function () {
290 |         $('.collapse').collapse();
291 | 
292 |         $('.filters').click()
293 |         {
294 |             showOverview();
295 |         }
296 | 
297 |         $('.filters #feature-failed-filter').click(function () {
298 |             showOverview();
299 |             $('.feature').hide();
300 |             $('.card.failed').parent().show();
301 |         });
302 |         $('.filters #feature-pending-filter').click(function () {
303 |             showOverview();
304 |             $('.feature').hide();
305 |             $('.card.pending').parent().show();
306 |         });
307 |         $('.filters #feature-passed-filter').click(function () {
308 |             showOverview();
309 |             $('.feature').hide();
310 |             $('.card.passed').parent().show();
311 |         });
312 |         $('.filters #feature-all-filter').click(function () {
313 |             showOverview();
314 |             $('.feature').show();
315 |         });
316 |     });
317 | 
318 |     $(function () {
319 |         $(".feature").click(function () {
320 |             var featureId = $(this).data("id");
321 |             showDetails();
322 |             showFeatureDetail(featureId);
323 |         });
324 |     });
325 | </script>
326 | </body>
327 | </html>
328 | 


--------------------------------------------------------------------------------
/src/Formatter/BehatHTMLFormatter.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace emuse\BehatHTMLFormatter\Formatter;
  4 | 
  5 | use Behat\Behat\EventDispatcher\Event\AfterFeatureTested;
  6 | use Behat\Behat\EventDispatcher\Event\AfterOutlineTested;
  7 | use Behat\Behat\EventDispatcher\Event\AfterScenarioTested;
  8 | use Behat\Behat\EventDispatcher\Event\AfterStepTested;
  9 | use Behat\Behat\EventDispatcher\Event\BeforeFeatureTested;
 10 | use Behat\Behat\EventDispatcher\Event\BeforeOutlineTested;
 11 | use Behat\Behat\EventDispatcher\Event\BeforeScenarioTested;
 12 | use Behat\Behat\Tester\Exception\PendingException;
 13 | use Behat\Behat\Tester\Result\ExecutedStepResult;
 14 | use Behat\Behat\Tester\Result\StepResult;
 15 | use Behat\Testwork\Counter\Memory;
 16 | use Behat\Testwork\Counter\Timer;
 17 | use Behat\Testwork\EventDispatcher\Event\AfterExerciseCompleted;
 18 | use Behat\Testwork\EventDispatcher\Event\AfterSuiteTested;
 19 | use Behat\Testwork\EventDispatcher\Event\BeforeExerciseCompleted;
 20 | use Behat\Testwork\EventDispatcher\Event\BeforeSuiteTested;
 21 | use Behat\Testwork\Output\Formatter;
 22 | use Behat\Testwork\Output\Printer\OutputPrinter;
 23 | use emuse\BehatHTMLFormatter\Classes\Feature;
 24 | use emuse\BehatHTMLFormatter\Classes\Scenario;
 25 | use emuse\BehatHTMLFormatter\Classes\Step;
 26 | use emuse\BehatHTMLFormatter\Classes\Suite;
 27 | use emuse\BehatHTMLFormatter\Printer\FileOutputPrinter;
 28 | use emuse\BehatHTMLFormatter\Renderer\BaseRenderer;
 29 | 
 30 | /**
 31 |  * Class BehatHTMLFormatter.
 32 |  */
 33 | class BehatHTMLFormatter implements Formatter
 34 | {
 35 |     //<editor-fold desc="Variables">
 36 |     /**
 37 |      * @var array
 38 |      */
 39 |     private $parameters;
 40 | 
 41 |     /**
 42 |      * @var
 43 |      */
 44 |     private $name;
 45 | 
 46 |     /**
 47 |      * @var
 48 |      */
 49 |     private $timer;
 50 | 
 51 |     /**
 52 |      * @var
 53 |      */
 54 |     private $memory;
 55 | 
 56 |     /**
 57 |      * @param string $outputPath where to save the generated report file
 58 |      */
 59 |     private $outputPath;
 60 | 
 61 |     /**
 62 |      * @param string $base_path Behat base path
 63 |      */
 64 |     private $base_path;
 65 | 
 66 |     /**
 67 |      * Printer used by this Formatter.
 68 |      *
 69 |      * @param $printer OutputPrinter
 70 |      */
 71 |     private $printer;
 72 | 
 73 |     /**
 74 |      * Renderer used by this Formatter.
 75 |      *
 76 |      * @param $renderer BaseRenderer
 77 |      */
 78 |     private $renderer;
 79 | 
 80 |     /**
 81 |      * Flag used by this Formatter.
 82 |      *
 83 |      * @param $print_args boolean
 84 |      */
 85 |     private $print_args;
 86 | 
 87 |     /**
 88 |      * Flag used by this Formatter.
 89 |      *
 90 |      * @param $print_outp boolean
 91 |      */
 92 |     private $print_outp;
 93 | 
 94 |     /**
 95 |      * Flag used by this Formatter.
 96 |      *
 97 |      * @param $loop_break boolean
 98 |      */
 99 |     private $loop_break;
100 | 
101 |     /**
102 |      * @var array
103 |      */
104 |     private $suites;
105 | 
106 |     /**
107 |      * @var Suite
108 |      */
109 |     private $currentSuite;
110 | 
111 |     /**
112 |      * @var int
113 |      */
114 |     private $featureCounter = 1;
115 | 
116 |     /**
117 |      * @var Feature
118 |      */
119 |     private $currentFeature;
120 | 
121 |     /**
122 |      * @var Scenario
123 |      */
124 |     private $currentScenario;
125 | 
126 |     /**
127 |      * @var Scenario[]
128 |      */
129 |     private $failedScenarios = array();
130 | 
131 |     /**
132 |      * @var Scenario[]
133 |      */
134 |     private $pendingScenarios = array();
135 | 
136 |     /**
137 |      * @var Scenario[]
138 |      */
139 |     private $passedScenarios = array();
140 | 
141 |     /**
142 |      * @var Feature[]
143 |      */
144 |     private $failedFeatures = array();
145 | 
146 |     /**
147 |      * @var Feature[]
148 |      */
149 |     private $passedFeatures = array();
150 | 
151 |     /**
152 |      * @var Step[]
153 |      */
154 |     private $failedSteps = array();
155 | 
156 |     /**
157 |      * @var Step[]
158 |      */
159 |     private $passedSteps = array();
160 | 
161 |     /**
162 |      * @var Step[]
163 |      */
164 |     private $pendingSteps = array();
165 | 
166 |     /**
167 |      * @var Step[]
168 |      */
169 |     private $skippedSteps = array();
170 | 
171 |     //</editor-fold>
172 | 
173 |     //<editor-fold desc="Formatter functions">
174 | 
175 |     /**
176 |      * @param $name
177 |      * @param $base_path
178 |      */
179 |     public function __construct($name, $renderer, $filename, $print_args, $print_outp, $loop_break, $base_path)
180 |     {
181 |         $this->name = $name;
182 |         $this->base_path = $base_path;
183 |         $this->print_args = $print_args;
184 |         $this->print_outp = $print_outp;
185 |         $this->loop_break = $loop_break;
186 |         $this->renderer = new BaseRenderer($renderer, $base_path);
187 |         $this->printer = new FileOutputPrinter($this->renderer->getNameList(), $filename, $base_path);
188 |         $this->timer = new Timer();
189 |         $this->memory = new Memory();
190 |     }
191 | 
192 |     /**
193 |      * Returns an array of event names this subscriber wants to listen to.
194 |      *
195 |      * @return array The event names to listen to
196 |      */
197 |     public static function getSubscribedEvents()
198 |     {
199 |         return array(
200 |             'tester.exercise_completed.before' => 'onBeforeExercise',
201 |             'tester.exercise_completed.after' => 'onAfterExercise',
202 |             'tester.suite_tested.before' => 'onBeforeSuiteTested',
203 |             'tester.suite_tested.after' => 'onAfterSuiteTested',
204 |             'tester.feature_tested.before' => 'onBeforeFeatureTested',
205 |             'tester.feature_tested.after' => 'onAfterFeatureTested',
206 |             'tester.scenario_tested.before' => 'onBeforeScenarioTested',
207 |             'tester.scenario_tested.after' => 'onAfterScenarioTested',
208 |             'tester.outline_tested.before' => 'onBeforeOutlineTested',
209 |             'tester.outline_tested.after' => 'onAfterOutlineTested',
210 |             'tester.step_tested.after' => 'onAfterStepTested',
211 |         );
212 |     }
213 | 
214 |     /**
215 |      * Returns formatter name.
216 |      *
217 |      * @return string
218 |      */
219 |     public function getName()
220 |     {
221 |         return $this->name;
222 |     }
223 | 
224 |     /**
225 |      * @return string
226 |      */
227 |     public function getBasePath()
228 |     {
229 |         return $this->base_path;
230 |     }
231 | 
232 |     /**
233 |      * Returns formatter description.
234 |      *
235 |      * @return string
236 |      */
237 |     public function getDescription()
238 |     {
239 |         return 'Formatter for teamcity';
240 |     }
241 | 
242 |     /**
243 |      * Returns formatter output printer.
244 |      *
245 |      * @return OutputPrinter
246 |      */
247 |     public function getOutputPrinter()
248 |     {
249 |         return $this->printer;
250 |     }
251 | 
252 |     /**
253 |      * Sets formatter parameter.
254 |      *
255 |      * @param string $name
256 |      * @param mixed  $value
257 |      */
258 |     public function setParameter($name, $value)
259 |     {
260 |         $this->parameters[$name] = $value;
261 |     }
262 | 
263 |     /**
264 |      * Returns parameter name.
265 |      *
266 |      * @param string $name
267 |      *
268 |      * @return mixed
269 |      */
270 |     public function getParameter($name)
271 |     {
272 |         return $this->parameters[$name];
273 |     }
274 | 
275 |     /**
276 |      * Returns output path.
277 |      *
278 |      * @return string output path
279 |      */
280 |     public function getOutputPath()
281 |     {
282 |         return $this->printer->getOutputPath();
283 |     }
284 | 
285 |     /**
286 |      * Returns if it should print the step arguments.
287 |      *
288 |      * @return bool
289 |      */
290 |     public function getPrintArguments()
291 |     {
292 |         return $this->print_args;
293 |     }
294 | 
295 |     /**
296 |      * Returns if it should print the step outputs.
297 |      *
298 |      * @return bool
299 |      */
300 |     public function getPrintOutputs()
301 |     {
302 |         return $this->print_outp;
303 |     }
304 | 
305 |     /**
306 |      * Returns if it should print scenario loop break.
307 |      *
308 |      * @return bool
309 |      */
310 |     public function getPrintLoopBreak()
311 |     {
312 |         return $this->loop_break;
313 |     }
314 | 
315 |     public function getTimer()
316 |     {
317 |         return $this->timer;
318 |     }
319 | 
320 |     public function getMemory()
321 |     {
322 |         return $this->memory;
323 |     }
324 | 
325 |     public function getSuites()
326 |     {
327 |         return $this->suites;
328 |     }
329 | 
330 |     public function getCurrentSuite()
331 |     {
332 |         return $this->currentSuite;
333 |     }
334 | 
335 |     public function getFeatureCounter()
336 |     {
337 |         return $this->featureCounter;
338 |     }
339 | 
340 |     public function getCurrentFeature()
341 |     {
342 |         return $this->currentFeature;
343 |     }
344 | 
345 |     public function getCurrentScenario()
346 |     {
347 |         return $this->currentScenario;
348 |     }
349 | 
350 |     public function getFailedScenarios()
351 |     {
352 |         return $this->failedScenarios;
353 |     }
354 | 
355 |     public function getPendingScenarios()
356 |     {
357 |         return $this->pendingScenarios;
358 |     }
359 | 
360 |     public function getPassedScenarios()
361 |     {
362 |         return $this->passedScenarios;
363 |     }
364 | 
365 |     public function getFailedFeatures()
366 |     {
367 |         return $this->failedFeatures;
368 |     }
369 | 
370 |     public function getPassedFeatures()
371 |     {
372 |         return $this->passedFeatures;
373 |     }
374 | 
375 |     public function getFailedSteps()
376 |     {
377 |         return $this->failedSteps;
378 |     }
379 | 
380 |     public function getPassedSteps()
381 |     {
382 |         return $this->passedSteps;
383 |     }
384 | 
385 |     public function getPendingSteps()
386 |     {
387 |         return $this->pendingSteps;
388 |     }
389 | 
390 |     public function getSkippedSteps()
391 |     {
392 |         return $this->skippedSteps;
393 |     }
394 | 
395 |     //</editor-fold>
396 | 
397 |     //<editor-fold desc="Event functions">
398 | 
399 |     /**
400 |      * @param BeforeExerciseCompleted $event
401 |      */
402 |     public function onBeforeExercise(BeforeExerciseCompleted $event)
403 |     {
404 |         $this->timer->start();
405 | 
406 |         $print = $this->renderer->renderBeforeExercise($this);
407 |         $this->printer->write($print);
408 |     }
409 | 
410 |     /**
411 |      * @param AfterExerciseCompleted $event
412 |      */
413 |     public function onAfterExercise(AfterExerciseCompleted $event)
414 |     {
415 |         $this->timer->stop();
416 | 
417 |         $print = $this->renderer->renderAfterExercise($this);
418 |         $this->printer->writeln($print);
419 |     }
420 | 
421 |     /**
422 |      * @param BeforeSuiteTested $event
423 |      */
424 |     public function onBeforeSuiteTested(BeforeSuiteTested $event)
425 |     {
426 |         $this->currentSuite = new Suite();
427 |         $this->currentSuite->setName($event->getSuite()->getName());
428 | 
429 |         $print = $this->renderer->renderBeforeSuite($this);
430 |         $this->printer->writeln($print);
431 |     }
432 | 
433 |     /**
434 |      * @param AfterSuiteTested $event
435 |      */
436 |     public function onAfterSuiteTested(AfterSuiteTested $event)
437 |     {
438 |         $this->suites[] = $this->currentSuite;
439 | 
440 |         $print = $this->renderer->renderAfterSuite($this);
441 |         $this->printer->writeln($print);
442 |     }
443 | 
444 |     /**
445 |      * @param BeforeFeatureTested $event
446 |      */
447 |     public function onBeforeFeatureTested(BeforeFeatureTested $event)
448 |     {
449 |         $feature = new Feature();
450 |         $feature->setId($this->featureCounter);
451 |         ++$this->featureCounter;
452 |         $feature->setName($event->getFeature()->getTitle());
453 |         $feature->setDescription($event->getFeature()->getDescription());
454 |         $feature->setTags($event->getFeature()->getTags());
455 |         $feature->setFile($event->getFeature()->getFile());
456 |         $feature->setScreenshotFolder($event->getFeature()->getTitle());
457 |         $this->currentFeature = $feature;
458 | 
459 |         $print = $this->renderer->renderBeforeFeature($this);
460 |         $this->printer->writeln($print);
461 |     }
462 | 
463 |     /**
464 |      * @param AfterFeatureTested $event
465 |      */
466 |     public function onAfterFeatureTested(AfterFeatureTested $event)
467 |     {
468 |         $this->currentSuite->addFeature($this->currentFeature);
469 |         if ($this->currentFeature->allPassed()) {
470 |             $this->passedFeatures[] = $this->currentFeature;
471 |         } else {
472 |             $this->failedFeatures[] = $this->currentFeature;
473 |         }
474 | 
475 |         $print = $this->renderer->renderAfterFeature($this);
476 |         $this->printer->writeln($print);
477 |     }
478 | 
479 |     /**
480 |      * @param BeforeScenarioTested $event
481 |      */
482 |     public function onBeforeScenarioTested(BeforeScenarioTested $event)
483 |     {
484 |         $scenario = new Scenario();
485 |         $scenario->setName($event->getScenario()->getTitle());
486 |         $scenario->setTags($event->getScenario()->getTags());
487 |         $scenario->setLine($event->getScenario()->getLine());
488 |         $scenario->setScreenshotName($event->getScenario()->getTitle());
489 |         $scenario->setScreenshotPath(
490 |             $this->printer->getOutputPath().
491 |             '/assets/screenshots/'.
492 |             preg_replace('/\W/', '', $event->getFeature()->getTitle()).'/'.
493 |             preg_replace('/\W/', '', $event->getScenario()->getTitle()).'.png'
494 |         );
495 |         $this->currentScenario = $scenario;
496 | 
497 |         $print = $this->renderer->renderBeforeScenario($this);
498 |         $this->printer->writeln($print);
499 |     }
500 | 
501 |     /**
502 |      * @param AfterScenarioTested $event
503 |      */
504 |     public function onAfterScenarioTested(AfterScenarioTested $event)
505 |     {
506 |         $scenarioPassed = $event->getTestResult()->isPassed();
507 | 
508 |         if ($scenarioPassed) {
509 |             $this->passedScenarios[] = $this->currentScenario;
510 |             $this->currentFeature->addPassedScenario();
511 |             $this->currentScenario->setPassed(true);
512 |         } elseif (StepResult::PENDING == $event->getTestResult()->getResultCode()) {
513 |             $this->pendingScenarios[] = $this->currentScenario;
514 |             $this->currentFeature->addPendingScenario();
515 |             $this->currentScenario->setPending(true);
516 |         } else {
517 |             $this->failedScenarios[] = $this->currentScenario;
518 |             $this->currentFeature->addFailedScenario();
519 |             $this->currentScenario->setPassed(false);
520 |             $this->currentScenario->setPending(false);
521 |         }
522 | 
523 |         $this->currentScenario->setLoopCount(1);
524 |         $this->currentFeature->addScenario($this->currentScenario);
525 | 
526 |         $print = $this->renderer->renderAfterScenario($this);
527 |         $this->printer->writeln($print);
528 |     }
529 | 
530 |     /**
531 |      * @param BeforeOutlineTested $event
532 |      */
533 |     public function onBeforeOutlineTested(BeforeOutlineTested $event)
534 |     {
535 |         $scenario = new Scenario();
536 |         $scenario->setName($event->getOutline()->getTitle());
537 |         $scenario->setTags($event->getOutline()->getTags());
538 |         $scenario->setLine($event->getOutline()->getLine());
539 |         $this->currentScenario = $scenario;
540 | 
541 |         $print = $this->renderer->renderBeforeOutline($this);
542 |         $this->printer->writeln($print);
543 |     }
544 | 
545 |     /**
546 |      * @param AfterOutlineTested $event
547 |      */
548 |     public function onAfterOutlineTested(AfterOutlineTested $event)
549 |     {
550 |         $scenarioPassed = $event->getTestResult()->isPassed();
551 | 
552 |         if ($scenarioPassed) {
553 |             $this->passedScenarios[] = $this->currentScenario;
554 |             $this->currentFeature->addPassedScenario();
555 |             $this->currentScenario->setPassed(true);
556 |         } elseif (StepResult::PENDING == $event->getTestResult()->getResultCode()) {
557 |             $this->pendingScenarios[] = $this->currentScenario;
558 |             $this->currentFeature->addPendingScenario();
559 |             $this->currentScenario->setPending(true);
560 |         } else {
561 |             $this->failedScenarios[] = $this->currentScenario;
562 |             $this->currentFeature->addFailedScenario();
563 |             $this->currentScenario->setPassed(false);
564 |             $this->currentScenario->setPending(false);
565 |         }
566 | 
567 |         $this->currentScenario->setLoopCount(sizeof($event->getTestResult()));
568 |         $this->currentFeature->addScenario($this->currentScenario);
569 | 
570 |         $print = $this->renderer->renderAfterOutline($this);
571 |         $this->printer->writeln($print);
572 |     }
573 | 
574 |     /**
575 |      * @param BeforeStepTested $event
576 |      */
577 |     public function onBeforeStepTested(BeforeStepTested $event)
578 |     {
579 |         $print = $this->renderer->renderBeforeStep($this);
580 |         $this->printer->writeln($print);
581 |     }
582 | 
583 |     /**
584 |      * @param AfterStepTested $event
585 |      */
586 |     public function onAfterStepTested(AfterStepTested $event)
587 |     {
588 |         $result = $event->getTestResult();
589 | 
590 |         /** @var Step $step */
591 |         $step = new Step();
592 |         $step->setKeyword($event->getStep()->getKeyword());
593 |         $step->setText($event->getStep()->getText());
594 |         $step->setLine($event->getStep()->getLine());
595 |         $step->setResult($result);
596 |         $step->setResultCode($result->getResultCode());
597 | 
598 |         if ($event->getStep()->hasArguments()) {
599 |             $object = $this->getObject($event->getStep()->getArguments());
600 |             $step->setArgumentType($object->getNodeType());
601 |             $step->setArguments($object);
602 |         }
603 | 
604 |         //What is the result of this step ?
605 |         if (is_a($result, 'Behat\Behat\Tester\Result\UndefinedStepResult')) {
606 |             //pending step -> no definition to load
607 |             $this->pendingSteps[] = $step;
608 |         } else {
609 |             if (is_a($result, 'Behat\Behat\Tester\Result\SkippedStepResult')) {
610 |                 //skipped step
611 |                 /* @var ExecutedStepResult $result */
612 |                 $step->setDefinition($result->getStepDefinition());
613 |                 $this->skippedSteps[] = $step;
614 |             } else {
615 |                 //failed or passed
616 |                 if ($result instanceof ExecutedStepResult) {
617 |                     $step->setDefinition($result->getStepDefinition());
618 |                     $exception = $result->getException();
619 |                     if ($exception) {
620 |                         if ($exception instanceof PendingException) {
621 |                             $this->pendingSteps[] = $step;
622 |                         } else {
623 |                             $step->setException($exception->getMessage());
624 |                             $this->failedSteps[] = $step;
625 |                         }
626 |                     } else {
627 |                         $step->setOutput($result->getCallResult()->getStdOut());
628 |                         $this->passedSteps[] = $step;
629 |                     }
630 |                 }
631 |             }
632 |         }
633 | 
634 |         $this->currentScenario->addStep($step);
635 | 
636 |         $print = $this->renderer->renderAfterStep($this);
637 |         $this->printer->writeln($print);
638 |     }
639 | 
640 |     //</editor-fold>
641 | 
642 |     /**
643 |      * @param $arguments
644 |      */
645 |     public function getObject($arguments)
646 |     {
647 |         foreach ($arguments as $argument => $args) {
648 |             return $args;
649 |         }
650 |     }
651 | }
652 | 


--------------------------------------------------------------------------------
/src/Renderer/Behat2Renderer.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Behat2 renderer for Behat report.
  4 |  *
  5 |  * @author DaSayan <glennwall@free.fr>
  6 |  */
  7 | 
  8 | namespace emuse\BehatHTMLFormatter\Renderer;
  9 | 
 10 | use Behat\Gherkin\Node\TableNode;
 11 | 
 12 | class Behat2Renderer implements RendererInterface
 13 | {
 14 |     /**
 15 |      * Renders before an exercice.
 16 |      *
 17 |      * @param object : BehatHTMLFormatter object
 18 |      *
 19 |      * @return string : HTML generated
 20 |      */
 21 |     public function renderBeforeExercise($obj)
 22 |     {
 23 |         $print = "<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Strict//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd'>
 24 |         <html xmlns ='http://www.w3.org/1999/xhtml'>
 25 |         <head>
 26 |             <meta http-equiv='Content-Type' content='text/html;charset=utf-8'/>
 27 |             <title>Behat Test Suite</title> ".$this->getCSS()."
 28 |         </head>
 29 |         <body>
 30 |         <div id='behat'>";
 31 | 
 32 |         return $print;
 33 |     }
 34 | 
 35 |     /**
 36 |      * Renders after an exercice.
 37 |      *
 38 |      * @param object : BehatHTMLFormatter object
 39 |      *
 40 |      * @return string : HTML generated
 41 |      */
 42 |     public function renderAfterExercise($obj)
 43 |     {
 44 |         //--> features results
 45 |         $featTotal = 0;
 46 |         $sceTotal = 0;
 47 |         $stepsTotal = 0;
 48 | 
 49 |         $strFeatPassed = '';
 50 | 
 51 |         if (null !== $obj->getPassedFeatures() && count($obj->getPassedFeatures()) > 0) {
 52 |             $strFeatPassed = ' <strong class="passed">'.count($obj->getPassedFeatures()).' success</strong>';
 53 |             $featTotal += count($obj->getPassedFeatures());
 54 |         }
 55 | 
 56 |         $strFeatFailed = '';
 57 |         $sumRes = 'passed';
 58 |         if (null !== $obj->getFailedFeatures() && count($obj->getFailedFeatures()) > 0) {
 59 |             $strFeatFailed = ' <strong class="failed">'.count($obj->getFailedFeatures()).' fail</strong>';
 60 |             $sumRes = 'failed';
 61 |             $featTotal += count($obj->getFailedFeatures());
 62 |         }
 63 | 
 64 |         //--> scenarios results
 65 |         $strScePassed = '';
 66 |         if (null !== $obj->getPassedScenarios() && count($obj->getPassedScenarios()) > 0) {
 67 |             $strScePassed = ' <strong class="passed">'.count($obj->getPassedScenarios()).' success</strong>';
 68 |             $sceTotal += count($obj->getPassedScenarios());
 69 |         }
 70 | 
 71 |         $strScePending = '';
 72 |         if (null !== $obj->getPendingScenarios() && count($obj->getPendingScenarios()) > 0) {
 73 |             $strScePending = ' <strong class="failed">'.count($obj->getPendingScenarios()).' fail</strong>';
 74 |             $sceTotal += count($obj->getPendingScenarios());
 75 |         }
 76 | 
 77 |         $strSceFailed = '';
 78 |         if (null !== $obj->getFailedScenarios() && count($obj->getFailedScenarios()) > 0) {
 79 |             $strSceFailed = ' <strong class="failed">'.count($obj->getFailedScenarios()).' fail</strong>';
 80 |             $sceTotal += count($obj->getFailedScenarios());
 81 |         }
 82 | 
 83 |         //--> steps results
 84 |         $strStepsPassed = '';
 85 |         if (null !== $obj->getPassedSteps() && count($obj->getPassedSteps()) > 0) {
 86 |             $strStepsPassed = ' <strong class="passed">'.count($obj->getPassedSteps()).' success</strong>';
 87 |             $stepsTotal += count($obj->getPassedSteps());
 88 |         }
 89 | 
 90 |         $strStepsPending = '';
 91 |         if (null !== $obj->getPendingSteps() && count($obj->getPendingSteps()) > 0) {
 92 |             $strStepsPending = ' <strong class="pending">'.count($obj->getPendingSteps()).' pending</strong>';
 93 |             $stepsTotal += count($obj->getPendingSteps());
 94 |         }
 95 | 
 96 |         $strStepsSkipped = '';
 97 |         if (null !== $obj->getSkippedSteps() && count($obj->getSkippedSteps()) > 0) {
 98 |             $strStepsSkipped = ' <strong class="skipped">'.count($obj->getSkippedSteps()).' skipped</strong>';
 99 |             $stepsTotal += count($obj->getSkippedSteps());
100 |         }
101 | 
102 |         $strStepsFailed = '';
103 |         if (null !== $obj->getFailedSteps() && count($obj->getFailedSteps()) > 0) {
104 |             $strStepsFailed = ' <strong class="failed">'.count($obj->getFailedSteps()).' fail</strong>';
105 |             $stepsTotal += count($obj->getFailedSteps());
106 |         }
107 | 
108 |         //list of pending steps to display
109 |         $strPendingList = '';
110 |         if (null !== $obj->getPendingSteps() && count($obj->getPendingSteps()) > 0) {
111 |             foreach ($obj->getPendingSteps() as $pendingStep) {
112 |                 $strPendingList .= '
113 |                     <li>'.$pendingStep->getKeyword().' '.$pendingStep->getText().'</li>';
114 |             }
115 |             $strPendingList = '
116 |             <div class="pending">Pending steps :
117 |                 <ul>'.$strPendingList.'
118 |                 </ul>
119 |             </div>';
120 |         }
121 | 
122 |         $print = '
123 |         <div class="summary '.$sumRes.'">
124 |             <div class="counters">
125 |                 <p class="features">
126 |                     '.$featTotal.' features ('.$strFeatPassed.$strFeatFailed.' )
127 |                 </p>
128 |                 <p class="scenarios">
129 |                     '.$sceTotal.' scenarios ('.$strScePassed.$strScePending.$strSceFailed.' )
130 |                 </p>
131 |                 <p class="steps">
132 |                     '.$stepsTotal.' steps ('.$strStepsPassed.$strStepsPending.$strStepsSkipped.$strStepsFailed.' )
133 |                 </p>
134 |                 <p class="time">
135 |                 '.$obj->getTimer().' - '.$obj->getMemory().'
136 |                 </p>
137 |             </div>
138 |             <div class="switchers">
139 |                 <a href="javascript:void(0)" id="behat_show_all">[+] all</a>
140 |                 <a href="javascript:void(0)" id="behat_hide_all">[-] all</a>
141 |             </div>
142 |         </div> '.$strPendingList.'
143 |     </div>'.$this->getJS().'
144 | </body>
145 | </html>';
146 | 
147 |         return $print;
148 |     }
149 | 
150 |     /**
151 |      * Renders before a suite.
152 |      *
153 |      * @param object : BehatHTMLFormatter object
154 |      *
155 |      * @return string : HTML generated
156 |      */
157 |     public function renderBeforeSuite($obj)
158 |     {
159 |         $print = '
160 |         <div class="suite">Suite : '.$obj->getCurrentSuite()->getName().'</div>';
161 | 
162 |         return $print;
163 |     }
164 | 
165 |     /**
166 |      * Renders after a suite.
167 |      *
168 |      * @param object : BehatHTMLFormatter object
169 |      *
170 |      * @return string : HTML generated
171 |      */
172 |     public function renderAfterSuite($obj)
173 |     {
174 |         return '';
175 |     }
176 | 
177 |     /**
178 |      * Renders before a feature.
179 |      *
180 |      * @param object : BehatHTMLFormatter object
181 |      *
182 |      * @return string : HTML generated
183 |      */
184 |     public function renderBeforeFeature($obj)
185 |     {
186 |         //feature head
187 |         $print = '
188 |         <div class="feature">
189 |             <h2>
190 |                 <span id="feat'.$obj->getCurrentFeature()->getId().'" class="keyword"> Feature: </span>
191 |                 <span class="title">'.$obj->getCurrentFeature()->getName().'</span>
192 |             </h2>
193 |             <p>'.$obj->getCurrentFeature()->getDescription().'</p>
194 |             <ul class="tags">';
195 |         foreach ($obj->getCurrentFeature()->getTags() as $tag) {
196 |             $print .= '
197 |                 <li>@'.$tag.'</li>';
198 |         }
199 |         $print .= '
200 |             </ul>';
201 | 
202 |         //TODO path is missing (?)
203 | 
204 |         return $print;
205 |     }
206 | 
207 |     /**
208 |      * Renders after a feature.
209 |      *
210 |      * @param object : BehatHTMLFormatter object
211 |      *
212 |      * @return string : HTML generated
213 |      */
214 |     public function renderAfterFeature($obj)
215 |     {
216 |         //list of results
217 |         $print = '
218 |             <div class="featureResult '.$obj->getCurrentFeature()->getPassedClass().'">Feature has '.$obj->getCurrentFeature()->getPassedClass();
219 | 
220 |         //percent only if failed scenarios
221 |         if ($obj->getCurrentFeature()->getTotalAmountOfScenarios() > 0 && 'failed' === $obj->getCurrentFeature()->getPassedClass()) {
222 |             $print .= '
223 |                 <span>Scenarios passed : '.round($obj->getCurrentFeature()->getPercentPassed(), 2).'%,
224 |                 Scenarios failed : '.round($obj->getCurrentFeature()->getPercentFailed(), 2).'%</span>';
225 |         }
226 | 
227 |         $print .= '
228 |             </div>
229 |         </div>';
230 | 
231 |         return $print;
232 |     }
233 | 
234 |     /**
235 |      * Renders before a scenario.
236 |      *
237 |      * @param object : BehatHTMLFormatter object
238 |      *
239 |      * @return string : HTML generated
240 |      */
241 |     public function renderBeforeScenario($obj)
242 |     {
243 |         //scenario head
244 |         $print = '
245 |             <div class="scenario">
246 |                 <ul class="tags">';
247 |         foreach ($obj->getCurrentScenario()->getTags() as $tag) {
248 |             $print .= '
249 |                     <li>@'.$tag.'</li>';
250 |         }
251 |         $print .= '
252 |                 </ul>';
253 | 
254 |         $print .= '
255 |                 <h3>
256 |                     <span class="keyword">'.$obj->getCurrentScenario()->getId().' Scenario: </span>
257 |                     <span class="title">'.$obj->getCurrentScenario()->getName().'</span>
258 |                 </h3>
259 |                 <ol>';
260 | 
261 |         //TODO path is missing
262 | 
263 |         return $print;
264 |     }
265 | 
266 |     /**
267 |      * Renders after a scenario.
268 |      *
269 |      * @param object : BehatHTMLFormatter object
270 |      *
271 |      * @return string : HTML generated
272 |      */
273 |     public function renderAfterScenario($obj)
274 |     {
275 |         $print = '
276 |                 </ol>
277 |             </div>';
278 | 
279 |         return $print;
280 |     }
281 | 
282 |     /**
283 |      * Renders before an outline.
284 |      *
285 |      * @param object : BehatHTMLFormatter object
286 |      *
287 |      * @return string : HTML generated
288 |      */
289 |     public function renderBeforeOutline($obj)
290 |     {
291 |         //scenario head
292 |         $print = '
293 |             <div class="scenario">
294 |                 <ul class="tags">';
295 |         foreach ($obj->getCurrentScenario()->getTags() as $tag) {
296 |             $print .= '
297 |                     <li>@'.$tag.'</li>';
298 |         }
299 |         $print .= '
300 |                 </ul>';
301 | 
302 |         $print .= '
303 |                 <h3>
304 |                     <span class="keyword">'.$obj->getCurrentScenario()->getId().' Scenario Outline: </span>
305 |                     <span class="title">'.$obj->getCurrentScenario()->getName().'</span>
306 |                 </h3>
307 |                 <ol>';
308 | 
309 |         //TODO path is missing
310 | 
311 |         return $print;
312 |     }
313 | 
314 |     /**
315 |      * Renders after an outline.
316 |      *
317 |      * @param object : BehatHTMLFormatter object
318 |      *
319 |      * @return string : HTML generated
320 |      */
321 |     public function renderAfterOutline($obj)
322 |     {
323 |         return $this->renderAfterScenario($obj);
324 |     }
325 | 
326 |     /**
327 |      * Renders before a step.
328 |      *
329 |      * @param object : BehatHTMLFormatter object
330 |      *
331 |      * @return string : HTML generated
332 |      */
333 |     public function renderBeforeStep($obj)
334 |     {
335 |         return '';
336 |     }
337 | 
338 |     /**
339 |      * Renders TableNode arguments.
340 |      *
341 |      * @param TableNode $table
342 |      *
343 |      * @return string : HTML generated
344 |      */
345 |     public function renderTableNode(TableNode $table)
346 |     {
347 |         $arguments = '<table class="argument"> <thead>';
348 |         $header = $table->getRow(0);
349 |         $arguments .= $this->preintTableRows($header);
350 | 
351 |         $arguments .= '</thead><tbody>';
352 |         foreach ($table->getHash() as $row) {
353 |             $arguments .= $this->preintTableRows($row);
354 |         }
355 | 
356 |         $arguments .= '</tbody></table>';
357 | 
358 |         return $arguments;
359 |     }
360 | 
361 |     /**
362 |      * Renders table rows.
363 |      *
364 |      * @param array $row
365 |      *
366 |      * @return string : HTML generated
367 |      */
368 |     public function preintTableRows($row)
369 |     {
370 |         $return = '<tr class="row">';
371 |         foreach ($row as $column) {
372 |             $return .= '<td>'.htmlentities($column).'</td>';
373 |         }
374 |         $return .= '</tr>';
375 | 
376 |         return $return;
377 |     }
378 | 
379 |     /**
380 |      * Renders after a step.
381 |      *
382 |      * @param object : BehatHTMLFormatter object
383 |      *
384 |      * @return string : HTML generated
385 |      */
386 |     public function renderAfterStep($obj)
387 |     {
388 |         $feature = $obj->getCurrentFeature();
389 |         $scenario = $obj->getCurrentScenario();
390 | 
391 |         $steps = $scenario->getSteps();
392 |         $step = end($steps); //needed because of strict standards
393 | 
394 |         //path displayed only if available (it's not available in undefined steps)
395 |         $strPath = '';
396 |         if (null !== $step->getDefinition()) {
397 |             $strPath = $step->getDefinition()->getPath();
398 |         }
399 | 
400 |         $stepResultClass = '';
401 |         if ($step->isPassed()) {
402 |             $stepResultClass = 'passed';
403 |         }
404 |         if ($step->isFailed()) {
405 |             $stepResultClass = 'failed';
406 |         }
407 |         if ($step->isSkipped()) {
408 |             $stepResultClass = 'skipped';
409 |         }
410 |         if ($step->isPending()) {
411 |             $stepResultClass = 'pending';
412 |         }
413 | 
414 |         $arguments = '';
415 |         $argumentType = $step->getArgumentType();
416 | 
417 |         if ('PyString' == $argumentType) {
418 |             $arguments = '<br><pre class="argument">'.htmlentities($step->getArguments()).'</pre>';
419 |         }
420 | 
421 |         if ('Table' == $argumentType) {
422 |             $arguments = '<br><pre class="argument">'.$this->renderTableNode($step->getArguments()).'</pre>';
423 |         }
424 | 
425 |         $print = '
426 |                     <li class="'.$stepResultClass.'">
427 |                         <div class="step">
428 |                             <span class="keyword">'.$step->getKeyWord().' </span>
429 |                             <span class="text">'.htmlentities($step->getText()).' </span>
430 |                             <span class="path">'.$strPath.'</span>'
431 |                             .$arguments.'
432 |                         </div>';
433 |         $exception = $step->getException();
434 |         if (!empty($exception)) {
435 |             $print .= '
436 |                         <pre class="backtrace">'.$step->getException().'</pre>';
437 |             if ($scenario->getRelativeScreenshotPath()) {
438 |                 $print .= '<a href="'.$scenario->getRelativeScreenshotPath().'">Screenshot</a>';
439 |             }
440 |         }
441 |         $print .= '
442 |                     </li>';
443 | 
444 |         return $print;
445 |     }
446 | 
447 |     /**
448 |      * To include CSS.
449 |      *
450 |      * @return string : HTML generated
451 |      */
452 |     public function getCSS()
453 |     {
454 |         return "<style type='text/css'>
455 |                 body {
456 |                     margin:0px;
457 |                     padding:0px;
458 |                     position:relative;
459 |                     padding-top:93px;
460 |                 }
461 |                 #behat {
462 |                     float:left;
463 |                     font-family: Georgia, serif;
464 |                     font-size:18px;
465 |                     line-height:26px;
466 |                     width:100%;
467 |                 }
468 |                 #behat .statistics {
469 |                     float:left;
470 |                     width:100%;
471 |                     margin-bottom:15px;
472 |                 }
473 |                 #behat .statistics p {
474 |                     text-align:right;
475 |                     padding:5px 15px;
476 |                     margin:0px;
477 |                     border-right:10px solid #000;
478 |                 }
479 |                 #behat .statistics.failed p {
480 |                     border-color:#C20000;
481 |                 }
482 |                 #behat .statistics.passed p {
483 |                     border-color:#3D7700;
484 |                 }
485 |                 #behat .suite {
486 |                     margin:8px;
487 |                 }
488 |                 #behat .feature {
489 |                     margin:15px;
490 |                 }
491 |                 #behat h2, #behat h3, #behat h4 {
492 |                     margin:0px 0px 5px 0px;
493 |                     padding:0px;
494 |                     font-family:Georgia;
495 |                 }
496 |                 #behat h2 .title, #behat h3 .title, #behat h4 .title {
497 |                     font-weight:normal;
498 |                 }
499 |                 #behat .path {
500 |                     font-size:10px;
501 |                     font-weight:normal;
502 |                     font-family: 'Bitstream Vera Sans Mono', 'DejaVu Sans Mono', Monaco, Courier, monospace !important;
503 |                     color:#999;
504 |                     padding:0px 5px;
505 |                     float:right;
506 |                 }
507 |                 #behat .path a:link,
508 |                 #behat .path a:visited {
509 |                     color:#999;
510 |                 }
511 |                 #behat .path a:hover,
512 |                 #behat .path a:active {
513 |                     background-color:#000;
514 |                     color:#fff;
515 |                 }
516 |                 #behat h3 .path {
517 |                     margin-right:4%;
518 |                 }
519 |                 #behat ul.tags {
520 |                     font-size:14px;
521 |                     font-weight:bold;
522 |                     color:#246AC1;
523 |                     list-style:none;
524 |                     margin:0px;
525 |                     padding:0px;
526 |                 }
527 |                 #behat ul.tags li {
528 |                     display:inline;
529 |                 }
530 |                 #behat ul.tags li:after {
531 |                     content:' ';
532 |                 }
533 |                 #behat ul.tags li:last-child:after {
534 |                     content:'';
535 |                 }
536 |                 #behat .feature > p {
537 |                     margin-top:0px;
538 |                     margin-left:20px;
539 |                 }
540 |                 #behat .scenario {
541 |                     margin-left:20px;
542 |                     margin-bottom:20px;
543 |                 }
544 |                 #behat .scenario > ol,
545 |                 #behat .scenario .examples > ol {
546 |                     margin:0px;
547 |                     list-style:none;
548 |                     padding:0px;
549 |                 }
550 |                 #behat .scenario > ol {
551 |                     margin-left:20px;
552 |                 }
553 |                 #behat .scenario > ol:after,
554 |                 #behat .scenario .examples > ol:after {
555 |                     content:'';
556 |                     display:block;
557 |                     clear:both;
558 |                 }
559 |                 #behat .scenario > ol li,
560 |                 #behat .scenario .examples > ol li {
561 |                     float:left;
562 |                     width:95%;
563 |                     padding-left:5px;
564 |                     border-left:5px solid;
565 |                     margin-bottom:4px;
566 |                 }
567 |                 #behat .scenario > ol li .argument,
568 |                 #behat .scenario .examples > ol li .argument {
569 |                     margin:10px 20px;
570 |                     font-size:14px;
571 |                     overflow:auto;
572 |                 }
573 |                 #behat .scenario > ol li table.argument,
574 |                 #behat .scenario .examples > ol li table.argument {
575 |                     border:1px solid #d2d2d2;
576 |                 }
577 |                 #behat .scenario > ol li table.argument thead td,
578 |                 #behat .scenario .examples > ol li table.argument thead td {
579 |                     font-weight: bold;
580 |                 }
581 |                 #behat .scenario > ol li table.argument td,
582 |                 #behat .scenario .examples > ol li table.argument td {
583 |                     padding:5px 10px;
584 |                     background:#f3f3f3;
585 |                 }
586 |                 #behat .scenario > ol li .keyword,
587 |                 #behat .scenario .examples > ol li .keyword {
588 |                     font-weight:bold;
589 |                 }
590 |                 #behat .scenario > ol li .path,
591 |                 #behat .scenario .examples > ol li .path {
592 |                     float:right;
593 |                 }
594 |                 #behat .scenario .examples {
595 |                     margin-top:20px;
596 |                     margin-left:40px;
597 |                 }
598 |                 #behat .scenario .examples h4 span {
599 |                     font-weight:normal;
600 |                     background:#f3f3f3;
601 |                     color:#999;
602 |                     padding:0 5px;
603 |                     margin-left:10px;
604 |                 }
605 |                 #behat .scenario .examples table {
606 |                     margin-left:20px;
607 |                 }
608 |                 #behat .scenario .examples table thead td {
609 |                     font-weight:bold;
610 |                     text-align:center;
611 |                 }
612 |                 #behat .scenario .examples table td {
613 |                     padding:2px 10px;
614 |                     font-size:16px;
615 |                 }
616 |                 #behat .scenario .examples table .failed.exception td {
617 |                     border-left:5px solid #000;
618 |                     border-color:#C20000 !important;
619 |                     padding-left:0px;
620 |                 }
621 |                 pre {
622 |                     font-family:monospace;
623 |                 }
624 |                 .snippet {
625 |                     font-size:14px;
626 |                     color:#000;
627 |                     margin-left:20px;
628 |                 }
629 |                 .backtrace {
630 |                     font-size:12px;
631 |                     line-height:18px;
632 |                     color:#000;
633 |                     overflow:auto;
634 |                     margin-left:20px;
635 |                     padding:15px;
636 |                     border-left:2px solid #C20000;
637 |                     background: #fff;
638 |                     margin-right:15px;
639 |                 }
640 |                 #behat .passed {
641 |                     background:#DBFFB4;
642 |                     border-color:#65C400 !important;
643 |                     color:#3D7700;
644 |                 }
645 |                 #behat .failed {
646 |                     background:#FFFBD3;
647 |                     border-color:#C20000 !important;
648 |                     color:#C20000;
649 |                 }
650 |                 #behat .undefined, #behat .pending {
651 |                     border-color:#FAF834 !important;
652 |                     background:#FCFB98;
653 |                     color:#000;
654 |                 }
655 |                 #behat .skipped {
656 |                     background:lightCyan;
657 |                     border-color:cyan !important;
658 |                     color:#000;
659 |                 }
660 |                 #behat .summary {
661 |                     position: absolute;
662 |                     top: 0px;
663 |                     left: 0px;
664 |                     width:100%;
665 |                     font-family: Arial, sans-serif;
666 |                     font-size: 14px;
667 |                     line-height: 18px;
668 |                 }
669 |                 #behat .summary .counters {
670 |                     padding: 10px;
671 |                     border-top: 0px;
672 |                     border-bottom: 0px;
673 |                     border-right: 0px;
674 |                     border-left: 5px;
675 |                     border-style: solid;
676 |                     overflow: hidden;
677 |                 }
678 |                 #behat .summary .switchers {
679 |                     position: absolute;
680 |                     right: 15px;
681 |                     top: 25px;
682 |                 }
683 |                 #behat .summary .switcher {
684 |                     text-decoration: underline;
685 |                     cursor: pointer;
686 |                 }
687 |                 #behat .summary .switchers a {
688 |                     margin-left: 10px;
689 |                     color: #000;
690 |                 }
691 |                 #behat .summary .switchers a:hover {
692 |                     text-decoration:none;
693 |                 }
694 |                 #behat .summary p {
695 |                     margin:0px;
696 |                 }
697 | 
698 |                 #behat .featureResult > span {
699 |                     font-size: 14px;
700 |                 }
701 | 
702 |                 #behat .jq-toggle > .scenario,
703 |                 #behat .jq-toggle > ol,
704 |                 #behat .jq-toggle > .examples {
705 |                     display:none;
706 |                 }
707 |                 #behat .jq-toggle-opened > .scenario,
708 |                 #behat .jq-toggle-opened > ol,
709 |                 #behat .jq-toggle-opened > .examples {
710 |                     display:block;
711 |                 }
712 |                 #behat .jq-toggle > h2,
713 |                 #behat .jq-toggle > h3 {
714 |                     cursor:pointer;
715 |                 }
716 |                 #behat .jq-toggle > h2:after,
717 |                 #behat .jq-toggle > h3:after {
718 |                     content:' |+';
719 |                     font-weight:bold;
720 |                 }
721 |                 #behat .jq-toggle-opened > h2:after,
722 |                 #behat .jq-toggle-opened > h3:after {
723 |                     content:' |-';
724 |                     font-weight:bold;
725 |                 }
726 |             </style>
727 | 
728 |             <style type='text/css' media='print'>
729 |                 body {
730 |                     padding:0px;
731 |                 }
732 | 
733 |                 #behat {
734 |                     font-size:11px;
735 |                 }
736 | 
737 |                 #behat .jq-toggle > .scenario,
738 |                 #behat .jq-toggle > .scenario .examples,
739 |                 #behat .jq-toggle > ol {
740 |                     display:block;
741 |                 }
742 | 
743 |                 #behat .summary {
744 |                     position:relative;
745 |                 }
746 | 
747 |                 #behat .summary .counters {
748 |                     border:none;
749 |                 }
750 | 
751 |                 #behat .summary .switchers {
752 |                     display:none;
753 |                 }
754 | 
755 |                 #behat .step .path {
756 |                     display:none;
757 |                 }
758 | 
759 |                 #behat .jq-toggle > h2:after,
760 |                 #behat .jq-toggle > h3:after {
761 |                     content:'';
762 |                     font-weight:bold;
763 |                 }
764 | 
765 |                 #behat .jq-toggle-opened > h2:after,
766 |                 #behat .jq-toggle-opened > h3:after {
767 |                     content:'';
768 |                     font-weight:bold;
769 |                 }
770 | 
771 |                 #behat .scenario > ol li,
772 |                 #behat .scenario .examples > ol li {
773 |                     border-left:none;
774 |                 }
775 |             </style>";
776 |     }
777 | 
778 |     /**
779 |      * To include JS.
780 |      *
781 |      * @return string : HTML generated
782 |      */
783 |     public function getJS()
784 |     {
785 |         return "<script type='text/javascript' src='https://ajax.googleapis.com/ajax/libs/jquery/1.6.3/jquery.min.js'></script>
786 |         <script type='text/javascript'>
787 |             $(document).ready(function(){
788 |                 Array.prototype.diff = function(a) {
789 |                     return this.filter(function(i) {return a.indexOf(i) < 0;});
790 |                 };
791 | 
792 |                 $('#behat .feature h2').click(function(){
793 |                     $(this).parent().toggleClass('jq-toggle-opened');
794 |                 }).parent().addClass('jq-toggle');
795 | 
796 |                 $('#behat .scenario h3').click(function(){
797 |                     $(this).parent().toggleClass('jq-toggle-opened');
798 |                 }).parent().addClass('jq-toggle');
799 | 
800 |                 $('#behat_show_all').click(function(){
801 |                     $('#behat .feature').addClass('jq-toggle-opened');
802 |                     $('#behat .scenario').addClass('jq-toggle-opened');
803 |                 });
804 | 
805 |                 $('#behat_hide_all').click(function(){
806 |                     $('#behat .feature').removeClass('jq-toggle-opened');
807 |                     $('#behat .scenario').removeClass('jq-toggle-opened');
808 |                 });
809 | 
810 |                 $('#behat .summary .counters .scenarios .passed')
811 |                     .addClass('switcher')
812 |                     .click(function(){
813 |                         var scenario = $('.feature .scenario:not(:has(.failed, .pending))');
814 |                         var feature  = scenario.parent();
815 | 
816 |                         $('#behat_hide_all').click();
817 | 
818 |                         scenario.addClass('jq-toggle-opened');
819 |                         feature.addClass('jq-toggle-opened');
820 |                     });
821 | 
822 | 
823 |                 $('#behat .summary .counters .scenarios .failed')
824 |                     .addClass('switcher')
825 |                     .click(function(){
826 |                         var scenario = $('.feature .scenario:has(.failed, .pending)');
827 |                         var feature = scenario.parent();
828 | 
829 |                         $('#behat_hide_all').click();
830 | 
831 |                         scenario.addClass('jq-toggle-opened');
832 |                         feature.addClass('jq-toggle-opened');
833 |                     });
834 | 
835 |                 $('#behat .summary .counters .steps .passed')
836 |                     .addClass('switcher')
837 |                     .click(function(){
838 |                         var scenario = $('.feature .scenario:has(.passed)');
839 |                         var feature  = scenario.parent();
840 | 
841 |                         $('#behat_hide_all').click();
842 | 
843 |                         scenario.addClass('jq-toggle-opened');
844 |                         feature.addClass('jq-toggle-opened');
845 |                     });
846 | 
847 |                 $('#behat .summary .counters .steps .failed')
848 |                     .addClass('switcher')
849 |                     .click(function(){
850 |                         var scenario = $('.feature .scenario:has(.failed)');
851 |                         var feature = scenario.parent();
852 | 
853 |                         $('#behat_hide_all').click();
854 | 
855 |                         scenario.addClass('jq-toggle-opened');
856 |                         feature.addClass('jq-toggle-opened');
857 |                     });
858 | 
859 |                 $('#behat .summary .counters .steps .skipped')
860 |                     .addClass('switcher')
861 |                     .click(function(){
862 |                         var scenario = $('.feature .scenario:has(.skipped)');
863 |                         var feature = scenario.parent();
864 | 
865 |                         $('#behat_hide_all').click();
866 | 
867 |                         scenario.addClass('jq-toggle-opened');
868 |                         feature.addClass('jq-toggle-opened');
869 |                     });
870 | 
871 |                 $('#behat .summary .counters .steps .pending')
872 |                     .addClass('switcher')
873 |                     .click(function(){
874 |                         var scenario = $('.feature .scenario:has(.pending)');
875 |                         var feature = scenario.parent();
876 | 
877 |                         $('#behat_hide_all').click();
878 | 
879 |                         scenario.addClass('jq-toggle-opened');
880 |                         feature.addClass('jq-toggle-opened');
881 |                     });
882 |             });
883 |         </script>";
884 |     }
885 | }
886 | 


--------------------------------------------------------------------------------