def ppsk_manual_create_user():
    wui = WebUI()
    config = Configuration(wui.d("visit.url"), wui.d("visit.title"), wui.d("visit.pre_url"))
    if wui.session_id:
        config.to_page_before_deployed_ssid()
        #---------------------------------add a user group ------------------------------------

        wui.input(SsidPage.get('Input_ssid_textarea'), wui.d("ssid.ssid_name"))
        wui.input(SsidPage.get('Input_ssid_boardcast_textarea'), wui.d("ssid.ssid_boardcast_name"))
        wui.info('handle input the name of ssid boardcast name', True)

        wui.info('will move scroll to access security...', True)
        wui.move_scroll_to_element(DeployedSSID.get('access_div'))
        wui.wait_until_element_displayed(DeployedSSID.get('access_8021x_label'))
        wui.click(SsidPage.get('Select_PPSK'))
        wui.info('select access security is private psk end.', True)
        
        wui.click(SsidPage.get('Add_user_group_button'))
        wui.info('ge to select user group page', True)
        
        wui.click(SsidPage.get('new_user_group_button'))
        wui.info('ge to create user group page', True)
        config.wait_deploy_element(1)
        
        wui.input(SsidPage.get('Input_user_group_name_textarea'), wui.d("ssid.user_group_name"))
        wui.info('input the name of user group name', True)
        config.wait_deploy_element(1)
        
        wui.click(SsidPage.get('Save_button_new_user_group_page'))
        wui.info('save the created user group', True)
        config.wait_deploy_element(1)
        
        click_to_add_user_of_usergroup(wui, wui.d("ssid.user_group_name"))
        wui.wait_until_element_displayed(SsidPage.get('user_account_list'))
        #---------------------------------add user to user group---------------------------------------------
        wui.click(SsidPage.get('Add_user_to_user_group_button'))
        wui.info('add user to user group', True)

        wui.input(SsidPage.get('Input_user_name_textarea'), wui.d("ssid.user_name"))
        wui.info('input the name of user', True)
        
        wui.input(SsidPage.get('Input_password_textarea'), wui.d("ssid.user_password"))
        wui.info('input the password of user', True)
        
        wui.input(SsidPage.get('Input_user_password_confirm_textarea'), wui.d("ssid.user_password"))
        wui.info('confirm the password of user', True)
        
        wui.click(SsidPage.get('Save_user_button'))
        wui.info('save the user', True)
        config.wait_deploy_element(1)
        wui.click(SsidPage.get('Cancel_button_of_user_in_user_group_page'))
        wui.info('to select usergroup page', True)

        config.wait_deploy_element(1)
        add_user_group_to_ssid_and_save(wui, wui.d("ssid.user_group_name"))
        wui.info('select the defiend user group and save', True)
        
        config.wait_deploy_element(1)
        wui.info('handle create a new ppsk ssid pic', True)
        wui.click(DeployedSSID.get('save_btn'))
示例#2
0
class CLOUD(object):
    # TODO:
    # - based on reply from qa team, the access url should be full qualified
    # name or ip address base on auth conf. since the web server might not be
    # resolved in testing environment or against certain conf which may cause
    # problem when verifying traffic pass-through successfully or not. pre_url
    # is temporary solution which is used to trigger the auth process. for
    # example, pre_url in full qualified name to trigger auth process while
    # url in ip address to verify traffic.
    def __init__(self, url, title, pre_url=None):
        self.url = url
        self.title = title
        self.pre_url = pre_url if pre_url else url

        self.w = WebUI()
        self.mode = None
        self.popup = None

    def check_cloud_on(self, locator, displayed):
        for i in range(4):
            try:
                self.w.wait_until_element_displayed(displayed)
                break
            except Exception, e:
                self.w.warn('Fail to find element %s, before check %s, will try again' \
                          %(str(displayed), str(locator)), True)
        if i == 3:
            raise WebUIException('Fail to find element %s, before check %s' \
                %(str(displayed), str(locator)))

        check_element = self.w.find_element(locator)
        if not check_element.is_selected():
            check_element.click()
def hshao_login():
    wui = WebUI()
    cloud = CLOUD(wui.d("visit.url"), wui.d("visit.title"), wui.d("visit.pre_url"))
    if wui.session_id:
        wui.click(myHome.get('Add_device_button'))
        wui.info('go to add device page', True)
        
        wui.input(myHome.get('Add_networkPolicy'), wui.d("visit.network_policy_name"))
        wui.info('go to add network policy page', True)
        
        wui.click(myHome.get('Next_button_networkPolicy'))
        wui.info('save network policy', True)
        
        wui.click(PolicyPage.get('Deploy_button'))
        wui.info('to device page', True)

        mac_element = DeployPolicyPage.get('Device_mac_xpath')
        checkbox_element = DeployPolicyPage.get('Device_checkbox_xpath')
        stat_element =  DeployPolicyPage.get('Device_stat_xpath')
        
        device_mac = wui.d("device.ap_mac")    
        i=1
        while 1:
            new_mac_element = (mac_element[0], mac_element[1] % i)
            new_checkbox_element = (checkbox_element[0], checkbox_element[1] % i)
            new_stat_element = (stat_element[0], stat_element[1] % i)
            try:
                wui.wait_until_element_displayed(new_mac_element)
                print new_mac_element
                if device_mac == wui.find_element(new_mac_element).text:
                    print wui.find_element(new_mac_element).text
                    try:
                        wui.wait_until_element_displayed(new_stat_element)
                    except Exception, e:
                        wui.error('this device status is false disconnect', True)
                        break
                    wui.click(new_checkbox_element)
                    wui.info('selected the checkbox success', True)
                    break
            except Exception, e:
                wui.error('device is not found in device list ', True)
                break
            i+=1        
        
        wui.click(monitor_cfg.Config_upload_button)
        wui.info('click upload to push complete config', True)
        
        wui.click(myHome.get('Devices_button'))
        wui.info('go to add device page', True)
        
        click_netpolicy_devicepage_filters(wui,wui.d("visit.network_policy_name"))
        wui.click(FiltersDevicepage.get('check_box_realdevice'))
        
        ap_mac = wui.d("device.ap_mac")
        print "the ap mac is :"
        print ap_mac
        check_device_devicepage(wui, ap_mac)
class Configuration(object):
    def __init__(self):
        self.w = WebUI()                         

    def create_config(self, config_object):
        getattr(self, config_object)(action='create')

    def remove_config(self, config_object):
        getattr(self, config_object)(action='remove')
    
    def navi_menu(self, name):
        self.w.click(ConfigurationPage.get('configuration_lnk'))
        self.w.wait_for_page_to_load()                
        self.w.click(NavigationPage.get('show_nav_link'))
        if name == 'ssids':
            self.w.click(NavigationPage.get('ssids_link'))
        if name == 'user_profiles':
            self.w.click(NavigationPage.get('user_profiles_link'))        
        if name == 'network_policies':
            self.w.click(NavigationPage.get('network_policies_link'))
        if name == 'vlans':
            self.w.click(NavigationPage.get('adv_config_link'), NavigationPage.get('common_objects_link'))
            self.w.click(NavigationPage.get('common_objects_link'), NavigationPage.get('vlans_link'))
            self.w.click(NavigationPage.get('vlans_link'))
        if name == 'dns_assignment':
            self.w.click(NavigationPage.get('adv_config_link'), NavigationPage.get('mgt_services_link'))
            self.w.click(NavigationPage.get('mgt_services_link'), NavigationPage.get('dns_assign_link'))            
            self.w.click(NavigationPage.get('dns_assign_link'))
        if name == 'ntp_assignment':
            self.w.click(NavigationPage.get('adv_config_link'), NavigationPage.get('mgt_services_link'))
            self.w.click(NavigationPage.get('mgt_services_link'), NavigationPage.get('ntp_assign_link'))  
            self.w.click(NavigationPage.get('ntp_assign_link'))
        if name == 'device_aaa_server':
            self.w.click(NavigationPage.get('adv_config_link'), NavigationPage.get('authentication_link'))
            self.w.click(NavigationPage.get('authentication_link'), NavigationPage.get('device_aaa_server_link'))
            self.w.click(NavigationPage.get('device_aaa_server_link'))
        if name == 'aaa_user_dir':
            self.w.click(NavigationPage.get('adv_config_link'), NavigationPage.get('authentication_link'))
            self.w.click(NavigationPage.get('authentication_link'), NavigationPage.get('aaa_user_dir_link'))
            self.w.click(NavigationPage.get('aaa_user_dir_link'))
        if name == 'aaa_client_settings':
            self.w.click(NavigationPage.get('adv_config_link'), NavigationPage.get('authentication_link'))
            self.w.click(NavigationPage.get('authentication_link'), NavigationPage.get('aaa_client_settings_link'))
            self.w.click(NavigationPage.get('aaa_client_settings_link'))            
        if name == 'cwp_settings':
            self.w.click(NavigationPage.get('adv_config_link'), NavigationPage.get('authentication_link'))
            self.w.click(NavigationPage.get('authentication_link'), NavigationPage.get('cwp_link'))
            self.w.click(NavigationPage.get('cwp_link'))  

    def check_exist(self, name):
        try:
            self.w.wait_until_element_displayed(ProfileListPage.created_setting_link(name))
            return True                       
        except Exception, e:
            return False
def hshao_login():
    wui = WebUI()
    cloud = CLOUD(wui.d("visit.url"), wui.d("visit.title"), wui.d("visit.pre_url"))
    if wui.session_id is None:
        wui.info('trying to access %s before login' % wui.d("visit.url"))
        cloud.try_again_get(wui.d("visit.url"), LoginPage.get('login_page_title'))


        wui.wait_until_element_displayed(LoginPage.get('login_btn'))
        wui.input(LoginPage.get('username_txt'), wui.d("login.username"))
        wui.input(LoginPage.get('password_txt'), wui.d("login.password"))
        wui.info('handle login form', True)
        wui.click(LoginPage.get('login_btn'))

        try:
            wui.wait_until_title_present(LoginSuccessfulPage.get('login_successful_page_title'), info=True)
            wui.info('login success', True)
        except Exception, e:
            wui.s.execute_script('return window.onbeforeunload=null')
            wui.warn('Fail to get login_successful_page after login, will try again', True)
            wui.s.refresh()
            wui.wait_until_title_present(LoginSuccessfulPopupPage.get('login_successful_popup_page_title'), info=True)
            
        #---------------------------------is device connected ------------------------------------
        wui.click(myHome.get('Devices_button'))
        wui.info('go to add device page', True)
        

        #ckeck if the device is connected and 
        ap_sn = wui.d("device.ap_SN")
        click_hostname_devicepage(wui, ap_sn)
         
        connection_status_element = myHome.get('Device_connect_status')
        new_connection_status_element = wui.find_element(connection_status_element).text
        device_connection_status_str = "Connected"
        if device_connection_status_str == new_connection_status_element:
            wui.info('The device status on is Connected', True)
        else:
            wui.error('The device status is not Connected', True)
             
        wui.click(myHome.get('Devices_button'))
        wui.info('go to add device page', True)
        
        remove_device_devicepage(wui, ap_sn)
        
        wui.click(myHome.get('Conform_to_remove_device_button'))
        wui.info('confirm to remove device', True)
def hive_profile_create():
    wui = WebUI()
    config = Configuration(wui.d("visit.url"), wui.d("visit.title"))
    if wui.session_id:
        config.to_url_home()
        config.to_menu(wui.d("policy.menu_name"))
        config.wait_until_to_menu_success(wui.d("policy.menu_name"))
        config.to_page_before_policy()
        config.create_network_policy(wui.d("policy.name"), wui.d("policy.Description"))
       
        # go to addtional setting to check kddr default status of the created network policy
        wui.click(DeviceDataCollection.additional_setting_button)
        try:
            wui.wait_until_element_displayed(DeviceDataCollection.ntp_elements)
            wui.info( 'go to additional settings page success' , True ) 
        except Exception, e:
            wui.error( 'go to additional settings page failed' , True )
       
        #check hive profile section
        wui.info('try to click the Hive button to go to hive profile config page...', True)
        wui.click(HiveConfig.get('hive_tab'))
        time.sleep(5)
        wui.wait_until_element_displayed(HiveConfig.get('hive_profile_title'))
        wui.info( 'success to go to hive profile page...' , True )
        #input hive name
        hive_name = wui.d( "hive.name") 
        wui.input(HiveConfig.get('new_hive_name'), hive_name)
        wui.info( 'input hive name successfully...' , True )
        #input encryption password
        wui.info('go to security section and turn on the switch for encryption password...', True)
        config.check_cloud_on(HiveConfig.get('encryption_switch_input'),HiveConfig.get('encryption_switch_div'))
        time.sleep(1)
        wui.info("turn on the switch successfully...", True)
        wui.info("try to click the button manual and input password...", True)
        config.click_cloud(HiveConfig.get('manual_pwd_btn_input'),HiveConfig.get('manual_pwd_btn_div'))
        time.sleep(1)
        wui.info('success to select the encryption type as manual...', True)
        wui.input(HiveConfig.get('manual_share_pwd'),wui.d("hive.key"))
        time.sleep(1)
        wui.info('input share password successfully', True)
        wui.input(HiveConfig.get('manual_cfm_pwd'),wui.d("hive.key"))
        time.sleep(1)
        wui.info('input confirm password successfully', True)
        
        wui.info('click save button to save the hive profile setting...', True)
        wui.click(HiveConfig.get('hive_profile_save_btn'))
        wui.wait_until_element_displayed(HiveConfig.get('hive_profile_success'))
        time.sleep(1)
        wui.info( 'save the hive profile setting successfully', True)
        
        wui.info('click next buttong to go to deploy config to device page....', True)
        wui.click(HiveConfig.get('hive_profile_next_btn'))
        time.sleep(1)
        wui.info('go to config deploy page success....', True)
def mac_filter_configuration():
    wui = WebUI()
    config = Configuration(wui.d("visit.url"), wui.d("visit.title"))
    if wui.session_id:
        config.to_page_before_deployed_ssid()
        ssidname=wui.d("ssid.name")
        config.input_ssid_name(ssidname, ssidname)
        config.ssid_usage_settings('CUSTOM')

        #select to security method as wpa psk  
        psk_key="aerohive"      
        wui.info('will move scroll to access security...', True)
        wui.move_scroll_to_element(DeployedSSID.get('access_div'))
        wui.wait_until_element_displayed(DeployedSSID.get('psk_access_label'))
        wui.click(DeployedSSID.get('psk_access_span'))
        wui.wait_until_element_displayed(DeployedSSID.get('psk_key_value'))
        wui.input(DeployedSSID.get('psk_key_value'), psk_key)
        wui.wait_until_element_displayed(DeployedSSID.get('psk_confirm_value'))
        wui.input(DeployedSSID.get('psk_confirm_value'), psk_key)
        
        #select cwp tab to config cwp
        cwp_name = wui.d("ssid.cwp_name")
        wui.info('try to click captive web portal tab to enable cwp', True)
        wui.move_scroll_to_element_use_px(CWPConfig.get('ssid_tab'))
        wui.click(CWPConfig.get('cwp_tab'))
        wui.wait_until_element_displayed(CWPConfig.get('cwp_enable_switch'))
        wui.info('go to  cwp configuration section successfully...', True)
        #enable cwp switch
        wui.check(CWPConfig.get('cwp_enable_switch'))
        wui.info('enable cwp successfull....', True)
        
        #config cwp web directory name
        wui.info('try to move element to cwp name input line....', True)
        wui.move_scroll_to_element(CWPConfig.get('cwp_name_input_element'))
        wui.input(CWPConfig.get('cwp_to_use_input'),cwp_name)
        time.sleep(1)
        wui.info('input cwp name successfully', True)
        
        wui.info('try to click the save button to save the cwp object', True)
        wui.click(CWPConfig.get('cwp_to_use_save'))
        wui.wait_until_element_displayed(CWPConfig.get('new_cwp_title'))
        time.sleep(1)
        wui.info('go to new cwp page success...', True)
        
        wui.wait_until_element_displayed(CWPConfig.get('cwp_name'))
        wui.click(CWPConfig.get('new_cwp_save'))
        time.sleep(2)
        wui.info('try to move scroll to cwp section', True)
        wui.move_scroll_to_element(CWPConfig.get('cwp_name_input_element'))
        wui.info('create cwp successfully', True)
        
        # save the ssid level configuration
        wui.click(CWPConfig.get('new_ssid_save'))
        wui.wait_until_element_displayed(CWPConfig.get('new_ssid_success'))
        time.sleep(1)
        wui.info('Save ssid successfully', True)
        
        #go to deploy page, and push config
        wui.click(monitor_cfg.Deploy_policy_button)
        time.sleep(2)
        wui.info( 'go to deploy policy page success' , True )
def mac_filter_configuration():
    wui = WebUI()
    config = Configuration(wui.d("visit.url"), wui.d("visit.title"))
    if wui.session_id:
        config.to_url_home()
        config.to_menu(wui.d("policy.menu_name"))
        config.wait_until_to_menu_success(wui.d("policy.menu_name"))
        config.to_page_before_policy()
        config.create_network_policy(wui.d("policy.name"), wui.d("policy.Description"))
        wui.wait_until_element_displayed(SelectSSIDPage.get('new_btn'))
        wui.info('Get to SSID select page', True)
        wui.click(SelectSSIDPage.get('new_btn'))  
        #input ssid name
        ssidname=wui.d("ssid.name")
        wui.wait_until_element_displayed(ConfigSSIDPage.get('ssidname_input'))
        wui.info('Get to SSID configure page', True)
        wui.input(ConfigSSIDPage.get('ssidname_input'), ssidname)
        wui.clear(ConfigSSIDPage.get('ssidbroadname_input'))
        wui.input(ConfigSSIDPage.get('ssidbroadname_input'), ssidname)
        wui.info('Input SSID name successfully', True)
                
        #select customer checkbox
        wui.wait_until_element_displayed(DeployedSSID.get('custom_display'))
        wui.click(DeployedSSID.get('custom_span'))
        time.sleep(1)
        wui.info('Select custom option successfully', True)
        
        #select open auth checkbox
        wui.info("Enter to Open mode")
        wui.info('will move scroll to next access security section', True)
        wui.move_scroll_to_element(DeployedSSID.get('access_div'))
        wui.wait_until_element_displayed(DeployedSSID.get('open_access_label'))
        wui.click(DeployedSSID.get('open_access_span'))
        wui.info('Config open successfully', True)
        
        #check optional setting section for mac filter is displayed
        wui.info('will move scroll to bottom page', True)
        wui.move_scroll_bottom()
        wui.wait_until_element_displayed(MacFilter.get('optional_setting_desc_xpath'))
        
        #optional setting page title diplay
        wui.info('Try to click customize button to go to config page', True)
        wui.click(MacFilter.get('opt_customize_btn'))
        wui.info('go to optional setting config page successfully', True)
        
        #go to mac filter config sections
        #enable mac-filter function
        wui.click(MacFilter.get('mac_filter_checkbox'))
        wui.info('mac filter is enabled!', True)
        
        #check the default action is Permit
        global_default_action = "Permit"
        new_global_default_action = wui.find_element(MacFilter.get('mac_filter_default_action')).text
        if global_default_action == new_global_default_action:
            wui.info('the global default action is Permit, it is correct for default setting', True)
        else:
            wui.error('The default action is incorrect!', True)
            
        #click new to add an mac filter entry, for exmaple for apples devices
        wui.info('Try to move to add new mac filter entry section', True)
        wui.move_scroll_to_element_use_px(MacFilter.get('mac_filter_section'))
        wui.info('move to mac filter config section success', True)
        wui.click(MacFilter.get('mac_filter_entry_new_btn'))
        wui.wait_until_element_displayed(MacFilter.get('mac_filter_newentry_input_mac'))
        wui.info('the new mac filter section display success!', True)
        #select apple devices oui
        wui.click(MacFilter.get('mac_filter_newentry_select_mac_btn'))
        wui.wait_until_element_displayed(MacFilter.get('mac_entry_oui_apple'))
        wui.info('can show the mac list success!', True)
        wui.click(MacFilter.get('mac_entry_oui_apple'))
        wui.info('select the apple devices oui success!', True)
        #select the mac entry action as deny
        wui.click(MacFilter.get('mac_entry_action_btn'))
        wui.info('click the dropdown box success!', True)
        tmp_mac_entry_action=wui.find_element(MacFilter.get('mac_entry_action_deny')).text
        selected_mac_entry_action = tmp_mac_entry_action.upper()
        wui.click(MacFilter.get('mac_entry_action_deny'))
        wui.info('select the deny action success!', True)
        #add the mac entry
        wui.click(MacFilter.get('mac_entry_add_btn'))
        wui.info('add the mac entry success!', True)
        
        # click save button to save the config about optional settings
        
        new_mac_entry_oui = wui.find_element(MacFilter.get('added_mac_entry_oui_name')).text
        new_mac_entry_action = wui.find_element(MacFilter.get('added_mac_entry_action')).text


        if (new_mac_entry_oui == "Apple-iPhone") and (new_mac_entry_action == selected_mac_entry_action):
            wui.info('mac filter object is correct....', True)
        else:
            wui.error('mac-filter object is incorrect....', True)
            
        wui.click(MacFilter.get('optional_setting_save_btn'))
        
        # save the ssid level configuration
        wui.click(MacFilter.get('ssid_saved_btn'))
        wui.wait_until_element_displayed(MacFilter.get('ssid_saved_success'))
        wui.info('Save ssid successfully', True)
        
        #go to deploy page, and push config
        wui.click(monitor_cfg.Deploy_policy_button)
        time.sleep(2)
        wui.info( 'go to deploy policy page success' , True )
def data_collect_default_config_push():
    wui = WebUI()
    config = Configuration(wui.d("visit.url"), wui.d("visit.title"), wui.d("visit.pre_url"))
    if wui.session_id:
        config.to_url_home()
        config.to_menu(wui.d("policy.menu_name"))
        config.wait_until_to_menu_success(wui.d("policy.menu_name"))
           
        wui.click(monitor_cfg.Configuration_button)
        wui.info( 'go to configuration page success' , True )
       
        wui.click(monitor_cfg.add_button)
        wui.info( 'go to add network policy page success' , True )
       
        policyname = wui.d( "sw_policy_name")
        #policyname = "wwwu-2257"
        wui.input(monitor_cfg.get( 'PolicyName_txt'), policyname)
        wui.input(monitor_cfg.get( 'PolicyDesc_txt'), wui.d("NetworkPolicy.PolicyDesc" ))
        wui.info( 'input policy name and description success' , True )
       
        wui.click(monitor_cfg.Next_button)
        wui.info( 'create network policy success', True )
       
        # go to addtional setting to check kddr default status of the created network policy
        wui.click(DeviceDataCollection.additional_setting_button)
        try:
            wui.wait_until_element_displayed(DeviceDataCollection.ntp_elements)
            wui.info( 'go to additional settings page success' , True ) 
        except Exception, e:
            wui.error( 'go to additional settings page failed' , True )
       
        #check the sections of data collection displayed
        wui.click(DeviceDataCollection.data_collection_btn)
        #wui.wait_until_element_displayed(DeviceDataCollection.application_identify_switch)
        time.sleep(5)
    
        #change the application_identify switch as off
        wui.wait_until_element_displayed(DeviceDataCollection.get('application_identify_xpath'))
        wui.info( 'application visibility and control section displayed' , True )
        wui.check(DeviceDataCollection.get('application_identify_xpath'))
        time.sleep(2)
        wui.info('turn off switch for application identification success!', True)
    
        #change the section of statistic collection settings
        wui.wait_until_element_displayed(DeviceDataCollection.get('statistic_collection_xpath'))
        wui.info( 'statistic collection section displayed' , True )
        wui.check(DeviceDataCollection.get('statistic_collection_xpath'))
        time.sleep(2)
        wui.info('turn off switch for statistic collection success!', True)
        
        #change the section of kddr setting
        wui.move_scroll_bottom()
        wui.wait_until_element_displayed(DeviceDataCollection.get('kddr_name'))
        wui.wait_until_element_displayed(DeviceDataCollection.get('kddr_xpath'))
        #wui.check(DeviceDataCollection.get('kddr_xpath'))
        wui.click(DeviceDataCollection.get('kddr_xpath'))
        time.sleep(2)
        wui.info('turn on switch for kddr success', True)
       
        #click save button to save the configuration
        wui.click(DeviceDataCollection.data_collection_save_btn)
        wui.wait_until_element_displayed(DeviceDataCollection.data_collection_save_info)
        wui.info('the device data collection can be saved successfully', True )
示例#10
0
class HM(object):
    def __init__(self):
        self.w = WebUI()
        self.mode = None
        self.configer = Configuration()
    
    def admin_mode(self):
        self.mode = 'admin'
    
    def vhm_mode(self):
        self.mode = 'vhm'
    
    def is_admin_mode(self):
        return self.mode == 'admin'
    
    def is_vhm_mode(self):
        return self.mode == 'vhm'
      
    def _login(self, server, user, passwd):
        self.server = server
        self.user = user
        self.passwd = passwd
        
        self.w.info('trying to login %s as %s:%s' % (self.server, self.user, self.passwd))
        
        self.w.get(self.server)
        self.w.wait_until_element_displayed(LoginPage.get('login_btn'))
        self.w.check_title(LoginPage.get('login_page_title'), 'check title after open')
        
        self.w.input(LoginPage.get('username_txt'), self.user)
        self.w.input(LoginPage.get('password_txt'), self.passwd)
        
        self.w.info('login', True)
        self.w.click(LoginPage.get('login_btn'))

    def login(self, server, user, passwd):
        self.admin_mode()
        
        self._login(server, user, passwd)
        self.w.wait_until_element_displayed(MainPage.get('monitor_lnk'))
        
        self.w.register_cleanup(self.logout)

    def login_by_vhm(self, server, vhm_user, vhm_passwd, hive_name=None, hive_mgt_passwd=None, quick_ssid_passwd=None):
        self.vhm_mode()
        
        self._login(server, vhm_user, vhm_passwd)
        def __tmp(w):
            return w.s.title != LoginPage.get('login_page_title')
        self.w.wait_until(__tmp, msg='login page navigated')
        if self.w.title == EULAPage.get('eula_page_title'):
            self.w.wait_until_element_displayed(EULAPage.get('agree_btn'))
            self.w.info('agree with EUAL', True)
            self.w.click(EULAPage.get('agree_btn'))
            self.w.wait_until_element_displayed(WelcomePage.get('continue_btn'))
            self.w.check_title(WelcomePage.get('welcome_page_title'))
        
            self.w.input(WelcomePage.get('hive_name_txt'), hive_name)
            self.w.input(WelcomePage.get('hive_mgt_passwd_txt'), hive_mgt_passwd)
            self.w.input(WelcomePage.get('hive_mgt_passwd_confirm_txt'), hive_mgt_passwd)
            self.w.check(WelcomePage.get('enterprise_mode_radio'))
            self.w.wait_until_element_displayed(WelcomePage.get('quick_ssid_passwd_txt'))
            self.w.input(WelcomePage.get('quick_ssid_passwd_txt'), quick_ssid_passwd)
            self.w.input(WelcomePage.get('quick_ssid_passwd_confirm_txt'), quick_ssid_passwd)
            
            self.w.info('handle initial configuration', True)
            self.w.click(WelcomePage.get('continue_btn'))
            self.w.check_title(MainPage.get('main_page_title'), 'check title after login')
            
            time.sleep(5)
            
        self.w.register_cleanup(self.logout)

    def to_hiveaps_table(self, type='all'):
        self.w.click(MainPage.get('monitor_lnk'))
        self.w.wait_until_title_present(HiveAPsPage.get('allAPs_page_title'))

        if type == 'all':
            self.w.click(HiveAPsPage.get('hive_aps_lnk'))
            self.w.wait_until_title_present(HiveAPsPage.get('hiveAPs_page_title'))

            self.w.click(HiveAPsPage.get('auto_refresh_off'))
            selecter = self.w.get_selecter(HiveAPsPage.get('device_per_page_sel'))
            if selecter.first_selected_option.text != '500':
                selecter.select_by_value('500')
                self.w.debug('after select page size', True)
        elif type == 'rogue':
            self.w.click(RogueAPsPage.get('rogue_aps_lnk'))
            self.w.wait_until_title_present(RogueAPsPage.get('rogueAPs_page_title'))

            selecter = self.w.get_selecter(RogueAPsPage.get('device_per_page_sel'))
            if selecter.first_selected_option.text != '500':
                selecter.select_by_value('500')

    def select_ap(self, text='', by='default'):
        if by == 'default':
            try:
                self.w.wait_until_element_displayed(APsTablePage.locate_checkbox(text))
            except Exception, e:
                self.w.warn('Cannot find: %s' % text, True)
            checkbox_disabled = self.w.find_element(APsTablePage.locate_checkbox(text)).get_attribute('disabled')       
            if checkbox_disabled == 'true':
                self.w.warn('not selectable AP: %s' % text, True)
            else:
                self.w.check(APsTablePage.locate_checkbox(text))
                self.w.info('after select AP: %s' % text, True)
        elif by == 'linktext':
            try:
                self.w.wait_until_element_displayed(APsTablePage.locate_checkbox_by_linktext(text))
            except Exception, e:
                self.w.warn('Cannot find: %s' % text, True)            
def firewall_rule_create():
    wui = WebUI()
    config = Configuration(wui.d("visit.url"), wui.d("visit.title"))
    if wui.session_id:
        config.to_page_before_deployed_ssid()
        # input ssid name
        ssidname=wui.d("ssid.name")
        wui.move_scroll_top()
        config.input_ssid_name(ssidname, ssidname)
        config.ssid_usage_settings('CUSTOM')
        config.set_access_security('open')
        config.wait_deploy_element(2)

        config.to_customize_user_profile_page()
        
        wui.move_scroll_by_element(FireWall.get('user_profile_tabs'))
        wui.info('move to user-profile tabs successfully!', True)

        wui.click(FireWall.get('security_tab_btn'))
        wui.info('go to security tab successfully', True)

        wui.info('try to turn on the switch to enable firewall', True)
        wui.check(FireWall.get('firewall_switch'))

        wui.move_scroll_bottom()

        #click dropdown box for firewall rules
        wui.click(FireWall.get('bound_traffic_dropdown_btn'))
        wui.info('click the dropdown box button successfully', True)
        wui.wait_until_element_displayed(FireWall.get('inbound_traffic_element'))
        wui.wait_until_element_displayed(FireWall.get('outbound_traffic_element'))
        wui.info('can display the inbound/outbound elements successfully', True)

        #select outbound traffic
        wui.click(FireWall.get('outbound_traffic_element'))

        outbound_traffic_element = "Outbound Traffic"
        selected_bound_traffic_element = wui.find_element(FireWall.get('bound_traffic_selected')).text
        if outbound_traffic_element == selected_bound_traffic_element:
            wui.info('selected the outbound element successfully', True)
        else:
            wui.error('failed selected the bound element', True)

        #config firewall rules default action
        wui.wait_until_element_displayed(FireWall.get('firwall_defaction_area'))
        wui.info('display firewall rules default action area sucessfully!', True)


        #select the firewall rules default actions is permit
        wui.info('Try to click the dropdown box...', True)
        wui.click(FireWall.get('firewall_defaction_dropdown_btn'))
        wui.wait_until_element_displayed(FireWall.get('firewall_defaction_deny_element'))
        wui.wait_until_element_displayed(FireWall.get('firewall_defaction_permit_element'))
        wui.info('Click the dropdown box success.....', True)
        wui.click(FireWall.get('firewall_defaction_permit_element'))
        wui.info('Success to select action Permit for firewall rules!', True)

        #add a new ip policy rules
        wui.click(FireWall.get('firewall_new_btn'))
        wui.wait_until_element_displayed(FireWall.get('new_firewall_page_title'))
        wui.info('go to new firewall page success', True)
        config.wait_deploy_element(1)


        config.user_profile_srcurce_ip(wui.d("userprofile.src_hostname"), wui.d("userprofile.src_hostip"))
        wui.info('selected the srcurce ip address successfully', True)
        config.user_profile_destination_ip(wui.d("userprofile.des_hostname"), wui.d("userprofile.des_hostip"))
        wui.info('selected the destination ip address successfully', True)
        config.user_profile_select_net_service()
        wui.info('handle to select service successfully', True)




        #config the rule action:
        wui.info('try to config the rule action as Deny', True)
        wui.click(FireWall.get('new_rule_action_btn'))
        wui.wait_until_element_displayed(FireWall.get('new_rule_action_nat'))
        wui.info('click the action dropdown box successfully', True)
        wui.info('try to select the deny action....', True)
        wui.click(FireWall.get('new_rule_action_deny'))
        wui.info('success to select the deny action...', True)
        
        #config the rule logging action:
        wui.info('try to config logging action as drop', True)
        wui.click(FireWall.get('new_rule_log_btn'))
        wui.wait_until_element_displayed(FireWall.get('new_rule_log_off'))
        wui.info('click the logging dropdown box successfully', True)
        wui.info('try to select drop packets....', True)
        wui.click(FireWall.get('new_rule_log_drop'))
        wui.info('success to select the drop logging...', True)
        
        #save the new ip firewall rule
        wui.info('try to save the ip rule setting...', True)
        wui.click(FireWall.get('new_rule_dialog_save'))
        wui.info('save the ip firewall rule success...', True)
        
        #check if the added ip rule correct
        wui.info('try to move scroll to bottom....', True)
        wui.move_scroll_bottom()
        wui.info('check if the added ip rule correct!...', True)
        added_rule_record = (FireWall.get('added_rule_record')[0], FireWall.get('added_rule_record')[1] %(wui.d("userprofile.src_hostname")))
        wui.wait_until_element_displayed(added_rule_record)
        wui.info('success to add ip firewall rule...', True)

        wui.info('Try to click save button to save the user-profile changing')
        wui.click(FireWall.get('user_profile_save_btn'))
        wui.info("Save user-profile success!", True)
        
        # save the ssid level configuration
        wui.click(FireWall.get('ssid_saved_btn'))
        wui.wait_until_element_displayed(FireWall.get('ssid_saved_success'))
        wui.info('Save ssid successfully', True)
def sw_device_overview_check():
    wui = WebUI()
    config = Configuration(wui.d("visit.url"), wui.d("visit.title"), wui.d("visit.pre_url"))
    if wui.session_id:
        config.to_url_home()
        config.to_menu(wui.d("policy.menu_name"))
        config.wait_until_to_menu_success(wui.d("policy.menu_name"))
        
        #go to monitor page to check the sw monitor information        
        wui.click(monitor_cfg.Device_list_button)
        wui.info('go to device list page success', True)
        
        device_entry_mac_element = monitor_cfg.get('Device_list_mac_xpath')
        device_entry_checkbox_element = monitor_cfg.get('Device_list_checkbox_xpath')
        device_entry_stat_element =  monitor_cfg.get('Device_list_stat_xpath')
        device_entry_ip_element = monitor_cfg.get('Device_list_ip_xpath')
        device_entry_hostname_element = monitor_cfg.get('Device_list_hostname_xpath')
        device_entry_sn_element = monitor_cfg.get('Device_list_sn_xpath')
        device_entry_ptype_element = monitor_cfg.get('Device_list_ptype_xpath')
        
        device_list_next_page = monitor_cfg.get('Device_list_next_page_xpath')
        device_list_next_page_disable = monitor_cfg.get('Device_list_next_page_disable_xpath')
         
        sw_mac = wui.d("dev_mgt0_mac")     
        
        is_page_exist=False
        page_num=1
        while not is_page_exist: 
            i=1
            find_mac_flag=0;
            while 1:
                new_device_entry_mac_element = (device_entry_mac_element[0], device_entry_mac_element[1] % i)
                new_device_entry_checkbox_element = (device_entry_checkbox_element[0], device_entry_checkbox_element[1] % i)
                new_device_entry_stat_element = (device_entry_stat_element[0], device_entry_stat_element[1] % i)
                new_device_entry_ip_element = (device_entry_ip_element[0], device_entry_ip_element[1] % i)
                new_device_entry_hostname_element = (device_entry_hostname_element[0], device_entry_hostname_element[1] % i)
                new_device_entry_sn_element = (device_entry_sn_element[0], device_entry_sn_element[1] % i)
                new_device_entry_ptype_element = (device_entry_ptype_element[0], device_entry_ptype_element[1] % i)
                
                try:
                    wui.wait_until_element_displayed(new_device_entry_mac_element)
                    if sw_mac == wui.find_element(new_device_entry_mac_element).text:
                        find_mac_flag=1
                        try:
                            wui.wait_until_element_displayed(new_device_entry_stat_element)
                        except Exception, e:
                            wui.error('this device status is false disconnect', True)
                            break
                        wui.click(new_device_entry_checkbox_element)
                        wui.info('selected the checkbox success', True)
                        is_page_exist=True
                        device_hostname_element = wui.find_element(new_device_entry_hostname_element).text
                        device_connection_status_str = "Connected"
                        wui.click(new_device_entry_hostname_element)
                        time.sleep(5)
                        wui.info('go to device overview monitoring page success', True)
                        
                        break
                except Exception, e:
                    wui.error('device is not found',True)
                    break
                i+=1
            if find_mac_flag == 0:
                try:
                    wui.wait_until_element_displayed(device_list_next_page)
                    wui.click(device_list_next_page)
                    wui.info('go to next page to find devices', True)
                    page_num+=1
                    continue
                except Exception, e:
                    wui.wait_until_element_displayed(device_list_next_page_disable)
                    wui.error('this is the last page and the device is not found',True)
                    break