jmeter-ruby 3.0.0

data/lib/jmeter-ruby/extend/controllers/foreach_controller.rb

@@ -0,0 +1,27 @@
+module JmeterRuby
+  class ExtendedDSL < DSL
+    def foreach_controller(params = {}, &block)
+      node = JmeterRuby::ForeachController.new(params).tap do |node|
+        if params[:start_index]
+          params[:startIndex] = params[:start_index]
+          node.doc.children.first.add_child (
+            Nokogiri::XML(<<-EOS.strip_heredoc).children
+              <stringProp name="ForeachController.startIndex"/>
+            EOS
+          )
+        end
+
+        if params[:end_index]
+          params[:endIndex] = params[:end_index]
+          node.doc.children.first.add_child (
+            Nokogiri::XML(<<-EOS.strip_heredoc).children
+              <stringProp name="ForeachController.endIndex"/>
+            EOS
+          )
+        end
+      end
+
+      attach_node(node, &block)
+    end
+  end
+end

data/lib/jmeter-ruby/extend/controllers/loop_controller.rb

@@ -0,0 +1,11 @@
+module JmeterRuby
+  class ExtendedDSL < DSL
+    def loop_controller(params, &block)
+      params[:loops] = params[:count] || 1
+
+      super
+    end
+
+    alias loops loop_controller
+  end
+end

data/lib/jmeter-ruby/extend/controllers/module_controller.rb

@@ -0,0 +1,23 @@
+module JmeterRuby
+  class ExtendedDSL < DSL
+    def module_controller(params, &block)
+      node = JmeterRuby::ModuleController.new(params)
+
+      if params[:test_fragment]
+        params[:test_fragment].kind_of?(String) &&
+        params[:test_fragment].split('/')
+      elsif params[:node_path]
+        params[:node_path]
+      else
+        []
+      end.each_with_index do |node_name, index|
+        node.doc.at_xpath('//collectionProp') <<
+          Nokogiri::XML(<<-EOS.strip_heredoc).children
+            <stringProp name="node_#{index}">#{node_name}</stringProp>
+          EOS
+      end
+
+      attach_node(node, &block)
+    end
+  end
+end

data/lib/jmeter-ruby/extend/controllers/throughput_controller.rb

@@ -0,0 +1,15 @@
+module JmeterRuby
+  class ExtendedDSL < DSL
+    def throughput_controller(params = {}, &block)
+      params[:style] = 1 if params[:percent]
+      params[:maxThroughput] = params[:total] || params[:percent] || 1
+
+      node = JmeterRuby::ThroughputController.new(params)
+      node.doc.xpath(".//FloatProperty/value").first.content = params[:maxThroughput].to_f
+
+      attach_node(node, &block)
+    end
+
+    alias throughput throughput_controller
+  end
+end

data/lib/jmeter-ruby/extend/controllers/transaction_controller.rb

@@ -0,0 +1,14 @@
+module JmeterRuby
+  class ExtendedDSL < DSL
+    def transaction_controller(*args, &block)
+      params = args.shift || {}
+      params = { name: params }.merge(args.shift || {}) if params.class == String
+      params[:parent] = params[:parent] || false
+      params[:includeTimers] = params[:include_timers] || false
+      node = JmeterRuby::TransactionController.new(params)
+      attach_node(node, &block)
+    end
+
+    alias transaction transaction_controller
+  end
+end

data/lib/jmeter-ruby/extend/misc/aliases.rb

@@ -0,0 +1,21 @@
+module JmeterRuby
+  class ExtendedDSL < DSL
+    alias auth http_authorization_manager
+    alias soap soapxmlrpc_request
+    alias ldap ldap_request
+    alias ldap_ext ldap_extended_request
+    alias ldap_extended ldap_extended_request
+    alias If if_controller
+    alias Switch switch_controller
+    alias While while_controller
+    alias Interleave random_controller
+    alias Random_order random_order_controller
+    alias Simple simple_controller
+    alias Once once_only_controller
+    alias view_results view_results_tree
+    alias log simple_data_writer
+    alias response_graph response_time_graph
+    alias bsh_pre beanshell_preprocessor
+    alias bsh_post beanshell_postprocessor
+  end
+end

data/lib/jmeter-ruby/extend/misc/exists.rb

@@ -0,0 +1,13 @@
+module JmeterRuby
+  class ExtendedDSL < DSL
+    def exists(variable, &block)
+      params ||= {}
+      params[:condition] = "\"${#{variable}}\" != \"\\${#{variable}}\""
+      params[:useExpression] = false
+      params[:name] = "if ${#{variable}}"
+      node = JmeterRuby::IfController.new(params)
+
+      attach_node(node, &block)
+    end
+  end
+end

data/lib/jmeter-ruby/extend/misc/rsync.rb

@@ -0,0 +1,24 @@
+module JmeterRuby
+  class ExtendedDSL < DSL
+    def rsync(params = {})
+      logger.warn "Test file upload via rsync ..."
+
+      file(params)
+
+      cmd = "#{params[:rsync_bin_path]} #{params[:rsync_params]} #{params[:file]} #{params[:remote_user]}@#{params[:remote_host]}:#{params[:remote_path]}"
+
+      logger.debug cmd if params[:debug]
+
+      Open3.popen2e("#{cmd}") do |stdin, stdout_err, wait_thr|
+        while line = stdout_err.gets
+          logger.debug line.chomp if params[:debug]
+        end
+
+        exit_status = wait_thr.value
+        abort "Sorry there was an error: #{cmd}" unless exit_status.success?
+      end
+
+      logger.info "Upload complete at: #{params[:remote_host]}:#{params[:remote_path]}"
+    end
+  end
+end

data/lib/jmeter-ruby/extend/misc/uuid.rb

@@ -0,0 +1,12 @@
+module JmeterRuby
+  class ExtendedDSL < DSL
+    def uuid_per_iteration(params = {}, &block)
+      params[:name] ||= '__UUID'
+      params[:variable] ||= 'UUID'
+
+      dummy_sampler name: params[:name], response_data: '${__UUID}' do
+        regex pattern: '(.*)', name: params[:variable], match_number: 1
+      end
+    end
+  end
+end

data/lib/jmeter-ruby/extend/misc/with_helpers.rb

@@ -0,0 +1,27 @@
+module JmeterRuby
+  class ExtendedDSL < DSL
+    def with_user_agent(device)
+      http_header_manager name: 'User-Agent', value: JmeterRuby::UserAgent.new(device).string
+    end
+
+    def with_browser(device)
+      http_header_manager name: 'User-Agent', value: JmeterRuby::UserAgent.new(device).string
+      http_header_manager [
+        { name: 'Accept-Encoding', value: 'gzip,deflate,sdch' },
+        { name: 'Accept', value: 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8' }
+      ]
+    end
+
+    def with_xhr
+      http_header_manager name: 'X-Requested-With', value: 'XMLHttpRequest'
+    end
+
+    def with_gzip
+      http_header_manager name: 'Accept-Encoding', value: 'gzip, deflate'
+    end
+
+    def with_json
+      http_header_manager name: 'Accept', value: 'text/html, application/xhtml+xml, application/xml;q=0.9, */*;q=0.8, application/json'
+    end
+  end
+end

data/lib/jmeter-ruby/extend/plugins/jmeter_plugins.rb

@@ -0,0 +1,120 @@
+module JmeterRuby
+  class ExtendedDSL < DSL
+    def response_codes_per_second(params = {}, &block)
+      node = JmeterRuby::Plugins::ResponseCodesPerSecond.new(params)
+      attach_node(node, &block)
+    end
+
+    def response_times_distribution(params = {}, &block)
+      node = JmeterRuby::Plugins::ResponseTimesDistribution.new(params)
+      attach_node(node, &block)
+    end
+
+    def response_times_over_time(params = {}, &block)
+      node = JmeterRuby::Plugins::ResponseTimesOverTime.new(params)
+      attach_node(node, &block)
+    end
+
+    def response_times_percentiles(params = {}, &block)
+      node = JmeterRuby::Plugins::ResponseTimesPercentiles.new(params)
+      attach_node(node, &block)
+    end
+
+    def transactions_per_second(params = {}, &block)
+      node = JmeterRuby::Plugins::TransactionsPerSecond.new(params)
+      attach_node(node, &block)
+    end
+
+    def latencies_over_time(params = {}, &block)
+      node = JmeterRuby::Plugins::LatenciesOverTime.new(params)
+      attach_node(node, &block)
+    end
+
+    def console_status_logger(params = {}, &block)
+      node = JmeterRuby::Plugins::ConsoleStatusLogger.new(params)
+      attach_node(node, &block)
+    end
+
+    alias console console_status_logger
+
+    def throughput_shaper(params = {}, &block)
+      node = JmeterRuby::Plugins::ThroughputShapingTimer.new(params)
+      attach_node(node, &block)
+    end
+
+    alias shaper throughput_shaper
+
+    def dummy_sampler(params = {}, &block)
+      node = JmeterRuby::Plugins::DummySampler.new(params)
+      attach_node(node, &block)
+    end
+
+    alias dummy dummy_sampler
+
+    def stepping_thread_group(params = {}, &block)
+      node = JmeterRuby::Plugins::SteppingThreadGroup.new(params)
+      attach_node(node, &block)
+    end
+
+    alias step stepping_thread_group
+
+    def ultimate_thread_group(params = {}, &block)
+      node = JmeterRuby::Plugins::UltimateThreadGroup.new(params)
+
+       (params.kind_of?(Array) ? params : params[:threads]).each_with_index do |group, index|
+        node.doc.at_xpath('//collectionProp') <<
+          Nokogiri::XML(<<-EOS.strip_heredoc).children
+            <collectionProp name="index">
+              <stringProp name="#{group[:start_threads]}">#{group[:start_threads]}</stringProp>
+              <stringProp name="#{group[:initial_delay]}">#{group[:initial_delay]}</stringProp>
+              <stringProp name="#{group[:start_time]}">#{group[:start_time]}</stringProp>
+              <stringProp name="#{group[:hold_time]}">#{group[:hold_time]}</stringProp>
+              <stringProp name="#{group[:stop_time]}">#{group[:stop_time]}</stringProp>
+            </collectionProp>
+          EOS
+      end
+
+      attach_node(node, &block)
+    end
+
+    alias ultimate ultimate_thread_group
+
+    def composite_graph(params = {}, &block)
+      node = JmeterRuby::Plugins::CompositeGraph.new(params)
+      attach_node(node, &block)
+    end
+
+    alias composite composite_graph
+
+    def active_threads_over_time(params = {}, &block)
+      node = JmeterRuby::Plugins::ActiveThreadsOverTime.new(params)
+      attach_node(node, &block)
+    end
+
+    alias active_threads active_threads_over_time
+
+    def perfmon_collector(params = {}, &block)
+      node = JmeterRuby::Plugins::PerfmonCollector.new(params)
+      attach_node(node, &block)
+    end
+
+    alias perfmon perfmon_collector
+
+    def loadosophia_uploader(params = {}, &block)
+      node = JmeterRuby::Plugins::LoadosophiaUploader.new(params)
+      attach_node(node, &block)
+    end
+
+    alias loadosophia loadosophia_uploader
+
+    def redis_data_set(params = {}, &block)
+      node = JmeterRuby::Plugins::RedisDataSet.new(params)
+      attach_node(node, &block)
+    end
+
+    def jmx_collector(params = {}, &block)
+      node = JmeterRuby::Plugins::JMXCollector.new(params)
+      attach_node(node, &block)
+    end
+  end
+end

data/lib/jmeter-ruby/extend/processors/extract.rb

@@ -0,0 +1,28 @@
+module JmeterRuby
+  class ExtendedDSL < DSL
+    def extract(params, &block)
+      node = if params[:regex]
+        params[:refname] = params[:name]
+        params[:regex] = params[:regex] #CGI.escapeHTML
+        params[:template] = params[:template] || "$1$"
+        JmeterRuby::RegularExpressionExtractor.new(params)
+      elsif params[:xpath]
+        params[:refname] = params[:name]
+        params[:xpathQuery] = params[:xpath]
+        JmeterRuby::XpathExtractor.new(params)
+      elsif params[:json]
+        params[:VAR] = params[:name]
+        params[:JSONPATH] = params[:json]
+        JmeterRuby::Plugins::JsonPathExtractor.new(params)
+      elsif params[:css]
+        params[:refname] = params[:name]
+        params[:expr] = params[:css]
+        JmeterRuby::CssjqueryExtractor.new(params)
+      end
+
+      attach_node(node, &block)
+    end
+
+    alias web_reg_save_param extract
+  end
+end

data/lib/jmeter-ruby/extend/processors/regular_expression_extractor.rb

@@ -0,0 +1,25 @@
+module JmeterRuby
+  class ExtendedDSL < DSL
+    def regular_expression_extractor(params, &block)
+      params[:refname] = params[:name]
+      params[:regex] = params[:pattern]
+      params[:template] = params[:template] || "$1$"
+
+      node = JmeterRuby::RegularExpressionExtractor.new(params).tap do |node|
+        if params[:variable]
+          node.doc.xpath("//stringProp[@name='Sample.scope']").first.content = 'variable'
+
+          node.doc.children.first.add_child (
+            Nokogiri::XML(<<-EOS.strip_heredoc).children
+              <stringProp name="Scope.variable">#{params[:variable]}</stringProp>
+            EOS
+          )
+        end
+      end
+
+      attach_node(node, &block)
+    end
+
+    alias regex regular_expression_extractor
+  end
+end

data/lib/jmeter-ruby/extend/samplers/http_request.rb

@@ -0,0 +1,58 @@
+module JmeterRuby
+  class ExtendedDSL < DSL
+    def http_request(*args, &block)
+      params = args.shift || {}
+      params = { url: params }.merge(args.shift || {}) if params.class == String
+
+      params[:method] ||= case __callee__.to_s
+      when 'visit'
+        'GET'
+      when 'submit'
+        'POST'
+      else
+        __callee__.to_s.upcase
+      end
+
+      params[:name] ||= params[:url]
+
+      parse_http_request(params)
+
+      if params[:sample]
+        transaction name: params[:name], parent: true do
+          loops count: params[:sample].to_i do
+            params.delete(:sample)
+            attach_node(http_request_node(params), &block)
+          end
+        end
+      else
+        attach_node(http_request_node(params), &block)
+      end
+    end
+
+    def http_request_node(params)
+      JmeterRuby::HttpRequest.new(params).tap do |node|
+        node.doc.children.first.add_child (
+          Nokogiri::XML(<<-EOS.strip_heredoc).children
+            <stringProp name="HTTPSampler.implementation">#{params[:implementation]}</stringProp>
+          EOS
+        ) if params[:implementation]
+
+        node.doc.children.first.add_child (
+          Nokogiri::XML(<<-EOS.strip_heredoc).children
+            <stringProp name="TestPlan.comments">#{params[:comments]}</stringProp>
+          EOS
+        ) if params[:comments]
+      end
+    end
+
+    alias request http_request
+    alias get http_request
+    alias visit http_request
+    alias post http_request
+    alias submit http_request
+    alias delete http_request
+    alias patch http_request
+    alias put http_request
+    alias head http_request
+  end
+end

data/lib/jmeter-ruby/extend/samplers/jms_pointtopoint.rb

@@ -0,0 +1,26 @@
+module JmeterRuby
+  class ExtendedDSL < DSL
+    def jms_pointtopoint(params, &block)
+
+        node = JmeterRuby::JmsPointtopoint.new(params).tap do |node|
+
+          if params[:jndi_properties]
+            params[:jndi_properties].map do |property_name, property_value|
+              node.doc.xpath('//collectionProp').first.add_child (
+               Nokogiri::XML(<<-EOS.strip_heredoc).children
+                <elementProp name="#{property_name}" elementType="Argument">
+                  <stringProp name="Argument.name">#{property_name}</stringProp>
+                  <stringProp name="Argument.value">#{property_value}</stringProp>
+                  <stringProp name="Argument.metadata">=</stringProp>
+                </elementProp>
+                EOS
+              )
+            end
+          end
+
+          attach_node(node, &block)
+
+      end
+    end
+  end
+end

data/lib/jmeter-ruby/extend/samplers/soapxmlrpc_request.rb

@@ -0,0 +1,9 @@
+module JmeterRuby
+  class ExtendedDSL < DSL
+    def soapxmlrpc_request(params, &block)
+      params[:method] ||= 'POST'
+
+      super
+    end
+  end
+end

data/lib/jmeter-ruby/extend/threads/setup_thread_group.rb

@@ -0,0 +1,18 @@
+module JmeterRuby
+  class ExtendedDSL < DSL
+    def setup_thread_group(*args, &block)
+      params = args.shift || {}
+      params = { count: params }.merge(args.shift || {}) if params.class == Integer
+      params[:num_threads] = params[:count] || 1
+      params[:ramp_time] = params[:rampup] || (params[:num_threads]/2.0).ceil
+      params[:start_time] = params[:start_time] || Time.now.to_i * 1000
+      params[:end_time] = params[:end_time] || Time.now.to_i * 1000
+      params[:duration] ||= 60
+      params[:continue_forever] ||= false
+      params[:loops] = -1 if params[:continue_forever]
+      node = JmeterRuby::SetupThreadGroup.new(params)
+
+      attach_node(node, &block)
+    end
+  end
+end

data/lib/jmeter-ruby/extend/threads/thread_group.rb

@@ -0,0 +1,19 @@
+module JmeterRuby
+  class ExtendedDSL < DSL
+    def thread_group(*args, &block)
+      params = args.shift || {}
+      params = { count: params }.merge(args.shift || {}) if params.class == Integer
+      params[:num_threads] = params[:count] || 1
+      params[:ramp_time] = params[:rampup] || (params[:num_threads]/2.0).ceil
+      params[:start_time] = params[:start_time] || Time.now.to_i * 1000
+      params[:end_time] = params[:end_time] || Time.now.to_i * 1000
+      params[:duration] ||= 60
+      params[:continue_forever] ||= false
+      params[:loops] = -1 if params[:continue_forever]
+      node = JmeterRuby::ThreadGroup.new(params)
+      attach_node(node, &block)
+    end
+
+    alias threads thread_group
+  end
+end

data/lib/jmeter-ruby/extend/timers/constant_throughput_timer.rb

@@ -0,0 +1,11 @@
+module JmeterRuby
+  class ExtendedDSL < DSL
+    def constant_throughput_timer(params, &block)
+      params[:value] ||= params[:throughput] || 0.0
+
+      node = JmeterRuby::ConstantThroughputTimer.new(params)
+      node.doc.xpath('//stringProp[@name="throughput"]').first.content = params[:value]
+      attach_node(node, &block)
+    end
+  end
+end

data/lib/jmeter-ruby/extend/timers/random_timer.rb

@@ -0,0 +1,14 @@
+module JmeterRuby
+  class ExtendedDSL < DSL
+    def random_timer(delay=0, range=0, &block)
+      params = {}
+      params[:delay] = delay
+      params[:range] = range
+      node = JmeterRuby::GaussianRandomTimer.new(params)
+
+      attach_node(node, &block)
+    end
+
+    alias think_time random_timer
+  end
+end

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

@@ -0,0 +1,54 @@
+require 'set'
+
+module JmeterRuby
+
+  class FallbackContextProxy
+    NON_PROXIED_METHODS = Set[:object_id, :__send__, :__id__, :==, :equal?, :"!", :"!=", :instance_eval,
+                              :instance_variables, :instance_variable_get, :instance_variable_set,
+                              :remove_instance_variable]
+
+    NON_PROXIED_INSTANCE_VARIABLES = Set[:@__receiver__, :@__fallback__]
+
+    instance_methods.each do |method|
+      unless NON_PROXIED_METHODS.include?(method.to_sym)
+        undef_method(method)
+      end
+    end
+
+    def initialize(receiver, fallback)
+      @__receiver__ = receiver
+      @__fallback__ = fallback
+    end
+
+    def id
+      @__receiver__.__send__(:id)
+    end
+
+    # Special case due to `Kernel#sub`'s existence
+    def sub(*args, &block)
+      __proxy_method__(:sub, *args, &block)
+    end
+
+    # Special case to allow proxy instance variables
+    def instance_variables
+      # Ruby 1.8.x returns string names, convert to symbols
+      super.map(&:to_sym) - NON_PROXIED_INSTANCE_VARIABLES.to_a
+    end
+
+    def method_missing(method, *args, &block)
+      __proxy_method__(method, *args, &block)
+    end
+
+    def __proxy_method__(method, *args, &block)
+      begin
+        @__receiver__.__send__(method.to_sym, *args, &block)
+      rescue ::NoMethodError => e
+        begin
+          @__fallback__.__send__(method.to_sym, *args, &block)
+        rescue ::NoMethodError
+          raise(e)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+module JmeterRuby
+  def dsl_eval(dsl, &block)
+    block_context = eval("self", block.binding)
+    proxy_context = JmeterRuby::FallbackContextProxy.new(dsl, block_context)
+    begin
+      block_context.instance_variables.each { |ivar| proxy_context.instance_variable_set(ivar, block_context.instance_variable_get(ivar)) }
+      proxy_context.instance_eval(&block)
+    ensure
+      block_context.instance_variables.each { |ivar| block_context.instance_variable_set(ivar, proxy_context.instance_variable_get(ivar)) }
+    end
+    dsl
+  end
+
+  module_function :dsl_eval
+
+  module Helper
+    def update(params)
+      params.delete(:name)
+      enabled_disabled(params)
+      if params.class == Array
+        update_collection params
+      else
+        params.each do |name, value|
+          node = @doc.children.xpath("//*[contains(@name,\"#{name.to_s}\")]")
+          if value.class == Nokogiri::XML::Builder
+            node.first.children = value.doc.at_xpath('//builder').children
+          else
+            node.first.content = value unless node.empty?
+          end
+
+        end
+      end
+    end
+
+    def enabled_disabled(params)
+      return unless params.is_a?(Hash)
+      @doc.children.first.attributes['enabled'].value = params[:enabled].to_s.empty? ? 'true' : 'false'
+    end
+
+    def update_at_xpath(params)
+      params[:update_at_xpath].each do |fragment|
+        if fragment[:xpath]
+          @doc.at_xpath(fragment[:xpath]) << fragment[:value]
+        else
+          fragment.each do |xpath, value|
+            @doc.at_xpath(xpath).content = value
+          end
+        end
+      end
+    end
+
+    def update_collection(params)
+      elements = @doc.at_xpath("//collectionProp/elementProp")
+      params.each_with_index do |param, index|
+        param.each do |name, value|
+          next unless elements && elements.element_children
+          element = elements.element_children.xpath("//*[contains(@name,\"#{name}\")]")
+          element.last.content = value
+        end
+        if index != params.size - 1 && elements
+           @doc.at_xpath("//collectionProp") << elements.dup
+        end
+      end
+    end
+
+    def enabled(params)
+      #default to true unless explicitly set to false
+      if params.has_key?(:enabled) && params[:enabled] == false
+        'false'
+      else
+        'true'
+      end
+    end
+  end
+end