mega-max-rb 0.0.1

data/capybara-3.40.0/lib/capybara/spec/session/node_wrapper_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+class NodeWrapper
+  def initialize(element); @element = element end
+  def to_capybara_node(); @element end
+end
+
+Capybara::SpecHelper.spec '#to_capybara_node' do
+  before do
+    @session.visit('/with_html')
+  end
+
+  it 'should support have_xxx expectations' do
+    para = NodeWrapper.new(@session.find(:css, '#first'))
+    expect(para).to have_link('ullamco')
+  end
+
+  it 'should support within' do
+    para = NodeWrapper.new(@session.find(:css, '#first'))
+    expect(@session).to have_css('#second')
+    @session.within(para) do
+      expect(@session).to have_link('ullamco')
+      expect(@session).not_to have_css('#second')
+    end
+  end
+
+  it 'should generate correct errors' do
+    para = NodeWrapper.new(@session.find(:css, '#first'))
+    expect do
+      expect(para).to have_text('Header Class Test One')
+    end.to raise_error(/^expected to find text "Header Class Test One" in "Lore/)
+    expect do
+      expect(para).to have_css('#second')
+    end.to raise_error(/^expected to find css "#second" within #<Capybara::Node::Element/)
+    expect do
+      expect(para).to have_link(href: %r{/without_simple_html})
+    end.to raise_error(%r{^expected to find link with href matching /\\/without_simple_html/ within #<Capybara::Node::Element})
+  end
+end

data/capybara-3.40.0/lib/capybara/spec/session/refresh_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# NOTE: This file uses `sleep` to sync up parts of the tests. This is only implemented like this
+# because of the methods being tested. In tests using Capybara this type of behavior should be implemented
+# using Capybara provided assertions with builtin waiting behavior.
+
+Capybara::SpecHelper.spec '#refresh' do
+  it 'reload the page' do
+    @session.visit('/form')
+    expect(@session).to have_select('form_locale', selected: 'English')
+    @session.select('Swedish', from: 'form_locale')
+    expect(@session).to have_select('form_locale', selected: 'Swedish')
+    @session.refresh
+    expect(@session).to have_select('form_locale', selected: 'English')
+  end
+
+  it 'raises any errors caught inside the server', requires: [:server] do
+    quietly { @session.visit('/error') }
+    expect do
+      @session.refresh
+    end.to raise_error(TestApp::TestAppError)
+  end
+
+  it 'it reposts' do
+    @session.visit('/form')
+    @session.select('Sweden', from: 'form_region')
+    @session.click_button('awesome')
+    sleep 2
+    expect do
+      @session.refresh
+      sleep 2
+    end.to change { extract_results(@session)['post_count'] }.by(1)
+  end
+end

data/capybara-3.40.0/lib/capybara/spec/session/reset_session_spec.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+Capybara::SpecHelper.spec '#reset_session!' do
+  it 'removes cookies from current domain' do
+    @session.visit('/set_cookie')
+    @session.visit('/get_cookie')
+    expect(@session).to have_content('test_cookie')
+
+    @session.reset_session!
+    @session.visit('/get_cookie')
+    expect(@session.body).not_to include('test_cookie')
+  end
+
+  it 'removes ALL cookies', requires: [:server] do
+    domains = ['localhost', '127.0.0.1']
+    domains.each do |domain|
+      @session.visit("http://#{domain}:#{@session.server.port}/set_cookie")
+      @session.visit("http://#{domain}:#{@session.server.port}/get_cookie")
+      expect(@session).to have_content('test_cookie')
+    end
+    @session.reset_session!
+    domains.each do |domain|
+      @session.visit("http://#{domain}:#{@session.server.port}/get_cookie")
+      expect(@session.body).not_to include('test_cookie')
+    end
+  end
+
+  it 'resets current url, host, path' do
+    @session.visit '/foo'
+    expect(@session.current_url).not_to be_empty
+    expect(@session.current_host).not_to be_empty
+    expect(@session.current_path).to eq('/foo')
+
+    @session.reset_session!
+    expect(@session.current_url).to satisfy('be a blank url') { |url| [nil, '', 'about:blank'].include? url }
+    expect(@session.current_path).to satisfy('be a blank path') { |path| ['', nil].include? path }
+    expect(@session.current_host).to be_nil
+  end
+
+  it 'resets page body' do
+    @session.visit('/with_html')
+    expect(@session).to have_content('This is a test')
+    expect(@session.find('.//h1').text).to include('This is a test')
+
+    @session.reset_session!
+    expect(@session.body).not_to include('This is a test')
+    expect(@session).to have_no_selector('.//h1')
+  end
+
+  it 'is synchronous' do
+    @session.visit('/with_slow_unload')
+    expect(@session).to have_selector(:css, 'div')
+    @session.reset_session!
+    expect(@session).to have_no_selector :xpath, '/html/body/*', wait: false
+  end
+
+  it 'handles modals during unload', requires: [:modals] do
+    @session.visit('/with_unload_alert')
+    expect(@session).to have_selector(:css, 'div')
+    expect { @session.reset_session! }.not_to raise_error
+    expect(@session).to have_no_selector :xpath, '/html/body/*', wait: false
+  end
+
+  it 'handles already open modals', requires: [:modals] do
+    @session.visit('/with_unload_alert')
+    @session.click_link('Go away')
+    expect { @session.reset_session! }.not_to raise_error
+    expect(@session).to have_no_selector :xpath, '/html/body/*', wait: false
+  end
+
+  it 'raises any standard errors caught inside the server', requires: [:server] do
+    quietly { @session.visit('/error') }
+    expect do
+      @session.reset_session!
+    end.to raise_error(TestApp::TestAppError)
+    @session.visit('/')
+    expect(@session.current_path).to eq('/')
+  end
+
+  it 'closes extra windows', requires: [:windows] do
+    @session.visit('/with_html')
+    @session.open_new_window
+    @session.open_new_window
+    expect(@session.windows.size).to eq 3
+    @session.reset_session!
+    expect(@session.windows.size).to eq 1
+  end
+
+  it 'closes extra windows when not on the first window', requires: [:windows] do
+    @session.visit('/with_html')
+    @session.switch_to_window(@session.open_new_window)
+    @session.open_new_window
+    expect(@session.windows.size).to eq 3
+    @session.reset_session!
+    expect(@session.windows.size).to eq 1
+  end
+
+  it 'does not block opening a new window after a frame was switched to and not switched back', requires: [:windows] do
+    @session.visit('/with_iframe?id=test_iframe&url=/')
+    @session.switch_to_frame(@session.find(:frame, 'test_iframe'))
+    within_window_test = lambda do
+      @session.within_window(@session.open_new_window) do
+        @session.visit('/')
+      end
+    end
+    expect(&within_window_test).to raise_error(Capybara::ScopeError)
+    @session.reset_session!
+    expect(&within_window_test).not_to raise_error
+  end
+
+  context 'When reuse_server == false' do
+    let!(:orig_reuse_server) { Capybara.reuse_server }
+
+    before do
+      Capybara.reuse_server = false
+    end
+
+    after do
+      Capybara.reuse_server = orig_reuse_server
+    end
+
+    it 'raises any standard errors caught inside the server during a second session', requires: [:server] do
+      Capybara.using_driver(@session.mode) do
+        Capybara.using_session(:another_session) do
+          another_session = Capybara.current_session
+          quietly { another_session.visit('/error') }
+          expect do
+            another_session.reset_session!
+          end.to raise_error(TestApp::TestAppError)
+          another_session.visit('/')
+          expect(another_session.current_path).to eq('/')
+        end
+      end
+    end
+  end
+
+  it 'raises configured errors caught inside the server', requires: [:server] do
+    prev_errors = Capybara.server_errors.dup
+
+    Capybara.server_errors = [LoadError]
+    quietly { @session.visit('/error') }
+    expect do
+      @session.reset_session!
+    end.not_to raise_error
+
+    quietly { @session.visit('/load_error') }
+    expect do
+      @session.reset_session!
+    end.to raise_error(LoadError)
+
+    Capybara.server_errors = prev_errors
+  end
+
+  it 'ignores server errors when `Capybara.raise_server_errors = false`', requires: [:server] do
+    Capybara.raise_server_errors = false
+    quietly { @session.visit('/error') }
+    @session.reset_session!
+    @session.visit('/')
+    expect(@session.current_path).to eq('/')
+  end
+end

data/capybara-3.40.0/lib/capybara/spec/session/response_code_spec.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+Capybara::SpecHelper.spec '#status_code' do
+  it 'should return response codes', requires: [:status_code] do
+    @session.visit('/with_simple_html')
+    expect(@session.status_code).to eq(200)
+  end
+end

data/capybara-3.40.0/lib/capybara/spec/session/save_and_open_page_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'launchy'
+
+Capybara::SpecHelper.spec '#save_and_open_page' do
+  before do
+    @session.visit '/foo'
+  end
+
+  after do
+    Dir.glob('capybara-*.html').each do |file|
+      FileUtils.rm(file)
+    end
+  end
+
+  it 'sends open method to launchy' do
+    allow(Launchy).to receive(:open)
+    @session.save_and_open_page
+    expect(Launchy).to have_received(:open).with(/capybara-\d+\.html/)
+  end
+end

data/capybara-3.40.0/lib/capybara/spec/session/save_and_open_screenshot_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'launchy'
+
+Capybara::SpecHelper.spec '#save_and_open_screenshot' do
+  before do
+    @session.visit '/'
+  end
+
+  it 'opens file from the default directory', requires: [:screenshot] do
+    expected_file_regex = /capybara-\d+\.png/
+    allow(@session.driver).to receive(:save_screenshot)
+    allow(Launchy).to receive(:open)
+
+    @session.save_and_open_screenshot
+
+    expect(@session.driver).to have_received(:save_screenshot)
+      .with(expected_file_regex, any_args)
+    expect(Launchy).to have_received(:open).with(expected_file_regex)
+  end
+
+  it 'opens file from the provided directory', requires: [:screenshot] do
+    custom_path = 'screenshots/1.png'
+    allow(@session.driver).to receive(:save_screenshot)
+    allow(Launchy).to receive(:open)
+
+    @session.save_and_open_screenshot(custom_path)
+
+    expect(@session.driver).to have_received(:save_screenshot)
+      .with(/#{custom_path}$/, any_args)
+    expect(Launchy).to have_received(:open).with(/#{custom_path}$/)
+  end
+
+  context 'when launchy cannot be required' do
+    it 'prints out a correct warning message', requires: [:screenshot] do
+      file_path = File.join(Dir.tmpdir, 'test.png')
+      allow(@session).to receive(:warn)
+      allow(@session).to receive(:require).with('launchy').and_raise(LoadError)
+      @session.save_and_open_screenshot(file_path)
+      expect(@session).to have_received(:warn).with("File saved to #{file_path}.\nPlease install the launchy gem to open the file automatically.")
+    end
+  end
+end

data/capybara-3.40.0/lib/capybara/spec/session/save_page_spec.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+Capybara::SpecHelper.spec '#save_page' do
+  let(:alternative_path) { File.join(Dir.pwd, 'save_and_open_page_tmp') }
+  before do
+    @old_save_path = Capybara.save_path
+    Capybara.save_path = nil
+    @session.visit('/foo')
+  end
+
+  after do
+    Capybara.save_path = @old_save_path
+    Dir.glob('capybara-*.html').each do |file|
+      FileUtils.rm(file)
+    end
+    FileUtils.rm_rf alternative_path
+  end
+
+  it 'saves the page in the root directory' do
+    @session.save_page
+    path = Dir.glob('capybara-*.html').first
+    expect(File.read(path)).to include('Another World')
+  end
+
+  it 'generates a sensible filename' do
+    @session.save_page
+    filename = Dir.glob('capybara-*.html').first
+    expect(filename).to match(/^capybara-\d+\.html$/)
+  end
+
+  it 'can store files in a specified directory' do
+    Capybara.save_path = alternative_path
+    @session.save_page
+    path = Dir.glob("#{alternative_path}/capybara-*.html").first
+    expect(File.read(path)).to include('Another World')
+  end
+
+  it 'uses the given filename' do
+    @session.save_page('capybara-001122.html')
+    expect(File.read('capybara-001122.html')).to include('Another World')
+  end
+
+  it 'can store files in a specified directory with a given filename' do
+    Capybara.save_path = alternative_path
+    @session.save_page('capybara-001133.html')
+    path = "#{alternative_path}/capybara-001133.html"
+    expect(File.read(path)).to include('Another World')
+  end
+
+  it 'can store files in a specified directory with a given relative filename' do
+    Capybara.save_path = alternative_path
+    @session.save_page('tmp/capybara-001144.html')
+    path = "#{alternative_path}/tmp/capybara-001144.html"
+    expect(File.read(path)).to include('Another World')
+  end
+
+  it 'returns an absolute path in pwd' do
+    result = @session.save_page
+    path = File.expand_path(Dir.glob('capybara-*.html').first, Dir.pwd)
+    expect(result).to eq(path)
+  end
+
+  it 'returns an absolute path in given directory' do
+    Capybara.save_path = alternative_path
+    result = @session.save_page
+    path = File.expand_path(Dir.glob("#{alternative_path}/capybara-*.html").first, alternative_path)
+    expect(result).to eq(path)
+  end
+
+  context 'asset_host contains a string' do
+    before { Capybara.asset_host = 'http://example.com' }
+
+    after { Capybara.asset_host = nil }
+
+    it 'prepends base tag with value from asset_host to the head' do
+      @session.visit('/with_js')
+      path = @session.save_page
+
+      result = File.read(path)
+      expect(result).to include("<head><base href='http://example.com' />")
+    end
+
+    it "doesn't prepend base tag to pages when asset_host is nil" do
+      Capybara.asset_host = nil
+      @session.visit('/with_js')
+      path = @session.save_page
+
+      result = File.read(path)
+      expect(result).to include('<html')
+      expect(result).not_to include('http://example.com')
+    end
+
+    it "doesn't prepend base tag to pages which already have it" do
+      @session.visit('/with_base_tag')
+      path = @session.save_page
+
+      result = File.read(path)
+      expect(result).to include('<html')
+      expect(result).not_to include('http://example.com')
+    end
+
+    it 'executes successfully even if the page is missing a <head>' do
+      @session.visit('/with_simple_html')
+      path = @session.save_page
+
+      result = File.read(path)
+      expect(result).to include('Bar')
+    end
+  end
+end

data/capybara-3.40.0/lib/capybara/spec/session/save_screenshot_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+Capybara::SpecHelper.spec '#save_screenshot', requires: [:screenshot] do
+  let(:alternative_path) { File.join(Dir.pwd, 'save_screenshot_tmp') }
+  before do
+    @old_save_path = Capybara.save_path
+    Capybara.save_path = nil
+    @session.visit '/foo'
+  end
+
+  after do
+    Capybara.save_path = @old_save_path
+    FileUtils.rm_rf alternative_path
+  end
+
+  it 'generates sensible filename' do
+    allow(@session.driver).to receive(:save_screenshot)
+
+    @session.save_screenshot
+
+    regexp = Regexp.new(File.join(Dir.pwd, 'capybara-\d+\.png'))
+    expect(@session.driver).to have_received(:save_screenshot).with(regexp, any_args)
+  end
+
+  it 'allows to specify another path' do
+    allow(@session.driver).to receive(:save_screenshot)
+
+    custom_path = 'screenshots/1.png'
+    @session.save_screenshot(custom_path)
+
+    expect(@session.driver).to have_received(:save_screenshot).with(/#{custom_path}$/, any_args)
+  end
+
+  context 'with Capybara.save_path' do
+    it 'file is generated in the correct location' do
+      Capybara.save_path = alternative_path
+      allow(@session.driver).to receive(:save_screenshot)
+
+      @session.save_screenshot
+
+      regexp = Regexp.new(File.join(alternative_path, 'capybara-\d+\.png'))
+      expect(@session.driver).to have_received(:save_screenshot).with(regexp, any_args)
+    end
+
+    it 'relative paths are relative to save_path' do
+      Capybara.save_path = alternative_path
+      allow(@session.driver).to receive(:save_screenshot)
+
+      custom_path = 'screenshots/2.png'
+      @session.save_screenshot(custom_path)
+
+      expect(@session.driver).to have_received(:save_screenshot).with(File.expand_path(custom_path, alternative_path), any_args)
+    end
+  end
+end

data/capybara-3.40.0/lib/capybara/spec/session/screenshot_spec.rb

@@ -0,0 +1,18 @@
+# coding: US-ASCII
+# frozen_string_literal: true
+
+Capybara::SpecHelper.spec '#save_screenshot' do
+  let(:image_path) { File.join(Dir.tmpdir, 'capybara-screenshot.png') }
+
+  before do
+    @session.visit '/'
+  end
+
+  it 'should generate PNG file', requires: [:screenshot] do
+    path = @session.save_screenshot image_path
+
+    magic = File.read(image_path, 4)
+    expect(magic).to eq "\x89PNG"
+    expect(path).to eq image_path
+  end
+end

data/capybara-3.40.0/lib/capybara/spec/session/scroll_spec.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+Capybara::SpecHelper.spec '#scroll_to', requires: [:scroll] do
+  before do
+    @session.visit('/scroll')
+  end
+
+  it 'can scroll an element to the top of the viewport' do
+    el = @session.find(:css, '#scroll')
+    @session.scroll_to(el, align: :top)
+    expect(el.evaluate_script('this.getBoundingClientRect().top')).to be_within(1).of(0)
+  end
+
+  it 'can scroll an element to the bottom of the viewport' do
+    el = @session.find(:css, '#scroll')
+    @session.scroll_to(el, align: :bottom)
+    el_bottom = el.evaluate_script('this.getBoundingClientRect().bottom')
+    viewport_bottom = el.evaluate_script('document.documentElement.clientHeight')
+    expect(el_bottom).to be_within(1).of(viewport_bottom)
+  end
+
+  it 'can scroll an element to the center of the viewport' do
+    el = @session.find(:css, '#scroll')
+    @session.scroll_to(el, align: :center)
+    el_center = el.evaluate_script('(function(rect){return (rect.top + rect.bottom)/2})(this.getBoundingClientRect())')
+    viewport_bottom = el.evaluate_script('document.documentElement.clientHeight')
+    expect(el_center).to be_within(2).of(viewport_bottom / 2)
+  end
+
+  it 'can scroll the window to the vertical top' do
+    @session.scroll_to :bottom
+    @session.scroll_to :top
+    expect(@session.evaluate_script('[window.scrollX || window.pageXOffset, window.scrollY || window.pageYOffset]')).to eq [0, 0]
+  end
+
+  it 'can scroll the window to the vertical bottom' do
+    @session.scroll_to :bottom
+    max_scroll = @session.evaluate_script('document.documentElement.scrollHeight - document.documentElement.clientHeight')
+    scrolled_location_x, scrolled_location_y = @session.evaluate_script('[window.scrollX || window.pageXOffset, window.scrollY || window.pageYOffset]')
+    expect(scrolled_location_x).to be_within(0.5).of(0)
+    expect(scrolled_location_y).to be_within(0.5).of(max_scroll)
+  end
+
+  it 'can scroll the window to the vertical center' do
+    @session.scroll_to :center
+    max_scroll = @session.evaluate_script('document.documentElement.scrollHeight - document.documentElement.clientHeight')
+    expect(@session.evaluate_script('[window.scrollX || window.pageXOffset, window.scrollY || window.pageYOffset]')).to eq [0, max_scroll / 2]
+  end
+
+  it 'can scroll the window to specific location' do
+    @session.scroll_to 100, 100
+    expect(@session.evaluate_script('[window.scrollX || window.pageXOffset, window.scrollY || window.pageYOffset]')).to eq [100, 100]
+  end
+
+  it 'can scroll an element to the top of the scrolling element' do
+    scrolling_element = @session.find(:css, '#scrollable')
+    el = scrolling_element.find(:css, '#inner')
+    scrolling_element.scroll_to(el, align: :top)
+    scrolling_element_top = scrolling_element.evaluate_script('this.getBoundingClientRect().top')
+    expect(el.evaluate_script('this.getBoundingClientRect().top')).to be_within(3).of(scrolling_element_top)
+  end
+
+  it 'can scroll an element to the bottom of the scrolling element' do
+    scrolling_element = @session.find(:css, '#scrollable')
+    el = scrolling_element.find(:css, '#inner')
+    scrolling_element.scroll_to(el, align: :bottom)
+    el_bottom = el.evaluate_script('this.getBoundingClientRect().bottom')
+    scroller_bottom = scrolling_element.evaluate_script('this.getBoundingClientRect().top + this.clientHeight')
+    expect(el_bottom).to be_within(1).of(scroller_bottom)
+  end
+
+  it 'can scroll an element to the center of the scrolling element' do
+    scrolling_element = @session.find(:css, '#scrollable')
+    el = scrolling_element.find(:css, '#inner')
+    scrolling_element.scroll_to(el, align: :center)
+    el_center = el.evaluate_script('(function(rect){return (rect.top + rect.bottom)/2})(this.getBoundingClientRect())')
+    scrollable_center = scrolling_element.evaluate_script('(this.clientHeight / 2) + this.getBoundingClientRect().top')
+    expect(el_center).to be_within(1).of(scrollable_center)
+  end
+
+  it 'can scroll the scrolling element to the top' do
+    scrolling_element = @session.find(:css, '#scrollable')
+    scrolling_element.scroll_to :bottom
+    scrolling_element.scroll_to :top
+    expect(scrolling_element.evaluate_script('[this.scrollLeft, this.scrollTop]')).to eq [0, 0]
+  end
+
+  it 'can scroll the scrolling element to the bottom' do
+    scrolling_element = @session.find(:css, '#scrollable')
+    scrolling_element.scroll_to :bottom
+    max_scroll = scrolling_element.evaluate_script('this.scrollHeight - this.clientHeight')
+    expect(scrolling_element.evaluate_script('[this.scrollLeft, this.scrollTop]')).to eq [0, max_scroll]
+  end
+
+  it 'can scroll the scrolling element to the vertical center' do
+    scrolling_element = @session.find(:css, '#scrollable')
+    scrolling_element.scroll_to :center
+    max_scroll = scrolling_element.evaluate_script('this.scrollHeight - this.clientHeight')
+    expect(scrolling_element.evaluate_script('[this.scrollLeft, this.scrollTop]')).to eq [0, max_scroll / 2]
+  end
+
+  it 'can scroll the scrolling element to specific location' do
+    scrolling_element = @session.find(:css, '#scrollable')
+    scrolling_element.scroll_to 100, 100
+    expect(scrolling_element.evaluate_script('[this.scrollLeft, this.scrollTop]')).to eq [100, 100]
+  end
+
+  it 'can scroll the window by a specific amount' do
+    @session.scroll_to(:current, offset: [50, 75])
+    expect(@session.evaluate_script('[window.scrollX || window.pageXOffset, window.scrollY || window.pageYOffset]')).to eq [50, 75]
+  end
+
+  it 'can scroll the scroll the scrolling element by a specific amount' do
+    scrolling_element = @session.find(:css, '#scrollable')
+    scrolling_element.scroll_to 100, 100
+    scrolling_element.scroll_to(:current, offset: [-50, 50])
+    expect(scrolling_element.evaluate_script('[this.scrollLeft, this.scrollTop]')).to eq [50, 150]
+  end
+end