aspec 0.1

data/README.md

@@ -0,0 +1,16 @@
+aspec
+=====
+
+External api surface testing library
+
+# Installing
+
+    gem install aspec
+	
+# Running
+
+    aspec spec/thing_aspec.rb
+
+# Tests
+
+    rspec spec

data/bin/aspec

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+$:.push(File.expand_path("../../lib", __FILE__))
+require 'aspec'
+
+Aspec::CLI.new(Dir.pwd, ARGV).run
+
+
+
+
+
+
+
+

data/lib/aspec.rb

@@ -0,0 +1,55 @@
+require 'rubygems'
+
+require 'rack/test'
+require 'rspec/mocks/standalone'
+require 'term/ansicolor'
+require 'json'
+
+require 'aspec/cli'
+require 'aspec/formatters/terminal'
+require 'aspec/formatters/junit'
+require 'aspec/runner'
+require 'aspec/parser'
+require 'aspec/test'
+
+module Aspec
+  def self.configuration
+    @configuration ||= Configure.new
+  end
+
+  def self.configure
+    yield configuration
+  end
+
+  class Configure
+    attr_accessor :verbose, :slow, :formatter
+
+    def verbose?; verbose; end
+    def slow?; slow; end
+
+    def app_under_test(&block)
+      @app_under_test = block
+    end
+
+    def before(&block)
+      @before = block
+    end
+
+    def get_app_under_test
+      @app_under_test
+    end
+
+    def get_before
+      @before
+    end
+
+    def after_suite(&block)
+      @after_suite = block
+    end
+
+    def get_after_suite
+      @after_suite
+    end
+  end
+end
+

data/lib/aspec/cli.rb

@@ -0,0 +1,45 @@
+
+module Aspec
+  class CLI
+    attr_reader :args, :working_dir
+
+    def initialize(working_dir, args)
+      @working_dir = working_dir
+      @args = args
+    end
+
+    def aspec_files
+      files = []
+      @args.each do |arg|
+        arg = File.expand_path(arg, working_dir)
+        if File.exist?(arg)
+          if File.directory?(arg)
+            files += Dir[arg + "**/*.aspec"]
+          elsif arg =~ /.*\.aspec/
+            files << arg
+          end
+        end
+      end
+      files
+    end
+
+    def aspec_helper_path
+      File.expand_path("aspec/aspec_helper.rb")
+    end
+
+    def run
+      bits = args[0].split(":")
+
+      load aspec_helper_path if File.exist?(aspec_helper_path)
+
+      @lines = bits[1..-1].map(&:to_i)
+      is_verbose = args.include?("-v")
+      Aspec.configure do |c|
+        c.verbose   = is_verbose
+        c.slow      = args.include?("--slow")
+        c.formatter = args.include?("--junit") ? Formatter::JUnit.new(@file) : Formatter::Terminal.new(is_verbose)
+      end
+      TestRunner.new(Aspec.configuration, aspec_files).run(@lines)
+    end
+  end
+end

data/lib/aspec/formatters/junit.rb

@@ -0,0 +1,92 @@
+
+module Aspec
+  module Formatter
+    class JUnit
+      def initialize(test_file_name, verbose = false, out_file_name = '.junit_aspecs')
+        @test_results = { :failures => [], :successes => [] }
+        @out = File.open(out_file_name, 'w')
+        @test_file_name = test_file_name
+        @exceptions = []
+        at_exit do
+          unless @out.closed?
+            @out.flush
+            @out.close
+            puts "Output junit results to .junit_aspecs"
+          end
+        end
+      end
+
+      def clear
+      end
+
+      def comment(comment_string)
+      end
+
+      def step_error(step)
+        @test_results[:failures] << [step_line(step), @exceptions]
+        @exceptions = []
+      end
+
+      def exception(error_string)
+        @exceptions << error_string
+      end
+
+      def step_error_title(step)
+      end
+
+      def step_pass(step)
+        @test_results[:successes] << step_line(step)
+      end
+
+      def debug
+      end
+
+      def dump_summary(summary)
+        @out.puts("<?xml version=\"1.0\" encoding=\"utf-8\" ?>")
+        @out.puts("<testsuite errors=\"0\" failures=\"#{failure_count}\" tests=\"#{example_count}\" time=\"#{duration=0}\" timestamp=\"#{Time.now.iso8601}\">")
+        @out.puts("  <properties />")
+
+        @test_results[:successes].each do |success_string|
+          #TODO: Add timings
+          runtime = 0
+          @out.puts("  <testcase classname=\"#{@test_file_name}\" name=\"#{test_name(success_string)}\" time=\"#{runtime}\" />")
+        end
+        @test_results[:failures].each do |(failure_string, exceptions)|
+          runtime = 0
+          @out.puts("  <testcase classname=\"#{@test_file_name}\" name=\"#{failure_string}\" time=\"#{runtime}\">")
+
+          @out.puts("    <failure message=\"failure\" type=\"failure\">")
+          @out.puts("<![CDATA[ #{exceptions} ]]>")
+          @out.puts("    </failure>")
+          @out.puts("  </testcase>")
+        end
+        @out.puts("</testsuite>")
+      end
+
+      private
+      def step_line(step)
+        "#{step[:method]} #{step[:url]} line: #{step[:line_num]}"
+      end
+
+      def test_name(string)
+        xml_encode(string.split("\n")[0].strip)
+      end
+
+      def example_count
+        @test_results[:successes].count + failure_count
+      end
+
+      def failure_count
+        @test_results[:failures].count
+      end
+
+      def xml_encode(string)
+        #TODO: Use builder to do this
+        string.gsub!('&', '&amp;')
+        string.gsub!('>', '')
+        string.gsub!('"','&quot;')
+        string
+      end
+    end
+  end
+end

data/lib/aspec/formatters/terminal.rb

@@ -0,0 +1,80 @@
+
+module Aspec
+  module Formatter
+    class Terminal
+      include Term::ANSIColor
+
+      def initialize(verbose, out = STDOUT)
+        @out = out
+        @verbose = verbose
+        @line_buffer ||= []
+      end
+
+      def clear
+        @line_buffer.clear
+      end
+
+      def comment(comment_string)
+        line(comment_string)
+      end
+
+      def exception(error_string)
+        line(error_string)
+      end
+
+      def step_error_title(step)
+        step_line(step)
+      end
+
+      def step_error(step)
+        line(red + step_line(step) + reset)
+        print_error unless @verbose
+      end
+
+      def step_pass(step)
+        line(green + step_line(step) + reset)
+      end
+
+      def debug(step)
+        @out.puts(step.inspect)
+      end
+
+      def dump_summary(summary)
+        @out.puts summary
+      end
+
+      private
+
+      def step_line(step)
+        bits = [step[:method].rjust(7, " "), step[:url].ljust(50, " "), step[:exp_status], (step[:exp_content_type]||"")]
+        if step[:exp_content_type] == "application/json"
+          begin
+            json_string = JSON.parse(step[:exp_response]).to_json
+            if json_string.length > 20
+              json_string = "\n" + JSON.pretty_generate(JSON.parse(step[:exp_response])).split("\n").map {|l| "         \\ #{l}"}.join("\n")
+            end
+            bits << json_string
+          rescue JSON::ParserError
+            bits << step[:exp_response]
+          end
+        else
+          bits << step[:exp_response]
+        end
+        bits.join("\t")
+      end
+
+      def line(line_string)
+        @out.puts(line_string) if @verbose
+        @line_buffer << line_string
+      end
+
+      def print_error
+        @line_buffer.each do |line|
+          @out.puts line
+        end
+        @line_buffer = []
+      end
+
+    end
+  end
+end

data/lib/aspec/parser.rb

@@ -0,0 +1,50 @@
+module Aspec
+  class Parser
+    def initialize(source)
+      @lines = source.split("\n").map {|l| l.strip}
+    end
+
+    def tests
+      @tests ||= begin
+        tests = [[]]
+        @lines.each_with_index do |line, line_num|
+          if line =~ /^\s*$/
+            if tests.last.length > 0
+              tests << []
+            end
+          elsif line =~ /^\s*\\(.*)$/
+            tests.last.last[:exp_response] = (tests.last.last[:exp_response] + $1)
+          else
+            tests.last << parse_line(line, line_num)
+          end
+        end
+        tests.select {|tests| tests.any?}.map {|steps| Test.new(steps) }
+      end
+    end
+
+    def parse_line(line, line_num)
+      if line =~ /^\s*(#.*)$/
+        {:comment => $1, :line_num => line_num}
+      else
+        bits = line.split(" ")
+        method = bits[0]
+        url    = bits[1]
+        url    = URI.encode(url)
+
+        exp_status = bits[2]
+        exp_status = exp_status.strip if exp_status
+        exp_content_type = bits[3]
+        exp_content_type = exp_content_type.strip if exp_content_type
+        exp_response = (bits[4..-1]||[]).join(" ")
+        is_regex = exp_response[0] == '/' and exp_response[-1] == '/' and exp_response.size > 2
+        exp_response = exp_response[1 .. -2] if is_regex
+
+        {:method => method, :url => url,
+          :exp_status => exp_status, :exp_content_type => exp_content_type, :exp_response => exp_response,
+          :resp_is_regex => is_regex, :line_num => line_num
+        }
+      end
+    end
+
+  end
+end

data/lib/aspec/runner.rb

@@ -0,0 +1,76 @@
+
+module Aspec
+  class TestRunner
+    include Term::ANSIColor
+
+    attr_reader :config, :source
+
+    def initialize(config, paths)
+      @paths = paths
+      @config = config
+    end
+
+    def verbose?
+      config.verbose?
+    end
+
+    def slow?
+      config.slow?
+    end
+
+    def formatter
+      config.formatter
+    end
+
+    def tests
+      @tests ||= begin
+        result = []
+        @paths.each do |path|
+          parser = Parser.new(File.read(path))
+          result += parser.tests
+        end
+        result.flatten
+      end
+    end
+
+    def before_each
+      if before_block = config.get_before
+        before_block.call
+      end
+    end
+
+    def run(lines)
+      successes = 0
+      failures = 0
+      if lines.any?
+        run_tests = tests.select {|test| lines.any? {|line_num| test.contains_line?(line_num)}}
+      else
+        run_tests = tests
+      end
+
+      run_tests.each do |test|
+        before_each
+        if test.run(config)
+          successes += 1 unless test.comment_only?
+          puts if verbose?
+        else
+          failures += 1
+          puts
+        end
+        formatter.clear
+      end
+      color = send(failures > 0 ? :red : :green)
+      formatter.dump_summary color + "#{successes} passed, #{failures} failed." + reset
+
+      if after_suite_block = config.get_after_suite
+        after_suite_block.call
+      end
+      if failures > 0
+        exit(1)
+      else
+        exit(0)
+      end
+    end
+  end
+end
+

data/lib/aspec/test.rb

@@ -0,0 +1,140 @@
+
+module Aspec
+  class Test
+    include Rack::Test::Methods
+
+    def initialize(steps)
+      @steps = steps
+    end
+
+    def validate_method(method)
+      raise "unknown method #{method}" unless %W(GET POST DELETE PUT).include?(method)
+    end
+
+    def comment_only?
+      @steps.all? {|s| s[:comment]}
+    end
+
+    def contains_line?(line_num)
+      @steps.first[:line_num] <= line_num and @steps.last[:line_num] >= line_num
+    end
+
+    def app
+      @app
+    end
+
+    def run(config)
+      formatter  = config.formatter
+      is_slow    = config.slow?
+      @app       = config.get_app_under_test.call
+      start_time = Time.at(0)
+      failed = false
+      @steps.each_with_index do |step, time_delta|
+        if is_slow
+          sleep 0.5
+        end
+
+        if ARGV.include?("--debug")
+          formatter.debug(step)
+        end
+
+        if failed
+          formatter.step_error_title(step)
+          next
+        end
+
+        if step[:comment]
+          formatter.comment(step[:comment])
+        else
+          Time.stub!(:now).and_return(start_time + 2*time_delta)
+
+          begin
+            if step[:method][0] == ">"
+              method = step[:method][1..-1]
+              validate_method(method)
+              url = "http://" + step[:url]
+              FakeWeb.register_uri(method.downcase.to_sym, url,
+                  :body => step[:exp_response],
+                  :content_type => step[:exp_content_type]
+                )
+            else
+              validate_method(step[:method])
+              send(step[:method].downcase, step[:url])
+            end
+          rescue Object => e
+            formatter.exception("  " + e.class.to_s + ": " + e.message)
+            e.backtrace.each do |backtrace_line|
+              formatter.exception("  " + backtrace_line) unless backtrace_line =~ /vendor\/bundle/ or backtrace_line =~ /test.rb/
+            end
+            failed = true
+          end
+
+          unless failed or step[:method][0] == ">"
+            if last_response.status.to_s != step[:exp_status]
+              formatter.exception(" * Expected status #{step[:exp_status]} got #{last_response.status}")
+              failed = true
+            end
+
+            if step[:exp_content_type] == "application/json" && !step[:resp_is_regex]
+              begin
+                expected_object = JSON.parse(step[:exp_response])
+                begin
+                  response_object = JSON.parse(last_response.body)
+                  if expected_object != response_object
+                    formatter.exception(" * Expected response #{JSON.pretty_generate(expected_object)} got #{JSON.pretty_generate(response_object)}")
+                    failed = true
+                  end
+                rescue JSON::ParserError
+                  formatter.exception(" * Response did not parse correctly as JSON: #{last_response.body.inspect}")
+                  failed = true
+                end
+              rescue JSON::ParserError
+                formatter.exception(" * Expectation did not parse correctly as JSON: #{step[:exp_response].inspect}")
+                failed = true
+              end
+
+            else
+
+              if step[:resp_is_regex]
+                pattern = nil, body = nil
+                if !(step[:exp_content_type].start_with? 'text/')
+                  pattern = Regexp.new(step[:exp_response].force_encoding("ASCII-8BIT"), Regexp::FIXEDENCODING)
+                  body = last_response.body.to_s.force_encoding("ASCII-8BIT")
+                else
+                  pattern = Regexp.new(step[:exp_response])
+                  body = last_response.body.to_s
+                end
+                if !(body =~ pattern)
+                  formatter.exception(" * Expected response pattern #{step[:exp_response].inspect} didn't match #{last_response.body.inspect}")
+                  failed = true
+                end
+              elsif !step[:resp_is_regex] & (last_response.body.to_s != step[:exp_response])
+                formatter.exception(" * Expected response #{step[:exp_response].inspect} got #{last_response.body.inspect[0..50] + "..."}")
+                failed = true
+              end
+            end
+
+            if step[:exp_content_type]
+              exp_content_type_header = "#{step[:exp_content_type]}"
+              exp_content_type_header << ";charset=utf-8" unless exp_content_type_header.start_with? "image/"
+              if last_response.headers["Content-Type"] != exp_content_type_header
+                formatter.exception(" * Expected content type #{exp_content_type_header} got #{last_response.headers["Content-Type"]}")
+                failed = true
+              end
+            end
+          end
+
+          if failed
+            formatter.step_error(step)
+          else
+            formatter.step_pass(step)
+          end
+        end
+      end
+      !failed
+    end
+  end
+end
+
+
+

data/spec/aspec_spec.rb

@@ -0,0 +1,9 @@
+
+require 'spec_helper'
+
+describe Aspec do
+  it "Should exist" do
+    Aspec
+  end
+
+end

data/spec/cli_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Aspec::CLI do
+  def test_app_dir
+    File.expand_path("../test_app", __FILE__)
+  end
+
+  it "should list all files in a directory" do
+    cli = Aspec::CLI.new(test_app_dir, ["aspec/"])
+    cli.aspec_files.sort.should == [
+      File.expand_path("aspec/failing.aspec", test_app_dir), 
+      File.expand_path("aspec/passing.aspec", test_app_dir)].sort
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$:.push(File.expand_path("../../lib", __FILE__))
+require 'aspec'

data/spec/test_app/aspec/aspec_helper.rb

@@ -0,0 +1,8 @@
+$:.push(File.expand_path("../../", __FILE__))
+require 'test_app'
+
+Aspec.configure do |c|
+  c.app_under_test do
+    TestApp.new
+  end
+end

data/spec/test_app/test_app.rb

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'sinatra'
+
+class TestApp < Sinatra::Application
+  get "/" do
+  end
+
+  get "/artists" do
+    status 200
+    content_type :json
+    @@artists.to_json
+  end
+
+  post "/artists" do
+    @@artists ||= []
+    @@artists << params[:name]
+    status 204
+    nil
+  end
+
+  delete "/artists/:name" do
+    @@artists = @@artists.reject {|a| a == params[:name] }
+    status 204
+    nil
+  end
+end
+

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification 
+name: aspec
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: "0.1"
+platform: ruby
+authors: 
+- Daniel Lucraft
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-12-06 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: term-ansicolor
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rack-test
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+description: 
+email: dan@songkick.com
+executables: 
+- aspec
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- README.md
+- lib/aspec.rb
+- lib/aspec/parser.rb
+- lib/aspec/runner.rb
+- lib/aspec/cli.rb
+- lib/aspec/test.rb
+- lib/aspec/formatters/terminal.rb
+- lib/aspec/formatters/junit.rb
+- spec/spec_helper.rb
+- spec/cli_spec.rb
+- spec/test_app/aspec/aspec_helper.rb
+- spec/test_app/test_app.rb
+- spec/aspec_spec.rb
+- bin/aspec
+homepage: http://github.com/songkick/aspec
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.md
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.12
+signing_key: 
+specification_version: 3
+summary: Testing for API external surfaces
+test_files: []
+