def setUp(self):
# feincms page containing zipfelchappe app content
self.page = Page.objects.create(title="Projects", slug="projects")
ct = self.page.content_type_for(ApplicationContent)
ct.objects.create(parent=self.page, urlconf_path=app_settings.ROOT_URLS)
# Fixture Data for following tests
self.project1 = ProjectFactory.create()
self.project2 = ProjectFactory.create()
self.user = UserFactory.create()
self.admin = UserFactory.create(is_superuser=True, is_staff=True)
self.reward = RewardFactory.create(project=self.project1, minimum=20.00, quantity=1)
# Fresh Client for every test
self.client = Client()
def test_postfinance_max_duration(self):
now = timezone.now()
project = ProjectFactory.create(start=now)
project.end = now + timedelta(days=31)
self.assertRaises(ValidationError, project.full_clean)
project.end = now + timedelta(days=29)
project.full_clean()
def _set_up_public_project_with_comment(self):
self.public_project = ProjectFactory.create(is_public=True, creator=self.user, comment_level='private')
self.public_project.add_contributor(self.contributor, save=True)
self.public_wiki = NodeWikiFactory(node=self.public_project, user=self.user)
self.public_comment = CommentFactory(node=self.public_project, target=Guid.load(self.public_wiki._id), user=self.user)
self.public_url = '/{}comments/{}/'.format(API_BASE, self.public_comment._id)
self.public_comment_payload = self._set_up_payload(self.public_comment._id)
def setup(self, session):
self.dummy_instance = ProjectFactory.create()
self.model = Project(
id=self.dummy_instance.id,
description=self.dummy_instance.description,
)
self.model_attributes = ['id', 'description']
def _set_up_public_project_with_comment(self):
self.public_project = ProjectFactory.create(is_public=True, creator=self.user, comment_level='private')
self.public_project.add_contributor(self.contributor, save=True)
self.public_file = test_utils.create_test_file(self.public_project, self.user)
self.public_comment = CommentFactory(node=self.public_project, target=self.public_file.get_guid(), user=self.user)
self.public_url = '/{}comments/{}/'.format(API_BASE, self.public_comment._id)
self.public_comment_payload = self._set_up_payload(self.public_comment._id)
def _set_up_private_project_with_comment(self):
self.private_project = ProjectFactory.create(is_public=False, creator=self.user, comment_level='private')
self.private_project.add_contributor(self.contributor, save=True)
self.file = test_utils.create_test_file(self.private_project, self.user)
self.comment = CommentFactory(node=self.private_project, target=self.file.get_guid(), user=self.user)
self.private_url = '/{}comments/{}/'.format(API_BASE, self.comment._id)
self.payload = self._set_up_payload(self.comment._id)
def test_postfinance_max_duration(self):
now = timezone.now()
project = ProjectFactory.create(start=now)
project.end = now + timedelta(days=31)
self.assertRaises(ValidationError, project.full_clean)
project.end = now + timedelta(days=29)
project.full_clean()
def test_list_prints_id_title_and_project_if_project_existent(self):
project = ProjectFactory.create()
tasks = TaskFactory.create_batch(2, state='open')
tasks[0].project = project
self.session.commit()
id_index = self.columns.index('id')
project_index = self.columns.index('project_id')
columns = [
self.columns[id_index],
self.columns[project_index],
]
labels = [
self.labels[id_index],
self.labels[project_index],
]
self.report.print(columns=columns, labels=labels)
# Prepare desired report
report_data = []
for task in sorted(tasks, key=lambda k: k.id, reverse=True):
task_report = []
for attribute in columns:
if attribute == 'id':
task_report.append(task.sulid)
else:
task_report.append(task.__getattribute__(attribute))
report_data.append(task_report)
self.tabulate.assert_called_once_with(report_data,
headers=labels,
tablefmt='simple')
self.print.assert_called_once_with(self.tabulate.return_value)
def _set_up_private_project_with_comment(self):
self.private_project = ProjectFactory.create(is_public=False, creator=self.user, comment_level='private')
self.private_project.add_contributor(self.contributor, save=True)
self.wiki = NodeWikiFactory(node=self.private_project, user=self.user)
self.comment = CommentFactory(node=self.private_project, target=Guid.load(self.wiki._id), user=self.user)
self.private_url = '/{}comments/{}/'.format(API_BASE, self.comment._id)
self.payload = self._set_up_payload(self.comment._id)
def setUp(self):
# feincms page containing zipfelchappe app content
self.page = Page.objects.create(title='Projects', slug='projects')
ct = self.page.content_type_for(ApplicationContent)
ct.objects.create(parent=self.page,
urlconf_path=app_settings.ROOT_URLS)
# Fixture Data for following tests
self.project1 = ProjectFactory.create()
self.project2 = ProjectFactory.create()
self.user = UserFactory.create()
self.reward = RewardFactory.create(project=self.project1,
minimum=20.00,
quantity=2)
# Fresh Client for every test
self.client = Client()
def setUp(self):
self.project = ProjectFactory.create()
self.user = UserFactory.create()
self.backer = BackerFactory.create(user=self.user)
self.p1 = PledgeFactory.create(
project=self.project,
amount=10.00,
)
def test_add_task_assigns_project_if_exist(self):
project = ProjectFactory.create()
title = self.fake.sentence()
self.manager.add(title=title, project_id=project.id)
generated_task = self.session.query(Task).one()
assert generated_task.project is project
def _set_up_public_project_with_comment(self):
self.public_project = ProjectFactory.create(is_public=True, creator=self.user)
self.public_project.add_contributor(self.contributor, save=True)
self.public_comment = CommentFactory(node=self.public_project, user=self.user)
reply_target = Guid.load(self.public_comment._id)
self.public_comment_reply = CommentFactory(node=self.public_project, target=reply_target, user=self.user)
self.public_url = '/{}comments/{}/'.format(API_BASE, self.public_comment._id)
self.public_comment_payload = self._set_up_payload(self.public_comment._id)
def _set_up_private_project_with_comment(self):
self.private_project = ProjectFactory.create(is_public=False,
creator=self.user)
self.private_project.add_contributor(self.contributor, save=True)
self.comment = CommentFactory(node=self.private_project,
user=self.user)
self.private_url = '/{}comments/{}/'.format(API_BASE, self.comment._id)
self.payload = self._set_up_payload(self.comment._id)
def test_report_does_not_print_projects_without_tasks(self):
project = ProjectFactory.create()
# empty project
ProjectFactory.create()
# Project assignment
for task in self.tasks:
task.project = project
self.session.commit()
self.report.print(columns=self.columns, labels=self.labels)
self.tabulate.assert_called_once_with([
[project.id, 20, project.description],
],
headers=self.labels,
tablefmt='simple')
self.print.assert_called_once_with(self.tabulate.return_value)
def test_default_max_duration(self):
global payment_providers
pf = payment_providers['postfinance']
del payment_providers['postfinance']
project = ProjectFactory.create()
self.assertEqual(app_settings.MAX_PROJECT_DURATION_DAYS, 120)
project.end = timezone.now() + timedelta(days=121)
self.assertRaises(ValidationError, project.full_clean)
project.end = timezone.now() + timedelta(days=119)
project.full_clean()
payment_providers['postfinance'] = pf
def setUp(self):
self.project = ProjectFactory.create()
self.p1 = PledgeFactory.create(
project=self.project,
amount=10.00,
)
self.p2 = PledgeFactory.create(project=self.project,
amount=20.00,
anonymously=True)
def test_default_max_duration(self):
global payment_providers
pf = payment_providers['postfinance']
del payment_providers['postfinance']
project = ProjectFactory.create()
self.assertEqual(app_settings.MAX_PROJECT_DURATION_DAYS, 120)
project.end = timezone.now() + timedelta(days=121)
self.assertRaises(ValidationError, project.full_clean)
project.end = timezone.now() + timedelta(days=119)
project.full_clean()
payment_providers['postfinance'] = pf
def _set_up_public_project_comment_reports(self):
self.public_project = ProjectFactory.create(is_public=True, creator=self.user)
self.public_project.add_contributor(contributor=self.contributor, save=True)
self.public_comment = CommentFactory.build(node=self.public_project, user=self.contributor)
self.public_comment.reports = {self.user._id: {
'category': 'spam',
'text': 'This is spam',
'date': datetime.utcnow(),
'retracted': False,
}}
self.public_comment.save()
self.public_url = '/{}comments/{}/reports/{}/'.format(API_BASE, self.public_comment._id, self.user._id)
def _set_up_public_project_comment_reports(self, comment_level='public'):
self.public_project = ProjectFactory.create(is_public=True, creator=self.user, comment_level=comment_level)
self.public_project.add_contributor(contributor=self.contributor, save=True)
self.public_comment = CommentFactory.build(node=self.public_project, user=self.contributor)
self.public_comment.reports = self.public_comment.reports or {}
self.public_comment.reports[self.user._id] = {
'category': 'spam',
'text': 'This is spam',
'date': datetime.utcnow(),
'retracted': False,
}
self.public_comment.save()
self.public_url = '/{}comments/{}/reports/'.format(API_BASE, self.public_comment._id)
def setUp(self):
self.project = ProjectFactory.create()
self.p1 = PledgeFactory.create(
project=self.project,
amount=10.00,
)
self.p2 = PledgeFactory.create(
project=self.project,
amount=20.00,
anonymously=True
)
def test_report_does_not_print_projects_without_open_tasks(self):
project = ProjectFactory.create()
project_with_closed_tasks = ProjectFactory.create()
completed_task = TaskFactory.create(state='completed')
completed_task.project = project_with_closed_tasks
deleted_task = TaskFactory.create(state='deleted')
deleted_task.project = project_with_closed_tasks
# Project assignment
for task in self.tasks:
task.project = project
self.session.commit()
self.report.print(columns=self.columns, labels=self.labels)
self.tabulate.assert_called_once_with([
[project.id, 20, project.description],
],
headers=self.labels,
tablefmt='simple')
self.print.assert_called_once_with(self.tabulate.return_value)
def _set_up_private_project_file_comment_reports(self):
self.private_project = ProjectFactory.create(is_public=False, creator=self.user)
self.private_project.add_contributor(contributor=self.contributor, save=True)
self.file = test_utils.create_test_file(self.private_project, self.user)
self.comment = CommentFactory.build(node=self.private_project, target=self.file.get_guid(), user=self.contributor)
self.comment.reports = self.comment.reports or {}
self.comment.reports[self.user._id] = {
'category': 'spam',
'text': 'This is spam',
'date': datetime.utcnow(),
'retracted': False,
}
self.comment.save()
self.private_url = '/{}comments/{}/reports/'.format(API_BASE, self.comment._id)
def setUp(self):
self.project = ProjectFactory.create()
self.reward = RewardFactory.create(project=self.project,
minimum=20.00,
quantity=5)
self.p1 = PledgeFactory.create(project=self.project,
amount=25.00,
reward=self.reward)
# Payment is not saved yet
self.p2 = PledgeFactory.build(project=self.project,
amount=20.00,
reward=self.reward)
def _set_up_public_project_with_comment(self):
self.public_project = ProjectFactory.create(is_public=True, creator=self.user)
self.public_project.add_contributor(self.contributor, save=True)
self.public_comment = CommentFactory(node=self.public_project, user=self.user)
self.public_url = '/{}comments/{}/'.format(API_BASE, self.public_comment._id)
self.public_comment_payload = {
'data': {
'id': self.public_comment._id,
'type': 'comments',
'attributes': {
'content': 'Updating this comment',
'deleted': False
}
}
}
def test_serialize_private_node(self):
user = UserFactory()
auth = Auth(user=user)
public = ProjectFactory.create(is_public=True)
# Add contributor with write permissions to avoid admin permission cascade
public.add_contributor(user, permissions=['read', 'write'])
public.save()
private = ProjectFactory(parent=public, is_public=False)
NodeFactory(parent=private)
collector = rubeus.NodeFileCollector(node=public, auth=auth)
private_dummy = collector._serialize_node(private)
assert_false(private_dummy['permissions']['edit'])
assert_false(private_dummy['permissions']['view'])
assert_equal(private_dummy['name'], 'Private Component')
assert_equal(len(private_dummy['children']), 0)
def test_serialize_private_node(self):
user = UserFactory()
auth = Auth(user=user)
public = ProjectFactory.create(is_public=True)
# Add contributor with write permissions to avoid admin permission cascade
public.add_contributor(user, permissions=['read', 'write'])
public.save()
private = ProjectFactory(parent=public, is_public=False)
NodeFactory(parent=private)
collector = rubeus.NodeFileCollector(node=public, auth=auth)
private_dummy = collector._serialize_node(private)
assert_false(private_dummy['permissions']['edit'])
assert_false(private_dummy['permissions']['view'])
assert_equal(private_dummy['name'], 'Private Component')
assert_equal(len(private_dummy['children']), 0)
def setUp(self):
# feincms page containing zipfelchappe app content
self.page = Page.objects.create(title='Projects',
slug='projects',
override_url='/')
ct = self.page.content_type_for(ApplicationContent)
ct.objects.create(parent=self.page,
urlconf_path=app_settings.ROOT_URLS)
self.project = ProjectFactory.create()
self.p1 = PledgeFactory.create(project=self.project,
amount=10,
provider='postfinance')
self.user = UserFactory.create(first_name='Hans', last_name='Muster')
self.p1.backer.user = self.user
self.p1.backer.save()
self.client = self.get_client_with_session()
def setUp(self):
# feincms page containing zipfelchappe app content
self.page = Page.objects.create(title='Projects', slug='projects', override_url='/')
ct = self.page.content_type_for(ApplicationContent)
ct.objects.create(parent=self.page, urlconf_path=app_settings.ROOT_URLS)
self.project = ProjectFactory.create()
self.p1 = PledgeFactory.create(
project=self.project,
amount=10,
provider='postfinance'
)
self.user = UserFactory.create(
first_name='Hans',
last_name='Muster'
)
self.p1.backer.user = self.user
self.p1.backer.save()
self.client = self.get_client_with_session()
def _set_up_private_project_comment_reports(self):
self.private_project = ProjectFactory.create(is_public=False,
creator=self.user)
self.private_project.add_contributor(contributor=self.contributor,
save=True)
self.wiki = NodeWikiFactory(node=self.private_project, user=self.user)
self.comment = CommentFactory.build(node=self.private_project,
target=Guid.load(self.wiki._id),
user=self.contributor)
self.comment.reports = self.comment.reports or {}
self.comment.reports[self.user._id] = {
'category': 'spam',
'text': 'This is spam',
'date': datetime.utcnow(),
'retracted': False,
}
self.comment.save()
self.private_url = '/{}comments/{}/reports/'.format(
API_BASE, self.comment._id)
def test_report_does_not_count_completed_tasks_in_projects(self):
project = ProjectFactory.create()
# Project assignment
for task in self.tasks:
task.project = project
# Complete one task
self.tasks[0].state = 'completed'
self.tasks[1].state = 'deleted'
self.session.commit()
self.report.print(columns=self.columns, labels=self.labels)
self.tabulate.assert_called_once_with([
[project.id, 18, project.description],
],
headers=self.labels,
tablefmt='simple')
self.print.assert_called_once_with(self.tabulate.return_value)
def setUp(self):
self.project = ProjectFactory.create()
self.reward = RewardFactory.create(
project=self.project,
minimum=20.00,
quantity=5
)
self.p1 = PledgeFactory.create(
project=self.project,
amount=25.00,
reward=self.reward
)
# Payment is not saved yet
self.p2 = PledgeFactory.build(
project=self.project,
amount=20.00,
reward=self.reward
)
def setUp(self):
super(TestRubeus, self).setUp()
self.project = ProjectFactory.create()
self.consolidated_auth = Auth(user=self.project.creator)
self.non_authenticator = UserFactory()
self.project.save()
self.project.add_contributor(
contributor=self.non_authenticator,
auth=self.consolidated_auth,
)
self.project.add_addon('s3', self.consolidated_auth)
self.project.creator.add_addon('s3', self.consolidated_auth)
self.node_settings = self.project.get_addon('s3')
self.user_settings = self.project.creator.get_addon('s3')
self.user_settings.access_key = 'We-Will-Rock-You'
self.user_settings.secret_key = 'Idontknowanyqueensongs'
self.node_settings.bucket = 'Sheer-Heart-Attack'
self.node_settings.user_settings = self.user_settings
self.node_settings.save()
def _set_up_public_project_comment_reports(self, comment_level='public'):
self.public_project = ProjectFactory.create(
is_public=True, creator=self.user, comment_level=comment_level)
self.public_project.add_contributor(contributor=self.contributor,
save=True)
self.public_file = test_utils.create_test_file(self.public_project,
self.user)
self.public_comment = CommentFactory.build(
node=self.public_project,
target=self.public_file.get_guid(),
user=self.contributor)
self.public_comment.reports = self.public_comment.reports or {}
self.public_comment.reports[self.user._id] = {
'category': 'spam',
'text': 'This is spam',
'date': datetime.utcnow(),
'retracted': False,
}
self.public_comment.save()
self.public_url = '/{}comments/{}/reports/'.format(
API_BASE, self.public_comment._id)
def setUp(self):
super(TestRubeus, self).setUp()
self.project = ProjectFactory.create()
self.consolidated_auth = Auth(user=self.project.creator)
self.non_authenticator = UserFactory()
self.project.save()
self.project.add_contributor(
contributor=self.non_authenticator,
auth=self.consolidated_auth,
)
self.project.add_addon('s3', self.consolidated_auth)
self.project.creator.add_addon('s3', self.consolidated_auth)
self.node_settings = self.project.get_addon('s3')
self.user_settings = self.project.creator.get_addon('s3')
self.user_settings.access_key = 'We-Will-Rock-You'
self.user_settings.secret_key = 'Idontknowanyqueensongs'
self.node_settings.bucket = 'Sheer-Heart-Attack'
self.node_settings.user_settings = self.user_settings
self.node_settings.save()
