omnitest 0.2.1

data/spec/fabricators/validator_fabricator.rb

@@ -0,0 +1,12 @@
+Fabricator(:validator, from: Omnitest::Skeptic::Validator) do
+  initialize_with do
+    callback = @_transient_attributes.delete :callback
+    desc = @_transient_attributes.delete :description
+    scope = @_transient_attributes
+    @_klass.new(desc, scope, &callback)
+  end # Hash based initialization
+  transient description: 'Sample validator'
+  transient suite: LANGUAGES.sample
+  transient scenario: SCENARIO_NAMES.sample
+  transient callback: Proc.new { Proc.new { |_scenario| } } # rubocop:disable Proc
+end

data/spec/fixtures/factorial.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python
+# Content above the snippet is ignored
+
+print 'Hello, world!'
+
+# {{snippet factorial}}
+def factorial(n):
+    if n == 0:
+        return 1
+    else:
+        return n * factorial(n-1)
+# {{endsnippet}}
+
+# So is content below the snippet
+print "{{snippet factorial_result}}"
+print "The result of factorial(7) is:"
+print "  %d" % factorial(7)
+print "{{endsnippet}}"

data/spec/fixtures/omnitest.yaml

@@ -0,0 +1,11 @@
+---
+  projects:
+    ruby:
+      language: 'ruby'
+      basedir: 'sdks/ruby'
+    java:
+      language: 'java'
+      basedir: 'sdks/java'
+    python:
+      language: 'python'
+      basedir: 'sdks/python'

data/spec/fixtures/skeptic.yaml

@@ -0,0 +1,16 @@
+---
+  global_env:
+    LOCALE: <%= ENV['LANG'] %>
+    FAVORITE_NUMBER: 5
+  suites:
+    Katas:
+      env:
+        NAME: 'Max'
+      samples:
+        - hello world
+        - quine
+    Tutorials:
+          env:
+          samples:
+            - deploying
+            - documenting

data/spec/fixtures/src-doc/_scenario.md.erb

@@ -0,0 +1 @@
+I am a generic template that is being used for the <%= scenario %> scenario.

data/spec/fixtures/src-doc/quine.md.erb

@@ -0,0 +1,20 @@
+# Quines
+
+This document is a small collection of quines.  This documentation is generated from a [Omnitest](https://github.com/omnitest/omnitest) that validated each quine.
+
+Examples for <%= scenario %> scenario:
+
+<% Omnitest.projects.each do |project| %>
+## <%= project %> <%#= project.name %>
+
+Source:
+
+```<%#= project.language %>
+<%#= project.sample_code_for scenario %>
+```
+
+Output:
+```
+<%#= project.result_for scenario %>
+```
+<% end %>

data/spec/omnitest/cli_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'omnitest/cli'
+
+module Omnitest
+  module CLI
+    describe OmnitestCLI do
+      let(:kernel) { double(:kernel) }
+      subject { ThorSpy.on(described_class, kernel) }
+      describe 'bootstrap' do
+        context 'with no args' do
+          xit 'calls bootstrap on each project' do
+            expect(kernel).to receive(:exit).with(0)
+            # TODO: Any way to test each project is called? We can't use
+            # `Omnitest.projects` because it will be reloaded.
+            subject.bootstrap
+          end
+        end
+
+        context 'with an existing project' do
+          xit 'calls bootstrap on the project' do
+            # expect(@project).to receive(:bootstrap)
+            expect(kernel).to receive(:exit).with(0)
+            subject.bootstrap('test')
+            expect(subject.stderr.string).to eq('')
+          end
+        end
+
+        context 'with an non-existant project' do
+          it 'fails' do
+            expect(kernel).to receive(:exit).with(1)
+            subject.bootstrap('missing')
+            expect(subject.stderr.string).to include('No projects matching regex `missing\'')
+          end
+        end
+      end
+    end
+  end
+end

data/spec/omnitest/configuration_spec.rb

@@ -0,0 +1,25 @@
+module Omnitest
+  describe Configuration do
+    subject(:configuration) { Configuration.new }
+
+    describe '.project_set' do
+      it 'parses the YAML file and registers the project set' do
+        original_project_set = configuration.project_set
+        configuration.project_set = 'spec/fixtures/omnitest.yaml'
+        new_project_set = configuration.project_set
+        expect(original_project_set).to_not eq(new_project_set)
+        expect(new_project_set).to(be_an_instance_of(ProjectSet))
+      end
+    end
+
+    describe '.manifest' do
+      it 'parses the YAML file and registers the manifest' do
+        original_manifest = configuration.skeptic.manifest
+        configuration.skeptic.manifest_file = 'spec/fixtures/skeptic.yaml'
+        new_manifest = configuration.skeptic.manifest
+        expect(original_manifest).to_not eq(new_manifest)
+        expect(new_manifest).to(be_an_instance_of(Skeptic::TestManifest))
+      end
+    end
+  end
+end

data/spec/omnitest/documentation_generator_spec.rb

@@ -0,0 +1,59 @@
+module Omnitest
+  describe DocumentationGenerator do
+    let(:scenario_name) { 'Quine' }
+    # let(:search_path) { 'spec/fixtures/src-doc' }
+    let(:bound_data) { double }
+
+    describe 'process' do
+      let(:generated_doc) { generator.process bound_data }
+
+      context 'when template is readable' do
+        subject(:generator) { DocumentationGenerator.new('spec/fixtures/src-doc/quine.md.erb', scenario_name) }
+
+        it 'processes the template' do
+          expect(generated_doc).to include 'Examples for Quine scenario:'
+        end
+      end
+
+      context 'when template is not readable' do
+        subject(:generator) { DocumentationGenerator.new('non_existant_file.md', scenario_name) }
+        it 'processes the template' do
+          expect(generated_doc).to be_nil
+        end
+      end
+    end
+
+    describe 'code2doc' do
+      subject(:generator) { DocumentationGenerator.new }
+
+      let(:source_code) do
+        <<-eos.gsub(/^( |\t)+/, '')
+        #!/usr/bin/env ruby
+
+        # Comments are documentation
+        puts 'And this is a code block'
+        eos
+      end
+
+      let(:source_file) do
+        file = Tempfile.new(['source', '.rb'])
+        file.write source_code
+        file.close
+        file.path
+      end
+
+      it 'converts source code to documentation' do
+        expect(generator.code2doc(source_file, 'ruby')).to eq(
+          <<-eos.gsub(/^( |\t)+/, '')
+          Comments are documentation
+
+          ```ruby
+          puts 'And this is a code block'
+          ```
+
+          eos
+        )
+      end
+    end
+  end
+end

data/spec/omnitest/file_finder_spec.rb

@@ -0,0 +1,21 @@
+module Omnitest
+  module Core
+    describe FileSystem do
+      it 'finds files within the search path' do
+        search_path = 'spec/fixtures/src-doc'
+        file = subject.find_file search_path, 'quine'
+        expect(file.relative_path_from path(search_path)).to eq(path('quine.md.erb'))
+      end
+
+      it 'raises Errno::ENOENT if no file is found' do
+        expect { subject.find_file 'spec/fixtures/src-doc', 'quinez' }.to raise_error Errno::ENOENT
+      end
+
+      private
+
+      def path(p)
+        Pathname.new p
+      end
+    end
+  end
+end

data/spec/omnitest/project_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+module Omnitest
+  describe Project do
+    subject(:project) { described_class.new(name: 'test', language: 'ruby', basedir: expected_project_dir) }
+    let(:expected_project_dir) { 'samples/sdks/foo' }
+    let(:psychic) { double('psychic') }
+    let(:psychic) { double('global psychic', basedir: current_dir) }
+    let(:expected_project_path) { Pathname.new(expected_project_dir) }
+
+    before do
+      subject.psychic = psychic
+      Omnitest.psychic = psychic
+    end
+
+    describe '#bootstrap' do
+      # Need an project that's already cloned
+      let(:expected_project_dir) { 'samples/sdks/ruby' }
+
+      it 'executes script/bootstrap' do
+        task = double('task')
+        expect(task).to receive(:execute)
+        expect(psychic).to receive(:task).with('bootstrap').and_return(task)
+        project.bootstrap
+      end
+    end
+
+    describe '#clone' do
+      it 'does nothing if there is no clone option' do
+        expect(psychic).to_not receive(:execute)
+        project.clone
+
+        project.clone
+      end
+
+      context 'with git as a simple string' do
+        it 'clones the repo specified by the string' do
+          project.git = 'git@github.com/foo/bar'
+          expect(psychic).to receive(:execute).with("git clone git@github.com/foo/bar -b master #{expected_project_path}")
+          project.clone
+        end
+      end
+
+      context 'with git as a hash' do
+        it 'clones the repo specified by the repo parameter' do
+          project.git = { repo: 'git@github.com/foo/bar' }
+          expect(psychic).to receive(:execute).with("git clone git@github.com/foo/bar -b master #{expected_project_path}")
+          project.clone
+        end
+
+        it 'clones the repo on the branch specified by the brach parameter' do
+          project.git = { repo: 'git@github.com/foo/bar', branch: 'quuz' }
+          expect(psychic).to receive(:execute).with("git clone git@github.com/foo/bar -b quuz #{expected_project_path}")
+          project.clone
+        end
+
+        it 'clones the repo to the location specified by the to parameter' do
+          project.git = { repo: 'git@github.com/foo/bar', to: 'sdks/foo' }
+          expect(psychic).to receive(:execute).with('git clone git@github.com/foo/bar -b master sdks/foo')
+          project.clone
+        end
+      end
+    end
+  end
+end

data/spec/omnitest_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Omnitest do
+  describe '.validate' do
+    context 'block given' do
+      it 'creates and registers a validator' do
+        Omnitest.validate 'custom validator', suite: 'test', scenario: 'test' do |_scenario|
+          # Validate the scenario results
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'omnitest'
+require 'fabrication'
+require 'thor_spy'
+require 'aruba'
+require 'aruba/api'
+
+# Config required for project
+RSpec.configure do | config |
+  config.include Aruba::Api
+  config.before(:example) do
+    @aruba_timeout_seconds = 30
+    clean_current_dir
+  end
+end
+
+RSpec.configure do |c|
+  c.before(:each) do
+    Omnitest.reset
+  end
+  c.expose_current_running_example_as :example
+end
+
+# For Fabricators
+LANGUAGES = %w(java ruby python nodejs c# golang php)
+SCENARIO_NAMES = [
+  'hello world',
+  'quine',
+  'my_kata'
+]

data/spec/thor_spy.rb

@@ -0,0 +1,66 @@
+class ThorSpy
+  attr_reader :stdout, :stdin, :stderr
+  attr_accessor :app
+
+  def self.on(app, kernel = Kernel)
+    new([], StringIO.new, StringIO.new, StringIO.new, kernel).with_app(app)
+  end
+
+  # Allow everything fun to be injected from the outside while defaulting to normal implementations.
+  def initialize(argv = [], stdin = STDIN, stdout = STDOUT, stderr = STDERR, kernel = Kernel)
+    @argv, @stdin, @stdout, @stderr, @kernel = argv, stdin, stdout, stderr, kernel
+  end
+
+  def app
+    fail 'You must set the Thor app via ThorSpy.on or #with_app before calling execute!' unless @app
+    @app
+  end
+
+  def with_app(app)
+    fail ArgumentError, 'app should be a class' unless app.is_a? Class
+    fail ArgumentError, 'app should be a subclass of Thor' unless app < Thor
+    @app = app
+    self
+  end
+
+  def execute!
+    exit_code = begin
+      # Thor accesses these streams directly rather than letting them be injected, so we replace them...
+      $stderr = @stderr
+      $stdin = @stdin
+      $stdout = @stdout
+
+      fail 'You must set the Thor app' if @app.nil?
+
+      # Run our normal Thor app the way we know and love.
+      app.start(@argv)
+
+      # Thor::Base#start does not have a return value, assume success if no exception is raised.
+      0
+    rescue StandardError => e
+      # The ruby interpreter would pipe this to STDERR and exit 1 in the case of an unhandled exception
+      b = e.backtrace
+      b.unshift("#{b.shift}: #{e.message} (#{e.class})")
+      @stderr.puts(b.map { |s| "\tfrom #{s}" }.join("\n"))
+      1
+    rescue SystemExit => e
+      e.status
+    ensure
+      # ...then we put them back.
+      $stderr = STDERR
+      $stdin = STDIN
+      $stdout = STDOUT
+    end
+
+    # Proxy our exit code back to the injected kernel.
+    @kernel.exit(exit_code)
+  end
+
+  def method_missing(meth, *args)
+    # I don't think a block makes sense, unless it's stdin.
+    return super if block_given?
+
+    @argv = [meth.to_s].concat(args)
+    execute!
+  end
+end

data/tests/omnitest/bootstrap_validations.rb

@@ -0,0 +1,7 @@
+# -*- encoding: utf-8 -*-
+
+Omnitest.validate 'Bootstraps java and ruby, but not python', suite: 'CLI', scenario: 'bootstrap' do |scenario|
+  expect(scenario.result.stdout).to include('-----> Bootstrapping java')
+  expect(scenario.result.stdout).to include('-----> Bootstrapping ruby')
+  expect(scenario.result.stdout).to_not include('-----> Bootstrapping python')
+end

data/tests/omnitest/show_validations.rb

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+
+Omnitest.validate 'Expected output for show', suite: 'Reports', scenario: 'show' do |scenario|
+  expected_output = <<-eos
+katas-hello_world-ruby:                            Fully Verified (2 of 2)
+  Test suite:                                        Katas
+  Test scenario:                                     hello world
+  Project:                                           ruby
+  Source:                                            sdks/ruby/katas/hello_world.rb
+  Execution result:
+    Exit Status:                                       0
+    Stdout:
+      Hello, world!
+    Stderr:
+  Validations:
+    Hello world validator:                             ✓ Passed
+    default validator:                                 ✓ Passed
+  Data from spies:
+eos
+  cleaned_up = scenario.result.stdout.gsub(/\e\[(\d+)(;\d+)*m/, '').gsub("\r\n", "\n")
+  expect(cleaned_up).to include(expected_output)
+end