def test_is_sync_enabled(self):
project_enabled = ProjectFactory.build(info={'sync': {'enabled': True}})
project_enabled = project_enabled.__dict__
project_disabled = ProjectFactory.build(info={'sync': {'enabled': False}})
project_disabled = project_disabled.__dict__
assert self.syncer.is_sync_enabled(project_enabled) == True
assert self.syncer.is_sync_enabled(project_disabled) == False
def test_save(self):
"""Test save fails if the project has no password"""
project = ProjectFactory.build()
assert self.project_repo.get(project.id) is None
assert_raises(BadRequest, self.project_repo.save, project)
def test_save_fails_if_integrity_error(self):
"""Test save raises a DBIntegrityError if the instance to be saved lacks
a required value"""
project = ProjectFactory.build(name=None)
assert_raises(DBIntegrityError, self.project_repo.save, project)
def test_update_category_only_updates_categories(self):
"""Test update_category raises a WrongObjectError when an object which is
not a Category instance is updated"""
bad_object = ProjectFactory.build()
assert_raises(WrongObjectError, self.project_repo.update_category, bad_object)
def test_undo_sync_without_cache(self, fake_requests, mock_update):
user = UserFactory.create(admin=True, email_addr=u'*****@*****.**')
project_syncer = ProjectSyncer(self.target_url, self.target_key)
project = ProjectFactory.build(short_name=self.target_id)
project_syncer.undo_sync(project)
assert_raises(AssertionError, project_syncer._sync.assert_called)
def test_update_category_only_updates_categories(self):
"""Test update_category raises a WrongObjectError when an object which is
not a Category instance is updated"""
bad_object = ProjectFactory.build()
assert_raises(WrongObjectError, self.project_repo.update_category, bad_object)
def test_save_fails_if_integrity_error(self):
"""Test save raises a DBIntegrityError if the instance to be saved lacks
a required value"""
project = ProjectFactory.build(name=None)
assert_raises(DBIntegrityError, self.project_repo.save, project)
def test_undo_sync_with_cache(self, fake_requests, eock_update):
user = UserFactory.create(admin=True, email_addr=u'*****@*****.**')
project_syncer = ProjectSyncer(self.target_url, self.target_key)
project = ProjectFactory.build(short_name=self.target_id)
project_syncer.cache_target(create_target(), self.target_id)
project_syncer.undo_sync(project)
project_syncer._sync.assert_called_once()
def test_delete_autoimporter_works_as_expected(self):
autoimporter = {'type': 'csv', 'csv_url': 'http://fakeurl.com'}
project = ProjectFactory.build(info={'autoimporter': autoimporter})
assert project.has_autoimporter() is True
project.delete_autoimporter()
assert project.has_autoimporter() is False, project.get_autoimporter()
def test_delete_autoimporter_works_as_expected(self):
autoimporter = {"type": "csv", "csv_url": "http://fakeurl.com"}
project = ProjectFactory.build(info={"autoimporter": autoimporter})
assert project.has_autoimporter() is True
project.delete_autoimporter()
assert project.has_autoimporter() is False, project.get_autoimporter()
def test_set_autoimporter_works_as_expected(self):
autoimporter = {"type": "csv", "csv_url": "http://fakeurl.com"}
project = ProjectFactory.build(info={})
assert project.has_autoimporter() is False
project.set_autoimporter(autoimporter)
assert project.get_autoimporter() == autoimporter, project.get_autoimporter()
def test_set_autoimporter_works_as_expected(self):
autoimporter = {'type': 'csv', 'csv_url': 'http://fakeurl.com'}
project = ProjectFactory.build(info={})
assert project.has_autoimporter() is False
project.set_autoimporter(autoimporter)
assert project.get_autoimporter() == autoimporter, project.get_autoimporter()
def test_delete_autoimporter_works_as_expected(self):
autoimporter = {'type': 'csv', 'csv_url': 'http://fakeurl.com'}
project = ProjectFactory.build(info={'autoimporter': autoimporter})
assert project.has_autoimporter() is True
project.delete_autoimporter()
assert project.has_autoimporter() is False, project.get_autoimporter()
def test_get_target_owners_if_project_not_exist_prod(self, fake_requests, mock_get_user_email, mock_get):
user = UserFactory.create(admin=True, email_addr=u'*****@*****.**')
project_syncer = ProjectSyncer(self.target_url, self.target_key)
mock_get.return_value = create_target()
project = ProjectFactory.build(short_name=self.target_id)
project_syncer.get_target_owners(project, True)
mock_get_user_email.assert_called()
def test_save(self):
"""Test save persist the project"""
project = ProjectFactory.build()
assert self.project_repo.get(project.id) is None
self.project_repo.save(project)
assert self.project_repo.get(project.id) == project, "Project not saved"
def test_assign_user_to_project_works_as_expected(self):
project = ProjectFactory.build(info={})
assign_users = [1, 3]
project.set_project_users(assign_users)
users = project.get_project_users()
assert not project.info.get(
'project_users'
), "User should not be assigned to project without access levels"
def test_set_autoimporter_works_as_expected(self):
autoimporter = {'type': 'csv', 'csv_url': 'http://fakeurl.com'}
project = ProjectFactory.build(info={})
assert project.has_autoimporter() is False
project.set_autoimporter(autoimporter)
assert project.get_autoimporter(
) == autoimporter, project.get_autoimporter()
def test_save(self):
"""Test save persist the project"""
project = ProjectFactory.build()
assert self.project_repo.get(project.id) is None
self.project_repo.save(project)
assert self.project_repo.get(
project.id) == project, "Project not saved"
def test_get_target_owners_if_project_exist_prod(self, fake_requests, mock_get, mock_get_target_user):
user = UserFactory.create(admin=True, email_addr=u'*****@*****.**')
project_syncer = ProjectSyncer(self.target_url, self.target_key)
mock_get_target_user.return_value = create_response(True, 200, json.dumps({'email_addr': '*****@*****.**'}))
mock_get.return_value = create_target()
project = ProjectFactory.build(short_name=self.target_id)
emails = project_syncer.get_target_owners(project, False)
assert len(emails) == 3
assert '*****@*****.**' in emails
mock_get_target_user.assert_called()
def test_project_save_without_data_classification_fails(self):
"""Test save fails if the project has no data classification"""
# project w/o data classification raises error
project = ProjectFactory.build(info=dict())
project.set_password('hello')
assert self.project_repo.get(project.id) is None
assert_raises(BadRequest, self.project_repo.save, project)
# project w/o input data classification raises error
project = ProjectFactory.build(info=dict(data_classification=dict(
output_data="a")))
project.set_password('hello')
assert self.project_repo.get(project.id) is None
assert_raises(BadRequest, self.project_repo.save, project)
# project w/o output data classification raises error
project = ProjectFactory.build(info=dict(data_classification=dict(
input_data="a")))
project.set_password('hello')
assert self.project_repo.get(project.id) is None
assert_raises(BadRequest, self.project_repo.save, project)
# project w/ incorrect input data classification raises error
project = ProjectFactory.build(info=dict(
data_classification=dict(input_data="a", output_data="a")))
project.set_password('hello')
assert self.project_repo.get(project.id) is None
assert_raises(BadRequest, self.project_repo.save, project)
# project w/ incorrect output data classification raises error
project = ProjectFactory.build(info=dict(data_classification=dict(
input_data="L3 - community", output_data="a")))
project.set_password('hello')
assert self.project_repo.get(project.id) is None
assert_raises(BadRequest, self.project_repo.save, project)
def test_get_autoimporter_returns_autoimporter(self):
autoimporter = {'type': 'csv', 'csv_url': 'http://fakeurl.com'}
project = ProjectFactory.build(info={'autoimporter': autoimporter})
assert project.get_autoimporter() == autoimporter, project.get_autoimporter()
def test_has_autoimporter_returns_false_if_no_autoimporter(self):
project = ProjectFactory.build(info={})
assert project.has_autoimporter() is False
def test_get_autoimporter_returns_autoimporter(self):
autoimporter = {'type': 'csv', 'csv_url': 'http://fakeurl.com'}
project = ProjectFactory.build(info={'autoimporter': autoimporter})
assert project.get_autoimporter(
) == autoimporter, project.get_autoimporter()
def test_check_password_bad_password(self, mock_signer):
mock_signer.loads = lambda x: x
project = ProjectFactory.build(info={'passwd_hash': 'mypassword'})
assert not project.check_password('notmypassword')
def test_has_autoimporter_returns_true_if_autoimporter(self):
autoimporter = {'type': 'csv', 'csv_url': 'http://fakeurl.com'}
project = ProjectFactory.build(info={'autoimporter': autoimporter})
assert project.has_autoimporter() is True
def test_needs_password_no_password_key(self):
"""Test needs_password returns false if the project has not a password"""
project = ProjectFactory.build(info={})
assert project.needs_password() is False
def test_needs_password_with_password_key_and_value(self, mock_signer):
"""Test needs_password returns true if the project has a password"""
mock_signer.loads = lambda x: x
project = ProjectFactory.build(info={'passwd_hash': 'mypassword'})
assert project.needs_password() is True
def test_get_autoimporter_returns_autoimporter(self):
autoimporter = {"type": "csv", "csv_url": "http://fakeurl.com"}
project = ProjectFactory.build(info={"autoimporter": autoimporter})
assert project.get_autoimporter() == autoimporter, project.get_autoimporter()
def test_has_autoimporter_returns_true_if_autoimporter(self):
autoimporter = {"type": "csv", "csv_url": "http://fakeurl.com"}
project = ProjectFactory.build(info={"autoimporter": autoimporter})
assert project.has_autoimporter() is True
def test_has_autoimporter_returns_false_if_no_autoimporter(self):
project = ProjectFactory.build(info={})
assert project.has_autoimporter() is False
def test_a_project_cannot_be_created_as_published(self):
"""Test a project cannot be created directly as published"""
published_project = ProjectFactory.build(published=True)
assert_raises(Forbidden, ensure_authorized_to, 'create', published_project)
def test_has_autoimporter_returns_true_if_autoimporter(self):
autoimporter = {'type': 'csv', 'csv_url': 'http://fakeurl.com'}
project = ProjectFactory.build(info={'autoimporter': autoimporter})
assert project.has_autoimporter() is True
def test_check_password_bad_password(self, mock_signer):
mock_signer.loads = lambda x: x
project = ProjectFactory.build(info={'passwd_hash': 'mypassword'})
assert not project.check_password('notmypassword')
def test_check_password_bad_password(self, mock_signer):
mock_signer.loads = lambda x: x
project = ProjectFactory.build(info={"passwd_hash": "mypassword"})
assert not project.check_password("notmypassword")
def test_needs_password_empty_password_key(self, mock_signer):
"""Test needs_password returns false if the project has an empty password"""
mock_signer.loads = lambda x: x
project = ProjectFactory.build(info={'passwd_hash': None})
assert project.needs_password() is False
def test_check_password_bad_password(self):
project = ProjectFactory.build(info={'passwd_hash': 'mypassword'})
assert not project.check_password('notmypassword')
def test_needs_password_no_password_key(self):
"""Test needs_password returns false if the project has not a password"""
project = ProjectFactory.build(info={})
assert project.needs_password() is False
def test_needs_password_empty_password_key(self, mock_signer):
"""Test needs_password returns false if the project has an empty password"""
mock_signer.loads = lambda x: x
project = ProjectFactory.build(info={'passwd_hash': None})
assert project.needs_password() is False
def test_a_project_cannot_be_created_as_published(self):
"""Test a project cannot be created directly as published"""
published_project = ProjectFactory.build(published=True)
assert_raises(Forbidden, ensure_authorized_to, 'create',
published_project)
def test_needs_password_with_password_key_and_value(self, mock_signer):
"""Test needs_password returns true if the project has a password"""
mock_signer.loads = lambda x: x
project = ProjectFactory.build(info={'passwd_hash': 'mypassword'})
assert project.needs_password() is True
