Popular recipes tagged "meta:requires=unittest"

Unit Testing Nested Functions (Python)

2016-11-10T10:23:11-08:00

Python recipe 580716 by Alfe (introspection, nested, unittests). Revision 3.

Python allows the declaration of nested functions. These are typically hard to unit test because using just the normal ways of calling they cannot be called from outside their surrounding function. So they cannot be considered a clearly separated unit and thus cannot be unit tested.

This is a drawback of using them, so many developers (especially the ones deep into test driven development who strive to have a high unit test coverage) tend to avoid them in favor for standalone functions which can be called from the unit tests without any hassle.

But not all solutions with nested functions can be written as elegant with standalone functions. Nested functions are powerful insofar that they can access the local variables of the surrounding function without any need to pass them into the nested function, thus the code can in many cases stay neat and tidy while using a standalone function instead might raise the need to pass the complete context in form of a bunch of parameters. Also, using nested functions makes their local usage clear to any reader and keeps the name space tight.

But at least in the standard CPython (i. e. not necessarily in Jython, etc.) the implementation of functions (and methods) allows to find the nested function's code, wrap it properly to give it its needed context and then call it from the outside. I wrote a small module which helps doing exactly this.

Using Tkinter's Invoke Method for testing (Python)

2017-06-13T18:54:02-07:00

Python recipe 578978 by Stephen Rigden (invoke, mainloop, tkinter, ttk, unittest, unittests).

This recipe shows a skeleton unittest fixture that calls a widget's command using invoke without starting tkinter's mainloop. (Tcl8.6.3/Tk8.6.3.)

Robust Testing of Tkinter Menu Items with Mocking. (Python)

2017-06-13T18:44:58-07:00

Python recipe 578964 by Stephen Rigden (invoke, mainloop, mock, mocking, tk, tkinter, unittest, unittesting, unittests). Revision 7.

This recipe addresses the problems encountered when building robust tests for Tk menus. The software under test is a simple window with two menu items that each invoke a one button dialog box. All user visible text is imported from an external config.ini file. This scenario can lead to fragile test code because of the way TK's invoke(index) command has been implemented. (Tcl8.6.3/Tk8.6.3.)

Python Unittest - Obtain the results of all the tests run as a list (Python)

2014-04-24T08:52:32-07:00

Python recipe 578866 by Cosmin Niculae (python, run, tests, unittest). Revision 2.

So far, there is no way of returning the results of the tests run with unittest in any form, except for having the results printed. The purpose of this code is to have the name of the test cases, their indexes, as well as the results (Pass, Fail, Error) as a list. This is extremely used when you want to create a table with the results, as it has all the information needed.

The affected file is the result.py in the unittest library folder.

Python 3 Token Bucket (Rate Limit) (Python)

2013-09-16T23:41:46-07:00

Python recipe 578659 by Esteban Castro Borsani (bucket, limit, rate, ratelimit, token, tokenbucket).

A thread safe implementation.

Shuffle (Python)

2013-02-19T11:01:01-08:00

Python recipe 578466 by Narayana Chikkam (shuffle).

Python function to shuffle a deck of cards

@unittest.skip_others decorator (Python)

2012-08-06T02:20:19-07:00

Python recipe 578234 by Giampaolo Rodolà (python, python3, skip, unittest). Revision 3.

Decorator which skips all tests except the one decorated with it. Based on original proposal on python-ideas: http://mail.python.org/pipermail/python-ideas/2010-August/007992.html

Range comparison (Python)

2012-06-06T12:00:52-07:00

Python recipe 578158 by Charlie Clark (case, comparison, switch, ternary).

Although Python now has something similar to ternary operator with the result if ... else other result construction and this allows chaining (adding additional conditions on the if side, this soon becomes unreadable. A common use case is to filter values by ranges so I wrote the following when porting some code from PHP once I found I no longer understand the logic for a simple three-way filter.

Stack Environment (Python)

2017-06-22T10:24:05-07:00

Python recipe 578147 by Alfe (environment, global, stack, stackenv, variable). Revision 3.

The environment variables of processes get inherited by their children who can modify them and pass them on to their children. The tree of processes is similar to the call tree of a running Python process, but a similar mechanism like the environment variables is missing. I'm offering a solution for this; each stack frame takes the place of a process, hence I call it StackEnv. It comes in handy if you want to pass information from one frame to a frame far below without patching all the calls in between to pass the data (which might belong to a framework you don't want to change).

Usecases:

You call a framework which calls back your code before returning (e. g. in passed objects you provide). You want to pass some information to your code without relying on global variables or similar constructs which weren't thread-safe nor re-entrant.
You want to pass pseudo-global but in fact situation-related information (e. g. the verbosity based on the situation the call comes from) without handing the information down in each and every call which can happen below yours.
You want to give called methods the option to override the decision of the caller method regarding this information. (E. g. the caller decides that verbosity should be True, but the called method then calls another method and decides that the verbosity in this case should be False.)

Alike processes, called frames cannot influence the values for calling frames (but of course mutable values can be used to pass information upwards; this normal kind of "abuse" isn't prevented).

Importing:

from stackEnv import stackEnv

Setting a stackEnv variable:

stackEnv.verbose = True

Using the value of a stackEnv variable:

if stackEnv.verbose: print "being verbose now"

Testing a stackEnv variable:

if 'verbose' in stackEnv: print "having information on verbosity"

Overriding a stackEnv variable's value for the rest of this frame and its calls:

stackEnv.verbose = False

Removing a stackEnv variable for the rest of this frame and its calls:

del stackEnv.verbose

Some more useful API of this class can be found in the unit test included.

Reader-Writer lock with priority for writers (Python)

2011-09-28T21:45:04-07:00

Python recipe 577803 by Mateusz Kobos (locking, threads). Revision 2.

The following class implements a reader-writer lock to use in the second readers-writers problem with python threads. In this problem, many readers can simultaneously access a share, and a writer has an exclusive access to this share. Additionally, the following constraints should be met: 1) no reader should be kept waiting if the share is currently opened for reading unless a writer is also waiting for the share, 2) no writer should be kept waiting for the share longer than absolutely necessary.

Simple enum mechanism (Python)

2012-01-15T12:30:31-08:00

Python recipe 578015 by Thomas Lehmann (enum).

Here are the basic ideas (orientation: C++):

You are responsible to find names for constants and this code provides a way to give values which differ from each other
The context is to allow different enums with values starting by 0
If you like to use constants like here: "Orientation.TOP" then place those constants in the relating class
You still can assign your own values

About the code:

It's not much code also it might look like (implementation + documentation + unittests)
The __docformat__ is for epydoc. Temporarily remove the "@singleton" when trying to generate the HTML documentation (can not yet be handled by epydoc).

Example(s): Have a look at the unittests please.

TRAC Interpreter -- Sixties programming language (Python)

2010-08-22T19:05:09-07:00

Python recipe 577366 by Jack Trainor (algorithm, educational, interpreter, language, trac).

A Python implementation of an interpreter for the TRAC programming language developed by Calvin Mooers in the early 1960s. This implementation reconstructs Mooers' original algorithm in Python and supports only a limited number of TRAC primitives for demonstration purposes.

TRAC Interpreter - Dragon style (Python)

2010-09-20T00:42:21-07:00

Python recipe 577396 by Jack Trainor (algorithm, educational, interpreter, language, lexical_analyzer, trac).

I've rewritten the TRAC interpreter from Recipe 577366 using a modern recursive descent style based on the Dragon book's lexer/parser model at the end of "Compliers: Principles, Techniques and Tools," Chapter 2, by Aho, Sethi, Ullman (1986).

TRAC Interpreter - Class and Stack version (Python)

2010-09-20T01:16:07-07:00

Python recipe 577397 by Jack Trainor (algorithm, educational, interpreter, language, lexical_analyzer, trac).

This is my third and final version of the Trac Interpreter from Recipe 577366. It processes the character stream into appropriate class objects and stores these objects on a stack.

Weighted random choice (Python)

2010-08-19T08:40:38-07:00

Python recipe 577363 by Carlos Valiente (random, sequence).

This function returns a random element from a sequence. The probability for each element in the sequence to be selected can be weighted by a user-provided callable

Starting several context managers concurrently (Python)

2010-08-11T14:27:01-07:00

Python recipe 577352 by Carlos Valiente .

This recipe implements the parallel context manager, which executes the __enter__ and __exit__ method of its arguments concurrently.

Sets with a custom equality/uniqueness function (Python)

2009-10-29T21:08:22-07:00

Python recipe 576932 by Gabriel Genellina (abstract_base_class, mutableset, set, unique). Revision 4.

The builtin set and frozenset types are based on object equality; they call __eq__ to determine whether an object is a member of the set or not. But there are cases when one needs a set of objects that are compared by other means, apart from the default __eq__ function. There are several ways to achieve that; this recipe presents two classes, FrozenKeyedSet and KeyedSet, that take an additional function key which is used to determine membership and uniqueness. Given two objects which return the same value for key, only one of them will be in the set.

Test byt2str Module (Python)

2009-10-08T19:49:28-07:00

Python recipe 576926 by Stephen Chappell (byt2str, testing). Revision 2.

To ensure that the "byt2str" module operates correctly, the following unit test has been devised. This recipe should ensure the correctness of the code and validate all corrections for accuracy when run. If you are not familiar with the "unittest" or "test" modules, this code may of be interest for the purpose of developing your own library validation suites. Testing code is important for providing a certain amount of assurance that the code being run is correct. If the code is changed incorrectly, a test like this should be able to detect a problem.

Converting arbitrary size Python integers to packed binary data strings (Python)

2009-01-16T13:27:29-08:00

Python recipe 576617 by David Moss (binary, integers, pack, struct, unpack, unsigned).

Routines for converting large unsigned arbitrary sized Python integers to packed binary data strings and vice versa.

unittest howto - practical demonstration of the various unittest methods (Python)

2009-02-18T23:24:31-08:00

Python recipe 576654 by Senthil Kumaran (unittests).

There is a good amount of unittest documentation, for the beginner the way different people have written unittest can be confusing. Here is my attempt to dispel the confusion. There are sets of many methods which does the same thing, use the one which you and your teammates can understand the best and use it consistently.