sus 0.6.2 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a7a023ab9f3e7c4335513ad7f7dd4e735e8749877001f5793f8fa98edf990b63
-  data.tar.gz: bac97d266bbbf1e438bc94001f59bca09d78900841bc55c42afe1a49ce34d00c
+  metadata.gz: b15c28cff36f956e3847c3c843f5426efbe05d9ef8f52fbc9df200f7efa1bf12
+  data.tar.gz: b6fe36ec97a8537b20b73d83d40aab8ebd7e3b60b9554493bf9e1ee2dd01bdf0
 SHA512:
-  metadata.gz: 63a7c1700c036a2b0ad6ca4b8e4dc90887cd0e80c02745a0130fa2c46632d072e5bef50f6e60d6d8609eef2247ebfa2f043e2082d88c9cbbfeae89d2aca23d29
-  data.tar.gz: 6d8dc8731abe2fa44282bce323f713e8c60e939002ed2f0431bd86fc2e904c1046c43a2a6b36d312a6b91f0ba741b8b39e69affa5fef0882206cb386dcba86db
+  metadata.gz: d3a1e05b190b0e590c8652356d13bdfe7bc84194b6da6c62d26a7d249d5c600966334f91db47c155db9e906a04832daa3f1d64426744acf830700962d2c3ab49
+  data.tar.gz: 5325cbc73f4e0dea9808e379008df9ea603a005683d1b342f2950497cc24a751c7b0a4907db1397e92162bc5698b7d8abc528d47229cd09a9e590311b8d86063

data/bin/sus

@@ -1,40 +1,18 @@
 #!/usr/bin/env ruby
 
-require_relative '../lib/sus'
-
-if File.exist?("config/test.rb")
-	load("config/test.rb")
-end
-
-def prepare(paths, registry)
-	if paths&.any?
-		paths.each do |path|
-			registry.load(path)
-		end
-	else
-		Dir.glob("test/**/*.rb").each do |path|
-			registry.load(path)
-		end
-	end
-end
+require_relative '../lib/sus/config'
+config = Sus::Config.load
 
+require_relative '../lib/sus'
 filter = Sus::Filter.new
-output = Sus::Output.default
 assertions = Sus::Assertions.default(output: Sus::Output::Null.new)
 
-prepare(ARGV, filter)
+config.prepare(filter)
 
+config.before_tests(assertions)
 filter.call(assertions)
-
-assertions.print(output)
-output.puts
+config.after_tests(assertions)
 
 if assertions.failed.any?
-	output.puts
-	
-	assertions.failed.each do |failure|
-		failure.output.append(output)
-	end
-	
 	exit(1)
 end

data/bin/sus-parallel

@@ -1,39 +1,23 @@
 #!/usr/bin/env ruby
 
-require_relative '../lib/sus'
-require_relative '../lib/sus/progress'
-
-if File.exist?("config/test.rb")
-	load("config/test.rb")
-end
-
-require 'etc'
-
-def prepare(paths, registry)
-	if paths&.any?
-		paths.each do |path|
-			registry.load(path)
-		end
-	else
-		Dir.glob("test/**/*.rb").each do |path|
-			registry.load(path)
-		end
-	end
-end
+require_relative '../lib/sus/config'
+config = Sus::Config.load
 
 Result = Struct.new(:job, :assertions)
 
-filter = Sus::Filter.new
-output = Sus::Output.default
-
+require_relative '../lib/sus'
+require_relative '../lib/sus/output'
 jobs = Thread::Queue.new
 results = Thread::Queue.new
 guard = Thread::Mutex.new
-progress = Sus::Progress.new(output)
+progress = Sus::Output::Progress.new(config.output)
+
+require 'etc'
 count = Etc.nprocessors
 
 loader = Thread.new do
-	prepare(ARGV, filter)
+	filter = Sus::Filter.new
+	config.prepare(filter)
 	
 	filter.each do |child|
 		guard.synchronize{progress.expand}
@@ -43,9 +27,10 @@ loader = Thread.new do
 	jobs.close
 end
 
+top = Sus::Assertions.new(output: Sus::Output::Null.new)
+config.before_tests(top)
+
 aggregation = Thread.new do
-	top = Sus::Assertions.new(output: Sus::Output::Null.new)
-	
 	while result = results.pop
 		guard.synchronize{progress.increment}
 		
@@ -79,16 +64,8 @@ workers.each(&:join)
 results.close
 
 assertions = aggregation.value
-
-assertions.print(output)
-output.puts
+config.after_tests(assertions)
 
 if assertions.failed.any?
-	output.puts
-	
-	assertions.failed.each do |failure|
-		failure.output.append(output)
-	end
-	
 	exit(1)
 end

data/lib/sus/assertions.rb

@@ -1,5 +1,6 @@
 
 require_relative 'output'
+require_relative 'clock'
 
 module Sus
 	class Assertions
@@ -7,14 +8,23 @@ module Sus
 			self.new(**options, verbose: true)
 		end
 		
-		def initialize(target: nil, output: Output.default, inverted: false, verbose: false)
+		def initialize(target: nil, output: Output.buffered, inverted: false, isolated: false, measure: false, verbose: false)
 			@target = target
 			@output = output
 			@inverted = inverted
+			@isolated = isolated
 			@verbose = verbose
 			
+			if measure
+				@clock = Clock.new
+			else
+				@clock = nil
+			end
+			
 			@passed = Array.new
 			@failed = Array.new
+			@deferred = Array.new
+			
 			@count = 0
 		end
 		
@@ -22,19 +32,25 @@ module Sus
 		attr :output
 		attr :level
 		attr :inverted
+		attr :isolated
 		attr :verbose
 		
-		# How many nested assertions passed.
+		attr :clock
+		
+		# Nested assertions that have passed.
 		attr :passed
 		
-		# How many nested assertions failed.
+		# Nested assertions that have failed.
 		attr :failed
 		
+		# Nested assertions have been deferred.
+		attr :deferred
+		
 		# The total number of assertions performed:
 		attr :count
 		
 		def inspect
-			"\#<#{self.class} #{@passed.size} passed #{@failed.size} failed>"
+			"\#<#{self.class} #{self.object_id} #{@passed.size} passed #{@failed.size} failed #{@deferred.size} deferred>"
 		end
 		
 		def total
@@ -60,6 +76,10 @@ module Sus
 					output.write(:failed, @failed.size, " failed", :reset, " ")
 				end
 				
+				if @deferred.any?
+					output.write(:deferred, @deferred.size, " deferred", :reset, " ")
+				end
+				
 				output.write("out of ", self.total, " total (", @count, " assertions)")
 			end
 		end
@@ -68,31 +88,58 @@ module Sus
 			@output.puts(:indent, *message)
 		end
 		
+		def empty?
+			@passed.empty? and @failed.empty?
+		end
+		
 		def passed?
-			@failed.empty?
+			if @inverted
+				# Inverted assertions:
+				self.failed.any?
+			else
+				# Normal assertions:
+				self.failed.empty?
+			end
 		end
 		
 		def failed?
-			@failed.any?
+			!self.passed?
 		end
 		
 		def assert(condition, message = nil)
-			@count += 1
+			# sleep 0.5
 			
-			if @inverted
-				condition = !condition
-			end
+			@count += 1
 			
 			if condition
 				@passed << self
 				
-				if @verbose
+				@output.indented do
 					@output.puts(:indent, :passed, pass_prefix, message || "assertion")
 				end
 			else
 				@failed << self
 				
-				@output.puts(:indent, :failed, fail_prefix, message || "assertion")
+				@output.indented do
+					@output.puts(:indent, :failed, fail_prefix, message || "assertion")
+				end
+			end
+		end
+		
+		# Add deferred assertions.
+		def defer(&block)
+			@deferred << block
+		end
+		
+		# Whether there are any deferred assertions.
+		def deferred?
+			@deferred.any?
+		end
+		
+		# This resolves all deferred assertions in order.
+		def resolve!
+			while block = @deferred.shift
+				block.call(self)
 			end
 		end
 		
@@ -107,44 +154,63 @@ module Sus
 		
 		def nested(target, isolated: false, inverted: false, **options)
 			result = nil
-			output = @output
-			
-			if inverted
-				inverted = !@inverted
-			else
-				inverted = @inverted
-			end
-			
-			if isolated
-				output = Output::Buffered.new(output)
-			end
+			output = Output::Buffered.new
 			
 			output.write(:indent)
 			target.print(output)
 			output.puts
 			
-			assertions = self.class.new(target: target, output: output, inverted: inverted, **options)
+			assertions = self.class.new(target: target, output: output, isolated: isolated, inverted: inverted, **options)
 			
 			begin
-				output.indented do
-					result = yield(assertions)
-				end
+				@clock&.start!
+				result = yield(assertions)
 			rescue StandardError => error
 				assertions.fail(error)
+			ensure
+				@clock&.stop!
+			end
+			
+			self.add(assertions)
+			
+			return result
+		end
+		
+		def add(assertions)
+			# If the assertions should be an isolated group, make sure any deferred assertions are resolved:
+			if assertions.isolated
+				assertions.resolve!
 			end
 			
-			if assertions
-				if isolated
-					merge(assertions)
-				else
-					add(assertions)
+			if assertions.deferred?
+				self.defer do
+					assertions.resolve!
+					self.add!(assertions)
 				end
+			else
+				self.add!(assertions)
 			end
+		end
+		
+		private
+		
+		def add!(assertions)
+			raise "Nested assertions must be fully resolved!" if assertions.deferred?
 			
-			return result
+			if assertions.isolated or assertions.inverted
+				# If we are isolated, we merge all child assertions into the parent as a single entity:
+				merge!(assertions)
+			else
+				# Otherwise, we append all child assertions into the parent assertions:
+				append!(assertions)
+			end
+			
+			@output.indented do
+				@output.append(assertions.output)
+			end
 		end
 		
-		def merge(assertions)
+		def merge!(assertions)
 			@count += assertions.count
 			
 			if assertions.passed?
@@ -164,19 +230,18 @@ module Sus
 			end
 		end
 		
-		def add(assertions)
+		def append!(assertions)
 			@count += assertions.count
 			@passed.concat(assertions.passed)
 			@failed.concat(assertions.failed)
+			@deferred.concat(assertions.deferred)
 			
 			if @verbose
 				self.print(@output, verbose: false)
 				@output.puts
 			end
 		end
-		
-		private
-		
+				
 		def pass_prefix
 			"✓ "
 		end

data/lib/sus/base.rb

@@ -28,10 +28,6 @@ module Sus
 		def refute(...)
 			@assertions.refute(...)
 		end
-		
-		def expect(subject)
-			Expect.new(subject)
-		end
 	end
 	
 	def self.base(description = "base")

data/lib/sus/be.rb

@@ -10,9 +10,7 @@ module Sus
 		end
 		
 		def call(assertions, subject)
-			assertions.nested(self) do |assertions|
-				assertions.assert(subject.public_send(*@arguments), subject)
-			end
+			assertions.assert(subject.public_send(*@arguments), self)
 		end
 		
 		class << self

data/lib/sus/clock.rb

@@ -0,0 +1,40 @@
+module Sus
+	class Clock
+		include Comparable
+		
+		def initialize(duration = 0.0)
+			@duration = duration
+		end
+		
+		attr :duration
+		
+		def <=>(other)
+			@duration <=> other.to_f
+		end
+		
+		def to_f
+			@duration
+		end
+		
+		def to_s
+			if @duration < 0.001
+				"#{(@duration * 1_000_000).round(1)}µs"
+			elsif @duration < 1.0
+				"#{(@duration * 1_000).round(1)}ms"
+			else
+				"#{@duration.round(1)}s"
+			end
+		end
+		
+		def start!
+			@start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+		end
+		
+		def stop!
+			if @start_time
+				@duration += Process.clock_gettime(Process::CLOCK_MONOTONIC) - @start_time
+				@start_time = nil
+			end
+		end
+	end
+end

data/lib/sus/config.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+# Copyright, 2022, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# 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 NONINFRINGEMENT. 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_relative 'clock'
+
+module Sus
+	class Config
+		PATH = "config/sus.rb"
+		
+		def self.path(root)
+			path = ::File.join(root, PATH)
+			
+			if ::File.exist?(path)
+				return path
+			end
+		end
+		
+		def self.load(root: Dir.pwd, argv: ARGV)
+			derived = Class.new(self)
+			
+			if path = self.path(root)
+				config = Module.new
+				config.module_eval(::File.read(path), path)
+				derived.prepend(config)
+			end
+			
+			return derived.new(root, argv)
+		end
+		
+		def initialize(root, paths)
+			@root = root
+			@paths = paths
+			@clock = Clock.new
+		end
+		
+		def output
+			@output ||= Sus::Output.default
+		end
+		
+		DEFAULT_TEST_PATTERN = "test/**/*.rb"
+		
+		def test_paths
+			return Dir.glob(DEFAULT_TEST_PATTERN, base: @root)
+		end
+		
+		def prepare(registry)
+			if @paths&.any?
+				@paths.each do |path|
+					registry.load(path)
+				end
+			else
+				test_paths.each do |path|
+					registry.load(path)
+				end
+			end
+		end
+		
+		def before_tests(assertions)
+			@clock.start!
+		end
+		
+		def after_tests(assertions)
+			@clock.stop!
+			
+			output = self.output
+			
+			assertions.print(output)
+			output.puts
+
+			print_finished_statistics(assertions)
+
+			if !partial? and assertions.passed?
+				print_test_feedback(assertions)
+			end
+						
+			print_slow_tests(assertions)
+			print_failed_assertions(assertions)
+		end
+		
+		protected
+		
+		def partial?
+			@paths.any?
+		end
+		
+		def print_finished_statistics(assertions)
+			duration = @clock.duration
+			rate = assertions.count / duration
+			
+			output.puts "🏁 Finished in ", @clock, "; #{rate.round(3)} assertions per second."
+		end
+		
+		def print_test_feedback(assertions)
+			duration = @clock.duration
+			rate = assertions.count / duration
+			
+			total = assertions.total
+			count = assertions.count
+			
+			if total < 10 or count < 10
+				output.puts "😭 You should write more tests and assertions!"
+				
+				# Statistics will be less meaningful with such a small amount of data, so give up:
+				return
+			end
+			
+			# Check whether there is at least, on average, one assertion (or more) per test:
+			assertions_per_test = assertions.count / assertions.total
+			if assertions_per_test < 1.0
+				output.puts "😩 Your tests don't have enough assertions (#{assertions_per_test.round(1)} < 1.0)!"
+			end
+			
+			# Give some feedback about the number of tests:
+			if total < 20
+				output.puts "🥲 You should write more tests (#{total}/20)!"
+			elsif total < 50
+				output.puts "🙂 Your test suite is starting to shape up, keep on at it (#{total}/50)!"
+			elsif total < 100
+				output.puts "😀 Your test suite is maturing, keep on at it (#{total}/100)!"
+			else
+				output.puts "🤩 Your test suite is amazing!"
+			end
+			
+			# Give some feedback about the performance of the tests:
+			if rate < 10.0
+				output.puts "💔 Ouch! Your test suite performance is painful (#{rate.round(1)} < 10)!"
+			elsif rate < 100.0
+				output.puts "💩 Oops! Your test suite performance could be better (#{rate.round(1)} < 100)!"
+			elsif rate < 1_000.0
+				output.puts "💪 Good job! Your test suite has good performance (#{rate.round(1)} < 1000)!"
+			elsif rate < 10_000.0
+				output.puts "🎉 Great job! Your test suite has excellent performance (#{rate.round(1)} < 10000)!"
+			else
+				output.puts "🔥 Wow! Your test suite has outstanding performance (#{rate.round(1)} >= 10000.0)!"
+			end
+		end
+		
+		def print_slow_tests(assertions, threshold = 0.1)
+			slowest_tests = assertions.passed.select{|test| test.clock > threshold}.sort_by(&:clock).reverse!
+			
+			if slowest_tests.empty?
+				output.puts "🐇 No slow tests found! Well done!"
+			else
+				output.puts "🐢 Slow tests:"
+			
+				slowest_tests.each do |test|
+					output.puts "\t", :variable, test.clock, :reset, ": ", test.target
+				end
+			end
+		end
+		
+		def print_failed_assertions(assertions)
+			if assertions.failed.any?
+				output.puts
+				
+				assertions.failed.each do |failure|
+					output.append(failure.output)
+				end
+			end
+		end
+	end
+end

data/lib/sus/expect.rb

@@ -1,11 +1,14 @@
 
 module Sus
 	class Expect
-		def initialize(assertions, subject)
+		def initialize(assertions, subject, inverted: false)
 			@assertions = assertions
 			@subject = subject
-			@inverted = false
+			@inverted = inverted
 		end
+
+		attr :subject
+		attr :inverted
 		
 		def not
 			self.dup.tap do |expect|
@@ -17,9 +20,9 @@ module Sus
 			output.write("expect ", :variable, @subject.inspect, :reset, " ")
 			
 			if @inverted
-				output.write(:failed, "to not", :reset)
+				output.write("to not", :reset)
 			else
-				output.write(:passed, "to", :reset)
+				output.write("to", :reset)
 			end
 		end
 		
@@ -30,14 +33,18 @@ module Sus
 			
 			return self
 		end
+
+		def and(predicate)
+			return to(predicate)
+		end
 	end
 	
 	class Base
-		def expect(subject = nil, &block)
+		def expect(subject = nil, **options, &block)
 			if block_given?
-				Expect.new(@assertions, block)
+				Expect.new(@assertions, block, **options)
 			else
-				Expect.new(@assertions, subject)
+				Expect.new(@assertions, subject, **options)
 			end
 		end
 	end

data/lib/sus/it.rb

@@ -26,7 +26,7 @@ module Sus
 		end
 		
 		def call(assertions)
-			assertions.nested(self, isolated: true) do |assertions|
+			assertions.nested(self, isolated: true, measure: true) do |assertions|
 				instance = self.new(assertions)
 				
 				instance.around do