gridinit-jmeter 0.2.4 → 0.2.5

data/Gemfile

@@ -12,8 +12,10 @@ platforms :jruby do
 end
 
 group :development do
-  gem 'pry'
-  gem 'pry-nav'
+  gem 'pry', :require => 'pry'
+  gem 'pry-nav', :require => 'pry-nav'
+  gem 'pry-debugger'
+  gem 'awesome_print', :require => 'ap'
 end
 
 group :test do

data/gridinit-jmeter.gemspec

@@ -17,6 +17,6 @@ Gem::Specification.new do |gem|
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   << 'grid'
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.require_paths = ["lib"]
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.require_paths = ['lib']
 end

data/lib/gridinit-jmeter.rb

@@ -40,7 +40,7 @@ require 'gridinit-jmeter/helpers/user-agents'
 # require 'gridinit-jmeter/config/ldap_extended_request_defaults'
 # require 'gridinit-jmeter/config/ldap_request_defaults'
 # require 'gridinit-jmeter/config/login_config_element'
-# require 'gridinit-jmeter/config/random_variable'
+require 'gridinit-jmeter/config/random_variable'
 # require 'gridinit-jmeter/config/simple_config_element'
 # require 'gridinit-jmeter/config/tcp_sampler_config'
   require 'gridinit-jmeter/config/user_defined_variable'
@@ -90,6 +90,7 @@ require 'gridinit-jmeter/helpers/user-agents'
   require 'gridinit-jmeter/listeners/stat_visualizer'
   require 'gridinit-jmeter/listeners/simple_data_writer'
   require 'gridinit-jmeter/listeners/summary_report'
+  require 'gridinit-jmeter/listeners/aggregate_report'
   require 'gridinit-jmeter/listeners/gc_latencies_over_time'
   require 'gridinit-jmeter/listeners/gc_response_codes_per_second'
   require 'gridinit-jmeter/listeners/gc_response_times_distribution'
@@ -105,6 +106,10 @@ require 'gridinit-jmeter/helpers/user-agents'
   require 'gridinit-jmeter/controllers/loop_controller'
   require 'gridinit-jmeter/controllers/throughput'
   require 'gridinit-jmeter/controllers/while_controller'
+  require 'gridinit-jmeter/controllers/switch'
+  require 'gridinit-jmeter/controllers/random_order'
+  require 'gridinit-jmeter/controllers/simple'
+  require 'gridinit-jmeter/controllers/interleave'
 
 # SAMPLERS
   require 'gridinit-jmeter/samplers/http_sampler'

data/lib/gridinit-jmeter/config/random_variable.rb

@@ -0,0 +1,24 @@
+module Gridinit
+  module Jmeter
+
+    class RandomVariableConfig
+      attr_accessor :doc
+      include Helper
+      def initialize(name, min, max, params={})
+        @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
+        <RandomVariableConfig guiclass="TestBeanGUI" testclass="RandomVariableConfig" testname="#{name}" enabled="#{enabled(params)}">
+          <stringProp name="maximumValue">#{max}</stringProp>
+          <stringProp name="minimumValue">#{min}</stringProp>
+          <stringProp name="outputFormat"></stringProp>
+          <boolProp name="perThread">false</boolProp>
+          <stringProp name="randomSeed"></stringProp>
+          <stringProp name="variableName">#{name}</stringProp>
+        </RandomVariableConfig>
+
+        EOF
+        update params
+      end
+    end  
+
+  end
+end

data/lib/gridinit-jmeter/controllers/if_controller.rb

@@ -4,10 +4,10 @@ module Gridinit
     class IfController
       attr_accessor :doc
       include Helper
-      def initialize(name, params={})
+      def initialize(name, condition, params={})
         @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
           <IfController guiclass="IfControllerPanel" testclass="IfController" testname="#{name}" enabled="true">
-            <stringProp name="IfController.condition"></stringProp>
+            <stringProp name="IfController.condition">#{condition}</stringProp>
             <boolProp name="IfController.evaluateAll">false</boolProp>
           </IfController>
         EOF

data/lib/gridinit-jmeter/controllers/interleave.rb

@@ -0,0 +1,18 @@
+module Gridinit
+  module Jmeter
+
+    class InterleaveController
+      attr_accessor :doc
+      include Helper
+      def initialize(name, params={})
+        @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
+        <InterleaveControl guiclass="InterleaveControlGui" testclass="InterleaveControl" testname="#{name}" enabled="true">
+          <intProp name="InterleaveControl.style">1</intProp>
+        </InterleaveControl>
+        EOF
+        update params
+      end
+    end  
+
+  end
+end

data/lib/gridinit-jmeter/controllers/random_order.rb

@@ -0,0 +1,16 @@
+module Gridinit
+  module Jmeter
+
+    class RandomOrderController
+      attr_accessor :doc
+      include Helper
+      def initialize(name, params={})
+        @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
+          <RandomOrderController guiclass="RandomOrderControllerGui" testclass="RandomOrderController" testname="#{name}" enabled="true"/>
+        EOF
+        update params
+      end
+    end  
+
+  end
+end

data/lib/gridinit-jmeter/controllers/simple.rb

@@ -0,0 +1,17 @@
+module Gridinit
+  module Jmeter
+
+    class SimpleController
+      attr_accessor :doc
+      include Helper
+
+      def initialize(name, params={})
+        @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
+          <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="#{name}" enabled="true"/>
+        EOF
+        update params
+      end
+    end
+
+  end
+end

data/lib/gridinit-jmeter/controllers/switch.rb

@@ -0,0 +1,20 @@
+module Gridinit
+  module Jmeter
+
+    class SwitchController
+      attr_accessor :doc
+      include Helper
+
+      def initialize(name, switch_value, params={})
+        @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
+        <SwitchController guiclass="SwitchControllerGui" testclass="SwitchController" testname="#{name}" enabled="#{enabled(params)}">
+          <stringProp name="SwitchController.value">#{switch_value}</stringProp>
+        </SwitchController>
+
+        EOF
+        update params
+      end
+    end
+
+  end
+end

data/lib/gridinit-jmeter/dsl.rb

@@ -28,7 +28,10 @@ module Gridinit
           </jmeterTestPlan>
         EOF
         node = Gridinit::Jmeter::TestPlan.new
-        @root.at_xpath("//jmeterTestPlan/hashTree") << node.doc.children << hash_tree
+
+
+        @current_node = @root.at_xpath("//jmeterTestPlan/hashTree")
+        @current_node = attach_to_last(node)
 
         variables(
           :name     => 'testguid',
@@ -38,97 +41,87 @@ module Gridinit
 
       def variables(params={}, &block)
         node = Gridinit::Jmeter::UserDefinedVariable.new(params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
       def defaults(params={}, &block)
         node = Gridinit::Jmeter::RequestDefaults.new(params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
       def cookies(params={}, &block)
         node = Gridinit::Jmeter::CookieManager.new(params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
       def cache(params={}, &block)
         node = Gridinit::Jmeter::CacheManager.new(params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
       def header(params={}, &block)
         node = Gridinit::Jmeter::HeaderManager.new(params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
       def with_xhr(params={}, &block)
         node = Gridinit::Jmeter::HeaderManager.new(
           params.merge('X-Requested-With' => 'XMLHttpRequest')
         )
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
       def with_user_agent(device, params={}, &block)
         node = Gridinit::Jmeter::HeaderManager.new(
           params.merge('User-Agent' => Gridinit::Jmeter::UserAgent.new(device).string)
         )
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
       def auth(params={}, &block)
         node = Gridinit::Jmeter::AuthManager.new(params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
       def threads(num_threads=1, params={}, &block)
         node = Gridinit::Jmeter::ThreadGroup.new(num_threads, params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
       def transaction(name="Transaction Contoller", params={}, &block)
         node = Gridinit::Jmeter::Transaction.new(name, params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
       def exists(var, params={}, &block)
         params[:condition] = "'${#{var}}'.length > 0"
-        node = Gridinit::Jmeter::IfController.new("if #{var}", params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        node               = Gridinit::Jmeter::IfController.new("if #{var}", params)
+        attach_node(node, &block)
       end
 
       def once(name="do once", params={}, &block)
         node = Gridinit::Jmeter::OnceOnly.new(name, params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
       def throughput(name="throughput", percent=100.0, params={}, &block)
         node = Gridinit::Jmeter::Throughput.new(name, percent, params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
-      def If(name="If Controller", params={}, &block)
-        node = Gridinit::Jmeter::IfController.new(name, params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+      def If(name="If Controller", condition="", params={}, &block)
+        node = Gridinit::Jmeter::IfController.new(name, condition, params)
+        attach_node(node, &block)
       end
 
       def Loop(loops=1, params={}, &block)
         node = Gridinit::Jmeter::LoopController.new(loops, params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
+      end
+
+      def Switch(name, switch_value, params={}, &block)
+        node = Gridinit::Jmeter::SwitchController.new(name, switch_value, params)
+        attach_node(node, &block)
       end
 
       def While(condition, params={}, &block)
@@ -139,153 +132,170 @@ module Gridinit
 
       def counter(name="counter", params={}, &block)
         node = Gridinit::Jmeter::CounterConfig.new(name, params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
+      end
+
+      def random_variable(name, min, max, params={}, &block)
+        node = Gridinit::Jmeter::RandomVariableConfig.new(name, min, max, params)
+        attach_node(node, &block)
+      end
+
+      def random_order(name='Random Order Controller', params={}, &block)
+        node = Gridinit::Jmeter::RandomOrderController.new(name, params)
+        attach_node(node, &block)
+      end
+
+      def interleave(name='Interleave Controller', params={}, &block)
+        node = Gridinit::Jmeter::InterleaveController.new(name, params)
+        attach_node(node, &block)
+      end
+
+      def simple(name='Simple Controller', params={}, &block)
+        node = Gridinit::Jmeter::SimpleController.new(name, params)
+        attach_node(node, &block)
       end
 
       def bsh_pre(script, params={}, &block)
         node = Gridinit::Jmeter::BeanShellPreProcessor.new(script, params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
       def visit(name="HTTP Request", url="", params={}, &block)
-        params[:method] = 'GET' if params[:method] == nil
+        params[:method] ||= 'GET'
         node = Gridinit::Jmeter::HttpSampler.new(name, url, params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        node            = Gridinit::Jmeter::HttpSampler.new(name, url, params)
+        attach_node(node, &block)
       end
 
       alias_method :get, :visit
 
       def submit(name="HTTP Request", url="", params={}, &block)
-        params[:method] = 'POST'
-        node = Gridinit::Jmeter::HttpSampler.new(name, url, params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        params[:method] ||= 'POST'
+        node            = Gridinit::Jmeter::HttpSampler.new(name, url, params)
+        attach_node(node, &block)
       end
 
       alias_method :post, :submit
 
+      def delete(name="HTTP Request", url="", params={}, &block)
+        params[:method] ||= 'DELETE'
+        node            = Gridinit::Jmeter::HttpSampler.new(name, url, params)
+        attach_node(node, &block)
+      end
+
+      def put(name="HTTP Request", url="", params={}, &block)
+        params[:method] ||= 'PUT'
+        node            = Gridinit::Jmeter::HttpSampler.new(name, url, params)
+        attach_node(node, &block)
+      end
+
       def extract(*args, &block)
         node = case args.first
-        when :regex
-          Gridinit::Jmeter::RegexExtractor.new(*args[1..-1])
-        when :xpath
-          Gridinit::Jmeter::XpathExtractor.new(*args[1..-1])
-        else
-          Gridinit::Jmeter::RegexExtractor.new(*args)
-        end
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+                 when :regex
+                   Gridinit::Jmeter::RegexExtractor.new(*args[1..-1])
+                 when :xpath
+                   Gridinit::Jmeter::XpathExtractor.new(*args[1..-1])
+                 else
+                   Gridinit::Jmeter::RegexExtractor.new(*args)
+               end
+        attach_node(node, &block)
       end
 
       alias_method :web_reg_save_param, :extract
 
       def random_timer(delay=0, range=0, &block)
         node = Gridinit::Jmeter::GaussianRandomTimer.new(delay, range)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
       alias_method :think_time, :random_timer
 
       def assert(match="contains", pattern="", params={}, &block)
         node = Gridinit::Jmeter::ResponseAssertion.new(match, pattern, params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
       alias_method :web_reg_find, :assert
 
       def view_results_full_visualizer(name="View Results Tree", params={}, &block)
         node = Gridinit::Jmeter::ViewResultsFullVisualizer.new(name, params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
       alias_method :view_results, :view_results_full_visualizer
 
       def table_visualizer(name="View Results in Table", params={}, &block)
         node = Gridinit::Jmeter::TableVisualizer.new(name, params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
       def graph_visualizer(name="Graph Results", params={}, &block)
         node = Gridinit::Jmeter::GraphVisualizer.new(name, params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
       def stat_visualizer(name="Stat Results", params={}, &block)
         node = Gridinit::Jmeter::StatVisualizer.new(name, params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
       def simple_data_writer(name="Simple Data Writer", params={}, &block)
         node = Gridinit::Jmeter::SimpleDataWriter.new(name, params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
       alias_method :log, :simple_data_writer
 
       def response_time_graph_visualizer(name="Reponse Time Graph", params={}, &block)
         node = Gridinit::Jmeter::ResponseTimeGraphVisualizer.new(name, params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
       alias_method :response_graph, :response_time_graph_visualizer
 
       def summary_report(name="Summary Report", params={}, &block)
         node = Gridinit::Jmeter::SummaryReport.new(name, params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
+      end
+
+      def aggregate_report(name="Aggregate Report", params={}, &block)
+        node = Gridinit::Jmeter::AggregateReport.new(name, params)
+        attach_node(node, &block)
       end
 
       def ldap_ext(name="LDAPExtSampler", params={}, &block)
         node = Gridinit::Jmeter::LDAPExtSampler.new(name, params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
       def gc_response_codes_per_second(name="jp@gc - Response Codes per Second", params={}, &block)
         node = Gridinit::Jmeter::GCResponseCodesPerSecond.new(name, params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
       def gc_response_times_distribution(name="jp@gc - Response Times Distribution", params={}, &block)
         node = Gridinit::Jmeter::GCResponseTimesDistribution.new(name, params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
       def gc_response_times_over_time(name="jp@gc - Response Times Over Time", params={}, &block)
         node = Gridinit::Jmeter::GCResponseTimesOverTime.new(name, params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
       def gc_response_times_percentiles(name="jp@gc - Response Times Percentiles", params={}, &block)
         node = Gridinit::Jmeter::GCResponseTimesPercentiles.new(name, params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
       def gc_transactions_per_second(name="jp@gc - Transactions per Second", params={}, &block)
         node = Gridinit::Jmeter::GCTransactionsPerSecond.new(name, params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
       def gc_latencies_over_time(name="jp@gc - Response Latencies Over Time", params={}, &block)
         node = Gridinit::Jmeter::GCLatenciesOverTime.new(name, params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
       def gc_console_status_logger(name="jp@gc - Console Status Logger", params={}, &block)
@@ -298,8 +308,7 @@ module Gridinit
 
       def throughput_shaper(name="jp@gc - Throughput Shaping Timer", steps=[], params={}, &block)
         node = Gridinit::Jmeter::ThroughputShapingTimer.new(name, steps)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
+        attach_node(node, &block)
       end
 
       alias_method :shaper, :throughput_shaper
@@ -313,6 +322,14 @@ module Gridinit
         logger.info "Test plan saved to: #{params[:file]}"
       end
 
+      def to_xml
+        doc.to_xml(:indent => 2)
+      end
+
+      def to_doc
+        doc.clone
+      end
+
       def run(params={})
         file(params)
         logger.warn "Test executing locally ..."
@@ -367,47 +384,19 @@ module Gridinit
         Nokogiri::XML::Node.new("hashTree", @root)
       end
 
-      def attach_to_last(node, calling_method)
-        xpath = xpath_from(calling_method)
-        last_node  = @root.xpath(xpath).last
-        last_node << node.doc.children << hash_tree
-      end
-
-      def xpath_from(calling_method)
-        case calling_method.grep(/dsl/)[1][/`.*'/][1..-2]
-        when 'threads'
-          '//ThreadGroup/following-sibling::hashTree'
-        when 'transaction'
-          '//TransactionController/following-sibling::hashTree'
-        when 'throughput'
-          '//ThroughputController/following-sibling::hashTree'
-        when 'once'
-          '//OnceOnlyController/following-sibling::hashTree'
-        when 'exists'
-          '//IfController/following-sibling::hashTree'
-        when 'Loop'
-          '//LoopController/following-sibling::hashTree'
-        when 'While'
-          '//WhileController/following-sibling::hashTree'
-        when 'counter'
-          '//CounterConfig/following-sibling::hashTree'
-        when 'bsh_pre'
-          '//BeanShellPreProcessor/following-sibling::hashTree'
-        when 'visit'
-          '//HTTPSamplerProxy/following-sibling::hashTree'
-        when 'submit'
-          '//HTTPSamplerProxy/following-sibling::hashTree'
-        when 'post'
-          '//HTTPSamplerProxy/following-sibling::hashTree'
-        when 'extract'
-          '//RegexExtractor/following-sibling::hashTree'
-        when 'random_timer'
-          '//GaussianRandomTimer/following-sibling::hashTree'
-        when 'throughput_shaper'
-          '//kg.apc.jmeter.timers.VariableThroughputTimer/following-sibling::hashTree'
-        else
-          '//TestPlan/following-sibling::hashTree'
-        end
+      def attach_to_last(node)
+        ht        = hash_tree
+        last_node = @current_node
+        last_node << node.doc.children << ht
+        ht
+      end
+
+      def attach_node(node, &block)
+        ht            = attach_to_last(node)
+        previous      = @current_node
+        @current_node = ht
+        self.instance_exec(&block) if block
+        @current_node = previous
       end
 
       def file(params={})
@@ -416,11 +405,11 @@ module Gridinit
       end
 
       def doc
-        Nokogiri::XML(@root.to_s,&:noblanks)
+        Nokogiri::XML(@root.to_s, &:noblanks)
       end
 
       def logger
-        @log ||= Logger.new(STDOUT)
+        @log       ||= Logger.new(STDOUT)
         @log.level = Logger::DEBUG
         @log
       end

data/lib/gridinit-jmeter/helpers/dsl_helper.rb

@@ -4,7 +4,16 @@ module Gridinit
       def update(params)
         params.each do |name, value|
           node = @doc.children.xpath("//*[contains(@name,\"#{name.to_s}\")]")
-          node.first.content = value unless node.empty? 
+          node.first.content = value unless node.empty?
+        end
+      end
+
+      def enabled(params)
+        #default to true unless explicitly set to false
+        if params.has_key?(:enabled) && params[:enabled] == false
+          'false'
+        else
+          'true'
         end
       end
     end

data/lib/gridinit-jmeter/listeners/aggregate_report.rb

@@ -0,0 +1,47 @@
+module Gridinit
+  module Jmeter
+
+    class AggregateReport
+      attr_accessor :doc
+      include Helper
+
+      def initialize(name, params={})
+        @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
+            <ResultCollector guiclass="StatVisualizer" testclass="ResultCollector" testname="#{name}" enabled="#{enabled(params)}">
+              <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>true</dataType>
+                  <encoding>false</encoding>
+                  <assertions>true</assertions>
+                  <subresults>true</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>
+                </value>
+              </objProp>
+              <stringProp name="filename"></stringProp>
+            </ResultCollector>
+        EOF
+        update params
+      end
+    end
+
+  end
+end

data/lib/gridinit-jmeter/listeners/gc_latencies_over_time.rb

@@ -6,7 +6,7 @@ module Gridinit
       include Helper
       def initialize(name, params={})
         @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
-          <kg.apc.jmeter.vizualizers.CorrectedResultCollector guiclass="kg.apc.jmeter.vizualizers.LatenciesOverTimeGui" testclass="kg.apc.jmeter.vizualizers.CorrectedResultCollector" testname="#{name}" enabled="true">
+          <kg.apc.jmeter.vizualizers.CorrectedResultCollector guiclass="kg.apc.jmeter.vizualizers.LatenciesOverTimeGui" testclass="kg.apc.jmeter.vizualizers.CorrectedResultCollector" testname="#{name}" enabled="#{enabled(params)}">
             <boolProp name="ResultCollector.error_logging">false</boolProp>
             <objProp>
               <name>saveConfig</name>

data/lib/gridinit-jmeter/listeners/gc_response_codes_per_second.rb

@@ -6,7 +6,7 @@ module Gridinit
       include Helper
       def initialize(name, params={})
         @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
-          <kg.apc.jmeter.vizualizers.CorrectedResultCollector guiclass="kg.apc.jmeter.vizualizers.ResponseCodesPerSecondGui" testclass="kg.apc.jmeter.vizualizers.CorrectedResultCollector" testname="#{name}" enabled="true">
+          <kg.apc.jmeter.vizualizers.CorrectedResultCollector guiclass="kg.apc.jmeter.vizualizers.ResponseCodesPerSecondGui" testclass="kg.apc.jmeter.vizualizers.CorrectedResultCollector" testname="#{name}" enabled="#{enabled(params)}">
             <boolProp name="ResultCollector.error_logging">false</boolProp>
             <objProp>
               <name>saveConfig</name>

data/lib/gridinit-jmeter/listeners/gc_response_times_distribution.rb

@@ -6,7 +6,7 @@ module Gridinit
       include Helper
       def initialize(name, params={})
         @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
-          <kg.apc.jmeter.vizualizers.CorrectedResultCollector guiclass="kg.apc.jmeter.vizualizers.ResponseTimesDistributionGui" testclass="kg.apc.jmeter.vizualizers.CorrectedResultCollector" testname="#{name}" enabled="true">
+          <kg.apc.jmeter.vizualizers.CorrectedResultCollector guiclass="kg.apc.jmeter.vizualizers.ResponseTimesDistributionGui" testclass="kg.apc.jmeter.vizualizers.CorrectedResultCollector" testname="#{name}" enabled="#{enabled(params)}">
             <boolProp name="ResultCollector.error_logging">false</boolProp>
             <objProp>
               <name>saveConfig</name>

data/lib/gridinit-jmeter/listeners/gc_response_times_over_time.rb

@@ -6,7 +6,7 @@ module Gridinit
       include Helper
       def initialize(name, params={})
         @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
-          <kg.apc.jmeter.vizualizers.CorrectedResultCollector guiclass="kg.apc.jmeter.vizualizers.ResponseTimesOverTimeGui" testclass="kg.apc.jmeter.vizualizers.CorrectedResultCollector" testname="#{name}" enabled="true">
+          <kg.apc.jmeter.vizualizers.CorrectedResultCollector guiclass="kg.apc.jmeter.vizualizers.ResponseTimesOverTimeGui" testclass="kg.apc.jmeter.vizualizers.CorrectedResultCollector" testname="#{name}" enabled="#{enabled(params)}">
             <boolProp name="ResultCollector.error_logging">false</boolProp>
             <objProp>
               <name>saveConfig</name>

data/lib/gridinit-jmeter/listeners/gc_response_times_percentiles.rb

@@ -6,7 +6,7 @@ module Gridinit
       include Helper
       def initialize(name, params={})
         @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
-          <kg.apc.jmeter.vizualizers.CorrectedResultCollector guiclass="kg.apc.jmeter.vizualizers.ResponseTimesPercentilesGui" testclass="kg.apc.jmeter.vizualizers.CorrectedResultCollector" testname="#{name}" enabled="true">
+          <kg.apc.jmeter.vizualizers.CorrectedResultCollector guiclass="kg.apc.jmeter.vizualizers.ResponseTimesPercentilesGui" testclass="kg.apc.jmeter.vizualizers.CorrectedResultCollector" testname="#{name}" enabled="#{enabled(params)}">
             <boolProp name="ResultCollector.error_logging">false</boolProp>
             <objProp>
               <name>saveConfig</name>

data/lib/gridinit-jmeter/listeners/gc_transactions_per_second.rb

@@ -6,7 +6,7 @@ module Gridinit
       include Helper
       def initialize(name, params={})
         @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
-          <kg.apc.jmeter.vizualizers.CorrectedResultCollector guiclass="kg.apc.jmeter.vizualizers.TransactionsPerSecondGui" testclass="kg.apc.jmeter.vizualizers.CorrectedResultCollector" testname="#{name}" enabled="true">
+          <kg.apc.jmeter.vizualizers.CorrectedResultCollector guiclass="kg.apc.jmeter.vizualizers.TransactionsPerSecondGui" testclass="kg.apc.jmeter.vizualizers.CorrectedResultCollector" testname="#{name}" enabled="#{enabled(params)}">
             <boolProp name="ResultCollector.error_logging">false</boolProp>
             <objProp>
               <name>saveConfig</name>

data/lib/gridinit-jmeter/listeners/graph_visualizer.rb

@@ -6,7 +6,7 @@ module Gridinit
       include Helper
       def initialize(name, params={})
         @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
-          <ResultCollector guiclass="GraphVisualizer" testclass="ResultCollector" testname="#{name}" enabled="true">
+          <ResultCollector guiclass="GraphVisualizer" testclass="ResultCollector" testname="#{name}" enabled="#{enabled(params)}">
             <boolProp name="ResultCollector.error_logging">false</boolProp>
             <objProp>
               <name>saveConfig</name>

data/lib/gridinit-jmeter/listeners/response_time_graph_visualizer.rb

@@ -7,7 +7,7 @@ module Gridinit
       def initialize(name, params={})
         @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
 
-          <ResultCollector guiclass="RespTimeGraphVisualizer" testclass="ResultCollector" testname="#{name}" enabled="true">
+          <ResultCollector guiclass="RespTimeGraphVisualizer" testclass="ResultCollector" testname="#{name}" enabled="#{enabled(params)}">
             <boolProp name="ResultCollector.error_logging">false</boolProp>
             <objProp>
               <name>saveConfig</name>

data/lib/gridinit-jmeter/listeners/simple_data_writer.rb

@@ -6,7 +6,7 @@ module Gridinit
       include Helper
       def initialize(name, params={})
         @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
-          <ResultCollector guiclass="SimpleDataWriter" testclass="ResultCollector" testname="#{name}" enabled="true">
+          <ResultCollector guiclass="SimpleDataWriter" testclass="ResultCollector" testname="#{name}" enabled="#{enabled(params)}">
             <boolProp name="ResultCollector.error_logging">false</boolProp>
             <objProp>
               <name>saveConfig</name>

data/lib/gridinit-jmeter/listeners/stat_visualizer.rb

@@ -6,7 +6,7 @@ module Gridinit
       include Helper
       def initialize(name, params={})
         @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
-          <ResultCollector guiclass="StatVisualizer" testclass="ResultCollector" testname="#{name}" enabled="true">
+          <ResultCollector guiclass="StatVisualizer" testclass="ResultCollector" testname="#{name}" enabled="#{enabled(params)}">
             <boolProp name="ResultCollector.error_logging">false</boolProp>
             <objProp>
               <name>saveConfig</name>

data/lib/gridinit-jmeter/listeners/summary_report.rb

@@ -6,7 +6,7 @@ module Gridinit
       include Helper
       def initialize(name, params={})
         @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
-          <ResultCollector guiclass="SummaryReport" testclass="ResultCollector" testname="#{name}" enabled="true">
+          <ResultCollector guiclass="SummaryReport" testclass="ResultCollector" testname="#{name}" enabled="#{enabled(params)}">
             <boolProp name="ResultCollector.error_logging">false</boolProp>
             <objProp>
               <name>saveConfig</name>

data/lib/gridinit-jmeter/listeners/table_visualizer.rb

@@ -6,7 +6,7 @@ module Gridinit
       include Helper
       def initialize(name, params={})
         @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
-          <ResultCollector guiclass="TableVisualizer" testclass="ResultCollector" testname="#{name}" enabled="true">
+          <ResultCollector guiclass="TableVisualizer" testclass="ResultCollector" testname="#{name}" enabled="#{enabled(params)}">
             <boolProp name="ResultCollector.error_logging">false</boolProp>
             <objProp>
               <name>saveConfig</name>

data/lib/gridinit-jmeter/listeners/view_results_full_visualizer.rb

@@ -4,10 +4,11 @@ module Gridinit
     class ViewResultsFullVisualizer
       attr_accessor :doc
       include Helper
+
       def initialize(name, params={})
         @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
-          <ResultCollector guiclass="ViewResultsFullVisualizer" testclass="ResultCollector" testname="#{name}" enabled="true">
-            <boolProp name="ResultCollector.error_logging">false</boolProp>
+          <ResultCollector guiclass="ViewResultsFullVisualizer" testclass="ResultCollector" testname="#{name}" enabled="#{enabled(params)}">
+            <boolProp name="ResultCollector.error_logging">#{error_only(params)}</boolProp>
             <objProp>
               <name>saveConfig</name>
               <value class="SampleSaveConfiguration">
@@ -40,7 +41,17 @@ module Gridinit
         EOF
         update params
       end
-    end  
+
+      def error_only(params)
+        #default to true unless explicitly set to false
+        if params.has_key?(:error_only) && params[:error_only] == true
+          'true'
+        else
+          'false'
+        end
+      end
+    end
+
 
   end
 end

data/lib/gridinit-jmeter/post_processors/regex_extractor.rb

@@ -4,21 +4,31 @@ module Gridinit
     class RegexExtractor
       attr_accessor :doc
       include Helper
+
       def initialize(name, regex, params={})
         @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
           <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="#{name}" enabled="true">
-            <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+            <stringProp name="RegexExtractor.useHeaders">#{use_headers_type(params)}</stringProp>
             <stringProp name="RegexExtractor.refname">#{name}</stringProp>
             <stringProp name="RegexExtractor.regex">#{CGI.escapeHTML regex}</stringProp>
             <stringProp name="RegexExtractor.template">$1$</stringProp>
-            <stringProp name="RegexExtractor.default"></stringProp>
+            <stringProp name="RegexExtractor.default">#{params[:default]}</stringProp>
             <stringProp name="RegexExtractor.match_number">0</stringProp>
             <stringProp name="Sample.scope">all</stringProp>
           </RegexExtractor>
         EOF
         update params
       end
-    end  
+
+      def use_headers_type(params)
+        #default to true unless explicitly set to false
+        if params.has_key?(:match_on)
+          params[:match_on]
+        else
+          'false'
+        end
+      end
+    end
 
   end
 end

data/lib/gridinit-jmeter/pre_processors/bean_shell_pre_processor.rb

@@ -10,7 +10,9 @@ module Gridinit
             <stringProp name="filename"></stringProp>
             <stringProp name="parameters"></stringProp>
             <boolProp name="resetInterpreter">false</boolProp>
-            <stringProp name="script">#{script}</stringProp>
+            <stringProp name="script"><![CDATA[
+#{script}
+            ]]></stringProp>
           </BeanShellPreProcessor>
         EOF
         update params

data/lib/gridinit-jmeter/threads/thread_group.rb

@@ -5,6 +5,7 @@ module Gridinit
       attr_accessor :doc
       include Helper
       def initialize(num_threads, params={})
+        params[:ramp_time] ||= num_threads/2
         @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
           <ThreadGroup guiclass="ThreadGroupGui" testclass="ThreadGroup" testname="Thread Group" enabled="true">
             <stringProp name="ThreadGroup.on_sample_error">continue</stringProp>
@@ -13,7 +14,7 @@ module Gridinit
               <stringProp name="LoopController.loops">1</stringProp>
             </elementProp>
             <stringProp name="ThreadGroup.num_threads">#{num_threads}</stringProp>
-            <stringProp name="ThreadGroup.ramp_time">1</stringProp>
+            <stringProp name="ThreadGroup.ramp_time">#{params[:ramp_time]}</stringProp>
             <longProp name="ThreadGroup.start_time">1352677419000</longProp>
             <longProp name="ThreadGroup.end_time">1352677419000</longProp>
             <boolProp name="ThreadGroup.scheduler">false</boolProp>

data/lib/gridinit-jmeter/version.rb

@@ -1,5 +1,5 @@
 module Gridinit
   module Jmeter
-    VERSION = "0.2.4"
+    VERSION = "0.2.5"
   end
 end

data/spec/dsl_spec.rb

@@ -21,15 +21,138 @@ describe "DSL" do
   it "should output a test plan to stdout" do
     $stdout.should_receive(:puts).with(/jmeterTestPlan/i)
     test do
-    end.jmx
+    end.out
   end
 
   it "should output a test plan to jmx file" do
     file = mock('file')
-    File.should_receive(:open).with("/tmp/jmeter.jmx", "w").and_yield(file)
+    File.should_receive(:open).with("jmeter.jmx", "w").and_yield(file)
     file.should_receive(:write).with(/jmeterTestPlan/i)
     test do
     end.jmx
   end
 
+  describe 'Disabled reports' do
+    let(:doc) do
+      test do
+        aggregate_report('Aggregate Report disabled', {enabled: false})
+        aggregate_report('Aggregate Report enabled', {enabled: true})
+        aggregate_report('Aggregate Report default', {enabled: true})
+      end.to_doc
+    end
+
+    let(:aggregate_report_disabled) { doc.search("//ResultCollector[@testname='Aggregate Report disabled']").first }
+    let(:aggregate_report_enabled) { doc.search("//ResultCollector[@testname='Aggregate Report enabled']").first }
+    let(:aggregate_report_default) { doc.search("//ResultCollector[@testname='Aggregate Report default']").first }
+
+    it 'should disable Aggregate Report disabled' do
+      aggregate_report_disabled.attributes['enabled'].value.should == 'false'
+    end
+
+    it 'should disable Aggregate Report enabled' do
+      aggregate_report_enabled.attributes['enabled'].value.should == 'true'
+    end
+    it 'should disable Aggregate Report default' do
+      aggregate_report_enabled.attributes['enabled'].value.should == 'true'
+    end
+  end
+
+  describe do
+
+    let(:doc) do
+      test do
+        view_results_full_visualizer('View Results Tree error_only', {error_only: true})
+        view_results_full_visualizer('View Results Tree not error_only', {error_only: false})
+        view_results_full_visualizer('View Results Tree default')
+      end.to_doc
+    end
+
+    let(:report_errors_only) { doc.search("//ResultCollector[@testname='View Results Tree error_only']").first }
+    let(:report_not_errors_only) { doc.search("//ResultCollector[@testname='View Results Tree not error_only']").first }
+    let(:report_default) { doc.search("//ResultCollector[@testname='View Results Tree default']").first }
+
+    it 'should be true when errors only' do
+      error_logging = report_errors_only.children.first
+      error_logging.attributes['name'].value.should == 'ResultCollector.error_logging'
+      error_logging.text.should == 'true'
+    end
+
+    it 'should be false when not errors only' do
+      error_logging = report_not_errors_only.children.first
+      error_logging.attributes['name'].value.should == 'ResultCollector.error_logging'
+      error_logging.text.should == 'false'
+    end
+    it 'should default to false when not given' do
+      error_logging = report_default.children.first
+      error_logging.attributes['name'].value.should == 'ResultCollector.error_logging'
+      error_logging.text.should == 'false'
+    end
+  end
+
+  describe 'extract use_headers_type' do
+
+    let(:doc) do
+      test do
+        extract :regex, 'match on url', 'blah', {match_on: 'URL'}
+        extract :regex, 'match on default', 'blah'
+      end.to_doc
+    end
+
+    let(:extract_url) { doc.search("//RegexExtractor[@testname='match on url']").first }
+    let(:extract) { doc.search("//RegexExtractor[@testname='match on default']").first }
+
+    it 'should match on URL' do
+      extract_url.search(".//stringProp[@name='RegexExtractor.useHeaders']").text.should == 'URL'
+    end
+
+    it 'should default to false' do
+      extract.search(".//stringProp[@name='RegexExtractor.useHeaders']").text.should == 'false'
+    end
+
+  end
+
+  describe 'Nested controllers' do
+
+    let(:doc) do
+      test do
+        simple 'blah1.1' do
+          simple 'blah2.1'
+          simple 'blah2.2' do
+            simple 'blah3.1'
+          end
+          simple 'blah2.3'
+        end
+        simple 'blah1.2'
+      end.to_doc
+    end
+
+    let(:blah1_1) { doc.search("//GenericController[@testname='blah1.1']").first }
+    let(:blah1_2) { doc.search("//GenericController[@testname='blah1.2']").first }
+
+    let(:blah2_1) { doc.search("//GenericController[@testname='blah2.1']").first }
+    let(:blah2_2) { doc.search("//GenericController[@testname='blah2.2']").first }
+    let(:blah2_3) { doc.search("//GenericController[@testname='blah2.3']").first }
+
+    let(:blah3_1) { doc.search("//GenericController[@testname='blah3.1']").first }
+
+    it 'nodes should have hashTree as its parent' do
+      [blah1_1, blah1_2, blah2_1, blah2_2, blah2_3, blah3_1].each do |node|
+        node.parent.name.should == 'hashTree'
+      end
+    end
+
+    describe 'blah3_1' do
+      it 'parent parent should be blah2_2' do
+        blah3_1.parent.should == blah2_2.next
+      end
+    end
+
+    describe 'blah1_2' do
+      it 'previous non hashTree sibling is blah1_1' do
+        blah1_2.previous.previous.should == blah1_1
+      end
+    end
+
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gridinit-jmeter
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-08 00:00:00.000000000 Z
+date: 2013-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -53,7 +53,6 @@ extra_rdoc_files: []
 files:
 - .gitattributes
 - .gitignore
-- .rbenv-version
 - .rspec
 - .travis.yml
 - Gemfile
@@ -93,11 +92,16 @@ files:
 - lib/gridinit-jmeter/config/cookie_manager.rb
 - lib/gridinit-jmeter/config/counter_config.rb
 - lib/gridinit-jmeter/config/header_manager.rb
+- lib/gridinit-jmeter/config/random_variable.rb
 - lib/gridinit-jmeter/config/request_defaults.rb
 - lib/gridinit-jmeter/config/user_defined_variable.rb
 - lib/gridinit-jmeter/controllers/if_controller.rb
+- lib/gridinit-jmeter/controllers/interleave.rb
 - lib/gridinit-jmeter/controllers/loop_controller.rb
 - lib/gridinit-jmeter/controllers/once_only.rb
+- lib/gridinit-jmeter/controllers/random_order.rb
+- lib/gridinit-jmeter/controllers/simple.rb
+- lib/gridinit-jmeter/controllers/switch.rb
 - lib/gridinit-jmeter/controllers/throughput.rb
 - lib/gridinit-jmeter/controllers/transaction.rb
 - lib/gridinit-jmeter/controllers/while_controller.rb
@@ -108,6 +112,7 @@ files:
 - lib/gridinit-jmeter/helpers/logger-colors.rb
 - lib/gridinit-jmeter/helpers/strip-heredoc.rb
 - lib/gridinit-jmeter/helpers/user-agents.rb
+- lib/gridinit-jmeter/listeners/aggregate_report.rb
 - lib/gridinit-jmeter/listeners/gc_console_status_logger.rb
 - lib/gridinit-jmeter/listeners/gc_latencies_over_time.rb
 - lib/gridinit-jmeter/listeners/gc_response_codes_per_second.rb
@@ -159,7 +164,4 @@ rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: This is a Ruby based DSL for writing JMeter test plans
-test_files:
-- spec/dsl_spec.rb
-- spec/spec_helper.rb
-- spec/stub.rb
+test_files: []

data/.rbenv-version

@@ -1 +0,0 @@
-1.9.3-p385