ballast 1.0.0

data/spec/ballast/concerns/ajax_spec.rb

@@ -0,0 +1,124 @@
+#
+# 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::Ajax do
+  class AjaxMockClass < OpenStruct
+    include Ballast::Concerns::Ajax
+
+    def initialize(attrs)
+      @operation = OpenStruct.new(attrs.delete(:operation))
+      super(attrs)
+    end
+  end
+
+  subject{ AjaxMockClass.new(response: OpenStruct.new(headers: {}), headers: {}, params: {}, performed?: false) }
+
+  describe "#is_ajax?" do
+    it "should return false by default" do
+      expect(AjaxMockClass.new(request: {}, params: {}).is_ajax?).to be(false)
+    end
+
+    it "should return true when the request is XHR" do
+      expect(AjaxMockClass.new(request: OpenStruct.new(xhr?: true)).is_ajax?).to be(true)
+    end
+
+    it "should return true when the parameter is overriden" do
+      expect(AjaxMockClass.new(params: {xhr: true}).is_ajax?).to be(true)
+    end
+  end
+
+  describe "#prepare_ajax" do
+    it "should return a default hash" do
+      expect(subject.prepare_ajax).to be_a(HashWithIndifferentAccess)
+      expect(subject.prepare_ajax).to eq({status: :ok}.with_indifferent_access)
+    end
+
+    it "should accept overrides for the status" do
+      expect(subject.prepare_ajax(:forbidden)).to eq({status: :forbidden}.with_indifferent_access)
+    end
+
+    it "should accept overrides for the data" do
+      expect(subject.prepare_ajax(:ok, "DATA")).to eq({status: :ok, data: "DATA"}.with_indifferent_access)
+    end
+
+    it "should accept overrides for the error" do
+      expect(subject.prepare_ajax(:ok, nil, "ERROR")).to eq({status: :ok, error: "ERROR"}.with_indifferent_access)
+    end
+  end
+
+  describe "#send_ajax" do
+    before(:each) do
+      allow(subject).to receive(:render) {|args| args}
+    end
+
+    it "should prepare the data if the data is not already an Hash" do
+      expect(subject).to receive(:prepare_ajax).with(:ok, "DATA").and_call_original
+      expect(subject).to receive(:render).with(json: "{\"status\":200,\"data\":\"DATA\"}", status: 200, callback: nil, content_type: nil)
+      subject.send_ajax("DATA")
+    end
+
+    it "translate HTTP status" do
+      expect(Rack::Utils).to receive(:status_code).with(:forbidden).and_call_original
+      expect(subject.send_ajax("DATA", status: :forbidden)[:status]).to eq(403)
+    end
+
+    it "should setup the right content type for text" do
+      expect(subject).to receive(:render).with(text: "{\"status\":200,\"data\":\"DATA\"}", status: 200, callback: nil, content_type: "text/plain")
+      subject.send_ajax("DATA", format: :text)
+    end
+
+    it "should set the right callback for JSONP" do
+      subject.params[:callback] = "callback"
+      expect(subject).to receive(:render).with(jsonp: "{\"status\":200,\"data\":\"DATA\"}", status: 200, callback: "callback", content_type: nil)
+      subject.send_ajax("DATA", format: :jsonp)
+    end
+  end
+
+  describe "#update_ajax" do
+    it "should merge the data from successful operations" do
+      subject = AjaxMockClass.new(operation: {success?: true, response: {data: "DATA"}})
+      expect(subject.update_ajax({existing: true})).to eq({existing: true, data: "DATA"})
+    end
+
+    it "should merge the data from failed operations" do
+      subject = AjaxMockClass.new(operation: {success?: false, errors: ["ERROR"]})
+      expect(subject.update_ajax({existing: true})).to eq({existing: true, 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
+  end
+
+  describe "#disallow_robots" do
+    it "should disallow robots outputting a text view" do
+      expect(subject).to receive(:render).with(text: "User-agent: *\nDisallow: /", content_type: "text/plain")
+      subject.disallow_robots
+    end
+  end
+end

data/spec/ballast/concerns/common_spec.rb

@@ -0,0 +1,100 @@
+#
+# 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::Common do
+  class CommonMockClass < OpenStruct
+    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 "#sending_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 "#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")
+    end
+  end
+
+  describe "#format_long_date" do
+    before(:each) 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)")
+    end
+  end
+
+  describe "#authenticate_user" do
+    it "should ask for authentication and yield the authenticator block" do
+      output = nil
+      expect(subject).to receive(:authenticate_with_http_basic) {|&block| block.call("USER", "PASSWORD") }
+
+      subject.authenticate_user { |*args| output = args }
+      expect(output).to eq(["USER", "PASSWORD"])
+    end
+
+    it "in case of failure, it should set error" do
+      expect(subject).to receive(:authenticate_with_http_basic).and_return(false)
+      expect(subject).to receive(:handle_error)
+      subject.authenticate_user
+
+      expect(subject.headers["WWW-Authenticate"]).to eq("Basic realm=\"Private Area\"")
+      expect(subject.instance_variable_get(:@error_title)).to eq("Authentication required.")
+      expect(subject.instance_variable_get(:@error_message)).to eq("To view this resource you have to authenticate.")
+      expect(subject.instance_variable_get(:@error_code)).to eq(401)
+    end
+
+    it "in case of failure, it should show custom messages" do
+      expect(subject).to receive(:authenticate_with_http_basic).and_return(false)
+      expect(subject).to receive(:handle_error)
+      subject.authenticate_user("AREA", "TITLE", "MESSAGE")
+
+      expect(subject.headers["WWW-Authenticate"]).to eq("Basic realm=\"AREA\"")
+      expect(subject.instance_variable_get(:@error_title)).to eq("TITLE")
+      expect(subject.instance_variable_get(:@error_message)).to eq("MESSAGE")
+    end
+  end
+end

data/spec/ballast/concerns/errors_handling_spec.rb

@@ -0,0 +1,63 @@
+#
+# 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::ErrorsHandling do
+  class ErrorsHandlingMockClass < OpenStruct
+    include Ballast::Concerns::Ajax
+    include Ballast::Concerns::ErrorsHandling
+
+    def initialize(attrs)
+      @operation = OpenStruct.new(attrs.delete(:operation))
+      super(attrs)
+    end
+  end
+
+  subject{ ErrorsHandlingMockClass.new(response: OpenStruct.new(headers: {}), headers: {}, params: {}, performed?: false) }
+
+  describe "#handle_error" do
+    it "should handle a custom error" do
+      error = {status: "STATUS", error: "ERROR"}
+      expect(subject).to receive(:send_or_render_error).with("LAYOUT")
+      subject.handle_error(error, "LAYOUT", "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")
+    end
+
+    it "should handle a debug error" do
+      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
+    end
+
+    it "should handle every other error" do
+      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
+    end
+
+    it "should render an AJAX error" do
+      expect_any_instance_of(RuntimeError).to receive(:backtrace).and_return(["A", "B"])
+      expect(subject).to receive(:is_ajax?).and_return(true)
+      expect(subject).to receive(:send_ajax).with({status: 500, error: "ERROR", data: {type: "Error - RuntimeError", backtrace: "A\nB"}}.with_indifferent_access)
+      subject.handle_error(RuntimeError.new("ERROR"), "LAYOUT")
+    end
+
+    it "should render a HTML error" do
+      expect(subject).to receive(:render).with(nothing: true, status: 500, layout: "LAYOUT", formats: [:html])
+      subject.handle_error(RuntimeError.new("ERROR"), "LAYOUT")
+    end
+  end
+end

data/spec/ballast/concerns/view_spec.rb

@@ -0,0 +1,107 @@
+#
+# 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::View do
+  class ViewMockClass < OpenStruct
+    include Ballast::Concerns::View
+
+    def initialize(attrs)
+      @operation = OpenStruct.new(attrs.delete(:operation))
+      super(attrs)
+    end
+  end
+
+  subject{ ViewMockClass.new(response: OpenStruct.new(headers: {}), headers: {}, params: {}, performed?: false) }
+
+  describe "#scope_css" do
+    it "should return the CSS namespace" do
+      expect(subject).to receive(:controller_path).and_return("NAME/CONTROLLER")
+      expect(subject).to receive(:action_name).and_return("ACTION")
+      expect(subject.scope_css).to eq("NAME-CONTROLLER ACTION")
+    end
+  end
+
+  describe "#browser" do
+    it "should return a browser object" do
+      expect(subject).to receive(:request).and_return(OpenStruct.new(user_agent: "AGENT"))
+      expect(Brauser::Browser).to receive(:new).with("AGENT").and_return("BROWSER")
+      expect(subject.browser).to eq("BROWSER")
+    end
+  end
+
+  describe "#browser_supported?" do
+    before(:each) do
+      expect(subject).to receive(:request).and_return(OpenStruct.new(user_agent: "AGENT"))
+    end
+
+    it "should check if a browser is supported" do
+      expect(subject.browser).to receive(:supported?).with("CONF").and_return("SUPPORTED")
+      expect(subject.browser_supported?("CONF")).to eq("SUPPORTED")
+    end
+
+    it "should use a default file" do
+      class Rails
+        def self.root
+          Pathname.new("ROOT")
+        end
+      end
+
+      expect(subject.browser).to receive(:supported?).with("ROOT/config/supported-browsers.yml").and_return(true)
+      subject.browser_supported?
+    end
+  end
+
+  describe "#javascript_params" do
+    before(:each) do
+      subject.instance_variable_set(:@javascript_params, {a: "1", b: 2})
+    end
+
+    it "should output Javascript as HTML" do
+      expect(subject).to receive(:content_tag).with(:tag, '{"a":"1","b":2}', {"data-jid" => "ID"}).and_return("HTML")
+      expect(subject.javascript_params(true, :tag, "ID")).to eq("HTML")
+    end
+
+    it "should return Javascript as Hash" do
+      expect(subject.javascript_params(false)).to eq({a: "1", b: 2})
+    end
+  end
+
+  describe "#add_javascript_params" do
+    before(:each) do
+      subject.add_javascript_params(:a, {b: 1})
+    end
+
+    it "should create an Hash" do
+      expect(subject.instance_variable_get(:@javascript_params)).to be_a(HashWithIndifferentAccess)
+    end
+
+    it "should add new keys" do
+      subject.add_javascript_params(:c, {d: 2})
+      expect(subject.instance_variable_get(:@javascript_params)).to eq({a: {b: 1}, c: {d: 2}}.with_indifferent_access)
+    end
+
+    it "should merge values for the same key" do
+      subject.add_javascript_params(:a, {d: 2})
+      expect(subject.instance_variable_get(:@javascript_params)).to eq({a: {b: 1, d: 2}}.with_indifferent_access)
+    end
+
+    it "should replace values for same key if requested to" do
+      subject.add_javascript_params(:a, {d: 2}, true)
+      expect(subject.instance_variable_get(:@javascript_params)).to eq({a: {d: 2}}.with_indifferent_access)
+    end
+
+    it "should merge from the root" do
+      subject.add_javascript_params(nil, {d: 2})
+      expect(subject.instance_variable_get(:@javascript_params)).to eq({a: {b: 1}, d: 2}.with_indifferent_access)
+    end
+
+    it "should replace the entire hash" do
+      subject.add_javascript_params(nil, {d: 2}, true)
+      expect(subject.instance_variable_get(:@javascript_params)).to eq({d: 2}.with_indifferent_access)
+    end
+  end
+end

data/spec/ballast/context_spec.rb

@@ -0,0 +1,23 @@
+#
+# 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::Context do
+  describe ".build" do
+    it "should prepare data" do
+      expect(Interactor::Context).to receive(:build).with({owner: "OWNER", errors: [], output: nil, response: an_instance_of(HashWithIndifferentAccess), a: 1, b: 2}.with_indifferent_access)
+      Ballast::Context.build("OWNER", {a: 1, b: 2})
+    end
+  end
+
+  describe "#method_missing" do
+    it "should lookup for keys in the object" do
+      context = Ballast::Context.build(nil, {output: 1})
+      expect(context.output).to eq(1)
+      expect { context.input }.to raise_error(NoMethodError)
+    end
+  end
+end

data/spec/ballast/errors_spec.rb

@@ -0,0 +1,16 @@
+#
+# 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::Errors::BaseError do
+  describe ".initialize" do
+    it "should propagate the message also as a response" do
+      reference = Ballast::Errors::BaseError.new("ERROR")
+      expect(reference.message).to eq("ERROR")
+      expect(reference.response).to eq("ERROR")
+    end
+  end
+end

data/spec/ballast/operation_spec.rb

@@ -0,0 +1,175 @@
+#
+# 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::Operation do
+  describe ".perform" do
+    it "should call the superclass implementation with no changes if the first arg is of the right class" do
+      context = Ballast::Context.new
+
+      expect(Ballast::Context).not_to receive(:build)
+
+      Ballast::Operation.perform(context)
+      Ballast::Operation.perform(nil, context: context)
+    end
+
+    it "should create a context on the fly if the first arg is NOT of the right class" do
+      expect(Ballast::Context).to receive(:build).with("OWNER", {}).and_return("ONTHEFLY")
+      Ballast::Operation.perform("OWNER")
+    end
+  end
+
+  describe "#initialize" do
+    it "should save the context and then call #setup" do
+      expect_any_instance_of(Ballast::Operation).to receive(:setup)
+      subject = Ballast::Operation.new("CONTEXT")
+
+      expect(subject.context).to eq("CONTEXT")
+    end
+  end
+
+  describe "#in_em_thread" do
+    it "should yield the block in EM::Synchrony thread" do
+      counter = 0
+      allow(EM).to receive(:reactor_running?).and_return(true)
+      expect(EM::Synchrony).to receive(:defer){|&block| block.call }
+
+      Ballast::Operation.new({}).in_em_thread { counter = 1 }
+      expect(counter).to eq(1)
+    end
+  end
+
+  describe "#setup_response" do
+    it "should save instance variables into the context response" do
+      subject = Ballast::Operation.new(Ballast::Context.build(nil, response: {a: 1, b: 2, c: 3, d: 4}))
+      subject.instance_variable_set(:@first, "A")
+      subject.instance_variable_set(:@second, "B")
+      subject.instance_variable_set(:@third, "C")
+
+      subject.setup_response
+      expect(subject.response).to eq({a: 1, b: 2, c: 3, d: 4, first: "A", second: "B", third: "C"}.with_indifferent_access)
+    end
+
+    it "should not do anything if interactor failed" do
+      subject = Ballast::Operation.new(Ballast::Context.build(nil, response: {a: 1, b: 2, c: 3, d: 4}))
+      expect(subject).to receive(:success?).and_return(false)
+
+      subject.instance_variable_set(:@first, "A")
+      subject.instance_variable_set(:@second, "B")
+      subject.instance_variable_set(:@third, "C")
+
+      subject.setup_response
+      expect(subject.response).to eq({a: 1, b: 2, c: 3, d: 4}.with_indifferent_access)
+    end
+  end
+
+  describe "#import_response" do
+    before(:each) do
+      @subject = Ballast::Operation.new(Ballast::Context.build(nil, response: {a: 1, b: 2, c: 3, d: 4}))
+      @target = Object.new
+      @target.instance_variable_set(:@c, 1)
+      @target.instance_variable_set(:@d, 2)
+    end
+
+    it "should load instance variables from the context response" do
+      @subject.import_response(@target, :a, :b)
+      expect(@target.instance_variable_get(:@a)).to eq(1)
+      expect(@target.instance_variable_get(:@b)).to eq(2)
+    end
+
+    it "should overwrite a variable by default" do
+      expect { @subject.import_response(@target, :c) }.not_to raise_error
+      expect(@target.instance_variable_get(:@c)).to eq(3)
+    end
+
+    it "should raise an error if a variable is already defined and overwrite is disabled" do
+      expect { @subject.import_response(@target, :c, overwrite: false) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#perform_with_handling" do
+    before(:each) do
+      @subject = Ballast::Operation.new({})
+    end
+
+    it "should yield the block" do
+      expect(@subject).to receive(:setup_response)
+
+      counter = 0
+      @subject.perform_with_handling { counter = 1 }
+      expect(counter).to eq(1)
+    end
+
+    it "should propagate debug dumps" do
+      expect { @subject.perform_with_handling { "DEBUG".for_debug } }.to raise_error(Lazier::Exceptions::Debug)
+    end
+
+    it "should handle BaseError" do
+      expect(@subject).to receive(:setup_response)
+      expect(@subject).to receive(:fail!).with("RESPONSE")
+      expect { @subject.perform_with_handling { raise Ballast::Errors::BaseError.new("RESPONSE") } }.not_to raise_error
+    end
+
+    it "should propagate the error otherwise" do
+      expect { @subject.perform_with_handling { raise RuntimeError.new("ERROR") } }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe "#fail!" do
+    it "should append the error and mark the failure" do
+      subject = Ballast::Operation.new(Ballast::Context.build(nil))
+      subject.fail!("NO")
+
+      expect(subject.failure?).to be(true)
+      expect(subject.errors).to eq(["NO"])
+    end
+  end
+
+  describe "#import_error" do
+    before(:each) do
+      @subject = Ballast::Operation.new(Ballast::Context.build(nil, errors: [{status: 401, error: "Unauthorized"}, {status: 403, error: "Forbidden"}]))
+    end
+
+    it "should set the flash of the target" do
+      target = OpenStruct.new(flash: {})
+      @subject.import_error(target)
+      expect(target.flash[:error]).to eq("Unauthorized")
+    end
+
+    it "should set instance variable if request to" do
+      target = OpenStruct.new(flash: {})
+      @subject.import_error(target, false)
+      expect(target.instance_variable_get(:@error)).to eq({status: 401, error: "Unauthorized"}.with_indifferent_access)
+    end
+
+    it "should import all errors if requested to" do
+      target = OpenStruct.new(flash: {})
+      @subject.import_error(target, true, false)
+      @subject.import_error(target, false, false)
+      expect(target.flash[:error]).to eq(["Unauthorized", "Forbidden"])
+      expect(target.instance_variable_get(:@error)).to eq([{status: 401, error: "Unauthorized"}.with_indifferent_access, {status: 403, error: "Forbidden"}.with_indifferent_access])
+    end
+  end
+
+  describe "#resolve_error" do
+    it "should format AJAX error" do
+      subject = Ballast::Operation.new({})
+      expect(subject.resolve_error(nil)).to eq({status: 500, error: "Oops! We're having some issue. Please try again later."})
+      expect(subject.resolve_error("A")).to eq({status: 500, error: "Oops! We're having some issue. Please try again later."})
+      expect(subject.resolve_error("A", {500 => "ERROR"})).to eq({status: 500, error: "ERROR"})
+      expect(subject.resolve_error(OpenStruct.new(response: 403))).to eq({status: 403, error: "Oops! We're having some issue. Please try again later."})
+      expect(subject.resolve_error(OpenStruct.new(response: 403), {403 => "ERROR"})).to eq({status: 403, error: "ERROR"})
+    end
+  end
+
+  describe "method_missing" do
+    it "should forward call to the owner" do
+      subject = Ballast::Operation.new(OpenStruct.new(owner: " ABC "))
+      expect(subject.strip).to eq("ABC")
+      expect { subject.not_strip }.to raise_error(NoMethodError)
+    end
+  end
+end

data/spec/ballast/operations_chain_spec.rb

@@ -0,0 +1,33 @@
+#
+# 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::OperationsChain do
+  describe ".perform" do
+    before(:each) do
+      expect_any_instance_of(Ballast::OperationsChain).to receive(:perform)
+    end
+
+    it "should initialize with the set of operations and the first argument as context" do
+      context = Ballast::Context.new
+      expect(Ballast::Context).not_to receive(:build)
+      expect(Ballast::OperationsChain).to receive(:new).with([:A, :B, :C], context).and_call_original
+      Ballast::OperationsChain.perform(context, [:A, :B, :C])
+    end
+
+    it "shuold use the provided owner and context" do
+      context = Ballast::Context.new
+      expect(Ballast::Context).not_to receive(:build)
+      expect(Ballast::OperationsChain).to receive(:new).with([:A, :B, :C], context).and_call_original
+      Ballast::OperationsChain.perform(nil, [:A, :B, :C], context: context)
+    end
+
+    it "should created the context on the fly if needed" do
+      expect(Ballast::Context).to receive(:build).with("A", {a: 1})
+      Ballast::OperationsChain.perform("A", [:A, :B, :C], params: {a: 1})
+    end
+  end
+end

data/spec/coverage_helper.rb

@@ -0,0 +1,19 @@
+#
+# 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 "pathname"
+require "simplecov"  
+require "coveralls"
+
+Coveralls.wear! if ENV["CI"] || ENV["JENKINS_URL"] # Do not load outside Travis
+
+SimpleCov.start do
+  root = Pathname.new(File.dirname(__FILE__)) + ".."
+
+  add_filter do |src_file|
+    path = Pathname.new(src_file.filename).relative_path_from(root).to_s
+    path !~ /^lib/
+  end
+end