The difference manifests itself when you have more than one test method in your class. setUpClass and tearDownClass are run once for the whole class; setUp and tearDown are run before and after each test method.

For example:

class Example(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        print("setUpClass")

    def setUp(self):
        print("setUp")

    def test1(self):
        print("test1")

    def test2(self):
        print("test2")

    def tearDown(self):
        print("tearDown")

    @classmethod
    def tearDownClass(cls):
        print("tearDownClass")

When you run this test, it prints:

setUpClass
setUp
test1
tearDown
.setUp
test2
tearDown
.tearDownClass

(The dots (.) are unittest's default output when a test passes.) Observe that setUp and tearDown appear before and after test1 and test2, whereas setUpClass and tearDownClass appear only once, at the beginning and end of the whole test case.

The two are quite different.

setUpClass is a class method, for one, so it'll only let you set class attributes.

They are also called at different times. The test runner creates a new instance for every test. If your test class contains 5 test methods, 5 instances are created and __init__ is called 5 times.

setUpClass is normally called only once. (If you shuffle up test ordering and test methods from different classes are intermingled, setUpClass can be called multiple times, use tearDownClass to clean up properly and that won't be a problem).

Also, a test runner usually creates all test instances at the start of the test run; this is normally cheap, as test instances don't hold (much) state so won't take up much memory.

As a rule of thumb, you should not use __init__ at all. Use setUpClass to create state shared between all the tests, and use setUp to create per-test state. setUp is called just before a test is run, so you can avoid building up a lot of memory-intensive state until it is needed for a test, and not before.

The problem is that setUpClass is executed earlier than classSetup fixture, hence the AttributeError.

One workaround might be to manually allow this method to be executed once, something like:

def setUp(self):  
    if getattr(self, 'navigated'):
         return

    self.sf.navigateToCCForms("img")
    self.navigated = True

I would also try the setup_class() method supported by pytest, though I suspect you would get the same issue as with setUpClass.

In your test methods you can now access the global class atribute _mine through self. So you can do something like this:

def test_something(self):
    self.assertEqual(self._mine.attribute, 'myAttribute')

Maybe this is what @Klaus means?

import unittest


class TestA(unittest.TestCase):
    def setUp(self):
        print "Setup # 1"

    def test1(self):
        print "Doing test1"

class TestB(unittest.TestCase):
    def setUp(self):
        print "Setup # 2"

    def test2(self):
        print "Doing test2"


if __name__ == "__main__":
    unittest.main()

Alternatively you can change setup based on the method name.
Although this might be a bit more of a pain to maintain.

class TestA(unittest.TestCase):
    def setUp(self):
        if self._testMethodName == "test1":
            print "Setup # 1"
        elif self._testMethodName == "test2":
            print "Setup # 2"

    def test1(self):
        print "Doing test1"

    def test2(self):
        print "Doing test2"


if __name__ == "__main__":
    unittest.main()

Both produce the same output:

Output:
Setup # 1
Doing test1
.Setup # 2
Doing test2
.
----------------------------------------------------------------------
Ran 2 tests in 0.001s

OK

EDIT: Sorry, I don't think I fully understand but here is my attempt at implementing your comment. My approach here is to reapply BaseTest.setUp() rather than try to keep it intact as you described.
TypeOneTests and TypeTwoTests inherit BaseTest and they call BaseTest's setUp function inside their own using super(...)

class BaseTest(unittest.TestCase):
    def setUp(self):
        print "BaseTest setUp"

    def tearDown(self):
        print "BaseTest tearDown"

    # you could add tests here but I didn't add any based on your comment


class TypeOneTests(BaseTest):
    def setUp(self):
        super(TypeOneTests, self).setUp()
        print "TypeOneTests setUp"

    def tearDown(self):
        print "TypeOneTests tearDown"

    def test(self):
        print "a test in TypeOneTests"


class TypeTwoTests(BaseTest):
    def setUp(self):
        super(TypeTwoTests, self).setUp()
        print "TypeTwoTests additional setUp"

    def tearDown(self):
        print "TypeTwoTests tearDown"
        super(TypeTwoTests, self).tearDown()

    def test(self):
        print "a test in TypeTwoTests"


if __name__ == "__main__":
    unittest.main()

Output:

BaseTest setUp
TypeOneTests setUp
a test in TypeOneTests
TypeOneTests tearDown
.BaseTest setUp
TypeTwoTests additional setUp
a test in TypeTwoTests
TypeTwoTests tearDown
BaseTest tearDown
.
----------------------------------------------------------------------
Ran 2 tests in 0.002s

OK

As of 2.7 (per the documentation) you get setUpClass and tearDownClass which execute before and after the tests in a given class are run, respectively. Alternatively, if you have a group of them in one file, you can use setUpModule and tearDownModule (documentation).

EDIT: Note that setUpClass and tearDownClass must be declared using @classmethod. Another answer to this question includes sample code.

Otherwise your best bet is probably going to be to create your own derived TestSuite and override run(). All other calls would be handled by the parent, and run would call your setup and teardown code around a call up to the parent's run method.