service_objects 0.1.0 → 1.0.0

data/spec/tests/bin/service_spec.rb

@@ -1,18 +0,0 @@
-# encoding: utf-8
-
-describe "$ service new", :sandbox, :capture do
-
-  let(:argv) { %w(foo) }
-
-  before { try_in_sandbox { `service new #{ argv.join(" ") }` } }
-
-  it "runs a scaffolder" do
-    %w(
-      app/services/foo.rb
-      config/locales/services/foo/en.yml
-      config/locales/services/foo/ru.yml
-      spec/tests/services/foo_spec.rb
-    ).each { |file| expect(file).to be_present_in_sandbox }
-  end
-
-end # describe $ service new

data/spec/tests/cli_spec.rb

@@ -1,179 +0,0 @@
-# encoding: utf-8
-require "service_objects/cli"
-
-describe ServiceObjects::CLI, :sandbox, :capture do
-
-  subject { try_in_sandbox { described_class.start options } }
-
-  shared_examples "adding an object" do
-
-    let(:file)    { "app/#{ folder }/foo.rb" }
-    let(:content) { read_in_sandbox(file)    }
-
-    it "[creates file]" do
-      expect(file).to be_present_in_sandbox
-    end
-
-    it "[declares a service]" do
-      expect(content).to include "class Foo < ServiceObjects::Base"
-    end
-
-  end # examples
-
-  shared_examples "adding a specification" do
-
-    it "[creates file]" do
-      expect("spec/tests/#{ folder }/foo_spec.rb").to be_present_in_sandbox
-    end
-
-  end # examples
-
-  shared_examples "adding translations" do |locales|
-
-    it "[creates files]" do
-      locales.each do |locale|
-        file = "config/locales/#{ folder }/foo/#{ locale }.yml"
-        expect(file).to be_present_in_sandbox
-      end
-    end
-
-    it "[adds content]" do
-      locales.each do |locale|
-        file    = "config/locales/#{ folder }/foo/#{ locale }.yml"
-        content = read_in_sandbox(file)
-
-        expect(content).to include("# #{ locale }:")
-        expect(content).to include("#{ folder }/foo:")
-      end
-    end
-
-  end # examples
-
-  shared_examples "using namespaces" do |modules|
-
-    let(:file)    { "app/#{ folder }/foo.rb" }
-    let(:content) { read_in_sandbox(file)    }
-
-    it "[adds modules]" do
-      modules.each do |item|
-        expect(content).to include "module #{ item }"
-      end
-    end
-
-  end # examples
-
-  context "foo" do
-
-    let(:options) { %w(foo)    }
-    let(:folder)  { "services" }
-
-    before { subject }
-
-    it_behaves_like "adding an object"
-    it_behaves_like "using namespaces", %w(Services)
-    it_behaves_like "adding a specification"
-    it_behaves_like "adding translations", %w(en ru)
-
-  end # context
-
-  context "foo -p bar baz" do
-
-    let(:options) { %w(foo -p bar baz) }
-    let(:folder)  { "services" }
-
-    before { subject }
-
-    it_behaves_like "adding an object"
-    it_behaves_like "using namespaces", %w(Services)
-    it_behaves_like "adding a specification"
-    it_behaves_like "adding translations", %w(en ru)
-
-    it "uses parameters" do
-      content = read_in_sandbox("app/services/foo.rb")
-      expect(content).to include "allows_params :bar, :baz"
-    end
-
-  end # context
-
-  context "foo -n foo:bar:baz" do
-
-    let(:options) { %w(foo -n foo:bar:baz cad:cam:messages) }
-    let(:folder)  { "services" }
-
-    before { subject }
-
-    it_behaves_like "adding an object"
-    it_behaves_like "using namespaces", %w(Services)
-    it_behaves_like "adding a specification"
-    it_behaves_like "adding translations", %w(en ru)
-
-    it "uses notifications" do
-      content = read_in_sandbox("app/services/foo.rb")
-      expect(content).to include "publish :foo, bar, baz"
-    end
-
-  end # context
-
-  context "foo -f bar baz" do
-
-    let(:options) { %w(foo -f bar baz) }
-    let(:folder)  { "bar/baz" }
-
-    before { subject }
-
-    it_behaves_like "adding an object"
-    it_behaves_like "using namespaces", %w(Bar Baz)
-    it_behaves_like "adding a specification"
-    it_behaves_like "adding translations", %w(en ru)
-
-  end # context
-
-  context "foo -f bar/baz" do
-
-    let(:options) { %w(foo -f bar/baz) }
-    let(:folder)  { "bar/baz" }
-
-    before { subject }
-
-    it_behaves_like "adding an object"
-    it_behaves_like "using namespaces", %w(Bar Baz)
-    it_behaves_like "adding a specification"
-    it_behaves_like "adding translations", %w(en ru)
-
-  end # context
-
-  context "foo -l jp ua" do
-
-    let(:options) { %w(foo -l jp ua) }
-    let(:folder)  { "services" }
-
-    before { subject }
-
-    it_behaves_like "adding an object"
-    it_behaves_like "using namespaces", %w(Services)
-    it_behaves_like "adding a specification"
-    it_behaves_like "adding translations", %w(jp ua)
-
-  end # context
-
-  context "foo -d get_item{AddItem}" do
-
-    let(:options) { %w(foo -d get_item{AddItem}) }
-    let(:folder)  { "services" }
-
-    before { subject }
-
-    it_behaves_like "adding an object"
-    it_behaves_like "using namespaces", %w(Services)
-    it_behaves_like "adding a specification"
-    it_behaves_like "adding translations", %w(en ru)
-
-    it "uses dependencies" do
-      content = read_in_sandbox("app/services/foo.rb")
-      expect(content).to include "depends_on get_item, default: AddItem"
-      expect(content).to include "GetItemListener"
-    end
-
-  end # context
-
-end # describe

data/spec/tests/helpers/dependable_spec.rb

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

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

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