def test_tx(self, mock): response = self.node.tx('id') mock.assert_called() assert response.to_json() == { 'type': 4, 'version': 3, 'sender': '3N5PoiMisnbNPseVXcCa5WDRLLHkj7dz4Du', 'senderKeyType': 'ed25519', 'senderPublicKey': 'AneNBwCMTG1YQ5ShPErzJZETTsHEWFnPWhdkKiHG6VTX', 'fee': 100000000, 'timestamp': 1631613596742, 'amount': 10000000, 'recipient': '3N6MFpSbbzTozDcfkTUT5zZ2sNbJKFyRtRj', 'attachment': '', 'height': '', 'id': '74MeWagvnJ2MZTV7wEUQVWG8mTVddS9pJuqvtyG8b5eP', 'proofs': [ 'j2q6isq2atpXBADMZ2Vz7oRozfUKGuDkLnVMqtnXkwDhw6tyHmMMHTbaVknP4JmYiVWN5PuNp6i4f5TBhuc9QSm' ] }
def test_allow_tpay_action(self): request = self.rf.get(reverse("admin:payments_paymentuser_changelist")) request.user = self.user with patch("payments.models.PaymentUser.allow_tpay") as mock: request._messages = Mock() self.admin.allow_thalia_pay(request, PaymentUser.objects.all()) mock.assert_called()
def test_uninstall(mocker): mock = mocker.patch(mocks.make_target("shim", "remove")) # although not specifically mocked, this will not uninstall pytorch-pip-shim since # it is outside the environment we are currently running in pip_uninstall(Package("pytorch-pip-shim", pps.__version__)) mock.assert_called()
def test_trigger_on_custom_chord(self): mock = unittest.mock.Mock() chord = Chord.from_midi_list([20, 40, 60]) self.assertFalse(self.MEL.handlers) # Empty check self.MEL.add_handler(mock, chord) press_chord(self.loopback, chord) mock.assert_called()
def test_trigger_on_sequence(self): mock = unittest.mock.Mock() seq1 = Sequence(Note(1), Note(2), Note(3)) self.assertFalse(self.MEL.handlers) # Empty check self.MEL.add_handler(mock, seq1) press_sequence(self.loopback, seq1) mock.assert_called()
def test_plot_show(self, mock): """Test to prove that plt.show is called in plot() method. Uses mocking """ self.system_probe = SolarSystem(3600, 10000, Options.PROBE_RUN, "CelestialObjects") animate = Animation(self.system_probe) animate.plot() mock.assert_called()
def test_not_adaptive(self): with unittest.mock.patch.object(SimilarTriangles, '_check_relaxation', return_value=None) as mock: self.optimizer = SimilarTriangles(self.model.parameters(), is_adaptive=False) self.closure() self.optimizer.step(self.closure) with self.assertRaises(AssertionError): mock.assert_called()
def test_plot_animate(self, mock, mock2): """Test used to check that a FunCAnimator is used in plot() Uses mocking """ mock.return_value = None self.system_probe = SolarSystem(3600, 10000, Options.PROBE_RUN, "CelestialObjects") animate = Animation(self.system_probe) animate.plot() mock.assert_called()
def test_animate_update(self, mock, mock2): """Test used to prove that update beeman is calld in the animate method Uses mocking. """ self.system_probe = SolarSystem(3600, 10000, Options.PROBE_RUN, "CelestialObjects") animate = Animation(self.system_probe) animate.plot() animate.init() animate.animate(0) mock.assert_called()
def test_scatterplot_update(self, mock, mock2): """Test used to prove that update_beeman() is called 100 times in scatter_plot method if the parameter passed to scatter_plot is 100. uses mocking """ self.system_probe = SolarSystem(3600, 10000, Options.PROBE_RUN, "CelestialObjects") animate = Animation(self.system_probe) animate.scatter_plot(100) mock.assert_called() self.assertEqual(mock.call_count, 100)
def test_decorator_string(self): mock = unittest.mock.Mock() self.assertFalse(self.MEL.handlers) # Empty @self.MEL.on_notes("C4 Major") def sub(): # pragma: no cover mock() self.assertTrue(self.MEL.handlers) # Not empty press_chord(self.loopback, Chord.from_ident("C4 Major")) mock.assert_called()
def test_ingest_oral_arguments(self, mock) -> None: """Can we successfully ingest oral arguments at a high level?""" site = test_oral_arg_scraper.Site() site.method = "LOCAL" parsed_site = site.parse() cl_scrape_oral_arguments.Command().scrape_court(parsed_site, full_crawl=True) # There should now be two items in the database. audio_files = Audio.objects.all() self.assertEqual(2, audio_files.count()) mock.assert_called()
def test_chord_progression_callback(self): c1 = Chord.from_ident("A1 Major") c2 = Chord.from_ident("A2 Major") c3 = Chord.from_ident("A3 Major") cs1 = ChordProgression(c1, c2, c3) mock = unittest.mock.Mock() self.MEL.add_handler(mock, cs1) press_chord(self.loopback, c1) press_chord(self.loopback, c2) press_chord(self.loopback, c3) time.sleep(TEST_CHORD_DELAY) mock.assert_called()
def test_transforms(self, config): mock = unittest.mock.Mock(wraps=lambda *args: args[0] if len(args) == 1 else args) for kwarg in self._TRANSFORM_KWARGS: if kwarg not in self._HAS_SPECIAL_KWARG: continue mock.reset_mock() with self.subTest(kwarg=kwarg): with self.create_dataset(config, **{kwarg: mock}) as (dataset, _): dataset[0] mock.assert_called()
def test_decorator_sequence(self): mock = unittest.mock.Mock() self.assertFalse(self.MEL.handlers) # Empty seq1 = Sequence(Note(5), Note(10), Note(15)) @self.MEL.on_notes(seq1) def sub(): mock() press_sequence(self.loopback, seq1) self.assertTrue(self.MEL.handlers) # Not empty mock.assert_called()
def test_decorator_chord(self): mock = unittest.mock.Mock() self.assertFalse(self.MEL.handlers) # Empty c1 = Chord(Note(5), Note(10), Note(15)) @self.MEL.on_notes(c1) def sub(): mock() self.assertTrue(self.MEL.handlers) # Not empty press_chord(self.loopback, c1) mock.assert_called()
def test_send_mail_with_keeper(self): with unittest.mock.patch( 'prog_code.util.mail_util.get_mail_keeper') as mock: mock.return_value = TEST_MAIL_KEEPER mail_util.send_msg('test address', 'test subject', 'test message') last_message = TEST_MAIL_INSTANCE.last_message self.assertEqual(last_message.subject, 'test subject') self.assertEqual(last_message.sender, 'from addr') self.assertEqual(last_message.body, 'test message') self.assertEqual(last_message.recipients, ['testaddress']) mock.assert_called()
def test_ingest_opinions_from_scraper(self, mock) -> None: """Can we successfully ingest opinions at a high level?""" site = test_opinion_scraper.Site() site.method = "LOCAL" parsed_site = site.parse() cl_scrape_opinions.Command().scrape_court(parsed_site, full_crawl=True, ocr_available=False) opinions = Opinion.objects.all() count = opinions.count() self.assertTrue( opinions.count() == 6, f"Should have 6 test opinions, not {count}", ) mock.assert_called()
def test_delete_search_query_restore(self): with unittest.mock.patch('prog_code.util.db_util.get_db_connection') as mock: fake_cursor = TestDBCursor() fake_connection = TestDBConnection(fake_cursor) mock.return_value = fake_connection filters = [ models.Filter('study', 'eq', 'study1,study2') ] filter_util.run_delete_query(filters, 'test', True) query = fake_cursor.queries[1] query_str ='UPDATE test SET deleted=0 WHERE (study == ? OR study == ?)' self.assertEqual(query, query_str) operands = fake_cursor.operands[0] self.assertEqual(len(operands), 2) self.assertEqual(operands[0], 'study1') self.assertEqual(operands[1], 'study2') mock.assert_called()
def test_update_training_data_set_with_update( mock, data_set_manager, file_repository_stub, workspace_stub, interpolated_sample_stubs_fixture): workspace_stub.training_data_set.last_modified = 1617981582110 data_set_manager.update_training_data_set() mock.assert_called() assert workspace_stub.training_data_set.last_modified == DataSourceStub.last_modified( workspace_stub.user_id, workspace_stub._id) assert not workspace_stub.training_data_set.feature_extraction_cache assert len(file_repository_stub.files) == 1 files_in_repository = pickle.loads( file_repository_stub.get_file( workspace_stub.training_data_set.sample_list_file_ID)) assert len(files_in_repository) == len(interpolated_sample_stubs_fixture) for i in range(len(files_in_repository)): assert files_in_repository[ i].label == interpolated_sample_stubs_fixture[i].label assert files_in_repository[i].data_frame.equals( interpolated_sample_stubs_fixture[i].data_frame)
def test_run_with_settings_dir(fake_manifest: FixtureType) -> None: base_dir = pathlib.Path("/foo") settings_dir = pathlib.Path("/settings") options = RunOptions() ref = [1.0] manifest = fake_manifest(base_dir, settings_dir, ref) runner = Runner(manifest) reporters = ReporterFactory() manifest_args = runner.parse_manifest_arguments([]) with unittest.mock.patch("pathlib.Path.mkdir") as mock: runner.run( "op1", base_dir, manifest_args, reporters, options, settings_dir=settings_dir, files=None, ) mock.assert_called() assert math.isclose(ref[0], 6.0) assert not reporters.has_error()
def test_run_search_query(self): with unittest.mock.patch('prog_code.util.db_util.get_db_connection') as mock: fake_cursor = TestDBCursor() fake_connection = TestDBConnection(fake_cursor) mock.return_value = fake_connection filters = [ models.Filter('study', 'eq', 'study1,study2') ] filter_util.run_search_query(filters, 'test') query = fake_cursor.queries[0] query_str ='SELECT * FROM test WHERE (study == ? OR study == ?) AND '\ '(deleted == ?)' self.assertEqual(query, query_str) operands = fake_cursor.operands[0] self.assertEqual(len(operands), 3) self.assertEqual(operands[0], 'study1') self.assertEqual(operands[1], 'study2') self.assertEqual(operands[2], 0) mock.assert_called()
def test_process_audio_file(self, mock) -> None: af = Audio.objects.get(pk=1) af.duration = None af.save() expected_duration = 15.0 self.assertNotEqual( af.duration, expected_duration, msg="Do we have no duration info at the outset?", ) process_audio_file(pk=1) af.refresh_from_db() measured_duration: float = af.duration # type: ignore # Use almost equal because measuring MP3's is wonky. self.assertAlmostEqual( measured_duration, expected_duration, delta=5, msg="We should end up with the proper duration of about %s. " "Instead we got %s." % (expected_duration, measured_duration), ) mock.assert_called()
def test_last_block(self, mock): self.node.last_block() mock.assert_called()
def test_compile(self, mock): self.node.compile('sddsfdsf') mock.assert_called()
def test_existingemail_fail(self, mock: mock.Mock) -> None: self.submit_form('login', 'input_id_login', send_form_keys={'id_email': '*****@*****.**'}) mock.assert_called() self.assert_url_equal('token_sent')
def test_send_mail_no_keeper(self): with unittest.mock.patch( 'prog_code.util.mail_util.get_mail_keeper') as mock: mock.return_value = None mail_util.send_msg('test address', 'test subject', 'test message') mock.assert_called()
def test_height(self, mock): self.node.height() mock.assert_called()
def test_block(self, mock): self.node.block(20) mock.assert_called()
def test_validate_config_and_parse_hyperparameters_with_valid_config( mock, valid_training_config, workspace_sensors): validate_config_and_parse_hyperparameters(valid_training_config, workspace_sensors) mock.assert_called()