diff --git a/test/utils_tests/opencas-py-tests/test_cas_config_01.py b/test/utils_tests/opencas-py-tests/test_cas_config_01.py index b52ebe3..e7e9596 100644 --- a/test/utils_tests/opencas-py-tests/test_cas_config_01.py +++ b/test/utils_tests/opencas-py-tests/test_cas_config_01.py @@ -476,3 +476,131 @@ def test_cas_config_from_file_insert_cache_insert_core_to_file( assert set(contents_hashed[cores_index + 1 :]) - set(cores_hashed) == set( ["51/dev/mango_core"] ) + + +@pytest.mark.parametrize( + "cleaning_policy,wake_up,flush_max_buffers,expected_exception", + [ + ("acp", "100", "500", None), # Valid normal values + ("acp", "0", "1", None), # Boundary value test + ("acp", "9999", "9999", None), # Boundary value test + ("acp", "-1", "500", ValueError), # Invalid wake_up value + ("acp", "10000", "500", ValueError), # Out of range wake_up value + ("acp", "abc", "500", ValueError), # Non-numeric wake_up value + ("acp", "100", "0", ValueError), # Invalid flush_max_buffers value + ("acp", "100", "10000", ValueError), # Out of range flush_max_buffers value + ("acp", "100", "abc", ValueError), # Non-numeric flush_max_buffers value + ("alru", "100", "500", None), # Valid normal values + ("alru", "0", "1", None), # Boundary value test + ("alru", "3599", "9999", None), # Boundary value test + ("alru", "-1", "500", ValueError), # Invalid wake_up value + ("alru", "3600", "500", ValueError), # Out of range wake_up value + ("alru", "abc", "500", ValueError), # Non-numeric wake_up value + ("alru", "100", "0", ValueError), # Invalid flush_max_buffers value + ("alru", "100", "10000", ValueError), # Out of range flush_max_buffers value + ("alru", "100", "abc", ValueError), # Non-numeric flush_max_buffers value + ("nop", "100", "500", ValueError), # Testing parameters for unsupported cleaning policy + ], +) +def test_cache_config_cleaning_policy_parameters(cleaning_policy, wake_up, flush_max_buffers, expected_exception): + """Test validation of wake_up and flush_max_buffers parameters for different cleaning policies""" + cache = opencas.cas_config.cache_config(1, "/dev/dummy", "WT", cleaning_policy=cleaning_policy) + + # Add test parameters + cache.params["wake-up"] = wake_up + cache.params["flush-max-buffers"] = flush_max_buffers + + if expected_exception: + with pytest.raises(expected_exception): + cache.check_wake_up_valid(wake_up) + cache.check_flush_max_buffers_valid(flush_max_buffers) + else: + # No exception should be raised + cache.check_wake_up_valid(wake_up) + cache.check_flush_max_buffers_valid(flush_max_buffers) + + +@pytest.mark.parametrize( + "cache_config_str, exception", + [ + ("1 /dev/dummy WT cleaning_policy=acp,wake-up=100,flush-max-buffers=500", None), + ("1 /dev/dummy WT cleaning_policy=alru,wake-up=60,flush-max-buffers=100", None), + ("1 /dev/dummy WT cleaning_policy=acp,wake-up=10000,flush-max-buffers=500", ValueError), + ("1 /dev/dummy WT cleaning_policy=acp,wake-up=100,flush-max-buffers=0", ValueError), + ("1 /dev/dummy WT cleaning_policy=alru,wake-up=3600,flush-max-buffers=100", ValueError), + ("1 /dev/dummy WT cleaning_policy=alru,wake-up=100,flush-max-buffers=10000", ValueError), + ("1 /dev/dummy WT cleaning_policy=nop,wake-up=100,flush-max-buffers=500", ValueError), + ], +) +def test_cache_config_from_line_with_cleaning_parameters(cache_config_str, exception): + """Test parsing cache configuration with cleaning policy parameters from config line""" + if exception: + with pytest.raises(exception): + cache = opencas.cas_config.cache_config.from_line(cache_config_str) + else: + cache = opencas.cas_config.cache_config.from_line(cache_config_str) + assert cache.params.get("cleaning_policy") in ["acp", "alru"] + assert "wake-up" in cache.params + assert "flush-max-buffers" in cache.params + + +@patch("opencas.casadm.run_cmd") +def test_set_param_cleaning_policy(mock_run_cmd): + """Test the set_param_cleaning_policy method call""" + # ACP policy + opencas.casadm.set_param_cleaning_policy("acp", 1, wake_up="100", flush_max_buffers="500") + mock_run_cmd.assert_called_with([ + '/sbin/casadm', + '--set-param', '--name', 'cleaning-acp', + '--cache-id', '1', + '--wake-up', '100', + '--flush-max-buffers', '500' + ]) + + # ALRU policy + mock_run_cmd.reset_mock() + opencas.casadm.set_param_cleaning_policy("alru", 2, wake_up="60", flush_max_buffers="200") + mock_run_cmd.assert_called_with([ + '/sbin/casadm', + '--set-param', '--name', 'cleaning-alru', + '--cache-id', '2', + '--wake-up', '60', + '--flush-max-buffers', '200' + ]) + + +@patch("opencas.casadm.set_param_cleaning_policy") +@patch("opencas.casadm.set_param") +def test_configure_cache_cleaning_policy(mock_set_param, mock_set_param_cleaning_policy): + """Test handling different cleaning policies in cache configuration""" + # ACP policy test + cache_acp = opencas.cas_config.cache_config(1, "/dev/dummy", "WT", + cleaning_policy="acp", + wake_up="100", + flush_max_buffers="500") + opencas.configure_cache(cache_acp) + mock_set_param_cleaning_policy.assert_called_once_with( + policy="acp", cache_id=1, wake_up="100", flush_max_buffers="500" + ) + mock_set_param.assert_not_called() + + # ALRU policy test + mock_set_param.reset_mock() + mock_set_param_cleaning_policy.reset_mock() + cache_alru = opencas.cas_config.cache_config(2, "/dev/dummy", "WT", + cleaning_policy="alru", + wake_up="60", + flush_max_buffers="200") + opencas.configure_cache(cache_alru) + mock_set_param_cleaning_policy.assert_called_once_with( + policy="alru", cache_id=2, wake_up="60", flush_max_buffers="200" + ) + mock_set_param.assert_not_called() + + # NOP policy test + mock_set_param.reset_mock() + mock_set_param_cleaning_policy.reset_mock() + cache_nop = opencas.cas_config.cache_config(3, "/dev/dummy", "WT", cleaning_policy="nop") + opencas.configure_cache(cache_nop) + mock_set_param.assert_called_once_with("cleaning", cache_id=3, policy="nop") + mock_set_param_cleaning_policy.assert_not_called()