mockserver-client 0.0.1

data/lib/mockserver/model/times.rb

@@ -0,0 +1,53 @@
+# encoding: UTF-8
+require 'hashie'
+require_relative './enum'
+
+#
+# A class to model the number of times an expectation should be respected.
+# @author:: Nayyara Samuel (mailto: nayyara.samuel@opower.com)
+#
+module MockServer::Model
+  # Enum for boolean values since Ruby does not have this by default
+  class Boolean < Enum
+    def allowed_values
+      [true, false]
+    end
+  end
+
+  # Model for times class
+  class Times < Hashie::Dash
+    include Hashie::Extensions::MethodAccess
+    include Hashie::Extensions::IgnoreUndeclared
+    include Hashie::Extensions::Coercion
+
+    property :remaining_times, default: 0
+    property :unlimited, default: false
+
+    coerce_key :unlimited, Boolean
+  end
+
+  # DSL methods related to times
+  module DSL
+    def unlimited
+      Times.new(unlimited: true)
+    end
+
+    def once
+      Times.new(remaining_times: 1)
+    end
+
+    def exactly(num)
+      Times.new(remaining_times: num)
+    end
+
+    def at_least(num)
+      Times.new(remaining_times: num, unlimited: true)
+    end
+
+    def times(&_)
+      obj = once
+      yield obj if block_given?
+      obj
+    end
+  end
+end

data/lib/mockserver/proxy_client.rb

@@ -0,0 +1,9 @@
+# encoding: UTF-8
+require_relative './abstract_client'
+
+#
+# The client used to interact with the proxy server.
+# @author:: Nayyara Samuel (mailto: nayyara.samuel@opower.com)
+#
+class MockServer::ProxyClient < MockServer::AbstractClient
+end

data/lib/mockserver/utility_methods.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+require 'active_support/inflector'
+require 'json'
+
+#
+# A module that has common utility methods used by this project
+# @author:: Nayyara Samuel (mailto: nayyara.samuel@opower.com)
+#
+module MockServer::UtilityMethods
+  # Does the following filter/transform operations on a hash
+  # - exclude null or empty valued keys from the hash
+  # - camelize the keys of the hash
+  # @param hash [Object] an object which will be used to create the hash. Must support :to_hash method
+  # @return [Hash] the transformed hash
+  def prepare_hash(obj)
+    obj = obj && obj.respond_to?(:to_hash) ? obj.to_hash : obj
+
+    if obj.is_a?(Hash)
+      obj.each_with_object({}) do |(k, v), acc|
+        is_empty = v.nil? || (v.respond_to?(:empty?) ? v.empty? : false)
+        acc[camelize(k)] = prepare_hash(v) unless is_empty
+      end
+    elsif obj.respond_to?(:map)
+      obj.map { |element| prepare_hash(element) }
+    else
+      obj
+    end
+  end
+
+  # @param [Object] an object to camelize the string representation of
+  # @return [String] the string converted to camelcase with first letter in lower case
+  def camelize(str)
+    str.to_s.camelize(:lower)
+  end
+
+  # Parse string response into JSON
+  # @param response [Response] from RestClient response
+  # @return [Hash] the parsed response or the object unmodified if parsing is not possible
+  def parse_response(response)
+    JSON.parse(response)
+  rescue JSON::ParserError
+    response
+  end
+end

data/lib/mockserver/version.rb

@@ -0,0 +1,5 @@
+# encoding: UTF-8
+# Version for this gem
+module MockServer
+  VERSION = '0.0.1'
+end

data/mockserver-client.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mockserver/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'mockserver-client'
+  spec.version = MockServer::VERSION
+  spec.authors = ['Nayyara Samuel']
+  spec.email = ['nayyara.samuel@gmail.com']
+  spec.summary = %q(A Ruby client for MockServer)
+  spec.required_ruby_version = '~> 1.9.3'
+
+  spec.files = `git ls-files -z`.split("\x0")
+  spec.executables = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.test_files = spec.files.grep(/^(test|spec|features)\//)
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake', '~> 10.3.2'
+  spec.add_development_dependency 'rspec', '~> 3.0.0'
+  spec.add_development_dependency 'simplecov', '~> 0.8.2'
+  spec.add_development_dependency 'webmock', '~> 1.18'
+  spec.add_development_dependency 'rubocop', '~> 0.23.0'
+
+  spec.add_dependency 'hashie', '~> 3.0'
+  spec.add_dependency 'json', '~> 1.8.1'
+  spec.add_dependency 'activesupport', '~> 4.1.1'
+  spec.add_dependency 'rest-client', '~> 1.6.7'
+  spec.add_dependency 'logging_factory', '~> 0.0.2'
+end

data/spec/fixtures/forward_mockserver.json

@@ -0,0 +1,7 @@
+{
+    "httpForward": {
+        "host": "www.mock-server.com",
+        "port": 80,
+        "scheme": "HTTP"
+    }
+}

data/spec/fixtures/incorrect_login_response.json

@@ -0,0 +1,20 @@
+{
+    "httpResponse": {
+        "statusCode": 401,
+        "headers": [
+            {
+                "name": "Content-Type",
+                "values": ["application/json; charset=utf-8"]
+            },
+            {
+                "name": "Cache-Control",
+                "values": ["public, max-age=86400"]
+            }
+        ],
+        "body": "incorrect username and password combination",
+        "delay": {
+            "timeUnit": "SECONDS",
+            "value": 1
+        }
+    }
+}

data/spec/fixtures/post_login_request.json

@@ -0,0 +1,22 @@
+{
+    "httpRequest": {
+        "method": "POST",
+        "path": "/login",
+        "queryParameters": [
+            {
+                "name": "returnUrl",
+                "values": ["/account"]
+            }
+        ],
+        "cookies": [
+            {
+                "name": "sessionId",
+                "values": ["2By8LOhBmaW5nZXJwcmludCIlMDAzMW"]
+            }
+        ],
+        "body": {
+            "type": "EXACT",
+            "value": "{username:'foo', password:'bar'}"
+        }
+    }
+}

data/spec/fixtures/register_expectation.json

@@ -0,0 +1,52 @@
+{
+    "httpRequest": {
+        "method": "POST",
+        "path": "/login",
+        "queryParameters": [
+            {
+                "values": [
+                    "/account"
+                ],
+                "name": "returnUrl"
+            }
+        ],
+        "cookies": [
+            {
+                "values": [
+                    "2By8LOhBmaW5nZXJwcmludCIlMDAzMW"
+                ],
+                "name": "sessionId"
+            }
+        ],
+        "body": {
+            "type": "EXACT",
+            "value": "{\"username\":\"foo\",\"password\":\"bar\"}"
+        }
+    },
+    "httpResponse": {
+        "statusCode": 401,
+        "headers": [
+            {
+                "values": [
+                    "application/json; charset=utf-8"
+                ],
+                "name": "Content-Type"
+            },
+            {
+                "values": [
+                    "public, max-age=86400"
+                ],
+                "name": "Cache-Control"
+            }
+        ],
+        "body": "{\"message\":\"incorrect username and password combination\"}",
+        "delay": {
+            "timeUnit": "SECONDS",
+            "value": 1
+        }
+    },
+    "times": {
+        "remainingTimes": 2,
+        "unlimited": false
+    }
+}

data/spec/fixtures/search_request.json

@@ -0,0 +1,6 @@
+{
+    "httpRequest": {
+        "method": "POST",
+        "path": "/login"
+    }
+}

data/spec/fixtures/times_once.json

@@ -0,0 +1,6 @@
+{
+    "times": {
+        "remainingTimes": 1,
+        "unlimited": false
+    }
+}

data/spec/mockserver/builder_spec.rb

@@ -0,0 +1,83 @@
+# encoding: UTF-8
+require_relative '../spec_helper'
+
+describe MockServer::Model::DSL do
+
+  it 'generates http requests correctly' do
+    mock_request = http_request(:POST, '/login')
+    mock_request.query_parameters = [parameter('returnUrl', '/account')]
+    mock_request.cookies = [cookie('sessionId', '2By8LOhBmaW5nZXJwcmludCIlMDAzMW')]
+    mock_request.body = exact("{username:'foo', password:'bar'}")
+
+    expect(to_camelized_hash(HTTP_REQUEST => mock_request)).to eq(FIXTURES.read('post_login_request.json'))
+
+    # Block style
+    mock_request = request(:POST, '/login') do |request|
+      request.query_parameters = [parameter('returnUrl', '/account')]
+      request.cookies = [cookie('sessionId', '2By8LOhBmaW5nZXJwcmludCIlMDAzMW')]
+      request.body = exact("{username:'foo', password:'bar'}")
+    end
+
+    expect(to_camelized_hash(HTTP_REQUEST => mock_request)).to eq(FIXTURES.read('post_login_request.json'))
+  end
+
+  it 'generates http responses correctly' do
+    mock_response = http_response
+    mock_response.status_code = 401
+    mock_response.headers = [header('Content-Type', 'application/json; charset=utf-8')]
+    mock_response.headers << header('Cache-Control', 'public, max-age=86400')
+    mock_response.body = body('incorrect username and password combination')
+    mock_response.delay = delay_by(:SECONDS, 1)
+
+    expect(to_camelized_hash(HTTP_RESPONSE => mock_response)).to eq(FIXTURES.read('incorrect_login_response.json'))
+
+    # Block style
+    mock_response = 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('incorrect username and password combination')
+      response.delay = delay_by(:SECONDS, 1)
+    end
+
+    expect(to_camelized_hash(HTTP_RESPONSE => mock_response)).to eq(FIXTURES.read('incorrect_login_response.json'))
+  end
+
+  it 'generates http forwards correctly' do
+    mock_forward = http_forward
+    mock_forward.host = 'www.mock-server.com'
+    mock_forward.port = 80
+
+    expect(to_camelized_hash(HTTP_FORWARD => mock_forward)).to eq(FIXTURES.read('forward_mockserver.json'))
+
+    # Block style
+    mock_forward = forward do |forward|
+      forward.host = 'www.mock-server.com'
+      forward.port = 80
+    end
+
+    expect(to_camelized_hash(HTTP_FORWARD => mock_forward)).to eq(FIXTURES.read('forward_mockserver.json'))
+  end
+
+  it 'generates times correctly' do
+    expect(to_camelized_hash(HTTP_TIMES => exactly(1))).to eq(FIXTURES.read('times_once.json'))
+
+    # Block style
+    mock_times = times do |times|
+      times.remaining_times = 1
+    end
+    expect(to_camelized_hash(HTTP_TIMES => mock_times)).to eq(FIXTURES.read('times_once.json'))
+  end
+
+  it 'generates body correctly' do
+    expect(to_camelized_hash(regex('*/login'))).to eq('type' => 'REGEX', 'value' => '*/login')
+    expect(to_camelized_hash(xpath('/login[1]'))).to eq('type' => 'XPATH', 'value' => '/login[1]')
+    expect(to_camelized_hash(parameterized(parameter('token', '4jy5hh')))).to eq('type' => 'PARAMETERS', 'parameters' => [{ 'name' => 'token', 'values' => ['4jy5hh'] }])
+  end
+
+  it 'generates times object correctly' do
+    expect(to_camelized_hash(unlimited)).to eq('unlimited' => 'true', 'remainingTimes' => 0)
+    expect(to_camelized_hash(at_least(2))).to eq('unlimited' => 'true', 'remainingTimes' => 2)
+  end
+
+end

data/spec/mockserver/mock_client_spec.rb

@@ -0,0 +1,77 @@
+# encoding: UTF-8
+require_relative '../spec_helper'
+
+describe MockServer::MockServerClient do
+
+  let(:client) { MockServer::MockServerClient.new('localhost', 8080) }
+  let(:register_expectation_json) { FIXTURES.read('register_expectation.json').to_json }
+  let(:search_request_json) { FIXTURES.read('search_request.json').to_json }
+
+  before do
+    # To suppress logging output to standard output, write to a temporary file
+    client.logger = LoggingFactory::DEFAULT_FACTORY.log('test', output: 'tmp.log', truncate: true)
+
+    # Stub requests
+    stub_request(:put, /.+\/expectation/).with(body: register_expectation_json).to_return(status: 201)
+    stub_request(:put, /.+\/clear/).with(body: search_request_json).to_return(status: 202)
+    stub_request(:put, /.+\/reset/).to_return(status: 202)
+    stub_request(:put, /.+\/retrieve/).with(body: search_request_json).to_return(body: '', status: 200)
+  end
+
+  it 'registers an expectation correctly' do
+    mock_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' }.to_json)
+      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' }.to_json)
+        response.delay = delay_by(:SECONDS, 1)
+      end
+
+      expectation.times = exactly(2)
+    end
+
+    response = client.register(mock_expectation)
+    expect(response.code).to eq(201)
+  end
+
+  it 'raises an error when trying to set both forward and response' do
+    mock_expectation = expectation do |expectation|
+      expectation.request do |request|
+        request.method = 'POST'
+        request.path = '/login'
+      end
+
+      expectation.response do |response|
+        response.status_code = 401
+      end
+
+      expectation.forward do |forward|
+        forward.scheme = :HTTP
+      end
+    end
+
+    expect { client.register(mock_expectation) }.to raise_error(RuntimeError, 'You can only set either of ["httpResponse", "httpForward"]. But not both')
+  end
+
+  it 'clears requests from the mock server' do
+    expect(client.clear(request(:POST, '/login')).code).to eq(202)
+  end
+
+  it 'resets the mock server' do
+    expect(client.reset.code).to eq(202)
+  end
+
+  it 'retrieves requests correctly' do
+    expect(client.retrieve(request(:POST, '/login')).code).to eq(200)
+  end
+
+end

data/spec/mockserver/proxy_client_spec.rb

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+require_relative '../spec_helper'
+
+describe MockServer::ProxyClient do
+
+  let(:client) { MockServer::ProxyClient.new('localhost', 8080) }
+  let(:register_expectation) { FIXTURES.read('register_expectation.json') }
+  let(:register_expectation_json) { register_expectation.to_json }
+  let(:search_request_json) { FIXTURES.read('search_request.json').to_json }
+
+  before do
+    # To suppress logging output to standard output, write to a temporary file
+    client.logger = LoggingFactory::DEFAULT_FACTORY.log('test', output: 'tmp.log', truncate: true)
+
+    # Stub requests
+    stub_request(:put, /.+\/retrieve/).with(body: search_request_json).to_return(
+        body: "[#{register_expectation_json}, #{register_expectation_json}]",
+        status: 200
+    )
+    stub_request(:put, /.+\/dumpToLog$/).to_return(status: 202).once
+    stub_request(:put, /.+\/dumpToLog\?type=java$/).to_return(status: 202).once
+  end
+
+  it 'verifies requests correctly' do
+    response = client.verify(request(:POST, '/login'), exactly(2))
+    expect(response).to eq([register_expectation, register_expectation])
+  end
+
+  it 'raises an error when verification fails' do
+    expect { client.verify(request(:POST, '/login')) }.to raise_error(RuntimeError, 'Expected request to be present: [1] (exactly). But found: [2]')
+  end
+
+  it 'dumps to logs correctly do' do
+    expect(client.dump_log.code).to eq(202)
+    expect(client.dump_log({}, true).code).to eq(202)
+  end
+end