mirror of
https://github.com/beetbox/beets.git
synced 2025-12-06 08:39:17 +01:00
1637 lines
54 KiB
Python
1637 lines
54 KiB
Python
# This file is part of beets.
|
|
# Copyright 2016, Adrian Sampson.
|
|
#
|
|
# Permission is hereby granted, free of charge, to any person obtaining
|
|
# a copy of this software and associated documentation files (the
|
|
# "Software"), to deal in the Software without restriction, including
|
|
# without limitation the rights to use, copy, modify, merge, publish,
|
|
# distribute, sublicense, and/or sell copies of the Software, and to
|
|
# permit persons to whom the Software is furnished to do so, subject to
|
|
# the following conditions:
|
|
#
|
|
# The above copyright notice and this permission notice shall be
|
|
# included in all copies or substantial portions of the Software.
|
|
|
|
"""Tests for the command-line interface.
|
|
"""
|
|
|
|
import os
|
|
import platform
|
|
import re
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
import unittest
|
|
from unittest.mock import Mock, patch
|
|
|
|
import pytest
|
|
from confuse import ConfigError
|
|
from mediafile import MediaFile
|
|
|
|
from beets import autotag, config, library, plugins, ui, util
|
|
from beets.autotag.match import distance
|
|
from beets.test import _common
|
|
from beets.test.helper import (
|
|
BeetsTestCase,
|
|
PluginTestCase,
|
|
capture_stdout,
|
|
control_stdin,
|
|
has_program,
|
|
)
|
|
from beets.ui import commands
|
|
from beets.util import MoveOperation, syspath
|
|
|
|
|
|
class ListTest(BeetsTestCase):
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.item = _common.item()
|
|
self.item.path = "xxx/yyy"
|
|
self.lib.add(self.item)
|
|
self.lib.add_album([self.item])
|
|
|
|
def _run_list(self, query="", album=False, path=False, fmt=""):
|
|
with capture_stdout() as stdout:
|
|
commands.list_items(self.lib, query, album, fmt)
|
|
return stdout
|
|
|
|
def test_list_outputs_item(self):
|
|
stdout = self._run_list()
|
|
assert "the title" in stdout.getvalue()
|
|
|
|
def test_list_unicode_query(self):
|
|
self.item.title = "na\xefve"
|
|
self.item.store()
|
|
self.lib._connection().commit()
|
|
|
|
stdout = self._run_list(["na\xefve"])
|
|
out = stdout.getvalue()
|
|
assert "na\xefve" in out
|
|
|
|
def test_list_item_path(self):
|
|
stdout = self._run_list(fmt="$path")
|
|
assert stdout.getvalue().strip() == "xxx/yyy"
|
|
|
|
def test_list_album_outputs_something(self):
|
|
stdout = self._run_list(album=True)
|
|
assert len(stdout.getvalue()) > 0
|
|
|
|
def test_list_album_path(self):
|
|
stdout = self._run_list(album=True, fmt="$path")
|
|
assert stdout.getvalue().strip() == "xxx"
|
|
|
|
def test_list_album_omits_title(self):
|
|
stdout = self._run_list(album=True)
|
|
assert "the title" not in stdout.getvalue()
|
|
|
|
def test_list_uses_track_artist(self):
|
|
stdout = self._run_list()
|
|
assert "the artist" in stdout.getvalue()
|
|
assert "the album artist" not in stdout.getvalue()
|
|
|
|
def test_list_album_uses_album_artist(self):
|
|
stdout = self._run_list(album=True)
|
|
assert "the artist" not in stdout.getvalue()
|
|
assert "the album artist" in stdout.getvalue()
|
|
|
|
def test_list_item_format_artist(self):
|
|
stdout = self._run_list(fmt="$artist")
|
|
assert "the artist" in stdout.getvalue()
|
|
|
|
def test_list_item_format_multiple(self):
|
|
stdout = self._run_list(fmt="$artist - $album - $year")
|
|
assert "the artist - the album - 0001" == stdout.getvalue().strip()
|
|
|
|
def test_list_album_format(self):
|
|
stdout = self._run_list(album=True, fmt="$genre")
|
|
assert "the genre" in stdout.getvalue()
|
|
assert "the album" not in stdout.getvalue()
|
|
|
|
|
|
class RemoveTest(BeetsTestCase):
|
|
def setUp(self):
|
|
super().setUp()
|
|
|
|
self.io.install()
|
|
|
|
# Copy a file into the library.
|
|
self.item_path = os.path.join(_common.RSRC, b"full.mp3")
|
|
self.i = library.Item.from_path(self.item_path)
|
|
self.lib.add(self.i)
|
|
self.i.move(operation=MoveOperation.COPY)
|
|
|
|
def test_remove_items_no_delete(self):
|
|
self.io.addinput("y")
|
|
commands.remove_items(self.lib, "", False, False, False)
|
|
items = self.lib.items()
|
|
assert len(list(items)) == 0
|
|
self.assertExists(self.i.path)
|
|
|
|
def test_remove_items_with_delete(self):
|
|
self.io.addinput("y")
|
|
commands.remove_items(self.lib, "", False, True, False)
|
|
items = self.lib.items()
|
|
assert len(list(items)) == 0
|
|
self.assertNotExists(self.i.path)
|
|
|
|
def test_remove_items_with_force_no_delete(self):
|
|
commands.remove_items(self.lib, "", False, False, True)
|
|
items = self.lib.items()
|
|
assert len(list(items)) == 0
|
|
self.assertExists(self.i.path)
|
|
|
|
def test_remove_items_with_force_delete(self):
|
|
commands.remove_items(self.lib, "", False, True, True)
|
|
items = self.lib.items()
|
|
assert len(list(items)) == 0
|
|
self.assertNotExists(self.i.path)
|
|
|
|
def test_remove_items_select_with_delete(self):
|
|
i2 = library.Item.from_path(self.item_path)
|
|
self.lib.add(i2)
|
|
i2.move(operation=MoveOperation.COPY)
|
|
|
|
for s in ("s", "y", "n"):
|
|
self.io.addinput(s)
|
|
commands.remove_items(self.lib, "", False, True, False)
|
|
items = self.lib.items()
|
|
assert len(list(items)) == 1
|
|
# There is probably no guarantee that the items are queried in any
|
|
# spcecific order, thus just ensure that exactly one was removed.
|
|
# To improve upon this, self.io would need to have the capability to
|
|
# generate input that depends on previous output.
|
|
num_existing = 0
|
|
num_existing += 1 if os.path.exists(syspath(self.i.path)) else 0
|
|
num_existing += 1 if os.path.exists(syspath(i2.path)) else 0
|
|
assert num_existing == 1
|
|
|
|
def test_remove_albums_select_with_delete(self):
|
|
a1 = self.add_album_fixture()
|
|
a2 = self.add_album_fixture()
|
|
path1 = a1.items()[0].path
|
|
path2 = a2.items()[0].path
|
|
items = self.lib.items()
|
|
assert len(list(items)) == 3
|
|
|
|
for s in ("s", "y", "n"):
|
|
self.io.addinput(s)
|
|
commands.remove_items(self.lib, "", True, True, False)
|
|
items = self.lib.items()
|
|
assert len(list(items)) == 2 # incl. the item from setUp()
|
|
# See test_remove_items_select_with_delete()
|
|
num_existing = 0
|
|
num_existing += 1 if os.path.exists(syspath(path1)) else 0
|
|
num_existing += 1 if os.path.exists(syspath(path2)) else 0
|
|
assert num_existing == 1
|
|
|
|
|
|
class ModifyTest(BeetsTestCase):
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.album = self.add_album_fixture()
|
|
[self.item] = self.album.items()
|
|
|
|
def modify_inp(self, inp, *args):
|
|
with control_stdin(inp):
|
|
self.run_command("modify", *args)
|
|
|
|
def modify(self, *args):
|
|
self.modify_inp("y", *args)
|
|
|
|
# Item tests
|
|
|
|
def test_modify_item(self):
|
|
self.modify("title=newTitle")
|
|
item = self.lib.items().get()
|
|
assert item.title == "newTitle"
|
|
|
|
def test_modify_item_abort(self):
|
|
item = self.lib.items().get()
|
|
title = item.title
|
|
self.modify_inp("n", "title=newTitle")
|
|
item = self.lib.items().get()
|
|
assert item.title == title
|
|
|
|
def test_modify_item_no_change(self):
|
|
title = "Tracktitle"
|
|
item = self.add_item_fixture(title=title)
|
|
self.modify_inp("y", "title", f"title={title}")
|
|
item = self.lib.items(title).get()
|
|
assert item.title == title
|
|
|
|
def test_modify_write_tags(self):
|
|
self.modify("title=newTitle")
|
|
item = self.lib.items().get()
|
|
item.read()
|
|
assert item.title == "newTitle"
|
|
|
|
def test_modify_dont_write_tags(self):
|
|
self.modify("--nowrite", "title=newTitle")
|
|
item = self.lib.items().get()
|
|
item.read()
|
|
assert item.title != "newTitle"
|
|
|
|
def test_move(self):
|
|
self.modify("title=newTitle")
|
|
item = self.lib.items().get()
|
|
assert b"newTitle" in item.path
|
|
|
|
def test_not_move(self):
|
|
self.modify("--nomove", "title=newTitle")
|
|
item = self.lib.items().get()
|
|
assert b"newTitle" not in item.path
|
|
|
|
def test_no_write_no_move(self):
|
|
self.modify("--nomove", "--nowrite", "title=newTitle")
|
|
item = self.lib.items().get()
|
|
item.read()
|
|
assert b"newTitle" not in item.path
|
|
assert item.title != "newTitle"
|
|
|
|
def test_update_mtime(self):
|
|
item = self.item
|
|
old_mtime = item.mtime
|
|
|
|
self.modify("title=newTitle")
|
|
item.load()
|
|
assert old_mtime != item.mtime
|
|
assert item.current_mtime() == item.mtime
|
|
|
|
def test_reset_mtime_with_no_write(self):
|
|
item = self.item
|
|
|
|
self.modify("--nowrite", "title=newTitle")
|
|
item.load()
|
|
assert 0 == item.mtime
|
|
|
|
def test_selective_modify(self):
|
|
title = "Tracktitle"
|
|
album = "album"
|
|
original_artist = "composer"
|
|
new_artist = "coverArtist"
|
|
for i in range(0, 10):
|
|
self.add_item_fixture(
|
|
title=f"{title}{i}", artist=original_artist, album=album
|
|
)
|
|
self.modify_inp(
|
|
"s\ny\ny\ny\nn\nn\ny\ny\ny\ny\nn", title, f"artist={new_artist}"
|
|
)
|
|
original_items = self.lib.items(f"artist:{original_artist}")
|
|
new_items = self.lib.items(f"artist:{new_artist}")
|
|
assert len(list(original_items)) == 3
|
|
assert len(list(new_items)) == 7
|
|
|
|
def test_modify_formatted(self):
|
|
for i in range(0, 3):
|
|
self.add_item_fixture(
|
|
title=f"title{i}", artist="artist", album="album"
|
|
)
|
|
items = list(self.lib.items())
|
|
self.modify("title=${title} - append")
|
|
for item in items:
|
|
orig_title = item.title
|
|
item.load()
|
|
assert item.title == f"{orig_title} - append"
|
|
|
|
# Album Tests
|
|
|
|
def test_modify_album(self):
|
|
self.modify("--album", "album=newAlbum")
|
|
album = self.lib.albums().get()
|
|
assert album.album == "newAlbum"
|
|
|
|
def test_modify_album_write_tags(self):
|
|
self.modify("--album", "album=newAlbum")
|
|
item = self.lib.items().get()
|
|
item.read()
|
|
assert item.album == "newAlbum"
|
|
|
|
def test_modify_album_dont_write_tags(self):
|
|
self.modify("--album", "--nowrite", "album=newAlbum")
|
|
item = self.lib.items().get()
|
|
item.read()
|
|
assert item.album == "the album"
|
|
|
|
def test_album_move(self):
|
|
self.modify("--album", "album=newAlbum")
|
|
item = self.lib.items().get()
|
|
item.read()
|
|
assert b"newAlbum" in item.path
|
|
|
|
def test_album_not_move(self):
|
|
self.modify("--nomove", "--album", "album=newAlbum")
|
|
item = self.lib.items().get()
|
|
item.read()
|
|
assert b"newAlbum" not in item.path
|
|
|
|
def test_modify_album_formatted(self):
|
|
item = self.lib.items().get()
|
|
orig_album = item.album
|
|
self.modify("--album", "album=${album} - append")
|
|
item.load()
|
|
assert item.album == f"{orig_album} - append"
|
|
|
|
# Misc
|
|
|
|
def test_write_initial_key_tag(self):
|
|
self.modify("initial_key=C#m")
|
|
item = self.lib.items().get()
|
|
mediafile = MediaFile(syspath(item.path))
|
|
assert mediafile.initial_key == "C#m"
|
|
|
|
def test_set_flexattr(self):
|
|
self.modify("flexattr=testAttr")
|
|
item = self.lib.items().get()
|
|
assert item.flexattr == "testAttr"
|
|
|
|
def test_remove_flexattr(self):
|
|
item = self.lib.items().get()
|
|
item.flexattr = "testAttr"
|
|
item.store()
|
|
|
|
self.modify("flexattr!")
|
|
item = self.lib.items().get()
|
|
assert "flexattr" not in item
|
|
|
|
@unittest.skip("not yet implemented")
|
|
def test_delete_initial_key_tag(self):
|
|
item = self.lib.items().get()
|
|
item.initial_key = "C#m"
|
|
item.write()
|
|
item.store()
|
|
|
|
mediafile = MediaFile(syspath(item.path))
|
|
assert mediafile.initial_key == "C#m"
|
|
|
|
self.modify("initial_key!")
|
|
mediafile = MediaFile(syspath(item.path))
|
|
assert mediafile.initial_key is None
|
|
|
|
def test_arg_parsing_colon_query(self):
|
|
(query, mods, dels) = commands.modify_parse_args(
|
|
["title:oldTitle", "title=newTitle"]
|
|
)
|
|
assert query == ["title:oldTitle"]
|
|
assert mods == {"title": "newTitle"}
|
|
|
|
def test_arg_parsing_delete(self):
|
|
(query, mods, dels) = commands.modify_parse_args(
|
|
["title:oldTitle", "title!"]
|
|
)
|
|
assert query == ["title:oldTitle"]
|
|
assert dels == ["title"]
|
|
|
|
def test_arg_parsing_query_with_exclaimation(self):
|
|
(query, mods, dels) = commands.modify_parse_args(
|
|
["title:oldTitle!", "title=newTitle!"]
|
|
)
|
|
assert query == ["title:oldTitle!"]
|
|
assert mods == {"title": "newTitle!"}
|
|
|
|
def test_arg_parsing_equals_in_value(self):
|
|
(query, mods, dels) = commands.modify_parse_args(
|
|
["title:foo=bar", "title=newTitle"]
|
|
)
|
|
assert query == ["title:foo=bar"]
|
|
assert mods == {"title": "newTitle"}
|
|
|
|
|
|
class WriteTest(BeetsTestCase):
|
|
def write_cmd(self, *args):
|
|
return self.run_with_output("write", *args)
|
|
|
|
def test_update_mtime(self):
|
|
item = self.add_item_fixture()
|
|
item["title"] = "a new title"
|
|
item.store()
|
|
|
|
item = self.lib.items().get()
|
|
assert item.mtime == 0
|
|
|
|
self.write_cmd()
|
|
item = self.lib.items().get()
|
|
assert item.mtime == item.current_mtime()
|
|
|
|
def test_non_metadata_field_unchanged(self):
|
|
"""Changing a non-"tag" field like `bitrate` and writing should
|
|
have no effect.
|
|
"""
|
|
# An item that starts out "clean".
|
|
item = self.add_item_fixture()
|
|
item.read()
|
|
|
|
# ... but with a mismatched bitrate.
|
|
item.bitrate = 123
|
|
item.store()
|
|
|
|
output = self.write_cmd()
|
|
|
|
assert output == ""
|
|
|
|
def test_write_metadata_field(self):
|
|
item = self.add_item_fixture()
|
|
item.read()
|
|
old_title = item.title
|
|
|
|
item.title = "new title"
|
|
item.store()
|
|
|
|
output = self.write_cmd()
|
|
|
|
assert f"{old_title} -> new title" in output
|
|
|
|
|
|
class MoveTest(BeetsTestCase):
|
|
def setUp(self):
|
|
super().setUp()
|
|
|
|
self.io.install()
|
|
|
|
self.itempath = os.path.join(self.libdir, b"srcfile")
|
|
shutil.copy(
|
|
syspath(os.path.join(_common.RSRC, b"full.mp3")),
|
|
syspath(self.itempath),
|
|
)
|
|
|
|
# Add a file to the library but don't copy it in yet.
|
|
self.i = library.Item.from_path(self.itempath)
|
|
self.lib.add(self.i)
|
|
self.album = self.lib.add_album([self.i])
|
|
|
|
# Alternate destination directory.
|
|
self.otherdir = os.path.join(self.temp_dir, b"testotherdir")
|
|
|
|
def _move(
|
|
self,
|
|
query=(),
|
|
dest=None,
|
|
copy=False,
|
|
album=False,
|
|
pretend=False,
|
|
export=False,
|
|
):
|
|
commands.move_items(
|
|
self.lib, dest, query, copy, album, pretend, export=export
|
|
)
|
|
|
|
def test_move_item(self):
|
|
self._move()
|
|
self.i.load()
|
|
assert b"libdir" in self.i.path
|
|
self.assertExists(self.i.path)
|
|
self.assertNotExists(self.itempath)
|
|
|
|
def test_copy_item(self):
|
|
self._move(copy=True)
|
|
self.i.load()
|
|
assert b"libdir" in self.i.path
|
|
self.assertExists(self.i.path)
|
|
self.assertExists(self.itempath)
|
|
|
|
def test_move_album(self):
|
|
self._move(album=True)
|
|
self.i.load()
|
|
assert b"libdir" in self.i.path
|
|
self.assertExists(self.i.path)
|
|
self.assertNotExists(self.itempath)
|
|
|
|
def test_copy_album(self):
|
|
self._move(copy=True, album=True)
|
|
self.i.load()
|
|
assert b"libdir" in self.i.path
|
|
self.assertExists(self.i.path)
|
|
self.assertExists(self.itempath)
|
|
|
|
def test_move_item_custom_dir(self):
|
|
self._move(dest=self.otherdir)
|
|
self.i.load()
|
|
assert b"testotherdir" in self.i.path
|
|
self.assertExists(self.i.path)
|
|
self.assertNotExists(self.itempath)
|
|
|
|
def test_move_album_custom_dir(self):
|
|
self._move(dest=self.otherdir, album=True)
|
|
self.i.load()
|
|
assert b"testotherdir" in self.i.path
|
|
self.assertExists(self.i.path)
|
|
self.assertNotExists(self.itempath)
|
|
|
|
def test_pretend_move_item(self):
|
|
self._move(dest=self.otherdir, pretend=True)
|
|
self.i.load()
|
|
assert b"srcfile" in self.i.path
|
|
|
|
def test_pretend_move_album(self):
|
|
self._move(album=True, pretend=True)
|
|
self.i.load()
|
|
assert b"srcfile" in self.i.path
|
|
|
|
def test_export_item_custom_dir(self):
|
|
self._move(dest=self.otherdir, export=True)
|
|
self.i.load()
|
|
assert self.i.path == self.itempath
|
|
self.assertExists(self.otherdir)
|
|
|
|
def test_export_album_custom_dir(self):
|
|
self._move(dest=self.otherdir, album=True, export=True)
|
|
self.i.load()
|
|
assert self.i.path == self.itempath
|
|
self.assertExists(self.otherdir)
|
|
|
|
def test_pretend_export_item(self):
|
|
self._move(dest=self.otherdir, pretend=True, export=True)
|
|
self.i.load()
|
|
assert b"srcfile" in self.i.path
|
|
self.assertNotExists(self.otherdir)
|
|
|
|
|
|
class UpdateTest(BeetsTestCase):
|
|
def setUp(self):
|
|
super().setUp()
|
|
|
|
self.io.install()
|
|
|
|
# Copy a file into the library.
|
|
item_path = os.path.join(_common.RSRC, b"full.mp3")
|
|
item_path_two = os.path.join(_common.RSRC, b"full.flac")
|
|
self.i = library.Item.from_path(item_path)
|
|
self.i2 = library.Item.from_path(item_path_two)
|
|
self.lib.add(self.i)
|
|
self.lib.add(self.i2)
|
|
self.i.move(operation=MoveOperation.COPY)
|
|
self.i2.move(operation=MoveOperation.COPY)
|
|
self.album = self.lib.add_album([self.i, self.i2])
|
|
|
|
# Album art.
|
|
artfile = os.path.join(self.temp_dir, b"testart.jpg")
|
|
_common.touch(artfile)
|
|
self.album.set_art(artfile)
|
|
self.album.store()
|
|
util.remove(artfile)
|
|
|
|
def _update(
|
|
self,
|
|
query=(),
|
|
album=False,
|
|
move=False,
|
|
reset_mtime=True,
|
|
fields=None,
|
|
exclude_fields=None,
|
|
):
|
|
self.io.addinput("y")
|
|
if reset_mtime:
|
|
self.i.mtime = 0
|
|
self.i.store()
|
|
commands.update_items(
|
|
self.lib,
|
|
query,
|
|
album,
|
|
move,
|
|
False,
|
|
fields=fields,
|
|
exclude_fields=exclude_fields,
|
|
)
|
|
|
|
def test_delete_removes_item(self):
|
|
assert list(self.lib.items())
|
|
util.remove(self.i.path)
|
|
util.remove(self.i2.path)
|
|
self._update()
|
|
assert not list(self.lib.items())
|
|
|
|
def test_delete_removes_album(self):
|
|
assert self.lib.albums()
|
|
util.remove(self.i.path)
|
|
util.remove(self.i2.path)
|
|
self._update()
|
|
assert not self.lib.albums()
|
|
|
|
def test_delete_removes_album_art(self):
|
|
artpath = self.album.artpath
|
|
self.assertExists(artpath)
|
|
util.remove(self.i.path)
|
|
util.remove(self.i2.path)
|
|
self._update()
|
|
self.assertNotExists(artpath)
|
|
|
|
def test_modified_metadata_detected(self):
|
|
mf = MediaFile(syspath(self.i.path))
|
|
mf.title = "differentTitle"
|
|
mf.save()
|
|
self._update()
|
|
item = self.lib.items().get()
|
|
assert item.title == "differentTitle"
|
|
|
|
def test_modified_metadata_moved(self):
|
|
mf = MediaFile(syspath(self.i.path))
|
|
mf.title = "differentTitle"
|
|
mf.save()
|
|
self._update(move=True)
|
|
item = self.lib.items().get()
|
|
assert b"differentTitle" in item.path
|
|
|
|
def test_modified_metadata_not_moved(self):
|
|
mf = MediaFile(syspath(self.i.path))
|
|
mf.title = "differentTitle"
|
|
mf.save()
|
|
self._update(move=False)
|
|
item = self.lib.items().get()
|
|
assert b"differentTitle" not in item.path
|
|
|
|
def test_selective_modified_metadata_moved(self):
|
|
mf = MediaFile(syspath(self.i.path))
|
|
mf.title = "differentTitle"
|
|
mf.genre = "differentGenre"
|
|
mf.save()
|
|
self._update(move=True, fields=["title"])
|
|
item = self.lib.items().get()
|
|
assert b"differentTitle" in item.path
|
|
assert item.genre != "differentGenre"
|
|
|
|
def test_selective_modified_metadata_not_moved(self):
|
|
mf = MediaFile(syspath(self.i.path))
|
|
mf.title = "differentTitle"
|
|
mf.genre = "differentGenre"
|
|
mf.save()
|
|
self._update(move=False, fields=["title"])
|
|
item = self.lib.items().get()
|
|
assert b"differentTitle" not in item.path
|
|
assert item.genre != "differentGenre"
|
|
|
|
def test_modified_album_metadata_moved(self):
|
|
mf = MediaFile(syspath(self.i.path))
|
|
mf.album = "differentAlbum"
|
|
mf.save()
|
|
self._update(move=True)
|
|
item = self.lib.items().get()
|
|
assert b"differentAlbum" in item.path
|
|
|
|
def test_modified_album_metadata_art_moved(self):
|
|
artpath = self.album.artpath
|
|
mf = MediaFile(syspath(self.i.path))
|
|
mf.album = "differentAlbum"
|
|
mf.save()
|
|
self._update(move=True)
|
|
album = self.lib.albums()[0]
|
|
assert artpath != album.artpath
|
|
assert album.artpath is not None
|
|
|
|
def test_selective_modified_album_metadata_moved(self):
|
|
mf = MediaFile(syspath(self.i.path))
|
|
mf.album = "differentAlbum"
|
|
mf.genre = "differentGenre"
|
|
mf.save()
|
|
self._update(move=True, fields=["album"])
|
|
item = self.lib.items().get()
|
|
assert b"differentAlbum" in item.path
|
|
assert item.genre != "differentGenre"
|
|
|
|
def test_selective_modified_album_metadata_not_moved(self):
|
|
mf = MediaFile(syspath(self.i.path))
|
|
mf.album = "differentAlbum"
|
|
mf.genre = "differentGenre"
|
|
mf.save()
|
|
self._update(move=True, fields=["genre"])
|
|
item = self.lib.items().get()
|
|
assert b"differentAlbum" not in item.path
|
|
assert item.genre == "differentGenre"
|
|
|
|
def test_mtime_match_skips_update(self):
|
|
mf = MediaFile(syspath(self.i.path))
|
|
mf.title = "differentTitle"
|
|
mf.save()
|
|
|
|
# Make in-memory mtime match on-disk mtime.
|
|
self.i.mtime = os.path.getmtime(syspath(self.i.path))
|
|
self.i.store()
|
|
|
|
self._update(reset_mtime=False)
|
|
item = self.lib.items().get()
|
|
assert item.title == "full"
|
|
|
|
def test_multivalued_albumtype_roundtrip(self):
|
|
# https://github.com/beetbox/beets/issues/4528
|
|
|
|
# albumtypes is empty for our test fixtures, so populate it first
|
|
album = self.album
|
|
correct_albumtypes = ["album", "live"]
|
|
|
|
# Setting albumtypes does not set albumtype, currently.
|
|
# Using x[0] mirrors https://github.com/beetbox/mediafile/blob/057432ad53b3b84385e5582f69f44dc00d0a725d/mediafile.py#L1928 # noqa: E501
|
|
correct_albumtype = correct_albumtypes[0]
|
|
|
|
album.albumtype = correct_albumtype
|
|
album.albumtypes = correct_albumtypes
|
|
album.try_sync(write=True, move=False)
|
|
|
|
album.load()
|
|
assert album.albumtype == correct_albumtype
|
|
assert album.albumtypes == correct_albumtypes
|
|
|
|
self._update()
|
|
|
|
album.load()
|
|
assert album.albumtype == correct_albumtype
|
|
assert album.albumtypes == correct_albumtypes
|
|
|
|
def test_modified_metadata_excluded(self):
|
|
mf = MediaFile(syspath(self.i.path))
|
|
mf.lyrics = "new lyrics"
|
|
mf.save()
|
|
self._update(exclude_fields=["lyrics"])
|
|
item = self.lib.items().get()
|
|
assert item.lyrics != "new lyrics"
|
|
|
|
|
|
class PrintTest(BeetsTestCase):
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.io.install()
|
|
|
|
def test_print_without_locale(self):
|
|
lang = os.environ.get("LANG")
|
|
if lang:
|
|
del os.environ["LANG"]
|
|
|
|
try:
|
|
ui.print_("something")
|
|
except TypeError:
|
|
self.fail("TypeError during print")
|
|
finally:
|
|
if lang:
|
|
os.environ["LANG"] = lang
|
|
|
|
def test_print_with_invalid_locale(self):
|
|
old_lang = os.environ.get("LANG")
|
|
os.environ["LANG"] = ""
|
|
old_ctype = os.environ.get("LC_CTYPE")
|
|
os.environ["LC_CTYPE"] = "UTF-8"
|
|
|
|
try:
|
|
ui.print_("something")
|
|
except ValueError:
|
|
self.fail("ValueError during print")
|
|
finally:
|
|
if old_lang:
|
|
os.environ["LANG"] = old_lang
|
|
else:
|
|
del os.environ["LANG"]
|
|
if old_ctype:
|
|
os.environ["LC_CTYPE"] = old_ctype
|
|
else:
|
|
del os.environ["LC_CTYPE"]
|
|
|
|
|
|
class ImportTest(BeetsTestCase):
|
|
def test_quiet_timid_disallowed(self):
|
|
config["import"]["quiet"] = True
|
|
config["import"]["timid"] = True
|
|
with pytest.raises(ui.UserError):
|
|
commands.import_files(None, [], None)
|
|
|
|
def test_parse_paths_from_logfile(self):
|
|
if os.path.__name__ == "ntpath":
|
|
logfile_content = (
|
|
"import started Wed Jun 15 23:08:26 2022\n"
|
|
"asis C:\\music\\Beatles, The\\The Beatles; C:\\music\\Beatles, The\\The Beatles\\CD 01; C:\\music\\Beatles, The\\The Beatles\\CD 02\n" # noqa: E501
|
|
"duplicate-replace C:\\music\\Bill Evans\\Trio '65\n"
|
|
"skip C:\\music\\Michael Jackson\\Bad\n"
|
|
"skip C:\\music\\Soulwax\\Any Minute Now\n"
|
|
)
|
|
expected_paths = [
|
|
"C:\\music\\Beatles, The\\The Beatles",
|
|
"C:\\music\\Michael Jackson\\Bad",
|
|
"C:\\music\\Soulwax\\Any Minute Now",
|
|
]
|
|
else:
|
|
logfile_content = (
|
|
"import started Wed Jun 15 23:08:26 2022\n"
|
|
"asis /music/Beatles, The/The Beatles; /music/Beatles, The/The Beatles/CD 01; /music/Beatles, The/The Beatles/CD 02\n" # noqa: E501
|
|
"duplicate-replace /music/Bill Evans/Trio '65\n"
|
|
"skip /music/Michael Jackson/Bad\n"
|
|
"skip /music/Soulwax/Any Minute Now\n"
|
|
)
|
|
expected_paths = [
|
|
"/music/Beatles, The/The Beatles",
|
|
"/music/Michael Jackson/Bad",
|
|
"/music/Soulwax/Any Minute Now",
|
|
]
|
|
|
|
logfile = os.path.join(self.temp_dir, b"logfile.log")
|
|
with open(logfile, mode="w") as fp:
|
|
fp.write(logfile_content)
|
|
actual_paths = list(commands._paths_from_logfile(logfile))
|
|
assert actual_paths == expected_paths
|
|
|
|
|
|
@_common.slow_test()
|
|
class TestPluginTestCase(PluginTestCase):
|
|
plugin = "test"
|
|
|
|
def setUp(self):
|
|
super().setUp()
|
|
config["pluginpath"] = [_common.PLUGINPATH]
|
|
|
|
|
|
class ConfigTest(TestPluginTestCase):
|
|
def setUp(self):
|
|
super().setUp()
|
|
|
|
# Don't use the BEETSDIR from `helper`. Instead, we point the home
|
|
# directory there. Some tests will set `BEETSDIR` themselves.
|
|
del os.environ["BEETSDIR"]
|
|
|
|
# Also set APPDATA, the Windows equivalent of setting $HOME.
|
|
appdata_dir = os.fsdecode(
|
|
os.path.join(self.temp_dir, b"AppData", b"Roaming")
|
|
)
|
|
|
|
self._orig_cwd = os.getcwd()
|
|
self.test_cmd = self._make_test_cmd()
|
|
commands.default_commands.append(self.test_cmd)
|
|
|
|
# Default user configuration
|
|
if platform.system() == "Windows":
|
|
self.user_config_dir = os.fsencode(
|
|
os.path.join(appdata_dir, "beets")
|
|
)
|
|
else:
|
|
self.user_config_dir = os.path.join(
|
|
self.temp_dir, b".config", b"beets"
|
|
)
|
|
os.makedirs(syspath(self.user_config_dir))
|
|
self.user_config_path = os.path.join(
|
|
self.user_config_dir, b"config.yaml"
|
|
)
|
|
|
|
# Custom BEETSDIR
|
|
self.beetsdir = os.path.join(self.temp_dir, b"beetsdir")
|
|
os.makedirs(syspath(self.beetsdir))
|
|
self.env_patcher = patch(
|
|
"os.environ",
|
|
{"HOME": os.fsdecode(self.temp_dir), "APPDATA": appdata_dir},
|
|
)
|
|
self.env_patcher.start()
|
|
|
|
self._reset_config()
|
|
|
|
def tearDown(self):
|
|
self.env_patcher.stop()
|
|
commands.default_commands.pop()
|
|
os.chdir(syspath(self._orig_cwd))
|
|
super().tearDown()
|
|
|
|
def _make_test_cmd(self):
|
|
test_cmd = ui.Subcommand("test", help="test")
|
|
|
|
def run(lib, options, args):
|
|
test_cmd.lib = lib
|
|
test_cmd.options = options
|
|
test_cmd.args = args
|
|
|
|
test_cmd.func = run
|
|
return test_cmd
|
|
|
|
def _reset_config(self):
|
|
# Config should read files again on demand
|
|
config.clear()
|
|
config._materialized = False
|
|
|
|
def write_config_file(self):
|
|
return open(self.user_config_path, "w")
|
|
|
|
def test_paths_section_respected(self):
|
|
with self.write_config_file() as config:
|
|
config.write("paths: {x: y}")
|
|
|
|
self.run_command("test", lib=None)
|
|
key, template = self.test_cmd.lib.path_formats[0]
|
|
assert key == "x"
|
|
assert template.original == "y"
|
|
|
|
def test_default_paths_preserved(self):
|
|
default_formats = ui.get_path_formats()
|
|
|
|
self._reset_config()
|
|
with self.write_config_file() as config:
|
|
config.write("paths: {x: y}")
|
|
self.run_command("test", lib=None)
|
|
key, template = self.test_cmd.lib.path_formats[0]
|
|
assert key == "x"
|
|
assert template.original == "y"
|
|
assert self.test_cmd.lib.path_formats[1:] == default_formats
|
|
|
|
def test_nonexistant_db(self):
|
|
with self.write_config_file() as config:
|
|
config.write("library: /xxx/yyy/not/a/real/path")
|
|
|
|
with pytest.raises(ui.UserError):
|
|
self.run_command("test", lib=None)
|
|
|
|
def test_user_config_file(self):
|
|
with self.write_config_file() as file:
|
|
file.write("anoption: value")
|
|
|
|
self.run_command("test", lib=None)
|
|
assert config["anoption"].get() == "value"
|
|
|
|
def test_replacements_parsed(self):
|
|
with self.write_config_file() as config:
|
|
config.write("replace: {'[xy]': z}")
|
|
|
|
self.run_command("test", lib=None)
|
|
replacements = self.test_cmd.lib.replacements
|
|
repls = [(p.pattern, s) for p, s in replacements] # Compare patterns.
|
|
assert repls == [("[xy]", "z")]
|
|
|
|
def test_multiple_replacements_parsed(self):
|
|
with self.write_config_file() as config:
|
|
config.write("replace: {'[xy]': z, foo: bar}")
|
|
self.run_command("test", lib=None)
|
|
replacements = self.test_cmd.lib.replacements
|
|
repls = [(p.pattern, s) for p, s in replacements]
|
|
assert repls == [("[xy]", "z"), ("foo", "bar")]
|
|
|
|
def test_cli_config_option(self):
|
|
config_path = os.path.join(self.temp_dir, b"config.yaml")
|
|
with open(config_path, "w") as file:
|
|
file.write("anoption: value")
|
|
self.run_command("--config", config_path, "test", lib=None)
|
|
assert config["anoption"].get() == "value"
|
|
|
|
def test_cli_config_file_overwrites_user_defaults(self):
|
|
with open(self.user_config_path, "w") as file:
|
|
file.write("anoption: value")
|
|
|
|
cli_config_path = os.path.join(self.temp_dir, b"config.yaml")
|
|
with open(cli_config_path, "w") as file:
|
|
file.write("anoption: cli overwrite")
|
|
self.run_command("--config", cli_config_path, "test", lib=None)
|
|
assert config["anoption"].get() == "cli overwrite"
|
|
|
|
def test_cli_config_file_overwrites_beetsdir_defaults(self):
|
|
os.environ["BEETSDIR"] = os.fsdecode(self.beetsdir)
|
|
env_config_path = os.path.join(self.beetsdir, b"config.yaml")
|
|
with open(env_config_path, "w") as file:
|
|
file.write("anoption: value")
|
|
|
|
cli_config_path = os.path.join(self.temp_dir, b"config.yaml")
|
|
with open(cli_config_path, "w") as file:
|
|
file.write("anoption: cli overwrite")
|
|
self.run_command("--config", cli_config_path, "test", lib=None)
|
|
assert config["anoption"].get() == "cli overwrite"
|
|
|
|
# @unittest.skip('Difficult to implement with optparse')
|
|
# def test_multiple_cli_config_files(self):
|
|
# cli_config_path_1 = os.path.join(self.temp_dir, b'config.yaml')
|
|
# cli_config_path_2 = os.path.join(self.temp_dir, b'config_2.yaml')
|
|
#
|
|
# with open(cli_config_path_1, 'w') as file:
|
|
# file.write('first: value')
|
|
#
|
|
# with open(cli_config_path_2, 'w') as file:
|
|
# file.write('second: value')
|
|
#
|
|
# self.run_command('--config', cli_config_path_1,
|
|
# '--config', cli_config_path_2, 'test', lib=None)
|
|
# assert config['first'].get() == 'value'
|
|
# assert config['second'].get() == 'value'
|
|
#
|
|
# @unittest.skip('Difficult to implement with optparse')
|
|
# def test_multiple_cli_config_overwrite(self):
|
|
# cli_config_path = os.path.join(self.temp_dir, b'config.yaml')
|
|
# cli_overwrite_config_path = os.path.join(self.temp_dir,
|
|
# b'overwrite_config.yaml')
|
|
#
|
|
# with open(cli_config_path, 'w') as file:
|
|
# file.write('anoption: value')
|
|
#
|
|
# with open(cli_overwrite_config_path, 'w') as file:
|
|
# file.write('anoption: overwrite')
|
|
#
|
|
# self.run_command('--config', cli_config_path,
|
|
# '--config', cli_overwrite_config_path, 'test')
|
|
# assert config['anoption'].get() == 'cli overwrite'
|
|
|
|
# FIXME: fails on windows
|
|
@unittest.skipIf(sys.platform == "win32", "win32")
|
|
def test_cli_config_paths_resolve_relative_to_user_dir(self):
|
|
cli_config_path = os.path.join(self.temp_dir, b"config.yaml")
|
|
with open(cli_config_path, "w") as file:
|
|
file.write("library: beets.db\n")
|
|
file.write("statefile: state")
|
|
|
|
self.run_command("--config", cli_config_path, "test", lib=None)
|
|
self.assert_equal_path(
|
|
util.bytestring_path(config["library"].as_filename()),
|
|
os.path.join(self.user_config_dir, b"beets.db"),
|
|
)
|
|
self.assert_equal_path(
|
|
util.bytestring_path(config["statefile"].as_filename()),
|
|
os.path.join(self.user_config_dir, b"state"),
|
|
)
|
|
|
|
def test_cli_config_paths_resolve_relative_to_beetsdir(self):
|
|
os.environ["BEETSDIR"] = os.fsdecode(self.beetsdir)
|
|
|
|
cli_config_path = os.path.join(self.temp_dir, b"config.yaml")
|
|
with open(cli_config_path, "w") as file:
|
|
file.write("library: beets.db\n")
|
|
file.write("statefile: state")
|
|
|
|
self.run_command("--config", cli_config_path, "test", lib=None)
|
|
self.assert_equal_path(
|
|
util.bytestring_path(config["library"].as_filename()),
|
|
os.path.join(self.beetsdir, b"beets.db"),
|
|
)
|
|
self.assert_equal_path(
|
|
util.bytestring_path(config["statefile"].as_filename()),
|
|
os.path.join(self.beetsdir, b"state"),
|
|
)
|
|
|
|
def test_command_line_option_relative_to_working_dir(self):
|
|
config.read()
|
|
os.chdir(syspath(self.temp_dir))
|
|
self.run_command("--library", "foo.db", "test", lib=None)
|
|
self.assert_equal_path(
|
|
config["library"].as_filename(), os.path.join(os.getcwd(), "foo.db")
|
|
)
|
|
|
|
def test_cli_config_file_loads_plugin_commands(self):
|
|
cli_config_path = os.path.join(self.temp_dir, b"config.yaml")
|
|
with open(cli_config_path, "w") as file:
|
|
file.write("pluginpath: %s\n" % _common.PLUGINPATH)
|
|
file.write("plugins: test")
|
|
|
|
self.run_command("--config", cli_config_path, "plugin", lib=None)
|
|
assert plugins.find_plugins()[0].is_test_plugin
|
|
self.unload_plugins()
|
|
|
|
def test_beetsdir_config(self):
|
|
os.environ["BEETSDIR"] = os.fsdecode(self.beetsdir)
|
|
|
|
env_config_path = os.path.join(self.beetsdir, b"config.yaml")
|
|
with open(env_config_path, "w") as file:
|
|
file.write("anoption: overwrite")
|
|
|
|
config.read()
|
|
assert config["anoption"].get() == "overwrite"
|
|
|
|
def test_beetsdir_points_to_file_error(self):
|
|
beetsdir = os.path.join(self.temp_dir, b"beetsfile")
|
|
open(beetsdir, "a").close()
|
|
os.environ["BEETSDIR"] = os.fsdecode(beetsdir)
|
|
with pytest.raises(ConfigError):
|
|
self.run_command("test")
|
|
|
|
def test_beetsdir_config_does_not_load_default_user_config(self):
|
|
os.environ["BEETSDIR"] = os.fsdecode(self.beetsdir)
|
|
|
|
with open(self.user_config_path, "w") as file:
|
|
file.write("anoption: value")
|
|
|
|
config.read()
|
|
assert not config["anoption"].exists()
|
|
|
|
def test_default_config_paths_resolve_relative_to_beetsdir(self):
|
|
os.environ["BEETSDIR"] = os.fsdecode(self.beetsdir)
|
|
|
|
config.read()
|
|
self.assert_equal_path(
|
|
util.bytestring_path(config["library"].as_filename()),
|
|
os.path.join(self.beetsdir, b"library.db"),
|
|
)
|
|
self.assert_equal_path(
|
|
util.bytestring_path(config["statefile"].as_filename()),
|
|
os.path.join(self.beetsdir, b"state.pickle"),
|
|
)
|
|
|
|
def test_beetsdir_config_paths_resolve_relative_to_beetsdir(self):
|
|
os.environ["BEETSDIR"] = os.fsdecode(self.beetsdir)
|
|
|
|
env_config_path = os.path.join(self.beetsdir, b"config.yaml")
|
|
with open(env_config_path, "w") as file:
|
|
file.write("library: beets.db\n")
|
|
file.write("statefile: state")
|
|
|
|
config.read()
|
|
self.assert_equal_path(
|
|
util.bytestring_path(config["library"].as_filename()),
|
|
os.path.join(self.beetsdir, b"beets.db"),
|
|
)
|
|
self.assert_equal_path(
|
|
util.bytestring_path(config["statefile"].as_filename()),
|
|
os.path.join(self.beetsdir, b"state"),
|
|
)
|
|
|
|
|
|
class ShowModelChangeTest(BeetsTestCase):
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.io.install()
|
|
self.a = _common.item()
|
|
self.b = _common.item()
|
|
self.a.path = self.b.path
|
|
|
|
def _show(self, **kwargs):
|
|
change = ui.show_model_changes(self.a, self.b, **kwargs)
|
|
out = self.io.getoutput()
|
|
return change, out
|
|
|
|
def test_identical(self):
|
|
change, out = self._show()
|
|
assert not change
|
|
assert out == ""
|
|
|
|
def test_string_fixed_field_change(self):
|
|
self.b.title = "x"
|
|
change, out = self._show()
|
|
assert change
|
|
assert "title" in out
|
|
|
|
def test_int_fixed_field_change(self):
|
|
self.b.track = 9
|
|
change, out = self._show()
|
|
assert change
|
|
assert "track" in out
|
|
|
|
def test_floats_close_to_identical(self):
|
|
self.a.length = 1.00001
|
|
self.b.length = 1.00005
|
|
change, out = self._show()
|
|
assert not change
|
|
assert out == ""
|
|
|
|
def test_floats_different(self):
|
|
self.a.length = 1.00001
|
|
self.b.length = 2.00001
|
|
change, out = self._show()
|
|
assert change
|
|
assert "length" in out
|
|
|
|
def test_both_values_shown(self):
|
|
self.a.title = "foo"
|
|
self.b.title = "bar"
|
|
change, out = self._show()
|
|
assert "foo" in out
|
|
assert "bar" in out
|
|
|
|
|
|
class ShowChangeTest(BeetsTestCase):
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.io.install()
|
|
|
|
self.items = [_common.item()]
|
|
self.items[0].track = 1
|
|
self.items[0].path = b"/path/to/file.mp3"
|
|
self.info = autotag.AlbumInfo(
|
|
album="the album",
|
|
album_id="album id",
|
|
artist="the artist",
|
|
artist_id="artist id",
|
|
tracks=[
|
|
autotag.TrackInfo(
|
|
title="the title", track_id="track id", index=1
|
|
)
|
|
],
|
|
)
|
|
|
|
def _show_change(
|
|
self,
|
|
items=None,
|
|
info=None,
|
|
color=False,
|
|
cur_artist="the artist",
|
|
cur_album="the album",
|
|
dist=0.1,
|
|
):
|
|
"""Return an unicode string representing the changes"""
|
|
items = items or self.items
|
|
info = info or self.info
|
|
mapping = dict(zip(items, info.tracks))
|
|
config["ui"]["color"] = color
|
|
config["import"]["detail"] = True
|
|
change_dist = distance(items, info, mapping)
|
|
change_dist._penalties = {"album": [dist], "artist": [dist]}
|
|
commands.show_change(
|
|
cur_artist,
|
|
cur_album,
|
|
autotag.AlbumMatch(change_dist, info, mapping, set(), set()),
|
|
)
|
|
return self.io.getoutput().lower()
|
|
|
|
def test_null_change(self):
|
|
msg = self._show_change()
|
|
assert "match (90.0%)" in msg
|
|
assert "album, artist" in msg
|
|
|
|
def test_album_data_change(self):
|
|
msg = self._show_change(
|
|
cur_artist="another artist", cur_album="another album"
|
|
)
|
|
assert "another artist -> the artist" in msg
|
|
assert "another album -> the album" in msg
|
|
|
|
def test_item_data_change(self):
|
|
self.items[0].title = "different"
|
|
msg = self._show_change()
|
|
assert "different" in msg and "the title" in msg
|
|
|
|
def test_item_data_change_with_unicode(self):
|
|
self.items[0].title = "caf\xe9"
|
|
msg = self._show_change()
|
|
assert "caf\xe9" in msg and "the title" in msg
|
|
|
|
def test_album_data_change_with_unicode(self):
|
|
msg = self._show_change(cur_artist="caf\xe9", cur_album="another album")
|
|
assert "caf\xe9" in msg and "the artist" in msg
|
|
|
|
def test_item_data_change_title_missing(self):
|
|
self.items[0].title = ""
|
|
msg = re.sub(r" +", " ", self._show_change())
|
|
assert "file.mp3" in msg and "the title" in msg
|
|
|
|
def test_item_data_change_title_missing_with_unicode_filename(self):
|
|
self.items[0].title = ""
|
|
self.items[0].path = "/path/to/caf\xe9.mp3".encode()
|
|
msg = re.sub(r" +", " ", self._show_change())
|
|
assert "caf\xe9.mp3" in msg or "caf.mp3" in msg
|
|
|
|
def test_colorize(self):
|
|
assert "test" == ui.uncolorize("test")
|
|
txt = ui.uncolorize("\x1b[31mtest\x1b[39;49;00m")
|
|
assert "test" == txt
|
|
txt = ui.uncolorize("\x1b[31mtest\x1b[39;49;00m test")
|
|
assert "test test" == txt
|
|
txt = ui.uncolorize("\x1b[31mtest\x1b[39;49;00mtest")
|
|
assert "testtest" == txt
|
|
txt = ui.uncolorize("test \x1b[31mtest\x1b[39;49;00m test")
|
|
assert "test test test" == txt
|
|
|
|
def test_color_split(self):
|
|
exp = ("test", "")
|
|
res = ui.color_split("test", 5)
|
|
assert exp == res
|
|
exp = ("\x1b[31mtes\x1b[39;49;00m", "\x1b[31mt\x1b[39;49;00m")
|
|
res = ui.color_split("\x1b[31mtest\x1b[39;49;00m", 3)
|
|
assert exp == res
|
|
|
|
def test_split_into_lines(self):
|
|
# Test uncolored text
|
|
txt = ui.split_into_lines("test test test", [5, 5, 5])
|
|
assert txt == ["test", "test", "test"]
|
|
# Test multiple colored texts
|
|
colored_text = "\x1b[31mtest \x1b[39;49;00m" * 3
|
|
split_txt = [
|
|
"\x1b[31mtest\x1b[39;49;00m",
|
|
"\x1b[31mtest\x1b[39;49;00m",
|
|
"\x1b[31mtest\x1b[39;49;00m",
|
|
]
|
|
txt = ui.split_into_lines(colored_text, [5, 5, 5])
|
|
assert txt == split_txt
|
|
# Test single color, multi space text
|
|
colored_text = "\x1b[31m test test test \x1b[39;49;00m"
|
|
txt = ui.split_into_lines(colored_text, [5, 5, 5])
|
|
assert txt == split_txt
|
|
# Test single color, different spacing
|
|
colored_text = "\x1b[31mtest\x1b[39;49;00mtest test test"
|
|
# ToDo: fix color_len to handle mid-text color escapes, and thus
|
|
# split colored texts over newlines (potentially with dashes?)
|
|
split_txt = ["\x1b[31mtest\x1b[39;49;00mt", "est", "test", "test"]
|
|
txt = ui.split_into_lines(colored_text, [5, 5, 5])
|
|
assert txt == split_txt
|
|
|
|
def test_album_data_change_wrap_newline(self):
|
|
# Patch ui.term_width to force wrapping
|
|
with patch("beets.ui.commands.ui.term_width", return_value=30):
|
|
# Test newline layout
|
|
config["ui"]["import"]["layout"] = "newline"
|
|
long_name = "another artist with a" + (" very" * 10) + " long name"
|
|
msg = self._show_change(
|
|
cur_artist=long_name, cur_album="another album"
|
|
)
|
|
# _common.log.info("Message:{}".format(msg))
|
|
assert "artist: another artist" in msg
|
|
assert " -> the artist" in msg
|
|
assert "another album -> the album" not in msg
|
|
|
|
def test_item_data_change_wrap_column(self):
|
|
# Patch ui.term_width to force wrapping
|
|
with patch("beets.ui.commands.ui.term_width", return_value=54):
|
|
# Test Column layout
|
|
config["ui"]["import"]["layout"] = "column"
|
|
long_title = "a track with a" + (" very" * 10) + " long name"
|
|
self.items[0].title = long_title
|
|
msg = self._show_change()
|
|
assert "(#1) a track (1:00) -> (#1) the title (0:00)" in msg
|
|
|
|
def test_item_data_change_wrap_newline(self):
|
|
# Patch ui.term_width to force wrapping
|
|
with patch("beets.ui.commands.ui.term_width", return_value=30):
|
|
config["ui"]["import"]["layout"] = "newline"
|
|
long_title = "a track with a" + (" very" * 10) + " long name"
|
|
self.items[0].title = long_title
|
|
msg = self._show_change()
|
|
assert "(#1) a track with" in msg
|
|
assert " -> (#1) the title (0:00)" in msg
|
|
|
|
|
|
@patch("beets.library.Item.try_filesize", Mock(return_value=987))
|
|
class SummarizeItemsTest(BeetsTestCase):
|
|
def setUp(self):
|
|
super().setUp()
|
|
item = library.Item()
|
|
item.bitrate = 4321
|
|
item.length = 10 * 60 + 54
|
|
item.format = "F"
|
|
self.item = item
|
|
|
|
def test_summarize_item(self):
|
|
summary = commands.summarize_items([], True)
|
|
assert summary == ""
|
|
|
|
summary = commands.summarize_items([self.item], True)
|
|
assert summary == "F, 4kbps, 10:54, 987.0 B"
|
|
|
|
def test_summarize_items(self):
|
|
summary = commands.summarize_items([], False)
|
|
assert summary == "0 items"
|
|
|
|
summary = commands.summarize_items([self.item], False)
|
|
assert summary == "1 items, F, 4kbps, 10:54, 987.0 B"
|
|
|
|
# make a copy of self.item
|
|
i2 = self.item.copy()
|
|
|
|
summary = commands.summarize_items([self.item, i2], False)
|
|
assert summary == "2 items, F, 4kbps, 21:48, 1.9 KiB"
|
|
|
|
i2.format = "G"
|
|
summary = commands.summarize_items([self.item, i2], False)
|
|
assert summary == "2 items, F 1, G 1, 4kbps, 21:48, 1.9 KiB"
|
|
|
|
summary = commands.summarize_items([self.item, i2, i2], False)
|
|
assert summary == "3 items, G 2, F 1, 4kbps, 32:42, 2.9 KiB"
|
|
|
|
|
|
class PathFormatTest(BeetsTestCase):
|
|
def test_custom_paths_prepend(self):
|
|
default_formats = ui.get_path_formats()
|
|
|
|
config["paths"] = {"foo": "bar"}
|
|
pf = ui.get_path_formats()
|
|
key, tmpl = pf[0]
|
|
assert key == "foo"
|
|
assert tmpl.original == "bar"
|
|
assert pf[1:] == default_formats
|
|
|
|
|
|
@_common.slow_test()
|
|
class PluginTest(TestPluginTestCase):
|
|
def test_plugin_command_from_pluginpath(self):
|
|
self.run_command("test", lib=None)
|
|
|
|
|
|
@_common.slow_test()
|
|
class CompletionTest(TestPluginTestCase):
|
|
def test_completion(self):
|
|
# Do not load any other bash completion scripts on the system.
|
|
env = dict(os.environ)
|
|
env["BASH_COMPLETION_DIR"] = os.devnull
|
|
env["BASH_COMPLETION_COMPAT_DIR"] = os.devnull
|
|
|
|
# Open a `bash` process to run the tests in. We'll pipe in bash
|
|
# commands via stdin.
|
|
cmd = os.environ.get("BEETS_TEST_SHELL", "/bin/bash --norc").split()
|
|
if not has_program(cmd[0]):
|
|
self.skipTest("bash not available")
|
|
tester = subprocess.Popen(
|
|
cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, env=env
|
|
)
|
|
|
|
# Load bash_completion library.
|
|
for path in commands.BASH_COMPLETION_PATHS:
|
|
if os.path.exists(syspath(path)):
|
|
bash_completion = path
|
|
break
|
|
else:
|
|
self.skipTest("bash-completion script not found")
|
|
try:
|
|
with open(util.syspath(bash_completion), "rb") as f:
|
|
tester.stdin.writelines(f)
|
|
except OSError:
|
|
self.skipTest("could not read bash-completion script")
|
|
|
|
# Load completion script.
|
|
self.io.install()
|
|
self.run_command("completion", lib=None)
|
|
completion_script = self.io.getoutput().encode("utf-8")
|
|
self.io.restore()
|
|
tester.stdin.writelines(completion_script.splitlines(True))
|
|
|
|
# Load test suite.
|
|
test_script_name = os.path.join(_common.RSRC, b"test_completion.sh")
|
|
with open(test_script_name, "rb") as test_script_file:
|
|
tester.stdin.writelines(test_script_file)
|
|
out, err = tester.communicate()
|
|
assert tester.returncode == 0
|
|
assert out == b"completion tests passed\n", (
|
|
"test/test_completion.sh did not execute properly. "
|
|
f'Output:{out.decode("utf-8")}'
|
|
)
|
|
|
|
|
|
class CommonOptionsParserCliTest(BeetsTestCase):
|
|
"""Test CommonOptionsParser and formatting LibModel formatting on 'list'
|
|
command.
|
|
"""
|
|
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.item = _common.item()
|
|
self.item.path = b"xxx/yyy"
|
|
self.lib.add(self.item)
|
|
self.lib.add_album([self.item])
|
|
|
|
def test_base(self):
|
|
l = self.run_with_output("ls")
|
|
assert l == "the artist - the album - the title\n"
|
|
|
|
l = self.run_with_output("ls", "-a")
|
|
assert l == "the album artist - the album\n"
|
|
|
|
def test_path_option(self):
|
|
l = self.run_with_output("ls", "-p")
|
|
assert l == "xxx/yyy\n"
|
|
|
|
l = self.run_with_output("ls", "-a", "-p")
|
|
assert l == "xxx\n"
|
|
|
|
def test_format_option(self):
|
|
l = self.run_with_output("ls", "-f", "$artist")
|
|
assert l == "the artist\n"
|
|
|
|
l = self.run_with_output("ls", "-a", "-f", "$albumartist")
|
|
assert l == "the album artist\n"
|
|
|
|
def test_format_option_unicode(self):
|
|
l = self.run_with_output(
|
|
b"ls", b"-f", "caf\xe9".encode(util.arg_encoding())
|
|
)
|
|
assert l == "caf\xe9\n"
|
|
|
|
def test_root_format_option(self):
|
|
l = self.run_with_output(
|
|
"--format-item", "$artist", "--format-album", "foo", "ls"
|
|
)
|
|
assert l == "the artist\n"
|
|
|
|
l = self.run_with_output(
|
|
"--format-item", "foo", "--format-album", "$albumartist", "ls", "-a"
|
|
)
|
|
assert l == "the album artist\n"
|
|
|
|
def test_help(self):
|
|
l = self.run_with_output("help")
|
|
assert "Usage:" in l
|
|
|
|
l = self.run_with_output("help", "list")
|
|
assert "Usage:" in l
|
|
|
|
with pytest.raises(ui.UserError):
|
|
self.run_command("help", "this.is.not.a.real.command")
|
|
|
|
def test_stats(self):
|
|
l = self.run_with_output("stats")
|
|
assert "Approximate total size:" in l
|
|
|
|
# # Need to have more realistic library setup for this to work
|
|
# l = self.run_with_output('stats', '-e')
|
|
# assert 'Total size:' in l
|
|
|
|
def test_version(self):
|
|
l = self.run_with_output("version")
|
|
assert "Python version" in l
|
|
assert "no plugins loaded" in l
|
|
|
|
# # Need to have plugin loaded
|
|
# l = self.run_with_output('version')
|
|
# assert 'plugins: ' in l
|
|
|
|
|
|
class CommonOptionsParserTest(BeetsTestCase):
|
|
def test_album_option(self):
|
|
parser = ui.CommonOptionsParser()
|
|
assert not parser._album_flags
|
|
parser.add_album_option()
|
|
assert bool(parser._album_flags)
|
|
|
|
assert parser.parse_args([]) == ({"album": None}, [])
|
|
assert parser.parse_args(["-a"]) == ({"album": True}, [])
|
|
assert parser.parse_args(["--album"]) == ({"album": True}, [])
|
|
|
|
def test_path_option(self):
|
|
parser = ui.CommonOptionsParser()
|
|
parser.add_path_option()
|
|
assert not parser._album_flags
|
|
|
|
config["format_item"].set("$foo")
|
|
assert parser.parse_args([]) == ({"path": None}, [])
|
|
assert config["format_item"].as_str() == "$foo"
|
|
|
|
assert parser.parse_args(["-p"]) == (
|
|
{"path": True, "format": "$path"},
|
|
[],
|
|
)
|
|
assert parser.parse_args(["--path"]) == (
|
|
{"path": True, "format": "$path"},
|
|
[],
|
|
)
|
|
|
|
assert config["format_item"].as_str() == "$path"
|
|
assert config["format_album"].as_str() == "$path"
|
|
|
|
def test_format_option(self):
|
|
parser = ui.CommonOptionsParser()
|
|
parser.add_format_option()
|
|
assert not parser._album_flags
|
|
|
|
config["format_item"].set("$foo")
|
|
assert parser.parse_args([]) == ({"format": None}, [])
|
|
assert config["format_item"].as_str() == "$foo"
|
|
|
|
assert parser.parse_args(["-f", "$bar"]) == ({"format": "$bar"}, [])
|
|
assert parser.parse_args(["--format", "$baz"]) == (
|
|
{"format": "$baz"},
|
|
[],
|
|
)
|
|
|
|
assert config["format_item"].as_str() == "$baz"
|
|
assert config["format_album"].as_str() == "$baz"
|
|
|
|
def test_format_option_with_target(self):
|
|
with pytest.raises(KeyError):
|
|
ui.CommonOptionsParser().add_format_option(target="thingy")
|
|
|
|
parser = ui.CommonOptionsParser()
|
|
parser.add_format_option(target="item")
|
|
|
|
config["format_item"].set("$item")
|
|
config["format_album"].set("$album")
|
|
|
|
assert parser.parse_args(["-f", "$bar"]) == ({"format": "$bar"}, [])
|
|
|
|
assert config["format_item"].as_str() == "$bar"
|
|
assert config["format_album"].as_str() == "$album"
|
|
|
|
def test_format_option_with_album(self):
|
|
parser = ui.CommonOptionsParser()
|
|
parser.add_album_option()
|
|
parser.add_format_option()
|
|
|
|
config["format_item"].set("$item")
|
|
config["format_album"].set("$album")
|
|
|
|
parser.parse_args(["-f", "$bar"])
|
|
assert config["format_item"].as_str() == "$bar"
|
|
assert config["format_album"].as_str() == "$album"
|
|
|
|
parser.parse_args(["-a", "-f", "$foo"])
|
|
assert config["format_item"].as_str() == "$bar"
|
|
assert config["format_album"].as_str() == "$foo"
|
|
|
|
parser.parse_args(["-f", "$foo2", "-a"])
|
|
assert config["format_album"].as_str() == "$foo2"
|
|
|
|
def test_add_all_common_options(self):
|
|
parser = ui.CommonOptionsParser()
|
|
parser.add_all_common_options()
|
|
assert parser.parse_args([]) == (
|
|
{"album": None, "path": None, "format": None},
|
|
[],
|
|
)
|
|
|
|
|
|
class EncodingTest(BeetsTestCase):
|
|
"""Tests for the `terminal_encoding` config option and our
|
|
`_in_encoding` and `_out_encoding` utility functions.
|
|
"""
|
|
|
|
def out_encoding_overridden(self):
|
|
config["terminal_encoding"] = "fake_encoding"
|
|
assert ui._out_encoding() == "fake_encoding"
|
|
|
|
def in_encoding_overridden(self):
|
|
config["terminal_encoding"] = "fake_encoding"
|
|
assert ui._in_encoding() == "fake_encoding"
|
|
|
|
def out_encoding_default_utf8(self):
|
|
with patch("sys.stdout") as stdout:
|
|
stdout.encoding = None
|
|
assert ui._out_encoding() == "utf-8"
|
|
|
|
def in_encoding_default_utf8(self):
|
|
with patch("sys.stdin") as stdin:
|
|
stdin.encoding = None
|
|
assert ui._in_encoding() == "utf-8"
|