Mã thử nghiệm đơn vị với một phụ thuộc hệ thống tập tin

Tôi đang viết một thành phần, được cung cấp một tệp ZIP, cần phải:

1. Giải nén tập tin.
2. Tìm một dll cụ thể trong số các tập tin được giải nén.
3. Tải dll đó thông qua sự phản chiếu và gọi một phương thức trên nó.

Tôi muốn đơn vị kiểm tra thành phần này.

Tôi muốn viết mã liên quan trực tiếp đến hệ thống tệp:

void DoIt()
{
   Zip.Unzip(theZipFile, "C:\\foo\\Unzipped");
   System.IO.File myDll = File.Open("C:\\foo\\Unzipped\\SuperSecret.bar");
   myDll.InvokeSomeSpecialMethod();
}

Nhưng mọi người thường nói, "Đừng viết các bài kiểm tra đơn vị dựa trên hệ thống tệp, cơ sở dữ liệu, mạng, v.v."

Nếu tôi viết nó theo cách thân thiện với bài kiểm tra đơn vị, tôi cho rằng nó sẽ giống như thế này:

void DoIt(IZipper zipper, IFileSystem fileSystem, IDllRunner runner)
{
   string path = zipper.Unzip(theZipFile);
   IFakeFile file = fileSystem.Open(path);
   runner.Run(file);
}

Yay! Bây giờ nó có thể kiểm tra được; Tôi có thể cung cấp thử nghiệm nhân đôi (giả) cho phương pháp DoIt. Nhưng với chi phí nào? Bây giờ tôi đã phải xác định 3 giao diện mới chỉ để làm cho thử nghiệm này. Và chính xác thì tôi đang thử nghiệm cái gì? Tôi đang kiểm tra rằng chức năng DoIt của tôi tương tác đúng với các phụ thuộc của nó. Nó không kiểm tra rằng tệp zip đã được giải nén đúng cách, v.v.

Nó không cảm thấy như tôi đang thử nghiệm chức năng nữa. Cảm giác như tôi chỉ đang thử nghiệm các tương tác trong lớp.

Câu hỏi của tôi là : cách thích hợp để kiểm tra đơn vị gì đó phụ thuộc vào hệ thống tệp?

chỉnh sửa Tôi đang sử dụng .NET, nhưng khái niệm này cũng có thể áp dụng Java hoặc mã gốc.

Thực sự không có gì sai với điều này, đó chỉ là câu hỏi liệu bạn gọi nó là kiểm tra đơn vị hay kiểm tra tích hợp. Bạn chỉ cần đảm bảo rằng nếu bạn tương tác với hệ thống tệp, không có tác dụng phụ ngoài ý muốn. Cụ thể, đảm bảo rằng bạn dọn dẹp sau khi bạn - xóa bất kỳ tệp tạm thời nào bạn đã tạo - và bạn không vô tình ghi đè lên một tệp hiện có có cùng tên tệp với tệp tạm thời bạn đang sử dụng. Luôn luôn sử dụng các đường dẫn tương đối và không phải là đường dẫn tuyệt đối.

Nó cũng là một ý tưởng tốt để chdir()vào một thư mục tạm thời trước khi chạy thử nghiệm của bạn và chdir()trở lại sau đó.

Yay! Bây giờ nó có thể kiểm tra được; Tôi có thể cung cấp thử nghiệm nhân đôi (giả) cho phương pháp DoIt. Nhưng với chi phí nào? Bây giờ tôi đã phải xác định 3 giao diện mới chỉ để làm cho thử nghiệm này. Và chính xác thì tôi đang thử nghiệm cái gì? Tôi đang kiểm tra rằng chức năng DoIt của tôi tương tác đúng với các phụ thuộc của nó. Nó không kiểm tra rằng tệp zip đã được giải nén đúng cách, v.v.

Bạn đã đánh móng tay ngay trên đầu của nó. Những gì bạn muốn kiểm tra là logic của phương pháp của bạn, không nhất thiết là liệu một tập tin thực sự có thể được giải quyết hay không. Bạn không cần phải kiểm tra (trong bài kiểm tra đơn vị này) xem một tệp có được giải nén chính xác hay không, phương pháp của bạn sẽ được chấp nhận. Các giao diện có giá trị bởi vì chúng cung cấp các khái niệm trừu tượng mà bạn có thể lập trình chống lại, thay vì dựa hoàn toàn hoặc rõ ràng dựa vào một triển khai cụ thể.

Câu hỏi của bạn cho thấy một trong những phần khó nhất của thử nghiệm dành cho các nhà phát triển mới tham gia vào nó:

"Cái quái gì tôi kiểm tra?"

Ví dụ của bạn không thú vị lắm vì nó chỉ kết hợp một số lệnh gọi API với nhau, vì vậy nếu bạn viết một bài kiểm tra đơn vị cho nó, bạn sẽ chỉ khẳng định rằng các phương thức được gọi. Các thử nghiệm như thế này kết hợp chặt chẽ các chi tiết thực hiện của bạn với thử nghiệm. Điều này là xấu vì bây giờ bạn phải thay đổi thử nghiệm mỗi khi bạn thay đổi chi tiết triển khai phương thức của mình vì thay đổi chi tiết triển khai sẽ phá vỡ (các) thử nghiệm của bạn!

Có các bài kiểm tra xấu thực sự tồi tệ hơn là không có bài kiểm tra nào cả.

Trong ví dụ của bạn:

void DoIt(IZipper zipper, IFileSystem fileSystem, IDllRunner runner)
{
   string path = zipper.Unzip(theZipFile);
   IFakeFile file = fileSystem.Open(path);
   runner.Run(file);
}

Mặc dù bạn có thể vượt qua trong giả, không có logic trong phương pháp để kiểm tra. Nếu bạn đã thử một bài kiểm tra đơn vị cho việc này, nó có thể trông giống như thế này:

// Assuming that zipper, fileSystem, and runner are mocks
void testDoIt()
{
  // mock behavior of the mock objects
  when(zipper.Unzip(any(File.class)).thenReturn("some path");
  when(fileSystem.Open("some path")).thenReturn(mock(IFakeFile.class));

  // run the test
  someObject.DoIt(zipper, fileSystem, runner);

  // verify things were called
  verify(zipper).Unzip(any(File.class));
  verify(fileSystem).Open("some path"));
  verify(runner).Run(file);
}

Xin chúc mừng, về cơ bản, bạn đã dán các chi tiết triển khai DoIt()phương pháp của mình vào một bài kiểm tra. Hạnh phúc duy trì.

Khi bạn viết bài kiểm tra, bạn muốn kiểm tra CÁI GÌ chứ không phải CÁCH . Xem Kiểm tra hộp đen để biết thêm.

Các GÌ là tên của phương pháp của bạn (hoặc ít nhất là nó nên có). Các CÁCH là tất cả các chi tiết thực hiện ít mà sống bên trong phương pháp của bạn. Các bài kiểm tra tốt cho phép bạn trao đổi CÁCH mà không phá vỡ CÁI GÌ .

Nghĩ về nó theo cách này, hãy tự hỏi:

"Nếu tôi thay đổi chi tiết thực hiện của phương pháp này (mà không thay đổi hợp đồng công khai) thì nó có phá vỡ (các) thử nghiệm của tôi không?"

Nếu câu trả lời là có, bạn đang kiểm tra CÁCH chứ không phải CÁI GÌ .

Để trả lời câu hỏi cụ thể của bạn về mã kiểm tra với các phụ thuộc hệ thống tệp, giả sử bạn có điều gì đó thú vị hơn một chút với tệp và bạn muốn lưu nội dung được mã hóa Base64 của byte[]tệp vào tệp. Bạn có thể sử dụng các luồng cho việc này để kiểm tra xem mã của bạn có làm đúng hay không mà phải kiểm tra xem nó làm như thế nào . Một ví dụ có thể giống như thế này (trong Java):

interface StreamFactory {
    OutputStream outStream();
    InputStream inStream();
}

class Base64FileWriter {
    public void write(byte[] contents, StreamFactory streamFactory) {
        OutputStream outputStream = streamFactory.outStream();
        outputStream.write(Base64.encodeBase64(contents));
    }
}

@Test
public void save_shouldBase64EncodeContents() {
    OutputStream outputStream = new ByteArrayOutputStream();
    StreamFactory streamFactory = mock(StreamFactory.class);
    when(streamFactory.outStream()).thenReturn(outputStream);

    // Run the method under test
    Base64FileWriter fileWriter = new Base64FileWriter();
    fileWriter.write("Man".getBytes(), streamFactory);

    // Assert we saved the base64 encoded contents
    assertThat(outputStream.toString()).isEqualTo("TWFu");
}

Xét nghiệm này sử dụng một ByteArrayOutputStreamnhưng trong ứng dụng (sử dụng dependency injection) các StreamFactory thực (có lẽ gọi là FileStreamFactory) sẽ quay trở lại FileOutputStreamtừ outputStream()và sẽ viết thư cho một File.

Điều thú vị về writephương pháp ở đây là nó đã viết nội dung ra mã hóa Base64, vì vậy đó là những gì chúng tôi đã thử nghiệm. Đối với DoIt()phương pháp của bạn , điều này sẽ được kiểm tra phù hợp hơn với kiểm tra tích hợp .

Tôi thận trọng để làm ô nhiễm mã của tôi với các loại và khái niệm chỉ tồn tại để tạo điều kiện cho thử nghiệm đơn vị. Chắc chắn, nếu nó làm cho thiết kế sạch hơn và tốt hơn thì tuyệt vời, nhưng tôi nghĩ đó thường không phải là trường hợp.

Tôi cho rằng điều này là các bài kiểm tra đơn vị của bạn sẽ làm nhiều nhất có thể mà có thể không được bảo hiểm 100%. Trong thực tế, nó có thể chỉ là 10%. Vấn đề là, bài kiểm tra đơn vị của bạn phải nhanh và không có phụ thuộc bên ngoài. Họ có thể kiểm tra các trường hợp như "phương thức này đưa ra một ArgumentNullException khi bạn chuyển thành null cho tham số này".

Sau đó, tôi sẽ thêm các thử nghiệm tích hợp (cũng tự động và có thể sử dụng cùng một khung thử nghiệm đơn vị) có thể có các phụ thuộc bên ngoài và thử nghiệm các kịch bản từ đầu đến cuối như các kịch bản này.

Khi đo độ bao phủ mã, tôi đo cả hai bài kiểm tra đơn vị và tích hợp.

Không có gì sai khi nhấn hệ thống tập tin, chỉ coi đó là một bài kiểm tra tích hợp chứ không phải là một bài kiểm tra đơn vị. Tôi sẽ trao đổi đường dẫn được mã hóa cứng bằng một đường dẫn tương đối và tạo một thư mục con TestData để chứa các khóa cho các bài kiểm tra đơn vị.

Nếu các bài kiểm tra tích hợp của bạn mất quá nhiều thời gian để chạy thì hãy tách chúng ra để chúng không chạy thường xuyên như các bài kiểm tra đơn vị nhanh của bạn.

Tôi đồng ý, đôi khi tôi nghĩ thử nghiệm dựa trên tương tác có thể gây ra quá nhiều khớp nối và thường kết thúc không cung cấp đủ giá trị. Bạn thực sự muốn kiểm tra việc giải nén tệp ở đây không chỉ xác minh rằng bạn đang gọi đúng phương thức.

Một cách sẽ là viết phương thức giải nén để lấy InputStreams. Sau đó, kiểm tra đơn vị có thể xây dựng một InputStream như vậy từ một mảng byte bằng cách sử dụng ByteArrayInputStream. Nội dung của mảng byte đó có thể là một hằng số trong mã kiểm tra đơn vị.

Đây có vẻ là một thử nghiệm tích hợp nhiều hơn vì bạn phụ thuộc vào một chi tiết cụ thể (hệ thống tệp) có thể thay đổi, theo lý thuyết.

Tôi sẽ trừu tượng mã liên quan đến HĐH thành mô-đun của riêng nó (lớp, lắp ráp, jar, bất cứ thứ gì). Trong trường hợp của bạn, bạn muốn tải một DLL cụ thể nếu được tìm thấy, vì vậy hãy tạo giao diện IDllLoader và lớp DLLLoader. Ứng dụng của bạn có nhận được DLL từ DLLLoader bằng giao diện và kiểm tra xem .. bạn không chịu trách nhiệm về mã giải nén phải không?

Giả sử rằng "tương tác hệ thống tệp" được kiểm tra tốt trong chính khung công tác, tạo phương thức của bạn để làm việc với các luồng và kiểm tra điều này. Mở FileStream và chuyển nó sang phương thức có thể được bỏ qua các thử nghiệm của bạn, vì FileStream.Open được kiểm tra tốt bởi những người tạo khung.

Bạn không nên kiểm tra tương tác lớp và gọi hàm. thay vào đó bạn nên xem xét thử nghiệm tích hợp. Kiểm tra kết quả yêu cầu và không hoạt động tải tập tin.

Đối với thử nghiệm đơn vị, tôi khuyên bạn nên bao gồm tệp thử nghiệm trong dự án của mình (tệp EAR hoặc tương đương) sau đó sử dụng đường dẫn tương đối trong các thử nghiệm đơn vị, ví dụ: "../testdata/testfile".

Miễn là dự án của bạn được xuất / nhập chính xác hơn kiểm tra đơn vị của bạn sẽ hoạt động.

Như những người khác đã nói, lần đầu tiên là tốt như một bài kiểm tra tích hợp. Các thử nghiệm thứ hai chỉ những gì chức năng được cho là thực sự làm, đó là tất cả các thử nghiệm đơn vị nên làm.

Như được hiển thị, ví dụ thứ hai có vẻ hơi vô nghĩa, nhưng nó cho bạn cơ hội để kiểm tra cách hàm phản ứng với các lỗi trong bất kỳ bước nào. Bạn không có bất kỳ lỗi kiểm tra nào trong ví dụ, nhưng trong hệ thống thực bạn có thể có, và việc tiêm phụ thuộc sẽ cho phép bạn kiểm tra tất cả các phản hồi đối với bất kỳ lỗi nào. Sau đó, chi phí sẽ có giá trị nó.