def test_existing_objs_some_deleted_w_queryset(self):
"""
Tests when some existing objects will be deleted on a queryset
"""
extant_obj0 = G(models.TestModel, int_field=0, float_field=1)
extant_obj1 = G(models.TestModel, int_field=1, float_field=1)
extant_obj2 = G(models.TestModel, int_field=2, float_field=1)
extant_obj3 = G(models.TestModel, int_field=3, float_field=1)
extant_obj4 = G(models.TestModel, int_field=4, float_field=0)
models.TestModel.objects.filter(int_field__lt=4).sync([
models.TestModel(int_field=1, float_field=2),
models.TestModel(int_field=2, float_field=2),
models.TestModel(int_field=3, float_field=2)
], ['int_field'], ['float_field'])
self.assertEquals(models.TestModel.objects.count(), 4)
self.assertTrue(models.TestModel.objects.filter(int_field=1).exists())
self.assertTrue(models.TestModel.objects.filter(int_field=2).exists())
self.assertTrue(models.TestModel.objects.filter(int_field=3).exists())
with self.assertRaises(models.TestModel.DoesNotExist):
models.TestModel.objects.get(id=extant_obj0.id)
test_model = models.TestModel.objects.get(id=extant_obj1.id)
self.assertEquals(test_model.float_field, 2)
test_model = models.TestModel.objects.get(id=extant_obj2.id)
self.assertEquals(test_model.float_field, 2)
test_model = models.TestModel.objects.get(id=extant_obj3.id)
self.assertEquals(test_model.float_field, 2)
test_model = models.TestModel.objects.get(id=extant_obj4.id)
self.assertEquals(test_model.float_field, 0)
def test_existing_objs_all_deleted(self):
"""
Tests when there are existing objects that will all be deleted.
"""
extant_obj1 = G(models.TestModel, int_field=1)
extant_obj2 = G(models.TestModel, int_field=2)
extant_obj3 = G(models.TestModel, int_field=3)
models.TestModel.objects.sync([
models.TestModel(int_field=4),
models.TestModel(int_field=5),
models.TestModel(int_field=6)
], ['int_field'], ['float_field'])
self.assertEquals(models.TestModel.objects.count(), 3)
self.assertTrue(models.TestModel.objects.filter(int_field=4).exists())
self.assertTrue(models.TestModel.objects.filter(int_field=5).exists())
self.assertTrue(models.TestModel.objects.filter(int_field=6).exists())
with self.assertRaises(models.TestModel.DoesNotExist):
models.TestModel.objects.get(id=extant_obj1.id)
with self.assertRaises(models.TestModel.DoesNotExist):
models.TestModel.objects.get(id=extant_obj2.id)
with self.assertRaises(models.TestModel.DoesNotExist):
models.TestModel.objects.get(id=extant_obj3.id)
def test_no_updates_unique_int_char_field(self):
"""
Tests the case when no updates were previously stored and the int and char fields are used as a uniqueness
constraint. In this case, there is data previously stored, but the uniqueness constraints dont match.
"""
# Create previously stored test models with a unique int field and -1 for all other fields
for i in range(3):
G(models.TestModel, int_field=i, char_field='-1', float_field=-1)
# Update using the int and char field as a uniqueness constraint. All three objects are created
models.TestModel.objects.bulk_upsert([
models.TestModel(int_field=0, char_field='0', float_field=0),
models.TestModel(int_field=1, char_field='1', float_field=1),
models.TestModel(int_field=2, char_field='2', float_field=2),
], ['int_field', 'char_field'], ['float_field'])
# Verify that no updates occured
self.assertEquals(models.TestModel.objects.count(), 6)
self.assertEquals(
models.TestModel.objects.filter(char_field='-1').count(), 3)
for i, model_obj in enumerate(
models.TestModel.objects.filter(
char_field='-1').order_by('int_field')):
self.assertEqual(model_obj.int_field, i)
self.assertEqual(model_obj.char_field, '-1')
self.assertAlmostEqual(model_obj.float_field, -1)
self.assertEquals(
models.TestModel.objects.exclude(char_field='-1').count(), 3)
for i, model_obj in enumerate(
models.TestModel.objects.exclude(
char_field='-1').order_by('int_field')):
self.assertEqual(model_obj.int_field, i)
self.assertEqual(model_obj.char_field, str(i))
self.assertAlmostEqual(model_obj.float_field, i)
def test_some_updates_unique_timezone_field_update_float_field(self):
"""
Tests the case when some updates were previously stored and the timezone field is used as a uniqueness
constraint. Only updates the float field.
"""
# Create previously stored test models with a unique int field and -1 for all other fields
for i in ['US/Eastern', 'US/Central']:
G(models.TestModel, time_zone=i, char_field='-1', float_field=-1)
# Update using the int field as a uniqueness constraint. The first two are updated while the third is created
models.TestModel.objects.bulk_upsert([
models.TestModel(time_zone=timezone('US/Eastern'),
char_field='0',
float_field=0),
models.TestModel(time_zone=timezone('US/Central'),
char_field='1',
float_field=1),
models.TestModel(
time_zone=timezone('UTC'), char_field='2', float_field=2),
], ['time_zone'], ['float_field'])
# Verify that the float field was updated for the first two models and the char field was not updated for
# the first two. The char field, however, should be '2' for the third model since it was created
m1 = models.TestModel.objects.get(time_zone=timezone('US/Eastern'))
self.assertEquals(m1.char_field, '-1')
self.assertAlmostEquals(m1.float_field, 0)
m2 = models.TestModel.objects.get(time_zone=timezone('US/Central'))
self.assertEquals(m2.char_field, '-1')
self.assertAlmostEquals(m2.float_field, 1)
m3 = models.TestModel.objects.get(time_zone=timezone('UTC'))
self.assertEquals(m3.char_field, '2')
self.assertAlmostEquals(m3.float_field, 2)
def test_existing_objs_some_deleted(self):
"""
Tests when some existing objects will be deleted.
"""
extant_obj1 = G(models.TestModel, int_field=1, float_field=1)
extant_obj2 = G(models.TestModel, int_field=2, float_field=1)
extant_obj3 = G(models.TestModel, int_field=3, float_field=1)
models.TestModel.objects.sync([
models.TestModel(int_field=3, float_field=2),
models.TestModel(int_field=4, float_field=2),
models.TestModel(int_field=5, float_field=2)
], ['int_field'], ['float_field'])
self.assertEquals(models.TestModel.objects.count(), 3)
self.assertTrue(models.TestModel.objects.filter(int_field=3).exists())
self.assertTrue(models.TestModel.objects.filter(int_field=4).exists())
self.assertTrue(models.TestModel.objects.filter(int_field=5).exists())
with self.assertRaises(models.TestModel.DoesNotExist):
models.TestModel.objects.get(id=extant_obj1.id)
with self.assertRaises(models.TestModel.DoesNotExist):
models.TestModel.objects.get(id=extant_obj2.id)
test_model = models.TestModel.objects.get(id=extant_obj3.id)
self.assertEquals(test_model.int_field, 3)
def test_no_existing_objs(self):
"""
Tests when there are no existing objects before the sync.
"""
models.TestModel.objects.sync([
models.TestModel(int_field=1),
models.TestModel(int_field=3),
models.TestModel(int_field=4)
], ['int_field'], ['float_field'])
self.assertEquals(models.TestModel.objects.count(), 3)
self.assertTrue(models.TestModel.objects.filter(int_field=1).exists())
self.assertTrue(models.TestModel.objects.filter(int_field=3).exists())
self.assertTrue(models.TestModel.objects.filter(int_field=4).exists())
def test_no_updates(self):
"""
Tests the case when no updates were previously stored (i.e objects are only created)
"""
models.TestModel.objects.bulk_upsert([
models.TestModel(int_field=0, char_field='0', float_field=0),
models.TestModel(int_field=1, char_field='1', float_field=1),
models.TestModel(int_field=2, char_field='2', float_field=2),
], ['int_field'], ['char_field', 'float_field'])
for i, model_obj in enumerate(
models.TestModel.objects.order_by('int_field')):
self.assertEqual(model_obj.int_field, i)
self.assertEqual(model_obj.char_field, str(i))
self.assertAlmostEqual(model_obj.float_field, i)
def test_post_bulk_operation_bulk_create(self):
"""
Tests that the bulk_create operation emits the post_bulk_operation signal.
"""
models.TestModel.objects.bulk_create([models.TestModel(int_field=2)])
self.assertEquals(self.signal_handler.model, models.TestModel)
self.assertEquals(self.signal_handler.num_times_called, 1)
def test_return_created_values(self):
"""
Tests that values that are created are returned properly when return_upserts is True.
"""
return_values = models.TestModel.objects.bulk_upsert(
[
models.TestModel(int_field=1),
models.TestModel(int_field=3),
models.TestModel(int_field=4)
], ['int_field'], ['float_field'],
return_upserts=True)
self.assertEquals(len(return_values), 3)
for test_model, expected_int in zip(
sorted(return_values, key=lambda k: k.int_field), [1, 3, 4]):
self.assertEquals(test_model.int_field, expected_int)
self.assertIsNotNone(test_model.id)
self.assertEquals(models.TestModel.objects.count(), 3)
def test_wo_update_fields(self):
"""
Tests bulk_upsert with no update fields. This function in turn should just do a bulk create for any
models that do not already exist.
"""
# Create models that already exist
G(models.TestModel, int_field=1)
G(models.TestModel, int_field=2)
# Perform a bulk_upsert with one new model
models.TestModel.objects.bulk_upsert([
models.TestModel(int_field=1),
models.TestModel(int_field=2),
models.TestModel(int_field=3)
], ['int_field'])
# Three objects should now exist
self.assertEquals(models.TestModel.objects.count(), 3)
for test_model, expected_int_value in zip(
models.TestModel.objects.order_by('int_field'), [1, 2, 3]):
self.assertEquals(test_model.int_field, expected_int_value)
def test_all_updates_unique_int_field(self):
"""
Tests the case when all updates were previously stored and the int field is used as a uniqueness
constraint.
"""
# Create previously stored test models with a unique int field and -1 for all other fields
for i in range(3):
G(models.TestModel, int_field=i, char_field='-1', float_field=-1)
# Update using the int field as a uniqueness constraint
models.TestModel.objects.bulk_upsert([
models.TestModel(int_field=0, char_field='0', float_field=0),
models.TestModel(int_field=1, char_field='1', float_field=1),
models.TestModel(int_field=2, char_field='2', float_field=2),
], ['int_field'], ['char_field', 'float_field'])
# Verify that the fields were updated
self.assertEquals(models.TestModel.objects.count(), 3)
for i, model_obj in enumerate(
models.TestModel.objects.order_by('int_field')):
self.assertEqual(model_obj.int_field, i)
self.assertEqual(model_obj.char_field, str(i))
self.assertAlmostEqual(model_obj.float_field, i)
def test_return_created_updated_values(self):
"""
Tests returning values when the items are either updated or created.
"""
# Create an item that will be updated
G(models.TestModel, int_field=2, float_field=1.0)
return_values = models.TestModel.objects.bulk_upsert(
[
models.TestModel(int_field=1, float_field=3.0),
models.TestModel(int_field=2.0, float_field=3.0),
models.TestModel(int_field=3, float_field=3.0),
models.TestModel(int_field=4, float_field=3.0)
], ['int_field'], ['float_field'],
return_upserts=True)
self.assertEquals(len(return_values), 4)
for test_model, expected_int in zip(
sorted(return_values, key=lambda k: k.int_field),
[1, 2, 3, 4]):
self.assertEquals(test_model.int_field, expected_int)
self.assertAlmostEquals(test_model.float_field, 3.0)
self.assertIsNotNone(test_model.id)
self.assertEquals(models.TestModel.objects.count(), 4)
def test_some_updates_unique_int_char_field_queryset(self):
"""
Tests the case when some updates were previously stored and a queryset is used on the bulk upsert.
"""
# Create previously stored test models with a unique int field and -1 for all other fields
for i in range(3):
G(models.TestModel, int_field=i, char_field='-1', float_field=-1)
# Update using the int field as a uniqueness constraint on a queryset. Only one object should be updated.
models.TestModel.objects.filter(int_field=0).bulk_upsert([
models.TestModel(int_field=0, char_field='0', float_field=0),
models.TestModel(int_field=1, char_field='1', float_field=1),
models.TestModel(int_field=2, char_field='2', float_field=2),
], ['int_field'], ['float_field'])
# Verify that two new objecs were inserted
self.assertEquals(models.TestModel.objects.count(), 5)
self.assertEquals(
models.TestModel.objects.filter(char_field='-1').count(), 3)
for i, model_obj in enumerate(
models.TestModel.objects.filter(
char_field='-1').order_by('int_field')):
self.assertEqual(model_obj.int_field, i)
self.assertEqual(model_obj.char_field, '-1')
def test_some_updates_unique_int_char_field_update_float_field(self):
"""
Tests the case when some updates were previously stored and the int and char fields are used as a uniqueness
constraint. Only updates the float field.
"""
# Create previously stored test models with a unique int and char field
for i in range(2):
G(models.TestModel, int_field=i, char_field=str(i), float_field=-1)
# Update using the int field as a uniqueness constraint. The first two are updated while the third is created
models.TestModel.objects.bulk_upsert([
models.TestModel(int_field=0, char_field='0', float_field=0),
models.TestModel(int_field=1, char_field='1', float_field=1),
models.TestModel(int_field=2, char_field='2', float_field=2),
], ['int_field', 'char_field'], ['float_field'])
# Verify that the float field was updated for the first two models and the char field was not updated for
# the first two. The char field, however, should be '2' for the third model since it was created
self.assertEquals(models.TestModel.objects.count(), 3)
for i, model_obj in enumerate(
models.TestModel.objects.order_by('int_field')):
self.assertEqual(model_obj.int_field, i)
self.assertEqual(model_obj.char_field, str(i))
self.assertAlmostEqual(model_obj.float_field, i)
def test_invalid_field(self):
t = models.TestModel()
with self.assertRaises(AttributeError):
_get_prepped_model_field(t, 'non_extant_field')
