intermodal 0.0.1 → 0.4.0

data/lib/intermodal/rspec/models/sanitization.rb

@@ -0,0 +1,84 @@
+module Intermodal
+  module RSpec
+    module Sanitization
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def expects_sanitization_of(_field, _options, &additional_examples)
+          # We are not trying to retest the sanitizer so much as lightly demonstrating
+          # idempotence. That is, repeated calls to the sanitizer should produce the
+          # same output
+
+          context _field.inspect do
+            subject { resource.update_attributes!(updated_attributes); resource }
+            let(:updated_attributes) { { _field => value } }
+            let(:accepted_tags) { _options[:accepted_tags] }
+            let(:rejected_tags) { _options[:rejected_tags] }
+
+            context 'with a random string' do
+              let(:value) { SecureRandom.hex(16) }
+              it 'should leave it alone' do
+                expect(subject).not_to be_changed     # Check update has persisted
+                expect(subject.send(_field)).to eql(value)
+              end
+            end
+
+            context 'with approved html tag' do
+              let(:tag)     { accepted_tags.sample }
+              let(:content) { SecureRandom.hex(16) }
+              let(:value)   { "<#{tag}>#{content}</#{tag}>" }
+              it 'should leave it alone' do
+                expect(subject).not_to be_changed     # Check update has persisted
+                expect(subject.send(_field)).to eql(value)
+              end
+            end
+
+            context 'with tag not on whitelist' do
+              let(:tag)     { rejected_tags.sample }
+              let(:content) { SecureRandom.hex(16) }
+              let(:value)   { "<#{tag}>#{content}</#{tag}>" }
+              it 'should sanitize tag' do
+                expect(subject).not_to be_changed     # Check update has persisted
+                expect(subject.send(_field)).to eql(content)
+              end
+            end
+
+            instance_eval(&additional_examples) if additional_examples
+          end
+        end
+
+        def expects_stripping_of(_field, &additional_examples)
+          # We are not trying to retest the sanitizer so much as lightly demonstrating
+          # idempotence. That is, repeated calls to the sanitizer should produce the
+          # same output
+
+          context _field.inspect do
+            subject { resource.update_attributes!(updated_attributes); resource }
+            let(:updated_attributes) { { _field => value } }
+            let(:rejected_tags) { %w(p div span ol ul li em strong) }
+
+            context 'with a random string' do
+              let(:value) { SecureRandom.hex(16) }
+              it 'should leave it alone' do
+                expect(subject).not_to be_changed     # Check update has persisted
+                expect(subject.send(_field)).to eql(value)
+              end
+            end
+
+            context 'with any tag' do
+              let(:tag)     { rejected_tags.sample }
+              let(:content) { SecureRandom.hex(16) }
+              let(:value)   { "<#{tag}>#{content}</#{tag}>" }
+              it 'should sanitize tag' do
+                expect(subject).not_to be_changed     # Check update has persisted
+                expect(subject.send(_field)).to eql(content)
+              end
+            end
+
+            instance_eval(&additional_examples) if additional_examples
+          end
+        end
+      end
+    end
+  end
+end

data/lib/intermodal/rspec/presenters.rb

@@ -0,0 +1,92 @@
+module Intermodal
+  module RSpec
+    module Presenters
+      extend ActiveSupport::Concern
+      included do
+        extend ::Intermodal::RSpec::Macros::Presenters
+
+        let(:resource) { model.make! }
+        let(:resource_name) { model.name.demodulize.underscore }
+        let(:presenter) { api.presenter_for(model) }
+        let(:presentation) { presenter.call(resource, :scope => scope).with_indifferent_access }
+        let(:scope) { :default }
+
+        def expects_presentation(input, expectation)
+          field = input.keys[0]
+          presenter.call(input.with_indifferent_access, :scope => scope)[field].should eql(expectation)
+        end
+      end
+    end
+
+    module Macros
+      module Presenters
+        def concerned_with_presentation(_model, &blk)
+          describe _model do
+            let(:model) { _model }
+            subject { model }
+
+            context "when concerned with presentation" do
+              instance_eval(&blk) if blk
+            end
+          end
+        end
+
+        def scoped_to(_scope, &blk)
+          context "when scoped to #{_scope}" do
+            let(:scope) { _scope }
+            instance_eval(&blk) if blk
+          end
+        end
+
+        def exposes(*fields)
+          fields.each do |field|
+            it "should present #{field}" do
+              presentation.should contain(field)
+            end
+          end
+        end
+
+        def hides(*fields)
+          fields.each do |field|
+            it "should not present #{field}" do
+              presentation.should_not contain(field)
+            end
+          end
+        end
+
+        def exposes_resource
+          context 'when exposing resource fields' do
+            exposes 'id', 'created_at', 'updated_at'
+          end
+        end
+
+        def exposes_named_resource
+          context 'when exposing named resource fields' do
+            exposes_resource
+            exposes 'name'
+          end
+        end
+
+        def exposes_linked_resources(linked_resources_name, options = {})
+          _linked_resource_name, _linking_association = linked_resources_name.to_s.singularize, options[:with]
+          context "when exposing linked resources, #{_linked_resource_name}" do
+            let(:linked_resource_ids_name) { :"#{_linked_resource_name}_ids" }
+            let(:linking_association) { :"#{_linking_association}" }
+            let(:linked_resource_ids) { resource.send(linking_association).send("to_#{linked_resource_ids_name}").to_a }
+            let(:presented_linked_ids) { presentation[linked_resource_ids_name].to_a }
+
+            exposes "#{_linked_resource_name}_ids" 
+            it "should present \"#{_linked_resource_name}_ids\" as a collection of ids" do
+              resource
+              (presented_linked_ids - linked_resource_ids).should be_empty
+              (linked_resource_ids - presented_linked_ids).should be_empty
+            end
+
+            pending "should only present \"#{_linked_resource_name}_ids\" scoped to account"
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Intermodal
+  module RSpec
+    module AuthenticatedRequests
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def expects_unauthorized_access_to_respond_with_401
+          context 'with unauthorized access credentials' do
+            let(:http_headers) { { 'X-Auth-Token' => '', 'Accept' => 'application/json' } }
+
+            expects_status(401)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,180 @@
+module Intermodal
+  module RSpec
+    module LinkedResources
+      extend ActiveSupport::Concern
+
+      included do
+        include Intermodal::RSpec::Resources
+      end
+
+      module ClassMethods
+        def link_resource(parent_resource, options = {}, &blk)
+          metadata[:parent_resource] = options[:parent_resource] = parent_resource
+          metadata[:target_resources] = options[:to]
+          metadata[:linking_resource_model] = options[:with]
+
+          _target_resources = options[:to]
+
+          resource_options = {
+            :namespace => options[:namespace]
+          }
+          resources [metadata[:parent_resource].to_s.pluralize, metadata[:target_resources]], resource_options do
+            let(:model) { options[:with] }
+            let(:model_parents) { [ send(options[:parent_resource]) ] }
+            let(:unlinked_targets) { raise "Override :unlinked_targets with let()" }
+            let(:target_resources) { _target_resources }
+            let(:collection_element_name) { "#{target_resources.to_s.singularize}_ids" }
+            let(:paginated_collection) { collection }
+            let(:resource_element_name) { parent_resource }
+            let(:presentation_root) { options[:parent_resource] }
+            let(:collection_proxy) do
+              Intermodal::Proxies::LinkingResources.new presentation_root,
+                :to => target_resources,
+                :with => collection,
+                :parent_id => model_parents.first.id
+            end
+            let(:presented_collection) { parser.decode(collection_proxy.send("to_#{format}")) }
+            instance_eval(&blk)
+          end
+        end
+
+        def expects_crud_for_linked_resource
+          expects_index :skip_pagination_examples => true do
+            it 'should include the parent id' do
+              collection.should_not be_empty
+              body[resource_element_name.to_s]['id'].should eql(model_parents.first.id)
+            end
+          end
+
+          expects_list_replace
+          expects_list_append
+          expects_list_remove
+        end
+
+        def expects_list_replace(&blk)
+          _metadata = metadata
+          request :post, metadata[:collection_url] do
+            let(:request_url) { collection_url }
+            let(:replacement_target_ids) { unlinked_targets.map(&:id) }
+            let(:request_payload) { { collection_element_name => replacement_target_ids } }
+            let(:updated_target_ids) { model.by_parent(model_parent).to_target_ids }
+
+            instance_eval(&blk) if blk
+
+            expects_status(201)
+            expects_content_type(metadata[:mime_type], metadata[:encoding])
+
+            with_malformed_data_should_respond_with_400
+            with_nil_target_ids_should_respond_with_422
+            expects_unauthorized_access_to_respond_with_401
+
+            context 'with empty payload' do
+              let(:request_payload) { { collection_element_name => [] } }
+
+              expects_status(201)
+              expects_content_type(metadata[:mime_type], metadata[:encoding])
+
+              it 'should reset resource linking' do
+                response.should_not be_empty
+                updated_target_ids.should be_empty
+              end
+            end
+
+            it "should link #{metadata[:target_resources]} to #{metadata[:parent_resource]}" do
+              model_collection.should_not be_empty
+              response.should_not be_empty
+              replacement_target_ids.each do |replacement_target_id|
+                updated_target_ids.should include(replacement_target_id)
+              end
+            end
+
+            it "should delete original linked #{metadata[:target_resources]}" do
+              model_collection.should_not be_empty
+              response.should_not be_empty
+              model_collection.each do |original_target_id|
+                updated_target_ids.should_not include(original_target_id)
+              end
+            end
+          end
+        end
+
+        def expects_list_append(&blk)
+          _metadata = metadata
+          request :put, metadata[:collection_url] do
+            instance_eval(&blk) if blk
+            let(:request_url) { collection_url }
+            let(:additional_target_ids) { unlinked_targets.map(&:id) }
+            let(:request_payload) { { collection_element_name => additional_target_ids } }
+            let(:updated_target_ids) { model.by_parent(model_parent).to_target_ids }
+
+            expects_status(200)
+            expects_content_type(metadata[:mime_type], metadata[:encoding])
+
+            it 'should link additional targets to manufacturer' do
+              model_collection.should_not be_empty
+              response.should_not be_empty
+              additional_target_ids.each do |additional_target_id|
+                updated_target_ids.should include(additional_target_id)
+              end
+            end
+
+            it 'should append to, but not delete original linked targets' do
+              model_collection.should_not be_empty
+              response.should_not be_empty
+              model_collection.each do |original_target_id|
+                updated_target_ids.should include(original_target_id)
+              end
+            end
+
+            with_malformed_data_should_respond_with_400
+            with_nil_target_ids_should_respond_with_422
+            expects_unauthorized_access_to_respond_with_401
+          end
+        end
+
+        def expects_list_remove(&blk)
+          _metadata = metadata
+          request :delete, metadata[:collection_url] do
+            instance_eval(&blk) if blk
+            let(:request_url) { collection_url }
+            let(:deleted_target_ids) { model_collection[0..1] }
+            let(:remaining_target_ids) { model_collection - deleted_target_ids }
+            let(:request_payload) { { collection_element_name => deleted_target_ids } }
+            let(:updated_target_ids) { model.by_parent(model_parent).to_target_ids }
+
+            expects_status(200)
+            expects_content_type(metadata[:mime_type], metadata[:encoding])
+
+            it 'should delete linked targets' do
+              deleted_target_ids.should_not be_empty
+              response.should_not be_empty
+              deleted_target_ids.each do |deleted_target_id|
+                updated_target_ids.should_not include(deleted_target_id)
+              end
+            end
+
+            it 'should keep remaining targets' do
+              deleted_target_ids.should_not be_empty
+              response.should_not be_empty
+              remaining_target_ids.each do |remaining_target_id|
+                updated_target_ids.should include(remaining_target_id)
+              end
+            end
+
+            with_malformed_data_should_respond_with_400
+            with_nil_target_ids_should_respond_with_422
+            expects_unauthorized_access_to_respond_with_401
+          end
+        end
+
+        def with_nil_target_ids_should_respond_with_422
+          context 'without nil ids ' do
+            let(:request_payload) { { collection_element_name => nil } }
+            expects_status(422)
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+module Intermodal
+  module RSpec
+    module PaginatedCollection
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def expects_paginated_resource(options = {}, &customizations)
+          # Default behavior for will_paginate
+          options[:page] ||= 1
+          options[:collection_name]
+
+          context 'when paginating' do
+            let(:expected_total_pages) { collection.size/per_page + 1 }
+            let(:expected_total_entries) { collection.size }
+            let(:collection_element_name) { options[:collection_name] } if options[:collection_name]
+            let(:responded_collection_metadata) do
+              case format
+              when :xml
+                body[collection_element_name.to_s]
+              else
+                body
+              end
+            end
+
+            instance_eval(&customizations) if customizations
+
+            if options[:empty_collection]
+              it 'should have an empty collection' do
+                body[collection_element_name.to_s].should be_empty
+              end
+            else
+              it 'should have a collection' do
+                collection
+                body[collection_element_name.to_s].should_not be_empty
+              end
+            end
+
+            it "should be on page #{options[:page]}" do
+              collection
+              responded_collection_metadata['page'].should eql(options[:page])
+            end
+
+            it 'should have total_pages' do
+              collection
+              responded_collection_metadata['total_pages'].should eql(expected_total_pages)
+            end
+
+            it 'should have total_entries' do
+              collection
+              responded_collection_metadata['total_entries'].should eql(expected_total_entries)
+            end
+          end
+        end
+
+        # Some version of WillPaginate steps on this
+        alias expects_pagination expects_paginated_resource
+      end
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+module Intermodal
+  module RSpec
+    module Rack
+      extend ActiveSupport::Concern
+
+      class SimpleXMLParser
+        def self.decode(*args)
+          Hash.from_xml(*args)
+        end
+      end
+
+      included do
+        subject { response }
+
+        # Define the Rack Application you are testing
+        let(:application) { fail NotImplementedError, 'Must define let(:application)' }
+        let(:http_headers) { Hash.new }
+        # let(:request_headers) { rack_compliant_headers(http_headers) }
+        let(:request_url_prefix) { '' }
+
+        let(:response) { application.call(request) }
+        let(:status) { response[0] }
+        let(:response_headers) { response[1] }
+        let(:content_type) { response_headers['Content-Type'] }
+        let(:raw_body) do
+          # http://rack.rubyforge.org/doc/files/SPEC.html
+          # Rack Spec says response[2] should respond to #each and we
+          # cannot gaurantee this is an ActionDispatch::Response
+
+          # This calls each on all the chunks in-memory and gives it back as a whole string
+
+          [].tap do |out|
+            response[2].each do |chunk|
+              out << chunk
+            end
+          end.join
+        end
+        let(:body) { parser.decode(raw_body) }
+
+        let(:json_parser) { MultiJson }
+        let(:xml_parser) { SimpleXMLParser }
+
+        let(:parser) do
+          case format
+          when :json
+            json_parser
+          when :xml
+            xml_parser
+          end
+        end
+
+        # Override to change payload Content-Type
+        let(:request_payload_mime_type) { Mime::Type.lookup_by_extension(format).to_s }
+
+        # Override to change JSON payload builder
+        let(:request_json_payload) { request_payload.to_json }
+
+        # Override to change XML payload builder
+        let(:request_xml_payload) { request_payload.to_xml }
+
+        # Override to send arbitrary payloads
+        let(:request_raw_payload) { send("request_#{format}_payload") unless request_payload.nil? }
+
+        let(:expected_mime_type) { Mime::Types.lookup_by_extension(format).to_s }
+        let(:expected_encoding) { 'utf-8' }
+
+        # Broken out so you can use this outside of let()
+        def rack_compliant_headers(_headers = {})
+          _headers.to_a.inject({}) do |m,kv|
+            m.tap do |_m|
+              _h, _v = kv
+              _m["HTTP_#{_h}".underscore.upcase] = _v
+            end
+          end
+        end
+
+        def rack_compliant_request(_method, _url, _headers, _body, format = :json)
+          _payload_mime_type = (format.is_a?(Symbol) ? Mime::Type.lookup_by_extension(format) : format)
+          req_opts = { :method => _method }.merge(rack_compliant_headers(_headers))
+          req_opts[:input] = _body
+          ::Rack::MockRequest.env_for(_url, req_opts).tap do |_r|
+            _r.merge!({ 'CONTENT_TYPE' => _payload_mime_type.to_s }) unless _body.nil?
+          end
+        end
+      end
+
+      module ClassMethods
+        def request(method, _url, payload = nil, &blk)
+          describe "#{method.to_s.upcase} #{_url}" do
+            rack_request(method, _url, &payload)
+            instance_eval(&blk)
+          end
+        end
+
+        def rack_request(method, _url, _format = nil, &_payload)
+          _format = _format # Scope for closure
+          _payload = proc do nil end unless _payload
+
+          let(:format) { _format } if _format
+          let(:request) { rack_compliant_request(method,
+                                                 request_url_prefix + request_url,
+                                                 http_headers,
+                                                 request_raw_payload,
+                                                 (request_raw_payload ? request_payload_mime_type : nil) ) }
+          let(:request_url) { _url }
+          let(:request_payload, &_payload)
+        end
+
+        def expects_status(response_status)
+          it "should respond with status #{response_status} #{Intermodal::RSpec::HTTP::STATUS_CODES[response_status.to_s]}" do
+            status.should eql(response_status)
+          end
+        end
+
+        def expects_content_type(mime_type, charset = nil)
+          if mime_type
+            it "should respond with content type of #{mime_type}" do
+              content_type.should match(%r{^#{mime_type}})
+            end
+            if charset
+              it "should respond encoded in #{charset}" do
+                content_type.should match(%r{charset=#{charset}})
+              end
+            end
+          else
+            it "should not respond with content type" do
+              content_type.should be_nil
+            end
+          end
+
+        end
+
+        def expects_empty_body
+          it "should respond with a Rack-compliant empty body" do
+            response[2].should be_empty
+            response[2].should be_respond_to(:each)
+          end
+        end
+      end
+    end
+  end
+end