Question

The tests that I have written for my Django application have been working perfectly during initial development where I have been using SQLite. Now that I am getting ready to deploy I have setup a MySQL server (as that is what I’ll be deploying to) but now some of my tests are failing.

Lastly the tests that are failing don’t fail when I manually test the functionality.

What could be going on?

I’m not doing anything unusual, all of the views do some database shenanigans and return a response. There isn’t anything timing related (no threading or anything).

The tests all inherit from django.test.TestCase and I’m not using any fixtures.

Here is an example of a test that fails.

class BaseTest(TestCase):
    def setUp(self):
        super(BaseTest, self).setUp()

        self.userCreds = dict(username='test', password='a')

        # Create an admin user
        admin = models.User.objects.create_superuser(
            email='', username='admin', password='a')

        # Create a user and grant them a licence
        user = models.User.objects.create_user(
            email='[e-mail]', first_name="Mister",
            last_name="Testy", **self.userCreds)

        profile = models.getProfileFor(user)
        node = profile.createNode(
            '12345', 'acomputer', 'auser',
            '[e-mail]', '0456 987 123')

        self.node = node

class TestClientUIViews(BaseTest):
    def test_toggleActive(self):
        url = reverse('toggleActive') + '?nodeId=%s' % self.node.nodeId

        self.assertFalse(self.node.active)

        # This should fail because only authenticated users can toggle a node active
        resp = self.client.get(url)
        self.assertEqual(resp.status_code, 403)
        self.assertFalse(self.node.active)

        # Login and make sure visiting the url toggles the active state
        self.client.login(**self.userCreds)
        resp = self.client.get(url)
        self.assertEqual(resp.status_code, 200)
        self.assertTrue(self.node.active)

        resp = self.client.get(url)
        self.assertEqual(resp.status_code, 200)
        self.assertFalse(self.node.active)

And here is what the model looks like:

class Node(models.Model):
    @property
    def active(self):
        '''
        Activation state gets explictly tracked in its own table but is
        exposed as a property for the sake of convenience
        '''
        activations = NodeActivation.objects \
            .filter(node=self) \
            .order_by('-datetime')

        try:
            return activations[0].active
        except IndexError:
            return False

    @active.setter
    def active(self, state):
        if self.active != state:
            NodeActivation.objects.create(node=self, active=state)

class NodeActivation(models.Model):
    node = models.ForeignKey("Node")
    datetime = models.DateTimeField(default=datetimeM.datetime.now)
    active = models.BooleanField(default=False)

My local MySQL is 5.5.19 (so its using InnoDB) but I get the same failures on the deployment server which is using 5.1.56. The tests fail regardless of the storage engine.

And as I mentioned at the beginning, if I switch back to use a SQLite database, all the tests go back to passing.

Answer 1

By changing the active property on the Node model class to this:

@property
def active(self):
    '''
    Activation state gets explictly tracked in its own table but is
    exposed as a property for the sake of convenience
    '''
    activations = NodeActivation.objects \
        .filter(node=self) \
        .order_by('-id')

    try:
        return activations[0].active
    except IndexError:
        return False

the problem goes away.

Note the change to the order_by call.

The records were getting created so quickly that ordering by datetime wasn’t deterministic, hence the erratic behaviour. And I guess SQLite is just slower than MySQL which is why it wasn’t a problem when using it as the backing database.

NOTE: Thanks to Austin Phillips for the tip (check out comments in his answer)