def test_handle_url_with_json_and_stream_url(self, console, args):
stream = Mock()
streams = dict(worst=Mock(), best=stream)
plugin = Mock(FakePlugin(),
module="fake",
arguments=[],
streams=Mock(return_value=streams))
with patch("streamlink_cli.main.streamlink",
resolve_url=Mock(return_value=plugin)):
handle_url()
self.assertEqual(console.msg.mock_calls, [])
self.assertEqual(console.msg_json.mock_calls,
[call(dict(plugin="fake", streams=streams))])
self.assertEqual(console.error.mock_calls, [])
if is_py3:
console.msg_json.mock_calls.clear()
console.json = False
handle_url()
self.assertEqual(console.msg.mock_calls,
[call("{0}", stream.to_manifest_url())])
self.assertEqual(console.msg_json.mock_calls, [])
self.assertEqual(console.error.mock_calls, [])
console.msg_json.mock_calls.clear()
""" fails
def test_rm_stray_tuned_profiles(self, _check_execute_command):
profiles = {'p1': self.tspec1, 'p2': self.tspec2, 'p3': self.tspec3}
# for this test, going to use host "a" and put 4 cephadm generated
# profiles "p1" "p2", "p3" and "who" only two of which should be there ("p1", "p2")
# as well as a file not generated by cephadm. Only the "p3" and "who"
# profiles should be removed from the host. This should total to 4
# calls to check_execute_command, 1 "ls", 2 "rm", and 1 "sysctl --system"
_check_execute_command.return_value = '\n'.join([
'p1-cephadm-tuned-profile.conf', 'p2-cephadm-tuned-profile.conf',
'p3-cephadm-tuned-profile.conf', 'who-cephadm-tuned-profile.conf',
'dont-touch-me'
])
mgr = FakeMgr(['a', 'b', 'c'], ['a', 'b', 'c'], [], profiles)
tp = TunedProfileUtils(mgr)
tp._remove_stray_tuned_profiles(
'a', self.profiles_to_calls(tp, [self.tspec1, self.tspec2]))
calls = [
mock.call('a', ['ls', SYSCTL_DIR]),
mock.call(
'a',
['rm', '-f', f'{SYSCTL_DIR}/p3-cephadm-tuned-profile.conf']),
mock.call(
'a',
['rm', '-f', f'{SYSCTL_DIR}/who-cephadm-tuned-profile.conf']),
mock.call('a', ['sysctl', '--system'])
]
_check_execute_command.assert_has_calls(calls, any_order=True)
def test_hls_low_latency_has_prefetch_disable_ads_has_preroll(
self, mock_log):
self.subject([
Playlist(0,
[SegmentAd(0),
SegmentAd(1),
SegmentAd(2),
SegmentAd(3)]),
Playlist(4, [
Segment(4),
Segment(5),
Segment(6),
Segment(7),
SegmentPrefetch(8),
SegmentPrefetch(9)
],
end=True)
],
disable_ads=True,
low_latency=True)
self.await_read(read_all=True)
self.assertEqual(mock_log.info.mock_calls, [
call("Will skip ad segments"),
call("Low latency streaming (HLS live edge: 2)"),
call("Waiting for pre-roll ads to finish, be patient")
])
def test_handle_stream_with_json_and_stream_url(self, console, args):
stream = Mock()
streams = dict(best=stream)
plugin = Mock(FakePlugin(),
module="fake",
arguments=[],
streams=Mock(return_value=streams))
handle_stream(plugin, streams, "best")
self.assertEqual(console.msg.mock_calls, [])
self.assertEqual(console.msg_json.mock_calls, [call(stream)])
self.assertEqual(console.error.mock_calls, [])
if is_py3:
console.msg_json.mock_calls.clear()
console.json = False
handle_stream(plugin, streams, "best")
self.assertEqual(console.msg.mock_calls,
[call("{0}", stream.to_url())])
self.assertEqual(console.msg_json.mock_calls, [])
self.assertEqual(console.error.mock_calls, [])
console.msg.mock_calls.clear()
stream.to_url.side_effect = TypeError()
handle_stream(plugin, streams, "best")
self.assertEqual(console.msg.mock_calls, [])
self.assertEqual(console.msg_json.mock_calls, [])
self.assertEqual(
console.exit.mock_calls,
[call("The stream specified cannot be translated to a URL")])
def test_can_register_retry_handler(self):
client = mock.Mock()
limiter = adaptive.register_retry_handler(client)
self.assertEqual(client.meta.events.register.call_args_list, [
mock.call('before-send', limiter.on_sending_request),
mock.call('needs-retry', limiter.on_receiving_response)
])
def test_filtered_logging(self, mock_log):
segments = self.get_segments(8)
thread, reader, writer = self.subject(segments, [
self.get_playlist(0, [0, 1], filtered=True),
self.get_playlist(2, [2, 3], filtered=False),
self.get_playlist(4, [4, 5], filtered=True),
self.get_playlist(6, [6, 7], filtered=False, end=True)
])
self.assertTrue(reader.filter_event.is_set(), "Doesn't let the reader wait if not filtering")
for i in range(2):
thread.await_write()
thread.await_write()
self.assertEqual(len(mock_log.info.mock_calls), i * 2 + 1)
self.assertEqual(mock_log.info.mock_calls[i * 2 + 0], call("Filtering out segments and pausing stream output"))
self.assertFalse(reader.filter_event.is_set(), "Lets the reader wait if filtering")
thread.await_write()
thread.await_write()
self.assertEqual(len(mock_log.info.mock_calls), i * 2 + 2)
self.assertEqual(mock_log.info.mock_calls[i * 2 + 1], call("Resuming stream output"))
self.assertTrue(reader.filter_event.is_set(), "Doesn't let the reader wait if not filtering")
thread.await_read()
self.assertEqual(
b"".join(thread.data),
b"".join(list(itertools.chain(segments[2:4], segments[6:8]))),
"Correctly filters out segments"
)
for i, _ in enumerate(segments):
self.assertTrue(self.mocks[self.url_segment.format(i)].called, "Downloads all segments")
def test_search_caseness(self):
(stdout, pkgs) = self.patched_search(['LOTUS'])
self.assertEqual(stdout.write.mock_calls,
[mock.call(u'N/S Matched: LOTUS'), mock.call('\n')])
pkg_names = map(str, pkgs)
self.assertIn('lotus-3-16.i686', pkg_names)
self.assertIn('lotus-3-16.x86_64', pkg_names)
def test_tracks_added_callback(self, track_lib_mock, lib_mock):
callback = mock.Mock()
sp_playlist = spotify.ffi.cast('sp_playlist *', 42)
playlist = spotify.Playlist._cached(
self.session, sp_playlist=sp_playlist
)
playlist.on(spotify.PlaylistEvent.TRACKS_ADDED, callback)
sp_tracks = [
spotify.ffi.cast('sp_track *', 43),
spotify.ffi.cast('sp_track *', 44),
spotify.ffi.cast('sp_track *', 45),
]
index = 7
_PlaylistCallbacks.tracks_added(
sp_playlist, sp_tracks, len(sp_tracks), index, spotify.ffi.NULL
)
callback.assert_called_once_with(playlist, mock.ANY, index)
tracks = callback.call_args[0][1]
self.assertEqual(len(tracks), len(sp_tracks))
self.assertIsInstance(tracks[0], spotify.Track)
self.assertEqual(tracks[0]._sp_track, sp_tracks[0])
track_lib_mock.sp_track_add_ref.assert_has_calls(
[
mock.call(sp_tracks[0]),
mock.call(sp_tracks[1]),
mock.call(sp_tracks[2]),
]
)
def test_setdict_alias(self):
with mock.patch.object(self.settings, 'set') as mock_set:
self.settings.setdict({'TEST_1': 'value1', 'TEST_2': 'value2'}, 10)
self.assertEqual(mock_set.call_count, 2)
calls = [mock.call('TEST_1', 'value1', 10),
mock.call('TEST_2', 'value2', 10)]
mock_set.assert_has_calls(calls, any_order=True)
def test_hls_low_latency_no_prefetch_disable_ads_has_preroll(
self, mock_log):
daterange = TagDateRangeAd(duration=4)
self.subject([
Playlist(
0, [daterange,
Segment(0),
Segment(1),
Segment(2),
Segment(3)]),
Playlist(
4, [Segment(4), Segment(5),
Segment(6), Segment(7)], end=True)
],
disable_ads=True,
low_latency=True)
self.await_write(6)
self.await_read(read_all=True)
self.assertEqual(mock_log.info.mock_calls, [
call("Will skip ad segments"),
call("Low latency streaming (HLS live edge: 2)"),
call("Waiting for pre-roll ads to finish, be patient"),
call("This is not a low latency stream")
])
def test_name(self, mock_log):
NamedPipe()
NamedPipe()
self.assertEqual(mock_log.info.mock_calls, [
call("Creating pipe streamlinkpipe-12345-1-67890"),
call("Creating pipe streamlinkpipe-12345-2-67890")
])
def test_instantiation(self):
# Instantiate the class.
dynamodb_class = type(
'dynamodb', (DynamoDBHighLevelResource, ServiceResource),
{'meta': self.meta})
with mock.patch('boto3.dynamodb.transform.TransformationInjector') \
as mock_injector:
dynamodb_class(client=self.client)
# It should have fired the following events upon instantiation.
event_call_args = self.events.register.call_args_list
self.assertEqual(
event_call_args,
[mock.call(
'provide-client-params.dynamodb',
copy_dynamodb_params,
unique_id='dynamodb-create-params-copy'),
mock.call(
'before-parameter-build.dynamodb',
mock_injector.return_value.inject_condition_expressions,
unique_id='dynamodb-condition-expression'),
mock.call(
'before-parameter-build.dynamodb',
mock_injector.return_value.inject_attribute_value_input,
unique_id='dynamodb-attr-value-input'),
mock.call(
'after-call.dynamodb',
mock_injector.return_value.inject_attribute_value_output,
unique_id='dynamodb-attr-value-output')]
)
def test_setdict_alias(self):
with mock.patch.object(self.settings, 'set') as mock_set:
self.settings.setdict({'TEST_1': 'value1', 'TEST_2': 'value2'}, 10)
self.assertEqual(mock_set.call_count, 2)
calls = [mock.call('TEST_1', 'value1', 10),
mock.call('TEST_2', 'value2', 10)]
mock_set.assert_has_calls(calls, any_order=True)
def test_ceph_volume_no_filter_for_batch(self, _run_cephadm, cephadm_module: CephadmOrchestrator):
_run_cephadm.return_value = ('{}', '', 0)
error_message = """cephadm exited with an error code: 1, stderr:/usr/bin/podman:stderr usage: ceph-volume inventory [-h] [--format {plain,json,json-pretty}] [path]/usr/bin/podman:stderr ceph-volume inventory: error: unrecognized arguments: --filter-for-batch
Traceback (most recent call last):
File "<stdin>", line 6112, in <module>
File "<stdin>", line 1299, in _infer_fsid
File "<stdin>", line 1382, in _infer_image
File "<stdin>", line 3612, in command_ceph_volume
File "<stdin>", line 1061, in call_throws"""
with with_host(cephadm_module, 'test'):
_run_cephadm.reset_mock()
_run_cephadm.side_effect = OrchestratorError(error_message)
s = CephadmServe(cephadm_module)._refresh_host_devices('test')
assert s == 'host test `cephadm ceph-volume` failed: ' + error_message
assert _run_cephadm.mock_calls == [
mock.call('test', 'osd', 'ceph-volume',
['--', 'inventory', '--format=json', '--filter-for-batch'], image='',
no_fsid=False),
mock.call('test', 'osd', 'ceph-volume',
['--', 'inventory', '--format=json'], image='',
no_fsid=False),
]
def test_handle_stream_with_json_and_stream_url(self, console, args):
stream = Mock()
streams = dict(best=stream)
plugin = FakePlugin("")
plugin._streams = streams
handle_stream(plugin, streams, "best")
self.assertEqual(console.msg.mock_calls, [])
self.assertEqual(console.msg_json.mock_calls, [
call(stream,
metadata=dict(id=u"test-id-1234-5678",
author=u"Tѥst Āuƭhǿr",
category=None,
title=u"Test Title"))
])
self.assertEqual(console.error.mock_calls, [])
console.msg_json.mock_calls *= 0
console.json = False
handle_stream(plugin, streams, "best")
self.assertEqual(console.msg.mock_calls,
[call("{0}", stream.to_url())])
self.assertEqual(console.msg_json.mock_calls, [])
self.assertEqual(console.error.mock_calls, [])
console.msg.mock_calls *= 0
stream.to_url.side_effect = TypeError()
handle_stream(plugin, streams, "best")
self.assertEqual(console.msg.mock_calls, [])
self.assertEqual(console.msg_json.mock_calls, [])
self.assertEqual(
console.exit.mock_calls,
[call("The stream specified cannot be translated to a URL")])
def test_short_exception(self, stderr):
try:
raise RuntimeError("test exception")
except RuntimeError:
print_small_exception("test_short_exception")
self.assertSequenceEqual(
[call('RuntimeError: test exception\n'),
call('\n')], stderr.write.mock_calls)
def test_register(self):
event_emitter = mock.Mock(HierarchicalEmitter)
self.handler.register(event_emitter)
self.assertEqual(event_emitter.register_last.call_args_list, [
mock.call('before-parameter-build', self.handler.capture),
mock.call('request-created', self.handler.capture),
mock.call('response-received', self.handler.capture),
mock.call('after-call', self.handler.capture),
mock.call('after-call-error', self.handler.capture),
])
def test_hosting_host_single(self, mock_log):
res, channel, author = self.subject("foo", [(1, "bar", "Bar"), (2, )])
self.assertFalse(res, "Doesn't stop HLS resolve procedure")
self.assertEqual(channel, "bar", "Switches channel")
self.assertEqual(author, "Bar", "Overrides author metadata")
self.assertEqual(
mock_log.info.mock_calls,
[call("foo is hosting bar"),
call("switching to bar")])
self.assertEqual(mock_log.error.mock_calls, [],
"Doesn't log anything to error")
def test_send(self):
client = WebsocketClient(self.session, "wss://localhost:0")
with patch.object(client, "ws") as mock_ws:
client.send("foo")
client.send(b"foo", ABNF.OPCODE_BINARY)
client.send_json({"foo": "bar", "baz": "qux"})
self.assertEqual(mock_ws.send.call_args_list, [
call("foo", ABNF.OPCODE_TEXT),
call(b"foo", ABNF.OPCODE_BINARY),
call("{\"foo\":\"bar\",\"baz\":\"qux\"}", ABNF.OPCODE_TEXT),
])
def test_hosting_host_single_disable(self, mock_log):
res, channel, channel_id, author = self.subject("foo", [(1, 2, "bar", "Bar")], disable=True)
self.assertTrue(res, "Stops HLS resolve procedure")
self.assertEqual(channel, "foo", "Doesn't switch channel")
self.assertEqual(channel_id, 1, "Doesn't switch channel id")
self.assertEqual(author, None, "Doesn't override author metadata")
self.assertEqual(mock_log.info.mock_calls, [
call("foo is hosting bar"),
call("hosting was disabled by command line option")
])
self.assertEqual(mock_log.error.mock_calls, [], "Doesn't log anything to error")
def test_setup_from_dnf_conf(self, setup_m):
conf = mock.Mock(debuglevel=2, errorlevel=2, logdir=self.logdir)
self.logging.setup_from_dnf_conf(conf)
self.assertEqual(setup_m.call_args, mock.call(dnf.logging.INFO,
dnf.logging.WARNING,
self.logdir))
conf = mock.Mock(debuglevel=6, errorlevel=6, logdir=self.logdir)
self.logging.setup_from_dnf_conf(conf)
self.assertEqual(setup_m.call_args, mock.call(dnf.logging.DEBUG,
dnf.logging.WARNING,
self.logdir))
def test_events_emitted_request_params(self):
self.request_params.traverse_and_document_shape(
section=self.doc_structure,
shape=self.operation_model.input_shape,
history=[])
self.assertEqual(self.event_emitter.emit.call_args_list, [
mock.call('docs.request-params.myservice.SampleOperation.Foo',
section=self.doc_structure.get_section('Foo')),
mock.call(('docs.request-params.myservice.SampleOperation'
'.complete-section'),
section=self.doc_structure)
])
def test_register(self):
event_emitter = mock.Mock(HierarchicalEmitter)
self.handler.register(event_emitter)
self.assertEqual(
event_emitter.register_last.call_args_list,
[
mock.call('before-parameter-build', self.handler.capture),
mock.call('request-created', self.handler.capture),
mock.call('response-received', self.handler.capture),
mock.call('after-call', self.handler.capture),
mock.call('after-call-error', self.handler.capture),
]
)
def test_log_current_versions(self, mock_log):
self.subject(["streamlink", "--loglevel", "info"])
self.assertEqual(mock_log.debug.mock_calls, [],
"Doesn't log anything if not debug logging")
with patch("sys.platform", "linux"), \
patch("platform.platform", Mock(return_value="linux")):
self.subject(["streamlink", "--loglevel", "debug"])
self.assertEqual(mock_log.debug.mock_calls[:4], [
call("OS: linux"),
call("Python: python"),
call("Streamlink: streamlink"),
call("Requests(requests), Socks(socks), Websocket(websocket)")
])
mock_log.debug.reset_mock()
with patch("sys.platform", "win32"), \
patch("platform.system", Mock(return_value="Windows")), \
patch("platform.release", Mock(return_value="0.0.0")):
self.subject(["streamlink", "--loglevel", "debug"])
self.assertEqual(mock_log.debug.mock_calls[:4], [
call("OS: Windows 0.0.0"),
call("Python: python"),
call("Streamlink: streamlink"),
call("Requests(requests), Socks(socks), Websocket(websocket)")
])
mock_log.debug.reset_mock()
def test_write_only_strips_until_text_is_found(self):
self.node.add_child(parser.DataNode(' '))
tag_child = parser.TagNode('foo')
tag_child.add_child(parser.DataNode(' '))
tag_child_2 = parser.TagNode('foo')
tag_child_2.add_child(parser.DataNode(' foo'))
tag_child_2.add_child(parser.DataNode(' '))
tag_child.add_child(tag_child_2)
self.node.add_child(tag_child)
self.node.write(self.doc)
calls = [mock.call('foo'), mock.call(' ')]
self.doc.handle_data.assert_has_calls(calls)
def test_attach_to_logs(self):
project = mock.create_autospec(Project)
log_printer = mock.create_autospec(LogPrinter, containers=[])
service_names = ['web', 'db']
timeout = 12
with mock.patch('compose.cli.main.signal', autospec=True) as mock_signal:
attach_to_logs(project, log_printer, service_names, timeout)
assert mock_signal.signal.mock_calls == [
mock.call(mock_signal.SIGINT, mock.ANY),
mock.call(mock_signal.SIGTERM, mock.ANY),
]
log_printer.run.assert_called_once_with()
def test_hls_low_latency_no_prefetch(self, mock_log):
self.subject([
Playlist(0, [Segment(0), Segment(1), Segment(2), Segment(3)]),
Playlist(4, [Segment(4), Segment(5), Segment(6), Segment(7)], end=True)
], disable_ads=False, low_latency=True)
self.assertTrue(self.session.get_plugin_option("twitch", "low-latency"))
self.assertFalse(self.session.get_plugin_option("twitch", "disable-ads"))
self.await_write(6)
self.await_read(read_all=True)
self.assertEqual(mock_log.info.mock_calls, [
call("Low latency streaming (HLS live edge: 2)"),
call("This is not a low latency stream")
])
def test_attach_to_logs(self):
project = mock.create_autospec(Project)
log_printer = mock.create_autospec(LogPrinter, containers=[])
service_names = ['web', 'db']
timeout = 12
with mock.patch('compose.cli.main.signal',
autospec=True) as mock_signal:
attach_to_logs(project, log_printer, service_names, timeout)
assert mock_signal.signal.mock_calls == [
mock.call(mock_signal.SIGINT, mock.ANY),
mock.call(mock_signal.SIGTERM, mock.ANY),
]
log_printer.run.assert_called_once_with()
def test_get_streams(self, parse_variant_playlist):
session = Streamlink()
Mjunoon.bind(session, "test")
script_text = """
<script id="playerScript" src="playerAssets/js/player.js?v=2.2&streamUrl=https://vod.mjunoon.tv:8181/live/41/41.m3u8&streamUrl=https://vod.mjunoon.tv:8181/live/17/17.m3u8"></script>
"""
parse_variant_playlist.items.return_value = [("test", Mock())]
with requests_mock.Mocker() as rmock:
rmock.get("https://mjunoon.tv/news-live", text=script_text)
plugin = Mjunoon("https://mjunoon.tv/news-live")
_ = list(plugin.streams())
self.assertSequenceEqual(
[call(ANY, "https://vod.mjunoon.tv:8181/live/41/41.m3u8", params=dict(id=1), verify=False),
call(ANY, "https://vod.mjunoon.tv:8181/live/17/17.m3u8", params=dict(id=2), verify=False)],
[parse_variant_playlist.mock_calls[0], parse_variant_playlist.mock_calls[3]])
def test_hls_no_low_latency_no_prefetch(self, mock_logging):
streams = ["[{0}]".format(i).encode("ascii") for i in range(10)]
playlists = [
self.getPlaylist(0, [0, 1, 2, 3], []),
self.getPlaylist(4, [4, 5, 6, 7], []) + "#EXT-X-ENDLIST\n"
]
streamlink, result, mocked = self.get_result(streams, playlists, low_latency=True)
self.assertTrue(streamlink.get_plugin_option("twitch", "low-latency"))
self.assertFalse(streamlink.get_plugin_option("twitch", "disable-ads"))
mock_logging.info.assert_has_calls([
call("Low latency streaming (HLS live edge: 2)"),
call("This is not a low latency stream")
])
def test_events_emitted_response_example(self):
self.response_example.traverse_and_document_shape(
section=self.doc_structure,
shape=self.operation_model.input_shape,
history=[])
structure_section = self.doc_structure.get_section('structure-value')
print(self.event_emitter.emit.call_args_list[0][1]['section'].name)
self.assertEqual(self.event_emitter.emit.call_args_list, [
mock.call('docs.response-example.myservice.SampleOperation.Foo',
section=structure_section.get_section('Foo').get_section(
'member-value')),
mock.call(('docs.response-example.myservice.SampleOperation'
'.complete-section'),
section=self.doc_structure)
])
def test_get_streams(self, parse_variant_playlist):
session = Streamlink()
Mjunoon.bind(session, "test")
script_text = """
<script id="playerScript" src="playerAssets/js/player.js?v=2.2&streamUrl=https://vod.mjunoon.tv:8181/live/41/41.m3u8&streamUrl=https://vod.mjunoon.tv:8181/live/17/17.m3u8"></script>
""" # noqa: E501
parse_variant_playlist.items.return_value = [("test", Mock())]
with requests_mock.Mocker() as rmock:
rmock.get("https://mjunoon.tv/news-live", text=script_text)
plugin = Mjunoon("https://mjunoon.tv/news-live")
_ = list(plugin.streams())
self.assertSequenceEqual(
[call(ANY, "https://vod.mjunoon.tv:8181/live/41/41.m3u8", params=dict(id=1), verify=False),
call(ANY, "https://vod.mjunoon.tv:8181/live/17/17.m3u8", params=dict(id=2), verify=False)],
[parse_variant_playlist.mock_calls[0], parse_variant_playlist.mock_calls[3]])
def test_hls_low_latency_has_prefetch_has_preroll(self, mock_log):
daterange = TagDateRangeAd(duration=4)
thread, segments = self.subject([
Playlist(
0, [daterange,
Segment(0),
Segment(1),
Segment(2),
Segment(3)]),
Playlist(4, [
Segment(4),
Segment(5),
Segment(6),
Segment(7),
SegmentPrefetch(8),
SegmentPrefetch(9)
],
end=True)
],
disable_ads=False,
low_latency=True)
self.await_write(8)
self.assertEqual(self.await_read(read_all=True),
self.content(segments, cond=lambda s: s.num > 1),
"Skips first two segments due to reduced live-edge")
self.assertFalse(
any([self.called(s) for s in segments.values() if s.num < 2]),
"Skips first two preroll segments")
self.assertTrue(
all([self.called(s) for s in segments.values() if s.num >= 2]),
"Downloads all remaining segments")
self.assertEqual(mock_log.info.mock_calls,
[call("Low latency streaming (HLS live edge: 2)")])
def test_create_transfer_manager(self):
client = object()
config = TransferConfig()
osutil = OSUtils()
with mock.patch('ibm_boto3.s3.transfer.TransferManager') as manager:
create_transfer_manager(client, config, osutil)
assert manager.call_args == mock.call(client, config, osutil, None)
def test_userconfirm(self, input_fnc):
# with defaultyes==False
input_fnc.return_value = 'y'
self.assertTrue(self.output.userconfirm())
self.assertEqual(input_fnc.call_args, mock.call(u'Is this ok [y/N]: '))
input_fnc.return_value = 'n'
self.assertFalse(self.output.userconfirm())
input_fnc.return_value = ''
self.assertFalse(self.output.userconfirm())
input_fnc.side_effect = self._keyboard_interrupt
input_fnc.return_value = 'y'
self.assertFalse(self.output.userconfirm())
input_fnc.side_effect = self._eof_error
self.assertFalse(self.output.userconfirm())
# with defaultyes==True
self.output.conf.defaultyes = True
input_fnc.side_effect = None
input_fnc.return_value = ''
self.assertTrue(self.output.userconfirm())
input_fnc.side_effect = self._keyboard_interrupt
input_fnc.return_value = ''
self.assertFalse(self.output.userconfirm())
input_fnc.side_effect = self._eof_error
self.assertTrue(self.output.userconfirm())
def test_parse_stream_progress(self):
# Configure Mock response with progress
test_docker_response_progress = {
"status": "Pushing",
"progress_detail": {
"current": 655337,
"start": 1413994898,
"total": 20412416
},
"id": "51783549ce98",
"progress": "[=> ] 790.1 kB/19.99 MB 30s"
}
test_docker_response_encoded = json.dumps(test_docker_response_progress).encode('utf-8')
test_values_list = [test_docker_response_encoded]
mock_response_attributes = {"__iter__.return_value": iter(test_values_list)}
self.mock_object_response.configure_mock(**mock_response_attributes)
# Configure Normalized keys with return value
mock_attributes_normalize_keys = {"return_value": test_docker_response_progress}
self.mock_utils_normalize_keys.configure_mock(**mock_attributes_normalize_keys)
# Configure Mock for Display Progress
attributes_display_progress = {"return_value": test_docker_response_progress}
self.mock_display_progress.configure_mock(**attributes_display_progress)
parse_stream(self.mock_object_response)
self.mock_display_progress.assert_has_call(mock.call(test_docker_response_progress))
class TestTwitchReruns(unittest.TestCase):
log_call = call("Reruns were disabled by command line option")
def subject(self, **params):
with patch(
"streamlink.plugins.twitch.TwitchAPI.stream_metadata") as mock:
mock.return_value = None if params.pop("offline", False) else {
"type": params.pop("stream_type", "live")
}
session = Streamlink()
Twitch.bind(session, "tests.plugins.test_twitch")
plugin = Twitch("https://www.twitch.tv/foo")
plugin.options.set("disable-reruns", params.pop("disable", True))
return plugin._check_for_rerun()
def test_disable_reruns_live(self, mock_log):
self.assertFalse(self.subject())
self.assertNotIn(self.log_call, mock_log.info.call_args_list)
def test_disable_reruns_not_live(self, mock_log):
self.assertTrue(self.subject(stream_type="rerun"))
self.assertIn(self.log_call, mock_log.info.call_args_list)
def test_disable_reruns_offline(self, mock_log):
self.assertFalse(self.subject(offline=True))
self.assertNotIn(self.log_call, mock_log.info.call_args_list)
def test_enable_reruns(self, mock_log):
self.assertFalse(self.subject(stream_type="rerun", disable=False))
self.assertNotIn(self.log_call, mock_log.info.call_args_list)
def test_cookie_store_clear_filter(self):
session = Mock()
session.http.cookies = requests.cookies.RequestsCookieJar()
Plugin.bind(session, 'tests.test_plugin')
Plugin.cache = Mock()
Plugin.cache.get_all.return_value = {
"__cookie:test-name:test.se:80:/":
self._create_cookie_dict("test-name", "test-value", None),
"__cookie:test-name2:test.se:80:/":
self._create_cookie_dict("test-name2", "test-value2", None)
}
plugin = Plugin("http://test.se")
# non-empty cookiejar
self.assertTrue(len(session.http.cookies.get_dict()) > 0)
plugin.clear_cookies(lambda c: c.name.endswith("2"))
self.assertSequenceEqual(
Plugin.cache.set.mock_calls,
[call("__cookie:test-name2:test.se:80:/", None, 0)])
self.assertSequenceEqual(
list(map(self._cookie_to_dict, session.http.cookies)), [
self._cookie_to_dict(
requests.cookies.create_cookie(
"test-name", "test-value", domain="test.se"))
])
def test_parse_stream_status(self):
# Configure Mock response with status
test_docker_response_status = {
"status": "Download complete",
"progress_detail": {},
"id": "12340981vas"
}
test_docker_response_encoded = json.dumps(
test_docker_response_status).encode('utf-8')
test_values_list = [test_docker_response_encoded]
mock_response_attributes = {
"__iter__.return_value": iter(test_values_list)
}
self.mock_object_response.configure_mock(**mock_response_attributes)
# Configure Normalized keys with return value
mock_attributes_normalize_keys = {
"return_value": test_docker_response_status
}
self.mock_utils_normalize_keys.configure_mock(
**mock_attributes_normalize_keys)
parse_stream(self.mock_object_response)
self.mock_display_progress.assert_has_call(
mock.call(test_docker_response_status))
def test_parse_stream_json(self):
# Defined json response for testing
test_response_json = {"test": "test messsage", "foo": "bar"}
test_response_json_encoded = json.dumps(test_response_json).encode('utf-8')
test_values_list = [test_response_json_encoded]
mock_response_attributes = {"__iter__.return_value": iter(test_values_list)}
self.mock_object_response.configure_mock(**mock_response_attributes)
# Configure normalize keys with dict
mock_attributes_normalize_keys = {"return_value": test_response_json}
self.mock_utils_normalize_keys.configure_mock(**mock_attributes_normalize_keys)
parse_stream(self.mock_object_response)
self.mock_utils_stdout.write.called_once_with(mock.call(test_response_json))
self.mock_utils_stdout.flush.called_once_with(mock.call())
def test_arguments(self):
from streamlink_cli.main import setup_plugin_args
session = Streamlink()
parser = MagicMock()
plugin_parser = MagicMock()
parser.add_argument_group = MagicMock(return_value=plugin_parser)
session.plugins = {
'tvplayer': TVPlayer
}
setup_plugin_args(session, parser)
self.assertSequenceEqual(plugin_parser.add_argument.mock_calls,
[call('--tvplayer-email', metavar="EMAIL", help=ANY),
call('--tvplayer-password', metavar="PASSWORD", help=ANY)],
)
def test_cookie_store_clear(self):
session = Mock()
session.http.cookies = requests.cookies.RequestsCookieJar()
Plugin.bind(session, 'tests.test_plugin')
Plugin.cache = Mock()
Plugin.cache.get_all.return_value = {
"__cookie:test-name:test.se:80:/": self._create_cookie_dict("test-name", "test-value", None),
"__cookie:test-name2:test.se:80:/": self._create_cookie_dict("test-name2", "test-value2", None)
}
plugin = Plugin("http://test.se")
# non-empty cookiejar
self.assertTrue(len(session.http.cookies.get_dict()) > 0)
plugin.clear_cookies()
self.assertSequenceEqual(
Plugin.cache.set.mock_calls,
[call("__cookie:test-name:test.se:80:/", None, 0),
call("__cookie:test-name2:test.se:80:/", None, 0)])
self.assertSequenceEqual(session.http.cookies, [])
def test_stream_open_video_audio(self, muxer, reader):
stream = DASHStream(self.session, Mock(), Mock(id=1, mimeType="video/mp4"), Mock(id=2, mimeType="audio/mp3", lang='en'))
open_reader = reader.return_value = Mock()
stream.open()
self.assertSequenceEqual(reader.mock_calls, [call(stream, 1, "video/mp4"),
call().open(),
call(stream, 2, "audio/mp3"),
call().open()])
self.assertSequenceEqual(muxer.mock_calls, [call(self.session, open_reader, open_reader, copyts=True),
call().open()])
def test_parse_stream_stream(self):
# Configure Mock response with stream
test_docker_response_stream = {
"stream": "test stream"
}
test_docker_response_encoded = json.dumps(test_docker_response_stream).encode('utf-8')
test_values_list = [test_docker_response_encoded]
mock_response_attributes = {"__iter__.return_value": iter(test_values_list)}
self.mock_object_response.configure_mock(**mock_response_attributes)
# Configure Normalized keys with return value
mock_attributes_normalize_keys = {"return_value": test_docker_response_stream}
self.mock_utils_normalize_keys.configure_mock(**mock_attributes_normalize_keys)
parse_stream(self.mock_object_response)
self.mock_display_stream.assert_has_call(mock.call(test_docker_response_stream))
def test_parse_stream_status(self):
# Configure Mock response with status
test_docker_response_status = {
"status": "Download complete",
"progress_detail": {},
"id": "12340981vas"
}
test_docker_response_encoded = json.dumps(test_docker_response_status).encode('utf-8')
test_values_list = [test_docker_response_encoded]
mock_response_attributes = {"__iter__.return_value": iter(test_values_list)}
self.mock_object_response.configure_mock(**mock_response_attributes)
# Configure Normalized keys with return value
mock_attributes_normalize_keys = {"return_value": test_docker_response_status}
self.mock_utils_normalize_keys.configure_mock(**mock_attributes_normalize_keys)
parse_stream(self.mock_object_response)
self.mock_display_progress.assert_has_call(mock.call(test_docker_response_status))
def test_cookie_store_clear_filter(self):
session = Mock()
session.http.cookies = requests.cookies.RequestsCookieJar()
Plugin.bind(session, 'tests.test_plugin')
Plugin.cache = Mock()
Plugin.cache.get_all.return_value = {
"__cookie:test-name:test.se:80:/": self._create_cookie_dict("test-name", "test-value", None),
"__cookie:test-name2:test.se:80:/": self._create_cookie_dict("test-name2", "test-value2", None)
}
plugin = Plugin("http://test.se")
# non-empty cookiejar
self.assertTrue(len(session.http.cookies.get_dict()) > 0)
plugin.clear_cookies(lambda c: c.name.endswith("2"))
self.assertSequenceEqual(
Plugin.cache.set.mock_calls,
[call("__cookie:test-name2:test.se:80:/", None, 0)])
self.assertSequenceEqual(
list(map(self._cookie_to_dict, session.http.cookies)),
[self._cookie_to_dict(requests.cookies.create_cookie("test-name", "test-value", domain="test.se"))]
)
