Addressing possible strategic problems with LDAP module and unit testing code

Huge thanks to @ferada. With his/her help and suggestions, I spent a little over an hour combing over my code and making all kinds of changes. My unit tests are now much easier to read & understand and new unit tests are much easier to write. Here is a list of some of the things I did, with the new code following the list:

• Factored out common test case patterns into parent test case class methods - in particular, this greatly alleviated my troubles with mocking out the LDAP module. Other useful helper functions were factored out as well.
• Renamed test cases to be much more descriptive - the refactor made it much easier for me to write arbitrarily short or long test cases, so I refactored my test cases into many shorter, easier to comprehend test cases.
• Did not use setUpClass test class method - though I thought this was really clever, I didn't think that the outcome (passing objects as test class method arguments instead of attaching the objects to the test class) was worth it.
• Cleaned up and renamed addOption tests to assertOptionsAdded - this should be much easier to read and understand now.
• Changed auth "enum" to use strings instead of integers for easier debugging. I still wish for an enumeration implementation in Python 2, but this is an improvement for now.
• Renamed gets to getSingle and getm to getMultiple for hopefully obvious reasons. Also, the tests for these two methods have been separated into different test classes.
• Cleaned up exception messages using textwrap.dedent.
• Added new tests and new class method - with the refactoring, writing the new unit tests was much easier. The new method is called addAttr. The unit test for it could be cleaned up a bit, but for now it works.

Module:

import ldap
import ldap.sasl
import ldap.modlist
import textwrap
import copy

SCOPE=ldap.SCOPE_SUBTREE # hardcoded for now; to be moved to configuration

class auth():
    kerb, simple, noauth = "kerb_auth", "simple_auth", "no_auth"

class LDAPObjectManager():

    def __init__(self, uri, authtype, user=None, password=None, **kwargs):
        # not sure that I like hardcoding the list of supported auth types...
        if not authtype in [auth.kerb, auth.simple, auth.noauth]:
            raise ValueError("'%s' is not a supported authentication method" \
                             % authtype)
        self._ldo = ldap.initialize(uri)
        for key, value in kwargs.items():
            self._ldo.set_option(getattr(ldap, key), value)
        if authtype == auth.simple:
            self._ldo.simple_bind_s(user, password)
        elif authtype == auth.kerb:
            self._ldo.sasl_interactive_bind_s('', ldap.sasl.gssapi())

    def _stripReferences(self, ldif):
        return filter(lambda x: x[0] is not None, ldif)

    def getSingle(self, sbase, sfilter, scope=SCOPE):
        ldif = self._ldo.search_ext_s(sbase, scope, sfilter)
        result = self._stripReferences(ldif)
        if not result:
            raise RuntimeError(textwrap.dedent("""\
                               No results found for single-object query:
                               base: '%s' 
                               filter: '%s'""" %(sbase, sfilter)))
        if len(result) > 1:
            raise RuntimeError(textwrap.dedent("""\
                               Too many results found for single-object query:
                               base: '%s' 
                               filter: '%s'""" %(sbase, sfilter)))
        return result[0]

    def getMultiple(self, sbase, sfilter, scope=SCOPE):
        return self._stripReferences(self._ldo.search_ext_s(sbase, scope,
                                                            sfilter))

    def addAttr(self, sbase, dn, attr, value):
        oldobj = self.getSingle(sbase, "dn=%s" %dn)
        newobj = copy.deepcopy(oldobj)
        newobj[1][attr].append(value)
        ml = ldap.modlist.modifyModlist(oldobj, newobj)
        self._ldo.modify_ext_s(dn, ml)

Unit Tests:

import mock
import unittest
import src.ldapobjectmanager
from src.ldapobjectmanager import LDAPObjectManager, auth

uri = 'ldaps://foo.bar:636'

def person(name):
    return ('CN={},OU=People,DC=foo,DC=bar'.format(name), {'name': [name]})

def reference():
    return (None, ['ldaps://foo.bar/cn=ref'])

class LOMTestCase(unittest.TestCase):

    def setUp(self):
        patcher = mock.patch('src.ldapobjectmanager.ldap', autospec=True)
        self.mock_ldap = patcher.start()
        self.addCleanup(patcher.stop)

    def getNewLDOandLOM(self, auth, **kwargs):
        ldo = self.mock_ldap.ldapobject.LDAPObject(uri)
        self.mock_ldap.initialize.return_value = ldo
        lom = LDAPObjectManager(uri, auth, **kwargs)
        return ldo, lom

    def assert_no_calls(self, method):
        self.assertEqual(method.call_args_list, [])

class TestLOMInitializationAndOptions(LOMTestCase):

    def testBadAuthTypeThrowsValueError(self):
        with self.assertRaises(ValueError):
            ldo, lom = self.getNewLDOandLOM("Totally bogus auth value")

    def testNoAuthShouldNotCauseBindCall(self):
        ldo, lom = self.getNewLDOandLOM(auth.noauth)
        self.assert_no_calls(ldo.simple_bind_s)
        self.assert_no_calls(ldo.sasl_interactive_bind_s)

    def testSimpleAuthCausesSimpleBindCall(self):
        user = 'foo'
        password = 'bar'
        ldo, lom = self.getNewLDOandLOM(auth.simple, user=user, password=password)
        ldo.simple_bind_s.assert_called_once_with(user, password)

    def testKerbAuthCausesSASLBindCall(self):
        sasl = mock.MagicMock()
        self.mock_ldap.sasl.gssapi.return_value = sasl
        ldo, lom = self.getNewLDOandLOM(auth.kerb)
        ldo.sasl_interactive_bind_s.assert_called_once_with('', sasl)

    def testAddInvalidOptionThrowsException(self):
        with self.assertRaises(AttributeError):
            ldo, lom = self.getNewLDOandLOM(auth.kerb, OPT_BOGUS=1)

    def testOptionKwargsAreSetOnConnectionObject(self):
        def assertOptionsAdded(**kwargs):
            ldo, lom = self.getNewLDOandLOM(auth.noauth, **kwargs)
            for key, value in kwargs.items():
                ldo.set_option.assert_any_call(getattr(self.mock_ldap, key),
                                               value)

        assertOptionsAdded(OPT_X_TLS=1)
        assertOptionsAdded(OPT_REFERRALS=0, OPT_URI="ldaps://baz.bar")

class LOMMethodTestCase(LOMTestCase):

    def setUp(self):
        super(LOMMethodTestCase, self).setUp()
        self.ldo, self.lom = self.getNewLDOandLOM(auth.kerb)

class TestLOMGetSingle(LOMMethodTestCase):

    def testGetSingleThrowsExceptionForNoResultsFound(self):
        self.ldo.search_ext_s.return_value = []
        with self.assertRaises(RuntimeError):
            self.lom.getSingle("", "")

    def testGetSingleThrowsExceptionForOnlyReferencesFound(self):
        # sometimes references are included in the result
        # these have no DN and should be discarded from the result
        self.ldo.search_ext_s.return_value = [(None, ['ldaps://foo.bar/cn=ref'])]
        with self.assertRaises(RuntimeError):
            self.lom.getSingle("", "")

    def testGetSingleSuccessfullyReturnsExactlyOneObject(self):
        alice = person('alice')
        self.ldo.search_ext_s.return_value = [alice]
        self.assertEqual(alice, self.lom.getSingle("", "name=alice"))

    def testGetSingleSuccessfullyReturnsExactlyOneObject(self):
        bob = person('bob')
        self.ldo.search_ext_s.return_value = [bob, reference()]
        self.assertEqual(bob, self.lom.getSingle("", "name=bob"))

    def testGetSingleThrowsExceptionWhenMultipleResultsFound(self):
        expectedresult = [person('fred'), person('george')]
        self.ldo.search_ext_s.return_value = expectedresult
        with self.assertRaises(RuntimeError):
            self.lom.getSingle("", "")

        self.assertEqual(expectedresult, self.lom.getMultiple("", ""))

class TestLOMGetMultiple(LOMMethodTestCase):

    def testGetMultipleSuccessfullyReturnsMultipleResults(self):
        expectedresult = [person('fred'), person('george')]
        self.ldo.search_ext_s.return_value = expectedresult
        self.assertEqual(expectedresult, self.lom.getMultiple("", ""))

    def testGetMultipleRemovesReferenceFromResult(self):
        susie = person('susie')
        ref = reference()
        self.ldo.search_ext_s.return_value = [
            ref, susie, susie, ref,
            ref, susie, susie, ref, susie, ref
        ]
        actualresult = self.lom.getMultiple("", "name=susie")
        self.assertEqual([susie] * 5, actualresult)

class TestLOMAddAttr(LOMMethodTestCase):

    def testAddAttrCreatesModlistAndCallsModify(self):
        dn = 'cn=foo,dc=bar,dc=baz'
        attr = 'awesome list'
        value1 = 'item 1'
        value2 = 'item 2'
        oldobj = (dn, {attr: [value1]})
        newobj = (dn, {attr: [value1, value2]})
        modlist = mock.MagicMock()
        self.mock_ldap.modlist.modifyModlist.return_value = modlist
        self.ldo.search_ext_s.return_value = [oldobj]
        self.lom.addAttr("", dn, attr, value2)
        self.mock_ldap.modlist.modifyModlist.assert_called_once_with(oldobj,
                                                                     newobj)
        self.ldo.modify_ext_s.assert_called_once_with(dn, modlist)