testcentricity_web 4.1.10 → 4.2.6

data/spec/spec_helper.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'capybara/rspec'
-require 'httparty'
-require 'require_all'
-require 'simplecov'
-require 'testcentricity_web'
-
-require_rel 'fixtures'
-
-include TestCentricity
-
-SimpleCov.command_name("RSpec-#{Time.now.strftime('%Y%m%d%H%M%S')}")
-
-$LOAD_PATH << './lib'
-
-# set the default locale and auto load all translations from config/locales/*.rb,yml.
-ENV['LOCALE'] = 'en-US' unless ENV['LOCALE']
-I18n.load_path += Dir['config/locales/*.{rb,yml}']
-I18n.default_locale = 'en-US'
-I18n.locale = ENV['LOCALE']
-Faker::Config.locale = ENV['LOCALE']
-
-# prevent Test::Unit's AutoRunner from executing during RSpec's rake task
-Test::Unit.run = true if defined?(Test::Unit) && Test::Unit.respond_to?(:run=)
-
-RSpec.configure do |config|
-  config.mock_with :rspec do |mocks|
-    mocks.allow_message_expectations_on_nil = true
-    mocks.verify_doubled_constant_names = true
-    mocks.verify_partial_doubles = true
-  end
-end

data/spec/testcentricity_web/browser_spec.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-describe TestCentricity::Browsers, required: true do
-  before(:context) do
-    # instantiate local test environment
-    @environs ||= EnvironData
-    @environs.find_environ('LOCAL', :yaml)
-    ENV['WEB_BROWSER'] = 'chrome_headless'
-  end
-
-  context 'web browser with multiple tabs/windows' do
-    it 'returns number of browser windows/tabs' do
-      WebDriverConnect.initialize_web_driver
-      Capybara.current_session.open_new_window
-      Capybara.current_session.open_new_window
-      expect(Browsers.num_browser_instances).to eql 3
-    end
-
-    it 'closes original browser instance' do
-      WebDriverConnect.initialize_web_driver
-      Capybara.current_session.open_new_window
-      Browsers.close_old_browser_instance
-      expect(Browsers.num_browser_instances).to eql 1
-    end
-
-    it 'closes current browser instance' do
-      WebDriverConnect.initialize_web_driver
-      Capybara.current_session.open_new_window
-      Browsers.switch_to_new_browser_instance
-      Capybara.current_session.open_new_window
-      Browsers.close_current_browser_instance
-      expect(Browsers.num_browser_instances).to eql 2
-    end
-  end
-
-  after(:each) do
-    Browsers.close_all_browser_instances
-    Capybara.current_session.quit
-    Environ.session_state = :quit
-  end
-end

data/spec/testcentricity_web/elements/audio_spec.rb

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

data/spec/testcentricity_web/elements/button_spec.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-describe TestCentricity::Button, required: true do
-  subject(:css_button) { described_class.new(:test_button, self, 'button#css_button', :page) }
-
-  it 'returns class' do
-    expect(css_button.class).to eql TestCentricity::Button
-  end
-
-  it 'registers with type button' do
-    expect(css_button.get_object_type).to eql :button
-  end
-
-  it 'should click the button' do
-    expect(css_button).to receive(:click)
-    css_button.click
-  end
-end

data/spec/testcentricity_web/elements/checkbox_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-describe TestCentricity::CheckBox, required: true do
-  subject(:css_check) { described_class.new(:test_check, self, 'input#css_check', :page) }
-
-  it 'returns class' do
-    expect(css_check.class).to eql TestCentricity::CheckBox
-  end
-
-  it 'registers with type checkbox' do
-    expect(css_check.get_object_type).to eql :checkbox
-  end
-
-  it 'should check the checkbox' do
-    expect(css_check).to receive(:check)
-    css_check.check
-  end
-
-  it 'should uncheck the checkbox' do
-    expect(css_check).to receive(:uncheck)
-    css_check.uncheck
-  end
-
-  it 'should know if checkbox is checked' do
-    allow(css_check).to receive(:checked?).and_return(true)
-    expect(css_check.checked?).to eq(true)
-  end
-
-  it 'should know if checkbox is indeterminate' do
-    allow(css_check).to receive(:indeterminate?).and_return(true)
-    expect(css_check.indeterminate?).to eq(true)
-  end
-end

data/spec/testcentricity_web/elements/file_field_spec.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-describe TestCentricity::FileField, required: true do
-  subject(:css_filefield) { described_class.new(:test_filefield, self, 'input#css_filefield', :page) }
-
-  it 'returns class' do
-    expect(css_filefield.class).to eql TestCentricity::FileField
-  end
-
-  it 'registers with type label' do
-    expect(css_filefield.get_object_type).to eql :filefield
-  end
-end

data/spec/testcentricity_web/elements/image_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-describe TestCentricity::Image, required: true do
-  subject(:css_image) { described_class.new(:test_image, self, 'img#css_image', :page) }
-
-  it 'returns class' do
-    expect(css_image.class).to eql TestCentricity::Image
-  end
-
-  it 'registers with type image' do
-    expect(css_image.get_object_type).to eql :image
-  end
-
-  it 'returns loaded' do
-    allow(css_image).to receive(:loaded?).and_return(true)
-    expect(css_image.loaded?).to eql true
-  end
-
-  it 'returns broken' do
-    allow(css_image).to receive(:broken?).and_return(false)
-    expect(css_image.broken?).to eql false
-  end
-
-  it 'returns alt' do
-    allow(css_image).to receive(:alt).and_return('alt')
-    expect(css_image.alt).to eql 'alt'
-  end
-
-  it 'returns src' do
-    allow(css_image).to receive(:src).and_return('src')
-    expect(css_image.src).to eql 'src'
-  end
-end

data/spec/testcentricity_web/elements/label_spec.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-describe TestCentricity::Label, required: true do
-  subject(:css_label) { described_class.new(:test_label, self, 'label#css_label', :page) }
-
-  it 'returns class' do
-    expect(css_label.class).to eql TestCentricity::Label
-  end
-
-  it 'registers with type label' do
-    expect(css_label.get_object_type).to eql :label
-  end
-
-  it 'returns caption' do
-    allow(css_label).to receive(:caption).and_return('caption')
-    expect(css_label.caption).to eql 'caption'
-  end
-end

data/spec/testcentricity_web/elements/link_spec.rb

@@ -1,23 +0,0 @@
-# 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

@@ -1,13 +0,0 @@
-# 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

@@ -1,28 +0,0 @@
-# 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

@@ -1,125 +0,0 @@
-# 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

@@ -1,68 +0,0 @@
-# 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

@@ -1,39 +0,0 @@
-# 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

@@ -1,49 +0,0 @@
-# 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