gridinit-jmeter 0.3.2 → 1.0.0.pre

data/lib/gridinit-jmeter/{idl → dsl}/user_parameters.rb

@@ -12,9 +12,10 @@ module Gridinit
       attr_accessor :doc
       include Helper
 
-      def initialize(name, params={})
+      def initialize(params={})
+        params[:name] ||= 'UserParameters'
         @doc = Nokogiri::XML(<<-EOS.strip_heredoc)
-<UserParameters guiclass="UserParametersGui" testclass="UserParameters" testname="#{name}" enabled="true">
+<UserParameters guiclass="UserParametersGui" testclass="UserParameters" testname="#{params[:name]}" enabled="true">
   <collectionProp name="UserParameters.names"/>
   <collectionProp name="UserParameters.thread_values">
     <collectionProp name="1"/>
@@ -23,6 +24,7 @@ module Gridinit
 </UserParameters>)
         EOS
         update params
+        update_at_xpath params if params[:update_at_xpath]
       end
     end
 

data/lib/gridinit-jmeter/{idl → dsl}/view_results_in_table.rb

@@ -12,9 +12,10 @@ module Gridinit
       attr_accessor :doc
       include Helper
 
-      def initialize(name, params={})
+      def initialize(params={})
+        params[:name] ||= 'ViewResultsInTable'
         @doc = Nokogiri::XML(<<-EOS.strip_heredoc)
-<ResultCollector guiclass="TableVisualizer" testclass="ResultCollector" testname="#{name}" enabled="true">
+<ResultCollector guiclass="TableVisualizer" testclass="ResultCollector" testname="#{params[:name]}" enabled="true">
   <boolProp name="ResultCollector.error_logging">false</boolProp>
   <objProp>
     <name>saveConfig</name>
@@ -49,6 +50,7 @@ module Gridinit
 </ResultCollector>)
         EOS
         update params
+        update_at_xpath params if params[:update_at_xpath]
       end
     end
 

data/lib/gridinit-jmeter/{idl → dsl}/view_results_tree.rb

@@ -12,9 +12,10 @@ module Gridinit
       attr_accessor :doc
       include Helper
 
-      def initialize(name, params={})
+      def initialize(params={})
+        params[:name] ||= 'ViewResultsTree'
         @doc = Nokogiri::XML(<<-EOS.strip_heredoc)
-<ResultCollector guiclass="ViewResultsFullVisualizer" testclass="ResultCollector" testname="#{name}" enabled="true">
+<ResultCollector guiclass="ViewResultsFullVisualizer" testclass="ResultCollector" testname="#{params[:name]}" enabled="true">
   <boolProp name="ResultCollector.error_logging">false</boolProp>
   <objProp>
     <name>saveConfig</name>
@@ -49,6 +50,7 @@ module Gridinit
 </ResultCollector>)
         EOS
         update params
+        update_at_xpath params if params[:update_at_xpath]
       end
     end
 

data/lib/gridinit-jmeter/{idl → dsl}/while_controller.rb

@@ -12,13 +12,15 @@ module Gridinit
       attr_accessor :doc
       include Helper
 
-      def initialize(name, params={})
+      def initialize(params={})
+        params[:name] ||= 'WhileController'
         @doc = Nokogiri::XML(<<-EOS.strip_heredoc)
-<WhileController guiclass="WhileControllerGui" testclass="WhileController" testname="#{name}" enabled="true">
+<WhileController guiclass="WhileControllerGui" testclass="WhileController" testname="#{params[:name]}" enabled="true">
   <stringProp name="WhileController.condition"/>
 </WhileController>)
         EOS
         update params
+        update_at_xpath params if params[:update_at_xpath]
       end
     end
 

data/lib/gridinit-jmeter/{idl → dsl}/xml_assertion.rb

@@ -12,11 +12,13 @@ module Gridinit
       attr_accessor :doc
       include Helper
 
-      def initialize(name, params={})
+      def initialize(params={})
+        params[:name] ||= 'XmlAssertion'
         @doc = Nokogiri::XML(<<-EOS.strip_heredoc)
-<XMLAssertion guiclass="XMLAssertionGui" testclass="XMLAssertion" testname="#{name}" enabled="true"/>)
+<XMLAssertion guiclass="XMLAssertionGui" testclass="XMLAssertion" testname="#{params[:name]}" enabled="true"/>)
         EOS
         update params
+        update_at_xpath params if params[:update_at_xpath]
       end
     end
 

data/lib/gridinit-jmeter/{idl → dsl}/xml_schema_assertion.rb

@@ -12,13 +12,15 @@ module Gridinit
       attr_accessor :doc
       include Helper
 
-      def initialize(name, params={})
+      def initialize(params={})
+        params[:name] ||= 'XmlSchemaAssertion'
         @doc = Nokogiri::XML(<<-EOS.strip_heredoc)
-<XMLSchemaAssertion guiclass="XMLSchemaAssertionGUI" testclass="XMLSchemaAssertion" testname="#{name}" enabled="true">
+<XMLSchemaAssertion guiclass="XMLSchemaAssertionGUI" testclass="XMLSchemaAssertion" testname="#{params[:name]}" enabled="true">
   <stringProp name="xmlschema_assertion_filename"/>
 </XMLSchemaAssertion>)
         EOS
         update params
+        update_at_xpath params if params[:update_at_xpath]
       end
     end
 

data/lib/gridinit-jmeter/{idl → dsl}/xpath_assertion.rb

@@ -12,9 +12,10 @@ module Gridinit
       attr_accessor :doc
       include Helper
 
-      def initialize(name, params={})
+      def initialize(params={})
+        params[:name] ||= 'XpathAssertion'
         @doc = Nokogiri::XML(<<-EOS.strip_heredoc)
-<XPathAssertion guiclass="XPathAssertionGui" testclass="XPathAssertion" testname="#{name}" enabled="true">
+<XPathAssertion guiclass="XPathAssertionGui" testclass="XPathAssertion" testname="#{params[:name]}" enabled="true">
   <boolProp name="XPath.negate">false</boolProp>
   <stringProp name="XPath.xpath">/</stringProp>
   <boolProp name="XPath.validate">false</boolProp>
@@ -24,6 +25,7 @@ module Gridinit
 </XPathAssertion>)
         EOS
         update params
+        update_at_xpath params if params[:update_at_xpath]
       end
     end
 

data/lib/gridinit-jmeter/{idl → dsl}/xpath_extractor.rb

@@ -12,9 +12,10 @@ module Gridinit
       attr_accessor :doc
       include Helper
 
-      def initialize(name, params={})
+      def initialize(params={})
+        params[:name] ||= 'XpathExtractor'
         @doc = Nokogiri::XML(<<-EOS.strip_heredoc)
-<XPathExtractor guiclass="XPathExtractorGui" testclass="XPathExtractor" testname="#{name}" enabled="true">
+<XPathExtractor guiclass="XPathExtractorGui" testclass="XPathExtractor" testname="#{params[:name]}" enabled="true">
   <stringProp name="XPathExtractor.default"/>
   <stringProp name="XPathExtractor.refname"/>
   <stringProp name="XPathExtractor.xpathQuery"/>
@@ -24,6 +25,7 @@ module Gridinit
 </XPathExtractor>)
         EOS
         update params
+        update_at_xpath params if params[:update_at_xpath]
       end
     end
 

data/lib/gridinit-jmeter/dsl.rb

@@ -1,22 +1,9 @@
 module Gridinit
 
-  def dsl_eval(dsl, &block)
-    block_context = eval("self", block.binding)
-    proxy_context = Gridinit::Jmeter::FallbackContextProxy.new(dsl, block_context)
-    begin
-      block_context.instance_variables.each { |ivar| proxy_context.instance_variable_set(ivar, block_context.instance_variable_get(ivar)) }
-      proxy_context.instance_eval(&block)
-    ensure
-      block_context.instance_variables.each { |ivar| block_context.instance_variable_set(ivar, proxy_context.instance_variable_get(ivar)) }
-    end
-    dsl
-  end
-
-  module_function :dsl_eval
-
   module Jmeter
 
-    class DSL
+    class ExtendedDSL < DSL
+      include Parser
       attr_accessor :root
 
       def initialize
@@ -29,295 +16,291 @@ module Gridinit
         EOF
         node = Gridinit::Jmeter::TestPlan.new
 
-
         @current_node = @root.at_xpath("//jmeterTestPlan/hashTree")
         @current_node = attach_to_last(node)
 
-        variables(
-          :name     => 'testguid',
-          :value    => '${__P(testguid,${__time(,)})}',
-          :comments => 'The testguid variable is mandatory when running on the Grid.') {}
+        variables :name     => 'testguid',
+                  :value    => '${__P(testguid,${__time(,)})}',
+                  :comments => 'Gridinit testguid automatically generated by DSL'
       end
 
-      def variables(params={}, &block)
-        node = Gridinit::Jmeter::UserDefinedVariable.new(params)
-        attach_node(node, &block)
-      end
+      ##
+      # Config Elements
 
-      def defaults(params={}, &block)
-        node = Gridinit::Jmeter::RequestDefaults.new(params)
-        attach_node(node, &block)
+      def user_defined_variables(params, &block)
+        params['Argument.name'] = params[:name]
+        super
       end
 
-      def cookies(params={}, &block)
-        node = Gridinit::Jmeter::CookieManager.new(params)
-        attach_node(node, &block)
-      end
+      alias_method :variables, :user_defined_variables
 
-      def cache(params={}, &block)
-        node = Gridinit::Jmeter::CacheManager.new(params)
-        attach_node(node, &block)
-      end
+      alias_method :defaults, :http_request_defaults      
 
-      def header(params={}, &block)
-        node = Gridinit::Jmeter::HeaderManager.new(params)
-        attach_node(node, &block)
+      def http_cookie_manager(params={}, &block)
+        params[:clearEachIteration] = true if params.keys.include? 'clear_each_iteration'
+        super
       end
 
-      def with_xhr(params={}, &block)
-        node = Gridinit::Jmeter::HeaderManager.new(
-          params.merge('X-Requested-With' => 'XMLHttpRequest')
-        )
-        attach_node(node, &block)
-      end
+      alias_method :cookies, :http_cookie_manager
 
-      def with_user_agent(device, params={}, &block)
-        node = Gridinit::Jmeter::HeaderManager.new(
-          params.merge('User-Agent' => Gridinit::Jmeter::UserAgent.new(device).string)
-        )
-        attach_node(node, &block)
+      def http_cache_manager(params={}, &block)
+        params[:clearEachIteration] = true if params.keys.include? 'clear_each_iteration'
+        super
       end
 
-      def auth(params={}, &block)
-        node = Gridinit::Jmeter::AuthManager.new(params)
-        attach_node(node, &block)
-      end
+      alias_method :cache, :http_cache_manager
 
-      def threads(num_threads=1, params={}, &block)
-        node = Gridinit::Jmeter::ThreadGroup.new(num_threads, params)
-        attach_node(node, &block)
+      def with_user_agent(device)
+        http_header_manager name: 'User-Agent', 
+                            value: Gridinit::Jmeter::UserAgent.new(device).string
       end
 
-      def transaction(name="Transaction Contoller", params={}, &block)
-        node = Gridinit::Jmeter::Transaction.new(name, params)
-        attach_node(node, &block)
+      def http_header_manager(params, &block)
+        params['Header.name'] = params[:name]
+        super
       end
 
-      def exists(var, params={}, &block)
-        params[:condition] = "'${#{var}}'.length > 0"
-        node               = Gridinit::Jmeter::IfController.new("if #{var}", params)
-        attach_node(node, &block)
-      end
+      alias_method :header, :http_header_manager
 
-      def once(name="do once", params={}, &block)
-        node = Gridinit::Jmeter::OnceOnly.new(name, params)
-        attach_node(node, &block)
-      end
+      alias_method :auth, :http_authorization_manager
 
-      def throughput(name="throughput", percent=100.0, params={}, &block)
-        node = Gridinit::Jmeter::Throughput.new(name, percent, params)
+      def thread_group(*args, &block)
+        params = args.shift || {}
+        params = { count: params }.merge(args.shift || {}) if params.class == Fixnum
+        params[:num_threads]        = params[:count] || 1
+        params[:ramp_time]          = params[:rampup] || (params[:num_threads]/2.0).ceil
+        params[:start_time]         = params[:start_time] || Time.now.to_i * 1000
+        params[:end_time]           = params[:end_time] || Time.now.to_i * 1000
+        params[:duration]         ||= 60
+        params[:continue_forever] ||= false
+        params[:loops]              = -1 if params[:continue_forever]
+        node = Gridinit::Jmeter::ThreadGroup.new(params)
         attach_node(node, &block)
       end
 
-      def If(name="If Controller", condition="", params={}, &block)
-        node = Gridinit::Jmeter::IfController.new(name, condition, params)
-        attach_node(node, &block)
-      end
+      alias_method :threads, :thread_group
 
-      def Loop(loops=1, params={}, &block)
-        node = Gridinit::Jmeter::LoopController.new(loops, params)
-        attach_node(node, &block)
-      end
+      ##
+      # HTTP Samplers
 
-      def Switch(name, switch_value, params={}, &block)
-        node = Gridinit::Jmeter::SwitchController.new(name, switch_value, params)
+      def get(*args, &block)
+        params = args.shift || {}
+        params = { url: params }.merge(args.shift || {}) if params.class == String
+        params[:method] ||= 'GET'
+        params[:name] ||= params[:url]
+        parse_http_request(params)
+        node = Gridinit::Jmeter::HttpRequest.new(params)
         attach_node(node, &block)
       end
 
-      def While(condition, params={}, &block)
-        node = Gridinit::Jmeter::WhileController.new(condition, params)
-        attach_node(node, &block)
-      end
+      alias_method :visit, :get
 
-      def counter(name="counter", params={}, &block)
-        node = Gridinit::Jmeter::CounterConfig.new(name, params)
+      def post(*args, &block)
+        params = args.shift || {}
+        params = { url: params }.merge(args.shift || {}) if params.class == String
+        params[:method] ||= 'POST'
+        params[:name] ||= params[:url]
+        parse_http_request(params)
+        node = Gridinit::Jmeter::HttpRequest.new(params)
         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
+      alias_method :submit, :post
 
-      def random_order(name='Random Order Controller', params={}, &block)
-        node = Gridinit::Jmeter::RandomOrderController.new(name, params)
+      def delete(*args, &block)
+        params = args.shift || {}
+        params = { url: params }.merge(args.shift || {}) if params.class == String
+        params[:method] ||= 'DELETE'
+        params[:name] ||= params[:url]
+        parse_http_request(params)
+        node = Gridinit::Jmeter::HttpRequest.new(params)
         attach_node(node, &block)
       end
 
-      def interleave(name='Interleave Controller', params={}, &block)
-        node = Gridinit::Jmeter::InterleaveController.new(name, params)
+      def put(*args, &block)
+        params = args.shift || {}
+        params = { url: params }.merge(args.shift || {}) if params.class == String
+        params[:method] ||= 'PUT'
+        params[:name] ||= params[:url]
+        parse_http_request(params)
+        node = Gridinit::Jmeter::HttpRequest.new(params)
         attach_node(node, &block)
       end
 
-      def simple(name='Simple Controller', params={}, &block)
-        node = Gridinit::Jmeter::SimpleController.new(name, params)
-        attach_node(node, &block)
+      def with_xhr
+        http_header_manager name: 'X-Requested-With', 
+                            value: 'XMLHttpRequest'
       end
 
-      def bsh_pre(script, params={}, &block)
-        node = Gridinit::Jmeter::BeanShellPreProcessor.new(script, params)
-        attach_node(node, &block)
-      end
+      ##
+      # Other Samplers
 
-      def visit(name="HTTP Request", url="", params={}, &block)
-        params[:method] ||= 'GET'
-        node = Gridinit::Jmeter::HttpSampler.new(name, url, params)
-        node            = Gridinit::Jmeter::HttpSampler.new(name, url, params)
-        attach_node(node, &block)
+      def soapxmlrpc_request(params, &block)
+        params[:method] ||= 'POST'
+        super
       end
 
-      def soap(name="SOAP Request", params={}, &block)
-        params[:method] = 'POST' if params[:method] == nil
-        node = Gridinit::Jmeter::SoapSampler.new(name, params)
-        attach_to_last(node, caller)
-        self.instance_exec(&block) if block
-      end
+      alias_method :soap, :soapxmlrpc_request
 
-      alias_method :get, :visit
+      alias_method :ldap, :ldap_request
 
-      def submit(name="HTTP Request", url="", params={}, &block)
-        params[:method] ||= 'POST'
-        node            = Gridinit::Jmeter::HttpSampler.new(name, url, params)
-        attach_node(node, &block)
-      end
+      alias_method :ldap_ext, :ldap_extended_request
 
-      alias_method :post, :submit
+      alias_method :ldap_extended, :ldap_extended_request
 
-      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
+      ##
+      # Controllers
 
-      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
+      def transaction_controller(*args, &block)
+        params = args.shift || {}
+        params = { name: params }.merge(args.shift || {}) if params.class == String
+        params[:parent] ||= true
+        params[:includeTimers] = params[:include_timers] || false
+        node = Gridinit::Jmeter::TransactionController.new(params)
         attach_node(node, &block)
       end
 
-      alias_method :web_reg_save_param, :extract
+      alias_method :transaction, :transaction_controller
 
-      def random_timer(delay=0, range=0, &block)
-        node = Gridinit::Jmeter::GaussianRandomTimer.new(delay, range)
+      def exists(variable, &block)
+        params ||= {}
+        params[:condition] = "'${#{variable}}'.length > 0"
+        node = Gridinit::Jmeter::IfController.new(params)
         attach_node(node, &block)
       end
 
-      alias_method :think_time, :random_timer
+      alias_method :If, :if_controller
 
-      def assert(match="contains", pattern="", params={}, &block)
-        node = Gridinit::Jmeter::ResponseAssertion.new(match, pattern, params)
-        attach_node(node, &block)
+      def loop_controller(params, &block)
+        params[:loops] = params[:count] || 1
+        super
       end
 
-      alias_method :web_reg_find, :assert
+      alias_method :Loop, :loop_controller
 
-      def view_results_full_visualizer(name="View Results Tree", params={}, &block)
-        node = Gridinit::Jmeter::ViewResultsFullVisualizer.new(name, params)
-        attach_node(node, &block)
-      end
+      alias_method :Throughput, :throughput_controller
 
-      alias_method :view_results, :view_results_full_visualizer
+      alias_method :Switch, :switch_controller
 
-      def table_visualizer(name="View Results in Table", params={}, &block)
-        node = Gridinit::Jmeter::TableVisualizer.new(name, params)
-        attach_node(node, &block)
-      end
+      alias_method :While, :while_controller
 
-      def graph_visualizer(name="Graph Results", params={}, &block)
-        node = Gridinit::Jmeter::GraphVisualizer.new(name, params)
-        attach_node(node, &block)
-      end
+      alias_method :Interleave, :random_controller
 
-      def stat_visualizer(name="Stat Results", params={}, &block)
-        node = Gridinit::Jmeter::StatVisualizer.new(name, params)
-        attach_node(node, &block)
-      end
+      alias_method :Random_order, :random_order_controller
 
-      def simple_data_writer(name="Simple Data Writer", params={}, &block)
-        node = Gridinit::Jmeter::SimpleDataWriter.new(name, params)
-        attach_node(node, &block)
-      end
+      alias_method :Simple, :simple_controller
+
+      alias_method :Once, :once_only_controller
+
+      ##
+      # Listeners
+
+      alias_method :view_results, :view_results_tree
 
       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_node(node, &block)
+      alias_method :response_graph, :response_time_graph
+
+      ##
+      # Other Elements
+
+      def beanshell_preprocessor(params, &block)
+        params[:script] = "<![CDATA[#{params[:script]}]]>"
+        super
       end
 
-      alias_method :response_graph, :response_time_graph_visualizer
+      alias_method :bsh_pre, :beanshell_preprocessor
 
-      def summary_report(name="Summary Report", params={}, &block)
-        node = Gridinit::Jmeter::SummaryReport.new(name, params)
+      def extract(params, &block)
+        node = if params[:regex]
+          params[:refname] = params[:name]
+          params[:regex] = params[:regex] #CGI.escapeHTML 
+          params[:template] = params[:template] || "$1$"
+          Gridinit::Jmeter::RegularExpressionExtractor.new(params)
+        else
+          params[:refname] = params[:name]
+          params[:xpathQuery] = params[:xpath]
+          Gridinit::Jmeter::XpathExtractor.new(params)
+        end
         attach_node(node, &block)
       end
 
-      def aggregate_report(name="Aggregate Report", params={}, &block)
-        node = Gridinit::Jmeter::AggregateReport.new(name, params)
+      alias_method :web_reg_save_param, :extract
+
+      def random_timer(delay=0, range=0, &block)
+        params={}
+        params[:delay] = delay
+        params[:range] = range
+        node = Gridinit::Jmeter::GaussianRandomTimer.new(params)
         attach_node(node, &block)
       end
 
-      def ldap_ext(name="LDAPExtSampler", params={}, &block)
-        node = Gridinit::Jmeter::LDAPExtSampler.new(name, params)
+      alias_method :think_time, :random_timer
+
+      def response_assertion(params={}, &block)
+        params[:test_type] = parse_test_type(params)
+        params[:match] = params.values.first
+        node = Gridinit::Jmeter::ResponseAssertion.new(params)
+        node.doc.xpath("//stringProp[@name='Assertion.scope']").remove if
+          params[:scope] == 'main' || params['scope'] == 'main'
         attach_node(node, &block)
       end
 
-      def gc_response_codes_per_second(name="jp@gc - Response Codes per Second", params={}, &block)
+      alias_method :assert, :response_assertion
+
+      alias_method :web_reg_find, :response_assertion
+
+      ##
+      # JMeter Plugins
+
+      def response_codes_per_second(name="jp@gc - Response Codes per Second", params={}, &block)
         node = Gridinit::Jmeter::GCResponseCodesPerSecond.new(name, params)
         attach_node(node, &block)
       end
 
-      def gc_response_times_distribution(name="jp@gc - Response Times Distribution", params={}, &block)
+      def response_times_distribution(name="jp@gc - Response Times Distribution", params={}, &block)
         node = Gridinit::Jmeter::GCResponseTimesDistribution.new(name, params)
         attach_node(node, &block)
       end
 
-      def gc_response_times_over_time(name="jp@gc - Response Times Over Time", params={}, &block)
+      def response_times_over_time(name="jp@gc - Response Times Over Time", params={}, &block)
         node = Gridinit::Jmeter::GCResponseTimesOverTime.new(name, params)
         attach_node(node, &block)
       end
 
-      def gc_response_times_percentiles(name="jp@gc - Response Times Percentiles", params={}, &block)
+      def response_times_percentiles(name="jp@gc - Response Times Percentiles", params={}, &block)
         node = Gridinit::Jmeter::GCResponseTimesPercentiles.new(name, params)
         attach_node(node, &block)
       end
 
-      def gc_transactions_per_second(name="jp@gc - Transactions per Second", params={}, &block)
+      def transactions_per_second(name="jp@gc - Transactions per Second", params={}, &block)
         node = Gridinit::Jmeter::GCTransactionsPerSecond.new(name, params)
         attach_node(node, &block)
       end
 
-      def gc_latencies_over_time(name="jp@gc - Response Latencies Over Time", params={}, &block)
+      def latencies_over_time(name="jp@gc - Response Latencies Over Time", params={}, &block)
         node = Gridinit::Jmeter::GCLatenciesOverTime.new(name, params)
         attach_node(node, &block)
       end
 
-      def gc_console_status_logger(name="jp@gc - Console Status Logger", params={}, &block)
+      def console_status_logger(name="jp@gc - Console Status Logger", params={}, &block)
         node = Gridinit::Jmeter::GCConsoleStatusLogger.new(name, params)
         attach_node(node, &block)
       end
 
-      alias_method :console, :gc_console_status_logger
+      alias_method :console, :console_status_logger
 
       def throughput_shaper(name="jp@gc - Throughput Shaping Timer", steps=[], params={}, &block)
-        node = Gridinit::Jmeter::ThroughputShapingTimer.new(name, steps)
+        node = Gridinit::Jmeter::GCThroughputShapingTimer.new(name, steps)
         attach_node(node, &block)
       end
 
       alias_method :shaper, :throughput_shaper
 
+
+      # API Methods
+
       def out(params={})
         puts doc.to_xml(:indent => 2)
       end
@@ -425,5 +408,5 @@ module Gridinit
 end
 
 def test(&block)
-  Gridinit.dsl_eval(Gridinit::Jmeter::DSL.new, &block)
+  Gridinit.dsl_eval(Gridinit::Jmeter::ExtendedDSL.new, &block)
 end