hypothesis generate json

• Docs »
• What you can generate and how
• Edit on GitHub

What you can generate and how ¶

Most things should be easy to generate and everything should be possible.

To support this principle Hypothesis provides strategies for most built-in types with arguments to constrain or adjust the output, as well as higher-order strategies that can be composed to generate more complex types.

This document is a guide to what strategies are available for generating data and how to build them. Strategies have a variety of other important internal features, such as how they simplify, but the data they can generate is the only public part of their API.

Functions for building strategies are all available in the hypothesis.strategies module. The salient functions from it are as follows:

Shrinking ¶

When using strategies it is worth thinking about how the data shrinks . Shrinking is the process by which Hypothesis tries to produce human readable examples when it finds a failure - it takes a complex example and turns it into a simpler one.

Each strategy defines an order in which it shrinks - you won’t usually need to care about this much, but it can be worth being aware of as it can affect what the best way to write your own strategies is.

The exact shrinking behaviour is not a guaranteed part of the API, but it doesn’t change that often and when it does it’s usually because we think the new way produces nicer examples.

Possibly the most important one to be aware of is one_of() , which has a preference for values produced by strategies earlier in its argument list. Most of the others should largely “do the right thing” without you having to think about it.

Adapting strategies ¶

Often it is the case that a strategy doesn’t produce exactly what you want it to and you need to adapt it. Sometimes you can do this in the test, but this hurts reuse because you then have to repeat the adaption in every test.

Hypothesis gives you ways to build strategies from other strategies given functions for transforming the data.

map is probably the easiest and most useful of these to use. If you have a strategy s and a function f , then an example s.map(f).example() is f(s.example()) , i.e. we draw an example from s and then apply f to it.

Note that many things that you might use mapping for can also be done with builds() .

Filtering ¶

filter lets you reject some examples. s.filter(f).example() is some example of s such that f(example) is truthy.

It’s important to note that filter isn’t magic and if your condition is too hard to satisfy then this can fail:

In general you should try to use filter only to avoid corner cases that you don’t want rather than attempting to cut out a large chunk of the search space.

A technique that often works well here is to use map to first transform the data and then use filter to remove things that didn’t work out. So for example if you wanted pairs of integers (x,y) such that x < y you could do the following:

Chaining strategies together ¶

Finally there is flatmap . flatmap draws an example, then turns that example into a strategy, then draws an example from that strategy.

It may not be obvious why you want this at first, but it turns out to be quite useful because it lets you generate different types of data with relationships to each other.

For example suppose we wanted to generate a list of lists of the same length:

In this example we first choose a length for our tuples, then we build a strategy which generates lists containing lists precisely of that length. The finds show what simple examples for this look like.

Most of the time you probably don’t want flatmap , but unlike filter and map which are just conveniences for things you could just do in your tests, flatmap allows genuinely new data generation that you wouldn’t otherwise be able to easily do.

(If you know Haskell: Yes, this is more or less a monadic bind. If you don’t know Haskell, ignore everything in these parentheses. You do not need to understand anything about monads to use this, or anything else in Hypothesis).

Recursive data ¶

Sometimes the data you want to generate has a recursive definition. e.g. if you wanted to generate JSON data, valid JSON is:

• Any float, any boolean, any unicode string.
• Any list of valid JSON data
• Any dictionary mapping unicode strings to valid JSON data.

The problem is that you cannot call a strategy recursively and expect it to not just blow up and eat all your memory. The other problem here is that not all unicode strings display consistently on different machines, so we’ll restrict them in our doctest.

The way Hypothesis handles this is with the recursive() function which you pass in a base case and a function that, given a strategy for your data type, returns a new strategy for it. So for example:

That is, we start with our leaf data and then we augment it by allowing lists and dictionaries of anything we can generate as JSON data.

The size control of this works by limiting the maximum number of values that can be drawn from the base strategy. So for example if we wanted to only generate really small JSON we could do this as:

Composite strategies ¶

The @composite decorator lets you combine other strategies in more or less arbitrary ways. It’s probably the main thing you’ll want to use for complicated custom strategies.

The composite decorator works by giving you a function as the first argument that you can use to draw examples from other strategies. For example, the following gives you a list and an index into it:

draw(s) is a function that should be thought of as returning s.example() , except that the result is reproducible and will minimize correctly. The decorated function has the initial argument removed from the list, but will accept all the others in the expected order. Defaults are preserved.

Note that the repr will work exactly like it does for all the built-in strategies: it will be a function that you can call to get the strategy in question, with values provided only if they do not match the defaults.

You can use assume inside composite functions:

This works as assume normally would, filtering out any examples for which the passed in argument is falsey.

Drawing interactively in tests ¶

There is also the data() strategy, which gives you a means of using strategies interactively. Rather than having to specify everything up front in @given you can draw from strategies in the body of your test:

If the test fails, each draw will be printed with the falsifying example. e.g. the above is wrong (it has a boundary condition error), so will print:

As you can see, data drawn this way is simplified as usual.

Test functions using the data() strategy do not support explicit @example(...) s. In this case, the best option is usually to construct your data with @composite or the explicit example, and unpack this within the body of the test.

Optionally, you can provide a label to identify values generated by each call to data.draw() . These labels can be used to identify values in the output of a falsifying example.

For instance:

will produce the output:

Test faster, fix more

Generating recursive data

Sometimes you want to generate data which is recursive . That is, in order to draw some data you may need to draw some more data from the same strategy. For example we might want to generate a tree structure, or arbitrary JSON.

Hypothesis has the recursive function in the hypothesis.strategies module to make this easier to do. This is an article about how to use it.

Lets start with a simple example of drawing tree shaped data: In our example a tree is either a single boolean value (a leaf node), or a tuple of two child trees. So a tree might be e.g. True, or (False, True), or ((True, True), False), etc.

First off, it might not be obvious that you need the recursive strategy. In principle you could just do this with composite:

If you try drawing examples from this you’ll probably see one of three scenarios:

• You’ll get a single boolean value
• You’ll get a very large tree
• You’ll get a RecursionError from a stack overflow

It’s unlikely that you’ll see any non-trivial small examples.

The reason for this is that this sort of recursion tends to explode in size: If this were implemneted as a naive random generation process then the expected size of the tree would be infinite. Hypothesis has some built in limiters to stop it ever trying to actually generate infinitely large amounts of data, but it will still tend to draw trees that are very large if they’re not trivial, and it can’t do anything about the recursion problem.

So instead of using this sort of unstructured recursion, Hypothesis exposes a way of doing recursion in a slightly more structured way that lets it control the size of the generated data much more effectively. This is the recursive strategy.

In order to use the recursive strategy you need two parts:

• A base strategy for generating “simple” instances of the data that you want.
• A function that takes a child strategy that generates data of the type you want and returns a new strategy generating “larger” instances.

So for example for our trees of booleans and tuples we could use booleans() for the first and something for returning tuples of children for the second:

The way to think about the recursive strategy is that you’re repeatedly building up a series of strategies as follows:

So at each level you augment the things from the previous level with your extend function. Drawing from the resulting recursive strategy then picks one of this infinite sequence of strategies and draws from it (this isn’t quite what happens in practice, but it’s pretty close).

The resulting strategy does a much better job of drawing small and medium sized trees than our original composite based one does, and should never raise a RecursionError:

You can also control the size of the trees it draws with the third parameter to recursive:

The max_leaves parameter controls the number of values drawn from the ‘base’ strategy. It defaults to 50, which will tend to give you moderately sized values. This helps keep example sizes under control, as otherwise it can be easy to create extend functions which cause the size to grow very rapidly.

In this particular example, Hypothesis will typically not hit the default, but consider something like the following:

In this case the size of the example will tend to push up against the max_leaves value because extend() grows the strategy in size quite rapidly, so if you want larger examples you will need to turn up max_leaves.

Using Hypothesis and Schemathesis to Test FastAPI

Share this tutorial.

• Hacker News

Testing is a necessary part of developing software. Software projects with high test coverage are never perfect, but it's a good initial indicator of the quality of the software. To encourage the writing of tests, tests should be fun and easy to write. They should also be treated with the same care as any other code in your codebase. Thus, you need to take the cost of maintaining the test suite into account when adding new tests. It's not easy balancing readability and maintainability while also ensuring tests cover a wide range of scenarios

In this article, we'll look at how property-based testing can help with this. We'll start by looking at what property-based testing is and why you may want to use it. Then, we'll show how Hypothesis and Schemathesis can be used to apply property-based testing to FastAPI.

Quick Start

Using hypothesis with fastapi, quick start with the cli, additional options, python tests, property-based testing.

What is property-based testing?

Property-based tests are based on the properties of a given function or a program. These tests help ensure that the function or program under test abides by its properties.

Why use property-based testing?

• Scope : Rather than having to write different test cases for every argument you want to test, property-based testing allows you to test a range of arguments for each parameter from a single test. This helps increase the robustness of your test suite while decreasing test redundancy. In short, your test code will be cleaner, more DRY, and overall more efficient while at the same time more effective since you'll be able to test all those edge cases much easier.
• Reproducibility : Testing agents save the test cases along with their results, which can be used for reproducing and replaying a test in case of failure.

Let's look at a quick example to help illustrate the point:

What's wrong with this?

• test cases are boring to write
• random, unbiased test examples are hard to come up with
• the test suite will quickly balloon in size so it will be hard to read and maintain going forward
• again, it's boring!
• it's hard to flesh out edge cases

Humans should not waste their time on this. It's the perfect task for a computer to do.

Property-based Testing with Hypothesis

Hypothesis is a tool for conducting property-based testing in Python. Hypothesis makes it easy to write tests and find all edge cases.

It works by generating arbitrary data matching your specification and checking that your guarantee still holds in that case. If it finds an example where it doesn't, it takes that example and cuts it down to size, simplifying it until it finds a much smaller example that still causes the problem. It then saves that example for later so that once it has found a problem with your code, it will not forget it in the future.

The most important part here is that all failed tests will be tried even after the errors have been fixed!

Hypothesis integrates into your normal pytest or unittest workflow.

Start by installing the library:

Next, you'll need to define a Strategy , which is a recipe for generating random data.

Strategies are meant to be composed together to generate complex input data for testing. Thus, rather than having to write and maintain your own data generators, Hypothesis manages all that for you.

Let's refactor test_factorial from above into a property-based test:

This test now asserts that the factorial of a number divided by the factorial of that number minus one is the original number.

Here, we passed the integers Strategy to the @given decorator, which is the the entry point to Hypothesis. This decorator essentially turns the test function into a parameterized function so that when it's called the generated data from the Strategy will be passed into the test.

If a failure had been found, Hypothesis uses Shrinking to find the smallest fail case.

Test output:

Here, we tested the expression num >= -2 against a pool of integers. Hypothesis started with num = -4475302896957925906 , a rather large number, as the first fail case. It then shrinked the values of num until Hypothesis found the value num = -3 as the smallest fail case.

Hypothesis has proven to be a simple yet powerful testing tool. Let's see how we can use it with FastAPI.

So, the /api/{s} route takes a URL parameter called s that should be an integer.

Like before we used the integers Strategy to generate random integers, positive and negative, for testing.

Schemathesis

Schemathesis is a modern API testing tool based on the OpenAPI and GraphQL specifications. It uses Hypothesis under the hood to apply property-based testing to API schemas. In other words, given a schema, Schemathesis can automatically generate test cases for you. Since FastAPI is based on OpenAPI standards, Schemathesis works well with it.

If you run the above server.py file and navigate to http://localhost:8000/openapi.json , you should see the OpenAPI specification generated by FastAPI. It defines all the endpoints along with their input types. Using this spec, Schemathesis can be used to generate test data.

Once installed, the simplest way to run tests is via the schemathesis command. With Uvicorn running in one terminal window, open a new window and run:

You should see:

Notice how this only checked for not_a_server_error . Schemathesis has five built-in checks :

• not_a_server_error : response has 5xx HTTP status
• status_code_conformance : response status is not defined in the API schema
• content_type_conformance : response content type is not defined in the API schema
• response_schema_conformance : response content does not conform to the schema defined for this specific response
• response_headers_conformance : response headers does not contain all defined headers.

You can perform all built-in checks with the --checks all option:

You can test a specific endpoint or HTTP method rather than the whole application:

A max response time can be used to help flesh out edge cases that may slow down the endpoints. The time is in milliseconds.

Do some of your endpoints require authorization?

You can use multiple workers to speed up the tests:

Normally, Schemathesis generates random data for each endpoint. Stateful tests make sure that the data comes from previous tests/responses:

Finally, replaying tests is simple since each test case is associated with a seed value. When a test case fails, it'll provide the seed so that the you can reproduce the failed case:

Then, to reproduce, run:

You can use Schemathesis inside your tests as well:

Schemathesis also supports making calls directly to ASGI (i.e., Uvicorn and Daphne) and WSGI (i.e., Gunicorn and uWSGI) applications instead of over the network:

Hopefully you can see just how powerful property-based testing can be. It can make your code more robust without reducing test readability from boilerplate test code. Features like shrinking to find the simplest failure cases and replaying improve productivity. Property-based testing will decrease time spent on writing manual tests while increasing test coverage.

A property-based testing tool like Hypothesis should be part of nearly every Python workflow. Schemathesis is used for automated API testing based on OpenAPI standards, which is very useful when coupled with an API-focused framework like FastAPI.

Test-Driven Development with FastAPI and Docker

In this course, you'll learn how to build, test, and deploy a text summarization service with Python, FastAPI, and Docker. The service itself will be exposed via a RESTful API and deployed to Heroku with Docker.

Recommended Tutorials

Stay sharp with course updates.

Join our mailing list to be notified about updates and new releases.

Send Us Feedback

genson 1.3.0

pip install genson Copy PIP instructions

Released: May 15, 2024

GenSON is a powerful, user-friendly JSON Schema generator.

Verified details

Maintainers.

Unverified details

Project links, github statistics.

• Open issues:

License: MIT License (MIT)

Author: Jon Wolverton

Tags json, schema, json-schema, jsonschema, object, generate, generator, builder, merge, draft 7, validate, validation

Classifiers

• 5 - Production/Stable
• OSI Approved :: MIT License
• OS Independent
• Python :: 3
• Python :: 3.7
• Python :: 3.8
• Python :: 3.9
• Python :: 3.10
• Python :: 3.11
• Python :: 3.12
• Software Development :: Code Generators
• Software Development :: Libraries :: Python Modules

Project description

GenSON is a powerful, user-friendly JSON Schema generator built in Python.

GenSON’s core function is to take JSON objects and generate schemas that describe them, but it is unique in its ability to merge schemas. It was originally built to describe the common structure of a large number of JSON objects, and it uses its merging ability to generate a single schema from any number of JSON objects and/or schemas.

GenSON’s schema builder follows these three rules:

JSON Schema Implementation

GenSON is compatible with JSON Schema Draft 6 and above.

It is important to note that GenSON uses only a subset of JSON Schema’s capabilities. This is mainly because it doesn’t know the specifics of your data model, and it tries to avoid guessing them. Its purpose is to generate the basic structure so that you can skip the boilerplate and focus on the details of the schema.

Currently, GenSON only deals with these keywords:

You should be aware that this limited vocabulary could cause GenSON to violate rules 1 and 2. If you feed it schemas with advanced keywords, it will just blindly pass them on to the final schema. Note that "$ref" and id are also not supported, so GenSON will not dereference linked nodes when building a schema.

Installation

The package includes a genson executable that allows you to access this functionality from the command line. For usage info, run with --help :

GenSON Python API

SchemaBuilder is the basic schema generator class. SchemaBuilder instances can be loaded up with existing schemas and objects before being serialized.

SchemaBuilder API

__init__(schema_uri=none).

value of the $schema keyword. If not given, it will use the value of the first available $schema keyword on an added schema or else the default: 'http://json-schema.org/schema#' . A value of False or None will direct GenSON to leave out the "$schema" keyword.

add_schema(schema)

Merge in a JSON schema. This can be a dict or another SchemaBuilder object.

a JSON Schema

add_object(obj)

Modify the schema to accommodate an object.

any object or scalar that can be serialized in JSON

to_schema()

Generate a schema based on previous inputs.

Generate a schema and convert it directly to serialized JSON.

__eq__(other)

Check for equality with another SchemaBuilder object.

another SchemaBuilder object. Other types are accepted, but will always return False

SchemaBuilder object interaction

SchemaBuilder objects can also interact with each other:

Seed Schemas

There are several cases where multiple valid schemas could be generated from the same object. GenSON makes a default choice in all these ambiguous cases, but if you want it to choose differently, you can tell it what to do using a seed schema .

Seeding Arrays

For example, suppose you have a simple array with two items:

There are always two ways for GenSON to interpret any array: List and Tuple. Lists have one schema for every item, whereas Tuples have a different schema for every array position. This is analogous to the (now deprecated) merge_arrays option from version 0. You can read more about JSON Schema array validation here .

List Validation

Tuple validation.

By default, GenSON always interprets arrays using list validation, but you can tell it to use tuple validation by seeding it with a schema.

Note that in this case, the seed schema is actually invalid. You can’t have an empty array as the value for an items keyword. But GenSON is a generator, not a validator, so you can fudge a little. GenSON will modify the generated schema so that it is valid, provided that there aren’t invalid keywords beyond the ones it knows about.

Seeding patternProperties

Support for patternProperties is new in version 1; however, since GenSON’s default behavior is to only use properties , this powerful keyword can only be utilized with seed schemas. You will need to supply an object schema with a patternProperties object whose keys are RegEx strings. Again, you can fudge here and set the values to null instead of creating valid subschemas.

There are a few gotchas you should be aware of here:

Typeless Schemas

In version 0, GenSON did not accept a schema without a type, but in order to be flexible in the support of seed schemas, support was added for version 1. However, GenSON violates rule #2 in its handling of typeless schemas. Any object will validate under an empty schema, but GenSON incorporates typeless schemas into the first-available typed schema, and since typed schemas are stricter than typless ones, objects that would validate under an added schema will not validate under the result.

Customizing SchemaBuilder

You can extend the SchemaBuilder class to add in your own logic (e.g. recording minimum and maximum for a number). In order to do this, you need to:

SchemaStrategy Classes

GenSON uses the Strategy Pattern to parse, update, and serialize different kinds of schemas that behave in different ways. There are several SchemaStrategy classes that roughly correspond to different schema types. GenSON maps each node in an object or schema to an instance of one of these classes. Each instance stores the current schema state and updates or returns it when required.

You can modify the specific ways these classes work by extending them. You can inherit from any existing SchemaStrategy class, though SchemaStrategy and TypedSchemaStrategy are the most useful base classes. You should call super and pass along all arguments when overriding any instance methods.

The documentation below explains the public API and what you need to extend and override at a high level. Feel free to explore the code to see more, but know that the public API is documented here, and anything else you depend on could be subject to change. All SchemaStrategy subclasses maintain the public API though, so you can extend any of them in this way.

SchemaStrategy API

[class constant] keywords.

This should be a tuple listing all of the JSON-schema keywords that this strategy knows how to handle. Any keywords encountered in added schemas will be be naively passed on to the generated schema unless they are in this list (or you override that behavior in to_schema ).

When adding keywords to a new SchemaStrategy , it’s best to splat the parent class’s KEYWORDS into the new tuple.

[class method] match_schema(cls, schema)

Return true if this strategy should be used to handle the passed-in schema.

a JSON Schema in dict form

[class method] match_object(cls, obj)

Return true if this strategy should be used to handle the passed-in object.

__init__(self, node_class)

Override this method if you need to initialize an instance variable.

This param is not part of the public API. Pass it along to super .

add_schema(self, schema)

Override this to modify how a schema is parsed and stored.

add_object(self, obj)

Override this to change the way a schemas are inferred from objects.

to_schema(self)

Override this method to customize how a schema object is constructed from the inputs. It is suggested that you invoke super as the basis for the return value, but it is not required.

__eq__(self, other)

When checking for SchemaBuilder equality, strategies are matched using __eq__ . The default implementation uses a simple __dict__ equality check.

Override this method if you need to override that behavior. This may be useful if you add instance variables that aren’t relevant to whether two SchemaStrategies are considered equal.

TypedSchemaStrategy API

This is an abstract schema strategy for making simple schemas that only deal with the type keyword, but you can extend it to add more functionality. Subclasses must define the following two class constants, but you get the entire SchemaStrategy interface for free.

[class constant] JS_TYPE

This will be the value of the type keyword in the generated schema. It is also used to match any added schemas.

[class constant] PYTHON_TYPE

This is a Python type or tuple of types that will be matched against an added object using isinstance .

Extending SchemaBuilder

Once you have extended SchemaStrategy types, you’ll need to create a SchemaBuilder class that uses them, since the default SchemaBuilder only incorporates the default strategies. To do this, extend the SchemaBuilder class and define one of these two constants inside it:

[class constant] EXTRA_STRATEGIES

This is the standard (and suggested) way to add strategies. Set it to a tuple of all your new strategies, and they will be added to the existing list of strategies to check. This preserves all the existing functionality.

Note that order matters. GenSON checks the list in order, so the first strategy has priority over the second and so on. All EXTRA_STRATEGIES have priority over the default strategies.

[class constant] STRATEGIES

This clobbers the existing list of strategies and completely replaces it. Set it to a tuple just like for EXTRA_STRATEGIES , but note that if any object or schema gets added that your exhaustive list of strategies doesn’t know how to handle, you’ll get an error. You should avoid doing this unless you’re extending most or all existing strategies in some way.

Example: MinNumber

Here’s some example code creating a number strategy that tracks the minimum number seen and includes it in the output schema.

Now that we have the MinNumberSchemaBuilder class, let’s see how it works.

Note that the exclusive builder is much more particular.

Contributing

When contributing, please follow these steps:

Tests are written in unittest and are run using tox and nose . Tox will run all tests with coverage against each supported Python version that is installed on your machine.

Integration

When you submit a PR, Travis CI performs the following steps:

If any of these steps fail, your PR cannot be merged until it is fixed.

Potential Future Features

The following are extra features under consideration.

logical support for more keywords:

Modernization

remove Python 2.7 support

This version was a total overhaul. The main change was to split Schema into three separate classes, making it simpler to add more complicated functionality by having different generator types to handle the different schema types.

Interface Changes

To make the transition easier, there is still a Schema class that wraps SchemaBuilder with a backwards-compatibility layer, but you will trigger a PendingDeprecationWarning if you use it.

The merge_arrays option has been removed in favor of seed schemas. You can now seed specific nodes as list or tuple instead of setting a global option for every node in the schema tree.

You can also now seed object nodes with patternProperties , which was a highly requested feature.

Other Changes

genson executable

0.1.0 (2014-11-29)

GenSON is written and maintained by Jon Wolverton .

Contributors

Project details, release history release notifications | rss feed.

May 15, 2024

Aug 15, 2020

Apr 24, 2020

Apr 17, 2020

Apr 9, 2019

Dec 3, 2018

Feb 18, 2018

Jan 2, 2018

Oct 15, 2017

Aug 12, 2017

Feb 7, 2017

Jun 19, 2016

Nov 30, 2014

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages .

Source Distribution

Uploaded May 15, 2024 Source

Built Distribution

Uploaded May 15, 2024 Python 3

Hashes for genson-1.3.0.tar.gz

Hashes for genson-1.3.0-py3-none-any.whl

• português (Brasil)

Supported by

• By logging in you accept our terms of service and privacy policy

hypothesis-jsonschema Release 0.22.0

Release 0.22.0 toggle dropdown 0.22.0 0.21.0 0.20.1 0.20.0 0.19.2 0.19.1 0.19.0 0.18.2 0.18.1 0.18.0.

Tools to generate test data from JSON schemata with Hypothesis

Homepage conda Python Download

Documentation

Hypothesis-jsonschema.

A Hypothesis strategy for generating data that matches some JSON schema .

Here's the PyPI page.

The public API consists of just one function: hypothesis_jsonschema.from_schema , which takes a JSON schema and returns a strategy for allowed JSON objects.

For more details on property-based testing and how to use or customise strategies, see the Hypothesis docs .

JSONSchema drafts 04, 05, and 07 are fully tested and working. As of version 0.11, this includes resolving non-recursive references!

Supported versions

hypothesis-jsonschema requires Python 3.6 or later. In general, 0.x versions will require very recent versions of all dependencies because I don't want to deal with compatibility workarounds.

hypothesis-jsonschema may make backwards-incompatible changes at any time before version 1.x - that's what semver means! - but I've kept the API surface small enough that this should be avoidable. The main source of breaks will be if or when schema that never really worked turn into explicit errors instead of generating values that don't quite match.

You can sponsor me to get priority support, roadmap input, and prioritized feature development.

Contributing to hypothesis-jsonschema

We love external contributions - and try to make them both easy and fun. You can read more details in our contributing guide , and see everyone who has contributed on GitHub . Thanks, everyone!

Patch notes can be found in CHANGELOG.md .

Security contact information

To report a security vulnerability, please use the Tidelift security contact . Tidelift will coordinate the fix and disclosure.

The Tidelift Subscription provides access to a continuously curated stream of human-researched and maintainer-verified data on open source packages and their licenses, releases, vulnerabilities, and development practices.

See all contributors

Something wrong with this page? Make a suggestion

Export .ABOUT file for this package

Last synced: 2021-12-15 19:45:07 UTC

Login to resync this project

• Projects extending Hypothesis
• Edit on GitHub

Projects extending Hypothesis ¶

Hypothesis has been eagerly used and extended by the open source community. This page lists extensions and applications; you can find more or newer packages by searching PyPI by keyword or filter by classifier , or search libraries.io .

If there’s something missing which you think should be here, let us know!

Being listed on this page does not imply that the Hypothesis maintainers endorse a package.

External strategies ¶

Some packages provide strategies directly:

hypothesis-fspaths - strategy to generate filesystem paths.

hypothesis-geojson - strategy to generate GeoJson .

hypothesis-geometry - strategies to generate geometric objects.

hs-dbus-signature - strategy to generate arbitrary D-Bus signatures .

hypothesis-sqlalchemy - strategies to generate SQLAlchemy objects.

hypothesis-ros - strategies to generate messages and parameters for the Robot Operating System .

hypothesis-csv - strategy to generate CSV files.

hypothesis-networkx - strategy to generate networkx graphs.

hypothesis-bio - strategies for bioinformatics data, such as DNA, codons, FASTA, and FASTQ formats.

hypothesis-rdkit - strategies to generate RDKit molecules and representations such as SMILES and mol blocks

hypothesmith - strategy to generate syntatically-valid Python code.

Others provide a function to infer a strategy from some other schema:

hypothesis-jsonschema - infer strategies from JSON schemas .

lollipop-hypothesis - infer strategies from lollipop schemas.

hypothesis-drf - infer strategies from a djangorestframework serialiser.

hypothesis-graphql - infer strategies from GraphQL schemas .

hypothesis-mongoengine - infer strategies from a mongoengine model.

hypothesis-pb - infer strategies from Protocol Buffer schemas.

Or some other custom integration, such as a “hypothesis” entry point :

deal is a design-by-contract library with built-in Hypothesis support.

icontract-hypothesis infers strategies from icontract code contracts.

Pandera schemas all have a .strategy() method, which returns a strategy for matching DataFrame s.

Pydantic automatically registers constrained types - so builds() and from_type() “just work” regardless of the underlying implementation.

Other cool things ¶

Tyche ( source ) is a VSCode extension which provides live insights into your property-based tests, including the distribution of generated inputs and the resulting code coverage. You can read the research paper here .

schemathesis is a tool for testing web applications built with Open API / Swagger specifications . It reads the schema and generates test cases which will ensure that the application is compliant with its schema. The application under test could be written in any language, the only thing you need is a valid API schema in a supported format. Includes CLI and convenient pytest integration. Powered by Hypothesis and hypothesis-jsonschema , inspired by the earlier swagger-conformance library.

Trio is an async framework with “an obsessive focus on usability and correctness”, so naturally it works with Hypothesis! pytest-trio includes a custom hook that allows @given(...) to work with Trio-style async test functions, and hypothesis-trio includes stateful testing extensions to support concurrent programs.

pymtl3 is “an open-source Python-based hardware generation, simulation, and verification framework with multi-level hardware modeling support”, which ships with Hypothesis integrations to check that all of those levels are equivalent, from function-level to register-transfer level and even to hardware.

libarchimedes makes it easy to use Hypothesis in the Hy language , a Lisp embedded in Python.

battle_tested is a fuzzing tool that will show you how your code can fail - by trying all kinds of inputs and reporting whatever happens.

pytest-subtesthack functions as a workaround for issue #377 .

returns uses Hypothesis to verify that Higher Kinded Types correctly implement functor, applicative, monad, and other laws; allowing a declarative approach to be combined with traditional pythonic code.

icontract-hypothesis includes a ghostwriter for test files and IDE integrations such as icontract-hypothesis-vim , icontract-hypothesis-pycharm , and icontract-hypothesis-vscode - you can run a quick ‘smoke test’ with only a few keystrokes for any type-annotated function, even if it doesn’t have any contracts!

Writing an extension ¶

See CONTRIBUTING.rst for more information.

New strategies can be added to Hypothesis, or published as an external package on PyPI - either is fine for most strategies. If in doubt, ask!

It’s generally much easier to get things working outside, because there’s more freedom to experiment and fewer requirements in stability and API style. We’re happy to review and help with external packages as well as pull requests!

If you’re thinking about writing an extension, please name it hypothesis-{something} - a standard prefix makes the community more visible and searching for extensions easier. And make sure you use the Framework :: Hypothesis trove classifier!

On the other hand, being inside gets you access to some deeper implementation features (if you need them) and better long-term guarantees about maintenance. We particularly encourage pull requests for new composable primitives that make implementing other strategies easier, or for widely used types in the standard library. Strategies for other things are also welcome; anything with external dependencies just goes in hypothesis.extra .

Tools such as assertion helpers may also need to check whether the current test is using Hypothesis:

Return True if the calling code is currently running inside an @given or stateful test, False otherwise.

This is useful for third-party integrations and assertion helpers which may be called from traditional or property-based tests, but can only use assume() or target() in the latter case.

Hypothesis integration via setuptools entry points ¶

If you would like to ship Hypothesis strategies for a custom type - either as part of the upstream library, or as a third-party extension, there’s a catch: from_type() only works after the corresponding call to register_type_strategy() , and you’ll have the same problem with register_random() . This means that either

you have to try importing Hypothesis to register the strategy when your library is imported, though that’s only useful at test time, or

the user has to call a ‘register the strategies’ helper that you provide before running their tests

Entry points are Python’s standard way of automating the latter: when you register a "hypothesis" entry point in your setup.py , we’ll import and run it automatically when hypothesis is imported. Nothing happens unless Hypothesis is already in use, and it’s totally seamless for downstream users!

Let’s look at an example. You start by adding a function somewhere in your package that does all the Hypothesis-related setup work:

and then tell setuptools that this is your "hypothesis" entry point:

And that’s all it takes!

If set, disables automatic loading of all hypothesis plugins. This is probably only useful for our own self-tests, but documented in case it might help narrow down any particularly weird bugs in complex environments.

Interaction with pytest-cov ¶

Because pytest does not load plugins from entrypoints in any particular order, using the Hypothesis entrypoint may import your module before pytest-cov starts. This is a known issue , but there are workarounds.

You can use coverage run pytest ... instead of pytest --cov ... , opting out of the pytest plugin entirely. Alternatively, you can ensure that Hypothesis is loaded after coverage measurement is started by disabling the entrypoint, and loading our pytest plugin from your conftest.py instead:

Another alternative, which we in fact use in our CI self-tests because it works well also with parallel tests, is to automatically start coverage early for all new processes if an environment variable is set. This automatic starting is set up by the PyPi package coverage_enable_subprocess .

This means all configuration must be done in .coveragerc , and not on the command line:

Then, set the relevant environment variable and run normally:

Alternative backends for Hypothesis ¶

EXPERIMENTAL AND UNSTABLE.

The importable name of a backend which Hypothesis should use to generate primitive types. We aim to support heuristic-random, solver-based, and fuzzing-based backends.

See issue #3086 for details, e.g. if you’re interested in writing your own backend. (note that there is no stable interface for this; you’d be helping us work out what that should eventually look like, and we’re likely to make regular breaking changes for some time to come)

Using the prototype crosshair-tool backend via hypothesis-crosshair , a solver-backed test might look something like:

GPT -4o, json output and sorting out problems

I want to organize the demerits returned by GPT into three parts: 1、 “problem_type”: “Fill-in-the-Blank”, 2、 “printed_problem_statement”: 3、“handwritten_student_answers”

But the sorting could not be completed. Always error json format. Can anyone tell me where I’m going wrong?

APT Return results

Hi, there is a ‘’'json prefix in front of the json you actually want. You can solve this by cleaning it up with regex:

Remove the backticks and ```json part using regex

Thank you very much . It is done

Related Topics

• Manage Email Subscriptions
• How to Post to DZone
• Article Submission Guidelines
• Manage My Drafts

Low-Code Development: Leverage low and no code to streamline your workflow so that you can focus on higher priorities.

LAST CALL. DZone Security Research: Tell us your top security strategies in 2024, and enter for a chance to win $!

Vector databases: Learn all about the specialized VDBMS — its initial setup, data preparation, collection creation, data querying, and more.

Launch your software development career: Dive head first into the SDLC and learn how to build high-quality software and teams. *Affiliate

• Get Some Rest! A Full API Stack
• Validate XML Request Against XML Schema in Mule 4
• Validate JSON Request Against JSON Schema in Mule 4
• API Testing With Cypress
• Using Agile To Recover Failing Projects
• Mastering Serverless Debugging
• How DevSecOps Can Combat Zero-Day Threats
• Phased Approach to Data Warehouse Modernization
• Software Design and Architecture
• Integration

How To Perform JSON Schema Validation in API Testing Using Rest-Assured Java

This article is a step-by-step tutorial to learn about json schema validation in api automation testing using the rest-assured framework..

Join the DZone community and get the full member experience.

Have you ever come across a situation in automated API testing where you were not able to identify the issue in the test failure and after debugging for multiple hours, you noticed that the data type of the value supplied in the response of the API had changed. Did you then notice that this was the core reason for the test failure?

This type of scenario can generally happen when you have third-party APIs integrated into your application. A real-time example of such a scenario would be integrating with the Bank APIs for making a payment for your e-commerce application or integrating with third-party API which provides the registration and login functionality using two-factor authentication.

In such a situation, though, you would be provided with detailed documentation of the APIs and functionality if it happens that there is a change in the API response from the third-party application since they cater to multiple clients and might have updated their API, maybe for a bug fix or a new feature requirement which you are unaware of.

One of the data type of the field received in response may be changed to integer from String or vice-versa. Or there is a new field/Object added in the response.

Thanks to JSON Schema Validation, these changes can now be caught easily and can save a lot of your efforts and time in debugging and finding the issue that leads to the failure of your system.

Before we begin with discussing the JSON Schema validation, let’s first understand what JSON is, and then continue with the JSON Schema Validation.

What Is JSON?

JSON stands for JavaScript Object Notation. It was originally specified by Douglas Crockford . It is a lightweight format for storing and transporting data and is often used when data is sent from the server to webpages. It is self-describing and easy to understand.

The following are important syntax rules for JSON:

• Data is in name/value pairs
• Data is separated by commas
• Curly braces hold objects
• Square brackets hold arrays

To understand further, let's take the following JSON file as an example:

Understanding the JSON File

The above-mentioned file begins with a curly brace { which means the file holds a JSON object. Inside the JSON object, data is stored in multiple data types as follows:

1. The root level itself is a JSON Object as it has a curly bracket to start with and has data stored in a key/value pair

2. JSON Array

JSON Array stores data inside the JSON file in a block with square bracket [] . If we take the example of the JSON file mentioned above, employee_data JSON array has 2 JSON Objects inside it.

3. JSON Object

As mentioned earlier, data stored within curly braces are JSON Objects and have multiple key/value pairs in them.

The company JSON Object holds the data for company details:

It can also be referred as company key  holding the company details record in its value .

What Is JSON Schema?

JSON Schema is a specification for JSON-based format for defining the structure of JSON data.

JSON Schema helps us describe the existing data format and provides clear, human and machine-readable documentation.

As JSON Schema provides complete structural validation, it helps in automated tests and also validating the client-submitted data for verification.

How Do I Generate JSON Schema for the JSON Request of an API?

Consider the following example of Post Response from a restful-booker website where the following data is returned in response once the user hits the post API for creating a new booking:

To generate the JSON Schema, we would be using an   online JSON schema generator tool from extendsclass.com .   Using this tool is very simple, you just need to copy and paste the JSON data for which you need to generate the JSON schema and click on the Generate Schema from JSON button on the web page and it will provide you with the JSON schema for the respective JSON data provided.

Here is the JSON Schema generated for the above JSON data for creating a new booking:

Understanding the JSON Schema

If you check the JSON data, the following two fields are the main records:

• Object of booking data

The following block generated in JSON Schema talks about these 2 fields that in root, these two fields are required as an Object type.

Next, let's talk about the properties block inside the JSON Schema. The following block states that bookingid should be in the root object and its type should be integer . Hence, in response, it is expected that the value in this field should be an integer   only. So, in case this type is changed to any other data type like String , Object , long or float , schema validation will fail and we would be able to identify the issue in the schema right away.

Likewise, you can notice the data types and required field values mentioned for the other fields in the JSON Schema.

Performing the JSON Schema Validation Using Rest-Assured Framework

What is rest-assured.

REST-Assured is a Java library that provides a domain-specific language (DSL) for writing powerful, maintainable tests for RESTful APIs. One thing I really like about rest assured is its BDD style of writing tests and one can read the tests very easily in a human-readable language.

Getting Started

The project is created using Maven . Once the project is created we need to add the dependency for rest-assured in pom.xml file. TestNG is used as a test runner.

The following dependencies are mandatorily required to be added in pom.xml

rest-assured dependency is required for running the API tests and json-schema-validator dependency is required for validating the JSON Schema.

Validating the JSON Schema

Step 1:  First of all, we need to generate the JSON Schema for the response JSON data which we need to validate.

As we are using the restful-booker create booking API, we would be copy-pasting the JSON response and generating the JSON schema using the JSON Schema Validator . In the screenshot below, on the left-hand side we have the JSON response. On clicking the Generate Schema from JSON button , JSON Schema would be generated on the right-hand section.

The following is the response received from create booking API in restful-booker .

The following is the JSON Schema for the above JSON response.

Project Folder Structure

We can copy the JSON Schema create a new JSON file and put it in the src\test\resources folder inside the project.

Writing JSON Schema Validation Test

The following test script will allow us to test the JSON Schema validation using the Rest-Assured framework.

It is pretty simple to write automation tests using Rest-Assured. We need to write the assertion for validating the JSON Schema inside the body()   method after the assertThat() method .  But before we move to the assertion, we need to read the JSON file we posted inside the src\test\resources folder. To do that we would be using the InputStream class .  The following line of code will help us in reading the JSON Schema file createbookingjsonschema.json

Next, we need to hit the post API and check the JSON Schema in response by using JsonSchemaValidator.matchesJsonSchema() method and pass the createBookingJsonSchema  InputStream instance in it .

The data required in the post-request payload will be generated using Builder pattern + Data Faker .  The following is the implementation of getBookingData() method that is available in the BookingData class.

Once the payload data is generated, it is very easy to write the JSON Schema validation test.

The following lines of code will help us in validating the JSON Schema in the response. Interpreting the lines of code given below, we are sending a post request with the body as required for Post API after which we are checking the status code returned in response is 200 and that the body has the JSON Schema as provided in the createBookingJsonSchema instance.

Running the Tests

Ite time now to run the test and check if the Schema validation happens correctly. Here is the Screenshot of testng.xml file.

Let’s run the tests now and validate the JSON Schema. We would be running the tests using TestNG by right-clicking on the testng.xml file.

In bookingid field, value of type integer is required however it has been updated to string just to check if the validation is actually working fine.

Let’s run the test again by right-clicking on the testng.xml file.

The following error log was generated and displayed in the console, which says that the value received in response was an integer whereas the value expected was string

You See! How easy it is to identify such kind of schema-related errors which if not done could have taken a lot of your effort as well as time to find it.

Running automated tests for checking the JSON Schema validation could prove to be a fruitful exercise and help in detecting the schema-level issues before they slip into production. It is recommended to add these checks in the automated pipeline and run them as regression tests in the nightly build. 

Happy Testing!

Published at DZone with permission of Faisal Khatri . See the original article here.

Opinions expressed by DZone contributors are their own.

Partner Resources

• About DZone
• Send feedback
• Community research
• Advertise with DZone

CONTRIBUTE ON DZONE

• Become a Contributor
• Core Program
• Visit the Writers' Zone
• Terms of Service
• Privacy Policy
• 3343 Perimeter Hill Drive
• Nashville, TN 37211
• [email protected]

Let's be friends:

• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
• OverflowAI GenAI features for Teams
• OverflowAPI Train & fine-tune LLMs
• Labs The future of collective knowledge sharing
• About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

Tool to generate JSON schema from JSON data [closed]

We have this json schema draft . I would like to get a sample of my JSON data and generate a skeleton for the JSON schema, that I can rework manually, adding things like description, required, etc, which can not be infered from the specific examples.

For example, from my input example.json :

I would run my json_schema_generator tool and would get:

This example has been coded manually, so it may have errors. Is there any tool out there which could help me with the conversion JSON -> JSON schema?

• 1 In the example provided, I would say it is clear that we have a dictionary (python terminology), with key-value pairs, where the values happen to be strings. I do not know of any other JSON schema that would describe the same data. And this is just an easy example: it could get much more complicated, of course, as specified in the JSON schema draft. –  blueFast Commented Sep 8, 2011 at 0:18
• 3 So you're claiming that "map from arbitrary strings to other arbitrary strings" (such as a mapping from file names to descriptions of the content) cannot be expressed as a JSON schema? For all I know, that may be true, but it would make that kind of schemata rather useless in my view. –  hmakholm left over Monica Commented Sep 8, 2011 at 0:26
• 1 Mmmm, I am not sure we are discussing something relevant to the question, but anyway. Let's use a better example: having fixed keys in the JSON data is definitely useful if that JSON data is, for example, describing properties of a person. Instead of "foo" and "bar", think about "name", and "surname". "name" and "surname" are clearly fixed properties of the person JSON data, so they are not arbitrary strings: they are part of the person schema. The values are of course arbitrary, so they are not part of the schema. –  blueFast Commented Sep 8, 2011 at 5:10
• 3 Having fixed keys is sometimes what you want, and sometimes it isn't. That's the entire point in fact: there's no way an automated tool can detect from at single sample which of the options you want. –  hmakholm left over Monica Commented Sep 8, 2011 at 11:54
• 3 I wouldn't have voted the question off-topic. If you're a programmer, it's a great question. –  Someone Somewhere Commented Mar 30, 2020 at 4:28

12 Answers 12

Summarising the other answers, here are the JSON schema generators proposed so far:

• https://www.liquid-technologies.com/online-json-to-schema-converter (1 input)
• http://www.jsonschema.net (1 input)
• https://easy-json-schema.github.io (1 input)
• https://github.com/gonvaled/jskemator (1 input but allows iteration)
• https://github.com/perenecabuto/json_schema_generator (1 input)
• https://github.com/rnd0101/json_schema_inferencer (1 input I think)
• https://pypi.python.org/pypi/genson/ (multiple inputs)
• https://pypi.python.org/pypi/skinfer (multiple inputs)
• https://github.com/Nijikokun/generate-schema (multiple inputs (pass object array))
• https://github.com/easy-json-schema/easy-json-schema (1 input)
• https://github.com/aspecto-io/genson-js (multiple inputs)
• https://github.com/maxlinc/json-schema-generator (1 input)

• jskemetor - no setup.py –  Att Righ Commented Aug 14, 2017 at 12:59
• Any chance you know if any of these support YAML inputs? We could convert, but just an extra step. –  DylanYoung Commented Oct 8, 2019 at 14:46
• Python: only genson are maintained ^), easy-json-schema works the same as genson and it doesn't have symbols limit like other online tools –  MoonRaiser Commented Dec 20, 2022 at 9:34
• liquid-technologies.com/online-json-to-schema-converter -> Did create a exact schema for my input JSON, all existing fields are required - the schema is about 3000 lines easy-json-schema.github.io -> Did simplify a repeating pattern(array), schema is about 70 lines. No fields are required. (But that can be added by adding a * ..) –  Benjamin Commented Feb 7, 2023 at 14:13

You might be looking for this:

http://www.jsonschema.net

It is an online tool that can automatically generate JSON schema from JSON string. And you can edit the schema easily.

• 4 An easy and handy place to start. But note reported issues with jsonschema.net identified elsewhere on this page, and the reasons discussed for wanting an offline, or at least API-accessible, tool to include in development workflows, allow updating of schemas with later example etc. See also the nice list of options by Steve Bennett. –  nealmcb Commented Oct 26, 2017 at 19:26
• Please note that this site will throw unexpected errors when editing the schema after the initial import. –  Coreus Commented Nov 13, 2017 at 11:22
• 1 Crashes for something like {"hello": "world","num": 42} but looks promising- –  DBX12 Commented Feb 2, 2018 at 11:24
• 5 The old sites were definitely not good enough. JSONSchema.Net has now been rewritten. It's much more robust. If you have any issues, please report them on GitHub and I'll gladly fix them: github.com/jackwootton/json-schema –  Jack Commented Feb 21, 2018 at 8:17
• 2 Warning - This site now has a login wall unfortunately :( –  user2085368 Commented Nov 27, 2021 at 21:11

GenSON ( PyPI | Github ) is a JSON Schema generator that can generate a single schema from multiple objects. You can also merge schemas with it. It is written in Python and comes with a CLI tool.

(Full disclosure: I'm the author.)

• 1 Nice work, man! I regret not finding this before I started to work on skinfer: github.com/scrapinghub/skinfer –  Elias Dorneles Commented Sep 23, 2015 at 12:28
• 1 Not a python, but here's another one github.com/snowplow/schema-guru –  chuwy Commented Sep 25, 2015 at 12:21
• 1 Great! I've been disappointed with the online schema generator jsonschema.net (it fails to create "required" properties for most objects, has no options to produce compact (one-line) properties or omit IDs, and most importantly, generates a schema that fails to validate the data used to create it for single-schema arrays). Looking forward to trying your tool. –  Dave Commented Feb 17, 2016 at 19:25
• @Dave - i m too facing similar problems with json schema.net, did this python tool help ? –  Cshah Commented Feb 7, 2017 at 13:44
• 1 @Cshah: I'm extremely impressed with GenSON and contributed a patch to it. I needed to generate more restrictive schemas than the author was comfortable with so I forked a version with options to generate pattern properties and additionalProperties / additionalItems so that unrecognized JSON data will be flagged as needing attention. –  Dave Commented Feb 14, 2017 at 15:52

Seeing that this question is getting quite some upvotes, I add new information (I am not sure if this is new, but I couldn't find it at the time)

• The home of JSON Schema
• An implementation of JSON Schema validation for Python
• Related hacker news discussion
• A json schema generator in python , which is what I was looking for.

After several months, the best answer I have is my simple tool. It is raw but functional.

What I want is something similar to this . The JSON data can provide a skeleton for the JSON schema. I have not implemented it yet, but it should be possible to give an existing JSON schema as basis, so that the existing JSON schema plus JSON data can generate an updated JSON schema. If no such schema is given as input, completely default values are taken.

This would be very useful in iterative development: the first time the tool is run, the JSON schema is dummy, but it can be refined automatically according to the evolution of the data.

• 2 Curious as to how @Green Su's suggestion didn't live up to your needs. I think you are describing a utility that provides jumpstarter (your term is 'skeletal') - something like a scaffolding code generator? –  justSteve Commented Aug 9, 2012 at 2:20
• 14 Basically, the problem with that tool is that it is an online tool. I need it to run it locally in my development environment, sometimes automatically as part of other tasks. A "copy here, paste there" tool does not help me. If it had a REST API that would be good enough. –  blueFast Commented Aug 9, 2012 at 9:18
• 4 @justSteve: the online tool, in addition to using a copy-paste workflow, still appears buggy (4 years after the original question). I have json objects for which the tool produces incorrect schemas but have not yet reduced them to minimal test cases to submit as bug reports. –  Dave Commented Feb 17, 2016 at 19:55

There's a python tool to generate JSON Schema for a given JSON: https://github.com/perenecabuto/json_schema_generator

• 6 This is unmaintained since 2013. It doesn't support Python 3. Moreover, it only supports an older draft, i.e. draft-03 . –  Asclepius Commented Aug 7, 2017 at 16:35

generate-schema ( NPM | Github ) takes a JSON Object generates schemas from it, one output is JSON Schema, it's written in Node.js and comes with a REPL and ClI tool for piping files into.

Full Disclosure: I'm the author :)

• Any plans to update the module to draft 4+? Adding min, max attrs, references and so on? Thanks for the tool btw :) Will be using it in my Project –  Mr. Alien Commented Dec 23, 2018 at 15:13

There's a nodejs tool which supports json schema v4 at https://github.com/krg7880/json-schema-generator

It works either as a command line tool, or as a nodejs library:

• 1 Comes with a CLI as well! –  Peter Ilfrich Commented Mar 3, 2016 at 0:50

json-schema-generator is a neat Ruby based JSON schema generator. It supports both draft 3 and 4 of the JSON schema. It can be run as a standalone executable, or it can be embedded inside of a Ruby script.

Then you can use json-schema to validate JSON samples against your newly generated schema if you want.

For the offline tools that support multiple inputs, the best I've seen so far is https://github.com/wolverdude/GenSON/ I'd like to see a tool that takes filenames on standard input because I have thousands of files. However, I run out of open file descriptors, so make sure the files are closed . I'd also like to see JSON Schema generators that handle recursion. I am now working on generating Java classes from JSON objects in hopes of going to JSON Schema from my Java classes. Here is my GenSON script if you are curious or want to identify bugs in it.

• First, can you provide an answer to unix.stackexchange.com/questions/211803/… ? –  Dave Commented Feb 17, 2016 at 20:14

There are a lot of tools mentioned, but one more called JSON Schema inferencer for the record:

https://github.com/rnd0101/json_schema_inferencer

(it's not a library or a product, but a Python script)

With the usual Full Disclosure: I am the author.

For node.js > 6.0.0 there is also the json-schema-by-example module.

Not the answer you're looking for? Browse other questions tagged json validation reflection jsonschema or ask your own question .

• Featured on Meta
• Upcoming initiatives on Stack Overflow and across the Stack Exchange network...
• Announcing a change to the data-dump process
• What makes a homepage useful for logged-in users

Hot Network Questions

• The human population on Earth reached its maximum with the end of the last zoo
• How to enter curly brace "{" as text in LaTex
• Team member working from home is distracted with kids while on video calls - should I say anything as her manager?
• QGIS (qgis2web) automatically update data set
• Has a rocket engine ever been reused by a second/third stage
• Older brother licking younger sister's legs
• Related low p-values that do not meet statistically significant thresholds
• How do we we scan 'nunc tantum sinus et statio mala fidèle carinis'
• Left zero-padded string in C++
• Can a star be made of sun spots?
• how to round numbers after comma everytime up
• Numbers in Generating Phase Coherent Electronic Systems
• Futuristic show/film about an empire and rebels where the empire rigs a rebel to explode
• Is there evidence of Mushroom's presence in "House of the Dragon" even if he doesn't appear on screen?
• o y u (or and or)
• Why is animateinline stretching my text, and how can I stop it?
• Automatic index creation - too many
• Good to have a packed tourist like itinerary when considering for Japan's visitor visa?
• Pattern on a PCB
• Upper Midwest weed - how to prevent/kill?
• Is this an invitation to submit or a polite rejection?
• How would the dynamics of discourse change if your interlocutor were a superintelligent being?
• How do I get Windows 11 to use existing Linux GPT on 6TB external HDD?
• Why doesn't sed have a j command?

Navigation Menu

Search code, repositories, users, issues, pull requests..., provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

• Notifications You must be signed in to change notification settings

Tools to generate test data from JSON schemata with Hypothesis

cs-lecture-ws2018/hypothesis-json

Folders and files.

Repository files navigation

Hypothesis-jsonschema.

A Hypothesis strategy for generating data that matches some JSON schema .

Here's the PyPI page.

The public API consists of just one function: hypothesis_jsonschema.from_schema , which takes a JSON schema and returns a strategy for allowed JSON objects.

For more details on property-based testing and how to use or customise strategies, see the Hypothesis docs .

JSONSchema drafts 04, 05, and 07 are fully tested and working. As of version 0.11, this includes resolving non-recursive references!

Supported versions

hypothesis-jsonschema requires Python 3.6 or later. In general, 0.x versions will require very recent versions of all dependencies because I don't want to deal with compatibility workarounds.

hypothesis-jsonschema may make backwards-incompatible changes at any time before version 1.x - that's what semver means! - but I've kept the API surface small enough that this should be avoidable. The main source of breaks will be if or when schema that never really worked turn into explicit errors instead of generating values that don't quite match.

You can sponsor me to get priority support, roadmap input, and prioritized feature development.

Contributing to hypothesis-jsonschema

We love external contributions - and try to make them both easy and fun. You can read more details in our contributing guide , and see everyone who has contributed on GitHub . Thanks, everyone!

Patch notes can be found in CHANGELOG.md .

Security contact information

To report a security vulnerability, please use the Tidelift security contact . Tidelift will coordinate the fix and disclosure.

• Python 100.0%