How to use rp_mock method in Lemoncheesecake

Best Python code snippet using lemoncheesecake

TestAmbariServer.py

Source:TestAmbariServer.py Github

copy

Full Screen

1'''2Licensed to the Apache Software Foundation (ASF) under one3or more contributor license agreements. See the NOTICE file4distributed with this work for additional information5regarding copyright ownership. The ASF licenses this file6to you under the Apache License, Version 2.0 (the7"License"); you may not use this file except in compliance8with the License. You may obtain a copy of the License at9 http://www.apache.org/licenses/LICENSE-2.010Unless required by applicable law or agreed to in writing, software11distributed under the License is distributed on an "AS IS" BASIS,12WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.13See the License for the specific language governing permissions and14limitations under the License.15'''16from stacks.utils.RMFTestCase import *17import sys18import os19import datetime20import errno21import json22from mock.mock import patch, MagicMock, create_autospec, call23import operator24from optparse import OptionParser25import platform26import re27import shutil28import signal29import stat30import StringIO31import tempfile32from unittest import TestCase33from only_for_platform import get_platform, not_for_platform, only_for_platform, os_distro_value, PLATFORM_LINUX, PLATFORM_WINDOWS34if get_platform() != PLATFORM_WINDOWS:35 from pwd import getpwnam36# We have to use this import HACK because the filename contains a dash37with patch("platform.linux_distribution", return_value = os_distro_value):38 with patch("os.symlink"):39 with patch("__builtin__.open"):40 with patch("glob.glob", return_value = ['/etc/init.d/postgresql-9.3']):41 _ambari_server_ = __import__('ambari-server')42 from ambari_commons.firewall import Firewall43 from ambari_commons.os_check import OSCheck, OSConst44 from ambari_commons.os_family_impl import OsFamilyImpl, OsFamilyFuncImpl45 from ambari_commons.exceptions import FatalException, NonFatalException46 from ambari_commons.logging_utils import get_verbose, set_verbose, get_silent, set_silent, get_debug_mode, \47 print_info_msg, print_warning_msg, print_error_msg48 from ambari_commons.os_utils import run_os_command, search_file, set_file_permissions, remove_file, copy_file, \49 is_valid_filepath50 from ambari_server.dbConfiguration import DBMSConfigFactory, check_jdbc_drivers51 from ambari_server.dbConfiguration_linux import PGConfig, LinuxDBMSConfig, OracleConfig52 from ambari_server.properties import Properties53 from ambari_server.resourceFilesKeeper import ResourceFilesKeeper, KeeperException54 from ambari_server.serverConfiguration import configDefaults, \55 check_database_name_property, OS_FAMILY_PROPERTY, \56 find_properties_file, get_ambari_classpath, get_ambari_jars, get_ambari_properties, get_JAVA_HOME, get_share_jars, \57 parse_properties_file, read_ambari_user, update_ambari_properties, update_properties_2, write_property, find_jdk, \58 AMBARI_CONF_VAR, AMBARI_SERVER_LIB, JDBC_DATABASE_PROPERTY, JDBC_RCA_PASSWORD_FILE_PROPERTY, \59 PERSISTENCE_TYPE_PROPERTY, JDBC_URL_PROPERTY, get_conf_dir, JDBC_USER_NAME_PROPERTY, JDBC_PASSWORD_PROPERTY, \60 JDBC_DATABASE_NAME_PROPERTY, OS_TYPE_PROPERTY, validate_jdk, JDBC_POSTGRES_SCHEMA_PROPERTY, \61 RESOURCES_DIR_PROPERTY, JDBC_RCA_PASSWORD_ALIAS, JDBC_RCA_SCHEMA_PROPERTY, IS_LDAP_CONFIGURED, \62 SSL_API, SSL_API_PORT, CLIENT_API_PORT_PROPERTY,\63 JDBC_CONNECTION_POOL_TYPE, JDBC_CONNECTION_POOL_ACQUISITION_SIZE, \64 JDBC_CONNECTION_POOL_IDLE_TEST_INTERVAL, JDBC_CONNECTION_POOL_MAX_AGE, JDBC_CONNECTION_POOL_MAX_IDLE_TIME, \65 JDBC_CONNECTION_POOL_MAX_IDLE_TIME_EXCESS,\66 LDAP_MGR_PASSWORD_PROPERTY, LDAP_MGR_PASSWORD_ALIAS, JDBC_PASSWORD_FILENAME, NR_USER_PROPERTY, SECURITY_KEY_IS_PERSISTED, \67 SSL_TRUSTSTORE_PASSWORD_PROPERTY, SECURITY_IS_ENCRYPTION_ENABLED, SSL_TRUSTSTORE_PASSWORD_ALIAS, \68 SECURITY_MASTER_KEY_LOCATION, SECURITY_KEYS_DIR, LDAP_PRIMARY_URL_PROPERTY, store_password_file, \69 get_pass_file_path, GET_FQDN_SERVICE_URL, JDBC_USE_INTEGRATED_AUTH_PROPERTY, SECURITY_KEY_ENV_VAR_NAME, \70 JAVA_HOME_PROPERTY, JDK_NAME_PROPERTY, JCE_NAME_PROPERTY71 from ambari_server.serverUtils import is_server_runing, refresh_stack_hash72 from ambari_server.serverSetup import check_selinux, check_ambari_user, proceedJDBCProperties, SE_STATUS_DISABLED, SE_MODE_ENFORCING, configure_os_settings, \73 download_and_install_jdk, prompt_db_properties, setup, \74 AmbariUserChecks, AmbariUserChecksLinux, AmbariUserChecksWindows, JDKSetup, reset, setup_jce_policy, expand_jce_zip_file75 from ambari_server.serverUpgrade import upgrade, upgrade_local_repo, change_objects_owner, upgrade_stack, \76 run_stack_upgrade, run_metainfo_upgrade, run_schema_upgrade, move_user_custom_actions77 from ambari_server.setupHttps import is_valid_https_port, setup_https, import_cert_and_key_action, get_fqdn, \78 generate_random_string, get_cert_info, COMMON_NAME_ATTR, is_valid_cert_exp, NOT_AFTER_ATTR, NOT_BEFORE_ATTR, \79 SSL_DATE_FORMAT, import_cert_and_key, is_valid_cert_host, setup_truststore, \80 SRVR_ONE_WAY_SSL_PORT_PROPERTY, SRVR_TWO_WAY_SSL_PORT_PROPERTY, GANGLIA_HTTPS81 from ambari_server.setupSecurity import adjust_directory_permissions, get_alias_string, get_ldap_event_spec_names, sync_ldap, LdapSyncOptions, \82 configure_ldap_password, setup_ldap, REGEX_HOSTNAME_PORT, REGEX_TRUE_FALSE, REGEX_ANYTHING, setup_master_key, \83 setup_ambari_krb5_jaas, ensure_can_start_under_current_user, generate_env84 from ambari_server.userInput import get_YN_input, get_choice_string_input, get_validated_string_input, \85 read_password86 from ambari_server_main import get_ulimit_open_files, ULIMIT_OPEN_FILES_KEY, ULIMIT_OPEN_FILES_DEFAULT87CURR_AMBARI_VERSION = "2.0.0"88@patch("ambari_server.dbConfiguration_linux.get_postgre_hba_dir", new = MagicMock(return_value = "/var/lib/pgsql/data"))89@patch("ambari_server.dbConfiguration_linux.get_postgre_running_status", new = MagicMock(return_value = "running"))90class TestAmbariServer(TestCase):91 def setUp(self):92 out = StringIO.StringIO()93 sys.stdout = out94 def tearDown(self):95 sys.stdout = sys.__stdout__96 @not_for_platform(PLATFORM_WINDOWS)97 @patch("ambari_server.dbConfiguration_linux.run_os_command")98 def test_configure_pg_hba_ambaridb_users(self, run_os_command_method):99 # Prepare mocks100 run_os_command_method.return_value = (0, "", "")101 database_username = "ffdf"102 tf1 = tempfile.NamedTemporaryFile()103 # Run test104 PGConfig._configure_pg_hba_ambaridb_users(tf1.name, database_username)105 # Check results106 self.assertTrue(run_os_command_method.called)107 string_expected = self.get_file_string(self.get_samples_dir("configure_pg_hba_ambaridb_users1"))108 string_actual = self.get_file_string(tf1.name)109 self.assertEquals(string_expected, string_actual)110 pass111 @not_for_platform(PLATFORM_WINDOWS)112 @patch("__builtin__.raw_input")113 def test_servicename_regex(self, raw_input_method):114 ''' Test to make sure the service name can contain digits '''115 set_silent(False)116 raw_input_method.return_value = "OT100"117 result = OracleConfig._get_validated_service_name("ambari", 1)118 self.assertEqual("OT100", result, "Not accepting digits")119 pass120 @not_for_platform(PLATFORM_WINDOWS)121 @patch("__builtin__.raw_input")122 def test_dbname_regex(self, raw_input_method):123 ''' Test to make sure the service name can contain digits '''124 set_silent(False)125 raw_input_method.return_value = "OT100"126 result = LinuxDBMSConfig._get_validated_db_name("Database", "ambari")127 self.assertEqual("OT100", result, "Not accepting digits")128 pass129 @not_for_platform(PLATFORM_WINDOWS)130 def test_configure_pg_hba_postgres_user(self):131 tf1 = tempfile.NamedTemporaryFile()132 PGConfig.PG_HBA_CONF_FILE = tf1.name133 with open(PGConfig.PG_HBA_CONF_FILE, 'w') as fout:134 fout.write("\n")135 fout.write("local all all md5\n")136 fout.write("host all all 0.0.0.0/0 md5\n")137 fout.write("host all all ::/0 md5\n")138 PGConfig._configure_pg_hba_postgres_user()139 expected = self.get_file_string(self.get_samples_dir(140 "configure_pg_hba_ambaridb_users2"))141 result = self.get_file_string(PGConfig.PG_HBA_CONF_FILE)142 self.assertEqual(expected, result, "pg_hba_conf not processed")143 mode = oct(os.stat(PGConfig.PG_HBA_CONF_FILE)[stat.ST_MODE])144 str_mode = str(mode)[-4:]145 self.assertEqual("0644", str_mode, "Wrong file permissions")146 pass147 @patch("__builtin__.raw_input")148 def test_get_choice_string_input(self, raw_input_method):149 prompt = "blablabla"150 default = "default blablabla"151 firstChoice = set(['yes', 'ye', 'y'])152 secondChoice = set(['no', 'n'])153 # test first input154 raw_input_method.return_value = "Y"155 result = get_choice_string_input(prompt, default,156 firstChoice, secondChoice)157 self.assertEquals(result, True)158 raw_input_method.reset_mock()159 # test second input160 raw_input_method.return_value = "N"161 result = get_choice_string_input(prompt, default,162 firstChoice, secondChoice)163 self.assertEquals(result, False)164 raw_input_method.reset_mock()165 # test enter pressed166 raw_input_method.return_value = ""167 result = get_choice_string_input(prompt, default,168 firstChoice, secondChoice)169 self.assertEquals(result, default)170 raw_input_method.reset_mock()171 # test wrong input172 list_of_return_values = ['yes', 'dsad', 'fdsfds']173 def side_effect(list):174 return list_of_return_values.pop()175 raw_input_method.side_effect = side_effect176 result = get_choice_string_input(prompt, default,177 firstChoice, secondChoice)178 self.assertEquals(result, True)179 self.assertEquals(raw_input_method.call_count, 3)180 pass181 @patch("re.search")182 @patch("__builtin__.raw_input")183 @patch("getpass.getpass")184 def test_get_validated_string_input(self, get_pass_method,185 raw_input_method, re_search_method):186 prompt = "blabla"187 default = "default_pass"188 pattern = "pattern_pp"189 description = "blabla2"190 # check password input191 self.assertFalse(False, get_silent())192 is_pass = True193 get_pass_method.return_value = "dfdsfdsfds"194 result = get_validated_string_input(prompt, default,195 pattern, description, is_pass)196 self.assertEquals(get_pass_method.return_value, result)197 get_pass_method.assure_called_once(prompt)198 self.assertFalse(raw_input_method.called)199 # check raw input200 get_pass_method.reset_mock()201 raw_input_method.reset_mock()202 is_pass = False203 raw_input_method.return_value = "dkf90ewuf0"204 result = get_validated_string_input(prompt, default,205 pattern, description, is_pass)206 self.assertEquals(raw_input_method.return_value, result)207 self.assertFalse(get_pass_method.called)208 raw_input_method.assure_called_once(prompt)209 pass210 @not_for_platform(PLATFORM_WINDOWS)211 def test_get_pass_file_path(self):212 result = get_pass_file_path("/etc/ambari/conf_file", JDBC_PASSWORD_FILENAME)213 self.assertEquals("/etc/ambari/password.dat", result)214 pass215 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))216 @patch.object(_ambari_server_, "setup_security")217 @patch("optparse.OptionParser")218 def test_main_test_setup_security(self, OptionParserMock,219 setup_security_method):220 opm = OptionParserMock.return_value221 options = MagicMock()222 args = ["setup-security"]223 opm.parse_args.return_value = (options, args)224 options.dbms = None225 options.sid_or_sname = "sid"226 setup_security_method.return_value = None227 _ambari_server_.mainBody()228 _ambari_server_.mainBody()229 self.assertTrue(setup_security_method.called)230 self.assertFalse(False, get_verbose())231 self.assertFalse(False, get_silent())232 pass233 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))234 @patch.object(_ambari_server_, "setup_ambari_krb5_jaas")235 @patch.object(_ambari_server_, "setup_master_key")236 @patch.object(_ambari_server_, "setup_truststore")237 @patch.object(_ambari_server_, "setup_https")238 @patch.object(_ambari_server_, "get_validated_string_input")239 def test_setup_security(self, get_validated_string_input_mock, setup_https_mock,240 setup_truststore_mock, setup_master_key_mock,241 setup_ambari_krb5_jaas_mock):242 args = {}243 get_validated_string_input_mock.return_value = '1'244 _ambari_server_.setup_security(args)245 self.assertTrue(setup_https_mock.called)246 get_validated_string_input_mock.return_value = '2'247 _ambari_server_.setup_security(args)248 self.assertTrue(setup_master_key_mock.called)249 get_validated_string_input_mock.return_value = '3'250 _ambari_server_.setup_security(args)251 self.assertTrue(setup_ambari_krb5_jaas_mock.called)252 get_validated_string_input_mock.return_value = '4'253 _ambari_server_.setup_security(args)254 self.assertTrue(setup_truststore_mock.called)255 get_validated_string_input_mock.return_value = '5'256 _ambari_server_.setup_security(args)257 self.assertTrue(setup_truststore_mock.called)258 pass259 @patch("re.sub")260 @patch("fileinput.FileInput")261 @patch("ambari_server.setupSecurity.get_validated_string_input")262 @patch("ambari_server.setupSecurity.search_file")263 @patch("os.path.exists")264 def test_setup_ambari_krb5_jaas(self, exists_mock, search_mock,265 get_validated_string_input_mock,266 fileinput_mock, re_sub_mock):267 search_mock.return_value = 'filepath'268 exists_mock.return_value = False269 # Negative case270 try:271 setup_ambari_krb5_jaas()272 self.fail("Should throw exception")273 except NonFatalException as fe:274 # Expected275 self.assertTrue("No jaas config file found at location" in fe.reason)276 pass277 # Positive case278 exists_mock.reset_mock()279 exists_mock.return_value = True280 get_validated_string_input_mock.side_effect = ['aaa@aaa.cnn',281 'pathtokeytab']282 fileinput_mock.return_value = [ 'keyTab=xyz', 'principal=xyz' ]283 setup_ambari_krb5_jaas()284 self.assertTrue(fileinput_mock.called)285 self.assertTrue(re_sub_mock.called)286 self.assertTrue(re_sub_mock.call_args_list, [('aaa@aaa.cnn'),287 ('pathtokeytab')])288 pass289 @patch("sys.exit")290 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))291 @patch.object(_ambari_server_, "setup")292 @patch.object(_ambari_server_, "start")293 @patch.object(_ambari_server_, "stop")294 @patch.object(_ambari_server_, "reset")295 @patch("optparse.OptionParser")296 def test_main_test_setup(self, OptionParserMock, reset_method, stop_method,297 start_method, setup_method, exit_mock):298 opm = OptionParserMock.return_value299 options = MagicMock()300 args = ["setup"]301 opm.parse_args.return_value = (options, args)302 options.dbms = None303 options.sid_or_sname = "sid"304 _ambari_server_.mainBody()305 self.assertTrue(setup_method.called)306 self.assertFalse(start_method.called)307 self.assertFalse(stop_method.called)308 self.assertFalse(reset_method.called)309 self.assertFalse(False, get_verbose())310 self.assertFalse(False, get_silent())311 setup_method.reset_mock()312 start_method.reset_mock()313 stop_method.reset_mock()314 reset_method.reset_mock()315 exit_mock.reset_mock()316 args = ["setup", "-v"]317 options = MagicMock()318 opm.parse_args.return_value = (options, args)319 options.dbms = None320 options.sid_or_sname = "sid"321 setup_method.side_effect = Exception("Unexpected error")322 try:323 _ambari_server_.mainBody()324 except Exception:325 self.assertTrue(True)326 self.assertTrue(setup_method.called)327 self.assertFalse(start_method.called)328 self.assertFalse(stop_method.called)329 self.assertFalse(reset_method.called)330 self.assertTrue(get_verbose())331 setup_method.reset_mock()332 start_method.reset_mock()333 stop_method.reset_mock()334 reset_method.reset_mock()335 exit_mock.reset_mock()336 args = ["setup"]337 options = MagicMock()338 opm.parse_args.return_value = (options, args)339 options.dbms = None340 options.sid_or_sname = "sid"341 options.verbose = False342 setup_method.side_effect = Exception("Unexpected error")343 _ambari_server_.mainBody()344 self.assertTrue(exit_mock.called)345 self.assertTrue(setup_method.called)346 self.assertFalse(start_method.called)347 self.assertFalse(stop_method.called)348 self.assertFalse(reset_method.called)349 self.assertFalse(get_verbose())350 pass351 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))352 @patch.object(_ambari_server_, "setup")353 @patch.object(_ambari_server_, "start")354 @patch.object(_ambari_server_, "stop")355 @patch.object(_ambari_server_, "reset")356 @patch("optparse.OptionParser")357 def test_main_test_start(self, optionParserMock, reset_method, stop_method,358 start_method, setup_method):359 opm = optionParserMock.return_value360 options = MagicMock()361 args = ["setup"]362 opm.parse_args.return_value = (options, args)363 options.dbms = None364 options.sid_or_sname = "sname"365 _ambari_server_.mainBody()366 self.assertTrue(setup_method.called)367 self.assertFalse(start_method.called)368 self.assertFalse(stop_method.called)369 self.assertFalse(reset_method.called)370 self.assertFalse(False, get_verbose())371 self.assertFalse(False, get_silent())372 pass373 @not_for_platform(PLATFORM_WINDOWS)374 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))375 @patch.object(_ambari_server_, "setup")376 @patch.object(_ambari_server_, "start")377 @patch.object(_ambari_server_, "stop")378 @patch.object(_ambari_server_, "reset")379 def test_main_test_start_debug_short(self, reset_method, stop_method,380 start_method, setup_method):381 temp_args = sys.argv382 try:383 sys.argv = ["ambari-server", "start", "-g"]384 _ambari_server_.mainBody()385 self.assertFalse(setup_method.called)386 self.assertTrue(start_method.called)387 self.assertFalse(stop_method.called)388 self.assertFalse(reset_method.called)389 self.assertTrue(get_debug_mode())390 finally:391 sys.argv = temp_args392 pass393 @only_for_platform(PLATFORM_WINDOWS)394 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))395 @patch.object(_ambari_server_, "setup")396 @patch.object(_ambari_server_, "start")397 @patch.object(_ambari_server_, "stop")398 @patch.object(_ambari_server_, "reset")399 def test_main_test_start_debug_short(self, reset_method, stop_method,400 start_method, setup_method):401 temp_args = sys.argv402 try:403 sys.argv = ["ambari-server", "pstart", "-g"]404 _ambari_server_.mainBody()405 self.assertFalse(setup_method.called)406 self.assertTrue(start_method.called)407 self.assertFalse(stop_method.called)408 self.assertFalse(reset_method.called)409 self.assertTrue(get_debug_mode())410 finally:411 sys.argv = temp_args412 pass413 @not_for_platform(PLATFORM_WINDOWS)414 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))415 @patch.object(_ambari_server_, "setup")416 @patch.object(_ambari_server_, "start")417 @patch.object(_ambari_server_, "stop")418 @patch.object(_ambari_server_, "reset")419 def test_main_test_start_debug_long(self, reset_method, stop_method,420 start_method, setup_method):421 temp_args = sys.argv422 try:423 sys.argv = ["ambari-server", "start", "--debug"]424 _ambari_server_.mainBody()425 self.assertFalse(setup_method.called)426 self.assertTrue(start_method.called)427 self.assertFalse(stop_method.called)428 self.assertFalse(reset_method.called)429 self.assertTrue(get_debug_mode())430 finally:431 sys.argv = temp_args432 pass433 @only_for_platform(PLATFORM_WINDOWS)434 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))435 @patch.object(_ambari_server_, "setup")436 @patch.object(_ambari_server_, "start")437 @patch.object(_ambari_server_, "stop")438 @patch.object(_ambari_server_, "reset")439 def test_main_test_start_debug_long(self, reset_method, stop_method,440 start_method, setup_method):441 temp_args = sys.argv442 try:443 sys.argv = ["ambari-server", "pstart", "--debug"]444 _ambari_server_.mainBody()445 self.assertFalse(setup_method.called)446 self.assertTrue(start_method.called)447 self.assertFalse(stop_method.called)448 self.assertFalse(reset_method.called)449 self.assertTrue(get_debug_mode())450 finally:451 sys.argv = temp_args452 pass453 #Backup is not yet supported on Windows454 @not_for_platform(PLATFORM_WINDOWS)455 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))456 @patch.object(_ambari_server_, "setup")457 @patch.object(_ambari_server_, "start")458 @patch.object(_ambari_server_, "stop")459 @patch.object(_ambari_server_, "reset")460 @patch.object(_ambari_server_, "backup")461 @patch.object(_ambari_server_, "restore")462 @patch("optparse.OptionParser")463 def test_main_test_backup(self, optionParserMock, restore_mock, backup_mock, reset_method, stop_method,464 start_method, setup_method):465 opm = optionParserMock.return_value466 options = MagicMock()467 args = ["backup"]468 opm.parse_args.return_value = (options, args)469 options.dbms = None470 options.sid_or_sname = "sname"471 _ambari_server_.mainBody()472 self.assertTrue(backup_mock.called)473 self.assertFalse(restore_mock.called)474 self.assertFalse(setup_method.called)475 self.assertFalse(start_method.called)476 self.assertFalse(stop_method.called)477 self.assertFalse(reset_method.called)478 self.assertFalse(False, get_verbose())479 self.assertFalse(False, get_silent())480 pass481 #Restore is not yet supported on Windows482 @not_for_platform(PLATFORM_WINDOWS)483 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))484 @patch.object(_ambari_server_, "setup")485 @patch.object(_ambari_server_, "start")486 @patch.object(_ambari_server_, "stop")487 @patch.object(_ambari_server_, "reset")488 @patch.object(_ambari_server_, "backup")489 @patch.object(_ambari_server_, "restore")490 @patch("optparse.OptionParser")491 def test_main_test_restore(self, optionParserMock, restore_mock, backup_mock, reset_method, stop_method,492 start_method, setup_method):493 opm = optionParserMock.return_value494 options = MagicMock()495 args = ["restore"]496 opm.parse_args.return_value = (options, args)497 options.dbms = None498 options.sid_or_sname = "sname"499 _ambari_server_.mainBody()500 self.assertTrue(restore_mock.called)501 self.assertFalse(backup_mock.called)502 self.assertFalse(setup_method.called)503 self.assertFalse(start_method.called)504 self.assertFalse(stop_method.called)505 self.assertFalse(reset_method.called)506 self.assertFalse(False, get_verbose())507 self.assertFalse(False, get_silent())508 pass509 @not_for_platform(PLATFORM_WINDOWS)510 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))511 @patch.object(_ambari_server_, "setup")512 @patch.object(_ambari_server_, "start")513 @patch.object(_ambari_server_, "is_server_runing")514 @patch.object(_ambari_server_, "reset")515 @patch("optparse.OptionParser")516 def test_main_test_stop(self, optionParserMock, reset_method, is_server_runing_method,517 start_method, setup_method):518 opm = optionParserMock.return_value519 options = MagicMock()520 del options.exit_message521 args = ["stop"]522 opm.parse_args.return_value = (options, args)523 is_server_runing_method.return_value = (False, None)524 options.dbms = None525 options.sid_or_sname = "sid"526 _ambari_server_.mainBody()527 self.assertFalse(setup_method.called)528 self.assertFalse(start_method.called)529 self.assertTrue(is_server_runing_method.called)530 self.assertFalse(reset_method.called)531 self.assertFalse(False, get_verbose())532 self.assertFalse(False, get_silent())533 self.assertTrue(options.exit_message is None)534 pass535 @only_for_platform(PLATFORM_WINDOWS)536 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))537 @patch.object(_ambari_server_, "setup")538 @patch.object(_ambari_server_, "start")539 @patch("os_windows.win32serviceutil.WaitForServiceStatus")540 @patch("os_windows.win32serviceutil.StopService")541 @patch("os_windows.win32serviceutil.StopServiceWithDeps")542 @patch.object(_ambari_server_, "reset")543 def test_main_test_stop(self, reset_method, service_stop_w_deps_method,544 service_stop_method, service_status_wait_method,545 start_method, setup_method):546 temp_args = sys.argv547 try:548 sys.argv = ["ambari-server", "stop"]549 _ambari_server_.mainBody()550 self.assertFalse(setup_method.called)551 self.assertFalse(start_method.called)552 self.assertTrue(service_stop_w_deps_method.called)553 self.assertTrue(service_status_wait_method.called)554 self.assertFalse(reset_method.called)555 self.assertFalse(False, get_verbose())556 self.assertFalse(False, get_silent())557 finally:558 sys.argv = temp_args559 pass560 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))561 @patch.object(_ambari_server_, "setup")562 @patch.object(_ambari_server_, "start")563 @patch.object(_ambari_server_, "stop")564 @patch.object(_ambari_server_, "reset")565 @patch("optparse.OptionParser")566 def test_main_test_reset(self, optionParserMock, reset_method, stop_method,567 start_method, setup_method):568 opm = optionParserMock.return_value569 options = MagicMock()570 args = ["reset"]571 opm.parse_args.return_value = (options, args)572 options.dbms = None573 options.sid_or_sname = "sid"574 _ambari_server_.mainBody()575 self.assertFalse(setup_method.called)576 self.assertFalse(start_method.called)577 self.assertFalse(stop_method.called)578 self.assertTrue(reset_method.called)579 self.assertFalse(False, get_verbose())580 self.assertFalse(False, get_silent())581 pass582 @not_for_platform(PLATFORM_WINDOWS)583 def test_configure_postgresql_conf(self):584 tf1 = tempfile.NamedTemporaryFile()585 PGConfig.POSTGRESQL_CONF_FILE = tf1.name586 with open(PGConfig.POSTGRESQL_CONF_FILE, 'w') as f:587 f.write("#listen_addresses = '127.0.0.1' #\n")588 f.write("#listen_addresses = '127.0.0.1'")589 PGConfig._configure_postgresql_conf()590 expected = self.get_file_string(self.get_samples_dir(591 "configure_postgresql_conf1"))592 result = self.get_file_string(PGConfig.POSTGRESQL_CONF_FILE)593 self.assertEqual(expected, result, "postgresql.conf not updated")594 mode = oct(os.stat(PGConfig.POSTGRESQL_CONF_FILE)[stat.ST_MODE])595 str_mode = str(mode)[-4:]596 self.assertEqual("0644", str_mode, "Wrong file permissions")597 pass598 @not_for_platform(PLATFORM_WINDOWS)599 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))600 @patch.object(PGConfig, "_restart_postgres")601 @patch.object(PGConfig, "_get_postgre_status")602 @patch.object(PGConfig, "_configure_postgresql_conf")603 @patch("ambari_server.dbConfiguration_linux.run_os_command")604 def test_configure_postgres(self,605 run_os_command_mock,606 configure_postgresql_conf_mock,607 get_postgre_status_mock,608 restart_postgres_mock):609 args = MagicMock()610 properties = Properties()611 args.database_index = 0612 del args.dbms613 del args.database_host614 del args.database_port615 del args.database_name616 del args.database_username617 del args.database_password618 del args.silent619 factory = DBMSConfigFactory()620 dbConfig = factory.create(args, properties)621 self.assertTrue(dbConfig.dbms, "postgres")622 self.assertTrue(dbConfig.persistence_type, "local")623 tf1 = tempfile.NamedTemporaryFile()624 tf2 = tempfile.NamedTemporaryFile()625 PGConfig.PG_HBA_CONF_FILE = tf1.name626 PGConfig.PG_HBA_CONF_FILE_BACKUP = tf2.name627 out = StringIO.StringIO()628 sys.stdout = out629 retcode, out1, err = dbConfig._configure_postgres()630 sys.stdout = sys.__stdout__631 self.assertEqual(0, retcode)632 self.assertEqual("Backup for pg_hba found, reconfiguration not required\n",633 out.getvalue())634 tf2.close()635 get_postgre_status_mock.return_value = PGConfig.PG_STATUS_RUNNING, 0, "", ""636 run_os_command_mock.return_value = 0, "", ""637 restart_postgres_mock.return_value = 0, "", ""638 rcode, out, err = dbConfig._configure_postgres()639 self.assertTrue(os.path.isfile(PGConfig.PG_HBA_CONF_FILE_BACKUP),640 "postgresql.conf backup not created")641 self.assertTrue(run_os_command_mock.called)642 mode = oct(os.stat(PGConfig.PG_HBA_CONF_FILE)[stat.ST_MODE])643 str_mode = str(mode)[-4:]644 self.assertEqual("0644", str_mode, "Wrong file permissions")645 self.assertTrue(configure_postgresql_conf_mock.called)646 self.assertEqual(0, rcode)647 os.unlink(PGConfig.PG_HBA_CONF_FILE_BACKUP)648 get_postgre_status_mock.return_value = "stopped", 0, "", ""649 rcode, out, err = dbConfig._configure_postgres()650 self.assertEqual(0, rcode)651 os.unlink(PGConfig.PG_HBA_CONF_FILE_BACKUP)652 sys.stdout = sys.__stdout__653 pass654 @not_for_platform(PLATFORM_WINDOWS)655 @patch("time.sleep")656 @patch("subprocess.Popen")657 @patch("ambari_server.dbConfiguration_linux.run_os_command")658 @patch.object(PGConfig, "_get_postgre_status")659 @patch("ambari_server.dbConfiguration_linux.print_info_msg")660 def test_restart_postgres(self, printInfoMsg_mock, get_postgre_status_mock,661 run_os_command_mock, popenMock, sleepMock):662 p = MagicMock()663 p.poll.return_value = 0664 popenMock.return_value = p665 retcode, out, err = PGConfig._restart_postgres()666 self.assertEqual(0, retcode)667 p.poll.return_value = None668 get_postgre_status_mock.return_value = "stopped", 0, "", ""669 run_os_command_mock.return_value = (1, None, None)670 retcode, out, err = PGConfig._restart_postgres()671 self.assertEqual(1, retcode)672 pass673 @not_for_platform(PLATFORM_WINDOWS)674 @patch("shlex.split")675 @patch("subprocess.Popen")676 @patch("ambari_commons.os_linux.print_info_msg")677 def test_run_os_command(self, printInfoMsg_mock, popenMock, splitMock):678 p = MagicMock()679 p.communicate.return_value = (None, None)680 p.returncode = 3681 popenMock.return_value = p682 # with list arg683 cmd = ["exec", "arg"]684 run_os_command(cmd)685 self.assertFalse(splitMock.called)686 # with str arg687 resp = run_os_command("runme")688 self.assertEqual(3, resp[0])689 self.assertTrue(splitMock.called)690 pass691 @only_for_platform(PLATFORM_WINDOWS)692 @patch("shlex.split")693 @patch("subprocess.Popen")694 @patch("ambari_commons.os_windows.print_info_msg")695 def test_run_os_command(self, printInfoMsg_mock, popenMock, splitMock):696 p = MagicMock()697 p.communicate.return_value = (None, None)698 p.returncode = 3699 popenMock.return_value = p700 # with list arg701 cmd = ["exec", "arg"]702 run_os_command(cmd)703 self.assertFalse(splitMock.called)704 # with str arg705 resp = run_os_command("runme")706 self.assertEqual(3, resp[0])707 self.assertTrue(splitMock.called)708 pass709 @not_for_platform(PLATFORM_WINDOWS)710 @patch("ambari_server.serverConfiguration.get_conf_dir")711 @patch("ambari_server.serverConfiguration.search_file")712 def test_write_property(self, search_file_mock, get_conf_dir_mock):713 expected_content = "key1=val1\n"714 tf1 = tempfile.NamedTemporaryFile()715 search_file_mock.return_value = tf1.name716 write_property("key1", "val1")717 result = tf1.read()718 self.assertTrue(expected_content in result)719 pass720 @only_for_platform(PLATFORM_WINDOWS)721 @patch("ambari_server.serverConfiguration.get_conf_dir")722 @patch("ambari_server.serverConfiguration.search_file")723 def test_write_property(self, search_file_mock, get_conf_dir_mock):724 expected_content = "key1=val1\n"725 tf1 = tempfile.NamedTemporaryFile("r+b", delete=False)726 search_file_mock.return_value = tf1.name727 tf1.close()728 write_property("key1", "val1")729 hf1 = open(tf1.name, "r")730 try:731 result = hf1.read()732 self.assertTrue(expected_content in result)733 finally:734 hf1.close()735 os.unlink(tf1.name)736 pass737 @not_for_platform(PLATFORM_WINDOWS)738 @patch("ambari_server.dbConfiguration.decrypt_password_for_alias")739 @patch("ambari_server.dbConfiguration_linux.run_os_command")740 def test_setup_db(self, run_os_command_mock,741 decrypt_password_for_alias_mock):742 args = MagicMock()743 del args.database_index744 del args.dbms745 del args.database_host746 del args.database_port747 del args.database_name748 del args.database_username749 del args.database_password750 properties = Properties()751 properties.process_pair(JDBC_PASSWORD_PROPERTY, get_alias_string("mypwdalias"))752 decrypt_password_for_alias_mock.return_value = "password"753 dbms = PGConfig(args, properties, "local")754 self.assertTrue(decrypt_password_for_alias_mock.called)755 run_os_command_mock.return_value = (0, None, None)756 result = dbms._setup_db()757 self.assertTrue(run_os_command_mock.called)758 self.assertEqual((0, None, None), result)759 pass760 @not_for_platform(PLATFORM_WINDOWS)761 @patch("ambari_server.dbConfiguration.decrypt_password_for_alias")762 @patch("time.sleep")763 @patch("ambari_server.dbConfiguration_linux.run_os_command")764 def test_setup_db_connect_attempts_fail(self, run_os_command_mock,765 sleep_mock, decrypt_password_for_alias_mock):766 args = MagicMock()767 del args.database_index768 del args.dbms769 del args.database_host770 del args.database_port771 del args.database_name772 del args.database_username773 del args.database_password774 properties = Properties()775 decrypt_password_for_alias_mock.return_value = "password"776 dbms = PGConfig(args, properties, "local")777 run_os_command_mock.side_effect = [(1, "error", "error"), (1, "error", "error"),778 (1, "error", "error")]779 result = dbms._setup_db()780 self.assertTrue(run_os_command_mock.called)781 self.assertEqual((1, 'error', 'error') , result)782 self.assertEqual(2, sleep_mock.call_count)783 pass784 @not_for_platform(PLATFORM_WINDOWS)785 @patch("ambari_server.dbConfiguration.decrypt_password_for_alias")786 @patch("time.sleep")787 @patch("ambari_server.dbConfiguration_linux.run_os_command")788 def test_setup_db_connect_attempts_success(self, run_os_command_mock,789 sleep_mock, decrypt_password_for_alias_mock):790 args = MagicMock()791 del args.database_index792 del args.dbms793 del args.database_host794 del args.database_port795 del args.database_name796 del args.database_username797 del args.database_password798 properties = Properties()799 decrypt_password_for_alias_mock.return_value = "password"800 dbms = PGConfig(args, properties, "local")801 run_os_command_mock.side_effect = [(1, "error", "error"), (0, None, None),802 (0, None, None)]803 result = dbms._setup_db()804 self.assertTrue(run_os_command_mock.called)805 self.assertEqual((0, None, None) , result)806 self.assertEqual(1, sleep_mock.call_count)807 pass808 @not_for_platform(PLATFORM_WINDOWS)809 @patch("ambari_server.serverSetup.get_YN_input")810 @patch("ambari_server.serverSetup.run_os_command")811 def test_check_selinux(self, run_os_command_mock, getYNInput_mock):812 run_os_command_mock.return_value = (0, SE_STATUS_DISABLED,813 None)814 rcode = check_selinux()815 self.assertEqual(0, rcode)816 getYNInput_mock.return_value = True817 run_os_command_mock.return_value = (0, "enabled "818 + SE_MODE_ENFORCING,819 None)820 rcode = check_selinux()821 self.assertEqual(0, rcode)822 self.assertTrue(run_os_command_mock.called)823 self.assertTrue(getYNInput_mock.called)824 pass825 @not_for_platform(PLATFORM_WINDOWS)826 @patch("ambari_server.serverConfiguration.print_info_msg")827 def test_get_ambari_jars(self, printInfoMsg_mock):828 env = "/ambari/jars"829 os.environ[AMBARI_SERVER_LIB] = env830 result = get_ambari_jars()831 self.assertEqual(env, result)832 del os.environ[AMBARI_SERVER_LIB]833 result = get_ambari_jars()834 self.assertEqual("/usr/lib/ambari-server", result)835 self.assertTrue(printInfoMsg_mock.called)836 pass837 @only_for_platform(PLATFORM_WINDOWS)838 @patch("ambari_server.serverConfiguration.print_info_msg")839 def test_get_ambari_jars(self, printInfoMsg_mock):840 env = "\\ambari\\jars"841 os.environ[AMBARI_SERVER_LIB] = env842 result = get_ambari_jars()843 self.assertEqual(env, result)844 del os.environ[AMBARI_SERVER_LIB]845 result = get_ambari_jars()846 self.assertEqual("lib", result)847 self.assertTrue(printInfoMsg_mock.called)848 pass849 @patch("glob.glob")850 @patch("ambari_server.serverConfiguration.print_info_msg")851 def test_get_share_jars(self, printInfoMsg_mock, globMock):852 globMock.return_value = ["one", "two"]853 expected = "one" + os.pathsep + "two" + os.pathsep + \854 "one" + os.pathsep + "two" + os.pathsep + \855 "one" + os.pathsep + "two"856 result = get_share_jars()857 self.assertEqual(expected, result)858 globMock.return_value = []859 expected = ""860 result = get_share_jars()861 self.assertEqual(expected, result)862 pass863 @patch("glob.glob")864 @patch("ambari_server.serverConfiguration.print_info_msg")865 @patch("ambari_server.serverConfiguration.get_ambari_properties")866 def test_get_ambari_classpath(self, get_ambari_properties_mock, printInfoMsg_mock, globMock):867 globMock.return_value = ["one"]868 result = get_ambari_classpath()869 self.assertTrue(get_ambari_jars() in result)870 self.assertTrue(get_share_jars() in result)871 globMock.return_value = []872 result = get_ambari_classpath()873 self.assertTrue(get_ambari_jars() in result)874 self.assertFalse(":" in result[2:])875 pass876 @not_for_platform(PLATFORM_WINDOWS)877 @patch("ambari_server.serverConfiguration.print_info_msg")878 def test_get_conf_dir(self, printInfoMsg_mock):879 env = "/dummy/ambari/conf"880 os.environ[AMBARI_CONF_VAR] = env881 result = get_conf_dir()882 self.assertEqual(env, result)883 del os.environ[AMBARI_CONF_VAR]884 result = get_conf_dir()885 self.assertEqual("/etc/ambari-server/conf", result)886 pass887 @only_for_platform(PLATFORM_WINDOWS)888 @patch("ambari_server.serverConfiguration.print_info_msg")889 def test_get_conf_dir(self, printInfoMsg_mock):890 env = "\\dummy\\ambari\\conf"891 os.environ[AMBARI_CONF_VAR] = env892 result = get_conf_dir()893 self.assertEqual(env, result)894 del os.environ[AMBARI_CONF_VAR]895 result = get_conf_dir()896 self.assertEqual("conf", result)897 pass898 def test_search_file(self):899 path = os.path.dirname(__file__)900 result = search_file(__file__, path)901 expected = os.path.abspath(__file__)902 self.assertEqual(expected, result)903 result = search_file("non_existent_file", path)904 self.assertEqual(None, result)905 pass906 @patch("ambari_server.serverConfiguration.search_file")907 def test_find_properties_file(self, search_file_mock):908 # Testing case when file is not found909 search_file_mock.return_value = None910 try:911 find_properties_file()912 self.fail("File not found'")913 except FatalException:914 # Expected915 pass916 self.assertTrue(search_file_mock.called)917 # Testing case when file is found918 value = MagicMock()919 search_file_mock.return_value = value920 result = find_properties_file()921 self.assertTrue(result is value)922 pass923 @patch("ambari_server.serverConfiguration.get_ambari_properties")924 @patch("ambari_server.serverConfiguration.Properties")925 def test_read_ambari_user(self, properties_mock, get_ambari_properties_mock):926 # Testing with defined user927 properties_mock.__getitem__.return_value = "dummy_user"928 get_ambari_properties_mock.return_value = properties_mock929 user = read_ambari_user()930 self.assertEquals(user, "dummy_user")931 # Testing with undefined user932 properties_mock.__getitem__.return_value = None933 user = read_ambari_user()934 self.assertEquals(user, None)935 pass936 @patch("ambari_server.setupSecurity.get_file_owner")937 @patch("ambari_server.setupSecurity.get_ambari_repo_file_full_name")938 @patch("os.path.exists")939 @patch("ambari_server.setupSecurity.set_file_permissions")940 @patch("ambari_server.setupSecurity.get_ambari_properties")941 @patch("ambari_server.setupSecurity.get_resources_location")942 @patch("ambari_server.setupSecurity.get_value_from_properties")943 @patch("os.mkdir")944 @patch("shutil.rmtree")945 @patch("ambari_commons.os_utils.print_info_msg")946 @patch("ambari_server.setupSecurity.change_owner")947 def test_adjust_directory_permissions(self, change_owner_mock, print_info_msg_mock, rmtree_mock, mkdir_mock,948 get_value_from_properties_mock, get_resources_location_mock,949 get_ambari_properties_mock, set_file_permissions_mock, exists_mock,950 get_ambari_repo_file_full_name_mock, get_file_owner_mock):951 # Testing boostrap dir wipe952 properties_mock = Properties()953 properties_mock.process_pair(JDK_NAME_PROPERTY, "dummy_jdk")954 properties_mock.process_pair(JCE_NAME_PROPERTY, "dummy_jce")955 properties_mock.process_pair(JAVA_HOME_PROPERTY, "dummy_java_home")956 get_ambari_properties_mock.return_value = properties_mock957 get_value_from_properties_mock.return_value = "dummy_bootstrap_dir"958 get_resources_location_mock.return_value = "dummy_resources_dir"959 exists_mock.return_value = False960 adjust_directory_permissions("user")961 self.assertEquals(rmtree_mock.call_args_list[0][0][0], os.path.join(os.getcwd(), "dummy_bootstrap_dir"))962 self.assertTrue(mkdir_mock.called)963 set_file_permissions_mock.reset_mock()964 change_owner_mock.reset_mock()965 # Test recursive calls966 old_adjust_owner_list = configDefaults.NR_ADJUST_OWNERSHIP_LIST967 old_change_owner_list = configDefaults.NR_CHANGE_OWNERSHIP_LIST968 try:969 configDefaults.NR_ADJUST_OWNERSHIP_LIST = [970 ( "/etc/ambari-server/conf", "755", "{0}", True ),971 ( "/etc/ambari-server/conf/ambari.properties", "644", "{0}", False )972 ]973 configDefaults.NR_CHANGE_OWNERSHIP_LIST = [974 ( "/etc/ambari-server", "{0}", True )975 ]976 adjust_directory_permissions("user")977 self.assertTrue(len(set_file_permissions_mock.call_args_list) ==978 len(configDefaults.NR_ADJUST_OWNERSHIP_LIST))979 self.assertEquals(set_file_permissions_mock.call_args_list[0][0][3], True)980 self.assertEquals(set_file_permissions_mock.call_args_list[1][0][3], False)981 self.assertTrue(len(change_owner_mock.call_args_list) ==982 len(configDefaults.NR_CHANGE_OWNERSHIP_LIST))983 self.assertEquals(change_owner_mock.call_args_list[0][0][2], True)984 finally:985 configDefaults.NR_ADJUST_OWNERSHIP_LIST = old_adjust_owner_list986 configDefaults.NR_CHANGE_OWNERSHIP_LIST = old_change_owner_list987 pass988 #989 # Test ambari repo file permission change call990 #991 # Reset the set_file_permissions() mock function992 set_file_permissions_mock.reset_mock()993 # Save the existing permissions list994 old_adjust_owner_list = configDefaults.NR_ADJUST_OWNERSHIP_LIST995 # Set up the mock function for os_utils.get_ambari_repo_file_full_name()996 get_ambari_repo_file_full_name_mock.return_value = "ambari.dummy.repo"997 # Set up the mock function for os_utils.get_file_owner()998 get_file_owner_mock.return_value = "dummy.root"999 try:1000 # Clear the list of files whose permissions are to be changed1001 configDefaults.NR_ADJUST_OWNERSHIP_LIST = [1002 ]1003 # Call the function to be tested.1004 adjust_directory_permissions("dummy_user")1005 # Assert that set_file_permissions() was called1006 self.assertTrue(set_file_permissions_mock.called)1007 # One of the entries in NR_ADJUST_OWNERSHIP_LIST should be the full path to the ambari repo file.1008 # These are the expected values:1009 ambari_repo_file_entry = (1010 get_ambari_repo_file_full_name_mock(),1011 '644',1012 get_file_owner_mock(),1013 False1014 )1015 # Assert the arguments to the call set_file_permissions() - got from NR_ADJUST_OWNERSHIP_LIST1016 # Flag to ensure we found our entry in the set_file_permissions() call1017 entry_found = False1018 for args_entry in set_file_permissions_mock.call_args_list:1019 if args_entry[0][0] == ambari_repo_file_entry[0]: # File name1020 # ambari repo file name matched; assert the rest of the entries1021 self.assertEquals(args_entry[0][1], ambari_repo_file_entry[1]) # Permissions1022 self.assertEquals(args_entry[0][2], ambari_repo_file_entry[2]) # File owner1023 self.assertEquals(args_entry[0][3], ambari_repo_file_entry[3]) # Non-recursive1024 entry_found = True1025 break1026 # Ensure that the ambari repo file entry was found1027 self.assertTrue(entry_found)1028 finally:1029 # Restore the permissions list1030 configDefaults.NR_ADJUST_OWNERSHIP_LIST = old_adjust_owner_list1031 pass1032 @not_for_platform(PLATFORM_WINDOWS)1033 @patch("os.path.exists")1034 @patch("ambari_commons.os_linux.os_run_os_command")1035 @patch("ambari_commons.os_linux.print_warning_msg")1036 @patch("ambari_commons.os_utils.print_info_msg")1037 def test_set_file_permissions(self, print_info_msg_mock, print_warning_msg_mock,1038 run_os_command_mock, exists_mock):1039 # Testing not existent file scenario1040 exists_mock.return_value = False1041 set_file_permissions("dummy-file", "dummy-mod",1042 "dummy-user", False)1043 self.assertFalse(run_os_command_mock.called)1044 self.assertTrue(print_info_msg_mock.called)1045 run_os_command_mock.reset_mock()1046 print_warning_msg_mock.reset_mock()1047 # Testing OK scenario1048 exists_mock.return_value = True1049 run_os_command_mock.side_effect = [(0, "", ""), (0, "", "")]1050 set_file_permissions("dummy-file", "dummy-mod",1051 "dummy-user", False)1052 self.assertTrue(len(run_os_command_mock.call_args_list) == 2)1053 self.assertFalse(print_warning_msg_mock.called)1054 run_os_command_mock.reset_mock()1055 print_warning_msg_mock.reset_mock()1056 # Testing first command fail1057 run_os_command_mock.side_effect = [(1, "", ""), (0, "", "")]1058 set_file_permissions("dummy-file", "dummy-mod",1059 "dummy-user", False)1060 self.assertTrue(len(run_os_command_mock.call_args_list) == 2)1061 self.assertTrue(print_warning_msg_mock.called)1062 run_os_command_mock.reset_mock()1063 print_warning_msg_mock.reset_mock()1064 # Testing second command fail1065 run_os_command_mock.side_effect = [(0, "", ""), (1, "", "")]1066 set_file_permissions("dummy-file", "dummy-mod",1067 "dummy-user", False)1068 self.assertTrue(len(run_os_command_mock.call_args_list) == 2)1069 self.assertTrue(print_warning_msg_mock.called)1070 run_os_command_mock.reset_mock()1071 print_warning_msg_mock.reset_mock()1072 # Testing recursive operation1073 exists_mock.return_value = True1074 run_os_command_mock.side_effect = [(0, "", ""), (0, "", "")]1075 set_file_permissions("dummy-file", "dummy-mod",1076 "dummy-user", True)1077 self.assertTrue(len(run_os_command_mock.call_args_list) == 2)1078 self.assertTrue("-R" in run_os_command_mock.call_args_list[0][0][0])1079 self.assertTrue("-R" in run_os_command_mock.call_args_list[1][0][0])1080 self.assertFalse(print_warning_msg_mock.called)1081 run_os_command_mock.reset_mock()1082 print_warning_msg_mock.reset_mock()1083 # Testing non-recursive operation1084 exists_mock.return_value = True1085 run_os_command_mock.side_effect = [(0, "", ""), (0, "", "")]1086 set_file_permissions("dummy-file", "dummy-mod",1087 "dummy-user", False)1088 self.assertTrue(len(run_os_command_mock.call_args_list) == 2)1089 self.assertFalse("-R" in run_os_command_mock.call_args_list[0][0][0])1090 self.assertFalse("-R" in run_os_command_mock.call_args_list[1][0][0])1091 self.assertFalse(print_warning_msg_mock.called)1092 run_os_command_mock.reset_mock()1093 print_warning_msg_mock.reset_mock()1094 pass1095 @not_for_platform(PLATFORM_WINDOWS)1096 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))1097 @patch("ambari_server.serverSetup.get_validated_string_input")1098 @patch("ambari_server.serverSetup.print_info_msg")1099 @patch("ambari_server.serverSetup.print_warning_msg")1100 @patch("ambari_server.serverSetup.run_os_command")1101 def test_create_custom_user(self, run_os_command_mock, print_warning_msg_mock,1102 print_info_msg_mock, get_validated_string_input_mock):1103 options = MagicMock()1104 user = "dummy-user"1105 get_validated_string_input_mock.return_value = user1106 userChecks = AmbariUserChecks(options)1107 # Testing scenario: absent user1108 run_os_command_mock.side_effect = [(0, "", "")]1109 result = userChecks._create_custom_user()1110 self.assertFalse(print_warning_msg_mock.called)1111 self.assertEquals(result, 0)1112 self.assertEquals(userChecks.user, user)1113 print_info_msg_mock.reset_mock()1114 print_warning_msg_mock.reset_mock()1115 run_os_command_mock.reset_mock()1116 # Testing scenario: existing user1117 run_os_command_mock.side_effect = [(9, "", "")]1118 result = userChecks._create_custom_user()1119 self.assertTrue("User dummy-user already exists" in str(print_info_msg_mock.call_args_list[1][0]))1120 self.assertEquals(result, 0)1121 self.assertEquals(userChecks.user, user)1122 print_info_msg_mock.reset_mock()1123 print_warning_msg_mock.reset_mock()1124 run_os_command_mock.reset_mock()1125 # Testing scenario: os command fail1126 run_os_command_mock.side_effect = [(1, "", "")]1127 result = userChecks._create_custom_user()1128 self.assertTrue(print_warning_msg_mock.called)1129 self.assertEquals(result, 1)1130 pass1131 @only_for_platform(PLATFORM_WINDOWS)1132 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))1133 @patch("win32security.LsaAddAccountRights")1134 @patch("win32security.LookupAccountName")1135 @patch("win32net.NetUserAdd")1136 @patch("win32net.NetUserGetInfo")1137 @patch("win32security.LsaOpenPolicy")1138 @patch("win32net.NetGetDCName")1139 @patch("ambari_server.serverSetup.get_validated_string_input")1140 @patch("ambari_server.serverSetup.print_info_msg")1141 @patch("ambari_server.serverSetup.print_warning_msg")1142 def test_create_custom_user(self, print_warning_msg_mock,1143 print_info_msg_mock, get_validated_string_input_mock,1144 net_get_dc_name_mock, lsa_open_policy_mock,1145 net_user_get_info_mock, net_user_add_mock,1146 lookup_account_name_mock, lsa_add_account_rights_mock):1147 def _reset_mocks():1148 get_validated_string_input_mock.reset_mock()1149 print_info_msg_mock.reset_mock()1150 print_warning_msg_mock.reset_mock()1151 net_get_dc_name_mock.reset_mock()1152 net_user_get_info_mock.reset_mock()1153 net_user_add_mock.reset_mock()1154 lookup_account_name_mock.reset_mock()1155 lsa_add_account_rights_mock.reset_mock()1156 pass1157 options = MagicMock()1158 user = "dummy-user"1159 get_validated_string_input_mock.return_value = user1160 userChecks = AmbariUserChecks(options)1161 # Testing scenario: absent user1162 def user_not_found(*args, **keywargs):1163 import pywintypes1164 raise pywintypes.error(2221)1165 net_user_get_info_mock.side_effect = user_not_found1166 result = userChecks._create_custom_user()1167 self.assertTrue(print_warning_msg_mock.called)1168 self.assertTrue(net_user_add_mock.called)1169 self.assertEqual(str(net_user_add_mock.call_args_list[0][0]), str((None, 1, {'comment': 'Ambari user', 'password': 'dummy-user', 'flags': 513, 'name': 'dummy-user', 'priv': 1})))1170 self.assertEquals(result, 0)1171 self.assertEquals(userChecks.user, ".\\" + user)1172 _reset_mocks()1173 # Testing scenario: existing user1174 net_user_get_info_mock.side_effect = None1175 net_user_get_info_mock.return_value = { "name":"dummy_user" }1176 #lookup_account_name_mock1177 #lsa_add_account_rights_mock1178 result = userChecks._create_custom_user()1179 self.assertTrue("User dummy-user already exists" in print_info_msg_mock.call_args_list[0][0][0])1180 self.assertEquals(result, 0)1181 self.assertEquals(userChecks.user, ".\\" + user)1182 self.assertFalse(net_user_add_mock.called)1183 _reset_mocks()1184 # Testing scenario: new domain user1185 get_validated_string_input_mock.side_effect = ["dummy_domain\\dummy_user", "newpassword"]1186 net_get_dc_name_mock.return_value = "dummy_dc"1187 net_user_get_info_mock.side_effect = user_not_found1188 result = userChecks._create_custom_user()1189 self.assertTrue(net_get_dc_name_mock.called)1190 self.assertEqual(str(net_get_dc_name_mock.call_args_list[0][0]), str((None, "dummy_domain")))1191 self.assertTrue(net_user_add_mock.called)1192 self.assertEqual(str(net_user_add_mock.call_args_list[0][0]), str(('dummy_dc', 1, {'comment': 'Ambari user', 'password': 'newpassword', 'flags': 513, 'name': 'dummy_user', 'priv': 1})))1193 self.assertEquals(result, 0)1194 self.assertEquals(userChecks.user, "dummy_domain\\dummy_user")1195 _reset_mocks()1196 # Testing scenario: existing domain user1197 get_validated_string_input_mock.side_effect = ["dummy_domain\\dummy_user", "newpassword"]1198 net_user_get_info_mock.side_effect = None1199 net_user_get_info_mock.return_value = { "name":"dummy_domain\\dummy_user" }1200 result = userChecks._create_custom_user()1201 self.assertTrue("User dummy_domain\\dummy_user already exists" in print_info_msg_mock.call_args_list[0][0][0])1202 self.assertTrue(net_get_dc_name_mock.called)1203 self.assertEqual(str(net_get_dc_name_mock.call_args_list[0][0]), str((None, "dummy_domain")))1204 self.assertFalse(net_user_add_mock.called)1205 self.assertEquals(result, 0)1206 self.assertEquals(userChecks.user, "dummy_domain\\dummy_user")1207 pass1208 @not_for_platform(PLATFORM_WINDOWS)1209 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))1210 @patch("ambari_server.serverSetup.read_ambari_user")1211 @patch("ambari_server.serverSetup.get_YN_input")1212 @patch("ambari_server.serverSetup.get_validated_string_input")1213 @patch("ambari_server.serverSetup.adjust_directory_permissions")1214 @patch("ambari_server.serverSetup.run_os_command")1215 @patch("ambari_server.serverSetup.print_error_msg")1216 @patch("ambari_server.serverSetup.print_warning_msg")1217 @patch("ambari_server.serverSetup.print_info_msg")1218 def test_check_ambari_user(self, print_info_msg_mock, print_warning_msg_mock, print_error_msg_mock,1219 run_os_command_mock, adjust_directory_permissions_mock,1220 get_validated_string_input_mock, get_YN_input_mock, read_ambari_user_mock):1221 def _reset_mocks():1222 get_YN_input_mock.reset_mock()1223 get_validated_string_input_mock.reset_mock()1224 run_os_command_mock.reset_mock()1225 adjust_directory_permissions_mock.reset_mock()1226 pass1227 options = MagicMock()1228 run_os_command_mock.return_value = (0, "", "")1229 # Scenario: user is already defined, user does not want to reconfigure it1230 read_ambari_user_mock.return_value = "dummy-user"1231 get_YN_input_mock.return_value = False1232 result = check_ambari_user(options)1233 self.assertTrue(get_YN_input_mock.called)1234 self.assertFalse(get_validated_string_input_mock.called)1235 self.assertFalse(run_os_command_mock.called)1236 self.assertTrue(adjust_directory_permissions_mock.called)1237 self.assertEqual(result[0], 0)1238 _reset_mocks()1239 # Scenario: user is already defined, but user wants to reconfigure it1240 read_ambari_user_mock.return_value = "dummy-user"1241 get_validated_string_input_mock.return_value = "new-dummy-user"1242 get_YN_input_mock.return_value = True1243 result = check_ambari_user(options)1244 self.assertTrue(get_YN_input_mock.called)1245 self.assertTrue(result[2] == "new-dummy-user")1246 self.assertTrue(get_validated_string_input_mock.called)1247 self.assertTrue(adjust_directory_permissions_mock.called)1248 self.assertEqual(result[0], 0)1249 _reset_mocks()1250 # Negative scenario: user is already defined, but user wants1251 # to reconfigure it, user creation failed1252 read_ambari_user_mock.return_value = "dummy-user"1253 run_os_command_mock.return_value = (1, "", "")1254 get_YN_input_mock.return_value = True1255 result = check_ambari_user(options)1256 self.assertTrue(get_YN_input_mock.called)1257 self.assertTrue(get_validated_string_input_mock.called)1258 self.assertTrue(run_os_command_mock.called)1259 self.assertFalse(adjust_directory_permissions_mock.called)1260 self.assertEqual(result[0], 1)1261 _reset_mocks()1262 # Scenario: user is not defined (setup process)1263 read_ambari_user_mock.return_value = None1264 get_YN_input_mock.return_value = True1265 get_validated_string_input_mock.return_value = "dummy-user"1266 run_os_command_mock.return_value = (0, "", "")1267 result = check_ambari_user(options)1268 self.assertTrue(get_YN_input_mock.called)1269 self.assertTrue(get_validated_string_input_mock.called)1270 self.assertTrue(run_os_command_mock.called)1271 self.assertTrue(result[2] == "dummy-user")1272 self.assertTrue(adjust_directory_permissions_mock.called)1273 self.assertEqual(result[0], 0)1274 _reset_mocks()1275 # Scenario: user is not defined (setup process), user creation failed1276 read_ambari_user_mock.return_value = None1277 get_YN_input_mock.return_value = True1278 run_os_command_mock.return_value = (1, "", "")1279 result = check_ambari_user(options)1280 self.assertTrue(get_YN_input_mock.called)1281 self.assertTrue(get_validated_string_input_mock.called)1282 self.assertTrue(run_os_command_mock.called)1283 self.assertFalse(adjust_directory_permissions_mock.called)1284 self.assertEqual(result[0], 1)1285 _reset_mocks()1286 # negative scenario: user is not defined (setup process), user creation failed1287 read_ambari_user_mock.return_value = None1288 get_YN_input_mock.return_value = True1289 run_os_command_mock.return_value = (1, "", "")1290 result = check_ambari_user(options)1291 self.assertTrue(get_YN_input_mock.called)1292 self.assertTrue(get_validated_string_input_mock.called)1293 self.assertTrue(run_os_command_mock.called)1294 self.assertFalse(adjust_directory_permissions_mock.called)1295 self.assertEqual(result[0], 1)1296 _reset_mocks()1297 # Scenario: user is not defined and left to be root1298 read_ambari_user_mock.return_value = None1299 get_YN_input_mock.return_value = False1300 result = check_ambari_user(options)1301 self.assertTrue(get_YN_input_mock.called)1302 self.assertFalse(get_validated_string_input_mock.called)1303 self.assertFalse(run_os_command_mock.called)1304 self.assertTrue(result[2] == "root")1305 self.assertTrue(adjust_directory_permissions_mock.called)1306 self.assertEqual(result[0], 0)1307 pass1308 @only_for_platform(PLATFORM_WINDOWS)1309 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))1310 @patch("ambari_commons.os_windows.UserHelper.add_user_privilege")1311 @patch("ambari_commons.os_windows.UserHelper.create_user")1312 @patch("ambari_commons.os_windows.UserHelper.find_user")1313 @patch("ambari_server.serverSetup.read_ambari_user")1314 @patch("ambari_server.serverSetup.get_YN_input")1315 @patch("ambari_server.serverSetup.get_validated_string_input")1316 @patch("ambari_server.serverSetup.adjust_directory_permissions")1317 @patch("ambari_server.serverSetup.run_os_command")1318 @patch("ambari_server.serverSetup.print_error_msg")1319 @patch("ambari_server.serverSetup.print_warning_msg")1320 @patch("ambari_server.serverSetup.print_info_msg")1321 def test_check_ambari_user(self, print_info_msg_mock, print_warning_msg_mock, print_error_msg_mock,1322 run_os_command_mock, adjust_directory_permissions_mock,1323 get_validated_string_input_mock, get_YN_input_mock, read_ambari_user_mock,1324 find_user_mock, create_user_mock, add_user_privilege_mock):1325 def _reset_mocks():1326 get_YN_input_mock.reset_mock()1327 get_validated_string_input_mock.reset_mock()1328 find_user_mock.reset_mock()1329 create_user_mock.reset_mock()1330 adjust_directory_permissions_mock.reset_mock()1331 pass1332 options = MagicMock()1333 options.svc_user = None1334 options.svc_password = None1335 run_os_command_mock.return_value = (0, "", "")1336 # Scenario: user is already defined, user does not want to reconfigure it1337 read_ambari_user_mock.return_value = "dummy-user"1338 get_YN_input_mock.return_value = False1339 result = check_ambari_user(options)1340 self.assertTrue(get_YN_input_mock.called)1341 self.assertFalse(get_validated_string_input_mock.called)1342 self.assertFalse(find_user_mock.called)1343 self.assertFalse(create_user_mock.called)1344 self.assertTrue(adjust_directory_permissions_mock.called)1345 self.assertEqual(result[0], 0)1346 _reset_mocks()1347 # Scenario: user is already defined, but user wants to reconfigure it1348 read_ambari_user_mock.return_value = "dummy-user"1349 get_validated_string_input_mock.side_effect = ["new-dummy-user", "new_password"]1350 get_YN_input_mock.return_value = True1351 find_user_mock.return_value = False1352 create_user_mock.return_value = (0, "User created")1353 add_user_privilege_mock.return_value = (0, "Privilege added")1354 result = check_ambari_user(options)1355 self.assertTrue(get_YN_input_mock.called)1356 self.assertEqual(result[2], ".\\new-dummy-user")1357 self.assertTrue(get_validated_string_input_mock.called)1358 self.assertTrue(adjust_directory_permissions_mock.called)1359 self.assertTrue(find_user_mock.called)1360 self.assertTrue(create_user_mock.called)1361 self.assertTrue(add_user_privilege_mock.called)1362 self.assertEqual(result[0], 0)1363 _reset_mocks()1364 # Negative scenario: user is already defined, but user wants1365 # to reconfigure it, user creation failed1366 read_ambari_user_mock.return_value = "dummy-user"1367 get_validated_string_input_mock.side_effect = ["new-dummy-user", "new_password"]1368 find_user_mock.return_value = False1369 create_user_mock.return_value = (-1, "Failed")1370 get_YN_input_mock.return_value = True1371 result = check_ambari_user(options)1372 self.assertTrue(get_YN_input_mock.called)1373 self.assertTrue(get_validated_string_input_mock.called)1374 self.assertTrue(create_user_mock.called)1375 self.assertFalse(adjust_directory_permissions_mock.called)1376 self.assertEqual(result[0], -1)1377 _reset_mocks()1378 # Scenario: user is not defined (setup process)1379 read_ambari_user_mock.return_value = None1380 get_YN_input_mock.return_value = True1381 get_validated_string_input_mock.side_effect = ["dummy-user", "new_password"]1382 create_user_mock.return_value = (0, "User created")1383 result = check_ambari_user(options)1384 self.assertTrue(get_YN_input_mock.called)1385 self.assertTrue(get_validated_string_input_mock.called)1386 self.assertTrue(create_user_mock.called)1387 self.assertTrue(result[2] == ".\\dummy-user")1388 self.assertTrue(adjust_directory_permissions_mock.called)1389 self.assertEqual(result[0], 0)1390 _reset_mocks()1391 # Scenario: user is not defined, use system account (setup process)1392 read_ambari_user_mock.return_value = None1393 get_YN_input_mock.return_value = True1394 get_validated_string_input_mock.side_effect = ["NT AUTHORITY\\SYSTEM"]1395 create_user_mock.return_value = (0, "User created")1396 result = check_ambari_user(options)1397 self.assertTrue(get_YN_input_mock.called)1398 self.assertTrue(get_validated_string_input_mock.called)1399 self.assertEqual(get_validated_string_input_mock.call_count, 1)1400 self.assertFalse(find_user_mock.called)1401 self.assertFalse(create_user_mock.called)1402 self.assertTrue(result[2] == "NT AUTHORITY\\SYSTEM")1403 self.assertTrue(adjust_directory_permissions_mock.called)1404 self.assertEqual(result[0], 0)1405 _reset_mocks()1406 # Scenario: user is not defined (setup process), user creation failed1407 read_ambari_user_mock.return_value = None1408 get_YN_input_mock.return_value = True1409 get_validated_string_input_mock.side_effect = ["new-dummy-user", "new_password"]1410 find_user_mock.return_value = False1411 create_user_mock.return_value = (-1, "Failed")1412 result = check_ambari_user(options)1413 self.assertTrue(get_YN_input_mock.called)1414 self.assertTrue(get_validated_string_input_mock.called)1415 self.assertTrue(create_user_mock.called)1416 self.assertFalse(adjust_directory_permissions_mock.called)1417 self.assertEqual(result[0], -1)1418 _reset_mocks()1419 # Scenario: user is not defined and left to be the default1420 read_ambari_user_mock.return_value = None1421 get_YN_input_mock.return_value = False1422 result = check_ambari_user(options)1423 self.assertTrue(get_YN_input_mock.called)1424 self.assertFalse(get_validated_string_input_mock.called)1425 self.assertFalse(run_os_command_mock.called)1426 self.assertTrue(result[2] == "NT AUTHORITY\\SYSTEM")1427 self.assertTrue(adjust_directory_permissions_mock.called)1428 self.assertEqual(result[0], 0)1429 pass1430 @patch("ambari_server.serverConfiguration.search_file")1431 @patch("__builtin__.open")1432 @patch("ambari_server.serverConfiguration.read_ambari_user")1433 @patch("ambari_server.serverConfiguration.set_file_permissions")1434 def test_store_password_file(self, set_file_permissions_mock,1435 read_ambari_user_mock, open_mock, search_file_mock):1436 search_file_mock.return_value = "/etc/ambari-server/conf/ambari.properties"1437 open_mock.return_value = MagicMock()1438 store_password_file("password", "passfile")1439 self.assertTrue(set_file_permissions_mock.called)1440 pass1441 @patch("subprocess.Popen")1442 @patch.object(OSCheck, "get_os_family")1443 @patch.object(OSCheck, "get_os_type")1444 @patch.object(OSCheck, "get_os_major_version")1445 def test_check_firewall_is_running(self, get_os_major_version_mock, get_os_type_mock, get_os_family_mock, popen_mock):1446 get_os_major_version_mock.return_value = 181447 get_os_type_mock.return_value = OSConst.OS_FEDORA1448 get_os_family_mock.return_value = OSConst.REDHAT_FAMILY1449 firewall_obj = Firewall().getFirewallObject()1450 p = MagicMock()1451 p.communicate.return_value = ("active", "err")1452 p.returncode = 01453 popen_mock.return_value = p1454 self.assertEqual("Fedora18FirewallChecks", firewall_obj.__class__.__name__)1455 self.assertTrue(firewall_obj.check_firewall())1456 p.communicate.return_value = ("", "err")1457 p.returncode = 31458 self.assertFalse(firewall_obj.check_firewall())1459 self.assertEqual("err", firewall_obj.stderrdata)1460 get_os_type_mock.return_value = OSConst.OS_UBUNTU1461 get_os_family_mock.return_value = OSConst.UBUNTU_FAMILY1462 firewall_obj = Firewall().getFirewallObject()1463 p.communicate.return_value = ("Status: active", "err")1464 p.returncode = 01465 self.assertEqual("UbuntuFirewallChecks", firewall_obj.__class__.__name__)1466 self.assertTrue(firewall_obj.check_firewall())1467 p.communicate.return_value = ("Status: inactive", "err")1468 p.returncode = 01469 self.assertFalse(firewall_obj.check_firewall())1470 self.assertEqual("err", firewall_obj.stderrdata)1471 get_os_type_mock.return_value = ""1472 get_os_family_mock.return_value = OSConst.SUSE_FAMILY1473 firewall_obj = Firewall().getFirewallObject()1474 p.communicate.return_value = ("### iptables", "err")1475 p.returncode = 01476 self.assertEqual("SuseFirewallChecks", firewall_obj.__class__.__name__)1477 self.assertTrue(firewall_obj.check_firewall())1478 p.communicate.return_value = ("SuSEfirewall2 not active", "err")1479 p.returncode = 01480 self.assertFalse(firewall_obj.check_firewall())1481 self.assertEqual("err", firewall_obj.stderrdata)1482 get_os_type_mock.return_value = ""1483 get_os_family_mock.return_value = OSConst.REDHAT_FAMILY1484 firewall_obj = Firewall().getFirewallObject()1485 p.communicate.return_value = ("Table: filter", "err")1486 p.returncode = 01487 self.assertEqual("FirewallChecks", firewall_obj.__class__.__name__)1488 self.assertTrue(firewall_obj.check_firewall())1489 p.communicate.return_value = ("", "err")1490 p.returncode = 31491 self.assertFalse(firewall_obj.check_firewall())1492 self.assertEqual("err", firewall_obj.stderrdata)1493 pass1494 @patch("ambari_server.setupHttps.get_validated_filepath_input")1495 @patch("ambari_server.setupHttps.get_validated_string_input")1496 @patch("ambari_server.setupHttps.run_os_command")1497 @patch("ambari_server.setupHttps.get_truststore_type")1498 @patch("__builtin__.open")1499 @patch("ambari_server.setupHttps.find_properties_file")1500 @patch("ambari_server.setupHttps.run_component_https_cmd")1501 @patch("ambari_server.setupHttps.get_delete_cert_command")1502 @patch("ambari_server.setupHttps.get_truststore_password")1503 @patch("ambari_server.setupHttps.get_truststore_path")1504 @patch("ambari_server.setupHttps.get_YN_input")1505 @patch("ambari_server.setupHttps.get_ambari_properties")1506 @patch("ambari_server.setupHttps.find_jdk")1507 def test_setup_truststore(self, find_jdk_mock, get_ambari_properties_mock, get_YN_input_mock,1508 get_truststore_path_mock, get_truststore_password_mock,1509 get_delete_cert_command_mock, run_component_https_cmd_mock,1510 find_properties_file_mock, open_mock,1511 get_truststore_type_mock, run_os_command_mock,1512 get_validated_string_input_mock,1513 get_validated_filepath_input_mock):1514 out = StringIO.StringIO()1515 sys.stdout = out1516 component = "component"1517 command = "command"1518 property = "use_ssl"1519 alias = "alias"1520 #Silent mode1521 set_silent(True)1522 setup_truststore()1523 self.assertEqual('setup-security is not enabled in silent mode.\n', out.getvalue())1524 sys.stdout = sys.__stdout__1525 #Verbouse mode and jdk_path is None1526 set_silent(False)1527 p = get_ambari_properties_mock.return_value1528 # Dont disable ssl1529 get_YN_input_mock.side_effect = [False]1530 get_validated_string_input_mock.return_value = "alias"1531 setup_truststore()1532 self.assertTrue(get_YN_input_mock.called)1533 p.get_property.reset_mock()1534 get_YN_input_mock.reset_mock()1535 # Cant find jdk1536 find_jdk_mock.return_value = None1537 try:1538 setup_truststore()1539 self.fail("Should throw exception")1540 except FatalException as fe:1541 # Expected1542 self.assertTrue('No JDK found, please run the "ambari-server setup" command to install a' +1543 ' JDK automatically or install any JDK manually to ' in fe.reason)1544 pass1545 #Verbouse mode and jdk_path is not None (use_https = true)1546 find_jdk_mock.return_value = "/jdk_path"1547 p.get_property.side_effect = ["true"]1548 get_YN_input_mock.side_effect = [True,True]1549 get_truststore_path_mock.return_value = "/truststore_path"1550 get_truststore_password_mock.return_value = "/truststore_password"1551 get_delete_cert_command_mock.return_value = "rm -f"1552 setup_truststore(True)1553 self.assertTrue(get_truststore_path_mock.called)1554 self.assertTrue(get_truststore_password_mock.called)1555 self.assertTrue(get_delete_cert_command_mock.called)1556 self.assertTrue(find_properties_file_mock.called)1557 self.assertTrue(open_mock.called)1558 self.assertTrue(p.store.called)1559 self.assertTrue(run_component_https_cmd_mock.called)1560 p.process_pair.reset_mock()1561 get_truststore_path_mock.reset_mock()1562 get_truststore_password_mock.reset_mock()1563 get_delete_cert_command_mock.reset_mock()1564 find_properties_file_mock.reset_mock()1565 open_mock.reset_mock()1566 p.store.reset_mock()1567 #Verbouse mode and jdk_path is not None (use_https = false) and import cert1568 p.get_property.side_effect = ["false"]1569 get_YN_input_mock.side_effect = [True,True]1570 setup_truststore(True)1571 self.assertTrue(get_truststore_type_mock.called)1572 self.assertTrue(get_truststore_path_mock.called)1573 self.assertTrue(get_truststore_password_mock.called)1574 self.assertTrue(get_delete_cert_command_mock.called)1575 self.assertTrue(find_properties_file_mock.called)1576 self.assertTrue(open_mock.called)1577 self.assertTrue(p.store.called)1578 self.assertTrue(run_component_https_cmd_mock.called)1579 self.assertTrue(run_os_command_mock.called)1580 self.assertTrue(get_validated_filepath_input_mock.called)1581 p.process_pair.reset_mock()1582 get_truststore_type_mock.reset_mock()1583 get_truststore_path_mock.reset_mock()1584 get_truststore_password_mock.reset_mock()1585 get_delete_cert_command_mock.reset_mock()1586 find_properties_file_mock.reset_mock()1587 open_mock.reset_mock()1588 p.store.reset_mock()1589 run_os_command_mock.reset_mock()1590 get_validated_filepath_input_mock.reset_mock()1591 pass1592 @patch("ambari_server.setupHttps.adjust_directory_permissions")1593 @patch("ambari_server.setupHttps.read_ambari_user")1594 @patch("ambari_server.setupHttps.get_validated_string_input")1595 @patch("ambari_server.setupHttps.find_properties_file")1596 @patch("ambari_server.setupHttps.get_ambari_properties")1597 @patch("ambari_server.setupHttps.import_cert_and_key_action")1598 @patch("ambari_server.setupHttps.get_YN_input")1599 @patch("__builtin__.open")1600 @patch("ambari_server.setupHttps.is_root")1601 @patch("ambari_server.setupHttps.is_valid_cert_host")1602 @patch("ambari_server.setupHttps.is_valid_cert_exp")1603 def test_setup_https(self, is_valid_cert_exp_mock, is_valid_cert_host_mock, \1604 is_root_mock, open_Mock, get_YN_input_mock, \1605 import_cert_and_key_action_mock,1606 get_ambari_properties_mock, \1607 find_properties_file_mock, \1608 get_validated_string_input_mock, read_ambari_user_method, \1609 adjust_directory_permissions_mock):1610 is_valid_cert_exp_mock.return_value = True1611 is_valid_cert_host_mock.return_value = True1612 args = MagicMock()1613 open_Mock.return_value = file1614 p = get_ambari_properties_mock.return_value1615 # Testing call under non-root1616 is_root_mock.return_value = False1617 try:1618 setup_https(args)1619 self.fail("Should throw exception")1620 except FatalException as fe:1621 # Expected1622 self.assertTrue("root-level" in fe.reason)1623 pass1624 # Testing call under root1625 is_root_mock.return_value = True1626 read_ambari_user_method.return_value = "user"1627 #Case #1: if client ssl is on and user didnt choose1628 #disable ssl option and choose import certs and keys1629 p.get_property.side_effect = ["key_dir", "5555", "6666", "true"]1630 get_YN_input_mock.side_effect = [False, True]1631 get_validated_string_input_mock.side_effect = ["4444"]1632 get_property_expected = "[call('security.server.keys_dir'),\n" + \1633 " call('client.api.ssl.port'),\n" + \1634 " call('client.api.ssl.port'),\n call('api.ssl')]"1635 process_pair_expected = "[call('client.api.ssl.port', '4444')]"1636 set_silent(False)1637 setup_https(args)1638 self.assertTrue(p.process_pair.called)1639 self.assertTrue(p.get_property.call_count == 4)1640 self.assertEqual(str(p.get_property.call_args_list), get_property_expected)1641 self.assertEqual(str(p.process_pair.call_args_list), process_pair_expected)1642 self.assertTrue(p.store.called)1643 self.assertTrue(import_cert_and_key_action_mock.called)1644 p.process_pair.reset_mock()1645 p.get_property.reset_mock()1646 p.store.reset_mock()1647 import_cert_and_key_action_mock.reset_mock()1648 #Case #2: if client ssl is on and user choose to disable ssl option1649 p.get_property.side_effect = ["key_dir", "", "true"]1650 get_YN_input_mock.side_effect = [True]1651 get_validated_string_input_mock.side_effect = ["4444"]1652 get_property_expected = "[call('security.server.keys_dir'),\n" + \1653 " call('client.api.ssl.port'),\n call('api.ssl')]"1654 process_pair_expected = "[call('api.ssl', 'false')]"1655 setup_https(args)1656 self.assertTrue(p.process_pair.called)1657 self.assertTrue(p.get_property.call_count == 3)1658 self.assertEqual(str(p.get_property.call_args_list), get_property_expected)1659 self.assertEqual(str(p.process_pair.call_args_list), process_pair_expected)1660 self.assertTrue(p.store.called)1661 self.assertFalse(import_cert_and_key_action_mock.called)1662 p.process_pair.reset_mock()1663 p.get_property.reset_mock()1664 p.store.reset_mock()1665 import_cert_and_key_action_mock.reset_mock()1666 #Case #3: if client ssl is off and user choose option1667 #to import cert and keys1668 p.get_property.side_effect = ["key_dir", "", None]1669 get_YN_input_mock.side_effect = [True, True]1670 get_validated_string_input_mock.side_effect = ["4444"]1671 get_property_expected = "[call('security.server.keys_dir'),\n" + \1672 " call('client.api.ssl.port'),\n call('api.ssl')]"1673 process_pair_expected = "[call('client.api.ssl.port', '4444')]"1674 setup_https(args)1675 self.assertTrue(p.process_pair.called)1676 self.assertTrue(p.get_property.call_count == 3)1677 self.assertEqual(str(p.get_property.call_args_list), get_property_expected)1678 self.assertEqual(str(p.process_pair.call_args_list), process_pair_expected)1679 self.assertTrue(p.store.called)1680 self.assertTrue(import_cert_and_key_action_mock.called)1681 p.process_pair.reset_mock()1682 p.get_property.reset_mock()1683 p.store.reset_mock()1684 import_cert_and_key_action_mock.reset_mock()1685 #Case #4: if client ssl is off and1686 #user did not choose option to import cert and keys1687 p.get_property.side_effect = ["key_dir", "", None]1688 get_YN_input_mock.side_effect = [False]1689 get_validated_string_input_mock.side_effect = ["4444"]1690 get_property_expected = "[call('security.server.keys_dir'),\n" + \1691 " call('client.api.ssl.port'),\n call('api.ssl')]"1692 process_pair_expected = "[]"1693 setup_https(args)1694 self.assertFalse(p.process_pair.called)1695 self.assertTrue(p.get_property.call_count == 3)1696 self.assertEqual(str(p.get_property.call_args_list), get_property_expected)1697 self.assertEqual(str(p.process_pair.call_args_list), process_pair_expected)1698 self.assertFalse(p.store.called)1699 self.assertFalse(import_cert_and_key_action_mock.called)1700 p.process_pair.reset_mock()1701 p.get_property.reset_mock()1702 p.store.reset_mock()1703 import_cert_and_key_action_mock.reset_mock()1704 #Case #5: if cert must be imported but didnt imported1705 p.get_property.side_effect = ["key_dir", "", "false"]1706 get_YN_input_mock.side_effect = [True]1707 import_cert_and_key_action_mock.side_effect = [False]1708 get_validated_string_input_mock.side_effect = ["4444"]1709 get_property_expected = "[call('security.server.keys_dir'),\n" + \1710 " call('client.api.ssl.port'),\n call('api.ssl')]"1711 process_pair_expected = "[call('client.api.ssl.port', '4444')]"1712 self.assertFalse(setup_https(args))1713 self.assertTrue(p.process_pair.called)1714 self.assertTrue(p.get_property.call_count == 3)1715 self.assertEqual(str(p.get_property.call_args_list), get_property_expected)1716 self.assertEqual(str(p.process_pair.call_args_list), process_pair_expected)1717 self.assertFalse(p.store.called)1718 self.assertTrue(import_cert_and_key_action_mock.called)1719 p.process_pair.reset_mock()1720 p.get_property.reset_mock()1721 p.store.reset_mock()1722 import_cert_and_key_action_mock.reset_mock()1723 #Case #6: if silent mode is enabled1724 set_silent(True)1725 try:1726 setup_https(args)1727 self.fail("Should throw exception")1728 except NonFatalException as fe:1729 self.assertTrue("setup-https is not enabled in silent mode" in fe.reason)1730 p.process_pair.reset_mock()1731 p.get_property.reset_mock()1732 p.store.reset_mock()1733 import_cert_and_key_action_mock.reset_mock()1734 #Case #7: read property throw exception1735 set_silent(False)1736 find_properties_file_mock.return_value = "propertyFile"1737 p.get_property.side_effect = KeyError("Failed to read property")1738 try:1739 setup_https(args)1740 self.fail("Should throw exception")1741 except FatalException as fe:1742 self.assertTrue("Failed to read property" in fe.reason)1743 pass1744 @patch("ambari_server.setupHttps.import_cert_and_key")1745 def test_import_cert_and_key_action(self, import_cert_and_key_mock):1746 import_cert_and_key_mock.return_value = True1747 properties = MagicMock()1748 properties.get_property.side_effect = ["key_dir", "5555", "6666", "true"]1749 properties.process_pair = MagicMock()1750 expect_process_pair = "[call('client.api.ssl.cert_name', 'https.crt'),\n" + \1751 " call('client.api.ssl.key_name', 'https.key'),\n" + \1752 " call('api.ssl', 'true')]"1753 import_cert_and_key_action("key_dir", properties)1754 self.assertEqual(str(properties.process_pair.call_args_list), \1755 expect_process_pair)1756 pass1757 @patch("ambari_server.setupHttps.remove_file")1758 @patch("ambari_server.setupHttps.copy_file")1759 @patch("ambari_server.setupHttps.read_ambari_user")1760 @patch("ambari_server.setupHttps.set_file_permissions")1761 @patch("ambari_server.setupHttps.import_file_to_keystore")1762 @patch("__builtin__.open")1763 @patch("ambari_server.setupHttps.run_os_command")1764 @patch("os.path.join")1765 @patch("os.path.isfile")1766 @patch("__builtin__.raw_input")1767 @patch("ambari_server.setupHttps.get_validated_string_input")1768 @patch("ambari_server.setupHttps.is_valid_cert_host")1769 @patch("ambari_server.setupHttps.is_valid_cert_exp")1770 def test_import_cert_and_key(self, is_valid_cert_exp_mock, \1771 is_valid_cert_host_mock, \1772 get_validated_string_input_mock, \1773 raw_input_mock, \1774 os_path_isfile_mock, \1775 os_path_join_mock, run_os_command_mock, \1776 open_mock, import_file_to_keystore_mock, \1777 set_file_permissions_mock, read_ambari_user_mock, copy_file_mock, \1778 remove_file_mock):1779 is_valid_cert_exp_mock.return_value = True1780 is_valid_cert_host_mock.return_value = True1781 os_path_isfile_mock.return_value = True1782 get_validated_string_input_mock.return_value = "password"1783 raw_input_mock.side_effect = \1784 ["cert_file_path", "key_file_path"]1785 os_path_join_mock.side_effect = ["keystore_file_path", "keystore_file_path_tmp", \1786 "pass_file_path", "pass_file_path_tmp", \1787 "passin_file_path", "password_file_path", \1788 "keystore_cert_file_path", \1789 "keystore_cert_key_file_path", ]1790 run_os_command_mock.return_value = (0, "", "")1791 om = open_mock.return_value1792 expect_import_file_to_keystore = "[call('keystore_file_path_tmp'," + \1793 " 'keystore_file_path'),\n" + \1794 " call('pass_file_path_tmp'," + \1795 " 'pass_file_path'),\n" + \1796 " call('cert_file_path'," + \1797 " 'keystore_cert_file_path'),\n" + \1798 " call('key_file_path'," + \1799 " 'keystore_cert_key_file_path')]"1800 import_cert_and_key("key_dir")1801 self.assertTrue(raw_input_mock.call_count == 2)1802 self.assertTrue(get_validated_string_input_mock.called)1803 self.assertEqual(os_path_join_mock.call_count, 8)1804 self.assertTrue(set_file_permissions_mock.call_count == 1)1805 self.assertEqual(str(import_file_to_keystore_mock.call_args_list), \1806 expect_import_file_to_keystore)1807 pass1808 @patch("ambari_server.setupHttps.remove_file")1809 @patch("ambari_server.setupHttps.copy_file")1810 @patch("ambari_server.setupHttps.generate_random_string")1811 @patch("ambari_server.setupHttps.read_ambari_user")1812 @patch("ambari_server.setupHttps.set_file_permissions")1813 @patch("ambari_server.setupHttps.import_file_to_keystore")1814 @patch("__builtin__.open")1815 @patch("ambari_server.setupHttps.run_os_command")1816 @patch("os.path.join")1817 @patch("ambari_server.setupHttps.get_validated_filepath_input")1818 @patch("ambari_server.setupHttps.get_validated_string_input")1819 @patch("ambari_server.setupHttps.is_valid_cert_host")1820 @patch("ambari_server.setupHttps.is_valid_cert_exp")1821 def test_import_cert_and_key_with_empty_password(self, \1822 is_valid_cert_exp_mock, is_valid_cert_host_mock,1823 get_validated_string_input_mock, get_validated_filepath_input_mock, \1824 os_path_join_mock, run_os_command_mock, open_mock, \1825 import_file_to_keystore_mock, set_file_permissions_mock,1826 read_ambari_user_mock, generate_random_string_mock, copy_file_mock, \1827 remove_file_mock):1828 is_valid_cert_exp_mock.return_value = True1829 is_valid_cert_host_mock.return_value = True1830 get_validated_string_input_mock.return_value = ""1831 get_validated_filepath_input_mock.side_effect = \1832 ["cert_file_path", "key_file_path"]1833 os_path_join_mock.side_effect = ["keystore_file_path", "keystore_file_path_tmp", \1834 "pass_file_path", "pass_file_path_tmp", \1835 "passin_file_path", "password_file_path", \1836 "keystore_cert_file_path", \1837 "keystore_cert_key_file_path", ]1838 run_os_command_mock.return_value = (0, "", "")1839 expect_import_file_to_keystore = "[call('keystore_file_path_tmp'," + \1840 " 'keystore_file_path'),\n" + \1841 " call('pass_file_path_tmp'," + \1842 " 'pass_file_path'),\n" + \1843 " call('cert_file_path'," + \1844 " 'keystore_cert_file_path'),\n" + \1845 " call('key_file_path.secured'," + \1846 " 'keystore_cert_key_file_path')]"1847 import_cert_and_key("key_dir")1848 self.assertEquals(get_validated_filepath_input_mock.call_count, 2)1849 self.assertTrue(get_validated_string_input_mock.called)1850 self.assertEquals(os_path_join_mock.call_count, 8)1851 self.assertEquals(set_file_permissions_mock.call_count, 1)1852 self.assertEqual(str(import_file_to_keystore_mock.call_args_list), \1853 expect_import_file_to_keystore)1854 self.assertTrue(generate_random_string_mock.called)1855 pass1856 @patch("__builtin__.open")1857 @patch("ambari_server.setupHttps.copy_file")1858 @patch("ambari_server.setupHttps.is_root")1859 @patch("ambari_server.setupHttps.read_ambari_user")1860 @patch("ambari_server.setupHttps.set_file_permissions")1861 @patch("ambari_server.setupHttps.import_file_to_keystore")1862 @patch("ambari_server.setupHttps.run_os_command")1863 @patch("os.path.join")1864 @patch("ambari_server.setupHttps.get_validated_filepath_input")1865 @patch("ambari_server.setupHttps.get_validated_string_input")1866 def test_import_cert_and_key_with_incorrect_password(self,1867 get_validated_string_input_mock, \1868 get_validated_filepath_input_mock, \1869 os_path_join_mock, \1870 run_os_command_mock, \1871 import_file_to_keystore_mock, \1872 set_file_permissions_mock, \1873 read_ambari_user_mock, \1874 is_root_mock, \1875 copy_file_mock, \1876 open_mock):1877 get_validated_string_input_mock.return_value = "incorrect_password"1878 get_validated_filepath_input_mock.return_value = 'filename'1879 open_mock.return_value = MagicMock()1880 os_path_join_mock.return_value = ''1881 is_root_mock.return_value = True1882 #provided password doesn't match, openssl command returns an error1883 run_os_command_mock.return_value = (1, "", "Some error message")1884 self.assertFalse(import_cert_and_key_action(*["key_dir", None]))1885 self.assertFalse(import_cert_and_key("key_dir"))1886 pass1887 def test_is_valid_cert_exp(self):1888 #No data in certInfo1889 certInfo = {}1890 is_valid = is_valid_cert_exp(certInfo)1891 self.assertFalse(is_valid)1892 #Issued in future1893 issuedOn = (datetime.datetime.now() + datetime.timedelta(hours=1000)).strftime(SSL_DATE_FORMAT)1894 expiresOn = (datetime.datetime.now() + datetime.timedelta(hours=2000)).strftime(SSL_DATE_FORMAT)1895 certInfo = {NOT_BEFORE_ATTR: issuedOn,1896 NOT_AFTER_ATTR: expiresOn}1897 is_valid = is_valid_cert_exp(certInfo)1898 self.assertFalse(is_valid)1899 #Was expired1900 issuedOn = (datetime.datetime.now() - datetime.timedelta(hours=2000)).strftime(SSL_DATE_FORMAT)1901 expiresOn = (datetime.datetime.now() - datetime.timedelta(hours=1000)).strftime(SSL_DATE_FORMAT)1902 certInfo = {NOT_BEFORE_ATTR: issuedOn,1903 NOT_AFTER_ATTR: expiresOn}1904 is_valid = is_valid_cert_exp(certInfo)1905 self.assertFalse(is_valid)1906 #Valid1907 issuedOn = (datetime.datetime.now() - datetime.timedelta(hours=2000)).strftime(SSL_DATE_FORMAT)1908 expiresOn = (datetime.datetime.now() + datetime.timedelta(hours=1000)).strftime(SSL_DATE_FORMAT)1909 certInfo = {NOT_BEFORE_ATTR: issuedOn,1910 NOT_AFTER_ATTR: expiresOn}1911 is_valid = is_valid_cert_exp(certInfo)1912 self.assertTrue(is_valid)1913 pass1914 @patch("ambari_server.setupHttps.get_fqdn")1915 def test_is_valid_cert_host(self, get_fqdn_mock):1916 #No data in certInfo1917 certInfo = {}1918 is_valid = is_valid_cert_host(certInfo)1919 self.assertFalse(is_valid)1920 #Failed to get FQDN1921 get_fqdn_mock.return_value = None1922 is_valid = is_valid_cert_host(certInfo)1923 self.assertFalse(is_valid)1924 #FQDN and Common name in certificated don't correspond1925 get_fqdn_mock.return_value = 'host1'1926 certInfo = {COMMON_NAME_ATTR: 'host2'}1927 is_valid = is_valid_cert_host(certInfo)1928 self.assertFalse(is_valid)1929 #FQDN and Common name in certificated correspond1930 get_fqdn_mock.return_value = 'host1'1931 certInfo = {COMMON_NAME_ATTR: 'host1'}1932 is_valid = is_valid_cert_host(certInfo)1933 self.assertTrue(is_valid)1934 pass1935 @patch("ambari_server.setupHttps.get_ambari_properties")1936 def test_is_valid_https_port(self, get_ambari_properties_mock):1937 #No ambari.properties1938 get_ambari_properties_mock.return_value = -11939 is_valid = is_valid_https_port(1111)1940 self.assertEqual(is_valid, False)1941 #User entered port used by one way auth1942 portOneWay = "1111"1943 portTwoWay = "2222"1944 validPort = "3333"1945 get_ambari_properties_mock.return_value = {SRVR_ONE_WAY_SSL_PORT_PROPERTY: portOneWay,1946 SRVR_TWO_WAY_SSL_PORT_PROPERTY: portTwoWay}1947 is_valid = is_valid_https_port(portOneWay)1948 self.assertEqual(is_valid, False)1949 #User entered port used by two way auth1950 is_valid = is_valid_https_port(portTwoWay)1951 self.assertEqual(is_valid, False)1952 #User entered valid port1953 get_ambari_properties_mock.return_value = {SRVR_ONE_WAY_SSL_PORT_PROPERTY: portOneWay,1954 SRVR_TWO_WAY_SSL_PORT_PROPERTY: portTwoWay}1955 is_valid = is_valid_https_port(validPort)1956 self.assertEqual(is_valid, True)1957 pass1958 @patch("socket.getfqdn")1959 @patch("urllib2.urlopen")1960 @patch("ambari_server.setupHttps.get_ambari_properties")1961 def test_get_fqdn(self, get_ambari_properties_mock, url_open_mock, getfqdn_mock):1962 #No ambari.properties1963 get_ambari_properties_mock.return_value = -11964 fqdn = get_fqdn()1965 self.assertEqual(fqdn, None)1966 #Check mbari_server.GET_FQDN_SERVICE_URL property name (AMBARI-2612)1967 #property name should be server.fqdn.service.url1968 self.assertEqual(GET_FQDN_SERVICE_URL, "server.fqdn.service.url")1969 #Read FQDN from service1970 p = MagicMock()1971 p[GET_FQDN_SERVICE_URL] = 'someurl'1972 get_ambari_properties_mock.return_value = p1973 u = MagicMock()1974 host = 'host1.domain.com'1975 u.read.return_value = host1976 url_open_mock.return_value = u1977 fqdn = get_fqdn()1978 self.assertEqual(fqdn, host)1979 #Failed to read FQDN from service, getting from socket1980 u.reset_mock()1981 u.side_effect = Exception("Failed to read FQDN from service")1982 getfqdn_mock.return_value = host1983 fqdn = get_fqdn()1984 self.assertEqual(fqdn, host)1985 pass1986 def test_get_ulimit_open_files(self):1987 # 1 - No ambari.properties1988 p = Properties()1989 open_files = get_ulimit_open_files(p)1990 self.assertEqual(open_files, ULIMIT_OPEN_FILES_DEFAULT)1991 # 2 - With ambari.properties - ok1992 prop_value = 650001993 p.process_pair(ULIMIT_OPEN_FILES_KEY, str(prop_value))1994 open_files = get_ulimit_open_files(p)1995 self.assertEqual(open_files, 65000)1996 # 2 - With ambari.properties - default1997 tf1 = tempfile.NamedTemporaryFile()1998 prop_value = 01999 p.process_pair(ULIMIT_OPEN_FILES_KEY, str(prop_value))2000 open_files = get_ulimit_open_files(p)2001 self.assertEqual(open_files, ULIMIT_OPEN_FILES_DEFAULT)2002 pass2003 @patch("ambari_server.setupHttps.run_os_command")2004 def test_get_cert_info(self, run_os_command_mock):2005 # Error running openssl command2006 path = 'path/to/certificate'2007 run_os_command_mock.return_value = -1, None, None2008 cert_info = get_cert_info(path)2009 self.assertEqual(cert_info, None)2010 #Empty result of openssl command2011 run_os_command_mock.return_value = 0, None, None2012 cert_info = get_cert_info(path)2013 self.assertEqual(cert_info, None)2014 #Positive scenario2015 notAfter = 'Jul 3 14:12:57 2014 GMT'2016 notBefore = 'Jul 3 14:12:57 2013 GMT'2017 attr1_key = 'A'2018 attr1_value = 'foo'2019 attr2_key = 'B'2020 attr2_value = 'bar'2021 attr3_key = 'CN'2022 attr3_value = 'host.domain.com'2023 subject_pattern = '/{attr1_key}={attr1_value}/{attr2_key}={attr2_value}/{attr3_key}={attr3_value}'2024 subject = subject_pattern.format(attr1_key=attr1_key, attr1_value=attr1_value,2025 attr2_key=attr2_key, attr2_value=attr2_value,2026 attr3_key=attr3_key, attr3_value=attr3_value)2027 out_pattern = \2028 "notAfter={notAfter}" + os.linesep + \2029 "notBefore={notBefore}" + os.linesep + \2030 "subject={subject}" + os.linesep + \2031 "-----BEGIN CERTIFICATE-----" + os.linesep + \2032 "MIIFHjCCAwYCCQDpHKOBI+Lt0zANBgkqhkiG9w0BAQUFADBRMQswCQYDVQQGEwJV" + os.linesep + \2033 "..." + os.linesep + \2034 "5lqd8XxOGSYoMOf+70BLN2sB" + os.linesep + \2035 "-----END CERTIFICATE-----" + os.linesep + \2036 ""2037 out = out_pattern.format(notAfter=notAfter, notBefore=notBefore, subject=subject)2038 run_os_command_mock.return_value = 0, out, None2039 cert_info = get_cert_info(path)2040 self.assertEqual(cert_info['notAfter'], notAfter)2041 self.assertEqual(cert_info['notBefore'], notBefore)2042 self.assertEqual(cert_info['subject'], subject)2043 self.assertEqual(cert_info[attr1_key], attr1_value)2044 self.assertEqual(cert_info[attr2_key], attr2_value)2045 self.assertEqual(cert_info[attr3_key], attr3_value)2046 pass2047 @patch("__builtin__.raw_input")2048 def test_get_validated_string_input(self, raw_input_mock):2049 prompt = 'prompt'2050 default_value = 'default'2051 description = 'desc'2052 validator = MagicMock()2053 validator.return_value = True2054 inputed_value1 = 'val1'2055 inputed_value2 = 'val2'2056 raw_input_mock.return_value = inputed_value12057 input = get_validated_string_input(prompt, default_value, None,2058 description, False, False, validator)2059 self.assertTrue(validator.called)2060 self.assertEqual(inputed_value1, input)2061 validator.side_effect = [False, True]2062 raw_input_mock.side_effect = [inputed_value1, inputed_value2]2063 input = get_validated_string_input(prompt, default_value, None,2064 description, False, False, validator)2065 self.assertEqual(inputed_value2, input)2066 pass2067 @not_for_platform(PLATFORM_WINDOWS)2068 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))2069 @patch("ambari_server.serverUtils.run_os_command")2070 @patch("__builtin__.open")2071 @patch("os.path.exists")2072 def test_is_server_runing(self, os_path_exists_mock, open_mock, \2073 run_os_command_mock):2074 os_path_exists_mock.return_value = True2075 f = open_mock.return_value2076 f.readline.return_value = "111"2077 run_os_command_mock.return_value = 0, "", ""2078 status, pid = is_server_runing()2079 self.assertTrue(status)2080 self.assertEqual(111, pid)2081 os_path_exists_mock.return_value = False2082 status, pid = is_server_runing()2083 self.assertFalse(status)2084 pass2085 @only_for_platform(PLATFORM_WINDOWS)2086 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))2087 @patch("os_windows.win32serviceutil.QueryServiceStatus")2088 def test_is_server_runing(self, query_service_status_mock):2089 query_service_status_mock.return_value = ("", 4)2090 status, desc = is_server_runing()2091 self.assertTrue(status)2092 self.assertEqual("", desc)2093 query_service_status_mock.return_value = ("", 1)2094 status, desc = is_server_runing()2095 self.assertFalse(status)2096 self.assertEqual("stopped", desc)2097 pass2098 @not_for_platform(PLATFORM_WINDOWS)2099 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))2100 @patch("ambari_server.serverUtils.run_os_command")2101 @patch("__builtin__.open")2102 @patch("os.path.exists")2103 def test_is_server_runing_bad_file(self, os_path_exists_mock, open_mock, \2104 run_os_command_mock):2105 os_path_exists_mock.return_value = True2106 f = open_mock.return_value2107 f.readline.return_value = "" # empty file content2108 run_os_command_mock.return_value = 0, "", ""2109 self.assertRaises(NonFatalException, is_server_runing)2110 open_mock.side_effect = IOError('[Errno 13] Permission denied: /var/run/ambari-server/ambari-server.pid')2111 self.assertRaises(FatalException, is_server_runing)2112 pass2113 @not_for_platform(PLATFORM_WINDOWS)2114 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))2115 @patch("os.path.exists")2116 @patch("os.makedirs")2117 @patch("os.chdir")2118 @patch("ambari_server.serverSetup.run_os_command")2119 def test_install_jdk(self, run_os_command_mock, os_chdir_mock, os_makedirs_mock, os_path_exists_mock):2120 run_os_command_mock.return_value = 1, "", ""2121 os_path_exists_mock.return_value = False2122 failed = False2123 try:2124 jdkSetup = JDKSetup()2125 jdkSetup._install_jdk(MagicMock(), MagicMock())2126 self.fail("Exception was not rised!")2127 except FatalException:2128 failed = True2129 self.assertTrue(failed)2130 pass2131 @only_for_platform(PLATFORM_WINDOWS)2132 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))2133 @patch("os.path.exists")2134 @patch("os.makedirs")2135 @patch("os.chdir")2136 @patch("ambari_server.serverSetup.run_os_command")2137 def test_install_jdk(self, run_os_command_mock, os_chdir_mock, os_makedirs_mock, os_path_exists_mock):2138 jdk_cfg = MagicMock()2139 jdk_cfg.inst_dir = "java_home_dir"2140 run_os_command_mock.return_value = 1, "", ""2141 os_path_exists_mock.return_value = False2142 failed = False2143 try:2144 jdkSetup = JDKSetup()2145 jdkSetup._install_jdk("jdk.exe", jdk_cfg)2146 self.fail("Exception was not rised!")2147 except FatalException:2148 failed = True2149 self.assertTrue(failed)2150 pass2151 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))2152 @patch("ambari_server.serverSetup.read_ambari_user")2153 @patch("os.stat")2154 @patch("os.path.isfile")2155 @patch("os.path.exists")2156 @patch("os.chdir")2157 @patch("os.makedirs")2158 @patch("ambari_server.serverSetup.JDKSetupLinux.adjust_jce_permissions")2159 @patch("ambari_server.serverSetup.expand_jce_zip_file")2160 @patch("ambari_server.serverSetup.force_download_file")2161 @patch("ambari_server.serverSetup.get_YN_input")2162 @patch("ambari_server.serverSetup.run_os_command")2163 @patch("ambari_server.serverSetup.update_properties")2164 @patch("ambari_server.serverSetup.get_validated_string_input")2165 @patch("ambari_server.serverSetup.print_info_msg")2166 @patch("ambari_server.serverSetup.validate_jdk")2167 @patch("ambari_server.serverSetup.get_JAVA_HOME")2168 @patch("ambari_server.serverSetup.get_resources_location")2169 @patch("ambari_server.serverSetup.get_ambari_properties")2170 @patch("shutil.copyfile")2171 @patch("sys.exit")2172 def test_download_jdk(self, exit_mock, copyfile_mock, get_ambari_properties_mock, get_resources_location_mock, get_JAVA_HOME_mock, \2173 validate_jdk_mock, print_info_msg_mock, get_validated_string_input_mock, update_properties_mock, \2174 run_os_command_mock, get_YN_input_mock, force_download_file_mock, expand_jce_zip_file_mock,2175 adjust_jce_permissions_mock, os_makedirs_mock,2176 os_chdir_mock, path_existsMock, path_isfileMock, statMock, read_ambari_user_mock):2177 @OsFamilyFuncImpl(OSConst.WINSRV_FAMILY)2178 def _init_test_jdk_mocks():2179 jdk1_url = "http://somewhere/myjdk.exe"2180 res_location = "resources"2181 p = Properties()2182 p.process_pair("java.releases", "jdk1")2183 p.process_pair("jdk1.desc", "JDK name")2184 p.process_pair("jdk1.url", "http://somewhere/myjdk.exe")2185 p.process_pair("jdk1.dest-file", "myjdk.exe")2186 p.process_pair("jdk1.jcpol-url", "http://somewhere/some-jcpol.zip")2187 p.process_pair("jdk1.jcpol-file", "some-jcpol.zip")2188 p.process_pair("jdk1.home", "C:\\jdk1")2189 p.process_pair("jdk1.re", "(jdk.*)/jre")2190 pem_side_effect1 = [False, True, False]2191 return p, jdk1_url, res_location, pem_side_effect12192 @OsFamilyFuncImpl(OsFamilyImpl.DEFAULT)2193 def _init_test_jdk_mocks():2194 jdk1_url = "http://somewhere/somewhere.tar.gz"2195 res_location = MagicMock()2196 p = Properties()2197 p.process_pair("java.releases", "jdk1")2198 p.process_pair("jdk1.desc", "JDK name")2199 p.process_pair("jdk1.url", jdk1_url)2200 p.process_pair("jdk1.dest-file", "somewhere.tar.gz")2201 p.process_pair("jdk1.jcpol-url", "http://somewhere/some-jcpol.tar.gz")2202 p.process_pair("jdk1.jcpol-file", "some-jcpol.tar.gz")2203 p.process_pair("jdk1.home", "/jdk1")2204 p.process_pair("jdk1.re", "(jdk.*)/jre")2205 pem_side_effect1 = [True, False, True, False]2206 return p, jdk1_url, res_location, pem_side_effect12207 args = MagicMock()2208 args.java_home = "somewhere"2209 args.silent = False2210 p, jdk1_url, res_location, pem_side_effect1 = _init_test_jdk_mocks()2211 validate_jdk_mock.return_value = False2212 path_existsMock.return_value = False2213 get_resources_location_mock.return_value = res_location2214 get_JAVA_HOME_mock.return_value = False2215 read_ambari_user_mock.return_value = "ambari"2216 get_ambari_properties_mock.return_value = p2217 # Test case: ambari.properties not found2218 try:2219 download_and_install_jdk(args)2220 self.fail("Should throw exception because of not found ambari.properties")2221 except FatalException:2222 # Expected2223 self.assertTrue(get_ambari_properties_mock.called)2224 pass2225 # Test case: JDK already exists2226 args.java_home = None2227 args.jdk_location = None2228 get_JAVA_HOME_mock.return_value = "some_jdk"2229 validate_jdk_mock.return_value = True2230 get_YN_input_mock.return_value = False2231 path_existsMock.return_value = False2232 run_os_command_mock.return_value = 0, "", ""2233 rcode = download_and_install_jdk(args)2234 self.assertEqual(0, rcode)2235 # Test case: java home setup2236 args.java_home = "somewhere"2237 validate_jdk_mock.return_value = True2238 path_existsMock.return_value = False2239 get_JAVA_HOME_mock.return_value = None2240 rcode = download_and_install_jdk(args)2241 self.assertEqual(0, rcode)2242 self.assertTrue(update_properties_mock.called)2243 # Test case: JDK file does not exist, property not defined2244 validate_jdk_mock.return_value = False2245 path_existsMock.return_value = False2246 get_ambari_properties_mock.return_value = p2247 p.removeProp("jdk1.url")2248 try:2249 download_and_install_jdk(args)2250 self.fail("Should throw exception")2251 except FatalException:2252 # Expected2253 pass2254 # Test case: JDK file does not exist, HTTP response does not2255 # contain Content-Length2256 p.process_pair("jdk1.url", jdk1_url)2257 validate_jdk_mock.return_value = False2258 path_existsMock.return_value = False2259 get_YN_input_mock.return_value = True2260 get_validated_string_input_mock.return_value = "1"2261 run_os_command_mock.return_value = (0, "Wrong out", None)2262 try:2263 download_and_install_jdk(args)2264 self.fail("Should throw exception")2265 except FatalException:2266 # Expected2267 pass2268 # Successful JDK download2269 args.java_home = None2270 validate_jdk_mock.return_value = False2271 path_existsMock.reset_mock()2272 path_existsMock.side_effect = [False, False, False]2273 path_isfileMock.return_value = False2274 args.jdk_location = None2275 run_os_command_mock.return_value = (0, "Creating jdk1/jre", None)2276 statResult = MagicMock()2277 statResult.st_size = 320002278 statMock.return_value = statResult2279 try:2280 rcode = download_and_install_jdk(args)2281 except Exception, e:2282 raise2283 self.assertEqual(0, rcode)2284 # Test case: not accept the license"2285 get_YN_input_mock.return_value = False2286 path_existsMock.reset_mock()2287 path_existsMock.side_effect = [False, False, True, False, True, False]2288 download_and_install_jdk(args)2289 self.assertTrue(exit_mock.called)2290 # Test case: jdk is already installed, ensure that JCE check is skipped if -j option is not supplied.2291 args.jdk_location = None2292 get_JAVA_HOME_mock.return_value = "some_jdk"2293 validate_jdk_mock.return_value = True2294 get_YN_input_mock.return_value = False2295 path_existsMock.reset_mock()2296 path_existsMock.side_effect = pem_side_effect12297 force_download_file_mock.reset_mock()2298 with patch("ambari_server.serverSetup.JDKSetup._download_jce_policy") as download_jce_policy_mock:2299 rcode = download_and_install_jdk(args)2300 self.assertFalse(download_jce_policy_mock.called)2301 self.assertFalse(force_download_file_mock.called)2302 # Test case: Update JAVA_HOME location using command: ambari-server setup -j %NEW_LOCATION%2303 update_properties_mock.reset_mock()2304 args.java_home = "somewhere"2305 validate_jdk_mock.return_value = True2306 path_existsMock.reset_mock()2307 path_existsMock.side_effect = pem_side_effect12308 get_JAVA_HOME_mock.return_value = "some_jdk"2309 path_isfileMock.return_value = True2310 download_and_install_jdk(args)2311 self.assertTrue(update_properties_mock.call_count == 1)2312 # Test case: Negative test case JAVA_HOME location should not be updated if -j option is supplied and2313 # jce_policy file already exists in resources dir.2314 #write_property_mock.reset_mock()2315 #args.java_home = "somewhere"2316 #path_existsMock.side_effect = None2317 #path_existsMock.return_value = True2318 #get_JAVA_HOME_mock.return_value = "some_jdk"2319 #try:2320 # download_and_install_jdk(args)2321 # self.fail("Should throw exception")2322 #except FatalException as fe:2323 # Expected2324 # self.assertFalse(write_property_mock.called)2325 # Test case: Setup ambari-server first time, Custom JDK selected, JDK exists2326 args.java_home = None2327 args.jdk_location = None2328 validate_jdk_mock.return_value = False2329 update_properties_mock.reset_mock()2330 path_existsMock.reset_mock()2331 path_existsMock.side_effect = [True, True, True, True]2332 get_validated_string_input_mock.return_value = "2"2333 get_JAVA_HOME_mock.return_value = None2334 rcode = download_and_install_jdk(args)2335 self.assertEqual(0, rcode)2336 self.assertTrue(update_properties_mock.called)2337 # Test case: Setup ambari-server first time, Custom JDK selected, JDK not exists2338 update_properties_mock.reset_mock()2339 validate_jdk_mock.return_value = False2340 path_existsMock.reset_mock()2341 path_existsMock.side_effect = pem_side_effect12342 get_validated_string_input_mock.return_value = "2"2343 get_JAVA_HOME_mock.return_value = None2344 try:2345 download_and_install_jdk(args)2346 self.fail("Should throw exception")2347 except FatalException as fe:2348 # Expected2349 pass2350 # Test when custom java home exists but java binary file doesn't exist2351 args.java_home = None2352 validate_jdk_mock.return_value = False2353 path_isfileMock.return_value = False2354 update_properties_mock.reset_mock()2355 path_existsMock.reset_mock()2356 path_existsMock.side_effect = pem_side_effect12357 get_validated_string_input_mock.return_value = "2"2358 get_JAVA_HOME_mock.return_value = None2359 flag = False2360 try:2361 download_and_install_jdk(args)2362 self.fail("Should throw exception")2363 except FatalException as fe:2364 # Expected2365 flag = True2366 pass2367 self.assertTrue(flag)2368 #Test case: Setup ambari-server with java home passed. Path to java home doesn't exist2369 args.java_home = "somewhere"2370 validate_jdk_mock.return_value = False2371 path_existsMock.reset_mock()2372 path_existsMock.side_effect = pem_side_effect12373 try:2374 download_and_install_jdk(args)2375 self.fail("Should throw exception")2376 except FatalException as fe:2377 self.assertTrue("Path to java home somewhere or java binary file does not exists" in fe.reason)2378 pass2379 pass2380 @not_for_platform(PLATFORM_WINDOWS)2381 @patch("ambari_server.dbConfiguration_linux.run_os_command")2382 def test_get_postgre_status(self, run_os_command_mock):2383 run_os_command_mock.return_value = (1, "running", None)2384 pg_status, retcode, out, err = PGConfig._get_postgre_status()2385 self.assertEqual("running", pg_status)2386 run_os_command_mock.return_value = (1, "wrong", None)2387 pg_status, retcode, out, err = PGConfig._get_postgre_status()2388 self.assertEqual(None, pg_status)2389 pass2390 @not_for_platform(PLATFORM_WINDOWS)2391 @patch("time.sleep")2392 @patch("subprocess.Popen")2393 @patch("ambari_server.dbConfiguration_linux.run_os_command")2394 @patch.object(PGConfig, "_get_postgre_status")2395 def test_check_postgre_up(self, get_postgre_status_mock, run_os_command_mock,2396 popen_mock, sleep_mock):2397 from ambari_server import serverConfiguration2398 p = MagicMock()2399 p.communicate.return_value = (None, None)2400 p.returncode = 02401 popen_mock.return_value = p2402 get_postgre_status_mock.return_value = "running", 0, "", ""2403 serverConfiguration.OS_TYPE = OSConst.OS_REDHAT2404 p.poll.return_value = 02405 run_os_command_mock.return_value = (0, None, None)2406 pg_status, retcode, out, err = PGConfig._check_postgre_up()2407 self.assertEqual(0, retcode)2408 serverConfiguration.OS_TYPE = OSConst.OS_SUSE2409 run_os_command_mock.return_value = (0, None, None)2410 p.poll.return_value = 02411 get_postgre_status_mock.return_value = "stopped", 0, "", ""2412 pg_status, retcode, out, err = PGConfig._check_postgre_up()2413 self.assertEqual(0, retcode)2414 pass2415 @patch("platform.linux_distribution")2416 @patch("platform.system")2417 @patch("ambari_commons.logging_utils.print_info_msg")2418 @patch("ambari_commons.logging_utils.print_error_msg")2419 @patch("ambari_server.serverSetup.get_ambari_properties")2420 @patch("ambari_server.serverSetup.write_property")2421 @patch("ambari_server.serverConfiguration.get_conf_dir")2422 def test_configure_os_settings(self, get_conf_dir_mock, write_property_mock, get_ambari_properties_mock,2423 print_error_msg_mock, print_info_msg_mock,2424 systemMock, distMock):2425 get_ambari_properties_mock.return_value = -12426 rcode = configure_os_settings()2427 self.assertEqual(-1, rcode)2428 p = MagicMock()2429 p[OS_TYPE_PROPERTY] = 'somevalue'2430 get_ambari_properties_mock.return_value = p2431 rcode = configure_os_settings()2432 self.assertEqual(0, rcode)2433 p.__getitem__.return_value = ""2434 rcode = configure_os_settings()2435 self.assertEqual(0, rcode)2436 self.assertTrue(write_property_mock.called)2437 self.assertEqual(2, write_property_mock.call_count)2438 self.assertEquals(write_property_mock.call_args_list[0][0][0], "server.os_family")2439 self.assertEquals(write_property_mock.call_args_list[1][0][0], "server.os_type")2440 pass2441 @patch("__builtin__.open")2442 @patch("ambari_server.serverConfiguration.Properties")2443 @patch("ambari_server.serverConfiguration.search_file")2444 @patch("ambari_server.serverConfiguration.get_conf_dir")2445 def test_get_JAVA_HOME(self, get_conf_dir_mock, search_file_mock,2446 Properties_mock, openMock):2447 openMock.side_effect = Exception("exception")2448 result = get_JAVA_HOME()2449 self.assertEqual(None, result)2450 expected = os.path.dirname(__file__)2451 p = MagicMock()2452 p.__getitem__.return_value = expected2453 openMock.side_effect = None2454 Properties_mock.return_value = p2455 result = get_JAVA_HOME()2456 self.assertEqual(expected, result)2457 pass2458 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))2459 def test_prompt_db_properties_default(self):2460 args = MagicMock()2461 args.must_set_database_options = False2462 del args.database_index2463 del args.dbms2464 del args.database_host2465 del args.database_port2466 del args.database_name2467 del args.database_username2468 del args.database_password2469 del args.persistence_type2470 prompt_db_properties(args)2471 self.assertEqual(args.database_index, 0)2472 pass2473 @not_for_platform(PLATFORM_WINDOWS)2474 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))2475 @patch.object(LinuxDBMSConfig, "_setup_remote_server")2476 @patch("ambari_server.dbConfiguration_linux.print_info_msg")2477 @patch("ambari_server.dbConfiguration_linux.read_password")2478 @patch("ambari_server.dbConfiguration_linux.get_validated_string_input")2479 @patch("ambari_server.dbConfiguration.get_validated_string_input")2480 @patch("ambari_server.serverSetup.get_YN_input")2481 def test_prompt_db_properties_oracle_sname(self, gyni_mock, gvsi_mock, gvsi_2_mock, rp_mock, print_info_msg_mock, srs_mock):2482 gyni_mock.return_value = True2483 list_of_return_values = ["ambari-server", "ambari", "1", "1521", "localhost", "2"]2484 def side_effect(*args, **kwargs):2485 return list_of_return_values.pop()2486 gvsi_mock.side_effect = side_effect2487 gvsi_2_mock.side_effect = side_effect2488 rp_mock.return_value = "password"2489 args = MagicMock()2490 args.must_set_database_options = True2491 del args.database_index2492 del args.dbms2493 del args.database_host2494 del args.database_port2495 del args.database_name2496 del args.database_username2497 del args.database_password2498 del args.persistence_type2499 del args.sid_or_sname2500 del args.jdbc_url2501 set_silent(False)2502 prompt_db_properties(args)2503 self.assertEqual(args.database_index, 1)2504 props = Properties()2505 factory = DBMSConfigFactory()2506 dbmsConfig = factory.create(args, props)2507 self.assertEqual(dbmsConfig.dbms, "oracle")2508 self.assertEqual(dbmsConfig.database_port, "1521")2509 self.assertEqual(dbmsConfig.database_host, "localhost")2510 self.assertEqual(dbmsConfig.database_name, "ambari")2511 self.assertEqual(dbmsConfig.database_username, "ambari")2512 self.assertEqual(dbmsConfig.database_password, "bigdata")2513 self.assertEqual(dbmsConfig.sid_or_sname, "sid")2514 dbmsConfig.configure_database(props)2515 self.assertEqual(dbmsConfig.database_username, "ambari-server")2516 self.assertEqual(dbmsConfig.sid_or_sname, "sname")2517 pass2518 @not_for_platform(PLATFORM_WINDOWS)2519 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))2520 @patch.object(LinuxDBMSConfig, "_setup_remote_server")2521 @patch("ambari_server.dbConfiguration_linux.print_info_msg")2522 @patch("ambari_server.dbConfiguration_linux.read_password")2523 @patch("ambari_server.dbConfiguration_linux.get_validated_string_input")2524 @patch("ambari_server.dbConfiguration.get_validated_string_input")2525 @patch("ambari_server.serverSetup.get_YN_input")2526 def test_prompt_db_properties_oracle_sid(self, gyni_mock, gvsi_mock, gvsi_2_mock, rp_mock, print_info_msg_mock, srs_mock):2527 gyni_mock.return_value = True2528 list_of_return_values = ["ambari-server", "ambari", "2", "1521", "localhost", "2"]2529 def side_effect(*args, **kwargs):2530 return list_of_return_values.pop()2531 gvsi_mock.side_effect = side_effect2532 gvsi_2_mock.side_effect = side_effect2533 rp_mock.return_value = "password"2534 args = MagicMock()2535 args.must_set_database_options = True2536 del args.database_index2537 del args.dbms2538 del args.database_host2539 del args.database_port2540 del args.database_name2541 del args.database_username2542 del args.database_password2543 del args.persistence_type2544 del args.sid_or_sname2545 del args.jdbc_url2546 set_silent(False)2547 prompt_db_properties(args)2548 self.assertEqual(args.database_index, 1)2549 props = Properties()2550 factory = DBMSConfigFactory()2551 dbmsConfig = factory.create(args, props)2552 self.assertEqual(dbmsConfig.dbms, "oracle")2553 self.assertEqual(dbmsConfig.database_port, "1521")2554 self.assertEqual(dbmsConfig.database_host, "localhost")2555 self.assertEqual(dbmsConfig.database_name, "ambari")2556 self.assertEqual(dbmsConfig.database_username, "ambari")2557 self.assertEqual(dbmsConfig.database_password, "bigdata")2558 dbmsConfig.configure_database(props)2559 self.assertEqual(dbmsConfig.database_username, "ambari-server")2560 self.assertEqual(dbmsConfig.database_password, "password")2561 self.assertEqual(dbmsConfig.sid_or_sname, "sid")2562 pass2563 @not_for_platform(PLATFORM_WINDOWS)2564 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))2565 @patch.object(PGConfig, "_setup_local_server")2566 @patch("ambari_server.dbConfiguration_linux.print_info_msg")2567 @patch("ambari_server.dbConfiguration_linux.read_password")2568 @patch("ambari_server.dbConfiguration_linux.get_validated_string_input")2569 @patch("ambari_server.dbConfiguration.get_validated_string_input")2570 @patch("ambari_server.serverSetup.get_YN_input")2571 def test_prompt_db_properties_postgre_adv(self, gyni_mock, gvsi_mock, gvsi_2_mock, rp_mock, print_info_msg_mock, sls_mock):2572 gyni_mock.return_value = True2573 list_of_return_values = ["ambari-server", "ambari", "ambari", "1"]2574 def side_effect(*args, **kwargs):2575 return list_of_return_values.pop()2576 gvsi_mock.side_effect = side_effect2577 gvsi_2_mock.side_effect = side_effect2578 rp_mock.return_value = "password"2579 args = MagicMock()2580 args.must_set_database_options = True2581 del args.database_index2582 del args.dbms2583 del args.database_host2584 del args.database_port2585 del args.database_name2586 del args.database_username2587 del args.database_password2588 del args.persistence_type2589 set_silent(False)2590 prompt_db_properties(args)2591 self.assertEqual(args.database_index, 0)2592 props = Properties()2593 factory = DBMSConfigFactory()2594 dbmsConfig = factory.create(args, props)2595 self.assertEqual(dbmsConfig.dbms, "postgres")2596 self.assertEqual(dbmsConfig.database_port, "5432")2597 self.assertEqual(dbmsConfig.database_host, "localhost")2598 self.assertEqual(dbmsConfig.database_name, "ambari")2599 self.assertEqual(dbmsConfig.database_username, "ambari")2600 self.assertEqual(dbmsConfig.database_password, "bigdata")2601 dbmsConfig.configure_database(props)2602 self.assertEqual(dbmsConfig.database_username, "ambari-server")2603 self.assertEqual(dbmsConfig.database_password, "password")2604 self.assertEqual(dbmsConfig.sid_or_sname, "sid")2605 pass2606 @not_for_platform(PLATFORM_WINDOWS)2607 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))2608 @patch("ambari_server.dbConfiguration_linux.store_password_file")2609 @patch("ambari_server.dbConfiguration_linux.read_password")2610 @patch("ambari_server.dbConfiguration_linux.get_validated_string_input")2611 @patch("ambari_server.dbConfiguration_linux.get_YN_input")2612 def test_prompt_db_properties_for_each_database_type(self, gyni_mock, gvsi_mock, rp_mock, spf_mock):2613 """2614 :return: Validates that installation for each database type correctly stores the database type, database name,2615 and optionally the postgres schema name.2616 """2617 from ambari_server import serverConfiguration2618 gyni_mock.return_value = True2619 rp_mock.return_value = "password"2620 spf_mock.return_value = "encrypted password"2621 # Values to use while installing several database types2622 hostname = "localhost"2623 db_name = "db_ambari"2624 postgres_schema = "sc_ambari"2625 port = "1234"2626 oracle_service = "1"2627 oracle_service_name = "ambari"2628 user_name = "ambari"2629 # Input values2630 postgres_embedded_values = [db_name, postgres_schema, hostname]2631 oracle_values = [hostname, port, oracle_service, oracle_service_name, user_name]2632 mysql_values = [hostname, port, db_name, user_name]2633 postgres_external_values = [hostname, port, db_name, postgres_schema, user_name]2634 mssql_values = [hostname, port, db_name, user_name]2635 list_of_return_values = postgres_embedded_values + oracle_values + mysql_values + postgres_external_values + mssql_values2636 list_of_return_values = list_of_return_values[::-1] # Reverse the list since the input will be popped2637 def side_effect(*args, **kwargs):2638 return list_of_return_values.pop()2639 gvsi_mock.side_effect = side_effect2640 if AMBARI_CONF_VAR in os.environ:2641 del os.environ[AMBARI_CONF_VAR]2642 tempdir = tempfile.gettempdir()2643 os.environ[AMBARI_CONF_VAR] = tempdir2644 prop_file = os.path.join(tempdir, "ambari.properties")2645 for i in range(0, 5):2646 # Use the expected path of the ambari.properties file to delete it if it exists, and then create a new one2647 # during each use case.2648 if os.path.exists(prop_file):2649 os.remove(prop_file)2650 with open(prop_file, "w") as f:2651 f.write("server.jdbc.database_name=oldDBName")2652 f.close()2653 serverConfiguration.AMBARI_PROPERTIES_FILE = prop_file2654 args = MagicMock()2655 properties = Properties()2656 args.database_index = i2657 args.silent = False2658 del args.dbms2659 del args.database_host2660 del args.database_port2661 del args.database_name2662 del args.database_username2663 del args.database_password2664 del args.sid_or_sname2665 del args.jdbc_url2666 factory = DBMSConfigFactory()2667 dbConfig = factory.create(args, properties)2668 dbConfig._prompt_db_properties()2669 if dbConfig._is_local_database():2670 dbConfig._setup_local_server(properties)2671 else:2672 dbConfig._setup_remote_server(properties)2673 if i == 0:2674 # Postgres Embedded2675 self.assertEqual(properties[JDBC_DATABASE_PROPERTY], "postgres")2676 self.assertEqual(properties[JDBC_DATABASE_NAME_PROPERTY], db_name)2677 self.assertEqual(properties[JDBC_POSTGRES_SCHEMA_PROPERTY], postgres_schema)2678 self.assertEqual(properties[PERSISTENCE_TYPE_PROPERTY], "local")2679 elif i == 1:2680 # Oracle2681 self.assertEqual(properties[JDBC_DATABASE_PROPERTY], "oracle")2682 self.assertFalse(JDBC_POSTGRES_SCHEMA_PROPERTY in properties.propertyNames())2683 self.assertEqual(properties[PERSISTENCE_TYPE_PROPERTY], "remote")2684 elif i == 2:2685 # MySQL2686 self.assertEqual(properties[JDBC_DATABASE_PROPERTY], "mysql")2687 self.assertFalse(JDBC_POSTGRES_SCHEMA_PROPERTY in properties.propertyNames())2688 self.assertEqual(properties[PERSISTENCE_TYPE_PROPERTY], "remote")2689 elif i == 3:2690 # Postgres External2691 self.assertEqual(properties[JDBC_DATABASE_PROPERTY], "postgres")2692 self.assertEqual(properties[JDBC_DATABASE_NAME_PROPERTY], db_name)2693 self.assertEqual(properties[JDBC_POSTGRES_SCHEMA_PROPERTY], postgres_schema)2694 self.assertEqual(properties[PERSISTENCE_TYPE_PROPERTY], "remote")2695 elif i == 4:2696 # MSSQL2697 self.assertEqual(properties[JDBC_DATABASE_PROPERTY], "mssql")2698 self.assertFalse(JDBC_POSTGRES_SCHEMA_PROPERTY in properties.propertyNames())2699 self.assertEqual(properties[PERSISTENCE_TYPE_PROPERTY], "remote")2700 pass2701 @patch.object(os.path, "exists")2702 @patch.object(os.path, "isfile")2703 def test_validate_jdk(self, isfile_mock, exists_mock):2704 exists_mock.side_effect = [False]2705 result = validate_jdk("path")2706 self.assertFalse(result)2707 exists_mock.side_effect = [True, False]2708 result = validate_jdk("path")2709 self.assertFalse(result)2710 exists_mock.side_effect = [True, True]2711 isfile_mock.return_value = False2712 result = validate_jdk("path")2713 self.assertFalse(result)2714 exists_mock.side_effect = [True, True]2715 isfile_mock.return_value = True2716 result = validate_jdk("path")2717 self.assertTrue(result)2718 pass2719 @patch("glob.glob")2720 @patch("ambari_server.serverConfiguration.get_JAVA_HOME")2721 @patch("ambari_server.serverConfiguration.validate_jdk")2722 def test_find_jdk(self, validate_jdk_mock, get_JAVA_HOME_mock, globMock):2723 get_JAVA_HOME_mock.return_value = "somewhere"2724 validate_jdk_mock.return_value = True2725 result = find_jdk()2726 self.assertEqual("somewhere", result)2727 get_JAVA_HOME_mock.return_value = None2728 globMock.return_value = []2729 result = find_jdk()2730 self.assertEqual(None, result)2731 globMock.return_value = ["one", "two"]2732 result = find_jdk()2733 self.assertNotEqual(None, result)2734 globMock.return_value = ["one", "two"]2735 validate_jdk_mock.side_effect = [False, True]2736 result = find_jdk()2737 self.assertEqual(result, "one")2738 pass2739 @patch("os.path.exists")2740 @patch("zipfile.ZipFile")2741 @patch("os.path.split")2742 @patch("os.listdir")2743 @patch("ambari_server.serverSetup.copy_files")2744 @patch("shutil.rmtree")2745 def test_unpack_jce_policy(self, rmtree_mock, copy_files_mock, os_listdir_mock, os_path_split_mock, zipfile_mock, exists_mock):2746 # Testing the case when the zip file doesn't contains any folder2747 exists_mock.return_value = True2748 zipfile = MagicMock()2749 zipfile_mock.return_value = zipfile2750 zip_members = ["US_export_policy.jar", "local_policy.jar", "README.txt"]2751 zipfile.namelist.return_value = zip_members2752 os_path_split_mock.return_value = [""]2753 expand_jce_zip_file("", "")2754 self.assertTrue(exists_mock.called)2755 self.assertTrue(zipfile_mock.called)2756 self.assertTrue(os_path_split_mock.called)2757 # Testing the case when the zip file contains a folder2758 unziped_jce_path = "jce"2759 os_path_split_mock.return_value = unziped_jce_path2760 expand_jce_zip_file("", "")2761 self.assertTrue(exists_mock.called)2762 self.assertTrue(zipfile_mock.called)2763 self.assertTrue(os_listdir_mock.called)2764 self.assertTrue(copy_files_mock.called)2765 self.assertTrue(rmtree_mock.called)2766 # Testing when the jdk_security_path or jce_zip_path doesn't exist2767 exists_mock.return_value = False2768 try:2769 expand_jce_zip_file("", "")2770 except FatalException:2771 self.assertTrue(True)2772 exists_mock.return_value = True2773 # Testing when zipfile fail with an error2774 zipfile_mock.side_effect = FatalException(1,"Extract error")2775 try:2776 expand_jce_zip_file("", "")2777 except FatalException:2778 self.assertTrue(True)2779 @patch("os.path.exists")2780 @patch("shutil.copy")2781 @patch("os.path.split")2782 @patch("ambari_server.serverSetup.update_properties")2783 @patch.object(JDKSetup, "unpack_jce_policy")2784 @patch("ambari_server.serverSetup.get_ambari_properties")2785 @patch("ambari_commons.os_utils.search_file")2786 @patch("__builtin__.open")2787 def test_setup_jce_policy(self, open_mock, search_file_mock, get_ambari_properties_mock, unpack_jce_policy_mock,2788 update_properties_mock, path_split_mock, shutil_copy_mock, exists_mock):2789 exists_mock.return_value = True2790 properties = Properties()2791 properties.process_pair(JAVA_HOME_PROPERTY, "/java_home")2792 unpack_jce_policy_mock.return_value = 02793 get_ambari_properties_mock.return_value = properties2794 conf_file = 'etc/ambari-server/conf/ambari.properties'2795 search_file_mock.return_value = conf_file2796 path_split_mock.return_value = ["/path/to", "JCEPolicy.zip"]2797 args = ['setup-jce', '/path/to/JCEPolicy.zip']2798 setup_jce_policy(args)2799 shutil_copy_mock.assert_called_with(args[1], configDefaults.SERVER_RESOURCES_DIR)2800 self.assertTrue(unpack_jce_policy_mock.called)2801 self.assertTrue(get_ambari_properties_mock.called)2802 self.assertTrue(update_properties_mock.called)2803 # Testing that if the source and the destination is the same will not try to copy the file2804 path_split_mock.return_value = [configDefaults.SERVER_RESOURCES_DIR, "JCEPolicy.zip"]2805 shutil_copy_mock.reset_mock()2806 setup_jce_policy(args)2807 self.assertFalse(shutil_copy_mock.called)2808 self.assertTrue(unpack_jce_policy_mock.called)2809 self.assertTrue(get_ambari_properties_mock.called)2810 self.assertTrue(update_properties_mock.called)2811 path_split_mock.return_value = ["/path/to", "JCEPolicy.zip"]2812 # Testing with bad path2813 exists_mock.return_value = False2814 try:2815 setup_jce_policy(args)2816 except FatalException:2817 self.assertTrue(True)2818 exists_mock.return_value = True2819 # Testing with an error produced by shutil.copy2820 shutil_copy_mock.reset_mock()2821 shutil_copy_mock.side_effect = FatalException(1, "Error trying to copy the file.")2822 try:2823 setup_jce_policy(args)2824 except FatalException:2825 self.assertTrue(True)2826 # Testing with an error produced by Properties.store function2827 update_properties_mock.side_effect = Exception("Invalid file.")2828 try:2829 setup_jce_policy(args)2830 except Exception:2831 self.assertTrue(True)2832 update_properties_mock.reset_mock()2833 # Testing with an error produced by unpack_jce_policy2834 unpack_jce_policy_mock.side_effect = FatalException(1, "Can not install JCE policy")2835 try:2836 setup_jce_policy(args)2837 except FatalException:2838 self.assertTrue(True)2839 pass2840 @not_for_platform(PLATFORM_WINDOWS)2841 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))2842 @patch("ambari_commons.firewall.run_os_command")2843 @patch("os.path.exists")2844 @patch("os.path.isfile")2845 @patch("ambari_commons.os_utils.remove_file")2846 @patch("ambari_server.dbConfiguration_linux.LinuxDBMSConfig.ensure_jdbc_driver_installed")2847 @patch("ambari_server.dbConfiguration_linux.get_YN_input")2848 @patch("ambari_server.serverSetup.update_properties")2849 @patch("ambari_server.dbConfiguration_linux.get_ambari_properties")2850 @patch("ambari_server.dbConfiguration_linux.store_password_file")2851 @patch("ambari_server.dbConfiguration_linux.run_os_command")2852 @patch("ambari_server.dbConfiguration_linux.PGConfig._configure_postgres")2853 @patch("ambari_server.dbConfiguration_linux.PGConfig._check_postgre_up")2854 @patch("ambari_server.dbConfiguration_linux.PGConfig._is_jdbc_user_changed")2855 @patch("ambari_server.serverSetup.verify_setup_allowed")2856 @patch("ambari_server.dbConfiguration_linux.read_password")2857 @patch("ambari_server.dbConfiguration_linux.get_validated_string_input")2858 @patch("ambari_server.dbConfiguration.get_validated_string_input")2859 @patch("ambari_server.serverSetup.get_YN_input")2860 @patch("ambari_server.serverSetup.get_ambari_properties")2861 @patch("ambari_server.serverSetup.configure_os_settings")2862 @patch("ambari_server.serverSetup.download_and_install_jdk")2863 @patch("ambari_server.serverSetup.check_ambari_user")2864 @patch("ambari_server.serverSetup.check_jdbc_drivers")2865 @patch("ambari_server.serverSetup.disable_security_enhancements")2866 @patch("ambari_server.serverSetup.is_root")2867 @patch("ambari_server.serverSetup.proceedJDBCProperties")2868 @patch("ambari_server.serverSetup.extract_views")2869 @patch("ambari_server.serverSetup.adjust_directory_permissions")2870 @patch("ambari_server.serverSetup.service_setup")2871 @patch("ambari_server.serverSetup.read_ambari_user")2872 @patch("ambari_server.serverSetup.expand_jce_zip_file")2873 def test_setup(self, expand_jce_zip_file_mock, read_ambari_user_mock,2874 service_setup_mock, adjust_dirs_mock, extract_views_mock, proceedJDBCProperties_mock, is_root_mock,2875 disable_security_enhancements_mock, check_jdbc_drivers_mock, check_ambari_user_mock,2876 download_jdk_mock, configure_os_settings_mock, get_ambari_properties_mock,2877 get_YN_input_mock, gvsi_mock, gvsi_1_mock,2878 read_password_mock, verify_setup_allowed_method, is_jdbc_user_changed_mock, check_postgre_up_mock,2879 configure_postgres_mock, run_os_command_1_mock,2880 store_password_file_mock, get_ambari_properties_1_mock, update_properties_mock,2881 get_YN_input_1_mock, ensure_jdbc_driver_installed_mock,2882 remove_file_mock, isfile_mock, exists_mock,2883 run_os_command_mock):2884 hostname = "localhost"2885 db_name = "db_ambari"2886 postgres_schema = "sc_ambari"2887 port = "1234"2888 oracle_service = "1"2889 oracle_service_name = "ambari"2890 user_name = "ambari"2891 args = MagicMock()2892 del args.dbms2893 del args.database_index2894 del args.database_host2895 del args.database_port2896 del args.database_name2897 del args.database_username2898 del args.database_password2899 args.silent = False2900 failed = False2901 properties = Properties()2902 get_YN_input_mock.return_value = False2903 isfile_mock.return_value = False2904 verify_setup_allowed_method.return_value = 02905 exists_mock.return_value = False2906 remove_file_mock.return_value = 02907 run_os_command_mock.return_value = 3,"",""2908 extract_views_mock.return_value = 02909 read_ambari_user_mock.return_value = "ambari"2910 read_password_mock.return_value = "bigdata2"2911 get_ambari_properties_mock.return_value = properties2912 get_ambari_properties_1_mock.return_value = properties2913 store_password_file_mock.return_value = "encrypted_bigdata2"2914 ensure_jdbc_driver_installed_mock.return_value = True2915 check_postgre_up_mock.return_value = (PGConfig.PG_STATUS_RUNNING, 0, "", "")2916 configure_postgres_mock.return_value = (0, "", "")2917 run_os_command_1_mock.return_value = (0, "", "")2918 expand_jce_zip_file_mock.return_value = 02919 def reset_mocks():2920 is_jdbc_user_changed_mock.reset_mock()2921 is_root_mock.reset_mock()2922 disable_security_enhancements_mock.reset_mock()2923 check_jdbc_drivers_mock.reset_mock()2924 check_ambari_user_mock.reset_mock()2925 run_os_command_mock.reset_mock()2926 configure_os_settings_mock.reset_mock()2927 run_os_command_1_mock.reset_mock()2928 get_YN_input_1_mock.reset_mock()2929 update_properties_mock.reset_mock()2930 args = MagicMock()2931 del args.dbms2932 del args.database_index2933 del args.database_host2934 del args.database_port2935 del args.database_name2936 del args.database_username2937 del args.database_password2938 del args.persistence_type2939 del args.sid_or_sname2940 del args.jdbc_url2941 args.jdbc_driver= None2942 args.jdbc_db = None2943 args.silent = False2944 return args2945 # Testing call under non-root2946 is_root_mock.return_value = False2947 try:2948 setup(args)2949 self.fail("Should throw exception")2950 except FatalException as fe:2951 # Expected2952 self.assertTrue("root-level" in fe.reason)2953 pass2954 args = reset_mocks()2955 # Testing calls under root2956 # remote case2957 is_root_mock.return_value = True2958 disable_security_enhancements_mock.return_value = (0, "")2959 check_ambari_user_mock.return_value = (0, False, 'user', None)2960 check_jdbc_drivers_mock.return_value = 02961 download_jdk_mock.return_value = 02962 configure_os_settings_mock.return_value = 02963 result = setup(args)2964 self.assertEqual(None, result)2965 self.assertTrue(check_ambari_user_mock.called)2966 self.assertEqual(1, run_os_command_mock.call_count)2967 #Local case2968 args = reset_mocks()2969 # Input values2970 db_selection_values = ["1"]2971 postgres_values = [db_name, postgres_schema, hostname]2972 postgres_values = postgres_values[::-1] # Reverse the list since the input will be popped2973 def side_effect(*args, **kwargs):2974 return db_selection_values.pop()2975 gvsi_mock.side_effect = side_effect2976 def side_effect_1(*args, **kwargs):2977 return postgres_values.pop()2978 gvsi_1_mock.side_effect = side_effect_12979 get_YN_input_mock.return_value = True2980 # is_local_database_mock.return_value = True2981 is_jdbc_user_changed_mock.return_value = False2982 try:2983 result = setup(args)2984 except FatalException:2985 self.fail("Setup should be successful")2986 self.assertEqual(None, result)2987 self.assertTrue(is_jdbc_user_changed_mock.called)2988 self.assertTrue(update_properties_mock.called)2989 self.assertTrue(run_os_command_1_mock.called)2990 self.assertFalse(remove_file_mock.called)2991 self.assertTrue("Ambari-DDL-Postgres-EMBEDDED-CREATE.sql" in run_os_command_1_mock.call_args[0][0][3])2992 #if DB user name was changed2993 args = reset_mocks()2994 # is_local_database_mock.return_value = True2995 is_jdbc_user_changed_mock.return_value = True2996 db_selection_values = ["1"]2997 postgres_values = [db_name, postgres_schema, hostname]2998 postgres_values = postgres_values[::-1] # Reverse the list since the input will be popped2999 try:3000 result = setup(args)3001 except FatalException:3002 self.fail("Setup should be successful")3003 self.assertEqual(None, result)3004 self.assertTrue(is_jdbc_user_changed_mock.called)3005 self.assertTrue(update_properties_mock.called)3006 self.assertTrue(run_os_command_1_mock.called)3007 self.assertFalse(remove_file_mock.called)3008 #negative case3009 args = reset_mocks()3010 # Use remote database3011 get_YN_input_1_mock.return_value = False3012 db_selection_values = ["4"]3013 postgres_values = [hostname, port, db_name, postgres_schema, user_name]3014 postgres_values = postgres_values[::-1] # Reverse the list since the input will be popped3015 try:3016 result = setup(args)3017 self.fail("Should throw exception")3018 except NonFatalException as fe:3019 self.assertTrue("Remote database setup aborted." in fe.reason)3020 self.assertFalse(run_os_command_1_mock.called)3021 # test not run setup if ambari-server setup executed with jdbc properties3022 args = reset_mocks()3023 # is_server_runing_mock.return_value = (False, 1)3024 args.jdbc_driver= "path/to/driver"3025 args.jdbc_db = "test_db_name"3026 setup(args)3027 self.assertTrue(proceedJDBCProperties_mock.called)3028 self.assertFalse(disable_security_enhancements_mock.called)3029 self.assertFalse(check_ambari_user_mock.called)3030 pass3031 @only_for_platform(PLATFORM_WINDOWS)3032 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))3033 @patch("ambari_commons.firewall.run_os_command")3034 @patch("os.path.exists")3035 @patch("os.path.isfile")3036 @patch("ambari_commons.os_utils.remove_file")3037 @patch("ambari_server.dbConfiguration_windows.MSSQLConfig.ensure_jdbc_driver_installed")3038 @patch("ambari_server.serverSetup.update_properties")3039 @patch("ambari_server.dbConfiguration_windows.store_password_file")3040 @patch("ambari_server.dbConfiguration_windows.run_os_command")3041 @patch("ambari_server.serverSetup.verify_setup_allowed")3042 @patch("ambari_server.dbConfiguration_windows.get_validated_string_input")3043 @patch("ambari_server.dbConfiguration.get_validated_string_input")3044 @patch("ambari_server.serverSetup.get_YN_input")3045 @patch("ambari_server.serverSetup.get_ambari_properties")3046 @patch("ambari_server.serverSetup.configure_os_settings")3047 @patch("ambari_server.serverSetup.download_and_install_jdk")3048 @patch("ambari_server.serverSetup.check_firewall")3049 @patch("ambari_server.serverSetup.check_ambari_user")3050 @patch("ambari_server.serverSetup.check_jdbc_drivers")3051 @patch("ambari_server.serverSetup.disable_security_enhancements")3052 @patch("ambari_server.serverSetup.is_root")3053 @patch("ambari_server.serverSetup.proceedJDBCProperties")3054 @patch("ambari_server.serverSetup.extract_views")3055 @patch("ambari_server.serverSetup.adjust_directory_permissions")3056 @patch("ambari_server.serverSetup.service_setup")3057 @patch("ambari_server.serverSetup.read_ambari_user")3058 @patch("ambari_server.serverSetup.expand_jce_zip_file")3059 def test_setup(self, expand_jce_zip_file_mock, read_ambari_user_mock,3060 service_setup_mock, adjust_dirs_mock, extract_views_mock, proceedJDBCProperties_mock, is_root_mock,3061 disable_security_enhancements_mock, check_jdbc_drivers_mock, check_ambari_user_mock, check_firewall_mock,3062 download_jdk_mock, configure_os_settings_mock, get_ambari_properties_mock,3063 get_YN_input_mock, gvsi_mock, gvsi_1_mock,3064 verify_setup_allowed_method, run_os_command_1_mock,3065 store_password_file_mock, update_properties_mock,3066 ensure_jdbc_driver_installed_mock,3067 remove_file_mock, isfile_mock, exists_mock,3068 run_os_command_mock):3069 hostname = "localhost"3070 db_name = "db_ambari"3071 port = "1433"3072 user_name = "ambari"3073 password = "bigdata2"3074 failed = False3075 properties = Properties()3076 get_YN_input_mock.return_value = False3077 isfile_mock.return_value = False3078 verify_setup_allowed_method.return_value = 03079 exists_mock.return_value = False3080 remove_file_mock.return_value = 03081 run_os_command_mock.return_value = 3,"",""3082 extract_views_mock.return_value = 03083 read_ambari_user_mock.return_value = "ambari"3084 #read_password_mock.return_value = "bigdata2"3085 get_ambari_properties_mock.return_value = properties3086 store_password_file_mock.return_value = "encrypted_bigdata2"3087 ensure_jdbc_driver_installed_mock.return_value = True3088 run_os_command_1_mock.return_value = (0, "", "")3089 expand_jce_zip_file_mock.return_value = 03090 def reset_mocks():3091 is_root_mock.reset_mock()3092 disable_security_enhancements_mock.reset_mock()3093 check_jdbc_drivers_mock.reset_mock()3094 check_ambari_user_mock.reset_mock()3095 run_os_command_mock.reset_mock()3096 configure_os_settings_mock.reset_mock()3097 run_os_command_1_mock.reset_mock()3098 update_properties_mock.reset_mock()3099 args = MagicMock()3100 del args.dbms3101 del args.database_index3102 del args.database_host3103 del args.database_port3104 del args.database_name3105 del args.database_username3106 del args.database_password3107 del args.default_database_host3108 del args.persistence_type3109 del args.init_db_script_file3110 del args.cleanup_db_script_file3111 del args.sid_or_sname3112 del args.jdbc_url3113 args.jdbc_driver= None3114 args.jdbc_db = None3115 args.silent = False3116 args.must_set_database_options = True3117 return args3118 args = reset_mocks()3119 # Testing call under non-root3120 is_root_mock.return_value = False3121 try:3122 setup(args)3123 self.fail("Should throw exception")3124 except FatalException as fe:3125 # Expected3126 self.assertTrue("administrator-level" in fe.reason)3127 pass3128 args = reset_mocks()3129 # Testing calls under root3130 is_root_mock.return_value = True3131 disable_security_enhancements_mock.return_value = (0, "")3132 check_ambari_user_mock.return_value = (0, False, 'user', None)3133 check_jdbc_drivers_mock.return_value = 03134 download_jdk_mock.return_value = 03135 configure_os_settings_mock.return_value = 03136 result = setup(args)3137 self.assertEqual(None, result)3138 self.assertTrue(check_ambari_user_mock.called)3139 self.assertEqual(2, run_os_command_1_mock.call_count)3140 #negative case3141 args = reset_mocks()3142 # Use Windows authentication3143 get_YN_input_mock.return_value = True3144 gvsi_1_mock.side_effect = [hostname, "1"]3145 try:3146 result = setup(args)3147 except Exception:3148 self.fail("Shouldn't throw exception")3149 self.assertTrue(run_os_command_1_mock.called)3150 # Use SQL Server authentication3151 get_YN_input_mock.return_value = True3152 gvsi_1_mock.side_effect = [hostname, "2", user_name, password]3153 try:3154 result = setup(args)3155 except Exception:3156 self.fail("Shouldn't throw exception")3157 self.assertTrue(run_os_command_1_mock.called)3158 # test not run setup if ambari-server setup executed with jdbc properties3159 args = reset_mocks()3160 args.jdbc_driver= "path/to/driver"3161 args.jdbc_db = "test_db_name"3162 setup(args)3163 self.assertTrue(proceedJDBCProperties_mock.called)3164 self.assertFalse(disable_security_enhancements_mock.called)3165 self.assertFalse(check_ambari_user_mock.called)3166 pass3167 @not_for_platform(PLATFORM_WINDOWS)3168 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))3169 @patch.object(OracleConfig, "_get_remote_script_line")3170 @patch("ambari_server.serverSetup.is_server_runing")3171 @patch("ambari_server.dbConfiguration_linux.get_YN_input")3172 @patch("ambari_server.serverSetup.get_YN_input")3173 @patch.object(PGConfig, "_setup_db")3174 @patch("ambari_server.dbConfiguration_linux.print_warning_msg")3175 @patch("ambari_server.dbConfiguration_linux.print_info_msg")3176 @patch("ambari_server.dbConfiguration_linux.run_os_command")3177 @patch("ambari_server.dbConfiguration.decrypt_password_for_alias")3178 @patch("ambari_server.serverSetup.get_ambari_properties")3179 @patch("ambari_server.serverSetup.is_root")3180 def test_reset(self, is_root_mock, get_ambari_properties_mock, decrypt_password_for_alias_mock,3181 run_os_command_mock, print_info_msg_mock, print_warning_msg_mock,3182 setup_db_mock, get_YN_input_mock, get_YN_input_2_mock, is_server_running_mock,3183 get_remote_script_line_mock):3184 def reset_mocks():3185 args = MagicMock()3186 del args.dbms3187 del args.database_index3188 del args.database_host3189 del args.database_port3190 del args.database_name3191 del args.database_username3192 del args.database_password3193 del args.persistence_type3194 del args.init_script_file3195 del args.drop_script_file3196 del args.sid_or_sname3197 del args.jdbc_url3198 return args3199 properties = Properties()3200 get_ambari_properties_mock.return_value = properties3201 args = reset_mocks()3202 args.persistence_type = "local"3203 get_YN_input_mock.return_value = False3204 decrypt_password_for_alias_mock.return_value = "password"3205 is_server_running_mock.return_value = (False, 0)3206 setup_db_mock.side_effect = [(0,None, None),(0,None, "ERROR: database 'ambari' is being accessed by other users"), (0, None, "ERROR: user 'mapred' already exist")]3207 # Testing call under non-root3208 is_root_mock.return_value = False3209 try:3210 reset(args)3211 self.fail("Should throw exception")3212 except FatalException as fe:3213 # Expected3214 self.assertTrue("root-level" in fe.reason)3215 pass3216 # Testing calls under root3217 is_root_mock.return_value = True3218 try:3219 reset(args)3220 self.fail("Should throw exception")3221 except FatalException as fe:3222 # Expected3223 self.assertFalse("root-level" in fe.reason)3224 pass3225 get_YN_input_mock.return_value = True3226 get_YN_input_2_mock.return_value = True3227 run_os_command_mock.return_value = (1, None, None)3228 try:3229 reset(args)3230 self.fail("Should throw exception")3231 except FatalException:3232 # Expected3233 pass3234 run_os_command_mock.return_value = (0, None, None)3235 reset(args)3236 self.assertTrue(setup_db_mock.called)3237 # Database errors cases3238 is_server_running_mock.side_effect = [(True, 123), (False, 0), (False, 0), (False, 0), (False, 0)]3239 try:3240 reset(args)3241 self.fail("Should throw exception")3242 except FatalException:3243 # Expected3244 pass3245 try:3246 reset(args)3247 self.fail("Should throw exception")3248 except NonFatalException:3249 # Expected3250 pass3251 args = reset_mocks()3252 args.dbms = "postgres"3253 #get_remote_script_line_mock.return_value = None3254 try:3255 #remote db case3256 reset(args)3257 self.fail("Should throw exception")3258 except NonFatalException:3259 # Expected3260 pass3261 args = reset_mocks()3262 args.dbms = "oracle"3263 print_warning_msg_mock.reset_mock()3264 get_remote_script_line_mock.reset_mock()3265 get_remote_script_line_mock.side_effect = ["drop", "create"]3266 try:3267 #remote db case (not Postgres)3268 rcode = reset(args)3269 self.fail("Should throw exception")3270 except NonFatalException:3271 # Expected3272 self.assertTrue(get_remote_script_line_mock.called)3273 self.assertTrue(print_warning_msg_mock.called)3274 pass3275 pass3276 @only_for_platform(PLATFORM_WINDOWS)3277 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))3278 @patch("ambari_server.serverSetup.is_server_runing")3279 @patch("ambari_server.serverSetup.get_YN_input")3280 @patch("ambari_server.dbConfiguration_windows.print_warning_msg")3281 @patch("ambari_server.dbConfiguration_windows.print_info_msg")3282 @patch("ambari_server.dbConfiguration_windows.run_os_command")3283 @patch("ambari_server.dbConfiguration.decrypt_password_for_alias")3284 @patch("ambari_server.serverSetup.get_ambari_properties")3285 @patch("ambari_server.serverSetup.is_root")3286 def test_reset(self, is_root_mock, get_ambari_properties_mock, decrypt_password_for_alias_mock,3287 run_os_command_mock, print_info_msg_mock, print_warning_msg_mock,3288 get_YN_input_mock, is_server_running_mock):3289 def reset_mocks():3290 args = MagicMock()3291 del args.dbms3292 del args.database_index3293 del args.database_host3294 del args.database_port3295 del args.database_name3296 del args.database_username3297 del args.database_password3298 del args.default_database_host3299 del args.persistence_type3300 del args.init_db_script_file3301 del args.cleanup_db_script_file3302 del args.sid_or_sname3303 del args.jdbc_url3304 return args3305 properties = Properties()3306 get_ambari_properties_mock.return_value = properties3307 args = reset_mocks()3308 args.persistence_type = "local"3309 get_YN_input_mock.return_value = False3310 decrypt_password_for_alias_mock.return_value = "password"3311 is_server_running_mock.return_value = (False, 0)3312 # Testing call under non-root3313 is_root_mock.return_value = False3314 try:3315 reset(args)3316 self.fail("Should throw exception")3317 except FatalException as fe:3318 # Expected3319 self.assertTrue("administrator-level" in fe.reason)3320 pass3321 # Testing calls under root3322 is_root_mock.return_value = True3323 try:3324 reset(args)3325 self.fail("Should throw exception")3326 except FatalException as fe:3327 # Expected3328 self.assertFalse("administrator-level" in fe.reason)3329 pass3330 get_YN_input_mock.return_value = True3331 run_os_command_mock.return_value = (1, None, None)3332 try:3333 reset(args)3334 self.fail("Should throw exception")3335 except FatalException:3336 # Expected3337 pass3338 run_os_command_mock.reset_mock()3339 run_os_command_mock.return_value = (0, None, None)3340 reset(args)3341 self.assertTrue(run_os_command_mock.called)3342 self.assertEqual(run_os_command_mock.call_count, 2)3343 # Database errors cases3344 is_server_running_mock.side_effect = [(True, 123), (False, 0)]3345 try:3346 reset(args)3347 self.fail("Should throw exception")3348 except FatalException:3349 # Expected3350 pass3351 try:3352 reset(args)3353 except NonFatalException:3354 self.fail("Shouldn't throw exception")3355 pass3356 pass3357 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))3358 @patch("ambari_server.serverSetup.get_YN_input")3359 @patch("__builtin__.raw_input")3360 @patch("ambari_server.serverSetup.is_root")3361 def test_reset_default(self, is_root_mock, raw_input_mock, get_YN_inputMock):3362 is_root_mock.return_value=True3363 get_YN_inputMock.return_value = False3364 raw_input_mock.return_value=""3365 args = MagicMock()3366 try:3367 reset(args)3368 self.fail("Should throw exception")3369 except FatalException as fe:3370 # Expected3371 self.assertTrue(fe.code == 1)3372 pass3373 pass3374 @not_for_platform(PLATFORM_WINDOWS)3375 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))3376 @patch.object(PGConfig, "_setup_db")3377 @patch("ambari_server.dbConfiguration_linux.print_info_msg")3378 @patch("ambari_server.dbConfiguration_linux.run_os_command")3379 #@patch("ambari_server.serverSetup.parse_properties_file")3380 @patch("ambari_server.serverSetup.is_root")3381 #@patch("ambari_server.serverSetup.check_database_name_property")3382 @patch("ambari_server.serverSetup.is_server_runing")3383 def test_silent_reset(self, is_server_runing_mock, #check_database_name_property_mock,3384 is_root_mock, #parse_properties_file_mock,3385 run_os_command_mock, print_info_msg_mock,3386 setup_db_mock):3387 is_root_mock.return_value = True3388 args = MagicMock()3389 del args.dbms3390 del args.database_index3391 del args.database_host3392 del args.database_port3393 del args.database_name3394 del args.database_username3395 del args.database_password3396 del args.persistence_type3397 set_silent(True)3398 self.assertTrue(get_silent())3399 setup_db_mock.return_value = (0, None, None)3400 run_os_command_mock.return_value = (0, None, None)3401 is_server_runing_mock.return_value = (False, 0)3402 def signal_handler(signum, frame):3403 self.fail("Timed out!")3404 signal.signal(signal.SIGALRM, signal_handler)3405 try:3406 signal.alarm(5)3407 rcode = reset(args)3408 signal.alarm(0)3409 self.assertEqual(None, rcode)3410 self.assertTrue(setup_db_mock.called)3411 finally:3412 signal.signal(signal.SIGALRM, signal.SIG_IGN)3413 pass3414 @only_for_platform(PLATFORM_WINDOWS)3415 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))3416 @patch("ambari_server.dbConfiguration_windows.MSSQLConfig._execute_db_script")3417 @patch("ambari_server.serverSetup.get_ambari_properties")3418 @patch("ambari_server.serverSetup.is_root")3419 @patch("ambari_server.serverSetup.is_server_runing")3420 def test_silent_reset(self, is_server_runing_mock,3421 is_root_mock, get_ambari_properties_mock,3422 execute_db_script_mock):3423 is_root_mock.return_value = True3424 args = MagicMock()3425 del args.dbms3426 del args.database_index3427 del args.database_host3428 del args.database_port3429 del args.database_name3430 del args.database_username3431 del args.database_password3432 del args.default_database_host3433 del args.persistence_type3434 del args.init_db_script_file3435 del args.cleanup_db_script_file3436 set_silent(True)3437 self.assertTrue(get_silent())3438 properties = Properties()3439 get_ambari_properties_mock.return_value = properties3440 is_server_runing_mock.return_value = (False, 0)3441 rcode = reset(args)3442 self.assertEqual(None, rcode)3443 self.assertEqual(execute_db_script_mock.call_count, 2)3444 @not_for_platform(PLATFORM_WINDOWS)3445 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))3446 @patch("sys.stdout.flush")3447 @patch("sys.stdout.write")3448 @patch("ambari_server_main.looking_for_pid")3449 @patch("ambari_server_main.wait_for_pid")3450 @patch("ambari_server_main.save_main_pid_ex")3451 @patch("ambari_server_main.check_exitcode")3452 @patch("os.makedirs")3453 @patch("ambari_server_main.locate_file")3454 @patch.object(_ambari_server_, "is_server_runing")3455 @patch("os.chown")3456 @patch("ambari_server.setupSecurity.get_master_key_location")3457 @patch("ambari_server.setupSecurity.save_master_key")3458 @patch("ambari_server_main.get_is_persisted")3459 @patch("ambari_server_main.get_is_secure")3460 @patch('os.chmod', autospec=True)3461 @patch("ambari_server.serverConfiguration.write_property")3462 @patch("ambari_server.serverConfiguration.get_validated_string_input")3463 @patch("os.environ")3464 @patch("ambari_server.setupSecurity.get_ambari_properties")3465 @patch("ambari_server.serverSetup.get_ambari_properties")3466 @patch("ambari_server.serverConfiguration.get_ambari_properties")3467 @patch("ambari_server_main.get_ambari_properties")3468 @patch("os.path.exists")3469 @patch("__builtin__.open")3470 @patch("subprocess.Popen")3471 @patch("ambari_server.serverConfiguration.search_file")3472 @patch("ambari_server_main.check_database_name_property")3473 @patch("ambari_server_main.find_jdk")3474 @patch("ambari_server_main.print_warning_msg")3475 @patch("ambari_server_main.print_info_msg")3476 @patch.object(PGConfig, "_check_postgre_up")3477 @patch("ambari_server_main.read_ambari_user")3478 @patch("ambari_server.setupSecurity.is_root")3479 @patch("ambari_server.dbConfiguration_linux.is_root")3480 @patch("ambari_server_main.is_root")3481 @patch.object(LinuxDBMSConfig, "_find_jdbc_driver")3482 @patch("getpass.getuser")3483 @patch("os.chdir")3484 @patch.object(ResourceFilesKeeper, "perform_housekeeping")3485 def test_start(self, perform_housekeeping_mock, chdir_mock, getuser_mock, find_jdbc_driver_mock,3486 is_root_mock, is_root_2_mock, is_root_3_mock, read_ambari_user_mock,3487 check_postgre_up_mock, print_info_msg_mock, print_warning_msg_mock,3488 find_jdk_mock, check_database_name_property_mock, search_file_mock,3489 popenMock, openMock, pexistsMock,3490 get_ambari_properties_mock, get_ambari_properties_2_mock, get_ambari_properties_3_mock,3491 get_ambari_properties_4_mock, os_environ_mock,3492 get_validated_string_input_method, write_property_method,3493 os_chmod_method, get_is_secure_mock, get_is_persisted_mock,3494 save_master_key_method, get_master_key_location_method,3495 os_chown_mock, is_server_running_mock, locate_file_mock,3496 os_makedirs_mock, check_exitcode_mock, save_main_pid_ex_mock,3497 wait_for_pid_mock, looking_for_pid_mock, stdout_write_mock, stdout_flush_mock):3498 def reset_mocks():3499 pexistsMock.reset_mock()3500 args = MagicMock()3501 del args.dbms3502 del args.database_index3503 del args.database_host3504 del args.database_port3505 del args.database_name3506 del args.database_username3507 del args.database_password3508 del args.persistence_type3509 del args.sid_or_sname3510 del args.jdbc_url3511 del args.debug3512 del args.suspend_start3513 return args3514 args = reset_mocks()3515 locate_file_mock.side_effect = lambda *args: '/bin/su' if args[0] == 'su' else '/bin/sh'3516 f = MagicMock()3517 f.readline.return_value = '42'3518 openMock.return_value = f3519 looking_for_pid_mock.return_value = [{3520 "pid": "777",3521 "exe": "/test",3522 "cmd": "test arg"3523 }]3524 wait_for_pid_mock.return_value = 13525 check_exitcode_mock.return_value = 03526 p = Properties()3527 p.process_pair(SECURITY_IS_ENCRYPTION_ENABLED, 'False')3528 get_ambari_properties_4_mock.return_value = \3529 get_ambari_properties_3_mock.return_value = get_ambari_properties_2_mock.return_value = \3530 get_ambari_properties_mock.return_value = p3531 get_is_secure_mock.return_value = False3532 get_is_persisted_mock.return_value = (False, None)3533 search_file_mock.return_value = None3534 is_server_running_mock.return_value = (True, 123)3535 os_chown_mock.return_value = None3536 # Checking "server is running"3537 pexistsMock.return_value = True3538 if get_platform() != PLATFORM_WINDOWS:3539 with patch("pwd.getpwnam") as getpwnam_mock:3540 pw = MagicMock()3541 pw.setattr('pw_uid', 0)3542 pw.setattr('pw_gid', 0)3543 getpwnam_mock.return_value = pw3544 try:3545 _ambari_server_.start(args)3546 self.fail("Should fail with 'Server is running'")3547 except FatalException as e:3548 # Expected3549 self.assertTrue('Ambari Server is already running.' in e.reason)3550 args = reset_mocks()3551 is_server_running_mock.return_value = (False, 0)3552 pexistsMock.return_value = False3553 # Checking situation when ambari user is not set up3554 read_ambari_user_mock.return_value = None3555 try:3556 _ambari_server_.start(args)3557 self.fail("Should fail with 'Can not detect a system user for Ambari'")3558 except FatalException as e:3559 # Expected3560 self.assertTrue('Unable to detect a system user for Ambari Server.' in e.reason)3561 # Checking start from non-root when current user is not the same as a3562 # custom user3563 args = reset_mocks()3564 read_ambari_user_mock.return_value = "dummy-user"3565 getuser_mock.return_value = "non_custom_user"3566 is_root_3_mock.return_value = \3567 is_root_2_mock.return_value = \3568 is_root_mock.return_value = False3569 try:3570 _ambari_server_.start(args)3571 self.fail("Should fail with 'Can not start ambari-server as user...'")3572 except FatalException as e:3573 # Expected3574 self.assertTrue('Unable to start Ambari Server as user' in e.reason)3575 #self.assertFalse(parse_properties_file_mock.called)3576 # Checking "jdk not found"3577 args = reset_mocks()3578 is_root_3_mock.return_value = \3579 is_root_2_mock.return_value = \3580 is_root_mock.return_value = True3581 find_jdk_mock.return_value = None3582 try:3583 _ambari_server_.start(args)3584 self.fail("Should fail with 'No JDK found'")3585 except FatalException as e:3586 # Expected3587 self.assertTrue('No JDK found' in e.reason)3588 args = reset_mocks()3589 find_jdk_mock.return_value = "somewhere"3590 ## Testing workflow under root3591 is_root_3_mock.return_value = \3592 is_root_2_mock.return_value = \3593 is_root_mock.return_value = True3594 # Remote DB3595 p.process_pair(JDBC_DATABASE_PROPERTY, 'oracle')3596 p.process_pair(PERSISTENCE_TYPE_PROPERTY, 'remote')3597 # Case when jdbc driver is not used3598 find_jdbc_driver_mock.return_value = -13599 try:3600 _ambari_server_.start(args)3601 self.fail("Should fail with exception")3602 except FatalException as e:3603 self.assertTrue('Before starting Ambari Server' in e.reason)3604 args = reset_mocks()3605 # Remote DB3606 p.process_pair(JDBC_DATABASE_PROPERTY, 'oracle')3607 p.process_pair(PERSISTENCE_TYPE_PROPERTY, 'remote')3608 find_jdbc_driver_mock.reset_mock()3609 find_jdbc_driver_mock.return_value = -13610 try:3611 _ambari_server_.start(args)3612 except FatalException as e:3613 # Ignored3614 pass3615 args = reset_mocks()3616 # Remote DB3617 p.process_pair(JDBC_DATABASE_PROPERTY, 'oracle')3618 p.process_pair(PERSISTENCE_TYPE_PROPERTY, 'remote')3619 find_jdbc_driver_mock.reset_mock()3620 find_jdbc_driver_mock.return_value = 03621 # Test exception handling on resource files housekeeping3622 perform_housekeeping_mock.reset_mock()3623 perform_housekeeping_mock.side_effect = KeeperException("some_reason")3624 pexistsMock.return_value = True3625 try:3626 _ambari_server_.start(args)3627 self.fail("Should fail with exception")3628 except FatalException as e:3629 self.assertTrue('some_reason' in e.reason)3630 self.assertTrue(perform_housekeeping_mock.called)3631 perform_housekeeping_mock.side_effect = lambda *v, **kv : None3632 perform_housekeeping_mock.reset_mock()3633 self.assertFalse('Unable to start PostgreSQL server' in e.reason)3634 self.assertFalse(check_postgre_up_mock.called)3635 args = reset_mocks()3636 # Local DB3637 p.process_pair(JDBC_DATABASE_PROPERTY, 'postgres')3638 p.process_pair(PERSISTENCE_TYPE_PROPERTY, 'local')3639 check_postgre_up_mock.reset_mock()3640 # case: postgres failed to start3641 check_postgre_up_mock.return_value = None, 1, "Unable to start PostgreSQL serv", "error"3642 try:3643 _ambari_server_.start(args)3644 self.fail("Should fail with 'Unable to start PostgreSQL server'")3645 except FatalException as e:3646 # Expected3647 self.assertTrue('Unable to start PostgreSQL server' in e.reason)3648 self.assertTrue(check_postgre_up_mock.called)3649 args = reset_mocks()3650 # Local DB3651 p.process_pair(JDBC_DATABASE_PROPERTY, 'postgres')3652 p.process_pair(PERSISTENCE_TYPE_PROPERTY, 'local')3653 check_postgre_up_mock.return_value = "running", 0, "success", ""3654 # Case: custom user is "root"3655 read_ambari_user_mock.return_value = "root"3656 # Java failed to start3657 proc = MagicMock()3658 proc.pid = -1863659 popenMock.return_value = proc3660 try:3661 _ambari_server_.start(args)3662 except FatalException as e:3663 # Expected3664 self.assertTrue(popenMock.called)3665 self.assertTrue('Ambari Server java process died' in e.reason)3666 self.assertTrue(perform_housekeeping_mock.called)3667 args = reset_mocks()3668 # Java OK3669 proc.pid = 1863670 popenMock.reset_mock()3671 _ambari_server_.start(args)3672 self.assertTrue(popenMock.called)3673 popen_arg = popenMock.call_args[0][0]3674 self.assertTrue(popen_arg[0] == "/bin/sh")3675 self.assertTrue(perform_housekeeping_mock.called)3676 args = reset_mocks()3677 # Local DB3678 p.process_pair(JDBC_DATABASE_PROPERTY, 'postgres')3679 p.process_pair(PERSISTENCE_TYPE_PROPERTY, 'local')3680 perform_housekeeping_mock.reset_mock()3681 popenMock.reset_mock()3682 # Case: custom user is not "root"3683 read_ambari_user_mock.return_value = "not-root-user"3684 _ambari_server_.start(args)3685 self.assertTrue(chdir_mock.called)3686 self.assertTrue(popenMock.called)3687 popen_arg = popenMock.call_args_list[0][0][0]3688 self.assertTrue("; /bin/su" in popen_arg[2])3689 self.assertTrue(perform_housekeeping_mock.called)3690 args = reset_mocks()3691 # Local DB3692 p.process_pair(JDBC_DATABASE_PROPERTY, 'postgres')3693 p.process_pair(PERSISTENCE_TYPE_PROPERTY, 'local')3694 check_postgre_up_mock.reset_mock()3695 popenMock.reset_mock()3696 ## Testing workflow under non-root3697 is_root_3_mock.return_value = \3698 is_root_2_mock.return_value = \3699 is_root_mock.return_value = False3700 read_ambari_user_mock.return_value = "not-root-user"3701 getuser_mock.return_value = read_ambari_user_mock.return_value3702 _ambari_server_.start(args)3703 self.assertFalse(check_postgre_up_mock.called)3704 args = reset_mocks()3705 # Remote DB3706 p.process_pair(JDBC_DATABASE_PROPERTY, 'postgres')3707 p.process_pair(PERSISTENCE_TYPE_PROPERTY, 'remote')3708 _ambari_server_.start(args)3709 self.assertFalse(check_postgre_up_mock.called)3710 args = reset_mocks()3711 # Remote DB3712 p.process_pair(JDBC_DATABASE_PROPERTY, 'postgres')3713 p.process_pair(PERSISTENCE_TYPE_PROPERTY, 'remote')3714 # Checking call3715 _ambari_server_.start(args)3716 self.assertTrue(popenMock.called)3717 popen_arg = popenMock.call_args[0][0]3718 self.assertTrue(popen_arg[0] == "/bin/sh")3719 args = reset_mocks()3720 # Remote DB3721 p.process_pair(JDBC_DATABASE_PROPERTY, 'postgres')3722 p.process_pair(PERSISTENCE_TYPE_PROPERTY, 'remote')3723 # Test start under wrong user3724 read_ambari_user_mock.return_value = "not-root-user"3725 getuser_mock.return_value = "non_custom_user"3726 try:3727 _ambari_server_.start(args)3728 self.fail("Can not start ambari-server as user non_custom_user.")3729 except FatalException as e:3730 # Expected3731 self.assertTrue('Unable to start Ambari Server as user' in e.reason)3732 args = reset_mocks()3733 # Check environ master key is set3734 popenMock.reset_mock()3735 os_environ_mock.copy.return_value = {"a": "b",3736 SECURITY_KEY_ENV_VAR_NAME: "masterkey"}3737 p.process_pair(JDBC_DATABASE_PROPERTY, 'postgres')3738 p.process_pair(PERSISTENCE_TYPE_PROPERTY, 'local')3739 read_ambari_user_mock.return_value = "root"3740 is_root_3_mock.return_value = \3741 is_root_2_mock.return_value = \3742 is_root_mock.return_value = True3743 _ambari_server_.start(args)3744 self.assertFalse(get_validated_string_input_method.called)3745 self.assertFalse(save_master_key_method.called)3746 popen_arg = popenMock.call_args[1]['env']3747 self.assertEquals(os_environ_mock.copy.return_value, popen_arg)3748 args = reset_mocks()3749 # Check environ master key is not set3750 popenMock.reset_mock()3751 os_environ_mock.reset_mock()3752 p.process_pair(SECURITY_IS_ENCRYPTION_ENABLED, 'True')3753 os_environ_mock.copy.return_value = {"a": "b"}3754 p.process_pair(JDBC_DATABASE_PROPERTY, 'postgres')3755 p.process_pair(PERSISTENCE_TYPE_PROPERTY, 'local')3756 read_ambari_user_mock.return_value = "root"3757 is_root_3_mock.return_value = \3758 is_root_2_mock.return_value = \3759 is_root_mock.return_value = True3760 get_validated_string_input_method.return_value = "masterkey"3761 os_chmod_method.return_value = None3762 get_is_secure_mock.return_value = True3763 _ambari_server_.start(args)3764 self.assertTrue(get_validated_string_input_method.called)3765 self.assertTrue(save_master_key_method.called)3766 popen_arg = popenMock.call_args[1]['env']3767 self.assertEquals(os_environ_mock.copy.return_value, popen_arg)3768 pass3769 @not_for_platform(PLATFORM_WINDOWS)3770 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))3771 @patch.object(_ambari_server_, "is_server_runing")3772 @patch("os.remove")3773 @patch("os.killpg")3774 @patch("os.getpgid")3775 @patch.object(_ambari_server_, "print_info_msg")3776 def test_stop(self, print_info_msg_mock, gpidMock, removeMock,3777 killMock, isServerRuningMock):3778 isServerRuningMock.return_value = (True, 123)3779 _ambari_server_.stop(None)3780 self.assertTrue(killMock.called)3781 self.assertTrue(removeMock.called)3782 pass3783 @only_for_platform(PLATFORM_WINDOWS)3784 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))3785 @patch("win32serviceutil.StopServiceWithDeps")3786 @patch("win32serviceutil.StopService")3787 @patch("win32serviceutil.WaitForServiceStatus")3788 def test_stop(self, WaitForServiceStatusMock, StopServiceMock, StopServiceWithDepsMock):3789 _ambari_server_.stop()3790 self.assertTrue(StopServiceWithDepsMock.called)3791 self.assertFalse(StopServiceMock.called)3792 self.assertTrue(WaitForServiceStatusMock.called)3793 pass3794 @patch.object(_ambari_server_, "BackupRestore_main")3795 def test_backup(self, bkrestore_mock):3796 args = ["", "/some/path/file.zip"]3797 _ambari_server_.backup(args)3798 self.assertTrue(bkrestore_mock.called)3799 pass3800 @patch.object(_ambari_server_, "BackupRestore_main")3801 def test_backup_no_path(self, bkrestore_mock):3802 args = [""]3803 _ambari_server_.backup(args)3804 self.assertTrue(bkrestore_mock.called)3805 pass3806 @patch.object(_ambari_server_, "BackupRestore_main")3807 def test_restore(self, bkrestore_mock):3808 args = ["", "/some/path/file.zip"]3809 _ambari_server_.restore(args)3810 self.assertTrue(bkrestore_mock.called)3811 pass3812 @patch.object(_ambari_server_, "BackupRestore_main")3813 def test_restore_no_path(self, bkrestore_mock):3814 args = [""]3815 _ambari_server_.restore(args)3816 self.assertTrue(bkrestore_mock.called)3817 pass3818 @patch("ambari_server.serverUpgrade.is_root")3819 @patch("ambari_server.serverUpgrade.check_database_name_property")3820 @patch("ambari_server.serverUpgrade.run_stack_upgrade")3821 def test_upgrade_stack(self, run_stack_upgrade_mock,3822 check_database_name_property_mock, is_root_mock):3823 # Testing call under non-root3824 is_root_mock.return_value = False3825 args = ['', 'HDP-2.0']3826 try:3827 upgrade_stack(args)3828 self.fail("Should throw exception")3829 except FatalException as fe:3830 # Expected3831 self.assertTrue("root-level" in fe.reason)3832 pass3833 # Testing calls under root3834 is_root_mock.return_value = True3835 run_stack_upgrade_mock.return_value = 03836 upgrade_stack(args)3837 self.assertTrue(run_stack_upgrade_mock.called)3838 run_stack_upgrade_mock.assert_called_with("HDP", "2.0", None, None)3839 pass3840 @patch("ambari_server.serverUpgrade.get_ambari_properties")3841 @patch("os.listdir")3842 @patch("os.path.isfile")3843 @patch("shutil.move")3844 def test_move_user_custom_actions(self, shutil_move_mock, os_path_isfile_mock, os_listdir_mock, get_ambari_properties_mock):3845 properties = Properties()3846 properties.process_pair(RESOURCES_DIR_PROPERTY, 'some/test/fake/resources/dir/path')3847 get_ambari_properties_mock.return_value = properties3848 os_listdir_mock.return_value = ['sometestdir', 'sometestfile.md', 'sometestfile.py', 'sometestfile2.java', 'sometestfile2.py', 'sometestdir2.py']3849 os_path_isfile_mock.side_effect = [False, True, True, True, True, False]3850 move_user_custom_actions()3851 custom_actions_scripts_dir = os.path.join('some/test/fake/resources/dir/path', 'custom_actions', 'scripts')3852 shutil_move_mock.assert_has_calls([call(os.path.join('some/test/fake/resources/dir/path', 'custom_actions', 'sometestfile.py'), custom_actions_scripts_dir),3853 call(os.path.join('some/test/fake/resources/dir/path', 'custom_actions', 'sometestfile2.py'), custom_actions_scripts_dir)])3854 self.assertEqual(shutil_move_mock.call_count, 2)3855 pass3856 @patch("ambari_server.serverConfiguration.get_conf_dir")3857 @patch("ambari_server.serverConfiguration.get_ambari_classpath")3858 @patch("ambari_server.serverUpgrade.run_os_command")3859 @patch("ambari_server.serverUpgrade.get_java_exe_path")3860 def test_run_stack_upgrade(self, java_exe_path_mock, run_os_command_mock,3861 get_ambari_classpath_mock, get_conf_dir_mock):3862 java_exe_path_mock.return_value = "/usr/lib/java/bin/java"3863 run_os_command_mock.return_value = (0, None, None)3864 get_ambari_classpath_mock.return_value = 'test:path12'3865 get_conf_dir_mock.return_value = '/etc/conf'3866 stackIdMap = {'HDP' : '2.0', 'repo_url' : 'http://test.com'}3867 run_stack_upgrade('HDP', '2.0', 'http://test.com', None)3868 self.assertTrue(java_exe_path_mock.called)3869 self.assertTrue(get_ambari_classpath_mock.called)3870 self.assertTrue(get_conf_dir_mock.called)3871 self.assertTrue(run_os_command_mock.called)3872 run_os_command_mock.assert_called_with('/usr/lib/java/bin/java -cp /etc/conf' + os.pathsep + 'test:path12 '3873 'org.apache.ambari.server.upgrade.StackUpgradeHelper '3874 'updateStackId ' + "'" + json.dumps(stackIdMap) + "'" +3875 ' > ' + os.sep + 'var' + os.sep + 'log' + os.sep + 'ambari-server' + os.sep +3876 'ambari-server.out 2>&1')3877 pass3878 @patch("ambari_server.serverConfiguration.get_conf_dir")3879 @patch("ambari_server.serverConfiguration.get_ambari_classpath")3880 @patch("ambari_server.serverUpgrade.run_os_command")3881 @patch("ambari_server.serverUpgrade.get_java_exe_path")3882 def test_run_stack_upgrade_with_url_os(self, java_exe_path_mock, run_os_command_mock,3883 get_ambari_classpath_mock, get_conf_dir_mock):3884 java_exe_path_mock.return_value = "/usr/lib/java/bin/java"3885 run_os_command_mock.return_value = (0, None, None)3886 get_ambari_classpath_mock.return_value = 'test:path12'3887 get_conf_dir_mock.return_value = '/etc/conf'3888 stackIdMap = {'HDP' : '2.0', 'repo_url': 'http://test.com', 'repo_url_os': 'centos5,centos6'}3889 run_stack_upgrade('HDP', '2.0', 'http://test.com', 'centos5,centos6')3890 self.assertTrue(java_exe_path_mock.called)3891 self.assertTrue(get_ambari_classpath_mock.called)3892 self.assertTrue(get_conf_dir_mock.called)3893 self.assertTrue(run_os_command_mock.called)3894 run_os_command_mock.assert_called_with('/usr/lib/java/bin/java -cp /etc/conf' + os.pathsep + 'test:path12 '3895 'org.apache.ambari.server.upgrade.StackUpgradeHelper '3896 'updateStackId ' + "'" + json.dumps(stackIdMap) + "'" +3897 ' > ' + os.sep + 'var' + os.sep + 'log' + os.sep + 'ambari-server' + os.sep +3898 'ambari-server.out 2>&1')3899 pass3900 @patch("ambari_server.serverUpgrade.ensure_can_start_under_current_user")3901 @patch("ambari_server.serverUpgrade.generate_env")3902 @patch("ambari_server.serverUpgrade.read_ambari_user")3903 @patch("ambari_server.serverConfiguration.get_conf_dir")3904 @patch("ambari_server.serverConfiguration.get_ambari_classpath")3905 @patch("ambari_server.serverUpgrade.run_os_command")3906 @patch("ambari_server.serverUpgrade.get_java_exe_path")3907 def test_run_schema_upgrade(self, java_exe_path_mock, run_os_command_mock,3908 get_ambari_classpath_mock, get_conf_dir_mock,3909 read_ambari_user_mock, generate_env_mock,3910 ensure_can_start_under_current_user_mock):3911 java_exe_path_mock.return_value = "/usr/lib/java/bin/java"3912 run_os_command_mock.return_value = (0, None, None)3913 get_ambari_classpath_mock.return_value = 'test' + os.pathsep + 'path12'3914 get_conf_dir_mock.return_value = '/etc/conf'3915 command = '/usr/lib/java/bin/java -cp /etc/conf' + os.pathsep + 'test' + os.pathsep + 'path12 ' \3916 'org.apache.ambari.server.upgrade.SchemaUpgradeHelper ' \3917 '> ' + os.sep + 'var' + os.sep + 'log' + os.sep + 'ambari-server' + os.sep + 'ambari-server.out 2>&1'3918 environ = {}3919 generate_env_mock.return_value = environ3920 ensure_can_start_under_current_user_mock.return_value = "root"3921 read_ambari_user_mock.return_value = "ambari"3922 run_schema_upgrade()3923 self.assertTrue(java_exe_path_mock.called)3924 self.assertTrue(ensure_can_start_under_current_user_mock.called)3925 self.assertTrue(generate_env_mock.called)3926 self.assertTrue(read_ambari_user_mock.called)3927 self.assertTrue(get_ambari_classpath_mock.called)3928 self.assertTrue(get_conf_dir_mock.called)3929 self.assertTrue(run_os_command_mock.called)3930 run_os_command_mock.assert_called_with(command, env=environ)3931 pass3932 @patch("ambari_server.serverConfiguration.get_conf_dir")3933 @patch("ambari_server.serverConfiguration.get_ambari_classpath")3934 @patch("ambari_server.serverUpgrade.run_os_command")3935 @patch("ambari_server.serverUpgrade.get_java_exe_path")3936 def test_run_metainfo_upgrade(self, java_exe_path_mock, run_os_command_mock,3937 get_ambari_classpath_mock, get_conf_dir_mock):3938 java_exe_path_mock.return_value = "/usr/lib/java/bin/java"3939 run_os_command_mock.return_value = (0, None, None)3940 get_ambari_classpath_mock.return_value = 'test' + os.pathsep + 'path12'3941 get_conf_dir_mock.return_value = '/etc/conf'3942 json_map = {'a': 'http://newurl'}3943 run_metainfo_upgrade(json_map)3944 self.assertTrue(java_exe_path_mock.called)3945 self.assertTrue(get_ambari_classpath_mock.called)3946 self.assertTrue(get_conf_dir_mock.called)3947 self.assertTrue(run_os_command_mock.called)3948 run_os_command_mock.assert_called_with('/usr/lib/java/bin/java '3949 '-cp /etc/conf' + os.pathsep + 'test' + os.pathsep + 'path12 '3950 'org.apache.ambari.server.upgrade.StackUpgradeHelper updateMetaInfo ' +3951 "'" + json.dumps(json_map) + "'" +3952 ' > ' + os.sep + 'var' + os.sep + 'log' + os.sep + 'ambari-server' +3953 os.sep + 'ambari-server.out 2>&1')3954 pass3955 @not_for_platform(PLATFORM_WINDOWS)3956 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))3957 @patch("os.path.isfile")3958 @patch("ambari_server.serverSetup.get_ambari_properties")3959 @patch("os.path.exists")3960 @patch("os.path.lexists")3961 @patch("os.remove")3962 @patch("os.symlink")3963 @patch("shutil.copy")3964 def test_proceedJDBCProperties(self, copy_mock, os_symlink_mock, os_remove_mock, lexists_mock, exists_mock,3965 get_ambari_properties_mock, isfile_mock):3966 args = MagicMock()3967 # test incorrect path to jdbc-driver3968 isfile_mock.return_value = False3969 args.jdbc_driver = "test jdbc"3970 fail = False3971 try:3972 proceedJDBCProperties(args)3973 except FatalException as e:3974 self.assertEquals("File test jdbc does not exist!", e.reason)3975 fail = True3976 self.assertTrue(fail)3977 # test incorrect jdbc-db3978 isfile_mock.return_value = True3979 args.jdbc_db = "incorrect db"3980 fail = False3981 try:3982 proceedJDBCProperties(args)3983 except FatalException as e:3984 self.assertEquals("Unsupported database name incorrect db. Please see help for more information.", e.reason)3985 fail = True3986 self.assertTrue(fail)3987 # test getAmbariProperties failed3988 args.jdbc_db = "mysql"3989 get_ambari_properties_mock.return_value = -13990 fail = False3991 try:3992 proceedJDBCProperties(args)3993 except FatalException as e:3994 self.assertEquals("Error getting ambari properties", e.reason)3995 fail = True3996 self.assertTrue(fail)3997 # test getAmbariProperties failed3998 args.jdbc_db = "mssql"3999 get_ambari_properties_mock.return_value = -14000 fail = False4001 try:4002 proceedJDBCProperties(args)4003 except FatalException as e:4004 self.assertEquals("Error getting ambari properties", e.reason)4005 fail = True4006 self.assertTrue(fail)4007 # test get resource dir param failed4008 args.jdbc_db = "oracle"4009 p = MagicMock()4010 get_ambari_properties_mock.return_value = p4011 p.__getitem__.side_effect = KeyError("test exception")4012 exists_mock.return_value = False4013 fail = False4014 try:4015 proceedJDBCProperties(args)4016 except FatalException as e:4017 fail = True4018 self.assertTrue(fail)4019 # test copy jdbc failed and symlink exists4020 lexists_mock.return_value = True4021 args.jdbc_db = "postgres"4022 get_ambari_properties_mock.return_value = MagicMock()4023 isfile_mock.side_effect = [True, False]4024 exists_mock.return_value = True4025 fail = False4026 def side_effect():4027 raise Exception(-1, "Failed to copy!")4028 copy_mock.side_effect = side_effect4029 try:4030 proceedJDBCProperties(args)4031 except FatalException as e:4032 fail = True4033 self.assertTrue(fail)4034 self.assertTrue(os_remove_mock.called)4035 # test success symlink creation4036 get_ambari_properties_mock.reset_mock()4037 os_remove_mock.reset_mock()4038 p = MagicMock()4039 get_ambari_properties_mock.return_value = p4040 p.__getitem__.side_effect = None4041 p.__getitem__.return_value = "somewhere"4042 copy_mock.reset_mock()4043 copy_mock.side_effect = None4044 isfile_mock.side_effect = [True, False]4045 proceedJDBCProperties(args)4046 self.assertTrue(os_remove_mock.called)4047 self.assertTrue(os_symlink_mock.called)4048 self.assertTrue(copy_mock.called)4049 self.assertEquals(os_symlink_mock.call_args_list[0][0][0], os.path.join("somewhere","test jdbc"))4050 self.assertEquals(os_symlink_mock.call_args_list[0][0][1], os.path.join("somewhere","postgres-jdbc-driver.jar"))4051 pass4052 @only_for_platform(PLATFORM_WINDOWS)4053 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))4054 @patch("os.path.isfile")4055 @patch("ambari_server.serverSetup.get_ambari_properties")4056 @patch("os.path.exists")4057 @patch("os.path.lexists")4058 @patch("os.remove")4059 @patch("os.symlink")4060 @patch("shutil.copy")4061 def test_proceedJDBCProperties(self, copy_mock, os_symlink_mock, os_remove_mock, lexists_mock, exists_mock,4062 get_ambari_properties_mock, isfile_mock):4063 args = MagicMock()4064 # test incorrect path to jdbc-driver4065 isfile_mock.return_value = False4066 args.jdbc_driver = "test jdbc"4067 fail = False4068 try:4069 proceedJDBCProperties(args)4070 except FatalException as e:4071 self.assertEquals("File test jdbc does not exist!", e.reason)4072 fail = True4073 self.assertTrue(fail)4074 # test incorrect jdbc-db4075 isfile_mock.return_value = True4076 args.jdbc_db = "incorrect db"4077 fail = False4078 try:4079 proceedJDBCProperties(args)4080 except FatalException as e:4081 self.assertEquals("Unsupported database name incorrect db. Please see help for more information.", e.reason)4082 fail = True4083 self.assertTrue(fail)4084 # test getAmbariProperties succeeded4085 args.jdbc_db = "mssql"4086 get_ambari_properties_mock.return_value = -14087 fail = False4088 try:4089 proceedJDBCProperties(args)4090 except FatalException as e:4091 self.assertEquals("Error getting ambari properties", e.reason)4092 fail = True4093 self.assertFalse(fail)4094 pass4095 @not_for_platform(PLATFORM_WINDOWS)4096 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))4097 @patch("__builtin__.open")4098 @patch("os.path.isfile")4099 @patch("os.path.lexists")4100 @patch("os.path.exists")4101 @patch("os.remove")4102 @patch("os.symlink")4103 @patch.object(Properties, "store")4104 @patch("ambari_server.serverUpgrade.adjust_directory_permissions")4105 @patch("ambari_server.serverUpgrade.print_warning_msg")4106 @patch("ambari_server.serverUpgrade.read_ambari_user")4107 @patch("ambari_server.serverUpgrade.run_schema_upgrade")4108 @patch("ambari_server.dbConfiguration_linux.run_os_command")4109 @patch("ambari_server.serverConfiguration.find_properties_file")4110 @patch("ambari_server.serverUpgrade.update_ambari_properties")4111 @patch("ambari_server.serverUpgrade.is_root")4112 @patch("ambari_server.serverConfiguration.write_property")4113 @patch("ambari_server.serverConfiguration.get_ambari_version")4114 @patch("ambari_server.dbConfiguration.get_ambari_properties")4115 @patch("ambari_server.serverConfiguration.get_ambari_properties")4116 @patch("ambari_server.serverUpgrade.get_ambari_properties")4117 @patch("ambari_server.serverUpgrade.upgrade_local_repo")4118 @patch("ambari_server.serverUpgrade.move_user_custom_actions")4119 @patch("ambari_server.serverUpgrade.update_krb_jaas_login_properties")4120 def test_upgrade_from_161(self, update_krb_jaas_login_properties_mock, move_user_custom_actions_mock, upgrade_local_repo_mock, get_ambari_properties_mock,4121 get_ambari_properties_2_mock, get_ambari_properties_3_mock, get_ambari_version_mock, write_property_mock,4122 is_root_mock, update_ambari_properties_mock, find_properties_file_mock, run_os_command_mock,4123 run_schema_upgrade_mock, read_ambari_user_mock, print_warning_msg_mock,4124 adjust_directory_permissions_mock, properties_store_mock,4125 os_symlink_mock, os_remove_mock, exists_mock, lexists_mock, isfile_mock, open_mock):4126 def reset_mocks():4127 run_os_command_mock.reset_mock()4128 write_property_mock.reset_mock()4129 isfile_mock.reset_mock()4130 lexists_mock.reeset_mock()4131 os_symlink_mock.reset_mock()4132 lexists_mock.return_value = False4133 args = MagicMock()4134 del args.dbms4135 del args.database_index4136 del args.database_host4137 del args.database_port4138 del args.database_name4139 del args.database_username4140 del args.database_password4141 del args.database_windows_auth4142 del args.default_database_host4143 del args.init_db_script_file4144 del args.cleanup_db_script_file4145 del args.must_set_database_options4146 del args.sid_or_sname4147 del args.jdbc_url4148 args.jdbc_driver= None4149 args.jdbc_db = None4150 args.silent = False4151 return args4152 args = reset_mocks()4153 args.dbms = "postgres"4154 is_root_mock.return_value = True4155 update_ambari_properties_mock.return_value = 04156 get_ambari_version_mock.return_value = "1.7.0"4157 move_user_custom_actions_mock.return_value = None4158 update_krb_jaas_login_properties_mock.return_value = -24159 # Local Postgres4160 # In Ambari 1.6.1 for an embedded postgres database, the "server.jdbc.database" property stored the DB name,4161 # and the DB type was assumed to be "postgres" if the "server.persistence.type" property was "local"4162 properties = Properties()4163 properties.process_pair(PERSISTENCE_TYPE_PROPERTY, "local")4164 properties.process_pair(JDBC_DATABASE_PROPERTY, "ambari")4165 properties.process_pair(RESOURCES_DIR_PROPERTY, "/tmp")4166 get_ambari_properties_mock.return_value = properties4167 properties2 = Properties()4168 properties2.process_pair(PERSISTENCE_TYPE_PROPERTY, "local")4169 properties2.process_pair(JDBC_DATABASE_NAME_PROPERTY, "ambari")4170 properties2.process_pair(JDBC_DATABASE_PROPERTY, "postgres")4171 get_ambari_properties_3_mock.side_effect = get_ambari_properties_2_mock.side_effect = [properties, properties2, properties2]4172 run_schema_upgrade_mock.return_value = 04173 read_ambari_user_mock.return_value = "custom_user"4174 run_os_command_mock.return_value = (0, "", "")4175 isfile_mock.return_value = False4176 try:4177 upgrade(args)4178 except FatalException as fe:4179 self.fail("Did not expect failure: " + str(fe))4180 else:4181 self.assertTrue(write_property_mock.called)4182 self.assertEquals(write_property_mock.call_args_list[0][0][0], JDBC_DATABASE_NAME_PROPERTY)4183 self.assertEquals(write_property_mock.call_args_list[0][0][1], "ambari")4184 self.assertEquals(write_property_mock.call_args_list[1][0][0], JDBC_DATABASE_PROPERTY)4185 self.assertEquals(write_property_mock.call_args_list[1][0][1], "postgres")4186 self.assertTrue(run_os_command_mock.called)4187 self.assertFalse(move_user_custom_actions_mock.called)4188 args = reset_mocks()4189 # External Postgres4190 # In Ambari 1.6.1 for an external postgres database, the "server.jdbc.database" property stored the4191 # DB type ("postgres"), and the "server.jdbc.schema" property stored the DB name.4192 properties = Properties()4193 properties.process_pair(PERSISTENCE_TYPE_PROPERTY, "remote")4194 properties.process_pair(JDBC_DATABASE_PROPERTY, "postgres")4195 properties.process_pair(JDBC_RCA_SCHEMA_PROPERTY, "ambari")4196 properties.process_pair(JDBC_URL_PROPERTY, "jdbc:postgresql://c6410.ambari.apache.org:5432/ambari")4197 properties2 = Properties()4198 properties2.process_pair(PERSISTENCE_TYPE_PROPERTY, "remote")4199 properties2.process_pair(JDBC_DATABASE_NAME_PROPERTY, "ambari")4200 properties2.process_pair(JDBC_DATABASE_PROPERTY, "postgres")4201 properties2.process_pair(JDBC_RCA_SCHEMA_PROPERTY, "ambari")4202 properties2.process_pair(JDBC_URL_PROPERTY, "jdbc:postgresql://c6410.ambari.apache.org:5432/ambari")4203 get_ambari_properties_mock.return_value = properties4204 get_ambari_properties_3_mock.side_effect = get_ambari_properties_2_mock.side_effect = [properties, properties2, properties2]4205 exists_mock.return_value = True4206 try:4207 upgrade(args)4208 except FatalException as fe:4209 self.fail("Did not expect failure: " + str(fe))4210 else:4211 self.assertTrue(write_property_mock.called)4212 self.assertFalse(run_os_command_mock.called)4213 self.assertFalse(move_user_custom_actions_mock.called)4214 args = reset_mocks()4215 # External Postgres missing DB type, so it should be set based on the JDBC URL.4216 properties = Properties()4217 properties.process_pair(PERSISTENCE_TYPE_PROPERTY, "remote")4218 properties.process_pair(JDBC_RCA_SCHEMA_PROPERTY, "ambari")4219 properties.process_pair(JDBC_URL_PROPERTY, "jdbc:postgresql://c6410.ambari.apache.org:5432/ambari")4220 get_ambari_properties_mock.return_value = properties4221 get_ambari_properties_3_mock.side_effect = get_ambari_properties_2_mock.side_effect = [properties, properties2, properties2]4222 try:4223 upgrade(args)4224 except FatalException as fe:4225 self.fail("Did not expect failure: " + str(fe))4226 else:4227 self.assertTrue(write_property_mock.call_count == 2)4228 self.assertFalse(move_user_custom_actions_mock.called)4229 args = reset_mocks()4230 # External MySQL4231 # In Ambari 1.6.1 for an external MySQL database, the "server.jdbc.database" property stored the DB type ("mysql"),4232 # And the "server.jdbc.schema" property stored the DB name.4233 properties = Properties()4234 properties.process_pair(PERSISTENCE_TYPE_PROPERTY, "remote")4235 properties.process_pair(JDBC_DATABASE_PROPERTY, "mysql")4236 properties.process_pair(JDBC_RCA_SCHEMA_PROPERTY, "ambari")4237 properties.process_pair(JDBC_URL_PROPERTY, "jdbc:mysql://c6409.ambari.apache.org:3306/ambari")4238 properties2 = Properties()4239 properties2.process_pair(PERSISTENCE_TYPE_PROPERTY, "remote")4240 properties2.process_pair(JDBC_DATABASE_PROPERTY, "mysql")4241 properties2.process_pair(JDBC_DATABASE_NAME_PROPERTY, "ambari")4242 properties2.process_pair(JDBC_RCA_SCHEMA_PROPERTY, "ambari")4243 properties2.process_pair(JDBC_URL_PROPERTY, "jdbc:mysql://c6409.ambari.apache.org:3306/ambari")4244 get_ambari_properties_mock.return_value = properties4245 get_ambari_properties_3_mock.side_effect = get_ambari_properties_2_mock.side_effect = [properties, properties2, properties2]4246 isfile_mock.side_effect = [False, True, False]4247 try:4248 upgrade(args)4249 except FatalException as fe:4250 self.fail("Did not expect failure: " + str(fe))4251 else:4252 self.assertTrue(write_property_mock.called)4253 self.assertFalse(move_user_custom_actions_mock.called)4254 self.assertTrue(os_symlink_mock.called)4255 self.assertTrue(os_symlink_mock.call_args_list[0][0][0] == "/var/lib/ambari-server/resources/mysql-connector-java.jar")4256 self.assertTrue(os_symlink_mock.call_args_list[0][0][1] == "/var/lib/ambari-server/resources/mysql-jdbc-driver.jar")4257 args = reset_mocks()4258 # External MySQL missing DB type, so it should be set based on the JDBC URL.4259 properties = Properties()4260 properties.process_pair(PERSISTENCE_TYPE_PROPERTY, "remote")4261 properties.process_pair(JDBC_RCA_SCHEMA_PROPERTY, "ambari")4262 properties.process_pair(JDBC_URL_PROPERTY, "jdbc:mysql://c6409.ambari.apache.org:3306/ambari")4263 get_ambari_properties_mock.return_value = properties4264 get_ambari_properties_3_mock.side_effect = get_ambari_properties_2_mock.side_effect = [properties, properties2, properties2]4265 isfile_mock.side_effect = None4266 try:4267 upgrade(args)4268 except FatalException as fe:4269 self.fail("Did not expect failure: " + str(fe))4270 else:4271 self.assertTrue(write_property_mock.call_count == 2)4272 self.assertFalse(move_user_custom_actions_mock.called)4273 pass4274 @not_for_platform(PLATFORM_WINDOWS)4275 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))4276 @patch("__builtin__.open")4277 @patch("os.path.isfile")4278 @patch("os.path.exists")4279 @patch("os.path.lexists")4280 @patch("os.remove")4281 @patch("os.symlink")4282 @patch.object(Properties, "store")4283 @patch.object(PGConfig, "_change_db_files_owner")4284 @patch("ambari_server.serverConfiguration.find_properties_file")4285 @patch("ambari_server.serverUpgrade.adjust_directory_permissions")4286 @patch("ambari_server.serverUpgrade.print_warning_msg")4287 @patch("ambari_server.serverUpgrade.read_ambari_user")4288 @patch("ambari_server.serverUpgrade.run_schema_upgrade")4289 @patch("ambari_server.serverUpgrade.update_ambari_properties")4290 @patch("ambari_server.serverUpgrade.parse_properties_file")4291 @patch("ambari_server.serverUpgrade.get_ambari_version")4292 @patch("ambari_server.serverConfiguration.get_ambari_version")4293 @patch("ambari_server.serverUpgrade.is_root")4294 @patch("ambari_server.dbConfiguration.get_ambari_properties")4295 @patch("ambari_server.serverConfiguration.get_ambari_properties")4296 @patch("ambari_server.serverUpgrade.get_ambari_properties")4297 @patch("ambari_server.serverUpgrade.upgrade_local_repo")4298 @patch("ambari_server.serverUpgrade.move_user_custom_actions")4299 @patch("ambari_server.serverUpgrade.update_krb_jaas_login_properties")4300 def test_upgrade(self, update_krb_jaas_login_properties_mock, move_user_custom_actions, upgrade_local_repo_mock,4301 get_ambari_properties_mock, get_ambari_properties_2_mock, get_ambari_properties_3_mock,4302 is_root_mock, get_ambari_version_mock, get_ambari_version_2_mock,4303 parse_properties_file_mock,4304 update_ambari_properties_mock, run_schema_upgrade_mock,4305 read_ambari_user_mock, print_warning_msg_mock,4306 adjust_directory_permissions_mock,4307 find_properties_file_mock, change_db_files_owner_mock, properties_store_mock,4308 os_symlink_mock, os_remove_mock, lexists_mock, exists_mock, isfile_mock, open_mock):4309 def reset_mocks():4310 isfile_mock.reset_mock()4311 args = MagicMock()4312 del args.database_index4313 del args.dbms4314 del args.database_host4315 del args.database_port4316 del args.database_name4317 del args.database_username4318 del args.database_password4319 del args.persistence_type4320 del args.sid_or_sname4321 del args.jdbc_url4322 args.must_set_database_options = True4323 return args4324 args = reset_mocks()4325 properties = Properties()4326 get_ambari_properties_3_mock.return_value = get_ambari_properties_2_mock.return_value = \4327 get_ambari_properties_mock.return_value = properties4328 update_ambari_properties_mock.return_value = 04329 run_schema_upgrade_mock.return_value = 04330 isfile_mock.return_value = False4331 get_ambari_version_2_mock.return_value = get_ambari_version_mock.return_value = CURR_AMBARI_VERSION4332 move_user_custom_actions.return_value = None4333 update_krb_jaas_login_properties_mock.return_value = -24334 # Testing call under non-root4335 is_root_mock.return_value = False4336 try:4337 upgrade(args)4338 self.fail("Should throw exception")4339 except FatalException as fe:4340 # Expected4341 self.assertTrue("root-level" in fe.reason)4342 pass4343 args = reset_mocks()4344 # Testing calls under root4345 is_root_mock.return_value = True4346 # Testing with undefined custom user4347 read_ambari_user_mock.return_value = None4348 run_schema_upgrade_mock.return_value = 04349 change_db_files_owner_mock.return_value = 04350 exists_mock.return_value = True4351 upgrade(args)4352 self.assertTrue(print_warning_msg_mock.called)4353 warning_args = print_warning_msg_mock.call_args[0][0]4354 self.assertTrue("custom ambari user" in warning_args)4355 self.assertTrue(upgrade_local_repo_mock.called)4356 self.assertTrue(move_user_custom_actions.called)4357 args = reset_mocks()4358 # Testing with defined custom user4359 read_ambari_user_mock.return_value = "ambari-custom-user"4360 upgrade(args)4361 self.assertTrue(adjust_directory_permissions_mock.called)4362 args = reset_mocks()4363 run_schema_upgrade_mock.return_value = 04364 parse_properties_file_mock.called = False4365 move_user_custom_actions.called = False4366 retcode = upgrade(args)4367 self.assertTrue(get_ambari_properties_mock.called)4368 self.assertTrue(get_ambari_properties_2_mock.called)4369 self.assertNotEqual(-1, retcode)4370 self.assertTrue(parse_properties_file_mock.called)4371 self.assertTrue(run_schema_upgrade_mock.called)4372 self.assertTrue(move_user_custom_actions.called)4373 # Assert that move_user_custom_actions is called on upgrade to Ambari == 2.0.04374 get_ambari_version_2_mock.return_value = get_ambari_version_mock.return_value = '2.0.0'4375 move_user_custom_actions.called = False4376 upgrade(args)4377 self.assertTrue(move_user_custom_actions.called)4378 # Assert that move_user_custom_actions is not called on upgrade to Ambari < 2.0.04379 get_ambari_version_2_mock.return_value = get_ambari_version_mock.return_value = '1.6.0'4380 move_user_custom_actions.called = False4381 upgrade(args)4382 self.assertFalse(move_user_custom_actions.called)4383 get_ambari_version_2_mock.return_value = get_ambari_version_mock.return_value = CURR_AMBARI_VERSION4384 # test getAmbariProperties failed4385 args = reset_mocks()4386 get_ambari_properties_3_mock.return_value = get_ambari_properties_2_mock.return_value = \4387 get_ambari_properties_mock.return_value = -14388 fail = False4389 try:4390 upgrade(args)4391 except FatalException as e:4392 self.assertEquals("Error getting ambari properties", e.reason)4393 fail = True4394 self.assertTrue(fail)4395 # test get resource dir param failed4396 args = reset_mocks()4397 p = MagicMock()4398 get_ambari_properties_mock.reset_mock()4399 get_ambari_properties_2_mock.reset_mock()4400 get_ambari_properties_3_mock.reset_mock()4401 get_ambari_properties_3_mock.return_value = get_ambari_properties_2_mock.return_value = \4402 get_ambari_properties_mock.return_value = p4403 p.__getitem__.side_effect = ["something", "something", "something", "something", KeyError("test exception")]4404 exists_mock.return_value = False4405 fail = False4406 try:4407 upgrade(args)4408 except FatalException as e:4409 fail = True4410 self.assertTrue(fail)4411 # test if some drivers are available in resources, and symlink available too4412 args = reset_mocks()4413 props = Properties()4414 props.process_pair(JDBC_DATABASE_NAME_PROPERTY, "something")4415 props.process_pair(RESOURCES_DIR_PROPERTY, "resources")4416 get_ambari_properties_3_mock.return_value = get_ambari_properties_2_mock.return_value = \4417 get_ambari_properties_mock.return_value = props4418 exists_mock.return_value = True4419 lexists_mock.return_value = True4420 isfile_mock.side_effect = [True, False, False]4421 upgrade(args)4422 self.assertTrue(os_remove_mock.called)4423 self.assertEquals(os_remove_mock.call_count, 1)4424 self.assertEquals(os_remove_mock.call_args[0][0], os.path.join("resources", "oracle-jdbc-driver.jar"))4425 self.assertEquals(os_symlink_mock.call_count, 1)4426 self.assertEquals(os_symlink_mock.call_args[0][0], os.path.join("resources", "ojdbc6.jar"))4427 self.assertEquals(os_symlink_mock.call_args[0][1], os.path.join("resources", "oracle-jdbc-driver.jar"))4428 pass4429 @only_for_platform(PLATFORM_WINDOWS)4430 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))4431 @patch("__builtin__.open")4432 @patch("os.path.isfile")4433 @patch("os.path.exists")4434 @patch("os.path.lexists")4435 @patch("os.remove")4436 @patch("os.symlink")4437 @patch.object(Properties, "store")4438 @patch("ambari_server.serverConfiguration.find_properties_file")4439 @patch("ambari_server.serverUpgrade.adjust_directory_permissions")4440 @patch("ambari_server.serverUpgrade.print_warning_msg")4441 @patch("ambari_server.serverUpgrade.read_ambari_user")4442 @patch("ambari_server.serverUpgrade.run_schema_upgrade")4443 @patch("ambari_server.serverUpgrade.update_ambari_properties")4444 @patch("ambari_server.serverUpgrade.parse_properties_file")4445 @patch("ambari_server.serverUpgrade.get_ambari_version")4446 @patch("ambari_server.serverConfiguration.get_ambari_version")4447 @patch("ambari_server.serverUpgrade.is_root")4448 @patch("ambari_server.dbConfiguration.get_ambari_properties")4449 @patch("ambari_server.serverConfiguration.get_ambari_properties")4450 @patch("ambari_server.serverUpgrade.get_ambari_properties")4451 @patch("ambari_server.serverUpgrade.upgrade_local_repo")4452 @patch("ambari_server.serverUpgrade.move_user_custom_actions")4453 @patch("ambari_server.serverUpgrade.update_krb_jaas_login_properties")4454 def test_upgrade(self, update_krb_jaas_login_properties_mock, move_user_custom_actions, upgrade_local_repo_mock,4455 get_ambari_properties_mock, get_ambari_properties_2_mock, get_ambari_properties_3_mock,4456 is_root_mock, get_ambari_version_mock, get_ambari_version_2_mock,4457 parse_properties_file_mock,4458 update_ambari_properties_mock, run_schema_upgrade_mock,4459 read_ambari_user_mock, print_warning_msg_mock,4460 adjust_directory_permissions_mock,4461 find_properties_file_mock, properties_store_mock,4462 os_symlink_mock, os_remove_mock, lexists_mock, exists_mock, isfile_mock, open_mock):4463 def reset_mocks():4464 isfile_mock.reset_mock()4465 args = MagicMock()4466 del args.dbms4467 del args.database_index4468 del args.database_host4469 del args.database_port4470 del args.database_name4471 del args.database_username4472 del args.database_password4473 del args.default_database_host4474 del args.persistence_type4475 del args.init_db_script_file4476 del args.cleanup_db_script_file4477 del args.sid_or_sname4478 del args.jdbc_url4479 args.must_set_database_options = True4480 return args4481 args = reset_mocks()4482 properties = Properties()4483 get_ambari_properties_3_mock.return_value = get_ambari_properties_2_mock.return_value = \4484 get_ambari_properties_mock.return_value = properties4485 update_ambari_properties_mock.return_value = 04486 run_schema_upgrade_mock.return_value = 04487 isfile_mock.return_value = False4488 get_ambari_version_2_mock.return_value = get_ambari_version_mock.return_value = CURR_AMBARI_VERSION4489 move_user_custom_actions.return_value = None4490 update_krb_jaas_login_properties_mock.return_value = -24491 # Testing call under non-root4492 is_root_mock.return_value = False4493 try:4494 upgrade(args)4495 self.fail("Should throw exception")4496 except FatalException as fe:4497 # Expected4498 self.assertTrue("administrator-level" in fe.reason)4499 pass4500 args = reset_mocks()4501 # Testing calls under root4502 is_root_mock.return_value = True4503 # Testing with undefined custom user4504 read_ambari_user_mock.return_value = None4505 run_schema_upgrade_mock.return_value = 04506 exists_mock.return_value = True4507 upgrade(args)4508 self.assertTrue(print_warning_msg_mock.called)4509 warning_args = print_warning_msg_mock.call_args[0][0]4510 self.assertTrue("custom ambari user" in warning_args)4511 self.assertTrue(upgrade_local_repo_mock.called)4512 self.assertTrue(move_user_custom_actions.called)4513 args = reset_mocks()4514 # Testing with defined custom user4515 read_ambari_user_mock.return_value = "ambari-custom-user"4516 upgrade(args)4517 self.assertTrue(adjust_directory_permissions_mock.called)4518 args = reset_mocks()4519 run_schema_upgrade_mock.return_value = 04520 parse_properties_file_mock.called = False4521 move_user_custom_actions.called = False4522 retcode = upgrade(args)4523 self.assertTrue(get_ambari_properties_mock.called)4524 self.assertTrue(get_ambari_properties_2_mock.called)4525 self.assertNotEqual(-1, retcode)4526 self.assertTrue(parse_properties_file_mock.called)4527 self.assertTrue(run_schema_upgrade_mock.called)4528 self.assertTrue(move_user_custom_actions.called)4529 # Assert that move_user_custom_actions is called on upgrade to Ambari == 2.0.04530 get_ambari_version_2_mock.return_value = get_ambari_version_mock.return_value = '2.0.0'4531 move_user_custom_actions.called = False4532 upgrade(args)4533 self.assertTrue(move_user_custom_actions.called)4534 # Assert that move_user_custom_actions is not called on upgrade to Ambari < 2.0.04535 get_ambari_version_2_mock.return_value = get_ambari_version_mock.return_value = '1.6.0'4536 move_user_custom_actions.called = False4537 upgrade(args)4538 self.assertFalse(move_user_custom_actions.called)4539 get_ambari_version_2_mock.return_value = get_ambari_version_mock.return_value = CURR_AMBARI_VERSION4540 # test getAmbariProperties failed4541 args = reset_mocks()4542 get_ambari_properties_3_mock.return_value = get_ambari_properties_2_mock.return_value = \4543 get_ambari_properties_mock.return_value = -14544 fail = False4545 try:4546 upgrade(args)4547 except FatalException as e:4548 self.assertEquals("Error getting ambari properties", e.reason)4549 fail = True4550 self.assertTrue(fail)4551 # test get resource dir param failed4552 args = reset_mocks()4553 p = MagicMock()4554 get_ambari_properties_mock.reset_mock()4555 get_ambari_properties_2_mock.reset_mock()4556 get_ambari_properties_3_mock.reset_mock()4557 get_ambari_properties_3_mock.return_value = get_ambari_properties_2_mock.return_value = \4558 get_ambari_properties_mock.return_value = p4559 p.__getitem__.side_effect = ["something", "something", "something", "something", KeyError("test exception")]4560 exists_mock.return_value = False4561 fail = False4562 try:4563 upgrade(args)4564 except FatalException as e:4565 fail = True4566 self.assertTrue(fail)4567 # test if some drivers are available in resources, and symlink available too4568 args = reset_mocks()4569 props = Properties()4570 props.process_pair(JDBC_DATABASE_NAME_PROPERTY, "something")4571 props.process_pair(RESOURCES_DIR_PROPERTY, "resources")4572 get_ambari_properties_3_mock.return_value = get_ambari_properties_2_mock.return_value = \4573 get_ambari_properties_mock.return_value = props4574 exists_mock.return_value = True4575 lexists_mock.return_value = True4576 isfile_mock.side_effect = [True, False, False]4577 pass4578 def test_print_info_msg(self):4579 out = StringIO.StringIO()4580 sys.stdout = out4581 set_verbose(True)4582 print_info_msg("msg")4583 self.assertNotEqual("", out.getvalue())4584 sys.stdout = sys.__stdout__4585 pass4586 def test_print_error_msg(self):4587 out = StringIO.StringIO()4588 sys.stdout = out4589 set_verbose(True)4590 print_error_msg("msg")4591 self.assertNotEqual("", out.getvalue())4592 sys.stdout = sys.__stdout__4593 pass4594 def test_print_warning_msg(self):4595 out = StringIO.StringIO()4596 sys.stdout = out4597 set_verbose(True)4598 print_warning_msg("msg")4599 self.assertNotEqual("", out.getvalue())4600 sys.stdout = sys.__stdout__4601 pass4602 @patch("ambari_server.userInput.get_choice_string_input")4603 def test_get_YN_input(self, get_choice_string_input_mock):4604 get_YN_input("prompt", "default")4605 self.assertTrue(get_choice_string_input_mock.called)4606 self.assertEqual(4, len(get_choice_string_input_mock.call_args_list[0][0]))4607 pass4608 @not_for_platform(PLATFORM_WINDOWS)4609 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))4610 @patch.object(_ambari_server_, "setup")4611 def test_main_db_options(self, setup_mock):4612 base_args = ["ambari-server.py", "setup"]4613 db_args = ["--database", "postgres", "--databasehost", "somehost.net", "--databaseport", "12345",4614 "--databasename", "ambari", "--databaseusername", "ambari", "--databasepassword", "bigdata"]4615 #test no args4616 failed = False4617 sys.argv = list(base_args)4618 try:4619 _ambari_server_.mainBody()4620 except SystemExit:4621 failed = True4622 pass4623 self.assertFalse(failed)4624 self.assertTrue(setup_mock.called)4625 self.assertTrue(setup_mock.call_args_list[0][0][0].must_set_database_options)4626 setup_mock.reset_mock()4627 # test embedded option4628 failed = False4629 sys.argv = list(base_args)4630 sys.argv.extend(db_args[-10:])4631 sys.argv.extend(["--database", "embedded"])4632 try:4633 _ambari_server_.mainBody()4634 except SystemExit:4635 failed = True4636 pass4637 self.assertFalse(failed)4638 self.assertTrue(setup_mock.called)4639 setup_mock.reset_mock()4640 #test full args4641 sys.argv = list(base_args)4642 sys.argv.extend(db_args)4643 try:4644 _ambari_server_.mainBody()4645 except SystemExit:4646 failed = True4647 pass4648 self.assertFalse(failed)4649 self.assertTrue(setup_mock.called)4650 self.assertFalse(setup_mock.call_args_list[0][0][0].must_set_database_options)4651 setup_mock.reset_mock()4652 #test not full args4653 sys.argv = list(base_args)4654 sys.argv.extend(["--database", "postgres"])4655 try:4656 _ambari_server_.mainBody()4657 except SystemExit:4658 failed = True4659 pass4660 self.assertFalse(setup_mock.called)4661 self.assertTrue(failed)4662 setup_mock.reset_mock()4663 #test wrong database4664 failed = False4665 sys.argv = list(base_args)4666 sys.argv.extend(["--database", "unknown"])4667 sys.argv.extend(db_args[2:])4668 try:4669 _ambari_server_.mainBody()4670 except SystemExit:4671 failed = True4672 pass4673 self.assertTrue(failed)4674 self.assertFalse(setup_mock.called)4675 setup_mock.reset_mock()4676 #test wrong port check4677 failed = False4678 sys.argv = list(base_args)4679 sys.argv.extend(["--databaseport", "unknown"])4680 sys.argv.extend(db_args[:4])4681 sys.argv.extend(db_args[6:])4682 try:4683 _ambari_server_.mainBody()4684 except SystemExit:4685 failed = True4686 pass4687 self.assertTrue(failed)4688 self.assertFalse(setup_mock.called)4689 pass4690 @only_for_platform(PLATFORM_WINDOWS)4691 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))4692 @patch.object(_ambari_server_, "setup")4693 def test_main_db_options(self, setup_mock):4694 base_args = ["ambari-server.py", "setup"]4695 db_args = ["--databasehost", "somehost.net", "--databaseport", "12345",4696 "--databasename", "ambari", "--databaseusername", "ambari", "--databasepassword", "bigdata"]4697 #test no args4698 failed = False4699 sys.argv = list(base_args)4700 try:4701 _ambari_server_.mainBody()4702 except SystemExit:4703 failed = True4704 pass4705 self.assertFalse(failed)4706 self.assertTrue(setup_mock.called)4707 self.assertTrue(setup_mock.call_args_list[0][0][0].must_set_database_options)4708 setup_mock.reset_mock()4709 #test full args4710 sys.argv = list(base_args)4711 sys.argv.extend(db_args)4712 try:4713 _ambari_server_.mainBody()4714 except SystemExit:4715 failed = True4716 pass4717 self.assertFalse(failed)4718 self.assertTrue(setup_mock.called)4719 self.assertFalse(setup_mock.call_args_list[0][0][0].must_set_database_options)4720 setup_mock.reset_mock()4721 #test not full args4722 sys.argv = list(base_args)4723 sys.argv.extend(["--databasehost", "somehost.net"])4724 try:4725 _ambari_server_.mainBody()4726 except SystemExit:4727 failed = True4728 pass4729 self.assertFalse(setup_mock.called)4730 self.assertTrue(failed)4731 setup_mock.reset_mock()4732 #test wrong port check4733 failed = False4734 sys.argv = list(base_args)4735 sys.argv.extend(["--databaseport", "unknown"])4736 sys.argv.extend(db_args[:2])4737 sys.argv.extend(db_args[6:])4738 try:4739 _ambari_server_.mainBody()4740 except SystemExit:4741 failed = True4742 pass4743 self.assertTrue(failed)4744 self.assertFalse(setup_mock.called)4745 pass4746 @not_for_platform(PLATFORM_WINDOWS)4747 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))4748 @patch("ambari_server.serverSetup.get_YN_input")4749 @patch("ambari_server.dbConfiguration.get_validated_string_input")4750 @patch("ambari_server.dbConfiguration_linux.print_info_msg")4751 def test_prompt_db_properties(self, print_info_msg_mock,4752 get_validated_string_input_mock, get_YN_input_mock):4753 def reset_mocks():4754 get_validated_string_input_mock.reset_mock()4755 get_YN_input_mock.reset_mock()4756 args = MagicMock()4757 del args.database_index4758 del args.dbms4759 del args.database_host4760 del args.database_port4761 del args.database_name4762 del args.database_username4763 del args.database_password4764 del args.persistence_type4765 return args4766 args = reset_mocks()4767 set_silent(False)4768 #test not prompt4769 args.must_set_database_options = False4770 prompt_db_properties(args)4771 self.assertFalse(get_validated_string_input_mock.called)4772 self.assertFalse(get_YN_input_mock.called)4773 args = reset_mocks()4774 #test prompt4775 args.must_set_database_options = True4776 get_YN_input_mock.return_value = False4777 prompt_db_properties(args)4778 self.assertTrue(get_YN_input_mock.called)4779 self.assertFalse(get_validated_string_input_mock.called)4780 args = reset_mocks()4781 #test prompt advanced4782 args.must_set_database_options = True4783 get_YN_input_mock.return_value = True4784 get_validated_string_input_mock.return_value = "4"4785 prompt_db_properties(args)4786 self.assertTrue(get_YN_input_mock.called)4787 self.assertTrue(get_validated_string_input_mock.called)4788 self.assertEquals(args.database_index, 3)4789 pass4790 @patch("ambari_server.serverConfiguration.get_conf_dir")4791 def test_update_ambari_properties(self, get_conf_dir_mock):4792 from ambari_server import serverConfiguration # need to modify constants inside the module4793 properties = ["server.jdbc.user.name=ambari-server\n",4794 "server.jdbc.user.passwd=/etc/ambari-server/conf/password.dat\n",4795 "java.home=/usr/jdk64/jdk1.6.0_31\n",4796 "server.jdbc.database_name=ambari\n",4797 "ambari-server.user=ambari\n",4798 "agent.fqdn.service.url=URL\n"]4799 NEW_PROPERTY = 'some_new_property=some_value\n'4800 CHANGED_VALUE_PROPERTY = 'server.jdbc.database_name=should_not_overwrite_value\n'4801 get_conf_dir_mock.return_value = '/etc/ambari-server/conf'4802 (tf1, fn1) = tempfile.mkstemp()4803 (tf2, fn2) = tempfile.mkstemp()4804 configDefaults.AMBARI_PROPERTIES_BACKUP_FILE = fn14805 os.close(tf1)4806 serverConfiguration.AMBARI_PROPERTIES_FILE = fn24807 os.close(tf2)4808 with open(serverConfiguration.AMBARI_PROPERTIES_FILE, "w") as f:4809 f.write(NEW_PROPERTY)4810 f.write(CHANGED_VALUE_PROPERTY)4811 f.close()4812 with open(configDefaults.AMBARI_PROPERTIES_BACKUP_FILE, 'w') as f:4813 for line in properties:4814 f.write(line)4815 f.close()4816 #Call tested method4817 update_ambari_properties()4818 timestamp = datetime.datetime.now()4819 #RPMSAVE_FILE wasn't found4820 self.assertFalse(os.path.exists(configDefaults.AMBARI_PROPERTIES_BACKUP_FILE))4821 #Renamed RPMSAVE_FILE exists4822 self.assertTrue(os.path.exists(configDefaults.AMBARI_PROPERTIES_BACKUP_FILE4823 + '.' + timestamp.strftime('%Y%m%d%H%M%S')))4824 with open(serverConfiguration.AMBARI_PROPERTIES_FILE, 'r') as f:4825 ambari_properties_content = f.readlines()4826 for line in properties:4827 if (line == "agent.fqdn.service.url=URL\n"):4828 if (not GET_FQDN_SERVICE_URL + "=URL\n" in ambari_properties_content) and (4829 line in ambari_properties_content):4830 self.fail()4831 else:4832 if not line in ambari_properties_content:4833 self.fail()4834 if not NEW_PROPERTY in ambari_properties_content:4835 self.fail()4836 if CHANGED_VALUE_PROPERTY in ambari_properties_content:4837 self.fail()4838 # Command should not fail if *.rpmsave file is missing4839 result = update_ambari_properties()4840 self.assertEquals(result, 0)4841 os.unlink(fn2)4842 #if ambari.properties file is absent then "ambari-server upgrade" should4843 # fail4844 (tf, fn) = tempfile.mkstemp()4845 configDefaults.AMBARI_PROPERTIES_BACKUP_FILE = fn4846 result = update_ambari_properties()4847 self.assertNotEquals(result, 0)4848 pass4849 @patch("ambari_server.properties.Properties.__init__")4850 @patch("ambari_server.serverConfiguration.search_file")4851 def test_update_ambari_properties_negative_case(self, search_file_mock, properties_mock):4852 search_file_mock.return_value = None4853 #Call tested method4854 self.assertEquals(0, update_ambari_properties())4855 self.assertFalse(properties_mock.called)4856 search_file_mock.return_value = False4857 #Call tested method4858 self.assertEquals(0, update_ambari_properties())4859 self.assertFalse(properties_mock.called)4860 search_file_mock.return_value = ''4861 #Call tested method4862 self.assertEquals(0, update_ambari_properties())4863 self.assertFalse(properties_mock.called)4864 pass4865 @patch("ambari_server.serverConfiguration.get_conf_dir")4866 def test_update_ambari_properties_without_some_properties(self, get_conf_dir_mock):4867 '''4868 Checks: update_ambari_properties call should add ambari-server.user property if4869 it's absent4870 '''4871 from ambari_server import serverConfiguration # need to modify constants inside the module4872 properties = ["server.jdbc.user.name=ambari-server\n",4873 "server.jdbc.user.passwd=/etc/ambari-server/conf/password.dat\n",4874 "java.home=/usr/jdk64/jdk1.6.0_31\n",4875 "server.os_type=redhat6\n"]4876 get_conf_dir_mock.return_value = '/etc/ambari-server/conf'4877 (tf1, fn1) = tempfile.mkstemp()4878 os.close(tf1)4879 (tf2, fn2) = tempfile.mkstemp()4880 os.close(tf2)4881 serverConfiguration.AMBARI_PROPERTIES_RPMSAVE_FILE = fn14882 serverConfiguration.AMBARI_PROPERTIES_FILE = fn24883 with open(serverConfiguration.AMBARI_PROPERTIES_RPMSAVE_FILE, 'w') as f:4884 for line in properties:4885 f.write(line)4886 #Call tested method4887 update_ambari_properties()4888 ambari_properties = Properties()4889 ambari_properties.load(open(fn2))4890 self.assertTrue(NR_USER_PROPERTY in ambari_properties.keys())4891 value = ambari_properties[NR_USER_PROPERTY]4892 self.assertEqual(value, "root")4893 self.assertTrue(OS_FAMILY_PROPERTY in ambari_properties.keys())4894 os.unlink(fn2)4895 pass4896 @not_for_platform(PLATFORM_WINDOWS)4897 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))4898 @patch("ambari_commons.firewall.run_os_command")4899 @patch("ambari_server.serverSetup.verify_setup_allowed")4900 @patch("sys.exit")4901 @patch("ambari_server.serverSetup.get_YN_input")4902 @patch("ambari_server.dbConfiguration.get_validated_string_input")4903 @patch("ambari_server.dbConfiguration_linux.get_YN_input")4904 @patch("ambari_server.dbConfiguration_linux.get_validated_string_input")4905 @patch("ambari_server.dbConfiguration_linux.PGConfig._store_remote_properties")4906 @patch("ambari_server.dbConfiguration_linux.LinuxDBMSConfig.ensure_jdbc_driver_installed")4907 @patch("ambari_server.dbConfiguration_linux.read_password")4908 @patch("ambari_server.serverSetup.check_jdbc_drivers")4909 @patch("ambari_server.serverSetup.is_root")4910 @patch("ambari_server.serverSetup.check_ambari_user")4911 @patch("ambari_server.serverSetup.download_and_install_jdk")4912 @patch("ambari_server.serverSetup.configure_os_settings")4913 @patch('__builtin__.raw_input')4914 @patch("ambari_server.serverSetup.disable_security_enhancements")4915 @patch("ambari_server.serverSetup.expand_jce_zip_file")4916 def test_setup_remote_db_wo_client(self, expand_jce_zip_file_mock, check_selinux_mock, raw_input, configure_os_settings_mock,4917 download_jdk_mock, check_ambari_user_mock, is_root_mock, check_jdbc_drivers_mock,4918 read_password_mock, ensure_jdbc_driver_installed_mock, store_remote_properties_mock,4919 get_validated_string_input_0_mock, get_YN_input_0_mock,4920 get_validated_string_input_mock, get_YN_input,4921 exit_mock, verify_setup_allowed_method,4922 run_os_command_mock):4923 args = MagicMock()4924 args.jdbc_driver = None4925 args.jdbc_db = None4926 args.silent = False4927 del args.dbms4928 del args.database_index4929 del args.database_host4930 del args.database_port4931 del args.database_name4932 del args.database_username4933 del args.database_password4934 del args.persistence_type4935 raw_input.return_value = ""4936 is_root_mock.return_value = True4937 check_selinux_mock.return_value = (0, "")4938 run_os_command_mock.return_value = 3,"",""4939 store_remote_properties_mock.return_value = 04940 get_YN_input.return_value = True4941 get_validated_string_input_mock.side_effect = ["4"]4942 get_validated_string_input_0_mock.side_effect = ["localhost", "5432", "ambari", "ambari", "admin"]4943 get_YN_input_0_mock.return_value = False4944 read_password_mock.return_value = "encrypted_bigdata"4945 ensure_jdbc_driver_installed_mock.return_value = True4946 check_jdbc_drivers_mock.return_value = 04947 check_ambari_user_mock.return_value = (0, False, 'user', None)4948 download_jdk_mock.return_value = 04949 configure_os_settings_mock.return_value = 04950 verify_setup_allowed_method.return_value = 04951 expand_jce_zip_file_mock.return_value = 04952 try:4953 setup(args)4954 self.fail("Should throw exception")4955 except NonFatalException as fe:4956 # Expected4957 self.assertTrue("Remote database setup aborted." in fe.reason)4958 pass4959 @not_for_platform(PLATFORM_WINDOWS)4960 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))4961 @patch("ambari_commons.firewall.run_os_command")4962 @patch("sys.exit")4963 @patch("ambari_server.userInput.get_YN_input")4964 @patch("ambari_commons.os_utils.is_root")4965 @patch("ambari_server.dbConfiguration_linux.store_password_file")4966 @patch("__builtin__.raw_input")4967 def test_store_remote_properties(self, raw_input_mock, store_password_file_mock,4968 is_root_mock, get_YN_input, exit_mock,4969 run_os_command_mock4970 ):4971 raw_input_mock.return_value = ""4972 is_root_mock.return_value = True4973 get_YN_input.return_value = False4974 run_os_command_mock.return_value = 3,"",""4975 store_password_file_mock.return_value = "encrypted_bigdata"4976 import optparse4977 args = optparse.Values()4978 args.dbms = "oracle"4979 args.database_host = "localhost"4980 args.database_port = "1234"4981 args.database_name = "ambari"4982 args.postgres_schema = "ambari"4983 args.sid_or_sname = "foo"4984 args.database_username = "foo"4985 args.database_password = "foo"4986 properties0 = Properties()4987 properties = Properties()4988 factory = DBMSConfigFactory()4989 dbConfig = factory.create(args, properties0)4990 dbConfig._store_remote_properties(properties)4991 found = False4992 for n in properties.propertyNames():4993 if not found and n.startswith("server.jdbc.properties"):4994 found = True4995 self.assertTrue(found)4996 # verify that some properties exist4997 self.assertEquals("internal", properties.get_property(JDBC_CONNECTION_POOL_TYPE))4998 # now try with MySQL instead of Oracle to verify that the properties are different4999 args.dbms = "mysql"5000 args.database_index = 25001 properties0 = Properties()5002 properties = Properties()5003 factory = DBMSConfigFactory()5004 dbConfig = factory.create(args, properties0)5005 dbConfig._store_remote_properties(properties)5006 # verify MySQL properties5007 self.assertEquals("c3p0", properties.get_property(JDBC_CONNECTION_POOL_TYPE))5008 @not_for_platform(PLATFORM_WINDOWS)5009 @patch("ambari_server.serverConfiguration.find_properties_file")5010 def test_get_ambari_properties(self, find_properties_file_mock):5011 find_properties_file_mock.return_value = None5012 rcode = get_ambari_properties()5013 self.assertEqual(rcode, -1)5014 tf1 = tempfile.NamedTemporaryFile()5015 find_properties_file_mock.return_value = tf1.name5016 prop_name = 'name'5017 prop_value = 'val'5018 with open(tf1.name, 'w') as fout:5019 fout.write(prop_name + '=' + prop_value)5020 fout.close()5021 properties = get_ambari_properties()5022 self.assertEqual(properties[prop_name], prop_value)5023 pass5024 @only_for_platform(PLATFORM_WINDOWS)5025 @patch("ambari_server.serverConfiguration.find_properties_file")5026 def test_get_ambari_properties(self, find_properties_file):5027 find_properties_file.return_value = None5028 rcode = get_ambari_properties()5029 self.assertEqual(rcode, -1)5030 tf1 = tempfile.NamedTemporaryFile(delete=False)5031 find_properties_file.return_value = tf1.name5032 tf1.close()5033 prop_name = 'name'5034 prop_value = 'val'5035 with open(tf1.name, 'w') as fout:5036 fout.write(prop_name + '=' + prop_value)5037 properties = get_ambari_properties()5038 self.assertEqual(properties[prop_name], prop_value)5039 self.assertEqual(properties.fileName, os.path.abspath(tf1.name))5040 sys.stdout = sys.__stdout__5041 pass5042 @patch("os.path.exists")5043 @patch("os.remove")5044 @patch("ambari_commons.os_utils.print_warning_msg")5045 def test_remove_file(self, printWarningMsgMock, removeMock, pathExistsMock):5046 def side_effect():5047 raise Exception(-1, "Failed to delete!")5048 removeMock.side_effect = side_effect5049 pathExistsMock.return_value = 15050 res = remove_file("/someNonExsistantDir/filename")5051 self.assertEquals(res, 1)5052 removeMock.side_effect = None5053 res = remove_file("/someExsistantDir/filename")5054 self.assertEquals(res, 0)5055 @patch("shutil.copyfile")5056 def test_copy_file(self, shutilCopyfileMock):5057 def side_effect():5058 raise Exception(-1, "Failed to copy!")5059 shutilCopyfileMock.side_effect = side_effect5060 try:5061 copy_file("/tmp/psswd", "/someNonExsistantDir/filename")5062 self.fail("Exception on file not copied has not been thrown!")5063 except FatalException:5064 # Expected5065 pass5066 self.assertTrue(shutilCopyfileMock.called)5067 shutilCopyfileMock.side_effect = None5068 try:5069 copy_file("/tmp/psswd", "/root/psswd")5070 except FatalException:5071 self.fail("Exception on file copied should not be thrown!")5072 self.assertTrue(shutilCopyfileMock.called)5073 pass5074 @not_for_platform(PLATFORM_WINDOWS)5075 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))5076 @patch("ambari_server.dbConfiguration_linux.get_ambari_properties")5077 @patch("ambari_server.dbConfiguration_linux.print_error_msg")5078 @patch("ambari_server.dbConfiguration.print_error_msg")5079 @patch("ambari_server.dbConfiguration_linux.print_warning_msg")5080 @patch("__builtin__.raw_input")5081 @patch("glob.glob")5082 @patch("os.path.isdir")5083 @patch("os.path.lexists")5084 @patch("os.remove")5085 @patch("os.symlink")5086 @patch("shutil.copy")5087 def test_ensure_jdbc_drivers_installed(self, shutil_copy_mock, os_symlink_mock, os_remove_mock, lexists_mock, isdir_mock, glob_mock,5088 raw_input_mock, print_warning_msg, print_error_msg_mock, print_error_msg_2_mock,5089 get_ambari_properties_mock):5090 out = StringIO.StringIO()5091 sys.stdout = out5092 def reset_mocks():5093 get_ambari_properties_mock.reset_mock()5094 shutil_copy_mock.reset_mock()5095 print_error_msg_mock.reset_mock()5096 print_warning_msg.reset_mock()5097 raw_input_mock.reset_mock()5098 args = MagicMock()5099 del args.database_index5100 del args.persistence_type5101 del args.silent5102 del args.sid_or_sname5103 del args.jdbc_url5104 args.dbms = "oracle"5105 return args5106 # Check positive scenario5107 drivers_list = [os.path.join(os.sep,'usr','share','java','ojdbc6.jar')]5108 resources_dir = os.sep + 'tmp'5109 props = Properties()5110 props.process_pair(RESOURCES_DIR_PROPERTY, resources_dir)5111 get_ambari_properties_mock.return_value = props5112 factory = DBMSConfigFactory()5113 args = reset_mocks()5114 glob_mock.return_value = drivers_list5115 isdir_mock.return_value = True5116 lexists_mock.return_value = True5117 dbms = factory.create(args, props)5118 rcode = dbms.ensure_jdbc_driver_installed(props)5119 self.assertEquals(os_symlink_mock.call_count, 1)5120 self.assertEquals(os_symlink_mock.call_args_list[0][0][0], os.path.join(os.sep,'tmp','ojdbc6.jar'))5121 self.assertEquals(os_symlink_mock.call_args_list[0][0][1], os.path.join(os.sep,'tmp','oracle-jdbc-driver.jar'))5122 self.assertTrue(rcode)5123 self.assertEquals(shutil_copy_mock.call_count, 1)5124 self.assertEquals(shutil_copy_mock.call_args_list[0][0][0], drivers_list[0])5125 self.assertEquals(shutil_copy_mock.call_args_list[0][0][1], resources_dir)5126 # Check negative scenarios5127 # Silent option, no drivers5128 set_silent(True)5129 args = reset_mocks()5130 glob_mock.return_value = []5131 failed = False5132 try:5133 dbms = factory.create(args, props)5134 rcode = dbms.ensure_jdbc_driver_installed(props)5135 except FatalException:5136 failed = True5137 self.assertTrue(print_error_msg_mock.called)5138 self.assertTrue(failed)5139 # Non-Silent option, no drivers5140 set_silent(False)5141 args = reset_mocks()5142 glob_mock.return_value = []5143 failed = False5144 try:5145 dbms = factory.create(args, props)5146 rcode = dbms.ensure_jdbc_driver_installed(props)5147 except FatalException:5148 failed = True5149 self.assertTrue(failed)5150 self.assertTrue(print_error_msg_mock.called)5151 # Non-Silent option, no drivers at first ask, present drivers after that5152 args = reset_mocks()5153 glob_mock.side_effect = [[], drivers_list]5154 dbms = factory.create(args, props)5155 rcode = dbms.ensure_jdbc_driver_installed(props)5156 self.assertTrue(rcode)5157 self.assertEquals(shutil_copy_mock.call_count, 1)5158 self.assertEquals(shutil_copy_mock.call_args_list[0][0][0], drivers_list[0])5159 self.assertEquals(shutil_copy_mock.call_args_list[0][0][1], resources_dir)5160 # Non-Silent option, no drivers at first ask, no drivers after that5161 args = reset_mocks()5162 glob_mock.side_effect = [[], []]5163 failed = False5164 try:5165 dbms = factory.create(args, props)5166 rcode = dbms.ensure_jdbc_driver_installed(props)5167 except FatalException:5168 failed = True5169 self.assertTrue(failed)5170 self.assertTrue(print_error_msg_mock.called)5171 # Failed to copy_files5172 args = reset_mocks()5173 glob_mock.side_effect = [drivers_list]5174 try:5175 dbms = factory.create(args, props)5176 rcode = dbms.ensure_jdbc_driver_installed(props)5177 except FatalException:5178 failed = True5179 self.assertTrue(failed)5180 sys.stdout = sys.__stdout__5181 pass5182 @not_for_platform(PLATFORM_WINDOWS)5183 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))5184 @patch("ambari_server.dbConfiguration.get_ambari_properties")5185 @patch("os.path.isdir")5186 @patch("os.path.isfile")5187 @patch("os.path.lexists")5188 @patch("os.remove")5189 @patch("os.symlink")5190 def test_check_jdbc_drivers(self, os_symlink_mock, os_remove_mock, lexists_mock, isfile_mock, isdir_mock,5191 get_ambari_properties_mock):5192 args = MagicMock()5193 # Check positive scenario5194 drivers_list = [os.path.join(os.sep,'usr','share','java','ojdbc6.jar')]5195 resources_dir = os.sep + 'tmp'5196 props = Properties()5197 props.process_pair(RESOURCES_DIR_PROPERTY, resources_dir)5198 get_ambari_properties_mock.return_value = props5199 isdir_mock.return_value = True5200 isfile_mock.side_effect = [True, False, False]5201 del args.database_index5202 del args.persistence_type5203 del args.silent5204 del args.sid_or_sname5205 del args.jdbc_url5206 lexists_mock.return_value = True5207 check_jdbc_drivers(args)5208 self.assertEquals(os_symlink_mock.call_count, 1)5209 self.assertEquals(os_symlink_mock.call_args_list[0][0][0], os.path.join(os.sep,'tmp','ojdbc6.jar'))5210 self.assertEquals(os_symlink_mock.call_args_list[0][0][1], os.path.join(os.sep,'tmp','oracle-jdbc-driver.jar'))5211 # Check negative scenarios5212 # No drivers deployed5213 get_ambari_properties_mock.reset_mock()5214 os_symlink_mock.reset_mock()5215 isfile_mock.side_effect = [False, False, False]5216 check_jdbc_drivers(args)5217 self.assertFalse(os_symlink_mock.called)5218 pass5219 @not_for_platform(PLATFORM_WINDOWS)5220 @patch("ambari_server.serverConfiguration.find_properties_file")5221 def test_get_ambari_properties(self, find_properties_file_mock):5222 find_properties_file_mock.return_value = None5223 rcode = get_ambari_properties()5224 self.assertEqual(rcode, -1)5225 tf1 = tempfile.NamedTemporaryFile()5226 find_properties_file_mock.return_value = tf1.name5227 prop_name = 'name'5228 prop_value = 'val'5229 with open(tf1.name, 'w') as fout:5230 fout.write(prop_name + '=' + prop_value)5231 fout.close()5232 properties = get_ambari_properties()5233 self.assertEqual(properties[prop_name], prop_value)5234 self.assertEqual(properties.fileName, os.path.abspath(tf1.name))5235 sys.stdout = sys.__stdout__5236 pass5237 @only_for_platform(PLATFORM_WINDOWS)5238 @patch("ambari_server.serverConfiguration.find_properties_file")5239 def test_get_ambari_properties(self, find_properties_file_mock):5240 find_properties_file_mock.return_value = None5241 rcode = get_ambari_properties()5242 self.assertEqual(rcode, -1)5243 tf1 = tempfile.NamedTemporaryFile(delete=False)5244 find_properties_file_mock.return_value = tf1.name5245 prop_name = 'name'5246 prop_value = 'val'5247 tf1.close()5248 with open(tf1.name, 'w') as fout:5249 fout.write(prop_name + '=' + prop_value)5250 fout.close()5251 properties = get_ambari_properties()5252 self.assertEqual(properties[prop_name], prop_value)5253 self.assertEqual(properties.fileName, os.path.abspath(tf1.name))5254 sys.stdout = sys.__stdout__5255 pass5256 @not_for_platform(PLATFORM_WINDOWS)5257 @patch("ambari_server.serverConfiguration.check_database_name_property")5258 @patch("ambari_server.serverConfiguration.find_properties_file")5259 def test_parse_properties_file(self, find_properties_file_mock, check_database_name_property_mock):5260 check_database_name_property_mock.return_value = 15261 tf1 = tempfile.NamedTemporaryFile(mode='r')5262 find_properties_file_mock.return_value = tf1.name5263 args = MagicMock()5264 parse_properties_file(args)5265 self.assertEquals(args.persistence_type, "local")5266 with open(tf1.name, 'w') as fout:5267 fout.write("\n")5268 fout.write(PERSISTENCE_TYPE_PROPERTY + "=remote")5269 args = MagicMock()5270 parse_properties_file(args)5271 self.assertEquals(args.persistence_type, "remote")5272 pass5273 @not_for_platform(PLATFORM_WINDOWS)5274 @patch("os.path.isabs")5275 @patch("ambari_server.dbConfiguration.decrypt_password_for_alias")5276 @patch("ambari_server.dbConfiguration_linux.get_ambari_properties")5277 def test_configure_database_username_password_masterkey_persisted(self,5278 get_ambari_properties_method,5279 decrypt_password_for_alias_method,5280 path_isabs_method):5281 out = StringIO.StringIO()5282 sys.stdout = out5283 properties = Properties()5284 properties.process_pair(JDBC_USER_NAME_PROPERTY, "fakeuser")5285 properties.process_pair(JDBC_PASSWORD_PROPERTY, "${alias=somealias}")5286 properties.process_pair(JDBC_DATABASE_NAME_PROPERTY, "fakedbname")5287 properties.process_pair(SECURITY_KEY_IS_PERSISTED, "True")5288 get_ambari_properties_method.return_value = properties5289 decrypt_password_for_alias_method.return_value = "falepasswd"5290 args = MagicMock()5291 args.master_key = None5292 del args.database_index5293 del args.dbms5294 del args.database_host5295 del args.database_port5296 del args.database_name5297 del args.database_username5298 del args.database_password5299 del args.sid_or_sname5300 del args.jdbc_url5301 dbms = OracleConfig(args, properties, "local")5302 self.assertTrue(decrypt_password_for_alias_method.called)5303 self.assertFalse(path_isabs_method.called)5304 self.assertEquals("fakeuser", dbms.database_username)5305 self.assertEquals("falepasswd", dbms.database_password)5306 sys.stdout = sys.__stdout__5307 pass5308 @not_for_platform(PLATFORM_WINDOWS)5309 @patch("ambari_server.dbConfiguration_linux.read_password")5310 def test_configure_database_password(self, read_password_method):5311 out = StringIO.StringIO()5312 sys.stdout = out5313 read_password_method.return_value = "fakepasswd"5314 result = LinuxDBMSConfig._configure_database_password(True)5315 self.assertTrue(read_password_method.called)5316 self.assertEquals("fakepasswd", result)5317 result = LinuxDBMSConfig._configure_database_password(True)5318 self.assertEquals("fakepasswd", result)5319 result = LinuxDBMSConfig._configure_database_password(True)5320 self.assertEquals("fakepasswd", result)5321 sys.stdout = sys.__stdout__5322 pass5323 @patch("os.path.exists")5324 @patch("ambari_server.setupSecurity.get_is_secure")5325 @patch("ambari_server.setupSecurity.get_is_persisted")5326 @patch("ambari_server.setupSecurity.remove_password_file")5327 @patch("ambari_server.setupSecurity.save_passwd_for_alias")5328 @patch("ambari_server.setupSecurity.read_master_key")5329 @patch("ambari_server.setupSecurity.read_ambari_user")5330 @patch("ambari_server.setupSecurity.get_master_key_location")5331 @patch("ambari_server.setupSecurity.update_properties_2")5332 @patch("ambari_server.setupSecurity.save_master_key")5333 @patch("ambari_server.setupSecurity.get_YN_input")5334 @patch("ambari_server.setupSecurity.search_file")5335 @patch("ambari_server.setupSecurity.get_ambari_properties")5336 @patch("ambari_server.setupSecurity.is_root")5337 def test_setup_master_key_not_persist(self, is_root_method,5338 get_ambari_properties_method, search_file_message,5339 get_YN_input_method, save_master_key_method,5340 update_properties_method, get_master_key_location_method,5341 read_ambari_user_method, read_master_key_method,5342 save_passwd_for_alias_method, remove_password_file_method,5343 get_is_persisted_method, get_is_secure_method, exists_mock):5344 is_root_method.return_value = True5345 p = Properties()5346 FAKE_PWD_STRING = "fakepasswd"5347 p.process_pair(JDBC_PASSWORD_PROPERTY, FAKE_PWD_STRING)5348 p.process_pair(LDAP_MGR_PASSWORD_PROPERTY, FAKE_PWD_STRING)5349 p.process_pair(SSL_TRUSTSTORE_PASSWORD_PROPERTY, FAKE_PWD_STRING)5350 p.process_pair(JDBC_RCA_PASSWORD_FILE_PROPERTY, FAKE_PWD_STRING)5351 get_ambari_properties_method.return_value = p5352 read_master_key_method.return_value = "aaa"5353 get_YN_input_method.return_value = False5354 read_ambari_user_method.return_value = None5355 save_passwd_for_alias_method.return_value = 05356 get_is_persisted_method.return_value = (True, "filepath")5357 get_is_secure_method.return_value = False5358 exists_mock.return_value = False5359 setup_master_key()5360 self.assertTrue(get_YN_input_method.called)5361 self.assertTrue(read_master_key_method.called)5362 self.assertTrue(read_ambari_user_method.called)5363 self.assertTrue(update_properties_method.called)5364 self.assertFalse(save_master_key_method.called)5365 self.assertTrue(save_passwd_for_alias_method.called)5366 self.assertEquals(3, save_passwd_for_alias_method.call_count)5367 self.assertTrue(remove_password_file_method.called)5368 result_expected = {JDBC_PASSWORD_PROPERTY:5369 get_alias_string(JDBC_RCA_PASSWORD_ALIAS),5370 JDBC_RCA_PASSWORD_FILE_PROPERTY:5371 get_alias_string(JDBC_RCA_PASSWORD_ALIAS),5372 LDAP_MGR_PASSWORD_PROPERTY:5373 get_alias_string(LDAP_MGR_PASSWORD_ALIAS),5374 SSL_TRUSTSTORE_PASSWORD_PROPERTY:5375 get_alias_string(SSL_TRUSTSTORE_PASSWORD_ALIAS),5376 SECURITY_IS_ENCRYPTION_ENABLED: 'true'}5377 sorted_x = sorted(result_expected.iteritems(), key=operator.itemgetter(0))5378 sorted_y = sorted(update_properties_method.call_args[0][1].iteritems(),5379 key=operator.itemgetter(0))5380 self.assertEquals(sorted_x, sorted_y)5381 pass5382 @patch("ambari_server.setupSecurity.save_passwd_for_alias")5383 @patch("os.path.exists")5384 @patch("ambari_server.setupSecurity.get_is_secure")5385 @patch("ambari_server.setupSecurity.get_is_persisted")5386 @patch("ambari_server.setupSecurity.read_master_key")5387 @patch("ambari_server.setupSecurity.read_ambari_user")5388 @patch("ambari_server.setupSecurity.get_master_key_location")5389 @patch("ambari_server.setupSecurity.update_properties_2")5390 @patch("ambari_server.setupSecurity.save_master_key")5391 @patch("ambari_server.setupSecurity.get_YN_input")5392 @patch("ambari_server.serverConfiguration.search_file")5393 @patch("ambari_server.setupSecurity.get_ambari_properties")5394 @patch("ambari_server.setupSecurity.is_root")5395 def test_setup_master_key_persist(self, is_root_method,5396 get_ambari_properties_method, search_file_message,5397 get_YN_input_method, save_master_key_method,5398 update_properties_method, get_master_key_location_method,5399 read_ambari_user_method, read_master_key_method,5400 get_is_persisted_method, get_is_secure_method, exists_mock,5401 save_passwd_for_alias_method):5402 is_root_method.return_value = True5403 p = Properties()5404 FAKE_PWD_STRING = "fakepasswd"5405 p.process_pair(JDBC_PASSWORD_PROPERTY, FAKE_PWD_STRING)5406 get_ambari_properties_method.return_value = p5407 search_file_message.return_value = "propertiesfile"5408 read_master_key_method.return_value = "aaa"5409 get_YN_input_method.side_effect = [True, False]5410 read_ambari_user_method.return_value = None5411 get_is_persisted_method.return_value = (True, "filepath")5412 get_is_secure_method.return_value = False5413 exists_mock.return_value = False5414 save_passwd_for_alias_method.return_value = 05415 setup_master_key()5416 self.assertTrue(get_YN_input_method.called)5417 self.assertTrue(read_master_key_method.called)5418 self.assertTrue(read_ambari_user_method.called)5419 self.assertTrue(update_properties_method.called)5420 self.assertTrue(save_master_key_method.called)5421 result_expected = {JDBC_PASSWORD_PROPERTY:5422 get_alias_string(JDBC_RCA_PASSWORD_ALIAS),5423 SECURITY_IS_ENCRYPTION_ENABLED: 'true'}5424 sorted_x = sorted(result_expected.iteritems(), key=operator.itemgetter(0))5425 sorted_y = sorted(update_properties_method.call_args[0][1].iteritems(),5426 key=operator.itemgetter(0))5427 self.assertEquals(sorted_x, sorted_y)5428 pass5429 @patch("ambari_server.setupSecurity.read_master_key")5430 @patch("ambari_server.setupSecurity.remove_password_file")5431 @patch("os.path.exists")5432 @patch("ambari_server.setupSecurity.read_ambari_user")5433 @patch("ambari_server.setupSecurity.get_master_key_location")5434 @patch("ambari_server.setupSecurity.save_passwd_for_alias")5435 @patch("ambari_server.setupSecurity.read_passwd_for_alias")5436 @patch("ambari_server.setupSecurity.update_properties_2")5437 @patch("ambari_server.setupSecurity.save_master_key")5438 @patch("ambari_server.setupSecurity.get_validated_string_input")5439 @patch("ambari_server.setupSecurity.get_YN_input")5440 @patch("ambari_server.setupSecurity.search_file")5441 @patch("ambari_server.setupSecurity.get_ambari_properties")5442 @patch("ambari_server.setupSecurity.is_root")5443 def test_reset_master_key_persisted(self, is_root_method,5444 get_ambari_properties_method, search_file_message,5445 get_YN_input_method, get_validated_string_input_method,5446 save_master_key_method, update_properties_method,5447 read_passwd_for_alias_method, save_passwd_for_alias_method,5448 get_master_key_location_method,5449 read_ambari_user_method, exists_mock,5450 remove_password_file_method, read_master_key_method):5451 # Testing call under non-root5452 is_root_method.return_value = False5453 try:5454 setup_master_key()5455 self.fail("Should throw exception")5456 except FatalException as fe:5457 # Expected5458 self.assertTrue("root-level" in fe.reason)5459 pass5460 # Testing call under root5461 is_root_method.return_value = True5462 search_file_message.return_value = "filepath"5463 read_ambari_user_method.return_value = None5464 p = Properties()5465 FAKE_PWD_STRING = '${alias=fakealias}'5466 p.process_pair(JDBC_PASSWORD_PROPERTY, FAKE_PWD_STRING)5467 p.process_pair(LDAP_MGR_PASSWORD_PROPERTY, FAKE_PWD_STRING)5468 p.process_pair(SSL_TRUSTSTORE_PASSWORD_PROPERTY, FAKE_PWD_STRING)5469 p.process_pair(JDBC_RCA_PASSWORD_FILE_PROPERTY, FAKE_PWD_STRING)5470 get_ambari_properties_method.return_value = p5471 get_YN_input_method.side_effect = [True, True]5472 read_master_key_method.return_value = "aaa"5473 read_passwd_for_alias_method.return_value = "fakepassword"5474 save_passwd_for_alias_method.return_value = 05475 exists_mock.return_value = False5476 setup_master_key()5477 self.assertTrue(save_master_key_method.called)5478 self.assertTrue(get_YN_input_method.called)5479 self.assertTrue(read_master_key_method.called)5480 self.assertTrue(update_properties_method.called)5481 self.assertTrue(read_passwd_for_alias_method.called)5482 self.assertTrue(3, read_passwd_for_alias_method.call_count)5483 self.assertTrue(3, save_passwd_for_alias_method.call_count)5484 result_expected = {JDBC_PASSWORD_PROPERTY:5485 get_alias_string(JDBC_RCA_PASSWORD_ALIAS),5486 JDBC_RCA_PASSWORD_FILE_PROPERTY:5487 get_alias_string(JDBC_RCA_PASSWORD_ALIAS),5488 LDAP_MGR_PASSWORD_PROPERTY:5489 get_alias_string(LDAP_MGR_PASSWORD_ALIAS),5490 SSL_TRUSTSTORE_PASSWORD_PROPERTY:5491 get_alias_string(SSL_TRUSTSTORE_PASSWORD_ALIAS),5492 SECURITY_IS_ENCRYPTION_ENABLED: 'true'}5493 sorted_x = sorted(result_expected.iteritems(), key=operator.itemgetter(0))5494 sorted_y = sorted(update_properties_method.call_args[0][1].iteritems(),5495 key=operator.itemgetter(0))5496 self.assertEquals(sorted_x, sorted_y)5497 pass5498 @patch("ambari_server.setupSecurity.get_is_persisted")5499 @patch("ambari_server.setupSecurity.get_is_secure")5500 @patch("ambari_server.setupSecurity.remove_password_file")5501 @patch("os.path.exists")5502 @patch("ambari_server.setupSecurity.read_ambari_user")5503 @patch("ambari_server.setupSecurity.get_master_key_location")5504 @patch("ambari_server.setupSecurity.save_passwd_for_alias")5505 @patch("ambari_server.setupSecurity.read_passwd_for_alias")5506 @patch("ambari_server.setupSecurity.update_properties_2")5507 @patch("ambari_server.setupSecurity.save_master_key")5508 @patch("ambari_server.setupSecurity.get_validated_string_input")5509 @patch("ambari_server.setupSecurity.get_YN_input")5510 @patch("ambari_server.setupSecurity.search_file")5511 @patch("ambari_server.setupSecurity.get_ambari_properties")5512 @patch("ambari_server.setupSecurity.is_root")5513 def test_reset_master_key_not_persisted(self, is_root_method,5514 get_ambari_properties_method,5515 search_file_message, get_YN_input_method,5516 get_validated_string_input_method, save_master_key_method,5517 update_properties_method, read_passwd_for_alias_method,5518 save_passwd_for_alias_method,5519 get_master_key_location_method, read_ambari_user_method,5520 exists_mock, remove_password_file_method, get_is_secure_method,5521 get_is_persisted_method):5522 is_root_method.return_value = True5523 search_file_message.return_value = False5524 read_ambari_user_method.return_value = None5525 p = Properties()5526 FAKE_PWD_STRING = '${alias=fakealias}'5527 p.process_pair(JDBC_PASSWORD_PROPERTY, FAKE_PWD_STRING)5528 p.process_pair(LDAP_MGR_PASSWORD_PROPERTY, FAKE_PWD_STRING)5529 p.process_pair(SSL_TRUSTSTORE_PASSWORD_PROPERTY, FAKE_PWD_STRING)5530 p.process_pair(JDBC_RCA_PASSWORD_FILE_PROPERTY, FAKE_PWD_STRING)5531 get_ambari_properties_method.return_value = p5532 get_YN_input_method.side_effect = [True, False]5533 get_validated_string_input_method.return_value = "aaa"5534 read_passwd_for_alias_method.return_value = "fakepassword"5535 save_passwd_for_alias_method.return_value = 05536 exists_mock.return_value = False5537 get_is_secure_method.return_value = True5538 get_is_persisted_method.return_value = (True, "filePath")5539 setup_master_key()5540 self.assertFalse(save_master_key_method.called)5541 self.assertTrue(get_YN_input_method.called)5542 self.assertTrue(get_validated_string_input_method.called)5543 self.assertTrue(update_properties_method.called)5544 self.assertTrue(read_passwd_for_alias_method.called)5545 self.assertTrue(3, read_passwd_for_alias_method.call_count)5546 self.assertTrue(3, save_passwd_for_alias_method.call_count)5547 self.assertFalse(save_master_key_method.called)5548 result_expected = {JDBC_PASSWORD_PROPERTY:5549 get_alias_string(JDBC_RCA_PASSWORD_ALIAS),5550 JDBC_RCA_PASSWORD_FILE_PROPERTY:5551 get_alias_string(JDBC_RCA_PASSWORD_ALIAS),5552 LDAP_MGR_PASSWORD_PROPERTY:5553 get_alias_string(LDAP_MGR_PASSWORD_ALIAS),5554 SSL_TRUSTSTORE_PASSWORD_PROPERTY:5555 get_alias_string(SSL_TRUSTSTORE_PASSWORD_ALIAS),5556 SECURITY_IS_ENCRYPTION_ENABLED: 'true'}5557 sorted_x = sorted(result_expected.iteritems(), key=operator.itemgetter(0))5558 sorted_y = sorted(update_properties_method.call_args[0][1].iteritems(),5559 key=operator.itemgetter(0))5560 self.assertEquals(sorted_x, sorted_y)5561 pass5562 @staticmethod5563 @OsFamilyFuncImpl(OSConst.WINSRV_FAMILY)5564 def _init_test_ldap_properties_map_invalid_input_1():5565 ldap_properties_map = \5566 {5567 LDAP_PRIMARY_URL_PROPERTY: "a:3",5568 "authentication.ldap.secondaryUrl": "b:2",5569 "authentication.ldap.useSSL": "false",5570 "authentication.ldap.usernameAttribute": "user",5571 "authentication.ldap.baseDn": "uid",5572 "authentication.ldap.bindAnonymously": "true",5573 "authentication.ldap.referral": "follow",5574 "client.security": "ldap",5575 "ambari.ldap.isConfigured": "true"5576 }5577 return ldap_properties_map5578 @staticmethod5579 @OsFamilyFuncImpl(OsFamilyImpl.DEFAULT)5580 def _init_test_ldap_properties_map_invalid_input_1():5581 ldap_properties_map = \5582 {5583 LDAP_PRIMARY_URL_PROPERTY: "a:3",5584 "authentication.ldap.secondaryUrl": "b:2",5585 "authentication.ldap.useSSL": "false",5586 "authentication.ldap.userObjectClass": "user",5587 "authentication.ldap.usernameAttribute": "uid",5588 "authentication.ldap.groupObjectClass": "group",5589 "authentication.ldap.groupNamingAttr": "cn",5590 "authentication.ldap.groupMembershipAttr": "member",5591 "authentication.ldap.dnAttribute": "dn",5592 "authentication.ldap.baseDn": "base",5593 "authentication.ldap.referral": "follow",5594 "authentication.ldap.bindAnonymously": "true",5595 "client.security": "ldap",5596 "ambari.ldap.isConfigured": "true"5597 }5598 return ldap_properties_map5599 @staticmethod5600 @OsFamilyFuncImpl(OSConst.WINSRV_FAMILY)5601 def _init_test_ldap_properties_map_invalid_input_2():5602 ldap_properties_map = \5603 {5604 LDAP_PRIMARY_URL_PROPERTY: "a:3",5605 "authentication.ldap.useSSL": "false",5606 "authentication.ldap.usernameAttribute": "user",5607 "authentication.ldap.baseDn": "uid",5608 "authentication.ldap.bindAnonymously": "true",5609 "authentication.ldap.referral": "follow",5610 "client.security": "ldap",5611 "ambari.ldap.isConfigured": "true"5612 }5613 return ldap_properties_map5614 @staticmethod5615 @OsFamilyFuncImpl(OsFamilyImpl.DEFAULT)5616 def _init_test_ldap_properties_map_invalid_input_2():5617 ldap_properties_map = \5618 {5619 LDAP_PRIMARY_URL_PROPERTY: "a:3",5620 "authentication.ldap.useSSL": "false",5621 "authentication.ldap.userObjectClass": "user",5622 "authentication.ldap.usernameAttribute": "uid",5623 "authentication.ldap.groupObjectClass": "group",5624 "authentication.ldap.groupNamingAttr": "cn",5625 "authentication.ldap.groupMembershipAttr": "member",5626 "authentication.ldap.dnAttribute": "dn",5627 "authentication.ldap.baseDn": "base",5628 "authentication.ldap.referral": "follow",5629 "authentication.ldap.bindAnonymously": "true",5630 "client.security": "ldap",5631 "ambari.ldap.isConfigured": "true"5632 }5633 return ldap_properties_map5634 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))5635 @patch("__builtin__.raw_input")5636 @patch("ambari_server.setupSecurity.get_is_secure")5637 @patch("ambari_server.setupSecurity.get_YN_input")5638 @patch("ambari_server.setupSecurity.update_properties_2")5639 @patch("ambari_server.setupSecurity.search_file")5640 @patch("ambari_server.setupSecurity.get_ambari_properties")5641 @patch("ambari_server.setupSecurity.is_root")5642 def test_setup_ldap_invalid_input(self, is_root_method, get_ambari_properties_method,5643 search_file_message,5644 update_properties_method,5645 get_YN_input_method,5646 get_is_secure_method,5647 raw_input_mock):5648 out = StringIO.StringIO()5649 sys.stdout = out5650 is_root_method.return_value = True5651 search_file_message.return_value = "filepath"5652 configs = {SECURITY_MASTER_KEY_LOCATION: "filepath",5653 SECURITY_KEYS_DIR: tempfile.gettempdir(),5654 SECURITY_IS_ENCRYPTION_ENABLED: "true"5655 }5656 get_ambari_properties_method.return_value = configs5657 raw_input_mock.side_effect = ['a:3', 'b:b', 'hody', 'b:2', 'false', 'user', 'uid', 'group', 'cn', 'member', 'dn', 'base', 'follow', 'true']5658 set_silent(False)5659 get_YN_input_method.return_value = True5660 setup_ldap()5661 ldap_properties_map = TestAmbariServer._init_test_ldap_properties_map_invalid_input_1()5662 sorted_x = sorted(ldap_properties_map.iteritems(), key=operator.itemgetter(0))5663 sorted_y = sorted(update_properties_method.call_args[0][1].iteritems(),5664 key=operator.itemgetter(0))5665 self.assertEquals(sorted_x, sorted_y)5666 self.assertTrue(get_YN_input_method.called)5667 self.assertEquals(14, raw_input_mock.call_count)5668 raw_input_mock.reset_mock()5669 raw_input_mock.side_effect = ['a:3', '', 'b:2', 'false', 'user', 'uid', 'group', 'cn', 'member', 'dn', 'base', 'follow', 'true']5670 setup_ldap()5671 ldap_properties_map = TestAmbariServer._init_test_ldap_properties_map_invalid_input_2()5672 sorted_x = sorted(ldap_properties_map.iteritems(), key=operator.itemgetter(0))5673 sorted_y = sorted(update_properties_method.call_args[0][1].iteritems(),5674 key=operator.itemgetter(0))5675 self.assertEquals(sorted_x, sorted_y)5676 self.assertEquals(13, raw_input_mock.call_count)5677 sys.stdout = sys.__stdout__5678 pass5679 @staticmethod5680 @OsFamilyFuncImpl(OSConst.WINSRV_FAMILY)5681 def _init_test_ldap_properties_map():5682 ldap_properties_map = \5683 {5684 "authentication.ldap.primaryUrl": "test",5685 "authentication.ldap.secondaryUrl": "test",5686 "authentication.ldap.useSSL": "false",5687 "authentication.ldap.usernameAttribute": "test",5688 "authentication.ldap.baseDn": "test",5689 "authentication.ldap.bindAnonymously": "false",5690 "authentication.ldap.managerDn": "test",5691 "authentication.ldap.referral": "test",5692 "client.security": "ldap",5693 LDAP_MGR_PASSWORD_PROPERTY: "ldap-password.dat",5694 "ambari.ldap.isConfigured": "true"5695 }5696 return ldap_properties_map5697 @staticmethod5698 @OsFamilyFuncImpl(OsFamilyImpl.DEFAULT)5699 def _init_test_ldap_properties_map():5700 ldap_properties_map = \5701 {5702 "authentication.ldap.primaryUrl": "test",5703 "authentication.ldap.secondaryUrl": "test",5704 "authentication.ldap.useSSL": "false",5705 "authentication.ldap.userObjectClass": "test",5706 "authentication.ldap.usernameAttribute": "test",5707 "authentication.ldap.baseDn": "test",5708 "authentication.ldap.bindAnonymously": "false",5709 "authentication.ldap.managerDn": "test",5710 "authentication.ldap.groupObjectClass": "test",5711 "authentication.ldap.groupMembershipAttr": "test",5712 "authentication.ldap.groupNamingAttr": "test",5713 "authentication.ldap.dnAttribute": "test",5714 "authentication.ldap.referral": "test",5715 "client.security": "ldap",5716 LDAP_MGR_PASSWORD_PROPERTY: "ldap-password.dat",5717 "ambari.ldap.isConfigured": "true"5718 }5719 return ldap_properties_map5720 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))5721 @patch("ambari_server.setupSecurity.get_is_secure")5722 @patch("ambari_server.setupSecurity.encrypt_password")5723 @patch("ambari_server.setupSecurity.save_passwd_for_alias")5724 @patch("ambari_server.setupSecurity.get_YN_input")5725 @patch("ambari_server.setupSecurity.update_properties_2")5726 @patch("ambari_server.setupSecurity.configure_ldap_password")5727 @patch("ambari_server.setupSecurity.get_validated_string_input")5728 @patch("ambari_server.serverConfiguration.search_file")5729 @patch("ambari_server.setupSecurity.get_ambari_properties")5730 @patch("ambari_server.setupSecurity.is_root")5731 @patch("ambari_server.setupSecurity.read_password")5732 @patch("os.path.exists")5733 def test_setup_ldap(self, exists_method, read_password_method, is_root_method, get_ambari_properties_method,5734 search_file_message,5735 get_validated_string_input_method,5736 configure_ldap_password_method, update_properties_method,5737 get_YN_input_method, save_passwd_for_alias_method,5738 encrypt_password_method, get_is_secure_method):5739 out = StringIO.StringIO()5740 sys.stdout = out5741 # Testing call under non-root5742 is_root_method.return_value = False5743 try:5744 setup_ldap()5745 self.fail("Should throw exception")5746 except FatalException as fe:5747 # Expected5748 self.assertTrue("root-level" in fe.reason)5749 pass5750 # Testing call under root5751 is_root_method.return_value = True5752 search_file_message.return_value = "filepath"5753 configs = {SECURITY_MASTER_KEY_LOCATION: "filepath",5754 SECURITY_KEYS_DIR: tempfile.gettempdir(),5755 SECURITY_IS_ENCRYPTION_ENABLED: "true"5756 }5757 get_ambari_properties_method.return_value = configs5758 configure_ldap_password_method.return_value = "password"5759 save_passwd_for_alias_method.return_value = 05760 encrypt_password_method.return_value = get_alias_string(LDAP_MGR_PASSWORD_ALIAS)5761 def yn_input_side_effect(*args, **kwargs):5762 if 'TrustStore' in args[0]:5763 return False5764 else:5765 return True5766 #get_YN_input_method.side_effect = yn_input_side_effect()5767 get_YN_input_method.side_effect = [True, ]5768 def valid_input_side_effect(*args, **kwargs):5769 if 'Bind anonymously' in args[0]:5770 return 'false'5771 if args[1] == "true" or args[1] == "false":5772 return args[1]5773 else:5774 return "test"5775 get_validated_string_input_method.side_effect = valid_input_side_effect5776 setup_ldap()5777 ldap_properties_map = TestAmbariServer._init_test_ldap_properties_map()5778 sorted_x = sorted(ldap_properties_map.iteritems(), key=operator.itemgetter(0))5779 sorted_y = sorted(update_properties_method.call_args[0][1].iteritems(),5780 key=operator.itemgetter(0))5781 self.assertEquals(sorted_x, sorted_y)5782 self.assertTrue(update_properties_method.called)5783 self.assertTrue(configure_ldap_password_method.called)5784 self.assertTrue(get_validated_string_input_method.called)5785 self.assertTrue(get_YN_input_method.called)5786 # truststore not found case5787 def os_path_exists(*args, **kwargs):5788 if "bogus" in args[0]:5789 return False5790 else:5791 return True5792 pass5793 def input_enable_ssl(*args, **kwargs):5794 if 'Bind anonymously' in args[0]:5795 return 'false'5796 if "SSL" in args[0]:5797 return "true"5798 if "Path to TrustStore file" in args[0]:5799 if input_enable_ssl.path_counter < 2:5800 input_enable_ssl.path_counter += 15801 return "bogus"5802 else:5803 return "valid"5804 if args[1] == "true" or args[1] == "false":5805 return args[1]5806 else:5807 return "test"5808 pass5809 input_enable_ssl.path_counter = 05810 exists_method.side_effect = os_path_exists5811 get_validated_string_input_method.side_effect = input_enable_ssl5812 read_password_method.return_value = "password"5813 get_YN_input_method.reset_mock()5814 get_YN_input_method.side_effect = [True, True]5815 update_properties_method.reset_mock()5816 setup_ldap()5817 self.assertTrue(read_password_method.called)5818 ldap_properties_map = \5819 {5820 "authentication.ldap.primaryUrl": "test",5821 "authentication.ldap.secondaryUrl": "test",5822 "authentication.ldap.useSSL": "true",5823 "authentication.ldap.usernameAttribute": "test",5824 "authentication.ldap.baseDn": "test",5825 "authentication.ldap.dnAttribute": "test",5826 "authentication.ldap.bindAnonymously": "false",5827 "authentication.ldap.managerDn": "test",5828 "client.security": "ldap",5829 "ssl.trustStore.type": "test",5830 "ssl.trustStore.path": "valid",5831 "ssl.trustStore.password": "password",5832 LDAP_MGR_PASSWORD_PROPERTY: get_alias_string(LDAP_MGR_PASSWORD_ALIAS)5833 }5834 sorted_x = sorted(ldap_properties_map.iteritems(), key=operator.itemgetter(0))5835 sorted_y = sorted(update_properties_method.call_args[0][1].iteritems(),5836 key=operator.itemgetter(0))5837 sys.stdout = sys.__stdout__5838 pass5839 @patch("urllib2.urlopen")5840 @patch("ambari_server.setupSecurity.get_validated_string_input")5841 @patch("ambari_server.setupSecurity.get_ambari_properties")5842 @patch("ambari_server.setupSecurity.is_server_runing")5843 @patch("ambari_server.setupSecurity.is_root")5844 def test_ldap_sync_all(self, is_root_method, is_server_runing_mock, get_ambari_properties_mock,5845 get_validated_string_input_mock, urlopen_mock):5846 is_root_method.return_value = True5847 is_server_runing_mock.return_value = (True, 0)5848 properties = Properties()5849 properties.process_pair(IS_LDAP_CONFIGURED, 'true')5850 properties.process_pair(CLIENT_API_PORT_PROPERTY, '8080')5851 get_ambari_properties_mock.return_value = properties5852 get_validated_string_input_mock.side_effect = ['admin', 'admin']5853 response = MagicMock()5854 response.getcode.side_effect = [201, 200, 200]5855 response.read.side_effect = ['{"resources" : [{"href" : "http://c6401.ambari.apache.org:8080/api/v1/ldap_sync_events/16","Event" : {"id" : 16}}]}',5856 '{"Event":{"status" : "RUNNING","summary" : {"groups" : {"created" : 0,"removed" : 0,"updated" : 0},"memberships" : {"created" : 0,"removed" : 0},"users" : {"created" : 0,"removed" : 0,"updated" : 0}}}}',5857 '{"Event":{"status" : "COMPLETE","summary" : {"groups" : {"created" : 1,"removed" : 0,"updated" : 0},"memberships" : {"created" : 5,"removed" : 0},"users" : {"created" : 5,"removed" : 0,"updated" : 0}}}}']5858 urlopen_mock.return_value = response5859 options = MagicMock()5860 options.ldap_sync_all = True5861 options.ldap_sync_existing = False5862 options.ldap_sync_users = None5863 options.ldap_sync_groups = None5864 sync_ldap(options)5865 url = '{0}://{1}:{2!s}{3}'.format('http', '127.0.0.1', '8080', '/api/v1/ldap_sync_events')5866 request = urlopen_mock.call_args_list[0][0][0]5867 self.assertEquals(url, str(request.get_full_url()))5868 self.assertEquals('[{"Event": {"specs": [{"principal_type": "users", "sync_type": "all"}, {"principal_type": "groups", "sync_type": "all"}]}}]', request.data)5869 self.assertTrue(response.getcode.called)5870 self.assertTrue(response.read.called)5871 pass5872 @patch("__builtin__.open")5873 @patch("os.path.exists")5874 @patch("urllib2.urlopen")5875 @patch("ambari_server.setupSecurity.get_validated_string_input")5876 @patch("ambari_server.setupSecurity.get_ambari_properties")5877 @patch("ambari_server.setupSecurity.is_server_runing")5878 @patch("ambari_server.setupSecurity.is_root")5879 def test_ldap_sync_users(self, is_root_method, is_server_runing_mock, get_ambari_properties_mock,5880 get_validated_string_input_mock, urlopen_mock, os_path_exists_mock, open_mock):5881 os_path_exists_mock.return_value = 15882 f = MagicMock()5883 f.__enter__().read.return_value = "bob, tom"5884 open_mock.return_value = f5885 is_root_method.return_value = True5886 is_server_runing_mock.return_value = (True, 0)5887 properties = Properties()5888 properties.process_pair(IS_LDAP_CONFIGURED, 'true')5889 get_ambari_properties_mock.return_value = properties5890 get_validated_string_input_mock.side_effect = ['admin', 'admin']5891 response = MagicMock()5892 response.getcode.side_effect = [201, 200, 200]5893 response.read.side_effect = ['{"resources" : [{"href" : "http://c6401.ambari.apache.org:8080/api/v1/ldap_sync_events/16","Event" : {"id" : 16}}]}',5894 '{"Event":{"status" : "RUNNING","summary" : {"groups" : {"created" : 0,"removed" : 0,"updated" : 0},"memberships" : {"created" : 0,"removed" : 0},"users" : {"created" : 0,"removed" : 0,"updated" : 0}}}}',5895 '{"Event":{"status" : "COMPLETE","summary" : {"groups" : {"created" : 1,"removed" : 0,"updated" : 0},"memberships" : {"created" : 5,"removed" : 0},"users" : {"created" : 5,"removed" : 0,"updated" : 0}}}}']5896 urlopen_mock.return_value = response5897 options = MagicMock()5898 options.ldap_sync_all = False5899 options.ldap_sync_existing = False5900 options.ldap_sync_users = 'users.txt'5901 options.ldap_sync_groups = None5902 sync_ldap(options)5903 request = urlopen_mock.call_args_list[0][0][0]5904 self.assertEquals('[{"Event": {"specs": [{"principal_type": "users", "sync_type": "specific", "names": "bob, tom"}]}}]', request.data)5905 self.assertTrue(response.getcode.called)5906 self.assertTrue(response.read.called)5907 pass5908 @patch("__builtin__.open")5909 @patch("os.path.exists")5910 @patch("urllib2.urlopen")5911 @patch("ambari_server.setupSecurity.get_validated_string_input")5912 @patch("ambari_server.setupSecurity.get_ambari_properties")5913 @patch("ambari_server.setupSecurity.is_server_runing")5914 @patch("ambari_server.setupSecurity.is_root")5915 def test_ldap_sync_groups(self, is_root_method, is_server_runing_mock, get_ambari_properties_mock,5916 get_validated_string_input_mock, urlopen_mock, os_path_exists_mock, open_mock):5917 os_path_exists_mock.return_value = 15918 f = MagicMock()5919 f.__enter__().read.return_value = "group1, group2"5920 open_mock.return_value = f5921 is_root_method.return_value = True5922 is_server_runing_mock.return_value = (True, 0)5923 properties = Properties()5924 properties.process_pair(IS_LDAP_CONFIGURED, 'true')5925 get_ambari_properties_mock.return_value = properties5926 get_validated_string_input_mock.side_effect = ['admin', 'admin']5927 response = MagicMock()5928 response.getcode.side_effect = [201, 200, 200]5929 response.read.side_effect = ['{"resources" : [{"href" : "http://c6401.ambari.apache.org:8080/api/v1/ldap_sync_events/16","Event" : {"id" : 16}}]}',5930 '{"Event":{"status" : "RUNNING","summary" : {"groups" : {"created" : 0,"removed" : 0,"updated" : 0},"memberships" : {"created" : 0,"removed" : 0},"users" : {"created" : 0,"removed" : 0,"updated" : 0}}}}',5931 '{"Event":{"status" : "COMPLETE","summary" : {"groups" : {"created" : 1,"removed" : 0,"updated" : 0},"memberships" : {"created" : 5,"removed" : 0},"users" : {"created" : 5,"removed" : 0,"updated" : 0}}}}']5932 urlopen_mock.return_value = response5933 options = MagicMock()5934 options.ldap_sync_all = False5935 options.ldap_sync_existing = False5936 options.ldap_sync_users = None5937 options.ldap_sync_groups = 'groups.txt'5938 sync_ldap(options)5939 request = urlopen_mock.call_args_list[0][0][0]5940 self.assertEquals('[{"Event": {"specs": [{"principal_type": "groups", "sync_type": "specific", "names": "group1, group2"}]}}]', request.data)5941 self.assertTrue(response.getcode.called)5942 self.assertTrue(response.read.called)5943 pass5944 @patch("urllib2.urlopen")5945 @patch("ambari_server.setupSecurity.get_validated_string_input")5946 @patch("ambari_server.setupSecurity.get_ambari_properties")5947 @patch("ambari_server.setupSecurity.is_server_runing")5948 @patch("ambari_server.setupSecurity.is_root")5949 def test_ldap_sync_ssl(self, is_root_method, is_server_runing_mock, get_ambari_properties_mock,5950 get_validated_string_input_mock, urlopen_mock):5951 is_root_method.return_value = True5952 is_server_runing_mock.return_value = (True, 0)5953 properties = Properties()5954 properties.process_pair(IS_LDAP_CONFIGURED, 'true')5955 properties.process_pair(SSL_API, 'true')5956 properties.process_pair(SSL_API_PORT, '8443')5957 get_ambari_properties_mock.return_value = properties5958 get_validated_string_input_mock.side_effect = ['admin', 'admin']5959 response = MagicMock()5960 response.getcode.side_effect = [201, 200, 200]5961 response.read.side_effect = ['{"resources" : [{"href" : "https://c6401.ambari.apache.org:8443/api/v1/ldap_sync_events/16","Event" : {"id" : 16}}]}',5962 '{"Event":{"status" : "RUNNING","summary" : {"groups" : {"created" : 0,"removed" : 0,"updated" : 0},"memberships" : {"created" : 0,"removed" : 0},"users" : {"created" : 0,"removed" : 0,"updated" : 0}}}}',5963 '{"Event":{"status" : "COMPLETE","summary" : {"groups" : {"created" : 1,"removed" : 0,"updated" : 0},"memberships" : {"created" : 5,"removed" : 0},"users" : {"created" : 5,"removed" : 0,"updated" : 0}}}}']5964 urlopen_mock.return_value = response5965 options = MagicMock()5966 options.ldap_sync_all = True5967 options.ldap_sync_existing = False5968 options.ldap_sync_users = None5969 options.ldap_sync_groups = None5970 sync_ldap(options)5971 url = '{0}://{1}:{2!s}{3}'.format('https', '127.0.0.1', '8443', '/api/v1/ldap_sync_events')5972 request = urlopen_mock.call_args_list[0][0][0]5973 self.assertEquals(url, str(request.get_full_url()))5974 self.assertTrue(response.getcode.called)5975 self.assertTrue(response.read.called)5976 pass5977 @patch("urllib2.urlopen")5978 @patch("ambari_server.setupSecurity.get_validated_string_input")5979 @patch("ambari_server.setupSecurity.get_ambari_properties")5980 @patch("ambari_server.setupSecurity.is_server_runing")5981 @patch("ambari_server.setupSecurity.is_root")5982 def test_ldap_sync_existing(self, is_root_method, is_server_runing_mock, get_ambari_properties_mock,5983 get_validated_string_input_mock, urlopen_mock):5984 is_root_method.return_value = True5985 is_server_runing_mock.return_value = (True, 0)5986 properties = Properties()5987 properties.process_pair(IS_LDAP_CONFIGURED, 'true')5988 get_ambari_properties_mock.return_value = properties5989 get_validated_string_input_mock.side_effect = ['admin', 'admin']5990 response = MagicMock()5991 response.getcode.side_effect = [201, 200, 200]5992 response.read.side_effect = ['{"resources" : [{"href" : "http://c6401.ambari.apache.org:8080/api/v1/ldap_sync_events/16","Event" : {"id" : 16}}]}',5993 '{"Event":{"status" : "RUNNING","summary" : {"groups" : {"created" : 0,"removed" : 0,"updated" : 0},"memberships" : {"created" : 0,"removed" : 0},"users" : {"created" : 0,"removed" : 0,"updated" : 0}}}}',5994 '{"Event":{"status" : "COMPLETE","summary" : {"groups" : {"created" : 1,"removed" : 0,"updated" : 0},"memberships" : {"created" : 5,"removed" : 0},"users" : {"created" : 5,"removed" : 0,"updated" : 0}}}}']5995 urlopen_mock.return_value = response5996 options = MagicMock()5997 options.ldap_sync_all = False5998 options.ldap_sync_existing = True5999 options.ldap_sync_users = None6000 options.ldap_sync_groups = None6001 sync_ldap(options)6002 self.assertTrue(response.getcode.called)6003 self.assertTrue(response.read.called)6004 pass6005 @patch("urllib2.urlopen")6006 @patch("ambari_server.setupSecurity.get_validated_string_input")6007 @patch("ambari_server.setupSecurity.get_ambari_properties")6008 @patch("ambari_server.setupSecurity.is_server_runing")6009 @patch("ambari_server.setupSecurity.is_root")6010 def test_ldap_sync_no_sync_mode(self, is_root_method, is_server_runing_mock, get_ambari_properties_mock,6011 get_validated_string_input_mock, urlopen_mock):6012 is_root_method.return_value = True6013 is_server_runing_mock.return_value = (True, 0)6014 properties = Properties()6015 properties.process_pair(IS_LDAP_CONFIGURED, 'true')6016 get_ambari_properties_mock.return_value = properties6017 get_validated_string_input_mock.side_effect = ['admin', 'admin']6018 response = MagicMock()6019 response.getcode.side_effect = [201, 200, 200]6020 response.read.side_effect = ['{"resources" : [{"href" : "http://c6401.ambari.apache.org:8080/api/v1/ldap_sync_events/16","Event" : {"id" : 16}}]}',6021 '{"Event":{"status" : "RUNNING","summary" : {"groups" : {"created" : 0,"removed" : 0,"updated" : 0},"memberships" : {"created" : 0,"removed" : 0},"users" : {"created" : 0,"removed" : 0,"updated" : 0}}}}',6022 '{"Event":{"status" : "COMPLETE","summary" : {"groups" : {"created" : 1,"removed" : 0,"updated" : 0},"memberships" : {"created" : 5,"removed" : 0},"users" : {"created" : 5,"removed" : 0,"updated" : 0}}}}']6023 urlopen_mock.return_value = response6024 options = MagicMock()6025 del options.ldap_sync_all6026 del options.ldap_sync_existing6027 del options.ldap_sync_users6028 del options.ldap_sync_groups6029 try:6030 sync_ldap(options)6031 self.fail("Should fail with exception")6032 except FatalException as e:6033 pass6034 pass6035 @patch("urllib2.urlopen")6036 @patch("ambari_server.setupSecurity.get_validated_string_input")6037 @patch("ambari_server.setupSecurity.get_ambari_properties")6038 @patch("ambari_server.setupSecurity.is_server_runing")6039 @patch("ambari_server.setupSecurity.is_root")6040 def test_ldap_sync_error_status(self, is_root_method, is_server_runing_mock, get_ambari_properties_mock,6041 get_validated_string_input_mock, urlopen_mock):6042 is_root_method.return_value = True6043 is_server_runing_mock.return_value = (True, 0)6044 properties = Properties()6045 properties.process_pair(IS_LDAP_CONFIGURED, 'true')6046 get_ambari_properties_mock.return_value = properties6047 get_validated_string_input_mock.side_effect = ['admin', 'admin']6048 response = MagicMock()6049 response.getcode.side_effect = [201, 200]6050 response.read.side_effect = ['{"resources" : [{"href" : "http://c6401.ambari.apache.org:8080/api/v1/ldap_sync_events/16","Event" : {"id" : 16}}]}',6051 '{"Event":{"status" : "ERROR","status_detail" : "Error!!","summary" : {"groups" : {"created" : 0,"removed" : 0,"updated" : 0},"memberships" : {"created" : 0,"removed" : 0},"users" : {"created" : 0,"removed" : 0,"updated" : 0}}}}']6052 urlopen_mock.return_value = response6053 options = MagicMock()6054 options.ldap_sync_all = False6055 options.ldap_sync_existing = False6056 options.ldap_sync_users = None6057 options.ldap_sync_groups = None6058 try:6059 sync_ldap(options)6060 self.fail("Should fail with exception")6061 except FatalException as e:6062 pass6063 pass6064 @patch("urllib2.urlopen")6065 @patch("urllib2.Request")6066 @patch("base64.encodestring")6067 @patch("ambari_server.setupSecurity.is_root")6068 @patch("ambari_server.setupSecurity.is_server_runing")6069 @patch("ambari_server.setupSecurity.get_ambari_properties")6070 @patch("ambari_server.setupSecurity.get_validated_string_input")6071 def test_sync_ldap_forbidden(self, get_validated_string_input_method, get_ambari_properties_method,6072 is_server_runing_method, is_root_method,6073 encodestring_method, request_constructor, urlopen_method):6074 options = MagicMock()6075 options.ldap_sync_all = True6076 options.ldap_sync_existing = False6077 options.ldap_sync_users = None6078 options.ldap_sync_groups = None6079 is_root_method.return_value = False6080 try:6081 sync_ldap(options)6082 self.fail("Should throw exception if not root")6083 except FatalException as fe:6084 # Expected6085 self.assertTrue("root-level" in fe.reason)6086 pass6087 is_root_method.return_value = True6088 is_server_runing_method.return_value = (None, None)6089 try:6090 sync_ldap(options)6091 self.fail("Should throw exception if ambari is stopped")6092 except FatalException as fe:6093 # Expected6094 self.assertTrue("not running" in fe.reason)6095 pass6096 is_server_runing_method.return_value = (True, None)6097 configs = MagicMock()6098 configs.get_property.return_value = None6099 get_ambari_properties_method.return_value = configs6100 try:6101 sync_ldap(options)6102 self.fail("Should throw exception if ldap is not configured")6103 except FatalException as fe:6104 # Expected6105 self.assertTrue("not configured" in fe.reason)6106 pass6107 configs.get_property.return_value = 'true'6108 get_validated_string_input_method.return_value = 'admin'6109 encodestring_method.return_value = 'qwe123'6110 requestMocks = [MagicMock()]6111 request_constructor.side_effect = requestMocks6112 response = MagicMock()6113 response.getcode.return_value = 4036114 urlopen_method.return_value = response6115 try:6116 sync_ldap(options)6117 self.fail("Should throw exception if return code != 200")6118 except FatalException as fe:6119 # Expected6120 self.assertTrue("status code" in fe.reason)6121 pass6122 pass6123 @patch("ambari_server.setupSecurity.is_root")6124 def test_sync_ldap_ambari_stopped(self, is_root_method):6125 is_root_method.return_value = False6126 options = MagicMock()6127 options.ldap_sync_all = True6128 options.ldap_sync_existing = False6129 options.ldap_sync_users = None6130 options.ldap_sync_groups = None6131 try:6132 sync_ldap(options)6133 self.fail("Should throw exception if not root")6134 except FatalException as fe:6135 # Expected6136 self.assertTrue("root-level" in fe.reason)6137 pass6138 pass6139 @patch("ambari_server.setupSecurity.is_root")6140 @patch("ambari_server.setupSecurity.is_server_runing")6141 def test_sync_ldap_ambari_stopped(self, is_server_runing_method, is_root_method):6142 is_root_method.return_value = True6143 is_server_runing_method.return_value = (None, None)6144 options = MagicMock()6145 options.ldap_sync_all = True6146 options.ldap_sync_existing = False6147 options.ldap_sync_users = None6148 options.ldap_sync_groups = None6149 try:6150 sync_ldap(options)6151 self.fail("Should throw exception if ambari is stopped")6152 except FatalException as fe:6153 # Expected6154 self.assertTrue("not running" in fe.reason)6155 pass6156 pass6157 @patch("ambari_server.setupSecurity.is_root")6158 @patch("ambari_server.setupSecurity.is_server_runing")6159 @patch("ambari_server.setupSecurity.get_ambari_properties")6160 def test_sync_ldap_not_configured(self, get_ambari_properties_method,6161 is_server_runing_method, is_root_method):6162 is_root_method.return_value = True6163 is_server_runing_method.return_value = (True, None)6164 configs = MagicMock()6165 configs.get_property.return_value = None6166 get_ambari_properties_method.return_value = configs6167 options = MagicMock()6168 options.ldap_sync_all = True6169 del options.ldap_sync_existing6170 del options.ldap_sync_users6171 del options.ldap_sync_groups6172 try:6173 sync_ldap(options)6174 self.fail("Should throw exception if ldap is not configured")6175 except FatalException as fe:6176 # Expected6177 self.assertTrue("not configured" in fe.reason)6178 pass6179 pass6180 @patch("__builtin__.open")6181 @patch("os.path.exists")6182 def test_get_ldap_event_spec_names(self, os_path_exists_mock, open_mock):6183 os_path_exists_mock.return_value = 16184 f = MagicMock()6185 f.__enter__().read.return_value = "\n\n\t some group, \tanother group, \n\t\tgrp, \ngroup*\n\n\n\n"6186 open_mock.return_value = f6187 bodies = [{"Event":{"specs":[]}}]6188 body = bodies[0]6189 events = body['Event']6190 specs = events['specs']6191 new_specs = [{"principal_type":"groups","sync_type":"specific","names":""}]6192 get_ldap_event_spec_names("groups.txt", specs, new_specs)6193 self.assertEquals("[{'Event': {'specs': [{'principal_type': 'groups', 'sync_type': 'specific', 'names': ' some group, another group, grp, group*'}]}}]", str(bodies))6194 pass6195 @patch("ambari_server.setupSecurity.read_password")6196 def test_configure_ldap_password(self, read_password_method):6197 out = StringIO.StringIO()6198 sys.stdout = out6199 read_password_method.return_value = "blah"6200 configure_ldap_password()6201 self.assertTrue(read_password_method.called)6202 sys.stdout = sys.__stdout__6203 pass6204 @patch("ambari_server.userInput.get_validated_string_input")6205 def test_read_password(self, get_validated_string_input_method):6206 out = StringIO.StringIO()6207 sys.stdout = out6208 passwordDefault = ""6209 passwordPrompt = 'Enter Manager Password* : '6210 passwordPattern = ".*"6211 passwordDescr = "Invalid characters in password."6212 get_validated_string_input_method.side_effect = ['', 'aaa', 'aaa']6213 password = read_password(passwordDefault, passwordPattern,6214 passwordPrompt, passwordDescr)6215 self.assertTrue(3, get_validated_string_input_method.call_count)6216 self.assertEquals('aaa', password)6217 get_validated_string_input_method.reset_mock()6218 get_validated_string_input_method.side_effect = ['aaa', 'aaa']6219 password = read_password(passwordDefault, passwordPattern,6220 passwordPrompt, passwordDescr)6221 self.assertTrue(2, get_validated_string_input_method.call_count)6222 self.assertEquals('aaa', password)6223 get_validated_string_input_method.reset_mock()6224 get_validated_string_input_method.side_effect = ['aaa']6225 password = read_password('aaa', passwordPattern,6226 passwordPrompt, passwordDescr)6227 self.assertTrue(1, get_validated_string_input_method.call_count)6228 self.assertEquals('aaa', password)6229 sys.stdout = sys.__stdout__6230 pass6231 def test_generate_random_string(self):6232 random_str_len = 1006233 str1 = generate_random_string(random_str_len)6234 self.assertTrue(len(str1) == random_str_len)6235 str2 = generate_random_string(random_str_len)6236 self.assertTrue(str1 != str2)6237 pass6238 @patch("__builtin__.open")6239 @patch("ambari_server.serverConfiguration.search_file")6240 @patch("ambari_server.serverConfiguration.backup_file_in_temp")6241 def test_update_properties_2(self, backup_file_in_temp_mock, search_file_mock, open_mock):6242 conf_file = "ambari.properties"6243 propertyMap = {"1": "1", "2": "2"}6244 properties = MagicMock()6245 f = MagicMock(name="file")6246 # f.__enter__.return_value = f #mimic file behavior6247 search_file_mock.return_value = conf_file6248 open_mock.return_value = f6249 update_properties_2(properties, propertyMap)6250 properties.store_ordered.assert_called_with(f.__enter__.return_value)6251 backup_file_in_temp_mock.assert_called_with(conf_file)6252 self.assertEquals(2, properties.removeOldProp.call_count)6253 self.assertEquals(2, properties.process_pair.call_count)6254 properties = MagicMock()6255 backup_file_in_temp_mock.reset_mock()6256 open_mock.reset_mock()6257 update_properties_2(properties, None)6258 properties.store_ordered.assert_called_with(f.__enter__.return_value)6259 backup_file_in_temp_mock.assert_called_with(conf_file)6260 self.assertFalse(properties.removeOldProp.called)6261 self.assertFalse(properties.process_pair.called)6262 pass6263 def test_regexps(self):6264 res = re.search(REGEX_HOSTNAME_PORT, "")6265 self.assertTrue(res is None)6266 res = re.search(REGEX_HOSTNAME_PORT, "ddd")6267 self.assertTrue(res is None)6268 res = re.search(REGEX_HOSTNAME_PORT, "gg:ff")6269 self.assertTrue(res is None)6270 res = re.search(REGEX_HOSTNAME_PORT, "gg:55444325")6271 self.assertTrue(res is None)6272 res = re.search(REGEX_HOSTNAME_PORT, "gg:555")6273 self.assertTrue(res is not None)6274 res = re.search(REGEX_TRUE_FALSE, "")6275 self.assertTrue(res is not None)6276 res = re.search(REGEX_TRUE_FALSE, "t")6277 self.assertTrue(res is None)6278 res = re.search(REGEX_TRUE_FALSE, "trrrr")6279 self.assertTrue(res is None)6280 res = re.search(REGEX_TRUE_FALSE, "true|false")6281 self.assertTrue(res is None)6282 res = re.search(REGEX_TRUE_FALSE, "true")6283 self.assertTrue(res is not None)6284 res = re.search(REGEX_TRUE_FALSE, "false")6285 self.assertTrue(res is not None)6286 res = re.search(REGEX_ANYTHING, "")6287 self.assertTrue(res is not None)6288 res = re.search(REGEX_ANYTHING, "t")6289 self.assertTrue(res is not None)6290 res = re.search(REGEX_ANYTHING, "trrrr")6291 self.assertTrue(res is not None)6292 pass6293 def get_sample(self, sample):6294 """6295 Returns sample file content as string with normalized line endings6296 """6297 path = self.get_samples_dir(sample)6298 return self.get_file_string(path)6299 def get_file_string(self, file):6300 """6301 Returns file content as string with normalized line endings6302 """6303 string = open(file, 'r').read()6304 return self.normalize(string)6305 def normalize(self, string):6306 """6307 Normalizes line ending in string according to platform-default encoding6308 """6309 return string.replace("\n", os.linesep)6310 def get_samples_dir(self, sample):6311 """6312 Returns full file path by sample name6313 """6314 testdir = os.path.dirname(__file__)6315 return os.path.dirname(testdir) + os.sep + "resources" + os.sep \6316 + 'TestAmbaryServer.samples/' + sample6317 @not_for_platform(PLATFORM_WINDOWS)6318 @patch("ambari_server.dbConfiguration_linux.get_ambari_properties")6319 def test_is_jdbc_user_changed(self, get_ambari_properties_mock):6320 previous_user = "previous_user"6321 new_user = "new_user"6322 props = Properties()6323 props.process_pair(JDBC_USER_NAME_PROPERTY, previous_user)6324 get_ambari_properties_mock.return_value = props6325 #check if users are different6326 result = PGConfig._is_jdbc_user_changed(new_user)6327 self.assertTrue(result)6328 #check if users are equal6329 result = PGConfig._is_jdbc_user_changed(previous_user)6330 self.assertFalse(result)6331 #check if one of users is None6332 result = PGConfig._is_jdbc_user_changed(None)6333 self.assertEqual(None, result)6334 pass6335 @not_for_platform(PLATFORM_WINDOWS)6336 @patch("ambari_server.serverConfiguration.write_property")6337 @patch("ambari_server.serverConfiguration.get_ambari_properties")6338 @patch("ambari_server.serverConfiguration.get_ambari_version")6339 def test_check_database_name_property(self, get_ambari_version_mock, get_ambari_properties_mock, write_property_mock):6340 parser = OptionParser()6341 parser.add_option('--database', default=None, help="Database to use embedded|oracle|mysql|mssql|postgres", dest="dbms")6342 args = parser.parse_args()6343 # negative case6344 get_ambari_properties_mock.return_value = {JDBC_DATABASE_NAME_PROPERTY: ""}6345 try:6346 result = check_database_name_property()6347 self.fail("Should fail with exception")6348 except FatalException as e:6349 self.assertTrue('DB Name property not set in config file.' in e.reason)6350 # positive case6351 dbname = "ambari"6352 get_ambari_properties_mock.reset_mock()6353 get_ambari_properties_mock.return_value = {JDBC_DATABASE_NAME_PROPERTY: dbname}6354 try:6355 result = check_database_name_property()6356 except FatalException:6357 self.fail("Setup should be successful")6358 # Check upgrade. In Ambari < 1.7.1 "database" property contained db name for local db6359 dbname = "ambari"6360 database = "ambari"6361 persistence = "local"6362 get_ambari_properties_mock.reset_mock()6363 get_ambari_properties_mock.return_value = {JDBC_DATABASE_NAME_PROPERTY: dbname,6364 JDBC_DATABASE_PROPERTY: database,6365 PERSISTENCE_TYPE_PROPERTY: persistence}6366 try:6367 result = check_database_name_property(upgrade=True)6368 except FatalException:6369 self.fail("Setup should be successful")6370 self.assertTrue(write_property_mock.called)6371 @not_for_platform(PLATFORM_WINDOWS)6372 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))6373 @patch("ambari_commons.firewall.run_os_command")6374 @patch("ambari_server.dbConfiguration_linux.PGConfig._is_jdbc_user_changed")6375 @patch("ambari_server.serverSetup.verify_setup_allowed")6376 @patch("ambari_server.serverSetup.get_YN_input")6377 @patch("ambari_server.serverSetup.configure_os_settings")6378 @patch("ambari_server.serverSetup.download_and_install_jdk")6379 @patch.object(PGConfig, "_configure_postgres")6380 @patch.object(PGConfig, "_check_postgre_up")6381 @patch("ambari_server.serverSetup.check_ambari_user")6382 @patch("ambari_server.serverSetup.check_jdbc_drivers")6383 @patch("ambari_server.serverSetup.check_selinux")6384 @patch("ambari_server.serverSetup.is_root")6385 @patch.object(PGConfig, "_setup_db")6386 @patch("ambari_server.serverSetup.get_is_secure")6387 @patch("ambari_server.dbConfiguration_linux.store_password_file")6388 @patch("ambari_server.serverSetup.extract_views")6389 @patch("ambari_server.serverSetup.adjust_directory_permissions")6390 @patch("sys.exit")6391 @patch("__builtin__.raw_input")6392 @patch("ambari_server.serverSetup.expand_jce_zip_file")6393 def test_ambariServerSetupWithCustomDbName(self, expand_jce_zip_file_mock, raw_input, exit_mock, adjust_dirs_mock,6394 extract_views_mock, store_password_file_mock,6395 get_is_secure_mock, setup_db_mock, is_root_mock, #is_local_database_mock,6396 check_selinux_mock, check_jdbc_drivers_mock, check_ambari_user_mock,6397 check_postgre_up_mock, configure_postgres_mock,6398 download_jdk_mock, configure_os_settings_mock, get_YN_input,6399 verify_setup_allowed_method, is_jdbc_user_changed_mock,6400 run_os_command_mock):6401 args = MagicMock()6402 raw_input.return_value = ""6403 get_YN_input.return_value = False6404 verify_setup_allowed_method.return_value = 06405 is_root_mock.return_value = True6406 check_selinux_mock.return_value = 06407 check_ambari_user_mock.return_value = (0, False, 'user', None)6408 check_jdbc_drivers_mock.return_value = 06409 check_postgre_up_mock.return_value = "running", 0, "", ""6410 #is_local_database_mock.return_value = True6411 configure_postgres_mock.return_value = 0, "", ""6412 download_jdk_mock.return_value = 06413 configure_os_settings_mock.return_value = 06414 is_jdbc_user_changed_mock.return_value = False6415 setup_db_mock.return_value = (0, None, None)6416 get_is_secure_mock.return_value = False6417 store_password_file_mock.return_value = "password"6418 extract_views_mock.return_value = 06419 run_os_command_mock.return_value = 3,"",""6420 new_db = "newDBName"6421 args.dbms = "postgres"6422 args.database_name = new_db6423 args.postgres_schema = new_db6424 args.database_username = "user"6425 args.database_password = "password"6426 args.jdbc_driver= None6427 args.jdbc_db = None6428 args.must_set_database_options = True6429 del args.database_index6430 del args.persistence_type6431 tempdir = tempfile.gettempdir()6432 prop_file = os.path.join(tempdir, "ambari.properties")6433 with open(prop_file, "w") as f:6434 f.write("server.jdbc.database_name=oldDBName")6435 f.close()6436 os.environ[AMBARI_CONF_VAR] = tempdir6437 try:6438 result = setup(args)6439 except FatalException as ex:6440 self.fail("Setup should be successful")6441 properties = get_ambari_properties()6442 self.assertTrue(JDBC_DATABASE_NAME_PROPERTY in properties.keys())6443 value = properties[JDBC_DATABASE_NAME_PROPERTY]6444 self.assertEqual(value, new_db)6445 del os.environ[AMBARI_CONF_VAR]6446 os.remove(prop_file)6447 pass6448 @only_for_platform(PLATFORM_WINDOWS)6449 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))6450 @patch("ambari_server.serverSetup.service_setup")6451 @patch("ambari_server.dbConfiguration_windows.MSSQLConfig._execute_db_script")6452 @patch("ambari_server.dbConfiguration_windows.store_password_file")6453 @patch("ambari_server.dbConfiguration_windows.MSSQLConfig._is_jdbc_driver_installed")6454 @patch("ambari_server.serverSetup.verify_setup_allowed")6455 @patch("ambari_server.serverSetup.get_YN_input")6456 @patch("ambari_server.serverSetup.configure_os_settings")6457 @patch("ambari_server.serverSetup.download_and_install_jdk")6458 @patch("ambari_server.serverSetup.check_firewall")6459 @patch("ambari_server.serverSetup.check_ambari_user")6460 @patch("ambari_server.serverSetup.check_jdbc_drivers")6461 @patch("ambari_server.serverSetup.is_root")6462 @patch("ambari_server.serverSetup.extract_views")6463 @patch("ambari_server.serverSetup.adjust_directory_permissions")6464 def test_ambariServerSetupWithCustomDbName(self,6465 adjust_dirs_mock,6466 extract_views_mock,6467 is_root_mock,6468 check_jdbc_drivers_mock,6469 check_ambari_user_mock,6470 check_firewall_mock,6471 download_jdk_mock,6472 configure_os_settings_mock,6473 get_YN_input,6474 verify_setup_allowed_method,6475 is_jdbc_driver_installed_mock,6476 store_password_file_mock,6477 execute_db_script_mock,6478 service_setup_mock):6479 args = MagicMock()6480 get_YN_input.return_value = False6481 verify_setup_allowed_method.return_value = 06482 is_root_mock.return_value = True6483 check_ambari_user_mock.return_value = (0, False, 'user', None)6484 check_jdbc_drivers_mock.return_value = 06485 download_jdk_mock.return_value = 06486 configure_os_settings_mock.return_value = 06487 is_jdbc_driver_installed_mock.return_value = True6488 store_password_file_mock.return_value = "password.dat"6489 extract_views_mock.return_value = 06490 new_db = "newDBName"6491 del args.dbms6492 del args.database_index6493 del args.database_host6494 del args.database_port6495 args.database_name = new_db6496 args.database_username = "user"6497 args.database_password = "password"6498 del args.database_windows_auth6499 args.jdbc_driver= None6500 args.jdbc_db = None6501 args.must_set_database_options = True6502 del args.default_database_host6503 del args.persistence_type6504 del args.init_db_script_file6505 del args.cleanup_db_script_file6506 tempdir = tempfile.gettempdir()6507 prop_file = os.path.join(tempdir, "ambari.properties")6508 with open(prop_file, "w") as f:6509 f.write("server.jdbc.database_name=oldDBName")6510 f.close()6511 os.environ[AMBARI_CONF_VAR] = tempdir6512 try:6513 result = setup(args)6514 except FatalException as ex:6515 self.fail("Setup should be successful")6516 properties = get_ambari_properties()6517 self.assertTrue(JDBC_DATABASE_NAME_PROPERTY in properties.keys())6518 value = properties[JDBC_DATABASE_NAME_PROPERTY]6519 self.assertEqual(value, new_db)6520 self.assertEqual(store_password_file_mock.call_count, 2)6521 self.assertEqual(execute_db_script_mock.call_count, 2)6522 del os.environ[AMBARI_CONF_VAR]6523 os.remove(prop_file)6524 pass6525 def test_is_valid_filepath(self):6526 temp_dir = tempfile.gettempdir()6527 temp_file = tempfile.NamedTemporaryFile(mode='r')6528 # Correct path to an existing file6529 self.assertTrue(temp_file)6530 # Correct path to an existing directory6531 self.assertFalse(is_valid_filepath(temp_dir), \6532 'is_valid_filepath(path) should return False is path is a directory')6533 # Incorrect path6534 self.assertFalse(is_valid_filepath(''))6535 pass6536 @patch("os.listdir")6537 @patch("os.path.exists")6538 @patch("ambari_server.serverUpgrade.load_stack_values")6539 @patch("ambari_server.serverUpgrade.get_ambari_properties")6540 @patch("ambari_server.serverUpgrade.run_metainfo_upgrade")6541 def test_upgrade_local_repo(self,6542 run_metainfo_upgrade_mock,6543 get_ambari_properties_mock,6544 load_stack_values_mock,6545 os_path_exists_mock,6546 os_listdir_mock):6547 from mock.mock import call6548 args = MagicMock()6549 args.persistence_type = "local"6550 def load_values_side_effect(*args, **kwargs):6551 res = {}6552 res['a'] = 'http://oldurl'6553 if -1 != args[1].find("HDPLocal"):6554 res['a'] = 'http://newurl'6555 return res6556 load_stack_values_mock.side_effect = load_values_side_effect6557 properties = Properties()6558 get_ambari_properties_mock.return_value = properties6559 os_path_exists_mock.return_value = 16560 os_listdir_mock.return_value = ['1.1']6561 upgrade_local_repo(args)6562 self.assertTrue(get_ambari_properties_mock.called)6563 self.assertTrue(load_stack_values_mock.called)6564 self.assertTrue(run_metainfo_upgrade_mock.called)6565 run_metainfo_upgrade_mock.assert_called_with({'a': 'http://newurl'})6566 pass6567 @patch("os.listdir")6568 @patch("os.path.exists")6569 @patch("ambari_server.serverUpgrade.load_stack_values")6570 @patch("ambari_server.serverUpgrade.get_ambari_properties")6571 @patch("ambari_server.serverUpgrade.run_metainfo_upgrade")6572 def test_upgrade_local_repo_nochange(self,6573 run_metainfo_upgrade_mock,6574 get_ambari_properties_mock,6575 load_stack_values_mock,6576 os_path_exists_mock,6577 os_listdir_mock):6578 from mock.mock import call6579 args = MagicMock()6580 args.persistence_type = "local"6581 def load_values_side_effect(*args, **kwargs):6582 res = {}6583 res['a'] = 'http://oldurl'6584 return res6585 load_stack_values_mock.side_effect = load_values_side_effect6586 properties = Properties()6587 get_ambari_properties_mock.return_value = properties6588 os_path_exists_mock.return_value = 16589 os_listdir_mock.return_value = ['1.1']6590 upgrade_local_repo(args)6591 self.assertTrue(get_ambari_properties_mock.called)6592 self.assertTrue(load_stack_values_mock.called)6593 self.assertTrue(run_metainfo_upgrade_mock.called)6594 run_metainfo_upgrade_mock.assert_called_with({})6595 pass6596 @patch("os.path.exists")6597 @patch.object(ResourceFilesKeeper, "perform_housekeeping")6598 def test_refresh_stack_hash(self,6599 perform_housekeeping_mock, path_exists_mock):6600 path_exists_mock.return_value = True6601 properties = Properties()6602 refresh_stack_hash(properties)6603 self.assertTrue(perform_housekeeping_mock.called)6604 pass6605 @not_for_platform(PLATFORM_WINDOWS)6606 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))6607 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))6608 @patch("ambari_server.dbConfiguration_linux.run_os_command")6609 @patch("ambari_server.dbConfiguration_linux.print_error_msg")6610 def test_change_objects_owner_both(self,6611 print_error_msg_mock,6612 run_os_command_mock):6613 args = MagicMock()6614 args.master_key = None6615 del args.database_index6616 del args.dbms6617 del args.database_host6618 del args.database_port6619 del args.database_name6620 del args.database_username6621 del args.database_password6622 del args.persistence_type6623 stdout = " stdout "6624 stderr = " stderr "6625 run_os_command_mock.return_value = 1, stdout, stderr6626 set_verbose(True)6627 self.assertRaises(FatalException, change_objects_owner, args)6628 print_error_msg_mock.assert_any_call("stderr:\nstderr")6629 print_error_msg_mock.assert_any_call("stdout:\nstdout")6630 pass6631 @not_for_platform(PLATFORM_WINDOWS)6632 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))6633 @patch("ambari_server.dbConfiguration_linux.run_os_command")6634 @patch("ambari_server.dbConfiguration_linux.print_error_msg")6635 def test_change_objects_owner_only_stdout(self,6636 print_error_msg_mock,6637 run_os_command_mock):6638 args = MagicMock()6639 del args.database_index6640 del args.dbms6641 del args.database_host6642 del args.database_port6643 del args.database_name6644 del args.database_username6645 del args.database_password6646 del args.persistence_type6647 stdout = " stdout "6648 stderr = ""6649 run_os_command_mock.return_value = 1, stdout, stderr6650 set_verbose(True)6651 self.assertRaises(FatalException, change_objects_owner, args)6652 print_error_msg_mock.assert_called_once_with("stdout:\nstdout")6653 pass6654 @not_for_platform(PLATFORM_WINDOWS)6655 @patch.object(OSCheck, "os_distribution", new = MagicMock(return_value = os_distro_value))6656 @patch("ambari_server.dbConfiguration_linux.run_os_command")6657 @patch("ambari_server.dbConfiguration_linux.print_error_msg")6658 def test_change_objects_owner_only_stderr(self,6659 print_error_msg_mock,6660 run_os_command_mock):6661 args = MagicMock()6662 del args.database_index6663 del args.dbms6664 del args.database_host6665 del args.database_port6666 del args.database_name6667 del args.database_username6668 del args.database_password6669 del args.persistence_type6670 stdout = ""6671 stderr = " stderr "6672 run_os_command_mock.return_value = 1, stdout, stderr6673 set_verbose(True)6674 self.assertRaises(FatalException, change_objects_owner, args)6675 print_error_msg_mock.assert_called_once_with("stderr:\nstderr")...

Full Screen

Full Screen

TestAmbaryServer.py

Source:TestAmbaryServer.py Github

copy

Full Screen

1'''2Licensed to the Apache Software Foundation (ASF) under one3or more contributor license agreements. See the NOTICE file4distributed with this work for additional information5regarding copyright ownership. The ASF licenses this file6to you under the Apache License, Version 2.0 (the7"License"); you may not use this file except in compliance8with the License. You may obtain a copy of the License at9 http://www.apache.org/licenses/LICENSE-2.010Unless required by applicable law or agreed to in writing, software11distributed under the License is distributed on an "AS IS" BASIS,12WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.13See the License for the specific language governing permissions and14limitations under the License.15'''16import StringIO17import re18from unittest import TestCase19import sys20from mock.mock import patch21from mock.mock import MagicMock22from mock.mock import create_autospec23import os, errno, tempfile24import signal25import stat26import datetime27import operator28from pwd import getpwnam29# We have to use this import HACK because the filename contains a dash30ambari_server = __import__('ambari-server')31FatalException = ambari_server.FatalException32NonFatalException = ambari_server.NonFatalException33class TestAmbariServer(TestCase):34 def setUp(self):35 out = StringIO.StringIO()36 sys.stdout = out37 def tearDown(self):38 sys.stdout = sys.__stdout__39 @patch.object(ambari_server, 'configure_database_username_password')40 @patch.object(ambari_server, 'run_os_command')41 @patch('optparse.Values')42 def test_configure_pg_hba_ambaridb_users(self, OptParseValuesMock,43 run_os_command_method,44 configure_database_username_password_method):45 # Prepare mocks46 run_os_command_method.return_value = (0, "", "")47 opvm = OptParseValuesMock.return_value48 opvm.database_username = "ffdf"49 tf1 = tempfile.NamedTemporaryFile()50 ambari_server.PG_HBA_CONF_FILE = tf1.name51 # Run test52 ambari_server.configure_pg_hba_ambaridb_users()53 # Check results54 self.assertTrue(run_os_command_method.called)55 self.assertTrue(configure_database_username_password_method.called)56 string_expected = self.get_file_string(self57 .get_samples_dir("configure_pg_hba_ambaridb_users1"))58 string_actual = self.get_file_string(ambari_server.PG_HBA_CONF_FILE)59 self.assertEquals(string_expected, string_actual)60 pass61 @patch('__builtin__.raw_input')62 def test_servicename_regex(self, raw_input_method):63 ''' Test to make sure the service name can contain digits '''64 ambari_server.SILENT = False65 raw_input_method.return_value = "OT100"66 result = ambari_server.get_validated_service_name("ambari", 1)67 self.assertEqual("OT100", result, "Not accepting digits")68 pass69 70 @patch('__builtin__.raw_input')71 def test_dbname_regex(self, raw_input_method):72 ''' Test to make sure the service name can contain digits '''73 ambari_server.SILENT = False74 raw_input_method.return_value = "OT100"75 result = ambari_server.get_validated_db_name("ambari")76 self.assertEqual("OT100", result, "Not accepting digits")77 78 def test_configure_pg_hba_postgres_user(self):79 tf1 = tempfile.NamedTemporaryFile()80 ambari_server.PG_HBA_CONF_FILE = tf1.name81 with open(ambari_server.PG_HBA_CONF_FILE, 'w') as fout:82 fout.write("\n")83 fout.write("local all all md5\n")84 fout.write("host all all 0.0.0.0/0 md5\n")85 fout.write("host all all ::/0 md5\n")86 ambari_server.configure_pg_hba_postgres_user()87 expected = self.get_file_string(self.get_samples_dir(88 "configure_pg_hba_ambaridb_users2"))89 result = self.get_file_string(ambari_server.PG_HBA_CONF_FILE)90 self.assertEqual(expected, result, "pg_hba_conf not processed")91 mode = oct(os.stat(ambari_server.PG_HBA_CONF_FILE)[stat.ST_MODE])92 str_mode = str(mode)[-4:]93 self.assertEqual("0644", str_mode, "Wrong file permissions")94 @patch('__builtin__.raw_input')95 def get_choice_string_input(self, raw_input_method):96 prompt = "blablabla"97 default = "default blablabla"98 firstChoice = set(['yes','ye', 'y'])99 secondChoice = set(['no','n'])100 # test first input101 raw_input_method.return_value = "Y"102 result = ambari_server.get_choice_string_input(prompt, default,103 firstChoice, secondChoice)104 self.assertEquals(result, True)105 raw_input_method.reset_mock()106 # test second input107 raw_input_method.return_value = "N"108 result = ambari_server.get_choice_string_input(prompt, default,109 firstChoice, secondChoice)110 self.assertEquals(result, False)111 raw_input_method.reset_mock()112 # test enter pressed113 raw_input_method.return_value = ""114 result = ambari_server.get_choice_string_input(prompt, default,115 firstChoice, secondChoice)116 self.assertEquals(result, default)117 raw_input_method.reset_mock()118 # test wrong input119 list_of_return_values= ['yes', 'dsad', 'fdsfds']120 def side_effect(list):121 return list_of_return_values.pop()122 raw_input_method.side_effect = side_effect123 result = ambari_server.get_choice_string_input(prompt, default,124 firstChoice, secondChoice)125 self.assertEquals(result, True)126 self.assertEquals(raw_input_method.call_count, 3)127 pass128 @patch('re.search')129 @patch('__builtin__.raw_input')130 @patch('getpass.getpass')131 def get_validated_string_input(self, get_pass_method,132 raw_input_method, re_search_method):133 prompt = "blabla"134 default = "default_pass"135 pattern = "pattern_pp"136 description = "blabla2"137 # check password input138 self.assertFalse(False, ambari_server.SILENT)139 is_pass = True140 get_pass_method.return_value = "dfdsfdsfds"141 result = ambari_server.get_validated_string_input(prompt, default,142 pattern, description, is_pass)143 self.assertEquals(get_pass_method.return_value, result)144 get_pass_method.assure_called_once(prompt)145 self.assertFalse(raw_input_method.called)146 # check raw input147 get_pass_method.reset_mock()148 raw_input_method.reset_mock()149 is_pass = False150 raw_input_method.return_value = "dkf90ewuf0"151 result = ambari_server.get_validated_string_input(prompt, default,152 pattern, description, is_pass)153 self.assertEquals(raw_input_method.return_value, result)154 self.assertFalse(get_pass_method.called)155 raw_input_method.assure_called_once(prompt)156 def test_get_pass_file_path(self):157 result = ambari_server.get_pass_file_path("/etc/ambari/conf_file")158 self.assertEquals("/etc/ambari/password.dat", result)159 pass160 @patch.object(ambari_server, 'setup')161 @patch.object(ambari_server, 'start')162 @patch.object(ambari_server, 'stop')163 @patch.object(ambari_server, 'reset')164 @patch('optparse.OptionParser')165 def test_main_test_setup(self, OptionParserMock, reset_method, stop_method,166 start_method, setup_method):167 opm = OptionParserMock.return_value168 options = MagicMock()169 args = ["setup"]170 opm.parse_args.return_value = (options, args)171 options.database=None172 options.sid_or_sname = "sid"173 ambari_server.main()174 self.assertTrue(setup_method.called)175 self.assertFalse(start_method.called)176 self.assertFalse(stop_method.called)177 self.assertFalse(reset_method.called)178 self.assertFalse(False, ambari_server.VERBOSE)179 self.assertFalse(False, ambari_server.SILENT)180 @patch.object(ambari_server, 'setup')181 @patch.object(ambari_server, 'start')182 @patch.object(ambari_server, 'stop')183 @patch.object(ambari_server, 'reset')184 @patch('optparse.OptionParser')185 def test_main_test_start(self, OptionParserMock, reset_method, stop_method,186 start_method, setup_method):187 opm = OptionParserMock.return_value188 options = MagicMock()189 args = ["setup"]190 opm.parse_args.return_value = (options, args)191 options.database=None192 options.sid_or_sname = "sname"193 ambari_server.main()194 self.assertTrue(setup_method.called)195 self.assertFalse(start_method.called)196 self.assertFalse(stop_method.called)197 self.assertFalse(reset_method.called)198 self.assertFalse(False, ambari_server.VERBOSE)199 self.assertFalse(False, ambari_server.SILENT)200 @patch.object(ambari_server, 'setup')201 @patch.object(ambari_server, 'start')202 @patch.object(ambari_server, 'stop')203 @patch.object(ambari_server, 'reset')204 @patch('optparse.OptionParser')205 def test_main_test_start_debug_short(self, OptionParserMock, reset_method, stop_method,206 start_method, setup_method):207 opm = OptionParserMock.return_value208 options = MagicMock()209 args = ["start", "-g"]210 opm.parse_args.return_value = (options, args)211 options.database=None212 options.sid_or_sname = "sid"213 ambari_server.main()214 self.assertFalse(setup_method.called)215 self.assertTrue(start_method.called)216 self.assertFalse(stop_method.called)217 self.assertFalse(reset_method.called)218 self.assertTrue(ambari_server.SERVER_DEBUG_MODE) 219 @patch.object(ambari_server, 'setup')220 @patch.object(ambari_server, 'start')221 @patch.object(ambari_server, 'stop')222 @patch.object(ambari_server, 'reset')223 @patch('optparse.OptionParser')224 def test_main_test_start_debug_long(self, OptionParserMock, reset_method, stop_method,225 start_method, setup_method):226 opm = OptionParserMock.return_value227 options = MagicMock()228 args = ["start", "--debug"]229 opm.parse_args.return_value = (options, args)230 options.database=None231 options.sid_or_sname = "sid"232 ambari_server.main()233 self.assertFalse(setup_method.called)234 self.assertTrue(start_method.called)235 self.assertFalse(stop_method.called)236 self.assertFalse(reset_method.called)237 self.assertTrue(ambari_server.SERVER_DEBUG_MODE)238 @patch.object(ambari_server, 'setup')239 @patch.object(ambari_server, 'start')240 @patch.object(ambari_server, 'stop')241 @patch.object(ambari_server, 'reset')242 @patch('optparse.OptionParser')243 def test_main_test_stop(self, OptionParserMock, reset_method, stop_method,244 start_method, setup_method):245 opm = OptionParserMock.return_value246 options = MagicMock()247 args = ["stop"]248 opm.parse_args.return_value = (options, args)249 options.database = None250 options.sid_or_sname = "sid"251 ambari_server.main()252 self.assertFalse(setup_method.called)253 self.assertFalse(start_method.called)254 self.assertTrue(stop_method.called)255 self.assertFalse(reset_method.called)256 self.assertFalse(False, ambari_server.VERBOSE)257 self.assertFalse(False, ambari_server.SILENT)258 @patch.object(ambari_server, 'setup')259 @patch.object(ambari_server, 'start')260 @patch.object(ambari_server, 'stop')261 @patch.object(ambari_server, 'reset')262 @patch('optparse.OptionParser')263 def test_main_test_reset(self, OptionParserMock, reset_method, stop_method,264 start_method, setup_method):265 opm = OptionParserMock.return_value266 options = MagicMock()267 args = ["reset"]268 opm.parse_args.return_value = (options, args)269 options.database=None270 options.sid_or_sname = "sid"271 ambari_server.main()272 self.assertFalse(setup_method.called)273 self.assertFalse(start_method.called)274 self.assertFalse(stop_method.called)275 self.assertTrue(reset_method.called)276 self.assertFalse(False, ambari_server.VERBOSE)277 self.assertFalse(False, ambari_server.SILENT)278 def test_configure_postgresql_conf(self):279 tf1 = tempfile.NamedTemporaryFile()280 ambari_server.POSTGRESQL_CONF_FILE = tf1.name281 with open(ambari_server.POSTGRESQL_CONF_FILE, 'w') as f:282 f.write("#listen_addresses = '127.0.0.1' #\n")283 f.write("#listen_addresses = '127.0.0.1'")284 ambari_server.configure_postgresql_conf()285 expected = self.get_file_string(self.get_samples_dir(286 "configure_postgresql_conf1"))287 result = self.get_file_string(ambari_server.POSTGRESQL_CONF_FILE)288 self.assertEqual(expected, result, "postgresql.conf not updated")289 mode = oct(os.stat(ambari_server.POSTGRESQL_CONF_FILE)[stat.ST_MODE])290 str_mode = str(mode)[-4:]291 self.assertEqual("0644", str_mode, "Wrong file permissions")292 @patch.object(ambari_server, "restart_postgres")293 @patch.object(ambari_server, "get_postgre_status")294 @patch.object(ambari_server, "configure_postgresql_conf")295 @patch.object(ambari_server, "configure_pg_hba_ambaridb_users")296 @patch.object(ambari_server, "configure_pg_hba_postgres_user")297 def test_configure_postgres(self, configure_pg_hba_postgres_user_mock,298 configure_pg_hba_ambaridb_users_mock,299 configure_postgresql_conf_mock,300 get_postgre_status_mock,301 restart_postgres_mock):302 tf1 = tempfile.NamedTemporaryFile()303 tf2 = tempfile.NamedTemporaryFile()304 ambari_server.PG_HBA_CONF_FILE = tf1.name305 ambari_server.PG_HBA_CONF_FILE_BACKUP = tf2.name306 args = MagicMock()307 out = StringIO.StringIO()308 sys.stdout = out309 rcode = ambari_server.configure_postgres()310 sys.stdout = sys.__stdout__311 self.assertEqual(0, rcode)312 self.assertEqual("Backup for pg_hba found, reconfiguration not required\n",313 out.getvalue())314 ambari_server.PG_HBA_CONF_FILE_BACKUP = tempfile.mktemp()315 get_postgre_status_mock.return_value = ambari_server.PG_STATUS_RUNNING316 restart_postgres_mock.return_value = 0317 rcode = ambari_server.configure_postgres()318 self.assertTrue(os.path.isfile(ambari_server.PG_HBA_CONF_FILE_BACKUP),319 "postgresql.conf backup not created")320 self.assertTrue(configure_pg_hba_postgres_user_mock.called)321 self.assertTrue(configure_pg_hba_ambaridb_users_mock.called)322 mode = oct(os.stat(ambari_server.PG_HBA_CONF_FILE)[stat.ST_MODE])323 str_mode = str(mode)[-4:]324 self.assertEqual("0644", str_mode, "Wrong file permissions")325 self.assertTrue(configure_postgresql_conf_mock.called)326 self.assertEqual(0, rcode)327 os.unlink(ambari_server.PG_HBA_CONF_FILE_BACKUP)328 get_postgre_status_mock.return_value = "stopped"329 rcode = ambari_server.configure_postgres()330 self.assertEqual(0, rcode)331 os.unlink(ambari_server.PG_HBA_CONF_FILE_BACKUP)332 sys.stdout = sys.__stdout__333 @patch("time.sleep")334 @patch("subprocess.Popen")335 @patch.object(ambari_server, "run_os_command")336 @patch.object(ambari_server, "get_postgre_status")337 @patch.object(ambari_server, "print_info_msg")338 def test_restart_postgres(self, printInfoMsg_mock, get_postgre_status_mock,339 run_os_command_mock, popenMock, sleepMock):340 p = MagicMock()341 p.poll.return_value = 0342 popenMock.return_value = p343 rcode = ambari_server.restart_postgres()344 self.assertEqual(0, rcode)345 p.poll.return_value = None346 get_postgre_status_mock.return_value = "stopped"347 run_os_command_mock.return_value = (1, None, None)348 rcode = ambari_server.restart_postgres()349 self.assertEqual(1, rcode)350 @patch("shlex.split")351 @patch("subprocess.Popen")352 @patch.object(ambari_server, "print_info_msg")353 def test_run_os_command(self, printInfoMsg_mock, popenMock, splitMock):354 p = MagicMock()355 p.communicate.return_value = (None, None)356 p.returncode = 3357 popenMock.return_value = p358 # with list arg359 cmd = ["exec", "arg"]360 ambari_server.run_os_command(cmd)361 self.assertFalse(splitMock.called)362 # with str arg363 resp = ambari_server.run_os_command("runme")364 self.assertEqual(3, resp[0])365 self.assertTrue(splitMock.called)366 @patch.object(ambari_server, "get_conf_dir")367 @patch.object(ambari_server, "search_file")368 def test_write_property(self, search_file_mock, get_conf_dir_mock):369 expected_content = "key1=val1\n"370 tf1 = tempfile.NamedTemporaryFile()371 search_file_mock.return_value = tf1.name372 ambari_server.write_property("key1", "val1")373 result = tf1.read()374 self.assertTrue(expected_content in result)375 @patch.object(ambari_server, "configure_database_username_password")376 @patch.object(ambari_server, "run_os_command")377 def test_setup_db(self, run_os_command_mock,378 configure_database_username_password_mock):379 run_os_command_mock.return_value = (0, None, None)380 result = ambari_server.setup_db(MagicMock())381 self.assertTrue(configure_database_username_password_mock.called)382 self.assertEqual(0, result)383 @patch.object(ambari_server, "get_YN_input")384 @patch.object(ambari_server, "run_os_command")385 def test_check_selinux(self, run_os_command_mock, getYNInput_mock):386 run_os_command_mock.return_value = (0, ambari_server.SE_STATUS_DISABLED,387 None)388 rcode = ambari_server.check_selinux()389 self.assertEqual(0, rcode)390 getYNInput_mock.return_value = True391 run_os_command_mock.return_value = (0,"enabled "392 + ambari_server.SE_MODE_ENFORCING,393 None)394 rcode = ambari_server.check_selinux()395 self.assertEqual(0, rcode)396 self.assertTrue(run_os_command_mock.called)397 self.assertTrue(getYNInput_mock.called)398 @patch.object(ambari_server, "print_info_msg")399 def test_get_ambari_jars(self, printInfoMsg_mock):400 env = "/ambari/jars"401 os.environ[ambari_server.AMBARI_SERVER_LIB] = env402 result = ambari_server.get_ambari_jars()403 self.assertEqual(env, result)404 del os.environ[ambari_server.AMBARI_SERVER_LIB]405 result = ambari_server.get_ambari_jars()406 self.assertEqual("/usr/lib/ambari-server", result)407 self.assertTrue(printInfoMsg_mock.called)408 @patch("glob.glob")409 @patch.object(ambari_server, "print_info_msg")410 def test_get_share_jars(self, printInfoMsg_mock, globMock):411 globMock.return_value = ["one", "two"]412 expected = "one:two:one:two"413 result = ambari_server.get_share_jars()414 self.assertEqual(expected, result)415 globMock.return_value = []416 expected = ""417 result = ambari_server.get_share_jars()418 self.assertEqual(expected, result)419 @patch("glob.glob")420 @patch.object(ambari_server, "print_info_msg")421 def test_get_ambari_classpath(self, printInfoMsg_mock, globMock):422 globMock.return_value = ["one"]423 result = ambari_server.get_ambari_classpath()424 self.assertTrue(ambari_server.get_ambari_jars() in result)425 self.assertTrue(ambari_server.get_share_jars() in result)426 globMock.return_value = []427 result = ambari_server.get_ambari_classpath()428 self.assertTrue(ambari_server.get_ambari_jars() in result)429 self.assertFalse(":" in result)430 @patch.object(ambari_server, "print_info_msg")431 def test_get_conf_dir(self, printInfoMsg_mock):432 env = "/dummy/ambari/conf"433 os.environ[ambari_server.AMBARI_CONF_VAR] = env434 result = ambari_server.get_conf_dir()435 self.assertEqual(env, result)436 del os.environ[ambari_server.AMBARI_CONF_VAR]437 result = ambari_server.get_conf_dir()438 self.assertEqual("/etc/ambari-server/conf", result)439 def test_search_file(self):440 path = os.path.dirname(__file__)441 result = ambari_server.search_file(__file__, path)442 expected = os.path.abspath(__file__)443 self.assertEqual(expected, result)444 result = ambari_server.search_file("non_existent_file", path)445 self.assertEqual(None, result)446 @patch.object(ambari_server, "search_file")447 def test_find_properties_file(self, search_file_mock):448 # Testing case when file is not found449 search_file_mock.return_value = None450 try:451 ambari_server.find_properties_file()452 self.fail("File not found'")453 except FatalException:454 # Expected455 pass456 self.assertTrue(search_file_mock.called)457 # Testing case when file is found458 value = MagicMock()459 search_file_mock.return_value = value460 result = ambari_server.find_properties_file()461 self.assertTrue(result is value)462 @patch.object(ambari_server, "find_properties_file")463 @patch("__builtin__.open")464 @patch("ambari-server.Properties")465 def test_read_ambari_user(self, properties_mock, open_mock, find_properties_file_mock):466 open_mock.return_value = "dummy"467 find_properties_file_mock.return_value = "dummy"468 # Testing with defined user469 properties_mock.return_value.__getitem__.return_value = "dummy_user"470 user = ambari_server.read_ambari_user()471 self.assertEquals(user, "dummy_user")472 # Testing with undefined user473 properties_mock.return_value.__getitem__.return_value = None474 user = ambari_server.read_ambari_user()475 self.assertEquals(user, None)476 @patch("os.path.exists")477 @patch.object(ambari_server, "set_file_permissions")478 @patch.object(ambari_server, "run_os_command")479 @patch.object(ambari_server, "get_ambari_properties")480 @patch.object(ambari_server, "get_value_from_properties")481 @patch("os.mkdir")482 def test_adjust_directory_permissions(self, mkdir_mock,483 get_value_from_properties_mock, get_ambari_properties_mock,484 run_os_command_mock, set_file_permissions_mock, exists_mock):485 # Testing boostrap dir wipe486 properties_mock = MagicMock()487 get_value_from_properties_mock.return_value = "dummy_bootstrap_dir"488 ambari_server.adjust_directory_permissions("user")489 exists_mock.return_value = False490 self.assertEquals(run_os_command_mock.call_args_list[0][0][0], "rm -rf dummy_bootstrap_dir")491 self.assertTrue(mkdir_mock.called)492 set_file_permissions_mock.reset_mock()493 # Test recursive calls494 old_list = ambari_server.NR_ADJUST_OWNERSHIP_LIST495 ambari_server.NR_ADJUST_OWNERSHIP_LIST = [496 ( "/etc/ambari-server/conf", "755", "{0}", True ),497 ( "/etc/ambari-server/conf/ambari.properties", "644", "{0}", False )498 ]499 ambari_server.adjust_directory_permissions("user")500 self.assertTrue(len(set_file_permissions_mock.call_args_list) ==501 len(ambari_server.NR_ADJUST_OWNERSHIP_LIST))502 self.assertEquals(set_file_permissions_mock.call_args_list[0][0][3], True)503 self.assertEquals(set_file_permissions_mock.call_args_list[1][0][3], False)504 ambari_server.NR_ADJUST_OWNERSHIP_LIST = old_list505 @patch("os.path.exists")506 @patch.object(ambari_server, "run_os_command")507 @patch.object(ambari_server, "print_warning_msg")508 @patch.object(ambari_server, "print_info_msg")509 def test_set_file_permissions(self, print_info_msg_mock, print_warning_msg_mock,510 run_os_command_mock, exists_mock):511 # Testing not existent file scenario512 exists_mock.return_value = False513 ambari_server.set_file_permissions("dummy-file", "dummy-mod",514 "dummy-user", False)515 self.assertFalse(run_os_command_mock.called)516 self.assertTrue(print_info_msg_mock.called)517 run_os_command_mock.reset_mock()518 print_warning_msg_mock.reset_mock()519 # Testing OK scenario520 exists_mock.return_value = True521 run_os_command_mock.side_effect = [(0, "", ""), (0, "", "")]522 ambari_server.set_file_permissions("dummy-file", "dummy-mod",523 "dummy-user", False)524 self.assertTrue(len(run_os_command_mock.call_args_list) == 2)525 self.assertFalse(print_warning_msg_mock.called)526 run_os_command_mock.reset_mock()527 print_warning_msg_mock.reset_mock()528 # Testing first command fail529 run_os_command_mock.side_effect = [(1, "", ""), (0, "", "")]530 ambari_server.set_file_permissions("dummy-file", "dummy-mod",531 "dummy-user", False)532 self.assertTrue(len(run_os_command_mock.call_args_list) == 2)533 self.assertTrue(print_warning_msg_mock.called)534 run_os_command_mock.reset_mock()535 print_warning_msg_mock.reset_mock()536 # Testing second command fail537 run_os_command_mock.side_effect = [(0, "", ""), (1, "", "")]538 ambari_server.set_file_permissions("dummy-file", "dummy-mod",539 "dummy-user", False)540 self.assertTrue(len(run_os_command_mock.call_args_list) == 2)541 self.assertTrue(print_warning_msg_mock.called)542 run_os_command_mock.reset_mock()543 print_warning_msg_mock.reset_mock()544 # Testing recursive operation545 exists_mock.return_value = True546 run_os_command_mock.side_effect = [(0, "", ""), (0, "", "")]547 ambari_server.set_file_permissions("dummy-file", "dummy-mod",548 "dummy-user", True)549 self.assertTrue(len(run_os_command_mock.call_args_list) == 2)550 self.assertTrue("-R" in run_os_command_mock.call_args_list[0][0][0])551 self.assertTrue("-R" in run_os_command_mock.call_args_list[1][0][0])552 self.assertFalse(print_warning_msg_mock.called)553 run_os_command_mock.reset_mock()554 print_warning_msg_mock.reset_mock()555 # Testing non-recursive operation556 exists_mock.return_value = True557 run_os_command_mock.side_effect = [(0, "", ""), (0, "", "")]558 ambari_server.set_file_permissions("dummy-file", "dummy-mod",559 "dummy-user", False)560 self.assertTrue(len(run_os_command_mock.call_args_list) == 2)561 self.assertFalse("-R" in run_os_command_mock.call_args_list[0][0][0])562 self.assertFalse("-R" in run_os_command_mock.call_args_list[1][0][0])563 self.assertFalse(print_warning_msg_mock.called)564 run_os_command_mock.reset_mock()565 print_warning_msg_mock.reset_mock()566 @patch.object(ambari_server, "get_validated_string_input")567 @patch.object(ambari_server, "print_info_msg")568 @patch.object(ambari_server, "print_warning_msg")569 @patch.object(ambari_server, "run_os_command")570 def test_create_custom_user(self, run_os_command_mock, print_warning_msg_mock,571 print_info_msg_mock, get_validated_string_input_mock):572 user = "dummy-user"573 get_validated_string_input_mock.return_value = user574 # Testing scenario: absent user575 run_os_command_mock.side_effect = [(0, "", "")]576 result = ambari_server.create_custom_user()577 self.assertFalse(print_warning_msg_mock.called)578 self.assertEquals(result, (0, user))579 print_info_msg_mock.reset_mock()580 print_warning_msg_mock.reset_mock()581 run_os_command_mock.reset_mock()582 # Testing scenario: existing user583 run_os_command_mock.side_effect = [(9, "", "")]584 result = ambari_server.create_custom_user()585 self.assertTrue("User dummy-user already exists" in str(print_info_msg_mock.call_args_list[1][0]))586 self.assertEquals(result, (0, user))587 print_info_msg_mock.reset_mock()588 print_warning_msg_mock.reset_mock()589 run_os_command_mock.reset_mock()590 # Testing scenario: os command fail591 run_os_command_mock.side_effect = [(1, "", "")]592 result = ambari_server.create_custom_user()593 self.assertTrue(print_warning_msg_mock.called)594 self.assertEquals(result, (1, None))595 @patch.object(ambari_server, "read_ambari_user")596 @patch.object(ambari_server, "get_YN_input")597 @patch.object(ambari_server, "create_custom_user")598 @patch.object(ambari_server, "write_property")599 @patch.object(ambari_server, "adjust_directory_permissions")600 @patch.object(ambari_server, "print_error_msg")601 def test_check_ambari_user(self, print_error_msg_mock,602 adjust_directory_permissions_mock, write_property_mock,603 create_custom_user_mock, get_YN_input_mock, read_ambari_user_mock):604 # Scenario: user is already defined, user does not want to reconfigure it605 read_ambari_user_mock.return_value = "dummy-user"606 get_YN_input_mock.return_value = False607 result = ambari_server.check_ambari_user()608 self.assertTrue(get_YN_input_mock.called)609 self.assertFalse(write_property_mock.called)610 self.assertFalse(create_custom_user_mock.called)611 self.assertTrue(adjust_directory_permissions_mock.called)612 self.assertEqual(result, 0)613 get_YN_input_mock.reset_mock()614 write_property_mock.reset_mock()615 adjust_directory_permissions_mock.reset_mock()616 create_custom_user_mock.reset_mock()617 # Scenario: user is already defined, but user wants to reconfigure it618 read_ambari_user_mock.return_value = "dummy-user"619 create_custom_user_mock.return_value = (0, "new-dummy-user")620 get_YN_input_mock.return_value = True621 result = ambari_server.check_ambari_user()622 self.assertTrue(get_YN_input_mock.called)623 self.assertTrue(write_property_mock.called)624 self.assertTrue(write_property_mock.call_args[0][1] == "new-dummy-user")625 self.assertTrue(create_custom_user_mock.called)626 self.assertTrue(adjust_directory_permissions_mock.called)627 self.assertEqual(result, 0)628 get_YN_input_mock.reset_mock()629 write_property_mock.reset_mock()630 adjust_directory_permissions_mock.reset_mock()631 create_custom_user_mock.reset_mock()632 # Negative scenario: user is already defined, but user wants633 # to reconfigure it, user creation failed634 read_ambari_user_mock.return_value = "dummy-user"635 create_custom_user_mock.return_value = (1, None)636 get_YN_input_mock.return_value = True637 result = ambari_server.check_ambari_user()638 self.assertTrue(get_YN_input_mock.called)639 self.assertTrue(create_custom_user_mock.called)640 self.assertFalse(write_property_mock.called)641 self.assertFalse(adjust_directory_permissions_mock.called)642 self.assertEqual(result, 1)643 get_YN_input_mock.reset_mock()644 create_custom_user_mock.reset_mock()645 write_property_mock.reset_mock()646 adjust_directory_permissions_mock.reset_mock()647 # Scenario: user is not defined (setup process)648 read_ambari_user_mock.return_value = None649 get_YN_input_mock.return_value = True650 create_custom_user_mock.return_value = (0, "dummy-user")651 result = ambari_server.check_ambari_user()652 self.assertTrue(get_YN_input_mock.called)653 self.assertTrue(create_custom_user_mock.called)654 self.assertTrue(write_property_mock.called)655 self.assertTrue(write_property_mock.call_args[0][1] == "dummy-user")656 self.assertTrue(adjust_directory_permissions_mock.called)657 self.assertEqual(result, 0)658 get_YN_input_mock.reset_mock()659 create_custom_user_mock.reset_mock()660 write_property_mock.reset_mock()661 adjust_directory_permissions_mock.reset_mock()662 # Scenario: user is not defined (setup process), user creation failed663 read_ambari_user_mock.return_value = None664 get_YN_input_mock.return_value = True665 create_custom_user_mock.return_value = (1, None)666 result = ambari_server.check_ambari_user()667 self.assertTrue(get_YN_input_mock.called)668 self.assertTrue(create_custom_user_mock.called)669 self.assertFalse(write_property_mock.called)670 self.assertFalse(adjust_directory_permissions_mock.called)671 self.assertEqual(result, 1)672 get_YN_input_mock.reset_mock()673 create_custom_user_mock.reset_mock()674 write_property_mock.reset_mock()675 adjust_directory_permissions_mock.reset_mock()676 # negative scenario: user is not defined (setup process), user creation failed677 read_ambari_user_mock.return_value = None678 get_YN_input_mock.return_value = True679 create_custom_user_mock.return_value = (1, None)680 result = ambari_server.check_ambari_user()681 self.assertTrue(get_YN_input_mock.called)682 self.assertTrue(create_custom_user_mock.called)683 self.assertFalse(write_property_mock.called)684 self.assertFalse(adjust_directory_permissions_mock.called)685 self.assertEqual(result, 1)686 get_YN_input_mock.reset_mock()687 create_custom_user_mock.reset_mock()688 write_property_mock.reset_mock()689 adjust_directory_permissions_mock.reset_mock()690 # Scenario: user is not defined and left to be root691 read_ambari_user_mock.return_value = None692 get_YN_input_mock.return_value = False693 result = ambari_server.check_ambari_user()694 self.assertTrue(get_YN_input_mock.called)695 self.assertFalse(create_custom_user_mock.called)696 self.assertTrue(write_property_mock.called)697 self.assertTrue(write_property_mock.call_args[0][1] == "root")698 self.assertTrue(adjust_directory_permissions_mock.called)699 self.assertEqual(result, 0)700 @patch.object(ambari_server, "search_file")701 @patch("__builtin__.open")702 @patch.object(ambari_server, "read_ambari_user")703 @patch.object(ambari_server, "set_file_permissions")704 def test_store_password_file(self, set_file_permissions_mock,705 read_ambari_user_mock, open_mock, search_file_mock):706 search_file_mock.return_value = "/etc/ambari-server/conf/ambari.properties"707 open_mock.return_value = MagicMock()708 ambari_server.store_password_file("password", "passfile")709 self.assertTrue(set_file_permissions_mock.called)710 @patch.object(ambari_server, "run_os_command")711 def test_check_iptables(self, run_os_command_mock):712 run_os_command_mock.return_value = (1, "test", "")713 rcode, info = ambari_server.check_iptables()714 self.assertEqual(1, rcode)715 self.assertEqual("test", info)716 run_os_command_mock.return_value = (2, "",717 ambari_server.IP_TBLS_SRVC_NT_FND)718 rcode = ambari_server.check_iptables()719 self.assertEqual(0, rcode)720 def test_dlprogress(self):721 out = StringIO.StringIO()722 sys.stdout = out723 ambari_server.dlprogress("filename", 10, 2, 100)724 sys.stdout = sys.__stdout__725 self.assertNotEqual("", out.getvalue())726 @patch("urllib2.urlopen")727 @patch("__builtin__.open")728 @patch.object(ambari_server, "dlprogress")729 def test_track_jdk(self, dlprogress_mock, openMock, urlopenMock):730 u = MagicMock()731 u.info.return_value = {"Content-Length":"24576"}732 chunks = [None, "second", "first"]733 def side_effect(*args, **kwargs):734 return chunks.pop()735 u.read.side_effect = side_effect736 urlopenMock.return_value = u737 f = MagicMock()738 openMock.return_value = f739 ambari_server.track_jdk("base", "url", "local")740 self.assertEqual(0, len(chunks))741 self.assertTrue(f.write.called)742 self.assertTrue(f.flush.called)743 self.assertTrue(f.close.called)744 self.assertEqual(2, len(dlprogress_mock.call_args_list))745 @patch("shutil.copy")746 @patch("os.path.join")747 @patch("os.path.exists")748 @patch.object(ambari_server, "get_ambari_properties")749 def test_install_jce_manualy(self, get_ambari_properties_mock,\750 os_path_exists_mock, os_path_join_mock,\751 shutil_copy_mock):752 args = MagicMock()753 args.jce_policy = "somewhere"754 p = MagicMock()755 get_ambari_properties_mock.return_value = p756 p.__getitem__.side_effect = None757 p.__getitem__.return_value = "somewhere"758 os_path_exists_mock.return_value = True759 os_path_join_mock.return_value = \760 "/var/lib/ambari-server/resources/jce_policy-6.zip" 761 ambari_server.install_jce_manualy(args) 762 self.assertTrue(shutil_copy_mock.called)763 shutil_copy_mock.side_effect = Exception("exception")764 try:765 ambari_server.install_jce_manualy(args)766 self.fail("Should throw exception because of not found jce_policy-6.zip")767 except Exception:768 # Expected769 self.assertTrue(shutil_copy_mock.called)770 pass 771 shutil_copy_mock.side_effect = None772 args.jce_policy = None773 ambari_server.install_jce_manualy(args)774 @patch.object(ambari_server, 'read_ambari_user')775 @patch.object(ambari_server, "get_validated_string_input")776 @patch.object(ambari_server, "find_properties_file")777 @patch.object(ambari_server, "get_ambari_properties")778 @patch.object(ambari_server, "is_server_runing")779 @patch.object(ambari_server, "import_cert_and_key_action") 780 @patch.object(ambari_server, "get_YN_input") 781 @patch("__builtin__.open")782 @patch("ambari-server.Properties")783 @patch.object(ambari_server, "is_root")784 @patch.object(ambari_server, "is_valid_cert_host") 785 @patch.object(ambari_server, "is_valid_cert_exp") 786 def test_setup_https(self, is_valid_cert_exp_mock, is_valid_cert_host_mock,\787 is_root_mock, Properties_mock, open_Mock, get_YN_input_mock,\788 import_cert_and_key_action_mock,789 is_server_runing_mock, get_ambari_properties_mock,\790 find_properties_file_mock,\791 get_validated_string_input_mock,792 read_ambari_user_method):793 794 is_valid_cert_exp_mock.return_value=True795 is_valid_cert_host_mock.return_value=True796 args = MagicMock()797 open_Mock.return_value = file798 p = get_ambari_properties_mock.return_value799 # Testing call under non-root800 is_root_mock.return_value = False801 try:802 ambari_server.setup_https(args)803 self.fail("Should throw exception")804 except FatalException as fe:805 # Expected806 self.assertTrue("root-level" in fe.reason)807 pass808 # Testing call under root809 is_root_mock.return_value = True810 read_ambari_user_method.return_value = None811 #Case #1: if client ssl is on and user didnt choose 812 #disable ssl option and choose import certs and keys813 p.get_property.side_effect = ["key_dir","5555","6666", "true"]814 get_YN_input_mock.side_effect = [False,True]815 get_validated_string_input_mock.side_effect = ["4444"]816 get_property_expected = "[call('security.server.keys_dir'),\n"+\817 " call('client.api.ssl.port'),\n"+\818 " call('client.api.ssl.port'),\n call('api.ssl')]"819 process_pair_expected = "[call('client.api.ssl.port', '4444')]"820 ambari_server.SILENT = False821 ambari_server.setup_https(args)822 823 self.assertTrue(p.process_pair.called)824 self.assertTrue(p.get_property.call_count == 4)825 self.assertEqual(str(p.get_property.call_args_list), get_property_expected)826 self.assertEqual(str(p.process_pair.call_args_list), process_pair_expected)827 self.assertTrue(p.store.called)828 self.assertTrue(import_cert_and_key_action_mock.called)829 p.process_pair.reset_mock()830 p.get_property.reset_mock()831 p.store.reset_mock()832 import_cert_and_key_action_mock.reset_mock()833 #Case #2: if client ssl is on and user choose to disable ssl option834 p.get_property.side_effect = ["key_dir","", "true"]835 get_YN_input_mock.side_effect = [True]836 get_validated_string_input_mock.side_effect = ["4444"]837 get_property_expected = "[call('security.server.keys_dir'),\n"+\838 " call('client.api.ssl.port'),\n call('api.ssl')]"839 process_pair_expected = "[call('api.ssl', 'false')]"840 ambari_server.setup_https(args)841 842 self.assertTrue(p.process_pair.called)843 self.assertTrue(p.get_property.call_count == 3)844 self.assertEqual(str(p.get_property.call_args_list), get_property_expected)845 self.assertEqual(str(p.process_pair.call_args_list), process_pair_expected)846 self.assertTrue(p.store.called)847 self.assertFalse(import_cert_and_key_action_mock.called)848 p.process_pair.reset_mock()849 p.get_property.reset_mock()850 p.store.reset_mock()851 import_cert_and_key_action_mock.reset_mock()852 #Case #3: if client ssl is off and user choose option 853 #to import cert and keys854 p.get_property.side_effect = ["key_dir","", None]855 get_YN_input_mock.side_effect = [True, True]856 get_validated_string_input_mock.side_effect = ["4444"]857 get_property_expected = "[call('security.server.keys_dir'),\n"+\858 " call('client.api.ssl.port'),\n call('api.ssl')]"859 process_pair_expected = "[call('client.api.ssl.port', '4444')]"860 ambari_server.setup_https(args)861 self.assertTrue(p.process_pair.called)862 self.assertTrue(p.get_property.call_count == 3)863 self.assertEqual(str(p.get_property.call_args_list), get_property_expected)864 self.assertEqual(str(p.process_pair.call_args_list), process_pair_expected)865 self.assertTrue(p.store.called)866 self.assertTrue(import_cert_and_key_action_mock.called)867 p.process_pair.reset_mock()868 p.get_property.reset_mock()869 p.store.reset_mock()870 import_cert_and_key_action_mock.reset_mock()871 872 #Case #4: if client ssl is off and 873 #user did not choose option to import cert and keys874 p.get_property.side_effect = ["key_dir","", None]875 get_YN_input_mock.side_effect = [False]876 get_validated_string_input_mock.side_effect = ["4444"]877 get_property_expected = "[call('security.server.keys_dir'),\n"+\878 " call('client.api.ssl.port'),\n call('api.ssl')]"879 process_pair_expected = "[]"880 ambari_server.setup_https(args)881 self.assertFalse(p.process_pair.called)882 self.assertTrue(p.get_property.call_count == 3)883 self.assertEqual(str(p.get_property.call_args_list), get_property_expected)884 self.assertEqual(str(p.process_pair.call_args_list), process_pair_expected)885 self.assertFalse(p.store.called)886 self.assertFalse(import_cert_and_key_action_mock.called)887 p.process_pair.reset_mock()888 p.get_property.reset_mock()889 p.store.reset_mock()890 import_cert_and_key_action_mock.reset_mock() 891 ambari_server.SILENT = True892 893 @patch.object(ambari_server, "import_cert_and_key")894 def test_import_cert_and_key_action(self, import_cert_and_key_mock):895 import_cert_and_key_mock.return_value = True896 properties = MagicMock()897 properties.get_property.side_effect = ["key_dir","5555","6666", "true"]898 properties.process_pair = MagicMock()899 expect_process_pair = "[call('client.api.ssl.cert_name', 'https.crt'),\n"+\900 " call('client.api.ssl.key_name', 'https.key'),\n"+\901 " call('api.ssl', 'true')]"902 ambari_server.import_cert_and_key_action("key_dir", properties)903 904 self.assertEqual(str(properties.process_pair.call_args_list),\905 expect_process_pair)906 907 @patch.object(ambari_server, "remove_file")908 @patch.object(ambari_server, "copy_file")909 @patch.object(ambari_server, "read_ambari_user")910 @patch.object(ambari_server, "set_file_permissions")911 @patch.object(ambari_server, "import_file_to_keystore")912 @patch("__builtin__.open")913 @patch.object(ambari_server, "run_os_command")914 @patch("os.path.join")915 @patch.object(ambari_server, "get_validated_filepath_input")916 @patch.object(ambari_server, "get_validated_string_input")917 @patch.object(ambari_server, "is_valid_cert_host") 918 @patch.object(ambari_server, "is_valid_cert_exp") 919 def test_import_cert_and_key(self,is_valid_cert_exp_mock,\920 is_valid_cert_host_mock,\921 get_validated_string_input_mock,\922 get_validated_filepath_input_mock,\923 os_path_join_mock, run_os_command_mock,\924 open_mock, import_file_to_keystore_mock,\925 set_file_permissions_mock, read_ambari_user_mock, copy_file_mock,\926 remove_file_mock):927 is_valid_cert_exp_mock.return_value=True928 is_valid_cert_host_mock.return_value=True929 get_validated_string_input_mock.return_value = "password"930 get_validated_filepath_input_mock.side_effect = \931 ["cert_file_path","key_file_path"]932 os_path_join_mock.side_effect = ["keystore_file_path", "keystore_file_path_tmp",\933 "pass_file_path", "pass_file_path_tmp",\934 "passin_file_path","password_file_path",\935 "keystore_cert_file_path",\936 "keystore_cert_key_file_path",]937 run_os_command_mock.return_value = (0, "", "")938 om = open_mock.return_value939 expect_import_file_to_keystore = "[call('keystore_file_path_tmp',"+\940 " 'keystore_file_path'),\n"+\941 " call('pass_file_path_tmp',"+\942 " 'pass_file_path'),\n"+\943 " call('cert_file_path',"+\944 " 'keystore_cert_file_path'),\n"+\945 " call('key_file_path',"+\946 " 'keystore_cert_key_file_path')]"947 ambari_server.import_cert_and_key("key_dir")948 self.assertTrue(get_validated_filepath_input_mock.call_count == 2)949 self.assertTrue(get_validated_string_input_mock.called)950 self.assertEqual(os_path_join_mock.call_count, 8)951 self.assertTrue(set_file_permissions_mock.call_count == 1)952 self.assertEqual(str(import_file_to_keystore_mock.call_args_list),\953 expect_import_file_to_keystore)954 @patch.object(ambari_server, "remove_file")955 @patch.object(ambari_server, "copy_file")956 @patch.object(ambari_server, "generate_random_string")957 @patch.object(ambari_server, "read_ambari_user")958 @patch.object(ambari_server, "set_file_permissions")959 @patch.object(ambari_server, "import_file_to_keystore")960 @patch("__builtin__.open")961 @patch.object(ambari_server, "run_os_command")962 @patch("os.path.join")963 @patch.object(ambari_server, "get_validated_filepath_input")964 @patch.object(ambari_server, "get_validated_string_input")965 @patch.object(ambari_server, "is_valid_cert_host") 966 @patch.object(ambari_server, "is_valid_cert_exp") 967 def test_import_cert_and_key_with_empty_password(self, \968 is_valid_cert_exp_mock, is_valid_cert_host_mock, 969 get_validated_string_input_mock, get_validated_filepath_input_mock,\970 os_path_join_mock, run_os_command_mock, open_mock, \971 import_file_to_keystore_mock, set_file_permissions_mock,972 read_ambari_user_mock, generate_random_string_mock, copy_file_mock,\973 remove_file_mock):974 975 is_valid_cert_exp_mock.return_value=True976 is_valid_cert_host_mock.return_value=True977 get_validated_string_input_mock.return_value = ""978 get_validated_filepath_input_mock.side_effect =\979 ["cert_file_path","key_file_path"]980 os_path_join_mock.side_effect = ["keystore_file_path", "keystore_file_path_tmp",\981 "pass_file_path", "pass_file_path_tmp",\982 "passin_file_path","password_file_path",\983 "keystore_cert_file_path",\984 "keystore_cert_key_file_path",]985 run_os_command_mock.return_value = (0, "", "")986 expect_import_file_to_keystore = "[call('keystore_file_path_tmp',"+\987 " 'keystore_file_path'),\n"+\988 " call('pass_file_path_tmp',"+\989 " 'pass_file_path'),\n"+\990 " call('cert_file_path',"+\991 " 'keystore_cert_file_path'),\n"+\992 " call('key_file_path.secured',"+\993 " 'keystore_cert_key_file_path')]"994 ambari_server.import_cert_and_key("key_dir")995 self.assertEquals(get_validated_filepath_input_mock.call_count, 2)996 self.assertTrue(get_validated_string_input_mock.called)997 self.assertEquals(os_path_join_mock.call_count, 8)998 self.assertEquals(set_file_permissions_mock.call_count, 1)999 self.assertEqual(str(import_file_to_keystore_mock.call_args_list),\1000 expect_import_file_to_keystore)1001 self.assertTrue(generate_random_string_mock.called)1002 @patch("__builtin__.open")1003 @patch.object(ambari_server, "copy_file")1004 @patch.object(ambari_server, "is_root")1005 @patch.object(ambari_server, "read_ambari_user")1006 @patch.object(ambari_server, "set_file_permissions")1007 @patch.object(ambari_server, "import_file_to_keystore")1008 @patch.object(ambari_server, "run_os_command")1009 @patch("os.path.join")1010 @patch.object(ambari_server, "get_validated_filepath_input")1011 @patch.object(ambari_server, "get_validated_string_input")1012 def test_import_cert_and_key_with_incorrect_password(self,1013 get_validated_string_input_mock,\1014 get_validated_filepath_input_mock,\1015 os_path_join_mock,\1016 run_os_command_mock,\1017 import_file_to_keystore_mock,\1018 set_file_permissions_mock,\1019 read_ambari_user_mock,\1020 is_root_mock,\1021 copy_file_mock,\1022 open_mock):1023 get_validated_string_input_mock.return_value = "incorrect_password"1024 get_validated_filepath_input_mock.return_value = 'filename'1025 open_mock.return_value = MagicMock()1026 os_path_join_mock.return_value = ''1027 is_root_mock.return_value = True1028 #provided password doesn't match, openssl command returns an error1029 run_os_command_mock.return_value = (1, "", "Some error message")1030 self.assertFalse(ambari_server.import_cert_and_key_action(*["key_dir", None]))1031 self.assertFalse(ambari_server.import_cert_and_key("key_dir"))1032 def test_is_valid_cert_exp(self):1033 1034 #No data in certInfo1035 certInfo = {}1036 is_valid = ambari_server.is_valid_cert_exp(certInfo)1037 self.assertFalse(is_valid)1038 1039 #Issued in future1040 issuedOn = (datetime.datetime.now() + datetime.timedelta(hours=1000)).strftime(ambari_server.SSL_DATE_FORMAT)1041 expiresOn = (datetime.datetime.now() + datetime.timedelta(hours=2000)).strftime(ambari_server.SSL_DATE_FORMAT)1042 certInfo = {ambari_server.NOT_BEFORE_ATTR : issuedOn,1043 ambari_server.NOT_AFTER_ATTR : expiresOn}1044 is_valid = ambari_server.is_valid_cert_exp(certInfo)1045 self.assertFalse(is_valid)1046 1047 #Was expired1048 issuedOn = (datetime.datetime.now() - datetime.timedelta(hours=2000)).strftime(ambari_server.SSL_DATE_FORMAT)1049 expiresOn = (datetime.datetime.now() - datetime.timedelta(hours=1000)).strftime(ambari_server.SSL_DATE_FORMAT)1050 certInfo = {ambari_server.NOT_BEFORE_ATTR : issuedOn,1051 ambari_server.NOT_AFTER_ATTR : expiresOn}1052 is_valid = ambari_server.is_valid_cert_exp(certInfo)1053 self.assertFalse(is_valid)1054 1055 #Valid1056 issuedOn = (datetime.datetime.now() - datetime.timedelta(hours=2000)).strftime(ambari_server.SSL_DATE_FORMAT)1057 expiresOn = (datetime.datetime.now() + datetime.timedelta(hours=1000)).strftime(ambari_server.SSL_DATE_FORMAT)1058 certInfo = {ambari_server.NOT_BEFORE_ATTR : issuedOn,1059 ambari_server.NOT_AFTER_ATTR : expiresOn}1060 is_valid = ambari_server.is_valid_cert_exp(certInfo)1061 self.assertTrue(is_valid)1062 1063 @patch.object(ambari_server, "get_fqdn")1064 def is_valid_cert_host(self, get_fqdn_mock):1065 1066 #No data in certInfo1067 certInfo = {}1068 is_valid = ambari_server.is_valid_cert_host(certInfo)1069 self.assertFalse(is_valid)1070 1071 #Failed to get FQDN1072 get_fqdn_mock.return_value = None1073 is_valid = ambari_server.is_valid_cert_host(certInfo)1074 self.assertFalse(is_valid)1075 1076 #FQDN and Common name in certificated don't correspond1077 get_fqdn_mock.return_value = 'host1'1078 certInfo = {ambari_server.COMMON_NAME_ATTR : 'host2'}1079 is_valid = ambari_server.is_valid_cert_host(certInfo)1080 self.assertFalse(is_valid)1081 1082 #FQDN and Common name in certificated correspond1083 get_fqdn_mock.return_value = 'host1'1084 certInfo = {ambari_server.COMMON_NAME_ATTR : 'host1'}1085 is_valid = ambari_server.is_valid_cert_host(certInfo)1086 self.assertFalse(is_valid)1087 @patch("socket.getfqdn")1088 @patch("urllib2.urlopen")1089 @patch.object(ambari_server, "get_ambari_properties")1090 def test_get_fqdn(self, get_ambari_properties_mock, url_open_mock, getfqdn_mock):1091 1092 #No ambari.properties1093 get_ambari_properties_mock.return_value = -11094 fqdn = ambari_server.get_fqdn()1095 self.assertEqual(fqdn, None)1096 1097 #Check mbari_server.GET_FQDN_SERVICE_URL property name (AMBARI-2612)1098 #property name should be server.fqdn.service.url1099 self.assertEqual(ambari_server.GET_FQDN_SERVICE_URL, "server.fqdn.service.url")1100 1101 #Read FQDN from service1102 p = MagicMock()1103 p[ambari_server.GET_FQDN_SERVICE_URL] = 'someurl'1104 get_ambari_properties_mock.return_value = p1105 1106 u = MagicMock()1107 host = 'host1.domain.com'1108 u.read.return_value = host1109 url_open_mock.return_value = u1110 1111 fqdn = ambari_server.get_fqdn()1112 self.assertEqual(fqdn, host)1113 1114 #Failed to read FQDN from service, getting from socket1115 u.reset_mock()1116 u.side_effect = Exception("Failed to read FQDN from service")1117 getfqdn_mock.return_value = host1118 fqdn = ambari_server.get_fqdn()1119 self.assertEqual(fqdn, host)1120 1121 @patch.object(ambari_server, "run_os_command")1122 def test_get_cert_info(self, run_os_command_mock):1123 # Error running openssl command1124 path = 'path/to/certificate'1125 run_os_command_mock.return_value = -1, None, None1126 cert_info = ambari_server.get_cert_info(path)1127 self.assertEqual(cert_info, None)1128 1129 #Empty result of openssl command1130 run_os_command_mock.return_value = 0, None, None1131 cert_info = ambari_server.get_cert_info(path)1132 self.assertEqual(cert_info, None)1133 1134 #Positive scenario1135 notAfter = 'Jul 3 14:12:57 2014 GMT'1136 notBefore = 'Jul 3 14:12:57 2013 GMT'1137 attr1_key = 'A'1138 attr1_value = 'foo'1139 attr2_key = 'B'1140 attr2_value = 'bar'1141 attr3_key = 'CN'1142 attr3_value = 'host.domain.com'1143 subject_pattern = '/{attr1_key}={attr1_value}/{attr2_key}={attr2_value}/{attr3_key}={attr3_value}'1144 subject = subject_pattern.format(attr1_key = attr1_key, attr1_value = attr1_value,1145 attr2_key = attr2_key, attr2_value = attr2_value,1146 attr3_key = attr3_key, attr3_value = attr3_value)1147 out_pattern = """1148notAfter={notAfter}1149notBefore={notBefore}1150subject={subject}1151-----BEGIN CERTIFICATE-----1152MIIFHjCCAwYCCQDpHKOBI+Lt0zANBgkqhkiG9w0BAQUFADBRMQswCQYDVQQGEwJV1153...11545lqd8XxOGSYoMOf+70BLN2sB1155-----END CERTIFICATE-----1156 """1157 out = out_pattern.format(notAfter = notAfter, notBefore = notBefore, subject = subject)1158 run_os_command_mock.return_value = 0, out, None1159 cert_info = ambari_server.get_cert_info(path)1160 self.assertEqual(cert_info['notAfter'], notAfter)1161 self.assertEqual(cert_info['notBefore'], notBefore)1162 self.assertEqual(cert_info['subject'], subject)1163 self.assertEqual(cert_info[attr1_key], attr1_value)1164 self.assertEqual(cert_info[attr2_key], attr2_value)1165 self.assertEqual(cert_info[attr3_key], attr3_value)1166 1167 @patch.object(ambari_server, "run_os_command")1168 @patch("__builtin__.open")1169 @patch("os.path.exists")1170 def test_is_server_runing(self, os_path_exists_mock, open_mock,\1171 run_os_command_mock):1172 os_path_exists_mock.return_value = True1173 f = open_mock.return_value1174 f.readline.return_value = "111"1175 run_os_command_mock.return_value = 0, "", ""1176 status, pid = ambari_server.is_server_runing()1177 self.assertTrue(status)1178 self.assertEqual(111, pid)1179 os_path_exists_mock.return_value = False1180 status, pid = ambari_server.is_server_runing()1181 self.assertFalse(status)1182 1183 @patch.object(ambari_server, "install_jce_manualy")1184 @patch("os.stat")1185 @patch("os.path.isfile")1186 @patch("os.path.exists")1187 @patch.object(ambari_server, "track_jdk")1188 @patch.object(ambari_server, "get_YN_input")1189 @patch.object(ambari_server, "run_os_command")1190 @patch.object(ambari_server, "write_property")1191 @patch.object(ambari_server, "print_info_msg")1192 @patch.object(ambari_server, "get_JAVA_HOME")1193 @patch.object(ambari_server, "get_ambari_properties")1194 @patch("shutil.copyfile")1195 def test_download_jdk(self, copyfile_mock, get_ambari_properties_mock, get_JAVA_HOME_mock,\1196 print_info_msg_mock, write_property_mock,\1197 run_os_command_mock, get_YN_input_mock, track_jdk_mock,1198 path_existsMock, path_isfileMock, statMock,\1199 install_jce_manualy_mock):1200 args = MagicMock()1201 args.java_home = "somewhere"1202 path_existsMock.return_value = False1203 get_JAVA_HOME_mock.return_value = False1204 get_ambari_properties_mock.return_value = -11205 # Test case: ambari.properties not found1206 try:1207 ambari_server.download_jdk(args)1208 self.fail("Should throw exception because of not found ambari.properties")1209 except FatalException:1210 # Expected1211 self.assertTrue(get_ambari_properties_mock.called)1212 pass1213 # Test case: JDK already exists1214 p = MagicMock()1215 get_ambari_properties_mock.return_value = p1216 p.__getitem__.return_value = "somewhere"1217 get_JAVA_HOME_mock.return_value = True1218 path_existsMock.return_value = True1219 rcode = ambari_server.download_jdk(args)1220 self.assertEqual(0, rcode)1221 # Test case: java home setup1222 get_JAVA_HOME_mock.return_value = False1223 rcode = ambari_server.download_jdk(args)1224 self.assertEqual(0, rcode)1225 self.assertTrue(write_property_mock.called)1226 # Test case: JDK file does not exist, property not defined1227 path_existsMock.return_value = False1228 p = MagicMock()1229 get_ambari_properties_mock.return_value = p1230 p.__getitem__.side_effect = KeyError("test exception")1231 try:1232 ambari_server.download_jdk(args)1233 self.fail("Should throw exception")1234 except FatalException:1235 # Expected1236 pass1237 # Test case: JDK file does not exist, os command (curl) result does not1238 # contain Content-Length1239 p.__getitem__.return_value = "somewhere"1240 p.__getitem__.side_effect = None1241 path_existsMock.return_value = False1242 run_os_command_mock.return_value = (0, "Wrong out", None)1243 try:1244 ambari_server.download_jdk(args)1245 self.fail("Should throw exception")1246 except FatalException:1247 # Expected1248 pass1249 # Successful JDK download1250 ambari_server.JDK_INSTALL_DIR = os.getcwd()1251 get_YN_input_mock.return_value = True1252 run_os_command_mock.return_value = (0, "Creating jdk-1.2/jre"1253 "Content-Length: 32000\r\n"1254 , None)1255 statResult = MagicMock()1256 statResult.st_size = 320001257 statMock.return_value = statResult1258 rcode = ambari_server.download_jdk(args)1259 self.assertEqual(0, rcode)1260 # Test case: JDK file does not exist, jdk-location argument passed1261 p.__getitem__.return_value = "somewhere"1262 p.__getitem__.side_effect = None1263 args.jdk_location = "/existing/jdk/file"1264 path_existsMock.side_effect = [False, False, True, False, False, False]1265 ambari_server.download_jdk(args)1266 self.assertTrue(copyfile_mock.called)1267 copyfile_mock.reset_mock()1268 # Negative test case: JDK file does not exist, jdk-location argument1269 # (non-accessible file) passed1270 p.__getitem__.return_value = "somewhere"1271 p.__getitem__.side_effect = None1272 args.jdk_location = "/existing/jdk/file"1273 path_existsMock.side_effect = [False, False, True, False, False, False]1274 def copyfile_side_effect(s, d):1275 raise Exception("TerribleException")1276 copyfile_mock.side_effect = copyfile_side_effect1277 try:1278 ambari_server.download_jdk(args)1279 self.fail("Should throw exception")1280 except FatalException:1281 # Expected1282 self.assertTrue(copyfile_mock.called)1283 copyfile_mock.reset_mock()1284 # Test case: jdk is already installed, ensure that JCE check is not skipped1285 p = MagicMock()1286 get_ambari_properties_mock.return_value = p1287 p.__getitem__.return_value = "somewhere"1288 get_JAVA_HOME_mock.return_value = True1289 path_existsMock.return_value = True1290 install_jce_manualy_mock.return_value = 11291 with patch.object(ambari_server, "download_jce_policy") as download_jce_policy_mock:1292 rcode = ambari_server.download_jdk(args)1293 self.assertTrue(download_jce_policy_mock.called)1294 @patch.object(ambari_server, "run_os_command")1295 def test_get_postgre_status(self, run_os_command_mock):1296 run_os_command_mock.return_value = (1, "running", None)1297 result = ambari_server.get_postgre_status()1298 self.assertEqual("running", result)1299 run_os_command_mock.return_value = (1, "wrong", None)1300 result = ambari_server.get_postgre_status()1301 self.assertEqual(None, result)1302 @patch("time.sleep")1303 @patch("subprocess.Popen")1304 @patch.object(ambari_server, "run_os_command")1305 @patch.object(ambari_server, "get_postgre_status")1306 def test_check_postgre_up(self, get_postgre_status_mock, run_os_command_mock,1307 popen_mock, sleep_mock):1308 p = MagicMock()1309 p.poll.return_value = 01310 popen_mock.return_value = p1311 run_os_command_mock.return_value = (0, None, None)1312 rcode = ambari_server.check_postgre_up()1313 self.assertEqual(0, rcode)1314 p.poll.return_value = 41315 get_postgre_status_mock.return_value = None1316 rcode = ambari_server.check_postgre_up()1317 self.assertEqual(4, rcode)1318 @patch("platform.linux_distribution")1319 @patch("platform.system")1320 @patch.object(ambari_server, "print_info_msg")1321 @patch.object(ambari_server, "print_error_msg")1322 @patch.object(ambari_server, "get_ambari_properties")1323 @patch.object(ambari_server, "write_property")1324 @patch.object(ambari_server, "get_conf_dir")1325 def test_configure_os_settings(self, get_conf_dir_mock, write_property_mock, get_ambari_properties_mock,1326 print_error_msg_mock, print_info_msg_mock,1327 systemMock, distMock):1328 get_ambari_properties_mock.return_value = -11329 rcode = ambari_server.configure_os_settings()1330 self.assertEqual(-1, rcode)1331 p = MagicMock()1332 p[ambari_server.OS_TYPE_PROPERTY] = 'somevalue'1333 get_ambari_properties_mock.return_value = p1334 rcode = ambari_server.configure_os_settings()1335 self.assertEqual(0, rcode)1336 p.__getitem__.return_value = ""1337 systemMock.return_value = "NonLinux"1338 rcode = ambari_server.configure_os_settings()1339 self.assertEqual(-1, rcode)1340 systemMock.return_value = "Linux"1341 distMock.return_value = ("CentOS", "6.3", None)1342 rcode = ambari_server.configure_os_settings()1343 self.assertEqual(0, rcode)1344 self.assertTrue(write_property_mock.called)1345 @patch("__builtin__.open")1346 @patch.object(ambari_server, "Properties")1347 @patch.object(ambari_server, "search_file")1348 @patch.object(ambari_server, "get_conf_dir")1349 def test_get_JAVA_HOME(self, get_conf_dir_mock, search_file_mock,1350 Properties_mock, openMock):1351 openMock.side_effect = Exception("exception")1352 result = ambari_server.get_JAVA_HOME()1353 self.assertEqual(None, result)1354 expected = os.path.dirname(__file__)1355 p = MagicMock()1356 p.__getitem__.return_value = expected1357 openMock.side_effect = None1358 Properties_mock.return_value = p1359 result = ambari_server.get_JAVA_HOME()1360 self.assertEqual(expected, result)1361 def test_prompt_db_properties_default(self):1362 args = MagicMock()1363 ambari_server.load_default_db_properties(args)1364 ambari_server.prompt_db_properties(args)1365 self.assertEqual(args.database, "postgres")1366 self.assertEqual(args.database_host, "localhost")1367 self.assertEqual(args.database_name, "ambari")1368 self.assertEqual(args.database_port, "5432")1369 @patch.object(ambari_server, "setup_master_key")1370 @patch.object(ambari_server, "read_password")1371 @patch.object(ambari_server, "get_validated_string_input")1372 @patch.object(ambari_server, "get_YN_input")1373 def test_prompt_db_properties_oracle_sname(self, gyni_mock, gvsi_mock, rp_mock, smk_mock):1374 ambari_server.PROMPT_DATABASE_OPTIONS = True1375 gyni_mock.return_value = True1376 list_of_return_values= ["ambari-server", "ambari", "1", "1521", "localhost", "2"]1377 def side_effect(*args, **kwargs):1378 return list_of_return_values.pop()1379 gvsi_mock.side_effect = side_effect1380 rp_mock.return_value = "password"1381 smk_mock.return_value = (None, False, True)1382 args = MagicMock()1383 ambari_server.load_default_db_properties(args)1384 ambari_server.prompt_db_properties(args)1385 self.assertEqual(args.database, "oracle")1386 self.assertEqual(args.database_port, "1521")1387 self.assertEqual(args.database_host, "localhost")1388 self.assertEqual(args.database_name, "ambari")1389 self.assertEqual(args.database_username, "ambari-server")1390 self.assertEqual(args.sid_or_sname, "sname")1391 @patch.object(ambari_server, "setup_master_key")1392 @patch.object(ambari_server, "read_password")1393 @patch.object(ambari_server, "get_validated_string_input")1394 @patch.object(ambari_server, "get_YN_input")1395 def test_prompt_db_properties_oracle_sid(self, gyni_mock, gvsi_mock, rp_mock, smk_mock):1396 ambari_server.PROMPT_DATABASE_OPTIONS = True1397 gyni_mock.return_value = True1398 list_of_return_values= ["ambari-server", "ambari", "2", "1521", "localhost", "2"]1399 def side_effect(*args, **kwargs):1400 return list_of_return_values.pop()1401 gvsi_mock.side_effect = side_effect1402 rp_mock.return_value = "password"1403 smk_mock.return_value = (None, False, True)1404 args = MagicMock()1405 ambari_server.load_default_db_properties(args)1406 ambari_server.prompt_db_properties(args)1407 self.assertEqual(args.database, "oracle")1408 self.assertEqual(args.database_port, "1521")1409 self.assertEqual(args.database_host, "localhost")1410 self.assertEqual(args.database_name, "ambari")1411 self.assertEqual(args.database_username, "ambari-server")1412 self.assertEqual(args.sid_or_sname, "sid")1413 @patch.object(ambari_server, "setup_master_key")1414 @patch.object(ambari_server, "read_password")1415 @patch.object(ambari_server, "get_validated_string_input")1416 @patch.object(ambari_server, "get_YN_input")1417 def test_prompt_db_properties_postgre_adv(self, gyni_mock, gvsi_mock, rp_mock, smk_mock):1418 ambari_server.PROMPT_DATABASE_OPTIONS = True1419 gyni_mock.return_value = True1420 list_of_return_values= ["ambari-server", "ambari", "1"]1421 def side_effect(*args, **kwargs):1422 return list_of_return_values.pop()1423 gvsi_mock.side_effect = side_effect1424 rp_mock.return_value = "password"1425 smk_mock.return_value = (None, False, True)1426 args = MagicMock()1427 ambari_server.load_default_db_properties(args)1428 ambari_server.prompt_db_properties(args)1429 self.assertEqual(args.database, "postgres")1430 self.assertEqual(args.database_port, "5432")1431 self.assertEqual(args.database_host, "localhost")1432 self.assertEqual(args.database_name, "ambari")1433 self.assertEqual(args.database_username, "ambari-server")1434 self.assertEqual(args.sid_or_sname, "sname")1435 @patch("glob.glob")1436 @patch.object(ambari_server, "get_JAVA_HOME")1437 def test_find_jdk(self, get_JAVA_HOME_mock, globMock):1438 get_JAVA_HOME_mock.return_value = "somewhere"1439 result = ambari_server.find_jdk()1440 self.assertEqual("somewhere", result)1441 get_JAVA_HOME_mock.return_value = None1442 globMock.return_value = []1443 result = ambari_server.find_jdk()1444 self.assertEqual(None, result)1445 globMock.return_value = ["one", "two"]1446 result = ambari_server.find_jdk()1447 self.assertNotEqual(None, result)1448 @patch("os.path.exists")1449 @patch.object(ambari_server, 'verify_setup_allowed')1450 @patch.object(ambari_server, "get_YN_input")1451 @patch.object(ambari_server, "configure_os_settings")1452 @patch.object(ambari_server, "download_jdk")1453 @patch.object(ambari_server, "configure_postgres")1454 @patch.object(ambari_server, "setup_db")1455 @patch.object(ambari_server, "check_postgre_up")1456 @patch.object(ambari_server, "check_iptables")1457 @patch.object(ambari_server, "check_ambari_user")1458 @patch.object(ambari_server, "check_jdbc_drivers")1459 @patch.object(ambari_server, "check_selinux")1460 @patch.object(ambari_server, "setup_remote_db")1461 @patch.object(ambari_server, "store_remote_properties")1462 @patch.object(ambari_server, "is_local_database")1463 @patch.object(ambari_server, "store_local_properties")1464 @patch.object(ambari_server, "is_root")1465 def test_setup(self, is_root_mock, store_local_properties_mock, is_local_database_mock, store_remote_properties_mock,1466 setup_remote_db_mock, check_selinux_mock, check_jdbc_drivers_mock, check_ambari_user_mock,1467 check_iptables_mock, check_postgre_up_mock, setup_db_mock, configure_postgres_mock,1468 download_jdk_mock, configure_os_settings_mock,get_YN_input,1469 verify_setup_allowed_method, exists_mock):1470 args = MagicMock()1471 failed = False1472 get_YN_input.return_value = False1473 verify_setup_allowed_method.return_value = 01474 exists_mock.return_value = False1475 def reset_mocks():1476 is_root_mock.reset_mock()1477 store_local_properties_mock.reset_mock()1478 store_remote_properties_mock.reset_mock()1479 is_local_database_mock.reset_mock()1480 setup_remote_db_mock.reset_mock()1481 check_selinux_mock.reset_mock()1482 check_jdbc_drivers_mock.reset_mock()1483 check_ambari_user_mock.reset_mock()1484 check_iptables_mock.reset_mock()1485 check_postgre_up_mock.reset_mock()1486 setup_db_mock.reset_mock()1487 configure_postgres_mock.reset_mock()1488 download_jdk_mock.reset_mock()1489 configure_os_settings_mock.reset_mock()1490 pass1491 # Testing call under non-root1492 is_root_mock.return_value = False1493 try:1494 ambari_server.setup(args)1495 self.fail("Should throw exception")1496 except FatalException as fe:1497 # Expected1498 self.assertTrue("root-level" in fe.reason)1499 pass1500 # Testing calls under root1501 # remote case1502 is_root_mock.return_value = True1503 check_selinux_mock.return_value = 01504 check_ambari_user_mock.return_value = 01505 check_jdbc_drivers_mock.return_value = 01506 check_iptables_mock.return_value = (0, "other")1507 check_postgre_up_mock.return_value = 01508 setup_db_mock.return_value = 01509 setup_remote_db_mock.return_value = 01510 is_local_database_mock.return_value = False1511 configure_postgres_mock.return_value = 01512 download_jdk_mock.return_value = 01513 configure_os_settings_mock.return_value = 01514 store_remote_properties_mock.return_value = 01515 store_local_properties_mock.return_value = 01516 result = ambari_server.setup(args)1517 self.assertEqual(None, result)1518 self.assertTrue(check_ambari_user_mock.called)1519 self.assertEquals(True, store_remote_properties_mock.called)1520 self.assertEquals(False, store_local_properties_mock.called)1521 #Local case1522 reset_mocks()1523 is_local_database_mock.return_value = True1524 try:1525 result = ambari_server.setup(args)1526 except FatalException:1527 self.fail("Setup should be successful")1528 self.assertEqual(None, result)1529 self.assertEquals(True, store_local_properties_mock.called)1530 self.assertEquals(False, store_remote_properties_mock.called)1531 #negative case1532 reset_mocks()1533 is_local_database_mock.return_value = False1534 setup_remote_db_mock.return_value = -11535 try:1536 result = ambari_server.setup(args)1537 self.fail("Should throw exception")1538 except NonFatalException as fe:1539 self.assertTrue("cli was not found" in fe.reason)1540 @patch.object(ambari_server, "get_YN_input")1541 @patch.object(ambari_server, "setup_db")1542 @patch.object(ambari_server, "print_info_msg")1543 @patch.object(ambari_server, "run_os_command")1544 @patch.object(ambari_server, "configure_database_username_password")1545 @patch.object(ambari_server, "parse_properties_file")1546 @patch.object(ambari_server, "execute_remote_script")1547 @patch.object(ambari_server, "is_root")1548 def test_reset(self, is_root_mock, execute_remote_script_mock, parse_properties_file_mock, configure_database_username_password_mock,1549 run_os_command_mock, print_info_msg_mock,1550 setup_db_mock, get_YN_inputMock):1551 parse_properties_file_mock.return_value = 01552 args = MagicMock()1553 args.persistence_type = "local"1554 get_YN_inputMock.return_value = False1555 # Testing call under non-root1556 is_root_mock.return_value = False1557 try:1558 ambari_server.reset(args)1559 self.fail("Should throw exception")1560 except FatalException as fe:1561 # Expected1562 self.assertTrue("root-level" in fe.reason)1563 pass1564 # Testing calls under root1565 is_root_mock.return_value = True1566 try:1567 ambari_server.reset(args)1568 self.fail("Should throw exception")1569 except FatalException as fe:1570 # Expected1571 self.assertFalse("root-level" in fe.reason)1572 pass1573 get_YN_inputMock.return_value = True1574 run_os_command_mock.return_value = (1, None, None)1575 try:1576 ambari_server.reset(args)1577 self.fail("Should throw exception")1578 except FatalException:1579 # Expected1580 pass1581 run_os_command_mock.return_value = (0, None, None)1582 ambari_server.reset(args)1583 self.assertTrue(setup_db_mock.called)1584 1585 #remote db case1586 args.persistence_type = "remote"1587 execute_remote_script_mock.return_value=(0, None, None)1588 rcode = ambari_server.reset(args)1589 self.assertEqual(None, rcode)1590 self.assertTrue(execute_remote_script_mock.called)1591 @patch.object(ambari_server, "setup_db")1592 @patch.object(ambari_server, "print_info_msg")1593 @patch.object(ambari_server, "run_os_command")1594 @patch.object(ambari_server, "parse_properties_file")1595 @patch.object(ambari_server, "is_root")1596 def test_silent_reset(self, is_root_mock, parse_properties_file_mock,1597 run_os_command_mock, print_info_msg_mock,1598 setup_db_mock):1599 is_root_mock.return_value = True1600 args = MagicMock()1601 ambari_server.SILENT = True1602 self.assertTrue(ambari_server.SILENT)1603 run_os_command_mock.return_value = (0, None, None)1604 def signal_handler(signum, frame):1605 self.fail("Timed out!")1606 signal.signal(signal.SIGALRM, signal_handler)1607 signal.alarm(5)1608 rcode = ambari_server.reset(args)1609 signal.alarm(0)1610 self.assertEqual(None, rcode)1611 self.assertTrue(setup_db_mock.called)1612 @patch("os.chown")1613 @patch("pwd.getpwnam")1614 @patch.object(ambari_server, 'get_master_key_location')1615 @patch.object(ambari_server, 'save_master_key')1616 @patch('os.chmod', autospec=True)1617 @patch.object(ambari_server, 'get_validated_string_input')1618 @patch("os.environ")1619 @patch.object(ambari_server, "get_ambari_properties")1620 @patch("os.kill")1621 @patch("os.path.exists")1622 @patch("__builtin__.open")1623 @patch("subprocess.Popen")1624 @patch.object(ambari_server, "print_info_msg")1625 @patch.object(ambari_server, "search_file")1626 @patch.object(ambari_server, "find_jdk")1627 @patch.object(ambari_server, "print_error_msg")1628 @patch.object(ambari_server, "check_postgre_up")1629 @patch.object(ambari_server, "check_iptables")1630 @patch.object(ambari_server, "parse_properties_file")1631 @patch.object(ambari_server, "read_ambari_user")1632 @patch.object(ambari_server, "is_root")1633 @patch("getpass.getuser")1634 @patch("os.chdir")1635 def test_start(self, chdir_mock, getuser_mock, is_root_mock, read_ambari_user_mock,1636 parse_properties_file_mock, check_iptables_mock, check_postgre_up_mock,1637 print_error_msg_mock, find_jdk_mock, search_file_mock,1638 print_info_msg_mock, popenMock, openMock, pexistsMock,1639 killMock, get_ambari_properties_mock, os_environ_mock,1640 get_validated_string_input_method, os_chmod_method,1641 save_master_key_method, get_master_key_location_method,1642 getpwnam_mock, os_chown_mock):1643 args = MagicMock()1644 f = MagicMock()1645 f.readline.return_value = 421646 openMock.return_value = f1647 p = get_ambari_properties_mock.return_value1648 p.get_property.return_value = 'False'1649 search_file_mock.return_value = None1650 pw = MagicMock()1651 pw.setattr('pw_uid', 0)1652 pw.setattr('pw_gid', 0)1653 getpwnam_mock.return_value = pw1654 os_chown_mock.return_value = None1655 # Checking "server is running"1656 pexistsMock.return_value = True1657 try:1658 ambari_server.start(args)1659 self.fail("Should fail with 'Server is running'")1660 except FatalException:1661 # Expected1662 pass1663 self.assertTrue(killMock.called)1664 killMock.reset_mock()1665 parse_properties_file_mock.reset_mock()1666 pexistsMock.return_value = False1667 # Checking situation when ambari user is not set up1668 read_ambari_user_mock.return_value = None1669 try:1670 ambari_server.start(args)1671 self.fail("Should fail with 'Can not detect a system user for Ambari'")1672 except FatalException as e:1673 # Expected1674 self.assertTrue('Unable to detect a system user for Ambari Server.' in e.reason)1675 parse_properties_file_mock.reset_mock()1676 # Checking start from non-root when current user is not the same as a1677 # custom user1678 read_ambari_user_mock.return_value = "dummy-user"1679 getuser_mock.return_value = "non_custom_user"1680 is_root_mock.return_value = False1681 try:1682 ambari_server.start(args)1683 self.fail("Should fail with 'Can not start ambari-server as user...'")1684 except FatalException as e:1685 # Expected1686 self.assertTrue('Unable to start Ambari Server as user' in e.reason)1687 self.assertFalse(parse_properties_file_mock.called)1688 parse_properties_file_mock.reset_mock()1689 # Checking "jdk not found"1690 is_root_mock.return_value = True1691 find_jdk_mock.return_value = None1692 try:1693 ambari_server.start(args)1694 self.fail("Should fail with 'No JDK found'")1695 except FatalException as e:1696 # Expected1697 self.assertTrue('No JDK found' in e.reason)1698 find_jdk_mock.return_value = "somewhere"1699 parse_properties_file_mock.reset_mock()1700 ## Testing workflow under root1701 is_root_mock.return_value = True1702 # Remote DB1703 args.persistence_type="remote"1704 check_iptables_mock.return_value = (0, None)1705 try:1706 ambari_server.start(args)1707 except FatalException as e:1708 # Ignored1709 pass1710 self.assertFalse('Unable to start PostgreSQL server' in e.reason)1711 self.assertFalse(check_postgre_up_mock.called)1712 check_postgre_up_mock.reset_mock()1713 parse_properties_file_mock.reset_mock()1714 # Local DB1715 args.persistence_type="local"1716 # case: postgres failed to start1717 check_postgre_up_mock.return_value = 11718 try:1719 ambari_server.start(args)1720 self.fail("Should fail with 'Unable to start PostgreSQL server'")1721 except FatalException as e:1722 # Expected1723 self.assertTrue('Unable to start PostgreSQL server' in e.reason)1724 self.assertTrue(check_postgre_up_mock.called)1725 parse_properties_file_mock.reset_mock()1726 # case: iptables failed to stop1727 check_postgre_up_mock.return_value = 01728 check_iptables_mock.return_value = (1, ambari_server.IP_TBLS_ENABLED)1729 try:1730 ambari_server.start(args)1731 self.fail("Should fail with 'Failed to stop iptables'")1732 except FatalException as e:1733 # Expected1734 self.assertTrue('Failed to stop iptables' in e.reason)1735 parse_properties_file_mock.reset_mock()1736 check_iptables_mock.return_value = (0, None)1737 # Case: custom user is "root"1738 read_ambari_user_mock.return_value = "root"1739 ambari_server.start(args)1740 self.assertTrue(popenMock.called)1741 popen_arg = popenMock.call_args[0][0]1742 self.assertTrue(popen_arg[0] == "/bin/sh")1743 popenMock.reset_mock()1744 parse_properties_file_mock.reset_mock()1745 # Case: custom user is not "root"1746 read_ambari_user_mock.return_value = "not-root-user"1747 ambari_server.start(args)1748 self.assertTrue(chdir_mock.called)1749 self.assertTrue(popenMock.called)1750 popen_arg = popenMock.call_args[0][0]1751 self.assertTrue(popen_arg[0] == "/bin/su")1752 check_postgre_up_mock.reset_mock()1753 popenMock.reset_mock()1754 parse_properties_file_mock.reset_mock()1755 ## Testing workflow under non-root1756 is_root_mock.return_value = False1757 read_ambari_user_mock.return_value = "not-root-user"1758 getuser_mock.return_value = read_ambari_user_mock.return_value1759 parse_properties_file_mock.reset_mock()1760 # Local DB1761 args.persistence_type="local"1762 ambari_server.start(args)1763 self.assertFalse(check_postgre_up_mock.called)1764 parse_properties_file_mock.reset_mock()1765 # Remote DB1766 args.persistence_type="remote"1767 ambari_server.start(args)1768 self.assertFalse(check_postgre_up_mock.called)1769 parse_properties_file_mock.reset_mock()1770 # Checking call1771 check_iptables_mock.reset_mock()1772 check_iptables_mock.return_value = (0, None)1773 ambari_server.start(args)1774 self.assertTrue(popenMock.called)1775 popen_arg = popenMock.call_args[0][0]1776 self.assertTrue(popen_arg[0] == "/bin/sh")1777 self.assertFalse(check_iptables_mock.called)1778 parse_properties_file_mock.reset_mock()1779 # Test start under wrong user1780 read_ambari_user_mock.return_value = "not-root-user"1781 getuser_mock.return_value = "non_custom_user"1782 try:1783 ambari_server.start(args)1784 self.fail("Can not start ambari-server as user non_custom_user.")1785 except FatalException as e:1786 # Expected1787 self.assertTrue('Unable to start Ambari Server as user' in e.reason)1788 parse_properties_file_mock.reset_mock()1789 # Check environ master key is set1790 popenMock.reset_mock()1791 os_environ_mock.copy.return_value = {"a" : "b",1792 ambari_server.SECURITY_KEY_ENV_VAR_NAME : "masterkey"}1793 args.persistence_type="local"1794 read_ambari_user_mock.return_value = "root"1795 is_root_mock.return_value = True1796 ambari_server.start(args)1797 self.assertFalse(get_validated_string_input_method.called)1798 self.assertFalse(save_master_key_method.called)1799 popen_arg = popenMock.call_args[1]['env']1800 self.assertEquals(os_environ_mock.copy.return_value, popen_arg)1801 parse_properties_file_mock.reset_mock()1802 # Check environ master key is not set1803 popenMock.reset_mock()1804 os_environ_mock.reset_mock()1805 p.get_property.return_value = 'True'1806 os_environ_mock.copy.return_value = {"a" : "b"}1807 args.persistence_type="local"1808 read_ambari_user_mock.return_value = "root"1809 is_root_mock.return_value = True1810 get_validated_string_input_method.return_value = "masterkey"1811 os_chmod_method.return_value = None1812 ambari_server.start(args)1813 self.assertTrue(get_validated_string_input_method.called)1814 self.assertTrue(save_master_key_method.called)1815 popen_arg = popenMock.call_args[1]['env']1816 self.assertEquals(os_environ_mock.copy.return_value, popen_arg)1817 @patch("__builtin__.open")1818 @patch("os.path.exists")1819 @patch("os.remove")1820 @patch("os.killpg")1821 @patch("os.getpgid")1822 @patch.object(ambari_server, "print_info_msg")1823 def test_stop(self, print_info_msg_mock, gpidMock, removeMock,1824 killMock, pexistsMock, openMock):1825 pexistsMock.return_value = True1826 f = MagicMock()1827 f.readline.return_value = "42"1828 openMock.return_value = f1829 ambari_server.stop(None)1830 self.assertTrue(f.readline.called)1831 self.assertTrue(killMock.called)1832 self.assertTrue(killMock.called)1833 self.assertTrue(f.close.called)1834 self.assertTrue(removeMock.called)1835 @patch.object(ambari_server, "configure_database_username_password")1836 @patch.object(ambari_server, "run_os_command")1837 @patch.object(ambari_server, "is_root")1838 def test_upgrade_stack(self, is_root_mock, run_os_command_mock,1839 configure_postgres_username_password_mock):1840 args = MagicMock()1841 # Testing call under non-root1842 is_root_mock.return_value = False1843 try:1844 ambari_server.upgrade_stack(args, 'HDP-2.0')1845 self.fail("Should throw exception")1846 except FatalException as fe:1847 # Expected1848 self.assertTrue("root-level" in fe.reason)1849 pass1850 # Testing calls under root1851 is_root_mock.return_value = True1852 run_os_command_mock.return_value = (0, '', '')1853 ambari_server.upgrade_stack(args, 'HDP-2.0')1854 self.assertTrue(configure_postgres_username_password_mock.called)1855 self.assertTrue(run_os_command_mock.called)1856 @patch.object(ambari_server, "adjust_directory_permissions")1857 @patch.object(ambari_server, "print_warning_msg")1858 @patch.object(ambari_server, "read_ambari_user")1859 @patch.object(ambari_server, "check_db_consistency")1860 @patch.object(ambari_server, "execute_db_script")1861 @patch.object(ambari_server, "check_postgre_up")1862 @patch.object(ambari_server, "update_ambari_properties")1863 @patch.object(ambari_server, "parse_properties_file")1864 @patch.object(ambari_server, "is_root")1865 def test_upgrade(self, is_root_mock, parse_properties_file_mock, update_ambari_properties_mock,1866 check_postgre_up_mock, execute_db_script_mock,1867 check_db_consistency_mock, read_ambari_user_mock,1868 print_warning_msg_mock, adjust_directory_permissions_mock):1869 args = MagicMock()1870 args.upgrade_script_file = "/var/lib/"\1871 "ambari-server/resources/upgrade/ddl/"\1872 "Ambari-DDL-Postgres-UPGRADE-1.3.0.sql"1873 update_ambari_properties_mock.return_value = 01874 check_postgre_up_mock.return_value = 01875 execute_db_script_mock.return_value = 01876 check_db_consistency_mock.return_value = 01877 # Testing call under non-root1878 is_root_mock.return_value = False1879 try:1880 ambari_server.upgrade(args)1881 self.fail("Should throw exception")1882 except FatalException as fe:1883 # Expected1884 self.assertTrue("root-level" in fe.reason)1885 pass1886 # Testing calls under root1887 is_root_mock.return_value = True1888 # Testing with undefined custom user1889 read_ambari_user_mock.return_value = None1890 ambari_server.upgrade(args)1891 self.assertTrue(print_warning_msg_mock.called)1892 warning_args = print_warning_msg_mock.call_args[0][0]1893 self.assertTrue("custom ambari user" in warning_args)1894 # Testing with defined custom user1895 read_ambari_user_mock.return_value = "ambari-custom-user"1896 ambari_server.upgrade(args)1897 self.assertTrue(adjust_directory_permissions_mock.called)1898 def test_print_info_msg(self):1899 out = StringIO.StringIO()1900 sys.stdout = out1901 ambari_server.VERBOSE = True1902 ambari_server.print_info_msg("msg")1903 self.assertNotEqual("", out.getvalue())1904 sys.stdout = sys.__stdout__1905 def test_print_error_msg(self):1906 out = StringIO.StringIO()1907 sys.stdout = out1908 ambari_server.VERBOSE = True1909 ambari_server.print_error_msg("msg")1910 self.assertNotEqual("", out.getvalue())1911 sys.stdout = sys.__stdout__1912 def test_print_warning_msg(self):1913 out = StringIO.StringIO()1914 sys.stdout = out1915 ambari_server.VERBOSE = True1916 ambari_server.print_warning_msg("msg")1917 self.assertNotEqual("", out.getvalue())1918 sys.stdout = sys.__stdout__1919 @patch.object(ambari_server, "get_choice_string_input")1920 def test_get_YN_input(self, get_choice_string_input_mock):1921 ambari_server.get_YN_input("prompt", "default")1922 self.assertTrue(get_choice_string_input_mock.called)1923 self.assertEqual(4, len(get_choice_string_input_mock.call_args_list[0][0]))1924 def test_load_default_db_properties(self):1925 args = MagicMock()1926 ambari_server.load_default_db_properties(args)1927 self.assertEquals(args.database, "postgres")1928 self.assertEquals(args.database_host, "localhost")1929 self.assertEquals(args.database_port, "5432")1930 self.assertEquals(args.database_name, "ambari")1931 self.assertEquals(args.database_username, "ambari")1932 self.assertEquals(args.database_password, "bigdata")1933 args = MagicMock()1934 ambari_server.DATABASE_INDEX=11935 ambari_server.load_default_db_properties(args)1936 self.assertEquals(args.database, "oracle")1937 self.assertEquals(args.database_port, "1521")1938 failed = False1939 args = MagicMock()1940 ambari_server.DATABASE_INDEX=21941 try:1942 ambari_server.load_default_db_properties(args)1943 except:1944 failed = True1945 self.assertTrue(failed)1946 pass1947 @patch.object(ambari_server, 'setup')1948 def test_main_db_options(self, setup_mock):1949 base_args = ["ambari-server.py", "setup"]1950 db_args = ["--database", "postgres", "--databasehost", "somehost.net", "--databaseport", "12345",1951 "--databasename", "ambari", "--databaseusername", "ambari", "--databasepassword", "bigdata"]1952 #test no args1953 failed = False1954 sys.argv = list(base_args)1955 try:1956 ambari_server.main()1957 except SystemExit:1958 failed = True1959 pass1960 self.assertFalse(failed)1961 self.assertTrue(setup_mock.called)1962 setup_mock.reset_mock()1963 #test full args1964 sys.argv = list(base_args)1965 sys.argv.extend(db_args)1966 try:1967 ambari_server.main()1968 except SystemExit:1969 failed = True1970 pass1971 self.assertTrue(ambari_server.PROMPT_DATABASE_OPTIONS)1972 self.assertFalse(failed)1973 self.assertTrue(setup_mock.called)1974 setup_mock.reset_mock()1975 #test not full args1976 sys.argv = list(base_args)1977 sys.argv.extend(["--database", "postgres"])1978 try:1979 ambari_server.main()1980 except SystemExit:1981 failed = True1982 pass1983 self.assertFalse(setup_mock.called)1984 self.assertTrue(failed)1985 setup_mock.reset_mock()1986 #test wrong database1987 failed = False1988 sys.argv = list(base_args)1989 sys.argv.extend(["--database", "unknown"])1990 sys.argv.extend(db_args[2:])1991 try:1992 ambari_server.main()1993 except SystemExit:1994 failed = True1995 pass1996 self.assertTrue(failed)1997 self.assertFalse(setup_mock.called)1998 setup_mock.reset_mock()1999 #test wrong port check2000 failed = False2001 sys.argv = list(base_args)2002 sys.argv.extend(["--databaseport", "unknown"])2003 sys.argv.extend(db_args[:4])2004 sys.argv.extend(db_args[6:])2005 try:2006 ambari_server.main()2007 except SystemExit:2008 failed = True2009 pass2010 self.assertTrue(failed)2011 self.assertFalse(setup_mock.called)2012 setup_mock.reset_mock()2013 pass2014 @patch.object(ambari_server, "load_default_db_properties")2015 @patch.object(ambari_server, "get_YN_input")2016 @patch.object(ambari_server, "get_validated_string_input")2017 @patch.object(ambari_server, "setup_master_key")2018 @patch.object(ambari_server, "configure_database_password")2019 def test_prompt_db_properties(self, configure_database_password_mock, setup_master_key_mock,2020 get_validated_string_input_mock, get_YN_input_mock, load_default_db_properties_mock):2021 args = MagicMock()2022 #test not prompt2023 ambari_server.PROMPT_DATABASE_OPTIONS = False2024 ambari_server.prompt_db_properties(args)2025 self.assertFalse(load_default_db_properties_mock.called)2026 self.assertFalse(get_validated_string_input_mock.called)2027 self.assertFalse(get_YN_input_mock.called)2028 load_default_db_properties_mock.reset_mock()2029 get_validated_string_input_mock.reset_mock()2030 get_YN_input_mock.reset_mock()2031 #test prompt2032 get_YN_input_mock.return_value = False2033 ambari_server.PROMPT_DATABASE_OPTIONS = True2034 ambari_server.prompt_db_properties(args)2035 self.assertTrue(get_YN_input_mock.called)2036 self.assertFalse(get_validated_string_input_mock.called)2037 self.assertTrue(load_default_db_properties_mock.called)2038 load_default_db_properties_mock.reset_mock()2039 get_validated_string_input_mock.reset_mock()2040 get_YN_input_mock.reset_mock()2041 #test prompt advanced2042 get_YN_input_mock.return_value = True2043 ambari_server.PROMPT_DATABASE_OPTIONS = True2044 setup_master_key_mock.return_value = (None, False, True)2045 configure_database_password_mock.return_value = ("test", None)2046 ambari_server.prompt_db_properties(args)2047 self.assertTrue(get_YN_input_mock.called)2048 self.assertTrue(get_validated_string_input_mock.called)2049 self.assertTrue(load_default_db_properties_mock.called)2050 self.assertEquals(args.database, "postgres")2051 load_default_db_properties_mock.reset_mock()2052 get_validated_string_input_mock.reset_mock()2053 get_YN_input_mock.reset_mock()2054 pass2055 @patch.object(ambari_server, "get_db_cli_tool")2056 @patch.object(ambari_server, "run_in_shell")2057 def test_execute_remote_script(self, run_in_shell_mock, get_db_cli_tool_mock):2058 args = MagicMock()2059 script = "script"2060 #success2061 run_in_shell_mock.return_value=(0, None, None)2062 get_db_cli_tool_mock.return_value="tool"2063 args.database = "postgres"2064 args.database_password = "some_password"2065 retcode, out, err = ambari_server.execute_remote_script(args, script)2066 self.assertEquals(retcode, 0)2067 self.assertTrue(get_db_cli_tool_mock.called)2068 self.assertTrue(run_in_shell_mock.called)2069 #fail no cli tool2070 get_db_cli_tool_mock.return_value = None2071 get_db_cli_tool_mock.called = False2072 run_in_shell_mock.called = False2073 retcode, out, err = ambari_server.execute_remote_script(args, script)2074 self.assertEquals(retcode, -1)2075 self.assertTrue(get_db_cli_tool_mock.called)2076 self.assertFalse(run_in_shell_mock.called)2077 #fail execute2078 errcode = 12079 get_db_cli_tool_mock.return_value = "tool"2080 run_in_shell_mock.return_value=(errcode, None, None)2081 get_db_cli_tool_mock.called = False2082 run_in_shell_mock.called = False2083 retcode, out, err = ambari_server.execute_remote_script(args, script)2084 self.assertEquals(retcode, errcode)2085 self.assertTrue(get_db_cli_tool_mock.called)2086 self.assertTrue(run_in_shell_mock.called)2087 #fail wrong database - case should be completely impossible2088 get_db_cli_tool_mock.return_value = "tool"2089 run_in_shell_mock.return_value=(0, None, None)2090 get_db_cli_tool_mock.called = False2091 run_in_shell_mock.called = False2092 args.database = "unknown"2093 retcode, out, err = ambari_server.execute_remote_script(args, script)2094 self.assertEquals(retcode, -2)2095 self.assertTrue(get_db_cli_tool_mock.called)2096 self.assertFalse(run_in_shell_mock.called)2097 pass2098 @patch.object(ambari_server, "get_conf_dir")2099 def test_update_ambari_properties(self, get_conf_dir_mock):2100 properties = ["server.jdbc.user.name=ambari-server\n",2101 "server.jdbc.user.passwd=/etc/ambari-server/conf/password.dat\n",2102 "java.home=/usr/jdk64/jdk1.6.0_31\n",2103 "server.os_type=redhat6\n",2104 "ambari-server.user=ambari\n",2105 "agent.fqdn.service.url=URL\n"]2106 NEW_PROPERTY = 'some_new_property=some_value\n'2107 CHANGED_VALUE_PROPERTY = 'server.os_type=should_not_overwrite_value\n'2108 get_conf_dir_mock.return_value = '/etc/ambari-server/conf'2109 (tf1, fn1) = tempfile.mkstemp()2110 (tf2, fn2) = tempfile.mkstemp()2111 ambari_server.AMBARI_PROPERTIES_RPMSAVE_FILE = fn12112 ambari_server.AMBARI_PROPERTIES_FILE = fn22113 with open(ambari_server.AMBARI_PROPERTIES_FILE, "w") as f:2114 f.write(NEW_PROPERTY)2115 f.write(CHANGED_VALUE_PROPERTY)2116 with open(ambari_server.AMBARI_PROPERTIES_RPMSAVE_FILE, 'w') as f:2117 for line in properties:2118 f.write(line)2119 #Call tested method2120 ambari_server.update_ambari_properties()2121 timestamp = datetime.datetime.now()2122 #RPMSAVE_FILE wasn't found2123 self.assertFalse(os.path.exists(ambari_server.AMBARI_PROPERTIES_RPMSAVE_FILE))2124 #Renamed RPMSAVE_FILE exists2125 self.assertTrue(os.path.exists(ambari_server.AMBARI_PROPERTIES_RPMSAVE_FILE2126 + '.' + timestamp.strftime('%Y%m%d%H%M%S')))2127 with open(ambari_server.AMBARI_PROPERTIES_FILE, 'r') as f:2128 ambari_properties_content = f.readlines()2129 for line in properties:2130 if (line == "agent.fqdn.service.url=URL\n"):2131 if (not ambari_server.GET_FQDN_SERVICE_URL+"=URL\n" in ambari_properties_content) and (line in ambari_properties_content):2132 self.fail()2133 else:2134 if not line in ambari_properties_content:2135 self.fail()2136 if not NEW_PROPERTY in ambari_properties_content:2137 self.fail()2138 if CHANGED_VALUE_PROPERTY in ambari_properties_content:2139 self.fail()2140 # Command should not fail if *.rpmsave file is missing2141 result = ambari_server.update_ambari_properties()2142 self.assertEquals(result, 0)2143 os.unlink(fn2)2144 #if ambari.properties file is absent then "ambari-server upgrade" should2145 # fail2146 (tf, fn) = tempfile.mkstemp()2147 ambari_server.AMBARI_PROPERTIES_RPMSAVE_FILE = fn2148 result = ambari_server.update_ambari_properties()2149 self.assertNotEquals(result, 0)2150 @patch.object(ambari_server.Properties, '__init__')2151 @patch.object(ambari_server, 'search_file')2152 def test_update_ambari_properties_negative_case(self, search_file_mock, properties_mock):2153 search_file_mock.return_value = None2154 #Call tested method2155 self.assertEquals(0, ambari_server.update_ambari_properties())2156 self.assertFalse(properties_mock.called)2157 search_file_mock.return_value = False2158 #Call tested method2159 self.assertEquals(0, ambari_server.update_ambari_properties())2160 self.assertFalse(properties_mock.called)2161 search_file_mock.return_value = ''2162 #Call tested method2163 self.assertEquals(0, ambari_server.update_ambari_properties())2164 self.assertFalse(properties_mock.called)2165 @patch.object(ambari_server, "get_conf_dir")2166 def test_update_ambari_properties_without_user_property(self, get_conf_dir_mock):2167 '''2168 Checks: update_ambari_properties call should add ambari-server.user property if2169 it's absent2170 '''2171 properties = ["server.jdbc.user.name=ambari-server\n",2172 "server.jdbc.user.passwd=/etc/ambari-server/conf/password.dat\n",2173 "java.home=/usr/jdk64/jdk1.6.0_31\n",2174 "server.os_type=redhat6\n"]2175 get_conf_dir_mock.return_value = '/etc/ambari-server/conf'2176 (tf1, fn1) = tempfile.mkstemp()2177 (tf2, fn2) = tempfile.mkstemp()2178 ambari_server.AMBARI_PROPERTIES_RPMSAVE_FILE = fn12179 ambari_server.AMBARI_PROPERTIES_FILE = fn22180 with open(ambari_server.AMBARI_PROPERTIES_RPMSAVE_FILE, 'w') as f:2181 for line in properties:2182 f.write(line)2183 #Call tested method2184 ambari_server.update_ambari_properties()2185 ambari_properties = ambari_server.Properties()2186 ambari_properties.load(open(fn2))2187 self.assertTrue(ambari_server.NR_USER_PROPERTY in ambari_properties.keys())2188 value = ambari_properties[ambari_server.NR_USER_PROPERTY]2189 self.assertEqual(value, "root")2190 os.unlink(fn2)2191 @patch.object(ambari_server, 'verify_setup_allowed')2192 @patch("sys.exit")2193 @patch.object(ambari_server, "get_YN_input")2194 @patch.object(ambari_server, "get_db_cli_tool")2195 @patch.object(ambari_server, "store_remote_properties")2196 @patch.object(ambari_server, "is_local_database")2197 @patch.object(ambari_server, "check_iptables")2198 @patch.object(ambari_server, "check_jdbc_drivers")2199 @patch.object(ambari_server, "is_root")2200 @patch.object(ambari_server, "check_ambari_user")2201 @patch.object(ambari_server, "download_jdk")2202 @patch.object(ambari_server, "configure_os_settings")2203 @patch('__builtin__.raw_input')2204 def test_setup_remote_db_wo_client(self,raw_input, configure_os_settings_mock,2205 download_jdk_mock, check_ambari_user_mock, is_root_mock,2206 check_jdbc_drivers_mock, check_iptables_mock, is_local_db_mock,2207 store_remote_properties_mock, get_db_cli_tool_mock, get_YN_input,2208 exit_mock, verify_setup_allowed_method):2209 args = MagicMock()2210 raw_input.return_value =""2211 is_root_mock.return_value = True2212 is_local_db_mock.return_value = False2213 get_YN_input.return_value = False2214 check_iptables_mock.return_value = (0, "other")2215 store_remote_properties_mock.return_value = 02216 get_db_cli_tool_mock.return_value = None2217 check_jdbc_drivers_mock.return_value=02218 check_ambari_user_mock.return_value = 02219 download_jdk_mock.return_value = 02220 configure_os_settings_mock.return_value = 02221 verify_setup_allowed_method.return_value = 02222 try:2223 ambari_server.setup(args)2224 self.fail("Should throw exception")2225 except NonFatalException as fe:2226 # Expected2227 self.assertTrue("The cli was not found" in fe.reason)2228 @patch.object(ambari_server, 'verify_setup_allowed')2229 @patch("sys.exit")2230 @patch.object(ambari_server, "get_YN_input")2231 @patch.object(ambari_server, "get_db_cli_tool")2232 @patch.object(ambari_server, "is_local_database")2233 @patch.object(ambari_server, "check_iptables")2234 @patch.object(ambari_server, "check_jdbc_drivers")2235 @patch.object(ambari_server, "is_root")2236 @patch.object(ambari_server, "check_ambari_user")2237 @patch.object(ambari_server, "download_jdk")2238 @patch.object(ambari_server, "configure_os_settings")2239 @patch('__builtin__.raw_input')2240 def test_store_remote_properties(self,raw_input, configure_os_settings_mock,2241 download_jdk_mock, check_ambari_user_mock, is_root_mock,2242 check_jdbc_drivers_mock, check_iptables_mock, is_local_db_mock,2243 get_db_cli_tool_mock, get_YN_input, exit_mock, verify_setup_allowed_method):2244 raw_input.return_value =""2245 is_root_mock.return_value = True2246 is_local_db_mock.return_value = False2247 get_YN_input.return_value = False2248 check_iptables_mock.return_value = (0, "other")2249 get_db_cli_tool_mock.return_value = None2250 check_jdbc_drivers_mock.return_value=02251 check_ambari_user_mock.return_value = 02252 download_jdk_mock.return_value = 02253 configure_os_settings_mock.return_value = 02254 verify_setup_allowed_method.return_value = 02255 import optparse2256 args = optparse.Values()2257 args.database = "oracle"2258 args.database_host = "localhost"2259 args.database_port = "1234"2260 args.database_name = "ambari"2261 args.sid_or_sname = "foo"2262 args.database_username = "foo"2263 args.database_password = "foo"2264 tempdir = tempfile.gettempdir()2265 prop_file = os.path.join(tempdir, "ambari.properties")2266 with open(prop_file, "w") as f:2267 f.write("dummy=dummy")2268 f.close()2269 os.environ[ambari_server.AMBARI_CONF_VAR] = tempdir2270 ambari_server.DATABASE_INDEX = 12271 ambari_server.store_remote_properties(args)2272 properties = ambari_server.get_ambari_properties()2273 found = False2274 for n in properties.propertyNames():2275 if not found and n.startswith("server.jdbc.properties"):2276 found = True2277 ambari_server.DATABASE_INDEX = 02278 del os.environ[ambari_server.AMBARI_CONF_VAR]2279 os.remove(prop_file)2280 self.assertTrue(found)2281 @patch.object(ambari_server, "parse_properties_file")2282 @patch.object(ambari_server, "get_db_cli_tool")2283 @patch.object(ambari_server, "print_error_msg")2284 @patch.object(ambari_server, "get_YN_input")2285 @patch.object(ambari_server, "setup_db")2286 @patch.object(ambari_server, "run_os_command")2287 @patch.object(ambari_server, "is_root")2288 def test_reset_remote_db_wo_client(self, is_root_mock, run_os_command_mock, setup_db_mock,2289 get_YN_inputMock, print_error_msg_mock, get_db_cli_tool_mock, parse_properties_file_mock):2290 args = MagicMock()2291 get_YN_inputMock.return_value = True2292 run_os_command_mock.return_value = (0, None, None)2293 args.persistence_type="remote"2294 get_db_cli_tool_mock.return_value = None2295 is_root_mock.return_value = True2296 try:2297 ambari_server.reset(args)2298 self.fail("Should throw exception")2299 except NonFatalException as fe:2300 # Expected2301 self.assertTrue("Client wasn't found" in fe.reason)2302 pass2303 @patch.object(ambari_server, "find_properties_file")2304 def test_get_ambari_properties(self, find_properties_file_mock):2305 find_properties_file_mock.return_value = None2306 rcode = ambari_server.get_ambari_properties()2307 self.assertEqual(rcode, -1)2308 2309 tf1 = tempfile.NamedTemporaryFile()2310 find_properties_file_mock.return_value = tf1.name2311 prop_name='name'2312 prop_value='val'2313 2314 with open(tf1.name, 'w') as fout:2315 fout.write(prop_name + '=' + prop_value)2316 fout.close()2317 properties = ambari_server.get_ambari_properties()2318 self.assertEqual(properties[prop_name], prop_value)2319 @patch.object(ambari_server, "get_ambari_properties")2320 @patch.object(ambari_server, "find_jdbc_driver")2321 @patch.object(ambari_server, "copy_files")2322 @patch.object(ambari_server, "print_error_msg")2323 @patch.object(ambari_server, "print_warning_msg")2324 @patch('__builtin__.raw_input')2325 @patch("sys.exit")2326 def check_jdbc_drivers(self, exit_mock, raw_input_mock, print_warning_msg, print_error_msg_mock, copy_files_mock,2327 find_jdbc_driver_mock, get_ambari_properties_mock):2328 out = StringIO.StringIO()2329 sys.stdout = out2330 args = MagicMock()2331 # Check positive scenario2332 drivers_list = ['driver_file']2333 resources_dir = '/tmp'2334 get_ambari_properties_mock.return_value = {ambari_server.RESOURCES_DIR_PROPERTY : resources_dir}2335 find_jdbc_driver_mock.return_value = drivers_list2336 args.database = "oracle"2337 rcode = ambari_server.check_jdbc_drivers(args)2338 self.assertEqual(0, rcode)2339 copy_files_mock.assert_called_with(drivers_list, resources_dir)2340 # Check negative scenarios2341 # Silent option, no drivers2342 ambari_server.SILENT = True2343 find_jdbc_driver_mock.return_value = -12344 rcode = ambari_server.check_jdbc_drivers(args)2345 self.assertTrue(print_error_msg_mock.called)2346 self.assertTrue(exit_mock.called)2347 # Non-Silent option, no drivers2348 ambari_server.SILENT = False2349 find_jdbc_driver_mock.return_value = -12350 rcode = ambari_server.check_jdbc_drivers(args)2351 self.assertTrue(exit_mock.called)2352 self.assertTrue(print_error_msg_mock.called)2353 # Non-Silent option, no drivers at first ask, present drivers after that2354 find_jdbc_driver_mock.side_effect = [-1, drivers_list]2355 rcode = ambari_server.check_jdbc_drivers(args)2356 self.assertEqual(0, rcode)2357 copy_files_mock.assert_called_with(drivers_list, resources_dir)2358 # Non-Silent option, no drivers at first ask, present drivers after that2359 find_jdbc_driver_mock.reset()2360 find_jdbc_driver_mock.side_effect = [-1, -1]2361 rcode = ambari_server.check_jdbc_drivers(args)2362 self.assertTrue(exit_mock.called)2363 self.assertTrue(print_error_msg_mock.called)2364 sys.stdout = sys.__stdout__2365 @patch.object(ambari_server, "find_properties_file")2366 def test_get_ambari_properties(self, find_properties_file):2367 find_properties_file.return_value = None2368 rcode = ambari_server.get_ambari_properties()2369 self.assertEqual(rcode, -1)2370 tf1 = tempfile.NamedTemporaryFile()2371 find_properties_file.return_value = tf1.name2372 prop_name='name'2373 prop_value='val'2374 with open(tf1.name, 'w') as fout:2375 fout.write(prop_name + '=' + prop_value)2376 fout.close()2377 properties = ambari_server.get_ambari_properties()2378 self.assertEqual(properties[prop_name], prop_value)2379 self.assertEqual(properties.fileName, os.path.abspath(tf1.name))2380 sys.stdout = sys.__stdout__2381 2382 @patch("os.path.exists")2383 @patch("os.remove")2384 @patch.object(ambari_server,"print_warning_msg")2385 def test_remove_file(self, printWarningMsgMock, removeMock, pathExistsMock):2386 def side_effect():2387 raise Exception(-1, "Failed to delete!")2388 2389 removeMock.side_effect = side_effect2390 pathExistsMock.return_value = 12391 2392 res = ambari_server.remove_file("/someNonExsistantDir/filename")2393 self.assertEquals(res,1)2394 2395 removeMock.side_effect = None2396 res = ambari_server.remove_file("/someExsistantDir/filename")2397 self.assertEquals(res, 0)2398 2399 @patch("shutil.copyfile")2400 def test_copy_file(self, shutilCopyfileMock):2401 def side_effect():2402 raise Exception(-1, "Failed to copy!")2403 2404 shutilCopyfileMock.side_effect = side_effect2405 2406 try:2407 ambari_server.copy_file("/tmp/psswd","/someNonExsistantDir/filename")2408 self.fail("Exception on file not copied has not been thrown!")2409 except FatalException:2410 # Expected2411 pass2412 2413 self.assertTrue(shutilCopyfileMock.called)2414 2415 2416 shutilCopyfileMock.side_effect = None2417 try:2418 ambari_server.copy_file("/tmp/psswd","/root/psswd")2419 except FatalException:2420 self.fail("Exception on file copied should not be thrown!")2421 2422 self.assertTrue(shutilCopyfileMock.called)2423 @patch.object(ambari_server, "get_ambari_properties")2424 @patch.object(ambari_server, "find_jdbc_driver")2425 @patch.object(ambari_server, "copy_files")2426 @patch.object(ambari_server, "print_error_msg")2427 @patch.object(ambari_server, "print_warning_msg")2428 @patch('__builtin__.raw_input')2429 def test_check_jdbc_drivers(self, raw_input_mock, print_warning_msg, print_error_msg_mock, copy_files_mock,2430 find_jdbc_driver_mock, get_ambari_properties_mock):2431 out = StringIO.StringIO()2432 sys.stdout = out2433 args = MagicMock()2434 2435 # Check positive scenario2436 drivers_list = ['driver_file']2437 resources_dir = '/tmp'2438 2439 get_ambari_properties_mock.return_value = {ambari_server.RESOURCES_DIR_PROPERTY : resources_dir}2440 find_jdbc_driver_mock.return_value = drivers_list2441 copy_files_mock.return_value = 02442 2443 args.database = "oracle"2444 2445 rcode = ambari_server.check_jdbc_drivers(args)2446 2447 self.assertEqual(0, rcode)2448 copy_files_mock.assert_called_with(drivers_list, resources_dir)2449 2450 get_ambari_properties_mock.reset_mock()2451 find_jdbc_driver_mock.reset_mock()2452 copy_files_mock.reset_mock()2453 print_error_msg_mock.reset_mock()2454 print_warning_msg.reset_mock()2455 raw_input_mock.reset_mock()2456 2457 2458 2459 # Check negative scenarios2460 # Silent option, no drivers2461 ambari_server.SILENT = True2462 2463 find_jdbc_driver_mock.return_value = -12464 2465 failed = False2466 2467 try:2468 rcode = ambari_server.check_jdbc_drivers(args)2469 except FatalException:2470 failed = True2471 2472 self.assertTrue(print_error_msg_mock.called)2473 self.assertTrue(failed)2474 2475 get_ambari_properties_mock.reset_mock()2476 find_jdbc_driver_mock.reset_mock()2477 copy_files_mock.reset_mock()2478 print_error_msg_mock.reset_mock()2479 print_warning_msg.reset_mock()2480 raw_input_mock.reset_mock()2481 2482 # Non-Silent option, no drivers2483 ambari_server.SILENT = False2484 2485 find_jdbc_driver_mock.return_value = -12486 2487 failed = False2488 2489 try:2490 rcode = ambari_server.check_jdbc_drivers(args)2491 except FatalException:2492 failed = True2493 self.assertTrue(failed)2494 self.assertTrue(print_error_msg_mock.called)2495 2496 get_ambari_properties_mock.reset_mock()2497 find_jdbc_driver_mock.reset_mock()2498 copy_files_mock.reset_mock()2499 print_error_msg_mock.reset_mock()2500 print_warning_msg.reset_mock()2501 raw_input_mock.reset_mock()2502 2503 # Non-Silent option, no drivers at first ask, present drivers after that2504 2505 find_jdbc_driver_mock.side_effect = [-1, drivers_list]2506 2507 rcode = ambari_server.check_jdbc_drivers(args)2508 2509 self.assertEqual(0, rcode)2510 copy_files_mock.assert_called_with(drivers_list, resources_dir)2511 2512 get_ambari_properties_mock.reset_mock()2513 find_jdbc_driver_mock.reset_mock()2514 copy_files_mock.reset_mock()2515 print_error_msg_mock.reset_mock()2516 print_warning_msg.reset_mock()2517 raw_input_mock.reset_mock()2518 2519 # Non-Silent option, no drivers at first ask, no drivers after that2520 find_jdbc_driver_mock.side_effect = [-1, -1]2521 2522 failed = False2523 2524 try:2525 rcode = ambari_server.check_jdbc_drivers(args)2526 except FatalException:2527 failed = True2528 2529 self.assertTrue(failed)2530 self.assertTrue(print_error_msg_mock.called)2531 2532 get_ambari_properties_mock.reset_mock()2533 find_jdbc_driver_mock.reset_mock()2534 copy_files_mock.reset_mock()2535 print_error_msg_mock.reset_mock()2536 print_warning_msg.reset_mock()2537 raw_input_mock.reset_mock()2538 2539 2540 2541 2542 # Failed to copy_files 2543 2544 find_jdbc_driver_mock.side_effect = [drivers_list]2545 try:2546 rcode = ambari_server.check_jdbc_drivers(args)2547 except FatalException:2548 failed = True2549 2550 self.assertTrue(failed)2551 2552 sys.stdout = sys.__stdout__2553 2554 2555 @patch.object(ambari_server, "find_properties_file")2556 def test_get_ambari_properties(self, find_properties_file_mock):2557 find_properties_file_mock.return_value = None2558 rcode = ambari_server.get_ambari_properties()2559 self.assertEqual(rcode, -1)2560 2561 tf1 = tempfile.NamedTemporaryFile()2562 find_properties_file_mock.return_value = tf1.name2563 prop_name='name'2564 prop_value='val'2565 2566 with open(tf1.name, 'w') as fout:2567 fout.write(prop_name + '=' + prop_value)2568 fout.close()2569 properties = ambari_server.get_ambari_properties()2570 2571 self.assertEqual(properties[prop_name], prop_value)2572 self.assertEqual(properties.fileName, os.path.abspath(tf1.name))2573 2574 sys.stdout = sys.__stdout__2575 @patch.object(ambari_server, "find_properties_file")2576 def test_parse_properties_file(self, find_properties_file_mock):2577 tf1 = tempfile.NamedTemporaryFile(mode='r')2578 find_properties_file_mock.return_value = tf1.name2579 args = MagicMock()2580 ambari_server.parse_properties_file(args)2581 self.assertEquals(args.persistence_type, "local")2582 with open(tf1.name, 'w') as fout:2583 fout.write("\n")2584 fout.write(ambari_server.PERSISTENCE_TYPE_PROPERTY+"=remote")2585 args = MagicMock()2586 ambari_server.parse_properties_file(args)2587 self.assertEquals(args.persistence_type, "remote")2588 @patch.object(ambari_server, 'decrypt_password_for_alias')2589 @patch.object(ambari_server, 'is_alias_string')2590 @patch.object(ambari_server, 'get_ambari_properties')2591 def test_configure_database_username_password_masterkey_persisted(self,2592 get_ambari_properties_method, is_alias_string_method,2593 decrypt_password_for_alias_method):2594 out = StringIO.StringIO()2595 sys.stdout = out2596 configs = {ambari_server.JDBC_USER_NAME_PROPERTY: "fakeuser",2597 ambari_server.JDBC_PASSWORD_PROPERTY: "${alias=somealias}",2598 ambari_server.SECURITY_KEY_IS_PERSISTED: "True" }2599 get_ambari_properties_method.return_value = configs2600 is_alias_string_method.return_value = True2601 decrypt_password_for_alias_method.return_value = "falepasswd"2602 args = MagicMock()2603 args.master_key = None2604 ambari_server.configure_database_username_password(args)2605 self.assertTrue(decrypt_password_for_alias_method.called)2606 self.assertTrue(is_alias_string_method.called)2607 self.assertEquals("fakeuser", args.database_username)2608 self.assertEquals("falepasswd", args.database_password)2609 sys.stdout = sys.__stdout__2610 @patch.object(ambari_server, 'read_password')2611 def test_configure_database_password(self, read_password_method):2612 out = StringIO.StringIO()2613 sys.stdout = out2614 read_password_method.return_value = "fakepasswd"2615 result = ambari_server.configure_database_password(True)2616 self.assertTrue(read_password_method.called)2617 self.assertEquals("fakepasswd", result)2618 result = ambari_server.configure_database_password(True)2619 self.assertEquals("fakepasswd", result)2620 result = ambari_server.configure_database_password(True)2621 self.assertEquals("fakepasswd", result)2622 sys.stdout = sys.__stdout__2623 @patch("os.path.exists")2624 @patch.object(ambari_server, 'get_is_secure')2625 @patch.object(ambari_server, 'get_is_persisted')2626 @patch.object(ambari_server, 'remove_password_file')2627 @patch.object(ambari_server, 'save_passwd_for_alias')2628 @patch.object(ambari_server, 'read_master_key')2629 @patch.object(ambari_server, 'read_ambari_user')2630 @patch.object(ambari_server, 'get_master_key_location')2631 @patch.object(ambari_server, 'update_properties')2632 @patch.object(ambari_server, 'save_master_key')2633 @patch.object(ambari_server, 'get_YN_input')2634 @patch.object(ambari_server, 'search_file')2635 @patch.object(ambari_server, 'get_ambari_properties')2636 @patch.object(ambari_server, 'is_root')2637 def test_setup_master_key_not_persist(self, is_root_method,2638 get_ambari_properties_method, search_file_message,2639 get_YN_input_method, save_master_key_method,2640 update_properties_method, get_master_key_location_method,2641 read_ambari_user_method, read_master_key_method,2642 save_passwd_for_alias_method, remove_password_file_method,2643 get_is_persisted_method, get_is_secure_method, exists_mock):2644 is_root_method.return_value = True2645 p = get_ambari_properties_method.return_value2646 p.get_property.side_effect = [ "fakepasswd", "fakepasswd", "fakepasswd", "fakepasswd"]2647 read_master_key_method.return_value = "aaa"2648 get_YN_input_method.return_value = False2649 read_ambari_user_method.return_value = None2650 save_passwd_for_alias_method.return_value = 02651 get_is_persisted_method.return_value = (True, "filepath")2652 get_is_secure_method.return_value = False2653 exists_mock.return_value = False2654 ambari_server.setup_master_key()2655 self.assertTrue(get_YN_input_method.called)2656 self.assertTrue(read_master_key_method.called)2657 self.assertTrue(read_ambari_user_method.called)2658 self.assertTrue(update_properties_method.called)2659 self.assertFalse(save_master_key_method.called)2660 self.assertTrue(save_passwd_for_alias_method.called)2661 self.assertEquals(3, save_passwd_for_alias_method.call_count)2662 self.assertTrue(remove_password_file_method.called)2663 result_expected = {ambari_server.JDBC_PASSWORD_PROPERTY :2664 ambari_server.get_alias_string(ambari_server.JDBC_RCA_PASSWORD_ALIAS),2665 ambari_server.JDBC_RCA_PASSWORD_FILE_PROPERTY:2666 ambari_server.get_alias_string(ambari_server.JDBC_RCA_PASSWORD_ALIAS),2667 ambari_server.LDAP_MGR_PASSWORD_PROPERTY :2668 ambari_server.get_alias_string(ambari_server.LDAP_MGR_PASSWORD_ALIAS),2669 ambari_server.SSL_TRUSTSTORE_PASSWORD_PROPERTY :2670 ambari_server.get_alias_string(ambari_server.SSL_TRUSTSTORE_PASSWORD_ALIAS),2671 ambari_server.SECURITY_IS_ENCRYPTION_ENABLED : 'true'}2672 sorted_x = sorted(result_expected.iteritems(), key=operator.itemgetter(0))2673 sorted_y = sorted(update_properties_method.call_args[0][1].iteritems(),2674 key=operator.itemgetter(0))2675 self.assertEquals(sorted_x, sorted_y)2676 @patch.object(ambari_server, 'save_passwd_for_alias')2677 @patch("os.path.exists")2678 @patch.object(ambari_server, 'get_is_secure')2679 @patch.object(ambari_server, 'get_is_persisted')2680 @patch.object(ambari_server, 'read_master_key')2681 @patch.object(ambari_server, 'read_ambari_user')2682 @patch.object(ambari_server, 'get_master_key_location')2683 @patch.object(ambari_server, 'update_properties')2684 @patch.object(ambari_server, 'save_master_key')2685 @patch.object(ambari_server, 'get_YN_input')2686 @patch.object(ambari_server, 'search_file')2687 @patch.object(ambari_server, 'get_ambari_properties')2688 @patch.object(ambari_server, 'is_root')2689 def test_setup_master_key_persist(self, is_root_method,2690 get_ambari_properties_method, search_file_message,2691 get_YN_input_method, save_master_key_method,2692 update_properties_method, get_master_key_location_method,2693 read_ambari_user_method, read_master_key_method,2694 get_is_persisted_method, get_is_secure_method, exists_mock,2695 save_passwd_for_alias_method):2696 is_root_method.return_value = True2697 p = get_ambari_properties_method.return_value2698 p.get_property.side_effect = [ "fakepasswd", None, None, None ]2699 read_master_key_method.return_value = "aaa"2700 get_YN_input_method.side_effect = [True, False]2701 read_ambari_user_method.return_value = None2702 get_is_persisted_method.return_value = (True, "filepath")2703 get_is_secure_method.return_value = False2704 exists_mock.return_value = False2705 save_passwd_for_alias_method.return_value = 02706 ambari_server.setup_master_key()2707 self.assertTrue(get_YN_input_method.called)2708 self.assertTrue(read_master_key_method.called)2709 self.assertTrue(read_ambari_user_method.called)2710 self.assertTrue(update_properties_method.called)2711 self.assertTrue(save_master_key_method.called)2712 result_expected = {ambari_server.JDBC_PASSWORD_PROPERTY:2713 ambari_server.get_alias_string(ambari_server.JDBC_RCA_PASSWORD_ALIAS),2714 ambari_server.SECURITY_IS_ENCRYPTION_ENABLED: 'true'}2715 sorted_x = sorted(result_expected.iteritems(), key=operator.itemgetter(0))2716 sorted_y = sorted(update_properties_method.call_args[0][1].iteritems(),2717 key=operator.itemgetter(0))2718 self.assertEquals(sorted_x, sorted_y)2719 @patch.object(ambari_server, 'read_master_key')2720 @patch.object(ambari_server, 'remove_password_file')2721 @patch("os.path.exists")2722 @patch.object(ambari_server, 'read_ambari_user')2723 @patch.object(ambari_server, 'get_master_key_location')2724 @patch("ambari-server.Properties")2725 @patch.object(ambari_server, 'save_passwd_for_alias')2726 @patch.object(ambari_server, 'read_passwd_for_alias')2727 @patch.object(ambari_server, 'update_properties')2728 @patch.object(ambari_server, 'save_master_key')2729 @patch.object(ambari_server, 'get_validated_string_input')2730 @patch.object(ambari_server, 'get_YN_input')2731 @patch.object(ambari_server, 'search_file')2732 @patch.object(ambari_server, 'get_ambari_properties')2733 @patch.object(ambari_server, 'is_root')2734 def test_reset_master_key_persisted(self, is_root_method,2735 get_ambari_properties_method, search_file_message,2736 get_YN_input_method, get_validated_string_input_method,2737 save_master_key_method, update_properties_method,2738 read_passwd_for_alias_method, save_passwd_for_alias_method,2739 Properties_mock, get_master_key_location_method,2740 read_ambari_user_method, exists_mock,2741 remove_password_file_method, read_master_key_method):2742 # Testing call under non-root2743 is_root_method.return_value = False2744 try:2745 ambari_server.setup_master_key()2746 self.fail("Should throw exception")2747 except FatalException as fe:2748 # Expected2749 self.assertTrue("root-level" in fe.reason)2750 pass2751 # Testing call under root2752 is_root_method.return_value = True2753 search_file_message.return_value = "filepath"2754 read_ambari_user_method.return_value = None2755 p = get_ambari_properties_method.return_value2756 p.get_property.side_effect = [ 'true', '${alias=fakealias}',2757 '${alias=fakealias}',2758 '${alias=fakealias}', '${alias=fakealias}']2759 get_YN_input_method.side_effect = [ True, True ]2760 read_master_key_method.return_value = "aaa"2761 read_passwd_for_alias_method.return_value = "fakepassword"2762 save_passwd_for_alias_method.return_value = 02763 exists_mock.return_value = False2764 ambari_server.setup_master_key()2765 self.assertTrue(save_master_key_method.called)2766 self.assertTrue(get_YN_input_method.called)2767 self.assertTrue(read_master_key_method.called)2768 self.assertTrue(update_properties_method.called)2769 self.assertTrue(read_passwd_for_alias_method.called)2770 self.assertTrue(3, read_passwd_for_alias_method.call_count)2771 self.assertTrue(3, save_passwd_for_alias_method.call_count)2772 result_expected = {ambari_server.JDBC_PASSWORD_PROPERTY:2773 ambari_server.get_alias_string(ambari_server.JDBC_RCA_PASSWORD_ALIAS),2774 ambari_server.JDBC_RCA_PASSWORD_FILE_PROPERTY:2775 ambari_server.get_alias_string(ambari_server.JDBC_RCA_PASSWORD_ALIAS),2776 ambari_server.LDAP_MGR_PASSWORD_PROPERTY:2777 ambari_server.get_alias_string(ambari_server.LDAP_MGR_PASSWORD_ALIAS),2778 ambari_server.SSL_TRUSTSTORE_PASSWORD_PROPERTY:2779 ambari_server.get_alias_string(ambari_server.SSL_TRUSTSTORE_PASSWORD_ALIAS),2780 ambari_server.SECURITY_IS_ENCRYPTION_ENABLED: 'true'}2781 sorted_x = sorted(result_expected.iteritems(), key=operator.itemgetter(0))2782 sorted_y = sorted(update_properties_method.call_args[0][1].iteritems(),2783 key=operator.itemgetter(0))2784 self.assertEquals(sorted_x, sorted_y)2785 @patch.object(ambari_server, 'get_is_persisted')2786 @patch.object(ambari_server, 'get_is_secure')2787 @patch.object(ambari_server, 'remove_password_file')2788 @patch("os.path.exists")2789 @patch.object(ambari_server, 'read_ambari_user')2790 @patch.object(ambari_server, 'get_master_key_location')2791 @patch("ambari-server.Properties")2792 @patch.object(ambari_server, 'save_passwd_for_alias')2793 @patch.object(ambari_server, 'read_passwd_for_alias')2794 @patch.object(ambari_server, 'update_properties')2795 @patch.object(ambari_server, 'save_master_key')2796 @patch.object(ambari_server, 'get_validated_string_input')2797 @patch.object(ambari_server, 'get_YN_input')2798 @patch.object(ambari_server, 'search_file')2799 @patch.object(ambari_server, 'get_ambari_properties')2800 @patch.object(ambari_server, 'is_root')2801 def test_reset_master_key_not_persisted(self, is_root_method,2802 get_ambari_properties_method,2803 search_file_message, get_YN_input_method,2804 get_validated_string_input_method, save_master_key_method,2805 update_properties_method, read_passwd_for_alias_method,2806 save_passwd_for_alias_method, Properties_mock,2807 get_master_key_location_method, read_ambari_user_method,2808 exists_mock, remove_password_file_method, get_is_secure_method,2809 get_is_persisted_method):2810 is_root_method.return_value = True2811 search_file_message.return_value = False2812 read_ambari_user_method.return_value = None2813 p = get_ambari_properties_method.return_value2814 p.get_property.side_effect = [ '${alias=fakealias}', '${alias=fakealias}',2815 '${alias=fakealias}', '${alias=fakealias}']2816 get_YN_input_method.side_effect = [ True, False ]2817 get_validated_string_input_method.return_value = "aaa"2818 read_passwd_for_alias_method.return_value = "fakepassword"2819 save_passwd_for_alias_method.return_value = 02820 exists_mock.return_value = False2821 get_is_secure_method.return_value = True2822 get_is_persisted_method.return_value = (True, "filePath")2823 ambari_server.setup_master_key()2824 self.assertFalse(save_master_key_method.called)2825 self.assertTrue(get_YN_input_method.called)2826 self.assertTrue(get_validated_string_input_method.called)2827 self.assertTrue(update_properties_method.called)2828 self.assertTrue(read_passwd_for_alias_method.called)2829 self.assertTrue(3, read_passwd_for_alias_method.call_count)2830 self.assertTrue(3, save_passwd_for_alias_method.call_count)2831 self.assertFalse(save_master_key_method.called)2832 result_expected = {ambari_server.JDBC_PASSWORD_PROPERTY:2833 ambari_server.get_alias_string(ambari_server.JDBC_RCA_PASSWORD_ALIAS),2834 ambari_server.JDBC_RCA_PASSWORD_FILE_PROPERTY:2835 ambari_server.get_alias_string(ambari_server.JDBC_RCA_PASSWORD_ALIAS),2836 ambari_server.LDAP_MGR_PASSWORD_PROPERTY:2837 ambari_server.get_alias_string(ambari_server.LDAP_MGR_PASSWORD_ALIAS),2838 ambari_server.SSL_TRUSTSTORE_PASSWORD_PROPERTY:2839 ambari_server.get_alias_string(ambari_server.SSL_TRUSTSTORE_PASSWORD_ALIAS),2840 ambari_server.SECURITY_IS_ENCRYPTION_ENABLED: 'true'}2841 sorted_x = sorted(result_expected.iteritems(), key=operator.itemgetter(0))2842 sorted_y = sorted(update_properties_method.call_args[0][1].iteritems(),2843 key=operator.itemgetter(0))2844 self.assertEquals(sorted_x, sorted_y)2845 @patch('__builtin__.raw_input')2846 @patch.object(ambari_server, 'get_is_secure')2847 @patch.object(ambari_server, 'get_YN_input')2848 @patch.object(ambari_server, 'update_properties')2849 @patch.object(ambari_server, 'search_file')2850 @patch.object(ambari_server, 'get_ambari_properties')2851 @patch.object(ambari_server, 'is_root')2852 def test_setup_ldap_invalid_input(self, is_root_method, get_ambari_properties_method,2853 search_file_message,2854 update_properties_method,2855 get_YN_input_method,2856 get_is_secure_method,2857 raw_input_mock):2858 out = StringIO.StringIO()2859 sys.stdout = out2860 is_root_method.return_value = True2861 search_file_message.return_value = "filepath"2862 configs = { ambari_server.SECURITY_MASTER_KEY_LOCATION : "filepath",2863 ambari_server.SECURITY_KEYS_DIR : tempfile.gettempdir(),2864 ambari_server.SECURITY_IS_ENCRYPTION_ENABLED : "true"2865 }2866 get_ambari_properties_method.return_value = configs2867 raw_input_mock.side_effect = ['a:3', 'b:b', 'host', 'b:2', 'false', 'uid', 'base', 'true']2868 ambari_server.SILENT = False2869 get_YN_input_method.return_value = True2870 ambari_server.setup_ldap()2871 ldap_properties_map = \2872 {2873 "authentication.ldap.primaryUrl" : "a:3",2874 "authentication.ldap.secondaryUrl" : "b:2",2875 "authentication.ldap.useSSL" : "false",2876 "authentication.ldap.usernameAttribute" : "uid",2877 "authentication.ldap.baseDn" : "base",2878 "authentication.ldap.bindAnonymously" : "true",2879 "client.security" : "ldap"2880 }2881 sorted_x = sorted(ldap_properties_map.iteritems(), key=operator.itemgetter(0))2882 sorted_y = sorted(update_properties_method.call_args[0][1].iteritems(),2883 key=operator.itemgetter(0))2884 self.assertEquals(sorted_x, sorted_y)2885 self.assertTrue(get_YN_input_method.called)2886 self.assertTrue(8, raw_input_mock.call_count)2887 raw_input_mock.reset_mock()2888 raw_input_mock.side_effect = ['a:3', '', 'b:2', 'false', 'uid', 'base', 'true']2889 ambari_server.setup_ldap()2890 ldap_properties_map = \2891 {2892 "authentication.ldap.primaryUrl" : "a:3",2893 "authentication.ldap.useSSL" : "false",2894 "authentication.ldap.usernameAttribute" : "uid",2895 "authentication.ldap.baseDn" : "base",2896 "authentication.ldap.bindAnonymously" : "true",2897 "client.security" : "ldap"2898 }2899 sorted_x = sorted(ldap_properties_map.iteritems(), key=operator.itemgetter(0))2900 sorted_y = sorted(update_properties_method.call_args[0][1].iteritems(),2901 key=operator.itemgetter(0))2902 self.assertEquals(sorted_x, sorted_y)2903 self.assertTrue(5, raw_input_mock.call_count)2904 sys.stdout = sys.__stdout__2905 @patch.object(ambari_server, 'get_is_secure')2906 @patch.object(ambari_server, 'encrypt_password')2907 @patch.object(ambari_server, 'save_passwd_for_alias')2908 @patch.object(ambari_server, 'get_YN_input')2909 @patch.object(ambari_server, 'update_properties')2910 @patch.object(ambari_server, 'configure_ldap_password')2911 @patch.object(ambari_server, 'get_validated_string_input')2912 @patch.object(ambari_server, 'setup_master_key')2913 @patch.object(ambari_server, 'search_file')2914 @patch.object(ambari_server, 'get_ambari_properties')2915 @patch.object(ambari_server, 'is_root')2916 def test_setup_ldap(self, is_root_method, get_ambari_properties_method,2917 search_file_message, setup_master_key_method,2918 get_validated_string_input_method,2919 configure_ldap_password_method, update_properties_method,2920 get_YN_input_method, save_passwd_for_alias_method,2921 encrypt_password_method, get_is_secure_method):2922 out = StringIO.StringIO()2923 sys.stdout = out2924 # Testing call under non-root2925 is_root_method.return_value = False2926 try:2927 ambari_server.setup_ldap()2928 self.fail("Should throw exception")2929 except FatalException as fe:2930 # Expected2931 self.assertTrue("root-level" in fe.reason)2932 pass2933 # Testing call under root2934 is_root_method.return_value = True2935 search_file_message.return_value = "filepath"2936 configs = { ambari_server.SECURITY_MASTER_KEY_LOCATION : "filepath",2937 ambari_server.SECURITY_KEYS_DIR : tempfile.gettempdir(),2938 ambari_server.SECURITY_IS_ENCRYPTION_ENABLED : "true"2939 }2940 get_ambari_properties_method.return_value = configs2941 configure_ldap_password_method.return_value = "password"2942 setup_master_key_method.return_value = (None, True, True)2943 save_passwd_for_alias_method.return_value = 02944 encrypt_password_method.return_value = ambari_server.get_alias_string(2945 ambari_server.LDAP_MGR_PASSWORD_ALIAS)2946 def yn_input_side_effect(*args, **kwargs):2947 if 'TrustStore' in args[0]:2948 return False2949 else:2950 return True2951 #get_YN_input_method.side_effect = yn_input_side_effect()2952 get_YN_input_method.side_effect = [ True, ]2953 def valid_input_side_effect(*args, **kwargs):2954 if 'Bind anonymously' in args[0]:2955 return 'false'2956 if args[1] == "true" or args[1] == "false":2957 return args[1]2958 else:2959 return "test"2960 get_validated_string_input_method.side_effect = valid_input_side_effect2961 ambari_server.setup_ldap()2962 ldap_properties_map =\2963 {2964 "authentication.ldap.primaryUrl" : "test",2965 "authentication.ldap.secondaryUrl" : "test",2966 "authentication.ldap.useSSL" : "false",2967 "authentication.ldap.usernameAttribute" : "test",2968 "authentication.ldap.baseDn" : "test",2969 "authentication.ldap.bindAnonymously" : "false",2970 "authentication.ldap.managerDn" : "test",2971 "client.security" : "ldap",\2972 ambari_server.LDAP_MGR_PASSWORD_PROPERTY : ambari_server.get_alias_string(\2973 ambari_server.LDAP_MGR_PASSWORD_ALIAS)2974 }2975 sorted_x = sorted(ldap_properties_map.iteritems(), key=operator.itemgetter(0))2976 sorted_y = sorted(update_properties_method.call_args[0][1].iteritems(),2977 key=operator.itemgetter(0))2978 self.assertEquals(sorted_x, sorted_y)2979 self.assertTrue(update_properties_method.called)2980 self.assertTrue(configure_ldap_password_method.called)2981 self.assertTrue(get_validated_string_input_method.called)2982 self.assertTrue(get_YN_input_method.called)2983 sys.stdout = sys.__stdout__2984 @patch.object(ambari_server, 'read_password')2985 def test_configure_ldap_password(self, read_password_method):2986 out = StringIO.StringIO()2987 sys.stdout = out2988 read_password_method.return_value = "blah"2989 ambari_server.configure_ldap_password()2990 self.assertTrue(read_password_method.called)2991 sys.stdout = sys.__stdout__2992 @patch.object(ambari_server, 'get_validated_string_input')2993 def test_read_password(self, get_validated_string_input_method):2994 out = StringIO.StringIO()2995 sys.stdout = out2996 passwordDefault = ""2997 passwordPrompt = 'Enter Manager Password* : '2998 passwordPattern = ".*"2999 passwordDescr = "Invalid characters in password."3000 get_validated_string_input_method.side_effect = ['', 'aaa', 'aaa']3001 password = ambari_server.read_password(passwordDefault, passwordPattern,3002 passwordPrompt, passwordDescr)3003 self.assertTrue(3, get_validated_string_input_method.call_count)3004 self.assertEquals('aaa', password)3005 get_validated_string_input_method.reset_mock()3006 get_validated_string_input_method.side_effect = ['aaa', 'aaa']3007 password = ambari_server.read_password(passwordDefault, passwordPattern,3008 passwordPrompt, passwordDescr)3009 self.assertTrue(2, get_validated_string_input_method.call_count)3010 self.assertEquals('aaa', password)3011 get_validated_string_input_method.reset_mock()3012 get_validated_string_input_method.side_effect = ['aaa']3013 password = ambari_server.read_password('aaa', passwordPattern,3014 passwordPrompt, passwordDescr)3015 self.assertTrue(1, get_validated_string_input_method.call_count)3016 self.assertEquals('aaa', password)3017 sys.stdout = sys.__stdout__3018 def test_generate_random_string(self):3019 random_str_len = 1003020 str1 = ambari_server.generate_random_string(random_str_len)3021 self.assertTrue(len(str1) == random_str_len)3022 3023 str2 = ambari_server.generate_random_string(random_str_len)3024 self.assertTrue(str1 != str2)3025 @patch("__builtin__.open")3026 @patch.object(ambari_server, "search_file")3027 @patch.object(ambari_server, "backup_file_in_temp")3028 def test_update_properties(self, backup_file_in_temp_mock, search_file_mock, open_mock):3029 conf_file = "ambari.properties"3030 propertyMap = {"1":"1", "2":"2"}3031 properties = MagicMock()3032 f = MagicMock(name = "file")3033 # f.__enter__.return_value = f #mimic file behavior3034 search_file_mock.return_value = conf_file3035 open_mock.return_value = f3036 ambari_server.update_properties(properties, propertyMap)3037 properties.store.assert_called_with(f.__enter__.return_value)3038 backup_file_in_temp_mock.assert_called_with(conf_file)3039 self.assertEquals(2, properties.removeOldProp.call_count)3040 self.assertEquals(2, properties.process_pair.call_count)3041 properties = MagicMock()3042 backup_file_in_temp_mock.reset_mock()3043 open_mock.reset_mock()3044 ambari_server.update_properties(properties, None)3045 properties.store.assert_called_with(f.__enter__.return_value)3046 backup_file_in_temp_mock.assert_called_with(conf_file)3047 self.assertFalse(properties.removeOldProp.called)3048 self.assertFalse(properties.process_pair.called)3049 pass3050 def test_regexps(self):3051 res = re.search(ambari_server.REGEX_HOSTNAME_PORT, "")3052 self.assertTrue(res is None)3053 res = re.search(ambari_server.REGEX_HOSTNAME_PORT, "ddd")3054 self.assertTrue(res is None)3055 res = re.search(ambari_server.REGEX_HOSTNAME_PORT, "gg:ff")3056 self.assertTrue(res is None)3057 res = re.search(ambari_server.REGEX_HOSTNAME_PORT, "gg:55444325")3058 self.assertTrue(res is None)3059 res = re.search(ambari_server.REGEX_HOSTNAME_PORT, "gg:555")3060 self.assertTrue(res is not None)3061 res = re.search(ambari_server.REGEX_TRUE_FALSE, "")3062 self.assertTrue(res is not None)3063 res = re.search(ambari_server.REGEX_TRUE_FALSE, "t")3064 self.assertTrue(res is None)3065 res = re.search(ambari_server.REGEX_TRUE_FALSE, "trrrr")3066 self.assertTrue(res is None)3067 res = re.search(ambari_server.REGEX_TRUE_FALSE, "true|false")3068 self.assertTrue(res is None)3069 res = re.search(ambari_server.REGEX_TRUE_FALSE, "true")3070 self.assertTrue(res is not None)3071 res = re.search(ambari_server.REGEX_TRUE_FALSE, "false")3072 self.assertTrue(res is not None)3073 res = re.search(ambari_server.REGEX_ANYTHING, "")3074 self.assertTrue(res is not None)3075 res = re.search(ambari_server.REGEX_ANYTHING, "t")3076 self.assertTrue(res is not None)3077 res = re.search(ambari_server.REGEX_ANYTHING, "trrrr")3078 self.assertTrue(res is not None)3079 def get_sample(self, sample):3080 """3081 Returns sample file content as string with normalized line endings3082 """3083 path = self.get_samples_dir(sample)3084 return self.get_file_string(path)3085 def get_file_string(self, file):3086 """3087 Returns file content as string with normalized line endings3088 """3089 string = open(file, 'r').read()3090 return self.normalize(string)3091 def normalize(self, string):3092 """3093 Normalizes line ending in string according to platform-default encoding3094 """3095 return string.replace("\n", os.linesep)3096 def get_samples_dir(self, sample):3097 """3098 Returns full file path by sample name3099 """3100 testdir = os.path.dirname(__file__)3101 return os.path.dirname(testdir) + os.sep + "resources" + os.sep \...

Full Screen

Full Screen

test_plugin.py

Source:test_plugin.py Github

copy

Full Screen

1########2# Copyright (c) 2014 GigaSpaces Technologies Ltd. All rights reserved3#4# Licensed under the Apache License, Version 2.0 (the "License");5# you may not use this file except in compliance with the License.6# You may obtain a copy of the License at7#8# http://www.apache.org/licenses/LICENSE-2.09#10# Unless required by applicable law or agreed to in writing, software11# distributed under the License is distributed on an "AS IS" BASIS,12# * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.13# * See the License for the specific language governing permissions and14# * limitations under the License.15from os import path16import unittest17import re18from cloudify.test_utils import workflow_test19from plugin.srv_graph.graph_element import ServiceGraphElement20from plugin.srv_graph.graph_element import ComponentElement21from plugin.srv_graph.graph_element import ComponentDependencyElement22from plugin.srv_graph.graph_element import ComponentFactory23from plugin.srv_graph.graph_element import ComponentFactoryFacade24from plugin.srv_graph.graph_builder import GraphBuilder25from plugin.api.client_facade_api import ARCADIAClientFacade26from plugin.srv_graph.pretty_printer import DefaultXMLPrinter27from plugin.srv_graph.pretty_printer import ARCADIAXMLPrinter28from plugin.tests.mocks.nodes import CloudifyWorlkflowNodeInstanceMock29from plugin.tests.mocks.nodes import CloudifyWorkflowRelationshipInstanceMock30from plugin.tests.mocks.client import ARCADIAClientMock31from plugin.context import actx32from plugin.tests.utils.xml_compare import XmlTree33def flatten_str(string):34 return re.sub('[\n\s\t]', '', string)35class TestPlugin(unittest.TestCase):36 def setUp(self):37 actx._components = dict()38 actx._relationships = dict()39 actx._service_graph_instance = None40 actx._client = None41 actx._service_graph_tree = None42 @workflow_test(path.join('blueprint', 'blueprint.yaml'),43 resources_to_copy=[path.join('blueprint',44 'test_plugin.yaml')])45 def test_install_arcadia_workflow(self, cfy_local):46 expected_result = '''47 <ServiceGraph xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="ArcadiaModellingArtefacts.xsd">48 <DescriptiveSGMetadata>49 <SGID>wordpress_mysql_service_graph_id</SGID>50 <SGName>SimpleWordPressServiceGraph</SGName>51 <SGDescription>SGDescription</SGDescription>52 </DescriptiveSGMetadata>53 <GraphNodeDescriptor>54 <GraphNode>55 <NID>graph_node_mysql_id</NID>56 <CNID>mysql_id</CNID>57 </GraphNode>58 <GraphNode>59 <NID>graph_node_wordpress_id</NID>60 <CNID>wordpress_id</CNID>61 <GraphDependency>62 <CEPCID>mysqltcp_cepcid</CEPCID>63 <ECEPID>mysqltcp</ECEPID>64 <NID>NID</NID>65 </GraphDependency>66 </GraphNode>67 </GraphNodeDescriptor>68 <RuntimePolicyDescriptor>69 <RuntimePolicy>70 <RPID>RPID</RPID>71 <RPName>RPName</RPName>72 </RuntimePolicy>73 </RuntimePolicyDescriptor>74 </ServiceGraph>'''75 actx.client = ARCADIAClientMock()76 77 cfy_local.execute('install_arcadia', task_retries=0)78 service_graph = actx.client._service_graph_tree79 self.assertTrue(isinstance(service_graph, ServiceGraphElement))80 self.assertTrue(len(service_graph.components) == 2)81 self.assertTrue(len(service_graph.policies) == 1)82 def find_component(array, component):83 for comp in array:84 if comp._instance._node_instance['name'] == component:85 return comp86 return87 mysql_comp = find_component(service_graph.components, 'mysql')88 wp_comp = find_component(service_graph.components, 'wordpress')89 self.assertTrue(mysql_comp)90 self.assertTrue(wp_comp)91 self.assertTrue(len(wp_comp.dependencies) == 1)92 self.assertTrue(wp_comp.dependencies[0].target._instance == mysql_comp._instance)93 expected_root = XmlTree.convert_string_to_tree(expected_result)94 actual_root = XmlTree.convert_string_to_tree(actx.client._service_graph_printed)95 self.assertTrue(XmlTree().xml_isomorphic(expected_root, actual_root))96 def test_pretty_print(self):97 expected_result = '''98 <service_graph> 99 service_graph100 <graph_node>101 mysql102 </graph_node>103 <graph_node>104 wordpress105 <graph_node_dependency>106 mysql-wordpress107 </graph_node_dependency>108 </graph_node>109 </service_graph>110 '''111 default_pretty_printer = DefaultXMLPrinter()112 service_graph = ServiceGraphElement(_instance="service_graph")113 mysql = ComponentElement(_instance="mysql")114 wordpress = ComponentElement(_instance="wordpress")115 dependency = ComponentDependencyElement(mysql, wordpress, "wordpress_to_mysql_realationship")116 wordpress.add_dependency(dependency)117 service_graph.add_component(mysql)118 service_graph.add_component(wordpress)119 result = service_graph.print_element(default_pretty_printer)120 self.assertEqual(flatten_str(result), flatten_str(expected_result))121 def test_graph_node_print(self):122 expected_rusult = '''123 <GraphNode>124 <NID>graph_node_mysql_id</NID>125 <CNID>mysql_id</CNID>126 </GraphNode> 127 '''128 mock_instance = CloudifyWorlkflowNodeInstanceMock()129 mock_instance._node_instance.runtime_properties['nid'] = 'graph_node_mysql_id'130 mock_instance._node_instance.runtime_properties['cnid'] = 'mysql_id'131 pretty_printer = ARCADIAXMLPrinter()132 ComponentFactoryFacade.set_factory(ComponentFactory())133 mysql = ComponentFactoryFacade.INSTANCE.create_component(mock_instance)134 result = mysql.print_element(pretty_printer)135 self.assertEqual(flatten_str(result), flatten_str(expected_rusult))136 def test_graph_node_dependency_print(self):137 expected_rusult = '''138 <GraphDependency>139 <CEPCID>mysqltcp_cepcid</CEPCID>140 <ECEPID>mysqltcp</ECEPID>141 <NID>NID</NID>142 </GraphDependency>143 '''144 wrap_comp_type = ['cloudify.nodes.Root', 'cloudify.nodes.SoftwareComponent', 'cloudify.arcadia.nodes.WrappedComponent']145 mock_instance = CloudifyWorlkflowNodeInstanceMock()146 mock_instance._node_instance.runtime_properties['nid'] = 'graph_node_mysql_id'147 mock_instance._node_instance.runtime_properties['cnid'] = 'mysql_id'148 mock_instance._node_instance.runtime_properties['cepcid'] = 'mysqltcp_cepcid'149 mock_instance._node_instance.runtime_properties['ecepid'] = 'mysqltcp'150 con_to_type = ['cloudify.relationships.depends_on', 'cloudify.relationships.connected_to', 151 'cloudify.arcadia.relationships.connected_to', 'wordpress_connected_to_mysql']152 mock_relationship = CloudifyWorkflowRelationshipInstanceMock(node_instance = mock_instance, 153 relationship_instance = {154 'runtime_properties' : {'nid': 'NID'}155 },156 type_hierarchy = con_to_type)157 158 ComponentFactoryFacade.set_factory(ComponentFactory())159 mysql_cmp = ComponentFactoryFacade.INSTANCE.create_component(_instance = mock_instance)160 mysql_dependency = ComponentFactoryFacade.INSTANCE.create_component_dependency(_instance = mock_relationship, _target = mysql_cmp)161 result = mysql_dependency.print_element(ARCADIAXMLPrinter())162 self.assertEqual(flatten_str(result), flatten_str(expected_rusult))163 def test_graph_with_dependencies(self):164 expected_rusult = '''165 <GraphNode>166 <NID>graph_node_wordpress_id</NID>167 <CNID>wordpress_id</CNID>168 <GraphDependency>169 <CEPCID>mysqltcp_cepcid</CEPCID>170 <ECEPID>mysqltcp</ECEPID>171 <NID>NID</NID>172 </GraphDependency>173 </GraphNode>174 '''175 wrap_comp_type = ['cloudify.nodes.Root', 'cloudify.nodes.SoftwareComponent', 'cloudify.arcadia.nodes.WrappedComponent']176 mock_wordpress = CloudifyWorlkflowNodeInstanceMock(type_hierarchy = wrap_comp_type)177 mock_wordpress._node_instance.runtime_properties['nid'] = 'graph_node_wordpress_id'178 mock_wordpress._node_instance.runtime_properties['cnid'] = 'wordpress_id'179 mock_msql = CloudifyWorlkflowNodeInstanceMock(type_hierarchy = wrap_comp_type)180 mock_msql._node_instance.runtime_properties['nid'] = 'graph_node_mysql_id'181 mock_msql._node_instance.runtime_properties['cnid'] = 'mysql_id'182 mock_msql._node_instance.runtime_properties['cepcid'] = 'mysqltcp_cepcid'183 mock_msql._node_instance.runtime_properties['ecepid'] = 'mysqltcp'184 con_to_type = ['cloudify.relationships.depends_on', 'cloudify.relationships.connected_to', 185 'cloudify.arcadia.relationships.connected_to', 'wordpress_connected_to_mysql']186 mock_relationship = CloudifyWorkflowRelationshipInstanceMock(node_instance = mock_msql, 187 relationship_instance = {188 'runtime_properties' : {'nid': 'NID'}189 },190 type_hierarchy = con_to_type)191 ComponentFactoryFacade.set_factory(ComponentFactory())192 wp_cmp = ComponentFactoryFacade.INSTANCE.create_component(_instance = mock_wordpress)193 mysql_cmp = ComponentFactoryFacade.INSTANCE.create_component(_instance = mock_msql)194 mysql_dep = ComponentFactoryFacade.INSTANCE.create_component_dependency(_instance = mock_relationship, _source = wp_cmp, _target = mysql_cmp)195 wp_cmp.add_dependency(mysql_dep)196 result = wp_cmp.print_element(ARCADIAXMLPrinter())197 self.assertEqual(flatten_str(result), flatten_str(expected_rusult))198 def test_complete_service_graph(self):199 expected_rusult = '''200 <ServiceGraph xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="ArcadiaModellingArtefacts.xsd">201 <DescriptiveSGMetadata>202 <SGID>wordpress_mysql_service_graph_id</SGID>203 <SGName>SimpleWordPressServiceGraph</SGName>204 <SGDescription>SGDescription</SGDescription>205 </DescriptiveSGMetadata>206 <GraphNodeDescriptor>207 <GraphNode>208 <NID>graph_node_mysql_id</NID>209 <CNID>mysql_id</CNID>210 </GraphNode>211 <GraphNode>212 <NID>graph_node_wordpress_id</NID>213 <CNID>wordpress_id</CNID>214 <GraphDependency>215 <CEPCID>mysqltcp_cepcid</CEPCID>216 <ECEPID>mysqltcp</ECEPID>217 <NID>NID</NID>218 </GraphDependency>219 </GraphNode>220 </GraphNodeDescriptor>221 <RuntimePolicyDescriptor>222 <RuntimePolicy>223 <RPID>RPID</RPID>224 <RPName>RPName</RPName>225 </RuntimePolicy>226 </RuntimePolicyDescriptor>227 </ServiceGraph> 228 '''229 srv_graph_type = ['cloudify.nodes.Root', 'cloudify.arcadia.nodes.ServiceGraph']230 runtime_type = ['cloudify.nodes.Root', 'cloudify.arcadia.nodes.RuntimePolicy']231 wrap_comp_type = ['cloudify.nodes.Root', 'cloudify.nodes.SoftwareComponent', 'cloudify.arcadia.nodes.WrappedComponent']232 sg_mock = CloudifyWorlkflowNodeInstanceMock(type_hierarchy = srv_graph_type)233 sg_mock._node_instance.runtime_properties['sgid'] = 'wordpress_mysql_service_graph_id'234 sg_mock._node_instance.runtime_properties['sgname'] = 'SimpleWordPressServiceGraph'235 sg_mock._node_instance.runtime_properties['sgdesc'] = 'SGDescription'236 wp_mock = CloudifyWorlkflowNodeInstanceMock(type_hierarchy = wrap_comp_type)237 wp_mock._node_instance.runtime_properties['nid'] = 'graph_node_wordpress_id'238 wp_mock._node_instance.runtime_properties['cnid'] = 'wordpress_id'239 mysql_mock = CloudifyWorlkflowNodeInstanceMock(type_hierarchy = wrap_comp_type)240 mysql_mock._node_instance.runtime_properties['nid'] = 'graph_node_mysql_id'241 mysql_mock._node_instance.runtime_properties['cnid'] = 'mysql_id'242 mysql_mock._node_instance.runtime_properties['cepcid'] = 'mysqltcp_cepcid'243 mysql_mock._node_instance.runtime_properties['ecepid'] = 'mysqltcp'244 rp_mock = CloudifyWorlkflowNodeInstanceMock(type_hierarchy = runtime_type)245 rp_mock._node_instance.runtime_properties['rpid'] = 'RPID'246 rp_mock._node_instance.runtime_properties['rpname'] = 'RPName'247 sg_mock._contained_instances.append(mysql_mock)248 sg_mock._contained_instances.append(wp_mock)249 sg_mock._contained_instances.append(rp_mock)250 sg_mock._node_instance['id'] = 'service_graph_gm17g6'251 mysql_mock._node_instance['id'] = 'mysql_x1m8sh'252 wp_mock._node_instance['id'] = 'wordpress_k8lr3c'253 rp_mock._node_instance['id'] = 'runtime_policy_7vy2nn'254 con_in_type = ['cloudify.relationships.contained_in', 'cloudify.arcadia.relationships.contained_in']255 con_to_type = ['cloudify.relationships.depends_on', 'cloudify.relationships.connected_to', 256 'cloudify.arcadia.relationships.connected_to', 'wordpress_connected_to_mysql']257 mysql_mock._relationship_instances['service_graph_gm17g6'] = CloudifyWorkflowRelationshipInstanceMock(258 node_instance = sg_mock,259 type_hierarchy = con_in_type)260 wp_mock._relationship_instances['service_graph_gm17g6'] = CloudifyWorkflowRelationshipInstanceMock(261 node_instance = sg_mock, type_hierarchy = con_in_type)262 wp_mock._relationship_instances['mysql_x1m8sh'] = CloudifyWorkflowRelationshipInstanceMock(263 node_instance = mysql_mock, 264 relationship_instance = {265 'runtime_properties' : {'nid': 'NID'} 266 },267 type_hierarchy = con_to_type)268 rp_mock._relationship_instances['service_graph_gm17g6'] = CloudifyWorkflowRelationshipInstanceMock(269 node_instance = sg_mock,270 type_hierarchy = con_in_type)271 graph_builder = GraphBuilder(_comp_factory = ComponentFactory())272 service_graph = graph_builder.build(sg_mock)273 result = service_graph.print_element(ARCADIAXMLPrinter())274 self.assertEqual(flatten_str(result), flatten_str(expected_rusult))275 def test_service_graph_builder(self):276 srv_graph_type = ['cloudify.nodes.Root', 'cloudify.arcadia.nodes.ServiceGraph']277 runtime_type = ['cloudify.nodes.Root', 'cloudify.arcadia.nodes.RuntimePolicy']278 wrap_comp_type = ['cloudify.nodes.Root', 'cloudify.nodes.SoftwareComponent', 'cloudify.arcadia.nodes.WrappedComponent']279 sg_mock = CloudifyWorlkflowNodeInstanceMock(type_hierarchy = srv_graph_type)280 mysql_mock = CloudifyWorlkflowNodeInstanceMock(type_hierarchy = wrap_comp_type)281 wp_mock = CloudifyWorlkflowNodeInstanceMock(type_hierarchy = wrap_comp_type)282 rp_mock = CloudifyWorlkflowNodeInstanceMock(type_hierarchy = runtime_type)283 sg_mock._contained_instances.append(wp_mock)284 sg_mock._contained_instances.append(mysql_mock)285 sg_mock._contained_instances.append(rp_mock)286 sg_mock._node_instance['id'] = 'service_graph_gm17g6'287 mysql_mock._node_instance['id'] = 'mysql_x1m8sh'288 wp_mock._node_instance['id'] = 'wordpress_k8lr3c'289 rp_mock._node_instance['id'] = 'runtime_policy_7vy2nn'290 con_to_type = ['cloudify.relationships.depends_on', 'cloudify.relationships.connected_to',291 'cloudify.arcadia.relationships.connected_to', 'wordpress_connected_to_mysql']292 con_in_type = ['cloudify.relationships.contained_in', 'cloudify.arcadia.relationships.contained_in']293 mysql_mock._relationship_instances['service_graph_gm17g6'] = CloudifyWorkflowRelationshipInstanceMock(node_instance=sg_mock, type_hierarchy=con_in_type)294 wp_mock._relationship_instances['service_graph_gm17g6'] = CloudifyWorkflowRelationshipInstanceMock(node_instance=sg_mock, type_hierarchy=con_in_type)295 wp_mock._relationship_instances['mysql_x1m8sh'] = CloudifyWorkflowRelationshipInstanceMock(node_instance=mysql_mock, type_hierarchy=con_to_type)296 rp_mock._relationship_instances['service_graph_gm17g6'] = CloudifyWorkflowRelationshipInstanceMock(node_instance=sg_mock, type_hierarchy=con_in_type)297 graph_builder = GraphBuilder(_comp_factory = ComponentFactory())298 service_graph = graph_builder.build(sg_mock)299 self.assertTrue(isinstance(service_graph, ServiceGraphElement))300 self.assertTrue(len(service_graph.components) == 2)301 self.assertTrue(len(service_graph.policies) == 1)302 def find_component(array, component):303 for comp in array:304 if comp._instance == component:305 return comp306 return307 mysql_comp = find_component(service_graph.components, mysql_mock)308 wp_comp = find_component(service_graph.components, wp_mock)309 self.assertTrue(mysql_comp)310 self.assertTrue(wp_comp)311 self.assertTrue(len(wp_comp.dependencies) == 1)...

Full Screen

Full Screen

test_http_transfer.py

Source:test_http_transfer.py Github

copy

Full Screen

1# Copyright 2015 VMware, Inc. All Rights Reserved.2#3# Licensed under the Apache License, Version 2.0 (the "License"); you may not4# use this file except in compliance with the License. You may obtain a copy5# of the License at http://www.apache.org/licenses/LICENSE-2.06#7# Unless required by applicable law or agreed to in writing, software8# distributed under the License is distributed on an "AS IS" BASIS, without9# warranties or conditions of any kind, EITHER EXPRESS OR IMPLIED. See the10# License for then specific language governing permissions and limitations11# under the License.12import unittest13import uuid14from hamcrest import * # noqa15from mock import MagicMock16from mock import patch17from nose_parameterized import parameterized18from common import services19from common.service_name import ServiceName20from gen.host import Host21from gen.host.ttypes import ServiceTicketRequest22from gen.host.ttypes import ServiceTicketResultCode23from gen.host.ttypes import ServiceType24from host.hypervisor.esx.http_disk_transfer import HttpNfcTransferer25from host.hypervisor.esx.vim_client import VimClient26class TestHttpTransfer(unittest.TestCase):27 """Http Transferer tests."""28 @patch.object(VimClient, "acquire_credentials")29 @patch("pysdk.connect.Connect")30 def setUp(self, connect, creds):31 self.host_uuid = str(uuid.uuid4())32 VimClient.host_uuid = self.host_uuid33 self.image_ds = "image_ds"34 creds.return_value = ["username", "password"]35 self.vim_client = VimClient(auto_sync=False)36 self.patcher = patch("host.hypervisor.esx.vm_config.GetEnv")37 self.patcher.start()38 services.register(ServiceName.AGENT_CONFIG, MagicMock())39 self.http_transferer = HttpNfcTransferer(self.vim_client,40 self.image_ds)41 def tearDown(self):42 self.vim_client.disconnect(wait=True)43 self.patcher.stop()44 @parameterized.expand([45 (True,), (False,)46 ])47 @patch("host.hypervisor.esx.http_disk_transfer.VimClient")48 @patch("host.hypervisor.esx.http_disk_transfer.DirectClient")49 def test_get_remote_connections(self, get_svc_ticket_success, _client_cls,50 _vim_client_cls):51 host = "mock_host"52 port = 883553 get_service_ticket_mock = MagicMock()54 if get_svc_ticket_success:55 get_service_ticket_mock.result = ServiceTicketResultCode.OK56 else:57 get_service_ticket_mock.result = ServiceTicketResultCode.NOT_FOUND58 instance = _client_cls.return_value59 instance.get_service_ticket.return_value = get_service_ticket_mock60 if get_svc_ticket_success:61 (agent_conn,62 vim_conn) = self.http_transferer._get_remote_connections(63 host, port)64 _client_cls.assert_called_once_with(65 "Host", Host.Client, host, port)66 instance.connect.assert_called_once_with()67 request = ServiceTicketRequest(service_type=ServiceType.VIM)68 instance.get_service_ticket.assert_called_once_with(request)69 _vim_client_cls.assert_called_once_with(70 host=host, ticket=get_service_ticket_mock.vim_ticket,71 auto_sync=False)72 self.assertEqual(agent_conn, instance)73 self.assertEqual(vim_conn, _vim_client_cls.return_value)74 else:75 self.assertRaises(76 ValueError, self.http_transferer._get_remote_connections,77 host, port)78 @parameterized.expand([79 (None, "http://*/ha-nfc/x.vmdk", "http://actual_host/ha-nfc/x.vmdk"),80 (None, "https://*/foo", "https://actual_host/foo"),81 (None, "http://*:1234/foo", "http://actual_host:1234/foo"),82 (None, "https://host/foo", "https://host/foo")83 ])84 def test_ensure_host_in_url(self, _, url, replaced_url):85 host = "actual_host"86 result = self.http_transferer._ensure_host_in_url(url, host)87 self.assertEqual(result, replaced_url)88 def test_export_shadow_vm(self):89 self.http_transferer._get_disk_url_from_lease = MagicMock()90 self.http_transferer._wait_for_lease = MagicMock()91 mock_get_vm = MagicMock()92 mock_lease = MagicMock()93 self.vim_client.get_vm_obj_in_cache = mock_get_vm94 mock_get_vm.return_value.ExportVm.return_value = mock_lease95 lease, url = self.http_transferer._export_shadow_vm()96 mock_get_vm.assert_called_once_with(self.http_transferer._shadow_vm_id)97 mock_get_vm.return_value.ExportVm.assert_called_once_with()98 self.http_transferer._wait_for_lease.assert_called_once_with(99 mock_lease)100 self.http_transferer._get_disk_url_from_lease.assert_called_once_with(101 mock_lease)102 def test_ensure_shadow_vm(self):103 self.http_transferer._vm_manager.create_vm = MagicMock()104 self.http_transferer._ensure_shadow_vm()105 create_vm = self.http_transferer._vm_manager.create_vm106 self.assertTrue(create_vm.called)107 vm_id_arg, vm_spec_arg = create_vm.call_args_list[0][0]108 expected_vm_id = "shadow_%s" % self.host_uuid109 self.assertEqual(vm_id_arg, expected_vm_id)110 self.assertEqual(111 vm_spec_arg.files.vmPathName,112 '[] /vmfs/volumes/%s/vms/%s' % (self.image_ds, expected_vm_id[:2]))113 def test_configure_shadow_vm_with_disk(self):114 image_id = "fake_image_id"115 vm_mgr = self.http_transferer._vm_manager116 vm_mgr.update_vm = MagicMock()117 spec_mock = MagicMock()118 info_mock = MagicMock()119 vm_mgr.update_vm_spec = MagicMock(return_value=spec_mock)120 vm_mgr.get_vm_config = MagicMock(return_value=info_mock)121 vm_mgr.remove_all_disks = MagicMock()122 vm_mgr.add_disk = MagicMock()123 self.http_transferer._configure_shadow_vm_with_disk(image_id)124 expected_vm_id = "shadow_%s" % self.host_uuid125 vm_mgr.update_vm_spec.assert_called_once_with()126 vm_mgr.get_vm_config.assert_called_once_with(expected_vm_id)127 vm_mgr.remove_all_disks.assert_called_once_with(spec_mock, info_mock)128 vm_mgr.add_disk.assert_called_once_with(129 spec_mock, self.image_ds, image_id, info_mock, disk_is_image=True)130 def test_get_image_stream_from_shadow_vm(self):131 image_id = "fake_image_id"132 lease_mock = MagicMock()133 url_mock = MagicMock()134 xferer = self.http_transferer135 xferer._ensure_shadow_vm = MagicMock()136 xferer._export_shadow_vm = MagicMock(137 return_value=(lease_mock, url_mock))138 xferer._configure_shadow_vm_with_disk = MagicMock()139 xferer._ensure_host_in_url = MagicMock(140 return_value=url_mock)141 lease, url = self.http_transferer._get_image_stream_from_shadow_vm(142 image_id)143 xferer._ensure_shadow_vm.assert_called_once_with()144 xferer._export_shadow_vm.assert_called_once_with()145 xferer._configure_shadow_vm_with_disk.assert_called_once_with(image_id)146 xferer._ensure_host_in_url.assert_called_once_with(url_mock,147 "localhost")148 self.assertEqual(lease, lease_mock)149 self.assertEqual(url, url_mock)150 @patch("uuid.uuid4", return_value="fake_id")151 @patch("pyVmomi.vim.vm.VmImportSpec")152 def test_create_import_vm_spec(self, mock_vm_imp_spec_cls, mock_uuid):153 image_id = "fake_image_id"154 destination_datastore = "fake_datastore"155 create_spec_mock = MagicMock()156 create_empty_disk_mock = MagicMock()157 xferer = self.http_transferer158 xferer._vm_config.create_spec_for_import = create_spec_mock159 xferer._vm_manager.create_empty_disk = create_empty_disk_mock160 spec = xferer._create_import_vm_spec(image_id, destination_datastore)161 expected_vm_id = "h2h_fake_id"162 create_spec_mock.assert_called_once_with(163 vm_id=expected_vm_id, image_id=image_id,164 datastore=destination_datastore, memory=32, cpus=1)165 create_empty_disk_mock.assert_called_once_with(166 create_spec_mock.return_value, destination_datastore, None,167 size_mb=1)168 mock_vm_imp_spec_cls.assert_called_once_with(169 configSpec=create_empty_disk_mock.return_value)170 self.assertEqual(spec, mock_vm_imp_spec_cls.return_value)171 def test_get_url_from_import_vm(self):172 host = "mock_host"173 lease_mock = MagicMock()174 url_mock = MagicMock()175 import_spec = MagicMock()176 rp_mock = MagicMock()177 folder_mock = MagicMock()178 vim_client_mock = MagicMock()179 vim_client_mock.host = host180 xferer = self.http_transferer181 xferer._wait_for_lease = MagicMock()182 xferer._get_disk_url_from_lease = MagicMock(return_value=url_mock)183 xferer._ensure_host_in_url = MagicMock(return_value=url_mock)184 vim_client_mock.root_resource_pool = rp_mock185 vim_client_mock.vm_folder = folder_mock186 rp_mock.ImportVApp.return_value = lease_mock187 lease, url = xferer._get_url_from_import_vm(vim_client_mock,188 import_spec)189 rp_mock.ImportVApp.assert_called_once_with(190 import_spec, folder_mock)191 xferer._wait_for_lease.assert_called_once_with(192 lease_mock)193 xferer._get_disk_url_from_lease.assert_called_once_with(lease_mock)194 xferer._ensure_host_in_url.assert_called_once_with(url_mock, host)195 self.assertEqual(lease, lease_mock)196 self.assertEqual(url, url_mock)197 @patch("os.unlink")198 def test_send_image_to_host(self, mock_unlink):199 host = "mock_host"200 port = 8835201 image_id = "fake_image_id"202 destination_datastore = "fake_datastore"203 read_lease_mock = MagicMock()204 from_url_mock = MagicMock()205 write_lease_mock = MagicMock()206 to_url_mock = MagicMock()207 import_spec_mock = MagicMock()208 xferer = self.http_transferer209 xferer._get_image_stream_from_shadow_vm = MagicMock(210 return_value=(read_lease_mock, from_url_mock))211 xferer.download_file = MagicMock()212 vim_conn_mock = MagicMock()213 agent_conn_mock = MagicMock()214 xferer._get_remote_connections = MagicMock(215 return_value=(agent_conn_mock, vim_conn_mock))216 xferer._create_import_vm_spec = MagicMock(217 return_value=import_spec_mock)218 xferer._get_url_from_import_vm = MagicMock(219 return_value=(write_lease_mock, to_url_mock))220 xferer.upload_file = MagicMock()221 self.http_transferer.send_image_to_host(222 image_id, destination_datastore, host, port)223 xferer._get_image_stream_from_shadow_vm.assert_called_once_with(224 image_id)225 shadow_vm_id = "shadow_%s" % self.host_uuid226 expected_tmp_file = "/vmfs/volumes/%s/%s_transfer.vmdk" % (227 self.image_ds, shadow_vm_id)228 xferer.download_file.assert_called_once_with(229 from_url_mock, expected_tmp_file)230 read_lease_mock.Complete.assert_called_once_with()231 xferer._create_import_vm_spec.assert_called_once_with(232 image_id, destination_datastore)233 xferer._get_url_from_import_vm.assert_called_once_with(234 vim_conn_mock, import_spec_mock)235 xferer.upload_file.assert_called_once_with(236 expected_tmp_file, to_url_mock)237 write_lease_mock.Complete.assert_called_once_with()...

Full Screen

Full Screen

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.

LambdaTest Learning Hubs:

YouTube

You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.

Run Lemoncheesecake automation tests on LambdaTest cloud grid

Perform automation testing on 3000+ real desktop and mobile devices online.

Try LambdaTest Now !!

Get 100 minutes of automation test minutes FREE!!

Next-Gen App & Browser Testing Cloud

Was this article helpful?

Helpful

NotHelpful