";
76 | public static final String NO_ELEMENT_FOUND = "No element found";
77 | public static final String ELEMENT_NOT_PRESENT = "Element not present";
78 | public static final String ELEMENT_NOT_SELECT = "Element not select";
79 | public static final String ELEMENT_NOT_TABLE = "Element not table";
80 | public static final String CELL_OUT_OF_BOUNDS = "Cell out of bounds";
81 | public static final String CONTAINS = "' contains '";
82 | public static final String DOES_NOT_MATCH_PATTERN = "' doesn't match pattern '";
83 | public static final String DOES_NOT_CONTAIN = "' doesn't contain '";
84 | public static final String EXPECTED_ELEMENT_NOT_PRESENT = "Expected Element Not Present";
85 |
86 | public static final String EXPECTED_TO_FIND_A_RESPONSE_OF = "Expected to find a response of: ";
87 | public static final String EXPECTED_TO_FIND_A_RESPONSE_CONTAINING = "Expected to find a response containing: ";
88 | public static final String EXPECTED_TO_FIND_A_RESPONSE_EXCLUDING = "Expected to find a response excluding: ";
89 | public static final String EXPECTED_TO_FIND_A_RESPONSE_MATCHING = "Expected to find a response matching a pattern of: ";
90 | public static final String EXPECTED_TO_FIND = "Expected to find ";
91 | public static final String EXPECTED_NOT_TO_FIND = "Expected not to find ";
92 | public static final String CONTAINING = " containing: ";
93 | public static final String EXCLUDING = " excluding: ";
94 | public static final String FOUND = "Found a response of: ";
95 | public static final String STARTI = "'";
96 | public static final String ENDI = "'";
97 | public static final String STARTB = "";
98 | public static final String ENDB = "";
99 | public static final String DIV_I = "";
100 | public static final String END_IDIV = "
";
101 |
102 | static final String LINK_START = "";
104 | static final String LINK_END = "";
105 |
106 | public static final Gson GSON = new GsonBuilder().setPrettyPrinting().create();
107 |
108 | private Constants() {
109 | }
110 | }
111 |
--------------------------------------------------------------------------------
/src/main/java/com/coveros/selenified/utilities/Hub.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2019 Coveros, Inc.
3 | *
4 | * This file is part of Selenified.
5 | *
6 | * Selenified is licensed under the Apache License, Version
7 | * 2.0 (the "License"); you may not use this file except
8 | * in compliance with the License. You may obtain a copy
9 | * of the License at
10 | *
11 | * http://www.apache.org/licenses/LICENSE-2.0
12 | *
13 | * Unless required by applicable law or agreed to in writing,
14 | * software distributed under the License is distributed on
15 | * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 | * KIND, either express or implied. See the License for the
17 | * specific language governing permissions and limitations
18 | * under the License.
19 | */
20 |
21 | package com.coveros.selenified.utilities;
22 |
23 | import com.coveros.selenified.exceptions.InvalidHubException;
24 |
25 | import java.net.MalformedURLException;
26 | import java.net.URL;
27 |
28 | import static com.coveros.selenified.utilities.Property.HUB;
29 | import static com.coveros.selenified.utilities.Property.getProgramProperty;
30 |
31 | /**
32 | * Utilities class to interact with some remote hub driver, retrieving information such as username, key, and test status
33 | *
34 | * @author Max Saperstone
35 | * @version 3.3.1
36 | * @lastupdate 8/23/2019
37 | */
38 | public class Hub {
39 |
40 | private static final String HUB_ISN_T_SET = "Hub isn't set";
41 | private static final String HUB_USER = "HUB_USER";
42 | private static final String HUB_PASS = "HUB_PASS";
43 | private URL hubURL;
44 | private String username = null;
45 | private String password = null;
46 |
47 | public Hub() throws MalformedURLException {
48 | if (!isHubSet()) {
49 | throw new InvalidHubException(HUB_ISN_T_SET);
50 | }
51 | String hubProperty = getProgramProperty(HUB);
52 | try {
53 | this.hubURL = new URL(hubProperty);
54 | } catch (MalformedURLException e) {
55 | throw new InvalidHubException("Hub '" + hubProperty + "' isn't valid. Must contain protocol, optionally credentials, and endpoint");
56 | }
57 | setUserInfo();
58 | String credentials = username == null ? "" : username + ":" + password + "@";
59 | String port = hubURL.getPort() == -1 ? "" : ":" + hubURL.getPort();
60 | this.hubURL = new URL(hubURL.getProtocol() + "://" + credentials + hubURL.getHost() + port + hubURL.getFile() + "/wd/hub");
61 | }
62 |
63 | /**
64 | * Determines if a hub property is set. This could be to sauce, grid, or any other cloud tool.
65 | * This should be provided with the protocol and address, but leaving out the /wd/hub
66 | *
67 | * @return boolean: is a hub location set
68 | */
69 | public static boolean isHubSet() {
70 | String hub = getProgramProperty(HUB);
71 | return hub != null && !"".equals(hub);
72 | }
73 |
74 | private void setUserInfo() throws InvalidHubException {
75 | String userInfo = hubURL.getUserInfo();
76 | if (System.getenv(HUB_USER) != null && System.getenv(HUB_PASS) != null) {
77 | this.username = System.getenv(HUB_USER);
78 | this.password = System.getenv(HUB_PASS);
79 | } else if (userInfo != null) {
80 | int split = userInfo.indexOf(':');
81 | if (split >= 0 && split <= userInfo.length()) {
82 | this.username = userInfo.substring(0, split);
83 | this.password = userInfo.substring(split + 1);
84 | } else {
85 | throw new InvalidHubException("Hub isn't valid. Credentials '" + userInfo + "' must contain both username and password");
86 | }
87 | }
88 | }
89 |
90 | /**
91 | * Retrieves the hub property if it is set. This could be to sauce, grid, or any other cloud tool.
92 | * This should be provided with the protocol and address, but leaving out the /wd/hub
93 | *
94 | * @return String: the set hub address, null if none are set
95 | */
96 | public URL getHubURL() {
97 | return hubURL;
98 | }
99 |
100 | public String getUsername() {
101 | return username;
102 | }
103 |
104 | public String getPassword() {
105 | return password;
106 | }
107 | }
108 |
--------------------------------------------------------------------------------
/src/main/java/com/coveros/selenified/utilities/LambdaTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2019 Coveros, Inc.
3 | *
4 | * This file is part of Selenified.
5 | *
6 | * Selenified is licensed under the Apache License, Version
7 | * 2.0 (the "License"); you may not use this file except
8 | * in compliance with the License. You may obtain a copy
9 | * of the License at
10 | *
11 | * http://www.apache.org/licenses/LICENSE-2.0
12 | *
13 | * Unless required by applicable law or agreed to in writing,
14 | * software distributed under the License is distributed on
15 | * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 | * KIND, either express or implied. See the License for the
17 | * specific language governing permissions and limitations
18 | * under the License.
19 | */
20 |
21 | package com.coveros.selenified.utilities;
22 |
23 | import com.coveros.selenified.services.HTTP;
24 | import com.coveros.selenified.services.Request;
25 | import com.google.gson.JsonObject;
26 | import org.testng.ITestResult;
27 | import org.testng.log4testng.Logger;
28 |
29 | import java.io.IOException;
30 | import java.net.MalformedURLException;
31 |
32 | import static com.coveros.selenified.Selenified.SESSION_ID;
33 | import static com.coveros.selenified.utilities.Property.HUB;
34 | import static com.coveros.selenified.utilities.Property.getProgramProperty;
35 |
36 | /**
37 | * Utilities class to interact with lambda test, retrieving information such as username, key, and test status
38 | *
39 | * @author Max Saperstone
40 | * @version 3.3.1
41 | * @lastupdate 8/18/2019
42 | */
43 | public class LambdaTest extends Hub {
44 | private static final Logger log = Logger.getLogger(LambdaTest.class);
45 |
46 | public LambdaTest() throws MalformedURLException {
47 | super();
48 | }
49 |
50 | /**
51 | * Determine whether the hub parameter is set, and if it is, is it set to sauce labs? Iff, then will return true,
52 | * otherwise, returns false
53 | *
54 | * @return Boolean: whether sauce labs is specified as the hub
55 | */
56 | public static Boolean isLambdaTest() {
57 | String hub = getProgramProperty(HUB);
58 | return hub != null && hub.contains("hub.lambdatest.com");
59 | }
60 |
61 | /**
62 | * Connects with Lambda Test and updates the status in their system to the test result
63 | * status
64 | *
65 | * @param result - the testng itestresult object
66 | */
67 | static void updateStatus(ITestResult result) {
68 | if (isLambdaTest() && result.getAttributeNames().contains(SESSION_ID)) {
69 | String sessionId = result.getAttribute(SESSION_ID).toString();
70 | JsonObject json = new JsonObject();
71 | String status = (result.getStatus() == 1) ? "passed" : "failed";
72 | json.addProperty("status_ind", status);
73 | try {
74 | LambdaTest lambdaTest = new LambdaTest();
75 | HTTP http = new HTTP(null, "https://api.lambdatest.com/automation/api/v1/", lambdaTest.getUsername(), lambdaTest.getPassword());
76 | http.patch("sessions/" + sessionId, new Request().setJsonPayload(json), null);
77 | } catch (MalformedURLException e) {
78 | log.error("Unable to connect to lambda test, due to credential problems");
79 | } catch (IOException e) {
80 | log.error(e);
81 | }
82 | }
83 | }
84 | }
--------------------------------------------------------------------------------
/src/main/java/com/coveros/selenified/utilities/Sauce.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2019 Coveros, Inc.
3 | *
4 | * This file is part of Selenified.
5 | *
6 | * Selenified is licensed under the Apache License, Version
7 | * 2.0 (the "License"); you may not use this file except
8 | * in compliance with the License. You may obtain a copy
9 | * of the License at
10 | *
11 | * http://www.apache.org/licenses/LICENSE-2.0
12 | *
13 | * Unless required by applicable law or agreed to in writing,
14 | * software distributed under the License is distributed on
15 | * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 | * KIND, either express or implied. See the License for the
17 | * specific language governing permissions and limitations
18 | * under the License.
19 | */
20 |
21 | package com.coveros.selenified.utilities;
22 |
23 | import com.coveros.selenified.exceptions.InvalidSauceException;
24 | import com.saucelabs.saucerest.SauceException;
25 | import com.saucelabs.saucerest.SauceREST;
26 | import org.openqa.selenium.remote.DesiredCapabilities;
27 | import org.testng.ITestResult;
28 | import org.testng.log4testng.Logger;
29 |
30 | import java.net.MalformedURLException;
31 |
32 | import static com.coveros.selenified.Selenified.SESSION_ID;
33 | import static com.coveros.selenified.utilities.Property.HUB;
34 | import static com.coveros.selenified.utilities.Property.getProgramProperty;
35 |
36 | /**
37 | * Utilities class to interact with sauce labs, retrieving information such as username, key, and test status
38 | *
39 | * @author Max Saperstone
40 | * @version 3.3.1
41 | * @lastupdate 8/18/2019
42 | */
43 | public class Sauce extends Hub {
44 | private static final Logger log = Logger.getLogger(Sauce.class);
45 | private static final String SAUCE_HUB_ISN_T_SET = "Sauce hub isn't set";
46 |
47 | public Sauce() throws MalformedURLException {
48 | super();
49 | }
50 |
51 | /**
52 | * Determine whether the hub parameter is set, and if it is, is it set to sauce labs? Iff, then will return true,
53 | * otherwise, returns false
54 | *
55 | * @return Boolean: whether sauce labs is specified as the hub
56 | */
57 | public static Boolean isSauce() {
58 | String hub = getProgramProperty(HUB);
59 | return hub != null && hub.contains("ondemand.saucelabs.com");
60 | }
61 |
62 | /**
63 | * Connects with SauceLabs and updates the status in their system to the test result
64 | * status
65 | *
66 | * @param result - the testng itestresult object
67 | */
68 | static void updateStatus(ITestResult result) {
69 | if (isSauce() && result.getAttributeNames().contains(SESSION_ID)) {
70 | String sessionId = result.getAttribute(SESSION_ID).toString();
71 | try {
72 | SauceREST sauce = new Sauce().getSauceConnection();
73 | if (result.getStatus() == 1) {
74 | sauce.jobPassed(sessionId);
75 | } else {
76 | sauce.jobFailed(sessionId);
77 | }
78 | } catch (SauceException | MalformedURLException e) {
79 | log.error("Unable to connect to sauce, due to credential problems");
80 | }
81 | }
82 | }
83 |
84 | /**
85 | * Sauce labs has specific capabilities to manage the selenium version used. The version is obtained from the
86 | * POM (or could be passed in via CMD to override) and then set so that Sauce sets the specific selenium version,
87 | * instead of their default: https://wiki.saucelabs.com/display/DOCS/Test+Configuration+Options#TestConfigurationOptions-SeleniumVersion
88 | * Additionally, the iedriverVersion is set to match the selenium version as suggested, if ie is the chosen browser
89 | * Finally, the default platform for edge is set to windows 10
90 | */
91 | public static void setupSauceCapabilities(DesiredCapabilities desiredCapabilities) {
92 | if (Sauce.isSauce()) {
93 | // set the selenium version
94 | desiredCapabilities.setCapability("seleniumVersion", System.getProperty("selenium.version"));
95 | // set the ie driver if needed
96 | if (desiredCapabilities.getBrowserName().equals("internet explorer")) {
97 | desiredCapabilities.setCapability("iedriverVersion", System.getProperty("selenium.version"));
98 | }
99 | }
100 | }
101 |
102 | /**
103 | * Creates a new connection to sauce labs
104 | *
105 | * @return SauceREST: an object with information to connect to/update sauce labs
106 | * @throws MalformedURLException if no sauce connection is set, invalid hub will be thrown
107 | */
108 | public SauceREST getSauceConnection() throws MalformedURLException {
109 | if (!isSauce()) {
110 | throw new InvalidSauceException(SAUCE_HUB_ISN_T_SET);
111 | }
112 | return new SauceREST(getUsername(), getPassword());
113 | }
114 | }
--------------------------------------------------------------------------------
/src/main/java/com/coveros/selenified/utilities/TestCase.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2019 Coveros, Inc.
3 | *
4 | * This file is part of Selenified.
5 | *
6 | * Selenified is licensed under the Apache License, Version
7 | * 2.0 (the "License"); you may not use this file except
8 | * in compliance with the License. You may obtain a copy
9 | * of the License at
10 | *
11 | * http://www.apache.org/licenses/LICENSE-2.0
12 | *
13 | * Unless required by applicable law or agreed to in writing,
14 | * software distributed under the License is distributed on
15 | * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 | * KIND, either express or implied. See the License for the
17 | * specific language governing permissions and limitations
18 | * under the License.
19 | */
20 |
21 | package com.coveros.selenified.utilities;
22 |
23 | import java.lang.reflect.Method;
24 | import java.util.Random;
25 |
26 | /**
27 | * Manages the test cases, including naming conventions and formatting
28 | *
29 | * @author Max Saperstone
30 | * @version 3.3.1
31 | * @lastupdate 6/28/2019
32 | */
33 | public class TestCase {
34 |
35 | private TestCase() {
36 | }
37 |
38 | //constants
39 | private static final int MAXFILENAMELENGTH = 200;
40 |
41 | /**
42 | * Generates a random string of alpha-numeric characters
43 | *
44 | * @param length the length of the random string
45 | * @return String: random string of characters
46 | */
47 | public static String getRandomString(int length) {
48 | if (length <= 0) {
49 | return "";
50 | }
51 | String stringChars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
52 | Random rnd = new Random();
53 | StringBuilder sb = new StringBuilder(length);
54 | for (int i = 0; i < length; i++) {
55 | sb.append(stringChars.charAt(rnd.nextInt(stringChars.length())));
56 | }
57 | return sb.toString();
58 | }
59 |
60 | /**
61 | * Removes all non alphanumeric characters from a provided string
62 | *
63 | * @param value - the string to cleanup
64 | * @return String: the provided string with all alphanumeric characters
65 | * removed
66 | */
67 | public static String removeNonWordCharacters(String value) {
68 | if (value == null) {
69 | return null;
70 | }
71 | return value.replaceAll("[^a-zA-Z0-9]+", "");
72 | }
73 |
74 | /**
75 | * Determines the unique test name, based on the parameters passed in
76 | *
77 | * @param method - the method under test to extract the name from
78 | * @param dataProvider - an array of objects being passed to the test as data
79 | * providers
80 | * @return String: a unique name
81 | */
82 | public static String getTestName(Method method, Object... dataProvider) {
83 | //TODO - look at making use of new setTestName and getFactoryParameters
84 | return getTestName(method.getDeclaringClass().getName(), method.getName(), dataProvider);
85 | }
86 |
87 | /**
88 | * Determines the unique test name, based on the parameters passed in
89 | *
90 | * @param className - the class name of the test method as a string
91 | * @param methodName - the method name of the test as a string
92 | * @param dataProvider - an array of objects being passed to the test as data
93 | * providers
94 | * @return String: a unique name
95 | */
96 | @SuppressWarnings("squid:S2116")
97 | public static String getTestName(String className, String methodName, Object... dataProvider) {
98 | StringBuilder testName = new StringBuilder(className + "." + methodName);
99 | if (dataProvider != null && dataProvider.length > 0) {
100 | addParameters(testName, dataProvider);
101 | if (testName.toString().length() > MAXFILENAMELENGTH) {
102 | testName = new StringBuilder(className + "." + methodName + dataProvider.toString().split(";")[1]);
103 | // purposefully using toString on object to obtain unique random hash
104 | }
105 | }
106 | return testName.toString();
107 | }
108 |
109 | /**
110 | * Loops through dataProviders, and adds string value of each one to test case name
111 | *
112 | * @param testName - StringBuilder containing the test case name
113 | * @param dataProvider - an array of objects being passed to the test as data
114 | * providers
115 | */
116 | static void addParameters(StringBuilder testName, Object[] dataProvider) {
117 | StringBuilder stringBuilder = new StringBuilder();
118 | for (Object data : dataProvider) {
119 | if (data == null) {
120 | continue;
121 | }
122 | stringBuilder.append(Reporter.capitalizeFirstLetters(removeNonWordCharacters(data.toString())));
123 | }
124 | if(stringBuilder.length() > 0) {
125 | testName.append("WithOption").append(stringBuilder);
126 | }
127 | }
128 | }
129 |
--------------------------------------------------------------------------------
/src/main/java/com/coveros/selenified/utilities/Transformer.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2019 Coveros, Inc.
3 | *
4 | * This file is part of Selenified.
5 | *
6 | * Selenified is licensed under the Apache License, Version
7 | * 2.0 (the "License"); you may not use this file except
8 | * in compliance with the License. You may obtain a copy
9 | * of the License at
10 | *
11 | * http://www.apache.org/licenses/LICENSE-2.0
12 | *
13 | * Unless required by applicable law or agreed to in writing,
14 | * software distributed under the License is distributed on
15 | * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 | * KIND, either express or implied. See the License for the
17 | * specific language governing permissions and limitations
18 | * under the License.
19 | */
20 |
21 | package com.coveros.selenified.utilities;
22 |
23 | import org.apache.commons.lang3.StringUtils;
24 | import org.testng.annotations.ITestAnnotation;
25 | import org.testng.internal.annotations.IAnnotationTransformer;
26 |
27 | import java.lang.reflect.Constructor;
28 | import java.lang.reflect.Method;
29 |
30 | import static com.coveros.selenified.utilities.Property.getBrowser;
31 |
32 | /**
33 | * Programmatically sets an invocation count for each test, based on the number
34 | * of browsers desired to test on. This allows for simple looping of the same
35 | * test multiple times each run on a different browser, which is handled by the
36 | * Selenified class. This class should be specified as a listener for the main
37 | * Selenified class, and/or in the TestNG xml file.
38 | *
39 | * @author Max Saperstone
40 | * @version 3.3.1
41 | * @lastupdate 8/29/2018
42 | */
43 | public class Transformer implements IAnnotationTransformer {
44 |
45 | /**
46 | * overrides the basic TestNG transform function to provide dynamic access
47 | * to an invocation count
48 | */
49 | @SuppressWarnings("rawtypes")
50 | @Override
51 | public void transform(ITestAnnotation annotation, Class testClass, Constructor testConstructor, Method testMethod) {
52 | annotation.setInvocationCount(StringUtils.countMatches(getBrowser(), ",") + 1);
53 | }
54 | }
55 |
--------------------------------------------------------------------------------
/src/test/java/ConflictIT.java:
--------------------------------------------------------------------------------
1 | import com.coveros.selenified.Locator;
2 | import com.coveros.selenified.Selenified;
3 | import com.coveros.selenified.application.App;
4 | import com.coveros.selenified.element.Element;
5 | import integration.WebBase;
6 | import org.testng.ITestContext;
7 | import org.testng.annotations.BeforeClass;
8 | import org.testng.annotations.Test;
9 |
10 | public class ConflictIT extends WebBase {
11 |
12 | @Test(groups = {"integration", "conflict"},
13 | description = "A sample test to show how to loop through elements with multiple matches")
14 | public void conflictingTestName() {
15 | // use this object to manipulate the app
16 | App app = this.apps.get();
17 | // perform some actions
18 | Element element = app.newElement(Locator.XPATH, "//form/input[@type='checkbox']");
19 | for (int match = 0; match < element.get().matchCount(); match++) {
20 | element.setMatch(match);
21 | element.click();
22 | element.assertState().checked();
23 | }
24 | // close out the test
25 | finish();
26 | }
27 | }
--------------------------------------------------------------------------------
/src/test/java/TestCaseTest.java:
--------------------------------------------------------------------------------
1 | import com.coveros.selenified.utilities.TestCase;
2 | import org.testng.annotations.Test;
3 |
4 | import java.lang.reflect.Method;
5 |
6 | import static org.testng.Assert.assertEquals;
7 |
8 | public class TestCaseTest {
9 | @Test
10 | public void getTestNameTest(Method method) {
11 | assertEquals(TestCase.getTestName(method), "TestCaseTest.getTestNameTest");
12 | }
13 |
14 | }
15 |
--------------------------------------------------------------------------------
/src/test/java/integration/ConflictIT.java:
--------------------------------------------------------------------------------
1 | package integration;
2 |
3 | import com.coveros.selenified.Locator;
4 | import com.coveros.selenified.application.App;
5 | import com.coveros.selenified.element.Element;
6 | import org.testng.annotations.Test;
7 |
8 | @Test(groups = {"conflict full"})
9 | public class ConflictIT extends WebBase {
10 |
11 | @Test(groups = {"integration", "conflict"},
12 | description = "A sample test to show how to loop through elements with multiple matches")
13 | public void conflictingTestName() {
14 | // use this object to manipulate the app
15 | App app = this.apps.get();
16 | // perform some actions
17 | Element element = app.newElement(Locator.XPATH, "//form/input[@type='checkbox']");
18 | for (int match = 0; match < element.get().matchCount(); match++) {
19 | element.setMatch(match);
20 | element.click();
21 | element.assertState().checked();
22 | }
23 | // close out the test
24 | finish();
25 | }
26 |
27 | }
28 |
--------------------------------------------------------------------------------
/src/test/java/integration/NoBrowserIT.java:
--------------------------------------------------------------------------------
1 | package integration;
2 |
3 | import com.coveros.selenified.application.App;
4 | import org.testng.ITestContext;
5 | import org.testng.ITestResult;
6 | import org.testng.annotations.BeforeMethod;
7 | import org.testng.annotations.Test;
8 |
9 | import java.io.IOException;
10 | import java.lang.reflect.Method;
11 |
12 | import static com.coveros.selenified.Browser.BrowserUse;
13 | import static org.testng.Assert.assertNull;
14 |
15 | public class NoBrowserIT extends WebBase {
16 |
17 | @BeforeMethod(alwaysRun = true)
18 | protected void startTest(Object[] dataProvider, Method method, ITestContext test, ITestResult result) throws IOException {
19 | super.startTest(dataProvider, method, test, result, BrowserUse.FALSE);
20 | }
21 |
22 | @Test(groups = {"integration"}, description = "An integration test to verify we can start a test without a browser")
23 | public void verifyNoBrowser() {
24 | // use this object to manipulate the app
25 | App app = this.apps.get();
26 | // verify no selenium actions class was setup
27 | assertNull(app);
28 | // verify no issues
29 | finish();
30 | }
31 | }
--------------------------------------------------------------------------------
/src/test/java/integration/NoJavascriptIT.java:
--------------------------------------------------------------------------------
1 | package integration;
2 |
3 | import com.coveros.selenified.Locator;
4 | import com.coveros.selenified.application.App;
5 | import org.testng.ITestContext;
6 | import org.testng.annotations.BeforeClass;
7 | import org.testng.annotations.Test;
8 |
9 | public class NoJavascriptIT extends WebBase {
10 |
11 | @BeforeClass(alwaysRun = true)
12 | public void beforeClass(ITestContext test) {
13 | addAdditionalDesiredCapabilities(this, test, "javascriptEnabled", false);
14 | super.beforeClass(test);
15 | }
16 |
17 | @Test(groups = {"integration", "assert", "excludes"},
18 | description = "An integration test to check the checkElementDoesntHaveAttribute method")
19 | public void checkElementDoesntHaveAnyAttributeTest() {
20 | // use this object to manipulate the app
21 | App app = this.apps.get();
22 | // perform some actions
23 | app.newElement(Locator.TAGNAME, "body").assertExcludes().attribute("class");
24 | // verify no issues
25 | finish();
26 | }
27 |
28 | @Test(groups = {"integration", "assert", "contains"},
29 | description = "An integration test to check the checkElementDoesntHaveAttribute method", expectedExceptions = AssertionError.class)
30 | public void checkElementDoesHaveAnAttributeTest() {
31 | // use this object to manipulate the app
32 | App app = this.apps.get();
33 | // perform some actions
34 | app.newElement(Locator.TAGNAME, "body").assertContains().attribute("class");
35 | // verify one issue
36 | finish(1);
37 | }
38 | }
39 |
--------------------------------------------------------------------------------
/src/test/java/integration/NoLoadIT.java:
--------------------------------------------------------------------------------
1 | package integration;
2 |
3 | import com.coveros.selenified.Browser.BrowserUse;
4 | import com.coveros.selenified.application.App;
5 | import com.coveros.selenified.utilities.Property;
6 | import org.apache.commons.io.FileUtils;
7 | import org.testng.ITestContext;
8 | import org.testng.ITestResult;
9 | import org.testng.annotations.BeforeMethod;
10 | import org.testng.annotations.Test;
11 |
12 | import java.io.File;
13 | import java.io.IOException;
14 | import java.lang.reflect.Method;
15 |
16 | import static org.testng.Assert.assertFalse;
17 | import static org.testng.Assert.assertNotNull;
18 |
19 | public class NoLoadIT extends WebBase {
20 |
21 | @BeforeMethod(alwaysRun = true)
22 | protected void startTest(Object[] dataProvider, Method method, ITestContext test, ITestResult result) throws IOException {
23 | super.startTest(dataProvider, method, test, result, BrowserUse.OPEN);
24 | }
25 |
26 | @SuppressWarnings("deprecation")
27 | @Test(groups = {"integration"},
28 | description = "An integration test to verify we can start a test with a browser, but won't load any app")
29 | public void verifyNoLoad(ITestContext context) throws IOException {
30 | // use this object to manipulate the app
31 | App app = this.apps.get();
32 | // verify a selenium actions class was setup
33 | assertNotNull(app);
34 | String directory = context.getOutputDirectory();
35 | String file = app.getReporter().getFileName();
36 | assertFalse(FileUtils.readFileToString(new File(directory, file + ".html"))
37 | .contains("Opening new browser and loading up starting app"));
38 | // verify the app wasn't attempted to load
39 | app.verify().urlEquals(Property.getAppURL(this.getClass().getName(), context));
40 | // verify one issue from the above check
41 | finish(1);
42 | }
43 | }
--------------------------------------------------------------------------------
/src/test/java/integration/OverrideIT.java:
--------------------------------------------------------------------------------
1 | package integration;
2 |
3 | import com.coveros.selenified.Browser;
4 | import com.coveros.selenified.Locator;
5 | import com.coveros.selenified.application.App;
6 | import com.coveros.selenified.element.Element;
7 | import org.openqa.selenium.remote.DesiredCapabilities;
8 | import org.testng.ITestContext;
9 | import org.testng.annotations.BeforeClass;
10 | import org.testng.annotations.Test;
11 |
12 | import static org.testng.Assert.assertFalse;
13 |
14 | public class OverrideIT extends WebBase {
15 |
16 | @BeforeClass(alwaysRun = true)
17 | public void beforeClass(ITestContext test) {
18 | addAdditionalDesiredCapabilities(this, test, "javascriptEnabled", false);
19 | super.beforeClass(test);
20 | }
21 |
22 | @Test(groups = {"integration", "selenified", "override"},
23 | description = "An integration test to check that properties can be overridden")
24 | public void overrideTest() {
25 | // use this object to manipulate the app
26 | App app = this.apps.get();
27 | // perform some actions
28 | Element table = app.newElement(Locator.ID, "table");
29 | if (app.getBrowser().getName() == Browser.BrowserName.HTMLUNIT) {
30 | table.verifyExcludes().attribute("id");
31 | // verify no issues
32 | finish();
33 | } else {
34 | table.assertContains().attribute("id");
35 | // verify no issues
36 | finish();
37 | }
38 | }
39 |
40 | @Test(groups = {"integration", "selenified", "override"},
41 | description = "An integration test to check that properties can be overridden")
42 | public void overrideVarCheckTest() {
43 | // use this object to manipulate the app
44 | App app = this.apps.get();
45 | // perform some actions
46 | DesiredCapabilities desiredCapabilities = app.getDesiredCapabilities();
47 | assertFalse(app.getDesiredCapabilities().isJavascriptEnabled());
48 | // verify no issues
49 | finish();
50 | }
51 | }
52 |
--------------------------------------------------------------------------------
/src/test/java/integration/SelenifiedIT.java:
--------------------------------------------------------------------------------
1 | package integration;
2 |
3 | import org.testng.annotations.Test;
4 |
5 | public class SelenifiedIT extends WebBase {
6 |
7 | @Test
8 | public void noAnnotationDetailsTest() {
9 | // verify no issues
10 | finish();
11 | }
12 |
13 | @Test(groups = {"integration", "selenified"})
14 | public void noDescriptionTest() {
15 | // verify no issues
16 | finish();
17 | }
18 |
19 | @Test(description = "A test to verify that logs work without any groups")
20 | public void noGroupsTest() {
21 | // verify no issues
22 | finish();
23 | }
24 |
25 | @Test(groups = "integration")
26 | public void oneGroupTest() {
27 | // verify no issues
28 | finish();
29 | }
30 |
31 | @Test(groups = {"integration", "selenified", "no-htmlunit", "no-chrome", "no-edge", "no-firefox", "no-safari", "no-internetexplorer"},
32 | description = "A test to verify a skip is thrown")
33 | public void skipThisTest() {
34 | this.apps.get().getReporter().fail("", "", "");
35 | finish();
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/src/test/java/integration/ServicesErrorIT.java:
--------------------------------------------------------------------------------
1 | package integration;
2 |
3 | import com.coveros.selenified.Browser.BrowserUse;
4 | import com.coveros.selenified.Selenified;
5 | import com.coveros.selenified.services.Call;
6 | import com.coveros.selenified.services.Request;
7 | import org.testng.ITestContext;
8 | import org.testng.ITestResult;
9 | import org.testng.annotations.BeforeClass;
10 | import org.testng.annotations.BeforeMethod;
11 | import org.testng.annotations.Test;
12 |
13 | import java.io.IOException;
14 | import java.lang.reflect.Method;
15 |
16 | public class ServicesErrorIT extends Selenified {
17 |
18 | @BeforeClass(alwaysRun = true)
19 | public void beforeClass(ITestContext test) {
20 | // set the base URL for the tests here
21 | setAppURL(this, test, "https://google.com/");
22 | // set the author of the tests here
23 | setAuthor(this, test, "Max Saperstone\n
max.saperstone@coveros.com");
24 | // set the version of the tests or of the software, possibly with a
25 | // dynamic check
26 | setVersion(this, test, "3.3.1");
27 | }
28 |
29 | @BeforeMethod(alwaysRun = true)
30 | protected void startTest(Object[] dataProvider, Method method, ITestContext test, ITestResult result) throws IOException {
31 | super.startTest(dataProvider, method, test, result, BrowserUse.FALSE);
32 | }
33 |
34 | @Test(groups = {"integration", "service", "httpget", "https"},
35 | description = "An integration test to verify the response code from a get call")
36 | public void compareGetResponseCode200Test() {
37 | // use this object to make calls
38 | Call call = this.calls.get();
39 | // perform some actions
40 | call.get("posts/4").verifyEquals().code(200);
41 | // verify 1 issue
42 | finish(1);
43 | }
44 |
45 | @Test(groups = {"integration", "service", "httppost", "https"},
46 | description = "An integration test to verify the response code from a post call")
47 | public void comparePostResponseCode201Test() {
48 | // use this object to verify the app looks as expected
49 | Call call = this.calls.get();
50 | // perform some actions
51 | call.post("posts/", new Request()).verifyEquals().code(201);
52 | // verify 1 issue
53 | finish(1);
54 | }
55 |
56 | @Test(groups = {"integration", "service", "httpput", "https"},
57 | description = "An integration test to verify the response code from a put call")
58 | public void comparePutResponseCode200Test() {
59 | // use this object to verify the app looks as expected
60 | Call call = this.calls.get();
61 | // perform some actions
62 | call.put("posts/3", new Request()).verifyEquals().code(200);
63 | // verify 1 issue
64 | finish(1);
65 | }
66 |
67 | @Test(groups = {"integration", "service", "httpdelete", "https"},
68 | description = "An integration test to verify the response code from a delete call")
69 | public void compareDeleteResponseCode200Test() {
70 | // use this object to verify the app looks as expected
71 | Call call = this.calls.get();
72 | // perform some actions
73 | call.delete("posts/5", new Request()).verifyEquals().code(200);
74 | // verify 1 issue
75 | finish(1);
76 | }
77 | }
--------------------------------------------------------------------------------
/src/test/java/integration/ServicesOverrideIT.java:
--------------------------------------------------------------------------------
1 | package integration;
2 |
3 | import com.coveros.selenified.services.Call;
4 | import com.coveros.selenified.services.HTTP.ContentType;
5 | import com.coveros.selenified.services.Request;
6 | import com.google.gson.JsonObject;
7 | import org.testng.ITestContext;
8 | import org.testng.annotations.BeforeClass;
9 | import org.testng.annotations.Test;
10 |
11 | import java.util.HashMap;
12 | import java.util.Map;
13 |
14 | public class ServicesOverrideIT extends ServicesBase {
15 |
16 | @BeforeClass(alwaysRun = true)
17 | public void setupHeaders(ITestContext test) {
18 | // for this test, we want to change the default headers for each call
19 | Map headers = new HashMap<>();
20 | headers.put("X-Atlassian-Token", "check");
21 | addHeaders(this, test, headers);
22 | setContentType(this, test, ContentType.FORMDATA);
23 | // for this particular test, we want to set some bogus credentials
24 | setCredentials(this, test, "servicesUsername", "servicesPassword");
25 | }
26 |
27 | @Test(groups = {"integration", "service", "headers"},
28 | description = "An integration test to verify we can successfully set header values")
29 | public void addHeaderTest() {
30 | // use this object to verify the app looks as expected
31 | Call call = this.calls.get();
32 | //set some custom headers
33 | Map headers = new HashMap<>();
34 | headers.put("X-Atlassian-Token", "no-check");
35 | call.addHeaders(headers);
36 | // perform some actions
37 | call.get("posts/", new Request()).verifyEquals().code(200);
38 | // verify no issues
39 | finish();
40 | }
41 |
42 | @Test(groups = {"integration", "service", "headers"},
43 | description = "An integration test to verify we can successfully set header values")
44 | public void addHeaderDataTest() {
45 | // use this object to verify the app looks as expected
46 | Call call = this.calls.get();
47 | //set some custom headers
48 | Map headers = new HashMap<>();
49 | headers.put("X-Atlassian-Token", "no-check");
50 | call.addHeaders(headers);
51 | // perform some actions - this will fail as application/xml isn't supported
52 | call.post("posts/", new Request().setJsonPayload(new JsonObject())).verifyEquals().code(201);
53 | // verify one issue
54 | finish(1);
55 | }
56 |
57 | @Test(groups = {"integration", "service", "headers"},
58 | description = "An integration test to verify we can successfully override standard header values")
59 | public void overrideAcceptTest() {
60 | // use this object to verify the app looks as expected
61 | Call call = this.calls.get();
62 | //set some custom headers
63 | Map headers = new HashMap<>();
64 | headers.put("Accept", "no-check");
65 | call.resetHeaders();
66 | call.addHeaders(headers);
67 | // perform some actions
68 | call.get("posts/").verifyEquals().code(200);
69 | // verify no issues
70 | finish();
71 | }
72 |
73 | @Test(groups = {"integration", "service", "headers"},
74 | description = "An integration test to verify we can successfully override standard header values")
75 | public void overrideCredentialsTest() {
76 | // use this object to verify the app looks as expected
77 | Call call = this.calls.get();
78 | //set some custom credentials
79 | call.addCredentials("hello", "world");
80 | // perform some actions
81 | call.get("posts/").verifyEquals().code(200);
82 | // verify no issues
83 | finish();
84 | }
85 | }
--------------------------------------------------------------------------------
/src/test/java/integration/ServicesResponseIT.java:
--------------------------------------------------------------------------------
1 | package integration;
2 |
3 | import com.coveros.selenified.services.Call;
4 | import com.coveros.selenified.services.Request;
5 | import org.testng.annotations.Test;
6 |
7 | import java.util.HashMap;
8 | import java.util.Map;
9 |
10 | import static org.testng.Assert.assertFalse;
11 | import static org.testng.Assert.assertTrue;
12 |
13 | public class ServicesResponseIT extends ServicesBase {
14 |
15 | @Test(groups = {"integration", "service", "httpget", "response"},
16 | description = "An integration test to verify json array response for data check")
17 | public void verifyJsonArrayDataCheckGetCall() {
18 | // use this object to verify the app looks as expected
19 | Call call = this.calls.get();
20 | // perform some actions
21 | assertTrue(call.get("posts/").isData());
22 | // verify no issues
23 | finish();
24 | }
25 |
26 | @Test(groups = {"integration", "service", "httpget", "response"},
27 | description = "An integration test to verify json object response for data check")
28 | public void verifyJsonObjectDataCheckGetCall() {
29 | // use this object to verify the app looks as expected
30 | Call call = this.calls.get();
31 | // perform some actions
32 | Map params = new HashMap<>();
33 | params.put("id", 4);
34 | assertTrue(call.get("posts/", new Request().setUrlParams(params)).isData());
35 | // verify no issues
36 | finish();
37 | }
38 |
39 | @Test(groups = {"integration", "service", "httpget", "response"},
40 | description = "An integration test to verify message response for data check")
41 | public void verifyMessageDataCheckGetCall() {
42 | // use this object to verify the app looks as expected
43 | Call call = this.calls.get();
44 | // perform some actions
45 | assertFalse(call.get("null/").isData());
46 | // verify no issues
47 | finish();
48 | }
49 | }
--------------------------------------------------------------------------------
/src/test/java/integration/ServicesResponseVerifyMatchesIT.java:
--------------------------------------------------------------------------------
1 | package integration;
2 |
3 | import com.coveros.selenified.services.Call;
4 | import com.coveros.selenified.services.Response;
5 | import com.google.gson.JsonArray;
6 | import org.testng.annotations.Test;
7 |
8 | import java.util.ArrayList;
9 | import java.util.List;
10 |
11 | public class ServicesResponseVerifyMatchesIT extends ServicesBase {
12 |
13 | //negative checks for verify equals
14 |
15 | @Test(groups = {"integration", "service", "httpget", "response"},
16 | description = "An integration test to verify response code negative responses")
17 | public void negativeSuccessfulGetCall() {
18 | // use this object to verify the app looks as expected
19 | Call call = this.calls.get();
20 | // perform some actions
21 | call.get("posts/").verifyMatches().code("301");
22 | // verify 1 issue
23 | finish(1);
24 | }
25 |
26 | @Test(groups = {"integration", "service", "httpget", "response"},
27 | description = "An integration test to verify response code negative responses")
28 | public void successfulGetCall() {
29 | // use this object to verify the app looks as expected
30 | Call call = this.calls.get();
31 | // perform some actions
32 | call.get("posts/").verifyMatches().code("([02]+)");
33 | // verify no issues
34 | finish();
35 | }
36 |
37 | @Test(groups = {"integration", "service", "httpget", "response"},
38 | description = "An integration test to verify json data response")
39 | public void verifyJsonCrumbsEmpty() {
40 | // use this object to verify the app looks as expected
41 | Call call = this.calls.get();
42 | // perform some actions
43 | call.get("posts/?id=4").verifyMatches().nestedValue(new ArrayList<>(), "(.*)");
44 | // verify no issues
45 | finish();
46 | }
47 |
48 | @Test(groups = {"integration", "service", "httpget", "response"},
49 | description = "An integration test to verify json data response")
50 | public void verifyJsonCrumbsSingle() {
51 | List crumbs = new ArrayList<>();
52 | crumbs.add("userId");
53 | // use this object to verify the app looks as expected
54 | Call call = this.calls.get();
55 | // perform some actions
56 | call.get("posts/?id=4").verifyMatches().nestedValue(crumbs, "[\\d]");
57 | // verify no issues
58 | finish();
59 | }
60 |
61 | @Test(groups = {"integration", "service", "httpget", "response"},
62 | description = "An integration test to verify json data response")
63 | public void verifyJsonCrumbsDouble() {
64 | List crumbs = new ArrayList<>();
65 | crumbs.add("userId");
66 | crumbs.add("user");
67 | // use this object to verify the app looks as expected
68 | Call call = this.calls.get();
69 | // perform some actions
70 | call.get("posts/?id=4").verifyMatches().nestedValue(crumbs, "[\\d]");
71 | // verify no issues
72 | finish(1);
73 | }
74 |
75 | @Test(groups = {"integration", "service", "httpget", "response"},
76 | description = "An integration test to verify json data response")
77 | public void verifyJsonCrumbsNoObject() {
78 | List crumbs = new ArrayList<>();
79 | crumbs.add("userId");
80 | // use this object to verify the app looks as expected
81 | Call call = this.calls.get();
82 | // perform some actions
83 | call.get("posts/").verifyMatches().nestedValue(crumbs, "[\\d]");
84 | // verify no issues
85 | finish(1);
86 | }
87 |
88 | @Test(groups = {"integration", "service", "httpget", "response"},
89 | description = "An integration test to verify json data response")
90 | public void verifyJsonCrumbsBadCrumb() {
91 | List crumbs = new ArrayList<>();
92 | crumbs.add("user");
93 | // use this object to verify the app looks as expected
94 | Call call = this.calls.get();
95 | // perform some actions
96 | call.get("posts/?id=4").verifyMatches().nestedValue(crumbs, "[\\d]");
97 | // verify no issues
98 | finish(1);
99 | }
100 |
101 | @Test(groups = {"integration", "service", "httpget", "response"},
102 | description = "An integration test to verify json data response")
103 | public void verifyJsonCrumbsMisMatch() {
104 | List crumbs = new ArrayList<>();
105 | crumbs.add("userId");
106 | // use this object to verify the app looks as expected
107 | Call call = this.calls.get();
108 | // perform some actions
109 | call.get("posts/?id=4").verifyMatches().nestedValue(crumbs, "hi");
110 | // verify no issues
111 | finish(1);
112 | }
113 |
114 | @Test(groups = {"integration", "service", "httpget", "response"},
115 | description = "An integration test to verify json data response")
116 | public void verifyJsonArrayMessageMismatch() {
117 | JsonArray json = new JsonArray();
118 | json.add(json1);
119 | json.add(json2);
120 | json.add(json3);
121 | // use this object to verify the app looks as expected
122 | Call call = this.calls.get();
123 | // perform some actions
124 | call.get("posts/").verifyMatches().message(json.toString());
125 | // verify 1 issue
126 | finish(1);
127 | }
128 |
129 | @Test(groups = {"integration", "service", "httpget", "response"},
130 | description = "An integration test to verify json data response")
131 | public void verifyJsonObjectMessageMismatch() {
132 | JsonArray json = new JsonArray();
133 | json.add(json4);
134 | // use this object to verify the app looks as expected
135 | Call call = this.calls.get();
136 | // perform some actions
137 | call.get("posts/?id=4").verifyMatches().message(json.toString());
138 | // verify 1 issue
139 | finish(1);
140 | }
141 |
142 | @Test(groups = {"integration", "service", "httpget", "response"},
143 | description = "An integration test to verify json data response")
144 | public void verifyJsonMessageMessageMismatch() {
145 | // use this object to verify the app looks as expected
146 | Call call = this.calls.get();
147 | // perform some actions
148 | Response response = call.get("posts/?id=4");
149 | response.verifyMatches().message("Something");
150 | // verify 1 issue
151 | finish(1);
152 | }
153 |
154 | @Test(groups = {"integration", "service", "httpget", "response"},
155 | description = "An integration test to verify json data response")
156 | public void verifyJsonMessageMessageNull() {
157 | // use this object to verify the app looks as expected
158 | Call call = this.calls.get();
159 | // perform some actions
160 | Response response = call.get("/null/");
161 | response.verifyMatches().message("Something");
162 | // verify 1 issue
163 | finish(1);
164 | }
165 | }
--------------------------------------------------------------------------------
/src/test/java/integration/WebBase.java:
--------------------------------------------------------------------------------
1 | package integration;
2 |
3 | import com.coveros.selenified.Selenified;
4 | import org.mockserver.integration.ClientAndServer;
5 | import org.testng.ITestContext;
6 | import org.testng.annotations.AfterSuite;
7 | import org.testng.annotations.BeforeClass;
8 | import org.testng.annotations.BeforeSuite;
9 |
10 | import java.io.IOException;
11 | import java.nio.file.Files;
12 | import java.nio.file.Paths;
13 |
14 | import static org.mockserver.integration.ClientAndServer.startClientAndServer;
15 | import static org.mockserver.model.HttpRequest.request;
16 | import static org.mockserver.model.HttpResponse.response;
17 |
18 | public class WebBase extends Selenified {
19 | private ClientAndServer mockServer;
20 | private int mockPort = 1070;
21 |
22 |
23 | @BeforeClass(alwaysRun = true)
24 | public void beforeClass(ITestContext test) {
25 | // set the base URL for the tests here
26 | setAppURL(this, test, "http://localhost:" + mockPort + "/");
27 | // set the author of the tests here
28 | setAuthor(this, test, "Max Saperstone\n
max.saperstone@coveros.com");
29 | // set the version of the tests or of the software, possibly with a dynamic check
30 | setVersion(this, test, "3.3.1");
31 |
32 | // when running on sauce labs, timezones can mess with the cookie expiration date, so setting it here to EST
33 | addAdditionalDesiredCapabilities(this, test, "timeZone", "New_York");
34 | }
35 |
36 | private static String readFile(String path) throws IOException {
37 | byte[] encoded = Files.readAllBytes(Paths.get(path));
38 | return new String(encoded);
39 | }
40 |
41 | @BeforeSuite(alwaysRun = true)
42 | public void startMockServer() throws IOException {
43 | if( System.getProperty("mockPort") != null) {
44 | mockPort += Integer.valueOf(System.getProperty("mockPort"));
45 | }
46 | System.setProperty("mockserver.logLevel", "OFF");
47 | mockServer = startClientAndServer(mockPort);
48 | mockServer.when(request().withMethod("GET").withPath("/"))
49 | .respond(response().withBody(readFile("public/index.html")));
50 | mockServer.when(request().withMethod("GET").withPath("/next_page.html"))
51 | .respond(response().withBody(readFile("public/next_page.html")));
52 | }
53 |
54 | @AfterSuite(alwaysRun = true)
55 | public void stopMockServer() {
56 | mockServer.stop();
57 | }
58 | }
59 |
--------------------------------------------------------------------------------
/src/test/java/integration/hub/LambdaTestIT.java:
--------------------------------------------------------------------------------
1 | package integration.hub;
2 |
3 | import com.coveros.selenified.Selenified;
4 | import com.coveros.selenified.application.App;
5 | import com.coveros.selenified.services.Call;
6 | import com.coveros.selenified.services.Response;
7 | import com.coveros.selenified.utilities.Hub;
8 | import org.openqa.selenium.remote.RemoteWebDriver;
9 | import org.openqa.selenium.remote.SessionId;
10 | import org.testng.ITestContext;
11 | import org.testng.annotations.BeforeClass;
12 | import org.testng.annotations.DataProvider;
13 | import org.testng.annotations.Test;
14 |
15 | import java.io.IOException;
16 | import java.util.ArrayList;
17 | import java.util.List;
18 |
19 | public class LambdaTestIT extends Selenified {
20 |
21 | private ITestContext test;
22 |
23 | @BeforeClass(alwaysRun = true)
24 | public void beforeClass(ITestContext test) {
25 | // set the base URL for the tests here
26 | setAppURL(this, test, "https://api.lambdatest.com/automation/api/v1/");
27 | // set the author of the tests here
28 | setAuthor(this, test, "Max Saperstone\n
max.saperstone@coveros.com");
29 | // set the version of the tests or of the software, possibly with a dynamic check
30 | setVersion(this, test, "3.3.1");
31 |
32 | this.test = test;
33 | }
34 |
35 | @Test(groups = {"integration", "hub", "lambda"}, description = "An integration test to check that lambda gets all expected information")
36 | public void hubTitleTest() {
37 | // use this object to manipulate the app
38 | App app = this.apps.get();
39 | // verify the correct page title
40 | app.azzert().urlEquals("https://api.lambdatest.com/automation/api/v1/");
41 | // capture the session_id
42 | test.setAttribute("HUB_SESSION_ID", ((RemoteWebDriver) app.getDriver()).getSessionId());
43 | test.setAttribute("HUB_BUILD", app.getDesiredCapabilities().getCapability("build"));
44 | // verify no issues
45 | finish();
46 | }
47 |
48 | @DataProvider(name = "search terms", parallel = true)
49 | public Object[][] DataSetOptions2() {
50 | return new Object[][]{new Object[]{"hi"}};
51 | }
52 |
53 | @Test(dataProvider = "search terms", groups = {"integration", "hub", "lambda"},
54 | description = "An integration test to check that lambda gets all expected information")
55 | public void hubSearchTest(String message) {
56 | // use this object to manipulate the app
57 | App app = this.apps.get();
58 | // find the search box element and create the object
59 | app.azzert().textPresent(message);
60 | // capture the session_id
61 | test.setAttribute("PARAM_SESSION_ID", ((RemoteWebDriver) app.getDriver()).getSessionId());
62 | // verify no issues
63 | finish();
64 | }
65 |
66 | @Test(groups = {"integration", "hub", "lambda", "lambdaAPI"}, dependsOnMethods = {"hubTitleTest"},
67 | description = "An integration test to check that lambda get all expected information")
68 | public void lambdaPassedTest(ITestContext iTestContext) throws IOException {
69 | SessionId sessionId = (SessionId) iTestContext.getAttribute("HUB_SESSION_ID");
70 | Hub hub = new Hub();
71 | Call call = this.calls.get();
72 | call.addCredentials(hub.getUsername(), hub.getPassword());
73 | Response response = call.get("sessions/" + sessionId.toString());
74 | List jsonDataSets = new ArrayList<>();
75 | jsonDataSets.add("data");
76 | jsonDataSets.add("status_ind");
77 | response.assertEquals().nestedValue(jsonDataSets, "passed");
78 | finish();
79 | }
80 |
81 | @Test(groups = {"integration", "hub", "lambda", "lambdaAPI"}, dependsOnMethods = {"hubTitleTest"},
82 | description = "An integration test to check that lambda get all expected information")
83 | public void lambdaBuildTest(ITestContext iTestContext) throws IOException {
84 | SessionId sessionId = (SessionId) iTestContext.getAttribute("HUB_SESSION_ID");
85 | String buildName = iTestContext.getAttribute("HUB_BUILD").toString();
86 | Hub hub = new Hub();
87 | Call call = this.calls.get();
88 | call.addCredentials(hub.getUsername(), hub.getPassword());
89 | Response response = call.get("sessions/" + sessionId.toString());
90 | List jsonDataSets = new ArrayList<>();
91 | jsonDataSets.add("data");
92 | jsonDataSets.add("build_name");
93 | response.assertEquals().nestedValue(jsonDataSets, buildName);
94 | finish();
95 | }
96 |
97 | @Test(groups = {"integration", "hub", "lambda", "lambdaAPI"}, dependsOnMethods = {"hubTitleTest"},
98 | description = "An integration test to check that lambda get all expected information")
99 | public void lambdaNameTest(ITestContext iTestContext) throws IOException {
100 | SessionId sessionId = (SessionId) iTestContext.getAttribute("HUB_SESSION_ID");
101 | Hub hub = new Hub();
102 | Call call = this.calls.get();
103 | call.addCredentials(hub.getUsername(), hub.getPassword());
104 | Response response = call.get("sessions/" + sessionId.toString());
105 | List jsonDataSets = new ArrayList<>();
106 | jsonDataSets.add("data");
107 | jsonDataSets.add("name");
108 | response.assertEquals().nestedValue(jsonDataSets, "integration.hub.LambdaTestIT.hubTitleTest");
109 | finish();
110 | }
111 |
112 | @Test(groups = {"integration", "hub", "lambda", "lambdaAPI"}, dependsOnMethods = {"hubSearchTest"},
113 | description = "An integration test to check that lambda get all expected information")
114 | public void lambdaComplexNameTest(ITestContext iTestContext) throws IOException {
115 | SessionId paramSessionId = (SessionId) iTestContext.getAttribute("PARAM_SESSION_ID");
116 | Hub hub = new Hub();
117 | Call call = this.calls.get();
118 | call.addCredentials(hub.getUsername(), hub.getPassword());
119 | Response response = call.get("sessions/" + paramSessionId.toString());
120 | List jsonDataSets = new ArrayList<>();
121 | jsonDataSets.add("data");
122 | jsonDataSets.add("name");
123 | response.assertEquals().nestedValue(jsonDataSets, "integration.hub.LambdaTestIT.hubSearchTestWithOptionHi");
124 | finish();
125 | }
126 | }
127 |
--------------------------------------------------------------------------------
/src/test/java/sample/MainPage.java:
--------------------------------------------------------------------------------
1 | package sample;
2 |
3 | import com.coveros.selenified.Locator;
4 | import com.coveros.selenified.application.App;
5 | import com.coveros.selenified.element.Element;
6 |
7 | final class MainPage {
8 |
9 | // our page elements
10 | private final Element click;
11 | private final Element alert;
12 | private final Element carList;
13 | public final Element checkbox;
14 |
15 | public MainPage(App app) {
16 | click = app.newElement(Locator.CLASSNAME, "click");
17 | alert = app.newElement(Locator.CSS, "input#alert_button");
18 | carList = app.newElement(Locator.ID, "car_list");
19 | checkbox = app.newElement(Locator.XPATH, "//form/input[@type='checkbox']");
20 | }
21 |
22 | public void selectCar(String car) {
23 | carList.selectOption(car);
24 | }
25 |
26 | public void assertCar(String car) {
27 | carList.assertEquals().selectedOption(car);
28 | }
29 |
30 | public void generateAlert() {
31 | click.click();
32 | alert.click();
33 | }
34 | }
--------------------------------------------------------------------------------
/src/test/java/sample/POMSampleIT.java:
--------------------------------------------------------------------------------
1 | package sample;
2 |
3 | import com.coveros.selenified.application.App;
4 | import integration.WebBase;
5 | import org.testng.annotations.BeforeMethod;
6 | import org.testng.annotations.DataProvider;
7 | import org.testng.annotations.Test;
8 |
9 | public class POMSampleIT extends WebBase {
10 |
11 | @DataProvider(name = "car list items", parallel = true)
12 | public Object[][] DataSetOptions() {
13 | return new Object[][]{new Object[]{"Volvo"}, new Object[]{"Saab"}, new Object[]{"Mercedes"}};
14 | }
15 |
16 | private final ThreadLocal main = new ThreadLocal<>();
17 |
18 | @BeforeMethod(alwaysRun = true)
19 | public void setupApp() {
20 | main.set(new MainPage(this.apps.get()));
21 | }
22 |
23 | @Test(dataProvider = "car list items", groups = {"sample", "pom"},
24 | description = "A sample test using a data provider to perform searches")
25 | public void sampleTestWDataProvider(String listItem) {
26 | // our test actions - use our threadsafe main object
27 | main.get().selectCar(listItem);
28 | main.get().assertCar(listItem);
29 | // close out the test
30 | finish();
31 | }
32 |
33 | // skipping safari as it doesn't support modal dialogs: https://github.com/SeleniumHQ/selenium-google-code-issue-archive/issues/3862
34 | @Test(groups = {"sample", "pom", "alert", "no-safari"}, description = "A sample test using a data provider to perform searches")
35 | public void sampleTest() {
36 | // grab our main app object
37 | App app = this.apps.get();
38 | // grab our main threadsafe object for future use
39 | MainPage main = this.main.get();
40 | // our test actions
41 | main.generateAlert();
42 | app.azzert().alertPresent();
43 | app.acceptAlert();
44 | app.azzert().alertNotPresent();
45 | }
46 |
47 | @Test(groups = {"sample", "pom"}, description = "A sample test using a data provider to perform searches")
48 | public void sampleTestWMatches() {
49 | // define a new main object
50 | MainPage main = new MainPage(this.apps.get());
51 | // perform some actions
52 | for (int match = 0; match < main.checkbox.get().matchCount(); match++) {
53 | main.checkbox.setMatch(match);
54 | main.checkbox.click();
55 | main.checkbox.assertState().checked();
56 | }
57 | // close out the test
58 | finish();
59 | }
60 | }
--------------------------------------------------------------------------------
/src/test/java/sample/ReadmeSampleIT.java:
--------------------------------------------------------------------------------
1 | package sample;
2 |
3 | import com.coveros.selenified.Locator;
4 | import com.coveros.selenified.Selenified;
5 | import com.coveros.selenified.application.App;
6 | import com.coveros.selenified.element.Element;
7 | import com.coveros.selenified.services.Call;
8 | import com.coveros.selenified.services.Request;
9 | import org.testng.ITestContext;
10 | import org.testng.annotations.BeforeClass;
11 | import org.testng.annotations.DataProvider;
12 | import org.testng.annotations.Test;
13 |
14 | import java.util.HashMap;
15 |
16 | public class ReadmeSampleIT extends Selenified {
17 |
18 | @BeforeClass(alwaysRun = true)
19 | public void beforeClass(ITestContext test) {
20 | // set the base URL for the tests here
21 | setAppURL(this, test, "https://www.coveros.com/");
22 | }
23 |
24 | @DataProvider(name = "coveros search terms", parallel = true)
25 | public Object[][] DataSetOptions() {
26 | return new Object[][]{new Object[]{"python"},
27 | new Object[]{"perl"}, new Object[]{"bash"},};
28 | }
29 |
30 | @Test(groups = {"sample", "coveros"}, description = "A sample selenium test to check a title")
31 | public void sampleTest() {
32 | // use this object to manipulate the app
33 | App app = this.apps.get();
34 | // verify the correct page title
35 | app.azzert().titleEquals("Coveros | Bringing together agile and security to deliver superior software");
36 | // verify no issues
37 | finish();
38 | }
39 |
40 | @Test(dataProvider = "coveros search terms", groups = {"sample", "coveros"},
41 | description = "A sample selenium test using a data provider to perform a search")
42 | public void sampleTestWDataProvider(String searchTerm) {
43 | // use this object to manipulate the app
44 | App app = this.apps.get();
45 | // find the search box element and create the object
46 | Element searchBox = app.newElement(Locator.NAME, "s");
47 | //perform the search and submit
48 | searchBox.type(searchTerm);
49 | searchBox.submit();
50 | //wait for the page to return the results
51 | app.newElement(Locator.ID, "recent-posts-4").waitForState().present();
52 | // verify the correct page title
53 | app.azzert().titleEquals("You searched for " + searchTerm + " - Coveros");
54 | // verify no issues
55 | finish();
56 | }
57 |
58 | @Test(groups = {"sample", "service", "coveros", "https"}, description = "A sample web services test to verify the response code")
59 | public void sampleServicesSearchTest() {
60 | HashMap params = new HashMap<>();
61 | params.put("s", "Max+Saperstone");
62 | // use this object to verify the app looks as expected
63 | Call call = this.calls.get();
64 | // retrieve the zip code and verify the return code
65 | call.get("", new Request().setUrlParams(params)).assertEquals().code(403);
66 | // verify no issues
67 | finish();
68 | }
69 | }
--------------------------------------------------------------------------------
/src/test/java/sample/SimpleSampleIT.java:
--------------------------------------------------------------------------------
1 | package sample;
2 |
3 | import com.coveros.selenified.Locator;
4 | import com.coveros.selenified.application.App;
5 | import com.coveros.selenified.element.Element;
6 | import integration.WebBase;
7 | import org.testng.annotations.DataProvider;
8 | import org.testng.annotations.Test;
9 |
10 | public class SimpleSampleIT extends WebBase {
11 |
12 | @DataProvider(name = "car list items", parallel = true)
13 | public Object[][] DataSetOptions() {
14 | return new Object[][]{new Object[]{"Volvo"}, new Object[]{"Saab"}, new Object[]{"Mercedes"}};
15 | }
16 |
17 | @Test(groups = {"sample"}, description = "A sample test to check a title")
18 | public void sampleTest() {
19 | // use this object to manipulate the app
20 | App app = this.apps.get();
21 | // perform the verification
22 | app.azzert().titleEquals("Selenified Test Page");
23 | }
24 |
25 | @Test(dataProvider = "car list items", groups = {"sample"},
26 | description = "A sample test using a data provider to perform searches")
27 | public void sampleTestWDataProvider(String listItem) {
28 | // use this object to manipulate the app
29 | App app = this.apps.get();
30 | // perform some actions
31 | app.newElement(Locator.ID, "car_list").selectOption(listItem);
32 | // close out the test
33 | finish();
34 | }
35 |
36 | @Test(groups = {"sample"}, description = "A sample test to show how to loop through elements with multiple matches")
37 | public void sampleTestLoopThroughElements() {
38 | // use this object to manipulate the app
39 | App app = this.apps.get();
40 | // perform some actions
41 | Element element = app.newElement(Locator.XPATH, "//form/input[@type='checkbox']");
42 | for (int match = 0; match < element.get().matchCount(); match++) {
43 | element.setMatch(match);
44 | element.click();
45 | element.assertState().checked();
46 | }
47 | // close out the test
48 | finish();
49 | }
50 | }
51 |
--------------------------------------------------------------------------------
/src/test/java/unit/AppTest.java:
--------------------------------------------------------------------------------
1 | package unit;
2 |
3 | import com.coveros.selenified.Browser;
4 | import com.coveros.selenified.Capabilities;
5 | import com.coveros.selenified.application.App;
6 | import com.coveros.selenified.exceptions.InvalidBrowserException;
7 | import com.coveros.selenified.exceptions.InvalidHubException;
8 | import com.coveros.selenified.exceptions.InvalidProxyException;
9 | import org.openqa.selenium.WebDriverException;
10 | import org.testng.annotations.Test;
11 |
12 | import java.net.MalformedURLException;
13 |
14 | import static com.coveros.selenified.utilities.Property.HUB;
15 | import static org.testng.Assert.fail;
16 |
17 | public class AppTest extends SaveProperties {
18 |
19 | @Test(expectedExceptions = WebDriverException.class)
20 | public void checkElementTypeTest() throws InvalidBrowserException, MalformedURLException, InvalidProxyException, InvalidHubException {
21 | System.setProperty(HUB, "http://myurl");
22 | new App(new Capabilities(new Browser("htmlunIT")), null);
23 | }
24 |
25 | @Test(expectedExceptions = MalformedURLException.class)
26 | public void checkElementTypeBadURLTest() throws InvalidBrowserException, MalformedURLException, InvalidProxyException, InvalidHubException {
27 | System.setProperty(HUB, "myurl");
28 | new App(new Capabilities(new Browser("htmlunit")), null);
29 | }
30 |
31 | @Test(expectedExceptions = InvalidBrowserException.class)
32 | public void nullCapabilitiesTest() throws InvalidBrowserException, MalformedURLException, InvalidProxyException, InvalidHubException {
33 | new App(null, null);
34 | fail("Expected an InvalidBrowserException");
35 | }
36 | }
--------------------------------------------------------------------------------
/src/test/java/unit/CallTest.java:
--------------------------------------------------------------------------------
1 | package unit;
2 |
3 | import com.coveros.selenified.exceptions.InvalidBrowserException;
4 | import com.coveros.selenified.exceptions.InvalidHTTPException;
5 | import com.coveros.selenified.exceptions.InvalidProxyException;
6 | import com.coveros.selenified.exceptions.InvalidReporterException;
7 | import com.coveros.selenified.services.Call;
8 | import com.coveros.selenified.services.HTTP;
9 | import com.coveros.selenified.utilities.Reporter;
10 | import org.testng.annotations.AfterMethod;
11 | import org.testng.annotations.Test;
12 |
13 | import java.io.File;
14 | import java.util.HashMap;
15 |
16 | public class CallTest {
17 |
18 | private Reporter reporter = new Reporter(null, null, null, null, null, null, null, null, null);
19 | private HTTP http = new HTTP(reporter, "SomeURL");
20 |
21 | public CallTest() throws InvalidBrowserException, InvalidProxyException {
22 | }
23 |
24 | @AfterMethod
25 | public void cleanup() {
26 | new File("null.html").delete();
27 | }
28 |
29 | @Test(expectedExceptions = InvalidHTTPException.class)
30 | public void constructorNullTest() throws InvalidHTTPException, InvalidReporterException {
31 | // just verify no errors are thrown
32 | new Call(null, null);
33 | }
34 |
35 | @Test
36 | public void constructorHttpTest() throws InvalidHTTPException, InvalidReporterException {
37 | // just verify no errors are thrown
38 | new Call(http, null);
39 | }
40 |
41 | @Test(expectedExceptions = InvalidReporterException.class)
42 | public void constructorNullReporterTest() throws InvalidHTTPException, InvalidReporterException {
43 | // just verify no errors are thrown
44 | new Call(new HTTP(null, "SomeURL"), null);
45 | }
46 |
47 | @Test
48 | public void constructorTest() throws InvalidHTTPException, InvalidReporterException {
49 | new Call(http, new HashMap<>());
50 | }
51 | }
52 |
--------------------------------------------------------------------------------
/src/test/java/unit/ExceptionTest.java:
--------------------------------------------------------------------------------
1 | package unit;
2 |
3 | import com.coveros.selenified.Browser;
4 | import com.coveros.selenified.Capabilities;
5 | import com.coveros.selenified.exceptions.InvalidBrowserException;
6 | import com.coveros.selenified.exceptions.InvalidHubException;
7 | import com.coveros.selenified.exceptions.InvalidProxyException;
8 | import org.testng.annotations.Test;
9 |
10 | import static org.testng.Assert.fail;
11 |
12 | public class ExceptionTest {
13 |
14 | @Test(expectedExceptions = InvalidBrowserException.class)
15 | public void invalidBrowserExceptionTest() throws InvalidBrowserException, InvalidProxyException, InvalidHubException {
16 | new Capabilities(new Browser("Android"));
17 | fail("Expected an InvalidBrowserException");
18 | }
19 | }
20 |
--------------------------------------------------------------------------------
/src/test/java/unit/HTTPTest.java:
--------------------------------------------------------------------------------
1 | package unit;
2 |
3 | import com.coveros.selenified.services.HTTP;
4 | import com.coveros.selenified.services.Request;
5 | import org.testng.annotations.Test;
6 |
7 | import java.util.HashMap;
8 | import java.util.Map;
9 |
10 | import static org.testng.Assert.*;
11 |
12 | public class HTTPTest {
13 |
14 | @Test
15 | public void useCredentialsEmptyTest() {
16 | HTTP http = new HTTP(null, "Service");
17 | assertFalse(http.useCredentials());
18 | }
19 |
20 | @Test
21 | public void useCredentialsBothTest() {
22 | HTTP http = new HTTP(null, "Service", "User", "Pass");
23 | assertTrue(http.useCredentials());
24 | }
25 |
26 | @Test
27 | public void useCredentialsNeitherTest() {
28 | HTTP http = new HTTP(null, "Service", "", "");
29 | assertFalse(http.useCredentials());
30 | }
31 |
32 | @Test
33 | public void useCredentialsUserTest() {
34 | HTTP http = new HTTP(null, "Service", "User", "");
35 | assertFalse(http.useCredentials());
36 | }
37 |
38 | @Test
39 | public void useCredentialsPassTest() {
40 | HTTP http = new HTTP(null, "Service", "", "Pass");
41 | assertFalse(http.useCredentials());
42 | }
43 |
44 | @Test
45 | public void buildStringNullParamTest() {
46 | HTTP http = new HTTP(null, "Service");
47 | assertEquals(http.getRequestParams(null), "");
48 | }
49 |
50 | @Test
51 | public void buildStringEmptyParamTest() {
52 | HTTP http = new HTTP(null, "Service");
53 | assertEquals(http.getRequestParams(new Request()), "");
54 | }
55 |
56 | @Test
57 | public void buildStringNoParamTest() {
58 | HTTP http = new HTTP(null, "Service");
59 | assertEquals(http.getRequestParams(new Request().setUrlParams(new HashMap<>())), "");
60 | }
61 |
62 | @Test
63 | public void buildStringSingleParamTest() {
64 | HTTP http = new HTTP(null, "Service");
65 | Map params = new HashMap<>();
66 | params.put("hello", "world");
67 | assertEquals(http.getRequestParams(new Request().setUrlParams(params)), "?hello=world");
68 | }
69 |
70 | @Test
71 | public void buildStringMultipleParamsTest() {
72 | HTTP http = new HTTP(null, "Service");
73 | Map params = new HashMap<>();
74 | params.put("hello", "world");
75 | params.put("john", 5);
76 | assertEquals(http.getRequestParams(new Request().setUrlParams(params)), "?john=5&hello=world");
77 | }
78 |
79 | @Test
80 | public void checkAddingCredentialsTest() {
81 | HTTP http = new HTTP(null, "Service");
82 | http.addCredentials("User", "Pass");
83 | assertTrue(http.useCredentials());
84 | }
85 |
86 | @Test
87 | public void checkAddingUserCredentialsTest() {
88 | HTTP http = new HTTP(null, "Service");
89 | http.addCredentials("User", "");
90 | assertFalse(http.useCredentials());
91 | }
92 |
93 | @Test
94 | public void checkAddingPassCredentialsTest() {
95 | HTTP http = new HTTP(null, "Service");
96 | http.addCredentials("", "Pass");
97 | assertFalse(http.useCredentials());
98 | }
99 |
100 | @Test
101 | public void checkAddingNoCredentialsTest() {
102 | HTTP http = new HTTP(null, "Service");
103 | http.addCredentials("", "");
104 | assertFalse(http.useCredentials());
105 | }
106 |
107 | @Test
108 | public void checkAddingBaseUrl() {
109 | HTTP http = new HTTP(null, "Service");
110 | assertEquals(http.getServiceBaseUrl(), "Service");
111 | }
112 |
113 | @Test
114 | public void checkAddingNullBaseUrl() {
115 | HTTP http = new HTTP(null, null);
116 | assertNull(http.getServiceBaseUrl());
117 | }
118 |
119 | @Test
120 | public void checkAddingEmptyBaseUrl() {
121 | HTTP http = new HTTP(null, "");
122 | assertEquals(http.getServiceBaseUrl(), "");
123 | }
124 |
125 | @Test
126 | public void getHeadersDefaultTest() {
127 | HTTP http = new HTTP(null, "");
128 | Map map = new HashMap<>();
129 | map.put("Accept", "application/json");
130 | map.put("Content-length", "0");
131 | map.put("Content-Type", "application/json; charset=UTF-8");
132 | assertEquals(http.getHeaders(), map);
133 | }
134 |
135 | @Test
136 | public void getHeadersExtraTest() {
137 | HTTP http = new HTTP(null, "");
138 | Map map = new HashMap<>();
139 | map.put("Accept", "application/json");
140 | map.put("Content-length", "0");
141 | map.put("Content-Type", "application/json; charset=UTF-8");
142 | map.put("Age", 1234);
143 | Map headers = new HashMap<>();
144 | headers.put("Age", 1234);
145 | http.addHeaders(headers);
146 | assertEquals(http.getHeaders(), map);
147 | }
148 |
149 | @Test
150 | public void getHeadersOverrideTest() {
151 | HTTP http = new HTTP(null, "");
152 | Map map = new HashMap<>();
153 | map.put("Accept", "application/xml");
154 | map.put("Content-length", "0");
155 | map.put("Content-Type", "application/json; charset=UTF-8");
156 | Map headers = new HashMap<>();
157 | headers.put("Accept", "application/xml");
158 | http.addHeaders(headers);
159 | assertEquals(http.getHeaders(), map);
160 | }
161 |
162 | @Test
163 | public void addHeadersDefaultTest() {
164 | HTTP http = new HTTP(null, "");
165 | Map map = new HashMap<>();
166 | map.put("Accept", "application/json");
167 | map.put("Content-length", "0");
168 | map.put("Content-Type", "application/json; charset=UTF-8");
169 | http.addHeaders(new HashMap<>());
170 | assertEquals(http.getHeaders(), map);
171 | }
172 |
173 | @Test
174 | public void addHeadersResetTest() {
175 | HTTP http = new HTTP(null, "");
176 | Map map = new HashMap<>();
177 | map.put("Accept", "application/json");
178 | map.put("Content-length", "0");
179 | map.put("Content-Type", "application/json; charset=UTF-8");
180 | Map headers = new HashMap<>();
181 | headers.put("Accept", "application/xml");
182 | http.addHeaders(headers);
183 | http.resetHeaders();
184 | assertEquals(http.getHeaders(), map);
185 | }
186 | }
--------------------------------------------------------------------------------
/src/test/java/unit/HubTest.java:
--------------------------------------------------------------------------------
1 | package unit;
2 |
3 | import com.coveros.selenified.exceptions.InvalidHubException;
4 | import com.coveros.selenified.utilities.Hub;
5 | import org.testng.annotations.Test;
6 |
7 | import java.io.IOException;
8 | import java.net.MalformedURLException;
9 | import java.net.URL;
10 |
11 | import static com.coveros.selenified.utilities.Property.HUB;
12 | import static org.testng.Assert.*;
13 | import static org.testng.AssertJUnit.assertNull;
14 |
15 | public class HubTest extends SaveProperties {
16 |
17 | @Test
18 | public void defaultIsHubTest() {
19 | assertFalse(Hub.isHubSet());
20 | }
21 |
22 | @Test
23 | public void defaultIsHubSystemEmptyTest() {
24 | System.setProperty(HUB, "");
25 | assertFalse(Hub.isHubSet());
26 | }
27 |
28 | @Test
29 | public void defaultIsHubSystemTest() {
30 | System.setProperty(HUB, "somehub");
31 | assertTrue(Hub.isHubSet());
32 | }
33 |
34 | @Test
35 | public void defaultIsHubFileEmptyTest() throws IOException {
36 | createPropertiesFile("");
37 | assertFalse(Hub.isHubSet());
38 | }
39 |
40 | @Test
41 | public void defaultIsHubFilePartialTest() throws IOException {
42 | createPropertiesFile(HUB);
43 | assertFalse(Hub.isHubSet());
44 | }
45 |
46 | @Test
47 | public void defaultIsHubFileUnsetTest() throws IOException {
48 | createPropertiesFile(HUB + "=");
49 | assertFalse(Hub.isHubSet());
50 | }
51 |
52 | @Test
53 | public void defaultIsHubFileTrueTest() throws IOException {
54 | createPropertiesFile(HUB + "=somehub");
55 | assertTrue(Hub.isHubSet());
56 | }
57 |
58 | @Test
59 | public void defaultIsHubOverrideEmptyTest() throws IOException {
60 | System.setProperty(HUB, "");
61 | createPropertiesFile(HUB + "=somehub");
62 | assertFalse(Hub.isHubSet());
63 | }
64 |
65 | @Test
66 | public void defaultIsHubOverrideTrueTest() throws IOException {
67 | System.setProperty(HUB, "somehub");
68 | createPropertiesFile(HUB + "=");
69 | assertTrue(Hub.isHubSet());
70 | }
71 |
72 | @Test(expectedExceptions = InvalidHubException.class)
73 | public void defaultGetHubTest() throws MalformedURLException {
74 | new Hub().getHubURL();
75 | }
76 |
77 | @Test(expectedExceptions = InvalidHubException.class)
78 | public void defaultGetHubSystemEmptyTest() throws MalformedURLException {
79 | System.setProperty(HUB, "");
80 | new Hub().getHubURL();
81 | }
82 |
83 | @Test(expectedExceptions = InvalidHubException.class)
84 | public void defaultGetHubSystemBadTest() throws MalformedURLException {
85 | System.setProperty(HUB, "somehub");
86 | new Hub().getHubURL();
87 | }
88 |
89 | @Test
90 | public void defaultGetHubSystemTest() throws MalformedURLException {
91 | System.setProperty(HUB, "https://somehub");
92 | assertEquals(new Hub().getHubURL(), new URL("https://somehub/wd/hub"));
93 | }
94 |
95 | @Test(expectedExceptions = InvalidHubException.class)
96 | public void defaultGetHubFileEmptyTest() throws IOException {
97 | createPropertiesFile("");
98 | new Hub().getHubURL();
99 | }
100 |
101 | @Test(expectedExceptions = InvalidHubException.class)
102 | public void defaultGetHubFilePartialTest() throws IOException {
103 | createPropertiesFile(HUB);
104 | new Hub().getHubURL();
105 | }
106 |
107 | @Test(expectedExceptions = InvalidHubException.class)
108 | public void defaultGetHubFileUnsetTest() throws IOException {
109 | createPropertiesFile(HUB + "=");
110 | new Hub().getHubURL();
111 | }
112 |
113 | @Test(expectedExceptions = InvalidHubException.class)
114 | public void defaultGetHubFileBadTest() throws IOException {
115 | createPropertiesFile(HUB + "=somehub");
116 | new Hub().getHubURL();
117 | }
118 |
119 |
120 | @Test
121 | public void defaultGetHubFileTrueTest() throws IOException {
122 | createPropertiesFile(HUB + "=https://somehub");
123 | assertEquals(new Hub().getHubURL(), new URL("https://somehub/wd/hub"));
124 | }
125 |
126 | @Test(expectedExceptions = InvalidHubException.class)
127 | public void defaultGetHubOverrideEmptyTest() throws IOException {
128 | System.setProperty(HUB, "");
129 | createPropertiesFile(HUB + "=somehub");
130 | new Hub().getHubURL();
131 | }
132 |
133 | @Test(expectedExceptions = InvalidHubException.class)
134 | public void defaultGetHubOverrideBadTest() throws IOException {
135 | System.setProperty(HUB, "somehub");
136 | createPropertiesFile(HUB + "=");
137 | new Hub().getHubURL();
138 | }
139 |
140 | @Test
141 | public void defaultGetHubOverrideTrueTest() throws IOException {
142 | System.setProperty(HUB, "http://somehub");
143 | createPropertiesFile(HUB + "=");
144 | assertEquals(new Hub().getHubURL(), new URL("http://somehub/wd/hub"));
145 | }
146 |
147 | @Test(expectedExceptions = InvalidHubException.class)
148 | public void getUserNoHubTest() throws MalformedURLException {
149 | new Hub().getUsername();
150 | }
151 |
152 | @Test
153 | public void getUserNoUserTest() throws MalformedURLException {
154 | System.setProperty(HUB, "https://ondemand.saucelabs.com:443");
155 | assertEquals(new Hub().getHubURL(), new URL("https://ondemand.saucelabs.com:443/wd/hub"));
156 | assertNull(new Hub().getUsername());
157 | assertNull(new Hub().getPassword());
158 | }
159 |
160 | @Test(expectedExceptions = InvalidHubException.class)
161 | public void getUserOnlyUserTest() throws MalformedURLException {
162 | System.setProperty(HUB, "https://sauceusername@ondemand.saucelabs.com:443");
163 | new Hub().getUsername();
164 | }
165 |
166 | @Test(expectedExceptions = InvalidHubException.class)
167 | public void getKeyNoHubTest() throws MalformedURLException {
168 | new Hub().getPassword();
169 | }
170 |
171 | @Test
172 | public void getKeyNoKeyTest() throws MalformedURLException {
173 | System.setProperty(HUB, "https://ondemand.saucelabs.com:443");
174 | assertNull(new Hub().getPassword(), null);
175 | }
176 |
177 | @Test(expectedExceptions = InvalidHubException.class)
178 | public void getKeyOnlyKeyTest() throws MalformedURLException {
179 | System.setProperty(HUB, "https://sauceaccesskey@ondemand.saucelabs.com:443");
180 | new Hub().getPassword();
181 | }
182 |
183 | @Test
184 | public void getCredsUrlSauceTest() throws MalformedURLException {
185 | System.setProperty(HUB, "https://sauceusername:sauceaccesskey@ondemand.saucelabs.com:443");
186 | assertEquals(new Hub().getUsername(), "sauceusername");
187 | assertEquals(new Hub().getPassword(), "sauceaccesskey");
188 | }
189 | }
190 |
--------------------------------------------------------------------------------
/src/test/java/unit/RequestTest.java:
--------------------------------------------------------------------------------
1 | package unit;
2 |
3 | import com.coveros.selenified.services.Request;
4 | import com.google.gson.JsonArray;
5 | import com.google.gson.JsonObject;
6 | import org.testng.annotations.Test;
7 |
8 | import java.util.HashMap;
9 | import java.util.Map;
10 |
11 | import static org.testng.Assert.*;
12 |
13 | public class RequestTest {
14 |
15 | @Test
16 | public void checkJsonDataRequestTest() {
17 | JsonObject json = new JsonObject();
18 | assertEquals(new Request().setJsonPayload(json).getJsonPayload(), json);
19 | }
20 |
21 | @Test
22 | public void checkJsonDataMultipartRequestTest() {
23 | JsonObject json = new JsonObject();
24 | assertEquals(new Request().setJsonPayload(json).getMultipartData(), null);
25 | }
26 |
27 | @Test
28 | public void checkJsonDataParamsRequestTest() {
29 | JsonObject json = new JsonObject();
30 | assertEquals(new Request().setJsonPayload(json).getUrlParams(), null);
31 | }
32 |
33 | @Test
34 | public void checkJsonDataDataRequestTest() {
35 | JsonObject json = new JsonObject();
36 | json.addProperty("name", "john");
37 | assertEquals(new Request().setJsonPayload(json).getJsonPayload(), json);
38 | }
39 |
40 | @Test
41 | public void checkJsonArrayRequestTest() {
42 | JsonArray json = new JsonArray();
43 | assertEquals(new Request().setJsonPayload(json).getJsonPayload(), json);
44 | }
45 |
46 | @Test
47 | public void checkJsonArrayMultipartRequestTest() {
48 | JsonArray json = new JsonArray();
49 | assertEquals(new Request().setJsonPayload(json).getMultipartData(), null);
50 | }
51 |
52 | @Test
53 | public void checkJsonArrayParamsRequestTest() {
54 | JsonArray json = new JsonArray();
55 | assertEquals(new Request().setJsonPayload(json).getUrlParams(), null);
56 | }
57 |
58 | @Test
59 | public void checkJsonArrayDataRequestTest() {
60 | JsonArray json = new JsonArray();
61 | json.add("john");
62 | json.add("smith");
63 | assertEquals(new Request().setJsonPayload(json).getJsonPayload(), json);
64 | }
65 |
66 | @Test
67 | public void checkMultipartRequestTest() {
68 | Map params = new HashMap<>();
69 | assertEquals(new Request().setMultipartData(params).getMultipartData(), params);
70 | }
71 |
72 | @Test
73 | public void checkMultipartParamsRequestTest() {
74 | Map params = new HashMap<>();
75 | assertEquals(new Request().setMultipartData(params).getUrlParams(), null);
76 | }
77 |
78 | @Test
79 | public void checkMultipartJsonRequestTest() {
80 | Map params = new HashMap<>();
81 | assertEquals(new Request().setMultipartData(params).getJsonPayload(), null);
82 | }
83 |
84 | @Test
85 | public void checkMultipartDataRequestTest() {
86 | Map params = new HashMap<>();
87 | params.put("name", "john");
88 | assertEquals(new Request().setMultipartData(params).getMultipartData(), params);
89 | }
90 |
91 | @Test
92 | public void checkParamsRequestTest() {
93 | Map params = new HashMap<>();
94 | assertEquals(new Request().setUrlParams(params).getUrlParams(), params);
95 | }
96 |
97 | @Test
98 | public void checkParamsJsonRequestTest() {
99 | Map params = new HashMap<>();
100 | assertEquals(new Request().setUrlParams(params).getJsonPayload(), null);
101 | }
102 |
103 | @Test
104 | public void checkParamsMultipartRequestTest() {
105 | Map params = new HashMap<>();
106 | assertEquals(new Request().setUrlParams(params).getMultipartData(), null);
107 | }
108 |
109 | @Test
110 | public void checkParamsDataRequestTest() {
111 | Map params = new HashMap<>();
112 | params.put("name", "john");
113 | assertEquals(new Request().setUrlParams(params).getUrlParams(), params);
114 | }
115 |
116 | @Test
117 | public void checkJsonObjectIsDataTest() {
118 | JsonObject json = new JsonObject();
119 | assertTrue(new Request().setJsonPayload(json).isPayload());
120 | }
121 |
122 | @Test
123 | public void checkJsonArrayIsDataTest() {
124 | JsonArray json = new JsonArray();
125 | assertTrue(new Request().setJsonPayload(json).isPayload());
126 | }
127 |
128 | @Test
129 | public void checkMultipartIsDataTest() {
130 | Map params = new HashMap<>();
131 | assertTrue(new Request().setMultipartData(params).isPayload());
132 | }
133 |
134 | @Test
135 | public void checkParamsIsDataTest() {
136 | Map params = new HashMap<>();
137 | assertFalse(new Request().setUrlParams(params).isPayload());
138 | }
139 | }
140 |
--------------------------------------------------------------------------------
/src/test/java/unit/ResponseTest.java:
--------------------------------------------------------------------------------
1 | package unit;
2 |
3 | import com.coveros.selenified.services.Response;
4 | import com.google.gson.JsonArray;
5 | import com.google.gson.JsonObject;
6 | import org.testng.annotations.Test;
7 |
8 | import static org.testng.Assert.assertFalse;
9 | import static org.testng.Assert.assertTrue;
10 |
11 | public class ResponseTest {
12 |
13 | @Test
14 | public void defaultIsDataTest() {
15 | Response response = new Response(null, null, 0, null, null, null);
16 | assertFalse(response.isData());
17 | }
18 |
19 | @Test
20 | public void IsDataObjectTest() {
21 | Response response = new Response(null, null, 0, new JsonObject(), null, null);
22 | assertTrue(response.isData());
23 | }
24 |
25 | @Test
26 | public void IsDataArrayTest() {
27 | Response response = new Response(null, null, 0, null, new JsonArray(), null);
28 | assertTrue(response.isData());
29 | }
30 |
31 | @Test
32 | public void IsDataBothTest() {
33 | Response response = new Response(null, null, 0, new JsonObject(), new JsonArray(), null);
34 | assertTrue(response.isData());
35 | }
36 | }
--------------------------------------------------------------------------------
/src/test/java/unit/SauceTest.java:
--------------------------------------------------------------------------------
1 | package unit;
2 |
3 | import com.coveros.selenified.Browser;
4 | import com.coveros.selenified.Capabilities;
5 | import com.coveros.selenified.exceptions.InvalidBrowserException;
6 | import com.coveros.selenified.exceptions.InvalidHubException;
7 | import com.coveros.selenified.exceptions.InvalidProxyException;
8 | import com.coveros.selenified.exceptions.InvalidSauceException;
9 | import com.coveros.selenified.utilities.Sauce;
10 | import org.openqa.selenium.Platform;
11 | import org.openqa.selenium.remote.DesiredCapabilities;
12 | import org.testng.annotations.Test;
13 |
14 | import java.net.MalformedURLException;
15 |
16 | import static com.coveros.selenified.utilities.Property.HUB;
17 | import static org.testng.Assert.assertEquals;
18 | import static org.testng.Assert.assertFalse;
19 | import static org.testng.Assert.assertTrue;
20 | import static unit.CapabilitiesTest.getBasicDesiredCapabilities;
21 |
22 | public class SauceTest extends SaveProperties {
23 |
24 | @Test
25 | public void isSauceNoHubTest() {
26 | assertFalse(Sauce.isSauce());
27 | }
28 |
29 | @Test
30 | public void isSauceNotSauceTest() {
31 | System.setProperty(HUB, "Hello World");
32 | assertFalse(Sauce.isSauce());
33 | }
34 |
35 | @Test
36 | public void isSauceNotSauceURLTest() {
37 | System.setProperty(HUB, "http://localhost:4444");
38 | assertFalse(Sauce.isSauce());
39 | }
40 |
41 | @Test
42 | public void isSauceSauceTest() {
43 | System.setProperty(HUB, "https://sauceusername:sauceaccesskey@ondemand.saucelabs.com:443");
44 | assertTrue(Sauce.isSauce());
45 | }
46 |
47 | @Test(expectedExceptions = InvalidHubException.class)
48 | public void getSauceConnectionEmptyTest() throws MalformedURLException {
49 | new Sauce().getSauceConnection();
50 | }
51 |
52 | @Test(expectedExceptions = InvalidSauceException.class)
53 | public void getSauceConnectionBadTest() throws MalformedURLException {
54 | System.setProperty(HUB, "https://saucelabs.com:443");
55 | new Sauce().getSauceConnection();
56 | }
57 |
58 | @Test
59 | public void getSauceConnectionTest() throws MalformedURLException {
60 | System.setProperty(HUB, "https://sauceusername:sauceaccesskey@ondemand.saucelabs.com:443");
61 | new Sauce().getSauceConnection();
62 | }
63 |
64 | @Test
65 | public void setupSauceCapabilitiesNoSauceTest() throws InvalidProxyException, InvalidBrowserException {
66 | // what we expect
67 | DesiredCapabilities expectedDesiredCapabilities = getBasicDesiredCapabilities("chrome");
68 | // what we're getting
69 | Capabilities capabilities = new Capabilities(new Browser("Chrome"));
70 | Sauce.setupSauceCapabilities(capabilities.getDesiredCapabilities());
71 | assertEquals(capabilities.getDesiredCapabilities(), expectedDesiredCapabilities);
72 | }
73 |
74 | @Test
75 | public void setupSauceCapabilitiesChromeTest() throws InvalidProxyException, InvalidBrowserException {
76 | System.setProperty(HUB, "ondemand.saucelabs.com");
77 | // what we expect
78 | DesiredCapabilities expectedDesiredCapabilities = getBasicDesiredCapabilities("chrome");
79 | expectedDesiredCapabilities.setCapability("seleniumVersion", "3.141.59");
80 | // what we're getting
81 | Capabilities capabilities = new Capabilities(new Browser("Chrome"));
82 | Sauce.setupSauceCapabilities(capabilities.getDesiredCapabilities());
83 | assertEquals(capabilities.getDesiredCapabilities(), expectedDesiredCapabilities);
84 | }
85 |
86 | @Test
87 | public void setupSauceCapabilitiesIETest() throws InvalidProxyException, InvalidBrowserException {
88 | System.setProperty(HUB, "ondemand.saucelabs.com");
89 | // what we expect
90 | DesiredCapabilities expectedDesiredCapabilities = getBasicDesiredCapabilities("internet explorer");
91 | expectedDesiredCapabilities.setPlatform(Platform.WINDOWS);
92 | expectedDesiredCapabilities.setAcceptInsecureCerts(false);
93 | expectedDesiredCapabilities.setCapability("seleniumVersion", "3.141.59");
94 | expectedDesiredCapabilities.setCapability("iedriverVersion", "3.141.59");
95 | // what we're getting
96 | Capabilities capabilities = new Capabilities(new Browser("internetExplorer"));
97 | Sauce.setupSauceCapabilities(capabilities.getDesiredCapabilities());
98 | assertEquals(capabilities.getDesiredCapabilities(), expectedDesiredCapabilities);
99 | }
100 | }
--------------------------------------------------------------------------------
/src/test/java/unit/SaveProperties.java:
--------------------------------------------------------------------------------
1 | package unit;
2 |
3 | import org.testng.ITestContext;
4 | import org.testng.annotations.AfterClass;
5 | import org.testng.annotations.AfterMethod;
6 | import org.testng.annotations.BeforeClass;
7 | import org.testng.annotations.BeforeMethod;
8 |
9 | import java.io.*;
10 |
11 | import static com.coveros.selenified.utilities.Property.*;
12 |
13 | public class SaveProperties {
14 | protected static final String SELENIFIED = System.getProperty("alt.build.dir") + "/test-classes/selenified.properties";
15 |
16 | private String setDefaultWait = null;
17 | private String setDefaultPoll = null;
18 | private String setGeneratePDF = null;
19 | private String setPackageResults = null;
20 | private String setHub = null;
21 | private String setProxy = null;
22 | private String setAppUrl = null;
23 | private String setBrowser = null;
24 | private String setHeadless = null;
25 | private String setOptions = null;
26 | private String setBuildName = null;
27 |
28 | File propertiesFile = new File(SELENIFIED);
29 | File savePropertiesFile = new File(SELENIFIED + ".tmp");
30 |
31 | @BeforeClass(alwaysRun = true)
32 | public void saveProperties() {
33 | if (System.getProperty(DEFAULT_WAIT) != null) {
34 | setDefaultWait = System.getProperty(DEFAULT_WAIT);
35 | }
36 | if (System.getProperty(DEFAULT_POLL) != null) {
37 | setDefaultPoll = System.getProperty(DEFAULT_POLL);
38 | }
39 | if (System.getProperty(GENERATE_PDF) != null) {
40 | setGeneratePDF = System.getProperty(GENERATE_PDF);
41 | }
42 | if (System.getProperty(PACKAGE_RESULTS) != null) {
43 | setPackageResults = System.getProperty(PACKAGE_RESULTS);
44 | }
45 | if (System.getProperty(HUB) != null) {
46 | setHub = System.getProperty(HUB);
47 | }
48 | if (System.getProperty(PROXY) != null) {
49 | setProxy = System.getProperty(PROXY);
50 | }
51 | if (System.getProperty(APP_URL) != null) {
52 | setAppUrl = System.getProperty(APP_URL);
53 | }
54 | if (System.getProperty(BROWSER) != null) {
55 | setBrowser = System.getProperty(BROWSER);
56 | }
57 | if (System.getProperty(HEADLESS) != null) {
58 | setHeadless = System.getProperty(HEADLESS);
59 | }
60 | if (System.getProperty(OPTIONS) != null) {
61 | setOptions = System.getProperty(OPTIONS);
62 | }
63 | if (System.getProperty(BUILD_NAME) != null) {
64 | setBuildName = System.getProperty(BUILD_NAME);
65 | }
66 | propertiesFile.renameTo(savePropertiesFile);
67 | }
68 |
69 | @AfterClass(alwaysRun = true)
70 | public void restoreProperties() {
71 | if (setDefaultWait != null) {
72 | System.setProperty(DEFAULT_WAIT, setDefaultWait);
73 | }
74 | if (setDefaultPoll != null) {
75 | System.setProperty(DEFAULT_POLL, setDefaultPoll);
76 | }
77 | if (setGeneratePDF != null) {
78 | System.setProperty(GENERATE_PDF, setGeneratePDF);
79 | }
80 | if (setPackageResults != null) {
81 | System.setProperty(PACKAGE_RESULTS, setPackageResults);
82 | }
83 | if (setHub != null) {
84 | System.setProperty(HUB, setHub);
85 | }
86 | if (setProxy != null) {
87 | System.setProperty(PROXY, setProxy);
88 | }
89 | if (setAppUrl != null) {
90 | System.setProperty(APP_URL, setAppUrl);
91 | }
92 | if (setBrowser != null) {
93 | System.setProperty(BROWSER, setBrowser);
94 | }
95 | if (setHeadless != null) {
96 | System.setProperty(HEADLESS, setHeadless);
97 | }
98 | if (setOptions != null) {
99 | System.setProperty(OPTIONS, setOptions);
100 | }
101 | if (setBuildName != null) {
102 | System.setProperty(BUILD_NAME, setBuildName);
103 | }
104 | savePropertiesFile.renameTo(propertiesFile);
105 | }
106 |
107 | @BeforeMethod(alwaysRun = true)
108 | @AfterMethod(alwaysRun = true)
109 | public void clearProperties(ITestContext context) {
110 | System.clearProperty(DEFAULT_WAIT);
111 | System.clearProperty(DEFAULT_POLL);
112 | System.clearProperty(GENERATE_PDF);
113 | System.clearProperty(PACKAGE_RESULTS);
114 | System.clearProperty(HUB);
115 | System.clearProperty(PROXY);
116 | System.clearProperty(APP_URL);
117 | context.removeAttribute(this.getClass().getName() + APP_URL);
118 | System.clearProperty(BROWSER);
119 | System.clearProperty(HEADLESS);
120 | System.clearProperty(OPTIONS);
121 | System.clearProperty(BUILD_NAME);
122 |
123 | if (new File(SELENIFIED).exists()) {
124 | new File(SELENIFIED).delete();
125 | }
126 | deleteDirectory(new File("directory"));
127 | }
128 |
129 | void createPropertiesFile(String content) throws IOException {
130 | BufferedWriter writer = new BufferedWriter(new FileWriter(SELENIFIED));
131 | writer.write(content);
132 | writer.close();
133 | }
134 |
135 | boolean deleteDirectory(File directoryToBeDeleted) {
136 | File[] allContents = directoryToBeDeleted.listFiles();
137 | if (allContents != null) {
138 | for (File file : allContents) {
139 | deleteDirectory(file);
140 | }
141 | }
142 | return directoryToBeDeleted.delete();
143 | }
144 | }
145 |
--------------------------------------------------------------------------------
/src/test/java/unit/ServicesAssertMatchesTest.java:
--------------------------------------------------------------------------------
1 | package unit;
2 |
3 | import com.coveros.selenified.Browser;
4 | import com.coveros.selenified.Capabilities;
5 | import com.coveros.selenified.exceptions.InvalidBrowserException;
6 | import com.coveros.selenified.exceptions.InvalidProxyException;
7 | import com.coveros.selenified.services.Response;
8 | import com.coveros.selenified.utilities.Reporter;
9 | import com.google.gson.JsonArray;
10 | import com.google.gson.JsonObject;
11 | import org.testng.annotations.AfterMethod;
12 | import org.testng.annotations.BeforeMethod;
13 | import org.testng.annotations.Test;
14 |
15 | import java.io.File;
16 | import java.util.ArrayList;
17 | import java.util.List;
18 |
19 | public class ServicesAssertMatchesTest {
20 |
21 | private Reporter reporter;
22 | private File directory;
23 | private File file;
24 |
25 | @BeforeMethod(alwaysRun = true)
26 | public void createFile() throws InvalidBrowserException, InvalidProxyException {
27 | reporter =
28 | new Reporter("directory", "file", new Capabilities(new Browser("None")), null, null, null, null, null, null);
29 | directory = new File("directory");
30 | file = new File("directory", "file.html");
31 | }
32 |
33 | @AfterMethod(alwaysRun = true)
34 | public void deleteFile() {
35 | file.delete();
36 | directory.delete();
37 | }
38 |
39 | @Test
40 | public void confirmEqualsCodePassTest() {
41 | JsonObject json = new JsonObject();
42 | json.addProperty("name", "john");
43 | Response response = new Response(reporter, null, 5, json, null, null);
44 | response.assertMatches().code("(\\d)");
45 | }
46 |
47 | @Test(expectedExceptions = AssertionError.class)
48 | public void confirmEqualsCodeFailTest() {
49 | JsonObject json = new JsonObject();
50 | json.addProperty("name", "john");
51 | Response response = new Response(reporter, null, 5, json, null, null);
52 | response.assertMatches().code("([0-3])");
53 | }
54 |
55 | @Test
56 | public void confirmEqualsMessagePassTest() {
57 | Response response = new Response(reporter, null, 5, new JsonObject(), null, "Some message");
58 | response.assertMatches().message("([\\w\\s]*)");
59 | }
60 |
61 | @Test(expectedExceptions = AssertionError.class)
62 | public void confirmEqualsMessageFailTest() {
63 | Response response = new Response(reporter, null, 5, new JsonObject(), null, "SOME MESSAGE");
64 | response.assertMatches().message("([a-z]*)");
65 | }
66 |
67 | @Test(expectedExceptions = AssertionError.class)
68 | public void confirmEqualsMessageNullTest() {
69 | Response response = new Response(reporter, null, 5, new JsonObject(), null, null);
70 | response.assertMatches().message("");
71 | }
72 |
73 | @Test(expectedExceptions = NullPointerException.class)
74 | public void confirmEqualsCrumbsNothing() {
75 | Response response = new Response(reporter, null, 5, null, null, null);
76 | response.assertMatches().nestedValue(null, "name");
77 | }
78 |
79 | @Test(expectedExceptions = AssertionError.class)
80 | public void confirmEqualsCrumbsNoJsonObject() {
81 | Response response = new Response(reporter, null, 5, null, null, null);
82 | response.assertMatches().nestedValue(new ArrayList<>(), "name");
83 | }
84 |
85 | @Test(expectedExceptions = NullPointerException.class)
86 | public void confirmEqualsCrumbsNoCrumbs() {
87 | Response response = new Response(reporter, null, 5, new JsonObject(), null, null);
88 | response.assertMatches().nestedValue(null, "name");
89 | }
90 |
91 | @Test(expectedExceptions = AssertionError.class)
92 | public void confirmEqualsCrumbsCrumbsNotExist() {
93 | JsonObject child = new JsonObject();
94 | child.addProperty("first", "john");
95 | child.addProperty("last", "smith");
96 | JsonArray json = new JsonArray();
97 | json.add(child);
98 | Response response = new Response(reporter, null, 5, null, json, null);
99 | List list = new ArrayList<>();
100 | list.add("name");
101 | response.assertMatches().nestedValue(list, "john");
102 | }
103 |
104 | @Test(expectedExceptions = AssertionError.class)
105 | public void confirmEqualsCrumbsCrumbsNotJsonObject() {
106 | JsonArray array = new JsonArray();
107 | array.add("john");
108 | array.add("jon");
109 | JsonObject json = new JsonObject();
110 | json.add("first", array);
111 | json.addProperty("last", "smith");
112 | Response response = new Response(reporter, null, 5, json, null, null);
113 | List list = new ArrayList<>();
114 | list.add("first");
115 | list.add("last");
116 | response.assertMatches().nestedValue(list, "john");
117 | }
118 |
119 | @Test
120 | public void confirmEqualsCrumbsMatch() {
121 | JsonObject json = new JsonObject();
122 | json.addProperty("first", "john");
123 | json.addProperty("last", "smith");
124 | Response response = new Response(reporter, null, 5, json, null, null);
125 | List list = new ArrayList<>();
126 | list.add("first");
127 | response.assertMatches().nestedValue(list, "john");
128 | }
129 |
130 | @Test(expectedExceptions = AssertionError.class)
131 | public void confirmEqualsCrumbsNoMatch() {
132 | JsonObject json = new JsonObject();
133 | json.addProperty("first", "john");
134 | json.addProperty("last", "smith");
135 | Response response = new Response(reporter, null, 5, json, null, null);
136 | List list = new ArrayList<>();
137 | list.add("first");
138 | response.assertMatches().nestedValue(list, "janice");
139 | }
140 | }
--------------------------------------------------------------------------------
/src/test/java/unit/TestCaseTest.java:
--------------------------------------------------------------------------------
1 | package unit;
2 |
3 | import com.coveros.selenified.utilities.TestCase;
4 | import org.testng.annotations.Test;
5 |
6 | import java.lang.reflect.Method;
7 |
8 | import static org.testng.Assert.assertEquals;
9 | import static org.testng.Assert.assertTrue;
10 |
11 | public class TestCaseTest {
12 |
13 | @Test
14 | public void getRandomStringLengthTest() {
15 | assertEquals(TestCase.getRandomString(0).length(), 0);
16 | assertEquals(TestCase.getRandomString(0), "");
17 | assertEquals(TestCase.getRandomString(999).length(), 999);
18 | assertTrue(TestCase.getRandomString(999).matches("^[A-Za-z0-9]{999}$"));
19 | assertEquals(TestCase.getRandomString(-1).length(), 0);
20 | assertEquals(TestCase.getRandomString(-1), "");
21 | }
22 |
23 | @Test
24 | public void removeNonWordCharactersTest() {
25 | assertEquals(TestCase.removeNonWordCharacters(null), null);
26 | assertEquals(TestCase.removeNonWordCharacters(""), "");
27 | assertEquals(TestCase.removeNonWordCharacters("hello world"), "helloworld");
28 | assertEquals(TestCase.removeNonWordCharacters("hello-world"), "helloworld");
29 | assertEquals(TestCase.removeNonWordCharacters("hello_world"), "helloworld");
30 | assertEquals(TestCase.removeNonWordCharacters("hello`~!@#$%^&*()world"), "helloworld");
31 | assertEquals(TestCase.removeNonWordCharacters("hello[]\\{}|;':\",./<>?world"), "helloworld");
32 | }
33 |
34 | @Test
35 | public void getTestNameNullTest(Method method) {
36 | assertEquals(TestCase.getTestName("UnitTests", "helloWorld"), "UnitTests.helloWorld");
37 | assertEquals(TestCase.getTestName("UnitTests", "helloWorld", null), "UnitTests.helloWorld");
38 | assertTrue(TestCase.getTestName("UnitTests", "helloWorld", new Object[]{}).startsWith("UnitTests.helloWorld"));
39 | assertTrue(TestCase.getTestName( "UnitTests", "helloWorld", new Object[]{null}).startsWith("UnitTests.helloWorld"));
40 |
41 | }
42 |
43 | @Test
44 | public void getTestNameTest(Method method) {
45 | assertEquals(TestCase.getTestName(method), "unit.TestCaseTest.getTestNameTest");
46 | Object[] options = new Object[]{"Python", "public"};
47 | assertEquals(TestCase.getTestName(method, options),
48 | "unit.TestCaseTest.getTestNameTestWithOptionPythonPublic");
49 | options = new Object[]{"Python", null};
50 | assertEquals(TestCase.getTestName(method, options),
51 | "unit.TestCaseTest.getTestNameTestWithOptionPython");
52 | assertEquals(TestCase.getTestName("UnitTests", "helloWorld", "python"),
53 | "UnitTests.helloWorldWithOptionPython");
54 | assertEquals(TestCase.getTestName("UnitTests", "helloWorld", "visual basic"),
55 | "UnitTests.helloWorldWithOptionVisualbasic");
56 | assertEquals(TestCase.getTestName("UnitTests", "helloWorld", "Python"),
57 | "UnitTests.helloWorldWithOptionPython");
58 | assertEquals(TestCase.getTestName("UnitTests", "helloWorld", "Python", "Perl"),
59 | "UnitTests.helloWorldWithOptionPythonPerl");
60 | assertEquals(TestCase
61 | .getTestName("UnitTests", "helloWorld", "Python", "Perl", "Bash", "Java", "Ruby", "Groovy",
62 | "Javascript", "PHP", "Scala", "Fortan", "Lisp", "COBOL", "Erlang", "Pacal", "Haskell", "Swift",
63 | "Elixir", "BASIC", "Tcl", "Rust", "Visual Basic", "Ceylon", "Cobra", "Forth", "Curry", "COMOL",
64 | "Gosu", "Powershell", "Squeak", "Gambas"),
65 | "UnitTests.helloWorldWithOptionPythonPerlBashJavaRubyGroovyJavascriptPHPScalaFortanLispCOBOLErlangPacalHaskellSwiftElixirBASICTclRustVisualBasicCeylonCobraForthCurryCOMOLGosuPowershellSqueakGambas");
66 | String testName = TestCase
67 | .getTestName("UnitTests", "helloWorld", "Python", "Perl", "Bash", "Java", "Ruby", "Groovy",
68 | "Javascript", "PHP", "Scala", "Fortan", "Lisp", "COBOL", "Erlang", "Pacal", "Haskell", "Swift",
69 | "Elixir", "BASIC", "Tcl", "Rust", "Visual Basic", "Ceylon", "Cobra", "Forth", "Curry", "COMOL",
70 | "Gosu", "Powershell", "Squeak", "Gambas", "Euphoria", "Fantom", "Assembly");
71 | assertTrue(testName.matches("^UnitTests\\.helloWorld@[0-9a-f]+$"));
72 | }
73 |
74 | }
75 |
--------------------------------------------------------------------------------
/src/test/resources/selenified.properties:
--------------------------------------------------------------------------------
1 | # connection
2 | hub=
3 | proxy=
4 | appURL=
5 | # browser
6 | browser=
7 | headless=true
8 | options=
9 | # logging
10 | defaultWait=5
11 | defaultPoll=50
12 | generatePDF=false
13 | packageResults=false
--------------------------------------------------------------------------------