sus 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 062dd6b24c634d7d006e3334d37fc630b026e6d119f1a4841c7265184ee9ad4d
-  data.tar.gz: 13f84c1d50a68251389502e41b1e10b637a6fc3fe6b5761aff21a9154b885233
+  metadata.gz: 37d794368517fecc66824b3fffff17d0849df9cdc100df5cf8ecb40bce1c2b1d
+  data.tar.gz: b8395a5ce04c2fe773f6135e6a930a5b05d5c0efa6e566d5d02e087862ea7ed7
 SHA512:
-  metadata.gz: c27b28f9e80a52244ca3fba25d48e9f87264bf1033898b0aa20d4cfb59565fe7d847c110159d34f2efc51a6082f30134606d6de2520806c8ff29bccba54250a4
-  data.tar.gz: fa80a6275e3a08853bf0366eb93b6fc3ae733481d14122669840aabc7081544e738e1bb4c86e777ec018851677b6c2b6b1ea5965f592e18232f34c583bf19abc
+  metadata.gz: 6407424e83d8a8068715c04472e5de5fec9a8570601cc9fc4b340c12236e98b85a9d3ef7bafddb3ccd567c6136d23175fd80ecc79b83fe39ba1990d1da593eee
+  data.tar.gz: 112c5ccafab10d46cef22ad1ebd11fbc9ed343bfae3df8d121ea0cf72c9126576d78e3bb524f770aa8d9669db75309a4e221b6265c52ca7de4fd34e1c27047dd

data/bin/sus-parallel

@@ -6,11 +6,11 @@ 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

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

@@ -20,6 +20,8 @@
 # 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"
@@ -47,6 +49,7 @@ module Sus
 		def initialize(root, paths)
 			@root = root
 			@paths = paths
+			@clock = Clock.new
 		end
 		
 		def output
@@ -72,19 +75,105 @@ module Sus
 		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|
-					failure.output.append(output)
+					output.append(failure.output)
 				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

data/lib/sus/mock.rb

@@ -0,0 +1,127 @@
+# 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 'expect'
+
+module Sus
+	class Mock
+		def initialize(target)
+			@target = target
+			@interceptor = Module.new
+			
+			@target.singleton_class.prepend(@interceptor)
+		end
+		
+		attr :target
+		
+		def print(output)
+			output.write("mock ", :context, @target.inspect)
+		end
+		
+		def clear
+			@interceptor.instance_methods.each do |method_name|
+				@interceptor.remove_method(method_name)
+			end
+		end
+		
+		def replace(method, &hook)
+			execution_context = Thread.current
+
+			@interceptor.define_method(method) do |*arguments, **options, &block|
+				if execution_context == Thread.current
+					hook.call(*arguments, **options, &block)
+				else
+					super(*arguments, **options, &block)
+				end
+			end
+			
+			return self
+		end
+		
+		def before(method, &hook)
+			execution_context = Thread.current
+
+			@interceptor.define_method(method) do |*arguments, **options, &block|
+				hook.call(*arguments, **options, &block) if execution_context == Thread.current
+				super(*arguments, **options, &block)
+			end
+
+			return self
+		end
+
+		def after(method, &hook)
+			execution_context = Thread.current
+
+			@interceptor.define_method(method) do |*arguments, **options, &block|
+				result = super(*arguments, **options, &block)
+				hook.call(result, *arguments, **options, &block) if execution_context == Thread.current
+				return result
+			end
+
+			return self
+		end
+	end
+
+	module Mocks
+		def after
+			super
+			
+			@mocks&.each_value(&:clear)
+		end
+		
+		def mock(target)
+			validate_mock!(target)
+
+			mock = self.mocks[target]
+
+			if block_given?
+				yield mock
+			end
+
+			return mock
+		end
+		
+		private
+		
+		MockTargetError = Class.new(StandardError)
+
+		def validate_mock!(target)
+			if target.frozen?
+				raise MockTargetError, "Cannot mock frozen object #{target.inspect}!"
+			end
+		end
+
+		def mocks
+			@mocks ||= Hash.new{|h,k| h[k] = Mock.new(k)}.compare_by_identity
+		end
+	end
+
+	class Base
+		def mock(target, &block)
+			# Pull in the extra functionality:
+			self.singleton_class.prepend(Mocks)
+
+			# Redirect the method to the new functionality:
+			self.mock(target, &block)
+		end
+	end
+end