gridinit-jmeter 0.0.1

data/examples/basic_testplan.rb

@@ -0,0 +1,44 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'gridinit-jmeter'
+
+base_url = 'http://localhost:4567'
+endpoint = 'localhost:3000'
+
+test do
+
+  cache clear_each_iteration: true
+  cookies
+  
+  threads 100 do
+
+    random_timer 3000, 3000
+  
+    transaction 'First Visit', {parent: true} do
+      visit 'Home Page', "#{base_url}/" do
+        extract 'csrf-token', "content='(.+?)' name='csrf-token'"
+      end
+    end
+
+    transaction 'Login' do
+      submit 'Submit Form', "#{base_url}/login", {
+        fill_in: {
+          username: 'tim',
+          password: 'password',
+          'csrf-token' => '${csrf-token}'
+        }
+      }
+      think_time 1000
+    end
+
+    transaction 'Check Mana' do
+      visit 'Rails Camp' , "#{base_url}/magic" do
+        assert "contains", "magic"
+        assert "not-contains", "unicorns"
+      end
+    end
+
+  end
+
+# end.jmx
+# end.run(path: '/usr/share/jmeter/bin/')
+end.grid '4dy-zJLEIgpYkKe6p6JhSQ', { endpoint: endpoint }

data/examples/basic_think_time.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'gridinit-jmeter'
+
+test do
+  threads 100 do
+    think_time 5000,5000
+    transaction 'Google Search' do
+      visit 'Home Page', 'http://google.com/'
+      random_timer 3000
+    end
+  end
+end.jmx

data/gridinit-jmeter.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'gridinit-jmeter/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "gridinit-jmeter"
+  gem.version       = Gridinit::Jmeter::VERSION
+  gem.authors       = ["Tim Koopmans"]
+  gem.email         = ["support@gridinit.com"]
+  gem.description   = %q{This is a Ruby based DSL for writing JMeter test plans}
+  gem.summary       = %q{This is a Ruby based DSL for writing JMeter test plans}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/lib/gridinit-jmeter/auth_manager.rb

@@ -0,0 +1,28 @@
+module Gridinit
+  module Jmeter
+
+    class AuthManager
+      attr_accessor :doc
+      def initialize(params={})
+        @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
+          <AuthManager guiclass="AuthPanel" testclass="AuthManager" testname="HTTP Authorization Manager" enabled="true">
+            <collectionProp name="AuthManager.auth_list">
+              <elementProp name="" elementType="Authorization">
+                <stringProp name="Authorization.url">/</stringProp>
+                <stringProp name="Authorization.username"></stringProp>
+                <stringProp name="Authorization.password"></stringProp>
+                <stringProp name="Authorization.domain"></stringProp>
+                <stringProp name="Authorization.realm"></stringProp>
+              </elementProp>
+            </collectionProp>
+          </AuthManager>
+        EOF
+        params.each do |name, value|
+          node = @doc.children.xpath("//*[contains(@name,\"#{name.to_s}\")]")
+          node.first.content = value unless node.empty? 
+        end
+      end
+    end  
+
+  end
+end

data/lib/gridinit-jmeter/cache_manager.rb

@@ -0,0 +1,22 @@
+module Gridinit
+  module Jmeter
+
+    class CacheManager
+      attr_accessor :doc
+      def initialize(params={})
+        @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
+          <CacheManager guiclass="CacheManagerGui" testclass="CacheManager" testname="HTTP Cache Manager" enabled="true">
+            <boolProp name="clearEachIteration">#{params[:clear_each_iteration] ? 'true' : 'false'}</boolProp>
+            <boolProp name="useExpires">#{params[:use_expires] ? 'true' : 'false'}</boolProp>
+          </CacheManager>
+        EOF
+        params.delete :clear_each_iteration
+        params.each do |name, value|
+          node = @doc.children.xpath("//*[contains(@name,\"#{name.to_s}\")]")
+          node.first.content = value unless node.empty? 
+        end
+      end
+    end  
+
+  end
+end

data/lib/gridinit-jmeter/cookie_manager.rb

@@ -0,0 +1,23 @@
+module Gridinit
+  module Jmeter
+
+    class CookieManager
+      attr_accessor :doc
+      def initialize(params={})
+        @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
+          <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
+            <collectionProp name="CookieManager.cookies"/>
+            <boolProp name="CookieManager.clearEachIteration">#{params[:clear_each_iteration] ? 'true' : 'false'}</boolProp>
+            <stringProp name="CookieManager.policy">default</stringProp>
+          </CookieManager>
+        EOF
+        params.delete :clear_each_iteration
+        params.each do |name, value|
+          node = @doc.children.xpath("//*[contains(@name,\"#{name.to_s}\")]")
+          node.first.content = value unless node.empty? 
+        end
+      end
+    end  
+
+  end
+end

data/lib/gridinit-jmeter/dsl.rb

@@ -0,0 +1,177 @@
+module Gridinit
+  module Jmeter
+
+    class DSL
+      attr_accessor :root
+
+      def initialize
+        @root = Nokogiri::XML(<<-EOF.strip_heredoc)
+          <?xml version="1.0" encoding="UTF-8"?>
+          <jmeterTestPlan version="1.2" properties="2.1">
+          <hashTree>
+          </hashTree>
+          </jmeterTestPlan>
+        EOF
+        node = Gridinit::Jmeter::TestPlan.new
+        @root.at_xpath("//jmeterTestPlan/hashTree") << node.doc.children << hash_tree
+        
+        variables(
+          name: 'testguid', 
+          value: '${__P(testguid,${__time(,)})}',
+          comments: 'The testguid variable is mandatory when running on the Grid.') {} 
+      end
+
+      def variables(params={}, &block)
+        node = Gridinit::Jmeter::UserDefinedVariable.new(params)
+        @root.at_xpath(xpath_from(caller)) << node.doc.children << hash_tree
+        self.instance_exec(&block) if block
+      end
+
+      def cookies(params={}, &block)
+        node = Gridinit::Jmeter::CookieManager.new(params)
+        @root.at_xpath(xpath_from(caller)) << node.doc.children << hash_tree
+        self.instance_exec(&block) if block
+      end
+
+      def cache(params={}, &block)
+        node = Gridinit::Jmeter::CacheManager.new(params)
+        @root.at_xpath(xpath_from(caller)) << node.doc.children << hash_tree
+        self.instance_exec(&block) if block
+      end
+
+      def auth(params={}, &block)
+        node = Gridinit::Jmeter::AuthManager.new(params)
+        @root.at_xpath(xpath_from(caller)) << node.doc.children << hash_tree
+        self.instance_exec(&block) if block
+      end
+
+      def threads(num_threads=1, params={}, &block)
+        node = Gridinit::Jmeter::ThreadGroup.new(num_threads, params)
+        @root.at_xpath(xpath_from(caller)) << node.doc.children << hash_tree
+        self.instance_exec(&block) if block
+      end
+
+      def transaction(name="Transaction Contoller", params={}, &block)
+        node = Gridinit::Jmeter::Transaction.new(name, params)
+        @root.at_xpath(xpath_from(caller)) << node.doc.children << hash_tree
+        self.instance_exec(&block) if block
+      end
+
+      def visit(name="HTTP Request", url="", params={}, &block)
+        params[:method] = 'GET'
+        node = Gridinit::Jmeter::HttpSampler.new(name, url, params)
+        @root.at_xpath(xpath_from(caller)) << node.doc.children << hash_tree
+        self.instance_exec(&block) if block
+      end
+
+      def submit(name="HTTP Request", url="", params={}, &block)
+        params[:method] = 'POST'
+        node = Gridinit::Jmeter::HttpSampler.new(name, url, params)
+        @root.at_xpath(xpath_from(caller)) << node.doc.children << hash_tree
+        self.instance_exec(&block) if block
+      end
+
+      alias_method :post, :submit
+
+      def extract(name="", regex="", params={}, &block)
+        node = Gridinit::Jmeter::RegexExtractor.new(name, regex, params)
+        @root.at_xpath(xpath_from(caller)) << node.doc.children << hash_tree
+        self.instance_exec(&block) if block
+      end
+
+      alias_method :web_reg_save_param, :extract
+
+      def random_timer(delay=0, range=0, &block)
+        node = Gridinit::Jmeter::GaussianRandomTimer.new(delay, range)
+        @root.at_xpath(xpath_from(caller)) << node.doc.children << hash_tree
+        self.instance_exec(&block) if block
+      end
+
+      alias_method :think_time, :random_timer
+
+      def assert(match="contains", pattern="", params={}, &block)
+        node = Gridinit::Jmeter::ResponseAssertion.new(match, pattern, params)
+        @root.at_xpath(xpath_from(caller)) << node.doc.children << hash_tree
+        self.instance_exec(&block) if block
+      end
+
+      alias_method :web_reg_find, :assert
+
+      def jmx(params={})
+        file(params)
+        puts doc.to_xml(:indent => 2)
+        logger.info "JMX saved to: #{params[:file]}"
+      end
+
+      def run(params={})
+        file(params)
+        logger.warn "Test executing locally ..."
+        cmd = "#{params[:path]}jmeter -n -t #{params[:file]} -j #{params[:log] ? params[:log] : 'jmeter.log' } -l #{params[:jtl] ? params[:jtl] : 'jmeter.jtl' }"
+        logger.info cmd
+        `#{cmd}`
+        logger.info "Results at: #{params[:jtl] ? params[:jtl] : 'jmeter.jtl'}"
+      end
+
+      def grid(token, params={})
+        file(params)
+        begin
+          response = RestClient.post "http://#{params[:endpoint] ? params[:endpoint] : 'gridinit.com'}/api?token=#{token}", {
+            :name => 'attachment', 
+            :attachment => File.new("#{params[:file]}", 'rb'),
+            :multipart => true,
+            :content_type => 'application/octet-stream'
+          }
+          logger.info "Results at: #{JSON.parse(response)["results"]}" if response.code == 200
+        rescue => e
+          logger.fatal "There was an error: #{e.message}"
+        end
+      end
+      
+      private
+
+      def hash_tree
+        Nokogiri::XML::Node.new("hashTree", @root)
+      end
+
+      def xpath_from(calling_method)
+        case calling_method.grep(/dsl/)[1][/`.*'/][1..-2]
+        when 'threads'
+          '//ThreadGroup[last()]/following-sibling::hashTree'
+        when 'transaction'
+          '//TransactionController[last()]/following-sibling::hashTree'
+        when 'visit'
+          '//HTTPSamplerProxy[last()]/following-sibling::hashTree'
+        when 'submit'
+          '//HTTPSamplerProxy[last()]/following-sibling::hashTree'
+        when 'extract'
+          '//RegexExtractor[last()]/following-sibling::hashTree'
+        when 'random_timer'
+          '//GaussianRandomTimer[last()]/following-sibling::hashTree'
+        else 
+          '//TestPlan/following-sibling::hashTree'
+        end
+      end
+
+      def file(params={})
+        params[:file] ||= 'jmeter.jmx'
+        File.open(params[:file], 'w') { |file| file.write(doc.to_xml(:indent => 2)) }
+      end
+
+      def doc
+        Nokogiri::XML(@root.to_s,&:noblanks)
+      end
+
+      def logger
+        @log ||= Logger.new(STDOUT)
+        @log.level = Logger::DEBUG
+        @log
+      end
+
+    end
+
+  end
+end
+
+def test(&block)
+  Docile.dsl_eval(Gridinit::Jmeter::DSL.new, &block)
+end

data/lib/gridinit-jmeter/gaussian_random_timer.rb

@@ -0,0 +1,17 @@
+module Gridinit
+  module Jmeter
+
+    class GaussianRandomTimer
+      attr_accessor :doc
+      def initialize(delay, range)
+        @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
+          <GaussianRandomTimer guiclass="GaussianRandomTimerGui" testclass="GaussianRandomTimer" testname="Think Time" enabled="true">
+            <stringProp name="ConstantTimer.delay">#{delay}</stringProp>
+            <stringProp name="RandomTimer.range">#{range}</stringProp>
+          </GaussianRandomTimer>
+        EOF
+      end
+    end 
+
+  end
+end

data/lib/gridinit-jmeter/http_sampler.rb

@@ -0,0 +1,68 @@
+module Gridinit
+  module Jmeter
+
+    class HttpSampler
+      attr_accessor :doc
+      def initialize(name, url, params={})
+        @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
+          <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="#{name}" enabled="true">
+            <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" testname="User Defined Variables" enabled="true">
+              <collectionProp name="Arguments.arguments"/>
+            </elementProp>
+            <stringProp name="HTTPSampler.domain"></stringProp>
+            <stringProp name="HTTPSampler.port"></stringProp>
+            <stringProp name="HTTPSampler.connect_timeout"></stringProp>
+            <stringProp name="HTTPSampler.response_timeout"></stringProp>
+            <stringProp name="HTTPSampler.protocol"></stringProp>
+            <stringProp name="HTTPSampler.contentEncoding"></stringProp>
+            <stringProp name="HTTPSampler.path">/</stringProp>
+            <stringProp name="HTTPSampler.method">GET</stringProp>
+            <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+            <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+            <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+            <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+            <boolProp name="HTTPSampler.monitor">false</boolProp>
+            <boolProp name="HTTPSampler.image_parser">true</boolProp>
+            <boolProp name="HTTPSampler.concurrentDwn">true</boolProp>
+            <stringProp name="HTTPSampler.embedded_url_re"></stringProp>
+          </HTTPSamplerProxy>
+        EOF
+        parse_url(url, params) unless url.empty?
+        fill_in(params) if params[:fill_in]
+        params.each do |name, value|
+          node = @doc.children.xpath("//*[contains(@name,\"#{name.to_s}\")]")
+          node.first.content = value unless node.empty? 
+        end
+      end
+
+      def parse_uri(url)
+        URI.parse(url).scheme.nil? ? URI.parse("http://#{url}") : URI.parse(url)   
+      end
+
+      def parse_url(url, params)
+        uri             = parse_uri(url)
+        params[:domain] = uri.host
+        params[:port]   = uri.port
+        params[:path]   = uri.path
+      end
+
+      def fill_in(params)
+        params[:fill_in].each do |name, value|
+          @doc.at_xpath('//collectionProp') << 
+            Nokogiri::XML(<<-EOF.strip_heredoc).children
+              <elementProp name="username" elementType="HTTPArgument">
+                <boolProp name="HTTPArgument.always_encode">false</boolProp>
+                <stringProp name="Argument.value">#{value}</stringProp>
+                <stringProp name="Argument.metadata">=</stringProp>
+                <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                <stringProp name="Argument.name">#{name}</stringProp>
+              </elementProp>
+              EOF
+        end
+        params.delete :fill_in
+      end
+
+    end  
+
+  end
+end

data/lib/gridinit-jmeter/regex_extractor.rb

@@ -0,0 +1,25 @@
+module Gridinit
+  module Jmeter
+
+    class RegexExtractor
+      attr_accessor :doc
+      def initialize(name, regex, params={})
+        @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
+          <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Regular Expression Extractor" enabled="true">
+            <stringProp name="RegexExtractor.useHeaders">false</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.match_number">0</stringProp>
+          </RegexExtractor>
+        EOF
+        params.each do |name, value|
+          node = @doc.children.xpath("//*[contains(@name,\"#{name.to_s}\")]")
+          node.first.content = value unless node.empty? 
+        end
+      end
+    end  
+
+  end
+end

data/lib/gridinit-jmeter/response_assertion.rb

@@ -0,0 +1,58 @@
+module Gridinit
+  module Jmeter
+
+    class ResponseAssertion
+      attr_accessor :doc
+      def initialize(match, pattern, params={})
+        @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
+          <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+            <collectionProp name="Asserion.test_strings">
+              <stringProp name="#{Time.now.to_i}">#{pattern}</stringProp>
+            </collectionProp>
+            <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+            <boolProp name="Assertion.assume_success">false</boolProp>
+            <intProp name="Assertion.test_type">#{test_type(match)}</intProp>
+          </ResponseAssertion>
+        EOF
+        if params[:scope]
+          @doc.at_xpath('//ResponseAssertion') << 
+            Nokogiri::XML(<<-EOF.strip_heredoc).children
+              <stringProp name="Assertion.scope">#{params[:scope]}</stringProp>
+              EOF
+          params.delete [:scope]
+        end
+        params.each do |name, value|
+          node = @doc.children.xpath("//*[contains(@name,\"#{name.to_s}\")]")
+          node.first.content = value unless node.empty? 
+        end
+      end
+
+      private
+
+      def test_type(match)
+        case match
+        when 'contains'
+          2
+        when 'not-contains'
+          6
+        when 'matches'
+          1
+        when 'not-matches'
+          5
+        when 'equals'
+          8
+        when 'not-equals'
+          12
+        when 'substring'
+          16
+        when 'not-substring'
+          20
+        else
+          2
+        end
+      end
+
+    end  
+
+  end
+end

data/lib/gridinit-jmeter/test_plan.rb

@@ -0,0 +1,22 @@
+module Gridinit
+  module Jmeter
+
+    class TestPlan
+      attr_accessor :doc
+      def initialize
+        @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
+          <TestPlan guiclass="TestPlanGui" testclass="TestPlan" testname="Test Plan" enabled="true">
+            <stringProp name="TestPlan.comments"></stringProp>
+            <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="User Defined Variables" enabled="true">
+              <collectionProp name="Arguments.arguments"/>
+            </elementProp>
+            <stringProp name="TestPlan.user_define_classpath"></stringProp>
+          </TestPlan>
+        EOF
+      end
+    end 
+
+  end
+end

data/lib/gridinit-jmeter/thread_group.rb

@@ -0,0 +1,31 @@
+module Gridinit
+  module Jmeter
+
+    class ThreadGroup
+      attr_accessor :doc
+      def initialize(num_threads, params={})
+        @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
+          <ThreadGroup guiclass="ThreadGroupGui" testclass="ThreadGroup" testname="Thread Group" enabled="true">
+            <stringProp name="ThreadGroup.on_sample_error">continue</stringProp>
+            <elementProp name="ThreadGroup.main_controller" elementType="LoopController" guiclass="LoopControlPanel" testclass="LoopController" testname="Loop Controller" enabled="true">
+              <boolProp name="LoopController.continue_forever">false</boolProp>
+              <stringProp name="LoopController.loops">1</stringProp>
+            </elementProp>
+            <stringProp name="ThreadGroup.num_threads">#{num_threads}</stringProp>
+            <stringProp name="ThreadGroup.ramp_time">1</stringProp>
+            <longProp name="ThreadGroup.start_time">1352677419000</longProp>
+            <longProp name="ThreadGroup.end_time">1352677419000</longProp>
+            <boolProp name="ThreadGroup.scheduler">false</boolProp>
+            <stringProp name="ThreadGroup.duration"></stringProp>
+            <stringProp name="ThreadGroup.delay"></stringProp>
+          </ThreadGroup>
+        EOF
+        params.each do |name, value|
+          node = @doc.children.xpath("//*[contains(@name,\"#{name.to_s}\")]")
+          node.first.content = value unless node.empty? 
+        end
+      end
+    end  
+
+  end
+end

data/lib/gridinit-jmeter/transaction.rb

@@ -0,0 +1,20 @@
+module Gridinit
+  module Jmeter
+
+    class Transaction
+      attr_accessor :doc
+      def initialize(name, params={})
+        @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
+          <TransactionController guiclass="TransactionControllerGui" testclass="TransactionController" testname="#{name}" enabled="true">
+            <boolProp name="TransactionController.parent">false</boolProp>
+          </TransactionController>
+        EOF
+        params.each do |name, value|
+          node = @doc.children.xpath("//*[contains(@name,\"#{name.to_s}\")]")
+          node.first.content = value unless node.empty? 
+        end
+      end
+    end  
+
+  end
+end

data/lib/gridinit-jmeter/user_defined_variable.rb

@@ -0,0 +1,27 @@
+module Gridinit
+  module Jmeter
+
+    class UserDefinedVariable
+      attr_accessor :doc
+      def initialize(params={})
+        @doc = Nokogiri::XML(<<-EOF.strip_heredoc)
+          <Arguments guiclass="ArgumentsPanel" testclass="Arguments" testname="User Defined Variables" enabled="true">
+            <collectionProp name="Arguments.arguments">
+              <elementProp name="testguid" elementType="Argument">
+                <stringProp name="Argument.name"></stringProp>
+                <stringProp name="Argument.value"></stringProp>
+                <stringProp name="Argument.metadata">=</stringProp>
+              </elementProp>
+            </collectionProp>
+            <stringProp name="TestPlan.comments"></stringProp>
+          </Arguments>
+        EOF
+        params.each do |name, value|
+          node = @doc.children.xpath("//*[contains(@name,\"#{name.to_s}\")]")
+          node.first.content = value unless node.empty? 
+        end
+      end
+    end 
+
+  end
+end

data/lib/gridinit-jmeter/version.rb

@@ -0,0 +1,5 @@
+module Gridinit
+  module Jmeter
+    VERSION = "0.0.1"
+  end
+end

data/lib/gridinit-jmeter.rb

@@ -0,0 +1,20 @@
+require 'nokogiri'
+require 'docile'
+require 'active_support/core_ext'
+require 'logger/colors'
+require 'rest_client'
+require 'cgi'
+
+require 'gridinit-jmeter/dsl'
+require 'gridinit-jmeter/version'
+require 'gridinit-jmeter/test_plan'
+require 'gridinit-jmeter/auth_manager'
+require 'gridinit-jmeter/cookie_manager'
+require 'gridinit-jmeter/cache_manager'
+require 'gridinit-jmeter/thread_group'
+require 'gridinit-jmeter/transaction'
+require 'gridinit-jmeter/http_sampler'
+require 'gridinit-jmeter/regex_extractor'
+require 'gridinit-jmeter/user_defined_variable'
+require 'gridinit-jmeter/gaussian_random_timer'
+require 'gridinit-jmeter/response_assertion'

data/spec/dsl_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+
+describe "DSL" do
+
+  it "test plan should respond to thread groups" do
+    test {}.should respond_to :threads
+  end
+
+  it "test plan should respond to transactions" do
+    test {}.should respond_to :transaction
+  end
+
+  it "test plan should respond to visit" do
+    test {}.should respond_to :visit
+  end
+
+  it "test plan should respond to submit" do
+    test {}.should respond_to :submit
+  end
+
+  it "should output a test plan to stdout" do
+    $stdout.should_receive(:puts).with(/jmeterTestPlan/i)
+    test do
+    end.jmx
+  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(:write).with(/jmeterTestPlan/i)
+    test do
+    end.jmx
+  end
+
+end