alfred_rails 0.0.1.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5aa092990a0c15473f2de135190053a555556beb
+  data.tar.gz: 4c733b4d2437fc8bcb064be5f7b6e0c45e4a8652
+SHA512:
+  metadata.gz: 287ec639bca0ca48c0bf5f0690848f8888b271850856f86f6ad2c207a593925c966b16b515bbab5f481256d65a1e5cb807cf0252f292ee151020474485456309
+  data.tar.gz: a92f6780d2ee432c6ec1bf77c44d3db50ed9bf4b0caa89afed01e76f9cb7706231435fa3a4462cc5b4ac5e1fb93e4bdbdcb4c9cce7fa4d742f9889017b0f5041

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.DS_Store
+database.sqlite
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,20 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.1
+  - ruby-head
+
+env:
+  - "RAILS_VERSION=3.1.0"
+  - "RAILS_VERSION=3.2.0"
+  - "RAILS_VERSION=4.0.0"
+  - "RAILS_VERSION=4.1.0"
+  - "RAILS_VERSION=master"
+
+matrix:
+  allow_failures:
+    - env: "RAILS_VERSION=master"
+    - rvm: ruby-head
+
+script: "bundle exec teaspoon && rake"

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in alfred_rails.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Johan van Zonneveld
+
+MIT License
+
+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,209 @@
+## Alfred Rails
+
+[![Gem Version](http://img.shields.io/gem/v/alfred_rails.svg)][gem]
+[![Build Status](http://img.shields.io/travis/jhnvz/alfred_rails.svg)][travis]
+[![Coverage Status](http://img.shields.io/coveralls/jhnvz/alfred_rails.svg)][coveralls]
+[![Code Climate](http://img.shields.io/codeclimate/github/jhnvz/alfred_rails.svg)][codeclimate]
+[![Dependency Status](http://img.shields.io/gemnasium/jhnvz/alfred_rails.svg)][gemnasium]
+
+[gem]: https://rubygems.org/gems/alfred_rails
+[travis]: http://travis-ci.org/jhnvz/alfred_rails
+[coveralls]: https://coveralls.io/r/jhnvz/alfred_rails
+[codeclimate]: https://codeclimate.com/github/jhnvz/alfred_rails
+[gemnasium]: https://gemnasium.com/jhnvz/alfred_rails
+
+Serves controller action responses under several conditions.
+
+How it works
+------------
+
+Alfred creates fixture files of your controller responses so you can use them in your tests. Ideal if your app's client is build with a javascript framework and you want to test responses under several conditions.
+
+Resources
+------------
+
+- [Installation](#installation)
+- [Defining scenario's](#defining-scenarios)
+- [Configuration](#configuration)
+- [Javascript testing](#javascript-testing)
+- [Guard](#guard)
+
+Installation
+------------
+
+1. Add `gem 'alfred_rails'` to your Gemfile (inside test group).
+2. Run `bundle install`.
+3. Run `rails g alfred:install`.
+
+Defining scenario's
+------------
+
+You can create empty definitions by running: 
+```
+$ rails g alfred:controller api/v1/posts
+```
+
+Here's an example of a definition:
+```ruby
+# spec/alfreds/api/v1/posts_controller.rb
+
+Alfred.define do
+  setup do
+    sign_in :user, create(:user)
+  end
+
+  controller Api::V1::PostsController do
+    scenario 'update post by manager' do
+      setup do
+        create(:post, :title => 'Alfred is awesome', :body => 'It saves me time')
+      end
+
+      patch :update, {
+        :format => :json,
+        :id     => 1,
+        :post   => {
+          :title => 'Alfred rocks!'
+        }
+      }
+    end
+  end
+
+  scenario 'update post by manager' do
+    controller Api::V1::PostsController
+  end
+end
+```
+
+This will create a fixture file which you can use in your javascript tests at:
+```
+spec/javascripts/fixtures/api/v1/posts/update/update_by_manager.js
+```
+
+Configuration
+------------
+
+```ruby
+# spec/alfred_helper.rb
+
+Alfred.configure do |config|
+  ## Includes
+  config.include FactoryGirl::Syntax::Methods
+  config.include Devise::TestHelpers
+
+  ## Setup
+  config.setup do
+    Apartment::Database.stub(:create).and_return(true)
+  end
+  
+  ## Mocking framework
+  config.mock_with :rspec
+  
+  ## Fixture path
+  config.fixture_path 'spec/javascripts/fixtures'
+end
+```
+
+Configuration instructions
+
+Javascript testing
+------------
+
+After defining and generating Alfred fixtures they are accessible in your JavaScript tests.
+
+```coffeescript
+# Get request response
+Alfred.serve('posts_controller/update', 'update post by manager')
+
+# Example of a test
+describe 'PostModel', ->
+
+  describe '#update', ->
+
+    it 'should update model', ->
+      response  = Alfred.serve('posts_controller/update', 'update post by manager')
+      @server   = sinon.fakeServer.create()
+
+      @server.respondWith 'PATCH', 'posts/1', [200, { 'Content-Type': 'application/json' }, response]
+
+      @post.update()
+      @server.respond()
+
+      @post.updated().should.equal(true)
+```
+
+Implementation on this differs on which libraries you are using to test with. In the above example we're using SinonJS to create a fake server response.
+
+### SinonJS adapter
+
+```coffeescript
+# Creates fake server and calls respondWith
+Alfred.SinonAdapter.serve('posts_controller/update', 'update post by manager')
+
+# Example of a test
+describe 'PostModel', ->
+
+  describe '#update', ->
+
+    it 'should update model', ->
+      @server = Alfred.SinonAdapter.serve('posts_controller/update', 'update post by manager')
+
+      @post.update()
+      @server.respond()
+
+      @post.updated().should.equal(true)
+```
+
+### Using any other test adapter
+
+By calling `Alfred.fetch` you can fetch a scenario object with meta data, such as path, request method etc. This can be useful when stubbing a request;
+
+```coffeescript
+Alfred.fetch('posts/update', 'update post by manager') # => Object
+```
+
+Guard
+------------
+
+Add the gem to your Gemfile (inside development group):
+``` ruby
+ gem 'guard-alfred', :require => false
+```
+
+Add guard definition to your Guardfile by running this command:
+```
+$ guard init alfred
+```
+
+Make sure to put this block on top of your Guardfile so all fixtures are created before running tests.
+```ruby
+guard :alfred do
+  watch(%r{^app/controllers/(.+)\.rb$}) { |m| "spec/alfreds/#{m[1]}.rb" }
+  watch(%r{^spec/alfreds/(.+)\.rb$})    { |m| "spec/alfreds/#{m[1]}.rb" }
+end
+```
+Please read [Guard usage doc](https://github.com/guard/guard#readme) for usage instructions.
+
+Supported Ruby Versions
+------------
+
+This library is tested against Travis and aims to support the following Ruby
+implementations:
+
+* Ruby 1.9.3
+* Ruby 2.0.0
+* Ruby 2.1.1
+
+Contributing
+------------
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+Copyright
+------------
+
+Copyright (c) 2014 Johan van Zonneveld. See LICENSE for details.
+

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/alfred_rails.gemspec

@@ -0,0 +1,45 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'alfred_rails/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "alfred_rails"
+  gem.version       = Alfred::VERSION
+  gem.authors       = ['Johan van Zonneveld', 'Arjen Oosterkamp']
+  gem.email         = ['johan@vzonneveld.nl', 'mail@arjen.me']
+  gem.homepage      = 'https://github.com/jhnvz/alfred_rails.git'
+  gem.summary       = %q{Serves controller responses under several conditions.}
+  gem.description   = %q{Alfred creates fixture files of your controller responses so you can use them in your tests. Ideal if your app's client is build with a javascript framework and you want to test responses under several conditions.}
+  gem.license       = 'MIT'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = ["alfred"]
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_development_dependency 'bundler', '>= 1.0.0'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'coveralls'
+  gem.add_development_dependency 'rspec', '>= 2.3'
+  gem.add_development_dependency 'rspec-rails', '~> 2.0'
+  gem.add_development_dependency 'batman-rails'
+  gem.add_development_dependency 'sqlite3'
+
+  gem.add_development_dependency 'teaspoon'
+  gem.add_development_dependency 'coffee-script'
+
+  gem.add_dependency 'database_cleaner'
+  gem.add_dependency 'ruby-progressbar'
+  gem.add_dependency 'ammeter'
+
+  if RUBY_VERSION > '1.9.2'
+    gem.add_dependency 'rails', '>= 3.2.0'
+  else
+    gem.add_dependency 'rails', '>= 3.2.0', '< 4.0.0'
+  end
+
+  if File.exists?('UPGRADING')
+    gem.post_install_message = File.read("UPGRADING")
+  end
+end

data/app/assets/javascripts/alfred/sinon_adapter.js.coffee

@@ -0,0 +1,35 @@
+class Alfred.SinonAdapter
+
+  ###*
+   * Serves an Alfred response server.
+   * @action {String} Controller and action
+   * @name {String} Name of the scenario
+   *
+   * @example
+   * server = Alfred.SinonAdapter.serve('sessions/current', 'default')
+   * server.respond()
+   *
+   * @returns
+   * {Object} Sinon FakeServer
+   *
+   ###
+  @serve: (action, name, path) ->
+    scenario  = Alfred.fetch(action, name)
+    meta      = scenario.meta
+    path      ||= @_path(meta.path)
+
+    server = sinon.fakeServer.create()
+    server.respondWith meta.method, path, [meta.status, { 'Content-Type': meta.type }, scenario.response]
+
+    server
+
+  ###*
+   * Makes sure the path is correct, without starting slash
+   * @path {String} Path to correct
+   *
+   ###
+  @_path: (path) ->
+    if path[0] == '/'
+      path.slice(1, path.length)
+    else
+      path

data/app/assets/javascripts/alfred.js.coffee

@@ -0,0 +1,61 @@
+class @Alfred
+
+  @scenarios: {}
+
+  ###*
+   * Fetches an Alfred response.
+   * @action {String} Controller and action
+   * @name {String} Name of the scenario
+   *
+   * @example
+   * Alfred.fetch('sessions/current', 'default')
+   *
+   * @returns
+   * {Object} Scenario object
+   *
+   ###
+  @fetch: (action, name) ->
+    @scenarios[action]?[@_name(name)]
+
+  ###*
+   * Serves an Alfred response.
+   * @action {String} Controller and action
+   * @name {String} Name of the scenario
+   *
+   * @example
+   * Alfred.serve('sessions/current', 'default')
+   *
+   * @returns
+   * {String} Scenario response string
+   *
+   ###
+  @serve: (action, name) ->
+    @fetch(action, name)?.response
+
+  ###*
+   * Registers an Alfred response.
+   * @action {String} Controller and action
+   * @name {String} Name of the scenario
+   * @meta {Object} Meta data of the response
+   * @response {String} Scenario response
+   *
+   * @example
+   * Alfred.register({
+   *   action:   'sessions/current',
+   *   name:     'default',
+   *   meta:     { path: 'api/1/sessions', method: 'GET' },
+   *   response: @response
+   * })
+   *
+   ###
+  @register: (object) ->
+    @scenarios[object.action] ||= {}
+    @scenarios[object.action][object.name] = {
+      name:     object.name
+      action:   object.action
+      meta:     object.meta
+      response: object.response
+    }
+
+  @_name: (name) ->
+    name.replace(/\s+/g, '_').toLowerCase()

data/bin/alfred

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+root = File.expand_path('../../lib', __FILE__)
+$:.unshift(root) unless $:.include?(root)
+
+require "alfred_rails/command_line"
+Alfred::CommandLine.new

data/lib/alfred_rails/command_line.rb

@@ -0,0 +1,62 @@
+ENV["RAILS_ENV"] ||= 'test'
+
+require "optparse"
+
+module Alfred
+  class CommandLine
+
+    def initialize
+      @options = {}
+      @options[:files] = parse_options
+
+      load_rails!
+
+      require 'alfred_rails'
+      ::Alfred.load!
+
+      ::Alfred::Runner.new(@options[:files])
+    end
+
+    ##
+    # Add abort method in case input is aborted.
+    #
+    # :nocov:
+    def abort(message = nil)
+      STDOUT.print(message) if message
+      exit(1)
+    end
+    # :nocov:
+
+    private
+
+      ##
+      # Parses the options and returns the files if present.
+      #
+      # === Returns
+      #
+      # [files (Array)] the files to run
+      #
+      def parse_options
+        options = {}
+        OptionParser.new do |options|
+          options.banner = "Usage: alfred [options] [files]\n"
+
+          options.on "-v", "--version", "Display the version.", proc {
+            STDOUT.print("#{Alfred::VERSION}\n")
+            exit
+          }
+        end.parse!
+      end
+
+      ##
+      # Load Rails environment and Alfred.
+      #
+      # :nocov:
+      def load_rails!
+        load 'config/application.rb'
+        ::Rails.application.initialize!
+      end
+      # :nocov:
+
+  end # CommandLine
+end # Alfred

data/lib/alfred_rails/configuration.rb

@@ -0,0 +1,157 @@
+module Alfred
+  class Configuration
+
+    attr_accessor :config
+
+    def initialize
+      @config = {
+        :includes => [],
+        :setup    => []
+      }
+
+      load_defaults!
+    end
+
+    ##
+    # Set or get setup for each scenario.
+    #
+    # === Params
+    #
+    # [block (Block)] the block to perform
+    #
+    # === Example
+    #
+    #   setup
+    #     User.create(:name => 'John Doe')
+    #   end
+    #
+    #   setup #=> [Proc]
+    #
+    # === Returns
+    #
+    # [setup (Array)] array with blocks
+    #
+    def setup(&block)
+      return @config[:setup] unless block_given?
+      @config[:setup] << block
+    end
+
+    ##
+    # Include modules.
+    #
+    # === Params
+    #
+    # [mod (Module)] the module to include
+    #
+    # === Example
+    #
+    #   include Devise::TestHelpers
+    #
+    def include(mod)
+      @config[:includes] << mod
+    end
+
+    ##
+    # Returns array of the modules to include.
+    #
+    # === Returns
+    #
+    # [modules (Array)] the modules to include
+    #
+    def includes
+      @config[:includes]
+    end
+
+    ##
+    # Set or get the fixture path.
+    #
+    # === Params
+    #
+    # [path (String)] the path to set
+    #
+    # === Examples
+    #
+    #   fixture_path('spec/javascript/fixtures')
+    #   fixture_path #=> 'spec/javascript/fixtures'
+    #
+    # === Returns
+    #
+    # [path (String)] the fixture path
+    #
+    def fixture_path(path=nil)
+      return config[:fixture_path] if path.nil?
+      config[:fixture_path] = "#{::Rails.root}/#{path}"
+    end
+
+    ##
+    # Set or get the test path.
+    #
+    # === Params
+    #
+    # [path (String)] the path to set
+    #
+    # === Examples
+    #
+    #   test_path('spec')
+    #   test_path #=> 'spec'
+    #
+    # === Returns
+    #
+    # [path (String)] the fixture path
+    #
+    def test_path(path=nil)
+      return config[:test_path] if path.nil?
+      config[:test_path] = path
+    end
+
+    ##
+    # Set or get the mocking framework.
+    #
+    # === Params
+    #
+    # [framework (Symbol)] the mocking framework
+    #
+    # === Examples
+    #
+    #   mock_with :rspec
+    #   mock_with #=> :rspec
+    #
+    # === Returns
+    #
+    # [framework (Symbol)] mocking framework
+    #
+    def mock_with(framework=nil)
+      return config[:mock_with] if framework.nil?
+      config[:mock_with] = framework
+    end
+
+    private
+
+      ##
+      # Wheter rspec is defined.
+      #
+      def rspec_defined?
+        defined?(RSpec)
+      end
+
+      ##
+      # Loads defaults based on defined constants.
+      # It guesses fixture_path and mocking framework.
+      #
+      def load_defaults!
+        ## Guess test path
+        @config[:test_path] = rspec_defined? ? "spec" : "test"
+
+        ## Guess fixture_path
+        @config[:fixture_path] = "#{::Rails.root}/#{test_path}/javascripts/fixtures"
+
+        ## Guess mocking framework
+        @config[:mock_with] = if rspec_defined?
+          :rspec
+        else
+          :test_unit
+        end
+      end
+
+  end # Configuration
+end # Alfred