brut 0.0.1 → 0.0.2

data/lib/brut/instrumentation/logger_span_exporter.rb

@@ -0,0 +1,75 @@
+# Based on OpenTelemetry::SDK::Trace::Export::ConsoleSpanExporter, but designed to 
+# log spans in a more traditional log-style format.
+class Brut::Instrumentation::LoggerSpanExporter
+  def initialize
+    @stopped = false
+    @child_spans = {}
+  end
+
+  NO_PARENT = "0000000000000000"
+
+  def export(spans, timeout: nil)
+    if @stopped
+      SemanticLogger[self.class].warn "Attempt to export spans after exporter was shut down"
+      return failure
+    end
+
+    Array(spans).each do |span|
+      if span.hex_parent_span_id == NO_PARENT
+        log_span(span:,indent: 0)
+      elsif span.attributes["http.user_agent"]
+        log_span(span:,indent: 0, synthetic_attributes: { browser: true })
+      else
+        @child_spans[span.hex_parent_span_id] ||= []
+        @child_spans[span.hex_parent_span_id] << span
+      end
+    end
+
+    success
+  end
+
+  def force_flush(timeout: nil)
+    success
+  end
+
+  def shutdown(timeout: nil)
+    @stopped = true
+    if @child_spans.any?
+      SemanticLogger[self.class].warn "There were #{@child_spans.length} spans un-logged"
+    end
+    success
+  end
+
+private
+
+  def failure = OpenTelemetry::SDK::Trace::Export::FAILURE
+  def success = OpenTelemetry::SDK::Trace::Export::SUCCESS
+
+  def log_span(span:,indent:, synthetic_attributes: {})
+    SemanticLogger.tagged(trace_id: span.hex_trace_id) do
+      message = (" " * indent) + span.name
+      params = {
+        timing: ((span.end_timestamp - span.start_timestamp)/1_000.0).to_i/1_000.0,
+      }.merge(span.attributes).merge(synthetic_attributes)
+
+      SemanticLogger[self.class].info(message, params)
+
+      previous_timestamp = span.start_timestamp
+      (span.events || []).each do |event|
+        event_message = (" " * (indent + 2)) + "event:#{event.name}"
+        event_params = {
+          timing: ((event.timestamp - previous_timestamp)/1_000.0).to_i/1_000.0
+        }.merge(event.attributes).merge(synthetic_attributes)
+        SemanticLogger[self.class].info(event_message,event_params)
+        previous_timestamp = event.timestamp
+      end
+
+      hex_span_id = span.hex_span_id
+      (@child_spans[hex_span_id] || []).each do |child_span|
+        log_span(span: child_span, indent: indent + 4)
+      end
+      @child_spans.delete(hex_span_id)
+    end
+  end
+
+end

data/lib/brut/instrumentation/open_telemetry.rb

@@ -0,0 +1,107 @@
+class Brut::Instrumentation::OpenTelemetry
+  # Create a span around the given block of code.
+  #
+  # @param [String] name the name of the span. Should be specific to the code being wrapped, but not contain dynamic information. For
+  # example, you could call this the method name, but should not include parameters in the name.
+  # @param [Hash<String|Symbol,Object>] attributes Hash of attributes to include in this span. This is as if you called
+  # {Brut::Instrumentation::OpenTelemetry::Span#add_attributes} as the first line of the block.  See that method for more details on
+  # the contents of this hash.
+  #
+  # @yield [Brut::Instrumentation::OpenTelemetry::Span] executes this block in the context of a new OpenTelemetry span. yields
+  #                                                     the span so you can call further methods on it.
+  # @yieldparam span [Brut::Instrumentation::OpenTelemetry::Span]
+  # @yieldreturn [Object] Whatever is returned from the block is returned by this method
+  # @return [Object] Whatever is returned from the block, unless an exception is raised.
+  # @raise [Exception] if the block raises an exception, that exception will be raised, however `record_exception` will be called.
+  #
+  def span(name,**attributes,&block)
+    result = nil
+    Brut.container.tracer.in_span(name) do |span|
+      wrapped_span = Span.new(span)
+      wrapped_span.add_attributes(attributes)
+      begin
+        result = block.(wrapped_span)
+      rescue => ex
+        span.record_exception(ex)
+        raise
+      end
+    end
+    result
+  end
+
+  # Adds an event to the current span
+  # @param [String] name the name of the event. Should not contain dynamic information.
+  # @param [Hash] attributes any attributes to attach to the event.
+  def add_event(name,**attributes)
+    explicit_attributes = attributes.delete(:attributes) || {}
+    timestamp = attributes.delete(:timestamp)
+    current_span = OpenTelemetry::Trace.current_span
+    current_span.add_event(name,
+                           attributes: NormalizedAttributes.new(nil,attributes.merge(explicit_attributes)).to_h,
+                           timestamp:)
+  end
+
+  def record_exception(ex,attributes=nil)
+    current_span = OpenTelemetry::Trace.current_span
+    current_span.record_exception(ex,attributes: NormalizedAttributes.new(nil,attributes).to_h)
+  end
+
+  # Adds attributes to the current span
+  # @param [Hash] attributes any attributes to attach to the event.
+  def add_attributes(attributes)
+    current_span = OpenTelemetry::Trace.current_span
+    current_span.add_attributes(NormalizedAttributes.new(nil,attributes).to_h)
+  end
+
+  class NormalizedAttributes
+    def initialize(prefix,attributes)
+      prefix = if prefix
+                 "#{prefix}."
+               else
+                 ""
+               end
+      @attributes = (attributes || {}).map { |key,value|
+        [ "#{prefix}#{key}", normalize_value(value) ]
+      }.to_h
+    end
+
+    def to_h
+      @attributes
+    end
+
+  private
+
+    def normalize_value(value)
+      case value
+      when String then value
+      when Numeric then value
+      when true then true
+      when false then false
+      when Array then value.map { normalize_value(it) }
+      else
+        value.to_s
+      end
+    end
+  end
+
+  class Span < SimpleDelegator
+
+    # Adds attributes to the span, converting the hash or keyword arguments to strings.
+    #
+    # @param [Hash] attributes a hash of the attributes to add. Keys will be converted to strings via `to_s`.
+    # Values will be converted via {Brut::Instrumentation::OpenTelemetry::NormalizedAttributes}, which preserves strings, numbers, and
+    # booleans, and converts the rest to strings via `to_s`.
+    def add_attributes(attributes)
+      add_prefixed_attributes(nil,attributes)
+    end
+
+    # Adds attributes to the span, prefixing each key with the given prefix, then converting the hash or keyword arguments to strings.
+    #
+    # @see #add_attributes
+    def add_prefixed_attributes(prefix,attributes)
+      __getobj__.add_attributes(
+        NormalizedAttributes.new(prefix,attributes).to_h
+      )
+    end
+  end
+end

data/lib/brut/instrumentation.rb

@@ -1,11 +1,9 @@
 module Brut::Instrumentation
-  autoload(:Basic,"brut/instrumentation/basic")
-  autoload(:Subscriber,"brut/instrumentation/subscriber")
-  autoload(:Event,"brut/instrumentation/event")
-  autoload(:HTTPEvent,"brut/instrumentation/http_event")
+  autoload(:OpenTelemetry,"brut/instrumentation/open_telemetry")
+  autoload(:LoggerSpanExporter,"brut/instrumentation/logger_span_exporter")
 
-  def instrument(**args,&block)
-    Brut.container.instrumentation.instrument(Brut::Instrumentation::Event.new(**args),&block)
+  def span(name,**attributes,&block)
+    Brut.container.instrumentation.span(name,**attributes,&block)
   end
 end
 

data/lib/brut/junk_drawer.rb

@@ -1,31 +1,63 @@
 require "tzinfo"
+# Models a clock, which is a time in the context of a time zone.  This theoretically makes it easier to get the time and date at the time zone of the user.
 class Clock
-  def initialize(tzinfo_timezone)
+  attr_reader :timezone
+  # Create a clock in the given timezone.  If `tzinfo_timezone` is non-`nil`, that value is the time zone of the clock, and all `Time`
+  # instances returned will be in that time zone.  If `tzinfo_timezone` is `nil`, then `ENV["TZ"]` is consulted. If the value of that
+  # environment variable is a valid timezone, it is used. Otherwise, UTC is used.
+  #
+  # @param [TZInfo::Timezone] tzinfo_timezone if present, this is the timezone of the clock.
+  # @param [Time] now if omitted, uses `Time.now` when asked the current time. Otherwises, uses this value, as a `Time` for
+  # now.  Don't do this unless you are testing.
+  def initialize(tzinfo_timezone, now: nil)
     if tzinfo_timezone
       @timezone = tzinfo_timezone
     elsif ENV["TZ"]
       @timezone = begin
                     TZInfo::Timezone.get(ENV["TZ"])
                   rescue TZInfo::InvalidTimezoneIdentifier => ex
-                    SemanticLogger[self.class.name].warn("#{ex} from ENV['TZ'] value '#{ENV['TZ']}'")
+                    Brut.container.instrumentation.record_exception(ex, class: self.class, invalid_env_tz: ENV['TZ'])
                     nil
                   end
     end
     if @timezone.nil?
       @timezone = TZInfo::Timezone.get("UTC")
     end
+    @now = now
   end
 
+  # Get the current time in the configured timezone, unless `now:` was used in the constructor, in which case *that* timestamp is
+  # returned in the configured time zone.
+  #
+  # @return [Time] the time now in the time zone of this clock
   def now
-    Time.now(in: @timezone)
+    if @now
+      self.in_time_zone(@now)
+    else
+      Time.now(in: @timezone)
+    end
   end
 
+  def today
+    self.now.to_date
+  end
+
+  # Convert the given time to this clock's time zone
+  # @param [Time] time a timestamp you wish to conver to this clock's time zone
+  # @return [Time] a new `Time` in the timezone of this clock.
   def in_time_zone(time)
     @timezone.to_local(time)
   end
 end
 
+# A wrapper around a string to avoid adding a ton of methods to `String`.
 class RichString
+  def self.from_string(string,blank_is_nil:true)
+    if string.to_s.strip == "" && blank_is_nil
+      return nil
+    end
+    self.new(string)
+  end
   def initialize(string)
     @string = string.to_s
   end
@@ -41,16 +73,34 @@ class RichString
 
   def camelize
     @string.to_s.split(/[_-]/).map { |part|
-      part.capitalize
+      RichString.new(part).capitalize(:first_only).to_s
     }.join("")
   end
 
+  # Capitalizes the string, with the ability to only capitalize the first letter.
+  #
+  # If `options` includes `:first_only`, then only the first letter of the string is capitalized. The remaining letters are left
+  # alone.  If `option` does not include `:first_only`, this capitalizes like Ruby's standard library, which is to lower case all
+  # letters save for the first.
+  #
+  # @param [Array] options options suitable for Ruby's built-in `String#capitalize` method
+  # @return [RichString] a new string where the wrapped string has been capitalized
+  def capitalize(*options)
+    if options.include?(:first_only)
+      options.delete(:first_only)
+      self.class.new(@string[0].capitalize(*options) + @string[1..-1])
+    else
+      self.class.new(@string.capitalize(*options))
+    end
+  end
+
   def humanized
     RichString.new(@string.tr("_-"," "))
   end
 
   def to_s = @string
   def to_str = self.to_s
+  def length = to_s.length
 
   def to_s_or_nil = @string.empty? ? nil : self.to_s
 

data/lib/brut/sinatra_helpers.rb

@@ -7,6 +7,8 @@ module Brut::SinatraHelpers
     sinatra_app.set :public_folder, Brut.container.public_root_dir
     sinatra_app.path("/__brut/csp-reporting",method: :post)
     sinatra_app.path("/__brut/locale_detection",method: :post)
+    sinatra_app.path("/__brut/instrumentation",method: :get)
+    sinatra_app.set :host_authorization, permitted_hosts: Brut.container.permitted_hosts
   end
 
   # @private
@@ -63,16 +65,19 @@ module Brut::SinatraHelpers
       Brut.container.routing.register_page(path)
 
       get path do
-        Brut.container.instrumentation.instrument(Brut::Instrumentation::HTTPEvent.new(name: :get_page, http_method: "GET", path: path )) do
-          route = Brut.container.routing.for(path: path,method: :get)
-          page_class = route.handler_class
+        route = Brut.container.routing.for(path: path,method: :get)
+        page_class = route.handler_class
+        Brut.container.instrumentation.span(page_class.name, path: path) do |span|
           request_context = Thread.current.thread_variable_get(:request_context)
           constructor_args = request_context.as_constructor_args(
             page_class,
             request_params: params,
+            route: route,
           )
+          span.add_prefixed_attributes("initializer.args", constructor_args.map { |k,v| [k.to_s,v.class.name] }.to_h)
           page_instance = page_class.new(**constructor_args)
           result = page_instance.handle!
+          span.add_attributes(result_class: result.class)
           case result
           in URI => uri
             redirect to(uri.to_s)
@@ -140,41 +145,40 @@ module Brut::SinatraHelpers
       path   = original_brut_route.path_template
 
       route method, path do
-        Brut.container.instrumentation.instrument(Brut::Instrumentation::HTTPEvent.new(name: type, http_method: method, path: path)) do
-          brut_route = Brut.container.routing.for(path:,method:)
-
-          handler_class = brut_route.handler_class
-          form_class    = brut_route.respond_to?(:form_class) ? brut_route.form_class : nil
-
-          request_context = Thread.current.thread_variable_get(:request_context)
-          handler = handler_class.new
-          form = if form_class.nil?
-                   nil
-                 else
-                   form_class.new(params: params)
-                 end
-
-          process_args = request_context.as_method_args(handler,:handle,request_params: params,form: form)
-
-          result = handler.handle!(**process_args)
-
-          case result
-          in URI => uri
-            redirect to(uri.to_s)
-          in Brut::FrontEnd::Component => component_instance
-            render_html(component_instance).to_s
-          in [ Brut::FrontEnd::Component => component_instance, Brut::FrontEnd::HttpStatus => http_status ]
-            [
-              http_status.to_i,
-              render_html(component_instance).to_s,
-            ]
-          in Brut::FrontEnd::HttpStatus => http_status
-            http_status.to_i
-          in Brut::FrontEnd::Download => download
-            [ 200, download.headers, download.data ]
-          else
-            raise NoMatchingPatternError, "Result from #{handler.class}'s handle! method was a #{result.class}, which cannot be used to understand the response to generate"
-          end
+        # This must be re-looked up per-request do allow reloading to work
+        brut_route = Brut.container.routing.for(path:,method:)
+
+        handler_class = brut_route.handler_class
+        form_class    = brut_route.respond_to?(:form_class) ? brut_route.form_class : nil
+
+        request_context = Thread.current.thread_variable_get(:request_context)
+        handler = handler_class.new
+        form = if form_class.nil?
+                 nil
+               else
+                 form_class.new(params: params)
+               end
+
+        process_args = request_context.as_method_args(handler,:handle,request_params: params,form: form,route:brut_route)
+
+        result = handler.handle!(**process_args)
+
+        case result
+        in URI => uri
+          redirect to(uri.to_s)
+        in Brut::FrontEnd::Component => component_instance
+          render_html(component_instance).to_s
+        in [ Brut::FrontEnd::Component => component_instance, Brut::FrontEnd::HttpStatus => http_status ]
+          [
+            http_status.to_i,
+            render_html(component_instance).to_s,
+          ]
+        in Brut::FrontEnd::HttpStatus => http_status
+          http_status.to_i
+        in Brut::FrontEnd::Download => download
+          [ 200, download.headers, download.data ]
+        else
+          raise NoMatchingPatternError, "Result from #{handler.class}'s handle! method was a #{result.class}, which cannot be used to understand the response to generate"
         end
       end
     end

data/lib/brut/spec_support/clock_support.rb

@@ -0,0 +1,6 @@
+module Brut::SpecSupport::ClockSupport
+  def real_clock = Clock.new(TZInfo::Timezone.get("UTC"))
+  def clock_at(now:)
+    Clock.new(TZInfo::Timezone.get("UTC"), now: Time.parse(now))
+  end
+end

data/lib/brut/spec_support/component_support.rb

@@ -1,42 +1,69 @@
 require_relative "flash_support"
+require_relative "session_support"
+require_relative "clock_support"
+require_relative "enhanced_node"
 module Brut::SpecSupport::ComponentSupport
   include Brut::SpecSupport::FlashSupport
+  include Brut::SpecSupport::SessionSupport
+  include Brut::SpecSupport::ClockSupport
   include Brut::I18n::ForHTML
 
-  def render_and_parse(component,&block)
+  # Render a component into its text representation.  This mimics what happens when a component is used
+  # inside a template.  You typically don't want this, but should use {#render_and_parse}, since that will
+  # parse the HTML.
+  def render(component,&block)
     if component.kind_of?(Brut::FrontEnd::Page)
       if !block.nil?
         raise "pages do not accept blocks - do not pass one to render_and_parse"
       end
-      result = component.handle!
-      case result
-      in String => html
-        Nokogiri::HTML5(html)
-      else
-        result
-      end
+      component.handle!
     else
       component.yielded_block = block
-      rendered_text = component.render
-      document = Nokogiri::HTML5(rendered_text)
-      component_html = document.css("body")
-      if component_html
-        non_blank_text_elements = component_html.children.select { |element|
-          if element.kind_of?(Nokogiri::XML::Text) && element.text.to_s.strip == ""
-            false
-          else
-            true
-          end
-        }
-        if non_blank_text_elements.size == 1
-          non_blank_text_elements[0]
-        else
-          raise "#{component.class} rendered #{non_blank_text_elements.size} elements other than blank text:\n\n#{non_blank_text_elements.map(&:name)}. Components should render a single element:\n#{rendered_text}"
-        end
-      else
-        raise "#{component.class} did not render HTML properly: #{rendered_text}"
+      component.render
+    end
+  end
+
+  # Render a component and parse it into a Nokogiri Node for examination.
+  #
+  # @example
+  #
+  #   result = render_and_parse(HeaderComponent.new(title: "Hello!")
+  #   expect(result.e!("h1").text).to eq("Hello!")
+  #
+  # @example Using context
+  #   result = render_and_parse(TableRow.new([ "one", "two" ]), context: "tbody")
+  #
+  # @param [Brut::FrontEnd::Component] component the component instance you wish to render. This should be set up to simulate the test
+  # you are running.
+  # @yield if the component requires or accepts a yielded block, this is how you do that in the test.
+  # @return [Brut::SpecSupport::EnhancedNode] a wrapper around a Nokogiri node to provide convienience methods.
+  def render_and_parse(component,&block)
+    rendered_text = render(component,&block)
+    if !rendered_text.kind_of?(String) && !rendered_text.kind_of?(Brut::FrontEnd::Templates::HTMLSafeString)
+      raise "#{component.class} returned a #{rendered_text.class} - you should not attempt to parse this.  Instead, call render(component)"
+    end
+    nokogiri_node = Nokogiri::HTML5(rendered_text)
+    if !component.kind_of?(Brut::FrontEnd::Page)
+      nokogiri_node = Nokogiri::HTML5.fragment(rendered_text.to_s.chomp, max_errors: 100, context: "template")
+      if nokogiri_node.errors.any?
+        raise "#{component.class} render invalid HTML:\n\n#{rendered_text}\n\nErrors: #{nokogiri_node.errors.join(", ")}"
+      end
+
+      non_blank_text_elements = nokogiri_node.children.select { |element|
+        is_text  = element.kind_of?(Nokogiri::XML::Text)
+        is_blank = element.text.to_s.strip == ""
+
+        is_blank_text = is_text && is_blank
+
+        !is_blank_text
+      }
+
+      if non_blank_text_elements.size != 1
+        raise "#{component.class} rendered #{non_blank_text_elements.size} elements other than blank text:\n\n#{non_blank_text_elements.map(&:name)}. Components should render a single element:\n#{rendered_text}"
       end
+      nokogiri_node = non_blank_text_elements[0]
     end
+    Brut::SpecSupport::EnhancedNode.new(nokogiri_node)
   end
 
   def routing_for(klass,**args)

data/lib/brut/spec_support/e2e_test_server.rb

@@ -0,0 +1,82 @@
+# Manages running the app in test mode for the purposes of running End-to-End tests against it.
+class Brut::SpecSupport::E2ETestServer
+  include SemanticLogger::Loggable
+  def self.instance
+    @instance ||= self.new(bin_dir: Brut.container.project_root / "bin")
+  end
+
+  # Create the test server, which will run various Brut dev commands
+  # from the given bin dir
+  #
+  # @param [Pathname] bin_dir path to where the app's Brut-provide CLI apps are installed
+  def initialize(bin_dir:)
+    @bin_dir = bin_dir
+    @pid     = nil
+  end
+
+  # Starts the server. Returns when the server has started
+  def start
+    if !@pid.nil?
+      logger.warn "Server is already running on pid '#{@pid}'"
+      return
+    end
+    Bundler.with_unbundled_env do
+      command = "#{@bin_dir}/test-server"
+      logger.info "Starting test server via '#{command}'"
+      @pid = Process.spawn(
+        command,
+        pgroup: true # We want this in its own process group, so we can 
+                     # more reliably kill it later on
+      )
+      logger.info "Starting with pid '#{@pid}'"
+    end
+    if is_port_open?("0.0.0.0",6503)
+      logger.info "Server is listening for requests on port 6503"
+    else
+      raise "Problem: server never started"
+    end
+  end
+
+  # Stops the server
+  def stop
+    if @pid.nil?
+      logger.warn "Server is already stopped"
+      return
+    end
+    logger.info "Stopping server nicely with TERM of pid '#{@pid}'"
+    Process.kill("-TERM",@pid) # The '-' is to kill the process group, not just the pid
+    begin
+      Timeout.timeout(4) do
+        Process.wait(@pid)
+      end
+    rescue Timeout::Error
+      logger.warn "Server still active after 4 seconds. Trying KILL on pid '#{@pid}'"
+      Process.kill("-KILL",@pid)
+    end
+    @pid = nil
+  end
+
+private
+
+  def is_port_open?(ip, port)
+    begin
+      Timeout::timeout(5) do
+        loop do
+          begin
+            logger.debug "Attemping to conenct to '#{ip}' on port '#{port}'"
+            s = TCPSocket.new(ip, port)
+            s.close
+            logger.debug "Connection accepted - server should be up!"
+            return true
+          rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+            logger.debug "Connection refused - server must still be starting"
+            sleep(0.1)
+          end
+        end
+      rescue Timeout::Error
+      end
+      false
+    end
+  end
+end
+

data/lib/brut/spec_support/enhanced_node.rb

@@ -0,0 +1,45 @@
+require "delegate"
+
+class Brut::SpecSupport::EnhancedNode < SimpleDelegator
+  include RSpec::Matchers
+
+  # Return the only Nokogiri::XML::Node for the given CSS selector, if it exists.
+  # If the selector matches more than one element, the test fails. If the selector 
+  # matches one element, it is returned, and nil is returned if no elements match.
+  def e(css_selector)
+    element = css(css_selector)
+    if (element.kind_of?(Nokogiri::XML::NodeSet))
+      expect(element.length).to be < 2
+      return Brut::SpecSupport::EnhancedNode.new(element.first)
+    else
+      expect([Nokogiri::XML::Node, Nokogiri::XML::Element]).to include(element.class)
+      return Brut::SpecSupport::EnhancedNode.new(element)
+    end
+  end
+
+  # Assert exactly one Nokogiri::XML::Node exists for the given CSS selector and return it. If there is not
+  # exactly one matching node, the test fails.
+  def e!(css_selector)
+    element = css(css_selector)
+    if (element.kind_of?(Nokogiri::XML::NodeSet))
+      expect(element.length).to eq(1),"#{css_selector} matched #{element.length} elements, not exactly 1:\n\n#{to_html}"
+      return Brut::SpecSupport::EnhancedNode.new(element.first)
+    else
+      expect([Nokogiri::XML::Node, Nokogiri::XML::Element]).to include(element.class)
+      return Brut::SpecSupport::EnhancedNode.new(element)
+    end
+  end
+
+  # Return ths first Nokogiri::XML::Node for the given CSS selector. If there are no
+  # matching nodes, the test fails.
+  def first!(css_selector)
+    element = css(css_selector)
+    if (element.kind_of?(Nokogiri::XML::NodeSet))
+      return Brut::SpecSupport::EnhancedNode.new(element.first)
+    else
+      expect([Nokogiri::XML::Node, Nokogiri::XML::Element]).to include(element.class)
+      return Brut::SpecSupport::EnhancedNode.new(element)
+    end
+  end
+
+end

data/lib/brut/spec_support/general_support.rb

@@ -4,9 +4,20 @@ module Brut::SpecSupport::GeneralSupport
   end
 
   module ClassMethods
-    def implementation_is_trivial
-      it "has no tests because the implementation is trivial" do
-        expect(true).to eq(true)
+    def implementation_is_trivial(check_again_at: nil)
+      check_again_at = if check_again_at.nil?
+                         nil
+                       elsif check_again_at.kind_of?(Time)
+                         check_again_at
+                       else
+                         check_again_at = Date.parse(check_again_at).to_time
+                       end
+      it "has no tests because the implementation is trivial#{check_again_at.nil? ? '' : ' for now'}" do
+        if check_again_at.nil?
+          expect(true).to eq(true)
+        else
+          expect(Time.now < check_again_at).to eq(true),"I'ts after #{check_again_at}. Check that the implementation of the class under test is still trivial. If it is, update or remove check_again_at:"
+        end
       end
     end
     def implementation_is_covered_by_other_tests(description)