alfred_rails 0.0.1.alpha

data/spec/generators/controller/controller_generator_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'generators/alfred/controller/controller_generator'
+
+describe Alfred::Generators::ControllerGenerator do
+
+  destination File.expand_path("../../../../tmp", __FILE__)
+
+  before do
+    prepare_destination
+    run_generator %w(api/v1/posts)
+  end
+
+  subject { file('spec/alfreds/api/v1/posts_controller.rb') }
+
+  it 'should exist' do
+    subject.should exist
+  end
+
+  it 'should contain controller name' do
+    File.read(subject).should include('controller Api::V1::PostsController')
+  end
+
+end

data/spec/generators/install/install_generator_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+require 'generators/alfred/install/install_generator'
+
+describe Alfred::Generators::InstallGenerator do
+  destination File.expand_path("../../../../tmp", __FILE__)
+
+  before { prepare_destination }
+
+  it "generates spec/alfred_helper.rb" do
+    run_generator
+    file('spec/alfred_helper.rb').should exist
+  end
+
+  describe 'conditions' do
+
+    before(:each) do
+      stub_class = Alfred::Generators::InstallGenerator.any_instance
+      stub_class.stub(:mock_with).and_return(:rspec)
+      stub_class.stub(:devise_defined?).and_return(false)
+      stub_class.stub(:factory_girl_defined?).and_return(false)
+    end
+
+    subject { File.read(file('spec/alfred_helper.rb')) }
+
+    it "sets mocking framework to rspec if defined" do
+      run_generator
+      subject.should include('config.mock_with :rspec')
+    end
+
+    it "sets mocking framework to test_unit if rspec is not defined" do
+      Alfred::Generators::InstallGenerator.any_instance.stub(:mock_with).and_return(:test_unit)
+      run_generator
+      subject.should include('config.mock_with :test_unit')
+    end
+
+    it 'should include Devise::TestHelpers if Devise is defined' do
+      Alfred::Generators::InstallGenerator.any_instance.stub(:devise_defined?).and_return(true)
+      run_generator
+      subject.should include('config.include Devise::TestHelpers')
+    end
+
+    it 'should include FactoryGirl::Syntax::Methods if FactoryGirl is defined?' do
+      Alfred::Generators::InstallGenerator.any_instance.stub(:factory_girl_defined?).and_return(true)
+      run_generator
+      subject.should include('config.include FactoryGirl::Syntax::Methods')
+    end
+
+    it 'should require "factory_girl" if FactoryGirl is defined?' do
+      Alfred::Generators::InstallGenerator.any_instance.stub(:factory_girl_defined?).and_return(true)
+      run_generator
+      subject.should include('require "factory_girl"')
+    end
+
+  end
+
+end

data/spec/javascripts/alfred/sinon_adapter_spec.js.coffee

@@ -0,0 +1,33 @@
+#= require alfred
+#= require alfred/sinon_adapter
+
+describe 'Alfred.SinonAdapter', ->
+
+  before ->
+    @action   = 'posts/index'
+    @name     = 'default'
+    @response = JSON.stringify({ posts: [{ title: 'Hi there' }] })
+    @meta     = {
+      path:   'posts'
+      method: 'GET'
+      status: 200
+      type:   'application/json'
+    }
+
+    Alfred.register({
+      action:   @action,
+      name:     @name,
+      meta:     @meta,
+      response: @response
+    })
+
+    @scenario = Alfred.scenarios[@action][@name]
+
+  describe 'serve', ->
+
+    it 'should setup a sinon fakeServer', ->
+      server = Alfred.SinonAdapter.serve(@action, @name)
+      response = server.responses[0]
+
+      response.method.should.equal('GET')
+      response.url.should.equal('posts')

data/spec/javascripts/alfred_spec.js.coffee

@@ -0,0 +1,46 @@
+#= require alfred
+
+describe 'Alfred', ->
+
+  before ->
+    @action   = 'posts/index'
+    @name     = 'default'
+    @response = JSON.stringify({ posts: [{ title: 'Hi there' }] })
+    @meta     = {
+      path:   'posts'
+      method: 'GET'
+      status: 200
+      type:   'application/json'
+    }
+
+    Alfred.register({
+      action:   @action,
+      name:     @name,
+      meta:     @meta,
+      response: @response
+    })
+
+    @scenario = Alfred.scenarios[@action][@name]
+
+  describe 'register', ->
+
+    it 'should register scenario', ->
+      @scenario.action.should.equal(@action)
+      @scenario.name.should.equal(@name)
+      @scenario.response.should.equal(@response)
+      @scenario.meta.should.equal(@meta)
+
+  describe 'fetch', ->
+
+    it 'should fetch scenario', ->
+      Alfred.fetch(@action, @name).should.equal(@scenario)
+
+  describe 'serve', ->
+
+    it 'should serve scenario response', ->
+      Alfred.serve(@action, @name).should.equal(@response)
+
+  describe '_name', ->
+
+    it 'should underscore name', ->
+      Alfred._name('this is a name').should.equal('this_is_a_name')

data/spec/javascripts/spec_helper.coffee

@@ -0,0 +1,5 @@
+//=require support/sinon
+//=require support/chai
+//=require support/sinon-chai
+
+should = chai.should()

data/spec/mock_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Alfred::Mock do
+
+  describe '#new' do
+
+    it 'should initialize mocking framework based on mock_with in configuration' do
+      Alfred.configure do |config|
+        config.mock_with :rspec
+      end
+
+      RSpec::Mocks.should_receive(:setup)
+      Alfred::Mock.new
+    end
+
+  end
+
+end

data/spec/registry_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe Alfred::Registry do
+
+  let!(:registry) { Alfred::Registry.new }
+  after(:each)    { registry.clear! }
+
+  it 'should initialize with an empty hash for items' do
+    registry.items.should == {}
+  end
+
+  describe '#register' do
+
+    it 'should add an item to the registry' do
+      registry.register('identifier', 'item')
+      registry.items.should == { 'identifier' => ['item'] }
+
+      registry.register('identifier', 'item2')
+      registry.items.should == { 'identifier' => ['item', 'item2'] }
+    end
+
+  end
+
+  describe '#registered?' do
+
+    it 'should return true if identifier is found' do
+      registry.register('identifier', 'item')
+      registry.registered?('identifier').should be_true
+    end
+
+    it 'should return false if identifier is not found' do
+      registry.register('identifier', 'item')
+      registry.registered?('identifier1').should be_false
+    end
+
+  end
+
+  describe '#find' do
+
+    it 'should find items by identifier' do
+      registry.register('identifier', 'item')
+      registry.find('identifier').should == ['item']
+    end
+
+    it 'should return nil if identifier not registered' do
+      registry.register('identifier', 'item')
+      registry.find('identifier1').should be_nil
+    end
+
+    it 'should support [] syntax' do
+      registry.register('identifier', 'item')
+      registry['identifier'].should == ['item']
+    end
+
+  end
+
+  describe '#all' do
+
+    it 'should return all items in registry' do
+      registry.register('identifier', 'item')
+      registry.register('identifier1', 'item1')
+
+      registry.all.should == ['item', 'item1']
+    end
+
+  end
+
+  describe 'clear!' do
+
+    it 'should clear all items' do
+      registry.register('identifier', 'item')
+      registry.clear!
+      registry.items.should == {}
+    end
+
+  end
+
+end

data/spec/request_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Alfred::Request do
+
+  let!(:request) { Alfred::Request.new('test') }
+
+  describe '#set_controller' do
+
+    it 'should set @controller' do
+      request.set_controller Api::V1::UsersController
+      request.instance_variable_get(:@controller).should be_kind_of(Api::V1::UsersController)
+    end
+
+    it 'should set @routes' do
+      request.set_controller Api::V1::UsersController
+      request.instance_variable_get(:@routes).should == Rails.application.routes
+    end
+
+  end
+
+  describe '#_setup' do
+
+    it 'should execute the given block' do
+      request._setup { User.create(:name => 'John Doe') }
+      User.count.should == 1
+      request._setup { User.create(:name => 'John Doe') }
+      User.count.should == 2
+    end
+
+  end
+
+end

data/spec/runner_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+
+describe Alfred::Runner do
+
+  before do
+    @log = ""
+    STDOUT.stub(:print) { |s| @log << s }
+  end
+
+  after(:each) { Alfred.registry.clear! }
+
+  describe '#initialize' do
+
+    describe 'with files supplied' do
+
+      before(:each) { Alfred::Runner.any_instance.stub(:run).and_return(true) }
+      subject       { Alfred::Runner.new(['spec/alfreds/api/v1/users_controller.rb', 'spec/alfreds/non_existing.rb']) }
+
+      it 'should assign @files with files' do
+        subject.files.should == ['spec/alfreds/api/v1/users_controller.rb', 'spec/alfreds/non_existing.rb']
+      end
+
+      it 'should assign @controllers with controller names' do
+        subject.controllers.should == ['api/v1/users_controller', 'non_existing']
+      end
+
+      it 'should assign @matches with matching alfred definitions' do
+        Alfred.define do
+          controller Api::V1::UsersController do
+            scenario 'foo'
+          end
+          controller Api::V1::PostsController do
+            scenario 'bar'
+          end
+        end
+        subject.matches.should == ["spec/alfreds/api/v1/users_controller.rb"]
+      end
+
+      it "should assign @scenarios with the scenarios for a controller" do
+        Alfred.define do
+          controller Api::V1::UsersController do
+            scenario 'foo'
+            scenario 'bar'
+          end
+          controller Api::V1::PostsController do
+            scenario 'bar'
+          end
+        end
+        subject.scenarios.size.should == 2
+      end
+
+    end
+
+  end
+
+  describe 'without files supplied' do
+
+    before(:each) { Alfred::Runner.any_instance.stub(:run).and_return(true) }
+    after(:each)  { Alfred.registry.clear! }
+
+    subject { Alfred::Runner.new }
+
+    it '@files should be empty' do
+      subject.files.should be_empty
+    end
+
+    it '@controllers should be nil' do
+      subject.controllers.should be_nil
+    end
+
+    it '@matches should be nil' do
+      Alfred.define do
+        controller Api::V1::UsersController do
+          scenario 'foo'
+        end
+        controller Api::V1::PostsController do
+          scenario 'bar'
+        end
+      end
+      subject.matches.should be_nil
+    end
+
+    it "should assign @scenarios with all scenario's" do
+      Alfred.define do
+        controller Api::V1::UsersController do
+          scenario 'foo'
+          scenario 'bar'
+        end
+        controller Api::V1::PostsController do
+          scenario 'bar'
+        end
+      end
+      subject.scenarios.size.should == 3
+    end
+
+  end
+
+  describe '#run' do
+
+    before do
+      Alfred::Scenario.any_instance.stub(:run).and_return(true)
+      ProgressBar.stub(:create).and_return(ProgressBar.new)
+      ProgressBar.any_instance.stub(:increment).and_return(true)
+    end
+
+    subject { Alfred::Runner.new(['spec/alfreds/api/v1/users_controller.rb', 'spec/alfreds/non_existing.rb']) }
+
+    context 'with matching files' do
+
+      before(:each) do
+        Alfred.define do
+          controller Api::V1::UsersController do
+            scenario 'foo'
+            scenario 'bar'
+          end
+          controller Api::V1::PostsController do
+            scenario 'bar'
+          end
+        end
+      end
+
+      it 'should notify about matches' do
+        subject
+        @log.should include('spec/alfreds/api/v1/users_controller.rb')
+        @log.should_not include('spec/alfreds/non_existing.rb')
+      end
+
+    end
+
+    context 'without matching files' do
+
+      before(:each) do
+        Alfred.define do
+          controller Api::V1::UsersController do
+            scenario 'foo'
+            scenario 'bar'
+          end
+          controller Api::V1::PostsController do
+            scenario 'bar'
+          end
+        end
+      end
+
+      it 'should not run' do
+        Alfred.define do
+          controller Api::V1::PostsController do
+            scenario 'bar'
+          end
+        end
+        subject.should_not_receive(:run)
+      end
+
+    end
+
+    context 'without files' do
+
+      subject { Alfred::Runner.new }
+
+      before(:each) do
+        Alfred.define do
+          controller Api::V1::UsersController do
+            scenario 'foo'
+            scenario 'bar'
+          end
+          controller Api::V1::PostsController do
+            scenario 'bar'
+          end
+        end
+      end
+
+      it 'should notify about running all files' do
+        subject
+        @log.should include("Running all scenario's")
+      end
+    end
+
+  end
+
+end

data/spec/scenario_dsl_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Alfred::ScenarioDSL do
+
+  let!(:scenario) { Alfred::Scenario.new('foo bar') }
+  let!(:dsl)      { Alfred::ScenarioDSL.new(scenario) }
+
+  describe '#setup' do
+
+    it 'should add setup blocks to definition' do
+      dsl.setup { User.new }
+      scenario.setups.size.should == 1
+      scenario.setups.first.should be_kind_of(Proc)
+
+      dsl.setup { User.new }
+      scenario.setups.size.should == 2
+    end
+
+  end
+
+  describe '#controller' do
+
+    it 'should set the controller to test' do
+      dsl.controller Api::V1::UsersController
+      scenario.controller.should == Api::V1::UsersController
+    end
+
+  end
+
+  describe 'request methods' do
+
+    it 'should respond to all request methods' do
+      dsl.should respond_to(:get)
+      dsl.should respond_to(:post)
+      dsl.should respond_to(:put)
+      dsl.should respond_to(:patch)
+      dsl.should respond_to(:head)
+      dsl.should respond_to(:delete)
+    end
+
+  end
+
+  describe '#setup_request_data' do
+
+    it 'should set method' do
+      dsl.setup_request_data(:get, :show, :id => 1)
+      scenario.method.should == :get
+    end
+
+    it 'should set action' do
+      dsl.setup_request_data(:get, :show, :id => 1)
+      scenario.action.should == :show
+    end
+
+    it 'should set params' do
+      dsl.setup_request_data(:get, :show, :id => 1)
+      scenario.params.should == { :id => 1 }
+    end
+
+  end
+
+end

data/spec/scenario_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Alfred::Scenario do
+
+  let!(:scenario) { Alfred::Scenario.new('foo bar') }
+
+  it 'should downcase the name on initialize' do
+    scenario.name.should == 'foo_bar'
+  end
+
+  it 'should initialize with empty setups array' do
+    scenario.setups.should == []
+  end
+
+  describe '#controller_name' do
+
+    it 'should return underscored controller name' do
+      scenario.controller = Api::V1::UsersController
+      scenario.controller_name.should == 'api/v1/users_controller'
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+## Test coverage
+
+require 'coveralls'
+Coveralls.wear!
+
+## Rails
+
+require 'support/application'
+
+## Rspec
+
+require 'rspec'
+require 'ammeter/init'
+require 'rspec/autorun'
+
+## Load alfred_rails
+
+require 'alfred_rails'
+
+## Make sure registry is empty after each example
+
+RSpec.configure do |config|
+  config.after(:each) { Alfred.registry.clear! }
+end

data/spec/support/application.rb

@@ -0,0 +1,21 @@
+require 'rails/all'
+
+module Rails
+  class Application
+    class Configuration
+      def database_configuration
+        YAML::load File.read('spec/fixtures/database.yml')
+      end
+    end
+  end
+end
+
+## Load support files
+
+load 'spec/support/rails.rb'
+load 'spec/support/routes.rb'
+load 'spec/support/schema.rb'
+
+[:controllers, :models, :lib].each do |dir|
+  Dir["spec/support/#{dir}/**/*.rb"].each { |f| load f }
+end

data/spec/support/controllers/api/v1/posts_controller.rb

@@ -0,0 +1,14 @@
+module Api
+  module V1
+    class PostsController < ActionController::Base
+      respond_to :xml, :json
+
+      def index
+        @posts = Post.all
+
+        respond_with(@posts)
+      end
+
+    end
+  end
+end

data/spec/support/controllers/api/v1/users_controller.rb

@@ -0,0 +1,14 @@
+module Api
+  module V1
+    class UsersController < ActionController::Base
+      respond_to :xml, :json
+
+      def index
+        @users = User.all
+
+        respond_with(@users)
+      end
+
+    end
+  end
+end

data/spec/support/lib/response_proxy.rb

@@ -0,0 +1,11 @@
+class ResponseProxy
+
+  attr_accessor :content_type
+
+  def initialize(attributes={})
+    attributes.keys.each do |key|
+      instance_variable_set("@#{key}".to_sym, attributes[key])
+    end
+  end
+
+end

data/spec/support/models/post.rb

@@ -0,0 +1 @@
+class Post < ActiveRecord::Base; end

data/spec/support/models/user.rb

@@ -0,0 +1 @@
+class User < ActiveRecord::Base; end

data/spec/support/rails.rb

@@ -0,0 +1,14 @@
+ENV['RAILS_ENV'] = 'test'
+
+module AlfredRailsTest
+  class Application < Rails::Application
+    config.eager_load                 = false
+    config.active_support.deprecation = :log
+    config.secret_token               = '8f62080da9dd946a6555635c46fbebfb'
+
+    if Rails::VERSION::STRING >= "4.0.0"
+      config.secret_key_base = '8f62080da9dd946a6555635c46fbebfb'
+    end
+  end
+end
+AlfredRailsTest::Application.initialize!

data/spec/support/routes.rb

@@ -0,0 +1,9 @@
+AlfredRailsTest::Application.routes.draw do
+
+  namespace :api do
+    namespace :v1 do
+      resources :users
+    end
+  end
+
+end