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):
"""
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.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_read(self):
"""
Tests Version model read
"""
model = VersionF.create(
description=u'Test Description'
)
self.assertTrue(model.description == 'Test Description')
def test_VersionDelete_no_login(self):
my_client = Client()
version_to_delete = VersionF.create(project=self.my_project)
my_response = my_client.post(reverse('version-delete', kwargs={
'slug': version_to_delete.slug,
'project_slug': self.my_version.project.slug
}))
self.assertEqual(my_response.status_code, 302)
def test_Version_delete(self):
"""
Tests Version model delete
"""
my_model = VersionF.create()
my_model.delete()
#check if deleted
self.assertTrue(my_model.pk is None)
def test_Version_read(self):
"""
Tests Version model read
"""
my_model = VersionF.create(
name=u'Custom Version'
)
self.assertTrue(my_model.name == 'Custom Version')
self.assertTrue(my_model.slug == 'custom-version')
def test_VersionDelete_no_login(self):
version_to_delete = VersionF.create(project=self.project, name='2.0.1')
response = self.client.post(
reverse('version-delete',
kwargs={
'slug': version_to_delete.slug,
'project_slug': self.version.project.slug
}))
self.assertEqual(response.status_code, 302)
def test_Version_delete(self):
"""
Tests Version model delete
"""
model = VersionF.create()
model.delete()
# check if deleted
self.assertTrue(model.pk is None)
def test_VersionDelete_no_login(self):
version_to_delete = VersionF.create(
project=self.project,
name='2.0.1')
response = self.client.post(reverse('version-delete', kwargs={
'slug': version_to_delete.slug,
'project_slug': self.version.project.slug
}))
self.assertEqual(response.status_code, 302)
def test_Version_create(self):
"""
Tests Version model creation
"""
my_model = VersionF.create()
#check if PK exists
self.assertTrue(my_model.pk is not None)
#check if name exists
self.assertTrue(my_model.name is not None)
def test_Version_create(self):
"""
Tests Version model creation
"""
model = VersionF.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_VersionDelete_with_login(self):
my_client = Client()
version_to_delete = VersionF.create(project=self.my_project)
post_data = {
'pk': version_to_delete.pk
}
my_client.login(username='******', password='******')
my_response = my_client.post(reverse('version-delete', kwargs={
'slug': version_to_delete.slug,
'project_slug': version_to_delete.project.slug
}), post_data)
self.assertRedirects(my_response, reverse('version-list', kwargs={
'project_slug': self.my_project.slug
}))
def setUp(self):
"""
Setup before each test
"""
logging.disable(logging.CRITICAL)
self.my_project = ProjectF.create()
self.my_version = VersionF.create(project=self.my_project)
self.my_category = CategoryF.create(project=self.my_project)
self.my_user = UserF.create(**{
'username': '******',
'password': '******',
'is_staff': True
})
def test_VersionDelete_with_login(self):
version_to_delete = VersionF.create(project=self.project, name='8.1.1')
post_data = {'pk': version_to_delete.pk}
self.client.login(username='******', password='******')
response = self.client.post(
reverse('version-delete',
kwargs={
'slug': version_to_delete.slug,
'project_slug': version_to_delete.project.slug
}), post_data)
self.assertRedirects(
response,
reverse('version-list', kwargs={'project_slug':
self.project.slug}))
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_Version_update(self):
"""
Tests Version model update
"""
my_model = VersionF.create()
new_model_data = {
'name': u'New Version Name',
'description': u'New description',
'approved': True
}
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_Version_update(self):
"""
Tests Version model update
"""
model = VersionF.create()
new_model_data = {
'10002001': u'10002001',
'description': u'New description',
'approved': True
}
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_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_Version_read(self):
"""
Tests Version model read
"""
model = VersionF.create(description=u'Test Description')
self.assertTrue(model.description == 'Test Description')
