rutl 0.6.0 → 0.8.0

data/lib/rspec/rutl_matchers.rb

@@ -1,11 +1,13 @@
-require 'utilities'
+require 'utilities/check_view'
 #
 # Additional RSpec matchers specific to this framework go here.
 #
+module RSpec
+  include CheckView
 
-# Is it the expected page?
-RSpec::Matchers.define :be_page do |expected|
-  match do |actual|
-    actual.is_a?(expected) && page?(expected)
+  Matchers.define :be_view do |expected|
+    match do |actual|
+      actual.is_a?(expected) && view?(expected)
+    end
   end
 end

data/lib/rutl.rb

@@ -1,4 +1,4 @@
-require 'rutl/browser'
+require 'rutl/application'
 require 'rutl/version'
 #
 # TODO: Rename to something better. RubyUI2API? RAPID for Ruby API DSL?
@@ -6,13 +6,33 @@ require 'rutl/version'
 # desktop UI testing, turning the UI into an API via its DSL.
 #
 module RUTL
-  # Should define RUTL::PAGES directory for your code
-  # or set ENV['RUTL_PAGES']
-  # or Browser intialize will raise.
-  # PAGES = nil
+  # maybe this doesn't exist so much anymore.
+  # Should there be one flat directory? Nested dirs organized?
+  # web pages aren't the same as app views (have urls)
+  # or do I make them look the same?
+  # Not have any methods for views that depend on url or have them explicitly
+  # call out url and non-url versions.
+  #
+  # Should define RUTL::VIEWS directory for your code
+  # or set ENV['RUTL_VIEWS']
+  # or Application intialize will raise.
+  # VIEWS = nil
+
+  # HUNGARIAN automatically appends _<element_type> to all view elements.
+  # So
+  #   button :foo
+  # is referred to later in code as
+  #    foo_button
+  # instead of just the flat name. So
+  #   bar_link.click
+  # instead of
+  #   bar.click
+  #
+  # And I like it so it goes on by default.
+  HUNGARIAN = true
 
   # If this RUTL::SCREENSHOT_DIR or ENV['SCREENSHOT_DIR']
-  # or Browser initialize is set, we take screenshots.
+  # or Application initialize is set, we take screenshots.
   # SCREENSHOTS = nil
 
   # This one is for diffing against.

data/lib/rutl/appium/appium_extension.rb

@@ -0,0 +1,27 @@
+module Appium
+  ##
+  # Extend Appium because I keep digging through WinAppDriver junk to
+  # figure out what's broken.
+  #
+  class Driver
+    def start
+      start_driver
+    rescue RuntimeError => e
+      if e.cause.to_s =~ /Failed to open TCP connection/
+        puts 'Cannot reach Appium server. Is it running? On the right port?'
+      else
+        puts "Cannot diagnose:\n#{e}"
+      end
+      exit
+    rescue Selenium::WebDriver::Error::NoSuchWindowError => e
+      puts "\n\n" + e.class
+      puts "\n\n" + e.cause
+      puts "\n\n" + e.backtrace
+      puts "\n\n" + (e.methods - Class.methods)
+    end
+
+    def quit
+      driver_quit
+    end
+  end
+end

data/lib/rutl/appium/appium_server.rb

@@ -0,0 +1,36 @@
+require 'faraday'
+require 'utilities/waiter'
+#
+# Class to wrap Appium in a Rubyish way.
+#
+class AppiumServer
+  include Waiter
+  attr_accessor :port, :server
+
+  def initialize(server: nil, port: nil)
+    @server = server || 'localhost'
+    @port = port || 4723
+  end
+
+  def quiet_cmd(in_string)
+    system in_string + ' 1>nul 2>&1'
+  end
+
+  def start
+    raise 'server already started' if started?
+    quiet_cmd('start "appium" cmd /c appium')
+    await -> { started? }
+  end
+
+  def started?
+    Faraday.get("http://#{@server}:#{@port}/wd/hub/status")
+    true
+  rescue Faraday::ConnectionFailed
+    false
+  end
+
+  def stop
+    raise 'server not started' unless started?
+    quiet_cmd('taskkill /f /fi "WINDOWTITLE eq appium" /t')
+  end
+end

data/lib/rutl/appium/windows_test_app_wrapper.rb

@@ -0,0 +1,40 @@
+require 'win32/window'
+require 'utilities/waiter'
+#
+# wrapper for simple test apps
+#
+class WindowsTestApp
+  include Waiter
+  attr_reader :window_handle_string
+
+  def initialize(name:, title:)
+    @name = name
+    @title = title
+  end
+
+  def find_window_by_title
+    result = Win32::Window.find(title: @title)
+    raise 'found more than one instance of app' if result.size > 1
+    result.empty? ? false : result.first
+  end
+
+  def wait_for_started
+    app_window = await -> { find_window_by_title }
+    @pid = app_window.pid
+    @window_handle_string = format('0x%08x', app_window.handle)
+  end
+
+  def start
+    quiet_cmd "start \"NO TITLE\" #{@name}"
+    wait_for_started
+  end
+
+  def stop
+    quiet_cmd "taskkill /f /pid #{@pid} /t"
+  end
+  alias kill stop
+
+  def quiet_cmd(in_string)
+    system in_string + ' 1>nul 2>&1'
+  end
+end

data/lib/rutl/application.rb

@@ -0,0 +1,70 @@
+require 'rutl/view'
+require 'utilities/string'
+
+module RUTL
+  #
+  # Application, this top-level class, controls a browser and
+  # a fake browser. It will soon call into apps, at which point I need to
+  # rethink this naming convention.
+  #
+  class Application
+    attr_reader :interface
+
+    def screenshot
+      @interface.camera.screenshot
+    end
+
+    def initialize(family:, type:, views: RUTL::VIEWS || ENV['RUTL_VIEWS'])
+      raise 'Must set views!' if views.nil? || views.empty?
+      # This is kind of evil. Figure out how to ditch the $ variable.
+      $application = self
+      @interface = load_interface(family: family, type: type)
+      @interface.views = load_views(directory: views)
+    end
+
+    def method_missing(method, *args, &block)
+      if args.empty?
+        @interface.send(method)
+      else
+        @interface.send(method, *args, &block)
+      end
+    end
+
+    def respond_to_missing?(*args)
+      @interface.respond_to?(*args)
+    end
+
+    private
+
+    def load_interface(family:, type:)
+      require "rutl/interface/#{family}/#{type}"
+      klass = "RUTL::Interface::#{type.to_s.pascal_case}"
+      Object.const_get(klass).new
+    end
+
+    def load_views(directory:)
+      require_views(directory: directory).map do |klass|
+        Object.const_get(klass).new(@interface)
+      end
+    end
+
+    # Ugly. Requires files for view objects.
+    # Returns array of class names to load.
+    def require_views(directory:)
+      Dir["#{directory}/*"].map do |file|
+        result = find_class_name(file)
+        result if result
+      end
+    end
+
+    def find_class_name(file)
+      require "rutl/../../#{file}"
+      File.open(file).each do |line|
+        bingo = line.match(/class (.*) < RUTL::View/)
+        # One class per file.
+        return bingo[1] if bingo && bingo[1]
+      end
+      false
+    end
+  end
+end

data/lib/rutl/camera.rb

@@ -27,14 +27,30 @@ module RUTL
 
     def shoot(path = nil)
       return if guard
+      file = prepare_shot(path)
+      cheese_already(file)
+    end
+    alias screenshot shoot
+
+    def prepare_shot(path = nil)
+      FileUtils.mkdir_p @dir
       # Magic path is used for all auto-screenshots.
       name = path || magic_path
+      File.join(@dir, pathify(name))
+    end
 
-      FileUtils.mkdir_p @dir
-      file = File.join(@dir, pathify(name))
-      @driver.save_screenshot(file)
+    def cheese_already(file)
+      if @driver.respond_to?(:save_screenshot)
+        @driver.save_screenshot(file)
+      elsif @driver.respond_to?(:screenshot)
+        @driver.screenshot(file)
+      else
+        raise 'unknown screenshot method!'
+      end
+    rescue Selenium::WebDriver::Error::NoSuchWindowError
+      puts 'app closed; no photos, please'
+      # leave a zero length file as a sign that we came down this path
     end
-    alias screenshot shoot
 
     def clean_dir(dir)
       FileUtils.rm_rf dir

data/lib/rutl/element/click_to_change_state_mixin.rb

@@ -14,7 +14,7 @@ module RUTL
       # * Returns the state we transitioned to.
       def click
         @context.interface.camera.screenshot
-        this_css.click
+        @context.find_element.click
         result = @context.interface.wait_for_transition(@context.destinations)
         @context.interface.camera.screenshot
         result

data/lib/rutl/element/element.rb

@@ -1,7 +1,7 @@
 module RUTL
   module Element
     #
-    # Page element base class.
+    # View element base class.
     #
     class Element
       attr_accessor :context
@@ -10,19 +10,18 @@ module RUTL
         raise element_context.to_s unless element_context.is_a? ElementContext
         @context = element_context
         # Not sure why, but I'm seeing Chrome fail becase the context interface
-        # passed in isn't the same as the browser's interface.
+        # passed in isn't the same as the application's interface.
         # This only happens with click test cases, before the click, and
         # only if that case isn't run first.
         # The context we're passed is also an instance from as
         # RUTL::Interface::Chrome, but a different instance.
         #
         # Here's the kludge workaround line:
-        @context.interface = $browser.interface
+        @context.interface = $application.interface
       end
 
-      # Returns the element at this css selector.
-      def this_css
-        @context.find_element(:css)
+      def find_element
+        @context.find_element
       end
 
       # Returns boolean, of course.
@@ -30,21 +29,21 @@ module RUTL
       # have a valid Element object for something that doesn't exist. Anymore.
       # Or yet.
       def exists?
-        this_css
+        find_element
       rescue Selenium::WebDriver::Error::NoSuchElementError
         false
       end
 
       def method_missing(method, *args, &block)
         if args.empty?
-          this_css.send(method)
+          find_element.send(method)
         else
-          this_css.send(method, *args, &block)
+          find_element.send(method, *args, &block)
         end
       end
 
       def respond_to_missing?(*args)
-        this_css.respond_to?(*args)
+        find_element.respond_to?(*args)
       end
     end
   end

data/lib/rutl/element/element_context.rb

@@ -17,7 +17,7 @@ module RUTL
       def initialize(destinations: nil, interface: nil, selectors: [])
         unless destinations.nil? || destinations.class == Array
           # Should check each destination to make sure it's a
-          # Page or a _____, too.
+          # View or a _____, too.
           raise 'destination must be an Array of destinations or nil.'
         end
         @destinations = destinations || []
@@ -29,11 +29,12 @@ module RUTL
         @selectors = selectors
       end
 
-      def find_element(type)
+      def find_element(type = nil)
+        type ||= @selectors.first.first
         # @interface.driver.find_element(type, @selectors[type])
         # Should be this, but apparently @interface.driver is being overwritten
-        # (or not written to) and it doesn't work. Using $browser does. :-(
-        $browser.interface.driver.find_element(type, @selectors[type])
+        # (or not written to) and it doesn't work. Using $application does. :-(
+        $application.interface.driver.find_element(type, @selectors[type])
       end
     end
   end

data/lib/rutl/element/string_reader_writer_mixin.rb

@@ -14,28 +14,32 @@ module RUTL
 
       # I could cut set() and only foo_text= if I change this.
       # The problem I'm running into is not having the driver in
-      # base element to do this_css calls. So I have to change the way
+      # base element to do find_element calls. So I have to change the way
       # drivers are passed into everything or initially have them everywhere,
-      # which means rewriting chosen drivers or changing page load.
+      # which means rewriting chosen drivers or changing view load.
       # Ick.
       def set(string)
         clear
-        this_css.send_keys(string)
+        find_element.send_keys(string)
       end
       alias text= set
       alias value= set
 
       # Return the String held by this element.
       def get
-        this_css.attribute(:value)
+        found = find_element
+        # This is a clumsy workaround for winappdriver, which gets textfields
+        # as #text even though everything else seems to use #attribute(:value).
+        # If both are false, this is undefined.
+        found.attribute(:value) || found.text
       end
       alias text get
       alias value get
       alias to_s get
 
-      # Talk to the page and set the element's string to ''.
+      # Talk to the view  and set the element's string to ''.
       def clear
-        this_css.clear
+        find_element.clear
         get
       end
 
@@ -48,7 +52,7 @@ module RUTL
       # Sends these keystrokes without clearing the field.
       # Returns the whole string in the field, including this input.
       def send_keys(string)
-        this_css.send_keys(string)
+        find_element.send_keys(string)
         get
       end
 

data/lib/rutl/interface/base.rb

@@ -1,15 +1,17 @@
-require 'utilities'
 require 'rutl/camera'
+require 'utilities/check_view'
+require 'utilities/waiter'
 
 module RUTL
   module Interface
     #
     # I might need to consider renaming these.
-    # The *interface classes lie between Browser
+    # The *interface classes lie between Application
     # and the webdriver-level classes.
     #
     class Base
-      include Utilities
+      include CheckView
+      include Waiter
 
       # RUTL::Driver
       attr_accessor :driver
@@ -17,72 +19,72 @@ module RUTL
       # RUTL::Camera
       attr_accessor :camera
 
-      # Array of all RUTL::Page classes
-      attr_accessor :pages
+      # Array of all RUTL::View classes
+      attr_accessor :views
 
       def initialize
         raise 'Child interface class must set @driver.' if @driver.nil?
         # base_name avoids collisions when unning the same tests with
-        # different browsers.
+        # different applications
         name = self.class.to_s.sub('RUTL::Interface', '')
         @camera = Camera.new(@driver, base_name: name)
       end
 
-      # Attempts to navigate to the page.
+      # Attempts to navigate to the view.
       # Takes screenshot if successful.
-      def goto(page)
-        raise 'expect Page class' unless page?(page)
-        find_page(page).go_to_here
+      def goto(view)
+        raise 'expect View class' unless view?(view)
+        find_view(view).go_to_here
         @camera.screenshot
       end
 
       # Should define in children; raises here.
-      # Should return the current page class.
-      def current_page
+      # Should return the current view class.
+      def current_view
         raise 'define in child classes'
       end
 
       def method_missing(method, *args, &block)
         if args.empty?
-          current_page.send(method)
+          current_view.send(method)
         else
-          current_page.send(method, *args, &block)
+          current_view.send(method, *args, &block)
         end
       end
 
-      # TODO: Is this needed? I not only find the page but also make sure the
-      # urls match. Even though that's what finding pages means?
+      # TODO: Is this needed? I not only find the view but also make sure the
+      # urls match. Even though that's what finding views means?
       def find_state(target_states)
         target_states.each do |state|
-          next unless state.url == current_page.url
-          page = find_page(state)
-          return page if page.loaded?
+          next unless state.url == current_view.url
+          view = find_view(state)
+          return view if view.loaded?
         end
         false
       end
 
-      # Attempts to find page by class or url.
-      def find_page(page)
-        @pages.each do |p|
-          return p if page?(page) && p.class == page
-          return p if String == page.class && page == p.url
+      # Attempts to find view by class or url.
+      def find_view(view)
+        @views.each do |p|
+          return p if view?(view) && p.class == view
+          return p if String == view.class && view == p.url
         end
-        raise "Page \"#{page}\" not found in pages #{@pages}"
+        raise "View \"#{view}\" not found in views #{@views}"
       end
 
       # Calls the polling utility mathod await() with a lambda trying to
-      # find the next state, probably a Page class.
+      # find the next state, probably a View class.
       def wait_for_transition(target_states)
         #
         # TODO: Should also see if there are other things to wait for.
-        # I don't think this is doing page load time.
+        # I don't think this is doing view load time.
         #
         await -> { find_state target_states }
       end
 
       def respond_to_missing?(*args)
         # This can't be right. Figure it out later.
-        current_page.respond_to?(*args)
+        current_view.respond_to?(*args)
       end
 
       def quit