def test_updates_pid_values_on_control(self, pid_mock_class):
pid_mock = pid_mock_class.return_value
tunings_mock = PropertyMock()
type(pid_mock).tunings = tunings_mock
tunings_mock.return_value = (1, 2, 3)
components_mock = PropertyMock()
type(pid_mock).components = components_mock
components_mock.return_value = (4, 3, 2)
controller = Controller(self.config, 5, 0.5, self.heater, self.cooler,
self.limiter, self.current_temp,
self.fridge_temp, [])
self.config.get.side_effect = lambda key: {
"p": 4,
"i": 5,
"d": 6,
"target": 23,
"heating_limit": 40,
"limit_window": 5
}.get(key)
pid_mock.return_value = 5
controller.control()
tunings_mock.assert_called_with((4, 5, 6))
def test_switch_heating_and_cooling_without_threshold(
self, pid_mock_class, control, h_current, h_switch, c_current,
c_switch):
pid_mock = pid_mock_class.return_value
self.heater.get.return_value = h_current
self.cooler.get.return_value = c_current
pid_mock.return_value = control
tunings_mock = PropertyMock()
type(pid_mock).tunings = tunings_mock
tunings_mock.return_value = (1, 2, 3)
components_mock = PropertyMock()
type(pid_mock).components = components_mock
components_mock.return_value = (4, 3, 2)
controller = Controller(self.config, 5, 0, self.heater, self.cooler,
self.limiter, self.current_temp,
self.fridge_temp, [])
controller.control()
if h_switch is None:
self.heater.set.assert_not_called()
else:
self.heater.set.assert_called_with(h_switch)
if c_switch is None:
self.cooler.set.assert_not_called()
else:
self.cooler.set.assert_called_with(c_switch)
def test_step_visibility(self, _step: PropertyMock):
"""Should return values from the internal _step object."""
_step.return_value = MagicMock(is_visible=True)
es = exposed.ExposedStep()
self.assertTrue(es.visible)
es.visible = False
self.assertFalse(es.visible)
def test_step_visibility(self, _step: PropertyMock):
"""Should return values from the internal _step object."""
_step.return_value = MagicMock(is_visible=True)
es = exposed.ExposedStep()
self.assertTrue(es.visible)
es.visible = False
self.assertFalse(es.visible)
def test_check_reorgs(self, current_block_number_mock: PropertyMock,
get_block_mock: MagicMock):
reorg_service = ReorgServiceProvider()
block = block_child
block_number = block["number"]
def get_block_fn(number: int, full_transactions=False):
if number == block_number:
return block_child
if number == block_number + 1:
return block_parent
get_block_mock.side_effect = get_block_fn
current_block_number = block_number + 100
current_block_number_mock.return_value = current_block_number
ethereum_block: EthereumBlock = EthereumBlockFactory(
number=block_number, confirmed=False)
self.assertEqual(reorg_service.check_reorgs(), block_number)
ethereum_block.block_hash = block["hash"]
ethereum_block.save(update_fields=["block_hash"])
self.assertIsNone(reorg_service.check_reorgs())
ethereum_block.refresh_from_db()
self.assertTrue(ethereum_block.confirmed)
def testRunner(self):
# Verify BatchTrial without runner will fail
with self.assertRaises(ValueError):
self.batch.run()
# Verify mark running without runner will fail
with self.assertRaises(ValueError):
self.batch.mark_running()
self.batch.runner = SyntheticRunner()
self.batch.run()
self.assertEqual(self.batch.deployed_name, "test_0")
self.assertNotEqual(len(self.batch.run_metadata.keys()), 0)
self.assertEqual(self.batch.status, TrialStatus.RUNNING)
# Verify setting runner on experiment but not BatchTrial
# Also mock staging_required to be false
staging_mock = PropertyMock()
with patch.object(SyntheticRunner, "staging_required", staging_mock):
mock_runner = SyntheticRunner()
staging_mock.return_value = True
self.experiment.runner = mock_runner
b2 = self.experiment.new_batch_trial()
b2.run()
self.assertEqual(b2.deployed_name, "test_1")
self.assertEqual(b2.status, TrialStatus.STAGED)
def test_get_installed_local(self):
"""Test get_installed_local used to find
installed napps in local machine"""
# Mock kytos.json path
mock_path = Mock()
def glob_side_effect(args):
"""Path.glob to mock finding paths with kytos.json file."""
self.assertEqual(args, "*/*/kytos.json")
mock_path1 = Mock()
mock_path1.parts = ['kytos', 'of_core', 'kytos.json']
return [mock_path1]
mock_path.glob = glob_side_effect
mock_prop_installed = PropertyMock()
with patch.object(NAppsManager, '_installed', mock_prop_installed):
mock_prop_installed.return_value = mock_path
get_return = self.napps_manager.get_installed_local()
self.assertEqual(get_return[0][0], 'kytos')
self.assertEqual(get_return[0][1], 'of_core')
self.assertEqual(mock_prop_installed.call_count, 1)
async def test_get_commits_to_cherry_pick_merge(
commits: mock.PropertyMock,
context_getter: conftest.ContextGetterFixture,
) -> None:
c1 = github_types.CachedGitHubBranchCommit({
"sha":
github_types.SHAType("c1f"),
"parents": [],
"commit_message":
"foobar",
"commit_verification_verified":
False,
})
c2 = github_types.CachedGitHubBranchCommit({
"sha":
github_types.SHAType("c2"),
"parents": [c1["sha"]],
"commit_message":
"foobar",
"commit_verification_verified":
False,
})
async def fake_commits(
) -> typing.List[github_types.CachedGitHubBranchCommit]:
return [c1, c2]
commits.return_value = fake_commits()
client = mock.Mock()
client.auth.get_access_token.return_value = "<token>"
ctxt = await context_getter(github_types.GitHubPullRequestNumber(1))
ctxt.repository.installation.client = client
base_branch = github_types.CachedGitHubBranchCommit({
"sha":
github_types.SHAType("base_branch"),
"parents": [],
"commit_message":
"foobar",
"commit_verification_verified":
False,
})
merge_commit = github_types.CachedGitHubBranchCommit({
"sha":
github_types.SHAType("merge_commit"),
"parents": [base_branch["sha"], c2["sha"]],
"commit_message":
"foobar",
"commit_verification_verified":
False,
})
assert await duplicate_pull._get_commits_to_cherrypick(ctxt,
merge_commit) == [
c1,
c2,
]
def test_step_stop_aborted(self, _step: PropertyMock):
"""
Should abort stopping and not raise an error when no internal step
is available to stop.
"""
_step.return_value = None
es = exposed.ExposedStep()
es.stop()
def interpolation_method(mocker, method):
# This uses the pytest-mock package in order to provide a fixture that will
# mock the global variable in the image module that determines if OpenCV
# should be used or not. Useful for running the unit tests with and without
# opencv
interp = PropertyMock()
interp.return_value = method
mocker.patch("menpo.image.base.cv2_perspective_interpolation", new_callable=interp)
def test_step_stop_aborted(self, _step: PropertyMock):
"""
Should abort stopping and not raise an error when no internal step
is available to stop.
"""
_step.return_value = None
es = exposed.ExposedStep()
es.stop()
def test_write_to_console_fail(self, _step: PropertyMock):
"""
Should raise a ValueError when there is no current step to operate
upon by the write function call.
"""
_step.return_value = None
step = exposed.ExposedStep()
with self.assertRaises(ValueError):
step.write_to_console('hello')
def test_write_to_console_fail(self, _step: PropertyMock):
"""
Should raise a ValueError when there is no current step to operate
upon by the write function call.
"""
_step.return_value = None
step = exposed.ExposedStep()
with self.assertRaises(ValueError):
step.write_to_console('hello')
def test_step_properties(self, _step: PropertyMock):
"""Should return values from the internal _step object."""
now = datetime.utcnow()
_step.return_value = MagicMock(start_time=now,
end_time=now,
elapsed_time=0)
es = exposed.ExposedStep()
self.assertEqual(now, es.start_time)
self.assertEqual(now, es.end_time)
self.assertEqual(0, es.elapsed_time)
def test_only_updates_pid_values_if_changed(self, pid_mock_class):
pid_mock = pid_mock_class.return_value
tunings_mock = PropertyMock()
type(pid_mock).tunings = tunings_mock
tunings_mock.return_value = (1, 2, 3)
components_mock = PropertyMock()
type(pid_mock).components = components_mock
components_mock.return_value = (4, 3, 2)
controller = Controller(self.config, 5, 0.5, self.heater, self.cooler,
self.limiter, self.current_temp,
self.fridge_temp, [])
pid_mock.return_value = 5
controller.control()
tunings_mock.assert_called_once_with() # the getter, not the setter
def test_publishes_to_listeners(self, pid_mock_class):
pid_mock = pid_mock_class.return_value
tunings_mock = PropertyMock()
type(pid_mock).tunings = tunings_mock
tunings_mock.return_value = (1, 2, 3)
components_mock = PropertyMock()
type(pid_mock).components = components_mock
components_mock.return_value = (4, 3, 2)
controller = Controller(self.config, 5, 0.5, self.heater, self.cooler,
self.limiter, self.current_temp,
self.fridge_temp, [self.listener])
pid_mock.return_value = .4
controller.control()
self.listener.handle_controller.assert_called_with(4, 3, 2, .4)
def testBatchLifecycle(self):
staging_mock = PropertyMock()
with patch.object(SyntheticRunner, "staging_required", staging_mock):
mock_runner = SyntheticRunner()
staging_mock.return_value = True
self.batch.runner = mock_runner
self.batch.run()
self.assertEqual(self.batch.status, TrialStatus.STAGED)
self.assertIsNotNone(self.batch.time_staged)
self.assertTrue(self.batch.status.is_deployed)
self.assertFalse(self.batch.status.expecting_data)
# Cannot change arms or runner once run
with self.assertRaises(ValueError):
self.batch.add_arms_and_weights(arms=self.arms,
weights=self.weights)
with self.assertRaises(ValueError):
self.batch.runner = None
# Cannot run batch that was already run
with self.assertRaises(ValueError):
self.batch.run()
self.batch.mark_running()
self.assertEqual(self.batch.status, TrialStatus.RUNNING)
self.assertIsNotNone(self.batch.time_run_started)
self.assertTrue(self.batch.status.expecting_data)
self.batch.complete()
# Cannot complete that which is already completed
with self.assertRaises(ValueError):
self.batch.complete()
# Verify trial is completed
self.assertEqual(self.batch.status, TrialStatus.COMPLETED)
self.assertIsNotNone(self.batch.time_completed)
self.assertTrue(self.batch.status.is_terminal)
# Cannot change status after BatchTrial is completed
with self.assertRaises(ValueError):
self.batch.mark_staged()
with self.assertRaises(ValueError):
self.batch.mark_completed()
with self.assertRaises(ValueError):
self.batch.mark_running()
with self.assertRaises(ValueError):
self.batch.mark_abandoned()
with self.assertRaises(ValueError):
self.batch.mark_failed()
def test_alt_return():
filer_image = mock.Mock(name='FilerImage', spec=True)
original_filename = PropertyMock(name='original_filename')
type(filer_image).original_filename = original_filename
original_filename.return_value = 'foo'
result = FilerImageAdapter().alt(filer_image)
assert result == 'foo'
# It's 2 because once for checking if the attribute exists and once for returning it
assert original_filename.call_count == 2
def test_alt_empty_return():
""" Douplex doesn't support mocked properties on free doubles so we need to use the standard mock library """
filer_image = mock.Mock(name='FilerImage', spec=True)
original_filename = PropertyMock(name='original_filename')
type(filer_image).original_filename = original_filename
original_filename.return_value = None
name = PropertyMock(name='name')
type(filer_image).name = name
name.return_value = None
default_alt_text = PropertyMock(name='default_alt_text')
type(filer_image).default_alt_text = default_alt_text
default_alt_text.return_value = None
result = FilerImageAdapter().alt(filer_image)
assert result == ''
assert original_filename.call_count == 1
assert name.call_count == 1
assert default_alt_text.call_count == 1
def test_get_internal_project_fail(self, sleep: MagicMock,
time_time: MagicMock,
internal_project: PropertyMock):
"""
Should fail to get internal project and return None after
eventually timing out.
"""
project = exposed.ExposedProject()
time_time.side_effect = range(20)
internal_project.return_value = None
result = project.get_internal_project()
self.assertIsNone(result)
self.assertEqual(10, sleep.call_count)
def test_step_properties(self, _step: PropertyMock):
"""Should return values from the internal _step object."""
now = datetime.utcnow()
_step.return_value = MagicMock(
start_time=now,
end_time=now,
elapsed_time=0,
is_visible=True
)
es = exposed.ExposedStep()
self.assertEqual(now, es.start_time)
self.assertEqual(now, es.end_time)
self.assertEqual(0, es.elapsed_time)
def test_dont_switch_heating_on_if_under_heating_threshold(
self, pid_mock_class):
pid_mock = pid_mock_class.return_value
self.heater.get.return_value = False
pid_mock.return_value = 0.4
tunings_mock = PropertyMock()
type(pid_mock).tunings = tunings_mock
tunings_mock.return_value = (1, 2, 3)
components_mock = PropertyMock()
type(pid_mock).components = components_mock
components_mock.return_value = (4, 3, 2)
controller = Controller(self.config, 5, 0.5, self.heater, self.cooler,
self.limiter, self.current_temp,
self.fridge_temp, [])
controller.control()
self.heater.set.assert_not_called()
def test_feeds_current_temperature_to_pid(self, pid_mock_class):
pid_mock = pid_mock_class.return_value
current_temp = Mock()
self.current_temp.get_average.return_value = current_temp
tunings_mock = PropertyMock()
type(pid_mock).tunings = tunings_mock
tunings_mock.return_value = (1, 2, 3)
components_mock = PropertyMock()
type(pid_mock).components = components_mock
components_mock.return_value = (4, 3, 2)
controller = Controller(self.config, 5, 0.5, self.heater, self.cooler,
self.limiter, self.current_temp,
self.fridge_temp, [])
pid_mock.return_value = 5
controller.control()
pid_mock.assert_called_with(current_temp)
def test_run_calls_submit_task_for_each_sensor(self, psubmit_task, prun):
sensors_collection = [[MagicMock() for _ in range(num)]
for num in range(4)]
mocked_sensors = PropertyMock()
type(self.simple_instance).sensors = mocked_sensors
for sensors in sensors_collection:
expected_calls = [
call(sensor, self.simple_instance._sensors_queue)
for sensor in sensors
]
mocked_sensors.return_value = sensors
#self.simple_instance.sensors = sensors
self.simple_instance.run()
psubmit_task.assert_has_calls(expected_calls, any_order=True)
def test_switch_off_heating_if_over_heating_limit(self, pid_mock_class,
fridge_temperature,
cb_current, cb_switch,
h_current, h_switch):
pid_mock = pid_mock_class.return_value
self.fridge_temp.get.return_value = fridge_temperature
self.heater.get.return_value = h_current
self.cooler.get.return_value = False
self.limiter.get.return_value = cb_current
pid_mock.return_value = 3 # would trigger the heater
tunings_mock = PropertyMock()
type(pid_mock).tunings = tunings_mock
tunings_mock.return_value = (1, 2, 3)
components_mock = PropertyMock()
type(pid_mock).components = components_mock
components_mock.return_value = (4, 3, 2)
controller = Controller(self.config, 5, 0, self.heater, self.cooler,
self.limiter, self.current_temp,
self.fridge_temp, [])
controller.control()
if cb_switch is None:
self.limiter.set.assert_not_called()
else:
self.limiter.set.assert_called_with(cb_switch)
if h_switch is None:
self.heater.set.assert_not_called()
else:
self.heater.set.assert_called_with(h_switch)
def test_compare_generated_with_data(mock_permalink_as_str: PropertyMock,
layout_description: LayoutDescription,
echoes_pickup_database: PickupDatabase):
debug._DEBUG_LEVEL = 0
status_update = MagicMock()
mock_permalink_as_str.return_value = "fixed-seed!"
generated_description = generator.generate_list(
layout_description.permalink, status_update=status_update, timeout=None)
indices: List[int] = [None] * echoes_pickup_database.total_pickup_count
for index, pickup in generated_description.patches.pickup_assignment.items():
indices[index.index] = echoes_pickup_database.original_index(pickup).index
print(indices)
assert generated_description.without_solver_path == layout_description
def test_get_internal_project_fail(
self,
sleep: MagicMock,
time_time: MagicMock,
internal_project: PropertyMock
):
"""
Should fail to get internal project and return None after
eventually timing out.
"""
project = exposed.ExposedProject()
time_time.side_effect = range(20)
internal_project.return_value = None
result = project.get_internal_project()
self.assertIsNone(result)
self.assertEqual(10, sleep.call_count)
def test_render_to_console(self, _step: PropertyMock):
"""
Should render to the console using a write_source function
call on the internal step report's stdout_interceptor.
"""
message = ' {{ a }} is not {{ b }}.'
_step_mock = MagicMock()
write_source = MagicMock()
_step_mock.report.stdout_interceptor.write_source = write_source
_step.return_value = _step_mock
step = exposed.ExposedStep()
step.render_to_console(message, a=7, b='happy')
args, kwargs = write_source.call_args
self.assertEqual('7 is not happy.', args[0])
async def test_queue_cleanup(mocker, conduit_mock, sparky, app):
mocker.patch(TESTED + '.CLEANUP_INTERVAL', timedelta(milliseconds=10))
fresh_mock = PropertyMock(return_value=True)
type(commander.TimestampedQueue()).fresh = fresh_mock
await sparky.startup(app)
await sparky._on_data(conduit_mock, '05 00 |00 00 00')
# Still fresh
await asyncio.sleep(0.1)
assert len(sparky._requests) == 1
# Assert stale was removed
fresh_mock.return_value = False
await asyncio.sleep(0.1)
assert len(sparky._requests) == 0
def test_write_to_console(self, _step: PropertyMock):
"""
Should write to the console using a write_source function
call on the internal step report's stdout_interceptor.
"""
trials = [2, True, None, 'This is a test', b'hello']
for message in trials:
_step_mock = MagicMock()
write_source = MagicMock()
_step_mock.report.stdout_interceptor.write_source = write_source
_step.return_value = _step_mock
step = exposed.ExposedStep()
step.write_to_console(message)
args, kwargs = write_source.call_args
self.assertEqual('{}'.format(message), args[0])
def test_write_to_console(self, _step: PropertyMock):
"""
Should write to the console using a write_source function
call on the internal step report's stdout_interceptor.
"""
trials = [2, True, None, 'This is a test', b'hello']
for message in trials:
_step_mock = MagicMock()
write_source = MagicMock()
_step_mock.report.stdout_interceptor.write_source = write_source
_step.return_value = _step_mock
step = exposed.ExposedStep()
step.write_to_console(message)
args, kwargs = write_source.call_args
self.assertEqual('{}'.format(message), args[0])
def test_compare_generated_with_data(mock_permalink_as_str: PropertyMock,
layout_description: LayoutDescription):
debug.set_level(0)
status_update = MagicMock()
mock_permalink_as_str.return_value = "fixed-seed!"
generated_description = generator.generate_description(
layout_description.permalink,
status_update=status_update,
validate_after_generation=True,
timeout=None)
# indices: List[int] = [None] * echoes_pickup_database.total_pickup_count
# for index, pickup in generated_description.patches.pickup_assignment.items():
# indices[index.index] = echoes_pickup_database.original_index(pickup).index
# print(indices)
assert generated_description.without_solver_path == layout_description
def test_output_name_for(mock_shareable_hash: PropertyMock, empty_patches):
# Setup
permalink_mock = MagicMock(spec=Permalink(
seed_number=15000,
spoiler=True,
preset=None,
))
layout = LayoutDescription(version="0.15.0",
permalink=permalink_mock,
patches=empty_patches,
solver_path=())
mock_shareable_hash.return_value = "PermalinkStr"
# Run
result = simplified_patcher._output_name_for(layout)
# Assert
assert result == "Echoes Randomizer - PermalinkStr"
def test_check_reorgs(self, current_block_number_mock: PropertyMock,
get_block_mock: MagicMock):
reorg_service = ReorgServiceProvider()
block = block_result[0]
block_number = block['number']
get_block_mock.return_value = block
current_block_number = block_number + 100
current_block_number_mock.return_value = current_block_number
ethereum_block: EthereumBlock = EthereumBlockFactory(
number=block_number, confirmed=False)
self.assertEqual(reorg_service.check_reorgs(), block_number)
ethereum_block.block_hash = block['hash']
ethereum_block.save(update_fields=['block_hash'])
self.assertIsNone(reorg_service.check_reorgs())
ethereum_block.refresh_from_db()
self.assertTrue(ethereum_block.confirmed)
def test_datpiff_player_response(self):
# test DatpiffPlayer response return correct request response
# when dpp_link is set correctly
with patch.object(mediasetup, "Album", autospec=True) as dp:
link = PropertyMock(return_value=dp_real_link)
dp.dpp_link = link
dp.datpiff_player_response = PropertyMock(
return_value=mocked_session.text)
self.assertEqual(dummy_text,
dp.datpiff_player_response.return_value)
with patch.object(mediasetup.Album,
"dpp_link",
new_callable=PropertyMock) as link:
# test DatpiffPlayer link is return correct value
link.return_value = dp_real_link
dp = self.dp
dp.dpp_link = link
self.assertEqual(dp_real_link, self.dp.dpp_link)
def test_is_service_synced(self, current_block_number_mock: PropertyMock):
current_block_number_mock.return_value = 500
self.assertTrue(self.index_service.is_service_synced())
reorg_blocks = self.index_service.eth_reorg_blocks
safe_master_copy = SafeMasterCopyFactory(
tx_block_number=current_block_number_mock.return_value -
reorg_blocks - 1)
self.assertFalse(self.index_service.is_service_synced())
safe_master_copy.tx_block_number = safe_master_copy.tx_block_number + 1
safe_master_copy.save(update_fields=["tx_block_number"])
self.assertTrue(self.index_service.is_service_synced())
safe_contract = SafeContractFactory(
erc20_block_number=current_block_number_mock.return_value -
reorg_blocks - 1)
self.assertFalse(self.index_service.is_service_synced())
safe_contract.erc20_block_number = safe_contract.erc20_block_number + 1
safe_contract.save(update_fields=["erc20_block_number"])
self.assertTrue(self.index_service.is_service_synced())
# Less than 10% of contracts out of sync will be alright (by default). Try with 1 of 20 out of sync
SafeContract.objects.all().delete()
SafeContractFactory(
erc20_block_number=current_block_number_mock.return_value -
reorg_blocks - 1)
for _ in range(19):
safe_contract_synced = SafeContractFactory(
erc20_block_number=current_block_number_mock.return_value -
reorg_blocks)
self.assertTrue(self.index_service.is_service_synced())
# Set one more of sync, so 2 of 20 out of sync
safe_contract_synced.erc20_block_number -= 1
safe_contract_synced.save(update_fields=["erc20_block_number"])
self.assertFalse(self.index_service.is_service_synced())
async def test_get_commits_to_cherry_pick_rebase(
commits: mock.PropertyMock,
redis_cache: utils.RedisCache,
) -> None:
gh_owner = github_types.GitHubAccount({
"login":
github_types.GitHubLogin("user"),
"id":
github_types.GitHubAccountIdType(0),
"type":
"User",
"avatar_url":
"",
})
gh_repo = github_types.GitHubRepository({
"full_name":
"user/name",
"name":
github_types.GitHubRepositoryName("name"),
"private":
False,
"id":
github_types.GitHubRepositoryIdType(0),
"owner":
gh_owner,
"archived":
False,
"url":
"",
"html_url":
"",
"default_branch":
github_types.GitHubRefType("ref"),
})
c1 = github_types.GitHubBranchCommit({
"sha": github_types.SHAType("c1f"),
"parents": [],
"commit": {
"message": "foobar"
},
})
c2 = github_types.GitHubBranchCommit({
"sha": github_types.SHAType("c2"),
"parents": [c1],
"commit": {
"message": "foobar"
},
})
commits.return_value = [c1, c2]
client = mock.Mock()
client.auth.get_access_token.return_value = "<token>"
client.items.side_effect = fake_get_github_pulls_from_sha
installation = context.Installation(
github_types.GitHubAccountIdType(123),
github_types.GitHubLogin("user"),
subscription.Subscription(redis_cache, 0, False, "", frozenset()),
client,
redis_cache,
)
repository = context.Repository(installation, gh_repo)
ctxt = await context.Context.create(
repository,
{
"labels": [],
"draft": False,
"merge_commit_sha": github_types.SHAType(""),
"title": "",
"commits": 1,
"rebaseable": False,
"maintainer_can_modify": False,
"id": github_types.GitHubPullRequestId(0),
"number": github_types.GitHubPullRequestNumber(6),
"merged": True,
"state": "closed",
"html_url": "<html_url>",
"changed_files": 1,
"base": {
"label": "",
"sha": github_types.SHAType("sha"),
"user": {
"login": github_types.GitHubLogin("user"),
"id": github_types.GitHubAccountIdType(0),
"type": "User",
"avatar_url": "",
},
"ref": github_types.GitHubRefType("ref"),
"repo": {
"full_name": "user/ref",
"name": github_types.GitHubRepositoryName("name"),
"private": False,
"id": github_types.GitHubRepositoryIdType(0),
"owner": {
"login": github_types.GitHubLogin("user"),
"id": github_types.GitHubAccountIdType(0),
"type": "User",
"avatar_url": "",
},
"archived": False,
"url": "",
"html_url": "",
"default_branch": github_types.GitHubRefType(""),
},
},
"head": {
"label": "",
"sha": github_types.SHAType("sha"),
"ref": github_types.GitHubRefType("fork"),
"user": {
"login": github_types.GitHubLogin("user"),
"id": github_types.GitHubAccountIdType(0),
"type": "User",
"avatar_url": "",
},
"repo": {
"full_name": "fork/other",
"name": github_types.GitHubRepositoryName("other"),
"private": False,
"archived": False,
"url": "",
"html_url": "",
"default_branch": github_types.GitHubRefType(""),
"id": github_types.GitHubRepositoryIdType(0),
"owner": {
"login": github_types.GitHubLogin("user"),
"id": github_types.GitHubAccountIdType(0),
"type": "User",
"avatar_url": "",
},
},
},
"user": {
"login": github_types.GitHubLogin("user"),
"id": github_types.GitHubAccountIdType(0),
"type": "User",
"avatar_url": "",
},
"merged_by": None,
"merged_at": None,
"mergeable_state": "clean",
},
)
base_branch = github_types.GitHubBranchCommitParent(
{"sha": github_types.SHAType("base_branch")})
rebased_c1 = github_types.GitHubBranchCommit({
"sha":
github_types.SHAType("rebased_c1"),
"parents": [base_branch],
"commit": {
"message": "hello c1"
},
})
rebased_c2 = github_types.GitHubBranchCommit({
"sha":
github_types.SHAType("rebased_c2"),
"parents": [rebased_c1],
"commit": {
"message": "hello c2"
},
})
async def fake_get_github_commit_from_sha(url, api_version=None):
if url.endswith("/commits/rebased_c1"):
return rebased_c1
if url.endswith("/commits/rebased_c2"):
return rebased_c2
raise RuntimeError(f"Unknown URL {url}")
client.item.side_effect = fake_get_github_commit_from_sha
assert await duplicate_pull._get_commits_to_cherrypick(ctxt,
rebased_c2) == [
rebased_c1,
rebased_c2,
]