jasder
/
autestmayn
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

改造浏览器工具基类以及谷歌浏览器工具类

This commit is contained in:
彭宇琦 2020-04-17 20:58:28 +08:00
parent da84e2e9e4
commit 15575ba510
8 changed files with 805 additions and 134 deletions
src
main/java/pres/auxiliary/work/selenium
brower
AbstractBrower.javaChromeBrower.javaIncorrectPageException.javaPage.java
browers
IncorrectPageTitleException.java
test/java
pres/auxiliary
selenium/browers
chromedriver.exe
work/selenium/brower
TestChromeBrower.java
test/selenium/brower
TestOpenNewHandle.java

236
src/main/java/pres/auxiliary/work/selenium/browers/AbstractBrower.java → src/main/java/pres/auxiliary/work/selenium/brower/AbstractBrower.java
View File

@ -1,23 +1,25 @@
package pres.auxiliary.work.selenium.browers;
package pres.auxiliary.work.selenium.brower;
import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.NoSuchWindowException;
import org.openqa.selenium.WebDriver;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
/**
* 该类定义启动浏览器时必要的方法以及打开浏览器，创建WebDriver对象的操作，由新添加的各个浏览器子类可进行继承
*
* <p><b>文件名：</b>AbstractBrower.java</p>
* <p><b>用途：</b>该类定义启动浏览器时必要的方法，开启浏览器的方法由子类继承编写</p>
* <p><b>编码时间：</b>2020年4月17日下午8:51:53</p>
* <p><b>修改时间：</b>2020年4月17日下午8:51:53</p>
* @author 彭宇琦
* @version Ver1.1
*
* @version Ver1.0
* @since JDK 12
*
*/
public abstract class AbstractBrower {
/**
@ -28,14 +30,10 @@ public abstract class AbstractBrower {
* 用于存储获取到的浏览器对象
*/
WebDriver driver = null;
/**
* 存储浏览器的设置内容，key表示浏览器设置的属性；value表示设置的内容
*/
HashMap<String, String> browerSetMap = new HashMap<String, String>();
/**
* 存储打开的页面
*/
ArrayList<Page> pageList = new ArrayList<>();
HashMap<String, Page> pageList = new HashMap<String, Page>(16);
/**
* 用于存储WebDriver当前指向的页面信息
@ -139,7 +137,7 @@ public abstract class AbstractBrower {
// 若pageList有元素，则根据openNewLabel参数来决定如何打开新的页面
if (pageList.size() == 0) {
// 存储页面对象
pageList.add(newPage);
pageList.put(newPage.getPageName(), newPage);
// 将当前页面对象指向newPage
nowPage = newPage;
// 在当前标签上打开页面
@ -147,14 +145,15 @@ public abstract class AbstractBrower {
} else {
if (openNewLabel) {
// 存储页面对象
pageList.add(newPage);
pageList.put(newPage.getPageName(), newPage);
// 将当前页面对象指向newPage
nowPage = newPage;
// 在标签页上打开页面
openNewLabelPage();
} else {
// 先在pageList移除nowPage
pageList.set(pageList.indexOf(nowPage), newPage);
pageList.remove(nowPage.getPageName());
pageList.put(newPage.getPageName(), newPage);
// 将nowPage指向newPage
nowPage = newPage;
// 在当前标签上打开页面
@ -162,14 +161,6 @@ public abstract class AbstractBrower {
}
}
// 遍历所有标签页，存储标签页信息
JSONArray labelInformation = new JSONArray();
pageList.forEach(page -> {
labelInformation.add(page.getPageInformation());
});
// 存储标签页信息
informationJson.put("标签信息", labelInformation);
// 切换至相应的窗口
driver.switchTo().window(nowPage.getHandle());
}
@ -190,39 +181,24 @@ public abstract class AbstractBrower {
openUrl(nowPage, false);
}
}
return driver;
}
/**
* 用于打开浏览器
*
* @return {@link WebDriver}类对象
*/
abstract void openBrower();
/**
* 获取浏览器的名称
*
* @return 浏览器名称
*/
// public abstract String getBrowerName();
/**
* 获取浏览器版本
*
* @return 浏览器版本
*/
// public abstract String getBrowerVersion();
/**
* 获取操作系统信息
*
* @return 操作系统信息
*/
// public abstract String getSystemInformation();
public JSONObject getAllInformation() {
// 遍历所有标签页，存储标签页信息
JSONArray labelInformation = new JSONArray();
pageList.forEach((name, page) -> {
labelInformation.add(page.getPageInformation());
});
// 存储标签页信息
informationJson.put("标签信息", labelInformation);
return informationJson;
}
@ -234,6 +210,17 @@ public abstract class AbstractBrower {
*/
public String getInformation(String key) {
if (informationJson.containsKey(key)) {
//若需要查看标签信息，则对标签信息即时进行存储
if ("标签信息".equals(key)) {
// 遍历所有标签页，存储标签页信息
JSONArray labelInformation = new JSONArray();
pageList.forEach((name, page) -> {
labelInformation.add(page.getPageInformation());
});
// 存储标签页信息
informationJson.put("标签信息", labelInformation);
}
return informationJson.getString(key);
} else {
return "";
@ -261,13 +248,36 @@ public abstract class AbstractBrower {
}
/**
* 用于关闭当前标签，若只存在一个标签时，则关闭浏览器，以保证进程能被完全浏览器驱动能被释放
* 用于关闭当前标签，若只存在一个标签时，关闭标签页后将生成一个空白页
*/
public void closeLabel() {
// 若当前只存在一个标签时，关闭标签，并生成一个新的空标签；若当前不只一个标签时，则对标签进行关闭
if (driver.getWindowHandles().size() == 1) {
driver.quit();
} else {
// 打开一个新标签
String newHandle = openNewLabel();
// 关闭当前的标签
driver.close();
// 将页面切换至新打开的标签上
driver.switchTo().window(newHandle);
// 将标签内容全部置空及当前页面内容置空
pageList.clear();
nowPage = null;
} else {
// 根据当前窗口handle查找相应的page对象
Page page = findPage(driver.getWindowHandle());
// 若窗口指向的页面存在，则将该页面从类中移除
if (page != null) {
pageList.remove(page.getPageName());
}
// 关闭当前标签
driver.close();
// 将driver随意指定一个窗口，保证能正常切换
driver.getWindowHandles().stream().forEach(handle -> {
driver.switchTo().window(handle);
return;
});
}
}
@ -275,23 +285,52 @@ public abstract class AbstractBrower {
* 用于关闭浏览器
*/
public void closeBrower() {
//关闭浏览器
driver.quit();
//将driver指定为null
driver = null;
// 清空页面存储的内容
pageList.clear();
nowPage = null;
}
/**
* 该方法用于对浏览器的一系列操作，包括全屏浏览器，跳转相应的站点，等待页面加载以及页面错误重载，
* 使用该方法时会抛出两个运行时异常，分别为IncorrectPageTitleException和PageNotFoundException
* 用于根据页面名称切换页面
*
* @param driver WebDriver对象
* @return 返回对浏览器进行操作后的得到的WebDriver对象
* @throws IncorrectPageException 页面title与设置的title不一致时抛出的异常
* @param pageName 页面名称
*/
WebDriver oprateBrower() {
// 全屏浏览器
driver.manage().window().maximize();
public void switchWindow(String pageName) {
try {
driver.switchTo().window(findPageHandle(pageName));
} catch (NoSuchWindowException e) {
throw new IncorrectPageException("页面未在浏览器中打开");
}
}
// 若循环结束，则说明页面无法正常加载，则置空pageTitle，抛出PageNotFountException
throw new IncorrectPageException("页面载入出错");
/**
* 用于根据页面切换页面
*
* @param page 页面对象
*/
public void switchWindow(Page page) {
// 查找pageList中是否存在传入的page，若存在，则获取相应的handle后对窗口进行切换
if (pageList.containsKey(page.getPageName())) {
try {
driver.switchTo().window(page.getHandle());
} catch (NoSuchWindowException e) {
throw new IncorrectPageException("页面未在浏览器中打开");
}
}
}
/**
* 用于切换到当前页面
*/
public void switchNowPage() {
// 若当前存储的页面不为null并且handle不为空时，则将页面切换至nowPage指向的页面
if (nowPage != null && !nowPage.getHandle().isEmpty()) {
switchWindow(nowPage);
}
}
/**
@ -300,7 +339,31 @@ public abstract class AbstractBrower {
* @param url 指定的站点
* @throws IncorrectPageException 当页面无法加载时抛出
*/
private String openNewLabelPage() {
private void openNewLabelPage() {
// 设置页面的Handle
nowPage.setHandle(openNewLabel());
// 加载页面
loadPage(nowPage);
}
/**
* 用于在原标签页中打开站点
*
* @param url 指定的站点
*/
private void overridePage() {
// 设置页面的Handle
nowPage.setHandle(driver.getWindowHandle());
// 加载页面
loadPage(nowPage);
}
/**
* 用于新建一个标签（窗口），返回其在浏览器中的handle值
*
* @return 新建标签（窗口）的handle
*/
private String openNewLabel() {
// 获取当前所有的handle
Set<String> handleSet = driver.getWindowHandles();
// 编写js脚本，执行js，以开启一个新的标签页
@ -315,26 +378,7 @@ public abstract class AbstractBrower {
}
}
// 设置页面的Handle
nowPage.setHandle(newHandle);
// 加载页面
loadPage(nowPage);
return nowPage.getHandle();
}
/**
* 用于在原标签页中打开站点
*
* @param url 指定的站点
*/
private String overridePage() {
// 设置页面的Handle
nowPage.setHandle(driver.getWindowHandle());
// 加载页面
loadPage(nowPage);
return nowPage.getHandle();
return newHandle;
}
/**
@ -358,17 +402,29 @@ public abstract class AbstractBrower {
* @return 页面对应窗口的Handle
*/
private String findPageHandle(String pageName) {
// 存储查找到的handle
String handle = "";
if (pageList.containsKey(pageName)) {
return pageList.get(pageName).getHandle();
} else {
return "";
}
}
// 循环，查找与pageName对应的Page对象，并返回相应的Handle
for (Page page : pageList) {
if (page.getPageName().equals(pageName)) {
handle = page.getHandle();
break;
/**
* 用于根据窗口handle来获取Page对象
*
* @param handle 窗口handle
* @return Page对象
*/
private Page findPage(String handle) {
// 遍历所有的page，查询与传入相同的handle
for (String pageName : pageList.keySet()) {
// 若存储的handle与传入的handle相同，则对其进行
if (handle.equals(pageList.get(pageName).getHandle())) {
return pageList.get(pageName);
}
}
return handle;
// 若类中未存储相应page，则返回null
return null;
}
}

358
src/main/java/pres/auxiliary/work/selenium/brower/ChromeBrower.java Normal file
View File

@ -0,0 +1,358 @@
package pres.auxiliary.work.selenium.brower;
import java.io.File;
import java.util.HashMap;
import java.util.HashSet;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;
import com.alibaba.fastjson.JSONArray;
/**
* <p><b>文件名：</b>ChromeBrower.java</p>
* <p><b>用途：</b>用于启动谷歌浏览器，并加载相应的待测页面，支持对浏览器进行部分个性化的配置，
* 以达到相应的测试效果。使用方法时，必须指定谷歌浏览器驱动所在位置，以保证浏览器能正常启动</p>
* <p>启动浏览器需要调用{@link #getDriver()}方法启动浏览器，若在构造方法中定义了{@link Page}类，则
* 启动浏览器时会自动对页面进行加载，若未定义，则只打开浏览器，如:</p>
* <p>
* 若调用方法：<br>
* ChromeBrower chrome = new {@link #ChromeBrower(File)}<br>
* chrome.{@link #getDriver()}<br>
* 后将只全屏打开浏览器，不会加载页面
* </p>
* <p>
* 若调用方法：<br>
* ChromeBrower chrome = new {@link #ChromeBrower(File, Page)}<br>
* 或ChromeBrower chrome = new {@link #ChromeBrower(File, String, String)}<br>
* chrome.{@link #getDriver()}<br>
* 后将全屏打开浏览器，并加载相应的页面
* </p>
* <p>对于个性化配置，在调用{@link #getDriver()}方法前调用{@link #addConfig(ChromeOptionType)}
* 或{@link #addConfig(ChromeOptionType, Object)}方法，通过枚举类{@link ChromeOptionType}
* 向浏览器添加相应的配置，在启动浏览器时，添加的配置会自动加载。</p>
* <p>若添加配置在调用{@link #getDriver()}方法之后，则设置的配置不会生效。</p>
* <p><b>编码时间：</b>2020年4月17日下午2:56:08</p>
* <p><b>修改时间：</b>2020年4月17日下午2:56:08</p>
* @author
* @version Ver1.0
* @since Selenium 3.14.0
* @since JDK 1.8
*
*/
public class ChromeBrower extends AbstractBrower {
/**
* 用于存储需要对浏览器进行配置的参数
*/
HashSet<ChromeOptionType> chromeConfigSet = new HashSet<ChromeOptionType>();
/**
* 指定驱动文件路径并添加一个待测站点
*
* @param driverFile 驱动文件对象
* @param page {@link Page}类对象
*/
public ChromeBrower(File driverFile, Page page) {
super(driverFile, page);
}
/**
* 指定驱动文件路径并添加一个待测站点
*
* @param driberFile 驱动文件对象
* @param url 待测站点
* @param pageName 待测站点名称，用于切换页面
*/
public ChromeBrower(File driverFile, String url, String pageName) {
super(driverFile, url, pageName);
}
/**
* 指定驱动文件所在路径
*
* @param driberFile 驱动文件对象
*/
public ChromeBrower(File driverFile) {
super(driverFile);
}
/**
* 用于添加浏览器需要带参数的配置，参数需要严格按照枚举中的说明进行配置，否则配置不会生效。 若添加的配置是不需要传入参数的，
* 则将忽略传入的参数，无参配置可以使用{@link #addConfig(ChromeOptionType)} 方法进行添加
*
* @param chromeOptionType 浏览器配置枚举（{@link ChromeOptionType}枚举类）
* @param value 需要设置的值
*/
public void addConfig(ChromeOptionType chromeOptionType, Object value) {
chromeOptionType.setValue(value);
chromeConfigSet.add(chromeOptionType);
}
/**
* 用于添加浏览器无需带参数的配置
*
* @param chromeOptionType 浏览器配置枚举（{@link ChromeOptionType}枚举类）
*/
public void addConfig(ChromeOptionType chromeOptionType) {
chromeConfigSet.add(chromeOptionType);
}
/**
* 用于移除相应的浏览器配置
*
* @param chromeOptionType 需要移除的浏览器配置
*/
public void removeConfig(ChromeOptionType chromeOptionType) {
chromeConfigSet.remove(chromeOptionType);
}
/**
* 清空所有的配置
*/
public void clearConfig() {
chromeConfigSet.clear();
}
@Override
void openBrower() {
// 添加谷歌浏览器驱动的存储位置
System.setProperty("webdriver.chrome.driver", driverFile.getAbsolutePath());
// 添加配置，并构建WebDriver对象，若未添加配置，则调用无参构造
if (chromeConfigSet.size() == 0) {
driver = new ChromeDriver();
} else {
driver = new ChromeDriver(browerConfig());
}
// 添加操作信息
informationJson.put("浏览器名称", ((ChromeDriver) driver).getCapabilities().getBrowserName());
informationJson.put("浏览器版本", ((ChromeDriver) driver).getCapabilities().getVersion());
informationJson.put("操作系统版本", System.getProperties().getProperty("os.name"));
}
/**
* 用于将配置添加至浏览器中
*/
ChromeOptions browerConfig() {
// 用于存储浏览器的配置信息
JSONArray configJsonArray = new JSONArray();
// 用于添加配置
ChromeOptions chromeOption = new ChromeOptions();
//若配置中存在控制已打开的浏览器，则直接添加相应的配置，并结束方法，否则会报错
if (chromeConfigSet.contains(ChromeOptionType.CONTRAL_OPEN_BROWER)) {
chromeOption.setExperimentalOption(ChromeOptionType.CONTRAL_OPEN_BROWER.getKey(), String.valueOf(ChromeOptionType.CONTRAL_OPEN_BROWER.getValue()));
return chromeOption;
}
// 用于存储谷歌浏览器个性化配置
HashMap<String, Object> chromePrefs = new HashMap<String, Object>(16);
// 用于存储谷歌浏览器对手机的配置
HashMap<String, Object> mobileEmulation = new HashMap<String, Object>(16);
// 遍历所有的chromeConfigSet，对浏览器进行相应的设置
for (ChromeOptionType configType : chromeConfigSet) {
// 根据设置的类型来指定使用哪种方法
// 0表示使用addArguments（启动配置项）配置
// 1表示setExperimentalOption（个性化配置）需要存储至map的配置
// 2表示setExperimentalOption（个性化配置）不需要存储至map的配置
// 3表示使用addArguments（启动配置项）配置，但需要拼接参数
switch (configType.getOptionType()) {
case 0:
chromeOption.addArguments(configType.getKey());
//添加信息
configJsonArray.add(configType.getName());
break;
case 1:
chromePrefs.put(configType.getKey(), configType.getValue());
configJsonArray.add(configType.getName());
break;
case 2:
chromeOption.setExperimentalOption(configType.getKey(), String.valueOf(configType.getValue()));
configJsonArray.add(configType.getName() + (configType.getValue() == null ? "" : String.valueOf(configType.getValue())));
break;
case 3:
// 拼接内容
chromeOption.addArguments(configType.getKey() + String.valueOf(configType.getValue()));
configJsonArray.add(configType.getName() + (configType.getValue() == null ? "" : String.valueOf(configType.getValue())));
break;
default:
throw new IllegalArgumentException("错误的类型: " + configType.getOptionType());
}
}
// 添加配置
chromeOption.setExperimentalOption("prefs", chromePrefs);
chromeOption.setExperimentalOption("mobileEmulation", mobileEmulation);
// 添加配置信息
informationJson.put("浏览器配置", configJsonArray);
return chromeOption;
}
/**
* <p>
* <b>文件名：</b>ChromeBrower.java
* </p>
* <p>
* <b>用途：</b>用于枚举出谷歌浏览器可以配置的参数
* </p>
* <p>
* <b>编码时间：</b>2020年4月14日下午7:57:36
* </p>
* <p>
* <b>修改时间：</b>2020年4月14日下午7:57:36
* </p>
*
* @author 彭宇琦
* @version Ver1.0
* @since JDK 12
*
*/
public enum ChromeOptionType {
/**
* 用于指定控制在本地或网络上已启动的浏览器，可以指定一个字符串参数，
* 表示被开启的浏览器的位置，如传入“127.0.0.1:9222”，则表示控制在"127.0.0.1:9222"上的浏览器<br>
* <b>注意：控制已打开的浏览器时，其他所有的配置均不会生效</b>
*/
CONTRAL_OPEN_BROWER("debuggerAddress", "启动已开启的浏览器", (short) 2),
/**
* 用于指定浏览器加载的页面不允许弹窗，无需指定参数
*/
DONOT_POPUPS("profile.managed_default_content_settings.popups", "禁止弹窗", (short) 1, 2),
/**
* 用于指定浏览器下载的文件路径，可以指定一个字符串参数，表示文件下载的位置，当指定有误时则下载至默认路径
*/
DOWNLOAD_FILE_PATH("download.default_directory", "文件下载路径", (short) 1),
/**
* 用于指定浏览器加载的页面不允许加载图片，无需指定参数
*/
DONOT_LOAD_IMAGE("profile.managed_default_content_settings.images", "禁止加载图片", (short) 1, 2),
/**
* 用于指定浏览器加载的页面不允许加载javascript，无需指定参数
*/
DONOT_LOAD_JS("profile.managed_default_content_settings.javascript", "禁止加载js", (short) 1, 2),
/**
* 用于指定使用无头浏览器运行，无需指定参数
*/
HEADLESS("-headless", "启动无头浏览器", (short) 0),
/**
* 用于设置浏览器以何种分辨率启动，需要指定一个字符串参数，以“宽, 长”的格式传入， 如需要使用“1024*768”的分辨率，则传入“"1027,
* 768"”，否则设置不会生效。<br>
* 注意，使用该参数设置时，会与浏览器全屏操作相矛盾，selenium会以全屏为主
*/
SET_WINDOW_SIZE("--window-size=", "设置浏览器分辨率", (short) 3),
/**
* 设置浏览器全屏启动
*/
SET_WINDOW_MAX_SIZE("--start-maximized", "设置浏览器全屏", (short) 0);
// TODO 添加忽略证书错误、隐藏“正在受自动测试....”提示、模拟手机等
;
/**
* 用于指向谷歌设置的key值
*/
private String key;
/**
* 用于指向对操作的解释（即存储在information中的名称）
*/
private String name;
/**
* 用于指向该设置操作的类型
* <ol>
* <li>0表示使用addArguments（启动配置项）配置</li>
* <li>1表示setExperimentalOption（个性化配置）需要存储至map的配置</li>
* <li>2表示setExperimentalOption（个性化配置）不需要存储至map的配置</li>
* <li>3表示使用addArguments（启动配置项）配置，但需要拼接参数</li>
* </ol>
*/
private short optionType;
/**
* 用于存储对操作设置的值
*/
private Object value;
/**
* 初始化配置
*
* @param key 谷歌设置的key值
* @param name 操作的解释
* @param optionType 操作的类型
*/
private ChromeOptionType(String key, String name, short optionType) {
this.key = key;
this.name = name;
this.optionType = optionType;
}
/**
* 初始化配置
*
* @param key 谷歌设置的key值
* @param name 操作的解释
* @param optionType 操作的类型
* @param value 对枚举设置的值
*/
private ChromeOptionType(String key, String name, short optionType, Object value) {
this.key = key;
this.name = name;
this.optionType = optionType;
this.value = value;
}
/**
* 返回谷歌浏览器配置的key值
*
* @return 谷歌浏览器配置的key值
*/
public String getKey() {
return key;
}
/**
* 返回谷歌浏览器配置的解释，用于存储至information中使用
*
* @return 谷歌浏览器配置的解释
*/
public String getName() {
return name;
}
/**
* 返回对浏览器配置的操作类型
* <ol>
* <li>0表示使用addArguments（启动配置项）配置</li>
* <li>1表示setExperimentalOption（个性化配置）需要存储至map的配置</li>
* <li>2表示setExperimentalOption（个性化配置）不需要存储至map的配置</li>
* <li>3表示使用addArguments（启动配置项）配置，但需要拼接参数</li>
* </ol>
*
* @return 浏览器配置的操作类型
*/
public short getOptionType() {
return optionType;
}
/**
* 用于返回存储在枚举中需要对浏览器设置的值
*
* @return 需要对浏览器设置的值
*/
public Object getValue() {
return value;
}
/**
* 用于对枚举对应的操作设置的值。注意，设置浏览器参数值的时候要传入正确的参数，否则设置无效
*
* @param value 对浏览器设置的值
*/
void setValue(Object value) {
this.value = value;
}
}
}

2
src/main/java/pres/auxiliary/work/selenium/browers/IncorrectPageException.java → src/main/java/pres/auxiliary/work/selenium/brower/IncorrectPageException.java
View File

@ -1,4 +1,4 @@
package pres.auxiliary.work.selenium.browers;
package pres.auxiliary.work.selenium.brower;
/**
* <p><b>文件名：</b>IncorrectPageException.java</p>

43
src/main/java/pres/auxiliary/work/selenium/browers/Page.java → src/main/java/pres/auxiliary/work/selenium/brower/Page.java
View File

@ -1,4 +1,4 @@
package pres.auxiliary.work.selenium.browers;
package pres.auxiliary.work.selenium.brower;
import java.util.concurrent.TimeUnit;
@ -57,9 +57,9 @@ public class Page {
this.pageName = pageName;
//存储页面信息
pageInformationJson.put("待测站点入口url", url);
pageInformationJson.put("页面名称", pageName);
pageInformationJson.put("页面站点", url);
pageInformationJson.put("页面加载时间", loadTime);
// pageInformationJson.put("页面标题断言", assertTitle);
}
/**
@ -190,4 +190,41 @@ public class Page {
}
}
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((handle == null) ? 0 : handle.hashCode());
result = prime * result + ((pageName == null) ? 0 : pageName.hashCode());
result = prime * result + ((url == null) ? 0 : url.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Page other = (Page) obj;
if (handle == null) {
if (other.handle != null)
return false;
} else if (!handle.equals(other.handle))
return false;
if (pageName == null) {
if (other.pageName != null)
return false;
} else if (!pageName.equals(other.pageName))
return false;
if (url == null) {
if (other.url != null)
return false;
} else if (!url.equals(other.url))
return false;
return true;
}
}

39
src/main/java/pres/auxiliary/work/selenium/browers/IncorrectPageTitleException.java
View File

@ -1,39 +0,0 @@
package pres.auxiliary.work.selenium.browers;
/**
* 该异常在目标站点Title与设置的目标站点Title不一致的情况下抛出的异常，继承于RuntimeException
*
* @author 彭宇琦
* @version Ver1.0
*/
public class IncorrectPageTitleException extends RuntimeException {
private static final long serialVersionUID = 1L;
public IncorrectPageTitleException() {
super();
// TODO Auto-generated constructor stub
}
public IncorrectPageTitleException(String message, Throwable cause, boolean enableSuppression,
boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
// TODO Auto-generated constructor stub
}
public IncorrectPageTitleException(String message, Throwable cause) {
super(message, cause);
// TODO Auto-generated constructor stub
}
public IncorrectPageTitleException(String message) {
super(message);
// TODO Auto-generated constructor stub
}
public IncorrectPageTitleException(Throwable cause) {
super(cause);
// TODO Auto-generated constructor stub
}
}

BIN
src/test/java/pres/auxiliary/selenium/browers/chromedriver.exe
View File

Binary file not shown.

231
src/test/java/pres/auxiliary/work/selenium/brower/TestChromeBrower.java Normal file
View File

@ -0,0 +1,231 @@
package pres.auxiliary.work.selenium.brower;
import java.io.File;
import java.util.Scanner;
import org.testng.annotations.AfterClass;
import org.testng.annotations.Test;
import pres.auxiliary.work.selenium.brower.ChromeBrower.ChromeOptionType;
/**
* <p><b>文件名：</b>TestChromeBrower.java</p>
* <p><b>用途：</b>用于对{@link ChromeBrower}类进行测试</p>
* <p><b>编码时间：</b>2020年4月17日下午3:40:47</p>
* <p><b>修改时间：</b>2020年4月17日下午3:40:47</p>
* @author
* @version Ver1.0
* @since JDK 12
*
*/
public class TestChromeBrower {
/**
* 指向driver文件
*/
private final File driverFile = new File("Resource/BrowersDriver/Chrom/78.0394.70/chromedriver.exe");
/**
* 指向浏览器对象
*/
ChromeBrower cb;
/**
* 关闭浏览器
*/
@AfterClass
public void quit() {
cb.getAllInformation().forEach((k, v) -> {
System.out.println(k + "：" + v);
});
Scanner sc = new Scanner(System.in);
sc.next();
cb.closeBrower();
sc.close();
}
/**
* 测试只打开浏览器
*/
@Test
public void chromeBrowerTest_File() {
cb = new ChromeBrower(driverFile);
cb.getDriver();
}
/**
* 测试打开浏览器后加载预设界面
*/
@Test
public void chromeBrowerTest_FilePage() {
cb = new ChromeBrower(driverFile, new Page("https://www.baidu.com", "百度"));
cb.getDriver();
}
/**
* 测试打开浏览器后加载预设界面
*/
@Test
public void chromeBrowerTest_FileStringString() {
cb = new ChromeBrower(driverFile, "https://www.hao123.com", "好123");
cb.getDriver();
}
@Test
public void addConfigTest_ChromeOptionType() {
cb = new ChromeBrower(driverFile, "https://www.hao123.com", "好123");
//不加载图片
cb.addConfig(ChromeOptionType.DONOT_LOAD_IMAGE);
//不加载js
cb.addConfig(ChromeOptionType.DONOT_LOAD_JS);
//不允许弹窗
cb.addConfig(ChromeOptionType.DONOT_POPUPS);
//全屏启动
cb.addConfig(ChromeOptionType.HEADLESS);
cb.getDriver();
}
@Test
public void addConfigTest_ChromeOptionTypeObject() {
cb = new ChromeBrower(driverFile, "https://www.hao123.com", "好123");
//不加载图片
cb.addConfig(ChromeOptionType.DONOT_LOAD_IMAGE);
//不加载js
cb.addConfig(ChromeOptionType.DONOT_LOAD_JS);
//1027*768的分辨率启动
cb.addConfig(ChromeOptionType.SET_WINDOW_SIZE, "1224, 768");
cb.getDriver();
}
/**
* 测试控制已打开的浏览器
*/
@Test
public void addConfigTest_ContrlBrower() {
cb = new ChromeBrower(driverFile);
//1027*768的分辨率启动
cb.addConfig(ChromeOptionType.CONTRAL_OPEN_BROWER, "127.0.0.1:9222");
cb.getDriver().get("http://www.baidu.com");
}
/**
* 测试在新浏览器中以新标签形式打开新页面，并在基础上再打开一个新标签，加载另一个页面
* @throws InterruptedException
*/
@Test
public void openUrlTest_PageBoolean() throws InterruptedException {
cb = new ChromeBrower(driverFile);
//不加载图片
cb.addConfig(ChromeOptionType.DONOT_LOAD_IMAGE);
//不加载js
cb.addConfig(ChromeOptionType.DONOT_LOAD_JS);
cb.getDriver();
cb.openUrl(new Page("http://www.baidu.com", "百度"), true);
Thread.sleep(5000);
cb.openUrl(new Page("http://www.hao123.com", "hao123"), true);
}
/**
* 测试在新浏览器中以原形式打开新页面，并在基础上在当前标签中，加载另一个页面
* @throws InterruptedException
*/
@Test
public void openUrlTest_StringStringBoolean() throws InterruptedException {
cb = new ChromeBrower(driverFile);
//不加载图片
cb.addConfig(ChromeOptionType.DONOT_LOAD_IMAGE);
//不加载js
cb.addConfig(ChromeOptionType.DONOT_LOAD_JS);
cb.getDriver();
cb.openUrl("http://www.baidu.com", "百度", false);
Thread.sleep(5000);
cb.openUrl("http://www.hao123.com", "hao123", false);
}
/**
* 测试关闭标签，并测试关闭至最后一个标签
* @throws InterruptedException
*/
@Test
public void closeLabelTest() throws InterruptedException {
cb = new ChromeBrower(driverFile, "https://www.hao123.com", "好123");
//不加载图片
cb.addConfig(ChromeOptionType.DONOT_LOAD_IMAGE);
//不加载js
cb.addConfig(ChromeOptionType.DONOT_LOAD_JS);
cb.getDriver();
cb.openUrl("http://www.baidu.com", "百度", true);
Thread.sleep(2500);
cb.closeLabel();
Thread.sleep(5000);
cb.closeLabel();
Thread.sleep(2500);
cb.openUrl("http://www.hao123.com", "hao123", false);
}
/**
* 测试重新唤起浏览器
* @throws InterruptedException
*/
@Test
public void closeBrowerTest() throws InterruptedException {
cb = new ChromeBrower(driverFile, "https://www.hao123.com", "好123");
//不加载图片
cb.addConfig(ChromeOptionType.DONOT_LOAD_IMAGE);
//不加载js
cb.addConfig(ChromeOptionType.DONOT_LOAD_JS);
cb.getDriver();
Thread.sleep(2500);
cb.closeBrower();
Thread.sleep(2500);
cb.getDriver();
cb.openUrl("http://www.baidu.com", "百度", true);
Thread.sleep(2500);
cb.initialization();
}
/**
* 测试切换页面
* @throws InterruptedException
*/
@Test
public void switchWindowTest() throws InterruptedException {
Page page = new Page("https://www.hao123.com", "好123");
cb = new ChromeBrower(driverFile, page);
//不加载图片
cb.addConfig(ChromeOptionType.DONOT_LOAD_IMAGE);
//不加载js
cb.addConfig(ChromeOptionType.DONOT_LOAD_JS);
cb.getDriver();
cb.openUrl("http://www.baidu.com", "百度", true);
cb.openUrl("http://www.qq.com", "腾讯", true);
Thread.sleep(2500);
cb.switchWindow("百度");
cb.openUrl("http://www.163.com", "网易", false);
Thread.sleep(2500);
cb.switchWindow(page);
cb.closeLabel();
}
}

30
src/test/java/test/selenium/brower/TestOpenNewHandle.java
View File

@ -31,7 +31,8 @@ public class TestOpenNewHandle {
public void overridePage() throws InterruptedException {
cd.get("http://www.baidu.com");
Thread.sleep(2000);
cd.get("http://www.qq.com");
cd.get("about:blank");
cd.switchTo().window("");
}
/**
@ -72,4 +73,31 @@ public class TestOpenNewHandle {
cd.get("http://www.163.com");
}
/**
* 覆盖原标签页
* @throws InterruptedException
*/
@Test
public void closeLabel() throws InterruptedException {
cd.get("http://www.baidu.com");
Thread.sleep(2000);
//获取当前所有的handle
Set<String> handleSet = cd.getWindowHandles();
//编写js脚本，执行js，以开启一个新的标签页
String js = "window.open(\"\");";
cd.executeScript(js);
//移除原有的windows的Handle，保留新打开的windows的Handle
String newHandle = "";
for (String handle : cd.getWindowHandles()) {
if (!handleSet.contains(handle)) {
newHandle = handle;
break;
}
}
cd.close();
cd.switchTo().window(newHandle);
cd.get("http://www.163.com");
}
}