Reference · command

metais test

Render every example of a package and compare it with the outputs it should produce.

Authoring

Usage

metais test [<package>] [--example <name>]... [--update [--dry-run]] [--limit <name>=<value>]... [--json]

Examples

metais test
Tests every example of the source directory in the working directory.
metais test report-1.0.0.metais --example basic
Tests the example basic of a packed package.
metais test --update --dry-run
Lists what --update would write into and remove from each example's expected/.
metais test --json
Prints every finding and each example's result as one metais.test/1 document.

Detail

The package is a source directory, the current directory when omitted, or a packed package file, whose examples are read in place. The package is opened and verified whole, and every template is parsed; an error there is reported and no example runs.

An example is a directory under examples/: inputs/ is a data directory, read as --data reads one; expected/ is the output directory a render should write; example.yaml may give a title, a description, and now, the render time. Every example runs, or each one --example names, in byte order of name, whatever another found. Its inputs are validated, with findings located in examples/<name>/inputs/; if they are valid it is rendered in memory as metais render renders, with now from example.yaml or none, and nothing else of the host. The package digest a template sees, and the provenance tag's package_digest, are sha256: and 64 zeros, and the provenance tool is test, so an expected output records nothing that changes with the package or the tool.

When expected/ exists, its files are compared with the render's by path, byte for byte but for a container; directories are ignored. A file the render did not write is example.output_missing, one it wrote that expected/ lacks is example.output_unexpected, and different content is example.output_differs: for text, a unified diff, of at most 40 lines here and 16 KiB in --json; for a binary file, the first differing byte and both sizes and digests. Its cause names the first likely explanation that applies: line endings, one final newline, a byte order mark, or trailing whitespace.

A container output is compared by its entries, not its zip's bytes: their names in order, each entry's uncompressed content, and the method of each entry declared stored: true and of a profile's mimetype; any other entry's method is the encoder's choice and is not compared. The expected container is read as a packed package is, with its bounds and profile, but in its entries' own order, and one that does not read is example.expected_unreadable. An entry expected and not written is example.entry_missing, one written and not expected example.entry_unexpected, entries in another order example.entry_order, at the first index where they differ, a stored entry the expected container deflates example.entry_method, and different content example.output_differs, located at <output>!<entry>; a container entry is compared by its own entries. An example without expected/ is rendered and not compared.

--update, on a source directory only, makes each selected example's expected/ exactly its render: every file that is missing or differs is written, through a staging directory inside expected/, and every file there the render no longer writes is removed, with any directory that empties. Only an example whose inputs validated and that rendered is updated, and nothing outside examples/<name>/expected/ is ever removed. Each file written or removed is listed; with --dry-run they are listed and nothing is written.

test exits 1 when any example fails.

Operands

<package>
A source directory, or a packed package file; the current directory when omitted. - is refused, since a package is read with random access.

Flags

--example <name>
Test only this example; repeatable. Without it, every example is tested. May be given more than once.
--update
Make each selected example's expected/ exactly its render, writing and removing files there; a source directory only.
--dry-run
With --update, list the files it would write and remove, and write nothing.
--limit <name>=<value>
Lower one resource limit for this run, to a whole number no higher than its default (a size may end in KiB, MiB or GiB). metais limits lists them. May be given more than once.
--fail-on <severity>
With warning, a warning fails the command with exit status 1 as an error does; no finding's severity changes. Values: error, warning. Default: error.
--json
Print the result as one JSON document on standard output.
--color <when>
Colour human output: auto colours a stream that is a terminal when NO_COLOR is unset or empty; always and never override NO_COLOR. Values: auto, always, never. Default: auto.
-h, --help
Print help to standard output and exit 0; nothing else runs.

Prints

Every finding, then a line counting the errors, warnings and notes, then one line per example with its status and each difference, a text difference's diff beneath it; with --update, each file written or removed.

--json: metais.test/1

Refusals

collection.as_file
An example's inputs are refused (as file). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
collection.directory_name
An example's inputs are refused (directory name). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
collection.item_name
An example's inputs are refused (item name). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
collection.stem_duplicate
An example's inputs are refused (stem duplicate). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
collection.subdirectory
An example's inputs are refused (subdirectory). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
csv.after_quote
An example's inputs are refused (after quote). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
csv.bare_quote
An example's inputs are refused (bare quote). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
csv.field_count
An example's inputs are refused (field count). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
csv.header_duplicate
An example's inputs are refused (header duplicate). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
csv.header_empty
An example's inputs are refused (header empty). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
csv.header_missing
An example's inputs are refused (header missing). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
csv.unterminated_quote
An example's inputs are refused (unterminated quote). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
example.entry_method
An example fails (entry method). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
example.entry_missing
An example fails (entry missing). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
example.entry_order
An example fails (entry order). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
example.entry_unexpected
An example fails (entry unexpected). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
example.expected_unreadable
An example fails (expected unreadable). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
example.metadata
An example fails (metadata). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
example.output_differs
An example fails (output differs). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
example.output_missing
An example fails (output missing). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
example.output_unexpected
An example fails (output unexpected). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.additional_item
An example's inputs are refused (additional item). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.additional_property
An example's inputs are refused (additional property). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.any_of
An example's inputs are refused (any of). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.const
An example's inputs are refused (const). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.constraints_failed
An example's inputs are refused (constraints failed). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.constraints_not_evaluated
An example's inputs are refused (constraints not evaluated). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.contains
An example's inputs are refused (contains). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.coverage
An example's inputs are refused (coverage). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.dependent_required
An example's inputs are refused (dependent required). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.encoding_invalid
An example's inputs are refused (encoding invalid). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.enum
An example's inputs are refused (enum). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.exclusive_maximum
An example's inputs are refused (exclusive maximum). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.exclusive_minimum
An example's inputs are refused (exclusive minimum). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.extension_not_accepted
An example's inputs are refused (extension not accepted). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.file_duplicate
An example's inputs are refused (file duplicate). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.file_unknown
An example's inputs are refused (file unknown). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.forbidden
An example's inputs are refused (forbidden). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.format
An example's inputs are refused (format). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.json_arg_invalid
An example's inputs are refused (json arg invalid). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.json_arg_not_object
An example's inputs are refused (json arg not object). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.json_arg_unknown
An example's inputs are refused (json arg unknown). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
An example's inputs are refused (link). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.max_contains
An example's inputs are refused (max contains). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.max_items
An example's inputs are refused (max items). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.max_length
An example's inputs are refused (max length). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.max_properties
An example's inputs are refused (max properties). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.maximum
An example's inputs are refused (maximum). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.min_contains
An example's inputs are refused (min contains). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.min_items
An example's inputs are refused (min items). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.min_length
An example's inputs are refused (min length). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.min_properties
An example's inputs are refused (min properties). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.minimum
An example's inputs are refused (minimum). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.missing
An example's inputs are refused (missing). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.multiple_of
An example's inputs are refused (multiple of). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.noncharacter
An example's inputs are refused (noncharacter). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.not
An example's inputs are refused (not). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.not_readable
An example's inputs are refused (not readable). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.not_regular_file
An example's inputs are refused (not regular file). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.number_out_of_range
An example's inputs are refused (number out of range). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.one_of
An example's inputs are refused (one of). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.one_of.ambiguous
An example's inputs are refused (one of: ambiguous). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.pattern
An example's inputs are refused (pattern). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.property_name
An example's inputs are refused (property name). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.raw_unavailable
An example's inputs are refused (raw unavailable). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.required
An example's inputs are refused (required). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.set_into_unparsed
An example's inputs are refused (set into unparsed). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.set_pointer_invalid
An example's inputs are refused (set pointer invalid). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.set_traversal
An example's inputs are refused (set traversal). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.type
An example's inputs are refused (type). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.unevaluated_item
An example's inputs are refused (unevaluated item). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.unevaluated_property
An example's inputs are refused (unevaluated property). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.unique_items
An example's inputs are refused (unique items). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.unique_keys
An example's inputs are refused (unique keys). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
input.validation.partial
An example's inputs are refused (validation: partial). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
json.duplicate_name
An example's inputs are refused (duplicate name). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
json.lone_surrogate
An example's inputs are refused (lone surrogate). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
json.noncharacter
An example's inputs are refused (noncharacter). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
json.syntax
An example's inputs are refused (syntax). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
json.trailing_content
An example's inputs are refused (trailing content). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
limit.exceeded
An example's inputs are refused (exceeded). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
limit.exceeded.output
An example's output is refused (exceeded: output). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
limit.exceeded.template
An example's output is refused (exceeded: template). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
limit.invalid
A --limit names no limit, gives a malformed value, or tries to raise one. Next: metais limits: Lists every limit with its default; a limit can be lowered and never raised.
limit.package
The package breaches one of its limits. Next: metais limits: Lists every limit with its default; a limit can be lowered and never raised.
manifest.additional_property
The manifest breaks one of its rules (additional property). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.const
The manifest breaks one of its rules (const). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.contains
The manifest breaks one of its rules (contains). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.dependent_required
The manifest breaks one of its rules (dependent required). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.enum
The manifest breaks one of its rules (enum). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.file.wrong_name
The manifest breaks one of its rules (file: wrong name). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.forbidden
The manifest breaks one of its rules (forbidden). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.input.duplicate_name
The manifest breaks one of its rules (input: duplicate name). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.json.duplicate_name
The manifest breaks one of its rules (json: duplicate name). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.json.encoding
The manifest breaks one of its rules (json: encoding). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.json.lone_surrogate
The manifest breaks one of its rules (json: lone surrogate). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.json.noncharacter
The manifest breaks one of its rules (json: noncharacter). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.json.syntax
The manifest breaks one of its rules (json: syntax). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.json.trailing_content
The manifest breaks one of its rules (json: trailing content). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.license.expression
The manifest breaks one of its rules (license: expression). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.max_items
The manifest breaks one of its rules (max items). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.max_length
The manifest breaks one of its rules (max length). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.min_items
The manifest breaks one of its rules (min items). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.min_length
The manifest breaks one of its rules (min length). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.not
The manifest breaks one of its rules (not). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.number_out_of_range
The manifest breaks one of its rules (number out of range). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.one_of
The manifest breaks one of its rules (one of). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.output.duplicate_id
The manifest breaks one of its rules (output: duplicate id). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.output.nested_for_each
The manifest breaks one of its rules (output: nested for each). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.path_not_found
The manifest breaks one of its rules (path not found). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.pattern
The manifest breaks one of its rules (pattern). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.required
The manifest breaks one of its rules (required). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.type
The manifest breaks one of its rules (type). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.unique_items
The manifest breaks one of its rules (unique items). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.yaml.alias
The manifest breaks one of its rules (yaml: alias). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.yaml.anchor
The manifest breaks one of its rules (yaml: anchor). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.yaml.bom
The manifest breaks one of its rules (yaml: bom). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.yaml.character
The manifest breaks one of its rules (yaml: character). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.yaml.directive
The manifest breaks one of its rules (yaml: directive). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.yaml.duplicate_key
The manifest breaks one of its rules (yaml: duplicate key). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.yaml.encoding
The manifest breaks one of its rules (yaml: encoding). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.yaml.key_empty
The manifest breaks one of its rules (yaml: key empty). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.yaml.key_not_scalar
The manifest breaks one of its rules (yaml: key not scalar). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.yaml.merge_key
The manifest breaks one of its rules (yaml: merge key). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.yaml.multi_document
The manifest breaks one of its rules (yaml: multi document). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.yaml.root_not_mapping
The manifest breaks one of its rules (yaml: root not mapping). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.yaml.scalar_refused
The manifest breaks one of its rules (yaml: scalar refused). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.yaml.syntax
The manifest breaks one of its rules (yaml: syntax). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
manifest.yaml.tag
The manifest breaks one of its rules (yaml: tag). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
markdown.frontmatter_body_field
An example's inputs are refused (frontmatter body field). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
markdown.frontmatter_not_mapping
An example's inputs are refused (frontmatter not mapping). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
markdown.frontmatter_unclosed
An example's inputs are refused (frontmatter unclosed). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.additional_item
An example's output fails its validation (additional item). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.additional_property
An example's output fails its validation (additional property). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.any_of
An example's output fails its validation (any of). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.const
An example's output fails its validation (const). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.container.missing_entry
An example's output is refused (container: missing entry). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.container.non_ascii
An example's output is refused (container: non ascii). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.container.reserved_entry
An example's output is refused (container: reserved entry). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.container.space
An example's output is refused (container: space). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.container.too_many_entries
An example's output is refused (container: too many entries). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.contains
An example's output fails its validation (contains). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.coverage
An example's output fails its validation (coverage). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.declaration.empty_mirror
An example's output fails its validation (declaration: empty mirror). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.declaration.empty_name
An example's output fails its validation (declaration: empty name). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.declaration.validate_kind
An example's output fails its validation (declaration: validate kind). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.dependent_required
An example's output fails its validation (dependent required). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.destination.not_directory
An example's expected/, or a directory in it, is not a directory where --update writes. Next: metais test <dir> --update: Updates the examples again once the cause is fixed; the files already written or removed are listed.
output.destination.nothing_written
--update's first write into, or removal from, an example's expected/ failed; nothing was written or removed. Next: metais test <dir> --update: Updates the examples again once the cause is fixed; the files already written or removed are listed.
output.destination.staging_exists
An example's expected/ holds .metais-staging, left by a killed write or in use by another, before --update had written or removed anything. Next: metais test <dir> --update: Updates the examples again once the cause is fixed; the files already written or removed are listed.
output.destination.write_failed
--update's write into, or removal from, an example's expected/ failed after it had written or removed a file; what it wrote and removed is listed. Next: metais test <dir> --update: Updates the examples again once the cause is fixed; the files already written or removed are listed.
output.enum
An example's output fails its validation (enum). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.exclusive_maximum
An example's output fails its validation (exclusive maximum). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.exclusive_minimum
An example's output fails its validation (exclusive minimum). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.expression.for_each_type
An example's output is refused (expression: for each type). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.forbidden
An example's output fails its validation (forbidden). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.format
An example's output fails its validation (format). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.max_contains
An example's output fails its validation (max contains). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.max_items
An example's output fails its validation (max items). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.max_length
An example's output fails its validation (max length). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.max_properties
An example's output fails its validation (max properties). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.maximum
An example's output fails its validation (maximum). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.min_contains
An example's output fails its validation (min contains). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.min_items
An example's output fails its validation (min items). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.min_length
An example's output fails its validation (min length). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.min_properties
An example's output fails its validation (min properties). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.minimum
An example's output fails its validation (minimum). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.multiple_of
An example's output fails its validation (multiple of). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.not
An example's output fails its validation (not). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.one_of
An example's output fails its validation (one of). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.one_of.ambiguous
An example's output fails its validation (one of: ambiguous). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.parse
An example's output fails its validation (parse). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.path.case_collision
An example's output is refused (path: case collision). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.path.character
An example's output is refused (path: character). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.path.duplicate
An example's output is refused (path: duplicate). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.path.encoding
An example's output is refused (path: encoding). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.path.file_directory_conflict
An example's output is refused (path: file directory conflict). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.path.not_nfc
An example's output is refused (path: not nfc). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.path.not_portable
An example's output is refused (path: not portable). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.path.shape
An example's output is refused (path: shape). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.pattern
An example's output fails its validation (pattern). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.property_name
An example's output fails its validation (property name). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.required
An example's output fails its validation (required). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.type
An example's output fails its validation (type). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.unevaluated_item
An example's output fails its validation (unevaluated item). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.unevaluated_property
An example's output fails its validation (unevaluated property). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.unique_items
An example's output fails its validation (unique items). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
output.unique_keys
An example's output fails its validation (unique keys). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.compiled.mismatch
The package is refused (compiled: mismatch). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.compiled.missing
The package is refused (compiled: missing). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.compiled.unknown_file
The package is refused (compiled: unknown file). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.container.archive_comment
The package is refused (container: archive comment). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.container.crc_mismatch
The package is refused (container: crc mismatch). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.container.data_descriptor
The package is refused (container: data descriptor). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.container.deflate_stream
The package is refused (container: deflate stream). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.container.encrypted
The package is refused (container: encrypted). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.container.entry_order
The package is refused (container: entry order). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.container.extra_field
The package is refused (container: extra field). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.container.field_value
The package is refused (container: field value). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.container.flags
The package is refused (container: flags). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.container.header_mismatch
The package is refused (container: header mismatch). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.container.method
The package is refused (container: method). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.container.not_zip
The package is refused (container: not zip). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.container.overlap_or_gap
The package is refused (container: overlap or gap). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.container.prepended_data
The package is refused (container: prepended data). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.container.second_end_record
The package is refused (container: second end record). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.container.size_mismatch
The package is refused (container: size mismatch). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.container.trailing_data
The package is refused (container: trailing data). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.container.zip64
The package is refused (container: zip64). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.digest.entries_mismatch
The package is refused (digest: entries mismatch). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.digest.mismatch
The package is refused (digest: mismatch). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.digest.not_canonical
The package is refused (digest: not canonical). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.digest.package_mismatch
The package is refused (digest: package mismatch). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.layout.compiled_in_source
The package is refused (layout: compiled in source). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.layout.empty_directory
The package is refused (layout: empty directory). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.layout.missing_manifest
The package is refused (layout: missing manifest). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.layout.non_regular_file
The package is refused (layout: non regular file). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.layout.readme
The package is refused (layout: readme). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.layout.unknown_top_level
The package is refused (layout: unknown top level). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.name.case_collision
The package is refused (name: case collision). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.name.character
The package is refused (name: character). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.name.directory_entry
The package is refused (name: directory entry). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.name.duplicate
The package is refused (name: duplicate). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.name.encoding
The package is refused (name: encoding). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.name.file_directory_conflict
The package is refused (name: file directory conflict). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.name.not_nfc
The package is refused (name: not nfc). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.name.not_portable
The package is refused (name: not portable). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.name.shape
The package is refused (name: shape). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.not_found
The package is refused (not found). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.not_readable
The package is refused (not readable). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.version.malformed
The package is refused (version: malformed). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.version.missing
The package is refused (version: missing). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.version.not_string
The package is refused (version: not string). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.version.unsupported_major
The package is refused (version: unsupported major). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
package.version.unsupported_minor
The package is refused (version: unsupported minor). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
schema.dialect
An input schema is refused (dialect). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
schema.format_unsupported
An input schema is refused (format unsupported). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
schema.id_duplicate
An input schema is refused (id duplicate). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
schema.invalid
An input schema is refused (invalid). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
schema.keyword_unknown
An input schema is refused (keyword unknown). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
schema.pattern_unsupported
An input schema is refused (pattern unsupported). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
schema.ref_by_path
An input schema is refused (ref by path). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
schema.ref_escapes
An input schema is refused (ref escapes). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
schema.ref_unresolved
An input schema is refused (ref unresolved). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
schema.syntax
An input schema is refused (syntax). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.amount_currency
An output's path, when or for_each does not parse (amount currency). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.asset_ambiguous
A template is refused (asset ambiguous). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.asset_not_found
A template is refused (asset not found). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.asset_not_text
A template is refused (asset not text). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.asset_not_written
A template is refused (asset not written). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.asset_tree
A template is refused (asset tree). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.comparison
A template is refused (comparison). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.date_format
An output's path, when or for_each does not parse (date format). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.date_input
A template is refused (date input). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.division_by_zero
An output's path, when or for_each does not parse (division by zero). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.duration_format
An output's path, when or for_each does not parse (duration format). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.duration_input
A template is refused (duration input). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.embed_index
A template is refused (embed index). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.embed_unknown_input
A template is refused (embed unknown input). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.filter_argument
An output's path, when or for_each does not parse (filter argument). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.filter_input
A template is refused (filter input). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.include
An output's path, when or for_each does not parse (include). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.invalid_utf8
A template is refused (invalid utf8). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.nil_property
A template is refused (nil property). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.not_utf8
A template is refused (not utf8). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.number_input
A template is refused (number input). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.number_range
An output's path, when or for_each does not parse (number range). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.object_output
A template is refused (object output). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.partial_name
A template is refused (partial name). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.partial_not_found
A template is refused (partial not found). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.provenance_argument
A template is refused (provenance argument). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.provenance_style
A template is refused (provenance style). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.reserved_name
A template is refused (reserved name). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.safe_position
An output's path, when or for_each does not parse (safe position). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.slug_empty
A template is refused (slug empty). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.syntax
An output's path, when or for_each does not parse (syntax). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.tag_argument
A template is refused (tag argument). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.tag_context
An output's path, when or for_each does not parse (tag context). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.undefined_property
A template is refused (undefined property). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.undefined_variable
A template is refused (undefined variable). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
template.unknown_filter
An output's path, when or for_each does not parse (unknown filter). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
usage.bad_value
A flag's value is missing, or is not one the flag accepts, or a flag that takes no value is given one. Next: metais test --help: Prints the operands and flags metais test takes.
usage.missing_flag
--dry-run is given without --update. Next: metais test <package> --update --dry-run: Lists what --update would write and remove, and writes nothing.
usage.not_a_source_directory
--update is given with a packed package, which is not edited. Next: metais test <dir> --update: Updates the examples of the package's source directory, which an author edits; a packed package is not changed.
usage.package_from_stdin
The package operand is -, standard input. Next: metais test --help: Prints the operands and flags metais test takes.
usage.repeated_flag
A flag that may be given once is given again. Next: metais test --help: Prints the operands and flags metais test takes.
usage.unexpected_operand
An operand the command does not take. Next: metais test --help: Prints the operands and flags metais test takes.
usage.unknown_example
An --example names no example of the package. Next: metais test <package> --example <name>: Names an example that exists: a directory under examples/.
usage.unknown_flag
An argument that is not a flag the command accepts, an abbreviated flag, or one-letter aliases written together. Next: metais test --help: Prints the operands and flags metais test takes.
yaml.alias
An example's inputs are refused (alias). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
yaml.anchor
An example's inputs are refused (anchor). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
yaml.bom
An example's inputs are refused (bom). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
yaml.character
An example's inputs are refused (character). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
yaml.directive
An example's inputs are refused (directive). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
yaml.duplicate_key
An example's inputs are refused (duplicate key). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
yaml.key_empty
An example's inputs are refused (key empty). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
yaml.key_not_scalar
An example's inputs are refused (key not scalar). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
yaml.merge_key
An example's inputs are refused (merge key). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
yaml.multi_document
An example's inputs are refused (multi document). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
yaml.scalar_refused
An example's inputs are refused (scalar refused). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
yaml.syntax
An example's inputs are refused (syntax). Next: metais test <package>: Tests every example again once the package or its examples are fixed.
yaml.tag
An example's inputs are refused (tag). Next: metais test <package>: Tests every example again once the package or its examples are fixed.