excursion 0.0.4 → 0.0.5

data/spec/excursion/helpers_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+class Excursion::Specs::TestHelperOne
+  include Excursion::Helpers::ApplicationHelper
+end
+class Excursion::Specs::TestHelperTwo
+  include Excursion::Helpers::ApplicationHelper
+end
+
+describe 'Excursion' do
+  before(:each) do
+    Excursion::Pool.class_variable_set(:@@applications, {})
+    File.unlink(Excursion::Specs::DUMMY_POOL_FILE) if File.exists?(Excursion::Specs::DUMMY_POOL_FILE)
+    Excursion.configure do |config|
+      config.datastore = :file
+      config.datastore_file = Excursion::Specs::DUMMY_POOL_FILE
+    end
+  end
+
+  after(:each) do
+    Excursion::Pool.class_variable_set(:@@applications, {})
+    File.unlink(Excursion::Specs::DUMMY_POOL_FILE) if File.exists?(Excursion::Specs::DUMMY_POOL_FILE)
+    Excursion.configure do |config|
+      config.datastore = nil
+      config.datastore_file = nil
+      config.memcache_server = nil
+    end
+  end
+  
+  context '::url_helpers' do
+    it 'should provide access to application url helpers' do
+      Excursion::Pool.register_application(Rails.application)
+      expect { Excursion.url_helpers.dummy }.to_not raise_exception(NoMethodError)
+    end
+  end
+end
+
+describe 'Excursion::Helpers' do
+  before(:each) do
+    Excursion::Pool.class_variable_set(:@@applications, {})
+    File.unlink(Excursion::Specs::DUMMY_POOL_FILE) if File.exists?(Excursion::Specs::DUMMY_POOL_FILE)
+    Excursion.configure do |config|
+      config.datastore = :file
+      config.datastore_file = Excursion::Specs::DUMMY_POOL_FILE
+    end
+  end
+
+  after(:each) do
+    Excursion::Pool.class_variable_set(:@@applications, {})
+    File.unlink(Excursion::Specs::DUMMY_POOL_FILE) if File.exists?(Excursion::Specs::DUMMY_POOL_FILE)
+    Excursion.configure do |config|
+      config.datastore = nil
+      config.datastore_file = nil
+      config.memcache_server = nil
+    end
+  end
+  
+  it 'should share instances of helper classes' do
+    h1 = Excursion::Specs::TestHelperOne.new
+    h2 = Excursion::Specs::TestHelperTwo.new
+    Excursion::Pool.register_application(Rails.application)
+    h1.dummy.should eql(h2.dummy)
+    h1.dummy.should eql(Excursion::Specs::TestHelperOne.new.dummy)
+  end
+end

data/spec/excursion/pool/application_spec.rb

@@ -0,0 +1,214 @@
+require 'spec_helper'
+
+describe 'Excursion::Pool::Application' do
+
+  context '::new' do
+    it 'should require a name' do
+      expect { Excursion::Pool::Application.new }.to raise_exception(ArgumentError)
+    end
+
+    it 'should require a config hash' do
+      expect { Excursion::Pool::Application.new 'app_name' }.to raise_exception(ArgumentError)
+    end
+
+    it 'should accept an optional route collection' do
+      expect { Excursion::Pool::Application.new 'app_name', {} }.to_not raise_exception(ArgumentError)
+      expect { Excursion::Pool::Application.new 'app_name', {}, {} }.to_not raise_exception(ArgumentError)
+    end
+
+    it 'should return a populated Application object' do
+      mock = Excursion::Specs::Mocks::SIMPLE_APP
+      mock_routes = Excursion::Specs::Mocks::NAMED_ROUTES
+      
+      app = Excursion::Pool::Application.new mock[:name], {default_url_options: mock[:default_url_options], registered_at: mock[:registered_at]}, mock_routes
+      app.should be_an_instance_of(Excursion::Pool::Application)
+      app.name.should eql(mock[:name])
+      app.default_url_options.should eql(mock[:default_url_options])
+      mock_routes.each do |name,path|
+        app.routes.routes.keys.should include(name)
+      end
+    end
+  end
+
+  describe '::from_cache' do
+    it 'should require a cached application hash' do
+      expect { Excursion::Pool::Application.from_cache }.to raise_exception(ArgumentError)
+    end
+
+    it 'should return an Application object with the cached properties' do
+      mock = Excursion::Specs::Mocks::SIMPLE_APP
+      
+      app = Excursion::Pool::Application.from_cache(mock)
+      app.should be_an_instance_of(Excursion::Pool::Application)
+      app.name.should eql(mock[:name])
+      app.default_url_options.should eql(mock[:default_url_options])
+      mock[:routes].each do |name,path|
+        app.routes.routes.keys.should include(name)
+      end
+    end
+  end
+
+  describe '#to_cache' do
+    subject { Excursion::Pool::Application.from_cache(Excursion::Specs::Mocks::SIMPLE_APP) }
+
+    it 'should return a hash' do
+      subject.to_cache.should be_an_instance_of(Hash)
+    end
+
+    context 'returned hash' do
+      it 'should contain the app name' do
+        subject.to_cache[:name].should eql(subject.name)
+      end
+      
+      it 'should contain the default_url_options' do
+        subject.to_cache[:default_url_options].should eql(subject.default_url_options)
+      end
+
+      it 'should contain a hash of the routes' do
+        subject.to_cache[:routes].should be_an_instance_of(Hash)
+        subject.to_cache[:routes].each do |name,path|
+          subject.routes.routes.keys.should include(name)
+        end
+      end
+
+      it 'should contain the registered_at property' do
+        subject.to_cache[:registered_at].should eql(subject.instance_variable_get(:@registered_at))
+      end
+    end
+  end
+
+  describe '#from_cache' do
+    subject { Excursion::Pool::Application.new 'test_app', {} }
+
+    it 'should require a cached application object' do
+      expect { subject.from_cache }.to raise_exception(ArgumentError)
+    end
+
+    it 'should populate the object with the cached values' do
+      mock = Excursion::Specs::Mocks::SIMPLE_APP
+      subject.from_cache(mock)
+      subject.default_url_options.should eql(mock[:default_url_options])
+      subject.instance_variable_get(:@registered_at).to_i.should eql(mock[:registered_at].to_i)
+      subject.routes.each do |name,path|
+        mock[:routes].keys.should include(name)
+      end
+    end
+  end
+
+  describe '#route' do
+    subject { Excursion::Pool::Application.from_cache(Excursion::Specs::Mocks::SIMPLE_APP) }
+    
+    it 'should require a name' do
+      expect { subject.route }.to raise_exception(ArgumentError)
+    end
+
+    context 'when the route exists' do
+      it 'should return the route object' do
+        if Excursion.rails3?
+          subject.route(:example).should be_an_instance_of(Journey::Route)
+        elsif Excursion.rails4?
+          subject.route(:example).should be_an_instance_of(ActionDispatch::Journey::Route)
+        end
+      end
+    end
+
+    context 'when the route does not exist' do
+      it 'should return nil' do
+        subject.route(:non_existent_route).should be_nil
+      end
+    end
+  end
+
+  describe '#routes' do
+    subject { Excursion::Pool::Application.from_cache(Excursion::Specs::Mocks::SIMPLE_APP) }
+
+    it 'should return a NamedRouteCollection' do
+      subject.routes.should be_an_instance_of(ActionDispatch::Routing::RouteSet::NamedRouteCollection)
+    end
+  end
+
+  describe '#routes=' do
+    subject { Excursion::Pool::Application.new 'test_app', {} }
+    
+    it 'should accept a Hash of named routes' do
+      expect { subject.routes = {} }.to_not raise_exception(ArgumentError)
+    end
+
+    it 'should accept a NamedRouteCollection' do
+      expect { subject.routes = ActionDispatch::Routing::RouteSet::NamedRouteCollection.new }.to_not raise_exception(ArgumentError)
+    end
+
+    it 'should only accept a Hash or NamedRouteCollection' do
+      expect { subject.routes = 'test string' }.to raise_exception(ArgumentError)
+      expect { subject.routes = 123 }.to raise_exception(ArgumentError)
+      expect { subject.routes = :test_symbol }.to raise_exception(ArgumentError)
+      expect { subject.routes = [] }.to raise_exception(ArgumentError)
+      expect { subject.routes = Object }.to raise_exception(ArgumentError)
+      expect { subject.routes = Object.new }.to raise_exception(ArgumentError)
+    end
+    
+    context 'when passing a Hash' do
+      it 'should override the application routes with the ones provided' do
+        subject.routes = Hash[Excursion::Specs::Mocks::NAMED_ROUTES.collect {|k,v| [k,v] }]
+        Excursion::Specs::Mocks::NAMED_ROUTES.each do |name,path|
+          subject.routes.routes.keys.should include(name)
+        end
+      end
+    end
+
+    context 'when passing a NamedRouteCollection' do
+      it 'should override the application routes with the ones provided' do
+        subject.routes = Excursion::Specs::Mocks::NAMED_ROUTES
+        Excursion::Specs::Mocks::NAMED_ROUTES.each do |name,path|
+          subject.routes.routes.keys.should include(name)
+        end
+      end
+    end
+  end
+
+  describe '#set_routes' do
+    subject { Excursion::Pool::Application.new 'test_app', {} }
+    
+    context 'routes' do
+      it 'should be required' do
+        expect { subject.set_routes }.to raise_exception(ArgumentError)
+      end
+      
+      it 'should accept a Hash of named routes' do
+        expect { subject.set_routes({}) }.to_not raise_exception(ArgumentError)
+      end
+
+      it 'should accept a NamedRouteCollection' do
+        expect { subject.set_routes ActionDispatch::Routing::RouteSet::NamedRouteCollection.new }.to_not raise_exception(ArgumentError)
+      end
+
+      it 'should only accept a Hash or NamedRouteCollection' do
+        expect { subject.set_routes 'test string' }.to raise_exception(ArgumentError)
+        expect { subject.set_routes 123 }.to raise_exception(ArgumentError)
+        expect { subject.set_routes :test_symbol }.to raise_exception(ArgumentError)
+        expect { subject.set_routes [] }.to raise_exception(ArgumentError)
+        expect { subject.set_routes Object }.to raise_exception(ArgumentError)
+        expect { subject.set_routes Object.new }.to raise_exception(ArgumentError)
+      end
+    end
+    
+    context 'when passing a Hash' do
+      it 'should override the application routes with the ones provided' do
+        subject.set_routes Hash[Excursion::Specs::Mocks::NAMED_ROUTES]
+        Excursion::Specs::Mocks::NAMED_ROUTES.each do |name,path|
+          subject.routes.routes.keys.should include(name)
+        end
+      end
+    end
+
+    context 'when passing a NamedRouteCollection' do
+      it 'should override the application routes with the ones provided' do
+        subject.set_routes Excursion::Specs::Mocks::NAMED_ROUTE_COLLECTION
+        Excursion::Specs::Mocks::NAMED_ROUTES.each do |name,path|
+          subject.routes.routes.keys.should include(name)
+        end
+      end
+    end
+  end
+
+end

data/spec/excursion/pool_spec.rb

@@ -0,0 +1,203 @@
+require 'spec_helper'
+
+describe 'Excursion::Pool' do
+
+  describe '::datastore' do
+    cleaner = Proc.new do
+      Excursion::Pool.class_variable_set(:@@datastore, nil)
+      Excursion.configure do |config|
+        datastore = nil
+        datastore_file = nil
+        memcache_server = nil
+      end
+    end
+    before :each, &cleaner
+    after :each, &cleaner
+
+    it 'should require a configured datastore' do
+      expect { Excursion::Pool.datastore }.to raise_exception(Excursion::NoDatastoreError)
+    end
+
+    it 'should support the :file datastore' do
+      Excursion.configuration.datastore = :file
+      expect { Excursion::Pool.datastore }.to_not raise_exception(Excursion::NoDatastoreError)
+    end
+
+    it 'should support the :memcache datastore' do
+      Excursion.configuration.datastore = :memcache
+      expect { Excursion::Pool.datastore }.to_not raise_exception(Excursion::NoDatastoreError)
+    end
+
+    context 'when using the :file datastore' do
+      it 'should require the datastore_file option be configured' do
+        Excursion.configuration.datastore = :file
+        expect { Excursion::Pool.datastore }.to raise_exception(Excursion::DatastoreConfigurationError)
+      end
+
+      it 'should return an instance of Excursion::Datastores::File' do
+        Excursion.configuration.datastore = :file
+        Excursion.configuration.datastore_file = Excursion::Specs::DUMMY_POOL_FILE
+        Excursion::Pool.datastore.should be_an_instance_of(Excursion::Datastores::File)
+      end
+    end
+
+    context 'when using the :memcache datastore' do
+      it 'should require the memcache_server option be configured' do
+        Excursion.configuration.datastore = :memcache
+        expect { Excursion::Pool.datastore }.to raise_exception(Excursion::MemcacheConfigurationError)
+      end
+      
+      it 'should return an instance of Excursion::Datastores::Memcache' do
+        Excursion.configuration.datastore = :memcache
+        Excursion.configuration.memcache_server = Excursion::Specs::DUMMY_MEMCACHE_SERVER
+        Excursion::Pool.datastore.should be_an_instance_of(Excursion::Datastores::Memcache)
+      end
+    end
+  end
+
+  describe '::register_application' do
+    before(:each) do
+      Excursion::Pool.class_variable_set(:@@applications, {})
+      File.unlink(Excursion::Specs::DUMMY_POOL_FILE) if File.exists?(Excursion::Specs::DUMMY_POOL_FILE)
+      Excursion.configure do |config|
+        config.datastore = :file
+        config.datastore_file = Excursion::Specs::DUMMY_POOL_FILE
+      end
+    end
+    
+    after(:each) do
+      Excursion::Pool.class_variable_set(:@@applications, {})
+      File.unlink(Excursion::Specs::DUMMY_POOL_FILE) if File.exists?(Excursion::Specs::DUMMY_POOL_FILE)
+      Excursion.configure do |config|
+        config.datastore = nil
+        config.datastore_file = nil
+        config.memcache_server = nil
+      end
+    end
+
+    it 'should require a rails application as the only argument' do
+      expect { Excursion::Pool.register_application }.to raise_exception(ArgumentError)
+      expect { Excursion::Pool.register_application 'string arg' }.to raise_exception(ArgumentError)
+      expect { Excursion::Pool.register_application 123 }.to raise_exception(ArgumentError)
+      expect { Excursion::Pool.register_application :symbol_arg }.to raise_exception(ArgumentError)
+      expect { Excursion::Pool.register_application Object }.to raise_exception(ArgumentError)
+      expect { Excursion::Pool.register_application Object.new }.to raise_exception(ArgumentError)
+    end
+
+    it 'should add the application to the local hash pool' do
+      Excursion::Pool.class_variable_get(:@@applications).should_not have_key('dummy')
+      Excursion::Pool.register_application(Rails.application) # Use the dummy app class
+      Excursion::Pool.class_variable_get(:@@applications).should have_key('dummy')
+    end
+
+    it 'should set the application in the datastore pool' do
+      Excursion::Pool.datastore.get('dummy').should be_nil
+      Excursion::Pool.register_application(Rails.application) # Use the dummy app class
+      Excursion::Pool.datastore.get('dummy').should_not be_nil
+    end
+  end
+
+  describe '::remove_application' do
+    before(:each) do
+      Excursion::Pool.class_variable_set(:@@applications, {})
+      File.unlink(Excursion::Specs::DUMMY_POOL_FILE) if File.exists?(Excursion::Specs::DUMMY_POOL_FILE)
+      Excursion.configure do |config|
+        config.datastore = :file
+        config.datastore_file = Excursion::Specs::DUMMY_POOL_FILE
+      end
+    end
+    
+    after(:each) do
+      Excursion::Pool.class_variable_set(:@@applications, {})
+      File.unlink(Excursion::Specs::DUMMY_POOL_FILE) if File.exists?(Excursion::Specs::DUMMY_POOL_FILE)
+      Excursion.configure do |config|
+        config.datastore = nil
+        config.datastore_file = nil
+        config.memcache_server = nil
+      end
+    end
+    
+    it 'should require a rails application as the only argument' do
+      expect { Excursion::Pool.remove_application }.to raise_exception(ArgumentError)
+      expect { Excursion::Pool.remove_application 'string arg' }.to raise_exception(ArgumentError)
+      expect { Excursion::Pool.remove_application 123 }.to raise_exception(ArgumentError)
+      expect { Excursion::Pool.remove_application :symbol_arg }.to raise_exception(ArgumentError)
+      expect { Excursion::Pool.remove_application Object }.to raise_exception(ArgumentError)
+      expect { Excursion::Pool.remove_application Object.new }.to raise_exception(ArgumentError)
+    end
+
+    it 'should remove the application from the local hash pool' do
+      Excursion::Pool.class_variable_get(:@@applications).should_not have_key('dummy')
+      Excursion::Pool.register_application(Rails.application) # Use the dummy app class
+      Excursion::Pool.class_variable_get(:@@applications).should have_key('dummy')
+      Excursion::Pool.remove_application(Rails.application)
+      Excursion::Pool.class_variable_get(:@@applications).should_not have_key('dummy')
+    end
+
+    it 'should remove the application from the datastore pool' do
+      Excursion::Pool.datastore.get('dummy').should be_nil
+      Excursion::Pool.register_application(Rails.application) # Use the dummy app class
+      Excursion::Pool.datastore.get('dummy').should_not be_nil
+      Excursion::Pool.remove_application(Rails.application)
+      Excursion::Pool.datastore.get('dummy').should be_nil
+    end
+  end
+
+  describe '::application' do
+    before(:each) do
+      Excursion::Pool.class_variable_set(:@@applications, {})
+      File.unlink(Excursion::Specs::DUMMY_POOL_FILE) if File.exists?(Excursion::Specs::DUMMY_POOL_FILE)
+      Excursion.configure do |config|
+        config.datastore = :file
+        config.datastore_file = Excursion::Specs::DUMMY_POOL_FILE
+      end
+    end
+    
+    after(:each) do
+      Excursion::Pool.class_variable_set(:@@applications, {})
+      File.unlink(Excursion::Specs::DUMMY_POOL_FILE) if File.exists?(Excursion::Specs::DUMMY_POOL_FILE)
+      Excursion.configure do |config|
+        config.datastore = nil
+        config.datastore_file = nil
+        config.memcache_server = nil
+      end
+    end
+    
+    it 'should require an application name string' do
+      expect { Excursion::Pool.application }.to raise_exception(ArgumentError)
+    end
+    
+    context 'when the requested app exists' do
+      context 'in the local hash pool' do
+        before(:each) do
+          Excursion::Pool.register_application(Rails.application)
+        end
+
+        it 'should return the Application object' do
+          Excursion::Pool.class_variable_get(:@@applications).should have_key('dummy')
+          Excursion::Pool.application('dummy').should be_an_instance_of(Excursion::Pool::Application)
+          Excursion::Pool.application('dummy').should eql(Excursion::Pool.class_variable_get(:@@applications)['dummy'])
+        end
+      end
+
+      context 'in the datastore pool' do
+        before(:each) do
+          Excursion::Pool.register_application(Rails.application)
+          Excursion::Pool.class_variable_set(:@@applications, {})
+        end
+
+        it 'should return the Application object' do
+          Excursion::Pool.class_variable_get(:@@applications).should_not have_key('dummy')
+          Excursion::Pool.application('dummy').should be_an_instance_of(Excursion::Pool::Application)
+          Excursion::Pool.application('dummy').should eql(Excursion::Pool.class_variable_get(:@@applications)['dummy'])
+        end
+      end
+    end
+
+    context 'when the requested app does not exist' do
+      it 'should return nil' do
+        Excursion::Pool.application('dummy').should be_nil
+      end
+    end
+  end
+end

data/spec/excursion_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe 'Excursion' do
+end

data/spec/spec_helper.rb

@@ -1 +1,21 @@
-# TODO: specs!
+require File.expand_path("../dummy/config/environment", __FILE__)
+require 'rspec/core'
+#require 'rspec/rails'
+#require 'rspec/autorun'
+
+Dir[File.join(File.dirname(__FILE__), "support/**/*.rb")].each { |f| require f }
+
+RSpec.configure do |config|
+  #config.before(:suite) do
+  #end
+
+  #config.before(:each) do
+  #end
+
+  #config.around(:each) do |example|
+    #ActiveRecord::Base.transaction do
+    #  example.run
+    #  raise ActiveRecord::Rollback
+    #end
+  #end
+end

data/spec/support/mocks.rb

@@ -0,0 +1,51 @@
+module Excursion
+  module Specs
+    DUMMY_POOL_FILE = File.expand_path('../../dummy/tmp/spec_pool.yml', __FILE__)
+    DUMMY_MEMCACHE_SERVER = 'localhost:11211'
+
+    module Mocks
+      def self.journey_route(name, path)
+        if Excursion.rails3?
+          Journey::Route.new(name, Rails.application, Journey::Path::Pattern.new(path), {required_defaults: []})
+        elsif Excursion.rails4?
+          ActionDispatch::Journey::Route.new(name, Rails.application, ActionDispatch::Journey::Path::Pattern.new(path), {required_defaults: []})
+        end
+      end
+
+      SIMPLE_VALUES = {
+        'key1' => 'value_one',
+        'key2' => 'value_two',
+        'key3' => 'value_three',
+      }
+
+      SIMPLE_APP = {
+        name: 'simple_app',
+        routes: {
+          root: '/',
+          example: '/example',
+          with_id: '/example/:id'
+        },
+        default_url_options: {
+          host: 'www.example.com',
+          port: 3000
+        },
+        registered_at: Time.now
+      }
+
+      SIMPLE_ROUTES = {
+        test: '/test',
+        example_route: '/abc',
+        foo: '/this/is/foo',
+        bar: '/and/this/is/bar'
+      }
+
+      NAMED_ROUTES = Hash[SIMPLE_ROUTES.collect { |name,path|[name, journey_route(name, path)] }]
+      NAMED_ROUTE_COLLECTION = ActionDispatch::Routing::RouteSet::NamedRouteCollection.new
+      NAMED_ROUTES.each { |name,route| NAMED_ROUTE_COLLECTION.add(name, route) }
+
+      APP_POOL = {
+        SIMPLE_APP[:name] => SIMPLE_APP
+      }
+    end
+  end
+end