mockserver-client 1.0.8.pre → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 5949e6484134d15b965631dad80fde5bce36b48b
-  data.tar.gz: 11dbadd346eae086b0b93e981d9f4b55e6900bed
+SHA256:
+  metadata.gz: 52c92809897fcdfe317afdab740419e5bef114b46482df4a9756821916bd4a73
+  data.tar.gz: 8b8ee1a6a5c341edecbe70a90ccb1dda4c481162eca2f30e83ee121beaa656d5
 SHA512:
-  metadata.gz: 7404475b6281eef548a4c27baf6397c47a3bfb0d7de8a2154ac3d0c92e4b85a2429a0c8aafca47918dc0f2a158154cefd7dfc61e11d94182a9cdb69b25e382d6
-  data.tar.gz: 16776ab334b6690eec900c3cf694902e3c2119617d18339ba2af621296b3af1f0f0eb7b631486277c538e3802f0662e4853578a9c606c6ef4ca747321c7e81ac
+  metadata.gz: 476994411a429882a93e0fe6852527b14ac9ce60ffc2ac328f0536eef2adee69f7c2ce8061bc8dfda7cc32869fe0e227ed3f5e979a3a1e1513c1ae3540be2f27
+  data.tar.gz: 94828363b6159101e0288c15b604e7e9acf19716f67efb5edf56f591a79946aaf987ed2c32f079f421d3ad74045d61fa0aac62b93820d162df3299b284108cd7

data/Gemfile

@@ -1,4 +1,5 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
-# Gem's dependencies in mockserver-client.gemspec
 gemspec

data/README.md

@@ -1,260 +1,112 @@
-# Mockserver Client
+# MockServer Ruby Client
 
-A Ruby client for [MockServer](http://www.mock-server.com) project. This client follows the Java client's fluent style closely by using Ruby blocks.
+Hand-written Ruby client for [MockServer](https://www.mock-server.com) with full REST API, fluent builder DSL, and WebSocket callback support.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Add to your Gemfile:
 
 ```ruby
-gem 'mockserver-client'
+gem 'mockserver-client', '~> 5.16'
 ```
 
-And then execute:
-
-```bash
-bundle
-```
-
-Or install it yourself as:
+Or install directly:
 
 ```bash
 gem install mockserver-client
 ```
 
-## Usage
-
-The usage notes here compare the Java syntax with the Ruby DSL for the various actions the MockServer client/proxy client supports. The Ruby code here assumes you have included `MockServer` and `MockServer::Model::DSL` modules. So these lines should  typically be at the top of your code:
+## Quick Start
 
 ```ruby
-include MockServer
-include MockServer::Model::DSL
-```
-
-### Create Expectations
-
-##### Java
-
-```java
-new MockServerClient("localhost", 9999)
-        .when(
-                request()
-                        .withMethod("POST")
-                        .withPath("/login")
-                        .withQueryStringParameters(
-                                new Parameter("returnUrl", "/account")
-                        )
-                        .withCookies(
-                                new Cookie("sessionId", "2By8LOhBmaW5nZXJwcmludCIlMDAzMW")
-                        )
-                        .withBody("{username: 'foo', password: 'bar'}"),
-                Times.exactly(1)
-        )
-        .respond(
-                response()
-                        .withStatusCode(401)
-                        .withHeaders(
-                                new Header("Content-Type", "application/json; charset=utf-8"),
-                                new Header("Cache-Control", "public, max-age=86400")
-                        )
-                        .withBody("{ message: 'incorrect username and password combination' }")
-                        .withDelay(new Delay(TimeUnit.SECONDS, 1))
-        );
+require 'mockserver-client'
+
+# Create a client
+client = MockServer::Client.new('localhost', 1080)
+
+# Set up an expectation using the fluent API
+client.when(
+  MockServer::HttpRequest.request(path: '/hello')
+    .with_method('GET')
+).respond(
+  MockServer::HttpResponse.response(body: 'world', status_code: 200)
+)
+
+# Verify a request was received
+client.verify(
+  MockServer::HttpRequest.request(path: '/hello'),
+  times: MockServer::VerificationTimes.at_least(1)
+)
+
+# Clean up
+client.reset
+client.close
 ```
 
-##### Ruby
+## Block Form
 
 ```ruby
-client = MockServerClient.new('localhost', 9999)
-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'}")
-     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' }")
-        response.delay = delay_by(:SECONDS, 1)
-    end
+MockServer::Client.new('localhost', 1080) do |client|
+  client.when(
+    MockServer::HttpRequest.request(path: '/api/test')
+  ).respond(
+    MockServer::HttpResponse.response(body: '{"status":"ok"}', status_code: 200)
+  )
 end
-client.register(expectation)
-```
-
-### Clear & Reset Server
-
-##### Java
-
-```java
-mockServerClient.clear(
-        request()
-                .withMethod("POST")
-                .withPath("/login")
-);
-mockServerClient.reset();
+# Client is automatically closed when the block exits
 ```
 
-##### Ruby
-
- ```ruby
- client.clear(request('POST', '/login'))
- client.reset
- ```
-### Verifying Behavior
-
-##### Java
-
-```java
-new ProxyClient("localhost", 9090).verify(
-        request()
-                .withMethod("POST")
-                .withPath("/login")
-                .withBody(exact("{username: 'foo', password: 'bar'}"))
-                .withCookies(
-                        new Cookie("sessionId", ".*")
-                ),
-        Times.exactly(1)
-);
-```
-
-##### Ruby
+## WebSocket Callbacks
 
 ```ruby
-# Not providing times here because the default is exactly(1) i.e. the second argument to verify method
-ProxyClient.new('localhost', 9090).verify(request(:POST, '/login') do |request|
-    request.body = exact("{username: 'foo', password: 'bar'}")
-    request.cookies = [cookie("sessionId", ".*")]
-end)
+client = MockServer::Client.new('localhost', 1080)
+
+# Response callback - dynamically generate responses
+client.mock_with_callback(
+  MockServer::HttpRequest.request(path: '/dynamic'),
+  ->(request) {
+    MockServer::HttpResponse.new(
+      status_code: 200,
+      body: "Echo: #{request.path}"
+    )
+  }
+)
+
+# Forward callback - modify requests before forwarding
+client.mock_with_forward_callback(
+  MockServer::HttpRequest.request(path: '/proxy'),
+  ->(request) {
+    request.with_header('X-Proxied', 'true')
+  }
+)
+
+client.close
 ```
 
+## Models
 
-### Analyzing Behavior
-
-##### Java
-
-```java
-new ProxyClient("localhost", 9090).dumpToLogAsJava(
-        request()
-                .withMethod("POST")
-                .withPath("/login")
-);
-```
-
-##### Ruby
-
-```ruby
-# Second argument is true to set output to Java; false to set output to default JSON (default)
-ProxyClient.new('localhost', 9090).dump_log(request(:POST, '/login'), true)
-```
-
-## Complete Ruby DSL
-The DSL is provided via the `MockServer::Model::DSL` module. Include this module in your code to make the DSL available.
+All 25 domain model classes are available under the `MockServer` module:
 
-Request
-* **request**: Used to build a request object. If a block is passed, will configure request first and then return the configured request. Example: `request(:POST, '/login') {|r| r.headers << header("Content-Type", "application/json")}`.
-* **http_request**: Alias for `request`.
+- `Delay`, `Times`, `TimeToLive`
+- `KeyToMultiValue`, `Body`, `SocketAddress`
+- `HttpRequest`, `HttpResponse`, `HttpForward`, `HttpTemplate`
+- `HttpClassCallback`, `HttpObjectCallback`, `HttpError`
+- `HttpOverrideForwardedRequest`, `HttpRequestAndHttpResponse`
+- `ConnectionOptions`
+- `Expectation`, `ExpectationId`
+- `OpenAPIDefinition`, `OpenAPIExpectation`
+- `Verification`, `VerificationSequence`, `VerificationTimes`
+- `Ports`
+- `RequestDefinition` (alias for `HttpRequest`)
 
-Body
-* **body**: Create a string body object (use in a response). Example: `body("unaccepted")`.
-* **exact**: Create a body of type `STRING`. Example: `exact('{"reason": "unauthorized"}')`.
-* **regex**: Create a body of type `REGEX`. Example: `regex('username[a-z]{4}')`.
-* **xpath**: Used to create a body of type `XPATH`. Example: `xpath("/element[key = 'some_key' and value = 'some_value']")`.
-* **parameterized**; Create a body to type `PARAMETERS`. Example `parameterized(parameter('someValue', 1, 2), parameter('otherValue', 4, 5))`.
-
-Parameters
-* **parameter**: Create a generic parameter. Example: `parameter('key', 'value1' , 'value2')`.
-* **cookie**: Create a cookie (same as `parameter` above but exists as syntactic sugar). Example: `cookie('sessionId', 'sessionid1ldj')`.
-* **header**: Create a header (same as `parameter` above but exists as syntactic sugar). Example: `header('Content-Type', 'application/json')`.
-
-Forward
-* **forward**: Create a forwarding response. If a block is passed, will configure forward response first and then return the configured object. Example: `forward {|f| f.scheme = 'HTTPS' }`.
-* **http_forward**: Alias for `forward`.
-
-Response
-* **response**: Create a response object. If a block is passed, will configure response first and then return the configured response. Example: `response {|r| r.status_code = 201 }`.
-* **http_response**: Alias for `response`.
-
-Delay
-* **delay_by**. Create a delay object in a response. Example : `delay_by(:MICROSECONDS, 20)`.
-
-Times (used in Expectation)
-* **times**: Create an 'times' object. If a block is passed, will configure the object first before returning it. Example: `times {|t| t.unlimited = false }`.
-* **unlimited**: Create an object with unlimited repeats. Example: `unlimited()`. (No parameters).
-* **once**. Create an object that repeats only once. Example: `once()`. (No parameters).
-* **exactly**. Create an object that repeats exactly the number of times specified. Example: `exactly(2)`.
-* **at_least**: Create an object that repeats at least the given number of times. (Use in verify). Example: `at_least(2)`.
-
-Expectation (use in register)
-* **expectation**: Create an expectation object. If a block is passed, will configure the object first before returning it. Example: `expectation {|e| e.request {|r| r.path = "index.html} }`. 
-Getter methods for `request`, `response` and `forward` methods will optionally accept a block. If block is passed object is configured before it is returned. The attribute `times` has conventional getter and setter methods.
-
-## CLI
-
-This gem comes with a command line interface which allow you to run the Mock Server calls from the command line. When this gem is installed, you will have the `mockserver` executable on your PATH. Type `mockserver --help` and you will get this output: 
-
-```bash
-mockserver --help 
-
-Commands: 
-  mockserver clear           # Clears all stored mock request/responses from server.
-  mockserver dump_log        # Dumps the matching request to the mock server logs.
-  mockserver help [COMMAND]  # Describe available commands or one specific command
-  mockserver register        # Register an expectation with the mock server.
-  mockserver reset           # Resets the server clearing all data.
-  mockserver retrieve        # Retrieve the list of requests that have been made to the mock/proxy server.
-  mockserver verify          # Verify that a request has been made the specified number of times to the server.
-
-Options:
-  -h, --host=HOST    # The host for the MockServer client.
-                     # Default: localhost
-  -p, --port=N       # The port for the MockServer client.
-                     # Default: 8080
-  -d, [--data=DATA]  # A JSON or YAML file containing the request payload.
-```
-
-To get help for an individual command, e.g. `dump_log`, you would do:
-
-```bash
-mockserver --help dump_log
-
-Usage:
-  mockserver dump_log
-
-Options:
-  -j, [--java], [--no-java]  # A switch to turn Java format for logs on/off.
-  -h, --host=HOST            # The host for the MockServer client.
-                             # Default: localhost
-  -p, --port=N               # The port for the MockServer client.
-                             # Default: 8080
-  -d, [--data=DATA]          # A JSON or YAML file containing the request payload.
-
-Dumps the matching request to the mock server logs.
-```
-
-Here is an example on how you would run the command:
-
-```bash
-mockserver dump_log -j true
-
-Running with parameters:
-	host: localhost
-	port: 8080
-	java: true
-
-[2014-06-21 09:23:32] DEBUG [MockServerClient] Sending dump log request to mockserver
-[2014-06-21 09:23:32] DEBUG [MockServerClient] URL: /dumpToLog?type=java. Payload: {}
-[2014-06-21 09:23:32] DEBUG [MockServerClient] Got dump to log response: 202
-```
+## License
 
-# Issues
+Apache-2.0
 
-If you have any problems, please [check the project issues](https://github.com/jamesdbloom/mockserver/issues?state=open).
+## AI Assistant Integration
 
-# Contributions
+MockServer includes a built-in [MCP](https://modelcontextprotocol.io) (Model Context Protocol) server that enables AI coding assistants to create expectations, verify requests, and debug HTTP traffic programmatically.
 
-Pull requests are, of course, very welcome! Please read our [contributing to the project](https://github.com/jamesdbloom/mockserver/wiki/Contributing-to-the-project) guide first. Then head over to the [open issues](https://github.com/jamesdbloom/mockserver/issues?state=open) to see what we need help with. Make sure you let us know if you intend to work on something. Also, check out the [milestones](https://github.com/jamesdbloom/mockserver/issues/milestones) to see what is planned for future releases.
+- **MCP Endpoint:** `http://localhost:1080/mockserver/mcp`
+- **AI Documentation:** [llms.txt](https://www.mock-server.com/llms.txt)
+- **Setup Guide:** [AI Integration](https://www.mock-server.com/mock_server/ai_mcp_setup.html)