def test_exception_backend_worker(raises, monkeypatch): mocked_post = MockingFunction() monkeypatch.setattr(requests, 'post', mocked_post) def raising(): raise raises worker_queue = queue.Queue() mocked_split_text = MockingFunction(raising, simple=True) monkeypatch.setattr(worker_queue, 'get', mocked_split_text) song_id = random.randint(1000, 10000) my_id = random.randint(0, 1000) my_host = str(random.randint(2, 1000)) + '/wowsers.html' worker_queue.put((web.PROCESS_SONG, '/filename/my_song.mp3', song_id)) with pytest.raises(raises): web.backend_worker(worker_queue, my_host, my_id, '/output') assert mocked_post.called assert mocked_post.args[0][1]['json']['id'] == my_id if raises is MemoryError: assert mocked_post.args[0][0] == (my_host + '/ultra_died/', ) else: assert mocked_post.args[0][0] == (my_host + '/died/', )
def text_nca_picker_feedback(nca_picker, monkeypatch, songs_dir): def my_get_userfeedback(feedback): assert feedback['old'] == feedback['good_old'] assert feedback['new'] == feedback['good_new'] assert feedback['old'].file_location != feedback['old'].file_location return feedback['number'] mocked__optimize_weights = MockingFunction() mocked_get_userfeedback = MockingFunction(func=my_get_userfeedback) songs = [] monkeypatch.setattr(nca_picker, 'get_userfeedback', mocked_get_userfeedback) monkeypatch.setattr(nca_picker, '_optimize_weights', mocked__optimize_weights) songs.append(nca_picker.get_next_song(None)) songs.append(nca_picker.get_next_song(None)) songs.append(nca_picker.get_next_song(None)) # Here (4th time) the core will start sending feedback. However this uses a # non existing Seg-1 so it should not be used. See docs/timing.dt for more # information. songs.append(nca_picker.get_next_song(None)) for i in range(10): songs.append( nca_picker.get_next_song({ 'good_old': songs[-5], 'good_new': songs[-4], 'number': i, })) assert mocked_get_userfeedback.called assert mocked__optimize_weights.called
def test_start_music(monkeypatch, app_client, empty): mocked_queue_empty = MockingFunction(lambda: empty, simple=True) monkeypatch.setattr(mp.queues.Queue, 'empty', mocked_queue_empty) mocked_queue_put = MockingFunction() monkeypatch.setattr(mp.queues.Queue, 'put', mocked_queue_put) try: response = app_client.post('/start/', data=json.dumps({}), content_type='application/json') other_res = [] for _ in range(10): other_res.append( app_client.post('/start/', data=json.dumps({}), content_type='application/json')) except Exception as exp: raise exp finally: monkeypatch.undo() mocked_queue_empty.called assert response.status_code == 200 assert json.loads(response.get_data(as_text=True))['ok'] == empty for res in other_res: assert res.status_code == (410 if empty else 200) assert not json.loads(res.get_data(as_text=True))['ok'] if empty: assert mocked_queue_put.called assert mocked_queue_put.args[0][0] == ((web.START_LOOP, ), ) else: assert not mocked_queue_put.called
def test_simple_picker_working_non_direct(monkeypatch, simple_picker): mock_random_choice = MockingFunction(func=random.choice) mock_is_file = MockingFunction(func=lambda i: i > 2, amount=True) monkeypatch.setattr(os.path, 'isfile', mock_is_file) monkeypatch.setattr(random, 'choice', mock_random_choice) simple_picker.get_next_song({}) assert len(mock_is_file.args) == 3 assert len(mock_random_choice.args) == 2
def test_nca_picker_next_song(nca_picker, monkeypatch, songs_dir): real_rand = random.random def feedback_test(feedback): options = { "1453492_Regina_Original_Mix.wav": 0.8, "1665536_Hear_Me_Out_Original_Mix.wav": 0.3, "2064084_New_Day_Original_Mix.wav": 0.7, "2739576_Hunger_Original_Mix.wav": 0.1, "1313776_Slazenger_Joseph_Capriati_Remix.wav": 0.1, "1588390_Where_2D_Meets_3D_Chris_Liebing_Remix.wav": 0.1, "1928097_Egoist_Original_Mix.wav": 0.1, "22538_Panikattack_Original_Mix.wav": 0.1, "3030059_Neve___Me_Original_Mix.wav": 0.1, } needle = False if feedback['old'].find("Bubbler") > 0: needle = feedback['new'] if feedback['new'].find("Bubbler") > 0: needle = feedback['old'] if needle: for key, value in options.items(): if key.find(needle) > 0: return value return real_rand() mock_random = MockingFunction(func=lambda: 0.99999999999, simple=True) monkeypatch.setattr(random, 'random', mock_random) real_rand() assert not mock_random.called mock_feedback = MockingFunction(func=feedback_test) nca_picker.get_feedback = mock_feedback streak = 0 next_song = nca_picker.get_next_song({}) next_song2 = nca_picker.get_next_song({}) assert isinstance(next_song2, dj_feet.song.Song) songs = [next_song.file_location] assert next_song.file_location == next_song2.file_location monkeypatch.undo() for _ in range(50): next_song2_new = nca_picker.get_next_song({}, force=streak > 3) if next_song2.file_location == next_song2_new.file_location: streak += 1 else: streak = 0 next_song2 = next_song2_new songs.append(next_song2.file_location) assert next_song2 is not None assert isinstance(next_song2, dj_feet.song.Song) if next_song == next_song2: pprint(nca_picker.song_distances) pprint(songs) assert mock_feedback.called assert len(songs) == 51
def test_get_class_instance(config, monkeypatch, basecls, cls, cls_args): mock_get_class = MockingFunction(lambda: cls, simple=True) mock_get_class_args = MockingFunction(lambda: cls_args, simple=True) monkeypatch.setattr(config, "get_class", mock_get_class) monkeypatch.setattr(config, "_get_class_args", mock_get_class_args) cls_instance = config._get_class_instance(basecls, cls.__name__) assert vars(cls_instance) == cls_args assert isinstance(cls_instance, cls) assert mock_get_class.called assert mock_get_class.args[0][0] == (basecls, cls.__name__) assert mock_get_class_args.called assert mock_get_class_args.args[0][0] == (cls, basecls.__name__)
def test_add_music(monkeypatch, app_client, throw, url, expected_code): def my_put(): if throw: raise queue.Full('Err') else: return None mocked_queue_put = MockingFunction(my_put, simple=True) monkeypatch.setattr(mp.queues.Queue, 'put_nowait', mocked_queue_put) try: my_file_loc = str(random.random()) + 'location/' song_id = random.randint(10, 1000) res = app_client.post(url, content_type='application/json', data=json.dumps({ 'file_location': my_file_loc, 'id': song_id, })) assert mocked_queue_put.called assert mocked_queue_put.args[0][0][0] == (expected_code, my_file_loc, song_id) assert json.loads(res.get_data(as_text=True))['ok'] != throw assert res.status_code == 200 except Exception as exp: raise exp finally: monkeypatch.undo()
def test_my_flask_getters_and_setters(monkeypatch, func, my_flask): mock_setup = MockingFunction() monkeypatch.setattr(my_flask, 'setup', mock_setup) func(my_flask) assert mock_setup.called
def test_protocol_communicator_feedback(protocol_communicator, monkeypatch, data, _): class MyResponse: def json(self): return data mocked_post_request = MockingFunction(MyResponse, simple=True) monkeypatch.setattr(requests, 'post', mocked_post_request) remote = str(random.randint(0, 1000)) + '-remote' app_id = str(random.randint(1000, 2000)) + '-id' start = str(random.randint(2000, 3000)) + '-start' end = str(random.randint(3000, 4000)) + '-end' res = protocol_communicator.get_user_feedback(remote, app_id, start, end) assert res == data['feedback'] assert mocked_post_request.called assert mocked_post_request.args == [((remote + '/get_feedback/', ), { 'json': { 'start': start, 'end': end, 'id': app_id } })]
def test_loop_excpetion(monkeypatch, mock_controller, mock_forcing_picker, mock_exception_transitioner, mock_communicator, capsys, patched_post): mock_sleep = MockingFunction(lambda: None, simple=True) monkeypatch.setattr(time, 'sleep', mock_sleep) core.loop(0, 'localhost', mock_controller, mock_forcing_picker, mock_exception_transitioner, mock_communicator) _, err = capsys.readouterr()
def test_app_test(monkeypatch): mocked_start = MockingFunction() monkeypatch.setattr(web, 'start', mocked_start) mocked_getenv = MockingFunction(lambda: 500, simple=True) monkeypatch.setattr(os, 'getenv', mocked_getenv) import dj_feet.wsgi as wsgi assert mocked_start.called assert mocked_getenv.called assert len(mocked_getenv.args) == 4 for idx, var in enumerate([ 'SDAAS_ID', 'SDAAS_INPUT_DIR', 'SDAAS_OUTPUT_DIR', 'SDAAS_REMOTE_URL' ]): assert var == mocked_getenv.args[idx][0][0]
def test_loop(monkeypatch, mock_controller, mock_picker, mock_transitioner, mock_communicator, capsys, patched_post): mock_sleep = MockingFunction(lambda: None, simple=True) monkeypatch.setattr(time, 'sleep', mock_sleep) now = round(time.time()) my_id = random.randint(1, 10010101) my_addr = str(random.random()) + "/local" core.loop(my_id, my_addr, mock_controller, mock_picker, mock_transitioner, mock_communicator) _, err = capsys.readouterr() iterations = mock_controller.amount if err: assert mock_controller.waittime_amount < 0 else: assert mock_controller.waittime_emitted == [ x[0][0] for x in mock_sleep.args ] assert all([x[0][0] > 0 for x in mock_sleep.args]) assert mock_controller.amount + 1 == mock_controller.called_amount assert mock_transitioner.merge_emitted == mock_transitioner.write_args if mock_controller.amount >= 5: assert mock_controller.amount == mock_communicator.called_amount + 4 assert len(mock_communicator.emitted) == max( len(mock_picker.feedback) - 4, 0) assert mock_communicator.emitted == mock_picker.feedback[4:] assert mock_communicator.files == mock_picker.emitted assert (not mock_picker.feedback) or mock_picker.feedback[0] == {} if iterations > 4: correct_time = mock_transitioner.max_size * ( iterations - 4) + mock_transitioner.merge_times[-4] assert mock_communicator.end_time == correct_time assert isinstance(mock_communicator.end_time, float) if iterations > 0: assert patched_post.called assert patched_post.args[0][0][0] == my_addr + '/controller_started/' assert patched_post.args[0][1]['json']['id'] == my_id assert patched_post.args[0][1]['json']['epoch'] == now i = 0 for prev, new in mock_transitioner.merge_args: if i == 0: assert prev is None else: assert mock_picker.emitted[i - 1] == prev assert mock_picker.emitted[i] == new i += 1
def test_preserving_force(monkeypatch, nca_picker, _): amount = 0 prev = None def call_and_add(amount, prev): new = nca_picker.get_next_song({}) if prev is None or new.file_location != prev.file_location: return amount + 1, new return amount, new mock_get_feedback = MockingFunction(func=lambda: 1, simple=True) nca_picker.get_feedback = mock_get_feedback monkeypatch.setattr(nca_picker, '_optimize_weights', lambda: mock_get_feedback({})) i = 0 for _ in range(5): amount, prev = call_and_add(amount, prev) if i > 100: nca_picker.reset_songs() nca_picker.get_next_song({}, force=True) nca_picker.get_next_song({}, force=True) nca_picker.get_next_song({}, force=True) if i > 200: assert False i += 1 assert not mock_get_feedback.called for _ in range(10): forced = nca_picker.get_next_song({}, force=True) assert forced.file_location != prev.file_location prev = forced assert not mock_get_feedback.called assert len(nca_picker.picked_songs) == 5 i = 0 while amount <= 5: amount, prev = call_and_add(amount, prev) if i > 100: nca_picker.reset_songs() nca_picker.get_next_song({}, force=True) nca_picker.get_next_song({}, force=True) nca_picker.get_next_song({}, force=True) if i > 200: assert False i += 1 assert len(nca_picker.picked_songs) == 5 if not mock_get_feedback.called: print(nca_picker.picked_songs) assert mock_get_feedback.called
def test_simple_picker_working_direct(monkeypatch, simple_picker, random_song_file, _): mock_random_choice = MockingFunction(func=lambda: random_song_file, simple=True) monkeypatch.setattr(random, 'choice', mock_random_choice) chosen_song = simple_picker.get_next_song({}) assert isinstance(chosen_song, dj_feet.song.Song) assert chosen_song.file_location == random_song_file assert len(mock_random_choice.args) == 1 assert len(mock_random_choice.args[0][0]) == 1 assert len(mock_random_choice.args[0][1]) == 0 assert isinstance(mock_random_choice.args[0][0][0], list) with pytest.raises(ValueError): simple_picker.get_next_song({})
def test_write_sample(inf_jukebox_transitioner, _, random_song_file, monkeypatch): mocking_export = MockingFunction() class MyAudioSegment: def __init__(self, wav): assert wav.startswith('/tmp/') def export(self, *args, **kwargs): mocking_export(*args, **kwargs) mocking_librosa = MockingFunction(lambda x, sample, sr, norm: x) monkeypatch.setattr(librosa.output, 'write_wav', mocking_librosa) mocking_pydub = MockingFunction(MyAudioSegment) monkeypatch.setattr(pydub.AudioSegment, 'from_wav', mocking_pydub) time_series, sr = librosa.load(random_song_file) inf_jukebox_transitioner.write_sample(time_series) assert len(mocking_librosa.args) == 1 assert len(mocking_export.args) == 1 inf_jukebox_transitioner.write_sample(time_series) assert len(mocking_librosa.args) == 2 assert len(mocking_export.args) == 2 assert mocking_librosa.called a = mocking_librosa.args[0][0][1] == time_series assert hasattr(a, '__iter__') and a.all() assert mocking_librosa.args[0][1]['sr'] == sr assert mocking_pydub.called assert mocking_export.args[0][0][0] == os.path.join( inf_jukebox_transitioner.output_folder, "part0.mp3") assert mocking_export.args[1][0][0] == os.path.join( inf_jukebox_transitioner.output_folder, "part1.mp3")
def test_merge_sample(inf_jukebox_transitioner, random_song_files, monkeypatch, same): mocking_append = MockingFunction(func=numpy.append) monkeypatch.setattr(numpy, 'append', mocking_append) song1 = Song(random_song_files[0]) if same: song2 = song1 else: song2 = Song(random_song_files[1]) res, time_delta = inf_jukebox_transitioner.merge(song1, song2) assert (time_delta == inf_jukebox_transitioner.segment_size) == same assert mocking_append.called != same assert abs( librosa.core.get_duration(res, song1.sampling_rate) - inf_jukebox_transitioner.segment_size) < 0.0001
def test_get_the_class_instance(config, monkeypatch, get_types_func, cls, boolean): mock_get_class_instance = MockingFunction(cls, simple=True) monkeypatch.setattr(config, '_get_class_instance', mock_get_class_instance) func = "get_" + get_types_func.__name__.lower() if boolean: inst = getattr(config, func)(cls) assert mock_get_class_instance.called assert mock_get_class_instance.args[0][0] == ( get_types_func, cls, ) else: inst = getattr(config, func)() assert mock_get_class_instance.called assert mock_get_class_instance.args[0][0] == ( get_types_func, None, ) assert isinstance(inst, cls)
def test_protocol_communicator_iteration(protocol_communicator, monkeypatch, _): filename = str(random.randint(0, 1000)) + 'song_location' file_loc = '/tmp/#sdaas_only/' + filename + '.mp3' my_remote = str(random.randint(1000, 2000)) + 'remote' my_id = str(random.randint(1000, 2000)) + 'id' MySong = namedtuple('my_song', 'file_location') a_song = MySong(file_loc) mocked_post_request = MockingFunction() monkeypatch.setattr(requests, 'post', mocked_post_request) protocol_communicator.iteration(my_remote, my_id, a_song) assert mocked_post_request.called assert mocked_post_request.args == [((my_remote + '/iteration/', ), { 'json': { 'id': my_id, 'filename_mixed': filename, } })]
def test_setup(monkeypatch): my_post_request = MockingFunction() monkeypatch.setattr(requests, 'post', my_post_request) my_id = random.randint(0, 100000) my_addr = str(random.randint(0, 100000)) + "-this-is-me-" + str(my_id) with web.app.app_context(): web.start(str(my_id), "/in", "/out", my_addr) stop_worker(web.app.queue, web.app.worker) assert web.app.config['INPUT_DIR'] == '/in' assert web.app.config['OUTPUT_DIR'] == '/out' assert my_post_request.called assert len(my_post_request.args[0][0]) == 1 assert my_post_request.args[0][0][0] == my_addr + '/im_alive/' data = my_post_request.args[0][1]['json'] assert data['id'] == my_id assert 'MyPicker' in data['options']['Picker'] assert 'param1' in data['options']['Picker']['MyPicker']['parts'] assert data['options']['Picker']['MyPicker']['parts']['param1']['required']
def test_get_class(config, monkeypatch, expected, basecls, cls_name, subclasses, boolean): mock_get_all_subclasses = MockingFunction(lambda: subclasses, simple=True) monkeypatch.setattr(helpers, 'get_all_subclasses', mock_get_all_subclasses) def get(): if boolean: return config.get_class(basecls, cls_name) else: monkeypatch.setattr(config, "user_config", {'main': { basecls.__name__: cls_name }}) return config.get_class(basecls, None) if isinstance(expected, type) and issubclass(expected, Exception): with pytest.raises(expected): get() else: assert expected == get() assert mock_get_all_subclasses.called assert mock_get_all_subclasses.args[0][0] == (basecls, )
def test_set_main_option(config, monkeypatch): class MyName(): def __init__(self, num): self.__name__ = str(num) my_picker = str(random.randint(100000, 10000000)) my_picker2 = str(random.randint(0, 100000 - 1)) mocked_get_all_subclasses = MockingFunction( lambda: map(MyName, [0, my_picker2, my_picker]), simple=True) monkeypatch.setattr(helpers, 'get_all_subclasses', mocked_get_all_subclasses) config.update_config_main_options({"Picker": my_picker}) assert config.user_config['main']['Picker'] == my_picker config.update_config_main_options({"Picker": my_picker2}) assert config.user_config['main']['Picker'] == my_picker2 with pytest.raises(ValueError): config.update_config_main_options({"Picker": my_picker * 2}) with pytest.raises(ValueError): config.update_config_main_options({"song_folder": my_picker})
def patched_post(monkeypatch): mocked_post = MockingFunction() monkeypatch.setattr(requests, 'post', mocked_post) yield mocked_post
def test_backend_worker(monkeypatch): class MyAudioSegement(): def __init__(self): self.args = [] self.called = False def export(self, filename, format): self.args.append((filename, format)) self.called = True class MyPicker(pickers.Picker): called = False args = [] def __init__(self, other, rest=101, a=True): pass @staticmethod def process_song_file(song_file, rest): MyPicker.args.append((song_file, rest)) MyPicker.called = True mocked_get_controller = MockingFunction(lambda: 'Controller') mocked_get_picker = MockingFunction(lambda: 'Picker') mocked_get_transitioner = MockingFunction(lambda: 'Transitioner') mocked_get_communicator = MockingFunction(lambda: 'Communicator') monkeypatch.setattr(config.Config, 'get_controller', mocked_get_controller) monkeypatch.setattr(config.Config, 'get_picker', mocked_get_picker) monkeypatch.setattr(config.Config, 'get_transitioner', mocked_get_transitioner) monkeypatch.setattr(config.Config, 'get_communicator', mocked_get_communicator) mocked_loop = MockingFunction() monkeypatch.setattr(core, 'loop', mocked_loop) my_segment = MyAudioSegement() mocked_from_mp3 = MockingFunction(lambda: my_segment, simple=True) monkeypatch.setattr(pydub.AudioSegment, 'from_mp3', mocked_from_mp3) # This also patches .export as this is done in MyAudioSegement mocked_get_class = MockingFunction(lambda: MyPicker, simple=True) monkeypatch.setattr(config.Config, 'get_class', mocked_get_class) mocked_post = MockingFunction() monkeypatch.setattr(requests, 'post', mocked_post) mocked_config_mupdate = MockingFunction() mocked_config_cupdate = MockingFunction() monkeypatch.setattr(config.Config, 'update_config_class_options', mocked_config_cupdate) monkeypatch.setattr(config.Config, 'update_config_main_options', mocked_config_mupdate) mocked_remove = MockingFunction() monkeypatch.setattr(os, 'remove', mocked_remove) worker_queue = queue.Queue() start_loop_arg = random.random() my_host = str(random.random()) + 'loc' my_id = random.randint(0, 1000) song_id = random.randint(1000, 10000) worker_queue.put((web.PROCESS_SONG, '/filename/my_song.mp3', song_id)) worker_queue.put((web.START_LOOP, start_loop_arg)) worker_queue.put((web.OPTIONS, { 'Picker': { 'name': 'MyPicker', 'options': { 'a': None } } })) worker_queue.put((web.DELETE_SONG, '/remove/this.mp3', song_id)) worker_queue.put((web.STOP, )) web.backend_worker(worker_queue, my_host, my_id, '/output') assert mocked_loop.called assert mocked_loop.args[0][0] == (my_id, my_host, 'Controller', 'Picker', 'Transitioner', 'Communicator') assert mocked_from_mp3.called assert my_segment.called assert my_segment.args[0][0].startswith('/tmp/') assert my_segment.args[0][0].endswith('/my_song.wav') assert my_segment.args[0][1] == 'wav' assert mocked_config_cupdate.called assert mocked_config_mupdate.called assert mocked_config_cupdate.args[0][0] == ('Picker', 'MyPicker', { 'a': None }) assert mocked_config_mupdate.args[0][0] == ({'Picker': 'MyPicker'}, ) assert mocked_post.called assert mocked_post.args[0][0][0] == my_host + '/music_processed/' assert mocked_post.args[0][1]['json']['id'] == song_id assert mocked_post.args[1][0][0] == my_host + '/music_deleted/' assert mocked_post.args[1][1]['json']['id'] == song_id assert mocked_remove.called assert mocked_remove.args[0][0][0].endswith('this.wav') assert mocked_remove.args[0][0][0].startswith('/tmp/') assert mocked_get_class.called assert MyPicker.called assert MyPicker.args == [(my_segment.args[0][0], 101)]