neospec 0.0.1

data/lib/neospec.rb

@@ -0,0 +1,38 @@
+require "neospec/color"
+require "neospec/expector"
+require "neospec/logger/basic"
+require "neospec/logger/symbols"
+require "neospec/report/basic"
+require "neospec/results"
+require "neospec/runner/basic"
+require "neospec/spec"
+require "neospec/spec/result"
+require "neospec/spec/result/failure"
+require "neospec/suite"
+require "neospec/version"
+
+class Neospec
+  attr_accessor :logger, :suites, :reporters
+
+  def initialize(
+    suites: [],
+    logger: Neospec::Logger::Basic.new,
+    reporters: [Neospec::Report::Basic]
+  )
+    @suites = suites
+    @logger = logger
+    @reporters = reporters
+  end
+
+  def run!
+    @suites.each { |suite|
+      suite.run(logger: logger)
+    }
+
+    results = Neospec::Results.new(suites: @suites)
+
+    reporters.each { |reporter| reporter.call(results) }
+
+    exit 1 unless results.successful?
+  end
+end

data/neospec.gemspec

@@ -0,0 +1,30 @@
+require_relative "./lib/neospec/version"
+
+Gem::Specification.new do |gem|
+  gem.name = "neospec"
+  gem.version = Neospec::VERSION
+  gem.summary = "A simple testing library that works on ruby and mruby"
+  gem.description = <<-DESC
+    A simple testing library that works on ruby and mruby.
+
+    This has been designed to be very modular, you can run different types of
+    suites with different setup/teardown and before/after blocks. You can have
+    as many reporters as you want, these can range from "output to the terminal
+    in a nice way" all the way to "shape the results into an XML or JSON for my
+    CI".
+
+    The secondary purpose of this testing library is to work with mruby for my
+    game engine Taylor and any project built upon that.
+
+    I also plan to support quite a few ruby versions as I want the code for
+    this to be very portable. The main feature I don't want to drop is
+    positional AND keyword arguments in definitions, this means anything that
+    matches the Ruby 2.6+ spec should be compatible.
+  DESC
+  gem.authors = ["Sean Earle"]
+  gem.email = ["sean.r.earle@gmail.com"]
+  gem.files = `git ls-files`.split($\)
+  gem.homepage = "https://github.com/HellRok/neospec"
+  gem.license = "MIT"
+  gem.required_ruby_version = ">= 2.6.0"
+end

data/spec/neospec/expector_spec.rb

@@ -0,0 +1,201 @@
+@unit.describe "Neospec::Expector#initialize" do
+  Given "We create a new Neospec::Expector instance" do
+    @result = Neospec::Spec::Result.new
+    @logger = TestLogger.new
+
+    @expect = Neospec::Expector.new(
+      result: @result,
+      actual: "actual",
+      logger: @logger,
+      stack: ["the stack"]
+    )
+  end
+
+  Then "instance variables are set" do
+    expect(@expect.instance_variable_get(:@result)).to_equal(@result)
+    expect(@expect.instance_variable_get(:@actual)).to_equal("actual")
+    expect(@expect.instance_variable_get(:@logger)).to_equal(@logger)
+    expect(@expect.instance_variable_get(:@stack)).to_equal(["the stack"])
+  end
+end
+
+@unit.describe "Neospec::Expector#log" do
+  Given "We create a new Neospec::Expector instance" do
+    @result = Neospec::Spec::Result.new
+    @logger = TestLogger.new
+
+    @expect = Neospec::Expector.new(
+      result: @result,
+      actual: "actual",
+      logger: @logger,
+      stack: ["the stack"]
+    )
+  end
+
+  When "#log is called" do
+    @expect.log("the message", context: :the_context)
+  end
+
+  Then "the message is logged" do
+    expect(@logger.calls.size).to_equal(1)
+    expect(@logger.calls.first).to_equal(
+      {
+        message: "the message",
+        context: :the_context,
+        result: @result
+      }
+    )
+  end
+end
+
+@unit.describe "Neospec::Expector#succeeded" do
+  Given "We create a new Neospec::Expector instance" do
+    @result = Neospec::Spec::Result.new
+    @logger = TestLogger.new
+
+    @expect = Neospec::Expector.new(
+      result: @result,
+      actual: "actual",
+      logger: @logger,
+      stack: ["the stack"]
+    )
+  end
+
+  When "#succeeded is called" do
+    @expect.succeeded("the success message")
+  end
+
+  Then "the expectation is recorded" do
+    expect(@result.expectations).to_equal(1)
+  end
+
+  And "the message is logged" do
+    expect(@logger.calls.size).to_equal(1)
+    expect(@logger.calls.first).to_equal(
+      {
+        message: "the success message",
+        context: :expect,
+        result: @result
+      }
+    )
+  end
+end
+
+@unit.describe "Neospec::Expector#failed" do
+  Given "We create a new Neospec::Expector instance" do
+    @result = Neospec::Spec::Result.new
+    @logger = TestLogger.new
+
+    @expect = Neospec::Expector.new(
+      result: @result,
+      actual: "actual",
+      logger: @logger,
+      stack: ["the stack"]
+    )
+  end
+
+  When "#failed is called" do
+    @expect.failed("the failure message")
+  end
+
+  Then "the failure is recorded" do
+    expect(@result.failures.size).to_equal(1)
+    expect(@result.failures.first.message).to_equal("Expected the failure message")
+    expect(@result.failures.first.stack).to_equal(["the stack"])
+  end
+
+  And "the expectation is recorded" do
+    expect(@result.expectations).to_equal(1)
+  end
+
+  And "the message is logged" do
+    expect(@logger.calls.size).to_equal(1)
+    expect(@logger.calls.first).to_equal(
+      {
+        message: "the failure message",
+        context: :expect,
+        result: @result
+      }
+    )
+  end
+end
+
+@unit.describe "Neospec::Expector expectations" do
+  Given "We create a new Neospec::Expector instance" do
+    @result = Neospec::Spec::Result.new
+    @logger = TestLogger.new
+
+    @expect = Neospec::Expector.new(
+      result: @result,
+      actual: "actual",
+      logger: @logger,
+      stack: ["the stack"]
+    )
+  end
+
+  When "#to_equal is called with success" do
+    @expect.to_equal("actual")
+  end
+
+  Then "it's recorded" do
+    expect(@result.expectations).to_equal(1)
+    expect(@result.failures.size).to_equal(0)
+    expect(@logger.calls.size).to_equal(1)
+    expect(@logger.calls.last[:message]).to_equal("to be equal")
+  end
+
+  When "#to_equal is called with failure" do
+    @expect.to_equal("wrong")
+  end
+
+  Then "it's recorded" do
+    expect(@result.expectations).to_equal(2)
+    expect(@result.failures.size).to_equal(1)
+    expect(@logger.calls.size).to_equal(2)
+    expect(@logger.calls.last[:message]).to_equal("'wrong' to equal 'actual'")
+  end
+
+  When "#not_to_equal is called with success" do
+    @expect.not_to_equal("wrong")
+  end
+
+  Then "it's recorded" do
+    expect(@result.expectations).to_equal(3)
+    expect(@result.failures.size).to_equal(1)
+    expect(@logger.calls.size).to_equal(3)
+    expect(@logger.calls.last[:message]).to_equal("not to be equal")
+  end
+
+  When "#to_equal is called with failure" do
+    @expect.not_to_equal("actual")
+  end
+
+  Then "it's recorded" do
+    expect(@result.expectations).to_equal(4)
+    expect(@result.failures.size).to_equal(2)
+    expect(@logger.calls.size).to_equal(4)
+    expect(@logger.calls.last[:message]).to_equal("'actual' not to equal 'actual'")
+  end
+
+  When "#to_be_a is called with success" do
+    @expect.to_be_a(String)
+  end
+
+  Then "it's recorded" do
+    expect(@result.expectations).to_equal(5)
+    expect(@result.failures.size).to_equal(2)
+    expect(@logger.calls.size).to_equal(5)
+    expect(@logger.calls.last[:message]).to_equal("to be a String")
+  end
+
+  When "#to_be_a is called with failure" do
+    @expect.to_be_a(Array)
+  end
+
+  Then "it's recorded" do
+    expect(@result.expectations).to_equal(6)
+    expect(@result.failures.size).to_equal(3)
+    expect(@logger.calls.size).to_equal(6)
+    expect(@logger.calls.last[:message]).to_equal("'Array' to equal 'String'")
+  end
+end

data/spec/neospec/logger/basic_spec.rb

@@ -0,0 +1,101 @@
+@unit.describe "Neospec::Logger::Basic#initialize" do
+  Given "we create a new Neospec::Suite instance" do
+    @output = TestOutputter.new
+    @logger = Neospec::Logger::Basic.new(output: @output, color: "color")
+  end
+
+  Then "instance variables are set" do
+    expect(@logger.instance_variable_get(:@output)).to_equal(@output)
+    expect(@logger.instance_variable_get(:@color)).to_equal("color")
+  end
+end
+
+@unit.describe "Neospec::Logger::Basic#log" do
+  Given "we create a new Neospec::Suite instance" do
+    @output = TestOutputter.new
+    @logger = Neospec::Logger::Basic.new(output: @output)
+  end
+
+  When "called with a describe context" do
+    @logger.log("describe message", context: :describe)
+  end
+
+  Then "it outputs with no indent" do
+    expect(@output.calls.size).to_equal(1)
+    expect(@output.calls.last).to_equal("#{Neospec::Color::BLUE}describe message#{Neospec::Color::RESET}\n")
+  end
+
+  When "called with a successful expect context" do
+    @logger.log("success message", context: :expect, result: Neospec::Spec::Result.new)
+  end
+
+  Then "it outputs with indent and ✓" do
+    expect(@output.calls.size).to_equal(2)
+    expect(@output.calls.last).to_equal("    #{Neospec::Color::GREEN}✓ expect success message#{Neospec::Color::RESET}\n")
+  end
+
+  When "called with a failed expect context" do
+    failure = Neospec::Spec::Result.new
+    failure.failures << "oops"
+    @logger.log("success message", context: :expect, result: failure)
+  end
+
+  Then "it outputs with indent and ✗" do
+    expect(@output.calls.size).to_equal(3)
+    expect(@output.calls.last).to_equal("    #{Neospec::Color::RED}✗ expect success message#{Neospec::Color::RESET}\n")
+  end
+
+  When "called with any other context" do
+    @logger.log("given message", context: :Given)
+  end
+
+  Then "it outputs with some indent" do
+    expect(@output.calls.size).to_equal(4)
+    expect(@output.calls.last).to_equal("  Given given message\n")
+  end
+end
+
+@unit.describe "Neospec::Logger::Basic#log without color" do
+  Given "we create a new Neospec::Suite instance" do
+    @output = TestOutputter.new
+    @logger = Neospec::Logger::Basic.new(color: false, output: @output)
+  end
+
+  When "called with a describe context" do
+    @logger.log("describe message", context: :describe)
+  end
+
+  Then "it outputs with no indent" do
+    expect(@output.calls.size).to_equal(1)
+    expect(@output.calls.last).to_equal("describe message\n")
+  end
+
+  When "called with a successful expect context" do
+    @logger.log("success message", context: :expect, result: Neospec::Spec::Result.new)
+  end
+
+  Then "it outputs with indent and ✓" do
+    expect(@output.calls.size).to_equal(2)
+    expect(@output.calls.last).to_equal("    ✓ expect success message\n")
+  end
+
+  When "called with a failed expect context" do
+    failure = Neospec::Spec::Result.new
+    failure.failures << "oops"
+    @logger.log("success message", context: :expect, result: failure)
+  end
+
+  Then "it outputs with indent and ✗" do
+    expect(@output.calls.size).to_equal(3)
+    expect(@output.calls.last).to_equal("    ✗ expect success message\n")
+  end
+
+  When "called with any other context" do
+    @logger.log("given message", context: :Given)
+  end
+
+  Then "it outputs with some indent" do
+    expect(@output.calls.size).to_equal(4)
+    expect(@output.calls.last).to_equal("  Given given message\n")
+  end
+end

data/spec/neospec/logger/symbols_spec.rb

@@ -0,0 +1,54 @@
+@unit.describe "Neospec::Logger::Symbols#initialize" do
+  Given "we create a new Neospec::Suite instance" do
+    @output = TestOutputter.new
+    @logger = Neospec::Logger::Symbols.new(output: @output, color: "color")
+  end
+
+  Then "instance variables are set" do
+    expect(@logger.instance_variable_get(:@output)).to_equal(@output)
+    expect(@logger.instance_variable_get(:@color)).to_equal("color")
+  end
+end
+
+@unit.describe "Neospec::Logger::Symbols#log" do
+  Given "we create a new Neospec::Suite instance" do
+    @output = TestOutputter.new
+    @logger = Neospec::Logger::Symbols.new(output: @output)
+  end
+
+  When "called with a describe context" do
+    @logger.log("describe message", context: :describe)
+  end
+
+  Then "it has no output" do
+    expect(@output.calls.size).to_equal(0)
+  end
+
+  When "called with a successful expect context" do
+    @logger.log("success message", context: :expect, result: Neospec::Spec::Result.new)
+  end
+
+  Then "it outputs ✓" do
+    expect(@output.calls.size).to_equal(1)
+    expect(@output.calls.last).to_equal("#{Neospec::Color::GREEN}✓#{Neospec::Color::RESET}")
+  end
+
+  When "called with a failed expect context" do
+    failure = Neospec::Spec::Result.new
+    failure.failures << "oops"
+    @logger.log("success message", context: :expect, result: failure)
+  end
+
+  Then "it outputs ✗" do
+    expect(@output.calls.size).to_equal(2)
+    expect(@output.calls.last).to_equal("#{Neospec::Color::RED}✗#{Neospec::Color::RESET}")
+  end
+
+  When "called with any other context" do
+    @logger.log("given message", context: :Given)
+  end
+
+  Then "it has no output" do
+    expect(@output.calls.size).to_equal(2)
+  end
+end

data/spec/neospec/report/basic_spec.rb

@@ -0,0 +1,115 @@
+@unit.describe "Neospec::Report::Basic.call" do
+  When "we have some results with no failures" do
+    @suite = Neospec::Suite.new
+    @results = Neospec::Results.new(suites: [@suite])
+
+    spec_1 = Neospec::Spec.new(description: "a spec", block: -> {})
+    spec_1.result.expectations = 3
+    spec_1.result.start = 1
+    spec_1.result.finish = 5
+    @suite.specs << spec_1
+
+    spec_2 = Neospec::Spec.new(description: "another spec", block: -> {})
+    spec_2.result.expectations = 4
+    spec_2.result.start = 6
+    spec_2.result.finish = 9.5
+    @suite.specs << spec_2
+  end
+
+  Then "it outputs information" do
+    @output = TestOutputter.new
+    Neospec::Report::Basic.call(@results, output: @output)
+
+    expect(@output.calls.size).to_equal(1)
+    expect(
+      @output.calls.last
+    ).to_equal(<<~STR)
+
+      Finished in 7.5 seconds
+
+      Results:
+        Specs:\t2
+        Expectations:\t7
+    STR
+  end
+
+  When "we have some results with failures" do
+    spec_3 = Neospec::Spec.new(description: "more spec", block: -> {})
+    spec_3.result.expectations = 4
+    spec_3.result.start = 6
+    spec_3.result.finish = 9.5
+    spec_3.result.failures << Neospec::Spec::Result::Failure.new(
+      message: "oops!",
+      stack: ["line 1", "line 2", "line 3", "line 4", "line 5", "line 6"]
+    )
+    @suite.specs << spec_3
+
+    spec_4 = Neospec::Spec.new(description: "even more spec", block: -> {})
+    spec_4.result.expectations = 2
+    spec_4.result.start = 10
+    spec_4.result.finish = 10.25
+    spec_4.result.failures << Neospec::Spec::Result::Failure.new(
+      message: "again, oops!",
+      stack: ["line 7", "line 8", "line 9", "line 10", "line 11", "line 12"]
+    )
+    @suite.specs << spec_4
+  end
+
+  Then "it outputs information" do
+    Neospec::Report::Basic.call(@results, output: @output)
+
+    expect(@output.calls.size).to_equal(2)
+    expect(
+      @output.calls.last
+    ).to_equal(<<~STR)
+
+      Finished in 11.25 seconds
+
+      Results:
+        Specs:\t4
+        Expectations:\t13
+        Failures:\t2
+
+      Failures:
+        #{Neospec::Color::RED}oops!#{Neospec::Color::RESET}
+          > line 1
+          > line 2
+          > line 3
+          > line 4
+          > line 5
+
+        #{Neospec::Color::RED}again, oops!#{Neospec::Color::RESET}
+          > line 7
+          > line 8
+          > line 9
+          > line 10
+          > line 11
+    STR
+  end
+end
+
+@unit.describe "Neospec::Report::Basic.formatted_duration" do
+  Given "some durations" do
+    hour = 60 * 60
+    day = 24 * 60 * 60
+    @milliseconds = 0.0012345
+    @seconds = 10.322
+    @minute = 61.5
+    @minutes = 124
+    @hour = hour + 62
+    @hours = (2 * hour) + 122
+    @day = day + hour + 63
+    @days = (3 * day) + (4 * hour) + 120
+  end
+
+  Then "it nicely formats them" do
+    expect(Neospec::Report::Basic.formatted_duration(@milliseconds)).to_equal("1.23 milliseconds")
+    expect(Neospec::Report::Basic.formatted_duration(@seconds)).to_equal("10.32 seconds")
+    expect(Neospec::Report::Basic.formatted_duration(@minute)).to_equal("1 minute 1 second")
+    expect(Neospec::Report::Basic.formatted_duration(@minutes)).to_equal("2 minutes 4 seconds")
+    expect(Neospec::Report::Basic.formatted_duration(@hour)).to_equal("1 hour 1 minute")
+    expect(Neospec::Report::Basic.formatted_duration(@hours)).to_equal("2 hours 2 minutes")
+    expect(Neospec::Report::Basic.formatted_duration(@day)).to_equal("1 day 1 hour")
+    expect(Neospec::Report::Basic.formatted_duration(@days)).to_equal("3 days 4 hours")
+  end
+end

data/spec/neospec/results_spec.rb

@@ -0,0 +1,151 @@
+@unit.describe "Neospec::Results#initialize" do
+  Given "we create a new Neospec::Results instance" do
+    @results = Neospec::Results.new(suites: "suites")
+  end
+
+  Then "instance variables are set" do
+    expect(@results.suites).to_equal("suites")
+  end
+end
+
+@unit.describe "Neospec::Results#specs" do
+  Given "we create a new Neospec::Results instance" do
+    @suite_1 = Neospec::Suite.new
+    @suite_2 = Neospec::Suite.new
+    @results = Neospec::Results.new(suites: [@suite_1, @suite_2])
+  end
+
+  And "we have defined specs" do
+    @suite_1.describe "a spec" do
+      expect(true).to_equal(true)
+    end
+
+    @suite_2.describe "a spec" do
+      expect(true).to_equal(true)
+    end
+
+    @suite_2.describe "a spec" do
+      expect(true).to_equal(true)
+    end
+  end
+
+  Then "#specs contains all the suites specs" do
+    expect(@results.specs.size).to_equal(3)
+  end
+end
+
+@unit.describe "Neospec::Results#successful?" do
+  Given "we create a new Neospec::Results instance" do
+    @suite = Neospec::Suite.new
+    @results = Neospec::Results.new(suites: [@suite])
+  end
+
+  And "we run a successful build" do
+    @suite.describe "a spec" do
+      expect(true).to_equal(true)
+    end
+    @suite.run(logger: TestLogger.new)
+  end
+
+  Then "it's successful" do
+    expect(@results.successful?).to_equal(true)
+  end
+
+  But "we record an unsuccessful result" do
+    @suite.describe "a failing spec" do
+      expect(true).to_equal(false)
+    end
+    @suite.run(logger: TestLogger.new)
+  end
+
+  Then "it's not successful" do
+    expect(@results.successful?).to_equal(false)
+  end
+end
+
+@unit.describe "Neospec::Results#expectations" do
+  Given "we create a new Neospec::Results instance" do
+    @suite = Neospec::Suite.new
+    @results = Neospec::Results.new(suites: [@suite])
+  end
+
+  Then "it starts at 0" do
+    expect(@results.expectations).to_equal(0)
+  end
+
+  When "we run a build" do
+    @suite.describe "a spec" do
+      expect(true).to_equal(true)
+      expect(true).to_equal(true)
+      expect(true).to_equal(true)
+    end
+
+    @suite.describe "another spec" do
+      expect(true).to_equal(true)
+      expect(true).to_equal(true)
+      expect(true).to_equal(true)
+      expect(true).to_equal(true)
+    end
+
+    @suite.run(logger: TestLogger.new)
+  end
+
+  Then "it sums the expectations" do
+    expect(@results.expectations).to_equal(7)
+  end
+end
+
+@unit.describe "Neospec::Results#duration" do
+  Given "we create a new Neospec::Results instance" do
+    @suite = Neospec::Suite.new
+    @results = Neospec::Results.new(suites: [@suite])
+  end
+
+  Then "it starts at 0" do
+    expect(@results.duration).to_equal(0)
+  end
+
+  When "there are results" do
+    spec_1 = Neospec::Spec.new(description: "a spec", block: -> {})
+    spec_1.result.start = 1
+    spec_1.result.finish = 3
+    @suite.specs << spec_1
+
+    spec_2 = Neospec::Spec.new(description: "another spec", block: -> {})
+    spec_2.result.start = 4
+    spec_2.result.finish = 9.5
+    @suite.specs << spec_2
+  end
+
+  Then "it sums the durations" do
+    expect(@results.duration).to_equal(7.5)
+  end
+end
+
+@unit.describe "Neospec::Results#failures" do
+  Given "we create a new Neospec::Results instance" do
+    @suite = Neospec::Suite.new
+    @results = Neospec::Results.new(suites: [@suite])
+  end
+
+  When "there are failures" do
+    spec_1 = Neospec::Spec.new(description: "a spec", block: -> {})
+    spec_1.result.failures << "failure 1"
+    @suite.specs << spec_1
+
+    spec_2 = Neospec::Spec.new(description: "another spec", block: -> {})
+    spec_2.result.failures << "failure 2"
+    spec_2.result.failures << "failure 3"
+    @suite.specs << spec_2
+  end
+
+  Then "it combines all the failures" do
+    expect(@results.failures).to_equal(
+      [
+        "failure 1",
+        "failure 2",
+        "failure 3"
+      ]
+    )
+  end
+end