turnip_formatter 0.2.1 → 0.2.2

data/lib/turnip_formatter/template/tab/feature_statistics.rb

@@ -1,78 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require 'turnip_formatter/template'
-
-module TurnipFormatter
-  class Template
-    module Tab
-      class FeatureStatistics
-        attr_reader :features
-
-        #
-        # @param [Array]  passed_examples  Array of TurnipFormatter::Scenario
-        #
-        def initialize(scenarios)
-          @features = scenarios.group_by { |s| s.feature_name }
-        end
-
-        def build
-          html = <<-EOS
-            <table>
-              <thead>
-                <tr>
-                  <th>Feature</th>
-                  <th>Scearios</th>
-                  <th>passed</th>
-                  <th>failed</th>
-                  <th>pending</th>
-                  <th>status</th>
-                </tr>
-              </thead>
-              <tbody>
-          EOS
-          
-          html += @features.map do |feature_name, scenarios|
-            info = feature_analysis(feature_name, scenarios)
-            build_tr(info)
-          end.join
-
-          html += '</tbody></table>'
-        end
-
-        private
-
-        def feature_analysis(name, scenarios)
-          status_group = scenarios.group_by { |s| s.status }
-
-          info = {
-            name: name,
-            scenarios: scenarios.count,
-            passed: status_count(status_group["passed"]),
-            failed: status_count(status_group["failed"]),
-            pending: status_count(status_group["pending"])
-          }
-          info[:status] = info[:failed].zero? ? (info[:pending].zero? ? 'passed' : 'pending') : 'failed'
-
-          info
-        end
-
-        def status_count(scenarios)
-          scenarios.nil? ? 0 : scenarios.count
-        end
-
-        def build_tr(info)
-          <<-EOS
-            <tr>
-              <td>#{info[:name]}</td>
-              <td>#{info[:scenarios]}</td>
-              <td>#{info[:passed]}</td>
-              <td>#{info[:failed]}</td>
-              <td>#{info[:pending]}</td>
-              <td class="#{info[:status]}">#{info[:status]}</td>
-            </tr>
-          EOS
-        end
-      end
-    end
-  end
-end

data/lib/turnip_formatter/template/tab/speed_statistics.rb

@@ -1,61 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require 'turnip_formatter/template'
-require 'ostruct'
-
-module TurnipFormatter
-  class Template
-    module Tab
-      class SpeedStatistics
-        attr_reader :scenarios
-
-        #
-        # @param [Array]  passed_examples  Array of TurnipFormatter::Scenario::Pass
-        #
-        def initialize(passed_scenarios)
-          @scenarios = passed_scenarios.map do |s|
-            OpenStruct.new(
-              {
-                id: s.id,
-                feature_name: s.feature_name,
-                name: s.name,
-                run_time: s.run_time
-              }
-            )
-          end.sort { |a, b| a.run_time <=> b.run_time }
-        end
-
-        def build
-          html = <<-EOS
-            <table>
-              <thead>
-                <tr>
-                  <th>Feature</th>
-                  <th>Scenario</th>
-                  <th>Duration</th>
-                </tr>
-              </thead>
-              <tbody>
-          EOS
-
-          html += scenarios.map do |scenario|
-            <<-EOS
-                <tr>
-                  <td><span>#{scenario.feature_name}</span></td>
-                  <td><a href=\"\##{scenario.id}\">#{scenario.name}</a></td>
-                  <td><span>#{scenario.run_time}</span> sec</td>
-                </tr>
-            EOS
-          end.join
-
-          html += <<-EOS
-              </tbody>
-            </table>
-          EOS
-
-          html
-        end
-      end
-    end
-  end
-end

data/lib/turnip_formatter/template/tab/tag_statistics.rb

@@ -1,101 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require 'turnip_formatter/template'
-
-module TurnipFormatter
-  class Template
-    module Tab
-      class TagStatistics
-        attr_reader :scenarios
-
-        #
-        # @param [Array]  passed_examples  Array of TurnipFormatter::Scenario
-        #
-        def initialize(scenarios)
-          @scenarios = scenarios
-        end
-
-        def build
-          html = <<-EOS
-            <table>
-              <thead>
-                <tr>
-                  <th>Tag</th>
-                  <th>Scearios</th>
-                  <th>passed</th>
-                  <th>failed</th>
-                  <th>pending</th>
-                  <th>status</th>
-                </tr>
-              </thead>
-              <tbody>
-          EOS
-          
-          html += tag_analysis.map { |info| build_tr(info) }.join
-          html += '</tbody></table>'
-        end
-
-        private
-
-        def tag_analysis
-          group_by_tag.map do |tag, scenarios|
-            status_group = scenarios.group_by { |s| s[:scenario].status }
-            info = OpenStruct.new(
-              name: tag,
-              scenarios: scenarios.count,
-              passed: status_count(status_group["passed"]),
-              failed: status_count(status_group["failed"]),
-              pending: status_count(status_group["pending"]),
-              status: 'failed'
-            )
-            info.status = (info.pending.zero? ? 'passed' : 'pending') if info.failed.zero?
-            info
-          end
-        end
-
-        #
-        # Image...
-        #
-        # [
-        #   { tags: [:a, :b], val: 3 },
-        #   { tags: [:a], val: 4 },
-        #   { tags: [:b], val: 5 },
-        # ]
-        # # => [
-        #        a: [3, 4],
-        #        b: [3, 5]
-        #      ]
-        # 
-        #
-        def group_by_tag
-          scenarios.map do |scenario|
-            if scenario.tags.empty?
-              { name: 'turnip', scenario: scenario }
-            else
-              scenario.tags.map do |tag|
-                { name: '@' + tag, scenario: scenario }
-              end
-            end
-          end.flatten.group_by { |s| s[:name] }.sort
-        end
-
-        def status_count(scenarios)
-          scenarios.nil? ? 0 : scenarios.count
-        end
-
-        def build_tr(info)
-          <<-EOS
-            <tr>
-              <td>#{info.name}</td>
-              <td>#{info.scenarios}</td>
-              <td>#{info.passed}</td>
-              <td>#{info.failed}</td>
-              <td>#{info.pending}</td>
-              <td class="#{info.status}">#{info.status}</td>
-            </tr>
-          EOS
-        end
-      end
-    end
-  end
-end

data/spec/turnip_formatter/template/tab/feature_statistics_spec.rb

@@ -1,87 +0,0 @@
-require 'spec_helper'
-require 'turnip_formatter/template/tab/feature_statistics'
-
-module TurnipFormatter
-  class Template
-    module Tab
-      describe FeatureStatistics do
-        include_context 'turnip_formatter scenario setup'
-        include_context 'turnip_formatter standard scenario metadata'
-
-        let :base_scenario do
-          TurnipFormatter::Scenario::Pass.new(example)
-        end
-
-        let :statistics do
-          FeatureStatistics.new(scenarios)
-        end
-
-        context 'feature only passed scenario' do
-          let :scenarios do
-            # Feature: Hago (passed:2 failed:0, pending:0)
-            ['passed', 'passed'].map do |status|
-              scenario = base_scenario.dup
-              scenario.stub(:status).and_return(status)
-              scenario
-            end
-          end
-
-          describe '#feature_analysis' do
-            it 'should get passed feature information' do
-              info = statistics.send(:feature_analysis, 'Hoge', scenarios)
-              expect(info[:name]).to eq 'Hoge'
-              expect(info[:passed]).to eq 2
-              expect(info[:failed]).to be_zero
-              expect(info[:pending]).to be_zero
-              expect(info[:status]).to eq 'passed'
-            end
-          end
-        end
-
-        context 'feature with failed scenario' do
-          let :scenarios do
-            # Feature: Hoge (passed:1 failed:2, pending:0)
-            ['passed', 'failed', 'failed'].map do |status|
-              scenario = base_scenario.dup
-              scenario.stub(:status).and_return(status)
-              scenario
-            end
-          end
-
-          describe '#feature_analysis' do
-            it 'should get failed feature information' do
-              info = statistics.send(:feature_analysis, 'Fuga', scenarios)
-              expect(info[:name]).to eq 'Fuga'
-              expect(info[:passed]).to eq 1
-              expect(info[:failed]).to eq 2
-              expect(info[:pending]).to be_zero
-              expect(info[:status]).to eq 'failed'
-            end
-          end
-        end
-
-        context 'feature with pending scenario' do
-          let :scenarios do
-            # Feature: Fuga (passed:1 failed:0, pending:1)
-            ['passed', 'pending'].map do |status|
-              scenario = base_scenario.dup
-              scenario.stub(:status).and_return(status)
-              scenario
-            end
-          end
-
-          describe '#feature_analysis' do
-            it 'should get pending feature information' do
-              info = statistics.send(:feature_analysis, 'Hago', scenarios)
-              expect(info[:name]).to eq 'Hago'
-              expect(info[:passed]).to eq 1
-              expect(info[:failed]).to be_zero
-              expect(info[:pending]).to eq 1
-              expect(info[:status]).to eq 'pending'
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/turnip_formatter/template/tab/speed_statistics_spec.rb

@@ -1,56 +0,0 @@
-require 'spec_helper'
-require 'turnip_formatter/template/tab/speed_statistics'
-
-module TurnipFormatter
-  class Template
-    module Tab
-      describe SpeedStatistics do
-        include_context 'turnip_formatter scenario setup'
-        include_context 'turnip_formatter standard scenario metadata'
-
-        let :passed_scenarios do
-          ([example] * 3).map do |ex|
-            TurnipFormatter::Scenario::Pass.new(ex)
-          end.each { |s| s.stub(:run_time).and_return(rand) }
-        end
-
-        let :statistics do
-          SpeedStatistics.new(passed_scenarios)
-        end
-
-        describe '#build' do
-          it 'should get string as HTML table' do
-            scenarios = statistics.scenarios
-            html = statistics.build
-
-            scenarios.each do |scenario|
-              tag_scenario_name = "<a href=\"\##{scenario.id}\">#{scenario.name}</a>"
-              tag_run_time = "<span>#{scenario.run_time}</span>"
-              tag_feature_name = "<span>#{scenario.feature_name}</span>"
-
-              expect_match = [
-                '<tr>',
-                "<td>#{tag_feature_name}</td>",
-                "<td>#{tag_scenario_name}</td>",
-                "<td>#{tag_run_time} sec</td>",
-                '</tr>'
-              ].join('[[:space:]]+')
-
-              expect(html).to match %r(#{expect_match})
-            end
-          end
-        end
-
-        describe '#scenarios' do
-          it 'should get array of scenario' do
-            scenarios = statistics.scenarios
-            expect(scenarios).to have(3).elements
-
-            run_time_list = scenarios.map(&:run_time)
-            expect(run_time_list.sort).to eq run_time_list
-          end
-        end
-      end
-    end
-  end
-end

data/spec/turnip_formatter/template/tab/tag_statistics_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-require 'turnip_formatter/template/tab/tag_statistics'
-
-module TurnipFormatter
-  class Template
-    module Tab
-      describe TagStatistics do
-        include_context 'turnip_formatter scenario setup'
-        include_context 'turnip_formatter standard scenario metadata'
-
-        let :base_scenario do
-          TurnipFormatter::Scenario::Pass.new(example)
-        end
-
-        let :scenarios do
-          scenarios = []
-
-         # | tag   | scenarios | passed | failed | pending | status  |
-         # |-------+-----------+--------+--------+---------+---------|
-         # | none  |         1 |      1 |      0 |       0 | status  |
-         # | @bar  |         2 |      0 |      1 |       1 | failed  |
-         # | @foo  |         1 |      0 |      1 |       0 | failed  |
-         # | @hoge |         1 |      1 |      0 |       1 | pending |
-
-          # Failed scenario have tags @hoge and @fuga
-          scenario = base_scenario.dup
-          scenario.stub(:tags).and_return(['foo', 'bar'])
-          scenario.stub(:status).and_return('failed')
-          scenarios << scenario
-
-          # Passed scenario no have tags
-          scenario = base_scenario.dup
-          scenario.stub(:tags).and_return([])
-          scenario.stub(:status).and_return('passed')
-          scenarios << scenario
-
-          # Passed scenario have tags @hoge
-          scenario = base_scenario.dup
-          scenario.stub(:tags).and_return(['hoge'])
-          scenario.stub(:status).and_return('passed')
-          scenarios << scenario
-
-          # Pending scenario have tags @fuga and @hago
-          scenario = base_scenario.dup
-          scenario.stub(:tags).and_return(['bar', 'hoge'])
-          scenario.stub(:status).and_return('pending')
-          scenarios << scenario
-        end
-
-        let :statistics do
-          TagStatistics.new(scenarios)
-        end
-
-        describe '#tag_analysis' do
-          let :results do
-            statistics.send(:tag_analysis)
-          end
-
-          it 'should get results sort by tag name' do
-            expect(results.map(&:name)).to eq ['@bar', '@foo', '@hoge', 'turnip']
-          end
-
-          it 'should get count of each status' do
-            # @bar
-            res = results[0]
-            expect([res.passed, res.failed, res.pending]).to eq [0, 1, 1]
-            expect(res.status).to eq 'failed'
-
-            # @foo
-            res = results[1]
-            expect([res.passed, res.failed, res.pending]).to eq [0, 1, 0]
-            expect(res.status).to eq 'failed'
-
-            # @hoge
-            res = results[2]
-            expect([res.passed, res.failed, res.pending]).to eq [1, 0, 1]
-            expect(res.status).to eq 'pending'
-
-            # no tags (turnip)
-            res = results[3]
-            expect([res.passed, res.failed, res.pending]).to eq [1, 0, 0]
-            expect(res.status).to eq 'passed'
-          end
-        end
-      end
-    end
-  end
-end