def test_submit_form(self):
keypair = generate_test_keypair()
first_key = EncryptionKey.objects.create(
public_key=keypair["publickey"], user=self.user, active=True)
with self.assertRaises(FormServiceException):
FormService.submit(form_id=self.form.id, content="helo")
create_signature_key.Command().handle()
result = FormService.submit(form_id=self.form.id, content="helo")
pub = pgpy.PGPKey()
pub.parse(
SignatureKey.objects.get(
active=True,
key_type=SignatureKey.SignatureKeyType.SECONDARY).public_key)
self.assertEqual(
bool(pub.verify(result["content"], result["signature"])), True)
signed_content = json.loads(result["content"])
self.assertEqual(signed_content["form_data"], "helo")
self.assertEqual(len(signed_content["public_keys_recipients"]), 1)
self.assertEqual(
signed_content["public_key_server"],
SignatureKey.objects.get(
active=True,
key_type=SignatureKey.SignatureKeyType.SECONDARY).public_key)
self.assertIn("BEGIN PGP PUBLIC KEY BLOCK",
signed_content["public_key_server"])
self.assertNotIn("BEGIN PGP PRIVATE KEY BLOCK",
signed_content["public_key_server"])
def setUp(self):
create_groups.Command().handle()
self.user = get_user_model().objects.create(username="******")
self.form = Form.objects.create(name="Hundiformular",
description="Doggo",
js_code="var foo;",
xml_code="<xml></xml>",
active=True)
# create a group and add a form/user to it
self.group = Group.objects.create(name="hundigruppe")
self.user.groups.add(self.group)
self.user.groups.add(AdministrativeStaffGroup)
self.form.teams.add(self.group)
self.keypair = generate_test_keypair()
self.first_key = EncryptionKey.objects.create(
public_key=self.keypair["publickey"], user=self.user, active=True)
create_signature_key.Command().handle()
self.form_submission = FormService.submit(form_id=self.form.id,
content="helo")
self.second_form = Form.objects.create(name="andre",
description="andre",
js_code="var foo;",
xml_code="<xml></xml>",
active=True)
# create a group and add a form/user to it
self.second_group = Group.objects.create(name="andre")
self.second_form.teams.add(self.second_group)
self.second_form_submission = FormService.submit(
form_id=self.second_form.id, content="helloo")
def test_retrieve_pgp_keys_for_form(self):
# a single key for one user
keypair = generate_test_keypair()
first_key = EncryptionKey.objects.create(
public_key=keypair["publickey"], user=self.user, active=True)
keys = FormService.retrieve_public_keys_for_form(self.form.id)
self.assertEqual(len(keys), 1)
# multiple keys for the same user
keypair = generate_test_keypair()
second_key = EncryptionKey.objects.create(
public_key=keypair["publickey"], active=True, user=self.user)
keys = FormService.retrieve_public_keys_for_form(self.form.id)
self.assertEqual(len(keys), 2)
# disable a key
first_key.active = False
first_key.save()
keys = FormService.retrieve_public_keys_for_form(self.form.id)
self.assertEqual(len(keys), 1)
# disable a key
second_key.active = False
second_key.save()
keys = FormService.retrieve_public_keys_for_form(self.form.id)
self.assertEqual(len(keys), 0)
def test_form_creation(self):
form = FormService.create_form_(self.admin, "A form", "Hello")
self.assertEqual(form.description, "Hello")
self.assertEqual(form.active, False)
self.assertEqual(Form.objects.count(), 2)
with self.assertRaises(PermissionError):
form = FormService.create_form_(self.user, "A form", "Hello")
def test_retrieve_form_submissions(self):
self.assertEqual(
FormReceiverService.retrieve_submitted_forms(self.user).count(), 1)
FormService.submit(form_id=self.form.id, content="helo")
self.assertEqual(
FormReceiverService.retrieve_submitted_forms(self.user).count(), 2)
self.user.groups.add(self.second_group)
self.assertEqual(
FormReceiverService.retrieve_submitted_forms(self.user).count(), 3)
def test_submit_key(self):
self.assertEqual(
len(FormService.retrieve_public_keys_for_form(self.form.id)), 1)
key = EncryptionKeyService.add_key(self.user, "keeey")
self.assertEqual(
len(FormService.retrieve_public_keys_for_form(self.form.id)), 1)
key.active = True
key.save()
self.assertEqual(
len(FormService.retrieve_public_keys_for_form(self.form.id)), 2)
def test_form_update(self):
form = FormService.create_form_(self.admin, "A form", "Hello")
form = FormService.update_form_(self.admin,
form.pk,
name="blub",
active=True,
js_code="var foo;",
xml_code="<xml></xml>")
self.assertEqual(form.xml_code, "<xml></xml>")
with self.assertRaises(PermissionError):
form = FormService.update_form_(self.user,
form.pk,
description="alo")
def test_retrieve_form(self):
# check form is retrieveable
form = FormService.retrieve_form(self.form.id)
self.assertEqual(self.form.id, form.id)
# disable form
self.form.active = False
self.form.save()
with self.assertRaises(FormServiceException):
form = FormService.retrieve_form(self.form.id)
# enable form again
self.form.active = True
self.form.save()
self.assertEqual(self.form.id, form.id)
def test_activate_key(self):
key = EncryptionKeyService.add_key(self.user, "keeey")
self.assertEqual(
len(FormService.retrieve_public_keys_for_form(self.form.id)), 1)
key = EncryptionKeyService.activate_key(self.admin, key.id)
self.assertEqual(
len(FormService.retrieve_public_keys_for_form(self.form.id)), 2)
key_two = EncryptionKeyService.add_key(self.user, "keeey")
self.assertEqual(
len(FormService.retrieve_public_keys_for_form(self.form.id)), 2)
with self.assertRaises(PermissionError):
key_two = EncryptionKeyService.activate_key(self.user, key_two)
def mutate(self, info, name, description):
user = get_user_from_info(info)
try:
result = FormService.create_form_(user, name, description)
except FormSchemaService.exceptions as e:
raise MutationExecutionException(str(e))
return CreateForm(success=True, form=result)
def mutate(self, info, form_id, content):
try:
result = FormService.submit(int(from_global_id(form_id)[1]),
content)
except FormService.exceptions as e:
raise MutationExecutionException(str(e))
return SubmitForm(success=True, **result)
def test_update_form_groups(self):
form = FormService.create_form_(self.admin, "A form", "Hello")
form = FormService.update_form_(self.admin,
form.pk,
name="blub",
active=True,
js_code="var foo;",
xml_code="<xml></xml>")
self.assertEqual(form.xml_code, "<xml></xml>")
grp = Group.objects.create(name="yolo")
form = FormService.update_form_groups(self.admin, form.pk,
[self.group.pk])
self.assertEqual(form.teams.first(), self.group)
self.assertEqual(form.teams.count(), 1)
form = FormService.update_form_groups(self.admin, form.pk, [grp.pk])
self.assertEqual(form.teams.first(), grp)
self.assertEqual(form.teams.count(), 1)
form = FormService.update_form_groups(self.admin, form.pk,
[self.group.pk, grp.pk])
self.assertEqual(form.teams.count(), 2)
with self.assertRaises(PermissionError):
form = FormService.update_form_groups(self.user, form.pk, [grp.pk])
def mutate(self,
info,
form_id,
name=NotPassed,
description=NotPassed,
xml_code=NotPassed,
js_code=NotPassed,
active=NotPassed):
user = get_user_from_info(info)
try:
result = FormService.update_form_(
user,
int(from_global_id(form_id)[1]),
name=name,
description=description,
xml_code=xml_code,
js_code=js_code,
active=active,
)
except FormSchemaService.exceptions as e:
raise MutationExecutionException(str(e))
return UpdateForm(success=True, form=result)
def resolve_public_keys_for_form(self, info, form_id):
return FormService.retrieve_public_keys_for_form(
int(from_global_id(form_id)[1]))
