This is a pre-production deployment of Warehouse, however changes made here WILL affect the production instance of PyPI.
Latest Version Dependencies status unknown Test status unknown Test coverage unknown
Project Description

python better assertion.

inspired by should.js and chai.js

http://the-py.github.io/the/

tested on python2.7, 3.2, 3.3

install

pip install the

API

It provides one object called the with an alias expect. (Take a look at the Usage and Example.)

from the import the, expect

Chains

do nothing but return itself.
  • should
  • have
  • to
  • when
  • be. Special. You can use it as a chain but it also plays as a matcher.
  • a. Special. You can use it as a chain but it also plays as a matcher.

More chains?

the.use("mychain")

Matchers without arg

trigger a certain assertion.
  • true. assert True
  • false. assert False
  • none. assert None
  • exist. assert not None
  • ok. assert Truthy
  • empty. assert Falsy

More?

take a look at the-easytype lib.
# define your matcher
def happy(self):
    return self._check(self.obj == "happy",
                       self.obj + " is happy.",
                       self.obj + " is not happy.")

# add to `the`
the.use(happy)

# DONE!
the(string).should.be.happy

Matchers with args

trigger a certain assertion
  • eq(other), equal(other). assert equal(==) @param: other {mixed}
  • lt(other), below(other). assert less than(<) @param: other {mixed}
  • gt(other), above(other). assert greater than(<) @param: other {mixed}
  • ne(other). assert not equal(!=) @param: other {mixed}
  • le(other). assert less than or equal to (>=). @param: other {mixed}
  • ge(other). assert greater than(>=). @param: other {mixed}
  • match(regex). assert string match a regex. @param: regex {mixed}
  • length(n), size(n). assert length. @param: n {int}
  • item(**kwargs), items(**kwargs). assert dict have item(s). @params: **kwargs
  • contain(other). assert a dict contains another dict. @param: other {dict}
  • key(*args), keys(*args). assert dict has key(s). @params: args
  • value(*args), values(*args). assert dict has value(s). @params: args
  • property(**kwargs), properties(**kwargs). assert object has property/properties. @params: args
  • include(item). assert container include item (in). @param: item {mixed}
  • within(container). assert item in container (in). @param: container {mixed}
  • inherit(parent). assert subclass. @param: parent {class}
  • method(m). assert object has method. @param: m {str}
  • result(r). assert function return value. Using apply to apply args @param: r {mixed}
  • throw(msg=None, ex=Exception) . assert function throw exception using apply to apply args @param: msg {regex} optional @param: ex {exception} optional
  • be(other). assert is. (It can also be used as a chain) @param: other {mixed}.
  • a(cls) . assert isinstance . (It can also be used as a chain) @param: cls {class}
  • exception(msg=None, ex=Exception) assert exception throw classmethod @param: msg {regex} optional @param: ex {exception} optional

More?

take a look at the-fs lib.
# define your matcher
def firstname(self, name):
      fname = self.obj.split()[0]
      return self._check(fname == name,
                         "The firstname of {} is {}".format(self.obj, name),
                         "The firstname of {} is not {}".format(self.obj, name))

# add to `the`
the.use(firstname)

# DONE!
expect("Wenjun Yan").to.have.firstname("Wenjun")

Magic methods

  • ==. e.g. expect(1) == 1
  • !=. e.g. expect(1) != 2
  • >=. e.g. expect(1) >= 1
  • <=. e.g. expect(2) <= 3
  • >. e.g. expect(3) > 2
  • <. e.g. expect(4) < 5
  • in. e.g. 1  in the(range(1,3))
  • [] . e.g. the(dictionary)["key"] == "value"

Negations

  • NOT
  • not_to
  • should_not

Plugin

use(*args, **kwags). use this to extend the functionality. classmethod @param: *args @param: **kwargs args can be a string (which will become a new chain), method(new matcher), list of arg or a dict (in this case the will use the key as new matcher’s name. Same as kwargs.). args can even be a module if it provides a API variable containing all matchers and chains to export.

Usage and Examples

assert >, <, >=, <=, ==

expect(1) > 0
expect(1).gt(0)
expect(1).above(0)

expect(1) >= 0
expect(1).ge(0)

expect(1) < 2
expect(1).lt(0)
expect(1).below(0)

expect(1) <= 2
expect(1).le(0)

expect(1) == 1
expect(1).eq(1)
expect(1).equal(1)

assert True, False, None

the(True).should.be.true
expect(True).to.be.true

the(False).should.be.false
expect(False).to.be.false

the(None).should.be.none
expect(None).to.be.none

assert truthy, falsy

the(1).should.be.ok
expect(1).to.be.ok

the("").should.be.empty
expect("").to.be.empty

assert is

the(1).should.be(1)
expect(1).to.be(1)

assert isinstance

the(1).should.be.an(int)
expect("1").to.be.a(str)

assert issubclass

the(int).should.inherit(object)
expect(int).to.inherit(object)

assert in

the(1).should.be.within(range(1,3))
expect(1).to.be.within(range(1,3))

assert len

the(range(1, 3)).should.have.length(3)
expect(range(1, 3)).to.have.length(3)

assert regexp

the("abc").should.match("a")
expect("abc").to.match("a")

assert dict.item

d = {a: 1, b: 2}
the(d).should.have.items(a=1, b=2)
expect(d).to.have.items(a=1, b=2)
expect(d)["a"] == 1

the(d).should.contain({"a": 1, "b": 2})
expect(d).to.contain({"a": 1, "b": 2})

assert dict.key

d = {a: 1, b: 2}
the(d).should.have.key("a")
expect(d).to.have.keys("a", "b")

assert dict.value

d = {a: 1, b: 2}
the(d).should.have.value(1)
expect(d).to.have.values(1, 2)

assert property

class A(object):
    def __init__(self):
        self.x = 1

    def getx(self):
        return self.x

expect(A()).to.have.property("x")
expect(A()).to.have.property(x=1)

assert method

class A(object):
    def __init__(self):
        self.x = 1

    def getx(self):
        return self.x

expect(A()).to.have.method("getx")
the(A()).should.have.method("getx")

assert function

def div(a, b):
    return a/b

expect(div).when.apply(1,2).to.have.result(1/2)
expect(div).when.apply(1,0).to.throw()

assert exception

with expect.exception():
    assert 1 == 2

Plugin

Release History

Release History

0.1.5

This version

History Node

TODO: Figure out how to actually get changelog content.

Changelog content for this version goes here.

Donec et mollis dolor. Praesent et diam eget libero egestas mattis sit amet vitae augue. Nam tincidunt congue enim, ut porta lorem lacinia consectetur. Donec ut libero sed arcu vehicula ultricies a non tortor. Lorem ipsum dolor sit amet, consectetur adipiscing elit.

Show More

0.1.4

History Node

TODO: Figure out how to actually get changelog content.

Changelog content for this version goes here.

Donec et mollis dolor. Praesent et diam eget libero egestas mattis sit amet vitae augue. Nam tincidunt congue enim, ut porta lorem lacinia consectetur. Donec ut libero sed arcu vehicula ultricies a non tortor. Lorem ipsum dolor sit amet, consectetur adipiscing elit.

Show More

0.0.4

History Node

TODO: Figure out how to actually get changelog content.

Changelog content for this version goes here.

Donec et mollis dolor. Praesent et diam eget libero egestas mattis sit amet vitae augue. Nam tincidunt congue enim, ut porta lorem lacinia consectetur. Donec ut libero sed arcu vehicula ultricies a non tortor. Lorem ipsum dolor sit amet, consectetur adipiscing elit.

Show More

Download Files

Download Files

TODO: Brief introduction on what you do with files - including link to relevant help section.

File Name & Checksum SHA256 Checksum Help Version File Type Upload Date
the-0.1.5.tar.gz (10.7 kB) Copy SHA256 Checksum SHA256 Source Oct 23, 2013

Supported By

WebFaction WebFaction Technical Writing Elastic Elastic Search Pingdom Pingdom Monitoring Dyn Dyn DNS HPE HPE Development Sentry Sentry Error Logging CloudAMQP CloudAMQP RabbitMQ Heroku Heroku PaaS Kabu Creative Kabu Creative UX & Design Fastly Fastly CDN DigiCert DigiCert EV Certificate Rackspace Rackspace Cloud Servers DreamHost DreamHost Log Hosting