def test_prints_committer_initials_only(self, mock_print):
committers = [
Committer(name='Name1', initials='initials1', email='email1'),
Committer(name='Name2', initials='initials2', email='email2')
]
committers_printer = CommittersPrinter(initials_only=True)
committers_printer.print(committers)
mock_print.assert_any_call('initials1, initials2')
def test_pretty_prints_committer_information(self, mock_print):
committers = [
Committer(name='Name1', initials='initials1', email='email1'),
Committer(name='Name2', initials='initials2', email='email2')
]
committers_printer = CommittersPrinter(initials_only=False)
committers_printer.print(committers)
mock_print.assert_any_call('initials1 - Name1 <email1>')
mock_print.assert_any_call('initials2 - Name2 <email2>')
def test_roates_first_committer_to_last(self):
current_committers = Mock()
first = Committer('name1', 'email1', 'initials1')
second = Committer('name2', 'email2', 'initials2')
current_committers.get.return_value = [first, second]
hook = PostCommit(current_committers)
hook.play([])
current_committers.set.assert_called_with([second, first])
def test_execute_ignores_case_when_finding_committers(self):
current_committers = Mock()
committers = Mock()
action = SetCommittersAction(committers, current_committers)
first = Committer('name', 'email', 'first')
second = Committer('name', 'email', 'second')
committers.all.return_value = [first, second]
action.execute(['first', 'SECOND'])
current_committers.set.assert_called_with([first, second])
def test_appends_current_committer_coauthored_lines_to_message_text(self):
committer1 = Committer('name1', 'email1', 'initials1')
committer2 = Committer('name2', 'email2', 'initials2')
lines = ['Commit message']
result = append_committers([committer1, committer2], lines)
self.assertEqual([
'Commit message', '', 'Co-authored-by: name1 <email1>',
'Co-authored-by: name2 <email2>'
], result)
def test_writes_committer_initials_and_current_time_to_committers_set_file(
self, mock_time, mock_write_lines, all_committers_set):
all_committers_set.return_value = []
mock_time.return_value = 1000000000
set_current_committers([
Committer('name', 'email', 'initials1'),
Committer('name', 'email', 'initials2')
], Path('/path/to/project/.git'))
formatted_path = str(Path('/path/to/project/.git'))
mock_write_lines.assert_called_with(
Path(join(CONFIGURATION_DIRECTORY, constants.COMMITTERS_SET)),
[f'initials1,initials2,1000000000000,{formatted_path}'])
def test_all_sorts_committers_alphabetically_by_initials(self):
mock_state = Mock()
second = Committer('name1', 'email1', 'z')
first = Committer('name2', 'email2', 'a')
mock_state.all.return_value = [second, first]
committers = Committers(Mock())
committers.current_state = mock_state
found = committers.all()
self.assertEqual(found, [first, second])
def test_replace_already_present_co_authored_messages(self):
committer1 = Committer('name3', 'email3', 'initials3')
committer2 = Committer('name4', 'email4', 'initials4')
lines = [
'Commit message', '', 'Co-authored-by: name1 <email1>',
'Co-authored-by: name2 <email2>'
]
result = append_committers([committer1, committer2], lines)
self.assertEqual([
'Commit message', '', 'Co-authored-by: name3 <email3>',
'Co-authored-by: name4 <email4>'
], result)
def test_add_overwrites_commiter_with_same_initials(self):
file_system = Mock()
committers_file = Mock()
file_system.get.return_value = committers_file
found = Committer(initials='initials1', name='name1', email='email1')
state = GlobalCommittersState(file_system)
state.all = Mock(return_value=[found])
state.remove = Mock()
state.add(Committer('name2', 'email2', 'initials1'))
state.remove.assert_called_with('initials1')
def test_execute_prints_set_committers(self, mock_print):
current_committers = Mock()
committers = Mock()
action = SetCommittersAction(committers, current_committers)
first = Committer('name', 'email', 'first')
second = Committer('name', 'email', 'second')
committers.all.return_value = [first, second]
action.execute(['first'])
mock_print.assert_has_calls(
[call('Committers set to:'),
call('first - name <email>')])
def test_all_gives_local_committers_precedence(self):
file_system = Mock()
global_state: GlobalCommittersState = Mock()
committer = Committer('name1', 'email1', 'initials')
global_state.all = Mock(return_value=[committer])
local = Committer('name2', 'email2', 'initials')
state = LocalCommittersState(file_system, global_state)
state._all_local_committers = Mock(return_value=[local])
result = state.all()
self.assertEqual([local], result)
def test_prints_list_of_committers(self, mock_print):
committers = Mock()
action = GetCommittersAction(committers, Mock())
committers.all = Mock(return_value=[
Committer('name1', 'email1', 'initials1'),
Committer('name2', 'email2', 'initials2'),
])
action.execute(['all'])
mock_print.assert_has_calls([
call('All committers'),
call('initials1 - name1 <email1>'),
call('initials2 - name2 <email2>'),
])
def test_add_saves_new_committer_to_file(self):
file_system = Mock()
committers_file = Mock()
file_system.get.return_value = committers_file
found = Committer(initials='initials1', name='name1', email='email1')
state = GlobalCommittersState(file_system)
state.all = Mock(return_value=[found])
state.add(Committer('name2', 'email2', 'initials2'))
committers_file.write.assert_called_with([
'initials1,name1,email1',
'initials2,name2,email2',
])
def test_doesnt_append_coauthored_lines_if_only_one_committer(self):
committer1 = Committer('name1', 'email1', 'initials1')
lines = ['Commit message']
result = append_committers([committer1], lines)
self.assertEqual(['Commit message'], result)
def test_all_includes_all_local_committers_and_global_committers(self, _):
committers_file = Mock()
committers_file.read.return_value = ['initials2,name2,email2']
file_system = Mock()
file_system.get.return_value = committers_file
global_state: GlobalCommittersState = Mock()
global_committer = Committer('name1', 'email1', 'initial1')
global_state.all = Mock(return_value=[global_committer])
state = LocalCommittersState(file_system, global_state)
result = state.all()
local = Committer('name2', 'email2', 'initials2')
self.assertEqual([global_committer, local], result)
def test_set_sets_current_committers(self, set_current_committers,
mock_project_root):
to_set = [Committer('name', 'email', 'initials')]
current = CurrentCommitters(Mock(), Mock())
current.set(to_set)
set_current_committers.assert_called_with(
to_set, mock_project_root.return_value)
def test_prints_list_of_currently_set_committers(self, mock_print):
current = Mock()
action = GetCommittersAction(Mock(), current)
current.get = Mock(return_value=[
Committer('name1', 'email1', 'initials1'),
Committer('name2', 'email2', 'initials2'),
])
action.execute(['current'])
mock_print.assert_has_calls([
call('Current committers'),
call('initials1 - name1 <email1>'),
call('initials2 - name2 <email2>'),
])
def test_overwrites_set_initials_if_git_path_matches(
self, mock_time, mock_write_lines, all_committers_set):
all_committers_set.return_value = [
CommittersSet(['initials1', 'initials2'], 1000000,
Path('/path/to/project/.git')),
]
mock_time.return_value = 1000000000
set_current_committers([
Committer('name', 'email', 'initials3'),
Committer('name', 'email', 'initials4')
], Path('/path/to/project/.git'))
formatted_path = str(Path('/path/to/project/.git'))
lines = [f'initials3,initials4,1000000000000,{formatted_path}']
mock_write_lines.assert_called_with(
Path(join(CONFIGURATION_DIRECTORY, constants.COMMITTERS_SET)),
lines)
def test_set_passes_committers_to_observers(self, _1, _2):
observer = Mock()
to_set = [Committer('name', 'email', 'initials')]
current = CurrentCommitters(Mock(), Mock())
current.register_observer(observer)
current.set(to_set)
observer.on_new_committers.assert_called_with(to_set)
def test_adds_given_committer_initials_to_committers_set_file(
self, mock_time, mock_write_lines, all_committers_set):
all_committers_set.return_value = [
CommittersSet(['initials3', 'initials4'], 1000000000000,
Path('/absolute/path/to/other/.git')),
]
mock_time.return_value = 1000000000
set_current_committers([
Committer('name', 'email', 'initials1'),
Committer('name', 'email', 'initials2')
], Path('/path/to/project/.git'))
lines = [
f'initials3,initials4,1000000000000,{str(Path("/absolute/path/to/other/.git"))}',
f'initials1,initials2,1000000000000,{str(Path("/path/to/project/.git"))}'
]
mock_write_lines.assert_called_with(
Path(join(CONFIGURATION_DIRECTORY,
constants.COMMITTERS_SET)).absolute(), lines)
def test_add_saves_new_committer_to_file(self):
committers_file = Mock()
file_system = Mock()
file_system.get.return_value = committers_file
found = Committer(initials='initials1', name='name1', email='email1')
global_state: GlobalCommittersState = Mock()
state = LocalCommittersState(file_system, global_state)
state._all_local_committers = Mock(return_value=[found])
state._local_committer_present = Mock(return_value=None)
state.add(Committer('name2', 'email2', 'initials2'))
committers_file.write.assert_called_with([
'initials1,name1,email1',
'initials2,name2,email2',
])
def test_by_initials_finds_committer_with_given_initials(self):
file_system = Mock()
state = GlobalCommittersState(file_system)
found = Committer(initials='initials1', name='name1', email='email1')
state.all = Mock(return_value=[found])
result = state.by_initials('initials1')
self.assertEqual(result, found)
def test_add_warns_when_local_committer_will_shadow_global_committer(
self, mock_print):
committers_file = Mock()
file_system = Mock()
file_system.get.return_value = committers_file
found = Committer(initials='initials1', name='name1', email='email1')
global_state: GlobalCommittersState = Mock()
global_state.by_initials.return_value = found
state = LocalCommittersState(file_system, global_state)
state._all_local_committers = Mock(return_value=[])
state.add(Committer('name2', 'email2', 'initials1'))
mock_print.assert_called_with(
('Adding committer with initials "initials1" will '
'overshadow global committer with same initials.'))
def test_handles_only_one_committer(self):
current_committers = Mock()
first = Committer('name1', 'email1', 'initials1')
current_committers.get.return_value = [first]
hook = PostCommit(current_committers)
hook.play([])
current_committers.set.assert_not_called()
def test_execute_sets_commit_message_to_current_committers(self):
current_committers = Mock()
current_committers.get = Mock(return_value=[
Committer('name1', 'email1', 'initials1'),
Committer('name2', 'email2', 'initials2'),
])
git = Mock()
git.commit_msg = ['initial commit']
action = CommitMsg(current_committers, git)
action.execute([])
self.assertEqual(git.commit_msg, [
'initial commit',
'',
'Co-authored-by: name1 <email1>',
'Co-authored-by: name2 <email2>',
])
def test_execute_sets_committers(self):
current_committers = Mock()
committers = Mock()
action = SetCommittersAction(committers, current_committers)
committer = Committer('name', 'email', 'first')
committers.all.return_value = [committer]
action.execute(['first'])
current_committers.set.assert_called_with([committer])
def test_overwriting_should_not_stop(self, mock_input, mock_print):
committers = Mock()
preparation = OverwritingCommitterCheck(committers)
committer = Committer(initials='initials',
name='name1',
email='email1')
committers.by_initials.return_value = committer
self.assertFalse(
preparation.should_stop(['initials', 'name2', 'email2']))
def test_all_reads_all_committers_from_config_committers_file(self):
file_system = Mock()
committers_file = Mock()
committers_file.read.return_value = ['initials1,name1,email1']
file_system.get.return_value = committers_file
state = GlobalCommittersState(file_system)
result = state.all()
self.assertEqual(
result,
[Committer(initials='initials1', name='name1', email='email1')])
def test_remove_removes_committer(self):
file_system = Mock()
committers_file = Mock()
file_system.get.return_value = committers_file
found = Committer(initials='initials1', name='name1', email='email1')
state = LocalCommittersState(file_system, Mock())
state._all_local_committers = Mock(return_value=[found])
state.remove('initials1')
committers_file.write.assert_called_with([])
def test_should_remove_overwritten_committer_if_given_y(
self, mock_input, mock_print):
committers = Mock()
preparation = OverwritingCommitterCheck(committers)
committer = Committer(initials='initials',
name='name1',
email='email1')
committers.by_initials.return_value = committer
preparation.should_stop(['initials', 'name2', 'email2'])
committers.remove.assert_called_with(committer.initials)
