rox-client-rspec 0.3.0

data/lib/rox-client-rspec/formatter.rb

@@ -0,0 +1,86 @@
+require 'paint'
+require 'fileutils'
+require 'rspec/core/formatters/base_formatter'
+
+module RoxClient::RSpec
+
+  class Formatter < RSpec::Core::Formatters::BaseFormatter
+
+    def initialize *args
+      super *args
+
+      config = RoxClient::RSpec.config
+      @client = Client.new config.server, config.client_options
+      @test_run = TestRun.new config.project
+
+      @groups = []
+    end
+
+    def start example_count
+      # TODO: measure milliseconds
+      @start_time = Time.now
+    end
+
+    def example_group_started group
+      @groups << group
+    end
+
+    def example_group_finished group
+      @groups.pop
+    end
+
+    def example_started example
+      @current_time = Time.now
+    end
+
+    def example_passed example
+      add_result example, true
+    end
+
+    def example_failed example
+      add_result example, false
+    end
+
+    def stop
+      end_time = Time.now
+      @test_run.end_time = end_time.to_i * 1000
+      @test_run.duration = ((end_time - @start_time) * 1000).round
+    end
+
+    def dump_summary duration, example_count, failure_count, pending_count
+      @client.process @test_run
+    end
+
+    private
+
+    def add_result example, successful
+
+      options = {
+        passed: successful,
+        duration: ((Time.now - @current_time) * 1000).round
+      }
+      options[:message] = failure_message(example) unless successful
+
+      @test_run.add_result example, @groups, options
+    end
+    
+    def failure_message example
+      exception = example.execution_result[:exception]
+      Array.new.tap do |a|
+        a << full_example_name(example)
+        a << "Failure/Error: #{read_failed_line(exception, example).strip}"
+        a << "  #{exception.class.name}:" unless exception.class.name =~ /RSpec/
+        exception.message.to_s.split("\n").each do |line|
+          a << "    #{line}"
+        end
+        format_backtrace(example.execution_result[:exception].backtrace, example).each do |backtrace_info|
+          a << "# #{backtrace_info}"
+        end
+      end.join "\n"
+    end
+
+    def full_example_name example
+      (@groups.collect{ |g| g.description.strip } << example.description.strip).join ' '
+    end
+  end
+end

data/lib/rox-client-rspec/project.rb

@@ -0,0 +1,32 @@
+
+module RoxClient::RSpec
+
+  class Project
+    # TODO: remove project name once API v0 is dead
+    attr_accessor :name, :version, :api_id, :category, :tags, :tickets
+
+    def initialize options = {}
+      update options
+    end
+
+    def update options = {}
+      %w(name version api_id category).each do |k|
+        instance_variable_set "@#{k}", options[k.to_sym] ? options[k.to_sym].to_s : nil if options.key? k.to_sym
+      end
+      @tags = wrap(options[:tags]).compact if options.key? :tags
+      @tickets = wrap(options[:tickets]).compact if options.key? :tickets
+    end
+
+    def validate!
+      required = { "name" => @name, "version" => @version, "API identifier" => @api_id }
+      missing = required.inject([]){ |memo,(k,v)| v.to_s.strip.length <= 0 ? memo << k : memo }
+      raise PayloadError.new("Missing project options: #{missing.join ', '}") if missing.any?
+    end
+
+    private
+
+    def wrap a
+      a.kind_of?(Array) ? a : [ a ]
+    end
+  end
+end

data/lib/rox-client-rspec/server.rb

@@ -0,0 +1,97 @@
+require 'oj'
+require 'httparty'
+
+module RoxClient::RSpec
+
+  class Server
+    attr_reader :name, :api_url, :api_key_id, :api_key_secret, :api_version, :project_api_id
+
+    class Error < RoxClient::RSpec::Error
+      attr_reader :response
+    
+      def initialize msg, response = nil
+        super msg
+        @response = response
+      end
+    end
+
+    def initialize options = {}
+      @name = options[:name].to_s.strip
+      @api_url = options[:api_url].to_s if options[:api_url]
+      @api_key_id = options[:api_key_id].to_s if options[:api_key_id]
+      @api_key_secret = options[:api_key_secret].to_s if options[:api_key_secret]
+      @api_version = options[:api_version] || 1
+      @project_api_id = options[:project_api_id].to_s if options[:project_api_id]
+    end
+
+    def payload_options
+      { version: @api_version }
+    end
+
+    def upload payload
+      validate!
+
+      uri = payload_uri
+      body = Oj.dump payload, mode: :strict
+
+      res = case @api_version
+      when 0
+        HTTParty.post uri, body: body
+      else
+        HTTParty.post uri, body: body, headers: payload_headers.merge(authentication_headers)
+      end
+
+      if res.code != 202
+        raise Error.new("Expected HTTP 202 Accepted when submitting payload, got #{res.code}", res)
+      end
+    end
+
+    private
+
+    def validate!
+      
+      raise Error.new("Server #{@name} requires $ROX_RUNNER_KEY to be set (API v0)") if @api_version == 0 and !ENV['ROX_RUNNER_KEY']
+
+      required = { "apiUrl" => @api_url }
+      required.merge!({ "apiKeyId" => @api_key_id, "apiKeySecret" => @api_key_secret, "projectApiId" => @project_api_id }) if @api_version >= 1
+      missing = required.inject([]){ |memo,(k,v)| v.to_s.strip.length <= 0 ? memo << k : memo }
+      raise Error.new("Server #{@name} is missing the following options: #{missing.join ', '}") if missing.any?
+    end
+
+    def payload_headers
+      { 'Content-Type' => 'application/vnd.lotaris.rox.payload.v1+json' }
+    end
+
+    def payload_uri
+      case @api_version
+
+      when 0
+        "#{@api_url}/v1/payload"
+
+      else
+      
+        # get api root
+        res = HTTParty.get @api_url, headers: authentication_headers
+        if res.code != 200
+          raise Error.new("Expected HTTP 200 OK status code for API root, got #{res.code}", res)
+        elsif res.content_type != 'application/hal+json'
+          raise Error.new("Expected API root in the application/hal+json content type, got #{res.content_type}", res)
+        end
+
+        body = Oj.load res.body, mode: :strict
+
+        links = body['_links'] || {}
+        if !links.key?('v1:test-payloads')
+          raise Error.new("Expected API root to have a v1:test-payloads link", res)
+        end
+
+        # extract payload uri
+        links['v1:test-payloads']['href']
+      end
+    end
+
+    def authentication_headers
+      { 'Authorization' => %|RoxApiKey id="#{@api_key_id}" secret="#{@api_key_secret}"| }
+    end
+  end
+end

data/lib/rox-client-rspec/tasks.rb

@@ -0,0 +1,62 @@
+require 'fileutils'
+require 'rake/tasklib'
+
+module RoxClient::RSpec
+
+  class Tasks < ::Rake::TaskLib
+
+    def initialize
+
+      namespace :spec do
+
+        namespace :rox do
+
+          desc "Generate a test run UID to group test results in ROX Center (stored in an environment variable)"
+          task :uid do
+            trace do
+              uid = uid_manager.generate_uid_to_env
+              puts Paint["ROX - Generated UID for test run: #{uid}", :cyan]
+            end
+          end
+
+          namespace :uid do
+
+            desc "Generate a test run UID to group test results in ROX Center (stored in a file)"
+            task :file do
+              trace do
+                uid = uid_manager.generate_uid_to_file
+                puts Paint["ROX - Generated UID for test run: #{uid}", :cyan]
+              end
+            end
+
+            desc "Clean the test run UID (file and environment variable)"
+            task :clean do
+              trace do
+                uid_manager.clean_uid
+                puts Paint["ROX - Cleaned test run UID", :cyan]
+              end
+            end
+          end
+        end
+      end
+    end
+
+    private
+
+    def trace &block
+      if Rake.application.options.trace
+        block.call
+      else
+        begin
+          block.call
+        rescue UID::Error => e
+          warn Paint["ROX - #{e.message}", :red]
+        end
+      end
+    end
+
+    def uid_manager
+      UID.new RoxClient::RSpec.config.client_options
+    end
+  end
+end

data/lib/rox-client-rspec/test_payload.rb

@@ -0,0 +1,23 @@
+require 'fileutils'
+require 'digest/sha2'
+
+module RoxClient::RSpec
+
+  class TestPayload
+
+    class Error < RoxClient::RSpec::Error; end
+
+    def initialize run
+      @run = run
+    end
+
+    def to_h options = {}
+      case options[:version]
+      when 0
+        { 'r' => [ @run.to_h(options) ] }
+      else # version 1 by default
+        @run.to_h options
+      end
+    end
+  end
+end

data/lib/rox-client-rspec/test_result.rb

@@ -0,0 +1,114 @@
+
+module RoxClient::RSpec
+
+  class TestResult
+    attr_reader :key, :name, :category, :tags, :tickets, :duration, :message
+
+    def initialize project, example, groups = [], options = {}
+
+      @category = project.category
+      @tags = project.tags
+      @tickets = project.tickets
+
+      @grouped = extract_grouped example, groups
+
+      [ :key, :name, :category, :tags, :tickets ].each do |attr|
+        instance_variable_set "@#{attr}".to_sym, send("extract_#{attr}".to_sym, example, groups)
+      end
+
+      @passed = !!options[:passed]
+      @duration = options[:duration]
+      @message = options[:message]
+    end
+
+    def passed?
+      @passed
+    end
+
+    def grouped?
+      @grouped
+    end
+
+    def update options = {}
+      @passed &&= options[:passed]
+      @duration += options[:duration]
+      @message = [ @message, options[:message] ].select{ |m| m }.join("\n\n") if options[:message]
+    end
+
+    def to_h options = {}
+      {
+        'k' => @key,
+        'p' => @passed,
+        'd' => @duration
+      }.tap do |h|
+
+        h['m'] = @message if @message
+
+        cache = options[:cache]
+        first = !cache || !cache.known?(self)
+        stale = !first && cache.stale?(self)
+        h['n'] = @name if stale or first
+        h['c'] = @category if stale or (first and @category)
+        h['g'] = @tags if stale or (first and !@tags.empty?)
+        h['t'] = @tickets if stale or (first and !@tickets.empty?)
+      end
+    end
+
+    def self.extract_grouped example, groups = []
+      !!groups.collect{ |g| meta(g)[:grouped] }.compact.last
+    end
+
+    def self.extract_key example, groups = []
+      (groups.collect{ |g| meta(g)[:key] } << meta(example)[:key]).compact.last
+    end
+
+    def self.meta holder
+      meta = holder.metadata[:rox] || {}
+      if meta.kind_of? String
+        { key: meta }
+      elsif meta.kind_of? Hash
+        meta
+      else
+        {}
+      end
+    end
+
+    private
+
+    def meta *args
+      self.class.meta *args
+    end
+
+    def extract_grouped *args
+      self.class.extract_grouped *args
+    end
+
+    def extract_key *args
+      self.class.extract_key *args
+    end
+
+    def extract_name example, groups = []
+      parts = groups.dup
+      parts = parts[0, parts.index{ |p| meta(p)[:grouped] } + 1] if @grouped
+      parts << example unless @grouped
+      parts.collect{ |p| p.description.strip }.join ' '
+    end
+
+    def extract_category example, groups = []
+      cat = (groups.collect{ |g| meta(g)[:category] }.unshift(@category) << meta(example)[:category]).compact.last
+      cat ? cat.to_s : nil
+    end
+
+    def extract_tags example, groups = []
+      (wrap(@tags) + groups.collect{ |g| wrap meta(g)[:tags] } + (wrap meta(example)[:tags])).flatten.compact.uniq.collect(&:to_s)
+    end
+
+    def extract_tickets example, groups = []
+      (wrap(@tickets) + groups.collect{ |g| wrap meta(g)[:tickets] } + (wrap meta(example)[:tickets])).flatten.compact.uniq.collect(&:to_s)
+    end
+
+    def wrap a
+      a.kind_of?(Array) ? a : [ a ]
+    end
+  end
+end

data/lib/rox-client-rspec/test_run.rb

@@ -0,0 +1,104 @@
+
+module RoxClient::RSpec
+
+  class TestRun
+    # TODO: remove end time once API v0 is dead
+    attr_reader :results, :project
+    attr_accessor :end_time, :duration, :uid
+
+    def initialize project
+      @results = []
+      @project = project
+    end
+
+    def add_result example, groups = [], options = {}
+
+      if TestResult.extract_grouped(example, groups) and (existing_result = @results.find{ |r| r.grouped? && r.key == TestResult.extract_key(example, groups) })
+        existing_result.update options
+      else
+        @results << TestResult.new(@project, example, groups, options)
+      end
+    end
+
+    def results_without_key
+      @results.select{ |r| !r.key or r.key.to_s.strip.empty? }
+    end
+
+    def results_by_key
+      @results.inject({}) do |memo,r|
+        (memo[r.key] ||= []) << r unless !r.key or r.key.to_s.strip.empty?
+        memo
+      end
+    end
+
+    def to_h options = {}
+      validate!
+
+      case options[:version]
+      when 0
+        {
+          'r' => ENV['ROX_RUNNER_KEY'],
+          'e' => @end_time,
+          'd' => @duration,
+          'j' => @project.name,
+          'v' => @project.version,
+          't' => @results.collect{ |r| r.to_h options }
+        }.tap do |h|
+          h['u'] = @uid if @uid
+        end
+      else # version 1 by default
+        {
+          'd' => @duration,
+          'r' => [
+            {
+              'j' => @project.api_id,
+              'v' => @project.version,
+              't' => @results.collect{ |r| r.to_h options }
+            }
+          ]
+        }.tap do |h|
+          h['u'] = @uid if @uid
+        end
+      end
+    end
+
+    private
+
+    def validate!
+      # TODO: validate duration
+
+      raise PayloadError.new("Missing project") if !@project
+      @project.validate!
+
+      validate_no_results_without_key
+      validate_no_duplicate_keys
+    end
+
+    def validate_no_duplicate_keys
+
+      results_with_duplicate_key = results_by_key.select{ |k,r| r.length >= 2 }
+      return if results_with_duplicate_key.none?
+
+      msg = "the following keys are used by multiple test results".tap do |s|
+        results_with_duplicate_key.each_pair do |key,results|
+          s << "\n     - #{key}"
+          results.each{ |r| s << "\n       - #{r.name}" }
+        end
+      end
+
+      raise PayloadError.new(msg)
+    end
+
+    def validate_no_results_without_key
+
+      keyless = results_without_key
+      return if keyless.empty?
+
+      msg = "the following test results are missing a key".tap do |s|
+        keyless.each{ |r| s << "\n     - #{r.name}" }
+      end
+
+      raise PayloadError.new(msg)
+    end
+  end
+end