alfred_rails 0.0.1.alpha

data/lib/alfred_rails/ui.rb

@@ -0,0 +1,90 @@
+module Alfred
+  class UI
+
+    class << self
+
+      ##
+      # Display info via STDOUT.
+      #
+      # === Params
+      #
+      # [message (String)] the message to display.
+      # [options (Hash)] optional options hash.
+      #
+      # === Example
+      #
+      #   UI.info('Alfred generated the following fixtures:')
+      #   #=>  07:46:28 - INFO - Alfred generated the following fixtures:
+      #
+      def info(message, options={})
+        new(options).queue(message, :timestamp => true).display
+      end
+
+    end # class << self
+
+    attr_accessor :message, :options
+
+    def initialize(options={})
+      @message = []
+      @options = options
+    end
+
+    ##
+    # Add a message to the queue.
+    #
+    # === Params
+    #
+    # [message (String)] the message to queue
+    # [options (Hash)] display timestamp
+    #
+    # === Example
+    #
+    #   message = UI.new
+    #   message.queue('Alfred generated the following fixtures:', :timestamp => true)
+    #
+    # Will add the following string to the queue:
+    #
+    #   '07:46:28 - INFO - Alfred generated the following fixtures:'
+    #
+    # Insert at the begin of the queue
+    #
+    #   message = Ui.new
+    #   message.queue('/spec/some_file.rb')
+    #   message.queue('Generated:', :timestamp => true, :before => true)
+    #
+    # Queue will look like:
+    #
+    #   message.message #=> ["07:46:28 - INFO - Generated:\n", "/spec/some_file.rb\n"]
+    #
+    def queue(message, options={})
+      message  = "#{timestamp}#{message}" if options[:timestamp]
+      position = options[:before] ? 0 : -1
+      @message.insert(position, "#{message}\n")
+      return self
+    end
+
+    ##
+    # Display the message.
+    #
+    def display
+      @message.insert(0, "\n")  if @options[:empty_line_before]
+      @message.insert(-1, "\n") if @options[:empty_line_after]
+
+      STDOUT.print(@message.join)
+    end
+
+    private
+
+      ##
+      # Returns a timestamp info string.
+      #
+      # === Example
+      #
+      #   ui.timestamp #=> '07:46:28 - INFO - '
+      #
+      def timestamp
+        "#{Time.now.strftime('%H:%M:%S')} - INFO - "
+      end
+
+  end # UI
+end # Alfred

data/lib/alfred_rails/version.rb

@@ -0,0 +1,3 @@
+module Alfred
+  VERSION = "0.0.1.alpha"
+end

data/lib/alfred_rails.rb

@@ -0,0 +1,99 @@
+require 'alfred_rails/version'
+require 'alfred_rails/rails'
+require 'alfred_rails/configuration'
+require 'alfred_rails/mock'
+require 'alfred_rails/registry'
+require 'alfred_rails/definition'
+require 'alfred_rails/scenario'
+require 'alfred_rails/fixture_file'
+require 'alfred_rails/scenario_dsl'
+require 'alfred_rails/request'
+require 'alfred_rails/runner'
+require 'alfred_rails/ui'
+
+require 'active_support'
+require 'database_cleaner'
+
+module Alfred
+  extend Alfred::Definition
+
+  class << self
+
+    ##
+    # Builds registry or returns existing registry.
+    #
+    # === Returns
+    #
+    # [registry (Alfred::Registry)] the registry
+    #
+    def registry
+      @registry ||= Registry.new
+    end
+
+    ##
+    # Builds configuration or returns existing configuration.
+    #
+    # === Returns
+    #
+    # [configuration (Alfred::Configuration)] the configuration instance
+    #
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    ##
+    # Configure Alfred.
+    #
+    # === Example
+    #
+    #   configure do |c|
+    #     c.include FactoryGirl::Syntax::Methods
+    #     c.include Devise::TestHelpers
+    #
+    #     c.before do
+    #       DatabaseCleaner.clean
+    #     end
+    #
+    #     c.mock_with :rspec
+    #
+    #     c.fixture_path 'spec/fixtures'
+    #   end
+    #
+    def configure
+      yield configuration if block_given?
+    end
+
+    ##
+    # Loads the configuration
+    #
+    def load_configuration!
+      Dir["spec/alfred_helper.rb"].each { |f| load f }
+      Dir["test/alfred_helper.rb"].each { |f| load f }
+    end
+
+    ##
+    # Loads the configuration and scenario's
+    #
+    def load!
+      load_configuration!
+
+      ## Load scenario's
+      Dir["spec/alfreds/**/*.rb"].each { |f| load f }
+      Dir["test/alfreds/**/*.rb"].each { |f| load f }
+
+      ## Include modules from configuration
+      Alfred.configuration.includes.each do |mod|
+        Request.send(:include, mod)
+      end
+    end
+
+    ##
+    # Returns fixture path defined in Configuration.
+    #
+    def fixture_path
+      configuration.fixture_path
+    end
+
+  end # class << self
+
+end # Alfred

data/lib/generators/alfred/controller/controller_generator.rb

@@ -0,0 +1,24 @@
+require 'alfred_rails'
+
+module Alfred
+  module Generators
+    class ControllerGenerator < ::Rails::Generators::NamedBase
+
+      def self.source_root
+        @source_root ||= File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+      end
+
+      def create_scenario
+        Alfred.load_configuration!
+        template 'alfred.erb', "#{test_path}/alfreds/#{class_name.underscore}_controller.rb"
+      end
+
+      private
+
+        def test_path
+          Alfred.configuration.test_path
+        end
+
+    end # ControllerGenerator
+  end # Generators
+end # Alfred

data/lib/generators/alfred/controller/templates/alfred.erb

@@ -0,0 +1,7 @@
+# Read about alfreds at https://github.com/jhnvz/alfred_rails
+
+Alfred.define do
+  controller <%= class_name %>Controller do
+    ## Place your scenario's here
+  end
+end

data/lib/generators/alfred/install/install_generator.rb

@@ -0,0 +1,85 @@
+require 'rails/generators'
+require 'alfred_rails'
+
+module Alfred
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+
+      def self.source_root
+        @source_root ||= File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+      end
+
+      ##
+      # Define method for checking presence of a module.
+      # Will also include module in config.
+      #
+      # === Examples
+      #
+      #   INCLUDES = [{ :class_name => 'Devise', :include => 'Devise::TestHelpers' }]
+      #
+      # Will define the following method:
+      #
+      #   def devise_enabled?
+      #     defined?(Devise)
+      #   end
+      #
+      # Adds the following code to config:
+      #
+      #   config.include Devise::TestHelpers
+      #
+      # === Current value:
+      #
+      INCLUDES = [
+        {
+          :class_name => 'Devise',
+          :include    => 'Devise::TestHelpers'
+        }, {
+          :class_name => 'FactoryGirl',
+          :include    => 'FactoryGirl::Syntax::Methods',
+          :require    => 'factory_girl'
+        }
+      ]
+
+      def create_alfred_helper
+        template "alfred_helper.erb", "#{test_path}/alfred_helper.rb"
+      end
+
+      private
+
+        INCLUDES.each do |mod|
+          define_method("#{mod[:class_name].underscore}_defined?") do
+            defined?(mod[:class_name].constantize)
+          end
+        end
+
+        def includes
+          includes = []
+          INCLUDES.each do |mod|
+            if send("#{mod[:class_name].underscore}_defined?")
+              includes << "config.include #{mod[:include]}"
+            end
+          end
+          includes
+        end
+
+        def requires
+          requires = []
+          INCLUDES.each do |mod|
+            if send("#{mod[:class_name].underscore}_defined?")
+              requires << "require \"#{mod[:require]}\"" if mod[:require]
+            end
+          end
+          requires
+        end
+
+        def mock_with
+          Alfred.configuration.mock_with
+        end
+
+        def test_path
+          Alfred.configuration.test_path
+        end
+
+    end # InstallGenerator
+  end # Generators
+end # Alfred

data/lib/generators/alfred/install/templates/alfred_helper.erb

@@ -0,0 +1,23 @@
+require 'database_cleaner'
+DatabaseCleaner.strategy = :truncation
+
+<% if requires.any? -%>
+<%= requires.join("\n  ") << "\n" %>
+<% end -%>
+Alfred.configure do |config|
+  <% if includes.any? -%>
+<%= "## We detected the following libraries. Remove them if you don't want to use them." %>
+  <%= includes.join("\n  ") << "\n" %>
+<% end -%>
+  ## Setup
+  config.setup do
+    ## Runs before every scenario
+    DatabaseCleaner.clean
+  end
+
+  ## Mocking framework
+  config.mock_with :<%= mock_with %>
+
+  ## Fixture path
+  config.fixture_path '<%= test_path %>/javascripts/fixtures'
+end

data/lib/tasks/alfred.rake

@@ -0,0 +1,6 @@
+task :alfred do
+  ENV['RACK_ENV'] = ENV['RAILS_ENV'] = 'test'
+
+  ## Run all examples
+  Bundler.with_clean_env { Kernel.system('bundle exec alfred') }
+end

data/spec/command_line_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'alfred_rails/command_line'
+
+module Kernel
+  def suppress_warnings
+    original_verbosity = $VERBOSE
+    $VERBOSE = nil
+    result = yield
+    $VERBOSE = original_verbosity
+    return result
+  end
+end
+
+describe Alfred::CommandLine do
+
+  subject { Alfred::CommandLine }
+
+  before(:each) do
+    @log = ""
+    STDOUT.stub(:print) { |s| @log << s }
+  end
+
+  describe '#initialize' do
+
+    before do
+      subject.any_instance.stub(:load_rails!).and_return(true)
+    end
+
+    it "should load rails environment and scenario's" do
+      subject.any_instance.should_receive(:load_rails!)
+      Alfred.should_receive(:load!)
+      subject.new
+    end
+
+    it "should run scenario's for the files found" do
+      subject.any_instance.stub(:parse_options).and_return(["file1", "file2"])
+      Alfred::Runner.should_receive(:new).with(["file1", "file2"])
+      subject.new
+    end
+
+    it "should run all scenario's if no files present" do
+      subject.any_instance.stub(:parse_options).and_return([])
+      Alfred::Runner.should_receive(:new).with([])
+      subject.new
+    end
+
+    it "assigns @options and adds the files that were parsed out" do
+      subject.any_instance.stub(:parse_options).and_return(["file1", "file2"])
+      subject.new.instance_variable_get(:@options).should == { :files => ["file1", "file2"] }
+    end
+
+  end
+
+  describe 'opt_parser' do
+
+    it "has --version" do
+      suppress_warnings { ARGV = ["--version"] }
+      expect { subject.new.parse_options }.to raise_error SystemExit
+      expect(@log).to match(/\d+\.\d+\.\d+\n/)
+    end
+
+  end
+
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe Alfred::Configuration do
+
+  let!(:configuration) { Alfred::Configuration.new }
+
+  it 'should initialize with an empty setup array' do
+    configuration.setup.should == []
+  end
+
+  it 'should initialize with an empty includes array' do
+    configuration.includes.should == []
+  end
+
+  describe '#load_defaults' do
+
+    it 'should set fixture_path to rspec directory if rspec is defined' do
+      configuration.fixture_path.should == "#{Rails.root}/spec/javascripts/fixtures"
+    end
+
+    it 'should set fixture path to test directory if rspec is not defined' do
+      Alfred::Configuration.any_instance.stub(:rspec_defined?).and_return(false)
+      configuration = Alfred::Configuration.new
+      configuration.fixture_path.should == "#{Rails.root}/test/javascripts/fixtures"
+    end
+
+    it 'should set mocking framework to :rspec if Rspec::Mocks is defined' do
+      configuration.mock_with.should == :rspec
+    end
+
+    it 'should set mocking framework to :test_unit if Rspec::Mocks is not defined' do
+      Alfred::Configuration.any_instance.stub(:rspec_defined?).and_return(false)
+      configuration = Alfred::Configuration.new
+      configuration.mock_with.should == :test_unit
+    end
+
+  end
+
+  describe '#setup' do
+
+    it 'should add procs to the setup array if block given' do
+      configuration.setup { User.create(:name => 'John Doe') }
+      configuration.setup.size.should == 1
+      configuration.setup.first.should be_kind_of(Proc)
+    end
+
+  end
+
+  describe '#mock_with' do
+
+    it 'should set mock_with if argument is given' do
+      configuration.mock_with :something
+      configuration.mock_with.should == :something
+    end
+
+  end
+
+  describe '#fixture_path' do
+
+    it 'should set fixture_path if argument is given' do
+      configuration.fixture_path 'some/path'
+      configuration.fixture_path.should == "#{Rails.root}/some/path"
+    end
+
+  end
+
+  describe '#test_path' do
+
+    it 'should set test_path if argument is given' do
+      configuration.test_path 'some/path'
+      configuration.test_path.should == "some/path"
+    end
+
+  end
+
+  describe '#include' do
+
+    it 'should add modules to include' do
+      configuration.include Object
+      configuration.includes.size.should == 1
+      configuration.includes.first.should == Object
+    end
+
+  end
+
+end

data/spec/definition_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+describe Alfred::Definition do
+
+  describe '#define' do
+
+    it 'should run the block through DSL' do
+      Alfred::Definition::DSL.should_receive(:run)
+      Alfred.define { scenario 'name' }
+    end
+
+  end
+
+  describe Alfred::Definition::DSL do
+
+    describe '#define' do
+
+      it 'should register a new scenario' do
+        Alfred.define do
+          scenario 'foo bar' do
+            setup { User.create(:name => 'John') }
+
+            controller Api::V1::UsersController
+
+            patch :update, :id => 1, :user => { :name => 'John Doe' }
+          end
+        end
+
+        scenario = Alfred.registry.all.first
+        scenario.controller.should == Api::V1::UsersController
+        scenario.method.should == :patch
+        scenario.action.should == :update
+        scenario.params.should == { :id => 1, :user => { :name => 'John Doe' } }
+        scenario.setups.size.should == 1
+        scenario.setups.first.should be_kind_of(Proc)
+      end
+
+    end
+
+    describe '#setup' do
+
+      it 'should be able to set setup for multiple scenarios' do
+        Alfred.define do
+          setup { User.create(:name => 'John') }
+
+          controller Api::V1::UsersController do
+            scenario 'foo bar'
+            scenario 'foo bar 1'
+          end
+        end
+
+        scenario = Alfred.registry.all[0]
+        scenario.setups.size.should == 1
+
+        scenario = Alfred.registry.all[1]
+        scenario.setups.size.should == 1
+      end
+
+      it 'should be able to set setup within controller block' do
+        Alfred.define do
+          controller Api::V1::UsersController do
+            setup { User.create(:name => 'John') }
+
+            scenario 'foo bar'
+            scenario 'foo bar 1'
+          end
+        end
+
+        scenario = Alfred.registry.all[0]
+        scenario.setups.size.should == 1
+
+        scenario = Alfred.registry.all[1]
+        scenario.setups.size.should == 1
+      end
+
+      it 'should append setup defined in scenario' do
+        Alfred.define do
+          setup { User.create(:name => 'John') }
+
+          controller Api::V1::UsersController do
+            scenario 'foo bar'
+            scenario 'foo bar 1' do
+              setup { Post.create(:title => 'Cool post') }
+            end
+          end
+        end
+
+        scenario = Alfred.registry.all[0]
+        scenario.setups.size.should == 1
+
+        scenario = Alfred.registry.all[1]
+        scenario.setups.size.should == 2
+      end
+
+    end
+
+    describe '#controller' do
+
+      it 'should be able to set controller for multiple scenarios' do
+        Alfred.define do
+          controller Api::V1::UsersController do
+            scenario 'foo bar'
+            scenario 'foo bar 1'
+          end
+        end
+
+        scenario = Alfred.registry.all[0]
+        scenario.controller.should == Api::V1::UsersController
+
+        scenario = Alfred.registry.all[1]
+        scenario.controller.should == Api::V1::UsersController
+      end
+
+      it 'should be able overwrite controller per scenario' do
+        Alfred.define do
+          controller Api::V1::UsersController do
+            scenario 'foo bar'
+            scenario 'foo bar 1' do
+              controller Api::V1::PostsController
+            end
+          end
+        end
+
+        scenario = Alfred.registry.all[0]
+        scenario.controller.should == Api::V1::UsersController
+
+        scenario = Alfred.registry.all[1]
+        scenario.controller.should == Api::V1::PostsController
+      end
+
+    end
+
+  end
+
+end

data/spec/fixture_file_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Alfred::FixtureFile do
+
+  let(:file) { Alfred::FixtureFile.new(nil, 'api/v1/users_controller', 'index', 'foo_bar') }
+
+  describe '#path' do
+
+    it 'should return path to save the file based on controller and action' do
+      file.path.should == "#{Alfred.fixture_path}/api/v1/users_controller/index"
+    end
+
+  end
+
+  describe '#filename' do
+
+    it 'should return the filename based on path' do
+      file.filename.should == "#{Alfred.fixture_path}/api/v1/users_controller/index/foo_bar.js"
+    end
+
+  end
+
+  describe '#content' do
+
+    let(:request) { Object.new }
+    let(:response) { Object.new }
+
+    before(:each) do
+      request.stub(:fullpath).and_return('api/1/users')
+      request.stub(:method).and_return('GET')
+
+      response.stub(:body).and_return('this is data')
+      response.stub(:status).and_return(200)
+      response.stub(:content_type).and_return('application/json')
+      response.stub(:request).and_return(request)
+
+      file.stub(:response).and_return(response)
+    end
+
+    it 'should return hash with data and request meta data' do
+      file.content.should == {
+        :name     => 'foo_bar',
+        :action   => 'api/v1/users_controller/index',
+        :meta     => {
+          :path     => 'api/1/users',
+          :method   => 'GET',
+          :status   => 200,
+          :type     => 'application/json',
+        },
+        :response => 'this is data'
+      }
+    end
+
+    it 'should return #to_js' do
+      file.to_js.should include "Alfred.register"
+    end
+
+  end
+
+end

data/spec/fixtures/database.yml

@@ -0,0 +1,4 @@
+test:
+  adapter: sqlite3
+  database: database.sqlite
+  host: localhost