ruby-sfn-local 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1c56a390adcd8cefff1fa95e14db7b966e40058f81fe7d775edf31256d7eaf76
+  data.tar.gz: 7da9325fb01e571bf5769e6d890547c91f684742cd872d43decbd0b6bd798f1c
+SHA512:
+  metadata.gz: e88364b74f3ed18ba23d4aab7b1e7df243a56893693af3c30531ef04c9cbc0e6f91657eb59f291eeef6e131ed3b6e55a3720cf7ce9dedb68096cce2e26c1ec1b
+  data.tar.gz: 3091356de9b879a01978babcd45ca8939f4d3b8f4e28a84e9e1c5f7dc1df4d2c8662867cdebaf677553adbfeee8401824d5ee0ddb61ba00b99455aabbd0dbade

data/lib/sfn/aws_cli.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module Sfn
+  class AwsCli
+    class ExecutionError < StandardError; end
+
+    def self.run(mod, command, params, key = nil, debug_info = '')
+      cmd = "#{Sfn.configuration.aws_command || 'aws'} #{mod} #{command} \
+                      --endpoint #{Sfn.configuration.aws_endpoint} \
+                      #{params.map do |k, v|
+                        "--#{k}=#{v}"
+                      end.join(' ')} \
+                      --no-cli-pager"
+      
+      stdout, stderr, _status = Open3.capture3(cmd)
+      raise raise ExecutionError, "#{stderr.strip}\n#{debug_info}" unless stderr.strip.empty?
+      
+      stdout = `#{cmd}`
+      unless key.nil?
+        data = JSON.parse(stdout)
+        return data[key].strip if data.key?(key)
+      end
+
+      stdout
+    end
+  end
+end

data/lib/sfn/collection.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module Sfn
+  class Collection
+    include Singleton
+
+    attr_reader :all
+
+    def initialize
+      response = AwsCli.run('stepfunctions', 'list-state-machines', {})
+      parsed_response = JSON.parse(response)
+      @all = parsed_response['stateMachines'] || []
+    end
+
+    def add(state_machine)
+      @all.push(state_machine.slice('stateMachineArn', 'name'))
+    end
+
+    def delete_by_arn(state_machine_arn)
+      @all.delete_if { |sf| sf['stateMachineArn'] == state_machine_arn }
+    end
+  end
+end

data/lib/sfn/configuration.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+module Sfn
+  def self.configuration
+    @configuration ||= OpenStruct.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+end

data/lib/sfn/execution.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Sfn
+  class Execution
+    attr_accessor :uuid, :state_machine, :test_case, :arn, :output, :profile
+
+    def self.call(state_machine, test_case, mock_data, input)
+      new(state_machine, test_case).exec(mock_data, input)
+    end
+
+    def initialize(state_machine, test_case)
+      self.uuid = SecureRandom.uuid
+      self.state_machine = state_machine
+      self.test_case = test_case.camelize
+    end
+
+    def exec(mock_data, input)
+      MockData.write_context(state_machine.name, test_case, mock_data)
+      self.arn = AwsCli.run('stepfunctions', 'start-execution',
+                            { name: uuid,
+                              'state-machine': "#{state_machine.arn}##{test_case}",
+                              input: "'#{input.to_json}'" },
+                            'executionArn')
+      self.output, self.profile = ExecutionLog.parse(arn)
+      self
+    end
+  end
+end

data/lib/sfn/execution_log.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Sfn
+  class ExecutionError < RuntimeError
+    attr_accessor :code, :events
+
+    def initialize(msg, code, events)
+      self.code = code
+      self.events = JSON.parse(events)
+      super(msg)
+    end
+  end
+
+  class ExecutionLog
+    attr_accessor :event
+
+    EVENTS = %w[stateEnteredEventDetails stateExitedEventDetails executionSucceededEventDetails
+                executionFailedEventDetails].freeze
+    def self.parse(execution_arn)
+      profile = {}
+      output = nil
+      error = nil
+      events_json = AwsCli.run('stepfunctions', 'get-execution-history',
+                               { 'execution-arn': execution_arn.to_s, query: "'events[?#{EVENTS.join(' || ')}]'" })
+
+      JSON.parse(events_json).each do |event|
+        parsed_event = new(event)
+
+        output ||= parsed_event.output
+        error  ||= parsed_event.error(events_json)
+        state_name = parsed_event.state_name
+
+        next if state_name.nil?
+
+        profile[state_name] ||= { input: [], output: [] }
+        profile[state_name][:input] << parsed_event.profile[:input] unless parsed_event.profile[:input].nil?
+        profile[state_name][:output] << parsed_event.profile[:output] unless parsed_event.profile[:output].nil?
+      end
+      [output, profile]
+    end
+
+    def initialize(event)
+      self.event = event
+    end
+
+    def state_name
+      event.dig('stateEnteredEventDetails', 'name') || event.dig('stateExitedEventDetails', 'name')
+    end
+
+    def output
+      try_parse(event.dig('executionSucceededEventDetails', 'output'))
+    end
+
+    def error(events_json = '{}')
+      return if event['executionFailedEventDetails'].nil?
+
+      raise ExecutionError.new(event['executionFailedEventDetails']['cause'],
+                               event['executionFailedEventDetails']['error'],
+                               events_json)
+    end
+
+    def profile
+      {
+        input: try_parse(event.dig('stateEnteredEventDetails', 'input')),
+        output: try_parse(event.dig('stateExitedEventDetails', 'output'))
+      }.compact
+    end
+
+    private
+
+    def try_parse(json_string)
+      JSON.parse(json_string)
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/sfn/mock_data.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+require 'openssl'
+
+module Sfn
+  module MockData
+    def self.write_context(state_machine_name, context, mock_data = {})
+      data = {
+        'StateMachines' => {
+          state_machine_name.to_s => {
+            'TestCases' => {
+              context.to_s => { 'foo' => 'bar' }
+            }
+          }
+        },
+        'MockedResponses' => { 'bar' => {} }
+      }
+
+      mock_data.each do |step, response|
+        uuid = OpenSSL::Digest::SHA512.digest({ step: step }.merge(response).to_json).camelize
+        data['StateMachines'][state_machine_name.to_s]['TestCases'][context.to_s][step.to_s] = uuid
+        data['MockedResponses'][uuid] = response
+      end
+      File.write(Sfn.configuration.mock_file_path, JSON.pretty_generate(data))
+    end
+  end
+end

data/lib/sfn/mock_macros/api_gateway.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Sfn
+  module MockMacros
+    module ApiGateway
+      def self.response(data)
+        data = [data] if data.is_a?(Hash)
+        data.map! do |val|
+          if val.key?(:error)
+            { Throw: { Error: val[:error], Cause: val[:cause] } }
+          else
+            val[:response] ||= val[:payload]
+            val[:response] ||= val[:output]
+            { Return: { Headers: val[:headers], ResponseBody: val[:response], StatusCode: val[:status],
+                        StatusText: 'OK' } }
+          end
+        end
+        out = {}
+        data.each_with_index do |val, idx|
+          out[idx.to_s] = val
+        end
+        out
+      end
+    end
+  end
+end

data/lib/sfn/mock_macros/lambda.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Sfn
+  module MockMacros
+    module Lambda
+      def self.response(data)
+        data = [data] if data.is_a?(Hash)
+        data.map! do |val|
+          if val.key?(:error)
+            { Throw: { Error: val[:error], Cause: val[:cause] } }
+          else
+            val[:payload] ||= val[:response]
+            val[:payload] ||= val[:output]
+            { Return: { Payload: val[:payload], StatusCode: 200 } }
+          end
+        end
+        out = {}
+        data.each_with_index do |val, idx|
+          out[idx.to_s] = val
+        end
+        out
+      end
+    end
+  end
+end

data/lib/sfn/mock_macros/sns.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Sfn
+  module MockMacros
+    module Sns
+      def self.response(data)
+        data = [data] if data.is_a?(Hash)
+        data.map! do |val|
+          if val.key?(:error)
+            { Throw: { Error: val[:error], Cause: val[:cause] } }
+          else
+            val[:uuid] ||= SecureRandom.uuid
+            val[:sequence] ||= 10_000_000_000_000_003_000
+            { Return: { MessageId: val[:uuid], SequenceNumber: val[:sequence] } }
+          end
+        end
+        out = {}
+        data.each_with_index do |val, idx|
+          out[idx.to_s] = val
+        end
+        out
+      end
+    end
+  end
+end

data/lib/sfn/mock_macros/step_function.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Sfn
+  module MockMacros
+    module StepFunction
+      def self.response(data)
+        data = [data] if data.is_a?(Hash)
+        data.map! do |val|
+          if val.key?(:error)
+            { Throw: { Error: val[:error], Cause: val[:cause] } }
+          else
+            val[:output] ||= val[:payload]
+            val[:output] ||= val[:response]
+            { Return: { Output: val[:output].to_json, Status: 'SUCCEDED' } }
+          end
+        end
+        out = {}
+        data.each_with_index do |val, idx|
+          out[idx.to_s] = val
+        end
+        out
+      end
+    end
+  end
+end

data/lib/sfn/mock_macros.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'sfn/mock_macros/lambda'
+require 'sfn/mock_macros/step_function'
+require 'sfn/mock_macros/api_gateway'
+require 'sfn/mock_macros/sns'
+
+module Sfn
+  module MockMacros
+    include Lambda
+    include StepFunction
+    include ApiGateway
+    include Sns
+
+    def self.gateway_response(data)
+      ApiGateway.response(data)
+    end
+
+    def self.lambda_response(data)
+      Lambda.response(data)
+    end
+
+    def self.sns_response(data)
+      Sns.response(data)
+    end
+
+    def self.step_function_response(data)
+      StepFunction.response(data)
+    end
+
+    def self.gateway_payload(data)
+      warn '[DEPRECATION] `gateway_payload` is deprecated.  Please use `gateway_response` instead.'
+      ApiGateway.response(data)
+    end
+
+    def self.lambda_payload(data)
+      warn '[DEPRECATION] `lambda_payload` is deprecated.  Please use `lambda_response` instead.'
+      Lambda.response(data)
+    end
+
+    def self.sns_payload(data)
+      warn '[DEPRECATION] `sns_payload` is deprecated.  Please use `sns_response` instead.'
+      Sns.response(data)
+    end
+
+    def self.step_function_payload(data)
+      warn '[DEPRECATION] `step_function_payload` is deprecated.  Please use `step_function_response` instead.'
+      StepFunction.response(data)
+    end
+  end
+end

data/lib/sfn/state_machine.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+require 'openssl'
+
+module Sfn
+  class DefinitionError < RuntimeError; end
+
+  class StateMachine
+    ROLE = 'arn:aws:iam::123456789012:role/DummyRole'
+
+    attr_accessor :name, :definition, :arn, :executions, :execution_arn
+
+    def self.all
+      Collection.instance.all.map { |sf| new(sf['name'], sf['stateMachineArn']) }
+    end
+
+    def self.destroy_all
+      all.each(&:destroy)
+    end
+
+    def self.find_by_name(name)
+      all.find { |sf| sf.name == name }
+    end
+
+    def self.find_by_arn(arn)
+      all.find { |sf| sf.arn == arn }
+    end
+
+    def initialize(name, arn = nil)
+      self.name = name
+      self.arn = arn || self.class.find_by_name(name)&.arn || create_state_machine
+      self.executions = {}
+    end
+
+    def destroy
+      AwsCli.run('stepfunctions', 'delete-state-machine',
+                 { 'state-machine-arn': arn })
+      Collection.instance.delete_by_arn(arn)
+    end
+
+    def run(mock_data = {}, input = {}, test_name = nil)
+      test_name ||= OpenSSL::Digest::SHA512.digest(mock_data.merge(input).to_json)
+      executions[test_name] ||= Execution.call(self, test_name, mock_data, input)
+      executions[test_name]
+    end
+
+    def to_hash
+      { 'stateMachineArn' => arn, 'name' => name }
+    end
+
+    private
+
+    def create_state_machine
+      self.arn = AwsCli.run('stepfunctions', 'create-state-machine',
+                            { definition: load_definition(name), name: name, 'role-arn': ROLE }, 'stateMachineArn')
+      raise Sf::DefinitionError if arn.empty?
+
+      Collection.instance.add(to_hash)
+      arn
+    end
+
+    def load_definition(_name)
+      local_definition_path = Tempfile.new(['name', '.json']).path
+      remote_definition_path = "#{Sfn.configuration.definition_path}/#{name}.json"
+
+      definition = File.read(remote_definition_path)
+      local_definition = definition.gsub(/"MaxConcurrency": [0-9]+/, '"MaxConcurrency": 1')
+
+      File.open(local_definition_path, 'w') { |file| file.puts local_definition }
+      "file://#{local_definition_path}"
+    end
+  end
+end

data/lib/sfn.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'securerandom'
+require 'sfn/configuration'
+require 'sfn/aws_cli'
+require 'sfn/collection'
+require 'sfn/state_machine'
+require 'sfn/mock_data'
+require 'sfn/mock_macros'
+require 'sfn/execution'
+require 'sfn/execution_log'
+require 'string'

data/lib/string.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class String
+  def camelize
+    split(/[^a-z0-9]/i).collect(&:capitalize).join
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: ruby-sfn-local
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+platform: ruby
+authors:
+- Gianni Mazza
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-05-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-release
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.11'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.28'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.28'
+description: A convenient gem to test step function locally
+email: gianni.mazza81rg@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/sfn.rb
+- lib/sfn/aws_cli.rb
+- lib/sfn/collection.rb
+- lib/sfn/configuration.rb
+- lib/sfn/execution.rb
+- lib/sfn/execution_log.rb
+- lib/sfn/mock_data.rb
+- lib/sfn/mock_macros.rb
+- lib/sfn/mock_macros/api_gateway.rb
+- lib/sfn/mock_macros/lambda.rb
+- lib/sfn/mock_macros/sns.rb
+- lib/sfn/mock_macros/step_function.rb
+- lib/sfn/state_machine.rb
+- lib/string.rb
+homepage: https://github.com/redvex/ruby-sfn-local
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Step Functions local ruby wrapper!
+test_files: []