แตงกวา - คู่มือฉบับย่อ

เพื่อให้ได้รับประโยชน์จากการทดสอบซอฟต์แวร์มากขึ้นปัจจุบันองค์กรต่างๆกำลังก้าวไปข้างหน้า พวกเขาใช้สถานการณ์จำลองการทดสอบการยอมรับที่สำคัญในขณะที่การพัฒนาอยู่ระหว่างดำเนินการ วิธีนี้เป็นที่รู้จักกันทั่วไปว่าBehavior Driven Development (BDD).

การพัฒนาที่ขับเคลื่อนด้วยพฤติกรรมเปิดโอกาสให้เราสร้างสคริปต์ทดสอบจากทั้งมุมมองของผู้พัฒนาและลูกค้าเช่นกัน ดังนั้นในการเริ่มต้นนักพัฒนาผู้จัดการโครงการ QAs ผู้ทดสอบการยอมรับของผู้ใช้และเจ้าของผลิตภัณฑ์ (ผู้ถือหุ้น) ทุกคนจะรวมตัวกันและระดมความคิดว่าควรผ่านสถานการณ์ทดสอบใดเพื่อให้ซอฟต์แวร์ / แอปพลิเคชันนี้ประสบความสำเร็จ ด้วยวิธีนี้พวกเขาสร้างชุดสถานการณ์ทดสอบ สคริปต์ทดสอบทั้งหมดนี้เป็นภาษาอังกฤษที่เรียบง่ายดังนั้นจึงมีจุดประสงค์ในการจัดทำเอกสารด้วย

ตัวอย่าง

หากเรากำลังพัฒนาคุณลักษณะการพิสูจน์ตัวตนผู้ใช้สิ่งต่อไปนี้อาจเป็นสถานการณ์การทดสอบที่สำคัญบางอย่างซึ่งจำเป็นต้องผ่านเพื่อเรียกว่าประสบความสำเร็จ

ผู้ใช้ควรสามารถเข้าสู่ระบบด้วยชื่อผู้ใช้ที่ถูกต้องและรหัสผ่านที่ถูกต้อง
ผู้ใช้ไม่ควรเข้าสู่ระบบด้วยชื่อผู้ใช้ที่ไม่ถูกต้องและรหัสผ่านที่ถูกต้อง
ผู้ใช้ไม่ควรเข้าสู่ระบบด้วยชื่อผู้ใช้ที่ถูกต้องและรหัสผ่านไม่ถูกต้อง

มันทำงานอย่างไร

เมื่อโค้ดพร้อมสคริปต์ทดสอบก็พร้อมเช่นกัน รหัสต้องผ่านสคริปต์ทดสอบที่กำหนดไว้ใน BDD หากไม่เกิดขึ้นจำเป็นต้องมีการปรับโครงสร้างโค้ดใหม่ โค้ดจะถูกตรึงหลังจากเรียกใช้สคริปต์ทดสอบที่กำหนดสำเร็จแล้วเท่านั้น

มันเป็นแนวคิดที่ง่ายมาก แต่สิ่งที่เราต้องการเพื่อให้แนวคิดนี้ถูกนำไปใช้ คำตอบคือ Behavior Driven Development (BDD) Framework แตงกวาเป็นหนึ่งในเครื่องมือโอเพนซอร์สที่สนับสนุนการพัฒนาที่ขับเคลื่อนด้วยพฤติกรรม เพื่อให้แม่นยำยิ่งขึ้น Cucumber สามารถกำหนดเป็นกรอบการทดสอบโดยใช้ข้อความภาษาอังกฤษธรรมดา ทำหน้าที่เป็นเอกสารการทดสอบอัตโนมัติและตัวช่วยในการพัฒนาทั้งหมดในที่เดียว

แตงกวาทำอะไร? สามารถอธิบายได้ตามขั้นตอนต่อไปนี้ -

แตงกวาอ่านโค้ดที่เขียนด้วยข้อความภาษาอังกฤษธรรมดา (ภาษา Gherkin - ที่จะแนะนำต่อไปในบทช่วยสอนนี้) ในไฟล์คุณลักษณะ (จะแนะนำในภายหลัง)

พบการจับคู่ที่ตรงกันของแต่ละขั้นตอนในข้อกำหนดขั้นตอน (ไฟล์รหัส - รายละเอียดที่ให้ไว้ในบทช่วยสอน)

ส่วนของโค้ดที่จะดำเนินการอาจเป็นเฟรมเวิร์กซอฟต์แวร์ที่แตกต่างกันเช่น Selenium, Ruby on Railsฯลฯ ไม่ใช่ทุกเครื่องมือ BDD framework ที่รองรับทุกเครื่องมือ

นี่กลายเป็นสาเหตุที่ทำให้แตงกวาได้รับความนิยมมากกว่ากรอบอื่น ๆ เช่น JBehave, JDave, Easyb, เป็นต้น

Cucumber รองรับแพลตฟอร์มซอฟต์แวร์ที่แตกต่างกันมากกว่าโหลเช่น -

ทับทิมบนราง
Selenium
PicoContainer
กรอบสปริง
Watir

ข้อดีของแตงกวาเหนือเครื่องมืออื่น ๆ

Cucumber รองรับภาษาต่างๆเช่น Java.net และ Ruby
ทำหน้าที่เป็นสะพานเชื่อมระหว่างภาษาทางธุรกิจและทางเทคนิค เราทำได้โดยสร้างกรณีทดสอบเป็นข้อความภาษาอังกฤษธรรมดา
อนุญาตให้เขียนสคริปต์ทดสอบโดยไม่มีความรู้เกี่ยวกับโค้ดใด ๆ ทำให้สามารถมีส่วนร่วมของผู้ที่ไม่ใช่โปรแกรมเมอร์ได้เช่นกัน
มันตอบสนองวัตถุประสงค์ของกรอบการทดสอบ end-to-end ซึ่งแตกต่างจากเครื่องมืออื่น ๆ
เนื่องจากสถาปัตยกรรมสคริปต์ทดสอบที่เรียบง่าย Cucumber จึงสามารถนำโค้ดกลับมาใช้ใหม่ได้

ในบทนี้เราจะเห็นการตั้งค่าสภาพแวดล้อมสำหรับ Cucumber ด้วย Selenium WebDriver และ Java บน Windows Machine

ข้อกำหนดเบื้องต้นสำหรับการตั้งค่าสภาพแวดล้อม

ต่อไปนี้เป็นข้อกำหนดเบื้องต้นที่จำเป็นในการตั้งค่าด้วย -

Java

Why we need- Java เป็นภาษาโปรแกรมที่มีประสิทธิภาพ Cucumber รองรับแพลตฟอร์ม Java สำหรับการดำเนินการ

How to install -

Step 1 - ดาวน์โหลด jdk และ jre จากลิงค์ต่อไปนี้ http://www.oracle.com/technetwork/java/javase/downloads/index.html

Step 2 - ยอมรับข้อตกลงใบอนุญาต

Step 3 - ติดตั้ง JDK และ JRE

Step 4 - ตั้งค่าตัวแปรสภาพแวดล้อมดังที่แสดงในภาพหน้าจอต่อไปนี้

คราส

Why we need- Eclipse คือ Integrated Development Environment (IDE) ประกอบด้วยพื้นที่ทำงานพื้นฐานและระบบปลั๊กอินที่ขยายได้สำหรับการปรับแต่งสภาพแวดล้อม

How to install -

Step 1 - ตรวจสอบให้แน่ใจว่าได้ติดตั้ง JAVA บนเครื่องของคุณแล้ว

Step 2 - ดาวน์โหลด Eclipse จาก https://eclipse.org/downloads/

Step 3 - ติดตั้ง Unzip และ Eclipse แล้ว

Maven

Why we need- Maven เป็นเครื่องมือสร้างระบบอัตโนมัติที่ใช้สำหรับโปรเจ็กต์ Java เป็นหลัก มันเป็นแพลตฟอร์มทั่วไปในการทำกิจกรรมต่างๆเช่นการสร้างซอร์สโค้ดการคอมไพล์โค้ดโค้ดแพ็กเกจลงใน jar เป็นต้นหลังจากนั้นหากเวอร์ชันซอฟต์แวร์ใด ๆ มีการเปลี่ยนแปลง Maven จะให้วิธีง่ายๆในการปรับเปลี่ยนโปรเจ็กต์ทดสอบให้เหมาะสม

How to install -

Step 1 - ดาวน์โหลด Maven จากลิงค์ต่อไปนี้ - https://maven.apache.org/download.cgi

Step 2 - คลายซิปไฟล์และจำตำแหน่ง

Step 3 - สร้างตัวแปรสภาพแวดล้อม MAVEN_HOME ดังที่แสดงในภาพหน้าจอต่อไปนี้

Step 4 - แก้ไขตัวแปร Path และรวม Maven ดังที่แสดงในภาพหน้าจอต่อไปนี้

Step 5 - ดาวน์โหลดปลั๊กอิน MAVEN จาก Eclipse

Step 6 - เปิด Eclipse

Step 7 - ไปที่ Help → Eclipse Marketplace → Search Maven → Maven Integration for Eclipse → INSTALL

กำหนดค่าแตงกวาด้วย Maven

Step 1 - สร้างโครงการ Maven

ไปที่ไฟล์→ใหม่→อื่น ๆ → Maven → Maven Project →ถัดไป
ระบุรหัสกลุ่ม (รหัสกลุ่มจะระบุโครงการของคุณโดยไม่ซ้ำกันในทุกโครงการ)
ระบุรหัสสิ่งประดิษฐ์ (รหัสวัตถุคือชื่อของ jar ที่ไม่มีเวอร์ชันคุณสามารถเลือกชื่อใดก็ได้ซึ่งเป็นตัวพิมพ์เล็ก) คลิกที่ Finish

Step 2 - เปิด pom.xml

ไปที่ package explorer ทางซ้ายมือของ Eclipse
ขยายโครงการ CucumberTest.
ค้นหา pom.xml ไฟล์.
คลิกขวาและเลือกตัวเลือกเปิดด้วย“ Text Editor”

Step 3 - เพิ่มการพึ่งพาสำหรับซีลีเนียม: สิ่งนี้จะระบุ Maven ว่าจะดาวน์โหลดไฟล์ Selenium jar ใดจากที่เก็บส่วนกลางไปยังที่เก็บในเครื่อง

เปิด pom.xml อยู่ในโหมดแก้ไขสร้างแท็กการอ้างอิง (<dependencies> </dependencies>) ภายในแท็กโปรเจ็กต์
ภายในแท็กการอ้างอิงให้สร้างแท็กการพึ่งพา (<dependency> </dependency>)
ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>org.seleniumhq.selenium</groupId> 
   <artifactId>selenium-java</artifactId> 
   <version>2.47.1</version> 
</dependency>

Step 4 - เพิ่มการพึ่งพาสำหรับ Cucumber-Java: สิ่งนี้จะระบุ Maven ซึ่งไฟล์ Cucumber จะถูกดาวน์โหลดจากที่เก็บส่วนกลางไปยังที่เก็บในเครื่อง

สร้างแท็กการอ้างอิงขึ้นมาอีกหนึ่งแท็ก
ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>info.cukes</groupId>
   <artifactId>cucumber-java</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

Step 5 - เพิ่มการพึ่งพาสำหรับ Cucumber-JUnit: สิ่งนี้จะระบุ Maven ซึ่งไฟล์ Cucumber JUnit จะถูกดาวน์โหลดจากที่เก็บกลางไปยังที่เก็บในเครื่อง

สร้างแท็กการอ้างอิงขึ้นมาอีกหนึ่งแท็ก
ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-junit</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

Step 6 - เพิ่มการพึ่งพาสำหรับ JUnit: สิ่งนี้จะระบุ Maven ซึ่งไฟล์ JUnit จะถูกดาวน์โหลดจากที่เก็บส่วนกลางไปยังที่เก็บในเครื่อง

สร้างแท็กการอ้างอิงขึ้นมาอีกหนึ่งแท็ก
ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>

Step 7 - ตรวจสอบไบนารี

ครั้งเดียว pom.xml แก้ไขเรียบร้อยแล้วให้บันทึก
ไปที่ Project → Clean - จะใช้เวลาสักครู่

คุณจะสามารถเห็นที่เก็บ Maven ดังที่แสดงในภาพหน้าจอต่อไปนี้

สร้างไฟล์คุณลักษณะ (จะกล่าวถึงในภายหลัง)
สร้างไฟล์ข้อกำหนดขั้นตอน (จะกล่าวถึงในภายหลัง)
สร้าง JUnit runner เพื่อเรียกใช้การทดสอบ (จะครอบคลุมในภายหลัง)

จนถึงตอนนี้เรามีความเข้าใจเกี่ยวกับแตงกวาและทำหน้าที่อะไร เรียกใช้สคริปต์ทดสอบซึ่งกำหนดไว้ในไฟล์คุณลักษณะ (จะกล่าวถึงในบทต่อ ๆ ไป) ภาษาที่เขียนไฟล์คุณลักษณะที่เรียกใช้งานได้นี้เรียกว่าGherkin. Gherkin เป็นภาษาข้อความภาษาอังกฤษธรรมดาซึ่งช่วยให้เครื่องมือ - Cucumber แปลความหมายและเรียกใช้สคริปต์ทดสอบ

อาจมีคนคิดว่ามีการพูดคุยกันหลายครั้งว่าแตงกวารองรับข้อความภาษาอังกฤษง่ายๆแล้วทำไมเราต้องใช้ภาษาแยกต่างหาก - Gherkins คำตอบอยู่ในแนวคิดของการพัฒนาพฤติกรรมที่ขับเคลื่อน

ดังที่ได้กล่าวไว้ก่อนหน้านี้เราได้เห็นว่า BDD รวมเอาผู้มุ่งหวังที่แตกต่างกันในขณะที่สร้างสคริปต์ทดสอบ อาจเป็นผู้มุ่งหวังในการพัฒนาผู้มุ่งหวังทางธุรกิจ ฯลฯ กล่าวได้ว่าเราต้องการผู้คนจากชุมชนที่แตกต่างกันเช่นนักพัฒนาผู้จัดการโครงการเจ้าของผลิตภัณฑ์และผู้ทดสอบในขณะที่พัฒนาสคริปต์การทดสอบ เนื่องจากบุคคลเหล่านี้ไม่ได้อยู่ในหมวดหมู่เดียวกันจึงมีความเสี่ยงที่จะไม่ใช้ภาษากลางในการกำหนดแนวคิดของสคริปต์ทดสอบ นี่คือจุดวิวัฒนาการของ Gherkins

Gherkin จัดเตรียมชุดคำหลักทั่วไปในข้อความภาษาอังกฤษซึ่งผู้คนในชุมชนต่าง ๆ สามารถใช้ได้และยังได้ผลลัพธ์เดียวกันในรูปแบบของสคริปต์ทดสอบ

ตัวอย่าง

Feature - เข้าสู่ระบบสำหรับเว็บไซต์เครือข่ายสังคม Given ฉันเป็นผู้ใช้ไซต์เครือข่ายสังคม When ฉันป้อนชื่อผู้ใช้เป็นชื่อผู้ใช้ 1 And ฉันป้อนรหัสผ่านเป็นรหัสผ่าน 1. Then ฉันควรถูกเปลี่ยนเส้นทางไปที่หน้าแรกของไซต์

สถานการณ์ดังกล่าวข้างต้นเป็นคุณลักษณะที่เรียกว่าการเข้าสู่ระบบของผู้ใช้ คำทั้งหมดที่เน้นเป็นตัวหนาคือคีย์เวิร์ด Gherkin

ตัวอย่างคำหลักอื่น ๆ -

Background
But
*
เค้าโครงสถานการณ์
Examples

Gherkin จะแยกวิเคราะห์แต่ละขั้นตอนที่เขียนในไฟล์การกำหนดขั้นตอน (จะกล่าวถึงในภายหลัง) ดังนั้นขั้นตอนที่กล่าวถึงในไฟล์คุณลักษณะและไฟล์ข้อกำหนดขั้นตอน (ที่จะกล่าวถึงในภายหลัง) ควรตรงกัน

คุณสามารถค้นหาขวด Gherkin ในโฟลเดอร์ Maven Dependency ใน Package Explorer มันจะดาวน์โหลดพร้อมกับขวดแตงกวาอื่น ๆ จะมีลักษณะเหมือนภาพหน้าจอต่อไปนี้ -

ข้อเท็จจริงที่น่าสนใจอีกประการหนึ่งเกี่ยวกับ Gherkin ก็คือไม่เพียง แต่รองรับภาษาอังกฤษเท่านั้น แต่ยังมีภาษาพื้นเมืองอื่น ๆ อีกมากมายเช่นฝรั่งเศสฟินแลนด์ชาวอินโดนีเซียฮังการีฮินดีอูรดูคุชราตเป็นต้น

ก Featureสามารถกำหนดเป็นหน่วยแบบสแตนด์อโลนหรือฟังก์ชันของโครงการ ลองมาดูตัวอย่างเว็บไซต์เครือข่ายสังคมออนไลน์ คุณลักษณะของผลิตภัณฑ์ / โครงการนี้มีลักษณะอย่างไร? คุณสมบัติพื้นฐานบางประการสามารถกำหนดได้ดังนี้ -

สร้างและลบผู้ใช้ออกจากไซต์เครือข่ายสังคม
ฟังก์ชันการเข้าสู่ระบบของผู้ใช้สำหรับไซต์เครือข่ายสังคม
การแบ่งปันภาพถ่ายหรือวิดีโอบนเว็บไซต์เครือข่ายสังคม
ส่งคำขอเป็นเพื่อน
Logout.

ถึงตอนนี้เป็นที่ชัดเจนแล้วว่าฟังก์ชันการทำงานที่เป็นอิสระแต่ละอย่างของผลิตภัณฑ์ที่อยู่ระหว่างการทดสอบสามารถเรียกได้ว่าเป็นคุณลักษณะเมื่อเราพูดถึงแตงกวา เป็นแนวทางปฏิบัติที่ดีที่สุดในภายหลังเมื่อคุณเริ่มการทดสอบว่าก่อนที่จะได้รับสคริปต์ทดสอบเราควรกำหนดคุณสมบัติที่จะทดสอบ

โดยปกติแล้วคุณลักษณะจะมีรายการสถานการณ์ที่จะทดสอบสำหรับคุณลักษณะนั้น ไฟล์ที่เราเก็บคุณลักษณะคำอธิบายเกี่ยวกับคุณลักษณะและสถานการณ์ที่จะทดสอบเรียกว่าไฟล์Feature File. เราจะดูเพิ่มเติมเกี่ยวกับไฟล์คุณสมบัติในบทต่อไปนี้

คำสำคัญที่ใช้แสดงคุณลักษณะที่อยู่ระหว่างการทดสอบใน Gherkins คือ“ คุณลักษณะ” แนวทางปฏิบัติที่ดีที่สุดที่แนะนำคือเขียนคำอธิบายเล็ก ๆ ของคุณลักษณะไว้ใต้ชื่อคุณลักษณะในไฟล์คุณลักษณะ สิ่งนี้จะตอบสนองความต้องการของเอกสารที่ดีเช่นกัน

ตัวอย่าง

Feature - เข้าสู่ระบบสำหรับเว็บไซต์เครือข่ายสังคม

ผู้ใช้ควรจะสามารถเข้าสู่เว็บไซต์เครือข่ายสังคมได้หากชื่อผู้ใช้และรหัสผ่านถูกต้อง

ผู้ใช้ควรจะแสดงข้อความแสดงข้อผิดพลาดหากชื่อผู้ใช้และรหัสผ่านไม่ถูกต้อง

ผู้ใช้ควรเข้าสู่โฮมเพจหากชื่อผู้ใช้และรหัสผ่านถูกต้อง

ไฟล์คุณลักษณะ

ไฟล์ที่เขียนการทดสอบแตงกวาเรียกว่าไฟล์ feature files. ขอแนะนำว่าควรมีไฟล์ฟีเจอร์แยกต่างหากสำหรับแต่ละฟีเจอร์ที่อยู่ระหว่างการทดสอบ นามสกุลของไฟล์ฟีเจอร์ต้องเป็น“ .feature”

หนึ่งสามารถสร้างไฟล์คุณสมบัติได้มากเท่าที่ต้องการ เพื่อให้มีโครงสร้างที่เป็นระเบียบแต่ละฟีเจอร์ควรมีไฟล์ฟีเจอร์เดียว

ตัวอย่างเช่น -

ซีเนียร์ No	ลักษณะเฉพาะ	ชื่อไฟล์คุณลักษณะ
1	เข้าสู่ระบบผู้ใช้	userLogin.feature
2	แบ่งปันโพสต์	sharePost.feature
3	สร้างบัญชี	createAccount.feature
4	ลบบัญชี	deleteAccount.feature

หลักการตั้งชื่อที่จะใช้สำหรับชื่อฟีเจอร์ชื่อไฟล์ฟีเจอร์ขึ้นอยู่กับการเลือกของแต่ละคน แตงกวาไม่มีกฎพื้นฐานเกี่ยวกับชื่อ

ไฟล์คุณสมบัติอย่างง่ายประกอบด้วยคำสำคัญ / ส่วนต่างๆต่อไปนี้ -

Feature - ชื่อของคุณสมบัติที่อยู่ระหว่างการทดสอบ
Description (ไม่บังคับ) - อธิบายเกี่ยวกับคุณลักษณะที่อยู่ระหว่างการทดสอบ
Scenario - สถานการณ์ทดสอบคืออะไร
Given - สิ่งที่จำเป็นต้องมีก่อนที่จะดำเนินการขั้นตอนการทดสอบ
When - เงื่อนไขเฉพาะที่ควรตรงกันเพื่อดำเนินการขั้นต่อไป
Then - จะเกิดอะไรขึ้นถ้าเงื่อนไขที่กล่าวถึงเมื่อพอใจ

ตัวอย่าง

Feature - ผู้ใช้เข้าสู่ระบบบนเว็บไซต์เครือข่ายสังคม

ผู้ใช้ควรสามารถเข้าสู่เว็บไซต์เครือข่ายสังคมได้เมื่อชื่อผู้ใช้และรหัสผ่านถูกต้อง

ผู้ใช้ควรจะแสดงข้อความแสดงข้อผิดพลาดเมื่อชื่อผู้ใช้และรหัสผ่านไม่ถูกต้อง

ผู้ใช้ควรถูกนำทางไปยังโฮมเพจหากชื่อผู้ใช้และรหัสผ่านถูกต้อง

Outline - เข้าสู่ระบบสำหรับเว็บไซต์เครือข่ายสังคม

ผู้ใช้ที่ระบุไปที่ Facebook เมื่อฉันป้อนชื่อผู้ใช้เป็น "<username>" และรหัสผ่านเป็น "<password>" จากนั้นการเข้าสู่ระบบจะไม่สำเร็จ

| username  | password  |
| username1 | password1 |

* AND คำสำคัญใช้เพื่อแสดงการเชื่อมโยงระหว่างสองเงื่อนไข AND สามารถใช้กับคำหลักอื่น ๆ เช่น GIVEN, WHEN และ THEN.

ไม่มีรายละเอียดตรรกะที่เขียนไว้ในไฟล์คุณลักษณะ

คำจำกัดความของขั้นตอน

เรามีไฟล์คุณลักษณะของเราพร้อมสำหรับสถานการณ์การทดสอบที่กำหนดไว้ อย่างไรก็ตามนี่ไม่ใช่งานที่เสร็จสมบูรณ์ แตงกวาไม่รู้จริงๆว่าจะใช้โค้ดส่วนไหนสำหรับสถานการณ์เฉพาะใด ๆ ที่ระบุไว้ในไฟล์ฟีเจอร์

สิ่งนี้เรียกความต้องการของไฟล์ระดับกลาง - คำจำกัดความขั้นตอน ไฟล์ข้อกำหนดขั้นตอนจะจัดเก็บการแม็ประหว่างแต่ละขั้นตอนของสถานการณ์จำลองที่กำหนดไว้ในไฟล์คุณลักษณะพร้อมด้วยรหัสของฟังก์ชันที่จะดำเนินการ

ดังนั้นเมื่อ Cucumber ดำเนินการตามขั้นตอนของสถานการณ์ที่กล่าวถึงในไฟล์คุณลักษณะจะสแกนไฟล์ข้อกำหนดขั้นตอนและดูว่าจะเรียกใช้ฟังก์ชันใด

ตัวอย่างไฟล์นิยามขั้นตอน

public void goToFacebook() { 
   driver = new FirefoxDriver(); 
   driver.navigate().to("https://www.facebook.com/"); 
} 
@When "^user logs in using Username as \"([^\"]*)\" and Password as \"([^\"]*)\"$" public void I_enter_Username_as_and_Password_as(String arg1, String arg2) { driver.findElement(By.id("email")).sendKeys(arg1); driver.findElement(By.id("pass")).sendKeys(arg2); driver.findElement(By.id("u_0_v")).click(); } @Then"^login should be unsuccessful$" 
public void validateRelogin() { 
   if(driver.getCurrentUrl().equalsIgnoreCase(
      "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){ 
         System.out.println("Test Pass");
   } else { 
      System.out.println("Test Failed"); 
   } 
   driver.close(); 
}

ดังนั้นด้วยแต่ละฟังก์ชั่นรหัสใดก็ตามที่คุณต้องการดำเนินการกับแต่ละขั้นตอนการทดสอบ (เช่น GIVEN / THEN / WHEN) คุณสามารถเขียนได้ในไฟล์ Step Definition ตรวจสอบให้แน่ใจว่าได้กำหนดรหัส / ฟังก์ชันสำหรับแต่ละขั้นตอนแล้ว

ฟังก์ชันนี้สามารถเป็นฟังก์ชัน Java ซึ่งเราสามารถใช้ทั้งคำสั่ง Java และ Selenium เพื่อทำให้ขั้นตอนการทดสอบของเราเป็นไปโดยอัตโนมัติ

Scenarioเป็นหนึ่งในโครงสร้างหลักของ Gherkin ทุกสถานการณ์เริ่มต้นด้วยคำหลัก“ สถานการณ์:” (หรือแปลเป็นภาษาท้องถิ่น) และตามด้วยชื่อสถานการณ์ที่เป็นทางเลือก แต่ละคุณลักษณะสามารถมีหนึ่งสถานการณ์ขึ้นไปและทุกสถานการณ์ประกอบด้วยหนึ่งขั้นตอนหรือมากกว่านั้น ตัวอย่างง่ายๆของสถานการณ์สามารถ -

Scenario - ตรวจสอบการทำงานของวิธีใช้

กำหนดให้ผู้ใช้ไปที่ Facebook

เมื่อผู้ใช้คลิกที่วิธีใช้หน้าวิธีใช้จะเปิดขึ้น

พิจารณากรณีที่เราจำเป็นต้องดำเนินการสถานการณ์ทดสอบมากกว่าหนึ่งครั้ง สมมติว่าเราต้องตรวจสอบให้แน่ใจว่าฟังก์ชันการเข้าสู่ระบบใช้งานได้สำหรับผู้สมัครสมาชิกทุกประเภท ที่ต้องดำเนินการสถานการณ์จำลองฟังก์ชันการเข้าสู่ระบบหลายครั้ง คัดลอกวางขั้นตอนเดียวกันเพื่อเรียกใช้โค้ดซ้ำดูเหมือนจะไม่ใช่ความคิดที่ชาญฉลาด สำหรับสิ่งนี้ Gherkin มีโครงสร้างอีกหนึ่งโครงสร้างซึ่งเป็นโครงร่างสถานการณ์

โครงร่างสถานการณ์คล้ายกับโครงสร้างสถานการณ์ ข้อแตกต่างเพียงอย่างเดียวคือการจัดหาอินพุตหลายตัว ดังที่คุณเห็นในตัวอย่างต่อไปนี้กรณีทดสอบยังคงเหมือนเดิมและไม่สามารถทำซ้ำได้ ที่ด้านล่างเราได้ระบุค่าอินพุตหลายค่าสำหรับตัวแปร“ ชื่อผู้ใช้” และ“ รหัสผ่าน” ในขณะที่ทำการทดสอบจริงแตงกวาจะแทนที่ตัวแปรด้วยค่าอินพุตที่ให้มาและจะดำเนินการทดสอบ เมื่อดำเนินการผ่าน -1 แล้วการทดสอบจะรันซ้ำสำหรับการทำซ้ำครั้งที่สองพร้อมกับค่าอินพุตอื่น ตัวแปรหรือตัวยึดตำแหน่งดังกล่าวสามารถแสดงด้วย "<>" ในขณะที่กล่าวถึงด้วยข้อความสีเหลือง

ตัวอย่าง

Scenario Outline- เข้าสู่ระบบสำหรับเว็บไซต์เครือข่ายสังคม ผู้ใช้ที่ระบุไปที่ Facebook

เมื่อผู้ใช้เข้าสู่ระบบโดยใช้ชื่อผู้ใช้เป็น "<username>" และรหัสผ่านเป็น "<password>" การเข้าสู่ระบบจะสำเร็จ

| username | password  | 
| user1    | password1 | 
| user2    | password2 |

มีเคล็ดลับและเทคนิคบางประการในการกำหนดสถานการณ์แตงกวาอย่างชาญฉลาด

แต่ละขั้นตอนควรกำหนดให้ชัดเจนเพื่อไม่ให้เกิดความสับสนแก่ผู้อ่าน
อย่าทำซ้ำสถานการณ์ทดสอบหากจำเป็นให้ใช้โครงร่างสถานการณ์เพื่อใช้การทำซ้ำ
พัฒนาขั้นตอนการทดสอบในลักษณะที่สามารถใช้ได้ภายในสถานการณ์และโครงร่างสถานการณ์ต่างๆ
เท่าที่จะทำได้ให้แต่ละขั้นตอนเป็นอิสระอย่างสมบูรณ์ ตัวอย่างเช่น“ ให้ผู้ใช้เข้าสู่ระบบ” ซึ่งสามารถแบ่งออกเป็นสองขั้นตอน
- กำหนดให้ผู้ใช้ป้อนชื่อผู้ใช้
- คลิกที่เข้าสู่ระบบ

Annotationเป็นข้อความที่กำหนดไว้ล่วงหน้าซึ่งมีความหมายเฉพาะ ช่วยให้คอมไพเลอร์ / ล่ามทราบสิ่งที่ควรทำเมื่อดำเนินการ แตงกวามีคำอธิบายประกอบสองสามข้อต่อไปนี้ -

Given -
- อธิบายถึงข้อกำหนดเบื้องต้นสำหรับการทดสอบที่จะดำเนินการ
- ตัวอย่าง - GIVEN ฉันเป็นผู้ใช้ Facebook
When -
- เป็นการกำหนดจุดทริกเกอร์สำหรับการดำเนินการในสถานการณ์ทดสอบใด ๆ
- ตัวอย่าง - เมื่อฉันป้อน "<username>"
Then -
- จากนั้นเก็บผลลัพธ์ที่คาดไว้สำหรับการทดสอบที่จะดำเนินการ
- ตัวอย่าง - จากนั้นการเข้าสู่ระบบควรจะสำเร็จ
And -
- มีเงื่อนไขและตรรกะระหว่างสองคำสั่งใด ๆ และสามารถใช้ร่วมกับคำสั่ง GIVEN, WHEN และ THEN ได้
- ตัวอย่าง - เมื่อฉันป้อน "<username>" ของฉันและฉันป้อน "<password>" ของฉัน
But -
- หมายถึงตรรกะหรือเงื่อนไขระหว่างสองคำสั่งใด ๆ หรือสามารถใช้ร่วมกับคำสั่ง GIVEN, WHEN และ THEN ได้
- ตัวอย่าง - จากนั้นการเข้าสู่ระบบควรจะสำเร็จ แต่ไม่ควรพลาดโฮมเพจ
Scenario -
- ต้องบันทึกรายละเอียดเกี่ยวกับสถานการณ์จำลองภายใต้การทดสอบหลังคำหลัก "สถานการณ์:"
- ตัวอย่าง -
  
  สถานการณ์:
  
  GIVEN ฉันเป็นผู้ใช้ Facebook
  
  เมื่อฉันป้อนไฟล์
  
  และฉันป้อนไฟล์
  
  จากนั้นการเข้าสู่ระบบควรจะสำเร็จ
  
  แต่ไม่ควรพลาดโฮมเพจ
Scenario Outline - (จะกล่าวถึงภายหลัง)
Examples - (จะกล่าวถึงภายหลัง)
Background -
- พื้นหลังโดยทั่วไปมีคำแนะนำเกี่ยวกับสิ่งที่ต้องตั้งค่าก่อนที่แต่ละสถานการณ์จะดำเนินไป อย่างไรก็ตามมันจะถูกดำเนินการหลังจากขอเกี่ยว "ก่อน" (จะครอบคลุมในภายหลัง) ดังนั้นจึงเหมาะอย่างยิ่งที่จะใช้เป็นรหัสเมื่อเราต้องการตั้งค่าเว็บเบราว์เซอร์หรือเราต้องการสร้างการเชื่อมต่อฐานข้อมูล
  - ตัวอย่าง -
    
    พื้นหลัง:
    
    ไปที่หน้าแรกของ Facebook

สถานการณ์ตัวอย่าง

มาสร้างสถานการณ์โดยอัตโนมัติเพื่อให้เข้าใจคำอธิบายประกอบได้ดีขึ้น

Step 1

สร้างโครงการทดสอบ Maven ที่มีชื่อว่า AnnotationTest.

ไปที่ไฟล์→ใหม่→อื่น ๆ → Maven → Maven Project →ถัดไป
ระบุรหัสกลุ่ม (รหัสกลุ่มจะระบุโครงการของคุณโดยไม่ซ้ำกันในทุกโครงการ)
ระบุรหัสสิ่งประดิษฐ์ (รหัสวัตถุคือชื่อของ jar ที่ไม่มีเวอร์ชันคุณสามารถเลือกชื่อใดก็ได้ที่เป็นตัวพิมพ์เล็ก)
คลิกที่ Finish
เปิด pom.xml −
- ไปที่ package explorer ทางซ้ายมือของ Eclipse
- ขยายโครงการ AnnotationTest
- ค้นหาไฟล์ pom.xml
- คลิกขวาและเลือกตัวเลือกเปิดด้วย“ โปรแกรมแก้ไขข้อความ”
เพิ่มการพึ่งพาสำหรับ Selenium - สิ่งนี้จะระบุ Maven ซึ่งจะต้องดาวน์โหลดไฟล์ Selenium jar จากที่เก็บส่วนกลางไปยังที่เก็บในเครื่อง
- เปิด pom.xml อยู่ในโหมดแก้ไขสร้างแท็กการอ้างอิง (<dependencies> </dependencies>) ภายในแท็กโปรเจ็กต์
- ภายในแท็กการอ้างอิงให้สร้างแท็กการพึ่งพา (<dependency> </dependency>)
- ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>org.seleniumhq.selenium</groupId> 
   <artifactId>selenium-java</artifactId> 
   <version>2.47.1</version> 
</dependency>

เพิ่มการพึ่งพาสำหรับ Cucumber-Java - สิ่งนี้จะระบุ Maven ซึ่งไฟล์ Cucumber จะถูกดาวน์โหลดจากที่เก็บส่วนกลางไปยังที่เก็บในเครื่อง
- สร้างแท็กการอ้างอิงขึ้นมาอีกหนึ่งแท็ก
- ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-java</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

เพิ่มการพึ่งพาสำหรับ Cucumber-JUnit - สิ่งนี้จะระบุ Maven ซึ่งจะต้องดาวน์โหลดไฟล์ Cucumber JUnit จากที่เก็บกลางไปยังที่เก็บในเครื่อง
- สร้างแท็กการอ้างอิงขึ้นมาอีกหนึ่งแท็ก
- ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-junit</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

เพิ่มการพึ่งพาสำหรับ JUnit - สิ่งนี้จะระบุ Maven ซึ่งไฟล์ JUnit จะถูกดาวน์โหลดจากที่เก็บส่วนกลางไปยังที่เก็บในเครื่อง
- สร้างแท็กการอ้างอิงขึ้นมาอีกหนึ่งแท็ก
- ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>

ตรวจสอบไบนารี
- เมื่อแก้ไข pom.xml สำเร็จแล้วให้บันทึก
- ไปที่ Project → Clean - จะใช้เวลาสักครู่

Step 2

สร้างแพ็คเกจชื่อ Annotation ภายใต้ src/test/java

เลือกโครงการที่สร้างขึ้นใหม่
คลิกขวาและเลือก 'ใหม่'
เลือกตัวเลือกเป็น 'แพ็คเกจ'
ตั้งชื่อเป็น "คำอธิบายประกอบ"
บันทึกไว้

Step 3

สร้างไฟล์ฟีเจอร์ชื่อ annotation.feature.

เลือกและคลิกขวาที่โครงร่างแพ็คเกจ
คลิกที่ไฟล์ 'New'
ตั้งชื่อไฟล์เช่น outline.feature.
เขียนข้อความต่อไปนี้ภายในไฟล์และบันทึก

Feature: annotation 
#This is how background can be used to eliminate duplicate steps 

Background: 
   User navigates to Facebook Given 
   I am on Facebook login page 

#Scenario with AND 
Scenario: 
   When I enter username as "TOM"
   And I enter password as "JERRY" 
   Then Login should fail 

#Scenario with BUT 
Scenario: 
   When I enter username as "TOM" 
   And I enter password as "JERRY" 
   Then Login should fail 
   But Relogin option should be available

Step 4

สร้างไฟล์ข้อกำหนดขั้นตอน

เลือกและคลิกขวาที่โครงร่างแพ็คเกจ
คลิกที่ไฟล์ 'New'
ตั้งชื่อไฟล์เป็น annotation.java
เขียนข้อความต่อไปนี้ภายในไฟล์และบันทึก

package Annotation; 

import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.firefox.FirefoxDriver; 

import cucumber.annotation.en.Given; 
import cucumber.annotation.en.Then; 
import cucumber.annotation.en.When; 

public class annotation { 
   WebDriver driver = null; 
   @Given("^I am on Facebook login page$") public void goToFacebook() { driver = new FirefoxDriver(); driver.navigate().to("https://www.facebook.com/"); } @When("^I enter username as \"(.*)\"$") 
   public void enterUsername(String arg1) {   
      driver.findElement(By.id("email")).sendKeys(arg1); 
   }
	
   @When ("^I enter password as \"(.*)\"$") public void enterPassword(String arg1) { driver.findElement(By.id("pass")).sendKeys(arg1); driver.findElement(By.id("u_0_v")).click(); } @Then("^Login should fail$") 
   public void checkFail() {  
      if(driver.getCurrentUrl().equalsIgnoreCase(
         "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){ 
            System.out.println("Test1 Pass"); 
      } else { 
         System.out.println("Test1 Failed"); 
      } 
      driver.close(); 
   } 
	
   @Then("^Relogin option should be available$") 
   public void checkRelogin() { 
      if(driver.getCurrentUrl().equalsIgnoreCase(
         "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){ 
            System.out.println("Test2 Pass"); 
      } else { 
         System.out.println("Test2 Failed"); 
      } 
      driver.close(); 
   }
}

Step 5

สร้างไฟล์คลาสนักวิ่ง

เลือกและคลิกขวาที่โครงร่างแพ็คเกจ
คลิกที่ไฟล์ 'New'
ตั้งชื่อไฟล์เช่น runTest.java
เขียนข้อความต่อไปนี้ภายในไฟล์และบันทึก

package Annotation; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"})
 
public class runTest { 
}

Step 6

ทำการทดสอบโดยใช้ตัวเลือก -

เลือกไฟล์ runTest.java จาก package explorer
คลิกขวาและเลือกตัวเลือก ‘Run as’
เลือก JUnit test

คุณจะสังเกตสิ่งต่อไปนี้เมื่อคุณเรียกใช้ไฟล์คลาสนี้ -

Facebook เปิดในอินสแตนซ์เว็บเบราว์เซอร์ Firefox ใหม่
TOM จะถูกส่งเป็นอินพุตไปยังฟิลด์ชื่อผู้ใช้
JERRY จะถูกส่งเป็นอินพุตไปยังฟิลด์รหัสผ่าน
เข้าสู่ระบบจะคลิก
ข้อความจะแสดงบนเบราว์เซอร์เกี่ยวกับการเข้าสู่ระบบที่ไม่สำเร็จ
ในคอนโซลคุณจะเห็น“ Test Pass” พิมพ์อยู่
ผลลัพธ์ขั้นที่ 1. ถึง 5. จะถูกเรียกใช้งานอีกครั้งสำหรับชื่อผู้ใช้เป็น "" และรหัสผ่านเป็น ""

Scenario outlineโดยทั่วไปจะแทนที่ตัวแปร / คำหลักด้วยค่าจากตาราง แต่ละแถวในตารางถือเป็นสถานการณ์สมมติ

มาดูตัวอย่างฟีเจอร์การเข้าสู่ระบบ Facebook กันต่อ จนถึงตอนนี้เราได้ดำเนินการสถานการณ์หนึ่ง: เมื่อระบุชื่อผู้ใช้ที่ถูกต้องการเข้าสู่ระบบจะสำเร็จ ตอนนี้สมมติว่าเราต้องการตรวจสอบว่าการเข้าสู่ระบบสำเร็จหรือไม่สำหรับอินพุตทั้งสามประเภทที่เป็นไปได้ซึ่ง ได้แก่ ชื่อผู้ใช้ที่อยู่อีเมลหรือหมายเลขโทรศัพท์ เพื่อให้บรรลุเป้าหมายนี้เราจะต้องเขียนสถานการณ์ที่แตกต่างกันสามสถานการณ์โดยแต่ละสถานการณ์จะแตกต่างกันไปตามประเภทของอินพุตการเข้าสู่ระบบจะสำเร็จ ในกรณีนี้สถานการณ์จะมีลักษณะดังต่อไปนี้

Scenario:

กำหนดให้ผู้ใช้ไปที่ Facebook

เมื่อฉันป้อนชื่อผู้ใช้และรหัสผ่านที่ถูกต้อง

จากนั้นเข้าสู่ระบบควรจะสำเร็จ

Scenario:

กำหนดให้ผู้ใช้ไปที่ Facebook

เมื่อฉันป้อนที่อยู่อีเมลและรหัสผ่านที่ถูกต้อง

จากนั้นเข้าสู่ระบบควรจะสำเร็จ

Scenario:

กำหนดให้ผู้ใช้ไปที่ Facebook

เมื่อฉันป้อนหมายเลขโทรศัพท์และรหัสผ่านที่ถูกต้อง

จากนั้นเข้าสู่ระบบควรจะสำเร็จ

ที่นี่หากเราเห็นอย่างใกล้ชิดสำหรับสามสถานการณ์ข้างต้น: คำสั่งเหมือนกันเฉพาะพารามิเตอร์การป้อนข้อมูล (ชื่อผู้ใช้ / ที่อยู่อีเมล / หมายเลขโทรศัพท์) เท่านั้นที่เปลี่ยนแปลง นั่นคือจุดที่สำคัญของเค้าโครงสถานการณ์มาเป็นภาพ

เมื่อเรากำหนดสถานการณ์ใด ๆ ด้วยโครงร่างสถานการณ์เราสามารถระบุสถานการณ์ทดสอบหนึ่งสถานการณ์และที่ด้านล่างของสถานการณ์นั้นเราสามารถระบุอินพุตได้หลายรายการ สถานการณ์จะดำเนินการหลายครั้งตามจำนวนอินพุตที่ระบุ

ตัวอย่าง

มาสร้างตัวอย่างโครงร่างสถานการณ์ -

Step 1 - สร้างโครงการทดสอบ Maven ที่มีชื่อว่า ScenarioOutlineTest

ไปที่ไฟล์→ใหม่→อื่น ๆ → Maven → Maven Project →ถัดไป
ระบุรหัสกลุ่ม (รหัสกลุ่มจะระบุโครงการของคุณโดยไม่ซ้ำกันในทุกโครงการ)
ระบุรหัสสิ่งประดิษฐ์ (รหัสวัตถุคือชื่อของ jar ที่ไม่มีเวอร์ชันคุณสามารถเลือกชื่อใดก็ได้ที่เป็นตัวพิมพ์เล็ก)
คลิกที่ Finish
เปิด pom.xml -
- ไปที่ package explorer ทางซ้ายมือของ Eclipse
- ขยายโครงการ CucumberTest
- ค้นหาไฟล์ pom.xml
- คลิกขวาและเลือกตัวเลือกเปิดด้วย“ โปรแกรมแก้ไขข้อความ”
เพิ่มการพึ่งพาสำหรับ Selenium - สิ่งนี้จะระบุ Maven ซึ่งจะต้องดาวน์โหลดไฟล์ Selenium jar จากที่เก็บส่วนกลางไปยังที่เก็บในเครื่อง
- เปิด pom.xml อยู่ในโหมดแก้ไขสร้างแท็กการอ้างอิง (<dependencies> </dependencies>) ภายในแท็กโปรเจ็กต์
- ภายในแท็กการอ้างอิงให้สร้างแท็กการพึ่งพา (<dependency> </dependency>)
- ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>org.seleniumhq.selenium</groupId> 
   <artifactId>selenium-java</artifactId> 
   <version>2.47.1</version> 
</dependency>

เพิ่มการพึ่งพาสำหรับ Cucumber-Java: สิ่งนี้จะระบุ Maven ซึ่งไฟล์ Cucumber จะถูกดาวน์โหลดจากที่เก็บส่วนกลางไปยังที่เก็บในเครื่อง
- สร้างแท็กการอ้างอิงขึ้นมาอีกหนึ่งแท็ก
- ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-java</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

เพิ่มการพึ่งพาสำหรับ Cucumber-JUnit: สิ่งนี้จะระบุ Maven ซึ่งไฟล์ Cucumber JUnit จะถูกดาวน์โหลดจากที่เก็บส่วนกลางไปยังที่เก็บในเครื่อง
- สร้างแท็กการอ้างอิงขึ้นมาอีกหนึ่งแท็ก
- ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-junit</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

เพิ่มการพึ่งพาสำหรับ JUnit - สิ่งนี้จะระบุ Maven ซึ่งไฟล์ JUnit จะถูกดาวน์โหลดจากที่เก็บส่วนกลางไปยังที่เก็บในเครื่อง
- สร้างแท็กการอ้างอิงขึ้นมาอีกหนึ่งแท็ก
- ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>

เพิ่มการพึ่งพาสำหรับ JUnit - สิ่งนี้จะระบุ Maven ซึ่งไฟล์ JUnit จะถูกดาวน์โหลดจากที่เก็บส่วนกลางไปยังที่เก็บในเครื่อง
- สร้างแท็กการอ้างอิงขึ้นมาอีกหนึ่งแท็ก
- ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>

ตรวจสอบไบนารี
- เมื่อแก้ไข pom.xml สำเร็จแล้วให้บันทึก
- ไปที่ Project → Clean - จะใช้เวลาสักครู่

Step 2 - สร้างแพ็คเกจชื่อ "โครงร่าง" ภายใต้ src/test/java

Step 3 - สร้างไฟล์คุณสมบัติชื่อ “outline.feature”

เลือกและคลิกขวาที่โครงร่างแพ็คเกจ
คลิกที่ไฟล์ 'New'
ตั้งชื่อไฟล์เช่น “outline.feature”
- เขียนข้อความต่อไปนี้ภายในไฟล์และบันทึก
  
  Feature - เค้าโครงสถานการณ์
  
  Scenario Outline - เข้าสู่ระบบสำหรับเว็บไซต์เครือข่ายสังคม
  
  กำหนดให้ผู้ใช้ไปที่ Facebook
  
  เมื่อฉันป้อนชื่อผู้ใช้เป็น "<username>" และรหัสผ่านเป็น "<password>"
  
  จากนั้นการเข้าสู่ระบบจะไม่สำเร็จ

Example -

| username  | password  | 
| username1 | password1 | 
| username2 | password2 |

Note- ที่นี่ตัวอย่างคำอธิบายประกอบอธิบายถึงช่วงของอินพุตที่จะให้เมื่อดำเนินการตามสถานการณ์ สถานการณ์การทดสอบจะดำเนินการสำหรับแต่ละอินพุตที่มีให้ ดังนั้นในตัวอย่างที่กำหนดสถานการณ์ทดสอบจะดำเนินการสามครั้ง

Step 4 - สร้างไฟล์นิยามขั้นตอน

เลือกและคลิกขวาที่โครงร่างแพ็คเกจ
คลิกที่ไฟล์ 'New'
ตั้งชื่อไฟล์เป็น stepdefinition.java
เขียนข้อความต่อไปนี้ภายในไฟล์และบันทึก

package Outline;
 
import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.firefox.FirefoxDriver; 

import cucumber.annotation.en.Given; 
import cucumber.annotation.en.Then; 
import cucumber.annotation.en.When; 

public class stepdefinition { 
   WebDriver driver = null; 
	
   @Given("^user navigates to facebook$") 
   public void goToFacebook() { 
      driver = new FirefoxDriver(); 
      driver.navigate().to("https://www.facebook.com/"); 
   } 
	
   @When("^I enter Username as \"([^\"]*)\" and Password as \"([^\"]*)\"$") public void I_enter_Username_as_and_Password_as(String arg1, String arg2) { driver.findElement(By.id("email")).sendKeys(arg1); driver.findElement(By.id("pass")).sendKeys(arg2); driver.findElement(By.id("u_0_v")).click(); } @Then("^login should be unsuccessful$") 
   public void validateRelogin() { 
      if(driver.getCurrentUrl().equalsIgnoreCase(
      "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){
         System.out.println("Test Pass"); 
      } else { 
         System.out.println("Test Failed"); 
      } 
      driver.close(); 
   }    
}

Note- ในโค้ดด้านบนเราต้องกำหนดฟังก์ชันที่มีอาร์กิวเมนต์อินพุตสองตัว: ชื่อผู้ใช้หนึ่งชื่อและอื่น ๆ จะเป็นรหัสผ่าน ดังนั้นสำหรับชุดข้อมูลแต่ละชุดที่มีให้ในแท็กตัวอย่างชุดของ GIVEN เมื่อไหร่และแล้วจะถูกดำเนินการ

Step 5 - สร้างไฟล์คลาสนักวิ่ง

เลือกและคลิกขวาที่โครงร่างแพ็คเกจ
คลิกที่ไฟล์ 'New'
ตั้งชื่อไฟล์เช่น runTest.java
เขียนข้อความต่อไปนี้ภายในไฟล์และบันทึก

package Outline; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"})

public class runTest { }

ทำการทดสอบโดยใช้ตัวเลือก -
- เลือก runTest.java ไฟล์จาก package explorer
- คลิกขวาและเลือกตัวเลือก ‘Run as’.
- เลือก JUnit test

คุณจะสังเกตสิ่งต่อไปนี้เมื่อคุณเรียกใช้ไฟล์คลาสนี้

Facebook เปิดในอินสแตนซ์เว็บเบราว์เซอร์ Firefox ใหม่
ชื่อผู้ใช้ 1 และรหัสผ่าน 1 จะถูกส่งไปเป็นช่องป้อนชื่อผู้ใช้และรหัสผ่าน
เข้าสู่ระบบจะคลิก
ข้อความจะแสดงบนเบราว์เซอร์เกี่ยวกับการเข้าสู่ระบบที่ไม่สำเร็จ
ในคอนโซลคุณจะเห็น“ Test Pass” พิมพ์อยู่
ผลลัพธ์ขั้นที่ 1 ถึง 5 จะถูกเรียกใช้งานอีกครั้งสำหรับชื่อผู้ใช้ 2 และรหัสผ่าน 2

โดยสรุปเมื่อสถานการณ์ไม่เปลี่ยนแปลง แต่มีการเปลี่ยนแปลงเฉพาะค่าข้อมูลขอแนะนำให้ใช้ตารางข้อมูลเค้าร่างสถานการณ์

มันดูเรียบง่ายเมื่อเรามีหนึ่งสองหรืออาจจะห้าสถานการณ์ในไฟล์ฟีเจอร์ อย่างไรก็ตามในชีวิตจริงไม่ได้เกิดขึ้น สำหรับแต่ละคุณลักษณะที่อยู่ระหว่างการทดสอบเราอาจมี 10, 20 หรืออาจมากกว่าจำนวนสถานการณ์ในไฟล์คุณลักษณะเดียว อาจเป็นตัวแทนของวัตถุประสงค์ที่แตกต่างกัน (การทดสอบควัน / การทดสอบการถดถอย) ผู้มุ่งหวังที่แตกต่างกัน (ผู้พัฒนา / QA / BA) สถานะที่แตกต่างกัน (พร้อมสำหรับการดำเนินการ / กำลังดำเนินการ) ฯลฯ จะจัดการการดำเนินการสำหรับมวลดังกล่าวได้อย่างไร?

สำหรับสิ่งนี้แตงกวาได้จัดเตรียมวิธีการจัดระเบียบการดำเนินการสถานการณ์ของคุณโดยใช้แท็กในไฟล์ฟีเจอร์ เราสามารถกำหนดแต่ละสถานการณ์ด้วยแท็กที่มีประโยชน์ ต่อมาในไฟล์นักวิ่งเราสามารถตัดสินใจได้ว่าแท็กใด (และเป็นไปตามสถานการณ์) ที่เราต้องการให้ Cucumber ดำเนินการ แท็กเริ่มต้นด้วย“ @” หลังจาก“ @” คุณสามารถมีข้อความที่เกี่ยวข้องเพื่อกำหนดแท็กของคุณ มาทำความเข้าใจกับตัวอย่างนี้

สมมติว่ามีสองสถานการณ์ขึ้นไปในไฟล์ฟีเจอร์ เราต้องการดำเนินการเพียงสถานการณ์เดียวโดยเป็นส่วนหนึ่งของการทดสอบควัน ดังนั้นสิ่งแรกคือการระบุสถานการณ์นั้นและประการที่สองคือการติดแท็กด้วยข้อความ“ @SmokeTest” ที่จุดเริ่มต้นของสถานการณ์ มาดูรายละเอียดกัน -

Step 1 - สร้างโครงการ Maven ชื่อ cucumberTag.

Step 2- สร้างแพ็คเกจชื่อ cucumberTag ภายใต้ src/test/java

Step 3- สร้างไฟล์คุณสมบัติชื่อ cucumberTag.feature.

เขียนข้อความต่อไปนี้ภายในไฟล์และบันทึก ไฟล์ฟีเจอร์นี้มีสองสถานการณ์ที่มีเพียงหนึ่งสถานการณ์เท่านั้นที่ถูกทำเครื่องหมายเป็นไฟล์SmokeTest แท็ก

Feature - แท็กแตงกวา

Scenario Outline - เข้าสู่ระบบสำหรับเว็บไซต์เครือข่ายสังคม

กำหนดให้ผู้ใช้ไปที่ Facebook

เมื่อฉันป้อนชื่อผู้ใช้เป็น "<username>" และรหัสผ่านเป็น "<password>"

จากนั้นการเข้าสู่ระบบจะไม่สำเร็จ

ตัวอย่าง

| username  | password  | 
| username1 | password1 | 
| username2 | password2 |

# สถานการณ์ต่อไปนี้ถูกแท็กเป็น SmokeTest และสิ่งนี้ควรได้รับการดำเนินการ @SmokeTest

Scenario:

กำหนดให้ผู้ใช้ไปที่ Facebook

เมื่อฉันป้อนชื่อผู้ใช้เป็น "<>" และรหัสผ่านเป็น "<>"

จากนั้นควรเปลี่ยนเส้นทางผู้ใช้เพื่อเข้าสู่ระบบลองใหม่

Step 4 - สร้างไฟล์นิยามขั้นตอน

เลือกและคลิกขวาที่โครงร่างแพ็คเกจ
คลิกที่ไฟล์ 'New'
ตั้งชื่อไฟล์เช่น cucumberTag.java
เขียนข้อความต่อไปนี้ภายในไฟล์และบันทึก

package cucumberTag;
 
import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.firefox.FirefoxDriver; 

import cucumber.annotation.en.Given; 
import cucumber.annotation.en.Then; 
import cucumber.annotation.en.When; 

public class cucumberTag { 
   WebDriver driver = null; 
	
   @Given("^user navigates to facebook$") public void goToFacebook() { driver = new FirefoxDriver(); driver.navigate().to("https://www.facebook.com/"); } @When("^I enter Username as \"([^\"]*)\" and Password as \"([^\"]*)\"$") 
   public void I_enter_Username_as_and_Password_as(String arg1, String arg2) {
      driver.findElement(By.id("email")).sendKeys(arg1);
      driver.findElement(By.id("pass")).sendKeys(arg2);
      driver.findElement(By.id("u_0_v")).click(); 
   } 
	
   @Then("^login should be unsuccessful$") public void validateRelogin() { if(driver.getCurrentUrl().equalsIgnoreCase( "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){ System.out.println("Test Pass"); } else { System.out.println("Test Failed"); } driver.close(); } @Then("^User should be redirected to login retry$") 
   public void loginRetry() { 
      if(driver.getCurrentUrl().equalsIgnoreCase(
         "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){ 
            System.out.println("Test Pass"); 
      } else { 
         System.out.println("Test Failed"); 
      } 
      driver.close(); 
   } 
}

Step 5 - สร้างไฟล์คลาสนักวิ่ง

สร้างคลาสนักวิ่งชื่อ runTest.java ภายในบรรจุภัณฑ์
เขียนรหัสต่อไปนี้
บันทึกไฟล์

package cucumberTag; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"}) 

public class runTest { }

เรียกใช้ตัวเลือกการทดสอบ
คลิกขวาและเลือกตัวเลือก ‘Run as’.
เลือก JUnit test

คุณจะสังเกตสิ่งต่อไปนี้เมื่อคุณเรียกใช้ไฟล์คลาสนี้

Facebook เปิดในอินสแตนซ์เว็บเบราว์เซอร์ Firefox ใหม่
จะไม่มีการระบุค่าให้กับฟิลด์ชื่อผู้ใช้และรหัสผ่าน
เข้าสู่ระบบจะคลิก
หน้าลองเข้าสู่ระบบอีกครั้งจะถูกโหลด

ไม่มีขีด จำกัด ในการกำหนดแท็กภายในไฟล์ฟีเจอร์ ตามความต้องการของคุณคุณสามารถได้รับแท็กที่จะใช้และสถานการณ์ที่จะดำเนินการ

ส่วนใหญ่มีแท็กสองประเภท -

Default tag- แท็กเริ่มต้นมีความหมายที่กำหนดไว้ล่วงหน้า ตัวอย่าง @ Dev, @ ละเว้น
Custom tag - แท็กที่กำหนดเองช่วยให้คุณมีความยืดหยุ่นเต็มที่ในการเลือกข้อความที่เหมาะสมสำหรับการกำหนดแท็กของคุณ

นอกจากนี้ยังสามารถกำหนดแท็กในระดับคุณลักษณะ เมื่อคุณกำหนดแท็กที่ระดับคุณลักษณะแล้วจะทำให้แน่ใจได้ว่าสถานการณ์ทั้งหมดภายในไฟล์คุณลักษณะนั้นจะสืบทอดแท็กนั้น ขึ้นอยู่กับลักษณะของสถานการณ์เราสามารถใช้มากกว่าหนึ่งแท็กสำหรับคุณลักษณะเดียว เมื่อใดก็ตามที่แตงกวาพบการโทรที่เหมาะสมสถานการณ์เฉพาะจะถูกดำเนินการ

แตงกวายังมีวิธีในการผกผันการเลือกแท็ก พิจารณาว่าจากสถานการณ์ที่กำหนดไว้จาก 25 สถานการณ์ 10 รายการถูกทำเครื่องหมายว่าเป็นการทดสอบควัน เราจำเป็นต้องดำเนินการเฉพาะสถานการณ์ทดสอบการถดถอย

สำหรับสิ่งนี้เราสามารถใช้“ ~” ในคลาส JUnit runner เพื่อยกเว้นสถานการณ์ทดสอบควัน จะมีลักษณะดังต่อไปนี้

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"}, 
   tags = {"~@SmokeTest"})
	
public class runTest { }

ในขณะที่กำหนดหลายแท็กเรายังสามารถกำหนดตรรกะหรือ / และตรรกะและการดำเนินการได้

การกำหนดตรรกะหรือในคลาสรองชนะเลิศ - @dev,@wip - มันบอกว่าต้องดำเนินการสถานการณ์ที่ตรงกับแท็กนี้
การกำหนดตรรกะหรือในคลาสรองชนะเลิศ - [@dev,~@wip] − มันบอกว่าต้องดำเนินการสถานการณ์ที่ตรงกับแท็กทั้งสองนี้

ในขณะที่ทำงานกับระบบอัตโนมัติเราอาจเผชิญกับสถานการณ์ต่างๆ แต่ละสถานการณ์มีความหมายและความต้องการที่แตกต่างกัน

ตั้งแต่เริ่มต้นเราได้นำตัวอย่างฟังก์ชันการเข้าสู่ระบบสำหรับไซต์เครือข่ายสังคมออนไลน์ซึ่งเรามีพารามิเตอร์อินพุตสองตัวที่จะส่งผ่าน ลองคิดถึงความเป็นไปได้เพิ่มเติม แล้วฟังก์ชัน“ การลงทะเบียนผู้ใช้ใหม่” เป็นอย่างไร? โดยปกติแล้วพารามิเตอร์อินพุตสามารถเป็นอะไรได้บ้างในขณะที่ลงทะเบียนผู้ใช้ใหม่สำหรับไซต์เครือข่ายสังคม สิ่งต่อไปนี้ -

ชื่อผู้ใช้
ที่อยู่อีเมล
Password
ป้อนรหัสผ่านอีกครั้ง
Birthdate
Gender
หมายเลขโทรศัพท์

Feature - การลงทะเบียนผู้ใช้ใหม่

ตรวจสอบว่าการลงทะเบียนผู้ใช้ใหม่ไม่สำเร็จหลังจากส่งอินพุตที่ไม่ถูกต้อง

เนื่องจากฉันอยู่ในหน้าลงทะเบียนผู้ใช้ใหม่

เมื่อฉันป้อนชื่อผู้ใช้และที่อยู่อีเมลเป็นที่อยู่อีเมลและรหัสผ่านและป้อนรหัสผ่านอีกครั้งในฐานะและวันเกิดเป็นและเพศเป็นและหมายเลขโทรศัพท์เนื่องจากการลงทะเบียนผู้ใช้จะไม่สำเร็จ

มันดูยุ่งเล็กน้อยในตอนแรก ดังนั้นมีวิธีใดที่ดีกว่าในการจัดการปัจจัยการผลิตดังกล่าวหรือไม่? คำตอบอาจเป็น "ตารางข้อมูล" ตารางข้อมูลคือชุดข้อมูลเข้าที่มีให้สำหรับแท็กเดียว แท็กนี้สามารถเป็น GIVEN เมื่อไหร่หรือแล้วก็ได้

ลองเขียนสถานการณ์ข้างต้นด้วยความช่วยเหลือของตารางข้อมูลและจะมีลักษณะดังต่อไปนี้ -

เนื่องจากฉันอยู่ในหน้าลงทะเบียนผู้ใช้ใหม่

เมื่อฉันป้อนข้อมูลที่ถูกต้องบนหน้า

| Fields                 | Values              |
| First Name             | Tom                 |
| Last Name              | Kenny               |
| Email Address          | [email protected] |
| Re-enter Email Address | [email protected] |
| Password               | Password1           |
| Birthdate              | 01                  |

จากนั้นการลงทะเบียนผู้ใช้ควรจะสำเร็จ

ตัวอย่าง

มาทำตัวอย่างตารางข้อมูลโดยอัตโนมัติ

Step 1 - สร้างโครงการทดสอบ Maven ชื่อ“ DataTableTest”

ไปที่ไฟล์→ใหม่→อื่น ๆ → Maven → Maven Project →ถัดไป
ให้ group Id (รหัสกลุ่มจะระบุโครงการของคุณโดยไม่ซ้ำกันในทุกโครงการ)
ให้ artifact Id (artifact Id คือชื่อของ jar ที่ไม่มีเวอร์ชันคุณสามารถเลือกชื่อใดก็ได้ที่เป็นตัวพิมพ์เล็ก)
คลิกที่ Finish
เปิด pom.xml -
- ไปที่ package explorer ทางซ้ายมือของ Eclipse
- ขยายโครงการ CucumberTest
- ค้นหาไฟล์ pom.xml
- คลิกขวาและเลือกตัวเลือกเปิดด้วย“ โปรแกรมแก้ไขข้อความ”
เพิ่มการพึ่งพาสำหรับ Selenium: สิ่งนี้จะระบุ Maven ซึ่งจะต้องดาวน์โหลดไฟล์ Selenium jar จากที่เก็บส่วนกลางไปยังที่เก็บในเครื่อง
- เปิด pom.xml อยู่ในโหมดแก้ไขสร้างแท็กการอ้างอิง (<dependencies> </dependencies>) ภายในแท็กโปรเจ็กต์
- ภายในแท็กการอ้างอิงให้สร้างแท็กการอ้างอิง (<dependency> </dependency>)
- ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>org.seleniumhq.selenium</groupId> 
   <artifactId>selenium-java</artifactId> 
   <version>2.47.1</version> 
</dependency>

เพิ่มการพึ่งพาสำหรับ Cucumber-Java - สิ่งนี้จะระบุ Maven ซึ่งไฟล์ Cucumber จะถูกดาวน์โหลดจากที่เก็บส่วนกลางไปยังที่เก็บในเครื่อง
- สร้างแท็กการอ้างอิงขึ้นมาอีกหนึ่งแท็ก
- ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-java</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

เพิ่มการพึ่งพาสำหรับ Cucumber-JUnit - สิ่งนี้จะระบุ Maven ซึ่งจะต้องดาวน์โหลดไฟล์ Cucumber JUnit จากที่เก็บกลางไปยังที่เก็บในเครื่อง
- สร้างแท็กการอ้างอิงขึ้นมาอีกหนึ่งแท็ก
- ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-junit</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

เพิ่มการพึ่งพาสำหรับ JUnit - สิ่งนี้จะระบุ Maven ซึ่งไฟล์ JUnit จะถูกดาวน์โหลดจากที่เก็บส่วนกลางไปยังที่เก็บในเครื่อง
- สร้างแท็กการอ้างอิงขึ้นมาอีกหนึ่งแท็ก
- ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>

ตรวจสอบไบนารี
- เมื่อแก้ไข pom.xml สำเร็จแล้วให้บันทึก
- ไปที่ Project → Clean - จะใช้เวลาสักครู่

Step 2 - สร้างแพ็คเกจชื่อ dataTable ภายใต้ src/test/java

Step 3 - สร้างไฟล์ฟีเจอร์

สร้างไฟล์ฟีเจอร์ชื่อ dataTable.feature ภายใน dataTable แพ็คเกจ (ดูโครงร่างสถานการณ์ส่วนสำหรับขั้นตอนโดยละเอียดเพิ่มเติม)
เขียนข้อความต่อไปนี้

Feature - ตารางข้อมูล

ตรวจสอบว่าการลงทะเบียนผู้ใช้ใหม่ไม่สำเร็จหลังจากส่งอินพุตที่ไม่ถูกต้อง

Scenario:

ให้ฉันอยู่ในหน้าลงทะเบียนผู้ใช้ใหม่

เมื่อฉันป้อนข้อมูลที่ไม่ถูกต้องในหน้า

| Fields                 | Values              |
| First Name             | Tom                 |
| Last Name              | Kenny               |
| Email Address          | [email protected] |
| Re-enter Email Address | [email protected] |
| Password               | Password1           |
| Birthdate              | 01                  |

จากนั้นการลงทะเบียนผู้ใช้จะไม่สำเร็จ

บันทึกไฟล์

Step 4 - สร้างไฟล์กำหนดขั้นตอน

สร้างไฟล์ข้อกำหนดขั้นตอนที่มีชื่อว่า 'dataTable.java' ภายในแพ็คเกจ dataTable (ดูโครงร่างสถานการณ์ส่วนสำหรับขั้นตอนโดยละเอียดเพิ่มเติม)
เขียนรหัสต่อไปนี้

package dataTable; 

import java.util.List; 

import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.WebElement; 
import org.openqa.selenium.firefox.FirefoxDriver; 
import org.openqa.selenium.support.ui.Select;

import cucumber.annotation.en.Given; 
import cucumber.annotation.en.Then; 
import cucumber.annotation.en.When; 
import cucumber.table.DataTable; 

public class stepdefinition { 
   WebDriver driver = null;
	
   @Given("^I am on new user registration page$") public void goToFacebook() { //Intiate web browser instance. driver = new FirefoxDriver(); driver.navigate().to("https://www.facebook.com/"); } @When("^I enter invalid data on the page$") 
   public void enterData(DataTable table){ 
      //Initialize data table 
      List<list> data = table.raw();
      System.out.println(data.get(1).get(1)); 
      
      //Enter data
      driver.findElement(By.name("firstname")).sendKeys(data.get(1).get(1));
      driver.findElement(By.name("lastname")).sendKeys(data.get(2).get(1));
      driver.findElement(By.name("reg_email__")).sendKeys(data.get(3).get(1));     
      driver.findElement(By.name("reg_email_confirmation__")).
         sendKeys(data.get(4).get(1)); 
      driver.findElement(By.name("reg_passwd__")).sendKeys(data.get(5).get(1)); 
      
      Select dropdownB = new Select(driver.findElement(By.name("birthday_day"))); 
      dropdownB.selectByValue("15"); 
		
      Select dropdownM = new Select(driver.findElement(By.name("birthday_month")));
      dropdownM.selectByValue("6"); 
		
      Select dropdownY = new Select(driver.findElement(By.name("birthday_year")));
      dropdownY.selectByValue("1990"); 
		
      driver.findElement(By.className("_58mt")).click(); 
      // Click submit button driver.findElement(By.name("websubmit")).click(); 
   } 
	
   @Then("^User registration should be unsuccessful$") 
   public void User_registration_should_be_unsuccessful() {
      if(driver.getCurrentUrl().equalsIgnoreCase("https://www.facebook.com/")){
         System.out.println("Test Pass"); 
      } else { 
         System.out.println("Test Failed"); 
      } 
      driver.close(); 
   } 
}

บันทึกไฟล์

Step 5 - สร้างไฟล์คลาสนักวิ่ง

สร้างคลาสนักวิ่งชื่อ runTest.java ภายในแพ็คเกจ
เขียนรหัสต่อไปนี้

package dataTable; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"})
 
public class runTest { }

บันทึกไฟล์
ทำการทดสอบโดยใช้ตัวเลือก
- เลือกไฟล์ runTest.java จาก package explorer
- คลิกขวาและเลือกตัวเลือก Run as
- เลือก JUnit test

คุณอาจสังเกตสิ่งต่อไปนี้เมื่อดำเนินการสำเร็จ

เว็บไซต์ Facebook ถูกโหลด
ข้อมูลจะถูกป้อนในหน้าลงทะเบียน
ปุ่มส่งจะถูกคลิก
เราจะเห็นว่าโฮมเพจจะไม่ปรากฏขึ้นและ“ Test Pass” จะถูกเขียนบนคอนโซล

Commentโดยพื้นฐานแล้วเป็นรหัสที่มีไว้เพื่อวัตถุประสงค์ในการจัดทำเอกสารไม่ใช่เพื่อการดำเนินการ ไม่ว่าจะเป็นไฟล์ข้อกำหนดขั้นตอนหรือไฟล์คุณลักษณะเพื่อให้อ่านและเข้าใจได้ง่ายขึ้น ดังนั้นจึงเป็นเรื่องสำคัญที่จะต้องใช้ / แสดงความคิดเห็นในตำแหน่งที่เหมาะสมในไฟล์ นอกจากนี้ยังช่วยในขณะที่ดีบักโค้ด ไฟล์ฟีเจอร์แตงกวาสามารถแสดงความคิดเห็นได้ทุกที่ ในการแสดงความคิดเห็นเราต้องขึ้นต้นข้อความด้วยเครื่องหมาย“ #”

ภาษาโปรแกรมต่างๆมีบรรทัดฐานที่แตกต่างกันในการกำหนดความคิดเห็น เรามาดูกันดีกว่าว่าแตงกวาเกี่ยวข้องกับมันอย่างไร

ไฟล์คำจำกัดความขั้นตอน - หากคุณใช้ Java เป็นแพลตฟอร์มให้ทำเครื่องหมายความคิดเห็นของคุณด้วย“ //”
ไฟล์ฟีเจอร์ - ในกรณีของไฟล์ฟีเจอร์เราต้องใส่ # ก่อนเริ่มความคิดเห็นของคุณ

ตัวอย่าง

ข้อความที่ไฮไลต์ในโปรแกรมอ้างถึงความคิดเห็นในโค้ด

Feature: annotation 

#This is how background can be used to eliminate duplicate steps 
Background: 
User navigates to Facebook 
Given I am on Facebook login page 

#Scenario with AND 
Scenario: 
When I enter username as "TOM" 
And I enter password as "JERRY" 
Then Login should fail 

#Scenario with BUT 
Scenario: 
When I enter username as "TOM" 
And I enter password as "JERRY" 
Then Login should fail 
But Relogin option should be available

แตงกวา hookช่วยให้เราจัดการขั้นตอนการทำงานของโค้ดได้ดีขึ้นและช่วยลดความซ้ำซ้อนของโค้ด เราสามารถพูดได้ว่าเป็นขั้นตอนที่มองไม่เห็นซึ่งทำให้เราสามารถดำเนินการสถานการณ์หรือการทดสอบของเราได้

เพื่อให้เข้าใจแนวคิดนี้ได้ดีขึ้นเรามาดูตัวอย่างไฟล์คุณลักษณะและไฟล์ข้อกำหนดขั้นตอน

ส่วนที่ไฮไลต์ในคำสั่งที่ระบุทำหน้าที่ในการตั้งค่า webdriver และสิ้นสุดเซสชัน webdriver ดังนั้นจึงไม่เกี่ยวข้องกับสาระสำคัญของ“ คำแถลงที่ได้รับ” และเป็นเหมือนการตั้งค่าสำหรับการทดสอบ นอกจากนี้หากเราคิดกับผู้มีโอกาสเป็นลูกค้าในวงกว้างจากนั้นในกรณีที่มีหลายสถานการณ์สำหรับคุณลักษณะนี้การตั้งค่าและการล้างข้อมูลบนเว็บนี้จะทำงานกับแต่ละคำสั่งที่กำหนด ตามเหตุผลแล้วการตั้งค่าและการล้างข้อมูลจะดำเนินการเพียงครั้งเดียวเท่านั้น

ดังนั้นเพื่อให้เกิดการเพิ่มประสิทธิภาพสามารถใช้ตะขอได้ บ่อยครั้งที่เราใช้ตะขอสองประเภท: ตะขอ "ก่อน" และตะขอ "หลัง" วิธีการ / ฟังก์ชัน / ชิ้นส่วนของโค้ดที่กำหนดไว้ในก่อนและหลัง hooks รันเสมอแม้ว่าสถานการณ์จะผ่านหรือล้มเหลว

ตามชื่อที่แนะนำก่อนที่ hook จะดำเนินการได้ดีก่อนสถานการณ์ทดสอบอื่น ๆ และหลังจากที่ hook ถูกเรียกใช้งานหลังจากเรียกใช้สถานการณ์ทั้งหมด

Hooks ถูกกำหนดไว้ภายในไฟล์ข้อกำหนดขั้นตอนเท่านั้น

มาดูตัวอย่างก่อนและหลังแบบอัตโนมัติกัน

Step 1 - สร้างโครงการ Maven เป็น hookTest เพิ่มการพึ่งพาที่จำเป็นใน pom.xml

Step 2 - สร้างแพ็คเกจ Java ที่มีชื่อว่า hookTest ภายใต้ src/test/java

Step 3 - สร้างไฟล์ข้อกำหนดขั้นตอนที่ชื่อเป็น hookTest.java ภายใต้แพ็คเกจ

package hookTest; 

import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.firefox.FirefoxDriver; 

import cucumber.annotation.en.Given; 
import cucumber.annotation.en.Then; 
import cucumber.annotation.en.When; 

public class hookTest {
   WebDriver driver = null; 
	
   @Before public void setUp(){ 
      driver = new FirefoxDriver(); 
   } 
	
   @Given("^user navigates to facebook$") 
   public void goToFacebook() { 
      driver.navigate().to("https://www.facebook.com/");
   } 
	
   @When("^I enter Username as \"([^\"]*)\" and Password as \"([^\"]*)\"$") public void I_enter_Username_as_and_Password_as(String arg1, String arg2) { driver.findElement(By.id("email")).sendKeys(arg1); driver.findElement(By.id("pass")).sendKeys(arg2); driver.findElement(By.id("u_0_v")).click(); } @Then("^login should be unsuccessful$") 
   public void validateRelogin() { 
      if(driver.getCurrentUrl().equalsIgnoreCase(
         "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){ 
            System.out.println("Test Pass"); 
      } else { 
         System.out.println("Test Failed"); 
      } 
      driver.close(); 
   } 
	
   @After public void cleanUp(){ 
      driver.close(); 
   } 
}

Step 4 - สร้างไฟล์ฟีเจอร์ชื่อ“ hookTest.feature” ภายใต้แพ็คเกจ

Feature - เค้าโครงสถานการณ์

Scenario Outline - การทดสอบตะขอ

กำหนดให้ผู้ใช้ไปที่ Facebook

เมื่อฉันป้อนชื่อผู้ใช้เป็น "<username>" และรหัสผ่านเป็น "<password>"

จากนั้นการเข้าสู่ระบบจะไม่สำเร็จ

ตัวอย่าง

| username  | password  | 
| username1 | password1 |

Step 5 - สร้างไฟล์คลาสนักวิ่ง

สร้างคลาสรันเนอร์เป็น runTest.java ภายในแพ็คเกจ dataTable (ดูโครงร่างสถานการณ์ส่วนสำหรับขั้นตอนโดยละเอียด)
เขียนรหัสต่อไปนี้

package hookTest; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"})  

public class runTest { }

บันทึกไฟล์
ทำการทดสอบโดยใช้ตัวเลือก -
- เลือกไฟล์ runTest.java จาก package explorer
- คลิกขวาและเลือกตัวเลือก Run as
- เลือก JUnit test

ตอนนี้เมื่อเราเรียกใช้สิ่งนี้ต่อไปนี้จะเป็นลำดับของการดำเนินการ

ก่อนที่จะเชื่อมต่อ - ตั้งค่า Webdriver และข้อกำหนดเบื้องต้นอื่น ๆ เพื่อเรียกใช้การทดสอบ
ให้คำสั่ง
เมื่อคำสั่ง
แล้วคำสั่ง
After hook - ปิด webdriver และทำตามขั้นตอนการล้างข้อมูล

ติดแท็ก Hooks

นอกจากนี้เรายังสามารถระบุได้ว่าเราต้องการให้ hooks ก่อนและหลังดำเนินการด้วยแท็กเฉพาะหรือไม่ Example- @Before ('@ เว็บ') แนวคิดเดียวกันของแท็กตรรกะและ / หรือสามารถใช้กับ hooks ได้เช่นกันExample - @Before (@ dev, @ wip), @Before (@ dev, ~ @ wip)

แตงกวาสามารถใช้ทดสอบระบบคอมพิวเตอร์ได้เกือบทุกชนิด จนถึงตอนนี้เราได้เห็นวิธีเรียกใช้การทดสอบโดยใช้ Eclipse IDE มีอีกวิธีหนึ่งที่เราสามารถเรียกใช้การทดสอบแตงกวาผ่านอินเทอร์เฟซบรรทัดคำสั่ง แล้วข้อดีของการทำคืออะไร?

การเรียกใช้กรอบการทดสอบจาก Terminal มีข้อดีในตัวเองเช่นการลบล้างการกำหนดค่าการรันที่กล่าวถึงในโค้ด

ในการดำเนินการทดสอบแตงกวาด้วยพรอมต์คำสั่งให้ใช้ขั้นตอนต่อไปนี้หลังการกำหนดค่าระบบ

Step 1- สร้างโครงการทดสอบ Maven ชื่อ commandLine.

ไปที่ไฟล์→ใหม่→อื่น ๆ → Maven → Maven Project →ถัดไป
ระบุรหัสกลุ่ม (รหัสกลุ่มจะระบุโครงการของคุณโดยไม่ซ้ำกันในทุกโครงการ)
ระบุรหัสสิ่งประดิษฐ์ (รหัสวัตถุคือชื่อของ jar ที่ไม่มีเวอร์ชันคุณสามารถเลือกชื่อใดก็ได้ที่เป็นตัวพิมพ์เล็ก)
คลิกที่ Finish
เปิด pom.xml -
- ไปที่ package explorer ทางซ้ายมือของ Eclipse
- ขยายโครงการ CucumberTest
- ค้นหา pom.xml ไฟล์.
- คลิกขวาและเลือกตัวเลือกเปิดด้วย“ โปรแกรมแก้ไขข้อความ”
เพิ่มการพึ่งพาสำหรับ Selenium - สิ่งนี้จะระบุ Maven ซึ่งจะต้องดาวน์โหลดไฟล์ Selenium jar จากที่เก็บส่วนกลางไปยังที่เก็บในเครื่อง
- เปิด pom.xml อยู่ในโหมดแก้ไขสร้างแท็กการอ้างอิง (<dependencies> </dependencies>) ภายในแท็กโปรเจ็กต์
- ภายในแท็กการอ้างอิงให้สร้างแท็กการอ้างอิง (<dependency> </dependency>)
- ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>org.seleniumhq.selenium</groupId> 
   <artifactId>selenium-java</artifactId> 
   <version>2.47.1</version> 
</dependency>

เพิ่มการพึ่งพาสำหรับ Cucumber-Java - สิ่งนี้จะระบุ Maven ซึ่งไฟล์ Cucumber จะถูกดาวน์โหลดจากที่เก็บส่วนกลางไปยังที่เก็บในเครื่อง
- สร้างแท็กการอ้างอิงขึ้นมาอีกหนึ่งแท็ก
- ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-java</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

เพิ่มการพึ่งพาสำหรับ Cucumber-JUnit - สิ่งนี้จะระบุ Maven ซึ่งจะต้องดาวน์โหลดไฟล์ Cucumber JUnit จากที่เก็บกลางไปยังที่เก็บในเครื่อง
- สร้างแท็กการอ้างอิงขึ้นมาอีกหนึ่งแท็ก
- ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-junit</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

เพิ่มการพึ่งพาสำหรับ JUnit - สิ่งนี้จะระบุ Maven ซึ่งไฟล์ JUnit จะถูกดาวน์โหลดจากที่เก็บส่วนกลางไปยังที่เก็บในเครื่อง
- สร้างแท็กการอ้างอิงขึ้นมาอีกหนึ่งแท็ก
- ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>

ตรวจสอบไบนารี
- เมื่อแก้ไข pom.xml สำเร็จแล้วให้บันทึก
- ไปที่ Project → Clean - จะใช้เวลาไม่กี่นาที

Step 2 - สร้างแพ็คเกจชื่อ "outline" ภายใต้ src / test / java

Step 3 - สร้างไฟล์ฟีเจอร์ชื่อ“ commandLine.feature”

เลือกและคลิกขวาที่โครงร่างแพ็คเกจ
คลิกที่ไฟล์ 'New'
ตั้งชื่อไฟล์เช่น“ commandLine.feature”
เขียนข้อความด้านล่างภายในไฟล์และบันทึก

Feature - เค้าโครงสถานการณ์

Scenario Outline - เข้าสู่ระบบสำหรับเว็บไซต์เครือข่ายสังคม

กำหนดให้ผู้ใช้ไปที่ Facebook

เมื่อฉันป้อนชื่อผู้ใช้เป็น "<username>" และรหัสผ่านเป็น "<password>"

จากนั้นการเข้าสู่ระบบจะไม่สำเร็จ

ตัวอย่าง

| username  | password  | 
| username1 | password1 | 
| username2 | password2 |

Step 4 - สร้างไฟล์นิยามขั้นตอน

เลือกและคลิกขวาที่โครงร่างแพ็คเกจ
คลิกที่ไฟล์ 'New'
ตั้งชื่อไฟล์เป็น commandLine.java
เขียนข้อความต่อไปนี้ภายในไฟล์และบันทึก

package Outline; 

import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.firefox.FirefoxDriver; 

import cucumber.annotation.en.Given; 
import cucumber.annotation.en.Then; i
import cucumber.annotation.en.When; 

public class stepdefinition { 
   WebDriver driver = null;
	
   @Given("^user navigates to facebook$") public void goToFacebook() { driver = new FirefoxDriver(); driver.navigate().to("https://www.facebook.com/"); } @When("^I enter Username as \"([^\"]*)\" and Password as \"([^\"]*)\"$") 
   public void I_enter_Username_as_and_Password_as(String arg1, String arg2) {
      driver.findElement(By.id("email")).sendKeys(arg1);
      driver.findElement(By.id("pass")).sendKeys(arg2);
      driver.findElement(By.id("u_0_v")).click(); 
   } 
	
   @Then("^login should be unsuccessful$") 
   public void validateRelogin() { 
      if(driver.getCurrentUrl().equalsIgnoreCase(
         "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){ 
            System.out.println("Test Pass"); 
      } else { 
         System.out.println("Test Failed"); 
      } 
      driver.close(); 
   } 
}

Note- ในโค้ดเราต้องกำหนดฟังก์ชันที่มีอาร์กิวเมนต์อินพุตสองตัว: ชื่อผู้ใช้หนึ่งชื่อและอื่น ๆ จะเป็นรหัสผ่าน ดังนั้นสำหรับการป้อนข้อมูลแต่ละชุดที่มีให้ในแท็กตัวอย่างชุดของ GIVEN เมื่อไหร่และแล้วจะถูกดำเนินการ

Step 5 - สร้างไฟล์คลาสนักวิ่ง

เลือกและคลิกขวาที่โครงร่างแพ็คเกจ
คลิกที่ไฟล์ 'New'
ตั้งชื่อไฟล์เช่น, runTest.java
เขียนข้อความต่อไปนี้ภายในไฟล์และบันทึก

package Outline; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"}) 

public class runTest { }

เปิดพรอมต์คำสั่ง
ไปที่ไดเร็กทอรีที่มีแพ็กเกจ“ commandLine” อยู่ e: \ Workspace \ LoginTest \ src> cd test \ java
เรียกใช้การทดสอบคำสั่ง mvn: คุณจะเห็นว่าสถานการณ์ทั้งหมดที่อธิบายไว้ในไฟล์คุณลักษณะได้รับการดำเนินการแล้ว (หากไม่มีข้อผิดพลาดใด ๆ ) สุดท้ายที่ด้านล่างคุณจะพบข้อมูลต่อไปนี้

ผลลัพธ์

This describes the total test run, along with failure if any.

คำสั่งก่อนหน้านี้รันทุกอย่างตามที่กล่าวไว้ในคลาส JUnit Runner อย่างไรก็ตามหากเราต้องการลบล้างการกำหนดค่าที่กล่าวถึงใน Runner ต่อไปนี้เป็นตัวอย่างบางส่วนที่ต้องทำ

ตอนนี้รันคำสั่ง mvn test - Dcucumber.options = "- help" ใน command prompt การรันสิ่งนี้จะพิมพ์ตัวเลือกที่มีทั้งหมด
ในการรันแท็กเฉพาะให้รันคำสั่ง mvn test -Dcucumber.options = "- tags @SmokeTest" บนพร้อมรับคำสั่ง จะเรียกใช้เฉพาะแท็กซึ่งมีเครื่องหมาย @SmokeTest
ในการเปลี่ยนรูปแบบของผลลัพธ์ให้รันคำสั่ง E: \ Workspace \ LoginTest> mvn test -Dcucumber.options = "- plugin junit: target / cucumber-junit-report.xml" บน command prompt มันจะเปลี่ยนรายงาน จัดรูปแบบเป็นตัวสร้างรายงาน JUnit

สิ่งสำคัญคือต้องทำความเข้าใจว่า Junit คืออะไรก่อนที่เราจะเริ่มการสนทนาเรื่อง Cucumber JUnit Runner JUnitเป็นกรอบการทดสอบหน่วยโอเพ่นซอร์สสำหรับภาษาโปรแกรม Java JUnit มีความสำคัญในการพัฒนาการพัฒนาที่ขับเคลื่อนด้วยการทดสอบและเป็นหนึ่งในตระกูลของกรอบการทดสอบหน่วยซึ่งเรียกรวมกันว่า xUnit ที่มาพร้อมกับ SUnit

ประโยชน์ของการใช้ JUnit

หน่วยมี Graphical User Interface (GUI) ทำให้สามารถเขียนและทดสอบซอร์สโค้ดได้อย่างรวดเร็วและง่ายดาย
JUnit ช่วยให้นักพัฒนาสามารถสร้างชุดทดสอบเพิ่มขึ้นเพื่อวัดความคืบหน้าและตรวจจับผลข้างเคียงที่ไม่ได้ตั้งใจ
การทดสอบสามารถทำงานได้อย่างต่อเนื่อง
JUnit แสดงความคืบหน้าของการทดสอบในแถบที่ปกติจะเป็นสีเขียว แต่จะเปลี่ยนเป็นสีแดงเมื่อการทดสอบล้มเหลว

ตอนนี้เราได้เห็นประโยชน์ของการใช้ JUnit แล้ว แต่เหตุผลที่เรากำลังพูดถึงในตอนนี้คือ Cucumber framework ประการหนึ่งแตงกวากำลังจัดหาวิธีสำหรับผู้ที่ไม่ใช่ผู้เชี่ยวชาญด้านเทคนิคในการกำหนดกรณีทดสอบสำหรับผลิตภัณฑ์และในทางกลับกันความคาดหวังของเราคือการดำเนินการกรณีทดสอบดังกล่าวอย่างราบรื่นและทันท่วงที

JUnit ทำหน้าที่เป็นสะพานเชื่อมระหว่างสองสิ่งนี้ ดังนั้นขั้นตอนการดำเนินการจะมีลักษณะดังต่อไปนี้ -

ผู้มีส่วนได้ส่วนเสียจดไฟล์คุณลักษณะ
ไฟล์ข้อกำหนดขั้นตอนจะถูกสร้างขึ้นตามนั้น
ระบุคลาส JUnit runner เพื่อรันชุดกรณีทดสอบ
เมื่อเราเรียกใช้คลาส JUnit runner -
- มันจะแยกวิเคราะห์ไฟล์ฟีเจอร์ Gherkin
- มันจะเรียกใช้ฟังก์ชันที่เขียนในไฟล์ข้อกำหนดขั้นตอนตามคำสั่งไฟล์คุณลักษณะ
- JUnit จะรวมผลกรณีทดสอบ
- จะสร้างรายงานการทดสอบในรูปแบบที่กำหนด (ซึ่งอาจเป็น html / JSON)

ประเด็นสำคัญคือจะกำหนดค่า JUnit ให้ทำสิ่งเหล่านี้ได้อย่างไร? ต่อไปนี้เป็นขั้นตอน -

Step 1 - ติดตั้ง Java

ดาวน์โหลด jdk และ jre จากลิงค์ http://www.oracle.com/technetwork/java/javase/downloads/index.html
ยอมรับข้อตกลงใบอนุญาต
ติดตั้ง JDK และ JRE
ตั้งค่าตัวแปรสภาพแวดล้อมดังที่แสดงในภาพหน้าจอต่อไปนี้

Step 2 - ติดตั้ง Eclipse

Why we need- Eclipse คือ Integrated Development Environment (IDE) ประกอบด้วยพื้นที่ทำงานพื้นฐานและระบบปลั๊กอินที่ขยายได้สำหรับการปรับแต่งสภาพแวดล้อม
How to install -
- ตรวจสอบให้แน่ใจว่าได้ติดตั้ง JAVA ในเครื่องของคุณแล้ว
- ดาวน์โหลด Eclipse จาก http://www.eclipse.org/downloads
- ติดตั้ง Unzip และ Eclipse แล้ว

Step 3 - ติดตั้ง Maven

Why we need- Maven เป็นเครื่องมือสร้างระบบอัตโนมัติที่ใช้สำหรับโปรเจ็กต์ Java เป็นหลัก มันมีแพลตฟอร์มทั่วไปในการทำกิจกรรมต่างๆเช่นการสร้างซอร์สโค้ดการคอมไพล์โค้ดโค้ดแพ็กเกจลงใน jar และอื่น ๆ ในภายหลังหากเวอร์ชันซอฟต์แวร์ใด ๆ มีการเปลี่ยนแปลง Maven จะมอบวิธีง่ายๆในการแก้ไขโปรเจ็กต์ทดสอบ
How to install -
- ดาวน์โหลด Maven - https://maven.apache.org/download.cgi
- แตกไฟล์และจำตำแหน่ง
- สร้างตัวแปรสภาพแวดล้อม MAVEN_HOME ดังที่แสดงในภาพหน้าจอต่อไปนี้

แก้ไขตัวแปรเส้นทางและรวม Maven ดังที่แสดงในภาพหน้าจอต่อไปนี้

ดาวน์โหลดปลั๊กอิน MAVEN จาก Eclipse
- เปิด Eclipse
- ได้รับความช่วยเหลือ→ Eclipse Marketplace →ค้นหา maven → Maven Integration for Eclipse → INSTALL

Step 4 - วิธีกำหนดค่าแตงกวาด้วย Maven

สร้างโครงการ Maven ใน Eclipse
- ไปที่ไฟล์→ใหม่→อื่น ๆ → Maven → Maven Project →ถัดไป
- ระบุรหัสกลุ่ม (รหัสกลุ่มจะระบุโครงการของคุณโดยไม่ซ้ำกันในทุกโครงการ)
- ระบุรหัสสิ่งประดิษฐ์ (รหัสวัตถุคือชื่อของ jar ที่ไม่มีเวอร์ชันคุณสามารถเลือกชื่อใดก็ได้ที่เป็นตัวพิมพ์เล็ก)
- คลิกที่ Finish
เปิด pom.xml
- ไปที่ package explorer ทางซ้ายมือของ Eclipse
- ขยายโครงการ CucumberTest
- ค้นหาไฟล์ pom.xml
- คลิกขวาและเลือกตัวเลือกเปิดด้วย“ โปรแกรมแก้ไขข้อความ”
เพิ่มการพึ่งพาสำหรับ Selenium - สิ่งนี้จะระบุ Maven ซึ่งจะต้องดาวน์โหลดไฟล์ Selenium jar จากที่เก็บส่วนกลางไปยังที่เก็บในเครื่อง
- เปิด pom.xml อยู่ในโหมดแก้ไขสร้างแท็กการอ้างอิง (<dependencies> </dependencies>) ภายในแท็กโปรเจ็กต์
- ภายในแท็กการอ้างอิงให้สร้างแท็กการอ้างอิง (<dependency> </dependency>)
- ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>org.seleniumhq.selenium</groupId> 
   <artifactId>selenium-java</artifactId> 
   <version>2.47.1</version> 
</dependency>

เพิ่มการพึ่งพาสำหรับ Cucumber-Java - สิ่งนี้จะระบุ Maven ซึ่งไฟล์ Cucumber จะดาวน์โหลดจากที่เก็บส่วนกลางไปยังที่เก็บในเครื่อง
- สร้างแท็กการอ้างอิงขึ้นมาอีกหนึ่งแท็ก
- ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-java</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

เพิ่มการพึ่งพาสำหรับ Cucumber-JUnit: สิ่งนี้จะระบุ Maven ซึ่งไฟล์ Cucumber JUnit จะถูกดาวน์โหลดจากที่เก็บส่วนกลางไปยังที่เก็บในเครื่อง
- สร้างแท็กการอ้างอิงขึ้นมาอีกหนึ่งแท็ก
- ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-junit</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

เพิ่มการพึ่งพาสำหรับ JUnit - สิ่งนี้จะระบุ Maven ซึ่งไฟล์ JUnit จะถูกดาวน์โหลดจากที่เก็บส่วนกลางไปยังที่เก็บในเครื่อง
- สร้างแท็กการอ้างอิงขึ้นมาอีกหนึ่งแท็ก
- ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>

ตรวจสอบไบนารี
- ครั้งเดียว pom.xml แก้ไขเรียบร้อยแล้วให้บันทึก
- ไปที่ Project → Clean - จะใช้เวลาสักครู่
- หลังจากนั้นคุณจะสามารถเห็นที่เก็บ Maven เหมือนภาพหน้าจอต่อไปนี้

Step 5 - สร้างไฟล์คุณสมบัติ (จะกล่าวถึงในภายหลัง)

Step 6 - สร้างไฟล์ข้อกำหนดขั้นตอน (จะกล่าวถึงในภายหลัง)

Step 7 - สร้าง Junit runner เพื่อทำการทดสอบ (จะกล่าวถึงภายหลัง)

เราทำการทดสอบเพื่อให้เข้าใจถึงความเสถียรของผลิตภัณฑ์ดังนั้นไม่ว่าจะเป็นการทดสอบด้วยตนเองหรือการทดสอบอัตโนมัติสิ่งสำคัญอย่างยิ่งที่จะต้องสร้างรายงานที่กระชับซึ่งสามารถแสดงถึงความเสถียรของผลิตภัณฑ์ได้ ดังนั้นในขณะที่เรากำลังสร้างสถานการณ์ทดสอบโดยอัตโนมัติด้วยแตงกวาสิ่งสำคัญคือต้องรู้ว่าเราจะสร้างรายงานการทดสอบแตงกวาได้ดีเพียงใด อย่างที่เราทราบกันดีว่า Cucumber เป็นกรอบงาน BDD แต่ไม่มีกลไกการรายงานที่สวยงาม

เพื่อให้บรรลุเป้าหมายนี้เราต้องรวม Cucumber เข้ากับเครื่องมือโอเพนซอร์สอื่น ๆ เช่น Ant / Junit ในที่นี้เราจะนำตัวอย่างของ JUnit เพิ่มเติมเนื่องจากมีการสนับสนุนภาษา Java

มาดูรายละเอียดของรูปแบบรายงานต่างๆซึ่งพร้อมใช้งานและใช้งานง่าย -

รูปแบบสวย (รายงาน HTML)

Pretty Format สร้างรายงานผลการทดสอบแตงกวาในรูปแบบ HTML เช่นไฟล์ HTML เป็นรูปแบบรายงานที่น่าอ่านมากที่สุด มันสร้างรายงานในลักษณะเดียวกับที่เป็นไฟล์ฟีเจอร์ดังนั้นการติดตามจึงทำได้ง่ายเช่นกัน นอกจากนี้คุณสามารถระบุตำแหน่งที่คุณต้องการวางรายงานนี้หลังจากการดำเนินการทดสอบ มันสามารถ -

Local Directory - เราสามารถระบุไดเร็กทอรีเป้าหมายสำหรับรายงานเป็นไดเร็กทอรีโลคัลของเครื่องที่จะทำการทดสอบ
Server Directory- นอกจากนี้เรายังมีข้อกำหนดในการระบุไดเร็กทอรีเป้าหมายเป็นไดเร็กทอรีใด ๆ บนเซิร์ฟเวอร์ซึ่งสามารถเข้าถึงได้โดยสาธารณะ โดยทั่วไปจะช่วยได้เมื่อเราต้องการให้ลูกค้า / ผู้มีส่วนได้ส่วนเสียดูผลการทดสอบ ณ เวลาใดเวลาหนึ่ง

ตัวอย่าง

มาดูตัวอย่างรูปแบบที่สวยงามโดยอัตโนมัติ

Step 1 - สร้างโครงการ Maven ชื่อ cucumberReport ใน Eclipse

Step 2 - สร้างแพ็คเกจชื่อ CucumberReport ภายใต้ src/test/java

Step 3 - สร้างไฟล์คุณสมบัติชื่อ cucumberReport.feature

เขียนข้อความต่อไปนี้ภายในไฟล์และบันทึก

Feature - รายงานแตงกวา

# นี่คือการตรวจสอบผลการทดสอบ Pass test case

Scenario: มีฟังก์ชันการเข้าสู่ระบบ

เนื่องจากฉันได้เปิดเบราว์เซอร์

เมื่อเปิดเว็บไซต์ Facebook

จากนั้นปุ่มเข้าสู่ระบบควรมีอยู่

# นี่คือการตรวจสอบผลการทดสอบสำหรับกรณีทดสอบที่ล้มเหลว

Scenario: ลืมรหัสผ่านอยู่

ให้ฉันเปิดเบราว์เซอร์

เมื่อเปิดเว็บไซต์ Facebook

จากนั้นลิงก์ลืมรหัสผ่านควรมีอยู่

Note- นี่คือสถานการณ์แรกจะผ่านไปในขณะที่สถานการณ์ที่สองจะล้มเหลว เพื่อให้เราได้เห็นว่ารายงานผ่านและรายงานล้มเหลวมีลักษณะอย่างไร

Step 4 - สร้างไฟล์นิยามขั้นตอน

เลือกและคลิกขวาที่โครงร่างแพ็คเกจ
คลิกที่ไฟล์ 'New'
ตั้งชื่อไฟล์เป็น cucumberReport.java
เขียนข้อความต่อไปนี้ภายในไฟล์และบันทึก

package CucumberReport; 

import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.firefox.FirefoxDriver; 

import cucumber.annotation.en.Given; 
import cucumber.annotation.en.Then; 
import cucumber.annotation.en.When; 

public class cucumberReport { 
   WebDriver driver = null;
	
   @Given("^I have open the browser$") 
   public void openBrowser() { 
      driver = new FirefoxDriver();
   } 
	
   @When("^I open Facebook website$") public void goToFacebook() { driver.navigate().to("https://www.facebook.com/"); } @Then("^Login button should exits$") 
   public void loginButton() { 
      if(driver.findElement(By.id("u_0_v")).isEnabled()) { 
         System.out.println("Test 1 Pass"); 
      } else { 
         System.out.println("Test 1 Fail");
      }
   } 
	
   @Then("^Forgot password link should exist$") 
   public void forgotPWD() { 
      if(driver.findElement(By.id("")).isEnabled()) { 
         System.out.println("Test 1 Pass"); 
      } else {
         System.out.println("Test 1 Fail");
      } 
   } 
}

Step 5 - สร้างไฟล์คลาสนักวิ่ง

สร้างคลาสนักวิ่งชื่อ runTest.java ภายในบรรจุภัณฑ์
เขียนรหัสต่อไปนี้ บันทึกไฟล์

package CucumberReport; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options( 
   format = {"pretty", "html:target/Destination"} ) 
//Specifying pretty as a format option ensure that HTML report will be generated. 
//When we specify html:target/Destination - It will generate the HTML report 

inside the Destination folder, in the target folder of the maven project.
 
public class runTest { }

ทำการทดสอบโดยใช้ตัวเลือก
- เลือก runTest.java ไฟล์จาก package explorer
- คลิกขวาและเลือกตัวเลือก Run as.
- เลือก JUnit test

คุณจะสังเกตสิ่งต่อไปนี้เมื่อคุณเรียกใช้ไฟล์คลาสนี้

ทั้งสองสถานการณ์จะถูกดำเนินการทีละคน

โฟลเดอร์ชื่อ Destination จะถูกสร้างขึ้นภายในไดเร็กทอรีเป้าหมาย

รายงานจะมีชื่อว่า“ Index.html”

เปิด Index.html ด้วยเว็บเบราว์เซอร์

คุณจะเห็นรายงานที่กล่าวถึงในภาพต่อไปนี้ -

มันเน้นสีของสถานการณ์ที่ล้มเหลว นอกจากนี้คุณจะเห็นไฮไลต์สำหรับขั้นตอนที่ล้มเหลวในสถานการณ์นั้น ทำให้การดีบักทำได้ง่ายมาก

รายงาน JSON

ตอนนี้เราได้เห็นแล้วว่ารายงาน HTML นั้นง่ายเพียงใด อย่างไรก็ตามหากเราต้องการส่งต่อข้อมูลรายงานนี้ไปยังแอปพลิเคชันอื่น ๆ นั่นเป็นเรื่องยุ่งยากในกรณีของรายงาน HTML นี่คือความต้องการรูปแบบการรายงานอื่น สัญกรณ์ออบเจ็กต์สคริปต์ JSON-Java เป็นอีกรูปแบบหนึ่งสำหรับการสร้างรายงานการทดสอบ Cucumber JSON เป็นวัตถุที่มีข้อมูลจำนวนมากที่จัดเก็บในรูปแบบข้อความ รายงาน JSON นำค่าที่แตกต่างไปจากตาราง รายงาน JSON ยังสามารถใช้เป็นเพย์โหลดของข้อมูลที่จะถ่ายโอนระหว่างเซิร์ฟเวอร์ต่างๆ นอกจากนี้ยังสามารถใช้เพื่อแสดงเป็นหน้าเว็บ โดยสรุปแอปพลิเคชันอื่นสามารถใช้รายงาน JSON ได้

What is payload information?เมื่อข้อมูลถูกส่งผ่านอินเทอร์เน็ตแต่ละหน่วยที่ส่งจะมีทั้งข้อมูลส่วนหัวและข้อมูลจริงที่กำลังส่ง ส่วนหัวระบุต้นทางและปลายทางของแพ็กเก็ตในขณะที่ข้อมูลจริงเรียกว่าเพย์โหลด ในการสร้างรายงาน JSON เราต้องทำการเปลี่ยนแปลงในไฟล์นักวิ่ง

เปลี่ยนตัวเลือกรูปแบบในไฟล์นักวิ่งดังนี้

package CucumberReport; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options( format={"json:target/Destination/cucumber.json"}) 

//When we specify json:target/Destination/cucumber.json - It will generate the JSON  
report inside the Destination folder, in the target folder of the maven project.

public class runTest {}

ทำการทดสอบโดยใช้ตัวเลือก -
- เลือก runTest.java ไฟล์จาก package explorer
- คลิกขวาและเลือกตัวเลือก Run as.
- เลือก JUnit test

คุณจะสังเกตสิ่งต่อไปนี้เมื่อคุณเรียกใช้ไฟล์คลาสนี้
- ทั้งสองสถานการณ์จะถูกดำเนินการทีละคน

รายงานจะมีชื่อเป็น cucumber.json (ตามที่ระบุไว้ในคลาสนักวิ่ง)
เปิด cucumber.json ไฟล์ด้วยโปรแกรมแก้ไขข้อความ
คุณจะเห็นรายงานที่กล่าวถึงในภาพหน้าจอต่อไปนี้หลังจากวางเส้นแบ่ง -

Note - JSON อ่านได้น้อยกว่าเมื่อเทียบกับรูปแบบรายงาน HTML

เป็นไปได้มากว่าการทดสอบของคุณอาจล้มเหลวเนื่องจากไม่ทราบสาเหตุ การระบุสาเหตุของความล้มเหลวและการแก้ไขเป็นสิ่งสำคัญมาก กระบวนการนี้เรียกว่าdebugging. ต่อไปนี้เป็นเคล็ดลับและเทคนิคบางประการซึ่งทำให้การแก้ไขจุดบกพร่องของแตงกวาเป็นเรื่องง่าย

อ็อพชันการดีบักสามารถใช้ได้กับ Eclipse วางจุดพัก. คลิกไฟล์และแก้ไขข้อบกพร่องโดยใช้ขั้นตอนต่อไปนี้ -

Step 1 - วางจุดแบ่งด้วยตนเองในไฟล์ข้อกำหนดขั้นตอน Ruby

ตัวอย่าง

require 'ruby-debug' 
Then /^the process should exit cleanly$/ do 
breakpoint 
assert @exited_cleanly, "Process did not exit cleanly: #{@stdout}" 
end

Step 2 - เรายังสามารถกำหนดขั้นตอนการดีบักแยกต่างหากเช่นต่อไปนี้ในไฟล์ข้อกำหนดขั้นตอน

Then /^I debug$/ do 
breakpoint 
0 
end

Step 3 - Webratเป็นเครื่องมือเริ่มต้นสำหรับการทดสอบแตงกวาด้วย Rails ช่วยให้คุณทำสิ่งต่างๆเช่นลิงก์คลิกพิมพ์และส่งแบบฟอร์มเป็นต้น

จะมีหลายครั้งที่คุณพยายามคลิกบางสิ่งบางอย่างและไม่มี คุณจะได้รับ HTML หยดใหญ่ ๆ กลับมาและการหาว่าหมายความว่าอะไรคือการลากจริง

save_and_open_page

Webrat มีวิธีการ save_and_open_page ซึ่งรวบรวม HTML ปัจจุบันบันทึกไว้จากนั้นจะเปิดในเบราว์เซอร์ให้คุณ มีประโยชน์อย่างยิ่ง

When /^I follow "(.*)"$/ do |link| 
save_and_open_page 
click_link(link) 
end

ในการรัน Cucumber test ด้วย Java ให้ทำตามขั้นตอนต่อไปนี้

Step 1 - ติดตั้ง Java -

ดาวน์โหลด jdk และ jre จาก

http://www.oracle.com/technetwork/java/javase/downloads/index.html
ยอมรับข้อตกลงใบอนุญาต
ติดตั้ง JDK และ JRE
ตั้งค่าตัวแปรสภาพแวดล้อมดังแสดงในภาพต่อไปนี้

Step 2 - ติดตั้ง Eclipse IDE -

ตรวจสอบให้แน่ใจว่าได้ติดตั้ง JAVA ในเครื่องของคุณแล้ว
ดาวน์โหลด Eclipse จาก https://eclipse.org/downloads/
ติดตั้ง Unzip และ Eclipse แล้ว

Step 3 - ติดตั้ง Maven -

ดาวน์โหลด Maven -https://maven.apache.org/download.cgi
แตกไฟล์และจำตำแหน่ง
สร้างตัวแปรสภาพแวดล้อม MAVEN_HOME ดังแสดงในภาพต่อไปนี้

แก้ไขตัวแปรเส้นทางและรวม Maven
ดาวน์โหลดปลั๊กอิน MAVEN จาก Eclipse
- เปิด Eclipse
- ได้รับความช่วยเหลือ→ Eclipse Marketplace →ค้นหา maven → Maven Integration for Eclipse → INSTALL

Step 4 - กำหนดค่าแตงกวาด้วย Maven

สร้างโครงการ Maven
- ไปที่ไฟล์→ใหม่→อื่น ๆ → Maven → Maven Project →ถัดไป
- ระบุรหัสกลุ่ม (รหัสกลุ่มจะระบุโครงการของคุณโดยไม่ซ้ำกันในทุกโครงการ)
- ระบุรหัสสิ่งประดิษฐ์ (รหัสวัตถุคือชื่อของ jar ที่ไม่มีเวอร์ชันคุณสามารถเลือกชื่อใดก็ได้ที่เป็นตัวพิมพ์เล็ก)
- คลิกที่ Finish

Step 5 - เปิด pom.xml -

ไปที่ package explorer ทางซ้ายมือของ Eclipse
ขยายโครงการ CucumberTest
ค้นหาไฟล์ pom.xml
คลิกขวาและเลือกตัวเลือกเปิดด้วย“ โปรแกรมแก้ไขข้อความ”

Step 6 - เพิ่มการพึ่งพาสำหรับ Selenium - สิ่งนี้จะระบุ Maven ซึ่งจะต้องดาวน์โหลดไฟล์ Selenium jar จากที่เก็บส่วนกลางไปยังที่เก็บในเครื่อง

เปิด pom.xml อยู่ในโหมดแก้ไขสร้างแท็กการอ้างอิง (<dependencies> </dependencies>) ภายในแท็กโปรเจ็กต์
ภายในแท็กการอ้างอิงให้สร้างแท็กการอ้างอิง (<dependency> </dependency>)
ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>org.seleniumhq.selenium</groupId> 
   <artifactId>selenium-java</artifactId> 
   <version>2.47.1</version> 
</dependency>

Step 7 - เพิ่มการพึ่งพาสำหรับ Cucumber-Java - สิ่งนี้จะระบุ Maven ซึ่งไฟล์ Cucumber จะถูกดาวน์โหลดจากที่เก็บส่วนกลางไปยังที่เก็บในเครื่อง

สร้างแท็กการอ้างอิงขึ้นมาอีกหนึ่งแท็ก
ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-java</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

Step 8 - เพิ่มการพึ่งพาสำหรับ Cucumber-JUnit - สิ่งนี้จะระบุ Maven ซึ่งไฟล์ Cucumber JUnit จะถูกดาวน์โหลดจากที่เก็บกลางไปยังที่เก็บในเครื่อง

สร้างแท็กการอ้างอิงขึ้นมาอีกหนึ่งแท็ก
ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-junit</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

Step 9- เพิ่มการพึ่งพาสำหรับ JUnit - สิ่งนี้จะระบุ Maven ซึ่งไฟล์ JUnit จะถูกดาวน์โหลดจากที่เก็บส่วนกลางไปยังที่เก็บในเครื่อง

สร้างแท็กการอ้างอิงขึ้นมาอีกหนึ่งแท็ก
ระบุข้อมูลต่อไปนี้ภายในแท็กการอ้างอิง

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>

Step 10 - ตรวจสอบไบนารี

เมื่อแก้ไข pom.xml สำเร็จแล้วให้บันทึก
ไปที่ Project → Clean - จะใช้เวลาสักครู่
คุณจะสามารถเห็นที่เก็บ Maven

Step 11 - สร้างแพ็คเกจภายใต้ src/test/java ตั้งชื่อเป็น cucumberJava.

Step 12 - สร้างไฟล์คุณสมบัติ

เลือกและคลิกขวาที่โครงร่างแพ็คเกจ
คลิกที่ไฟล์ 'New'
ตั้งชื่อไฟล์เช่น cucumberJava.feature.
เขียนข้อความต่อไปนี้ภายในไฟล์และบันทึก

Feature: แตงกวา Java

Scenario: มีฟังก์ชันการเข้าสู่ระบบ

ให้ฉันเปิดเบราว์เซอร์

เมื่อเปิดเว็บไซต์ Facebook

จากนั้นปุ่มเข้าสู่ระบบควรออก

Step 13 - สร้างไฟล์กำหนดขั้นตอน -

เลือกและคลิกขวาที่โครงร่างแพ็คเกจ
คลิกที่ไฟล์ 'New'
ตั้งชื่อไฟล์เช่น annotation.java.
เขียนข้อความต่อไปนี้ภายในไฟล์และบันทึก

package CucumberJava; 
import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.firefox.FirefoxDriver; 

import cucumber.annotation.en.Given; 
import cucumber.annotation.en.Then; 
import cucumber.annotation.en.When; 

public class cucumberJava { 
   WebDriver driver = null; 
   @Given("^I have open the browser$") public void openBrowser() { driver = new FirefoxDriver(); } @When("^I open Facebook website$") 
   public void goToFacebook() { 
      driver.navigate().to("https://www.facebook.com/"); 
   } 
   @Then("^Login button should exits$") 
   public void loginButton() { 
      if(driver.findElement(By.id("u_0_v")).isEnabled()) { 
         System.out.println("Test 1 Pass"); 
      } else { 
         System.out.println("Test 1 Fail"); 
      } 
      driver.close(); 
   } 
}

Step 14 - สร้างไฟล์คลาสนักวิ่ง

เลือกและคลิกขวาที่โครงร่างแพ็คเกจ
คลิกที่ไฟล์ 'New'
ตั้งชื่อไฟล์เป็น runTest.java.
เขียนข้อความต่อไปนี้ภายในไฟล์และบันทึก

package cucumberJava; 
import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"}) 
public class runTest { 
}

Step 15 - ทำการทดสอบโดยใช้ตัวเลือก -

เลือกไฟล์ runTest.java จาก package explorer
คลิกขวาและเลือกตัวเลือก Run as.
เลือก JUnit test

คุณจะสังเกตสิ่งต่อไปนี้เมื่อดำเนินการ -

เว็บเบราว์เซอร์ Firefox จะเปิดขึ้น
มันจะเปิดหน้าล็อกอิน Facebook บนเบราว์เซอร์
จะตรวจพบปุ่มล็อกอิน
เบราว์เซอร์จะปิด
ในหน้าต่าง JUnit คุณจะเห็นสถานการณ์ที่มีเครื่องหมายถูกสีเขียวซึ่งแสดงถึงความสำเร็จของการดำเนินการทดสอบ

ภาษา Ruby มีข้อดีดังต่อไปนี้ -

เป็นเรื่องง่ายที่จะเข้าใจ
มันเป็นภาษาเชิงวัตถุ
เป็นไลบรารีคลาสที่มีประสิทธิภาพ
มีการสนับสนุนออนไลน์จำนวนมาก

ต่อไปนี้เป็นกระบวนการทีละขั้นตอนในการทำงานของแตงกวากับ Ruby

Step 1 - ติดตั้ง Ruby

ไปที่หน้าดาวน์โหลด RubyInstaller
ดาวน์โหลดเวอร์ชันที่เหมาะสมที่สุดสำหรับระบบปฏิบัติการของคุณ (เช่น 32 หรือ 64 บิต)
เรียกใช้ exe ที่ดาวน์โหลดมา
ระหว่างการติดตั้งให้เลือกตัวเลือก“ Add Ruby …” และ“ Associate …” ดังที่แสดงในภาพต่อไปนี้

Step 2 - ดาวน์โหลดและแยกชุด Dev

ไปที่หน้าดาวน์โหลด RubyInstaller
ดาวน์โหลดเวอร์ชัน Devkit ที่เหมาะสมที่สุดสำหรับระบบปฏิบัติการของคุณ (เช่น 32 หรือ 64 บิต)
แตกไฟล์ devkit ที่โฟลเดอร์ c: \ Ruby \ Devkit
เปิดพรอมต์คำสั่ง
ภายใน Ruby devkit ให้รันคำสั่งต่อไปนี้

C:\Ruby\devkit> ruby dk.rb init 
C:\Ruby\devkit> ruby dk.rb install

Step 3 - ติดตั้งแตงกวาและอัญมณีทับทิมอื่น ๆ

ในการติดตั้ง Cucumber ให้อัปเดตการตั้งค่าอัญมณีปัจจุบันก่อน

C:\Users\Admin> gem update –system

จากนั้นติดตั้งอัญมณีที่คุณต้องการสำหรับการทดสอบเว็บ Cucumber

C:\Users\Admin> gem install --no-ri --no-rdoc rspec 
C:\Users\Admin> gem install --no-ri --no-rdoc win32console 
C:\Users\Admin> gem install --no-ri --no-rdoc watir-webdriver 
C:\Users\Admin> gem install --no-ri --no-rdoc cucumber

เรียกใช้แตงกวา

C:\Users\Admin\Documents>cucumber –init 
C:\Users\Admin\Documents>cucumber

Step 4 - ติดตั้ง IDE - KOMODO

ไปที่หน้า http://www.activestate.com/komodo-ide/downloads
ดาวน์โหลดตัวติดตั้งทดลองใช้ฟรี
ดับเบิลคลิกที่ exe ที่ดาวน์โหลดมา
ทำตามขั้นตอนการติดตั้ง
เสร็จสิ้นการติดตั้งและเปิด IDE

Step 5 - ติดตั้ง Watir - ไปที่พรอมต์คำสั่งและเรียกใช้คำสั่งต่อไปนี้ "gem install watir"

Step 6 - ติดตั้ง rspec - ไปที่พรอมต์คำสั่งและเรียกใช้คำสั่งต่อไปนี้ "gem install rspec"

Step 7 - สร้างไฟล์คุณสมบัติ

เปิดโปรแกรมแก้ไข KOMODO
คลิกที่ไอคอนไฟล์ใหม่
เขียนข้อความต่อไปนี้

Feature: ผู้ใช้ต้องสามารถค้นหาเนื้อหาโดยใช้ Google

Scenario: ค้นหาคำ

ระบุว่าฉันได้ป้อน "watir" ลงในแบบสอบถาม

เมื่อฉันคลิก "search"

จากนั้นฉันควรจะเห็นผลลัพธ์บางอย่าง

คลิก save ไอคอน.
ตั้งชื่อให้ว่า CucumberRuby.feature
เลือกโฟลเดอร์ใด ๆ ตัวอย่างเช่น: “e:\WithRuby”
บันทึกไฟล์

Step 8 - สร้างไฟล์กำหนดขั้นตอน

เปิดโปรแกรมแก้ไข KOMODO
คลิกไอคอนไฟล์ "ใหม่"
เขียนรหัสต่อไปนี้

require "watir-webdriver" 
require "rspec/expectations" 

Given /^I have entered "([^"]*)" into the query$/ do |term| 
@browser ||= Watir::Browser.new :firefox 
@browser.goto "google.com" 
@browser.text_field(:name => "q").set term 
end 

When /^I click "([^"]*)"$/ do |button_name| @browser.button.click end Then /^I should see some results$/ do 
@browser.div(:id => "resultStats").wait_until_present 
@browser.div(:id => "resultStats").should exist 
@browser.close 
End

คลิกไอคอนบันทึก
ให้ชื่อเป็น CucumberRuby.rb
เลือกโฟลเดอร์ใด ๆ เช่น: “e:\WithRuby”
บันทึกไฟล์

Step 9 - สร้างไฟล์ทดสอบ

เปิดโปรแกรมแก้ไข KOMODO
คลิกที่ไอคอนไฟล์ "ใหม่"
เขียนรหัสต่อไปนี้

require "rubygems" 
require "test/unit" 
require "watir-webdriver" 

class GoogleSearch < Test::Unit::TestCase 
def setup 
@browser ||= Watir::Browser.new :firefox 
end 

def teardown 
@browser.close 
end 

def test_search 
@browser.goto "google.com" 
@browser.text_field(:name => "q").set "watir" 
@browser.button.click 
@browser.div(:id => "resultStats").wait_until_present assert 
@browser.title == "watir - Google Search" 
end 
end