cake-tester 0.2.0

data/lib/test_neutral.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'test_result'
+
+class TestNeutral < TestResult
+
+  def initialize(title, message = nil)
+    super(title)
+    @message = message
+  end
+
+  def report(spacer_count = 0)
+    super
+    if @message.nil?
+      Printer.neutral("#{@spacer}(-) #{@title}")
+    else
+      Printer.neutral("#{@spacer}    #{@title}: #{@message}")
+    end
+  end
+
+  def neutrals
+    1
+  end
+end
+
+class AssertNeutral < AssertResult
+  def report(spacer_count)
+    super
+    Printer.neutral(@spacer + format_message)
+  end
+end

data/lib/test_options.rb

@@ -0,0 +1,25 @@
+# TestOptions
+#
+# @param fail_on_first_expect, default value will be set to true
+#
+class TestOptions
+  def fail_on_first_expect
+    return true if @fail_on_first_expect.nil?
+
+    @fail_on_first_expect
+  end
+
+  # @param fail_on_first_expect [Boolean]
+  def initialize(fail_on_first_expect: nil)
+    @fail_on_first_expect = fail_on_first_expect
+  end
+
+  # Maps options from parent onto this instance. If childy already has a setting,
+  # it will not be overwritten.
+  # @param parent [TestOptions]
+  def map_from_parent(parent)
+    return if parent.nil?
+
+    @fail_on_first_expect = @fail_on_first_expect.nil? ? parent.fail_on_first_expect : @fail_on_first_expect
+  end
+end

data/lib/test_pass.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'test_result'
+
+# A successful test result
+class TestPass < TestResult
+  def report(spacer_count = 0)
+    super
+
+    Printer.pass("#{@spacer}(O) #{@title}")
+  end
+
+  def successes
+    1
+  end
+end
+
+# A successful assertion result
+class AssertPass < AssertResult
+  def initialize
+    super(nil)
+  end
+end

data/lib/test_result.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+# Contains the base class for all test and assertion results
+module Result
+  def successes
+    0
+  end
+
+  def failures
+    0
+  end
+
+  def neutrals
+    0
+  end
+
+  private
+
+  def generate_spacer(spacer_count)
+    @spacer = ''
+    return if spacer_count.zero?
+
+    (0..(spacer_count - 1)).each do |i|
+      @spacer += if i < (spacer_count - 1)
+                   '   '
+                 else
+                   ' `-'
+                 end
+    end
+  end
+end
+
+# @abstract Contains the base class for all test results
+class TestResult
+  include Result
+
+  def initialize(title)
+    @title = title
+  end
+
+  def report(spacer_count = 0)
+    generate_spacer(spacer_count)
+  end
+end
+
+# @abstract Contains the base class for all assertion results
+class AssertResult
+  include Result
+  attr_writer :index
+
+  def initialize(message, index)
+    @message = message
+    @index = index
+  end
+
+  def report(spacer_count = 0)
+    generate_spacer(spacer_count)
+  end
+
+  private
+
+  def format_message
+    # Asserts will always be indented, thus the 4 spaces
+    if @index.nil?
+      "    #{@message}"
+    else
+      "    [##{@index}] #{@message}"
+    end
+  end
+end

data/test/test_basic.cake.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative '../lib/cake'
+
+TestRunner.new('Test Runner - Basic', [
+  Group.new('Group Basic', [
+    Test.new(
+      'True should be true',
+      assertions: proc { [Expect::IsTrue.new(true)] }
+    )
+  ])
+])

data/test/test_context.cake.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative '../lib/cake'
+
+teardown_counter = 0
+
+TestRunner.new('Test Runner - Context', [
+  Test.new(
+    'Action should set "actual"',
+    action: ->(_test) { true },
+    assertions: ->(test) { [Expect::IsTrue.new(test.actual)] }
+  ),
+  Test.new(
+    'Action can set "actual" and "expected"',
+    action: ->(test) {
+              value = 'foo'
+              test.actual = value
+              test.expected = value
+            },
+    assertions: ->(test) { [Expect::Equals.new(actual: test.actual, expected: test.expected)] }
+  ),
+  Test.new(
+    'Other variables can be declared in context',
+    action: ->(test) {
+      test.foo = 'bar'
+    },
+    assertions: ->(test) {
+      [Expect::Equals.new(
+        actual: test.foo,
+        expected: 'bar'
+      )]
+    }
+  ),
+  Test.new(
+    'Siblings should not affect each other',
+    assertions: ->(test) {
+      [Expect::IsNil.new(test.foo)]
+    }
+  ),
+  Test.new(
+    'Values can be set in setup',
+    setup: ->(test) {
+      test.actual = true
+      test.expected = true
+      test.foo = 'bar'
+    },
+    assertions:
+      ->(test) {
+        [
+          Expect::Equals.new(actual: test.foo, expected: 'bar'),
+          Expect::Equals.new(actual: test.actual, expected: test.expected)
+        ]
+      }
+  ),
+  Test.new(
+    'Values can be modified in teardown',
+    setup: ->(_test) {
+      teardown_counter += 1
+    },
+    assertions: ->(_test) {
+                  [
+                      Expect::IsTrue.new(teardown_counter.positive?)
+                    ]
+                },
+    teardown: ->(_test) {
+      teardown_counter = 0
+    }
+  ),
+  Test.new(
+    'Teardown reset value',
+    assertions: ->(_test) {
+                  [
+                      Expect::IsTrue.new(teardown_counter.zero?)
+                    ]
+                }
+  ),
+  Group.new('Groups can assign context', [
+    Test.new(
+      'Group can pass context to children',
+      assertions: ->(test) { [Expect::Equals.new(actual: test.foo, expected: 'bar')] }
+    ),
+    Test.new(
+      'Children can override parent context',
+      action: ->(test) { test.foo = 'baz' },
+      assertions: ->(test) { [Expect::Equals.new(actual: test.foo, expected: 'baz')] }
+    )
+  ], setup: ->(test) {
+    test.foo = 'bar'
+  }),
+  Group.new('Groups can modify values in teardown after children have run', [
+    Test.new(
+      'Teardown counter should be 1',
+      assertions: proc { [Expect::Equals.new(actual: teardown_counter, expected: 1)] }
+    )
+  ],
+  setup: proc { teardown_counter += 1 },
+  teardown: proc { teardown_counter = 0 }),
+  Test.new(
+    'Teardown reset value',
+    assertions: proc { [Expect::Equals.new(actual: teardown_counter, expected: 0)] }
+  )
+])

data/test/test_expects.cake.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative '../lib/cake'
+
+TestRunner.new('Simple Test with no groups', [
+  Test.new(
+    'True is true - assertion',
+    assertions: proc {
+                  [Expect::IsTrue.new(true)]
+                }
+  ),
+  Test.new(
+    'Equals, true is equal to true',
+    assertions: proc {
+                  [Expect::Equals.new(actual: true, expected: true)]
+                }
+  ),
+  Test.new(
+    'IsNotEqual, true is not equal to false',
+    assertions: proc {
+                  [Expect::IsNotEqual.new(actual: true, not_expected: false)]
+                }
+  ),
+  Test.new(
+    'IsNil, nil is nil',
+    assertions: proc {
+                  [Expect::IsNil.new(nil)]
+                }
+  ),
+  Test.new(
+    'IsNotNil, true is not nil',
+    assertions: proc {
+                  [Expect::IsNotNil.new(true)]
+                }
+  ),
+  Test.new('RespondTo, true responds to is_a?',
+    assertions: proc {
+                  [Expect::RespondTo.new(true, :is_a?)]
+                }),
+  Test.new('Undefined, true does not respond to foo',
+    assertions: proc {
+                  [Expect::Undefined.new(true, :foo)]
+                }),
+  Test.new('DoesNotRepondTo, is a synonym for Undefined',
+    assertions: proc {
+                  [Expect::DoesNotRespondTo.new(true, :foo)]
+                })
+])

data/test/test_failures.cake.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative '../lib/cake'
+
+TestRunner.new('All of these should fail in various ways', [
+  Test.new('Should report multiple failures',
+    assertions: proc {
+      [
+        Expect::Equals.new(actual: true, expected: false),
+        # This line is meant to pass
+        Expect::IsTrue.new(true),
+        Expect::IsFalse.new(true),
+        Expect::IsTrue.new(false)
+      ]
+    },
+    options: TestOptions.new(fail_on_first_expect: false)),
+  Test.new('Should report only one failure by default',
+    assertions: proc {
+      [
+        Expect::Equals.new(actual: true, expected: false),
+        # This line is meant to pass
+        Expect::IsTrue.new(true),
+        # This is a failure, but shouldn't be run
+        Expect::IsFalse.new(true),
+        # This is also a failure, and shouldn't be run
+        Expect::IsTrue.new(false)
+      ]
+    }),
+  Test.new('Should report only one failure if fail_on_first_expect is true',
+    assertions: proc {
+      [
+        Expect::Equals.new(actual: true, expected: false),
+        # This line is meant to pass
+        Expect::IsTrue.new(true),
+        # This is a failure, but shouldn't be run
+        Expect::IsFalse.new(true),
+        # This is also a failure, and shouldn't be run
+        Expect::IsTrue.new(false)
+      ]
+    },
+    options: TestOptions.new(fail_on_first_expect: true)),
+  Group.new('Groups should report as failed when at least one test has failed', [
+    Test.new('This test should fail', assertions: proc { [Expect::IsTrue.new(false)] }),
+    Test.new('This test should pass', assertions: proc { [Expect::IsTrue.new(true)] })
+  ])
+])

data/test/test_group.cake.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative '../lib/cake'
+
+TestRunner.new('Test Groups', [
+  Group.new('Should run all children tests', [
+    Test.new(
+      'True should be true',
+      assertions: proc { [Expect::IsTrue.new(true)] }
+    ),
+    Test.new('False should be false',
+      assertions: proc { [Expect::IsFalse.new(false)] })
+  ]),
+  Group.new('Nested Group - Parent', [
+    Group.new('Nested Group - Child', [
+      Test.new('Nested test should pass',
+        assertions: proc { [Expect::IsTrue.new(true)] })
+    ])
+  ])
+])

data/test/test_runner.cake.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative '../lib/cake'
+
+TestRunner.new('Test Runner Cake Test', [
+  Group.new('Runs a group', [
+    Test.new(
+      'Test in group runs',
+      assertions: proc { [Expect::IsTrue.new(true)] }
+    )
+  ]),
+  Group.new('Runs a nested group, parent', [
+    Group.new('Runs a nested group, child', [
+      Test.new('Test in a nested group runs',
+        assertions: proc { [Expect::IsTrue.new(true)] })
+    ])
+  ]),
+  Test.new('Individual test runs',
+    assertions: proc { [Expect::IsTrue.new(true)] })
+])

data/test/test_skip.cake.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../lib/cake'
+
+TestRunner.new('Test Runner can skip', skip: true)
+TestRunner.new(
+  'Test Runner with children can skip', [
+    Group.new('This group should be skipped', [
+      Test.new('This test should be skipped', assertions: proc {
+        [Expect::IsTrue.new(true)]
+      })
+    ]),
+    Test.new('This test should be skipped', assertions: proc {
+      [Expect::IsTrue.new(true)]
+    })
+  ],
+  skip: true
+)
+
+TestRunner.new('Test Runner - Children marked skipped should skip', [
+  Group.new('Group - Group marked as skip should be skipped', [
+    Test.new('Children of skipped group should also be skipped', assertions: proc {
+      [Expect::IsTrue.new(true)]
+    })
+  ], skip: true),
+  Group.new('Group - Siblings not marked as skipped should not be skipped', [
+    Test.new('This test should not be skipped', assertions: proc {
+      [Expect::IsTrue.new(true)]
+    })
+  ]),
+  Test.new('Test - Tests marked as skip should be skipped', assertions: proc {
+    [Expect::IsTrue.new(true)]
+  }, skip: true),
+  Test.new('Test - Siblings of skipped test should not be skipped', assertions: proc {
+    [Expect::IsTrue.new(true)]
+  })
+])

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: cake-tester
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Polyhedra
+- C. Lee Spruit
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-12-11 00:00:00.000000000 Z
+dependencies: []
+description: ''
+email:
+executables:
+- cake
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".solargraph.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/cake
+- bin/collector.rb
+- bin/runner.rb
+- bin/settings.rb
+- cake-tester.gemspec
+- lib/cake.rb
+- lib/contextual/child.rb
+- lib/contextual/context.rb
+- lib/contextual/group.rb
+- lib/contextual/node.rb
+- lib/contextual/parent.rb
+- lib/contextual/test.rb
+- lib/contextual/test_runner.rb
+- lib/expect.rb
+- lib/helpers/filter_settings.rb
+- lib/helpers/printer.rb
+- lib/test_failure.rb
+- lib/test_message.rb
+- lib/test_neutral.rb
+- lib/test_options.rb
+- lib/test_pass.rb
+- lib/test_result.rb
+- test/test_basic.cake.rb
+- test/test_context.cake.rb
+- test/test_expects.cake.rb
+- test/test_failures.cake.rb
+- test/test_group.cake.rb
+- test/test_runner.cake.rb
+- test/test_skip.cake.rb
+homepage: https://github.com/Polyhedra-Studio/Cake-Ruby
+licenses:
+- MPL-2.0
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: The lightweight, explicit testing framework for Ruby.
+test_files: []