apirunner 0.3.5 → 0.3.6

data/VERSION

@@ -1 +1 @@
-0.3.5
+0.3.6

data/apirunner.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{apirunner}
-  s.version = "0.3.5"
+  s.version = "0.3.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["jan@moviepilot.com"]
-  s.date = %q{2010-10-07}
+  s.date = %q{2010-10-12}
   s.description = %q{apirunner is a testsuite to query your RESTful JSON API and match response with your defined expectations}
   s.email = %q{developers@moviepilot.com}
   s.extra_rdoc_files = [
@@ -45,7 +45,6 @@ Gem::Specification.new do |s|
     "lib/apirunner.rb",
     "lib/apirunner/railtie.rb",
     "lib/checker.rb",
-    "lib/core_extensions.rb",
     "lib/expectation_matcher.rb",
     "lib/http_client.rb",
     "lib/plugins/plug01_response_json_syntax_checker.rb",
@@ -53,12 +52,16 @@ Gem::Specification.new do |s|
     "lib/plugins/plug03_response_header_checker.rb",
     "lib/plugins/plug04_response_body_checker.rb",
     "lib/result.rb",
+    "lib/string_ext.rb",
     "lib/tasks/api.rake",
     "lib/testcase.rb",
     "spec/.rspec",
+    "spec/api_configuration_spec.rb",
     "spec/api_runner_spec.rb",
+    "spec/checker_spec.rb",
     "spec/expectation_matcher_spec.rb",
     "spec/http_client_spec.rb",
+    "spec/result_spec.rb",
     "spec/spec_helper.rb"
   ]
   s.homepage = %q{http://github.com/moviepilot/apirunner}
@@ -66,9 +69,12 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.7}
   s.summary = %q{one-line summary of your gem}
   s.test_files = [
+    "spec/api_configuration_spec.rb",
     "spec/api_runner_spec.rb",
+    "spec/checker_spec.rb",
     "spec/expectation_matcher_spec.rb",
     "spec/http_client_spec.rb",
+    "spec/result_spec.rb",
     "spec/spec_helper.rb"
   ]
 

data/lib/api_runner.rb

@@ -1,22 +1,25 @@
 class ApiRunner
   require 'yaml'
+  require 'string_ext' if not String.respond_to?(:underscore)
   require 'expectation_matcher'
   require 'http_client'
   require 'api_configuration'
   require 'testcase'
-  require 'core_extensions'
-  include CoreExtensions
+  require 'string_ext'
+
+  require 'JSON'
 
   CONFIG_FILE = "config/api_runner.yml"
   SPEC_PATH = "test/api_runner/"
   EXCLUDES_FILE = "test/api_runner/excludes.yml"
 
   # initializes the object, loads environment, build base_uri
-  def initialize(env)
+  def initialize(env, performance=nil)
     @spec = []
     @results = []
     @excludes = []
     @configuration = ApiConfiguration.new(YAML.load_file(self.class.config_file), env)
+    @configuration.verbosity = "performance" if performance
     load_excludes(env)
     load_url_spec
     @http_client = HttpClient.new(@configuration.protocol, @configuration.host, @configuration.port, @configuration.namespace)
@@ -148,4 +151,3 @@ class ApiRunner
     EXCLUDES_FILE
   end
 end
-

data/lib/apirunner.rb

@@ -1,5 +1,6 @@
 APIRUNNER_ROOT=File.dirname(__FILE__) + "/.."
 require 'api_runner'
+require 'string_ext'
 module Apirunner
   require 'apirunner/railtie' if defined?(Rails)
 end

data/lib/checker.rb

@@ -1,5 +1,4 @@
 class Checker
-
   @@children = []
 
   def initialize(testcase, response, excludes=nil)
@@ -27,26 +26,6 @@ class Checker
     @@children << child
   end
 
-  # recursively parses the tree and returns a set of relative pathes
-  # that can be used to match the both trees leafs
-  def matcher_pathes_from(node, pathes = nil)
-    pathes ||= []
-    if not node.children.blank?
-      node.children.each do |sub_node|
-        matcher_pathes_from(sub_node, pathes)
-      end
-    else
-      pathes << relative_path(node.parent.path)
-    end
-    pathes
-  end
-
-  # returns relative path for matching the target tree of the response body
-  # explicit array adressing is replaced by *
-  def relative_path(path)
-    path.gsub(/\/([^\/]+)\[\d+\]\//i,"/*/")
-  end
-
   # returns true if given attributes is an excluded item that does not have to be evaluated in this environment
   def excluded?(item)
     @excludes.include?(item)
@@ -71,7 +50,7 @@ class Checker
   # parses output into JSON object
   def valid_json?(response_body)
     # responses may be nil, return true then
-    return true if response_body.blank?
+    return true if response_body.nil? or response_body == {} or response_body == "" or response_body == " "
     # returns true if given response is valid json, else false
     JSON.parse(response_body.to_s) rescue false
   end

data/lib/http_client.rb

@@ -1,5 +1,7 @@
 class HttpClient
   require 'net/http'
+  require "cgi"
+  require "benchmark"
 
   def initialize(protocol, host, port, namespace)
     @http = Net::HTTP.new(host, port)
@@ -10,53 +12,56 @@ class HttpClient
   end
 
   def send_request(method, resource, headers=nil, data=nil, params=nil)
-    build_response(self.send(method.to_s.downcase, headers, resource, data, params))
+    runtime, response = self.send(method.to_s.downcase, headers, resource, data, params)
+    build_response(response, runtime, method, resource, params)
   end
 
   protected
 
   # returns struct containing response.code, headers, body and message
   # this is only for easily interfaceing another http client
-  def build_response(raw_response)
-    response_struct = Struct.new(:code, :message, :headers, :body)
+  def build_response(raw_response, runtime, method, resource, params)
+    end_time = Time.now.usec
+    response_struct = Struct.new(:code, :message, :headers, :body, :runtime, :fully_qualified_path)
     response = response_struct.new
     response.code = raw_response.code
     response.message = raw_response.message
     response.body = raw_response.body
-    response.headers = JSON.parse(raw_response.header.to_json) rescue nil
+    response.headers = JSON.parse(raw_response.headers.to_json) rescue ""
+    response.runtime = runtime
+    response.fully_qualified_path = (method == "GET" ? build_uri(resource, params).request_uri : resource_path(resource))
     response
   end
 
   # sends GET request and returns response
   def get(headers, resource, data, params)
     request = Net::HTTP::Get.new(build_uri(resource, params).request_uri, initheader = headers)
-    @http.request(request)
+    return Benchmark.realtime{ @response = @http.request(request) }, @response
   end
 
   # sends PUT request and returns response
   def put(headers, resource, data, params)
     request = Net::HTTP::Put.new(resource_path(resource), initheader = headers)
     request.body = data.to_json
-    @http.request(request)
+    return Benchmark.realtime { @response = @http.request(request) }, @response
   end
 
   # sends POST request and returns response
   def post(headers, resource, data, params)
     request = Net::HTTP::Post.new(resource_path(resource), initheader = headers)
     request.body = data.to_json
-    @http.request(request)
+    return Benchmark.realtime{ @response = @http.request(request) }, @response
   end
 
   # sends DELETE request and returns response
   def delete(headers, resource, data, params)
     request = Net::HTTP::Delete.new(resource_path(resource), initheader = headers)
-    @http.request(request)
+    return Benchmark.realtime{ @response = @http.request(request) }, @response
   end
 
   # redefines the resource path including the namespace
   def resource_path(resource)
     @namespace.nil? ? resource : "/" + @namespace + resource
-    "/" + @namespace + resource
   end
 
   # rebuild a uri in details, so that another protocol, host, port and GET params can be specified, after Net::HTTP was created

data/lib/plugins/plug01_response_json_syntax_checker.rb

@@ -5,7 +5,7 @@ class ResponseJsonSyntaxChecker < Checker
     result = Result.new(@testcase, @response)
     if not valid_json?(@response.body)
       result.succeeded = false
-      result.error_message = "expected valid JSON in body\n got --#{@response.body[1..400]}--"
+      result.error_message = "expected valid JSON in body\n got --#{@response.body[1..400]}-- #{@response.body.class}"
     end
     result
   end

data/lib/plugins/plug02_response_code_checker.rb

@@ -8,10 +8,11 @@ class ResponseCodeChecker < Checker
         result.succeeded = false
         result.error_message = " expected response code --#{@testcase.response_expectation['status_code']}--\n got response code --#{@response.code}--"
       end
-    rescue
-      result.succeeded = false
-      result.error_message = " unexpected error while parsing testcase/response. Check your testcase format!"
-    end
+     rescue Exception => e
+       result.succeeded = false
+       result.error_message = " unexpected error while parsing testcase/response. Check your testcase format!"
+       result.error_message = "\n\n Exception occured: #{e}"
+     end
     result
   end
 

data/lib/plugins/plug03_response_header_checker.rb

@@ -17,10 +17,11 @@ class ResponseHeaderChecker < Checker
           end
         end
       end unless (@testcase.response_expectation['headers'].nil? or @testcase.response_expectation['headers'].empty?)
-    rescue
-      result.succeeded = false
-      result.error_message = " unexpected error while parsing testcase/response. Check your testcase format!"
-    end
+     rescue Exception => e
+       result.succeeded = false
+       result.error_message = " unexpected error while parsing testcase/response. Check your testcase format!"
+       result.error_message = "\n\nException occured: #{e}"
+     end
     result
   end
 

data/lib/plugins/plug04_response_body_checker.rb

@@ -66,4 +66,26 @@ class ResponseBodyChecker < Checker
     end
     result
   end
+
+  private
+
+  # recursively parses the tree and returns a set of relative pathes
+  # that can be used to match the both trees leafs
+  def matcher_pathes_from(node, pathes = nil)
+    pathes ||= []
+    if not node.children.blank?
+      node.children.each do |sub_node|
+        matcher_pathes_from(sub_node, pathes)
+      end
+    else
+      pathes << relative_path(node.parent.path)
+    end
+    pathes
+  end
+
+  # returns relative path for matching the target tree of the response body
+  # explicit array adressing is replaced by *
+  def relative_path(path)
+    path.gsub(/\/([^\/]+)\[\d+\]\//i,"/*/")
+  end
 end

data/lib/result.rb

@@ -42,13 +42,14 @@ class Result
   # yields a more verbose message in any case and includes a curl command to manually simulate the testcase
   def verbose_with_curl(index)
     be_verbose(index)
-    puts "\n  simulate this call with: \"curl TODO\""
+    puts("\n  simulate this call with: \"curl TODO\"")
   end
 
   # yields the verbose error messages
   def be_verbose(index)
     puts "\n#{result_case} (#{index+1})- \"#{@testcase.name}\""
     puts @error_message
+    puts("Request runtime: #{@response.runtime}")
     puts("  More more more verbosity\n")
     puts("  request method: #{@testcase.request['method']}")
     puts("  resource path: #{@testcase.request['path']}")
@@ -64,6 +65,12 @@ class Result
     puts("    response body: #{JSON.parse(@response.body) rescue nil}")
   end
 
+  #  yields out only performance information
+  def performance(index)
+    puts "\n#{@testcase.name}\n"
+    puts "  %-10s %-20s %-8s %s " % ["#{@response.runtime.to_s[0..6]}s", "[#{result_case}]", @testcase.request['method'], @response.fully_qualified_path]
+  end
+
   # returns the result case for interpolation in the output message header
   def result_case
     if @succeeded
@@ -85,8 +92,8 @@ class Result
 
   def ansi_colors(color)
     case color
-    when 'green' then ['\033[32m', '\033[0m']
-    when 'red'   then ['\033[31m', '\033[0m']
+    when :green then ["\033[32m", "\033[0m"]
+    when :red   then ["\033[31m", "\033[0m"]
     else ['','']
     end
   end

data/lib/string_ext.rb

@@ -0,0 +1,23 @@
+class String
+  # generates filenames from classnames the rails way
+  def underscore
+    self.to_s.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
+  end
+
+  # opposites underscore defined above
+  def camelize(first_letter_in_uppercase = true)
+    if first_letter_in_uppercase
+      self.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+    else
+      self.first + camelize(lower_case_and_underscored_word)[1..-1]
+    end
+  end
+  # # opposites underscore defined above
+  # def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+  #   if first_letter_in_uppercase
+  #     lower_case_and_underscored_word.to_s.gsub(/\\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+  #   else
+  #     lower_case_and_underscored_word.first + camelize(lower_case_and_underscored_word)[1..-1]
+  #   end
+  # end
+end

data/lib/tasks/api.rake

@@ -4,7 +4,7 @@ rescue
 end
 namespace :api do
   namespace :run do
-    config.each_key do |env|
+    config.delete_if{ |key| key == "general" }.each_key do |env|
       desc "runs a series of nessecary api calls and parses their response in environment #{env}"
       task env.to_sym => :environment do
         puts "Running API tests in environment #{env}"
@@ -14,6 +14,17 @@ namespace :api do
       end
     end unless config.nil?
   end
+  namespace:performance do
+    config.delete_if{ |key| key == "general" }.each_key do |env|
+      desc "runs a series of nessecary api calls for performance measuring and parses their response in environment #{env}"
+      task env.to_sym => :environment do
+        puts "Running API performance tests in environment #{env}"
+        api_runner = ApiRunner.new(env, performance=true)
+        api_runner.run
+        puts "\nPerformance testrun finished\n\n"
+      end
+    end unless config.nil?
+  end
   desc "generates configuration and a skeleton for apirunner tests as well as excludes"
   task :scaffold do
     TEST_EXAMPLES_PATH="test/api_runner"

data/spec/api_configuration_spec.rb

@@ -0,0 +1,40 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'initialize' do
+  before(:each) do
+    @config_hash = {
+      "test" => {
+        :a => 1,
+        :b => 2,
+        :protocol => "http",
+        :host => "localhost",
+        :port => 3000,
+        :namespace => "namespace"
+      },
+      "general" => {
+        "verbosity" => ["verbose", "unused"],
+        "priority" => 10
+      }
+    }
+  end
+
+  it 'should set instance variables for each config key value pair' do
+    @a = ApiConfiguration.new(@config_hash, "test")
+    @a.instance_variable_get(:@a).should == 1
+    @a.instance_variable_get(:@b).should == 2
+    @a.instance_variable_get(:@protocol).should == "http"
+    @a.instance_variable_get(:@host).should == "localhost"
+    @a.instance_variable_get(:@port).should == 3000
+    @a.instance_variable_get(:@namespace).should == "namespace"
+  end
+
+  it 'should set verbosity correctly' do
+    @a = ApiConfiguration.new(@config_hash, "test")
+    @a.instance_variable_get(:@verbosity).should == "verbose"
+  end
+
+  it 'should set priority correctly' do
+    @a = ApiConfiguration.new(@config_hash, "test")
+    @a.instance_variable_get(:@priority).should == 10
+  end
+end

data/spec/api_runner_spec.rb

@@ -8,11 +8,20 @@ describe 'apirunner' do
     @a = ApiRunner.new(:local)
   end
   describe 'initialize' do
-    it 'should fill all instance variables' do
-      @a.instance_variable_get(:@protocol).should eql "http"
-      @a.instance_variable_get(:@host).should eql "localhost"
-      @a.instance_variable_get(:@port).should eql 3000
-      @a.instance_variable_get(:@namespace).should eql "api1v0"
+    it 'should fill all instance variables properly' do
+      @a.instance_variable_get(:@spec).should be_a(Array)
+      @a.instance_variable_get(:@spec).size.should == 58
+      @a.instance_variable_get(:@results).should be_a(Array)
+      @a.instance_variable_get(:@results).size.should == 0
+      @a.instance_variable_get(:@configuration).should be_a(ApiConfiguration)
+      @a.instance_variable_get(:@configuration).host.should == "localhost"
+      @a.instance_variable_get(:@configuration).port.should == 3000
+      @a.instance_variable_get(:@configuration).protocol.should == "http"
+      @a.instance_variable_get(:@configuration).namespace.should == "api1v0"
+      @a.instance_variable_get(:@configuration).verbosity.should == "verbose_on_error"
+      @a.instance_variable_get(:@configuration).priority.should == 0
+      @a.instance_variable_get(:@http_client).should be_a(HttpClient)
+      @a.instance_variable_get(:@expectation).should be_a(ExpectationMatcher)
     end
     it 'should fill @excludes' do
       @a.instance_variable_get(:@excludes).should_not be_nil
@@ -24,36 +33,41 @@ describe 'apirunner' do
       @a.instance_variable_get(:@spec).should be_a(Array)
       @a.instance_variable_get(:@spec).size.should >= 1
     end
-    it 'should instantiate an http client into @http_client' do
-      @a.instance_variable_get(:@http_client).should be_a(HttpClient)
-    end
-    it 'should instantiate an expectation_matcher into @expectation' do
-      @a.instance_variable_get(:@expectation).should be_a(ExpectationMatcher)
-    end
   end
 
   describe 'run_tests' do
     it 'should send a request for every given testcase' do
-      response_struct = Struct.new(:code, :message, :headers, :body)
-      response = response_struct.new
-      response.code = 404
-      response.message = "Ok"
-      response.body = {}
-      response.headers = {}
+      pending "TODO"
+      response = Result.new({},{})
       @a.should_receive(:server_is_available?).and_return true
       @a.should_receive(:send_request).exactly(@a.instance_variable_get(:@spec).size).times.and_return(response)
       @a.run
     end
-    it 'should run a test for every test_type'
-    it 'should save an error message in @errors if an error occured'
+    it 'should save an error message in @errors if an error occured' do
+      pending "TODO"
+      response = Result.new({},{})
+      @a.should_receive(:server_is_available?).and_return true
+      @a.should_receive(:send_request).exactly(@a.instance_variable_get(:@spec).size).times.and_return(response)
+      @a.run
+      @a.instance_variable_get(:@results).should_not be_nil
+      @a.instance_variable_get(:@results).size.should_not == 0
+    end
   end
 
   describe 'send_request' do
-    it 'should invoke send_request at the @http_client with the appropiate method, uri and data'
+    it "should invoke send_request at the @http_client with appropiate method, path, headers, body and get-parameters" do
+      pending "TODO"
+      @a.instance_variable_get(:@http_client).should_receive(:send_request).and_return(Result.new({},{}))
+      @a.send(:send_request_for,Testcase.new({}))
+    end
   end
 
   describe 'target_uri' do
-    it 'should create a correct target uri from existing instance variables'
+    it 'should create a correct target uri from existing instance variables' do
+      @a.send(:target_uri).match(@a.instance_variable_get(:@configuration).protocol).should be_true
+      @a.send(:target_uri).match(@a.instance_variable_get(:@configuration).host).should be_true
+      @a.send(:target_uri).match("://").should be_true
+    end
   end
 
   describe 'server_is_available?' do

data/spec/checker_spec.rb

@@ -0,0 +1,86 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'json'
+require 'nokogiri'
+
+describe "Checker" do
+  describe "self.available_plugins" do
+    it "should return an array of available plugins inheriting from self" do
+      Checker.available_plugins.should be_a(Array)
+      Checker.available_plugins.size.should_not == 0
+    end
+  end
+  describe "relative_path" do
+    it 'should substitute an absolute addressing in a given path' do
+      pending "Move me"
+      path = "/bla/foo/values[6]/duffy/duck"
+      Checker.new({},{}).send(:relative_path, path).should eql "/bla/foo/*/duffy/duck"
+    end
+    it 'should substitute more than one absolute adressing in a given path' do
+      pending "Move me"
+      path = "/bla/foo/values[6]/duffy/friends[1]/duck"
+      Checker.new({},{}).send(:relative_path, path).should eql "/bla/foo/*/duffy/*/duck"
+    end
+    it 'should return a string' do
+      pending "Move me"
+      path = "/bla/foo/values[6]/duffy/friends[1]/duck"
+      Checker.new({},{}).send(:relative_path, path).should be_a(String)
+    end
+  end
+  describe "excluded?" do
+    it "should return true if a given item is not part of the instances exludes"
+    it "should return false if a given item is part of the instances excludes"
+  end
+  describe "is_regex?" do
+    it 'should return true if the given string seems to be a regular expression' do
+      string = "/^\d{3}$/"
+      Checker.new({},{}).send(:is_regex?, string).should be_true
+    end
+    it 'should return false if the given string does not seem to be a regular expression' do
+      string = "fooz"
+      Checker.new({},{}).send(:is_regex?, string).should be_false
+      string = "/fooz"
+      Checker.new({},{}).send(:is_regex?, string).should be_false
+      string = "fooz/"
+      Checker.new({},{}).send(:is_regex?, string).should be_false
+    end
+  end
+  describe "regex_matches?" do
+    it 'should return true if the given regular expression matches the given value' do
+      regex = "^\\d{2}$"
+      value = "12"
+      Checker.new({},{}).send(:regex_matches?, regex, value).should be_true
+    end
+    it 'should return false if the giveb reular expression does not match the given value' do
+      regex = "^\\d{2}$"
+      value = "123"
+      Checker.new({},{}).send(:regex_matches?, regex, value).should be_false
+      value = "foo"
+      Checker.new({},{}).send(:regex_matches?, regex, value).should be_false
+    end
+  end
+  describe "string_matches?" do
+    it 'should return true if the given string matches the given value' do
+      string = "bar"
+      value = "bar"
+      Checker.new({},{}).send(:string_matches?, string, value).should be_true
+    end
+    it 'should return false if the given string does not match the given value' do
+      string = "bar"
+      value = "foo"
+      Checker.new({},{}).send(:string_matches?, string, value).should be_false
+    end
+  end
+  describe "valid_json?" do
+    it 'should return true if the given response body consists of valid JSON' do
+      validateable = { :foo => "bar" }.to_json
+      Checker.new({},{}).send(:valid_json?, validateable).should be_true
+    end
+    it 'should return true if the given response body is nil' do
+      Checker.new({},{}).send(:valid_json?, nil).should be_true
+    end
+    it 'should return false if the given response body consists of anything else but valid JSON' do
+      Checker.new({},{}).send(:valid_json?, "foobar").should be_false
+    end
+  end
+end
+

data/spec/expectation_matcher_spec.rb

@@ -1,232 +1,35 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-require 'json'
-require 'nokogiri'
 
 describe 'ExpectationMatcher' do
-  before(:each) do
-    @em = ExpectationMatcher.new
-  end
-  describe 'regex_matches?' do
-    it 'should return true if given regex matches the given string' do
-      ExpectationMatcher.new.send(:regex_matches?, "/^\\d{2}$/", "12").should be_true
-    end
-    it 'should return false if the given regex does not match the given string' do
-      ExpectationMatcher.new.send(:regex_matches?, "/^\\d{2}$/", "133").should be_false
-    end
-  end
-
-  describe 'testtypes' do
-    it 'should return the available testtypes of the class' do
-      @em.test_types.should eql ([:response_code, :response_body_format, :response_headers, :response_body])
-    end
-    it 'should at least return one testtype' do
-      @em.test_types.size.should >= 1
-    end
-    it 'should return an array of symbols' do
-      @em.test_types.should be_a(Array)
-      @em.test_types.each do |type|
-        type.should be_a(Symbol)
-      end
-    end
-    it 'should not return nil' do
-      @em.test_types.should_not be_nil
-    end
-  end
-
-  describe 'check' do
-    it 'should invoke http client with the given method, response and testcase' do
-      @em = ExpectationMatcher.new
-      @em.should_receive(:put)
-      @em.check(:put, {}, [])
-      @em.should_receive(:post)
-      @em.check(:post, {}, [])
-      @em.should_receive(:get)
-      @em.check(:get, {}, [])
-      @em.should_receive(:delete)
-      @em.check(:delete, {}, [])
-    end
-  end
-
-  describe 'response_code' do
-    it 'should return a struct representing success if the given response code matches the expected one' do
-      response_struct = Struct.new(:code, :message, :headers, :body)
-      response = response_struct.new
-      response.code = 404
-      testcase = { 'response_expectation' => { 'status_code' => 404 } }
-      @em.send(:response_code, response, testcase).should be_a(Struct)
-      @em.send(:response_code, response, testcase).succeeded.should be_true
-      @em.send(:response_code, response, testcase).error.should be_nil
-    end
-    it 'should return a struct representing failure if the given repsonse code does not match the expected one' do
-      response_struct = Struct.new(:code, :message, :headers, :body)
-      response = response_struct.new
-      response.code = 400
-      testcase = { 'response_expectation' => { 'status_code' => 404 } }
-      @em.send(:response_code, response, testcase).should be_a(Struct)
-      @em.send(:response_code, response, testcase).succeeded.should be_false
-      @em.send(:response_code, response, testcase).error.should_not be_nil
-    end
-  end
-
-  describe 'response_body_format' do
-    before(:each) do
-      response_struct = Struct.new(:code, :message, :headers, :body)
-      @response = response_struct.new
-    end
-    it 'should return a struct representing success if the given response body is nil, cause this is allowed' do
-      @response.body = nil
-      @em.send(:response_body_format, @response, {}).should be_a(Struct)
-      @em.send(:response_body_format, @response, {}).succeeded.should be_true
-      @em.send(:response_body_format, @response, {}).error.should be_nil
-    end
-    it 'should return the given response body in JSON format, if a valid JSON string is given to check' do
-      @response.body = {:fooz => "baaz"}.to_json
-      @em.send(:response_body_format, @response, {}).should be_a(Struct)
-      @em.send(:response_body_format, @response, {}).succeeded.should be_true
-      @em.send(:response_body_format, @response, {}).error.should be_nil
-    end
-    it 'should not fatal but return false, if the given response body is no valid JSON' do
-      @response.body = "foozbaz"
-      @em.send(:response_body_format, @response, {}).should be_a(Struct)
-      @em.send(:response_body_format, @response, {}).succeeded.should be_false
-      @em.send(:response_body_format, @response, {}).error.should_not be_nil
-    end
-  end
-
-  describe 'response_headers' do
-    before(:each) do
-      response_struct = Struct.new(:code, :message, :headers, :body)
-      @response = response_struct.new
-    end
-    it 'should return a struct representing success, if one certain expected header value matches the response header' do
-      @response.headers = {"content-type"=>["text/html; charset=utf-8"], "cache-control"=>["no-cache"], "x-runtime"=>["0.340116"], "server"=>["WEBrick/1.3.1 (Ruby/1.9.2/2010-08-18)"], "date"=>["Tue, 21 Sep 2010 11:33:05 GMT"], "content-length"=>["149"], "connection"=>["close"], "Last-Modified" => "2010-10-01 23:23:23"}
-      testcase = { 'response_expectation' => { 'headers' => {"Last-Modified"=>"/.*/"} } }
-      @em.send(:response_headers, @response, testcase).should be_a(Struct)
-      @em.send(:response_headers, @response, testcase).succeeded.should be_true
-      @em.send(:response_headers, @response, testcase).error.should be_nil
-    end
-    it 'should return a struct representing success, if more than one expected header values match the ones in the repsonse header' do
-      pending "TODO: pair this one"
-    end
-    it 'should even return a struct representing success if the response header contains more values than the excpected' do
-      pending "TODO: pair this one"
-    end
-    it 'should return a struct representing an error, if one single expected header value does not match the one in response' do
-      pending "TODO: pair this one"
-    end
-    it 'should return a struct representing an error, if one of more expected header values does not match the corresponding one in the response' do
-      pending "TODO: pair this one"
-    end
-    it 'should return a struct representing success, if the expected header is nil - no expectation exists' do
-      pending "TODO: pair this one"
-      testcase = { 'response_expectation' => { 'headers' => nil } }
-      @em.send(:response_headers, @response, testcase).should be_a(Struct)
-      @em.send(:response_headers, @response, testcase).succeeded.should be_true
-      @em.send(:response_headers, @response, testcase).error.should be_nil
-    end
-  end
-
-  describe 'response_body' do
-    it 'should check something'
-    it 'should return a result struct'
-  end
-
-  describe 'matcher_pathes_from' do
-    it 'should return pathes to all leaves of a given tree including relative pathes in case of arrays in the JSON' do
-      xml_tree = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><hash><bla>laber</bla><foo><values type=\"array\"><value><a>1</a></value><value><b type=\"integer\">2</b></value><value><c>/.*/</c></value></values></foo><bar>baz</bar></hash>"
-      tree = Nokogiri::XML(xml_tree)
-      @em.send(:matcher_pathes_from, tree).should be_a(Array)
-      @em.send(:matcher_pathes_from, tree).include?("/hash/bla").should be_true
-      @em.send(:matcher_pathes_from, tree).include?("/hash/foo/values/*/a").should be_true
-      @em.send(:matcher_pathes_from, tree).include?("/hash/foo/values/*/b").should be_true
-      @em.send(:matcher_pathes_from, tree).include?("/hash/foo/values/*/c").should be_true
-      @em.send(:matcher_pathes_from, tree).include?("/hash/bar").should be_true
-      @em.send(:matcher_pathes_from, tree).each do |path|
-        path.should be_a(String)
-      end
-    end
-  end
-
-  describe 'relative_path' do
-    it 'should substitute an absolute addressing in a given path' do
-      path = "/bla/foo/values[6]/duffy/duck"
-      @em.send(:relative_path, path).should eql "/bla/foo/*/duffy/duck"
-    end
-    it 'should substitute more than one absolute adressing in a given path' do
-      path = "/bla/foo/values[6]/duffy/friends[1]/duck"
-      @em.send(:relative_path, path).should eql "/bla/foo/*/duffy/*/duck"
-    end
-    it 'should return a string' do
-      path = "/bla/foo/values[6]/duffy/friends[1]/duck"
-      @em.send(:relative_path, path).should be_a(String)
-    end
-  end
-
-  describe 'excluded?' do
-    before(:each) do
-      @em = ExpectationMatcher.new(['foo', 'bar'])
-    end
-    it 'should return true if the given string is present in the @excludes instance variable of the class' do
-      @em.send(:excluded?, 'foo').should be_true
-    end
-    it 'should return false if the given string is not present in the @excludes instance variable of the class' do
-      @em.send(:excluded?, 'fooz').should be_false
-    end
-  end
-
-  describe 'is_regex?' do
-    it 'should return true if the given string seems to be a regular expression' do
-      string = "/^\d{3}$/"
-      @em.send(:is_regex?, string).should be_true
-    end
-    it 'should return false if the given string does not seem to be a regular expression' do
-      string = "fooz"
-      @em.send(:is_regex?, string).should be_false
-      string = "/fooz"
-      @em.send(:is_regex?, string).should be_false
-      string = "fooz/"
-      @em.send(:is_regex?, string).should be_false
-    end
-  end
-
-  describe 'regex_matches?' do
-    it 'should return true if the given regular expression matches the given value' do
-      regex = "^\\d{2}$"
-      value = "12"
-      @em.send(:regex_matches?, regex, value).should be_true
-    end
-    it 'should return false if the giveb reular expression does not match the given value' do
-      regex = "^\\d{2}$"
-      value = "123"
-      @em.send(:regex_matches?, regex, value).should be_false
-      value = "foo"
-      @em.send(:regex_matches?, regex, value).should be_false
-    end
-  end
-
-  describe 'string_matches?' do
-    it 'should return true if the given string matches the given value' do
-      string = "bar"
-      value = "bar"
-      @em.send(:string_matches?, string, value).should be_true
-    end
-    it 'should return false if the given string does not match the given value' do
-      string = "bar"
-      value = "foo"
-      @em.send(:string_matches?, string, value).should be_false
-    end
-  end
-
-  describe 'valid_json?' do
-    it 'should return true if the given response body consists of valid JSON' do
-      validateable = { :foo => "bar" }.to_json
-      @em.send(:valid_json?, validateable).should be_true
-    end
-    it 'should return true if the given response body is nil' do
-      @em.send(:valid_json?, nil).should be_true
-    end
-    it 'should return false if the given response body consists of anything else but valid JSON' do
-      @em.send(:valid_json?, "foobar").should be_false
+  describe "initialize" do
+    it "should have a properly filled instance variable @excludes after instanciation" do
+      @e = ExpectationMatcher.new(["exclude1","exclude2","exclude3"])
+      @e.instance_variable_get(:@excludes).should be_a(Array)
+      @e.instance_variable_get(:@excludes).size.should == 3
+      @e.instance_variable_get(:@excludes)[0].should eql "exclude1"
+    end
+    it "should habe an empty array in @excludes if no excludes were given" do
+      @e = ExpectationMatcher.new()
+      @e.instance_variable_get(:@excludes).should be_a(Array)
+      @e.instance_variable_get(:@excludes).size.should == 0
+    end
+  end
+  describe "check" do
+    it "should invoke check at the given plugin" do
+      @e = ExpectationMatcher.new
+      @e.should_receive(:test_plugin).once.with({ :response => "1" }, { :testcase => "2" })
+      @e.check("TestPlugin", { :response => "1"}, { :testcase => "2" })
+    end
+  end
+  describe "self.initialize_plugins" do
+    it "should create private invocation methods for every plugin" do
+      pending "TODO"
+      ExpectationMatcher.should_receive(:available_plugins).and_return(["PluginNoOne", "PluginNoTwo", "PluginNoThree"])
+      @e = ExpectationMatcher.new
+      # FIXME private methods
+      @e.should respond_to(:plugin_no_one)
+      @e.should respond_to(:plugin_no_two)
+      @e.should respond_to(:plugin_no_three)
     end
   end
 end

data/spec/http_client_spec.rb

@@ -2,46 +2,73 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe 'http_client' do
   before(:each) do
-    @http_client = HttpClient.new
+    @http_client = HttpClient.new("http", "localhost", 3000, "namespace")
     any_response = Struct.new(:code, :message, :headers, :body)
     @response = any_response.new(:code => 200, :message => "Ok", :headers => {:foo => ["baz" => "bar"], :body => {:a => "b"}})
   end
   describe 'send_request' do
-    it 'should invoke a send request in the underlying http class with the given method, uri and data' do
-      @http_client.class.should_receive(:put)
-      @http_client.should_receive(:build_response).and_return(@response)
-      @http_client.send_request(:put, "http://foo.bar", nil)
-
-      @http_client.class.should_receive(:get)
-      @http_client.should_receive(:build_response).and_return(@response)
-      @http_client.send_request(:get, "http://foo.bar", nil)
+    it 'should invoke a PUT request in the underlying http class with the given method, uri and data' do
+      @http_client.stub(:build_response).and_return(@response)
+      @http_client.should_receive(:put).and_return(@response)
+      @http_client.send_request(:put, "/path/to/resource", nil, { :data => "2" }, { :params => "3" })
+    end
+    it 'should invoke a GET request in the underlying http class with the given method, uri and data' do
+      @http_client.stub(:build_response).and_return(@response)
+      @http_client.should_receive(:get).and_return(@response)
+      @http_client.send_request(:get, "/path/to/resource", nil, { :data => "2" }, { :params => "3" })
     end
-    it 'should invoke build response and return its output to the caller' do
-      @http_client.should_receive(:build_response).and_return("response")
-      @http_client.send_request(:put, "http://foo.bar", nil).should eql "response"
+    it 'should invoke a POST request in the underlying http class with the given method, uri and data' do
+      @http_client.stub(:build_response).and_return(@response)
+      @http_client.should_receive(:post).and_return(@response)
+      @http_client.send_request(:post, "/path/to/resource", nil, { :data => "2" }, { :params => "3" })
     end
-    it 'should not fatal if expected data attribute is nil' do
-      pending "TODO: pair this one"
-      @http_client.should_receive(:build_response).and_return(@response)
-      @http_client.send_request(:put, "http://foo.bar", nil).should_not raise_error
+    it 'should invoke a DELETE request in the underlying http class with the given method, uri and data' do
+      @http_client.stub(:build_response).and_return(@response)
+      @http_client.should_receive(:delete).and_return(@response)
+      @http_client.send_request(:delete, "/path/to/resource", nil, { :data => "2" }, { :params => "3" })
     end
   end
-
   describe 'build_response' do
     it 'should return a struct consisting of 4 symbols: :code, :message, :headers and :body with right types' do
       raw_response_struct = Struct.new(:code, :message, :headers, :body)
       response = raw_response_struct.new
-
       response.code    = 404
       response.message = "Hi Duffy Duck"
-      response.headers = { :foo => ["bar" => "baz"] }
+      response.headers = { :daisy => "duck" }
       response.body    = { :duffy => "duck" }
-
-      @http_client.send(:build_response, response).to_s.should eql response.to_s
       @http_client.send(:build_response, response).code.should_not be_nil
       @http_client.send(:build_response, response).message.should_not be_nil
-      @http_client.send(:build_response, response).body.should_not be_nil
-      @http_client.send(:build_response, response).headers.should_not be_nil
+      @http_client.send(:build_response, response).body.should == {:duffy => "duck"}
+      @http_client.send(:build_response, response).headers.should == {"daisy" => "duck"}
+    end
+  end
+  describe "resource_path" do
+    it "should return a resource path extended by the namespace if one is set" do
+      @http_client.send(:resource_path, "/users/duffyduck").match(@http_client.instance_variable_get(:@namespace)).should_not be_nil
+    end
+    it "should return a correct resource path even if no namespace is set" do
+      @http_client.instance_variable_set(:@namespace, nil)
+      @http_client.send(:resource_path, "/users/duffyduck").match(/\/users\/duffyduck/).should_not be_nil
+    end
+  end
+  describe "build_uri" do
+    it "should return a correct uri from the given parameters" do
+      @http_client.send(:build_uri,"/users/duffyduck").should_not be_nil
+      @http_client.send(:build_uri,"/users/duffyduck").to_s.match(@http_client.instance_variable_get(:@protocol)).should_not be_nil
+      @http_client.send(:build_uri,"/users/duffyduck").to_s.match(@http_client.instance_variable_get(:@host)).should_not be_nil
+      @http_client.send(:build_uri,"/users/duffyduck").to_s.match(@http_client.instance_variable_get(:@port).to_s).should_not be_nil
+      @http_client.send(:build_uri,"/users/duffyduck").to_s.match(@http_client.instance_variable_get(:@namespace)).should_not be_nil
+    end
+    it "should only include a port in uri if a port was specified or port was set to 80" do
+      @http_client.instance_variable_set(:@port, nil)
+      @http_client.send(:build_uri,"/users/duffyduck").to_s.match("80").should be_nil
+      @http_client.instance_variable_set(:@port, 80)
+      @http_client.send(:build_uri,"/users/duffyduck").to_s.match("80").should be_nil
+    end
+    it "should add given GET parameters in correct notation" do
+      @http_client.send(:build_uri,"/users/duffyduck", {:param1 => "1", :param2 => "a"}).to_s.match(/\?param/).should_not be_nil
+      @http_client.send(:build_uri,"/users/duffyduck", {:param1 => "1", :param2 => "a"}).to_s.match(/param1=1/).should_not be_nil
+      @http_client.send(:build_uri,"/users/duffyduck", {:param1 => "1", :param2 => "a"}).to_s.match(/param2=a/).should_not be_nil
     end
   end
 end

data/spec/result_spec.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "result" do
+  before(:all) do
+    @r = Result.new({ :name => "testcase_name" }, {})
+  end
+  describe "verbose_on_error" do
+    it "should invoke be_verbose if an error occured" do
+      @r.instance_variable_set(:@succeeded, false)
+      @r.should_receive(:be_verbose).once
+      @r.send(:verbose_on_error, 1)
+    end
+    it "should not invoke be_verbose if no error occured" do
+      @r.instance_variable_set(:@succeeded, true)
+      @r.should_receive(:be_verbose).exactly(0).times
+      @r.send(:verbose_on_error, 1)
+    end
+  end
+  describe "verbose_on_success" do
+    it "should invoke be_verbose in case of an error" do
+      @r.instance_variable_set(:@succeeded, false)
+      @r.should_receive(:be_verbose).once
+      @r.send(:verbose_on_success, 1)
+    end
+    it "should invoke be_verbose in case of no error too" do
+      @r.instance_variable_set(:@succeeded, true)
+      @r.should_receive(:be_verbose).once
+      @r.send(:verbose_on_success, 1)
+    end
+  end
+  describe "verbose_with_curl" do
+    it "should invoke be_verbose in case of an error" do
+      @r.instance_variable_set(:@succeeded, false)
+      @r.should_receive(:be_verbose).once
+      @r.send(:verbose_with_curl, 1)
+    end
+    it "should invoke be_verbose in case of no error too" do
+      @r.instance_variable_set(:@succeeded, true)
+      @r.should_receive(:be_verbose).once
+      @r.send(:verbose_with_curl, 1)
+    end
+  end
+end
+
+

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 3
-  - 5
-  version: 0.3.5
+  - 6
+  version: 0.3.6
 platform: ruby
 authors: 
 - jan@moviepilot.com
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-07 00:00:00 +02:00
+date: 2010-10-12 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -234,7 +234,6 @@ files:
 - lib/apirunner.rb
 - lib/apirunner/railtie.rb
 - lib/checker.rb
-- lib/core_extensions.rb
 - lib/expectation_matcher.rb
 - lib/http_client.rb
 - lib/plugins/plug01_response_json_syntax_checker.rb
@@ -242,12 +241,16 @@ files:
 - lib/plugins/plug03_response_header_checker.rb
 - lib/plugins/plug04_response_body_checker.rb
 - lib/result.rb
+- lib/string_ext.rb
 - lib/tasks/api.rake
 - lib/testcase.rb
 - spec/.rspec
+- spec/api_configuration_spec.rb
 - spec/api_runner_spec.rb
+- spec/checker_spec.rb
 - spec/expectation_matcher_spec.rb
 - spec/http_client_spec.rb
+- spec/result_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/moviepilot/apirunner
@@ -263,7 +266,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 4004679743371264897
+      hash: 2715016286846955498
       segments: 
       - 0
       version: "0"
@@ -283,7 +286,10 @@ signing_key:
 specification_version: 3
 summary: one-line summary of your gem
 test_files: 
+- spec/api_configuration_spec.rb
 - spec/api_runner_spec.rb
+- spec/checker_spec.rb
 - spec/expectation_matcher_spec.rb
 - spec/http_client_spec.rb
+- spec/result_spec.rb
 - spec/spec_helper.rb

data/lib/core_extensions.rb

@@ -1,17 +0,0 @@
-module CoreExtensions
-  class String
-    # generates filenames from classnames the rails way
-    def underscore(string)
-      string.to_s.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
-    end
-
-    # opposites underscore defined above
-    def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
-      if first_letter_in_uppercase
-        lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
-      else
-        lower_case_and_underscored_word.first + camelize(lower_case_and_underscored_word)[1..-1]
-      end
-    end
-  end
-end