def setUp(self):
"""
Setup before each test
"""
logging.disable(logging.CRITICAL)
self.test_project = ProjectF.create()
self.unapproved_project = ProjectF.create(approved=False)
self.my_user = UserF.create(**{
'username': '******',
'password': '******',
'is_staff': True
})
def setUp(self):
"""
Setup before each test
We force the locale to en otherwise it will use
the locale of the host running the tests and we
will get unpredictable results / 404s
"""
self.client = Client()
self.client.post('/set_language/', data={'language': 'en'})
logging.disable(logging.CRITICAL)
self.user = UserF.create(**{
'username': '******',
'password': '******',
'is_staff': True
})
self.user.set_password('password')
self.user.save()
self.project = ProjectF.create(name='testproject')
self.sponsorship_level = SponsorshipLevelF.create(project=self.project,
name='Gold')
# Current sponsor
self.current_sponsor = SponsorF.create(project=self.project,
name='Current Sponsor')
self.current_sponsorship_period = SponsorshipPeriodF.create(
sponsor=self.current_sponsor,
sponsorship_level=self.sponsorship_level,
project=self.project,
approved=True,
start_date=datetime.datetime.now() - datetime.timedelta(days=180),
end_date=(datetime.datetime.now() +
datetime.timedelta(days=365)).date(),
)
# Past sponsor under a certain time limit, in this case 1 year
self.past_sponsor = SponsorF.create(project=self.project,
name='Past Sponsor')
self.past_sponsorship_period = SponsorshipPeriodF.create(
sponsor=self.past_sponsor,
sponsorship_level=self.sponsorship_level,
project=self.project,
approved=True,
start_date=datetime.datetime.now() - datetime.timedelta(days=180),
end_date=(datetime.datetime.now() -
datetime.timedelta(days=30)).date())
# It's a very old sponsor that will not be shown
self.one_decade_ago_sponsor = SponsorF.create(
project=self.project, name='One Decade Ago Sponsor')
self.one_decade_ago_sponsorship_period = SponsorshipPeriodF.create(
sponsor=self.one_decade_ago_sponsor,
sponsorship_level=self.sponsorship_level,
project=self.project,
approved=True,
start_date=datetime.datetime.now() - datetime.timedelta(days=4000),
end_date=(datetime.datetime.now() -
datetime.timedelta(days=3650)).date())
def setUp(self):
"""
Setup before each test
We force the locale to en otherwise it will use
the locale of the host running the tests and we
will get unpredictable results / 404s
"""
self.client = Client()
self.client.post(
'/set_language/', data={'language': 'en'})
logging.disable(logging.CRITICAL)
self.project = ProjectF.create(
name='testproject')
self.sponsor = SponsorF.create(
project=self.project,
name='Kartoza')
self.sponsorship_level = SponsorshipLevelF.create(
project=self.project,
name='Gold')
self.sponsorship_period = SponsorshipPeriodF.create(
sponsor=self.sponsor,
sponsorship_level=self.sponsorship_level,
approved=True)
self.user = UserF.create(**{
'username': '******',
'password': '******',
'is_staff': True
})
def test_ProjectDelete_no_login(self):
my_client = Client()
project_to_delete = ProjectF.create()
my_response = my_client.post(reverse('project-delete', kwargs={
'slug': project_to_delete.slug
}))
self.assertEqual(my_response.status_code, 302)
def setUp(self):
"""
Setup before each test
We force the locale to en otherwise it will use
the locale of the host running the tests and we
will get unpredictable results / 404s
"""
self.client = Client()
self.client.post('/set_language/', data={'language': 'en'})
logging.disable(logging.CRITICAL)
self.project = ProjectF.create(name='testproject')
self.version = VersionF.create(project=self.project, name='1.0.1')
self.category = CategoryF.create(project=self.project,
name='testcategory')
self.entry = EntryF.create(category=self.category,
version=self.version,
title='testentry',
approved=True)
self.user = UserF.create(**{
'username': '******',
'password': '******',
'is_staff': True
})
def setUp(self):
"""
Setup before each test
We force the locale to en otherwise it will use
the locale of the host running the tests and we
will get unpredictable results / 404s
"""
self.client = Client()
self.client.post('/set_language/', data={'language': 'en'})
logging.disable(logging.CRITICAL)
self.project = ProjectF.create(name='testproject')
self.sponsor = SponsorF.create(project=self.project, name='Kartoza')
self.sponsorship_level = SponsorshipLevelF.create(project=self.project,
name='Gold')
self.sponsorship_period = SponsorshipPeriodF.create(
sponsor=self.sponsor,
sponsorship_level=self.sponsorship_level,
approved=True)
self.user = UserF.create(**{
'username': '******',
'password': '******',
'is_staff': True
})
def setUp(self):
"""
Setup before each test
We force the locale to en otherwise it will use
the locale of the host running the tests and we
will get unpredictable results / 404s
"""
self.client = Client()
self.client.post(
'/set_language/', data={'language': 'en'})
logging.disable(logging.CRITICAL)
self.project = ProjectF.create(name='testproject')
self.version = VersionF.create(
project=self.project,
name='1.0.1')
self.category = CategoryF.create(
project=self.project,
name='testcategory')
self.user = UserF.create(**{
'username': '******',
'password': '******',
'is_staff': True
})
def test_Version_Sponsors(self):
"""
Tests version sponsors
"""
project = ProjectF.create()
sponsorship_period = SponsorshipPeriodF.create()
data = {
'start_date': u'2016-01-01',
'end_date': u'2016-02-01',
'approved': True,
'private': False,
'project_id': project.pk,
}
sponsorship_period.__dict__.update(data)
sponsorship_period.save()
version_model = VersionF.create()
data = {
'10002001': u'10002001',
'description': u'New description',
'approved': True,
'release_date': u'2016-01-10',
'project_id': project.pk,
}
version_model.__dict__.update(data)
version_model.save()
version_model.refresh_from_db()
sponsors = version_model.sponsors()
self.assertEqual(sponsors.count(), 1)
def test_Version_Sponsors(self):
"""
Tests version sponsors
"""
project = ProjectF.create()
sponsorship_period = SponsorshipPeriodF.create()
data = {
'start_date': u'2016-01-01',
'end_date': u'2016-02-01',
'approved': True,
'private': False,
'project_id': project.pk,
}
sponsorship_period.__dict__.update(data)
sponsorship_period.save()
version_model = VersionF.create()
data = {
'10002001': u'10002001',
'description': u'New description',
'approved': True,
'release_date': u'2016-01-10',
'project_id': project.pk,
}
version_model.__dict__.update(data)
version_model.save()
version_model.refresh_from_db()
sponsors = version_model.sponsors()
self.assertEqual(sponsors.count(), 1)
def setUp(self):
self.client = Client()
self.client.post('/set_language/', data={'language': 'en'})
logging.disable(logging.CRITICAL)
self.project = ProjectF.create()
self.certifying_organisation = \
CertifyingOrganisationF.create(project=self.project)
self.training_center = \
TrainingCenterF.create(
certifying_organisation=self.certifying_organisation)
self.course_convener = \
CourseConvenerF.create(
certifying_organisation=self.certifying_organisation)
self.course_type = \
CourseTypeF.create(
certifying_organisation=self.certifying_organisation)
self.course = CourseF.create(
certifying_organisation=self.certifying_organisation,
training_center=self.training_center,
course_convener=self.course_convener,
course_type=self.course_type)
self.user = UserF.create(**{
'username': '******',
'password': '******',
'is_staff': True
})
self.user.set_password('password')
self.user.save()
def setUp(self):
"""
Setup before each test
We force the locale to en otherwise it will use
the locale of the host running the tests and we
will get unpredictable results / 404s
"""
self.client = Client()
self.client.post(
'/set_language/', data={'language': 'en'})
logging.disable(logging.CRITICAL)
self.project = ProjectF.create()
self.sponsor = SponsorF.create(project=self.project)
self.user = UserF.create(**{
'username': '******',
'password': '******',
'is_staff': True
})
self.user2 = UserF.create(**{
'username': '******',
'password': '******',
'is_staff': False
})
# Something changed in the way factoryboy works with django 1.8
# I think - we need to explicitly set the users password
# because the core.model_factories.UserF._prepare method
# which sets the password is never called. Next two lines are
# a work around for that - sett #581
self.user.set_password('password')
self.user.save()
self.user2.set_password('password')
self.user2.save()
def test_unidecode(self):
"""
Tests unidecode() to represent special characters into ASCII
"""
model = ProjectF.create(name=u'straße',)
# check if properly decoded into ASCII
self.assertTrue(model.slug == "strasse")
def setUp(self):
"""Setting up before each test."""
self.client = Client()
self.client.post('/set_language/', data={'language': 'en'})
logging.disable(logging.CRITICAL)
self.user = UserF.create(**{
'username': '******',
'is_staff': False,
})
self.user.set_password('password')
self.user.save()
# lets set up a testing project to create organisations from.
self.test_project = ProjectF.create()
self.unapproved_project = ProjectF.create(approved=False)
self.test_organisation = OrganisationF.create()
def setUp(self):
"""
Setup before each test
"""
logging.disable(logging.CRITICAL)
self.user = UserF.create(**{"username": "******", "password": "******", "is_staff": True})
self.project = ProjectF.create()
self.committee = CommitteeF.create(project=self.project, users=[self.user])
def test_Project_read(self):
"""
Tests Project model read
"""
model = ProjectF.create(name='Custom Project', slug='custom-project')
self.assertTrue(model.name == 'Custom Project')
self.assertTrue(model.slug == 'custom-project')
def setUp(self):
"""
Setup before each test
We force the locale to en otherwise it will use
the locale of the host running the tests and we
will get unpredictable results / 404s
"""
self.client = Client()
self.client.post('/set_language/', data={'language': 'en'})
logging.disable(logging.CRITICAL)
self.test_project = ProjectF.create()
self.unapproved_project = ProjectF.create(approved=False)
self.user = UserF.create(**{
'username': '******',
'password': '******',
'is_staff': True
})
def test_ProjectDelete_with_login(self):
client = Client()
project_to_delete = ProjectF.create()
post_data = {'pk': project_to_delete.pk}
client.login(username='******', password='******')
response = client.post(
reverse('project-delete', kwargs={'slug': project_to_delete.slug}),
post_data)
self.assertRedirects(response, reverse('project-list'))
def setUp(self):
"""
Setup before each test
We force the locale to en otherwise it will use
the locale of the host running the tests and we
will get unpredictable results / 404s
"""
self.client = Client()
self.client.post(
'/set_language/', data={'language': 'en'})
logging.disable(logging.CRITICAL)
self.user = UserF.create(**{
'username': '******',
'password': '******',
'is_staff': True,
})
self.user.set_password('password')
self.user.save()
self.user2 = UserF.create(**{
'username': '******',
'password': '******',
'is_staff': True,
'first_name': 'User',
'last_name': 'Last',
})
self.user.set_password('password')
self.user.save()
self.project = ProjectF.create(
owner=self.user,
project_representative=self.user2
)
self.certifying_organisation = \
CertifyingOrganisationF.create()
self.course_convener = CourseConvenerF.create()
self.training_center = TrainingCenterF.create()
self.course_type = CourseTypeF.create()
self.course = CourseF.create(
course_convener=self.course_convener,
certifying_organisation=self.certifying_organisation,
course_type=self.course_type,
training_center=self.training_center
)
self.attendee = AttendeeF.create()
self.certificate = CertificateF.create(
course=self.course,
attendee=self.attendee,
author=self.user
)
self.certifying_organisation_certificate = (
CertifyingOrganisationCertificateF.create(
author=self.user,
certifying_organisation=self.certifying_organisation
)
)
def test_Project_delete(self):
"""
Tests Project model delete
"""
model = ProjectF.create()
model.delete()
# check if deleted
self.assertTrue(model.pk is None)
def setUp(self):
"""
Setup before each test
We force the locale to en otherwise it will use
the locale of the host running the tests and we
will get unpredictable results / 404s
"""
self.client = Client()
self.client.post(
'/set_language/', data={'language': 'en'})
logging.disable(logging.CRITICAL)
self.test_project = ProjectF.create()
self.unapproved_project = ProjectF.create(approved=False)
self.user = UserF.create(**{
'username': '******',
'password': '******',
'is_staff': True
})
def test_Project_delete(self):
"""
Tests Project model delete
"""
model = ProjectF.create()
model.delete()
# check if deleted
self.assertTrue(model.pk is None)
def test_Project_read(self):
"""
Tests Project model read
"""
model = ProjectF.create(
name='Custom Project',
slug='custom-project'
)
self.assertTrue(model.name == 'Custom Project')
self.assertTrue(model.slug == 'custom-project')
def test_Project_create(self):
"""
Tests Project model creation
"""
model = ProjectF.create()
# check if PK exists
self.assertTrue(model.pk is not None)
# check if name exists
self.assertTrue(model.name is not None)
def test_ProjectDelete_with_login(self):
my_client = Client()
project_to_delete = ProjectF.create()
post_data = {
'pk': project_to_delete.pk
}
my_client.login(username='******', password='******')
my_response = my_client.post(reverse('project-delete', kwargs={
'slug': project_to_delete.slug
}), post_data)
self.assertRedirects(my_response, reverse('project-list'))
def test_Project_create(self):
"""
Tests Project model creation
"""
model = ProjectF.create()
# check if PK exists
self.assertTrue(model.pk is not None)
# check if name exists
self.assertTrue(model.name is not None)
def setUp(self):
"""
In this test, a certificate is cost 3 credit.
"""
self.client = Client()
self.client.post('/set_language/', data={'language': 'en'})
self.user = UserF.create(**{'username': '******', 'is_staff': True})
self.user.set_password('password')
self.user.save()
self.project = ProjectF.create(certificate_credit=3)
def setUp(self):
"""
Setup before each test
"""
logging.disable(logging.CRITICAL)
self.my_project = ProjectF.create()
self.my_category = CategoryF.create(project=self.my_project)
self.my_user = UserF.create(**{
'username': '******',
'password': '******',
'is_staff': True
})
def setUp(self):
"""
Setup before each test
"""
logging.disable(logging.CRITICAL)
self.user = UserF.create(**{
'username': '******',
'password': '******',
'is_staff': True
})
self.project = ProjectF.create()
self.committee = CommitteeF.create(project=self.project,
users=[self.user])
def setUp(self):
"""
Setup before each test
"""
logging.disable(logging.CRITICAL)
self.my_user = UserF.create(**{
'username': '******',
'password': '******',
'is_staff': True
})
self.my_project = ProjectF.create()
self.my_committee = CommitteeF.create(project=self.my_project,
users=[self.my_user])
self.my_ballot = BallotF.create(committee=self.my_committee)
def setUp(self):
"""
Setup before each test
"""
self.user = UserF.create(**{
'username': '******',
'password': '******',
'is_staff': False
})
self.user.set_password('password')
self.user.save()
self.project = ProjectF.create()
self.sustaining_member = SponsorF.create(project=self.project,
author=self.user)
def test_sponsors(self):
"""
Tests version sponsors
"""
project = ProjectF.create()
data = {
'name': u'New Project Name',
'description': u'New description',
'approved': True,
'private': False,
'slug': u'new-project-slug'
}
project.__dict__.update(data)
project.save()
version_model = VersionF.create()
data = {
'10002001': u'10002001',
'description': u'New description',
'approved': True,
'release_date': u'2016-01-10',
'project': project
}
version_model.__dict__.update(data)
version_model.save()
sponsor = SponsorF.create()
data = {
'name': u'Foo Sponsor',
'project': project
}
sponsor.__dict__.update(data)
sponsor.save()
sponsorship_period = SponsorshipPeriodF.create()
data = {
'start_date': u'2016-01-01',
'end_date': u'2016-02-01',
'approved': True,
'private': False,
'project': project,
'sponsor': sponsor
}
sponsorship_period.__dict__.update(data)
sponsorship_period.save()
sponsors = version_model.sponsors()
self.assertEqual(sponsors.count(), 1)
def test_sponsors(self):
"""
Tests version sponsors
"""
project = ProjectF.create()
data = {
'name': u'New Project Name',
'description': u'New description',
'approved': True,
'private': False,
'slug': u'new-project-slug'
}
project.__dict__.update(data)
project.save()
version_model = VersionF.create()
data = {
'10002001': u'10002001',
'description': u'New description',
'approved': True,
'release_date': u'2016-01-10',
'project': project
}
version_model.__dict__.update(data)
version_model.save()
sponsor = SponsorF.create()
data = {'name': u'Foo Sponsor', 'project': project}
sponsor.__dict__.update(data)
sponsor.save()
sponsorship_period = SponsorshipPeriodF.create()
data = {
'start_date': u'2016-01-01',
'end_date': u'2016-02-01',
'approved': True,
'private': False,
'project': project,
'sponsor': sponsor
}
sponsorship_period.__dict__.update(data)
sponsorship_period.save()
sponsors = version_model.sponsors()
self.assertEqual(sponsors.count(), 1)
def test_Project_update(self):
"""
Tests Project model update
"""
my_model = ProjectF.create()
new_model_data = {
'name': u'New Project Name',
'description': u'New description',
'approved': False,
'private': True,
'slug': u'new-project-slug'
}
my_model.__dict__.update(new_model_data)
my_model.save()
#check if updated
for key, val in new_model_data.items():
self.assertEqual(my_model.__dict__.get(key), val)
def test_Project_update(self):
"""
Tests Project model update
"""
model = ProjectF.create()
new_model_data = {
'name': u'New Project Name',
'description': u'New description',
'approved': False,
'private': True,
'slug': u'new-project-slug'
}
model.__dict__.update(new_model_data)
model.save()
# check if updated
for key, val in new_model_data.items():
self.assertEqual(model.__dict__.get(key), val)
def test_gitter_validation(self):
"""
Test validation for gitter room field
"""
model = ProjectF.create()
new_model_data = {
'name': u'New Project Name',
'description': u'New description',
'approved': False,
'private': True,
'slug': u'new-project-slug',
'gitter_room': u'invalid',
}
model.__dict__.update(new_model_data)
with self.assertRaises(ValidationError):
if model.full_clean():
model.save()
self.assertEqual(Project.objects.filter(gitter_room='invalid').count(), 0)
def test_gitter_validation(self):
"""
Test validation for gitter room field
"""
model = ProjectF.create()
new_model_data = {
'name': u'New Project Name',
'description': u'New description',
'approved': False,
'private': True,
'slug': u'new-project-slug',
'gitter_room': u'invalid',
}
model.__dict__.update(new_model_data)
with self.assertRaises(ValidationError):
if model.full_clean():
model.save()
self.assertEqual(
Project.objects.filter(gitter_room='invalid').count(), 0)
def setUp(self):
"""
Setup before each test
We force the locale to en otherwise it will use
the locale of the host running the tests and we
will get unpredictable results / 404s
"""
self.client = Client()
self.client.post('/set_language/', data={'language': 'en'})
logging.disable(logging.CRITICAL)
self.user = UserF.create(**{'username': '******', 'is_staff': True})
# Something changed in the way factoryboy works with django 1.8
# I think - we need to explicitly set the users password
# because the core.model_factories.UserF._prepare method
# which sets the password is never called. Next two lines are
# a work around for that - sett #581
self.user.set_password('password')
self.user.save()
# Create project
self.test_project = ProjectF.create()
# Create section
self.test_section = SectionF.create(project=self.test_project)
self.test_worksheet = WorksheetF.create(section=self.test_section)
self.kwargs_project = {'project_slug': self.test_section.project.slug}
self.kwargs_section = {'slug': self.test_section.slug}
self.kwargs_section_full = {
'project_slug': self.test_section.project.slug,
'slug': self.test_section.slug
}
self.kwargs_worksheet_full = {
'project_slug': self.test_section.project.slug,
'section_slug': self.test_section.slug,
'pk': self.test_worksheet.pk
}
def test_ProjectDelete_no_login(self):
client = Client()
project_to_delete = ProjectF.create()
response = client.post(
reverse('project-delete', kwargs={'slug': project_to_delete.slug}))
self.assertEqual(response.status_code, 302)
