http://git-wip-us.apache.org/repos/asf/ambari/blob/49955a35/ambari-server/src/test/python/TestAmbariServer.py ---------------------------------------------------------------------- diff --git a/ambari-server/src/test/python/TestAmbariServer.py b/ambari-server/src/test/python/TestAmbariServer.py index 4484458..d11e4fe 100644 --- a/ambari-server/src/test/python/TestAmbariServer.py +++ b/ambari-server/src/test/python/TestAmbariServer.py @@ -34,7 +34,7 @@ import StringIO import tempfile from unittest import TestCase -from only_for_platform import only_for_platform, get_platform, PLATFORM_LINUX, PLATFORM_WINDOWS +from only_for_platform import get_platform, not_for_platform, only_for_platform, PLATFORM_LINUX, PLATFORM_WINDOWS if get_platform() != PLATFORM_WINDOWS: os_distro_value = ('Suse','11','Final') @@ -50,17 +50,35 @@ with patch("platform.linux_distribution", return_value = os_distro_value): with patch("glob.glob", return_value = ['/etc/init.d/postgresql-9.3']): _ambari_server_ = __import__('ambari-server') - from ambari_commons import Firewall, OSCheck, OSConst, FirewallChecks + from ambari_commons import Firewall, OSCheck, OSConst from ambari_commons.exceptions import FatalException, NonFatalException - from ambari_commons.logging_utils import get_verbose, set_verbose, get_silent, set_silent, get_debug_mode - from ambari_commons.os_utils import run_os_command, search_file + from ambari_commons.logging_utils import get_verbose, set_verbose, get_silent, set_silent, get_debug_mode, \ + print_info_msg, print_warning_msg, print_error_msg + from ambari_commons.os_utils import run_os_command, search_file, set_file_permissions, remove_file, copy_file, \ + is_valid_filepath + from ambari_server.dbConfiguration import DBMSConfigFactory, check_jdbc_drivers + from ambari_server.dbConfiguration_linux import PGConfig, LinuxDBMSConfig, OracleConfig from ambari_server.properties import Properties from ambari_server.resourceFilesKeeper import ResourceFilesKeeper, KeeperException - from ambari_server.serverConfiguration import AMBARI_PROPERTIES_BACKUP_FILE, AMBARI_PROPERTIES_FILE, \ - NR_USER_PROPERTY, configDefaults, \ - find_properties_file, get_ambari_properties, get_JAVA_HOME, read_ambari_user, \ - update_ambari_properties, update_properties, update_properties_2, write_property - from ambari_server.userInput import get_YN_input, get_choice_string_input + from ambari_server.serverConfiguration import configDefaults, \ + check_database_name_property, \ + find_properties_file, get_ambari_classpath, get_ambari_jars, get_ambari_properties, get_JAVA_HOME, get_share_jars, \ + parse_properties_file, read_ambari_user, update_ambari_properties, update_properties_2, write_property, find_jdk, \ + AMBARI_CONF_VAR, AMBARI_SERVER_LIB, JDBC_DATABASE_PROPERTY, JDBC_RCA_PASSWORD_FILE_PROPERTY, \ + PERSISTENCE_TYPE_PROPERTY, JDBC_URL_PROPERTY, get_conf_dir, JDBC_USER_NAME_PROPERTY, JDBC_PASSWORD_PROPERTY, \ + JDBC_DATABASE_NAME_PROPERTY, OS_TYPE_PROPERTY, validate_jdk, JDBC_POSTGRES_SCHEMA_PROPERTY, \ + RESOURCES_DIR_PROPERTY, JDBC_RCA_PASSWORD_ALIAS, JDBC_RCA_SCHEMA_PROPERTY, IS_LDAP_CONFIGURED, \ + LDAP_MGR_PASSWORD_PROPERTY, LDAP_MGR_PASSWORD_ALIAS, JDBC_PASSWORD_FILENAME, NR_USER_PROPERTY, SECURITY_KEY_IS_PERSISTED, \ + SSL_TRUSTSTORE_PASSWORD_PROPERTY, SECURITY_IS_ENCRYPTION_ENABLED, SSL_TRUSTSTORE_PASSWORD_ALIAS, \ + SECURITY_MASTER_KEY_LOCATION, SECURITY_KEYS_DIR + from ambari_server.serverSetup import check_selinux, check_ambari_user, proceedJDBCProperties, SE_STATUS_DISABLED, SE_MODE_ENFORCING, configure_os_settings, \ + download_and_install_jdk, prompt_db_properties, setup, \ + AmbariUserChecks, AmbariUserChecksLinux, AmbariUserChecksWindows, JDKSetup, reset, is_server_runing + from ambari_server.serverUpgrade import upgrade, upgrade_local_repo, change_objects_owner, upgrade_stack, \ + run_stack_upgrade, run_metainfo_upgrade, run_schema_upgrade, move_user_custom_actions + from ambari_server.setupSecurity import get_pass_file_path, store_password_file, read_password, \ + adjust_directory_permissions, get_alias_string + from ambari_server.userInput import get_YN_input, get_choice_string_input, get_validated_string_input CURR_AMBARI_VERSION = "2.0.0" @@ -74,73 +92,71 @@ class TestAmbariServer(TestCase): sys.stdout = sys.__stdout__ - @patch.object(_ambari_server_, "configure_database_username_password") - @patch.object(_ambari_server_, "run_os_command") - @patch('optparse.Values') - def test_configure_pg_hba_ambaridb_users(self, OptParseValuesMock, - run_os_command_method, - configure_database_username_password_method): + @not_for_platform(PLATFORM_WINDOWS) + @patch("ambari_server.dbConfiguration_linux.run_os_command") + def test_configure_pg_hba_ambaridb_users(self, run_os_command_method): # Prepare mocks run_os_command_method.return_value = (0, "", "") - opvm = OptParseValuesMock.return_value - opvm.database_username = "ffdf" + database_username = "ffdf" tf1 = tempfile.NamedTemporaryFile() - _ambari_server_.PG_HBA_CONF_FILE = tf1.name # Run test - _ambari_server_.configure_pg_hba_ambaridb_users() + PGConfig._configure_pg_hba_ambaridb_users(tf1.name, database_username) # Check results self.assertTrue(run_os_command_method.called) - self.assertTrue(configure_database_username_password_method.called) - string_expected = self.get_file_string(self - .get_samples_dir("configure_pg_hba_ambaridb_users1")) - string_actual = self.get_file_string(_ambari_server_.PG_HBA_CONF_FILE) + string_expected = self.get_file_string(self.get_samples_dir("configure_pg_hba_ambaridb_users1")) + string_actual = self.get_file_string(tf1.name) self.assertEquals(string_expected, string_actual) pass - @patch('__builtin__.raw_input') + @not_for_platform(PLATFORM_WINDOWS) + @patch("__builtin__.raw_input") def test_servicename_regex(self, raw_input_method): ''' Test to make sure the service name can contain digits ''' set_silent(False) raw_input_method.return_value = "OT100" - result = _ambari_server_.get_validated_service_name("ambari", 1) + result = OracleConfig._get_validated_service_name("ambari", 1) self.assertEqual("OT100", result, "Not accepting digits") pass - @patch('__builtin__.raw_input') + @not_for_platform(PLATFORM_WINDOWS) + @patch("__builtin__.raw_input") def test_dbname_regex(self, raw_input_method): ''' Test to make sure the service name can contain digits ''' set_silent(False) raw_input_method.return_value = "OT100" - result = _ambari_server_.get_validated_db_name("ambari") + result = LinuxDBMSConfig._get_validated_db_name("Database", "ambari") self.assertEqual("OT100", result, "Not accepting digits") + pass + @not_for_platform(PLATFORM_WINDOWS) def test_configure_pg_hba_postgres_user(self): tf1 = tempfile.NamedTemporaryFile() - _ambari_server_.PG_HBA_CONF_FILE = tf1.name + PGConfig.PG_HBA_CONF_FILE = tf1.name - with open(_ambari_server_.PG_HBA_CONF_FILE, 'w') as fout: + with open(PGConfig.PG_HBA_CONF_FILE, 'w') as fout: fout.write("\n") fout.write("local all all md5\n") fout.write("host all all 0.0.0.0/0 md5\n") fout.write("host all all ::/0 md5\n") - _ambari_server_.configure_pg_hba_postgres_user() + PGConfig._configure_pg_hba_postgres_user() expected = self.get_file_string(self.get_samples_dir( "configure_pg_hba_ambaridb_users2")) - result = self.get_file_string(_ambari_server_.PG_HBA_CONF_FILE) + result = self.get_file_string(PGConfig.PG_HBA_CONF_FILE) self.assertEqual(expected, result, "pg_hba_conf not processed") - mode = oct(os.stat(_ambari_server_.PG_HBA_CONF_FILE)[stat.ST_MODE]) + mode = oct(os.stat(PGConfig.PG_HBA_CONF_FILE)[stat.ST_MODE]) str_mode = str(mode)[-4:] self.assertEqual("0644", str_mode, "Wrong file permissions") + pass - @patch('__builtin__.raw_input') + @patch("__builtin__.raw_input") def test_get_choice_string_input(self, raw_input_method): prompt = "blablabla" default = "default blablabla" @@ -189,9 +205,9 @@ class TestAmbariServer(TestCase): pass - @patch('re.search') - @patch('__builtin__.raw_input') - @patch('getpass.getpass') + @patch("re.search") + @patch("__builtin__.raw_input") + @patch("getpass.getpass") def test_get_validated_string_input(self, get_pass_method, raw_input_method, re_search_method): prompt = "blabla" @@ -203,7 +219,7 @@ class TestAmbariServer(TestCase): is_pass = True get_pass_method.return_value = "dfdsfdsfds" - result = _ambari_server_.get_validated_string_input(prompt, default, + result = get_validated_string_input(prompt, default, pattern, description, is_pass) self.assertEquals(get_pass_method.return_value, result) @@ -216,22 +232,24 @@ class TestAmbariServer(TestCase): is_pass = False raw_input_method.return_value = "dkf90ewuf0" - result = _ambari_server_.get_validated_string_input(prompt, default, + result = get_validated_string_input(prompt, default, pattern, description, is_pass) self.assertEquals(raw_input_method.return_value, result) self.assertFalse(get_pass_method.called) raw_input_method.assure_called_once(prompt) + pass + @not_for_platform(PLATFORM_WINDOWS) def test_get_pass_file_path(self): - result = _ambari_server_.get_pass_file_path("/etc/ambari/conf_file") + result = get_pass_file_path("/etc/ambari/conf_file", JDBC_PASSWORD_FILENAME) self.assertEquals("/etc/ambari/password.dat", result) pass @patch.object(_ambari_server_, "setup_security") - @patch('optparse.OptionParser') + @patch("optparse.OptionParser") def test_main_test_setup_security(self, OptionParserMock, setup_security_method): opm = OptionParserMock.return_value @@ -248,6 +266,7 @@ class TestAmbariServer(TestCase): self.assertTrue(setup_security_method.called) self.assertFalse(False, get_verbose()) self.assertFalse(False, get_silent()) + pass @patch.object(_ambari_server_, "setup_ambari_krb5_jaas") @patch.object(_ambari_server_, "setup_master_key") @@ -276,13 +295,14 @@ class TestAmbariServer(TestCase): get_validated_string_input_mock.return_value = '4' _ambari_server_.setup_security(args) self.assertTrue(setup_ambari_krb5_jaas.called) + pass - @patch('re.sub') - @patch('fileinput.FileInput') + @patch("re.sub") + @patch("fileinput.FileInput") @patch.object(_ambari_server_, "get_validated_string_input") @patch.object(_ambari_server_, "search_file") - @patch('os.path.exists') + @patch("os.path.exists") def test_setup_ambari_krb5_jaas(self, exists_mock, search_mock, get_validated_string_input_mock, fileinput_mock, re_sub_mock): @@ -313,12 +333,13 @@ class TestAmbariServer(TestCase): self.assertTrue(re_sub_mock.called) self.assertTrue(re_sub_mock.call_args_list, [('a...@aaa.cnn'), ('pathtokeytab')]) + pass @patch.object(_ambari_server_, "setup") @patch.object(_ambari_server_, "start") @patch.object(_ambari_server_, "stop") @patch.object(_ambari_server_, "reset") - @patch('optparse.OptionParser') + @patch("optparse.OptionParser") def test_main_test_setup(self, OptionParserMock, reset_method, stop_method, start_method, setup_method): opm = OptionParserMock.return_value @@ -337,16 +358,17 @@ class TestAmbariServer(TestCase): self.assertFalse(False, get_verbose()) self.assertFalse(False, get_silent()) + pass @patch.object(_ambari_server_, "setup") @patch.object(_ambari_server_, "start") @patch.object(_ambari_server_, "stop") @patch.object(_ambari_server_, "reset") - @patch('optparse.OptionParser') - def test_main_test_start(self, OptionParserMock, reset_method, stop_method, + @patch("optparse.OptionParser") + def test_main_test_start(self, optionParserMock, reset_method, stop_method, start_method, setup_method): - opm = OptionParserMock.return_value + opm = optionParserMock.return_value options = MagicMock() args = ["setup"] opm.parse_args.return_value = (options, args) @@ -362,16 +384,17 @@ class TestAmbariServer(TestCase): self.assertFalse(False, get_verbose()) self.assertFalse(False, get_silent()) + pass @patch.object(_ambari_server_, "setup") @patch.object(_ambari_server_, "start") @patch.object(_ambari_server_, "stop") @patch.object(_ambari_server_, "reset") - @patch('optparse.OptionParser') - def test_main_test_start_debug_short(self, OptionParserMock, reset_method, stop_method, + @patch("optparse.OptionParser") + def test_main_test_start_debug_short(self, optionParserMock, reset_method, stop_method, start_method, setup_method): - opm = OptionParserMock.return_value + opm = optionParserMock.return_value options = MagicMock() args = ["start", "-g"] opm.parse_args.return_value = (options, args) @@ -387,16 +410,17 @@ class TestAmbariServer(TestCase): self.assertFalse(reset_method.called) self.assertTrue(get_debug_mode()) + pass @patch.object(_ambari_server_, "setup") @patch.object(_ambari_server_, "start") @patch.object(_ambari_server_, "stop") @patch.object(_ambari_server_, "reset") - @patch('optparse.OptionParser') - def test_main_test_start_debug_long(self, OptionParserMock, reset_method, stop_method, + @patch("optparse.OptionParser") + def test_main_test_start_debug_long(self, optionParserMock, reset_method, stop_method, start_method, setup_method): - opm = OptionParserMock.return_value + opm = optionParserMock.return_value options = MagicMock() args = ["start", "--debug"] opm.parse_args.return_value = (options, args) @@ -411,6 +435,7 @@ class TestAmbariServer(TestCase): self.assertFalse(reset_method.called) self.assertTrue(get_debug_mode()) + pass @patch.object(_ambari_server_, "setup") @patch.object(_ambari_server_, "start") @@ -418,10 +443,10 @@ class TestAmbariServer(TestCase): @patch.object(_ambari_server_, "reset") @patch.object(_ambari_server_, "backup") @patch.object(_ambari_server_, "restore") - @patch('optparse.OptionParser') - def test_main_test_backup(self, OptionParserMock, restore_mock, backup_mock, reset_method, stop_method, + @patch("optparse.OptionParser") + def test_main_test_backup(self, optionParserMock, restore_mock, backup_mock, reset_method, stop_method, start_method, setup_method): - opm = OptionParserMock.return_value + opm = optionParserMock.return_value options = MagicMock() args = ["backup"] opm.parse_args.return_value = (options, args) @@ -439,6 +464,7 @@ class TestAmbariServer(TestCase): self.assertFalse(False, get_verbose()) self.assertFalse(False, get_silent()) + pass @patch.object(_ambari_server_, "setup") @patch.object(_ambari_server_, "start") @@ -446,10 +472,10 @@ class TestAmbariServer(TestCase): @patch.object(_ambari_server_, "reset") @patch.object(_ambari_server_, "backup") @patch.object(_ambari_server_, "restore") - @patch('optparse.OptionParser') - def test_main_test_restore(self, OptionParserMock, restore_mock, backup_mock, reset_method, stop_method, + @patch("optparse.OptionParser") + def test_main_test_restore(self, optionParserMock, restore_mock, backup_mock, reset_method, stop_method, start_method, setup_method): - opm = OptionParserMock.return_value + opm = optionParserMock.return_value options = MagicMock() args = ["restore"] opm.parse_args.return_value = (options, args) @@ -467,15 +493,16 @@ class TestAmbariServer(TestCase): self.assertFalse(False, get_verbose()) self.assertFalse(False, get_silent()) + pass @patch.object(_ambari_server_, "setup") @patch.object(_ambari_server_, "start") @patch.object(_ambari_server_, "stop") @patch.object(_ambari_server_, "reset") - @patch('optparse.OptionParser') - def test_main_test_stop(self, OptionParserMock, reset_method, stop_method, + @patch("optparse.OptionParser") + def test_main_test_stop(self, optionParserMock, reset_method, stop_method, start_method, setup_method): - opm = OptionParserMock.return_value + opm = optionParserMock.return_value options = MagicMock() args = ["stop"] opm.parse_args.return_value = (options, args) @@ -492,16 +519,17 @@ class TestAmbariServer(TestCase): self.assertFalse(False, get_verbose()) self.assertFalse(False, get_silent()) + pass @patch.object(_ambari_server_, "setup") @patch.object(_ambari_server_, "start") @patch.object(_ambari_server_, "stop") @patch.object(_ambari_server_, "reset") - @patch('optparse.OptionParser') - def test_main_test_reset(self, OptionParserMock, reset_method, stop_method, + @patch("optparse.OptionParser") + def test_main_test_reset(self, optionParserMock, reset_method, stop_method, start_method, setup_method): - opm = OptionParserMock.return_value + opm = optionParserMock.return_value options = MagicMock() args = ["reset"] @@ -518,96 +546,124 @@ class TestAmbariServer(TestCase): self.assertFalse(False, get_verbose()) self.assertFalse(False, get_silent()) + pass + @not_for_platform(PLATFORM_WINDOWS) def test_configure_postgresql_conf(self): tf1 = tempfile.NamedTemporaryFile() - _ambari_server_.POSTGRESQL_CONF_FILE = tf1.name + PGConfig.POSTGRESQL_CONF_FILE = tf1.name - with open(_ambari_server_.POSTGRESQL_CONF_FILE, 'w') as f: + with open(PGConfig.POSTGRESQL_CONF_FILE, 'w') as f: f.write("#listen_addresses = '127.0.0.1' #\n") f.write("#listen_addresses = '127.0.0.1'") - _ambari_server_.configure_postgresql_conf() + PGConfig._configure_postgresql_conf() expected = self.get_file_string(self.get_samples_dir( "configure_postgresql_conf1")) - result = self.get_file_string(_ambari_server_.POSTGRESQL_CONF_FILE) + result = self.get_file_string(PGConfig.POSTGRESQL_CONF_FILE) self.assertEqual(expected, result, "postgresql.conf not updated") - mode = oct(os.stat(_ambari_server_.POSTGRESQL_CONF_FILE)[stat.ST_MODE]) + mode = oct(os.stat(PGConfig.POSTGRESQL_CONF_FILE)[stat.ST_MODE]) str_mode = str(mode)[-4:] self.assertEqual("0644", str_mode, "Wrong file permissions") + pass - @patch.object(_ambari_server_, "restart_postgres") - @patch.object(_ambari_server_, "get_postgre_status") - @patch.object(_ambari_server_, "configure_postgresql_conf") - @patch.object(_ambari_server_, "configure_pg_hba_ambaridb_users") - @patch.object(_ambari_server_, "configure_pg_hba_postgres_user") - def test_configure_postgres(self, configure_pg_hba_postgres_user_mock, - configure_pg_hba_ambaridb_users_mock, + @not_for_platform(PLATFORM_WINDOWS) + @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value)) + @patch.object(PGConfig, "_restart_postgres") + @patch.object(PGConfig, "_get_postgre_status") + @patch.object(PGConfig, "_configure_postgresql_conf") + @patch("ambari_server.dbConfiguration_linux.run_os_command") + def test_configure_postgres(self, + run_os_command_mock, configure_postgresql_conf_mock, get_postgre_status_mock, restart_postgres_mock): + args = MagicMock() + properties = Properties() + + args.database_index = 0 + + del args.dbms + del args.database_host + del args.database_port + del args.database_name + del args.database_username + del args.database_password + del args.silent + + factory = DBMSConfigFactory() + dbConfig = factory.create(args, properties) + + self.assertTrue(dbConfig.dbms, "postgres") + self.assertTrue(dbConfig.persistence_type, "local") + tf1 = tempfile.NamedTemporaryFile() tf2 = tempfile.NamedTemporaryFile() - _ambari_server_.PG_HBA_CONF_FILE = tf1.name - _ambari_server_.PG_HBA_CONF_FILE_BACKUP = tf2.name - args = MagicMock() + + PGConfig.PG_HBA_CONF_FILE = tf1.name + PGConfig.PG_HBA_CONF_FILE_BACKUP = tf2.name out = StringIO.StringIO() sys.stdout = out - retcode, out1, err = _ambari_server_.configure_postgres() + retcode, out1, err = dbConfig._configure_postgres() sys.stdout = sys.__stdout__ self.assertEqual(0, retcode) self.assertEqual("Backup for pg_hba found, reconfiguration not required\n", out.getvalue()) + tf2.close() - _ambari_server_.PG_HBA_CONF_FILE_BACKUP = tempfile.mktemp() - get_postgre_status_mock.return_value = _ambari_server_.PG_STATUS_RUNNING, 0, "", "" + get_postgre_status_mock.return_value = PGConfig.PG_STATUS_RUNNING, 0, "", "" + run_os_command_mock.return_value = 0, "", "" restart_postgres_mock.return_value = 0, "", "" - rcode, out, err = _ambari_server_.configure_postgres() + rcode, out, err = dbConfig._configure_postgres() - self.assertTrue(os.path.isfile(_ambari_server_.PG_HBA_CONF_FILE_BACKUP), + self.assertTrue(os.path.isfile(PGConfig.PG_HBA_CONF_FILE_BACKUP), "postgresql.conf backup not created") - self.assertTrue(configure_pg_hba_postgres_user_mock.called) - self.assertTrue(configure_pg_hba_ambaridb_users_mock.called) - mode = oct(os.stat(_ambari_server_.PG_HBA_CONF_FILE)[stat.ST_MODE]) + self.assertTrue(run_os_command_mock.called) + mode = oct(os.stat(PGConfig.PG_HBA_CONF_FILE)[stat.ST_MODE]) str_mode = str(mode)[-4:] self.assertEqual("0644", str_mode, "Wrong file permissions") self.assertTrue(configure_postgresql_conf_mock.called) self.assertEqual(0, rcode) - os.unlink(_ambari_server_.PG_HBA_CONF_FILE_BACKUP) + os.unlink(PGConfig.PG_HBA_CONF_FILE_BACKUP) + get_postgre_status_mock.return_value = "stopped", 0, "", "" - rcode, out, err = _ambari_server_.configure_postgres() + rcode, out, err = dbConfig._configure_postgres() self.assertEqual(0, rcode) - os.unlink(_ambari_server_.PG_HBA_CONF_FILE_BACKUP) + os.unlink(PGConfig.PG_HBA_CONF_FILE_BACKUP) sys.stdout = sys.__stdout__ + pass + @not_for_platform(PLATFORM_WINDOWS) @patch("time.sleep") @patch("subprocess.Popen") - @patch.object(_ambari_server_, "run_os_command") - @patch.object(_ambari_server_, "get_postgre_status") - @patch.object(_ambari_server_, "print_info_msg") + @patch("ambari_server.dbConfiguration_linux.run_os_command") + @patch.object(PGConfig, "_get_postgre_status") + @patch("ambari_server.dbConfiguration_linux.print_info_msg") def test_restart_postgres(self, printInfoMsg_mock, get_postgre_status_mock, run_os_command_mock, popenMock, sleepMock): p = MagicMock() p.poll.return_value = 0 popenMock.return_value = p - retcode, out, err = _ambari_server_.restart_postgres() + retcode, out, err = PGConfig._restart_postgres() self.assertEqual(0, retcode) p.poll.return_value = None get_postgre_status_mock.return_value = "stopped", 0, "", "" run_os_command_mock.return_value = (1, None, None) - retcode, out, err = _ambari_server_.restart_postgres() + retcode, out, err = PGConfig._restart_postgres() self.assertEqual(1, retcode) + pass + @not_for_platform(PLATFORM_WINDOWS) @patch("shlex.split") @patch("subprocess.Popen") @patch("ambari_commons.os_linux.print_info_msg") @@ -627,6 +683,29 @@ class TestAmbariServer(TestCase): resp = run_os_command("runme") self.assertEqual(3, resp[0]) self.assertTrue(splitMock.called) + pass + + @only_for_platform(PLATFORM_WINDOWS) + @patch("shlex.split") + @patch("subprocess.Popen") + @patch("ambari_commons.os_windows.print_info_msg") + def test_run_os_command(self, printInfoMsg_mock, popenMock, splitMock): + + p = MagicMock() + p.communicate.return_value = (None, None) + p.returncode = 3 + popenMock.return_value = p + + # with list arg + cmd = ["exec", "arg"] + run_os_command(cmd) + self.assertFalse(splitMock.called) + + # with str arg + resp = run_os_command("runme") + self.assertEqual(3, resp[0]) + self.assertTrue(splitMock.called) + pass @patch("ambari_server.serverConfiguration.get_conf_dir") @@ -640,116 +719,181 @@ class TestAmbariServer(TestCase): write_property("key1", "val1") result = tf1.read() self.assertTrue(expected_content in result) + pass - @patch.object(_ambari_server_, "configure_database_username_password") - @patch.object(_ambari_server_, "run_os_command") + @not_for_platform(PLATFORM_WINDOWS) + @patch("ambari_server.dbConfiguration.decrypt_password_for_alias") + @patch("ambari_server.dbConfiguration_linux.run_os_command") def test_setup_db(self, run_os_command_mock, - configure_database_username_password_mock): + decrypt_password_for_alias_mock): + args = MagicMock() + del args.database_index + del args.dbms + del args.database_host + del args.database_port + del args.database_name + del args.database_username + del args.database_password + + properties = Properties() + properties.process_pair(JDBC_PASSWORD_PROPERTY, get_alias_string("mypwdalias")) + + decrypt_password_for_alias_mock.return_value = "password" + dbms = PGConfig(args, properties, "local") + + self.assertTrue(decrypt_password_for_alias_mock.called) run_os_command_mock.return_value = (0, None, None) - result = _ambari_server_.setup_db(MagicMock()) - self.assertTrue(configure_database_username_password_mock.called) + result = dbms._setup_db() + self.assertTrue(run_os_command_mock.called) self.assertEqual((0, None, None), result) + pass - @patch.object(_ambari_server_, "configure_database_username_password") + @not_for_platform(PLATFORM_WINDOWS) + @patch("ambari_server.dbConfiguration.decrypt_password_for_alias") @patch("time.sleep") - @patch.object(_ambari_server_, "run_os_command") + @patch("ambari_server.dbConfiguration_linux.run_os_command") def test_setup_db_connect_attempts_fail(self, run_os_command_mock, - sleep_mock, config_db_mock): + sleep_mock, decrypt_password_for_alias_mock): + args = MagicMock() + del args.database_index + del args.dbms + del args.database_host + del args.database_port + del args.database_name + del args.database_username + del args.database_password + + properties = Properties() + + decrypt_password_for_alias_mock.return_value = "password" + dbms = PGConfig(args, properties, "local") + run_os_command_mock.side_effect = [(1, "error", "error"), (1, "error", "error"), (1, "error", "error")] - result = _ambari_server_.setup_db(MagicMock()) + result = dbms._setup_db() self.assertTrue(run_os_command_mock.called) self.assertEqual((1, 'error', 'error') , result) self.assertEqual(2, sleep_mock.call_count) pass - @patch.object(_ambari_server_, "configure_database_username_password") + @not_for_platform(PLATFORM_WINDOWS) + @patch("ambari_server.dbConfiguration.decrypt_password_for_alias") @patch("time.sleep") - @patch.object(_ambari_server_, "run_os_command") + @patch("ambari_server.dbConfiguration_linux.run_os_command") def test_setup_db_connect_attempts_success(self, run_os_command_mock, - sleep_mock, config_db_mock): + sleep_mock, decrypt_password_for_alias_mock): + args = MagicMock() + del args.database_index + del args.dbms + del args.database_host + del args.database_port + del args.database_name + del args.database_username + del args.database_password + + properties = Properties() + + decrypt_password_for_alias_mock.return_value = "password" + dbms = PGConfig(args, properties, "local") + run_os_command_mock.side_effect = [(1, "error", "error"), (0, None, None), (0, None, None)] - result = _ambari_server_.setup_db(MagicMock()) + result = dbms._setup_db() self.assertTrue(run_os_command_mock.called) self.assertEqual((0, None, None) , result) self.assertEqual(1, sleep_mock.call_count) pass - @patch.object(_ambari_server_, "get_YN_input") - @patch.object(_ambari_server_, "run_os_command") + @not_for_platform(PLATFORM_WINDOWS) + @patch("ambari_server.serverSetup.get_YN_input") + @patch("ambari_server.serverSetup.run_os_command") def test_check_selinux(self, run_os_command_mock, getYNInput_mock): - run_os_command_mock.return_value = (0, _ambari_server_.SE_STATUS_DISABLED, + run_os_command_mock.return_value = (0, SE_STATUS_DISABLED, None) - rcode = _ambari_server_.check_selinux() + rcode = check_selinux() self.assertEqual(0, rcode) getYNInput_mock.return_value = True run_os_command_mock.return_value = (0, "enabled " - + _ambari_server_.SE_MODE_ENFORCING, + + SE_MODE_ENFORCING, None) - rcode = _ambari_server_.check_selinux() + rcode = check_selinux() self.assertEqual(0, rcode) self.assertTrue(run_os_command_mock.called) self.assertTrue(getYNInput_mock.called) - @patch.object(_ambari_server_, "print_info_msg") + @not_for_platform(PLATFORM_WINDOWS) + @patch("ambari_server.serverConfiguration.print_info_msg") def test_get_ambari_jars(self, printInfoMsg_mock): env = "/ambari/jars" - os.environ[_ambari_server_.AMBARI_SERVER_LIB] = env - result = _ambari_server_.get_ambari_jars() + os.environ[AMBARI_SERVER_LIB] = env + result = get_ambari_jars() self.assertEqual(env, result) - del os.environ[_ambari_server_.AMBARI_SERVER_LIB] - result = _ambari_server_.get_ambari_jars() + del os.environ[AMBARI_SERVER_LIB] + result = get_ambari_jars() self.assertEqual("/usr/lib/ambari-server", result) self.assertTrue(printInfoMsg_mock.called) + @only_for_platform(PLATFORM_WINDOWS) + @patch("ambari_server.serverConfiguration.print_info_msg") + def test_get_ambari_jars(self, printInfoMsg_mock): + + env = "/ambari/jars" + os.environ[AMBARI_SERVER_LIB] = env + result = get_ambari_jars() + self.assertEqual(env, result) + + del os.environ[AMBARI_SERVER_LIB] + result = get_ambari_jars() + self.assertEqual("libs", result) + self.assertTrue(printInfoMsg_mock.called) + @patch("glob.glob") - @patch.object(_ambari_server_, "print_info_msg") + @patch("ambari_server.serverConfiguration.print_info_msg") def test_get_share_jars(self, printInfoMsg_mock, globMock): globMock.return_value = ["one", "two"] expected = "one:two:one:two" - result = _ambari_server_.get_share_jars() + result = get_share_jars() self.assertEqual(expected, result) globMock.return_value = [] expected = "" - result = _ambari_server_.get_share_jars() + result = get_share_jars() self.assertEqual(expected, result) @patch("glob.glob") - @patch.object(_ambari_server_, "print_info_msg") - def test_get_ambari_classpath(self, printInfoMsg_mock, globMock): + @patch("ambari_server.serverConfiguration.print_info_msg") + @patch("ambari_server.serverConfiguration.get_ambari_properties") + def test_get_ambari_classpath(self, get_ambari_properties_mock, printInfoMsg_mock, globMock): globMock.return_value = ["one"] - result = _ambari_server_.get_ambari_classpath() - self.assertTrue(_ambari_server_.get_ambari_jars() in result) - self.assertTrue(_ambari_server_.get_share_jars() in result) + result = get_ambari_classpath() + self.assertTrue(get_ambari_jars() in result) + self.assertTrue(get_share_jars() in result) globMock.return_value = [] - result = _ambari_server_.get_ambari_classpath() - self.assertTrue(_ambari_server_.get_ambari_jars() in result) + result = get_ambari_classpath() + self.assertTrue(get_ambari_jars() in result) self.assertFalse(":" in result) - @patch.object(_ambari_server_, "print_info_msg") + @patch("ambari_server.serverConfiguration.print_info_msg") def test_get_conf_dir(self, printInfoMsg_mock): env = "/dummy/ambari/conf" - os.environ[_ambari_server_.AMBARI_CONF_VAR] = env - result = _ambari_server_.get_conf_dir() + os.environ[AMBARI_CONF_VAR] = env + result = get_conf_dir() self.assertEqual(env, result) - del os.environ[_ambari_server_.AMBARI_CONF_VAR] - result = _ambari_server_.get_conf_dir() + del os.environ[AMBARI_CONF_VAR] + result = get_conf_dir() self.assertEqual("/etc/ambari-server/conf", result) def test_search_file(self): - path = os.path.dirname(__file__) result = search_file(__file__, path) expected = os.path.abspath(__file__) @@ -795,20 +939,20 @@ class TestAmbariServer(TestCase): @patch("os.path.exists") - @patch.object(_ambari_server_, "set_file_permissions") - @patch.object(_ambari_server_, "run_os_command") - @patch.object(_ambari_server_, "get_ambari_properties") - @patch.object(_ambari_server_, "get_value_from_properties") + @patch("ambari_server.setupSecurity.set_file_permissions") + @patch("ambari_server.setupSecurity.get_ambari_properties") + @patch("ambari_server.setupSecurity.get_value_from_properties") @patch("os.mkdir") - def test_adjust_directory_permissions(self, mkdir_mock, + @patch("shutil.rmtree") + def test_adjust_directory_permissions(self, rmtree_mock, mkdir_mock, get_value_from_properties_mock, get_ambari_properties_mock, - run_os_command_mock, set_file_permissions_mock, exists_mock): + set_file_permissions_mock, exists_mock): # Testing boostrap dir wipe properties_mock = MagicMock() get_value_from_properties_mock.return_value = "dummy_bootstrap_dir" - _ambari_server_.adjust_directory_permissions("user") exists_mock.return_value = False - self.assertEquals(run_os_command_mock.call_args_list[0][0][0], "rm -rf dummy_bootstrap_dir") + adjust_directory_permissions("user") + self.assertEquals(rmtree_mock.call_args_list[0][0][0], os.path.join(os.getcwd(), "dummy_bootstrap_dir")) self.assertTrue(mkdir_mock.called) set_file_permissions_mock.reset_mock() @@ -821,7 +965,7 @@ class TestAmbariServer(TestCase): ( "/etc/ambari-server/conf/ambari.properties", "644", "{0}", False ) ] - _ambari_server_.adjust_directory_permissions("user") + adjust_directory_permissions("user") self.assertTrue(len(set_file_permissions_mock.call_args_list) == len(configDefaults.NR_ADJUST_OWNERSHIP_LIST)) self.assertEquals(set_file_permissions_mock.call_args_list[0][0][3], True) @@ -830,16 +974,17 @@ class TestAmbariServer(TestCase): configDefaults.NR_ADJUST_OWNERSHIP_LIST = old_list + @not_for_platform(PLATFORM_WINDOWS) @patch("os.path.exists") - @patch.object(_ambari_server_, "run_os_command") - @patch.object(_ambari_server_, "print_warning_msg") - @patch.object(_ambari_server_, "print_info_msg") + @patch("ambari_commons.os_linux.os_run_os_command") + @patch("ambari_commons.os_linux.print_warning_msg") + @patch("ambari_commons.os_utils.print_info_msg") def test_set_file_permissions(self, print_info_msg_mock, print_warning_msg_mock, run_os_command_mock, exists_mock): # Testing not existent file scenario exists_mock.return_value = False - _ambari_server_.set_file_permissions("dummy-file", "dummy-mod", + set_file_permissions("dummy-file", "dummy-mod", "dummy-user", False) self.assertFalse(run_os_command_mock.called) self.assertTrue(print_info_msg_mock.called) @@ -850,7 +995,7 @@ class TestAmbariServer(TestCase): # Testing OK scenario exists_mock.return_value = True run_os_command_mock.side_effect = [(0, "", ""), (0, "", "")] - _ambari_server_.set_file_permissions("dummy-file", "dummy-mod", + set_file_permissions("dummy-file", "dummy-mod", "dummy-user", False) self.assertTrue(len(run_os_command_mock.call_args_list) == 2) self.assertFalse(print_warning_msg_mock.called) @@ -860,7 +1005,7 @@ class TestAmbariServer(TestCase): # Testing first command fail run_os_command_mock.side_effect = [(1, "", ""), (0, "", "")] - _ambari_server_.set_file_permissions("dummy-file", "dummy-mod", + set_file_permissions("dummy-file", "dummy-mod", "dummy-user", False) self.assertTrue(len(run_os_command_mock.call_args_list) == 2) self.assertTrue(print_warning_msg_mock.called) @@ -870,7 +1015,7 @@ class TestAmbariServer(TestCase): # Testing second command fail run_os_command_mock.side_effect = [(0, "", ""), (1, "", "")] - _ambari_server_.set_file_permissions("dummy-file", "dummy-mod", + set_file_permissions("dummy-file", "dummy-mod", "dummy-user", False) self.assertTrue(len(run_os_command_mock.call_args_list) == 2) self.assertTrue(print_warning_msg_mock.called) @@ -882,7 +1027,7 @@ class TestAmbariServer(TestCase): exists_mock.return_value = True run_os_command_mock.side_effect = [(0, "", ""), (0, "", "")] - _ambari_server_.set_file_permissions("dummy-file", "dummy-mod", + set_file_permissions("dummy-file", "dummy-mod", "dummy-user", True) self.assertTrue(len(run_os_command_mock.call_args_list) == 2) self.assertTrue("-R" in run_os_command_mock.call_args_list[0][0][0]) @@ -896,7 +1041,7 @@ class TestAmbariServer(TestCase): exists_mock.return_value = True run_os_command_mock.side_effect = [(0, "", ""), (0, "", "")] - _ambari_server_.set_file_permissions("dummy-file", "dummy-mod", + set_file_permissions("dummy-file", "dummy-mod", "dummy-user", False) self.assertTrue(len(run_os_command_mock.call_args_list) == 2) self.assertFalse("-R" in run_os_command_mock.call_args_list[0][0][0]) @@ -907,18 +1052,21 @@ class TestAmbariServer(TestCase): print_warning_msg_mock.reset_mock() - @patch.object(_ambari_server_, "get_validated_string_input") - @patch.object(_ambari_server_, "print_info_msg") - @patch.object(_ambari_server_, "print_warning_msg") - @patch.object(_ambari_server_, "run_os_command") + @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value)) + @patch("ambari_server.serverSetup.get_validated_string_input") + @patch("ambari_server.serverSetup.print_info_msg") + @patch("ambari_server.serverSetup.print_warning_msg") + @patch("ambari_server.serverSetup.run_os_command") def test_create_custom_user(self, run_os_command_mock, print_warning_msg_mock, print_info_msg_mock, get_validated_string_input_mock): user = "dummy-user" get_validated_string_input_mock.return_value = user + userChecks = AmbariUserChecks() + # Testing scenario: absent user run_os_command_mock.side_effect = [(0, "", "")] - result = _ambari_server_.create_custom_user() + result = userChecks._create_custom_user() self.assertFalse(print_warning_msg_mock.called) self.assertEquals(result, (0, user)) @@ -928,7 +1076,7 @@ class TestAmbariServer(TestCase): # Testing scenario: existing user run_os_command_mock.side_effect = [(9, "", "")] - result = _ambari_server_.create_custom_user() + result = userChecks._create_custom_user() self.assertTrue("User dummy-user already exists" in str(print_info_msg_mock.call_args_list[1][0])) self.assertEquals(result, (0, user)) @@ -938,28 +1086,30 @@ class TestAmbariServer(TestCase): # Testing scenario: os command fail run_os_command_mock.side_effect = [(1, "", "")] - result = _ambari_server_.create_custom_user() + result = userChecks._create_custom_user() self.assertTrue(print_warning_msg_mock.called) self.assertEquals(result, (1, None)) - @patch.object(_ambari_server_, "read_ambari_user") - @patch.object(_ambari_server_, "get_YN_input") - @patch.object(_ambari_server_, "create_custom_user") - @patch.object(_ambari_server_, "write_property") - @patch.object(_ambari_server_, "adjust_directory_permissions") - @patch.object(_ambari_server_, "print_error_msg") + @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value)) + @patch("ambari_server.serverSetup.read_ambari_user") + @patch("ambari_server.serverSetup.get_YN_input") + @patch.object(AmbariUserChecksLinux, "_create_custom_user") + @patch.object(AmbariUserChecksWindows, "_create_custom_user") + @patch("ambari_server.serverSetup.write_property") + @patch("ambari_server.serverSetup.adjust_directory_permissions") + @patch("ambari_server.serverSetup.print_error_msg") def test_check_ambari_user(self, print_error_msg_mock, adjust_directory_permissions_mock, write_property_mock, - create_custom_user_mock, get_YN_input_mock, read_ambari_user_mock): + create_custom_user_mock, create_custom_user_2_mock, get_YN_input_mock, read_ambari_user_mock): # Scenario: user is already defined, user does not want to reconfigure it read_ambari_user_mock.return_value = "dummy-user" get_YN_input_mock.return_value = False - result = _ambari_server_.check_ambari_user() + result = check_ambari_user() self.assertTrue(get_YN_input_mock.called) self.assertFalse(write_property_mock.called) - self.assertFalse(create_custom_user_mock.called) + self.assertFalse(create_custom_user_mock.called or create_custom_user_2_mock.called) self.assertTrue(adjust_directory_permissions_mock.called) self.assertEqual(result, 0) @@ -967,17 +1117,18 @@ class TestAmbariServer(TestCase): write_property_mock.reset_mock() adjust_directory_permissions_mock.reset_mock() create_custom_user_mock.reset_mock() + create_custom_user_2_mock.reset_mock() # Scenario: user is already defined, but user wants to reconfigure it read_ambari_user_mock.return_value = "dummy-user" - create_custom_user_mock.return_value = (0, "new-dummy-user") + create_custom_user_2_mock.return_value = create_custom_user_mock.return_value = (0, "new-dummy-user") get_YN_input_mock.return_value = True - result = _ambari_server_.check_ambari_user() + result = check_ambari_user() self.assertTrue(get_YN_input_mock.called) self.assertTrue(write_property_mock.called) self.assertTrue(write_property_mock.call_args[0][1] == "new-dummy-user") - self.assertTrue(create_custom_user_mock.called) + self.assertTrue(create_custom_user_mock.called or create_custom_user_2_mock.called) self.assertTrue(adjust_directory_permissions_mock.called) self.assertEqual(result, 0) @@ -985,32 +1136,34 @@ class TestAmbariServer(TestCase): write_property_mock.reset_mock() adjust_directory_permissions_mock.reset_mock() create_custom_user_mock.reset_mock() + create_custom_user_2_mock.reset_mock() # Negative scenario: user is already defined, but user wants # to reconfigure it, user creation failed read_ambari_user_mock.return_value = "dummy-user" - create_custom_user_mock.return_value = (1, None) + create_custom_user_2_mock.return_value = create_custom_user_mock.return_value = (1, None) get_YN_input_mock.return_value = True - result = _ambari_server_.check_ambari_user() + result = check_ambari_user() self.assertTrue(get_YN_input_mock.called) - self.assertTrue(create_custom_user_mock.called) + self.assertTrue(create_custom_user_mock.called or create_custom_user_2_mock.called) self.assertFalse(write_property_mock.called) self.assertFalse(adjust_directory_permissions_mock.called) self.assertEqual(result, 1) get_YN_input_mock.reset_mock() create_custom_user_mock.reset_mock() + create_custom_user_2_mock.reset_mock() write_property_mock.reset_mock() adjust_directory_permissions_mock.reset_mock() # Scenario: user is not defined (setup process) read_ambari_user_mock.return_value = None get_YN_input_mock.return_value = True - create_custom_user_mock.return_value = (0, "dummy-user") - result = _ambari_server_.check_ambari_user() + create_custom_user_2_mock.return_value = create_custom_user_mock.return_value = (0, "dummy-user") + result = check_ambari_user() self.assertTrue(get_YN_input_mock.called) - self.assertTrue(create_custom_user_mock.called) + self.assertTrue(create_custom_user_mock.called or create_custom_user_2_mock.called) self.assertTrue(write_property_mock.called) self.assertTrue(write_property_mock.call_args[0][1] == "dummy-user") self.assertTrue(adjust_directory_permissions_mock.called) @@ -1018,6 +1171,7 @@ class TestAmbariServer(TestCase): get_YN_input_mock.reset_mock() create_custom_user_mock.reset_mock() + create_custom_user_2_mock.reset_mock() write_property_mock.reset_mock() adjust_directory_permissions_mock.reset_mock() @@ -1025,16 +1179,17 @@ class TestAmbariServer(TestCase): read_ambari_user_mock.return_value = None get_YN_input_mock.return_value = True - create_custom_user_mock.return_value = (1, None) - result = _ambari_server_.check_ambari_user() + create_custom_user_2_mock.return_value = create_custom_user_mock.return_value = (1, None) + result = check_ambari_user() self.assertTrue(get_YN_input_mock.called) - self.assertTrue(create_custom_user_mock.called) + self.assertTrue(create_custom_user_mock.called or create_custom_user_2_mock.called) self.assertFalse(write_property_mock.called) self.assertFalse(adjust_directory_permissions_mock.called) self.assertEqual(result, 1) get_YN_input_mock.reset_mock() create_custom_user_mock.reset_mock() + create_custom_user_2_mock.reset_mock() write_property_mock.reset_mock() adjust_directory_permissions_mock.reset_mock() @@ -1042,40 +1197,41 @@ class TestAmbariServer(TestCase): read_ambari_user_mock.return_value = None get_YN_input_mock.return_value = True - create_custom_user_mock.return_value = (1, None) - result = _ambari_server_.check_ambari_user() + create_custom_user_2_mock.return_value = create_custom_user_mock.return_value = (1, None) + result = check_ambari_user() self.assertTrue(get_YN_input_mock.called) - self.assertTrue(create_custom_user_mock.called) + self.assertTrue(create_custom_user_mock.called or create_custom_user_2_mock.called) self.assertFalse(write_property_mock.called) self.assertFalse(adjust_directory_permissions_mock.called) self.assertEqual(result, 1) get_YN_input_mock.reset_mock() create_custom_user_mock.reset_mock() + create_custom_user_2_mock.reset_mock() write_property_mock.reset_mock() adjust_directory_permissions_mock.reset_mock() # Scenario: user is not defined and left to be root read_ambari_user_mock.return_value = None get_YN_input_mock.return_value = False - result = _ambari_server_.check_ambari_user() + result = check_ambari_user() self.assertTrue(get_YN_input_mock.called) - self.assertFalse(create_custom_user_mock.called) + self.assertFalse(create_custom_user_mock.called or create_custom_user_2_mock.called) self.assertTrue(write_property_mock.called) self.assertTrue(write_property_mock.call_args[0][1] == "root") self.assertTrue(adjust_directory_permissions_mock.called) self.assertEqual(result, 0) - @patch.object(_ambari_server_, "search_file") + @patch("ambari_server.serverConfiguration.search_file") @patch("__builtin__.open") - @patch.object(_ambari_server_, "read_ambari_user") - @patch.object(_ambari_server_, "set_file_permissions") + @patch("ambari_server.setupSecurity.read_ambari_user") + @patch("ambari_server.setupSecurity.set_file_permissions") def test_store_password_file(self, set_file_permissions_mock, read_ambari_user_mock, open_mock, search_file_mock): search_file_mock.return_value = "/etc/ambari-server/conf/ambari.properties" open_mock.return_value = MagicMock() - _ambari_server_.store_password_file("password", "passfile") + store_password_file("password", "passfile") self.assertTrue(set_file_permissions_mock.called) @patch("subprocess.Popen") @@ -1140,99 +1296,6 @@ class TestAmbariServer(TestCase): self.assertFalse(firewall_obj.check_iptables()) self.assertEqual("err", firewall_obj.stderrdata) - - def test_dlprogress(self): - - out = StringIO.StringIO() - sys.stdout = out - _ambari_server_.dlprogress("filename", 10, 2, 100) - sys.stdout = sys.__stdout__ - self.assertNotEqual("", out.getvalue()) - - - @patch("urllib2.urlopen") - @patch("__builtin__.open") - @patch.object(_ambari_server_, "dlprogress") - def test_track_jdk(self, dlprogress_mock, openMock, urlopenMock): - - u = MagicMock() - u.info.return_value = {"Content-Length": "24576"} - chunks = [None, "second", "first"] - - def side_effect(*args, **kwargs): - return chunks.pop() - - u.read.side_effect = side_effect - urlopenMock.return_value = u - - f = MagicMock() - openMock.return_value = f - - _ambari_server_.track_jdk("base", "url", "local") - - self.assertEqual(0, len(chunks)) - self.assertTrue(f.write.called) - self.assertTrue(f.flush.called) - self.assertTrue(f.close.called) - self.assertEqual(2, len(dlprogress_mock.call_args_list)) - - @patch("shutil.copy") - @patch("os.path.join") - @patch("os.path.exists") - @patch("os.path.isdir") - @patch.object(_ambari_server_, "get_ambari_properties") - def test_install_jce_manualy(self, get_ambari_properties_mock, \ - os_path_isdir_mock, os_path_exists_mock, os_path_join_mock, \ - shutil_copy_mock): - args = MagicMock() - args.jce_policy = "somewhere" - p = MagicMock() - get_ambari_properties_mock.return_value = p - p.__getitem__.side_effect = None - p.__getitem__.return_value = "somewhere" - - # Case when JCE path doesn't exists - os_path_exists_mock.return_value = False - try: - _ambari_server_.install_jce_manualy(args) - self.fail("Should throw exception") - except FatalException as fe: - # Expected - self.assertTrue("JCE Policy path" in fe.reason) - pass - os_path_exists_mock.reset() - - # Case when JCE is a directory - os_path_exists_mock.return_value = True - os_path_isdir_mock.return_value = True - try: - _ambari_server_.install_jce_manualy(args) - self.fail("Should throw exception") - except FatalException as fe: - # Expected - self.assertTrue("JCE Policy path is a directory" in fe.reason) - pass - os_path_isdir_mock.reset() - - os_path_isdir_mock.return_value = False - os_path_join_mock.return_value = \ - "/var/lib/ambari-server/resources/jce_policy-6.zip" - _ambari_server_.install_jce_manualy(args) - self.assertTrue(shutil_copy_mock.called) - - shutil_copy_mock.side_effect = Exception("exception") - try: - _ambari_server_.install_jce_manualy(args) - self.fail("Should throw exception because of not found jce_policy-6.zip") - except Exception: - # Expected - self.assertTrue(shutil_copy_mock.called) - pass - - shutil_copy_mock.side_effect = None - args.jce_policy = None - _ambari_server_.install_jce_manualy(args) - @patch.object(_ambari_server_, "get_validated_filepath_input") @patch.object(_ambari_server_, "run_os_command") @patch.object(_ambari_server_, "get_truststore_type") @@ -1544,7 +1607,7 @@ class TestAmbariServer(TestCase): @patch.object(_ambari_server_, "run_os_command") @patch("os.path.join") @patch("os.path.isfile") - @patch('__builtin__.raw_input') + @patch("__builtin__.raw_input") @patch.object(_ambari_server_, "get_validated_string_input") @patch.object(_ambari_server_, "is_valid_cert_host") @patch.object(_ambari_server_, "is_valid_cert_exp") @@ -1792,7 +1855,7 @@ class TestAmbariServer(TestCase): self.assertEqual(fqdn, host) - @patch.object(_ambari_server_, "find_properties_file") + @patch("ambari_server.serverConfiguration.find_properties_file") def test_get_ulimit_open_files(self, find_properties_file_mock): # 1 - No ambari.properties @@ -1868,7 +1931,7 @@ MIIFHjCCAwYCCQDpHKOBI+Lt0zANBgkqhkiG9w0BAQUFADBRMQswCQYDVQQGEwJV self.assertEqual(cert_info[attr3_key], attr3_value) - @patch('__builtin__.raw_input') + @patch("__builtin__.raw_input") def test_get_validated_string_input(self, raw_input_mock): prompt = 'prompt' default_value = 'default' @@ -1878,19 +1941,19 @@ MIIFHjCCAwYCCQDpHKOBI+Lt0zANBgkqhkiG9w0BAQUFADBRMQswCQYDVQQGEwJV inputed_value1 = 'val1' inputed_value2 = 'val2' raw_input_mock.return_value = inputed_value1 - input = _ambari_server_.get_validated_string_input(prompt, default_value, None, + input = get_validated_string_input(prompt, default_value, None, description, False, False, validator) self.assertTrue(validator.called) self.assertEqual(inputed_value1, input) validator.side_effect = [False, True] raw_input_mock.side_effect = [inputed_value1, inputed_value2] - input = _ambari_server_.get_validated_string_input(prompt, default_value, None, + input = get_validated_string_input(prompt, default_value, None, description, False, False, validator) self.assertEqual(inputed_value2, input) - @patch.object(_ambari_server_, "run_os_command") + @patch("ambari_server.serverSetup.run_os_command") @patch("__builtin__.open") @patch("os.path.exists") def test_is_server_runing(self, os_path_exists_mock, open_mock, \ @@ -1899,15 +1962,15 @@ MIIFHjCCAwYCCQDpHKOBI+Lt0zANBgkqhkiG9w0BAQUFADBRMQswCQYDVQQGEwJV f = open_mock.return_value f.readline.return_value = "111" run_os_command_mock.return_value = 0, "", "" - status, pid = _ambari_server_.is_server_runing() + status, pid = is_server_runing() self.assertTrue(status) self.assertEqual(111, pid) os_path_exists_mock.return_value = False - status, pid = _ambari_server_.is_server_runing() + status, pid = is_server_runing() self.assertFalse(status) - @patch.object(_ambari_server_, "run_os_command") + @patch("ambari_server.serverSetup.run_os_command") @patch("__builtin__.open") @patch("os.path.exists") def test_is_server_runing_bad_file(self, os_path_exists_mock, open_mock, \ @@ -1916,144 +1979,162 @@ MIIFHjCCAwYCCQDpHKOBI+Lt0zANBgkqhkiG9w0BAQUFADBRMQswCQYDVQQGEwJV f = open_mock.return_value f.readline.return_value = "" # empty file content run_os_command_mock.return_value = 0, "", "" - self.assertRaises(NonFatalException, _ambari_server_.is_server_runing) + self.assertRaises(NonFatalException, is_server_runing) open_mock.side_effect = IOError('[Errno 13] Permission denied: /var/run/ambari-server/ambari-server.pid') - self.assertRaises(FatalException, _ambari_server_.is_server_runing) + self.assertRaises(FatalException, is_server_runing) + @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value)) + @patch("os.path.exists") + @patch("os.makedirs") @patch("os.chdir") - @patch.object(_ambari_server_, "run_os_command") - def test_install_jdk(self, run_os_command_mock, os_chdir_mock): + @patch("ambari_server.serverSetup.run_os_command") + def test_install_jdk(self, run_os_command_mock, os_chdir_mock, os_makedirs_mock, os_path_exists_mock): run_os_command_mock.return_value = 1, "", "" + os_path_exists_mock.return_value = False failed = False try: - _ambari_server_.install_jdk(MagicMock()) + jdkSetup = JDKSetup() + jdkSetup._install_jdk(MagicMock(), MagicMock()) self.fail("Exception was not rised!") except FatalException: failed = True self.assertTrue(failed) + @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value)) @patch("os.stat") @patch("os.path.isfile") @patch("os.path.exists") - @patch.object(_ambari_server_, "track_jdk") - @patch.object(_ambari_server_, "get_YN_input") - @patch.object(_ambari_server_, "run_os_command") - @patch.object(_ambari_server_, "write_property") - @patch.object(_ambari_server_, "remove_property") - @patch.object(_ambari_server_, "get_validated_string_input") - @patch.object(_ambari_server_, "print_info_msg") - @patch.object(_ambari_server_, "get_JAVA_HOME") - @patch.object(_ambari_server_, "get_ambari_properties") + @patch("os.chdir") + @patch("ambari_server.serverSetup.force_download_file") + @patch("ambari_server.serverSetup.get_YN_input") + @patch("ambari_server.serverSetup.run_os_command") + @patch("ambari_server.serverSetup.update_properties") + @patch("ambari_server.serverSetup.get_validated_string_input") + @patch("ambari_server.serverSetup.print_info_msg") + @patch("ambari_server.serverSetup.validate_jdk") + @patch("ambari_server.serverSetup.get_JAVA_HOME") + @patch("ambari_server.serverSetup.get_ambari_properties") @patch("shutil.copyfile") @patch("sys.exit") def test_download_jdk(self, exit_mock, copyfile_mock, get_ambari_properties_mock, get_JAVA_HOME_mock, \ - print_info_msg_mock, get_validated_string_input_mock, remove_property_mock, write_property_mock, \ - run_os_command_mock, get_YN_input_mock, track_jdk_mock, - path_existsMock, path_isfileMock, statMock): + validate_jdk_mock, print_info_msg_mock, get_validated_string_input_mock, update_properties_mock, \ + run_os_command_mock, get_YN_input_mock, force_download_file_mock, + os_chdir_mock, path_existsMock, path_isfileMock, statMock): args = MagicMock() args.java_home = "somewhere" + args.silent = False + + p = Properties() + p.process_pair("java.releases", "jdk1") + p.process_pair("jdk1.desc", "JDK name") + p.process_pair("jdk1.url", "http://somewhere/somewhere.tar.gz") + p.process_pair("jdk1.dest-file", "somewhere.tar.gz") + p.process_pair("jdk1.jcpol-url", "http://somewhere/some-jcpol.tar.gz") + p.process_pair("jdk1.jcpol-file", "some-jcpol.tar.gz") + p.process_pair("jdk1.home", "/jdk1") + p.process_pair("jdk1.re", "(jdk.*)/jre") + + validate_jdk_mock.return_value = False path_existsMock.return_value = False get_JAVA_HOME_mock.return_value = False - get_ambari_properties_mock.return_value = -1 + get_ambari_properties_mock.return_value = p # Test case: ambari.properties not found try: - _ambari_server_.download_jdk(args) + download_and_install_jdk(args) self.fail("Should throw exception because of not found ambari.properties") except FatalException: # Expected self.assertTrue(get_ambari_properties_mock.called) pass + # Test case: JDK already exists - p = MagicMock() args.java_home = None args.jdk_location = None - get_ambari_properties_mock.return_value = p - p.__getitem__.return_value = "somewhere" - get_JAVA_HOME_mock.return_value = True + get_JAVA_HOME_mock.return_value = "some_jdk" + validate_jdk_mock.return_value = True get_YN_input_mock.return_value = False - path_existsMock.side_effect = [False,False] - rcode = _ambari_server_.download_jdk(args) + path_existsMock.return_value = False + run_os_command_mock.return_value = 0, "", "" + rcode = download_and_install_jdk(args) self.assertEqual(0, rcode) + # Test case: java home setup args.java_home = "somewhere" - path_existsMock.side_effect = [True,False,False] - get_JAVA_HOME_mock.return_value = False - rcode = _ambari_server_.download_jdk(args) + validate_jdk_mock.return_value = True + path_existsMock.return_value = False + get_JAVA_HOME_mock.return_value = None + rcode = download_and_install_jdk(args) self.assertEqual(0, rcode) - self.assertTrue(write_property_mock.called) - self.assertTrue(remove_property_mock.call_count == 2) + self.assertTrue(update_properties_mock.called) + # Test case: JDK file does not exist, property not defined - path_existsMock.side_effect = None + validate_jdk_mock.return_value = False path_existsMock.return_value = False - p = MagicMock() get_ambari_properties_mock.return_value = p - p.__getitem__.side_effect = KeyError("test exception") + p.removeProp("jdk1.url") try: - _ambari_server_.download_jdk(args) + download_and_install_jdk(args) self.fail("Should throw exception") except FatalException: # Expected pass - # Test case: JDK file does not exist, os command (curl) result does not + + # Test case: JDK file does not exist, HTTP response does not # contain Content-Length - p.__getitem__.return_value = "somewhere" - p.__getitem__.side_effect = None + p.process_pair("jdk1.url", "http://somewhere/somewhere.tar.gz") + validate_jdk_mock.return_value = False path_existsMock.return_value = False get_YN_input_mock.return_value = True get_validated_string_input_mock.return_value = "1" run_os_command_mock.return_value = (0, "Wrong out", None) try: - _ambari_server_.download_jdk(args) + download_and_install_jdk(args) self.fail("Should throw exception") except FatalException: # Expected pass - # Successful JDK download + + # Successful JDK download args.java_home = None + validate_jdk_mock.return_value = False path_isfileMock.return_value = False args.jdk_location = None - configDefaults.JDK_INSTALL_DIR = os.getcwd() - run_os_command_mock.return_value = (0, "Creating jdk-1.2/jre" - "Content-Length: 32000\r\n" - , None) + run_os_command_mock.return_value = (0, "Creating jdk1/jre" , None) statResult = MagicMock() statResult.st_size = 32000 statMock.return_value = statResult - rcode = _ambari_server_.download_jdk(args) + rcode = download_and_install_jdk(args) self.assertEqual(0, rcode) # Test case: not accept the license" - p.__getitem__.return_value = "somewhere" - p.__getitem__.side_effect = None get_YN_input_mock.return_value = False - _ambari_server_.download_jdk(args) + download_and_install_jdk(args) self.assertTrue(exit_mock.called) # Test case: jdk is already installed, ensure that JCE check is skipped if -j option is not supplied. - p = MagicMock() args.jdk_location = None - get_ambari_properties_mock.return_value = p - p.__getitem__.return_value = "somewhere" - get_JAVA_HOME_mock.return_value = True + get_JAVA_HOME_mock.return_value = "some_jdk" + validate_jdk_mock.return_value = True get_YN_input_mock.return_value = False path_existsMock.return_value = False - with patch.object(_ambari_server_, "download_jce_policy") as download_jce_policy_mock: - rcode = _ambari_server_.download_jdk(args) + force_download_file_mock.reset_mock() + with patch("ambari_server.serverSetup.JDKSetup._download_jce_policy") as download_jce_policy_mock: + rcode = download_and_install_jdk(args) self.assertFalse(download_jce_policy_mock.called) + self.assertFalse(force_download_file_mock.called) # Test case: Update JAVA_HOME location using command: ambari-server setup -j %NEW_LOCATION% - write_property_mock.reset_mock() - remove_property_mock.reset_mock() + update_properties_mock.reset_mock() args.java_home = "somewhere" - path_existsMock.side_effect = [True,False,False] - get_JAVA_HOME_mock.return_value = True + validate_jdk_mock.return_value = True + path_existsMock.return_value = False + get_JAVA_HOME_mock.return_value = "some_jdk" path_isfileMock.return_value = True - _ambari_server_.download_jdk(args) - self.assertTrue(write_property_mock.call_count == 1) - self.assertTrue(remove_property_mock.call_count == 2) + download_and_install_jdk(args) + self.assertTrue(update_properties_mock.call_count == 1) # Test case: Negative test case JAVA_HOME location should not be updated if -j option is supplied and # jce_policy file already exists in resources dir. @@ -2061,129 +2142,134 @@ MIIFHjCCAwYCCQDpHKOBI+Lt0zANBgkqhkiG9w0BAQUFADBRMQswCQYDVQQGEwJV #args.java_home = "somewhere" #path_existsMock.side_effect = None #path_existsMock.return_value = True - #get_JAVA_HOME_mock.return_value = True + #get_JAVA_HOME_mock.return_value = "some_jdk" #try: - # _ambari_server_.download_jdk(args) + # download_and_install_jdk(args) # self.fail("Should throw exception") #except FatalException as fe: - # Expected + # Expected # self.assertFalse(write_property_mock.called) + # Test case: Setup ambari-server first time, Custom JDK selected, JDK exists args.java_home = None args.jdk_location = None - write_property_mock.reset_mock() - remove_property_mock.reset_mock() - path_existsMock.side_effect = None - path_existsMock.return_value = True - get_validated_string_input_mock.return_value = "3" - get_JAVA_HOME_mock.return_value = False - rcode = _ambari_server_.download_jdk(args) + validate_jdk_mock.return_value = False + update_properties_mock.reset_mock() + path_existsMock.side_effect = [False, True] + get_validated_string_input_mock.return_value = "2" + get_JAVA_HOME_mock.return_value = None + rcode = download_and_install_jdk(args) self.assertEqual(0, rcode) - self.assertTrue(write_property_mock.called) - self.assertTrue(remove_property_mock.call_count == 2) + self.assertTrue(update_properties_mock.called) + # Test case: Setup ambari-server first time, Custom JDK selected, JDK not exists - write_property_mock.reset_mock() - remove_property_mock.reset_mock() - path_existsMock.side_effect = [False,False,False] - get_validated_string_input_mock.return_value = "3" - get_JAVA_HOME_mock.return_value = False + update_properties_mock.reset_mock() + validate_jdk_mock.return_value = False + path_existsMock.side_effect = None + path_existsMock.return_value = False + get_validated_string_input_mock.return_value = "2" + get_JAVA_HOME_mock.return_value = None try: - _ambari_server_.download_jdk(args) + download_and_install_jdk(args) self.fail("Should throw exception") except FatalException as fe: # Expected pass + # Test when custom java home exists but java binary file doesn't exist args.java_home = None + validate_jdk_mock.return_value = False path_isfileMock.return_value = False - write_property_mock.reset_mock() - remove_property_mock.reset_mock() - path_existsMock.side_effect = [True,False,False] - get_validated_string_input_mock.return_value = "3" - get_JAVA_HOME_mock.return_value = False + update_properties_mock.reset_mock() + path_existsMock.return_value = False + get_validated_string_input_mock.return_value = "2" + get_JAVA_HOME_mock.return_value = None flag = False try: - _ambari_server_.download_jdk(args) + download_and_install_jdk(args) self.fail("Should throw exception") except FatalException as fe: # Expected flag = True pass self.assertTrue(flag) - #Test case: Setup ambari-server with java home passed. Path to java home doesn't not exists + + #Test case: Setup ambari-server with java home passed. Path to java home doesn't exist args.java_home = "somewhere" + validate_jdk_mock.return_value = False path_existsMock.return_value = False try: - _ambari_server_.download_jdk(args) + download_and_install_jdk(args) self.fail("Should throw exception") except FatalException as fe: self.assertTrue("Path to java home somewhere or java binary file does not exists" in fe.reason) pass - @patch.object(_ambari_server_, "run_os_command") + @not_for_platform(PLATFORM_WINDOWS) + @patch("ambari_server.dbConfiguration_linux.run_os_command") def test_get_postgre_status(self, run_os_command_mock): run_os_command_mock.return_value = (1, "running", None) - pg_status, retcode, out, err = _ambari_server_.get_postgre_status() + pg_status, retcode, out, err = PGConfig._get_postgre_status() self.assertEqual("running", pg_status) run_os_command_mock.return_value = (1, "wrong", None) - pg_status, retcode, out, err = _ambari_server_.get_postgre_status() + pg_status, retcode, out, err = PGConfig._get_postgre_status() self.assertEqual(None, pg_status) + @not_for_platform(PLATFORM_WINDOWS) @patch("time.sleep") @patch("subprocess.Popen") - @patch.object(_ambari_server_, "run_os_command") - @patch.object(_ambari_server_, "get_postgre_status") + @patch("ambari_server.dbConfiguration_linux.run_os_command") + @patch.object(PGConfig, "_get_postgre_status") def test_check_postgre_up(self, get_postgre_status_mock, run_os_command_mock, popen_mock, sleep_mock): + from ambari_server import serverConfiguration + p = MagicMock() - p.poll.return_value = 0 p.communicate.return_value = (None, None) p.returncode = 0 popen_mock.return_value = p get_postgre_status_mock.return_value = "running", 0, "", "" + + serverConfiguration.OS_TYPE = OSConst.OS_REDHAT + p.poll.return_value = 0 + run_os_command_mock.return_value = (0, None, None) - pg_status, retcode, out, err = _ambari_server_.check_postgre_up() + pg_status, retcode, out, err = PGConfig._check_postgre_up() self.assertEqual(0, retcode) - _ambari_server_.OS_TYPE = OSConst.OS_SUSE + serverConfiguration.OS_TYPE = OSConst.OS_SUSE p.poll.return_value = 4 get_postgre_status_mock.return_value = "stopped", 0, "", "" - pg_status, retcode, out, err = _ambari_server_.check_postgre_up() + pg_status, retcode, out, err = PGConfig._check_postgre_up() self.assertEqual(4, retcode) @patch("platform.linux_distribution") @patch("platform.system") - @patch.object(_ambari_server_, "print_info_msg") - @patch.object(_ambari_server_, "print_error_msg") - @patch.object(_ambari_server_, "get_ambari_properties") - @patch.object(_ambari_server_, "write_property") - @patch.object(_ambari_server_, "get_conf_dir") + @patch("ambari_commons.logging_utils.print_info_msg") + @patch("ambari_commons.logging_utils.print_error_msg") + @patch("ambari_server.serverSetup.get_ambari_properties") + @patch("ambari_server.serverSetup.write_property") + @patch("ambari_server.serverConfiguration.get_conf_dir") def test_configure_os_settings(self, get_conf_dir_mock, write_property_mock, get_ambari_properties_mock, print_error_msg_mock, print_info_msg_mock, systemMock, distMock): get_ambari_properties_mock.return_value = -1 - rcode = _ambari_server_.configure_os_settings() + rcode = configure_os_settings() self.assertEqual(-1, rcode) p = MagicMock() - p[_ambari_server_.OS_TYPE_PROPERTY] = 'somevalue' + p[OS_TYPE_PROPERTY] = 'somevalue' get_ambari_properties_mock.return_value = p - rcode = _ambari_server_.configure_os_settings() + rcode = configure_os_settings() self.assertEqual(0, rcode) p.__getitem__.return_value = "" - systemMock.return_value = "NonLinux" - rcode = _ambari_server_.configure_os_settings() - self.assertEqual(-1, rcode) - - systemMock.return_value = "Linux" - distMock.return_value = ("CentOS", "6.3", None) - rcode = _ambari_server_.configure_os_settings() + rcode = configure_os_settings() self.assertEqual(0, rcode) self.assertTrue(write_property_mock.called) self.assertEqual(2, write_property_mock.call_count) @@ -2209,47 +2295,90 @@ MIIFHjCCAwYCCQDpHKOBI+Lt0zANBgkqhkiG9w0BAQUFADBRMQswCQYDVQQGEwJV result = get_JAVA_HOME() self.assertEqual(expected, result) + @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value)) def test_prompt_db_properties_default(self): args = MagicMock() - _ambari_server_.load_default_db_properties(args) - _ambari_server_.prompt_db_properties(args) - self.assertEqual(args.dbms, "postgres") - self.assertEqual(args.database_host, "localhost") - self.assertEqual(args.database_name, "ambari") - self.assertEqual(args.database_port, "5432") - - @patch.object(_ambari_server_, "setup_master_key") - @patch.object(_ambari_server_, "read_password") - @patch.object(_ambari_server_, "get_validated_string_input") - @patch.object(_ambari_server_, "get_YN_input") - def test_prompt_db_properties_oracle_sname(self, gyni_mock, gvsi_mock, rp_mock, smk_mock): - _ambari_server_.PROMPT_DATABASE_OPTIONS = True - gyni_mock.return_value = True - list_of_return_values = ["ambari-server", "ambari", "1", "1521", "localhost", "2"] + args.must_set_database_options = False + + del args.database_index + del args.dbms + del args.database_host + del args.database_port + del args.database_name + del args.database_username + del args.database_password + del args.persistence_type + + prompt_db_properties(args) + + self.assertEqual(args.database_index, 0) + + @not_for_platform(PLATFORM_WINDOWS) + @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value)) + @patch.object(LinuxDBMSConfig, "_setup_remote_server") + @patch("ambari_server.dbConfiguration_linux.print_info_msg") + @patch("ambari_server.dbConfiguration_linux.read_password") + @patch("ambari_server.dbConfiguration_linux.get_validated_string_input") + @patch("ambari_server.dbConfiguration.get_validated_string_input") + @patch("ambari_server.serverSetup.get_YN_input") + def test_prompt_db_properties_oracle_sname(self, gyni_mock, gvsi_mock, gvsi_2_mock, rp_mock, print_info_msg_mock, srs_mock): + gyni_mock.return_value = True + list_of_return_values = ["ambari-server", "ambari", "1", "1521", "localhost", "2"] def side_effect(*args, **kwargs): return list_of_return_values.pop() gvsi_mock.side_effect = side_effect + gvsi_2_mock.side_effect = side_effect rp_mock.return_value = "password" - smk_mock.return_value = (None, False, True) args = MagicMock() - _ambari_server_.load_default_db_properties(args) - _ambari_server_.prompt_db_properties(args) - self.assertEqual(args.dbms, "oracle") - self.assertEqual(args.database_port, "1521") - self.assertEqual(args.database_host, "localhost") - self.assertEqual(args.database_name, "ambari") - self.assertEqual(args.database_username, "ambari-server") - self.assertEqual(args.sid_or_sname, "sname") + args.must_set_database_options = True + + del args.database_index + del args.dbms + del args.database_host + del args.database_port + del args.database_name + del args.database_username + del args.database_password + del args.persistence_type + del args.sid_or_sname + del args.jdbc_url - @patch.object(_ambari_server_, "setup_master_key") - @patch.object(_ambari_server_, "read_password") - @patch.object(_ambari_server_, "get_validated_string_input") - @patch.object(_ambari_server_, "get_YN_input") - def test_prompt_db_properties_oracle_sid(self, gyni_mock, gvsi_mock, rp_mock, smk_mock): - _ambari_server_.PROMPT_DATABASE_OPTIONS = True + set_silent(False) + + prompt_db_properties(args) + + self.assertEqual(args.database_index, 1) + + props = Properties() + + factory = DBMSConfigFactory() + dbmsConfig = factory.create(args, props) + + self.assertEqual(dbmsConfig.dbms, "oracle") + self.assertEqual(dbmsConfig.database_port, "1521") + self.assertEqual(dbmsConfig.database_host, "localhost") + self.assertEqual(dbmsConfig.database_name, "ambari") + self.assertEqual(dbmsConfig.database_username, "ambari") + self.assertEqual(dbmsConfig.database_password, "bigdata") + + dbmsConfig.configure_database(props) + + self.assertEqual(dbmsConfig.database_username, "ambari-server") + self.assertEqual(dbmsConfig.sid_or_sname, "sname") + pass + + @not_for_platform(PLATFORM_WINDOWS) + @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value)) + @patch.object(LinuxDBMSConfig, "_setup_remote_server") + @patch("ambari_server.dbConfiguration_linux.print_info_msg") + @patch("ambari_server.dbConfiguration_linux.read_password") + @patch("ambari_server.dbConfiguration_linux.get_validated_string_input") + @patch("ambari_server.dbConfiguration.get_validated_string_input") + @patch("ambari_server.serverSetup.get_YN_input") + def test_prompt_db_properties_oracle_sid(self, gyni_mock, gvsi_mock, gvsi_2_mock, rp_mock, print_info_msg_mock, srs_mock): gyni_mock.return_value = True list_of_return_values = ["ambari-server", "ambari", "2", "1521", "localhost", "2"] @@ -2257,25 +2386,57 @@ MIIFHjCCAwYCCQDpHKOBI+Lt0zANBgkqhkiG9w0BAQUFADBRMQswCQYDVQQGEwJV return list_of_return_values.pop() gvsi_mock.side_effect = side_effect + gvsi_2_mock.side_effect = side_effect rp_mock.return_value = "password" - smk_mock.return_value = (None, False, True) args = MagicMock() - _ambari_server_.load_default_db_properties(args) - _ambari_server_.prompt_db_properties(args) - self.assertEqual(args.dbms, "oracle") - self.assertEqual(args.database_port, "1521") - self.assertEqual(args.database_host, "localhost") - self.assertEqual(args.database_name, "ambari") - self.assertEqual(args.database_username, "ambari-server") - self.assertEqual(args.sid_or_sname, "sid") + args.must_set_database_options = True + + del args.database_index + del args.dbms + del args.database_host + del args.database_port + del args.database_name + del args.database_username + del args.database_password + del args.persistence_type + del args.sid_or_sname + del args.jdbc_url - @patch.object(_ambari_server_, "setup_master_key") - @patch.object(_ambari_server_, "read_password") - @patch.object(_ambari_server_, "get_validated_string_input") - @patch.object(_ambari_server_, "get_YN_input") - def test_prompt_db_properties_postgre_adv(self, gyni_mock, gvsi_mock, rp_mock, smk_mock): - _ambari_server_.PROMPT_DATABASE_OPTIONS = True + set_silent(False) + + prompt_db_properties(args) + + self.assertEqual(args.database_index, 1) + + props = Properties() + + factory = DBMSConfigFactory() + dbmsConfig = factory.create(args, props) + + self.assertEqual(dbmsConfig.dbms, "oracle") + self.assertEqual(dbmsConfig.database_port, "1521") + self.assertEqual(dbmsConfig.database_host, "localhost") + self.assertEqual(dbmsConfig.database_name, "ambari") + self.assertEqual(dbmsConfig.database_username, "ambari") + self.assertEqual(dbmsConfig.database_password, "bigdata") + + dbmsConfig.configure_database(props) + + self.assertEqual(dbmsConfig.database_username, "ambari-server") + self.assertEqual(dbmsConfig.database_password, "password") + self.assertEqual(dbmsConfig.sid_or_sname, "sid") + pass + + @not_for_platform(PLATFORM_WINDOWS) + @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value)) + @patch.object(PGConfig, "_setup_local_server") + @patch("ambari_server.dbConfiguration_linux.print_info_msg") + @patch("ambari_server.dbConfiguration_linux.read_password") + @patch("ambari_server.dbConfiguration_linux.get_validated_string_input") + @patch("ambari_server.dbConfiguration.get_validated_string_input") + @patch("ambari_server.serverSetup.get_YN_input") + def test_prompt_db_properties_postgre_adv(self, gyni_mock, gvsi_mock, gvsi_2_mock, rp_mock, print_info_msg_mock, sls_mock): gyni_mock.return_value = True list_of_return_values = ["ambari-server", "ambari", "ambari", "1"] @@ -2283,34 +2444,62 @@ MIIFHjCCAwYCCQDpHKOBI+Lt0zANBgkqhkiG9w0BAQUFADBRMQswCQYDVQQGEwJV return list_of_return_values.pop() gvsi_mock.side_effect = side_effect + gvsi_2_mock.side_effect = side_effect rp_mock.return_value = "password" - smk_mock.return_value = (None, False, True) args = MagicMock() - _ambari_server_.load_default_db_properties(args) - _ambari_server_.prompt_db_properties(args) - self.assertEqual(args.dbms, "postgres") - self.assertEqual(args.database_port, "5432") - self.assertEqual(args.database_host, "localhost") - self.assertEqual(args.database_name, "ambari") - self.assertEqual(args.database_username, "ambari-server") - self.assertEqual(args.sid_or_sname, "sname") + args.must_set_database_options = True - @patch.object(_ambari_server_, "setup_master_key") - @patch.object(_ambari_server_, "read_password") - @patch.object(_ambari_server_, "get_validated_string_input") - @patch.object(_ambari_server_, "get_YN_input") - def test_prompt_db_properties_for_each_database_type(self, gyni_mock, gvsi_mock, rp_mock, smk_mock): + del args.database_index + del args.dbms + del args.database_host + del args.database_port + del args.database_name + del args.database_username + del args.database_password + del args.persistence_type + + set_silent(False) + + prompt_db_properties(args) + + self.assertEqual(args.database_index, 0) + + props = Properties() + + factory = DBMSConfigFactory() + dbmsConfig = factory.create(args, props) + + self.assertEqual(dbmsConfig.dbms, "postgres") + self.assertEqual(dbmsConfig.database_port, "5432") + self.assertEqual(dbmsConfig.database_host, "localhost") + self.assertEqual(dbmsConfig.database_name, "ambari") + self.assertEqual(dbmsConfig.database_username, "ambari") + self.assertEqual(dbmsConfig.database_password, "bigdata") + + dbmsConfig.configure_database(props) + + self.assertEqual(dbmsConfig.database_username, "ambari-server") + self.assertEqual(dbmsConfig.database_password, "password") + self.assertEqual(dbmsConfig.sid_or_sname, "sname") + pass + + @not_for_platform(PLATFORM_WINDOWS) + @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value)) + @patch("ambari_server.dbConfiguration_linux.store_password_file") + @patch("ambari_server.dbConfiguration_linux.read_password") + @patch("ambari_server.dbConfiguration_linux.get_validated_string_input") + @patch("ambari_server.dbConfiguration_linux.get_YN_input") + def test_prompt_db_properties_for_each_database_type(self, gyni_mock, gvsi_mock, rp_mock, spf_mock): """ :return: Validates that installation for each database type correctly stores the database type, database name, and optionally the postgres schema name. """ from ambari_server import serverConfiguration - _ambari_server_.PROMPT_DATABASE_OPTIONS = True gyni_mock.return_value = True rp_mock.return_value = "password" - smk_mock.return_value = (None, False, True) + spf_mock.return_value = "encrypted password" # Values to use while installing several database types hostname = "localhost" @@ -2322,10 +2511,10 @@ MIIFHjCCAwYCCQDpHKOBI+Lt0zANBgkqhkiG9w0BAQUFADBRMQswCQYDVQQGEwJV user_name = "ambari" # Input values - postgres_embedded_values = ["1", db_name, postgres_schema, hostname] - oracle_values = ["2", hostname, port, oracle_service, oracle_service_name, user_name] - mysql_values = ["3", hostname, port, db_name, user_name] - postgres_external_values = ["4", hostname, port, db_name, postgres_schema, user_name] + postgres_embedded_values = [db_name, postgres_schema, hostname] + oracle_values = [hostname, port, oracle_service, oracle_service_name, user_name] + mysql_values = [hostname, port, db_name, user_name] + postgres_external_values = [hostname, port, db_name, postgres_schema, user_name] list_of_return_values = postgres_embedded_values + oracle_values + mysql_values + postgres_external_values list_of_return_values = list_of_return_values[::-1] # Reverse the list since the input will be popped @@ -2334,273 +2523,391 @@ MIIFHjCCAwYCCQDpHKOBI+Lt0zANBgkqhkiG9w0BAQUFADBRMQswCQYDVQQGEwJV return list_of_return_values.pop() gvsi_mock.side_effect = side_effect - if _ambari_server_.AMBARI_CONF_VAR in os.environ: - del os.environ[_ambari_server_.AMBARI_CONF_VAR] + if AMBARI_CONF_VAR in os.environ: + del os.environ[AMBARI_CONF_VAR] tempdir = tempfile.gettempdir() - os.environ[_ambari_server_.AMBARI_CONF_VAR] = tempdir + os.environ[AMBARI_CONF_VAR] = tempdir prop_file = os.path.join(tempdir, "ambari.properties") - for i in range(1, 5): - # Use the expected path of the ambari.properties file to delete it if it exists, and then create a new one - # during each use case. - if os.path.exists(prop_file): - os.remove(prop_file) - with open(prop_file, "w") as f: - f.write("server.jdbc.database_name=oldDBName") - f.close() - - serverConfiguration.AMBARI_PROPERTIES_FILE = prop_file - - args = MagicMock() - _ambari_server_.load_default_db_properties(args) - _ambari_server_.prompt_db_properties(args) - - if i == 1: - _ambari_server_.store_local_properties(args) # Embedded postgres is the only one that saves local properties - else: - _ambari_server_.store_remote_properties(args) - - properties = get_ambari_properties() - if i == 1: - # Postgres Embedded - self.assertEqual(properties[_ambari_server_.JDBC_DATABASE_PROPERTY], "postgres") - self.assertEqual(properties[_ambari_server_.JDBC_DATABASE_NAME_PROPERTY], db_name) - self.assertEqual(properties[_ambari_server_.JDBC_POSTGRES_SCHEMA_PROPERTY], postgres_schema) - elif i == 2: - # Oracle - self.assertEqual(properties[_ambari_server_.JDBC_DATABASE_PROPERTY], "oracle") - self.assertFalse(_ambari_server_.JDBC_POSTGRES_SCHEMA_PROPERTY in properties.propertyNames()) - elif i == 3: - # MySQL - self.assertEqual(properties[_ambari_server_.JDBC_DATABASE_PROPERTY], "mysql") - self.assertFalse(_ambari_server_.JDBC_POSTGRES_SCHEMA_PROPERTY in properties.propertyNames()) - elif i == 4: - # Postgres External - self.assertEqual(properties[_ambari_server_.JDBC_DATABASE_PROPERTY], "postgres") - self.assertEqual(properties[_ambari_server_.JDBC_DATABASE_NAME_PROPERTY], db_name) - self.assertEqual(properties[_ambari_server_.JDBC_POSTGRES_SCHEMA_PROPERTY], postgres_schema) + for i in range(0, 4): + # Use the expected path of the ambari.properties file to delete it if it exists, and then create a new one + # during each use case. + if os.path.exists(prop_file): + os.remove(prop_file) + with open(prop_file, "w") as f: + f.write("server.jdbc.database_name=oldDBName") + f.close() + + serverConfiguration.AMBARI_PROPERTIES_FILE = prop_file + + args = MagicMock() + properties = Properties() + + args.database_index = i + args.silent = False + + del args.dbms + del args.database_host + del args.database_port + del args.database_name + del args.database_username + del arg
<TRUNCATED>