กลยุทธ์ที่ดีที่สุดสำหรับแอปพลิเคชันที่ใช้ฐานข้อมูลทดสอบคืออะไร


346

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

แต่การทดสอบ ORM และฐานข้อมูลนั้นมักจะเต็มไปด้วยปัญหาและการประนีประนอม

ในช่วงหลายปีที่ผ่านมาฉันได้ลองใช้กลยุทธ์สองสามข้อ

  • โหลดฐานข้อมูลทดสอบด้วยข้อมูลที่ทราบ เรียกใช้การทดสอบกับ ORM และยืนยันว่าข้อมูลที่ถูกต้องกลับมา ข้อเสียของที่นี่คือฐานข้อมูลการทดสอบของคุณต้องติดตามการเปลี่ยนแปลงใด ๆ ของสคีมาในฐานข้อมูลแอปพลิเคชัน นอกจากนี้ยังขึ้นอยู่กับข้อมูลเทียมและอาจไม่เปิดเผยข้อบกพร่องที่เกิดขึ้นเนื่องจากการป้อนข้อมูลของผู้ใช้ที่โง่ ในที่สุดหากฐานข้อมูลทดสอบมีขนาดเล็กก็จะไม่เปิดเผยความไร้ประสิทธิภาพเช่นดัชนีที่ขาดหายไป (ตกลงว่าอันสุดท้ายไม่ใช่การทดสอบหน่วยที่ควรใช้ แต่ไม่เจ็บ)

  • โหลดสำเนาของฐานข้อมูลการผลิตและทดสอบกับที่ ปัญหาที่นี่คือคุณอาจไม่รู้ว่ามีอะไรในฐานข้อมูลการผลิตในเวลาใดก็ตาม การทดสอบของคุณอาจต้องเขียนใหม่หากข้อมูลเปลี่ยนแปลงตลอดเวลา

บางคนชี้ให้เห็นว่ากลยุทธ์ทั้งสองนี้ขึ้นอยู่กับข้อมูลที่เฉพาะเจาะจงและการทดสอบหน่วยควรทดสอบการทำงานเท่านั้น ด้วยเหตุนี้ฉันได้เห็นข้อเสนอแนะ:

  • ใช้เซิร์ฟเวอร์ฐานข้อมูลจำลองและตรวจสอบเฉพาะว่า ORM กำลังส่งแบบสอบถามที่ถูกต้องเพื่อตอบสนองต่อการเรียกใช้เมธอดที่กำหนด

คุณใช้กลยุทธ์อะไรในการทดสอบแอพพลิเคชันที่ใช้ฐานข้อมูลหากมี สิ่งที่ได้ผลดีที่สุดสำหรับคุณ


ฉันคิดว่าคุณยังควรมีดัชนีฐานข้อมูลในสภาพแวดล้อมการทดสอบสำหรับกรณีเช่นดัชนีเฉพาะ
dtc

ฉัน pesonally ไม่รังเกียจคำถามนี้ที่นี่ แต่ถ้าเราไปตามกฎคำถามนี้ไม่ได้สำหรับstackoverflowแต่สำหรับซอฟต์แวร์ engineering.stackexchange เว็บไซต์
ITExpert

คำตอบ:


155

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

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

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

  3. สำหรับกลุ่มของฉันการป้อนข้อมูลผู้ใช้จะกระทำที่ระดับแอปพลิเคชัน (ไม่ใช่ db) ดังนั้นจึงเป็นการทดสอบผ่านการทดสอบหน่วยมาตรฐาน

กำลังโหลดสำเนาฐานข้อมูลการผลิต:
นี่เป็นวิธีการที่ใช้ในงานล่าสุดของฉัน มันเป็นสาเหตุของความเจ็บปวดอย่างมากในสองประเด็น:

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

เซิร์ฟเวอร์ฐานข้อมูลที่เยาะเย้ย:
เราทำสิ่งนี้ในงานปัจจุบันของฉัน หลังจากคอมมิชชันทุกครั้งเราจะทำการทดสอบหน่วยกับรหัสแอปพลิเคชันที่มีการเข้าถึงฐานข้อมูลจำลอง mock db จากนั้นสามครั้งต่อวันเราดำเนินการสร้างฐานข้อมูลแบบเต็มที่อธิบายไว้ข้างต้น ฉันขอแนะนำวิธีการทั้งสองอย่างแน่นอน


37
การโหลดสำเนาฐานข้อมูลการผลิตยังมีความปลอดภัยและความเป็นส่วนตัว เมื่อมันเริ่มมีขนาดใหญ่การคัดลอกและนำไปไว้ในสภาพแวดล้อมการพัฒนาของคุณอาจเป็นเรื่องใหญ่
WW

ความจริงแล้วนี่เป็นความเจ็บปวดครั้งใหญ่ ฉันยังใหม่กับการทดสอบและฉันยังเขียน orm ฉันต้องการทดสอบ ฉันใช้วิธีแรกของคุณแล้ว แต่อ่านว่ามันไม่ได้สร้างหน่วยทดสอบ ฉันใช้ฟังก์ชั่นเครื่องยนต์ db เฉพาะและการเยาะเย้ย DAO จะยาก ฉันคิดว่าไม่ดีแค่ใช้วิธีการปัจจุบันของฉันเพราะมันใช้งานได้และคนอื่นใช้มัน ทดสอบอัตโนมัติ rock btw ขอบคุณ
frostymarvelous

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

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

ควรใช้การปรับปรุงและการเยาะเย้ยลิงให้ดีขึ้นและหลีกเลี่ยงการเขียน
Nickpick

56

ฉันมักจะทำการทดสอบกับฐานข้อมูลในหน่วยความจำ (HSQLDB หรือ Derby) ด้วยเหตุผลเหล่านี้:

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

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

ข้อมูลถูกโหลดจาก SQL, เท็มเพลตฐานข้อมูลหรือดัมพ์ / การสำรองข้อมูล ฉันชอบที่ทิ้งถ้าพวกเขาอยู่ในรูปแบบที่อ่านได้เพราะฉันสามารถวางไว้ใน VCS หากไม่ได้ผลฉันจะใช้ไฟล์ CSV หรือ XML ถ้าฉันต้องโหลดข้อมูลจำนวนมหาศาล ... ฉันทำไม่ได้ คุณไม่ต้องโหลดข้อมูลจำนวนมหาศาล :) ไม่ใช่สำหรับการทดสอบหน่วย การทดสอบประสิทธิภาพเป็นปัญหาอื่นและใช้กฎที่แตกต่างกัน


1
ความเร็วเป็นเหตุผลเดียวที่ใช้ (โดยเฉพาะ) ฐานข้อมูลในหน่วยความจำหรือไม่?
rinogo

2
ฉันเดาว่าข้อได้เปรียบอีกอย่างอาจเป็นเรื่องของ "ความไม่แน่นอน" - ไม่จำเป็นต้องทำความสะอาดตัวเอง เพียงฆ่าฐานข้อมูลในหน่วยความจำ (แต่มีวิธีอื่นในการทำสิ่งนี้ให้สำเร็จเช่นวิธี ROLLBACK ที่คุณพูดถึง)
rinogo

1
ข้อได้เปรียบคือการทดสอบแต่ละครั้งสามารถเลือกกลยุทธ์เป็นรายบุคคล เรามีการทดสอบที่ทำงานในเธรดลูกซึ่งหมายความว่าสปริงจะให้ข้อมูลเสมอ
Aaron Digulla

@Aaron: เรากำลังติดตามกลยุทธ์นี้เช่นกัน ฉันอยากจะรู้ว่ากลยุทธ์ของคุณที่จะยืนยันว่าโมเดลในหน่วยความจำมีโครงสร้างเดียวกันกับฐานข้อมูลจริงหรือไม่?
Guillaume

1
@ Guillaume: ฉันกำลังสร้างฐานข้อมูลทั้งหมดจากไฟล์ SQL เดียวกัน H2 เป็นสิ่งที่ยอดเยี่ยมสำหรับสิ่งนี้เนื่องจากรองรับส่วนใหญ่ของฐานข้อมูลหลัก หากไม่ได้ผลฉันจะใช้ตัวกรองที่ใช้ SQL ดั้งเดิมและแปลงเป็น SQL สำหรับฐานข้อมูลในหน่วยความจำ
Aaron Digulla

14

ฉันได้ถามคำถามนี้มานาน แต่ฉันคิดว่าไม่มีกระสุนเงินสำหรับสิ่งนั้น

สิ่งที่ฉันทำอยู่ในขณะนี้คือการเยาะเย้ยวัตถุ DAO และเก็บไว้ในหน่วยความจำแทนชุดที่ดีของวัตถุที่เป็นตัวแทนกรณีที่น่าสนใจของข้อมูลที่สามารถอยู่บนฐานข้อมูล

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

อีกวิธีหนึ่งที่ฉันพบว่าน่าสนใจมาก แต่ไม่คุ้มค่าเสมอไปเนื่องจากเป็นการเสียเวลาเพียงเล็กน้อยคือการสร้างสคีมาที่คุณใช้สำหรับการผลิตบนฐานข้อมูลแบบฝังที่เพิ่งทำงานภายในการทดสอบหน่วย

แม้ว่าจะไม่มีคำถามวิธีนี้จะปรับปรุงความครอบคลุมของคุณ แต่ก็มีข้อเสียเล็กน้อยเนื่องจากคุณจะต้องใกล้เคียงที่สุดกับ ANSI SQL เพื่อให้ทำงานได้ทั้งกับ DBMS ปัจจุบันของคุณและการแทนที่แบบฝังตัว

ไม่ว่าสิ่งที่คุณคิดว่าเป็นที่เกี่ยวข้องมากขึ้นสำหรับรหัสของคุณมีไม่กี่โครงการออกมีที่อาจจะทำให้มันง่ายขึ้นเช่นDbUnit


13

แม้ว่าจะมีเครื่องมือที่ช่วยให้คุณสามารถที่จะเยาะเย้ยฐานข้อมูลของคุณในทางใดทางหนึ่ง (เช่นjOOQ 's MockConnectionซึ่งสามารถเห็นได้ในคำตอบนี้ - ปฏิเสธผมทำงานสำหรับผู้ขาย jOOQ) ที่ผมจะแนะนำให้ไม่ได้ที่จะเยาะเย้ยฐานข้อมูลขนาดใหญ่ที่มีความซับซ้อน คำสั่ง

แม้ว่าคุณเพียงแค่ต้องการรวมทดสอบ ORM ของคุณโปรดระวังว่า ORM จะออกแบบสอบถามที่ซับซ้อนมากไปยังฐานข้อมูลของคุณซึ่งอาจแตกต่างกันไปใน

  • วากยสัมพันธ์
  • ความซับซ้อน
  • คำสั่งซื้อ (!)

การเยาะเย้ยสิ่งที่สร้างข้อมูลหุ่นที่มีเหตุผลนั้นค่อนข้างยากเว้นแต่ว่าคุณจะสร้างฐานข้อมูลเล็ก ๆ น้อย ๆ ในการจำลองซึ่งแปลคำสั่ง SQL ที่ส่ง ต้องบอกว่าให้ใช้ฐานข้อมูลทดสอบการรวมที่รู้จักกันดีซึ่งคุณสามารถรีเซ็ตได้อย่างง่ายดายด้วยข้อมูลที่รู้จักกันดีซึ่งคุณสามารถรันการทดสอบการรวมระบบได้


5

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

ฉันยังทำการเปลี่ยนแปลงทั้งหมด (รวมถึงสกีมาฐานข้อมูล) กับสภาพแวดล้อมการทดสอบของฉันก่อนดังนั้นจึงกลายเป็นวิธีอื่น ๆ : หลังจากการทดสอบทั้งหมดผ่านให้ใช้การปรับปรุงสคีมากับโฮสต์การผลิต ฉันยังคงทำการทดสอบคู่กับฐานข้อมูลแอปพลิเคชันแยกต่างหากในระบบการพัฒนาของฉันเพื่อให้ฉันสามารถตรวจสอบได้ว่าการอัพเกรดฐานข้อมูลทำงานได้อย่างถูกต้องก่อนสัมผัสกล่องผลิตจริง


3

ฉันใช้วิธีแรก แต่แตกต่างกันเล็กน้อยที่ช่วยแก้ไขปัญหาที่คุณกล่าวถึง

ทุกอย่างที่จำเป็นในการเรียกใช้การทดสอบสำหรับ DAO อยู่ในการควบคุมของแหล่งที่มา มันมีสคีมาและสคริปต์เพื่อสร้างฐานข้อมูล (นักเทียบท่าเป็นสิ่งที่ดีสำหรับเรื่องนี้) หากสามารถใช้ฐานข้อมูลแบบฝังได้ - ฉันใช้เพื่อความเร็ว

ความแตกต่างที่สำคัญกับวิธีการอธิบายอื่น ๆ คือข้อมูลที่จำเป็นสำหรับการทดสอบไม่ได้โหลดจากสคริปต์ SQL หรือไฟล์ XML ทุกอย่าง (ยกเว้นข้อมูลพจนานุกรมบางส่วนที่มีประสิทธิภาพคงที่) สร้างขึ้นโดยแอปพลิเคชันโดยใช้ฟังก์ชัน / คลาสยูทิลิตี้

วัตถุประสงค์หลักคือเพื่อให้ข้อมูลที่ใช้โดยการทดสอบ

  1. ใกล้กับการทดสอบมาก
  2. ชัดเจน (การใช้ไฟล์ SQL สำหรับข้อมูลทำให้เกิดปัญหามากในการดูว่าส่วนใดของข้อมูลที่ใช้ในการทดสอบแบบใด)
  3. แยกการทดสอบออกจากการเปลี่ยนแปลงที่ไม่เกี่ยวข้อง

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

เพื่อให้ความคิดของสิ่งที่มันหมายในทางปฏิบัติบางพิจารณาการทดสอบสำหรับ DAO บางส่วนที่ทำงานร่วมกับCommentเพื่อPosts Authorsเขียนโดย เพื่อทดสอบการทำงานของ CRUD สำหรับ DAO เช่นนั้นข้อมูลบางอย่างควรถูกสร้างขึ้นในฐานข้อมูล การทดสอบจะมีลักษณะดังนี้:

@Test
public void savedCommentCanBeRead() {
    // Builder is needed to declaratively specify the entity with all attributes relevant
    // for this specific test
    // Missing attributes are generated with reasonable values
    // factory's responsibility is to create entity (and all entities required by it
    //  in our example Author) in the DB
    Post post = factory.create(PostBuilder.post());

    Comment comment = CommentBuilder.comment().forPost(post).build();

    sut.save(comment);

    Comment savedComment = sut.get(comment.getId());

    // this checks fields that are directly stored
    assertThat(saveComment, fieldwiseEqualTo(comment));
    // if there are some fields that are generated during save check them separately
    assertThat(saveComment.getGeneratedField(), equalTo(expectedValue));        
}

สิ่งนี้มีข้อดีกว่าสคริปต์ SQL หรือไฟล์ XML ที่มีข้อมูลทดสอบ:

  1. การบำรุงรักษารหัสนั้นง่ายกว่ามาก (การเพิ่มคอลัมน์บังคับเช่นในบางเอนทิตีที่อ้างอิงในการทดสอบหลายอย่างเช่นผู้แต่งไม่จำเป็นต้องเปลี่ยนไฟล์ / บันทึกจำนวนมาก แต่เพียงการเปลี่ยนแปลงในตัวสร้างและ / หรือโรงงาน)
  2. ข้อมูลที่ต้องการโดยการทดสอบที่เฉพาะเจาะจงอธิบายไว้ในการทดสอบตัวเองและไม่ได้อยู่ในไฟล์อื่น ๆ ความใกล้เคียงนี้มีความสำคัญอย่างยิ่งสำหรับความเข้าใจในการทดสอบ

ย้อนกลับ vs กระทำ

ฉันคิดว่าสะดวกกว่าที่จะทำการทดสอบเมื่อมีการดำเนินการ ประการแรกเอฟเฟกต์บางอย่าง (ตัวอย่างDEFERRED CONSTRAINTS) ไม่สามารถตรวจสอบได้หากการกระทำไม่เคยเกิดขึ้น ประการที่สองเมื่อการทดสอบล้มเหลวสามารถตรวจสอบข้อมูลในฐานข้อมูลได้เนื่องจากไม่ได้ทำการย้อนกลับโดยการย้อนกลับ

ด้วยสาเหตุนี้มีข้อเสียที่การทดสอบอาจสร้างข้อมูลที่เสียหายและสิ่งนี้จะนำไปสู่ความล้มเหลวในการทดสอบอื่น ๆ เพื่อจัดการกับเรื่องนี้ฉันพยายามที่จะแยกการทดสอบ ในตัวอย่างข้างต้นทุกการทดสอบอาจสร้างใหม่Authorและหน่วยงานอื่น ๆ ทั้งหมดจะถูกสร้างขึ้นที่เกี่ยวข้องกับมันเพื่อให้การชนเป็นเรื่องยาก เพื่อจัดการกับค่าคงที่ที่เหลือซึ่งอาจแตกหัก แต่ไม่สามารถแสดงเป็นข้อ จำกัด ระดับ DB ฉันใช้การตรวจสอบแบบเป็นโปรแกรมบางอย่างสำหรับเงื่อนไขที่ผิดพลาดที่อาจเรียกใช้หลังจากการทดสอบทุกครั้ง (และพวกเขาจะทำงานใน CI เหตุผล)


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

ดังนั้นเพื่อความกระจ่าง: คุณใช้ฟังก์ชั่นยูทิลิตี้ / คลาสตลอดทั้งแอปพลิเคชันของคุณหรือเพียงเพื่อการทดสอบของคุณ?
Ella

@Ella ฟังก์ชันยูทิลิตี้เหล่านี้มักไม่จำเป็นต้องใช้นอกรหัสทดสอบ PostBuilder.post()คิดว่าสำหรับตัวอย่างเกี่ยวกับ มันสร้างค่าบางอย่างสำหรับแอตทริบิวต์บังคับทั้งหมดของโพสต์ ไม่จำเป็นต้องใช้ในรหัสการผลิต
Roman Konoval

2

สำหรับโครงการที่ใช้ JDBC (โดยตรงหรือโดยอ้อมเช่น JPA, EJB, ... ) คุณสามารถจำลองไม่ใช่ฐานข้อมูลทั้งหมด (ในกรณีเช่นนี้จะเป็นการดีกว่าที่จะใช้ทดสอบฐานข้อมูลบน RDBMS จริง) แต่จะจำลองระดับ JDBC เท่านั้น .

ข้อได้เปรียบคือสิ่งที่เป็นนามธรรมซึ่งมาพร้อมกับวิธีการดังกล่าวเนื่องจากข้อมูล JDBC (ชุดผลลัพธ์, จำนวนการอัพเดต, การเตือน, ... ) จะเหมือนกันทุกอย่างที่เป็นแบ็กเอนด์: prod db ของคุณ, การทดสอบ db หรือข้อมูล mockup บางรายการ กรณี.

ด้วยการเชื่อมต่อ JDBC เยาะเย้ยสำหรับแต่ละกรณีไม่จำเป็นต้องจัดการทดสอบ db (ล้างข้อมูลเพียงหนึ่งการทดสอบในเวลาเดียวติดตั้งโหลด, ... ) การเชื่อมต่อ mockup ทุกครั้งจะถูกแยกออกและไม่จำเป็นต้องทำความสะอาด มีเพียงการติดตั้งที่น้อยที่สุดที่จำเป็นในการทดสอบแต่ละกรณีเพื่อจำลองการแลกเปลี่ยน JDBC ซึ่งช่วยหลีกเลี่ยงความซับซ้อนในการจัดการฐานข้อมูลทดสอบทั้งหมด

Acolyte เป็นกรอบของฉันซึ่งรวมถึงไดรเวอร์ JDBC และยูทิลิตี้สำหรับชนิดของ mockup นี้: http://acolyte.eu.org

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.