temporal-ruby 0.0.0 → 0.0.1.pre.pre1

data/lib/temporal/saga/result.rb

@@ -0,0 +1,22 @@
+module Temporal
+  module Saga
+    class Result
+      attr_reader :rollback_reason
+
+      def initialize(completed, rollback_reason = nil)
+        @completed = completed
+        @rollback_reason = rollback_reason
+
+        freeze
+      end
+
+      def completed?
+        @completed
+      end
+
+      def compensated?
+        !completed?
+      end
+    end
+  end
+end

data/lib/temporal/saga/saga.rb

@@ -0,0 +1,24 @@
+module Temporal
+  module Saga
+    class Saga
+      def initialize(context)
+        @context = context
+        @compensations = []
+      end
+
+      def add_compensation(activity, *args)
+        compensations << [activity, args]
+      end
+
+      def compensate
+        compensations.reverse_each do |(activity, args)|
+          context.execute_activity!(activity, *args)
+        end
+      end
+
+      private
+
+      attr_reader :context, :compensations
+    end
+  end
+end

data/lib/temporal/testing.rb

@@ -0,0 +1,50 @@
+require 'temporal/testing/temporal_override'
+require 'temporal/testing/workflow_override'
+
+module Temporal
+  module Testing
+    DISABLED_MODE = nil
+    LOCAL_MODE = :local
+
+    class << self
+      def local!(&block)
+        set_mode(LOCAL_MODE, &block)
+      end
+
+      def disabled!(&block)
+        set_mode(DISABLED_MODE, &block)
+      end
+
+      def disabled?
+        mode == DISABLED_MODE
+      end
+
+      def local?
+        mode == LOCAL_MODE
+      end
+
+      private
+
+      attr_reader :mode
+
+      def set_mode(new_mode, &block)
+        if block_given?
+          with_mode(new_mode, &block)
+        else
+          @mode = new_mode
+        end
+      end
+
+      def with_mode(new_mode, &block)
+        previous_mode = mode
+        @mode = new_mode
+        yield
+      ensure
+        @mode = previous_mode
+      end
+    end
+  end
+end
+
+Temporal.singleton_class.prepend Temporal::Testing::TemporalOverride
+Temporal::Workflow.extend Temporal::Testing::WorkflowOverride

data/lib/temporal/testing/future_registry.rb

@@ -0,0 +1,27 @@
+module Temporal
+  module Testing
+    class FutureRegistry
+      def initialize
+        @store = {}
+      end
+
+      def register(token, future)
+        raise 'already registered' if store.key?(token)
+
+        store[token] = future
+      end
+
+      def complete(token, result)
+        store[token].set(result)
+      end
+
+      def fail(token, error)
+        store[token].fail(error.class.name, error.message)
+      end
+
+      private
+
+      attr_reader :store
+    end
+  end
+end

data/lib/temporal/testing/local_activity_context.rb

@@ -0,0 +1,17 @@
+require 'securerandom'
+require 'temporal/uuid'
+require 'temporal/activity/context'
+
+module Temporal
+  module Testing
+    class LocalActivityContext < Activity::Context
+      def initialize(metadata)
+        super(nil, metadata)
+      end
+
+      def heartbeat(details = nil)
+        raise NotImplementedError, 'not yet available for testing'
+      end
+    end
+  end
+end

data/lib/temporal/testing/local_workflow_context.rb

@@ -0,0 +1,178 @@
+require 'securerandom'
+require 'temporal/testing/local_activity_context'
+require 'temporal/testing/workflow_execution'
+require 'temporal/execution_options'
+require 'temporal/metadata/activity'
+require 'temporal/workflow/future'
+require 'temporal/workflow/history/event_target'
+
+module Temporal
+  module Testing
+    class LocalWorkflowContext
+      attr_reader :headers
+
+      def initialize(execution, workflow_id, run_id, disabled_releases, headers = {})
+        @last_event_id = 0
+        @execution = execution
+        @run_id = run_id
+        @workflow_id = workflow_id
+        @disabled_releases = disabled_releases
+        @headers = headers
+      end
+
+      def logger
+        Temporal.logger
+      end
+
+      def has_release?(change_name)
+        !disabled_releases.include?(change_name.to_s)
+      end
+
+      def execute_activity(activity_class, *input, **args)
+        options = args.delete(:options) || {}
+        input << args unless args.empty?
+
+        event_id = next_event_id
+        activity_id = options[:activity_id] || event_id
+
+        target = Workflow::History::EventTarget.new(event_id, Workflow::History::EventTarget::ACTIVITY_TYPE)
+        future = Workflow::Future.new(target, self, cancelation_id: activity_id)
+
+        execution_options = ExecutionOptions.new(activity_class, options)
+        metadata = Metadata::Activity.new(
+          namespace: execution_options.namespace,
+          id: activity_id,
+          name: execution_options.name,
+          task_token: nil,
+          attempt: 1,
+          workflow_run_id: run_id,
+          workflow_id: workflow_id,
+          workflow_name: nil, # not yet used, but will be in the future
+          headers: execution_options.headers
+        )
+        context = LocalActivityContext.new(metadata)
+
+        result = activity_class.execute_in_context(context, input)
+
+        if context.async?
+          execution.register_future(context.async_token, future)
+        else
+          # Fulfil the future straigt away for non-async activities
+          future.set(result)
+        end
+
+        future
+      end
+
+      def execute_activity!(activity_class, *input, **args)
+        future = execute_activity(activity_class, *input, **args)
+        result = future.get
+
+        raise future.exception if future.failed?
+
+        result
+      end
+
+      def execute_local_activity(activity_class, *input, **args)
+        options = args.delete(:options) || {}
+        input << args unless args.empty?
+
+        execution_options = ExecutionOptions.new(activity_class, options)
+        activity_id = options[:activity_id] || SecureRandom.uuid
+        metadata = Metadata::Activity.new(
+          namespace: execution_options.namespace,
+          id: activity_id,
+          name: execution_options.name,
+          task_token: nil,
+          attempt: 1,
+          workflow_run_id: run_id,
+          workflow_id: workflow_id,
+          workflow_name: nil, # not yet used, but will be in the future
+          headers: execution_options.headers
+        )
+        context = LocalActivityContext.new(metadata)
+
+        activity_class.execute_in_context(context, input)
+      end
+
+      def execute_workflow(workflow_class, *input, **args)
+        raise NotImplementedError, 'not yet available for testing'
+      end
+
+      def execute_workflow!(workflow_class, *input, **args)
+        options = args.delete(:options) || {}
+        input << args unless args.empty?
+
+        execution = WorkflowExecution.new
+        workflow_id = SecureRandom.uuid
+        run_id = SecureRandom.uuid
+        execution_options = ExecutionOptions.new(workflow_class, options)
+        context = Temporal::Testing::LocalWorkflowContext.new(
+          execution, workflow_id, run_id, workflow_class.disabled_releases, execution_options.headers
+        )
+
+        workflow_class.execute_in_context(context, input)
+      end
+
+      def side_effect(&block)
+        block.call
+      end
+
+      def sleep(timeout)
+        ::Kernel.sleep timeout
+      end
+
+      def start_timer(timeout, timer_id = nil)
+        raise NotImplementedError, 'not yet available for testing'
+      end
+
+      def cancel_timer(timer_id)
+        raise NotImplementedError, 'not yet available for testing'
+      end
+
+      def complete(result = nil)
+        result
+      end
+
+      def fail(exception)
+        raise exception
+      end
+
+      def wait_for_all(*futures)
+        futures.each(&:wait)
+
+        return
+      end
+
+      def wait_for(future)
+        # Point of communication
+        Fiber.yield while !future.finished?
+      end
+
+      def now
+        Time.now
+      end
+
+      def on_signal(&block)
+        raise NotImplementedError, 'not yet available for testing'
+      end
+
+      def cancel_activity(activity_id)
+        raise NotImplementedError, 'not yet available for testing'
+      end
+
+      def cancel(target, cancelation_id)
+        raise NotImplementedError, 'not yet available for testing'
+      end
+
+      private
+
+      attr_reader :execution, :run_id, :workflow_id, :disabled_releases
+
+      def next_event_id
+        @last_event_id += 1
+        @last_event_id
+      end
+    end
+  end
+end

data/lib/temporal/testing/temporal_override.rb

@@ -0,0 +1,121 @@
+require 'securerandom'
+require 'temporal/activity/async_token'
+require 'temporal/workflow/execution_info'
+require 'temporal/testing/workflow_execution'
+require 'temporal/testing/local_workflow_context'
+
+module Temporal
+  module Testing
+    module TemporalOverride
+      def start_workflow(workflow, *input, **args)
+        return super if Temporal::Testing.disabled?
+
+        if Temporal::Testing.local?
+          start_locally(workflow, *input, **args)
+        end
+      end
+
+      def fetch_workflow_execution_info(_namespace, workflow_id, run_id)
+        return super if Temporal::Testing.disabled?
+
+        execution = executions[[workflow_id, run_id]]
+
+        Workflow::ExecutionInfo.new(
+          workflow: nil,
+          workflow_id: workflow_id,
+          run_id: run_id,
+          start_time: nil,
+          close_time: nil,
+          status: execution.status,
+          history_length: nil,
+        ).freeze
+      end
+
+      def complete_activity(async_token, result = nil)
+        return super if Temporal::Testing.disabled?
+
+        details = Activity::AsyncToken.decode(async_token)
+        execution = executions[[details.workflow_id, details.run_id]]
+
+        execution.complete_activity(async_token, result)
+      end
+
+      def fail_activity(async_token, exception)
+        return super if Temporal::Testing.disabled?
+
+        details = Activity::AsyncToken.decode(async_token)
+        execution = executions[[details.workflow_id, details.run_id]]
+
+        execution.fail_activity(async_token, exception)
+      end
+
+      private
+
+      def executions
+        @executions ||= {}
+      end
+
+      def start_locally(workflow, *input, **args)
+        options = args.delete(:options) || {}
+        input << args unless args.empty?
+
+        reuse_policy = options[:workflow_id_reuse_policy] || :allow_failed
+        workflow_id = options[:workflow_id] || SecureRandom.uuid
+        run_id = SecureRandom.uuid
+
+        if !allowed?(workflow_id, reuse_policy)
+          raise Temporal::WorkflowExecutionAlreadyStartedFailure.new(
+            "Workflow execution already started for id #{workflow_id}, reuse policy #{reuse_policy}",
+            previous_run_id(workflow_id)
+          )
+        end
+
+        execution = WorkflowExecution.new
+        executions[[workflow_id, run_id]] = execution
+
+        execution_options = ExecutionOptions.new(workflow, options)
+        headers = execution_options.headers
+        context = Temporal::Testing::LocalWorkflowContext.new(
+          execution, workflow_id, run_id, workflow.disabled_releases, headers
+        )
+
+        execution.run do
+          workflow.execute_in_context(context, input)
+        end
+
+        run_id
+      end
+
+      def allowed?(workflow_id, reuse_policy)
+        disallowed_statuses = disallowed_statuses_for(reuse_policy)
+
+        # there isn't a single execution in a dissallowed status
+        executions.none? do |(w_id, _), execution|
+          w_id == workflow_id && disallowed_statuses.include?(execution.status)
+        end
+      end
+
+      def previous_run_id(workflow_id)
+        executions.each do |(w_id, run_id), _|
+          return run_id if w_id == workflow_id
+        end
+        nil
+      end
+
+      def disallowed_statuses_for(reuse_policy)
+        case reuse_policy
+        when :allow_failed
+          [Workflow::ExecutionInfo::RUNNING_STATUS, Workflow::ExecutionInfo::COMPLETED_STATUS]
+        when :allow
+          [Workflow::ExecutionInfo::RUNNING_STATUS]
+        when :reject
+          [
+            Workflow::ExecutionInfo::RUNNING_STATUS,
+            Workflow::ExecutionInfo::FAILED_STATUS,
+            Workflow::ExecutionInfo::COMPLETED_STATUS
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/temporal/testing/workflow_execution.rb

@@ -0,0 +1,44 @@
+require 'temporal/testing/future_registry'
+
+module Temporal
+  module Testing
+    class WorkflowExecution
+      attr_reader :status
+
+      def initialize
+        @status = Workflow::ExecutionInfo::RUNNING_STATUS
+        @futures = FutureRegistry.new
+      end
+
+      def run(&block)
+        @fiber = Fiber.new(&block)
+        resume
+      end
+
+      def resume
+        fiber.resume
+        @status = Workflow::ExecutionInfo::COMPLETED_STATUS unless fiber.alive?
+      rescue StandardError
+        @status = Workflow::ExecutionInfo::FAILED_STATUS
+      end
+
+      def register_future(token, future)
+        futures.register(token, future)
+      end
+
+      def complete_activity(token, result)
+        futures.complete(token, result)
+        resume
+      end
+
+      def fail_activity(token, exception)
+        futures.fail(token, exception)
+        resume
+      end
+
+      private
+
+      attr_reader :fiber, :futures
+    end
+  end
+end