flunk 0.0.1

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Mysterious Trousers, LLC (http://www.mysterioustrousers.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,298 @@
+Flunk
+=====
+
+A gem for testing a Ruby on Rails web APIs by simulating a client.
+
+
+### Installation
+
+In your Gemfile, add this line:
+
+    gem "flunk"
+
+### Description
+
+We write mostly JSON APIs using Rails, not your traditional web app, so we wanted a better way to test our JSON APIs. This is flunk.
+
+### Usage
+
+In each test block you call a series of methods [`desc`, `path`, `method`, `username`, `password`, `body`, `status`, `assertions`] as necessary.
+
+`desc`: In the future, a documentation generator will be added and this will be used to determine if the test should be documented as an API method.
+`path`: The relative URL for the resource.
+`method`: :get, :post, :put or :delete
+`username`: For authentication using basic auth.
+`password`: For authentication using basic auth.
+`body`: The body of the request.
+`status`: This method actually acts like an assertion. It is what the status of the response SHOULD be. An error will be thrown if it doesn't match.
+`assertions`: A block of of assertions you call to verify the response was what it should have been.
+
+Once you call `assertions`, the request is fired and a `result` method is available within the assertions block containing the response.
+
+### Example
+
+It's your typical rails integration test, but inherits from Flunk:
+
+    class UsersTest < Flunk
+    
+      setup do
+      	@user = FactoryGirl.create(:user)
+      end
+
+You write tests that SHOULD pass to test your app's basic functionality all works:
+
+      test "Create User" do
+        desc      "Creating a new Langwich user."
+      	path			"signup"
+      	method		:post
+      	body			user: attrs = FactoryGirl.attributes_for(:user)
+      	status		:created
+        assertions {
+          assert_equal result[:name],       attrs[:name]
+          assert_equal result[:username],   attrs[:username]
+          assert_equal result[:email],      attrs[:email]
+          assert_not_nil result[:api_token]
+          user = User.find_by_api_token result[:api_token]
+          assert_equal 1, user.languages.count
+        }
+      end
+      
+      test "Log In" do
+        desc      "Obtain a users API token by logging in with their username and password"
+      	path			"login"
+      	method		:get
+      	body			username: @user.username, password: @user.password
+      	status		:ok
+        assertions {
+          assert_not_nil result[:api_token]
+        }
+      end
+      
+      test "Log In With Email" do
+      	path			"login"
+      	method		:get
+      	body			username: @user.email, password: @user.password
+      	status		:ok
+        assertions {
+          assert_not_nil result[:api_token]
+        }
+      end
+      
+      test "Read User" do
+        desc      "Read a users information."
+        path      "account"
+        method    :get
+        username  @user.api_token
+        status    :ok
+      end
+      
+      test "Update User" do
+        desc      "Update the username, e-mail, password and/or name"
+        path      "account"
+        method    :put
+        username  @user.api_token
+        body      user: { username: username = Faker::Internet.user_name }
+        status    :ok
+        assertions {
+          assert_equal result[:username], username
+        }
+      end
+      
+      test "Update E-mail" do
+        path      "account"
+        method    :put
+        username  @user.api_token
+        body      user:  { email: email = Faker::Internet.email }
+        status    :ok
+        assertions {
+          assert_equal result[:email], email
+        }
+      end
+      
+      test "Update User Password" do
+        path      "account"
+        method    :put
+        username  @user.api_token
+        body      user: { password: Faker::Lorem.characters(10) }
+        status    :ok
+      end
+      
+      test "Update Name" do
+        path      "account"
+        method    :put
+        username  @user.api_token
+        body      user: { name: name = Faker::Name.first_name }
+        status    :ok
+        assertions {
+          assert_equal result[:name], name
+        }
+      end
+      
+      test "Delete User" do
+        path      "account"
+        method    :delete
+        username  @user.api_token
+        status    :ok
+      end
+      
+
+
+Then, write tests that SHOULDN'T pass to make sure your app rejects bad requests correctly/gracefully:
+
+      
+      flunk "Create User", "Missing username" do
+        desc      "Attempting to create a user without a username."
+        path      "signup"
+        method    :post
+        body      user: FactoryGirl.attributes_for(:user, username: nil)
+        status    :unprocessable_entity
+      end
+      
+      flunk "Create User", "Username already taken" do
+        path      "signup"
+        method    :post
+        body      user: FactoryGirl.attributes_for(:user, username: @user.username)
+        status    :unprocessable_entity
+      end
+      
+      flunk "Create User", "Invalid username" do
+        path      "signup"
+        method    :post
+        body      user: FactoryGirl.attributes_for(:user, username: "a234$2aa" )
+        status    :unprocessable_entity
+      end
+      
+      flunk "Create User", "Missing e-mail" do
+        desc      "Attempting to create a user without a e-mail."
+        path      "signup"
+        method    :post
+        body      user: FactoryGirl.attributes_for(:user, email: nil)
+        status    :unprocessable_entity
+      end
+      
+      flunk "Create User", "E-mail already taken" do
+        desc      "Attempting to create a user with an e-mail that's already taken."
+        path      "signup"
+        method    :post
+        body      user: FactoryGirl.attributes_for(:user, email: @user.email)
+        status    :unprocessable_entity
+      end
+      
+      flunk "Create User", "Invalid e-mail" do
+        path      "signup"
+        method    :post
+        body      user: FactoryGirl.attributes_for(:user, email: "aaaa@aakk")
+        status    :unprocessable_entity
+      end
+      
+      flunk "Create User", "Missing password" do
+        desc      "Attempting to create a user without a password."
+        path      "signup"
+        method    :post
+        body      user: FactoryGirl.attributes_for(:user, password: nil)
+        status    :unprocessable_entity
+      end
+      
+      flunk "Create User", "Missing name" do
+        path      "signup"
+        method    :post
+        body      user: FactoryGirl.attributes_for(:user, name: nil)
+        status    :unprocessable_entity
+      end
+      
+      
+      
+      
+      flunk "Log In", "No username" do
+        desc       "Attempting to obtain an API token with the wrong password"
+        path       "login"
+        method     :get
+        body       password: "a"
+        status     :unauthorized
+      end
+      
+      flunk "Log In", "Wrong password" do
+        desc       "Attempting to obtain an API token with the wrong password"
+        path       "login"
+        method     :get
+        body       username: @user.username, password: "a"
+        status     :unauthorized
+      end
+      
+      
+      
+      
+      flunk "Read User", "Wrong API token" do
+        path       "login"
+        method     :get
+        username   "a"
+        status     :unauthorized
+      end
+      
+      
+      
+      
+      flunk "Update User", "Wrong password" do
+        path      "account"
+        method    :put
+        username  "a"
+        body      user: FactoryGirl.attributes_for(:user)
+        status    :unauthorized
+      end
+      
+      flunk "Update User", "Username already taken" do
+        path      "account"
+        method    :put
+        username  @user.api_token
+        u = FactoryGirl.create(:user)
+        body      user: { username: u.username }
+        status    :unprocessable_entity
+      end
+      
+       flunk "Update User", "Invalid username" do
+        path      "account"
+        method    :put
+        username  @user.api_token
+        body      user: { username: "a234$2aa" }
+        status    :unprocessable_entity
+      end
+      
+      flunk "Update User", "E-mail already taken" do
+        desc      "Attempting to update a user with an e-mail that's already taken."
+        path      "account"
+        method    :put
+        username  @user.api_token
+        u = FactoryGirl.create(:user)
+        body      user: { email: u.email }
+        status    :unprocessable_entity
+      end
+      
+      flunk "Update User", "Invalid e-mail" do
+        desc      "Attempting to update the user with an invalid e-mail"
+        path      "account"
+        method    :put
+        username  @user.api_token
+        body      user: { email: "aaaa@aakk" }
+        status    :unprocessable_entity
+      end
+      
+        
+      
+      
+      flunk "Delete User", "Wrong password" do
+        path      "account"
+        method    :delete
+        username  "a"
+        body      user: FactoryGirl.attributes_for(:user)
+        status    :unauthorized
+      end
+      
+    end
+
+### Generator
+
+To generate a flunk test:
+
+    rails g generate flunk_test User
+
+This will create an integration test: test/integration/users_test.rb

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/flunk.gemspec

@@ -0,0 +1,14 @@
+Gem::Specification.new do |s|
+  s.name                = "flunk"
+  s.version             = "0.0.1"
+  s.platform            = Gem::Platform::RUBY
+  s.authors             = ["Adam Kirk"]
+  s.email               = %q{atomkirk@gmail.com}
+  s.homepage            = %q{https://github.com/mysterioustrousers/flunk}
+  s.summary             = %q{A gem for testing a Ruby on Rails web APIs by simulating a client.}
+  s.description         = %q{A gem for testing a Ruby on Rails web APIs by simulating a client.}
+
+  s.files               = `git ls-files`.split("\n").reject {|path| path =~ /\.gitignore$/ }
+  s.test_files          =`git ls-files -- test/*`.split("\n")
+  s.require_paths       = ["lib"]
+end

data/lib/flunk.rb

@@ -0,0 +1,100 @@
+class Flunk < ActionDispatch::IntegrationTest
+
+  def self.test(name, &block)
+    new_proc = Proc.new do
+      instance_eval(&block)
+      result
+      @assertions.call unless @assertions.nil?
+    end
+
+    super name, &new_proc
+  end
+
+  def self.flunk(action, failure_reason, &block)
+    test("FLUNKED: #{action} (#{failure_reason})", &block)
+  end
+
+  def result
+    if !@result_fetched
+      @result_fetched = true
+
+      if (@username || @password)
+        @headers ||= {}
+        @headers["HTTP_AUTHORIZATION"] = "Basic #{Base64.encode64(@username.to_s + ":" + @password.to_s)}".strip
+      end
+
+      send @method, @path, @body, @headers
+
+      @response = response
+
+      assert_response @status
+
+      if response.body.length > 2
+        if response.content_type == 'application/json'
+          json = ActiveSupport::JSON.decode(response.body)
+          rec_symbolize( json )
+          @result = json
+        end
+      end
+    end
+
+    @result
+  end
+
+  def path(path)
+    @path = path
+  end
+
+  def method(method)
+    @method = method
+  end
+
+  def username(username)
+    @username = username
+  end
+
+  def password(password)
+    @password = password
+  end
+
+  def ssl(ssl)
+    @ssl = ssl
+  end
+
+  def body(body)
+    @body = body
+  end
+
+  def header(key, value)
+    @headers ||= {}
+    @headers[key] = value
+  end
+
+  def param(key, value)
+    @params ||= {}
+    @params[key] = value
+  end
+
+  def status(status)
+    @status = status
+  end
+
+  def desc(desc)
+    @desc = desc
+  end
+
+  def assertions(&block)
+    @assertions = block
+  end
+
+  def rec_symbolize(obj)
+    if obj.class == Hash
+      obj.symbolize_keys!
+      obj.map {|k,v| rec_symbolize(v) }
+    elsif obj.class == Array
+      obj.map {|v| rec_symbolize(v) }
+    end
+    nil
+  end
+
+end

data/lib/generators/flunk_test/USAGE

@@ -0,0 +1,8 @@
+Description:
+    This generates an flunk rails integration test.
+
+Example:
+    rails generate flunk_test Title
+
+    This will create:
+      test/integration/titles_test.rb

data/lib/generators/flunk_test/flunk_test_generator.rb

@@ -0,0 +1,7 @@
+class FlunkTestGenerator < Rails::Generators::NamedBase
+  source_root File.expand_path('../templates', __FILE__)
+
+  def create_test_file
+      template "flunk_test.rb", "test/integration/#{file_name.pluralize}_test.rb"
+  end
+end

data/lib/generators/flunk_test/templates/flunk_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+
+class <%= class_name.pluralize %>Test < Flunk
+
+  setup do
+  end
+
+  # Write tests that should succeed to make sure the required functionality works.
+  test "Test Title" do
+    desc      "A description of the function this tests"
+    path      "resource/:id"
+    method    :get
+    username  @user.username
+    password  @user.password
+    status    :ok
+    assertions {
+      assert_equal 2, 2
+    }
+  end
+
+
+  # Write a test that SHOULD fail to ensure your application handles bad requests gracefully.
+  flunk "Test Title", "Why it flunks" do
+    path      "/resource/:id"
+    method    :get
+    status    :unauthorized
+  end
+
+end

data/lib/tasks/flunk.rake

@@ -0,0 +1,2 @@
+task flunk: ["test:integration"] do
+end

data/test/test_flunk.rb

@@ -0,0 +1,6 @@
+require 'test/unit'
+require 'flunk'
+
+class FlunkTest < Test::Unit::TestCase
+
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: flunk
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Adam Kirk
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-01 00:00:00.000000000 Z
+dependencies: []
+description: A gem for testing a Ruby on Rails web APIs by simulating a client.
+email: atomkirk@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- flunk-0.0.1.gem
+- flunk.gemspec
+- lib/flunk.rb
+- lib/generators/flunk_test/USAGE
+- lib/generators/flunk_test/flunk_test_generator.rb
+- lib/generators/flunk_test/templates/flunk_test.rb
+- lib/tasks/flunk.rake
+- test/test_flunk.rb
+homepage: https://github.com/mysterioustrousers/flunk
+licenses: []
+post_install_message: 
+rdoc_options: []
+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.24
+signing_key: 
+specification_version: 3
+summary: A gem for testing a Ruby on Rails web APIs by simulating a client.
+test_files:
+- test/test_flunk.rb