polytrix 0.0.1 → 0.1.0.pre

data/spec/fabricators/manifest_fabricator.rb

@@ -0,0 +1,50 @@
+require 'hashie/mash'
+
+# Fabricates test manifests (.polytrix_tests.yml files)
+LANGUAGES = %w(java ruby python nodejs c# golang php)
+SAMPLE_NAMES = [
+  'hello world',
+  'quine',
+  'my_kata'
+]
+
+Fabricator(:manifest, from: Polytrix::Manifest) do
+  initialize_with { @_klass.new to_hash } # Hash based initialization
+  transient suite_count: 3
+  transient samples_per_suite: 3
+  global_env do
+    {
+      VAR1: 1,
+      VAR2: 2
+    }
+  end
+  suites do |attr|
+    suite_count = attr[:suite_count]
+    if suite_count
+      suites = attr[:suite_count].times.reduce({}) do |h, i|
+        name = LANGUAGES[i] ||= "suite_#{i}"
+        h[name] = Fabricate(:suite, name: name, sample_count: attr[:samples_per_suite])
+        h
+      end
+      suites
+    else
+      nil
+    end
+  end
+end
+
+Fabricator(:suite, from: Hashie::Mash) do
+  initialize_with { @_klass.new to_hash } # Hash based initialization
+  transient name: LANGUAGES[0]
+  transient sample_count: 3
+  samples do |attr|
+    sample_count = attr[:sample_count]
+    if sample_count
+      attr[:sample_count].times.map do |i|
+        SAMPLE_NAMES[i] ||= "sample_#{i}"
+      end
+    else
+      nil
+    end
+  end
+end

data/spec/fabricators/validator_fabricator.rb

@@ -0,0 +1,12 @@
+require 'hashie/mash'
+
+Fabricator(:validator, from: Polytrix::Validator) do
+  initialize_with do
+    callback = @_transient_attributes.delete :callback
+    scope = @_transient_attributes
+    @_klass.new(scope, &callback)
+  end # Hash based initialization
+  transient suite: LANGUAGES.sample
+  transient sample: SAMPLE_NAMES.sample
+  transient callback: Proc.new { Proc.new { |challenge| } } # rubocop:disable Proc
+end

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/polytrix/challenge_runner_spec.rb

@@ -1,8 +1,8 @@
 module Polytrix
   describe ChallengeRunner do
-    subject(:runner) { ChallengeRunner.createRunner }
+    subject(:runner) { ChallengeRunner.create_runner }
     let(:challenge) do
-      Challenge.new :name => 'factorial', :source_file => 'spec/fixtures/factorial.py', :basedir => 'spec/fixtures'
+      Fabricate(:challenge, name: 'factorial', source_file: 'spec/fixtures/factorial.py', basedir: 'spec/fixtures')
     end
 
     describe '#run_challenge' do
@@ -11,4 +11,4 @@ module Polytrix
       end
     end
   end
-end
+end

data/spec/polytrix/challenge_spec.rb

@@ -1,9 +1,8 @@
 module Polytrix
   describe Challenge do
     subject(:challenge) do
-      implementor = Polytrix::Implementor.new :name => 'some_sdk', :basedir => 'spec/fixtures'
-      builder = Polytrix::ChallengeBuilder.new implementor
-      builder.build :name => 'factorial', :vars => {}
+      implementor = Polytrix::Implementor.new name: 'some_sdk', basedir: 'spec/fixtures'
+      implementor.build_challenge name: 'factorial', vars: {}
     end
 
     describe '#run' do
@@ -17,4 +16,4 @@ module Polytrix
       end
     end
   end
-end
+end

data/spec/polytrix/cli_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'polytrix/cli'
+
+module Polytrix
+  module CLI
+    describe Main do
+      let(:kernel) { double(:kernel) }
+      subject { ThorSpy.on(described_class, kernel) }
+      describe 'bootstrap' do
+        context 'with no args' do
+          it 'calls Polytrix.bootstrap' do
+            expect(kernel).to receive(:exit).with(0)
+            expect(Polytrix).to receive(:bootstrap)
+            subject.bootstrap
+          end
+        end
+
+        context 'with an existing SDK' do
+          before do
+            @implementor = Polytrix.configuration.implementor name: 'test', basedir: '.'
+          end
+
+          it 'calls bootstrap on the SDK' do
+            expect(@implementor).to receive(:bootstrap)
+            expect(kernel).to receive(:exit).with(0)
+            expect(subject.stderr.string).to eq('')
+            subject.bootstrap('test')
+          end
+        end
+
+        context 'with an non-existant SDK' do
+          it 'fails' do
+            expect { subject.bootstrap('missing') }.to raise_error(SystemExit, 'SDK missing not found')
+          end
+        end
+      end
+    end
+  end
+end

data/spec/polytrix/configuration_spec.rb

@@ -3,8 +3,52 @@ module Polytrix
     subject(:configuration) { Configuration.new }
 
     it 'creates a logger' do
-      expect(configuration.logger).to be_kind_of Logger
+      expect(configuration.logger).to be_kind_of ::Logger
     end
 
+    describe '.test_manifest' do
+      it 'parses the YAML file and registers the manifest' do
+        original_manifest = configuration.test_manifest
+        configuration.test_manifest = 'spec/fixtures/polytrix_tests.yml'
+        new_manifest = configuration.test_manifest
+        expect(original_manifest).to_not eq(new_manifest)
+        expect(new_manifest).to(be_an_instance_of(Polytrix::Manifest))
+      end
+    end
+
+    describe '.implementor' do
+      context 'argument is a Hash' do
+        it 'creates and registers Implementors' do
+          # This'd be a bit nicer w/ rspec 3...
+          expect do
+            configuration.implementor name: 'test', basedir: '.'
+          end.to change {
+            configuration.implementors
+          }.from(be_empty).to be_an_instance_of(Array)
+
+          expect(configuration.implementors.first).to be_an_instance_of Polytrix::Implementor
+          expect(configuration.implementors.first.name).to eq('test')
+        end
+      end
+      context 'argument is a String' do
+        context 'directory exists' do
+          context 'polytrix.yml does not exist' do
+            it 'builds an implementor with default settings' do
+              implementor = configuration.implementor('samples/sdks/ruby')
+              expect(implementor).to be_an_instance_of(Polytrix::Implementor)
+              expect(implementor.name).to eq('ruby') # directory name
+            end
+          end
+
+          context 'polytrix_tests.yml exists' do
+            it 'loads settings from polytrix.yml' do
+              implementor = configuration.implementor('samples/sdks/custom')
+              expect(implementor).to be_an_instance_of(Polytrix::Implementor)
+              expect(implementor.name).to eq('My Custom project')
+            end
+          end
+        end
+      end
+    end
   end
 end

data/spec/polytrix/documentation/helpers/code_helper_spec.rb

@@ -0,0 +1,120 @@
+module Polytrix
+  module Documentation
+    module Helpers
+      describe CodeHelper do
+        let(:challenge) { Fabricate(:challenge, name: 'test', source_file: @source_file) }
+        let(:source) do
+          %q[
+            # This snippet should not be in the output.
+            puts "Random: #{rand}"
+
+            # Snippet: Hello, world!
+            puts 'Hello, world!'
+
+            # Nor should this snippet
+            puts 'Done'
+          ]
+        end
+        let(:expected_snippet) do
+          %q[
+            puts 'Hello, world!'
+          ]
+        end
+
+        around do | example |
+          with_files(source: source) do | files |
+            @source_file = files.first
+            example.run
+          end
+        end
+
+        describe '#snippet_after' do
+          it 'returns the code block after the match (string)' do
+            snippet = challenge.snippet_after 'Snippet: Hello, world!'
+            expect(snippet.strip).to eq(expected_snippet.strip)
+          end
+
+          it 'returns the code block after the match (regex)' do
+            snippet = challenge.snippet_after(/Snippet: .*/)
+            expect(snippet.strip).to eq(expected_snippet.strip)
+          end
+
+          it 'returns nothing if no match is found' do
+            snippet = challenge.snippet_after 'Nothing matches'
+            expect(snippet).to be_empty
+          end
+        end
+
+        describe '#snippet_between' do
+          # Yes, whitespace doesn't work very well w/ snippet_between
+          let(:expected_snippet) do
+            %q[
+           puts "Random: #{rand}"
+# Snippet: Hello, world!
+            puts 'Hello, world!'
+            ]
+          end
+
+          it 'inserts all code blocks between the matching regexes' do
+            snippet = challenge.snippet_between 'This snippet should not be in the output', 'Nor should this snippet'
+            expect(snippet.strip).to eq(expected_snippet.strip)
+          end
+
+          it 'inserts nothing unless both matches are found' do
+            # Neither match
+            snippet = challenge.snippet_between 'foo', 'bar'
+            expect(snippet.strip).to be_empty
+
+            # First matches
+            snippet = challenge.snippet_between 'This snippet should not be in the output', 'foo'
+            expect(snippet.strip).to be_empty
+
+            # Last matches
+            snippet = challenge.snippet_between 'foo', 'Nor should this snippet'
+            expect(snippet.strip).to be_empty
+          end
+
+        end
+
+        describe '#code_block' do
+          it 'generates markdown code blocks by default' do
+            expected = "```ruby\n" + source + "\n```\n"
+            code_block = challenge.code_block(challenge.source, 'ruby')
+            expect(code_block).to eq(expected)
+          end
+
+          it 'generates rst for format :rst' do
+            indented_source = source.lines.map do|line|
+              "  #{line}"
+            end.join("\n")
+            expected = ".. code-block:: ruby\n" + indented_source + "\n"
+            code_block = challenge.code_block(challenge.source, 'ruby', format: :rst)
+            expect(code_block).to eq(expected)
+          end
+        end
+
+        def generate_doc_for(template_file, source_file)
+          doc_gen = DocumentationGenerator.new(template_file, 'testing')
+          challenge = Fabricate(:challenge, name: 'test', source_file: source_file)
+          doc_gen.process(challenge)
+        end
+
+        def with_files(files)
+          tmpfiles = []
+          begin
+            files.each do |k, v|
+              file = Tempfile.new(k.to_s)
+              file.write(v)
+              file.close
+              tmpfiles << file
+            end
+            yield tmpfiles.map(&:path)
+          ensure
+            tmpfiles.each { |tmpfile| tmpfile.unlink }
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/polytrix/documentation_generator_spec.rb

@@ -1,35 +1,56 @@
 module Polytrix
   describe DocumentationGenerator do
-    let(:search_path) { 'spec/fixtures/src-doc' }
+    let(:scenario_name) { 'Quine' }
+    # let(:search_path) { 'spec/fixtures/src-doc' }
     let(:bound_data) { double }
-    subject(:generator) { DocumentationGenerator.new(search_path) }
 
-    context 'when no documentation exists' do
-      it 'does nothing if there is no documentation for the scenario' do
-        expect(generator.process 'no_doc', bound_data).to be_nil
+    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
 
-    context 'when documentation does exist' do
+    describe 'code2doc' do
+      subject(:generator) { DocumentationGenerator.new }
 
-      let(:generated_doc) { generator.process 'Quine', bound_data }
+      let(:source_code) do
+        <<-eos.gsub(/^( |\t)+/, '')
+        #!/usr/bin/env ruby
 
-      it 'returns the generated document as a string' do
-        expect(generated_doc).to be_a(String)
+        # Comments are documentation
+        puts 'And this is a code block'
+        eos
       end
 
-      context 'ERB processing' do
-        it 'processes scenario' do
-          expect(generated_doc).to include 'Examples for Quine scenario:'
-        end
-
-        it 'processes Polytrix.implementors' do
-          fail 'This test requires implementors' unless Polytrix.implementors
+      let(:source_file) do
+        file = Tempfile.new(['source', '.rb'])
+        file.write source_code
+        file.close
+        file.path
+      end
 
-          Polytrix.implementors.each do |implementor|
-            expect(generated_doc).to include "## #{implementor}"
-          end
-        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

data/spec/polytrix/file_finder_spec.rb

@@ -1,8 +1,8 @@
 module Polytrix
   module Core
-    describe FileFinder do
+    describe FileSystemHelper do
       subject(:finder) do
-        Object.new.extend(Polytrix::Core::FileFinder)
+        Object.new.extend(Polytrix::Core::FileSystemHelper)
       end
 
       it 'finds files within the search path' do
@@ -12,10 +12,11 @@ module Polytrix
       end
 
       it 'raises FileNotFound except if a file is not found' do
-        expect { finder.find_file 'spec/fixtures/src-doc', 'quinez' }.to raise_error FileFinder::FileNotFound
+        expect { finder.find_file 'spec/fixtures/src-doc', 'quinez' }.to raise_error FileSystemHelper::FileNotFound
       end
 
       private
+
       def path(p)
         Pathname.new p
       end

data/spec/polytrix/implementor_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+module Polytrix
+  describe Implementor do
+    subject(:implementor) { described_class.new(name: 'test', language: 'ruby', basedir: 'sdks/test') }
+    let(:executor) { double('executor') }
+
+    before do
+      subject.executor = executor
+    end
+
+    describe '#bootstrap' do
+      it 'executes script/bootstrap' do
+        expect(executor).to receive(:execute).with('./scripts/bootstrap',  cwd: Pathname.new(File.absolute_path('sdks/test')), prefix: 'test')
+        implementor.bootstrap
+      end
+    end
+
+    describe '#build_challenge' do
+      subject(:implementor) { Polytrix::Implementor.new name: 'some_sdk', basedir: File.absolute_path('spec/fixtures') }
+      let(:challenge) { Fabricate(:challenge, name: 'factorial', vars: {}) }
+
+      it 'builds a Challenge' do
+        expect(challenge).to be_an_instance_of Polytrix::Challenge
+      end
+
+      it 'finds the source' do
+        expected_file = Pathname.new 'spec/fixtures/factorial.py'
+        expect(challenge.source_file).to eq(expected_file)
+      end
+    end
+  end
+end

data/spec/polytrix/manifest_spec.rb

@@ -1,26 +1,44 @@
 module Polytrix
-  module Core
-    describe Manifest do
-      describe '#from_yaml' do
-        subject(:manifest) { described_class.from_yaml 'spec/fixtures/polytrix.yml' }
+  describe Manifest do
+    describe '#from_yaml' do
+      subject(:manifest) { described_class.from_yaml 'spec/fixtures/polytrix_tests.yml' }
 
-        it 'initializes a manifest' do
-          expect(manifest).to be_an_instance_of Polytrix::Manifest
-        end
+      it 'initializes a manifest' do
+        expect(manifest).to be_an_instance_of Polytrix::Manifest
+      end
 
-        it 'processes ERB' do
-          expect(manifest.global_env['LOCALE']).to eq(ENV['LANG'])
-        end
+      it 'processes ERB' do
+        expect(manifest.global_env['LOCALE']).to eq(ENV['LANG'])
+      end
+
+      it 'parses global_env' do
+        expect(manifest.global_env).to be_an_instance_of Polytrix::Manifest::Environment
+      end
 
-        it 'parses global_env' do
-          expect(manifest.global_env).to be_an_instance_of Polytrix::Manifest::Environment
+      it 'parses suites' do
+        expect(manifest.suites).to be_an_instance_of Polytrix::Manifest::Suites
+      end
+
+      describe '#find_suite' do
+        before(:each) do
+          Polytrix.configuration.test_manifest = 'samples/polytrix_tests.yml'
+        end
+        it 'returns nil if no suite matches' do
+          suite = subject.find_suite('none')
+          expect(suite).to be_nil
         end
 
-        it 'parses suites' do
-          expect(manifest.suites).to be_an_instance_of Polytrix::Manifest::Suites
+        it 'returns the suite if one is found' do
+          suite = subject.find_suite('Katas')
+          expect(suite).to be_an_instance_of Polytrix::Manifest::Suite
         end
 
+        it 'is not case sensitive' do
+          suite = subject.find_suite('katas')
+          expect(suite).to be_an_instance_of Polytrix::Manifest::Suite
+        end
       end
+
     end
   end
 end

data/spec/polytrix/middleware/feature_executor_spec.rb

@@ -19,7 +19,7 @@ module Polytrix
 
           before do
             allow(challenge_runner).to receive(:challenge_command).with(env[:env_file], Pathname.new('test.js')).and_return('some command to execute')
-            allow(challenge_runner).to receive(:run_command).with('some command to execute').and_return Polytrix::Result.new(process: 'a', source: 'b', data: 'c')
+            allow(challenge_runner).to receive(:run_command).with('some command to execute').and_return Polytrix::Result.new(execution_result: 'a', source_file: 'b')
             allow(app).to receive(:call).with(env)
           end
 

data/spec/polytrix/result_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+module Polytrix
+  describe Result do
+    describe '#status' do
+      context 'mixed pass/fail' do
+        let(:subject) do
+          Polytrix::Result.new(
+            validations: [
+              { validated_by: 'max', result: 'passed' },
+              { validated_by: 'polytrix', result: 'failed' }
+            ]
+          ).status
+        end
+        it 'reports the failed status' do
+          is_expected.to eq('failed')
+        end
+      end
+      context 'mix passed/pending/skipped' do
+        let(:subject) do
+          Polytrix::Result.new(
+            validations: [
+              { validated_by: 'max', result: 'passed' },
+              { validated_by: 'polytrix', result: 'pending' },
+              { validated_by: 'john doe', result: 'skipped' }
+            ]
+          ).status
+        end
+        it 'reports the passed status' do
+          is_expected.to eq('passed')
+        end
+      end
+      context 'mix pending/skipped' do
+        let(:subject) do
+          Polytrix::Result.new(
+            validations: [
+              { validated_by: 'max', result: 'pending' },
+              { validated_by: 'polytrix', result: 'pending' },
+              { validated_by: 'john doe', result: 'skipped' }
+            ]
+          ).status
+        end
+        it 'reports the pending status' do
+          is_expected.to eq('pending')
+        end
+      end
+    end
+  end
+end

data/spec/polytrix/validations_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+module Polytrix
+  describe Validations do
+    describe '#coerce' do
+      it 'accepts an array when built via Result' do
+        Polytrix::Result.new(
+          validations: [
+            { validated_by: 'max', result: 'passed' },
+            { validated_by: 'polytrix', result: 'skipped' }
+          ]
+        )
+      end
+    end
+  end
+end

data/spec/polytrix/validator_registry_spec.rb

@@ -0,0 +1,39 @@
+module Polytrix
+  describe 'ValidatorRegistry' do
+    subject(:registry) { Polytrix::ValidatorRegistry }
+
+    describe '#register' do
+      it 'registers a validator' do
+        callback = proc do |challenge|
+          expect(challenge[:result].execution_result.exitstatus).to eq(0)
+        end
+
+        expect(registry.validators).to be_empty
+        registry.register suite: 'java', sample: 'hello world', &callback
+        validator = registry.validators.first
+        expect(validator.suite).to eql('java')
+        expect(validator.sample).to eql('hello world')
+        expect(validator.instance_variable_get('@callback')).to eql(callback)
+      end
+    end
+
+    describe '#validators_for' do
+      let(:java_hello_world_validator) { Fabricate(:validator, suite: 'java', sample: 'hello world') }
+      let(:java_validator) { Fabricate(:validator, suite: 'java', sample: //) }
+      let(:ruby_validator) { Fabricate(:validator, suite: 'ruby') }
+
+      before do
+        registry.register(java_hello_world_validator)
+        registry.register(java_validator)
+        registry.register(ruby_validator)
+      end
+
+      it 'returns registered validators that match the scope of the challenge' do
+        challenge = Fabricate(:challenge, suite: 'java', name: 'hello world')
+        validators = registry.validators_for challenge
+        expect(validators).to include(java_hello_world_validator, java_validator)
+        expect(validators).to_not include(ruby_validator)
+      end
+    end
+  end
+end