onyx_online/voicemeeter-api-python
1
0
Fork 0
mirror of https://github.com/onyx-and-iris/voicemeeter-api-python.git synced 2026-03-08 02:59:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

run through formatter

Browse Source
This commit is contained in:
onyx-and-iris 2026-03-07 21:23:37 +00:00
parent 00ac5b1428
commit 9903ecca72
6 changed files with 250 additions and 238 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
tests/conftest.py
View File

@ -1,7 +1,7 @@
def pytest_addoption(parser):
parser.addoption(
"--run-slow",
action="store_true",
'--run-slow',
action='store_true',
default=False,
help="Run slow tests",
help='Run slow tests',
)

22
tests/test_configs.py
View File

@ -10,37 +10,37 @@ class TestUserConfigs:
@classmethod
def setup_class(cls):
vm.apply_config("example")
vm.apply_config('example')
def test_it_tests_vm_config_string(self):
assert "PhysStrip" in vm.strip[data.phys_in].label
assert "VirtStrip" in vm.strip[data.virt_in].label
assert "PhysBus" in vm.bus[data.phys_out].label
assert "VirtBus" in vm.bus[data.virt_out].label
assert 'PhysStrip' in vm.strip[data.phys_in].label
assert 'VirtStrip' in vm.strip[data.virt_in].label
assert 'PhysBus' in vm.bus[data.phys_out].label
assert 'VirtBus' in vm.bus[data.virt_out].label
def test_it_tests_vm_config_bool(self):
assert vm.strip[0].A1 == True
@pytest.mark.skipif(
data.name != "potato",
reason="Skip test if kind is not potato",
data.name != 'potato',
reason='Skip test if kind is not potato',
)
def test_it_tests_vm_config_bool_strip_eq_on(self):
assert vm.strip[data.phys_in].eq.on == True
@pytest.mark.skipif(
data.name != "banana",
reason="Skip test if kind is not banana",
data.name != 'banana',
reason='Skip test if kind is not banana',
)
def test_it_tests_vm_config_bool_bus_eq_ab(self):
assert vm.bus[data.phys_out].eq.ab == True
@pytest.mark.skipif(
"not config.getoption('--run-slow')",
reason="Only run when --run-slow is given",
reason='Only run when --run-slow is given',
)
def test_it_tests_vm_config_busmode(self):
assert vm.bus[data.phys_out].mode.get() == "composite"
assert vm.bus[data.phys_out].mode.get() == 'composite'
def test_it_tests_vm_config_bass_med_high(self):
assert vm.strip[data.virt_in].bass == -3.2

24
tests/test_errors.py
View File

@ -3,7 +3,7 @@ import re
import pytest
import voicemeeterlib
from tests import data, vm
from tests import vm
class TestErrors:
@ -14,36 +14,36 @@ class TestErrors:
voicemeeterlib.error.VMError,
match="Unknown Voicemeeter kind 'unknown_kind'",
):
voicemeeterlib.api("unknown_kind")
voicemeeterlib.api('unknown_kind')
def test_it_tests_an_unknown_parameter(self):
with pytest.raises(
voicemeeterlib.error.CAPIError,
match="VBVMR_SetParameterFloat returned -3",
match='VBVMR_SetParameterFloat returned -3',
) as exc_info:
vm.set("unknown.parameter", 1)
vm.set('unknown.parameter', 1)
e = exc_info.value
assert e.code == -3
assert e.fn_name == "VBVMR_SetParameterFloat"
assert e.fn_name == 'VBVMR_SetParameterFloat'
def test_it_tests_an_unknown_config_name(self):
EXPECTED_MSG = (
"No config with name 'unknown' is loaded into memory",
f"Known configs: {list(vm.configs.keys())}",
f'Known configs: {list(vm.configs.keys())}',
)
with pytest.raises(
voicemeeterlib.error.VMError, match=re.escape("\n".join(EXPECTED_MSG))
voicemeeterlib.error.VMError, match=re.escape('\n'.join(EXPECTED_MSG))
):
vm.apply_config("unknown")
vm.apply_config('unknown')
def test_it_tests_an_invalid_config_key(self):
CONFIG = {
"strip-0": {"A1": True, "B1": True, "gain": -6.0},
"bus-0": {"mute": True, "eq": {"on": True}},
"unknown-0": {"state": True},
"vban-out-1": {"name": "streamname"},
'strip-0': {'A1': True, 'B1': True, 'gain': -6.0},
'bus-0': {'mute': True, 'eq': {'on': True}},
'unknown-0': {'state': True},
'vban-out-1': {'name': 'streamname'},
}
with pytest.raises(ValueError, match="invalid config key 'unknown-0'"):
vm.apply(CONFIG)

64
tests/test_factory.py
View File

@ -7,17 +7,17 @@ class TestRemoteFactories:
__test__ = True
@pytest.mark.skipif(
data.name != "basic",
reason="Skip test if kind is not basic",
data.name != 'basic',
reason='Skip test if kind is not basic',
)
def test_it_tests_vm_remote_attrs_for_basic(self):
assert hasattr(vm, "strip")
assert hasattr(vm, "bus")
assert hasattr(vm, "command")
assert hasattr(vm, "button")
assert hasattr(vm, "vban")
assert hasattr(vm, "device")
assert hasattr(vm, "option")
assert hasattr(vm, 'strip')
assert hasattr(vm, 'bus')
assert hasattr(vm, 'command')
assert hasattr(vm, 'button')
assert hasattr(vm, 'vban')
assert hasattr(vm, 'device')
assert hasattr(vm, 'option')
assert len(vm.strip) == 3
assert len(vm.bus) == 2
@ -25,19 +25,19 @@ class TestRemoteFactories:
assert len(vm.vban.instream) == 6 and len(vm.vban.outstream) == 5
@pytest.mark.skipif(
data.name != "banana",
reason="Skip test if kind is not banana",
data.name != 'banana',
reason='Skip test if kind is not banana',
)
def test_it_tests_vm_remote_attrs_for_banana(self):
assert hasattr(vm, "strip")
assert hasattr(vm, "bus")
assert hasattr(vm, "command")
assert hasattr(vm, "button")
assert hasattr(vm, "vban")
assert hasattr(vm, "device")
assert hasattr(vm, "option")
assert hasattr(vm, "recorder")
assert hasattr(vm, "patch")
assert hasattr(vm, 'strip')
assert hasattr(vm, 'bus')
assert hasattr(vm, 'command')
assert hasattr(vm, 'button')
assert hasattr(vm, 'vban')
assert hasattr(vm, 'device')
assert hasattr(vm, 'option')
assert hasattr(vm, 'recorder')
assert hasattr(vm, 'patch')
assert len(vm.strip) == 5
assert len(vm.bus) == 5
@ -45,20 +45,20 @@ class TestRemoteFactories:
assert len(vm.vban.instream) == 10 and len(vm.vban.outstream) == 9
@pytest.mark.skipif(
data.name != "potato",
reason="Skip test if kind is not potato",
data.name != 'potato',
reason='Skip test if kind is not potato',
)
def test_it_tests_vm_remote_attrs_for_potato(self):
assert hasattr(vm, "strip")
assert hasattr(vm, "bus")
assert hasattr(vm, "command")
assert hasattr(vm, "button")
assert hasattr(vm, "vban")
assert hasattr(vm, "device")
assert hasattr(vm, "option")
assert hasattr(vm, "recorder")
assert hasattr(vm, "patch")
assert hasattr(vm, "fx")
assert hasattr(vm, 'strip')
assert hasattr(vm, 'bus')
assert hasattr(vm, 'command')
assert hasattr(vm, 'button')
assert hasattr(vm, 'vban')
assert hasattr(vm, 'device')
assert hasattr(vm, 'option')
assert hasattr(vm, 'recorder')
assert hasattr(vm, 'patch')
assert hasattr(vm, 'fx')
assert len(vm.strip) == 8
assert len(vm.bus) == 8

340
tests/test_higher.py
View File

@ -3,19 +3,18 @@ import pytest
from tests import data, vm
@pytest.mark.parametrize("value", [False, True])
@pytest.mark.parametrize('value', [False, True])
class TestSetAndGetBoolHigher:
__test__ = True
"""strip tests, physical and virtual"""
@pytest.mark.parametrize(
"index,param",
'index,param',
[
(data.phys_in, "mute"),
(data.phys_in, "mono"),
(data.virt_in, "mc"),
(data.virt_in, "mono"),
(data.phys_in, 'mute'),
(data.phys_in, 'mono'),
(data.virt_in, 'mc'),
],
)
def test_it_sets_and_gets_strip_bool_params(self, index, param, value):
@ -25,14 +24,14 @@ class TestSetAndGetBoolHigher:
""" strip EQ tests, physical """
@pytest.mark.skipif(
data.name != "potato",
reason="Skip test if kind is not potato",
data.name != 'potato',
reason='Skip test if kind is not potato',
)
@pytest.mark.parametrize(
"index,param",
'index,param',
[
(data.phys_in, "on"),
(data.phys_in, "ab"),
(data.phys_in, 'on'),
(data.phys_in, 'ab'),
],
)
def test_it_sets_and_gets_strip_eq_bool_params(self, index, param, value):
@ -43,10 +42,10 @@ class TestSetAndGetBoolHigher:
""" bus tests, physical and virtual """
@pytest.mark.parametrize(
"index,param",
'index,param',
[
(data.phys_out, "mute"),
(data.virt_out, "sel"),
(data.phys_out, 'mute'),
(data.virt_out, 'sel'),
],
)
def test_it_sets_and_gets_bus_bool_params(self, index, param, value):
@ -57,10 +56,10 @@ class TestSetAndGetBoolHigher:
""" bus EQ tests, physical and virtual """
@pytest.mark.parametrize(
"index,param",
'index,param',
[
(data.phys_out, "on"),
(data.virt_out, "ab"),
(data.phys_out, 'on'),
(data.virt_out, 'ab'),
],
)
def test_it_sets_and_gets_bus_eq_bool_params(self, index, param, value):
@ -71,16 +70,16 @@ class TestSetAndGetBoolHigher:
""" bus modes tests, physical and virtual """
@pytest.mark.skipif(
data.name != "basic",
reason="Skip test if kind is not basic",
data.name != 'basic',
reason='Skip test if kind is not basic',
)
@pytest.mark.parametrize(
"index,param",
'index,param',
[
(data.phys_out, "normal"),
(data.phys_out, "amix"),
(data.virt_out, "normal"),
(data.virt_out, "composite"),
(data.phys_out, 'normal'),
(data.phys_out, 'amix'),
(data.virt_out, 'normal'),
(data.virt_out, 'composite'),
],
)
def test_it_sets_and_gets_busmode_basic_bool_params(self, index, param, value):
@ -88,18 +87,18 @@ class TestSetAndGetBoolHigher:
assert getattr(vm.bus[index].mode, param) == value
@pytest.mark.skipif(
data.name == "basic",
reason="Skip test if kind is basic",
data.name == 'basic',
reason='Skip test if kind is basic',
)
@pytest.mark.parametrize(
"index,param",
'index,param',
[
(data.phys_out, "normal"),
(data.phys_out, "amix"),
(data.phys_out, "rearonly"),
(data.virt_out, "normal"),
(data.virt_out, "upmix41"),
(data.virt_out, "composite"),
(data.phys_out, 'normal'),
(data.phys_out, 'amix'),
(data.phys_out, 'rearonly'),
(data.virt_out, 'normal'),
(data.virt_out, 'upmix41'),
(data.virt_out, 'composite'),
],
)
def test_it_sets_and_gets_busmode_bool_params(self, index, param, value):
@ -109,8 +108,8 @@ class TestSetAndGetBoolHigher:
""" macrobutton tests """
@pytest.mark.parametrize(
"index,param",
[(data.button_lower, "state"), (data.button_upper, "trigger")],
'index,param',
[(data.button_lower, 'state'), (data.button_upper, 'trigger')],
)
def test_it_sets_and_gets_macrobutton_bool_params(self, index, param, value):
setattr(vm.button[index], param, value)
@ -119,8 +118,8 @@ class TestSetAndGetBoolHigher:
""" vban instream tests """
@pytest.mark.parametrize(
"index,param",
[(data.vban_in, "on")],
'index,param',
[(data.vban_in, 'on')],
)
def test_it_sets_and_gets_vban_instream_bool_params(self, index, param, value):
setattr(vm.vban.instream[index], param, value)
@ -129,8 +128,8 @@ class TestSetAndGetBoolHigher:
""" vban outstream tests """
@pytest.mark.parametrize(
"index,param",
[(data.vban_out, "on")],
'index,param',
[(data.vban_out, 'on')],
)
def test_it_sets_and_gets_vban_outstream_bool_params(self, index, param, value):
setattr(vm.vban.outstream[index], param, value)
@ -139,8 +138,8 @@ class TestSetAndGetBoolHigher:
""" command tests """
@pytest.mark.parametrize(
"param",
[("lock")],
'param',
[('lock')],
)
def test_it_sets_command_bool_params(self, param, value):
setattr(vm.command, param, value)
@ -148,12 +147,12 @@ class TestSetAndGetBoolHigher:
""" recorder tests """
@pytest.mark.skipif(
data.name == "basic",
reason="Skip test if kind is basic",
data.name == 'basic',
reason='Skip test if kind is basic',
)
@pytest.mark.parametrize(
"param",
[("A1"), ("B2")],
'param',
[('A1'), ('B2')],
)
def test_it_sets_and_gets_recorder_bool_params(self, param, value):
assert hasattr(vm.recorder, param)
@ -161,12 +160,12 @@ class TestSetAndGetBoolHigher:
assert getattr(vm.recorder, param) == value
@pytest.mark.skipif(
data.name == "basic",
reason="Skip test if kind is basic",
data.name == 'basic',
reason='Skip test if kind is basic',
)
@pytest.mark.parametrize(
"param",
[("loop")],
'param',
[('loop')],
)
def test_it_sets_recorder_bool_params(self, param, value):
assert hasattr(vm.recorder, param)
@ -176,12 +175,12 @@ class TestSetAndGetBoolHigher:
""" recoder.mode tests """
@pytest.mark.skipif(
data.name == "basic",
reason="Skip test if kind is basic",
data.name == 'basic',
reason='Skip test if kind is basic',
)
@pytest.mark.parametrize(
"param",
[("loop"), ("recbus")],
'param',
[('loop'), ('recbus')],
)
def test_it_sets_recorder_mode_bool_params(self, param, value):
assert hasattr(vm.recorder.mode, param)
@ -191,11 +190,11 @@ class TestSetAndGetBoolHigher:
""" recorder.armstrip """
@pytest.mark.skipif(
data.name == "basic",
reason="Skip test if kind is basic",
data.name == 'basic',
reason='Skip test if kind is basic',
)
@pytest.mark.parametrize(
"index",
'index',
[
(data.phys_out),
(data.virt_out),
@ -207,11 +206,11 @@ class TestSetAndGetBoolHigher:
""" recorder.armbus """
@pytest.mark.skipif(
data.name == "basic",
reason="Skip test if kind is basic",
data.name == 'basic',
reason='Skip test if kind is basic',
)
@pytest.mark.parametrize(
"index",
'index',
[
(data.phys_out),
(data.virt_out),
@ -223,12 +222,12 @@ class TestSetAndGetBoolHigher:
""" fx tests """
@pytest.mark.skipif(
data.name != "potato",
reason="Skip test if kind is not potato",
data.name != 'potato',
reason='Skip test if kind is not potato',
)
@pytest.mark.parametrize(
"param",
[("reverb"), ("reverb_ab"), ("delay"), ("delay_ab")],
'param',
[('reverb'), ('reverb_ab'), ('delay'), ('delay_ab')],
)
def test_it_sets_and_gets_fx_bool_params(self, param, value):
setattr(vm.fx, param, value)
@ -237,12 +236,12 @@ class TestSetAndGetBoolHigher:
""" patch tests """
@pytest.mark.skipif(
data.name == "basic",
reason="Skip test if kind is basic",
data.name == 'basic',
reason='Skip test if kind is basic',
)
@pytest.mark.parametrize(
"param",
[("postfadercomposite")],
'param',
[('postfadercomposite')],
)
def test_it_sets_and_gets_patch_bool_params(self, param, value):
setattr(vm.patch, param, value)
@ -251,12 +250,12 @@ class TestSetAndGetBoolHigher:
""" patch.insert tests """
@pytest.mark.skipif(
data.name == "basic",
reason="Skip test if kind is basic",
data.name == 'basic',
reason='Skip test if kind is basic',
)
@pytest.mark.parametrize(
"index, param",
[(data.insert_lower, "on"), (data.insert_higher, "on")],
'index, param',
[(data.insert_lower, 'on'), (data.insert_higher, 'on')],
)
def test_it_sets_and_gets_patch_insert_bool_params(self, index, param, value):
setattr(vm.patch.insert[index], param, value)
@ -265,8 +264,8 @@ class TestSetAndGetBoolHigher:
""" option tests """
@pytest.mark.parametrize(
"param",
[("monitoronsel")],
'param',
[('monitoronsel')],
)
def test_it_sets_and_gets_option_bool_params(self, param, value):
setattr(vm.option, param, value)
@ -279,36 +278,49 @@ class TestSetAndGetIntHigher:
"""strip tests, physical and virtual"""
@pytest.mark.parametrize(
"index,param,value",
'index,param,value',
[
(data.phys_in, "limit", -40),
(data.phys_in, "limit", 12),
(data.virt_in, "k", 0),
(data.virt_in, "k", 4),
(data.phys_in, 'limit', -40),
(data.phys_in, 'limit', 12),
(data.virt_in - 1, 'k', 0),
(data.virt_in - 1, 'k', 4),
],
)
def test_it_sets_and_gets_strip_bool_params(self, index, param, value):
def test_it_sets_and_gets_strip_int_params(self, index, param, value):
setattr(vm.strip[index], param, value)
assert getattr(vm.strip[index], param) == value
""" bus tests, physical """
@pytest.mark.parametrize(
'index,param,value',
[
(data.phys_out, 'mono', 0),
(data.phys_out, 'mono', 2),
],
)
def test_it_sets_and_gets_bus_int_params(self, index, param, value):
setattr(vm.bus[index], param, value)
assert getattr(vm.bus[index], param) == value
""" vban outstream tests """
@pytest.mark.parametrize(
"index,param,value",
[(data.vban_out, "sr", 48000)],
'index,param,value',
[(data.vban_out, 'sr', 48000)],
)
def test_it_sets_and_gets_vban_outstream_bool_params(self, index, param, value):
def test_it_sets_and_gets_vban_outstream_int_params(self, index, param, value):
setattr(vm.vban.outstream[index], param, value)
assert getattr(vm.vban.outstream[index], param) == value
""" patch.asio tests """
@pytest.mark.skipif(
data.name == "basic",
reason="Skip test if kind is basic",
data.name == 'basic',
reason='Skip test if kind is basic',
)
@pytest.mark.parametrize(
"index,value",
'index,value',
[
(0, 1),
(data.asio_in, 4),
@ -321,11 +333,11 @@ class TestSetAndGetIntHigher:
""" patch.A2[i]-A5[i] tests """
@pytest.mark.skipif(
data.name == "basic",
reason="Skip test if kind is basic",
data.name == 'basic',
reason='Skip test if kind is basic',
)
@pytest.mark.parametrize(
"index,value",
'index,value',
[
(0, 1),
(data.asio_out, 4),
@ -340,11 +352,11 @@ class TestSetAndGetIntHigher:
""" patch.composite tests """
@pytest.mark.skipif(
data.name == "basic",
reason="Skip test if kind is basic",
data.name == 'basic',
reason='Skip test if kind is basic',
)
@pytest.mark.parametrize(
"index,value",
'index,value',
[
(0, 3),
(0, data.channels),
@ -359,11 +371,11 @@ class TestSetAndGetIntHigher:
""" option tests """
@pytest.mark.skipif(
data.name == "basic",
reason="Skip test if kind is basic",
data.name == 'basic',
reason='Skip test if kind is basic',
)
@pytest.mark.parametrize(
"index,value",
'index,value',
[
(data.phys_out, 30),
(data.phys_out, 500),
@ -376,16 +388,16 @@ class TestSetAndGetIntHigher:
""" recorder tests """
@pytest.mark.skipif(
data.name == "basic",
reason="Skip test if kind is basic",
data.name == 'basic',
reason='Skip test if kind is basic',
)
@pytest.mark.parametrize(
"param,value",
'param,value',
[
("samplerate", 32000),
("samplerate", 96000),
("bitresolution", 16),
("bitresolution", 32),
('samplerate', 32000),
('samplerate', 96000),
('bitresolution', 16),
('bitresolution', 32),
],
)
def test_it_sets_and_gets_recorder_int_params(self, param, value):
@ -400,10 +412,10 @@ class TestSetAndGetFloatHigher:
"""strip tests, physical and virtual"""
@pytest.mark.parametrize(
"index,param,value",
'index,param,value',
[
(data.phys_in, "gain", -3.6),
(data.virt_in, "gain", 5.8),
(data.phys_in, 'gain', -3.6),
(data.virt_in, 'gain', 5.8),
],
)
def test_it_sets_and_gets_strip_float_params(self, index, param, value):
@ -411,25 +423,25 @@ class TestSetAndGetFloatHigher:
assert getattr(vm.strip[index], param) == value
@pytest.mark.parametrize(
"index,value",
'index,value',
[(data.phys_in, 2), (data.phys_in, 2), (data.virt_in, 8), (data.virt_in, 8)],
)
def test_it_gets_prefader_levels_and_compares_length_of_array(self, index, value):
assert len(vm.strip[index].levels.prefader) == value
@pytest.mark.parametrize(
"index,value",
'index,value',
[(data.phys_in, 2), (data.phys_in, 2), (data.virt_in, 8), (data.virt_in, 8)],
)
def test_it_gets_postmute_levels_and_compares_length_of_array(self, index, value):
assert len(vm.strip[index].levels.postmute) == value
@pytest.mark.skipif(
data.name != "potato",
reason="Only test if logged into Potato version",
data.name != 'potato',
reason='Only test if logged into Potato version',
)
@pytest.mark.parametrize(
"index, j, value",
'index, j, value',
[
(data.phys_in, 0, -20.7),
(data.virt_in, 3, -60),
@ -444,12 +456,12 @@ class TestSetAndGetFloatHigher:
""" strip tests, physical """
@pytest.mark.parametrize(
"index, param, value",
'index, param, value',
[
(data.phys_in, "pan_x", -0.6),
(data.phys_in, "pan_x", 0.6),
(data.phys_in, "color_y", 0.8),
(data.phys_in, "fx_x", -0.6),
(data.phys_in, 'pan_x', -0.6),
(data.phys_in, 'pan_x', 0.6),
(data.phys_in, 'color_y', 0.8),
(data.phys_in, 'fx_x', -0.6),
],
)
def test_it_sets_and_gets_strip_xy_params(self, index, param, value):
@ -458,14 +470,14 @@ class TestSetAndGetFloatHigher:
assert getattr(vm.strip[index], param) == value
@pytest.mark.skipif(
data.name != "potato",
reason="Only test if logged into Potato version",
data.name != 'potato',
reason='Only test if logged into Potato version',
)
@pytest.mark.parametrize(
"index, param, value",
'index, param, value',
[
(data.phys_in, "reverb", -1.6),
(data.phys_in, "postfx1", True),
(data.phys_in, 'reverb', -1.6),
(data.phys_in, 'postfx1', True),
],
)
def test_it_sets_and_gets_strip_effects_params(self, index, param, value):
@ -474,14 +486,14 @@ class TestSetAndGetFloatHigher:
assert getattr(vm.strip[index], param) == value
@pytest.mark.skipif(
data.name != "potato",
reason="Only test if logged into Potato version",
data.name != 'potato',
reason='Only test if logged into Potato version',
)
@pytest.mark.parametrize(
"index, param, value",
'index, param, value',
[
(data.phys_in, "gainin", -8.6),
(data.phys_in, "knee", 0.5),
(data.phys_in, 'gainin', -8.6),
(data.phys_in, 'knee', 0.5),
],
)
def test_it_sets_and_gets_strip_comp_params(self, index, param, value):
@ -490,14 +502,14 @@ class TestSetAndGetFloatHigher:
assert getattr(vm.strip[index].comp, param) == value
@pytest.mark.skipif(
data.name != "potato",
reason="Only test if logged into Potato version",
data.name != 'potato',
reason='Only test if logged into Potato version',
)
@pytest.mark.parametrize(
"index, param, value",
'index, param, value',
[
(data.phys_in, "bpsidechain", 120),
(data.phys_in, "hold", 3000),
(data.phys_in, 'bpsidechain', 120),
(data.phys_in, 'hold', 3000),
],
)
def test_it_sets_and_gets_strip_gate_params(self, index, param, value):
@ -506,13 +518,13 @@ class TestSetAndGetFloatHigher:
assert getattr(vm.strip[index].gate, param) == value
@pytest.mark.skipif(
data.name != "potato",
reason="Only test if logged into Potato version",
data.name != 'potato',
reason='Only test if logged into Potato version',
)
@pytest.mark.parametrize(
"index, param, value",
'index, param, value',
[
(data.phys_in, "knob", -8.6),
(data.phys_in, 'knob', -8.6),
],
)
def test_it_sets_and_gets_strip_denoiser_params(self, index, param, value):
@ -522,13 +534,13 @@ class TestSetAndGetFloatHigher:
""" strip tests, virtual """
@pytest.mark.parametrize(
"index, param, value",
'index, param, value',
[
(data.virt_in, "pan_x", -0.6),
(data.virt_in, "pan_x", 0.6),
(data.virt_in, "treble", -1.6),
(data.virt_in, "mid", 5.8),
(data.virt_in, "bass", -8.1),
(data.virt_in, 'pan_x', -0.6),
(data.virt_in, 'pan_x', 0.6),
(data.virt_in, 'treble', -1.6),
(data.virt_in, 'mid', 5.8),
(data.virt_in, 'bass', -8.1),
],
)
def test_it_sets_and_gets_strip_eq_params(self, index, param, value):
@ -538,12 +550,12 @@ class TestSetAndGetFloatHigher:
""" bus tests, physical and virtual """
@pytest.mark.skipif(
data.name != "potato",
reason="Only test if logged into Potato version",
data.name != 'potato',
reason='Only test if logged into Potato version',
)
@pytest.mark.parametrize(
"index, param, value",
[(data.phys_out, "returnreverb", 3.6), (data.virt_out, "returnfx1", 5.8)],
'index, param, value',
[(data.phys_out, 'returnreverb', 3.6), (data.virt_out, 'returnfx1', 5.8)],
)
def test_it_sets_and_gets_bus_effects_float_params(self, index, param, value):
assert hasattr(vm.bus[index], param)
@ -551,30 +563,30 @@ class TestSetAndGetFloatHigher:
assert getattr(vm.bus[index], param) == value
@pytest.mark.parametrize(
"index, param, value",
[(data.phys_out, "gain", -3.6), (data.virt_out, "gain", 5.8)],
'index, param, value',
[(data.phys_out, 'gain', -3.6), (data.virt_out, 'gain', 5.8)],
)
def test_it_sets_and_gets_bus_float_params(self, index, param, value):
setattr(vm.bus[index], param, value)
assert getattr(vm.bus[index], param) == value
@pytest.mark.parametrize(
"index,value",
'index,value',
[(data.phys_out, 8), (data.virt_out, 8)],
)
def test_it_gets_prefader_levels_and_compares_length_of_array(self, index, value):
def test_it_gets_bus_levels_and_compares_length_of_array(self, index, value):
assert len(vm.bus[index].levels.all) == value
@pytest.mark.parametrize("value", ["test0", "test1"])
@pytest.mark.parametrize('value', ['test0', 'test1'])
class TestSetAndGetStringHigher:
__test__ = True
"""strip tests, physical and virtual"""
@pytest.mark.parametrize(
"index, param",
[(data.phys_in, "label"), (data.virt_in, "label")],
'index, param',
[(data.phys_in, 'label'), (data.virt_in, 'label')],
)
def test_it_sets_and_gets_strip_string_params(self, index, param, value):
setattr(vm.strip[index], param, value)
@ -583,8 +595,8 @@ class TestSetAndGetStringHigher:
""" bus tests, physical and virtual """
@pytest.mark.parametrize(
"index, param",
[(data.phys_out, "label"), (data.virt_out, "label")],
'index, param',
[(data.phys_out, 'label'), (data.virt_out, 'label')],
)
def test_it_sets_and_gets_bus_string_params(self, index, param, value):
setattr(vm.bus[index], param, value)
@ -593,8 +605,8 @@ class TestSetAndGetStringHigher:
""" vban instream tests """
@pytest.mark.parametrize(
"index, param",
[(data.vban_in, "name")],
'index, param',
[(data.vban_in, 'name')],
)
def test_it_sets_and_gets_vban_instream_string_params(self, index, param, value):
setattr(vm.vban.instream[index], param, value)
@ -603,29 +615,29 @@ class TestSetAndGetStringHigher:
""" vban outstream tests """
@pytest.mark.parametrize(
"index, param",
[(data.vban_out, "name")],
'index, param',
[(data.vban_out, 'name')],
)
def test_it_sets_and_gets_vban_outstream_string_params(self, index, param, value):
setattr(vm.vban.outstream[index], param, value)
assert getattr(vm.vban.outstream[index], param) == value
@pytest.mark.parametrize("value", [False, True])
@pytest.mark.parametrize('value', [False, True])
class TestSetAndGetMacroButtonHigher:
__test__ = True
"""macrobutton tests"""
@pytest.mark.parametrize(
"index, param",
'index, param',
[
(0, "state"),
(39, "stateonly"),
(69, "trigger"),
(22, "stateonly"),
(45, "state"),
(65, "trigger"),
(0, 'state'),
(39, 'stateonly'),
(69, 'trigger'),
(22, 'stateonly'),
(45, 'state'),
(65, 'trigger'),
],
)
def test_it_sets_and_gets_macrobutton_params(self, index, param, value):

32
tests/test_lower.py
View File

@ -9,12 +9,12 @@ class TestSetAndGetFloatLower:
"""VBVMR_SetParameterFloat, VBVMR_GetParameterFloat"""
@pytest.mark.parametrize(
"param,value",
'param,value',
[
(f"Strip[{data.phys_in}].Mute", 1),
(f"Bus[{data.virt_out}].Eq.on", 1),
(f"Strip[{data.phys_in}].Mute", 0),
(f"Bus[{data.virt_out}].Eq.on", 0),
(f'Strip[{data.phys_in}].Mute', 1),
(f'Bus[{data.virt_out}].Eq.on', 1),
(f'Strip[{data.phys_in}].Mute', 0),
(f'Bus[{data.virt_out}].Eq.on', 0),
],
)
def test_it_sets_and_gets_mute_eq_float_params(self, param, value):
@ -22,11 +22,11 @@ class TestSetAndGetFloatLower:
assert (round(vm.get(param))) == value
@pytest.mark.parametrize(
"param,value",
'param,value',
[
(f"Strip[{data.phys_in}].Comp", 5.3),
(f"Strip[{data.virt_in}].Gain", -37.5),
(f"Bus[{data.virt_out}].Gain", -22.7),
(f'Strip[{data.phys_in}].Comp', 5.3),
(f'Strip[{data.virt_in}].Gain', -37.5),
(f'Bus[{data.virt_out}].Gain', -22.7),
],
)
def test_it_sets_and_gets_comp_gain_float_params(self, param, value):
@ -34,29 +34,29 @@ class TestSetAndGetFloatLower:
assert (round(vm.get(param), 1)) == value
@pytest.mark.parametrize("value", ["test0", "test1"])
@pytest.mark.parametrize('value', ['test0', 'test1'])
class TestSetAndGetStringLower:
__test__ = True
"""VBVMR_SetParameterStringW, VBVMR_GetParameterStringW"""
@pytest.mark.parametrize(
"param",
[(f"Strip[{data.phys_out}].label"), (f"Bus[{data.virt_out}].label")],
'param',
[(f'Strip[{data.phys_out}].label'), (f'Bus[{data.virt_out}].label')],
)
def test_it_sets_and_gets_string_params(self, param, value):
vm.set(param, value)
assert vm.get(param, string=True) == value
@pytest.mark.parametrize("value", [0, 1])
@pytest.mark.parametrize('value', [0, 1])
class TestMacroButtonsLower:
__test__ = True
"""VBVMR_MacroButton_SetStatus, VBVMR_MacroButton_GetStatus"""
@pytest.mark.parametrize(
"index, mode",
'index, mode',
[(33, 1), (49, 1)],
)
def test_it_sets_and_gets_macrobuttons_state(self, index, mode, value):
@ -64,7 +64,7 @@ class TestMacroButtonsLower:
assert vm.get_buttonstatus(index, mode) == value
@pytest.mark.parametrize(
"index, mode",
'index, mode',
[(14, 2), (12, 2)],
)
def test_it_sets_and_gets_macrobuttons_stateonly(self, index, mode, value):
@ -72,7 +72,7 @@ class TestMacroButtonsLower:
assert vm.get_buttonstatus(index, mode) == value
@pytest.mark.parametrize(
"index, mode",
'index, mode',
[(50, 3), (65, 3)],
)
def test_it_sets_and_gets_macrobuttons_trigger(self, index, mode, value):