def test_with_hosting_service_new_account_2fa_code_required(self):
"""Testing RepositoryForm with a hosting service and new account and
two-factor auth code required
"""
form = RepositoryForm({
'name': 'test',
'hosting_type': 'test',
'test-hosting_account_username': '******',
'test-hosting_account_password': '******',
'tool': self.git_tool_id,
'test_repo_name': 'testrepo',
'bug_tracker_type': 'none',
})
self.assertFalse(form.is_valid())
self.assertFalse(form.hosting_account_linked)
self.assertIn('hosting_account', form.errors)
self.assertEqual(form.errors['hosting_account'],
['Enter your 2FA code.'])
self.assertTrue(
form.hosting_service_info['test']['needs_two_factor_auth_code'])
# Make sure none of the other auth forms are unhappy. That would be
# an indicator that we're doing form processing and validation wrong.
for auth_form in six.itervalues(form.hosting_auth_forms):
self.assertEqual(auth_form.errors, {})
def test_with_hosting_service_new_account_auth_error(self):
"""Testing RepositoryForm with a hosting service and new account and
authorization error
"""
form = RepositoryForm({
'name': 'test',
'hosting_type': 'test',
'test-hosting_account_username': '******',
'test-hosting_account_password': '******',
'tool': self.git_tool_id,
'test_repo_name': 'testrepo',
'bug_tracker_type': 'none',
})
self.assertFalse(form.is_valid())
self.assertFalse(form.hosting_account_linked)
self.assertIn('hosting_account', form.errors)
self.assertEqual(form.errors['hosting_account'],
['Unable to link the account: The username is '
'very very bad.'])
# Make sure none of the other auth forms are unhappy. That would be
# an indicator that we're doing form processing and validation wrong.
for auth_form in six.itervalues(form.hosting_auth_forms):
self.assertEqual(auth_form.errors, {})
def test_with_hosting_service_new_account_missing_fields(self):
"""Testing RepositoryForm with a hosting service and new account and
missing fields
"""
form = RepositoryForm({
'name': 'test',
'hosting_type': 'test',
'tool': self.git_tool_id,
'test_repo_name': 'testrepo',
'bug_tracker_type': 'none',
})
self.assertFalse(form.is_valid())
self.assertFalse(form.hosting_account_linked)
self.assertIn('hosting_account_username', form.errors)
self.assertIn('hosting_account_password', form.errors)
# Make sure the auth form also contains the errors.
auth_form = form.hosting_auth_forms.pop('test')
self.assertIn('hosting_account_username', auth_form.errors)
self.assertIn('hosting_account_password', auth_form.errors)
# Make sure none of the other auth forms are unhappy. That would be
# an indicator that we're doing form processing and validation wrong.
for auth_form in six.itervalues(form.hosting_auth_forms):
self.assertEqual(auth_form.errors, {})
def test_with_hosting_service_new_account(self):
"""Testing RepositoryForm with a hosting service and new account"""
form = RepositoryForm({
'name': 'test',
'hosting_type': 'test',
'test-hosting_account_username': '******',
'test-hosting_account_password': '******',
'tool': self.git_tool_id,
'test_repo_name': 'testrepo',
'bug_tracker_type': 'none',
})
self.assertTrue(form.is_valid())
self.assertTrue(form.hosting_account_linked)
repository = form.save()
self.assertEqual(repository.name, 'test')
self.assertEqual(repository.hosting_account.username, 'testuser')
self.assertEqual(repository.hosting_account.service_name, 'test')
self.assertEqual(repository.hosting_account.local_site, None)
self.assertEqual(repository.extra_data['repository_plan'], '')
self.assertEqual(repository.path, 'http://example.com/testrepo/')
self.assertEqual(repository.mirror_path, '')
# Make sure none of the other auth forms are unhappy. That would be
# an indicator that we're doing form processing and validation wrong.
for auth_form in six.itervalues(form.hosting_auth_forms):
self.assertEqual(auth_form.errors, {})
def test_with_hosting_service_self_hosted_and_existing_account(self):
"""Testing RepositoryForm with a self-hosted hosting service and
existing account
"""
account = HostingServiceAccount.objects.create(
username='******',
service_name='self_hosted_test',
hosting_url='https://example.com')
account.data['password'] = '******'
account.save()
form = RepositoryForm({
'name': 'test',
'hosting_type': 'self_hosted_test',
'self_hosted_test-hosting_url': 'https://example.com',
'hosting_account': account.pk,
'tool': self.git_tool_id,
'test_repo_name': 'myrepo',
'bug_tracker_type': 'none',
})
form.validate_repository = False
self.assertTrue(form.is_valid())
self.assertFalse(form.hosting_account_linked)
repository = form.save()
self.assertEqual(repository.name, 'test')
self.assertEqual(repository.hosting_account, account)
self.assertEqual(repository.extra_data['hosting_url'],
'https://example.com')
def test_with_hosting_service_new_account_2fa_code_required(self):
"""Testing RepositoryForm with a hosting service and new account and
two-factor auth code required
"""
form = RepositoryForm({
'name': 'test',
'hosting_type': 'test',
'test-hosting_account_username': '******',
'test-hosting_account_password': '******',
'tool': self.git_tool_id,
'test_repo_name': 'testrepo',
'bug_tracker_type': 'none',
})
self.assertFalse(form.is_valid())
self.assertFalse(form.hosting_account_linked)
self.assertIn('hosting_account', form.errors)
self.assertEqual(form.errors['hosting_account'],
['Enter your 2FA code.'])
self.assertTrue(
form.hosting_service_info['test']['needs_two_factor_auth_code'])
# Make sure none of the other auth forms are unhappy. That would be
# an indicator that we're doing form processing and validation wrong.
for auth_form in six.itervalues(form.hosting_auth_forms):
self.assertEqual(auth_form.errors, {})
def test_with_hosting_service_existing_account(self):
"""Testing RepositoryForm with a hosting service and existing
account
"""
account = HostingServiceAccount.objects.create(username='******',
service_name='test')
account.data['password'] = '******'
account.save()
form = RepositoryForm({
'name': 'test',
'hosting_type': 'test',
'hosting_account': account.pk,
'tool': self.git_tool_id,
'test_repo_name': 'testrepo',
'bug_tracker_type': 'none',
})
self.assertTrue(form.is_valid())
self.assertFalse(form.hosting_account_linked)
repository = form.save()
self.assertEqual(repository.name, 'test')
self.assertEqual(repository.hosting_account, account)
self.assertEqual(repository.extra_data['repository_plan'], '')
def test_with_hosting_service_with_hosting_bug_tracker(self):
"""Testing RepositoryForm with hosting service's bug tracker"""
account = HostingServiceAccount.objects.create(username='******',
service_name='test')
account.data['password'] = '******'
account.save()
form = RepositoryForm({
'name': 'test',
'hosting_type': 'test',
'hosting_account': account.pk,
'tool': self.git_tool_id,
'test_repo_name': 'testrepo',
'bug_tracker_use_hosting': True,
'bug_tracker_type': 'googlecode',
})
form.validate_repository = False
self.assertTrue(form.is_valid())
repository = form.save()
self.assertTrue(repository.extra_data['bug_tracker_use_hosting'])
self.assertEqual(repository.bug_tracker,
'http://example.com/testuser/testrepo/issue/%s')
self.assertNotIn('bug_tracker_type', repository.extra_data)
self.assertFalse('bug_tracker-test_repo_name'
in repository.extra_data)
self.assertFalse('bug_tracker-hosting_account_username'
in repository.extra_data)
def test_repository_form_with_local_site_and_bad_group(self):
"""Testing adding a Group to a RepositoryForm with the wrong LocalSite."""
test_site = LocalSite.objects.create(name='test')
tool = Tool.objects.get(name='Subversion')
group = Group.objects.create(name='test-group')
svn_repo_path = 'file://' + os.path.join(os.path.dirname(__file__),
'testdata/svn_repo')
form = RepositoryForm({
'name': 'test',
'path': svn_repo_path,
'hosting_type': 'custom',
'bug_tracker_type': 'custom',
'review_groups': [group.pk],
'local_site': test_site.pk,
'tool': tool.pk,
})
self.assertFalse(form.is_valid())
group.local_site = test_site
group.save()
form = RepositoryForm({
'name': 'test',
'path': svn_repo_path,
'hosting_type': 'custom',
'bug_tracker_type': 'custom',
'review_groups': [group.pk],
'tool': tool.pk,
})
self.assertFalse(form.is_valid())
def test_with_hosting_service_new_account_missing_fields(self):
"""Testing RepositoryForm with a hosting service and new account and
missing fields
"""
form = RepositoryForm({
'name': 'test',
'hosting_type': 'test',
'tool': self.git_tool_id,
'test_repo_name': 'testrepo',
'bug_tracker_type': 'none',
})
self.assertFalse(form.is_valid())
self.assertFalse(form.hosting_account_linked)
self.assertIn('hosting_account_username', form.errors)
self.assertIn('hosting_account_password', form.errors)
# Make sure the auth form also contains the errors.
auth_form = form.hosting_auth_forms.pop('test')
self.assertIn('hosting_account_username', auth_form.errors)
self.assertIn('hosting_account_password', auth_form.errors)
# Make sure none of the other auth forms are unhappy. That would be
# an indicator that we're doing form processing and validation wrong.
for auth_form in six.itervalues(form.hosting_auth_forms):
self.assertEqual(auth_form.errors, {})
def test_with_hosting_service_existing_account_reauthing(self):
"""Testing RepositoryForm with a hosting service and existing
account with re-authorizating
"""
# We won't be setting the password, so that is_authorized() will
# fail.
account = HostingServiceAccount.objects.create(username='******',
service_name='test')
form = RepositoryForm({
'name': 'test',
'hosting_type': 'test',
'hosting_account': account.pk,
'test-hosting_account_username': '******',
'test-hosting_account_password': '******',
'tool': self.git_tool_id,
'test_repo_name': 'testrepo',
'bug_tracker_type': 'none',
})
self.assertTrue(form.is_valid())
self.assertTrue(form.hosting_account_linked)
account = HostingServiceAccount.objects.get(pk=account.pk)
self.assertEqual(account.username, 'testuser2')
self.assertEqual(account.data['password'], 'testpass2')
def test_with_hosting_service_new_account(self):
"""Testing RepositoryForm with a hosting service and new account"""
form = RepositoryForm({
'name': 'test',
'hosting_type': 'test',
'test-hosting_account_username': '******',
'test-hosting_account_password': '******',
'tool': self.git_tool_id,
'test_repo_name': 'testrepo',
'bug_tracker_type': 'none',
})
self.assertTrue(form.is_valid())
self.assertTrue(form.hosting_account_linked)
repository = form.save()
self.assertEqual(repository.name, 'test')
self.assertEqual(repository.hosting_account.username, 'testuser')
self.assertEqual(repository.hosting_account.service_name, 'test')
self.assertEqual(repository.hosting_account.local_site, None)
self.assertEqual(repository.extra_data['repository_plan'], '')
self.assertEqual(repository.path, 'http://example.com/testrepo/')
self.assertEqual(repository.mirror_path, '')
# Make sure none of the other auth forms are unhappy. That would be
# an indicator that we're doing form processing and validation wrong.
for auth_form in six.itervalues(form.hosting_auth_forms):
self.assertEqual(auth_form.errors, {})
def test_with_hosting_service_new_account_localsite(self):
"""Testing RepositoryForm with a hosting service, new account and
LocalSite
"""
local_site = LocalSite.objects.create(name='testsite')
form = RepositoryForm(
{
'name': 'test',
'hosting_type': 'test',
'test-hosting_account_username': '******',
'test-hosting_account_password': '******',
'tool': self.git_tool_id,
'test_repo_name': 'testrepo',
'bug_tracker_type': 'none',
'local_site': local_site.pk,
},
local_site_name=local_site.name)
self.assertTrue(form.is_valid())
self.assertTrue(form.hosting_account_linked)
repository = form.save()
self.assertEqual(repository.name, 'test')
self.assertEqual(repository.local_site, local_site)
self.assertEqual(repository.hosting_account.username, 'testuser')
self.assertEqual(repository.hosting_account.service_name, 'test')
self.assertEqual(repository.hosting_account.local_site, local_site)
self.assertEqual(repository.extra_data['repository_plan'], '')
def test_with_hosting_service_existing_account(self):
"""Testing RepositoryForm with a hosting service and existing
account
"""
account = HostingServiceAccount.objects.create(username='******',
service_name='test')
account.data['password'] = '******'
account.save()
form = RepositoryForm({
'name': 'test',
'hosting_type': 'test',
'hosting_account': account.pk,
'tool': self.git_tool_id,
'test_repo_name': 'testrepo',
'bug_tracker_type': 'none',
})
self.assertTrue(form.is_valid())
self.assertFalse(form.hosting_account_linked)
repository = form.save()
self.assertEqual(repository.name, 'test')
self.assertEqual(repository.hosting_account, account)
self.assertEqual(repository.extra_data['repository_plan'], '')
def test_with_hosting_service_self_hosted_and_existing_account(self):
"""Testing RepositoryForm with a self-hosted hosting service and
existing account
"""
account = HostingServiceAccount.objects.create(
username='******',
service_name='self_hosted_test',
hosting_url='https://example.com')
account.data['password'] = '******'
account.save()
form = RepositoryForm({
'name': 'test',
'hosting_type': 'self_hosted_test',
'self_hosted_test-hosting_url': 'https://example.com',
'hosting_account': account.pk,
'tool': self.git_tool_id,
'test_repo_name': 'myrepo',
'bug_tracker_type': 'none',
})
form.validate_repository = False
self.assertTrue(form.is_valid())
self.assertFalse(form.hosting_account_linked)
repository = form.save()
self.assertEqual(repository.name, 'test')
self.assertEqual(repository.hosting_account, account)
self.assertEqual(repository.extra_data['hosting_url'],
'https://example.com')
def test_with_hosting_service_new_account_localsite(self):
"""Testing RepositoryForm with a hosting service, new account and
LocalSite
"""
local_site = LocalSite.objects.create(name='testsite')
form = RepositoryForm(
{
'name': 'test',
'hosting_type': 'test',
'test-hosting_account_username': '******',
'test-hosting_account_password': '******',
'tool': self.git_tool_id,
'test_repo_name': 'testrepo',
'bug_tracker_type': 'none',
'local_site': local_site.pk,
},
local_site_name=local_site.name)
self.assertTrue(form.is_valid())
self.assertTrue(form.hosting_account_linked)
repository = form.save()
self.assertEqual(repository.name, 'test')
self.assertEqual(repository.local_site, local_site)
self.assertEqual(repository.hosting_account.username, 'testuser')
self.assertEqual(repository.hosting_account.service_name, 'test')
self.assertEqual(repository.hosting_account.local_site, local_site)
self.assertEqual(repository.extra_data['repository_plan'], '')
def test_with_hosting_service_self_hosted_bug_tracker_service(self):
"""Testing RepositoryForm with a self-hosted bug tracker service"""
account = HostingServiceAccount.objects.create(
username='******',
service_name='self_hosted_test',
hosting_url='https://example.com')
account.data['password'] = '******'
account.save()
form = RepositoryForm({
'name': 'test',
'hosting_type': 'self_hosted_test',
'hosting_url': 'https://example.com',
'hosting_account': account.pk,
'tool': self.git_tool_id,
'test_repo_name': 'testrepo',
'bug_tracker_type': 'self_hosted_test',
'bug_tracker_hosting_url': 'https://example.com',
'bug_tracker-test_repo_name': 'testrepo',
})
form.validate_repository = False
self.assertTrue(form.is_valid())
repository = form.save()
self.assertFalse(repository.extra_data['bug_tracker_use_hosting'])
self.assertEqual(repository.bug_tracker,
'https://example.com/testrepo/issue/%s')
self.assertEqual(repository.extra_data['bug_tracker_type'],
'self_hosted_test')
self.assertEqual(repository.extra_data['bug_tracker-test_repo_name'],
'testrepo')
self.assertEqual(repository.extra_data['bug_tracker_hosting_url'],
'https://example.com')
def test_with_hosting_service_new_account_auth_error(self):
"""Testing RepositoryForm with a hosting service and new account and
authorization error
"""
form = RepositoryForm({
'name': 'test',
'hosting_type': 'test',
'test-hosting_account_username': '******',
'test-hosting_account_password': '******',
'tool': self.git_tool_id,
'test_repo_name': 'testrepo',
'bug_tracker_type': 'none',
})
self.assertFalse(form.is_valid())
self.assertFalse(form.hosting_account_linked)
self.assertIn('hosting_account', form.errors)
self.assertEqual(
form.errors['hosting_account'],
['Unable to link the account: The username is '
'very very bad.'])
# Make sure none of the other auth forms are unhappy. That would be
# an indicator that we're doing form processing and validation wrong.
for auth_form in six.itervalues(form.hosting_auth_forms):
self.assertEqual(auth_form.errors, {})
def test_with_hosting_service_existing_account_reauthing(self):
"""Testing RepositoryForm with a hosting service and existing
account with re-authorizating
"""
# We won't be setting the password, so that is_authorized() will
# fail.
account = HostingServiceAccount.objects.create(username='******',
service_name='test')
form = RepositoryForm({
'name': 'test',
'hosting_type': 'test',
'hosting_account': account.pk,
'test-hosting_account_username': '******',
'test-hosting_account_password': '******',
'tool': self.git_tool_id,
'test_repo_name': 'testrepo',
'bug_tracker_type': 'none',
})
self.assertTrue(form.is_valid())
self.assertTrue(form.hosting_account_linked)
account = HostingServiceAccount.objects.get(pk=account.pk)
self.assertEqual(account.username, 'testuser2')
self.assertEqual(account.data['password'], 'testpass2')
def test_with_hosting_service_with_hosting_bug_tracker(self):
"""Testing RepositoryForm with hosting service's bug tracker"""
account = HostingServiceAccount.objects.create(username='******',
service_name='test')
account.data['password'] = '******'
account.save()
form = RepositoryForm({
'name': 'test',
'hosting_type': 'test',
'hosting_account': account.pk,
'tool': self.git_tool_id,
'test_repo_name': 'testrepo',
'bug_tracker_use_hosting': True,
'bug_tracker_type': 'googlecode',
})
form.validate_repository = False
self.assertTrue(form.is_valid())
repository = form.save()
self.assertTrue(repository.extra_data['bug_tracker_use_hosting'])
self.assertEqual(repository.bug_tracker,
'http://example.com/testuser/testrepo/issue/%s')
self.assertNotIn('bug_tracker_type', repository.extra_data)
self.assertFalse('bug_tracker-test_repo_name' in repository.extra_data)
self.assertFalse(
'bug_tracker-hosting_account_username' in repository.extra_data)
def test_with_hosting_service_with_existing_custom_bug_tracker(self):
"""Testing RepositoryForm with existing custom bug tracker"""
repository = Repository(name='test',
bug_tracker='http://example.com/issue/%s')
form = RepositoryForm(instance=repository)
self.assertFalse(form._get_field_data('bug_tracker_use_hosting'))
self.assertEqual(form._get_field_data('bug_tracker_type'), 'custom')
self.assertEqual(form.initial['bug_tracker'],
'http://example.com/issue/%s')
def test_with_hosting_service_with_existing_custom_bug_tracker(self):
"""Testing RepositoryForm with existing custom bug tracker"""
repository = Repository(name='test',
bug_tracker='http://example.com/issue/%s')
form = RepositoryForm(instance=repository)
self.assertFalse(form._get_field_data('bug_tracker_use_hosting'))
self.assertEqual(form._get_field_data('bug_tracker_type'), 'custom')
self.assertEqual(form.initial['bug_tracker'],
'http://example.com/issue/%s')
def test_with_hosting_service_with_existing_bug_tracker_using_hosting(
self):
"""Testing RepositoryForm with existing bug tracker using hosting
service
"""
account = HostingServiceAccount.objects.create(username='******',
service_name='test')
repository = Repository(name='test', hosting_account=account)
repository.extra_data['bug_tracker_use_hosting'] = True
repository.extra_data['test_repo_name'] = 'testrepo'
form = RepositoryForm(instance=repository)
self.assertTrue(form._get_field_data('bug_tracker_use_hosting'))
def test_with_hosting_service_with_existing_bug_tracker_using_hosting(
self):
"""Testing RepositoryForm with existing bug tracker using hosting
service
"""
account = HostingServiceAccount.objects.create(username='******',
service_name='test')
repository = Repository(name='test',
hosting_account=account)
repository.extra_data['bug_tracker_use_hosting'] = True
repository.extra_data['test_repo_name'] = 'testrepo'
form = RepositoryForm(instance=repository)
self.assertTrue(form._get_field_data('bug_tracker_use_hosting'))
def test_bound_forms_with_post_with_bug_tracker_service_and_plan(self):
"""Testing RepositoryForm binds hosting service forms only if matching
posted bug tracker hosting_service with specific plans
"""
form = RepositoryForm({
'name': 'test',
'bug_tracker_type': 'github',
'bug_tracker_plan': 'public',
})
# Make sure only the relevant forms are bound.
for hosting_type, bug_forms in six.iteritems(form.bug_tracker_forms):
for plan_id, bug_form in six.iteritems(bug_forms):
self.assertEqual(
bug_form.is_bound, hosting_type == 'github'
and plan_id == 'public')
# Repository info wasn't set in the form above.
for hosting_type, repo_forms in six.iteritems(form.repository_forms):
for plan_id, repo_form in six.iteritems(repo_forms):
self.assertFalse(repo_form.is_bound)
# Auth forms are never bound on initialize.
for hosting_type, auth_form in six.iteritems(form.hosting_auth_forms):
self.assertFalse(auth_form.is_bound)
def test_bound_forms_with_post_with_service(self):
"""Testing RepositoryForm binds hosting service forms only if matching
posted hosting_service using default plan
"""
form = RepositoryForm({
'name': 'test',
'hosting_type': 'test',
})
# Make sure only the relevant forms are bound.
for hosting_type, repo_forms in six.iteritems(form.repository_forms):
for plan_id, repo_form in six.iteritems(repo_forms):
self.assertEqual(
repo_form.is_bound, hosting_type == 'test'
and plan_id == form.DEFAULT_PLAN_ID)
for hosting_type, bug_forms in six.iteritems(form.bug_tracker_forms):
for plan_id, bug_form in six.iteritems(bug_forms):
self.assertEqual(
bug_form.is_bound, hosting_type == 'test'
and plan_id == form.DEFAULT_PLAN_ID)
# Auth forms are never bound on initialize.
for hosting_type, auth_form in six.iteritems(form.hosting_auth_forms):
self.assertFalse(auth_form.is_bound)
def test_plain_repository_with_missing_fields(self):
"""Testing RepositoryForm with a plain repository with missing fields
"""
form = RepositoryForm({
'name': 'test',
'hosting_type': 'custom',
'tool': self.git_tool_id,
'bug_tracker_type': 'none',
})
self.assertFalse(form.is_valid())
self.assertIn('path', form.errors)
# Make sure none of the other auth forms are unhappy. That would be
# an indicator that we're doing form processing and validation wrong.
for auth_form in six.itervalues(form.hosting_auth_forms):
self.assertEqual(auth_form.errors, {})
def test_plain_repository_with_missing_fields(self):
"""Testing RepositoryForm with a plain repository with missing fields
"""
form = RepositoryForm({
'name': 'test',
'hosting_type': 'custom',
'tool': self.git_tool_id,
'bug_tracker_type': 'none',
})
self.assertFalse(form.is_valid())
self.assertIn('path', form.errors)
# Make sure none of the other auth forms are unhappy. That would be
# an indicator that we're doing form processing and validation wrong.
for auth_form in six.itervalues(form.hosting_auth_forms):
self.assertEqual(auth_form.errors, {})
def test_with_hosting_service_self_hosted_and_blank_url(self):
"""Testing RepositoryForm with a self-hosted hosting service and blank
URL
"""
form = RepositoryForm({
'name': 'test',
'hosting_type': 'self_hosted_test',
'self_hosted_test-hosting_url': '',
'self_hosted_test-hosting_account_username': '******',
'self_hosted_test-hosting_account_password': '******',
'test_repo_name': 'myrepo',
'tool': self.git_tool_id,
'bug_tracker_type': 'none',
})
form.validate_repository = False
self.assertFalse(form.is_valid())
self.assertFalse(form.hosting_account_linked)
def test_repository_form_with_local_site_and_bad_user(self):
"""Testing adding a User to a RepositoryForm with the wrong LocalSite."""
test_site = LocalSite.objects.create(name='test')
tool = Tool.objects.get(name='Subversion')
svn_repo_path = 'file://' + os.path.join(os.path.dirname(__file__),
'testdata/svn_repo')
form = RepositoryForm({
'name': 'test',
'path': svn_repo_path,
'hosting_type': 'custom',
'bug_tracker_type': 'custom',
'users': [self.user.pk],
'local_site': test_site.pk,
'tool': tool.pk,
})
self.assertFalse(form.is_valid())
def test_with_hosting_service_self_hosted_and_blank_url(self):
"""Testing RepositoryForm with a self-hosted hosting service and blank
URL
"""
form = RepositoryForm({
'name': 'test',
'hosting_type': 'self_hosted_test',
'self_hosted_test-hosting_url': '',
'self_hosted_test-hosting_account_username': '******',
'self_hosted_test-hosting_account_password': '******',
'test_repo_name': 'myrepo',
'tool': self.git_tool_id,
'bug_tracker_type': 'none',
})
form.validate_repository = False
self.assertFalse(form.is_valid())
self.assertFalse(form.hosting_account_linked)
def test_repository_form_with_local_site_and_bad_user(self):
"""Testing adding a User to a RepositoryForm with the wrong LocalSite
"""
test_site = LocalSite.objects.create(name='test')
tool = Tool.objects.get(name='Subversion')
svn_repo_path = 'file://' + os.path.join(os.path.dirname(__file__),
'..', 'testdata', 'svn_repo')
form = RepositoryForm({
'name': 'test',
'path': svn_repo_path,
'hosting_type': 'custom',
'bug_tracker_type': 'custom',
'users': [self.user.pk],
'local_site': test_site.pk,
'tool': tool.pk,
})
self.assertFalse(form.is_valid())
def test_with_hosting_service_with_existing_bug_tracker_service(self):
"""Testing RepositoryForm with existing bug tracker service"""
repository = Repository(name='test')
repository.extra_data['bug_tracker_type'] = 'test'
repository.extra_data['bug_tracker-test_repo_name'] = 'testrepo'
repository.extra_data['bug_tracker-hosting_account_username'] = \
'testuser'
form = RepositoryForm(instance=repository)
self.assertFalse(form._get_field_data('bug_tracker_use_hosting'))
self.assertEqual(form._get_field_data('bug_tracker_type'), 'test')
self.assertEqual(
form._get_field_data('bug_tracker_hosting_account_username'),
'testuser')
self.assertIn('test', form.bug_tracker_forms)
self.assertIn('default', form.bug_tracker_forms['test'])
bitbucket_form = form.bug_tracker_forms['test']['default']
self.assertEqual(bitbucket_form.fields['test_repo_name'].initial,
'testrepo')
def test_with_hosting_service_with_existing_bug_tracker_service(self):
"""Testing RepositoryForm with existing bug tracker service"""
repository = Repository(name='test')
repository.extra_data['bug_tracker_type'] = 'test'
repository.extra_data['bug_tracker-test_repo_name'] = 'testrepo'
repository.extra_data['bug_tracker-hosting_account_username'] = \
'testuser'
form = RepositoryForm(instance=repository)
self.assertFalse(form._get_field_data('bug_tracker_use_hosting'))
self.assertEqual(form._get_field_data('bug_tracker_type'), 'test')
self.assertEqual(
form._get_field_data('bug_tracker_hosting_account_username'),
'testuser')
self.assertIn('test', form.bug_tracker_forms)
self.assertIn('default', form.bug_tracker_forms['test'])
bitbucket_form = form.bug_tracker_forms['test']['default']
self.assertEqual(
bitbucket_form.fields['test_repo_name'].initial,
'testrepo')
def test_plain_repository(self):
"""Testing RepositoryForm with a plain repository"""
form = RepositoryForm({
'name': 'test',
'hosting_type': 'custom',
'tool': self.git_tool_id,
'path': '/path/to/test.git',
'bug_tracker_type': 'none',
})
self.assertTrue(form.is_valid())
repository = form.save()
self.assertEqual(repository.name, 'test')
self.assertEqual(repository.hosting_account, None)
self.assertEqual(repository.extra_data, {})
# Make sure none of the other auth forms are unhappy. That would be
# an indicator that we're doing form processing and validation wrong.
for auth_form in six.itervalues(form.hosting_auth_forms):
self.assertEqual(auth_form.errors, {})
def test_plain_repository(self):
"""Testing RepositoryForm with a plain repository"""
form = RepositoryForm({
'name': 'test',
'hosting_type': 'custom',
'tool': self.git_tool_id,
'path': '/path/to/test.git',
'bug_tracker_type': 'none',
})
self.assertTrue(form.is_valid())
repository = form.save()
self.assertEqual(repository.name, 'test')
self.assertEqual(repository.hosting_account, None)
self.assertEqual(repository.extra_data, {})
# Make sure none of the other auth forms are unhappy. That would be
# an indicator that we're doing form processing and validation wrong.
for auth_form in six.itervalues(form.hosting_auth_forms):
self.assertEqual(auth_form.errors, {})
def test_repository_form_with_local_site_and_bad_group(self):
"""Testing adding a Group to a RepositoryForm with the wrong LocalSite
"""
test_site = LocalSite.objects.create(name='test')
tool = Tool.objects.get(name='Subversion')
group = Group.objects.create(name='test-group')
svn_repo_path = 'file://' + os.path.join(os.path.dirname(__file__),
'..', 'testdata', 'svn_repo')
form = RepositoryForm({
'name': 'test',
'path': svn_repo_path,
'hosting_type': 'custom',
'bug_tracker_type': 'custom',
'review_groups': [group.pk],
'local_site': test_site.pk,
'tool': tool.pk,
})
self.assertFalse(form.is_valid())
group.local_site = test_site
group.save()
form = RepositoryForm({
'name': 'test',
'path': svn_repo_path,
'hosting_type': 'custom',
'bug_tracker_type': 'custom',
'review_groups': [group.pk],
'tool': tool.pk,
})
self.assertFalse(form.is_valid())
def test_with_hosting_service_no_bug_tracker(self):
"""Testing RepositoryForm with no bug tracker"""
account = HostingServiceAccount.objects.create(username='******',
service_name='test')
account.data['password'] = '******'
account.save()
form = RepositoryForm({
'name': 'test',
'hosting_type': 'test',
'hosting_account': account.pk,
'tool': self.git_tool_id,
'test_repo_name': 'testrepo',
'bug_tracker_type': 'none',
})
self.assertTrue(form.is_valid())
repository = form.save()
self.assertFalse(repository.extra_data['bug_tracker_use_hosting'])
self.assertEqual(repository.bug_tracker, '')
self.assertNotIn('bug_tracker_type', repository.extra_data)
def test_with_hosting_service_no_bug_tracker(self):
"""Testing RepositoryForm with no bug tracker"""
account = HostingServiceAccount.objects.create(username='******',
service_name='test')
account.data['password'] = '******'
account.save()
form = RepositoryForm({
'name': 'test',
'hosting_type': 'test',
'hosting_account': account.pk,
'tool': self.git_tool_id,
'test_repo_name': 'testrepo',
'bug_tracker_type': 'none',
})
self.assertTrue(form.is_valid())
repository = form.save()
self.assertFalse(repository.extra_data['bug_tracker_use_hosting'])
self.assertEqual(repository.bug_tracker, '')
self.assertNotIn('bug_tracker_type', repository.extra_data)
def test_with_self_hosted_and_invalid_account_service(self):
"""Testing RepositoryForm with a self-hosted hosting service and
invalid existing account due to mismatched service type
"""
account = HostingServiceAccount.objects.create(
username='******',
service_name='self_hosted_test',
hosting_url='https://example1.com')
account.data['password'] = '******'
account.save()
form = RepositoryForm({
'name': 'test',
'hosting_type': 'test',
'hosting_account': account.pk,
'tool': self.git_tool_id,
'test_repo_name': 'myrepo',
'bug_tracker_type': 'none',
})
form.validate_repository = False
self.assertFalse(form.is_valid())
self.assertFalse(form.hosting_account_linked)
def test_with_hosting_service_existing_account_needs_reauth(self):
"""Testing RepositoryForm with a hosting service and existing
account needing re-authorization
"""
# We won't be setting the password, so that is_authorized() will
# fail.
account = HostingServiceAccount.objects.create(username='******',
service_name='test')
form = RepositoryForm({
'name': 'test',
'hosting_type': 'test',
'hosting_account': account.pk,
'tool': self.git_tool_id,
'test_repo_name': 'testrepo',
'bug_tracker_type': 'none',
})
self.assertFalse(form.is_valid())
self.assertFalse(form.hosting_account_linked)
self.assertEqual(set(form.errors.keys()),
set(['hosting_account_username',
'hosting_account_password']))
def test_with_self_hosted_and_invalid_account_service(self):
"""Testing RepositoryForm with a self-hosted hosting service and
invalid existing account due to mismatched service type
"""
account = HostingServiceAccount.objects.create(
username='******',
service_name='self_hosted_test',
hosting_url='https://example1.com')
account.data['password'] = '******'
account.save()
form = RepositoryForm({
'name': 'test',
'hosting_type': 'test',
'hosting_account': account.pk,
'tool': self.git_tool_id,
'test_repo_name': 'myrepo',
'bug_tracker_type': 'none',
})
form.validate_repository = False
self.assertFalse(form.is_valid())
self.assertFalse(form.hosting_account_linked)
def test_with_hosting_service_existing_account_needs_reauth(self):
"""Testing RepositoryForm with a hosting service and existing
account needing re-authorization
"""
# We won't be setting the password, so that is_authorized() will
# fail.
account = HostingServiceAccount.objects.create(username='******',
service_name='test')
form = RepositoryForm({
'name': 'test',
'hosting_type': 'test',
'hosting_account': account.pk,
'tool': self.git_tool_id,
'test_repo_name': 'testrepo',
'bug_tracker_type': 'none',
})
self.assertFalse(form.is_valid())
self.assertFalse(form.hosting_account_linked)
self.assertEqual(
set(form.errors.keys()),
set(['hosting_account_username', 'hosting_account_password']))
def test_with_hosting_service_self_hosted_bug_tracker_service(self):
"""Testing RepositoryForm with a self-hosted bug tracker service"""
account = HostingServiceAccount.objects.create(
username='******',
service_name='self_hosted_test',
hosting_url='https://example.com')
account.data['password'] = '******'
account.save()
form = RepositoryForm({
'name': 'test',
'hosting_type': 'self_hosted_test',
'hosting_url': 'https://example.com',
'hosting_account': account.pk,
'tool': self.git_tool_id,
'test_repo_name': 'testrepo',
'bug_tracker_type': 'self_hosted_test',
'bug_tracker_hosting_url': 'https://example.com',
'bug_tracker-test_repo_name': 'testrepo',
})
form.validate_repository = False
self.assertTrue(form.is_valid())
repository = form.save()
self.assertFalse(repository.extra_data['bug_tracker_use_hosting'])
self.assertEqual(repository.bug_tracker,
'https://example.com/testrepo/issue/%s')
self.assertEqual(repository.extra_data['bug_tracker_type'],
'self_hosted_test')
self.assertEqual(
repository.extra_data['bug_tracker-test_repo_name'],
'testrepo')
self.assertEqual(
repository.extra_data['bug_tracker_hosting_url'],
'https://example.com')
