emerson 0.1.0.pre.1 → 0.1.0.pre.2

data/spec/emerson/scope_spec.rb

@@ -0,0 +1,146 @@
+require "spec_helper"
+
+describe Emerson::Scope, :type => :controller do
+  render_views
+  let!(:products) { resources(:product, 2) }
+
+  controller(:products)
+
+  before do
+    templates do
+      def index
+        <<-ERB
+        <ul>
+          <% products.each do |product| %>
+          <li><%= product.name %></li>
+          <% end %>
+        </ul>
+        ERB
+      end
+    end
+  end
+
+  describe ".scope" do
+    context "called without a 'resources' argument" do
+      it "raises an exception" do
+        expect {
+          controller_class.class_eval do
+            scope :by => :user
+          end
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "called without the :by requirement" do
+      it "raises an exception" do
+        expect {
+          controller_class.class_eval do
+            scope :products
+          end
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe "#current_scope" do
+    let(:user) { resource(:user) }
+
+    before do
+      user.products = [products.first]
+
+      controller do
+        scope :products, :by => :user
+
+        def index
+          render(:json => { :user => current_scope.id })
+        end
+      end
+    end
+
+    it "returns the record representing the current scope" do
+      get(:index, :user_id => user.id)
+      expect(response).to send_json({
+        :user => user.id
+      })
+    end
+
+    context "detailed scope configurations and environments" do
+      it "is pending" do
+        pending "TODO"
+      end
+    end
+  end
+
+  describe "#scoped" do
+    context "without a scope configuration" do
+      before do
+        controller do
+          def index
+            respond_with(scoped)
+          end
+        end
+      end
+  
+      it "selects the resource using the default scope, from the controller name" do
+        get(:index)
+        expect(response.body).to have_css('ul > li', :text => products[0].name)
+        expect(response.body).to have_css('ul > li', :text => products[1].name)
+      end
+    end
+  
+    context "with a scope configuration" do
+      let(:user) { resource(:user) }
+
+      before do
+        user.products = [products.first]
+
+        controller do
+          scope :products, :by => :user
+
+          def index
+            respond_with(scoped)
+          end
+        end
+      end
+
+      context "given no scoping environment" do
+        it "selects the resource using the default scope, from configuration" do
+          get(:index)
+          expect(response.body).to have_css('ul > li', :text => products[0].name)
+          expect(response.body).to have_css('ul > li', :text => products[1].name)
+        end
+      end
+
+      context "given a scoping environment based on request params" do
+        it "selects the resource using the provided scope" do
+          get(:index, :user_id => user.id)
+          expect(response.body).to     have_css('ul > li', :text => products[0].name)
+          expect(response.body).to_not have_css('ul > li', :text => products[1].name)
+        end
+      end
+    end
+
+    context "with a scope configuration and a scoping environment as a specific object" do
+      let(:user) { resource(:user) }
+
+      before do
+        user.products = [products.first]
+
+        controller.stub(:user) { user }
+        controller do
+          scope :products, :by => :user
+
+          def index
+            respond_with(scoped(user))
+          end
+        end
+      end
+
+      it "selects the resource using the provided scope" do
+        get(:index)
+        expect(response.body).to     have_css('ul > li', :text => products[0].name)
+        expect(response.body).to_not have_css('ul > li', :text => products[1].name)
+      end
+    end
+  end
+end

data/spec/emerson_spec.rb

@@ -0,0 +1,105 @@
+require "spec_helper"
+
+describe Emerson do
+  let(:features) { Emerson.features }
+
+  around do |example|
+    with_features(features) { example.run }
+  end
+
+  describe ".responder_enabled?" do
+    context "with the default feature set" do
+      it "returns true" do
+        expect(Emerson).to be_responder_enabled
+      end
+    end
+
+    context "when the configured feature set is :all" do
+      let(:features) { :all }
+
+      it "returns true" do
+        expect(Emerson).to be_responder_enabled
+      end
+    end
+
+    context "when the configured feature set includes :responder" do
+      let(:features) { [:responder] }
+
+      it "returns true" do
+        expect(Emerson).to be_responder_enabled
+      end
+    end
+
+    context "when the configured feature set is nil" do
+      let(:features) { nil }
+
+      it "returns false" do
+        expect(Emerson).to_not be_responder_enabled
+      end
+    end
+
+    context "when the configured feature set is false" do
+      let(:features) { false }
+
+      it "returns false" do
+        expect(Emerson).to_not be_responder_enabled
+      end
+    end
+
+    context "when the configured feature set is []" do
+      let(:features) { [] }
+
+      it "returns false" do
+        expect(Emerson).to_not be_responder_enabled
+      end
+    end
+  end
+
+  describe ".scope_enabled?" do
+    context "with the default feature set" do
+      it "returns true" do
+        expect(Emerson).to be_scope_enabled
+      end
+    end
+
+    context "when the configured feature set is :all" do
+      let(:features) { :all }
+
+      it "returns true" do
+        expect(Emerson).to be_scope_enabled
+      end
+    end
+
+    context "when the configured feature set includes :scope" do
+      let(:features) { [:scope] }
+
+      it "returns true" do
+        expect(Emerson).to be_scope_enabled
+      end
+    end
+
+    context "when the configured feature set is nil" do
+      let(:features) { nil }
+
+      it "returns false" do
+        expect(Emerson).to_not be_scope_enabled
+      end
+    end
+
+    context "when the configured feature set is false" do
+      let(:features) { false }
+
+      it "returns false" do
+        expect(Emerson).to_not be_scope_enabled
+      end
+    end
+
+    context "when the configured feature set is []" do
+      let(:features) { [] }
+
+      it "returns false" do
+        expect(Emerson).to_not be_scope_enabled
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,67 @@
+# This file is copied to spec/ when you run 'rails generate rspec:install'
+ENV["RAILS_ENV"] ||= 'test'
+require File.expand_path("../dummy/config/environment", __FILE__)
+require 'rspec/rails'
+require 'rspec/autorun'
+require 'capybara/rspec'
+require 'ffaker'
+
+require 'emerson/matchers'
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[Rails.root.join("../support/**/*.rb")].each {|f| require f}
+
+Capybara.register_driver :firefox do |app|
+  Capybara::Selenium::Driver.new(app, :browser => :firefox)
+end
+
+RSpec.configure do |config|
+  config.include Capybara::RSpecMatchers
+  config.include Support::ControllerHelpers
+  config.include Support::FeatureHelpers
+  config.include Support::ResourceHelpers
+  config.include Support::TemplateHelpers
+
+  # ## Mock Framework
+  #
+  # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+
+  # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
+  config.fixture_path = "#{::Rails.root}/spec/support/fixtures"
+
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, remove the following line or assign false
+  # instead of true.
+  config.use_transactional_fixtures = true
+
+  # If true, the base class of anonymous controllers will be inferred
+  # automatically. This will be the default behavior in future versions of
+  # rspec-rails.
+  config.infer_base_class_for_anonymous_controllers = false
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = "random"
+
+  config.before do
+    reset_resources
+  end
+
+  config.after do
+    reset_resources
+  end
+end
+
+Emerson.setup do |config|
+  # Uncomment this line to specify a custom fixture path for Emerson. It will
+  # default to the RSpec fixture path and is required for the response tests.
+  #
+  # config.fixture_path = "#{::Rails.root}/spec/support/fixtures"
+end

data/spec/support/helpers/controller_helpers.rb

@@ -0,0 +1,98 @@
+module Support
+  module ControllerHelpers
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Override `ControllerExampleGroup.controller` for some nice sugar.
+      # See instance method below.
+      def controller(key, base = nil)
+        klass = Class.new(base || ApplicationController) do
+          include Emerson::Response
+        end
+
+        klass.class_eval <<-CODE
+          def self.name
+            @_name ||= [key, 'controller'].join('_').camelcase
+          end
+
+          def self.key
+            @_key ||= '#{key}'.intern
+          end
+
+          def #{key}
+            resources
+          end
+
+          def resources=(value)
+            @resources = value
+          end
+
+          def resources
+            @resources
+          end
+
+          # Scope helper
+          def class_for(type)
+            "Support::ResourceHelpers::\#{type.to_s.classify}".constantize
+          end
+        CODE
+
+        metadata[:example_group][:described_class] = klass
+
+        before do
+          @_resource_type = key
+        end
+      end
+    end
+
+    # Add `#controller` ExampleGroup instance method which, combined with the
+    # overriden class method above, provides the ability to:
+    #
+    # @example
+    #   describe "GET #index" do
+    #     controller(:products)
+    #
+    #     before do
+    #       controller do
+    #         def index
+    #           respond_with(products)
+    #         end
+    #       end
+    #     end
+    #
+    #     it "is successful" do
+    #       get(:index)
+    #       expect(response).to be_success
+    #     end
+    #   end
+    def controller(*args, &body)
+      if block_given?
+        controller_class.class_eval(&body)
+
+        resource_set = self.instance_variable_get('@_resources')
+        resource_set = self.instance_variable_get('@__memoized') unless resource_set.present?
+        resource_key = "#{controller_class.key}".singularize.intern
+
+        @controller.resources = (resource_set[resource_key] || resource_set[controller_class.key])
+      end
+
+      super()
+    end
+
+    def controller_class
+      described_class
+    end
+
+    # Wrap `ActionController::TestCase::Behavior` actions in
+    # a warm routing embrace.
+    def process(*)
+      with_routing do |routes|
+        routes.instance_eval "
+          draw { resources #{@_resource_type.inspect} }
+        "
+
+        super
+      end
+    end
+  end
+end

data/spec/support/helpers/feature_helpers.rb

@@ -0,0 +1,12 @@
+module Support
+  module FeatureHelpers
+    def with_features(enabled, &block)
+      originals = Emerson.features
+      Emerson.features = enabled
+
+      yield
+
+      Emerson.features = originals
+    end
+  end
+end

data/spec/support/helpers/resource_helpers.rb

@@ -0,0 +1,95 @@
+require 'virtus'
+
+module Support
+  module ResourceHelpers
+    def reset_resources
+      Product.records = []
+      User.records    = []
+    end
+
+    def resource(type)
+      resources(type)[0]
+    end
+
+    def resources(type, count = nil)
+      @_resources ||= {}
+
+      if count.present? || @_resources[type].blank?
+        model   = resource_class(type)
+        count ||= 1
+        count.times { model.create }
+
+        @_resources[type] = model.records
+      end
+
+      @_resources[type]
+    end
+
+    def resource_class(type)
+      case type
+      when :product
+        Product
+      when :user
+        User
+      end
+    end
+
+    class Base
+      include Virtus
+      extend  ActiveModel::Naming
+      include ActiveModel::Conversion
+      include ActiveModel::Validations
+
+      attribute :id,   Fixnum, :default => :default_id
+      attribute :name, String, :default => :default_name
+
+      class_attribute :records
+      self.records = []
+
+      # Emulating ActiveRecord class methods
+      class << self
+        def create
+          record = self.new
+
+          self.records << record
+          record
+        end
+
+        def find(id)
+          self.records.first { |r| r.id == id.to_i }
+        end
+
+        def scoped
+          self.records
+        end
+      end
+
+      def default_id
+        Faker::Lorem.word
+      end
+
+      def default_name
+        Faker::Lorem.word
+      end
+    end
+
+    class Product < Base
+      def default_name
+        Faker::Product.product_name
+      end
+    end
+
+    class User < Base
+      attribute :products, Array, :default => :default_products
+
+      # self.records = []
+      def default_name
+        Faker::Name.name.gsub(/[']/, '')
+      end
+
+      def default_products
+        [Product.new, Product.new]
+      end
+    end
+  end
+end