testcentricity_web 4.1.8 → 4.1.9

data/spec/testcentricity_web/elements/link_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+describe TestCentricity::Link, required: true do
+  subject(:css_link) { described_class.new(:test_label, self, 'a#css_label', :page) }
+
+  it 'returns class' do
+    expect(css_link.class).to eql TestCentricity::Link
+  end
+
+  it 'registers with type link' do
+    expect(css_link.get_object_type).to eql :link
+  end
+
+  it 'returns href' do
+    allow(css_link).to receive(:href).and_return('href')
+    expect(css_link.href).to eql 'href'
+  end
+
+  it 'should click the link' do
+    expect(css_link).to receive(:click)
+    css_link.click
+  end
+end

data/spec/testcentricity_web/elements/list_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+describe TestCentricity::List, required: true do
+  subject(:css_list) { described_class.new(:test_list, self, 'ul#css_list', :page) }
+
+  it 'returns class' do
+    expect(css_list.class).to eql TestCentricity::List
+  end
+
+  it 'registers with type list' do
+    expect(css_list.get_object_type).to eql :list
+  end
+end

data/spec/testcentricity_web/elements/radio_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+describe TestCentricity::Radio, required: true do
+  subject(:css_radio) { described_class.new(:test_radio, self, 'input#css_radio', :page) }
+
+  it 'returns class' do
+    expect(css_radio.class).to eql TestCentricity::Radio
+  end
+
+  it 'registers with type radio' do
+    expect(css_radio.get_object_type).to eql :radio
+  end
+
+  it 'should select the radio' do
+    expect(css_radio).to receive(:select)
+    css_radio.select
+  end
+
+  it 'should unselect the radio' do
+    expect(css_radio).to receive(:unselect)
+    css_radio.unselect
+  end
+
+  it 'should know if radio is selected' do
+    allow(css_radio).to receive(:selected?).and_return(true)
+    expect(css_radio.selected?).to eq(true)
+  end
+end

data/spec/testcentricity_web/elements/ui_element_spec.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+describe TestCentricity::UIElement, required: true do
+  subject(:css_element) { described_class.new(:css_test_element, self, 'button#css_button', :page) }
+  subject(:xpath_element) { described_class.new(:xpath_test_element, self, "//button[@id='xpath_button']", :page) }
+
+  it 'returns class' do
+    expect(css_element.class).to eql described_class
+  end
+
+  it 'returns css locator type' do
+    expect(css_element.get_locator_type).to eql :css
+  end
+
+  it 'returns xpath locator type' do
+    expect(xpath_element.get_locator_type).to eql :xpath
+  end
+
+  it 'returns name' do
+    expect(css_element.get_name).to eql :css_test_element
+  end
+
+  it 'returns locator' do
+    expect(css_element.get_locator).to eql 'button#css_button'
+  end
+
+  it 'returns css locator type' do
+    expect(css_element.get_locator_type).to eql :css
+  end
+
+  it 'should click the element' do
+    allow(css_element).to receive(:click)
+    css_element.click
+  end
+
+  it 'should double click the element' do
+    allow(css_element).to receive(:double_click)
+    css_element.double_click
+  end
+
+  it 'should right click the element' do
+    allow(css_element).to receive(:right_click)
+    css_element.right_click
+  end
+
+  it 'should click the element at specified offset' do
+    allow(css_element).to receive(:click_at)
+    css_element.click_at(10, 10)
+  end
+
+  it 'should hover over the element' do
+    allow(css_element).to receive(:hover)
+    css_element.hover
+  end
+
+  it 'should hover over the element at specified offset' do
+    allow(css_element).to receive(:hover_at)
+    css_element.hover_at(10, 15)
+  end
+
+  it 'should drag the element by specified offset' do
+    allow(css_element).to receive(:drag_by)
+    css_element.drag_by(20, 15)
+  end
+
+  it 'should know if element is visible' do
+    allow(css_element).to receive(:visible?).and_return(false)
+    expect(css_element.visible?).to eq(false)
+  end
+
+  it 'should know if element is hidden' do
+    allow(css_element).to receive(:hidden?).and_return(true)
+    expect(css_element.hidden?).to eq(true)
+  end
+
+  it 'should know if element exists' do
+    allow(css_element).to receive(:exists?).and_return(true)
+    expect(css_element.exists?).to be true
+  end
+
+  it 'should know if element is disabled' do
+    allow(css_element).to receive(:enabled?).and_return(true)
+    expect(css_element.enabled?).to eq(true)
+  end
+
+  it 'should know if element is disabled' do
+    allow(css_element).to receive(:disabled?).and_return(true)
+    expect(css_element.disabled?).to eq(true)
+  end
+
+  it 'should know if element is obscured' do
+    allow(css_element).to receive(:obscured?).and_return(true)
+    expect(css_element.obscured?).to eq(true)
+  end
+
+  it 'should know if element is focused' do
+    allow(css_element).to receive(:focused?).and_return(true)
+    expect(css_element.focused?).to eq(true)
+  end
+
+  it 'should know if element is displayed' do
+    allow(css_element).to receive(:displayed?).and_return(true)
+    expect(css_element.displayed?).to eq(true)
+  end
+
+  it 'should know if element is required' do
+    allow(css_element).to receive(:required?).and_return(true)
+    expect(css_element.required?).to eq(true)
+  end
+
+  it 'should send keys' do
+    allow(css_element).to receive(:send_keys).with('foo bar')
+    css_element.send_keys('foo bar')
+  end
+
+  it 'should right highlight the element' do
+    allow(css_element).to receive(:highlight)
+    css_element.highlight(2)
+  end
+
+  it 'should right unhighlight the element' do
+    allow(css_element).to receive(:unhighlight)
+    css_element.unhighlight
+  end
+end

data/spec/testcentricity_web/elements/video_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+describe TestCentricity::Video, required: true do
+  subject(:css_video) { described_class.new(:test_video, self, 'video#css_video', :page) }
+
+  it 'returns class' do
+    expect(css_video.class).to eql TestCentricity::Video
+  end
+
+  it 'registers with type video' do
+    expect(css_video.get_object_type).to eql :video
+  end
+
+  it 'returns autoplay' do
+    allow(css_video).to receive(:autoplay?).and_return(false)
+    expect(css_video.autoplay?).to eql false
+  end
+
+  it 'returns controls' do
+    allow(css_video).to receive(:controls?).and_return(true)
+    expect(css_video.controls?).to eql true
+  end
+
+  it 'returns ended' do
+    allow(css_video).to receive(:ended?).and_return(true)
+    expect(css_video.ended?).to eql true
+  end
+
+  it 'returns loop' do
+    allow(css_video).to receive(:loop?).and_return(false)
+    expect(css_video.loop?).to eql false
+  end
+
+  it 'returns muted' do
+    allow(css_video).to receive(:muted?).and_return(false)
+    expect(css_video.muted?).to eql false
+  end
+
+  it 'returns paused' do
+    allow(css_video).to receive(:paused?).and_return(true)
+    expect(css_video.paused?).to eql true
+  end
+
+  it 'returns seeking' do
+    allow(css_video).to receive(:seeking?).and_return(false)
+    expect(css_video.seeking?).to eql false
+  end
+
+  it 'should play the video' do
+    expect(css_video).to receive(:play)
+    css_video.play
+  end
+
+  it 'should pause the video' do
+    expect(css_video).to receive(:pause)
+    css_video.pause
+  end
+
+  it 'should mute the video' do
+    expect(css_video).to receive(:mute)
+    css_video.mute
+  end
+
+  it 'should unmute the video' do
+    expect(css_video).to receive(:unmute)
+    css_video.unmute
+  end
+end

data/spec/testcentricity_web/helper_specs/object_helpers_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+describe Object, required: true do
+  it 'returns true when blank' do
+    [nil, {}, ''].each do |value|
+      expect(value.blank?).to eql true
+    end
+  end
+
+  it 'returns false when not blank' do
+    [0, 42, 'fred', ['Fred', 21], {a: 42}].each do |value|
+      expect(value.blank?).to eql false
+    end
+  end
+
+  it 'returns true when present' do
+    [0, 42, 'fred', ['Fred', 21], {a: 42}].each do |value|
+      expect(value.present?).to eql true
+    end
+  end
+
+  it 'returns false when not present' do
+    [nil, {}, ''].each do |value|
+      expect(value.present?).to eql false
+    end
+  end
+
+  it 'returns true when Boolean' do
+    [!nil?, nil?, 2 + 2 == 4].each do |value|
+      expect(value.boolean?).to eql true
+    end
+  end
+
+  it 'returns false when not a Boolean' do
+    [4, 'Ethel', [1, 'a']].each do |value|
+      expect(value.boolean?).to eql false
+    end
+  end
+end

data/spec/testcentricity_web/helper_specs/string_helpers_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+describe String, required: true do
+  it 'returns string between' do
+    expect('The rain in Spain'.string_between('The ', ' Spain')).to eql 'rain in'
+  end
+
+  it 'returns title case' do
+    expect('The rain in Spain'.titlecase).to eql 'The Rain In Spain'
+  end
+
+  it 'returns boolean value when true' do
+    %w[true t yes y x 1].each do |value|
+      expect(value.to_bool).to eql true
+    end
+  end
+
+  it 'returns boolean value when false' do
+    %w[false f no n 0].each do |value|
+      expect(value.to_bool).to eql false
+    end
+  end
+
+  it 'returns true when Integer' do
+    %w[26 3 10345].each do |value|
+      expect(value.is_int?).to eql true
+    end
+  end
+
+  it 'returns false when not an Integer' do
+    %w[271.234 0.1234 Fred].each do |value|
+      expect(value.is_int?).to eql false
+    end
+  end
+
+  it 'returns true when Float' do
+    %w[271.234 0.1234 21.4].each do |value|
+      expect(value.is_float?).to eql true
+    end
+  end
+
+  it 'returns formatted date' do
+    expect('04/06/2022'.format_date_time('%A, %d %b %Y')).to eql 'Saturday, 04 Jun 2022'
+  end
+
+  it 'returns translated formatted date' do
+    expect('04/06/2022'.format_date_time(:abbrev)).to eql 'Jun 04, 2022'
+  end
+end

data/spec/testcentricity_web/page_object_spec.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+describe TestCentricity::PageObject, required: true do
+  before :context do
+    @test_page = TestPage.new
+  end
+
+  context 'page object traits' do
+    it 'returns page name' do
+      expect(@test_page.page_name).to eq('Basic Test Page')
+    end
+
+    it 'returns page url' do
+      expect(@test_page.page_url).to eq('/basic_test_page.html')
+    end
+
+    it 'returns page locator' do
+      expect(@test_page.page_locator).to eq('form#HTMLFormElements')
+    end
+
+    it 'determines if page is secure' do
+      allow(@test_page).to receive(:secure?).and_return(false)
+      expect(@test_page.secure?).to eq(false)
+    end
+
+    it 'should display the title of the page' do
+      allow(@test_page).to receive(:title).and_return('I am the title of a page')
+      expect(@test_page.title).to eql 'I am the title of a page'
+    end
+
+    it 'determines if page is secure' do
+      allow(@test_page).to receive(:secure?).and_return(false)
+      expect(@test_page.secure?).to eq(false)
+    end
+
+    it 'responds to open_portal' do
+      expect(@test_page).to respond_to(:open_portal)
+    end
+
+    it 'responds to load_page' do
+      expect(@test_page).to respond_to(:load_page)
+    end
+
+    it 'responds to verify_page_exists' do
+      expect(@test_page).to respond_to(:verify_page_exists)
+    end
+
+    it 'responds to exists?' do
+      expect(@test_page).to respond_to(:exists?)
+    end
+  end
+
+  context 'page object with UI elements' do
+    it 'responds to element' do
+      expect(@test_page).to respond_to(:element1)
+    end
+
+    it 'responds to button' do
+      expect(@test_page).to respond_to(:button1)
+    end
+
+    it 'responds to textfield' do
+      expect(@test_page).to respond_to(:field1)
+    end
+
+    it 'responds to link' do
+      expect(@test_page).to respond_to(:link1)
+    end
+
+    it 'responds to range' do
+      expect(@test_page).to respond_to(:range1)
+    end
+
+    it 'responds to image' do
+      expect(@test_page).to respond_to(:image1)
+    end
+
+    it 'responds to radio' do
+      expect(@test_page).to respond_to(:radio1)
+    end
+
+    it 'responds to checkbox' do
+      expect(@test_page).to respond_to(:check1)
+    end
+
+    it 'responds to section' do
+      expect(@test_page).to respond_to(:section1)
+    end
+  end
+end

data/spec/testcentricity_web/section_object_spec.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+describe TestCentricity::PageSection, required: true do
+  before :context do
+    @test_page = TestPage.new
+    @test_section = @test_page.section1
+  end
+
+  context 'section object traits' do
+    it 'returns section name' do
+      expect(@test_section.section_name).to eq('Basic Test Section')
+    end
+
+    it 'returns section locator' do
+      expect(@test_section.get_locator).to eq('div#section')
+    end
+
+    it 'returns class' do
+      expect(@test_section.class).to eql TestSection
+    end
+
+    it 'returns css locator type' do
+      expect(@test_section.get_locator_type).to eql :css
+    end
+
+    it 'registers with type section' do
+      expect(@test_section.get_object_type).to eql :section
+    end
+
+    it 'returns parent list object' do
+      expect(@test_section.get_parent_list).to eql nil
+    end
+  end
+
+  context 'section object with UI elements' do
+    it 'responds to element' do
+      expect(@test_section).to respond_to(:element1)
+    end
+
+    it 'responds to button' do
+      expect(@test_section).to respond_to(:button1)
+    end
+
+    it 'responds to textfield' do
+      expect(@test_section).to respond_to(:field1)
+    end
+
+    it 'responds to link' do
+      expect(@test_section).to respond_to(:link1)
+    end
+
+    it 'responds to range' do
+      expect(@test_section).to respond_to(:range1)
+    end
+
+    it 'responds to image' do
+      expect(@test_section).to respond_to(:image1)
+    end
+
+    it 'responds to radio' do
+      expect(@test_section).to respond_to(:radio1)
+    end
+
+    it 'responds to checkbox' do
+      expect(@test_section).to respond_to(:check1)
+    end
+
+    it 'responds to section' do
+      expect(@test_section).to respond_to(:section2)
+    end
+  end
+end

data/spec/testcentricity_web/version_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+describe 'TestCentricityWeb::VERSION', required: true do
+  subject { TestCentricityWeb::VERSION }
+
+  it { is_expected.to be_truthy }
+end

data/spec/testcentricity_web/webdriver_connect/grid_webdriver_spec.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+describe TestCentricity::WebDriverConnect, grid: true do
+  before(:context) do
+    # instantiate remote test environment
+    @environs ||= EnvironData
+    @environs.find_environ('REMOTE', :yaml)
+    ENV['SELENIUM'] = 'remote'
+    endpoint = 'http://localhost:4444/wd/hub'
+    ENV['REMOTE_ENDPOINT'] = endpoint
+    # wait for Dockerized Selenium grid to be running
+    20.downto(0) do |interval|
+      begin
+        response = HTTParty.get("#{endpoint}/status")
+        break if response.body.include?('Selenium Grid ready')
+      rescue
+        if interval == 0
+          raise 'Selenium Grid is not running.'
+        else
+          sleep(1)
+        end
+      end
+    end
+  end
+
+  context 'grid web browser instances' do
+    it 'connects to a grid hosted Firefox browser' do
+      ENV['WEB_BROWSER'] = 'firefox'
+      WebDriverConnect.initialize_web_driver
+      verify_grid_browser(browser = :firefox, platform = :desktop)
+    end
+
+    it 'connects to a grid hosted Chrome browser' do
+      ENV['WEB_BROWSER'] = 'chrome'
+      WebDriverConnect.initialize_web_driver
+      Browsers.suppress_js_leave_page_modal
+      verify_grid_browser(browser = :chrome, platform = :desktop)
+    end
+
+    it 'connects to a grid hosted Edge browser' do
+      ENV['WEB_BROWSER'] = 'edge'
+      WebDriverConnect.initialize_web_driver
+      Browsers.suppress_js_alerts
+      verify_grid_browser(browser = :edge, platform = :desktop)
+    end
+
+    it 'connects to a grid hosted emulated mobile web browser' do
+      ENV['WEB_BROWSER'] = 'ipad_pro_12_9'
+      ENV['HOST_BROWSER'] = 'chrome'
+      ENV['ORIENTATION'] = 'portrait'
+      WebDriverConnect.initialize_web_driver
+      Browsers.set_device_orientation('landscape')
+      verify_grid_browser(browser = :ipad_pro_12_9, platform = :mobile)
+    end
+  end
+
+  after(:each) do
+    $server.stop if Environ.driver == :appium && $server.running?
+    Capybara.current_session.quit
+    Environ.session_state = :quit
+  end
+
+  def verify_grid_browser(browser, platform)
+    expect(Environ.browser).to eq(browser)
+    expect(Environ.platform).to eq(platform)
+    expect(Environ.headless).to eq(false)
+    expect(Environ.session_state).to eq(:running)
+    expect(Environ.driver).to eq(:webdriver)
+    expect(Environ.device).to eq(:web)
+    expect(Environ.grid).to eq(:selenium_grid)
+  end
+end

data/spec/testcentricity_web/webdriver_connect/local_webdriver_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+describe TestCentricity::WebDriverConnect, required: true do
+  before(:context) do
+    # instantiate local test environment
+    @environs ||= EnvironData
+    @environs.find_environ('LOCAL', :yaml)
+    ENV['SELENIUM'] = ''
+  end
+
+  context 'local web browser instances' do
+    it 'connects to a local Firefox browser' do
+      ENV['WEB_BROWSER'] = 'firefox'
+      WebDriverConnect.initialize_web_driver
+      verify_local_browser(browser = :firefox, platform = :desktop, headless = false)
+    end
+
+    it 'connects to a local Safari browser' do
+      ENV['WEB_BROWSER'] = 'safari'
+      WebDriverConnect.initialize_web_driver
+      verify_local_browser(browser = :safari, platform = :desktop, headless = false)
+    end
+
+    it 'connects to a local Chrome browser' do
+      ENV['WEB_BROWSER'] = 'chrome'
+      WebDriverConnect.initialize_web_driver
+      Browsers.suppress_js_leave_page_modal
+      verify_local_browser(browser = :chrome, platform = :desktop, headless = false)
+    end
+
+    it 'connects to a local Edge browser' do
+      ENV['WEB_BROWSER'] = 'edge'
+      WebDriverConnect.initialize_web_driver
+      Browsers.suppress_js_alerts
+      verify_local_browser(browser = :edge, platform = :desktop, headless = false)
+    end
+
+    it 'connects to a local emulated mobile web browser' do
+      ENV['WEB_BROWSER'] = 'ipad_pro_12_9'
+      ENV['HOST_BROWSER'] = 'chrome'
+      ENV['ORIENTATION'] = 'portrait'
+      WebDriverConnect.initialize_web_driver
+      Browsers.set_device_orientation('landscape')
+      verify_local_browser(browser = :ipad_pro_12_9, platform = :mobile, headless = false)
+      expect(Environ.browser_size).to eq([1366, 1024])
+    end
+  end
+
+  context 'local headless browser instances' do
+    it 'connects to a local headless Chrome browser' do
+      ENV['WEB_BROWSER'] = 'chrome_headless'
+      WebDriverConnect.initialize_web_driver
+      Browsers.maximize_browser
+      verify_local_browser(browser = :chrome_headless, platform = :desktop, headless = true)
+    end
+
+    it 'connects to a local headless Edge browser' do
+      ENV['WEB_BROWSER'] = 'edge_headless'
+      WebDriverConnect.initialize_web_driver
+      Browsers.refresh_browser
+      verify_local_browser(browser = :edge_headless, platform = :desktop, headless = true)
+    end
+
+    it 'connects to a local headless Firefox browser' do
+      ENV['WEB_BROWSER'] = 'firefox_headless'
+      WebDriverConnect.initialize_web_driver
+      Browsers.delete_all_cookies
+      verify_local_browser(browser = :firefox_headless, platform = :desktop, headless = true)
+    end
+  end
+
+  after(:each) do
+    Capybara.current_session.quit
+    Environ.session_state = :quit
+  end
+
+  def verify_local_browser(browser, platform, headless)
+    expect(Environ.browser).to eq(browser)
+    expect(Environ.platform).to eq(platform)
+    expect(Environ.headless).to eq(headless)
+    expect(Environ.session_state).to eq(:running)
+    expect(Environ.driver).to eq(:webdriver)
+    expect(Environ.device).to eq(:web)
+    expect(Environ.is_web?).to eq(true)
+  end
+end