sayso-routing-filter 0.2.2.001

data/test/filters/all_filters/recognition.rb

@@ -0,0 +1,92 @@
+module Recognition
+  # 1 filter
+
+  test 'recognizes the path /some.html (extension)' do
+    params = self.params
+    assert_equal params, routes.recognize_path('/some.html')
+  end
+
+  test 'recognizes the path /de/some (locale)' do
+    params = self.params.merge(:locale => 'de')
+    assert_equal params, routes.recognize_path('/de/some')
+  end
+
+  test 'recognizes the path /some/page/2 (pagination)' do
+    params = self.params.merge(:page => 2)
+    assert_equal params, routes.recognize_path('/some/page/2')
+  end
+
+  test 'recognizes the path /:uuid/some (uuid)' do
+    params = self.params.merge(:uuid => uuid)
+    assert_equal params, routes.recognize_path("/#{uuid}/some")
+  end
+  
+  # extension with any
+
+  test 'recognizes the path /de/some.html (extension, locale)' do
+    params = self.params.merge(:locale => 'de')
+    assert_equal params, routes.recognize_path('/de/some.html')
+  end
+
+  test 'recognizes the path /some/page/2.html (extension, pagination)' do
+    params = self.params.merge(:page => 2)
+    assert_equal params, routes.recognize_path('/some/page/2.html')
+  end
+
+  test 'recognizes the path /:uuid/some.html (extension, uuid)' do
+    params = self.params.merge(:uuid => uuid)
+    assert_equal params, routes.recognize_path("/#{uuid}/some.html")
+  end
+
+  # locale with any
+
+  test 'recognizes the path /de/some/page/2 (locale, pagination)' do
+    params = self.params.merge(:locale => 'de', :page => 2)
+    assert_equal params, routes.recognize_path('/de/some/page/2')
+  end
+
+  test 'recognizes the path /de/:uuid/some (locale, uuid)' do
+    params = self.params.merge(:locale => 'de', :uuid => uuid)
+    assert_equal params, routes.recognize_path("/de/#{uuid}/some")
+  end
+
+  # pagination with any
+
+  test 'recognizes the path /:uuid/some/page/2 (pagination, uuid)' do
+    params = self.params.merge(:page => 2, :uuid => uuid)
+    assert_equal params, routes.recognize_path("/#{uuid}/some/page/2")
+  end
+
+  # extension, locale with any
+
+  test 'recognizes the path /de/some/page/2.html (extension, locale, pagination)' do
+    params = self.params.merge(:locale => 'de', :page => 2)
+    assert_equal params, routes.recognize_path("/de/some/page/2.html")
+  end
+
+  test 'recognizes the path /de/:uuid/some.html (extension, locale, uuid)' do
+    params = self.params.merge(:locale => 'de', :uuid => uuid)
+    assert_equal params, routes.recognize_path("/de/#{uuid}/some.html")
+  end
+  
+  # extension, pagination with any
+
+  test 'recognizes the path /some/page/2.html (extension, pagination, uuid)' do
+    params = self.params.merge(:page => 2, :uuid => uuid)
+    assert_equal params, routes.recognize_path("/#{uuid}/some/page/2.html")
+  end
+  
+  # locale, pagination with any
+
+  test 'recognizes the path /de/some/page/2 (locale, pagination, uuid)' do
+    params = self.params.merge(:locale => 'de', :page => 2, :uuid => uuid)
+    assert_equal params, routes.recognize_path("/de/#{uuid}/some/page/2")
+  end
+  
+  # all
+
+  test 'recognizes the path /de/:uuid/some/page/2.html (extension, locale, pagination, uuid)' do
+    params = self.params.merge(:locale => 'de', :page => 2, :uuid => uuid)
+    assert_equal params, routes.recognize_path("/de/#{uuid}/some/page/2.html")
+  end
+end

data/test/filters/all_filters_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+require 'filters/all_filters/generation'
+require 'filters/all_filters/recognition'
+
+class AllFiltersTest < Test::Unit::TestCase
+  attr_reader :routes, :params, :uuid
+
+  def setup
+    I18n.locale = nil
+    I18n.default_locale = :en
+    I18n.available_locales = %w(de en)
+
+    RoutingFilter::Locale.include_default_locale = false
+
+    @params = { :controller => 'some', :action => 'index' }
+    @uuid   = 'd00fbbd1-82b6-4c1a-a57d-098d529d6854'
+
+    @routes = draw_routes do
+      filter :uuid, :pagination ,:locale, :extension
+      match 'some', :to => 'some#index'
+    end
+  end
+
+  include Recognition, Generation
+end

data/test/filters/extension_test.rb

@@ -0,0 +1,54 @@
+require 'test_helper'
+
+class ForceExtensionTest < Test::Unit::TestCase
+  attr_reader :routes, :params
+
+  def setup
+    @routes = draw_routes do
+      filter :extension, :exclude => %r(^/(admin|$))
+      match '/',                  :to => 'some#index'
+      match 'some/:id(.:format)', :to => 'some#show'
+      match '/admin/some/new',    :to => 'some#new'
+    end
+    @params = { :controller => 'some', :action => 'show', :id => '1' }
+  end
+
+  test 'recognizes the path some/1.html and strips the extension' do
+    assert_nil routes.recognize_path('/some/1.html')[:format]
+  end
+
+  test 'recognizes the path some/1.xml but does not strip the extension' do
+    assert 'xml', routes.recognize_path('/some/1.xml')[:format]
+  end
+
+  test 'appends the extension .html to the generated path' do
+    assert_equal '/some/1.html', routes.generate(params)
+  end
+
+  test 'does not touch existing extensions in generated paths' do
+    assert_equal '/some/1.xml', routes.generate(params.merge(:format => 'xml'))
+  end
+
+  test 'does not touch url query params in generated paths' do
+    assert_equal '/some/1.html?foo=bar', routes.generate(params.merge(:foo => 'bar'))
+  end
+
+  test 'excludes / by default' do
+    assert_equal '/', routes.generate(:controller => 'some', :action => 'index')
+  end
+
+  test 'excludes / by default (with url query params)' do
+    assert_equal '/?foo=bar', routes.generate(:controller => 'some', :action => 'index', :foo => 'bar')
+  end
+
+  test 'excludes with custom regexp' do
+    assert_equal '/admin/some/new', routes.generate(:controller => 'some', :action => 'new')
+  end
+
+  # TODO - why would anyone want to have this?
+  #
+  # test 'does not exclude / when :exclude => false was passed' do
+  #   routes.filters.first.instance_variable_set(:@exclude, false)
+  #   assert_equal '/.html', routes.generate(:controller => 'some', :action => 'index')
+  # end
+end

data/test/filters/locale_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+class LocaleTest < Test::Unit::TestCase
+  attr_reader :routes, :show_params, :index_params
+
+  def setup
+    I18n.locale = nil
+    I18n.default_locale = :en
+    I18n.available_locales = %w(de en)
+
+    RoutingFilter::Locale.include_default_locale = true
+
+    @index_params = { :controller => 'some', :action => 'index' }
+    @show_params  = { :controller => 'some', :action => 'show', :id => '1' }
+
+    @routes = draw_routes do
+      filter :locale
+      match 'products/:id', :to => 'some#show'
+      match '/', :to => 'some#index'
+    end
+  end
+
+  test 'recognizes the path /en' do
+    assert_equal index_params.merge(:locale => 'en'), routes.recognize_path('/en')
+  end
+
+  test 'recognizes the path /en/' do
+    assert_equal index_params.merge(:locale => 'en'), routes.recognize_path('/en/')
+  end
+
+  test 'recognizes the path /en/products/1' do
+    assert_equal show_params.merge(:locale => 'en'), routes.recognize_path('/en/products/1')
+  end
+
+  test 'recognizes the path /de/products/1' do
+    assert_equal show_params.merge(:locale => 'de'), routes.recognize_path('/de/products/1')
+  end
+
+
+  test 'prepends the segments /:locale to the generated path / if the current locale is not the default locale' do
+    I18n.locale = 'de'
+    assert_equal '/de', routes.generate(index_params)
+  end
+
+  test 'prepends the segments /:locale to the generated path /products/1 if the current locale is not the default locale' do
+    I18n.locale = 'de'
+    assert_equal '/de/products/1', routes.generate(show_params)
+  end
+
+  test 'prepends the segments /:locale to the generated path if it was passed as a param' do
+    assert_equal '/de/products/1', routes.generate(show_params.merge(:locale => 'de'))
+  end
+
+  test 'prepends the segments /:locale if the given locale is the default_locale and include_default_locale is true' do
+    assert RoutingFilter::Locale.include_default_locale?
+    assert_equal '/en/products/1', routes.generate(show_params.merge(:locale => 'en'))
+  end
+
+  test 'does not prepend the segments /:locale if the current locale is the default_locale and include_default_locale is false' do
+    I18n.locale = 'en'
+    RoutingFilter::Locale.include_default_locale = false
+    assert_equal '/products/1', routes.generate(show_params)
+  end
+
+  test 'does not prepend the segments /:locale if the given locale is the default_locale and include_default_locale is false' do
+    RoutingFilter::Locale.include_default_locale = false
+    assert_equal '/products/1', routes.generate(show_params.merge(:locale => I18n.default_locale))
+  end
+end

data/test/filters/pagination_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+
+class PaginationTest < Test::Unit::TestCase
+  attr_reader :routes, :params
+
+  def setup
+    @routes = draw_routes do
+      filter :pagination
+      match 'some', :to => 'some#index'
+    end
+    @params = { :controller => 'some', :action => 'index', :page => 2 }
+  end
+
+  test 'recognizes the path some/page/2' do
+    assert_equal params, routes.recognize_path('/some/page/2')
+  end
+
+  test 'appends the segments /page/:page to the generated path if the passed :page param does not equal 1' do
+    assert_equal '/some/page/2', routes.generate(params)
+  end
+
+  test 'does not append anything to the generated path if the passed :page param equals 1' do
+    assert_equal '/some', routes.generate(params.merge(:page => 1))
+  end
+
+  test 'appends the segments /page/:page to the generated path but respects url query params' do
+    assert_equal '/some/page/2?foo=bar', routes.generate(params.merge(:foo => 'bar'))
+  end
+end

data/test/filters/uuid_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+class UuidTest < Test::Unit::TestCase
+  attr_reader :routes, :uuid, :params
+
+  def setup
+    @routes = draw_routes do
+      filter :uuid
+      match 'some/:id', :to => 'some#show'
+    end
+    @uuid   = 'd00fbbd1-82b6-4c1a-a57d-098d529d6854'
+    @params = { :controller => 'some', :action => 'show', :id => '1', :uuid => uuid }
+  end
+
+  test 'recognizes the path :uuid/product/1' do
+    assert_equal params, routes.recognize_path("/#{uuid}/some/1")
+  end
+
+  test 'prepends the :uuid segment to the generated path if passed as a param' do
+    assert_equal "/#{uuid}/some/1", routes.generate(params)
+  end
+
+  test 'matches uuid segments' do
+    pattern = Uuid::UUID_SEGMENT
+    uuids = %w(
+      d00fbbd1-82b6-4c1a-a57d-098d529d6854 cdb33760-94da-11df-981c-0800200c9a66
+      0c65a6ec-6491-4316-a137-0021cf4e6471 cbbd44c3-c195-48e5-be04-3cc8a6578f51
+    )
+    uuids.each { |uuid| assert pattern.match("/#{uuid}/"), "does not match /#{uuid}/ but should" }
+  end
+
+  test 'does not match non-uuid segments' do
+    pattern = Uuid::UUID_SEGMENT
+    uuids = %w(
+      !aaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa aaaa-aaaaaaaa-aaaa-aaaa-aaaaaaaaaaaa
+      aaaaaaaa_aaaa_aaaa_aaaa_aaaaaaaaaaaa aaaaaaaa-aaaa-aaaa-aaaaaaaaaaaa
+    )
+    uuids.each { |uuid| assert !pattern.match("/#{uuid}/"), "matches /#{uuid}/ but shouldn't" }
+  end
+end

data/test/rails_test.rb

@@ -0,0 +1,92 @@
+require 'test_helper'
+require "test_adapters/rails_#{ActionPack::VERSION::MAJOR}"
+
+class RailsTest < Test::Unit::TestCase
+  include TestRailsAdapter
+
+  I18n.available_locales = [:en, :de]
+
+  class TestsController < ActionController::Base
+    include Rails.application.routes.url_helpers if defined?(Rails)
+
+    def index
+      url = url_for(params.merge(:only_path => true))
+      render :text => params.merge(:url => url).inspect
+    end
+
+    def show
+      url = foo_path(params)
+      render :text => params.merge(:url => url).inspect
+    end
+  end
+
+  def params
+    response.status.to_s.include?('200') ? eval(response.body).symbolize_keys : {}
+  end
+
+  test "get to /" do
+    get '/'
+    assert_nil params[:locale]
+    assert_nil params[:page]
+    assert_nil params[:uuid]
+    assert_equal '/en.html', params[:url]
+  end
+
+  test "get to /foo/1" do
+    get '/foo/1'
+    assert_nil params[:locale]
+    assert_nil params[:page]
+    assert_nil params[:uuid]
+    assert_equal '/en/foo/1.html', params[:url]
+  end
+
+  test "get to /de" do
+    get '/de'
+    assert_equal 'de', params[:locale]
+    assert_nil params[:page]
+    assert_nil params[:uuid]
+    assert_equal '/de.html', params[:url]
+  end
+
+  test "get to /de/foo/1" do
+    get '/de/foo/1'
+    assert_equal 'de', params[:locale]
+    assert_nil params[:page]
+    assert_nil params[:uuid]
+    assert_equal '/de/foo/1.html', params[:url]
+  end
+
+  test "get to /page/2" do
+    get '/page/2'
+    assert_nil params[:locale]
+    assert_equal 2, params[:page]
+    assert_nil params[:uuid]
+    assert_equal '/en/page/2.html', params[:url]
+  end
+
+  test "get to /foo/1/page/2" do
+    get '/foo/1/page/2'
+    assert_nil params[:locale]
+    assert_equal 2, params[:page]
+    assert_nil params[:uuid]
+    assert_equal '/en/foo/1/page/2.html', params[:url]
+  end
+
+  test "get to /:uuid" do
+    uuid = 'd00fbbd1-82b6-4c1a-a57d-098d529d6854'
+    get "/#{uuid}"
+    assert_nil params[:locale]
+    assert_nil params[:page]
+    assert_equal uuid, params[:uuid]
+    assert_equal "/en/#{uuid}.html", params[:url]
+  end
+
+  test "get to /foo/1/:uuid" do
+    uuid = 'd00fbbd1-82b6-4c1a-a57d-098d529d6854'
+    get "/#{uuid}/foo/1"
+    assert_nil params[:locale]
+    assert_nil params[:page]
+    assert_equal uuid, params[:uuid]
+    assert_equal "/en/#{uuid}/foo/1.html", params[:url]
+  end
+end

data/test/routes_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+class RoutesTest < Test::Unit::TestCase
+  class RoutingFilter::Test < Filter
+    def around_recognize(path, env, &block)
+      'recognized'
+    end
+
+    def around_generate(*args, &block)
+      'generated'
+    end
+  end
+
+  attr_reader :routes
+
+  def setup
+    @routes = draw_routes { |set| set.filter :test }
+  end
+
+  test "routes.filter instantiates and registers a filter" do
+    assert routes.filters.first.is_a?(RoutingFilter::Test)
+  end
+
+  # test "filter.around_recognize is being called" do
+  #   assert_equal 'recognized', routes.recognize_path('/')
+  # end
+
+  test "filter.around_generate is being called" do
+    assert_equal 'generated', routes.generate({})
+  end
+end

data/test/routing_filter_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+include RoutingFilter
+
+class RoutingFilterTest < Test::Unit::TestCase
+  class FooFilter < Filter
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+
+    def foo(log, &block)
+      log << name
+      yield
+    end
+  end
+
+  attr_reader :chain
+
+  def setup
+    @chain = Chain.new
+    @chain.unshift FooFilter.new('custom filter')
+    @chain.unshift FooFilter.new('common filter')
+  end
+
+  test "filter.previous is nil for the first filter in the chain" do
+    assert_nil chain.first.previous
+  end
+
+  test "filter.previous returns the previous filter in the chain" do
+    assert_equal chain.first, chain.last.previous
+  end
+
+  test "filter.next is nil for the last filter in the chain" do
+    assert_nil chain.last.next
+  end
+
+  test "filter.next returns the next filter in the chain" do
+    assert_equal chain.last, chain.first.next
+  end
+
+  test "chain.run calls the given method on registered filters in reverse order" do
+    log = []
+    assert_equal 'common filter, custom filter, finalizer', chain.run(:foo, log, &lambda { log << 'finalizer' }).join(', ')
+  end
+end