jmeter_perf 1.0.9

data/lib/jmeter_perf/extend/config_elements/user_parameters.rb

@@ -0,0 +1,31 @@
+module JmeterPerf
+  class ExtendedDSL < DSL
+    def user_parameters(params, &block)
+      params["Argument.name"] = params[:name] if params.is_a?(Hash)
+
+      params[:names] = Nokogiri::XML::Builder.new do |b|
+        b.builder do
+          params[:names].each do |name|
+            b.stringProp name, name: name
+          end
+        end
+      end
+
+      params[:thread_values] = Nokogiri::XML::Builder.new do |b|
+        b.builder do
+          params[:thread_values].map do |user, values|
+            b.collectionProp name: user do
+              values.each_with_index.map do |value, index|
+                b.stringProp value, name: index
+              end
+            end
+          end
+        end
+      end
+
+      super
+    end
+
+    alias_method :parameters, :user_parameters
+  end
+end

data/lib/jmeter_perf/extend/controllers/foreach_controller.rb

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

data/lib/jmeter_perf/extend/controllers/loop_controller.rb

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

data/lib/jmeter_perf/extend/controllers/module_controller.rb

@@ -0,0 +1,26 @@
+module JmeterPerf
+  class ExtendedDSL < DSL
+    def module_controller(params, &)
+      node = JmeterPerf::DSL::ModuleController.new(params)
+
+      if params[:test_fragment]
+        params[:test_fragment].is_a?(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(
+          JmeterPerf::Helpers::String.strip_heredoc(
+            <<-EOS
+              <stringProp name="node_#{index}">#{node_name}</stringProp>
+            EOS
+          )
+        ).children
+      end
+
+      attach_node(node, &)
+    end
+  end
+end

data/lib/jmeter_perf/extend/controllers/throughput_controller.rb

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

data/lib/jmeter_perf/extend/controllers/transaction_controller.rb

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

data/lib/jmeter_perf/extend/misc/exists.rb

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

data/lib/jmeter_perf/extend/misc/rsync.rb

@@ -0,0 +1,24 @@
+module JmeterPerf
+  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_perf/extend/misc/uuid.rb

@@ -0,0 +1,12 @@
+module JmeterPerf
+  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_perf/extend/misc/with_helpers.rb

@@ -0,0 +1,27 @@
+module JmeterPerf
+  class ExtendedDSL < DSL
+    def with_user_agent(device)
+      http_header_manager name: "User-Agent", value: JmeterPerf::Helpers::UserAgent.string(device)
+    end
+
+    def with_browser(device)
+      http_header_manager name: "User-Agent", value: JmeterPerf::Helpers::UserAgent.string(device)
+      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_perf/extend/plugins/jmeter_plugins.rb

@@ -0,0 +1,124 @@
+module JmeterPerf
+  class ExtendedDSL < DSL
+    def response_codes_per_second(params = {}, &)
+      node = JmeterPerf::Plugins::ResponseCodesPerSecond.new(params)
+      attach_node(node, &)
+    end
+
+    def response_times_distribution(params = {}, &)
+      node = JmeterPerf::Plugins::ResponseTimesDistribution.new(params)
+      attach_node(node, &)
+    end
+
+    def response_times_over_time(params = {}, &)
+      node = JmeterPerf::Plugins::ResponseTimesOverTime.new(params)
+      attach_node(node, &)
+    end
+
+    def response_times_percentiles(params = {}, &)
+      node = JmeterPerf::Plugins::ResponseTimesPercentiles.new(params)
+      attach_node(node, &)
+    end
+
+    def transactions_per_second(params = {}, &)
+      node = JmeterPerf::Plugins::TransactionsPerSecond.new(params)
+      attach_node(node, &)
+    end
+
+    def latencies_over_time(params = {}, &)
+      node = JmeterPerf::Plugins::LatenciesOverTime.new(params)
+      attach_node(node, &)
+    end
+
+    def console_status_logger(params = {}, &)
+      node = JmeterPerf::Plugins::ConsoleStatusLogger.new(params)
+      attach_node(node, &)
+    end
+
+    alias_method :console, :console_status_logger
+
+    def throughput_shaper(params = {}, &)
+      node = JmeterPerf::Plugins::ThroughputShapingTimer.new(params)
+      attach_node(node, &)
+    end
+
+    alias_method :shaper, :throughput_shaper
+
+    def dummy_sampler(params = {}, &)
+      node = JmeterPerf::Plugins::DummySampler.new(params)
+      attach_node(node, &)
+    end
+
+    alias_method :dummy, :dummy_sampler
+
+    def stepping_thread_group(params = {}, &)
+      node = JmeterPerf::Plugins::SteppingThreadGroup.new(params)
+      attach_node(node, &)
+    end
+
+    alias_method :step, :stepping_thread_group
+
+    def ultimate_thread_group(params = {}, &)
+      node = JmeterPerf::Plugins::UltimateThreadGroup.new(params)
+
+      (params.is_a?(Array) ? params : params[:threads]).each_with_index do |group, index|
+        node.doc.at_xpath("//collectionProp").<<
+        Nokogiri::XML(
+          JmeterPerf::Helpers::String.strip_heredoc(
+            <<-EOS
+              <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
+          )
+        ).children
+      end
+
+      attach_node(node, &)
+    end
+
+    alias_method :ultimate, :ultimate_thread_group
+
+    def composite_graph(params = {}, &)
+      node = JmeterPerf::Plugins::CompositeGraph.new(params)
+      attach_node(node, &)
+    end
+
+    alias_method :composite, :composite_graph
+
+    def active_threads_over_time(params = {}, &)
+      node = JmeterPerf::Plugins::ActiveThreadsOverTime.new(params)
+      attach_node(node, &)
+    end
+
+    alias_method :active_threads, :active_threads_over_time
+
+    def perfmon_collector(params = {}, &)
+      node = JmeterPerf::Plugins::PerfmonCollector.new(params)
+      attach_node(node, &)
+    end
+
+    alias_method :perfmon, :perfmon_collector
+
+    def loadosophia_uploader(params = {}, &)
+      node = JmeterPerf::Plugins::LoadosophiaUploader.new(params)
+      attach_node(node, &)
+    end
+
+    alias_method :loadosophia, :loadosophia_uploader
+
+    def redis_data_set(params = {}, &)
+      node = JmeterPerf::Plugins::RedisDataSet.new(params)
+      attach_node(node, &)
+    end
+
+    def jmx_collector(params = {}, &)
+      node = JmeterPerf::Plugins::JMXCollector.new(params)
+      attach_node(node, &)
+    end
+  end
+end

data/lib/jmeter_perf/extend/processors/extract.rb

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

data/lib/jmeter_perf/extend/processors/regular_expression_extractor.rb

@@ -0,0 +1,27 @@
+module JmeterPerf
+  class ExtendedDSL < DSL
+    def regular_expression_extractor(params, &)
+      params[:refname] = params[:name]
+      params[:regex] = params[:pattern]
+      params[:template] = params[:template] || "$1$"
+
+      node = JmeterPerf::DSL::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(JmeterPerf::Helpers::String.strip_heredoc(
+              <<-EOS
+                <stringProp name="Scope.variable">#{params[:variable]}</stringProp>
+              EOS
+            )).children
+          )
+        end
+      end
+
+      attach_node(node, &)
+    end
+
+    alias_method :regex, :regular_expression_extractor
+  end
+end

data/lib/jmeter_perf/extend/samplers/http_request.rb

@@ -0,0 +1,66 @@
+module JmeterPerf
+  class ExtendedDSL < DSL
+    def http_request(*args, &)
+      params = args.shift || {}
+      params = {url: params}.merge(args.shift || {}) if params.is_a?(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), &)
+      end
+    end
+
+    def http_request_node(params)
+      JmeterPerf::DSL::HTTPRequest.new(params).tap do |node|
+        if params[:implementation]
+          node.doc.children.first.add_child(
+            Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+              <<-EOS
+                <stringProp name="HTTPSampler.implementation">#{params[:implementation]}</stringProp>
+              EOS
+            )).children
+          )
+        end
+
+        if params[:comments]
+          node.doc.children.first.add_child(
+            Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+              <<-EOS
+                <stringProp name="TestPlan.comments">#{params[:comments]}</stringProp>
+              EOS
+            )).children
+          )
+        end
+      end
+    end
+
+    alias_method :request, :http_request
+    alias_method :get, :http_request
+    alias_method :visit, :http_request
+    alias_method :post, :http_request
+    alias_method :submit, :http_request
+    alias_method :delete, :http_request
+    alias_method :patch, :http_request
+    alias_method :put, :http_request
+    alias_method :head, :http_request
+  end
+end

data/lib/jmeter_perf/extend/samplers/jms_pointtopoint.rb

@@ -0,0 +1,23 @@
+module JmeterPerf
+  class ExtendedDSL < DSL
+    def jms_pointtopoint(params, &block)
+      JmeterPerf::JmsPointtopoint.new(params).tap do |node|
+        params[:jndi_properties]&.each do |property_name, property_value|
+          node.doc.xpath("//collectionProp").first.add_child(
+            Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+              <<-EOS
+                <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
+            )).children
+          )
+        end
+
+        attach_node(node, &block)
+      end
+    end
+  end
+end

data/lib/jmeter_perf/extend/samplers/soapxmlrpc_request.rb

@@ -0,0 +1,10 @@
+module JmeterPerf
+  class ExtendedDSL < DSL
+    def soapxmlrpc_request(params, &block)
+      params[:method] ||= "POST"
+
+      super
+    end
+    alias_method :soap, :soapxmlrpc_request
+  end
+end

data/lib/jmeter_perf/extend/threads/thread_group.rb

@@ -0,0 +1,19 @@
+module JmeterPerf
+  class ExtendedDSL < DSL
+    def thread_group(*args, &)
+      params = args.shift || {}
+      params = {count: params}.merge(args.shift || {}) if params.is_a?(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 = JmeterPerf::DSL::ThreadGroup.new(params)
+      attach_node(node, &)
+    end
+
+    alias_method :threads, :thread_group
+  end
+end

data/lib/jmeter_perf/extend/timers/constant_throughput_timer.rb

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

data/lib/jmeter_perf/extend/timers/random_timer.rb

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