mockserver-client 1.0.8.pre → 5.3.0

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

data/spec/mockserver/proxy_client_spec.rb

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