capybara 3.0.0 → 3.36.0

data/.yard/templates_custom/default/class/html/setup.rb

@@ -1,17 +0,0 @@
-def init
-  super
-  sections.place(:builtins).before(:subclasses)
-end
-
-def builtins
-  return if object.path != "Capybara::Selector" # only show built-in selectors for Selector class
-
-  @selectors = Registry.all(:selector)
-  return if @selectors.nil? || @selectors.empty?
-
-  @selectors = @selectors.map do |selector|
-    [selector.name, selector]
-  end
-
-  erb(:selectors)
-end

data/.yard/yard_extensions.rb

@@ -1,78 +0,0 @@
-YARD::Templates::Engine.register_template_path Pathname.new('./.yard/templates_custom')
-
-YARD::Tags::Library.define_tag "Locator", :locator
-YARD::Tags::Library.define_tag "Filter", :filter, :with_types_and_name
-
-class SelectorObject < YARD::CodeObjects::Base
-  def path
-    "__Capybara" + sep + super
-  end
-end
-
-class AddSelectorHandler < YARD::Handlers::Ruby::Base
-  handles method_call(:add_selector)
-  namespace_only
-  process do
-    name = statement.parameters.first.jump(:tstring_content, :ident).source
-    # object = YARD::CodeObjects::MethodObject.new(namespace, name.to_sym)
-    # object = SelectorObject.new(YARD::Registry.resolve(P("Capybara"), "#add_selector", false, true), name.to_sym)
-    object = SelectorObject.new(namespace, name)
-    register(object)
-    parse_block(statement.last.last, :owner => object)
-
-    # modify the object
-    object.dynamic = true
-  end
-end
-
-class AddExpressionFilterHandler < YARD::Handlers::Ruby::Base
-  handles method_call(:xpath)
-  handles method_call(:css)
-
-  process do
-    return unless owner.is_a?(SelectorObject)
-    return if statement.parameters.empty?
-    # names = statement.parameters.children.map { |p| p.jump(:tstring_content, :ident).source.sub(/^:/, '') }
-    names = statement.parameters.children.map &:source
-    current_names = owner.tags(:filter).map(&:name)
-    (names-current_names).each do |name|
-      owner.add_tag(YARD::Tags::Tag.new(:filter, nil, nil, name))
-    end
-  end
-end
-
-class AddFilterHandler < YARD::Handlers::Ruby::Base
-  handles method_call(:filter)
-
-  process do
-    return unless owner.is_a?(SelectorObject)
-    return if statement.parameters.empty?
-    name = statement.parameters.first.source
-    type = if statement.parameters[1] && statement.parameters[1].source == ':boolean'
-      'Boolean'
-    else
-      nil
-    end
-    if owner.tags(:filter).none? {|tag| tag.name == name }
-      filter_tag = YARD::Tags::Tag.new(:filter, nil, type, name)
-      owner.add_tag(filter_tag)
-    end
-  end
-end
-
-class FilterSetHandler < YARD::Handlers::Ruby::Base
-  handles method_call(:filter_set)
-
-  process do
-    return unless owner.is_a?(SelectorObject)
-    return if statement.parameters.empty? || !statement.parameters[1]
-
-    names = statement.parameters[1].flatten.map { |name| ":#{name}" }
-    names.each do |name|
-      if owner.tags(:filter).none? {|tag| tag.name == name }
-        filter_tag = YARD::Tags::Tag.new(:filter, nil, nil, name)
-        owner.add_tag(filter_tag)
-      end
-    end
-  end
-end

data/lib/capybara/rspec/compound.rb

@@ -1,90 +0,0 @@
-module Capybara
-  module RSpecMatchers
-    module Compound
-      include ::RSpec::Matchers::Composable
-
-      def and(matcher)
-        Capybara::RSpecMatchers::Compound::And.new(self, matcher)
-      end
-
-      def and_then(matcher)
-        ::RSpec::Matchers::BuiltIn::Compound::And.new(self, matcher)
-      end
-
-      def or(matcher)
-        Capybara::RSpecMatchers::Compound::Or.new(self, matcher)
-      end
-
-      class CapybaraEvaluator
-        def initialize(actual)
-          @actual = actual
-          @match_results = Hash.new { |h, matcher| h[matcher] = matcher.matches?(@actual) }
-        end
-
-        def matcher_matches?(matcher)
-          @match_results[matcher]
-        end
-
-        def reset
-          @match_results.clear
-        end
-      end
-
-      class And < ::RSpec::Matchers::BuiltIn::Compound::And
-      private
-
-        def match(_expected, actual)
-          @evaluator = CapybaraEvaluator.new(actual)
-          syncer = sync_element(actual)
-          begin
-            syncer.synchronize do
-              @evaluator.reset
-              raise ::Capybara::ElementNotFound unless [matcher_1_matches?, matcher_2_matches?].all?
-              true
-            end
-          rescue
-            false
-          end
-        end
-
-        def sync_element(el)
-          if el.respond_to? :synchronize
-            el
-          elsif el.respond_to? :current_scope
-            el.current_scope
-          else
-            Capybara.string(el)
-          end
-        end
-      end
-
-      class Or < ::RSpec::Matchers::BuiltIn::Compound::Or
-      private
-
-        def match(_expected, actual)
-          @evaluator = CapybaraEvaluator.new(actual)
-          syncer = sync_element(actual)
-          begin
-            syncer.synchronize do
-              @evaluator.reset
-              raise ::Capybara::ElementNotFound unless [matcher_1_matches?, matcher_2_matches?].any?
-              true
-            end
-          rescue
-            false
-          end
-        end
-
-        def sync_element(el)
-          if el.respond_to? :synchronize
-            el
-          elsif el.respond_to? :current_scope
-            el.current_scope
-          else
-            Capybara.string(el)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/capybara/spec/session/assert_selector.rb

@@ -1,149 +0,0 @@
-# frozen_string_literal: true
-
-Capybara::SpecHelper.spec '#assert_selector' do
-  before do
-    @session.visit('/with_html')
-  end
-
-  it "should be true if the given selector is on the page" do
-    @session.assert_selector(:xpath, "//p")
-    @session.assert_selector(:css, "p a#foo")
-    @session.assert_selector("//p[contains(.,'est')]")
-  end
-
-  it "should be false if the given selector is not on the page" do
-    expect { @session.assert_selector(:xpath, "//abbr") }.to raise_error(Capybara::ElementNotFound)
-    expect { @session.assert_selector(:css, "p a#doesnotexist") }.to raise_error(Capybara::ElementNotFound)
-    expect { @session.assert_selector("//p[contains(.,'thisstringisnotonpage')]") }.to raise_error(Capybara::ElementNotFound)
-  end
-
-  it "should use default selector" do
-    Capybara.default_selector = :css
-    expect { @session.assert_selector("p a#doesnotexist") }.to raise_error(Capybara::ElementNotFound)
-    @session.assert_selector("p a#foo")
-  end
-
-  it "should respect scopes" do
-    @session.within "//p[@id='first']" do
-      @session.assert_selector(".//a[@id='foo']")
-      expect { @session.assert_selector(".//a[@id='red']") }.to raise_error(Capybara::ElementNotFound)
-    end
-  end
-
-  context "with count" do
-    it "should be true if the content is on the page the given number of times" do
-      @session.assert_selector("//p", count: 3)
-      @session.assert_selector("//p//a[@id='foo']", count: 1)
-      @session.assert_selector("//p[contains(.,'est')]", count: 1)
-    end
-
-    it "should be false if the content is on the page the given number of times" do
-      expect { @session.assert_selector("//p", count: 6) }.to raise_error(Capybara::ElementNotFound)
-      expect { @session.assert_selector("//p//a[@id='foo']", count: 2) }.to raise_error(Capybara::ElementNotFound)
-      expect { @session.assert_selector("//p[contains(.,'est')]", count: 5) }.to raise_error(Capybara::ElementNotFound)
-    end
-
-    it "should be false if the content isn't on the page at all" do
-      expect { @session.assert_selector("//abbr", count: 2) }.to raise_error(Capybara::ElementNotFound)
-      expect { @session.assert_selector("//p//a[@id='doesnotexist']", count: 1) }.to raise_error(Capybara::ElementNotFound)
-    end
-  end
-
-  context "with text" do
-    it "should discard all matches where the given string is not contained" do
-      @session.assert_selector("//p//a", text: "Redirect", count: 1)
-      expect { @session.assert_selector("//p", text: "Doesnotexist") }.to raise_error(Capybara::ElementNotFound)
-    end
-
-    it "should discard all matches where the given regexp is not matched" do
-      @session.assert_selector("//p//a", text: /re[dab]i/i, count: 1)
-      expect { @session.assert_selector("//p//a", text: /Red$/) }.to raise_error(Capybara::ElementNotFound)
-    end
-  end
-
-  context "with wait", requires: [:js] do
-    it "should find element if it appears before given wait duration" do
-      Capybara.using_wait_time(0.1) do
-        @session.visit('/with_js')
-        @session.click_link('Click me')
-        @session.assert_selector(:css, "a#has-been-clicked", text: "Has been clicked", wait: 2)
-      end
-    end
-  end
-end
-
-Capybara::SpecHelper.spec '#refute_selector' do
-  it "should be an alias of #assert_no_selector" do
-    expect(Capybara::Node::Matchers.instance_method(:refute_selector)).to eq Capybara::Node::Matchers.instance_method(:assert_no_selector)
-  end
-end
-
-Capybara::SpecHelper.spec '#assert_no_selector' do
-  before do
-    @session.visit('/with_html')
-  end
-
-  it "should be false if the given selector is on the page" do
-    expect { @session.assert_no_selector(:xpath, "//p") }.to raise_error(Capybara::ElementNotFound)
-    expect { @session.assert_no_selector(:css, "p a#foo") }.to raise_error(Capybara::ElementNotFound)
-    expect { @session.assert_no_selector("//p[contains(.,'est')]") }.to raise_error(Capybara::ElementNotFound)
-  end
-
-  it "should be true if the given selector is not on the page" do
-    @session.assert_no_selector(:xpath, "//abbr")
-    @session.assert_no_selector(:css, "p a#doesnotexist")
-    @session.assert_no_selector("//p[contains(.,'thisstringisnotonpage')]")
-  end
-
-  it "should use default selector" do
-    Capybara.default_selector = :css
-    @session.assert_no_selector("p a#doesnotexist")
-    expect { @session.assert_no_selector("p a#foo") }.to raise_error(Capybara::ElementNotFound)
-  end
-
-  it "should respect scopes" do
-    @session.within "//p[@id='first']" do
-      expect { @session.assert_no_selector(".//a[@id='foo']") }.to raise_error(Capybara::ElementNotFound)
-      @session.assert_no_selector(".//a[@id='red']")
-    end
-  end
-
-  context "with count" do
-    it "should be false if the content is on the page the given number of times" do
-      expect { @session.assert_no_selector("//p", count: 3) }.to raise_error(Capybara::ElementNotFound)
-      expect { @session.assert_no_selector("//p//a[@id='foo']", count: 1) }.to raise_error(Capybara::ElementNotFound)
-      expect { @session.assert_no_selector("//p[contains(.,'est')]", count: 1) }.to raise_error(Capybara::ElementNotFound)
-    end
-
-    it "should be true if the content is on the page the wrong number of times" do
-      @session.assert_no_selector("//p", count: 6)
-      @session.assert_no_selector("//p//a[@id='foo']", count: 2)
-      @session.assert_no_selector("//p[contains(.,'est')]", count: 5)
-    end
-
-    it "should be true if the content isn't on the page at all" do
-      @session.assert_no_selector("//abbr", count: 2)
-      @session.assert_no_selector("//p//a[@id='doesnotexist']", count: 1)
-    end
-  end
-
-  context "with text" do
-    it "should discard all matches where the given string is contained" do
-      expect { @session.assert_no_selector("//p//a", text: "Redirect", count: 1) }.to raise_error(Capybara::ElementNotFound)
-      @session.assert_no_selector("//p", text: "Doesnotexist")
-    end
-
-    it "should discard all matches where the given regexp is matched" do
-      expect { @session.assert_no_selector("//p//a", text: /re[dab]i/i, count: 1) }.to raise_error(Capybara::ElementNotFound)
-      @session.assert_no_selector("//p//a", text: /Red$/)
-    end
-  end
-
-  context "with wait", requires: [:js] do
-    it "should not find element if it appears after given wait duration" do
-      @session.visit('/with_js')
-      @session.click_link('Click me')
-      @session.assert_no_selector(:css, "a#has-been-clicked", text: "Has been clicked", wait: 0.1)
-    end
-  end
-end

data/lib/capybara/spec/views/with_title.erb

@@ -1,5 +0,0 @@
-
-<title>Test Title</title>
-<body>
-  <svg><title>abcdefg</title></svg>
-</body>

data/spec/selenium_spec_marionette.rb

@@ -1,143 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require "selenium-webdriver"
-require 'shared_selenium_session'
-require 'rspec/shared_spec_matchers'
-
-browser_options = ::Selenium::WebDriver::Firefox::Options.new
-browser_options.args << '--headless' if ENV['HEADLESS']
-browser_options.add_preference 'dom.file.createInChild', true
-# browser_options.add_option("log", {"level": "trace"})
-
-Capybara.register_driver :selenium_marionette do |app|
-  # ::Selenium::WebDriver.logger.level = "debug"
-  Capybara::Selenium::Driver.new(
-    app,
-    browser: :firefox,
-    desired_capabilities: { marionette: true, 'moz:webdriverClick': true },
-    options: browser_options
-    # Get a trace level log from geckodriver
-    # :driver_opts => { args: ['-vv'] }
-  )
-end
-
-Capybara.register_driver :selenium_marionette_clear_storage do |app|
-  Capybara::Selenium::Driver.new(
-    app,
-    browser: :firefox,
-    desired_capabilities: { marionette: true },
-    clear_local_storage: true,
-    clear_session_storage: true,
-    options: browser_options
-  )
-end
-
-module TestSessions
-  SeleniumMarionette = Capybara::Session.new(:selenium_marionette, TestApp)
-end
-
-skipped_tests = %i[response_headers status_code trigger]
-skipped_tests << :windows if ENV['TRAVIS'] && ENV['SKIP_WINDOW']
-
-$stdout.puts `#{Selenium::WebDriver::Firefox.driver_path} --version` if ENV['CI']
-
-Capybara::SpecHelper.run_specs TestSessions::SeleniumMarionette, "selenium", capybara_skip: skipped_tests
-
-RSpec.describe "Capybara::Session with firefox" do
-  include Capybara::SpecHelper
-  include_examples  "Capybara::Session", TestSessions::SeleniumMarionette, :selenium_marionette
-  include_examples  Capybara::RSpecMatchers, TestSessions::SeleniumMarionette, :selenium_marionette
-end
-
-RSpec.describe Capybara::Selenium::Driver do
-  before do
-    @driver = Capybara::Selenium::Driver.new(TestApp, browser: :firefox, options: browser_options)
-  end
-
-  describe '#quit' do
-    it "should reset browser when quit" do
-      expect(@driver.browser).to be
-      @driver.quit
-      # access instance variable directly so we don't create a new browser instance
-      expect(@driver.instance_variable_get(:@browser)).to be_nil
-    end
-
-    context "with errors" do
-      before do
-        @original_browser = @driver.browser
-      end
-      after do
-        # Ensure browser is actually quit so we don't leave hanging processe
-        RSpec::Mocks.space.proxy_for(@original_browser).reset
-        @original_browser.quit
-      end
-
-      it "warns UnknownError returned during quit because the browser is probably already gone" do
-        expect_any_instance_of(Capybara::Selenium::Driver).to receive(:warn).with(/random message/)
-        allow(@driver.browser).to(
-          receive(:quit)
-          .and_raise(Selenium::WebDriver::Error::UnknownError, "random message")
-        )
-
-        expect { @driver.quit }.not_to raise_error
-        expect(@driver.instance_variable_get(:@browser)).to be_nil
-      end
-
-      it "ignores silenced UnknownError returned during quit because the browser is almost definitely already gone" do
-        expect_any_instance_of(Capybara::Selenium::Driver).not_to receive(:warn)
-        allow(@driver.browser).to(
-          receive(:quit)
-          .and_raise(Selenium::WebDriver::Error::UnknownError, "Error communicating with the remote browser")
-        )
-
-        expect { @driver.quit }.not_to raise_error
-        expect(@driver.instance_variable_get(:@browser)).to be_nil
-      end
-    end
-  end
-
-  context "storage" do
-    describe "#reset!" do
-      it "does not clear either storage by default" do
-        @session = TestSessions::SeleniumMarionette
-        @session.visit('/with_js')
-        @session.find(:css, '#set-storage').click
-        @session.reset!
-        @session.visit('/with_js')
-        expect(@session.driver.browser.local_storage.keys).not_to be_empty
-        expect(@session.driver.browser.session_storage.keys).not_to be_empty
-      end
-
-      it "clears storage when set" do
-        @session = Capybara::Session.new(:selenium_marionette_clear_storage, TestApp)
-        @session.visit('/with_js')
-        @session.find(:css, '#set-storage').click
-        @session.reset!
-        @session.visit('/with_js')
-        expect(@session.driver.browser.local_storage.keys).to be_empty
-        expect(@session.driver.browser.session_storage.keys).to be_empty
-      end
-    end
-  end
-
-  context "#refresh" do
-    def extract_results(session)
-      expect(session).to have_xpath("//pre[@id='results']")
-      YAML.load Nokogiri::HTML(session.body).xpath("//pre[@id='results']").first.inner_html.lstrip
-    end
-
-    it "can repost by accepting confirm" do
-      @session = TestSessions::SeleniumMarionette
-      @session.visit('/form')
-      @session.select('Sweden', from: 'form_region')
-      @session.click_button('awesome')
-      expect do
-        @session.accept_confirm(wait: 0.1) do
-          @session.refresh
-          sleep 2
-        end
-      end.to change { extract_results(@session)['post_count'] }.by(1)
-    end
-  end
-end