polytrix 0.0.1

data/features/pacto/extensions/loaders/simple_loader.rb

@@ -0,0 +1,55 @@
+require 'multi_json'
+require 'yaml'
+require 'pacto'
+require_relative 'yaml_or_json_loader'
+
+class Pacto::Extensions::Loaders::URIMapLoader < Pacto::Extensions::Loaders::YamlOrJsonLoader
+  class << self
+    include Pacto::Logger
+
+    def load(file)
+      data = super
+      contracts = []
+      data['services'].each do | group_name, service_group |
+        service_group['servers'].each do | server |
+          if service_group['services']
+            service_group['services'].each_pair do | service_name, service_definition|
+              contract = build_simple_contract service_definition, group_name, service_name, server, file
+              Pacto.contract_registry.register(contract)
+              contracts << contract
+            end
+          end
+        end
+      end
+      Pacto::ContractList.new contracts
+    end
+
+    private
+    def build_simple_contract service_definition, group_name, service_name, server, file
+      service_signature = "#{service_definition['method'].upcase} #{service_definition['uriTemplate']}"
+      logger.debug "Building contract for '#{service_signature}' as '#{group_name} - #{service_name}' on #{server}"
+      # FIXME: What about scheme?
+      host = "https://#{server}"
+      request_clause = Pacto::RequestClause.new(host, {
+        'method' => service_definition['method'],
+        'headers' => [], #not supporting this yet, probably needs conversion
+        'path' => convert_template(service_definition['uriTemplate']),
+        'body' => service_definition['requestSchema'] || {}
+      })
+      response_clause = Pacto::ResponseClause.new({
+        'status' => service_definition['responseStatusCode'] || 200,
+        'headers' => [], #not supporting this yet, probably needs conversion
+        'body' => service_definition['responseSchema'] || {}
+      })
+      Pacto::Contract.new(request_clause, response_clause, file, service_name)
+    end
+
+    def convert_template path
+      Addressable::Template.new(path) if path
+      # path.gsub(/{(\w+)}/, ':\1') if path
+    end
+  end
+end
+
+# Pacto.configuration.strict_matchers = false
+# contracts = Pacto::Extensions::Loaders::URIMapLoader.load('pacto/rackspace_uri_map.yaml')

data/features/pacto/extensions/loaders/yaml_or_json_loader.rb

@@ -0,0 +1,17 @@
+module Pacto
+  module Extensions
+    module Loaders
+      class YamlOrJsonLoader
+        YAML_EXTENSIONS = %w{.yml .yaml}
+        def self.load(file)
+          raw_data = File.read file
+          if YAML_EXTENSIONS.include? File.extname(file)
+            YAML::load(raw_data)
+          else
+            MultiJson.load(raw_data)
+          end
+        end
+      end
+    end
+  end
+end

data/features/pacto/extensions/matchers.rb

@@ -0,0 +1,38 @@
+RSpec::Matchers.define :have_validated_service do |group_name, service_name|
+  @requested_name = service_name
+  @contract = Pacto.contract_registry.find{ |c| c.name == @requested_name }
+  match do
+    unless @contract.nil?
+      @validations = Pacto::ValidationRegistry.instance.validations.select {|v|
+        # FIXME: Same contract on multiple servers is currently problematic
+        v.contract && v.contract.name == @contract.name
+      }
+      !(@validations.empty? || @validations.map(&:successful?).include?(false))
+    end
+  end
+
+  failure_message_for_should do
+    buffer = StringIO.new
+    buffer.puts "expected Pacto to have validated #{@requested_name}"
+    if @contract.nil?
+      buffer.puts '  but no known contract matches that name'
+    elsif @validations.empty?
+      buffer.puts '  but no request matched the pattern'
+      buffer.puts "    pattern: #{@contract.request_pattern}"
+      buffer.puts '    received:'
+      buffer.puts "#{WebMock::RequestRegistry.instance}"
+    elsif @validations.map(&:successful?).include?(false)
+      buffer.puts '  but validation errors were found:'
+      buffer.print '    '
+      validation_results = @validations.map(&:results).flatten.compact
+      buffer.puts validation_results.join "\n    "
+      validation_results.each do |validation_result|
+        buffer.puts "    #{validation_result}"
+      end
+    else
+      # FIXME: ensure this is unreachable?
+      buffer.puts '  but an unknown problem occurred'
+    end
+    buffer.string
+  end
+end

data/features/phase2/feature_coverage_report.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+require 'yaml'
+require 'csv'
+
+class CSVFeatureMatrix
+  def initialize(matrix_csv)
+    @feature_matrix = []
+
+    CSV.foreach(matrix_csv, :headers => :first_row) do |row|
+      
+      # Carry the product
+      @product = row['Product'] if row['Product']
+      row['Product'] ||= @product
+
+      next if row['Feature'].nil? or row['Feature'].empty?
+
+      # Normalize status
+      SDKs.each do |sdk|
+        row[sdk] = '' unless row[sdk] == 'Done'
+      end
+
+      @feature_matrix << row.to_hash
+    end
+  end
+
+  def products
+    @feature_matrix.map{|f| f['Product']}.uniq.compact
+  end
+
+  def features(product)
+    @feature_matrix.select{|f| f['Product'] == product}.map{|f| f['Feature']}.compact
+  end
+
+  def implementers product, service_name
+    code_sample = @feature_matrix.find{|f| f['Feature'] == service_name}
+    feature.keys.select{|k| feature[k] == 'Done'}
+  end
+end
+
+class CoveredFeatures
+  def initialize(coverage_files)
+    @coverage = {}
+    @covered_features = {}
+    [*coverage_files].each do |file|
+      @coverage.merge! YAML::load(File.read(file))
+    end
+    @coverage.values.flatten.uniq do |covered_feature|
+      @covered_features[covered_feature] = SDKs.select{|sdk|
+        @coverage.select{|k,v| k =~ /#{sdk}$/}.values.flatten.include? covered_feature
+      }
+    end
+  end
+
+  def coverers(product, feature)
+    @covered_features[feature] || []
+  end
+end
+
+sdk_coverage = CoveredFeatures.new(Dir['reports/api_coverage*.yaml'])
+original_feature_matrix = CSVFeatureMatrix.new 'original_feature_matrix.csv'
+
+original_feature_matrix.products.each do |product|
+  describe product do
+    original_feature_matrix.features(product).each do |feature|
+      describe feature do
+        coverers = sdk_coverage.coverers(product, feature)
+        implementers = original_feature_matrix.implementers(product,feature)
+        SDKs.each do |sdk|
+          it sdk, sdk.to_sym do
+            if coverers.include? sdk
+              # pass
+            else
+              if implementers.include? sdk
+                pending
+              else
+                fail
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+# data = YAML::load(File.read('pacto/rackspace_uri_map.yaml'))
+# data['services'].each do |service_group_name, service_group|
+#   describe service_group_name do
+#     services = service_group['services'] || []
+#     services.each do |service_name, service|
+#       describe service_name do
+#         SDKs.each do |sdk|
+#           it sdk, sdk.to_sym do
+#             sdk_coverage = coverage.select{|k,v| k =~ /#{sdk}$/ }
+#             if sdk_coverage.values.flatten.include? service_name
+#               # pass
+#             else
+#               if original_feature_matrix.implemented? service_name, sdk
+#                 pending
+#               else
+#                 fail
+#               end
+#             end
+#           end
+#         end
+#       end
+#     end
+#   end
+# end

data/features/phase2/run_all_features.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+require 'yaml'
+
+data = YAML::load(File.read('pacto/rackspace_uri_map.yaml'))
+data['services'].each do |service_group_name, service_group|
+  describe service_group_name do
+    services = service_group['services'] || []
+    services.each do |service_name, service|
+      code_sample service_name, '', standard_env_vars, [] do
+      end
+    end
+  end
+end
+

data/features/static_site/fixtures/index.html

@@ -0,0 +1,6 @@
+<!DOCTYPE html>
+<html>
+  <body>
+    <h1>Hello, World!</h1>
+  </body>
+</html>

data/lib/polytrix/challenge.rb

@@ -0,0 +1,27 @@
+require 'hashie/dash'
+require 'hashie/extensions/coercion'
+require 'hashie/extensions/indifferent_access'
+
+module Polytrix
+  class Challenge < Hashie::Dash
+    include Hashie::Extensions::Coercion
+    include Hashie::Extensions::IndifferentAccess
+    property :name
+    property :implementor
+    property :vars, :default => {}
+    property :source_file
+    coerce_key :source_file, Pathname
+    property :basedir
+    coerce_key :basedir, Pathname
+    property :challenge_runner, :default => ChallengeRunner.createRunner
+    property :result
+    property :env_file
+    coerce_key :vars, Polytrix::Manifest::Environment
+    property :plugin_data, :default => {}
+
+    def run
+      challenge_runner.run_challenge self
+    end
+
+  end
+end

data/lib/polytrix/challenge_builder.rb

@@ -0,0 +1,16 @@
+module Polytrix
+  class ChallengeBuilder
+    include Polytrix::Core::FileFinder
+
+    def initialize(implementor)
+      @implementor = implementor
+    end
+
+    def build(challenge_data)
+      challenge_data[:source_file] ||= find_file @implementor.basedir, challenge_data[:name]
+      challenge_data[:basedir] ||= @implementor.basedir
+      challenge_data[:implementor] ||= @implementor.name
+      Challenge.new challenge_data
+    end
+  end
+end

data/lib/polytrix/challenge_runner.rb

@@ -0,0 +1,87 @@
+require 'polytrix'
+require 'mixlib/shellout'
+require 'rbconfig'
+
+module Polytrix
+  module Runners
+    autoload :LinuxChallengeRunner, 'polytrix/runners/linux_challenge_runner'
+    autoload :WindowsChallengeRunner, 'polytrix/runners/windows_challenge_runner'
+  end
+
+  class FeatureNotImplementedError < StandardError
+    def initialize(feature)
+      super "Feature #{feature} is not implemented"
+    end
+  end
+
+  class ChallengeRunner
+    include Polytrix::Core::FileFinder
+
+    def self.createRunner
+      case RbConfig::CONFIG['host_os']
+      when /mswin(\d+)|mingw/i
+        Runners::WindowsChallengeRunner.new
+      else
+        Runners::LinuxChallengeRunner.new
+      end
+    end
+
+    def editor_enabled?
+      !challenge_editor.nil?
+    end
+
+    def challenge_editor
+      ENV['CHALLENGE_EDITOR']
+    end
+
+    def interactive?
+      ENV['INTERACTIVE']
+    end
+
+    def show_output?
+      ENV['SHOW_OUTPUT']
+    end
+
+    def run_command(command)
+      if interactive? # allows use of pry, code.interact, etc.
+        system command
+      else # better error messages and interrupt handling
+        challenge_process = Mixlib::ShellOut.new(command)
+        challenge_process.live_stream = $stdout if show_output?
+        challenge_process.run_command
+        challenge_process.error!
+        challenge_process
+      end
+    end
+
+    def run_challenge(challenge)
+      middleware.call(challenge)
+      challenge
+    end
+
+    def find_challenge!(challenge, basedir = Dir.pwd)
+      find_file basedir, challenge
+    rescue Polytrix::Core::FileFinder::FileNotFound
+      raise FeatureNotImplementedError, challenge
+    end
+
+    def edit_challenge(challenge)
+      suffix = infer_suffix File.dirname(challenge)
+      challenge_file = "#{challenge}#{suffix}"
+      puts "Would you like to create #{challenge_file} (y/n)? "
+      system "#{challenge_editor} #{challenge_file}" if $stdin.gets.strip == 'y'
+      File.absolute_path challenge_file
+    end
+
+    def infer_suffix(source_dir)
+      # FIXME: Should be configurable or have a better way to infer
+      Dir["#{source_dir}/**/*.*"].map { |f| File.extname f }.first
+    end
+
+    private
+
+    def middleware
+      Polytrix.configuration.middleware
+    end
+  end
+end

data/lib/polytrix/configuration.rb

@@ -0,0 +1,31 @@
+require 'middleware'
+require 'logger'
+require 'hashie/dash'
+require 'hashie/extensions/coercion'
+
+module Polytrix
+  # Autoload pool
+  module Runners
+    module Middleware
+      autoload :FeatureExecutor, 'polytrix/runners/middleware/feature_executor'
+      autoload :SetupEnvVars,    'polytrix/runners/middleware/setup_env_vars'
+      autoload :ChangeDirectory, 'polytrix/runners/middleware/change_directory'
+
+      STANDARD_MIDDLEWARE = ::Middleware::Builder.new do
+        use Polytrix::Runners::Middleware::ChangeDirectory
+        use Polytrix::Runners::Middleware::SetupEnvVars
+        use Polytrix::Runners::Middleware::FeatureExecutor
+      end
+    end
+  end
+
+  class Configuration < Hashie::Dash
+    include Hashie::Extensions::Coercion
+
+    property :logger,       :default => Logger.new($stdout)
+    property :middleware,   :default => Polytrix::Runners::Middleware::STANDARD_MIDDLEWARE
+    property :implementors
+    coerce_key :implementors, Polytrix::Implementor
+
+  end
+end

data/lib/polytrix/core/file_finder.rb

@@ -0,0 +1,43 @@
+module Polytrix
+  module Core
+    module FileFinder
+      class FileNotFound < StandardError; end
+
+      # Finds a file by loosely matching the file name to a scenario name
+      def find_file(search_path, scenario_name, ignored_patterns = read_gitignore(search_path))
+        potential_files = Dir.glob("#{search_path}/**/*#{scenario_name}.*", File::FNM_CASEFOLD)
+        potential_files.concat Dir.glob("#{search_path}/**/*#{scenario_name.gsub(' ', '_')}.*", File::FNM_CASEFOLD)
+        potential_files.concat Dir.glob("#{search_path}/**/*#{scenario_name.gsub('_', '')}.*", File::FNM_CASEFOLD)
+
+        # Find the first file, not including generated files
+        file = potential_files.find { |file|
+          !ignored? ignored_patterns, search_path, file
+        }
+
+        fail FileNotFound, "No file was found for #{scenario_name} within #{search_path}" if file.nil?
+        Pathname.new file
+      end
+
+      private
+
+      def read_gitignore(dir)
+        gitignore_file = "#{dir}/.gitignore"
+        File.read(gitignore_file)
+      rescue
+        ""
+      end
+
+      def ignored?(ignored_patterns, base_path, target_file)
+        ignored_patterns.split.find do |pattern|
+          # if git ignores a folder, we should ignore all files it contains
+          pattern = "#{pattern}**" if pattern[-1] == '/'
+          relativize(target_file, base_path).fnmatch? pattern
+        end
+      end
+
+      def relativize(file, base_path)
+        Pathname.new(file).relative_path_from Pathname.new(base_path)
+      end
+    end
+  end
+end

data/lib/polytrix/core/implementor.rb

@@ -0,0 +1,17 @@
+require 'hashie/dash'
+require 'hashie/extensions/coercion'
+
+module Polytrix
+  class Implementor < Hashie::Dash
+    include Hashie::Extensions::Coercion
+    property :name
+    property :basedir
+    property :language
+    coerce_key :basedir, Pathname
+
+    def initialize(data)
+      data[:basedir] ||= "sdks/#{data[:name]}"
+      super(data)
+    end
+  end
+end

data/lib/polytrix/core/result_tracker.rb

@@ -0,0 +1,25 @@
+require 'singleton'
+require 'hashie/mash'
+
+module Polytrix
+  class ResultTracker
+    include Singleton
+
+    attr_reader :results
+
+    def example_started(example)
+      data_for(example)[example.description] = Hashie::Mash.new
+    end
+
+    def execution_result(example, result)
+      data_for(example)[example.description][:execution_result] = result
+    end
+
+    private
+    def data_for(example)
+      @results ||= Hashie::Mash.new
+      group_names = example.example_group.parent_groups.map{|g| g.description}
+      group_names.inject(@results, :initializing_reader)
+    end
+  end
+end

data/lib/polytrix/documentation_generator.rb

@@ -0,0 +1,18 @@
+module Polytrix
+  class DocumentationGenerator
+    include Polytrix::Core::FileFinder
+    attr_reader :template_file
+
+    def initialize(search_path)
+      @search_path = search_path
+    end
+
+    def process(scenario, challenges)
+      @template_file = find_file @search_path, scenario, ""
+      erb = ERB.new File.read(template_file)
+      erb.result binding
+    rescue Polytrix::Core::FileFinder::FileNotFound
+      nil
+    end
+  end
+end

data/lib/polytrix/manifest.rb

@@ -0,0 +1,46 @@
+require 'yaml'
+require 'hashie/dash'
+require 'hashie/mash'
+require 'hashie/extensions/coercion'
+
+module Polytrix
+  class Manifest < Hashie::Dash
+    class Environment < Hashie::Mash
+      # Hashie Coercion - automatically treat all values as string
+      def self.coerce(obj)
+        data = obj.inject({}) do |h, (key, value)|
+          h[key] = value.to_s
+          h
+        end
+        new data
+      end
+    end
+
+    class Suite < Hashie::Mash
+    end
+
+    class Suites < Hashie::Mash
+      # Hashie Coercion - automatically treat all values as string
+      def self.coerce(obj)
+        data = obj.inject({}) do |h, (key, value)|
+          h[key] = Polytrix::Manifest::Suite.new(value)
+          h
+        end
+        new data
+      end
+    end
+
+    include Hashie::Extensions::Coercion
+    property :global_env
+    coerce_key :global_env, Polytrix::Manifest::Environment
+    property :suites
+    coerce_key :suites, Polytrix::Manifest::Suites
+
+    def self.from_yaml(yaml_file)
+      raw_content = File.read(yaml_file)
+      processed_content = ERB.new(raw_content).result
+      data = YAML::load processed_content
+      new data
+    end
+  end
+end

data/lib/polytrix/result.rb

@@ -0,0 +1,9 @@
+require 'hashie/dash'
+
+module Polytrix
+  class Result < Hashie::Dash
+    property :process, required: true
+    property :source
+    property :data
+  end
+end

data/lib/polytrix/rspec/documentation_formatter.rb

@@ -0,0 +1,41 @@
+require 'polytrix/rspec'
+require 'hashie/mash'
+require 'yaml'
+require 'fileutils'
+
+module Polytrix
+  module RSpec
+    class DocumentationFormatter < ::RSpec::Core::Formatters::BaseFormatter
+      def initialize(output)
+        @results = Hashie::Mash.new
+        super
+      end
+
+      def example_group_finished(example_group)
+        group_names = example_group.parent_groups.map{|g| g.description}
+        polytrix_challenges = example_group.examples.map { |e| e.metadata[:polytrix] }
+        produce_doc example_group.description, polytrix_challenges
+      end
+
+      def dump_summary(duration, example_count, failure_count, pending_count)
+        doc_gen = Polytrix::DocumentationGenerator.new 'doc-src'
+        all_challenges = examples.map{|e| e.metadata[:polytrix]}
+        grouped_challenges = all_challenges.compact.group_by(&:name)
+        produce_doc 'index', grouped_challenges
+      end
+
+      private
+      def produce_doc(name, data)
+        doc_gen = Polytrix::DocumentationGenerator.new 'doc-src'
+        doc = doc_gen.process(name, data)
+        target_file = doc_gen.template_file.to_s.gsub 'doc-src', 'docs'
+        unless target_file.empty?
+          FileUtils.mkdir_p File.dirname(target_file)
+          File.open(target_file, 'wb') do |f|
+            f.write doc
+          end
+        end
+      end
+    end
+  end
+end