Why TestProject
TestProject Agents
Smart Test Recorder
Schedule and Run Tests
Reports
TestProject Addons
Integrations
TestProject API
Articles
Releases
Contact us
Using Page object model and Page Factory with TestProject
Test automation is an important part of any software testing project, but effective test automation needs to be thought through and designed well. There are several strategies and methods that can be used to keep your test automation efficient and easy to run and maintain over time. A couple of common strategies for this include the page object and page factory models. These approaches to test automation allow you to keep the tests modular and well organized for maximum effectiveness. These strategies are most often used in coded tests and TestProject supports them in any coded tests you make or run in the platform, but the same concepts can also be used within the Test Recorder as well.
Page Object in Recorded Tests
The page object model is essentially a way of organizing your tests so that you have one class per page and that class contains the elements for that page along with the methods for acting on those elements. A similar concept can be applied within the Recorder. For example, you could create a test for logging into your app. You can then use that test in all other tests in the project that need to start with logging in.
To do that in the Recorder, just click "add a new test as a step" and select the test. (In our case the login test):
You can then choose the login test as a test step in your current test case.
This lets you re-use the same login test in multiple tests which means that if something changes on the login page, you only need to update that one test, and all of the tests using it will get that change.
Page Object in Coded Tests
The Page object model is of course well suited to coded tests. This section will walk you through an example of how you can use the page object model in an android test written in Java.
Build your First Test with Appium
Let’s start by learning how to create a “plain” Appium automated test for Android. The code below automates the TestProject Demo app. You can download its APK or view the complete source code.
To start the automation, the test prepares Android driver capabilities with all the required information about the device under test (DUT) and App under test (AUT). Then, using these capabilities, it initiates the Android driver that will be used to invoke various Appium actions on the mobile application. To perform the actions, Appium must identify the elements it interacts with. To do so, it uses various location strategies.
The most convenient location strategy is the ID (aka. resource-id in Android). For example, it searches for the login button to make sure that the login screen is displayed using By.id and the value login. I will show how to identify your element locators later in this tutorial, here.
Basic Login Test:
1
package io.testproject.appium.tests;
2
3
import io.appium.java_client.android.AndroidDriver;
4
import io.appium.java_client.android.AndroidKeyCode;
5
import io.appium.java_client.remote.AndroidMobileCapabilityType;
6
import io.appium.java_client.remote.MobileCapabilityType;
7
import org.openqa.selenium.By;
8
import org.openqa.selenium.Platform;
9
import org.openqa.selenium.remote.DesiredCapabilities;
10
11
import java.net.URL;
12
13
public class PositiveLoginTest {
14
15
private final static String APP_PACKAGE_NAME = "io.testproject.demo";
16
private final static String APP_ACTIVITY_NAME = ".MainActivity";
17
private final static String PASSWORD = "12345";
18
19
public static void main(String[] args) throws Exception {
20
21
// Prepare Appium session
22
DesiredCapabilities capabilities = DesiredCapabilities.android();
23
capabilities.setCapability(MobileCapabilityType.PLATFORM_NAME, Platform.ANDROID);
24
capabilities.setCapability(MobileCapabilityType.UDID, "YOUR_DEVICE_UDID");
25
capabilities.setCapability(MobileCapabilityType.NO_RESET, false);
26
capabilities.setCapability(AndroidMobileCapabilityType.APP_PACKAGE, APP_PACKAGE_NAME);
27
capabilities.setCapability(AndroidMobileCapabilityType.APP_ACTIVITY, APP_ACTIVITY_NAME);
28
29
// Initialize driver
30
AndroidDriver driver = new AndroidDriver(new URL("http://0.0.0.0:4723/wd/hub"), capabilities);
31
32
// Discard state
33
driver.resetApp();
34
35
// Will throw exception if login element missing
36
driver.findElement(By.id("login"));
37
38
// Hide keyboard if visible
39
if (driver.findElements(By.className("UIAKeyboard")).size() != 0) {
40
driver.pressKey(new KeyEvent(AndroidKey.ESCAPE));
41
}
42
43
// Type Full Name
44
driver.findElement(By.id("name")).sendKeys("John Smith");
45
46
// Type Password
47
driver.findElement(By.id("password")).sendKeys(PASSWORD);
48
49
// Click Login
50
driver.findElement(By.id("login")).click();
51
52
// Verify login
53
if (driver.findElement(By.id("greetings")).isDisplayed()) {
54
System.out.println("Test completed successfully");
55
}
56
57
// Close session
58
driver.quit();
59
}
60
}
Copied!
Page Object Model and Page Factory Advantages vs. “Plain” Appium
This demonstrates how to create a “Plain” Appium test, but let's see how we can improve it with the Page Object Model (POM). Below are the advantages of utilizing POM as opposed to “plain” Appium:
“Plain” Appium
POM Appium
Mix of test logic and UI actions
Separation of duties to OOP classes
Coupled design
Decoupling objects library from decision taking in tests
Difficult maintenance
One authority to manage page elements and UI action
Code redundancy
No duplicate findElement calls and UI manipulations
Unnecessary complexity
Self-explanatory code, thanks to FindBy annotations
Create Page Classes by Utilizing Page Object and Page Factory
In order to create the page object model, you will need to define the page classes. In the demo application there are two pages: the Login page and the Profile page.
To map the elements, POM uses the FindBy annotations. These annotations should be used to decorate the fields declared for the elements. Location strategies can be different, but the most convenient one is the ID (aka. resource-id in Android).
While creating tests like this it can be helpful to use the inspector and element locator in order to find the correct values.
These values can then be placed in the annotations in the code. Then, initElements method residing on the PageObject factory class should be invoked to initialize all the elements of the page.
Elements, page class fields, are now being used across the page to manipulate the UI and encapsulated in methods invoked externally.
Login Page Class:
1
package io.testproject.appium.pom.tests.pages;
2
3
import io.appium.java_client.android.AndroidDriver;
4
import io.appium.java_client.android.AndroidElement;
5
import io.appium.java_client.pagefactory.AndroidFindBy;
6
import io.appium.java_client.pagefactory.AppiumFieldDecorator;
7
import org.openqa.selenium.support.PageFactory;
8
9
import java.time.Duration;
10
11
public class LoginPage {
12
13
private AndroidDriver<AndroidElement> driver;
14
15
public LoginPage() {
16
}
17
18
public LoginPage(AndroidDriver<AndroidElement> driver) {
19
this.driver = driver;
20
PageFactory.initElements(new AppiumFieldDecorator(driver, Duration.ofSeconds(5)), this);
21
}
22
23
@AndroidFindBy(className = "UIAKeyboard")
24
private AndroidElement keyboard;
25
26
@AndroidFindBy(id = "name")
27
private AndroidElement nameElement;
28
29
@AndroidFindBy(id = "password")
30
private AndroidElement passwordElement;
31
32
@AndroidFindBy(id = "login")
33
private AndroidElement loginElement;
34
35
public boolean isDisplayed() {
36
return loginElement.isDisplayed();
37
}
38
39
public void typeName(String name) {
40
nameElement.sendKeys(name);
41
}
42
43
public void typePassword(String password) {
44
passwordElement.sendKeys(password);
45
}
46
47
public void clickLogin() {
48
loginElement.click();
49
}
50
51
public void hideKeyboardIfVisible() {
52
if (keyboard != null) {
53
driver.hideKeyboard();
54
}
55
}
56
57
public void login (String name, String password) {
58
hideKeyboardIfVisible();
59
typeName(name);
60
typePassword(password);
61
clickLogin();
62
}
63
}
Copied!
The element inspector and locator can be used to find the profile page class on the same manner as for the login page above.
Profile Page Class:
1
package io.testproject.appium.pom.tests.pages;
2
3
import io.appium.java_client.android.AndroidDriver;
4
import io.appium.java_client.android.AndroidElement;
5
import io.appium.java_client.pagefactory.AndroidFindBy;
6
import io.appium.java_client.pagefactory.AppiumFieldDecorator;
7
import org.openqa.selenium.support.PageFactory;
8
9
public class ProfilePage {
10
11
private AndroidDriver driver;
12
13
public ProfilePage() {
14
}
15
16
public ProfilePage(AndroidDriver driver) {
17
this.driver = driver;
18
PageFactory.initElements(new AppiumFieldDecorator(driver), this);
19
}
20
21
@AndroidFindBy(className = "UIAKeyboard")
22
private AndroidElement keyboard;
23
24
@AndroidFindBy(id = "greetings")
25
private AndroidElement greetingsElement;
26
27
@AndroidFindBy(id = "logout")
28
private AndroidElement logoutElement;
29
30
@AndroidFindBy(id = "country")
31
private AndroidElement countryElement;
32
33
@AndroidFindBy(id = "address")
34
private AndroidElement addressElement;
35
36
@AndroidFindBy(id = "email")
37
private AndroidElement emailElement;
38
39
@AndroidFindBy(id = "phone")
40
private AndroidElement phoneElement;
41
42
@AndroidFindBy(id = "save")
43
private AndroidElement saveElement;
44
45
@AndroidFindBy(id = "saved")
46
private AndroidElement savedElement;
47
48
public boolean isDisplayed() {
49
return greetingsElement.isDisplayed();
50
}
51
52
public void typeCountry(String country) {
53
countryElement.sendKeys(country);
54
}
55
56
public void typeAddress(String address) {
57
addressElement.sendKeys(address);
58
}
59
60
public void typeEmail(String email) {
61
emailElement.sendKeys(email);
62
}
63
64
public void typePhone(String phone) {
65
phoneElement.sendKeys(phone);
66
}
67
68
public void hideKeyboardIfVisible() {
69
if (keyboard != null) {
70
driver.hideKeyboard();
71
}
72
}
73
74
public void save() {
75
saveElement.click();
76
}
77
78
public void updateProfile(String country, String address, String email, String phone) {
79
hideKeyboardIfVisible();
80
typeCountry(country);
81
typeAddress(address);
82
typeEmail(email);
83
typePhone(phone);
84
save();
85
}
86
87
public boolean isSaved() {
88
return savedElement.isDisplayed();
89
}
90
91
}
Copied!
Create an Appium Page Object Test
This test is identical to the one above with the only difference that all the UI actions are now encapsulated into the pages classes.
Instead of searching and manipulating elements directly, this is being done using convenience methods (e.g.isDisplayed)that are implemented by every page.
1
package io.testproject.appium.pom.tests;
2
3
import io.appium.java_client.android.AndroidDriver;
4
import io.appium.java_client.remote.AndroidMobileCapabilityType;
5
import io.appium.java_client.remote.MobileCapabilityType;
6
import io.testproject.appium.pom.tests.pages.LoginPage;
7
import io.testproject.appium.pom.tests.pages.ProfilePage;
8
import org.openqa.selenium.Platform;
9
import org.openqa.selenium.remote.DesiredCapabilities;
10
11
import java.net.URL;
12
13
public class PositiveLoginTest {
14
15
private final static String APP_PACKAGE_NAME = "io.testproject.demo";
16
private final static String APP_ACTIVITY_NAME = ".MainActivity";
17
private final static String PASSWORD = "12345";
18
19
public static void main(String[] args) throws Exception {
20
21
// Prepare Appium session
22
DesiredCapabilities capabilities = DesiredCapabilities.android();
23
capabilities.setCapability(MobileCapabilityType.PLATFORM_NAME, Platform.ANDROID);
24
capabilities.setCapability(MobileCapabilityType.UDID, "YOUR_DEVICE_UDID");
25
capabilities.setCapability(MobileCapabilityType.NO_RESET, false);
26
capabilities.setCapability(AndroidMobileCapabilityType.APP_PACKAGE, APP_PACKAGE_NAME);
27
capabilities.setCapability(AndroidMobileCapabilityType.APP_ACTIVITY, APP_ACTIVITY_NAME);
28
29
// Initialize driver
30
AndroidDriver driver = new AndroidDriver(new URL("http://0.0.0.0:4723/wd/hub"), capabilities);
31
32
driver.resetApp();
33
34
LoginPage loginPage = new LoginPage(driver);
35
if (!loginPage.isDisplayed()) {
36
return;
37
}
38
39
loginPage.login("John Smith", PASSWORD);
40
ProfilePage profilePage = new ProfilePage(driver);
41
if (!profilePage.isDisplayed()) {
42
return;
43
}
44
45
System.out.println("Test completed successfully");
46
47
// Close session
48
driver.quit();
49
}
50
}
Copied!
Example of Implementing Page Object Model with TestProject Framework
This test can be enhanced even further by utilizing TestProject, so let's look at how to do that. The test logic stays identical to the previous examples, but, you will notice a few enhancements:
- The pages classes remain the same.
- Test class is annotated with @Test annotation providing the test with a friendlier name.
- Calls to report.step allow reporting of test milestones and provided better progress granulation when reviewing them in the results and reporting dashboard.
- The call to report.result allows for providing a final statement for the test execution before it passes or fails.
1
import io.testproject.java.annotations.v2.Parameter;
2
import io.testproject.java.annotations.v2.Test;
3
import io.testproject.java.enums.TakeScreenshotConditionType;
4
import io.testproject.java.sdk.v2.drivers.AndroidDriver;
5
import io.testproject.java.sdk.v2.enums.ExecutionResult;
6
import io.testproject.java.sdk.v2.exceptions.FailureException;
7
import io.testproject.java.sdk.v2.reporters.TestReporter;
8
import io.testproject.java.sdk.v2.tests.AndroidTest;
9
import io.testproject.java.sdk.v2.tests.helpers.AndroidTestHelper;
10
11
@Test(name = "Demo Test with Defaults")
12
public class DemoTestWithDefaults implements AndroidTest {
13
14
@Parameter
15
public String name = "John Smith";
16
17
@Parameter
18
public String password = "12345";
19
20
@Parameter
21
public String country = "Canada";
22
23
@Parameter
24
public String address = "8 Ness Ave";
25
26
@Parameter
27
public String email = "[email protected]";
28
29
@Parameter
30
public String phone = "+1 555 555";
31
32
public ExecutionResult execute(AndroidTestHelper helper) throws FailureException {
33
AndroidDriver driver = helper.getDriver();
34
TestReporter report = helper.getReporter();
35
36
driver.resetApp();
37
38
LoginPage loginPage = new LoginPage(driver);
39
report.step("Launched TestProject Demo app", loginPage.isDisplayed());
40
41
loginPage.login(name, password);
42
ProfilePage profilePage = new ProfilePage(driver);
43
report.step(String.format("Logged in with %s:%s", name, password), profilePage.isDisplayed(), TakeScreenshotConditionType.Always);
44
45
profilePage.updateProfile(country, address, email, phone);
46
report.step(String.format("Profile information saved"), profilePage.isSaved(), TakeScreenshotConditionType.Always);
47
48
report.result("Test completed successfully");
49
return ExecutionResult.PASSED;
50
}
51
}
Copied!
To run the test locally, create a Runner as can be seen in the following example:
1
import io.testproject.java.sdk.v2.Runner;
2
3
import java.io.IOException;
4
5
public class RunTests {
6
private static Runner runner;
7
8
public static void init() throws InstantiationException {
9
runner = Runner.createAndroid("TP_DEV_TOKEN", "DEVICE_UDID", "io.testproject.demo", "io.testproject.demo.MainActivity");
10
11
}
12
13
public static void tearDown() throws IOException {
14
runner.close();
15
}
16
17
public static void main(String[] args) throws Exception {
18
init();
19
runner.run(new DemoTestWithDefaults());
20
tearDown();
21
}
22
}
Copied!
You can find more documentation for TestProject SDK here: https://github.com/testproject-io/java-sdk-examples.
Last modified 6mo ago
Copy link
Contents
Page Object in Recorded Tests
Page Object in Coded Tests
Build your First Test with Appium
Page Object Model and Page Factory Advantages vs. “Plain” Appium
Create Page Classes by Utilizing Page Object and Page Factory
Create an Appium Page Object Test
Example of Implementing Page Object Model with TestProject Framework