stddtool 0.3.1.1 → 0.5.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f309b34a2bec721ea88a95c4559f89cc5a91f32f
-  data.tar.gz: c55c4b861c8c1ba71225f6118f40a6b35195895a
+  metadata.gz: a76f2860a1034d498debff40c95430820672f253
+  data.tar.gz: 763ba36d5c0b9ade26fc7ce5065d635c96853fb5
 SHA512:
-  metadata.gz: 13c35af0badc7f4bef1c6f9f7646b28ad8d4e89aba40e2dfbccc64c1e6e0bb2ee2396e30b6107b3afa5d523ba03639bd4f788e1b7dc5383eb665f87e1cd1303f
-  data.tar.gz: a49a5bad7524f5d3e85df41dc5539f90b8f06621f260a631bb8372b14994b5cce20da530737e6cce166d8a82287d4211094015ab3bb0eefadf6db82df153e02b
+  metadata.gz: 762a58b64e6446448b45b6484ee534e071f9ecf4a03dace0bbcf4dda2ec6b64000c0bab46e8b799df29d27e2e5388c8c0d580d91b5b095b59d7dc44a70b90eff
+  data.tar.gz: 775638653d5391ef5121b53701ff25e0d1f15f4181c71fba1bed095821e5c32f03e013e5dbf6a7f2444aa8043b4a0eb070240ee30b4a399d59fc746f1ca7ede2

data/lib/stddtool.rb

@@ -6,268 +6,251 @@ require 'ostruct'
 require 'cucumber/formatter/io'
 require 'gherkin/formatter/argument'
 require 'base64'
-require 'objects'
 require 'cucumber/ast/scenario_outline'
 require 'cucumber/ast/scenario'
+require 'stdd_api'
 
-class STDDTool
-  AST_CLASSES = {
-      Cucumber::Ast::Scenario        => 'scenario',
-      Cucumber::Ast::ScenarioOutline => 'scenario_outline'
-    }
-
-  def initialize(step_mother, io, options)
-    @buildnr = ENV['BUILD']
-    @job = ENV['JOB']
-    @url = ENV['STDD_URL'] ? ENV['STDD_URL'] : ['http://www.stddtool.se']
-    @proxy = ENV['http_proxy'] ? URI.parse('http://'+ENV['http_proxy']) : OpenStruct.new
-    # Generate string as runId
-    o = [('a'..'z'), ('A'..'Z')].map { |i| i.to_a }.flatten
-    @runID = (0...50).map{ o[rand(o.length)] }.join
-    @delayed_messages = []
-    p @runID
-    @connectionError = nil
-    p "Initiating STDDTool(#{@url}) formatter for #{@job} : #{@buildnr}"
-    @inside_outline = false
-  end
 
-  def embed(src, mime_type, label)
-    p "got embedding"
-    case(mime_type)
-    when /^image\/(png|gif|jpg|jpeg)/
-      p "Encoding image from #{src}"
-      buf = Base64.encode64(open(src,'rb') { |io| io.read })
-      embeddingObj=EmbeddingObj.new(mime_type,buf)
-
-      p "starts to post embedding"
-      postEmbedding(@scenarioID,embeddingObj)
-      p "posted embedding to scenario with id : #{@scenarioID}"
-    end
-  end
 
-  def puts(message)
-    @delayed_messages << message
-  end
 
+module Cucumber
+  module Formatter
+    class STDDTool
+      include Io
+      attr_reader :runtime
 
+      AST_CLASSES = {
+          Cucumber::Ast::Scenario        => 'scenario',
+          Cucumber::Ast::ScenarioOutline => 'scenario_outline'
+      }
 
-  def before_feature(feature)
-    # puts feature.source_tag_names
-    featureObj=FeatureObj.new(@job,@buildnr,feature.title,feature.description,feature.file,feature.source_tag_names,@runID)
-    postFeature(featureObj)
+      def initialize(runtime, path_or_io, options)
+        @runtime, @io, @options = runtime, ensure_io(path_or_io, "stddtool"), options
+        @delayed_messages = []
+        @io.puts @runID
+        @connection_error = nil
+        @io.puts "Initiating STDDTool(#{@url}) formatter for #{@project} : #{@module}"
+        @inside_outline = false
+        @io.flush
 
-    @feature_element = FeatureElement.new
-    @feature_element.tags  = Array.new
-    @feature_element.feature_ID = @featureID
+        @stdd_client = STDDAPI::Client.new(ENV['STDD_URL'],ENV['http_proxy'])
 
-  end
+        #Collect all enviroment-variables
+        @customer_name = ENV['CUSTOMER']
+        @project_name = ENV['PROJECT']
 
-  def tag_name(tag_name)
-    @feature_element ? @feature_element.tags.push({'name' => tag_name}) : true
-  end
+        @run_name = ENV['RUN']
+        @run_source = ENV['SOURCE']
+        @run_revision = ENV['REV']
 
-  def before_background(background)
-      # @in_background = true
-  end
+        init_customer_project_and_run(@customer_name,@project_name,@run_name,@run_source,@run_revision)
 
-  def after_background(background)
-    # @in_background = nil
-  end
+        @module_name = ENV['MODULE']
+        init_module(@module_name)
 
-  def before_step(step)
-    @delayed_messages = []
-    @start_time = Time.now
-  end
+      end
 
-  def before_step_result(*args)
-    @duration = Time.now - @start_time
-  end
+      def init_module name
+        return if @connection_error
+        valid,response = @stdd_client.create_module(@run.id,name,'cucumber',Time.now)
+        if(valid)
+          @module = response
+        else
+          @connection_error = response
+          puts @connection_error
+        end
+      end
 
-  def before_feature_element(feature_element)
-    @feature_element.element_type = AST_CLASSES[feature_element.class]
-  end
+      def init_customer_project_and_run customer_name, project_name, run_name, run_source, run_revision
+        return if @connection_error
+        #Customer
+        create_customer_if_not_exist(customer_name)
+        
+        #Project
+        create_project_if_not_exists(@customer.id,project_name)
+
+        #Run
+        valid, response = @stdd_client.create_run(@project.id,run_name,run_source,run_revision)
+        if(valid)
+          @run = response
+        else
+          @connection_error = response
+          puts @connection_error
+        end
 
-  def background_name(keyword, name, file_colon_line, source_indent)
-    p "Background #{name}"
-    @feature_element.name=name
-    @feature_element.keyword = keyword
-    postFeatureElement(@feature_element)
-  end
+      end
 
-  def scenario_name(keyword, name, file_colon_line, source_indent)
-    p "scenario #{name}"
-    @feature_element.name=name
-    @feature_element.keyword = keyword
-    postFeatureElement(@feature_element)
-  end
+      def create_customer_if_not_exist customer_name
+        return if @connection_error
+        # Kontrollera om kunden finns
+        valid, response = @stdd_client.get_customer customer_name
 
-  def after_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line)
-    step_name = step_match.format_args(lambda{|param| "*#{param}*"})
-    stepObj=StepObj.new(keyword,step_name,status,exception, @duration,@delayed_messages)
-    postStep(@scenarioID,stepObj)
-    #end
-  end
+        # Om kunden finns
+        if(valid && response)
+          puts "Customer already exists"
+        else
+          puts "Customer does not exist, creating new.."
+          # Skapa en kund
+          valid, response = @stdd_client.create_customer customer_name
+        end
+
+        if(valid)
+          @customer = response
+          return true
+        else
+          @connection_error = response
+          puts @connection_error
+          return false
+        end
+
+      end
+
+    def create_project_if_not_exists customer_id,project_name
+      return if @connection_error
+      # Kontrollera om projektet finns
+      valid, response = @stdd_client.get_project customer_id, project_name
+
+      # Om projektet finns
+      if(valid)
+        puts "Project already exists"
+        @project = response
+        return true
+      end
+
+      puts "Project does not exist, creating new.."
+      # Skapa ett projekt
+      valid, response = @stdd_client.create_project customer_id, project_name
+      if valid
+        @project = response
+        return true
+      else
+        @connection_error = response
+        puts @connection_error
+        return false
+      end
 
-  def postFeature(featureObj)
-    if @connectionError
-      p "FEATURE WILL NOT BE REPORTED TO STDDTOOL DUE TO : #{@connectionError}"
-      return
     end
 
-    p "posting feature #{featureObj.feature_title}"
-    uri = URI.parse(@url)
-    begin
-      http = Net::HTTP::Proxy(@proxy.host, @proxy.port).new(uri.host, uri.port)
-      request = Net::HTTP::Post.new("/collectionapi/features")
-      request.add_field('X-Auth-Token', '97f0ad9e24ca5e0408a269748d7fe0a0')
-      request.body = featureObj.to_json
-      response = http.request(request)
-      case response.code 
-        when /20\d/
+    def embed(src, mime_type, label)
+      return if @connection_error
+      @io.puts "got embedding"
+      case mime_type
+      when /^image\/(png|gif|jpg|jpeg)/
+        buf = Base64.encode64(open(src,'rb') { |io| io.read })
+        embedding=STDDAPI::Objects::Embedding.new(@scenario.id,mime_type,buf)
+      
+        valid,response = @stdd_client.add_embedding_to_scenario(embedding)
+        if(valid)
           #success
         else
-          p response.body
-          @connectionError = response.body
-          p @connectionError
+          @connection_error = response
+          puts @connection_error
+        end
       end
+    end
 
-      parsed = JSON.parse(response.body)
+      def before_feature(feature)
+        return if @connection_error
+        # puts feature.source_tag_names
+        @feature = STDDAPI::Objects::Feature.new(@module.id,feature.title,Time.now)
+        @feature.description = feature.description
+        @feature.tags = feature.source_tag_names
+        @feature.file = feature.file
+
+        valid,response = @stdd_client.create_feature(@feature)
+        if(valid)
+          @feature.id = response
+        else
+          @connection_error = response
+          puts @connection_error
+        end
+
+        # @feature_element = FeatureElement.new
+        # @feature_element.tags  = Array.new
+        # @feature_element.feature_ID = @featureID
+        @scenario = STDDAPI::Objects::Scenario.new(@feature.id, "",'scenario','Scenario')
+        @scenario.tags=Array.new
 
-      if parsed["error"]
-        p parsed["error"]
       end
-      @featureID =  parsed["_id"]
 
-    rescue
+      def tag_name(tag_name)
+        return if @connection_error
+        @scenario ? @scenario.tags.push({'name' => tag_name}) : true
+      end
 
-      @connectionError = "COULD NOT CONNECT TO HOST AT: #{@url}"
-      p @connectionError
-    end
+      def before_step(step)
+        return if @connection_error
+        @delayed_messages = []
+        @step_start_time = Time.now
+      end
 
-  end
+      def before_step_result(*args)
+        return if @connection_error
+        @step_duration = Time.now - @step_start_time
+      end
 
+      def before_feature_element(feature_element)
+        return if @connection_error
+        @scenario.element_type = AST_CLASSES[feature_element.class]
+      end
 
-# def before_outline_table(outline_table)
-#   @inside_outline = true
-# end
-
-# def after_outline_table(outline_table)
-#   @inside_outline = false
-# end
-
-# def before_examples(examples)
-#  @inside_outline = true
-# end
-    
-# def  after_examples(examples)
-#   @inside_outline = false
-# end
-# def before_table_row(table_row)
-#   # @cellArray = Array.new
-# end
-
-# #additional code for scenario-outline
-
-# def before_outline_table(outline_table)
-#   p "before outline table"
-#   @inside_outline = true
-#   @outline_row = 0
-# end
-
-# def after_outline_table(outline_table)
-#   p "after outline table"
-#   @outline_row = nil
-#   @inside_outline = false
-# end
-
-# def before_examples(examples)
-#    @examples_array = Array.new
-#    @examplesRowNumber=0;
-# end
-
-# def examples_name(keyword, name)
-#   p "keyword: #{keyword}"
-#   p "name: #{name}"
-# end
-    
-# # def  after_examples_array(arg1)
-# #   p "after examples array: #{arg1}"
-# # end
-# def before_table_row(table_row)
-#   # @cellArray = Array.new
-# end
-
-# def table_cell_value(value, status)
-#   scenarioExampleCell=ScenarioExampleCell.new(@examplesRowNumber,value,status)
-#   postScenarioExampleCell(@scenarioID,scenarioExampleCell)
-# end
-
-# def after_table_row(table_row)
-  
-#     p @cellArray
-#   if table_row.exception
-#     p "tr exception: #{table_row.exception}"
-    
-#   end
-#   p "after table row"
-#   if @outline_row
-#     @outline_row += 1
-#   end
-#   @examplesRowNumber = @examplesRowNumber +1
-# end
-
-# def after_examples(examples)
-#   p "after examples"
-# end
-
-
-
-
-  def postStep(scenarioID,stepObj)
-    return if @connectionError
-
-    p "posting step #{stepObj.step_name}"
-    uri = URI.parse(@url)
-    path = "/collectionapi/scenarios/#{scenarioID}"
-    req = Net::HTTP::Put.new(path, initheader = { 'X-Auth-Token' => '97f0ad9e24ca5e0408a269748d7fe0a0'})
-    req.body = stepObj.to_json
-    response = Net::HTTP::Proxy(@proxy.host, @proxy.port).new(uri.host, uri.port).start {|http| http.request(req) }
-  end
+      def background_name(keyword, name, file_colon_line, source_indent)
+        return if @connection_error
+        @io.puts "Background #{name}"
+        @scenario.name=name
+        @scenario.keyword = keyword
+        post_scenario
 
-  def postEmbedding(scenarioID,embeddingObj)
-    return if @connectionError
+      end
 
-    uri = URI.parse(@url)
-    path = "/collectionapi/scenarios/#{scenarioID}"
-    req = Net::HTTP::Put.new(path, initheader = { 'X-Auth-Token' => '97f0ad9e24ca5e0408a269748d7fe0a0'})
-    req.body = embeddingObj.to_json
-    response = Net::HTTP::Proxy(@proxy.host, @proxy.port).new(uri.host, uri.port).start {|http| http.request(req) }
-  end
+      def scenario_name(keyword, name, file_colon_line, source_indent)
+        return if @connection_error
+        @io.puts "scenario #{name}"
+        @scenario.name=name
+        @scenario.keyword = keyword
+        post_scenario
+        
+      end
 
-  def postFeatureElement(feature_element)
-    return if @connectionError
-    if @inside_outline
-      p "in outline"
-    end
-    p "posting featureElement #{feature_element.name}"
-    uri = URI.parse(@url)
-    http = Net::HTTP::Proxy(@proxy.host, @proxy.port).new(uri.host, uri.port)
-    request = Net::HTTP::Post.new("/collectionapi/scenarios")
-    request.add_field('X-Auth-Token', '97f0ad9e24ca5e0408a269748d7fe0a0')
-    request.body = feature_element.to_json
-    response = http.request(request)
-    # puts response.body
-    parsed = JSON.parse(response.body)
-    @scenarioID =  parsed["_id"]
-  end
+      def post_scenario
+        return if @connection_error
+        valid,response = @stdd_client.create_scenario(@scenario)
+        if(valid)
+          @scenario.id = response
+        else
+          @connection_error = response
+          puts @connection_error
+        end
+      end
 
-  # def postScenarioExampleCell(scenarioID,scenarioExampleItem)
-  #   p "posting postScenarioExampleCell"
-  #   uri = URI.parse(@url)
-  #   path = "/collectionapi/scenarios/#{scenarioID}"
-  #   req = Net::HTTP::Put.new(path, initheader = { 'X-Auth-Token' => '97f0ad9e24ca5e0408a269748d7fe0a0'})
-  #   req.body = scenarioExampleItem.to_json
-  #   response = Net::HTTP::Proxy(@proxy.host, @proxy.port).new(uri.host, uri.port).start {|http| http.request(req) }
-  # end
+      def after_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line)
+        return if @connection_error
+        step_name = step_match.format_args(lambda{|param| "*#{param}*"})
+        @step = STDDAPI::Objects::Step.new(@scenario.id,keyword, step_name)
+        @step.status=status
+        @step.error_message = exception
+        @step.duration = @step_duration
+        @step.messages = @delayed_messages 
+
+        valid,response = @stdd_client.add_step_to_scenario(@step)
+        if(valid)
+          # success
+        else
+          @connection_error = response
+          puts @connection_error
+        end
+      end
 
-end
+      def after_features(features)
+        return if @connection_error
+        valid, response = @stdd_client.update_module_stopTime(@module.id,Time.now)
+        if(valid)
+          @module = response
+        else
+          @connection_error = response
+          puts @connection_error
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stddtool
 version: !ruby/object:Gem::Version
-  version: 0.3.1.1
+  version: 0.5.0.1
 platform: ruby
 authors:
 - Anton Danielsson
@@ -11,15 +11,28 @@ autorequire:
 bindir: bin
 cert_chain: []
 date: 2014-02-05 00:00:00.000000000 Z
-dependencies: []
-description: Cucumber formatter that reports the cucumber testresults to STDDTool
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: stdd_api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.2.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.2.0.1
+description: Cucumber formatter that reports  cucumber testresults to STDDTool
 email: anton.danielsson@learningwell.se
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/stddtool.rb
-- lib/objects.rb
 homepage: https://github.com/antda/cucumber-stddtool
 licenses:
 - MIT

data/lib/objects.rb

@@ -1,94 +0,0 @@
-# encoding: utf-8
-
-class FeatureObj
-  def initialize(job,build,title,description,file,tags,runId)
-    @id = title.downcase.gsub(' ', '-')
-    @job = job
-    @build = build
-    @feature_title=title
-    @feature_description = description
-    @feature_file = file
-    @runID = runId
-
-    tagArr = Array.new
-    tags.each do |tag|
-      tagArr.push({'name' => tag})
-    end
-
-    @feature_tags = tagArr
-
-  end
-  attr_accessor :feature_title
-  def to_json
-    {
-      'id' => @id,
-      'job' => @job,
-      'build' => @build,
-      'runID' => @runID,
-      'title' => @feature_title,
-      'description' => @feature_description ,
-      'file' => @feature_file,
-      'tags' => @feature_tags,
-      }.to_json
-  end
-end
-
-
-class StepObj
-  def initialize(keyword, name, status,exception,duration,messages)
-    @step_keyword=keyword
-    @step_name=name
-    @step_status=status
-    @step_exception = exception
-    @step_duration = duration
-    @step_messages = messages
-  end
-  attr_accessor :step_name
-  def to_json
-      {'$addToSet' => 
-        {'steps' =>{'keyword' => @step_keyword,
-                    'name' => @step_name ,
-                    'result' => {'status' =>@step_status,'error_message'=> @step_exception,'duration'=>@step_duration},
-                    'messages' => @step_messages
-                  }
-        }
-      }.to_json
-  end
-end
-
-class FeatureElement
-  def initialize()
-    tags = Array.new
-  end
-  attr_accessor :feature_ID,:keyword,:tags,:name,:element_type
-  def to_json
-      {'featureId' => @feature_ID,'keyword' => @keyword, 'name' => @name,'tags' => @tags,'element_type' => @element_type}.to_json
-  end
-end
-
-class EmbeddingObj
-  def initialize(mime_type,data)
-    @mime_type = mime_type
-    @data=data
-  end
-  def to_json
-      {'$addToSet' =>{'embeddings' =>{'mime_type' => @mime_type,'data' => @data}}}.to_json
-  end
-end
-
-# class ScenarioExampleCell
-#   def initialize(row,value,status)
-#     @row = row
-#     @value=value
-#     @status=status
-#   end
-#   def to_json
-#       {"$addToSet" => 
-#         {"outline.#{@row.to_s}" =>{ 
-#                   "value" => @value,
-#                   "status" => @status
-#                 }
-#         }
-#       }.to_json
-#   end
-# end