def test_disable_concurrency_class(model_class=SimpleConcurrentModel):
instance = model_class(username=next(nextname))
instance.save()
copy = refetch(instance)
copy.save()
with disable_concurrency(SimpleConcurrentModel):
instance.save()
def test_disable_concurrency_class(model_class=SimpleConcurrentModel):
instance = model_class(username=next(nextname))
instance.save()
copy = refetch(instance)
copy.save()
with disable_concurrency(SimpleConcurrentModel):
instance.save()
def check_or_create(
self,
prefix,
viewset,
basename,
url_name,
):
name = fqn(viewset)
source_model = ContentType.objects.get_for_model(
viewset().get_queryset().model)
service, isnew = self.model.objects.get_or_create(
viewset=viewset,
defaults={
'name': name,
'cache_ttl': '1y',
'access': getattr(viewset, 'default_access',
conf.DEFAULT_ACCESS),
'description': getattr(viewset, '__doc__', ""),
'source_model': source_model
})
with disable_concurrency(service):
service.url_name = url_name
service.basename = basename
service.suffix = prefix
service.source_model = source_model
service.save()
service.viewset.get_service.cache_clear()
return service, isnew
def service(db):
service = PartnerViewSet.get_service()
service.access = ACL_ACCESS_OPEN
with disable_concurrency(service):
service.save()
yield service
service.access = ACL_ACCESS_LOGIN
service.save()
def test_import_csv_with_version(self):
url = reverse('admin:demoapp_importexport_changelist')
res = self.app.get(url, user='******')
res = res.click(_("Import"))
with disable_concurrency(DemoModel):
res.form['import_file'] = ("import_file2",
self.get_file_to_upload("data_with_version.csv"))
res.form['input_format'] = 0
res = res.form.submit()
res = res.form.submit()
def test_import_csv_with_version(self):
url = reverse('admin:demoapp_importexport_changelist')
res = self.app.get(url, user='******')
res = res.click(_("Import"))
with disable_concurrency(DemoModel):
res.form['import_file'] = (
"import_file2",
self.get_file_to_upload("data_with_version.csv"))
res.form['input_format'] = 0
res = res.form.submit()
res = res.form.submit()
def _save_base(model_instance,
raw=False,
force_insert=False,
force_update=False,
using=None,
update_fields=None):
if force_insert:
with disable_concurrency(model_instance):
return func(model_instance, raw, force_insert,
force_update, using, update_fields)
return func(model_instance, raw, force_insert, force_update, using,
update_fields)
def test_loaddata():
datafile = os.path.join(os.path.dirname(__file__), 'dumpdata.json')
data = json.load(open(datafile, 'r'))
pk = data[0]['pk']
# with pytest.raises(RecordModifiedError):
# call_command('loaddata', datafile, stdout=StringIO())
with disable_concurrency():
call_command('loaddata', datafile, stdout=StringIO())
assert SimpleConcurrentModel.objects.get(id=pk).username == 'loaded'
def test_loaddata():
datafile = os.path.join(os.path.dirname(__file__), "dumpdata.json")
data = json.load(open(datafile, "r"))
pk = data[0]["pk"]
# with pytest.raises(RecordModifiedError):
# call_command('loaddata', datafile, stdout=StringIO())
with disable_concurrency():
call_command("loaddata", datafile, stdout=StringIO())
assert SimpleConcurrentModel.objects.get(id=pk).username == "loaded"
def test_disable_concurrency_global():
instance1 = SimpleConcurrentModel(username=next(nextname))
instance2 = AutoIncConcurrentModel(username=next(nextname))
instance1.save()
instance2.save()
refetch(instance1).save()
refetch(instance2).save()
with disable_concurrency():
instance1.save()
instance2.save()
copy2 = refetch(instance2)
refetch(instance2).save()
with pytest.raises(RecordModifiedError):
copy2.save()
def test_disable_concurrency_instance(model_class=SimpleConcurrentModel):
instance1 = model_class(username=next(nextname))
instance1.save()
copy1 = refetch(instance1)
copy1.save()
instance2 = model_class(username=next(nextname))
instance2.save()
copy2 = refetch(instance2)
copy2.save()
with disable_concurrency(instance1):
instance1.save()
with pytest.raises(RecordModifiedError):
instance2.save()
def test_disable_concurrency_instance(model_class=SimpleConcurrentModel):
instance1 = model_class(username=next(nextname))
instance1.save()
copy1 = refetch(instance1)
copy1.save()
instance2 = model_class(username=next(nextname))
instance2.save()
copy2 = refetch(instance2)
copy2.save()
with disable_concurrency(instance1):
instance1.save()
with pytest.raises(RecordModifiedError):
instance2.save()
def test_disable_concurrency_global():
instance1 = SimpleConcurrentModel(username=next(nextname))
instance2 = AutoIncConcurrentModel(username=next(nextname))
instance1.save()
instance2.save()
refetch(instance1).save()
refetch(instance2).save()
with disable_concurrency():
instance1.save()
instance2.save()
copy2 = refetch(instance2)
refetch(instance2).save()
with pytest.raises(RecordModifiedError):
copy2.save()
def build_site_content(site, base_site=None):
"""Build new site content by copying content from one site to another."""
# Get all site related models
models_to_copy = _get_site_models()
base_site = base_site or Site.objects.get_current()
parents = {}
for model_cls in models_to_copy:
copies = []
# Use a QuerySet rather than the default manager because the
# CurrentSiteManager forces the site equal to the current SITE_ID
for instance in QuerySet(model_cls).filter(site=base_site):
instance._original_id = instance.id
instance.id = None
instance.site = site
copies.append(instance)
# Multi-table inheritance classes can't be bulk created
for c in copies:
for _, field in model_cls._meta.parents.items():
parent = getattr(c, field.name)
parent.id = None
setattr(c, field.name, parent)
if hasattr(c, '_concurrencymeta'):
with disable_concurrency(c):
c.save(force_insert=True)
else:
c.save(force_insert=True)
if issubclass(model_cls, Page):
parents[c._original_id] = c.id
# Copy form fields
if model_cls == Form:
# Copy fields as well
fields = []
for field in Field.objects.filter(form=c._original_id):
field.id = None
field.form = c
fields.append(field)
Field.objects.bulk_create(fields)
# SiteRelated.save will force this to the "current" site
# so these need to be updated with the site we actually want
QuerySet(model_cls).filter(id__in=[c.id for c in copies]).update(site=site)
if parents:
# Update the page structure
for original, new_id in parents.items():
QuerySet(Page).filter(parent=original, site=site).update(parent=new_id)
def _save_base(model_instance, raw=False, force_insert=False,
force_update=False, using=None, update_fields=None):
if force_insert:
with disable_concurrency(model_instance):
return func(model_instance, raw, force_insert, force_update, using, update_fields)
return func(model_instance, raw, force_insert, force_update, using, update_fields)
def test_disable_concurrency_not_managed():
u = User(username='******')
with disable_concurrency(u):
u.save()
def test_disable_concurrency_not_managed():
u = User(username='******')
with disable_concurrency(u):
u.save()
def render_revision_form(self, request, obj, version, context, revert=False, recover=False):
with disable_concurrency(obj):
return super(ConcurrencyReversionAdmin, self).render_revision_form(request, obj, version, context, revert, recover)
