jmeter-ruby 3.0.0

data/lib/jmeter-ruby/helpers/logger-colors.rb

@@ -0,0 +1,48 @@
+require 'logger' 
+
+class Logger
+  module Colors
+    VERSION = '1.0.0'
+
+    NOTHING      = '0;0'
+    BLACK        = '0;30'
+    RED          = '0;31'
+    GREEN        = '0;32'
+    BROWN        = '0;33'
+    BLUE         = '0;34'
+    PURPLE       = '0;35'
+    CYAN         = '0;36'
+    LIGHT_GRAY   = '0;37'
+    DARK_GRAY    = '1;30'
+    LIGHT_RED    = '1;31'
+    LIGHT_GREEN  = '1;32'
+    YELLOW       = '1;33'
+    LIGHT_BLUE   = '1;34'
+    LIGHT_PURPLE = '1;35'
+    LIGHT_CYAN   = '1;36'
+    WHITE        = '1;37'
+
+    SCHEMA = {
+      STDOUT => %w[nothing green brown red purple cyan],
+      STDERR => %w[nothing green yellow light_red light_purple light_cyan],
+    }
+  end
+end
+
+class Logger
+  alias format_message_colorless format_message
+
+  def format_message(level, *args)
+    if Logger::Colors::SCHEMA[@logdev.dev]
+      color = begin
+        Logger::Colors.const_get \
+          Logger::Colors::SCHEMA[@logdev.dev][Logger.const_get(level.sub "ANY","UNKNOWN")].to_s.upcase
+      rescue NameError
+        "0;0"
+      end
+      "\e[#{ color }m#{ format_message_colorless(level, *args) }\e[0;0m" 
+    else
+      format_message_colorless(level, *args)
+    end
+  end
+end

data/lib/jmeter-ruby/helpers/parser.rb

@@ -0,0 +1,135 @@
+module JmeterRuby
+  module Parser
+
+    def parse_http_request(params)
+      if params[:raw_path]
+        params[:path] = params[:url]
+        parse_url(params)
+      else
+        parse_url(params)
+        params[:fill_in] ||= {}
+        params[:params] && params[:params].split('&').each do |param|
+          name,value = param.split('=')
+          params[:fill_in][name] ||= []
+          params[:fill_in][name] << value
+        end
+      end
+
+      fill_in(params) if params.has_key?(:fill_in)
+      raw_body(params) if params.has_key?(:raw_body)
+      files(params) if params.has_key?(:files)
+    end
+
+    def parse_url(params)
+      return if params[:url].empty?
+      if params[:url] =~ /https?:\/\/\$/ || params[:url][0] == '$'
+        params[:path] = params[:url] # special case for named expressions
+      else
+        uri = parse_uri(params[:url])
+        params[:port]     ||= uri.port unless URI.parse(URI::Parser.new.escape(params[:url])).scheme.nil?
+        params[:protocol] ||= uri.scheme unless URI.parse(URI::Parser.new.escape(params[:url])).scheme.nil?
+        params[:domain]   ||= uri.host
+        params[:path]     ||= uri.path && URI::Parser.new.unescape(uri.path)
+        params[:params]   ||= uri.query && URI::Parser.new.unescape(uri.query)
+      end
+      params.delete(:url)
+    end
+
+    def parse_uri(uri)
+      URI.parse(URI::Parser.new.escape(uri)).scheme.nil? ?
+        URI.parse(URI::Parser.new.escape("http://#{uri}")) :
+        URI.parse(URI::Parser.new.escape(uri))
+    end
+
+    def fill_in(params)
+      params[:update_at_xpath] ||= []
+      params[:update_at_xpath] = params[:fill_in].
+        each_with_object(params[:update_at_xpath]) do |(name, values), memo|
+           Array(values).each do |value|
+            memo << {
+              :xpath => '//collectionProp',
+              :value => Nokogiri::XML(<<-EOF.strip_heredoc).children
+                <elementProp name="#{name}" elementType="HTTPArgument">
+                  <boolProp name="HTTPArgument.always_encode">#{params[:always_encode] ? 'true' : false}</boolProp>
+                  <stringProp name="Argument.value">#{value}</stringProp>
+                  <stringProp name="Argument.metadata">=</stringProp>
+                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                  <stringProp name="Argument.name">#{name}</stringProp>
+                </elementProp>
+                EOF
+            }
+          end
+        end
+      params.delete(:fill_in)
+    end
+
+    def raw_body(params)
+      params[:update_at_xpath] ||= []
+      params[:update_at_xpath] << {
+        :xpath => '//HTTPSamplerProxy',
+        :value => Nokogiri::XML(<<-EOF.strip_heredoc).children
+          <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
+          EOF
+      }
+
+      params[:update_at_xpath] << {
+        :xpath => '//collectionProp',
+        :value => Nokogiri::XML(<<-EOF.strip_heredoc).children
+          <elementProp name="" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">false</boolProp>
+            <stringProp name="Argument.value">#{params[:raw_body].encode(:xml => :text)}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+          </elementProp>
+          EOF
+      }
+      params.delete(:raw_body)
+    end
+
+    def files(params)
+      files = params.delete(:files)
+      return if files.empty?
+      x = Nokogiri::XML::Builder.new do |b|
+        b.elementProp(name: "HTTPsampler.Files", elementType: "HTTPFileArgs") {
+          b.collectionProp(name: "HTTPFileArgs.files") {
+            files.each do |f|
+              b.elementProp(name: f[:path], elementType: "HTTPFileArg") {
+                b.stringProp f[:path] || '' , name: "File.path"
+                b.stringProp f[:paramname] || '' , name: "File.paramname"
+                b.stringProp f[:mimetype] || '' , name: "File.mimetype"
+              }
+            end
+          }
+        }
+      end
+      params[:update_at_xpath] ||= []
+      params[:update_at_xpath] << {
+        :xpath => '//HTTPSamplerProxy',
+        :value => x.doc.root
+      }
+    end
+
+    def parse_test_type(params)
+      case params.keys.first.to_s
+      when 'contains'
+        2
+      when 'not-contains'
+        6
+      when 'matches'
+        1
+      when 'not-matches'
+        5
+      when 'equals'
+        8
+      when 'not-equals'
+        12
+      when 'substring'
+        16
+      when 'not-substring'
+        20
+      else
+        2
+      end
+    end
+
+  end
+end

data/lib/jmeter-ruby/helpers/strip-heredoc.rb

@@ -0,0 +1,5 @@
+class String
+  def strip_heredoc
+    gsub /^#{self[/\A\s*/]}/, ''
+  end
+end

data/lib/jmeter-ruby/helpers/user-agents.rb

@@ -0,0 +1,27 @@
+module JmeterRuby
+  class UserAgent
+    def initialize(device)
+      @common_devices = {
+        :iphone     => 'Mozilla/5.0 (iPhone; CPU iPhone OS 5_1 like Mac OS X) AppleWebKit/534.46 (KHTML, like Gecko) Version/5.1 Mobile/9B179 Safari/7534.48.3',
+        :ipod       => 'Mozilla/5.0 (iPod; CPU iPhone OS 5_1 like Mac OS X) AppleWebKit/534.46 (KHTML, like Gecko) Version/5.1 Mobile/9B176 Safari/7534.48.3',
+        :ipad       => 'Mozilla/5.0 (iPad; CPU OS 5_1 like Mac OS X) AppleWebKit/534.46 (KHTML, like Gecko) Version/5.1 Mobile/9B176 Safari/7534.48.3',
+        :safari_osx => 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) AppleWebKit/536.25 (KHTML, like Gecko) Version/6.0 Safari/536.25',
+        :safari_win => 'Mozilla/5.0 (Windows; Windows NT 6.1) AppleWebKit/534.57.2 (KHTML, like Gecko) Version/5.1.7 Safari/534.57.2',
+        :ie7        => 'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.0)',
+        :ie8        => 'Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.0; Trident/4.0)',
+        :ie9        => 'Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)',
+        :chrome_osx => 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.46 Safari/536.5',
+        :chrome_win => 'Mozilla/5.0 (Windows; Windows NT 6.1) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.46 Safari/536.5',
+        :ff_osx     => 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.7; rv:11.0) Gecko/20100101 Firefox/11.0',
+        :ff_win     => 'Mozilla/5.0 (Windows NT 6.1; rv:11.0) Gecko/20100101 Firefox/11.0',
+        :opera_osx  => 'Opera/9.80 (Macintosh; Intel Mac OS X 10.7.4; U; en) Presto/2.10.229 Version/11.62',
+        :opera_win  => 'Opera/9.80 (Windows NT 6.1; U; en) Presto/2.10.229 Version/11.62'
+      }
+      @device = device
+    end
+
+    def string
+      @common_devices[@device] || @common_devices[:chrome_osx]
+    end
+  end
+end

data/lib/jmeter-ruby/idl.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+# This is an IDL script to translate a JMeter testplan into Ruby DSL objects
+require 'nokogiri'
+require 'pathname'
+
+home = Pathname("..").expand_path(__FILE__)
+dsl  = File.join(home, "/dsl")
+
+file = File.open File.join(home, "idl.xml")
+doc = Nokogiri::XML file.read.gsub! /\n\s+/, ''
+nodes = doc.xpath '//jmeterTestPlan/hashTree'
+
+class String
+  def classify
+    return self if self !~ / / && self =~ /[A-Z]+.*/
+    split(' ').map{|e| e.capitalize}.join.gsub /[\(\)-\/\.]/, ''
+  end
+
+  def underscore
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+end
+
+results = []
+doc.traverse do |node|
+  results << node if node.class !=
+    Nokogiri::XML::Document &&
+    node.attributes['testclass'] &&
+    node.name != 'elementProp'
+end
+
+methods = []
+methods << "# JmeterRuby::DSL methods"
+results.each do |element|
+  klass = element.attributes['testname'].to_s.classify
+  methods << "- #{element.attributes['testname'].to_s}\n  `#{klass.underscore}`"
+  Dir.mkdir(dsl, 0700) unless Dir.exist? dsl
+  File.open("#{dsl}/#{klass.underscore}.rb", 'w') { |file| file.write(<<EOC)
+module JmeterRuby
+  class DSL
+    def #{klass.underscore}(params={}, &block)
+      node = JmeterRuby::#{klass}.new(params)
+      attach_node(node, &block)
+    end
+  end
+
+  class #{klass}
+    attr_accessor :doc
+    include Helper
+
+    def initialize(params={})
+      testname = params.kind_of?(Array) ? '#{klass}' : (params[:name] || '#{klass}')
+      @doc = Nokogiri::XML(<<-EOS.strip_heredoc)
+#{element.to_xml.gsub /testname=".+?"/, 'testname="#{testname}"'})
+      EOS
+      update params
+      update_at_xpath params if params.is_a?(Hash) && params[:update_at_xpath]
+    end
+  end
+
+end
+EOC
+}
+end
+
+File.open("#{home}/DSL.md", 'w') { |file| file.write methods.join("\n") }