person.py

class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age  = age

    def info(self):
        print("Name: %s - Age: %d" % (self.name, self.age))

runner.py

import unittest
import inspect
import nose
import sys

from nose.plugins import Plugin
from cs           import Capture
from IPython      import embed
from person       import Person

class MyTest(unittest.TestCase):
    def setUp(self):
        if 'Person' in globals():
            self.Person_init_args = inspect.getargspec(Person).args

            if hasattr(Person, 'info'):
                self.Person_info_args = inspect.getargspec(Person.info).args

    def test_class_exists(self):
        self.assertTrue('Person' in globals())

    def test_Person_extends_object(self):
        self.assertTrue(issubclass(Person, object))

    def test_Person_has_init(self):
        self.assertTrue(hasattr(Person, '__init__'))

    def test_Person_init_args_self(self):
        self.assertTrue('self' in self.Person_init_args)

    def test_Person_init_args_name(self):
        self.assertTrue('name' in self.Person_init_args)

    def test_Person_init_args_age(self):
        self.assertTrue('age' in self.Person_init_args)

    def test_Person_init_args_right_order(self):
        self.assertTrue(['self', 'name', 'age'] == self.Person_init_args)

    def test_Person_init_assigns_name(self):
        person = Person('James', 23)

        self.assertTrue(hasattr(person, 'name'))

    def test_Person_init_assigns_age(self):
        person = Person('James', 23)

        self.assertTrue(hasattr(person, 'age'))

    def test_Person_has_info(self):
        self.assertTrue(hasattr(Person, 'info'))

    def test_Person_info_args_self(self):
        self.assertTrue('self' in self.Person_info_args)

    def test_Person_info_prints(self):
        with Capture() as output:
            Person('James', 23).info()

        self.assertTrue(len(output))

class JSONTestReporter(Plugin):
    name     = 'json'

    # We're going to take an outside param that we'll assign all the errors,
    # failures, and passes to, so we can do something with that data after tests
    # have been run.
    def __init__(self, outside_report):
        super().__init__()

        self.outside_report = outside_report

    def options(self, parser, env):
        super().options(parser, env)

    def configure(self, options, config):
        super().configure(options, config)

        self.enabled = True
        self.config  = config

        self.outside_report['failures'] = []
        self.outside_report['errors']   = []
        self.outside_report['successes']   = []

    def addError(self, test, err):
        self.outside_report['errors'].append({ 'test': test, 'err': err })

    def addFailure(self, test, err):
        self.outside_report['failures'].append({ 'test': test, 'err': err })

    def addSuccess(self, test):
        self.outside_report['successes'].append({ 'test': test })

suite  = unittest.defaultTestLoader.loadTestsFromTestCase(MyTest)
report = {}
run    = nose.run(argv=['-s'],
                 suite=suite,
                 addplugins=[JSONTestReporter(report)])

print(report) # {'failures': [], 'errors': [], 'passes': []}