zold 0.32.0 → 0.32.1

data/test/node/test_front.rb

@@ -1,379 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2018-2025 Zerocracy
-# SPDX-License-Identifier: MIT
-
-require 'json'
-require 'time'
-require 'securerandom'
-require 'threads'
-require 'zold/score'
-require 'memory_profiler'
-require_relative '../test__helper'
-require_relative 'fake_node'
-require_relative '../fake_home'
-require_relative '../../lib/zold/http'
-require_relative '../../lib/zold/age'
-require_relative '../../lib/zold/json_page'
-
-class FrontTest < Zold::Test
-  def app
-    Zold::Front
-  end
-
-  # Use this test to check how much memory is being used after doing a large
-  # number of routine operations. There should be no suspicious information
-  # in the report, which will be printed to the console.
-  def test_memory_leakage
-    skip
-    report = MemoryProfiler.report(top: 10) do
-      FakeNode.new(log: fake_log).run(opts('--network=foo')) do |port|
-        100.times do
-          Zold::Http.new(uri: "http://localhost:#{port}/", network: 'foo').get
-        end
-      end
-    end
-    report.pretty_print
-  end
-
-  def test_renders_front_json
-    FakeNode.new(log: fake_log).run(opts('--network=foo')) do |port|
-      res = Zold::Http.new(uri: "http://localhost:#{port}/", network: 'foo').get
-      json = JSON.parse(res.body)
-      assert_equal(Zold::VERSION, json['version'])
-      assert_equal(Zold::PROTOCOL, json['protocol'])
-      assert_equal('foo', json['network'])
-      assert_equal('zold-io/zold', json['repo'])
-      assert_predicate(json['pid'], :positive?, json)
-      assert_predicate(json['cpus'], :positive?, json)
-      refute_predicate(json['journal'], :negative?, json)
-      assert_predicate(json['memory'], :positive?, json)
-      refute_predicate(json['load'], :negative?, json)
-      assert_predicate(json['wallets'], :positive?, json)
-      assert_predicate(json['remotes'], :zero?, json)
-      assert_predicate(json['nscore'], :zero?, json)
-    end
-  end
-
-  def test_renders_public_pages
-    FakeNode.new(log: fake_log).run(opts) do |port|
-      {
-        200 => [
-          '/robots.txt',
-          '/',
-          '/remotes',
-          '/version',
-          '/protocol',
-          '/farm',
-          '/ledger',
-          '/ledger.json',
-          '/metronome',
-          '/journal',
-          '/score',
-          '/queue',
-          '/trace',
-          '/threads',
-          '/ps'
-        ],
-        404 => [
-          '/this-is-absent',
-          '/wallet/ffffeeeeddddcccc',
-          '/wallet/ffffeeeeddddcccc.bin',
-          '/wallet/ffffeeeeddddcccc.txt',
-          '/wallet/ffffeeeeddddcccc/balance',
-          '/wallet/ffffeeeeddddcccc/key',
-          '/wallet/ffffeeeeddddcccc/mtime',
-          '/wallet/ffffeeeeddddcccc/digest'
-        ]
-      }.each do |code, paths|
-        paths.each do |p|
-          uri = URI("http://localhost:#{port}#{p}")
-          response = Zold::Http.new(uri: uri).get
-          assert_equal(
-            code, response.status,
-            "Invalid response code for #{uri}: #{response.status_line}"
-          )
-        end
-      end
-    end
-  end
-
-  def test_updates_list_of_remotes
-    FakeNode.new(log: fake_log).run(['--no-metronome', '--ignore-score-weakness', '--no-cache']) do |port|
-      (Zold::Remotes::MAX_NODES + 5).times do |i|
-        score = Zold::Score.new(
-          host: 'localhost', port: i + 1, invoice: 'NOPREFIX@ffffffffffffffff', strength: 1
-        ).next.next.next.next
-        response = Zold::Http.new(uri: "http://localhost:#{port}/remotes", score: score).get
-        assert_equal(200, response.status, response.body)
-        assert_equal(
-          [i + 1, Zold::Remotes::MAX_NODES + 1].min,
-          Zold::JsonPage.new(response.body).to_hash['all'].count, response.body
-        )
-        assert_match(
-          /(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})Z/,
-          Zold::JsonPage.new(response.body).to_hash['mtime'].to_s,
-          response.body
-        )
-      end
-    end
-  end
-
-  def test_increments_score
-    FakeNode.new(log: fake_log).run(opts('--threads=1')) do |port|
-      3.times do |i|
-        assert_equal_wait(true, max: 120) do
-          response = Zold::Http.new(uri: "http://localhost:#{port}/").get
-          assert_equal(200, response.status, response.body)
-          score = Zold::Score.parse_json(Zold::JsonPage.new(response.body).to_hash['score'])
-          score.value >= i
-        end
-      end
-    end
-  end
-
-  [
-    '.txt', '.html',
-    '/balance', '/key', '/mtime',
-    '/digest', '/size',
-    '/age', '/mnemo', '/debt', '/txns',
-    '/txns.json', '.bin', '/copies'
-  ].each do |p|
-    method = "test_wallet_page_#{p.gsub(/[^a-z]/, '_')}"
-    define_method(method) do
-      FakeHome.new(log: fake_log).run do |home|
-        FakeNode.new(log: fake_log).run(opts) do |port|
-          wallet = home.create_wallet(txns: 2)
-          base = "http://localhost:#{port}"
-          response = Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}").put(wallet.path)
-          assert_equal(200, response.status, response.body)
-          assert_equal_wait(200) { Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}").get.status }
-          assert_equal_wait(200) { Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}#{p}").get.status }
-        end
-      end
-    end
-  end
-
-  def test_renders_wallets_page
-    FakeHome.new(log: fake_log).run do |home|
-      FakeNode.new(log: fake_log).run(opts) do |port|
-        wallet = home.create_wallet(txns: 2)
-        base = "http://localhost:#{port}"
-        response = Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}").put(wallet.path)
-        assert_equal(200, response.status, response.body)
-        assert_equal_wait(200) { Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}").get.status }
-        response = Zold::Http.new(uri: "#{base}/wallets").get
-        assert_equal(200, response.status, response.body)
-        assert_includes(response.body.to_s.split("\n"), wallet.id.to_s, response.body)
-      end
-    end
-  end
-
-  def test_fetch_in_multiple_threads
-    FakeNode.new(log: fake_log).run(opts) do |port|
-      FakeHome.new(log: fake_log).run do |home|
-        wallet = home.create_wallet
-        base = "http://localhost:#{port}"
-        Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}").put(wallet.path)
-        assert_equal_wait(200) { Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}").get.status }
-        threads = []
-        mutex = Mutex.new
-        Threads.new(6).assert(100) do
-          assert_equal_wait(200) do
-            res = Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}").get
-            mutex.synchronize { threads << res.headers['X-Zold-Thread'] }
-            res.status
-          end
-        end
-        assert_operator(threads.uniq.count, :>, 1)
-      end
-    end
-  end
-
-  def test_pushes_twice
-    FakeNode.new(log: fake_log).run(opts) do |port|
-      FakeHome.new(log: fake_log).run do |home|
-        wallet = home.create_wallet
-        base = "http://localhost:#{port}"
-        assert_equal(
-          200,
-          Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}").put(wallet.path).status
-        )
-        assert_equal_wait(200) { Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}").get.status }
-        3.times do
-          r = Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}").put(wallet.path)
-          assert_equal(304, r.status, r.body)
-        end
-      end
-    end
-  end
-
-  def test_pushes_many_wallets
-    FakeNode.new(log: fake_log).run(opts) do |port|
-      base = "http://localhost:#{port}"
-      FakeHome.new(log: fake_log).run do |home|
-        Threads.new(5).assert do
-          wallet = home.create_wallet
-          Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}").put(wallet.path)
-          assert_equal_wait(200) { Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}").get.status }
-        end
-      end
-    end
-  end
-
-  def test_different_logos
-    {
-      '0' => 'https://www.zold.io/images/logo-red.png',
-      '4' => 'https://www.zold.io/images/logo-orange.png',
-      '16' => 'https://www.zold.io/images/logo-green.png'
-    }.each do |num, path|
-      score = Zold::Score.new(
-        host: 'localhost', port: 999,
-        invoice: 'NOPREFIX@ffffffffffffffff',
-        strength: 1
-      )
-      num.to_i.times do
-        score = score.next
-      end
-      if score.value >= 16
-        assert_equal(
-          'https://www.zold.io/images/logo-green.png', path,
-          "Expected #{path} for score #{score.value}"
-        )
-      elsif score.value >= 4
-        assert_equal(
-          'https://www.zold.io/images/logo-orange.png', path,
-          "Expected #{path} for score #{score.value}"
-        )
-      else
-        assert_equal(
-          'https://www.zold.io/images/logo-red.png', path,
-          "Expected #{path} for score #{score.value}"
-        )
-      end
-    end
-  end
-
-  def test_gzip
-    FakeNode.new(log: fake_log).run(opts) do |port|
-      response = Zold::Http.new(uri: URI("http://localhost:#{port}/version")).get
-      assert_equal(200, response.status, response)
-      assert_operator(300, :>, response.body.length.to_i, 'Expected the content to be small')
-    end
-  end
-
-  def test_performance
-    times = Queue.new
-    FakeNode.new(log: fake_log).run(opts('--threads=4', '--strength=6')) do |port|
-      Threads.new(10).assert(100) do
-        start = Time.now
-        Zold::Http.new(uri: URI("http://localhost:#{port}/")).get
-        times << (Time.now - start)
-      end
-    end
-    all = []
-    all << times.pop(true) until times.empty?
-    fake_log.info("Average response time is #{all.sum / all.count}")
-  end
-
-  # The score exposed via the HTTP header must be reduced to the value of 16.
-  # We need this in order to optimize the amount of data we transfer in each
-  # HTTP request. This value is enough to identify a valuable node, and filter
-  # out those that are too weak.
-  def test_score_is_reduced
-    FakeNode.new(log: fake_log).run(opts('--threads=1', '--strength=1', '--farmer=plain')) do |port|
-      scores = []
-      50.times do
-        res = Zold::Http.new(uri: URI("http://localhost:#{port}/")).get
-        scores << Zold::Score.parse(res.headers[Zold::Http::SCORE_HEADER]).value
-        sleep(0.1)
-      end
-      assert_operator(scores.uniq.sort.reverse[0], :<=, Zold::Front::MIN_SCORE)
-    end
-  end
-
-  def test_headers_are_being_set_correctly
-    FakeNode.new(log: fake_log).run(opts('--expose-version=9.9.9')) do |port|
-      response = Zold::Http.new(uri: URI("http://localhost:#{port}/")).get
-      assert_equal('no-cache', response.headers['Cache-Control'])
-      assert_equal('close', response.headers['Connection'])
-      assert_equal('9.9.9', response.headers['X-Zold-Version'])
-      assert_equal(app.settings.protocol.to_s, response.headers[Zold::Http::PROTOCOL_HEADER])
-      assert_equal('*', response.headers['Access-Control-Allow-Origin'])
-      assert(response.headers['X-Zold-Milliseconds'])
-      refute_nil(response.headers[Zold::Http::SCORE_HEADER])
-    end
-  end
-
-  def test_alias_parameter
-    name = SecureRandom.hex(4)
-    FakeNode.new(log: fake_log).run(opts("--alias=#{name}")) do |port|
-      uri = URI("http://localhost:#{port}/")
-      response = Zold::Http.new(uri: uri).get
-      assert_match(
-        name,
-        Zold::JsonPage.new(response.body).to_hash['alias'].to_s,
-        response.body
-      )
-    end
-  end
-
-  def test_default_alias_parameter
-    FakeNode.new(log: fake_log).run(opts) do |port|
-      uri = URI("http://localhost:#{port}/")
-      response = Zold::Http.new(uri: uri).get
-      assert_match(
-        "localhost:#{port}",
-        Zold::JsonPage.new(response.body).to_hash['alias'].to_s,
-        response.body
-      )
-    end
-  end
-
-  def test_invalid_alias
-    skip
-    exception = assert_raises RuntimeError do
-      FakeNode.new(log: fake_log).run(opts('--alias=invalid-alias')) do |port|
-        uri = URI("http://localhost:#{port}/")
-        Zold::Http.new(uri: uri).get
-      end
-    end
-    assert_includes(exception.message, 'should be a 4 to 16 char long', exception.message)
-  end
-
-  def test_push_fetch_in_multiple_threads
-    key = Zold::Key.new(text: File.read('fixtures/id_rsa'))
-    FakeNode.new(log: fake_log).run(opts) do |port|
-      FakeHome.new(log: fake_log).run do |home|
-        wallet = home.create_wallet(Zold::Id::ROOT)
-        base = "http://localhost:#{port}"
-        Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}").put(wallet.path)
-        assert_equal_wait(200) { Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}").get.status }
-        cycles = 50
-        cycles.times do
-          wallet.sub(Zold::Amount.new(zents: 10), "NOPREFIX@#{Zold::Id.new}", key)
-          Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}").put(wallet.path)
-          assert_equal(200, Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}").get.status)
-        end
-        assert_equal_wait(-10 * cycles) do
-          Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}/balance").get.body.to_i
-        end
-      end
-    end
-  end
-
-  def test_checksum_in_json
-    FakeNode.new(log: fake_log).run(opts) do |port|
-      uri = URI("http://localhost:#{port}/")
-      response = Zold::Http.new(uri: uri).get
-      hash = Zold::JsonPage.new(response.body).to_hash
-      assert_includes(hash.keys, 'checksum')
-    end
-  end
-
-  private
-
-  def opts(*extra)
-    ['--no-metronome', '--ignore-score-weakness', '--standalone', '--threads=0', '--strength=1'] + extra
-  end
-end

data/test/node/test_nodup_entrance.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2018-2025 Zerocracy
-# SPDX-License-Identifier: MIT
-
-require_relative '../fake_home'
-require_relative '../test__helper'
-require_relative '../../lib/zold/id'
-require_relative '../../lib/zold/node/nodup_entrance'
-require_relative 'fake_entrance'
-
-# NoDupEntrance test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2018-2025 Zerocracy
-# License:: MIT
-class TestNoDupEntrance < Zold::Test
-  def test_ignores_dup
-    FakeHome.new(log: fake_log).run do |home|
-      wallet = home.create_wallet
-      Zold::NoDupEntrance.new(RealEntrance.new, home.wallets, log: fake_log).start do |e|
-        assert_empty(e.push(wallet.id, File.read(wallet.path)))
-      end
-    end
-  end
-
-  class RealEntrance < FakeEntrance
-    def push(id, _)
-      [id]
-    end
-  end
-end

data/test/node/test_nospam_entrance.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2018-2025 Zerocracy
-# SPDX-License-Identifier: MIT
-
-require_relative '../test__helper'
-require_relative '../../lib/zold/id'
-require_relative '../../lib/zold/node/nospam_entrance'
-require_relative 'fake_entrance'
-
-# NoSpamEntrance test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2018-2025 Zerocracy
-# License:: MIT
-class TestNoSpamEntrance < Zold::Test
-  def test_ignores_spam
-    Zold::NoSpamEntrance.new(RealEntrance.new, log: fake_log).start do |e|
-      id = Zold::Id.new
-      content = 'hello'
-      refute_empty(e.push(id, content))
-      assert_empty(e.push(id, content))
-      assert_empty(e.push(id, content))
-    end
-  end
-
-  class RealEntrance < FakeEntrance
-    def push(id, _)
-      [id]
-    end
-  end
-end

data/test/node/test_safe_entrance.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2018-2025 Zerocracy
-# SPDX-License-Identifier: MIT
-
-require_relative '../fake_home'
-require_relative '../test__helper'
-require_relative '../../lib/zold/wallet'
-require_relative '../../lib/zold/id'
-require_relative '../../lib/zold/key'
-require_relative '../../lib/zold/node/safe_entrance'
-require_relative '../../lib/zold/node/soft_error'
-require_relative 'fake_entrance'
-
-# SafeEntrance test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2018-2025 Zerocracy
-# License:: MIT
-class TestSafeEntrance < Zold::Test
-  def test_rejects_wallet_with_negative_balance
-    FakeHome.new(log: fake_log).run do |home|
-      wallet = home.create_wallet
-      amount = Zold::Amount.new(zld: 39.99)
-      key = Zold::Key.new(file: 'fixtures/id_rsa')
-      wallet.sub(amount, "NOPREFIX@#{Zold::Id.new}", key)
-      assert_raises Zold::SoftError do
-        Zold::SafeEntrance.new(FakeEntrance.new).push(wallet.id, File.read(wallet.path))
-      end
-    end
-  end
-
-  def test_rejects_wallet_with_wrong_network
-    FakeHome.new(log: fake_log).run do |home|
-      wallet = Zold::Wallet.new(File.join(home.dir, 'wallet.z'))
-      wallet.init(Zold::Id.new, Zold::Key.new(file: 'fixtures/id_rsa.pub'), network: 'someothernetwork')
-      assert_raises StandardError do
-        Zold::SafeEntrance.new(FakeEntrance.new).push(wallet.id, File.read(wallet.path))
-      end
-    end
-  end
-end

data/test/node/test_spread_entrance.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2018-2025 Zerocracy
-# SPDX-License-Identifier: MIT
-
-require_relative '../fake_home'
-require_relative 'fake_node'
-require_relative '../test__helper'
-require_relative '../../lib/zold/id'
-require_relative '../../lib/zold/node/entrance'
-require_relative '../../lib/zold/node/pipeline'
-require_relative '../../lib/zold/node/spread_entrance'
-require_relative 'fake_entrance'
-
-# SpreadEntrance test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2018-2025 Zerocracy
-# License:: MIT
-class TestSpreadEntrance < Zold::Test
-  def test_renders_json
-    FakeHome.new(log: fake_log).run do |home|
-      wallet = home.create_wallet(Zold::Id.new)
-      Zold::SpreadEntrance.new(
-        Zold::Entrance.new(
-          home.wallets,
-          Zold::Pipeline.new(home.remotes, home.copies(wallet).root, 'x'),
-          log: fake_log
-        ),
-        home.wallets, home.remotes, 'x', log: fake_log
-      ).start do |e|
-        assert_equal(0, e.to_json[:modified])
-      end
-    end
-  end
-
-  def test_ignores_duplicates
-    FakeHome.new(log: fake_log).run do |home|
-      FakeNode.new(log: fake_log).run(['--ignore-score-weakness']) do |port|
-        wallet = home.create_wallet
-        remotes = home.remotes
-        remotes.add('localhost', port)
-        Zold::SpreadEntrance.new(FakeEntrance.new, home.wallets, remotes, 'x', log: fake_log).start do |e|
-          8.times { e.push(wallet.id, File.read(wallet.path)) }
-          assert_operator(e.to_json[:modified], :<, 2, "It's too big: #{e.to_json[:modified]}")
-        end
-      end
-    end
-  end
-end

data/test/node/test_sync_entrance.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2018-2025 Zerocracy
-# SPDX-License-Identifier: MIT
-
-require_relative '../fake_home'
-require_relative '../test__helper'
-require_relative '../../lib/zold/node/sync_entrance'
-require_relative 'fake_entrance'
-
-# SyncEntrance test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2018-2025 Zerocracy
-# License:: MIT
-class TestSyncEntrance < Zold::Test
-  def test_renders_json
-    FakeHome.new(log: fake_log).run do |home|
-      Zold::SyncEntrance.new(FakeEntrance.new, File.join(home.dir, 'x'), log: fake_log).start do |e|
-        refute_nil(e.to_json)
-      end
-    end
-  end
-end

data/test/node/test_trace.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2018-2025 Zerocracy
-# SPDX-License-Identifier: MIT
-
-require_relative '../test__helper'
-require_relative '../../lib/zold/node/trace'
-
-class TraceTest < Zold::Test
-  def test_records_log_lines
-    trace = Zold::Trace.new(fake_log, 2)
-    trace.error('This should not be visible')
-    trace.error('How are you, друг?')
-    trace.error('Works?')
-    refute_includes(trace.to_s, 'visible')
-    assert_includes(trace.to_s, 'друг')
-  end
-end

data/test/test__helper.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2018-2025 Zerocracy
-# SPDX-License-Identifier: MIT
-
-gem 'openssl'
-require 'openssl'
-require 'minitest/hooks/test'
-require 'concurrent'
-require 'timeout'
-
-$stdout.sync = true
-
-ENV['RACK_ENV'] = 'test'
-require 'simplecov'
-require 'simplecov-cobertura'
-unless SimpleCov.running || ENV['PICKS']
-  SimpleCov.command_name('test')
-  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(
-    [
-      SimpleCov::Formatter::HTMLFormatter,
-      SimpleCov::Formatter::CoberturaFormatter
-    ]
-  )
-  SimpleCov.minimum_coverage 85
-  SimpleCov.minimum_coverage_by_file 50
-  SimpleCov.start do
-    add_filter 'test/'
-    add_filter 'vendor/'
-    add_filter 'target/'
-    track_files 'lib/**/*.rb'
-    track_files '*.rb'
-  end
-end
-
-require 'minitest/autorun'
-require 'minitest/mock'
-require 'minitest/reporters'
-require 'webmock/minitest'
-Minitest::Reporters.use! [Minitest::Reporters::SpecReporter.new]
-Minitest.load :minitest_reporter
-
-require_relative '../lib/zold/hands'
-Zold::Hands.start
-
-module Zold
-  class Test < Minitest::Test
-    include Minitest::Hooks
-
-    # We need this in order to make sure any test is faster than a minute. This
-    # should help spotting tests that hang out sometimes. The number of seconds
-    # to wait can be increased, but try to make it as little as possible,
-    # in order to catch problems earlier.
-    def around
-      Timeout.timeout(180) do
-        Thread.current.name = 'test'
-        super
-      end
-    end
-
-    def assert_wait(max: 30, &block)
-      assert_equal_wait(true, max: max, &block)
-    end
-
-    def assert_equal_wait(expected, max: 30)
-      start = Time.now
-      loop do
-        begin
-          actual = yield
-          if expected == actual
-            assert_equal(expected, actual)
-            break
-          end
-        rescue StandardError => e
-          fake_log.debug(e.message)
-        end
-        sleep 1
-        sec = Time.now - start
-        require_relative '../lib/zold/age'
-        raise "'#{actual}' is not equal to '#{expected}' even after #{Zold::Age.new(start)} of waiting" if sec > max
-      end
-    end
-
-    def fake_log
-      require 'loog'
-      @fake_log ||= ENV['TEST_QUIET_LOG'] == 'true' ? Loog::NULL : Loog::VERBOSE
-    end
-
-    class TestLogger
-      attr_accessor :msgs
-
-      def initialize(log = Loog::NULL)
-        @log = log
-        @msgs = []
-      end
-
-      def info(msg)
-        @log.info(msg)
-        @msgs << msg
-      end
-
-      def debug(msg)
-        @log.debug(msg)
-        @msgs << msg
-      end
-
-      def error(msg)
-        @log.error(msg)
-        @msgs << msg
-      end
-    end
-  end
-end