NewYour coding agent can read the release notes before it upgrades.Set up the MCP server →
Go modules, #749 by repository stars
Latest stable
v1.12.17
Last release 20 days ago
01 Nov 2026
Ships fairly regularly
a new release about every 3 weeks
Nearly every release is documented
notes for 58 of the last 60 stable releases
Nothing withdrawn
no release was ever pulled
11 years old
195 releases · first in 2015
Drag across the ruler to compare, or tap a release to open it.
Bug fixes and supports templating using request header, eg. {{ Request.Header.X-Header-Id }}
Bug fixes and supports templating using request header, eg. {{ Request.Header.X-Header-Id }}
A universal date time templating helper is added:
A universal date time templating helper is added:
{{ now "<offset>" "<format>" }}
It generates current date time with an offset in any custom format or Unix timestamp. More info can be found in the doc.
Thanks to @kulaginds' PR, you can now use templating functions in the response headers.
Your coding agent can read these notes before it upgrades. Set up the MCP server →
Thanks to @kulaginds' PR, you can now use templating functions in the response headers.
Nothing published for this version
Hoverfly by default ignores repeated requests when capturing. Using the following flag, you can set Hoverfly to capture the new request-response pair
Hoverfly by default ignores repeated requests when capturing. Using the following flag, you can set Hoverfly to capture the new request-response pair by overwriting the old one.
hoverctl mode capture --overwrite-duplicate
Thanks to @aosavitski's PR, the performance of stateful simulation has been improved. This release also fixed the following bugs: https://github.com/SpectoLabs/hoverfly/issues/868 https://github.com/SpectoLabs/hoverfly/issues/865
You can now enable Cross-Origin Resource Sharing (CORS) support on hoverfly. Your web application running on the browser can make requests to Hoverfly
You can now enable Cross-Origin Resource Sharing (CORS) support on hoverfly. Your web application running on the browser can make requests to Hoverfly even it’s not on the same domain.
hoverfly -cors
or
hoverctl start --cors
For more information, please see the docs.
Some users experience slow import for large simulation file (a few hundred MBs with lots of pairs), you can speed it up by disabling the duplicate request checking feature:
hoverfly -no-import-check
or
hoverctl start --no-import-check
A response proxied by Hoverfly contains header Hoverfly: Was-Here. In this release, we are adding Hoverfly: Forwarded to it if a request is not simulated but forwarded to the remote service in SPY mode.
We have added a new helper method for string find and replace: ` {{ replace string oldValue newValue }} For example, you can solve the problem in issu
We have added a new helper method for string find and replace:
{{ replace string oldValue newValue }}
For example, you can solve the problem in issue https://github.com/SpectoLabs/hoverfly/issues/841 with this templating function which replaces all occurrences of "_token" in the query params with an empty string.
{{ replace Request.QueryParam.access_token.[0] "_token" "" }}
You can now import multiple simulations when you start hoverfly using hoverctl :
hoverctl start --import foo.json --import bar.json
This is equivalent to the following hoverfly command:
hoverfly -import foo.json -import bar.json
You can also add additional simulations after hoverfly is started:
hoverctl simulation add foo.json bar.json
This release also fixes the following bugs:
After the previous two RC versions, we are so excited to finally release Hoverfly v1.0.0. We really appreciate all the contributions and feedback from
After the previous two RC versions, we are so excited to finally release Hoverfly v1.0.0. We really appreciate all the contributions and feedback from the community!
A big thanks to @dilitvinov, a new matcher (jsonPartial) is available to let you partially match a JSON document. You can find out more here here.
Some APIs use HTTP response trailers, and we have implemented a solution to capture them as normal headers:
"response" : {
"headers" : {
"Trailer": ["X-Streaming-Error"],
"X-Streaming-Error" : [ "Connection Closed" ]
}
}
Hoverfly Helm chart has been accepted into the official Helm incubator repository.
You can simply run the following command to deploy Hoverfly into your Kubernetes cluster:
helm install incubator/hoverfly
You can find more details in the doc.
Thanks to @rusenask, the Hoverfly v1.0.0 Docker image will be much slimmer as it based on Alpine, and the Dockerfile uses multi-stage build.
Nothing published for this version
Nothing published for this version
Nothing published for this version
This release improves performance. These improvements will save both CPU time and reduce latency, in some cases by a significant margin. Thanks to the
This release improves performance. These improvements will save both CPU time and reduce latency, in some cases by a significant margin. Thanks to the Hoverfly community for their assistance in identifying and fixing these issues.
$ hoverfly -cache-size 100
Fixed an issue which prevented hoverctl controlling a remote hoverfly running in a Docker container: https://github.com/SpectoLabs/hoverfly/issues/801
Nothing published for this version
It lays a good foundation for us to implement matcher chaining to solve XML/JSON matching issues without introducing breaking changes. That's when we…
Happy Friday! We are thrilled to announce an RC release of v1.0.0!
The v5 simulation schema introduced since v0.17.0 is stable and easy to extend for more powerful request matchers. It lays a good foundation for us to implement matcher chaining to solve XML/JSON matching issues without introducing breaking changes. That's when we start considering a Hoverfly v1 release.
Thank you for all your contributions, we are hoping to work with you again on more exciting features in the coming months, and make Hoverfly shines!
Thanks to @podtserkovskiy's contribution, you can now enable random delay in a simulation based on log-normal distribution. Here is an example:
"globalActions": {
"delaysLogNormal": [
{
"urlPattern": ".",
"httpMethod": "",
"min": 100,
"max": 10000,
"mean": 5000,
"median": 500
}
]
}
where mean and median values could be calculated from your actual server response times, and Hoverfly generate random latencies that are lognormally distributed based on these parameters.
Default log level of Hoverfly is info, but if you prefer less noise or a bit concern about the performance overheads of info logging, you can control the log level with this release:
$ hoverfly -log-level warn
Which logs warning level or above (error, fatal and panic)
Some long-standing bugs have been addressed in this release, such as bugs that affect multi-value query capture, config.yaml loading and plain HTTP tunnelling.
https://github.com/SpectoLabs/hoverfly/issues/704 https://github.com/SpectoLabs/hoverfly/issues/752 https://github.com/SpectoLabs/hoverfly/issues/786 https://github.com/SpectoLabs/hoverfly/issues/792
Nothing published for this version
This is a pure bugfix release to address the following issues:
This is a pure bugfix release to address the following issues:
While we helped the community with load testing issues using hoverfly, we fixed a few bugs causing hoverfly to crash under load. This includes transistive bugs from an old version of logrus, concurrent read/write access to map, and usage counter failed to update in webserver mode(https://github.com/SpectoLabs/hoverfly/issues/776)
This bug can be confusing when you need to debug an unmatched request. As reported by hoverfly-java users https://github.com/SpectoLabs/hoverfly-java/issues/187, the query parameters are duplicated in the closest-match debug message.
A huge thanks to @xiang-zhu's PR, Hoverfly finally has support for two-way SSL authentication. This new feature lets you capture or spy an HTTPS serve
A huge thanks to @xiang-zhu's PR, Hoverfly finally has support for two-way SSL authentication. This new feature lets you capture or spy an HTTPS server that requires this authentication method. You can provide certificate key, client certificate and CA certificate with the following flags when starting hoverfly:
--client-authentication-client-key
--client-authentication-client-cert
--client-authentication-ca-cert
You must also provide a host pattern using --client-authentication-destination flag to tell Hoverfly which request hosts should be called using this authentication method.
Thanks again to @john4744 for fixing a concurrency issue when doing stateful capture. Hoverfly should now generate the correct state values when capturing concurrent requests.
Thanks again to @john4744 for spotting and fixing a bug in the state part of Hoverfly. Hoverfly did not use any locks on the state, meaning there coul
Thanks again to @john4744 for spotting and fixing a bug in the state part of Hoverfly. Hoverfly did not use any locks on the state, meaning there could be concurrency issues with multiple requests and responses using and modifying state.
A bug was noticed regarding warnings when importing simulations with Content-Length headers on the responses with encoded bodies. This has now been fixed.
We have added support for configuring Hoverfly with a PAC file which now allows users to dynamically change upstream proxies. Our support of PAC files
We have added support for configuring Hoverfly with a PAC file which now allows users to dynamically change upstream proxies. Our support of PAC files is fairly primitive for now, offering support for DIRECT and PROXY commands. We currently do not support fallback upstream proxies such as PROXY proxy1.org.corp; PROXY proxy1.org.corp.
The PAC file can be imported to Hoverfly through a PUT request to /api/v2/hoverfly/pac or through the use of hoverctl.
hoverctl start --pac-file path/to/file.pac
For more information on Using Hoverfly behind a proxy
Thanks to @john4744 for spotting and fixing a bug in stateful capture. This should now be resolved.
…forcing users to have to remain using the deprecated query field from v4. This was captured is in issue #750. This version should now support zero que…
We have updated templating again! This time, we've the ability to use parts of the request body in your response. This is done using jsonpath and xpath.
{{ Request.Body “jsonpath” “$.test” }}
{{ Request.Body “xpath” “/root/id” }}
These templating functions will retrieve parts of the document from the request based off of the query provided.
For more information on Template helpers
With the introduction of the v5 schema, we temporarily lost the ability to define a request with zero query parameters, forcing users to have to remain using the deprecated query field from v4. This was captured is in issue #750. This version should now support zero query parameters correctly.
From user feedback, we found some users were struggling to make sense of the changes being outputted in diff mode due to the constantly changing headers, often headers that the user did not care had changed.
We have updated diff mode to now support the ability to filter out headers. These are defined simiarly to how you would define capturing headers when setting the mode to capture.
hoverctl mode diff --headers Content-Type,Authorization
hoverctl mode diff --all-headers
We have introduced a few new template helper methods. These helpers allow you to generate date times that can be offset from the time the response is
We have introduced a few new template helper methods. These helpers allow you to generate date times that can be offset from the time the response is served and can also be formatted using Golang date time formats.
For more information on Template helpers
There was regression in Hoverfly regarding the Content-Length and Transfer-Encoding headers being sent when using Hoverfly with HTTPs. This is against
There was regression in Hoverfly regarding the Content-Length and Transfer-Encoding headers being sent when using Hoverfly with HTTPs. This is against the HTTP specification, resulting in some clients throwing errors, such as in issue https://github.com/SpectoLabs/hoverfly/issues/727. This should now be resolved.
We have introduced some new template helper methods. These helpers allow you to generate random data and support several different data formats. If you have any ideas for additional template helper methods, feel free to raise an issue against Hoverfly and suggest them.
For more information on Template helpers)
…will now get moved to a new query field called deprecatedQuery. We intend to remove this field at some point in time, but we hope everyone will be abl…
We have introduced a new version of the schema. This new version changes both request queries and request headers.
We have updated the format of matchers. The reasoning behind this was to make them more flexible and easier to extend in the future.
{
"matcher": "exact",
"value": "new-matcher"
}
We have updated Headers to now allow for the user of matchers, previously, header values were defined as strings.
"headers": {
"Content-Type": [
"application/json"
]
}
In v5, you now use matchers, bringing it more inline with the other fields of a request.
"headers": {
"Content-Type": [
{
"matcher": "exact",
"value": "application/json"
}
]
}
We have also updated the request query field to match headers. Previously, queries were represented as strings, which didn't make much sense considering how we represented headers.
"query": [
{
"matcher": "exact",
"value": "testQuery=testValue"
}
]
Now, they follow the same structure as request headers. This should allow for easier matching using different matchers.
"query": {
"testQuery": [
{
"matcher": "exact",
"value": "testValue"
}
]
}
A downside to this that existing queries from older simulations will now get moved to a new query field called deprecatedQuery. We intend to remove this field at some point in time, but we hope everyone will be able to update their simulations to adopt this new query structure before we remove it.
With the introduction of a temporary field that is marked as deprecated, we have also updated the simulation import API and hoverctl to now warn users if their simulations contain deprecated fields. This warning is just a warning and does not interfere with the importing process, so it is possible to ignore this until a time that suits you best.
For more information on Deprecated Queries
We have updated capture mode to now support the capturing of multiple request response pairs using the same request. This now means you can record stateful services and iterate through the recorded responses. This behaviour is not default and you will need to enable it when going into capture mode.
hoverctl mode capture --stateful
For more information on Sequences For a tutorial on Sequences
Thanks to @MatousJobanek for adding a new mode to Hoverfly. By switching Hoverfly into diff mode, you can now execute requests against Hoverfly and it
Thanks to @MatousJobanek for adding a new mode to Hoverfly. By switching Hoverfly into diff mode, you can now execute requests against Hoverfly and it will work out the difference between the original service's response and the response stored in the simulation.
hoverctl mode capture
curl http://time.jsontest.com --proxy http://localhost:8500
hoverctl mode diff
curl http://time.jsontest.com --proxy http://localhost:8500
hoverctl diff get
We have switched all JSON path matching in Hoverfly to now use k8s.io/client-go/util/jsonpath. The end result should be better JSON path matching that should support more queries.
Content-Length headerIncludes the latest Hoverfly Dashboard, with Spy mode toggle and some optimisation and security fix.
hoverctl now lets you selectively export simulations, instead of exporting everything into one big JSON file. You can use —url-pattern flag with a plain text string or regex string to do the filtering. It can filter on hostname(destination) and path.
$ hoverctl export echo.json --url-pattern "echo.jsontest.com" // export simulations for echo.jsontest.com only
$ hoverctl export api.json --url-pattern "(.+).jsontest.com" // export simulations for all jsontest.com subdomains
The Get Journal API is default to return the last 25 journal logs only, and you can control the paging using offset and limit query parameters. You can also query the requests made within a time window using from and to query parameters. The time queries support Unix timestamp.
Thanks to @3sunnysideup, Hoverfly has a new spy mode. When it is set, Hoverfly will only simulate the APIs that you have defined, and call real APIs f
Thanks to @3sunnysideup, Hoverfly has a new spy mode. When it is set, Hoverfly will only simulate the APIs that you have defined, and call real APIs for anything else. It is deemed useful if the service under test has different external dependencies, and you want to spy on particular endpoints only. To use this new feature, simply set:
$ hoverctl mode spy
This setting allows Hoverfly to handle CONNECT requests for non-TLS tunnelling, making it possible to use Hoverly with Netty-based HTTP client such as reactor-netty.
$ hoverfly -plain-http-tunneling
Hoverfly now binds to loopback interface by default and prevents firewall alerts being triggered when running on Windows machine. If you still need Hoverfly to listen on all the network interfaces, you can do so by setting:
$ hoverfly -listen-on-host 0.0.0.0
hoverctl statusis now showing if Hoverfly is running on proxy or webserver mode$ docker run -d -p 8888:8888 -p 8500:8500 spectolabs/hoverfly -webserverAdded helper methods to use current data time for templating.
Thanks to @joostvanwollingen, you can now add bash completion file for hoverctl by running:
hoverctl completion
In this minor release, we fixed a few bugs:
In this minor release, we fixed a few bugs:
There are some improvements including:
hoverctl status command which prints the status of HoverflyThe big addition to v0.14.0 is the introduction of state. Hoverfly stores state as a key value map, allowing for multiple states to be stored at any g
The big addition to v0.14.0 is the introduction of state. Hoverfly stores state as a key value map, allowing for multiple states to be stored at any given time. This state can then be used as a matching requirement for requests and can be modified with successful responses served.
More information on state is available here.
Hoverfly finally has the ability to produce dynamic responses with the new templating feature. This feature allows for values from the original reques
Hoverfly finally has the ability to produce dynamic responses with the new templating feature. This feature allows for values from the original request being included in the response body through the use of template tags.
For more information on Templating
With the introduction of templating, we have bumped the simulation schema version up to v3. The two changes between v2 and v3 are that the request query field no longer requires character escaping and a new boolean template field on the response to enable templating on a per request response pair basis.
It was noticed that the journal was no working when using Hoverfly as a webserver. This has been fixed and should now behave the same regardless if using Hoverfly as a webserver or a proxy.
In the last release, we added the journal API. This API could be used for seeing the requests and responses being served by Hoverfly. There was an old
requestType field in journal API responsesIn the last release, we added the journal API. This API could be used for seeing the requests and responses being served by Hoverfly. There was an old, unused field being used in the request object. This field has now been removed.
In preparation for the next big release of Hoverfly, we noticed a bug. When importing simulations, Hoverfly did not provide a useful error when importing a simulation using an unsupported schema version. This has now been fixed.
To give more visibility as to what Hoverfly is up to, we have introduced a record of all requests and responses being served by Hoverfly. This can be
To give more visibility as to what Hoverfly is up to, we have introduced a record of all requests and responses being served by Hoverfly. This can be found via the new admin API endpoint /api/v2/journal. Along with the requests and responses, metadata for each request is also recorded. This includes latency observed by Hoverfly and the mode it was in. By default, the journal will store the last 1000 requests and responses. The size of the journal is modifiable via a new -journal-size flag.
With the introduction of the logs API several releases ago, and then the updating of the hoverctl logs command to use the API, we have now stopped hoverctl from writing logs to disk. If there are any .log files left you in your .hoverfly/ directory, they can now be deleted as they are no longer used by hoverctl.
We have fixed an issue involving caching. Hoverfly will cache each request/response it serves in an attempt to speed up matching, including failures to match. This bug occurred when trying to match using specific header values, something that the cache cannot do due to how we hash each request.
With this small release of Hoverfly, we have updated the logs. Previously, Hoverfly would log out to standard out using JSON formatting. This has been
With this small release of Hoverfly, we have updated the logs. Previously, Hoverfly would log out to standard out using JSON formatting. This has been updated to now use the plaintext format. If you depend on JSON formatted logs in standard out, there is now a -logs flag to set the format back to json. The logs API which can be found at /api/v2/logs will still output JSON formatted logs by default.
hoverfly -logs=json
We have expanded the logs API to now allow the ability to filter logs based on a UNIX timestamp. This can now be done by providing the from query parameter with a UNIX timestamp value. All logs returned will be after this point in time, making it easier to follow logs and only request new log entries.
With the introduction of plaintext log formatting to the logs API, a bug was noticed regarding the Content-Type header on responses from the Hoverfly API. Regardless of content, this header was always set to application/json. This has now been fixed so that the header is now correctly set regardless of response body content.
After several releases of bug fixes, we are finally ready to release the next big update to Hoverfly.
After several releases of bug fixes, we are finally ready to release the next big update to Hoverfly.
Before v0.12.0, when matching a request in simulate mode, the first match would be returned. This could often be a problem if looser request response pairs were defined at the top of a simulation.
To get around this, we have implemented a scoring system. Each match within a request will be scored and every request response pair from a simulation will now be checked. This should result in more accurate and reliable simulations.
It is still possible to use the previous matching strategy by using the --matching-strategy=first flag when setting the mode with hoverctl.
For more information on Matching strategies
With the introduction of scoring request response pairs to determine the most accurate match, Hoverfly can now report the closest request response pair when a request is unmatched. When this happens, an informative report of what happening during matching is now printed both to the logs as well as the HTTP error response body. This should make it much easier now to debug failing requests going through Hoverfly.
The second update to Hoverfly comes in the form of the UI. The UI part of Hoverfly has been neglected for a long time and as a result, we have rebuilt using Angular. This new dashboard is now separate from the Hoverfly codebase in its own codebase.
For more information on Hoverfly UI
With the change to Hoverfly UI being an external project for development, the -dev flag on Hoverfly has been updated to now enable CORS headers.
For more information on Hoverfly flags
We have added a new endpoint to Hoverfly which will allow users to shutdown Hoverfly. A shutdown can be triggered by sending a DELETE HTTP request to
We have added a new endpoint to Hoverfly which will allow users to shutdown Hoverfly. A shutdown can be triggered by sending a DELETE HTTP request to /api/v2/shutdown. This will terminate the instance immediately.
With the introduction of the shutdown API on Hoverfly, hoverctl has now been updated to no longer keep track of PIDs. Instead, hoverctl will now rely only on being able to communicate with Hoverfly via the API. This should have no functional impact on how hoverctl is used.
A bug was noticed with the jsonMatch request field matcher. The bug was that the order of elements within the JSON provided was respected when matching, making this matcher more difficult to use. This should now be resolved.
Another bug was spotted regarding headers served by Hoverfly. They noted that Hoverfly did not always respect the upper and lower case characters of the header keys from the simulation. This has been fixed and Hoverfly should now always send headers that match the headers from the simulation loaded.
Someone else pointed out that when setting TLS verification to false, they found Hoverfly was still applying TLS verification to proxied requests. It was promptly discovered that the TLS verification feature was working in reverse, meaning that TLS verification was disabled by default and specifying to disable it actually enabled it. This has been resolved.
WARNING if you are using Hoverfly with services in which you would like to TLS verification disabled, you will now need to set that with either hoverfly -tls-verification=false or hoverctl start --disable-tls.
We have updated and improved the hoverctl logs command. Using hoverctl logs will now print out plain text logs. To get the logs in a JSON format like
We have updated and improved the hoverctl logs command. Using hoverctl logs will now print out plain text logs. To get the logs in a JSON format like before, you can now use the new --json flag. We have renamed --follow-logs to --follow. We have also updated the way we retrieve logs. Before, we were writing the logs to disk and this was created while starting a Hoverfly process. Now, we are using the logs API from Hoverfly. This means hoverctl logs will now work with both local and remote instances of Hoverfly.
Two bugs were found in previous versions of hoverctl that only occurred on Windows. The first bug occurred when prompted to enter a password, hoverctl would error and terminate. The other bug found was that hoverctl would not update the config file. Both of these bugs have now been fixed.
The hoverctl targets command has been updated to include a default target indicator in the table of targets. We have also changed the way the default target works. Now, when it points to a target that does not exist, the default target will be changed to the local target.
As a result of updating the Hoverfly UI for v0.11.2, the Hoverfly binary increased in size. This has been fixed and the Hoverfly is now back to its or
As a result of updating the Hoverfly UI for v0.11.2, the Hoverfly binary increased in size. This has been fixed and the Hoverfly is now back to its original file size.
To make hoverctl easier to use, we have extended the config command with four new subcommands. It is now possible to retrieve either the host, admin port, proxy port or the auth token.
hoverctl config host
hoverctl config admin-port
hoverctl config proxy-port
hoverctl config auth-token
These commands can be used to get information about specific targets. For example:
hoverctl -t target-name config host
More information on hoverctl commands
When connecting to Hoverfly, regardless if you are proxying HTTP or HTTPS requests, you still need to make an HTTP request to Hoverfly. This can be a security problem when running Hoverfly in non-local environments with authentication enabled. You may be exposing your authorization credentials or your authorization token.
To solve this problem, when starting a Hoverfly instance on a remote host, we recommend using the new -proxy-auth Hoverfly flag with the value header-auth.
This flag will disable the default security mechanisms for the proxy. Instead, Hoverfly will expect a custom security header X-HOVERFLY-AUTHORIZATION. The reason for this that depending on your HTTP client, the default Proxy-Authorization header may be included in the insecure initial request. Using a custom header will make sure the authorization token is not included in that first request.
hoverfly -auth -username bench -password password123 -proxy-auth=header-auth
Setting -proxy-auth=header-auth will enable https-only by default
When authentication is enabled, you can now use a Proxy-Authorization header on the requests you are sending to the proxy. This header accepts both Ba
When authentication is enabled, you can now use a Proxy-Authorization header on the requests you are sending to the proxy. This header accepts both Basic authentication with base64 encoded value and also accepts Bearer authentication with a JWT token value. In combination with this work, we've also added the ability for disabling Basic authentication with the Hoverfly flag -disable-basic-auth.
More information on proxy authentication
We have added a new flag to both Hoverfly and hoverctl. This flag is --https-only and will set the Hoverfly proxy to only accept HTTPS requests. Any non HTTPS requests will result in 502 Bad Gateway responses.
More information on hoverctl commands
In an effort to keep Hoverfly secure when authentication is enabled, we have added a timeout that is triggered after three unsuccessful login attempts. After the three attempts, logging in result in a 429 Too Many Requests and you will have to wait 10 minutes.
More information on proxy authentication
Due to the ongoing work to tidy up the public API of the Hoverfly library, a bug was introduced causing our mechanism to update the version number in the library to not correctly up date the version of Hoverfly. This has now been fixed with this release meaning the version number will now be consistent across Hoverfly.
More information on hoverctl commands
We've made a big change to how hoverctl works. "Targets" make it easier to work with multiple Hoverfly instances - this is especially useful if you wa
We've made a big change to how hoverctl works. "Targets" make it easier to work with multiple Hoverfly instances - this is especially useful if you want to use hoverctl to manage both local and remote instances.
A target stores the configuration for a Hoverfly instance, so you can easily specify which instance to use when executing hoverctl commands by setting the -t / --target flag. If you do not specify a target, hoverctl will use the "default" target. Targets can be viewed using hoverctl targets and can be created using hoverctl targets create my-target.
More information on hoverctl targets
We have added a new command for logging into an instance of Hoverfly. As part of this change, we've moved the username and password out of the config file. Instead, when using the hoverctl login command, you will be now prompted to enter a username and password.
More information on hoverctl login
With the introduction of the new hoverctl login command, we have also added the --auth flag to hoverctl start. Using this flag will prompt you to set a username and password which will be used to log in to the Hoverfly instance.
More information on starting Hoverfly with authentication
Based on feedback, we have shortened the output of the hoverctl middleware command. Before, it would print out the full middleware script. Now, it will print the first five lines so that you can confirm that a script has been set. If you want to see the full script, this can be done by using the verbose -v flag.
More information on middleware
It was noticed that hoverctl was not writing errors to the standard error stream. This bug has been fixed in v0.11.1.
More information on hoverctl
Its been a month in the making. v0.11.0 is here with a bevy of improvements, building on already existing functionality.
Its been a month in the making. v0.11.0 is here with a bevy of improvements, building on already existing functionality.
Originally, Hoverfly only supported "recordings". An incoming request had to exactly match a stored request for a response to be returned.
Since the introduction of templates, it was clear that the way we match requests in Hoverfly needed to improve. v0.11.0 brings the first phase of those improvements.
Recordings are now treated like templates, meaning it is even easier and simpler to modify a captured request and turn it into a looser fitting template.
Instead of defining request field values exactly, we have introduced a new set of matchers. Each request field (except headers) will now take an object of matchers. These matchers have allowed us to add new ways of matching data. For example, it is now possible to match a request body based on an XPath expression.
This change has resulted in the Hoverfly schema being updated to v2. When importing an older v1 schemaVersion simulation, Hoverfly will automatically upgrade it to v2.
More information on request matchers
Previous versions of Hoverfly used a cache to store request recordings. The issue with this was you could not cache request templates, meaning a slower response time than with recording.
v0.11.0 has changed the way the cache works. Now, responses are stored against incoming requests meaning Hoverfly should now perform consistently regardless of how "loose" your simulation is.
The cache will be reloaded from your simulation every time you enter simulate mode. We have also added API endpoints for both viewing the state of the cache as well as flushing it.
More information on the logs API
We've changed capture mode so now by default, when you capture requests, request headers ill not be captured. This is due to the way the cache works with hashes of the request. Now, if you want to capture headers, you will need to specify them when setting capture mode.
In hoverctl, we have added two new flags to hoverctl mode which are
hoverctl mode capture --headers "User-Agent,Content-Type,Authorization"
hoverctl mode capture --all-headers
More information on hoverctl
If you are using HTTPS/TLS traffic and have not seen our last release, v0.10.3, we strongly advise looking as it provides instructions on how to replace the expired certificate.
Greetings, its been a while. We've been very busy preparing v0.11.0 of Hoverfly, which will be coming very soon.
Greetings, its been a while. We've been very busy preparing v0.11.0 of Hoverfly, which will be coming very soon.
This is an important release for those using HTTPS/SSL traffic with Hoverfly
Today (24th March, 2017), the certificate that ships with Hoverfly for HTTPS/SSL traffic expired. This has prompted a new certificate which now has a 5 year expiry.
As a result of this, from v0.10.3 onwards, you will need to remove the current certificate from your certificate truststore and add the new one.
If you cannot or do not want to update your version of Hoverfly, you can work around this by generating new certificates with Hoverfly and setting them manually when starting Hoverfly.
For more information on HTTPS/SSL
We have updated hoverctl version so it will now report the versions of both hoverfly and hoverctl binaries
For more information on hoverctl commands.
Its time for a small Hoverfly update. Over the past week, we've been fixing bugs and adding features.
Its time for a small Hoverfly update. Over the past week, we've been fixing bugs and adding features.
With the change to using spf13/cobra, we introduced a bug where "index out of range" errors would be printed when parameters were missing from certain hoverctl commands. This has been fixed to print a nicer error message.
For more information on hoverctl
We have expanded authentication within Hoverfly. Originally, turning on authentication would only take affect on the API, requiring a JWT token to communicate with Hoverfly. v0.10.2 now introduces authentication to the Hoverfly proxy.
For more information on authentication
As part of the changes to authentication, we have also enabled the ability to use authentication with an in-memory database. Previously you were restricted to only being able to enable authentication when using BoltDB.
For more information on authentication
With this release, we have created a new section in the documentation for "advanced tutorials". This section includes guides that show how to use Hoverfly in more complex situations. If you have any issues or misunderstandings around the documentation, feel free to raise issues. We are always striving to improve our docs!
For more information on advanced tutorials
Its been a month since the last release so we've got v0.10.1 ready for you. Since the last release, we've been busy improving the functional tests aro
Its been a month since the last release so we've got v0.10.1 ready for you. Since the last release, we've been busy improving the functional tests around Hoverfly and hoverctl, moving hoverctl over to use Cobra as well as fixing a few bugs and adding a new feature.
In v0.10.0, we fixed a bug which meant that query parameters were being compared based on order, meaning that rearranging query parameters would cause matching to fail. Sadly, this fix was only to request recordings. This has now been applied to both templates and recordings, fixing the issue permanently.
For more information on templates
During the refactor of v0.10.0 a bug was introduced that caused the request bodies on POST and PUT requests to be unreadable due to the preparation of bytes before being attached to a HTTP request. This has now been resolved.
Thanks to the work of @Bruno-DaSilva, we now have the ability to run Hoverfly behind of another proxy. This opens up the possibility of using Hoverfly in environments where using a proxy is required to communicate outside of your network. Currently, this upstream proxy feature only works with unauthenticated proxies, though we are looking to address this soon.
For more information on setting an upstream proxy
Having moved over to Cobra, we have reorganized the codebase, removed irrelevant commands (delays and templates) and produced more descriptive help text for each of the hoverctl commands.
For more information on hoverctl commands
It's a new year, so here's a new version of Hoverfly! This version has been in the works longer than expected but as a result, this release is even be
It's a new year, so here's a new version of Hoverfly! This version has been in the works longer than expected but as a result, this release is even better than we initially intended.
We had the opportunity to rewrite several parts of the codebase. Some of this time has been spent on refactoring and some has been spent on improvements. Because of this, we've bumped the version number up to v0.10.0.
Alongside the new release, we have rewritten the Hoverfly documentation and are now publishing it to ReadTheDocs. We hope that these changes will make it easier to get up to speed with Hoverfly quickly.
Stick around and let me tell you about the changes.
We had the opportunity to look into middleware and how its managed within Hoverfly. One of the initial limitations was that the middleware had to be on the host which Hoverfly was running.
This was okay for local development work but as soon as you tried to use a remote Hoverfly instance or even the Hoverfly docker image, setting middleware became difficult.
We have addressed this by changing how you set middleware. Instead of specifying a command, the API now accepts three values: "binary", "script" and "remote". "Binary" is the binary process Hoverfly should run. This should be located on the host machine. As for "script", rather than sending a path to a file, Hoverfly will now accept the contents of the script. Once the script has been received, Hoverfly will write it into the temporary directory, deleting it when it is no longer needed. The "remote" field is for supplying a URL for middleware which can be accessed via HTTP.
This change in API has been reflected in hoverctl. When setting middleware with hoverctl, you are now expected to use the new middleware flags, --binary, --script, --remote.
hoverctl middleware --binary python --script my_middleware.py
For more information on setting middleware: Using middleware to simulate network latency
For a while, there has been an inconsistency between Hoverfly and hoverctl. Starting Hoverfly as a process would default to writing data to the BoltDB request.db file. Starting a Hoverfly process with hoverctl would set Hoverfly to use an in-memory database. This caused confusion for some users. By default, both Hoverfly and hoverctl will now start Hoverfly processes with an in-memory database.
In conjunction with this change, we have also introduced a new --database flag to hoverctl for the times when you do need to persist data with BoltDB.
For more information on hoverctl: hoverctl commands
Through the refactoring, we have standardised the HTTP errors returned by Hoverfly. Previously, when using Hoverfly as a proxy, there were several different style errors that could occur. Now, whenever Hoverfly throws an error, it will return a response with a 512 error code and a nice description of the error. Each error that Hoverfly returns will also be logged, which will be either in the standard out of the Hoverfly process, or captured by hoverctl so they can be viewed with hoverctl logs.
We noticed a bug regarding recorded requests with query parameters. When the HTTP request was being converted in to an internal Request object, there was no sorting on the query parameters. As a result of this, it was possible to record the same request multiple times by changing the order of the query parameters. This version of Hoverfly fixes this by always sorting the query parameters into alphabetical order when converting a HTTP request to a Request object.
For more information on capturing requests and responses Creating and exporting a simulation
I remember v0.9.1, it felt like it was less than a week ago.
I remember v0.9.1, it felt like it was less than a week ago.
It was, but we have another new version of Hoverfly already! This new version contains a few usability fixes as well as a fix to a bug.
This week, we discovered a bug. This bug was only noticeable when running Hoverfly with the in memory database. The problem was, if you made a request to the cache and it failed, the cache would remain locked, making it impossible to ever read or write from the cache without resetting Hoverfly. This has been fixed up now and the in memory cache should not get stuck in a locked state any more.
When exporting data to a JSON file with hoverctl, the file it would write would always have the simulation JSON on one line, making it hard to read. Now, hoverctl will write JSON in a more formatted way, making it easier to read your simulations.
For more information on exporting simulations Exporting captured data
With v0.9.0, we introduced a new schema for the simulation. This schema is slightly more complicated than the previous. One of the issues we found was that when creating your own simulation files, Hoverfly gave no validation on this schema. Now, when importing a simulation file, if it doesn't match the expected schema, it will now report the error.
For more information on simulations Managing simulation data
Another small piece of feedback we had was that it wasn't always clear which ports Hoverfly had started on when using the hoverctl tool. We've updated hoverctl to now log the admin and proxy ports when starting an instance of Hoverfly.
For more information on hoverctl Hoverctl reference
_What better way to celebrate Cyber Monday with the Cyber Monday Hoverfly Deal! Download Hoverfly, and get hoverctl, absolutely free!_
What better way to celebrate Cyber Monday with the Cyber Monday Hoverfly Deal! Download Hoverfly, and get hoverctl, absolutely free!
Its been two weeks since the release of Hoverfly v0.9.0 and we are ready for the next release. This version features many smaller changes to hoverctl to make it easier to use.
We've introduced the destination command to hoverctl. This will return the destination being used by the running Hoverfly instance. Much like the other hoverctl commands, you can also use this to set the destination. Also, Hoverfly will now match the destination against full URLs, both destination and path.
hoverctl destination '<regex>'
For more information on setting the destination Filtering destination
Previously, if you wanted to use a certificate and key which were different than the defaults, you would have to launch Hoverfly manually. With this version, we've introduced the --certificate and --key flags to hoverctl.
hoverctl start --certificate /path/to/certificate.pem --key /path/to/key.pem
For more information on new flags Hoverctl flags
Much like the certificate and key values, if you wanted to disable TLS verification on Hoverfly, this could only be done by providing a flag to the Hoverfly binary. Hoverctl now supports this functionality when starting an instance of Hoverfly.
hoverctl start --disable-tls
For more information on new flags Hoverctl flags
All of these new flags introduced in this version of hoverctl have been included in the config.yaml. By default, hoverctl will always check the config.yaml and use any configuration to start Hoverfly. If for example, you always disable TLS verification, instead of providing the flag each time, you could just edit the config file to include hoverfly.tls.disable: true.
For more information on new flags Hoverctl configuration
If you are unsure of the configuration that hoverctl is using, we've added a new command to find out. Calling the config command in hoverctl will now report the location of the config.yaml that it is using as well as printing the configuration that is being used.
hoverctl config
For more information on new command Hoverctl config
With this release, we are deprecating the old API. We believe the new V2 API covers all of the required functionality. The old API is still accessible…
Its been a while but we are back! Hello! There have been some big changes to Hoverfly. A lot of the past month has been spent implementing the groundwork needed for us to continue to develop and evolve Hoverfly with more confidence of backwards compatibility.
With this release, we are deprecating the old API. We believe the new V2 API covers all of the required functionality. The old API is still accessible, but it will be removed at some point in the future.
With this release out of the way, we plan to go back to smaller, more regular releases in the future.
Over time, the input files required for Hoverfly have grown. Initially, there was a records file containing requests and responses. We then introduced templates and then delays. v0.9.0 simplifies all of this and now has a new schema for simulations. This schema contains all everything Hoverfly needs. The simulation schema now has the recorded requests and respones, the templates and the delays. In the future, any new forms of data we support in Hoverfly will be delivered via this schema.
For more information on the new schema: Managing simulation data
We've been hard at work on building out a new RESTful API for Hoverfly. This new API is versioned, which should allow us to make changes more easily without breaking backwards compatibility. As part of the new API, we've created a new endpoint for getting simulations with the new schema.
For more information on the new API: API reference
To make these changes, we're are going to be making breaking changes and creating a new version of the API, v2. I'm keeping a wiki page for breaking c…
Happy National Ampersand Day! What better way to celebrate today by showing your appreciation for the ampersand & checking out the latest release of Hoverfly. Its a small release today with a new feature and a bug fix. But before that, I would like to warn you about upcoming changes.
Recently we've been adding features and expanding the functionality of Hoverfly. This has been fantastic but as a result, we've slowly made it more complicated to use with different sets of data required with their own import and export steps. We've been starting to work on v0.9.0 which plans to change this and simplify both request templates and delays. To make these changes, we're are going to be making breaking changes and creating a new version of the API, v2. I'm keeping a wiki page for breaking changes so that we can clearly communicate these breaking changes ahead of time
For more information on these breaking changes: Upcoming breaking changes
The introduction of request templates was a great feature. It allowed for more flexible simulations. We have now expanded upon this to allow you to make your new simulations even more flexible. Instead of specifying a complete string to match against, its now possible to include an asterisk to substitute characters, similar to using a UNIX command line. This can be used in any of the fields available in a request template.
For more information on wildcards in request templates: Managing simulation data
A bug was found when trying to create a simulation of an OAuth2 log in. When the log in occurred, we spotted that the redirects were not being stored. Further investigation found that Hoverfly was executing the redirects and then returning a response as if the redirect never happened. This bug has been fixed, and now Hoverfly will return a redirect without executing it.
Greetings one and all. It’s Friday and Monday is a public holiday in the UK. The weather is looking good and Hoverfly is looking better. Here is v0.8.
Greetings one and all. It’s Friday and Monday is a public holiday in the UK. The weather is looking good and Hoverfly is looking better. Here is v0.8.1 and the changes it introduces.
For this release we have focused on refactoring, specifically around how Hoverfly simulation data is managed. In the past, we have referred to this data with different names - this hasn't always been clear.
From v0.8.1 we have defined a new standard for naming. Gone are the days of generic “payloads”. Requests and responses are now formed together to become RequestResponsePairs. We plan on updating the documentation to make sure that we always refer to simulation data now as pairs.
Along with this change, we have been refactoring data importing and exporting. Previously, if you wanted to make use of request templates or delays, you would have to create new files. We feel that this is unnecessary and that all data pertaining to a simulation should live in one file. This release allows request templates to be added to your normal simulation recordings.
For more information on request response pairs: Managing simulation data
A bug was discovered in webserver mode in which headers would not be included in the response. We have patched this up and written tests around it.
For more information on webserver mode: Server type
Another bug was discovered while using request templates. Despite being an option, you could not match on the request template body. This has been fixed in this version, again with tests around it.
For more information on request templates: Matching requests
Nothing published for this version
It's that time where we make a Hoverfly release! It's my favourite time as I get to review all the exciting work we've put into Hoverfly.
It's that time where we make a Hoverfly release! It's my favourite time as I get to review all the exciting work we've put into Hoverfly.
Before v0.8.0, matching within Hoverfly on requests was very strict and a bit brittle. You couldn't match a request just on the destination and a header - such as the Authorization header. Before, you had to capture every request that you wanted to match against using the same destination and header. v.0.8.0 changes that. We've introduced the ability to match on certain key elements of the request. You want to match on any POST request? Now you can. You want to match any request for the favicon regardless of destination? Now you can.
This is a powerful feature that can help make simulations more flexible. We are very excited about this feature and has helped us already.
For more information on request templates: Matching requests
In our continuous effort to move towards making hoverctl the wrapper for managing Hoverfly processes, we introduced the ability to set middleware via hoverctl. This now means that is no longer necessary to start Hoverfly with middleware. Using the hoverctl, you can now set it during run time, making it easier than ever to swap out middleware as and when you need it.
For more information on setting middleware via hoverctl: Hoverctl
As part of the middleware change, we've been curious as to how you could set middleware on remote machines running Hoverfly, especially without needing SSH access to the box. Our solution was to introduce the ability to run middleware as a web service. Instead of providing Hoverfly a command and a file to execute, you can now provide a URL instead. Building remote middleware is incredibly easily and using serverless technology like AWS Lambda makes working with middleware even easier.
For more information on remote execution of middleware: Using middleware
Nothing published for this version
Its been less than a week but its time for another release! Since the last release, we've been listening to feedback and implemented some changes to m
Its been less than a week but its time for another release! Since the last release, we've been listening to feedback and implemented some changes to make Hoverfly just that little bit better than it already was.
In v0.7.0 we introduced response delays, a great way to introduce delays into your simulations. With v0.7.1, we've expanded the functionality of response delays. Originally, you could only apply delays based on host. We've expanded it. You can now apply delays based on the full URL path and HTTP methods. This change allows for your response delays to be much more flexible.
This change means that the "hostPattern" field in your response delays will now need to be "urlPattern". Response delays will no longer work with "hostPattern"
For more information on response delays: Simulating service latency
Another big feature of v0.7.0 was the introduction of hoverctl, the command line tool for interacting with both Hoverfly and your simulation data inside it. One of the biggest drawbacks to using hoverctl was that if you started an instance of Hoverfly using it, you lost access to the logs. This is no longer the case. We've added logs to hoverctl. You can how call hoverctl logs and get access to the Hoverfly logs. Need to tail the logs and follow them in real time? Not a problem, use the --follow flag.
For more information on hoverctl: hoverctl reference
Both Hoverfly and hoverctl did not have --version flags, making them noncompliant with POSIX guidelines. v0.7.1 adds the --version flag to both Hoverfly and hoverctl.
For more information on hoverctl: hoverctl reference
For more information on Hoverfly flags: Hoverfly flags and environment variables
Its been a requested feature for a while. Hoverfly is now available using Homebrew. This formula includes both Hoverfly and hoverctl. It is currently not available on homebrew-core and instead, resides in its own SpectoLabs tap.
If you want to install Hoverfly via Homebrew, please run brew install SpectoLabs/tap/hoverfly
We've been busy adding new features to Hoverfly, as well as developing tools to support the use of Hoverfly.
Greetings!
We've been busy adding new features to Hoverfly, as well as developing tools to support the use of Hoverfly.
We have created a new command line interface for Hoverfly. This allows for the management of local and remote Hoverfly instances. Using hoverctl, you can start and stop instances of Hoverfly, and manage Hoverfly data. You can export your simulations and then share them on SpectoLab, an API simulation repository for sharing and retrieving simulations. SpectoLab is currently in private beta, but you can request access. Hoverctl will still work with Hoverfly, even if you don't have access to SpectoLab.
For more information on hoverctl: hoverctl reference
Run the following command to install and set up Hoverfly and hoverctl:
curl -o install.sh https://storage.googleapis.com/specto-binaries/install.sh && bash install.sh
We noticed that a common usage of middleware was to introduce response delays to simulations, so we've added the ability to set response delays in Hoverfly without the need for middleware. Hoverfly uses a regex to match against a request, opening up the opportunity to add different delays to different hosts.
For more information on response delays: Simulating service latency
We also got feedback that running Hoverfly as a proxy was not always desirable (or even possible), especially when simulations have been recorded previously and all you need is simulate mode. Now Hoverfly can run as a webserver, allowing you to point your application directly at Hoverfly without having to configure a proxy. Currently this only works via HTTP.
For more information on running Hoverfly as a webserver: Server type
Also, this release introduces a new repository structure. This was mainly due to the introduction of hoverctl. The end result is a much tidier repository that makes it easy to run different suites of functional tests.
Its time for a new minor version of Hoverfly.
Its time for a new minor version of Hoverfly.
Why have we gone from v0.5.17 to v0.6.0?
We made a slight change to the structure of payloads. We added a new field to indicate whether or not the body needs to be base64-encoded. The reason being that during the export and import process, any binary body data in a response would get lost due to being parsed to Unicode characters.
You can find out more about this change here. If you are trying to read or write binary data to the response body in your middleware, find out more here.
In this release, we have also introduced Ginkgo and Gomega to help us functionally test Hoverfly, which in turn has enabled us to start to modularize the codebase.
Next version of UI and improved documentation
Next version of UI and improved documentation
Minor refactoring, added memory cache that is used by 3rd party libraries for temporary stuff.
Minor refactoring, added memory cache that is used by 3rd party libraries for temporary stuff.
BoltDB backend moved to separate package, currently used for requests/responses and metadata storage.
multiple -dest flags are now available for providing a list of hosts that should be virtualized
multiple -dest flags are now available for providing a list of hosts that should be virtualized
added new metadata API, see readme for more.
added new metadata API, see readme for more.
One column per quarter.