omnitest 0.2.1

data/lib/omnitest/command/generators/dashboard.rb

@@ -0,0 +1,148 @@
+require 'json'
+require 'tilt'
+require 'haml'
+require 'omnitest/reporters'
+
+module Omnitest
+  module Command
+    class Generate
+      class Dashboard < Thor::Group
+        include Thor::Actions
+        include Omnitest::Core::FileSystem
+        module Helpers
+          include Omnitest::Core::Util::String
+          # include Padrino::Helpers::RenderHelpers # requires sinatra-compatible render method
+          include Padrino::Helpers::TagHelpers
+          include Padrino::Helpers::OutputHelpers
+          include Padrino::Helpers::AssetTagHelpers
+
+          def projects
+            Omnitest.projects.map do |project|
+              slugify(project.name)
+            end
+          end
+
+          def results
+            rows = []
+            grouped_scenarios = Omnitest.scenarios.group_by { |scenario| [scenario.suite, scenario.name] }
+            grouped_scenarios.each do |(suite, name), scenarios|
+              row = {
+                slug_prefix: slugify(suite, name),
+                suite: suite,
+                scenario: name
+              }
+              Omnitest.projects.each do |project|
+                scenario = scenarios.find { |s| s.psychic.name == project.name }
+                row[slugify(project.name)] = scenario.status_description
+              end
+              rows << row
+            end
+            rows
+          end
+
+          def as_json(data)
+            JSON.dump(data)
+          rescue => e
+            JSON.dump(to_utf(data))
+          end
+
+          def to_utf(data)
+            Hash[
+              data.collect do |k, v|
+                if v.respond_to?(:collect)
+                  [k, to_utf(v)]
+                elsif v.respond_to?(:encoding)
+                  [k, v.dup.encode('UTF-8')]
+                else
+                  [k, v]
+                end
+              end
+            ]
+          end
+
+          def status(status, msg = nil, _color = :cyan)
+            "<strong>#{status}</strong> <em>#{msg}</em>"
+          end
+
+          def bootstrap_color(color)
+            bootstrap_classes = {
+              green: 'success',
+              cyan: 'primary',
+              red: 'danger',
+              yellow: 'warning'
+            }
+            bootstrap_classes.key?(color) ? bootstrap_classes[color] : color
+          end
+        end
+
+        include Helpers
+
+        class_option :destination, default: 'reports/'
+        class_option :code_style, default: 'github'
+
+        def self.source_root
+          Omnitest::Reporters::GENERATORS_DIR
+        end
+
+        def report_name
+          @report_name ||= self.class.name.downcase.split('::').last
+        end
+
+        def add_framework_to_source_root
+          source_paths.map do | path |
+            path << "/#{report_name}"
+          end
+        end
+
+        def set_destination_root
+          self.destination_root = options[:destination]
+        end
+
+        def setup
+          @tabs = {}
+          @tabs['Dashboard'] = 'dashboard.html'
+          Omnitest.update_config!(options)
+          Omnitest.setup
+        end
+
+        def create_spy_reports
+          reports = Omnitest::Skeptic::Spies.reports[:dashboard]
+          reports.each do | report_class |
+            if report_class.respond_to? :tab_name
+              @active_tab = report_class.tab_name
+              @tabs[@active_tab] = report_class.tab_target
+            else
+              @active_tab = nil
+            end
+            report_class.tabs = @tabs
+            invoke report_class, args, options
+          end if reports
+        end
+
+        def copy_assets
+          directory Omnitest::Reporters::ASSETS_DIR, 'assets'
+        end
+
+        def copy_base_structure
+          @active_tab = 'Dashboard'
+          directory 'files', '.'
+        end
+
+        def create_results_json
+          create_file 'matrix.json', as_json(results)
+        end
+
+        def create_test_reports
+          template_file = find_in_source_paths('templates/_test_report.html.haml')
+          template = Tilt.new(template_file)
+          Omnitest.scenarios.each do |scenario|
+            @scenario = scenario
+            add_file "details/#{scenario.slug}.html" do
+              template.render(self)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnitest/command/generators/documentation.rb

@@ -0,0 +1,119 @@
+require 'json'
+require 'omnitest/reporters'
+
+module Omnitest
+  module Command
+    class Generate
+      class Documentation < Thor::Group
+        include Thor::Actions
+        include Omnitest::Core::FileSystem
+        include Omnitest::Psychic::Code2Doc::CodeHelper
+        include Omnitest::Psychic::Code2Doc::SnippetHelper
+
+        BUILTIN_GENERATORS = Dir["#{Omnitest::Reporters::GENERATORS_DIR}/*"].select { |f| File.directory? f }
+
+        attr_reader :projects, :project, :project_name, :project_basedir
+
+        class << self
+          def generators
+            BUILTIN_GENERATORS + Dir['tests/omnitest/generators/*'].select { |f| File.directory? f }
+          end
+
+          def generator_names
+            generators.map { |d| File.basename d }
+          end
+
+          def generator_not_found(generator)
+            s = "ERROR: No generator named #{generator}, available generators: "
+            s << generator_names.join(', ')
+          end
+
+          def source_root
+            Omnitest::RESOURCES_DIR
+          end
+        end
+
+        argument :project_regexp, default: 'all'
+        argument :scenario_regexp, default: 'all'
+        class_option :source, default: 'doc-src/', desc: 'Source folder with documentation templates'
+        class_option :destination, default: 'docs/', desc: 'Destination for generated documentation'
+        class_option :template, desc: 'The name or location of a custom generator template'
+        class_option :scope, desc: 'Whether the template should be applied once (global), per project, or per scenario',
+                             enum: %w(global project scenario), default: 'global'
+        class_option :failed, type: :boolean, desc: 'Only list tests that failed / passed'
+        class_option :skipped, type: :boolean, desc: 'Only list tests that were skipped / executed'
+        class_option :samples, type: :boolean, desc: 'Only list tests that have sample code / do not have sample code'
+        class_option :travis, type: :boolean, desc: "Enable/disable delegation to travis-build, if it's available"
+        def setup
+          Omnitest.update_config!(options)
+          Omnitest.setup
+        end
+
+        def set_source_and_destination
+          unless options[:template] || File.exist?(options[:source])
+            abort 'Either the --source directory must exist, or --template must be specified'
+          end
+
+          if options[:template]
+            generator = self.class.generators.find { |d| File.basename(d) == options[:template] }
+            abort self.class.generator_not_found(generator) if generator.nil?
+            source_paths << generator
+          else
+            source_paths << Pathname(options[:source]).expand_path
+          end
+
+          self.destination_root = options[:destination]
+        end
+
+        def apply_template
+          if options[:template]
+            generator_script = "#{options[:template]}_template.rb"
+            apply(generator_script)
+          else
+            case options[:scope]
+            when 'global'
+              @projects = Omnitest.filter_projects(project_regexp)
+              process_directory
+            when 'project'
+              Omnitest.filter_projects(project_regexp).each do | project |
+                bind_project_variables(project)
+                process_directory
+              end
+            when 'scenario'
+              Omnitest.scenarios(project_regexp, scenario_regexp).each do | scenario |
+                bind_scenario_variables(scenario)
+                process_directory
+              end
+            end
+          end
+        end
+
+        private
+
+        def scenario_output_snippet(project_regex, scenario_regex, opts = {})
+          scenario = Omnitest.scenarios(project_regex, scenario_regex).first
+          fail "Output is not available for #{scenario_name} because that scenario does not exist" unless scenario
+          fail "Output is not available for #{scenario_name} because it has not been executed" unless scenario.result
+          snippetize_output(scenario.result, opts)
+        end
+
+        def process_directory
+          directory Pathname(options[:source]).expand_path, Pathname(options[:destination]).expand_path
+        end
+
+        def bind_project_variables(project)
+          @project = project
+          @project_name = project.name
+          @project_basedir = project.basedir
+        end
+
+        def bind_scenario_variables(scenario)
+          bind_project_variables(scenario.project)
+          @scenario = scenario
+          @scenario_name = scenario.name
+          @scenario_slug = scenario.slug
+        end
+      end
+    end
+  end
+end

data/lib/omnitest/command/list.rb

@@ -0,0 +1,62 @@
+require 'omnitest/reporters'
+module Omnitest
+  module Command
+    class List < Omnitest::Command::Base
+      include Omnitest::Reporters
+
+      def call
+        setup
+        @reporter = Omnitest::Reporters.reporter(options[:format], shell)
+        tests = parse_subcommand(args.shift, args.shift)
+
+        table = [header_row]
+        table += tests.map do | scenario |
+          row(scenario)
+        end
+        print_table(table)
+      end
+
+      private
+
+      def header_row
+        row = []
+        row << colorize('Suite', :green)
+        row << colorize('Scenario', :green)
+        row << colorize('Project', :green)
+        row << colorize('Status', :green)
+        row << colorize('Source', :green) if options[:source]
+        row
+      end
+
+      def row(scenario)
+        row = []
+        row << color_pad(scenario.suite)
+        row << color_pad(scenario.name)
+        row << color_pad(scenario.psychic.name)
+        row << format_status(scenario)
+        if options[:source]
+          source_file = scenario.absolute_source_file ? scenario.source_file : colorize('<No code sample>', :red)
+          row << source_file
+        end
+        row
+      end
+
+      def print_table(*args)
+        @reporter.print_table(*args)
+      end
+
+      def colorize(string, *args)
+        return string unless @reporter.respond_to? :set_color
+        @reporter.set_color(string, *args)
+      end
+
+      def color_pad(string)
+        string + colorize('', :white)
+      end
+
+      def format_status(scenario)
+        colorize(scenario.status_description, scenario.status_color)
+      end
+    end
+  end
+end

data/lib/omnitest/command/project_action.rb

@@ -0,0 +1,26 @@
+require 'benchmark'
+
+module Omnitest
+  module Command
+    class ProjectAction < Omnitest::Command::Base
+      include RunAction
+
+      # Invoke the command.
+      def call
+        banner "Starting Omnitest (v#{Omnitest::VERSION})"
+        elapsed = Benchmark.measure do
+          setup
+          project_regex = args.shift
+          if %w(task workflow).include? action # a bit hacky...
+            argument = project_regex
+            project_regex = args.shift
+            args.unshift argument
+          end
+          projects = select_projects(project_regex, options)
+          run_action(projects, action, options[:concurrency], *args)
+        end
+        banner "Omnitest is finished. #{Core::Util.duration(elapsed.real)}"
+      end
+    end
+  end
+end

data/lib/omnitest/command/scenario_action.rb

@@ -0,0 +1,20 @@
+require 'benchmark'
+
+module Omnitest
+  module Command
+    class ScenarioAction < Omnitest::Command::Base
+      include RunAction
+
+      # Invoke the command.
+      def call
+        banner "Starting Omnitest (v#{Omnitest::VERSION})"
+        elapsed = Benchmark.measure do
+          setup
+          scenarios = parse_subcommand(args.shift, args.shift)
+          run_action(scenarios, action, options[:concurrency])
+        end
+        banner "Omnitest is finished. #{Core::Util.duration(elapsed.real)}"
+      end
+    end
+  end
+end

data/lib/omnitest/command/show.rb

@@ -0,0 +1,148 @@
+require 'omnitest/reporters'
+
+module Omnitest
+  module Command
+    class Show < Omnitest::Command::Base # rubocop:disable Metrics/ClassLength
+      include Omnitest::Reporters
+      include Omnitest::Core::Util::String
+      include Omnitest::Core::FileSystem
+
+      def call
+        @indent_level = 0
+        setup
+        @reporter = Omnitest::Reporters.reporter(options[:format], shell)
+        scenarios = parse_subcommand(args.shift, args.shift)
+
+        scenarios.each do | scenario |
+          status_color = scenario.status_color.to_sym
+          status(scenario.slug, colorize(scenario.status_description, status_color), status_color)
+          indent do
+            status('Test suite', scenario.suite)
+            status('Test scenario', scenario.name)
+            status('Project', scenario.psychic.name)
+            source_file = if scenario.code_sample
+                            Core::FileSystem.relativize(scenario.absolute_source_file, Dir.pwd)
+                          else
+                            colorize('<No code sample>', :red)
+                          end
+            status('Source', source_file)
+            display_source(scenario)
+            display_execution_result(scenario)
+            display_validations(scenario)
+            display_spy_data(scenario)
+          end
+        end
+      end
+
+      private
+
+      def reformat(string)
+        return if string.nil? || string.empty?
+
+        indent do
+          string.gsub(/^/, indent)
+        end
+      end
+
+      def indent
+        if block_given?
+          @indent_level += 2
+          result = yield
+          @indent_level -= 2
+          result
+        else
+          ' ' * @indent_level
+        end
+      end
+
+      def display_source(test)
+        return if !options[:source] || !test.source?
+
+        shell.say test.highlighted_code
+      end
+
+      def display_execution_result(test)
+        return if test.result.nil? || test.result.execution_result.nil?
+
+        execution_result = test.result.execution_result
+        status 'Execution result'
+        indent do
+          status('Exit Status', execution_result.exitstatus)
+          status 'Stdout'
+          say reformat(execution_result.stdout)
+          status 'Stderr'
+          say reformat(execution_result.stderr)
+        end
+      end
+
+      def display_validations(test)
+        return if test.validations.nil?
+
+        status 'Validations'
+        indent do
+          test.validations.each do | name, validation |
+            status(name, indicator(validation))
+            indent do
+              status 'Error message', validation.error if validation.error
+              unless !options[:source] || !validation.error_source?
+                status 'Validator source'
+                say highlight(validation.error_source, language: 'ruby')
+              end
+            end
+          end
+        end
+      end
+
+      def display_spy_data(test)
+        return if test.spy_data.nil?
+
+        status 'Data from spies'
+        indent do
+          test.spy_data.each do |_spy, data|
+            indent do
+              data.each_pair do |k, v|
+                status(k, v)
+              end
+            end
+          end
+        end
+      end
+
+      def say(msg)
+        shell.say msg if msg
+      end
+
+      def status(status, msg = nil, color = :cyan, colwidth = 50)
+        msg = yield if block_given?
+        shell.say(indent)
+        status = shell.set_color("#{status}:", color, true)
+        # The built-in say_status is right-aligned, we want left-aligned
+        shell.say format("%-#{colwidth}s %s", status, msg).rstrip
+      end
+
+      def print_table(*args)
+        @reporter.print_table(*args)
+      end
+
+      def colorize(string, *args)
+        return string unless @reporter.respond_to? :set_color
+        @reporter.set_color(string, *args)
+      end
+
+      def color_pad(string)
+        string + colorize('', :white)
+      end
+
+      def indicator(validation)
+        case validation.status
+        when :passed
+          colorize("\u2713 Passed", :green)
+        when :failed
+          colorize('x Failed', :red)
+        else
+          colorize(validation.status, :yellow)
+        end
+      end
+    end
+  end
+end