In questo tutorial impareremo a conoscere i modelli di progettazione e le migliori pratiche di Selenium mentre lavoriamo con lo sviluppo del framework Selenium Automation (framework ibrido in selenio), ci sono due varianti di Framework Design o Framework model che dobbiamo considerare, che sono:
Abbiamo bisogno di sapere e capire perché il modello di progettazione del linguaggio è richiesto quando stiamo sviluppando il nostro quadro in uno dei Selenio modello quadro. Suggeriamo di passare attraverso i segmenti precedenti del Serie di tutorial sullo sviluppo di Selenium Framework per ottenere l'intera comprensione.
Capiamolo in dettaglio:
modelli di progettazione del selenio e migliori pratiche -quadro ibrido in selenio
Durante la progettazione di qualsiasi Framework, è necessario considerare alcune architetture di progettazione, ovvero modelli di progettazione e best practice del selenio e, in base alle necessità del tipo di modello di framework, è necessario selezionare un linguaggio Design pattern per risolvere il problema dello stato della progettazione del framework nel suo complesso.
Quindi, solo per concludere, possiamo scegliere un modello di framework Selenium (Hybrid, Modello a oggetti della pagina, Data Driven, ecc.), ma per implementare il modello, dobbiamo seguire e implementare alcuni Language Design Pattern (es. java/C# Design patterns )
Perché abbiamo bisogno del modello di progettazione del selenio e delle migliori pratiche durante la creazione di Selenium Framework:
Quali modelli di design da utilizzare in Selenium Framework:
Ci sono alcuni design pattern che potresti usare per implementare diverse aree del framework, come un esempio:
Faremo il modello di codifica live dell'intero Framework nei prossimi post qui.
Singleton Design Pattern per framework ibrido in selenio:
Singleton Design Pattern è un pattern in cui è possibile creare un solo oggetto da una classe e arrivare a utilizzare lo stesso oggetto per accedere ai metodi della classe; potremmo usare il design pattern nel configuratore dove abbiamo solo bisogno di leggere i dati di configurazione e possiamo caricare in qualche archivio dati (qualsiasi tipo di struttura dati che potresti usare come e quando richiesto durante l'esecuzione da qualsiasi classe e metodo)
Quindi potremmo ottenere lo stesso nel modo seguente mentre progettiamo lo stesso con il motivo Singleton Design.
NOTA: progetteremo e svilupperemo il framework da zero nella prossima sezione della serie di tutorial, ma questo tutorial specifico ti fornirà informazioni sulla necessità del modello di progettazione.
pacchetto com.cyborg.core.generic.dataUtils; importa java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; importa java.io.InputStream; importa java.util.LinkedHashMap; importare java.util.Proprietà; importare java.util.Set; import org.apache.log4j.PropertyConfigurator; // Questa è la classe pubblica della classe SingleTon PropertiesDataUtils { private Properties properties = null; LinkedHashMap statico pubblico configDataStore = nuova LinkedHashMap (); InputStream è = nullo; // Questo è il riferimento statico e privato della classe che potresti usare ovunque nel tuo framework private static PropertiesDataUtils propertiesDataUtils = null; booleano centralizeLog = falso; // Questo è il costruttore Private per creare l'oggetto ma non è possibile accedervi dall'esterno della classe per mantenere il design del pattern SingleTon, ovvero la creazione di un solo oggetto.
Private PropertiesDataUtils(String filePath) { generateDataStore(filePath); centralizeLog = Boolean.parseBoolean(PropertiesDataUtils.configDataStore.get("centralizedLog")); if(centralizeLog) PropertyConfigurator.configure(System.getProperty("user.dir")+"//src//test//resources//config//log4j_central.properties"); else PropertyConfigurator.configure(System.getProperty("user.dir")+"//src//test//resources//config//log4j_local.properties"); } private PropertiesDataUtils() { } // Questo metodo fondamentalmente crea l'istanza della classe SingleTon public static PropertiesDataUtils getInstance(String filePath) { if (propertiesDataUtils == null) propertiesDataUtils = new PropertiesDataUtils(filePath); restituire proprietàDataUtils; } // questo metodo crea sostanzialmente il datastore in cui si desidera memorizzare tutti i dati di configurazione come discusso in precedenza private void generateDataStore(String filePath) { try { this.properties = new Properties(); è=nuovo FileInputStream(filePath); properties.load(è); overrideFromEnvironment(); Impostare chiavi = loadAllKeys(); for (Oggetto k : chiavi) { Stringa chiave = (Stringa) k; configDataStore.put(chiave, getPropertyValue(chiave)); } } catch (FileNotFoundException fileNotFoundException) { Stringa exceptionData = String.valueOf(fileNotFoundException.getCause().getMessage()); } cattura (IOException ioException) { Stringa exceptionData = String.valueOf(ioException.getCause().getMessage()); } infine { if (null != is) { try { is.close(); } catch (Eccezione e) { Stringa exceptionData = String.valueOf(e.getCause().getMessage()); } } } } // Questo metodo viene utilizzato per caricare tutte le chiavi dal file delle proprietà.
Con questo approccio, potremmo usare il design pattern Singleton e usarlo nel nostro framework.
Factory Design Pattern in Selenium Framework:
Nel modello di progettazione di fabbrica, creiamo una classe (la chiamiamo una classe di fabbrica) e, d'altra parte, ne abbiamo una interfaccia ed eventualmente implementata da un numero “n” di classi.
La classe factory fondamentalmente restituisce l'oggetto delle classi precedenti (a seconda delle necessità), quindi non devi occuparti di quanto sopra “N” numero di oggetti delle classi; piuttosto, è possibile creare un oggetto della classe Factory e chiamare il metodo della classe factory che restituisce l'oggetto della linea di base necessario per le classi richieste tra le classi "n" di Adobe.
Ora, puoi prendere in considerazione questo design durante la creazione della diversa implementazione di Webdriver / browser.
Abbiamo un vario browser e l'implementazione con un diverso tipo di Selenium driver (es. LocalDriver, RemoteDriver, ThreadDriver, ecc.) e se e quando richiedi un tipo specifico di driver e specifico tipo di browser puoi menzionarlo nel file di configurazione e in base alla necessità la classe di fabbrica ti fornirà l'istanza di il driver e il browser per il tuo script di automazione da utilizzare ulteriormente.
Di seguito è riportato il codice di base per l'implementazione di questo modello di progettazione durante la creazione delle interazioni driver-browser:
Design dell'interfaccia:
pacchetto com.cyborg.core.web.utils.driverUtils; import org.openqa.selenium.WebDriver; import org.openqa.selenium.remote.RemoteWebDriver; public interface IDriver { public WebDriver init(String browserName); }
Numero "N" di implementazioni di classi di esplorazione (che stanno implementando l'interfaccia):
pacchetto com.cyborg.core.web.utils.driverUtils;
importare org.openqa.selenium.WebDriver;
importa org.openqa.selenium.chrome.ChromeDriver;
importa org.openqa.selenium.edge.EdgeDriver;
importa org.openqa.selenium.firefox.FirefoxDriver;
importare org.openqa.selenium.ie.InternetExplorerDriver;
importare org.openqa.selenium.safari.SafariDriver;
la classe pubblica LocalDriver implementa IDriver {
public WebDriver init(String nomebrowser) {
String percorsoToDriver = getDriverPath(browserName);
if (null!= nomebrowser) {
cambia (nomebrowser) {
custodia "cromata":
System.setProperty("webdriver.chrome.driver",
percorso del driver);
restituisce il nuovo ChromeDriver();
caso "firefox":
System.setProperty("webdriver.gecko.driver", percorsoToDriver);
restituisce il nuovo FirefoxDriver();
predefinito:
System.setProperty("webdriver.chrome.driver", percorsoToDriver);
restituisce il nuovo ChromeDriver();
}
} altro {
System.setProperty("webdriver.chrome.driver",
percorso del driver);
restituisce il nuovo ChromeDriver();
}
}
private String getDriverPath(String browserName) {
String osData = System.getProperty("os.name").toLowerCase().split("\\\\s")[0];
if (null!= osData) {
if (osData.equalsIgnoreCase("mac")) {
return "./DriversExe/" + osData + "_" + nomebrowser;
} else if (osData.contains("nux") || (osData.contains("nix"))) {
return "./DriversExe/linux_" + nomebrowser;
} altrimenti se (osData.contains("win")) {
return "./DriversExe/" + osData + "_" + nomebrowser + ".exe";
}
}
restituire null;
}
}
Ecco l'implementazione della classe Remote Driver:
pacchetto com.cyborg.core.web.utils.driverUtils; import org.openqa.selenium.WebDriver; import org.openqa.selenium.remote.DesiredCapabilities; import org.openqa.selenium.remote.RemoteWebDriver; import com.cyborg.core.generic.dataUtils.PropertiesDataUtils; import java.net.MalformedURLException; importare java.net.URL; la classe pubblica RemoteDriver implementa IDriver { DesiredCapabilities caps; Stringa remoteHuburl=PropertiesDataUtils.configDataStore.get("WEB_GRID_IP"); @Override public WebDriver init(String browserName) { if (browserName != null) { switch (browserName) { case "firefox": try { return new RemoteWebDriver(new URL(remoteHuburl), caps.firefox()); } cattura (MalformedURLException malformedUrlEx) { malformedUrlEx.getCause().getMessage(); malformedUrlEx.printStackTrace(); } case "chrome": try { return new RemoteWebDriver(new URL(remoteHuburl), caps.chrome()); } cattura (MalformedURLException malformedUrlEx) { malformedUrlEx.getCause().getMessage(); malformedUrlEx.printStackTrace(); } case "ie": try { return new RemoteWebDriver(new URL(remoteHuburl), caps.internetExplorer()); } cattura (MalformedURLException malformedUrlEx) { malformedUrlEx.getCause().getMessage(); malformedUrlEx.printStackTrace(); } predefinito: try { return new RemoteWebDriver(new URL(remoteHuburl), caps.chrome()); } cattura (MalformedURLException malformedUrlEx) { malformedUrlEx.getCause().getMessage(); malformedUrlEx.printStackTrace(); } } restituisce null; } altro { ritorno nullo; } }
Ecco l'implementazione della classe Factory, che fornisce il rispettivo browser e oggetto della classe driver:
pacchetto com.cyborg.core.web.utils.driverUtils; public class DriverProvider { public IDriver getDriver(String typeOfDriver) { if (typeOfDriver != null) { switch (typeOfDriver) { case "local": return new LocalDriver(); case "remote": restituisce new RemoteDriver(); default: restituisce new LocalDriver(); } } else { return null; } } }
Allo stesso modo, puoi implementare il Appium driver con lo stesso design, basta fornire l'implementazione e dichiarare un metodo nelle interfacce IDriver.
Conclusione: Con questo, stiamo concludendo qui come puoi usare i modelli di progettazione del linguaggio come parte dei modelli di progettazione e delle migliori pratiche Selenium durante lo sviluppo del framework ibrido in Selenium; nei prossimi segmenti del tutorial, costruiremo il framework del modello Page Object per Selenium Automation.
Prendere il Tutorial generale sul selenio, puoi visitare qui.
Debarghya Roy, un architetto di ingegneria con oltre 12 anni di esperienza, lavora con un'azienda Fortune 5 ed è un attivo collaboratore open source. Esperto in un'ampia gamma di tecnologie tra cui Java, C#, Python e vari strumenti di automazione e ingegneria delle prestazioni, ha anche esperienza nell'automazione della sicurezza, RPA e sviluppo back-end utilizzando SpringBoot, Kafka e stack ELK. Con sede a Bangalore, in India, Debarghya è appassionata di blog, musica e sostiene l'"Educazione per tutti", che ha portato alla fondazione di LambdaGeeks.
