Changing test file structure to ensure pytest discoverability (#289)

Author: georgev93

.github/CONTRIBUTING.md

@@ -7,7 +7,7 @@ If you want to contribute a new feature or fix, please:
 - Check if there isn't any open issue for the same problem
 - Fork the project
 - Implement your feature or fix
-- Bonus points if you provide a test case in `test/test.py`
+- Bonus points if you provide a test case in `test/test_*.py`
 - Provide a commit for the change you want to make (one feature per commit, please)
 - Create a pull request
 
@@ -17,4 +17,4 @@ If you want to contribute a new feature or fix, please:
 
 ## Issues and Questions
 
-If you simply have a question or want to raise an issue, head to the issue tracker. There's a template there that you're kindly asked to fill out. It helps me understand what the problem might be.
+If you simply have a question or want to raise an issue, head to the issue tracker. There's a template there that you're kindly asked to fill out. It helps me understand what the problem might be.

.github/workflows/python-package.yml

@@ -34,4 +34,4 @@ jobs:
         mypy ffmpeg_normalize
     - name: Test with pytest
       run: |
-        pytest test/test.py
+        pytest

DEVELOPERS.md

@@ -2,10 +2,10 @@
 
 ## Tests
 
-Tests are located in `test/test.py`. To run them:
+Tests are located in `tests/test_*.py`. To run them:
 
 - Install `requirements.txt` and `requirements.dev.txt`
-- Run `pytest test/test.py`
+- Run `pytest`
 
 ## Creating API Docs
 

test/out.mp4 tests/out.mp4test/out.mp4 renamed to tests/out.mp4

@@ -148,21 +148,21 @@ def cleanup(self):
                 shutil.rmtree("normalized")
 
     def test_output_filename_and_folder(self):
-        ffmpeg_normalize_call(["test/test.mp4"])
+        ffmpeg_normalize_call(["tests/test.mp4"])
         assert os.path.isfile("normalized/test.mkv")
 
     def test_default_warnings(self):
         _, stderr = ffmpeg_normalize_call(
-            ["test/test.mp4", "--dynamic", "-o", "normalized/test2.wav"]
+            ["tests/test.mp4", "--dynamic", "-o", "normalized/test2.wav"]
         )
         assert "sample rate will automatically be set" in stderr
 
     def test_multiple_outputs(self):
         os.makedirs("normalized", exist_ok=True)
         ffmpeg_normalize_call(
             [
-                "test/test.mp4",
-                "test/test.mp4",
+                "tests/test.mp4",
+                "tests/test.mp4",
                 "-o",
                 "normalized/test1.mkv",
                 "normalized/test2.mkv",
@@ -172,23 +172,23 @@ def test_multiple_outputs(self):
         assert os.path.isfile("normalized/test2.mkv")
 
     def test_overwrites(self):
-        ffmpeg_normalize_call(["test/test.mp4", "-v"])
-        _, stderr = ffmpeg_normalize_call(["test/test.mp4", "-v"])
+        ffmpeg_normalize_call(["tests/test.mp4", "-v"])
+        _, stderr = ffmpeg_normalize_call(["tests/test.mp4", "-v"])
         assert "exists" in stderr
 
     def test_dry(self):
-        ffmpeg_normalize_call(["test/test.mp4", "-n"])
+        ffmpeg_normalize_call(["tests/test.mp4", "-n"])
         assert not os.path.isfile("normalized/test.mkv")
 
     def test_only_supports_one_stream_output(self):
         os.makedirs("normalized", exist_ok=True)
         _, stderr = ffmpeg_normalize_call(
-            ["test/test.mp4", "-o", "normalized/test.wav", "-v"]
+            ["tests/test.mp4", "-o", "normalized/test.wav", "-v"]
         )
         assert "Output file only supports one stream" in stderr
 
     def test_peak(self):
-        ffmpeg_normalize_call(["test/test.mp4", "-nt", "peak", "-t", "0"])
+        ffmpeg_normalize_call(["tests/test.mp4", "-nt", "peak", "-t", "0"])
         assert os.path.isfile("normalized/test.mkv")
         assert fuzzy_equal(
             _get_stats("normalized/test.mkv", "peak"),
@@ -215,7 +215,7 @@ def test_peak(self):
         )
 
     def test_rms(self):
-        ffmpeg_normalize_call(["test/test.mp4", "-nt", "rms", "-t", "-15"])
+        ffmpeg_normalize_call(["tests/test.mp4", "-nt", "rms", "-t", "-15"])
         assert os.path.isfile("normalized/test.mkv")
         assert fuzzy_equal(
             _get_stats("normalized/test.mkv", "rms"),
@@ -242,7 +242,7 @@ def test_rms(self):
         )
 
     def test_ebu(self):
-        ffmpeg_normalize_call(["test/test.mp4", "-nt", "ebu"])
+        ffmpeg_normalize_call(["tests/test.mp4", "-nt", "ebu"])
         assert os.path.isfile("normalized/test.mkv")
         assert fuzzy_equal(
             _get_stats("normalized/test.mkv", "ebu"),
@@ -291,15 +291,15 @@ def test_ebu(self):
         )
 
     def test_acodec(self):
-        ffmpeg_normalize_call(["test/test.mp4", "-c:a", "aac"])
+        ffmpeg_normalize_call(["tests/test.mp4", "-c:a", "aac"])
         assert os.path.isfile("normalized/test.mkv")
         assert _get_stream_info("normalized/test.mkv")[1]["codec_name"] == "aac"
 
     def test_abr(self):
         os.makedirs("normalized", exist_ok=True)
         ffmpeg_normalize_call(
             [
-                "test/test.mp4",
+                "tests/test.mp4",
                 "-c:a",
                 "aac",
                 "-b:a",
@@ -316,37 +316,37 @@ def test_abr(self):
         )
 
     def test_ar(self):
-        ffmpeg_normalize_call(["test/test.mp4", "-ar", "48000"])
+        ffmpeg_normalize_call(["tests/test.mp4", "-ar", "48000"])
         assert os.path.isfile("normalized/test.mkv")
         assert _get_stream_info("normalized/test.mkv")[1]["sample_rate"] == "48000"
 
     def test_vcodec(self):
-        ffmpeg_normalize_call(["test/test.mp4", "-c:v", "libx265"])
+        ffmpeg_normalize_call(["tests/test.mp4", "-c:v", "libx265"])
         assert os.path.isfile("normalized/test.mkv")
         assert _get_stream_info("normalized/test.mkv")[0]["codec_name"] == "hevc"
 
     def test_extra_input_options_json(self):
         ffmpeg_normalize_call(
-            ["test/test.mp4", "-c:a", "aac", "-ei", '[ "-f", "mp4" ]']
+            ["tests/test.mp4", "-c:a", "aac", "-ei", '[ "-f", "mp4" ]']
         )
         # FIXME: some better test that options are respected?
         assert os.path.isfile("normalized/test.mkv")
 
     def test_extra_output_options_json(self):
-        ffmpeg_normalize_call(["test/test.mp4", "-c:a", "aac", "-e", '[ "-vbr", "3" ]'])
+        ffmpeg_normalize_call(["tests/test.mp4", "-c:a", "aac", "-e", '[ "-vbr", "3" ]'])
         # FIXME: some better test that options are respected?
         assert os.path.isfile("normalized/test.mkv")
 
     def test_ofmt_fail(self):
         _, stderr = ffmpeg_normalize_call(
-            ["test/test.mp4", "-ofmt", "mp3", "-o", "normalized/test.mp3", "-vn", "-sn"]
+            ["tests/test.mp4", "-ofmt", "mp3", "-o", "normalized/test.mp3", "-vn", "-sn"]
         )
         assert "does not support" in stderr
 
     def test_ofmt_mp3(self):
         ffmpeg_normalize_call(
             [
-                "test/test.mp4",
+                "tests/test.mp4",
                 "-ofmt",
                 "mp3",
                 "-o",
@@ -360,31 +360,31 @@ def test_ofmt_mp3(self):
         assert os.path.isfile("normalized/test.mp3")
 
     def test_ext_fail(self):
-        _, stderr = ffmpeg_normalize_call(["test/test.mp4", "-ext", "mp3"])
+        _, stderr = ffmpeg_normalize_call(["tests/test.mp4", "-ext", "mp3"])
         assert "does not support" in stderr
 
     def test_ext_mp3(self):
-        ffmpeg_normalize_call(["test/test.mp4", "-ext", "mp3", "-c:a", "libmp3lame"])
+        ffmpeg_normalize_call(["tests/test.mp4", "-ext", "mp3", "-c:a", "libmp3lame"])
         assert os.path.isfile("normalized/test.mp3")
 
     def test_version(self):
         stdout, _ = ffmpeg_normalize_call(["--version"])
         assert "ffmpeg-normalize v" in stdout
 
     def test_progress(self):
-        _, stderr = ffmpeg_normalize_call(["test/test.mp4", "-pr"])
+        _, stderr = ffmpeg_normalize_call(["tests/test.mp4", "-pr"])
         assert "0/100" in stderr
         assert "100/100" in stderr or "100%" in stderr
         assert os.path.isfile("normalized/test.mkv")
 
     def test_duration(self):
-        _, stderr = ffmpeg_normalize_call(["test/test.wav", "--debug"])
+        _, stderr = ffmpeg_normalize_call(["tests/test.wav", "--debug"])
         assert "Found duration: " in stderr
 
     def test_pre_filters(self):
         ffmpeg_normalize_call(
             [
-                "test/test.wav",
+                "tests/test.wav",
                 "-o",
                 "normalized/test2.wav",
                 "-prf",
@@ -421,7 +421,7 @@ def test_pre_filters(self):
     def test_post_filters(self):
         ffmpeg_normalize_call(
             [
-                "test/test.wav",
+                "tests/test.wav",
                 "-o",
                 "normalized/test2.wav",
                 "-pof",
@@ -457,31 +457,31 @@ def test_post_filters(self):
 
     def test_quiet(self):
         _, stderr = ffmpeg_normalize_call(
-            ["test/test.mp4", "-ext", "wav", "-vn", "-f", "q"]
+            ["tests/test.mp4", "-ext", "wav", "-vn", "-f", "q"]
         )
         assert "only supports one stream" not in stderr
 
     def test_audio_channels(self):
         ffmpeg_normalize_call(
-            ["test/test.mp4", "-ac", "1", "-o", "normalized/test.wav"]
+            ["tests/test.mp4", "-ac", "1", "-o", "normalized/test.wav"]
         )
         assert os.path.isfile("normalized/test.wav")
         stream_info = _get_stream_info("normalized/test.wav")[0]
         assert stream_info["channels"] == 1
 
         ffmpeg_normalize_call(
-            ["test/test.mp4", "-ac", "2", "-o", "normalized/test2.wav"]
+            ["tests/test.mp4", "-ac", "2", "-o", "normalized/test2.wav"]
         )
         assert os.path.isfile("normalized/test2.wav")
         stream_info = _get_stream_info("normalized/test2.wav")[0]
         assert stream_info["channels"] == 2
 
     def test_replaygain(self):
         for file in [
-            "test/test.mp4",
-            "test/test.mp3",
-            "test/test.ogg",
-            "test/test.opus",
+            "tests/test.mp4",
+            "tests/test.mp3",
+            "tests/test.ogg",
+            "tests/test.opus",
         ]:
             original_mtime = os.path.getmtime(file)
             ffmpeg_normalize_call([file, "--replaygain"])