Release Notes

4.0.5

This release provides the following improvements.

ResponseValidator: Rework to handle combined header values [293]

To validate OpenAPI responses, generated tests now combine all values supplied for each header field name into a single comma-separated list. NOTE: To see the effect of this change, you must regenerate your OpenAPI tests.
Speed up handling of numeric schemas with extremely large ranges

When a numeric schema specifies both minimum and maximum (i.e. a bounded range), Tcases calculates the number of values within the range that will be considered for test case generation, taking into account any multipleOf requirements. (This is for the purpose of checking consistency with other schema constraints.) Since OpenAPI allows numeric values to be arbitrarily large, a bounded range can be enormous! In previous releases, counting up the values for extremely large ranges was so slow that Tcases appeared to freeze. This release fixes that problem by speeding up the counting process.

4.0.4

This release provides the following improvements.

Decode DecimalValue from JSON correctly [289]

A test case generated from an OpenAPI definition may specify a constant input value that is a JSON-encoded object or array. For example, this can occur when tests are generated from the example definitions. This release fixes a defect that caused non-integral numbers in such JSON constants to be decoded incorrectly as integers.
Maven plugin dependencies

This release fixes a problem that caused some dependencies of the Tcases Maven Plugin to be incorrectly excluded.

4.0.3

This release provides the following improvements.

Generate "not multiple" failure cases correctly [285]

When an input value is defined by a schema specifying a multipleOf requirement, Tcases will generate a failure case using a value that is not a multiple. This release fixes a defect would sometimes cause Tcases to incorrectly omit this failure case or to spin forever trying to generate it.
Upgraded dependencies

Upgraded to swagger-parser=2.1.20, slf4j-api=2.0.11, logback-classic=1.3.12

4.0.2

This release provides the following improvements.

Skip "too large" failure cases for array variables when infeasible [276]

You can use a variable schema to automatically generate value definitions. For a variable with a schema of type array, Tcases will normally generate a "too large" failure value definition, using an array value that exceeds the specified maxItems. But in some cases, this failure is infeasible. For example, consider the following definition for the switches array.
```
{
  "system": "MySystem",
  "MyFunction": {
    "arg": {
      "switches": {
        "type": "array",
        "maxItems": 2,
        "uniqueItems": true,
        "items": {
          "type": "boolean"
        }
      }
    }
  }
}
```
A "too large" failure value would require an array containing three or more boolean values. But such an array is not possible without violating the uniqueItems condition. Because a failure value must represent single distinct error, the "too large" failure is infeasible.

In previous versions of Tcases, this situation would cause Tcases to throw an exception and give up. But in this release, Tcases will simply skip the infeasible "too large" case and keep going.
Upgraded dependencies

Upgraded to swagger-parser 2.1.15.

4.0.1

This release provides the following improvements.

Using the Tcases API to generate tests

The Tcases command line interface is implemented using a Java API. You can use the same API to do all of the same things in your own Java program, including creating a system input definition, generating test cases, and reading or writing Tcases documents. For details, see Using The Tcases API.

Thanks to grzegorzgrzegorz for inspiring improvements to make this API easier to use.
Tcases::getTests: Resolve schemas by default

The Tcases::getTests method is the basic interface for generating test cases. It includes an optional TestCaseResolverFactory parameter that defines how test case values are resolved. In this release, the default TestCaseResolverFactory uses the schemas defined by variable definitions and value definitions to resolve test case values.
Tcases::getEffectiveInputDef: Normalize all schemas

In this release, the Tcases::getEffectiveInputDef method ensures that all schema definitions in the resulting system input definition have been "normalized". Schema normalization updates the original schema definition to resolve any inconsistencies. For example, a schema that defined both "minimum": 0 and "exclusiveMinimum": 1 would be normalized to define only "minimum": 2. Any change made during schema normalization is reported in a log message.
Upgraded dependencies

Upgraded to swagger-parser 2.1.10.

4.0.0

With this major release, JSON becomes the preferred format for all Tcases documents. From now on, unless otherwise stated, new features will be supported only in JSON documents, although existing XML documents will continue to be supported as before. Tcases: The Complete Guide has been updated accordingly.

This release also introduces an important new feature: schema-based value definitions. Using standard JSON Schema keywords, you have the option to create a more concrete definition of a value class, which Tcases can use to automatically generate test cases with actual representative values. You can even use a schema to generate all of the value definitions for a variable automatically.

This release also introduces a new shell command -- tcases-copy -- and its Maven counterpart -- tcases:copy. You can use tcases-copy to copy a Tcases project to a new location or to convert it from XML to JSON.