jmeter_perf 1.0.9

data/lib/jmeter_perf/dsl/duration_assertion.rb

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

@@ -0,0 +1,33 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element ForEachController
+    # @param params [Hash] Parameters for the ForEachController element (default: `{}`).
+    # @yield block to attach to the ForEachController element
+    # @return [JmeterPerf::ForEachController], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#foreachcontroller
+    def for_each_controller(params = {}, &)
+      node = ForEachController.new(params)
+      attach_node(node, &)
+    end
+
+    class ForEachController
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "ForEachController" : (params[:name] || "ForEachController")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <ForeachController guiclass="ForeachControlPanel" testclass="ForeachController" testname="#{testname}" enabled="true">
+              <stringProp name="ForeachController.inputVal"/>
+              <stringProp name="ForeachController.returnVal"/>
+              <boolProp name="ForeachController.useSeparator">true</boolProp>
+            </ForeachController>
+          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/ftp_request.rb

@@ -0,0 +1,40 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element FTPRequest
+    # @param params [Hash] Parameters for the FTPRequest element (default: `{}`).
+    # @yield block to attach to the FTPRequest element
+    # @return [JmeterPerf::FTPRequest], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#ftprequest
+    def ftp_request(params = {}, &)
+      node = FTPRequest.new(params)
+      attach_node(node, &)
+    end
+
+    class FTPRequest
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "FTPRequest" : (params[:name] || "FTPRequest")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <FTPSampler guiclass="FtpTestSamplerGui" testclass="FTPSampler" testname="#{testname}" enabled="true">
+              <stringProp name="FTPSampler.server"/>
+              <stringProp name="FTPSampler.port"/>
+              <stringProp name="FTPSampler.filename"/>
+              <stringProp name="FTPSampler.localfilename"/>
+              <stringProp name="FTPSampler.inputdata"/>
+              <boolProp name="FTPSampler.binarymode">false</boolProp>
+              <boolProp name="FTPSampler.saveresponse">false</boolProp>
+              <boolProp name="FTPSampler.upload">false</boolProp>
+              <stringProp name="ConfigTestElement.username"/>
+              <stringProp name="ConfigTestElement.password"/>
+            </FTPSampler>
+          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/ftp_request_defaults.rb

@@ -0,0 +1,38 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element FTPRequestDefaults
+    # @param params [Hash] Parameters for the FTPRequestDefaults element (default: `{}`).
+    # @yield block to attach to the FTPRequestDefaults element
+    # @return [JmeterPerf::FTPRequestDefaults], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#ftprequestdefaults
+    def ftp_request_defaults(params = {}, &)
+      node = FTPRequestDefaults.new(params)
+      attach_node(node, &)
+    end
+
+    class FTPRequestDefaults
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "FTPRequestDefaults" : (params[:name] || "FTPRequestDefaults")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <ConfigTestElement guiclass="FtpConfigGui" testclass="ConfigTestElement" testname="#{testname}" enabled="true">
+              <stringProp name="FTPSampler.server"/>
+              <stringProp name="FTPSampler.port"/>
+              <stringProp name="FTPSampler.filename"/>
+              <stringProp name="FTPSampler.localfilename"/>
+              <stringProp name="FTPSampler.inputdata"/>
+              <boolProp name="FTPSampler.binarymode">false</boolProp>
+              <boolProp name="FTPSampler.saveresponse">false</boolProp>
+              <boolProp name="FTPSampler.upload">false</boolProp>
+            </ConfigTestElement>
+          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/gaussian_random_timer.rb

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

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

@@ -0,0 +1,61 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element GraphResults
+    # @param params [Hash] Parameters for the GraphResults element (default: `{}`).
+    # @yield block to attach to the GraphResults element
+    # @return [JmeterPerf::GraphResults], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#graphresults
+    def graph_results(params = {}, &)
+      node = GraphResults.new(params)
+      attach_node(node, &)
+    end
+
+    class GraphResults
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "GraphResults" : (params[:name] || "GraphResults")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <ResultCollector guiclass="GraphVisualizer" 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/html_assertion.rb

@@ -0,0 +1,36 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element HTMLAssertion
+    # @param params [Hash] Parameters for the HTMLAssertion element (default: `{}`).
+    # @yield block to attach to the HTMLAssertion element
+    # @return [JmeterPerf::HTMLAssertion], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#htmlassertion
+    def html_assertion(params = {}, &)
+      node = HTMLAssertion.new(params)
+      attach_node(node, &)
+    end
+
+    class HTMLAssertion
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "HTMLAssertion" : (params[:name] || "HTMLAssertion")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <HTMLAssertion guiclass="HTMLAssertionGui" testclass="HTMLAssertion" testname="#{testname}" enabled="true">
+              <longProp name="html_assertion_error_threshold">0</longProp>
+              <longProp name="html_assertion_warning_threshold">0</longProp>
+              <stringProp name="html_assertion_doctype">omit</stringProp>
+              <boolProp name="html_assertion_errorsonly">false</boolProp>
+              <longProp name="html_assertion_format">0</longProp>
+              <stringProp name="html_assertion_filename"/>
+            </HTMLAssertion>
+          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/html_link_parser.rb

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

@@ -0,0 +1,38 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element HTMLParameterMask
+    # @param params [Hash] Parameters for the HTMLParameterMask element (default: `{}`).
+    # @yield block to attach to the HTMLParameterMask element
+    # @return [JmeterPerf::HTMLParameterMask], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#htmlparametermask
+    def html_parameter_mask(params = {}, &)
+      node = HTMLParameterMask.new(params)
+      attach_node(node, &)
+    end
+
+    class HTMLParameterMask
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "HTMLParameterMask" : (params[:name] || "HTMLParameterMask")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <ConfigTestElement guiclass="ObsoleteGui" testclass="ConfigTestElement" testname="#{testname}" enabled="true">
+              <elementProp name="ParamModifier.mask" elementType="ConfigTestElement">
+                <stringProp name="ParamModifier.field_name"/>
+                <stringProp name="ParamModifier.prefix"/>
+                <longProp name="ParamModifier.lower_bound">0</longProp>
+                <longProp name="ParamModifier.upper_bound">10</longProp>
+                <longProp name="ParamModifier.increment">1</longProp>
+                <stringProp name="ParamModifier.suffix"/>
+              </elementProp>
+            </ConfigTestElement>
+          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/http_authorization_manager.rb

@@ -0,0 +1,39 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element HTTPAuthorizationManager
+    # @param params [Hash] Parameters for the HTTPAuthorizationManager element (default: `{}`).
+    # @yield block to attach to the HTTPAuthorizationManager element
+    # @return [JmeterPerf::HTTPAuthorizationManager], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#httpauthorizationmanager
+    def http_authorization_manager(params = {}, &)
+      node = HTTPAuthorizationManager.new(params)
+      attach_node(node, &)
+    end
+
+    class HTTPAuthorizationManager
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "HTTPAuthorizationManager" : (params[:name] || "HTTPAuthorizationManager")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <AuthManager guiclass="AuthPanel" testclass="AuthManager" testname="#{testname}" enabled="true">
+              <collectionProp name="AuthManager.auth_list">
+                <elementProp name="" elementType="Authorization">
+                  <stringProp name="Authorization.url"/>
+                  <stringProp name="Authorization.username"/>
+                  <stringProp name="Authorization.password"/>
+                  <stringProp name="Authorization.domain"/>
+                  <stringProp name="Authorization.realm"/>
+                </elementProp>
+              </collectionProp>
+            </AuthManager>
+          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/http_cache_manager.rb

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

@@ -0,0 +1,34 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element HTTPCookieManager
+    # @param params [Hash] Parameters for the HTTPCookieManager element (default: `{}`).
+    # @yield block to attach to the HTTPCookieManager element
+    # @return [JmeterPerf::HTTPCookieManager], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#httpcookiemanager
+    def http_cookie_manager(params = {}, &)
+      node = HTTPCookieManager.new(params)
+      attach_node(node, &)
+    end
+
+    class HTTPCookieManager
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "HTTPCookieManager" : (params[:name] || "HTTPCookieManager")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="#{testname}" enabled="true">
+              <collectionProp name="CookieManager.cookies"/>
+              <boolProp name="CookieManager.clearEachIteration">false</boolProp>
+              <stringProp name="CookieManager.policy">default</stringProp>
+              <stringProp name="CookieManager.implementation">org.apache.jmeter.protocol.http.control.HC4CookieHandler</stringProp>
+            </CookieManager>
+          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/http_header_manager.rb

@@ -0,0 +1,36 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element HTTPHeaderManager
+    # @param params [Hash] Parameters for the HTTPHeaderManager element (default: `{}`).
+    # @yield block to attach to the HTTPHeaderManager element
+    # @return [JmeterPerf::HTTPHeaderManager], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#httpheadermanager
+    def http_header_manager(params = {}, &)
+      node = HTTPHeaderManager.new(params)
+      attach_node(node, &)
+    end
+
+    class HTTPHeaderManager
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "HTTPHeaderManager" : (params[:name] || "HTTPHeaderManager")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="#{testname}" enabled="true">
+              <collectionProp name="HeaderManager.headers">
+                <elementProp name="" elementType="Header">
+                  <stringProp name="Header.name"/>
+                  <stringProp name="Header.value"/>
+                </elementProp>
+              </collectionProp>
+            </HeaderManager>
+          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/http_request.rb

@@ -0,0 +1,47 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element HTTPRequest
+    # @param params [Hash] Parameters for the HTTPRequest element (default: `{}`).
+    # @yield block to attach to the HTTPRequest element
+    # @return [JmeterPerf::HTTPRequest], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#httprequest
+    def http_request(params = {}, &)
+      node = HTTPRequest.new(params)
+      attach_node(node, &)
+    end
+
+    class HTTPRequest
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "HTTPRequest" : (params[:name] || "HTTPRequest")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="#{testname}" enabled="true">
+              <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" testname="#{testname}" enabled="true">
+                <collectionProp name="Arguments.arguments"/>
+              </elementProp>
+              <stringProp name="HTTPSampler.domain"/>
+              <stringProp name="HTTPSampler.port"/>
+              <stringProp name="HTTPSampler.connect_timeout"/>
+              <stringProp name="HTTPSampler.response_timeout"/>
+              <stringProp name="HTTPSampler.protocol"/>
+              <stringProp name="HTTPSampler.contentEncoding"/>
+              <stringProp name="HTTPSampler.path"/>
+              <stringProp name="HTTPSampler.method">GET</stringProp>
+              <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+              <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+              <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+              <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+              <boolProp name="HTTPSampler.monitor">false</boolProp>
+              <stringProp name="HTTPSampler.embedded_url_re"/>
+            </HTTPSamplerProxy>
+          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/http_request_defaults.rb

@@ -0,0 +1,53 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element HTTPRequestDefaults
+    # @param params [Hash] Parameters for the HTTPRequestDefaults element (default: `{}`).
+    # @yield block to attach to the HTTPRequestDefaults element
+    # @return [JmeterPerf::HTTPRequestDefaults], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#httprequestdefaults
+    def http_request_defaults(params = {}, &)
+      node = HTTPRequestDefaults.new(params)
+      attach_node(node, &)
+    end
+
+    class HTTPRequestDefaults
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "HTTPRequestDefaults" : (params[:name] || "HTTPRequestDefaults")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <ConfigTestElement guiclass="HttpDefaultsGui" testclass="ConfigTestElement" testname="#{testname}" enabled="true">
+              <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" testname="#{testname}" enabled="true">
+                <collectionProp name="Arguments.arguments">
+                  <elementProp name="" elementType="HTTPArgument">
+                    <boolProp name="HTTPArgument.always_encode">false</boolProp>
+                    <stringProp name="Argument.value">username=my_name&amp;password=my_password&amp;email="my name &lt;test@example.com&gt;"</stringProp>
+                    <stringProp name="Argument.metadata">=</stringProp>
+                  </elementProp>
+                </collectionProp>
+              </elementProp>
+              <stringProp name="HTTPSampler.domain"/>
+              <stringProp name="HTTPSampler.port"/>
+              <stringProp name="HTTPSampler.proxyHost"/>
+              <stringProp name="HTTPSampler.proxyPort"/>
+              <stringProp name="HTTPSampler.connect_timeout"/>
+              <stringProp name="HTTPSampler.response_timeout"/>
+              <stringProp name="HTTPSampler.protocol"/>
+              <stringProp name="HTTPSampler.contentEncoding"/>
+              <stringProp name="HTTPSampler.path">/</stringProp>
+              <stringProp name="HTTPSampler.implementation">HttpClient4</stringProp>
+              <boolProp name="HTTPSampler.image_parser">true</boolProp>
+              <boolProp name="HTTPSampler.concurrentDwn">true</boolProp>
+              <stringProp name="HTTPSampler.concurrentPool">4</stringProp>
+              <stringProp name="HTTPSampler.embedded_url_re"/>
+            </ConfigTestElement>
+          EOS
+        ))
+        update params
+        update_at_xpath params if params.is_a?(Hash) && params[:update_at_xpath]
+      end
+    end
+  end
+end