డేటా నడిచే, కీవర్డ్ నడిచే & హైబ్రిడ్ సెలీనియం ముసాయిదాను నిర్మించడం

మునుపటి ఈ శ్రేణిలో మీకు సెలీనియం పరీక్షలో ప్రాథమిక భావనలను బహిర్గతం చేసింది.అయితే, ఈ బ్లాగులో, మీ కోడ్ నిర్మాణాన్ని ఆప్టిమైజ్ చేయడానికి సెలీనియం ఫ్రేమ్‌వర్క్‌ను ఎలా ఉపయోగించాలో నేను మీకు చెప్తాను మరియు ఇది మిమ్మల్ని మరింత దగ్గరగా చేస్తుంది .

సెలీనియం ఫ్రేమ్‌వర్క్ అంటే ఏమిటి?

సెలీనియం ఫ్రేమ్‌వర్క్ అనేది కోడ్ నిర్వహణను సరళంగా చేయడానికి మరియు కోడ్ రీడబిలిటీని మెరుగుపరచడానికి కోడ్ నిర్మాణం. ఒక ఫ్రేమ్‌వర్క్‌లో మొత్తం కోడ్‌ను చిన్న చిన్న ముక్కలుగా విడగొట్టడం జరుగుతుంది, ఇది ఒక నిర్దిష్ట కార్యాచరణను పరీక్షిస్తుంది.

కోడ్ డేటా నిర్మాణంలో ఉంది, “డేటా సెట్” వాస్తవ “పరీక్ష కేసు” నుండి వేరు చేయబడుతుంది, ఇది వెబ్ అప్లికేషన్ యొక్క కార్యాచరణను పరీక్షిస్తుంది. ఇది కూడా ఒక విధంగా నిర్మించబడవచ్చు, అమలు చేయవలసిన పరీక్ష కేసులను బాహ్య అనువర్తనం నుండి (.csv వంటివి) పిలుస్తారు.

అక్కడ అనేక ఫ్రేమ్‌వర్క్‌లు ఉన్నాయి, కానీ సాధారణంగా ఉపయోగించే 3 సెలీనియం ఫ్రేమ్‌వర్క్ (లు):

• డేటా నడిచే ఫ్రేమ్‌వర్క్
• కీవర్డ్ నడిచే ఫ్రేమ్‌వర్క్
• హైబ్రిడ్ ఫ్రేమ్‌వర్క్

ఈ ఫ్రేమ్‌వర్క్‌లు ఈ బ్లాగులోని డెమోతో చర్చించబడతాయి. ఇంకా ముందుకు వెళ్ళే ముందు, సెలీనియం ఫ్రేమ్‌వర్క్ ఎందుకు అమల్లో ఉండాలి, మరియు వాటిని ఉపయోగించడం ద్వారా మీరు ఏ ప్రయోజనాలను పొందుతారో నేను మీకు చెప్తాను.

జావాలో విలువ ద్వారా ఎలా పాస్ చేయాలి

మనకు సెలీనియం ఫ్రేమ్‌వర్క్ ఎందుకు అవసరం?

ఒక ఫ్రేమ్‌వర్క్ లేకుండా, ఒక పరీక్ష కేసు ఉంటుంది, ఇది మొత్తం పరీక్ష కార్యాచరణను కలిగి ఉంటుంది. భయానక భాగం ఏమిటంటే, ఈ సింగిల్ టెస్ట్ కేసులో మిలియన్ లైన్ల కోడ్ వరకు పెరిగే సామర్ధ్యం ఉంది. కాబట్టి చాలా పెద్దది ఒక పరీక్ష కేసు చదవడానికి కఠినంగా ఉంటుంది. మీరు తరువాత ఏదైనా కార్యాచరణను సవరించాలనుకున్నా, మీరు కోడ్‌ను సవరించడానికి చాలా కష్టంగా ఉంటారు.

ఫ్రేమ్‌వర్క్‌ను అమలు చేయడం వల్ల, చిన్నది కాని బహుళ కోడ్ ముక్కలు వస్తాయి, వివిధ ప్రయోజనాలు ఉన్నాయి.

సెలీనియం ఫ్రేమ్‌వర్క్ యొక్క ప్రయోజనాలు

• పెరిగిన కోడ్ పునర్వినియోగం
• మెరుగైన కోడ్ రీడబిలిటీ
• అధిక పోర్టబిలిటీ
• స్క్రిప్ట్ తగ్గించబడిందినిర్వహణ

ఫ్రేమ్‌వర్క్‌ల యొక్క ప్రాథమికాలను ఇప్పుడు మీకు తెలుసు, వాటిలో ప్రతిదాన్ని వివరంగా వివరిస్తాను.

డేటా నడిచే ముసాయిదా

సెలీనియంలోని డేటా నడిచే ఫ్రేమ్‌వర్క్ “డేటా సమితిని” వాస్తవ “పరీక్ష కేసు” (కోడ్) నుండి వేరు చేసే సాంకేతికత. ఈ ఫ్రేమ్‌వర్క్ పూర్తిగా ఇన్‌పుట్ పరీక్ష డేటాపై ఆధారపడి ఉంటుంది. పరీక్ష డేటా ఎక్సెల్ ఫైల్, .సిఎస్వి ఫైల్ లేదా ఏదైనా డేటాబేస్ వంటి బాహ్య వనరుల నుండి ఇవ్వబడుతుంది.

పరీక్ష కేసు డేటా సమితి నుండి వేరు చేయబడినందున, మీ కోడ్‌లో టోకు మార్పులు చేయకుండా మేము ఒక నిర్దిష్ట కార్యాచరణ యొక్క పరీక్ష కేసును సులభంగా సవరించవచ్చు. ఉదాహరణకు, మీరు లాగిన్ కార్యాచరణ కోసం కోడ్‌ను సవరించాలనుకుంటే, అదే కోడ్‌లోని ఇతర ఆధారిత భాగాన్ని కూడా సవరించడానికి బదులుగా మీరు దాన్ని సవరించవచ్చు.

ఇది కాకుండా, ఎంత డేటాను పరీక్షించాలో కూడా మీరు సులభంగా నియంత్రించవచ్చు. ఎక్సెల్ ఫైల్‌కు (లేదా ఇతర వనరులకు) ఎక్కువ యూజర్‌పేరు మరియు పాస్‌వర్డ్ ఫీల్డ్‌లను జోడించడం ద్వారా మీరు పరీక్ష పారామితుల సంఖ్యను సులభంగా పెంచవచ్చు.

ఉదాహరణకు, నేను వెబ్ పేజీకి లాగిన్‌ను తనిఖీ చేయవలసి వస్తే, నేను యూజర్‌పేరు మరియు పాస్‌వర్డ్ ఆధారాల సమితిని ఎక్సెల్ ఫైల్‌లో ఉంచగలను మరియు బ్రౌజర్‌లో ఆటోమేషన్‌ను ప్రత్యేక జావా క్లాస్ ఫైల్‌లో నిర్వహించడానికి కోడ్‌కు ఆధారాలను పంపగలను.

సెలీనియం వెబ్‌డ్రైవర్‌తో అపాచీ POI ని ఉపయోగించడం

ఎక్సెల్ ఫైళ్ళను చదవడానికి వెబ్‌డ్రైవర్ నేరుగా మద్దతు ఇవ్వదు. అందువల్ల మేము ఉపయోగిస్తాము అపాచీ POI ఏదైనా మైక్రోసాఫ్ట్ ఆఫీస్ పత్రాన్ని చదవడం / వ్రాయడం కోసం. మీరు అపాచీ POI (JAR ఫైళ్ళ సమితి) నుండి డౌన్‌లోడ్ చేసుకోవచ్చు ఇక్కడ . మీ అవసరానికి అనుగుణంగా జిప్ ఫైల్ లేదా తారు ఫైల్‌ను డౌన్‌లోడ్ చేయండి మరియు వాటిని సెలీనియం JAR ల సెట్‌తో పాటు ఉంచండి.

ప్రధాన కోడ్ మరియు డేటా సెట్ మధ్య సమన్వయం జాగ్రత్త తీసుకోబడుతుంది టెస్ట్ఎన్జి డేటా ప్రొవైడర్స్, ఇది అపాచీ POI JAR ఫైళ్ళలో భాగంగా వచ్చే లైబ్రరీ. డెమో ప్రయోజనం కోసం, నేను “లాగిన్ క్రెడెన్షియల్స్” అనే ఎక్సెల్ ఫైల్‌ను సృష్టించాను, ఇందులో వినియోగదారు పేర్లు మరియు పాస్‌వర్డ్‌లు వేర్వేరు నిలువు వరుసలలో నిల్వ చేయబడ్డాయి.

పరీక్ష కేసును అర్థం చేసుకోవడానికి క్రింది కోడ్‌ను చూడండి. ఫ్లైట్ బుకింగ్ అప్లికేషన్ యొక్క లాగిన్ కార్యాచరణను పరీక్షించడానికి ఇది ఒక సాధారణ కోడ్.

ప్యాకేజీ డేటాడ్రైవెన్ దిగుమతి org.openqa.selenium.B దిగుమతి ద్వారా org.openqa.selenium.chrome.ChromeDriver దిగుమతి org.testng. దిగుమతి org.testng.annotations.AfterMethod దిగుమతి org.testng.annotations.DataProvider దిగుమతి org.Testng.annotations. పబ్లిక్ క్లాస్ DDTExcel {ChromeDriver డ్రైవర్ estTest (dataProvider = 'testdata') పబ్లిక్ శూన్యమైన డెమోప్రొజెక్ట్ (స్ట్రింగ్ యూజర్‌పేరు, స్ట్రింగ్ పాస్‌వర్డ్) అంతరాయం కలిగించే ఎక్సెప్షన్‌ను విసిరివేస్తుంది {System.setProperty ('webdriver.chrome.driver', 'C: UsersVardhanDownloadsxromed క్రొత్త ChromeDriver () driver.get ('http://newtours.demoaut.com/') driver.findElement (By.name ('userName')). sendKeys (username) driver.findElement (By.name ('password' )). sendKeys (password) driver.findElement (By.name ('login')). ​​క్లిక్ చేయండి () Thread.sleep (5000) Assert.assertTrue (driver.getTitle (). మ్యాచ్‌లు ('ఫ్లైట్ కనుగొనండి: మెర్క్యురీ టూర్స్: '),' చెల్లని ఆధారాలు ') System.out.println (' లాగిన్ విజయవంతమైంది ') after after అనర్థర్ మెథడ్ శూన్యమైన ప్రోగ్రామ్ టెర్మినేషన్ () {driver.quit () @ ata డేటాప్రొవైడర్ (పేరు =' టెస్ట్‌డేటా ') పబ్లిక్ ఆబ్జెక్ట్ [] [] టెస్ట్‌డా taFeed () {ReadExcelFile config = new ReadExcelFile ('C: UsersVardhanworkspaceSeleniumLoginCredentials.xlsx') int rows = config.getRowCount (0) ఆబ్జెక్ట్ [] [] ఆధారాలు = కొత్త ఆబ్జెక్ట్ [అడ్డు వరుసలు] [2] (int i = 0i
మీరు పై నుండి గమనించినట్లయితే, మాకు “TestDataFeed ()” అనే పద్ధతి ఉంది. ఈ పద్ధతిలో, నేను “ReadExcelFile” అనే మరొక తరగతి యొక్క ఆబ్జెక్ట్ ఉదాహరణను సృష్టించాను. ఈ వస్తువును తక్షణం చేస్తున్నప్పుడు, డేటాను కలిగి ఉన్న నా ఎక్సెల్ ఫైల్ యొక్క మార్గాన్ని నేను తినిపించాను. ఎక్సెల్ వర్క్‌బుక్ నుండి వచనాన్ని తిరిగి పొందటానికి నేను లూప్ కోసం మరింత నిర్వచించాను.
కానీ, ఇచ్చిన షీట్ సంఖ్య, కాలమ్ సంఖ్య మరియు అడ్డు వరుస సంఖ్య నుండి డేటాను చదవడానికి, కాల్స్ “ReadExcelFile” తరగతికి చేయబడతాయి. నా “ReadExcelFile” యొక్క కోడ్ క్రింద ఉంది.
ప్యాకేజీ డేటాడ్రైవెన్ దిగుమతి java.io.File దిగుమతి java.io.FileInputStream దిగుమతి org.apache.poi.xssf.usermodel.XSSFSheet దిగుమతి org.apache.poi.xssf.usermodel.XSSF వర్క్‌బుక్ పబ్లిక్ క్లాస్ రీడ్‌ఎక్సెల్ ఫైల్ ExcelPath) {try {file src = new file (ExcelPath) FileInputStream fis = new FileInputStream (src) wb = new XSSFWorkbook (fis)} క్యాచ్ (మినహాయింపు ఇ) {System.out.println (e.getMessage ())}} పబ్లిక్ స్ట్రింగ్ గెట్‌డేటా (పూర్ణాంక షీట్‌నంబర్, పూర్ణాంక వరుస, పూర్ణాంక కాలమ్) {షీట్ = wb.getSheetAt (షీట్‌నంబర్) స్ట్రింగ్ డేటా = షీట్.గెట్‌రో (అడ్డు వరుస) .జెట్ సెల్ (కాలమ్) .జెట్‌స్ట్రింగ్ సెల్‌వాల్యూ () రిటర్న్ డేటా int row = wb.getSheetAt (sheetIndex) .getLastRowNum () row = row + 1 return row}}
మొదట నేను దిగుమతి చేసుకున్న లైబ్రరీలను గమనించండి. నేను దిగుమతి చేసాను అపాచీ POI XSSF ఫైళ్ళను ఎక్సెల్ చేయడానికి డేటాను చదవడానికి / వ్రాయడానికి ఉపయోగించే లైబ్రరీలు. ఇక్కడ, విలువలను దాటడానికి నేను కన్స్ట్రక్టర్ (అదే పద్ధతి యొక్క వస్తువు) ను సృష్టించాను: షీట్ సంఖ్య, అడ్డు వరుస సంఖ్య మరియు కాలమ్ సంఖ్య. ఈ ఫ్రేమ్‌వర్క్‌ను బాగా అర్థం చేసుకోవడానికి, ఈ క్రింది వీడియో ద్వారా వెళ్ళమని నేను మిమ్మల్ని అభ్యర్థిస్తున్నాను, ఇక్కడ నేను దీన్ని నిర్మాణాత్మక పద్ధతిలో వివరించాను.
 
 సెలీనియం వెబ్‌డ్రైవర్‌లో డేటా నడిచే ముసాయిదా | సెలీనియం ట్యుటోరియల్ 
  
ఇప్పుడు ఫ్రేమ్‌వర్క్‌కి వెళ్దాం, అనగా కీవర్డ్ నడిచే ఫ్రేమ్‌వర్క్.
 కీవర్డ్ నడిచే ముసాయిదా 
కీవర్డ్ డ్రైవెన్ ఫ్రేమ్‌వర్క్ అనేది ఒక టెక్నిక్, దీనిలో అన్ని ఆపరేషన్లు & చేయవలసిన సూచనలు వాస్తవ పరీక్ష కేసు నుండి విడిగా వ్రాయబడతాయి. డేటా నడిచే ఫ్రేమ్‌వర్క్‌తో దీనికి ఉన్న సారూప్యత ఏమిటంటే, చేయవలసిన కార్యకలాపాలు మళ్ళీ ఎక్సెల్ షీట్ వంటి బాహ్య ఫైల్‌లో నిల్వ చేయబడతాయి.
నేను మాట్లాడుతున్న ఆపరేషన్లు పరీక్షా కేసులో భాగంగా అమలు చేయాల్సిన పద్ధతులు తప్ప మరొకటి కాదు. కీవర్డ్ డ్రైవ్ ఫ్రేమ్‌వర్క్‌తో ఉన్న ప్రయోజనం ఏమిటంటే మీరు పరీక్షించదలిచిన కార్యాచరణలను సులభంగా నియంత్రించవచ్చు. ఎక్సెల్ ఫైల్‌లో అప్లికేషన్ యొక్క కార్యాచరణను పరీక్షించే పద్ధతులను మీరు పేర్కొనవచ్చు. అందువల్ల, ఎక్సెల్ లో పేర్కొన్న పద్ధతి పేర్లు మాత్రమే పరీక్షించబడతాయి.
ఉదాహరణకు, వెబ్ అప్లికేషన్‌లోకి లాగిన్ అవ్వడానికి, మేము ప్రధాన పరీక్ష కేసులో బహుళ పద్ధతులను వ్రాయవచ్చు, దీనిలో ప్రతి పరీక్ష కేసు నిర్దిష్ట కార్యాచరణను పరీక్షిస్తుంది. బ్రౌజర్ డ్రైవర్‌ను ఇన్‌స్టాంటియేట్ చేయడానికి ఒక పద్ధతి ఉండవచ్చు, వినియోగదారు పేరు & పాస్‌వర్డ్ ఫీల్డ్‌లను కనుగొనడానికి, పద్ధతులు ఉండవచ్చు, వెబ్ పేజీకి నావిగేట్ చేయడానికి మరొక పద్ధతి ఉండవచ్చు.
ఫ్రేమ్‌వర్క్ ఎలా ఉందో అర్థం చేసుకోవడానికి క్రింది కోడ్‌ను చూడండి. దిగువ కోడ్‌లో వ్యాఖ్యానించబడిన పంక్తులు మీకు అర్థం కాకపోతే వివరణగా ఉపయోగపడతాయి.
ప్యాకేజీ కీవర్డ్డ్రైవెన్ దిగుమతి org.openqa.selenium.chrome.ChromeDriver దిగుమతి org.testng. దిగుమతి org.testng.annotations.Test దిగుమతి java.util.concurrent.TimeUnit దిగుమతి org.openqa.selenium.By దిగుమతి org.openqa.selenium.We. పబ్లిక్ క్లాస్ చర్యలు {పబ్లిక్ స్టాటిక్ వెబ్‌డ్రైవర్ డ్రైవర్ పబ్లిక్ స్టాటిక్ శూన్య ఓపెన్‌బౌజర్ () {System.setProperty ('webdriver.chrome.driver', 'C: UsersVardhanDownloadschromedriver.exe') డ్రైవర్ = కొత్త ChromeDriver ()} పబ్లిక్ స్టాటిక్ శూన్య నావిగేట్ () {డ్రైవర్ . మేనేజ్ (). టైమ్‌అవుట్‌లు (). అవ్యక్తంగా వేచి ఉండండి (10, టైమ్‌యూనిట్.సెకాండ్స్) డ్రైవర్.జెట్ ('http://newtours.demoaut.com')} పబ్లిక్ స్టాటిక్ శూన్య ఇన్పుట్_ యూజర్‌నేమ్ () {driver.findElement (By.name (' యూజర్‌నేమ్ ')). పంపండి కీస్ (' మెర్క్యురీ ')} పబ్లిక్ స్టాటిక్ శూన్యమైన ఇన్‌పుట్_పాస్వర్డ్ () {driver.findElement (By.name (' password ')). sendKeys (' మెర్క్యూరీ ')} పబ్లిక్ స్టాటిక్ శూన్యత క్లిక్_లాగిన్ () {driver.findElement (By.name ('లాగిన్')) క్లిక్ చేయండి () public est టెస్ట్ పబ్లిక్ స్టాటిక్ శూన్యత verify_login () {స్ట్రింగ్ పేజ్ టైటిల్ = డ్రైవర్.జెట్ టైటిల్ () Assert.assertEquals (పేజీ టైటిల్, 'ఫ్లైట్ కనుగొనండి: మెర్క్యురీ టూర్స్ : ')} పబ్లిక్ స్టాటిక్ శూన్య క్లోజ్ బ్రౌజర్ () {driver.quit ()}}
మీరు గమనిస్తే, పరీక్షించాల్సిన వివిధ కార్యాచరణలు వేర్వేరు పద్ధతుల్లో పిలువబడతాయి. ఇప్పుడు, ఎక్సెల్ ఫైల్‌లో పద్ధతి పేరు ఉనికి ఆధారంగా ఈ పద్ధతులు మరొక తరగతి నుండి పిలువబడతాయి. అదేవిధంగా, ఎక్సెల్ ఫైల్ను చదవడానికి మరియు ఫలితాలను తిరిగి పంపడానికి, నేను మరొక క్లాస్ వ్రాసాను. రెండూ క్రింద ప్రదర్శించబడతాయి.
జావాలో ఓవర్రైడింగ్ మరియు ఓవర్లోడింగ్
పద్ధతులను ప్రారంభించే తరగతి ఫైల్, ఇది.
ప్యాకేజీ కీవర్డ్డ్రైవెన్ పబ్లిక్ క్లాస్ డ్రైవర్‌స్క్రిప్ట్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) విసిరివేత మినహాయింపు {// ఎక్సెల్ ఫైల్ పేరును ఎక్సెల్ ఫైల్ పేరుతో ప్రకటించడం స్ట్రింగ్ sPath = 'సి: యూజర్స్వర్ధన్‌వర్క్‌స్పేస్సెలెనియం ఫ్రేమ్‌వర్క్స్ డెమోడాటాఇంగైన్.ఎక్స్ఎల్ఎక్స్ ఎక్సెల్ ఫైల్‌తో కనెక్ట్ అవ్వడానికి మేము ఎక్సెల్ పాత్ మరియు షీట్‌నేమ్‌ను వాదనలుగా దాటుతున్నాము ప్రస్తుత కాలమ్‌లు // తరువాతి అధ్యాయాలలో మేము ఈ హార్డ్ కోడెడ్ విలువలను వరిబెల్స్‌తో భర్తీ చేస్తాము // ఇది కాలమ్ 3 (యాక్షన్ కీవర్డ్) వరుస యొక్క విలువలను వరుసల వారీగా (int iRow = 1iRow<=7iRow++) { String sActions = ReadExcelData.getCellData(iRow, 1) //Comparing the value of Excel cell with all the keywords in the 'Actions' class if(sActions.equals('openBrowser')) { //This will execute if the excel cell value is 'openBrowser' //Action Keyword is called here to perform action Actions.openBrowser() } else if(sActions.equals('navigate')) { Actions.navigate() } else if(sActions.equals('input_Username')) { Actions.input_Username() } else if(sActions.equals('input_Password')) { Actions.input_Password() } else if(sActions.equals('click_Login')) { Actions.click_Login() } else if(sActions.equals('verify_Login')) { Actions.verify_login() } else if(sActions.equals('closeBrowser')) { Actions.closeBrowser() } } } } 
మరియు ఎక్సెల్ విలువలను చదివే క్లాస్ ఫైల్ ఇది.
ప్యాకేజీ కీవర్డ్డ్రైవెన్ దిగుమతి java.io.FileInputStream దిగుమతి org.apache.poi.xssf.usermodel.XSSFSheet దిగుమతి org.apache.poi.xssf.usermodel.XSSFWorkbook దిగుమతి org.apache.poi.xssf.usermodel.XSSXDell XSSFSheet ExcelWSheet ప్రైవేట్ స్టాటిక్ XSSFWorkbook ExcelWBook ప్రైవేట్ స్టాటిక్ XSSFCell సెల్ // ఈ పద్ధతి ఫైల్ మార్గాన్ని సెట్ చేయడం మరియు ఎక్సెల్ ఫైల్‌ను తెరవడం // ఎక్సెల్ పాత్ మరియు షీట్‌నేమ్‌ను ఈ పద్ధతికి వాదనలుగా పబ్లిక్ స్టాటిక్ శూన్యమైన సెట్ఎక్సెల్ ఫైల్ (స్ట్రింగ్ పాత్, స్ట్రింగ్ షీట్ నేమ్) మినహాయింపు {FileInputStream ExcelFile = new FileInputStream (Path) ExcelWBook = new XSSFWorkbook (ExcelFile) ExcelWSheet = ExcelWBook.getSheet (SheetName)} // ఈ పద్ధతి ఎక్సెల్ సెల్ నుండి పరీక్ష డేటాను చదవడం / ఇందులో మనం పారామితులను దాటుతున్నాము / రో నమ్ మరియు కోల్ నమ్ పబ్లిక్ స్టాటిక్ స్ట్రింగ్ getCellData (int RowNum, int ColNum) మినహాయింపు {సెల్ = ExcelWSheet.getRow (RowNum) .getCell (ColNum) స్ట్రింగ్ సెల్‌డేటా = Cell.getStringCellValue () తిరిగి సెల్‌డేటా}}
ఇప్పుడు, ఈ సెలీనియం ఫ్రేమ్‌వర్క్ బ్లాగ్ యొక్క చివరి భాగంలోకి వెళ్దాం, ఇక్కడ హైబ్రిడ్ ఫ్రేమ్‌వర్క్‌ను ఎలా నిర్మించాలో నేను మీకు చూపిస్తాను.
 హైబ్రిడ్ ఫ్రేమ్‌వర్క్  
హైబ్రిడ్ ఫ్రేమ్‌వర్క్ అనేది ఒక టెక్నిక్, దీనిలో మేము డేటా డ్రైవెన్ & కీవర్డ్ డ్రైవెన్ సెలీనియం ఫ్రేమ్‌వర్క్ (ల) రెండింటినీ ఉత్తమంగా ఉపయోగించుకోవచ్చు. ఈ బ్లాగులో పైన చూపిన ఉదాహరణలను ఉపయోగించి, ఎక్సెల్ ఫైల్ (కీవర్డ్ నడిచే విధానం) లో అమలు చేయడానికి పద్ధతులను నిల్వ చేయడం ద్వారా మరియు ఈ పద్ధతి పేర్లను పంపడం ద్వారా మేము హైబ్రిడ్ ఫ్రేమ్‌వర్క్‌ను నిర్మించవచ్చు. జావా రిఫ్లెక్షన్ క్లాస్ (డేటా నడిచే విధానం) సృష్టించడానికి బదులుగా ఉంటే / వేరే “డ్రైవర్‌స్క్రిప్ట్” క్లాస్‌లో లూప్.
దిగువ కోడ్ స్నిప్పెట్‌లో సవరించిన “డ్రైవర్‌స్క్రిప్ట్” తరగతిని చూడండి.ఇక్కడ, బహుళ ఇఫ్ / ఎల్స్ లూప్‌లను ఉపయోగించటానికి బదులుగా, ఎక్సెల్ ఫైల్ నుండి పద్ధతి పేర్లను చదవడానికి డేటా నడిచే విధానం ఉపయోగించబడుతుంది.
ప్యాకేజీ హైబ్రిడ్ఫ్రేమ్‌వర్క్ దిగుమతి java.lang.reflect.Method పబ్లిక్ క్లాస్ డ్రైవర్‌స్క్రిప్ట్ జావా {// ఇది ఒక క్లాస్ ఆబ్జెక్ట్, దీనిని 'పబ్లిక్ స్టాటిక్' గా ప్రకటించారు // కాబట్టి దీనిని ప్రధాన [] పద్ధతి పబ్లిక్ స్టాటిక్ చర్యల పరిధికి వెలుపల ఉపయోగించవచ్చు పబ్లిక్ స్టాటిక్ స్ట్రింగ్ కార్యకలాపాలు // ఇది 'పబ్లిక్ స్టాటిక్' గా ప్రకటించబడిన ప్రతిబింబ తరగతి వస్తువు // కాబట్టి దీనిని ప్రధాన [] పద్ధతి పబ్లిక్ స్టాటిక్ మెథడ్ పద్ధతి [] పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) యొక్క పరిధికి వెలుపల ఉపయోగించవచ్చు. {// ఎక్సెల్ ఫైల్ పేరును ఎక్సెల్ ఫైల్ పేరుతో ప్రకటిస్తోంది స్ట్రింగ్ sPath = 'C: యూజర్స్వర్ధన్వర్క్స్పేస్సెలెనియం ఫ్రేమ్వర్క్స్ డెమోడాటాఎంగైన్.ఎక్స్ఎల్ఎక్స్' // ఇక్కడ మనం ఎక్సెల్ ఫైల్ తో కనెక్ట్ అవ్వడానికి ఎక్సెల్ పాత్ మరియు షీట్ నేమ్ ను పాస్ చేస్తున్నాము // ఈ పద్ధతి గతంలో సృష్టించబడింది ReadExcelData.setExcelFile (sPath, 'Sheet1') // హార్డ్ కోడెడ్ విలువలు ప్రస్తుతానికి ఎక్సెల్ వరుస & నిలువు వరుసల కోసం ఉపయోగించబడతాయి // తరువాత, మేము ఈ హార్డ్ కోడెడ్ విలువను మరింత సమర్థవంతంగా ఉపయోగిస్తాము // ఇది చదవడానికి లూప్ కాలమ్ (యాక్షన్ కీవర్డ్) అడ్డు వరుస యొక్క విలువలు అడ్డు వరుస ద్వారా // దీని అర్థం టెస్ట్ స్టెప్స్ షీట్‌లో టెస్ట్ కేసు కోసం పేర్కొన్న అన్ని దశలను ఈ లూప్ అమలు చేస్తుంది (int iRow = 1iRow<=7iRow++) { sActions = ReadExcelData.getCellData(iRow, 1) //A new separate method is created with the name 'execute_Actions' //You will find this method below of the this test //So this statement is doing nothing but calling that piece of code to execute execute_Actions() } } //This method contains the code to perform some action //As it is completely different set of logic, which revolves around the action only, it makes sense to keep it separate from the main driver script //This is to execute test step (Action) private static void execute_Actions() throws Exception { //Here we are instantiating a new object of class 'Actions' actionKeywords = new Actions() //This will load all the methods of the class 'Actions' in it. //It will be like array of method, use the break point here and do the watch method = actionKeywords.getClass().getMethods() //This is a loop which will run for the number of actions in the Action Keyword class //method variable contain all the method and method.length returns the total number of methods for(int i = 0i
డేటా నడిచే, కీవర్డ్ నడిచే & హైబ్రిడ్ నడిచే ఫ్రేమ్‌వర్క్‌ల యొక్క ఈ భావనను బాగా అర్థం చేసుకోవడానికి, ఈ క్రింది వీడియోను చూడమని నేను మిమ్మల్ని అభ్యర్థిస్తున్నాను.
 
 జావా ఉపయోగించి సెలీనియం ముసాయిదా | సెలీనియం ట్యుటోరియల్ | సెలీనియం శిక్షణ ఆన్‌లైన్ 
  
ఈ బ్లాగ్ మీకు ఉపయోగపడిందని మరియు సెలీనియం ఫ్రేమ్‌వర్క్ అంటే ఏమిటి, ఇది ఎలా ప్రయోజనకరంగా ఉంటుంది మరియు ఈ 3 సెలీనియం ఫ్రేమ్‌వర్క్‌లను ఉపయోగించి మీ కోడ్ నిర్మాణాన్ని ఎలా నిర్మించాలో మీకు స్పష్టమైన అవగాహన ఇచ్చిందని నేను ఆశిస్తున్నాను. ఈ శ్రేణిలోని మరిన్ని బ్లాగులకు అనుగుణంగా ఉండండి.
 మీరు సెలీనియం నేర్చుకోవాలనుకుంటే మరియు పరీక్షా డొమైన్‌లో వృత్తిని నిర్మించాలనుకుంటే, మా ఇంటరాక్టివ్, లైవ్-ఆన్‌లైన్‌ను చూడండి    ఇక్కడ, మీ అభ్యాస వ్యవధిలో మీకు మార్గనిర్దేశం చేయడానికి 24 * 7 మద్దతుతో వస్తుంది. “సెలీనియం ఫ్రేమ్‌వర్క్” కి సంబంధించిన అంశాలు ఎడురేకా కోర్సులో లోతైన కవరేజీని కలిగి ఉన్నాయి. 
 మాకు ప్రశ్న ఉందా? దయచేసి దీన్ని వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము మిమ్మల్ని సంప్రదిస్తాము.