zold 0.32.0 → 0.32.1

data/test/commands/test_taxes.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2018-2025 Zerocracy
-# SPDX-License-Identifier: MIT
-
-require 'tmpdir'
-require 'webmock/minitest'
-require_relative '../test__helper'
-require_relative '../fake_home'
-require_relative '../../lib/zold/wallets'
-require_relative '../../lib/zold/amount'
-require_relative '../../lib/zold/key'
-require 'loog'
-require_relative '../../lib/zold/id'
-require_relative '../../lib/zold/commands/taxes'
-
-# TAXES test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2018-2025 Zerocracy
-# License:: MIT
-class TestTaxes < Zold::Test
-  def test_pays_taxes
-    FakeHome.new(log: fake_log).run do |home|
-      wallets = home.wallets
-      wallet = home.create_wallet
-      fund = Zold::Amount.new(zld: 19.99)
-      10.times do |i|
-        wallet.add(
-          Zold::Txn.new(
-            i + 1,
-            Time.now - (24 * 60 * 60 * 365 * 300),
-            fund,
-            'NOPREFIX', Zold::Id.new, '-'
-          )
-        )
-      end
-      remotes = home.remotes
-      score = Zold::Score.new(host: 'localhost', port: 80, strength: 1, invoice: 'NOPREFIX@0000000000000000')
-      10.times { score = score.next }
-      remotes.add(score.host, score.port)
-      stub_request(:get, "http://#{score.host}:#{score.port}/").to_return(
-        status: 200,
-        body: {
-          score: score.to_h
-        }.to_json
-      )
-      before = wallet.balance
-      tax = Zold::Tax.new(wallet, ignore_score_weakness: true)
-      debt = tax.debt
-      Zold::Taxes.new(wallets: wallets, remotes: remotes, log: fake_log).run(
-        ['taxes', '--private-key=fixtures/id_rsa', '--ignore-score-weakness', 'pay', wallet.id.to_s]
-      )
-      wallet.flush
-      assert_predicate(tax.paid, :positive?, tax.paid)
-      assert_equal((before - debt).to_zld(6), wallet.balance.to_zld(6))
-    end
-  end
-end

data/test/fake_home.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2018-2025 Zerocracy
-# SPDX-License-Identifier: MIT
-
-require 'tmpdir'
-require 'loog'
-require_relative '../lib/zold/id'
-require_relative '../lib/zold/wallet'
-require_relative '../lib/zold/wallets'
-require_relative '../lib/zold/sync_wallets'
-require_relative '../lib/zold/cached_wallets'
-require_relative '../lib/zold/key'
-require_relative '../lib/zold/version'
-require_relative '../lib/zold/remotes'
-
-# Fake home dir.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2018-2025 Zerocracy
-# License:: MIT
-class FakeHome
-  attr_reader :dir
-
-  def initialize(dir = __dir__, log: Loog::NULL)
-    @dir = dir
-    @log = log
-  end
-
-  def run
-    Dir.mktmpdir do |dir|
-      FileUtils.copy(File.expand_path(File.join(__dir__, '../fixtures/id_rsa')), File.join(dir, 'id_rsa'))
-      yield FakeHome.new(dir, log: @log)
-    end
-  end
-
-  def wallets
-    Zold::SyncWallets.new(Zold::CachedWallets.new(Zold::Wallets.new(@dir)), log: @log)
-  end
-
-  def create_wallet(id = Zold::Id.new, dir = @dir, txns: 0)
-    target = Zold::Wallet.new(File.join(dir, id.to_s + Zold::Wallet::EXT))
-    wallets.acq(id, exclusive: true) do |w|
-      w.init(id, Zold::Key.new(file: File.expand_path(File.join(__dir__, '../fixtures/id_rsa.pub'))))
-      File.write(target.path, File.read(w.path))
-      txns.times do |i|
-        w.add(
-          Zold::Txn.new(
-            1, Time.now,
-            Zold::Amount.new(zld: (i + 1).to_f),
-            'NOPREFIX', Zold::Id.new, '-'
-          )
-        )
-      end
-    end
-    target
-  end
-
-  def create_wallet_json(id = Zold::Id.new)
-    require 'zold/score'
-    score = Zold::Score::ZERO
-    Dir.mktmpdir 'wallets' do |external_dir|
-      wallet = create_wallet(id, external_dir)
-      {
-        version: Zold::VERSION,
-        protocol: Zold::PROTOCOL,
-        id: wallet.id.to_s,
-        score: score.to_h,
-        size: wallet.size,
-        wallets: 1,
-        mtime: wallet.mtime.utc.iso8601,
-        digest: wallet.digest,
-        balance: wallet.balance.to_i,
-        body: File.read(wallet.path)
-      }.to_json
-    end
-  end
-
-  def copies(wallet = create_wallet)
-    Zold::Copies.new(File.join(@dir, "copies/#{wallet.id}"))
-  end
-
-  def remotes
-    remotes = Zold::Remotes.new(file: File.join(@dir, 'secrets/remotes'))
-    remotes.clean
-    remotes
-  end
-end

data/test/node/fake_entrance.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2018-2025 Zerocracy
-# SPDX-License-Identifier: MIT
-
-# Fake entrance.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2018-2025 Zerocracy
-# License:: MIT
-class FakeEntrance
-  def initialize
-    # Nothing here
-  end
-
-  def to_json
-    {}
-  end
-
-  def start
-    yield self
-  end
-
-  def push(id, _)
-    [id]
-  end
-end

data/test/node/fake_node.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2018-2025 Zerocracy
-# SPDX-License-Identifier: MIT
-
-require 'tmpdir'
-require 'webmock/minitest'
-require 'random-port'
-require_relative '../fake_home'
-require 'loog'
-require_relative '../../lib/zold/http'
-require_relative '../../lib/zold/verbose_thread'
-require_relative '../../lib/zold/node/front'
-
-# Fake node.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2018-2025 Zerocracy
-# License:: MIT
-class FakeNode
-  def initialize(log: Loog::NULL)
-    @log = log
-  end
-
-  # This is a pretty weird situation: we have to acquire a single port
-  # number an reuse it for all tests. If we use different port numbers,
-  # acquiring them for each instance of FakeNode, we get port collisions,
-  # sometimes. Maybe this can be fixed sometimes.
-  # rubocop:disable Style/ClassVars
-  @@port = RandomPort::Pool::SINGLETON.acquire
-  # rubocop:enable Style/ClassVars
-
-  def run(args = ['--standalone', '--no-metronome'])
-    WebMock.allow_net_connect!
-    FakeHome.new(log: @log).run do |home|
-      node = Thread.new do
-        Thread.current.name = 'fake_node'
-        Thread.current.abort_on_exception = false
-        Zold::VerboseThread.new(@log).run do
-          require_relative '../../lib/zold/commands/node'
-          Zold::Node.new(wallets: home.wallets, remotes: home.remotes, copies: home.copies.root, log: @log).run(
-            [
-              '--home', home.dir,
-              '--network=test',
-              '--port', @@port.to_s,
-              '--host=localhost',
-              '--bind-port', @@port.to_s,
-              '--threads=1',
-              '--dump-errors',
-              '--strength=2',
-              '--halt-code=test',
-              '--routine-immediately',
-              '--invoice=NOPREFIX@ffffffffffffffff'
-            ] + args
-          )
-        end
-      end
-      uri = "http://localhost:#{@@port}/"
-      attempt = 0
-      loop do
-        ping = Zold::Http.new(uri: uri).get
-        unless ping.status == 599 && node.alive?
-          @log.debug("The URL #{uri} is probably alive, after #{attempt} attempts")
-          break
-        end
-        unless node.alive?
-          @log.debug("The URL #{uri} is dead, after #{attempt} attempts")
-          break
-        end
-        @log.debug("Waiting for #{uri} (attempt no.#{attempt}): ##{ping.status}...")
-        sleep 0.5
-        attempt += 1
-        if attempt > 10
-          @log.error("Waiting for too long for #{uri} (#{attempt} attempts)")
-          break
-        end
-      end
-      raise "The node is dead at #{uri}" unless node.alive?
-      begin
-        yield @@port
-      ensure
-        Zold::Http.new(uri: "#{uri}?halt=test").get
-        node.join
-        sleep 0.1 # stupid sleep to make sure all threads are terminated
-      end
-      @log.debug("Thread with fake node stopped: #{node.alive?}")
-    end
-  end
-end

data/test/node/test_async_entrance.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2018-2025 Zerocracy
-# SPDX-License-Identifier: MIT
-
-require 'threads'
-require_relative '../fake_home'
-require_relative '../test__helper'
-require_relative '../../lib/zold/id'
-require_relative '../../lib/zold/node/async_entrance'
-require_relative 'fake_entrance'
-
-# AsyncEntrance test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2018-2025 Zerocracy
-# License:: MIT
-class TestAsyncEntrance < Zold::Test
-  def test_renders_json
-    FakeHome.new(log: fake_log).run do |home|
-      Zold::AsyncEntrance.new(FakeEntrance.new, home.dir, log: fake_log).start do |e|
-        assert_equal(0, e.to_json[:queue])
-      end
-    end
-  end
-
-  def test_sends_through_once
-    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)
-      basic = CountingEntrance.new
-      Zold::AsyncEntrance.new(basic, File.join(home.dir, 'a/b/c'), log: fake_log).start do |e|
-        e.push(wallet.id, File.read(wallet.path))
-        assert_equal_wait(1) { basic.count }
-      end
-    end
-  end
-
-  def test_sends_through
-    FakeHome.new(log: fake_log).run do |home|
-      basic = CountingEntrance.new
-      Zold::AsyncEntrance.new(basic, File.join(home.dir, 'a/b/c'), log: fake_log, queue_limit: 1000).start do |e|
-        Threads.new(20).assert do
-          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)
-          5.times { e.push(wallet.id, File.read(wallet.path)) }
-        end
-        assert_equal_wait(true) { basic.count >= 20 }
-      end
-    end
-  end
-
-  def test_handles_broken_entrance_gracefully
-    FakeHome.new(log: fake_log).run do |home|
-      wallet = home.create_wallet
-      id = wallet.id
-      body = File.read(wallet.path)
-      Zold::AsyncEntrance.new(BrokenEntrance.new, home.dir, log: fake_log).start do |e|
-        e.push(id, body)
-      end
-    end
-  end
-
-  class CountingEntrance < FakeEntrance
-    attr_reader :count
-
-    def initialize
-      super
-      @count = 0
-    end
-
-    def push(_, _)
-      @count += 1
-    end
-  end
-
-  class BrokenEntrance < FakeEntrance
-    def push(_, _)
-      raise 'It intentionally crashes'
-    end
-  end
-end

data/test/node/test_entrance.rb

@@ -1,64 +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/wallets'
-require_relative '../../lib/zold/remotes'
-require_relative '../../lib/zold/id'
-require_relative '../../lib/zold/key'
-require_relative '../../lib/zold/node/entrance'
-require_relative '../../lib/zold/node/pipeline'
-require_relative '../../lib/zold/commands/pay'
-
-# ENTRANCE test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2018-2025 Zerocracy
-# License:: MIT
-class TestEntrance < Zold::Test
-  def test_pushes_wallet
-    sid = Zold::Id::ROOT
-    tid = Zold::Id.new
-    body = FakeHome.new(log: fake_log).run do |home|
-      source = home.create_wallet(sid)
-      target = home.create_wallet(tid)
-      Zold::Pay.new(wallets: home.wallets, copies: home.dir, remotes: home.remotes, log: fake_log).run(
-        [
-          'pay', '--force', '--private-key=fixtures/id_rsa',
-          source.id.to_s, target.id.to_s, '19.99', 'testing'
-        ]
-      )
-      File.read(source.path)
-    end
-    FakeHome.new(log: fake_log).run do |home|
-      source = home.create_wallet(sid)
-      target = home.create_wallet(tid)
-      ledger = File.join(home.dir, 'ledger.csv')
-      e = Zold::Entrance.new(
-        home.wallets,
-        Zold::Pipeline.new(home.remotes, home.copies(source).root, 'x', ledger: ledger),
-        log: fake_log
-      )
-      modified = e.push(source.id, body)
-      assert_equal(2, modified.count)
-      assert_equal(Zold::Amount.new(zld: -19.99), source.balance)
-      assert_equal(Zold::Amount.new(zld: 19.99), target.balance)
-      assert_includes(modified, sid)
-      assert_includes(modified, tid)
-      assert_equal(1, File.read(ledger).split("\n").count)
-    end
-  end
-
-  def test_renders_json
-    FakeHome.new(log: fake_log).run do |home|
-      wallet = home.create_wallet
-      e = Zold::Entrance.new(home.wallets, Zold::Pipeline.new(home.remotes, home.copies.root, 'x'), log: fake_log)
-      e.push(wallet.id, File.read(wallet.path))
-      assert_includes(e.to_json[:history], wallet.id.to_s)
-      refute_predicate(e.to_json[:speed], :negative?)
-    end
-  end
-end

data/test/node/test_farm.rb

@@ -1,159 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2018-2025 Zerocracy
-# SPDX-License-Identifier: MIT
-
-require 'rack/test'
-require 'tmpdir'
-require_relative '../test__helper'
-require 'loog'
-require_relative '../../lib/zold/node/farm'
-
-class FarmTest < Zold::Test
-  def test_renders_in_json
-    Dir.mktmpdir do |dir|
-      farm = Zold::Farm.new('NOPREFIX6@ffffffffffffffff', File.join(dir, 'f'), log: fake_log, strength: 2)
-      farm.start('localhost', 80, threads: 2) do
-        assert_wait { !farm.best.empty? && !farm.best[0].value.zero? }
-        count = 0
-        100.times { count += farm.to_json[:best].length }
-        assert_predicate(count, :positive?)
-      end
-    end
-  end
-
-  def test_renders_in_text
-    Dir.mktmpdir do |dir|
-      farm = Zold::Farm.new('NOPREFIX7@ffffffffffffffff', File.join(dir, 'f'), log: fake_log, strength: 1)
-      farm.start('localhost', 80, threads: 2) do
-        refute_nil(farm.to_text)
-      end
-    end
-  end
-
-  def test_makes_many_scores
-    Dir.mktmpdir do |dir|
-      farm = Zold::Farm.new('NOPREFIX6@ffffffffffffffff', File.join(dir, 'f'),
-        log: fake_log, lifetime: 10, farmer: Zold::Farmers::Plain.new, strength: 1)
-      farm.start('localhost', 80, threads: 4) do
-        assert_wait { farm.best.length == 4 }
-      end
-    end
-  end
-
-  # @todo #527:30min This test takes too long. The speed should be less than
-  #  a few milliseconds, however, if you run it a few times, you will see
-  #  that it is over 100ms sometimes. This is way too slow. I can't understand
-  #  what's going on. It seems that IO.read() is taking too long sometimes.
-  #  Try to measure its time of execution in Farm.load() and you will see
-  #  that it's usually a few microseconds, but sometimes over 200ms.
-  def test_reads_scores_at_high_speed
-    Dir.mktmpdir do |dir|
-      farm = Zold::Farm.new('NOPREFIX6@ffffffffffffffff', File.join(dir, 'f'), log: fake_log, strength: 4)
-      farm.start('localhost', 80, threads: 4) do
-        assert_wait { !farm.best.empty? && !farm.best[0].value.zero? }
-        cycles = 100
-        speed = (0..(cycles - 1)).sum do
-          start = Time.now
-          farm.best
-          Time.now - start
-        end / cycles
-        fake_log.info("Average speed is #{(speed * 1000).round(2)}ms in #{cycles} cycles")
-      end
-    end
-  end
-
-  def test_makes_best_score_in_background
-    Dir.mktmpdir do |dir|
-      farm = Zold::Farm.new('NOPREFIX1@ffffffffffffffff', File.join(dir, 'f'), log: fake_log, strength: 3)
-      farm.start('localhost', 80, threads: 1) do
-        assert_wait { !farm.best.empty? && farm.best[0].value >= 3 }
-        score = farm.best[0]
-        refute_predicate(score, :expired?)
-        assert_operator(score.value, :>=, 3)
-      end
-    end
-  end
-
-  def test_correct_score_from_empty_farm
-    Dir.mktmpdir do |dir|
-      farm = Zold::Farm.new('NOPREFIX2@cccccccccccccccc', File.join(dir, 'f'), log: fake_log, strength: 1)
-      farm.start('example.com', 8080, threads: 0) do
-        score = farm.best[0]
-        refute_predicate(score, :expired?)
-        assert_equal(0, score.value)
-        assert_equal('example.com', score.host)
-        assert_equal(8080, score.port)
-      end
-    end
-  end
-
-  def test_pre_loads_history
-    Dir.mktmpdir do |dir|
-      cache = File.join(dir, 'a/b/c/cache')
-      farm = Zold::Farm.new('NOPREFIX3@cccccccccccccccc', cache, log: fake_log, strength: 1)
-      farm.start('example.com', 8080, threads: 0) do
-        score = farm.best[0]
-        refute_nil(score, 'The list of best scores can\'t be empty!')
-        assert_path_exists(cache, 'The cache file has to be created!')
-        assert_equal(0, score.value)
-        refute_predicate(score, :expired?)
-        assert_equal('example.com', score.host)
-        assert_equal(8080, score.port)
-      end
-    end
-  end
-
-  def test_drops_expired_scores_from_history
-    Dir.mktmpdir do |dir|
-      cache = File.join(dir, 'cache')
-      score = Zold::Score.new(
-        time: Time.parse('2017-07-19T21:24:51Z'),
-        host: 'some-host', port: 9999, invoice: 'NOPREFIX4@ffffffffffffffff',
-        suffixes: %w[13f7f01 b2b32b 4ade7e],
-        strength: 6
-      )
-      File.write(cache, score.to_s)
-      farm = Zold::Farm.new('NOPREFIX4@ffffffffffffffff', cache, log: fake_log, strength: score.strength)
-      farm.start(score.host, score.port, threads: 1) do
-        100.times do
-          sleep(0.1)
-          b = farm.best[0]
-          refute_nil(b)
-          break if b.value.zero?
-        end
-        assert_equal(0, farm.best[0].value)
-      end
-    end
-  end
-
-  def test_garbage_farm_file
-    log = TestLogger.new
-    Dir.mktmpdir do |dir|
-      file = File.join(dir, 'corrupted_farm')
-      [
-        'some garbage',
-        'some other garbage'
-      ].each do |score_garbage_line|
-        valid_score = Zold::Score.new(
-          time: Time.parse('2017-07-19T21:24:51Z'),
-          host: 'some-host', port: 9999, invoice: 'NOPREFIX5@ffffffffffffffff',
-          suffixes: %w[13f7f01 b2b32b 4ade7e], strength: 6
-        )
-        File.open(file, 'w') do |f|
-          f.puts(score_garbage_line)
-          f.puts(valid_score)
-        end
-        farm = Zold::Farm.new('NOPREFIX5@ffffffffffffffff', file, log: log)
-        assert_equal(1, farm.best.count)
-        refute_nil(log.msgs.find { |m| m.include?('Invalid score') })
-      end
-    end
-  end
-
-  def test_terminates_farm_entirely
-    Zold::Farm.new('NOPREFIX4@ffffffffffffffff', log: fake_log, strength: 10).start('localhost', 4096, threads: 1) do
-      sleep 1
-    end
-  end
-end

data/test/node/test_farmers.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2018-2025 Zerocracy
-# SPDX-License-Identifier: MIT
-
-require 'time'
-require 'zold/score'
-require_relative '../test__helper'
-require_relative '../../lib/zold/node/farmers'
-require_relative '../../lib/zold/verbose_thread'
-
-class FarmersTest < Zold::Test
-  # Types to test
-  TYPES = [
-    Zold::Farmers::Plain,
-    Zold::Farmers::Spawn,
-    Zold::Farmers::Fork
-  ].freeze
-
-  def test_calculates_next_score
-    before = Zold::Score.new(host: 'some-host', port: 9999, invoice: 'NOPREFIX4@ffffffffffffffff', strength: 3)
-    TYPES.each do |farmer_class|
-      farmer = farmer_class.new(log: fake_log)
-      after = farmer.up(before)
-      assert_equal(1, after.value)
-      refute_predicate(after, :expired?)
-      assert_equal('some-host', after.host)
-      assert_equal(9999, after.port)
-    end
-  end
-
-  def test_calculates_large_score
-    TYPES.each do |type|
-      log = TestLogger.new(fake_log)
-      thread = Thread.start do
-        farmer = type.new(log: log)
-        farmer.up(Zold::Score.new(host: 'a', port: 1, invoice: 'NOPREFIX4@ffffffffffffffff', strength: 20))
-      end
-      sleep(0.1)
-      thread.kill
-      thread.join
-    end
-  end
-
-  def test_kills_farmer
-    TYPES.each do |type|
-      farmer = type.new(log: fake_log)
-      thread = Thread.start do
-        Zold::VerboseThread.new(fake_log).run do
-          farmer.up(Zold::Score.new(host: 'some-host', invoice: 'NOPREFIX4@ffffffffffffffff', strength: 32))
-        end
-      end
-      sleep(1)
-      thread.kill
-      thread.join
-    end
-  end
-end