def do_login(self, create=True, superuser=False):
# login page
with self.wait_for_page_load():
self.click(self.driver.find_element_by_id('login-button'), )
# Create user
if create:
user = create_test_user()
if superuser:
user.is_superuser = True
user.save()
user.profile.language = 'en'
user.profile.save()
user.profile.languages.set(
Language.objects.filter(code__in=('he', 'cs', 'hu')))
else:
user = None
# Login
username_input = self.driver.find_element_by_id('id_username')
username_input.send_keys('*****@*****.**')
password_input = self.driver.find_element_by_id('id_password')
password_input.send_keys('testpassword')
with self.wait_for_page_load():
self.click(
self.driver.find_element_by_xpath('//input[@value="Login"]'))
return user
def setUp(self):
super(ViewTestCase, self).setUp()
# Many tests needs access to the request factory.
self.factory = RequestFactory()
# Create user
self.user = create_test_user()
group = Group.objects.get(name='Users')
self.user.groups.add(group)
# Create project to have some test base
self.subproject = self.create_subproject()
self.project = self.subproject.project
# Login
self.client.login(username='******', password='******')
# Prepopulate kwargs
self.kw_project = {
'project': self.project.slug
}
self.kw_subproject = {
'project': self.project.slug,
'subproject': self.subproject.slug,
}
self.kw_translation = {
'project': self.project.slug,
'subproject': self.subproject.slug,
'lang': 'cs',
}
self.kw_lang_project = {
'project': self.project.slug,
'lang': 'cs',
}
# Store URL for testing
self.translation_url = self.get_translation().get_absolute_url()
self.project_url = self.project.get_absolute_url()
self.subproject_url = self.subproject.get_absolute_url()
def do_login(self, create=True, superuser=False):
# login page
with self.wait_for_page_load():
self.click(
self.driver.find_element_by_id('login-button'),
)
# Create user
if create:
user = create_test_user()
if superuser:
user.is_superuser = True
user.save()
user.profile.language = 'en'
user.profile.save()
user.profile.languages.set(
Language.objects.filter(code__in=('he', 'cs', 'hu'))
)
else:
user = None
# Login
username_input = self.driver.find_element_by_id('id_username')
username_input.send_keys('*****@*****.**')
password_input = self.driver.find_element_by_id('id_password')
password_input.send_keys('testpassword')
with self.wait_for_page_load():
self.click(
self.driver.find_element_by_xpath('//input[@value="Login"]')
)
return user
def setUp(self):
super(GitCloneTest, self).setUp()
self.clone_test_repos()
self.component = self.create_component()
self.component.project.access_control = Project.ACCESS_PRIVATE
self.component.project.save()
self.user = create_test_user()
def do_login(self, create=True, superuser=False):
# login page
with self.wait_for_page_load():
self.click(self.driver.find_element_by_id("login-button"))
# Create user
if create:
user = create_test_user()
if superuser:
user.is_superuser = True
user.save()
user.profile.language = "en"
user.profile.save()
user.profile.languages.set(
Language.objects.filter(code__in=("he", "cs", "hu")))
else:
user = None
# Login
username_input = self.driver.find_element_by_id("id_username")
username_input.send_keys("*****@*****.**")
password_input = self.driver.find_element_by_id("id_password")
password_input.send_keys("testpassword")
with self.wait_for_page_load():
self.click(
self.driver.find_element_by_xpath('//input[@value="Login"]'))
return user
def setUp(self):
super().setUp()
self.clone_test_repos()
self.component = self.create_component()
self.component.project.access_control = Project.ACCESS_PRIVATE
self.component.project.save()
self.user = create_test_user()
def setUp(self):
super(GitCloneTest, self).setUp()
self.clone_test_repos()
self.subproject = self.create_subproject()
self.subproject.project.access_control = Project.ACCESS_PRIVATE
self.subproject.project.save()
self.user = create_test_user()
def test_delete_votes(self):
component = self.create_po(suggestion_voting=True, suggestion_autoaccept=True)
user = create_test_user()
translation = component.translation_set.get(language_code="cs")
unit = translation.unit_set.first()
suggestion = Suggestion.objects.add(unit, "Test", None)
Vote.objects.create(suggestion=suggestion, value=Vote.POSITIVE, user=user)
component.project.delete()
def test_login(self):
# open home page
self.driver.get('{0}{1}'.format(self.live_server_url, reverse('home')))
# login page
self.expand_navbar()
self.click(self.driver.find_element_by_id('login-button'), )
username_input = self.driver.find_element_by_id('id_username')
username_input.send_keys('testuser')
password_input = self.driver.find_element_by_id('id_password')
password_input.send_keys('secret')
self.click(
self.driver.find_element_by_xpath('//input[@value="Login"]'))
# Wait for submit
time.sleep(1)
# We should end up on login page as user was invalid
self.driver.find_element_by_id('id_username')
# Do proper login with new user
create_test_user()
password_input = self.driver.find_element_by_id('id_password')
password_input.send_keys('testpassword')
self.click(
self.driver.find_element_by_xpath('//input[@value="Login"]'))
# Wait for submit
time.sleep(1)
# Load profile
self.expand_navbar()
self.click(self.driver.find_element_by_id('profile-button'))
# Wait for profile to load
self.driver.find_element_by_id('subscriptions')
# Finally logout
self.expand_navbar()
self.click(self.driver.find_element_by_id('logout-button'))
# We should be back on home page
self.expand_navbar()
self.driver.find_element_by_id('suggestions')
def test_add_suggestions(self):
user = create_test_user()
call_command(
"add_suggestions", "test", "test", "cs", TEST_PO, author=user.email
)
translation = self.component.translation_set.get(language_code="cs")
self.assertEqual(translation.stats.suggestions, 1)
profile = Profile.objects.get(user__email=user.email)
self.assertEqual(profile.suggested, 1)
def test_add_suggestions(self):
user = create_test_user()
call_command(
'add_suggestions', 'test', 'test', 'cs', TEST_PO,
author=user.email
)
translation = self.component.translation_set.get(language_code='cs')
self.assertEqual(translation.stats.suggestions, 1)
profile = Profile.objects.get(user__email=user.email)
self.assertEqual(profile.suggested, 1)
def test_add_suggestions(self):
user = create_test_user()
call_command(
'add_suggestions', 'test', 'test', 'cs', TEST_PO,
author=user.email
)
translation = self.subproject.translation_set.get(language_code='cs')
self.assertEqual(translation.have_suggestion, 1)
profile = Profile.objects.get(user__email=user.email)
self.assertEqual(profile.suggested, 1)
def test_newlines(self):
user = create_test_user()
unit = Unit.objects.filter(translation__language_code="cs")[0]
unit.translate(user, "new\nstring", STATE_TRANSLATED)
self.assertEqual(unit.target, "new\nstring")
# New object to clear all_flags cache
unit = Unit.objects.get(pk=unit.pk)
unit.flags = "dos-eol"
unit.translate(user, "new\nstring", STATE_TRANSLATED)
self.assertEqual(unit.target, "new\r\nstring")
unit.translate(user, "other\r\nstring", STATE_TRANSLATED)
self.assertEqual(unit.target, "other\r\nstring")
def test_newlines(self):
user = create_test_user()
unit = Unit.objects.all()[0]
unit.translate(user, 'new\nstring', STATE_TRANSLATED)
self.assertEqual(unit.target, 'new\nstring')
# New object to clear all_flags cache
unit = Unit.objects.all()[0]
unit.flags = 'dos-eol'
unit.translate(user, 'new\nstring', STATE_TRANSLATED)
self.assertEqual(unit.target, 'new\r\nstring')
unit.translate(user, 'other\r\nstring', STATE_TRANSLATED)
self.assertEqual(unit.target, 'other\r\nstring')
def test_newlines(self):
request = HttpRequest()
request.user = create_test_user()
unit = Unit.objects.all()[0]
unit.translate(request, 'new\nstring', STATE_TRANSLATED)
self.assertEqual(unit.target, 'new\nstring')
# New object to clear all_flags cache
unit = Unit.objects.all()[0]
unit.flags = 'dos-eol'
unit.translate(request, 'new\nstring', STATE_TRANSLATED)
self.assertEqual(unit.target, 'new\r\nstring')
unit.translate(request, 'other\r\nstring', STATE_TRANSLATED)
self.assertEqual(unit.target, 'other\r\nstring')
def test_commit_groupping(self):
project = self.create_subproject()
translation = project.translation_set.get(language_code='cs')
request = HttpRequest()
request.user = create_test_user()
for unit in translation.unit_set.all():
unit.translate(request, 'test2', STATE_TRANSLATED)
for unit in translation.unit_set.all():
request.user = User.objects.create(
first_name='User {}'.format(unit.pk),
username='******'.format(unit.pk),
email='{}@example.com'.format(unit.pk)
)
unit.translate(request, 'test', STATE_TRANSLATED)
translation.commit_pending(None)
def setUp(self):
super(ViewTestCase, self).setUp()
if self.fake_search:
Fulltext.FAKE = True
# Many tests needs access to the request factory.
self.factory = RequestFactory()
# Create user
self.user = create_test_user()
group = Group.objects.get(name='Users')
self.user.groups.add(group)
# Create another user
self.anotheruser = create_another_user()
self.user.groups.add(group)
# Create project to have some test base
self.component = self.create_component()
self.project = self.component.project
# Invalidate caches
self.project.stats.invalidate()
cache.clear()
# Login
self.client.login(username='******', password='******')
# Prepopulate kwargs
self.kw_project = {
'project': self.project.slug
}
self.kw_component = {
'project': self.project.slug,
'component': self.component.slug,
}
self.kw_translation = {
'project': self.project.slug,
'component': self.component.slug,
'lang': 'cs',
}
self.kw_lang_project = {
'project': self.project.slug,
'lang': 'cs',
}
# Store URL for testing
self.translation_url = self.get_translation().get_absolute_url()
self.project_url = self.project.get_absolute_url()
self.component_url = self.component.get_absolute_url()
def setUp(self):
super(ViewTestCase, self).setUp()
if self.fake_search:
Fulltext.FAKE = True
# Many tests needs access to the request factory.
self.factory = RequestFactory()
# Create user
self.user = create_test_user()
group = Group.objects.get(name='Users')
self.user.groups.add(group)
# Create another user
self.anotheruser = create_another_user()
self.user.groups.add(group)
# Create project to have some test base
self.component = self.create_component()
self.project = self.component.project
# Invalidate caches
self.project.stats.invalidate()
cache.clear()
# Login
self.client.login(username='******', password='******')
# Prepopulate kwargs
self.kw_project = {
'project': self.project.slug
}
self.kw_component = {
'project': self.project.slug,
'component': self.component.slug,
}
self.kw_translation = {
'project': self.project.slug,
'component': self.component.slug,
'lang': 'cs',
}
self.kw_lang_project = {
'project': self.project.slug,
'lang': 'cs',
}
# Store URL for testing
self.translation_url = self.get_translation().get_absolute_url()
self.project_url = self.project.get_absolute_url()
self.component_url = self.component.get_absolute_url()
def test_commit_groupping(self):
component = self.create_component()
translation = component.translation_set.get(language_code='cs')
request = HttpRequest()
request.user = create_test_user()
start_rev = component.repository.last_revision
# Initial translation
for unit in translation.unit_set.all():
unit.translate(request, 'test2', STATE_TRANSLATED)
# Translation completed, no commit forced
self.assertEqual(start_rev, component.repository.last_revision)
# Translation from same author should not trigger commit
for unit in translation.unit_set.all():
unit.translate(request, 'test3', STATE_TRANSLATED)
for unit in translation.unit_set.all():
unit.translate(request, 'test4', STATE_TRANSLATED)
self.assertEqual(start_rev, component.repository.last_revision)
# Translation from other author should trigger commmit
for i, unit in enumerate(translation.unit_set.all()):
request.user = User.objects.create(
full_name='User {}'.format(unit.pk),
username='******'.format(unit.pk),
email='{}@example.com'.format(unit.pk)
)
# Fetch current pending state, it might have been
# updated by background commit
unit.pending = Unit.objects.get(pk=unit.pk).pending
unit.translate(request, 'test', STATE_TRANSLATED)
if i == 0:
# First edit should trigger commit
self.assertNotEqual(
start_rev, component.repository.last_revision
)
start_rev = component.repository.last_revision
# No further commit now
self.assertEqual(start_rev, component.repository.last_revision)
# Commit pending changes
translation.commit_pending('test', None)
self.assertNotEqual(start_rev, component.repository.last_revision)
def test_middleware(self):
user = create_test_user()
# Unauthenticated
response = self.client.get(reverse("home"), follow=True)
self.assertContains(response, "Browse all 0 projects")
# Login
self.client.login(username="******", password="******")
# Chck that homepage redirects
response = self.client.get(reverse("home"), follow=True)
self.assertTrue(response.redirect_chain[-1][0].startswith(
reverse("legal:confirm")))
# Check that contact works even without TOS
response = self.client.get(reverse("contact"), follow=True)
self.assertContains(response, "You can only contact administrators")
# Confirm current TOS
request = HttpRequest()
request.META["REMOTE_ADDR"] = "127.0.0.1"
user.agreement.make_current(request)
# Homepage now should work
response = self.client.get(reverse("home"), follow=True)
self.assertContains(response, "Suggested translations")
def test_middleware(self):
user = create_test_user()
# Unauthenticated
response = self.client.get(reverse('home'), follow=True)
self.assertContains(response, 'Browse all 0 projects')
# Login
self.client.login(username='******', password='******')
# Chck that homepage redirects
response = self.client.get(reverse('home'), follow=True)
self.assertTrue(response.redirect_chain[-1][0].startswith(
reverse('legal:confirm')))
# Check that contact works even without TOS
response = self.client.get(reverse('contact'), follow=True)
self.assertContains(response, 'You can contact maintainers')
# Confirm current TOS
request = HttpRequest()
request.META['REMOTE_ADDR'] = '127.0.0.1'
user.agreement.make_current(request)
# Homepage now should work
response = self.client.get(reverse('home'), follow=True)
self.assertContains(response, 'Suggested translations')
def test_commit_groupping(self):
project = self.create_component()
translation = project.translation_set.get(language_code='cs')
request = HttpRequest()
request.user = create_test_user()
start_rev = project.repository.last_revision
# Initial translation
for unit in translation.unit_set.all():
unit.translate(request, 'test2', STATE_TRANSLATED)
# Translation completed, commit forced
self.assertNotEqual(start_rev, project.repository.last_revision)
start_rev = project.repository.last_revision
# Translation from same author should not trigger commit
for unit in translation.unit_set.all():
unit.translate(request, 'test3', STATE_TRANSLATED)
for unit in translation.unit_set.all():
unit.translate(request, 'test4', STATE_TRANSLATED)
self.assertEqual(start_rev, project.repository.last_revision)
# Translation from other author should trigger commmit
for i, unit in enumerate(translation.unit_set.all()):
request.user = User.objects.create(
full_name='User {}'.format(unit.pk),
username='******'.format(unit.pk),
email='{}@example.com'.format(unit.pk)
)
unit.refresh_from_db()
unit.translate(request, 'test', STATE_TRANSLATED)
if i == 0:
# First edit should trigger commit
self.assertNotEqual(
start_rev, project.repository.last_revision
)
start_rev = project.repository.last_revision
# No further commit now
self.assertEqual(start_rev, project.repository.last_revision)
# Commit pending changes
translation.commit_pending(None)
self.assertNotEqual(start_rev, project.repository.last_revision)
def test_commit_groupping(self):
project = self.create_component()
translation = project.translation_set.get(language_code='cs')
request = HttpRequest()
request.user = create_test_user()
start_rev = project.repository.last_revision
# Initial translation
for unit in translation.unit_set.all():
unit.translate(request, 'test2', STATE_TRANSLATED)
# Translation completed, commit forced
self.assertNotEqual(start_rev, project.repository.last_revision)
start_rev = project.repository.last_revision
# Translation from same author should not trigger commit
for unit in translation.unit_set.all():
unit.translate(request, 'test3', STATE_TRANSLATED)
for unit in translation.unit_set.all():
unit.translate(request, 'test4', STATE_TRANSLATED)
self.assertEqual(start_rev, project.repository.last_revision)
# Translation from other author should trigger commmit
for i, unit in enumerate(translation.unit_set.all()):
request.user = User.objects.create(
first_name='User {}'.format(unit.pk),
username='******'.format(unit.pk),
email='{}@example.com'.format(unit.pk)
)
unit.refresh_from_db()
unit.translate(request, 'test', STATE_TRANSLATED)
if i == 0:
# First edit should trigger commit
self.assertNotEqual(
start_rev, project.repository.last_revision
)
start_rev = project.repository.last_revision
# No further commit now
self.assertEqual(start_rev, project.repository.last_revision)
# Commit pending changes
translation.commit_pending(None)
self.assertNotEqual(start_rev, project.repository.last_revision)
def test_commit_groupping(self):
component = self.create_component()
translation = component.translation_set.get(language_code="cs")
user = create_test_user()
start_rev = component.repository.last_revision
# Initial translation
for unit in translation.unit_set.iterator():
unit.translate(user, "test2", STATE_TRANSLATED)
# Translation completed, no commit forced
self.assertEqual(start_rev, component.repository.last_revision)
# Translation from same author should not trigger commit
for unit in translation.unit_set.iterator():
unit.translate(user, "test3", STATE_TRANSLATED)
for unit in translation.unit_set.iterator():
unit.translate(user, "test4", STATE_TRANSLATED)
self.assertEqual(start_rev, component.repository.last_revision)
# Translation from other author should trigger commmit
for i, unit in enumerate(translation.unit_set.iterator()):
user = User.objects.create(
full_name=f"User {unit.pk}",
username=f"user-{unit.pk}",
email=f"{unit.pk}@example.com",
)
# Fetch current pending state, it might have been
# updated by background commit
unit.pending = Unit.objects.get(pk=unit.pk).pending
unit.translate(user, "test", STATE_TRANSLATED)
if i == 0:
# First edit should trigger commit
self.assertNotEqual(start_rev,
component.repository.last_revision)
start_rev = component.repository.last_revision
# No further commit now
self.assertEqual(start_rev, component.repository.last_revision)
# Commit pending changes
translation.commit_pending("test", None)
self.assertNotEqual(start_rev, component.repository.last_revision)
def setUp(self):
Payment.objects.all().delete()
Customer.objects.all().delete()
self.user = create_test_user()
self.client.login(username='******', password='******')
self.plan_a = Plan.objects.create(name='Plan A',
price=19,
yearly_price=199,
public=True)
self.plan_b = Plan.objects.create(name='Plan B',
price=49,
yearly_price=499,
public=True)
self.plan_c = Plan.objects.create(name='Plan C',
price=9,
yearly_price=99,
public=False)
self.plan_d = Plan.objects.create(name='Plan D',
price=0,
yearly_price=0,
public=True)
setup_dirs()
def test_acl(self):
"""Test for ACL handling."""
# Create user to verify ACL
user = create_test_user()
# Create project
project = self.create_project()
# Enable ACL
project.access_control = Project.ACCESS_PRIVATE
project.save()
# Check user does not have access
self.assertFalse(user.can_access_project(project))
# Add to ACL group
user.groups.add(Group.objects.get(name="Test@Translate"))
# Need to fetch user again to clear permission cache
user = User.objects.get(username="******")
# We now should have access
self.assertTrue(user.can_access_project(project))
def test_acl(self):
"""Test for ACL handling."""
# Create user to verify ACL
user = create_test_user()
# Create project
project = self.create_project()
# Enable ACL
project.access_control = Project.ACCESS_PRIVATE
project.save()
# Check user does not have access
self.assertFalse(user.can_access_project(project))
# Add to ACL group
user.groups.add(Group.objects.get(name='Test@Translate'))
# Need to fetch user again to clear permission cache
user = User.objects.get(username='******')
# We now should have access
self.assertTrue(user.can_access_project(project))
def setUp(self):
super().setUp()
# Many tests needs access to the request factory.
self.factory = RequestFactory()
# Create user
self.user = create_test_user()
group = Group.objects.get(name="Users")
self.user.groups.add(group)
# Create another user
self.anotheruser = create_another_user()
self.user.groups.add(group)
# Create project to have some test base
self.component = self.create_component()
self.project = self.component.project
# Invalidate caches
self.project.stats.invalidate()
cache.clear()
# Login
self.client.login(username="******", password="******")
# Prepopulate kwargs
self.kw_project = {"project": self.project.slug}
self.kw_component = {
"project": self.project.slug,
"component": self.component.slug,
}
self.kw_translation = {
"project": self.project.slug,
"component": self.component.slug,
"lang": "cs",
}
self.kw_lang_project = {"project": self.project.slug, "lang": "cs"}
# Store URL for testing
self.translation_url = self.get_translation().get_absolute_url()
self.project_url = self.project.get_absolute_url()
self.component_url = self.component.get_absolute_url()
def test_middleware(self):
user = create_test_user()
# Unauthenticated
response = self.client.get(reverse('home'), follow=True)
self.assertContains(response, 'Suggested translations')
# Login
self.client.login(username='******', password='******')
# Chck that homepage redirects
response = self.client.get(reverse('home'), follow=True)
self.assertTrue(
response.redirect_chain[-1][0].startswith(
reverse('legal:confirm')
)
)
# Check that contact works even without TOS
response = self.client.get(reverse('contact'), follow=True)
self.assertContains(response, 'You can contact maintainers')
# Confirm current TOS
request = HttpRequest()
request.META['REMOTE_ADDR'] = '127.0.0.1'
user.agreement.make_current(request)
# Homepage now should work
response = self.client.get(reverse('home'), follow=True)
self.assertContains(response, 'Suggested translations')
