def test_path_ge_scalar(self):
"""
Greater than or equal to (>=) used with a scalar value returns the
expected result.
"""
float_tag = logic.create_tag(
user=self.site_admin_user,
name="float-tag",
description="A tag for annotating floating point data.",
type_of="f",
namespace=self.test_namespace,
private=False,
)
annotation1 = float_tag.annotate(self.admin_user, "test_object1", 0.0)
annotation2 = float_tag.annotate(self.admin_user, "test_object2", 1.23)
annotation3 = float_tag.annotate(self.admin_user, "test_object3",
-1.23)
annotation1.save()
annotation2.save()
annotation3.save()
tokens = list(self.lexer.tokenize("test_namespace/float-tag >= 0.0"))
parser = query.QueryParser(self.admin_user, self.lexer.tag_paths)
result = parser.parse((x for x in tokens))
self.assertEqual(len(result), 2)
self.assertIn("test_object1", result)
self.assertIn("test_object2", result)
def test_path_is_boolean(self):
"""
Check expected result from a query asking for objects tagged with a
boolean value.
"""
boolean_tag = logic.create_tag(
user=self.site_admin_user,
name="bool-tag",
description="A tag for annotating boolean data.",
type_of="b",
namespace=self.test_namespace,
private=False,
)
annotation1 = boolean_tag.annotate(self.admin_user, "test_object1",
True)
annotation2 = boolean_tag.annotate(self.admin_user, "test_object2",
False)
annotation1.save()
annotation2.save()
# Check False
lexer = query.QueryLexer()
tokens1 = list(lexer.tokenize("test_namespace/bool-tag is False"))
parser = query.QueryParser(self.admin_user, lexer.tag_paths)
result = parser.parse((x for x in tokens1))
self.assertEqual(len(result), 1)
self.assertIn("test_object2", result)
# Check True
tokens = list(self.lexer.tokenize("test_namespace/bool-tag is true"))
parser = query.QueryParser(self.admin_user, self.lexer.tag_paths)
result = parser.parse((x for x in tokens))
self.assertEqual(len(result), 1)
self.assertIn("test_object1", result)
def test_path_is_mime(self):
"""
Check expected result from a query asking for objects tagged with a
binary blob of a certain MIME type (e.g. image/png).
"""
binary_tag = logic.create_tag(
user=self.site_admin_user,
name="bin-tag",
description="A tag for annotating binary data.",
type_of="a",
namespace=self.test_namespace,
private=False,
)
val = uploadedfile.InMemoryUploadedFile(
file=BytesIO(b"hello"),
field_name="",
name="file.txt",
content_type="text/text",
size=5,
charset="utf-8",
)
annotation = binary_tag.annotate(self.admin_user, "test_object1", val)
annotation.save()
tokens = list(
self.lexer.tokenize("test_namespace/bin-tag is mime:text/text"))
parser = query.QueryParser(self.admin_user, self.lexer.tag_paths)
result = parser.parse((x for x in tokens))
self.assertEqual(len(result), 1)
self.assertIn("test_object1", result)
def test_path_lt_scalar(self):
"""
Less than (<) used with a scalar value returns the expected result.
"""
int_tag = logic.create_tag(
user=self.site_admin_user,
name="int-tag",
description="A tag for annotating integer data.",
type_of="i",
namespace=self.test_namespace,
private=False,
)
annotation1 = int_tag.annotate(self.admin_user, "test_object1", 0)
annotation2 = int_tag.annotate(self.admin_user, "test_object2", 100)
annotation1.save()
annotation2.save()
tokens = list(self.lexer.tokenize("test_namespace/int-tag < 100"))
parser = query.QueryParser(self.admin_user, self.lexer.tag_paths)
result = parser.parse((x for x in tokens))
self.assertEqual(len(result), 1)
self.assertIn("test_object1", result)
def test_path_le_scalar(self):
"""
Less than or equal to (>=) used with a scalar value returns the
expected result.
"""
datetime_tag = logic.create_tag(
user=self.site_admin_user,
name="dt-tag",
description="A tag for annotating datetime data.",
type_of="d",
namespace=self.test_namespace,
private=False,
)
annotation1 = datetime_tag.annotate(
self.admin_user,
"test_object1",
datetime(2020, 8, 19, tzinfo=timezone.utc),
)
annotation2 = datetime_tag.annotate(
self.admin_user,
"test_object2",
datetime(2019, 8, 19, tzinfo=timezone.utc),
)
annotation3 = datetime_tag.annotate(
self.admin_user,
"test_object3",
datetime(2021, 8, 19, tzinfo=timezone.utc),
)
annotation1.save()
annotation2.save()
annotation3.save()
tokens = list(
self.lexer.tokenize("test_namespace/dt-tag <= 2020-08-19"))
parser = query.QueryParser(self.admin_user, self.lexer.tag_paths)
result = parser.parse((x for x in tokens))
self.assertEqual(len(result), 2)
self.assertIn("test_object1", result)
self.assertIn("test_object2", result)
def test_path_gt_scalar(self):
"""
Great than (>) used with a scalar value returns the expected result.
"""
dur_tag = logic.create_tag(
user=self.site_admin_user,
name="dur-tag",
description="A tag for annotating duration data.",
type_of="u",
namespace=self.test_namespace,
private=False,
)
annotation1 = dur_tag.annotate(self.admin_user, "test_object1",
timedelta(seconds=1024))
annotation2 = dur_tag.annotate(self.admin_user, "test_object2",
timedelta(days=1024))
annotation1.save()
annotation2.save()
tokens = list(self.lexer.tokenize("test_namespace/dur-tag > 100d"))
parser = query.QueryParser(self.admin_user, self.lexer.tag_paths)
result = parser.parse((x for x in tokens))
self.assertEqual(len(result), 1)
self.assertIn("test_object2", result)
def test_path_iis_string(self):
"""
Check expected results from a query asking for objects tagged with a
string/pointer that case insensitively matches the search term.
"""
pointer_tag = logic.create_tag(
user=self.site_admin_user,
name="pointer-tag",
description="A tag for pointing at things via a URL.",
type_of="p",
namespace=self.test_namespace,
private=False,
)
val1 = "https://ntoll.org/"
val2 = "Hello"
annotation1 = pointer_tag.annotate(self.admin_user, "test_object1",
val1)
annotation2 = self.public_tag.annotate(self.admin_user, "test_object2",
val2)
annotation1.save()
annotation2.save()
# Check pointer match.
lexer = query.QueryLexer()
tokens1 = list(
lexer.tokenize(
'test_namespace/pointer-tag iis "https://NTOLL.ORG/"'))
parser = query.QueryParser(self.admin_user, lexer.tag_paths)
result = parser.parse((x for x in tokens1))
self.assertEqual(len(result), 1)
self.assertIn("test_object1", result)
# Check string match.
tokens2 = list(
self.lexer.tokenize('test_namespace/public_tag iis "helLO"'))
parser = query.QueryParser(self.admin_user, self.lexer.tag_paths)
result = parser.parse((x for x in tokens2))
self.assertEqual(len(result), 1)
self.assertIn("test_object2", result)
def setUp(self):
self.lexer = query.QueryLexer()
self.site_admin_user = models.User.objects.create_user(
username="******",
email="*****@*****.**",
password="******",
is_superuser=True,
)
self.admin_user = models.User.objects.create_user(
username="******",
email="*****@*****.**",
password="******",
)
self.tag_user = models.User.objects.create_user(
username="******",
email="*****@*****.**",
password="******",
)
self.tag_reader = models.User.objects.create_user(
username="******",
email="*****@*****.**",
password="******",
)
self.normal_user = models.User.objects.create_user(
username="******",
email="*****@*****.**",
password="******",
)
self.namespace_name = "test_namespace"
self.namespace_description = "This is a test namespace."
self.test_namespace = logic.create_namespace(
self.site_admin_user,
self.namespace_name,
self.namespace_description,
admins=[
self.admin_user,
],
)
self.public_tag_name = "public_tag"
self.public_tag_description = "This is a public tag."
self.public_tag_type_of = "s"
self.public_tag = logic.create_tag(
user=self.site_admin_user,
name=self.public_tag_name,
description=self.public_tag_description,
type_of=self.public_tag_type_of,
namespace=self.test_namespace,
private=False,
)
self.user_tag_name = "user_tag"
self.user_tag_description = "This is a user tag."
self.user_tag_type_of = "b"
self.user_tag = logic.create_tag(
user=self.site_admin_user,
name=self.user_tag_name,
description=self.user_tag_description,
type_of=self.user_tag_type_of,
namespace=self.test_namespace,
private=True,
users=[
self.tag_user,
],
)
self.reader_tag_name = "reader_tag"
self.reader_tag_description = "This is a reader tag."
self.reader_tag_type_of = "i"
self.reader_tag = logic.create_tag(
user=self.site_admin_user,
name=self.reader_tag_name,
description=self.reader_tag_description,
type_of=self.reader_tag_type_of,
namespace=self.test_namespace,
private=True,
readers=[
self.tag_reader,
],
)