Schemathesis
GoSwagger
Schemathesis | GoSwagger | |
---|---|---|
23 | 25 | |
2,091 | 9,280 | |
1.6% | 0.6% | |
9.7 | 8.7 | |
10 days ago | 5 days ago | |
Python | Go | |
MIT License | Apache License 2.0 |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
Schemathesis
-
Ask HN: Any Good Fuzzer for gRPC?
I am not aware of any tools like that, but eventually, I plan to add support for gRPC fuzzing to Schemathesis. There were already some discussions and it is more or less clear how to move forward. See https://github.com/schemathesis/schemathesis/discussions/190...
-
Show HN: Auto-generate load tests/synthetic test data from OpenAPI spec/HAR file
Why is AI needed for this at all? Have you heard about Schemathesis (https://github.com/schemathesis/schemathesis)?
-
A Tale of Two Kitchens - Hypermodernizing Your Python Code Base
SchemaThesis is a powerful tool, especially when working with web APIs, and here's how it can enhance your testing capabilities:
- Hurl 4.0.0
-
OpenAPI v4 Proposal
I'm sorry, but you have completely misunderstood the purpose of Open API.
It is not a specification to define your business logic classes and objects -- either client or server side. Its goal is to define the interface of an API, and to provide a single source of truth that requests and responses can be validated against. It contains everything you need to know to make requests to an API; code generation is nice to have (and I use it myself, but mainly on the server side, for routing and validation), but not something required or expected from OpenAPI
For what it's worth, my personal preferred workflow to build an API is as follows:
1. Build the OpenAPI spec first. A smaller spec could easily be done by hand, but I prefer using a design tool like Stoplight [0]; it has the best Web-based OpenAPI (and JSON Schema) editor I have encountered, and integrates with git nearly flawlessly.
2. Use an automated tool to generate the API code implementation. Again, a static generation tool such as datamodel-code-generator [1] (which generates Pydantic models) would suffice, but for Python I prefer the dynamic request routing and validation provided by pyapi-server [2].
3. Finally, I use automated testing tools such as schemathesis [3] to test the implementation against the specification.
[0] https://stoplight.io/
[1] https://koxudaxi.github.io/datamodel-code-generator/
[2] https://pyapi-server.readthedocs.io
[3] https://schemathesis.readthedocs.io
-
Faster time-to-market with API-first
Consolidating the API specification with OpenAPI was a turning point for the project. From that moment we were able to run mock servers to build and test the UI before integrating with the backend, and we were able to validate the backend implementation against the specification. We used prism to run mock servers, and Dredd to validate the server implementation (these days I’d rather use schemathesis).
- Show HN: Step CI – API Testing and Monitoring Made Simple
-
API-first development maturity framework
In this approach, you produce an API specification first, then you build the API against the specification, and then you validate your implementation against the specification using automated API testing tools. This is the most reliable approach for building API servers, since it’s the only one that holds the server accountable and validates the implementation against the source of truth. Unfortunately, this approach isn’t as common as it should be. One of the reasons why it isn’t so common is because it requires you to produce the API specification first, which, as we saw earlier, puts off many developers who don’t know how to work with OpenAPI. However, like I said before, generating OpenAPI specifications doesn’t need to be painful since you can use tools for that. In this approach, you use automated API testing tools to validate your implementation. Tools like Dredd and schemathesis. These tools work by parsing your API specification and automatically generating tests that ensure your implementation complies with the specification. They look at every aspect of your API implementation, including use of headers, status codes, compliance with schemas, and so on. The most advanced of these tools at the moment is schemathesis, which I highly encourage you to check out.
-
How do you manage microservices API versions and branching strategies?
Keep all API versions in the code Another strategy is to have all the different API versions in the same code. So you may have a folder structure that looks like this: api ├── v1 └── v2 Within the API folder, you have one folder for v1 and another one for v2. Each folder has its own schemas and routes as required by the API version they implement. If you use URL-based versioning, v1 is accessible through the example.com/v1 endpoint or the v1.example.com subdomain (whichever strategy you use), and same for v2. Deprecating a version is a simple as its corresponding folder. In any case, I'd recommend you also validate your API implementations in the CI using something like schemathesis. Schemathesis looks at the API documentation and automatically generates hundreds of tests to make sure you're using the right schemas, status codes, and so on. It works best if you design and document the API before implementing, which allows you to include OpenAPI links and other features.
-
This Week in Python
schemathesis – Run generated test scenarios based on your OpenAPI specification
GoSwagger
- How do you provide documentation for your REST APIs?
-
What is the benefit of creating a server struct?
Hi everyone, I was going through go-swagger todo list example and came across the following implementation of server struct.
-
OpenAPI v4 Proposal
Much or some OpenAPI tooling has not even moved past OpenAPI 2.0 some even refusing and saying that they will not update to Swagger 3.0 [0] and others have issues open since some 2019 and still open with no resolution in sight (because these are individuals doing out of passion and the spec is complex to implement) and yet we have Open API spec 4.0
All this is - trying to do RPC over HTTP in a fashion that was deemed virtuous in some doctoral thesis.
I wish there were better alternatives for RPC that work everywhere including browsers.
[0]https://github.com/go-swagger/go-swagger/issues/1122#issueco...
-
[Request] Library Recommendation for Auto Swagger/OpenAPIv3 Documentation
I recommend this: https://github.com/go-swagger/go-swagger
-
A there any production-ready code generators?
Hi there. I am seeking any open source Schema Driven Development tool like go-swagger, but i really need to use there:
- Is there a way to generate controller from swagger through build tools?
-
Go-Swagger not generating properties in yaml file
Can anyone point out what am I doint wrong? Note: I have already checked No properties generated in json file for swagger:response but didn't find anything which can help.
-
FastAPI Replacement - especially with openapi
Try this https://github.com/go-swagger/go-swagger. It generates code for you. It is useful if only for you to generate the models/structs you could use.
-
OpenAPI Specification: The Complete Guide
go-swagger brings to the go community a complete suite of fully-featured, high-performance, API components to work with a Swagger API: - Github - Swagger 2.0 implementation for go
-
Easiest way to make a documentation?
There is also a Code Generator that reads in a swagger file (2.0 only) and generates code for you, so all you have to do is create functions.
What are some alternatives?
dredd - Language-agnostic HTTP API Testing Tool
swag - Automatically generate RESTful API documentation with Swagger 2.0 for Go.
Robot Framework - Generic automation framework for acceptance testing and RPA
Gin - Gin is a HTTP web framework written in Go (Golang). It features a Martini-like API with much better performance -- up to 40 times faster. If you need smashing performance, get yourself some Gin.
pytest - The pytest framework makes it easy to write small tests, yet scales to support complex functional testing
go-kit - A standard library for microservices.
coverage
kin-openapi - OpenAPI 3.0 (and Swagger v2) implementation for Go (parsing, converting, validation, and more)
drf-openapi-tester - Test utility for validating OpenAPI documentation
goa - 🌟 Goa: Elevate Go API development! 🚀 Streamlined design, automatic code generation, and seamless HTTP/gRPC support. ✨
tox - Command line driven CI frontend and development task automation tool.
oapi-codegen - Generate Go client and server boilerplate from OpenAPI 3 specifications