Backup_Repos/beets
1
0
Fork 0
mirror of https://github.com/beetbox/beets.git synced 2025-12-06 16:42:42 +01:00
Code Issues Projects Releases Wiki Activity

Define AsIsImporterMixin to run autotag=False importer

Browse source
This commit is contained in:
Šarūnas Nejus 2024-07-12 22:35:07 +01:00
parent f042f5ad32
commit 8d85cfd72a
No known key found for this signature in database
GPG key ID: DD28F6704DBE3435
7 changed files with 68 additions and 105 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
beets/test/helper.py
View file

@ -624,6 +624,17 @@ class ImportHelper(TestHelper):
self.assertEqual(len(os.listdir(syspath(self.libdir))), 0) self.assertEqual(len(os.listdir(syspath(self.libdir))), 0)
class AsIsImporterMixin:
def setUp(self):
super().setUp()
self.prepare_album_for_import(1)
def run_asis_importer(self, **kwargs):
importer = self.setup_importer(autotag=False, **kwargs)
importer.run()
return importer
class ImportTestCase(ImportHelper, BeetsTestCase): class ImportTestCase(ImportHelper, BeetsTestCase):
pass pass

12
test/plugins/test_convert.py
View file

@ -24,6 +24,7 @@ from mediafile import MediaFile
from beets import util from beets import util
from beets.test import _common from beets.test import _common
from beets.test.helper import ( from beets.test.helper import (
AsIsImporterMixin,
ImportHelper, ImportHelper,
PluginTestCase, PluginTestCase,
capture_log, capture_log,
@ -95,12 +96,9 @@ class ConvertTestCase(ConvertMixin, PluginTestCase):
@_common.slow_test() @_common.slow_test()
class ImportConvertTest(ImportHelper, ConvertTestCase): class ImportConvertTest(AsIsImporterMixin, ImportHelper, ConvertTestCase):
def setUp(self): def setUp(self):
super().setUp() super().setUp()
self.prepare_album_for_import(1)
self.importer = self.setup_importer(autotag=False)
self.config["convert"] = { self.config["convert"] = {
"dest": os.path.join(self.temp_dir, b"convert"), "dest": os.path.join(self.temp_dir, b"convert"),
"command": self.tagged_copy_cmd("convert"), "command": self.tagged_copy_cmd("convert"),
@ -111,7 +109,7 @@ class ImportConvertTest(ImportHelper, ConvertTestCase):
} }
def test_import_converted(self): def test_import_converted(self):
self.importer.run() self.run_asis_importer()
item = self.lib.items().get() item = self.lib.items().get()
self.assertFileTag(item.path, "convert") self.assertFileTag(item.path, "convert")
@ -120,7 +118,7 @@ class ImportConvertTest(ImportHelper, ConvertTestCase):
def test_import_original_on_convert_error(self): def test_import_original_on_convert_error(self):
# `false` exits with non-zero code # `false` exits with non-zero code
self.config["convert"]["command"] = "false" self.config["convert"]["command"] = "false"
self.importer.run() self.run_asis_importer()
item = self.lib.items().get() item = self.lib.items().get()
self.assertIsNotNone(item) self.assertIsNotNone(item)
@ -128,7 +126,7 @@ class ImportConvertTest(ImportHelper, ConvertTestCase):
def test_delete_originals(self): def test_delete_originals(self):
self.config["convert"]["delete_originals"] = True self.config["convert"]["delete_originals"] = True
self.importer.run() self.run_asis_importer()
for path in self.importer.paths: for path in self.importer.paths:
for root, dirnames, filenames in os.walk(path): for root, dirnames, filenames in os.walk(path):
self.assertEqual( self.assertEqual(

7
test/plugins/test_keyfinder.py
View file

@ -17,11 +17,11 @@ from unittest.mock import patch
from beets import util from beets import util
from beets.library import Item from beets.library import Item
from beets.test.helper import ImportTestCase, PluginMixin from beets.test.helper import AsIsImporterMixin, ImportTestCase, PluginMixin
@patch("beets.util.command_output") @patch("beets.util.command_output")
class KeyFinderTest(PluginMixin, ImportTestCase): class KeyFinderTest(AsIsImporterMixin, PluginMixin, ImportTestCase):
plugin = "keyfinder" plugin = "keyfinder"
def test_add_key(self, command_output): def test_add_key(self, command_output):
@ -39,8 +39,7 @@ class KeyFinderTest(PluginMixin, ImportTestCase):
def test_add_key_on_import(self, command_output): def test_add_key_on_import(self, command_output):
command_output.return_value = util.CommandOutput(b"dbm", b"") command_output.return_value = util.CommandOutput(b"dbm", b"")
self.prepare_album_for_import(1) self.run_asis_importer()
self.setup_importer(autotag=False).run()
item = self.lib.items().get() item = self.lib.items().get()
self.assertEqual(item["initial_key"], "C#m") self.assertEqual(item["initial_key"], "C#m")

10
test/plugins/test_permissions.py
View file

@ -6,7 +6,7 @@ import platform
from unittest.mock import Mock, patch from unittest.mock import Mock, patch
from beets.test._common import touch from beets.test._common import touch
from beets.test.helper import ImportTestCase, PluginMixin from beets.test.helper import AsIsImporterMixin, ImportTestCase, PluginMixin
from beets.util import displayable_path from beets.util import displayable_path
from beetsplug.permissions import ( from beetsplug.permissions import (
check_permissions, check_permissions,
@ -15,14 +15,13 @@ from beetsplug.permissions import (
) )
class PermissionsPluginTest(PluginMixin, ImportTestCase): class PermissionsPluginTest(AsIsImporterMixin, PluginMixin, ImportTestCase):
plugin = "permissions" plugin = "permissions"
def setUp(self): def setUp(self):
super().setUp() super().setUp()
self.config["permissions"] = {"file": "777", "dir": "777"} self.config["permissions"] = {"file": "777", "dir": "777"}
self.prepare_album_for_import(1)
def test_permissions_on_album_imported(self): def test_permissions_on_album_imported(self):
self.do_thing(True) self.do_thing(True)
@ -45,7 +44,6 @@ class PermissionsPluginTest(PluginMixin, ImportTestCase):
& 0o777 & 0o777
) )
self.importer = self.setup_importer(autotag=False)
typs = ["file", "dir"] typs = ["file", "dir"]
track_file = (b"album", b"track_1.mp3") track_file = (b"album", b"track_1.mp3")
@ -57,7 +55,7 @@ class PermissionsPluginTest(PluginMixin, ImportTestCase):
False: {k: get_stat(v) for (k, v) in zip(typs, (track_file, ()))}, False: {k: get_stat(v) for (k, v) in zip(typs, (track_file, ()))},
} }
self.importer.run() self.run_asis_importer()
item = self.lib.items().get() item = self.lib.items().get()
self.assertPerms(item.path, "file", expect_success) self.assertPerms(item.path, "file", expect_success)
@ -94,7 +92,7 @@ class PermissionsPluginTest(PluginMixin, ImportTestCase):
def do_set_art(self, expect_success): def do_set_art(self, expect_success):
if platform.system() == "Windows": if platform.system() == "Windows":
self.skipTest("permissions not available on Windows") self.skipTest("permissions not available on Windows")
self.setup_importer(autotag=False).run() self.run_asis_importer()
album = self.lib.albums().get() album = self.lib.albums().get()
artpath = os.path.join(self.temp_dir, b"cover.jpg") artpath = os.path.join(self.temp_dir, b"cover.jpg")
touch(artpath) touch(artpath)

9
test/plugins/test_replaygain.py
View file

@ -19,7 +19,7 @@ from typing import ClassVar
from mediafile import MediaFile from mediafile import MediaFile
from beets import config from beets import config
from beets.test.helper import ImportTestCase, has_program from beets.test.helper import AsIsImporterMixin, ImportTestCase, has_program
from beetsplug.replaygain import ( from beetsplug.replaygain import (
FatalGstreamerPluginReplayGainError, FatalGstreamerPluginReplayGainError,
GStreamerBackend, GStreamerBackend,
@ -68,9 +68,6 @@ class ReplayGainTestCase(ImportTestCase):
except Exception: except Exception:
self.tearDown() self.tearDown()
self.prepare_album_for_import(1)
self.importer = self.setup_importer(autotag=False)
def tearDown(self): def tearDown(self):
self.unload_plugins() self.unload_plugins()
super().tearDown() super().tearDown()
@ -360,9 +357,9 @@ class ReplayGainFfmpegNoiseCliTest(
FNAME = "whitenoise" FNAME = "whitenoise"
class ImportTest: class ImportTest(AsIsImporterMixin):
def test_import_converted(self): def test_import_converted(self):
self.importer.run() self.run_asis_importer()
for item in self.lib.items(): for item in self.lib.items():
# FIXME: Add fixtures with known track/album gain (within a # FIXME: Add fixtures with known track/album gain (within a
# suitable tolerance) so that we can actually check correct # suitable tolerance) so that we can actually check correct

95
test/test_importer.py
View file

@ -35,6 +35,7 @@ from beets.autotag import AlbumInfo, AlbumMatch, TrackInfo
from beets.importer import albums_in_dir from beets.importer import albums_in_dir
from beets.test import _common from beets.test import _common
from beets.test.helper import ( from beets.test.helper import (
AsIsImporterMixin,
AutotagStub, AutotagStub,
BeetsTestCase, BeetsTestCase,
ImportTestCase, ImportTestCase,
@ -45,15 +46,10 @@ from beets.test.helper import (
from beets.util import bytestring_path, displayable_path, syspath from beets.util import bytestring_path, displayable_path, syspath
class ScrubbedImportTest(PluginMixin, ImportTestCase): class ScrubbedImportTest(AsIsImporterMixin, PluginMixin, ImportTestCase):
db_on_disk = True db_on_disk = True
plugin = "scrub" plugin = "scrub"
def setUp(self):
super().setUp()
self.prepare_album_for_import(1)
self.setup_importer(autotag=False)
def test_tags_not_scrubbed(self): def test_tags_not_scrubbed(self):
config["plugins"] = ["scrub"] config["plugins"] = ["scrub"]
config["scrub"]["auto"] = False config["scrub"]["auto"] = False
@ -61,7 +57,7 @@ class ScrubbedImportTest(PluginMixin, ImportTestCase):
for mediafile in self.import_media: for mediafile in self.import_media:
self.assertEqual(mediafile.artist, "Tag Artist") self.assertEqual(mediafile.artist, "Tag Artist")
self.assertEqual(mediafile.album, "Tag Album") self.assertEqual(mediafile.album, "Tag Album")
self.importer.run() self.run_asis_importer()
for item in self.lib.items(): for item in self.lib.items():
imported_file = os.path.join(item.path) imported_file = os.path.join(item.path)
imported_file = MediaFile(imported_file) imported_file = MediaFile(imported_file)
@ -75,7 +71,7 @@ class ScrubbedImportTest(PluginMixin, ImportTestCase):
for mediafile in self.import_media: for mediafile in self.import_media:
self.assertEqual(mediafile.artist, "Tag Artist") self.assertEqual(mediafile.artist, "Tag Artist")
self.assertEqual(mediafile.album, "Tag Album") self.assertEqual(mediafile.album, "Tag Album")
self.importer.run() self.run_asis_importer()
for item in self.lib.items(): for item in self.lib.items():
imported_file = os.path.join(item.path) imported_file = os.path.join(item.path)
imported_file = MediaFile(imported_file) imported_file = MediaFile(imported_file)
@ -89,7 +85,7 @@ class ScrubbedImportTest(PluginMixin, ImportTestCase):
for mediafile in self.import_media: for mediafile in self.import_media:
self.assertEqual(mediafile.artist, "Tag Artist") self.assertEqual(mediafile.artist, "Tag Artist")
self.assertEqual(mediafile.album, "Tag Album") self.assertEqual(mediafile.album, "Tag Album")
self.importer.run() self.run_asis_importer()
for item in self.lib.items(): for item in self.lib.items():
imported_file = os.path.join(item.path) imported_file = os.path.join(item.path)
imported_file = MediaFile(imported_file) imported_file = MediaFile(imported_file)
@ -98,22 +94,17 @@ class ScrubbedImportTest(PluginMixin, ImportTestCase):
@_common.slow_test() @_common.slow_test()
class NonAutotaggedImportTest(ImportTestCase): class NonAutotaggedImportTest(AsIsImporterMixin, ImportTestCase):
db_on_disk = True db_on_disk = True
def setUp(self):
super().setUp()
self.prepare_album_for_import(1)
self.setup_importer(autotag=False)
def test_album_created_with_track_artist(self): def test_album_created_with_track_artist(self):
self.importer.run() self.run_asis_importer()
albums = self.lib.albums() albums = self.lib.albums()
self.assertEqual(len(albums), 1) self.assertEqual(len(albums), 1)
self.assertEqual(albums[0].albumartist, "Tag Artist") self.assertEqual(albums[0].albumartist, "Tag Artist")
def test_import_copy_arrives(self): def test_import_copy_arrives(self):
self.importer.run() self.run_asis_importer()
for mediafile in self.import_media: for mediafile in self.import_media:
self.assert_file_in_lib( self.assert_file_in_lib(
b"Tag Artist", b"Tag Artist",
@ -124,7 +115,7 @@ class NonAutotaggedImportTest(ImportTestCase):
def test_threaded_import_copy_arrives(self): def test_threaded_import_copy_arrives(self):
config["threaded"] = True config["threaded"] = True
self.importer.run() self.run_asis_importer()
for mediafile in self.import_media: for mediafile in self.import_media:
self.assert_file_in_lib( self.assert_file_in_lib(
b"Tag Artist", b"Tag Artist",
@ -133,35 +124,27 @@ class NonAutotaggedImportTest(ImportTestCase):
) )
def test_import_with_move_deletes_import_files(self): def test_import_with_move_deletes_import_files(self):
config["import"]["move"] = True
for mediafile in self.import_media: for mediafile in self.import_media:
self.assertExists(mediafile.path) self.assertExists(mediafile.path)
self.importer.run() self.run_asis_importer(move=True)
for mediafile in self.import_media: for mediafile in self.import_media:
self.assertNotExists(mediafile.path) self.assertNotExists(mediafile.path)
def test_import_with_move_prunes_directory_empty(self): def test_import_with_move_prunes_directory_empty(self):
config["import"]["move"] = True
self.assertExists(os.path.join(self.import_dir, b"album")) self.assertExists(os.path.join(self.import_dir, b"album"))
self.importer.run() self.run_asis_importer(move=True)
self.assertNotExists(os.path.join(self.import_dir, b"album")) self.assertNotExists(os.path.join(self.import_dir, b"album"))
def test_import_with_move_prunes_with_extra_clutter(self): def test_import_with_move_prunes_with_extra_clutter(self):
self.touch(os.path.join(self.import_dir, b"album", b"alog.log")) self.touch(os.path.join(self.import_dir, b"album", b"alog.log"))
config["clutter"] = ["*.log"] config["clutter"] = ["*.log"]
config["import"]["move"] = True
self.assertExists(os.path.join(self.import_dir, b"album")) self.assertExists(os.path.join(self.import_dir, b"album"))
self.importer.run() self.run_asis_importer(move=True)
self.assertNotExists(os.path.join(self.import_dir, b"album")) self.assertNotExists(os.path.join(self.import_dir, b"album"))
def test_threaded_import_move_arrives(self): def test_threaded_import_move_arrives(self):
config["import"]["move"] = True self.run_asis_importer(move=True, threaded=True)
config["import"]["threaded"] = True
self.importer.run()
for mediafile in self.import_media: for mediafile in self.import_media:
self.assert_file_in_lib( self.assert_file_in_lib(
b"Tag Artist", b"Tag Artist",
@ -170,36 +153,28 @@ class NonAutotaggedImportTest(ImportTestCase):
) )
def test_threaded_import_move_deletes_import(self): def test_threaded_import_move_deletes_import(self):
config["import"]["move"] = True self.run_asis_importer(move=True, threaded=True)
config["threaded"] = True
self.importer.run()
for mediafile in self.import_media: for mediafile in self.import_media:
self.assertNotExists(mediafile.path) self.assertNotExists(mediafile.path)
def test_import_without_delete_retains_files(self): def test_import_without_delete_retains_files(self):
config["import"]["delete"] = False self.run_asis_importer(delete=False)
self.importer.run()
for mediafile in self.import_media: for mediafile in self.import_media:
self.assertExists(mediafile.path) self.assertExists(mediafile.path)
def test_import_with_delete_removes_files(self): def test_import_with_delete_removes_files(self):
config["import"]["delete"] = True self.run_asis_importer(delete=True)
self.importer.run()
for mediafile in self.import_media: for mediafile in self.import_media:
self.assertNotExists(mediafile.path) self.assertNotExists(mediafile.path)
def test_import_with_delete_prunes_directory_empty(self): def test_import_with_delete_prunes_directory_empty(self):
config["import"]["delete"] = True
self.assertExists(os.path.join(self.import_dir, b"album")) self.assertExists(os.path.join(self.import_dir, b"album"))
self.importer.run() self.run_asis_importer(delete=True)
self.assertNotExists(os.path.join(self.import_dir, b"album")) self.assertNotExists(os.path.join(self.import_dir, b"album"))
@unittest.skipUnless(_common.HAVE_SYMLINK, "need symlinks") @unittest.skipUnless(_common.HAVE_SYMLINK, "need symlinks")
def test_import_link_arrives(self): def test_import_link_arrives(self):
config["import"]["link"] = True self.run_asis_importer(link=True)
self.importer.run()
for mediafile in self.import_media: for mediafile in self.import_media:
filename = os.path.join( filename = os.path.join(
self.libdir, self.libdir,
@ -216,8 +191,7 @@ class NonAutotaggedImportTest(ImportTestCase):
@unittest.skipUnless(_common.HAVE_HARDLINK, "need hardlinks") @unittest.skipUnless(_common.HAVE_HARDLINK, "need hardlinks")
def test_import_hardlink_arrives(self): def test_import_hardlink_arrives(self):
config["import"]["hardlink"] = True self.run_asis_importer(hardlink=True)
self.importer.run()
for mediafile in self.import_media: for mediafile in self.import_media:
filename = os.path.join( filename = os.path.join(
self.libdir, self.libdir,
@ -237,8 +211,7 @@ class NonAutotaggedImportTest(ImportTestCase):
def test_import_reflink_arrives(self): def test_import_reflink_arrives(self):
# Detecting reflinks is currently tricky due to various fs # Detecting reflinks is currently tricky due to various fs
# implementations, we'll just check the file exists. # implementations, we'll just check the file exists.
config["import"]["reflink"] = True self.run_asis_importer(reflink=True)
self.importer.run()
for mediafile in self.import_media: for mediafile in self.import_media:
self.assert_file_in_lib( self.assert_file_in_lib(
b"Tag Artist", b"Tag Artist",
@ -248,8 +221,7 @@ class NonAutotaggedImportTest(ImportTestCase):
def test_import_reflink_auto_arrives(self): def test_import_reflink_auto_arrives(self):
# Should pass regardless of reflink support due to fallback. # Should pass regardless of reflink support due to fallback.
config["import"]["reflink"] = "auto" self.run_asis_importer(reflink="auto")
self.importer.run()
for mediafile in self.import_media: for mediafile in self.import_media:
self.assert_file_in_lib( self.assert_file_in_lib(
b"Tag Artist", b"Tag Artist",
@ -269,7 +241,7 @@ def create_archive(session):
return path return path
class RmTempTest(ImportTestCase): class RmTempTest(BeetsTestCase):
"""Tests that temporarily extracted archives are properly removed """Tests that temporarily extracted archives are properly removed
after usage. after usage.
""" """
@ -285,20 +257,18 @@ class RmTempTest(ImportTestCase):
archive_task = importer.ArchiveImportTask(zip_path) archive_task = importer.ArchiveImportTask(zip_path)
archive_task.extract() archive_task.extract()
tmp_path = archive_task.toppath tmp_path = archive_task.toppath
self.setup_importer(autotag=False, import_dir=tmp_path)
self.assertExists(tmp_path) self.assertExists(tmp_path)
archive_task.finalize(self) archive_task.finalize(self)
self.assertNotExists(tmp_path) self.assertNotExists(tmp_path)
class ImportZipTest(ImportTestCase): class ImportZipTest(AsIsImporterMixin, ImportTestCase):
def test_import_zip(self): def test_import_zip(self):
zip_path = create_archive(self) zip_path = create_archive(self)
self.assertEqual(len(self.lib.items()), 0) self.assertEqual(len(self.lib.items()), 0)
self.assertEqual(len(self.lib.albums()), 0) self.assertEqual(len(self.lib.albums()), 0)
self.setup_importer(autotag=False, import_dir=zip_path) self.run_asis_importer(import_dir=zip_path)
self.importer.run()
self.assertEqual(len(self.lib.items()), 1) self.assertEqual(len(self.lib.items()), 1)
self.assertEqual(len(self.lib.albums()), 1) self.assertEqual(len(self.lib.albums()), 1)
@ -1402,14 +1372,9 @@ class ResumeImportTest(ImportTestCase):
self.assertIsNotNone(self.lib.items("title:'Track 1'").get()) self.assertIsNotNone(self.lib.items("title:'Track 1'").get())
class IncrementalImportTest(ImportTestCase): class IncrementalImportTest(AsIsImporterMixin, ImportTestCase):
def setUp(self):
super().setUp()
self.prepare_album_for_import(1)
def test_incremental_album(self): def test_incremental_album(self):
importer = self.setup_importer(autotag=False, incremental=True) importer = self.run_asis_importer(incremental=True)
importer.run()
# Change album name so the original file would be imported again # Change album name so the original file would be imported again
# if incremental was off. # if incremental was off.
@ -1421,10 +1386,7 @@ class IncrementalImportTest(ImportTestCase):
self.assertEqual(len(self.lib.albums()), 2) self.assertEqual(len(self.lib.albums()), 2)
def test_incremental_item(self): def test_incremental_item(self):
importer = self.setup_importer( importer = self.run_asis_importer(incremental=True, singletons=True)
autotag=False, incremental=True, singletons=True
)
importer.run()
# Change track name so the original file would be imported again # Change track name so the original file would be imported again
# if incremental was off. # if incremental was off.
@ -1436,10 +1398,9 @@ class IncrementalImportTest(ImportTestCase):
self.assertEqual(len(self.lib.items()), 2) self.assertEqual(len(self.lib.items()), 2)
def test_invalid_state_file(self): def test_invalid_state_file(self):
importer = self.setup_importer(autotag=False, incremental=True)
with open(self.config["statefile"].as_filename(), "wb") as f: with open(self.config["statefile"].as_filename(), "wb") as f:
f.write(b"000") f.write(b"000")
importer.run() self.run_asis_importer(incremental=True)
self.assertEqual(len(self.lib.albums()), 1) self.assertEqual(len(self.lib.albums()), 1)

29
test/test_logging.py
View file

@ -9,7 +9,12 @@ import beets.logging as blog
import beetsplug import beetsplug
from beets import plugins, ui from beets import plugins, ui
from beets.test import _common, helper from beets.test import _common, helper
from beets.test.helper import BeetsTestCase, ImportTestCase, PluginMixin from beets.test.helper import (
AsIsImporterMixin,
BeetsTestCase,
ImportTestCase,
PluginMixin,
)
class LoggingTest(BeetsTestCase): class LoggingTest(BeetsTestCase):
@ -46,7 +51,7 @@ class LoggingTest(BeetsTestCase):
self.assertTrue(stream.getvalue(), "foo oof baz") self.assertTrue(stream.getvalue(), "foo oof baz")
class LoggingLevelTest(PluginMixin, ImportTestCase): class LoggingLevelTest(AsIsImporterMixin, PluginMixin, ImportTestCase):
plugin = "dummy" plugin = "dummy"
class DummyModule: class DummyModule:
@ -135,8 +140,7 @@ class LoggingLevelTest(PluginMixin, ImportTestCase):
def test_import_stage_level0(self): def test_import_stage_level0(self):
self.config["verbose"] = 0 self.config["verbose"] = 0
with helper.capture_log() as logs: with helper.capture_log() as logs:
self.prepare_album_for_import(1) self.run_asis_importer()
self.setup_importer(autotag=False).run()
self.assertIn("dummy: warning import_stage", logs) self.assertIn("dummy: warning import_stage", logs)
self.assertNotIn("dummy: info import_stage", logs) self.assertNotIn("dummy: info import_stage", logs)
self.assertNotIn("dummy: debug import_stage", logs) self.assertNotIn("dummy: debug import_stage", logs)
@ -144,8 +148,7 @@ class LoggingLevelTest(PluginMixin, ImportTestCase):
def test_import_stage_level1(self): def test_import_stage_level1(self):
self.config["verbose"] = 1 self.config["verbose"] = 1
with helper.capture_log() as logs: with helper.capture_log() as logs:
self.prepare_album_for_import(1) self.run_asis_importer()
self.setup_importer(autotag=False).run()
self.assertIn("dummy: warning import_stage", logs) self.assertIn("dummy: warning import_stage", logs)
self.assertIn("dummy: info import_stage", logs) self.assertIn("dummy: info import_stage", logs)
self.assertNotIn("dummy: debug import_stage", logs) self.assertNotIn("dummy: debug import_stage", logs)
@ -153,15 +156,14 @@ class LoggingLevelTest(PluginMixin, ImportTestCase):
def test_import_stage_level2(self): def test_import_stage_level2(self):
self.config["verbose"] = 2 self.config["verbose"] = 2
with helper.capture_log() as logs: with helper.capture_log() as logs:
self.prepare_album_for_import(1) self.run_asis_importer()
self.setup_importer(autotag=False).run()
self.assertIn("dummy: warning import_stage", logs) self.assertIn("dummy: warning import_stage", logs)
self.assertIn("dummy: info import_stage", logs) self.assertIn("dummy: info import_stage", logs)
self.assertIn("dummy: debug import_stage", logs) self.assertIn("dummy: debug import_stage", logs)
@_common.slow_test() @_common.slow_test()
class ConcurrentEventsTest(ImportTestCase): class ConcurrentEventsTest(AsIsImporterMixin, ImportTestCase):
"""Similar to LoggingLevelTest but lower-level and focused on multiple """Similar to LoggingLevelTest but lower-level and focused on multiple
events interaction. Since this is a bit heavy we don't do it in events interaction. Since this is a bit heavy we don't do it in
LoggingLevelTest. LoggingLevelTest.
@ -264,20 +266,17 @@ class ConcurrentEventsTest(ImportTestCase):
blog.getLogger("beets").set_global_level(blog.WARNING) blog.getLogger("beets").set_global_level(blog.WARNING)
with helper.capture_log() as logs: with helper.capture_log() as logs:
self.prepare_album_for_import(1) self.run_asis_importer()
self.setup_importer(autotag=False).run()
self.assertEqual(logs, []) self.assertEqual(logs, [])
blog.getLogger("beets").set_global_level(blog.INFO) blog.getLogger("beets").set_global_level(blog.INFO)
with helper.capture_log() as logs: with helper.capture_log() as logs:
self.prepare_album_for_import(1) self.run_asis_importer()
self.setup_importer(autotag=False).run()
for l in logs: for l in logs:
self.assertIn("import", l) self.assertIn("import", l)
self.assertIn("album", l) self.assertIn("album", l)
blog.getLogger("beets").set_global_level(blog.DEBUG) blog.getLogger("beets").set_global_level(blog.DEBUG)
with helper.capture_log() as logs: with helper.capture_log() as logs:
self.prepare_album_for_import(1) self.run_asis_importer()
self.setup_importer(autotag=False).run()
self.assertIn("Sending event: database_change", logs) self.assertIn("Sending event: database_change", logs)