RubyGems - capybara-simulated - Versions diffs - 0.0.2 - Mend

capybara-simulated 0.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (22) hide show

checksums.yaml +7 -0
data/LICENSE +20 -0
data/README.md +225 -0
data/lib/capybara/simulated/browser.rb +1012 -0
data/lib/capybara/simulated/driver.rb +191 -0
data/lib/capybara/simulated/errors.rb +9 -0
data/lib/capybara/simulated/node.rb +235 -0
data/lib/capybara/simulated/version.rb +5 -0
data/lib/capybara/simulated.rb +10 -0
data/lib/capybara-simulated.rb +1 -0
data/vendor/esbuild-wasm/LICENSE.md +21 -0
data/vendor/esbuild-wasm/bin/esbuild +91 -0
data/vendor/esbuild-wasm/esbuild.wasm +0 -0
data/vendor/esbuild-wasm/lib/main.js +2337 -0
data/vendor/esbuild-wasm/wasm_exec.js +575 -0
data/vendor/esbuild-wasm/wasm_exec_node.js +40 -0
data/vendor/js/bundle-modules.mjs +168 -0
data/vendor/js/csim.bundle.js +101015 -0
data/vendor/js/entry.mjs +8 -0
data/vendor/js/prelude.js +186 -0
data/vendor/js/runtime.js +2054 -0
metadata +106 -0

data/lib/capybara/simulated/driver.rb ADDED Viewed

@@ -0,0 +1,191 @@
+require 'capybara/driver/base'
+module Capybara
+  module Simulated
+    class Driver < Capybara::Driver::Base
+      DEFAULT_WINDOW_HANDLE = 'main'.freeze
+      attr_reader :app
+      def initialize(app)
+        @app = app
+      end
+      def browser
+        @browser ||= begin
+          b = Browser.new(app)
+          b.driver_for_results = self
+          b
+        end
+      end
+      def needs_server?      = false
+      def javascript_enabled? = true
+      # Capybara's synchronize loop will retry on ElementNotFound only
+      # when the driver opts into waiting. Even though our DOM updates
+      # happen in-process, async setTimeout-style behaviours need
+      # Capybara to give them time.
+      def wait?              = true
+      def visit(path)         = browser.visit(path)
+      def refresh             = browser.refresh
+      def go_back             = browser.go_back
+      def go_forward          = browser.go_forward
+      def current_url         = browser.current_url
+      def html                = browser.html
+      def title               = browser.title
+      def status_code         = browser.status_code
+      def response_headers    = browser.response_headers || {}
+      def find_xpath(query, **_)
+        browser.find_xpath(query).map {|id| Node.new(self, id) }
+      end
+      def find_css(query, **_)
+        browser.find_css(query).map {|id| Node.new(self, id) }
+      end
+      def execute_script(script, *args)
+        browser.execute_script(script, args)
+      end
+      def evaluate_script(script, *args)
+        browser.evaluate_script(script, args)
+      end
+      def evaluate_async_script(script, *args)
+        browser.evaluate_async_script(script, args)
+      end
+      def send_keys(*keys)
+        # Capybara calls session-level `send_keys` to drive global key
+        # navigation (typically `:tab`). Even when nothing has been
+        # focused yet, `<body>` is a valid sink so Tab handling can
+        # advance to the first focusable descendant.
+        handle_id = browser.active_element || browser.find_css('body').first
+        return unless handle_id
+        browser.send_keys(handle_id, keys)
+      end
+      def active_element
+        handle_id = browser.active_element
+        Node.new(self, handle_id) if handle_id
+      end
+      def save_screenshot(path, **_options)
+        File.write(path, html)
+        path
+      end
+      def reset!
+        return unless @browser
+        @browser.reset_state!
+      end
+      def invalid_element_errors
+        [Capybara::Simulated::StaleElementReferenceError]
+      end
+      def no_such_window_error
+        Capybara::WindowError
+      end
+      def current_window_handle = DEFAULT_WINDOW_HANDLE
+      def window_handles         = [DEFAULT_WINDOW_HANDLE]
+      def open_new_window
+        raise NotImplementedError, 'capybara-simulated supports a single window'
+      end
+      def close_window(_handle)
+        raise NotImplementedError, 'capybara-simulated supports a single window'
+      end
+      def switch_to_window(handle)
+        return if handle == DEFAULT_WINDOW_HANDLE || handle.respond_to?(:handle) && handle.handle == DEFAULT_WINDOW_HANDLE
+        raise Capybara::WindowError, "no such window: #{handle.inspect}"
+      end
+      def window_size(_handle)        = [1024, 768]
+      def resize_window_to(_h, _w, _h2); end
+      def maximize_window(_handle); end
+      def fullscreen_window(_handle); end
+      def switch_to_frame(_frame)
+        raise NotImplementedError, 'frames are not supported by capybara-simulated'
+      end
+      def frame_title
+        browser.title
+      end
+      def frame_url
+        browser.current_url
+      end
+      def accept_modal(type, **options, &blk)
+        push_modal_handler(type, options, accept: true)
+        wait_for_modal(type, options, &blk)
+      end
+      def dismiss_modal(type, **options, &blk)
+        push_modal_handler(type, options, accept: false)
+        wait_for_modal(type, options, &blk)
+      end
+      private
+      # Modals fired from `setTimeout` callbacks don't appear synchronously
+      # when the block runs `click_link`. Advance the virtual clock in
+      # short slices until either a matching modal arrives or the wait
+      # budget runs out, matching Capybara's `accept_modal` semantics for
+      # asynchronous alerts.
+      MODAL_POLL_STEP_MS = 50
+      def wait_for_modal(type, options, &blk)
+        blk.call if blk
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) +
+                   (options[:wait] || Capybara.default_max_wait_time || 2).to_f
+        text_matcher = options[:text]
+        loop do
+          browser.modal_inbox.concat(browser.drain_modal_queue)
+          match = browser.modal_inbox.find {|m|
+            m['type'].to_s == type.to_s && modal_text_matches?(m['message'], text_matcher)
+          }
+          if match
+            browser.modal_inbox.delete(match)
+            pop_modal_handler(type, options)
+            return match['message']
+          end
+          break if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+          browser.advance_virtual_clock_step(MODAL_POLL_STEP_MS)
+        end
+        pop_modal_handler(type, options)
+        raise Capybara::ModalNotFound, "Unable to find modal dialog#{" with text matching #{text_matcher.inspect}" if text_matcher}"
+      end
+      def modal_text_matches?(message, matcher)
+        return true if matcher.nil?
+        case matcher
+        when Regexp then matcher.match?(message.to_s)
+        else             message.to_s.include?(matcher.to_s)
+        end
+      end
+      # Modal handlers stack in registration order; the JS modal stub
+      # picks the first whose text predicate matches the firing message.
+      # Required for nested `dismiss_confirm { accept_confirm { ... } }`
+      # blocks where two confirms fire in one synchronous click handler.
+      def push_modal_handler(type, options, accept:)
+        response = case type
+                   when :alert   then true
+                   when :confirm then accept
+                   when :prompt  then accept ? options[:with] : false
+                   end
+        browser.add_modal_handler(type: type.to_s, text: options[:text], response: response)
+      end
+      def pop_modal_handler(type, options)
+        browser.remove_modal_handler(type: type.to_s, text: options[:text])
+      end
+      public
+    end
+  end
+end

data/lib/capybara/simulated/errors.rb ADDED Viewed

@@ -0,0 +1,9 @@
+module Capybara
+  module Simulated
+    # Raised by the runtime when a Ruby caller hands back a handle id that
+    # no longer maps to a live DOM node — usually because the page was
+    # reloaded between the find and the action. Capybara's synchronize
+    # block catches these via the driver's `invalid_element_errors`.
+    class StaleElementReferenceError < StandardError; end
+  end
+end

data/lib/capybara/simulated/node.rb ADDED Viewed

@@ -0,0 +1,235 @@
+require 'capybara/driver/node'
+require 'capybara/node/whitespace_normalizer'
+module Capybara
+  module Simulated
+    class Node < Capybara::Driver::Node
+      include Capybara::Node::WhitespaceNormalizer
+      def handle_id = native
+      def all_text
+        normalize_spacing(browser.all_text(handle_id))
+      end
+      def visible_text
+        normalize_visible_spacing(browser.visible_text(handle_id))
+      end
+      def [](name)
+        case name.to_s
+        when 'value'    then value
+        when 'checked'  then checked? ? 'true' : nil
+        when 'selected' then selected? ? 'true' : nil
+        else browser.attr(handle_id, name)
+        end
+      end
+      def value
+        browser.value(handle_id)
+      end
+      def set(value, **_opts)
+        return if disabled?
+        # readonly is meaningless on checkbox/radio; the HTML spec ignores
+        # it for those types, and Capybara's specs explicitly assert that.
+        type = (self[:type] || tag_name || '').to_s.downcase
+        return if readonly? && type != 'checkbox' && type != 'radio'
+        browser.set_value(handle_id, value)
+      end
+      def select_option
+        return if disabled?
+        browser.select_option(handle_id)
+      end
+      def unselect_option
+        raise Capybara::UnselectNotAllowed, 'Cannot unselect option from single select box.' unless select_node_multiple?
+        browser.unselect_option(handle_id)
+      end
+      def tag_name
+        browser.tag_name(handle_id)
+      end
+      def visible?
+        browser.visible?(handle_id)
+      end
+      def obscured?
+        false
+      end
+      def checked?
+        browser.checked?(handle_id)
+      end
+      def selected?
+        browser.selected?(handle_id)
+      end
+      def disabled?
+        browser.disabled?(handle_id)
+      end
+      def readonly?
+        browser.readonly?(handle_id)
+      end
+      def multiple?
+        browser.multiple?(handle_id)
+      end
+      def click(keys = [], **opts)
+        browser.click(handle_id, click_options(keys, opts))
+      end
+      def right_click(keys = [], **opts)
+        browser.right_click(handle_id, click_options(keys, opts))
+      end
+      def double_click(keys = [], **opts)
+        browser.double_click(handle_id, click_options(keys, opts))
+      end
+      private
+      # x/y from Capybara are *offsets* — from top-left when
+      # Capybara.w3c_click_offset is false, from center when true. The
+      # runtime reads `simRect` to translate these into absolute
+      # clientX/clientY before dispatching the mouse events. Defaults
+      # (no x/y) target the element's center.
+      def click_options(keys, opts)
+        out = modifier_options(keys)
+        if opts.key?(:x) || opts.key?(:y)
+          out['offsetX']   = opts[:x].to_f if opts.key?(:x)
+          out['offsetY']   = opts[:y].to_f if opts.key?(:y)
+          out['w3cOffset'] = !!Capybara.w3c_click_offset
+        end
+        out['delay'] = opts[:delay].to_f if opts.key?(:delay) && opts[:delay].to_f.positive?
+        out
+      end
+      def modifier_options(keys)
+        opts = {}
+        Array(keys).each do |k|
+          case k
+          when :shift   then opts['shiftKey'] = true
+          when :ctrl, :control then opts['ctrlKey'] = true
+          when :alt     then opts['altKey'] = true
+          when :meta, :command then opts['metaKey'] = true
+          end
+        end
+        opts
+      end
+      public
+      def hover
+        browser.hover(handle_id)
+      end
+      def trigger(event)
+        browser.trigger(handle_id, event)
+      end
+      def send_keys(*keys)
+        browser.send_keys(handle_id, keys)
+      end
+      def drag_to(other, **_opts)
+        browser.trigger(handle_id, 'dragstart')
+        browser.trigger(other.handle_id, 'dragenter')
+        browser.trigger(other.handle_id, 'dragover')
+        browser.trigger(other.handle_id, 'drop')
+        browser.trigger(handle_id, 'dragend')
+      end
+      def drop(*args)
+        items = args.flat_map {|arg| drop_items_for(arg) }
+        browser.drop(handle_id, items)
+      end
+      def scroll_by(_x, _y); end
+      def scroll_to(_element, _alignment, _position = nil); end
+      def submit
+        browser.submit(handle_id)
+      end
+      def find_xpath(xpath)
+        browser.find_xpath(xpath, handle_id).map {|id| self.class.new(driver, id) }
+      end
+      def find_css(css)
+        browser.find_css(css, handle_id).map {|id| self.class.new(driver, id) }
+      end
+      def rect
+        browser.rect(handle_id)
+      end
+      def path
+        browser.path(handle_id)
+      end
+      def shadow_root
+        id = browser.shadow_root(handle_id)
+        id ? Node.new(driver, id) : nil
+      end
+      def style(_styles)
+        raise NotImplementedError, 'The simulated driver does not process CSS'
+      end
+      def ==(other)
+        other.is_a?(Node) && other.handle_id == handle_id
+      end
+      def inspect
+        %(#<Capybara::Simulated::Node tag="#{tag_name}" id=#{handle_id}>)
+      rescue StandardError
+        super
+      end
+      private
+      def drop_items_for(arg)
+        case arg
+        when Hash
+          arg.map {|type, data|
+            {'kind' => 'string', 'type' => type.to_s, 'data' => data.to_s}
+          }
+        when String
+          [{'kind' => 'file', 'name' => File.basename(arg), 'type' => '', 'contents' => safely_read(arg)}]
+        else
+          []
+        end
+      end
+      def safely_read(path)
+        File.binread(path)
+      rescue StandardError
+        ''
+      end
+      def browser = driver.browser
+      def select_node_multiple?
+        browser.evaluate_script(<<~JS)
+          (() => {
+            const el = (#{select_lookup_js})
+            const sel = el.closest('select');
+            return !!(sel && sel.multiple);
+          })()
+        JS
+      end
+      def select_lookup_js
+        # The JS-side handles map is private; use evaluate via a tiny accessor.
+        # Cheaper: ask browser directly through path/tag inspection.
+        "document.evaluate(#{path.inspect}, document, null, 9, null).singleNodeValue"
+      end
+    end
+  end
+end

data/lib/capybara/simulated/version.rb ADDED Viewed

@@ -0,0 +1,5 @@
+module Capybara
+  module Simulated
+    VERSION = '0.0.2'
+  end
+end

data/lib/capybara/simulated.rb ADDED Viewed

@@ -0,0 +1,10 @@
+require 'capybara'
+require 'capybara/simulated/version'
+require 'capybara/simulated/errors'
+require 'capybara/simulated/browser'
+require 'capybara/simulated/driver'
+require 'capybara/simulated/node'
+Capybara.register_driver :simulated do |app|
+  Capybara::Simulated::Driver.new(app)
+end

data/lib/capybara-simulated.rb ADDED Viewed

	@@ -0,0 +1 @@
1	+ require 'capybara/simulated'

data/vendor/esbuild-wasm/LICENSE.md ADDED Viewed

@@ -0,0 +1,21 @@
+MIT License
+Copyright (c) 2020 Evan Wallace
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/vendor/esbuild-wasm/bin/esbuild ADDED Viewed

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+// Forward to the automatically-generated WebAssembly loader from the Go compiler
+const module_ = require('module');
+const path = require('path');
+const fs = require('fs');
+const wasm_exec_node = path.join(__dirname, '..', 'wasm_exec_node.js');
+const esbuild_wasm = path.join(__dirname, '..', 'esbuild.wasm');
+const code = fs.readFileSync(wasm_exec_node, 'utf8');
+const wrapper = new Function('require', 'WebAssembly', code);
+function instantiate(bytes, importObject) {
+  // Using this API causes "./esbuild --version" to run around 1 second faster
+  // than using the "WebAssembly.instantiate()" API when run in node (v12.16.2)
+  const module = new WebAssembly.Module(bytes);
+  const instance = new WebAssembly.Instance(module, importObject);
+  return Promise.resolve({ instance, module });
+}
+// Node has another bug where using "fs.read" to read from stdin reads
+// everything successfully and then throws an error, but only on Windows. Go's
+// WebAssembly support uses "fs.read" so it hits this problem. This is a patch
+// to try to work around the bug in node. This bug has been reported to node
+// at least twice in https://github.com/nodejs/node/issues/35997 and in
+// https://github.com/nodejs/node/issues/19831. This issue has also been
+// reported to the Go project: https://github.com/golang/go/issues/43913.
+const read = fs.read;
+fs.read = function () {
+  const callback = arguments[5];
+  arguments[5] = function (err, count) {
+    if (count === 0 && err && err.code === 'EOF') {
+      arguments[0] = null;
+    }
+    return callback.apply(this, arguments);
+  };
+  return read.apply(this, arguments);
+};
+// Hack around a Unicode bug in node: https://github.com/nodejs/node/issues/24550.
+// See this for the matching Go issue: https://github.com/golang/go/issues/43917.
+const write = fs.write;
+fs.write = function (fd, buf, offset, length, position, callback) {
+  if (offset === 0 && length === buf.length && position === null) {
+    if (fd === process.stdout.fd) {
+      try {
+        process.stdout.write(buf, err => err ? callback(err, 0, null) : callback(null, length, buf));
+      } catch (err) {
+        callback(err, 0, null);
+      }
+      return;
+    }
+    if (fd === process.stderr.fd) {
+      try {
+        process.stderr.write(buf, err => err ? callback(err, 0, null) : callback(null, length, buf));
+      } catch (err) {
+        callback(err, 0, null);
+      }
+      return;
+    }
+  }
+  return write.apply(this, arguments);
+};
+const writeSync = fs.writeSync;
+fs.writeSync = function (fd, buf) {
+  if (fd === process.stdout.fd) return process.stdout.write(buf), buf.length;
+  if (fd === process.stderr.fd) return process.stderr.write(buf), buf.length;
+  return writeSync.apply(this, arguments);
+};
+// WASM code generated with Go 1.17.2+ will crash when run in a situation with
+// many environment variables: https://github.com/golang/go/issues/49011. An
+// example of this situation is running a Go-compiled WASM executable in GitHub
+// Actions. Work around this by filtering node's copy of environment variables
+// down to only include the environment variables that esbuild currently uses.
+const esbuildUsedEnvVars = [
+  'NO_COLOR',
+  'NODE_PATH',
+  'npm_config_user_agent',
+  'WT_SESSION',
+]
+for (let key in process.env) {
+  if (esbuildUsedEnvVars.indexOf(key) < 0) {
+    delete process.env[key]
+  }
+}
+process.argv.splice(2, 0, esbuild_wasm);
+wrapper(module_.createRequire(wasm_exec_node), Object.assign(Object.create(WebAssembly), { instantiate }));

data/vendor/esbuild-wasm/esbuild.wasm ADDED Viewed

Binary file