capybara 3.8.1 → 3.33.0

data/lib/capybara.rb

@@ -5,6 +5,7 @@ require 'nokogiri'
 require 'xpath'
 require 'forwardable'
 require 'capybara/config'
+require 'capybara/registration_container'
 
 module Capybara
   class CapybaraError < StandardError; end
@@ -38,6 +39,8 @@ module Capybara
     #   See {Capybara.configure}
     # @!method javascript_driver
     #   See {Capybara.configure}
+    # @!method allow_gumbo
+    #   See {Capybara.configure}
     Config::OPTIONS.each do |method|
       def_delegators :config, method, "#{method}="
     end
@@ -64,35 +67,47 @@ module Capybara
     #       config.app_host   = 'http://www.google.com'
     #     end
     #
-    # === Configurable options
-    #
-    # [app_host = String/nil]             The default host to use when giving a relative URL to visit, must be a valid URL e.g. http://www.example.com
-    # [always_include_port = Boolean]     Whether the Rack server's port should automatically be inserted into every visited URL unless another port is explicitly specified (Default: false)
-    # [asset_host = String]               Where dynamic assets are hosted - will be prepended to relative asset locations if present (Default: nil)
-    # [run_server = Boolean]              Whether to start a Rack server for the given Rack app (Default: true)
-    # [raise_server_errors = Boolean]     Should errors raised in the server be raised in the tests? (Default: true)
-    # [server_errors = Array\<Class\>]    Error classes that should be raised in the tests if they are raised in the server and Capybara.raise_server_errors is true (Default: [StandardError])
-    # [default_selector = :css/:xpath]    Methods which take a selector use the given type by default (Default: :css)
-    # [default_max_wait_time = Numeric]   The maximum number of seconds to wait for asynchronous processes to finish (Default: 2)
-    # [ignore_hidden_elements = Boolean]  Whether to ignore hidden elements on the page (Default: true)
-    # [automatic_reload = Boolean]        Whether to automatically reload elements as Capybara is waiting (Default: true)
-    # [save_path = String]  Where to put pages saved through save_(page|screenshot), save_and_open_(page|screenshot) (Default: Dir.pwd)
-    # [automatic_label_click = Boolean]   Whether Node#choose, Node#check, Node#uncheck will attempt to click the associated label element if the checkbox/radio button are non-visible (Default: false)
-    # [enable_aria_label = Boolean]  Whether fields, links, and buttons will match against aria-label attribute (Default: false)
-    # [reuse_server = Boolean]  Reuse the server thread between multiple sessions using the same app object (Default: true)
-    # [threadsafe = Boolean]  Whether sessions can be configured individually (Default: false)
-    # [server = Symbol]  The name of the registered server to use when running the app under test (Default: :webrick)
-    # [default_set_options = Hash]  The default options passed to Node::set (Default: {})
-    # [test_id = Symbol/String/nil] Optional attribute to match locator aginst with builtin selectors along with id (Default: nil)
-    # [predicates_wait = Boolean]  Whether Capybaras predicate matchers use waiting behavior by default (Default: true)
-    # [default_normalize_ws = Boolean] Whether text predicates and matchers use normalize whitespace behaviour (Default: false)
-    #
-    # === DSL Options
-    #
-    # when using capybara/dsl, the following options are also available:
-    #
-    # [default_driver = Symbol]           The name of the driver to use by default. (Default: :rack_test)
-    # [javascript_driver = Symbol]        The name of a driver to use for JavaScript enabled tests. (Default: :selenium)
+    # #### Configurable options
+    #
+    # - **allow_gumbo** (Boolean = `false`) - When `nokogumbo` is available, whether it will be used to parse HTML strings.
+    # - **always_include_port** (Boolean = `false`) - Whether the Rack server's port should automatically be inserted into every visited URL
+    #   unless another port is explicitly specified.
+    # - **app_host** (String, `nil`) - The default host to use when giving a relative URL to visit, must be a valid URL e.g. `http://www.example.com`.
+    # - **asset_host** (String = `nil`) - Where dynamic assets are hosted - will be prepended to relative asset locations if present.
+    # - **automatic_label_click** (Boolean = `false`) - Whether {Capybara::Node::Element#choose Element#choose}, {Capybara::Node::Element#check Element#check},
+    #   {Capybara::Node::Element#uncheck Element#uncheck} will attempt to click the associated `<label>` element if the checkbox/radio button are non-visible.
+    # - **automatic_reload** (Boolean = `true`) - Whether to automatically reload elements as Capybara is waiting.
+    # - **default_max_wait_time** (Numeric = `2`) - The maximum number of seconds to wait for asynchronous processes to finish.
+    # - **default_normalize_ws** (Boolean = `false`) - Whether text predicates and matchers use normalize whitespace behavior.
+    # - **default_selector** (`:css`, `:xpath` = `:css`) - Methods which take a selector use the given type by default. See also {Capybara::Selector}.
+    # - **default_set_options** (Hash = `{}`) - The default options passed to {Capybara::Node::Element#set Element#set}.
+    # - **enable_aria_label** (Boolean = `false`) - Whether fields, links, and buttons will match against `aria-label` attribute.
+    # - **enable_aria_role** (Boolean = `false`) - Selectors will check for relevant aria role (currently only `button`).
+    # - **exact** (Boolean = `false`) - Whether locators are matched exactly or with substrings. Only affects selector conditions
+    #   written using the `XPath#is` method.
+    # - **exact_text** (Boolean = `false`) - Whether the text matchers and `:text` filter match exactly or on substrings.
+    # - **ignore_hidden_elements** (Boolean = `true`) - Whether to ignore hidden elements on the page.
+    # - **match** (`:one`, `:first`, `:prefer_exact`, `:smart` = `:smart`) - The matching strategy to find nodes.
+    # - **predicates_wait** (Boolean = `true`) - Whether Capybara's predicate matchers use waiting behavior by default.
+    # - **raise_server_errors** (Boolean = `true`) - Should errors raised in the server be raised in the tests?
+    # - **reuse_server** (Boolean = `true`) - Whether to reuse the server thread between multiple sessions using the same app object.
+    # - **run_server** (Boolean = `true`) - Whether to start a Rack server for the given Rack app.
+    # - **save_path** (String = `Dir.pwd`) - Where to put pages saved through {Capybara::Session#save_page save_page}, {Capybara::Session#save_screenshot save_screenshot},
+    #   {Capybara::Session#save_and_open_page save_and_open_page}, or {Capybara::Session#save_and_open_screenshot save_and_open_screenshot}.
+    # - **server** (Symbol = `:default` (which uses puma)) - The name of the registered server to use when running the app under test.
+    # - **server_port** (Integer) - The port Capybara will run the application server on, if not specified a random port will be used.
+    # - **server_errors** (Array\<Class> = `[Exception]`) - Error classes that should be raised in the tests if they are raised in the server
+    #   and {configure raise_server_errors} is `true`.
+    # - **test_id** (Symbol, String, `nil` = `nil`) - Optional attribute to match locator against with built-in selectors along with id.
+    # - **threadsafe** (Boolean = `false`) - Whether sessions can be configured individually.
+    # - **w3c_click_offset** (Boolean = 'false') - Whether click offsets should be from element center (true) or top left (false)
+    #
+    # #### DSL Options
+    #
+    # When using `capybara/dsl`, the following options are also available:
+    #
+    # - **default_driver** (Symbol = `:rack_test`) - The name of the driver to use by default.
+    # - **javascript_driver** (Symbol = `:selenium`) - The name of a driver to use for JavaScript enabled tests.
     #
     def configure
       yield config
@@ -112,7 +127,7 @@ module Capybara
     # @yieldreturn [Capybara::Driver::Base]   A Capybara driver instance
     #
     def register_driver(name, &block)
-      drivers[name] = block
+      drivers.send(:register, name, block)
     end
 
     ##
@@ -131,7 +146,7 @@ module Capybara
     # @yieldparam host                        The host/ip to bind to
     #
     def register_server(name, &block)
-      servers[name.to_sym] = block
+      servers.send(:register, name.to_sym, block)
     end
 
     ##
@@ -162,8 +177,8 @@ module Capybara
     # @param [Symbol] name    The name of the selector to add
     # @yield                  A block executed in the context of the new {Capybara::Selector}
     #
-    def add_selector(name, &block)
-      Capybara::Selector.add(name, &block)
+    def add_selector(name, **options, &block)
+      Capybara::Selector.add(name, **options, &block)
     end
 
     ##
@@ -173,7 +188,7 @@ module Capybara
     # button style (a class) might look like this
     #
     #     Capybara.modify_selector(:button) do
-    #       filter (:style, valid_values: [:primary, :secondary]) { |node, style| node[:class].split.include? "btn-#{style}" }
+    #       filter (:btn_style, valid_values: [:primary, :secondary]) { |node, style| node[:class].split.include? "btn-#{style}" }
     #     end
     #
     #
@@ -185,11 +200,11 @@ module Capybara
     end
 
     def drivers
-      @drivers ||= {}
+      @drivers ||= RegistrationContainer.new
     end
 
     def servers
-      @servers ||= {}
+      @servers ||= RegistrationContainer.new
     end
 
     # Wraps the given string, which should contain an HTML document or fragment
@@ -198,15 +213,13 @@ module Capybara
     # any string containing HTML in the exact same way you would query the current document in a Capybara
     # session.
     #
-    # Example: A single element
-    #
+    # @example A single element
     #     node = Capybara.string('<a href="foo">bar</a>')
     #     anchor = node.first('a')
     #     anchor[:href] #=> 'foo'
     #     anchor.text #=> 'bar'
     #
-    # Example: Multiple elements
-    #
+    # @example Multiple elements
     #     node = Capybara.string <<-HTML
     #       <ul>
     #         <li id="home">Home</li>
@@ -294,12 +307,12 @@ module Capybara
 
     ##
     #
-    # The current Capybara::Session based on what is set as Capybara.app and Capybara.current_driver
+    # The current {Capybara::Session} based on what is set as {app} and {current_driver}.
     #
     # @return [Capybara::Session]     The currently used session
     #
     def current_session
-      session_pool["#{current_driver}:#{session_name}:#{app.object_id}"] ||= Capybara::Session.new(current_driver, app)
+      specified_session || session_pool["#{current_driver}:#{session_name}:#{app.object_id}"]
     end
 
     ##
@@ -337,22 +350,31 @@ module Capybara
 
     ##
     #
-    # Yield a block using a specific session name.
+    # Yield a block using a specific session name or {Capybara::Session} instance.
     #
-    def using_session(name)
+    def using_session(name_or_session, &block)
+      previous_session = current_session
       previous_session_info = {
+        specified_session: specified_session,
         session_name: session_name,
         current_driver: current_driver,
         app: app
       }
-      self.session_name = name
-      yield
-    ensure
-      self.session_name = previous_session_info[:session_name]
-      if threadsafe
-        self.current_driver = previous_session_info[:current_driver]
-        self.app = previous_session_info[:app]
+      self.specified_session = self.session_name = nil
+      if name_or_session.is_a? Capybara::Session
+        self.specified_session = name_or_session
+      else
+        self.session_name = name_or_session
       end
+
+      if block.arity.zero?
+        yield
+      else
+        yield current_session, previous_session
+      end
+    ensure
+      self.session_name, self.specified_session = previous_session_info.values_at(:session_name, :specified_session)
+      self.current_driver, self.app = previous_session_info.values_at(:current_driver, :app) if threadsafe
     end
 
     ##
@@ -363,9 +385,26 @@ module Capybara
     # @return [Nokogiri::HTML::Document]      HTML document
     #
     def HTML(html) # rubocop:disable Naming/MethodName
-      Nokogiri::HTML(html).tap do |document|
-        document.xpath('//textarea').each do |textarea|
-          textarea['_capybara_raw_value'] = textarea.content.sub(/\A\n/, '')
+      if Nokogiri.respond_to?(:HTML5) && Capybara.allow_gumbo # Nokogumbo installed and allowed for use
+        Nokogiri::HTML5(html).tap do |document|
+          document.xpath('//template').each do |template|
+            # template elements content is not part of the document
+            template.inner_html = ''
+          end
+          document.xpath('//textarea').each do |textarea|
+            # The Nokogumbo HTML5 parser already returns spec compliant contents
+            textarea['_capybara_raw_value'] = textarea.content
+          end
+        end
+      else
+        Nokogiri::HTML(html).tap do |document|
+          document.xpath('//template').each do |template|
+            # template elements content is not part of the document
+            template.inner_html = ''
+          end
+          document.xpath('//textarea').each do |textarea|
+            textarea['_capybara_raw_value'] = textarea.content.delete_prefix("\n")
+          end
         end
       end
     end
@@ -381,7 +420,25 @@ module Capybara
     end
 
     def session_pool
-      @session_pool ||= {}
+      @session_pool ||= Hash.new do |hash, name|
+        hash[name] = Capybara::Session.new(current_driver, app)
+      end
+    end
+
+    def specified_session
+      if threadsafe
+        Thread.current['capybara_specified_session']
+      else
+        @specified_session ||= nil
+      end
+    end
+
+    def specified_session=(session)
+      if threadsafe
+        Thread.current['capybara_specified_session'] = session
+      else
+        @specified_session = session
+      end
     end
   end
 
@@ -433,41 +490,8 @@ module Capybara
   require 'capybara/selenium/driver'
 end
 
-Capybara.register_server :default do |app, port, _host|
-  Capybara.run_default_server(app, port)
-end
-
-Capybara.register_server :webrick do |app, port, host, **options|
-  require 'rack/handler/webrick'
-  Rack::Handler::WEBrick.run(app, { Host: host, Port: port, AccessLog: [], Logger: WEBrick::Log.new(nil, 0) }.merge(options))
-end
-
-Capybara.register_server :puma do |app, port, host, **options|
-  begin
-    require 'rack/handler/puma'
-  rescue LoadError
-    raise LoadError, 'Capybara is unable to load `puma` for its server, please add `puma` to your project or specify a different server via something like `Capybara.server = :webrick`.'
-  else
-    unless Rack::Handler::Puma.respond_to?(:config)
-      raise LoadError, 'Capybara requires `puma` version 3.8.0 or higher, please upgrade `puma` or register and specify your own server block'
-    end
-  end
-  # If we just run the Puma Rack handler it installs signal handlers which prevent us from being able to interrupt tests.
-  # Therefore construct and run the Server instance ourselves.
-  # Rack::Handler::Puma.run(app, { Host: host, Port: port, Threads: "0:4", workers: 0, daemon: false }.merge(options))
-
-  conf = Rack::Handler::Puma.config(app, { Host: host, Port: port, Threads: '0:4', workers: 0, daemon: false }.merge(options))
-  events = conf.options[:Silent] ? ::Puma::Events.strings : ::Puma::Events.stdio
-
-  events.log 'Capybara starting Puma...'
-  events.log "* Version #{Puma::Const::PUMA_VERSION} , codename: #{Puma::Const::CODE_NAME}"
-  events.log "* Min threads: #{conf.options[:min_threads]}, max threads: #{conf.options[:max_threads]}"
-
-  Puma::Server.new(conf.app, events, conf.options).tap do |s|
-    s.binder.parse conf.options[:binds], s.events
-    s.min_threads, s.max_threads = conf.options[:min_threads], conf.options[:max_threads]
-  end.run.join
-end
+require 'capybara/registrations/servers'
+require 'capybara/registrations/drivers'
 
 Capybara.configure do |config|
   config.always_include_port = false
@@ -482,33 +506,16 @@ Capybara.configure do |config|
   config.exact = false
   config.exact_text = false
   config.raise_server_errors = true
-  config.server_errors = [StandardError]
+  config.server_errors = [Exception]
   config.visible_text_only = false
   config.automatic_label_click = false
   config.enable_aria_label = false
+  config.enable_aria_role = false
   config.reuse_server = true
   config.default_set_options = {}
   config.test_id = nil
   config.predicates_wait = true
   config.default_normalize_ws = false
-end
-
-Capybara.register_driver :rack_test do |app|
-  Capybara::RackTest::Driver.new(app)
-end
-
-Capybara.register_driver :selenium do |app|
-  Capybara::Selenium::Driver.new(app)
-end
-
-Capybara.register_driver :selenium_chrome do |app|
-  Capybara::Selenium::Driver.new(app, browser: :chrome)
-end
-
-Capybara.register_driver :selenium_chrome_headless do |app|
-  Capybara::Selenium::Driver.load_selenium
-  browser_options = ::Selenium::WebDriver::Chrome::Options.new
-  browser_options.args << '--headless'
-  browser_options.args << '--disable-gpu' if Gem.win_platform?
-  Capybara::Selenium::Driver.new(app, browser: :chrome, options: browser_options)
+  config.allow_gumbo = false
+  config.w3c_click_offset = false
 end

data/spec/basic_node_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 RSpec.describe Capybara do
   describe '.string' do
     let :string do
-      Capybara.string <<-STRING
+      described_class.string <<-STRING
         <html>
           <head>
             <title>simple_node</title>
@@ -52,7 +52,7 @@ RSpec.describe Capybara do
     end
 
     it 'allows using custom matchers' do
-      Capybara.add_selector :lifeform do
+      described_class.add_selector :lifeform do
         xpath { |name| ".//option[contains(.,'#{name}')]" }
       end
       expect(string).to have_selector(:id, 'page')
@@ -62,7 +62,7 @@ RSpec.describe Capybara do
     end
 
     it 'allows custom matcher using css' do
-      Capybara.add_selector :section do
+      described_class.add_selector :section do
         css { |css_class| "section .#{css_class}" }
       end
       expect(string).to     have_selector(:section, 'subsection')
@@ -110,6 +110,17 @@ RSpec.describe Capybara do
       expect(string.find('//form/input[@name="meh"]')).not_to be_disabled
     end
 
+    it 'drops illegal fragments when using gumbo' do
+      skip 'libxml is less strict than Gumbo' unless Nokogiri.respond_to?(:HTML5)
+      expect(described_class.string('<td>1</td>')).not_to have_css('td')
+    end
+
+    it 'can disable use of gumbo' do
+      skip "Test doesn't make sense unlesss nokogumbo is loaded" unless Nokogiri.respond_to?(:HTML5)
+      described_class.allow_gumbo = false
+      expect(described_class.string('<td>1</td>')).to have_css('td')
+    end
+
     describe '#title' do
       it 'returns the page title' do
         expect(string.title).to eq('simple_node')

data/spec/capybara_spec.rb

@@ -4,20 +4,20 @@ require 'spec_helper'
 
 RSpec.describe Capybara do
   describe 'default_max_wait_time' do
-    after do
-      Capybara.default_max_wait_time = @previous_default_time
-    end
+    before { @previous_default_time = described_class.default_max_wait_time }
+
+    after { described_class.default_max_wait_time = @previous_default_time } # rubocop:disable RSpec/InstanceVariable
 
     it 'should be changeable' do
-      @previous_default_time = Capybara.default_max_wait_time
-      Capybara.default_max_wait_time = 5
-      expect(Capybara.default_max_wait_time).to eq(5)
+      expect(described_class.default_max_wait_time).not_to eq(5)
+      described_class.default_max_wait_time = 5
+      expect(described_class.default_max_wait_time).to eq(5)
     end
   end
 
   describe '.register_driver' do
     it 'should add a new driver' do
-      Capybara.register_driver :schmoo do |app|
+      described_class.register_driver :schmoo do |app|
         Capybara::RackTest::Driver.new(app)
       end
       session = Capybara::Session.new(:schmoo, TestApp)
@@ -28,85 +28,85 @@ RSpec.describe Capybara do
 
   describe '.register_server' do
     it 'should add a new server' do
-      Capybara.register_server :blob do |_app, _port, _host|
+      described_class.register_server :blob do |_app, _port, _host|
         # do nothing
       end
 
-      expect(Capybara.servers).to have_key(:blob)
+      expect(described_class.servers[:blob]).to be_truthy
     end
   end
 
   describe '.server' do
     after do
-      Capybara.server = :default
+      described_class.server = :default
     end
 
     it 'should default to a proc that calls run_default_server' do
       mock_app = Object.new
-      allow(Capybara).to receive(:run_default_server).and_return(true)
-      Capybara.server.call(mock_app, 8000)
-      expect(Capybara).to have_received(:run_default_server).with(mock_app, 8000)
+      allow(described_class).to receive(:run_default_server).and_return(true)
+      described_class.server.call(mock_app, 8000)
+      expect(described_class).to have_received(:run_default_server).with(mock_app, 8000)
     end
 
     it 'should return a custom server proc' do
       server = ->(_app, _port) {}
-      Capybara.register_server :custom, &server
-      Capybara.server = :custom
-      expect(Capybara.server).to eq(server)
+      described_class.register_server :custom, &server
+      described_class.server = :custom
+      expect(described_class.server).to eq(server)
     end
 
     it 'should have :webrick registered' do
-      expect(Capybara.servers[:webrick]).not_to be_nil
+      expect(described_class.servers[:webrick]).not_to be_nil
     end
 
     it 'should have :puma registered' do
-      expect(Capybara.servers[:puma]).not_to be_nil
+      expect(described_class.servers[:puma]).not_to be_nil
     end
   end
 
   describe 'server=' do
     after do
-      Capybara.server = :default
+      described_class.server = :default
     end
 
     it 'accepts a proc' do
       server = ->(_app, _port) {}
-      Capybara.server = server
-      expect(Capybara.server).to eq server
+      described_class.server = server
+      expect(described_class.server).to eq server
     end
   end
 
   describe 'app_host' do
     after do
-      Capybara.app_host = nil
+      described_class.app_host = nil
     end
 
     it 'should warn if not a valid URL' do
-      expect { Capybara.app_host = 'www.example.com' }.to raise_error(ArgumentError, /Capybara\.app_host should be set to a url/)
+      expect { described_class.app_host = 'www.example.com' }.to raise_error(ArgumentError, /Capybara\.app_host should be set to a url/)
     end
 
     it 'should not warn if a valid URL' do
-      expect { Capybara.app_host = 'http://www.example.com' }.not_to raise_error
+      expect { described_class.app_host = 'http://www.example.com' }.not_to raise_error
     end
 
     it 'should not warn if nil' do
-      expect { Capybara.app_host = nil }.not_to raise_error
+      expect { described_class.app_host = nil }.not_to raise_error
     end
   end
 
   describe 'default_host' do
     around do |test|
-      old_default = Capybara.default_host
+      old_default = described_class.default_host
       test.run
-      Capybara.default_host = old_default
+      described_class.default_host = old_default
     end
 
     it 'should raise if not a valid URL' do
-      expect { Capybara.default_host = 'www.example.com' }.to raise_error(ArgumentError, /Capybara\.default_host should be set to a url/)
+      expect { described_class.default_host = 'www.example.com' }.to raise_error(ArgumentError, /Capybara\.default_host should be set to a url/)
     end
 
     it 'should not warn if a valid URL' do
-      expect { Capybara.default_host = 'http://www.example.com' }.not_to raise_error
+      expect { described_class.default_host = 'http://www.example.com' }.not_to raise_error
     end
   end
 end

data/spec/css_builder_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# rubocop:disable RSpec/InstanceVariable
+RSpec.describe Capybara::Selector::CSSBuilder do
+  let :builder do
+    ::Capybara::Selector::CSSBuilder.new(@css)
+  end
+
+  context 'add_attribute_conditions' do
+    it 'adds a single string condition to a single selector' do
+      @css = 'div'
+      selector = builder.add_attribute_conditions(random: 'abc')
+      expect(selector).to eq %(div[random='abc'])
+    end
+
+    it 'adds multiple string conditions to a single selector' do
+      @css = 'div'
+      selector = builder.add_attribute_conditions(random: 'abc', other: 'def')
+      expect(selector).to eq %(div[random='abc'][other='def'])
+    end
+
+    it 'adds a single string condition to a multiple selector' do
+      @css = 'div, ul'
+      selector = builder.add_attribute_conditions(random: 'abc')
+      expect(selector).to eq %(div[random='abc'], ul[random='abc'])
+    end
+
+    it 'adds multiple string conditions to a multiple selector' do
+      @css = 'div, ul'
+      selector = builder.add_attribute_conditions(random: 'abc', other: 'def')
+      expect(selector).to eq %(div[random='abc'][other='def'], ul[random='abc'][other='def'])
+    end
+
+    it 'adds simple regexp conditions to a single selector' do
+      @css = 'div'
+      selector = builder.add_attribute_conditions(random: /abc/, other: /def/)
+      expect(selector).to eq %(div[random*='abc'][other*='def'])
+    end
+
+    it 'adds wildcard regexp conditions to a single selector' do
+      @css = 'div'
+      selector = builder.add_attribute_conditions(random: /abc.*def/, other: /def.*ghi/)
+      expect(selector).to eq %(div[random*='abc'][random*='def'][other*='def'][other*='ghi'])
+    end
+
+    it 'adds alternated regexp conditions to a single selector' do
+      @css = 'div'
+      selector = builder.add_attribute_conditions(random: /abc|def/, other: /def|ghi/)
+      expect(selector).to eq %(div[random*='abc'][other*='def'], div[random*='abc'][other*='ghi'], div[random*='def'][other*='def'], div[random*='def'][other*='ghi'])
+    end
+
+    it 'adds alternated regexp conditions to a multiple selector' do
+      @css = 'div,ul'
+      selector = builder.add_attribute_conditions(other: /def.*ghi|jkl/)
+      expect(selector).to eq %(div[other*='def'][other*='ghi'], div[other*='jkl'], ul[other*='def'][other*='ghi'], ul[other*='jkl'])
+    end
+
+    it "returns original selector when regexp can't be substringed" do
+      @css = 'div'
+      selector = builder.add_attribute_conditions(other: /.+/)
+      expect(selector).to eq 'div'
+    end
+
+    context ':class' do
+      it 'handles string with CSS .' do
+        @css = 'a'
+        selector = builder.add_attribute_conditions(class: 'my_class')
+        expect(selector).to eq 'a.my_class'
+      end
+
+      it 'handles negated string with CSS .' do
+        @css = 'a'
+        selector = builder.add_attribute_conditions(class: '!my_class')
+        expect(selector).to eq 'a:not(.my_class)'
+      end
+
+      it 'handles array of string with CSS .' do
+        @css = 'a'
+        selector = builder.add_attribute_conditions(class: %w[my_class my_other_class])
+        expect(selector).to eq 'a.my_class.my_other_class'
+      end
+
+      it 'handles array of string with CSS . when negated included' do
+        @css = 'a'
+        selector = builder.add_attribute_conditions(class: %w[my_class !my_other_class])
+        expect(selector).to eq 'a.my_class:not(.my_other_class)'
+      end
+    end
+
+    context ':id' do
+      it 'handles string with CSS #' do
+        @css = 'ul'
+        selector = builder.add_attribute_conditions(id: 'my_id')
+        expect(selector).to eq 'ul#my_id'
+      end
+    end
+  end
+end
+# rubocop:enable RSpec/InstanceVariable