20181128_selenium_java问题集锦（3）_element定位方法的封装

最新推荐文章于 2024-03-28 18:49:49 发布
原创 最新推荐文章于 2024-03-28 18:49:49 发布 · 405 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文分享了在使用Selenium Java进行自动化测试时，对元素定位方法的封装，旨在简化非空判断操作，提高脚本的可读性和易维护性。同时，讨论了如何通过日志增强脚本的错误定位能力，欢迎大家提出优化建议，共同进步。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1、对于selenium_java还是封装一下element的定位方法吧，否则，每次查找元素后都非空判断一下好麻烦。

import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.openqa.selenium.Alert;
import org.openqa.selenium.By;
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.interactions.Actions;
import org.testng.Assert;
import org.testng.Reporter;
import org.testng.log4testng.Logger;

import cn.com.cnpc.richfit.cloud.resourceMan.testcase.CloudTestBase;
import cn.com.cnpc.richfit.cloud.resourceMan.utils.CommonProperties;
import cn.com.cnpc.richfit.cloud.resourceMan.utils.TimeUtils;

/**
 * 查找元素的工具类
 * @author lenovo
 *
 */
public class CloudElementMethods {
	public WebElement element = null;
	public List<WebElement> elementList = new ArrayList<WebElement>();
	private WebDriver driver = null;
	private static final Logger LOG = Logger.getLogger(CloudElementMethods.class);
	private static final int DELAY_NUM = 2;// 默认延迟次数
	private static final long DELAY_STEP_LENGTH = 500;// 默认延迟步长，500毫秒

	public void setDriver(WebDriver driver) {
		this.driver = driver;
	}

	/**
	 * id获取单个元素
	 * 
	 * @param id
	 * @return
	 */
	public WebElement getElementById(String id) {
		LOG.info("getElementById method called");
		Reporter.log("getElementById method called");
		System.out.println("getElementById method called");
		try {
			element = driver.findElement(By.id(id));
			if (element == null) {
				for (int i = 0; i < DELAY_NUM; i++) {
					TimeUtils.waitfor(DELAY_STEP_LENGTH);
					element = driver.findElement(By.id(id));
					if (element != null) {
						break;
					}
				}
			}
		} catch (Exception e) {
			LOG.info("Can not find element:" + id);
			Reporter.log("Can not find element:" + id);
			System.out.println("Can not find element:" + id);
			element = null;
			// Assert.fail("Can not find element:"+id);
			return element;
		}
		return element;
	}
	/**
	 * id获取单个元素-从父级元素获取
	 * 
	 * @param id
	 * @return
	 */
	public WebElement getElementById(WebElement fatherElement, String id) {
		LOG.info("getElementById method called");
		Reporter.log("getElementById method called");
		System.out.println("getElementById method called");
		try {
			element = fatherElement.findElement(By.id(id));
			if (element == null) {
				for (int i = 0; i < DELAY_NUM; i++) {
					TimeUtils.waitfor(DELAY_STEP_LENGTH);
					element = fatherElement.findElement(By.id(id));
					if (element != null) {
						break;
					}
				}
			}
		} catch (Exception e) {
			LOG.info("Can not find element:" + id);
			Reporter.log("Can not find element:" + id);
			System.out.println("Can not find element:" + id);
			element = null;
			// Assert.fail("Can not find element:"+id);
			return element;
		}
		return element;
	}

	/**
	 * classname获取单个元素
	 * 
	 * @param classname
	 * @return
	 */
	public WebElement getElementByClassName(String classname) {
		LOG.info("getElementByClassName method called");
		Reporter.log("getElementByClassName method called");
		System.out.println("getElementByClassName method called");
		try {
			element = driver.findElement(By.className(classname));
			if (element == null) {
				for (int i = 0; i < DELAY_NUM; i++) {
					TimeUtils.waitfor(DELAY_STEP_LENGTH);
					element = driver.findElement(By.className(classname));
					if (element != null) {
						break;
					}
				}
			}
		} catch (Exception e) {
			// TODO: handle exception
			LOG.info("Can not find element:" + classname);
			Reporter.log("Can not find element:" + classname);
			System.out.println("Can not find element:" + classname);
			element = null;
			// Assert.fail("Can not find element:"+classname);
			return element;
		}
		return element;
	}
	/**
	 * classname获取单个元素-从父级元素获取
	 * 
	 * @param classname
	 * @return
	 */
	public WebElement getElementByClassName(WebElement fatherELement, String classname) {
		if (fatherELement!=null) {
			LOG.info("getElementByClassName method called");
			Reporter.log("getElementByClassName method called");
			System.out.println("getElementByClassName method called");
			try {
				element = fatherELement.findElement(By.className(classname));
				if (element == null) {
					for (int i = 0; i < DELAY_NUM; i++) {
						TimeUtils.waitfor(DELAY_STEP_LENGTH);
						element = fatherELement.findElement(By.className(classname));
						if (element != null) {
							break;
						}
					}
				}
			} catch (Exception e) {
				// TODO: handle exception
				LOG.info("Can not find element:" + classname);
				Reporter.log("Can not find element:" + classname);
				System.out.println("Can not find element:" + classname);
				element = null;
				// Assert.fail("Can not find element:"+classname);
				return element;
			}
		}
		return element;
	}

	/**
	 * classname获取多个元素
	 * 
	 * @param classname
	 * @return
	 */
	public List<WebElement> getElementsByClassName(String classname) {
		LOG.info("getElementsByClassName method called");
		Reporter.log("getElementsByClassName method called");
		System.out.println("getElementsByClassName method called");
		try {
			elementList = driver.findElements(By.className(classname));
			if (elementList == null) {
				for (int i = 0; i < DELAY_NUM; i++) {
					TimeUtils.waitfor(DELAY_STEP_LENGTH);
					elementList = driver.findElements(By.className(classname));
					if (elementList != null) {
						break;
					}
				}
			}
		} catch (Exception e) {
			// TODO: handle exception
			LOG.info("Can not find elements:" + classname);
			Reporter.log("Can not find element:" + classname);
			System.out.println("Can not find element:" + classname);
			elementList = null;
			// Assert.fail("Can not find element:"+classname);
			return elementList;
		}
		return elementList;
	}
	/**
	 * classname获取多个元素-从父级元素获取
	 * 
	 * @param classname
	 * @return
	 */
	public List<WebElement> getElementsByClassName(WebElement fatherElement, String classname) {
		if (fatherElement!=null) {
			LOG.info("getElementsByClassName method called");
			Reporter.log("getElementsByClassName method called");
			System.out.println("getElementsByClassName method called");
			try {
				elementList = fatherElement.findElements(By.className(classname));
				if (elementList == null) {
					for (int i = 0; i < DELAY_NUM; i++) {
						TimeUtils.waitfor(DELAY_STEP_LENGTH);
						elementList = fatherElement.findElements(By.className(classname));
						if (elementList != null) {
							break;
						}
					}
				}
			} catch (Exception e) {
				// TODO: handle exception
				LOG.info("Can not find elements:" + classname);
				Reporter.log("Can not find element:" + classname);
				System.out.println("Can not find element:" + classname);
				elementList = null;
				// Assert.fail("Can not find element:"+classname);
				return elementList;
			}
		}
		return elementList;
	}

	/**
	 * name属性获取单个元素
	 * 
	 * @param name
	 * @return
	 */
	public WebElement getElementByName(String name) {
		LOG.info("getElementByName method called");
		Reporter.log("getElementByName method called");
		System.out.println("getElementByName method called");
		try {
			element = driver.findElement(By.name(name));
			if (element == null) {
				for (int i = 0; i < DELAY_NUM; i++) {
					TimeUtils.waitfor(DELAY_STEP_LENGTH);
					element = driver.findElement(By.name(name));
					if (element != null) {
						break;
					}
				}
			}
		} catch (Exception e) {
			// TODO: handle exception
			LOG.info("Can not find element:" + name);
			Reporter.log("Can not find element:" + name);
			System.out.println("Can not find element:" + name);
			element = null;
			// Assert.fail("Can not find element:"+name);
			return element;
		}
		return element;
	}
	/**
	 * name属性获取单个元素-从父级元素获取
	 * 
	 * @param name
	 * @return
	 */
	public WebElement getElementByName(WebElement fatherElement, String name) {
		if (fatherElement!=null) {
			LOG.info("getElementByName method called");
			Reporter.log("getElementByName method called");
			System.out.println("getElementByName method called");
			try {
				element = fatherElement.findElement(By.name(name));
				if (element == null) {
					for (int i = 0; i < DELAY_NUM; i++) {
						TimeUtils.waitfor(DELAY_STEP_LENGTH);
						element = fatherElement.findElement(By.name(name));
						if (element != null) {
							break;
						}
					}
				}
			} catch (Exception e) {
				// TODO: handle exception
				LOG.info("Can not find element:" + name);
				Reporter.log("Can not find element:" + name);
				System.out.println("Can not find element:" + name);
				element = null;
				// Assert.fail("Can not find element:"+name);
				return element;
			}
		}
		return element;
	}

	/**
	 * name属性获取多个元素
	 * 
	 * @param name
	 * @return
	 */
	public List<WebElement> getElementsByName(String name) {
		LOG.info("getElementsByName method called");
		Reporter.log("getElementsByName method called");
		System.out.println("getElementsByName method called");
		try {
			elementList = driver.findElements(By.name(name));
			if (elementList == null) {
				for (int i = 0; i < DELAY_NUM; i++) {
					TimeUtils.waitfor(DELAY_STEP_LENGTH);
					elementList = driver.findElements(By.name(name));
					if (elementList != null) {
						break;
					}
				}
			}
		} catch (Exception e) {
			// TODO: handle exception
			LOG.info("Can not find elements:" + name);
			Reporter.log("Can not find element:" + name);
			System.out.println("Can not find element:" + name);
			elementList = null;
			// Assert.fail("Can not find element:"+name);
			return elementList;
		}
		return elementList;
	}
	/**
	 * name属性获取多个元素-从父级元素获取
	 * 
	 * @param name
	 * @return
	 */
	public List<WebElement> getElementsByName(WebElement fatherElement, String name) {
		if (fatherElement!=null) {
			LOG.info("getElementsByName method called");
			Reporter.log("getElementsByName method called");
			System.out.println("getElementsByName method called");
			try {
				elementList = fatherElement.findElements(By.name(name));
				if (elementList == null) {
					for (int i = 0; i < DELAY_NUM; i++) {
						TimeUtils.waitfor(DELAY_STEP_LENGTH);
						elementList = fatherElement.findElements(By.name(name));
						if (elementList != null) {
							break;
						}
					}
				}
			} catch (Exception e) {
				// TODO: handle exception
				LOG.info("Can not find elements:" + name);
				Reporter.log("Can not find element:" + name);
				System.out.println("Can not find element:" + name);
				elementList = null;
				// Assert.fail("Can not find element:"+name);
				return elementList;
			}
		}
		return elementList;
	}

	/**
	 * 标签选择器获取单个元素
	 * 
	 * @param tagname
	 * @return
	 */
	public WebElement getElementByTagName(String tagname) {
		LOG.info("getElementByTagName method called");
		Reporter.log("getElementByTagName method called");
		System.out.println("getElementByTagName method called");
		try {
			element = driver.findElement(By.tagName(tagname));
			if (element == null) {
				for (int i = 0; i < DELAY_NUM; i++) {
					TimeUtils.waitfor(DELAY_STEP_LENGTH);
					element = driver.findElement(By.tagName(tagname));
					if (element != null) {
						break;
					}
				}
			}
		} catch (Exception e) {
			// TODO: handle exception
			LOG.info("Can not find element:" + tagname);
			Reporter.log("Can not find element:" + tagname);
			System.out.println("Can not find element:" + tagname);
			element = null;
			// Assert.fail("Can not find element:"+tagname);
			return element;
		}
		return element;
	}
	/**
	 * 标签选择器获取单个元素-从父级元素获取
	 * 
	 * @param tagname
	 * @return
	 */
	public WebElement getElementByTagName(WebElement fatherElement,String tagname) {
		if (fatherElement!=null) {
			LOG.info("getElementByTagName method called");
			Reporter.log("getElementByTagName method called");
			System.out.println("getElementByTagName method called");
			try {
				element = fatherElement.findElement(By.tagName(tagname));
				if (element == null) {
					for (int i = 0; i < DELAY_NUM; i++) {
						TimeUtils.waitfor(DELAY_STEP_LENGTH);
						element = fatherElement.findElement(By.tagName(tagname));
						if (element != null) {
							break;
						}
					}
				}
			} catch (Exception e) {
				// TODO: handle exception
				LOG.info("Can not find element:" + tagname);
				Reporter.log("Can not find element:" + tagname);
				System.out.println("Can not find element:" + tagname);
				element = null;
				// Assert.fail("Can not find element:"+tagname);
				return element;
			}
		}
		return element;
	}

	/**
	 * 标签选择器获取多个元素
	 * 
	 * @param tagname
	 * @return
	 */
	public List<WebElement> getElementsByTagName(String tagname) {
		LOG.info("getElementsByTagName method called");
		Reporter.log("getElementsByTagName method called");
		System.out.println("getElementsByTagName method called");
		try {
			elementList = driver.findElements(By.tagName(tagname));
			if (elementList == null) {
				for (int i = 0; i < DELAY_NUM; i++) {
					TimeUtils.waitfor(DELAY_STEP_LENGTH);
					elementList = driver.findElements(By.tagName(tagname));
					if (elementList != null) {
						break;
					}
				}
			}
		} catch (Exception e) {
			// TODO: handle exception
			LOG.info("Can not find elements:" + tagname);
			Reporter.log("Can not find element:" + tagname);
			System.out.println("Can not find element:" + tagname);
			elementList = null;
			// Assert.fail("Can not find element:"+tagname);
			return elementList;
		}
		return elementList;
	}
	/**
	 * 标签选择器获取多个元素-从父级元素获取
	 * 
	 * @param tagname
	 * @return
	 */
	public List<WebElement> getElementsByTagName(WebElement fatherElement, String tagname) {
		if (fatherElement !=null) {
			LOG.info("getElementsByTagName method called");
			Reporter.log("getElementsByTagName method called");
			System.out.println("getElementsByTagName method called");
			try {
				elementList = fatherElement.findElements(By.tagName(tagname));
				if (elementList == null) {
					for (int i = 0; i < DELAY_NUM; i++) {
						TimeUtils.waitfor(DELAY_STEP_LENGTH);
						elementList = fatherElement.findElements(By.tagName(tagname));
						if (elementList != null) {
							break;
						}
					}
				}
			} catch (Exception e) {
				// TODO: handle exception
				LOG.info("Can not find elements:" + tagname);
				Reporter.log("Can not find element:" + tagname);
				System.out.println("Can not find element:" + tagname);
				elementList = null;
				// Assert.fail("Can not find element:"+tagname);
				return elementList;
			}
		}
		return elementList;
	}

	/**
	 * linkText获取单个元素
	 * 
	 * @param text
	 * @return
	 */
	public WebElement getElementByLinkText(String text) {
		LOG.info("getElementByLinkText method called");
		Reporter.log("getElementByLinkText method called");
		System.out.println("getElementByLinkText method called");
		try {
			element = driver.findElement(By.linkText(text));
			if (element == null) {
				for (int i = 0; i < DELAY_NUM; i++) {
					TimeUtils.waitfor(DELAY_STEP_LENGTH);
					element = driver.findElement(By.linkText(text));
					if (element != null) {
						break;
					}
				}
			}
		} catch (Exception e) {
			// TODO: handle exception
			LOG.info("Can not find element:" + text);
			Reporter.log("Can not find element:" + text);
			System.out.println("Can not find element:" + text);
			System.out.println(e.toString());
			element = null;
			// Assert.fail("Can not find element:"+text);
			return element;
		}
		return element;
	}
	/**
	 * linkText获取单个元素-从父级元素获取
	 * 
	 * @param text
	 * @return
	 */
	public WebElement getElementByLinkText(WebElement fatherElement, String text) {
		if (fatherElement!=null) {
			LOG.info("getElementByLinkText method called");
			Reporter.log("getElementByLinkText method called");
			System.out.println("getElementByLinkText method called");
			try {
				element = fatherElement.findElement(By.linkText(text));
				if (element == null) {
					for (int i = 0; i < DELAY_NUM; i++) {
						TimeUtils.waitfor(DELAY_STEP_LENGTH);
						element = fatherElement.findElement(By.linkText(text));
						if (element != null) {
							break;
						}
					}
				}
			} catch (Exception e) {
				// TODO: handle exception
				LOG.info("Can not find element:" + text);
				Reporter.log("Can not find element:" + text);
				System.out.println("Can not find element:" + text);
				System.out.println(e.toString());
				element = null;
				// Assert.fail("Can not find element:"+text);
				return element;
			}
		}
		return element;
	}

	/**
	 * linkText获取多个元素，匹配查询
	 * 
	 * @param text
	 * @return
	 */
	public List<WebElement> getElementsByLinkText(String text) {
		LOG.info("getElementsByLinkText method called");
		Reporter.log("getElementsByLinkText method called");
		System.out.println("getElementsByLinkText method called");
		try {
			elementList = driver.findElements(By.linkText(text));
			if (elementList == null) {
				for (int i = 0; i < DELAY_NUM; i++) {
					TimeUtils.waitfor(DELAY_STEP_LENGTH);
					elementList = driver.findElements(By.linkText(text));
					if (elementList != null) {
						break;
					}
				}
			}
		} catch (Exception e) {
			// TODO: handle exception
			LOG.info("Can not find elements:" + text);
			Reporter.log("Can not find element:" + text);
			System.out.println("Can not find element:" + text);
			System.out.println(e.toString());
			elementList = null;
			// Assert.fail("Can not find element:"+text);
			return elementList;
		}
		return elementList;
	}
	/**
	 * linkText获取多个元素，匹配查询-从父级元素获取
	 * 
	 * @param text
	 * @return
	 */
	public List<WebElement> getElementsByLinkText(WebElement fatherElement, String text) {
		if (fatherElement!=null) {
			LOG.info("getElementsByLinkText method called");
			Reporter.log("getElementsByLinkText method called");
			System.out.println("getElementsByLinkText method called");
			try {
				elementList = fatherElement.findElements(By.linkText(text));
				if (elementList == null) {
					for (int i = 0; i < DELAY_NUM; i++) {
						TimeUtils.waitfor(DELAY_STEP_LENGTH);
						elementList = fatherElement.findElements(By.linkText(text));
						if (elementList != null) {
							break;
						}
					}
				}
			} catch (Exception e) {
				// TODO: handle exception
				LOG.info("Can not find elements:" + text);
				Reporter.log("Can not find element:" + text);
				System.out.println("Can not find element:" + text);
				System.out.println(e.toString());
				elementList = null;
				// Assert.fail("Can not find element:"+text);
				return elementList;
			}
		}
		return elementList;
	}

	/**
	 * PatialLinkText获取单个元素,模糊匹配
	 * 
	 * @param pttext
	 * @return
	 */
	public WebElement getElementByPtLinkText(String pttext) {
		LOG.info("getElementByPtLinkText method called");
		Reporter.log("getElementByPtLinkText method called");
		System.out.println("getElementByPtLinkText method called");
		try {
			element = driver.findElement(By.partialLinkText(pttext));
			if (element == null) {
				for (int i = 0; i < DELAY_NUM; i++) {
					TimeUtils.waitfor(DELAY_STEP_LENGTH);
					element = driver.findElement(By.partialLinkText(pttext));
					if (element != null) {
						break;
					}
				}
			}
		} catch (Exception e) {
			// TODO: handle exception
			LOG.info("Can not find element:" + pttext);
			Reporter.log("Can not find element:" + pttext);
			System.out.println("Can not find element:" + pttext);
			element = null;
			// Assert.fail("Can not find element:"+pttext);
			return element;
		}
		return element;
	}
	/**
	 * PatialLinkText获取单个元素,模糊匹配-从父级元素获取
	 * 
	 * @param pttext
	 * @return
	 */
	public WebElement getElementByPtLinkText(WebElement fatherElement, String pttext) {
		if (fatherElement!=null) {
			LOG.info("getElementByPtLinkText method called");
			Reporter.log("getElementByPtLinkText method called");
			System.out.println("getElementByPtLinkText method called");
			try {
				element = fatherElement.findElement(By.partialLinkText(pttext));
				if (element == null) {
					for (int i = 0; i < DELAY_NUM; i++) {
						TimeUtils.waitfor(DELAY_STEP_LENGTH);
						element = fatherElement.findElement(By.partialLinkText(pttext));
						if (element != null) {
							break;
						}
					}
				}
			} catch (Exception e) {
				// TODO: handle exception
				LOG.info("Can not find element:" + pttext);
				Reporter.log("Can not find element:" + pttext);
				System.out.println("Can not find element:" + pttext);
				element = null;
				// Assert.fail("Can not find element:"+pttext);
				return element;
			}
		}
		return element;
	}

	/**
	 * PatialLinkText获取多个元素,模糊匹配
	 * 
	 * @param pttext
	 * @return
	 */
	public List<WebElement> getElementsByPtLinkText(String pttext) {
		LOG.info("getElementsByPtLinkText method called");
		Reporter.log("getElementsByPtLinkText method called");
		System.out.println("getElementsByPtLinkText method called");
		try {
			elementList = driver.findElements(By.partialLinkText(pttext));
			if (elementList == null) {
				for (int i = 0; i < DELAY_NUM; i++) {
					TimeUtils.waitfor(DELAY_STEP_LENGTH);
					elementList = driver.findElements(By.partialLinkText(pttext));
					if (elementList != null) {
						break;
					}
				}
			}
		} catch (Exception e) {
			// TODO: handle exception
			LOG.info("Can not find elements:" + pttext);
			Reporter.log("Can not find element:" + pttext);
			System.out.println("Can not find element:" + pttext);
			elementList = null;
			// Assert.fail("Can not find element:"+pttext);
			return elementList;
		}
		return elementList;
	}
	/**
	 * PatialLinkText获取多个元素,模糊匹配-从父级元素获取
	 * 
	 * @param pttext
	 * @return
	 */
	public List<WebElement> getElementsByPtLinkText(WebElement fatherElement, String pttext) {
		if (fatherElement !=null) {
			LOG.info("getElementsByPtLinkText method called");
			Reporter.log("getElementsByPtLinkText method called");
			System.out.println("getElementsByPtLinkText method called");
			try {
				elementList = fatherElement.findElements(By.partialLinkText(pttext));
				if (elementList == null) {
					for (int i = 0; i < DELAY_NUM; i++) {
						TimeUtils.waitfor(DELAY_STEP_LENGTH);
						elementList = fatherElement.findElements(By.partialLinkText(pttext));
						if (elementList != null) {
							break;
						}
					}
				}
			} catch (Exception e) {
				// TODO: handle exception
				LOG.info("Can not find elements:" + pttext);
				Reporter.log("Can not find element:" + pttext);
				System.out.println("Can not find element:" + pttext);
				elementList = null;
				// Assert.fail("Can not find element:"+pttext);
				return elementList;
			}
		}
		return elementList;
	}

	/**
	 * css-selector获取单个元素
	 * 
	 * @param css
	 * @return
	 */
	public WebElement getElementByCSSSelector(String css) {
		LOG.info("getElementByCSSSelector method called");
		Reporter.log("getElementByCSSSelector method called");
		System.out.println("getElementByCSSSelector method called");
		try {
			element = driver.findElement(By.cssSelector(css));
			if (element == null) {
				for (int i = 0; i < DELAY_NUM; i++) {
					TimeUtils.waitfor(DELAY_STEP_LENGTH);
					element = driver.findElement(By.cssSelector(css));
					if (element != null) {
						break;
					}
				}
			}
		} catch (Exception e) {
			// TODO: handle exception
			LOG.info("Can not find element:" + css);
			Reporter.log("Can not find element:" + css);
			System.out.println("Can not find element:" + css);
			element = null;
			// Assert.fail("Can not find element:"+css);
			return element;
		}
		return element;
	}
	/**
	 * css-selector获取单个元素-从父级元素获取
	 * 
	 * @param css
	 * @return
	 */
	public WebElement getElementByCSSSelector(WebElement fatherElement, String css) {
		if (fatherElement !=null) {
			LOG.info("getElementByCSSSelector method called");
			Reporter.log("getElementByCSSSelector method called");
			System.out.println("getElementByCSSSelector method called");
			try {
				element = fatherElement.findElement(By.cssSelector(css));
				if (element == null) {
					for (int i = 0; i < DELAY_NUM; i++) {
						TimeUtils.waitfor(DELAY_STEP_LENGTH);
						element = fatherElement.findElement(By.cssSelector(css));
						if (element != null) {
							break;
						}
					}
				}
			} catch (Exception e) {
				// TODO: handle exception
				LOG.info("Can not find element:" + css);
				Reporter.log("Can not find element:" + css);
				System.out.println("Can not find element:" + css);
				element = null;
				// Assert.fail("Can not find element:"+css);
				return element;
			}
		}
		return element;
	}

	/**
	 * css-selector获取多个元素
	 * 
	 * @param css
	 * @return
	 */
	public List<WebElement> getElementsByCSSSelector(String css) {
		LOG.info("getElementsByCSSSelector method called");
		Reporter.log("getElementsByCSSSelector method called");
		System.out.println("getElementsByCSSSelector method called");
		try {
			elementList = driver.findElements(By.cssSelector(css));
			if (elementList == null) {
				for (int i = 0; i < DELAY_NUM; i++) {
					TimeUtils.waitfor(DELAY_STEP_LENGTH);
					elementList = driver.findElements(By.cssSelector(css));
					if (elementList != null) {
						break;
					}
				}
			}
		} catch (Exception e) {
			// TODO: handle exception
			LOG.info("Can not find elements:" + css);
			Reporter.log("Can not find element:" + css);
			System.out.println("Can not find element:" + css);
			elementList = null;
			// Assert.fail("Can not find element:"+css);
			return elementList;
		}
		return elementList;
	}
	/**
	 * css-selector获取多个元素-从父级元素获取
	 * 
	 * @param css
	 * @return
	 */
	public List<WebElement> getElementsByCSSSelector(WebElement fatherElement, String css) {
		if (fatherElement!=null) {
			LOG.info("getElementsByCSSSelector method called");
			Reporter.log("getElementsByCSSSelector method called");
			System.out.println("getElementsByCSSSelector method called");
			try {
				elementList = fatherElement.findElements(By.cssSelector(css));
				if (elementList == null) {
					for (int i = 0; i < DELAY_NUM; i++) {
						TimeUtils.waitfor(DELAY_STEP_LENGTH);
						elementList = fatherElement.findElements(By.cssSelector(css));
						if (elementList != null) {
							break;
						}
					}
				}
			} catch (Exception e) {
				// TODO: handle exception
				LOG.info("Can not find elements:" + css);
				Reporter.log("Can not find element:" + css);
				System.out.println("Can not find element:" + css);
				elementList = null;
				// Assert.fail("Can not find element:"+css);
				return elementList;
			}
		}
		return elementList;
	}

	/**
	 * xpath获取单个元素
	 * 
	 * @param xpathlocator
	 * @return
	 */
	public WebElement getElementUsingXpath(String xpathlocator) {
		LOG.info("getElementUsingXpath method called");
		Reporter.log("getElementUsingXpath method called");
		System.out.println("getElementUsingXpath method called");
		System.out.println(driver.getTitle());
		try {
			element = driver.findElement(By.xpath(xpathlocator));
			if (element == null) {
				for (int i = 0; i < DELAY_NUM; i++) {
					TimeUtils.waitfor(DELAY_STEP_LENGTH);
					element = driver.findElement(By.xpath(xpathlocator));
					if (element != null) {
						break;
					}
				}
			}
		} catch (Exception e) {
			LOG.info("Can not find element:" + By.xpath(xpathlocator).toString());
			Reporter.log("Can not find element:" + By.xpath(xpathlocator).toString());
			System.out.println("Can not find element:" + By.xpath(xpathlocator).toString());
			element = null;
			// Assert.fail("Can not find
			// element:"+By.xpath(xpathlocator).toString());
			return element;
		}
		return element;
	}
	/**
	 * xpath获取单个元素-从父级元素获取
	 * 
	 * @param xpathlocator
	 * @return
	 */
	public WebElement getElementUsingXpath(WebElement fatherElement, String xpathlocator) {
		if (fatherElement!=null) {
			LOG.info("getElementUsingXpath method called");
			Reporter.log("getElementUsingXpath method called");
			System.out.println("getElementUsingXpath method called");
			System.out.println(driver.getTitle());
			try {
				element = fatherElement.findElement(By.xpath(xpathlocator));
				if (element == null) {
					for (int i = 0; i < DELAY_NUM; i++) {
						TimeUtils.waitfor(DELAY_STEP_LENGTH);
						element = fatherElement.findElement(By.xpath(xpathlocator));
						if (element != null) {
							break;
						}
					}
				}
			} catch (Exception e) {
				LOG.info("Can not find element:" + By.xpath(xpathlocator).toString());
				Reporter.log("Can not find element:" + By.xpath(xpathlocator).toString());
				System.out.println("Can not find element:" + By.xpath(xpathlocator).toString());
				element = null;
				// Assert.fail("Can not find
				// element:"+By.xpath(xpathlocator).toString());
				return element;
			}
		}
		return element;
	}

	/**
	 * 通过页面元素存在不存在来断言，不存在元素，断言失败，用例停止执行 页面存在元素，不做任何操作
	 * 
	 * @param element
	 *            元素
	 * @param str
	 *            依据什么找到元素
	 */
	public void assertFailByElementNotExist(WebElement element, String str) {
		if (element == null) {
			Assert.fail("Can not find element:" + str);
		}
	}

	/**
	 * 通过页面元素存不存在来断言 不存在元素，查看是否是跳入了非安全页面 在containsLabel为true的情况下，断言成功
	 * 在containsLabel为false的情况下，断言失败
	 * 
	 * @param element
	 *            元素
	 * @param str
	 *            依据什么找到的元素
	 * @param curUrl
	 *            当前页面的url
	 */
	public void assertByElementNotExist(WebElement element, String str, String curUrl) {
		if (element == null) {
			if (curUrl != null && CloudTestBase.containsLabel) {
				Assert.assertTrue(enterUnsafePage(curUrl));
			} else {
				Assert.fail("Can not find element:" + str);
			}
		}
	}

	/**
	 * 是否进入了非安全页面
	 * 
	 * @param curUrl
	 * @return
	 */
	public boolean enterUnsafePage(String curUrl) {
		if (curUrl != null && curUrl.equals(CommonProperties.UNSAFE_CLOUD_URL)) {
			return true;
		}
		return false;
	}

	/**
	 * 鼠标移动到元素位置
	 * 
	 * @param element
	 */
	public void scrollTo(WebElement element) {
		JavascriptExecutor javascriptExecutor = (JavascriptExecutor) driver;
		javascriptExecutor.executeScript("arguments[0].scrollIntoView(true)", element);
	}

	/**
	 * driver跳转到到当前window
	 * 
	 * @param curDriver
	 */
	public WebDriver switchToCurrentWindow(WebDriver curDriver) {
		String currentWindow = curDriver.getWindowHandle();
		Set<String> winHandels = curDriver.getWindowHandles();
		List<String> it = new ArrayList<String>(winHandels);
		// 跳转到新打开的窗口
		for (String winHandle : curDriver.getWindowHandles()) {
			if (!winHandle.equals(currentWindow)) {
				curDriver = curDriver.switchTo().window(winHandle);
				break;
			}
		}
		return curDriver;
	}

	/**
	 * 判断是否出现了alert框或者确认对话框
	 * 
	 * @param curDriver
	 * @return
	 */
	public boolean isDispalyedAlert(WebDriver curDriver) {
		if (curDriver != null) {
			Alert confirm = curDriver.switchTo().alert();
			if (confirm != null) {
				return true;
			}
		}
		return false;
	}
	/**
	 * 获取Input标签的值
	 * @param driver
	 * @param element
	 * @return
	 */
	public String getInputValue(WebDriver driver, WebElement element){
		JavascriptExecutor javaScriptExecutor = (JavascriptExecutor) driver;
		try{
            String value = javaScriptExecutor.executeScript("return arguments[0].value", element).toString();
			return value;
		}catch (Exception e){
		    e.printStackTrace();
			return null;
		}

	}

	/**
	 * 鼠标移动到元素
	 * 
	 * @param element
	 */
	public void actionToElement(WebElement element) {
		// 创建鼠标属性方法
		Actions action = new Actions(driver);
		// 获取 moveToElement 方法 ，元素定位到想要移上去的元素上
		action.moveToElement(element).perform();
	}

	/**
	 * 窗口最大化
	 */
	public void maxWindow() {
		driver.manage().window().maximize();
	}
/**
	 * 滚动到目标元素的Y坐标位置
	 * 
	 * @param driver
	 * @param element
	 */
	public void scrollYLoaction(WebDriver driver, WebElement element) {
		int YLoc = element.getLocation().getY();
		String js = String.format("window.scroll(0,%s)", YLoc);
		((JavascriptExecutor) driver).executeScript(js, element);
	}
	/**
	 * 滚动到目标元素位置
	 * @param driver
	 * @param element
	 */
	public void scrollTargetLoaction(WebDriver driver, WebElement element) {
			((JavascriptExecutor) driver).executeScript("arguments[0].scrollIntoView();", element);
	}

 

有些其他封装的方法也一并粘出来了，

里边的Log貌似设的有点多，可再修改一下，有时间再改吧，目的是脚本一旦执行出错，能快速定位到问题所在。

如果有谁有更好的脚本强壮的建议，可直接提额，互相精进一下嘛~~

暂时先这些。

Selenium定位的封装
weixin_35973114的博客
06-30 1442
1.在企业级自动化时，为了提升效率，不要每次都编写冗余的定位代码，需要对定位进行封装来提升开发的效率 2.封装思路，把定位的元素比如name，id，与元素值，存储到变量里 3.创建一个方法，包含两个参数，用于接收元素与元素值，在创建一个if…elif 语句判断元素属于那种定位 4.在定位的时候就不需要重复写定位语句，只需要在定位时调用方法传入参数、 5.代码: from time import s...
python爬虫面试题集锦及答案
AudiA6LV6的博客
09-18 7304
传统定义：分布式存储系统是大量 PC 服务器通过 Internet 互联，对外提供一个整体的服务。分布式存储系统具有以下的几个特性：可扩展 ：分布式存储系统可以扩展到几百台甚至几千台这样的一个集群规模，系统的 整体性能线性增长。低成本 ：分布式存储系统的自动容错、自动负载均衡的特性，允许分布式存储系统可 以构建在低成本的服务器上。另外，线性的扩展能力也使得增加、减少服务器的成本低， 实现分布式存储系统的自动运维。
selenium+java元素定位与操作及实例
10-15
selenium+java操作UI时，对界面元素进行定位与操作及实例
selenium对元素定位和操作方法的封装
qq_45478878的博客
06-29 841
-- coding:UTF-8 -- from selenium import webdriver import time class common(object): #新建对象就自动创建浏览器并且最大化窗口 def init(self): self.driver=webdriver.Chrome() self.driver.maximize_window() #打开网页功能 def open(self,url): self.driver.get(url) self.driver.implicitly_w
Java-002 selenium元素定位
Luqing1123570994的博客
04-14 269
1.selenium定位方法 Selenium提供了8种定位方式: id name class name tag name link text partial link text xpath css selector 这8种定位方式在Java selenium中所对应的方法为： findElement(By.id()) findElement(By.name()) findElement(By.className()) findElement(By.tagName()) findElement(By.lin
java selenium (五) 元素定位大全
优快云专栏--北京中关村
11-18 1958
页面元素定位是自动化中最重要的事情， selenium Webdriver 提供了很多种元素定位的方法。测试人员应该熟练掌握各种定位方法。使用最简单，最稳定的定位方法。阅读目录。
与滑动验证码的斗智斗勇，看如何用Python破解
qq_46614154的博客
05-13 1828
前言 很多小伙伴们反馈，在web自动化的过程中，经常会被登录的验证码给卡住，不知道如何去通过验证码的验证。今天专门给大家来聊聊验证码的问题，一般的情况下遇到验证码我们可以都可以找开发去帮忙解决，关闭验证码，或者给一个万能的验证码！那么如果开发不提供帮助的话，我们自己有没有办法来处理这些验证码的问题呢？答案当然是有的，常见的验证码一般分为两类，一类是图文验证码，一类是滑动验证码！ 关于图文识别的验证码，之前已经出了相关的识别解决方案，今天就不做过多的介绍了，有兴趣的小伙伴可以私聊领取配套的视频资.
【多格式媒体测试基础】：音频和视频格式测试的必要性
!... # 摘要 随着数字媒体技术的迅速发展，多媒体测试...文中进一步探讨了跨平台多媒体测试策略，包括不同操作系统和移动端平台的测试方法，以及测试环境的搭建。此外，本文还讨论了在多媒体测试中应用自动化技术的策略
【自动化测试解决方案】：TI技术提高电源测试效率
!... # 摘要 随着技术的快速发展，自动化测试已成为提高软件测试效率和质量的关键手段，尤其在TI技术及电源测试领域，其重要性日益凸显。本文系统地介绍了自动化测试的理论框架、技术选型、实践过程，并针对测试环境...
java-selenium八种元素定位方式
caidaqin001的专栏
07-16 817
八种定位方式 一、ID定位 　　一般情况下页面元素的id属性在当前网页中是唯一的所以使用ID定位可以保证定位的唯一性，不会像其他定位方式一样可能定位到多个页面元素。但有的网页页面元素没有id属性值，导致无法使用ID定位方式。 　　HTML 源码 <a onclick="return false;" id="lb" name="tj_login" href="https://passport.baidu.com/v2/?login&amp;tpl=mn&amp">登录&l
Java+selenium常用封装方法
weixin_44242153的博客
05-20 1814
1.下拉框的选择方法 WebElement element = driver.findElement(By.cssSelector（））; Element.click(); //这是点击下拉框的定位方法 Thread.sleep(2000);//点击下拉框后等待下方元素加载 然后再找到需要选择的选项 WebElement element = driver.findElement(By.xpath()); Element.click; 2.日历控件处理方法 String js = "d.
java+selenium自动化测试之8大常用定位方法
最新发布
weixin_60728436的博客
03-28 3526
定位元素：Selenium能够模拟用户去浏览器页面上执行对应（输入，点击，清除，提交）等操作，它是凭什么方式去寻找到页面的元素？Selenium没有视觉、听觉等。Selenium通过在页面上寻找元素位置，找到元素后，然后对元素进行相应的操作，Selenium寻找元素位置的方法，称之为定位。
java【selenium】封装查找元素方法，查找单个元素，查找多个元素集合，查找元素是否存在
weixin_39048389的博客
04-07 898
import org.openqa.selenium.By; import org.openqa.selenium.WebDriver; import org.openqa.selenium.WebElement; public class EncapsulationElement { WebDriver driver; //初始化构造函数时，带着WebDriver driver public E...
[selenium webdriver Java]元素定位——findElement/findElements
weixin_30378623的博客
04-27 526
策略语法语法描述 By id driver.findElement(By.id()) driver.findElements(By.id()) 通过id属性定位元素 By name driver.findElement(By.name()) driver.findElements(By.name()) 通过name属性定位元素 By class ...
selenium-webdriver 关于测试新打开页面报错解决办法
热门推荐
emilyRR的专栏
03-09 2万+
先看一下，从selenium IDE 导出的测试代码package com.test;import static org.junit.Assert.fail;import java.util.concurrent.TimeUnit;import org.junit.After; import org.junit.Before; import org.junit.Test; import org.op
使用WebDriver的过程中遇到的一个Bug
MaxSu的专栏
05-03 1309
在使用WebDriver的过程中遇到一个Bug,如下： 在进行登录的过程中使用”（\n）” 这个字符串作为密码，再点击弹出的警告框(WebDirver会直接报错)，错误信息如下（目前还没有找到解决办法）：FAILED: testLogIn org.openqa.selenium.UnhandledAlertException: unexpected alert open: {Alert tex
selenium模拟浏览器操作时 element is not attached to the page document 等异常的处理
chenhailonghp的博客
08-22 4563
问题场景 利用selenium、chromedriver模拟浏览器操作网页。一套共280多个页面，循环获取页面元素内容，有输入、跳转等动作 问题现象 主要出现在以下这段代码处，打开页面后，获取页面上样式表为“.el-input__inner”的内容。 ... WebDriver w = new ChromeDriver() w.get(baseUrl); .... //输入框、模拟输入搜...
selenium+java 定位方法 findElement 之 By tagName
qq_36969649的博客
10-31 1436
即通过tagName定位： driver.findElement ( By.tagName ("input"));  
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值