def test_fork_and_watch_project(self):
p6 = CodeDoubanProject.add('project6', owner_id="admin_user",
summary="test", product="fire")
p7 = CodeDoubanProject.add('project7', owner_id="other_user",
summary="test", product="fire")
fork_count = CodeDoubanProject.get_forked_count(p6.id)
p6fork = p6.fork('project6_other_user', 'other_user')
fork_count2 = CodeDoubanProject.get_forked_count(p6.id)
ok_(fork_count2 == fork_count + 1)
ok_(CodeDoubanProject.get_forked_count(p6fork.id) == 0)
p6fork2 = p6fork.fork('project6_fork_other_user', 'other_user')
ok_(CodeDoubanProject.get_forked_count(p6.id) == fork_count + 2)
ok_(CodeDoubanProject.get_forked_count(p6fork.id) == 1)
ok_(CodeDoubanProject.get_forked_count(p6fork2.id) == 0)
watch_count = CodeDoubanProject.get_watched_count(p7.id)
CodeDoubanProject.add_watch(p7.id, 'admin_user')
watch_count2 = CodeDoubanProject.get_watched_count(p7.id)
ok_(watch_count2 == watch_count + 1)
ok_(len(p7.get_watch_users()) == watch_count2)
p6.delete()
p7.delete()
def test_multiple_project_index(self):
skip_test()
for i in range(5):
CodeDoubanProject.add('test%s' % i, 'owner', create_trac=False)
_reposearch.RepoSearch.index_repos()
objs = _reposearch.RepoSearch.query_repo_objs()
assert len(objs) == 5
def test_multiple_project_index(self):
skip_test()
for i in range(5):
CodeDoubanProject.add('test%s' % i, 'owner', create_trac=False)
_reposearch.RepoSearch.index_repos()
objs = _reposearch.RepoSearch.query_repo_objs()
assert len(objs) == 5
def get_temp_project(origin=None, repo_path=BARE_REPO_PATH):
if origin:
prefix_path = get_repo_root()
temp_repo_path = tempfile.mkdtemp(suffix=".git",
prefix="test_",
dir=prefix_path)
project_name = temp_repo_path[len(prefix_path) + 1:][:-4]
project = CodeDoubanProject.add(project_name,
TEMP_PROJECT_OWNER,
TEMP_PROJECT_DESCRIPTION,
fork_from=origin.id,
create_trac=False)
return project
prefix_path = get_repo_root()
temp_repo_path = tempfile.mkdtemp(suffix=".git",
prefix="test_",
dir=prefix_path)
project_name = temp_repo_path[len(prefix_path) + 1:][:-4]
project = CodeDoubanProject.add(project_name, TEMP_PROJECT_OWNER,
TEMP_PROJECT_DESCRIPTION)
shutil.rmtree(temp_repo_path)
repo = Jagare(repo_path)
repo.clone(temp_repo_path, bare=True)
return project
def get_temp_project(origin=None, repo_path=BARE_REPO_PATH):
if origin:
prefix_path = get_repo_root()
temp_repo_path = tempfile.mkdtemp(suffix=".git",
prefix="test_",
dir=prefix_path)
project_name = temp_repo_path[len(prefix_path) + 1:][:-4]
project = CodeDoubanProject.add(project_name,
TEMP_PROJECT_OWNER,
TEMP_PROJECT_DESCRIPTION,
fork_from=origin.id,
create_trac=False)
return project
prefix_path = get_repo_root()
temp_repo_path = tempfile.mkdtemp(suffix=".git",
prefix="test_",
dir=prefix_path)
project_name = temp_repo_path[len(prefix_path) + 1:][:-4]
project = CodeDoubanProject.add(project_name, TEMP_PROJECT_OWNER,
TEMP_PROJECT_DESCRIPTION)
shutil.rmtree(temp_repo_path)
repo = Jagare(repo_path)
repo.clone(temp_repo_path, bare=True)
return project
def test_fork_and_watch_project(self):
p6 = CodeDoubanProject.add('project6',
owner_id="admin_user",
summary="test",
product="fire")
p7 = CodeDoubanProject.add('project7',
owner_id="other_user",
summary="test",
product="fire")
fork_count = CodeDoubanProject.get_forked_count(p6.id)
p6fork = p6.fork('project6_other_user', 'other_user')
fork_count2 = CodeDoubanProject.get_forked_count(p6.id)
ok_(fork_count2 == fork_count + 1)
ok_(CodeDoubanProject.get_forked_count(p6fork.id) == 0)
p6fork2 = p6fork.fork('project6_fork_other_user', 'other_user')
ok_(CodeDoubanProject.get_forked_count(p6.id) == fork_count + 2)
ok_(CodeDoubanProject.get_forked_count(p6fork.id) == 1)
ok_(CodeDoubanProject.get_forked_count(p6fork2.id) == 0)
watch_count = CodeDoubanProject.get_watched_count(p7.id)
CodeDoubanProject.add_watch(p7.id, 'admin_user')
watch_count2 = CodeDoubanProject.get_watched_count(p7.id)
ok_(watch_count2 == watch_count + 1)
ok_(len(p7.get_watch_users()) == watch_count2)
p6.delete()
p7.delete()
def test_multiple_project_index(self):
skip_test()
for i in range(5):
CodeDoubanProject.add(
'test%s' % i, 'owner%s' % i, create_trac=False)
_usersearch.UserSearch.index_users()
objs = _usersearch.UserSearch.query_user_objs()
assert len(objs) == 5
def test_multiple_project_index(self):
skip_test()
for i in range(5):
CodeDoubanProject.add('test%s' % i,
'owner%s' % i,
create_trac=False)
_usersearch.UserSearch.index_users()
objs = _usersearch.UserSearch.query_user_objs()
assert len(objs) == 5
def test_transfer_project(self):
pname1 = 'project6'
pname2 = 'project7'
proj_owner = 'admin_user'
to_user = '******'
p = CodeDoubanProject.add(pname1, owner_id=proj_owner,
summary="test", product="fire")
_ = CodeDoubanProject.add(pname2, owner_id=proj_owner,
summary="test", product="fire")
p.transfer_to(to_user)
p1 = CodeDoubanProject.get_by_name(pname1)
assert p1.owner_id == to_user
p2 = CodeDoubanProject.get_by_name(pname2)
assert p2.owner_id == proj_owner
def test_update_can_push(self):
project_name = "project11"
owner_id = "testuser"
summary = "a summary"
product = "fire"
CodeDoubanProject.add(project_name, owner_id, summary, product)
p = CodeDoubanProject.get_by_name('project11')
assert p.can_push == 1
p.update_can_push(False)
p = CodeDoubanProject.get_by_name('project11')
assert p.can_push == 0
p.update_can_push(True)
p = CodeDoubanProject.get_by_name('project11')
assert p.can_push == 1
def setup_repos(tmpdir, prj_name='test_proj'):
origin_project = CodeDoubanProject.add(prj_name, 1,
create_trac=False)
path = origin_project.git_real_path
with clone(path) as workdir:
with open(os.path.join(workdir, 'origin'), 'w') as f:
f.write(content_a)
fork_project = CodeDoubanProject.add(prj_name + '_fork', 2,
fork_from=origin_project.id,
create_trac=False)
fork_path = fork_project.git_real_path
repo = origin_project
fork_repo = fork_project
return path, repo, fork_path, fork_repo
def test_get_my_projects(self):
project_name = "code"
product_name = "fire"
summary = "test"
owner_id = "xingben"
for i in range(5):
delete_project("%s%d" % (project_name, i))
CodeDoubanProject.add("%s%d" % (project_name, i), owner_id=owner_id, summary=summary, product=product_name)
api_token = self.create_api_token("xingben")
ret = self.app.get(
"/api/user/repos", headers=dict(Authorization="Bearer %s" % api_token.token), status=200
).json
self.assertEquals(len(ret), 5)
self.assertTrue("name" in ret[0])
self.assertTrue("description" in ret[0])
def test_project_meta_dict(self):
project_name = "project3"
owner_id = "testuser"
summary = "a summary"
product = "fire"
project = CodeDoubanProject.add(project_name, owner_id, summary,
product)
# hookfile_path = "%s/hooks/post-receive" % project.git_real_path
project = CodeDoubanProject.get_by_name(project_name)
data = {
'url': "%s/%s" % (DOMAIN, project_name),
'name': project_name,
'description': summary,
'product': product,
'committers_count': 0,
'forked_count': 0,
'open_issues_count': 0,
'open_tickets_count': 0,
'watched_count': 0,
'owner': {
'name': owner_id,
'avatar': gravatar_url(owner_id + '@douban.com'),
},
}
commits = project.git.get_revisions("HEAD~1", "HEAD")
if commits:
data['last_commit'] = commits[0]
ok_(project.get_info() == data)
project.delete()
def setup_repos(tmpdir, prj_name='test_proj'):
delete_project(prj_name)
origin_project = CodeDoubanProject.add(prj_name, 1, create_trac=False)
path = origin_project.git_real_path
with clone(path) as workdir:
with open(os.path.join(workdir, 'origin'), 'w') as f:
f.write(content_a)
delete_project(prj_name + '_fork')
fork_project = CodeDoubanProject.add(prj_name + '_fork',
2,
fork_from=origin_project.id,
create_trac=False)
fork_path = fork_project.git_real_path
repo = origin_project
fork_repo = fork_project
return path, repo, fork_path, fork_repo
def test_can_set_undefined_second_level_entry(self):
project = CodeDoubanProject.add(
'tp', owner_id="test1", create_trac=False)
u = self.addUser()
project.git.commit_one_file(PROJECT_CONF_FILE,
'docs: {unexisting_key: aaa}', 'm', u)
assert project.conf['docs']['unexisting_key'] == 'aaa'
def test_personal_project(self):
project_name = "lisong_intern/code"
summary = "test"
owner_id = "lisong_intern"
delete_project(project_name)
CodeDoubanProject.add(project_name, owner_id=owner_id, summary=summary)
ret = self.app.get("/api/%s/" % project_name, status=200).json
self.assertEqual(ret["name"], project_name)
self.assertEqual(ret["owner"]["name"], owner_id)
self.assertEqual(ret["description"], summary)
self.assertEqual(ret["committers_count"], 0)
self.assertEqual(ret["watched_count"], 0)
self.assertEqual(ret["forked_count"], 0)
self.assertEqual(ret["open_issues_count"], 0)
self.assertEqual(ret["open_tickets_count"], 0)
def setUp(self):
super(ProjectIssueCommentsTest, self).setUp()
project_name = "code"
product_name = "fire"
summary = "test"
owner_id = "lisong_intern"
delete_project(project_name)
project = CodeDoubanProject.add(
project_name,
owner_id=owner_id,
summary=summary,
product=product_name
)
self.project = project
title = "test title"
description = "test desc"
creator = "test"
issue = ProjectIssue.add(
title,
description,
creator,
project=self.project.id
)
self.issue = issue
self.project = project
self.comment1 = IssueComment.add(
self.issue.issue_id, 'content1', 'test1')
self.comment2 = IssueComment.add(
self.issue.issue_id, 'content2', 'test2')
self.api_token = self.create_api_token('test1')
self.api_token2 = self.create_api_token('test2')
def test_project_stat(self):
store.execute("delete from codedouban_projects where project_id < 5")
project_rs = get_all_project()
assert len(project_rs) == 0
project_fork_count = len(filter(lambda x: x[1] is not None,
project_rs))
assert project_fork_count == 0
project_name = "project"
project = CodeDoubanProject.add(project_name,
owner_id="test1",
summary="test",
product="fire")
git_path = os.path.join(get_repo_root(), '%s.git' % project_name)
ok_(os.path.exists(git_path))
project_rs = get_all_project()
assert len(project_rs) == 1
project_fork_count = len(filter(lambda x: x[1] is not None,
project_rs))
assert project_fork_count == 0
project_fork = project.fork('project_test_fork', 'test_fork')
project_rs = get_all_project()
assert len(project_rs) == 2
project_fork_count = len(filter(lambda x: x[1] is not None,
project_rs))
assert project_fork_count == 1
project.delete()
project_fork.delete()
def test_project_meta_dict(self):
project_name = "project3"
owner_id = "testuser"
summary = "a summary"
product = "fire"
project = CodeDoubanProject.add(
project_name, owner_id, summary, product)
# hookfile_path = "%s/hooks/post-receive" % project.git_real_path
project = CodeDoubanProject.get_by_name(project_name)
data = {
'url': "%s/%s" % (DOMAIN, project_name),
'name': project_name,
'description': summary,
'product': product,
'committers_count': 0,
'forked_count': 0,
'open_issues_count': 0,
'open_tickets_count': 0,
'watched_count': 0,
'owner': {
'name': owner_id,
'avatar': gravatar_url(owner_id + '@douban.com'),
},
}
commits = project.git.get_revisions("HEAD~1", "HEAD")
if commits:
data['last_commit'] = commits[0]
ok_(project.get_info() == data)
project.delete()
def test_broken_conf(self):
project = CodeDoubanProject.add(
'tp', owner_id="test1", create_trac=False)
u = self.addUser()
project.git.commit_one_file(PROJECT_CONF_FILE,
'docs {dir: other_dir', 'm', u)
assert project.conf['docs']['dir'] == 'other_dir'
def test_project_stat(self):
store.execute("delete from codedouban_projects where project_id < 5")
project_rs = get_all_project()
assert len(project_rs) == 0
project_fork_count = len(filter(lambda x: x[1] is not None,
project_rs))
assert project_fork_count == 0
project_name = "project"
project = CodeDoubanProject.add(
project_name, owner_id="test1", summary="test", product="fire")
git_path = os.path.join(get_repo_root(), '%s.git' % project_name)
ok_(os.path.exists(git_path))
project_rs = get_all_project()
assert len(project_rs) == 1
project_fork_count = len(filter(lambda x: x[1] is not None,
project_rs))
assert project_fork_count == 0
project_fork = project.fork('project_test_fork', 'test_fork')
project_rs = get_all_project()
assert len(project_rs) == 2
project_fork_count = len(filter(lambda x: x[1] is not None,
project_rs))
assert project_fork_count == 1
project.delete()
project_fork.delete()
def test_permissions_check(self):
project_name = "project4"
project = CodeDoubanProject.add(project_name, owner_id="admin_user",
summary="test", product="fire")
ok_(project.is_admin("admin_user"))
ok_(not project.is_admin("other_user"))
project.delete()
def add_people_project(project):
name = "%s/%s" % (project.owner_id, project.name)
_project = CodeDoubanProject.add(
name=name, owner_id=project.owner_id,
summary=project.summary, product=project.product,
intern_banned=project.intern_banned)
return _project
def test_personal_project(self):
project_name = "lisong_intern/code"
summary = "test"
owner_id = "lisong_intern"
delete_project(project_name)
CodeDoubanProject.add(project_name, owner_id=owner_id, summary=summary)
ret = self.app.get("/api/%s/" % project_name, status=200).json
self.assertEqual(ret['name'], project_name)
self.assertEqual(ret['owner']['name'], owner_id)
self.assertEqual(ret['description'], summary)
self.assertEqual(ret['committers_count'], 0)
self.assertEqual(ret['watched_count'], 0)
self.assertEqual(ret['forked_count'], 0)
self.assertEqual(ret['open_issues_count'], 0)
self.assertEqual(ret['open_tickets_count'], 0)
def test_fork_project(self):
orig = CodeDoubanProject.add('orig', owner_id="user1")
fork = orig.fork('fork', 'user2')
ok_(os.path.exists(fork.git_real_path))
ok_(os.path.exists(os.path.join(fork.git_real_path, 'HEAD')))
eq_(fork.owner_id, 'user2')
def test_fork_project(self):
orig = CodeDoubanProject.add('orig', owner_id="user1")
fork = orig.fork('fork', 'user2')
ok_(os.path.exists(fork.git_real_path))
ok_(os.path.exists(os.path.join(fork.git_real_path, 'HEAD')))
eq_(fork.owner_id, 'user2')
def test_create_project(self):
project_name = "project"
project = CodeDoubanProject.add(
project_name, owner_id="test1", summary="test", product="fire")
git_path = os.path.join(get_repo_root(), '%s.git' % project_name)
ok_(os.path.exists(git_path))
project.delete()
def test_update_can_push(self):
project_name = "project11"
owner_id = "testuser"
summary = "a summary"
product = "fire"
CodeDoubanProject.add(project_name,
owner_id,
summary,
product)
p = CodeDoubanProject.get_by_name('project11')
assert p.can_push == 1
p.update_can_push(False)
p = CodeDoubanProject.get_by_name('project11')
assert p.can_push == 0
p.update_can_push(True)
p = CodeDoubanProject.get_by_name('project11')
assert p.can_push == 1
def test_conf_add_wrong_keys(self):
project = CodeDoubanProject.add(
'tp', owner_id="test1", create_trac=False)
u = self.addUser()
project.git.commit_one_file(
PROJECT_CONF_FILE,
'unexisting_key_argl1: 1\nunexisting_key_argl2: 2', 'm', u)
assert 'unexisting_key_argl1' not in project.conf
def test_cannot_set_undefined_first_level_entry(self):
project = CodeDoubanProject.add(
'tp', owner_id="test1", create_trac=False)
u = self.addUser()
project.git.commit_one_file(PROJECT_CONF_FILE,
'unexisting_key: 123', 'm', u)
# First level key need to be defined in default_code_config.yaml
assert 'unexisting_key' not in project.conf
def add_org_project(project):
_project = CodeDoubanProject.add(
name=name,
owner_id=project.owner_id,
summary=project.summary,
product=project.product,
intern_banned=project.intern_banned)
return _project
def test_permissions_check(self):
project_name = "project4"
project = CodeDoubanProject.add(project_name,
owner_id="admin_user",
summary="test",
product="fire")
ok_(project.is_admin("admin_user"))
ok_(not project.is_admin("other_user"))
project.delete()
def test_rename_bad_project(self):
pname1 = 'project10'
pname2 = '/dad13/'
proj_owner = 'admin_user'
p = CodeDoubanProject.add(pname1, owner_id=proj_owner,
summary="test", product="fire")
assert p.rename(pname2) is False
git_path = os.path.join(get_repo_root(), '%s.git' % pname1)
ok_(os.path.exists(git_path))
def test_get_forked_from_should_return_origin_project(self):
prj = CodeDoubanProject.get_by_name('orig')
prj.delete()
prj = CodeDoubanProject.get_by_name('fork')
prj.delete()
orig = CodeDoubanProject.add('orig', owner_id="test1")
fork = orig.fork('fork', 'user2')
source = fork.get_forked_from()
eq_(source, orig)
def add_people_project(project):
name = "%s/%s" % (project.owner_id, project.name)
_project = CodeDoubanProject.add(
name=name,
owner_id=project.owner_id,
summary=project.summary,
product=project.product,
intern_banned=project.intern_banned)
return _project
def test_transfer_project(self):
pname1 = 'project6'
pname2 = 'project7'
proj_owner = 'admin_user'
to_user = '******'
p = CodeDoubanProject.add(pname1,
owner_id=proj_owner,
summary="test",
product="fire")
_ = CodeDoubanProject.add(pname2,
owner_id=proj_owner,
summary="test",
product="fire")
p.transfer_to(to_user)
p1 = CodeDoubanProject.get_by_name(pname1)
assert p1.owner_id == to_user
p2 = CodeDoubanProject.get_by_name(pname2)
assert p2.owner_id == proj_owner
def test_get_forked_from_should_return_origin_project(self):
prj = CodeDoubanProject.get_by_name('orig')
prj.delete()
prj = CodeDoubanProject.get_by_name('fork')
prj.delete()
orig = CodeDoubanProject.add('orig', owner_id="test1")
fork = orig.fork('fork', 'user2')
source = fork.get_forked_from()
eq_(source, orig)
def test_can_set_undefined_second_level_entry(self):
self.clean_up()
project = CodeDoubanProject.add('tp',
owner_id="test1",
create_trac=False)
u = self.addUser()
project.git.commit_one_file(PROJECT_CONF_FILE,
'docs: {unexisting_key: aaa}', 'm', u)
assert project.conf['docs']['unexisting_key'] == 'aaa'
def test_broken_conf(self):
self.clean_up()
project = CodeDoubanProject.add('tp',
owner_id="test1",
create_trac=False)
u = self.addUser()
project.git.commit_one_file(PROJECT_CONF_FILE, 'docs {dir: other_dir',
'm', u)
assert project.conf['docs']['dir'] == 'other_dir'
def test_rename_project(self):
pname1 = 'project8'
pname2 = 'project9'
proj_owner = 'admin_user'
p = CodeDoubanProject.add(pname1, owner_id=proj_owner,
summary="test", product="fire")
p.rename(pname2)
assert p.name == pname2
git_path = os.path.join(get_repo_root(), '%s.git' % pname2)
ok_(os.path.exists(git_path))
def test_create_project(self):
project_name = "project"
project = CodeDoubanProject.add(project_name,
owner_id="test1",
summary="test",
product="fire")
git_path = os.path.join(get_repo_root(), '%s.git' % project_name)
ok_(os.path.exists(git_path))
project.delete()
def test_conf_add_wrong_keys(self):
self.clean_up()
project = CodeDoubanProject.add('tp',
owner_id="test1",
create_trac=False)
u = self.addUser()
project.git.commit_one_file(
PROJECT_CONF_FILE,
'unexisting_key_argl1: 1\nunexisting_key_argl2: 2', 'm', u)
assert 'unexisting_key_argl1' not in project.conf
def test_cannot_set_undefined_first_level_entry(self):
self.clean_up()
project = CodeDoubanProject.add('tp',
owner_id="test1",
create_trac=False)
u = self.addUser()
project.git.commit_one_file(PROJECT_CONF_FILE, 'unexisting_key: 123',
'm', u)
# First level key need to be defined in default_code_config.yaml
assert 'unexisting_key' not in project.conf
def test_get_my_projects(self):
project_name = "code"
product_name = "fire"
summary = "test"
owner_id = "xingben"
for i in range(5):
delete_project("%s%d" % (project_name, i))
CodeDoubanProject.add("%s%d" % (project_name, i),
owner_id=owner_id,
summary=summary,
product=product_name)
api_token = self.create_api_token('xingben')
ret = self.app.get("/api/user/repos",
headers=dict(Authorization="Bearer %s" %
api_token.token),
status=200).json
self.assertEquals(len(ret), 5)
self.assertTrue('name' in ret[0])
self.assertTrue('description' in ret[0])
def test_get_fork_network_should_return_all_projects_with_same_origin(self): # noqa
orig = CodeDoubanProject.add('orig', owner_id="test1")
fork = orig.fork('fork', 'user1')
fork2 = orig.fork('fork2', 'user2')
fork3 = fork.fork('fork3', 'user3')
expected_network = set([orig, fork, fork2, fork3])
for proj in [orig, fork, fork2, fork3]:
network = proj.get_fork_network()
eq_(set(network), expected_network)
def test_rename_bad_project(self):
pname1 = 'project10'
pname2 = '/dad13/'
proj_owner = 'admin_user'
p = CodeDoubanProject.add(pname1,
owner_id=proj_owner,
summary="test",
product="fire")
assert p.rename(pname2) is False
git_path = os.path.join(get_repo_root(), '%s.git' % pname1)
ok_(os.path.exists(git_path))
def setUp(self):
super(ProjectIssueTest, self).setUp()
project_name = "code"
product_name = "fire"
summary = "test"
owner_id = "lisong_intern"
project = CodeDoubanProject.add(project_name, owner_id=owner_id, summary=summary, product=product_name)
self.project = project
self.username = "******"
self.username2 = "zhangchi"
self.api_token = self.create_api_token(self.username)
self.api_token2 = self.create_api_token(self.username2)
def test_rename_project(self):
pname1 = 'project8'
pname2 = 'project9'
proj_owner = 'admin_user'
p = CodeDoubanProject.add(pname1,
owner_id=proj_owner,
summary="test",
product="fire")
p.rename(pname2)
assert p.name == pname2
git_path = os.path.join(get_repo_root(), '%s.git' % pname2)
ok_(os.path.exists(git_path))
def add_mirror_project(project):
name = "mirror/%s" % (project.name)
_project = CodeDoubanProject.add(
name=name, owner_id='mirror', summary=project.summary,
product=project.product, intern_banned=project.intern_banned,
mirror=project.mirror_url)
if _project:
CodeDoubanMirror.add(url=project.mirror_url,
state=MIRROR_STATE_CLONING,
project_id=_project.id,
with_proxy=project.mirror_proxy)
return _project
def test_zero_vote_and_zero_comment_display(self):
app = TestApp(M.app)
project_name = "project"
project = CodeDoubanProject.add(
project_name, owner_id="test1", summary="test", product="fire")
issue = ProjectIssue.add('test', 'test description', 'test',
project=project.id)
resp = app.get(project.url + "/issues/")
assert resp.status_int == 200
assert 'Issues' in resp.body
assert '0 vote' not in resp.body
assert '0 comment' not in resp.body
def test_new_project_issue_participant_count(self):
app = TestApp(M.app)
project_name = "project"
project = CodeDoubanProject.add(
project_name, owner_id="test1", summary="test", product="fire")
issue = ProjectIssue.add(
'test', 'test description', 'test', project=project.id)
resp = app.get(issue.url)
assert resp.status_int == 200
assert 'Issues' in resp.body
assert '<strong>1</strong> participant' in resp.text
assert '<strong>1</strong> participants' not in resp.text
def add_fork_project(project):
name = "%s/%s" % (project.owner_id, project.name)
_project = CodeDoubanProject.add(
name=name, owner_id=project.owner_id, summary=project.summary,
product=project.product, fork_from=project.fork_from,
intern_banned=project.intern_banned)
if _project:
fork_from_project = CodeDoubanProject.get(project.fork_from)
_project.update(project.summary,
project.product,
name,
fork_from_project.intern_banned)
return _project
def test_two_comments_display(self):
app = TestApp(M.app)
project_name = "project4"
project = CodeDoubanProject.add(
project_name, owner_id="test1", summary="test", product="fire")
issue = ProjectIssue.add('test', 'test description', 'test',
project=project.id)
issue.add_comment('this is a comment', 'test')
issue.add_comment('this is also a comment', 'test')
resp = app.get(project.url + "/issues/")
assert resp.status_int == 200
assert "Issues" in resp.body
assert "2 comments" in resp.body
def test_get_fork_network_should_return_all_projects_with_same_origin(
self): # noqa
prj = CodeDoubanProject.get_by_name('orig')
prj.delete()
orig = CodeDoubanProject.add('orig', owner_id="test1")
fork = orig.fork('fork1', 'user1')
fork2 = orig.fork('fork2', 'user2')
fork3 = fork.fork('fork3', 'user3')
expected_network = set([orig, fork, fork2, fork3])
for proj in [orig, fork, fork2, fork3]:
network = proj.get_fork_network()
eq_(set(network), expected_network)
def add_fork_project(project):
name = "%s/%s" % (project.owner_id, project.name)
_project = CodeDoubanProject.add(
name=name,
owner_id=project.owner_id,
summary=project.summary,
product=project.product,
fork_from=project.fork_from,
intern_banned=project.intern_banned)
if _project:
fork_from_project = CodeDoubanProject.get(project.fork_from)
_project.update(project.summary, project.product, name,
fork_from_project.intern_banned)
return _project
def add_mirror_project(project):
name = "mirror/%s" % (project.name)
_project = CodeDoubanProject.add(
name=name,
owner_id='mirror',
summary=project.summary,
product=project.product,
intern_banned=project.intern_banned,
mirror=project.mirror_url)
if _project:
CodeDoubanMirror.add(url=project.mirror_url,
state=MIRROR_STATE_CLONING,
project_id=_project.id,
with_proxy=project.mirror_proxy)
return _project
def create_project_and_a_fork(self):
from nose import SkipTest
raise SkipTest(
"These tests have Segmentation Fault") # guibog 20121105
orig = CodeDoubanProject.add('orig', 'origuser')
with clone(orig.git_real_path) as workdir:
with open(os.path.join(workdir, 'a'), 'w') as f:
f.write("a line of code\n")
fork = orig.fork('fork', 'forkuser')
with clone(fork.git_real_path) as workdir:
with open(os.path.join(workdir, 'b'), 'w') as f:
f.write("another line of code\n")
return orig, fork
def setUp(self):
super(ProjectIssueTest, self).setUp()
project_name = "code"
product_name = "fire"
summary = "test"
owner_id = "lisong_intern"
delete_project(project_name)
project = CodeDoubanProject.add(project_name,
owner_id=owner_id,
summary=summary,
product=product_name)
self.project = project
self.username = "******"
self.username2 = "zhangchi"
self.api_token = self.create_api_token(self.username)
self.api_token2 = self.create_api_token(self.username2)
def test_zero_vote_and_zero_comment_display(self):
app = TestApp(M.app)
project_name = "project"
delete_project(project_name)
project = CodeDoubanProject.add(project_name,
owner_id="test1",
summary="test",
product="fire")
ProjectIssue.add('test',
'test description',
'test',
project=project.id)
resp = app.get(project.url + "/issues/")
assert resp.status_int == 200
assert 'Issues' in resp.body
assert '0 vote' not in resp.body
assert '0 comment' not in resp.body
