jmeter_perf 1.0.9

data/lib/jmeter_perf/dsl/throughput_controller.rb

@@ -0,0 +1,38 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element ThroughputController
+    # @param params [Hash] Parameters for the ThroughputController element (default: `{}`).
+    # @yield block to attach to the ThroughputController element
+    # @return [JmeterPerf::ThroughputController], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#throughputcontroller
+    def throughput_controller(params = {}, &)
+      node = ThroughputController.new(params)
+      attach_node(node, &)
+    end
+
+    class ThroughputController
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "ThroughputController" : (params[:name] || "ThroughputController")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="#{testname}" enabled="true">
+              <intProp name="ThroughputController.style">0</intProp>
+              <boolProp name="ThroughputController.perThread">false</boolProp>
+              <intProp name="ThroughputController.maxThroughput">1</intProp>
+              <FloatProperty>
+                <name>ThroughputController.percentThroughput</name>
+                <value>100.0</value>
+                <savedValue>0.0</savedValue>
+              </FloatProperty>
+            </ThroughputController>
+          EOS
+        ))
+        update params
+        update_at_xpath params if params.is_a?(Hash) && params[:update_at_xpath]
+      end
+    end
+  end
+end

data/lib/jmeter_perf/dsl/transaction_controller.rb

@@ -0,0 +1,32 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element TransactionController
+    # @param params [Hash] Parameters for the TransactionController element (default: `{}`).
+    # @yield block to attach to the TransactionController element
+    # @return [JmeterPerf::TransactionController], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#transactioncontroller
+    def transaction_controller(params = {}, &)
+      node = TransactionController.new(params)
+      attach_node(node, &)
+    end
+
+    class TransactionController
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "TransactionController" : (params[:name] || "TransactionController")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <TransactionController guiclass="TransactionControllerGui" testclass="TransactionController" testname="#{testname}" enabled="true">
+              <boolProp name="TransactionController.parent">true</boolProp>
+              <boolProp name="TransactionController.includeTimers">false</boolProp>
+            </TransactionController>
+          EOS
+        ))
+        update params
+        update_at_xpath params if params.is_a?(Hash) && params[:update_at_xpath]
+      end
+    end
+  end
+end

data/lib/jmeter_perf/dsl/uniform_random_timer.rb

@@ -0,0 +1,32 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element UniformRandomTimer
+    # @param params [Hash] Parameters for the UniformRandomTimer element (default: `{}`).
+    # @yield block to attach to the UniformRandomTimer element
+    # @return [JmeterPerf::UniformRandomTimer], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#uniformrandomtimer
+    def uniform_random_timer(params = {}, &)
+      node = UniformRandomTimer.new(params)
+      attach_node(node, &)
+    end
+
+    class UniformRandomTimer
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "UniformRandomTimer" : (params[:name] || "UniformRandomTimer")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <UniformRandomTimer guiclass="UniformRandomTimerGui" testclass="UniformRandomTimer" testname="#{testname}" enabled="true">
+              <stringProp name="ConstantTimer.delay">0</stringProp>
+              <stringProp name="RandomTimer.range">100.0</stringProp>
+            </UniformRandomTimer>
+          EOS
+        ))
+        update params
+        update_at_xpath params if params.is_a?(Hash) && params[:update_at_xpath]
+      end
+    end
+  end
+end

data/lib/jmeter_perf/dsl/user_defined_variables.rb

@@ -0,0 +1,39 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element UserDefinedVariables
+    # @param params [Hash] Parameters for the UserDefinedVariables element (default: `{}`).
+    # @yield block to attach to the UserDefinedVariables element
+    # @return [JmeterPerf::UserDefinedVariables], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#userdefinedvariables
+    def user_defined_variables(params = {}, &)
+      node = UserDefinedVariables.new(params)
+      attach_node(node, &)
+    end
+
+    class UserDefinedVariables
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "UserDefinedVariables" : (params[:name] || "UserDefinedVariables")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <Arguments guiclass="ArgumentsPanel" testclass="Arguments" testname="#{testname}" enabled="true">
+              <collectionProp name="Arguments.arguments">
+                <elementProp name=" " elementType="Argument">
+                  <stringProp name="Argument.name"> </stringProp>
+                  <stringProp name="Argument.value"> </stringProp>
+                  <stringProp name="Argument.metadata">=</stringProp>
+                  <stringProp name="Argument.desc"> </stringProp>
+                </elementProp>
+              </collectionProp>
+              <stringProp name="TestPlan.comments"> </stringProp>
+            </Arguments>
+          EOS
+        ))
+        update params
+        update_at_xpath params if params.is_a?(Hash) && params[:update_at_xpath]
+      end
+    end
+  end
+end

data/lib/jmeter_perf/dsl/user_parameters.rb

@@ -0,0 +1,36 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element UserParameters
+    # @param params [Hash] Parameters for the UserParameters element (default: `{}`).
+    # @yield block to attach to the UserParameters element
+    # @return [JmeterPerf::UserParameters], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#userparameters
+    def user_parameters(params = {}, &)
+      node = UserParameters.new(params)
+      attach_node(node, &)
+    end
+
+    class UserParameters
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "UserParameters" : (params[:name] || "UserParameters")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <UserParameters guiclass="UserParametersGui" testclass="UserParameters" testname="#{testname}" enabled="true">
+              <collectionProp name="UserParameters.names"/>
+              <collectionProp name="UserParameters.thread_values">
+                <collectionProp name="1"/>
+                <collectionProp name="1"/>
+              </collectionProp>
+              <boolProp name="UserParameters.per_iteration">false</boolProp>
+            </UserParameters>
+          EOS
+        ))
+        update params
+        update_at_xpath params if params.is_a?(Hash) && params[:update_at_xpath]
+      end
+    end
+  end
+end

data/lib/jmeter_perf/dsl/view_results_in_table.rb

@@ -0,0 +1,61 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element ViewResultsInTable
+    # @param params [Hash] Parameters for the ViewResultsInTable element (default: `{}`).
+    # @yield block to attach to the ViewResultsInTable element
+    # @return [JmeterPerf::ViewResultsInTable], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#viewresultsintable
+    def view_results_in_table(params = {}, &)
+      node = ViewResultsInTable.new(params)
+      attach_node(node, &)
+    end
+
+    class ViewResultsInTable
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "ViewResultsInTable" : (params[:name] || "ViewResultsInTable")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <ResultCollector guiclass="TableVisualizer" testclass="ResultCollector" testname="#{testname}" enabled="true">
+              <boolProp name="ResultCollector.error_logging">false</boolProp>
+              <objProp>
+                <name>saveConfig</name>
+                <value class="SampleSaveConfiguration">
+                  <time>true</time>
+                  <latency>true</latency>
+                  <timestamp>true</timestamp>
+                  <success>true</success>
+                  <label>true</label>
+                  <code>true</code>
+                  <message>false</message>
+                  <threadName>true</threadName>
+                  <dataType>false</dataType>
+                  <encoding>false</encoding>
+                  <assertions>false</assertions>
+                  <subresults>false</subresults>
+                  <responseData>false</responseData>
+                  <samplerData>false</samplerData>
+                  <xml>false</xml>
+                  <fieldNames>false</fieldNames>
+                  <responseHeaders>false</responseHeaders>
+                  <requestHeaders>false</requestHeaders>
+                  <responseDataOnError>false</responseDataOnError>
+                  <saveAssertionResultsFailureMessage>false</saveAssertionResultsFailureMessage>
+                  <assertionsResultsToSave>0</assertionsResultsToSave>
+                  <bytes>true</bytes>
+                  <threadCounts>true</threadCounts>
+                  <sampleCount>true</sampleCount>
+                </value>
+              </objProp>
+              <stringProp name="filename"/>
+            </ResultCollector>
+          EOS
+        ))
+        update params
+        update_at_xpath params if params.is_a?(Hash) && params[:update_at_xpath]
+      end
+    end
+  end
+end

data/lib/jmeter_perf/dsl/view_results_tree.rb

@@ -0,0 +1,61 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element ViewResultsTree
+    # @param params [Hash] Parameters for the ViewResultsTree element (default: `{}`).
+    # @yield block to attach to the ViewResultsTree element
+    # @return [JmeterPerf::ViewResultsTree], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#viewresultstree
+    def view_results_tree(params = {}, &)
+      node = ViewResultsTree.new(params)
+      attach_node(node, &)
+    end
+
+    class ViewResultsTree
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "ViewResultsTree" : (params[:name] || "ViewResultsTree")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <ResultCollector guiclass="ViewResultsFullVisualizer" testclass="ResultCollector" testname="#{testname}" enabled="true">
+              <boolProp name="ResultCollector.error_logging">false</boolProp>
+              <objProp>
+                <name>saveConfig</name>
+                <value class="SampleSaveConfiguration">
+                  <time>true</time>
+                  <latency>true</latency>
+                  <timestamp>true</timestamp>
+                  <success>true</success>
+                  <label>true</label>
+                  <code>true</code>
+                  <message>false</message>
+                  <threadName>true</threadName>
+                  <dataType>false</dataType>
+                  <encoding>false</encoding>
+                  <assertions>false</assertions>
+                  <subresults>false</subresults>
+                  <responseData>false</responseData>
+                  <samplerData>false</samplerData>
+                  <xml>false</xml>
+                  <fieldNames>false</fieldNames>
+                  <responseHeaders>false</responseHeaders>
+                  <requestHeaders>false</requestHeaders>
+                  <responseDataOnError>false</responseDataOnError>
+                  <saveAssertionResultsFailureMessage>false</saveAssertionResultsFailureMessage>
+                  <assertionsResultsToSave>0</assertionsResultsToSave>
+                  <bytes>true</bytes>
+                  <threadCounts>true</threadCounts>
+                  <sampleCount>true</sampleCount>
+                </value>
+              </objProp>
+              <stringProp name="filename"/>
+            </ResultCollector>
+          EOS
+        ))
+        update params
+        update_at_xpath params if params.is_a?(Hash) && params[:update_at_xpath]
+      end
+    end
+  end
+end

data/lib/jmeter_perf/dsl/while_controller.rb

@@ -0,0 +1,31 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element WhileController
+    # @param params [Hash] Parameters for the WhileController element (default: `{}`).
+    # @yield block to attach to the WhileController element
+    # @return [JmeterPerf::WhileController], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#whilecontroller
+    def while_controller(params = {}, &)
+      node = WhileController.new(params)
+      attach_node(node, &)
+    end
+
+    class WhileController
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "WhileController" : (params[:name] || "WhileController")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <WhileController guiclass="WhileControllerGui" testclass="WhileController" testname="#{testname}" enabled="true">
+              <stringProp name="WhileController.condition"/>
+            </WhileController>
+          EOS
+        ))
+        update params
+        update_at_xpath params if params.is_a?(Hash) && params[:update_at_xpath]
+      end
+    end
+  end
+end

data/lib/jmeter_perf/dsl/x_path_assertion.rb

@@ -0,0 +1,37 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element XPathAssertion
+    # @param params [Hash] Parameters for the XPathAssertion element (default: `{}`).
+    # @yield block to attach to the XPathAssertion element
+    # @return [JmeterPerf::XPathAssertion], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#xpathassertion
+    def x_path_assertion(params = {}, &)
+      node = XPathAssertion.new(params)
+      attach_node(node, &)
+    end
+
+    class XPathAssertion
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "XPathAssertion" : (params[:name] || "XPathAssertion")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <XPathAssertion guiclass="XPathAssertionGui" testclass="XPathAssertion" testname="#{testname}" enabled="true">
+              <boolProp name="XPath.negate">false</boolProp>
+              <stringProp name="XPath.xpath">/</stringProp>
+              <boolProp name="XPath.validate">false</boolProp>
+              <boolProp name="XPath.whitespace">false</boolProp>
+              <boolProp name="XPath.tolerant">false</boolProp>
+              <boolProp name="XPath.namespace">false</boolProp>
+              <stringProp name="Assertion.scope">all</stringProp>
+            </XPathAssertion>
+          EOS
+        ))
+        update params
+        update_at_xpath params if params.is_a?(Hash) && params[:update_at_xpath]
+      end
+    end
+  end
+end

data/lib/jmeter_perf/dsl/x_path_extractor.rb

@@ -0,0 +1,37 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element XPathExtractor
+    # @param params [Hash] Parameters for the XPathExtractor element (default: `{}`).
+    # @yield block to attach to the XPathExtractor element
+    # @return [JmeterPerf::XPathExtractor], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#xpathextractor
+    def x_path_extractor(params = {}, &)
+      node = XPathExtractor.new(params)
+      attach_node(node, &)
+    end
+
+    class XPathExtractor
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "XPathExtractor" : (params[:name] || "XPathExtractor")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <XPathExtractor guiclass="XPathExtractorGui" testclass="XPathExtractor" testname="#{testname}" enabled="true">
+              <stringProp name="XPathExtractor.default"/>
+              <stringProp name="XPathExtractor.refname"/>
+              <stringProp name="XPathExtractor.xpathQuery"/>
+              <boolProp name="XPathExtractor.validate">false</boolProp>
+              <boolProp name="XPathExtractor.tolerant">false</boolProp>
+              <boolProp name="XPathExtractor.namespace">false</boolProp>
+              <stringProp name="Sample.scope">all</stringProp>
+            </XPathExtractor>
+          EOS
+        ))
+        update params
+        update_at_xpath params if params.is_a?(Hash) && params[:update_at_xpath]
+      end
+    end
+  end
+end

data/lib/jmeter_perf/dsl/xml_assertion.rb

@@ -0,0 +1,29 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element XMLAssertion
+    # @param params [Hash] Parameters for the XMLAssertion element (default: `{}`).
+    # @yield block to attach to the XMLAssertion element
+    # @return [JmeterPerf::XMLAssertion], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#xmlassertion
+    def xml_assertion(params = {}, &)
+      node = XMLAssertion.new(params)
+      attach_node(node, &)
+    end
+
+    class XMLAssertion
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "XMLAssertion" : (params[:name] || "XMLAssertion")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <XMLAssertion guiclass="XMLAssertionGui" testclass="XMLAssertion" testname="#{testname}" enabled="true"/>
+          EOS
+        ))
+        update params
+        update_at_xpath params if params.is_a?(Hash) && params[:update_at_xpath]
+      end
+    end
+  end
+end

data/lib/jmeter_perf/dsl/xml_schema_assertion.rb

@@ -0,0 +1,31 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element XMLSchemaAssertion
+    # @param params [Hash] Parameters for the XMLSchemaAssertion element (default: `{}`).
+    # @yield block to attach to the XMLSchemaAssertion element
+    # @return [JmeterPerf::XMLSchemaAssertion], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#xmlschemaassertion
+    def xml_schema_assertion(params = {}, &)
+      node = XMLSchemaAssertion.new(params)
+      attach_node(node, &)
+    end
+
+    class XMLSchemaAssertion
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "XMLSchemaAssertion" : (params[:name] || "XMLSchemaAssertion")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <XMLSchemaAssertion guiclass="XMLSchemaAssertionGUI" testclass="XMLSchemaAssertion" testname="#{testname}" enabled="true">
+              <stringProp name="xmlschema_assertion_filename"/>
+            </XMLSchemaAssertion>
+          EOS
+        ))
+        update params
+        update_at_xpath params if params.is_a?(Hash) && params[:update_at_xpath]
+      end
+    end
+  end
+end

data/lib/jmeter_perf/extend/assertions/response_assertion.rb

@@ -0,0 +1,38 @@
+module JmeterPerf
+  class ExtendedDSL < DSL
+    def response_assertion(params, &)
+      params[:test_type] = parse_test_type(params)
+      params["0"] = params.values.first
+
+      if params[:json]
+        params[:EXPECTED_VALUE] = params[:value]
+        params[:JSON_PATH] = params[:json]
+        node = JmeterPerf::Plugins::JsonPathAssertion.new(params)
+      end
+
+      node ||= JmeterPerf::DSL::ResponseAssertion.new(params).tap do |node|
+        if params[:variable]
+          params["Scope.variable"] = params[:variable]
+          node.doc.xpath("//stringProp[@name='Assertion.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
+
+        if params[:scope] == "main"
+          node.doc.xpath("//stringProp[@name='Assertion.scope']").remove
+        end
+      end
+
+      attach_node(node, &)
+    end
+
+    alias_method :assert, :response_assertion
+    alias_method :web_reg_find, :response_assertion
+  end
+end

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

@@ -0,0 +1,13 @@
+module JmeterPerf
+  class ExtendedDSL < DSL
+    def http_header_manager(params, &block)
+      if params.is_a?(Hash)
+        params["Header.name"] = params[:name]
+      end
+
+      super
+    end
+
+    alias_method :header, :http_header_manager
+  end
+end

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

@@ -0,0 +1,12 @@
+module JmeterPerf
+  class ExtendedDSL < DSL
+    def http_cache_manager(params = {}, &block)
+      params[:clearEachIteration] = true if params.key? :clear_each_iteration
+      params[:useExpires] = true if params.key? :use_expires
+
+      super
+    end
+
+    alias_method :cache, :http_cache_manager
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module JmeterPerf
+  class ExtendedDSL < DSL
+    def http_cookie_manager(params = {}, &)
+      params[:clearEachIteration] = true if params.key? :clear_each_iteration
+
+      node = JmeterPerf::DSL::HTTPCookieManager.new(params)
+
+      params[:user_defined_cookies]&.each { |cookie| add_cookie_to_collection(cookie, node) }
+
+      attach_node(node, &)
+    end
+
+    alias_method :cookies, :http_cookie_manager
+
+    private
+
+    def add_cookie_to_collection(cookie, node)
+      raise "Cookie name must be provided." unless cookie[:name]
+      raise "Cookie value must be provided." unless cookie[:value]
+      node.doc.at_xpath("//collectionProp") << Nokogiri::XML(
+        JmeterPerf::Helpers::String.strip_heredoc(
+          <<-EOS
+            <elementProp name="#{cookie[:name]}" elementType="Cookie" testname="#{cookie[:name]}">
+              <stringProp name="Cookie.value">#{cookie[:value]}</stringProp>
+              <stringProp name="Cookie.domain">#{cookie[:domain]}</stringProp>
+              <stringProp name="Cookie.path">#{cookie[:path]}</stringProp>
+              <boolProp name="Cookie.secure">#{cookie[:secure] || false}</boolProp>
+              <longProp name="Cookie.expires">0</longProp>
+              <boolProp name="Cookie.path_specified">true</boolProp>
+              <boolProp name="Cookie.domain_specified">true</boolProp>
+            </elementProp>
+          EOS
+        )
+      ).children
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module JmeterPerf
+  class ExtendedDSL < DSL
+    def http_request_defaults(params = {}, &)
+      params[:image_parser] = true if params.key? :download_resources
+      params[:concurrentDwn] = true if params.key? :use_concurrent_pool
+      params[:concurrentPool] = params[:use_concurrent_pool] if params.key? :use_concurrent_pool
+
+      node = JmeterPerf::DSL::HTTPRequestDefaults.new(params).tap do |node|
+        if params[:urls_must_match]
+          node.doc.children.first.add_child(
+            Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+              <<-EOS
+              <stringProp name="HTTPSampler.embedded_url_re">#{params[:urls_must_match]}</stringProp>
+              EOS
+            )).children
+          )
+        end
+
+        if params[:md5]
+          node.doc.children.first.add_child(
+            Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+              <<-EOS
+                <boolProp name="HTTPSampler.md5">true</stringProp>
+              EOS
+            )).children
+          )
+        end
+
+        if params[:proxy_host]
+          node.doc.children.first.add_child(
+            Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+              <<-EOS
+                <stringProp name="HTTPSampler.proxyHost">#{params[:proxy_host]}</stringProp>
+              EOS
+            )).children
+          )
+        end
+
+        if params[:proxy_port]
+          node.doc.children.first.add_child(
+            Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+              <<-EOS
+                <stringProp name="HTTPSampler.proxyPort">#{params[:proxy_port]}</stringProp>
+              EOS
+            )).children
+          )
+        end
+      end
+
+      attach_node(node, &)
+    end
+
+    alias_method :defaults, :http_request_defaults
+  end
+end

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

@@ -0,0 +1,13 @@
+module JmeterPerf
+  class ExtendedDSL < DSL
+    def user_defined_variables(params, &block)
+      if params.is_a?(Hash)
+        params["Argument.name"] = params[:name]
+      end
+
+      super
+    end
+
+    alias_method :variables, :user_defined_variables
+  end
+end