easily run python unit tests
Project description
Pyt -- easy python testing for unittest tests
=============================================
Pyt's goal is to make writing and running Python unit tests fun and easy
:)
Currently, there are two main components, the ``pyt`` command line test
runner, and the ``Assert`` class
pyt testrunner
--------------
So here was my problem, I would work on big Python projects, and I would
be adding a new python file to a module in this big project, for
example, my new file might be something like this:
::
/project/foo/bar/che/baz/newmodule.py
I would be adding the ``Happy`` class with a ``sad`` method to
``newmodule`` and I would want to test it, so I would then have to add a
test for it:
::
/project/test/foo/bar/che/baz/newmodule_test.py
Then I would want to test my new class method:
::
$ python -m unittest test.foo.bar.che.baz.newmodule_test.HappyTestCase.test_sad
This got really annoying! Everytime, I would have to remember the syntax
to call unittest from the command line, and then I would have to
remember what I named the test case (let's see, was that
``HappyTestCase`` or ``HappyTest``), so I decided to take a bit of time
and simplify it, that's when ``pyt`` was born.
With ``pyt``, I just need to remember what I'm working on:
::
$ pyt Happy.sad
and ``pyt`` will do the rest, it will check every test module it finds
in the working directory and see if it has a Happy test case with a
``test_sad`` method. No more having to remember the unittest syntax, no
more typing long test paths. Hopefully, if tests are easy to run, I'll
write more of them.
More examples
~~~~~~~~~~~~~
Continuing the above example
To run all the ``Happy`` tests:
::
$ pyt Happy
To run all the ``newmodule`` tests:
::
$ pyt newmodule
To run more than one test:
::
$ pyt test1 test2 ...
Things to be aware of
~~~~~~~~~~~~~~~~~~~~~
- ``pyt`` uses Python's `PEP
8 <http://www.python.org/dev/peps/pep-0008/>`__ style conventions to
decide what is the module and class, so, given input like this:
::
$ pyt foo.bar.Baz.che
``pyt`` will consider ``foo.bar`` to be modules, ``Baz`` to be a
class because it starts with a capital letter, and ``che`` to be a
method since it comes after a class.
- ``pyt`` can fail on vague input and will run the first satisfactory
test it finds, so if you have:
::
/project
__init__.py
/user.py
/foo/
__init__.py
user.py
and you want to run tests for ``foo.user`` and you run:
::
$ pyt user
it will run the first ``user_test`` it finds, even if you meant a
different one, the solution is to just be more verbose when you have
to be:
::
$ pyt foo.user
pyt Assert
----------
This is a helper class designed to make writing assert statements in
your test cases a lot more fluid:
::
from pyt import Assert
v = 5
a = Assert(v)
a == 5 # assertEqual(v, 5)
a != 5 # assertNotEqual(v, 5)
a > 5 # assertGreater(v, 5)
a >= 5 # assertGreaterEqual(v, 5)
a < 5 # assertLess(v, 5)
a <= 5 # assertLessEqual(v, 5)
+a # self.assertGreater(v, 0)
-a # self.assertLess(v, 0)
~a # self.assertNotEqual(v, 0)
v = "foobar"
a = Assert(v)
"foo" in a # assertIn("foo", v)
"foo not in a # assertNotIn("foo", v)
a % str # assertIsInstance(v, str)
a % (str, unicode) # to use multiple, put them in a tuple
a ^ str # assertNotIsInstance(v, str)
a / regex # assertRegexpMatches(v, re)
a // regex # assertNotRegexpMatches(v, re)
# assertRaises(ValueError)
with Assert(ValueError):
raise ValueError("boom")
a == False # assertFalse(v)
a == True # assertTrue(v)
a * 'foo', 'bar' # assert foo and bar are keys/attributes in v
a ** {...} # assert v has all keys and values in dict
a *= 'foo', 'bar' # assert foo and bar are the only keys in v
a **= {...} # assert v has only the keys and values in dict
a.len == 5 # assertEqual(len(v), 5)
# it even works on attributes and methods of objects
o = SomeObject()
o.foo = 1
a = Assert(o)
a.foo == 1
a.bar() == "bar return value"
Installation
------------
Use ``pip``:
::
$ pip install pyt
You can also get it directly from the repo:
::
$ pip install git+https://github.com/Jaymon/pyt#egg=pyt
TODO
----
Glob support
^^^^^^^^^^^^
add support for globs, so you could do:
::
pyt *
to run all commands. Or:
::
pyt mod*.Foo.bar*
to run all test modules that start with ``mod``, have a ``Foo`` class,
and ``test_bar*`` methods
Tests don't run in windows
^^^^^^^^^^^^^^^^^^^^^^^^^^
I used ``/`` in the tests, and ``os.sep`` in all the pyt stuff, so it
runs on windows, it just doesn't pass the tests :(
=============================================
Pyt's goal is to make writing and running Python unit tests fun and easy
:)
Currently, there are two main components, the ``pyt`` command line test
runner, and the ``Assert`` class
pyt testrunner
--------------
So here was my problem, I would work on big Python projects, and I would
be adding a new python file to a module in this big project, for
example, my new file might be something like this:
::
/project/foo/bar/che/baz/newmodule.py
I would be adding the ``Happy`` class with a ``sad`` method to
``newmodule`` and I would want to test it, so I would then have to add a
test for it:
::
/project/test/foo/bar/che/baz/newmodule_test.py
Then I would want to test my new class method:
::
$ python -m unittest test.foo.bar.che.baz.newmodule_test.HappyTestCase.test_sad
This got really annoying! Everytime, I would have to remember the syntax
to call unittest from the command line, and then I would have to
remember what I named the test case (let's see, was that
``HappyTestCase`` or ``HappyTest``), so I decided to take a bit of time
and simplify it, that's when ``pyt`` was born.
With ``pyt``, I just need to remember what I'm working on:
::
$ pyt Happy.sad
and ``pyt`` will do the rest, it will check every test module it finds
in the working directory and see if it has a Happy test case with a
``test_sad`` method. No more having to remember the unittest syntax, no
more typing long test paths. Hopefully, if tests are easy to run, I'll
write more of them.
More examples
~~~~~~~~~~~~~
Continuing the above example
To run all the ``Happy`` tests:
::
$ pyt Happy
To run all the ``newmodule`` tests:
::
$ pyt newmodule
To run more than one test:
::
$ pyt test1 test2 ...
Things to be aware of
~~~~~~~~~~~~~~~~~~~~~
- ``pyt`` uses Python's `PEP
8 <http://www.python.org/dev/peps/pep-0008/>`__ style conventions to
decide what is the module and class, so, given input like this:
::
$ pyt foo.bar.Baz.che
``pyt`` will consider ``foo.bar`` to be modules, ``Baz`` to be a
class because it starts with a capital letter, and ``che`` to be a
method since it comes after a class.
- ``pyt`` can fail on vague input and will run the first satisfactory
test it finds, so if you have:
::
/project
__init__.py
/user.py
/foo/
__init__.py
user.py
and you want to run tests for ``foo.user`` and you run:
::
$ pyt user
it will run the first ``user_test`` it finds, even if you meant a
different one, the solution is to just be more verbose when you have
to be:
::
$ pyt foo.user
pyt Assert
----------
This is a helper class designed to make writing assert statements in
your test cases a lot more fluid:
::
from pyt import Assert
v = 5
a = Assert(v)
a == 5 # assertEqual(v, 5)
a != 5 # assertNotEqual(v, 5)
a > 5 # assertGreater(v, 5)
a >= 5 # assertGreaterEqual(v, 5)
a < 5 # assertLess(v, 5)
a <= 5 # assertLessEqual(v, 5)
+a # self.assertGreater(v, 0)
-a # self.assertLess(v, 0)
~a # self.assertNotEqual(v, 0)
v = "foobar"
a = Assert(v)
"foo" in a # assertIn("foo", v)
"foo not in a # assertNotIn("foo", v)
a % str # assertIsInstance(v, str)
a % (str, unicode) # to use multiple, put them in a tuple
a ^ str # assertNotIsInstance(v, str)
a / regex # assertRegexpMatches(v, re)
a // regex # assertNotRegexpMatches(v, re)
# assertRaises(ValueError)
with Assert(ValueError):
raise ValueError("boom")
a == False # assertFalse(v)
a == True # assertTrue(v)
a * 'foo', 'bar' # assert foo and bar are keys/attributes in v
a ** {...} # assert v has all keys and values in dict
a *= 'foo', 'bar' # assert foo and bar are the only keys in v
a **= {...} # assert v has only the keys and values in dict
a.len == 5 # assertEqual(len(v), 5)
# it even works on attributes and methods of objects
o = SomeObject()
o.foo = 1
a = Assert(o)
a.foo == 1
a.bar() == "bar return value"
Installation
------------
Use ``pip``:
::
$ pip install pyt
You can also get it directly from the repo:
::
$ pip install git+https://github.com/Jaymon/pyt#egg=pyt
TODO
----
Glob support
^^^^^^^^^^^^
add support for globs, so you could do:
::
pyt *
to run all commands. Or:
::
pyt mod*.Foo.bar*
to run all test modules that start with ``mod``, have a ``Foo`` class,
and ``test_bar*`` methods
Tests don't run in windows
^^^^^^^^^^^^^^^^^^^^^^^^^^
I used ``/`` in the tests, and ``os.sep`` in all the pyt stuff, so it
runs on windows, it just doesn't pass the tests :(
Project details
Release history Release notifications | RSS feed
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
Source Distribution
pyt-0.6.4.tar.gz
(8.4 kB
view hashes)