Move helper methods and classes to their own directory

spec/helpers/expectations_helper.cr

@@ -0,0 +1,64 @@
+# Utility methods for creating expectations, partials, and matchers.
+
+def new_partial(label : String, actual : T) forall T
+  Spectator::Expectations::ValueExpectationPartial.new(label, actual)
+end
+
+def new_partial(actual : T = 123) forall T
+  new_partial(actual.to_s, actual)
+end
+
+def new_matcher(label : String, expected : T) forall T
+  Spectator::Matchers::EqualityMatcher.new(label, expected)
+end
+
+def new_matcher(expected : T = 123) forall T
+  new_matcher(expected.to_s, expected)
+end
+
+def new_expectation(expected : ExpectedType = 123, actual : ActualType = 123) forall ExpectedType, ActualType
+  partial = new_partial("foo", actual)
+  matcher = new_matcher("bar", expected)
+  Spectator::Expectations::ValueExpectation.new(partial, matcher)
+end
+
+def new_met_expectation(value : T = 123) forall T
+  new_expectation(value, value).tap do |expectation|
+    expectation.satisfied?.should be_true # Sanity check.
+  end
+end
+
+def new_unmet_expectation(expected : ExpectedType = 123, actual : ActualType = 456) forall ExpectedType, ActualType
+  new_expectation(expected, actual).tap do |expectation|
+    expectation.satisfied?.should be_false # Sanity check.
+  end
+end
+
+def new_successful_result
+  new_met_expectation.eval.tap do |result|
+    result.successful?.should be_true # Sanity check.
+  end
+end
+
+def new_failure_result
+  new_unmet_expectation.eval.tap do |result|
+    result.successful?.should be_false # Sanity check.
+  end
+end
+
+def generate_results(success_count = 1, failure_count = 0)
+  successful = Array.new(success_count) { new_successful_result }
+  failures = Array.new(failure_count) { new_failure_result }
+  results = (successful + failures).shuffle
+  reporter = Spectator::Expectations::ExpectationReporter.new(false)
+  results.each do |result|
+    reporter.report(result)
+  end
+  {successful: successful, failures: failures, results: results, reporter: reporter}
+end
+
+def report_results(success_count = 1, failure_count = 0)
+  harness = Spectator::Internals::Harness.current
+  success_count.times { harness.report_expectation(new_successful_result) }
+  failure_count.times { harness.report_expectation(new_failure_result) }
+end

spec/helpers/failing_example.cr

@@ -0,0 +1,22 @@
+# Example that always fails.
+class FailingExample < Spectator::RunnableExample
+  # Dummy description.
+  def what
+    "FAIL"
+  end
+
+  # Run the example that always fails.
+  private def run_instance
+    report_results(0, 1)
+  end
+
+  # Creates a failing example.
+  def self.create
+    hooks = Spectator::ExampleHooks.empty
+    group = Spectator::RootExampleGroup.new(hooks)
+    values = Spectator::Internals::SampleValues.empty
+    new(group, values).tap do |example|
+      group.children = [example.as(Spectator::ExampleComponent)]
+    end
+  end
+end

spec/helpers/spy_example.cr

@@ -0,0 +1,37 @@
+# Example that invokes a closure when it is run.
+# This is useful for capturing what's going on when an event is running.
+class SpyExample < Spectator::RunnableExample
+  # Dummy description.
+  def what
+    "SPY"
+  end
+
+  # Captures the sample values when the example is created.
+  def initialize(group, @sample_values)
+    super(group, @sample_values)
+  end
+
+  # Sample values given to the example.
+  getter sample_values : Spectator::Internals::SampleValues
+
+  setter block : Proc(Nil)? = nil
+
+  # Method called by the framework to run the example code.
+  private def run_instance
+    if block = @block
+      block.call
+    end
+  end
+
+  # Creates a spy example.
+  # The block passed to this method will be executed when the example runs.
+  def self.create(&block)
+    hooks = Spectator::ExampleHooks.empty
+    group = Spectator::RootExampleGroup.new(hooks)
+    values = Spectator::Internals::SampleValues.empty
+    new(group, values).tap do |example|
+      group.children = [example.as(Spectator::ExampleComponent)]
+      example.block = block
+    end
+  end
+end

spec/helpers/spy_sut.cr

@@ -0,0 +1,36 @@
+# Example system to test that doubles as a spy.
+# This class tracks calls made to it.
+class SpySUT
+  # Number of times the `#==` method was called.
+  getter eq_call_count = 0
+
+  # Returns true and increments `#eq_call_count`.
+  def ==(other : T) forall T
+    @eq_call_count += 1
+    true
+  end
+end
+
+# Example that always succeeds.
+class PassingExample < Spectator::RunnableExample
+  # Dummy description.
+  def what
+    "PASS"
+  end
+
+  # Run the example that always passes.
+  # If this doesn't something broke.
+  private def run_instance
+    report_results(1, 0)
+  end
+
+  # Creates a passing example.
+  def self.create
+    hooks = Spectator::ExampleHooks.empty
+    group = Spectator::RootExampleGroup.new(hooks)
+    values = Spectator::Internals::SampleValues.empty
+    new(group, values).tap do |example|
+      group.children = [example.as(Spectator::ExampleComponent)]
+    end
+  end
+end