测试“无限循环”时的最佳实践是什么？

Question

我的基本逻辑是在某个地方运行一个无限循环并尽可能地对其进行测试。无限循环的原因并不重要（游戏的主循环，类似守护进程的逻辑......），我更多地询问有关这种情况的最佳实践。

让我们以这段代码为例：

module Blah
  extend self

  def run
     some_initializer_method
     loop do
        some_other_method
        yet_another_method
     end
  end
end

我想使用 Rspec 测试方法 Blah.run （我也使用 RR，但简单的 rspec 将是一个可以接受的答案）。

我认为最好的方法是进一步分解，比如将循环分成另一个方法或其他东西：

module Blah
  extend self

  def run
     some_initializer_method
     do_some_looping
  end

 def do_some_looping
   loop do
     some_other_method
     yet_another_method
   end
 end
end

...这允许我们测试 run 并模拟循环...但是有时需要测试循环内的代码。

那么在这种情况下你会怎么做呢？

只是不测试这个逻辑，这意味着测试 some_other_method & yet_another_method 但不是 do_some_looping ？

循环是否会通过模拟在某个时刻中断？

……还有别的事吗？

Answer 1

更实际的可能是在单独的线程中执行循环，断言一切正常，然后在不再需要该线程时终止该线程。

thread = Thread.new do
  Blah.run
end

assert_equal 0, Blah.foo

thread.kill

Answer 2

在 rspec 3.3 中，将此行添加

allow(subject).to receive(:loop).and_yield

到您的 before 钩子中将简单地屈服于块而无需任何循环

Answer 3

将循环体放在单独的方法中怎么样，例如calculateOneWorldIteration？这样您就可以根据需要在测试中旋转循环。而且它不会损害 API，这是公共接口中非常自然的方法。

Answer 4

你无法测试永远运行的东西。

当遇到难以（或不可能）测试的代码部分时，您应该： -

• 重构以隔离代码中难以测试的部分。让无法测试的部分变得微小而琐碎。注释以确保它们以后不会扩展为不平凡 对
• 其他部分进行单元测试，这些部分现在与难以测试的部分分开
• 难以测试的部分将被集成或验收测试覆盖

如果游戏中的主循环只循环一次，当你运行它时，这一点会立即显而易见。

Answer 5

模拟循环以便仅执行您指定的次数怎么样？

Module Object
    private
    def loop
        3.times { yield }
    end
end

当然，您只能在规格中嘲笑这一点。

Answer 6

我知道这有点老了，但您也可以使用 Yields 方法来伪造一个块并将单个迭代传递给循环方法。这应该允许您测试在循环中调用的方法，而无需实际将其放入无限循环中。

require 'test/unit'
require 'mocha'

class Something
  def test_method
    puts "test_method"
    loop do
      puts String.new("frederick")
    end
  end
end

class LoopTest < Test::Unit::TestCase

  def test_loop_yields
    something = Something.new
    something.expects(:loop).yields.with() do
      String.expects(:new).returns("samantha")
    end
    something.test_method
  end
end

# Started
# test_method
# samantha
# .
# Finished in 0.005 seconds.
#
# 1 tests, 2 assertions, 0 failures, 0 errors

Answer 7

我几乎总是使用 catch/throw 结构来测试无限循环。

引发错误也可能有效，但这并不理想，特别是如果您的循环块挽救了所有错误（包括异常）。如果您的块不能救援 Exception（或其他一些错误类），那么您可以对 Exception（或其他非救援类）进行子类化并救援您的子类：

异常示例

设置

class RspecLoopStop < Exception; end

测试

blah.stub!(:some_initializer_method)
blah.should_receive(:some_other_method)
blah.should_receive(:yet_another_method)
# make sure it repeats
blah.should_receive(:some_other_method).and_raise RspecLoopStop

begin
  blah.run
rescue RspecLoopStop
  # all done
end

Catch/抛出示例：

blah.stub!(:some_initializer_method)
blah.should_receive(:some_other_method)
blah.should_receive(:yet_another_method)
blah.should_receive(:some_other_method).and_throw :rspec_loop_stop

catch :rspec_loop_stop
  blah.run
end

当我第一次尝试这个时，我担心在 :some_other_method 上第二次使用 should_receive 会“覆盖”第一个，但这是不是 案件。如果您想亲自查看，请向 should_receive 添加块，看看它是否被调用了预期的次数：

blah.should_receive(:some_other_method) { puts 'received some_other_method' }

Answer 8

我们测试仅在有信号时退出的循环的解决方案是对退出条件方法进行存根，使其第一次返回 false，第二次返回 true，确保循环只执行一次。

具有无限循环的类：

class Scheduling::Daemon
  def run
    loop do
      if daemon_received_stop_signal?
        break
      end

      # do stuff
    end
  end
end

规范测试循环的行为：

describe Scheduling::Daemon do
  describe "#run" do
    before do
      Scheduling::Daemon.should_receive(:daemon_received_stop_signal?).
        and_return(false, true)  # execute loop once then exit
    end      

    it "does stuff" do
      Scheduling::Daemon.run  
      # assert stuff was done
    end
  end
end

Answer 9

:) 几个月前我有此查询。

简而言之，没有简单的方法来测试这一点。您测试驱动循环的内部结构。然后你将它放入一个循环方法中&手动测试循环是否正常工作，直到发生终止条件。

Answer 10

我发现的最简单的解决方案是产生一次循环然后返回。我这里用的是摩卡。

require 'spec_helper'
require 'blah'

describe Blah do
  it 'loops' do
    Blah.stubs(:some_initializer_method)
    Blah.stubs(:some_other_method)
    Blah.stubs(:yet_another_method)

    Blah.expects(:loop).yields().then().returns()

    Blah.run
  end
end

我们期望循环实际执行，并确保它在一次迭代后退出。

尽管如此，如上所述，保持循环方法尽可能小和愚蠢是一个很好的做法。

希望这有帮助！