def setUp(self):
super(GitTests, self).setUp()
tool = Tool.objects.get(name='Git')
self.local_repo_path = os.path.join(os.path.dirname(__file__), '..',
'testdata', 'git_repo')
self.git_ssh_path = ('localhost:%s' %
self.local_repo_path.replace('\\', '/'))
remote_repo_path = '[email protected]:reviewboard/reviewboard.git'
remote_repo_raw_url = ('http://github.com/api/v2/yaml/blob/show/'
'reviewboard/reviewboard/<revision>')
self.repository = Repository(name='Git test repo',
path=self.local_repo_path,
tool=tool)
self.remote_repository = Repository(name='Remote Git test repo',
path=remote_repo_path,
raw_file_url=remote_repo_raw_url,
tool=tool)
try:
self.tool = self.repository.get_scmtool()
self.remote_tool = self.remote_repository.get_scmtool()
except ImportError:
raise nose.SkipTest('git binary not found')
def _test_get_file(self, tool_name, revision, base_commit_id,
expected_revision):
def _http_get(service, url, *args, **kwargs):
self.assertEqual(
url,
'https://bitbucket.org/api/1.0/repositories/'
'myuser/myrepo/raw/%s/path'
% expected_revision)
return b'My data', {}
account = self._get_hosting_account()
service = account.service
repository = Repository(hosting_account=account,
tool=Tool.objects.get(name=tool_name))
repository.extra_data = {
'bitbucket_repo_name': 'myrepo',
}
account.data['password'] = encrypt_password('abc123')
self.spy_on(service.client.http_get, call_fake=_http_get)
result = service.get_file(repository, 'path', revision,
base_commit_id)
self.assertTrue(service.client.http_get.called)
self.assertEqual(result, 'My data')
def _test_get_file_exists(self, tool_name, expect_git_blob_url=False,
file_exists=True):
def _http_get(service, url, *args, **kwargs):
if expect_git_blob_url:
self.assertEqual(
url,
'https://api3.codebasehq.com/myproj/myrepo/blob/123')
else:
self.assertEqual(
url,
'https://api3.codebasehq.com/myproj/myrepo/blob/123/'
'myfile')
if file_exists:
return b'{}', {}
else:
raise HTTPError(url, 404, '', {}, StringIO())
account = self._get_hosting_account()
service = account.service
repository = Repository(hosting_account=account,
tool=Tool.objects.get(name=tool_name))
repository.extra_data = {
'codebasehq_project_name': 'myproj',
'codebasehq_repo_name': 'myrepo',
}
self._authorize(service)
self.spy_on(service.client.http_get, call_fake=_http_get)
result = service.get_file_exists(repository, 'myfile', '123')
self.assertTrue(service.client.http_get.called)
self.assertEqual(result, file_exists)
def _test_get_file_exists(self, tool_name, revision, base_commit_id,
expected_revision, expected_found,
expected_http_called=True):
def _http_get(service, url, *args, **kwargs):
self.assertEqual(
url,
'https://bitbucket.org/api/1.0/repositories/'
'myuser/myrepo/raw/%s/path'
% expected_revision)
if expected_found:
return b'{}', {}
else:
error = HTTPError(url, 404, 'Not Found', {}, None)
error.read = lambda: error.msg
raise error
account = self._get_hosting_account()
service = account.service
repository = Repository(hosting_account=account,
tool=Tool.objects.get(name=tool_name))
repository.extra_data = {
'bitbucket_repo_name': 'myrepo',
}
account.data['password'] = encrypt_password('abc123')
self.spy_on(service.client.http_get, call_fake=_http_get)
result = service.get_file_exists(repository, 'path', revision,
base_commit_id)
self.assertEqual(service.client.http_get.called, expected_http_called)
self.assertEqual(result, expected_found)
def _test_get_file_exists(self, tool_name, revision, base_commit_id,
expected_revision, expected_found,
expected_http_called=True):
def _http_get(service, url, *args, **kwargs):
self.assertEqual(
url,
'https://bitbucket.org/api/1.0/repositories/'
'myuser/myrepo/raw/%s/path'
% expected_revision)
if expected_found:
return '{}', {}
else:
raise HTTPError()
account = self._get_hosting_account()
service = account.service
repository = Repository(hosting_account=account,
tool=Tool.objects.get(name=tool_name))
repository.extra_data = {
'bitbucket_repo_name': 'myrepo',
}
service.authorize('myuser', 'abc123', None)
self.spy_on(service._http_get, call_fake=_http_get)
result = service.get_file_exists(repository, 'path', revision,
base_commit_id)
self.assertEqual(service._http_get.called, expected_http_called)
self.assertEqual(result, expected_found)
def setUp(self):
super(PerforceStunnelTests, self).setUp()
if not is_exe_in_path('stunnel'):
raise nose.SkipTest('stunnel is not installed')
cert = os.path.join(os.path.dirname(__file__),
'..', 'testdata', 'stunnel.pem')
self.proxy = STunnelProxy('public.perforce.com:1666')
self.proxy.start_server(cert)
# Find an available port to listen on
path = 'stunnel:localhost:%d' % self.proxy.port
self.repository = Repository(name='Perforce.com - secure',
path=path,
username='******',
encoding='none',
tool=Tool.objects.get(name='Perforce'))
try:
self.tool = self.repository.get_scmtool()
self.tool.use_stunnel = True
except ImportError:
raise nose.SkipTest('perforce/p4python is not installed')
def test_check_repository_subversion(self):
"""Testing Assembla.check_repository with Subversion"""
try:
account = self.create_hosting_account()
service = account.service
service.authorize('myuser', 'abc123', None)
repository = Repository(path='https://svn.example.com/',
hosting_account=account,
tool=Tool.objects.get(name='Subversion'))
scmtool = repository.get_scmtool()
self.spy_on(scmtool.check_repository, call_original=False)
service.check_repository(path='https://svn.example.com/',
username='******',
password='******',
scmtool_class=scmtool.__class__,
local_site_name=None)
self.assertTrue(scmtool.check_repository.called)
self.assertNotIn('p4_host',
scmtool.check_repository.last_call.kwargs)
except ImportError:
self.skipTest('Perforce support is not installed')
def test_is_ssh_key_associated(self):
"""Testing that GitHub associated SSH keys are correctly identified"""
associated_key = 'good_key'
unassociated_key = 'bad_key'
keys = simplejson.dumps([{
'key': 'neutral_key'
}, {
'key': associated_key
}])
def _http_get(self, *args, **kwargs):
return keys, None
self.service_class._http_get = _http_get
self.service_class._format_public_key = lambda self, key: key
account = self._get_hosting_account()
account.data['authorization'] = {'token': 'abc123'}
service = account.service
repository = Repository(hosting_account=account)
repository.extra_data = {
'repository_plan': 'public',
'github_public_repo_name': 'myrepo',
}
self.assertTrue(
service.is_ssh_key_associated(repository, associated_key))
self.assertFalse(
service.is_ssh_key_associated(repository, unassociated_key))
self.assertFalse(service.is_ssh_key_associated(repository, None))
def test_save_form_perforce_with_portfolio(self):
"""Testing Assembla configuration form with Perforce with Assembla
portfolio IDs
"""
try:
account = self._get_hosting_account()
service = account.service
service.authorize('myuser', 'abc123', None)
repository = Repository(hosting_account=account,
tool=Tool.objects.get(name='Perforce'))
form = self._get_form(
fields={
'assembla_project_id': 'myportfolio/myproject',
})
self.spy_on(get_hostname, call_fake=lambda: 'myhost.example.com')
form.save(repository)
self.assertIn('use_ticket_auth', repository.extra_data)
self.assertTrue(repository.extra_data['use_ticket_auth'])
self.assertIn('p4_host', repository.extra_data)
self.assertIn('p4_client', repository.extra_data)
self.assertEqual(repository.extra_data['p4_host'],
'myportfolio/myproject')
self.assertEqual(repository.extra_data['p4_client'],
'myhost.example.com-myportfolio-myproject')
except ImportError:
raise nose.SkipTest
def test_associate_ssh_key(self):
"""Testing that GitHub SSH key association sends expected data"""
http_post_data = {}
def _http_post(self, *args, **kwargs):
http_post_data['args'] = args
http_post_data['kwargs'] = kwargs
return None, None
self.service_class._http_post = _http_post
self.service_class._format_public_key = lambda self, key: key
account = self._get_hosting_account()
account.data['authorization'] = {'token': 'abc123'}
repository = Repository(hosting_account=account)
repository.extra_data = {
'repository_plan': 'public',
'github_public_repo_name': 'myrepo',
}
service = account.service
service.associate_ssh_key(repository, 'mykey')
req_body = simplejson.loads(http_post_data['kwargs']['body'])
expected_title = ('Review Board (%s)' %
Site.objects.get_current().domain)
self.assertEqual(
http_post_data['args'][0],
'https://api.github.com/repos/myuser/myrepo/keys?'
'access_token=abc123')
self.assertEqual(http_post_data['kwargs']['content_type'],
'application/json')
self.assertEqual(req_body['title'], expected_title)
self.assertEqual(req_body['key'], 'mykey')
def _test_get_file(self, tool_name, revision, base_commit_id,
expected_revision):
def _http_get(service, url, *args, **kwargs):
if tool_name == 'Git':
self.assertEqual(
url, 'https://mydomain.beanstalkapp.com/api/repositories/'
'myrepo/blob?id=%s&name=path' % expected_revision)
payload = b'My data'
else:
self.assertEqual(
url, 'https://mydomain.beanstalkapp.com/api/repositories/'
'myrepo/node.json?path=/path&revision=%s&contents=1' %
expected_revision)
payload = b'{"contents": "My data"}'
return payload, {}
account = self._get_hosting_account()
service = account.service
repository = Repository(hosting_account=account,
tool=Tool.objects.get(name=tool_name))
repository.extra_data = {
'beanstalk_account_domain': 'mydomain',
'beanstalk_repo_name': 'myrepo',
}
service.authorize('myuser', 'abc123', None)
self.spy_on(service.client.http_get, call_fake=_http_get)
result = service.get_file(repository, '/path', revision,
base_commit_id)
self.assertTrue(service.client.http_get.called)
self.assertEqual(result, 'My data')
def test_ticket_login_with_local_site(self):
"""Testing Perforce with ticket-based logins with Local Sites"""
repo = Repository(
name='Perforce.com',
path='public.perforce.com:1666',
tool=Tool.objects.get(name='Perforce'),
username='******',
password='******',
local_site=LocalSite.objects.get(name='local-site-1'))
repo.extra_data = {
'use_ticket_auth': True,
}
client = repo.get_scmtool().client
self.assertTrue(client.use_ticket_auth)
self.spy_on(client.get_ticket_status, call_fake=lambda *args: {
'user': '******',
'expiration_secs': 100000,
})
self.spy_on(client.login, call_original=False)
with client.connect():
self.assertFalse(client.login.called)
self.assertEqual(client.p4.ticket_file,
os.path.join(settings.SITE_DATA_DIR, 'p4',
'local-site-1', 'p4tickets'))
def test_check_repository_perforce(self):
"""Testing Assembla.check_repository with Perforce"""
try:
account = self.create_hosting_account()
service = account.service
service.authorize('myuser', 'abc123', None)
repository = Repository(hosting_account=account,
tool=Tool.objects.get(name='Perforce'))
scmtool = repository.get_scmtool()
self.spy_on(scmtool.check_repository, call_original=False)
service.check_repository(path='mypath',
username='******',
password='******',
scmtool_class=scmtool.__class__,
local_site_name=None,
assembla_project_id='myproject')
self.assertTrue(scmtool.check_repository.called)
self.assertIn('p4_host', scmtool.check_repository.last_call.kwargs)
self.assertEqual(
scmtool.check_repository.last_call.kwargs['p4_host'],
'myproject')
except ImportError:
self.skipTest('Perforce support is not installed')
def test_get_branches(self):
"""Testing GitHub get_branches implementation"""
branches_api_response = json.dumps([
{
'ref': 'refs/heads/master',
'object': {
'sha': '859d4e148ce3ce60bbda6622cdbe5c2c2f8d9817',
}
},
{
'ref': 'refs/heads/release-1.7.x',
'object': {
'sha': '92463764015ef463b4b6d1a1825fee7aeec8cb15',
}
},
{
'ref': 'refs/heads/some-component/fix',
'object': {
'sha': '764015ef492c8cb1546363b45fee7ab6d1a182ee',
}
},
{
'ref': 'refs/tags/release-1.7.11',
'object': {
'sha': 'f5a35f1d8a8dcefb336a8e3211334f1f50ea7792',
}
},
])
def _http_get(self, *args, **kwargs):
return branches_api_response, None
account = self._get_hosting_account()
account.data['authorization'] = {'token': 'abc123'}
repository = Repository(hosting_account=account)
repository.extra_data = {
'repository_plan': 'public',
'github_public_repo_name': 'myrepo',
}
service = account.service
self.spy_on(service.client.http_get, call_fake=_http_get)
branches = service.get_branches(repository)
self.assertTrue(service.client.http_get.called)
self.assertEqual(len(branches), 3)
self.assertEqual(branches, [
Branch(id='master',
commit='859d4e148ce3ce60bbda6622cdbe5c2c2f8d9817',
default=True),
Branch(id='release-1.7.x',
commit='92463764015ef463b4b6d1a1825fee7aeec8cb15',
default=False),
Branch(id='some-component/fix',
commit='764015ef492c8cb1546363b45fee7ab6d1a182ee',
default=False),
])
def test_get_branches(self):
"""Testing GitLab get_branches implementation"""
branches_api_response = json.dumps([
{
'name': 'master',
'commit': {
'id': 'ed899a2f4b50b4370feeea94676502b42383c746'
}
},
{
'name': 'branch1',
'commit': {
'id': '6104942438c14ec7bd21c6cd5bd995272b3faff6'
}
},
{
'name': 'branch2',
'commit': {
'id': '21b3bcabcff2ab3dc3c9caa172f783aad602c0b0'
}
},
{
'branch-name': 'branch3',
'commit': {
'id': 'd5a3ff139356ce33e37e73add446f16869741b50'
}
}
])
def _http_get(self, *args, **kwargs):
return branches_api_response, None
account = self._get_hosting_account(use_url=True)
account.data['private_token'] = encrypt_password('abc123')
service = account.service
repository = Repository(hosting_account=account)
repository.extra_data = {'gitlab_project_id': 123456}
self.spy_on(service.client.http_get, call_fake=_http_get)
branches = service.get_branches(repository)
self.assertTrue(service.client.http_get.called)
self.assertEqual(len(branches), 3)
self.assertEqual(
branches,
[
Branch(id='master',
commit='ed899a2f4b50b4370feeea94676502b42383c746',
default=True),
Branch(id='branch1',
commit='6104942438c14ec7bd21c6cd5bd995272b3faff6',
default=False),
Branch(id='branch2',
commit='21b3bcabcff2ab3dc3c9caa172f783aad602c0b0',
default=False)
])
def test_get_commits(self):
"""Testing ReviewBoardGateway get_commits implementation"""
commits_api_response = json.dumps([{
'author':
'myname',
'id':
'bfdde95432b3af879af969bd2377dc3e55ee46e6',
'date':
'2015-02-13 22:34:01 -0700 -0700',
'message':
'mymessage',
'parent_id':
'304c53c163aedfd0c0e0933776f09c24b87f5944',
}, {
'author':
'myname',
'id':
'304c53c163aedfd0c0e0933776f09c24b87f5944',
'date':
'2015-02-13 22:32:42 -0700 -0700',
'message':
'mymessage',
'parent_id':
'fa1330719893098ae397356e8125c2aa45b49221',
}, {
'author': 'anothername',
'id': 'fa1330719893098ae397356e8125c2aa45b49221',
'date': '2015-02-12 16:01:48 -0700 -0700',
'message': 'mymessage',
'parent_id': '',
}])
def _http_get(self, *args, **kwargs):
return commits_api_response, None
account = self._get_hosting_account()
account.data['private_token'] = encrypt_password('abc123')
repository = Repository(hosting_account=account)
repository.extra_data = {
'rbgateway_repo_name': 'myrepo',
}
service = account.service
self.spy_on(service.client.http_get, call_fake=_http_get)
commits = service.get_commits(
repository, branch='bfdde95432b3af879af969bd2377dc3e55ee46e6')
self.assertTrue(service.client.http_get.called)
self.assertEqual(len(commits), 3)
self.assertEqual(commits[0].parent, commits[1].id)
self.assertEqual(commits[1].parent, commits[2].id)
self.assertEqual(commits[0].date, '2015-02-13 22:34:01 -0700 -0700')
self.assertEqual(commits[1].id,
'304c53c163aedfd0c0e0933776f09c24b87f5944')
self.assertEqual(commits[2].author_name, 'anothername')
self.assertEqual(commits[2].parent, '')
def setUp(self):
super(PerforceTests, self).setUp()
self.repository = Repository(name='Perforce.com',
path='public.perforce.com:1666',
username='******',
encoding='none',
tool=Tool.objects.get(name='Perforce'))
def setUp(self):
self.repository = Repository(name='Perforce.com',
path='public.perforce.com:1666',
tool=Tool.objects.get(name='Perforce'))
try:
self.tool = self.repository.get_scmtool()
except ImportError:
raise nose.SkipTest('perforce/p4python is not installed')
def test_get_commits(self):
"""Testing GitLab get_commits implementation"""
commits_api_response = json.dumps([{
'id':
'ed899a2f4b50b4370feeea94676502b42383c746',
'author_name':
'Chester Li',
'created_at':
'2015-03-10T11:50:22+03:00',
'message':
'Replace sanitize with escape once'
}, {
'id':
'6104942438c14ec7bd21c6cd5bd995272b3faff6',
'author_name':
'Chester Li',
'created_at':
'2015-03-10T09:06:12+03:00',
'message':
'Sanitize for network graph'
}, {
'id':
'21b3bcabcff2ab3dc3c9caa172f783aad602c0b0',
'author_name':
'East Coast',
'created_at':
'2015-03-04T15:31:18.000-04:00',
'message':
'Add a timer to test file'
}])
def _http_get(self, *args, **kargs):
return commits_api_response, None
account = self._get_hosting_account(use_url=True)
account.data['private_token'] = encrypt_password('abc123')
service = account.service
repository = Repository(hosting_account=account)
repository.extra_data = {'gitlab_project_id': 123456}
self.spy_on(service.client.http_get, call_fake=_http_get)
commits = service.get_commits(
repository, start='ed899a2f4b50b4370feeea94676502b42383c746')
self.assertTrue(service.client.http_get.called)
self.assertEqual(len(commits), 3)
self.assertEqual(commits[0].id,
'ed899a2f4b50b4370feeea94676502b42383c746')
self.assertNotEqual(commits[0].author_name, 'East Coast')
self.assertEqual(commits[1].date, '2015-03-10T09:06:12+03:00')
self.assertNotEqual(commits[1].message,
'Replace sanitize with escape once')
self.assertEqual(commits[2].author_name, 'East Coast')
def test_bad_root(self):
"""Testing CVSTool with a bad CVSROOT"""
file = 'test/testfile'
rev = Revision('1.1')
badrepo = Repository(name='CVS',
path=self.cvs_repo_path + '2',
tool=Tool.objects.get(name='CVS'))
badtool = badrepo.get_scmtool()
self.assertRaises(SCMError, lambda: badtool.get_file(file, rev))
def test_changeset_broken(self):
"""Testing PerforceTool.get_changeset error conditions"""
repo = Repository(name='Perforce.com',
path='public.perforce.com:1666',
tool=Tool.objects.get(name='Perforce'),
username='******',
password='******',
encoding='none')
tool = repo.get_scmtool()
self.assertRaises(AuthenticationError, lambda: tool.get_changeset(157))
repo = Repository(name='localhost:1',
path='localhost:1',
tool=Tool.objects.get(name='Perforce'))
tool = repo.get_scmtool()
self.assertRaises(RepositoryNotFoundError,
lambda: tool.get_changeset(1))
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 setUp(self):
svn_repo_path = os.path.join(os.path.dirname(__file__),
'testdata/svn_repo')
self.repository = Repository(name='Subversion SVN',
path='file://' + svn_repo_path,
tool=Tool.objects.get(name='Subversion'))
try:
self.tool = self.repository.get_scmtool()
except ImportError:
raise nose.SkipTest('pysvn is not installed')
def test_https_repo(self):
"""Testing HgTool.file_exists with an HTTPS-based repository"""
repo = Repository(name='Test HG2',
path='https://bitbucket.org/pypy/pypy',
tool=Tool.objects.get(name='Mercurial'))
tool = repo.get_scmtool()
rev = Revision('877cf1960916')
self.assertTrue(tool.file_exists('TODO.rst', rev))
self.assertTrue(not tool.file_exists('TODO.rstNotFound', rev))
def setUp(self):
hg_repo_path = os.path.join(os.path.dirname(__file__),
'testdata/hg_repo.bundle')
self.repository = Repository(name='Test HG',
path=hg_repo_path,
tool=Tool.objects.get(name='Mercurial'))
try:
self.tool = self.repository.get_scmtool()
except ImportError:
raise nose.SkipTest('Hg is not installed')
def setUp(self):
self.cvs_repo_path = os.path.join(os.path.dirname(__file__),
'testdata/cvs_repo')
self.repository = Repository(name='CVS',
path=self.cvs_repo_path,
tool=Tool.objects.get(name='CVS'))
try:
self.tool = self.repository.get_scmtool()
except ImportError:
raise nose.SkipTest('cvs binary not found')
def testPathWithoutPort(self):
"""Testing parsing a CVSROOT without a port"""
repo = Repository(name="CVS",
path="example.com:/cvsroot/test",
username="******",
tool=Tool.objects.get(name="CVS"))
tool = repo.get_scmtool()
self.assertEqual(tool.repopath, "/cvsroot/test")
self.assertEqual(tool.client.repository,
":pserver:[email protected]:/cvsroot/test")
def test_custom_host(self):
"""Testing Perforce client initialization with a custom P4HOST"""
repo = Repository(name='Perforce.com',
path='public.perforce.com:1666',
tool=Tool.objects.get(name='Perforce'),
encoding='utf8')
repo.extra_data['p4_host'] = 'my-custom-host'
tool = repo.get_scmtool()
with tool.client._connect():
self.assertEqual(tool.client.p4.host, 'my-custom-host')
def _get_repo_api_url(self, plan, fields):
account = self._get_hosting_account()
service = account.service
self.assertNotEqual(service, None)
repository = Repository(hosting_account=account)
repository.extra_data['repository_plan'] = plan
form = self._get_form(plan, fields)
form.save(repository)
return service._get_repo_api_url(repository)
def test_clean_with_path_conflict_with_archived(self):
"""Testing Repository.clean with archived repositories ignored for
path conflict
"""
self.repository.archive()
repository = Repository(name='New test repo',
path=self.repository.path,
tool=self.repository.tool)
with self.assertNumQueries(1):
repository.clean()
