simple-service 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d65e66415fb2f397d259653690c278d2322d196433617694df746fabc31a3e13
-  data.tar.gz: 1c37a1564e0cfd743eba8ff453b6659e4bd4cc6d82b240c095931b3b6eb5ec26
+  metadata.gz: b11dc9f7476ba1c23a3ee3f59efd5a24c33c1e867d8d8e537d5b2e6d554cefa2
+  data.tar.gz: c4e792ec0eadd9be20a9fd4bc1aacf9a19997cd56a0893d9d7c8fd41b1fd9313
 SHA512:
-  metadata.gz: 32271afe6c145349999b772d8d9981cd09895e78228a01fa8d22a3103fd4a8ea1e198f7e24a69681a6068b00c7f81b7944a613efc5fb7f9bdbb5d7221fa42f0b
-  data.tar.gz: 8ed02caac30787e6e9dc62491374f1bd75a9116c29b4091bb4027336b28e53f0499918b95d45d5961d3e52f405e5a099f448c2461180e8f170b35f1f33032a41
+  metadata.gz: 937d5e053a777c3a5a0876b697e5e39af0927bc53a867ebafa2fe7961c54ff6ce25629f5a7b6417f2578482aea85f193934a51376fbf202739c4ee50a6e746bc
+  data.tar.gz: c50ceef04bc2191802e1f48e2c8fb5761d5cbb0642f21e6d58db28929ed18d0bd4870dcfe52db88524fef85576c216845e570cd48f458f03bce171fc8ba0961a

data/.github/workflows/rspec.yaml

@@ -0,0 +1,25 @@
+on: push
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    # https://help.github.com/en/articles/workflow-syntax-for-github-actions#jobsjob_idstrategymatrix
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby_version: [2.7, 3.1.2]
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          # Not needed with a .ruby-version file
+          ruby-version: ${{ matrix.ruby_version }}
+          # runs 'bundle install' and caches installed gems automatically
+          bundler-cache: true
+
+      - name: Run tests
+        run: |
+          bundle exec rspec

data/Gemfile

@@ -6,8 +6,8 @@ gemspec
 # --- Development and test dependencies ------------------------------
 
 group :development, :test do
-  gem 'rake', '~> 11'
-  gem 'rspec', '~> 3.7'
+  gem 'rake'
+  gem 'rspec'
   # gem 'rubocop', '~> 0.61.1'
   gem 'simplecov', '~> 0'
   gem 'pry-byebug'

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.3.0

data/lib/simple/service/action/method_reflection.rb

@@ -1,4 +1,4 @@
-# rubocop:disable Metrics/AbcSize
+# rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
 
 module ::Simple::Service::Action::MethodReflection # @private
   extend self
@@ -29,13 +29,14 @@ module ::Simple::Service::Action::MethodReflection # @private
 
     fake_recipient = Object.new.extend(service)
     fake_call_args = minimal_arguments(method)
+    fake_call_kwargs = fake_call_args.last.is_a?(Hash) ? fake_call_args.pop : {}
 
     trace_point = TracePoint.trace(:call) do |tp|
       throw :received_fake_call, tp.binding if tp.defined_class == service && tp.method_id == method_id
     end
 
     bnd = catch(:received_fake_call) do
-      fake_recipient.send(method_id, *fake_call_args)
+      fake_recipient.send(method_id, *fake_call_args, **fake_call_kwargs)
     end
 
     trace_point.disable

data/lib/simple/service/action.rb

@@ -78,13 +78,21 @@ module Simple::Service
 
       verify_required_args!(args, flags)
 
+      args = args.dup
+      flags = flags.dup
+
       positionals = build_positional_arguments(args, flags)
+
+      if flags["args"].is_a?(Array)
+        positionals.concat flags.delete("args")
+      end
+
       keywords = build_keyword_arguments(args.merge(flags))
 
       # check for extra flags
-      extra_flags = (flags.keys - keywords.keys.map(&:to_s)).map { |flag| "--#{flag}" }
-      unless extra_flags.empty?
-        raise Simple::Service::ArgumentError, "Unknown flag(s): #{extra_flags.join(", ")}."
+      unknown_flags = (flags.keys - keywords.keys.map(&:to_s))
+      unless unknown_flags.empty?
+        raise Simple::Service::UnknownFlagError.new(name, unknown_flags)
       end
 
       service_instance = Object.new
@@ -108,7 +116,7 @@ module Simple::Service
       missing_parameters = @required_names - args.keys - flags.keys
       return if missing_parameters.empty?
 
-      raise ::Simple::Service::MissingArguments.new(self, missing_parameters)
+      raise ::Simple::Service::MissingArgumentError.new(self, missing_parameters)
     end
 
     # Enumerating all parameters it puts all named parameters into a Hash
@@ -139,9 +147,9 @@ module Simple::Service
     def build_positional_arguments(args, flags)
       positionals = positional_names.each_with_object([]) do |parameter_name, ary|
         if args.key?(parameter_name)
-          ary << args[parameter_name]
+          ary << args.delete(parameter_name)
         elsif flags.key?(parameter_name)
-          ary << flags[parameter_name]
+          ary << flags.delete(parameter_name)
         end
       end
 
@@ -149,9 +157,9 @@ module Simple::Service
       # It is always optional - but if it exists it must be an Array.
       if variadic_parameter
         value = if args.key?(variadic_parameter.name)
-                  args[variadic_parameter.name]
+                  args.delete(variadic_parameter.name)
                 elsif flags.key?(variadic_parameter.name)
-                  flags[variadic_parameter.name]
+                  flags.delete(variadic_parameter.name)
                 end
 
         positionals.concat(value) if value
@@ -175,7 +183,7 @@ module Simple::Service
         ary = ary[0..positional_names.length]
 
         if !extra_arguments.empty? && !variadic_parameter
-          raise ::Simple::Service::ExtraArguments.new(self, extra_arguments)
+          raise ::Simple::Service::ExtraArgumentError.new(self, extra_arguments)
         end
 
         existing_positional_names = positional_names

data/lib/simple/service/errors.rb

@@ -1,6 +1,6 @@
 module Simple::Service
   # Will be raised by ::Simple::Service.action.
-  class NoSuchAction < ::ArgumentError
+  class NoSuchActionError < ::ArgumentError
     attr_reader :service, :name
 
     def initialize(service, name)
@@ -18,7 +18,7 @@ module Simple::Service
   class ArgumentError < ::ArgumentError
   end
 
-  class MissingArguments < ArgumentError
+  class MissingArgumentError < ArgumentError
     attr_reader :action
     attr_reader :parameters
 
@@ -32,7 +32,7 @@ module Simple::Service
     end
   end
 
-  class ExtraArguments < ArgumentError
+  class ExtraArgumentError < ArgumentError
     attr_reader :action
     attr_reader :arguments
 
@@ -42,8 +42,22 @@ module Simple::Service
     end
 
     def to_s
-      str = @arguments.map(&:inspect).join(", ")
-      "#{action}: extra argument(s) #{str}"
+      str = arguments.map(&:inspect).join(", ")
+      "#{action}: extra argument(s): #{str}"
+    end
+  end
+
+  class UnknownFlagError < ExtraArgumentError
+    attr_reader :flags
+
+    def initialize(action, flags)
+      @flags = flags
+      super(action, flags)
+    end
+
+    def to_s
+      inspected_flags = flags.map { |flag| "--#{flag}" }.join(", ")
+      "#{action}: unknown flag(s): #{inspected_flags}"
     end
   end
 

data/lib/simple/service.rb

@@ -86,7 +86,7 @@ module Simple::Service
 
     actions = self.actions(service)
     actions[name] || begin
-      raise ::Simple::Service::NoSuchAction.new(service, name)
+      raise ::Simple::Service::NoSuchActionError.new(service, name)
     end
   end
 
@@ -98,6 +98,14 @@ module Simple::Service
   # As the main purpose of this module is to call services with outside data,
   # the +.invoke+ action is usually preferred.
   def self.invoke3(service, name, *args, **flags)
+    # The following checks if flags is empty. This might be intentional, but might also mean that
+    # the caller is sending in kwargs as last arguments of the args array.
+    #
+    # This is supported in 2.7.*, but no longer works with ruby 3.
+    if flags.empty? && args.last.is_a?(Hash)
+      flags = args.pop
+    end
+
     flags = flags.transform_keys(&:to_s)
     invoke service, name, args: args, flags: flags
   end

data/simple-service.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |gem|
   # executables are used for development purposes only
   gem.executables   = []
 
-  gem.required_ruby_version = '~> 2.5'
+  gem.required_ruby_version = '>= 2.5'
 
   gem.add_dependency "expectation", "~> 1"
   gem.add_dependency "simple-immutable", "~> 1", ">= 1.1"

data/spec/simple/service/action_invoke3_spec.rb

@@ -6,16 +6,6 @@ describe "Simple::Service.invoke3" do
   let(:service) { InvokeTestService }
   let(:action)  { nil }
 
-  # a shortcut
-  def invoke3!(*args, **keywords)
-    @actual = ::Simple::Service.invoke3(service, action, *args, **keywords)
-    # rescue ::StandardError => e
-  rescue ::Simple::Service::ArgumentError => e
-    @actual = e
-  end
-
-  attr_reader :actual
-
   # when calling #invoke3 using positional arguments they will be matched against
   # positional arguments of the invoke3d method - but they will not be matched
   # against named arguments.
@@ -37,33 +27,34 @@ describe "Simple::Service.invoke3" do
 
     context "calling without args" do
       it "runs the action" do
-        invoke3!
+        actual = ::Simple::Service.invoke3(service, action)
         expect(actual).to eq("service2 return")
       end
     end
 
     context "calling with extra positional args" do
       it "raises ExtraArguments" do
-        invoke3!("foo", "bar")
-        expect(actual).to be_a(::Simple::Service::ExtraArguments)
-        expect(actual.to_s).to match(/"foo", "bar"/)
+        expect {
+          ::Simple::Service.invoke3(service, action, "foo", "bar")
+        }.to raise_error(::Simple::Service::ExtraArgumentError, /"foo", "bar"/)
       end
     end
 
     context "calling with extra named args" do
-      it "ignores extra args" do
-        invoke3!(foo: "foo", bar: "bar")
-        expect(actual).to eq("service2 return")
+      it "raises an ExtraArguments error" do
+        expect {
+          ::Simple::Service.invoke3(service, action, foo: "foo", bar: "bar")
+        }.to raise_error(::Simple::Service::ExtraArgumentError)
       end
     end
 
     context "calling with an additional hash arg" do
-      xit "ignores extra args" do
-        args = []
-        args.push foo: "foo", bar: "bar"
-        invoke3!(*args)
-
-        expect(actual).to be_a(::Simple::Service::ExtraArguments)
+      it "ignores extra args" do
+        expect {
+          args = []
+          args.push foo: "foo", bar: "bar"
+          ::Simple::Service.invoke3(service, action, *args)
+        }.to raise_error(::Simple::Service::ExtraArgumentError)
       end
     end
   end
@@ -79,44 +70,48 @@ describe "Simple::Service.invoke3" do
 
     context "without args" do
       it "raises MissingArguments" do
-        invoke3!
-        expect(actual).to be_a(::Simple::Service::MissingArguments)
+        expect {
+          ::Simple::Service.invoke3(service, action)
+        }.to raise_error(::Simple::Service::MissingArgumentError)
       end
     end
 
     context "with the required number of args" do
       it "runs" do
-        invoke3!("foo", "bar")
+        actual = ::Simple::Service.invoke3(service, action, "foo", "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
-        invoke3!("foo", "bar", "baz", "number4")
+        actual = ::Simple::Service.invoke3(service, action, "foo", "bar", "baz", "number4")
         expect(actual).to eq(%w[foo bar baz number4])
       end
     end
 
     context "with more than the allowed number of args" do
       it "raises ExtraArguments" do
-        invoke3!("foo", "bar", "baz", "number4", "extra")
-        expect(actual).to be_a(::Simple::Service::ExtraArguments)
+        expect {
+          ::Simple::Service.invoke3(service, action, "foo", "bar", "baz", "number4", "extra")
+        }.to raise_error(::Simple::Service::ExtraArgumentError)
       end
     end
 
     context "calling with extra named args" do
       it "ignores extra args" do
-        invoke3!("foo", "bar", "baz", extra3: 3)
-        expect(actual).to eq(["foo", "bar", "baz", 2.781])
+        expect {
+          ::Simple::Service.invoke3(service, action, "foo", "bar", "baz", extra3: 3)
+        }.to raise_error(::Simple::Service::ExtraArgumentError)
       end
     end
 
     context "calling with an additional hash arg" do
-      xit "raises ExtraArguments" do
-        args = ["foo", "bar", "baz", extra3: 3]
-        invoke3!(*args)
-        expect(actual).to be_a(::Simple::Service::ExtraArguments)
+      it "raises ExtraArguments" do
+        expect {
+          args = ["foo", "bar", "baz", extra3: 3]
+          ::Simple::Service.invoke3(service, action, *args)
+        }.to raise_error(::Simple::Service::ExtraArgumentError)
       end
     end
   end
@@ -132,36 +127,39 @@ describe "Simple::Service.invoke3" do
 
     context "without args" do
       it "raises MissingArguments" do
-        invoke3!
-        expect(actual).to be_a(::Simple::Service::MissingArguments)
+        expect {
+          ::Simple::Service.invoke3(service, action)
+        }.to raise_error(::Simple::Service::MissingArgumentError)
       end
     end
 
     context "with the required number of args" do
       it "runs" do
-        invoke3!(a: "foo", b: "bar")
+        actual = ::Simple::Service.invoke3(service, action, 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
-        invoke3!(a: "foo", b: "bar", c: "baz", e: "number4")
+        actual = ::Simple::Service.invoke3(service, action, a: "foo", b: "bar", c: "baz", e: "number4")
         expect(actual).to eq(%w[foo bar baz number4])
       end
     end
 
     context "with more than the allowed number of args" do
       it "runs" do
-        invoke3!("foo", "bar", "baz", "number4", "extra")
-        expect(actual).to be_a(::Simple::Service::ExtraArguments)
+        expect {
+          ::Simple::Service.invoke3(service, action, "foo", "bar", "baz", "number4", "extra")
+        }.to raise_error(::Simple::Service::ExtraArgumentError)
       end
     end
 
     context "with extra named args" do
       it "ignores extra args" do
-        invoke3!(a: "foo", b: "bar", c: "baz", extra3: 3)
-        expect(actual).to eq(["foo", "bar", "baz", 2.781])
+        expect {
+          ::Simple::Service.invoke3(service, action, a: "foo", b: "bar", c: "baz", extra3: 3)
+        }.to raise_error(::Simple::Service::ArgumentError)
       end
     end
   end
@@ -177,36 +175,39 @@ describe "Simple::Service.invoke3" do
 
     context "without args" do
       it "raises MissingArguments" do
-        invoke3!
-        expect(actual).to be_a(::Simple::Service::MissingArguments)
+        expect {
+          ::Simple::Service.invoke3(service, action)
+        }.to raise_error(::Simple::Service::MissingArgumentError)
       end
     end
 
     context "with the required number of args" do
       it "runs" do
-        invoke3!("foo")
+        actual = ::Simple::Service.invoke3(service, action, "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
-        invoke3!("foo", "bar", "baz", e: "number4")
+        actual = ::Simple::Service.invoke3(service, action, "foo", "bar", "baz", e: "number4")
         expect(actual).to eq(%w[foo bar baz number4])
       end
     end
 
     context "with more than the allowed number of args" do
-      it "runs" do
-        invoke3!("foo", "bar", "baz", "extra", e: "number4")
-        expect(actual).to be_a(::Simple::Service::ExtraArguments)
+      it "raises an ExtraArguments error" do
+        expect {
+          ::Simple::Service.invoke3(service, action, "foo", "bar", "baz", "extra", e: "number4")
+        }.to raise_error(::Simple::Service::ExtraArgumentError)
       end
     end
 
     context "with extra named args" do
-      it "ignores extra args" do
-        invoke3!("foo", "bar", "baz", e: "number4", extra3: 3)
-        expect(actual).to eq(["foo", "bar", "baz", "number4"])
+      it "raises an ExtraArguments error" do
+        expect {
+          ::Simple::Service.invoke3(service, action, "foo", "bar", "baz", e: "number4", extra3: 3)
+        }.to raise_error(::Simple::Service::ExtraArgumentError)
       end
     end
   end
@@ -222,36 +223,38 @@ describe "Simple::Service.invoke3" do
 
     context "without args" do
       it "raises MissingArguments" do
-        invoke3!
-        expect(actual).to be_a(::Simple::Service::MissingArguments)
+        expect {
+          ::Simple::Service.invoke3(service, action)
+        }.to raise_error(::Simple::Service::MissingArgumentError)
       end
     end
 
     context "with the required number of args" do
       it "runs" do
-        invoke3!("foo")
+        actual = ::Simple::Service.invoke3(service, action, "foo")
         expect(actual).to eq(["foo", "queen bee", [], 2.781])
       end
     end
 
     context "with the allowed number of args" do
       it "runs" do
-        invoke3!("foo", "bar", "baz", e: "number4")
+        actual = ::Simple::Service.invoke3(service, action, "foo", "bar", "baz", e: "number4")
         expect(actual).to eq(["foo", "bar", ["baz"], "number4"])
       end
     end
 
     context "with more than the allowed number of args" do
       it "runs" do
-        invoke3!("foo", "bar", "baz", "extra", e: "number4")
+        actual = ::Simple::Service.invoke3(service, action, "foo", "bar", "baz", "extra", e: "number4")
         expect(actual).to eq(["foo", "bar", ["baz", "extra"], "number4"])
       end
     end
 
     context "with extra named args" do
-      it "ignores extra args" do
-        invoke3!("foo", "bar", "baz", e: "number4", extra3: 3)
-        expect(actual).to eq(["foo", "bar", ["baz"], "number4"])
+      it "raises an ExtraArguments error" do
+        expect {
+          ::Simple::Service.invoke3(service, action, "foo", "bar", "baz", e: "number4", extra3: 3)
+        }.to raise_error(::Simple::Service::ExtraArgumentError)
       end
     end
   end

data/spec/simple/service/action_invoke_spec.rb

@@ -5,16 +5,6 @@ describe "Simple::Service.invoke" do
   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
     #
@@ -26,22 +16,23 @@ describe "Simple::Service.invoke" do
 
     context "calling without args" do
       it "runs the action" do
-        invoke!
+        actual = ::Simple::Service.invoke(service, action, args: {}, flags: {})
         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" })
+        actual = ::Simple::Service.invoke(service, action, args: { "foo" => "foo", "bar" => "bar" }, flags: {})
         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")
+      it "raises an error" do
+        expect {
+          ::Simple::Service.invoke(service, action, args: {}, flags: { "foo" => "foo", "bar" => "bar" })
+        }.to raise_error(::Simple::Service::UnknownFlagError)
       end
     end
   end
@@ -57,36 +48,36 @@ describe "Simple::Service.invoke" do
 
     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/)
+        expect {
+          ::Simple::Service.invoke(service, action, args: {}, flags: {})
+        }.to raise_exception(::Simple::Service::MissingArgumentError, /\ba, b\b/)
       end
     end
 
     context "with the required number of args" do
       it "runs" do
-        invoke!(args: { "a" => "foo", "b" => "bar" })
+        actual = ::Simple::Service.invoke(service, action, args: { "a" => "foo", "b" => "bar" }, flags: {})
         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" })
+      it "merges flags and args to provide variadic arguments" do
+        actual = ::Simple::Service.invoke(service, action, 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" })
+        actual = ::Simple::Service.invoke(service, action, args: { "a" => "foo", "b" => "bar", "c" => "baz", "e" => "number4" }, flags: {})
         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 })
+        actual = ::Simple::Service.invoke(service, action, args: { "a" => "foo", "b" => "bar", "c" => "baz", "e" => "number4", "extra3" => 3 }, flags: {})
         expect(actual).to eq(%w[foo bar baz number4])
       end
     end
@@ -103,29 +94,29 @@ describe "Simple::Service.invoke" do
 
     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/)
+        expect {
+          ::Simple::Service.invoke(service, action, args: {}, flags: {})
+        }.to raise_error(::Simple::Service::MissingArgumentError, /\ba, b\b/)
       end
     end
 
     context "with the required number of args" do
       it "runs" do
-        invoke!(args: { "a" => "foo", "b" => "bar" })
+        actual = ::Simple::Service.invoke(service, action, args: { "a" => "foo", "b" => "bar" }, flags: {})
         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" })
+        actual = ::Simple::Service.invoke(service, action, args: { "a" => "foo", "b" => "bar", "c" => "baz", "e" => "number4" }, flags: {})
         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 })
+        actual = ::Simple::Service.invoke(service, action, args: { "a" => "foo", "b" => "bar", "c" => "baz", "extra3" => 3 }, flags: {})
         expect(actual).to eq(["foo", "bar", "baz", 2.781])
       end
     end
@@ -142,28 +133,29 @@ describe "Simple::Service.invoke" do
 
     context "without args" do
       it "raises MissingArguments" do
-        invoke!
-        expect(actual).to be_a(::Simple::Service::MissingArguments)
+        expect {
+          ::Simple::Service.invoke(service, action, args: {}, flags: {})
+        }.to raise_error(::Simple::Service::MissingArgumentError)
       end
     end
 
     context "with the required number of args" do
       it "runs" do
-        invoke!(args: { "a" => "foo" })
+        actual = ::Simple::Service.invoke(service, action, args: { "a" => "foo" }, flags: {})
         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" })
+        actual = ::Simple::Service.invoke(service, action, args: { "a" => "foo", "b" => "bar", "c" => "baz", "e" => "number4" }, flags: {})
         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 })
+        actual = ::Simple::Service.invoke(service, action, args: { "a" => "foo", "b" => "bar", "c" => "baz", "e" => "number4", "extra3" => 3 }, flags: {})
         expect(actual).to eq(["foo", "bar", "baz", "number4"])
       end
     end
@@ -180,33 +172,34 @@ describe "Simple::Service.invoke" do
 
     context "without args" do
       it "raises MissingArguments" do
-        invoke!
-        expect(actual).to be_a(::Simple::Service::MissingArguments)
+        expect {
+          ::Simple::Service.invoke(service, action, args: {}, flags: {})
+        }.to raise_error(::Simple::Service::MissingArgumentError)
       end
     end
 
     context "with the required number of args" do
       it "runs" do
-        invoke!(args: { "a" => "foo" })
+        actual = ::Simple::Service.invoke(service, action, args: { "a" => "foo" }, flags: {})
         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" })
+        actual = ::Simple::Service.invoke(service, action, 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 })
+        actual = ::Simple::Service.invoke(service, action, args: { "a" => "foo", "b" => "bar", "args" => ["baz", "extra"] }, flags: { "e" => "number4" })
         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 })
+        actual = ::Simple::Service.invoke(service, action, args: { "a" => "foo", "b" => "bar" }, flags: { "args" => ["baz", "extra"], "e" => "number4" })
         expect(actual).to eq(["foo", "bar", ["baz", "extra"], "number4"])
       end
     end
@@ -216,13 +209,13 @@ describe "Simple::Service.invoke" do
     it "raises ArgumentError" do
       hsh = { a: "foo", "b" => "KJH" }
 
-      expect do
-        invoke!(args: hsh)
-      end.to raise_error(Expectation::Matcher::Mismatch)
+      expect {
+        ::Simple::Service.invoke(service, action, args: hsh, flags: {})
+      }.to raise_error(Expectation::Matcher::Mismatch)
 
-      expect do
-        invoke!(flags: hsh)
-      end.to raise_error(Expectation::Matcher::Mismatch)
+      expect {
+        ::Simple::Service.invoke(service, action, args: {}, flags: hsh)
+      }.to raise_error(Expectation::Matcher::Mismatch)
     end
   end
 end

data/spec/simple/service/service_spec.rb

@@ -47,11 +47,11 @@ describe "Simple::Service" do
 
     describe "Simple::Service::NoSuchAction" do
       it "does not inherit from Simple::Service::ArgumentError" do
-        expect(Simple::Service::NoSuchAction < Simple::Service::ArgumentError).to be_falsey
+        expect(Simple::Service::NoSuchActionError < Simple::Service::ArgumentError).to be_falsey
       end
 
       it "inherits from ArgumentError" do
-        expect(Simple::Service::NoSuchAction < ::ArgumentError).to eq true
+        expect(Simple::Service::NoSuchActionError < ::ArgumentError).to eq true
       end
     end
 
@@ -59,55 +59,40 @@ describe "Simple::Service" 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.to raise_error(Simple::Service::NoSuchActionError, /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
-
     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" })
 
-      invoke3
+      Simple::Service.invoke3(service, :service1, "my_a", "my_b", d: "my_d")
     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
-
       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
 
-        invoke
+        Simple::Service.invoke(service, :service1, args: ["my_a", "my_b"], flags: { "d" => "my_d" })
       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"]
 
-      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)
+      expect(Simple::Service.invoke(SpecTestService, :foo, args: ["bar-value"], flags: { "baz" => "baz-value" })).to eq(expected)
+      expect(Simple::Service.invoke(SpecTestService, :foo, args: { "bar" => "bar-value", "baz" => "baz-value" })).to eq(expected)
+
+      expect(Simple::Service.invoke3(SpecTestService, :foo, "bar-value", baz: "baz-value")).to eq(expected)
+      expect(Simple::Service.invoke3(SpecTestService, :foo, bar: "bar-value", baz: "baz-value")).to eq(expected)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simple-service
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - radiospiel
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-13 00:00:00.000000000 Z
+date: 2022-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: expectation
@@ -50,6 +50,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/rspec.yaml"
 - ".gitignore"
 - ".rubocop.yml"
 - ".tm_properties"
@@ -130,13 +131,13 @@ files:
 homepage: http://github.com/radiospiel/simple-service
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "~>"
+  - - ">="
     - !ruby/object:Gem::Version
       version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
@@ -145,8 +146,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: Pretty simple and somewhat abstract service description
 test_files: