flipp-mockserver-client 0.1.0

data/lib/mockserver/mock_server_client.rb

@@ -0,0 +1,59 @@
+# encoding: UTF-8
+require_relative './model/expectation'
+require_relative './abstract_client'
+require_relative './utility_methods'
+
+#
+# The client used to interact with the mock server.
+# @author:: Nayyara Samuel (mailto: nayyara.samuel@opower.com)
+#
+module MockServer
+  EXPECTATION_ENDPOINT = '/expectation'
+
+  # The client used to interact with the mock server.
+  class MockServerClient < AbstractClient
+    include Model
+    include UtilityMethods
+
+    # Registers an expectation with the mockserver
+    # @param expectation [Expectation] the expectation to create the request from
+    # @return [Object] the response from the register action
+    def register(expectation)
+      fail 'Expectation passed in is not valid type' unless expectation.is_a?(Expectation)
+      request = create_expectation_request(expectation)
+
+      logger.debug('Registering new expectation')
+      logger.debug("URL: #{EXPECTATION_ENDPOINT} Payload: #{request.to_hash}")
+
+      response = @base[EXPECTATION_ENDPOINT].put(request.to_json, content_type: :json)
+      logger.debug("Got register response: #{response.code}")
+      parse_string_to_json(response)
+    end
+
+    def register_expectations(expectations)
+      request_array = []
+      expectations.each { |x|
+        fail 'Expectation passed in is not valid type' unless x.is_a?(Expectation)
+        request = create_expectation_request(x)
+        request_array << request
+      }
+      logger.debug('Registering new array of expectations')
+      response = @base[EXPECTATION_ENDPOINT].put(request_array.to_json, content_type: :json)
+      logger.debug("Got register response: #{response.code}")
+      parse_string_to_json(response)
+    end
+
+    private
+
+    # Create an expecation request to send to the expectation endpoint of
+    # @param expectation [Expectation] the expectation  to create the request from
+    # @return [Hash] a hash representing the request to use in registering an expectation with the mock server
+    # rubocop:disable Lint/LiteralInInterpolation
+    def create_expectation_request(expectation)
+      expectation_request = camelized_hash(expectation)
+      logger.debug("Expectation JSON: #{expectation_request.to_json}")
+      fail "You can only set either of #{[HTTP_RESPONSE, HTTP_FORWARD]}. But not both" if expectation_request[HTTP_RESPONSE] && expectation_request[HTTP_FORWARD]
+      expectation_request
+    end
+  end
+end

data/lib/mockserver/model/array_of.rb

@@ -0,0 +1,85 @@
+# encoding: UTF-8
+#
+# The ArrayOf class stores instances of a given class only.
+# It enforces this by intercepting the methods :<<, :[]= and :insert on the Array class
+# and casts objects to the allowed type first. To use in your code, create a subclass of ArrayOf and override the child_class() method to return
+# the class associated with the array.
+#
+# NOTE: You should use this class internally with the contract that you only call :<<. :[]= and :insert method
+# to manipulate the array in use. Can easily be changed to have stricter rules, suffices for internal use in this gem.
+#
+# @author:: Nayyara Samuel (mailto: nayyara.samuel@opower.com)
+#
+module MockServer::Model
+  DEFAULT_MISSING_INDEX = -1_000_000_000
+
+  # The ArrayOf class stores instances of a given class only.
+  class ArrayOf < Array
+    alias_method :add_element, :<<
+    alias_method :set_element, :[]=
+    alias_method :insert_element, :insert
+
+    # Create an array from the elements passed in
+    def initialize(items)
+      items.each do |item|
+        self << item
+      end
+    end
+
+    # The class/type that this array stores
+    def child_class
+      fail 'Subclass should override method :child_class'
+    end
+
+    # Add the item to the array
+    # @param item [Object] an item of the type/class supported by this array
+    # @raise [Exception] if the item cannot be converted to the allowed class
+    def <<(item)
+      add_element(convert_to_child_class(item))
+    end
+
+    # Set the given item at the index
+    # @param index [Integer] the index for the new element
+    # @param item [Object] an item of the type/class supported by this array
+    # @raise [Exception] if the item cannot be converted to the allowed class
+    def []=(index, item)
+      set_element(index, convert_to_child_class(item))
+    end
+
+    # Adds the given item at the index and shifts elements forward
+    # @param index [Integer] the index for the new element
+    # @param item [Object] an item of the type/class supported by this array
+    # @raise [Exception] if the item cannot be converted to the allowed class
+    def insert(index, item)
+      insert_element(index, convert_to_child_class(item))
+    end
+
+    # Method to set the element at the specified index.
+    # Will insert at index if there is another object at the index; otherwise will update.
+    # If the special DEFAULT_MISSING_INDEX value is given, will insert at the end.
+    # @param index [Integer] the index for the new element
+    # @param item [Object] an item of the type/class supported by this array
+    # @raise [Exception] if the item cannot be converted to the allowed class
+    def set(index, item)
+      if index == DEFAULT_MISSING_INDEX
+        self << item
+      elsif self[index]
+        insert(index, item)
+      else
+        self[index] = item
+      end
+    end
+
+    # Cast item to target class
+    def convert_to_child_class(item)
+      if item && item.class != child_class
+        begin
+          item = child_class.new(item)
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          raise "Failed to convert element: #{item} to required type #{child_class}. Error: #{e.message}"
+        end
+      end
+      item
+    end
+  end
+end

data/lib/mockserver/model/body.rb

@@ -0,0 +1,56 @@
+# encoding: UTF-8
+require 'hashie'
+require_relative './parameter'
+require_relative './enum'
+
+#
+# A model for a a body in a request object.
+# @author: Nayyara Samuel (mailto: nayyara.samuel@opower.com)
+#
+module MockServer::Model
+  # An enum for body type
+  class BodyType < SymbolizedEnum
+    def allowed_values
+      [:STRING, :REGEX, :XPATH, :PARAMETERS, :BINARY]
+    end
+  end
+
+  # A model for a a body in a request object.
+  class Body < Hashie::Dash
+    include Hashie::Extensions::MethodAccess
+    include Hashie::Extensions::IgnoreUndeclared
+    include Hashie::Extensions::Coercion
+
+    property :type, required: true
+    property :value
+    property :parameters
+
+    coerce_key :type, BodyType
+    coerce_key :value, String
+    coerce_key :parameters, Parameters
+  end
+
+  # DSL methods related to body
+  module DSL
+    # For response object where body can only be a string
+    def body(value)
+      value
+    end
+
+    def exact(value)
+      Body.new(type: :STRING, value: value)
+    end
+
+    def regex(value)
+      Body.new(type: :REGEX, value: value)
+    end
+
+    def xpath(value)
+      Body.new(type: :XPATH, value: value)
+    end
+
+    def parameterized(*parameters)
+      Body.new(type: :PARAMETERS, parameters: parameters)
+    end
+  end
+end

data/lib/mockserver/model/cookie.rb

@@ -0,0 +1,36 @@
+# encoding: UTF-8
+require 'hashie'
+require_relative './array_of'
+
+#
+# A class to model cookies in payloads.
+# @author:: Nayyara Samuel (mailto: nayyara.samuel@opower.com)
+#
+module MockServer::Model
+  # Model for cookie
+  class Cookie < Hashie::Dash
+    include Hashie::Extensions::MethodAccess
+    include Hashie::Extensions::IgnoreUndeclared
+    include Hashie::Extensions::Coercion
+
+    property :name, required: true
+    property :value, required: true
+
+    coerce_key :name, String
+    coerce_key :value, String
+  end
+
+  # A collection that only stores cookies
+  class Cookies < ArrayOf
+    def child_class
+      Cookie
+    end
+  end
+
+  # DSL methods for cookie
+  module DSL
+    def cookie(key, value)
+      Cookie.new(name: key, value: value)
+    end
+  end
+end

data/lib/mockserver/model/delay.rb

@@ -0,0 +1,34 @@
+# encoding: UTF-8
+require_relative './enum'
+
+#
+# A model for a delay in a response.
+# @author: Nayyara Samuel (mailto: nayyara.samuel@opower.com)
+#
+module MockServer::Model
+  # Enum for time unit
+  class TimeUnit < SymbolizedEnum
+    def allowed_values
+      [:NANOSECONDS, :MICROSECONDS, :MILLISECONDS, :SECONDS, :MINUTES, :HOURS, :DAYS]
+    end
+  end
+
+  # Model a delay object
+  class Delay < Hashie::Dash
+    include Hashie::Extensions::MethodAccess
+    include Hashie::Extensions::IgnoreUndeclared
+    include Hashie::Extensions::Coercion
+
+    property :time_unit, default: 'SECONDS'
+    property :value, required: true
+
+    coerce_key :time_unit, TimeUnit
+  end
+
+  # DSL methods related to delay model
+  module DSL
+    def delay_by(time_unit, value)
+      Delay.new(time_unit: time_unit, value: value)
+    end
+  end
+end

data/lib/mockserver/model/enum.rb

@@ -0,0 +1,47 @@
+# encoding: UTF-8
+#
+# A class to model a Java-like Enum.
+# To create an Enum extend this class and override :allowed_values method with allowed enum values.
+#
+# @author:: Nayyara Samuel (mailto: nayyara.samuel@opower.com)
+#
+module MockServer::Model
+  # Enum generic class
+  class Enum
+    # Create an instance of the enum from the value supplied
+    # @param supplied_value [Object] value used to create instance of an enum
+    # @raise [Exception] if the supplied value is not valid for this enum
+    def initialize(supplied_value)
+      supplied_value = pre_process_value(supplied_value)
+      fail "Supplied value: #{supplied_value} is not valid. Allowed values are: #{allowed_values.inspect}" unless allowed_values.include?(supplied_value)
+      @value = supplied_value
+    end
+
+    # @return [Array] a list of values allowed by this enum
+    def allowed_values
+      fail 'Override :allowed_values in Enum class'
+    end
+
+    # A pre-process hook for a value before it is stored
+    # @param value [Object] a value used to instantiate the enum
+    # @return [Object] the processed value. By default, a no-op implementation.
+    def pre_process_value(value)
+      value
+    end
+
+    # Override this for JSON representation
+    def to_s
+      @value.to_s
+    end
+  end
+
+  # Subclass of Enum that has a list of symbols as allowed values.
+  class SymbolizedEnum < Enum
+    # Pre-process the value passed in and convert to a symbol
+    # @param value [Object] a value used to instantiate the enum
+    # @return [Symbol] a symbolized version of the value passed in (first calls to_s)
+    def pre_process_value(value)
+      value.to_s.to_sym
+    end
+  end
+end

data/lib/mockserver/model/expectation.rb

@@ -0,0 +1,158 @@
+# encoding: UTF-8
+require_relative './array_of'
+require_relative './request'
+require_relative './response'
+require_relative './forward'
+require_relative './times'
+require_relative '../utility_methods'
+
+#
+# A class to model an expectation sent to the Mockserver instance.
+# See http://www.mock-server.com/#create-expectations for details.
+#
+# @author:: Nayyara Samuel (mailto: nayyara.samuel@opower.com)
+#
+module MockServer
+  HTTP_REQUEST  = 'httpRequest' unless const_defined?(:HTTP_REQUEST)
+  HTTP_RESPONSE = 'httpResponse' unless const_defined?(:HTTP_RESPONSE)
+  HTTP_FORWARD  = 'httpForward' unless const_defined?(:HTTP_FORWARD)
+  HTTP_TIMES    = 'times' unless const_defined?(:HTTP_TIMES)
+
+  # Models
+  module Model
+    # Expectation model
+    class Expectation
+      include MockServer::UtilityMethods
+      attr_accessor :times
+
+      # Creates an expectation from a hash
+      # @param payload [Hash] a hash representation of the expectation
+      def populate_from_payload(payload)
+        @request = payload[MockServer::HTTP_REQUEST]
+        @request = Request.new(symbolize_keys(@request)) if @request
+
+        @response = payload[MockServer::HTTP_RESPONSE]
+        @response = Response.new(symbolize_keys(@response)) if @response
+
+        @forward = payload[MockServer::HTTP_FORWARD]
+        @forward = Forward.new(symbolize_keys(@forward)) if @forward
+
+        @times = payload[MockServer::HTTP_TIMES]
+        @times = Times.new(symbolize_keys(@times)) if @times
+      end
+
+      # Method to setup the request on the expectation object
+      # @yieldparam [Request] the request that this expectation references
+      # @return [Expectation] this object according to the  the builder pattern
+      def request(&_)
+        if block_given?
+          @request ||= Request.new
+          yield @request
+        end
+        @request
+      end
+
+      # Method to setup the response on the expectation object
+      # @yieldparam [Response] the response that this expectation references
+      # @return [Expectation] this object according to the  the builder pattern
+      def response(&_)
+        if block_given?
+          @response ||= Response.new
+          yield @response
+        end
+        @response
+      end
+
+      # Method to setup the request on the expectation object
+      # @yieldparam [Forward] the forward object that this expectation references
+      # @return [Expectation] this object according to the  the builder pattern
+      def forward(&_)
+        if block_given?
+          @forward ||= Forward.new
+          yield @forward
+        end
+        @forward
+      end
+
+      # Setter for request
+      # @param request [Request] a request object
+      def request=(request)
+        @request = Request.new(request)
+      end
+
+      # Setter for response
+      # @param response [Response] a response object
+      def response=(response)
+        @response = Response.new(response)
+      end
+
+      # Setter for forward
+      # @param forward [Forward] a forward object
+      def forward=(forward)
+        @forward = Forward.new(forward)
+      end
+
+      # Override to_json method
+      # @return [String] the json representation for this object
+      def to_json(*p)
+        to_hash.to_json(*p)
+      end
+
+      # Convert to hash
+      # @return [Hash] the hash representation for this object
+      def to_hash
+        {
+          MockServer::HTTP_REQUEST  => @request,
+          MockServer::HTTP_RESPONSE => @response,
+          MockServer::HTTP_FORWARD  => @forward,
+          MockServer::HTTP_TIMES    => @times
+        }
+      end
+    end
+
+    # Class to store a list of mocks - useful for modeling retrieve endpoint result
+    class Expectations < ArrayOf
+      # Code is used to store HTTP status code returned from retrieve endpoint
+      attr_accessor :code
+
+      def child_class
+        Expectation
+      end
+    end
+
+    # DSL method for creating expectation
+    module DSL
+      def expectation(&_)
+        expectation = Expectation.new
+        yield expectation if block_given?
+        expectation
+      end
+
+      def expectation_from_json(payload)
+        expectation = Expectation.new
+        yield expectation if block_given?
+        expectation.populate_from_payload(payload)
+        expectation
+      end
+
+      def expectation_array_from_json(json_array)
+        expectation_array = []
+        json_array.each { |x|
+          e = expectation_from_json(x)
+          expectation_array << e
+        }
+        expectation_array
+      end
+
+      def add_header_to_expect_array(expectation_array, key, value)
+        expectations = []
+        expectation_array.each { |expectation|
+          expectation.request.headers << header(key, value)
+          expectations << expectation
+        }
+        expectations
+      end
+
+    end
+  end
+end