zold 0.32.0 → 0.32.1

data/test/test_remotes.rb

@@ -1,301 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2018-2025 Zerocracy
-# SPDX-License-Identifier: MIT
-
-require 'tmpdir'
-require 'webmock/minitest'
-require 'threads'
-require_relative 'test__helper'
-require 'loog'
-require_relative '../lib/zold/age'
-require_relative '../lib/zold/remotes'
-require_relative '../lib/zold/verbose_thread'
-
-# Remotes test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2018-2025 Zerocracy
-# License:: MIT
-class TestRemotes < Zold::Test
-  def test_adds_remotes
-    Dir.mktmpdir do |dir|
-      file = File.join(dir, 'remotes')
-      FileUtils.touch(file)
-      remotes = Zold::Remotes.new(file: file)
-      remotes.add('127.0.0.1')
-      assert_equal(1, remotes.all.count)
-    end
-  end
-
-  def test_finds_masters
-    Dir.mktmpdir do |dir|
-      file = File.join(dir, 'remotes')
-      FileUtils.touch(file)
-      remotes = Zold::Remotes.new(file: file)
-      assert(remotes.master?('b2.zold.io', 4096))
-    end
-  end
-
-  def test_reads_broken_file
-    Dir.mktmpdir do |dir|
-      file = File.join(dir, 'remotes')
-      [
-        ',0,0,0',
-        'some garbage',
-        '',
-        "\n\n\n\n"
-      ].each do |t|
-        File.write(file, t)
-        remotes = Zold::Remotes.new(file: file)
-        assert_empty(remotes.all, remotes.all)
-      end
-    end
-  end
-
-  def test_iterates_and_fails
-    Dir.mktmpdir do |dir|
-      file = File.join(dir, 'remotes')
-      FileUtils.touch(file)
-      remotes = Zold::Remotes.new(file: file)
-      ips = (0..50)
-      ips.each { |i| remotes.add("0.0.0.#{i + 1}", 9999) }
-      remotes.iterate(Loog::NULL) { raise 'Intended' }
-      ips.each { |i| assert_equal(1, remotes.all[i][:errors]) }
-    end
-  end
-
-  def test_iterates_all_failures
-    Dir.mktmpdir do |dir|
-      file = File.join(dir, 'remotes')
-      FileUtils.touch(file)
-      remotes = Zold::Remotes.new(file: file)
-      5.times { |i| remotes.add("0.0.0.#{i + 1}", 9999) }
-      total = 0
-      remotes.iterate(Loog::NULL) do
-        total += 1
-        raise 'Intended'
-      end
-      assert_equal(5, total)
-    end
-  end
-
-  def test_closes_threads_carefully
-    Dir.mktmpdir do |dir|
-      file = File.join(dir, 'remotes')
-      FileUtils.touch(file)
-      remotes = Zold::Remotes.new(file: file)
-      5.times { |i| remotes.add("0.0.0.#{i + 1}", 9999) }
-      total = 0
-      remotes.iterate(Loog::NULL) do
-        sleep 0.25
-        total += 1
-      end
-      assert_equal(5, total)
-    end
-  end
-
-  def test_iterates_them_all_even_with_delays
-    Dir.mktmpdir do |dir|
-      remotes = Zold::Remotes.new(file: File.join(dir, 'rrr.csv'))
-      remotes.clean
-      5.times { |i| remotes.add("0.0.0.#{i + 1}", 8080) }
-      total = 0
-      remotes.iterate(fake_log) do
-        sleep 0.25
-        total += 1
-      end
-      assert_equal(5, total)
-    end
-  end
-
-  def fake_log_msg_of_iterates_when_fail
-    Dir.mktmpdir do |dir|
-      file = File.join(dir, 'remotes')
-      FileUtils.touch(file)
-      remotes = Zold::Remotes.new(file: file)
-      remotes.add('0.0.0.1', 9999)
-      log = TestLogger.new
-      remotes.iterate(log) { raise 'Intended' }
-      assert(log.msgs.find { |m| m.include?(' in ') })
-    end
-  end
-
-  def fake_log_msg_of_iterates_when_take_too_long
-    Dir.mktmpdir do |dir|
-      file = File.join(dir, 'remotes')
-      FileUtils.touch(file)
-      remotes = Zold::Remotes.new(file: file, timeout: 1)
-      remotes.add('127.0.0.1')
-      log = TestLogger.new
-      remotes.iterate(log) { sleep(2) }
-      assert(log.msgs.find { |m| m.include?('Took too long to execute') })
-    end
-  end
-
-  def test_removes_remotes
-    Dir.mktmpdir do |dir|
-      file = File.join(dir, 'remotes')
-      FileUtils.touch(file)
-      remotes = Zold::Remotes.new(file: file)
-      remotes.add('127.0.0.1')
-      remotes.add('LOCALHOST', 433)
-      remotes.remove('localhost', 433)
-      assert_equal(1, remotes.all.count)
-    end
-  end
-
-  def test_resets_remotes
-    Dir.mktmpdir do |dir|
-      remotes = Zold::Remotes.new(file: File.join(dir, 'remotes'))
-      remotes.clean
-      remotes.masters
-      remotes.masters
-      refute_empty(remotes.all)
-    end
-  end
-
-  def test_modifies_score
-    Dir.mktmpdir do |dir|
-      file = File.join(dir, 'remotes')
-      FileUtils.touch(file)
-      remotes = Zold::Remotes.new(file: file)
-      remotes.add('127.0.0.1', 1024)
-      remotes.rescore('127.0.0.1', 1024, 15)
-      remotes.all.each do |r|
-        assert_equal(15, r[:score])
-        assert_equal('http://127.0.0.1:1024/', r[:home].to_s)
-      end
-    end
-  end
-
-  def test_tolerates_invalid_requests
-    Dir.mktmpdir do |dir|
-      file = File.join(dir, 'remotes')
-      remotes = Zold::Remotes.new(file: file)
-      remotes.error('127.0.0.1', 1024)
-      remotes.rescore('127.0.0.1', 1024, 15)
-    end
-  end
-
-  def test_modifies_from_many_threads
-    Dir.mktmpdir do |dir|
-      remotes = Zold::Remotes.new(file: File.join(dir, 'a.csv'))
-      remotes.clean
-      host = '192.168.0.1'
-      remotes.add(host)
-      Threads.new(5).assert do
-        remotes.error(host)
-      end
-      assert_equal(0, remotes.all.count { |r| r[:host] != host })
-    end
-  end
-
-  def test_mtime
-    Dir.mktmpdir 'test' do |dir|
-      file = File.join(dir, 'remotes')
-      FileUtils.touch(file)
-      File.stub :mtime, Time.mktime(2018, 1, 1) do
-        remotes = Zold::Remotes.new(file: file)
-        remotes.add('127.0.0.1')
-        assert_equal(Time.mktime(2018, 1, 1), remotes.mtime)
-      end
-    end
-  end
-
-  def test_read_mtime_from_file
-    Dir.mktmpdir 'test' do |dir|
-      file = File.join(dir, 'a/b/c/remotes')
-      remotes = Zold::Remotes.new(file: file)
-      remotes.clean
-      assert_equal(File.mtime(file).to_i, remotes.mtime.to_i)
-    end
-  end
-
-  def test_adds_from_many_threads
-    Dir.mktmpdir do |dir|
-      remotes = Zold::Remotes.new(file: File.join(dir, 'xx.csv'))
-      remotes.clean
-      host = '127.0.0.1'
-      Threads.new(2).assert(100) do |_, r|
-        port = 8080 + r
-        remotes.add(host, port)
-        remotes.error(host, port)
-        assert(remotes.all.find { |x| x[:port] == port })
-      end
-      assert_equal(100, remotes.all.count)
-    end
-  end
-
-  def test_quickly_ads_and_reads
-    Dir.mktmpdir do |dir|
-      remotes = Zold::Remotes.new(file: File.join(dir, 'uu-90.csv'))
-      remotes.clean
-      start = Time.now
-      100.times { |i| remotes.add('192.168.0.1', 8080 + i) }
-      Threads.new(4).assert(10) do |t|
-        remotes.add('127.0.0.1', 8080 + t)
-        remotes.error('127.0.0.1', 8080 + t)
-        remotes.all
-        remotes.iterate(fake_log) { remotes.all }
-        remotes.remove('127.0.0.1', 8080 + t)
-      end
-      fake_log.info("Total time: #{Zold::Age.new(start)}")
-    end
-  end
-
-  def test_unerror_remote
-    Dir.mktmpdir do |dir|
-      remotes = Zold::Remotes.new(file: File.join(dir, 'uu-90.csv'))
-      remotes.clean
-      remotes.add('192.168.0.1', 8081)
-      assert_equal 0, remotes.all.last[:errors]
-      remotes.error('192.168.0.1', 8081)
-      assert_equal 1, remotes.all.last[:errors]
-      remotes.unerror('192.168.0.1', 8081)
-      assert_equal 0, remotes.all.last[:errors]
-    end
-  end
-
-  def test_empty_remotes
-    Time.stub :now, Time.mktime(2018, 1, 1) do
-      remotes = Zold::Remotes::Empty.new
-      assert_equal(Time.mktime(2018, 1, 1), remotes.mtime)
-    end
-  end
-
-  def test_reads_mtime_from_empty_file
-    Dir.mktmpdir do |dir|
-      refute_nil(Zold::Remotes.new(file: File.join(dir, 'file/is/absent')).mtime)
-    end
-  end
-
-  def test_reports_zold_error_header
-    Dir.mktmpdir do |dir|
-      remotes = Zold::Remotes.new(file: File.join(dir, 'uu-90.csv'))
-      remotes.clean
-      remotes.add('11a-example.org', 8080)
-      stub_request(:get, 'http://11a-example.org:8080/').to_return(
-        status: 500,
-        headers: {
-          'X-Zold-Error': 'hey you'
-        }
-      )
-      remotes.iterate(fake_log) do |r|
-        r.assert_code(200, r.http.get)
-      end
-    end
-  end
-
-  def test_manifests_correct_network_name
-    Dir.mktmpdir do |dir|
-      remotes = Zold::Remotes.new(file: File.join(dir, 'uu-083.csv'), network: 'x13')
-      remotes.clean
-      remotes.add('r5-example.org', 8080)
-      stub_request(:get, 'http://r5-example.org:8080/').to_return(status: 200)
-      remotes.iterate(fake_log) do |r|
-        r.http.get
-      end
-      assert_requested(:get, 'http://r5-example.org:8080/', headers: { 'X-Zold-Network' => 'x13' })
-    end
-  end
-end

data/test/test_signature.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2018-2025 Zerocracy
-# SPDX-License-Identifier: MIT
-
-require 'tmpdir'
-require_relative 'test__helper'
-require_relative '../lib/zold/key'
-require_relative '../lib/zold/id'
-require_relative '../lib/zold/txn'
-require_relative '../lib/zold/amount'
-require_relative '../lib/zold/signature'
-
-# Signature test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2018-2025 Zerocracy
-# License:: MIT
-class TestSignature < Zold::Test
-  def test_signs_and_validates
-    pvt = Zold::Key.new(file: 'fixtures/id_rsa')
-    pub = Zold::Key.new(file: 'fixtures/id_rsa.pub')
-    txn = Zold::Txn.new(
-      123, Time.now, Zold::Amount.new(zld: 14.95),
-      'NOPREFIX', Zold::Id.new, 'hello, world!'
-    )
-    id = Zold::Id.new
-    txn = txn.signed(pvt, id)
-    assert_equal(684, txn.sign.length)
-    assert(Zold::Signature.new.valid?(pub, id, txn))
-  end
-end

data/test/test_size.rb

@@ -1,21 +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/size'
-
-# Size test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2018-2025 Zerocracy
-# License:: MIT
-class TestSize < Zold::Test
-  def test_prints_size
-    assert_equal('?', Zold::Size.new(nil).to_s)
-    assert_equal('10b', Zold::Size.new(10).to_s)
-    assert_equal('2Kb', Zold::Size.new(2 * 1024).to_s)
-    assert_equal('9Mb', Zold::Size.new(9 * 1024 * 1024).to_s)
-    assert_equal('7Gb', Zold::Size.new(7 * 1024 * 1024 * 1024).to_s)
-  end
-end

data/test/test_sync_wallets.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2018-2025 Zerocracy
-# SPDX-License-Identifier: MIT
-
-require 'concurrent'
-require 'threads'
-require_relative 'test__helper'
-require_relative 'fake_home'
-require_relative '../lib/zold/key'
-require_relative '../lib/zold/id'
-require_relative '../lib/zold/wallets'
-require_relative '../lib/zold/sync_wallets'
-require_relative '../lib/zold/amount'
-
-# SyncWallets test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2018-2025 Zerocracy
-# License:: MIT
-class TestSyncWallets < Zold::Test
-  def test_adds_wallet
-    FakeHome.new(log: fake_log).run do |home|
-      wallets = home.wallets
-      id = Zold::Id.new
-      home.create_wallet(id)
-      key = Zold::Key.new(file: 'fixtures/id_rsa')
-      amount = Zold::Amount.new(zld: 5.0)
-      Threads.new(5).assert(100) do
-        wallets.acq(id, exclusive: true) do |wallet|
-          wallet.sub(amount, "NOPREFIX@#{Zold::Id.new}", key)
-          wallet.refurbish
-        end
-      end
-      # assert_equal_wait(amount * -100, max: 4) do
-      #   wallets.acq(id, &:balance)
-      # end
-    end
-  end
-end

data/test/test_tax.rb

@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2018-2025 Zerocracy
-# SPDX-License-Identifier: MIT
-
-require 'zold/score'
-require 'time'
-require_relative 'test__helper'
-require_relative 'fake_home'
-require_relative '../lib/zold/id'
-require_relative '../lib/zold/txn'
-require_relative '../lib/zold/wallet'
-require_relative '../lib/zold/tax'
-require_relative '../lib/zold/key'
-require_relative '../lib/zold/amount'
-require_relative '../lib/zold/prefixes'
-
-# Tax test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2018-2025 Zerocracy
-# License:: MIT
-class TestTax < Zold::Test
-  def test_print_fee
-    fake_log.info("Fee in zents: #{Zold::Tax::FEE.to_i}")
-  end
-
-  def test_calculates_tax_for_one_year
-    FakeHome.new(log: fake_log).run do |home|
-      wallet = home.create_wallet
-      a = 10_000
-      wallet.add(
-        Zold::Txn.new(
-          1,
-          Time.now - (a * 60 * 60),
-          Zold::Amount.new(zld: 19.99),
-          'NOPREFIX', Zold::Id.new, '-'
-        )
-      )
-      tax = Zold::Tax.new(wallet)
-      assert_equal(Zold::Tax::FEE * a, tax.debt, tax.to_text)
-    end
-  end
-
-  def test_calculates_debt
-    FakeHome.new(log: fake_log).run do |home|
-      wallet = home.create_wallet
-      (1..30).each do |i|
-        wallet.add(
-          Zold::Txn.new(
-            i + 1,
-            Time.now - (24 * 60 * 60 * 365 * 10),
-            Zold::Amount.new(zld: i.to_f),
-            'NOPREFIX', Zold::Id.new, '-'
-          )
-        )
-      end
-      score = Zold::Score.new(
-        host: 'localhost', port: 80, invoice: 'NOPREFIX@cccccccccccccccc',
-        suffixes: %w[A B C D E F G H I J K L M N O P Q R S T U V]
-      )
-      tax = Zold::Tax.new(wallet)
-      debt = tax.debt
-      txn = tax.pay(Zold::Key.new(file: 'fixtures/id_rsa'), score)
-      assert_equal(debt, txn.amount * -1)
-    end
-  end
-
-  def test_prints_tax_formula
-    FakeHome.new(log: fake_log).run do |home|
-      wallet = home.create_wallet
-      tax = Zold::Tax.new(wallet)
-      refute_nil(tax.to_text)
-    end
-  end
-
-  def test_takes_tax_payment_into_account
-    FakeHome.new(log: fake_log).run do |home|
-      wallet = home.create_wallet
-      amount = Zold::Amount.new(zents: 95_596_800)
-      wallet.add(
-        Zold::Txn.new(
-          1,
-          Time.now,
-          amount * -1,
-          'NOPREFIX', Zold::Id.new('912ecc24b32dbe74'),
-          "TAXES 6 5b5a21a9 b2.zold.io 1000 DCexx0hG 912ecc24b32dbe74 \
-386d4a ec9eae 306e3d 119d073 1c00dba 1376703 203589 5b55f7"
-        )
-      )
-      tax = Zold::Tax.new(wallet, strength: 6)
-      assert_equal(amount, tax.paid)
-      assert_operator(tax.debt, :<, Zold::Amount::ZERO, tax.debt)
-    end
-  end
-
-  def test_filters_out_incoming_payments
-    FakeHome.new(log: fake_log).run do |home|
-      wallet = home.create_wallet
-      amount = Zold::Amount.new(zents: 95_596_800)
-      prefix = Zold::Prefixes.new(wallet).create(8)
-      score = Zold::Score.new(
-        time: Time.now, host: 'localhost', port: 4096,
-        invoice: "#{prefix}@#{wallet.id}", strength: 1
-      )
-      wallet.add(
-        Zold::Txn.new(
-          1,
-          Time.now,
-          amount,
-          'NOPREFIX', Zold::Id.new('0000111122223333'),
-          "TAXES #{score}"
-        )
-      )
-      wallet.add(
-        Zold::Txn.new(
-          2,
-          Time.now,
-          amount * -1,
-          'NOPREFIX', Zold::Id.new('912ecc24b32dbe74'),
-          "TAXES 6 5b5a21a9 b2.zold.io 1000 DCexx0hG 912ecc24b32dbe74 \
-386d4a ec9eae 306e3d 119d073 1c00dba 1376703 203589 5b55f7"
-        )
-      )
-      tax = Zold::Tax.new(wallet, strength: 6, ignore_score_weakness: true)
-      assert_equal(amount, tax.paid)
-      # assert(tax.debt < Zold::Amount::ZERO, tax.debt)
-    end
-  end
-
-  def test_checks_existence_of_duplicates
-    FakeHome.new(log: fake_log).run do |home|
-      wallet = home.create_wallet
-      wallet.add(
-        Zold::Txn.new(
-          1,
-          Time.now - (24 * 60 * 60 * 365),
-          Zold::Amount.new(zld: 19.99),
-          'NOPREFIX', Zold::Id.new, '-'
-        )
-      )
-      target = home.create_wallet
-      invoice = "#{Zold::Prefixes.new(target).create}@#{target.id}"
-      tax = Zold::Tax.new(wallet)
-      score = Zold::Score.new(
-        host: 'localhost', port: 80, invoice: invoice,
-        suffixes: %w[A B C D E F G H I J K L M N O P Q R S T U V]
-      )
-      tax.pay(Zold::Key.new(file: 'fixtures/id_rsa'), score)
-      assert(tax.exists?(tax.details(score)))
-      refute(tax.exists?('-'))
-    end
-  end
-end

data/test/test_thread_pool.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2018-2025 Zerocracy
-# SPDX-License-Identifier: MIT
-
-require 'concurrent'
-require_relative 'test__helper'
-require_relative '../lib/zold/thread_pool'
-
-# ThreadPool test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2018-2025 Zerocracy
-# License:: MIT
-class TestThreadPool < Zold::Test
-  def test_closes_all_threads_right
-    pool = Zold::ThreadPool.new('test', log: fake_log)
-    idx = Concurrent::AtomicFixnum.new
-    threads = 50
-    threads.times do
-      pool.add do
-        idx.increment
-      end
-    end
-    pool.kill
-    assert_equal(threads, idx.value)
-  end
-
-  def test_adds_and_stops
-    pool = Zold::ThreadPool.new('test', log: fake_log)
-    pool.add do
-      sleep 60 * 60
-    end
-    pool.kill
-  end
-
-  def test_stops_stuck_threads
-    pool = Zold::ThreadPool.new('test', log: fake_log)
-    pool.add do
-      loop do
-        # forever
-      end
-    end
-    pool.kill
-  end
-
-  def test_stops_empty_pool
-    pool = Zold::ThreadPool.new('test', log: fake_log)
-    pool.kill
-  end
-
-  def test_prints_to_json
-    pool = Zold::ThreadPool.new('test', log: fake_log)
-    pool.add do
-      Thread.current.thread_variable_set(:foo, 1)
-      loop do
-        # forever
-      end
-    end
-    assert_kind_of(Array, pool.to_json)
-    assert_equal('test', pool.to_json[0][:name])
-    assert_equal('run', pool.to_json[0][:status])
-    assert(pool.to_json[0][:alive])
-    assert_equal(1, pool.to_json[0][:vars]['foo'])
-    pool.kill
-  end
-
-  def test_prints_to_text
-    pool = Zold::ThreadPool.new('test', log: fake_log)
-    refute_nil(pool.to_s)
-  end
-end

data/test/test_tree_wallets.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2018-2025 Zerocracy
-# SPDX-License-Identifier: MIT
-
-require 'tmpdir'
-require_relative 'test__helper'
-require_relative '../lib/zold/wallet'
-require_relative '../lib/zold/key'
-require_relative '../lib/zold/id'
-require_relative '../lib/zold/tree_wallets'
-
-# TreeWallets test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2018-2025 Zerocracy
-# License:: MIT
-class TestTreeWallets < Zold::Test
-  def test_adds_wallet
-    Dir.mktmpdir do |dir|
-      wallets = Zold::TreeWallets.new(dir)
-      id = Zold::Id.new('abcd0123abcd0123')
-      wallets.acq(id, exclusive: true) do |wallet|
-        wallet.init(id, Zold::Key.new(file: 'fixtures/id_rsa.pub'))
-        assert(wallet.path.end_with?('/a/b/c/d/abcd0123abcd0123.z'))
-      end
-      assert_equal(1, wallets.all.count)
-      assert_equal(id, wallets.all[0])
-    end
-  end
-
-  def test_adds_many_wallets
-    Dir.mktmpdir do |dir|
-      wallets = Zold::TreeWallets.new(dir)
-      10.times do
-        id = Zold::Id.new
-        wallets.acq(id, exclusive: true) do |wallet|
-          wallet.init(id, Zold::Key.new(file: 'fixtures/id_rsa.pub'))
-        end
-      end
-      assert_equal(10, wallets.all.count)
-    end
-  end
-
-  def test_count_tree_wallets
-    files = [
-      "0000111122223333#{Zold::Wallet::EXT}",
-      "a/b/d/e/0000111122223333#{Zold::Wallet::EXT}",
-      "a/b/0000111122223333#{Zold::Wallet::EXT}"
-    ]
-    garbage = [
-      '0000111122223333',
-      '0000111122223333.lock',
-      'a/b/c-0000111122223333'
-    ]
-    Dir.mktmpdir do |dir|
-      (files + garbage).each do |f|
-        path = File.join(dir, f)
-        FileUtils.mkdir_p(File.dirname(path))
-        FileUtils.touch(path)
-      end
-      wallets = Zold::TreeWallets.new(dir)
-      assert_equal(files.count, wallets.count)
-    end
-  end
-end