def test_extract_2_terrains(self):
# given
terrain = ['2', '4, 6', '2, 8', '3', '1, 2, 3', '4, 5, 6', '7, 8, 9']
TerrainsAnalyzer.extract_data_from_file = mock.Mock(return_value='')
analyzer = TerrainsAnalyzer('')
# when
result = analyzer.extract_terrains(terrain)
# then
expected = [[[4, 6], [2, 8]], [[1, 2, 3], [4, 5, 6], [7, 8, 9]]]
self.assertEqual(result, expected)
def test_create_response_uri_generates_session_state_if_session_management_enabled(
self):
# RequestFactory doesn't support sessions, so we mock it
self.request.session = mock.Mock(session_key=None)
authorization_endpoint = AuthorizeEndpoint(self.request)
authorization_endpoint.validate_params()
uri = authorization_endpoint.create_response_uri()
self.assertIn('session_state=', uri)
def test_minimum_effort_to_travel_3x3(self):
# given
terrain = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
TerrainsAnalyzer.extract_data_from_file = mock.Mock(
return_value=terrain)
analyzer = TerrainsAnalyzer('')
# when
result = analyzer.minimum_effort_to_travel(terrain)
# then
self.assertEqual(result, 21)
def test_get_or_make_loop_handles_runtime_error():
asyncio.set_event_loop(None)
mock_loop = mock.Mock(asyncio.AbstractEventLoop)
with mock.patch.object(asyncio, "new_event_loop", return_value=mock_loop) as new_event_loop:
assert aio.get_or_make_loop() is mock_loop
new_event_loop.assert_called_once_with()
assert asyncio.get_event_loop_policy().get_event_loop() is mock_loop
def test_send_payload(self, mock_subproc_popen):
process_mock = mock.Mock()
attrs = {'stdout.readline.return_value': 'Test\n'}
process_mock.configure_mock(**attrs)
mock_subproc_popen.return_value = process_mock
@mock.patch('requests.post', side_effect=mocked_post)
def test_post(self, mock_get):
feed_file('test', False, 1, '', 0)
self.assertTrue(mock_subproc_popen.called)
def test_use_case_with_positive_percentage(connected_device):
volume_increase_in_percentage = 10
initial_volume = connected_device.volume
device_discovery_service = mock.Mock()
device_discovery_service.get.return_value = connected_device # We mock the device discovery service
device_transport_control_service = mock.Mock()
volume_up_uc = VolumeUpUseCase(device_discovery_service,
device_transport_control_service)
volume_up_request = VolumeUpRequestObject.from_dict(
{'volume_increase': volume_increase_in_percentage})
response_object = volume_up_uc.execute(volume_up_request)
assert bool(response_object) is True
device_transport_control_service.volume_up.assert_called_with(
connected_device)
assert connected_device.volume == initial_volume + volume_increase_in_percentage
def test_get_one(self):
self.get_mock.return_value = fakes.FakeResponse(data=self.pod_json)
pod_get_one = pods.PodGetOne(self.app, mock.Mock())
args = ['def']
verifies = [('name', 'def')]
parsed_args = self.check_parser(pod_get_one, args, verifies)
pod_get_one.take_action(parsed_args)
self.get_mock.assert_called_once_with(
self.base_url + '/def',
headers=clientmanager.ClientManager.headers)
def test_use_case_with_positive_integer(connected_device):
volume_decrease_integer = 10
initial_volume = connected_device.volume
device_discovery_service = mock.Mock()
device_discovery_service.get.return_value = connected_device # We mock the device discovery service
device_transport_control_service = mock.Mock()
volume_down_uc = VolumeDownUseCase(device_discovery_service,
device_transport_control_service)
volume_down_request = VolumeDownRequestObject.from_dict(
{'volume_decrease': volume_decrease_integer})
response_object = volume_down_uc.execute(volume_down_request)
assert bool(response_object) is True
device_transport_control_service.volume_down.assert_called_with(
connected_device)
assert connected_device.volume == initial_volume - volume_decrease_integer
def test_get(self):
self.get_mock.return_value = fakes.FakeResponse(data=self.projects_rsp)
project_get = projects.ProjectGet(self.app, mock.Mock())
args = ['-name', 'dfs']
verifies = [('name', 'dfs')]
parsed_args = self.check_parser(project_get, args, verifies)
project_get.take_action(parsed_args)
self.get_mock.assert_called_once_with(
self.base_url + '?name=dfs',
headers=clientmanager.ClientManager.headers)
def test_strip_site_theme_from_uri(self, parent_mock, helper_mock):
"""
Test site theme templates path is stripped from the given template path.
"""
theme = mock.Mock()
theme.theme_dir_name = 'bragi'
helper_mock.get_current_theme.return_value = theme
helper_mock.get_project_root_name.return_value = 'lms'
default_theme = mock.Mock()
default_theme.theme_dir_name = 'default-theme'
default_theme.name = 'default_theme'
default_theme.path = Path('/themes/default_theme/lms')
default_theme.template_path = Path('default-theme/lms/templates')
parent_mock.return_value = default_theme
template_path = strip_site_theme_templates_path(
'bragi/lms/templates/header.html')
self.assertEqual(template_path, 'header.html')
def setUp(self):
super().setUp()
self.manager = mock.Mock()
self.resource_type_factory = ResourceTypeFactory()
self.resource_type_factory.register('server')
self.server_resource_type = self.resource_type_factory.get('server')
self.app = get_app()
Api(self.app, manager=self.manager, resource_type_factory=self.resource_type_factory)
def test__lshw(self, udev_mock, po, wm, output_helper, hwd):
wm.return_value = '/valid/path'
udev_mock.return_value = "mocked_udevadm_out"
process_mock = mock.Mock()
attrs = {'communicate.return_value': (output_helper.lshw_out['stdout'], 'error')}
process_mock.configure_mock(**attrs)
po.return_value = process_mock
out = hwd.HardwareDetections()._lshw()
expected = output_helper.lshw_out['expected_return']
assert out == expected
def test_get_all(self):
self.get_mock.return_value = fakes.FakeResponse(data=self.pods_rsp)
pod_get = pods.PodGet(self.app, mock.Mock())
args = []
verifies = []
parsed_args = self.check_parser(pod_get, args, verifies)
pod_get.take_action(parsed_args)
self.get_mock.assert_called_once_with(
self.base_url,
headers=clientmanager.ClientManager.headers)
def test_send_call_message(self):
message = pika_drv_msg.RpcPikaOutgoingMessage(
self._pika_engine, self._message, self._context
)
expiration = 1
stopwatch = timeutils.StopWatch(duration=expiration).start()
result = "it is a result"
reply_queue_name = "reply_queue_name"
future = futures.Future()
future.set_result(result)
reply_listener = mock.Mock()
reply_listener.register_reply_waiter.return_value = future
reply_listener.get_reply_qname.return_value = reply_queue_name
res = message.send(
exchange=self._exchange,
routing_key=self._routing_key,
reply_listener=reply_listener,
stopwatch=stopwatch,
retrier=None
)
self.assertEqual(result, res)
self._pika_engine.connection_with_confirmation_pool.acquire(
).__enter__().channel.publish.assert_called_once_with(
body=mock.ANY,
exchange=self._exchange, mandatory=True,
properties=mock.ANY,
routing_key=self._routing_key
)
body = self._pika_engine.connection_with_confirmation_pool.acquire(
).__enter__().channel.publish.call_args[1]["body"]
self.assertEqual(
b'{"_$_request_id": 555, "_$_token": "it is a token", '
b'"msg_str": "hello", "msg_type": 1}',
body
)
props = self._pika_engine.connection_with_confirmation_pool.acquire(
).__enter__().channel.publish.call_args[1]["properties"]
self.assertEqual(props.content_encoding, 'utf-8')
self.assertEqual(props.content_type, 'application/json')
self.assertEqual(props.delivery_mode, 1)
self.assertTrue(expiration * 1000 - float(props.expiration) < 100)
self.assertEqual(props.headers, {'version': '1.0'})
self.assertEqual(props.correlation_id, message.msg_id)
self.assertEqual(props.reply_to, reply_queue_name)
self.assertTrue(props.message_id)
def test_get_one(self):
self.get_mock.return_value = fakes.FakeResponse(
data=self.testcase_json)
testcase_get_one = testcases.TestcaseGetOne(self.app, mock.Mock())
args = ['--project-name', 'functest', 'def']
verifies = [('project_name', 'functest'), ('name', 'def')]
parsed_args = self.check_parser(testcase_get_one, args, verifies)
testcase_get_one.take_action(parsed_args)
self.get_mock.assert_called_once_with(
self.base_url.format(parsed_args.project_name) + '/def',
headers=clientmanager.ClientManager.headers)
def test_get(self):
self.get_mock.return_value = fakes.FakeResponse(
data=self.testcases_rsp)
testcase_get = testcases.TestcaseGet(self.app, mock.Mock())
args = ['--project-name', 'dfs']
verifies = [('project_name', 'dfs')]
parsed_args = self.check_parser(testcase_get, args, verifies)
testcase_get.take_action(parsed_args)
self.get_mock.assert_called_once_with(
self.base_url.format(parsed_args.project_name),
headers=clientmanager.ClientManager.headers)
def test_device_matches(self, pu, ms, ps):
ps.return_value = '/dev/disk/by-id'
ms.return_value = '-name ata* -o -name scsi* -o -name nvme*'
pu.return_value = -1
cephdisks.__salt__ = {}
cephdisks.__salt__['helper.run'] = mock.Mock()
cephdisks.__salt__['helper.run'].return_value = (0,
'/dev/disk/by-id/sda',
"")
ret = cephdisks.device_('/dev/sda')
assert ret == '/dev/disk/by-id/sda'
def test_delete_success(self):
self.delete_mock.return_value = fk.FakeResponse()
scenario_delete = scenarios.ScenarioDelete(self.app, mock.Mock())
args = ['def']
verifies = [('name', 'def')]
parsed_args = self.check_parser(scenario_delete, args, verifies)
scenario_delete.take_action(parsed_args)
self.delete_mock.assert_called_once_with(
self.base_url + '/def',
data=None,
headers=clientmanager.ClientManager.headers)
def build_fastapi_app(self, config={}, **limiter_args):
limiter_args.setdefault("key_func", get_remote_address)
limiter = Limiter(**limiter_args)
app = FastAPI()
app.state.limiter = limiter
app.add_middleware(SlowAPIMiddleware)
mock_handler = mock.Mock()
mock_handler.level = logging.INFO
limiter.logger.addHandler(mock_handler)
return app, limiter
def test_handle_http_error(self, code):
"""Test for handle http errors when {code} code"""
ex = mock.Mock()
ex.resp.status = code
ex.content = json.dumps({
"error": {"message": "message"}
})
with self.assertRaises(HTTPException):
file_actions.handle_http_error(ex)
def test_parse_animal_from_row():
row = mock.Mock()
mock_name_column = mock.Mock()
mock_name_attrs = {'href': mock.Mock()}
mock_name_column.find.return_value.attrs = mock_name_attrs
mock_collateral_adjectives_column = mock.Mock()
collateral_adjectives = ['a', 'b']
mock_collateral_adjectives_column.contents = collateral_adjectives + [
mock.Mock()
]
row.find_all.return_value = [
mock_name_column, None, None, None, None,
mock_collateral_adjectives_column, None
]
animal = parse_animal_from_row(row)
assert animal.collateral_adjectives == collateral_adjectives
assert animal.name == mock_name_column.get_text.return_value
assert animal.link == mock_name_attrs['href']
def test_backup_mysql_status_updated(mock_get_dst, mock_backup_stream,
mock_prep_status, mock_mysql_source,
config_content):
s_config = config_content.format(destination="ssh", port='1234')
buf = StringIO.StringIO(s_config)
config = ConfigParser.ConfigParser()
config.readfp(buf)
mock_dst = mock.Mock()
mock_get_dst.return_value = mock_dst
backup_mysql("hourly", config)
mock_dst.status.assert_called_once()
def test_rclone_returns_output_rc(self, mock_subproc_popen):
process_mock = mock.Mock()
attrs = {
'returncode': '0',
}
process_mock.configure_mock(**attrs)
mock_subproc_popen.return_value = process_mock
rc, output = self.backend.run_rclone("foo")
self.assertEqual(rc, "0")
def test_get_industry_tickers(self):
self.db.collection.find = mock.Mock()
self.db.collection.find.return_value = [{
"Industry": "Semiconductors",
"Ticker": "AMD"
}, {
"Industry": "Semiconductors",
"Ticker": "INTL"
}]
self.assertEqual(self.db.get_industry_tickers("Semiconductors"),
['AMD', 'INTL'])
def test_use_case_empty_parameters(connected_device):
device_discovery_service = mock.Mock()
device_discovery_service.get.return_value = connected_device # We mock the device discovery service
initial_volume = connected_device.volume
device_transport_control_service = mock.Mock()
mute_uc = MuteUseCase(device_discovery_service,
device_transport_control_service)
mute_request_object = MuteRequestObject.from_dict({})
result_object = mute_uc.execute(mute_request_object)
device_discovery_service.get.assert_called()
device_transport_control_service.mute.assert_called()
device_transport_control_service.mute.assert_called_with(connected_device)
assert bool(result_object) is True
assert connected_device.volume == initial_volume
def test_power_on_domain_not_found(self, mock_open):
connection_mock = mock.Mock()
connection_mock.lookupByName.side_effect = \
libvirt.libvirtError('virDomainLookupByName() failed',
conn=connection_mock)
mock_open.return_value = connection_mock
self.assertRaises(drivers.DeviceNotFound, self.driver.power_on,
'domainA')
connection_mock.close.assert_called_with()
def test__updates_needed(self, po, apt):
"""
Updates pending
"""
process_mock = mock.Mock()
attrs = {'communicate.return_value': ("", "1;1")}
process_mock.configure_mock(**attrs)
po.return_value = process_mock
ret = apt._updates_needed()
assert po.called is True
assert ret is True
def test_wsfe_number(self):
# Simulamos la respuesta de la AFIP y un numero distinto al siguiente del talonario
afip_wsfe = mock.Mock()
afip_wsfe.get_last_number = mock.MagicMock(return_value=1)
with self.assertRaises(ValidationError):
self.invoice._action_wsfe_number(self.document_book_fc_a, afip_wsfe, 001)
# Ahora probamos el caso que coinciden ambos talonarios
afip_wsfe.get_last_number = mock.MagicMock(return_value=0)
self.invoice._action_wsfe_number(self.document_book_fc_a, afip_wsfe, 001)
def test_percepcion_base_1000_5_porciento(self):
partner = mock.Mock()
perception = mock.Mock()
rule = mock.Mock()
rule.not_applicable_minimum = 400
perception.id = 1
perception.name = 'test'
perception.jurisdiction = 'bs_as'
perception.perception_rule_ids = [rule]
r_value = {perception: 5.0}
partner.get_perceptions_values = MagicMock(return_value=[r_value])
calculator = perception_calculator.PerceptionCalculator(
partner, 1000, None)
values = calculator.get_perceptions_values()[0]
assert values['perception_id'] == perception.id
assert values['base'] == 1000
assert values['amount'] == 50
assert values['name'] == perception.name
assert values['jurisdiction'] == perception.jurisdiction
def test_03(self):
url = 'http://127.0.0.1:8000/login/'
data = {
'username': '******',
'password': '******',
'validate': 'wxym3',
}
mock_data = mock.Mock(return_value=data)
self.run.run_main = mock_data
res = self.run.run_main(url, 'POST', data)
self.assertEqual(res['username'], 'LC003')
