testcentricity 3.0.4 → 3.1.0

data/spec/testcentricity/elements/list_spec.rb

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

data/spec/testcentricity/elements/ui_element_spec.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-describe TestCentricity::AppUIElement, required: true do
-  subject(:test_element) { described_class.new(:test_element, self, { accessibility_id: 'element 1' }, :page) }
-
-  it 'returns class' do
-    expect(test_element.class).to eql described_class
-  end
-
-  it 'returns name' do
-    expect(test_element.get_name).to eql :test_element
-  end
-
-  it 'returns locator' do
-    expect(test_element.get_locator).to eql({ accessibility_id: 'element 1'})
-  end
-
-  it 'should click the element' do
-    allow(test_element).to receive(:click)
-    test_element.click
-  end
-
-  it 'should tap the element' do
-    allow(test_element).to receive(:tap)
-    test_element.tap
-  end
-
-  it 'should double tap the element' do
-    allow(test_element).to receive(:double_tap)
-    test_element.double_tap
-  end
-
-  it 'should know if element is visible' do
-    allow(test_element).to receive(:visible?).and_return(false)
-    expect(test_element.visible?).to eq(false)
-  end
-
-  it 'should know if element is hidden' do
-    allow(test_element).to receive(:hidden?).and_return(true)
-    expect(test_element.hidden?).to eq(true)
-  end
-
-  it 'should know if element exists' do
-    allow(test_element).to receive(:exists?).and_return(true)
-    expect(test_element.exists?).to be true
-  end
-
-  it 'should know if element is enabled' do
-    allow(test_element).to receive(:enabled?).and_return(true)
-    expect(test_element.enabled?).to eq(true)
-  end
-
-  it 'should know if element is disabled' do
-    allow(test_element).to receive(:disabled?).and_return(true)
-    expect(test_element.disabled?).to eq(true)
-  end
-
-  it 'should know if element is selected' do
-    allow(test_element).to receive(:selected?).and_return(true)
-    expect(test_element.selected?).to eq(true)
-  end
-
-  it 'returns value' do
-    allow(test_element).to receive(:value).and_return('value')
-    expect(test_element.value).to eql 'value'
-  end
-
-  it 'should send keys' do
-    allow(test_element).to receive(:send_keys).with('foo bar')
-    test_element.send_keys('foo bar')
-  end
-end

data/spec/testcentricity/mobile/appium_connect_spec.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-describe TestCentricity::AppiumConnect, required: true do
-  before(:context) do
-    # instantiate local test environment
-    @environs ||= EnvironData
-    @environs.find_environ('LOCAL', :yaml)
-    ENV['SELENIUM'] = ''
-    ENV['WEB_BROWSER'] = 'appium'
-    ENV['DEVICE_TYPE'] = 'phone'
-    ENV['LOCALE'] = 'en-US'
-    ENV['LANGUAGE'] = 'en'
-    # start Appium server
-    $server = TestCentricity::AppiumServer.new
-    $server.start
-  end
-
-  context 'Mobile device simulator' do
-    it 'connects to iOS Simulator using environment variables' do
-      ENV['AUTOMATION_ENGINE'] = 'XCUITest'
-      ENV['APP_PLATFORM_NAME'] = 'ios'
-      ENV['APP_VERSION'] = '15.4'
-      ENV['APP_DEVICE'] = 'iPhone 13 Pro Max'
-      ENV['APP'] = Environ.current.ios_app_path
-      AppiumConnect.initialize_appium
-      AppiumConnect.start_driver
-      expect(Environ.browser).to eq(:appium)
-      expect(Environ.platform).to eq(:mobile)
-      expect(Environ.driver).to eq(:appium)
-      expect(Environ.device).to eq(:simulator)
-      expect(Environ.device_name).to eq('iPhone 13 Pro Max')
-      expect(Environ.device_os).to eq(:ios)
-      expect(Environ.device_type).to eq(:phone)
-      expect(Environ.device_os_version).to eq('15.4')
-      expect(Environ.is_ios?).to eq(true)
-    end
-
-    it 'connects to iOS Simulator using desired_capabilities hash' do
-      ENV['APP_PLATFORM_NAME'] = 'ios'
-      ENV['APP_VERSION'] = '15.4'
-      ENV['APP_DEVICE'] = 'iPhone 13 Pro Max'
-
-      capabilities = {
-        platformName: 'ios',
-        platformVersion: '15.4',
-        deviceName: 'iPhone 13 Pro Max',
-        automationName: 'XCUITest',
-        app: Environ.current.ios_app_path
-      }
-      AppiumConnect.initialize_appium(capabilities)
-      AppiumConnect.start_driver
-      expect(Environ.browser).to eq(:appium)
-      expect(Environ.platform).to eq(:mobile)
-      expect(Environ.driver).to eq(:appium)
-      expect(Environ.device).to eq(:simulator)
-      expect(Environ.device_name).to eq('iPhone 13 Pro Max')
-      expect(Environ.device_os).to eq(:ios)
-      expect(Environ.device_type).to eq(:phone)
-      expect(Environ.device_os_version).to eq('15.4')
-      expect(Environ.is_ios?).to eq(true)
-    end
-
-    it 'connects to Android Simulator using environment variables' do
-      ENV['AUTOMATION_ENGINE'] = 'UiAutomator2'
-      ENV['APP_PLATFORM_NAME'] = 'Android'
-      ENV['APP_VERSION'] = '12.0'
-      ENV['APP_DEVICE'] = 'Pixel_5_API_31'
-      ENV['APP'] = Environ.current.android_apk_path
-      AppiumConnect.initialize_appium
-      AppiumConnect.start_driver
-      expect(Environ.browser).to eq(:appium)
-      expect(Environ.platform).to eq(:mobile)
-      expect(Environ.driver).to eq(:appium)
-      expect(Environ.device).to eq(:simulator)
-      expect(Environ.device_name).to eq('Pixel_5_API_31')
-      expect(Environ.device_os).to eq(:android)
-      expect(Environ.device_type).to eq(:phone)
-      expect(Environ.device_os_version).to eq('12.0')
-      expect(Environ.is_android?).to eq(true)
-    end
-
-    it 'connects to Android Simulator using desired_capabilities hash' do
-      ENV['APP_PLATFORM_NAME'] = 'Android'
-      ENV['APP_VERSION'] = '12.0'
-      ENV['APP_DEVICE'] = 'Pixel_5_API_31'
-
-      capabilities = {
-        platformName: 'Android',
-        platformVersion: '12.0',
-        deviceName: 'Pixel_5_API_31',
-        automationName: 'UiAutomator2',
-        avd: 'Pixel_5_API_31',
-        app: Environ.current.android_apk_path
-      }
-      AppiumConnect.initialize_appium(capabilities)
-      AppiumConnect.start_driver
-      expect(Environ.browser).to eq(:appium)
-      expect(Environ.platform).to eq(:mobile)
-      expect(Environ.driver).to eq(:appium)
-      expect(Environ.device).to eq(:simulator)
-      expect(Environ.device_name).to eq('Pixel_5_API_31')
-      expect(Environ.device_os).to eq(:android)
-      expect(Environ.device_type).to eq(:phone)
-      expect(Environ.device_os_version).to eq('12.0')
-      expect(Environ.is_android?).to eq(true)
-    end
-  end
-
-  after(:each) do
-    AppiumConnect.quit_driver
-    Environ.session_state = :quit
-  end
-
-  after(:context) do
-    $server.stop if Environ.driver == :appium && $server.running?
-  end
-end

data/spec/testcentricity/mobile/screen_object_spec.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-describe TestCentricity::ScreenObject, required: true do
-  before :context do
-    @test_screen = TestScreen.new
-  end
-
-  context 'screen object traits' do
-    it 'returns page name' do
-      expect(@test_screen.page_name).to eq('Basic Test Screen')
-    end
-
-    it 'returns page locator' do
-      expect(@test_screen.page_locator).to eq({ accessibility_id: 'test screen' })
-    end
-
-    it 'responds to open_portal' do
-      expect(@test_screen).to respond_to(:open_portal)
-    end
-
-    it 'responds to load_page' do
-      expect(@test_screen).to respond_to(:load_page)
-    end
-
-    it 'responds to verify_page_exists' do
-      expect(@test_screen).to respond_to(:verify_page_exists)
-    end
-
-    it 'responds to exists?' do
-      expect(@test_screen).to respond_to(:exists?)
-    end
-  end
-
-  context 'page object with UI elements' do
-    it 'responds to element' do
-      expect(@test_screen).to respond_to(:element1)
-    end
-
-    it 'responds to button' do
-      expect(@test_screen).to respond_to(:button1)
-    end
-
-    it 'responds to textfield' do
-      expect(@test_screen).to respond_to(:field1)
-    end
-
-    it 'responds to image' do
-      expect(@test_screen).to respond_to(:image1)
-    end
-
-    it 'responds to switch' do
-      expect(@test_screen).to respond_to(:switch1)
-    end
-
-    it 'responds to checkbox' do
-      expect(@test_screen).to respond_to(:check1)
-    end
-
-    it 'responds to section' do
-      expect(@test_screen).to respond_to(:section1)
-    end
-  end
-end

data/spec/testcentricity/mobile/screen_section_object_spec.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-describe TestCentricity::ScreenSection, required: true do
-  before :context do
-    @test_page = TestScreen.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([{ accessibility_id: 'test section' }])
-    end
-
-    it 'returns class' do
-      expect(@test_section.class).to eql TestScreenSection
-    end
-
-    it 'registers with type section' do
-      expect(@test_section.get_object_type).to eql :section
-    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 image' do
-      expect(@test_section).to respond_to(:image1)
-    end
-
-    it 'responds to switch' do
-      expect(@test_section).to respond_to(:switch1)
-    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/version_spec.rb

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

data/spec/testcentricity/web/browser_spec.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-describe TestCentricity::Browsers, web: 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/local_webdriver_spec.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-describe TestCentricity::WebDriverConnect, web: 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

data/spec/testcentricity/web/mobile_webdriver_spec.rb

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-describe TestCentricity::WebDriverConnect, web: true do
-  before(:context) do
-    # instantiate local test environment
-    @environs ||= EnvironData
-    @environs.find_environ('LOCAL', :yaml)
-    ENV['SELENIUM'] = ''
-    ENV['WEB_BROWSER'] = 'appium'
-    ENV['DEVICE_TYPE'] = 'tablet'
-    # start Appium server
-    $server = TestCentricity::AppiumServer.new
-    $server.start
-  end
-
-  context 'Mobile device simulator' do
-    it 'connects to iOS Simulator - environment variables' do
-      ENV['AUTOMATION_ENGINE'] = 'XCUITest'
-      ENV['APP_PLATFORM_NAME'] = 'ios'
-      ENV['APP_BROWSER'] = 'Safari'
-      ENV['APP_VERSION'] = '15.4'
-      ENV['APP_DEVICE'] = 'iPad Pro (12.9-inch) (5th generation)'
-      WebDriverConnect.initialize_web_driver
-      expect(Environ.browser).to eq(:appium)
-      expect(Environ.platform).to eq(:mobile)
-      expect(Environ.headless).to eq(false)
-      expect(Environ.session_state).to eq(:running)
-      expect(Environ.driver).to eq(:appium)
-      expect(Environ.device).to eq(:simulator)
-      expect(Environ.device_name).to eq('iPad Pro (12.9-inch) (5th generation)')
-      expect(Environ.device_os).to eq(:ios)
-      expect(Environ.device_type).to eq(:tablet)
-      expect(Environ.device_os_version).to eq('15.4')
-      expect(Environ.is_ios?).to eq(true)
-    end
-
-    it 'connects to iOS Simulator - desired_capabilities hash' do
-      ENV['APP_PLATFORM_NAME'] = 'ios'
-      ENV['APP_BROWSER'] = 'Safari'
-      ENV['APP_VERSION'] = '15.4'
-      ENV['APP_DEVICE'] = 'iPad Pro (12.9-inch) (5th generation)'
-
-      caps = {
-        desired_capabilities: {
-          platformName: 'ios',
-          platformVersion: '15.4',
-          browserName: 'Safari',
-          deviceName: 'iPad Pro (12.9-inch) (5th generation)',
-          automationName: 'XCUITest'
-        }
-      }
-      WebDriverConnect.initialize_web_driver(caps)
-      expect(Environ.browser).to eq(:appium)
-      expect(Environ.platform).to eq(:mobile)
-      expect(Environ.headless).to eq(false)
-      expect(Environ.session_state).to eq(:running)
-      expect(Environ.driver).to eq(:appium)
-      expect(Environ.device).to eq(:simulator)
-      expect(Environ.device_name).to eq('iPad Pro (12.9-inch) (5th generation)')
-      expect(Environ.device_os).to eq(:ios)
-      expect(Environ.device_type).to eq(:tablet)
-      expect(Environ.device_os_version).to eq('15.4')
-      expect(Environ.is_ios?).to eq(true)
-    end
-
-    it 'connects to Android Simulator - environment variables' do
-      ENV['APP_PLATFORM_NAME'] = 'Android'
-      ENV['APP_BROWSER'] = 'Chrome'
-      ENV['APP_VERSION'] = '12.0'
-      ENV['APP_DEVICE'] = 'Pixel_C_API_31'
-      WebDriverConnect.initialize_web_driver
-      expect(Environ.browser).to eq(:appium)
-      expect(Environ.platform).to eq(:mobile)
-      expect(Environ.headless).to eq(false)
-      expect(Environ.session_state).to eq(:running)
-      expect(Environ.driver).to eq(:appium)
-      expect(Environ.device).to eq(:simulator)
-      expect(Environ.device_name).to eq('Pixel_C_API_31')
-      expect(Environ.device_os).to eq(:android)
-      expect(Environ.device_type).to eq(:tablet)
-      expect(Environ.device_os_version).to eq('12.0')
-      expect(Environ.is_android?).to eq(true)
-    end
-
-    it 'connects to Android Simulator - desired_capabilities hash' do
-      ENV['APP_PLATFORM_NAME'] = 'Android'
-      ENV['APP_BROWSER'] = 'Chrome'
-      ENV['APP_VERSION'] = '12.0'
-      ENV['APP_DEVICE'] = 'Pixel_C_API_31'
-
-      caps = {
-        desired_capabilities: {
-          platformName: 'Android',
-          platformVersion: '12.0',
-          browserName: 'Chrome',
-          deviceName: 'Pixel_C_API_31',
-          automationName: 'Android'
-        }
-      }
-      WebDriverConnect.initialize_web_driver(caps)
-      expect(Environ.browser).to eq(:appium)
-      expect(Environ.platform).to eq(:mobile)
-      expect(Environ.headless).to eq(false)
-      expect(Environ.session_state).to eq(:running)
-      expect(Environ.driver).to eq(:appium)
-      expect(Environ.device).to eq(:simulator)
-      expect(Environ.device_name).to eq('Pixel_C_API_31')
-      expect(Environ.device_os).to eq(:android)
-      expect(Environ.device_type).to eq(:tablet)
-      expect(Environ.device_os_version).to eq('12.0')
-      expect(Environ.is_android?).to eq(true)
-    end
-  end
-
-  after(:each) do
-    Capybara.current_session.quit
-    Environ.session_state = :quit
-  end
-
-  after(:context) do
-    $server.stop if Environ.driver == :appium && $server.running?
-  end
-end

data/spec/testcentricity/web/page_object_spec.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-describe TestCentricity::PageObject, web: 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 '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