service_objects 0.1.0 → 1.0.0

data/lib/service_objects/version.rb

@@ -4,6 +4,6 @@ module ServiceObjects
 
   # The semantic version of the module.
   # @see http://semver.org/ Semantic versioning 2.0
-  VERSION = "0.1.0".freeze
+  VERSION = "1.0.0".freeze
 
 end # module ServiceObjects

data/service_objects.gemspec

@@ -13,18 +13,20 @@ Gem::Specification.new do |gem|
                   " both the Interactor and Observer design patterns."
   gem.license     = "MIT"
 
-  gem.require_paths    = ["lib"]
   gem.files            = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
-  gem.executables      = ["service"]
   gem.test_files       = Dir["spec/**/*.rb"]
   gem.extra_rdoc_files = Dir["README.md", "LICENSE"]
+  gem.require_paths    = ["lib"]
 
-  gem.required_ruby_version = "~> 2.1"
-  gem.add_runtime_dependency "activemodel", "~> 4.1"
-  gem.add_runtime_dependency "extlib", "~> 0.9"
-  gem.add_runtime_dependency "naught", "~> 1.0"
+  gem.required_ruby_version = "~> 2.0"
+
+  gem.add_runtime_dependency "attestor", "~> 2.2"
+  gem.add_runtime_dependency "attr_coerced", "~> 0.0"
+  gem.add_runtime_dependency "chronicles", "~> 0.0"
+  gem.add_runtime_dependency "virtus", "~> 1.0"
   gem.add_runtime_dependency "wisper", "~> 1.6"
-  gem.add_runtime_dependency "hexx-cli", "~> 0.0"
-  gem.add_development_dependency "hexx-rspec", "~> 0.3"
 
-end
+  gem.add_development_dependency "hexx-cli", "~> 0.0"
+  gem.add_development_dependency "hexx-rspec", "~> 0.4"
+
+end # Gem::Specification

data/spec/lib/base_spec.rb

@@ -0,0 +1,247 @@
+# encoding: utf-8
+
+describe ServiceObjects::Base do
+
+  let(:test_class) { Class.new(described_class) }
+
+  before  { ServiceObjects::Test = test_class }
+  after   { ServiceObjects.send :remove_const, :Test }
+
+  subject { test_class.new }
+
+  describe ".new" do
+
+    it "includes Virtus.model" do
+      expect(subject).to be_kind_of Virtus::Model::Core
+    end
+
+    it "includes Attestor::Validations" do
+      expect(subject).to be_kind_of Attestor::Validations
+    end
+
+    it "includes a Wisper::Publisher" do
+      expect(subject).to be_kind_of Wisper::Publisher
+    end
+
+    it "includes an Attr::Coerced" do
+      expect(subject).to be_kind_of AttrCoerced
+    end
+
+  end # describe .new
+
+  describe ".dependency" do
+
+    let(:implementation) { String }
+
+    context "with default value" do
+
+      before { test_class.dependency :foo, default: implementation }
+
+      it "declares the getter" do
+        expect(subject).to respond_to :foo
+      end
+
+      it "declares the setter" do
+        expect(subject).to respond_to :foo=
+        expect { subject.foo = Object }.to change { subject.foo }.to Object
+      end
+
+      it "sets the default value" do
+        expect(subject.foo).to eq implementation
+      end
+
+    end # context
+
+    context "without default value" do
+
+      before  { test_class.dependency :foo }
+
+      it "declares the getter" do
+        expect(subject).to respond_to :foo
+      end
+
+      it "declares the setter" do
+        expect(subject).to respond_to :foo=
+        expect { subject.foo = Object }.to change { subject.foo }.to Object
+      end
+
+      it "sets the default value" do
+        expect(subject.foo).to be_nil
+      end
+
+    end # context
+
+  end # describe .dependency
+
+  describe "#validate" do
+
+    before { allow(subject).to receive :publish }
+
+    it "calls #validate!" do
+      expect(subject).to receive(:validate!).with(:foo)
+      subject.validate :foo
+    end
+
+    context "when #validate! fails" do
+
+      let(:error) { Attestor::InvalidError.new subject, "foo" }
+
+      before { allow(subject).to receive(:validate!) { fail error } }
+
+      it "doesn't fail" do
+        expect { subject.validate :foo }.not_to raise_error
+      end
+
+      it "publishes an error" do
+        expect(subject).to receive(:publish) do |name, *|
+          expect(name).to eq :error
+        end
+        subject.validate :foo
+      end
+
+      it "publishes error messages" do
+        expect(subject).to receive(:publish) do |_, messages|
+          expect(messages).to be_kind_of Array
+          expect(messages.count).to eq 1
+          expect(messages.first.type).to eq :error
+          expect(messages.first.text).to eq "foo"
+        end
+        subject.validate :foo
+      end
+
+    end # context
+
+    context "when #validate! passes" do
+
+      before { allow(subject).to receive(:validate!) }
+
+      it "publishes nothing" do
+        expect(subject).not_to receive(:publish)
+        subject.validate :foo
+      end
+
+    end # context
+
+  end # describe #validate
+
+  describe "#run" do
+
+    it "calls #run!" do
+      expect(subject).to receive(:run!)
+      subject.run
+    end
+
+    it "catches :published" do
+      allow(subject).to receive(:run!) { throw :published }
+      expect { subject.run }.not_to raise_error
+    end
+
+    it "raises NotImplementedError when #run! not implemented" do
+      expect { subject.run }.to raise_error do |err|
+        expect(err).to be_kind_of NotImplementedError
+        expect(err.message).to eq "#{ subject.class.name }#run! not implemented"
+      end
+    end
+
+  end # describe #run
+
+  describe "#message" do
+
+    context "with a symbolic key" do
+
+      let(:scope)  { %i(service_objects service_objects/test foo) }
+      let(:result) { subject.message :foo, :bar, baz: :qux }
+
+      it "returns the message" do
+        expect(result).to be_kind_of ServiceObjects::Message
+      end
+
+      it "sets the proper message type" do
+        expect(result.type).to eq :foo
+      end
+
+      it "translates the key" do
+        expect(result.text).to eq I18n.t(:bar, scope: scope)
+      end
+
+      it "uses options" do
+        expect(I18n).to receive(:t).with(:bar, scope: scope, baz: :qux)
+        result
+      end
+
+      it "ignores the :scope option" do
+        expect(I18n).to receive(:t).with(:bar, scope: scope)
+        subject.message :foo, :bar, scope: :qux
+      end
+
+    end # context
+
+    context "with non-symbolic key" do
+
+      let(:result) { subject.message :foo, 11, baz: :qux }
+
+      it "returns the message" do
+        expect(result).to be_kind_of ServiceObjects::Message
+      end
+
+      it "sets the proper message type" do
+        expect(result.type).to eq :foo
+      end
+
+      it "stringifies the argument" do
+        expect(result.text).to eq "11"
+      end
+
+    end # context
+
+  end # describe #translate
+
+  describe "#publish" do
+
+    let(:listener) { double foo: nil }
+    before { subject.subscribe listener }
+
+    it "publishes notification" do
+      expect(listener).to receive :foo
+      begin
+        subject.send :publish, :foo
+      rescue
+      end
+    end
+
+    it "throws :published" do
+      expect { subject.send :publish, :success }.to raise_error do |error|
+        expect(error.message).to eq "uncaught throw :published"
+      end
+    end
+
+  end # describe #publish
+
+  describe "#run_service" do
+
+    let(:service)  { double subscribe: nil, run: nil }
+    let(:listener) { double finalize: nil }
+
+    after { subject.run_service service, listener }
+
+    it "subscribes service for the listener" do
+      expect(service).to receive(:subscribe).with(listener, prefix: :on).once
+    end
+
+    it "runs the service" do
+      expect(service).to receive(:run).once
+    end
+
+    it "finalizes the listener" do
+      expect(listener).to receive(:finalize).once
+    end
+
+    it "runs commands in the proper order" do
+      expect(service).to  receive(:subscribe).ordered
+      expect(service).to  receive(:run).ordered
+      expect(listener).to receive(:finalize).ordered
+    end
+
+  end # describe #run_service
+
+end # describe ServiceObjects::Attributes

data/spec/lib/listener_spec.rb

@@ -0,0 +1,96 @@
+# encoding: utf-8
+
+describe ServiceObjects::Listener do
+
+  let(:test_class)  { Class.new(described_class) { attr_reader :foo } }
+  let(:object)      { Class.new { private def bar; end }.new }
+  subject           { test_class.new(object) }
+
+  describe "#respond_to?" do
+
+    it "returns true if method defined" do
+      expect(subject).to respond_to :foo
+    end
+
+    it "returns true if method defined by object" do
+      expect(subject.respond_to?(:bar)).to be_falsey
+      expect(subject.respond_to?(:bar, true)).to be_truthy
+    end
+
+    it "returns false if method neither defined by itself nor by object" do
+      expect(subject).not_to respond_to :baz
+    end
+
+  end # describe #respond_to?
+
+  describe "arbitrary method" do
+
+    it "is delegated to object" do
+      expect(object).to receive(:bar)
+      subject.bar
+    end
+
+  end # describe arbitrary method
+
+  describe "#otherwise" do
+
+    it "is defined" do
+      expect(subject).to respond_to :otherwise
+    end
+
+    it "passes" do
+      expect { subject.otherwise }.not_to raise_error
+    end
+
+  end # describe #otherwise
+
+  describe "#finalize" do
+
+    context "[when own method has been called]" do
+
+      before { subject.foo }
+
+      it "calls #otherwise" do
+        expect(subject).to receive(:otherwise)
+        subject.finalize
+      end
+
+      it "doesn't call #otherwise twice" do
+        expect(subject).to receive(:otherwise).once
+        2.times { subject.finalize }
+      end
+    end
+
+    context "[when own method has been called]" do
+
+      it "doesn't call it again" do
+        expect(subject).to receive(:otherwise).once
+        subject.otherwise
+        subject.finalize
+      end
+
+    end # context
+
+    context "[when delegated method has been called]" do
+
+      before { subject.bar }
+
+      it "doesn't call #otherwise" do
+        expect(subject).not_to receive(:otherwise)
+        subject.finalize
+      end
+
+    end # context
+
+    context "[when no methods has been called]" do
+
+      it "doesn't call #otherwise" do
+        expect(subject).not_to receive(:otherwise)
+        subject.finalize
+      end
+
+    end # context
+
+  end # describe #finalize
+
+end # describe ServiceObjects::Listener

data/spec/lib/message_spec.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+describe ServiceObjects::Message do
+
+  let(:type) { :foo  }
+  let(:text) { "foo" }
+
+  subject { described_class.new type, text }
+
+  describe ".new" do
+
+    it "creates immutable object" do
+      expect(subject).to be_frozen
+    end
+
+  end # describe .new
+
+  describe "#type" do
+
+    it "is initialized" do
+      expect(subject.type).to eq type
+    end
+
+    it "is symbolized" do
+      subject = described_class.new type.to_s, text
+      expect(subject.type).to eq type
+    end
+
+  end # describe #type
+
+  describe "#text" do
+
+    it "is initialized" do
+      expect(subject.text).to eq text
+    end
+
+    it "is stringified" do
+      subject = described_class.new type, text.to_sym
+      expect(subject.text).to eq text
+    end
+
+    it "is immutable" do
+      expect(subject.text).to be_frozen
+    end
+
+  end # describe #text
+
+end # describe ServiceObjects::Message

data/spec/spec_helper.rb

@@ -1,10 +1,12 @@
 # encoding: utf-8
 
-# Loads the RSpec test suit.
-require "hexx-rspec"
+begin
+  require "hexx-suit"
+  Hexx::Suit.load_metrics_for(self)
+rescue LoadError
+  require "hexx-rspec"
+  Hexx::RSpec.load_metrics_for(self)
+end
 
-# Loads runtime metrics in the current scope
-Hexx::RSpec.load_metrics_for(self)
-
-# Loads the code of the module.
+# Loads the code under test
 require "service_objects"