You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ambari.apache.org by fb...@apache.org on 2015/01/24 02:37:06 UTC
[2/8] ambari git commit: AMBARI-8317 Refactor the OS-dependent Ambari
Server Windows components - Part 1.4
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, [('aaa@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>