simple-service 0.1.1 → 0.1.6

data/spec/simple/service/action_invoke_spec.rb

@@ -0,0 +1,237 @@
+# rubocop:disable Style/WordArray
+
+require "spec_helper"
+
+describe "Simple::Service.invoke" do
+  # the context to use in the around hook below. By default this is nil -
+  # which gives us an empty context.
+  let(:context) { nil }
+
+  around do |example|
+    ::Simple::Service.with_context(context) { example.run }
+  end
+
+  let(:service) { InvokeTestService }
+  let(:action)  { nil }
+
+  # a shortcut
+  def invoke!(args: {}, flags: {})
+    @actual = ::Simple::Service.invoke(service, action, args: args, flags: flags)
+    # rescue ::StandardError => e
+  rescue ::Simple::Service::ArgumentError => e
+    @actual = e
+  end
+
+  attr_reader :actual
+
+  context "calling an action w/o parameters" do
+    # reminder: this is the definition of no_params
+    #
+    # def no_params
+    #   "service2 return"
+    # end
+
+    let(:action) { :no_params }
+
+    context "calling without args" do
+      it "runs the action" do
+        invoke!
+        expect(actual).to eq("service2 return")
+      end
+    end
+
+    context "calling with extra named args" do
+      it "ignores extra args" do
+        invoke!(args: { "foo" => "foo", "bar" => "bar" })
+        expect(actual).to eq("service2 return")
+      end
+    end
+
+    context "calling with extra flags" do
+      it "ignores extra args" do
+        invoke!(flags: { "foo" => "foo", "bar" => "bar" })
+        expect(actual).to eq("service2 return")
+      end
+    end
+  end
+
+  context "calling an action w/positional parameters" do
+    # reminder: this is the definition of positional_params
+    #
+    # def positional_params(a, b, c = "speed-of-light", e = 2.781)
+    #   [a, b, c, e]
+    # end
+
+    let(:action) { :positional_params }
+
+    context "without args" do
+      it "raises MissingArguments" do
+        invoke!
+        expect(actual).to be_a(::Simple::Service::MissingArguments)
+        expect(actual.to_s).to match(/\ba, b\b/)
+      end
+    end
+
+    context "with the required number of args" do
+      it "runs" do
+        invoke!(args: { "a" => "foo", "b" => "bar" })
+        expect(actual).to eq(["foo", "bar", "speed-of-light", 2.781])
+      end
+    end
+
+    context "with the required number of args and flags" do
+      it "merges flags and args to provide arguments" do
+        invoke!(args: { "a" => "foo" }, flags: { "b" => "bar" })
+        expect(actual).to eq(["foo", "bar", "speed-of-light", 2.781])
+      end
+    end
+
+    context "with the allowed number of args" do
+      it "runs" do
+        invoke!(args: { "a" => "foo", "b" => "bar", "c" => "baz", "e" => "number4" })
+        expect(actual).to eq(%w[foo bar baz number4])
+      end
+    end
+
+    context "calling with extra named args" do
+      it "ignores extra args" do
+        invoke!(args: { "a" => "foo", "b" => "bar", "c" => "baz", "e" => "number4", "extra3" => 3 })
+        expect(actual).to eq(%w[foo bar baz number4])
+      end
+    end
+  end
+
+  context "calling an action w/named parameters" do
+    # reminder: this is the definition of named_params
+    #
+    # def named_params(a:, b:, "c" => "speed-of-light", e: 2.781)
+    #   [a, b, c, e]
+    # end
+
+    let(:action) { :named_params }
+
+    context "without args" do
+      it "raises MissingArguments" do
+        invoke!
+        expect(actual).to be_a(::Simple::Service::MissingArguments)
+        expect(actual.to_s).to match(/\ba, b\b/)
+      end
+    end
+
+    context "with the required number of args" do
+      it "runs" do
+        invoke!(args: { "a" => "foo", "b" => "bar" })
+        expect(actual).to eq(["foo", "bar", "speed-of-light", 2.781])
+      end
+    end
+
+    context "with the allowed number of args" do
+      it "runs" do
+        invoke!(args: { "a" => "foo", "b" => "bar", "c" => "baz", "e" => "number4" })
+        expect(actual).to eq(%w[foo bar baz number4])
+      end
+    end
+
+    context "with extra named args" do
+      it "ignores extra args" do
+        invoke!(args: { "a" => "foo", "b" => "bar", "c" => "baz", "extra3" => 3 })
+        expect(actual).to eq(["foo", "bar", "baz", 2.781])
+      end
+    end
+  end
+
+  context "calling an action w/mixed and optional parameters" do
+    # reminder: this is the definition of named_params
+    #
+    # def mixed_optional_params(a, b = "default-b", c = "speed-of-light", e: 2.781)
+    #   [a, b, c, e]
+    # end
+
+    let(:action) { :mixed_optional_params }
+
+    context "without args" do
+      it "raises MissingArguments" do
+        invoke!
+        expect(actual).to be_a(::Simple::Service::MissingArguments)
+      end
+    end
+
+    context "with the required number of args" do
+      it "runs" do
+        invoke!(args: { "a" => "foo" })
+        expect(actual).to eq(["foo", "default-b", "speed-of-light", 2.781])
+      end
+    end
+
+    context "with the allowed number of args" do
+      it "runs" do
+        invoke!(args: { "a" => "foo", "b" => "bar", "c" => "baz", "e" => "number4" })
+        expect(actual).to eq(%w[foo bar baz number4])
+      end
+    end
+
+    context "with extra named args" do
+      it "ignores extra args" do
+        invoke!(args: { "a" => "foo", "b" => "bar", "c" => "baz", "e" => "number4", "extra3" => 3 })
+        expect(actual).to eq(["foo", "bar", "baz", "number4"])
+      end
+    end
+  end
+
+  context "calling an action w/mixed and variadic parameters" do
+    # reminder: this is the definition of variadic_params
+    #
+    # def variadic_params(a, b = "queen bee", *args, e: 2.781)
+    #   [a, b, args, e]
+    # end
+
+    let(:action) { :variadic_params }
+
+    context "without args" do
+      it "raises MissingArguments" do
+        invoke!
+        expect(actual).to be_a(::Simple::Service::MissingArguments)
+      end
+    end
+
+    context "with the required number of args" do
+      it "runs" do
+        invoke!(args: { "a" => "foo" })
+        expect(actual).to eq(["foo", "queen bee", [], 2.781])
+      end
+    end
+
+    context "with the allowed number of args" do
+      it "runs" do
+        invoke!(args: { "a" => "foo", "b" => "bar", "args" => ["baz"] }, flags: { "e" => "number4" })
+        expect(actual).to eq(["foo", "bar", ["baz"], "number4"])
+      end
+    end
+
+    context "with variadic args" do
+      it "sends the variadic args from the args: parameter" do
+        invoke!(args: { "a" => "foo", "b" => "bar", "args" => ["baz", "extra"] }, flags: { "e" => "number4", "extra3" => 2 })
+        expect(actual).to eq(["foo", "bar", ["baz", "extra"], "number4"])
+      end
+
+      it "sends the variadic args from the flags: parameter" do
+        invoke!(args: { "a" => "foo", "b" => "bar" }, flags: { "args" => ["baz", "extra"], "e" => "number4", "extra3" => 2 })
+        expect(actual).to eq(["foo", "bar", ["baz", "extra"], "number4"])
+      end
+    end
+  end
+
+  describe "calling with symbolized Hashes" do
+    it "raises ArgumentError" do
+      hsh = { a: "foo", "b" => "KJH" }
+
+      expect do
+        invoke!(args: hsh)
+      end.to raise_error(Expectation::Matcher::Mismatch)
+
+      expect do
+        invoke!(flags: hsh)
+      end.to raise_error(Expectation::Matcher::Mismatch)
+    end
+  end
+end

data/spec/simple/service/action_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+describe Simple::Service::Action do
+  let(:service) { SpecService }
+
+  let(:service1) { ::Simple::Service.action(service, :service1) }
+  let(:service2) { ::Simple::Service.action(service, :service2) }
+  let(:service3) { ::Simple::Service.action(service, :service3) }
+
+  describe "attributes" do
+    describe "#service" do
+      it "returns the service module" do
+        expect(service1.service).to eq(service)
+      end
+    end
+
+    describe "#name" do
+      it "returns the action name" do
+        expect(service1.name).to eq(:service1)
+      end
+    end
+
+    describe "full_name" do
+      it "returns the full_name" do
+        expect(service1.full_name).to eq("SpecService#service1")
+      end
+    end
+
+    describe "to_s" do
+      it "returns the full_name" do
+        expect(service1.to_s).to eq("SpecService#service1")
+      end
+    end
+
+    describe "#short_description" do
+      it "returns the short_description as per source code" do
+        expect(service1.short_description).to eq("This is service1")
+        expect(service2.short_description).to eq("This is service2 (no full description)")
+        expect(service3.short_description).to eq(nil)
+      end
+    end
+
+    describe "#full_description" do
+      it "returns the full_description as per source code" do
+        expect(service1.full_description).to eq("Service 1 has a full description")
+        expect(service2.full_description).to eq(nil)
+        expect(service3.full_description).to eq(nil)
+      end
+    end
+  end
+end

data/spec/simple/service/context_spec.rb

@@ -1,13 +1,47 @@
 require "spec_helper"
 
+describe Simple::Service do
+  describe ".with_context" do
+    it "merges the current context for the duration of the block" do
+      block_called = false
+
+      Simple::Service.with_context(a: "a") do
+        expect(Simple::Service.context.a).to eq("a")
+
+        # overwrite value
+        Simple::Service.with_context(a: "b") do
+          expect(Simple::Service.context.a).to eq("b")
+          block_called = true
+        end
+
+        # overwrite value w/nil
+        Simple::Service.with_context(a: nil) do
+          expect(Simple::Service.context.a).to be_nil
+          Simple::Service.context.a = "c"
+          expect(Simple::Service.context.a).to eq("c")
+        end
+        expect(Simple::Service.context.a).to eq("a")
+      end
+
+      expect(block_called).to eq(true)
+    end
+  end
+end
+
 describe Simple::Service::Context do
   let(:context) { Simple::Service::Context.new }
-  
+
   before do
     context.one = 1
   end
 
-  describe "reading" do
+  describe "invalid identifier" do
+    it "raises an error" do
+      expect { context.one! }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe "context reading" do
     it "returns a value if set" do
       expect(context.one).to eq(1)
     end
@@ -17,16 +51,14 @@ describe Simple::Service::Context do
     end
   end
 
-  describe "writing" do
+  describe "context writing" do
     it "sets a value if it does not exist yet" do
-      context.two = 2 
+      context.two = 2
       expect(context.two).to eq(2)
     end
 
     it "raises a ReadOnly error if the value exists and is not equal" do
-      expect {
-        context.one = 2 
-      }.to raise_error(::Simple::Service::Context::ReadOnlyError)
+      expect { context.one = 2 }.to raise_error(::Simple::Service::ContextReadOnlyError)
     end
 
     it "sets the value if it exists and is equal" do

data/spec/simple/service/service_spec.rb

@@ -0,0 +1,158 @@
+require "spec_helper"
+
+# rubocop:disable Style/WordArray
+
+describe "Simple::Service" do
+  context "when running against a NoService module" do
+    let(:service) { NoServiceModule }
+
+    describe ".service?" do
+      it "returns false on a NoService module" do
+        expect(Simple::Service.service?(service)).to eq(false)
+      end
+    end
+
+    describe ".actions" do
+      it "raises an argument error" do
+        expect { Simple::Service.actions(service) }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe ".action" do
+      it "raises an argument error" do
+        expect { Simple::Service.action(service, :service1) }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe ".invoke3" do
+      it "raises an argument error" do
+        ::Simple::Service.with_context do
+          expect { Simple::Service.invoke3(service, :service1, {}, {}, context: nil) }.to raise_error(::ArgumentError)
+        end
+      end
+    end
+  end
+
+  # running against a proper service module
+  let(:service) { SpecService }
+
+  describe ".service?" do
+    it "returns true" do
+      expect(Simple::Service.service?(service)).to eq(true)
+    end
+  end
+
+  describe ".actions" do
+    it "returns a Hash of actions on a Service module" do
+      actions = Simple::Service.actions(service)
+      expect(actions).to be_a(Hash)
+      expect(actions.keys).to contain_exactly(:service1, :service2, :service3)
+    end
+  end
+
+  describe ".action" do
+    context "with an existing name" do
+      it "returns a Action object" do
+        action = Simple::Service.action(service, :service1)
+        expect(action.service).to eq(service)
+        expect(action.name).to eq(:service1)
+      end
+    end
+
+    describe "Simple::Service::NoSuchAction" do
+      it "does not inherit from Simple::Service::ArgumentError" do
+        expect(Simple::Service::NoSuchAction < Simple::Service::ArgumentError).to be_falsey
+      end
+
+      it "inherits from ArgumentError" do
+        expect(Simple::Service::NoSuchAction < ::ArgumentError).to eq true
+      end
+    end
+
+    context "with an unknown name" do
+      it "raises a NoSuchAction error" do
+        expect do
+          Simple::Service.action(service, :no_such_service)
+        end.to raise_error(Simple::Service::NoSuchAction, /No such action :no_such_service/)
+      end
+    end
+  end
+
+  describe ".invoke3" do
+    def invoke3
+      Simple::Service.invoke3(service, :service1, "my_a", "my_b", d: "my_d")
+    end
+
+    context "when context is not set" do
+      it "raises a ContextMissingError" do
+        action = Simple::Service.actions(service)[:service1]
+        expect(action).not_to receive(:invoke)
+
+        expect do
+          invoke3
+        end.to raise_error(::Simple::Service::ContextMissingError)
+      end
+    end
+
+    context "when context is set" do
+      it "calls Action#invoke with the right arguments" do
+        action = Simple::Service.actions(service)[:service1]
+        expect(action).to receive(:invoke).with(args: ["my_a", "my_b"], flags: { "d" => "my_d" })
+
+        ::Simple::Service.with_context do
+          invoke3
+        end
+      end
+    end
+  end
+
+  describe ".invoke" do
+    context "with a args array" do
+      def invoke
+        Simple::Service.invoke(service, :service1, args: ["my_a", "my_b"], flags: { "d" => "my_d" })
+      end
+
+      context "when context is not set" do
+        it "raises a ContextMissingError" do
+          action = Simple::Service.actions(service)[:service1]
+          expect(action).not_to receive(:invoke)
+
+          expect do
+            invoke
+          end.to raise_error(::Simple::Service::ContextMissingError)
+        end
+      end
+
+      context "when context is set" do
+        it "calls Action#invoke with the right arguments" do
+          action = Simple::Service.actions(service)[:service1]
+          expect(action).to receive(:invoke).with(args: ["my_a", "my_b"], flags: { "d" => "my_d" }).and_call_original
+
+          ::Simple::Service.with_context do
+            invoke
+          end
+        end
+      end
+    end
+  end
+
+  describe "documentation example" do
+    def invoke(*args, **flags)
+      Simple::Service.invoke(SpecTestService, :foo, *args, **flags)
+    end
+
+    def invoke3(*args, **flags)
+      Simple::Service.invoke3(SpecTestService, :foo, *args, **flags)
+    end
+
+    it "calls Action#invoke with the right arguments" do
+      expected = ["bar-value", "baz-value"]
+      ::Simple::Service.with_context do
+        expect(invoke3("bar-value", baz: "baz-value")).to eq(expected)
+        expect(invoke3(bar: "bar-value", baz: "baz-value")).to eq(expected)
+        expect(invoke(args: ["bar-value"], flags: { "baz" => "baz-value" })).to eq(expected)
+        expect(invoke(args: { "bar" => "bar-value", "baz" => "baz-value" })).to eq(expected)
+      end
+    end
+  end
+end