คงเป็น "ความชั่วร้าย" ในระดับสากลสำหรับการทดสอบหน่วยและถ้าเป็นเช่นนั้นทำไม Resharper จึงแนะนำ [ปิด]

ฉันได้พบว่ามีเพียง 3 วิธีในการทดสอบหน่วยอ้างอิง (จำลอง / ต้นขั้ว) ที่คงที่ใน C # .NET:

• ไฝ
• TypeMock
• JustMock

เนื่องจากว่าสองสิ่งนี้ไม่ฟรีและไม่มีการปล่อยรุ่น 1.0 การเยาะเย้ยสิ่งคงไม่ง่ายเกินไป

นั่นทำให้วิธีการคงที่และ "ความชั่วร้าย" (ในแง่การทดสอบหน่วย) หรือไม่? และถ้าเป็นเช่นนั้นทำไม resharper จึงต้องการให้ฉันทำอะไรที่คงที่ (การสมมติว่า resharper ไม่ได้เป็น "ความชั่วร้าย" ด้วย)

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

เมื่อมองไปที่คำตอบอื่น ๆ ที่นี่ฉันคิดว่าอาจมีความสับสนระหว่างวิธีการคงที่ที่มีสถานะคงที่หรือก่อให้เกิดผลข้างเคียง

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

ดูเหมือนว่าคุณจะทำให้เกิดความสับสนคงข้อมูลและแบบคงที่วิธีการ Resharper ถ้าฉันจำได้อย่างถูกต้องแนะนำให้ทำprivateวิธีการภายในชั้นคงที่ถ้าพวกเขาสามารถทำได้ - ฉันเชื่อว่าสิ่งนี้ให้ผลประโยชน์การปฏิบัติน้อย มันไม่ได้แนะนำให้ทำ "อะไรที่สามารถจะ" คงที่!

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

public static long Square(int x)
{
    return x * x;
}

จากนั้นจึงสามารถทดสอบได้อย่างชัดเจนและไม่มีผลข้างเคียง คุณแค่ตรวจสอบว่าเมื่อคุณผ่านพูด 20 คุณได้ 400 กลับไม่มีปัญหา

หากคำถามจริงที่นี่คือ "ฉันจะทดสอบรหัสนี้ได้อย่างไร":

public class MyClass
{
   public void MethodToTest()
   {
       //... do something
       MyStaticClass.StaticMethod();
       //...more
   }
}

จากนั้นเพียงแค่ refactor รหัสและฉีดตามปกติการเรียกคลาสแบบคงที่เช่นนี้:

public class MyClass
{
   private readonly IExecutor _externalExecutor;
   public MyClass(_IExecutor executor)
   {
       _exeternalExecutor = executor;
   }

   public void MethodToTest()
   {
       //... do something
       _exetrnalExecutor.DoWork();
       //...more
   }
}

public class MyStaticClassExecutor : IExecutor
{
    public void DoWork()
    {
        MyStaticClass.StaticMethod();
    }
}

สถิตไม่จำเป็นต้องชั่ว แต่พวกเขาสามารถ จำกัด ตัวเลือกของคุณเมื่อมันมาถึงการทดสอบหน่วยกับปลอม / mocks / ต้นขั้ว

มีวิธีการทั่วไปสองวิธีในการเยาะเย้ย

คนแรก (แบบดั้งเดิม - ดำเนินการโดย RhinoMocks, Moq, NMock2; mocks และตอไม้ด้วยตนเองอยู่ในค่ายนี้ด้วย) อาศัยการทดสอบตะเข็บและการฉีดพึ่งพา สมมติว่าคุณกำลังทดสอบโค้ดคงที่บางหน่วยและมีการอ้างอิง สิ่งที่มักจะเกิดขึ้นในรหัสที่ได้รับการออกแบบด้วยวิธีนี้เป็นที่สถิตสร้างการพึ่งพาตัวเอง inverting ผกผันพึ่งพา ในไม่ช้าคุณจะค้นพบว่าคุณไม่สามารถฉีดอินเทอร์เฟซที่เยาะเย้ยลงในรหัสภายใต้การทดสอบที่ออกแบบมาด้วยวิธีนี้

คนที่สอง (เยาะเย้ยอะไร - ดำเนินการโดย TypeMock, JustMock และโมล) อาศัย .NET ของProfiling API มันสามารถดักคำสั่ง CIL ใด ๆ ของคุณและแทนที่โค้ดของคุณด้วยปลอม สิ่งนี้ทำให้ TypeMock และผลิตภัณฑ์อื่น ๆ ในค่ายนี้เยาะเย้ยอะไรก็ได้: สถิตยศาสตร์ชั้นเรียนที่ปิดสนิทวิธีส่วนตัว - สิ่งที่ไม่ได้ออกแบบมาให้ทดสอบได้

มีการถกเถียงกันอย่างต่อเนื่องระหว่างโรงเรียนแห่งความคิดสองแห่ง หนึ่งกล่าวว่าปฏิบัติตามหลักการและการออกแบบเพื่อการทดสอบความทนทาน (ซึ่งมักจะรวมถึงสถิตยศาสตร์) อีกอันหนึ่งบอกว่าซื้อ TypeMock และไม่ต้องกังวล

ตรวจสอบนี้: "วิธีการคงเป็นความตายที่จะตรวจสอบได้" สรุปสั้น ๆ ของการโต้แย้ง:

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

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

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

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

ระบุว่ามีสามตัวเลือก:

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

2. อย่าสร้างการพึ่งพาเวลารวบรวมระหว่างคลาสที่คุณรับผิดชอบการทดสอบ วิธีนี้ใช้ได้ผลโดยที่คุณไม่ต้องสนใจรูปแบบโค้ดที่ได้

3. อย่าทดสอบหน่วยรวมการทดสอบการรวมแทน ใช้งานได้จริงหากไม่ขัดแย้งกับสิ่งอื่นที่คุณต้องใช้ในการทดสอบการรวมระบบ

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

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

ก่อน:

    public static DBConnection ConnectToDB( string dbName, string connectionInfo ) {
    }

หลังจาก:

    public static Func<string, string, DBConnection> ConnectToDB (dbName, connectionInfo ) {
    };

ทั้งสองเข้ากันได้กับการโทร ผู้โทรไม่จำเป็นต้องเปลี่ยน ร่างกายของฟังก์ชั่นยังคงเหมือนเดิม

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

        Database.ConnectToDB = (dbName, connectionInfo) => { return null|whatever; }

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

    [TestCleanup]
    public void Cleanup()
    {
        typeof(Database).TypeInitializer.Invoke(null, null);
    }

ซึ่งจะเรียกใช้ initializer คงที่ของคลาสของคุณอีกครั้ง

แลมบ์ดาฟันซ์ไม่ได้รับการสนับสนุนมากมายเหมือนวิธีการคงที่ทั่วไปดังนั้นวิธีนี้จึงมีผลข้างเคียงที่ไม่พึงประสงค์ดังต่อไปนี้:

1. หากวิธีสแตติกเป็นวิธีส่วนขยายคุณต้องเปลี่ยนเป็นวิธีที่ไม่ใช่ส่วนขยายก่อน Resharper สามารถทำสิ่งนี้ให้คุณโดยอัตโนมัติ
2. ถ้าชนิดข้อมูลใด ๆ ของวิธีการแบบคงที่มีแอสเซมบลีที่ฝังตัว interop เช่นสำหรับ Office คุณต้องตัดวิธีการตัดคำชนิดหรือเปลี่ยนเป็นชนิด 'วัตถุ'
3. คุณไม่สามารถใช้เครื่องมือการเปลี่ยนโครงสร้างการเปลี่ยนลายเซ็นของ Resharper ได้อีกต่อไป

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

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

เหตุใด C # จึงมีวิธีคงที่ ทำไมจึงอนุญาตให้ใช้วิธีการที่ไม่ใช่เสมือนได้

หากคุณใช้ "ฟีเจอร์" เหล่านี้คุณจะไม่สามารถสร้างวิธีแยกได้

แล้วคุณจะใช้มันเมื่อไหร่?

ใช้รหัสดังกล่าวที่คุณไม่ต้องการให้ใครออกไป ตัวอย่าง: เมธอด Format () ของคลาส String วิธี WriteLine () ของคลาส Console เมธอด Cosh () ของคลาส Math

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

1. ฉันเชื่อว่าส่วนหนึ่งเป็นเพราะวิธีการคงที่ "เร็วขึ้น" ในการโทรกว่าวิธีการแบบอินสแตนซ์ (ในเครื่องหมายคำพูดเนื่องจากกลิ่นของการเพิ่มประสิทธิภาพขนาดเล็ก) ดูที่http://dotnetperls.com/static-method
2. กำลังบอกคุณว่าไม่จำเป็นต้องมีรัฐดังนั้นจึงสามารถโทรจากที่ใดก็ได้ลบค่าใช้จ่ายในการติดตั้งถ้านั่นเป็นสิ่งเดียวที่ใครบางคนต้องการ
3. หากฉันต้องการเยาะเย้ยฉันก็คิดว่าโดยทั่วไปแล้วมันเป็นแนวปฏิบัติที่ประกาศไว้บนอินเทอร์เฟซ
4. ถ้ามันถูกประกาศในอินเทอร์เฟซแล้ว R # จะไม่แนะนำให้คุณทำให้มันคงที่
5. ถ้ามันถูกประกาศว่าเป็นเสมือนดังนั้น R # จะไม่แนะนำให้คุณทำให้มันคงที่เช่นกัน
6. โฮลดิ้งของรัฐ (เขต) คงเป็นสิ่งที่ควรได้รับการพิจารณาอย่างรอบคอบ สถานะคงที่และหัวข้อผสมเช่นลิเธียมและน้ำ

R # ไม่ใช่เครื่องมือเดียวที่จะทำให้ข้อเสนอแนะนี้ การวิเคราะห์รหัส FxCop / MS ก็จะทำเช่นเดียวกัน

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

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

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

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

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

ตอนนี้สำหรับเรื่องความเป็นไปได้ของสถานการณ์นี้ไม่ควรเป็นปัญหาเพราะคุณไม่ควรทดสอบวิธีการส่วนตัว

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