service_operation 1.0.0

data/lib/service_operation/rack_mountable.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module ServiceOperation
+  # mount in Rails routes.rb with mount(ServiceName => '/path')
+  # @todo remove ActionDispatch dependency
+  class RackMountable
+    include ServiceOperation::Base
+
+    IS_RACK_REQUEST_REGEXP = /SERVER_NAME|rack\./.freeze
+
+    allow_remote!
+
+    params do
+      request optional: true
+    end
+
+    returns do
+      body Any(String, Hash)
+      headers Hash
+      status String
+    end
+
+    after do
+      context.body = context.body || context.message || context.error || ''
+      context.headers ||= {}
+      context.status = (context.status || 200).to_s
+    end
+
+    #
+    # Class Methods
+    #
+
+    class << self
+      alias base_call call
+
+      # Wrap the call method with a check to see if its a rack request
+      # If so merge in request.params and return a rack response
+      def call(*args)
+        if request = rack_request(*args)
+          rack_response base_call(request: request)
+        else
+          base_call(*args)
+        end
+      end
+
+      private
+
+      #
+      # Request
+      #
+
+      def rack_request(*args)
+        return unless args.first.is_a?(Hash) && args.first.keys.grep(IS_RACK_REQUEST_REGEXP).any?
+
+        ActionDispatch::Request.new(args.first)
+      end
+
+      #
+      # Response
+      #
+
+      def rack_response(context)
+        [context.status, context.headers, rack_body(context)]
+      end
+
+      def rack_body(context)
+        body = context.body
+        body = contextbody.to_json if body.is_a?(Hash)
+        body = [body] unless body.is_a?(Array)
+        body
+      end
+    end
+  end
+end

data/lib/service_operation/service_notification.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module ServiceOperation
+  # Extensions to ServiceOperation::Base for sending notifications via the ServiceNotifications gem.
+  module ServiceNotification
+    VALID_SERVICE_NOTIFICATION_STATUSES = [:created, :ok].freeze
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    # ClassMethods
+    module ClassMethods
+      # in a Class Method to avoid using allow_any_instance_of in tests
+      def service_notifications_post(payload)
+        uri = URI payload.delete(:url)
+
+        request = Net::HTTP::Post.new(uri)
+        request.body = payload.to_json
+
+        response = http(uri).request(request)
+
+        # status, body
+        [
+          Rack::Utils::SYMBOL_TO_STATUS_CODE.invert[response.code],
+          JSON.parse(response.body, symbolize_names: true)
+        ]
+      end
+
+      private
+
+      def http(uri)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        http
+      end
+    end
+
+    #
+    # Instances
+    #
+
+    # modify to suit in sub class
+    def call
+      context.response ||= notify
+    end
+
+    private
+
+    # @return [Hash] response from ServiceNotifications
+    def notify(options = nil)
+      options ||= payload
+      options = service_notifications_defaults.merge(options)
+
+      status, body = self.class.service_notifications_post options
+
+      unless VALID_SERVICE_NOTIFICATION_STATUSES.include?(status)
+        context.service_notifications_response = body
+        fail!(status)
+      end
+
+      body
+    end
+
+    # A standard ServiceNotification payload for {#notify} to use
+    # @abstract
+    # @return [Hash]
+    def payload
+      raise 'define in subclass'
+    end
+
+    def service_notifications_defaults
+      {
+        url: service_notifications_url,
+        api_key: service_notifications_api_key,
+        instant: true, notification: 'inline'
+      }
+    end
+
+    # define in sub class or pass in payload
+    # @abstract
+    # @return [String]
+    def service_notifications_api_key
+      raise 'define in subclass'
+    end
+
+    def service_notifications_url
+      ENV['SERVICE_NOTIFICATIONS_URL']
+    end
+  end
+end

data/lib/service_operation/spec/spec_helper.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'simplecov'
+SimpleCov.start
+
+require 'service_operation/spec/support/action_contexts'
+require 'service_operation/spec/support/operation_contexts'
+
+# Stub ServiceNotifications
+module StubServiceNotifications
+  # @example
+  #   stub_service_notifications(YourOperation, email: user.email)
+  # @example
+  #   stub_service_notifications(objects: a_hash_including(plain: a_string_matching(/Welcome/)))
+  def stub_service_notifications(*args)
+    options, klass = args.reverse
+    klass ||= described_class
+
+    stubber = allow(klass).to receive(:service_notifications_post)
+    stubber = stubber.with stub_service_notifications_options(options) if options
+    stubber.and_return [:created, { test: true }]
+  end
+
+  private
+
+  def stub_service_notifications_options(options)
+    recipient = options.delete(:recipient) ||
+                { email: options.delete(:email), uid: options.delete(:uid) }.compact
+
+    options[:recipients] ||= [a_hash_including(recipient)] if recipient[:email]
+
+    options = {
+      url: ENV['SERVICE_NOTIFICATIONS_URL'], api_key: a_string_matching(/^(.*){32}$/)
+    }.merge options
+
+    a_hash_including options
+  end
+end
+
+RSpec.configure do |config|
+  config.include StubServiceNotifications
+  config.include_context 'action', type: :action
+  config.include_context 'operation', type: :operation
+end

data/lib/service_operation/spec/support/action_contexts.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+shared_context 'action', type: :action do
+  let(:input) { {} }
+  let(:context) { described_class.call(input) }
+  let(:contexts) { [] }
+  let(:errors) { context.errors || [] }
+
+  private
+
+  def call_action
+    contexts << described_class.call(input)
+    contexts.last
+  end
+
+  def call_action!
+    context = call_action
+    expect_success(context)
+    context
+  end
+
+  def last_context
+    contexts.last || call_service
+  end
+
+  def expect_action_to
+    expect { context }.to yield
+  end
+
+  def expect_success(obj = context)
+    expect(obj.error).to eq(nil)
+    expect(obj.errors).to eq({}) if obj.errors
+    expect(obj).to be_success
+  end
+
+  def expect_failure(obj = context)
+    raise 'failed without error' if obj.failure? && obj.error.nil? && obj.errors.blank?
+    expect(obj).not_to be_success
+  end
+
+  # expect_error('blah')
+  # expect_error(/blah/)
+  # expect_error(/blah/).not_to eq('blah')
+  # expect_error.to include("blah")
+  def expect_error(error = nil)
+    expect_failure
+
+    expectation = expect(context.error)
+
+    if error
+      expectation.to eq(error)
+    else
+      expectation
+    end
+  end
+end

data/lib/service_operation/spec/support/operation_contexts.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+shared_context 'operation', type: :operation do
+  let(:input) { {} }
+  let(:output) { described_class.call(input) }
+  let(:outputs) { [] }
+  let(:errors) { output.errors || [] }
+
+  private
+
+  def call_operation
+    outputs << described_class.call(input)
+    outputs.last
+  end
+
+  def call_operation!
+    output = call_operation
+    expect_success(output)
+    output
+  end
+
+  def last_operation
+    operations.last || call_operation
+  end
+
+  def expect_operation_to
+    expect { output }.to yield
+  end
+
+  def expect_success(obj = output)
+    expect(obj.error).to eq(nil)
+    expect(obj.errors).to eq({}) if obj.errors
+    expect(obj).to be_success
+  end
+
+  def expect_failure(obj = output)
+    raise 'failed without error' if obj.failure? && obj.error.nil? && obj.errors.blank?
+    expect(obj).not_to be_success
+  end
+
+  # expect_error('blah')
+  # expect_error(/blah/)
+  # expect_error(/blah/).not_to eq('blah')
+  # expect_error.to include("blah")
+  def expect_error(error = nil)
+    expect_failure
+
+    expectation = expect(output.error)
+
+    if error
+      expectation.to eq(error)
+    else
+      expectation
+    end
+  end
+end

data/lib/service_operation/validations.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ServiceOperation
+  # Validations
+  module Validations
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+      end
+    end
+
+    # Class Methods
+    module ClassMethods
+    end
+
+    def require_at_least_one_of(*args)
+      # mothballed:
+      # @option args.last [Boolean] :context whether to check context directly rather than send()
+      #                                      use if you want to prevent an auto generated value.
+      # options = args.last.is_a?(Hash) ? args.pop : {}
+      # base = options[:context] ? context : self
+
+      base = self
+      return if args.any? { |k| base.send(k) }
+
+      errors.add(:base, "One of #{args.map(&:to_s).join(', ')} required.")
+    end
+  end
+end

data/lib/service_operation/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ServiceOperation
+  VERSION = '1.0.0'
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: service_operation
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Zach Powell
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-09-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.7.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.7.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+description: 
+email: zach@babelian.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/service_operation.rb
+- lib/service_operation/base.rb
+- lib/service_operation/context.rb
+- lib/service_operation/delay.rb
+- lib/service_operation/error_handling.rb
+- lib/service_operation/errors.rb
+- lib/service_operation/failure.rb
+- lib/service_operation/hooks.rb
+- lib/service_operation/params.rb
+- lib/service_operation/params/attribute.rb
+- lib/service_operation/params/dsl.rb
+- lib/service_operation/params/types.rb
+- lib/service_operation/rack_mountable.rb
+- lib/service_operation/service_notification.rb
+- lib/service_operation/spec/spec_helper.rb
+- lib/service_operation/spec/support/action_contexts.rb
+- lib/service_operation/spec/support/operation_contexts.rb
+- lib/service_operation/validations.rb
+- lib/service_operation/version.rb
+homepage: https://github.com/babelian/service_operation
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.1
+signing_key: 
+specification_version: 4
+summary: Service Operations based on Interactor, Interactor Contracts, and ValueSemantics
+test_files: []