mockserver-client 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    N2ZiZDY2MzcwMzQ5NGViNDc2YTQzYmY0NmYxMWI3ZjhkNGY5NzYyNQ==
+  data.tar.gz: !binary |-
+    OGVmMWM2ZWExZGVmZTk0YTU0MDI1MzU2ODM5YWNmMTNmYTY1M2NiMw==
+SHA512:
+  metadata.gz: !binary |-
+    MzNkZDY5NWE2YTNlMGQ5YjQ1YWNiYjY0MGRlNTllYmZmMzRmN2YwNDYyOGM4
+    ODA2YzFiNzY0MGZjOWVlYTYyZGRhNzRmMzZlYmRkMzk4NjU3N2EyYzc5OGNk
+    NDBkMWFmMmRkNTk0YTI4NTFiOGM3MjMzMTc4NzQ4MTFiNzc2ZmQ=
+  data.tar.gz: !binary |-
+    MGIyZDEwOTUwMjllYTc4YTgzNWEyYTdlMjAzZDg4MWUyMmExMDA3Nzg3ZTI1
+    ODNlNmJmYzcxODI4NjVkZWMxOTgzZGQyNmMxOGRiZGQzYmEyZWMwYWNhYzIw
+    MTMyMTk3ZTk5M2MzOTcwNjg4ZjliOTFlZWQ2OWM4MmY5ZTQ1MjQ=

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+tmp.log

data/.rubocop.yml

@@ -0,0 +1,13 @@
+Style/LineLength:
+  Max: 180
+Style/ClassAndModuleChildren:
+  EnforcedStyle: compact
+Style/CyclomaticComplexity:
+  Enabled: false
+Lint/LiteralInInterpolation:
+  Enabled: false
+Style/MethodLength:
+  Enabled: false
+Style/FileName:
+  Exclude:
+    - '**/mockserver-client.rb'

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 1.9.3
+script:
+  - bundle exec rake rubocop
+  - bundle exec rake spec
+  - bundle exec rake build

data/Gemfile

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

data/README.md

@@ -0,0 +1,200 @@
+# Mockserver Client
+
+[![Build Status](https://travis-ci.org/nayyara-samuel/mockserver-client.svg?branch=master)](https://travis-ci.org/nayyara-samuel/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:
+
+    gem 'mockserver-client'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mockserver-client
+
+## Usage
+
+The usage notes here compare the Java syntax with the Ruby DSL for the various actions the MockServer client/proxy client supports. 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
+
+##### Java
+```java
+
+new MockServerClient("localhost", 9999)
+        .when(
+                request()
+                        .withMethod("POST")
+                        .withPath("/login")
+                        .withQueryStringParameters(
+                                new Parameter("returnUrl", "/account")
+                        )
+                        .withCookies(
+                                new Cookie("sessionId", "2By8LOhBmaW5nZXJwcmludCIlMDAzMW")
+                        )
+                        .withBody("{username: 'foo', password: 'bar'}"),
+                Times.exactly(1)
+        )
+        .respond(
+                response()
+                        .withStatusCode(401)
+                        .withHeaders(
+                                new Header("Content-Type", "application/json; charset=utf-8"),
+                                new Header("Cache-Control", "public, max-age=86400")
+                        )
+                        .withBody("{ message: 'incorrect username and password combination' }")
+                        .withDelay(new Delay(TimeUnit.SECONDS, 1))
+        );
+```
+
+##### Ruby
+
+```ruby
+
+client = MockServerClient.new('localhost', 9999)
+expectation = expectation do |expectation|
+     expectation.request do |request|
+        request.method = 'POST'
+        request.path = '/login'
+        request.query_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
+
+##### Java
+
+```java
+mockServerClient.clear(
+        request()
+                .withMethod("POST")
+                .withPath("/login")
+);
+mockServerClient.reset();
+```
+
+##### Ruby
+
+ ```ruby
+ client.clear(request('POST', '/login'))
+ client.reset
+ ```
+### Verifying Behavior
+
+##### Java
+
+```java
+new ProxyClient("localhost", 9090).verify(
+        request()
+                .withMethod("POST")
+                .withPath("/login")
+                .withBody(exact("{username: 'foo', password: 'bar'}"))
+                .withCookies(
+                        new Cookie("sessionId", ".*")
+                ),
+        Times.exactly(1)
+);
+```
+
+##### 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
+
+##### Java
+
+```java
+new ProxyClient("localhost", 9090).dumpToLogAsJava(
+        request()
+                .withMethod("POST")
+                .withPath("/login")
+);
+```
+
+##### 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'), true)
+```
+
+## 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 `EXACT`. 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.
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/mockserver-client/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+6. **IMPORTANT**: Keep code coverage high. Preferably above 95%. This project uses SimpleCov for code coverage which reports percentage coverage.

data/Rakefile

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+require 'bundler/gem_tasks'
+require 'rubocop/rake_task'
+require 'rspec/mocks/version'
+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/lib/mockserver-client.rb

@@ -0,0 +1,4 @@
+# encoding: UTF-8
+require_relative './mockserver/version'
+require_relative './mockserver/mock_server_client'
+require_relative './mockserver/proxy_client'

data/lib/mockserver/abstract_client.rb

@@ -0,0 +1,112 @@
+# encoding: UTF-8
+require 'rest-client'
+require 'logging_factory'
+require_relative './model/times'
+require_relative './model/request'
+
+# An abstract client for making requests supported by mock and proxy client.
+# @author Nayyara Samuel(mailto: nayyara.samuel@opower.com)
+#
+module MockServer
+  HTTP_REQUEST = 'httpRequest'
+  HTTP_RESPONSE = 'httpResponse'
+  HTTP_FORWARD = 'httpForward'
+  HTTP_TIMES = 'times'
+
+  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
+
+    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}")
+      @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 = prepare_hash(HTTP_REQUEST => Request.new(request))
+      url = CLEAR_ENDPOINT
+
+      logger.debug("Clearing expectation with request: #{request}")
+      logger.debug("URL: #{url}. Payload: #{request.to_hash}")
+
+      response = @base[url].put(request.to_json, content_type: :json)
+      logger.debug("Got clear response: #{response.code}")
+      parse_response(response)
+    end
+
+    # Reset the mock server clearing all expectations previously registered
+    # @return [Object] the response from the reset action
+    def reset
+      request = {}
+      url = RESET_ENDPOINT
+
+      logger.debug('Resetting mockserver')
+      logger.debug("URL: #{url}. Payload: #{request.to_hash}")
+
+      response = @base[url].put(request.to_json)
+      logger.debug("Got reset response: #{response.code}")
+      parse_response(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 ? prepare_hash(HTTP_REQUEST => Request.new(request)) : {}
+      url = RETRIEVE_ENDPOINT
+
+      logger.debug('Retrieving request list from mockserver')
+      logger.debug("URL: #{url}. Payload: #{request.to_hash}")
+
+      response = @base[RETRIEVE_ENDPOINT].put(request.to_json)
+      logger.debug("Got retrieve response: #{response.code}")
+      parse_response(response)
+    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.new(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_response(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
+      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

@@ -0,0 +1,50 @@
+# 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)
+      url = EXPECTATION_ENDPOINT
+      request = create_expectation_request(expectation)
+
+      logger.debug('Registering new expectation')
+      logger.debug("URL: #{url} Payload: #{request.to_hash}")
+
+      response = @base[url].put(request.to_json, content_type: :json)
+      logger.debug("Got register response: #{response.code}")
+      parse_response(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
+    def create_expectation_request(expectation)
+      expectation_request = prepare_hash(HTTP_REQUEST => expectation.request,
+                                         HTTP_RESPONSE => expectation.response,
+                                         HTTP_FORWARD => expectation.forward,
+                                         HTTP_TIMES => expectation.times)
+
+      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