intermodal 0.0.1 → 0.4.0

data/spec/rack/auth_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Intermodal::Rack::Auth do
+  include Intermodal::RSpec::Rack
+  include SpecHelpers::Application
+
+  let(:application) { Intermodal::Rack::Auth }
+
+  context 'when successfully authenticating' do
+    let(:http_headers) { {
+      'X-Auth-Identity' => access_credential.identity,
+      'X-Auth-Key' => access_credential.key } }
+
+    request :get, '/' do
+      expects_status(204)
+      expects_empty_body # Make sure returned body responds to #each (String has no #each in 1.9)
+
+      it 'should respond with a valid X-Auth-Token header' do
+        response_headers.should be_include('X-Auth-Token')
+        AccessToken.authenticate!(response_headers['X-Auth-Token']).should eql(account)
+      end
+
+    end
+  end
+
+  context 'with invalid authentication credentials' do
+    let(:http_headers)  { {
+      'X-Auth-Identity' => 'no identity',
+      'X-Auth-Key' => 'no key' } }
+
+    request :get, '/' do
+      expects_status(401)
+      expects_empty_body # Make sure returned body responds to #each (String has no #each in 1.9)
+    end
+  end
+
+  context 'with invalid access token' do
+    let(:x_access_token) { 'invalid_key' }
+    let(:delete_access_token) { AccessToken::REDIS.del("auth:#{x_access_token}") }
+    let(:http_headers) do
+      delete_access_token
+      { 'X-Access-Token' => x_access_token }
+    end
+
+    request :get, '/' do
+      expects_status(401)
+      expects_empty_body # Make sure returned body responds to #each (String has no #each in 1.9)
+    end
+  end
+
+end

data/spec/requests/linked_resources.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Intermodal::ResourceController do
+  include Intermodal::RSpec::LinkedResources
+  include SpecHelpers::Application
+  include SpecHelpers::API
+
+  let(:api_class) do
+    define_class :Api, Rails::Engine do
+      include Intermodal::API
+      include SpecHelpers::Epiphyte
+
+      controllers do
+        link_resources_from :items, :to => :vendors, :model => Sku
+      end
+
+      routes.draw do
+        get    '/items/:id/vendors(.:format)', :to => 'items/vendors#index'
+        post   '/items/:id/vendors(.:format)', :to => 'items/vendors#create'
+        put    '/items/:id/vendors(.:format)', :to => 'items/vendors#update'
+        delete '/items/:id/vendors(.:format)', :to => 'items/vendors#destroy'
+      end
+    end
+  end
+
+  context 'when implemented within an api engine' do
+    link_resource :items, :to => :vendors, :with => Sku do
+      let(:model_parents) { [ item ] }
+      let(:model_collection) { skus; items.skus.to_sku_ids }
+      let(:unlinked_targets) { Sku.make!(3, :item => item) }
+      let(:skus) { item.vendors << vendors }
+      let(:vendors) { Vendor.make!(3, :account => account) }
+
+      expects_crud_for_linked_resource
+    end
+  end
+end

data/spec/requests/nested_resources_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Intermodal::NestedResourceController do
+  include Intermodal::RSpec::Resources
+  include SpecHelpers::Application
+  include SpecHelpers::API
+
+  let(:api_class) do
+    define_class :Api, Rails::Engine do
+      include Intermodal::API
+      include SpecHelpers::Epiphyte
+
+      map_data do
+        presentation_for :part do
+          presents :id
+          presents :item_id
+          presents :description
+        end
+
+        acceptance_for :part do
+          accepts :name
+        end
+      end
+
+      controllers do
+        nested_resources :items, :parts
+      end
+
+      routes.draw do
+        resources :items do
+          resources :parts, :controller => 'items/parts'
+        end
+      end
+    end
+  end
+
+  context 'when implemented within an api engine' do
+    let(:model_factory_options) { (model_parent ? { parent_names.last.to_s.singularize => model_parent } : {:account => account} ) }
+    let(:model_collection) do
+      3.times { model.make!(model_factory_options) }
+      (model_parent ? model.by_parent(model_parent) : model.by_account(account) )
+    end
+
+    resources [:items, :parts] do
+      let(:model_parents) { [ item ] }
+      let(:model) { Part }
+
+      given_create_attributes :name => 'New Part', :item_id => 1
+      given_update_attributes :name => 'Updated Part'
+
+      expects_resource_crud
+    end
+  end
+end

data/spec/requests/resources_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Intermodal::ResourceController do
+  include Intermodal::RSpec::Resources
+  include SpecHelpers::Application
+  include SpecHelpers::API
+
+  let(:api_class) do
+    define_class :Api, Rails::Engine do
+      include Intermodal::API
+      include SpecHelpers::Epiphyte
+
+      map_data do
+        presentation_for :item do
+          presents :id
+          presents :name
+          presents :description
+        end
+
+        acceptance_for :item do
+          accepts :name
+          accepts :description
+        end
+      end
+
+      controllers do
+        resources :items
+      end
+
+      routes.draw do
+        resources :items
+      end
+    end
+  end
+
+  context 'when implemented within an api engine' do
+    let(:model_factory_options) { (model_parent ? { parent_names.last.to_s.singularize => model_parent } : {:account => account} ) }
+    let(:model_collection) do
+      3.times { model.make!(model_factory_options) }
+      (model_parent ? model.by_parent(model_parent) : model.by_account(account) )
+    end
+
+    resources :items do
+      given_create_attributes :name => 'New Item', :description => 'Ipsum Lorem', :account_id => 1
+      given_update_attributes :name => 'Updated Merchant', :description => 'Lorem Ipsum'
+
+      expects_resource_crud
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,53 @@
+$LOAD_PATH.unshift '.'
+
+require 'intermodal'
+require 'rails'
+require 'active_record'
+
+require 'will_paginate/active_record'
+
+# TODO: Figure out how to load this automatically through the epiphyte
+require 'intermodal/proxies/will_paginate'
+::WillPaginate::Collection.send(:include, Intermodal::Proxies::WillPaginate::Collection)
+
+require 'action_controller'
+require 'rspec-rails'
+require 'database_cleaner'
+require 'machinist/active_record'
+require 'redis'
+require 'ap' # Debugging
+require 'pry'
+
+
+# Usage:
+# variable_to_watch.tap(&WATCH)
+WATCH = lambda { |o| ap o } unless defined?(WATCH)
+
+# Log to stderr
+Rails.logger = ActiveSupport::BufferedLogger.new($stderr, ActiveSupport::BufferedLogger::Severity::ERROR)
+
+# Turn this on for debugging
+ActiveRecord::Migration.verbose = false
+
+Dir["spec/support/**/*.rb"].map { |f| f.gsub(%r{.rb$}, '') }.each { |f| require f }
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+  config.filter_run :focus => true
+  config.filter_run_excluding :external => true
+  config.run_all_when_everything_filtered = true
+
+  # Uncomment to use with Rspec Rails
+  # If you'd prefer not to run each of your examples within a transaction,
+  # uncomment the following line.
+  #config.use_transactional_examples false
+
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :truncation # :transaction strategy currently does not work
+    DatabaseCleaner.clean_with :truncation
+  end
+
+  config.before(:each)  { DatabaseCleaner.start }
+  config.after(:each)   { DatabaseCleaner.clean }
+end
+

data/spec/support/api.rb

@@ -0,0 +1,50 @@
+module SpecHelpers
+  module API
+    extend ActiveSupport::Concern
+
+    included do
+      let(:application) { api }
+      let(:http_headers) { {'X-Auth-Token' => access_token.token } }
+
+      let(:api) do
+        api_class.tap do |a|
+          stub_warden_serializer
+          stub_abstract_store
+          a.instance.initializers.reject! { |initializer| skipped_initializers.include? initializer.name }
+
+          a.instance.initialize!
+        end
+      end
+
+      # TODO: REFACTOR
+      # This has to be done because we're using a custom serializer to Redis
+      # The right thing to do is to use Warden's serialization. This allows
+      # people to use their own authentication scheme besides the built-in one
+      # (and possibly spin off the built-in auth as its own gem).
+      let(:stub_warden_serializer) do
+        class Warden::SessionSerializer
+          def store(user, scope)
+          end
+
+          def fetch(scope)
+          end
+
+          def stored?(scope)
+            false
+          end
+
+          def delete(scope, user=nil)
+          end
+        end
+      end
+      let(:stub_abstract_store) do
+        class ::ActionDispatch::Session::AbstractStore
+          def destroy_session(env, sid, options) 
+          end
+        end
+      end
+
+      let(:skipped_initializers) { [:add_routing_paths, :append_assets_path, :prepend_helpers_path] }
+    end
+  end
+end

data/spec/support/app/class_builder.rb

@@ -0,0 +1,41 @@
+# Taken from Remarkable 4.0.0 alpha
+# https://github.com/remarkable/remarkable/blob/1e653044dfb9726034f600bae13d81e9986c44f6/remarkable_activerecord/spec/support/model_builder.rb
+
+require 'machinist/active_record'
+
+module SpecHelpers
+  module ClassBuilder
+    extend ActiveSupport::Concern
+
+    def unload_class(class_name)
+      Object.send(:remove_const, class_name) if Object.const_defined?(class_name)
+    end
+
+    def define_class(class_name, base, &block)
+      class_name = class_name.to_s.camelize
+
+      unload_class(class_name)
+
+      Class.new(base).tap do |klass|
+        Object.const_set(class_name, klass)
+        klass.class_eval(&block) if block_given?
+      end
+    end
+
+    def define_model_class(class_name, base = nil, &block)
+      base = base || ActiveRecord::Base
+      klass = define_class(class_name, base) do
+        #extend Machinist::Machinable
+        #include Machinist::Blueprints
+        #include Machinist::ActiveRecordExtensions
+
+        #def self.blueprint_class
+        #  Machinist::ActiveRecord::Blueprint
+        #end
+      end
+
+      klass.class_eval(&block) if block_given?
+      klass
+    end
+  end
+end

data/spec/support/app/db/adapter_helper.rb

@@ -0,0 +1,53 @@
+module SpecHelpers
+  module Adapter
+    extend ActiveSupport::Concern
+
+    CONFIGURATIONS = {
+      :postgresql => {
+        :adapter => "postgresql",
+        :username => "postgres",
+        :password => "",
+        :database => "test",
+        :min_messages => "ERROR" },
+      :postgresql_admin => {
+        :adapter => "postgresql",
+        :username => "postgres",
+        :password => "",
+        :database => "admin",
+        :min_messages => "ERROR" }, 
+      # :postgresql_admin is used to connect in; :postgresql is used to actually test the migrations
+      :mysql => {
+        :adapter => 'mysql',
+        :host => 'localhost',
+        :username => 'root',
+        :database => 'test' }, 
+      :sqlite3 => {
+        :adapter => "sqlite3",
+        :database => ":memory:" } }
+
+    included do
+      let(:database_env) { CONFIGURATIONS[database_type] }
+      let(:database_name) { database_env[:database] }
+      let(:postgres_admin_env) { CONFIGURATIONS[:postgresql_admin] }
+
+      let(:recreate_database) do
+        if database_type.to_s == 'sqlite3'
+          ActiveRecord::Base.establish_connection(database_env)
+          next
+        end
+
+        ActiveRecord::Base.establish_connection(CONFIGURATIONS[:postgresql_admin]) if database_type.to_s == 'postgresql'
+
+        ActiveRecord::Base.connection.drop_database(database_name)
+        ActiveRecord::Base.connection.create_database(database_name)
+
+        if database_type.to_s == 'postgresql'
+          ActiveRecord::Base.connection.disconnect!
+          ActiveRecord::Base.establish_connection(database_env)
+        else
+          ActiveRecord::Base.connection.reset!
+        end
+      end
+    end
+  end
+end

data/spec/support/app/db/authentication_schema_helper.rb

@@ -0,0 +1,62 @@
+require 'spec/support/app/db/adapter_helper'
+require 'spec/support/app/db/migration_helper'
+require 'spec/support/app/class_builder'
+
+module SpecHelpers
+  module AuthenticationSchema
+    extend ActiveSupport::Concern
+
+    included do
+      include SpecHelpers::Adapter
+      include SpecHelpers::Migration
+      include SpecHelpers::ClassBuilder
+
+      # Simulates rake db:migrate
+      let(:auth_db_migrate) { create_accounts; create_account_credentials }
+      let(:db_migrate) { auth_db_migrate }
+
+      # Simulates rake db:recreate
+      let(:db_recreate) { recreate_database; db_migrate }
+
+      # Schema Migrations
+      let(:create_accounts) do
+        create_table :accounts do |t|
+          t.string :name
+        end
+      end
+
+      # Note: Properly, account_id should be a foreign key reference
+      # but this is not important for the purpose of testing Intermodal
+      let(:create_account_credentials) do
+        create_table :access_credentials do |t|
+          t.integer :account_id
+          t.string  :identity
+          t.string  :key
+        end
+      end
+
+      let(:establish_redis_connection) { AccessToken.establish_connection! }
+
+      # Shims
+      let(:shims) { [shim_for_account, shim_for_access_credential, shim_for_access_token] }
+
+      let(:shim_for_account) do
+        define_model_class :Account do
+          include Intermodal::Models::Account
+        end
+      end
+
+      let(:shim_for_access_credential) do
+        define_model_class :AccessCredential do
+          include Intermodal::Models::AccessCredential
+        end
+      end
+
+      let(:shim_for_access_token) do
+        define_class :AccessToken, Object do
+          include Intermodal::Models::AccessToken
+        end
+      end
+    end
+  end
+end