screen-object 1.0.0

data/lib/screen-object/load_appium.rb

@@ -0,0 +1,31 @@
+=begin
+***********************************************************************************************************
+Copyright 2016 Capital One Services, LLC
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and limitations under the License. 
+***********************************************************************************************************
+=end
+
+module ScreenObject
+  module Load_App
+
+    def self.start_driver
+      $driver.start_driver
+    end
+
+    def self.quit_driver
+      $driver.driver_quit
+    end
+
+    def self.load_driver(appium_txt)
+      #Appium.promote_singleton_appium_methods ScreenObject
+    end
+
+  end
+end

data/lib/screen-object/screen_factory.rb

@@ -0,0 +1,43 @@
+require 'page_navigation'
+
+module ScreenObject
+
+  #
+  # Module to facilitate to creating of screen objects in step definitions.  You
+  # can make the methods below available to all of your step definitions by adding
+  # this module to World.
+  #
+  # @example Making the ScreenFactory available to your step definitions
+  #   World ScreenObject::ScreenFactory
+  #
+  # @example using a screen in a Scenario
+  #   on MyScreenObject do |screen|
+  #     screen.name = 'Cheezy'
+  #   end
+  #
+  # If you plan to use the navigate_to method you will need to ensure
+  # you setup the possible routes ahead of time.  You must always have
+  # a default route in order for this to work.  Here is an example of
+  # how you define routes:
+  #
+  # @example Example routes defined in env.rb
+  #   ScreenObject::ScreenFactory.routes = {
+  #     :default => [[ScreenOne,:method1], [ScreenTwoA,:method2], [ScreenThree,:method3]],
+  #     :another_route => [[ScreenOne,:method1, "arg1"], [ScreenTwoB,:method2b], [ScreenThree,:method3]]
+  #   }
+  #
+  # Notice the first entry of :another_route is passing an argument
+  # to the method.
+  #
+
+  module ScreenFactory
+    include PageNavigation
+
+    def on(screen_class, &blk)
+      @current_screen = screen_class.new
+      blk.call @current_screen if blk
+      @current_screen
+    end
+
+  end
+end

data/lib/screen-object/version.rb

@@ -0,0 +1,4 @@
+
+module ScreenObject
+  VERSION = '1.0.0'
+end

data/screen-object.gemspec

@@ -0,0 +1,28 @@
+$:.push File.expand_path('../lib', __FILE__)
+require 'screen-object/version'
+
+
+Gem::Specification.new do |s|
+  s.name = 'screen-object'
+  s.version = ScreenObject::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = ['Sreepad Bhagwat','Shailendra Jain']
+  s.license = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
+  s.homepage = 'https://github.kdc.capitalone.com/mobius/screen-object'
+  s.summary = 'Page Object like DSL for testing mobile application'
+  s.description = 'Page Object like DSL for testing mobile application'
+
+  s.files = `git ls-files | grep -v sample_app`.split("\n")
+  s.test_files = `git ls-files -- {spec,features}/*`.split("\n")
+  s.executables = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  #s.add_runtime_dependency 'appium_lib', '~> 7.0', '>= 7.0.0'
+  s.add_runtime_dependency 'appium_lib', '~> 8.0.2'
+  s.add_runtime_dependency 'page_navigation', '~> 0.9'
+  s.add_runtime_dependency 'childprocess', '~> 0.5'
+
+  s.add_development_dependency 'cucumber', '~> 1.3', '>= 1.3.0'
+  s.add_development_dependency 'rspec', '~> 3.1', '>= 3.1.0'
+end
+

data/spec/integration/appium_server_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'screen-object/appium_server'
+
+describe ScreenObject::AppiumServer do
+
+
+  let(:the_server) { ScreenObject::AppiumServer.new }
+
+  context 'when appium server is started' do
+    it 'should start the appium server as a process' do
+      the_server.start
+      the_pid = the_server.process.pid
+      expect(the_server.process).to be_running_process
+      Process.kill(9, the_pid)
+    end
+
+    it 'should be stopped when exiting' do
+      the_server.start
+      the_pid = the_server.process.pid
+      the_server.stop
+      expect(the_server.process).to_not be_running_process
+    end
+  end
+end

data/spec/lib/appium_server_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require 'screen-object/appium_server'
+
+describe ScreenObject::AppiumServer do
+
+  attr_reader :the_server
+
+  before(:each) do
+    @process = double(:process)
+    allow(ChildProcess).to receive(:build).and_return(@process)
+    allow(@process).to receive(:start)
+  end
+
+  def the_server(params = {})
+    @the_server ||= ScreenObject::AppiumServer.new(params)
+  end
+
+  def expected_build_params(*params)
+    expect(ChildProcess).to receive(:build).with(*params).and_return(@process)
+  end
+  
+
+  context "when starting the appium server" do
+    it 'should start the appium process with no parameters' do
+      expected_build_params('appium')
+      the_server.start
+    end
+
+    it 'should pass a parameter and value to the appium process' do
+      expected_build_params('appium', '--foo', 'bar')
+      the_server('foo' => 'bar').start
+    end
+
+    it 'should not contain value in the server start parameter if value is nil' do
+      expected_build_params('appium', '--foo')
+      the_server('foo' => nil).start
+    end
+
+    it 'should accept symbol as key for the parameter' do
+      expected_build_params('appium', '--foo', 'bar')
+      the_server(:foo => 'bar').start
+    end
+
+    it 'should start the server process' do
+      expected_build_params('appium')
+      expect(@process).to receive(:start)
+      the_server.start
+    end
+  end
+
+  context "When stopping the appium server" do
+    it 'should stop the appium process' do
+      the_server.start
+      expect(@process).to receive(:stop)
+      the_server.stop
+    end
+  end
+
+end

data/spec/lib/screen_object_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'selenium-webdriver'
+
+class TestScreen
+  include ScreenObject
+end
+
+describe ScreenObject do
+
+  let(:the_screen) { TestScreen.new }
+
+  context 'when waiting for something to happen' do
+
+    let(:wait) { double('wait') }
+
+    before do
+      allow(wait).to receive(:until)
+    end
+
+    it 'should wait for 5 seconds by default' do
+      expect(Selenium::WebDriver::Wait).to receive(:new).with(timeout: 5, message: nil).and_return(wait)
+      the_screen.wait_until { }
+    end
+
+    it 'should allow you to override the default wait time' do
+      expect(Selenium::WebDriver::Wait).to receive(:new).with(timeout: 10, message: nil).and_return(wait)
+      the_screen.wait_until(10) { }
+    end
+
+    it 'should allow you to provide a message to use when wait fails' do
+      expect(Selenium::WebDriver::Wait).to receive(:new).with(timeout: 10, message: 'foobar').and_return(wait)
+      the_screen.wait_until(10, 'foobar') { }
+    end
+  end
+  
+end
+

data/spec/screen-object/button_spec.rb

@@ -0,0 +1,25 @@
+require_relative '../spec_helper'
+
+describe "Interface" do
+
+  locator = "name~dummy"
+  let(:selenium_object) { double('') }
+  let(:button) {ScreenObject::AppElements::Button.new(locator)}
+
+  context "interaction with tap method" do
+    it "should tap on the button" do
+      expect(button).to receive(:element).and_return(selenium_object)
+      expect(selenium_object).to receive(:click).and_return(true)
+      expect(button.tap).to eq(true)
+    end
+  end
+
+  context "interaction with enable method" do
+    it "should check if button is enabled" do
+      expect(button).to receive(:element).and_return(selenium_object)
+      expect(selenium_object).to receive(:enabled?).and_return(true)
+      expect(button.enabled?).to eq(true)
+    end
+  end
+
+end

data/spec/screen-object/checkbox_spec.rb

@@ -0,0 +1,35 @@
+require_relative '../spec_helper'
+
+describe "Interface" do
+
+  locator = "name~dummy"
+  let(:selenium_object) { double('') }
+  let(:check_box) {ScreenObject::AppElements::CheckBox.new(locator)}
+
+  context "interaction with checked method" do
+    it "should retun true if checked?" do
+      expect(check_box).to receive(:element).and_return(selenium_object)
+      expect(selenium_object).to receive(:attribute).with('checked').and_return('true')
+      expect(check_box.checked?).to eq(true)
+    end
+  end
+
+  context "interaction with check method" do
+    it "should check the element" do
+      expect(check_box).to receive(:element).and_return(selenium_object)
+      expect(selenium_object).to receive(:click).and_return(true)
+      expect(check_box).to receive(:checked?).and_return(false)
+      expect(check_box.check).to eq(true)
+    end
+  end
+
+  context "interaction with uncheck method" do
+    it "should uncheck the element" do
+      expect(check_box).to receive(:element).and_return(selenium_object)
+      expect(selenium_object).to receive(:click).and_return(true)
+      expect(check_box).to receive(:checked?).and_return(true)
+      expect(check_box.uncheck).to eq(true)
+    end
+  end
+
+end

data/spec/screen-object/element_spec.rb

@@ -0,0 +1,205 @@
+require_relative '../spec_helper'
+
+describe "Interface" do
+
+   locator = "name~dummy"
+   let(:selenium_driver) {double('')}
+   let(:element) {ScreenObject::AppElements::Element.new(locator)}
+
+  context "interaction with click method" do
+    it "should click on element" do
+      expect(element).to receive(:element).and_return(selenium_driver)
+      expect(selenium_driver).to receive(:click).and_return(true)
+      expect(element.click).to be true
+    end
+
+  end
+
+  context "interaction with value method" do
+    it "should return value" do
+      expect(element).to receive(:element).and_return(selenium_driver)
+      expect(selenium_driver).to receive(:value).and_return("value")
+      expect(element.value).to eql ("value")
+    end
+
+  end
+
+  context "interaction with exists? method" do
+    it "should return value" do
+      expect(element).to receive(:element).and_return(selenium_driver)
+      expect(selenium_driver).to receive(:displayed?).and_return(true)
+      expect(element.exists?).to eql (true)
+    end
+
+  end
+
+   context "interaction with element method" do
+     it "should return element object" do
+       expect(element).to receive(:driver).and_return(selenium_driver)
+       expect(selenium_driver).to receive(:find_element).and_return(selenium_driver)
+       expect(element.element).to eql (selenium_driver)
+     end
+
+   end
+
+   context "interaction with element method" do
+     it "should return element object" do
+       expect(element).to receive(:driver).and_return(selenium_driver)
+       expect(selenium_driver).to receive(:find_elements).and_return(selenium_driver)
+       expect(element.elements).to eql (selenium_driver)
+     end
+
+   end
+
+   context "interaction with element method" do
+     it "should return element object" do
+       expect(element).to receive(:dynamic_xpath).and_return(selenium_driver)
+       expect(selenium_driver).to receive(:displayed?).and_return(true)
+       expect(element.dynamic_text_exists?("dynamic_text")).to eql (true)
+     end
+
+   end
+
+   # context "interaction with scroll method" do
+   #   it "should return element object" do
+   #     expect(element).to receive(:driver).and_return(selenium_driver)
+   #     expect(selenium_driver).to receive(:execute_script).and_return(selenium_driver)
+   #     expect(element.scroll).to eql (selenium_driver)
+   #   end
+   # end
+
+   context "interaction with scroll_for_element_click method" do
+     it "should click on object if it does exists on the first page" do
+       expect(element).to receive(:element).and_return(selenium_driver)
+       expect(selenium_driver).to receive(:displayed?).and_return(true)
+       expect(element).to receive(:element).and_return(selenium_driver)
+       expect(selenium_driver).to receive(:click).and_return(true)
+       expect(element.scroll_for_element_click).to eql (true)
+     end
+
+   end
+
+   context "interaction with scroll_for_element_click method" do
+     it "should scroll for element and click.." do
+       expect(element).to receive(:element).and_return(selenium_driver)
+       expect(selenium_driver).to receive(:displayed?).and_return(false)
+       expect(element).to receive(:scroll).and_return(selenium_driver)
+       expect(element).to receive(:element).and_return(selenium_driver)
+       expect(selenium_driver).to receive(:click).and_return(true)
+       expect(element.scroll_for_element_click).to eql (true)
+     end
+
+   end
+
+   context "interaction with scroll_for_dynamic_element_click method" do
+     it "should click on object if it does exists on the first page" do
+       expect(element).to receive(:dynamic_xpath).with("expected_text").and_return(selenium_driver)
+       expect(selenium_driver).to receive(:displayed?).and_return(true)
+       expect(element).to receive(:element).and_return(selenium_driver)
+       expect(selenium_driver).to receive(:click).and_return(true)
+       expect(element.scroll_for_dynamic_element_click("expected_text")).to eql (true)
+     end
+
+   end
+
+   context "interaction with scroll_for_dynamic_element_click method" do
+     it "should scroll for element and click.." do
+       expect(element).to receive(:dynamic_xpath).with("expected_text").and_return(selenium_driver)
+       expect(selenium_driver).to receive(:displayed?).and_return(false)
+       expect(element).to receive(:scroll).and_return(selenium_driver)
+       expect(element).to receive(:element).and_return(selenium_driver)
+       expect(selenium_driver).to receive(:click).and_return(true)
+       expect(element.scroll_for_dynamic_element_click("expected_text")).to eql (true)
+     end
+
+   end
+
+   context "interaction with click_text method" do
+     it "should click on object if it does exists on the first page" do
+       expect(element).to receive(:exists?).and_return(true)
+       expect(element).to receive(:click).and_return(true)
+       expect(element.click_text("text")).to eq (true)
+     end
+
+   end
+
+   context "interaction with click_text method" do
+     it "should click on object if it does exists on the first page" do
+       expect(element).to receive(:exists?).and_return(false)
+       expect(element).to receive(:scroll_to_text).with("text").and_return(selenium_driver)
+       expect(element).to receive(:element).and_return(selenium_driver)
+       expect(selenium_driver).to receive(:click).and_return(true)
+       expect(element.click_text("text")).to eq (true)
+     end
+
+   end
+
+   context "interaction with click_dynamic_text method" do
+     it "should click on object if it does exists on the first page" do
+       expect(element).to receive(:dynamic_text_exists?).with("text").and_return(true)
+       expect(element).to receive(:element).and_return(selenium_driver)
+       expect(selenium_driver).to receive(:click).and_return(true)
+       expect(element.click_dynamic_text("text")).to eq (true)
+     end
+
+   end
+
+   context "interaction with click_dynamic_text method" do
+     it "should click on object if it does exists on the first page" do
+       expect(element).to receive(:dynamic_text_exists?).with("text").and_return(false)
+       expect(element).to receive(:scroll_to_text).with("text").and_return(selenium_driver)
+       expect(element).to receive(:element).and_return(selenium_driver)
+       expect(selenium_driver).to receive(:click).and_return(true)
+       expect(element.click_dynamic_text("text")).to eq (true)
+     end
+
+   end
+
+
+   context "interaction with click_exact_text method" do
+     it "should click on object if it does exists on the first page" do
+       expect(element).to receive(:exists?).and_return(true)
+       expect(element).to receive(:click).and_return(true)
+       expect(element.click_exact_text("text")).to eq (true)
+     end
+
+   end
+
+   context "interaction with click_exact_text method" do
+     it "should click on object if it does exists on the first page" do
+       expect(element).to receive(:exists?).and_return(false)
+       expect(element).to receive(:scroll_to_exact_text).with("text").and_return(selenium_driver)
+       expect(element).to receive(:element).and_return(selenium_driver)
+       expect(selenium_driver).to receive(:click).and_return(true)
+       expect(element.click_exact_text("text")).to eq (true)
+     end
+
+   end
+
+   context "interaction with click_dynamic_exact_text method" do
+     it "should click on object if it does exists on the first page" do
+       expect(element).to receive(:dynamic_text_exists?).with("text").and_return(true)
+       expect(element).to receive(:element).and_return(selenium_driver)
+       expect(selenium_driver).to receive(:click).and_return(true)
+       expect(element.click_dynamic_exact_text("text")).to eq (true)
+     end
+
+   end
+
+   context "interaction with click_exact_text method" do
+     it "should click on object if it does exists on the first page" do
+       expect(element).to receive(:dynamic_text_exists?).with("text").and_return(false)
+       expect(element).to receive(:scroll_to_exact_text).with("text").and_return(selenium_driver)
+
+       expect(element).to receive(:element).and_return(selenium_driver)
+       expect(selenium_driver).to receive(:click).and_return(true)
+       expect(element.click_dynamic_exact_text("text")).to eq (true)
+     end
+
+   end
+
+
+end
+
+
+