service_objects 0.0.1

data/spec/tests/helpers/dependable_spec.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+describe ServiceObjects::Helpers::Dependable do
+
+  let(:test_class) { Class.new      }
+  subject          { test_class.new }
+
+  before  { test_class.extend described_class }
+
+  describe ".depends_on" do
+
+    shared_examples "dependency declarator" do
+
+      it "[defines dependency getter]" do
+        expect(subject).to respond_to dependency_name
+      end
+
+      it "[defines dependency sette]r" do
+        expect(subject).to respond_to("#{ dependency_name }=").with(1).argument
+      end
+
+      it "[sets default dependency]" do
+        expect(subject.send dependency_name).to eq default_value
+      end
+
+      it "[resets dependency to default implementation]" do
+        expect { subject.send "#{ dependency_name }=", nil }
+          .not_to change { subject.send dependency_name }
+      end
+
+    end # examples definition
+
+    context "without arguments" do
+
+      it "fails" do
+        expect { test_class.depends_on }.to raise_error
+      end
+
+    end # context
+
+    context "with one argument" do
+
+      let(:default_value)   { ServiceObjects::NULL }
+      let(:dependency_name) { :get_item  }
+
+      before { test_class.depends_on :get_item }
+
+      it_behaves_like "dependency declarator"
+
+    end # context
+
+    context "with two arguments" do
+
+      let(:default_value)   { Class.new  }
+      let(:dependency_name) { :get_item  }
+
+      before { test_class.depends_on :get_item, default: default_value }
+
+      it_behaves_like "dependency declarator"
+
+    end # context
+
+    context "repeatedly" do
+
+      let(:default_value)   { Class.new  }
+      let(:dependency_name) { :get_item  }
+
+      before { test_class.depends_on :get_item }
+      before { test_class.depends_on :get_item, default: default_value }
+
+      it_behaves_like "dependency declarator"
+
+    end # context
+
+  end # describe .depends_on
+
+end # describe ServiceObject::Helpers::Dependable

data/spec/tests/helpers/exceptions_spec.rb

@@ -0,0 +1,112 @@
+# encoding: utf-8
+
+describe ServiceObjects::Helpers::Exceptions do
+
+  let(:service_invalid) { ServiceObjects::Invalid           }
+  let(:messages_class)  { ServiceObjects::Message           }
+  let(:messages_module) { ServiceObjects::Helpers::Messages }
+  let(:test_class)      { Class.new                         }
+
+  before { test_class.include described_class }
+
+  it "includes ServiceObjects::Helpers::Messages" do
+    expect(test_class).to include messages_module
+  end
+
+  describe "#escape" do
+
+    subject { test_class.new }
+
+    def escape_from_foo(with_exception: nil)
+      subject.escape do
+        fail with_exception if with_exception
+        "foo"
+      end
+    end
+
+    context "when the block raises nothing" do
+
+      let(:result) { escape_from_foo }
+
+      it "yields the block" do
+        expect(result).to eq "foo"
+      end
+
+    end
+
+    context "when ServiceObjects::Invalid raised by the object" do
+
+      let(:exception) { service_invalid.new subject }
+
+      it "re-raises Invalid error" do
+        expect { escape_from_foo with_exception: exception }
+          .to raise_error service_invalid
+      end
+
+      it "doesn't mutate the object" do
+        expect { escape_from_foo with_exception: exception rescue nil }
+          .not_to change { subject }
+      end
+
+    end
+
+    context "when ServiceObjects::Invalid raised by another object" do
+
+      let(:another_object) { test_class.new }
+      let(:exception)      { service_invalid.new another_object }
+
+      before { another_object.add_message type: "error", text: "bar" }
+
+      it "raises Invalid error" do
+        expect { escape_from_foo with_exception: exception }
+          .to raise_error service_invalid
+      end
+
+      it "raises the exception of its own" do
+        begin
+          escape_from_foo with_exception: exception
+        rescue => err
+          expect(err.object).to eq subject
+        end
+      end
+
+      it "populates messages from the exception to self" do
+        escape_from_foo with_exception: exception rescue nil
+
+        expect(subject.messages).to eq another_object.messages
+      end
+
+    end
+
+    context "when the block raises StandardError" do
+
+      let(:exception)        { StandardError.new("text") }
+      let(:expected_message) { messages_class.new type: "error", text: "text" }
+
+      it "raises a SerivceObjects::Invalid" do
+        expect { escape_from_foo with_exception: exception }
+          .to raise_error service_invalid
+      end
+
+      it "adds an error to the messages" do
+        escape_from_foo with_exception: exception rescue nil
+
+        expect(subject.messages).to contain_exactly expected_message
+      end
+
+    end
+
+    context "when the block raises another exception" do
+
+      let(:exception) { SyntaxError.new }
+
+      it "re-raises the exception unchanged" do
+        expect { escape_from_foo with_exception: exception }
+          .to raise_error exception
+      end
+
+    end
+
+  end # describe .escape
+
+end # describe ServiceObjects::Exceptions

data/spec/tests/helpers/messages_spec.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+describe ServiceObjects::Helpers::Messages do
+
+  let(:messages_class) { ServiceObjects::Message }
+  let(:test_class)     { Class.new               }
+
+  before { ServiceObjects::Test = test_class        }
+  before { test_class.include described_class       }
+  after  { ServiceObjects.send :remove_const, :Test }
+
+  subject { test_class.new }
+
+  describe "#translate" do
+
+    let(:scope)      { %w(activemodel messages models service_objects/test) }
+    let(:traslation) { I18n.t(:text, scope: scope, name: "name")            }
+
+    it "translates symbols in the service's scope" do
+      expect(subject.translate(:text, name: "name")).to eq traslation
+    end
+
+    it "doesn't translate strings" do
+      expect(subject.translate("text")).to eq "text"
+    end
+
+    it "converts non-symbolic argument to string" do
+      expect(subject.translate nil).to eq ""
+      expect(subject.translate 1).to eq "1"
+    end
+
+  end # #translate
+
+  describe "#messages" do
+
+    it "returns an array" do
+      expect(subject.messages).to be_kind_of Array
+    end
+
+  end # #messages
+
+  describe "#add_message" do
+
+    let(:message) { subject.messages.first }
+
+    it "adds a new message to the #messages" do
+      subject.add_message text: "foo", type: "bar", priority: 5, baz: 0
+
+      expect(message).to be_kind_of messages_class
+      expect(message.type).to eq "bar"
+      expect(message.text).to eq "foo"
+      expect(message.priority).to eq 5.0
+    end
+
+    it "translates a symbol" do
+      subject.add_message text: :foo, type: :bar, priority: 5, baz: 0
+
+      translation = subject.translate :foo, baz: 0
+      expect(message.text).to eq translation
+    end
+
+  end # #add_message
+
+end # ServiceObjects::Helpers::Messages

data/spec/tests/helpers/parameterized_spec.rb

@@ -0,0 +1,136 @@
+# encoding: utf-8
+
+describe ServiceObjects::Helpers::Parameterized do
+
+  let(:parameters) { ServiceObjects::Helpers::Parameters }
+  let(:test_class) { Class.new }
+  before  { test_class.extend described_class }
+  subject { test_class.new }
+
+  it "includes ServiceObjects::Helpers::Parameters" do
+    expect(test_class).to include parameters
+  end
+
+  describe ".allows_params" do
+
+    # ==========================================================================
+    # Defines behaviours
+    # ==========================================================================
+
+    shared_examples "white list" do
+
+      # 'allowed_params' taken from context
+
+      let(:whitelist) { Array(allowed_params).flatten.map(&:to_sym) }
+
+      it "[sets whitelist]" do
+        subject
+        expect(test_class.whitelist).to match_array whitelist
+      end
+
+      it "[returns whitelist]" do
+        expect(subject).to eq test_class.whitelist
+      end
+
+    end # behaviour
+
+    shared_examples "attributes creator" do
+
+      # 'allowed_params' taken from context
+
+      let(:whitelist) { Array(allowed_params).flatten.map(&:to_sym) }
+      let(:object)    { test_class.new options }
+      let(:options) do
+        whitelist.inject({}) { |a, e| a.merge(e => rand(1..10)) }
+      end
+
+      before  { subject }
+
+      it "[defines setters]" do
+        whitelist.each { |name| expect(object).to respond_to name }
+      end
+
+      it "[sets default values]" do
+        whitelist.each { |name| expect(object.send name).to eq options[name] }
+      end
+
+      it "[makes getters aliases to params]" do
+        whitelist.each do |name|
+          value = ("a".."z").to_a.sample
+
+          expect { object.params[name] = value }
+            .to change { object.send name }
+            .to value
+        end
+      end
+
+      it "[defines getters]" do
+        whitelist.each { |name| expect(object).to respond_to "#{ name }=" }
+      end
+
+      it "[makes setters aliases to params]" do
+        whitelist.each do |name|
+          value = ("a".."z").to_a.sample
+
+          expect { object.send "#{ name }=", value }
+            .to change { object.params[name] }
+            .to value
+        end
+      end
+
+    end # behaviour
+
+    # ==========================================================================
+    # Tests behaviours
+    # ==========================================================================
+
+    context "without arguments" do
+
+      let(:allowed_params) { [] }
+      subject { test_class.allows_params allowed_params }
+
+      it_behaves_like "white list"
+
+    end # context
+
+    context "with one symbolic argument" do
+
+      let(:allowed_params) { :name }
+      subject { test_class.allows_params allowed_params }
+
+      it_behaves_like "white list"
+      it_behaves_like "attributes creator"
+
+    end # context
+
+    context "with one string argument" do
+
+      let(:allowed_params) { "name" }
+      subject { test_class.allows_params allowed_params }
+
+      it_behaves_like "white list"
+      it_behaves_like "attributes creator"
+
+    end # context
+
+    context "with a list of arguments" do
+
+      let(:allowed_params) { [:name, "code"] }
+      subject { test_class.allows_params(*allowed_params) }
+
+      it_behaves_like "white list"
+      it_behaves_like "attributes creator"
+
+    end # context
+
+    context "with an array of arguments" do
+
+      let(:allowed_params) { [:name, "code"] }
+      subject { test_class.allows_params allowed_params }
+
+      it_behaves_like "white list"
+      it_behaves_like "attributes creator"
+
+    end # context
+  end
+end

data/spec/tests/helpers/parameters_spec.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+describe ServiceObjects::Helpers::Parameters do
+
+  let(:test_class) { Class.new }
+  before  { test_class.include described_class }
+  subject { test_class.new }
+
+  describe "#params" do
+
+    subject { test_class.new }
+
+    it "returns a hash" do
+      expect(subject.params).to be_kind_of Hash
+    end
+
+  end # describe #params
+
+  describe ".whitelist" do
+
+    it "is defined" do
+      expect(test_class).to respond_to :whitelist
+      expect { test_class.instance_eval "@whitelist = [:foo]" }
+        .to change { test_class.whitelist }
+        .to [:foo]
+    end
+
+    it "returns empty array by default" do
+      expect(test_class.whitelist).to eq []
+    end
+
+  end # describe #whitelist
+
+  describe ".new" do
+
+    before { allow(test_class).to receive(:whitelist) { [:foo, :bar] } }
+
+    it "allows options" do
+      expect(test_class).to respond_to(:new).with(1).argument
+    end
+
+    it "makes params optional" do
+      expect(test_class).to respond_to(:new).with(0).argument
+    end
+
+    it "assings parameters from options" do
+      options = { foo: "foo" }
+
+      subject = test_class.new options
+      expect(subject.params).to eq options
+    end
+
+    it "symbolizes options keys at any level" do
+      source_options = { "foo" => "foo", "bar" => { "bar" => "baz" } }
+      target_options = { foo: "foo", bar: { bar: "baz" } }
+
+      subject = test_class.new(source_options)
+      expect(subject.params).to eq target_options
+    end
+
+    it "filters options" do
+      source_options = { foo: "foo", baz: "baz" }
+      target_options = { foo: "foo" }
+
+      subject = test_class.new(source_options)
+      expect(subject.params).to eq target_options
+    end
+
+  end # describe .new
+
+end # describe ServiceObjects::Helpers::Whitelist