sus 0.7.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 062dd6b24c634d7d006e3334d37fc630b026e6d119f1a4841c7265184ee9ad4d
-  data.tar.gz: 13f84c1d50a68251389502e41b1e10b637a6fc3fe6b5761aff21a9154b885233
+  metadata.gz: 34208c06066d1f09d5a32350e26efc277bbd6d322df448bd55cec6070ea15c09
+  data.tar.gz: 9969914ac2241c539244e362e876096c5d0c7dbe95e830db021d6dc46965c5c3
 SHA512:
-  metadata.gz: c27b28f9e80a52244ca3fba25d48e9f87264bf1033898b0aa20d4cfb59565fe7d847c110159d34f2efc51a6082f30134606d6de2520806c8ff29bccba54250a4
-  data.tar.gz: fa80a6275e3a08853bf0366eb93b6fc3ae733481d14122669840aabc7081544e738e1bb4c86e777ec018851677b6c2b6b1ea5965f592e18232f34c583bf19abc
+  metadata.gz: 8fcf93e09b4e3f60a7ff2f01805bf3a11679f219ad382117b023fc575ae2ada0cb0126151d87922d3b5d2a5c384dc0ae42617332142802b580e09aaa68bb54db
+  data.tar.gz: 6c3600065acc4e25a0adf4473fbd0e87ae1901a1238802a4baedf1a45f3c556b6b8d4d46c7b8eb540c87c64d9c82350302c77c669c942fa39c3d713c052d7ac2

data/bin/sus

@@ -4,13 +4,20 @@ require_relative '../lib/sus/config'
 config = Sus::Config.load
 
 require_relative '../lib/sus'
-filter = Sus::Filter.new
-assertions = Sus::Assertions.default(output: Sus::Output::Null.new)
+registry = config.registry
 
-config.prepare(filter)
+if config.verbose?
+	output = config.output
+	verbose = true
+else
+	output = Sus::Output::Null.new
+	verbose = false
+end
+
+assertions = Sus::Assertions.default(output: output, verbose: verbose)
 
 config.before_tests(assertions)
-filter.call(assertions)
+registry.call(assertions)
 config.after_tests(assertions)
 
 if assertions.failed.any?

data/bin/sus-parallel

@@ -6,20 +6,19 @@ config = Sus::Config.load
 Result = Struct.new(:job, :assertions)
 
 require_relative '../lib/sus'
-require_relative '../lib/sus/progress'
+require_relative '../lib/sus/output'
 jobs = Thread::Queue.new
 results = Thread::Queue.new
 guard = Thread::Mutex.new
-progress = Sus::Progress.new(config.output)
+progress = Sus::Output::Progress.new(config.output)
 
 require 'etc'
 count = Etc.nprocessors
 
 loader = Thread.new do
-	filter = Sus::Filter.new
-	config.prepare(filter)
+	registry = config.registry
 	
-	filter.each do |child|
+	registry.each do |child|
 		guard.synchronize{progress.expand}
 		jobs << child
 	end

data/lib/sus/assertions.rb

@@ -1,20 +1,34 @@
 
 require_relative 'output'
+require_relative 'clock'
+
+require_relative 'output/backtrace'
 
 module Sus
 	class Assertions
 		def self.default(**options)
-			self.new(**options, verbose: true)
+			self.new(**options)
 		end
 		
-		def initialize(target: nil, output: Output.default, inverted: false, verbose: false)
+		def initialize(identity: nil, target: nil, output: Output.buffered, inverted: false, isolated: false, measure: false, verbose: false)
+			# In theory, the target could carry the identity of the assertion group, but it's not really necessary, so we just handle it explicitly and pass it into any nested assertions.
+			@identity = identity
 			@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 +36,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} #{@passed.size} passed #{@failed.size} failed #{@deferred.size} deferred>"
 		end
 		
 		def total
@@ -42,8 +62,6 @@ module Sus
 		end
 		
 		def print(output, verbose: @verbose)
-			self
-			
 			if verbose && @target
 				@target.print(output)
 				output.write(": ")
@@ -60,6 +78,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,115 +90,171 @@ 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
 			
-			if @inverted
-				condition = !condition
-			end
-			
 			if condition
 				@passed << self
 				
-				if @verbose
-					@output.puts(:indent, :passed, pass_prefix, message || "assertion")
+				if @inverted || @verbose
+					@output.puts(:indent, :passed, pass_prefix, message || "assertion", Output::Backtrace.first(@identity))
 				end
 			else
 				@failed << self
 				
-				@output.puts(:indent, :failed, fail_prefix, message || "assertion")
+				if !@inverted || @verbose
+					@output.puts(:indent, :failed, fail_prefix, message || "assertion", Output::Backtrace.first(@identity))
+				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!
+			@output.indented do
+				while block = @deferred.shift
+					block.call(self)
+				end
 			end
 		end
 		
 		def fail(error)
 			@failed << self
 			
-			@output.puts(:indent, :failed, fail_prefix, "Unhandled exception ", :value, error.class, ": ", error.message)
-			error.backtrace.each do |line|
-				@output.puts(:indent, line)
+			lines = error.message.split(/\r?\n/)
+			
+			@output.puts(:indent, :error, fail_prefix, "Unhandled exception ", :value, error.class, ":", :reset, " ", lines.shift)
+			
+			lines.each do |line|
+				@output.puts(:indent, "| ", line)
 			end
+				
+			@output.write(Output::Backtrace.for(error, @identity))
 		end
 		
-		def nested(target, isolated: false, inverted: false, **options)
+		def nested(target, identity: @identity, isolated: false, inverted: false, **options)
 			result = nil
-			output = @output
-			
-			if inverted
-				inverted = !@inverted
-			else
-				inverted = @inverted
-			end
 			
+			# Isolated assertions need to have buffered output so they can be replayed if they fail:
 			if isolated
-				output = Output::Buffered.new(output)
+				output = @output.buffered
+			else
+				output = @output
 			end
 			
-			output.write(:indent)
-			target.print(output)
-			output.puts
+			output.puts(:indent, target)
 			
-			assertions = self.class.new(target: target, output: output, inverted: inverted, **options)
+			assertions = self.class.new(identity: identity, target: target, output: output, isolated: isolated, inverted: inverted, verbose: @verbose, **options)
 			
-			begin
-				output.indented do
+			@clock&.start!
+
+			output.indented do
+				begin
 					result = yield(assertions)
+				rescue StandardError => error
+					assertions.fail(error)
+				ensure
+					@clock&.stop!
 				end
-			rescue StandardError => error
-				assertions.fail(error)
 			end
 			
-			if assertions
-				if isolated
-					merge(assertions)
-				else
-					add(assertions)
+			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 and assertions.deferred?
+				assertions.resolve!
+			end
+			
+			if assertions.deferred?
+				self.defer do
+					output.puts(:indent, assertions.target)
+					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
 		end
 		
-		def merge(assertions)
+		def merge!(assertions)
 			@count += assertions.count
 			
 			if assertions.passed?
 				@passed << assertions
 
-				if @verbose
-					@output.write(:indent, :passed, pass_prefix, :reset)
-					self.print(@output, verbose: false)
-					@output.puts
-				end
+				# if @verbose
+				# 	@output.write(:indent, :passed, pass_prefix, :reset)
+				# 	self.print(@output, verbose: false)
+				# 	@output.puts
+				# end
 			else
 				@failed << assertions
 
-				@output.write(:indent, :failed, fail_prefix, :reset)
-				self.print(@output, verbose: false)
-				@output.puts
+				# @output.write(:indent, :failed, fail_prefix, :reset)
+				# self.print(@output, verbose: false)
+				# @output.puts
 			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
+			# if @verbose
+			# 	@output.write(:indent)
+			# 	self.print(@output, verbose: false)
+			# 	@output.puts
+			# end
 		end
-		
-		private
-		
+				
 		def pass_prefix
 			"✓ "
 		end

data/lib/sus/base.rb

@@ -1,10 +1,16 @@
 
 require_relative 'context'
+require_relative 'loader'
 
 module Sus
+	# The base test case class. We need to be careful about what local state is stored.
 	class Base
 		def initialize(assertions)
-			@assertions = assertions
+			@__assertions__ = assertions
+		end
+		
+		def inspect
+			"\#<Sus::Base for #{self.class.description.inspect}>"
 		end
 		
 		def before
@@ -22,23 +28,20 @@ module Sus
 		end
 		
 		def assert(...)
-			@assertions.assert(...)
+			@__assertions__.assert(...)
 		end
 		
 		def refute(...)
-			@assertions.refute(...)
-		end
-		
-		def expect(subject)
-			Expect.new(subject)
+			@__assertions__.refute(...)
 		end
 	end
 	
-	def self.base(description = "base")
+	def self.base(description = nil)
 		base = Class.new(Base)
+		
 		base.extend(Context)
 		base.description = description
-		
+				
 		return base
 	end
 end

data/lib/sus/be.rb

@@ -6,13 +6,13 @@ module Sus
 		end
 		
 		def print(output)
-			output.write("be ", :be, *@arguments.join(" "))
+			operation, *arguments = *@arguments
+			
+			output.write("be ", :be, operation.to_s, :reset, " ", :variable, arguments.map(&:inspect).join, :reset)
 		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
@@ -58,5 +58,9 @@ module Sus
 				Be
 			end
 		end
+		
+		def be_a(klass)
+			Be.new(:is_a?, klass)
+		end
 	end
 end

data/lib/sus/be_within.rb

@@ -7,7 +7,7 @@ module Sus
 			end
 			
 			def print(output)
-				output.write("be within ", :variable, @range)
+				output.write("be within ", :variable, @range, :reset)
 			end
 			
 			def call(assertions, subject)
@@ -30,7 +30,7 @@ module Sus
 		end
 		
 		def print(output)
-			output.write("be within ", :variable, @tolerance)
+			output.write("be within ", :variable, @tolerance, :reset)
 		end
 		
 		def call(assertions, subject)

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

@@ -20,6 +20,10 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require_relative 'clock'
+require_relative 'registry'
+require_relative 'loader'
+
 module Sus
 	class Config
 		PATH = "config/sus.rb"
@@ -32,7 +36,7 @@ module Sus
 			end
 		end
 		
-		def self.load(root: Dir.pwd, argv: ARGV)
+		def self.load(root: Dir.pwd, arguments: ARGV)
 			derived = Class.new(self)
 			
 			if path = self.path(root)
@@ -41,12 +45,30 @@ module Sus
 				derived.prepend(config)
 			end
 			
-			return derived.new(root, argv)
+			options = {
+				verbose: !!arguments.delete('--verbose')
+			}
+			
+			return derived.new(root, arguments, **options)
 		end
 		
-		def initialize(root, paths)
+		def initialize(root, paths, verbose: false)
 			@root = root
 			@paths = paths
+			@verbose = verbose
+			
+			@clock = Clock.new
+		end
+		
+		attr :root
+		attr :paths
+		
+		def verbose?
+			@verbose
+		end
+		
+		def partial?
+			@paths.any?
 		end
 		
 		def output
@@ -59,8 +81,26 @@ module Sus
 			return Dir.glob(DEFAULT_TEST_PATTERN, base: @root)
 		end
 		
-		def prepare(registry)
+		def registry
+			@registry ||= self.load_registry
+		end
+		
+		def base
+			Sus.base
+		end
+		
+		def setup_base(base)
+			base.extend(Loader)
+			base.define_singleton_method(:require_root) {self.root}
+		end
+		
+		def load_registry
+			registry = Sus::Registry.new
+			
+			self.setup_base(registry.base)
+			
 			if @paths&.any?
+				registry = Sus::Filter.new(registry)
 				@paths.each do |path|
 					registry.load(path)
 				end
@@ -69,22 +109,110 @@ module Sus
 					registry.load(path)
 				end
 			end
+			
+			return registry
 		end
 		
 		def before_tests(assertions)
+			@clock.start!
 		end
 		
 		def after_tests(assertions)
+			@clock.stop!
+			
+			self.print_summary(assertions)
+		end
+		
+		protected
+		
+		def print_summary(assertions)
 			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
+		
+		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|
-					failure.output.append(output)
+					output.append(failure.output)
 				end
 			end
 		end