booth 0.0.1 → 0.0.2

data/lib/booth/syntaxes/username.rb

@@ -1,15 +1,18 @@
+# frozen_string_literal: true
+
 module Booth
   module Syntaxes
     class Username
+      include Calls
       include ::Booth::Logging
-      include ::Booth::MethodObject
 
       param :input
 
       def call
-        # debug { "Checking username #{input.inspect} for valid syntax..." }
+        # log { "Checking username #{input.inspect} for valid syntax..." }
         check_blank.on_success { check_too_short }
                    .on_success { check_too_long }
+                   .on_success { check_starts_with_letter }
                    .on_success { check_characters }
       end
 
@@ -18,7 +21,7 @@ module Booth
       def check_blank
         return Tron.success :username_present if input.present?
 
-        debug { 'This username is blank.' }
+        log { 'This username is blank.' }
         Tron.failure :blank_username,
                      normalized_username: nil,
                      normalized_invalid_username: normalized_username,
@@ -28,7 +31,7 @@ module Booth
       def check_too_short
         return Tron.success :username_not_too_short if input.to_s.length >= min_length
 
-        debug { "This username is less than #{min_length} characters long." }
+        log { "This username is less than #{min_length} characters long." }
         Tron.failure :username_is_too_short,
                      normalized_username: nil,
                      normalized_invalid_username: normalized_username,
@@ -38,22 +41,32 @@ module Booth
       def check_too_long
         return Tron.success :username_not_too_long if input.to_s.length <= max_length
 
-        debug { "This username is more than #{max_length} characters long." }
+        log { "This username is more than #{max_length} characters long." }
         Tron.failure :username_is_too_long,
                      normalized_username: nil,
                      normalized_invalid_username: normalized_username,
                      public_message: I18n.t('booth.username_too_long', maximum: max_length)
       end
 
+      def check_starts_with_letter
+        return Tron.success :starts_with_letter if input.to_s.match?(/\A[a-zA-Z].*/)
+
+        log { 'This username does not start with a letter.' }
+        Tron.failure :username_must_start_with_letter,
+                     normalized_username: nil,
+                     normalized_invalid_username: normalized_username,
+                     public_message: I18n.t('booth.username_must_start_with_letter')
+      end
+
       def check_characters
         if input.to_s.length == normalized_username.length
-          debug { 'This username has the correct syntax' }
+          log { 'This username has the correct syntax' }
           return Tron.success :valid_username_syntax,
                               normalized_username:,
                               normalized_invalid_username: normalized_username
         end
 
-        debug { 'This username contains invalid characters' }
+        log { 'This username contains invalid characters' }
         Tron.failure :invalid_username_format,
                      normalized_username: nil,
                      normalized_invalid_username: normalized_username,
@@ -70,15 +83,15 @@ module Booth
       end
 
       def allowed_characters
-        ::Regexp.escape 'abcdefghijklmnopqrstuvwxyz0123456789@ßöäü_+-,.!?#$%'
+        ::Regexp.escape 'abcdefghijklmnopqrstuvwxyz0123456789'
       end
 
       def min_length
-        3
+        3 # Like Github
       end
 
       def max_length
-        50
+        39 # Like Github
       end
     end
   end

data/lib/booth/syntaxes/uuid.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Booth
   module Syntaxes
     class Uuid
       include ::Booth::Logging
-      include ::Booth::MethodObject
+      include Calls
 
       param :input
       option :raise_if_invalid, default: -> { true }

data/lib/booth/test.rb

@@ -1,6 +1,10 @@
-# Just in case
+# frozen_string_literal: true
+
+# Just in case a developer using Booth makes a mistake.
 raise 'Requiring `booth/test` is only intended for testing your code' unless Rails.env.test?
 
+# raise "Only require 'booth/test' when running incorporation test" if ENV['BOOTH_SKIP_INCORPORATION']
+
 def try_to_load_gem(gem_name, require_name = nil)
   require_name = gem_name if require_name.nil?
   require require_name
@@ -9,45 +13,46 @@ rescue LoadError => e
 end
 
 # Gems
+try_to_load_gem 'capybara', 'capybara/dsl'
 try_to_load_gem 'capybara-lockstep'
-try_to_load_gem 'rack_session_access'
+try_to_load_gem 'rack_session_access', 'rack_session_access/capybara'
 try_to_load_gem 'selenium-devtools', 'selenium/devtools'
 try_to_load_gem 'selenium-webdriver'
-require 'rack_session_access/capybara'
+try_to_load_gem 'minitest'
+
+require 'active_support/testing/time_helpers'
 
-# Internal Helpers
-require_relative 'test/helpers'
-require_relative 'test/support/force_login'
+# Support
+# require_relative 'test/support/virtual_authenticators/manager'
+# require_relative 'test/support/virtual_authenticators/create'
+
+# # Internal Helpers
+require_relative 'testing/shortcuts'
+# # require_relative 'test/support/force_login'
+require_relative 'testing/incorporation_test_case'
 
 # Tests
-require_relative 'test/userland/logins/missing_authenticators'
-require_relative 'test/userland/logins/missing_onboarding'
-require_relative 'test/userland/logins/username_and_password'
-require_relative 'test/userland/logins/username_and_webauth'
-require_relative 'test/userland/logins/username_password_and_otp'
-require_relative 'test/userland/logins/username_password_and_webauth'
-require_relative 'test/userland/onboardings/already_logged_in'
-require_relative 'test/userland/onboardings/otp'
-require_relative 'test/userland/onboardings/password'
-require_relative 'test/userland/onboardings/timeout'
-require_relative 'test/userland/otps/manage'
-require_relative 'test/userland/password_resets/reset'
 
 # Public API
-require_relative 'test/userland'
+require_relative 'testing/userland'
 
 module Booth
   module Test
-    def self.middleware
-      ::RackSessionAccess::Middleware
+    module Userland
+      def self.scenarios(...)
+        Booth::Testing::Userland.scenarios(...)
+      end
     end
 
     def self.force_login(...)
-      ::Booth::Test::Support::ForceLogin.call(...)
+      ::Booth::Testing::Support::ForceLogin.call(...)
     end
   end
 end
 
 Capybara.configure do |config|
   config.test_id = 'data-booth' # How Booth interacts with your HTML elements.
+  config.default_max_wait_time = 20 if ENV['CHROME'] # For manual debugging
 end
+
+Rails.application.config.middleware.use RackSessionAccess::Middleware

data/lib/booth/testing/incorporation_test_case.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Booth
+  module Testing
+    class IncorporationTestCase
+      include ::Calls
+      include ::Capybara::DSL
+      include ::Minitest::Assertions
+      include ::ActiveSupport::Testing::TimeHelpers
+      include ::Booth::Testing::Shortcuts
+
+      option :host, default: -> { 'localhost' }
+      option :scope
+      option :routing_namespace
+      option :before_test, default: -> {}
+      option :after_credential, default: -> { ->(credential_id:) {} }
+
+      private
+
+      def virtual_authenticators
+        @virtual_authenticators ||= ::Booth::Testing::Support::VirtualAuthenticators::Manager.new
+      end
+
+      # So that `Minitest::Assertions` can be included
+      def assertions = 0
+      attr_writer :assertions
+    end
+  end
+end

data/lib/booth/testing/shortcuts.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Booth
+  module Testing
+    # Shortcuts and Assertions for System tests.
+    module Shortcuts
+      extend ActiveSupport::Concern
+
+      included do
+        include ActiveSupport::Testing::TimeHelpers
+      end
+
+      def visit_namespaced(controller:, action:, params: {})
+        ::Booth::Testing::Support::Visit.call(routing_namespace:, controller:, action:, params:)
+      end
+
+      def create_and_onboard(username:)
+        ::Booth::Testing::Support::Shortcuts::CreateAndOnboard.call(routing_namespace:,
+                                                                    scope:,
+                                                                    username:,
+                                                                    after_credential:)
+      end
+
+      def register_new_passkey(username:)
+        ::Booth::Testing::Support::Shortcuts::RegisterNewPasskey.call(routing_namespace:,
+                                                                      scope:,
+                                                                      username:)
+      end
+
+      def login_with_passkey(username:)
+        ::Booth::Testing::Support::Shortcuts::LoginWithPasskey.call(routing_namespace:,
+                                                                    scope:,
+                                                                    username:)
+      end
+
+      def assert_logged_out
+        ::Booth::Testing::Support::AssertLoggedOut.call(scope:)
+      end
+
+      def assert_logged_in(credential: Dry::Initializer::UNDEFINED, username: Dry::Initializer::UNDEFINED)
+        ::Booth::Testing::Support::AssertLoggedIn.call(scope:, credential:, username:)
+      end
+
+      def assert_userland_view(controller:, step:)
+        ::Booth::Testing::Support::AssertPartial.call(namespace: :userland, controller:, step:)
+      end
+
+      def soft_reset_session
+        ::Booth::Testing::Support::SoftResetSession.call
+      end
+
+      def virtual_authenticators
+        @virtual_authenticators ||= ::Booth::Testing::Support::VirtualAuthenticators::Manager.new
+      end
+      # def debug
+      #   puts
+      #   puts
+      #   puts Nokogiri::XML(page.html, &:noblanks)
+      #   puts
+      # end
+
+      # def respond_to_remote
+      #   visit userland_remote_login_path
+
+      #   credential = ::Booth::Models::Session.sorted_scope.first.credential
+      #   code = ::Booth::Core::Remotes::Get.call(credential_id: credential.id).formatted_code
+
+      #   fill_in 'Code', with: code
+      #   click_on 'Continue'
+
+      #   assert_content 'logged in on the other device'
+      #   assert_content 'solved your challenge'
+      # end
+
+    end
+  end
+end

data/lib/booth/testing/support/assert_all_partials_were_covered.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Booth
+  module Testing
+    module Support
+      class AssertAllPartialsWereCovered
+        include ::Minitest::Assertions
+        include ::Calls
+
+        # cd test/dummy
+        # ls app/views/community -R
+        EXPECTED_PARTIALS = %w[
+          userland/logins/enter_username
+          userland/logins/enter_webauth
+          userland/logins/no_authenticators
+          userland/logins/remote_session_available
+          userland/logins/remote_session_expired
+          userland/onboardings/already_used
+          userland/onboardings/blocked
+          userland/onboardings/not_found
+          userland/onboardings/not_needed
+          userland/onboardings/redeem
+          userland/onboardings/success
+          userland/onboardings/timed_out
+          userland/onboardings/wrong_user
+          userland/registrations/already_logged_in
+          userland/registrations/choose_username
+          userland/remote_logins/no_remote
+          userland/remote_logins/remote_login
+          userland/remote_logins/remote_solved
+          userland/sessions/index
+          userland/webauths/choose_nickname
+          userland/webauths/completed
+          userland/webauths/confirm
+          userland/webauths/index
+          userland/webauths/register
+          userland/webauths/sudo
+          userland/sessions/enter_webauth_to_destroy
+          userland/sessions/enter_webauth_to_destroy_all_others
+        ].freeze
+
+        def call
+          assert_empty superfluous_partials, 'These partials were rendered but not anticipated'
+          assert_empty missing_partials, 'These partials were not rendered in any test'
+        end
+
+        private
+
+        def missing_partials
+          (EXPECTED_PARTIALS - covered_partials)
+        end
+
+        def superfluous_partials
+          (covered_partials - EXPECTED_PARTIALS)
+        end
+
+        def covered_partials
+          Booth::Testing::Support::AssertPartial.asserted_partials.to_a
+        end
+
+        # So that `Minitest::Assertions` can be included
+        def assertions
+          0
+        end
+        attr_writer :assertions
+      end
+    end
+  end
+end

data/lib/booth/testing/support/assert_logged_in.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Booth
+  module Testing
+    module Support
+      class AssertLoggedIn
+        class AssertionFailedError < StandardError; end
+        include ::Calls
+        include ::Capybara::DSL
+        include ::Booth::Logging
+
+        option :scope
+        option :credential, as: :manual_credential, optional: true
+        option :username, optional: true
+
+        def call
+          # tries ||= 0
+          ::Capybara::Lockstep.synchronize
+
+          browser_session_id = nil
+          active_sessions.each do |session|
+            browser_session_id = ::Booth::Testing::Support::GetSessionValue.call(key:)
+            return true if browser_session_id == session.id.to_s
+          end
+
+          attributes = {
+            expected_username: credential.username,
+            expected_credential_id: credential.id,
+            expected_session_ids: active_sessions.map(&:id),
+            actual_session_id: browser_session_id,
+          }
+          raise AssertionFailedError, "Expected to be logged in. #{attributes}"
+          # "Expected Credential `#{credential.id}` to be logged in with a session of: #{active_sessions.map(&:id)}"
+
+          # With the Webauth pingpong it sometimes takes a little longer.
+          # And Capybara Lockstep doesn't seem to be able to detect that.
+          # rescue AssertionFailedError
+          #   if (tries += 1) < 3
+          #     log { 'Trying again...' }
+          #     sleep 1
+          #     retry
+          #   end
+
+          #   raise
+        end
+
+        private
+
+        def active_sessions
+          credential.sessions.active_scope.sorted_scope
+        end
+
+        def credential
+          if @credential == Dry::Initializer::UNDEFINED &&
+             @username == Dry::Initializer::UNDEFINED
+            raise 'Must provide either `credential:` or `username:`'
+          end
+
+          manual_credential || ::Booth::Models::Credential.find_by(username:)
+        end
+
+        def key
+          "warden.user.#{scope}.key"
+        end
+      end
+    end
+  end
+end

data/lib/booth/{test → testing}/support/assert_logged_out.rb

@@ -1,10 +1,13 @@
+# frozen_string_literal: true
+
 module Booth
-  module Test
+  module Testing
     module Support
       class AssertLoggedOut
-        include ::Booth::MethodObject
+        include ::Calls
+        include ::Capybara::DSL
+        include ::Booth::Logging
 
-        option :page
         option :scope
 
         def call
@@ -18,7 +21,7 @@ module Booth
         private
 
         def logged_in?
-          ::Booth::Test::Support::GetSessionValue.call(page:, key:)
+          ::Booth::Testing::Support::GetSessionValue.call(key:)
         end
 
         def key

data/lib/booth/testing/support/assert_partial.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Booth
+  module Testing
+    module Support
+      class AssertPartial
+        include ::Calls
+        include ::Capybara::DSL
+        include ::Booth::Logging
+
+        cattr_accessor :asserted_partials, instance_accessor: false, default: Set.new
+
+        option :namespace
+        option :controller
+        option :step
+
+        def call
+          ::Capybara::Lockstep.synchronize
+          log { "Looking for view `#{partial}`" }
+
+          assert_selector 'template', visible: false
+
+          content = page.html.match(%r{<template>([^<]+)</template>})[1].strip
+
+          raise "Expected view '#{partial}' but got '#{content}'" unless content == partial
+
+          log { "The expected view `#{partial}` was rendered." }
+          self.class.asserted_partials << partial
+          nil
+        end
+
+        def expected_tag
+          "<template>#{partial}</template>"
+        end
+
+        def actual_tag
+          page.html.scan(%r{<template>[^/]+/[^/]+/[^/]+</template>}).uniq.first.presence ||
+            page.text
+        end
+
+        def partial
+          "#{namespace}/#{controller}/#{step}"
+        end
+
+        def test_file_and_line_number
+          # Called from e.g. `::Booth::Testing::Userland::LoginRemotely`.
+          candidate = caller[3].split(':in ').first
+          return candidate unless candidate.include?('calls')
+
+          # Called from e.g. `::Booth::Testing::Support::RegisterNewPasskey`.
+          caller[2].split(':in ').first
+        end
+      end
+    end
+  end
+end

data/lib/booth/{test → testing}/support/force_login.rb

@@ -1,14 +1,20 @@
+# frozen_string_literal: true
+
 module Booth
-  module Test
+  module Testing
     module Support
       class ForceLogin
-        include ::Booth::MethodObject
+        include Calls
 
         option :credential_id
-        option :request, ::Booth::Request
+        option :request
 
         def call
-          ::Booth::Sessions::CreateAndLogin.call(credential:, request:)
+          login = ::Booth::Core::Sessions::CreateAndLogin.call(domain: request.host, scope:,
+                                                               credential:, request:)
+          raise login.inspect if login.failure?
+
+          nil
         end
 
         delegate :scope, to: :credential

data/lib/booth/{test → testing}/support/get_session_value.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 module Booth
-  module Test
+  module Testing
     module Support
       class GetSessionValue
-        include ::Booth::MethodObject
+        include ::Calls
+        include ::Capybara::DSL
         include ::Booth::Logging
 
-        option :page
         option :key
 
         def call
@@ -16,7 +18,7 @@ module Booth
             result = page.get_rack_session[key]
           end
 
-          debug { "session[#{key.inspect}] is: #{result.inspect}" }
+          log { "session[#{key.inspect}] is: #{result.inspect}" }
 
           ::Capybara::Lockstep.synchronize
           result
@@ -25,8 +27,8 @@ module Booth
         private
 
         def in_new_window(&)
-          window = page.open_new_window
-          page.within_window(window, &)
+          window = open_new_window
+          within_window(window, &)
           window.close
         end
       end

data/lib/booth/testing/support/scenario.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Booth
+  module Testing
+    module Support
+      class Scenario
+        attr_accessor :routing_namespace, :scope, :before_test, :after_credential
+
+        def initialize(klass)
+          @klass = klass
+        end
+
+        def name
+          @klass.to_s.underscore.parameterize(separator: '_')
+        end
+
+        def call
+          @klass.call routing_namespace:, scope:, before_test:, after_credential:
+        end
+      end
+    end
+  end
+end

data/lib/booth/testing/support/shortcuts/create_and_onboard.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Booth
+  module Testing
+    module Support
+      module Shortcuts
+        # Create a Credential and use an Onboarding link to login.
+        class CreateAndOnboard
+          include ::Calls
+          include ::Capybara::DSL
+
+          option :routing_namespace
+          option :scope
+          option :username
+          option :after_credential
+
+          def call
+            Visit.call(routing_namespace:,
+                       controller: :onboardings,
+                       action: :show,
+                       params: { id: onboarding.secret_key })
+
+            AssertPartial.call(namespace: :userland, controller: :onboardings, step: :redeem)
+
+            click_on :submit
+
+            AssertLoggedIn.call(scope:, credential:)
+
+            nil
+          end
+
+          private
+
+          def onboarding
+            @onboarding ||= ::Booth::Models::Onboarding.create!(
+              credential_id: credential.id,
+            )
+          end
+
+          def credential
+            return @credential if defined?(@credential)
+
+            @credential = ::Booth::Models::Credential.create!(
+              domain: ::Capybara.app_host.remove('http://'),
+              username:,
+              scope:,
+            )
+
+            after_credential&.call(credential_id: @credential.id)
+            @credential
+          end
+        end
+      end
+    end
+  end
+end