intermodal 0.0.1 → 0.4.0

data/lib/intermodal/rspec/requests/request_validations.rb

@@ -0,0 +1,36 @@
+module Intermodal
+  module RSpec
+    module RequestValidations
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # This macro expects the following to be defined:
+        # let(:valid_payload) { request_payload that would succeed }
+        #
+        # You then pass a override hash and the expected response code,
+        # usually a 400 Bad Request or 422 Unprocessible Entity
+        #
+        # In overrides, if you pass a callable object such as a lambda or a proc,
+        # then it will be called at test time before merging into the request payload.
+        #
+        # Example:
+        #
+        # overrides: { apple: -> { tree.apples.sample } }
+        def expect_request_invalid(message, opts={}, &additional_examples)
+          _status     = opts[:status] || 422
+          _overrides  = opts[:overrides] or raise 'Must pass overrides: parameter'
+
+          context "when #{message}" do
+            let(:request_payload) { attributes.merge(overrides) }
+            let(:overrides)       { Hash[_overrides.map(&eval_hash)] }
+            let(:eval_hash)       { ->(x) { [x[0].to_s, maybe_call.(x[1]) ] } }
+            let(:maybe_call)      { ->(x) { x.respond_to?(:call) ? x.call : x } }
+
+            expects_status _status
+            instance_eval(&additional_examples) if additional_examples
+          end
+        end
+      end
+    end
+  end
+end

data/lib/intermodal/rspec/requests/resources.rb

@@ -0,0 +1,275 @@
+module Intermodal
+  module RSpec
+    module Resources
+      extend ActiveSupport::Concern
+
+      included do
+        include Intermodal::RSpec::Rack
+        include Intermodal::RSpec::AuthenticatedRequests
+        include Intermodal::RSpec::PaginatedCollection
+
+        let(:api) { raise "Must define let(:api)" }
+
+        let(:resource_collection_name) { resource_name.pluralize }
+        let(:model) { resource_name.camelize.constantize }
+        let(:parent_models) { parent_names.map { |p| p.to_s.singularize.camelize.constantize } }
+
+        let(:model_collection) do
+          3.times { model.make!(model_factory_options) }
+          (model_parent ? model.by_parent(model_parent) : model.all )
+        end
+
+        let(:model_resource) { model.make!(model_factory_options) }
+        let(:model_factory_options) { (model_parent ? { parent_names.last.to_s.singularize => model_parent } : {} ) }
+        let(:model_parents) { parent_models.map { |p| p.make! } }
+        let(:model_parent) { model_parents.last }
+        let(:presenter) { api.presenter_for model }
+
+        let(:collection) { model_collection }
+        let(:paginated_collection) { model_collection.paginate(:page => page, :per_page => per_page) }
+        let(:presented_collection) { parser.decode(paginated_collection.send("to_#{format}", :presenter => presenter, :root => collection_element_name, :scope => presenter_scope_for_index)) }
+        let(:page) { 1 }
+        let(:per_page) { api.default_per_page }
+
+        let(:resource_element_name) { model.name.demodulize.underscore }
+        let(:collection_element_name) { resource_element_name.pluralize }
+        let(:expected_resource) { model.find(model_resource.id) }
+        let(:persisted_resource_id) { body['id'] }
+        let(:resource_after_create) { model.find(persisted_resource_id) }
+        let(:resource_after_update) { model.find(resource_id) }
+        let(:resource_after_destroy) { resource_after_update }
+        let(:resource) { parser.decode(expected_resource.send("to_#{format}", :presenter => presenter, :scope => presenter_scope)) }
+        let(:presenter_scope) { nil }
+        let(:presenter_scope_for_index) { presenter_scope }
+        let(:resource_id) { resource['id'] }
+        let(:parent_ids) { parent_names.zip(model_parents.map { |m| m.id }) }
+
+        let(:namespace) { nil }
+        let(:namespace_path) { ( namespace ? "/#{namespace}" : nil ) }
+        let(:parent_path) { parent_ids.map { |p, p_id| "/#{p}/#{p_id}" }.join }
+        let(:collection_url) { [ namespace_path, parent_path, "/#{resource_collection_name}.#{format}" ].join }
+        let(:resource_url) { [ namespace_path, parent_path, "/#{resource_collection_name}/#{resource_id}.#{format}" ].join }
+
+        let(:request_json_payload) { request_payload.to_json }
+        let(:request_xml_payload) { request_payload.to_xml(:root => resource_element_name) }
+
+        let(:malformed_json_payload) { '{ "bad": [ "data": ] }' }
+        let(:malformed_xml_payload) { '<bad><data></bad></data>' }
+
+        # DELETE specs expect record to be deleted.
+        # Override this if you are using something such as ActiveResource:
+        # let(:record_not_found_error) { ActiveResource::ResourceNotFound }
+        let(:record_not_found_error) { ActiveRecord::RecordNotFound }
+
+        # Some of the test examples assume that the database is blank.
+        # For example, index tests require injecting 3 resources and expects
+        # the index endpoint to return exactly 3 resources.
+        let(:reset_datastore!) { } # Do nothing by default
+      end
+
+      module ClassMethods
+        def given_create_attributes(values = {})
+          let(:valid_create_attributes) { values }
+        end
+
+        def given_update_attributes(values = {})
+          let(:valid_update_attributes) { values }
+        end
+
+        def metadata_for_resources(resource_name, options = {})
+          if resource_name.is_a?(Array)
+            parents = resource_name
+            resource_name = parents.pop
+          end
+          resource_name = resource_name.to_s if resource_name.is_a?(Symbol)
+
+          { :formats => [ :json ],
+            :resource_name => resource_name,
+            :model_name => resource_name.singularize,
+            :encoding => 'utf-8',
+            :parents => parents || [],
+            :namespace_path => ( options[:namespace] ? "/#{options[:namespace]}" : nil )
+          }.merge(options)
+        end
+
+        def metadata_for_formatted_resource(format, options = {})
+          { :format => format,
+            :collection_url => collection_url_for_resource(options[:namespace_path], options[:parents], options[:resource_name], format),
+            :resource_url => resource_url_for_resource(options[:namespace_path], options[:parents], options[:resource_name], format),
+            :mime_type => Mime::Type.lookup_by_extension(format).to_s
+          }.merge(options)
+        end
+
+        def parent_path_for_resource(parents)
+          parents.map { |p| "/#{p}/:id" }.join
+        end
+
+        def collection_url_for_resource(namespace, parents, resource_name, format)
+          [ namespace, parent_path_for_resource(parents), "/#{resource_name}.#{format}" ].join
+        end
+
+        def resource_url_for_resource(namespace, parents, resource_name, format)
+          [ namespace, parent_path_for_resource(parents), "/#{resource_name}/:id.#{format}" ].join
+        end
+
+        def resources(resource_name, options = {}, &blk)
+          options = metadata_for_resources(resource_name, options)
+          _resource_name = options[:resource_name].singularize
+
+          # If you want xml, pass it as formats: [ :json, :xml ]
+          options[:formats].each do |format|
+            format_options = metadata_for_formatted_resource(format, options)
+            context format_options[:collection_url], format_options do
+              let(:namespace) { options[:namespace] }
+              let(:resource_name) { _resource_name }
+              let(:parent_names) { options[:parents] }
+              let(:format) { format }
+              let(options[:parents].last) { model_parent } if options[:parents].last
+              instance_eval(&blk) if blk
+            end
+          end
+        end
+
+        def expects_resource_crud(options = {}, &additional_examples)
+          expected_actions = options[:only] || [ :index, :show, :create, :update, :destroy ]
+          expected_actions -= options[:except] if options[:except]
+
+          expected_actions.each do |action|
+            send("expects_#{action}")
+          end
+
+          instance_eval(&additional_examples) if additional_examples
+        end
+
+        STANDARD_SUCCESSFUL_STATUS_FOR = {
+          :index => 200,
+          :show => 200,
+          :create => 201,
+          :update => 200,
+          :destroy => 204 }
+
+        STANDARD_REQUEST_FOR = {
+          :index => { :method => :get, :end_point => :collection_url },
+          :show => { :method => :get, :end_point => :resource_url },
+          :create => { :method => :post, :end_point => :collection_url, :payload => proc do valid_create_attributes end },
+          :update => { :method => :put, :end_point => :resource_url, :payload => proc do valid_update_attributes end },
+          :destroy => { :method => :delete, :end_point => :resource_url } }
+
+        def request_resource_action(action, options = {}, &blk)
+          options = {
+            :mime_type => metadata[:mime_type],
+            :encoding => metadata[:encoding],
+            :status => STANDARD_SUCCESSFUL_STATUS_FOR[action],
+            :collection_url => metadata[:collection_url],
+            :resource_url => metadata[:resource_url]
+          }.merge(STANDARD_REQUEST_FOR[action]).merge(options)
+
+          request options[:method], options[options[:end_point]], options[:payload] do
+            let(:request_url) { send(options[:end_point]) }
+            expects_status(options[:status])
+            expects_content_type(options[:mime_type], options[:encoding])
+            instance_eval(&blk) if blk
+          end
+        end
+
+        def expects_index(options = {}, &additional_examples)
+          request_resource_action(:index, options) do
+            unless options[:skip_presentation_test]
+              it "should return a list of all #{metadata[:resource_name]}" do
+                reset_datastore!
+                collection.should_not be_empty
+                body.should eql(presented_collection)
+              end
+            end
+
+            expects_unauthorized_access_to_respond_with_401
+            unless options[:skip_pagination_examples]
+              expects_paginated_resource do
+                before(:each) { reset_datastore! }
+              end
+            end
+            instance_eval(&additional_examples) if additional_examples
+          end
+        end
+
+        def expects_show(options = {}, &additional_examples)
+          request_resource_action(:show, options) do
+            it "should return a #{metadata[:resource_name]} of id 1" do
+              resource.should_not be_nil
+              body.should eql(resource)
+            end
+
+            with_non_existent_resource_should_respond_with_404
+            expects_unauthorized_access_to_respond_with_401
+            instance_eval(&additional_examples) if additional_examples
+          end
+        end
+
+        def expects_create(options = {}, &additional_examples)
+          request_resource_action(:create, options) do
+            it "should return the newly created #{metadata[:resource_name]}" do
+              body.should eql(parser.decode(resource_after_create.send("to_#{format}", { :presenter => presenter, :scope => presenter_scope})))
+            end
+
+            with_malformed_data_should_respond_with_400
+            expects_unauthorized_access_to_respond_with_401
+            instance_eval(&additional_examples) if additional_examples
+          end
+        end
+
+        def expects_update(options = {}, &additional_examples)
+          request_resource_action(:update, options) do
+            it "should update #{metadata[:resource_name]}" do
+              response.should_not be(nil)
+              valid_update_attributes.each do |updated_attribute, updated_value|
+                resource_after_update[updated_attribute].should eql(updated_value)
+              end
+            end
+
+            with_malformed_data_should_respond_with_400
+            with_non_existent_resource_should_respond_with_404
+            expects_unauthorized_access_to_respond_with_401
+            instance_eval(&additional_examples) if additional_examples
+          end
+        end
+
+        def expects_destroy(options = {}, &additional_examples)
+          request_resource_action(:destroy, {mime_type: nil, encoding: nil}.merge(options)) do
+            it "should delete #{metadata[:resource_name]}" do
+              response.should_not be(nil)
+              lambda { resource_after_destroy }.should raise_error(record_not_found_error)
+            end
+
+            with_non_existent_resource_should_respond_with_404
+            expects_unauthorized_access_to_respond_with_401
+            instance_eval(&additional_examples) if additional_examples
+          end
+        end
+
+        def with_malformed_data_should_respond_with_400
+          context "with malformed #{metadata[:format]} payload" do
+            let(:request_raw_payload) { send("malformed_#{format}_payload") }
+
+            expects_status(400)
+            expects_content_type(metadata[:mime_type], metadata[:encoding])
+          end
+        end
+
+        def with_non_existent_resource_should_respond_with_404
+          context 'with non-existent resource' do
+            let(:resource_id) { 0 } # Assumes that persisted datastore never uses id of 0
+            expects_status 404
+          end
+        end
+
+        def expects_json_presentation(_presenter_scope = nil)
+          let(:presenter_scope) { _presenter_scope } if _presenter_scope
+
+          it 'should present a JSON object' do
+            body.should eql(presented_resource)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/intermodal/rspec/requests/rfc2616_status_codes.rb

@@ -0,0 +1,51 @@
+module Intermodal
+  module RSpec
+    module HTTP
+      RFC2616_HTTP_STATUS_CODES = 
+        [[100, "Continue"],
+          [101, "Switching Protocols"],
+          [200, "OK"],
+          [201, "Created"],
+          [202, "Accepted"],
+          [203, "Non-Authoritative Information"],
+          [204, "No Content"],
+          [205, "Reset Content"],
+          [206, "Partial Content"],
+          [300, "Multiple Choices"],
+          [301, "Moved Permanently"],
+          [302, "Found"],
+          [303, "See Other"],
+          [304, "Not Modified"],
+          [305, "Use Proxy"],
+          [306, "(Unused)"],
+          [307, "Temporary Redirect"],
+          [400, "Bad Request"],
+          [401, "Unauthorized"],
+          [402, "Payment Required"],
+          [403, "Forbidden"],
+          [404, "Not Found"],
+          [405, "Method Not Allowed"],
+          [406, "Not Acceptable"],
+          [407, "Proxy Authentication Required"],
+          [408, "Request Timeout"],
+          [409, "Conflict"],
+          [410, "Gone"],
+          [411, "Length Required"],
+          [412, "Precondition Failed"],
+          [413, "Request Entity Too Large"],
+          [414, "Request-URI Too Long"],
+          [415, "Unsupported Media Type"],
+          [416, "Requested Range Not Satisfiable"],
+          [417, "Expectation Failed"],
+          [422, "Unprocessable Entity"],
+          [500, "Internal Server Error"],
+          [501, "Not Implemented"],
+          [502, "Bad Gateway"],
+          [503, "Service Unavailable"],
+          [504, "Gateway Timeout"],
+          [505, "HTTP Version Not Supported"]]
+
+      STATUS_CODES = RFC2616_HTTP_STATUS_CODES.inject({}) { |h, e| h[e[0].to_s]=e[1]; h }
+    end
+  end
+end

data/lib/intermodal/rspec/validators.rb

@@ -0,0 +1,86 @@
+require 'active_support/concern'
+
+module Intermodal
+  module RSpec
+    module Validators
+      extend ActiveSupport::Concern
+
+      included do
+        # Make sure to define:
+        #   let(:resource)                    # resource to be tested
+        #   let(:associated_resource)         # association and resource both owned by same account
+        #   let(:invalid_associated_resource) # association and resource owned by different account
+        #
+        # Optional
+        #   let(:attribute) # Attribute being validated
+        #   let(:message)   # Error message
+        #
+        def self.validates_same_account(association, &additional_examples)
+          context "validates #{association} is owned by same account" do
+            let(:attribute) { association }
+            let(:message)   { 'must belong to the same account' }
+
+            context 'when association belongs to same account' do
+              it 'should be_valid' do
+                expect(resource.account_id).to eql(associated_resource.account_id)
+                expect(resource).to be_valid
+                expect(resource.errors).not_to have_key(attribute)
+              end
+            end
+
+            context 'when association belongs to a different account' do
+              before(:each) { resource.send("#{association}=", invalid_associated_resource) }
+
+              it 'should not be valid and report the error' do
+                expect(resource.account_id).not_to eql(invalid_associated_resource.account_id)
+                expect(resource).not_to be_valid
+                expect(resource.errors).to have_key(attribute)
+                expect(resource.errors[attribute]).to include(message)
+              end
+            end
+
+            instance_eval(&additional_examples) if additional_examples
+          end
+        end
+
+        # Make sure to define:
+        #   let(:resource)                    # resource to be tested
+        #   let(:associated_resource)         # association and resource owned by different accounts
+        #   let(:invalid_associated_resource) # association and resource both owned by same account
+        #
+        # Optional
+        #   let(:attribute) # Attribute being validated
+        #   let(:message)   # Error message
+        #
+        def self.validates_different_account(association, &additional_examples)
+          context "validates #{association} is owned by a different account" do
+            let(:attribute) { association }
+            let(:message)   { 'must belong to a different account' }
+
+            context 'when association belongs to same account' do
+              before(:each) { resource.send("#{association}=", invalid_associated_resource) }
+
+              it 'should not be valid' do
+                expect(resource.account_id).to eql(invalid_associated_resource.account_id)
+                expect(resource).not_to be_valid
+                expect(resource.errors).to have_key(attribute)
+                expect(resource.errors[attribute]).to include(message)
+              end
+            end
+
+            context 'when association belongs to a different account' do
+
+              it 'should not be valid and report the error' do
+                expect(resource.account_id).not_to eql(associated_resource.account_id)
+                expect(resource).to be_valid
+                expect(resource.errors).not_to have_key(attribute)
+              end
+            end
+
+            instance_eval(&additional_examples) if additional_examples
+          end
+        end
+      end
+    end
+  end
+end