mockserver-client 5.3.0 → 6.0.0

data/lib/mockserver-client/models/verification_times.rb

@@ -1,192 +0,0 @@
-=begin
-#Mock Server API
-
-#MockServer enables easy mocking of any system you integrate with via HTTP or HTTPS with clients written in Java, JavaScript and Ruby and a simple REST API (as shown below).  MockServer Proxy is a proxy that introspects all proxied traffic including encrypted SSL traffic and supports Port Forwarding, Web Proxying (i.e. HTTP proxy), HTTPS Tunneling Proxying (using HTTP CONNECT) and SOCKS Proxying (i.e. dynamic port forwarding).  Both MockServer and the MockServer Proxy record all received requests so that it is possible to verify exactly what requests have been sent by the system under test.
-
-OpenAPI spec version: 5.3.0
-
-Generated by: https://openapi-generator.tech
-OpenAPI Generator version: 3.3.1
-
-=end
-
-require 'date'
-
-module MockServer
-  class VerificationTimes
-    attr_accessor :count
-
-    attr_accessor :exact
-
-    # Attribute mapping from ruby-style variable name to JSON key.
-    def self.attribute_map
-      {
-        :'count' => :'count',
-        :'exact' => :'exact'
-      }
-    end
-
-    # Attribute type mapping.
-    def self.openapi_types
-      {
-        :'count' => :'Integer',
-        :'exact' => :'BOOLEAN'
-      }
-    end
-
-    # Initializes the object
-    # @param [Hash] attributes Model attributes in the form of hash
-    def initialize(attributes = {})
-      return unless attributes.is_a?(Hash)
-
-      # convert string to symbol for hash key
-      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
-
-      if attributes.has_key?(:'count')
-        self.count = attributes[:'count']
-      end
-
-      if attributes.has_key?(:'exact')
-        self.exact = attributes[:'exact']
-      end
-    end
-
-    # Show invalid properties with the reasons. Usually used together with valid?
-    # @return Array for valid properties with the reasons
-    def list_invalid_properties
-      invalid_properties = Array.new
-      invalid_properties
-    end
-
-    # Check to see if the all the properties in the model are valid
-    # @return true if the model is valid
-    def valid?
-      true
-    end
-
-    # Checks equality by comparing each attribute.
-    # @param [Object] Object to be compared
-    def ==(o)
-      return true if self.equal?(o)
-      self.class == o.class &&
-          count == o.count &&
-          exact == o.exact
-    end
-
-    # @see the `==` method
-    # @param [Object] Object to be compared
-    def eql?(o)
-      self == o
-    end
-
-    # Calculates hash code according to all attributes.
-    # @return [Fixnum] Hash code
-    def hash
-      [count, exact].hash
-    end
-
-    # Builds the object from hash
-    # @param [Hash] attributes Model attributes in the form of hash
-    # @return [Object] Returns the model itself
-    def build_from_hash(attributes)
-      return nil unless attributes.is_a?(Hash)
-      self.class.openapi_types.each_pair do |key, type|
-        if type =~ /\AArray<(.*)>/i
-          # check to ensure the input is an array given that the the attribute
-          # is documented as an array but the input is not
-          if attributes[self.class.attribute_map[key]].is_a?(Array)
-            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
-          end
-        elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
-        end # or else data not found in attributes(hash), not an issue as the data can be optional
-      end
-
-      self
-    end
-
-    # Deserializes the data based on type
-    # @param string type Data type
-    # @param string value Value to be deserialized
-    # @return [Object] Deserialized data
-    def _deserialize(type, value)
-      case type.to_sym
-      when :DateTime
-        DateTime.parse(value)
-      when :Date
-        Date.parse(value)
-      when :String
-        value.to_s
-      when :Integer
-        value.to_i
-      when :Float
-        value.to_f
-      when :BOOLEAN
-        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
-          true
-        else
-          false
-        end
-      when :Object
-        # generic object (usually a Hash), return directly
-        value
-      when /\AArray<(?<inner_type>.+)>\z/
-        inner_type = Regexp.last_match[:inner_type]
-        value.map { |v| _deserialize(inner_type, v) }
-      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
-        k_type = Regexp.last_match[:k_type]
-        v_type = Regexp.last_match[:v_type]
-        {}.tap do |hash|
-          value.each do |k, v|
-            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
-          end
-        end
-      else # model
-        temp_model = MockServer.const_get(type).new
-        temp_model.build_from_hash(value)
-      end
-    end
-
-    # Returns the string representation of the object
-    # @return [String] String presentation of the object
-    def to_s
-      to_hash.to_s
-    end
-
-    # to_body is an alias to to_hash (backward compatibility)
-    # @return [Hash] Returns the object in the form of hash
-    def to_body
-      to_hash
-    end
-
-    # Returns the object in the form of hash
-    # @return [Hash] Returns the object in the form of hash
-    def to_hash
-      hash = {}
-      self.class.attribute_map.each_pair do |attr, param|
-        value = self.send(attr)
-        next if value.nil?
-        hash[param] = _to_hash(value)
-      end
-      hash
-    end
-
-    # Outputs non-array value in the form of hash
-    # For object, use to_hash. Otherwise, just return the value
-    # @param [Object] value Any valid value
-    # @return [Hash] Returns the value in the form of hash
-    def _to_hash(value)
-      if value.is_a?(Array)
-        value.compact.map { |v| _to_hash(v) }
-      elsif value.is_a?(Hash)
-        {}.tap do |hash|
-          value.each { |k, v| hash[k] = _to_hash(v) }
-        end
-      elsif value.respond_to? :to_hash
-        value.to_hash
-      else
-        value
-      end
-    end
-  end
-end

data/lib/mockserver-client/version.rb

@@ -1,15 +0,0 @@
-=begin
-#Mock Server API
-
-#MockServer enables easy mocking of any system you integrate with via HTTP or HTTPS with clients written in Java, JavaScript and Ruby and a simple REST API (as shown below).  MockServer Proxy is a proxy that introspects all proxied traffic including encrypted SSL traffic and supports Port Forwarding, Web Proxying (i.e. HTTP proxy), HTTPS Tunneling Proxying (using HTTP CONNECT) and SOCKS Proxying (i.e. dynamic port forwarding).  Both MockServer and the MockServer Proxy record all received requests so that it is possible to verify exactly what requests have been sent by the system under test.
-
-OpenAPI spec version: 5.3.0
-
-Generated by: https://openapi-generator.tech
-OpenAPI Generator version: 3.3.1
-
-=end
-
-module MockServer
-  VERSION = '5.3.0'
-end

data/spec/api/control_api_spec.rb

@@ -1,102 +0,0 @@
-=begin
-#Mock Server API
-
-#MockServer enables easy mocking of any system you integrate with via HTTP or HTTPS with clients written in Java, JavaScript and Ruby and a simple REST API (as shown below).  MockServer Proxy is a proxy that introspects all proxied traffic including encrypted SSL traffic and supports Port Forwarding, Web Proxying (i.e. HTTP proxy), HTTPS Tunneling Proxying (using HTTP CONNECT) and SOCKS Proxying (i.e. dynamic port forwarding).  Both MockServer and the MockServer Proxy record all received requests so that it is possible to verify exactly what requests have been sent by the system under test.
-
-OpenAPI spec version: 5.3.0
-
-Generated by: https://openapi-generator.tech
-OpenAPI Generator version: 3.3.1
-
-=end
-
-require 'spec_helper'
-require 'json'
-
-# Unit tests for MockServer::ControlApi
-# Automatically generated by openapi-generator (https://openapi-generator.tech)
-# Please update as you see appropriate
-describe 'ControlApi' do
-  before do
-    # run before each test
-    @instance = MockServer::ControlApi.new
-  end
-
-  after do
-    # run after each test
-  end
-
-  describe 'test an instance of ControlApi' do
-    it 'should create an instance of ControlApi' do
-      expect(@instance).to be_instance_of(MockServer::ControlApi)
-    end
-  end
-
-  # unit tests for bind_put
-  # bind additional listening ports
-  # only supported on Netty version
-  # @param ports list of ports to bind to, where 0 indicates dynamically bind to any available port
-  # @param [Hash] opts the optional parameters
-  # @return [Ports]
-  describe 'bind_put test' do
-    it 'should work' do
-      # assertion here. ref: https://www.relishapp.com/rspec/rspec-expectations/docs/built-in-matchers
-    end
-  end
-
-  # unit tests for clear_put
-  # clears expectations and recorded requests that match the request matcher
-  # @param [Hash] opts the optional parameters
-  # @option opts [HttpRequest] :http_request request used to match expectations and recored requests to clear
-  # @return [nil]
-  describe 'clear_put test' do
-    it 'should work' do
-      # assertion here. ref: https://www.relishapp.com/rspec/rspec-expectations/docs/built-in-matchers
-    end
-  end
-
-  # unit tests for reset_put
-  # clears all expectations and recorded requests
-  # @param [Hash] opts the optional parameters
-  # @return [nil]
-  describe 'reset_put test' do
-    it 'should work' do
-      # assertion here. ref: https://www.relishapp.com/rspec/rspec-expectations/docs/built-in-matchers
-    end
-  end
-
-  # unit tests for retrieve_put
-  # retrieve recorded requests, active expectations, recorded expectations or log messages
-  # @param [Hash] opts the optional parameters
-  # @option opts [String] :format changes response format, default if not specificed is \"json\", supported values are \"java\", \"json\"
-  # @option opts [String] :type specifies the type of object that is retrieve, default if not specified is \"requests\", supported values are \"logs\", \"requests\", \"recorded_expectations\", \"active_expectations\"
-  # @option opts [HttpRequest] :http_request request used to match which recorded requests, expectations or log messages to return, an empty body matches all requests, expectations or log messages
-  # @return [Object]
-  describe 'retrieve_put test' do
-    it 'should work' do
-      # assertion here. ref: https://www.relishapp.com/rspec/rspec-expectations/docs/built-in-matchers
-    end
-  end
-
-  # unit tests for status_put
-  # return listening ports
-  # @param [Hash] opts the optional parameters
-  # @return [Ports]
-  describe 'status_put test' do
-    it 'should work' do
-      # assertion here. ref: https://www.relishapp.com/rspec/rspec-expectations/docs/built-in-matchers
-    end
-  end
-
-  # unit tests for stop_put
-  # stop running process
-  # only supported on Netty version
-  # @param [Hash] opts the optional parameters
-  # @return [nil]
-  describe 'stop_put test' do
-    it 'should work' do
-      # assertion here. ref: https://www.relishapp.com/rspec/rspec-expectations/docs/built-in-matchers
-    end
-  end
-
-end

data/spec/api/expectation_api_spec.rb

@@ -1,46 +0,0 @@
-=begin
-#Mock Server API
-
-#MockServer enables easy mocking of any system you integrate with via HTTP or HTTPS with clients written in Java, JavaScript and Ruby and a simple REST API (as shown below).  MockServer Proxy is a proxy that introspects all proxied traffic including encrypted SSL traffic and supports Port Forwarding, Web Proxying (i.e. HTTP proxy), HTTPS Tunneling Proxying (using HTTP CONNECT) and SOCKS Proxying (i.e. dynamic port forwarding).  Both MockServer and the MockServer Proxy record all received requests so that it is possible to verify exactly what requests have been sent by the system under test.
-
-OpenAPI spec version: 5.3.0
-
-Generated by: https://openapi-generator.tech
-OpenAPI Generator version: 3.3.1
-
-=end
-
-require 'spec_helper'
-require 'json'
-
-# Unit tests for MockServer::ExpectationApi
-# Automatically generated by openapi-generator (https://openapi-generator.tech)
-# Please update as you see appropriate
-describe 'ExpectationApi' do
-  before do
-    # run before each test
-    @instance = MockServer::ExpectationApi.new
-  end
-
-  after do
-    # run after each test
-  end
-
-  describe 'test an instance of ExpectationApi' do
-    it 'should create an instance of ExpectationApi' do
-      expect(@instance).to be_instance_of(MockServer::ExpectationApi)
-    end
-  end
-
-  # unit tests for expectation_put
-  # create expectation
-  # @param expectations expectation to create
-  # @param [Hash] opts the optional parameters
-  # @return [nil]
-  describe 'expectation_put test' do
-    it 'should work' do
-      # assertion here. ref: https://www.relishapp.com/rspec/rspec-expectations/docs/built-in-matchers
-    end
-  end
-
-end

data/spec/api/verify_api_spec.rb

@@ -1,57 +0,0 @@
-=begin
-#Mock Server API
-
-#MockServer enables easy mocking of any system you integrate with via HTTP or HTTPS with clients written in Java, JavaScript and Ruby and a simple REST API (as shown below).  MockServer Proxy is a proxy that introspects all proxied traffic including encrypted SSL traffic and supports Port Forwarding, Web Proxying (i.e. HTTP proxy), HTTPS Tunneling Proxying (using HTTP CONNECT) and SOCKS Proxying (i.e. dynamic port forwarding).  Both MockServer and the MockServer Proxy record all received requests so that it is possible to verify exactly what requests have been sent by the system under test.
-
-OpenAPI spec version: 5.3.0
-
-Generated by: https://openapi-generator.tech
-OpenAPI Generator version: 3.3.1
-
-=end
-
-require 'spec_helper'
-require 'json'
-
-# Unit tests for MockServer::VerifyApi
-# Automatically generated by openapi-generator (https://openapi-generator.tech)
-# Please update as you see appropriate
-describe 'VerifyApi' do
-  before do
-    # run before each test
-    @instance = MockServer::VerifyApi.new
-  end
-
-  after do
-    # run after each test
-  end
-
-  describe 'test an instance of VerifyApi' do
-    it 'should create an instance of VerifyApi' do
-      expect(@instance).to be_instance_of(MockServer::VerifyApi)
-    end
-  end
-
-  # unit tests for verify_put
-  # verify a request has been received a specific number of times
-  # @param verification request matcher and the number of times to match
-  # @param [Hash] opts the optional parameters
-  # @return [nil]
-  describe 'verify_put test' do
-    it 'should work' do
-      # assertion here. ref: https://www.relishapp.com/rspec/rspec-expectations/docs/built-in-matchers
-    end
-  end
-
-  # unit tests for verify_sequence_put
-  # verify a sequence of request has been received in the specific order
-  # @param verification_sequence the sequence of requests matchers
-  # @param [Hash] opts the optional parameters
-  # @return [nil]
-  describe 'verify_sequence_put test' do
-    it 'should work' do
-      # assertion here. ref: https://www.relishapp.com/rspec/rspec-expectations/docs/built-in-matchers
-    end
-  end
-
-end

data/spec/api_client_spec.rb

@@ -1,226 +0,0 @@
-=begin
-#Mock Server API
-
-#MockServer enables easy mocking of any system you integrate with via HTTP or HTTPS with clients written in Java, JavaScript and Ruby and a simple REST API (as shown below).  MockServer Proxy is a proxy that introspects all proxied traffic including encrypted SSL traffic and supports Port Forwarding, Web Proxying (i.e. HTTP proxy), HTTPS Tunneling Proxying (using HTTP CONNECT) and SOCKS Proxying (i.e. dynamic port forwarding).  Both MockServer and the MockServer Proxy record all received requests so that it is possible to verify exactly what requests have been sent by the system under test.
-
-OpenAPI spec version: 5.3.0
-
-Generated by: https://openapi-generator.tech
-OpenAPI Generator version: 3.3.1
-
-=end
-
-require 'spec_helper'
-
-describe MockServer::ApiClient do
-  context 'initialization' do
-    context 'URL stuff' do
-      context 'host' do
-        it 'removes http from host' do
-          MockServer.configure { |c| c.host = 'http://example.com' }
-          expect(MockServer::Configuration.default.host).to eq('example.com')
-        end
-
-        it 'removes https from host' do
-          MockServer.configure { |c| c.host = 'https://wookiee.com' }
-          expect(MockServer::ApiClient.default.config.host).to eq('wookiee.com')
-        end
-
-        it 'removes trailing path from host' do
-          MockServer.configure { |c| c.host = 'hobo.com/v4' }
-          expect(MockServer::Configuration.default.host).to eq('hobo.com')
-        end
-      end
-
-      context 'base_path' do
-        it "prepends a slash to base_path" do
-          MockServer.configure { |c| c.base_path = 'v4/dog' }
-          expect(MockServer::Configuration.default.base_path).to eq('/v4/dog')
-        end
-
-        it "doesn't prepend a slash if one is already there" do
-          MockServer.configure { |c| c.base_path = '/v4/dog' }
-          expect(MockServer::Configuration.default.base_path).to eq('/v4/dog')
-        end
-
-        it "ends up as a blank string if nil" do
-          MockServer.configure { |c| c.base_path = nil }
-          expect(MockServer::Configuration.default.base_path).to eq('')
-        end
-      end
-    end
-  end
-
-  describe 'params_encoding in #build_request' do
-    let(:config) { MockServer::Configuration.new }
-    let(:api_client) { MockServer::ApiClient.new(config) }
-
-    it 'defaults to nil' do
-      expect(MockServer::Configuration.default.params_encoding).to eq(nil)
-      expect(config.params_encoding).to eq(nil)
-
-      request = api_client.build_request(:get, '/test')
-      expect(request.options[:params_encoding]).to eq(nil)
-    end
-
-    it 'can be customized' do
-      config.params_encoding = :multi
-      request = api_client.build_request(:get, '/test')
-      expect(request.options[:params_encoding]).to eq(:multi)
-    end
-  end
-
-  describe 'timeout in #build_request' do
-    let(:config) { MockServer::Configuration.new }
-    let(:api_client) { MockServer::ApiClient.new(config) }
-
-    it 'defaults to 0' do
-      expect(MockServer::Configuration.default.timeout).to eq(0)
-      expect(config.timeout).to eq(0)
-
-      request = api_client.build_request(:get, '/test')
-      expect(request.options[:timeout]).to eq(0)
-    end
-
-    it 'can be customized' do
-      config.timeout = 100
-      request = api_client.build_request(:get, '/test')
-      expect(request.options[:timeout]).to eq(100)
-    end
-  end
-
-  describe '#deserialize' do
-    it "handles Array<Integer>" do
-      api_client = MockServer::ApiClient.new
-      headers = { 'Content-Type' => 'application/json' }
-      response = double('response', headers: headers, body: '[12, 34]')
-      data = api_client.deserialize(response, 'Array<Integer>')
-      expect(data).to be_instance_of(Array)
-      expect(data).to eq([12, 34])
-    end
-
-    it 'handles Array<Array<Integer>>' do
-      api_client = MockServer::ApiClient.new
-      headers = { 'Content-Type' => 'application/json' }
-      response = double('response', headers: headers, body: '[[12, 34], [56]]')
-      data = api_client.deserialize(response, 'Array<Array<Integer>>')
-      expect(data).to be_instance_of(Array)
-      expect(data).to eq([[12, 34], [56]])
-    end
-
-    it 'handles Hash<String, String>' do
-      api_client = MockServer::ApiClient.new
-      headers = { 'Content-Type' => 'application/json' }
-      response = double('response', headers: headers, body: '{"message": "Hello"}')
-      data = api_client.deserialize(response, 'Hash<String, String>')
-      expect(data).to be_instance_of(Hash)
-      expect(data).to eq(:message => 'Hello')
-    end
-  end
-
-  describe "#object_to_hash" do
-    it 'ignores nils and includes empty arrays' do
-      # uncomment below to test object_to_hash for model
-      # api_client = MockServer::ApiClient.new
-      # _model = MockServer::ModelName.new
-      # update the model attribute below
-      # _model.id = 1
-      # update the expected value (hash) below
-      # expected = {id: 1, name: '', tags: []}
-      # expect(api_client.object_to_hash(_model)).to eq(expected)
-    end
-  end
-
-  describe '#build_collection_param' do
-    let(:param) { ['aa', 'bb', 'cc'] }
-    let(:api_client) { MockServer::ApiClient.new }
-
-    it 'works for csv' do
-      expect(api_client.build_collection_param(param, :csv)).to eq('aa,bb,cc')
-    end
-
-    it 'works for ssv' do
-      expect(api_client.build_collection_param(param, :ssv)).to eq('aa bb cc')
-    end
-
-    it 'works for tsv' do
-      expect(api_client.build_collection_param(param, :tsv)).to eq("aa\tbb\tcc")
-    end
-
-    it 'works for pipes' do
-      expect(api_client.build_collection_param(param, :pipes)).to eq('aa|bb|cc')
-    end
-
-    it 'works for multi' do
-      expect(api_client.build_collection_param(param, :multi)).to eq(['aa', 'bb', 'cc'])
-    end
-
-    it 'fails for invalid collection format' do
-      expect(proc { api_client.build_collection_param(param, :INVALID) }).to raise_error(RuntimeError, 'unknown collection format: :INVALID')
-    end
-  end
-
-  describe '#json_mime?' do
-    let(:api_client) { MockServer::ApiClient.new }
-
-    it 'works' do
-      expect(api_client.json_mime?(nil)).to eq false
-      expect(api_client.json_mime?('')).to eq false
-
-      expect(api_client.json_mime?('application/json')).to eq true
-      expect(api_client.json_mime?('application/json; charset=UTF8')).to eq true
-      expect(api_client.json_mime?('APPLICATION/JSON')).to eq true
-
-      expect(api_client.json_mime?('application/xml')).to eq false
-      expect(api_client.json_mime?('text/plain')).to eq false
-      expect(api_client.json_mime?('application/jsonp')).to eq false
-    end
-  end
-
-  describe '#select_header_accept' do
-    let(:api_client) { MockServer::ApiClient.new }
-
-    it 'works' do
-      expect(api_client.select_header_accept(nil)).to be_nil
-      expect(api_client.select_header_accept([])).to be_nil
-
-      expect(api_client.select_header_accept(['application/json'])).to eq('application/json')
-      expect(api_client.select_header_accept(['application/xml', 'application/json; charset=UTF8'])).to eq('application/json; charset=UTF8')
-      expect(api_client.select_header_accept(['APPLICATION/JSON', 'text/html'])).to eq('APPLICATION/JSON')
-
-      expect(api_client.select_header_accept(['application/xml'])).to eq('application/xml')
-      expect(api_client.select_header_accept(['text/html', 'application/xml'])).to eq('text/html,application/xml')
-    end
-  end
-
-  describe '#select_header_content_type' do
-    let(:api_client) { MockServer::ApiClient.new }
-
-    it 'works' do
-      expect(api_client.select_header_content_type(nil)).to eq('application/json')
-      expect(api_client.select_header_content_type([])).to eq('application/json')
-
-      expect(api_client.select_header_content_type(['application/json'])).to eq('application/json')
-      expect(api_client.select_header_content_type(['application/xml', 'application/json; charset=UTF8'])).to eq('application/json; charset=UTF8')
-      expect(api_client.select_header_content_type(['APPLICATION/JSON', 'text/html'])).to eq('APPLICATION/JSON')
-      expect(api_client.select_header_content_type(['application/xml'])).to eq('application/xml')
-      expect(api_client.select_header_content_type(['text/plain', 'application/xml'])).to eq('text/plain')
-    end
-  end
-
-  describe '#sanitize_filename' do
-    let(:api_client) { MockServer::ApiClient.new }
-
-    it 'works' do
-      expect(api_client.sanitize_filename('sun')).to eq('sun')
-      expect(api_client.sanitize_filename('sun.gif')).to eq('sun.gif')
-      expect(api_client.sanitize_filename('../sun.gif')).to eq('sun.gif')
-      expect(api_client.sanitize_filename('/var/tmp/sun.gif')).to eq('sun.gif')
-      expect(api_client.sanitize_filename('./sun.gif')).to eq('sun.gif')
-      expect(api_client.sanitize_filename('..\sun.gif')).to eq('sun.gif')
-      expect(api_client.sanitize_filename('\var\tmp\sun.gif')).to eq('sun.gif')
-      expect(api_client.sanitize_filename('c:\var\tmp\sun.gif')).to eq('sun.gif')
-      expect(api_client.sanitize_filename('.\sun.gif')).to eq('sun.gif')
-    end
-  end
-end

data/spec/configuration_spec.rb

@@ -1,42 +0,0 @@
-=begin
-#Mock Server API
-
-#MockServer enables easy mocking of any system you integrate with via HTTP or HTTPS with clients written in Java, JavaScript and Ruby and a simple REST API (as shown below).  MockServer Proxy is a proxy that introspects all proxied traffic including encrypted SSL traffic and supports Port Forwarding, Web Proxying (i.e. HTTP proxy), HTTPS Tunneling Proxying (using HTTP CONNECT) and SOCKS Proxying (i.e. dynamic port forwarding).  Both MockServer and the MockServer Proxy record all received requests so that it is possible to verify exactly what requests have been sent by the system under test.
-
-OpenAPI spec version: 5.3.0
-
-Generated by: https://openapi-generator.tech
-OpenAPI Generator version: 3.3.1
-
-=end
-
-require 'spec_helper'
-
-describe MockServer::Configuration do
-  let(:config) { MockServer::Configuration.default }
-
-  before(:each) do
-    # uncomment below to setup host and base_path
-    # require 'URI'
-    # uri = URI.parse("http://localhost:1080")
-    # MockServer.configure do |c|
-    #   c.host = uri.host
-    #   c.base_path = uri.path
-    # end
-  end
-
-  describe '#base_url' do
-    it 'should have the default value' do
-      # uncomment below to test default value of the base path
-      # expect(config.base_url).to eq("http://localhost:1080")
-    end
-
-    it 'should remove trailing slashes' do
-      [nil, '', '/', '//'].each do |base_path|
-        config.base_path = base_path
-        # uncomment below to test trailing slashes
-        # expect(config.base_url).to eq("http://localhost:1080")
-      end
-    end
-  end
-end