service_objects 0.1.0 → 1.0.0

data/spec/tests/helpers/parameterized_spec.rb

@@ -1,136 +0,0 @@
-# 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

@@ -1,71 +0,0 @@
-# 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

data/spec/tests/helpers/validations_spec.rb

@@ -1,60 +0,0 @@
-# encoding: utf-8
-
-describe ServiceObjects::Helpers::Validations do
-
-  let(:invalid)         { ServiceObjects::Invalid           }
-  let(:message_class)   { ServiceObjects::Message           }
-  let(:messages_module) { ServiceObjects::Helpers::Messages }
-  let(:test_class)      { Class.new                         }
-  let(:validations)     { ActiveModel::Validations }
-
-  before { ServiceObjects::Test = test_class        }
-  before { test_class.include described_class       }
-  after  { ServiceObjects.send :remove_const, :Test }
-
-  it "includes ActiveModel::Validations" do
-    expect(test_class).to include validations
-  end
-
-  it "includes ServiceObjects::Helpers::Messages" do
-    expect(test_class).to include messages_module
-  end
-
-  describe "#validate!" do
-
-    subject { test_class.new }
-
-    context "when the service is valid" do
-
-      it "passes" do
-        expect { subject.validate! }.not_to raise_error
-      end
-
-    end
-
-    context "when the service is invalid" do
-
-      before { subject.errors.add :base, :invalid }
-      before { allow(subject).to receive(:valid?) { false } }
-
-      it "fails" do
-        expect { subject.validate! }.to raise_error invalid
-      end
-
-      it "populates #messages from errors" do
-        begin
-          subject.validate!
-        rescue => err
-          message = subject.messages.first
-        end
-
-        expect(message).to be_kind_of message_class
-        expect(message.type).to eq "error"
-        expect(err.messages).to contain_exactly message
-      end
-
-    end
-
-  end # #validate!
-
-end # ServiceObjects::Helpers::Validations

data/spec/tests/invalid_spec.rb

@@ -1,69 +0,0 @@
-# encoding: utf-8
-
-describe ServiceObjects::Invalid do
-
-  let(:messages) { double :messages }
-  let(:object)   { double :object, messages: messages }
-
-  subject { described_class.new object }
-
-  describe ".new" do
-
-    context "without arguments" do
-
-      subject { described_class.new }
-
-      it "fails with ArgumentError" do
-        expect { subject }.to raise_error ArgumentError
-      end
-    end
-
-    context "with an object that doesn't responds to :messages" do
-
-      let(:object) { double }
-      subject { described_class.new object }
-
-      it "fails with TypeError" do
-        expect { subject }.to raise_error TypeError
-      end
-
-      it "returns a proper message" do
-        begin
-          subject
-        rescue => err
-          expect(err.message)
-            .to eq "#{ object.inspect } doesn't respond to #messages"
-        end
-      end
-    end
-
-    context "with an object that responds to :messages" do
-
-      it "doesn't fail" do
-        expect { subject }.not_to raise_error
-      end
-
-      it "initializes a RuntimeError" do
-        expect(subject).to be_kind_of RuntimeError
-      end
-    end
-  end
-
-  describe "#object" do
-
-    it "is initialized" do
-      expect(subject.object).to eq object
-    end
-  end
-
-  describe "#messages" do
-
-    it "returns an array" do
-      expect(subject.messages).to be_kind_of Array
-    end
-
-    it "is delegated to the #object" do
-      expect(subject.messages).to contain_exactly object.messages
-    end
-  end
-end

data/spec/tests/listener_spec.rb

@@ -1,73 +0,0 @@
-# encoding: utf-8
-
-describe ServiceObjects::Listener do
-
-  let(:object) { double :object, foo: nil   }
-  subject      { described_class.new object }
-
-  describe ".new" do
-
-    it "provides a decorator" do
-      expect(subject).to respond_to :foo
-      expect(object).to receive(:foo)
-      subject.foo
-    end
-
-  end # .new
-
-  describe "#otherwise" do
-
-    it "is defined" do
-      expect(subject).to respond_to :otherwise
-    end
-
-  end # #otherwise
-
-  describe "#finalize" do
-
-    before { subject.singleton_class.send(:define_method, :on_success) { nil } }
-
-    shared_examples "calling #otherwise" do
-      after { subject.finalize }
-      it { is_expected.to receive :otherwise }
-    end
-
-    shared_examples "skipping #otherwise" do
-      after { subject.finalize }
-      it { is_expected.not_to receive :otherwise }
-    end
-
-    shared_examples "mutating" do
-      it "returns self" do
-        expect(subject.finalize).to eq subject
-      end
-    end
-
-    context "when no callbacks has been checked" do
-
-      it_behaves_like "calling #otherwise"
-      it_behaves_like "mutating"
-
-    end # context
-
-    context "when undefined callback has been checked" do
-
-      before { subject.respond_to? :on_error }
-
-      it_behaves_like "calling #otherwise"
-      it_behaves_like "mutating"
-
-    end # context
-
-    context "when defined callback has been checked" do
-
-      before { subject.respond_to? :on_success }
-
-      it_behaves_like "skipping #otherwise"
-      it_behaves_like "mutating"
-
-    end # context
-
-  end # #finalize
-
-end # ServiceObjects::Listener

data/spec/tests/message_spec.rb

@@ -1,191 +0,0 @@
-# encoding: utf-8
-require "json"
-
-describe ServiceObjects::Message do
-
-  subject { described_class.new type: :foo, text: :bar }
-
-  it "is comparable" do
-    expect(subject).to be_kind_of ::Comparable
-  end
-
-  describe ".new" do
-
-    it "requires the type" do
-      expect { described_class.new text: :bar }.to raise_error ArgumentError
-    end
-
-    it "requires the text" do
-      expect { described_class.new type: :foo }.to raise_error ArgumentError
-    end
-
-    it "freezes the object" do
-      expect(subject).to be_frozen
-    end
-
-  end # .new
-
-  describe "#type" do
-
-    it "is stringified" do
-      expect(subject.type).to eq "foo"
-    end
-
-    it "is frozen" do
-      expect(subject.type).to be_frozen
-    end
-
-  end # #type
-
-  describe "#text" do
-
-    it "is stringified" do
-      expect(subject.text).to eq "bar"
-    end
-
-    it "is frozen" do
-      expect(subject.text).to be_frozen
-    end
-
-  end # #text
-
-  describe "#priority" do
-
-    it "is float" do
-      expect(subject.priority).to be_kind_of Float
-    end
-
-    it "is customizable" do
-      subject = described_class.new type: "foo", text: "bar", priority: 1.5
-      expect(subject.priority).to eq 1.5
-    end
-
-    it "is set by default to 0.0 for non-errors" do
-      subject = described_class.new type: "foo", text: "bar"
-      expect(subject.priority).to eq 0.0
-    end
-
-    it "is set by default to -1.0 for errors" do
-      subject = described_class.new type: "error", text: "bar"
-      expect(subject.priority).to eq(-1.0)
-    end
-
-  end # #priority
-
-  describe "#inspect" do
-
-    it "returns text, type and priority of the message" do
-      expect(subject.inspect)
-        .to eq %W(
-          #<ServiceObjects::Message:#{ subject.object_id }
-          type=\"#{ subject.type }\"
-          text=\"#{ subject.text }\"
-          priority=#{ subject.priority }>
-        ).join(" ")
-    end
-
-  end # #inspect
-
-  describe "#==" do
-
-    it "treats messages with the same type, text and priority as equal" do
-      a = described_class.new type: "foo", text: "bar"
-      b = described_class.new type: "foo", text: "bar"
-      expect(a == b).to be_truthy
-    end
-
-    it "treats messages with different types as different" do
-      a = described_class.new type: "bar", text: "foo"
-      b = described_class.new type: "baz", text: "foo"
-      expect(a == b).to be_falsey
-    end
-
-    it "treats messages with different texts as different" do
-      a = described_class.new type: "foo", text: "bar"
-      b = described_class.new type: "foo", text: "baz"
-      expect(a == b).to be_falsey
-    end
-
-    it "treats messages with different priorities as different" do
-      a = described_class.new type: "foo", text: "bar", priority: 1
-      b = described_class.new type: "foo", text: "bar", priority: 1.1
-      expect(a == b).to be_falsey
-    end
-
-    it "treats message as different from non-message" do
-      a = described_class.new type: "foo", text: "bar"
-      b = Struct.new(:type, :text).new("foo", "bar")
-      expect(a == b).to be_falsey
-    end
-
-  end # #==
-
-  describe "#<=>" do
-
-    it "orders messages by priorities" do
-      a = described_class.new type: "foo", text: "bar", priority: 0
-      b = described_class.new type: "foo", text: "bar", priority: 0.1
-      expect(a <=> b).to eq(-1)
-      expect(b <=> a).to eq(1)
-    end
-
-    it "orders messages by type" do
-      a = described_class.new type: "bar", text: "foo"
-      b = described_class.new type: "baz", text: "foo"
-      expect(a <=> b).to eq(-1)
-      expect(b <=> a).to eq(1)
-    end
-
-    it "orders messages by text" do
-      a = described_class.new type: "foo", text: "bar"
-      b = described_class.new type: "foo", text: "baz"
-      expect(a <=> b).to eq(-1)
-      expect(b <=> a).to eq(1)
-    end
-
-    it "orders messages at first by priorities" do
-      a = described_class.new type: "bar", text: "bar", priority: 0
-      b = described_class.new type: "baz", text: "baz", priority: 1
-      expect(a <=> b).to eq(-1)
-      expect(b <=> a).to eq(1)
-    end
-
-    it "orders messages at second by types" do
-      a = described_class.new type: "bar", text: "bar"
-      b = described_class.new type: "baz", text: "baz"
-      expect(a <=> b).to eq(-1)
-      expect(b <=> a).to eq(1)
-    end
-
-    it "treats messages with the same type, text and priority as equal" do
-      a = described_class.new type: "foo", text: "bar"
-      b = described_class.new type: "foo", text: "bar"
-      expect(a <=> b).to eq 0
-      expect(b <=> a).to eq 0
-    end
-
-    it "returns nil if other value is not a message" do
-      expect(subject <=> 1).to be_nil
-    end
-
-  end # #<=>
-
-  describe "#to_h" do
-
-    it "serializes type and text" do
-      hash = { type: subject.type, text: subject.text }
-      expect(subject.to_h).to eq hash
-    end
-
-  end # #to_h
-
-  describe "#to_json" do
-
-    it "serializes type and text" do
-      hash = { type: subject.type, text: subject.text }
-      expect(subject.to_json).to eq hash.to_json
-    end
-
-  end # #to_json
-
-end # ServiceObjects::Message