jmeter_perf 1.0.9

data/lib/jmeter_perf/dsl/bean_shell_timer.rb

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,39 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element CSVDataSetConfig
+    # @param params [Hash] Parameters for the CSVDataSetConfig element (default: `{}`).
+    # @yield block to attach to the CSVDataSetConfig element
+    # @return [JmeterPerf::CSVDataSetConfig], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#csvdatasetconfig
+    def csv_data_set_config(params = {}, &)
+      node = CSVDataSetConfig.new(params)
+      attach_node(node, &)
+    end
+
+    class CSVDataSetConfig
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "CSVDataSetConfig" : (params[:name] || "CSVDataSetConfig")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <CSVDataSet guiclass="TestBeanGUI" testclass="CSVDataSet" testname="#{testname}" enabled="true">
+              <stringProp name="delimiter">,</stringProp>
+              <stringProp name="fileEncoding"/>
+              <stringProp name="filename"/>
+              <boolProp name="quotedData">false</boolProp>
+              <boolProp name="recycle">true</boolProp>
+              <stringProp name="shareMode">shareMode.all</stringProp>
+              <boolProp name="stopThread">false</boolProp>
+              <boolProp name="ignoreFirstLine">false</boolProp>
+              <stringProp name="variableNames"/>
+            </CSVDataSet>
+          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/debug_postprocessor.rb

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

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

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