You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ambari.apache.org by ma...@apache.org on 2013/06/13 20:52:45 UTC
svn commit: r1492819 [3/3] - in /incubator/ambari/trunk/ambari-server: ./
etc/init.d/ sbin/ src/main/package/rpm/ src/main/python/ src/test/python/
Modified: incubator/ambari/trunk/ambari-server/src/test/python/TestAmbaryServer.py
URL: http://svn.apache.org/viewvc/incubator/ambari/trunk/ambari-server/src/test/python/TestAmbaryServer.py?rev=1492819&r1=1492818&r2=1492819&view=diff
==============================================================================
--- incubator/ambari/trunk/ambari-server/src/test/python/TestAmbaryServer.py (original)
+++ incubator/ambari/trunk/ambari-server/src/test/python/TestAmbaryServer.py Thu Jun 13 18:52:44 2013
@@ -27,10 +27,20 @@ import signal
import stat
# We have to use this import HACK because the filename contains a dash
ambari_server = __import__('ambari-server')
+FatalException = ambari_server.FatalException
class TestAmbariServer(TestCase):
+ def setUp(self):
+ out = StringIO.StringIO()
+ sys.stdout = out
+
+
+ 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')
@@ -82,10 +92,6 @@ class TestAmbariServer(TestCase):
@patch('__builtin__.raw_input')
def test_get_choice_string_input(self, raw_input_method):
- out = StringIO.StringIO()
- sys.stdout = out
-
-
prompt = "blablabla"
default = "default blablabla"
firstChoice = set(['yes','ye', 'y'])
@@ -128,8 +134,6 @@ class TestAmbariServer(TestCase):
self.assertEquals(result, True)
self.assertEquals(raw_input_method.call_count, 3)
- sys.stdout = sys.__stdout__
-
pass
@@ -139,14 +143,12 @@ class TestAmbariServer(TestCase):
@patch('getpass.getpass')
def test_get_validated_string_input(self, get_pass_method,
raw_input_method, re_search_method):
- out = StringIO.StringIO()
- sys.stdout = out
-
prompt = "blabla"
default = "default_pass"
pattern = "pattern_pp"
description = "blabla2"
# check password input
+ self.assertFalse(False, ambari_server.SILENT)
is_pass = True
get_pass_method.return_value = "dfdsfdsfds"
@@ -170,8 +172,6 @@ class TestAmbariServer(TestCase):
self.assertFalse(get_pass_method.called)
raw_input_method.assure_called_once(prompt)
- sys.stdout = sys.__stdout__
-
def test_get_pass_file_path(self):
@@ -180,9 +180,6 @@ class TestAmbariServer(TestCase):
pass
-
-
-
@patch.object(ambari_server, 'setup')
@patch.object(ambari_server, 'start')
@patch.object(ambari_server, 'stop')
@@ -232,7 +229,7 @@ class TestAmbariServer(TestCase):
self.assertFalse(False, ambari_server.SILENT)
-
+
@patch.object(ambari_server, 'setup')
@patch.object(ambari_server, 'start')
@patch.object(ambari_server, 'stop')
@@ -278,8 +275,7 @@ class TestAmbariServer(TestCase):
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')
@@ -307,7 +303,6 @@ class TestAmbariServer(TestCase):
self.assertFalse(False, ambari_server.SILENT)
-
@patch.object(ambari_server, 'setup')
@patch.object(ambari_server, 'start')
@patch.object(ambari_server, 'stop')
@@ -333,9 +328,7 @@ class TestAmbariServer(TestCase):
self.assertFalse(False, ambari_server.SILENT)
-
def test_configure_postgresql_conf(self):
-
tf1 = tempfile.NamedTemporaryFile()
ambari_server.POSTGRESQL_CONF_FILE = tf1.name
@@ -355,7 +348,6 @@ class TestAmbariServer(TestCase):
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")
@@ -366,8 +358,6 @@ class TestAmbariServer(TestCase):
configure_postgresql_conf_mock,
get_postgre_status_mock,
restart_postgres_mock):
-
-
tf1 = tempfile.NamedTemporaryFile()
tf2 = tempfile.NamedTemporaryFile()
ambari_server.PG_HBA_CONF_FILE = tf1.name
@@ -414,10 +404,6 @@ class TestAmbariServer(TestCase):
@patch.object(ambari_server, "print_info_msg")
def test_restart_postgres(self, printInfoMsg_mock, get_postgre_status_mock,
run_os_command_mock, popenMock, sleepMock):
-
- out = StringIO.StringIO()
- sys.stdout = out
-
p = MagicMock()
p.poll.return_value = 0
popenMock.return_value = p
@@ -429,7 +415,6 @@ class TestAmbariServer(TestCase):
run_os_command_mock.return_value = (1, None, None)
rcode = ambari_server.restart_postgres()
self.assertEqual(1, rcode)
- sys.stdout = sys.__stdout__
@@ -465,7 +450,7 @@ class TestAmbariServer(TestCase):
search_file_mock.return_value = tf1.name
ambari_server.write_property("key1", "val1")
result = tf1.read()
- self.assertEqual(expected_content, result)
+ self.assertTrue(expected_content in result)
@@ -484,10 +469,6 @@ class TestAmbariServer(TestCase):
@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):
-
- out = StringIO.StringIO()
- sys.stdout = out
-
run_os_command_mock.return_value = (0, ambari_server.SE_STATUS_DISABLED,
None)
rcode = ambari_server.check_selinux()
@@ -501,7 +482,6 @@ class TestAmbariServer(TestCase):
self.assertEqual(0, rcode)
self.assertTrue(run_os_command_mock.called)
self.assertTrue(getYNInput_mock.called)
- sys.stdout = sys.__stdout__
@@ -537,20 +517,17 @@ class TestAmbariServer(TestCase):
def test_get_ambari_classpath(self, printInfoMsg_mock, globMock):
globMock.return_value = ["one"]
result = ambari_server.get_ambari_classpath()
- print result
self.assertTrue(ambari_server.get_ambari_jars() in result)
self.assertTrue(ambari_server.get_share_jars() in result)
globMock.return_value = []
result = ambari_server.get_ambari_classpath()
- print result
self.assertTrue(ambari_server.get_ambari_jars() in result)
self.assertFalse(":" in result)
@patch.object(ambari_server, "print_info_msg")
def test_get_conf_dir(self, printInfoMsg_mock):
-
- env = "/ambari/conf"
+ env = "/dummy/ambari/conf"
os.environ[ambari_server.AMBARI_CONF_VAR] = env
result = ambari_server.get_conf_dir()
self.assertEqual(env, result)
@@ -558,8 +535,6 @@ class TestAmbariServer(TestCase):
del os.environ[ambari_server.AMBARI_CONF_VAR]
result = ambari_server.get_conf_dir()
self.assertEqual("/etc/ambari-server/conf", result)
- self.assertTrue(printInfoMsg_mock.called)
-
def test_search_file(self):
@@ -573,12 +548,211 @@ class TestAmbariServer(TestCase):
self.assertEqual(None, result)
+ @patch.object(ambari_server, "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()
+ self.fail("File not found'")
+ except FatalException:
+ # Expected
+ pass
+ self.assertTrue(search_file_mock.called)
+
+ # Testing case when file is found
+ value = MagicMock()
+ search_file_mock.return_value = value
+ result = ambari_server.find_properties_file()
+ self.assertTrue(result is value)
+
+
+ @patch.object(ambari_server, "find_properties_file")
+ @patch("__builtin__.open")
+ @patch("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()
+ self.assertEquals(user, "dummy_user")
+ # Testing with undefined user
+ properties_mock.return_value.__getitem__.return_value = None
+ user = ambari_server.read_ambari_user()
+ self.assertEquals(user, None)
+
+ @patch.object(ambari_server, "set_file_permissions")
+ def test_adjust_directory_permissions(self, set_file_permissions_mock):
+ ambari_server.adjust_directory_permissions("user")
+ self.assertTrue(len(set_file_permissions_mock.call_args_list) ==
+ len(ambari_server.NR_ADJUST_OWNERSHIP_LIST))
+
+
+ @patch("os.path.exists")
@patch.object(ambari_server, "run_os_command")
- def test_check_iptables(self, run_os_command_mock):
+ @patch.object(ambari_server, "print_warning_msg")
+ def test_set_file_permissions(self, print_warning_msg_mock,
+ run_os_command_mock, exists_mock):
- out = StringIO.StringIO()
- sys.stdout = out
+ # Testing not existent file scenario
+ exists_mock.return_value = False
+ ambari_server.set_file_permissions("dummy-file", "dummy-mod",
+ "dummy-user", "dummy-group")
+ self.assertFalse(run_os_command_mock.called)
+ self.assertTrue(print_warning_msg_mock.called)
+
+ run_os_command_mock.reset_mock()
+ print_warning_msg_mock.reset_mock()
+
+ # 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",
+ "dummy-user", "dummy-group")
+ self.assertTrue(len(run_os_command_mock.call_args_list) == 2)
+ self.assertFalse(print_warning_msg_mock.called)
+
+ run_os_command_mock.reset_mock()
+ print_warning_msg_mock.reset_mock()
+
+ # Testing first command fail
+ run_os_command_mock.side_effect = [(1, "", ""), (0, "", "")]
+ ambari_server.set_file_permissions("dummy-file", "dummy-mod",
+ "dummy-user", "dummy-group")
+ self.assertTrue(len(run_os_command_mock.call_args_list) == 2)
+ self.assertTrue(print_warning_msg_mock.called)
+
+ run_os_command_mock.reset_mock()
+ print_warning_msg_mock.reset_mock()
+
+ # Testing second command fail
+ run_os_command_mock.side_effect = [(0, "", ""), (1, "", "")]
+ ambari_server.set_file_permissions("dummy-file", "dummy-mod",
+ "dummy-user", "dummy-group")
+ self.assertTrue(len(run_os_command_mock.call_args_list) == 2)
+ self.assertTrue(print_warning_msg_mock.called)
+
+ run_os_command_mock.reset_mock()
+ 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")
+ 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
+
+ # Testing scenario: existing group, existing user
+ run_os_command_mock.side_effect = [(9, "", ""), (9, "", ""), (0, "", "")]
+ result = ambari_server.create_custom_user()
+ self.assertTrue(len(run_os_command_mock.call_args_list) == 3)
+ self.assertEquals(result, (0, user))
+
+ run_os_command_mock.reset_mock()
+
+ # Testing scenario: absent group, absent user
+ run_os_command_mock.side_effect = [(0, "", ""), (0, "", "")]
+ result = ambari_server.create_custom_user()
+ self.assertTrue(len(run_os_command_mock.call_args_list) == 2)
+ self.assertEquals(result, (0, user))
+ run_os_command_mock.reset_mock()
+
+ # Testing scenario: os command fail
+ run_os_command_mock.side_effect = [(1, "", "")]
+ result = ambari_server.create_custom_user()
+ self.assertTrue(len(run_os_command_mock.call_args_list) == 1)
+ self.assertEquals(result, (1, None))
+
+ run_os_command_mock.reset_mock()
+
+
+ @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")
+ 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):
+
+ # Scenario: user is already defined
+ read_ambari_user_mock.return_value = "dummy-user"
+ result = ambari_server.check_ambari_user()
+ self.assertFalse(get_YN_input_mock.called)
+ self.assertFalse(write_property_mock.called)
+ self.assertTrue(adjust_directory_permissions_mock.called)
+ self.assertEqual(result, 0)
+
+ get_YN_input_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()
+ self.assertTrue(get_YN_input_mock.called)
+ self.assertTrue(create_custom_user_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)
+ self.assertEqual(result, 0)
+
+ get_YN_input_mock.reset_mock()
+ create_custom_user_mock.reset_mock()
+ write_property_mock.reset_mock()
+ adjust_directory_permissions_mock.reset_mock()
+
+ # Scenario: user is not defined (setup process), user creation failed
+
+ 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()
+ self.assertTrue(get_YN_input_mock.called)
+ self.assertTrue(create_custom_user_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()
+ 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()
+ self.assertTrue(get_YN_input_mock.called)
+ self.assertFalse(create_custom_user_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("__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):
+ search_file_mock.return_value = "/etc/ambari-server/conf/ambari.properties"
+ open_mock.return_value = MagicMock()
+ ambari_server.store_password_file("password", "passfile")
+ self.assertTrue(set_file_permissions_mock.called)
+
+
+ @patch.object(ambari_server, "run_os_command")
+ def test_check_iptables(self, run_os_command_mock):
run_os_command_mock.return_value = (1, "test", "")
rcode, info = ambari_server.check_iptables()
self.assertEqual(1, rcode)
@@ -589,8 +763,6 @@ class TestAmbariServer(TestCase):
rcode = ambari_server.check_iptables()
self.assertEqual(0, rcode)
- sys.stdout = sys.__stdout__
-
def test_dlprogress(self):
@@ -637,27 +809,24 @@ class TestAmbariServer(TestCase):
@patch.object(ambari_server, "print_info_msg")
@patch.object(ambari_server, "get_JAVA_HOME")
@patch.object(ambari_server, "get_ambari_properties")
- def test_download_jdk(self, get_ambari_properties_mock,
- get_JAVA_HOME_mock, print_info_msg_mock,
- write_property_mock, run_os_command_mock,
- get_YN_input_mock, track_jdk_mock, path_existsMock,
+ def test_download_jdk(self, get_ambari_properties_mock, get_JAVA_HOME_mock, print_info_msg_mock,
+ write_property_mock, run_os_command_mock, get_YN_input_mock, track_jdk_mock,
+ path_existsMock,
path_isfileMock, statMock):
-
- out = StringIO.StringIO()
- sys.stdout = out
-
args = MagicMock()
args.java_home = "somewhere"
path_existsMock.return_value = False
get_JAVA_HOME_mock.return_value = False
get_ambari_properties_mock.return_value = -1
- rcode = ambari_server.download_jdk(args)
-
- self.assertEqual(-1, rcode)
- self.assertTrue(get_ambari_properties_mock.called)
+ try:
+ ambari_server.download_jdk(args)
+ self.fail("Should throw exception because of not found ambari.properties")
+ except FatalException:
+ # Expected
+ self.assertTrue(get_ambari_properties_mock.called)
+ pass
- #search_file_mock.return_value = "something"
get_JAVA_HOME_mock.return_value = True
path_existsMock.return_value = True
rcode = ambari_server.download_jdk(args)
@@ -672,15 +841,23 @@ class TestAmbariServer(TestCase):
p = MagicMock()
get_ambari_properties_mock.return_value = p
p.__getitem__.side_effect = KeyError("test exception")
- rcode = ambari_server.download_jdk(args)
- self.assertEqual(-1, rcode)
+ try:
+ ambari_server.download_jdk(args)
+ self.fail("Should throw exception")
+ except FatalException:
+ # Expected
+ pass
p.__getitem__.return_value = "somewhere"
p.__getitem__.side_effect = None
path_existsMock.return_value = False
run_os_command_mock.return_value = (0, "Wrong out", None)
- rcode = ambari_server.download_jdk(args)
- self.assertEqual(-1, rcode)
+ try:
+ ambari_server.download_jdk(args)
+ self.fail("Should throw exception")
+ except FatalException:
+ # Expected
+ pass
ambari_server.JDK_INSTALL_DIR = os.getcwd()
get_YN_input_mock.return_value = True
@@ -693,9 +870,6 @@ class TestAmbariServer(TestCase):
rcode = ambari_server.download_jdk(args)
self.assertEqual(0, rcode)
- sys.stdout = sys.__stdout__
-
-
@patch.object(ambari_server, "run_os_command")
def test_get_postgre_status(self, run_os_command_mock):
@@ -709,31 +883,24 @@ class TestAmbariServer(TestCase):
self.assertEqual(None, result)
+ @patch("time.sleep")
@patch("subprocess.Popen")
- @patch.object(ambari_server, 'run_os_command')
+ @patch.object(ambari_server, "run_os_command")
@patch.object(ambari_server, "get_postgre_status")
- def test_check_postgre_up(self, get_postgre_status_mock,
- run_os_command_method, popen_mock):
-
- out = StringIO.StringIO()
- sys.stdout = out
-
+ def test_check_postgre_up(self, get_postgre_status_mock, run_os_command_mock,
+ popen_mock, sleep_mock):
p = MagicMock()
p.poll.return_value = 0
popen_mock.return_value = p
- get_postgre_status_mock.return_value = ambari_server.PG_STATUS_RUNNING
- run_os_command_method.return_value = (0, None, None)
-
+ run_os_command_mock.return_value = (0, None, None)
rcode = ambari_server.check_postgre_up()
self.assertEqual(0, rcode)
- get_postgre_status_mock.return_value = None
p.poll.return_value = 4
+ get_postgre_status_mock.return_value = None
rcode = ambari_server.check_postgre_up()
self.assertEqual(4, rcode)
- sys.stdout = sys.__stdout__
-
@patch("platform.linux_distribution")
@@ -743,13 +910,13 @@ class TestAmbariServer(TestCase):
@patch.object(ambari_server, "get_ambari_properties")
@patch.object(ambari_server, "write_property")
@patch.object(ambari_server, "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):
-
+ 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()
self.assertEqual(-1, rcode)
-
+
p = MagicMock()
p[ambari_server.OS_TYPE_PROPERTY] = 'somevalue'
get_ambari_properties_mock.return_value = p
@@ -775,10 +942,6 @@ class TestAmbariServer(TestCase):
@patch.object(ambari_server, "get_conf_dir")
def test_get_JAVA_HOME(self, get_conf_dir_mock, search_file_mock,
Properties_mock, openMock):
-
- out = StringIO.StringIO()
- sys.stdout = out
-
openMock.side_effect = Exception("exception")
result = ambari_server.get_JAVA_HOME()
self.assertEqual(None, result)
@@ -791,17 +954,10 @@ class TestAmbariServer(TestCase):
result = ambari_server.get_JAVA_HOME()
self.assertEqual(expected, result)
- sys.stdout = sys.__stdout__
-
-
@patch("glob.glob")
@patch.object(ambari_server, "get_JAVA_HOME")
def test_find_jdk(self, get_JAVA_HOME_mock, globMock):
-
- out = StringIO.StringIO()
- sys.stdout = out
-
get_JAVA_HOME_mock.return_value = "somewhere"
result = ambari_server.find_jdk()
self.assertEqual("somewhere", result)
@@ -815,8 +971,6 @@ class TestAmbariServer(TestCase):
result = ambari_server.find_jdk()
self.assertNotEqual(None, result)
- sys.stdout = sys.__stdout__
-
@patch.object(ambari_server, "configure_os_settings")
@patch.object(ambari_server, "download_jdk")
@@ -824,19 +978,33 @@ class TestAmbariServer(TestCase):
@patch.object(ambari_server, "setup_db")
@patch.object(ambari_server, "check_postgre_up")
@patch.object(ambari_server, "check_iptables")
+ @patch.object(ambari_server, "check_ambari_user")
+ @patch.object(ambari_server, "check_jdbc_drivers")
@patch.object(ambari_server, "check_selinux")
@patch.object(ambari_server, "setup_remote_db")
@patch.object(ambari_server, "store_remote_properties")
- def test_setup(self, store_remote_properties_mock, setup_remote_db_mock, check_selinux_mock, check_iptables_mock,
+ @patch.object(ambari_server, "is_root")
+ def test_setup(self, is_root_mock, store_remote_properties_mock, setup_remote_db_mock, check_selinux_mock,
+ check_jdbc_drivers_mock, check_ambari_user_mock, check_iptables_mock,
check_postgre_up_mock, setup_db_mock, configure_postgres_mock,
download_jdk_mock, configure_os_settings_mock, ):
-
- out = StringIO.StringIO()
- sys.stdout = out
-
args = MagicMock()
+ # Testing call under non-root
+ is_root_mock.return_value = False
+ try:
+ ambari_server.setup(args)
+ self.fail("Should throw exception")
+ except FatalException as fe:
+ # Expected
+ self.assertTrue("root-level" in fe.reason)
+ pass
+
+ # Testing calls under root
+ is_root_mock.return_value = True
check_selinux_mock.return_value = 0
+ check_ambari_user_mock.return_value = 0
+ check_jdbc_drivers_mock.return_value = 0
check_iptables_mock.return_value = (0, "other")
check_postgre_up_mock.return_value = 0
setup_db_mock.return_value = 0
@@ -846,10 +1014,9 @@ class TestAmbariServer(TestCase):
configure_os_settings_mock.return_value = 0
store_remote_properties_mock.return_value = 0
result = ambari_server.setup(args)
- self.assertEqual(None, result)
-
- sys.stdout = sys.__stdout__
+ self.assertEqual(None, result)
+ self.assertTrue(check_ambari_user_mock.called)
@patch.object(ambari_server, "get_YN_input")
@@ -858,44 +1025,59 @@ class TestAmbariServer(TestCase):
@patch.object(ambari_server, "run_os_command")
@patch.object(ambari_server, "configure_database_username_password")
@patch.object(ambari_server, "parse_properties_file")
- def test_reset(self, parse_properties_file_mock, configure_database_username_password_mock,
+ @patch.object(ambari_server, "is_root")
+ def test_reset(self, is_root_mock, parse_properties_file_mock, configure_database_username_password_mock,
run_os_command_mock, print_info_msg_mock,
setup_db_mock, get_YN_inputMock):
- out = StringIO.StringIO()
- sys.stdout = out
parse_properties_file_mock.return_value = 0
-
args = MagicMock()
args.persistence_type = "local"
get_YN_inputMock.return_value = False
- rcode = ambari_server.reset(args)
- self.assertEqual(-1, rcode)
+
+ # Testing call under non-root
+ is_root_mock.return_value = False
+ try:
+ ambari_server.reset(args)
+ self.fail("Should throw exception")
+ except FatalException as fe:
+ # Expected
+ self.assertTrue("root-level" in fe.reason)
+ pass
+
+ # Testing calls under root
+ is_root_mock.return_value = True
+ try:
+ ambari_server.reset(args)
+ self.fail("Should throw exception")
+ except FatalException as fe:
+ # Expected
+ self.assertFalse("root-level" in fe.reason)
+ pass
get_YN_inputMock.return_value = True
run_os_command_mock.return_value = (1, None, None)
- rcode = ambari_server.reset(args)
- self.assertEqual(1, rcode)
+ try:
+ ambari_server.reset(args)
+ self.fail("Should throw exception")
+ except FatalException:
+ # Expected
+ pass
run_os_command_mock.return_value = (0, None, None)
- rcode = ambari_server.reset(args)
- self.assertEqual(None, rcode)
+ ambari_server.reset(args)
self.assertTrue(setup_db_mock.called)
- sys.stdout = sys.__stdout__
-
-
@patch.object(ambari_server, "setup_db")
@patch.object(ambari_server, "print_info_msg")
@patch.object(ambari_server, "run_os_command")
@patch.object(ambari_server, "parse_properties_file")
- def test_silent_reset(self, parse_properties_file_mock,
+ @patch.object(ambari_server, "is_root")
+ def test_silent_reset(self, is_root_mock, parse_properties_file_mock,
run_os_command_mock, print_info_msg_mock,
setup_db_mock):
-
- out = StringIO.StringIO()
- sys.stdout = out
+ is_root_mock.return_value = True
args = MagicMock()
ambari_server.SILENT = True
@@ -912,8 +1094,6 @@ class TestAmbariServer(TestCase):
self.assertEqual(None, rcode)
self.assertTrue(setup_db_mock.called)
- sys.stdout = sys.__stdout__
-
@patch("os.kill")
@@ -927,45 +1107,162 @@ class TestAmbariServer(TestCase):
@patch.object(ambari_server, "check_postgre_up")
@patch.object(ambari_server, "check_iptables")
@patch.object(ambari_server, "parse_properties_file")
- def test_start(self, parse_properties_file_mock, check_iptables_mock, check_postgre_up_mock,
+ @patch.object(ambari_server, "read_ambari_user")
+ @patch.object(ambari_server, "is_root")
+ @patch("getpass.getuser")
+ @patch("os.chdir")
+ def test_start(self, chdir_mock, getuser_mock, is_root_mock, read_ambari_user_mock,
+ parse_properties_file_mock, check_iptables_mock, check_postgre_up_mock,
print_error_msg_mock, find_jdk_mock, get_conf_dir_mock,
print_info_msg_mock, popenMock, openMock, pexistsMock,
killMock):
-
- out = StringIO.StringIO()
- sys.stdout = out
-
args = MagicMock()
+
f = MagicMock()
f.readline.return_value = 42
openMock.return_value = f
+
+ # Checking "server is running"
pexistsMock.return_value = True
- rcode = ambari_server.start(args)
+ try:
+ ambari_server.start(args)
+ self.fail("Should fail with 'Server is running'")
+ except FatalException:
+ # Expected
+ pass
self.assertTrue(killMock.called)
- self.assertEqual(None, rcode)
pexistsMock.return_value = False
+
+ # Checking situation when ambari user is not set up
+ read_ambari_user_mock.return_value = None
+ try:
+ ambari_server.start(args)
+ self.fail("Should fail with 'Can not detect a system user for Ambari'")
+ except FatalException as e:
+ # Expected
+ self.assertTrue('Can not detect a system user' in e.reason)
+
+ # Checking start from non-root when current user is not the same as a
+ # custom user
+ read_ambari_user_mock.return_value = "dummy-user"
+ getuser_mock.return_value = "non_custom_user"
+ is_root_mock.return_value = False
+ try:
+ ambari_server.start(args)
+ self.fail("Should fail with 'Can not start ambari-server as user...'")
+ except FatalException as e:
+ # Expected
+ self.assertTrue('Can not start ambari-server as user' in e.reason)
+
+ # Checking "jdk not found"
+ is_root_mock.return_value = True
find_jdk_mock.return_value = None
- rcode = ambari_server.start(args)
- self.assertEqual(-1, rcode)
+ try:
+ ambari_server.start(args)
+ self.fail("Should fail with 'No JDK found'")
+ except FatalException as e:
+ # Expected
+ self.assertTrue('No JDK found' in e.reason)
find_jdk_mock.return_value = "somewhere"
+
+
+ ## Testing workflow under root
+ is_root_mock.return_value = True
+
+ # Remote DB
args.persistence_type="remote"
- check_postgre_up_mock.return_value = 0
check_iptables_mock.return_value = (0, None)
- p = MagicMock()
- popenMock.return_value = p
- rcode = ambari_server.start(args)
- self.assertEqual(None, rcode)
+ try:
+ ambari_server.start(args)
+ except FatalException as e:
+ # Ignored
+ pass
+
+ self.assertFalse('Unable to start PostgreSQL server' in e.reason)
self.assertFalse(check_postgre_up_mock.called)
- self.assertTrue(f.write.called)
+ check_postgre_up_mock.reset_mock()
+
+ # Local DB
args.persistence_type="local"
- rcode = ambari_server.start(args)
- self.assertEqual(None, rcode)
- self.assertTrue(check_postgre_up_mock.called)
- sys.stdout = sys.__stdout__
+ # case: postgres failed to start
+ check_postgre_up_mock.return_value = 1
+ try:
+ ambari_server.start(args)
+ self.fail("Should fail with 'Unable to start PostgreSQL server'")
+ except FatalException as e:
+ # Expected
+ self.assertTrue('Unable to start PostgreSQL server' in e.reason)
+ self.assertTrue(check_postgre_up_mock.called)
+
+ # case: iptables failed to stop
+ check_postgre_up_mock.return_value = 0
+ check_iptables_mock.return_value = (1, ambari_server.IP_TBLS_ENABLED)
+ try:
+ ambari_server.start(args)
+ self.fail("Should fail with 'Failed to stop iptables'")
+ except FatalException as e:
+ # Expected
+ self.assertTrue('Failed to stop iptables' in e.reason)
+
+ check_iptables_mock.return_value = (0, None)
+ # Case: custom user is "root"
+ read_ambari_user_mock.return_value = "root"
+ ambari_server.start(args)
+ self.assertTrue(popenMock.called)
+ popen_arg = popenMock.call_args[0][0]
+ self.assertTrue(popen_arg[0] == "/bin/sh")
+ popenMock.reset_mock()
+ # Case: custom user is not "root"
+ read_ambari_user_mock.return_value = "not-root-user"
+ ambari_server.start(args)
+ self.assertTrue(chdir_mock.called)
+ self.assertTrue(popenMock.called)
+ popen_arg = popenMock.call_args[0][0]
+ self.assertTrue(popen_arg[0] == "/bin/su")
+ check_postgre_up_mock.reset_mock()
+
+ popenMock.reset_mock()
+
+ ## Testing workflow under non-root
+ is_root_mock.return_value = False
+ read_ambari_user_mock.return_value = "not-root-user"
+ getuser_mock.return_value = read_ambari_user_mock.return_value
+ # Local DB
+ args.persistence_type="local"
+
+ ambari_server.start(args)
+
+ self.assertFalse(check_postgre_up_mock.called)
+
+ # Remote DB
+ args.persistence_type="remote"
+
+ ambari_server.start(args)
+
+ self.assertFalse(check_postgre_up_mock.called)
+
+ # Checking call
+ check_iptables_mock.reset_mock()
+ check_iptables_mock.return_value = (0, None)
+ ambari_server.start(args)
+ self.assertTrue(popenMock.called)
+ popen_arg = popenMock.call_args[0][0]
+ self.assertTrue(popen_arg[0] == "/bin/sh")
+ self.assertFalse(check_iptables_mock.called)
+
+ # Test start under wrong user
+ read_ambari_user_mock.return_value = "not-root-user"
+ getuser_mock.return_value = "non_custom_user"
+ try:
+ ambari_server.start(args)
+ self.fail("Can not start ambari-server as user non_custom_user.")
+ except FatalException as e:
+ # Expected
+ self.assertTrue('Can not start ambari-server as user' in e.reason)
@@ -977,15 +1274,11 @@ class TestAmbariServer(TestCase):
@patch.object(ambari_server, "print_info_msg")
def test_stop(self, print_info_msg_mock, gpidMock, removeMock,
killMock, pexistsMock, openMock):
-
pexistsMock.return_value = True
f = MagicMock()
f.readline.return_value = "42"
openMock.return_value = f
- out = StringIO.StringIO()
- sys.stdout = out
-
ambari_server.stop(None)
self.assertTrue(f.readline.called)
@@ -994,12 +1287,83 @@ class TestAmbariServer(TestCase):
self.assertTrue(f.close.called)
self.assertTrue(removeMock.called)
- sys.stdout = sys.__stdout__
+ @patch.object(ambari_server, "configure_database_username_password")
+ @patch.object(ambari_server, "run_os_command")
+ @patch.object(ambari_server, "is_root")
+ def test_upgrade_stack(self, is_root_mock, run_os_command_mock,
+ configure_postgres_username_password_mock):
+ args = MagicMock()
+ # Testing call under non-root
+ is_root_mock.return_value = False
+ try:
+ ambari_server.upgrade_stack(args, 'HDP-2.0')
+ self.fail("Should throw exception")
+ except FatalException as fe:
+ # Expected
+ self.assertTrue("root-level" in fe.reason)
+ pass
+
+ # Testing calls under root
+ is_root_mock.return_value = True
+ run_os_command_mock.return_value = (0, '', '')
+ ambari_server.upgrade_stack(args, 'HDP-2.0')
+
+ self.assertTrue(configure_postgres_username_password_mock.called)
+ self.assertTrue(run_os_command_mock.called)
- def test_print_info_msg(self):
+ @patch.object(ambari_server, "adjust_directory_permissions")
+ @patch.object(ambari_server, "print_warning_msg")
+ @patch.object(ambari_server, "read_ambari_user")
+ @patch.object(ambari_server, "check_db_consistency")
+ @patch.object(ambari_server, "execute_db_script")
+ @patch.object(ambari_server, "check_postgre_up")
+ @patch.object(ambari_server, "update_ambari_properties")
+ @patch.object(ambari_server, "parse_properties_file")
+ @patch.object(ambari_server, "is_root")
+ def test_upgrade(self, is_root_mock, parse_properties_file_mock, update_ambari_properties_mock,
+ check_postgre_up_mock, execute_db_script_mock,
+ check_db_consistency_mock, read_ambari_user_mock,
+ print_warning_msg_mock, adjust_directory_permissions_mock):
+
+ args = MagicMock()
+ args.upgrade_script_file = "/var/lib/"\
+ "ambari-server/resources/upgrade/ddl/"\
+ "Ambari-DDL-Postgres-UPGRADE-1.3.0.sql"
+ update_ambari_properties_mock.return_value = 0
+ check_postgre_up_mock.return_value = 0
+ execute_db_script_mock.return_value = 0
+ check_db_consistency_mock.return_value = 0
+
+ # Testing call under non-root
+ is_root_mock.return_value = False
+ try:
+ ambari_server.upgrade(args)
+ self.fail("Should throw exception")
+ except FatalException as fe:
+ # Expected
+ self.assertTrue("root-level" in fe.reason)
+ pass
+
+ # Testing calls under root
+ is_root_mock.return_value = True
+
+ # Testing with undefined custom user
+ read_ambari_user_mock.return_value = None
+ ambari_server.upgrade(args)
+ self.assertTrue(print_warning_msg_mock.called)
+ warning_args = print_warning_msg_mock.call_args[0][0]
+ self.assertTrue("custom ambari user" in warning_args)
+
+ # Testing with defined custom user
+ read_ambari_user_mock.return_value = "ambari-custom-user"
+ ambari_server.upgrade(args)
+ self.assertTrue(adjust_directory_permissions_mock.called)
+
+
+ def test_print_info_msg(self):
out = StringIO.StringIO()
sys.stdout = out
@@ -1044,23 +1408,26 @@ class TestAmbariServer(TestCase):
self.assertTrue(get_choice_string_input_mock.called)
self.assertEqual(4, len(get_choice_string_input_mock.call_args_list[0][0]))
+
@patch.object(ambari_server, "get_conf_dir")
- def test_update_ambari_properties(self, get_conf_dir_mock):
+ @patch("os.rename") # We want to remove temp file after test
+ def test_update_ambari_properties(self, rename_mock, get_conf_dir_mock):
properties = ["server.jdbc.user.name=ambari-server\n",
"server.jdbc.user.passwd=/etc/ambari-server/conf/password.dat\n",
"java.home=/usr/jdk64/jdk1.6.0_31\n",
- "server.os_type=redhat6\n"]
+ "server.os_type=redhat6\n",
+ "ambari.user=ambari\n"]
NEW_PROPERTY = 'some_new_property=some_value\n'
CHANGED_VALUE_PROPERTY = 'server.os_type=should_not_overwrite_value\n'
get_conf_dir_mock.return_value = ""
- tf1 = tempfile.NamedTemporaryFile()
- tf2 = tempfile.NamedTemporaryFile()
- ambari_server.AMBARI_PROPERTIES_RPMSAVE_FILE = tf1.name
- ambari_server.AMBARI_PROPERTIES_FILE = tf2.name
+ (tf1, fn1) = tempfile.mkstemp()
+ (tf2, fn2) = tempfile.mkstemp()
+ ambari_server.AMBARI_PROPERTIES_RPMSAVE_FILE = fn1
+ ambari_server.AMBARI_PROPERTIES_FILE = fn2
with open(ambari_server.AMBARI_PROPERTIES_FILE, "w") as f:
f.write(NEW_PROPERTY)
@@ -1086,43 +1453,47 @@ class TestAmbariServer(TestCase):
if CHANGED_VALUE_PROPERTY in ambari_properties_content:
self.fail()
- pass
+ self.assertTrue(rename_mock.called)
+
+
+ os.unlink(fn1)
+ # Command should not fail if *.rpmsave file is missing
+ result = ambari_server.update_ambari_properties()
+ self.assertEquals(result, 0)
+
+ os.unlink(fn2)
@patch("sys.exit")
- @patch.object(ambari_server, "download_jdk")
@patch.object(ambari_server, "get_db_cli_tool")
@patch.object(ambari_server, "store_remote_properties")
@patch.object(ambari_server, "is_local_database")
@patch.object(ambari_server, "check_iptables")
@patch.object(ambari_server, "check_jdbc_drivers")
- def test_setup_remote_db_wo_client(self, check_jdbc_drivers_mock, check_iptables_mock, is_local_db_mock,
- store_remote_properties_mock, get_db_cli_tool_mock, download_jdk_mock, exit_mock):
-
- out = StringIO.StringIO()
- sys.stdout = out
-
+ @patch.object(ambari_server, "is_root")
+ @patch.object(ambari_server, "check_ambari_user")
+ @patch.object(ambari_server, "download_jdk")
+ @patch.object(ambari_server, "configure_os_settings")
+ def test_setup_remote_db_wo_client(self, configure_os_settings_mock, download_jdk_mock, check_ambari_user_mock, is_root_mock, check_jdbc_drivers_mock, check_iptables_mock, is_local_db_mock,
+ store_remote_properties_mock, get_db_cli_tool_mock, exit_mock):
args = MagicMock()
-
+ is_root_mock.return_value = True
is_local_db_mock.return_value = False
check_iptables_mock.return_value = (0, "other")
store_remote_properties_mock.return_value = 0
get_db_cli_tool_mock.return_value = None
check_jdbc_drivers_mock.return_value=0
-
- failed = False
- result = None
+ check_ambari_user_mock.return_value = 0
+ download_jdk_mock.return_value = 0
+ configure_os_settings_mock.return_value = 0
try:
- result = ambari_server.setup(args)
- except Exception:
- failed = True
+ ambari_server.setup(args)
+ self.fail("Should throw exception")
+ except FatalException as fe:
+ # Expected
+ self.assertTrue("The cli was not found" in fe.reason)
- self.assertEqual(False, failed)
- self.assertEqual(None, result)
- self.assertEqual(True, exit_mock.called)
-
- sys.stdout = sys.__stdout__
@patch.object(ambari_server, "parse_properties_file")
@patch.object(ambari_server, "get_db_cli_tool")
@@ -1130,21 +1501,22 @@ class TestAmbariServer(TestCase):
@patch.object(ambari_server, "get_YN_input")
@patch.object(ambari_server, "setup_db")
@patch.object(ambari_server, "run_os_command")
- def test_reset_remote_db_wo_client(self, run_os_command_mock, setup_db_mock,
+ @patch.object(ambari_server, "is_root")
+ def test_reset_remote_db_wo_client(self, is_root_mock, run_os_command_mock, setup_db_mock,
get_YN_inputMock, print_error_msg_mock, get_db_cli_tool_mock, parse_properties_file_mock):
-
- out = StringIO.StringIO()
- sys.stdout = out
-
args = MagicMock()
get_YN_inputMock.return_value = True
run_os_command_mock.return_value = (0, None, None)
args.persistence_type="remote"
get_db_cli_tool_mock.return_value = None
- rcode = ambari_server.reset(args)
- self.assertEqual(-1, rcode)
-
- sys.stdout = sys.__stdout__
+ is_root_mock.return_value = True
+ try:
+ ambari_server.reset(args)
+ self.fail("Should throw exception")
+ except FatalException as fe:
+ # Expected
+ self.assertTrue("Client wasn't found" in fe.reason)
+ pass
@patch.object(ambari_server, "get_ambari_properties")
@@ -1152,17 +1524,13 @@ class TestAmbariServer(TestCase):
@patch.object(ambari_server, "copy_files")
@patch('__builtin__.raw_input')
def test_check_jdbc_drivers(self, raw_input_mock, copy_files_mock, find_jdbc_driver_mock, get_ambari_properties_mock):
-
- out = StringIO.StringIO()
- sys.stdout = out
-
args = MagicMock()
# Check positive scenario
drivers_list = ['driver_file']
resources_dir = '/tmp'
- get_ambari_properties_mock.return_value = {ambari_server.RESOURCES_DIR_KEY : resources_dir}
+ get_ambari_properties_mock.return_value = {ambari_server.RESOURCES_DIR_PROPERTY : resources_dir}
find_jdbc_driver_mock.return_value = drivers_list
rcode = ambari_server.check_jdbc_drivers(args)
@@ -1181,18 +1549,16 @@ class TestAmbariServer(TestCase):
#Ensure user was asked to provide drivers
self.assertTrue(raw_input_mock.called)
- sys.stdout = sys.__stdout__
-
-
- @patch.object(ambari_server, "search_file")
- def test_get_ambari_properties(self, search_file_mock):
- search_file_mock.return_value = None
+ @patch.object(ambari_server, "find_properties_file")
+ def test_get_ambari_properties(self, find_properties_file_mock):
+
+ find_properties_file_mock.return_value = None
rcode = ambari_server.get_ambari_properties()
self.assertEqual(rcode, -1)
tf1 = tempfile.NamedTemporaryFile()
- search_file_mock.return_value = tf1.name
+ find_properties_file_mock.return_value = tf1.name
prop_name='name'
prop_value='val'
@@ -1203,8 +1569,7 @@ class TestAmbariServer(TestCase):
properties = ambari_server.get_ambari_properties()
self.assertEqual(properties[prop_name], prop_value)
-
- sys.stdout = sys.__stdout__
+
@patch.object(ambari_server, "get_ambari_properties")
@patch.object(ambari_server, "find_jdbc_driver")
@@ -1220,87 +1585,88 @@ class TestAmbariServer(TestCase):
sys.stdout = out
args = MagicMock()
-
+
# Check positive scenario
drivers_list = ['driver_file']
resources_dir = '/tmp'
-
- get_ambari_properties_mock.return_value = {ambari_server.RESOURCES_DIR_KEY : resources_dir}
+
+ get_ambari_properties_mock.return_value = {ambari_server.RESOURCES_DIR_PROPERTY : resources_dir}
find_jdbc_driver_mock.return_value = drivers_list
-
+
args.database = "oracle"
-
+
rcode = ambari_server.check_jdbc_drivers(args)
-
+
self.assertEqual(0, rcode)
copy_files_mock.assert_called_with(drivers_list, resources_dir)
-
+
# Check negative scenarios
# Silent option, no drivers
ambari_server.SILENT = True
-
+
find_jdbc_driver_mock.return_value = -1
-
+
rcode = ambari_server.check_jdbc_drivers(args)
-
+
self.assertTrue(print_error_msg_mock.called)
self.assertTrue(exit_mock.called)
-
+
# Non-Silent option, no drivers
ambari_server.SILENT = False
-
+
find_jdbc_driver_mock.return_value = -1
-
+
rcode = ambari_server.check_jdbc_drivers(args)
-
+
self.assertTrue(exit_mock.called)
self.assertTrue(print_error_msg_mock.called)
-
+
# Non-Silent option, no drivers at first ask, present drivers after that
-
+
find_jdbc_driver_mock.side_effect = [-1, drivers_list]
-
+
rcode = ambari_server.check_jdbc_drivers(args)
-
+
self.assertEqual(0, rcode)
copy_files_mock.assert_called_with(drivers_list, resources_dir)
-
+
# Non-Silent option, no drivers at first ask, present drivers after that
find_jdbc_driver_mock.reset()
find_jdbc_driver_mock.side_effect = [-1, -1]
-
+
rcode = ambari_server.check_jdbc_drivers(args)
-
+
self.assertTrue(exit_mock.called)
self.assertTrue(print_error_msg_mock.called)
-
-
+
+
sys.stdout = sys.__stdout__
-
-
- @patch.object(ambari_server, "search_file")
- def test_get_ambari_properties(self, search_file_mock):
- search_file_mock.return_value = None
+
+ @patch.object(ambari_server, "find_properties_file")
+ def test_get_ambari_properties(self, find_properties_file):
+
+ find_properties_file.return_value = None
rcode = ambari_server.get_ambari_properties()
self.assertEqual(rcode, -1)
-
+
tf1 = tempfile.NamedTemporaryFile()
- search_file_mock.return_value = tf1.name
+ find_properties_file.return_value = tf1.name
prop_name='name'
prop_value='val'
-
+
with open(tf1.name, 'w') as fout:
fout.write(prop_name + '=' + prop_value)
fout.close()
properties = ambari_server.get_ambari_properties()
-
+
self.assertEqual(properties[prop_name], prop_value)
self.assertEqual(properties.fileName, os.path.abspath(tf1.name))
-
+
sys.stdout = sys.__stdout__
+
@patch.object(ambari_server, "search_file")
def test_parse_properties_file(self, search_file_mock):
@@ -1321,8 +1687,6 @@ class TestAmbariServer(TestCase):
ambari_server.parse_properties_file(args)
self.assertEquals(args.persistence_type, "remote")
- sys.stdout = sys.__stdout__
-
def get_sample(self, sample):
"""