def git_magic():
"""
This creates repository on the downloaded and extracted folder.
Once that's accomplished, it will push the changes to the repository.
Preserving the history of the branch.
"""
print("Before Git, PATH is: %s." % sys.path)
for param in os.environ.keys():
print("%20s %s" % (param, os.environ[param]))
import git
print("Performing git magic.")
source = git.Repo.init(path='/tmp/public')
print("Repo initated.")
origin = source.create_remote('origin', REPO)
origin.fetch()
source.head.reset(commit='origin/master')
source.heads.master.set_tracking_branch(origin.refs.master)
source.heads.master.checkout()
source.git.add(A=True)
from git import Actor
author = Actor(NAME, EMAIL)
committer = Actor(NAME, EMAIL)
source.index.commit(message='Added new content through AWS Lambda.',
author=author,
committer=committer)
source.git.push()
print("Push done.")
def test_dirty_git(tmpdir):
""" Check that repository fails to initialise if unchecked files are in the repo """
repo = Repo.init(path=tmpdir)
tmppath = pathlib.Path(tmpdir)
index = repo.index
author = Actor("An author", "*****@*****.**")
committer = Actor("A committer", "*****@*****.**")
# First commit
with open(tmppath / ".gitignore", "w") as ignore:
ignore.write(".wily/")
index.add([".gitignore"])
commit1 = index.commit("commit1", author=author, committer=committer)
# Write a test file to the repo
with open(tmppath / "blah.py", "w") as ignore:
ignore.write("*.py[co]\n")
index.add(["blah.py"])
repo.close()
config = DEFAULT_CONFIG
config.path = tmpdir
with pytest.raises(DirtyGitRepositoryError):
archiver = GitArchiver(config)
archiver.revisions(tmpdir, 2)
def test_checkout_master(self):
if not select_tune_date_update(cnn):
date_updated = create_tune_date_update(cnn)
git_dir = os.path.join(config.git_folder, cnn.dsn)
branch_name = '%s_%s' % (
db_name, date_updated.strftime('%d.%m.%Y_%H.%M')
) # %Y%m%d_%H%M%S
repo = clone_or_open_repo(git_dir)
past_branch = repo.create_head(branch_name, 'master')
repo.head.reference = past_branch
repo.head.reset(index=True, working_tree=True)
logger.info("checkout new branch %s" % branch_name)
# Сохраним тексты
df = select_objects_in_folder_or_date_modified(
cnn, git_dir, 1, 'd')
dirs.write_object_from_df(df, git_dir)
# Закомитим
# repo.git.add(update=True)
repo.git.add(A=True)
index = repo.index
from git import Actor
author = Actor("An author", "*****@*****.**")
committer = Actor("A committer", "*****@*****.**")
index.commit("my commit message",
author=author,
committer=committer)
def test_commit_authorized_time(self):
# repos_dir = r"C:\Users\BryzzhinIS\Documents\Хранилища\sync_script"
# repo_dir = os.path.join(repos_dir, 'dbs', 'lw-abs-abs')
# repo = clone_or_open_repo(repo_dir)
# repo.git.add(A=True)
# author = Actor('sources_sync_job', '@mail')
# committer = Actor('sources_sync_job', '@mail')
# time_str = "2012-07-24T23:14:29-07:00"
# time_str = "2012-07-24T23:14:29"
# repo.index.commit('test', author=author, committer=committer, author_date=time_str)
last_date_update = '28.09.2017 18:30:30'
df = select_all_by_date_modified(cnn, last_date_update)
df = df.sort_values('MODIFIED', ascending=False)
# localtz = pytz.timezone('Europe/Moscow')
# time_str = localtz.localize(df.iloc[0]["MODIFIED"]).strftime('%d.%m.%YT%H:%M:%S%z')
time_str = (df.iloc[0]["MODIFIED"] +
datetime.timedelta(hours=-3)).strftime('%d.%m.%YT%H:%M:%S')
print(time_str)
repos_dir = r"C:\Users\BryzzhinIS\Documents\Хранилища\sync_script"
# repo_dir = os.path.join(repos_dir, 'dbs', 'lw-abs-abs')
repo_dir = os.path.join(repos_dir, 'dbs', 'mideveryday')
repo = clone_or_open_repo(repo_dir)
repo.git.add(A=True)
author = Actor('sources_sync_job', '@mail')
committer = Actor('sources_sync_job', '@mail')
# time_str = "2012-07-24T23:14:29-07:00"
# time_str = "2012-07-24T23:14:29"
repo.index.commit('test',
author=author,
committer=committer,
author_date=time_str)
async def add_to_index(author_name: Optional[str] = Body(...),
author_email: Optional[str] = Body(...),
msg: Optional[str] = None):
if gitrepo.is_dirty(untracked_files=True):
# add the changed files to the index for this commit
changedFiles = [item.a_path for item in gitrepo.index.diff(None)]
# create a status message
num_changed_files = len(changedFiles)
num_new_files = len(gitrepo.untracked_files)
if msg is None:
msg = f"adds {num_changed_files} changed and {num_new_files} new files to repo"
# add changed and new files to index for commit
gitrepo.index.add(gitrepo.untracked_files)
gitrepo.index.add(changedFiles)
# set author and committer
committer = Actor("file-repo", "*****@*****.**")
if author_email is None:
author_email = "*****@*****.**"
if author_name is None:
author_name = "file-repo"
author = Actor(f"{author_name}", f"{author_email}")
gitrepo.index.commit(msg, author=author, committer=committer)
return {
"num_changed_files": num_changed_files,
"num_new_files": num_new_files,
"changed": (num_new_files > 0 or num_changed_files > 0)
}
def ampq_addFile(id=None, file=None, message=None, branch="master"):
repository = get_object_or_404(Repository, pk=id)
temp = tempfile.mkdtemp()
repo = Repo.clone_from(repository.url, temp,
branch=branch) # clone du dépot
new_file_path = os.path.join(repo.working_tree_dir,
os.path.basename(file.file.name))
fichier = open(new_file_path, 'wb')
fichier.write(file.file.read())
fichier.close()
repo.index.add([new_file_path])
print(temp + '/' + file.file.name + '/')
print(os.path.basename(file.file.name))
print(temp + '/' + os.path.basename(file.file.name))
author = Actor("Utilisateur", "*****@*****.**")
committer = Actor("admin la maison des partitions",
"*****@*****.**")
repo.index.commit(message, author=author, committer=committer)
repo.remotes.origin.push()
file.file.delete()
file.delete()
return 1
def delete_data(self, repo_path, message, author=None, committer=None):
"""
Delete a file that's not necessarily a model file.
:param str repo_path:
Which file to delete.
:param str message:
The commit message.
:param tuple author:
The author information (name, email address)
Defaults repo default if unspecified.
:param tuple committer:
The committer information (name, email address).
Defaults to the author if unspecified.
:returns:
The commit
"""
if not isinstance(message, str):
raise StorageException('Messages need to be bytestrings.')
file_path = os.path.join(self.repo.working_dir, repo_path)
if not os.path.isfile(file_path):
raise StorageException('File does not exist.')
author_actor = Actor(*author) if author else None
committer_actor = Actor(*committer) if committer else author_actor
# Remove from the index
index = self.repo.index
index.remove([file_path], working_tree=True)
return index.commit(message,
author=author_actor,
committer=committer_actor)
def test_build(tmpdir):
"""
Test that build works in a basic repository.
"""
repo = Repo.init(path=tmpdir)
tmppath = pathlib.Path(tmpdir)
# Write a test file to the repo
with open(tmppath / "test.py", "w") as test_txt:
test_txt.write("import abc")
with open(tmppath / ".gitignore", "w") as test_txt:
test_txt.write(".wily/")
index = repo.index
index.add(["test.py", ".gitignore"])
author = Actor("An author", "*****@*****.**")
committer = Actor("A committer", "*****@*****.**")
commit = index.commit("basic test", author=author, committer=committer)
with patch("wily.logger") as logger:
runner = CliRunner()
result = runner.invoke(
main.cli, ["--debug", "--path", tmpdir, "build", "test.py"])
assert result.exit_code == 0, result.stdout
cache_path = tmpdir / ".wily"
assert cache_path.exists()
index_path = tmpdir / ".wily" / "git" / "index.json"
assert index_path.exists()
rev_path = tmpdir / ".wily" / "git" / commit.name_rev.split(
" ")[0] + ".json"
assert rev_path.exists()
def get_commit_author():
"""get a dictionary that represent the commit author with ``author`` and ``comitter`` key. If there is no users,
bot account pk is used.
:return: correctly formatted commit author for ``repo.index.commit()``
:rtype: dict
"""
user = get_current_user()
if user and user.is_authenticated():
aut_user = str(user.pk)
aut_email = None
if hasattr(user, 'email'):
aut_email = user.email
else:
try:
aut_user = str(
User.objects.filter(username=settings.ZDS_APP['member']
['bot_account']).first().pk)
except AttributeError:
aut_user = '******'
aut_email = None
if aut_email is None or aut_email.strip() == "":
aut_email = _(u"inconnu@{}").format(settings.ZDS_APP['site']['dns'])
return {
'author': Actor(aut_user, aut_email),
'committer': Actor(aut_user, aut_email)
}
def _prepare(cls, create, **kwargs):
extract = super(ExtractFactory, cls)._prepare(create, **kwargs)
chapter = kwargs.pop('chapter', None)
with open(extract.get_path(relative=False), "w") as f:
f.write("This dumb content is just here to prove you zep12 is far better than old module")
if chapter:
if chapter.tutorial:
repo = Repo(os.path.join(settings.ZDS_APP['tutorial']['repo_path'],
chapter.tutorial.get_phy_slug()))
index = repo.index
index.add([extract.get_path(relative=True)])
man_path = os.path.join(chapter.tutorial.get_path(), "manifest.json")
chapter.tutorial.dump_json(path=man_path)
index.add(["manifest.json"])
chapter.tutorial.sha_draft = index.commit(
"bla",
author=Actor("bla", "*****@*****.**"),
committer=Actor("bla", "*****@*****.**"))
chapter.tutorial.save()
elif chapter.part:
repo = Repo(os.path.join(settings.ZDS_APP['tutorial']['repo_path'],
chapter.part.tutorial.get_phy_slug()))
index = repo.index
index.add([extract.get_path(relative=True)])
man_path = os.path.join(chapter.part.tutorial.get_path(), "manifest.json")
chapter.part.tutorial.dump_json(path=man_path)
index.add(["manifest.json"])
chapter.part.tutorial.sha_draft = index.commit(
"bla",
author=Actor("bla", "*****@*****.**"),
committer=Actor("bla", "*****@*****.**"))
chapter.part.tutorial.save()
return extract
def patch_and_push(dfp, repository, target_branch, release_version):
"""patch the Dockerfile and push the created branch to origin"""
# lets create a new branch
new_branch = repository.create_head(target_branch)
new_branch.checkout()
# set dockerfile version to release version
dfp.envs['MATTERMOST_VERSION'] = release_version
dfp.envs['MATTERMOST_VERSION_SHORT'] = release_version.replace('.', '')
# and write back the Dockerfile
with open('./mattermost-openshift-workdir/Dockerfile', 'w') as f:
f.write(dfp.content)
f.close()
# commit our work
repository.index.add(['Dockerfile'])
author = Actor('Mattermost Server Updater Bot', '*****@*****.**')
committer = Actor('Mattermost Server Updater Bot', '*****@*****.**')
repository.index.commit("Update to Mattermost " + release_version,
author=author,
committer=committer)
# and push to origin
with repository.git.custom_environment(GIT_SSH_COMMAND=SSH_CMD):
repository.remotes.origin.push(
refspec='{}:{}'.format(target_branch, target_branch))
def create_working_md(sender, instance, created, **kwargs):
path = instance.get_path()
if created:
print 'create sroty'
instance.authors.add(instance.owner)
instance.save()
f = codecs.open(path, encoding='utf-8', mode='w+')
f.write(instance.contents)
f.seek(0)
f.close()
from git import Repo, Commit, Actor, Tree
author = Actor(instance.owner.username, instance.owner.email)
committer = Actor(settings.GIT_COMMITTER['name'],
settings.GIT_COMMITTER['email'])
# commit if there are any differences
repo = Repo.init(settings.GIT_ROOT)
# add and commit JUST THIS FILE
#tree = Tree(repo=repo, path=instance.owner.profile.get_path())
repo.index.add([instance.owner.profile.get_path()])
repo.index.commit(message=u"saving %s" % instance.title,
author=author,
committer=committer)
def test_build_crash(tmpdir):
"""
Simulate a runtime error in the build.
"""
repo = Repo.init(path=tmpdir)
tmppath = pathlib.Path(tmpdir)
# Write a test file to the repo
with open(tmppath / "test.py", "w") as test_txt:
test_txt.write("import abc")
index = repo.index
index.add(["test.py"])
author = Actor("An author", "*****@*****.**")
committer = Actor("A committer", "*****@*****.**")
index.commit("basic test", author=author, committer=committer)
repo.close()
import wily.commands.build
with patch.object(wily.commands.build.Bar,
"finish",
side_effect=RuntimeError("arggh")) as bar_finish:
runner = CliRunner()
result = runner.invoke(main.cli,
["--path", tmpdir, "build", "test.py"])
assert bar_finish.called_once
assert result.exit_code == 1, result.stdout
def test_detached_head(tmpdir):
""" Check that repo can initialize in detached head state"""
repo = Repo.init(path=tmpdir)
tmppath = pathlib.Path(tmpdir)
index = repo.index
author = Actor("An author", "*****@*****.**")
committer = Actor("A committer", "*****@*****.**")
# First commit
with open(tmppath / "test.py", "w") as ignore:
ignore.write("print('hello world')")
index.add(["test.py"])
commit1 = index.commit("commit1", author=author, committer=committer)
# Second commit
with open(tmppath / "test.py", "w") as ignore:
ignore.write("print('hello world')\nprint(1)")
index.add(["test.py"])
commit2 = index.commit("commit2", author=author, committer=committer)
repo.git.checkout(commit2.hexsha)
repo.close()
config = DEFAULT_CONFIG
config.path = tmpdir
archiver = GitArchiver(config)
assert archiver.revisions(tmpdir, 1) is not None
def database_backup():
repo = git.Repo(BACKUP_PATH)
origin = repo.remote('origin')
origin.pull()
try:
now = get_time_format()
json_name = 'data_{}.json'.format(now)
try:
cmd = 'python manage.py dumpdata > %s ' % json_name
os.system(cmd)
except:
cmd = 'python3 manage.py dumpdata > %s ' % json_name
os.system(cmd)
if not os.path.isfile(json_name):
return 1
shutil.move(json_name, BACKUP_PATH)
author = Actor("taomercy", "*****@*****.**")
committer = Actor("taomercy", "*****@*****.**")
repo.git.add(os.path.join(BACKUP_PATH, json_name))
if repo.index.diff('HEAD'):
commit_msg = 'data backup %s' % now
repo.index.commit(commit_msg, author=author, committer=committer)
origin.push()
else:
logging.info("no changes")
logging.info('backup end')
return 0
except Exception as err:
print(repo.git.status())
logging.info(err)
return 1
def get_commit_author():
"""get a dictionary that represent the commit author with ``author`` and ``comitter`` key. If there is no users,
bot account pk is used.
:return: correctly formatted commit author for ``repo.index.commit()``
:rtype: dict
"""
user = get_current_user()
if user and user.is_authenticated:
aut_user = str(user.pk)
aut_email = None
if hasattr(user, "email"):
aut_email = user.email
else:
try:
aut_user = str(
User.objects.filter(username=settings.ZDS_APP["member"]
["bot_account"]).first().pk)
except AttributeError: # if nothing is found, `first` returns None, which does not have attribute pk
aut_user = "******"
aut_email = None
if aut_email is None or not aut_email.strip():
aut_email = _("inconnu@{}").format(settings.ZDS_APP["site"]["dns"])
return {
"author": Actor(aut_user, aut_email),
"committer": Actor(aut_user, aut_email)
}
async def change_repo(url):
# Remove Default Dockerfile then download New Dockerfile
os.remove("Dockerfile")
urllib.request.urlretrieve(url, "Dockerfile")
# Commit Changes
repo = Repo()
index = repo.index
index.add(["Dockerfile"]) # add a new file to the index
from git import Actor
author = Actor("Nana", "*****@*****.**")
committer = Actor("Nana", "*****@*****.**")
# commit by commit message and author and committer
index.commit("Change Repo", author=author, committer=committer)
if HEROKU_API is not None:
import heroku3
heroku = heroku3.from_key(HEROKU_API)
heroku_applications = heroku.apps()
if len(heroku_applications) >= 1:
heroku_app = heroku_applications[0]
heroku_git_url = heroku_app.git_url.replace(
"https://", "https://*****:*****@"
)
if "heroku" in repo.remotes:
remote = repo.remote("heroku")
remote.set_url(heroku_git_url)
else:
remote = repo.create_remote("heroku", heroku_git_url)
remote.push(refspec="HEAD:refs/heads/master", force=True)
def ampq_deleteFile(id=None, file=None, message=None, branch="master"):
repository = get_object_or_404(Repository, pk=id)
temp = tempfile.mkdtemp()
# clone du dépot
repo = Repo.clone_from(repository.url, temp,
branch=branch) # clone du dépot
#repo.git.checkout(branch)
new_file_path = os.path.join(repo.working_tree_dir,
os.path.basename(file.name))
repo.index.remove([new_file_path])
print(temp + '/' + file.name + '/')
print(os.path.basename(file.name))
print(temp + '/' + os.path.basename(file.name))
author = Actor("Utilisateur", "*****@*****.**")
committer = Actor("admin la maison des partitions",
"*****@*****.**")
repo.index.commit(str(message), author=author, committer=committer)
repo.remotes.origin.push()
return 1
def init_repo(message, bot, path_to_user_folder):
try:
with open(path_to_user_folder + '/user_data/token.txt', 'r') as f:
token = f.read()
with Git().custom_environment(HTTPS_REMOTE_URL='https://' + token +
':x-oauth-basic@' + message.text[8:]):
repo = Repo.init(path_to_user_folder + '/main')
repo.index.add('*')
author = Actor("seppass", "*****@*****.**")
committer = Actor("seppass", "*****@*****.**")
repo.index.commit('initial commit',
author=author,
committer=committer)
origin = repo.create_remote("origin",
url='https://' + token +
':x-oauth-basic@' + message.text[8:])
repo.git.push("--set-upstream", origin, repo.head.ref)
msg = bot.send_message(
message.chat.id,
'Я закончил.',
reply_markup=types.ReplyKeyboardRemove(selective=False))
del_mess(msg, bot, 6)
return
except:
msg = bot.send_message(
message.chat.id,
'Произошла ошибка.',
reply_markup=types.ReplyKeyboardRemove(selective=False))
del_mess(msg, bot, 4)
return
def __init__(self,
storage: GitStorage,
message: str,
author: Tuple[str, str] = None,
committer: Tuple[str, str] = None):
super().__init__(storage, message)
self.author = None if author is None else Actor(*author)
self.committer = None if committer is None else Actor(*committer)
def gitdir(tmpdir):
""" Create a project and add code to it """
repo = Repo.init(path=tmpdir)
tmppath = pathlib.Path(tmpdir)
testpath = tmppath / "src" / "test.py"
(tmppath / "src").mkdir()
# Write a test file to the repo
with open(testpath, "w") as test_txt:
test_txt.write("import abc")
index = repo.index
index.add([str(testpath)])
author = Actor("An author", "*****@*****.**")
committer = Actor("A committer", "*****@*****.**")
index.commit("basic test", author=author, committer=committer)
first_test = """
import abc
foo = 1
def function1():
a = 1 + 1
class Class1(object):
def method(self):
b = 1 + 5
"""
with open(testpath, "w") as test_txt:
test_txt.write(dedent(first_test))
index.add([str(testpath)])
index.commit("add line", author=author, committer=committer)
second_test = """
import abc
foo = 1
def function1():
a = 1 + 1
class Class1(object):
def method(self):
b = 1 + 5
if b == 6:
return 'banana'
"""
with open(testpath, "w") as test_txt:
test_txt.write(dedent(second_test))
with open(tmppath / ".gitignore", "w") as test_txt:
test_txt.write(".wily/")
index.add([str(testpath), ".gitignore"])
index.commit("remove line", author=author, committer=committer)
return tmpdir
def test_build_twice(tmpdir, cache_path):
"""
Test that build works when run twice.
"""
repo = Repo.init(path=tmpdir)
tmppath = pathlib.Path(tmpdir)
# Write a test file to the repo
with open(tmppath / "test.py", "w") as test_txt:
test_txt.write("import abc")
index = repo.index
index.add(["test.py"])
author = Actor("An author", "*****@*****.**")
committer = Actor("A committer", "*****@*****.**")
commit = index.commit("basic test", author=author, committer=committer)
runner = CliRunner()
result = runner.invoke(
main.cli,
[
"--debug", "--path", tmpdir, "--cache", cache_path, "build",
"test.py"
],
)
assert result.exit_code == 0, result.stdout
cache_path = pathlib.Path(cache_path) / "git"
assert cache_path.exists()
index_path = cache_path / "index.json"
assert index_path.exists()
rev_path = cache_path / (commit.name_rev.split(" ")[0] + ".json")
assert rev_path.exists()
# Write a test file to the repo
with open(tmppath / "test.py", "w") as test_txt:
test_txt.write("import abc\nfoo = 1")
index.add(["test.py"])
commit2 = index.commit("basic test", author=author, committer=committer)
repo.close()
result = runner.invoke(main.cli,
["--debug", "--path", tmpdir, "build", "test.py"])
assert result.exit_code == 0, result.stdout
assert cache_path.exists()
index_path = cache_path / "index.json"
assert index_path.exists()
rev_path = cache_path / (commit.name_rev.split(" ")[0] + ".json")
assert rev_path.exists()
rev_path2 = cache_path / (commit2.name_rev.split(" ")[0] + ".json")
assert rev_path2.exists()
def commit(date):
repo = Repo(search_parent_directories=True)
author = Actor('wirbot', '*****@*****.**')
committer = Actor('wirbot', '*****@*****.**')
repo.git.add('.')
repo.index.commit(f'Updates: {date}', author=author, committer=committer)
repo.git.push()
def init_repo2():
repo = Repo.init(os.path.join(REPOS_ROOT, "repo2"))
repo_file(repo, "bar.txt", "BAR")
repo.index.add([os.path.join(repo.working_dir, "bar.txt")])
commit = repo.index.commit("Commit 2",
committer=Actor("Committer2",
"*****@*****.**"),
author=Actor("Author2", "*****@*****.**"))
repo.create_head("master2", commit)
return IndividualRepo(repo.working_dir, "master2")
def test_git_end_to_end(tmpdir):
"""
Complete end-to-end test of the git integration
"""
repo = Repo.init(path=tmpdir)
tmppath = pathlib.Path(tmpdir)
index = repo.index
author = Actor("An author", "*****@*****.**")
committer = Actor("A committer", "*****@*****.**")
# First commit
with open(tmppath / ".gitignore", "w") as ignore:
ignore.write(".wily/")
index.add([".gitignore"])
commit1 = index.commit("commit1", author=author, committer=committer)
# Second commit
with open(tmppath / "test.py", "w") as file1:
file1.write("print(1)")
index.add(["test.py"])
commit2 = index.commit("commit2", author=author, committer=committer)
repo.close()
config = DEFAULT_CONFIG
config.path = tmpdir
archiver = GitArchiver(config)
assert archiver.config == config
revisions = archiver.revisions(tmpdir, 3)
assert len(revisions) == 2
assert revisions[0].message == "commit2"
assert revisions[0].author_email == "*****@*****.**"
assert revisions[0].author_name == "An author"
assert (
revisions[0].key in commit2.name_rev
and revisions[0].key not in commit1.name_rev
)
assert revisions[1].message == "commit1"
assert revisions[1].author_email == "*****@*****.**"
assert revisions[1].author_name == "An author"
assert (
revisions[1].key in commit1.name_rev
and revisions[1].key not in commit2.name_rev
)
checkout = archiver.checkout(revisions[1], None)
assert not (tmppath / "test.py").exists()
finish = archiver.finish()
assert (tmppath / "test.py").exists()
def make_commits(repo: Repo,
commits_data: list,
has_mirror: bool = False) -> list:
"""Loads commit data from JSON file and makes commits in given repo.
Args:
repo (`Repo`): git repo instance where commits will be made
commits_data (list): Contains the commit details to write
has_mirror (bool): Indicates whether to write to `.gitchmirror`
Returns:
list: list of dicts representing commits made
"""
# Simulate git add-commit workflow for each commit item
for i, commit_item in enumerate(commits_data):
changes = []
hexsha = commit_item["hexsha"]
message = commit_item["message"]
commit_dt = datetime.fromtimestamp(
commit_item["timestamp"]).isoformat()
# Create new file
fname = f"{i:05d}.txt"
fpath = os.path.join(repo.working_dir, fname)
with open(fpath, "w", encoding="utf-8") as f:
# Write commit message as file content
f.write(message)
changes.append(fpath)
# Write to .gitchmirror file
if has_mirror:
gpath = os.path.join(repo.working_dir, GITCHMFILE)
with open(gpath, "a+", encoding="utf-8") as g:
g.write(f"{hexsha}\n")
changes.append(gpath)
# Create author and committer
author = Actor(name=commit_item["author_name"],
email=commit_item["author_email"])
committer = Actor(
name=commit_item["committer_name"],
email=commit_item["committer_email"],
)
# Stage and commit the created file(s)
repo.index.add(changes)
repo.index.commit(
message=message,
author=author,
author_date=commit_dt,
committer=committer,
commit_date=commit_dt,
)
return commits_data
def add_and_commit(self, repo_dir, filename):
author = Actor("teaster", "*****@*****.**")
committer = Actor("teaster", "*****@*****.**")
repo = Repo('{}/{}'.format(docker_build_dir, repo_dir))
new_file_path = os.path.join(repo.working_tree_dir, filename)
repo.index.add([new_file_path])
repo.index.commit("added Dockerfile",
author=author,
committer=committer)
def test_repo_not_synced(self):
index = self.bp_repo.index
new_file_path = os.path.join(self.test_dir, "new-file-name")
open(new_file_path, "w").close()
index.add([new_file_path])
author = Actor("An author", "*****@*****.**")
committer = Actor("A committer", "*****@*****.**")
index.commit("my commit message", author=author, committer=committer)
self.assertFalse(self.bp_repo.is_current_branch_synced())
def test_operator_on_code_with_metric_named_objects(operator, tmpdir):
code_with_metric_named_objects = """
# CyclomaticComplexity
def complexity(): pass
# Halstead
def h1(): pass
def h2(): pass
def N1(): pass
def N2(): pass
def vocabulary(): pass
def length(): pass
def volume(): pass
def difficulty(): pass
def error(): pass
# Maintainability
def rank(): pass
def mi(): pass
# RawMetrics
def loc(): pass
def lloc(): pass
def sloc(): pass
def comments(): pass
def multi(): pass
def blank(): pass
def single_comments(): pass
"""
testpath = pathlib.Path(tmpdir) / "test.py"
author = Actor("An author", "*****@*****.**")
committer = Actor("A committer", "*****@*****.**")
with open(testpath, "w") as test_py:
test_py.write(dedent(code_with_metric_named_objects))
with Repo.init(path=tmpdir) as repo:
repo.index.add(["test.py"])
repo.index.commit("add test.py", author=author, committer=committer)
runner = CliRunner()
result = runner.invoke(
main.cli,
["--debug", "--path", tmpdir, "build",
str(testpath), "-o", operator],
catch_exceptions=False,
)
assert result.exit_code == 0, result.stdout
def test_build_with_config(tmpdir, cache_path):
"""
Test that build works in a basic repository and a configuration file.
"""
repo = Repo.init(path=tmpdir)
tmppath = pathlib.Path(tmpdir)
config = """
[wily]
path = test.py
operators = raw, maintainability
"""
config_path = tmppath / "wily.cfg"
with open(config_path, "w") as config_f:
config_f.write(config)
# Write a test file to the repo
with open(tmppath / "test.py", "w") as test_txt:
test_txt.write("import abc")
index = repo.index
index.add(["test.py"])
author = Actor("An author", "*****@*****.**")
committer = Actor("A committer", "*****@*****.**")
commit = index.commit("basic test", author=author, committer=committer)
repo.close()
runner = CliRunner()
result = runner.invoke(
main.cli,
[
"--debug",
"--config",
config_path,
"--path",
tmpdir,
"--cache",
cache_path,
"build",
],
)
assert result.exit_code == 0, result.stdout
cache_path = pathlib.Path(cache_path)
assert cache_path.exists()
index_path = cache_path / "git" / "index.json"
assert index_path.exists()
rev_path = cache_path / "git" / (commit.name_rev.split(" ")[0] + ".json")
assert rev_path.exists()
