jmeter_perf 1.0.9

data/lib/jmeter_perf/dsl/module_controller.rb

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

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

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

@@ -0,0 +1,40 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element OSProcessSampler
+    # @param params [Hash] Parameters for the OSProcessSampler element (default: `{}`).
+    # @yield block to attach to the OSProcessSampler element
+    # @return [JmeterPerf::OSProcessSampler], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#osprocesssampler
+    def os_process_sampler(params = {}, &)
+      node = OSProcessSampler.new(params)
+      attach_node(node, &)
+    end
+
+    class OSProcessSampler
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "OSProcessSampler" : (params[:name] || "OSProcessSampler")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <SystemSampler guiclass="SystemSamplerGui" testclass="SystemSampler" testname="#{testname}" enabled="true">
+              <boolProp name="SystemSampler.checkReturnCode">false</boolProp>
+              <stringProp name="SystemSampler.expectedReturnCode">0</stringProp>
+              <stringProp name="SystemSampler.command"/>
+              <elementProp name="SystemSampler.arguments" elementType="Arguments" guiclass="ArgumentsPanel" testclass="Arguments" testname="#{testname}" enabled="true">
+                <collectionProp name="Arguments.arguments"/>
+              </elementProp>
+              <elementProp name="SystemSampler.environment" elementType="Arguments" guiclass="ArgumentsPanel" testclass="Arguments" testname="#{testname}" enabled="true">
+                <collectionProp name="Arguments.arguments"/>
+              </elementProp>
+              <stringProp name="SystemSampler.directory"/>
+            </SystemSampler>
+          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/poisson_random_timer.rb

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

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

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

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

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

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

@@ -0,0 +1,38 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element RegularExpressionExtractor
+    # @param params [Hash] Parameters for the RegularExpressionExtractor element (default: `{}`).
+    # @yield block to attach to the RegularExpressionExtractor element
+    # @return [JmeterPerf::RegularExpressionExtractor], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#regularexpressionextractor
+    def regular_expression_extractor(params = {}, &)
+      node = RegularExpressionExtractor.new(params)
+      attach_node(node, &)
+    end
+
+    class RegularExpressionExtractor
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "RegularExpressionExtractor" : (params[:name] || "RegularExpressionExtractor")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="#{testname}" enabled="true">
+              <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+              <stringProp name="RegexExtractor.refname"/>
+              <stringProp name="RegexExtractor.regex"/>
+              <stringProp name="RegexExtractor.template"/>
+              <stringProp name="RegexExtractor.default"/>
+              <stringProp name="RegexExtractor.match_number"/>
+              <stringProp name="Sample.scope">all</stringProp>
+              <boolProp name="RegexExtractor.default_empty_value"/>
+            </RegexExtractor>
+          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/response_assertion.rb

@@ -0,0 +1,37 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element ResponseAssertion
+    # @param params [Hash] Parameters for the ResponseAssertion element (default: `{}`).
+    # @yield block to attach to the ResponseAssertion element
+    # @return [JmeterPerf::ResponseAssertion], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#responseassertion
+    def response_assertion(params = {}, &)
+      node = ResponseAssertion.new(params)
+      attach_node(node, &)
+    end
+
+    class ResponseAssertion
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "ResponseAssertion" : (params[:name] || "ResponseAssertion")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="#{testname}" enabled="true">
+              <collectionProp name="Asserion.test_strings">
+                <stringProp name="0"/>
+              </collectionProp>
+              <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+              <boolProp name="Assertion.assume_success">false</boolProp>
+              <intProp name="Assertion.test_type">16</intProp>
+              <stringProp name="Assertion.scope">all</stringProp>
+            </ResponseAssertion>
+          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/response_time_graph.rb

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

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

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

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

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