aws-flow 1.3.0 → 2.0.0

data/spec/aws/decider/unit/workflow_client_spec.rb

@@ -0,0 +1,83 @@
+require_relative 'setup'
+
+
+describe WorkflowClient do
+
+  class TestWorkflow
+    extend AWS::Flow::Workflows
+
+    workflow :start
+    def start
+      return "This is the entry point"
+    end
+  end
+  before(:each) do
+    workflow_type_object = double("workflow_type", :name => "TestWorkflow.start", :start_execution => "" )
+    @client = WorkflowClient.new(FakeServiceClient.new, FakeDomain.new(workflow_type_object), TestWorkflow, StartWorkflowOptions.new)
+  end
+  it "makes sure that configure works correctly" do
+    @client.reconfigure(:start) {{ :task_list => "This nonsense" }}
+    @client.start
+  end
+
+  context "#start_workflow" do
+
+    before(:all) do
+      class WorkflowClientTestWorkflow
+        extend AWS::Flow::Workflows
+        workflow :workflow_a, :workflow_b do
+          {
+            version: "1.0",
+            default_execution_start_to_close_timeout: 600,
+            default_task_list: "tasklist_a"
+          }
+        end
+        workflow :workflow_c do
+          {
+            version: "1.0",
+            default_execution_start_to_close_timeout: 300,
+            default_task_list: "tasklist_c"
+          }
+        end
+      end
+    end
+
+    context "multiple workflow definitions in a single workflow class" do
+
+      it "ensures we can have multiple workflows in one class - by calling the first workflow" do
+        type = FakeWorkflowType.new("domain", "WorkflowClientTestWorkflow.workflow_a", "1.0")
+        domain = FakeDomain.new(type)
+        swf = AWS::SimpleWorkflow.new
+        client = AWS::Flow::workflow_client(swf.client, domain) { { from_class: "WorkflowClientTestWorkflow" } }
+        expect_any_instance_of(AWS::SimpleWorkflow::Client::V20120125).to receive(:start_workflow_execution).twice { |options| options[:workflow_type][:name].should == "WorkflowClientTestWorkflow.workflow_a"; { run_id: "run_id" } }
+        client.start_execution
+        client.workflow_a
+      end
+
+      it "ensures we can have multiple workflows in one class - by calling the second workflow" do
+        type = FakeWorkflowType.new("domain", "WorkflowClientTestWorkflow.workflow_c", "1.0")
+        domain = FakeDomain.new(type)
+        swf = AWS::SimpleWorkflow.new
+        client = AWS::Flow::workflow_client(swf.client, domain) { { from_class: "WorkflowClientTestWorkflow" } }
+        expect_any_instance_of(AWS::SimpleWorkflow::Client::V20120125).to receive(:start_workflow_execution) { |options| options[:workflow_type][:name].should == "WorkflowClientTestWorkflow.workflow_c"; { run_id: "run_id" } }
+        client.workflow_c
+      end
+
+      it "ensures we can define multiple workflows with same options" do
+     
+        type = FakeWorkflowType.new("domain", "WorkflowClientTestWorkflow.workflow_a", "1.0")
+        domain = FakeDomain.new(type)
+        swf = AWS::SimpleWorkflow.new
+        client = AWS::Flow::workflow_client(swf.client, domain) { { from_class: "WorkflowClientTestWorkflow" } }
+        expect_any_instance_of(AWS::SimpleWorkflow::Client::V20120125).to receive(:start_workflow_execution) { |options| options[:workflow_type][:name].should == "WorkflowClientTestWorkflow.workflow_a"; { run_id: "run_id" } }
+        expect_any_instance_of(AWS::SimpleWorkflow::Client::V20120125).to receive(:start_workflow_execution) { |options| options[:workflow_type][:name].should == "WorkflowClientTestWorkflow.workflow_b"; { run_id: "run_id" } }
+        client.workflow_a
+        client.workflow_b
+      end
+
+    end
+
+  end
+end
+
+

data/spec/aws/{unit → flow}/begin_rescue_ensure_spec.rb

@@ -13,6 +13,7 @@
 # permissions and limitations under the License.
 ##
 
+require_relative 'factories'
 
 def change_test(options = {})
   subject { this_bre }

data/spec/aws/{integration → runner/integration}/runner_integration_spec.rb

@@ -1,51 +1,22 @@
-require 'runner'
-require 'bundler/setup'
-require 'aws/decider'
+require 'spec_helper'
 require 'logger'
 require 'socket'
+include Test::Integ
 
 describe "Runner" do
-
-  # Copied from the utilities for the samples and recipes
-  module SharedUtils
-
-    def setup_domain(domain_name)
-      swf = AWS::SimpleWorkflow.new
-      domain = swf.domains[domain_name]
-      unless domain.exists?
-        swf.domains.create(domain_name, 10)
-      end
-      domain
-    end
-
-    def build_workflow_worker(domain, klass, task_list)
-      AWS::Flow::WorkflowWorker.new(domain.client, domain, task_list, klass)
-    end
-
-    def build_generic_activity_worker(domain, task_list)
-      AWS::Flow::ActivityWorker.new(domain.client, domain, task_list)
-    end
-
-    def build_activity_worker(domain, klass, task_list)
-      AWS::Flow::ActivityWorker.new(domain.client, domain, task_list, klass)
-    end
-
-    def build_workflow_client(domain, options_hash)
-      AWS::Flow::workflow_client(domain.client, domain) { options_hash }
-    end
+  before(:all) do
+    @swf, @domain = setup_swf
   end
 
   class PingUtils
-    include SharedUtils
 
     WF_VERSION = "1.0"
     ACTIVITY_VERSION = "1.0"
     WF_TASKLIST = "workflow_tasklist"
     ACTIVITY_TASKLIST = "activity_tasklist"
-    DOMAIN = "PingTest"
 
     def initialize
-      @domain = setup_domain(DOMAIN)
+      @domain = Test::Integ::get_test_domain
     end
 
     def activity_worker
@@ -91,8 +62,8 @@ describe "Runner" do
     workflow :ping do
       {
         version: PingUtils::WF_VERSION,
-        task_list: PingUtils::WF_TASKLIST,
-        execution_start_to_close_timeout: 30,
+        default_task_list: PingUtils::WF_TASKLIST,
+        default_execution_start_to_close_timeout: 600,
       }
     end
 
@@ -136,10 +107,14 @@ describe "Runner" do
     it "runs" do
 
       runner_config = JSON.parse('{
+        "domain":
+          {
+            "name": ' + "\"#{get_test_domain.name}\"" + ',
+            "retention_in_days": 10
+          },
         "workflow_paths": [],
         "workflow_workers": [
           {
-            "domain": ' + "\"#{PingUtils::DOMAIN}\"" + ',
             "task_list": ' + "\"#{PingUtils::WF_TASKLIST}\"" + ',
             "workflow_classes": [ ' + "\"PingWorkflow\""  + ' ],
             "number_of_workers": 1
@@ -148,7 +123,6 @@ describe "Runner" do
         "activity_paths": [],
         "activity_workers": [
           {
-            "domain": ' + "\"#{PingUtils::DOMAIN}\"" + ',
             "task_list": ' + "\"#{PingUtils::ACTIVITY_TASKLIST}\"" + ',
             "activity_classes": [ ' + "\"PingActivity\""  + ' ],
             "number_of_forks_per_worker": 1,
@@ -162,16 +136,15 @@ describe "Runner" do
 
       workers = AWS::Flow::Runner.start_workers("", runner_config)
 
+      sleep 2
       utils  = PingUtils.new
       wf_client = utils.workflow_client
       
       workflow_execution = wf_client.ping()
 
-      sleep 3 until [
-                     "WorkflowExecutionCompleted",
-                     "WorkflowExecutionTimedOut",
-                     "WorkflowExecutionFailed"
-                    ].include? workflow_execution.events.to_a.last.event_type
+      wait_for_execution(workflow_execution, 3)
+
+      workflow_execution.events.map(&:event_type).last.should == "WorkflowExecutionCompleted"
 
       # kill the workers
       workers.each { |w| Process.kill("KILL", w) }

data/spec/aws/{unit → runner/unit}/runner_unit_spec.rb

@@ -1,8 +1,7 @@
-require 'runner'
+require 'spec_helper'
 require 'tempfile'
 require 'socket'
 require 'fileutils'
-require_relative '../../spec_helper.rb'
 
 describe "Runner" do
   
@@ -55,7 +54,6 @@ describe "Runner" do
         "activity_paths": [],
         "activity_workers": [
           {
-            "domain": "foo",
             "task_list": "bar",
             "activity_classes": [],
             "number_of_workers": 3
@@ -79,7 +77,6 @@ describe "Runner" do
         "activity_paths": [],
         "activity_workers": [
           {
-            "domain": "foo",
             "task_list": "bar",
             "number_of_workers": 3
           }
@@ -102,7 +99,6 @@ describe "Runner" do
         "workflow_paths": [],
         "workflow_workers": [
           {
-            "domain": "foo",
             "task_list": "bar",
             "workflow_classes": [],
             "number_of_workers": 3
@@ -126,7 +122,6 @@ describe "Runner" do
         "workflow_paths": [],
         "workflow_workers": [
           {
-            "domain": "foo",
             "task_list": "bar",
             "number_of_workers": 3
           }
@@ -153,7 +148,6 @@ describe "Runner" do
         "workflow_paths": [],
         "workflow_workers": [
           {
-            "domain": "foo",
             "task_list": "bar",
             "workflow_classes": [ "Object", "String" ],
             "number_of_workers": 3
@@ -168,7 +162,6 @@ describe "Runner" do
         "activity_paths": [],
         "activity_workers": [
           {
-            "domain": "foo",
             "task_list": "bar",
             "activity_classes": [ "Object", "String" ],
             "number_of_workers": 3
@@ -182,6 +175,8 @@ describe "Runner" do
       # mock out a few methods to focus on the fact that the workers were created
       allow_any_instance_of(AWS::Flow::WorkflowWorker).to receive(:add_implementation).and_return(nil)
       allow_any_instance_of(AWS::Flow::WorkflowWorker).to receive(:start).and_return(nil)
+
+      AWS::Flow::Runner.stub(:setup_domain)
       AWS::Flow::Runner.stub(:load_files)
 
       # what we are testing:
@@ -197,6 +192,7 @@ describe "Runner" do
       # mock out a few methods to focus on the fact that the workers were created
       allow_any_instance_of(AWS::Flow::ActivityWorker).to receive(:add_implementation).and_return(nil)
       allow_any_instance_of(AWS::Flow::ActivityWorker).to receive(:start).and_return(nil)
+      AWS::Flow::Runner.stub(:setup_domain)
       AWS::Flow::Runner.stub(:load_files)
 
       # what we are testing:
@@ -211,6 +207,7 @@ describe "Runner" do
       allow_any_instance_of(AWS::Flow::WorkflowWorker).to receive(:start).and_return(nil)
       AWS::Flow::Runner.stub(:fork)
       AWS::Flow::Runner.stub(:load_files)
+      AWS::Flow::Runner.stub(:setup_domain)
       
       # stub that we can query later
       implems = []
@@ -230,6 +227,7 @@ describe "Runner" do
       allow_any_instance_of(AWS::Flow::ActivityWorker).to receive(:start).and_return(nil)
       AWS::Flow::Runner.stub(:fork)
       AWS::Flow::Runner.stub(:load_files)
+      AWS::Flow::Runner.stub(:setup_domain)
       
       # stub that we can query later
       implems = []
@@ -249,6 +247,7 @@ describe "Runner" do
       allow_any_instance_of(AWS::Flow::WorkflowWorker).to receive(:add_implementation).and_return(nil)
       AWS::Flow::Runner.stub(:fork).and_yield
       AWS::Flow::Runner.stub(:load_files)
+      AWS::Flow::Runner.stub(:setup_domain)
       
       # stub that we can query later
       starts = 0
@@ -268,6 +267,7 @@ describe "Runner" do
       allow_any_instance_of(AWS::Flow::ActivityWorker).to receive(:add_implementation).and_return(nil)
       AWS::Flow::Runner.stub(:fork).and_yield
       AWS::Flow::Runner.stub(:load_files)
+      AWS::Flow::Runner.stub(:setup_domain)
       
       # stub that we can query later
       starts = 0
@@ -303,8 +303,8 @@ describe "Runner" do
       expect(AWS::Flow::Runner).to receive(:require).with(File.join(base, relative))
 
       AWS::Flow::Runner.load_files( File.join(base, "blahconfig"), "", 
-                                   {:config_key => "any_key_name",
-                                    :default_file => relative})
+                                   {config_key: "any_key_name",
+                                    default_file: relative})
     end
 
     it "loads the default only if needed" do
@@ -317,8 +317,8 @@ describe "Runner" do
 
       AWS::Flow::Runner.load_files( File.join(base, "blahconfig"), 
                                     JSON.parse('{ "activity_paths": [ "foo", "bar"] }'), 
-                                   {:config_key => "activity_paths",
-                                    :default_file => relative})
+                                   {config_key: "activity_paths",
+                                    default_file: relative})
     end
 
     it "loads the \"flow/activities.rb\" by default for activity worker" do
@@ -326,7 +326,6 @@ describe "Runner" do
         document = '{
         "activity_workers": [
           {
-            "domain": "foo",
             "task_list": "bar",
             "activity_classes": [ "Object", "String" ],
             "number_of_workers": 3
@@ -336,6 +335,7 @@ describe "Runner" do
         JSON.parse(document)
       end
 
+      AWS::Flow::Runner.stub(:setup_domain)
       expect(AWS::Flow::Runner).to receive(:require).with(File.join(".", "flow", "activities.rb"))
 
       AWS::Flow::Runner.start_activity_workers(AWS::SimpleWorkflow.new, ".", activity_js)
@@ -346,7 +346,6 @@ describe "Runner" do
         document = '{
         "workflow_workers": [
           {
-            "domain": "foo",
             "task_list": "bar",
             "workflow_classes": [ "Object", "String" ],
             "number_of_workers": 3
@@ -356,6 +355,7 @@ describe "Runner" do
         JSON.parse(document)
       end
 
+      AWS::Flow::Runner.stub(:setup_domain)
       expect(AWS::Flow::Runner).to receive(:require).with(File.join(".", "flow", "workflows.rb"))
 
       AWS::Flow::Runner.start_workflow_workers(AWS::SimpleWorkflow.new, ".", workflow_js)
@@ -367,7 +367,6 @@ describe "Runner" do
         "activity_paths": [ "foo", "bar"],
         "activity_workers": [
           {
-            "domain": "foo",
             "task_list": "bar",
             "activity_classes": [ "Object", "String" ],
             "number_of_workers": 3
@@ -377,6 +376,7 @@ describe "Runner" do
         JSON.parse(document)
       end
 
+      AWS::Flow::Runner.stub(:setup_domain)
       expect(AWS::Flow::Runner).to_not receive(:require).with(File.join(".", "flow", "activities.rb"))
       expect(AWS::Flow::Runner).to receive(:require).with(File.join("foo"))
       expect(AWS::Flow::Runner).to receive(:require).with(File.join("bar"))
@@ -390,7 +390,6 @@ describe "Runner" do
         "workflow_paths": [ "foo", "bar"],
         "workflow_workers": [
           {
-            "domain": "foo",
             "task_list": "bar",
             "workflow_classes": [ "Object", "String" ],
             "number_of_workers": 3
@@ -400,6 +399,7 @@ describe "Runner" do
         JSON.parse(document)
       end
 
+      AWS::Flow::Runner.stub(:setup_domain)
       expect(AWS::Flow::Runner).to_not receive(:require).with(File.join(".", "flow", "workflows.rb"))
       expect(AWS::Flow::Runner).to receive(:require).with(File.join("foo"))
       expect(AWS::Flow::Runner).to receive(:require).with(File.join("bar"))
@@ -467,7 +467,6 @@ describe "Runner" do
         document = '{
         "activity_workers": [
           {
-            "domain": "foo",
             "task_list": "bar",
             "number_of_workers": 3
           }
@@ -476,6 +475,7 @@ describe "Runner" do
         JSON.parse(document)
       end
 
+      AWS::Flow::Runner.stub(:setup_domain)
       impls = []
       AWS::Flow::ActivityWorker.any_instance.stub(:add_implementation) do |impl|
         impls << impl
@@ -492,7 +492,6 @@ describe "Runner" do
         document = '{
         "workflow_workers": [
           {
-            "domain": "foo",
             "task_list": "bar",
             "number_of_workers": 3
           }
@@ -501,6 +500,7 @@ describe "Runner" do
         JSON.parse(document)
       end
 
+      AWS::Flow::Runner.stub(:setup_domain)
       impls = []
       AWS::Flow::WorkflowWorker.any_instance.stub(:add_implementation) do |impl|
         impls << impl

data/spec/spec_helper.rb

@@ -13,11 +13,12 @@
 # permissions and limitations under the License.
 ##
 
+require 'bundler/setup'
 require 'aws/flow'
 require 'aws/decider'
+require 'runner'
 
-include AWS::Flow::Core
-
+include AWS::Flow
 
 def constantize(camel_case_word)
   names = camel_case_word.split('::')
@@ -28,3 +29,264 @@ def constantize(camel_case_word)
   end
   constant
 end
+
+module Test
+  module Integ
+    def setup_domain(domain_name)
+      swf = AWS::SimpleWorkflow.new
+      domain = swf.domains[domain_name]
+      unless domain.exists?
+        swf.domains.create(domain_name, 10)
+      end
+      domain
+    end
+
+    def build_client(from_class)
+      domain = get_test_domain
+      build_workflow_client(domain, from_class)
+    end
+
+    def build_worker(klass, task_list)
+      domain = get_test_domain
+      return build_workflow_worker(domain, klass, task_list) if klass.is_a? AWS::Flow::Workflows
+      return build_activity_worker(domain, klass, task_list) if klass.is_a? AWS::Flow::Activities
+      raise "the class needs to extend AWS::Flow::Workflows or AWS::Flow::Activities"
+    end
+
+    def build_workflow_worker(domain, klass, task_list)
+      AWS::Flow::WorkflowWorker.new(domain.client, domain, task_list, klass)
+    end
+
+    def build_generic_activity_worker(domain, task_list)
+      AWS::Flow::ActivityWorker.new(domain.client, domain, task_list)
+    end
+
+    def build_activity_worker(domain, klass, task_list)
+      AWS::Flow::ActivityWorker.new(domain.client, domain, task_list, klass)
+    end
+
+    def build_workflow_client(domain, options_hash)
+      AWS::Flow::workflow_client(domain.client, domain) { options_hash }
+    end
+    def kill_executors
+      return if ForkingExecutor.executors.nil?
+      ForkingExecutor.executors.each do |executor|
+        executor.shutdown(0) unless executor.is_shutdown rescue StandardError
+      end
+      #TODO Reinstate this, but it's useful to keep them around for debugging
+      #ForkingExecutor.executors = []
+    end
+
+    def setup_swf
+      current_date = Time.now.strftime("%d-%m-%Y")
+      file_name = "/tmp/" + current_date
+      if File.exists?(file_name)
+        last_run = File.open(file_name, 'r').read.to_i
+      else
+        last_run = 0
+      end
+      last_run += 1
+      File.open(file_name, 'w+') {|f| f.write(last_run)}
+      current_date = Time.now.strftime("%d-%m-%Y")
+      swf = AWS::SimpleWorkflow.new
+      $rubyflow_decider_domain = "rubyflow_#{current_date}-#{last_run}"
+      begin
+        domain = swf.domains.create($rubyflow_decider_domain, "10")
+      rescue AWS::SimpleWorkflow::Errors::DomainAlreadyExistsFault => e
+        domain = swf.domains[$rubyflow_decider_domain]
+      end
+      @swf, @domain = swf, domain
+      return swf, domain
+    end
+
+    def get_test_domain
+      swf = AWS::SimpleWorkflow.new
+      domain = swf.domains[$rubyflow_decider_domain]
+      return domain
+    end
+
+    def wait_for_execution(execution, sleep_time=5)
+      sleep sleep_time until [
+        "WorkflowExecutionCompleted",
+        "WorkflowExecutionTimedOut",
+        "WorkflowExecutionFailed"
+      ].include? execution.events.to_a.last.event_type
+    end
+
+    def wait_for_decision(execution, decision="DecisionTaskScheduled")
+      sleep 1 until [
+        decision
+      ].flatten.include? execution.events.to_a.last.event_type
+    end
+
+    def validate_execution(execution, decision="WorkflowExecutionCompleted")
+      execution.events.map(&:event_type).last.should == decision
+    end
+    def validate_execution_failed(execution)
+      validate_execution(execution, "WorkflowExecutionFailed")
+    end
+  end
+
+  module Unit
+
+    class FakeConfig
+      def to_h
+
+      end
+    end
+    class FakeServiceClient
+      attr_accessor :trace
+
+      def respond_decision_task_completed(task_completed_request)
+        @trace ||= []
+        @trace << task_completed_request
+      end
+      def start_workflow_execution(options)
+        FakeWorkflowExecution.new(nil, options[:workflow_id])
+      end
+      def register_activity_type(options)
+      end
+      def register_workflow_type(options)
+      end
+      def respond_activity_task_completed(task_token, result)
+      end
+      def config
+        FakeConfig.new
+      end
+    end
+
+    class FakeAttribute
+      def initialize(data); @data = data; end
+      def method_missing(method_name, *args, &block)
+        if @data.keys.include? method_name
+          return @data[method_name]
+        end
+        super
+      end
+      def keys; @data.keys; end
+      def [](key); @data[key]; end
+      def to_h; @data; end
+      def []=(key, val); @data[key] = val; end
+    end
+    class TestHistoryEvent < AWS::SimpleWorkflow::HistoryEvent
+      def initialize(event_type, event_id, attributes)
+        @event_type = event_type
+        @attributes = attributes
+        @event_id = event_id
+        @created_at = Time.now
+      end
+    end
+
+    class FakeWorkflowType < WorkflowType
+      class << self
+        attr_accessor :types
+      end
+      attr_accessor :domain, :name, :version
+      def initialize(domain, name, version)
+        @domain = domain
+        @name = name
+        @version = version
+        FakeWorkflowType.types ||= {}
+        FakeWorkflowType.types["#{name}.#{version}"] = self
+      end
+    end
+
+    class TestHistoryWrapper
+      attr_accessor :workflow_execution, :workflow_type, :events
+      def initialize(workflow_type, workflow_execution, events)
+        @workflow_type = workflow_type
+        @workflow_execution = workflow_execution
+        @events = events
+      end
+      def task_token
+        "1"
+      end
+      def previous_started_event_id
+        1
+      end
+    end
+
+    class FakeEvents
+      def initialize(args)
+        @events = []
+        args.each_with_index do |event, index|
+          event, attr = event if event.is_a? Array
+          attr ||= {}
+          @events << TestHistoryEvent.new(event, index + 1, FakeAttribute.new(attr))
+        end
+        @events
+      end
+      def to_a
+        @events
+      end
+    end
+    class TrivialConverter
+      def dump(x)
+        x
+      end
+      def load(x)
+        x
+      end
+    end
+
+    class FakeLogger
+      attr_accessor :level
+      def info(s); end
+      def debug(s); end
+      def warn(s); end
+      def error(s); end
+    end
+
+    class FakePage
+      def initialize(object); @object = object; end
+      def page; @object; end
+    end
+
+    class FakeWorkflowExecution
+      class << self
+        attr_accessor :executions
+      end
+      def initialize(run_id, workflow_id)
+        @hash = {}
+        @run_id = run_id.nil? ? SecureRandom.uuid : run_id
+        @workflow_id = workflow_id.nil? ? SecureRandom.uuid : workflow_id
+        @hash = {"runId" => @run_id, "workflowId" => @workflow_id}
+        FakeWorkflowExecution.executions ||= {}
+        FakeWorkflowExecution.executions[[@run_id, @workflow_id]] = self
+      end
+      def self.at(workflow_id, run_id)
+        FakeWorkflowExecution.executions[[run_id, workflow_id]] unless FakeWorkflowExecution.executions.nil?
+      end
+      def [](option)
+        self.hash[option]
+      end
+      attr_accessor :run_id, :workflow_id, :task_list, :domain, :hash
+    end
+
+    class FakeDomain
+      def initialize(workflow_type_object = nil)
+        @workflow_type_object ||= []
+        @workflow_type_object << workflow_type_object unless workflow_type_object.nil?
+        @name = "fake_domain"
+      end
+      def register(workflow_type_object)
+        @workflow_type_object << workflow_type_object
+      end
+      def page; FakePage.new(@workflow_type_object); end
+      def workflow_executions; FakeWorkflowExecution; end
+      attr_accessor :name
+    end
+
+    class SynchronousWorkflowWorker < WorkflowWorker
+      def start
+        poller = SynchronousWorkflowTaskPoller.new(@service, nil, DecisionTaskHandler.new(@workflow_definition_map), @task_list)
+        poller.poll_and_process_single_task
+      end
+    end
+
+    class Hash
+      def to_h; self; end
+    end
+  end
+
+end