ਜਾਵਾ ਅਤੇ ਵੈਬਡਰਾਈਵਰ ਦੇ ਨਾਲ ਪੇਜ ਆਬਜੈਕਟ ਮਾਡਲ ਫਰੇਮਵਰਕ

ਇਹ ਟਿutorialਟੋਰਿਅਲ ਟੈਸਟ ਆਟੋਮੇਸ਼ਨ ਫਰੇਮਵਰਕ ਡਿਵੈਲਪਮੈਂਟ ਦਾ ਦੂਜਾ ਹਿੱਸਾ ਹੈ.

ਪਹਿਲੇ ਹਿੱਸੇ ਵਿੱਚ, ਅਸੀਂ ਸਿੱਖਿਆ ਹੈ ਕਿ ਸਕ੍ਰੈਚ ਤੋਂ ਫਰੇਮਵਰਕ ਦੀ ਬਣਤਰ ਕਿਵੇਂ ਬਣਾਈਏ.

ਇਸ ਟਿutorialਟੋਰਿਅਲ ਵਿੱਚ, ਅਸੀਂ ਫਰੇਮਵਰਕ ਲਈ ਬੇਸ ਕਲਾਸਸ ਬਣਾਉਣ ਜਾ ਰਹੇ ਹਾਂ.


ਨੋਟ:ਜੇ ਤੁਸੀਂ ਇਸ ਟਿutorialਟੋਰਿਅਲ ਦਾ ਭਾਗ 1 ਨਹੀਂ ਪੜ੍ਹਿਆ ਹੈ, ਤਾਂ ਕਿਰਪਾ ਕਰਕੇ 'ਤੇ ਦਿੱਤੇ ਨਿਰਦੇਸ਼ਾਂ ਦਾ ਪਾਲਣ ਕਰੋ ਸਕ੍ਰੈਚ ਤੋਂ ਇੱਕ ਟੈਸਟ ਆਟੋਮੇਸ਼ਨ ਫਰੇਮਵਰਕ ਕਿਵੇਂ ਬਣਾਇਆ ਜਾਵੇ .

ਇਸ ਦੇ ਉਲਟ, ਤੁਸੀਂ ਮੇਰੇ ਦੁਆਰਾ ਬੇਸ ਫਰੇਮਵਰਕ ਨੂੰ ਕਲੋਨ ਕਰ ਸਕਦੇ ਹੋ GitHub ਰੈਪੋ .

ਇੱਕ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ ਇਸ ਟਿutorialਟੋਰਿਅਲ ਦੇ ਭਾਗ 1 ਦੀਆਂ ਹਦਾਇਤਾਂ ਦੀ ਪਾਲਣਾ ਕਰ ਲੈਂਦੇ ਹੋ ਜਾਂ ਰੈਪੋ ਨੂੰ ਕਲੋਨ ਕਰ ਲੈਂਦੇ ਹੋ, ਤੁਹਾਡੇ ਕੋਲ ਇਹ ਚਾਰ ਮਾਵੇਨ ਮੈਡਿulesਲ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ:


  • ਡੋਮੇਨ - ਕਲਾਸਾਂ ਜੋ ਕਾਰੋਬਾਰ ਦੇ ਮਾਡਲ ਦਾ ਵਰਣਨ ਕਰਦੀਆਂ ਹਨ
  • ਫਰੇਮਵਰਕ - ਕੋਰ ਕਲਾਸਾਂ ਜੋ theਾਂਚਾ ਬਣਦੀਆਂ ਹਨ
  • ਪੇਜ-ਇਕਾਈ - ਹਰੇਕ ਵੈਬਪੰਨੇ ਦੇ ਭਾਗ ਅਤੇ ਲੋਕੇਟਰ
  • ਰੈਗ੍ਰੇਸ਼ਨ-ਟੈਸਟ - ਅਸਲ ਪ੍ਰੀਖਿਆ ਦੀਆਂ ਕਲਾਸਾਂ ਜੋ ਪੇਜ ਆਬਜੈਕਟ ਤੇ ਨਿਰਭਰ ਕਰਦੀਆਂ ਹਨ

ਸਾਡਾ ਫਰੇਮਵਰਕ ਪੇਜ ਆਬਜੈਕਟ ਮਾਡਲ ਡਿਜ਼ਾਈਨ ਪੈਟਰਨ 'ਤੇ ਅਧਾਰਤ ਹੋਵੇਗਾ. ਅਸੀਂ ਵੈਬਡਰਾਈਵਰ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰਾਂਗੇ ਪੇਜਫੈਕਟਰੀ ਵੈਬ ਐਲੀਮੈਂਟਸ ਅਰੰਭ ਕਰਨ ਲਈ ਕਲਾਸ.



ਸੇਲੇਨੀਅਮ ਪੇਜ ਆਬਜੈਕਟ ਮਾਡਲ

ਠੀਕ ਹੈ, ਹੁਣ ਜਦੋਂ ਤੁਸੀਂ ਬੇਸ structureਾਂਚਾ ਬਣਾਇਆ ਹੈ, ਆਓ ਬੇਸ ਕਲਾਸਾਂ ਜੋੜ ਕੇ ਅਰੰਭ ਕਰੀਏ.

ਬੇਸ ਪੇਜ.ਜਾਵਾ

ਵਿੱਚ ਫਰੇਮਵਰਕ ਮੋਡੀ moduleਲ, ਅਸੀਂ ਇੱਕ ਕਲਾਸ ਬਣਾਉਂਦੇ ਹਾਂ ਜਿਸਨੂੰ ਬੇਸਪੇਜ.ਜਾਵਾ ਕਹਿੰਦੇ ਹਨ. ਸਾਰੀਆਂ ਪੇਜ ਆਬਜੈਕਟ ਕਲਾਸਾਂ ਬੇਸਪੇਜ ਨੂੰ ਵਧਾਉਂਦੀਆਂ ਹਨ, ਇਸ ਤਰ੍ਹਾਂ ਸਾਰੇ ਬੇਸ ਵਿਧੀਆਂ ਵਿਰਾਸਤ ਵਿਚ ਹੁੰਦੀਆਂ ਹਨ.

ਸਾਡੀ ਬੇਸਪੇਜ ਕਲਾਸ ਵਿਚ ਇਕ ਕੰਸਟਰਕਟਰ ਹੋਵੇਗਾ ਜੋ ਇਕ ਵੈਬਡ੍ਰਾਈਵਰ ਵੌਇਟ ਨੂੰ ਆਰੰਭ ਕਰਨ ਲਈ ਇਕ ਵੈਬਡ੍ਰਾਈਵਰ objectਬਜੈਕਟ ਲੈਂਦਾ ਹੈ. ਨਿਰਮਾਤਾ ਪੇਜਫੈਕਟਰੀ ਦੁਆਰਾ ਵੈਬ ਐਲੀਮੈਂਟਸ ਅਰੰਭ ਕਰਨ ਲਈ ਵੀ ਜ਼ਿੰਮੇਵਾਰ ਹੋਣਗੇ.


ਇਸ ਤੋਂ ਇਲਾਵਾ, ਸਾਡੇ ਕੋਲ ਵੱਖ ਵੱਖ ਇੰਤਜ਼ਾਰਾਂ ਜਿਵੇਂ ਕਿ ਵੇਟਫੋਰਮੈਂਟਮੈਂਟ ਟੂ ਐਪਅਰ ਨੂੰ ਹੈਂਡਲ ਕਰਨ ਲਈ ਕੁਝ ਸਹੂਲਤਾਂ ਦੇ ਇੰਤਜ਼ਾਰ methodsੰਗ ਵੀ ਹੋਣਗੇ.

ਤਾਂ ਬੇਸਪੇਜ ਕਲਾਸ ਇਸ ਤਰਾਂ ਦਿਖਾਈ ਦੇਵੇਗੀ:

package rima.framework.core; import org.openqa.selenium.By; import org.openqa.selenium.WebDriver; import org.openqa.selenium.support.PageFactory; import org.openqa.selenium.support.pagefactory.AjaxElementLocatorFactory; import org.openqa.selenium.support.ui.ExpectedConditions; import org.openqa.selenium.support.ui.WebDriverWait; public class BasePage {
private static final int TIMEOUT = 5;
private static final int POLLING = 100;
protected WebDriver driver;
private WebDriverWait wait;
public BasePage(WebDriver driver) {
this.driver = driver;
wait = new WebDriverWait(driver, TIMEOUT, POLLING);
PageFactory.initElements(new AjaxElementLocatorFactory(driver, TIMEOUT), this);
}
protected void waitForElementToAppear(By locator) {
wait.until(ExpectedConditions.visibilityOfElementLocated(locator));
}
protected void waitForElementToDisappear(By locator) {
wait.until(ExpectedConditions.invisibilityOfElementLocated(locator));
}
protected void waitForTextToDisappear(By locator, String text) {
wait.until(ExpectedConditions.not(ExpectedConditions.textToBe(locator, text)));
} }
ਨੋਟ:ਬੇਸਪੇਜ ਕਲਾਸ ਵਿਚ ਅਸੀਂ ਵੈਬਡਰਾਈਵਰ ਆਬਜੈਕਟ ਨੂੰ ਆਰੰਭ ਨਹੀਂ ਕਰਦੇ. ਸ਼ੁਰੂਆਤੀ ਬੇਸੈਸਟ ਕਲਾਸ ਵਿਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ.

ਬੇਸੈਸਟ.ਜਾਵਾ

ਬੇਸੈਸਟ ਕਲਾਸ ਵੈਬਡਰਾਈਵਰ objectਬਜੈਕਟ ਨੂੰ ਅਰੰਭ ਕਰਨ ਅਤੇ ਖਤਮ ਕਰਨ ਦੇ .ੰਗਾਂ ਨੂੰ ਰੱਖਦੀ ਹੈ. ਕਿਉਂਕਿ ਸਾਰੀਆਂ ਟੈਸਟ ਕਲਾਸਾਂ ਬੇਸੈਸਟ ਕਲਾਸ ਦਾ ਵਾਧਾ ਕਰੇਗੀ, ਤਦ ਆਰੰਭਕਤਾ ਸਪੱਸ਼ਟ ਤੌਰ ਤੇ ਕੀਤੀ ਜਾਂਦੀ ਹੈ. ਟੈਸਟ ਦੀਆਂ ਕਲਾਸਾਂ ਬਸ _ _ + _ | ਤੇ ਕਾਲ ਕਰਕੇ ਵੈਬਡਰਾਈਵਰ ਆਬਜੈਕਟ ਪ੍ਰਾਪਤ ਕਰਦੀਆਂ ਹਨ .ੰਗ.

ਇਸ ਦੇ ਨਾਲ, ਜਿਵੇਂ ਕਿ ਅਸੀਂ TestNG ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਾਂ, ਅਸੀਂ | _ _ _ _ | ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ ਅਤੇ getDriver() ਵਿਆਖਿਆਵਾਂ, ਜਿਵੇਂ ਕਿ:


@BeforeSuite

ਪੇਜ ਆਬਜੈਕਟ ਸ਼ਾਮਲ ਕਰਨਾ

ਹੁਣ, ਵਿਚ ਪੇਜ-ਇਕਾਈ ਮੋਡੀ moduleਲ, ਅਸੀਂ ਆਪਣਾ ਪਹਿਲਾ ਪੇਜ jectਬਜੈਕਟ ਬਣਾਉਂਦੇ ਹਾਂ. ਇਸ ਟਿutorialਟੋਰਿਅਲ ਲਈ, ਮੈਂ ਗੂਗਲ ਦਾ ਹੋਮਪੇਜ ਇਸਤੇਮਾਲ ਕਰਾਂਗਾ.

@AfterSuite

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਵੇਖ ਸਕਦੇ ਹੋ, ਇਹ ਪੇਜ ਆਬਜੈਕਟ ਬਹੁਤ ਕੁਝ ਨਹੀਂ ਕਰਦਾ. ਇਸਦਾ ਸਿਰਫ ਇਕ ਕੰਸਟਰਕਟਰ ਹੈ ਜੋ ਵੈਬਡ੍ਰਾਇਵਰ ਆਬਜੈਕਟ ਲੈਂਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਆਪਣੇ ਸੁਪਰ ਕਲਾਸ ਕੰਸਟਰਕਟਰ ਤੇ ਦਿੰਦਾ ਹੈ.

ਦੁਬਾਰਾ, ਧਿਆਨ ਦਿਓ ਕਿ ਕੋਈ ਵੀ ਪੇਜ ਆਬਜੈਕਟ ਜਾਂ ਬੇਸਪੇਜ ਵੈਬਡਰਾਈਵਰ Obਬਜੈਕਟ ਨੂੰ ਆਰੰਭ ਨਹੀਂ ਕਰਦਾ.

ਇਸ ਟਿutorialਟੋਰਿਅਲ ਦੇ ਭਾਗ 3 ਵਿਚ, ਅਸੀਂ ਗੂਗਲ ਦੇ ਹੋਮਪੇਜ ਦੇ ਸਰਚ ਫੰਕਸ਼ਨ ਨੂੰ ਸੰਭਾਲਣ ਦੇ ਤਰੀਕਿਆਂ ਨੂੰ ਜੋੜਾਂਗੇ.




ਟੈਸਟ ਸ਼ਾਮਲ ਕਰਨਾ

ਵਿੱਚ ਟੈਸਟ ਸ਼ਾਮਲ ਕਰਦੇ ਹਾਂ ਰੈਗ੍ਰੇਸ਼ਨ-ਟੈਸਟ ਮੋਡੀ .ਲ.

ਅਸੀਂ ਇਕ ਪ੍ਰੀਖਿਆ ਵਿਧੀ ਨਾਲ ਗੂਗਲਹੋਮਪੇਜ ਟੈਸਟਸ ਨਾਮਕ ਇਕ ਟੈਸਟ ਕਲਾਸ ਬਣਾਉਂਦੇ ਹਾਂ ਜੋ ਸਾਡੇ ਗੂਗਲ ਹੋਮਪੇਜ ਪੇਜ ਆਬਜੈਕਟ ਨੂੰ ਸਿਰਫ ਪ੍ਰਭਾਵਤ ਕਰਦੀ ਹੈ. ਹੁਣ ਲਈ, ਇਹ ਕੋਈ ਹੋਰ ਕਿਰਿਆ ਨਹੀਂ ਕਰਦੀ.

ਇਸ ਟਿutorialਟੋਰਿਅਲ ਦੇ ਭਾਗ 3 ਵਿੱਚ, ਮੈਂ ਨਤੀਜਿਆਂ ਨੂੰ ਖੋਜਣ ਅਤੇ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਦੇ methodsੰਗਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਾਂਗਾ.

package rima.framework.core; import io.github.bonigarcia.wdm.ChromeDriverManager; import org.openqa.selenium.WebDriver; import org.openqa.selenium.chrome.ChromeDriver; import org.openqa.selenium.chrome.ChromeOptions; import org.testng.annotations.AfterSuite; import org.testng.annotations.BeforeSuite; public class BaseTest {
private WebDriver driver;
@BeforeSuite
public void beforeSuite() {
System.setProperty('headless', 'false'); // You can set this property elsewhere
String headless = System.getProperty('headless');

ChromeDriverManager.chromedriver();
if('true'.equals(headless)) {

ChromeOptions chromeOptions = new ChromeOptions();

chromeOptions.addArguments('--headless');

driver = new ChromeDriver(chromeOptions);
} else {

driver = new ChromeDriver();
}
}
@AfterSuite
public void afterSuite() {
if(null != driver) {

driver.close();

driver.quit();
}
}
public WebDriver getDriver() {
return driver;
} }

ਜਦੋਂ ਤੁਸੀਂ ਆਪਣੇ ਆਈਡੀਈ ਵਿੱਚ ਉਪਰੋਕਤ ਟੈਸਟ ਚਲਾਉਂਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਇੱਕ ਗੂਗਲ ਕਰੋਮ ਬਰਾ browserਜ਼ਰ ਨੂੰ ਖੁੱਲਾ ਅਤੇ ਬੰਦ ਵੇਖਣਾ ਚਾਹੀਦਾ ਹੈ.


ਇਸ ਟਿutorialਟੋਰਿਅਲ ਦੇ ਭਾਗ 3 ਲਈ ਬਣੇ ਰਹੋ ਜਿੱਥੇ ਮੈਂ theਾਂਚੇ ਨੂੰ ਵਧਾਉਣ ਲਈ ਹੋਰ ਭਾਗ ਜੋੜ ਕੇ ਉਪਰੋਕਤ ਉਦਾਹਰਣ ਨੂੰ ਅੱਗੇ ਲੈ ਜਾਵਾਂਗਾ.

ਤੁਸੀਂ ਉੱਪਰ ਦਿੱਤੇ ਸਾਰੇ ਸਰੋਤ ਕੋਡ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ GitHub ਰੈਪੋ . ਉਮੀਦ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਉਪਰੋਕਤ ਵੈੱਬ ਡ੍ਰਾਈਵਰ ਫਰੇਮਵਰਕ ਟਿutorialਟੋਰਿਅਲ ਲਾਭਦਾਇਕ ਮਿਲਿਆ ਹੈ.

ਅੱਗੇ ਪੜ੍ਹਨ:

ਦਿਲਚਸਪ ਲੇਖ