alfred_rails 0.0.1.alpha

data/lib/alfred_rails/definition.rb

@@ -0,0 +1,129 @@
+module Alfred
+  module Definition
+
+    ##
+    # Defines a new Alfred scenario.
+    #
+    # === Params
+    #
+    # [block (Block)] the block to perform
+    #
+    # === Examples
+    #
+    #   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(:poset, :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
+    #
+    def define(&block)
+      Thread.current[:controller] = nil
+      Thread.current[:setup]      = []
+
+      DSL.run(block)
+    end
+
+    class DSL
+
+      ##
+      # Define a new scenario.
+      #
+      # === Params
+      #
+      # [name (Symbol)] the name of the scenario
+      # [block (Block)] the block to perform
+      #
+      def scenario(name, &block)
+        scenario            = Scenario.new(name)
+        scenario.controller = Thread.current[:controller]
+
+        Thread.current[:setup].each { |setup| scenario.setups << setup }
+
+        dsl = ScenarioDSL.new(scenario)
+        dsl.instance_eval(&block) if block_given?
+
+        Alfred.registry.register(scenario.controller_name, scenario)
+      end
+
+      ##
+      # Define the controller.
+      #
+      # === Params
+      #
+      # [controller (ActionController::Base)] the controller
+      # [block (Block)] the block to perform
+      #
+      def controller(controller, &block)
+        Thread.current[:controller] = controller
+
+        instance_eval(&block)
+      end
+
+      ##
+      # Define setup for every scenario.
+      #
+      # === Params
+      #
+      # [block (Block)] the block to setup on Alfred Scenario
+      #
+      # === Examples
+      #
+      #   Alfred.define do
+      #     setup do
+      #       SomeController.stub(:current_user).and_return(create(:user))
+      #     end
+      #
+      #     scenario 'alfred is awesome' do
+      #
+      #     end
+      #   end
+      #
+      def setup(&block)
+        Thread.current[:setup] << block
+      end
+
+      ##
+      # Runs the code inside a block.
+      #
+      # === Params
+      #
+      # [block (Block)] the block to run
+      #
+      # === Examples
+      #
+      #   new.run do
+      #     setup do
+      #       User.create(:name => 'John Doe')
+      #     end
+      #   end
+      #
+      #   #=> Will call the setup method with a new block
+      #
+      def self.run(block)
+        new.instance_eval(&block)
+      end
+
+    end # DSL
+
+  end # Definition
+end # Alfred

data/lib/alfred_rails/fixture_file.rb

@@ -0,0 +1,70 @@
+module Alfred
+  class FixtureFile
+
+    attr_reader :response, :controller_name, :action, :name
+
+    def initialize(response, controller_name, action, name)
+      @response = response
+      @controller_name = controller_name
+      @action = action
+      @name = name
+    end
+
+    ##
+    # Returns the path name to save the fixture.
+    #
+    def path
+      "#{Alfred.fixture_path}/#{controller_name}/#{action}"
+    end
+
+    ##
+    # Returns the folder name to save the fixture.
+    #
+    def filename
+      "#{path}/#{name.underscore}.js"
+    end
+
+    ##
+    # Saves the fixture.
+    #
+    def save
+      FileUtils.mkdir_p(path)
+
+      File.open(filename, 'w') do |fixture|
+        fixture.write(to_js)
+      end
+    end
+
+    ##
+    # Outputs the content to a JavaScript format wrapped around Alfred.register JavaScript method
+    #
+    def to_js
+      "Alfred.register(#{content.to_json})"
+    end
+
+    ##
+    # Scenario content with meta data outputted as a hash.
+    #
+    def content
+      @content ||= {
+        :name     => name,
+        :action   => "#{controller_name}/#{action}",
+        :meta     => meta,
+        :response => response.body
+      }
+    end
+
+    ##
+    # Scenario meta data, such as path, method, status and content type
+    #
+    def meta
+      {
+        :path   => response.request.fullpath,
+        :method => response.request.method,
+        :status => response.status,
+        :type   => response.content_type,
+      }
+    end
+
+  end
+end

data/lib/alfred_rails/mock.rb

@@ -0,0 +1,14 @@
+module Alfred
+  class Mock
+
+    ##
+    # Initialize mocking framework based on configuration.
+    #
+    def initialize
+      if Alfred.configuration.mock_with == :rspec
+        RSpec::Mocks::setup(Object.new)
+      end
+    end
+
+  end # Mock
+end # Alfred

data/lib/alfred_rails/rails.rb

@@ -0,0 +1,14 @@
+module Alfred
+  module Rails
+    class Engine < ::Rails::Engine; end
+
+    # :nocov:
+    class Railtie < ::Rails::Railtie
+      rake_tasks do
+        load "tasks/alfred.rake"
+      end
+    end # Railtie
+    # :nocov:
+
+  end # Rails
+end # Alfred

data/lib/alfred_rails/registry.rb

@@ -0,0 +1,84 @@
+module Alfred
+  class Registry
+
+    attr_accessor :items
+
+    def initialize
+      @items = {}
+    end
+
+    ##
+    # Register a new Scenario.
+    #
+    # === Params
+    #
+    # [identifier (String)] the scenario identifier
+    # [item (Scenario)] the scenario object
+    #
+    # === Example
+    #
+    #   Alfred.registry.register('api/v1/posts_controller', #Alfred::Scenario:0x007f933a6aaa98>)
+    #
+    def register(identifier, item)
+      @items[identifier] ||= []
+      @items[identifier] << item
+    end
+
+    ##
+    # Check if controller and action are already registered.
+    #
+    # === Params
+    #
+    # [identifier (String)] the scenario identifier
+    #
+    # === Example
+    #
+    #   Scenario.registry.registered?('api/v1/posts_controller')
+    #
+    # === Returns
+    #
+    # [found (TrueClass|FalseClass)] wheter found or not
+    #
+    def registered?(identifier)
+      @items.key?(identifier)
+    end
+
+    ##
+    # Finds a Scenario by its identifier.
+    #
+    # === Params
+    #
+    # [identifier (String)] unique identifier
+    #
+    # === Examples
+    #
+    #   Alfred.registry.find("api/v1/sessions_controller")
+    #   #=> [#<Alfred::Scenario:0x007f933a6aaa98>]
+    #
+    # === Returns
+    #
+    # [items (Array)] returns all the items for identifier
+    #
+    def find(identifier)
+      if registered?(identifier)
+        @items[identifier]
+      end
+    end
+    alias :[] :find
+
+    ##
+    # Returns all the items.
+    #
+    def all
+      @items.values.flatten
+    end
+
+    ##
+    # Removes al items from registry.
+    #
+    def clear!
+      @items.clear
+    end
+
+  end # Registry
+end # Alfred

data/lib/alfred_rails/request.rb

@@ -0,0 +1,38 @@
+module Alfred
+  class Request < ActionController::TestCase
+
+    ##
+    # Runs setup block before it runs the controller action.
+    #
+    # [block (Block)] the block to execute
+    #
+    # === Example
+    #
+    #   request = Alfred::Request.new('test')
+    #   request.setup do
+    #     User.create(:name => 'John Doe')
+    #   end
+    #
+    def _setup(&block)
+      instance_eval(&block) if block_given?
+    end
+
+    ##
+    # Sets the controller instance to test.
+    #
+    # === Params
+    #
+    # [controller_instance (ActionController::Base#new)] the controller to test
+    #
+    # === Example
+    #
+    #   request = Alfred::Request.new('test')
+    #   request.set_controller(Api::V1::UsersController)
+    #
+    def set_controller(controller)
+      @routes     = ::Rails.application.routes
+      @controller = controller.new
+    end
+
+  end # Request
+end # Alfred

data/lib/alfred_rails/runner.rb

@@ -0,0 +1,116 @@
+require 'ruby-progressbar'
+
+module Alfred
+  class Runner
+
+    attr_accessor :files, :controllers, :matches, :scenarios
+
+    ##
+    # Initialize a new runner and find and run scenario's.
+    # Runs al scenarios if files are empty.
+    #
+    # === Params
+    #
+    # [files (Array)] the files to lookup
+    #
+    # === Example
+    #
+    # Run specific scenario's:
+    #
+    #   Runner.new(['spec/alfreds/some_controller.rb'])
+    #   #=> Will run scenario's for some_controller
+    #
+    # Run all scenario's:
+    #
+    #   Runner.new
+    #   #=> Will run all scenario's
+    #
+    def initialize(files=[])
+      @files       = files
+      @controllers = controllers_for_files
+      @matches     = matches_for_controllers
+      @scenarios   = scenarios_for_controllers
+
+      run if @scenarios.any?
+    end
+
+    private
+
+      ##
+      # Returns controller_names for files in @files.
+      #
+      def controllers_for_files
+        if @files.any?
+          @files.map do |file|
+            file
+              .gsub('.rb', '')
+              .gsub("#{::Alfred.configuration.test_path}/alfreds/", '')
+          end
+        end
+      end
+
+      ##
+      # Returns registered scenarios for @controllers.
+      # Returns all scenarios if @controllers is nil.
+      #
+      def scenarios_for_controllers
+        if @controllers
+          scenarios = []
+          @controllers.each do |controller|
+            scenarios << Alfred.registry[controller]
+          end
+          scenarios.flatten.compact
+        else
+          Alfred.registry.all
+        end
+      end
+
+      ##
+      # Returns controllers found in registry.
+      #
+      def matches_for_controllers
+        if @controllers
+          matches = []
+          @controllers.each do |controller|
+            if Alfred.registry.registered?(controller)
+              matches << "#{Alfred.configuration.test_path}/alfreds/#{controller}.rb"
+            end
+          end
+          matches
+        end
+      end
+
+      ##
+      # Display runner start message.
+      #
+      def start_message
+        message = @matches ? @matches.join(' ') : "all scenario's"
+        UI.info("Alfred: Serving #{message}", :empty_line_before => true)
+      end
+
+      ##
+      # Run scenarios defined in @scenarios
+      #
+      def run
+        start_message
+
+        progress = ProgressBar.create(
+          :starting_at => 0,
+          :format      => '%c/%C: |%B| %a',
+          :total       => @scenarios.size
+        )
+
+        message = UI.new(:empty_line_before => true, :empty_line_after => true)
+
+        @scenarios.each do |scenario|
+          scenario.run # Run the scenario
+          progress.increment # Increment progressbar
+          message.queue(scenario.file.filename) # Add filename to the message queue
+        end
+
+        message.queue('Alfred served the following fixtures:', :timestamp => true, :before => true)
+        message.display
+      end
+
+  end # Runner
+end # Alfred

data/lib/alfred_rails/scenario.rb

@@ -0,0 +1,99 @@
+module Alfred
+  class Scenario
+
+    ## Attributes
+
+    attr_accessor :name, :setups, :method, :controller, :action, :params, :identifier
+
+    ##
+    # Initialize a new Alfred scenario.
+    #
+    # === Params
+    #
+    # [name (String)] name of the scenario
+    #
+    # === Example
+    #
+    #   Scenario.new('admin permissions')
+    #
+    def initialize(name)
+      @name   = name.downcase.gsub(' ', '_')
+      @setups = []
+    end
+
+    ##
+    # Returns the controller name based on controller.
+    #
+    # === Examples
+    #
+    #   scenario = Scenario.new('test')
+    #   scenario.controller = Api::V1::UserController
+    #
+    #   scenario.controller_name #=> 'api/v1/users_controller'
+    #
+    def controller_name
+      controller.name.underscore
+    end
+
+    ##
+    # Runs the scenario.
+    #
+    def run
+      setup_request
+      apply_setup
+      perform_request
+
+      ## Persist response to disk
+      file.save
+    end
+
+    ##
+    # Initialize or return existing file instance.
+    #
+    def file
+      @file ||= FixtureFile.new(@response, controller_name, action, name)
+    end
+
+    private
+
+      ##
+      # Initialize a new Request.
+      #
+      def setup_request
+        controller.send(:include, ::Rails.application.routes.url_helpers)
+
+        ## Initialize mocking framework
+        Alfred::Mock.new
+
+        ## Setup request
+        @request = Request.new(name)
+        @request.set_controller(controller)
+        @request.setup_controller_request_and_response
+      end
+
+      ##
+      # Apply global and scenario setups to request.
+      #
+      def apply_setup
+        ## Run global setup before example
+        Alfred.configuration.setup.each do |setup|
+          @request._setup(&setup)
+        end
+
+        ## Run setup blocks for scenario
+        setups.each { |setup| @request._setup(&setup) }
+      end
+
+      ##
+      # Perform request and assign response.
+      #
+      def perform_request
+        ## Perform request
+        @request.send(method, action, params)
+
+        ## Set response
+        @response = @request.response
+      end
+
+  end # Scenario
+end # Alfred

data/lib/alfred_rails/scenario_dsl.rb

@@ -0,0 +1,83 @@
+module Alfred
+  class ScenarioDSL
+
+    attr_accessor :scenario
+
+    def initialize(scenario)
+      @scenario = scenario
+    end
+
+    ##
+    # Apply setup to Scenario instance.
+    #
+    # === Params
+    #
+    # [block (Block)] the block to perform.
+    #
+    # === Example
+    #
+    #   setup do
+    #     User.create(:name => 'John Doe')
+    #   end
+    #
+    def setup(&block)
+      scenario.setups << block
+    end
+
+    ##
+    # Set the controller to test.
+    #
+    # === Params
+    #
+    # [controller (ActionController::Base)] the controller to test
+    #
+    # === Example
+    #
+    #   controller(ActionController::Base)
+    #
+    def controller(controller)
+      scenario.controller = controller
+    end
+
+    ##
+    # Respond to request methods
+    #
+    # === Examples
+    #
+    #   post :create, :post => { :title => 'Some title' }
+    #   get  :show, :id => 1
+    #
+    [
+      :get,
+      :post,
+      :patch,
+      :put,
+      :delete,
+      :head
+    ].each do |method|
+      define_method(method) do |*args|
+        setup_request_data(method, *args)
+      end
+    end
+
+    ##
+    # Setup request data.
+    #
+    # === Params
+    #
+    # [method (Sym)] request method
+    # [action (Sym)] controller and action
+    # [params (Hash)] request params
+    #
+    # === Example
+    #
+    #   setup_request(:get, :show, :id => 1)
+    #
+    def setup_request_data(method, action, params={})
+      scenario.method = method
+      scenario.action = action
+      scenario.params = params
+    end
+
+  end # ScenarioDSL
+end # Alfred