Metadata-Version: 2.1
Name: preggy
Version: 1.4.4
Summary: preggy is an assertion library for Python.** What were you `expect`ing?
Home-page: http://heynemann.github.io/preggy
Author: Bernardo Heynemann
Author-email: heynemann@gmail.com
Maintainer: Zearin
Maintainer-email: zearin@gonk.net
License: MIT
Download-URL: https://github.com/heynemann/preggy/releases/tag/1.4.4
Keywords: test testing assert assertion library development
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Natural Language :: English
Classifier: Operating System :: MacOS
Classifier: Operating System :: MacOS :: MacOS X
Classifier: Operating System :: POSIX
Classifier: Operating System :: Unix
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 2.6
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3.2
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: Implementation :: PyPy
Classifier: Topic :: Software Development :: Libraries
Classifier: Topic :: Software Development :: Testing
Description-Content-Type: text/markdown
Provides-Extra: tests
License-File: LICENSE

preggy
======

[![Build Status](https://travis-ci.org/heynemann/preggy.png?branch=master)](https://travis-ci.org/heynemann/preggy)
[![PyPi version](https://pypip.in/v/preggy/badge.png)](https://crate.io/packages/preggy/)
[![PyPi downloads](https://pypip.in/d/preggy/badge.png)](https://crate.io/packages/preggy/)
[![Coverage Status](https://coveralls.io/repos/heynemann/preggy/badge.png?branch=master)](https://coveralls.io/r/heynemann/preggy?branch=master)

**preggy is an assertion library for Python.** What were you `expect`ing?

Extracted from the [PyVows](http://pyvows.org) project.


Installing
==========

We recommend using `pip`:

    pip install preggy


Usage
=====

Simply tell your test what to `expect()`:

```python
from preggy import expect

def test_roses_are_red():
    rose = Rose()
    expect(rose.color).to_equal('red')

def test_violets_are_not_red():
    violet = Violet()
    expect(violet.color).not_to_equal('red')
```


Built-in Expectations
=====================


Equality
--------

```python
expect(4).to_equal(4)
expect(5).Not.to_equal(4)
expect(5).not_to_equal(4)  # same as previous
```


Comparison
--------

```python
expect(4).to_be_lesser_than(5)
expect(5).to_be_greater_than(4)
expect(5).Not.to_be_lesser_than(4)
expect(4).not_to_be_greater(5)  # same as previous

expect(4).to_be_lesser_or_equal_to(5)
expect(4).to_be_lesser_or_equal_to(4)
expect(5).not_to_be_lesser_or_equal_to(4)

expect(5).to_be_greater_or_equal_to(4)
expect(5).to_be_greater_or_equal_to(5)
expect(4).not_to_be_greater_or_equal_to(5)

expect("b").to_be_greater_than("a")
expect("a").to_be_lesser_than("b")

expect([1, 2, 3]).to_be_greater_than([1, 2])  # comparing using length
expect((1, 2, 3)).to_be_greater_than((1, 2))  # comparing using length
expect({ "a": "b", "c": "d" }).to_be_greater_than({ "a": "b" })  # comparing using length of keys
```


Similarity
----------

```python
expect('sOmE RandOm     CAse StRiNG').to_be_like('some random case string')

expect(1).to_be_like(1)
expect(1).to_be_like(1.0)
expect(1).to_be_like(long(1))

expect([1, 2, 3]).to_be_like([3, 2, 1])
expect([1, 2, 3]).to_be_like((3, 2, 1))
expect([[1, 2], [3,4]]).to_be_like([4, 3], [2, 1]])

expect({ 'some': 1, 'key': 2 }).to_be_like({ 'key': 2, 'some': 1 })

expect('sOmE RandOm     CAse StRiNG').Not.to_be_like('other string')
expect('sOmE RandOm     CAse StRiNG').not_to_be_like('other string')  # same as previous

expect(1).not_to_be_like(2)
expect([[1, 2], [3,4]]).not_to_be_like([4, 4], [2, 1]])
expect({ 'some': 1, 'key': 2 }).not_to_be_like({ 'key': 3, 'some': 4 })
```


Type
----

```python
expect(os.path).to_be_a_function()
expect(1).to_be_numeric()
expect({ 'some': 1, 'key': 2 }).to_be_instance_of(dict)
expect(open(__file__)).to_be_a_file()

expect('some').Not.to_be_a_function()
expect('some').Not.to_be_numeric()
expect('some').Not.to_be_instance_of(dict)
expect('some').Not.to_be_a_file()
```


True / False
------------

```python
expect(True).to_be_true()
expect('some').to_be_true()
expect([1, 2, 3]).to_be_true()
expect({ 'a': 'b' }).to_be_true()
expect(1).to_be_true()

expect(False).to_be_false()  # not_to_be_true() would work, too. but, it's so...eww
expect(None).to_be_false()
expect('').to_be_false()
expect(0).to_be_false()
expect([]).to_be_false()
expect({}).to_be_false()
```


None
----

```python
expect(None).to_be_null()
expect('some').Not.to_be_null()
expect('some').not_to_be_null()  # same as previous
```


Inclusion
---------

```python
expect([1, 2, 3]).to_include(2)
expect((1, 2, 3)).to_include(2)
expect('123').to_include('2')
expect({ 'a': 1, 'b': 2, 'c': 3}).to_include('b')

expect([1, 3]).Not.to_include(2)  # or, exclusion...
```


Regular Expressions
-------------------

```python
expect('some').to_match(r'^[a-z]+')
expect('Some').Not.to_match(r'^[a-z]+')
```


Length
------

```python
expect([1, 2, 3]).to_length(3)
expect((1, 2, 3)).to_length(3)
expect('abc').to_length(3)
expect({ 'a': 1, 'b': 2, 'c': 3}).to_length(3)
expect(lifo_queue).to_length(2)
expect(queue).to_length(3)

expect([1]).Not.to_length(3)
expect([1]).not_to_length(3)  # same as previous
```


Emptiness
---------

```python
expect([]).to_be_empty()
expect(tuple()).to_be_empty()
expect({}).to_be_empty()
expect('').to_be_empty()

expect([1]).not_to_be_empty()
expect((1,2)).not_to_be_empty()
expect({'a': 1}).not_to_be_empty()
expect('roses are red').not_to_be_empty()
```


Exceptions
----------

```python
expect(RuntimeError()).to_be_an_error() 
expect(RuntimeError()).to_be_an_error_like(RuntimeError)
expect(ValueError('error')).to_have_an_error_message_of('error')

expect("I'm not an error").Not.to_be_an_error()
expect(ValueError()).Not.to_be_an_error_like(RuntimeError)
expect(ValueError('some')).Not.to_have_an_error_message_of('error')

# when expecting a method to error
err = expect.error_to_happen(RuntimeError)  # attribute to a variable so you can use the exception later

with err:
    raise RuntimeError("something is wrong")

expect(err).to_have_an_error_message_of('something is wrong')

# or the shorter version
with expect.error_to_happen(RuntimeError, message="something is wrong"):
    raise RuntimeError("something is wrong")

# or if you don't care about the message:
with expect.error_to_happen(RuntimeError):
    raise RuntimeError("something is wrong")

# or if you need to make sure error does not happen
with expect.error_not_to_happen(RuntimeError, message="something is wrong"):
    raise RuntimeError("something is wrong")  # Fails with AssertionError

# or if you don't care about the message, only that the error does not happen:
with expect.error_not_to_happen(RuntimeError):
    raise RuntimeError("something is wrong")  # Fails with AssertionError
```

Failure
-------

```python
expect.not_to_be_here()  # raises AssertionError

# raises AssertionError with error message
expect.not_to_be_here("some error message")
```

Chained Assertions
------------------

```python
# assertions may be chained, for brevity:
expect(6).not_to_be_null().to_equal(6)

# a more *sensible* example:
expect(foo).not_to_be_null().to_equal(expected.get('foo'))
```


