# gabbi Package

## `case` Module

## `driver` Module

## `suitemaker` Module

## `fixture` Module

Manage fixtures for gabbi at the test suite level.

class `gabbi.fixture.``GabbiFixture`

  Bases: `object`

  A context manager that operates as a fixture.

  Subclasses must implement `start_fixture` and `stop_fixture`, each of which contain the logic for stopping and starting whatever the fixture is. What a fixture is is left as an exercise for the implementor.

  These context managers will be nested so any actual work needs to happen in `start_fixture` and `stop_fixture` and not in `__init__`. Otherwise exception handling will not work properly.

  `start_fixture`()

    Implement the actual workings of starting the fixture here.

  `stop_fixture`()

    Implement the actual workings of stopping the fixture here.

exception `gabbi.fixture.``GabbiFixtureError`

  Bases: `Exception`

  Generic exception for GabbiFixture.

class `gabbi.fixture.``SkipAllFixture`

  Bases: `gabbi.fixture.GabbiFixture`

  A fixture that skips all the tests in the current suite.

  `start_fixture`()

    Implement the actual workings of starting the fixture here.

`gabbi.fixture.``nest`(fixtures)

  Nest a series of fixtures.

  This is duplicated from `nested` in the stdlib, which has been deprecated because of issues with how exceptions are difficult to handle during `__init__`. Gabbi needs to nest an unknown number of fixtures dynamically, so the `with` syntax that replaces `nested` will not work.

## `handlers` Module

### `handlers.base` Module

Base classes for response and content handlers.

class `gabbi.handlers.base.``ContentHandler`

  Bases: `gabbi.handlers.base.ResponseHandler`

  A subclass of ResponseHandlers that adds content handling.

  static `accepts`(content_type)

    Return True if this handler can handler this type.

  static `dumps`(data, pretty=False, test=None)

    Return structured data as a string.

    If pretty is true, prettify.

  static `load_data_file`(test, file_path)

    Return the string content of the file specified by the file_path.

  static `loads`(data)

    Create structured (Python) data from a stream.

  classmethod `replacer`(response_data, path)

    Return the string that is replacing RESPONSE.

class `gabbi.handlers.base.``ResponseHandler`

  Bases: `object`

  Add functionality for making assertions about an HTTP response.

  A subclass may implement two methods: `action` and `preprocess`.

  `preprocess` takes one argument, the `TestCase`. It is called exactly once for each test before looping across the assertions. It is used, rarely, to copy the `test.output` into a useful form (such as a parsed DOM).

  `action` takes two or three arguments. If `test_key_value` is a list `action` is called with the test case and a single list item. If `test_key_value` is a dict then `action` is called with the test case and a key and value pair.

  `action`(test, item, value=None)

    Test an individual entry for this response handler.

    If the entry is a key value pair the key is in item and the value in value. Otherwise the entry is considered a single item from a list.

  `preprocess`(test)

    Do any pre-single-test preprocessing.

  `test_key_suffix` = ''
  `test_key_value` = []

### `handlers.core` Module

Core response handlers.

class `gabbi.handlers.core.``ForbiddenHeadersResponseHandler`

  Bases: `gabbi.handlers.base.ResponseHandler`

  Test that listed headers are not in the response.

  `action`(test, forbidden, value=None)

    Test an individual entry for this response handler.

    If the entry is a key value pair the key is in item and the value in value. Otherwise the entry is considered a single item from a list.

  `test_key_suffix` = 'forbidden_headers'
  `test_key_value` = []

class `gabbi.handlers.core.``HeadersResponseHandler`

  Bases: `gabbi.handlers.base.ResponseHandler`

  Compare expected headers with actual headers.

  If a header value is wrapped in `/` it is treated as a raw regular expression.

  Headers values are always treated as strings.

  `action`(test, header, value=None)

    Test an individual entry for this response handler.

    If the entry is a key value pair the key is in item and the value in value. Otherwise the entry is considered a single item from a list.

  `test_key_suffix` = 'headers'
  `test_key_value` = {}

class `gabbi.handlers.core.``StringResponseHandler`

  Bases: `gabbi.handlers.base.ResponseHandler`

  Test for matching strings in the the response body.

  `action`(test, expected, value=None)

    Test an individual entry for this response handler.

    If the entry is a key value pair the key is in item and the value in value. Otherwise the entry is considered a single item from a list.

  `test_key_suffix` = 'strings'
  `test_key_value` = []

### `handlers.jsonhandler` Module

### `handlers.yaml_disk_loading_jsonhandler` Module

## `suite` Module

A TestSuite for containing gabbi tests.

This suite has two features: the contained tests are ordered and there are suite-level fixtures that operate as context managers.

class `gabbi.suite.``GabbiSuite`(tests=())

  Bases: `unittest.suite.TestSuite`

  A TestSuite with fixtures.

  The suite wraps the tests with a set of nested context managers that operate as fixtures.

  If a fixture raises unittest.case.SkipTest during setup, all the tests in this suite will be skipped.

  `run`(result, debug=False)

    Override TestSuite run to start suite-level fixtures.

    To avoid exception confusion, use a null Fixture when there are no fixtures.

  `start`(result, tests)

    Start fixtures when using pytest.

  `stop`()

    Stop fixtures when using pytest.

`gabbi.suite.``noop`(*args)

  A noop method used to disable collected tests.

## `runner` Module

## `reporter` Module

TestRunner and TestResult for gabbi-run.

class `gabbi.reporter.``ConciseTestResult`(stream, descriptions, verbosity)

  Bases: `unittest.runner.TextTestResult`

  A TextTestResult with simple but useful output.

  If the output is a tty or GABBI_FORCE_COLOR is set in the environment, output will be colorized.

  `addError`(test, err)

    Called when an error has occurred. ‘err’ is a tuple of values as returned by sys.exc_info().

  `addExpectedFailure`(test, err)

    Called when an expected failure/error occurred.

  `addFailure`(test, err)

    Called when an error has occurred. ‘err’ is a tuple of values as returned by sys.exc_info().

  `addSkip`(test, reason)

    Called when a test is skipped.

  `addSuccess`(test)

    Called when a test has completed successfully

  `addUnexpectedSuccess`(test)

    Called when a test was expected to fail, but succeed.

  `getDescription`(test)
  `printErrorList`(flavor, errors)
  `startTest`(test)

    Called when the given test is about to be run

class `gabbi.reporter.``ConciseTestRunner`(stream=None, descriptions=True, verbosity=1, failfast=False, buffer=False, resultclass=None, warnings=None, *, tb_locals=False)

  Bases: `unittest.runner.TextTestRunner`

  A TextTestRunner that uses ConciseTestResult for reporting results.

  `resultclass`

    alias of `ConciseTestResult`

class `gabbi.reporter.``PyTestResult`(stream=None, descriptions=None, verbosity=None)

  Bases: `unittest.result.TestResult`

  Wrap a test result to allow it to work with pytest.

  The main behaviors here are:

  - to turn what had been exceptions back into exceptions

  - use pytest’s skip and xfail methods

  `addError`(test, err)

    Called when an error has occurred. ‘err’ is a tuple of values as returned by sys.exc_info().

  `addExpectedFailure`(test, err)

    Called when an expected failure/error occurred.

  `addFailure`(test, err)

    Called when an error has occurred. ‘err’ is a tuple of values as returned by sys.exc_info().

  `addSkip`(test, reason)

    Called when a test is skipped.

## `utils` Module

Utility functions grab bag.

`gabbi.utils.``create_url`(base_url, host, port=None, prefix='', ssl=False)

  Given pieces of a path-based url, return a fully qualified url.

`gabbi.utils.``decode_response_content`(header_dict, content)

  Decode content to a proper string.

`gabbi.utils.``extract_content_type`(header_dict, default='application/binary')

  Extract parsed content-type from headers.

`gabbi.utils.``get_colorizer`(stream)

  Return a function to colorize a string.

  Only if stream is a tty .

`gabbi.utils.``host_info_from_target`(target, prefix=None)

  Turn url or host:port and target into test destination.

`gabbi.utils.``load_yaml`(handle=None, yaml_file=None, safe=True)

  Read and parse any YAML file or filehandle.

  Let exceptions flow where they may.

  If no file or handle is provided, read from STDIN.

`gabbi.utils.``not_binary`(content_type)

  Decide if something is content we’d like to treat as a string.

`gabbi.utils.``parse_content_type`(content_type, default_charset='utf-8')

  Parse content type value for media type and charset.

## `exception` Module

Gabbi specific exceptions.

exception `gabbi.exception.``GabbiFormatError`

  Bases: `ValueError`

  An exception to encapsulate poorly formed test data.

exception `gabbi.exception.``GabbiSyntaxWarning`

  Bases: `SyntaxWarning`

  A warning about syntax that is not desirable.

## `httpclient` Module

## `json_parser` Module