def test_get_file_http_with_username(self):
"""Testing SCMClient.get_file_http with username"""
self.spy_on(urlopen, op=kgb.SpyOpReturn(GetFileHTTPResponse()))
client = SCMClient(path='/path/to/repo',
username='******',
password='******')
self.assertEqual(
client.get_file_http('https://example.com',
path='/path/to/file',
revision='abc123'), b'abc')
request = urlopen.last_call.args[0]
self.assertEqual(request.headers[str('Authorization')],
str('Basic dGVzdC11c2VyOnRlc3QtcGFzcw=='))
def test_find_matching_server_repository_with_uuid_match(self):
"""Testing SVNClient.find_matching_server_repository with UUID
match
"""
url = 'svn+ssh://blargle/'
self.options.repository_url = url
client = SVNClient(options=self.options)
self.spy_on(client.svn_info,
op=kgb.SpyOpReturn({
'Repository UUID': 'UUID-3',
}))
repository, info = get_repository_resource(self.root_resource,
tool=client,
repository_paths=url)
self.assertEqual(repository.id, 3)
def test_get_or_create_user_not_in_ldap(self):
"""Testing LDAPBackend.get_or_create_user with new user not found in
LDAP
"""
self.spy_on(TestLDAPObject.search_s,
owner=TestLDAPObject,
op=kgb.SpyOpReturn([]))
self.assertEqual(User.objects.count(), 0)
user = self.backend.get_or_create_user(username='******', request=None)
self.assertIsNone(user)
self.assertEqual(User.objects.count(), 0)
self.assertSpyCalledWith(TestLDAPObject.search_s,
'CN=admin,DC=example,DC=com',
ldap.SCOPE_SUBTREE, '(uid=doc)')
def test_get_file_with_context(self):
"""Testing Repository.get_file with context="""
repository = self.repository
scmtool_cls = repository.scmtool_class
self.spy_on(scmtool_cls.get_file,
owner=scmtool_cls,
op=kgb.SpyOpReturn(b'data'))
context = FileLookupContext(base_commit_id='def456')
repository.get_file(path='readme', revision='abc123', context=context)
self.assertSpyCalledWith(scmtool_cls.get_file,
'readme',
revision='abc123',
base_commit_id='def456',
context=context)
def test_post_with_hosting_service_and_bug_tracker_use_hosting(self):
"""Testing the POST repositories/ API with hosting service and
bug_tracker_use_hosting
"""
account = HostingServiceAccount.objects.create(
username='******',
service_name='github')
self.spy_on(GitHub.is_authorized,
owner=GitHub,
op=kgb.SpyOpReturn(True))
self.spy_on(GitHub.check_repository,
owner=GitHub,
call_original=False)
rsp = self._post_repository({
'bug_tracker_use_hosting': True,
'github_public_org_name': 'myorg',
'github_public_org_repo_name': 'myrepo',
'hosting_account_username': '******',
'hosting_type': 'github',
'repository_plan': 'public-org',
'tool': 'Git',
})
self._verify_repository_info(
rsp=rsp,
expected_tool_id='git',
expected_attrs={
'bug_tracker':
'http://github.com/myorg/myrepo/issues#issue/%s',
'extra_data': {
'bug_tracker_use_hosting': True,
'github_public_org_name': 'myorg',
'github_public_org_repo_name': 'myrepo',
'repository_plan': 'public-org',
},
'hosting_account': account,
'mirror_path': '[email protected]:myorg/myrepo.git',
'path': 'git://github.com/myorg/myrepo.git',
})
self.assertSpyCalled(GitHub.is_authorized)
self.assertSpyCalled(GitHub.check_repository)
def test_create_from_data_with_committer_date_none(self):
"""Testing DiffCommitManager.create_from_data with committer_date=None
"""
# committer_date is a property that sets a couple of fields based on
# the provided date. If this crashes (which was an issue initially with
# the implementation when passing in None), construction will fail
# with:
#
# TypeError: 'committer_date' is an invalid keyword argument for
# this function
repository = self.create_repository(tool_name='Test')
self.spy_on(repository.get_file_exists, op=kgb.SpyOpReturn(True))
diffset = DiffSet.objects.create_empty(repository=repository,
basedir='',
revision=1)
commit = DiffCommit.objects.create_from_data(
repository=repository,
diff_file_name='diff',
diff_file_contents=self.commit_test_diff,
parent_diff_file_name=None,
parent_diff_file_contents=b'',
request=None,
commit_id='r1',
parent_id='r0',
author_name='Author',
author_email='*****@*****.**',
author_date=parse_date('2000-01-01 00:00:00-0600'),
committer_name='Committer',
committer_email='*****@*****.**',
committer_date=None,
commit_message='Description',
diffset=diffset,
validation_info={})
self.assertEqual(commit.files.count(), 1)
self.assertEqual(diffset.files.count(), commit.files.count())
self.assertEqual(diffset.commit_count, 1)
self.assertIsNone(commit.committer_date)
self.assertIsNone(commit.committer_date_utc)
self.assertIsNone(commit.committer_date_offset)
def _test_hook_approval_sequence(self, accessible_values, result):
"""Test a sequence of FileDiffACLHook approval results.
Args:
accessible_values (list of bool):
A list of the values to return from FileDiffACLHook
implementations.
result (bool):
A resulting approval value to check.
"""
with override_feature_check(DiffACLsFeature.feature_id,
enabled=True):
for value in accessible_values:
hook = FileDiffACLHook(extension=self.extension)
self.spy_on(hook.is_accessible, op=kgb.SpyOpReturn(value))
self.assertEqual(self.review_request.is_accessible_by(self.user),
result)
def test_post_with_unknown_cert_and_trust_host(self):
"""Testing the POST repositories/ API with Unknown Certificate error
and trust_host=1
"""
class Certificate(object):
failures = ['failures']
fingerprint = 'fingerprint'
hostname = 'example.com'
issuer = 'issuer'
valid_from = 'valid_from'
valid_until = 'valid_until'
cert = Certificate()
@self.spy_for(TestTool.check_repository, owner=TestTool)
def _check_repository(cls, *args, **kwargs):
if not TestTool.accept_certificate.called:
raise UnverifiedCertificateError(cert)
self.spy_on(
TestTool.accept_certificate,
owner=TestTool,
op=kgb.SpyOpReturn({
'fingerprint': '123',
}))
rsp = self._post_repository({
'trust_host': 1,
})
self._verify_repository_info(
rsp=rsp,
expected_attrs={
'extra_data': {
'cert': {
'fingerprint': '123',
},
},
})
self.assertSpyCalled(TestTool.accept_certificate)
def _check_upgrade_settings(self, stored_settings, stored_settings_text,
expected_settings_text):
"""Check that upgrading settings produces the expected results.
Args:
stored_settings (dict):
A dictionary of settings that would be stored in
:file:`settings_local.py`.
stored_settings_text (unicode):
The content of the :file:`settings_local.py` file to write
and upgrade.
expected_settings_text (unicode):
The content of just the settings, without any blank lines
or comments.
Raises:
AssertionError:
An expectation failed.
"""
class SettingsLocal(object):
pass
for key, value in six.iteritems(stored_settings):
setattr(SettingsLocal, key, value)
site = Site(install_dir=self.sitedir2,
options={})
self.spy_on(site.get_settings_local,
op=kgb.SpyOpReturn(SettingsLocal))
with open(os.path.join(site.abs_install_dir, 'conf',
'settings_local.py'),
'w') as fp:
fp.write(stored_settings_text)
site.upgrade_settings()
self._check_settings_local(site.abs_install_dir,
expected_settings_text)
def test_post_with_hosting_service_and_invalid_username(self):
"""Testing the POST <URL> API with hosting service and invalid
hosting_account_username
"""
self.spy_on(GitHub.is_authorized,
owner=GitHub,
op=kgb.SpyOpReturn(True))
self.spy_on(GitHub.check_repository,
owner=GitHub,
call_original=False)
rsp = self._post_repository(
{
'bug_tracker_use_hosting': True,
'github_public_org_name': 'myorg',
'github_public_org_repo_name': 'myrepo',
'hosting_account_username': '******',
'hosting_type': 'github',
'repository_plan': 'public-org',
'tool': 'Git',
},
expected_status=400)
self.assertEqual(rsp, {
'err': {
'code': 105,
'msg': 'One or more fields had errors',
},
'fields': {
'hosting_account_username': [
'An existing hosting service account with the username '
'"test-user" could not be found for the hosting '
'service "github".'
],
},
'stat': 'fail',
})
self.assertSpyNotCalled(GitHub.is_authorized)
self.assertSpyNotCalled(GitHub.check_repository)
def test_post_with_hosting_service_and_hosting_url(self):
"""Testing the POST <URL> API with hosting service and hosting_url"""
account = HostingServiceAccount.objects.create(
hosting_url='https://example.com',
username='******',
service_name='gitlab')
self.spy_on(GitLab.is_authorized,
owner=GitLab,
op=kgb.SpyOpReturn(True))
self.spy_on(GitLab.check_repository,
owner=GitLab,
call_original=False)
rsp = self._post_repository({
'gitlab_personal_repo_name': 'myrepo',
'hosting_account_username': '******',
'hosting_type': 'gitlab',
'hosting_url': 'https://example.com',
'repository_plan': 'personal',
'tool': 'Git',
})
self._verify_repository_info(
rsp=rsp,
expected_tool_id='git',
expected_attrs={
'extra_data': {
'bug_tracker_use_hosting': False,
'gitlab_personal_repo_name': 'myrepo',
'hosting_url': 'https://example.com',
'repository_plan': 'personal',
},
'hosting_account': account,
'mirror_path': 'https://example.com/test-user/myrepo.git',
'path': '[email protected]:test-user/myrepo.git',
})
self.assertSpyCalled(GitLab.is_authorized)
self.assertSpyCalled(GitLab.check_repository)
def test_find_domain_controllers_from_dns_with_custom_domain(self):
"""Testing ActiveDirectoryBackend.find_domain_controllers_from_dns
with custom domain
"""
self.spy_on(
dns.resolver.query,
op=kgb.SpyOpReturn(
dns.resolver.Answer(
qname=dns.name.from_text('_ldap._tcp.corp.example.com'),
rdtype=dns.rdatatype.SRV,
rdclass=dns.rdataclass.IN,
response=dns.message.from_text(
'id 12345\n'
'opcode QUERY\n'
'rcode NOERROR\n'
'flags QR RD RA\n'
';QUESTION\n'
'_ldap._tcp.corp.example.com. IN SRV\n'
';ANSWER\n'
'_ldap._tcp.corp.example.com. 299 IN SRV 10 1 389'
' my-ad3.example.com.\n'
'_ldap._tcp.corp.example.com. 299 IN SRV 5 1 390'
' my-ad2.example.com.\n'
'_ldap._tcp.corp.example.com. 299 IN SRV 5 5 391'
' my-ad1.example.com.\n'
';AUTHORITY\n'
';ADDITIONAL\n'))))
self.assertEqual(
self.backend.find_domain_controllers_from_dns('corp.example.com'),
[
(391, 'my-ad1.example.com'),
(390, 'my-ad2.example.com'),
(389, 'my-ad3.example.com'),
])
self.assertSpyCalledWith(dns.resolver.query,
'_ldap._tcp.corp.example.com',
rdtype='SRV')
def test_authenticate_with_invalid_credentials(self):
"""Testing LDAPBackend.authenticate with invalid credentials"""
self.spy_on(TestLDAPObject.bind_s,
owner=TestLDAPObject,
op=kgb.SpyOpRaise(ldap.INVALID_CREDENTIALS()))
self.spy_on(TestLDAPObject.search_s,
owner=TestLDAPObject,
op=kgb.SpyOpReturn([
('CN=Doc Dwarf,OU=MyOrg,DC=example,DC=COM', {}),
]))
user = self.backend.authenticate(request=None,
username='******',
password='******')
self.assertIsNone(user)
self.assertSpyCalledWith(TestLDAPObject.bind_s,
'CN=Doc Dwarf,OU=MyOrg,DC=example,DC=COM',
'mypass')
self.assertSpyCalledWith(TestLDAPObject.search_s,
'CN=admin,DC=example,DC=com',
ldap.SCOPE_SUBTREE, '(uid=doc)')
def test_authenticate_with_exception(self):
"""Testing LDAPBackend.authenticate with unexpected exception"""
self.spy_on(TestLDAPObject.bind_s,
owner=TestLDAPObject,
op=kgb.SpyOpRaise(Exception('oh no!')))
self.spy_on(TestLDAPObject.search_s,
owner=TestLDAPObject,
op=kgb.SpyOpReturn([
('CN=Doc Dwarf,OU=MyOrg,DC=example,DC=COM', {}),
]))
user = self.backend.authenticate(request=None,
username='******',
password='******')
self.assertIsNone(user)
self.assertSpyCalledWith(TestLDAPObject.bind_s,
'CN=Doc Dwarf,OU=MyOrg,DC=example,DC=COM',
'mypass')
self.assertSpyCalledWith(TestLDAPObject.search_s,
'CN=admin,DC=example,DC=com',
ldap.SCOPE_SUBTREE, '(uid=doc)')
def _get_settings_upgrade_needed(self, stored_settings):
"""Return Site.get_settings_upgrade_needed with the provided settings.
Args:
stored_settings (dict):
A dictionary of settings that would be stored in
:file:`settings_local.py`.
Returns:
bool:
The result of :py:class:`~reviewboard.cmdline.rbsite.Site.
get_settings_upgrade_needed`.
"""
class SettingsLocal(object):
pass
for key, value in six.iteritems(stored_settings):
setattr(SettingsLocal, key, value)
site = Site(install_dir=self.sitedir2, options={})
self.spy_on(site.get_settings_local, op=kgb.SpyOpReturn(SettingsLocal))
return site.get_settings_upgrade_needed()
def test_sends_404_when_no_patch_error(self):
"""Testing DownloadPatchErrorBundleView returns 404 when
no patch error is raised by the renderer.
"""
review_request = self.create_review_request(publish=True,
create_repository=True)
diffset = self.create_diffset(review_request=review_request)
self.create_diffcommit(diffset=diffset)
filediff_id = diffset.files.all()[0].pk
# This does not raise a PatchError, so there is no patch error bundle.
self.spy_on(DiffRenderer.render_to_response,
op=kgb.SpyOpReturn(HttpResponse()))
response = self.client.get(
local_site_reverse('patch-error-bundle',
kwargs={
'review_request_id': review_request.pk,
'revision': diffset.revision,
'filediff_id': filediff_id,
}))
self.assertEqual(response.status_code, 404)
def test_authenticate_with_valid_credentials_with_at(self):
"""Testing ActiveDirectoryBackend.authenticate with valid credentials
and "@" in username
"""
self.spy_on(TestLDAPObject.simple_bind_s, owner=TestLDAPObject)
self.spy_on(TestLDAPObject.search_s,
owner=TestLDAPObject,
op=kgb.SpyOpReturn([
('CN=Test User,OU=MyOrg,DC=example,DC=com', {
'givenName': [b'Test'],
'sn': [b'User'],
'mail': [b'*****@*****.**'],
}),
]))
user = self.backend.authenticate(request=None,
username='******',
password='******')
self.assertIsNotNone(user)
self.assertIsNotNone(user.pk)
self.assertEqual(user.username, 'test-user')
self.assertEqual(user.first_name, 'Test')
self.assertEqual(user.last_name, 'User')
self.assertEqual(user.email, '*****@*****.**')
self.assertFalse(user.is_staff)
self.assertFalse(user.is_superuser)
self.assertSpyCalledWith(TestLDAPObject.simple_bind_s,
'*****@*****.**', 'test-pass')
self.assertSpyCalledWith(
TestLDAPObject.search_s,
'dc=test,dc=example,dc=com',
filterstr='(&(objectClass=user)(sAMAccountName=test-user))',
scope=ldap.SCOPE_SUBTREE)
def test_create_from_data_custom_parser_extra_data(self):
"""Testing DiffCommitManager.create_from_data with a custom diff parser
that sets extra_data
"""
repository = self.create_repository(tool_name='Test')
class CustomParser(DiffParser):
def parse(self):
result = super(CustomParser, self).parse()
self.parsed_diff.extra_data = {
'key1': 'value1',
}
self.parsed_diff_change.extra_data = {
'key2': 'value2',
}
return result
def parse_diff_header(self, linenum, parsed_file):
parsed_file.extra_data = {
'key3': 'value3',
}
return super(CustomParser,
self).parse_diff_header(linenum, parsed_file)
self.spy_on(repository.get_file_exists, op=kgb.SpyOpReturn(True))
tool = repository.get_scmtool()
self.spy_on(repository.get_scmtool, op=kgb.SpyOpReturn(tool))
self.spy_on(tool.get_parser,
call_fake=lambda repo, diff: CustomParser(diff))
diffset = DiffSet.objects.create_empty(repository=repository,
basedir='',
revision=1)
diffcommit = DiffCommit.objects.create_from_data(
repository=repository,
diff_file_name='diff',
diff_file_contents=self.DEFAULT_FILEDIFF_DATA_DIFF,
parent_diff_file_name=None,
parent_diff_file_contents=b'',
request=None,
commit_id='r1',
parent_id='r0',
author_name='Author',
author_email='*****@*****.**',
author_date=parse_date('2000-01-01 00:00:00-0600'),
committer_name='Committer',
committer_email='*****@*****.**',
committer_date=None,
commit_message='Description',
diffset=diffset,
validation_info={})
# Test against what's in the database.
diffset.refresh_from_db()
diffcommit.refresh_from_db()
self.assertEqual(diffset.extra_data, {
'key1': 'value1',
})
self.assertEqual(diffcommit.extra_data, {
'key2': 'value2',
})
self.assertEqual(diffset.files.count(), 1)
filediff = diffset.files.all()[0]
self.assertEqual(
filediff.extra_data, {
'is_symlink': False,
'key3': 'value3',
'raw_delete_count': 1,
'raw_insert_count': 1,
})
# Check the FileLookupContext passed to get_file_exists.
self.assertSpyCallCount(repository.get_file_exists, 1)
context = repository.get_file_exists.last_call.kwargs.get('context')
self.assertIsNotNone(context)
self.assertEqual(context.diff_extra_data, {
'key1': 'value1',
})
self.assertEqual(context.commit_extra_data, {
'key2': 'value2',
})
self.assertEqual(context.file_extra_data, {
'key3': 'value3',
})
def test_create_from_data_custom_parser_extra_data_and_parent(self):
"""Testing DiffSetManager.create_from_data with a custom diff parser
that sets extra_data and using parent diff
"""
repository = self.create_repository(tool_name='Test')
namespaces = ['main_', 'parent_']
class CustomParser(DiffParser):
def parse(self):
self.namespace = namespaces.pop(0)
result = super(CustomParser, self).parse()
self.parsed_diff.extra_data = {
'%skey1' % self.namespace: 'value1',
}
self.parsed_diff_change.extra_data = {
'%skey2' % self.namespace: 'value2',
}
return result
def parse_diff_header(self, linenum, parsed_file):
parsed_file.extra_data = {
'%skey3' % self.namespace: 'value3',
}
return super(CustomParser,
self).parse_diff_header(linenum, parsed_file)
self.spy_on(repository.get_file_exists, op=kgb.SpyOpReturn(True))
tool = repository.get_scmtool()
self.spy_on(repository.get_scmtool, op=kgb.SpyOpReturn(tool))
self.spy_on(tool.get_parser,
call_fake=lambda repo, diff: CustomParser(diff))
diffset = DiffSet.objects.create_from_data(
repository=repository,
diff_file_name='diff',
diff_file_contents=self.DEFAULT_FILEDIFF_DATA_DIFF,
parent_diff_file_name='parent-diff',
parent_diff_file_contents=self.DEFAULT_FILEDIFF_DATA_DIFF,
basedir='/')
# Test against what's in the database.
diffset.refresh_from_db()
self.assertEqual(
diffset.extra_data, {
'change_extra_data': {
'main_key2': 'value2',
},
'main_key1': 'value1',
'parent_extra_data': {
'change_extra_data': {
'parent_key2': 'value2',
},
'parent_key1': 'value1',
},
})
self.assertEqual(diffset.files.count(), 1)
filediff = diffset.files.all()[0]
self.assertEqual(
filediff.extra_data, {
'__parent_diff_empty': False,
'is_symlink': False,
'main_key3': 'value3',
'parent_extra_data': {
'parent_key3': 'value3',
},
'parent_source_filename': '/README',
'parent_source_revision': 'revision 123',
'raw_delete_count': 1,
'raw_insert_count': 1,
})
# Check the FileLookupContext passed to get_file_exists.
self.assertSpyCallCount(repository.get_file_exists, 1)
context = repository.get_file_exists.last_call.kwargs.get('context')
self.assertIsNotNone(context)
self.assertEqual(context.diff_extra_data, {
'parent_key1': 'value1',
})
self.assertEqual(context.commit_extra_data, {
'parent_key2': 'value2',
})
self.assertEqual(context.file_extra_data, {
'parent_key3': 'value3',
})
