mockserver-client 1.0.8.pre → 5.3.0

data/.gitignore

@@ -1,21 +0,0 @@
-# Ruby #
-########
-*.gem
-*.rbc
-*.bundle
-*.so
-*.o
-*.a
-*.log
-.config
-.yardoc
-.rakeTasks
-Gemfile.lock
-InstalledFiles
-coverage
-*doc
-*tmp
-lib/bundler/man
-pkg
-spec/reports
-vendor/bundle

data/.rubocop.yml

@@ -1,7 +0,0 @@
-Style/LineLength:
-  Max: 180
-Style/ClassAndModuleChildren:
-  EnforcedStyle: compact
-Style/FileName:
-  Exclude:
-    - '**/mockserver-client.rb'

data/bin/mockserver

@@ -1,9 +0,0 @@
-# encoding: UTF-8
-#!/usr/bin/env ruby
-
-#
-# A thor-based runner for commands in this project
-# @author: Nayyara Samuel (mailto: nayyara.samuel@opower.com)
-#
-require_relative '../lib/cli'
-MockServerCLI.start

data/lib/cli.rb

@@ -1,146 +0,0 @@
-# encoding: UTF-8
-require 'thor'
-require 'colorize'
-require_relative './mockserver-client'
-
-# CLI for this gem
-# @author Nayyara Samuel(nayyara.samuel@opower.com)
-#
-module CLIHelpers
-  include MockServer
-
-  LOGGER = LoggingFactory::DEFAULT_FACTORY.log('MockServerClient')
-
-  # Prints out the parameters passed to it
-  # @param options [Hash] a hash of parameters
-  def print_parameters(options)
-    puts "\nRunning with parameters:".bold
-    options.each { |k, v| puts "\t#{k}: #{v}".yellow }
-    puts ''
-  end
-
-  # Create a mockserver client
-  # @param options [Struct] with host and port set
-  # @return [MockServerClient] the mockserver client with the host and port
-  def mockserver_client(options)
-    client        = MockServerClient.new(options.host, options.port)
-    client.logger = LOGGER
-    client
-  end
-
-  # Create a proxy client
-  # @param options [Struct] with host and port set
-  # @return [ProxyClient] the proxy client with the host and port
-  def proxy_client(options)
-    client        = ProxyClient.new(options.host, options.port)
-    client.logger = LOGGER
-    client
-  end
-
-  # Convert a hash to a struct
-  # @param hash [Hash] a hash
-  # @return [Struct] a struct constructed from the hash
-  def to_struct(hash)
-    hash = symbolize_keys(hash)
-    Struct.new(*hash.keys).new(*hash.values)
-  end
-
-  # Process a block using options extracted into a struct
-  # @param mockserver [Boolean] true to use mockserver, false to use proxy
-  # @yieldparam [AbstractClient] a mockserver or a proxy client
-  # @yieldparam [Struct] a struct created from options hash
-  def execute_command(mockserver = false, data_required = false, error_msg = '--data option must be provided', &_)
-    print_parameters(options)
-    struct_options = to_struct({ data: nil }.merge(options))
-    if data_required && !options['data']
-      error(error_msg)
-    else
-      client = mockserver ? mockserver_client(struct_options) : proxy_client(struct_options)
-      yield client, struct_options if block_given?
-    end
-  end
-
-  # Prints an error message
-  # @param message [String] an error message
-  def error(message)
-    puts message.red
-  end
-
-  # Read a file
-  # @param file [String] a file to read
-  def read_file(file)
-    YAML.load_file(file)
-  end
-end
-
-# CLI for mock server and proxy clients
-class MockServerCLI < Thor
-  include CLIHelpers
-  include MockServer::UtilityMethods
-  include MockServer::Model::DSL
-
-  class_option :host, type: :string, aliases: '-h', required: true, default: 'localhost', desc: 'The host for the MockServer client.'
-  class_option :port, type: :numeric, aliases: '-p', required: true, default: 8080, desc: 'The port for the MockServer client.'
-  class_option :data, type: :string, aliases: '-d', desc: 'A JSON or YAML file containing the request payload.'
-
-  desc 'retrieve', 'Retrieve the list of requests that have been made to the mock/proxy server.'
-
-  def retrieve
-    execute_command do |client, _|
-      result = options.data ? client.retrieve(read_file(options.data)) : client.retrieve
-      puts "RESULT:\n".bold + "#{result.to_json}".green
-    end
-  end
-
-  desc 'register', 'Register an expectation with the mock server.'
-
-  def register
-    execute_command(true, true) do |client, options|
-      payload          = read_file(options.data)
-      mock_expectation = expectation do |expectation|
-        expectation.populate_from_payload(payload)
-      end
-      client.register(mock_expectation)
-    end
-  end
-
-  desc 'dump_log', 'Dumps the matching request to the mock server logs.'
-  option :java, type: :boolean, aliases: '-j', default: false, desc: 'A switch to turn Java format for logs on/off.'
-
-  def dump_log
-    execute_command do |client, options|
-      options.data ? client.dump_log(read_file(options.data), options.java) : client.dump_log(nil, options.java)
-    end
-  end
-
-  desc 'clear', 'Clears all stored mock request/responses from server.'
-
-  def clear
-    error_message = 'ERROR: No request provided. HINT: Use `clear` to selectively clear requests. Use `reset` to clear all.'
-    execute_command(false, true, error_message) do |client, _|
-      payload = read_file(options.data)
-      client.clear(payload)
-    end
-  end
-
-  desc 'reset', 'Resets the server clearing all data.'
-
-  def reset
-    execute_command do |client, _|
-      client.reset
-    end
-  end
-
-  desc 'verify', 'Verify that a request has been made the specified number of times to the server.'
-
-  def verify
-    execute_command(false, true) do |client, _|
-      payload      = read_file(options.data)
-      mock_request = payload[HTTP_REQUEST]
-      mock_times   = payload[HTTP_TIMES]
-
-      error 'No request found for verifying against' unless mock_request
-      mock_times ? client.verify(mock_request, mock_times) : client.verify(mock_request)
-    end
-  end
-end

data/lib/mockserver/abstract_client.rb

@@ -1,111 +0,0 @@
-# encoding: UTF-8
-require 'rest-client'
-require 'logging_factory'
-require_relative './model/times'
-require_relative './model/request'
-require_relative './model/expectation'
-require_relative './utility_methods'
-
-# An abstract client for making requests supported by mock and proxy client.
-# @author Nayyara Samuel(mailto: nayyara.samuel@opower.com)
-#
-module MockServer
-  RESET_ENDPOINT    = '/reset'
-  CLEAR_ENDPOINT    = '/clear'
-  RETRIEVE_ENDPOINT = '/retrieve'
-  DUMP_LOG_ENDPOINT = '/dumpToLog'
-
-  # An abstract client for making requests supported by mock and proxy client.
-  class AbstractClient
-    include Model::DSL
-    include Model
-    include UtilityMethods
-
-    attr_accessor :logger
-
-    def initialize(host, port)
-      fail 'Cannot instantiate AbstractClient class. You must subclass it.' if self.class == AbstractClient
-      fail 'Host/port must not be nil' unless host && port
-      @base   = RestClient::Resource.new("http://#{host}:#{port}", headers: { 'Content-Type' => 'application/json' })
-      @logger = ::LoggingFactory::DEFAULT_FACTORY.log(self.class)
-    end
-
-    # Clear all expectations with the given request
-    # @param request [Request] the request to use to clear an expectation
-    # @return [Object] the response from the clear action
-    def clear(request)
-      request = camelized_hash(HTTP_REQUEST => Request.new(symbolize_keys(request)))
-
-      logger.debug("Clearing expectation with request: #{request}")
-      logger.debug("URL: #{CLEAR_ENDPOINT}. Payload: #{request.to_hash}")
-
-      response = @base[CLEAR_ENDPOINT].put(request.to_json, content_type: :json)
-      logger.debug("Got clear response: #{response.code}")
-      parse_string_to_json(response)
-    end
-
-    # Reset the mock server clearing all expectations previously registered
-    # @return [Object] the response from the reset action
-    def reset
-      request = {}
-
-      logger.debug('Resetting mockserver')
-      logger.debug("URL: #{RESET_ENDPOINT}. Payload: #{request.to_hash}")
-
-      response = @base[RESET_ENDPOINT].put(request.to_json)
-      logger.debug("Got reset response: #{response.code}")
-      parse_string_to_json(response)
-    end
-
-    # Retrieve the list of requests that have been processed by the server
-    # @param request [Request] to filter requests
-    # @return [Object] the list of responses processed by the server
-    def retrieve(request = nil)
-      request = request ? camelized_hash(HTTP_REQUEST => Request.new(symbolize_keys(request))) : {}
-
-      logger.debug('Retrieving request list from mockserver')
-      logger.debug("URL: #{RETRIEVE_ENDPOINT}. Payload: #{request.to_hash}")
-
-      response = @base[RETRIEVE_ENDPOINT].put(request.to_json)
-      logger.debug("Got retrieve response: #{response.code}")
-      requests = Requests.new([])
-      parse_string_to_json(response.body).map { |result| requests << request_from_json(result) } unless response.empty?
-      requests.code = response.code
-      requests
-    end
-
-    # Request to dump logs to file
-    # @param java [Boolean] true to dump as Java code; false to dump as JSON
-    # @return [Object] the list of responses processed by the server
-    def dump_log(request = nil, java = false)
-      type_params = java ? '?type=java' : ''
-      url         = "#{DUMP_LOG_ENDPOINT}#{type_params}"
-      request     = request ? Request.new(symbolize_keys(request)) : {}
-
-      logger.debug('Sending dump log request to mockserver')
-      logger.debug("URL: #{url}. Payload: #{request.to_hash}")
-
-      response = @base[url].put(request.to_json)
-      logger.debug("Got dump to log response: #{response.code}")
-      parse_string_to_json(response)
-    end
-
-    # Verify that the given request is called the number of times expected
-    # @param request [Request] to filter requests
-    # @param times [Times] expected number of times
-    # @return [Object] the list of responses processed by the server that match the request
-    def verify(request, times = exactly(1))
-      logger.debug('Sending query for verify to mockserver')
-      results   = retrieve(request)
-
-      # Reusing the times model here so interpreting values here
-      times     = Times.new(symbolize_keys(times))
-      num_times = times.remaining_times
-      is_exact  = !times.unlimited
-
-      fulfilled = is_exact ? (num_times == results.size) : (num_times <= results.size)
-      fail "Expected request to be present: [#{num_times}] (#{is_exact ? 'exactly' : 'at least'}). But found: [#{results.size}]" unless fulfilled
-      results
-    end
-  end
-end

data/lib/mockserver/mock_server_client.rb

@@ -1,46 +0,0 @@
-# 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
-
-    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

@@ -1,85 +0,0 @@
-# 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

@@ -1,56 +0,0 @@
-# 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