api_pi 0.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 593aca0cfdef51079c984f36b65e73ff91782b6a
+  data.tar.gz: 36490547835fc125f4f35239921a11c36cacdcd4
+SHA512:
+  metadata.gz: 600be817d0712ec773b48ebee4b2fe4b6e04421e6f64f6043afc37e0fc618cc610b3177956a49b7a442639097ab73c8277f389360ae30d248c1f1964de05a3ea
+  data.tar.gz: 1956d03a05709903c9dedcc3e67358783984989f1c82f5adf0de666a3bed69bdc66d4856cb8002ab9b2c4a95b7d1010cdcc560624d82308c4db19b4a76a49786

data/.gitignore

@@ -0,0 +1,2 @@
+.bundle/
+*.gem

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0-p0

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,26 @@
+PATH
+  remote: .
+  specs:
+    api_pi (0.2.2)
+      map (~> 6.5)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.3.5)
+    crack (0.4.2)
+      safe_yaml (~> 1.0.0)
+    map (6.5.1)
+    rake (10.1.0)
+    safe_yaml (1.0.1)
+    webmock (1.17.3)
+      addressable (>= 2.2.7)
+      crack (>= 0.3.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  api_pi!
+  rake (~> 10.1)
+  webmock (~> 1.17)

data/README.md

@@ -0,0 +1,200 @@
+# API P.I.
+
+A ruby DSL to test expected values in a service API!
+
+An example test can be found in the example/ directory.
+
+## Install
+
+Api P.I. requires ruby 2.0.0+
+
+Clone this repository to your machine:
+
+    $ git clone git@github.ubermind.com:bewoodall/api_pi.git && cd api_pi
+
+Build and Install the gem:
+
+    $ gem build api_pi.gemspec && gem install api_pi-VERSION.gem
+    
+## Usage
+
+### GETting Data
+
+To get a response from a particular service, you need to make an HTTP GET
+request to a URL.  
+
+    get "http://url-to-test.com/object.json" do...end
+
+The `get` method takes a URL string and then is fed a block to build tests. 
+
+Once you GET your URL, you are ready to create test blocks.
+
+### Setting Headers
+
+If you need to set custom request headers, you can do so with the `set_header`
+method.  To set a header, call `set_header` before you `get`:
+
+    set_header "user-agent", "api-pi"
+    set_header "cookie", "set-cookie:my-cookies"
+
+### Test Creation
+
+Once you have your GET block created, you are ready to create test blocks.
+Test blocks are used to group similar assertions into readable units.  
+
+For example, you may want to put your header tests into one test block:
+
+    get 'example.com/user.json' do
+      test 'Headers have correct data' do
+        # You header assertions...
+      end
+    end
+
+Inside of the test block, you would then put your header assertions.  Once you
+run your tests, your test blocks are grouped together and pass/fail based on
+assertions in the test block.
+
+### Header Querying
+
+Header fields can be queried using the following format:
+
+    response.header.fields.in.dot.notation
+
+`response.header` is required in order to use dot notation on header fields.
+
+Example:
+    
+    response.header.connection.is 'keep-alive'
+    response.header.contenttype.is 'application/json'
+
+**Note that when using dot notation, you will need to omit dashes. 
+content-type should be written as contenttype.
+content-length should be written as contentlength.**
+
+### Response Code Querying
+
+You may expect a certain response code to be returned from your HTTP GET.
+To assert a specific code:
+
+    response.code.is 200
+or
+
+    response.code.is "400"
+
+### JSON Body Querying
+
+A JSON block can be queried into using dot notation.  For example:
+
+    { 
+      "data": {
+        "string": "STRING",
+        "array": [1, 2, 3, 4],
+        "nest": {
+          "hello": "world",
+          "nest2": {
+            "good": "bye!"
+          }
+        }
+      }
+    }
+
+To query the "nest2" field, you would say:
+
+    response.body.data.nest.nest2....
+
+Querying into an Array can be done a few ways:
+
+    response.body.data.array.first 
+or
+
+    response.body.data.array.last
+
+can be used to query the first and last item in the array.
+
+To query a specific item in an array, use it's index:
+
+    response.body.data.array[1]
+
+would query the array at index '1', which in this case is '2'
+
+You can use rubys `each` to iterate through an array as well:
+
+    response.body.data.array.each do |a|
+      a.is_an Integer
+    end
+
+This goes through the array and tests every item in it!
+
+## Assertions
+
+### is
+
+`is` assertions are used to compare exact values.
+  
+    "this".is "this"  => true
+    200.is "200"      => true
+    "this".is "that"  => false
+    
+### is_a, is_an
+  
+The `is_a` and `is_an` assertions are used to assert Type on a field:
+
+    "Hello, World!".is_a String   => true
+    3.14159265359.is_an Integer   => true
+    "Not an array!".is_an Array   => false
+
+### has_key, lacks_key
+
+The `has_key` and `lacks_key` assertions can be used to query if a certain field
+is present in a JSON block:
+
+    { "here": "present!" }.has_key "here"   => true
+    { "here": "present!" }.has_key "nope!"  => false
+
+    { "here": "present!" }.lacks_key "nope!"  => true
+    { "here": "present!" }.lacks_key "here"   => false
+
+### has_keys
+
+`has_keys` works the same as `has_key`, except it takes multiple keys and test them all at once:
+
+    { "here": "present!", "hello": "world!" }.has_keys "here","hello" => true
+    { "here": "present!", "hello": "world!" }.has_keys "here","hope" => false
+
+### matches
+
+`matches` expectes a Regex formed value.
+
+    "hello".matches /ll/    => true
+
+### includes
+
+`includes` can be used for array to query if specific values are present:
+
+    [1,2,3,4].includes 2    => true
+
+### not_nil?
+
+`not_nil?` checks to see if the value is nil:
+
+    nil.not_nil?          => false
+    "something".not_nil?  => true
+
+### stripped?
+
+`stripped?` will test is there is whitespace before or after a string:
+
+    "works".stripped?     => true
+    " spaces ".stripped?  => false
+
+## Testing
+
+Api-PI is testing using Ruby's MiniTest framework.  To run tests:
+
+    $ rake
+
+To-Do
+-----
+
+* Ability to basic_auth before GET request
+

data/Rakefile

@@ -0,0 +1,20 @@
+require 'rake/testtask'
+
+task :test => ["test:all","test:unit"]
+
+task :default => "test:all"
+
+namespace :test do
+  desc "Run all tests"
+  Rake::TestTask.new(:all) do |t|
+    t.libs << "test"
+    t.test_files = FileList['test/*/test_*.rb']
+  end
+
+  desc "Run unit tests"
+  Rake::TestTask.new(:unit) do |t|
+    t.libs << "test"
+    t.test_files = FileList['test/unit/test_*.rb']
+    t.verbose = true
+  end
+end

data/api_pi.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require "api_pi/version"
+
+Gem::Specification.new do |g|
+  g.name    = 'api_pi'
+  g.version = ApiPi::VERSION
+
+  g.summary     = "API validation DSL"
+  g.description = "A ruby DSL to validate API requests."
+
+  g.authors = "Ben Woodall"
+  g.email   = "mail@benwoodall.com"
+
+  g.files      = `git ls-files`.split("\n")
+  g.test_files = `git ls-files -- test/*`.split("\n")
+
+  g.extra_rdoc_files = ["README.md"]
+  
+  g.add_dependency 'map', '~> 6.5'
+  g.add_development_dependency 'webmock', '~> 1.17'
+  g.add_development_dependency 'rake', '~> 10.1'
+end

data/example/apiary.rb

@@ -0,0 +1,30 @@
+require 'api_pi'
+
+set_header "api-pi-demo-header", "api-pi-example"
+
+get "http://apipi.apiary.io/tests" do
+
+  test "headers" do
+    response.header.contenttype.is "application/json"
+    response.code.is 200
+  end
+
+  test "body results.string" do
+    response.body.results.string.is_a String
+    response.body.results.string.matches /\w*/
+  end
+
+  test "results.int" do
+    response.body.results.int.is_an Integer
+  end
+
+  test "results" do
+    response.body.results.has_key "string"
+    response.body.results.lacks_key "nope"
+    response.body.results.has_keys "string","int","here","array"
+  end
+
+  test "results.array" do
+    response.body.results.array.includes 4
+  end
+end

data/lib/api_pi.rb

@@ -0,0 +1,13 @@
+require 'api_pi/case'
+require 'api_pi/request'
+require 'api_pi/dsl'
+require 'api_pi/assertion'
+require 'api_pi/version'
+
+module ApiPi
+  
+  # Build Headers, setting default User-Agent.
+
+  HEADER = { "user-agent" => "ApiPi-v#{ApiPi::VERSION}"}
+
+end

data/lib/api_pi/assertion.rb

@@ -0,0 +1,127 @@
+module ApiPi
+  class AssertionError < Exception;end
+end
+
+# Patches created to write test assertions
+
+class Object
+
+  # `check_if` is used to build assertions.  Create your own with it!
+
+  def check_if test, msg=nil
+    msg ||= "I don't know about that"
+    unless test then
+      raise ApiPi::AssertionError, msg
+    end
+    true
+  end
+  
+  # `is` assertions are used to compare exact values.
+  #   
+  #     "this".is "this"  => true
+  #     200.is "200"      => true
+  #     "this".is "that"  => false
+  
+  def is this
+    msg = "#{self} is not #{this}"
+    if this.is_a? Integer
+      check_if self == this.to_s, msg
+    else
+      check_if self == this, msg
+    end
+  end
+
+  # The `is_a` and `is_an` assertions are used to assert Type on a field:
+  # 
+  #     "Hello, World!".is_a String   => true
+  #     3.14159265359.is_a Float      => true
+  #     "Not an array!".is_an Array   => false
+  
+  def is_a klass
+    msg = "#{self} is not a #{klass}"
+    check_if self.is_a?(klass), msg 
+  end
+  alias :is_an :is_a
+
+  # The `has_key` assertion can be used to query if a certain
+  # field is present in a JSON block:
+  # 
+  #     { "here": "present!" }.has_key "here"   => true
+  #     { "here": "present!" }.has_key "nope!"  => false
+  
+  def has_key kkey
+    msg = "#{kkey} was not found in #{self.keys.join(', ')}}"
+    check_if self.respond_to?(kkey), msg
+  end
+
+  # The `has_keys` assertion works the same as `has_key`, except it takes 
+  # multiple keys and tests them all at once:
+  #
+  #     { "here": "present!", "hello": "world!" }.has_keys "here","hello" => true
+  #     { "here": "present!", "hello": "world!" }.has_keys "here","hope" => false
+
+  def has_keys *kkeys
+    not_found = []
+    kkeys.each do |k|
+      unless self.respond_to?(k)
+        not_found << k
+      end
+    end
+    if not_found.empty?
+      true
+    else
+      nf = not_found.join(", ")
+      msg = "#{nf} were not found in #{self.keys.join(', ')}" 
+      raise ApiPi::AssertionError, msg
+    end
+  end
+
+  # `lacks_key` is the opposite of `has_key`, in that it tests that a
+  # field is NOT present in a JSON block:
+  #
+  #     { "here": "present!" }.lacks_key "nope!"  => true
+  #     { "here": "present!" }.lacks_key "here"   => false
+
+  def lacks_key kkey
+    msg = "#{kkey} was found in #{self.keys.join(', ')}}"
+    check_if !self.respond_to?(kkey), msg
+  end
+
+  # `matches` expectes a Regex formed value.
+  # 
+  #     "hello".matches /ll/    => true
+
+  def matches regex
+    msg = "#{self} did not match regex #{regex}"
+    check_if self.match(regex), msg
+  end
+
+  # `includes` can be used for array to query if specific values are present:
+  # 
+  #     [1,2,3,4].includes 2    => true
+
+  def includes item
+    msg = "#{self} did not include #{item}"
+    check_if self.include?(item), msg
+  end
+
+  # `not_nil?` checks to see if the value is nil:
+  # 
+  #     nil.not_nil?          => false
+  #     "something".not_nil?  => true
+
+  def not_nil?
+    msg = "#{self} was nil/null"
+    check_if !self.nil?, msg
+  end
+
+  # `stripped?` will test is there is whitespace before or after a string:
+  # 
+  #     "works".stripped?     => true
+  #     " spaces ".stripped?  => false
+  
+  def stripped?
+    msg = "#{self} contains whitespace"
+    check_if(self.strip == self, msg)
+  end
+end

data/lib/api_pi/case.rb

@@ -0,0 +1,54 @@
+module ApiPi
+  class Case
+
+    attr_reader :tests, :url
+    def initialize(url, tests)
+      @tests = tests
+      @url = url
+      @success_count = 0
+      @failure_count = 0
+    end
+
+    # Begin investigating each GET request and their tests.
+
+    def investigate
+      puts "\nRequesting JSON from #{url} and testing"
+      tests.each_pair do |test, block|
+        print " - #{test}\n"
+        check test, block
+      end
+      summary
+      exit_status
+    end
+
+    private
+
+      # Runs tests and returns the results from the assertions.
+
+      def check test, block
+        res = []
+        begin
+          block.call
+        rescue ApiPi::AssertionError => e
+          res << e.message
+        end
+        failed = !res.empty?
+        failed ? @failure_count += 1 : @success_count += 1
+        puts "\tERROR: #{res.first}\n" if failed
+      end
+
+      # Text output from results of #check.
+
+      def summary
+        s = tests.keys.size
+        puts "\n#{s} tests, #{@success_count} succeeded, #{@failure_count} failed"
+      end
+
+      # Exit api_pi with a status of 1 if there are any failed tests.
+      # Exit witha  status of 0 if all tests succeeded.
+
+      def exit_status
+        @failure_count == 0 ? exit(0) : exit(1)
+      end
+  end
+end

data/lib/api_pi/dsl.rb

@@ -0,0 +1,37 @@
+require 'map'
+
+module ApiPi
+  class Dsl
+
+    attr_reader :response, :tests
+
+    def initialize response
+      @tests = {}
+      @response = Map.new(response)
+    end
+
+    def parse url, block
+      self.instance_eval(&block)
+      pi = ApiPi::Case.new(url, tests)
+      pi.investigate
+    end
+
+    # Test blocks are used to group similar assertions into readable units.  
+    # 
+    # For example, you may want to put your header tests into one test block:
+    # 
+    #     get 'example.com/user.json' do
+    #       test 'Headers have correct data' do
+    #         # You header assertions...
+    #       end
+    #     end
+    # 
+    # Inside of the test block, you would then put your header assertions.
+    # onceyou run your tests, your test blocks are grouped together and 
+    # pass/fail based on  assertions in the test block.
+
+    def test desc, &block
+      @tests[desc] = block
+    end
+  end
+end

data/lib/api_pi/request.rb

@@ -0,0 +1,55 @@
+require 'net/http'
+require 'json'
+
+module Kernel
+
+  # Patch to add the `get` method. Create tests and assertions within.
+
+  def get url, &block
+    uri = URI.parse url
+    get = Net::HTTP::Get.new(uri)
+    req = Net::HTTPHeader.build_headers get
+    resp = Net::HTTP.start(uri.host, uri.port) { |http| http.request(req) }
+    json = net_parse resp
+    ApiPi::Dsl.new(json).parse(url, block)
+  end
+
+  # Used to set headers for GET requests.
+
+  def set_header key, value
+    ApiPi::HEADER.merge!( { key => value } )
+  end
+
+  private
+   
+    # Groups all of the response parsing
+
+    def net_parse response
+      body   = { body: JSON.load(response.body) }
+      header = { header: response.to_dhash }
+      code   = { code: response.code }
+      body.merge!(header).merge!(code)
+    end
+end
+
+module Net::HTTPHeader
+
+  # Adds request headers from ApiPi::HEADER
+  def self.build_headers http_request
+    ApiPi::HEADER.each do |k,v|
+      http_request.add_field k, v
+    end
+    http_request
+  end
+
+  # Rebuild headers without dashes, which break JSON mapping.
+
+  def to_dhash
+    head = {}
+    self.each_header do |k,v|
+      new_hash = Hash[k.gsub('-',''), v]
+      head.merge!(new_hash)
+    end
+    head
+  end
+end

data/lib/api_pi/version.rb

@@ -0,0 +1,3 @@
+module ApiPi
+  VERSION = '0.2.2'
+end

data/test/test_helper.rb

@@ -0,0 +1,14 @@
+require 'minitest/autorun'
+require 'webmock/minitest'
+require 'api_pi'
+
+module ApiPi
+  class TestCase < MiniTest::Unit::TestCase
+
+    def setup
+      map = { k: "v", a: [1,2,3], m: 1 }
+      @map = Map.new(map)
+    end
+
+  end
+end

data/test/unit/test_assertions.rb

@@ -0,0 +1,101 @@
+require 'test_helper'
+
+module ApiPi
+  class TestAssertions < TestCase
+    
+    def test_patch_methods
+      assert Object.respond_to?(:check_if), Object.check_if(true, "Yep")
+      assert Object.respond_to?(:is), Object.is(Object) 
+      assert Object.respond_to?(:is_a), @map.k.is_a(String)
+      assert Object.respond_to?(:is_an), Object.is_an(Object)
+      assert Object.respond_to?(:has_key), @map.has_key(:k)
+      assert Object.respond_to?(:has_keys), @map.has_keys(:k,:m)
+      assert Object.respond_to?(:lacks_key), @map.lacks_key(:v)
+      assert Object.respond_to?(:matches), "string".matches(/.*/)
+      assert Object.respond_to?(:includes), [1,2,3].includes(2)
+      assert Object.respond_to?(:not_nil?), "not_nil".not_nil?
+      assert Object.respond_to?(:stripped?), "stripped".stripped?
+    end
+
+    def test_check_if__with_true
+      assert check_if(true)
+    end
+
+    def test_check_if__with_false
+      assert_raises(ApiPi::AssertionError) { check_if false }
+    end
+
+    def test_is__with_true
+      assert "this".is("this")
+    end
+
+    def test_is__with_false
+      assert_raises(ApiPi::AssertionError) { "this".is("that") }
+    end
+
+    def test_is__with_integers
+      assert "200".is(200)
+    end
+
+    def test_is_a__with_true
+      assert "string".is_a(String) 
+    end
+
+    def test_is_a__with_false
+      assert_raises(ApiPi::AssertionError) { "string".is_a(Integer) }
+    end
+
+    def test_has_key__with_true
+      assert @map.has_key(:k)
+    end
+
+    def test_has_key__with_false
+      assert_raises(ApiPi::AssertionError) { @map.has_key(:n) }
+    end
+
+    def test_has_keys__with_true
+      assert @map.has_keys(:k,:m)
+    end
+
+    def test_has_keys__with_false
+      assert_raises(ApiPi::AssertionError) { @map.has_keys(:n,:r) } 
+    end
+
+    def test_lacks_key__with_true
+      assert @map.lacks_key(:n)
+    end
+
+    def test_lacks_key__with_false
+      assert_raises(ApiPi::AssertionError) { @map.lacks_key(:k) }
+    end
+
+    def test_matches__with_true
+      assert @map.k.matches(/v/)
+    end
+
+    def test_matches__with_false
+      assert_raises(ApiPi::AssertionError) { @map.k.matches(/\d/) }
+    end
+
+    def test_includes__with_true
+      assert @map.a.includes(1)
+    end
+
+    def test_includes__with_false
+      assert_raises(ApiPi::AssertionError) { @map.a.includes("n") }
+    end
+
+    def test_not_nil__with_nil
+      assert_raises(ApiPi::AssertionError) { nil.not_nil? }
+    end
+
+    def test_not_nil__with_not_nil
+      assert "not_nil".not_nil?
+    end
+
+    def test_stripped?
+      assert "stripped".stripped?
+      assert_raises(ApiPi::AssertionError) { " not_stripped ". stripped? }
+    end
+  end
+end

data/test/unit/test_dsl.rb

@@ -0,0 +1,16 @@
+require 'test_helper'
+
+module ApiPi
+  class TestDsl < TestCase
+
+    def test_response_gathering
+      r = ApiPi::Dsl.new(t:'t')
+      r.test "metadata" do 
+        "test".is_a(String)
+      end
+      assert r.tests.has_key?('metadata'), r.tests['metadata']
+      assert_kind_of Proc, r.tests['metadata']
+    end
+
+  end
+end

data/test/unit/test_requests.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+
+module ApiPi
+  class TestRequests < TestCase
+
+    def setup
+      @good_url = "http://test-service.com/200.json"
+      @good_header = { 'Content-Type' => 'application/json' }
+      stub_request(:get, @good_url)
+                  .to_return(status: 200, body: "", headers: @good_header)
+    end
+
+    def test_kernel_responds_to_get
+      assert Kernel.respond_to?(:get)
+    end
+
+    def test_kernel_responds_to_set_header
+      assert Kernel.respond_to?(:set_header)
+    end
+
+    def test_set_header
+      set_header "User-Agent", "Api-Pi Test"
+      set_header "Not-A-Field", "But-I-Work"
+      assert ApiPi::HEADER.has_key?("User-Agent")
+      assert ApiPi::HEADER.has_key?("Not-A-Field")
+    end
+
+    def test_dhash
+      resp = Net::HTTP.get_response(URI(@good_url))
+      header = resp.to_dhash
+      assert header.has_key?('contenttype')
+    end
+  end
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: api_pi
+version: !ruby/object:Gem::Version
+  version: 0.2.2
+platform: ruby
+authors:
+- Ben Woodall
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: map
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '6.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '6.5'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.1'
+description: A ruby DSL to validate API requests.
+email: mail@benwoodall.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- .gitignore
+- .ruby-version
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- api_pi.gemspec
+- example/apiary.rb
+- lib/api_pi.rb
+- lib/api_pi/assertion.rb
+- lib/api_pi/case.rb
+- lib/api_pi/dsl.rb
+- lib/api_pi/request.rb
+- lib/api_pi/version.rb
+- test/test_helper.rb
+- test/unit/test_assertions.rb
+- test/unit/test_dsl.rb
+- test/unit/test_requests.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: API validation DSL
+test_files:
+- test/test_helper.rb
+- test/unit/test_assertions.rb
+- test/unit/test_dsl.rb
+- test/unit/test_requests.rb