我一直在努力将我用于测试驱动 .NET 代码的标准方法调整为 Ruby。

例如，我正在编写一个类，它将:

grab all *.markdown files from a directory
  foreach file:
    extract code samples from file
    save code to file.cs in output directory

通常对于 .NET，我最终会得到类似这样的东西:

class ExamplesToCode {
  public ExamplesToCode(IFileFinder finder, IExampleToCodeConverter converter) { ... }
  public void Convert(string exampleDir, string targetDir) { ... }
}

在我的测试中(首先编写)，我会模拟查找器和转换器。然后我将 finder.FindFiles("*.markdown") stub 以返回 ["file1", "file2"]，并检查 转换器。 Convert("file1", targetDir) 和 converter.Convert("file2", targetDir) 被调用。

我难以将其应用到 Ruby 的地方是 Ruby 倾向于使用 block 和内部迭代器(例如 array.each { |x| puts x })，并在构造函数注入(inject)中包含模块。我不确定在这些情况下如何对代码进行单元测试(没有设置完整的集成测试)，而且 .NET 方法似乎非常不符合规则；它似乎与 Ruby 的自然工作方式相冲突。

关于如何以 Ruby 方式执行此操作的任何建议？这个例子的 Ruby 测试的例子会很棒。

最佳答案

您可以进行类似这样的类(class)测试:

class ExamplesToCodeTest < Test::Unit::TestCase
  def test_convert
    # have some example markdown files in a fixtures directory
    ExamplesToCode.convert("test/fixtures/*.markdown")
    assert_equal expected_output_1, File.read("test/output/file_1.cs")
    assert_equal expected_output_2, File.read("test/output/file_2.cs")
    assert_equal expected_output_3, File.read("test/output/file_3.cs")
  end
  private
    def expected_output_1
      "... expected stuff here ..."
    end
    def expected_output_2
      "... expected stuff here ..."
    end
    def expected_output_3
      "... expected stuff here ..."
    end
end

我想这会是一个不错的集成测试，但这不是我真正喜欢的，我喜欢将我的代码分成一口大小的 block

首先，我会创建一个可以处理解析 Markdown 文件的类，例如:

class MarkdownReaderTest < Test::Unit::TestCase
  def test_read_code_sample_1
    reader = MarkdownReader.new
    code_sample = reader.read("fixtures/code_sample_1.markdown")
    # or maybe something like this:
    # code_sample = reader.parse(File.read("fixtures/code_sample_1.markdown"))
    # if you want the reader to just be a parser...
    assert_equal code_sample_1, code_sample
  end
  # ... repeat for other types of code samples ...
  private
    def code_sample_1
      "text of code sample 1 here..."
    end
end

现在所有读取和解析 markdown 文件的代码都在 MarkdownReader 类中。现在，如果我们不想实际编写文件，您可以使用 RR 或 Mocha 或其他东西进行一些模拟(我在这里使用 rr):

class CodeSampleWriter < Test::Unit::TestCase
  include RR::Adapters::TestUnit
  def test_write_code_sample
    # assuming CodeSampleWriter class is using the File.write()...
    any_instance_of(File) do |f|
      mock(f).write(code_sample_text) { true }
    end
    writer = CodeSampleWriter.new
    writer.write(code_sample_text)
  end
  private
    def code_sample_text
      "... code sample text here ..."
    end
end

现在假设 ExamplesToCode 类使用 MarkdownReader 和 CodeSampleWriter 类，您可以像这样再次使用带有 RR 的模拟对象:

class ExamplesToCodeTest < Test::Unit::TestCase
  include RR::Adapters::TestUnit
  def test_convert
    # mock the dir, so we don't have to have an actual dir with files...
    mock(Dir).glob("*.markdown") { markdown_file_paths }
    # mock the reader, so we don't actually read files...
    any_instance_of(MarkdownReader) do |reader|
      mock(reader).read("file1.markdown") { code_sample_1 }
      mock(reader).read("file2.markdown") { code_sample_1 }
      mock(reader).read("file3.markdown") { code_sample_1 }
    end
    # mock the writer, so we don't actually write files...
    any_instance_of(CodeSampleWriter) do |writer|
      mock(writer).write_code_sample(code_sample_1) { true }
      mock(writer).write_code_sample(code_sample_2) { true }
      mock(writer).write_code_sample(code_sample_3) { true }
    end
    # now that the mocks are mocked, it's go time!
    ExamplesToCode.new.convert("*.markdown")
  end
  private
    def markdown_file_paths
      ["file1.markdown", "file2.markdown", "file3.markdown"]
    end
    def code_sample_1; "... contents of file 1 ..."; end
    def code_sample_2; "... contents of file 2 ..."; end
    def code_sample_3; "... contents of file 3 ..."; end
end

希望这能让您对如何在 Ruby 中进行测试有所了解。不是煽动性的，但在大多数情况下，依赖注入(inject)在 Ruby 世界中是看不到或使用的东西——它通常会增加很多开销。模拟/ double 通常是更好的测试选择。

关于c# - 如何从 .NET 风格的 TDD 迁移到 Ruby？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/3682405/