flipp-mockserver-client 0.1.0

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",
+        "queryStringParameters": [
+            {
+                "name": "returnUrl",
+                "values": ["/account"]
+            }
+        ],
+        "cookies": [
+            {
+                "name": "sessionId",
+              "value": "2By8LOhBmaW5nZXJwcmludCIlMDAzMW"
+            }
+        ],
+        "body": {
+            "type": "STRING",
+            "value": "{username:'foo', password:'bar'}"
+        }
+    }
+}

data/spec/fixtures/register_expectation.json

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

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

@@ -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/integration/mock_client_integration_spec.rb

@@ -0,0 +1,82 @@
+# 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', 8098) }
+
+  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:8098/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

@@ -0,0 +1,136 @@
+# 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
+
+
+  describe 'transforming request body' do
+    let(:expectation) { MockServer::Model::Expectation.new }
+    let(:request) { MockServer::Model::Request.new }
+
+    [{type: :XPATH, value: '/mock/instance'},
+     {type: :REGEX, value: '\d+.\d+'},
+     {type: :STRING, value: 'Mockserver is great'}].each do |request_hash|
+
+      it "generates a request body of type #{request_hash[:type]}" do
+        request.body = MockServer::Model::Body.new(request_hash)
+        expectation.request = request
+
+        expect(to_camelized_hash(expectation)).to eq({
+          "httpRequest" => {
+          "method" => "GET",
+            "body" => {
+              "type"  => request_hash[:type].to_s,
+              "value" => request_hash[:value].to_s
+            }
+          }
+        })
+      end
+    end
+
+    context 'when request body type binary' do
+      let(:body) do
+        MockServer::Model::Body.new(type: :BINARY, value: 'TW9ja3NlcnZlciBpcyBncmVhdAo=')
+      end
+
+      it 'correctly transforms to a string and updates the object' do
+        request.body = body
+        expectation.request = request
+
+        expect(to_camelized_hash(expectation)).to eq({
+          "httpRequest" => {
+            "method" => "GET",
+            "body" => {
+              "type" => "STRING",
+              "value" => "Mockserver is great\n"
+            }
+          }
+        })
+      end
+    end
+  end
+end

data/spec/mockserver/mock_client_spec.rb

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

data/spec/mockserver/proxy_client_spec.rb

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+require_relative '../spec_helper'
+
+describe MockServer::ProxyClient do
+
+  let(:client) { MockServer::ProxyClient.new('localhost', 8080) }
+  let(:retrieved_request) { FIXTURES.read('retrieved_request.json') }
+  let(:retrieved_request_json) { retrieved_request.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:   "[#{retrieved_request_json}, #{retrieved_request_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))
+    response = response.map { |mock| to_camelized_hash(mock.to_hash) }
+    expect(response).to eq([retrieved_request, retrieved_request])
+  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