gauge-ruby 0.0.4.1

data/lib/datastore.rb

@@ -0,0 +1,84 @@
+# Copyright 2015 ThoughtWorks, Inc.
+
+# This file is part of Gauge-Ruby.
+
+# Gauge-Ruby is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Gauge-Ruby is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Gauge-Ruby.  If not, see <http://www.gnu.org/licenses/>.
+
+module Gauge
+  # @api public
+  class DataStore
+
+    # @api private
+    def initialize
+      clear
+    end
+
+    # Fetches the object corresponding to the given key
+    # @param key [string], the key for retrieving object.
+    # @return [object]
+    def get(key)
+      @data_map[key]
+    end
+
+    # Stores the object against the given key
+    # @param key [string], the key for storing the object, has to be unique
+    # @param value [object], the object to be persisted
+    def put(key, value)
+      @data_map[key] = value
+    end
+
+    # @api private
+    def clear
+      @data_map = Hash.new
+    end
+  end
+
+
+  # @api public
+  class DataStoreFactory
+    # Gets a datastore, that lives throughout the suite execution
+    # @example
+    #   DataStoreFactory.suite_datastore.put("foo", {:name=>"foo"})
+    #   DataStoreFactory.suite_datastore.get("foo")
+    #   => {:name=>"foo"}
+    def self.suite_datastore
+      return @@suite_datastore
+    end
+
+    # Gets a datastore, that lives throughout a specification execution
+    # This is purged after every specification execution.
+    # @example
+    #   DataStoreFactory.scenario_datastore.put("foo", {:name=>"foo"})
+    #   DataStoreFactory.scenario_datastore.get("foo")
+    #   => {:name=>"foo"}
+    def self.spec_datastore
+      return @@spec_datastore
+    end
+
+    # Gets a datastore, that lives throughout a scenario execution
+    # This is purged after every scenario execution.
+    # @example
+    #   DataStoreFactory.scenario_datastore.put("foo", {:name=>"foo"})
+    #   DataStoreFactory.scenario_datastore.get("foo")
+    #   => {:name=>"foo"}
+    def self.scenario_datastore
+      return @@scenario_datastore
+    end
+
+    private
+    @@suite_datastore = DataStore.new
+    @@spec_datastore = DataStore.new
+    @@scenario_datastore = DataStore.new
+  end
+end

data/lib/executor.rb

@@ -0,0 +1,47 @@
+# Copyright 2015 ThoughtWorks, Inc.
+
+# This file is part of Gauge-Ruby.
+
+# Gauge-Ruby is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Gauge-Ruby is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Gauge-Ruby.  If not, see <http://www.gnu.org/licenses/>.
+
+require_relative 'gauge'
+
+module Gauge
+  # @api private
+  module Executor
+    def self.load_steps(steps_implementation_dir)
+      Dir["#{steps_implementation_dir}/**/*.rb"].each { |x| require x }
+    end
+
+    def self.execute_step(step, args)
+      block = MethodCache.get_step step
+      if args.size == 1
+        block.call(args[0])
+      else
+        block.call(args)
+      end
+    end
+
+    def self.execute_hooks(hooks, currentExecutionInfo)
+      begin
+        hooks.each do |hook|
+          hook.call(currentExecutionInfo)
+        end
+        return nil
+      rescue Exception => e
+        return e
+      end
+    end
+  end
+end

data/lib/gauge.rb

@@ -0,0 +1,105 @@
+# Copyright 2015 ThoughtWorks, Inc.
+
+# This file is part of Gauge-Ruby.
+
+# Gauge-Ruby is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Gauge-Ruby is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Gauge-Ruby.  If not, see <http://www.gnu.org/licenses/>.
+
+require_relative 'connector'
+require_relative 'method_cache'
+require_relative 'configuration'
+
+# @api public
+module Kernel
+  class << self
+    private
+    # @!macro [attach] self.hook
+    #   @method $1(&block)
+    #   @api public
+    #   @param block [block], this block is called while executing the $1 hook
+    #   @example
+    #      $1 do
+    #         puts "I am the $1 hook"
+    #      end
+    def hook(hook)
+      define_method hook do |&block|
+        Gauge::MethodCache.send("add_#{hook}_hook".to_sym, &block)
+      end
+    end
+  end
+
+  # Specify implementation for a given step
+  #
+  #
+  # @example
+  #   step 'this is a simple step' do
+  #     puts 'hello there!'
+  #   end
+  # @example
+  #   # step with parameters
+  #   # * say "hello" to "gauge"
+  #   step 'say <what> to <who>' do |what, who|
+  #     puts "say #{what} to #{who}"
+  #   end
+  # @example
+  #   # step with aliases, two step texts can map to the same definition
+  #   # provided they have the same parameter signature
+  #   # * say "hello" to "gauge"
+  #   # * When you meet "gauge", say "hello"
+  #
+  #   step 'say <what> to <who>', 'When you meet <who>, say <what>' do |what, who|
+  #     puts "say #{what} to #{who}"
+  #   end
+  # @example
+  #   # step with table
+  #   # * Step that takes a table
+  #   #        |Product|       Description           |
+  #   #        |-------|-----------------------------|
+  #   #        |Gauge  |BDD style testing with ease  |
+  #   #        |Mingle |Agile project management     |
+  #   #        |Snap   |Hosted continuous integration|
+  #   #        |Gocd   |Continuous delivery platform |
+  #   
+  #   step 'Step that takes a table <table>' do |table|
+  #     # note the extra <table> that is added to the description
+  #       puts x.columns.join("|")
+  #       x.rows.each { |r| puts r.join("|") }
+  #   end
+  # @param step_texts [string, ...] the step text(s)
+  # @param block [block] the implementation block for given step.
+  def step(*step_texts, &block)
+    step_texts.each do |text|
+      parameterized_step_text = Gauge::Connector.step_value(text)
+      Gauge::MethodCache.add_step(parameterized_step_text, &block)
+      Gauge::MethodCache.add_step_text(parameterized_step_text, text)
+    end
+    Gauge::MethodCache.add_step_alias(*step_texts)
+  end
+
+  # Invoked before execution of every step.
+  hook "before_step"
+  # Invoked after execution of every step.
+  hook "after_step"
+  # Invoked before execution of every specification.
+  hook "before_spec"
+  # Invoked after execution of every specification.
+  hook "after_spec"
+  # Invoked before execution of every scenario.
+  hook "before_scenario"
+  # Invoked after execution of every scenario.
+  hook "after_scenario"
+  # Invoked before execution of the entire suite.
+  hook "before_suite"
+  # Invoked after execution of the entire suite.
+  hook "after_suite"
+end

data/lib/gauge_runtime.rb

@@ -0,0 +1,78 @@
+# Copyright 2015 ThoughtWorks, Inc.
+
+# This file is part of Gauge-Ruby.
+
+# Gauge-Ruby is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Gauge-Ruby is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Gauge-Ruby.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'socket'
+require 'protocol_buffers'
+
+require_relative 'messages.pb'
+require_relative 'executor'
+require_relative 'connector'
+require_relative 'message_processor'
+
+
+module Gauge
+  # @api private
+  module Runtime
+    DEFAULT_IMPLEMENTATIONS_DIR_PATH = File.join(Dir.pwd, 'step_implementations')
+
+    def self.dispatch_messages(socket)
+      while (!socket.eof?)
+        len = Connector.message_length(socket)
+        data = socket.read len
+        message = Messages::Message.parse(data)
+        handle_message(socket, message)
+        if (message.messageType == Messages::Message::MessageType::KillProcessRequest || message.messageType == Messages::Message::MessageType::ExecutionEnding)
+          socket.close
+          return
+        end
+      end
+    end
+
+
+    def self.handle_message(socket, message)
+      if (!MessageProcessor.is_valid_message(message))
+        puts "Invalid message received : #{message}"
+        execution_status_response = Messages::ExecutionStatusResponse.new(:executionResult => Messages::ProtoExecutionResult.new(:failed => true, :executionTime => 0))
+        message = Messages::Message.new(:messageType => Messages::Message::MessageType::ExecutionStatusResponse, :messageId => message.messageId, :executionStatusResponse => execution_status_response)
+        write_message(socket, message)
+      else
+        response = MessageProcessor.process_message message
+        write_message(socket, response)
+      end
+    end
+
+    def self.write_message(socket, message)
+      serialized_message = message.to_s
+      size = serialized_message.bytesize
+      ProtocolBuffers::Varint.encode(socket, size)
+      socket.write serialized_message
+    end
+
+    def self.portFromEnvVariable(envVariable)
+      port = ENV[envVariable]
+      if (port.nil?)
+        raise RuntimeError, "Could not find Env variable :#{envVariable}"
+      end
+      return port
+    end
+
+    STDOUT.sync = true
+    Connector.make_connections()
+    Executor.load_steps(DEFAULT_IMPLEMENTATIONS_DIR_PATH)
+    dispatch_messages(Connector.executionSocket)
+  end
+end

data/lib/message_processor.rb

@@ -0,0 +1,55 @@
+# Copyright 2015 ThoughtWorks, Inc.
+
+# This file is part of Gauge-Ruby.
+
+# Gauge-Ruby is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Gauge-Ruby is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Gauge-Ruby.  If not, see <http://www.gnu.org/licenses/>.
+
+require_relative 'messages.pb'
+require_relative 'executor'
+require_relative 'table'
+Dir[File.join(File.dirname(__FILE__), 'processors/*.rb')].each {|file| require file }
+
+module Gauge
+  # @api private
+  class MessageProcessor
+    extend Processors
+
+    @processors = Hash.new
+    @processors[Messages::Message::MessageType::StepValidateRequest] = method(:process_step_validation_request)
+    @processors[Messages::Message::MessageType::ExecutionStarting] = method(:process_execution_start_request)
+    @processors[Messages::Message::MessageType::ExecutionEnding] = method(:process_execution_end_request)
+    @processors[Messages::Message::MessageType::SpecExecutionStarting] = method(:process_spec_execution_start_request)
+    @processors[Messages::Message::MessageType::SpecExecutionEnding] = method(:process_spec_execution_end_request)
+    @processors[Messages::Message::MessageType::ScenarioExecutionStarting] = method(:process_scenario_execution_start_request)
+    @processors[Messages::Message::MessageType::ScenarioExecutionEnding] = method(:process_scenario_execution_end_request)
+    @processors[Messages::Message::MessageType::StepExecutionStarting] = method(:process_step_execution_start_request)
+    @processors[Messages::Message::MessageType::StepExecutionEnding] = method(:process_step_execution_end_request)
+    @processors[Messages::Message::MessageType::ExecuteStep] = method(:process_execute_step_request)
+    @processors[Messages::Message::MessageType::StepNamesRequest] = method(:process_step_names_request)
+    @processors[Messages::Message::MessageType::KillProcessRequest] = method(:process_kill_processor_request)
+    @processors[Messages::Message::MessageType::SuiteDataStoreInit] = method(:process_datastore_init)
+    @processors[Messages::Message::MessageType::SpecDataStoreInit] = method(:process_datastore_init)
+    @processors[Messages::Message::MessageType::ScenarioDataStoreInit] = method(:process_datastore_init)
+    @processors[Messages::Message::MessageType::StepNameRequest] = method(:process_step_name_request)
+    @processors[Messages::Message::MessageType::RefactorRequest] = method(:refactor_step)
+
+    def self.is_valid_message(message)
+      return @processors.has_key? message.messageType
+    end
+
+    def self.process_message(message)
+      @processors[message.messageType].call message
+    end
+  end
+end

data/lib/messages.pb.rb

@@ -0,0 +1,308 @@
+#!/usr/bin/env ruby
+
+# Copyright 2015 ThoughtWorks, Inc.
+
+# This file is part of Gauge-Ruby.
+
+# Gauge-Ruby is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Gauge-Ruby is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Gauge-Ruby.  If not, see <http://www.gnu.org/licenses/>.
+
+# Generated by the protocol buffer compiler. DO NOT EDIT!
+
+require 'protocol_buffers'
+
+begin; require 'spec.pb'; rescue LoadError; end
+
+module Gauge
+  # @api private
+  module Messages
+    # forward declarations
+    class KillProcessRequest < ::ProtocolBuffers::Message; end
+    class ExecutionStatusResponse < ::ProtocolBuffers::Message; end
+    class ExecutionStartingRequest < ::ProtocolBuffers::Message; end
+    class SpecExecutionStartingRequest < ::ProtocolBuffers::Message; end
+    class SpecExecutionEndingRequest < ::ProtocolBuffers::Message; end
+    class ScenarioExecutionStartingRequest < ::ProtocolBuffers::Message; end
+    class ScenarioExecutionEndingRequest < ::ProtocolBuffers::Message; end
+    class StepExecutionStartingRequest < ::ProtocolBuffers::Message; end
+    class StepExecutionEndingRequest < ::ProtocolBuffers::Message; end
+    class ExecutionInfo < ::ProtocolBuffers::Message; end
+    class SpecInfo < ::ProtocolBuffers::Message; end
+    class ScenarioInfo < ::ProtocolBuffers::Message; end
+    class StepInfo < ::ProtocolBuffers::Message; end
+    class ExecuteStepRequest < ::ProtocolBuffers::Message; end
+    class StepValidateRequest < ::ProtocolBuffers::Message; end
+    class StepValidateResponse < ::ProtocolBuffers::Message; end
+    class ExecutionEndingRequest < ::ProtocolBuffers::Message; end
+    class SuiteExecutionResult < ::ProtocolBuffers::Message; end
+    class StepNamesRequest < ::ProtocolBuffers::Message; end
+    class StepNamesResponse < ::ProtocolBuffers::Message; end
+    class ScenarioDataStoreInitRequest < ::ProtocolBuffers::Message; end
+    class SpecDataStoreInitRequest < ::ProtocolBuffers::Message; end
+    class SuiteDataStoreInitRequest < ::ProtocolBuffers::Message; end
+    class ParameterPosition < ::ProtocolBuffers::Message; end
+    class RefactorRequest < ::ProtocolBuffers::Message; end
+    class RefactorResponse < ::ProtocolBuffers::Message; end
+    class StepNameRequest < ::ProtocolBuffers::Message; end
+    class StepNameResponse < ::ProtocolBuffers::Message; end
+    class Message < ::ProtocolBuffers::Message; end
+
+    class KillProcessRequest < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.KillProcessRequest"
+
+    end
+
+    class ExecutionStatusResponse < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.ExecutionStatusResponse"
+
+      required ::Gauge::Messages::ProtoExecutionResult, :executionResult, 1
+    end
+
+    class ExecutionStartingRequest < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.ExecutionStartingRequest"
+
+      optional ::Gauge::Messages::ExecutionInfo, :currentExecutionInfo, 1
+    end
+
+    class SpecExecutionStartingRequest < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.SpecExecutionStartingRequest"
+
+      optional ::Gauge::Messages::ExecutionInfo, :currentExecutionInfo, 1
+    end
+
+    class SpecExecutionEndingRequest < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.SpecExecutionEndingRequest"
+
+      optional ::Gauge::Messages::ExecutionInfo, :currentExecutionInfo, 1
+    end
+
+    class ScenarioExecutionStartingRequest < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.ScenarioExecutionStartingRequest"
+
+      optional ::Gauge::Messages::ExecutionInfo, :currentExecutionInfo, 1
+    end
+
+    class ScenarioExecutionEndingRequest < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.ScenarioExecutionEndingRequest"
+
+      optional ::Gauge::Messages::ExecutionInfo, :currentExecutionInfo, 1
+    end
+
+    class StepExecutionStartingRequest < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.StepExecutionStartingRequest"
+
+      optional ::Gauge::Messages::ExecutionInfo, :currentExecutionInfo, 1
+    end
+
+    class StepExecutionEndingRequest < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.StepExecutionEndingRequest"
+
+      optional ::Gauge::Messages::ExecutionInfo, :currentExecutionInfo, 1
+    end
+
+    class ExecutionInfo < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.ExecutionInfo"
+
+      optional ::Gauge::Messages::SpecInfo, :currentSpec, 1
+      optional ::Gauge::Messages::ScenarioInfo, :currentScenario, 2
+      optional ::Gauge::Messages::StepInfo, :currentStep, 3
+      optional :string, :stacktrace, 4
+    end
+
+    class SpecInfo < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.SpecInfo"
+
+      required :string, :name, 1
+      required :string, :fileName, 2
+      required :bool, :isFailed, 3
+      repeated :string, :tags, 4
+    end
+
+    class ScenarioInfo < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.ScenarioInfo"
+
+      required :string, :name, 1
+      required :bool, :isFailed, 2
+      repeated :string, :tags, 3
+    end
+
+    class StepInfo < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.StepInfo"
+
+      required ::Gauge::Messages::ExecuteStepRequest, :step, 1
+      required :bool, :isFailed, 2
+    end
+
+    class ExecuteStepRequest < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.ExecuteStepRequest"
+
+      required :string, :actualStepText, 1
+      required :string, :parsedStepText, 2
+      optional :bool, :scenarioFailing, 3
+      repeated ::Gauge::Messages::Parameter, :parameters, 4
+    end
+
+    class StepValidateRequest < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.StepValidateRequest"
+
+      required :string, :stepText, 1
+      required :int32, :numberOfParameters, 2
+    end
+
+    class StepValidateResponse < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.StepValidateResponse"
+
+      required :bool, :isValid, 1
+      optional :string, :errorMessage, 2
+    end
+
+    class ExecutionEndingRequest < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.ExecutionEndingRequest"
+
+      optional ::Gauge::Messages::ExecutionInfo, :currentExecutionInfo, 1
+    end
+
+    class SuiteExecutionResult < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.SuiteExecutionResult"
+
+      required ::Gauge::Messages::ProtoSuiteResult, :suiteResult, 1
+    end
+
+    class StepNamesRequest < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.StepNamesRequest"
+
+    end
+
+    class StepNamesResponse < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.StepNamesResponse"
+
+      repeated :string, :steps, 1
+    end
+
+    class ScenarioDataStoreInitRequest < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.ScenarioDataStoreInitRequest"
+
+    end
+
+    class SpecDataStoreInitRequest < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.SpecDataStoreInitRequest"
+
+    end
+
+    class SuiteDataStoreInitRequest < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.SuiteDataStoreInitRequest"
+
+    end
+
+    class ParameterPosition < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.ParameterPosition"
+
+      required :int32, :oldPosition, 1
+      required :int32, :newPosition, 2
+    end
+
+    class RefactorRequest < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.RefactorRequest"
+
+      required ::Gauge::Messages::ProtoStepValue, :oldStepValue, 1
+      required ::Gauge::Messages::ProtoStepValue, :newStepValue, 2
+      repeated ::Gauge::Messages::ParameterPosition, :paramPositions, 3
+    end
+
+    class RefactorResponse < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.RefactorResponse"
+
+      required :bool, :success, 1
+      optional :string, :error, 2
+      repeated :string, :filesChanged, 3
+    end
+
+    class StepNameRequest < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.StepNameRequest"
+
+      required :string, :stepValue, 1
+    end
+
+    class StepNameResponse < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.StepNameResponse"
+
+      required :bool, :isStepPresent, 1
+      repeated :string, :stepName, 2
+      required :bool, :hasAlias, 3
+    end
+
+    class Message < ::ProtocolBuffers::Message
+      # forward declarations
+
+      # enums
+      module MessageType
+        include ::ProtocolBuffers::Enum
+
+        set_fully_qualified_name "gauge.messages.Message.MessageType"
+
+        ExecutionStarting = 0
+        SpecExecutionStarting = 1
+        SpecExecutionEnding = 2
+        ScenarioExecutionStarting = 3
+        ScenarioExecutionEnding = 4
+        StepExecutionStarting = 5
+        StepExecutionEnding = 6
+        ExecuteStep = 7
+        ExecutionEnding = 8
+        StepValidateRequest = 9
+        StepValidateResponse = 10
+        ExecutionStatusResponse = 11
+        StepNamesRequest = 12
+        StepNamesResponse = 13
+        KillProcessRequest = 14
+        SuiteExecutionResult = 15
+        ScenarioDataStoreInit = 16
+        SpecDataStoreInit = 17
+        SuiteDataStoreInit = 18
+        StepNameRequest = 19
+        StepNameResponse = 20
+        RefactorRequest = 21
+        RefactorResponse = 22
+      end
+
+      set_fully_qualified_name "gauge.messages.Message"
+
+      required ::Gauge::Messages::Message::MessageType, :messageType, 1
+      required :int64, :messageId, 2
+      optional ::Gauge::Messages::ExecutionStartingRequest, :executionStartingRequest, 3
+      optional ::Gauge::Messages::SpecExecutionStartingRequest, :specExecutionStartingRequest, 4
+      optional ::Gauge::Messages::SpecExecutionEndingRequest, :specExecutionEndingRequest, 5
+      optional ::Gauge::Messages::ScenarioExecutionStartingRequest, :scenarioExecutionStartingRequest, 6
+      optional ::Gauge::Messages::ScenarioExecutionEndingRequest, :scenarioExecutionEndingRequest, 7
+      optional ::Gauge::Messages::StepExecutionStartingRequest, :stepExecutionStartingRequest, 8
+      optional ::Gauge::Messages::StepExecutionEndingRequest, :stepExecutionEndingRequest, 9
+      optional ::Gauge::Messages::ExecuteStepRequest, :executeStepRequest, 10
+      optional ::Gauge::Messages::ExecutionEndingRequest, :executionEndingRequest, 11
+      optional ::Gauge::Messages::StepValidateRequest, :stepValidateRequest, 12
+      optional ::Gauge::Messages::StepValidateResponse, :stepValidateResponse, 13
+      optional ::Gauge::Messages::ExecutionStatusResponse, :executionStatusResponse, 14
+      optional ::Gauge::Messages::StepNamesRequest, :stepNamesRequest, 15
+      optional ::Gauge::Messages::StepNamesResponse, :stepNamesResponse, 16
+      optional ::Gauge::Messages::SuiteExecutionResult, :suiteExecutionResult, 17
+      optional ::Gauge::Messages::KillProcessRequest, :killProcessRequest, 18
+      optional ::Gauge::Messages::ScenarioDataStoreInitRequest, :scenarioDataStoreInitRequest, 19
+      optional ::Gauge::Messages::SpecDataStoreInitRequest, :specDataStoreInitRequest, 20
+      optional ::Gauge::Messages::SuiteDataStoreInitRequest, :suiteDataStoreInitRequest, 21
+      optional ::Gauge::Messages::StepNameRequest, :stepNameRequest, 22
+      optional ::Gauge::Messages::StepNameResponse, :stepNameResponse, 23
+      optional ::Gauge::Messages::RefactorRequest, :refactorRequest, 24
+      optional ::Gauge::Messages::RefactorResponse, :refactorResponse, 25
+    end
+
+  end
+end