mockserver-client 1.0.8.pre → 6.0.0

data/lib/mockserver/model/times.rb

@@ -1,61 +0,0 @@
-# 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
-
-    def !
-      !@value
-    end
-
-    def initialize(supplied_value)
-      @value = pre_process_value(supplied_value)
-    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

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

@@ -1,59 +0,0 @@
-# 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 obj [Object] an object which will be used to create the hash. Must support :to_hash method
-  # @return [Hash] the transformed hash
-  # rubocop:disable Style/MethodLength
-  # rubocop:disable Style/CyclomaticComplexity
-  def camelized_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)] = camelized_hash(v) unless is_empty
-      end
-    elsif obj.respond_to?(:map)
-      obj.map { |element| camelized_hash(element) }
-    else
-      obj
-    end
-  end
-
-  # Converts keys to symbols
-  # @param hash [Hash] a hash
-  # @return [Hash] a copy of the hash where keys are symbols
-  def symbolize_keys(hash)
-    if hash.is_a?(Hash)
-      Hash[hash.map { |k, v| [k.to_s.underscore.to_sym, symbolize_keys(v)] }]
-    elsif hash.respond_to?(:map)
-      hash.map { |obj| symbolize_keys(obj) }
-    else
-      hash
-    end
-  end
-
-  # @param str [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_string_to_json(response)
-    JSON.parse(response)
-  rescue JSON::ParserError
-    response
-  end
-end

data/pom.xml

@@ -1,118 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <parent>
-        <groupId>org.mock-server</groupId>
-        <artifactId>mockserver</artifactId>
-        <version>3.10.2-SNAPSHOT</version>
-    </parent>
-    <modelVersion>4.0.0</modelVersion>
-
-    <artifactId>mockserver-client-ruby</artifactId>
-    <name>MockServer Ruby Client</name>
-    <description>A ruby client for the MockServer</description>
-    <url>http://www.mock-server.com</url>
-
-    <properties>
-        <skipRubyRelease>true</skipRubyRelease>
-        <skipRubyBuild>false</skipRubyBuild>
-    </properties>
-
-    <build>
-        <plugins>
-            <!-- run mock server for ruby client tests -->
-            <plugin>
-                <groupId>${project.groupId}</groupId>
-                <artifactId>mockserver-maven-plugin</artifactId>
-                <version>${project.version}</version>
-                <configuration>
-                    <logLevel>WARN</logLevel>
-                    <serverPort>1080</serverPort>
-                    <proxyPort>1090</proxyPort>
-                </configuration>
-                <executions>
-                    <execution>
-                        <id>pre-test</id>
-                        <phase>generate-test-sources</phase>
-                        <goals>
-                            <goal>start</goal>
-                        </goals>
-                    </execution>
-                    <execution>
-                        <id>post-test</id>
-                        <phase>verify</phase>
-                        <goals>
-                            <goal>stop</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>
-            <!-- run ruby bundle build and install -->
-            <plugin>
-                <groupId>org.codehaus.mojo</groupId>
-                <artifactId>exec-maven-plugin</artifactId>
-                <version>1.4.0</version>
-                <executions>
-                    <execution>
-                        <id>bundle_install</id>
-                        <phase>prepare-package</phase>
-                        <goals>
-                            <goal>exec</goal>
-                        </goals>
-                        <configuration>
-                            <skip>${skipRubyBuild}</skip>
-                            <executable>bundle</executable>
-                            <arguments>
-                                <argument>install</argument>
-                                <argument>--path</argument>
-                                <argument>vendor/bundle</argument>
-                            </arguments>
-                            <environmentVariables>
-                                <BUNDLE_GEMFILE>${basedir}/Gemfile</BUNDLE_GEMFILE>
-                            </environmentVariables>
-                        </configuration>
-                    </execution>
-                    <execution>
-                        <id>ruby_make</id>
-                        <phase>prepare-package</phase>
-                        <goals>
-                            <goal>exec</goal>
-                        </goals>
-                        <configuration>
-                            <skip>${skipRubyBuild}</skip>
-                            <executable>bundle</executable>
-                            <arguments>
-                                <argument>exec</argument>
-                                <argument>rake</argument>
-                                <argument>build</argument>
-                                <argument>spec</argument>
-                            </arguments>
-                            <environmentVariables>
-                                <BUNDLE_GEMFILE>${basedir}/Gemfile</BUNDLE_GEMFILE>
-                            </environmentVariables>
-                        </configuration>
-                    </execution>
-                    <execution>
-                        <id>ruby_release</id>
-                        <phase>deploy</phase>
-                        <goals>
-                            <goal>exec</goal>
-                        </goals>
-                        <configuration>
-                            <skip>${skipRubyRelease}</skip>
-                            <executable>bundle</executable>
-                            <arguments>
-                                <argument>exec</argument>
-                                <argument>rake</argument>
-                                <argument>release</argument>
-                            </arguments>
-                            <environmentVariables>
-                                <BUNDLE_GEMFILE>${basedir}/Gemfile</BUNDLE_GEMFILE>
-                            </environmentVariables>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
-        </plugins>
-    </build>
-
-</project>

data/spec/fixtures/forward_mockserver.json

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

data/spec/fixtures/incorrect_login_response.json

@@ -1,20 +0,0 @@
-{
-  "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

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

data/spec/fixtures/register_expectation.json

@@ -1,50 +0,0 @@
-{
-    "httpRequest": {
-        "method": "POST",
-        "path": "/login",
-        "queryStringParameters": [
-            {
-                "values": [
-                    "/account"
-                ],
-                "name": "returnUrl"
-            }
-        ],
-        "cookies": [
-            {
-              "name": "sessionId",
-              "value": "2By8LOhBmaW5nZXJwcmludCIlMDAzMW"
-            }
-        ],
-        "body": {
-            "type": "STRING",
-            "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/retrieved_request.json

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

data/spec/fixtures/search_request.json

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

data/spec/fixtures/times_once.json

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

data/spec/integration/mock_client_integration_spec.rb

@@ -1,82 +0,0 @@
-# encoding: UTF-8
-require 'rspec'
-require 'net/http'
-require 'webmock/rspec'
-require_relative '../../lib/mockserver-client'
-
-RSpec.configure do |config|
-  include WebMock::API
-  include MockServer
-  include MockServer::UtilityMethods
-  include MockServer::Model::DSL
-
-  # Only accept expect syntax do not allow old should syntax
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-end
-
-describe MockServer::MockServerClient do
-
-  let(:client) { MockServer::MockServerClient.new('localhost', 1080) }
-
-  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)
-  end
-
-  def create_agent
-    uri      = URI('http://api.nsa.gov:1337/agent')
-    http     = Net::HTTP.new(uri.host, uri.port)
-    req      = Net::HTTP::Post.new(uri.path, 'Content-Type' => 'application/json')
-    req.body = { name: 'John Doe', role: 'agent' }.to_json
-    res = http.request(req)
-    puts "response #{res.body}"
-  rescue => e
-    puts "failed #{e}"
-  end
-
-  it 'setup complex expectation' do
-    WebMock.allow_net_connect!
-
-    # given
-    mock_expectation = expectation do |expectation|
-      expectation.request do |request|
-        request.method = 'POST'
-        request.path   = '/somePath'
-        request.query_string_parameters << parameter('param', 'someQueryStringValue')
-        request.headers << header('Header', 'someHeaderValue')
-        request.cookies << cookie('cookie', 'someCookieValue')
-        request.body = exact('someBody')
-      end
-
-      expectation.response do |response|
-        response.status_code = 201
-        response.headers << header('header', 'someHeaderValue')
-        response.body  = body('someBody')
-        response.delay = delay_by(:SECONDS, 1)
-      end
-
-      expectation.times = exactly(1)
-    end
-
-    # and
-    expect(client.register(mock_expectation).code).to eq(201)
-
-    # when
-    uri           = URI('http://localhost:1080/somePath')
-    http          = Net::HTTP.new(uri.host, uri.port)
-    req           = Net::HTTP::Post.new('/somePath?param=someQueryStringValue')
-    req['Header'] = 'someHeaderValue'
-    req['Cookie'] = 'cookie=someCookieValue'
-    req.body      = 'someBody'
-    res           = http.request(req)
-
-    # then
-    expect(res.code).to eq('201')
-    expect(res.body).to eq('someBody')
-
-    WebMock.disable_net_connect!
-  end
-
-end

data/spec/mockserver/builder_spec.rb

@@ -1,90 +0,0 @@
-# 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_string_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_string_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 expectation correctly from file' do
-    payload          = FIXTURES.read('register_expectation.json')
-    mock_expectation = expectation_from_json(payload)
-
-    expect(to_camelized_hash(mock_expectation.to_hash)).to eq(payload)
-  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

@@ -1,80 +0,0 @@
-# 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, headers: { 'Content-Type' => 'application/json' }).to_return(status: 201)
-    stub_request(:put, /.+\/clear/).with(body: search_request_json, headers: { 'Content-Type' => 'application/json' }).to_return(status: 202)
-    stub_request(:put, /.+\/reset/).with(headers: { 'Content-Type' => 'application/json' }).to_return(status: 202)
-    stub_request(:put, /.+\/retrieve/).with(body: search_request_json, headers: { 'Content-Type' => 'application/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_string_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