def test_add_topics(self):
aggregator = Aggregator()
aggregator.add(Repo(False, 10, "python", ["Flask"]))
self.assertEqual(aggregator.topics, {"flask": 1})
aggregator.add(Repo(False, 10, "python", ["flask"]))
self.assertEqual(aggregator.topics, {"flask": 2})
aggregator.add(Repo(False, 10, "python", ["flask", "numpy"]))
self.assertEqual(aggregator.topics, {"flask": 3, "numpy": 1})
def test_add_languages(self):
aggregator = Aggregator()
aggregator.add(Repo(False, 10, "Python", ["Flask"]))
self.assertEqual(aggregator.languages, {"python": 1})
aggregator.add(Repo(False, 10, "python", ["Flask"]))
self.assertEqual(aggregator.languages, {"python": 2})
aggregator.add(Repo(False, 10, "java", ["Flask"]))
self.assertEqual(aggregator.languages, {"python": 2, "java": 1})
aggregator.add(Repo(False, 10, None, ["Flask"]))
self.assertEqual(aggregator.languages, {"python": 2, "java": 1})
def test_asdict(self):
aggregator = Aggregator()
expected = {
"public_repo_count": 0,
"public_repo_breakdown": {
"original_repo_count": 0,
"forked_repo_count": 0
},
"watcher_count": 0,
"languages": [],
"topics": []
}
self.assertEqual(aggregator.asdict(), expected)
expected2 = {
"public_repo_count": 1,
"public_repo_breakdown": {
"original_repo_count": 1,
"forked_repo_count": 0
},
"watcher_count": 10,
"languages": [{
"name": "python",
"count": 1
}],
"topics": [{
"name": "flask",
"count": 1
}]
}
aggregator.add(Repo(True, 10, "python", ["flask"]))
self.assertEqual(aggregator.asdict(), expected2)
def add_repo(project_id):
data = request.get_json()
project = Project.query.get(project_id)
if project is None:
return jsonify(message="Project not found"), 404
if not project.course.is_user(current_user.id):
return jsonify(message="Unauthorized to add project"), 403
repo = project.get_repo_for_user(current_user.id)
if repo:
return jsonify(message="Already added repo for project"), 400
repo = Repo(project_id=project.id, name=data['repo_name'])
repo.user_id = current_user.id
if project.type is not ProjectTypes.IND:
g = project.get_group_for_user(current_user.id)
if g is None:
return jsonify(message="Not part of group"), 400
repo.group_id = g.id
webhook = add_webhook(repo.name, current_user.oauth_token)
if 'id' not in webhook:
return jsonify(error="Could not create webhook", data=webhook), 401
repo.webhook_id = webhook['id']
db.session.add(repo)
db.session.commit()
return jsonify(repo=ps.RepoSchema().dump(repo)), 201
def RunWithPars(pars, uid):
startTime = Common.getCurrentTimeMil()
reposFol = 'SavePath/Repos/'
if not os.path.exists(config.basedir + '/' + reposFol):
os.makedirs(config.basedir + '/' + reposFol)
fname = reposFol + Common.gen_rnd_filename()
os.makedirs(config.basedir + '/' + fname)
##ADD Field
e = Repo()
e.cloneFinishDate = "--RUNNING--"
e.cloneStartDate = str(startTime)
e.repoInfo = ''
e.isPrivate = int(pars['isPrivate'])
e.path = fname
e.repoName = pars['repoName']
e.url = pars['url']
e.userId = uid
db.session.add(e)
db.session.commit()
try:
porcelain.clone(pars['url'], config.basedir + '/' + fname)
endTime = Common.getCurrentTimeMil()
e.cloneFinishDate = str(endTime)
db.session.commit()
except Exception as ex:
print(ex)
e.delete()
db.session.commit()
def add_repository(url, comment, user_id):
repo = Repo(url=url,
timestamp=datetime.datetime.now(),
user_id=user_id,
comment=comment)
db.session.add(repo)
db.session.commit()
return repo
def test_init(self):
is_original = True
watcher_count = 10
language = "Python"
topics = ["Flask"]
repo = Repo(is_original, watcher_count, language, topics)
self.assertEqual(repo.is_original, is_original)
self.assertEqual(repo.watcher_count, watcher_count)
self.assertEqual(repo.language, language)
self.assertEqual(repo.topics, topics)
def create(self, request, *args, **kwargs):
""" Generates db repo object """
user = request.data['user']
path = request.data['path']
version = request.data['version']
res = RepoManager(user).create()
if not version:
version = res
r = Repo(user=user, path=path, version=version)
r.save()
rs = RepoSerializer(r)
return Response(rs.data)
def change_status(target_repo, state):
from models import Repo
if not use_database:
return ''
try:
repo = Repo.objects.get(url=target_repo)
repo.last_used = datetime.today()
repo.state = state
repo.owner = parent_folder
repo.save()
except DoesNotExist:
repo = Repo()
repo.url = target_repo
repo.state = state
repo.owner = parent_folder
repo.save()
except Exception as e:
print 'database_exception: ' + str(e)
def cargar_datos(self):
"""Parsea o contido dun ficheiro JSON."""
datos_json = self.cargar_json()
for k, v in datos_json.items():
if (k == "usuario"):
usuario = v
self.usuario = UsuarioGit(usuario["usuario"], usuario["email"])
elif (k == "repos"):
for item in v:
aux = item
repo = Repo(
aux["nome"],
aux["rama"],
aux["remoto"],
aux["uri"],
aux["directorio"],
aux["ten_submodulos"],
aux["e_submodulo"]
)
self.add_repo(repo)
def post(self):
parsed_args = parser.parse_args()
repo = Repo(creator=parsed_args['creator'], name=parsed_args['name'])
session.add(repo)
session.commit()
return repo, 201
def test_add_none(self):
aggregator = Aggregator()
aggregator.add(Repo(None, 10, "Python", ["Flask"]))
self.assertEqual(aggregator.count, 1)
self.assertEqual(aggregator.original_count, 0)
self.assertEqual(aggregator.forked_count, 0)
