zold 0.15.0 → 0.16.0

data/test/node/test_emission.rb

@@ -29,7 +29,7 @@ require_relative '../../lib/zold/amount'
 class EmissionTest < Minitest::Test
   def test_emission
     (1..10).each do |year|
-      FakeHome.new.run do |home|
+      FakeHome.new(log: test_log).run do |home|
         wallet = home.create_wallet
         wallet.add(
           Zold::Txn.new(
@@ -45,7 +45,7 @@ Limit: #{Zold::Emission.new(wallet).limit}")
   end
 
   def test_emission_passes
-    FakeHome.new.run do |home|
+    FakeHome.new(log: test_log).run do |home|
       wallet = home.create_wallet(Zold::Id::ROOT)
       wallet.add(
         Zold::Txn.new(

data/test/node/test_entrance.rb

@@ -39,7 +39,7 @@ class TestEntrance < Minitest::Test
   def test_pushes_wallet
     sid = Zold::Id::ROOT
     tid = Zold::Id.new
-    body = FakeHome.new.run do |home|
+    body = FakeHome.new(log: test_log).run do |home|
       source = home.create_wallet(sid)
       target = home.create_wallet(tid)
       Zold::Pay.new(wallets: home.wallets, remotes: home.remotes, log: test_log).run(
@@ -48,13 +48,15 @@ class TestEntrance < Minitest::Test
           source.id.to_s, target.id.to_s, '19.99', 'testing'
         ]
       )
-      File.read(source.path)
+      IO.read(source.path)
     end
-    FakeHome.new.run do |home|
+    FakeHome.new(log: test_log).run do |home|
       source = home.create_wallet(sid)
-      home.create_wallet(tid)
+      target = home.create_wallet(tid)
       e = Zold::Entrance.new(home.wallets, home.remotes, home.copies(source).root, 'x', log: test_log)
       modified = e.push(source.id, body)
+      assert_equal(Zold::Amount.new(zld: -19.99), source.balance)
+      assert_equal(Zold::Amount.new(zld: 19.99), target.balance)
       assert_equal(2, modified.count)
       assert(modified.include?(sid))
       assert(modified.include?(tid))
@@ -62,10 +64,10 @@ class TestEntrance < Minitest::Test
   end
 
   def test_renders_json
-    FakeHome.new.run do |home|
+    FakeHome.new(log: test_log).run do |home|
       wallet = home.create_wallet
       e = Zold::Entrance.new(home.wallets, home.remotes, home.copies.root, 'x', log: test_log)
-      e.push(wallet.id, File.read(wallet.path))
+      e.push(wallet.id, IO.read(wallet.path))
       assert(e.to_json[:history].include?(wallet.id.to_s))
       assert(!e.to_json[:speed].negative?)
     end

data/test/node/test_farm.rb

@@ -106,7 +106,7 @@ class FarmTest < Minitest::Test
         suffixes: %w[13f7f01 b2b32b 4ade7e],
         strength: 6
       )
-      File.write(cache, score.to_s)
+      IO.write(cache, score.to_s)
       farm = Zold::Farm.new('NOPREFIX4@ffffffffffffffff', cache, log: test_log)
       farm.start(score.host, score.port, threads: 1, strength: score.strength) do
         100.times do

data/test/node/test_front.rb

@@ -24,6 +24,7 @@ require 'minitest/autorun'
 require 'json'
 require 'time'
 require 'securerandom'
+require 'threads'
 require_relative '../test__helper'
 require_relative 'fake_node'
 require_relative '../fake_home'
@@ -33,6 +34,10 @@ require_relative '../../lib/zold/json_page'
 require_relative '../../lib/zold/score'
 
 class FrontTest < Minitest::Test
+  def app
+    Zold::Front
+  end
+
   def test_renders_front_json
     FakeNode.new(log: test_log).run(['--no-metronome', '--network=foo', '--threads=0']) do |port|
       res = Zold::Http.new(uri: "http://localhost:#{port}/", network: 'foo', score: nil).get
@@ -51,7 +56,7 @@ class FrontTest < Minitest::Test
   end
 
   def test_renders_public_pages
-    FakeNode.new(log: test_log).run(['--ignore-score-weakness']) do |port|
+    FakeNode.new(log: test_log).run(['--ignore-score-weakness', '--no-metronome', '--threads=0']) do |port|
       {
         '200' => [
           '/robots.txt',
@@ -66,7 +71,14 @@ class FrontTest < Minitest::Test
         ],
         '404' => [
           '/this-is-absent',
-          '/wallet/ffffeeeeddddcccc'
+          '/wallet/ffffeeeeddddcccc',
+          '/wallet/ffffeeeeddddcccc.bin',
+          '/wallet/ffffeeeeddddcccc.json',
+          '/wallet/ffffeeeeddddcccc.txt',
+          '/wallet/ffffeeeeddddcccc/balance',
+          '/wallet/ffffeeeeddddcccc/key',
+          '/wallet/ffffeeeeddddcccc/mtime',
+          '/wallet/ffffeeeeddddcccc/digest'
         ]
       }.each do |code, paths|
         paths.each do |p|
@@ -98,12 +110,12 @@ class FrontTest < Minitest::Test
   end
 
   def test_renders_wallet_pages
-    FakeHome.new.run do |home|
+    FakeHome.new(log: test_log).run do |home|
       FakeNode.new(log: test_log).run(['--ignore-score-weakness', '--standalone']) do |port|
         wallet = home.create_wallet
         base = "http://localhost:#{port}"
         response = Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}", score: nil)
-          .put(File.read(wallet.path))
+          .put(IO.read(wallet.path))
         assert_equal('200', response.code, response.body)
         assert_equal_wait('200') { Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}", score: nil).get.code }
         [
@@ -123,15 +135,15 @@ class FrontTest < Minitest::Test
   end
 
   def test_fetch_in_multiple_threads
-    FakeNode.new(log: test_log).run(['--no-metronome']) do |port|
-      FakeHome.new.run do |home|
+    FakeNode.new(log: test_log).run(['--no-metronome', '--threads=0', '--standalone']) do |port|
+      FakeHome.new(log: test_log).run do |home|
         wallet = home.create_wallet
         base = "http://localhost:#{port}"
-        Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}", score: nil).put(File.read(wallet.path))
+        Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}", score: nil).put(IO.read(wallet.path))
         assert_equal_wait('200') { Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}", score: nil).get.code }
         threads = []
         mutex = Mutex.new
-        assert_in_threads(loops: 100) do
+        Threads.new(6).assert(100) do
           assert_equal_wait('200') do
             res = Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}", score: nil).get
             mutex.synchronize { threads << res.header['X-Zold-Thread'] }
@@ -144,18 +156,18 @@ class FrontTest < Minitest::Test
   end
 
   def test_pushes_twice
-    FakeNode.new(log: test_log).run do |port|
-      FakeHome.new.run do |home|
+    FakeNode.new(log: test_log).run(['--no-metronome', '--threads=0', '--standalone']) do |port|
+      FakeHome.new(log: test_log).run do |home|
         wallet = home.create_wallet
         base = "http://localhost:#{port}"
         assert_equal(
           '200',
-          Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}", score: nil).put(File.read(wallet.path)).code
+          Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}", score: nil).put(IO.read(wallet.path)).code
         )
         assert_equal_wait('200') { Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}", score: nil).get.code }
         3.times do
           r = Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}", score: nil)
-            .put(File.read(wallet.path))
+            .put(IO.read(wallet.path))
           assert_equal('304', r.code, r.body)
         end
       end
@@ -163,12 +175,12 @@ class FrontTest < Minitest::Test
   end
 
   def test_pushes_many_wallets
-    FakeNode.new(log: test_log).run do |port|
+    FakeNode.new(log: test_log).run(['--no-metronome', '--threads=0', '--standalone']) do |port|
       base = "http://localhost:#{port}"
-      FakeHome.new.run do |home|
-        assert_in_threads(threads: 20) do
+      FakeHome.new(log: test_log).run do |home|
+        Threads.new(5).assert do
           wallet = home.create_wallet
-          Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}", score: nil).put(File.read(wallet.path))
+          Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}", score: nil).put(IO.read(wallet.path))
           assert_equal_wait('200') { Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}", score: nil).get.code }
         end
       end
@@ -181,7 +193,6 @@ class FrontTest < Minitest::Test
       '4' => 'https://www.zold.io/images/logo-orange.png',
       '16' => 'https://www.zold.io/images/logo-green.png'
     }.each do |num, path|
-      test_log.info("Calculating score #{num}...")
       score = Zold::Score.new(
         time: Time.now, host: 'localhost', port: 999,
         invoice: 'NOPREFIX@ffffffffffffffff',
@@ -190,7 +201,6 @@ class FrontTest < Minitest::Test
       num.to_i.times do
         score = score.next
       end
-      test_log.info("Score #{num} calculated.")
       if score.value >= 16
         assert_equal(
           path, 'https://www.zold.io/images/logo-green.png',
@@ -225,23 +235,22 @@ class FrontTest < Minitest::Test
   end
 
   def test_performance
-    start = Time.now
-    total = 50
+    times = Queue.new
     FakeNode.new(log: test_log).run(['--threads=4', '--strength=6', '--no-metronome']) do |port|
-      total.times do
+      Threads.new(10).assert(100) do
+        start = Time.now
         Zold::Http.new(uri: URI("http://localhost:#{port}/"), score: nil).get
+        times << Time.now - start
       end
     end
-    test_log.info("Average response time is #{Zold::Age.new(start)}")
-  end
-
-  def app
-    Zold::Front
+    all = []
+    all << times.pop(true) until times.empty?
+    test_log.info("Average response time is #{all.inject(&:+) / all.count}")
   end
 
   def test_headers_are_being_set_correctly
     Time.stub :now, Time.at(0) do
-      FakeNode.new(log: test_log).run(['--ignore-score-weakness']) do |port|
+      FakeNode.new(log: test_log).run(['--no-metronome', '--threads=0', '--ignore-score-weakness']) do |port|
         response = Zold::Http.new(uri: URI("http://localhost:#{port}/"), score: nil).get
         assert_equal('no-cache', response.header['Cache-Control'])
         assert_equal('close', response.header['Connection'])
@@ -273,7 +282,7 @@ class FrontTest < Minitest::Test
   end
 
   def test_default_alias_parameter
-    FakeNode.new(log: test_log).run(['--ignore-score-weakness']) do |port|
+    FakeNode.new(log: test_log).run(['--ignore-score-weakness', '--no-metronome']) do |port|
       uri = URI("http://localhost:#{port}/")
       response = Zold::Http.new(uri: uri, score: nil).get
       assert_match(
@@ -295,17 +304,17 @@ class FrontTest < Minitest::Test
   end
 
   def test_push_fetch_in_multiple_threads
-    key = Zold::Key.new(text: File.read('fixtures/id_rsa'))
-    FakeNode.new(log: test_log).run do |port|
-      FakeHome.new.run do |home|
+    key = Zold::Key.new(text: IO.read('fixtures/id_rsa'))
+    FakeNode.new(log: test_log).run(['--no-metronome', '--threads=0', '--standalone']) do |port|
+      FakeHome.new(log: test_log).run do |home|
         wallet = home.create_wallet(Zold::Id::ROOT)
         base = "http://localhost:#{port}"
-        Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}", score: nil).put(File.read(wallet.path))
+        Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}", score: nil).put(IO.read(wallet.path))
         assert_equal_wait('200') { Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}", score: nil).get.code }
         cycles = 50
         cycles.times do
           wallet.sub(Zold::Amount.new(coins: 10), "NOPREFIX@#{Zold::Id.new}", key)
-          Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}", score: nil).put(File.read(wallet.path))
+          Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}", score: nil).put(IO.read(wallet.path))
           assert_equal('200', Zold::Http.new(uri: "#{base}/wallet/#{wallet.id}", score: nil).get.code)
         end
         assert_equal_wait(-10 * cycles) do

data/test/node/test_nodup_entrance.rb

@@ -33,10 +33,10 @@ require_relative 'fake_entrance'
 # License:: MIT
 class TestAsyncEntrance < Minitest::Test
   def test_ignores_dup
-    FakeHome.new.run do |home|
+    FakeHome.new(log: test_log).run do |home|
       wallet = home.create_wallet
       Zold::NoDupEntrance.new(RealEntrance.new, home.wallets, log: test_log).start do |e|
-        assert(e.push(wallet.id, File.read(wallet.path)).empty?)
+        assert(e.push(wallet.id, IO.read(wallet.path)).empty?)
       end
     end
   end

data/test/node/test_safe_entrance.rb

@@ -35,23 +35,23 @@ require_relative 'fake_entrance'
 # License:: MIT
 class TestSafeEntrance < Minitest::Test
   def test_rejects_wallet_with_negative_balance
-    FakeHome.new.run do |home|
+    FakeHome.new(log: test_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 StandardError do
-        Zold::SafeEntrance.new(FakeEntrance.new).push(wallet.id, File.read(wallet.path))
+        Zold::SafeEntrance.new(FakeEntrance.new).push(wallet.id, IO.read(wallet.path))
       end
     end
   end
 
   def test_rejects_wallet_with_wrong_network
-    FakeHome.new.run do |home|
-      wallet = Zold::Wallet.new(File.join(home.dir, 'wallet'))
+    FakeHome.new(log: test_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))
+        Zold::SafeEntrance.new(FakeEntrance.new).push(wallet.id, IO.read(wallet.path))
       end
     end
   end

data/test/node/test_spread_entrance.rb

@@ -35,7 +35,7 @@ require_relative 'fake_entrance'
 # License:: MIT
 class TestSpreadEntrance < Minitest::Test
   def test_renders_json
-    FakeHome.new.run do |home|
+    FakeHome.new(log: test_log).run do |home|
       wallet = home.create_wallet(Zold::Id.new)
       Zold::SpreadEntrance.new(
         Zold::Entrance.new(home.wallets, home.remotes, home.copies(wallet).root, 'x', log: test_log),
@@ -47,13 +47,13 @@ class TestSpreadEntrance < Minitest::Test
   end
 
   def test_ignores_duplicates
-    FakeHome.new.run do |home|
+    FakeHome.new(log: test_log).run do |home|
       FakeNode.new(log: test_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: test_log).start do |e|
-          8.times { e.push(wallet.id, File.read(wallet.path)) }
+          8.times { e.push(wallet.id, IO.read(wallet.path)) }
           assert(e.to_json[:modified] < 2, "It's too big: #{e.to_json[:modified]}")
         end
       end

data/test/node/test_sync_entrance.rb

@@ -32,7 +32,7 @@ require_relative 'fake_entrance'
 # License:: MIT
 class TestSyncEntrance < Minitest::Test
   def test_renders_json
-    FakeHome.new.run do
+    FakeHome.new(log: test_log).run do
       Zold::SyncEntrance.new(FakeEntrance.new, log: test_log).start do |e|
         assert(!e.to_json.nil?)
       end

data/test/test__helper.rb

@@ -53,40 +53,14 @@ module Minitest
         end
         sleep 1
         sec = Time.now - start
-        raise "'#{actual}' is not equal to '#{expected}' even after #{Age.new(start)} of waiting" if sec > max
+        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 assert_in_threads(threads: Concurrent.processor_count * 8, loops: 0)
-      done = Concurrent::AtomicFixnum.new
-      cycles = Concurrent::AtomicFixnum.new
-      pool = Concurrent::FixedThreadPool.new(threads)
-      latch = Concurrent::CountDownLatch.new(1)
-      threads.times do |t|
-        pool.post do
-          Thread.current.name = "assert-thread-#{t}"
-          latch.wait(10)
-          loop do
-            Zold::VerboseThread.new(test_log).run(true) do
-              yield t
-            end
-            cycles.increment
-            break if cycles.value > loops
-          end
-          done.increment
-        end
-      end
-      latch.count_down
-      pool.shutdown
-      pool.kill unless pool.wait_for_termination(10)
-      assert_equal(threads, done.value)
-    end
-
     def test_log
       require_relative '../lib/zold/log'
-      @test_log = Zold::Log::Verbose.new
-      @test_log = Zold::Log::Quiet.new if ENV['TEST_QUIET_LOG']
-      Zold::Log::Sync.new(@test_log)
+      @test_log ||= Zold::Log::Sync.new(ENV['TEST_QUIET_LOG'] ? Zold::Log::Quiet.new : Zold::Log::Verbose.new)
     end
 
     class TestLogger

data/test/test_cached_wallets.rb

@@ -35,7 +35,7 @@ require_relative '../lib/zold/amount'
 # License:: MIT
 class TestCachedWallets < Minitest::Test
   def test_adds_wallet
-    FakeHome.new.run do |home|
+    FakeHome.new(log: test_log).run do |home|
       wallets = Zold::CachedWallets.new(home.wallets)
       id = Zold::Id.new
       first = nil

data/test/test_copies.rb

@@ -26,7 +26,9 @@ require 'time'
 require_relative 'fake_home'
 require_relative 'test__helper'
 require_relative '../lib/zold/id'
+require_relative '../lib/zold/age'
 require_relative '../lib/zold/copies'
+require_relative '../lib/zold/dir_items'
 require_relative '../lib/zold/wallet'
 
 # Copies test.
@@ -121,12 +123,12 @@ class TestCopies < Minitest::Test
 
   def content(text)
     id = Zold::Id.new('aaaabbbbccccdddd')
-    FakeHome.new.run do |home|
+    FakeHome.new(log: test_log).run do |home|
       wallet = home.create_wallet(id)
       amount = Zold::Amount.new(zld: 1.99)
       key = Zold::Key.new(file: 'fixtures/id_rsa')
       wallet.sub(amount, 'NOPREFIX@0000111122223333', key, text, time: Time.parse('2018-01-01T01:01:01Z'))
-      File.read(wallet.path)
+      IO.read(wallet.path)
     end
   end
 end

data/test/test_dir_items.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2018 Yegor Bugayenko
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the 'Software'), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+require 'minitest/autorun'
+require 'tmpdir'
+require 'threads'
+require_relative 'test__helper'
+require_relative '../lib/zold/age'
+require_relative '../lib/zold/dir_items'
+
+# DirItems test.
+# Author:: Yegor Bugayenko (yegor256@gmail.com)
+# Copyright:: Copyright (c) 2018 Yegor Bugayenko
+# License:: MIT
+class TestDirItems < Minitest::Test
+  def test_intensive_write_in_threads
+    Dir.mktmpdir do |dir|
+      file = File.join(dir, 'hey.txt')
+      Thread.start do
+        loop do
+          Zold::DirItems.new(dir).fetch
+        end
+      end
+      Threads.new(100).assert do
+        start = Time.now
+        File.open(file, 'w+') do |f|
+          f.write('test')
+        end
+        test_log.debug("Saved in #{Zold::Age.new(start)}")
+        sleep 1
+      end
+    end
+  end
+
+  def test_lists_empty_dir
+    Dir.mktmpdir do |dir|
+      assert_equal(0, Zold::DirItems.new(File.join(dir, 'a/b/c')).fetch.count)
+    end
+  end
+
+  def test_lists_recursively
+    Dir.mktmpdir do |dir|
+      files = ['test1.txt', 'a/b/c/text', 'd/e/f/text', 'a/b/c/zz/text.1.2.3']
+      files.each do |f|
+        path = File.join(dir, f)
+        FileUtils.mkdir_p(File.dirname(path))
+        FileUtils.touch(path)
+      end
+      found = Zold::DirItems.new(dir).fetch
+      assert_equal(files.count, found.count)
+      files.each do |f|
+        assert(found.include?(f), f)
+      end
+    end
+  end
+
+  def test_lists_non_recursively
+    Dir.mktmpdir do |dir|
+      files = ['1.txt', 'a/1.txt', 'a/b/1.txt', 'a/b/c/1.txt']
+      files.each do |f|
+        path = File.join(dir, f)
+        FileUtils.mkdir_p(File.dirname(path))
+        FileUtils.touch(path)
+      end
+      found = Zold::DirItems.new(dir).fetch(recursive: false)
+      assert_equal(1, found.count)
+    end
+  end
+end