flipp-mockserver-client 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c0442883161829df4b30bd7e65d12003a75e381d
+  data.tar.gz: 98dd73428d57662b761c52b7894ec76154577e76
+SHA512:
+  metadata.gz: d2b506eb6d651fa03636ef9cee170062dcd2d87af8746f273314e6a485d060253341973fb7d4aa956cf2b61cf186d9674b760996a49a6d1f4e8696bd438cb8e3
+  data.tar.gz: 227e278980bbb3c75c0cd42e6bfff4630566bea4c2e4c21d3146d96570aabfb952efd27fcc1f3a901e85e0315a485c0b15b5fddf7c7e54bc9cccab64d7cd4b30

data/.gitignore

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

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

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Gem's dependencies in mockserver-client.gemspec
+gemspec

data/README.md

@@ -0,0 +1,182 @@
+# Flipp - Modified Mockserver Client
+
+A Ruby client for [MockServer](http://www.mock-server.com) project. This client follows the Java client's fluent style closely by using Ruby blocks.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mockserver-client'
+```
+
+Create and install the gem:
+
+```bash
+gem build [gem_name].gemspec
+gem install [gem_name-version].gem
+```
+
+## Usage
+
+The Ruby code here assumes you have included `MockServer` and `MockServer::Model::DSL` modules. So these lines should  typically be at the top of your code:
+
+```ruby
+include MockServer
+include MockServer::Model::DSL
+```
+
+### Create Expectations
+
+##### Ruby
+
+```ruby
+client = MockServerClient.new('localhost', 9999)
+expectation = expectation do |expectation|
+     expectation.request do |request|
+        request.method = 'POST'
+        request.path = '/login'
+        request.query_string_parameters << parameter('returnUrl', '/account')
+        request.cookies = [cookie('sessionId', '2By8LOhBmaW5nZXJwcmludCIlMDAzMW')]
+        request.body = exact("{username: 'foo', password: 'bar'}")
+     end
+
+    expectation.response do |response|
+        response.status_code = 401
+        response.headers << header('Content-Type', 'application/json; charset=utf-8')
+        response.headers << header('Cache-Control', 'public, max-age=86400')
+        response.body = body("{ message: 'incorrect username and password combination' }")
+        response.delay = delay_by(:SECONDS, 1)
+    end
+end
+client.register(expectation)
+```
+
+### Clear & Reset Server
+
+##### Ruby
+
+ ```ruby
+ client.clear(request('POST', '/login'))
+ client.reset
+ ```
+### Verifying Behavior
+
+##### Ruby
+
+```ruby
+# Not providing times here because the default is exactly(1) i.e. the second argument to verify method
+ProxyClient.new('localhost', 9090).verify(request(:POST, '/login') do |request|
+    request.body = exact("{username: 'foo', password: 'bar'}")
+    request.cookies = [cookie("sessionId", ".*")]
+end)
+```
+
+
+### Analyzing Behavior
+
+##### Ruby
+
+```ruby
+# Second argument is true to set output to Java; false to set output to default JSON (default)
+ProxyClient.new('localhost', 9090).dump_log(request(:POST, '/login'), false)
+```
+
+## Complete Ruby DSL
+The DSL is provided via the `MockServer::Model::DSL` module. Include this module in your code to make the DSL available.
+
+Request
+* **request**: Used to build a request object. If a block is passed, will configure request first and then return the configured request. Example: `request(:POST, '/login') {|r| r.headers << header("Content-Type", "application/json")}`.
+* **http_request**: Alias for `request`.
+
+Body
+* **body**: Create a string body object (use in a response). Example: `body("unaccepted")`.
+* **exact**: Create a body of type `STRING`. Example: `exact('{"reason": "unauthorized"}')`.
+* **regex**: Create a body of type `REGEX`. Example: `regex('username[a-z]{4}')`.
+* **xpath**: Used to create a body of type `XPATH`. Example: `xpath("/element[key = 'some_key' and value = 'some_value']")`.
+* **parameterized**; Create a body to type `PARAMETERS`. Example `parameterized(parameter('someValue', 1, 2), parameter('otherValue', 4, 5))`.
+
+Parameters
+* **parameter**: Create a generic parameter. Example: `parameter('key', 'value1' , 'value2')`.
+* **cookie**: Create a cookie (same as `parameter` above but exists as syntactic sugar). Example: `cookie('sessionId', 'sessionid1ldj')`.
+* **header**: Create a header (same as `parameter` above but exists as syntactic sugar). Example: `header('Content-Type', 'application/json')`.
+
+Forward
+* **forward**: Create a forwarding response. If a block is passed, will configure forward response first and then return the configured object. Example: `forward {|f| f.scheme = 'HTTPS' }`.
+* **http_forward**: Alias for `forward`.
+
+Response
+* **response**: Create a response object. If a block is passed, will configure response first and then return the configured response. Example: `response {|r| r.status_code = 201 }`.
+* **http_response**: Alias for `response`.
+
+Delay
+* **delay_by**. Create a delay object in a response. Example : `delay_by(:MICROSECONDS, 20)`.
+
+Times (used in Expectation)
+* **times**: Create an 'times' object. If a block is passed, will configure the object first before returning it. Example: `times {|t| t.unlimited = false }`.
+* **unlimited**: Create an object with unlimited repeats. Example: `unlimited()`. (No parameters).
+* **once**. Create an object that repeats only once. Example: `once()`. (No parameters).
+* **exactly**. Create an object that repeats exactly the number of times specified. Example: `exactly(2)`.
+* **at_least**: Create an object that repeats at least the given number of times. (Use in verify). Example: `at_least(2)`.
+
+Expectation (use in register)
+* **expectation**: Create an expectation object. If a block is passed, will configure the object first before returning it. Example: `expectation {|e| e.request {|r| r.path = "index.html} }`.
+Getter methods for `request`, `response` and `forward` methods will optionally accept a block. If block is passed object is configured before it is returned. The attribute `times` has conventional getter and setter methods.
+
+## CLI
+
+This gem comes with a command line interface which allow you to run the Mock Server calls from the command line. When this gem is installed, you will have the `mockserver` executable on your PATH. Type `mockserver --help` and you will get this output:
+
+```bash
+mockserver --help
+
+Commands:
+  mockserver clear           # Clears all stored mock request/responses from server.
+  mockserver dump_log        # Dumps the matching request to the mock server logs.
+  mockserver help [COMMAND]  # Describe available commands or one specific command
+  mockserver register        # Register an expectation with the mock server.
+  mockserver reset           # Resets the server clearing all data.
+  mockserver retrieve        # Retrieve the list of requests that have been made to the mock/proxy server.
+  mockserver verify          # Verify that a request has been made the specified number of times to the server.
+
+Options:
+  -h, --host=HOST    # The host for the MockServer client.
+                     # Default: localhost
+  -p, --port=N       # The port for the MockServer client.
+                     # Default: 8080
+  -d, [--data=DATA]  # A JSON or YAML file containing the request payload.
+```
+
+To get help for an individual command, e.g. `dump_log`, you would do:
+
+```bash
+mockserver --help dump_log
+
+Usage:
+  mockserver dump_log
+
+Options:
+  -j, [--java], [--no-java]  # A switch to turn Java format for logs on/off.
+  -h, --host=HOST            # The host for the MockServer client.
+                             # Default: localhost
+  -p, --port=N               # The port for the MockServer client.
+                             # Default: 8080
+  -d, [--data=DATA]          # A JSON or YAML file containing the request payload.
+
+Dumps the matching request to the mock server logs.
+```
+
+Here is an example on how you would run the command:
+
+```bash
+mockserver dump_log -j true
+
+Running with parameters:
+	host: localhost
+	port: 8080
+	java: true
+
+[2014-06-21 09:23:32] DEBUG [MockServerClient] Sending dump log request to mockserver
+[2014-06-21 09:23:32] DEBUG [MockServerClient] URL: /dumpToLog?type=java. Payload: {}
+[2014-06-21 09:23:32] DEBUG [MockServerClient] Got dump to log response: 202
+```

data/Rakefile

@@ -0,0 +1,10 @@
+# encoding: UTF-8
+require 'bundler/gem_tasks'
+require 'rubocop/rake_task'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new(:rubocop)
+
+desc 'Main task for this project to ensure the project passes build'
+task default: [:rubocop, :spec, :build]

data/bin/mockserver

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

@@ -0,0 +1,146 @@
+# 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-client.rb

@@ -0,0 +1,17 @@
+# encoding: UTF-8
+require_relative './mockserver/version'
+require_relative './mockserver/mock_server_client'
+require_relative './mockserver/proxy_client'
+
+# Setup serialization correctly with multi_json
+require 'json/pure'
+
+# To fix serialization bugs. See: http://prettystatemachine.blogspot.com/2010/09/typeerrors-in-tojson-make-me-briefly.html
+class Fixnum
+  def to_json(_)
+    to_s
+  end
+end
+
+require 'multi_json'
+MultiJson.use(:json_pure)

data/lib/mockserver/abstract_client.rb

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