Metadata-Version: 2.0
Name: grappa
Version: 0.1.1
Summary: Behavior-oriented, expressive, developer-friendly assertions library
Home-page: https://github.com/grappa-python/grappa
Author: Tomas Aparicio
Author-email: UNKNOWN
License: MIT
Platform: UNKNOWN
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: System Administrators
Classifier: Operating System :: OS Independent
Classifier: Development Status :: 4 - Beta
Classifier: Natural Language :: English
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Topic :: Software Development
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Programming Language :: Python :: Implementation :: CPython
Classifier: Programming Language :: Python :: Implementation :: PyPy
Requires-Dist: colorama (~=0.3.7)

.. image:: http://i.imgur.com/kKZPYut.jpg
   :width: 100%
   :alt: grappa logo
   :align: center


|Build Status| |PyPI| |Coverage Status| |Documentation Status| |Stability| |Quality| |Versions| |SayThanks|

About
-----

``grappa`` is a behavior-oriented, self-declarative, expressive and developer-friendly
lightweight assertion library for Python_.

``grappa`` comes with two declarative `assertion styles`_: ``expect`` and ``should``.

It also comes with a detailed, human-friendly `error reporting`_ system that aims to reduce friction
and improve human agility while testing and fixing software.

To get started, take a look to the `documentation`_, `tutorial`_ and `assertion operators`_.

Status
------

``grappa`` is currently **beta quality** software and under active development.

In a nutshell
-------------

A small example demonstrating some `grappa` features:

.. code-block:: python

    from grappa import should

    True | should.be.true
    False | should.be.false
    None | should.be.none

    'bar' | should.be.equal.to('bar')
    13.14 | should.be.lower.than(14)
    13.14 | should.be.higher.than(13)

    'Hello grappa' | should.match('(\W)+ grappa$')
    'Hello grappa' | should.contain('grappa') | should.contain('llo')

    {'foo': True} | should.be.a('dict')
    [1, 2, 3] | should.be.a('list') > should.have.length.of(3)
    (lambda x: x) | should.not_be.have.type.of('lambda')

    {'foo': 'bar'} | should.have.key('foo').that.should.be.equal.to('bar')
    (1, 2, 3, 4) | should.be.a(tuple) > should.have.index.at(3) > should.be.equal.to(4)

    an_object | should.have.properties('foo', 'bar', 'baz')
    an_object | should.implement.methods('foo', 'bar', 'baz')

    ({'bar': [1, 2, 3]}
        | should.have.key('bar')
        > should.be.a('list')
        > should.have.length.of(3)
        > should.contain.item(3)
        > should.have.index.at(1)
        > should.be.equal.to(2))

See `documentation`_ for more examples.

Showcase
--------

.. image:: https://asciinema.org/a/d6yd2475m41thdku7d3ntkeir.png
   :width: 100%
   :alt: showcase
   :align: center
   :target: https://asciinema.org/a/d6yd2475m41thdku7d3ntkeir?autoplay=1&speed=3&size=small

Why grappa?
-----------

``grappa`` aims to assist humans while doing a very recurrent and not very fun task in software development: testing things.

The core idea behind ``grappa`` comes from the fact that human time is considerably more expensive than machine time,
and therefore any machine assistance to optimize processes and close the gap is beneficial.

With ``grappa`` you can express almost in plain English what the test contract actually is, but in a way that's
fun and easy to write but also more easy and pleasant to read or maintain by other developers.


The Zen of grappa
-----------------

- Frictionless testing: introducing self-declarative behavior testing patterns can make testing more fun for test writers and more enjoyable for test readers.
- Expressivity is paramount: humans should easily understand what the code is doing.
- Human time is expensive: any modern software should assist people to identify and understand errors easily.
- Make error reporting great again: feedback during testing is key, let's make it more handy and less frustrating.
- Testing patterns consolidation: software expectations are limited to the boundaries of language data types and structures.
- Hurt less feelings: seeing errors is not a nice thing, but it can be painless if details are showed you in a more gentle way.


Features
--------

-  Behavior-oriented expressive fluent API.
-  Built-in assertion DSL with English semantics.
-  Supports both ``expect`` and ``should`` assertion styles.
-  Full-featured built-in `assertion operators`_.
-  Human-friendly and detailed error reporting with embedded failing code.
-  Built-in expectations difference comparison on error.
-  Extensible assertions based on third-party plugins.
-  Assertion chaining and composition.
-  Composable assertion via logical operators such as ``and`` & ``or``.
-  Testing framework agnostic. Works with ``unittest``, ``nosetests``, ``pytest``, ``behave`` ...
-  Lightweight and (almost) dependency-free.
-  Works with Python 2.7+, 3+, PyPy and potentially other Python implementations.


Installation
------------

Using ``pip`` package manager:

.. code-block:: bash

    pip install --upgrade grappa

Or install the latest sources from Github:

.. code-block:: bash

    pip install -e git+git://github.com/grappa-py/grappa.git#egg=grappa


.. _Python: http://python.org
.. _`documentation`: http://grappa.readthedocs.io
.. _`tutorial`: http://grappa.readthedocs.io/en/latest/tutorial.html
.. _`error reporting`: http://grappa.readthedocs.io/en/latest/errors.html
.. _`assertion styles`: http://grappa.readthedocs.io/en/latest/style.html
.. _`assertion operators`: http://grappa.readthedocs.io/en/latest/operators.html

.. |Build Status| image:: https://travis-ci.org/grappa-py/grappa.svg?branch=master
   :target: https://travis-ci.org/grappa-py/grappa
.. |PyPI| image:: https://img.shields.io/pypi/v/grappa.svg?maxAge=2592000?style=flat-square
   :target: https://pypi.python.org/pypi/grappa
.. |Coverage Status| image:: https://coveralls.io/repos/github/grappa-py/grappa/badge.svg?branch=master
   :target: https://coveralls.io/github/grappa-py/grappa?branch=master
.. |Documentation Status| image:: https://readthedocs.org/projects/grappa/badge/?version=latest
   :target: http://grappa.readthedocs.io/en/latest/?badge=latest
.. |Quality| image:: https://codeclimate.com/github/grappa-py/grappa/badges/gpa.svg
   :target: https://codeclimate.com/github/grappa-py/grappa
   :alt: Code Climate
.. |Stability| image:: https://img.shields.io/pypi/status/grappa.svg
   :target: https://pypi.python.org/pypi/grappa
   :alt: Stability
.. |Versions| image:: https://img.shields.io/pypi/pyversions/grappa.svg
   :target: https://pypi.python.org/pypi/grappa
   :alt: Python Versions
.. |SayThanks| image:: https://img.shields.io/badge/Say%20Thanks!-%F0%9F%A6%89-1EAEDB.svg
   :target: https://saythanks.io/to/h2non
   :alt: Say Thanks


History
=======

v0.1.1 / 2017-03-23
-------------------

  * refactor(diff): process expected values as tuple first
  * fix(contain): remove print statements
  * refactor(core): normalize yielding syntax, add missing documentation
  * refactor(core): normalize yielding syntax, add missing documentation
  * feat(#26): support disable operator chaining
  * feat(#28): better assertion reporting. feat(operators): add index operator
  * refactor(reporter): support raw mode with proper indent pretty printing
  * refactor(operators): add satisfy/satisfies attribute operators
  * feat(diff): consume diff specific subject/expected values
  * feat(operators): add is/is_not operator attributes
  * refactor(core): isolate reporters per module
  * feat(#13, #25): add suboperators support and diff output report
  * refactor(docs): update organization name
  * refactor(docs): update project image
  * refactor(reporter): ignore subject/expected output if empty
  * refactor(reporter): show diff if enabled
  * feat(docs): add in a nutshell section
  * feat(#24, #25): feature enhancements
  * feat(docs): add say thanks badge
  * refactor(reporter): load value from operator first
  * fix(docs): use proper badges
  * fix(docs): update type operator examples
  * fix(metadata): update
  * refactor(test): add chained test for keys
  * feat(Makefile): add publish commands

0.1.0 (2017-03-05)
------------------

* First version (beta)


