restful-capabilities 0.0.2

data/test/unit/adapters/tc_get_handler_mixin.rb

@@ -0,0 +1,342 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+#############################################################################
+#
+#  Copyright (c) 2019 Razor Risk Technologies Pty Limited. All rights reserved.
+#
+#############################################################################
+
+$:.unshift File.join(File.dirname(__FILE__), *(['..'] * 3), 'lib')
+
+
+# ##########################################################
+# requires
+
+require 'razor_risk/cassini/testing/suppress_pantheios_logging' unless $DEBUG
+
+require 'razor_risk/cassini/applications/route_verb_adaptors/capabilities/get_handler_mixin'
+
+require 'razor_risk/razor/connectivity/test_doubles/razor_requester/returns_given_response'
+require 'razor_risk/razor/connectivity/razor_3/response'
+
+require 'test/unit'
+
+# ##########################################################
+# Tests
+
+class TestGetHandlerMixin < Test::Unit::TestCase
+
+    include ::RazorRisk::Cassini::Applications::RouteVerbAdaptors
+    include ::RazorRisk::Cassini::Applications::RouteVerbAdaptors::Capabilities
+
+    include ::RazorRisk::Razor::Connectivity::Razor3
+    include ::RazorRisk::Razor::Connectivity::Razor3::EntityConnectors
+    include ::RazorRisk::Razor::Connectivity::TestDoubles::RazorRequester
+
+    class MockStruct
+
+        def self.create(*args)
+
+            args = [:procs] if args.empty?
+
+            Struct.new(*args) do
+
+                def method_missing(method, *args)
+                    unless method == :procs
+                        if procs
+                            if procs[method]
+                                procs[method].call(*args)
+                            end
+                        end
+                    end
+                end
+
+                yield if block_given?
+            end
+        end
+    end
+
+    class MockHandler
+
+        include ::RazorRisk::Cassini::Applications::RouteVerbAdaptors::Capabilities::GetHandlerMixin
+
+        attr_reader :settings
+        attr_reader :statuses
+        attr_reader :content_types
+
+        attr_accessor :procs
+
+        def initialize credentials, razor_requester
+
+            @procs = {}
+            @credentials = credentials
+            @settings = Struct
+                .new(:razor_requester, :request_options)
+                .new(razor_requester, {})
+        end
+
+        def get_required_credentials
+            @credentials
+        end
+
+        def status status
+            @statuses ||= []
+            @statuses << status
+        end
+
+        def content_type type
+            @content_types ||= []
+            @content_types << type
+        end
+
+        def halt *args
+            @procs[:halt].call(*args) if @procs[:halt]
+
+            raise HaltException
+        end
+
+        def method_missing(method, *args)
+            @procs[method].call(*args) if @procs[method]
+        end
+    end
+
+    class HaltException < StandardError; end
+
+    def test_is_defined
+
+        assert_const_defined Capabilities, :GetHandlerMixin
+    end
+end
+
+class TestInitialization < TestGetHandlerMixin
+
+    def test_initialization
+
+        rr = ReturnsGivenResponse.new(nil, nil, given_response: '')
+        cr = {}
+        h  = MockHandler.new(cr, rr)
+
+        assert_not_nil h
+        assert_kind_of GetHandlerMixin, h
+    end
+end
+
+class TestYieldsEntityConnector < TestGetHandlerMixin
+
+    def test_yields_correct_entity_connector
+
+        # Create Handler
+        rr = ReturnsGivenResponse.new(nil, nil, given_response: '')
+        cr = {}
+        h  = MockHandler.new(cr, rr)
+
+        # Handle request
+        result   = MockStruct.create.new
+        response = MockStruct.create(:result, :succeeded?).new(result, true)
+        request  = MockStruct.create.new(accept?: Proc.new { true })
+
+        h.handle 'env', 'params', request, 'response' do |ec|
+            assert_instance_of CapabilitiesConnector, ec
+            response
+        end
+    end
+end
+
+class TestHandlesResponse < TestGetHandlerMixin
+
+    def test_handles_unsuccessful_response
+
+        # Create Handler
+        rr = ReturnsGivenResponse.new(nil, nil, given_response: '')
+        cr = {}
+        h  = MockHandler.new(cr, rr)
+
+        # Handle request
+        result  = MockStruct.create(:message).new("hello world!")
+        reasons = MockStruct.create.new(
+            lookup?: Proc.new { |l| false },
+            join:    Proc.new { |*args| 'reason string' },
+            empty?:   Proc.new { true },
+        )
+        qlf      = MockStruct.create(:reasons).new(reasons)
+        response = MockStruct.create(
+            :result, :succeeded?, :failure_qualifier
+        ).new(
+            result, false, qlf
+        )
+        request = MockStruct.create.new(
+            accept?: Proc.new{|a| a == 'application/xml'}
+        )
+
+
+        halt_args = nil
+        h.procs[:halt] = Proc.new { |*args| halt_args = *args }
+
+        assert_raise(HaltException) do
+            h.handle('env', 'params', request, 'response') { |ec| response }
+        end
+
+        # Check result
+        assert_not_nil halt_args
+        assert_equal(500, halt_args.shift)
+        assert_equal({ 'Content-Type' => 'text/plain'} , halt_args.shift)
+        assert_equal('Server Error', halt_args.shift)
+    end
+
+    def test_handles_nil_response
+
+        # Create Handler
+        rr = ReturnsGivenResponse.new(nil, nil, given_response: '')
+        cr = {}
+        h  = MockHandler.new(cr, rr)
+
+        # Handle request
+        reasons        = MockStruct.create.new(
+            lookup?: Proc.new { nil },
+            empty?:  Proc.new { true }
+        )
+        qlf            = MockStruct.create(:reasons).new(reasons)
+        response       = MockStruct
+            .create(:result, :succeeded?, :failure_qualifier)
+            .new(nil, false, qlf)
+        halt_args      = nil
+        h.procs[:halt] = Proc.new { |*args| halt_args = *args }
+
+        assert_raise(HaltException) do
+            h.handle('env', 'params', 'request', 'response') { |ec| response }
+        end
+
+        # Check result
+        assert_not_nil halt_args
+        assert_equal(404, halt_args.shift)
+        assert_equal({ 'Content-Type' => 'text/plain'} , halt_args.shift)
+        assert_equal('Capabilities not found', halt_args.shift)
+    end
+
+    def test_handles_RZ0011_error
+
+        # Create Handler
+        rr = ReturnsGivenResponse.new(nil, nil, given_response: '')
+        cr = {}
+        h  = MockHandler.new(cr, rr)
+
+        # Handle request
+        resp    = MockStruct.create.new
+        reason  = MockStruct.create(:message, :details).new('message', 'details')
+        reasons = MockStruct.create.new(
+            lookup?: Proc.new { |l| 'RZ0011' == l ? reason : nil },
+            join: Proc.new { |*args| 'reason string' },
+        )
+        qlf      = MockStruct.create(:reasons).new(reasons)
+        response = MockStruct.create(
+            :result,
+            :succeeded?,
+            :failure_qualifier
+        ).new(resp, false, qlf)
+
+        halt_args = nil
+        h.procs[:halt] = Proc.new { |*args| halt_args = *args }
+
+        assert_raise(HaltException) do
+            h.handle('env', 'params', 'request', 'response') { |ec| response }
+        end
+        # Check result
+
+        assert_not_nil halt_args
+        assert_equal(404, halt_args.shift)
+        assert_equal({ 'Content-Type' => 'text/plain'} , halt_args.shift)
+        assert_equal('message: details', halt_args.shift)
+    end
+
+    def test_handles_successful_response
+
+        # Create Handler
+        rr = ReturnsGivenResponse.new(nil, nil, given_response: '')
+        cr = {}
+        h  = MockHandler.new(cr, rr)
+
+        # Handle request
+        result   = MockStruct.create(:message).new("hello world!")
+        response = MockStruct.create(:result, :succeeded?).new(result, true)
+        request  = MockStruct.create.new(
+            accept?: Proc.new{|a| a == 'application/xml'}
+        )
+        h.handle('env', 'params', request, 'response') { |ec| response }
+
+        # Check result
+        assert_equal 200, h.statuses.last
+    end
+
+    def test_handles_application_xml
+
+        # Create Handler
+        rr = ReturnsGivenResponse.new(nil, nil, given_response: '')
+        cr = {}
+        h  = MockHandler.new(cr, rr)
+
+        # Handle request
+        result   = MockStruct.create(:message).new("hello world!")
+        response = MockStruct.create(:result, :succeeded?).new(result, true)
+        request  = MockStruct.create.new(
+            accept?: Proc.new{|a| a == 'application/xml'}
+        )
+        body = h.handle('env', 'params', request, 'response') { |ec| response }
+
+        # Check result
+        assert_equal 200,                 h.statuses.last
+        assert_equal ['application/xml'], h.content_types
+        assert_equal result.to_s,         body
+    end
+
+    def test_handles_text_xml
+
+        # Create Handler
+        rr = ReturnsGivenResponse.new(nil, nil, given_response: '')
+        cr = {}
+        h  = MockHandler.new(cr, rr)
+
+        # Handle request
+        result   = MockStruct.create(:message).new("hello world!")
+        response = MockStruct.create(:result, :succeeded?).new(result, true)
+        request  = MockStruct.create.new(
+            accept?: Proc.new { |a| a == 'text/xml' },
+        )
+        body = h.handle('env', 'params', request, 'response') { |ec| response }
+
+        # Check result
+        assert_equal 200,          h.statuses.last
+        assert_equal ['text/xml'], h.content_types
+        assert_equal result.to_s,  body
+    end
+
+    def test_handles_invalid_accept
+
+        # Create Handler
+        rr = ReturnsGivenResponse.new(nil, nil, given_response: '')
+        cr = {}
+        h  = MockHandler.new(cr, rr)
+
+        # Handle request
+        result   = MockStruct.create(:message).new("hello world!")
+        response = MockStruct.create(:result, :succeeded?).new(result, true)
+        request  = MockStruct.create.new(accept?: Proc.new{ false })
+
+        halt_args = nil
+        h.procs[:halt] = Proc.new { |*args| halt_args = *args }
+
+        assert_raise(HaltException) do
+            h.handle('env', 'params', request, 'response') { |ec| response }
+        end
+
+        # Check result
+        assert_not_nil halt_args
+        assert_equal(500, halt_args.shift)
+        assert_equal({ 'Content-Type' => 'text/plain'} , halt_args.shift)
+        assert_equal('No supported Accept types', halt_args.shift)
+    end
+end
+
+# ############################## end of file ############################# #
+
+