From da39c4f1fdb42c240fddc54b216f7680c4ec49dc Mon Sep 17 00:00:00 2001 From: Lukas Slebodnik Date: Mon, 9 Jan 2017 19:59:56 +0100 Subject: [PATCH 1/2] intg: Add module for starting services ATM; there is just a class for sssd --- src/tests/intg/services.py | 82 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 82 insertions(+) create mode 100644 src/tests/intg/services.py diff --git a/src/tests/intg/services.py b/src/tests/intg/services.py new file mode 100644 index 0000000..dbb4cd1 --- /dev/null +++ b/src/tests/intg/services.py @@ -0,0 +1,82 @@ +# +# LDAP integration test +# +# Copyright (c) 2017 Red Hat, Inc. +# Author: Lukas Slebodnik +# +# This is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by +# the Free Software Foundation; version 2 only +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . +# +import os +import os.path +import signal +import subprocess +import time + +import config + + +class SSSD(object): + def __init__(self): + self.pid = 0 + + def start(self): + """Start the SSSD process""" + assert self.pid == 0 + + if subprocess.call(["sssd", "-D", "-f"]) != 0: + raise Exception("sssd start failed") + + # wait 2 seconds for pidfile + wait_time = 2 + for _ in range(wait_time * 10): + if os.path.isfile(config.PIDFILE_PATH): + break + time.sleep(.1) + + assert os.path.isfile(config.PIDFILE_PATH) + with open(config.PIDFILE_PATH, "r") as pid_file: + self.pid = int(pid_file.read()) + + def stop(self): + """Stop the SSSD process and remove its state""" + + # stop process only if running + if self.pid != 0: + try: + os.kill(self.pid, signal.SIGTERM) + while True: + try: + os.kill(self.pid, signal.SIGCONT) + except: + break + time.sleep(.1) + except: + pass + + # clean pid so we can start service one more time + self.pid = 0 + + def restart(self): + self.stop() + self.start() + + def go_offline(self): + os.kill(self.pid, signal.SIGUSR1) + + @staticmethod + def clean_cache(): + """Remove SSSD cache files""" + for path in os.listdir(config.DB_PATH): + os.unlink(config.DB_PATH + "/" + path) + for path in os.listdir(config.MCACHE_PATH): + os.unlink(config.MCACHE_PATH + "/" + path) From 1a7c81cbe12a8f2243ddf4305d568d146587f586 Mon Sep 17 00:00:00 2001 From: Lukas Slebodnik Date: Mon, 9 Jan 2017 20:02:46 +0100 Subject: [PATCH 2/2] intg: Use sssd init code from services.py --- src/tests/intg/ldap_local_override_test.py | 106 +++++++++++------------ src/tests/intg/test_enumeration.py | 50 +++-------- src/tests/intg/test_ldap.py | 42 ++-------- src/tests/intg/test_local_domain.py | 40 +++------ src/tests/intg/test_memory_cache.py | 130 +++++++++++++++++------------ src/tests/intg/test_netgroup.py | 61 +++----------- src/tests/intg/test_sssctl.py | 46 +++------- src/tests/intg/test_ts_cache.py | 41 +++------ 8 files changed, 192 insertions(+), 324 deletions(-) diff --git a/src/tests/intg/ldap_local_override_test.py b/src/tests/intg/ldap_local_override_test.py index d78f3cc..7600249 100644 --- a/src/tests/intg/ldap_local_override_test.py +++ b/src/tests/intg/ldap_local_override_test.py @@ -18,16 +18,16 @@ # import os import stat -import ent -import grp import pwd -import config -import signal import subprocess import time import pytest + +import config +import ent import ds_openldap import ldap_ent +import services import sssd_id from util import unindent @@ -96,44 +96,15 @@ def create_conf_fixture(request, contents): request.addfinalizer(lambda: os.unlink(config.CONF_PATH)) -def stop_sssd(): - pid_file = open(config.PIDFILE_PATH, "r") - pid = int(pid_file.read()) - os.kill(pid, signal.SIGTERM) - while True: - try: - os.kill(pid, signal.SIGCONT) - except: - break - time.sleep(1) - - -def start_sssd(): - """Start sssd""" - if subprocess.call(["sssd", "-D", "-f"]) != 0: - raise Exception("sssd start failed") - - -def restart_sssd(): - stop_sssd() - start_sssd() - - def create_sssd_fixture(request): - """Start sssd and add teardown for stopping it and removing state""" - if subprocess.call(["sssd", "-D", "-f"]) != 0: - raise Exception("sssd start failed") + """Start SSSD and add teardown for stopping it and removing its state""" + request.sssd = services.SSSD() + request.sssd.start() - def teardown(): - try: - stop_sssd() - except: - pass - for path in os.listdir(config.DB_PATH): - os.unlink(config.DB_PATH + "/" + path) - for path in os.listdir(config.MCACHE_PATH): - os.unlink(config.MCACHE_PATH + "/" + path) - request.addfinalizer(teardown) + def cleanup_sssd_process(): + request.sssd.stop() + request.sssd.clean_cache() + request.addfinalizer(cleanup_sssd_process) OVERRIDE_FILENAME = "export_file" @@ -269,10 +240,13 @@ def env_two_users_and_group(request, ldap_conn): # Assert entries are not overriden assert_user_default() + return request.sssd + @pytest.fixture def env_two_users_and_group_overriden(request, ldap_conn, env_two_users_and_group): + sssd = env_two_users_and_group # Override subprocess.check_call(["sss_override", "user-add", "user1", @@ -292,11 +266,13 @@ def env_two_users_and_group_overriden(request, ldap_conn, "-s", "/bin/ov_user2_shell"]) # Restart SSSD so the override might take effect - restart_sssd() + sssd.restart() # Assert entries are overriden assert_user_overriden() + return sssd + # # Simple user override @@ -305,6 +281,7 @@ def env_two_users_and_group_overriden(request, ldap_conn, @pytest.fixture def env_simple_user_override(request, ldap_conn, env_two_users_and_group): + sssd = env_two_users_and_group # Override subprocess.check_call(["sss_override", "user-add", "user1", @@ -324,7 +301,7 @@ def env_simple_user_override(request, ldap_conn, env_two_users_and_group): "-s", "/bin/ov_user2_shell"]) # Restart SSSD so the override might take effect - restart_sssd() + sssd.restart() def test_simple_user_override(ldap_conn, env_simple_user_override): @@ -340,6 +317,7 @@ def test_simple_user_override(ldap_conn, env_simple_user_override): @pytest.fixture def env_root_user_override(request, ldap_conn, env_two_users_and_group): + sssd = env_two_users_and_group # Assert entries are not overriden ent.assert_passwd_by_name( @@ -366,7 +344,7 @@ def env_root_user_override(request, ldap_conn, env_two_users_and_group): "-s", "/bin/ov_user2_shell"]) # Restart SSSD so the override might take effect - restart_sssd() + sssd.restart() def test_root_user_override(ldap_conn, env_root_user_override): @@ -430,7 +408,7 @@ def env_replace_user_override(request, ldap_conn): "-s", "/bin/ov_user1_shell"]) # Restart SSSD so the override might take effect - restart_sssd() + request.sssd.restart() # Assert entries are overriden ent.assert_passwd_by_name( @@ -450,7 +428,7 @@ def env_replace_user_override(request, ldap_conn): "-s", "/bin/ov2_user1_shell"]) # Restart SSSD so the override might take effect - restart_sssd() + request.sssd.restart() def test_replace_user_override(ldap_conn, env_replace_user_override): @@ -500,6 +478,7 @@ def test_remove_user_override(ldap_conn, env_remove_user_override): @pytest.fixture def env_imp_exp_user_override(request, ldap_conn, env_two_users_and_group_overriden): + sssd = env_two_users_and_group_overriden # Export overrides subprocess.check_call(["sss_override", "user-export", OVERRIDE_FILENAME]) @@ -517,7 +496,7 @@ def env_imp_exp_user_override(request, ldap_conn, # Import overrides subprocess.check_call(["sss_override", "user-import", OVERRIDE_FILENAME]) - restart_sssd() + sssd.restart() def test_imp_exp_user_override(ldap_conn, env_imp_exp_user_override): @@ -530,6 +509,7 @@ def test_imp_exp_user_override(ldap_conn, env_imp_exp_user_override): def test_imp_exp_user_overrride_noname(ldap_conn, env_two_users_and_group): + sssd = env_two_users_and_group # Override subprocess.check_call(["sss_override", "user-add", "user1", @@ -547,7 +527,7 @@ def test_imp_exp_user_overrride_noname(ldap_conn, "-s", "/bin/ov_user2_shell"]) # Restart SSSD so the override might take effect - restart_sssd() + sssd.restart() # Assert entries are overriden assert_user_overriden(override_name=False) @@ -568,7 +548,7 @@ def test_imp_exp_user_overrride_noname(ldap_conn, # Import overrides subprocess.check_call(["sss_override", "user-import", OVERRIDE_FILENAME]) - restart_sssd() + sssd.restart() assert_user_overriden(override_name=False) @@ -720,9 +700,12 @@ def env_group_basic(request, ldap_conn): with pytest.raises(KeyError): pwd.getpwnam('ov_empty_group@LDAP') + return request.sssd + @pytest.fixture def env_group_override(request, ldap_conn, env_group_basic): + sssd = env_group_basic # Override subprocess.check_call(["sss_override", "group-add", "group", @@ -734,11 +717,13 @@ def env_group_override(request, ldap_conn, env_group_basic): "--gid", "3002"]) # Restart SSSD so the override might take effect - restart_sssd() + sssd.restart() # Assert entries are overridden assert_group_overriden() + return sssd + # # Simple group override @@ -747,6 +732,7 @@ def env_group_override(request, ldap_conn, env_group_basic): @pytest.fixture def env_simple_group_override(request, ldap_conn, env_group_basic): + sssd = env_group_basic # Override subprocess.check_call(["sss_override", "group-add", "group", @@ -758,7 +744,7 @@ def env_simple_group_override(request, ldap_conn, env_group_basic): "--gid", "3002"]) # Restart SSSD so the override might take effect - restart_sssd() + sssd.restart() def test_simple_group_override(ldap_conn, env_simple_group_override): @@ -774,6 +760,7 @@ def test_simple_group_override(ldap_conn, env_simple_group_override): @pytest.fixture def env_root_group_override(request, ldap_conn, env_group_basic): + sssd = env_group_basic # Override subprocess.check_call(["sss_override", "group-add", "group", @@ -785,7 +772,7 @@ def env_root_group_override(request, ldap_conn, env_group_basic): "--gid", "0"]) # Restart SSSD so the override might take effect - restart_sssd() + sssd.restart() def test_root_group_override(ldap_conn, env_root_group_override): @@ -811,6 +798,7 @@ def test_root_group_override(ldap_conn, env_root_group_override): @pytest.fixture def env_replace_group_override(request, ldap_conn, env_group_override): + sssd = env_group_override # Override of override subprocess.check_call(["sss_override", "group-add", "group", @@ -822,7 +810,7 @@ def env_replace_group_override(request, ldap_conn, env_group_override): "--gid", "4002"]) # Restart SSSD so the override might take effect - restart_sssd() + sssd.restart() def test_replace_group_override(ldap_conn, env_replace_group_override): @@ -880,6 +868,7 @@ def test_remove_group_override(ldap_conn, env_remove_group_override): @pytest.fixture def env_imp_exp_group_override(request, ldap_conn, env_group_override): + sssd = env_group_override # Export overrides subprocess.check_call(["sss_override", "group-export", @@ -897,7 +886,7 @@ def env_imp_exp_group_override(request, ldap_conn, env_group_override): # Import overrides subprocess.check_call(["sss_override", "group-import", OVERRIDE_FILENAME]) - restart_sssd() + sssd.restart() def test_imp_exp_group_override(ldap_conn, env_imp_exp_group_override): @@ -909,6 +898,7 @@ def test_imp_exp_group_override(ldap_conn, env_imp_exp_group_override): def test_imp_exp_group_override_noname(ldap_conn, env_group_basic): + sssd = env_group_basic # Override - do not use -n here) subprocess.check_call(["sss_override", "group-add", "group", @@ -918,7 +908,7 @@ def test_imp_exp_group_override_noname(ldap_conn, env_group_basic): "--gid", "3002"]) # Restart SSSD so the override might take effect - restart_sssd() + sssd.restart() # Assert entries are overridden assert_group_overriden(override_name=False) @@ -939,7 +929,7 @@ def test_imp_exp_group_override_noname(ldap_conn, env_group_basic): # Import overrides subprocess.check_call(["sss_override", "group-import", OVERRIDE_FILENAME]) - restart_sssd() + sssd.restart() assert_group_overriden(override_name=False) @@ -986,7 +976,7 @@ def env_regr_2757_override(request, ldap_conn): # Override subprocess.check_call(["sss_override", "user-add", "user1@LDAP", "-n", "alias1"]) - restart_sssd() + request.sssd.restart() def test_regr_2757_override(ldap_conn, env_regr_2757_override): @@ -1041,7 +1031,7 @@ def env_regr_2790_override(request, ldap_conn): subprocess.check_call(["sss_override", "user-add", "user2", "-n", "alias2"]) - restart_sssd() + request.sssd.restart() def test_regr_2790_override(ldap_conn, env_regr_2790_override): @@ -1096,7 +1086,7 @@ def env_mix_cased_name_override(request, ldap_conn): "-h", "/home/ov/user2", "-s", "/bin/ov_user2_shell"]) - restart_sssd() + request.sssd.restart() def test_mix_cased_name_override(ldap_conn, env_mix_cased_name_override): diff --git a/src/tests/intg/test_enumeration.py b/src/tests/intg/test_enumeration.py index 47772de..fa167ec 100644 --- a/src/tests/intg/test_enumeration.py +++ b/src/tests/intg/test_enumeration.py @@ -20,16 +20,16 @@ import stat import pwd import grp -import ent -import config -import signal -import subprocess import time import ldap import pytest + +import config +import ent import ds_openldap import ldap_ent -from util import * +import services +from util import unindent LDAP_BASE_DN = "dc=example,dc=com" INTERACTIVE_TIMEOUT = 4 @@ -179,41 +179,15 @@ def create_conf_fixture(request, contents): create_conf_cleanup(request) -def create_sssd_process(): - """Start the SSSD process""" - if subprocess.call(["sssd", "-D", "-f"]) != 0: - raise Exception("sssd start failed") - - -def cleanup_sssd_process(): - """Stop the SSSD process and remove its state""" - try: - pid_file = open(config.PIDFILE_PATH, "r") - pid = int(pid_file.read()) - os.kill(pid, signal.SIGTERM) - while True: - try: - os.kill(pid, signal.SIGCONT) - except: - break - time.sleep(1) - except: - pass - for path in os.listdir(config.DB_PATH): - os.unlink(config.DB_PATH + "/" + path) - for path in os.listdir(config.MCACHE_PATH): - os.unlink(config.MCACHE_PATH + "/" + path) - - -def create_sssd_cleanup(request): - """Add teardown for stopping SSSD and removing its state""" - request.addfinalizer(cleanup_sssd_process) - - def create_sssd_fixture(request): """Start SSSD and add teardown for stopping it and removing its state""" - create_sssd_process() - create_sssd_cleanup(request) + request.sssd = services.SSSD() + request.sssd.start() + + def cleanup_sssd_process(): + request.sssd.stop() + request.sssd.clean_cache() + request.addfinalizer(cleanup_sssd_process) @pytest.fixture diff --git a/src/tests/intg/test_ldap.py b/src/tests/intg/test_ldap.py index 848cb41..cd546b1 100644 --- a/src/tests/intg/test_ldap.py +++ b/src/tests/intg/test_ldap.py @@ -20,7 +20,6 @@ import stat import pwd import grp -import signal import subprocess import time import ldap @@ -31,6 +30,7 @@ import ds_openldap import ent import ldap_ent +import services import sssd_id import sssd_ldb from util import unindent @@ -188,41 +188,15 @@ def create_conf_fixture(request, contents): create_conf_cleanup(request) -def create_sssd_process(): - """Start the SSSD process""" - if subprocess.call(["sssd", "-D", "-f"]) != 0: - raise Exception("sssd start failed") - - -def cleanup_sssd_process(): - """Stop the SSSD process and remove its state""" - try: - pid_file = open(config.PIDFILE_PATH, "r") - pid = int(pid_file.read()) - os.kill(pid, signal.SIGTERM) - while True: - try: - os.kill(pid, signal.SIGCONT) - except: - break - time.sleep(1) - except: - pass - for path in os.listdir(config.DB_PATH): - os.unlink(config.DB_PATH + "/" + path) - for path in os.listdir(config.MCACHE_PATH): - os.unlink(config.MCACHE_PATH + "/" + path) - - -def create_sssd_cleanup(request): - """Add teardown for stopping SSSD and removing its state""" - request.addfinalizer(cleanup_sssd_process) - - def create_sssd_fixture(request): """Start SSSD and add teardown for stopping it and removing its state""" - create_sssd_process() - create_sssd_cleanup(request) + request.sssd = services.SSSD() + request.sssd.start() + + def cleanup_sssd_process(): + request.sssd.stop() + request.sssd.clean_cache() + request.addfinalizer(cleanup_sssd_process) @pytest.fixture diff --git a/src/tests/intg/test_local_domain.py b/src/tests/intg/test_local_domain.py index 8e1d6fb..6fd3741 100644 --- a/src/tests/intg/test_local_domain.py +++ b/src/tests/intg/test_local_domain.py @@ -20,27 +20,15 @@ import stat import pwd import grp -import time -import config -import signal import subprocess import pytest + +import config import ent +import services from util import unindent -def stop_sssd(): - pid_file = open(config.PIDFILE_PATH, "r") - pid = int(pid_file.read()) - os.kill(pid, signal.SIGTERM) - while True: - try: - os.kill(pid, signal.SIGCONT) - except: - break - time.sleep(1) - - def create_conf_fixture(request, contents): """Generate sssd.conf and add teardown for removing it""" conf = open(config.CONF_PATH, "w") @@ -51,20 +39,14 @@ def create_conf_fixture(request, contents): def create_sssd_fixture(request): - """Start sssd and add teardown for stopping it and removing state""" - if subprocess.call(["sssd", "-D", "-f"]) != 0: - raise Exception("sssd start failed") - - def teardown(): - try: - stop_sssd() - except: - pass - for path in os.listdir(config.DB_PATH): - os.unlink(config.DB_PATH + "/" + path) - for path in os.listdir(config.MCACHE_PATH): - os.unlink(config.MCACHE_PATH + "/" + path) - request.addfinalizer(teardown) + """Start SSSD and add teardown for stopping it and removing its state""" + request.sssd = services.SSSD() + request.sssd.start() + + def cleanup_sssd_process(): + request.sssd.stop() + request.sssd.clean_cache() + request.addfinalizer(cleanup_sssd_process) @pytest.fixture diff --git a/src/tests/intg/test_memory_cache.py b/src/tests/intg/test_memory_cache.py index c7ba724..3fba50a 100644 --- a/src/tests/intg/test_memory_cache.py +++ b/src/tests/intg/test_memory_cache.py @@ -18,16 +18,16 @@ # import os import stat -import ent import grp import pwd -import config -import signal import subprocess -import time import pytest + +import config +import ent import ds_openldap import ldap_ent +import services import sssd_id from util import unindent @@ -78,33 +78,15 @@ def create_conf_fixture(request, contents): request.addfinalizer(lambda: os.unlink(config.CONF_PATH)) -def stop_sssd(): - pid_file = open(config.PIDFILE_PATH, "r") - pid = int(pid_file.read()) - os.kill(pid, signal.SIGTERM) - while True: - try: - os.kill(pid, signal.SIGCONT) - except: - break - time.sleep(1) - - def create_sssd_fixture(request): - """Start sssd and add teardown for stopping it and removing state""" - if subprocess.call(["sssd", "-D", "-f"]) != 0: - raise Exception("sssd start failed") + """Start SSSD and add teardown for stopping it and removing its state""" + request.sssd = services.SSSD() + request.sssd.start() - def teardown(): - try: - stop_sssd() - except: - pass - for path in os.listdir(config.DB_PATH): - os.unlink(config.DB_PATH + "/" + path) - for path in os.listdir(config.MCACHE_PATH): - os.unlink(config.MCACHE_PATH + "/" + path) - request.addfinalizer(teardown) + def cleanup_sssd_process(): + request.sssd.stop() + request.sssd.clean_cache() + request.addfinalizer(cleanup_sssd_process) def load_data_to_ldap(request, ldap_conn): @@ -151,7 +133,7 @@ def sanity_rfc2307(request, ldap_conn): """).format(**locals()) create_conf_fixture(request, conf) create_sssd_fixture(request) - return None + return request.sssd @pytest.fixture @@ -177,7 +159,7 @@ def fqname_rfc2307(request, ldap_conn): """).format(**locals()) create_conf_fixture(request, conf) create_sssd_fixture(request) - return None + return request.sssd @pytest.fixture @@ -204,7 +186,7 @@ def fqname_case_insensitive_rfc2307(request, ldap_conn): """).format(**locals()) create_conf_fixture(request, conf) create_sssd_fixture(request) - return None + return request.sssd def test_getpwnam(ldap_conn, sanity_rfc2307): @@ -291,8 +273,10 @@ def test_getpwnam(ldap_conn, sanity_rfc2307): def test_getpwnam_with_mc(ldap_conn, sanity_rfc2307): + sssd = sanity_rfc2307 + test_getpwnam(ldap_conn, sanity_rfc2307) - stop_sssd() + sssd.stop() test_getpwnam(ldap_conn, sanity_rfc2307) @@ -317,8 +301,10 @@ def test_getgrnam_simple(ldap_conn, sanity_rfc2307): def test_getgrnam_simple_with_mc(ldap_conn, sanity_rfc2307): + sssd = sanity_rfc2307 + test_getgrnam_simple(ldap_conn, sanity_rfc2307) - stop_sssd() + sssd.stop() test_getgrnam_simple(ldap_conn, sanity_rfc2307) @@ -367,8 +353,10 @@ def test_getgrnam_membership(ldap_conn, sanity_rfc2307): def test_getgrnam_membership_with_mc(ldap_conn, sanity_rfc2307): + sssd = sanity_rfc2307 + test_getgrnam_membership(ldap_conn, sanity_rfc2307) - stop_sssd() + sssd.stop() test_getgrnam_membership(ldap_conn, sanity_rfc2307) @@ -399,14 +387,18 @@ def test_initgroups(ldap_conn, sanity_rfc2307): def test_initgroups_with_mc(ldap_conn, sanity_rfc2307): + sssd = sanity_rfc2307 + test_initgroups(ldap_conn, sanity_rfc2307) - stop_sssd() + sssd.stop() test_initgroups(ldap_conn, sanity_rfc2307) def test_initgroups_fqname_with_mc(ldap_conn, fqname_rfc2307): + sssd = fqname_rfc2307 + assert_user_gids_equal('user1@LDAP', [2000, 2001]) - stop_sssd() + sssd.stop() assert_user_gids_equal('user1@LDAP', [2000, 2001]) @@ -422,13 +414,14 @@ def assert_initgroups_equal(user, primary_gid, expected_gids): ) -def assert_stored_last_initgroups(user1_case1, user1_case2, user1_case_last, +def assert_stored_last_initgroups(sssd, + user1_case1, user1_case2, user1_case_last, primary_gid, expected_gids): assert_initgroups_equal(user1_case1, primary_gid, expected_gids) assert_initgroups_equal(user1_case2, primary_gid, expected_gids) assert_initgroups_equal(user1_case_last, primary_gid, expected_gids) - stop_sssd() + sssd.stop() user = user1_case1 (res, errno, _) = sssd_id.call_sssd_initgroups(user, primary_gid) @@ -453,7 +446,8 @@ def test_initgroups_case_insensitive_with_mc1(ldap_conn, primary_gid = 2001 expected_gids = [2000, 2001] - assert_stored_last_initgroups(user1_case1, user1_case2, user1_case_last, + assert_stored_last_initgroups(fqname_case_insensitive_rfc2307, + user1_case1, user1_case2, user1_case_last, primary_gid, expected_gids) @@ -465,7 +459,8 @@ def test_initgroups_case_insensitive_with_mc2(ldap_conn, primary_gid = 2001 expected_gids = [2000, 2001] - assert_stored_last_initgroups(user1_case1, user1_case2, user1_case_last, + assert_stored_last_initgroups(fqname_case_insensitive_rfc2307, + user1_case1, user1_case2, user1_case_last, primary_gid, expected_gids) @@ -477,7 +472,8 @@ def test_initgroups_case_insensitive_with_mc3(ldap_conn, primary_gid = 2001 expected_gids = [2000, 2001] - assert_stored_last_initgroups(user1_case1, user1_case2, user1_case_last, + assert_stored_last_initgroups(fqname_case_insensitive_rfc2307, + user1_case1, user1_case2, user1_case_last, primary_gid, expected_gids) @@ -510,6 +506,7 @@ def run_simple_test_with_initgroups(): def test_invalidation_of_gids_after_initgroups(ldap_conn, sanity_rfc2307): + sssd = sanity_rfc2307 # the sssd cache was empty and not all user's group were # resolved with getgr{nm,gid}. Therefore there is a change in @@ -517,7 +514,7 @@ def test_invalidation_of_gids_after_initgroups(ldap_conn, sanity_rfc2307): run_simple_test_with_initgroups() assert_initgroups_equal("user1", 2001, [2000, 2001]) - stop_sssd() + sssd.stop() ent.assert_passwd_by_name( 'user1', @@ -549,6 +546,7 @@ def test_invalidation_of_gids_after_initgroups(ldap_conn, sanity_rfc2307): def test_initgroups_without_change_in_membership(ldap_conn, sanity_rfc2307): + sssd = sanity_rfc2307 # the sssd cache was empty and not all user's group were # resolved with getgr{nm,gid}. Therefore there is a change in @@ -563,7 +561,7 @@ def test_initgroups_without_change_in_membership(ldap_conn, sanity_rfc2307): # user groups should not be invlaidated run_simple_test_with_initgroups() - stop_sssd() + sssd.stop() # everything should be in memory cache run_simple_test_with_initgroups() @@ -615,6 +613,8 @@ def assert_missing_mc_records_for_user1(): def test_invalidate_user_before_stop(ldap_conn, sanity_rfc2307): + sssd = sanity_rfc2307 + # initialize cache with full ID (res, errno, _) = sssd_id.get_user_groups("user1") assert res == sssd_id.NssReturnCode.SUCCESS, \ @@ -622,25 +622,29 @@ def test_invalidate_user_before_stop(ldap_conn, sanity_rfc2307): assert_mc_records_for_user1() subprocess.call(["sss_cache", "-u", "user1"]) - stop_sssd() + sssd.stop() assert_missing_mc_records_for_user1() def test_invalidate_user_after_stop(ldap_conn, sanity_rfc2307): + sssd = sanity_rfc2307 + # initialize cache with full ID (res, errno, _) = sssd_id.get_user_groups("user1") assert res == sssd_id.NssReturnCode.SUCCESS, \ "Could not find groups for user1, %d" % errno assert_mc_records_for_user1() - stop_sssd() + sssd.stop() subprocess.call(["sss_cache", "-u", "user1"]) assert_missing_mc_records_for_user1() def test_invalidate_users_before_stop(ldap_conn, sanity_rfc2307): + sssd = sanity_rfc2307 + # initialize cache with full ID (res, errno, _) = sssd_id.get_user_groups("user1") assert res == sssd_id.NssReturnCode.SUCCESS, \ @@ -648,25 +652,29 @@ def test_invalidate_users_before_stop(ldap_conn, sanity_rfc2307): assert_mc_records_for_user1() subprocess.call(["sss_cache", "-U"]) - stop_sssd() + sssd.stop() assert_missing_mc_records_for_user1() def test_invalidate_users_after_stop(ldap_conn, sanity_rfc2307): + sssd = sanity_rfc2307 + # initialize cache with full ID (res, errno, _) = sssd_id.get_user_groups("user1") assert res == sssd_id.NssReturnCode.SUCCESS, \ "Could not find groups for user1, %d" % errno assert_mc_records_for_user1() - stop_sssd() + sssd.stop() subprocess.call(["sss_cache", "-U"]) assert_missing_mc_records_for_user1() def test_invalidate_group_before_stop(ldap_conn, sanity_rfc2307): + sssd = sanity_rfc2307 + # initialize cache with full ID (res, errno, _) = sssd_id.get_user_groups("user1") assert res == sssd_id.NssReturnCode.SUCCESS, \ @@ -674,25 +682,29 @@ def test_invalidate_group_before_stop(ldap_conn, sanity_rfc2307): assert_mc_records_for_user1() subprocess.call(["sss_cache", "-g", "group1"]) - stop_sssd() + sssd.stop() assert_missing_mc_records_for_user1() def test_invalidate_group_after_stop(ldap_conn, sanity_rfc2307): + sssd = sanity_rfc2307 + # initialize cache with full ID (res, errno, _) = sssd_id.get_user_groups("user1") assert res == sssd_id.NssReturnCode.SUCCESS, \ "Could not find groups for user1, %d" % errno assert_mc_records_for_user1() - stop_sssd() + sssd.stop() subprocess.call(["sss_cache", "-g", "group1"]) assert_missing_mc_records_for_user1() def test_invalidate_groups_before_stop(ldap_conn, sanity_rfc2307): + sssd = sanity_rfc2307 + # initialize cache with full ID (res, errno, _) = sssd_id.get_user_groups("user1") assert res == sssd_id.NssReturnCode.SUCCESS, \ @@ -700,25 +712,29 @@ def test_invalidate_groups_before_stop(ldap_conn, sanity_rfc2307): assert_mc_records_for_user1() subprocess.call(["sss_cache", "-G"]) - stop_sssd() + sssd.stop() assert_missing_mc_records_for_user1() def test_invalidate_groups_after_stop(ldap_conn, sanity_rfc2307): + sssd = sanity_rfc2307 + # initialize cache with full ID (res, errno, _) = sssd_id.get_user_groups("user1") assert res == sssd_id.NssReturnCode.SUCCESS, \ "Could not find groups for user1, %d" % errno assert_mc_records_for_user1() - stop_sssd() + sssd.stop() subprocess.call(["sss_cache", "-G"]) assert_missing_mc_records_for_user1() def test_invalidate_everything_before_stop(ldap_conn, sanity_rfc2307): + sssd = sanity_rfc2307 + # initialize cache with full ID (res, errno, _) = sssd_id.get_user_groups("user1") assert res == sssd_id.NssReturnCode.SUCCESS, \ @@ -726,19 +742,21 @@ def test_invalidate_everything_before_stop(ldap_conn, sanity_rfc2307): assert_mc_records_for_user1() subprocess.call(["sss_cache", "-E"]) - stop_sssd() + sssd.stop() assert_missing_mc_records_for_user1() def test_invalidate_everything_after_stop(ldap_conn, sanity_rfc2307): + sssd = sanity_rfc2307 + # initialize cache with full ID (res, errno, _) = sssd_id.get_user_groups("user1") assert res == sssd_id.NssReturnCode.SUCCESS, \ "Could not find groups for user1, %d" % errno assert_mc_records_for_user1() - stop_sssd() + sssd.stop() subprocess.call(["sss_cache", "-E"]) assert_missing_mc_records_for_user1() @@ -750,6 +768,8 @@ def test_removed_mc(ldap_conn, sanity_rfc2307): https://fedorahosted.org/sssd/ticket/2726 """ + sssd = sanity_rfc2307 + ent.assert_passwd_by_name( 'user1', dict(name='user1', passwd='*', uid=1001, gid=2001, @@ -761,7 +781,7 @@ def test_removed_mc(ldap_conn, sanity_rfc2307): ent.assert_group_by_name("group1", dict(name="group1", gid=2001)) ent.assert_group_by_gid(2001, dict(name="group1", gid=2001)) - stop_sssd() + sssd.stop() # remove cache without invalidation for path in os.listdir(config.MCACHE_PATH): diff --git a/src/tests/intg/test_netgroup.py b/src/tests/intg/test_netgroup.py index 3cf5dac..e8d6f97 100644 --- a/src/tests/intg/test_netgroup.py +++ b/src/tests/intg/test_netgroup.py @@ -19,9 +19,7 @@ import os import stat -import signal import subprocess -import time import ldap import ldap.modlist import pytest @@ -29,8 +27,9 @@ import config import ds_openldap import ldap_ent -from util import unindent +import services import sssd_netgroup +from util import unindent LDAP_BASE_DN = "dc=example,dc=com" @@ -143,51 +142,15 @@ def create_conf_fixture(request, contents): create_conf_cleanup(request) -def create_sssd_process(): - """Start the SSSD process""" - if subprocess.call(["sssd", "-D", "-f"]) != 0: - raise Exception("sssd start failed") - - -def get_sssd_pid(): - pid_file = open(config.PIDFILE_PATH, "r") - pid = int(pid_file.read()) - return pid - - -def cleanup_sssd_process(): - """Stop the SSSD process and remove its state""" - try: - pid = get_sssd_pid() - os.kill(pid, signal.SIGTERM) - while True: - try: - os.kill(pid, signal.SIGCONT) - except: - break - time.sleep(1) - except: - pass - for path in os.listdir(config.DB_PATH): - os.unlink(config.DB_PATH + "/" + path) - for path in os.listdir(config.MCACHE_PATH): - os.unlink(config.MCACHE_PATH + "/" + path) - - -def create_sssd_cleanup(request): - """Add teardown for stopping SSSD and removing its state""" - request.addfinalizer(cleanup_sssd_process) - - -def simulate_offline(): - pid = get_sssd_pid() - os.kill(pid, signal.SIGUSR1) - - def create_sssd_fixture(request): """Start SSSD and add teardown for stopping it and removing its state""" - create_sssd_process() - create_sssd_cleanup(request) + request.sssd = services.SSSD() + request.sssd.start() + + def cleanup_sssd_process(): + request.sssd.stop() + request.sssd.clean_cache() + request.addfinalizer(cleanup_sssd_process) @pytest.fixture @@ -226,7 +189,7 @@ def add_tripled_netgroup(request, ldap_conn): conf = format_basic_conf(ldap_conn, SCHEMA_RFC2307_BIS) create_conf_fixture(request, conf) create_sssd_fixture(request) - return None + return request.sssd def test_add_tripled_netgroup(add_tripled_netgroup): @@ -471,13 +434,15 @@ def test_removing_nested_netgroups(removing_nested_netgroups, ldap_conn): def test_offline_netgroups(add_tripled_netgroup): + sssd = add_tripled_netgroup + res, _, netgrps = sssd_netgroup.get_sssd_netgroups("tripled_netgroup") assert res == sssd_netgroup.NssReturnCode.SUCCESS assert netgrps == [("host", "user", "domain")] subprocess.check_call(["sss_cache", "-N"]) - simulate_offline() + sssd.go_offline() res, _, netgrps = sssd_netgroup.get_sssd_netgroups("tripled_netgroup") assert res == sssd_netgroup.NssReturnCode.SUCCESS diff --git a/src/tests/intg/test_sssctl.py b/src/tests/intg/test_sssctl.py index 0df5d0b..ae30ae0 100644 --- a/src/tests/intg/test_sssctl.py +++ b/src/tests/intg/test_sssctl.py @@ -17,17 +17,15 @@ # along with this program. If not, see . # import os -import ent -import grp -import pwd import subprocess -import pytest import stat -import time -import signal +import pytest + +import config import ds_openldap +import ent import ldap_ent -import config +import services from util import unindent import sssd_netgroup @@ -78,33 +76,15 @@ def create_conf_fixture(request, contents): request.addfinalizer(lambda: os.unlink(config.CONF_PATH)) -def stop_sssd(): - pid_file = open(config.PIDFILE_PATH, "r") - pid = int(pid_file.read()) - os.kill(pid, signal.SIGTERM) - while True: - try: - os.kill(pid, signal.SIGCONT) - except: - break - time.sleep(1) - - def create_sssd_fixture(request): - """Start sssd and add teardown for stopping it and removing state""" - if subprocess.call(["sssd", "-D", "-f"]) != 0: - raise Exception("sssd start failed") - - def teardown(): - try: - stop_sssd() - except: - pass - for path in os.listdir(config.DB_PATH): - os.unlink(config.DB_PATH + "/" + path) - for path in os.listdir(config.MCACHE_PATH): - os.unlink(config.MCACHE_PATH + "/" + path) - request.addfinalizer(teardown) + """Start SSSD and add teardown for stopping it and removing its state""" + request.sssd = services.SSSD() + request.sssd.start() + + def cleanup_sssd_process(): + request.sssd.stop() + request.sssd.clean_cache() + request.addfinalizer(cleanup_sssd_process) @pytest.fixture diff --git a/src/tests/intg/test_ts_cache.py b/src/tests/intg/test_ts_cache.py index 445cdf6..5fcd501 100644 --- a/src/tests/intg/test_ts_cache.py +++ b/src/tests/intg/test_ts_cache.py @@ -19,17 +19,18 @@ import os import stat -import ent import grp import pwd -import config -import signal import subprocess import time import ldap import pytest + +import config import ds_openldap +import ent import ldap_ent +import services import sssd_ldb import sssd_id from util import unindent @@ -92,33 +93,15 @@ def create_conf_fixture(request, contents): request.addfinalizer(lambda: os.unlink(config.CONF_PATH)) -def stop_sssd(): - pid_file = open(config.PIDFILE_PATH, "r") - pid = int(pid_file.read()) - os.kill(pid, signal.SIGTERM) - while True: - try: - os.kill(pid, signal.SIGCONT) - except: - break - time.sleep(1) - - def create_sssd_fixture(request): - """Start sssd and add teardown for stopping it and removing state""" - if subprocess.call(["sssd", "-D", "-f"]) != 0: - raise Exception("sssd start failed") - - def teardown(): - try: - stop_sssd() - except: - pass - for path in os.listdir(config.DB_PATH): - os.unlink(config.DB_PATH + "/" + path) - for path in os.listdir(config.MCACHE_PATH): - os.unlink(config.MCACHE_PATH + "/" + path) - request.addfinalizer(teardown) + """Start SSSD and add teardown for stopping it and removing its state""" + request.sssd = services.SSSD() + request.sssd.start() + + def cleanup_sssd_process(): + request.sssd.stop() + request.sssd.clean_cache() + request.addfinalizer(cleanup_sssd_process) def load_data_to_ldap(request, ldap_conn, schema):