คำถามติดแท็ก testing

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

10 development-process  testing 

เมื่อเร็ว ๆ นี้ฉันคิดถึงรหัสที่ปลอดภัยมาก Thread ปลอดภัย หน่วยความจำที่ปลอดภัย ไม่ระเบิดในหน้าของคุณด้วย -a- segfault ปลอดภัย แต่เพื่อความชัดเจนในคำถามลองใช้โมเดลความปลอดภัยของรัสเป็นคำจำกัดความต่อเนื่องของเรา บ่อยครั้งที่การทำให้มั่นใจในความปลอดภัยนั้นเป็นปัญหาใหญ่แค่ไหนเพราะได้รับการพิสูจน์โดยความต้องการของ Rust unsafeมีแนวคิดการเขียนโปรแกรมที่สมเหตุสมผลเช่นการเห็นพ้องต้องกันซึ่งไม่สามารถนำมาใช้ใน Rust ได้โดยไม่ต้องใช้unsafeคำสำคัญ . แม้ว่าการทำงานพร้อมกันสามารถทำให้ปลอดภัยได้อย่างสมบูรณ์แบบด้วยการล็อก mutexes ช่องทางและการแยกหน่วยความจำหรือสิ่งที่มีอยู่คุณต้องทำงานนอกรูปแบบความปลอดภัยของ Rust ด้วยunsafeแล้วรับรองตัวแปลด้วยตนเองว่า"ใช่ฉันรู้ว่าฉันกำลังทำอะไร สิ่งนี้ดูไม่ปลอดภัย แต่ฉันได้พิสูจน์แล้วว่าในทางคณิตศาสตร์มันปลอดภัยอย่างสมบูรณ์ " แต่ปกติแล้วจะลงมาด้วยตนเองทำให้รูปแบบของสิ่งเหล่านี้และพวกเขาพิสูจน์ความปลอดภัยอยู่กับprovers ทฤษฎีบท จากทั้งมุมมองวิทยาศาสตร์คอมพิวเตอร์ (เป็นไปได้) และมุมมองการปฏิบัติจริง (มันจะใช้ชีวิตของจักรวาล) มันสมเหตุสมผลที่จะจินตนาการโปรแกรมที่ใช้รหัสโดยพลการในภาษาใด ๆ และประเมินว่ามันเป็นหรือไม่ " ปลอดภัยสนิม "? คำเตือน : สิ่งที่ง่ายในเรื่องนี้ก็คือการชี้ให้เห็นว่าโปรแกรมอาจจะปล่อยปละละเลยดังนั้นปัญหาการหยุดทำงานจึงทำให้เราล้มเหลว สมมติว่าโปรแกรมใดก็ตามที่ส่งไปยังผู้อ่านนั้นรับประกันว่าจะหยุด ในขณะที่ "รหัสโดยพลการในภาษาใด ๆ " เป็นเป้าหมาย แต่ฉันก็ตระหนักว่าสิ่งนี้ขึ้นอยู่กับความคุ้นเคยของโปรแกรมกับภาษาที่เลือกซึ่งเราจะดำเนินการตามที่กำหนด

10 algorithms  testing  computer-science  rust 

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

9 testing  qa  pricing  risk 

ฉันเพิ่งดู"ทุกสิ่งเล็ก ๆ น้อย ๆ "จาก RailsConf 2014 ในระหว่างการพูดคุยนี้ Sandi Metz refactors ฟังก์ชั่นที่รวมถึงคำสั่ง if ซ้อนขนาดใหญ่: def tick if @name != 'Aged Brie' && @name != 'Backstage passes to a TAFKAL80ETC concert' if @quality > 0 if @name != 'Sulfuras, Hand of Ragnaros' @quality -= 1 end end else ... end ... …

9 unit-testing  testing  refactoring  ruby  rewrite 

ฉันมีรหัสบางอย่างในโครงการของฉันฉันเรียกตัวเองtestsว่าไม่ใช่การทดสอบหน่วย พวกเขาตั้งใจที่จะวิ่งและผลลัพธ์จะต้องมีการประเมินโดยมนุษย์ ฉันทำสิ่งนี้เพราะฉันสร้างเครื่องยนต์ฟิสิกส์และในระหว่างการพัฒนาฉันต้องดูว่าฉันกำลังทำอะไรอยู่ ดังนั้นฉันจึงทำsimulationแพ็คเกจในโมดูลทดสอบ เป็นการทดสอบหน่วยทางเทคนิคเพราะการจำลองกำลังใช้ไลบรารีการทดสอบหน่วย แต่ฉันไม่ได้ตั้งใจที่จะเรียกใช้พวกเขาทั้งหมดเช่นการทดสอบหน่วยที่แท้จริงของฉัน สิ่งที่ฉันต้องการทำคือแยกความแตกต่างของการทดสอบพิเศษจากการทดสอบหน่วยของฉันเพราะฉันต้องการเรียกใช้การทดสอบหน่วยทั้งหมดได้อย่างง่ายดาย ฉันคิดว่ามันเหมือนกับการทดสอบเชิงหน้าที่ คุณเคยเจอกรณีที่คุณต้องเตรียมใบสมัครสำหรับการทดสอบการทำงานหรือไม่? การจัดเตรียมการทดสอบการทำงาน (โดยทั่วไปคือแบบจำลองของฉัน) อยู่ที่ไหนในโครงการและวิธีแยกแยะความแตกต่างจากการทดสอบหน่วย ฉันอยู่ใน Java ดังนั้นฉันสามารถเปลี่ยนลายเซ็นวิธีการทั้งหมดของฉันจาก@Test public void myNamedTest()เป็นpublic static void main(String[] args)แต่มันจะลำบากและเป็นประโยชน์น้อยกว่าสำหรับฉันที่จะใช้แบบจำลองของฉัน ฉันใช้junitในgradleโครงการ โซลูชันใด ๆ ที่สร้างโฟลเดอร์ทดสอบพิเศษด้วยgradleยินดีต้อนรับ

9 java  unit-testing  testing  functional-testing  gradle 

พื้นหลังเล็กน้อยของฉัน - ฉันเป็นผู้ทดสอบด้วยตนเองเป็นเวลาเกือบ 2 ปีในสภาพแวดล้อม Agile โดยใช้ SCRUM (1-2 สัปดาห์ในการวิ่ง) ดังนั้นฉันต้องการที่จะแนะนำการทดสอบระบบอัตโนมัติในงานของฉันโดยใช้ Selenium WebDriver (กับ Java) คำถามของฉันอยู่ในระหว่างเมื่อฉันควรทดสอบการทำงานด้วยตนเองและเมื่อฉันควรแปลงพวกเขาสำหรับการทดสอบอัตโนมัติ ฉันได้อ่านและรับแนวทางที่แตกต่างเช่น: เมื่อเริ่มการวิ่งใหม่ให้แปลงเรื่องราวของผู้ใช้เป็นสคริปต์อัตโนมัติจากการวิ่งก่อนหน้านี้หรือ; แปลงเรื่องราวของผู้ใช้ภายในการวิ่งเดียวกัน คำแนะนำใด ๆ / s จะได้รับการชื่นชมอย่างมาก ขอบคุณล่วงหน้า.

9 testing  agile  scrum  selenium  test-automation 

บางครั้งฟังก์ชั่นส่วนตัวของโมดูลหรือคลาสนั้นเป็นฟังก์ชั่นภายในที่ยังไม่ถูกแยกออกมาซึ่งอาจสมควรได้รับการทดสอบของตัวเอง ดังนั้นทำไมไม่ทดสอบพวกเขา เราจะเขียนการทดสอบสำหรับพวกเขาในภายหลังหาก / เมื่อพวกเขากำลังสกัด เหตุใดจึงไม่เขียนการทดสอบตอนนี้เมื่อพวกเขายังคงเป็นส่วนหนึ่งของไฟล์เดียวกัน เพื่อสาธิต: module_aครั้งแรกที่ผมเขียน ตอนนี้ฉันต้องการเขียนแบบทดสอบ _private_funcผมอยากจะทดสอบฟังก์ชั่น 'ส่วนตัว' ฉันไม่เข้าใจว่าทำไมฉันถึงไม่เขียนการทดสอบถ้าในภายหลังฉันอาจปรับโครงสร้างให้กับโมดูลภายในของตัวเองแล้วเขียนการทดสอบ สมมติว่าฉันมีโมดูลที่มีฟังก์ชั่นต่อไปนี้ (มันอาจจะเป็นคลาส): def public_func(a): b = _do_stuff(a) return _do_more_stuff(b) _do_stuffและ_do_more_stuffเป็นฟังก์ชั่น 'ส่วนตัว' ของโมดูล ฉันเข้าใจความคิดที่ว่าเราควรทดสอบส่วนต่อประสานสาธารณะเท่านั้นไม่ใช่รายละเอียดการใช้งาน อย่างไรก็ตามนี่คือสิ่งที่: _do_stuffและ_do_more_stuffมีฟังก์ชั่นส่วนใหญ่ของโมดูล แต่ละคนอาจเป็นฟังก์ชั่นสาธารณะของโมดูล 'ภายใน' ที่แตกต่างกัน แต่พวกเขายังไม่พัฒนาและมีขนาดใหญ่พอที่จะแยกไปยังไฟล์แยก ดังนั้นการทดสอบฟังก์ชั่นเหล่านี้จึงถูกต้องเพราะมันเป็นหน่วยงานที่สำคัญ หากพวกเขาอยู่ในโมดูลที่แตกต่างกันเป็นฟังก์ชั่นสาธารณะเราจะได้ทดสอบพวกเขา ดังนั้นทำไมไม่ทดสอบพวกเขาเมื่อพวกเขายังไม่ได้ (หรือเคย) แยกเป็นไฟล์อื่น?

9 python  testing 

ฉันมีลำดับชั้นคลาส Java ที่เกิดขึ้นจากชั้นนามธรรมและส่วนขยาย N ของมัน ในคลาส abstract ฉันมีเมธอดที่ถูกเพิ่มความคิดเห็นด้วยหมายเหตุประกอบ @Remove แม้ว่าเราจะไม่ได้รับข้อยกเว้นใด ๆ ที่จะไม่ล้มเหลวหากลบหมายเหตุนี้เราอาจได้รับการยกเว้นหน่วยความจำดังนั้นฉันจึงต้องการให้แน่ใจว่าเราสังเกตเห็นอย่างรวดเร็วที่สุดหากคำอธิบายประกอบนี้หายไปในการซ่อมแซมบางส่วน ฉันกำลังพยายามสร้าง GUTS (การทดสอบหน่วยที่ดี) ดังนั้นฉันคิดว่าฉันสามารถจัดทำเอกสาร "ข้อกำหนดทางเทคนิค" นี้ในการทดสอบของฉันพร้อมกรณีทดสอบที่ระบุไว้ แต่นี่ไม่ใช่คุณสมบัติมันเป็นรายละเอียดการใช้งานและไม่ได้เชื่อมโยงกับพฤติกรรมของวิธีการ (วิธีการอาจว่างเปล่า แต่ต้องมีอยู่และจะต้องมีคำอธิบายประกอบ) การสร้างแบบทดสอบสำหรับสิ่งนั้นหรือมีวิธีอื่นในการตรวจสอบการมีอยู่ของคำอธิบายประกอบนี้หรือไม่?

9 java  unit-testing  testing 

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

9 testing 

TL; DRฉันต้องการความช่วยเหลือในการระบุเทคนิคเพื่อลดความซับซ้อนของการทดสอบหน่วยอัตโนมัติเมื่อทำงานภายในกรอบงานที่เป็นมลรัฐ พื้นหลัง: ฉันกำลังเขียนเกมใน typescript และเป็นกรอบ Phaser Phaser อธิบายว่าตัวเองเป็นเกมเฟรมเวิร์ก HTML5 ที่พยายามอย่างน้อยที่สุดเพื่อ จำกัด โครงสร้างของรหัสของคุณ สิ่งนี้มาพร้อมกับการแลกเปลี่ยนไม่กี่อย่างนั่นคือมีPhaser God-object อยู่ซึ่งอนุญาตให้คุณเข้าถึงทุกสิ่ง: แคชฟิสิกส์สถานะเกมและอื่น ๆ สถานะนี้ทำให้ยากต่อการทดสอบการใช้งานมากมายเช่นไทล์แมปของฉัน ลองดูตัวอย่าง: ที่นี่ฉันกำลังทดสอบว่าเลเยอร์ไทล์ของฉันถูกต้องหรือไม่และฉันสามารถระบุกำแพงและสิ่งมีชีวิตภายในไทล์แมปของฉัน: export class TilemapTest extends tsUnit.TestClass { constructor() { super(); this.map = this.mapLoader.load("maze", this.manifest, this.mazeMapDefinition); this.parameterizeUnitTest(this.isWall, [ [{ x: 0, y: 0 }, true], [{ x: 1, y: 1 }, …

9 javascript  testing  typescript 

ในช่วงสองสามสัปดาห์ที่ผ่านมาฉันได้ครุ่นคิดและค้นคว้าวิธีเติมช่องว่างในวิธีการทดสอบของเรา ในการทดสอบหน่วยคำศัพท์ที่ง่ายมีขนาดเล็กเกินไปและการทดสอบการรวมแบบดั้งเดิมนั้นใหญ่เกินไป สถานการณ์ที่เกิดขึ้นบ่อยครั้งที่Aและองค์ประกอบการใช้งานทั้งB Cอย่างไรก็ตามAและมีความต้องการที่แตกต่างกันเล็กน้อยและทำให้สมมติฐานแตกต่างกันเล็กน้อยเกี่ยวกับB Cหากฉันเป็นผู้พัฒนาAฉันจะทดสอบสมมติฐานของฉันได้Cอย่างไรและที่ไหน? เห็นได้ชัดว่าการทดสอบหน่วยที่Aมีข้อสมมติฐานล้อเลียนเกี่ยวกับCการทดสอบAแยกได้ แต่ก็ไม่ได้ทดสอบสมมติฐานเอง Cเป็นไปได้ก็คือการเพิ่มการทดสอบหน่วยสำหรับ อย่างไรก็ตามสิ่งนี้ไม่เหมาะเพราะในขณะที่Aอยู่ระหว่างการพัฒนาการเปลี่ยนแปลงการทดสอบCด้วยข้อสมมติฐานที่พัฒนาขึ้นจากAนั้นจะมีความเงอะงะมากเกินไป อันที่จริงAs นักพัฒนาอาจไม่ได้มีการเข้าถึงเพียงพอที่จะทดสอบหน่วยของC(เช่นห้องสมุดภายนอก) ในการจัดวางสิ่งนี้ด้วยตัวอย่างที่ชัดเจนยิ่งขึ้น: สมมติว่านี่เป็นแอปพลิเคชั่นของโหนด AและBขึ้นอยู่กับCการอ่านไฟล์ (ในหมู่สิ่งอื่น ๆ ) Cและการจัดเก็บเนื้อหาของแฟ้มในวัตถุส่งผ่านไปยัง ในตอนแรกไฟล์ทั้งหมดที่Cจัดการมีขนาดเล็กและสามารถอ่านแบบซิงโครนัสโดยไม่มีการบล็อกที่สำคัญ อย่างไรก็ตามผู้พัฒนาBตระหนักว่าไฟล์ของเขามีขนาดใหญ่ขึ้นและจำเป็นต้องเปลี่ยนCมาอ่านแบบ async ซึ่งส่งผลให้เกิดข้อผิดพลาดในการซิงโครไนซ์เป็นระยะAซึ่งยังคงCมีการอ่านไฟล์ นี่เป็นประเภทของบั๊กที่ยากต่อการติดตามจากการทดสอบการรวมระบบแบบสมบูรณ์และอาจไม่สามารถทำการทดสอบการรวมระบบได้เลย มันไม่ได้ถูกจับโดยAการทดสอบหน่วย s เพราะAข้อสันนิษฐานนั้นถูกเยาะเย้ย แต่มันได้อย่างง่ายดายจับโดย "มินิ" บูรณาการทดสอบว่าการออกกำลังกายเพียงและAC ฉันพบการอ้างอิงประเภทนี้ของการทดสอบเพียงเล็กน้อยเท่านั้น บูรณาการในขนาดเล็ก , การทดสอบส่วนประกอบของการรวม , หน่วยบูรณาการการทดสอบ นอกจากนี้ยังเกี่ยวข้องกับทิศทางการทดสอบ BDDค่อนข้างมากกว่าการทดสอบ TDD อย่างเป็นทางการ ฉันจะเติมช่องว่างการทดสอบนี้ได้อย่างไร โดยเฉพาะ - ฉันจะทำการทดสอบแบบไหน? ฉันจะจำลองอินพุตAและCสำหรับการทดสอบการรวม "มินิ" ได้อย่างไร และควรแยกความกังวลเรื่องการทดสอบระหว่างการทดสอบและการทดสอบหน่วยเท่าไหร่ หรือมีวิธีที่ดีกว่าในการเติมเต็มช่องว่างในการทดสอบ?

9 unit-testing  testing  node.js  integration-tests  bdd 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน6 ปีที่ผ่านมา เมื่อเร็ว ๆ นี้ฉันคิดถึงเรื่องการสร้างทีมพัฒนาแบบลีน ท้ายที่สุดฉันต้องการเปิดบ้านซอฟต์แวร์เล็ก ๆ ของฉันด้วยคนจำนวนน้อยที่มีใจเดียวกัน เป้าหมายจะไม่กลายเป็นคนรวย แต่มีสภาพแวดล้อมในการทำงานที่ดี จนถึงตอนนี้ฉันกำหนดทีมแบบลีนดังต่อไปนี้: เล็ก ๆ น้อย ๆ จัดการตนเอง; สมาชิกทุกคนจะต้องมีการควบคุมคุณภาพในใจ; สมาชิกจะต้องสามารถดำเนินการได้หลายบทบาท จุดสุดท้ายคือที่ที่ฉันกังวลเล็กน้อยเพราะเมื่อมนต์ไป ... นักพัฒนาทำการทดสอบที่ไม่ดี ในขณะที่ฉันเข้าใจว่ามักจะมีนักพัฒนา "ใกล้เกินไป" รหัสหรือโค้ดเพื่อนร่วมงานของพวกเขาที่จะทำให้การประเมินผลในระดับที่สูงขึ้นของคุณภาพของพวกเขาผมไม่เชื่อว่าพวกเขาจะพฤตินัยทดสอบที่ไม่ดี ในทางตรงกันข้ามฉันเห็นว่าคุณภาพของนักพัฒนาที่ดีทับซ้อนกันอย่างมากกับคุณภาพของผู้ทดสอบที่ดี สมมติว่าถูกต้องฉันคิดวิธีที่แตกต่างของการแก้ไขปัญหา dev / ผู้ทดสอบและฉันเชื่อว่าฉันมากับแบบจำลองที่ทำงานได้ โมเดลของฉันต้องการ: บ้านซอฟต์แวร์ขนาดเล็กที่มี 2+ โครงการ วิธี Agile (ซ้ำ) เพื่อการพัฒนาและการส่งมอบ 1 ทีมต่อโครงการ สมาชิกในทีมทั้งหมดจะเป็นนักพัฒนาซอฟต์แวร์ รายละเอียดงานของพวกเขาจะระบุอย่างชัดเจนการพัฒนา , การประกันคุณภาพ , การทดสอบและการจัดส่งสินค้าเป็นความรับผิดชอบ …

9 agile  testing  organization 

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

9 testing  sql  math  relational-database 

ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้เป็นหัวข้อสำหรับ Software Engineering Stack Exchange ปิดให้บริการใน4 ปีที่แล้ว ฉันต้องการทราบแนวคิดของการจัดหมวดหมู่ข้อบกพร่องโดยพิจารณาจากความง่ายในการแก้และประโยชน์ที่จะได้รับ ตัวอย่างเช่นหากมีข้อผิดพลาดซึ่งจะใช้เวลาหนึ่งชั่วโมง (ปิดไฟล์สองครั้งและอื่น ๆ ) เพื่อแก้ปัญหา vs อีกอันหนึ่งซึ่งใช้เวลาหนึ่งวัน แต่ถ้าการแก้ไขข้อผิดพลาดครั้งแรกนั้นไม่สำคัญมากฉันก็คงจะแก้ไขข้อที่สองได้ มีงานวิจัยใดบ้างที่จัดกลุ่มข้อบกพร่องโดยพิจารณาจากประโยชน์ด้านต้นทุนหรือตัวชี้วัดที่คล้ายคลึงกัน สมมติว่าเป็นไปได้ที่จะจัดหมวดหมู่บั๊กตามลักษณะของข้อบกพร่องเช่นความเสี่ยงด้านความปลอดภัยข้อผิดพลาดของหน่วยความจำข้อผิดพลาดเชิงตรรกะ ฯลฯ ในมิติอื่น ๆ อาจมีพารามิเตอร์เช่นความยากลำบาก (ง่ายปานกลางยาก) มีมิติอื่น ๆ ที่ฉันควรมองหาหรือไม่ เพื่อให้สิ่งต่าง ๆ ง่ายขึ้นฉันสามารถสรุปได้สองสิ่ง: โปรแกรมเมอร์ทุกคนในทีมมีความสามารถเท่าเทียมกันในการแก้ไขข้อบกพร่องใด ๆ ไม่มีกำหนด

9 testing  software  issue-tracking 

เรามีห้องทดสอบสามชุด: ชุด "เล็ก" ใช้เวลาเพียงสองสามชั่วโมงในการทำงาน ชุด "กลาง" ที่ใช้เวลาหลายชั่วโมงโดยปกติแล้วจะวิ่งทุกคืน (ทุกคืน) ชุด "ใหญ่" ที่ใช้เวลาหนึ่งสัปดาห์ + ในการทำงาน เรามีห้องทดสอบสั้นกว่านี้เยอะ แต่ฉันไม่ได้สนใจที่นี่ วิธีการในปัจจุบันคือการเรียกใช้ชุดเล็กก่อนที่แต่ละกระทำเพื่อลำต้น จากนั้นชุดสื่อขนาดกลางจะทำงานทุกคืนและหากในตอนเช้ามันกลับกลายเป็นว่าล้มเหลวเราพยายามแยกแยะว่าการกระทำของเมื่อวานนี้คือการตำหนิการย้อนกลับที่กระทำและทดสอบอีกครั้ง กระบวนการที่คล้ายกันจะทำเพียงสัปดาห์ละครั้งแทนความถี่ทุกคืนสำหรับห้องสวีทขนาดใหญ่ น่าเสียดายที่ชุดสื่อกลางล้มเหลวค่อนข้างบ่อย นั่นหมายความว่าลำตัวมักไม่เสถียรซึ่งน่ารำคาญอย่างยิ่งเมื่อคุณต้องการแก้ไขและทดสอบพวกมัน มันน่ารำคาญเพราะเมื่อฉันเช็คเอาต์จากท้ายรถฉันไม่สามารถรู้ได้อย่างแน่นอนว่ามันเสถียรและหากการทดสอบล้มเหลวฉันไม่สามารถทราบได้อย่างแน่นอนว่าเป็นความผิดของฉันหรือไม่ คำถามของฉันคือมีวิธีการบางอย่างที่รู้จักกันในการจัดการสถานการณ์ประเภทนี้ในลักษณะที่จะทำให้ลำต้นอยู่ในสภาพดีเสมอ? เช่น "กระทำเป็นพิเศษในสาขา precommit ซึ่งจะทำการปรับปรุงลำต้นเป็นระยะทุกครั้งที่ผ่านไปทุกคืน" และมันจะสำคัญไหมถ้ามันเป็นระบบควบคุมแหล่งรวมส่วนกลางอย่าง SVN หรือระบบที่กระจายแบบ git? โดยวิธีการที่ฉันเป็นนักพัฒนาจูเนียร์ที่มีความสามารถที่ จำกัด ในการเปลี่ยนแปลงสิ่งต่าง ๆ ฉันแค่พยายามที่จะเข้าใจว่ามีวิธีการจัดการกับความเจ็บปวดนี้ที่ฉันกำลังประสบ

9 testing  version-control  development-methodologies  branching