rufus 0.1

data/lib/rufus/accessors/accessors.rb

@@ -0,0 +1,25 @@
+module Rufus
+  module Accessors
+
+    def view(name, locator)
+      define_method("#{name}_view") do
+        Rufus::Accessors::View.new(locator)
+      end
+      define_method("#{name}") do
+        Rufus::Accessors::View.new(locator).click
+      end
+    end
+
+    def label(name, locator)
+      view(name, locator)
+    end
+
+    def text(name, locator)
+      view(name, locator)
+    end
+
+    def button(name, locator)
+      view(name, locator)
+    end
+  end
+end

data/lib/rufus/accessors/view.rb

@@ -0,0 +1,47 @@
+module Rufus
+  module Accessors
+    class View
+      include Rufus
+
+      def initialize(locator={})
+        @locator = locator
+      end
+
+      def exists?
+        element = selenium.find(what)
+        false
+        true unless element.nil?
+      end
+
+      def click
+        selenium.find(what).click
+      end
+
+      def displayed?
+        selenium.find(what).displayed?
+      end
+
+      def enabled?
+        selenium.find(what).enabled?
+      end
+
+      def text
+        selenium.find(what).text
+      end
+
+      def send_keys(keys)
+        selenium.find(what).send_keys keys
+      end
+
+      def what
+        key = @locator.keys[0].to_sym
+        value = @locator[key]
+        {key => value}
+      end
+
+      def locator
+        @locator
+      end
+    end
+  end
+end

data/lib/rufus/driver.rb

@@ -0,0 +1,120 @@
+require 'yaml'
+require 'selenium-webdriver'
+
+module Rufus
+  class Driver
+
+    def initialize
+      @config = YAML.load_file('config.yml') unless !File.exists?('config.yml')
+
+      if @config["appium_url"].nil? || @config["appium_url"].eql?("")
+        @url = 'http://127.0.0.1:4723/wd/hub'
+      else
+        @url = @config["appium_url"]
+      end
+
+    end
+
+    def start
+      driver.get @url
+    end
+
+    def config
+      @config
+    end
+
+    def server_url
+      @url
+    end
+
+    def find(locator)
+      how = locator.keys[0].to_sym
+      what = locator[how]
+      driver.find_element(how, what)
+    end
+
+    def click(locator)
+      find(locator).click
+    end
+
+    def press_button name
+      click(:name => name)
+    end
+
+    def enabled?(locator)
+      find(locator).enabled?
+    end
+
+    def displayed?(locator)
+      find(locator).displayed?
+    end
+
+    def type(keys, name)
+      locator = {:name => name}
+      find(locator).send_keys keys
+    end
+
+    def sequence(*names, times)
+      timed_sequence(names, times, 1)
+    end
+
+    def buttons
+      buttons = []
+      elements = elements_by_tag 'UIAButton'
+      elements.each do |element|
+        buttons << element.text
+      end
+      buttons
+    end
+
+    def text_fields
+      fields = []
+      elements = elements_by_tag 'UIATextField'
+      elements.each do |element|
+        fields << element.text
+      end
+      fields
+    end
+
+    def labels
+      labels = []
+      elements = elements_by_tag 'UIAStaticText'
+      elements.each do |element|
+        labels << element.text
+      end
+      labels
+    end
+
+    def timed_sequence(names, times, seconds)
+      current = 0
+      until current == times
+        names.each do |name|
+          click(:name => name)
+          sleep seconds
+
+        end
+        current += 1
+        puts "sequence #{current} completed"
+      end
+    end
+
+    private
+    def elements_by_tag(name)
+      driver.find_elements(:tag_name, name)
+    end
+
+    private
+    def capabilities
+      {
+          'browserName' => @config["browser"],
+          'platform' => @config["platform"],
+          'version' => @config["version"].to_s,
+          'app' => @config["app"]
+      }
+    end
+
+    def driver
+      @selenium ||= Selenium::WebDriver.for(:remote, :desired_capabilities => capabilities, :url => @url)
+    end
+  end
+end

data/lib/rufus/navigation.rb

@@ -0,0 +1,23 @@
+require 'page_navigation'
+
+module Rufus
+  module Navigation
+    include PageNavigation
+
+    def on(cls)
+      screen = cls.new
+
+      wait = 0
+      until wait == 59 do
+
+        if screen.active?
+          return screen
+        else
+          wait += 1
+        end
+      end
+
+        raise "Expected #{cls} to be active"
+      end
+    end
+end

data/lib/rufus.rb

@@ -0,0 +1,11 @@
+require 'rufus/navigation'
+require 'rufus/accessors/accessors'
+require 'rufus/accessors/view'
+
+module Rufus
+
+  def self.included(cls)
+    cls.extend Rufus::Accessors
+  end
+
+end

data/rufus.gemspec

@@ -0,0 +1,13 @@
+Gem::Specification.new do |gem|
+  gem.name          = "rufus"
+  gem.version       = "0.1"
+  gem.authors       = ["Jeremy Stewart"]
+  gem.email         = ["jlstewart379@gmail.com"]
+  gem.description   = "Page object wrapper for Appium"
+  gem.summary       = "Page object wrapper for Appium"
+  gem.homepage      = "https://github.com/jlstewart379/rufus"
+  gem.require_paths = ["lib"]
+  gem.files         = `git ls-files`.split($/)
+  gem.add_dependency 'page_navigation', '>= 0.7'
+  gem.add_development_dependency 'rspec'
+end

data/spec/accessors_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+class TestPage
+  include Rufus
+
+  view(:some_view, :name => 'testView')
+  label(:some_label, :name => 'someLabel')
+  text(:some_text_box, :name => 'someTextBox')
+  button(:some_button, :name => 'someButton')
+
+end
+
+describe Rufus::Accessors do
+
+  let(:screen) { TestPage.new }
+
+  context 'view' do
+    let(:view) { double('View accessor') }
+
+    before(:each) do
+      Rufus::Accessors::View.should_receive(:new).with(:name => 'testView').and_return(view)
+    end
+
+    it 'can return the view object' do
+      screen.some_view_view.should be(view)
+    end
+
+    it 'can click a view' do
+      view.should_receive(:click)
+      screen.some_view
+    end
+  end
+
+  context 'label' do
+    let(:label) { double('Label accessor') }
+
+    before(:each) do
+      Rufus::Accessors::View.should_receive(:new).with(:name => 'someLabel').and_return(label)
+    end
+
+    it 'can return the label' do
+      screen.some_label_view.should be(label)
+    end
+
+    it 'can click a label' do
+      label.should_receive(:click)
+      screen.some_label
+    end
+  end
+
+  context 'text box' do
+    let(:text_box) { double('Label accessor') }
+
+    before(:each) do
+      Rufus::Accessors::View.should_receive(:new).with(:name => 'someTextBox').and_return(text_box)
+    end
+
+    it 'can return the text box' do
+      screen.some_text_box_view.should be(text_box)
+    end
+
+    it 'can click a text box' do
+      text_box.should_receive(:click)
+      screen.some_text_box
+    end
+  end
+
+  context 'button' do
+    let(:button) { double('Label accessor') }
+
+    before(:each) do
+      Rufus::Accessors::View.should_receive(:new).with(:name => 'someButton').and_return(button)
+    end
+
+    it 'can return the button' do
+      screen.some_button_view.should be(button)
+    end
+
+    it 'can click a button' do
+      button.should_receive(:click)
+      screen.some_button
+    end
+  end
+end
+

data/spec/driver_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+require 'rufus/driver'
+require 'yaml'
+
+describe Rufus::Driver do
+
+  let(:selenium){double('Selenium web driver')}
+
+  context 'initializing' do
+
+    let(:yaml){double('YAML loader')}
+
+
+    before(:each) do
+      File.stub(:exists?).and_return(true)
+      YAML.should_receive(:load_file).with("config.yml").and_return("browser_name" =>"iOS", "platform"=>"Mac", "version"=>"6.1", "app"=>"/Users/app/path/rufus.app")
+      @driver = Rufus::Driver.new
+    end
+
+    it 'loads the config file' do
+
+      config = @driver.config
+      config["browser_name"].should eq("iOS")
+      config["platform"].should eq("Mac")
+      config["version"].should eq("6.1")
+      config["app"].should eq("/Users/app/path/rufus.app")
+    end
+
+ end
+
+  context 'dealing with elements' do
+
+    let(:mock_driver){double('mock selenium driver')}
+    let(:mock_elements){double('mock selenium driver elements list')}
+    let(:mock_element){double('mock selenium driver element')}
+
+    before(:each) do
+      File.stub(:exists?).and_return(true)
+      YAML.should_receive(:load_file).with("config.yml").and_return("browser_name" =>"iOS", "platform"=>"Mac", "version"=>"6.1", "app"=>"/Users/app/path/rufus.app")
+
+      @driver = Rufus::Driver.new
+
+      Selenium::WebDriver.should_receive(:for).and_return(mock_driver)
+      mock_driver.should_receive(:find_element).with(:name, 'rufusButton').and_return(mock_element)
+    end
+
+    it 'can find an element by name' do
+      @driver.find({:name => 'rufusButton'})
+    end
+
+    it 'can click on an element by name' do
+      mock_element.should_receive(:click)
+      @driver.click({:name =>'rufusButton'})
+    end
+
+    it 'can click a button by name only' do
+      mock_element.should_receive(:click)
+      @driver.press_button 'rufusButton'
+    end
+
+    it 'can tell if an element is enabled' do
+      mock_element.should_receive(:enabled?).and_return(true)
+      @driver.enabled?(:name => 'rufusButton').should be_true
+    end
+
+    it 'can tell if an element is displayed on screen' do
+      mock_element.should_receive(:displayed?).and_return(true)
+      @driver.displayed?(:name => 'rufusButton').should be_true
+    end
+
+    it 'can enter text into an element' do
+      mock_element.should_receive(:send_keys).with('text')
+      @driver.type('text', 'rufusButton')
+    end
+  end
+
+  context 'finding all elements of a type' do
+
+    let(:mock_driver){double('mock selenium driver')}
+    let(:mock1){double('first mock element')}
+    let(:mock2){double('second mock element')}
+    let(:mock3){double('third mock element')}
+
+    before(:each) do
+      File.stub(:exists?).and_return(true)
+      YAML.should_receive(:load_file).with("config.yml").and_return("browser_name" =>"iOS", "platform"=>"Mac", "version"=>"6.1", "app"=>"/Users/app/path/rufus.app")
+
+      @test_driver = Rufus::Driver.new
+
+      Selenium::WebDriver.should_receive(:for).and_return(mock_driver)
+
+    end
+
+    it 'can find all button elements on the screen' do
+      mock_driver.should_receive(:find_elements).with(:tag_name, 'UIAButton').and_return([mock1, mock2, mock3])
+      mock1.should_receive(:text).and_return("one")
+      mock2.should_receive(:text).and_return("two")
+      mock3.should_receive(:text).and_return("three")
+      @test_driver.buttons.should == ["one", "two", "three"]
+    end
+
+    it 'can find all text field elements on the screen' do
+      mock_driver.should_receive(:find_elements).with(:tag_name, 'UIATextField').and_return([mock1, mock2, mock3])
+      mock1.should_receive(:text).and_return("one")
+      mock2.should_receive(:text).and_return("two")
+      mock3.should_receive(:text).and_return("three")
+      @test_driver.text_fields.should == ["one", "two", "three"]
+    end
+
+    it 'can find all labels on the screen' do
+      mock_driver.should_receive(:find_elements).with(:tag_name, 'UIAStaticText').and_return([mock1, mock2, mock3])
+      mock1.should_receive(:text).and_return("one")
+      mock2.should_receive(:text).and_return("two")
+      mock3.should_receive(:text).and_return("three")
+      @test_driver.labels.should == ["one", "two", "three"]
+    end
+  end
+
+  context 'choosing the url' do
+    before(:each) do
+      File.stub(:exists?).and_return(true)
+      YAML.should_receive(:load_file).with("config.yml").and_return("browser_name" =>"iOS", "platform"=>"Mac", "version"=>"6.1", "app"=>"/Users/app/path/rufus.app")
+      @driver = Rufus::Driver.new
+    end
+    it 'sets the default url' do
+      @driver.server_url.should eq 'http://127.0.0.1:4723/wd/hub'
+    end
+  end
+
+  context 'executing button sequences' do
+
+    let(:mock_driver){double('mock selenium driver')}
+    let(:mock_rufus_button){double('Mock rufus button')}
+    let(:mock_rufus_page_button){double('mock selenium driver element')}
+
+    before(:each) do
+      File.stub(:exists?).and_return(true)
+      YAML.should_receive(:load_file).with("config.yml").and_return("browser_name" =>"iOS", "platform"=>"Mac", "version"=>"6.1", "app"=>"/Users/app/path/rufus.app")
+      @driver = Rufus::Driver.new
+      Selenium::WebDriver.should_receive(:for).and_return(mock_driver)
+    end
+
+    it 'can click buttons in sequence' do
+      mock_driver.should_receive(:find_element).exactly(20).times.with(:name, 'rufusButton').and_return(mock_rufus_button)
+      mock_driver.should_receive(:find_element).exactly(10).times.with(:name, 'rufusPageButton').and_return(mock_rufus_page_button)
+      mock_rufus_button.should_receive(:click).exactly(20).times
+      mock_rufus_page_button.should_receive(:click).exactly(10).times
+      @driver.timed_sequence(['rufusButton', 'rufusPageButton', 'rufusButton'] , 10, 0)
+
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'selenium-webdriver'
+require 'rufus'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/view_spec.rb

@@ -0,0 +1,102 @@
+require 'rufus/accessors/view'
+require 'spec_helper'
+
+
+describe Rufus::Accessors::View do
+
+  context 'checking for existence' do
+    let(:view){Rufus::Accessors::View.new(:label => 'testView')}
+    let(:view_by_text){Rufus::Accessors::View.new(:text => "textViewText")}
+    let(:selenium){double('Selenium::WebDriver')}
+    let(:element){double('Selenium element')}
+
+    before(:each) do
+      view.should_receive(:selenium).and_return(selenium)
+    end
+
+    context 'element exists' do
+      it 'reports that element exists' do
+        selenium.should_receive(:find).and_return(Selenium::WebDriver::Element.new(nil, nil))
+        view.exists?.should be_true
+      end
+    end
+
+    context 'element does not exist' do
+      it 'reports that the element does not exist' do
+        selenium.should_receive(:find).and_return(nil)
+        view.exists?.should be_false
+      end
+    end
+
+    context 'clicking an element' do
+      it 'can click an element' do
+        selenium.should_receive(:find).with({:label =>'testView'}).and_return(element)
+        element.should_receive(:click)
+        view.click
+      end
+    end
+
+    context 'telling if a view is displayed' do
+      it 'can tell if a view is displayed' do
+        selenium.should_receive(:find).with({:label =>'testView'}).and_return(element)
+        element.should_receive(:displayed?).and_return(true)
+        view.displayed?.should be_true
+      end
+      it 'can tell if a view is not displayed' do
+        selenium.should_receive(:find).with({:label =>'testView'}).and_return(element)
+        element.should_receive(:displayed?).and_return(false)
+        view.displayed?.should be_false
+      end
+    end
+
+    context 'telling if a view is enabled' do
+      it 'can tell if a view is enabled' do
+        selenium.should_receive(:find).with({:label =>'testView'}).and_return(element)
+        element.should_receive(:enabled?).and_return(true)
+        view.enabled?.should be_true
+      end
+      it 'can tell if a view is not enabled' do
+        selenium.should_receive(:find).with({:label =>'testView'}).and_return(element)
+        element.should_receive(:enabled?).and_return(false)
+        view.enabled?.should be_false
+      end
+    end
+
+    context 'getting text from a view' do
+      it 'can get the text of a view' do
+        selenium.should_receive(:find).with({:label =>'testView'}).and_return(element)
+        element.should_receive(:text).and_return("some text")
+        view.text.should eq("some text")
+      end
+    end
+
+    context 'sending text input to a view' do
+      it 'can send text input to a view' do
+        selenium.should_receive(:find).with({:label =>'testView'}).and_return(element)
+        element.should_receive(:send_keys).with("keyboard entries")
+        view.send_keys("keyboard entries")
+      end
+    end
+
+  end
+
+  context 'finding element by text' do
+
+    let(:view_by_text){Rufus::Accessors::View.new(:text => "textViewText")}
+    let(:selenium){double('Selenium::WebDriver')}
+    let(:element){double('Selenium element')}
+
+    it 'tells selenium to search by text' do
+      view_by_text.should_receive(:selenium).and_return(selenium)
+      selenium.should_receive(:find).with({:text=>'textViewText'}).and_return(element)
+      view_by_text.exists?
+    end
+  end
+end
+
+
+
+
+
+
+