sus 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dccbd079d0154903705918ed6d572de0f4a4079d2f4d5fd352e8cef0a9694a05
+  data.tar.gz: 400eb2d789f2ff17209f289ad2f0e0d89486cd200e127e80f304fdb2e29c87f3
+SHA512:
+  metadata.gz: f7c3cb03088ccd432b27101ab654032c713bbecff85b18e6bdadf7315361a3be306778bbda012ee04e69f325f989ec093809b13d070f20b5ae8818e7deccdb7a
+  data.tar.gz: b8519c677f9d0731bc5c5a7bbb0dd71ee302b9d5a68b115e1ec6feeb4baf6d841e76a0487b71a9ad0f78ae9a35e30370a88d26a937d1cb0c7d0a617ad77e123b

data/bin/sus

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/sus'
+
+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
+
+filter = Sus::Filter.new
+output = Sus::Output.default
+assertions = Sus::Assertions.default(output: Sus::Output::Null.new)
+
+prepare(ARGV, filter)
+
+filter.call(assertions)
+
+assertions.print(output)
+output.puts
+
+if assertions.failed.any?
+	output.puts
+	
+	assertions.failed.each do |failure|
+		failure.output.append(output)
+	end
+end

data/bin/sus-parallel

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/sus'
+require_relative '../lib/sus/progress'
+
+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
+
+Result = Struct.new(:job, :assertions)
+
+filter = Sus::Filter.new
+output = Sus::Output.default
+
+jobs = Thread::Queue.new
+results = Thread::Queue.new
+guard = Thread::Mutex.new
+progress = Sus::Progress.new(output)
+count = Etc.nprocessors
+
+loader = Thread.new do
+	prepare(ARGV, filter)
+	
+	filter.each do |child|
+		guard.synchronize{progress.expand}
+		jobs << child
+	end
+	
+	jobs.close
+end
+
+aggregation = Thread.new do
+	top = Sus::Assertions.new(output: Sus::Output::Null.new)
+	
+	while result = results.pop
+		guard.synchronize{progress.increment}
+		
+		top.add(result.assertions)
+		
+		guard.synchronize{progress.report(count, top, :busy)}
+	end
+	
+	guard.synchronize{progress.clear}
+	
+	top
+end
+
+workers = count.times.map do |index|
+	Thread.new do
+		while job = jobs.pop
+			guard.synchronize{progress.report(index, job, :busy)}
+			
+			assertions = Sus::Assertions.new(output: Sus::Output::Null.new)
+			job.call(assertions)
+			results << Result.new(job, assertions)
+			
+			guard.synchronize{progress.report(index, "idle", :free)}
+		end
+	end
+end
+
+loader.join
+
+workers.each(&:join)
+results.close
+
+assertions = aggregation.value
+
+assertions.print(output)
+output.puts
+
+if assertions.failed.any?
+	output.puts
+	
+	assertions.failed.each do |failure|
+		failure.output.append(output)
+	end
+end

data/lib/sus/assertions.rb

@@ -0,0 +1,188 @@
+
+require_relative 'output'
+
+module Sus
+	class Assertions
+		def self.default(**options)
+			self.new(**options, verbose: true)
+		end
+		
+		def initialize(target: nil, output: Output.default, inverted: false, verbose: false)
+			@target = target
+			@output = output
+			@inverted = inverted
+			@verbose = verbose
+			
+			@passed = Array.new
+			@failed = Array.new
+			@count = 0
+		end
+		
+		attr :target
+		attr :output
+		attr :level
+		attr :inverted
+		attr :verbose
+		
+		# How many nested assertions passed.
+		attr :passed
+		
+		# How many nested assertions failed.
+		attr :failed
+		
+		# The total number of assertions performed:
+		attr :count
+		
+		def inspect
+			"\#<#{self.class} #{@passed.size} passed #{@failed.size} failed>"
+		end
+		
+		def total
+			@passed.size + @failed.size
+		end
+		
+		def print(output, verbose: @verbose)
+			self
+			
+			if verbose && @target
+				@target.print(output)
+				output.write(": ")
+			end
+			
+			if @count.zero?
+				output.write("0 assertions")
+			else
+				if @passed.any?
+					output.write(:passed, @passed.size, " passed", :reset, " ")
+				end
+				
+				if @failed.any?
+					output.write(:failed, @failed.size, " failed", :reset, " ")
+				end
+				
+				output.write("out of ", self.total, " total (", @count, " assertions)")
+			end
+		end
+		
+		def puts(*message)
+			@output.puts(:indent, *message)
+		end
+		
+		def passed?
+			@failed.empty?
+		end
+		
+		def failed?
+			@failed.any?
+		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")
+				end
+			else
+				@failed << self
+				
+				@output.puts(:indent, :failed, fail_prefix, message || "assertion")
+			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)
+			end
+		end
+		
+		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.write(:indent)
+			target.print(output)
+			output.puts
+			
+			assertions = self.class.new(target: target, output: output, inverted: inverted, **options)
+			
+			begin
+				output.indented do
+					result = yield(assertions)
+				end
+			rescue StandardError => error
+				assertions.fail(error)
+			end
+			
+			if assertions
+				if isolated
+					merge(assertions)
+				else
+					add(assertions)
+				end
+			end
+			
+			return result
+		end
+		
+		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
+			else
+				@failed << assertions
+
+				@output.write(:indent, :failed, fail_prefix, :reset)
+				self.print(@output, verbose: false)
+				@output.puts
+			end
+		end
+		
+		def add(assertions)
+			@count += assertions.count
+			@passed.concat(assertions.passed)
+			@failed.concat(assertions.failed)
+			
+			if @verbose
+				self.print(@output, verbose: false)
+				@output.puts
+			end
+		end
+		
+		private
+		
+		def pass_prefix
+			"✓ "
+		end
+		
+		def fail_prefix
+			"✗ "
+		end
+	end
+end

data/lib/sus/base.rb

@@ -0,0 +1,44 @@
+
+require_relative 'context'
+
+module Sus
+	class Base
+		def initialize(assertions)
+			@assertions = assertions
+		end
+		
+		def before
+		end
+		
+		def after
+		end
+		
+		def around
+			self.before
+			
+			return yield
+		ensure
+			self.after
+		end
+		
+		def assert(...)
+			@assertions.assert(...)
+		end
+		
+		def refute(...)
+			@assertions.refute(...)
+		end
+		
+		def expect(subject)
+			Expect.new(subject)
+		end
+	end
+	
+	def self.base(description = "base")
+		base = Class.new(Base)
+		base.extend(Context)
+		base.description = description
+		
+		return base
+	end
+end

data/lib/sus/be.rb

@@ -0,0 +1,62 @@
+
+module Sus
+	class Be
+		def initialize(*arguments)
+			@arguments = arguments
+		end
+		
+		def print(output)
+			output.write("be ", :be, *@arguments.join(" "))
+		end
+		
+		def call(assertions, subject)
+			assertions.nested(self) do |assertions|
+				assertions.assert(subject.public_send(*@arguments), self)
+			end
+		end
+		
+		class << self
+			def == value
+				Be.new(:==, value)
+			end
+			
+			def != value
+				Be.new(:!=, value)
+			end
+			
+			def > value
+				Be.new(:>, value)
+			end
+			
+			def >= value
+				Be.new(:>=, value)
+			end
+			
+			def < value
+				Be.new(:<, value)
+			end
+			
+			def <= value
+				Be.new(:<=, value)
+			end
+			
+			def =~ value
+				Be.new(:=~, value)
+			end
+			
+			def === value
+				Be.new(:===, value)
+			end
+		end
+	end
+	
+	class Base
+		def be(*arguments)
+			if arguments.any?
+				Be.new(*arguments)
+			else
+				Be
+			end
+		end
+	end
+end

data/lib/sus/command/list.rb

@@ -0,0 +1,36 @@
+require 'etc'
+require 'samovar'
+
+module Sus
+	module Command
+		class List < Samovar::Command
+			self.description = "List all available tests."
+			
+			many :paths
+			
+			def prepare(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
+			
+			def call
+				registry = Sus::Registry.new
+				output = Sus::Output.default
+				
+				prepare(registry)
+				
+				registry.each do |child|
+					child.print(output)
+					output.puts
+				end
+			end
+		end
+	end
+end

data/lib/sus/command/run.rb

@@ -0,0 +1,104 @@
+require 'etc'
+require 'samovar'
+
+module Sus
+	module Command
+		class Run < Samovar::Command
+			self.description = "Run one or more tests."
+			
+			options do
+				option '-c/--count <n>', "The number of threads to use for running tests.", type: Integer, default: Etc.nprocessors
+				option '-r/--require <path>', ""
+			end
+			
+			many :paths
+			
+			def prepare(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
+			
+			Result = Struct.new(:job, :assertions)
+			
+			def call
+				registry = Sus::Registry.new
+				jobs = Thread::Queue.new
+				results = Thread::Queue.new
+
+				output = Sus::Output.default
+				guard = Thread::Mutex.new
+				progress = Sus::Progress.new(output)
+				count = @options[:count]
+
+				loader = Thread.new do
+					prepare(registry)
+					
+					registry.each do |child|
+						guard.synchronize{progress.expand}
+						jobs << child
+					end
+					
+					jobs.close
+				end
+
+				aggregation = Thread.new do
+					assertions = Sus::Assertions.new(output: output.buffered)
+					first = true
+					
+					while result = results.pop
+						guard.synchronize{progress.increment}
+						
+						if result.assertions.failed?
+							if first
+								first = false
+							else
+								assertions.output.puts
+							end
+							
+							result.assertions.output.append(assertions.output)
+						end
+						
+						assertions.add(result.assertions)
+						guard.synchronize{progress.report(count, assertions, :busy)}
+					end
+					
+					guard.synchronize{progress.clear}
+					
+					assertions.output.puts unless first
+					assertions.output.append(output)
+					
+					assertions.print(output)
+					output.puts
+				end
+
+				workers = count.times.map do |index|
+					Thread.new do
+						while job = jobs.pop
+							guard.synchronize{progress.report(index, job, :busy)}
+							
+							assertions = Sus::Assertions.new(output: output.buffered)
+							job.call(assertions)
+							results << Result.new(job, assertions)
+							
+							guard.synchronize{progress.report(index, "idle", :free)}
+						end
+					end
+				end
+
+				loader.join
+
+				workers.each(&:join)
+				results.close
+
+				aggregation.join
+			end
+		end
+	end
+end

data/lib/sus/command/sequential.rb

@@ -0,0 +1,35 @@
+require 'etc'
+require 'samovar'
+
+module Sus
+	module Command
+		class Sequential < Samovar::Command
+			self.description = "Run one or more tests."
+			
+			many :paths
+			
+			def prepare(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
+			
+			Result = Struct.new(:job, :assertions)
+			
+			def call
+				registry = Sus::Registry.new
+				output = Sus::Output.default
+
+				prepare(registry)
+
+				registry.call
+			end
+		end
+	end
+end

data/lib/sus/command/top.rb

@@ -0,0 +1,26 @@
+require 'samovar'
+require_relative 'run'
+require_relative 'sequential'
+require_relative 'list'
+
+module Sus
+	module Command
+		class Top < Samovar::Command
+			self.description = "Test your code."
+			
+			nested :command, {
+				'run' => Run,
+				'sequential' => Sequential,
+				'list' => List,
+			}, default: 'run'
+			
+			def call
+				if command = self.command
+					command.call
+				else
+					self.print_usage
+				end
+			end
+		end
+	end
+end

data/lib/sus/context.rb

@@ -0,0 +1,63 @@
+
+require_relative 'assertions'
+require_relative 'identity'
+
+module Sus
+	module Context
+		attr_accessor :identity
+		attr_accessor :description
+		attr_accessor :children
+		
+		def self.extended(base)
+			base.children = Hash.new
+		end
+		
+		def to_s
+			self.description || self.name
+		end
+		
+		def inspect
+			if description = self.description
+				"\#<#{self.name || "Context"} #{self.description}>"
+			else
+				self.name
+			end
+		end
+		
+		def add(child)
+			@children[child.identity] = child
+		end
+		
+		def empty?
+			@children.nil? || @children.empty?
+		end
+		
+		def leaf?
+			false
+		end
+		
+		def print(output)
+			output.write("context ", :context, self.description)
+		end
+		
+		def call(assertions)
+			return if self.empty?
+			
+			assertions.nested(self) do |assertions|
+				self.children.each do |identity, child|
+					child.call(assertions)
+				end
+			end
+		end
+		
+		def each(&block)
+			self.children.each do |identity, child|
+				if child.leaf?
+					yield child
+				else
+					child.each(&block)
+				end
+			end
+		end
+	end
+end