jmeter_perf 1.0.9

data/lib/jmeter_perf/dsl/simple_controller.rb

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

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

@@ -0,0 +1,41 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element SMIMEAssertion
+    # @param params [Hash] Parameters for the SMIMEAssertion element (default: `{}`).
+    # @yield block to attach to the SMIMEAssertion element
+    # @return [JmeterPerf::SMIMEAssertion], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#smimeassertion
+    def smime_assertion(params = {}, &)
+      node = SMIMEAssertion.new(params)
+      attach_node(node, &)
+    end
+
+    class SMIMEAssertion
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "SMIMEAssertion" : (params[:name] || "SMIMEAssertion")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <SMIMEAssertion guiclass="SMIMEAssertionGui" testclass="SMIMEAssertion" testname="#{testname}" enabled="true">
+              <boolProp name="SMIMEAssert.verifySignature">false</boolProp>
+              <boolProp name="SMIMEAssert.notSigned">false</boolProp>
+              <stringProp name="SMIMEAssert.issuerDn"/>
+              <stringProp name="SMIMEAssert.signerDn"/>
+              <stringProp name="SMIMEAssert.signerSerial"/>
+              <stringProp name="SMIMEAssert.signerEmail"/>
+              <stringProp name="SMIMEAssert.signerCertFile"/>
+              <boolProp name="SMIMEAssert.signerNoCheck">false</boolProp>
+              <boolProp name="SMIMEAssert.signerCheckConstraints">false</boolProp>
+              <boolProp name="SMIMEAssert.signerCheckByFile">false</boolProp>
+              <stringProp name="SMIMEAssert.messagePosition"/>
+            </SMIMEAssertion>
+          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/smtp_sampler.rb

@@ -0,0 +1,57 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element SMTPSampler
+    # @param params [Hash] Parameters for the SMTPSampler element (default: `{}`).
+    # @yield block to attach to the SMTPSampler element
+    # @return [JmeterPerf::SMTPSampler], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#smtpsampler
+    def smtp_sampler(params = {}, &)
+      node = SMTPSampler.new(params)
+      attach_node(node, &)
+    end
+
+    class SMTPSampler
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "SMTPSampler" : (params[:name] || "SMTPSampler")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <SmtpSampler guiclass="SmtpSamplerGui" testclass="SmtpSampler" testname="#{testname}" enabled="true">
+              <stringProp name="SMTPSampler.server"/>
+              <stringProp name="SMTPSampler.serverPort"/>
+              <stringProp name="SMTPSampler.mailFrom"/>
+              <stringProp name="SMTPSampler.replyTo"/>
+              <stringProp name="SMTPSampler.receiverTo"/>
+              <stringProp name="SMTPSampler.receiverCC"/>
+              <stringProp name="SMTPSampler.receiverBCC"/>
+              <stringProp name="SMTPSampler.subject"/>
+              <stringProp name="SMTPSampler.suppressSubject">false</stringProp>
+              <stringProp name="SMTPSampler.include_timestamp">false</stringProp>
+              <stringProp name="SMTPSampler.message"/>
+              <stringProp name="SMTPSampler.plainBody">false</stringProp>
+              <stringProp name="SMTPSampler.attachFile"/>
+              <stringProp name="SMTPSampler.useSSL">false</stringProp>
+              <stringProp name="SMTPSampler.useStartTLS">false</stringProp>
+              <stringProp name="SMTPSampler.trustAllCerts">false</stringProp>
+              <stringProp name="SMTPSampler.enforceStartTLS">false</stringProp>
+              <stringProp name="SMTPSampler.useLocalTrustStore">false</stringProp>
+              <stringProp name="SMTPSampler.trustStoreToUse"/>
+              <boolProp name="SMTPSampler.use_eml">false</boolProp>
+              <stringProp name="SMTPSampler.emlMessageToSend"/>
+              <stringProp name="SMTPSampler.useAuth">false</stringProp>
+              <stringProp name="SMTPSampler.password"/>
+              <stringProp name="SMTPSampler.username"/>
+              <stringProp name="SMTPSampler.messageSizeStatistics">false</stringProp>
+              <stringProp name="SMTPSampler.enableDebug">false</stringProp>
+              <collectionProp name="SMTPSampler.headerFields"/>
+            </SmtpSampler>
+          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/soap_xml_rpc_request.rb

@@ -0,0 +1,39 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element SOAPXmlRPCRequest
+    # @param params [Hash] Parameters for the SOAPXmlRPCRequest element (default: `{}`).
+    # @yield block to attach to the SOAPXmlRPCRequest element
+    # @return [JmeterPerf::SOAPXmlRPCRequest], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#soapxmlrpcrequest
+    def soap_xml_rpc_request(params = {}, &)
+      node = SOAPXmlRPCRequest.new(params)
+      attach_node(node, &)
+    end
+
+    class SOAPXmlRPCRequest
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "SOAPXmlRPCRequest" : (params[:name] || "SOAPXmlRPCRequest")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <SoapSampler guiclass="SoapSamplerGui" testclass="SoapSampler" testname="#{testname}" enabled="true">
+              <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
+                <collectionProp name="Arguments.arguments"/>
+              </elementProp>
+              <stringProp name="SoapSampler.URL_DATA"/>
+              <stringProp name="HTTPSamper.xml_data"/>
+              <stringProp name="SoapSampler.xml_data_file"/>
+              <stringProp name="SoapSampler.SOAP_ACTION"/>
+              <stringProp name="SoapSampler.SEND_SOAP_ACTION">true</stringProp>
+              <boolProp name="HTTPSampler.use_keepalive">false</boolProp>
+            </SoapSampler>
+          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/spline_visualizer.rb

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

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

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

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

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

@@ -0,0 +1,37 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element TCPSamplerConfig
+    # @param params [Hash] Parameters for the TCPSamplerConfig element (default: `{}`).
+    # @yield block to attach to the TCPSamplerConfig element
+    # @return [JmeterPerf::TCPSamplerConfig], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#tcpsamplerconfig
+    def tcp_sampler_config(params = {}, &)
+      node = TCPSamplerConfig.new(params)
+      attach_node(node, &)
+    end
+
+    class TCPSamplerConfig
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "TCPSamplerConfig" : (params[:name] || "TCPSamplerConfig")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <ConfigTestElement guiclass="TCPConfigGui" testclass="ConfigTestElement" testname="#{testname}" enabled="true">
+              <stringProp name="TCPSampler.server"/>
+              <boolProp name="TCPSampler.reUseConnection">true</boolProp>
+              <stringProp name="TCPSampler.port"/>
+              <boolProp name="TCPSampler.nodelay">false</boolProp>
+              <stringProp name="TCPSampler.timeout"/>
+              <stringProp name="TCPSampler.request"/>
+              <boolProp name="TCPSampler.closeConnection">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/test_action.rb

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

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

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

@@ -0,0 +1,43 @@
+module JmeterPerf
+  class DSL
+    # DSL method synonymous with the JMeter Element ThreadGroup
+    # @param params [Hash] Parameters for the ThreadGroup element (default: `{}`).
+    # @yield block to attach to the ThreadGroup element
+    # @return [JmeterPerf::ThreadGroup], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation#threadgroup
+    def thread_group(params = {}, &)
+      node = ThreadGroup.new(params)
+      attach_node(node, &)
+    end
+
+    class ThreadGroup
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "ThreadGroup" : (params[:name] || "ThreadGroup")
+        @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<~EOS
+            <ThreadGroup guiclass="ThreadGroupGui" testclass="ThreadGroup" testname="#{testname}" enabled="true">
+              <stringProp name="ThreadGroup.on_sample_error">continue</stringProp>
+              <elementProp name="ThreadGroup.main_controller" elementType="LoopController" guiclass="LoopControlPanel" testclass="LoopController" testname="#{testname}" enabled="true">
+                <boolProp name="LoopController.continue_forever">false</boolProp>
+                <intProp name="LoopController.loops">-1</intProp>
+              </elementProp>
+              <stringProp name="ThreadGroup.num_threads">1</stringProp>
+              <stringProp name="ThreadGroup.ramp_time">1</stringProp>
+              <longProp name="ThreadGroup.start_time">1366415241000</longProp>
+              <longProp name="ThreadGroup.end_time">1366415241000</longProp>
+              <boolProp name="ThreadGroup.scheduler">true</boolProp>
+              <stringProp name="ThreadGroup.duration"/>
+              <stringProp name="ThreadGroup.delay"/>
+              <boolProp name="ThreadGroup.delayedStart">true</boolProp>
+            </ThreadGroup>
+          EOS
+        ))
+        update params
+        update_at_xpath params if params.is_a?(Hash) && params[:update_at_xpath]
+      end
+    end
+  end
+end