def test_delete_clipboards(self):
clipboard1 = models.ContentNode.objects.create(
**self.clipboard_db_metadata)
clipboard2 = models.ContentNode.objects.create(
**self.clipboard_db_metadata)
self.client.force_authenticate(user=self.user)
response = self.client.post(
self.sync_url,
[
generate_delete_event(clipboard1.id, CLIPBOARD),
generate_delete_event(clipboard2.id, CLIPBOARD),
],
format="json",
)
self.assertEqual(response.status_code, 200, response.content)
try:
models.ContentNode.objects.get(id=clipboard1.id)
self.fail("ContentNode 1 was not deleted")
except models.ContentNode.DoesNotExist:
pass
try:
models.ContentNode.objects.get(id=clipboard2.id)
self.fail("ContentNode 2 was not deleted")
except models.ContentNode.DoesNotExist:
pass
def test_cannot_delete_some_channels(self):
user = testdata.user()
channel1 = models.Channel.objects.create(**self.channel_metadata)
channel1.editors.add(user)
channel2 = models.Channel.objects.create(**self.channel_metadata)
self.client.force_authenticate(user=user)
with self.settings(TEST_ENV=False):
# Override test env here to check what will happen in production
response = self.client.post(
self.sync_url,
[
generate_delete_event(channel1.id, CHANNEL),
generate_delete_event(channel2.id, CHANNEL),
],
format="json",
)
# Returns a 200 as, as far as the frontend is concerned
# the operation is done.
self.assertEqual(response.status_code, 200, response.content)
try:
models.Channel.objects.get(id=channel1.id)
self.fail("Channel 1 was not deleted")
except models.Channel.DoesNotExist:
pass
try:
models.Channel.objects.get(id=channel2.id)
except models.Channel.DoesNotExist:
self.fail("Channel 2 was deleted")
def test_delete_files(self):
file1 = models.File.objects.create(**self.file_db_metadata)
file2 = models.File.objects.create(**self.file_db_metadata)
self.client.force_authenticate(user=self.user)
response = self.client.post(
self.sync_url,
[
generate_delete_event(
file1.id,
FILE,
),
generate_delete_event(
file2.id,
FILE,
),
],
format="json",
)
self.assertEqual(response.status_code, 200, response.content)
try:
models.File.objects.get(id=file1.id)
self.fail("File 1 was not deleted")
except models.File.DoesNotExist:
pass
try:
models.File.objects.get(id=file2.id)
self.fail("File 2 was not deleted")
except models.File.DoesNotExist:
pass
def test_delete_channels(self):
user = testdata.user()
channel1 = models.Channel.objects.create(**self.channel_metadata)
channel1.editors.add(user)
channel2 = models.Channel.objects.create(**self.channel_metadata)
channel2.editors.add(user)
self.client.force_authenticate(user=user)
response = self.client.post(
self.sync_url,
[
generate_delete_event(channel1.id, CHANNEL),
generate_delete_event(channel2.id, CHANNEL),
],
format="json",
)
self.assertEqual(response.status_code, 200, response.content)
try:
models.Channel.objects.get(id=channel1.id)
self.fail("Channel 1 was not deleted")
except models.Channel.DoesNotExist:
pass
try:
models.Channel.objects.get(id=channel2.id)
self.fail("Channel 2 was not deleted")
except models.Channel.DoesNotExist:
pass
def test_delete_invitations(self):
invitation1 = models.Invitation.objects.create(
**self.invitation_db_metadata)
invitation2 = models.Invitation.objects.create(
**self.invitation_db_metadata)
self.client.force_authenticate(user=self.user)
response = self.client.post(
self.sync_url,
[
generate_delete_event(
invitation1.id,
INVITATION,
),
generate_delete_event(
invitation2.id,
INVITATION,
),
],
format="json",
)
self.assertEqual(response.status_code, 200, response.content)
try:
models.Invitation.objects.get(id=invitation1.id)
self.fail("Invitation 1 was not deleted")
except models.Invitation.DoesNotExist:
pass
try:
models.Invitation.objects.get(id=invitation2.id)
self.fail("Invitation 2 was not deleted")
except models.Invitation.DoesNotExist:
pass
def test_delete_editor_and_viewer(self):
editor = testdata.user(email="*****@*****.**")
self.channel.editors.add(editor)
viewer = testdata.user(email="*****@*****.**")
self.channel.viewers.add(viewer)
self.client.force_authenticate(user=self.user)
response = self.client.post(
self.sync_url,
[
generate_delete_event([editor.id, self.channel.id],
EDITOR_M2M),
generate_delete_event([viewer.id, self.channel.id],
VIEWER_M2M),
],
format="json",
)
self.assertEqual(response.status_code, 200, response.content)
self.assertFalse(self.channel.editors.filter(id=editor.id).exists())
self.assertFalse(self.channel.viewers.filter(id=viewer.id).exists())
def test_delete_assessmentitems(self):
assessmentitem1 = models.AssessmentItem.objects.create(
**self.assessmentitem_db_metadata
)
assessmentitem2 = models.AssessmentItem.objects.create(
**self.assessmentitem_db_metadata
)
self.client.force_authenticate(user=self.user)
response = self.client.post(
self.sync_url,
[
generate_delete_event(
[assessmentitem1.contentnode_id, assessmentitem1.assessment_id],
ASSESSMENTITEM,
),
generate_delete_event(
[assessmentitem2.contentnode_id, assessmentitem2.assessment_id],
ASSESSMENTITEM,
),
],
format="json",
)
self.assertEqual(response.status_code, 200, response.content)
try:
models.AssessmentItem.objects.get(id=assessmentitem1.id)
self.fail("AssessmentItem 1 was not deleted")
except models.AssessmentItem.DoesNotExist:
pass
try:
models.AssessmentItem.objects.get(id=assessmentitem2.id)
self.fail("AssessmentItem 2 was not deleted")
except models.AssessmentItem.DoesNotExist:
pass
def copy(self,
pk,
from_key=None,
target=None,
position=None,
mods=None,
excluded_descendants=None,
**kwargs):
try:
target, position = self.validate_targeting_args(target, position)
except ValidationError as e:
return str(e), None
try:
source = self.get_queryset().get(pk=from_key)
except ContentNode.DoesNotExist:
error = ValidationError("Copy source node does not exist")
return str(error), [generate_delete_event(pk, CONTENTNODE)]
# Affected channel for the copy is the target's channel
channel_id = target.channel_id
if ContentNode.objects.filter(pk=pk).exists():
error = ValidationError("Copy pk already exists")
return str(error), None
task_args = {
"user_id": self.request.user.id,
"channel_id": channel_id,
"source_id": source.id,
"target_id": target.id,
"pk": pk,
"mods": mods,
"excluded_descendants": excluded_descendants,
"position": position,
}
task, task_info = create_async_task("duplicate-nodes",
self.request.user, **task_args)
return (
None,
[
generate_update_event(pk, CONTENTNODE,
{TASK_ID: task_info.task_id})
],
)
def test_delete_channelset(self):
channelset = models.ChannelSet.objects.create(
**self.channelset_db_metadata)
channelset.editors.add(self.user)
self.client.force_authenticate(user=self.user)
response = self.client.post(
self.sync_url,
[generate_delete_event(
channelset.id,
CHANNELSET,
)],
format="json",
)
self.assertEqual(response.status_code, 200, response.content)
try:
models.ChannelSet.objects.get(id=channelset.id)
self.fail("ChannelSet was not deleted")
except models.ChannelSet.DoesNotExist:
pass
