Many advocates of unit testing believe that testing desktop (GUI) applications is so difficult as to not be worth it. Not only is it possible, but 'functional testing' (testing an application from the point of view of the user) is an important part of an agile development process.
 
This talk is based on my experience of testing a spreadsheet application with Resolver Systems. Whether you have drunk the agile kool-aid or not, functional testing can improve your application and your development processes.
 
The basic topics covered are:
 
* Why test functionally (including some unexpected benefits)
* The processes and infrastructure around automated tests
* How to functionally test - general principles and specific examples
* Difficulties and fragilities - and how to minimize them
 
 
Online Slides:
 
http://www.voidspace.org.uk/python/articles/testing/index.shtml

The benefits of continuous test integration are well known. Setting up an infrastruture for this can be a lot of work. It involves integration with version control, automated product building and running of tests, reporting on results in an accessible way, code coverage measuring, and code analysis such as with lint-like tools. We discuss how to set up such an automatic QA system using extensible open source python tools. The focus will be on Buildbot (http://buildbot.net), an open-source, Python-based continuous integration framework. Topics include a survey of the current best available open source software; testing code in languages other than python (and the benefits of using tools written in python in such a situation); strategies for extending these tools to meet custom needs, while avoiding maintainability and quality pitfalls; and special bonus details for QA of projects implemented in python specifically.

Coverage testing measures the execution of code, and is a great way of testing your tests: are they exercising all of your code? There are some pitfalls to be aware of in implementing coverage testing, though. 100% coverage is a fabulous ideal, but not only is it hard to reach, it still leaves a lot to be desired.

Windmill is the best-integrated solution for Web test development and its flexibility is largely due to its development in Python. This talk will get you writing and running automated tests and show off some of the most useful built-in tools for debugging and continuous integration.

As we become more efficient at producing web sites, inevitably the issue of quality (or lack thereof) can begin to slow the velocity at which implementation teams are able to move forward. Functional testing tools can help increase quality, bolster team confidence and keep things running smoothly.
 
This panel will bring together the maintainers of several functional testing frameworks written in Python. The session will be split into three distinct parts:
 
1. A lightning talk style introduction to each framework.
2. A guided discussion around the application of each framework.
3. A question and answer session with the audience.

"Scripting" with Python is becoming more common. This talk will discuss why you would want to "script" with Python (instead of say bash). It will also discuss best practices that will allow you to actually test your scripts, maintain them over time, and easily distribute them. Python has some advantages to bash in these areas.

As a Python web developer you are probably familiar with the paradigms of testing simple web applications. Your test case makes a GET / POST request, your program responds with an HTML page, and your test verifies the HTML elements. Unfortunately, today's typical web application is not so simple! Since modern browsers support asynchronous JavaScript (Ajax) very well, the HTML response might deliver program code to run on the client's web browser. The browser's runtime environment would then interact with your server-side Python program and you now have a big problem: How does your test suite cover both server-side functionality and client-side functionality?
 
This talk will use a real Python / Ajax web application as an example then offer practical strategies for creating a fast, scalable test suite to help ensure that each release of such an app works as intended. It goes beyond just the tools and technologies; it examines architectural strategies -- how and when to use stubs, how to design a testable UI, etc -- so that as your application grows in size, your tests remain fast and effective.

Over the past eight years CCP have been developing computer games like EVE Online (www.eve-online.com) using Python. In this presentation we'll show the Python-based tools we've created and techniques we've employed to aid us in this process. Our framework customises the development experience which our programmers engage in, from our own custom namespacing approach, to code reloading, unit testing, systems testing and Python-based GUIs. We'll endeavour to demonstrate each of these and where possible elaborate on what is involved in implementing similar systems.

Building a flexible and scalable functional testing framework for your application is typically an evolutionary process. You experiment and find things that work, and things that don't, particularly if you have little programming experience. Sometimes, you proceed down a path that binds your hands later down the road, and a massive refactor is needed. I would like to present a simple testing framework built upon several existing, free technologies (ConfigObj, twill, nose) and models (Page Objects, Scenario Objects, Abstract State Machines) that is easy to configure, extend, and maintain.

There has been a lot of buzz in the Python community about Python's new standard in Documentation systems. This talk starts with a discussion about the motivation for using sphinx. We then move on to a short screencast which demonstrates how to get started with sphinx, and how to utilize sphinx's autodoc features. I will then discuss shortly doctests, and how they can be used to both test and document your project. Next I demonstrate how nosetests, and sphinx can be integrated in your development process to produce well tested documentation, using another short screencast.