# 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: `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: `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.

    If there is a failure decoding then the handler should repackage the error as a gabbi.exception.GabbiDataLoadError.

  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: `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: `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: `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: `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=None)

    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: `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, durations=None)

  Bases: `TextTestRunner`

  A TextTestRunner that uses ConciseTestResult for reporting results.

  resultclass

    alias of `ConciseTestResult`

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

  Bases: `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.GabbiDataLoadError

  Bases: `ValueError`

  An exception to alert when data streams cannot be loaded.

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