ballast 1.9.3 → 2.0.0

data/lib/ballast/service.rb

@@ -0,0 +1,147 @@
+#
+# This file is part of the ballast gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+module Ballast
+  # A class which implements a common abstraction for services.
+  #
+  # @attribute [r] owner
+  #   @return [Object|NilClass] The owner of this service.
+  class Service
+    # A response to a service invocation.
+    #
+    # @attribute [r] success
+    #   @return [Boolean] Whether the invocation was successful or not.
+    # @attribute [r] data
+    #   @return [Object] The data returned by the operation.
+    # @attribute [r] errors
+    #   @return [Array] The errors returned by the operation.
+    class Response
+      attr_reader :success, :data, :errors
+
+      # Creates a new service response.
+      #
+      # @param success [Boolean] Whether the invocation was successful or not.
+      # @param data [Object|NilClass] The data returned by the operation.
+      # @param errors [Array|NilClass] The errors returned by the operation.
+      # @param error [Object|NilClass] Alias for errors. *Ignored if `errors` is present.*
+      def initialize(success = true, data: nil, errors: nil, error: nil)
+        errors ||= error.ensure_array
+
+        @success = success.to_boolean
+        @data = data
+        @errors = errors.ensure_array(no_duplicates: true, compact: true)
+      end
+
+      # Returns whether the invocation was successful or not.
+      #
+      # @return [Boolean] `true` if the service invocation was successful, `false` otherwise.
+      def success?
+        # TODO@PI: Ignore rubocop on this
+        @success
+      end
+      alias_method :successful?, :success?
+      alias_method :succeeded?, :success?
+
+      # Returns whether the invocation failed or not.
+      #
+      # @return [Boolean] `true` if the service invocation failed, `false` otherwise.
+      def fail?
+        !@success
+      end
+      alias_method :failed?, :fail?
+
+      # Returns the first error returned by the operation.
+      #
+      # @return [Object] The first error returned by the service.
+      def error
+        @errors.first
+      end
+
+      # Converts this response to a AJAX response.
+      #
+      # @return [AjaxResponse] The AJAX response, which will include only the first error.
+      def as_ajax_response
+        status, error_message =
+            if successful?
+              [:ok, nil]
+            elsif error.is_a?(Hash)
+              [error[:status], error[:error]]
+            else
+              [:unknown, error]
+            end
+
+        AjaxResponse.new(status: status, data: data, error: error_message)
+      end
+    end
+
+    attr_reader :owner
+
+    # Invokes one of the operations exposed by the service.
+    #
+    # @param operation [String] The operation to invoke.
+    # @param owner [Object|NilClass] The owner of the service.
+    # @param raise_errors [Boolean] Whether to raise errors instead of returning a failure.
+    # @param params [Hash] The parameters to pass to the service.
+    # @param kwargs [Hash] Other modifiers to pass to the service.
+    # @param block [Proc] A lambda to pass to the service.
+    # @return [Response] The response of the service.
+    def self.call(operation = :perform, owner: nil, raise_errors: false, params: {}, **kwargs, &block)
+      fail!(status: 501, error: "Unsupported operation #{self}.#{operation}.") unless respond_to?(operation)
+      Response.new(true, data: send(operation, owner: owner, params: params, **kwargs, &block))
+    rescue Errors::Failure => failure
+      handle_failure(failure, raise_errors)
+    end
+
+    # Marks the failure of the operation.
+    #
+    # @param details [Object] The error(s) occurred.
+    # @param on_validation [Boolean] Whether the error(s) was/were validation error(s).
+    def self.fail!(details, on_validation: false)
+      raise(on_validation ? Errors::ValidationFailure : Errors::Failure, details)
+    end
+
+    # Creates a service object.
+    #
+    # @param owner [Object|NilClass] The owner of the service.
+    def initialize(owner = nil)
+      @owner = owner
+    end
+
+    # Invokes one of the operations exposed by the service.
+    #
+    # @param operation [String] The operation to invoke.
+    # @param owner [Object|NilClass] The owner of the service.
+    # @param raise_errors [Boolean] Whether to raise errors instead of returning a failure.
+    # @param params [Hash] The parameters to pass to the service.
+    # @param kwargs [Hash] Other modifiers to pass to the service.
+    # @param block [Proc] A lambda to pass to the service.
+    # @return [Response] The response of the service.
+    def call(operation = :perform, owner: nil, raise_errors: false, params: {}, **kwargs, &block)
+      # PI: Ignore Roodi on this method
+      @owner = owner if owner
+      fail!(status: 501, error: "Unsupported operation #{self.class}##{operation}.") unless respond_to?(operation)
+      Response.new(true, data: send(operation, params: params, **kwargs, &block))
+    rescue Errors::Failure => failure
+      self.class.send(:handle_failure, failure, raise_errors)
+    end
+
+    # Marks the failure of the operation.
+    #
+    # @param details [Object] The error(s) occurred.
+    # @param on_validation [Boolean] Whether the error(s) was/were validation error(s).
+    def fail!(details, on_validation: false)
+      self.class.fail!(details, on_validation: on_validation)
+    end
+
+    # Handles a failure.
+    #
+    # @param failure [Failure] The failure to handle.
+    # @param raise_errors [Boolean] If `true` it will simply raise the error, otherwise it will return a failure as as Service::Response.
+    # @return [Response] A failure response.
+    def self.handle_failure(failure, raise_errors)
+      raise_errors ? raise(failure) : Response.new(false, error: failure.details)
+    end
+  end
+end

data/lib/ballast/version.rb

@@ -10,13 +10,13 @@ module Ballast
   # @see http://semver.org
   module Version
     # The major version.
-    MAJOR = 1
+    MAJOR = 2
 
     # The minor version.
-    MINOR = 9
+    MINOR = 0
 
     # The patch version.
-    PATCH = 3
+    PATCH = 0
 
     # The current version of ballast.
     STRING = [MAJOR, MINOR, PATCH].compact.join(".")

data/lib/ballast.rb

@@ -3,40 +3,41 @@
 # Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
 #
 
-require "lazier"
+# PI: Ignore flog on this file.
+
 require "brauser"
-require "interactor"
 require "addressable/uri"
-require "rack/utils"
-require "rack/fiber_pool"
 require "em-synchrony"
-require "oj"
+require "rack/utils"
+require "emoji"
+require "action_view/helpers/capture_helper"
+require "action_view/helpers/tag_helper"
 
-Lazier.load!
+Lazier.load!(:hash, :datetime)
 Oj.default_options = Oj.default_options.merge(mode: :compat, indent: 2, symbol_keys: true)
 
-require "ballast/version" if !defined?(Ballast::Version)
 require "ballast/errors"
-require "ballast/context"
-require "ballast/operation"
-require "ballast/operations_chain"
+require "ballast/emoji"
+require "ballast/ajax_response"
+require "ballast/service"
 require "ballast/request_domain_matcher"
 require "ballast/configuration"
-require "ballast/concerns/ajax"
+require "ballast/concerns/ajax_handling"
 require "ballast/concerns/common"
 require "ballast/concerns/view"
 require "ballast/concerns/errors_handling"
 require "ballast/middlewares/default_host"
 
+# A collection of base utilities for web frameworks.
 module Ballast
-  # If running under eventmachine, run the block in a thread of its threadpool using EM::Synchrony, otherwise run the block normally.
+  # If running under eventmachine, runs the block in a thread of its threadpool using EM::Synchrony, otherwise runs the block directly.
   #
   # @param start_reactor [Boolean] If start a EM::Synchrony reactor if none is running.
   # @param block [Proc] The block to run.
   def self.in_em_thread(start_reactor = false, &block)
-    if EM.reactor_running? then
+    if EM.reactor_running?
       run_in_thread(&block)
-    elsif start_reactor then
+    elsif start_reactor
       EM.synchrony do
         Ballast.in_em_thread(&block)
         EM.stop
@@ -47,12 +48,11 @@ module Ballast
   end
 
   private
-    # Runs a block inside a EM thread.
-    #
-    # @param block [Proc] The block to run.
-    def self.run_in_thread(&block)
-      EM::Synchrony.defer do
-        Fiber.new { block.call }.resume
-      end
+
+  # :nodoc:
+  def self.run_in_thread(&block)
+    EM::Synchrony.defer do
+      Fiber.new { block.call }.resume
     end
-end
+  end
+end

data/spec/ballast/ajax_response_spec.rb

@@ -0,0 +1,61 @@
+#
+# This file is part of the ballast gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+require "spec_helper"
+
+describe Ballast::AjaxResponse do
+  describe "#initialize" do
+    it "should save arguments" do
+      subject = Ballast::AjaxResponse.new(status: "STATUS", data: "DATA", error: "ERROR", transport: "TRANSPORT")
+
+      expect(subject.status).to eq("STATUS")
+      expect(subject.data).to eq("DATA")
+      expect(subject.error).to eq("ERROR")
+      expect(subject.transport).to eq("TRANSPORT")
+    end
+  end
+
+  describe "#numeric_status" do
+    it "should return the status as an integer" do
+      expect(Ballast::AjaxResponse.new.numeric_status).to eq(200)
+      expect(Ballast::AjaxResponse.new(status: :forbidden).numeric_status).to eq(403)
+      expect(Ballast::AjaxResponse.new(status: :whatever).numeric_status).to eq(500)
+    end
+  end
+
+  describe "#as_json" do
+    it "should serialize correctly" do
+      subject = Ballast::AjaxResponse.new(data: "DATA", error: "ERROR", transport: "TRANSPORT")
+      expect(subject.as_json).to eq({status: 200, data: "DATA", error: "ERROR"})
+      expect(subject.as_json(original_status: true)).to eq({status: :ok, data: "DATA", error: "ERROR"})
+    end
+  end
+
+  describe "#reply" do
+    before(:example) do
+      @transport = OpenStruct.new(request: OpenStruct.new(format: :json), params: {}, performed?: false)
+    end
+
+    subject { Ballast::AjaxResponse.new(status: 200, data: "DATA", error: "ERROR", transport: @transport) }
+
+    it "should setup the right content type for text" do
+      expect(@transport).to receive(:render).with(text: "{\"status\":200,\"data\":\"DATA\",\"error\":\"ERROR\"}", status: 200, callback: nil, content_type: "text/plain")
+      subject.reply(format: :text)
+    end
+
+    it "should set the right callback for JSONP" do
+      @transport.params[:callback] = "callback"
+      expect(@transport).to receive(:render).with(jsonp: "{\"status\":200,\"data\":\"DATA\",\"error\":\"ERROR\"}", status: 200, callback: "callback", content_type: nil)
+      subject.reply(format: :jsonp)
+    end
+
+    it "should fallback to transport request format" do
+      subject.status = 403
+
+      expect(@transport).to receive(:render).with(json: "{\"status\":403,\"data\":\"DATA\",\"error\":\"ERROR\"}", status: 403, callback: nil, content_type: nil)
+      subject.reply(format: nil)
+    end
+  end
+end

data/spec/ballast/concerns/ajax_handling_spec.rb

@@ -0,0 +1,86 @@
+#
+# This file is part of the ballast gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+require "spec_helper"
+
+describe Ballast::Concerns::AjaxHandling do
+  class AjaxMockClass < OpenStruct
+    include Ballast::Concerns::AjaxHandling
+  end
+
+  subject{ AjaxMockClass.new(response: OpenStruct.new(headers: {}), headers: {}, params: {}, performed?: false) }
+
+  describe "#ajax_request?" do
+    it "should return false by default" do
+      expect(AjaxMockClass.new(request: {}, params: {}).ajax_request?).to be_falsey
+    end
+
+    it "should return true when the request is XHR" do
+      expect(AjaxMockClass.new(request: OpenStruct.new(xhr?: true)).ajax_request?).to be_truthy
+    end
+
+    it "should return true when the parameter is overriden" do
+      expect(AjaxMockClass.new(params: {xhr: true}).ajax_request?).to be_truthy
+    end
+  end
+
+  describe "#prepare_ajax_response" do
+    it "should return a AJAX response" do
+      expect(subject.prepare_ajax_response).to be_a(Ballast::AjaxResponse)
+
+      expect(Ballast::AjaxResponse).to receive(:new).with({status: "STATUS", data: "DATA", error: "ERROR", transport: subject})
+      subject.prepare_ajax_response(status: "STATUS", data: "DATA", error: "ERROR")
+    end
+  end
+
+  describe "#prevent_caching" do
+    it "should append correct headers" do
+      subject.prevent_caching
+
+      expect(subject.response.headers).to eq({
+        "Cache-Control" => "no-cache, no-store, max-age=0, must-revalidate",
+        "Pragma" => "no-cache",
+        "Expires" => "Fri, 01 Jan 1990 00:00:00 GMT"
+      })
+    end
+  end
+
+  describe "#allow_cors" do
+    it "should append correct headers" do
+      subject.allow_cors
+
+      expect(subject.headers).to eq({
+        "Access-Control-Allow-Origin" => "*",
+        "Access-Control-Allow-Methods" => "POST, GET, OPTIONS",
+        "Access-Control-Allow-Headers" => "*",
+        "Access-Control-Max-Age" => "31557600"
+      })
+    end
+
+    it "should append custom headers values" do
+      subject.allow_cors(allow_origin: "ORIGIN", allow_methods: [:first, :second], allow_headers: "_", max_age: 1.day, allow_credentials: true)
+
+      expect(subject.headers).to eq({
+        "Access-Control-Allow-Origin" => "ORIGIN",
+        "Access-Control-Allow-Methods" => "FIRST, SECOND",
+        "Access-Control-Allow-Headers" => "_",
+        "Access-Control-Max-Age" => "86400",
+        "Access-Control-Allow-Credentials" => "true"
+      })
+    end
+  end
+
+  describe "#generate_robots_txt" do
+    it "should generate a robots.txt file which prevents everything by default" do
+      expect(subject).to receive(:render).with(text: "User-agent: *\nDisallow: /", content_type: "text/plain")
+      subject.disallow_robots
+    end
+
+    it "should generate a robots.txt file which prevents everything by default" do
+      expect(subject).to receive(:render).with(text: "User-agent: A\nDisallow: B\nDisallow: C\nDisallow: D\n\nUser-agent: E\nDisallow: F\nDisallow: \nDisallow: G", content_type: "text/plain")
+      subject.generate_robots_txt({"A"=> ["B", "C", "D"], "E" => ["F", "", "G"]})
+    end
+  end
+end

data/spec/ballast/concerns/common_spec.rb

@@ -10,86 +10,51 @@ describe Ballast::Concerns::Common do
     include Ballast::Concerns::Common
   end
 
-  class OperationMockClass
-
-  end
-
-  module Actions
-    module CommonMockClass
-      class Sub
-      end
-    end
-  end
-
   subject{ CommonMockClass.new(request: OpenStruct.new(headers: {}), headers: {}, params: {}, performed?: false) }
 
-  describe "#is_json?" do
+  describe "#json?" do
     it "should return false by default" do
-      expect(CommonMockClass.new(request: OpenStruct.new({format: ""}), params: {}).is_json?).to be(false)
+      expect(CommonMockClass.new(request: OpenStruct.new({format: ""}), params: {}).json?).to be_falsey
     end
 
     it "should return true when the request is JSON" do
-      expect(CommonMockClass.new(request: OpenStruct.new(format: "json")).is_json?).to be(true)
+      expect(CommonMockClass.new(request: OpenStruct.new(format: "json")).json?).to be_truthy
     end
 
     it "should return true when the parameter is overriden" do
-      expect(CommonMockClass.new(request: OpenStruct.new({format: ""}), params: {json: true}).is_json?).to be(true)
+      expect(CommonMockClass.new(request: OpenStruct.new({format: ""}), params: {json: true}).json?).to be_truthy
     end
   end
 
-  describe "#sending_data?" do
+  describe "#request_data?" do
     it "should return the current status" do
-      expect(CommonMockClass.new(request: OpenStruct.new(post?: false, put?: false)).sending_data?).to be(false)
-      expect(CommonMockClass.new(request: OpenStruct.new(post?: true, put?: false)).sending_data?).to be(true)
-      expect(CommonMockClass.new(request: OpenStruct.new(post?: false, put?: true)).sending_data?).to be(true)
-    end
-  end
-
-  describe "#perform_operation" do
-    it "should perform the requested operation and memoize it" do
-      expect(OperationMockClass).to receive(:perform).with("OWNER", a: 1, b: 2).and_return("OPERATION 1")
-      expect(OperationMockClass).to receive(:perform).with(subject, c: 3, d: 4).and_return("OPERATION 2")
-
-      subject.perform_operation(OperationMockClass, "OWNER", a: 1, b: 2)
-      expect(subject.instance_variable_get(:@operation)).to eq("OPERATION 1")
-      subject.perform_operation(OperationMockClass, c: 3, d: 4)
-      expect(subject.instance_variable_get(:@operation)).to eq("OPERATION 2")
-    end
-  end
-
-  describe "#perform_operations_chain" do
-    it "should perform the requested operation chain and memoize it" do
-      expect(Ballast::OperationsChain).to receive(:perform).with("OWNER", [:a, :b], a: 1, b: 2).and_return("OPERATION 1")
-      expect(Ballast::OperationsChain).to receive(:perform).with(subject, [:c, :d], c: 3, d: 4).and_return("OPERATION 2")
-
-      subject.perform_operations_chain([:a, :b], "OWNER", a: 1, b: 2)
-      expect(subject.instance_variable_get(:@operation)).to eq("OPERATION 1")
-      subject.perform_operations_chain([:c, :d], c: 3, d: 4)
-      expect(subject.instance_variable_get(:@operation)).to eq("OPERATION 2")
+      expect(CommonMockClass.new(request: OpenStruct.new(post?: false, put?: false)).request_data?).to be_falsey
+      expect(CommonMockClass.new(request: OpenStruct.new(post?: true, put?: false)).request_data?).to be_truthy
+      expect(CommonMockClass.new(request: OpenStruct.new(post?: false, put?: true)).request_data?).to be_truthy
     end
   end
 
   describe "#format_short_duration" do
     it "should format a date" do
       now = DateTime.civil(2013, 12, 9, 15, 6, 00)
-      expect(subject.format_short_duration(DateTime.civil(2013, 12, 9, 16, 6, 0), now, "ago")).to eq("now")
-      expect(subject.format_short_duration(DateTime.civil(2013, 12, 9, 15, 5, 58), now, "")).to eq("2s")
-      expect(subject.format_short_duration(DateTime.civil(2013, 12, 9, 15, 3, 0), now, " in the past")).to eq("3m in the past")
-      expect(subject.format_short_duration(DateTime.civil(2013, 12, 9, 8, 6, 0), now, "")).to eq("7h")
-      expect(subject.format_short_duration(DateTime.civil(2013, 5, 3, 15, 6, 0), now, "")).to eq("May 03")
-      expect(subject.format_short_duration(DateTime.civil(2011, 6, 4, 15, 6, 0), now, "")).to eq("Jun 04 2011")
+      expect(subject.format_short_duration(DateTime.civil(2013, 12, 9, 16, 6, 0), reference: now, suffix: "ago")).to eq("now")
+      expect(subject.format_short_duration(DateTime.civil(2013, 12, 9, 15, 5, 58), reference: now, suffix: "")).to eq("2s")
+      expect(subject.format_short_duration(DateTime.civil(2013, 12, 9, 15, 3, 0), reference: now, suffix: " in the past")).to eq("3m in the past")
+      expect(subject.format_short_duration(DateTime.civil(2013, 12, 9, 8, 6, 0), reference: now, suffix: "")).to eq("7h")
+      expect(subject.format_short_duration(DateTime.civil(2013, 5, 3, 15, 6, 0), reference: now, suffix: "")).to eq("May 03")
+      expect(subject.format_short_duration(DateTime.civil(2011, 6, 4, 15, 6, 0), reference: now, suffix: "")).to eq("Jun 04 2011")
     end
   end
 
   describe "#format_long_date" do
-    before(:each) do
+    before(:example) do
       expect_any_instance_of(DateTime).to receive(:dst?).and_return(true)
       expect(Time).to receive(:zone).at_least(1).and_return(ActiveSupport::TimeZone["UTC"], ActiveSupport::TimeZone["Pacific Time (US & Canada)"])
     end
 
     it "should format a date" do
       expect(subject.format_long_date(DateTime.civil(2013, 7, 11, 10, 9, 8))).to eq("10:09AM • Jul 11th, 2013 (UTC)")
-      expect(subject.format_long_date(DateTime.civil(2013, 7, 11, 10, 9, 8), "SEP", "%F %T %o %- %:Z")).to eq("2013-07-11 10:09:08 11th SEP Pacific Time (US & Canada) (DST)")
+      expect(subject.format_long_date(DateTime.civil(2013, 7, 11, 10, 9, 8), separator: "SEP", format: "%F %T %o %- %:Z")).to eq("2013-07-11 10:09:08 11th SEP Pacific Time (US & Canada) (DST)")
     end
   end
 
@@ -114,7 +79,7 @@ describe Ballast::Concerns::Common do
       expect(subject).to receive(:authenticate_with_http_basic).and_return(false)
       expect(subject).to receive(:handle_error).with({status: 401, title: "TITLE", message: "MESSAGE"})
 
-      subject.authenticate_user("AREA", "TITLE", "MESSAGE")
+      subject.authenticate_user(area: "AREA", title: "TITLE", message: "MESSAGE")
       expect(subject.headers["WWW-Authenticate"]).to eq("Basic realm=\"AREA\"")
     end
   end

data/spec/ballast/concerns/errors_handling_spec.rb

@@ -6,65 +6,71 @@
 require "spec_helper"
 
 describe Ballast::Concerns::ErrorsHandling do
-  class ErrorsHandlingMockClass < OpenStruct
-    include Ballast::Concerns::Ajax
+  class ErrorsHandlingMockClass
+    include Ballast::Concerns::AjaxHandling
     include Ballast::Concerns::ErrorsHandling
 
-    def initialize(attrs)
-      @operation = OpenStruct.new(attrs.delete(:operation))
-      super(attrs)
+    def request
+      OpenStruct.new(format: "json")
+    end
+
+    def performed?
+
+    end
+
+    def render(*args)
+
     end
   end
 
-  subject{ ErrorsHandlingMockClass.new(response: OpenStruct.new(headers: {}), headers: {}, params: {}, performed?: false) }
+  subject{ ErrorsHandlingMockClass.new }
 
   describe "#handle_error" do
     it "should handle a custom error" do
-      error = {status: "STATUS", error: "ERROR"}
+      error = {status: "STATUS", error: "ERROR", title: "TITLE"}
       expect(subject).to receive(:send_or_render_error).with("LAYOUT", nil)
-      subject.handle_error(error, "LAYOUT", "TITLE")
-
+      subject.handle_error(error, layout: "LAYOUT", title: "OTHER TITLE")
       expect(subject.instance_variable_get(:@error)).to eq(error)
-      expect(subject.instance_variable_get(:@error_code)).to eq("STATUS")
-      expect(subject.instance_variable_get(:@error_title)).to eq("TITLE")
-      expect(subject.instance_variable_get(:@error_message)).to eq("ERROR")
+
+      error = {status: "STATUS", error: "ERROR"}
+      expect(subject).to receive(:send_or_render_error).with("LAYOUT", nil)
+      subject.handle_error(error, layout: "LAYOUT", title: "OTHER TITLE")
+      expect(subject.instance_variable_get(:@error)).to eq(error.merge({title: "OTHER TITLE"}))
     end
 
     it "should handle a debug error" do
+      error = Lazier::Exceptions::Debug.new("MESSAGE")
       expect(subject).to receive(:send_or_render_error)
-      subject.handle_error(Lazier::Exceptions::Debug.new("MESSAGE"))
 
-      expect(subject.instance_variable_get(:@error_code)).to eq(503)
-      expect(subject.instance_variable_get(:@error_title)).to eq("Debug")
-      expect(subject.instance_variable_get(:@error_message)).to be_nil
+      subject.handle_error(error)
+      expect(subject.instance_variable_get(:@error)).to eq({status: 503, title: "Debug", error: "MESSAGE", exception: error})
     end
 
     it "should handle every other error" do
+      error = RuntimeError.new("ERROR")
       expect(subject).to receive(:send_or_render_error)
-      subject.handle_error(RuntimeError.new("ERROR"))
 
-      expect(subject.instance_variable_get(:@error_code)).to eq(500)
-      expect(subject.instance_variable_get(:@error_title)).to eq("Error - RuntimeError")
-      expect(subject.instance_variable_get(:@error_message)).to be_nil
+      subject.handle_error(error)
+      expect(subject.instance_variable_get(:@error)).to eq({status: 500, title: "Error - RuntimeError", error: "ERROR", exception: error})
     end
 
     it "should render an AJAX error" do
       expect_any_instance_of(RuntimeError).to receive(:backtrace).and_return(["A", "B"])
-      allow(subject).to receive(:request).and_return(OpenStruct.new(format: :json))
-      expect(subject).to receive(:is_ajax?).exactly(2).and_return(true, false)
-      
-      expect(subject).to receive(:send_ajax).with({status: 500, error: "ERROR", data: {type: "Error - RuntimeError", backtrace: ["A", "B"]}}.with_indifferent_access, {format: :json})
-      expect(subject).to receive(:send_ajax).with({status: :forbidden, error: "ERROR", data: {type: "TITLE"}}.with_indifferent_access, {format: :json})
+      expect(subject).to receive(:ajax_request?).exactly(2).and_return(true, false)
+
+      expect(Ballast::AjaxResponse).to receive(:new).with({status: 500, error: "ERROR", data: {description: "Error - RuntimeError", backtrace: ["A", "B"]}, transport: subject}).and_call_original
+      expect(Ballast::AjaxResponse).to receive(:new).with({status: :forbidden, error: "ERROR", data: {description: "TITLE", backtrace: nil}, transport: subject}).and_call_original
 
-      subject.handle_error(RuntimeError.new("ERROR"), "LAYOUT")
+      subject.handle_error(RuntimeError.new("ERROR"))
       subject.instance_variable_set(:@error, nil)
-      subject.handle_error({title: "TITLE", status: :forbidden, error: "ERROR"}, :json)
+      subject.handle_error({title: "TITLE", status: :forbidden, error: "ERROR"}, format: :json)
     end
 
     it "should render a HTML error" do
-      allow(subject).to receive(:request).and_return(OpenStruct.new(format: :html))
+      expect(subject).to receive(:ajax_request?).and_return(false)
+      expect(subject).to receive(:request).and_return(OpenStruct.new(format: "HTML"))
       expect(subject).to receive(:render).with(html: "", status: 500, layout: "LAYOUT", formats: [:html])
-      subject.handle_error(RuntimeError.new("ERROR"), "LAYOUT")
+      subject.handle_error(RuntimeError.new("ERROR"), layout: "LAYOUT")
     end
   end
 end