scarpe 0.2.1 → 0.3.0

data/scarpe-components/test/test_dimensions.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "scarpe/components/calzini"
+
+class TestDimensions < Minitest::Test
+  def test_no_value_returns_nil
+    assert_nil ::Scarpe::Components::Calzini.dimensions_length(nil)
+  end
+
+  def test_integer_value_returns_px
+    assert_equal "100px", ::Scarpe::Components::Calzini.dimensions_length(100)
+  end
+
+  def test_negative_integer_value_returns_calc
+    assert_equal "calc(100% - 100px)", ::Scarpe::Components::Calzini.dimensions_length(-100)
+  end
+
+  def test_float_value_returns_percent
+    assert_equal "100.0%", ::Scarpe::Components::Calzini.dimensions_length(1.0)
+  end
+
+  def test_otherwise_you_get_what_you_give
+    assert_equal "banana", ::Scarpe::Components::Calzini.dimensions_length("banana")
+  end
+end

data/scarpe-components/test/test_helper.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+# Prevent Calzini or Tiranti from registering itself with Scarpe::Webview, which isn't present here
+ENV["SCARPE_HTML_RENDERER"] = "NONE"
+
+require "shoes"
+
+require "minitest/autorun"
+
+require "minitest/reporters"
+Minitest::Reporters.use! [Minitest::Reporters::SpecReporter.new]
+
+# For tests, default to simple print logger
+# TODO: switch to modular logger and failure-logged tests?
+require "shoes/log"
+require "scarpe/components/print_logger"
+Shoes::Log.instance = Scarpe::Components::PrintLogImpl.new
+Shoes::Log.configure_logger(Shoes::Log::DEFAULT_LOG_CONFIG)
+
+require "scarpe/components/unit_test_helpers"
+
+require "scarpe/components/calzini"
+
+class CalziniRenderer
+  include Scarpe::Components::Calzini
+
+  attr_accessor :html_id
+
+  def initialize
+    @html_id = "elt-1"
+  end
+
+  def handler_js_code(event, *args)
+    js_args = ["'#{event}'", *args].join(", ")
+    "handle(#{js_args})"
+  end
+end
+
+class Minitest::Test
+  include Scarpe::Test::Helpers
+end

data/scarpe-components/test/test_html.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "scarpe/components/html"
+
+class TestHTML < Minitest::Test
+  def test_works_without_content
+    subject = ::Scarpe::Components::HTML.render(&:div)
+
+    assert_equal "<div></div>", subject
+  end
+
+  def test_works_for_pure_tags
+    subject = Scarpe::Components::HTML.render { |h| h.div { "foo" } }
+
+    assert_equal "<div>foo</div>", subject
+  end
+
+  def test_works_for_classes
+    subject = Scarpe::Components::HTML.render { |h| h.div(class: "container") { "foo" } }
+
+    assert_equal '<div class="container">foo</div>', subject
+  end
+
+  def test_works_for_style
+    subject = Scarpe::Components::HTML.render { |h| h.div(style: { display: "block", width: "100px" }) { "foo" } }
+
+    assert_equal '<div style="display:block;width:100px">foo</div>', subject
+  end
+
+  def test_works_for_string_style
+    subject = Scarpe::Components::HTML.render { |h| h.div(style: "display:block;width:100px") { "foo" } }
+
+    assert_equal '<div style="display:block;width:100px">foo</div>', subject
+  end
+
+  def test_no_style_if_style_empty
+    subject = ::Scarpe::Components::HTML.render { |h| h.div(style: {}) { "foo" } }
+
+    assert_equal "<div>foo</div>", subject
+  end
+
+  def test_works_with_multiple_children
+    subject = Scarpe::Components::HTML.render do |h|
+      h.ul do
+        h.li { "one" }
+        h.li { "two" }
+      end
+    end
+
+    assert_equal "<ul><li>one</li><li>two</li></ul>", subject
+  end
+
+  def test_works_with_void_tag
+    subject = Scarpe::Components::HTML.render { |h| h.input(type: "text") }
+
+    assert_equal '<input type="text" />', subject
+  end
+
+  def test_raises_with_void_tag_blocks
+    assert_raises(Shoes::Errors::InvalidAttributeValueError, "void tag input cannot have content") do
+      Scarpe::Components::HTML.render { |h| h.input(type: "text") { "foo" } }
+    end
+  end
+end

data/scarpe-components/test/test_minitest_result.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+require "scarpe/components/minitest_result"
+
+class TestMinitestResult < Minitest::Test
+  def test_mtr_success
+    path = File.join __dir__, "mtr_data/succeed_2_asserts.json"
+    res = Scarpe::Components::MinitestResult.new(path)
+
+    refute res.error?
+    refute res.fail?
+    refute res.skip?
+    assert res.passed?, "Passing result with two assertions should count as passing!"
+    assert_equal 2, res.assertions
+  end
+
+  def test_mtr_failure
+    path = File.join __dir__, "mtr_data/fail_with_message.json"
+    res = Scarpe::Components::MinitestResult.new(path)
+
+    refute res.error?, "Fail-with-message data should not be an error!"
+    assert res.fail?, "Fail-with-message data should be a failure!"
+    refute res.skip?
+    refute res.passed?
+    assert_equal "Fail with message", res.fail_message
+  end
+
+  def test_mtr_error
+    path = File.join __dir__, "mtr_data/exception.json"
+    res = Scarpe::Components::MinitestResult.new(path)
+
+    assert res.error?, "Exception data should show an error!"
+    refute res.fail?, "Exception data should not be an assertion failure!"
+    refute res.skip?
+    refute res.passed?
+    assert res.error_message.include?("This is an exception"), "Error msg data should include the exception message"
+  end
+
+  def test_mtr_skip_no_msg
+    path = File.join __dir__, "mtr_data/skipped_no_message.json"
+    res = Scarpe::Components::MinitestResult.new(path)
+
+    refute res.error?, "Skipped data should not be an error!"
+    refute res.fail?, "Skipped data should not be a failure!"
+    assert res.skip?, "Skipped data should count as skipped"
+    refute res.passed?
+  end
+
+  def test_mtr_skip_w_msg
+    path = File.join __dir__, "mtr_data/skipped_w_msg.json"
+    res = Scarpe::Components::MinitestResult.new(path)
+
+    refute res.error?, "Skipped data should not be an error!"
+    refute res.fail?, "Skipped data should not be a failure!"
+    assert res.skip?, "Skipped data should count as skipped"
+    refute res.passed?
+    assert_equal "Just skipping", res.skip_message
+  end
+end

data/scarpe-components/test/test_promises.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+require "scarpe/components/promises"
+
+class TestPromises < Minitest::Test
+  Promise = Scarpe::Promise
+  PrintLogger = Scarpe::Components::PrintLogImpl::PrintLogger
+
+  def setup
+    # Save so we can restore it post-test
+    @silenced = PrintLogger.silence
+
+    # For these tests, don't log anything
+    PrintLogger.silence = true
+  end
+
+  def teardown
+    # Restore previous log state
+    PrintLogger.silence = @silenced
+  end
+
+  def empty_promise_with_checker(state: nil, parents: [])
+    # Initially, no handlers have been called
+    called = {
+      fulfilled: false,
+      rejected: false,
+      scheduled: false,
+    }
+    p = Promise.new(state: state, parents: parents)
+    p.on_fulfilled { called[:fulfilled] = true }
+    p.on_rejected { called[:rejected] = true }
+    p.on_scheduled { called[:scheduled] = true }
+
+    [p, called]
+  end
+
+  def promise_that_immediately_returns(val, parents: [])
+    Promise.fulfilled(val, parents: parents)
+  end
+
+  def test_simple_promise_fulfillment
+    p, called = empty_promise_with_checker
+
+    p.fulfilled!
+
+    assert_equal true, called[:fulfilled], "Promise fulfilled handler wasn't called successfully on simple fulfillment!"
+    assert_equal false, called[:rejected], "Promise rejection handler was called on simple fulfillment!"
+    assert_equal true, called[:scheduled], "Promise scheduled handler wasn't called on simple fulfillment!"
+  end
+
+  def test_simple_promise_fulfillment_accessor
+    p = Promise.new
+
+    p.fulfilled!
+
+    assert_equal true, p.fulfilled?, "Promise fulfilled? accessor failed!"
+    assert_equal false, p.rejected?, "Promise rejected? accessor failed!"
+  end
+
+  def test_simple_promise_rejection_accessor
+    p = Promise.new
+
+    p.rejected!
+
+    assert_equal false, p.fulfilled?, "Promise fulfilled? accessor failed!"
+    assert_equal true, p.rejected?, "Promise rejected? accessor failed!"
+  end
+
+  def test_simple_promise_rejection
+    p, called = empty_promise_with_checker
+
+    p.rejected!
+
+    assert_equal false, called[:fulfilled], "Promise wasn't called successfully on simple rejection!"
+    assert_equal true, called[:rejected], "Promise rejection handler wasn't called on simple rejection!"
+
+    # Here's a fun thing - the on_scheduled handler *will* be called, but only if there's no incomplete
+    # parent, because effectively the promise will be scheduled during construction.
+    assert_equal true, called[:scheduled], "Promise scheduled handler wasn't called on simple rejection!"
+  end
+
+  def test_dependent_promise_fulfillment
+    parent_promise = Promise.new
+    promise, called = empty_promise_with_checker(parents: [parent_promise])
+
+    # If a promise has an incomplete parent, it will start as unscheduled
+    assert_equal :unscheduled, promise.state
+    assert_equal false, called[:scheduled]
+
+    parent_promise.fulfilled!
+
+    # After the parent is complete, it will be scheduled
+    assert_equal :pending, promise.state
+    assert_equal true, called[:scheduled]
+  end
+
+  def test_dependent_promise_rejection
+    parent_promise = Promise.new
+    promise, called = empty_promise_with_checker(parents: [parent_promise])
+
+    # If a promise has an incomplete parent, it will start as unscheduled
+    assert_equal :unscheduled, promise.state
+    assert_equal false, called[:scheduled]
+
+    parent_promise.rejected!
+
+    # After the parent is rejected, it will be rejected
+    assert_equal :rejected, promise.state
+    assert_equal false, called[:scheduled]
+    assert_equal true, called[:rejected]
+  end
+
+  def test_promise_with_initial_rejected_parent
+    parent1_promise = Promise.new
+    parent2_promise = Promise.rejected
+    promise, called = empty_promise_with_checker(parents: [parent1_promise, parent2_promise])
+
+    assert_equal :rejected, promise.state
+
+    assert_equal false, called[:scheduled]
+    assert_equal false, called[:fulfilled]
+    assert_equal true, called[:rejected]
+  end
+
+  def test_multiparent_fulfillment
+    parent1_promise = Promise.new
+    parent2_promise = Promise.new
+    promise, called = empty_promise_with_checker(parents: [parent1_promise, parent2_promise])
+
+    parent1_promise.fulfilled!
+
+    assert_equal :unscheduled, promise.state
+    assert_equal false, called[:scheduled]
+
+    parent2_promise.fulfilled!
+
+    # After the parents are complete, it will be scheduled
+    assert_equal :pending, promise.state
+    assert_equal true, called[:scheduled]
+  end
+
+  def test_multiparent_rejection
+    parent1_promise = Promise.new
+    parent2_promise = Promise.new
+    promise, called = empty_promise_with_checker(parents: [parent1_promise, parent2_promise])
+
+    parent1_promise.rejected!
+
+    assert_equal :rejected, promise.state
+    assert_equal false, called[:scheduled]
+    assert_equal true, called[:rejected]
+  end
+
+  def test_instant_fulfillment
+    p = promise_that_immediately_returns(7)
+    assert_equal :fulfilled, p.state
+    assert_equal 7, p.returned_value, "The promise should be fulfilled with a value of 7!"
+  end
+
+  def test_multiparent_instant_fulfillment_with_args
+    parents = [
+      promise_that_immediately_returns(7),
+      promise_that_immediately_returns(5),
+      promise_that_immediately_returns(8),
+    ]
+    assert_equal true, parents.all? { |p| p.complete? && p.returned_value.is_a?(Integer) }
+    sum_up_promise = Promise.new(parents: parents)
+    sum_up_promise.to_execute { |*args| args.sum }
+
+    assert_equal :fulfilled, sum_up_promise.state
+    assert_equal 20, sum_up_promise.returned_value
+  end
+
+  def test_multiparent_delayed_fulfillment_with_args
+    parents = [
+      Promise.new,
+      promise_that_immediately_returns(10),
+      Promise.new,
+      Promise.new,
+    ]
+    sum_up_promise = Promise.new(parents: parents)
+    sum_up_promise.to_execute { |*args| args.sum }
+
+    parents[0].fulfilled!(3)
+    parents[2].fulfilled!(8)
+
+    assert_equal false, sum_up_promise.complete?
+
+    parents[3].fulfilled!(9)
+
+    assert_equal :fulfilled, sum_up_promise.state
+    assert_equal 30, sum_up_promise.returned_value
+  end
+
+  def test_simple_executor_success
+    p = Promise.new
+    p.to_execute { 7 }
+
+    assert_equal :fulfilled, p.state
+    assert_equal 7, p.returned_value
+  end
+
+  def test_simple_executor_failure
+    expected_err = RuntimeError.new "Yup, that's an error"
+    p = Promise.new
+    p.to_execute { raise expected_err }
+
+    assert_equal :rejected, p.state
+    assert_equal expected_err, p.reason
+  end
+
+  def test_delayed_executor_success
+    parent = Promise.new
+    p = Promise.new(parents: [parent])
+    p.to_execute { 7 }
+
+    assert_equal :unscheduled, p.state
+
+    parent.fulfilled!
+
+    assert_equal :fulfilled, p.state
+    assert_equal 7, p.returned_value
+  end
+
+  def test_scheduler_raise_error
+    expected_err = StandardError.new "Yup, that's an error"
+    p = Promise.new { raise expected_err }
+
+    assert_equal :rejected, p.state
+    assert_equal expected_err, p.reason, "Promise should record the raised error as the reason for rejection!"
+  end
+
+  def test_explicit_rejected_error
+    expected_err = StandardError.new "Yup, that's an error"
+    p = Promise.new
+
+    p.rejected!(expected_err)
+
+    assert_equal expected_err, p.reason, "Promise should record the raised error as the reason for rejection!"
+  end
+
+  def test_then_with_success
+    called = {
+      p1_scheduled: false,
+      p2_scheduled: false,
+      p3_scheduled: false,
+    }
+    p1 = Promise.new { called[:p1_scheduled] = true }
+    p1.then { called[:p2_scheduled] = true }.then { called[:p3_scheduled] = true }
+
+    assert_equal true, called[:p1_scheduled]
+    assert_equal false, called[:p2_scheduled]
+
+    p1.fulfilled!
+
+    assert_equal true, called[:p2_scheduled]
+    assert_equal false, called[:p3_scheduled]
+  end
+end

data/scarpe-components/test/test_segmented_app_files.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+require "scarpe/components/segmented_file_loader"
+
+SEG_TEST_DATA = {}
+
+class TestSegmentedAppFiles < Minitest::Test
+  def setup
+    @orig_file_loaders = Shoes.file_loaders
+    Shoes.reset_file_loaders # create new loaders array with no overlap with @orig_file_loaders
+    SEG_TEST_DATA.clear
+
+    @loader = Scarpe::Components::SegmentedFileLoader.new
+    Shoes.add_file_loader @loader
+  end
+
+  def teardown
+    Shoes.set_file_loaders(@orig_file_loaders)
+  end
+
+  def test_add_segment_type
+    @loader.add_segment_type("new_seg_type", proc { true })
+  end
+
+  def test_default_single_segment_with_front_matter
+    app = <<~SEG_TEST_FILE
+      ---
+      front_matter: yes
+      ----- app code
+      SEG_TEST_DATA[:app_ran] = true
+    SEG_TEST_FILE
+    with_tempfile(["segfile_test_app", ".scas"], app) do |app_file|
+      Shoes.run_app(app_file)
+    end
+
+    assert_equal({ app_ran: true }, SEG_TEST_DATA)
+  end
+
+  def test_default_single_segment_no_front_matter_with_initial_name
+    app = <<~SEG_TEST_FILE
+      ----- app code
+      SEG_TEST_DATA[:app_ran] = true
+    SEG_TEST_FILE
+    with_tempfile(["segfile_test_app", ".scas"], app) do |app_file|
+      Shoes.run_app(app_file)
+    end
+
+    assert_equal({ app_ran: true }, SEG_TEST_DATA)
+  end
+
+  def test_default_single_segment_no_front_matter_no_initial_name
+    app = <<~SEG_TEST_FILE
+      SEG_TEST_DATA[:app_ran] = true
+    SEG_TEST_FILE
+    with_tempfile(["segfile_test_app", ".scas"], app) do |app_file|
+      Shoes.run_app(app_file)
+    end
+
+    assert_equal({ app_ran: true }, SEG_TEST_DATA)
+  end
+
+  # TODO: this test is partially updated to ShoesSpec rather
+  # than CatsCradle, but we could use a proper version.
+  def test_default_double_segment_with_front_matter
+    app = <<~SEG_TEST_FILE
+      ---
+      front_matter: yes
+      ----- app code
+      SEG_TEST_DATA[:app_ran] = true
+      eval File.read(ENV['SHOES_SPEC_TEST']) # run test code
+      ----- test code
+      SEG_TEST_DATA[:test_ran] = true
+    SEG_TEST_FILE
+    with_tempfile(["segfile_test_app", ".scas"], app) do |app_file|
+      Shoes.run_app(app_file)
+    end
+
+    assert_equal({ app_ran: true, test_ran: true }, SEG_TEST_DATA)
+  end
+
+  def test_empty_front_matter
+    app = <<~SEG_TEST_FILE
+      ---
+      ----- app code
+      SEG_TEST_DATA[:app_ran] = true
+      eval File.read(ENV['SHOES_SPEC_TEST']) # run test code
+      ----- test code
+      SEG_TEST_DATA[:test_ran] = true
+    SEG_TEST_FILE
+    with_tempfile(["segfile_test_app", ".scas"], app) do |app_file|
+      Shoes.run_app(app_file)
+    end
+
+    assert_equal({ app_ran: true, test_ran: true }, SEG_TEST_DATA)
+  end
+
+  def test_default_double_segment_no_front_matter_with_initial_name
+    app = <<~SEG_TEST_FILE
+      ----- app code
+      SEG_TEST_DATA[:app_ran] = true
+      eval File.read(ENV['SHOES_SPEC_TEST']) # run test code
+      ----- test code
+      SEG_TEST_DATA[:test_ran] = true
+    SEG_TEST_FILE
+    with_tempfile(["segfile_test_app", ".scas"], app) do |app_file|
+      Shoes.run_app(app_file)
+    end
+
+    assert_equal({ app_ran: true, test_ran: true }, SEG_TEST_DATA)
+  end
+
+  def test_unnamed_double_segments
+    app = <<~SEG_TEST_FILE
+      -----
+      SEG_TEST_DATA[:app_ran] = true
+      eval File.read(ENV['SHOES_SPEC_TEST']) # run test code
+      -----
+      SEG_TEST_DATA[:test_ran] = true
+    SEG_TEST_FILE
+    with_tempfile(["segfile_test_app", ".scas"], app) do |app_file|
+      Shoes.run_app(app_file)
+    end
+
+    assert_equal({ app_ran: true, test_ran: true }, SEG_TEST_DATA)
+  end
+
+  def test_default_double_segment_no_front_matter_no_initial_name
+    app = <<~SEG_TEST_FILE
+      SEG_TEST_DATA[:app_ran] = true
+      eval File.read(ENV['SHOES_SPEC_TEST']) # run test code
+      ----- test code
+      SEG_TEST_DATA[:test_ran] = true
+    SEG_TEST_FILE
+    with_tempfile(["segfile_test_app", ".scas"], app) do |app_file|
+      Shoes.run_app(app_file)
+    end
+
+    assert_equal({ app_ran: true, test_ran: true }, SEG_TEST_DATA)
+  end
+
+  def test_extra_dashes_in_dividers
+    app = <<~SEG_TEST_FILE
+      ---
+        front_matter: yes
+      ---------------- app code
+      SEG_TEST_DATA[:app_ran] = true
+      eval File.read(ENV['SHOES_SPEC_TEST']) # run test code
+      ------- test code
+      SEG_TEST_DATA[:test_ran] = true
+    SEG_TEST_FILE
+    with_tempfile(["segfile_test_app", ".scas"], app) do |app_file|
+      Shoes.run_app(app_file)
+    end
+
+    assert_equal({ app_ran: true, test_ran: true }, SEG_TEST_DATA)
+  end
+
+  def test_custom_segment_types
+    # "shoes" type already exists and evaluates the code, don't need to add it
+    @loader.add_segment_type("capybara", proc { |path| load path })
+    @loader.add_segment_type("extra_data", proc { |path| load path })
+
+    app = <<~SEG_TEST_FILE
+      ---
+      :segments:
+      - shoes
+      - capybara
+      - extra_data
+      -----
+      SEG_TEST_DATA[:shoes_ran] = true
+      -----
+      SEG_TEST_DATA[:capy_ran] = true
+      -----
+      SEG_TEST_DATA[:extra_data_ran] = true
+    SEG_TEST_FILE
+    with_tempfile(["segfile_test_app", ".scas"], app) do |app_file|
+      Shoes.run_app(app_file)
+    end
+
+    assert_equal({ shoes_ran: true, capy_ran: true, extra_data_ran: true }, SEG_TEST_DATA)
+  end
+end