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 2014/12/19 20:51:07 UTC
[2/7] ambari git commit: AMBARI-8373 Refactor the OS-dependent Ambari
Server Windows components
http://git-wip-us.apache.org/repos/asf/ambari/blob/2914d681/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 0eae33b..64349a1 100644
--- a/ambari-server/src/test/python/TestAmbariServer.py
+++ b/ambari-server/src/test/python/TestAmbariServer.py
@@ -35,20 +35,44 @@ import shutil
from pwd import getpwnam
from ambari_server.resourceFilesKeeper import ResourceFilesKeeper, KeeperException
from ambari_server import BackupRestore
-
+
+from ambari_commons import OSCheck, OSConst, Firewall, FirewallChecks
+from ambari_commons.exceptions import *
+from ambari_commons.os_linux import *
+from ambari_commons.os_utils import *
+from ambari_commons.inet_utils import *
+
# We have to use this import HACK because the filename contains a dash
-from ambari_commons import Firewall, OSCheck, OSConst, FirewallChecks
+with patch("platform.linux_distribution", return_value = ('Suse','11','Final')):
+ with patch("os.symlink"):
+ with patch("__builtin__.open"):
+ with patch("glob.glob", return_value = ['/etc/init.d/postgresql-9.3']):
+ ambari__server = __import__('ambari-server')
with patch("platform.linux_distribution", return_value = ('Suse','11','Final')):
with patch("os.symlink"):
with patch("__builtin__.open"):
with patch("glob.glob", return_value = ['/etc/init.d/postgresql-9.3']):
- ambari_server = __import__('ambari-server')
+ from ambari_server.dbConfiguration import *
+ from ambari_server.dbConfiguration_linux import *
+ from ambari_server.properties import *
+ from ambari_server.serverConfiguration import *
+ from ambari_server.serverSetup import *
+ from ambari_server.userInput import *
-FatalException = ambari_server.FatalException
-NonFatalException = ambari_server.NonFatalException
CURR_AMBARI_VERSION = "2.0.0"
+db_YN_Inputs_test_ambariServerSetupWithCustomDbName_call_count = 0
+
+def db_YN_Inputs_ret_test_ambariServerSetupWithCustomDbName(*args, **kwargs):
+ global db_YN_Inputs_test_ambariServerSetupWithCustomDbName_call_count
+ if db_YN_Inputs_test_ambariServerSetupWithCustomDbName_call_count == 0:
+ db_YN_Inputs_test_ambariServerSetupWithCustomDbName_call_count += 1
+ return False
+ else:
+ return True
+
+
class TestAmbariServer(TestCase):
def setUp(self):
out = StringIO.StringIO()
@@ -58,27 +82,18 @@ class TestAmbariServer(TestCase):
def tearDown(self):
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):
+ @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
@@ -86,9 +101,9 @@ class TestAmbariServer(TestCase):
def test_servicename_regex(self, raw_input_method):
''' Test to make sure the service name can contain digits '''
- ambari_server.SILENT = False
+ ambari__server.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
@@ -96,31 +111,31 @@ class TestAmbariServer(TestCase):
def test_dbname_regex(self, raw_input_method):
''' Test to make sure the service name can contain digits '''
- ambari_server.SILENT = False
+ ambari__server.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")
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")
@@ -134,7 +149,7 @@ class TestAmbariServer(TestCase):
# test first input
raw_input_method.return_value = "Y"
- result = ambari_server.get_choice_string_input(prompt, default,
+ result = ambari__server.get_choice_string_input(prompt, default,
firstChoice, secondChoice)
self.assertEquals(result, True)
raw_input_method.reset_mock()
@@ -142,7 +157,7 @@ class TestAmbariServer(TestCase):
raw_input_method.return_value = "N"
- result = ambari_server.get_choice_string_input(prompt, default,
+ result = ambari__server.get_choice_string_input(prompt, default,
firstChoice, secondChoice)
self.assertEquals(result, False)
@@ -152,7 +167,7 @@ class TestAmbariServer(TestCase):
raw_input_method.return_value = ""
- result = ambari_server.get_choice_string_input(prompt, default,
+ result = ambari__server.get_choice_string_input(prompt, default,
firstChoice, secondChoice)
self.assertEquals(result, default)
@@ -166,7 +181,7 @@ class TestAmbariServer(TestCase):
raw_input_method.side_effect = side_effect
- result = ambari_server.get_choice_string_input(prompt, default,
+ result = ambari__server.get_choice_string_input(prompt, default,
firstChoice, secondChoice)
self.assertEquals(result, True)
self.assertEquals(raw_input_method.call_count, 3)
@@ -184,11 +199,11 @@ class TestAmbariServer(TestCase):
pattern = "pattern_pp"
description = "blabla2"
# check password input
- self.assertFalse(False, ambari_server.SILENT)
+ self.assertFalse(False, ambari__server.SILENT)
is_pass = True
get_pass_method.return_value = "dfdsfdsfds"
- result = ambari_server.get_validated_string_input(prompt, default,
+ result = ambari__server.get_validated_string_input(prompt, default,
pattern, description, is_pass)
self.assertEquals(get_pass_method.return_value, result)
@@ -201,7 +216,7 @@ class TestAmbariServer(TestCase):
is_pass = False
raw_input_method.return_value = "dkf90ewuf0"
- result = ambari_server.get_validated_string_input(prompt, default,
+ result = ambari__server.get_validated_string_input(prompt, default,
pattern, description, is_pass)
self.assertEquals(raw_input_method.return_value, result)
@@ -210,12 +225,12 @@ class TestAmbariServer(TestCase):
def test_get_pass_file_path(self):
- result = ambari_server.get_pass_file_path("/etc/ambari/conf_file")
+ result = ambari__server.get_pass_file_path("/etc/ambari/conf_file")
self.assertEquals("/etc/ambari/password.dat", result)
pass
- @patch.object(ambari_server, 'setup_security')
+ @patch.object(ambari__server, 'setup_security')
@patch('optparse.OptionParser')
def test_main_test_setup_security(self, OptionParserMock,
setup_security_method):
@@ -227,46 +242,46 @@ class TestAmbariServer(TestCase):
options.sid_or_sname = "sid"
setup_security_method.return_value = None
- ambari_server.main()
+ ambari__server.main()
- ambari_server.main()
+ ambari__server.main()
self.assertTrue(setup_security_method.called)
- self.assertFalse(False, ambari_server.VERBOSE)
- self.assertFalse(False, ambari_server.SILENT)
-
- @patch.object(ambari_server, 'setup_ambari_krb5_jaas')
- @patch.object(ambari_server, 'setup_master_key')
- @patch.object(ambari_server, 'setup_component_https')
- @patch.object(ambari_server, 'setup_https')
- @patch.object(ambari_server, 'get_validated_string_input')
+ self.assertFalse(False, ambari__server.VERBOSE)
+ self.assertFalse(False, ambari__server.SILENT)
+
+ @patch.object(ambari__server, 'setup_ambari_krb5_jaas')
+ @patch.object(ambari__server, 'setup_master_key')
+ @patch.object(ambari__server, 'setup_component_https')
+ @patch.object(ambari__server, 'setup_https')
+ @patch.object(ambari__server, "get_validated_string_input")
def test_setup_security(self, get_validated_string_input_mock, setup_https,
setup_component_https, setup_master_key,
setup_ambari_krb5_jaas):
args = {}
get_validated_string_input_mock.return_value = '1'
- ambari_server.setup_security(args)
+ ambari__server.setup_security(args)
self.assertTrue(setup_https.called)
get_validated_string_input_mock.return_value = '2'
- ambari_server.setup_security(args)
+ ambari__server.setup_security(args)
self.assertTrue(setup_component_https.called)
setup_component_https.assert_called_with("Ganglia", "setup-ganglia-https",
- ambari_server.GANGLIA_HTTPS, "ganglia_cert")
+ ambari__server.GANGLIA_HTTPS, "ganglia_cert")
get_validated_string_input_mock.return_value = '3'
- ambari_server.setup_security(args)
+ ambari__server.setup_security(args)
self.assertTrue(setup_master_key.called)
get_validated_string_input_mock.return_value = '4'
- ambari_server.setup_security(args)
+ ambari__server.setup_security(args)
self.assertTrue(setup_ambari_krb5_jaas.called)
@patch('re.sub')
@patch('fileinput.FileInput')
- @patch.object(ambari_server, 'get_validated_string_input')
- @patch.object(ambari_server, 'search_file')
+ @patch("ambari_server.userInput.get_validated_string_input")
+ @patch.object(ambari__server, "search_file")
@patch('os.path.exists')
def test_setup_ambari_krb5_jaas(self, exists_mock, search_mock,
get_validated_string_input_mock,
@@ -277,7 +292,7 @@ class TestAmbariServer(TestCase):
# Negative case
try:
- ambari_server.setup_ambari_krb5_jaas()
+ ambari__server.setup_ambari_krb5_jaas()
self.fail("Should throw exception")
except NonFatalException as fe:
# Expected
@@ -292,17 +307,17 @@ class TestAmbariServer(TestCase):
fileinput_mock.return_value = [ 'keyTab=xyz', 'principal=xyz' ]
- ambari_server.setup_ambari_krb5_jaas()
+ ambari__server.setup_ambari_krb5_jaas()
self.assertTrue(fileinput_mock.called)
self.assertTrue(re_sub_mock.called)
self.assertTrue(re_sub_mock.call_args_list, [('aaa@aaa.cnn'),
('pathtokeytab')])
- @patch.object(ambari_server, 'setup')
- @patch.object(ambari_server, 'start')
- @patch.object(ambari_server, 'stop')
- @patch.object(ambari_server, 'reset')
+ @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_setup(self, OptionParserMock, reset_method, stop_method,
start_method, setup_method):
@@ -313,21 +328,21 @@ class TestAmbariServer(TestCase):
options.dbms = None
options.sid_or_sname = "sid"
- ambari_server.main()
+ ambari__server.main()
self.assertTrue(setup_method.called)
self.assertFalse(start_method.called)
self.assertFalse(stop_method.called)
self.assertFalse(reset_method.called)
- self.assertFalse(False, ambari_server.VERBOSE)
- self.assertFalse(False, ambari_server.SILENT)
+ self.assertFalse(False, ambari__server.VERBOSE)
+ self.assertFalse(False, ambari__server.SILENT)
- @patch.object(ambari_server, 'setup')
- @patch.object(ambari_server, 'start')
- @patch.object(ambari_server, 'stop')
- @patch.object(ambari_server, 'reset')
+ @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,
start_method, setup_method):
@@ -338,21 +353,21 @@ class TestAmbariServer(TestCase):
options.dbms = None
options.sid_or_sname = "sname"
- ambari_server.main()
+ ambari__server.main()
self.assertTrue(setup_method.called)
self.assertFalse(start_method.called)
self.assertFalse(stop_method.called)
self.assertFalse(reset_method.called)
- self.assertFalse(False, ambari_server.VERBOSE)
- self.assertFalse(False, ambari_server.SILENT)
+ self.assertFalse(False, ambari__server.VERBOSE)
+ self.assertFalse(False, ambari__server.SILENT)
- @patch.object(ambari_server, 'setup')
- @patch.object(ambari_server, 'start')
- @patch.object(ambari_server, 'stop')
- @patch.object(ambari_server, 'reset')
+ @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,
start_method, setup_method):
@@ -364,20 +379,20 @@ class TestAmbariServer(TestCase):
options.dbms = None
options.sid_or_sname = "sid"
- ambari_server.main()
+ ambari__server.main()
self.assertFalse(setup_method.called)
self.assertTrue(start_method.called)
self.assertFalse(stop_method.called)
self.assertFalse(reset_method.called)
- self.assertTrue(ambari_server.SERVER_DEBUG_MODE)
+ self.assertTrue(ambari__server.SERVER_DEBUG_MODE)
- @patch.object(ambari_server, 'setup')
- @patch.object(ambari_server, 'start')
- @patch.object(ambari_server, 'stop')
- @patch.object(ambari_server, 'reset')
+ @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,
start_method, setup_method):
@@ -388,21 +403,21 @@ class TestAmbariServer(TestCase):
options.dbms = None
options.sid_or_sname = "sid"
- ambari_server.main()
+ ambari__server.main()
self.assertFalse(setup_method.called)
self.assertTrue(start_method.called)
self.assertFalse(stop_method.called)
self.assertFalse(reset_method.called)
- self.assertTrue(ambari_server.SERVER_DEBUG_MODE)
+ self.assertTrue(ambari__server.SERVER_DEBUG_MODE)
- @patch.object(ambari_server, 'setup')
- @patch.object(ambari_server, 'start')
- @patch.object(ambari_server, 'stop')
- @patch.object(ambari_server, 'reset')
- @patch.object(ambari_server, 'backup')
- @patch.object(ambari_server, 'restore')
+ @patch.object(ambari__server, 'setup')
+ @patch.object(ambari__server, 'start')
+ @patch.object(ambari__server, 'stop')
+ @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,
start_method, setup_method):
@@ -413,7 +428,7 @@ class TestAmbariServer(TestCase):
options.dbms = None
options.sid_or_sname = "sname"
- ambari_server.main()
+ ambari__server.main()
self.assertTrue(backup_mock.called)
self.assertFalse(restore_mock.called)
@@ -422,15 +437,15 @@ class TestAmbariServer(TestCase):
self.assertFalse(stop_method.called)
self.assertFalse(reset_method.called)
- self.assertFalse(False, ambari_server.VERBOSE)
- self.assertFalse(False, ambari_server.SILENT)
+ self.assertFalse(False, ambari__server.VERBOSE)
+ self.assertFalse(False, ambari__server.SILENT)
- @patch.object(ambari_server, 'setup')
- @patch.object(ambari_server, 'start')
- @patch.object(ambari_server, 'stop')
- @patch.object(ambari_server, 'reset')
- @patch.object(ambari_server, 'backup')
- @patch.object(ambari_server, 'restore')
+ @patch.object(ambari__server, 'setup')
+ @patch.object(ambari__server, 'start')
+ @patch.object(ambari__server, 'stop')
+ @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,
start_method, setup_method):
@@ -441,7 +456,7 @@ class TestAmbariServer(TestCase):
options.dbms = None
options.sid_or_sname = "sname"
- ambari_server.main()
+ ambari__server.main()
self.assertTrue(restore_mock.called)
self.assertFalse(backup_mock.called)
@@ -450,13 +465,13 @@ class TestAmbariServer(TestCase):
self.assertFalse(stop_method.called)
self.assertFalse(reset_method.called)
- self.assertFalse(False, ambari_server.VERBOSE)
- self.assertFalse(False, ambari_server.SILENT)
+ self.assertFalse(False, ambari__server.VERBOSE)
+ self.assertFalse(False, ambari__server.SILENT)
- @patch.object(ambari_server, 'setup')
- @patch.object(ambari_server, 'start')
- @patch.object(ambari_server, 'stop')
- @patch.object(ambari_server, 'reset')
+ @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,
start_method, setup_method):
@@ -468,21 +483,21 @@ class TestAmbariServer(TestCase):
options.dbms = None
options.sid_or_sname = "sid"
- ambari_server.main()
+ ambari__server.main()
self.assertFalse(setup_method.called)
self.assertFalse(start_method.called)
self.assertTrue(stop_method.called)
self.assertFalse(reset_method.called)
- self.assertFalse(False, ambari_server.VERBOSE)
- self.assertFalse(False, ambari_server.SILENT)
+ self.assertFalse(False, ambari__server.VERBOSE)
+ self.assertFalse(False, ambari__server.SILENT)
- @patch.object(ambari_server, 'setup')
- @patch.object(ambari_server, 'start')
- @patch.object(ambari_server, 'stop')
- @patch.object(ambari_server, 'reset')
+ @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,
start_method, setup_method):
@@ -494,108 +509,130 @@ class TestAmbariServer(TestCase):
options.dbms = None
options.sid_or_sname = "sid"
- ambari_server.main()
+ ambari__server.main()
self.assertFalse(setup_method.called)
self.assertFalse(start_method.called)
self.assertFalse(stop_method.called)
self.assertTrue(reset_method.called)
- self.assertFalse(False, ambari_server.VERBOSE)
- self.assertFalse(False, ambari_server.SILENT)
-
+ self.assertFalse(False, ambari__server.VERBOSE)
+ self.assertFalse(False, ambari__server.SILENT)
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")
- @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,
+ @patch.object(OSCheck, "get_os_family")
+ @patch.object(OSCheck, "get_os_type")
+ @patch.object(OSCheck, "get_os_major_version")
+ @patch("ambari_server.dbConfiguration_linux.PGConfig._restart_postgres")
+ @patch("ambari_server.dbConfiguration_linux.PGConfig._get_postgre_status")
+ @patch("ambari_server.dbConfiguration_linux.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):
+ restart_postgres_mock,
+ get_os_major_version_mock, get_os_type_mock, get_os_family_mock):
+ args = MagicMock()
+ properties = Properties()
+
+ args.dbms_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__
@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("ambari_server.dbConfiguration_linux.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)
@patch("shlex.split")
@patch("subprocess.Popen")
- @patch.object(ambari_server, "print_info_msg")
+ @patch("ambari_commons.os_linux.print_info_msg")
def test_run_os_command(self, printInfoMsg_mock, popenMock, splitMock):
p = MagicMock()
@@ -605,151 +642,283 @@ class TestAmbariServer(TestCase):
# with list arg
cmd = ["exec", "arg"]
- ambari_server.run_os_command(cmd)
+ run_os_command(cmd)
self.assertFalse(splitMock.called)
# with str arg
- resp = ambari_server.run_os_command("runme")
+ resp = run_os_command("runme")
self.assertEqual(3, resp[0])
self.assertTrue(splitMock.called)
- @patch.object(ambari_server, "get_conf_dir")
- @patch.object(ambari_server, "search_file")
+ @patch.object(ambari__server, "get_conf_dir")
+ @patch.object(ambari__server, "search_file")
def test_write_property(self, search_file_mock, get_conf_dir_mock):
expected_content = "key1=val1\n"
tf1 = tempfile.NamedTemporaryFile()
search_file_mock.return_value = tf1.name
- ambari_server.write_property("key1", "val1")
+ ambari__server.write_property("key1", "val1")
result = tf1.read()
self.assertTrue(expected_content in result)
- @patch.object(ambari_server, "configure_database_username_password")
- @patch.object(ambari_server, "run_os_command")
- def test_setup_db(self, run_os_command_mock,
+ #TODO Deprecate
+ @patch.object(ambari__server, "configure_database_username_password")
+ @patch.object(ambari__server, 'run_os_command')
+ def test_setup_db_old(self, run_os_command_mock,
configure_database_username_password_mock):
run_os_command_mock.return_value = (0, None, None)
- result = ambari_server.setup_db(MagicMock())
+ result = ambari__server.setup_db(MagicMock())
self.assertTrue(configure_database_username_password_mock.called)
self.assertEqual((0, None, None), result)
- @patch.object(ambari_server, "configure_database_username_password")
+ #TODO Deprecate
+ @patch.object(ambari__server, "configure_database_username_password")
@patch("time.sleep")
- @patch.object(ambari_server, "run_os_command")
- def test_setup_db_connect_attempts_fail(self, run_os_command_mock,
+ @patch.object(ambari__server, 'run_os_command')
+ def test_setup_db_connect_attempts_fail_old(self, run_os_command_mock,
sleep_mock, config_db_mock):
run_os_command_mock.side_effect = [(1, "error", "error"), (1, "error", "error"),
(1, "error", "error")]
- result = ambari_server.setup_db(MagicMock())
+ result = ambari__server.setup_db(MagicMock())
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")
+ #TODO Deprecate
+ @patch.object(ambari__server, "configure_database_username_password")
@patch("time.sleep")
- @patch.object(ambari_server, "run_os_command")
- def test_setup_db_connect_attempts_success(self, run_os_command_mock,
- sleep_mock, config_db_mock):
+ @patch.object(ambari__server, 'run_os_command')
+ def test_setup_db_connect_attempts_success_old(self, run_os_command_mock, sleep_mock,
+ config_db_mock):
run_os_command_mock.side_effect = [(1, "error", "error"), (0, None, None),
(0, None, None)]
- result = ambari_server.setup_db(MagicMock())
+ result = ambari__server.setup_db(MagicMock())
+ self.assertTrue(run_os_command_mock.called)
+ self.assertEqual((0, None, None) , result)
+ self.assertEqual(1, sleep_mock.call_count)
+ pass
+
+
+ @patch.object(OSCheck, "get_os_family")
+ @patch.object(OSCheck, "get_os_type")
+ @patch.object(OSCheck, "get_os_major_version")
+ @patch("time.sleep")
+ @patch("ambari_server.dbConfiguration_linux.run_os_command")
+ def test_setup_db(self, run_os_command_mock, sleep_mock,
+ get_os_major_version_mock, get_os_type_mock, get_os_family_mock):
+ args = MagicMock()
+ properties = Properties()
+
+ args.dbms_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
+
+ run_os_command_mock.return_value = (0, None, None)
+
+ factory = DBMSConfigFactory()
+ dbConfig = factory.create(args, properties)
+
+ self.assertTrue(dbConfig.dbms, "postgres")
+ self.assertTrue(dbConfig.persistence_type, "local")
+
+ result = dbConfig._setup_db()
+ self.assertEqual((0, None, None), result)
+
+ @patch.object(OSCheck, "get_os_family")
+ @patch.object(OSCheck, "get_os_type")
+ @patch.object(OSCheck, "get_os_major_version")
+ @patch("time.sleep")
+ @patch("ambari_server.dbConfiguration_linux.run_os_command")
+ def test_setup_db_connect_attempts_fail(self, run_os_command_mock, sleep_mock,
+ get_os_major_version_mock, get_os_type_mock, get_os_family_mock):
+ args = MagicMock()
+ properties = Properties()
+
+ args.dbms_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
+
+ run_os_command_mock.side_effect = [(1, "error", "error"), (1, "error", "error"),
+ (1, "error", "error")]
+
+ factory = DBMSConfigFactory()
+ dbConfig = factory.create(args, properties)
+
+ self.assertTrue(dbConfig.dbms, "postgres")
+ self.assertTrue(dbConfig.persistence_type, "local")
+
+ result = dbConfig._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(OSCheck, "get_os_family")
+ @patch.object(OSCheck, "get_os_type")
+ @patch.object(OSCheck, "get_os_major_version")
+ @patch("time.sleep")
+ @patch("ambari_server.dbConfiguration_linux.run_os_command")
+ def test_setup_db_connect_attempts_success(self, run_os_command_mock, sleep_mock,
+ get_os_major_version_mock, get_os_type_mock, get_os_family_mock):
+ args = MagicMock()
+ properties = Properties()
+
+ args.dbms_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
+
+ run_os_command_mock.side_effect = [(1, "error", "error"), (0, None, None),
+ (0, None, None)]
+
+ factory = DBMSConfigFactory()
+ dbConfig = factory.create(args, properties)
+
+ self.assertTrue(dbConfig.dbms, "postgres")
+ self.assertTrue(dbConfig.persistence_type, "local")
+
+ result = dbConfig._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")
- def test_check_selinux(self, run_os_command_mock, getYNInput_mock):
- run_os_command_mock.return_value = (0, ambari_server.SE_STATUS_DISABLED,
+ @patch.object(OSCheck, "get_os_family")
+ @patch.object(OSCheck, "get_os_type")
+ @patch.object(OSCheck, "get_os_major_version")
+ @patch("ambari_server.serverSetup.get_YN_input")
+ @patch("ambari_server.serverSetup.run_os_command")
+ def test_disable_security_enhancements(self, run_os_command_mock, getYNInput_mock,
+ get_os_major_version_mock, get_os_type_mock, get_os_family_mock):
+ run_os_command_mock.return_value = (0, ambari__server.SE_STATUS_DISABLED,
None)
- rcode = ambari_server.check_selinux()
+ (rcode, err) = disable_security_enhancements()
self.assertEqual(0, rcode)
getYNInput_mock.return_value = True
run_os_command_mock.return_value = (0, "enabled "
- + ambari_server.SE_MODE_ENFORCING,
+ + ambari__server.SE_MODE_ENFORCING,
None)
- rcode = ambari_server.check_selinux()
+ (rcode, err) = disable_security_enhancements()
self.assertEqual(0, rcode)
self.assertTrue(run_os_command_mock.called)
self.assertTrue(getYNInput_mock.called)
- @patch.object(ambari_server, "print_info_msg")
+ @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.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.AMBARI_SERVER_LIB]
+ result = get_ambari_jars()
self.assertEqual("/usr/lib/ambari-server", 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.get_ambari_properties")
+ @patch("ambari_server.serverConfiguration.print_info_msg")
+ def test_get_ambari_classpath(self, printInfoMsg_mock, get_ambari_properties_mock, globMock):
+ props = {}
+ props[JDBC_DRIVER_PATH_PROPERTY] = "/driver"
+ get_ambari_properties_mock.return_value = props
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("/driver" 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)
+ props[JDBC_DRIVER_PATH_PROPERTY] = ""
+ result = get_ambari_classpath()
+ self.assertTrue(get_ambari_jars() in result)
self.assertFalse(":" in result)
- @patch.object(ambari_server, "print_info_msg")
+ @patch("glob.glob")
+ @patch("ambari_server.serverConfiguration.get_ambari_properties")
+ @patch("ambari_server.serverConfiguration.print_info_msg")
+ def test_get_full_ambari_classpath(self, printInfoMsg_mock, get_ambari_properties_mock, globMock):
+ props = {}
+ props[JDBC_DRIVER_PATH_PROPERTY] = "/driver"
+ get_ambari_properties_mock.return_value = props
+ globMock.return_value = ["one"]
+ result = get_full_ambari_classpath()
+ self.assertTrue(get_ambari_jars() in result)
+ self.assertTrue(get_share_jars() in result)
+ props[JDBC_DRIVER_PATH_PROPERTY] = "/driver dir"
+ result = get_full_ambari_classpath()
+ self.assertEqual(result[0], '"')
+ self.assertEqual(result[len(result) - 1], '"')
+
+
+ @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__server.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__server.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 = ambari_server.search_file(__file__, path)
+ result = search_file(__file__, path)
expected = os.path.abspath(__file__)
self.assertEqual(expected, result)
- result = ambari_server.search_file("non_existent_file", path)
+ result = search_file("non_existent_file", path)
self.assertEqual(None, result)
- @patch.object(ambari_server, "search_file")
+ @patch("ambari_server.serverConfiguration.search_file")
def test_find_properties_file(self, search_file_mock):
# Testing case when file is not found
search_file_mock.return_value = None
try:
- ambari_server.find_properties_file()
+ find_properties_file()
self.fail("File not found'")
except FatalException:
# Expected
@@ -759,71 +928,73 @@ class TestAmbariServer(TestCase):
# Testing case when file is found
value = MagicMock()
search_file_mock.return_value = value
- result = ambari_server.find_properties_file()
+ result = find_properties_file()
self.assertTrue(result is value)
- @patch.object(ambari_server, "find_properties_file")
+ @patch.object(ambari__server, "find_properties_file")
@patch("__builtin__.open")
- @patch("ambari-server.Properties")
+ @patch.object(ambari__server, "Properties")
def test_read_ambari_user(self, properties_mock, open_mock, find_properties_file_mock):
open_mock.return_value = "dummy"
find_properties_file_mock.return_value = "dummy"
# Testing with defined user
properties_mock.return_value.__getitem__.return_value = "dummy_user"
- user = ambari_server.read_ambari_user()
+ user = ambari__server.read_ambari_user()
self.assertEquals(user, "dummy_user")
# Testing with undefined user
properties_mock.return_value.__getitem__.return_value = None
- user = ambari_server.read_ambari_user()
+ user = ambari__server.read_ambari_user()
self.assertEquals(user, None)
@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("os.mkdir")
- def test_adjust_directory_permissions(self, mkdir_mock,
+ @patch("ambari_server.setupSecurity.set_file_permissions")
+ @patch("ambari_server.setupSecurity.run_os_command")
+ @patch("ambari_server.setupSecurity.get_ambari_properties")
+ @patch("ambari_server.setupSecurity.get_value_from_properties")
+ @patch("shutil.rmtree")
+ @patch("os.makedirs")
+ def test_adjust_directory_permissions(self, mkdir_mock, rmtree_mock,
get_value_from_properties_mock, get_ambari_properties_mock,
run_os_command_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")
+ 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")
+ self.assertTrue(set_file_permissions_mock.called)
+ self.assertTrue(rmtree_mock.called)
self.assertTrue(mkdir_mock.called)
set_file_permissions_mock.reset_mock()
# Test recursive calls
- old_list = ambari_server.NR_ADJUST_OWNERSHIP_LIST
+ old_list = configDefaults.NR_ADJUST_OWNERSHIP_LIST
- ambari_server.NR_ADJUST_OWNERSHIP_LIST = [
+ configDefaults.NR_ADJUST_OWNERSHIP_LIST = [
( "/etc/ambari-server/conf", "755", "{0}", True ),
( "/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(ambari_server.NR_ADJUST_OWNERSHIP_LIST))
+ len(configDefaults.NR_ADJUST_OWNERSHIP_LIST))
self.assertEquals(set_file_permissions_mock.call_args_list[0][0][3], True)
self.assertEquals(set_file_permissions_mock.call_args_list[1][0][3], False)
- ambari_server.NR_ADJUST_OWNERSHIP_LIST = old_list
+ configDefaults.NR_ADJUST_OWNERSHIP_LIST = old_list
@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)
@@ -834,7 +1005,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)
@@ -844,7 +1015,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)
@@ -854,7 +1025,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)
@@ -866,7 +1037,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])
@@ -880,7 +1051,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])
@@ -891,18 +1062,24 @@ 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, "get_os_family")
+ @patch.object(OSCheck, "get_os_type")
+ @patch.object(OSCheck, "get_os_major_version")
+ @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):
+ print_info_msg_mock, get_validated_string_input_mock,
+ get_os_major_version_mock, get_os_type_mock, get_os_family_mock):
user = "dummy-user"
get_validated_string_input_mock.return_value = user
+ checks = AmbariUserChecks()
+
# Testing scenario: absent user
run_os_command_mock.side_effect = [(0, "", "")]
- result = ambari_server.create_custom_user()
+ result = checks._create_custom_user()
self.assertFalse(print_warning_msg_mock.called)
self.assertEquals(result, (0, user))
@@ -912,7 +1089,7 @@ class TestAmbariServer(TestCase):
# Testing scenario: existing user
run_os_command_mock.side_effect = [(9, "", "")]
- result = ambari_server.create_custom_user()
+ result = checks._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))
@@ -922,25 +1099,29 @@ class TestAmbariServer(TestCase):
# Testing scenario: os command fail
run_os_command_mock.side_effect = [(1, "", "")]
- result = ambari_server.create_custom_user()
+ result = checks._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, "get_os_family")
+ @patch.object(OSCheck, "get_os_type")
+ @patch.object(OSCheck, "get_os_major_version")
+ @patch("ambari_server.serverSetup.read_ambari_user")
+ @patch("ambari_server.serverSetup.get_YN_input")
+ @patch("ambari_server.serverSetup.AmbariUserChecksLinux._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, get_YN_input_mock, read_ambari_user_mock,
+ get_os_major_version_mock, get_os_type_mock, get_os_family_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)
@@ -957,7 +1138,7 @@ class TestAmbariServer(TestCase):
read_ambari_user_mock.return_value = "dummy-user"
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")
@@ -976,7 +1157,7 @@ class TestAmbariServer(TestCase):
read_ambari_user_mock.return_value = "dummy-user"
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.assertFalse(write_property_mock.called)
@@ -992,7 +1173,7 @@ class TestAmbariServer(TestCase):
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()
+ result = check_ambari_user()
self.assertTrue(get_YN_input_mock.called)
self.assertTrue(create_custom_user_mock.called)
self.assertTrue(write_property_mock.called)
@@ -1010,7 +1191,7 @@ 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()
+ result = check_ambari_user()
self.assertTrue(get_YN_input_mock.called)
self.assertTrue(create_custom_user_mock.called)
self.assertFalse(write_property_mock.called)
@@ -1027,7 +1208,7 @@ 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()
+ result = check_ambari_user()
self.assertTrue(get_YN_input_mock.called)
self.assertTrue(create_custom_user_mock.called)
self.assertFalse(write_property_mock.called)
@@ -1042,7 +1223,7 @@ class TestAmbariServer(TestCase):
# 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.assertTrue(write_property_mock.called)
@@ -1051,15 +1232,15 @@ class TestAmbariServer(TestCase):
self.assertEqual(result, 0)
- @patch.object(ambari_server, "search_file")
@patch("__builtin__.open")
- @patch.object(ambari_server, "read_ambari_user")
- @patch.object(ambari_server, "set_file_permissions")
- def test_store_password_file(self, set_file_permissions_mock,
- read_ambari_user_mock, open_mock, search_file_mock):
+ @patch.object(ambari__server, "search_file")
+ @patch.object(ambari__server, "set_file_permissions")
+ @patch.object(ambari__server, "read_ambari_user")
+ def test_store_password_file(self, read_ambari_user_mock, set_file_permissions_mock,
+ search_file_mock, open_mock):
search_file_mock.return_value = "/etc/ambari-server/conf/ambari.properties"
open_mock.return_value = MagicMock()
- ambari_server.store_password_file("password", "passfile")
+ ambari__server.store_password_file("password", "passfile")
self.assertTrue(set_file_permissions_mock.called)
@patch("subprocess.Popen")
@@ -1124,23 +1305,36 @@ class TestAmbariServer(TestCase):
self.assertFalse(firewall_obj.check_iptables())
self.assertEqual("err", firewall_obj.stderrdata)
-
- def test_dlprogress(self):
+ def test_download_progress(self):
out = StringIO.StringIO()
sys.stdout = out
- ambari_server.dlprogress("filename", 10, 2, 100)
+ download_progress("filename", 10, 2, 100)
sys.stdout = sys.__stdout__
self.assertNotEqual("", out.getvalue())
+ @patch("os.makedirs")
+ @patch("os.path.exists")
+ @patch("os.rename")
+ @patch("os.stat")
@patch("urllib2.urlopen")
@patch("__builtin__.open")
- @patch.object(ambari_server, "dlprogress")
- def test_track_jdk(self, dlprogress_mock, openMock, urlopenMock):
+ @patch("ambari_commons.inet_utils.download_progress")
+ @patch("ambari_commons.inet_utils.print_info_msg")
+ def test_track_jdk(self, print_info_msg_mock, download_progress_mock, openMock,
+ urlopenMock, os_stat_mock, os_rename_mock, os_path_exists_mock, os_makedirs_mock):
+ os_path_exists_mock.return_value = False
+
+ fsize = MagicMock()
+ fsize.st_size = 24576
+ os_stat_mock.return_value = fsize
+
+ inf = MagicMock()
+ inf.getheaders.return_value = ["bytes 0-24575/24576"]
u = MagicMock()
- u.info.return_value = {"Content-Length": "24576"}
+ u.info.return_value = inf
chunks = [None, "second", "first"]
def side_effect(*args, **kwargs):
@@ -1152,19 +1346,19 @@ class TestAmbariServer(TestCase):
f = MagicMock()
openMock.return_value = f
- ambari_server.track_jdk("base", "url", "local")
+ force_download_file("base", "url", progress_func=download_progress_mock)
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))
+ self.assertEqual(2, len(download_progress_mock.call_args_list))
+ self.assertTrue(print_info_msg_mock.called)
@patch("shutil.copy")
@patch("os.path.join")
@patch("os.path.exists")
@patch("os.path.isdir")
- @patch.object(ambari_server, "get_ambari_properties")
+ @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):
@@ -1178,7 +1372,7 @@ class TestAmbariServer(TestCase):
# Case when JCE path doesn't exists
os_path_exists_mock.return_value = False
try:
- ambari_server.install_jce_manualy(args)
+ ambari__server.install_jce_manualy(args)
self.fail("Should throw exception")
except FatalException as fe:
# Expected
@@ -1190,7 +1384,7 @@ class TestAmbariServer(TestCase):
os_path_exists_mock.return_value = True
os_path_isdir_mock.return_value = True
try:
- ambari_server.install_jce_manualy(args)
+ ambari__server.install_jce_manualy(args)
self.fail("Should throw exception")
except FatalException as fe:
# Expected
@@ -1201,12 +1395,12 @@ class TestAmbariServer(TestCase):
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)
+ 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)
+ ambari__server.install_jce_manualy(args)
self.fail("Should throw exception because of not found jce_policy-6.zip")
except Exception:
# Expected
@@ -1215,20 +1409,20 @@ class TestAmbariServer(TestCase):
shutil_copy_mock.side_effect = None
args.jce_policy = None
- ambari_server.install_jce_manualy(args)
+ 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")
+ @patch.object(ambari__server, "get_validated_filepath_input")
+ @patch.object(ambari__server, 'run_os_command')
+ @patch.object(ambari__server, "get_truststore_type")
@patch("__builtin__.open")
- @patch.object(ambari_server, "find_properties_file")
- @patch.object(ambari_server, "run_component_https_cmd")
- @patch.object(ambari_server, "get_delete_cert_command")
- @patch.object(ambari_server, "get_truststore_password")
- @patch.object(ambari_server, "get_truststore_path")
- @patch.object(ambari_server, "get_YN_input")
- @patch.object(ambari_server, "get_ambari_properties")
- @patch.object(ambari_server, "find_jdk")
+ @patch.object(ambari__server, "find_properties_file")
+ @patch.object(ambari__server, "run_component_https_cmd")
+ @patch.object(ambari__server, "get_delete_cert_command")
+ @patch.object(ambari__server, "get_truststore_password")
+ @patch.object(ambari__server, "get_truststore_path")
+ @patch.object(ambari__server, "get_YN_input")
+ @patch.object(ambari__server, "get_ambari_properties")
+ @patch.object(ambari__server, "find_jdk")
def test_setup_component_https(self, find_jdk_mock, get_ambari_properties_mock, get_YN_input_mock,
get_truststore_path_mock, get_truststore_password_mock,
get_delete_cert_command_mock, run_component_https_cmd_mock,
@@ -1242,18 +1436,18 @@ class TestAmbariServer(TestCase):
property = "use_ssl"
alias = "alias"
#Silent mode
- ambari_server.SILENT = True
- ambari_server.setup_component_https(component, command, property, alias)
+ ambari__server.SILENT = True
+ ambari__server.setup_component_https(component, command, property, alias)
self.assertEqual('command is not enabled in silent mode.\n', out.getvalue())
sys.stdout = sys.__stdout__
#Verbouse mode and jdk_path is None
- ambari_server.SILENT = False
+ ambari__server.SILENT = False
p = get_ambari_properties_mock.return_value
# Use ssl
p.get_property.side_effect = ["true"]
# Dont disable ssl
get_YN_input_mock.side_effect = [False]
- ambari_server.setup_component_https(component, command, property, alias)
+ ambari__server.setup_component_https(component, command, property, alias)
self.assertTrue(p.get_property.called)
self.assertTrue(get_YN_input_mock.called)
p.get_property.reset_mock()
@@ -1262,7 +1456,7 @@ class TestAmbariServer(TestCase):
p.get_property.side_effect = ["false"]
# Dont enable ssl
get_YN_input_mock.side_effect = [False]
- ambari_server.setup_component_https(component, command, property, alias)
+ ambari__server.setup_component_https(component, command, property, alias)
self.assertTrue(p.get_property.called)
self.assertTrue(get_YN_input_mock.called)
p.get_property.reset_mock()
@@ -1270,7 +1464,7 @@ class TestAmbariServer(TestCase):
# Cant find jdk
find_jdk_mock.return_value = None
try:
- ambari_server.setup_component_https(component, command, property, alias)
+ ambari__server.setup_component_https(component, command, property, alias)
self.fail("Should throw exception")
except FatalException as fe:
# Expected
@@ -1284,7 +1478,7 @@ class TestAmbariServer(TestCase):
get_truststore_path_mock.return_value = "/truststore_path"
get_truststore_password_mock.return_value = "/truststore_password"
get_delete_cert_command_mock.return_value = "rm -f"
- ambari_server.setup_component_https(component, command, property, alias)
+ ambari__server.setup_component_https(component, command, property, alias)
self.assertTrue(p.process_pair.called)
self.assertTrue(get_truststore_path_mock.called)
@@ -1305,7 +1499,7 @@ class TestAmbariServer(TestCase):
#Verbouse mode and jdk_path is not None (use_https = false) and import cert
p.get_property.side_effect = ["false"]
get_YN_input_mock.side_effect = [True]
- ambari_server.setup_component_https(component, command, property, alias)
+ ambari__server.setup_component_https(component, command, property, alias)
self.assertTrue(p.process_pair.called)
self.assertTrue(get_truststore_type_mock.called)
@@ -1330,19 +1524,19 @@ class TestAmbariServer(TestCase):
run_os_command_mock.reset_mock()
get_validated_filepath_input_mock.reset_mock()
- @patch.object(ambari_server, 'adjust_directory_permissions')
- @patch.object(ambari_server, 'read_ambari_user')
- @patch.object(ambari_server, "get_validated_string_input")
- @patch.object(ambari_server, "find_properties_file")
- @patch.object(ambari_server, "get_ambari_properties")
- @patch.object(ambari_server, "is_server_runing")
- @patch.object(ambari_server, "import_cert_and_key_action")
- @patch.object(ambari_server, "get_YN_input")
+ @patch.object(ambari__server, "adjust_directory_permissions")
+ @patch.object(ambari__server, "read_ambari_user")
+ @patch.object(ambari__server, "get_validated_string_input")
+ @patch.object(ambari__server, "find_properties_file")
+ @patch.object(ambari__server, "get_ambari_properties")
+ @patch.object(ambari__server, "is_server_runing")
+ @patch.object(ambari__server, "import_cert_and_key_action")
+ @patch.object(ambari__server, "get_YN_input")
@patch("__builtin__.open")
- @patch("ambari-server.Properties")
- @patch.object(ambari_server, "is_root")
- @patch.object(ambari_server, "is_valid_cert_host")
- @patch.object(ambari_server, "is_valid_cert_exp")
+ @patch("ambari_server.properties.Properties")
+ @patch.object(ambari__server, "is_root")
+ @patch.object(ambari__server, "is_valid_cert_host")
+ @patch.object(ambari__server, "is_valid_cert_exp")
def test_setup_https(self, is_valid_cert_exp_mock, is_valid_cert_host_mock, \
is_root_mock, Properties_mock, open_Mock, get_YN_input_mock, \
import_cert_and_key_action_mock,
@@ -1360,7 +1554,7 @@ class TestAmbariServer(TestCase):
# Testing call under non-root
is_root_mock.return_value = False
try:
- ambari_server.setup_https(args)
+ ambari__server.setup_https(args)
self.fail("Should throw exception")
except FatalException as fe:
# Expected
@@ -1379,8 +1573,8 @@ class TestAmbariServer(TestCase):
" call('client.api.ssl.port'),\n" + \
" call('client.api.ssl.port'),\n call('api.ssl')]"
process_pair_expected = "[call('client.api.ssl.port', '4444')]"
- ambari_server.SILENT = False
- ambari_server.setup_https(args)
+ ambari__server.SILENT = False
+ ambari__server.setup_https(args)
self.assertTrue(p.process_pair.called)
self.assertTrue(p.get_property.call_count == 4)
@@ -1401,7 +1595,7 @@ class TestAmbariServer(TestCase):
get_property_expected = "[call('security.server.keys_dir'),\n" + \
" call('client.api.ssl.port'),\n call('api.ssl')]"
process_pair_expected = "[call('api.ssl', 'false')]"
- ambari_server.setup_https(args)
+ ambari__server.setup_https(args)
self.assertTrue(p.process_pair.called)
self.assertTrue(p.get_property.call_count == 3)
@@ -1423,7 +1617,7 @@ class TestAmbariServer(TestCase):
get_property_expected = "[call('security.server.keys_dir'),\n" + \
" call('client.api.ssl.port'),\n call('api.ssl')]"
process_pair_expected = "[call('client.api.ssl.port', '4444')]"
- ambari_server.setup_https(args)
+ ambari__server.setup_https(args)
self.assertTrue(p.process_pair.called)
self.assertTrue(p.get_property.call_count == 3)
@@ -1445,7 +1639,7 @@ class TestAmbariServer(TestCase):
get_property_expected = "[call('security.server.keys_dir'),\n" + \
" call('client.api.ssl.port'),\n call('api.ssl')]"
process_pair_expected = "[]"
- ambari_server.setup_https(args)
+ ambari__server.setup_https(args)
self.assertFalse(p.process_pair.called)
self.assertTrue(p.get_property.call_count == 3)
@@ -1467,7 +1661,7 @@ class TestAmbariServer(TestCase):
get_property_expected = "[call('security.server.keys_dir'),\n" + \
" call('client.api.ssl.port'),\n call('api.ssl')]"
process_pair_expected = "[call('client.api.ssl.port', '4444')]"
- self.assertFalse(ambari_server.setup_https(args))
+ self.assertFalse(ambari__server.setup_https(args))
self.assertTrue(p.process_pair.called)
self.assertTrue(p.get_property.call_count == 3)
self.assertEqual(str(p.get_property.call_args_list), get_property_expected)
@@ -1481,9 +1675,9 @@ class TestAmbariServer(TestCase):
import_cert_and_key_action_mock.reset_mock()
#Case #6: if silent mode is enabled
- ambari_server.SILENT = True
+ ambari__server.SILENT = True
try:
- ambari_server.setup_https(args)
+ ambari__server.setup_https(args)
self.fail("Should throw exception")
except NonFatalException as fe:
self.assertTrue("setup-https is not enabled in silent mode" in fe.reason)
@@ -1494,18 +1688,18 @@ class TestAmbariServer(TestCase):
import_cert_and_key_action_mock.reset_mock()
#Case #7: read property throw exception
- ambari_server.SILENT = False
+ ambari__server.SILENT = False
find_properties_file_mock.return_value = "propertyFile"
p.get_property.side_effect = KeyError("Failed to read property")
try:
- ambari_server.setup_https(args)
+ ambari__server.setup_https(args)
self.fail("Should throw exception")
except FatalException as fe:
self.assertTrue("Failed to read property" in fe.reason)
- @patch.object(ambari_server, "import_cert_and_key")
+ @patch.object(ambari__server, "import_cert_and_key")
def test_import_cert_and_key_action(self, import_cert_and_key_mock):
import_cert_and_key_mock.return_value = True
properties = MagicMock()
@@ -1514,24 +1708,24 @@ class TestAmbariServer(TestCase):
expect_process_pair = "[call('client.api.ssl.cert_name', 'https.crt'),\n" + \
" call('client.api.ssl.key_name', 'https.key'),\n" + \
" call('api.ssl', 'true')]"
- ambari_server.import_cert_and_key_action("key_dir", properties)
+ ambari__server.import_cert_and_key_action("key_dir", properties)
self.assertEqual(str(properties.process_pair.call_args_list), \
expect_process_pair)
- @patch.object(ambari_server, "remove_file")
- @patch.object(ambari_server, "copy_file")
- @patch.object(ambari_server, "read_ambari_user")
- @patch.object(ambari_server, "set_file_permissions")
- @patch.object(ambari_server, "import_file_to_keystore")
+ @patch.object(ambari__server, "remove_file")
+ @patch.object(ambari__server, "copy_file")
+ @patch.object(ambari__server, "read_ambari_user")
+ @patch.object(ambari__server, "set_file_permissions")
+ @patch.object(ambari__server, "import_file_to_keystore")
@patch("__builtin__.open")
- @patch.object(ambari_server, "run_os_command")
+ @patch.object(ambari__server, 'run_os_command')
@patch("os.path.join")
@patch("os.path.isfile")
@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")
+ @patch.object(ambari__server, "get_validated_string_input")
+ @patch.object(ambari__server, "is_valid_cert_host")
+ @patch.object(ambari__server, "is_valid_cert_exp")
def test_import_cert_and_key(self, is_valid_cert_exp_mock, \
is_valid_cert_host_mock, \
get_validated_string_input_mock, \
@@ -1563,7 +1757,7 @@ class TestAmbariServer(TestCase):
" call('key_file_path'," + \
" 'keystore_cert_key_file_path')]"
- ambari_server.import_cert_and_key("key_dir")
+ ambari__server.import_cert_and_key("key_dir")
self.assertTrue(raw_input_mock.call_count == 2)
self.assertTrue(get_validated_string_input_mock.called)
self.assertEqual(os_path_join_mock.call_count, 8)
@@ -1571,19 +1765,19 @@ class TestAmbariServer(TestCase):
self.assertEqual(str(import_file_to_keystore_mock.call_args_list), \
expect_import_file_to_keystore)
- @patch.object(ambari_server, "remove_file")
- @patch.object(ambari_server, "copy_file")
- @patch.object(ambari_server, "generate_random_string")
- @patch.object(ambari_server, "read_ambari_user")
- @patch.object(ambari_server, "set_file_permissions")
- @patch.object(ambari_server, "import_file_to_keystore")
+ @patch.object(ambari__server, "remove_file")
+ @patch.object(ambari__server, "copy_file")
+ @patch.object(ambari__server, "generate_random_string")
+ @patch.object(ambari__server, "read_ambari_user")
+ @patch.object(ambari__server, "set_file_permissions")
+ @patch.object(ambari__server, "import_file_to_keystore")
@patch("__builtin__.open")
- @patch.object(ambari_server, "run_os_command")
+ @patch.object(ambari__server, 'run_os_command')
@patch("os.path.join")
- @patch.object(ambari_server, "get_validated_filepath_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")
+ @patch.object(ambari__server, "get_validated_filepath_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")
def test_import_cert_and_key_with_empty_password(self, \
is_valid_cert_exp_mock, is_valid_cert_host_mock,
get_validated_string_input_mock, get_validated_filepath_input_mock, \
@@ -1613,7 +1807,7 @@ class TestAmbariServer(TestCase):
" call('key_file_path.secured'," + \
" 'keystore_cert_key_file_path')]"
- ambari_server.import_cert_and_key("key_dir")
+ ambari__server.import_cert_and_key("key_dir")
self.assertEquals(get_validated_filepath_input_mock.call_count, 2)
self.assertTrue(get_validated_string_input_mock.called)
self.assertEquals(os_path_join_mock.call_count, 8)
@@ -1623,15 +1817,15 @@ class TestAmbariServer(TestCase):
self.assertTrue(generate_random_string_mock.called)
@patch("__builtin__.open")
- @patch.object(ambari_server, "copy_file")
- @patch.object(ambari_server, "is_root")
- @patch.object(ambari_server, "read_ambari_user")
- @patch.object(ambari_server, "set_file_permissions")
- @patch.object(ambari_server, "import_file_to_keystore")
- @patch.object(ambari_server, "run_os_command")
+ @patch.object(ambari__server, "copy_file")
+ @patch.object(ambari__server, "is_root")
+ @patch.object(ambari__server, "read_ambari_user")
+ @patch.object(ambari__server, "set_file_permissions")
+ @patch.object(ambari__server, "import_file_to_keystore")
+ @patch.object(ambari__server, 'run_os_command')
@patch("os.path.join")
- @patch.object(ambari_server, "get_validated_filepath_input")
- @patch.object(ambari_server, "get_validated_string_input")
+ @patch.object(ambari__server, "get_validated_filepath_input")
+ @patch.object(ambari__server, "get_validated_string_input")
def test_import_cert_and_key_with_incorrect_password(self,
get_validated_string_input_mock, \
get_validated_filepath_input_mock, \
@@ -1654,110 +1848,110 @@ class TestAmbariServer(TestCase):
#provided password doesn't match, openssl command returns an error
run_os_command_mock.return_value = (1, "", "Some error message")
- self.assertFalse(ambari_server.import_cert_and_key_action(*["key_dir", None]))
- self.assertFalse(ambari_server.import_cert_and_key("key_dir"))
+ self.assertFalse(ambari__server.import_cert_and_key_action(*["key_dir", None]))
+ self.assertFalse(ambari__server.import_cert_and_key("key_dir"))
def test_is_valid_cert_exp(self):
#No data in certInfo
certInfo = {}
- is_valid = ambari_server.is_valid_cert_exp(certInfo)
+ is_valid = ambari__server.is_valid_cert_exp(certInfo)
self.assertFalse(is_valid)
#Issued in future
- issuedOn = (datetime.datetime.now() + datetime.timedelta(hours=1000)).strftime(ambari_server.SSL_DATE_FORMAT)
- expiresOn = (datetime.datetime.now() + datetime.timedelta(hours=2000)).strftime(ambari_server.SSL_DATE_FORMAT)
- certInfo = {ambari_server.NOT_BEFORE_ATTR: issuedOn,
- ambari_server.NOT_AFTER_ATTR: expiresOn}
- is_valid = ambari_server.is_valid_cert_exp(certInfo)
+ issuedOn = (datetime.datetime.now() + datetime.timedelta(hours=1000)).strftime(ambari__server.SSL_DATE_FORMAT)
+ expiresOn = (datetime.datetime.now() + datetime.timedelta(hours=2000)).strftime(ambari__server.SSL_DATE_FORMAT)
+ certInfo = {ambari__server.NOT_BEFORE_ATTR: issuedOn,
+ ambari__server.NOT_AFTER_ATTR: expiresOn}
+ is_valid = ambari__server.is_valid_cert_exp(certInfo)
self.assertFalse(is_valid)
#Was expired
- issuedOn = (datetime.datetime.now() - datetime.timedelta(hours=2000)).strftime(ambari_server.SSL_DATE_FORMAT)
- expiresOn = (datetime.datetime.now() - datetime.timedelta(hours=1000)).strftime(ambari_server.SSL_DATE_FORMAT)
- certInfo = {ambari_server.NOT_BEFORE_ATTR: issuedOn,
- ambari_server.NOT_AFTER_ATTR: expiresOn}
- is_valid = ambari_server.is_valid_cert_exp(certInfo)
+ issuedOn = (datetime.datetime.now() - datetime.timedelta(hours=2000)).strftime(ambari__server.SSL_DATE_FORMAT)
+ expiresOn = (datetime.datetime.now() - datetime.timedelta(hours=1000)).strftime(ambari__server.SSL_DATE_FORMAT)
+ certInfo = {ambari__server.NOT_BEFORE_ATTR: issuedOn,
+ ambari__server.NOT_AFTER_ATTR: expiresOn}
+ is_valid = ambari__server.is_valid_cert_exp(certInfo)
self.assertFalse(is_valid)
#Valid
- issuedOn = (datetime.datetime.now() - datetime.timedelta(hours=2000)).strftime(ambari_server.SSL_DATE_FORMAT)
- expiresOn = (datetime.datetime.now() + datetime.timedelta(hours=1000)).strftime(ambari_server.SSL_DATE_FORMAT)
- certInfo = {ambari_server.NOT_BEFORE_ATTR: issuedOn,
- ambari_server.NOT_AFTER_ATTR: expiresOn}
- is_valid = ambari_server.is_valid_cert_exp(certInfo)
+ issuedOn = (datetime.datetime.now() - datetime.timedelta(hours=2000)).strftime(ambari__server.SSL_DATE_FORMAT)
+ expiresOn = (datetime.datetime.now() + datetime.timedelta(hours=1000)).strftime(ambari__server.SSL_DATE_FORMAT)
+ certInfo = {ambari__server.NOT_BEFORE_ATTR: issuedOn,
+ ambari__server.NOT_AFTER_ATTR: expiresOn}
+ is_valid = ambari__server.is_valid_cert_exp(certInfo)
self.assertTrue(is_valid)
- @patch.object(ambari_server, "get_fqdn")
+ @patch.object(ambari__server, "get_fqdn")
def test_is_valid_cert_host(self, get_fqdn_mock):
#No data in certInfo
certInfo = {}
- is_valid = ambari_server.is_valid_cert_host(certInfo)
+ is_valid = ambari__server.is_valid_cert_host(certInfo)
self.assertFalse(is_valid)
#Failed to get FQDN
get_fqdn_mock.return_value = None
- is_valid = ambari_server.is_valid_cert_host(certInfo)
+ is_valid = ambari__server.is_valid_cert_host(certInfo)
self.assertFalse(is_valid)
#FQDN and Common name in certificated don't correspond
get_fqdn_mock.return_value = 'host1'
- certInfo = {ambari_server.COMMON_NAME_ATTR: 'host2'}
- is_valid = ambari_server.is_valid_cert_host(certInfo)
+ certInfo = {ambari__server.COMMON_NAME_ATTR: 'host2'}
+ is_valid = ambari__server.is_valid_cert_host(certInfo)
self.assertFalse(is_valid)
#FQDN and Common name in certificated correspond
get_fqdn_mock.return_value = 'host1'
- certInfo = {ambari_server.COMMON_NAME_ATTR: 'host1'}
- is_valid = ambari_server.is_valid_cert_host(certInfo)
+ certInfo = {ambari__server.COMMON_NAME_ATTR: 'host1'}
+ is_valid = ambari__server.is_valid_cert_host(certInfo)
self.assertTrue(is_valid)
- @patch.object(ambari_server, "get_ambari_properties")
+ @patch.object(ambari__server, "get_ambari_properties")
def test_is_valid_https_port(self, get_ambari_properties_mock):
#No ambari.properties
get_ambari_properties_mock.return_value = -1
- is_valid = ambari_server.is_valid_https_port(1111)
+ is_valid = ambari__server.is_valid_https_port(1111)
self.assertEqual(is_valid, False)
#User entered port used by one way auth
portOneWay = "1111"
portTwoWay = "2222"
validPort = "3333"
- get_ambari_properties_mock.return_value = {ambari_server.SRVR_ONE_WAY_SSL_PORT_PROPERTY: portOneWay,
- ambari_server.SRVR_TWO_WAY_SSL_PORT_PROPERTY: portTwoWay}
- is_valid = ambari_server.is_valid_https_port(portOneWay)
+ get_ambari_properties_mock.return_value = {ambari__server.SRVR_ONE_WAY_SSL_PORT_PROPERTY: portOneWay,
+ ambari__server.SRVR_TWO_WAY_SSL_PORT_PROPERTY: portTwoWay}
+ is_valid = ambari__server.is_valid_https_port(portOneWay)
self.assertEqual(is_valid, False)
#User entered port used by two way auth
- is_valid = ambari_server.is_valid_https_port(portTwoWay)
+ is_valid = ambari__server.is_valid_https_port(portTwoWay)
self.assertEqual(is_valid, False)
#User entered valid port
- get_ambari_properties_mock.return_value = {ambari_server.SRVR_ONE_WAY_SSL_PORT_PROPERTY: portOneWay,
- ambari_server.SRVR_TWO_WAY_SSL_PORT_PROPERTY: portTwoWay}
- is_valid = ambari_server.is_valid_https_port(validPort)
+ get_ambari_properties_mock.return_value = {ambari__server.SRVR_ONE_WAY_SSL_PORT_PROPERTY: portOneWay,
+ ambari__server.SRVR_TWO_WAY_SSL_PORT_PROPERTY: portTwoWay}
+ is_valid = ambari__server.is_valid_https_port(validPort)
self.assertEqual(is_valid, True)
@patch("socket.getfqdn")
@patch("urllib2.urlopen")
- @patch.object(ambari_server, "get_ambari_properties")
+ @patch.object(ambari__server, "get_ambari_properties")
def test_get_fqdn(self, get_ambari_properties_mock, url_open_mock, getfqdn_mock):
#No ambari.properties
get_ambari_properties_mock.return_value = -1
- fqdn = ambari_server.get_fqdn()
+ fqdn = ambari__server.get_fqdn()
self.assertEqual(fqdn, None)
#Check mbari_server.GET_FQDN_SERVICE_URL property name (AMBARI-2612)
#property name should be server.fqdn.service.url
- self.assertEqual(ambari_server.GET_FQDN_SERVICE_URL, "server.fqdn.service.url")
+ self.assertEqual(ambari__server.GET_FQDN_SERVICE_URL, "server.fqdn.service.url")
#Read FQDN from service
p = MagicMock()
- p[ambari_server.GET_FQDN_SERVICE_URL] = 'someurl'
+ p[ambari__server.GET_FQDN_SERVICE_URL] = 'someurl'
get_ambari_properties_mock.return_value = p
u = MagicMock()
@@ -1765,57 +1959,57 @@ class TestAmbariServer(TestCase):
u.read.return_value = host
url_open_mock.return_value = u
- fqdn = ambari_server.get_fqdn()
+ fqdn = ambari__server.get_fqdn()
self.assertEqual(fqdn, host)
#Failed to read FQDN from service, getting from socket
u.reset_mock()
u.side_effect = Exception("Failed to read FQDN from service")
getfqdn_mock.return_value = host
- fqdn = ambari_server.get_fqdn()
+ fqdn = ambari__server.get_fqdn()
self.assertEqual(fqdn, host)
- @patch.object(ambari_server, "find_properties_file")
+ @patch.object(ambari__server, "find_properties_file")
def test_get_ulimit_open_files(self, find_properties_file_mock):
# 1 - No ambari.properties
find_properties_file_mock.return_value = None
- open_files = ambari_server.get_fqdn()
+ open_files = ambari__server.get_fqdn()
self.assertEqual(open_files, None)
# 2 - With ambari.properties - ok
tf1 = tempfile.NamedTemporaryFile()
prop_value = 65000
with open(tf1.name, 'w') as fout:
- fout.write(ambari_server.ULIMIT_OPEN_FILES_KEY + '=' + str(prop_value))
+ fout.write(ambari__server.ULIMIT_OPEN_FILES_KEY + '=' + str(prop_value))
fout.close()
find_properties_file_mock.return_value = tf1.name
- open_files = ambari_server.get_ulimit_open_files()
+ open_files = ambari__server.get_ulimit_open_files()
self.assertEqual(open_files, 65000)
# 2 - With ambari.properties - default
tf1 = tempfile.NamedTemporaryFile()
prop_value = 0
with open(tf1.name, 'w') as fout:
- fout.write(ambari_server.ULIMIT_OPEN_FILES_KEY + '=' + str(prop_value))
+ fout.write(ambari__server.ULIMIT_OPEN_FILES_KEY + '=' + str(prop_value))
fout.close()
find_properties_file_mock.return_value = tf1.name
- open_files = ambari_server.get_ulimit_open_files()
- self.assertEqual(open_files, ambari_server.ULIMIT_OPEN_FILES_DEFAULT)
+ open_files = ambari__server.get_ulimit_open_files()
+ self.assertEqual(open_files, ambari__server.ULIMIT_OPEN_FILES_DEFAULT)
- @patch.object(ambari_server, "run_os_command")
+ @patch.object(ambari__server, 'run_os_command')
def test_get_cert_info(self, run_os_command_mock):
# Error running openssl command
path = 'path/to/certificate'
run_os_command_mock.return_value = -1, None, None
- cert_info = ambari_server.get_cert_info(path)
+ cert_info = ambari__server.get_cert_info(path)
self.assertEqual(cert_info, None)
#Empty result of openssl command
run_os_command_mock.return_value = 0, None, None
- cert_info = ambari_server.get_cert_info(path)
+ cert_info = ambari__server.get_cert_info(path)
self.assertEqual(cert_info, None)
#Positive scenario
@@ -1843,7 +2037,7 @@ MIIFHjCCAwYCCQDpHKOBI+Lt0zANBgkqhkiG9w0BAQUFADBRMQswCQYDVQQGEwJV
"""
out = out_pattern.format(notAfter=notAfter, notBefore=notBefore, subject=subject)
run_os_command_mock.return_value = 0, out, None
- cert_info = ambari_server.get_cert_info(path)
+ cert_info = ambari__server.get_cert_info(path)
self.assertEqual(cert_info['notAfter'], notAfter)
self.assertEqual(cert_info['notBefore'], notBefore)
self.assertEqual(cert_info['subject'], subject)
@@ -1862,19 +2056,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 = ambari__server.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 = ambari__server.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.object(ambari__server, 'run_os_command')
@patch("__builtin__.open")
@patch("os.path.exists")
def test_is_server_runing(self, os_path_exists_mock, open_mock, \
@@ -1883,15 +2077,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 = ambari__server.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 = ambari__server.is_server_runing()
self.assertFalse(status)
- @patch.object(ambari_server, "run_os_command")
+ @patch.object(ambari__server, 'run_os_command')
@patch("__builtin__.open")
@patch("os.path.exists")
def test_is_server_runing_bad_file(self, os_path_exists_mock, open_mock, \
@@ -1900,144 +2094,169 @@ 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)
+
+ try:
+ ambari__server.is_server_runing()
+ self.fail("Should throw NonFatalException")
+ except NonFatalException as fe:
+ pass
open_mock.side_effect = IOError('[Errno 13] Permission denied: /var/run/ambari-server/ambari-server.pid')
- self.assertRaises(FatalException, ambari_server.is_server_runing)
+
+ try:
+ ambari__server.is_server_runing()
+ self.fail("Should throw FatalException")
+ except FatalException as fe:
+ pass
+ @patch.object(OSCheck, "get_os_family")
+ @patch.object(OSCheck, "get_os_type")
+ @patch.object(OSCheck, "get_os_major_version")
@patch("os.chdir")
- @patch.object(ambari_server, "run_os_command")
- def test_install_jdk(self, run_os_command_mock, os_chdir_mock):
- run_os_command_
<TRUNCATED>