def test_transcription_review(self):
asset = create_asset()
anon = get_anonymous_user()
t1 = Transcription(asset=asset,
user=anon,
text="test",
submitted=now())
t1.full_clean()
t1.save()
self.login_user()
resp = self.client.post(reverse("review-transcription",
args=(t1.pk, )),
data={"action": "foobar"})
data = self.assertValidJSON(resp, expected_status=400)
self.assertIn("error", data)
self.assertEqual(
1,
Transcription.objects.filter(pk=t1.pk,
accepted__isnull=True).count())
resp = self.client.post(reverse("review-transcription",
args=(t1.pk, )),
data={"action": "accept"})
data = self.assertValidJSON(resp, expected_status=200)
self.assertEqual(
1,
Transcription.objects.filter(pk=t1.pk,
accepted__isnull=False).count())
def setUp(self):
user = User.objects.create(
username="******", email="*****@*****.**", is_staff=True
)
user.set_password("top_secret")
user.save()
self.assertTrue(self.client.login(username="******", password="******"))
campaign = create_campaign(published=True)
project = create_project(campaign=campaign, published=True)
item = create_item(project=project, published=True)
asset = create_asset(
item=item,
title="TestAsset",
description="Asset Description",
download_url=DOWNLOAD_URL,
media_type=MediaType.IMAGE,
sequence=1,
)
# add a Transcription object
transcription1 = Transcription(
asset=asset,
user=user,
text="Sample",
submitted=datetime.now(),
accepted=datetime.now(),
)
transcription1.full_clean()
transcription1.save()
def test_transcription_double_review(self):
asset = create_asset()
anon = get_anonymous_user()
t1 = Transcription(asset=asset,
user=anon,
text="test",
submitted=now())
t1.full_clean()
t1.save()
self.login_user()
resp = self.client.post(reverse("review-transcription",
args=(t1.pk, )),
data={"action": "accept"})
data = self.assertValidJSON(resp, expected_status=200)
resp = self.client.post(reverse("review-transcription",
args=(t1.pk, )),
data={"action": "reject"})
data = self.assertValidJSON(resp, expected_status=400)
self.assertIn("error", data)
self.assertEqual("This transcription has already been reviewed",
data["error"])
def test_stale_transcription_submission(self):
asset = create_asset()
anon = get_anonymous_user()
t1 = Transcription(asset=asset, user=anon, text="test")
t1.full_clean()
t1.save()
t2 = Transcription(asset=asset, user=anon, text="test", supersedes=t1)
t2.full_clean()
t2.save()
resp = self.client.post(reverse("submit-transcription",
args=(t1.pk, )))
data = self.assertValidJSON(resp, expected_status=400)
self.assertIn("error", data)
def save_transcription(request, *, asset_pk):
asset = get_object_or_404(Asset, pk=asset_pk)
if request.user.is_anonymous:
user = get_anonymous_user()
else:
user = request.user
# Check whether this transcription text contains any URLs
# If so, ask the user to correct the transcription by removing the URLs
transcription_text = request.POST["text"]
url_match = re.search(URL_REGEX, transcription_text)
if url_match:
return JsonResponse(
{
"error":
"It looks like your text contains URLs. "
"Please remove the URLs and try again."
},
status=400,
)
supersedes_pk = request.POST.get("supersedes")
if not supersedes_pk:
superseded = None
if asset.transcription_set.filter(supersedes=None).exists():
return JsonResponse(
{"error": "An open transcription already exists"}, status=409)
else:
if asset.transcription_set.filter(supersedes=supersedes_pk).exists():
return JsonResponse(
{"error": "This transcription has been superseded"},
status=409)
try:
superseded = asset.transcription_set.get(pk=supersedes_pk)
except Transcription.DoesNotExist:
return JsonResponse({"error": "Invalid supersedes value"},
status=400)
transcription = Transcription(asset=asset,
user=user,
supersedes=superseded,
text=transcription_text)
transcription.full_clean()
transcription.save()
return JsonResponse(
{
"id":
transcription.pk,
"submissionUrl":
reverse("submit-transcription", args=(transcription.pk, )),
},
status=201,
)
def test_bagit_export(self):
"""
Test the http GET on route /campaigns/exportBagit/<campaignname>/
"""
self.login_user()
campaign = create_campaign(published=True)
project = create_project(campaign=campaign, published=True)
item = create_item(project=project, published=True)
asset = create_asset(
item=item,
title="TestAsset",
description="Asset Description",
media_url="1.jpg",
media_type=MediaType.IMAGE,
sequence=1,
)
# add a Transcription object
transcription1 = Transcription(asset=asset,
user=self.user,
text="Sample")
transcription1.full_clean()
transcription1.save()
item_dir = os.path.join(settings.MEDIA_ROOT, campaign.slug,
project.slug, item.item_id, asset.slug)
asset_file = ContentFile(b"Not a real JPEG")
default_storage.save(os.path.join(item_dir, f"{asset.sequence}.jpg"),
asset_file)
response = self.client.get(
reverse("transcriptions:export-bagit", args=(campaign.slug, )))
self.assertEqual(response.status_code, 200)
self.assertEquals(
response.get("Content-Disposition"),
"attachment; filename=%s.zip" % campaign.slug,
)
f = io.BytesIO(response.content)
zipped_file = zipfile.ZipFile(f, "r")
self.assertIn("bagit.txt", zipped_file.namelist())
self.assertIn("bag-info.txt", zipped_file.namelist())
self.assertIn(
"data/test-project/testitem0123456789/testasset/1.jpg",
zipped_file.namelist(),
)
def test_AccountProfileView_get(self):
"""
Test the http GET on route account/profile
:return:
"""
# Arrange
self.login_user()
# create a collection
self.collection = Collection(
title="TextCollection",
slug="www.foo.com/slug2",
description="Collection Description",
metadata={"key": "val1"},
status=Status.PCT_0,
)
self.collection.save()
# create an Asset
self.asset = Asset(
title="TestAsset",
slug="www.foo.com/slug1",
description="Asset Description",
media_url="http://www.foo.com/1/2/3",
media_type=MediaType.IMAGE,
collection=self.collection,
metadata={"key": "val2"},
status=Status.PCT_0,
)
self.asset.save()
# add a Transcription object
self.transcription = Transcription(
asset=self.asset, user_id=self.user.id, status=Status.PCT_0
)
self.transcription.save()
# Act
response = self.client.get("/account/profile/")
# Assert
# validate the web page has the "tester" and "*****@*****.**" as values
self.assertTrue('value="tester"' in str(response.content))
self.assertTrue('value="*****@*****.**"' in str(response.content))
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, template_name="profile.html")
def setUpTestData(cls):
cls.anon_user = get_anonymous_user()
cls.reviewer = User.objects.create_user(username="******",
email="*****@*****.**")
cls.test_project = create_project()
cls.test_topic = create_topic(project=cls.test_project)
cls.items = [
create_item(
item_id=f"item_{i}",
title=f"Item {i}",
project=cls.test_project,
do_save=False,
) for i in range(0, 3)
]
Item.objects.bulk_create(cls.items)
cls.assets = []
for item in cls.items:
for i in range(0, 15):
cls.assets.append(
create_asset(title=f"{item.id} — {i}",
item=item,
do_save=False))
Asset.objects.bulk_create(cls.assets)
cls.transcriptions = []
for asset in cls.assets:
last_t = None
for n in range(0, 3):
cls.transcriptions.append(
Transcription(
asset=asset,
supersedes=last_t,
text=f"{asset} — {n}",
user=cls.anon_user,
))
Transcription.objects.bulk_create(cls.transcriptions)
submitted_t = cls.transcriptions[-1]
submitted_t.submitted = now()
submitted_t.full_clean()
submitted_t.save()
def test_transcription_disallow_self_review(self):
asset = create_asset()
self.login_user()
t1 = Transcription(asset=asset,
user=self.user,
text="test",
submitted=now())
t1.full_clean()
t1.save()
resp = self.client.post(reverse("review-transcription",
args=(t1.pk, )),
data={"action": "accept"})
data = self.assertValidJSON(resp, expected_status=400)
self.assertIn("error", data)
self.assertEqual("You cannot accept your own transcription",
data["error"])
def test_transcription_allow_self_reject(self):
asset = create_asset()
self.login_user()
t1 = Transcription(asset=asset,
user=self.user,
text="test",
submitted=now())
t1.full_clean()
t1.save()
resp = self.client.post(reverse("review-transcription",
args=(t1.pk, )),
data={"action": "reject"})
self.assertValidJSON(resp, expected_status=200)
self.assertEqual(
Asset.objects.get(pk=asset.pk).transcription_status,
TranscriptionStatus.IN_PROGRESS,
)
self.assertEqual(
Transcription.objects.get(pk=t1.pk).reviewed_by, self.user)
def save_transcription(request, *, asset_pk):
asset = get_object_or_404(Asset, pk=asset_pk)
if request.user.is_anonymous:
user = get_anonymous_user()
else:
user = request.user
supersedes_pk = request.POST.get("supersedes")
if not supersedes_pk:
superseded = None
if asset.transcription_set.filter(supersedes=None).exists():
return JsonResponse(
{"error": "An open transcription already exists"}, status=409
)
else:
if asset.transcription_set.filter(supersedes=supersedes_pk).exists():
return JsonResponse(
{"error": "This transcription has been superseded"}, status=409
)
try:
superseded = asset.transcription_set.get(pk=supersedes_pk)
except Transcription.DoesNotExist:
return JsonResponse({"error": "Invalid supersedes value"}, status=400)
transcription = Transcription(
asset=asset, user=user, supersedes=superseded, text=request.POST["text"]
)
transcription.full_clean()
transcription.save()
return JsonResponse(
{
"id": transcription.pk,
"submissionUrl": reverse("submit-transcription", args=(transcription.pk,)),
},
status=201,
)
def test_anonymous_transcription_submission(self):
asset = create_asset()
anon = get_anonymous_user()
transcription = Transcription(asset=asset,
user=anon,
text="previous entry")
transcription.full_clean()
transcription.save()
resp = self.client.post(
reverse("submit-transcription", args=(transcription.pk, )))
data = self.assertValidJSON(resp, expected_status=401)
self.assertIn("key", data)
self.assertIn("image", data)
self.assertFalse(
Transcription.objects.filter(submitted__isnull=False).exists())
self.completeCaptcha(data["key"])
self.client.post(
reverse("submit-transcription", args=(transcription.pk, )))
self.assertTrue(
Transcription.objects.filter(submitted__isnull=False).exists())
def test_ConcordiaAssetView_post(self):
"""
This unit test test the POST route /transcribe/<collection>/asset/<Asset_name>/
:return:
"""
# Arrange
self.login_user()
# create a collection
self.collection = Collection(
title="TestCollection",
slug="Collection1",
description="Collection Description",
metadata={"key": "val1"},
status=Status.EDIT,
)
self.collection.save()
# create an Asset
self.asset = Asset(
title="TestAsset",
slug="Asset1",
description="Asset Description",
media_url="http://www.foo.com/1/2/3",
media_type=MediaType.IMAGE,
collection=self.collection,
metadata={"key": "val2"},
status=Status.EDIT,
)
self.asset.save()
# add a Transcription object
self.transcription = Transcription(
asset=self.asset,
user_id=self.user.id,
text="Test transcription 1",
status=Status.EDIT,
)
self.transcription.save()
tag_name = "Test tag 1"
# Act
response = self.client.post(
"/transcribe/Collection1/asset/Asset1/",
{
"tx": "First Test Transcription",
"tags": tag_name,
"action": "Save"
},
)
# Assert
self.assertEqual(response.status_code, 302)
self.assertEqual(response.url, "/transcribe/Collection1/asset/Asset1/")
# Verify the new transcription and tag are in the db
transcription = Transcription.objects.filter(
text="First Test Transcription", asset=self.asset)
self.assertEqual(len(transcription), 1)
tags = UserAssetTagCollection.objects.filter(asset=self.asset,
user_id=self.user.id)
if tags:
separate_tags = tags[0].tags.all()
self.assertEqual(len(tags), 1)
self.assertEqual(separate_tags[0].name, tag_name)
def test_transcription_review_asset_status_updates(self):
"""
Confirm that the Asset.transcription_status field is correctly updated
throughout the review process
"""
asset = create_asset()
anon = get_anonymous_user()
# We should see NOT_STARTED only when no transcription records exist:
self.assertEqual(asset.transcription_set.count(), 0)
self.assertEqual(
Asset.objects.get(pk=asset.pk).transcription_status,
TranscriptionStatus.NOT_STARTED,
)
t1 = Transcription(asset=asset,
user=anon,
text="test",
submitted=now())
t1.full_clean()
t1.save()
self.assertEqual(
Asset.objects.get(pk=asset.pk).transcription_status,
TranscriptionStatus.SUBMITTED,
)
# “Login” so we can review the anonymous transcription:
self.login_user()
self.assertEqual(
1,
Transcription.objects.filter(pk=t1.pk,
accepted__isnull=True).count())
resp = self.client.post(reverse("review-transcription",
args=(t1.pk, )),
data={"action": "reject"})
self.assertValidJSON(resp, expected_status=200)
# After rejecting a transcription, the asset status should be reset to
# in-progress:
self.assertEqual(
1,
Transcription.objects.filter(pk=t1.pk,
accepted__isnull=True,
rejected__isnull=False).count(),
)
self.assertEqual(
Asset.objects.get(pk=asset.pk).transcription_status,
TranscriptionStatus.IN_PROGRESS,
)
# We'll simulate a second attempt:
t2 = Transcription(asset=asset,
user=anon,
text="test",
submitted=now(),
supersedes=t1)
t2.full_clean()
t2.save()
self.assertEqual(
Asset.objects.get(pk=asset.pk).transcription_status,
TranscriptionStatus.SUBMITTED,
)
resp = self.client.post(reverse("review-transcription",
args=(t2.pk, )),
data={"action": "accept"})
self.assertValidJSON(resp, expected_status=200)
self.assertEqual(
1,
Transcription.objects.filter(pk=t2.pk,
accepted__isnull=False).count())
self.assertEqual(
Asset.objects.get(pk=asset.pk).transcription_status,
TranscriptionStatus.COMPLETED,
)
def test_ExportCollectionToBagit_get(self):
"""
Test the http GET on route /transcribe/exportBagit/<collectionname>/
:return:
"""
media_url_str = "/foocollection/testasset/asset.jpg"
collection_name_str = "foocollection"
asset_folder_name_str = "testasset"
asset_name_str = "asset.jpg"
# Arrange
self.login_user()
# create a collection
self.collection = Collection(
title="FooCollection",
slug=collection_name_str,
description="Collection Description",
metadata={"key": "val1"},
is_active=True,
s3_storage=False,
status=Status.EDIT,
)
self.collection.save()
# create an Asset
self.asset = Asset(
title="TestAsset",
slug=asset_folder_name_str,
description="Asset Description",
media_url=media_url_str,
media_type=MediaType.IMAGE,
collection=self.collection,
sequence=0,
metadata={"key": "val2"},
status=Status.EDIT,
)
self.asset.save()
# add a Transcription object
self.transcription = Transcription(asset=self.asset,
user_id=self.user.id,
status=Status.EDIT,
text="Sample")
self.transcription.save()
# Make sure correct folders structure exists
collection_folder = "{0}/{1}".format(settings.MEDIA_ROOT,
collection_name_str)
if not os.path.exists(collection_folder):
os.makedirs(collection_folder)
source_dir = "{0}/{1}".format(collection_folder, asset_folder_name_str)
if not os.path.exists(source_dir):
os.makedirs(source_dir)
# create source asset file
with open("{0}/{1}".format(source_dir, asset_name_str),
"w+") as csv_file:
writer = csv.writer(csv_file)
writer.writerow([
"Collection",
"Title",
"Description",
"MediaUrl",
"Transcription",
"Tags",
])
# Act
response = self.client.get("/transcribe/exportBagit/foocollection/")
# Assert
self.assertEqual(response.status_code, 200)
self.assertEquals(
response.get("Content-Disposition"),
"attachment; filename=foocollection.zip",
)
try:
f = io.BytesIO(response.content)
zipped_file = zipfile.ZipFile(f, "r")
# self.assertIsNone(zipped_file.testzip())
self.assertIn("bagit.txt", zipped_file.namelist())
self.assertIn("bag-info.txt", zipped_file.namelist())
self.assertIn("data/testasset/export.csv", zipped_file.namelist())
csv_file = zipped_file.read("data/testasset/export.csv")
self.assertEqual(
str(csv_file),
"b'Collection,Title,Description,MediaUrl,Transcription,Tags\\r\\nFooCollection,TestAsset,Asset Description,{0},,\\r\\n'"
.format(media_url_str), # noqa
)
finally:
zipped_file.close()
f.close()
# Clean up temp folders
try:
shutil.rmtree(collection_folder)
except Exception as e:
pass
def test_ConcordiaAssetView_get(self):
"""
This unit test test the GET route /transcribe/<collection>/asset/<Asset_name>/
with already in use. Verify the updated_on time is updated on PageInUse
:return:
"""
# Arrange
self.login_user()
# create a collection
self.collection = Collection(
title="TestCollection",
slug="Collection1",
description="Collection Description",
metadata={"key": "val1"},
status=Status.EDIT,
)
self.collection.save()
# create an Asset
asset_slug = "Asset1"
self.asset = Asset(
title="TestAsset",
slug=asset_slug,
description="Asset Description",
media_url="http://www.foo.com/1/2/3",
media_type=MediaType.IMAGE,
collection=self.collection,
metadata={"key": "val2"},
status=Status.EDIT,
)
self.asset.save()
# add a Transcription object
self.transcription = Transcription(
asset=self.asset,
user_id=self.user.id,
text="Test transcription 1",
status=Status.EDIT,
)
self.transcription.save()
url = "/transcribe/Collection1/asset/Asset1/"
# Act
response = self.client.get(url)
# Assert
self.assertEqual(response.status_code, 200)
# get PageInUse value
page_in_use = PageInUse.objects.get(page_url=url)
# sleep so update time can be tested against original time
time.sleep(2)
# Act
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
# get PageInUse value
page_in_use2 = PageInUse.objects.get(page_url=url)
self.assertNotEqual(page_in_use.updated_on, page_in_use2.updated_on)
self.assertEqual(page_in_use.created_on, page_in_use2.created_on)
def test_ConcordiaAssetView_post_anonymous_invalid_captcha(self):
"""
This unit test test the POST route /transcribe/<collection>/asset/<Asset_name>/
for an anonymous user with missing captcha. This user should not be able to tag
also
:return:
"""
# Arrange
# create a collection
self.collection = Collection(
title="TestCollection",
slug="Collection1",
description="Collection Description",
metadata={"key": "val1"},
status=Status.EDIT,
)
self.collection.save()
# create an Asset
self.asset = Asset(
title="TestAsset",
slug="Asset1",
description="Asset Description",
media_url="http://www.foo.com/1/2/3",
media_type=MediaType.IMAGE,
collection=self.collection,
metadata={"key": "val2"},
status=Status.EDIT,
)
self.asset.save()
# create anonymous user
anon_user = User.objects.create(username="******",
email="*****@*****.**")
anon_user.set_password("blah_anonymous!")
anon_user.save()
# add a Transcription object
self.transcription = Transcription(
asset=self.asset,
user_id=anon_user.id,
text="Test transcription 1",
status=Status.EDIT,
)
self.transcription.save()
tag_name = "Test tag 1"
# Act
# post as anonymous user without captcha data
response = self.client.post(
"/transcribe/Collection1/asset/Asset1/",
{
"tx": "First Test Transcription",
"tags": tag_name,
"action": "Save"
},
)
# Assert
self.assertEqual(response.status_code, 200)
# Verify the new transcription are not in db
transcription = Transcription.objects.filter(
text="First Test Transcription", asset=self.asset)
self.assertEqual(len(transcription), 0)
def test_ConcordiaAssetView_post_anonymous_happy_path(self):
"""
This unit test test the POST route /transcribe/<collection>/asset/<Asset_name>/
for an anonymous user. This user should not be able to tag
:return:
"""
# Arrange
# create a collection
self.collection = Collection(
title="TestCollection",
slug="Collection1",
description="Collection Description",
metadata={"key": "val1"},
status=Status.EDIT,
)
self.collection.save()
# create an Asset
self.asset = Asset(
title="TestAsset",
slug="Asset1",
description="Asset Description",
media_url="http://www.foo.com/1/2/3",
media_type=MediaType.IMAGE,
collection=self.collection,
metadata={"key": "val2"},
status=Status.EDIT,
)
self.asset.save()
# create anonymous user
anon_user = User.objects.create(username="******",
email="*****@*****.**")
anon_user.set_password("blah_anonymous!")
anon_user.save()
# add a Transcription object
self.transcription = Transcription(
asset=self.asset,
user_id=anon_user.id,
text="Test transcription 1",
status=Status.EDIT,
)
self.transcription.save()
tag_name = "Test tag 1"
# Act
response = self.client.get("/transcribe/Collection1/asset/Asset1/")
self.assertEqual(response.status_code, 200)
hash_ = re.findall(r'value="([0-9a-f]+)"', str(response.content))[0]
captcha_response = CaptchaStore.objects.get(hashkey=hash_).response
response = self.client.post(
"/transcribe/Collection1/asset/Asset1/",
{
"tx": "First Test Transcription 1",
"tags": tag_name,
"action": "Save",
"captcha_0": hash_,
"captcha_1": captcha_response
},
)
# Assert
self.assertEqual(response.status_code, 302)
self.assertEqual(response.url, "/transcribe/Collection1/asset/Asset1/")
# Verify the new transcription in the db
transcription = Transcription.objects.filter(
text="First Test Transcription 1", asset=self.asset)
self.assertEqual(len(transcription), 1)
tags = UserAssetTagCollection.objects.filter(asset=self.asset,
user_id=anon_user.id)
# Tag is not in db, as anonymous user can't tag
self.assertEqual(len(tags), 0)
def test_Transcriptions_latest_get(self):
"""
Test getting latest transcription for an asset. route ws/transcriptions/asset/
:return:
"""
# Arrange
self.login_user()
# create a second user
username = "******"
self.user2 = User.objects.create(username=username,
email="*****@*****.**")
self.user2.set_password("top_secret")
self.user2.save()
# create a collection
self.collection = Collection(
title="TextCollection",
slug="www.foo.com/slug2",
description="Collection Description",
metadata={"key": "val1"},
status=Status.EDIT,
)
self.collection.save()
# create Assets
self.asset = Asset(
title="TestAsset",
slug="www.foo.com/slug1",
description="Asset Description",
media_url="http://www.foo.com/1/2/3",
media_type=MediaType.IMAGE,
collection=self.collection,
metadata={"key": "val2"},
status=Status.EDIT,
)
self.asset.save()
self.asset2 = Asset(
title="TestAsset2",
slug="www.foo.com/slug2",
description="Asset Description",
media_url="http://www.foo.com/1/2/3",
media_type=MediaType.IMAGE,
collection=self.collection,
metadata={"key": "val2"},
status=Status.EDIT,
)
self.asset2.save()
# add Transcription objects
self.transcription = Transcription(asset=self.asset,
user_id=self.user.id,
status=Status.EDIT,
text="T1")
self.transcription.save()
t2_text = "T2"
self.transcription2 = Transcription(asset=self.asset,
user_id=self.user2.id,
status=Status.EDIT,
text=t2_text)
self.transcription2.save()
# Act
response = self.client.get("/ws/transcription/%s/" % self.asset.id)
json_resp = json.loads(response.content)
# Assert
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(json_resp["text"], t2_text)
def test_ExportCollectionToBagit_get(self):
"""
Test the http GET on route /transcribe/exportBagit/<collectionname>/
:return:
"""
# Arrange
self.login_user()
## Build test data for local storage collection ##
# Collection Info (local storage)
locstor_media_url_str = "/locstorcollection/testasset/asset.jpg"
locstor_collection_name_str = "locstorcollection"
locstor_asset_folder_name_str = "testasset"
locstor_asset_name_str = "asset.jpg"
# create a collection (local Storage)
self.collection1 = Collection(
title="LocStorCollection",
slug=locstor_collection_name_str,
description="Collection Description",
metadata={"key": "val1"},
is_active=True,
s3_storage=False,
status=Status.EDIT,
)
self.collection1.save()
# create an Asset (local Storage)
self.asset1 = Asset(
title="TestAsset",
slug=locstor_asset_folder_name_str,
description="Asset Description",
media_url=locstor_media_url_str,
media_type=MediaType.IMAGE,
collection=self.collection1,
sequence=0,
metadata={"key": "val2"},
status=Status.EDIT,
)
self.asset1.save()
# add a Transcription object
self.transcription1 = Transcription(
asset=self.asset1, user_id=self.user.id, status=Status.EDIT, text="Sample"
)
self.transcription1.save()
## Build test data for S3 Storage Collection ##
# Collection Info (S3 storage)
s3_media_url_str = "https://s3.us-east-2.amazonaws.com/chc-collections/test_s3/mss859430177/0.jpg"
s3_collection_name_str = "test_s3"
s3_asset_folder_name_str = "testasset"
s3_asset_name_str = "asset.jpg"
# create a collection (local Storage)
self.collection2 = Collection(
title="Test S3",
slug=s3_collection_name_str,
description="Collection Description",
metadata={"key": "val1"},
is_active=True,
s3_storage=True,
status=Status.EDIT,
)
self.collection2.save()
# create an Asset (local Storage)
self.asset2 = Asset(
title="TestAsset",
slug=s3_asset_folder_name_str,
description="Asset Description",
media_url=s3_media_url_str,
media_type=MediaType.IMAGE,
collection=self.collection2,
sequence=0,
metadata={"key": "val2"},
status=Status.EDIT,
)
self.asset2.save()
# add a Transcription object
self.transcription2 = Transcription(
asset=self.asset2, user_id=self.user.id, status=Status.EDIT, text="Sample"
)
self.transcription2.save()
# Make sure correct folders structure exists for Local Storage Collection
collection_folder = "{0}/{1}".format(settings.MEDIA_ROOT, locstor_collection_name_str)
if not os.path.exists(collection_folder):
os.makedirs(collection_folder)
item_dir = "{0}/{1}".format(collection_folder, locstor_asset_folder_name_str)
if not os.path.exists(item_dir):
os.makedirs(item_dir)
# create source asset file for Local Storage Collection
with open("{0}/{1}".format(item_dir, locstor_asset_name_str), "w+") as csv_file:
writer = csv.writer(csv_file)
writer.writerow(
[
"Collection",
"Title",
"Description",
"MediaUrl",
"Transcription",
"Tags",
]
)
# Act (local storage collection)
response = self.client.get("/transcribe/exportBagit/locstorcollection/")
# Assert for Local Storage Collection
self.assertEqual(response.status_code, 200)
self.assertEquals(
response.get("Content-Disposition"),
"attachment; filename=locstorcollection.zip",
)
try:
f = io.BytesIO(response.content)
zipped_file = zipfile.ZipFile(f, "r")
# self.assertIsNone(zipped_file.testzip())
self.assertIn("bagit.txt", zipped_file.namelist())
self.assertIn("bag-info.txt", zipped_file.namelist())
self.assertIn("data/testasset/asset.txt", zipped_file.namelist())
finally:
zipped_file.close()
f.close()
# Act (s3 collection)
response2 = self.client.get("/transcribe/exportBagit/test_s3/")
# Assert for s3 Collection
self.assertEqual(response2.status_code, 200)
self.assertEquals(
response2.get("Content-Disposition"),
"attachment; filename=test_s3.zip",
)
try:
f = io.BytesIO(response2.content)
zipped_file = zipfile.ZipFile(f, "r")
self.assertIn("bagit.txt", zipped_file.namelist())
self.assertIn("bag-info.txt", zipped_file.namelist())
self.assertIn("data/mss859430177/0.txt", zipped_file.namelist())
self.assertIn("data/mss859430177/0.jpg", zipped_file.namelist())
finally:
zipped_file.close()
f.close()
# Clean up temp folders
try:
shutil.rmtree(collection_folder)
except Exception as e:
pass
def test_ConcordiaAssetView_post_contact_community_manager(self):
"""
This unit test test the POST route /transcribe/<collection>/asset/<Asset_name>/
for an anonymous user. Clicking the contact community manager button
should redirect to the contact us page.
:return:
"""
# Arrange
# create a collection
self.collection = Collection(
title="TestCollection",
slug="Collection1",
description="Collection Description",
metadata={"key": "val1"},
status=Status.EDIT,
)
self.collection.save()
# create an Asset
self.asset = Asset(
title="TestAsset",
slug="Asset1",
description="Asset Description",
media_url="http://www.foo.com/1/2/3",
media_type=MediaType.IMAGE,
collection=self.collection,
metadata={"key": "val2"},
status=Status.EDIT,
)
self.asset.save()
# create anonymous user
anon_user = User.objects.create(username="******",
email="*****@*****.**")
anon_user.set_password("blah_anonymous!")
anon_user.save()
# add a Transcription object
self.transcription = Transcription(
asset=self.asset,
user_id=anon_user.id,
text="Test transcription 1",
status=Status.EDIT,
)
self.transcription.save()
tag_name = "Test tag 1"
# Act
response = self.client.get("/transcribe/Collection1/asset/Asset1/")
self.assertEqual(response.status_code, 200)
response = self.client.post(
"/transcribe/Collection1/asset/Asset1/",
{
"tx": "",
"tags": "",
"action": "Contact Manager"
},
)
# Assert
self.assertEqual(response.status_code, 302)
self.assertEqual(response.url, "/contact/?pre_populate=true")
def test_Transcriptions_by_user(self):
"""
Test getting the user's transcriptions. route ws/transcription_by_user/<userid>/
:return:
"""
# Arrange
self.login_user()
# create a second user
username = "******"
self.user2 = User.objects.create(username=username,
email="*****@*****.**")
self.user2.set_password("top_secret")
self.user2.save()
# create a campaign
self.campaign = Campaign(
title="TextCampaign",
slug="www.foo.com/slug2",
description="Campaign Description",
metadata={"key": "val1"},
status=Status.EDIT,
)
self.campaign.save()
# create Assets
self.asset = Asset(
title="TestAsset",
slug="www.foo.com/slug1",
description="Asset Description",
media_url="http://www.foo.com/1/2/3",
media_type=MediaType.IMAGE,
campaign=self.campaign,
metadata={"key": "val2"},
status=Status.EDIT,
)
self.asset.save()
self.asset2 = Asset(
title="TestAsset2",
slug="www.foo.com/slug2",
description="Asset Description",
media_url="http://www.foo.com/1/2/3",
media_type=MediaType.IMAGE,
campaign=self.campaign,
metadata={"key": "val2"},
status=Status.EDIT,
)
self.asset2.save()
# add Transcription objects
t1_text = "T1"
self.transcription = Transcription(asset=self.asset,
user_id=self.user.id,
status=Status.EDIT,
text=t1_text)
self.transcription.save()
t2_text = "T2"
self.transcription2 = Transcription(asset=self.asset,
user_id=self.user2.id,
status=Status.EDIT,
text=t2_text)
self.transcription2.save()
t3_text = "T3"
self.transcription3 = Transcription(asset=self.asset,
user_id=self.user.id,
status=Status.EDIT,
text=t3_text)
self.transcription3.save()
# Act
response = self.client.get("/ws/transcription_by_user/%s/" %
self.user.id)
json_resp = json.loads(response.content)
transcriptions_array = []
for trans in json_resp["results"]:
transcriptions_array.append(trans["text"])
# Assert
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(json_resp["count"], 2)
self.assertTrue("T3" in transcriptions_array)
self.assertTrue("T1" in transcriptions_array)
self.assertFalse("T2" in transcriptions_array)