lebowski 0.1.0

data/lib/lebowski/foundation/application.rb

@@ -0,0 +1,315 @@
+# ==========================================================================
+# Project:   Lebowski Framework - The SproutCore Test Automation Framework
+# License:   Licensed under MIT license (see License.txt)
+# ==========================================================================
+
+module Lebowski
+  module Foundation
+    
+    #
+    # This class represents a SproutCore-based application. In order to interact with the
+    # actual application you must create an instance of this class and start it. Once
+    # started, you are then free to access any object or view that has been created by 
+    # the application within the web browser.  
+    #
+    class Application < Lebowski::Foundation::SCObject
+      include Lebowski
+      include Lebowski::Foundation
+      include Lebowski::Foundation::Panes
+      include Lebowski::Foundation::Mixins::KeyCheck
+    
+      SAFARI = '*safari'
+      FIREFOX = '*firefox'
+      CHROME = '*chrome'
+      
+      DEFAULT_BROWSER = FIREFOX
+      DEFAULT_SELENIUM_SERVER_HOST = 'localhost'
+      DEFAULT_SELENIUM_SERVER_PORT = 4444
+      DEFAULT_APP_SERVER_HOST = 'localhost'
+      DEFAULT_APP_SERVER_PORT = 4020
+      DEFAULT_TIMEOUT_IN_SECONDS = 240
+    
+      attr_reader :app_name,
+                  :app_root_path,
+                  :host,
+                  :port,
+                  :base_url,
+                  :session_id,
+                  :browser,
+                  :app_is_loaded_flag
+                  
+      #
+      # Creates an Application instance that will allow you to interact with a
+      # SproutCore-based application.
+      #
+      # Initialization requires a hash input containing parameters to set up
+      # the application instance. At minimum, the following are required
+      #
+      #   app_root_path  => The root URL path to the SproutCore-based application (e.g. /my_app)
+      #   app_name       => The name of the application's root object (e.g. MyApp)
+      #
+      # In addition to the two required params, the following optional params can
+      # also be supplied:
+      #
+      #   selenium_server_host => The name of the host the selenium server is running on (default is localhost)
+      #   selenium_server_port => The port the selenium server is listening on (default is 4444)
+      #   app_server_host      => The name of the server hosting the web application (defalt is localhost)
+      #   app_server_port      => The port on the server to access the web application (default is 4020)
+      #   browser              => The web browser to load the web application in to (default is SAFARI)
+      #
+      # Example:
+      #
+      #   Lebowski::Foundation::Application.new \
+      #     :app_root_path => "/hello_world",
+      #     :app_name => "HelloWorldApp"
+      #
+      def initialize(params)
+        super()
+        
+        if params.nil?
+          raise ArgumentError.new "must supply parameters to create application instance"
+        end
+        
+        if not params.kind_of?(Hash)
+          raise ArgumentError.new "must supply a hash containing parameters"
+        end
+        
+        @host = get_selenium_server_host(params)
+        @port = get_selenium_server_port(params)
+        @browser = get_browser(params)
+        
+        @app_root_path = get_app_root_path(params)
+        raise ArgumentError.new "Application root path is required - :app_root_path" if @app_root_path.nil?
+        
+        @app_name = get_app_name(params)
+        raise ArgumentError.new "Application name is required - :app_name" if @app_name.nil?
+        
+        @rel_path = @app_name
+        @app_is_loaded_flag = get_app_is_loaded_flag(params)
+        @timeout_in_seconds = get_timeout_in_second(params)
+        @base_url = get_application_base_url(params)
+        @session_id = get_session_id(params)
+        
+        @driver = Lebowski::Runtime::SproutCoreDriver.new \
+          :host => @host, 
+          :port => @port, 
+          :browser => @browser, 
+          :url => @base_url, 
+          :timeout_in_second => @timeout_in_seconds
+          
+        @started = false 
+      end
+    
+      #
+      # Responsible for starting the application. The application will create
+      # an internal driver that is used to actually communicate with the 
+      # selenium server. 
+      #
+      # You can optionally supply a block used to wait until some condition 
+      # has been satisfied before going on and running the rest of your script. 
+      # Example:
+      #
+      #   application.start do |it|
+      #     it['appIsLoaded'] == true
+      #   end
+      #
+      # If the condition does not become true before timing out then an exception
+      # will be thrown. You can adjust the timeout like so,
+      #
+      #   application.start(20) do |it|
+      #     it['appIsLoaded'] == true
+      #   end
+      #
+      def start(timeout=nil, &block)
+        return if started?
+        
+        begin
+          if @session_id.nil? 
+            @driver.start
+          else 
+            @driver.session_id = @session_id
+          end
+          
+          @driver.set_application_name @app_name
+        	@driver.open_sc_application @app_root_path, @timeout_in_seconds
+        	@started = true
+        rescue Exception => ex
+          err_message = "Error connecting to selenium server: #{ex.message}\n"
+          err_message << "Confirm that selenium server is running on #{@selenium_server_host}:#{@selenium_server_port}"
+          raise Runtime::SeleniumServerError.new err_message
+        end
+        
+        if block_given?
+          begin
+            wait_until(timeout, &block)
+          rescue TimeoutError => toe
+            err_message = "Unable to start application. Wait condition was not met before timeout. #{toe.message}"
+            raise TimeoutError.new err_message
+          end
+        end
+      	
+      end
+      
+      def end()
+        return if (not started?)
+        
+        begin
+          @driver.stop
+          @started = false
+        rescue Exception => ex
+          err_message = "Error disconnecting from selenium server: #{ex.message}\n"
+          err_message << "Confirm that selenium server is running on #{@selenium_server_host}:#{@selenium_server_port}"
+          raise Runtime::SeleniumServerError.new err_message
+        end
+      end
+      
+      def started?()
+        return @started
+      end
+      
+      def window()
+        @window = Window.new(@driver) if @window.nil?
+        return @window
+      end
+      
+      def abs_path()
+        return nil
+      end
+      
+      def root_object(name, expected_type=nil)
+        return self['$' + name, expected_type]
+      end
+      
+      alias_method :framework, :root_object
+      
+      def main_pane(expected_type=nil)
+        return self['$SC.RootResponder.responder.mainPane', expected_type]
+      end
+      
+      def key_pane(expected_type=nil)
+        return self['$SC.RootResponder.responder.keyPane', expected_type]
+      end
+      
+      def responding_panes()
+        if @responding_panes.nil?
+          @responding_panes = ObjectArray.new self, '$SC.RootResponder.responder.panes'
+        end
+        return @responding_panes
+      end
+      
+      def define_root_object(key, name, expected_type=nil)
+        return define(key, '$' + name, expected_type)
+      end
+      
+      alias_method :define_framework, :define_root_object
+      
+    private
+    
+      def get_selenium_client(params)
+        return params[:driver]
+      end
+    
+      def get_selenium_server_host(params)
+        client = get_selenium_client(params) 
+        return client.host if (not client.nil?)
+        return DEFAULT_SELENIUM_SERVER_HOST if params[:selenium_server_host].nil?
+        return params[:selenium_server_host]
+      end
+      
+      def get_selenium_server_port(params)
+        client = get_selenium_client(params) 
+        return client.port if (not client.nil?)
+        return DEFAULT_SELENIUM_SERVER_PORT if params[:selenium_server_port].nil?
+        return params[:selenium_server_port].to_i
+      end
+      
+      def get_app_server_host(params)
+        return DEFAULT_APP_SERVER_HOST if params[:app_server_host].nil?
+        return params[:app_server_host]
+      end
+      
+      def get_app_server_port(params)
+        return DEFAULT_APP_SERVER_PORT if params[:app_server_port].nil?
+        return params[:app_server_port].to_i
+      end
+      
+      def get_application_base_url(params)
+        client = get_selenium_client(params) 
+        return client.browser_url if (not client.nil?)
+        return "http://#{get_app_server_host(params)}:#{get_app_server_port(params)}"
+      end
+      
+      def get_session_id(params)
+        client = get_selenium_client(params) 
+        return client.session_id if (not client.nil?)
+        return nil
+      end
+      
+      def get_browser(params)
+        client = get_selenium_client(params) 
+        return client.browser_string if (not client.nil?)
+        
+        browser = params[:browser]
+        case (browser)
+        when :firefox
+          return FIREFOX
+        when :safari
+          return SAFARI
+        else
+          return DEFAULT_BROWSER
+        end
+      end
+      
+      def get_app_root_path(params)
+        return params[:app_root_path]
+      end
+      
+      def get_app_name(params)
+        return params[:app_name]
+      end
+      
+      def get_app_is_loaded_flag(params)
+        return params[:app_is_loaded_flag] 
+      end
+      
+      def get_timeout_in_second(params)
+        return DEFAULT_TIMEOUT_IN_SECONDS if params[:timeout_in_seconds].nil?
+        return params[:timeout_in_seconds].to_i
+      end
+    
+    end
+    
+    #
+    # Represents the browser window the application has been loaded into
+    #
+    class Window
+      
+      def initialize(driver)
+        @driver = driver
+      end
+      
+      #
+      # Moves the browser window
+      #
+      def move_to(x, y)
+        @driver.sc_window_move_to(x,y)
+      end
+      
+      #      
+      # Resizes the browser window
+      #
+      def resize_to(width, height)
+        @driver.sc_window_resize_to(width, height)
+      end
+      
+      #
+      # Maximizes the browser window
+      #
+      def maximize() 
+        @driver.sc_window_maximize
+      end
+      
+    end
+    
+  end
+end

data/lib/lebowski/foundation/core.rb

@@ -0,0 +1,61 @@
+module Lebowski
+  module Foundation
+   
+    # A SproutCore error instance (SC.Error)
+    SC_T_ERROR = 'error'
+
+    # Null value
+    SC_T_NULL = 'null' 
+
+    # Undefined value
+    SC_T_UNDEFINED = 'undefined'
+
+    # A function
+    SC_T_FUNCTION = 'function'
+
+    # Number primitive
+    SC_T_NUMBER = 'number'
+
+    # Boolean primitive 
+    SC_T_BOOL = 'boolean'
+
+    # An instance of Array
+    SC_T_ARRAY = 'array'
+
+    # String primitive
+    SC_T_STRING = 'string' 
+
+    # A JavaScript object not inheriting from SC.Object 
+    SC_T_HASH = 'hash' 
+
+    # A SproutCore class (created using SC.Object.extend())
+    SC_T_CLASS = 'class'
+
+    # A SproutCore object instance
+    SC_T_OBJECT = 'object'
+    
+    SC_MIXED_STATE = '__MIXED__'
+    
+    # Constants used by the collection view. see SproutCore file collection_content.js
+    SC_LEAF_NODE = 0x0020
+    SC_BRANCH_OPEN = 0x0011
+    SC_BRANCH_CLOSED = 0x0012
+    
+    module Util
+
+      def assert_is_object(value, name) 
+        if not value.kind_of? Lebowski::Foundation::ProxyObject
+          raise ArgumentInvalidTypeError.new name, value, Lebowski::Foundation::ProxyObject
+        end
+      end
+
+      def assert_is_view(value, name)
+        if not value.kind_of? Lebowski::Foundation::Views::View
+          raise ArgumentInvalidTypeError.new name, value, Lebowski::Foundation::Views::View
+        end
+      end
+
+    end
+    
+  end
+end

data/lib/lebowski/foundation/core_query.rb

@@ -0,0 +1,231 @@
+# ==========================================================================
+# Project:   Lebowski Framework - The SproutCore Test Automation Framework
+# License:   Licensed under MIT license (see License.txt)
+# ==========================================================================
+
+module Lebowski
+  module Foundation
+   
+    #
+    # Represents a SproutCore Core Query object. This proxy provides a subset of the
+    # functionality that the actual core query object has.
+    #
+    # The core query is obtained through a view object and requires a CSS selector.
+    # Based on the associated view and given selector, the core query object will
+    # then contain zero or more DOM elements that match the selector starting from
+    # the view's layer (read: root DOM element).
+    #
+    # For feature and integration testing, the use of the core query object may be
+    # too low-level. Rather, this object is handy for custom views that override
+    # the render method. By creating a proxy to the custom view you can then use
+    # this object to do some fine grained checks that you don't want to expose
+    # to the casual tester, for instance.
+    #
+    class CoreQuery
+     
+      INVALID_HANDLE = -1
+     
+      attr_reader :selector, # The CSS selector
+                  :handle,   # The handle to the remote core query object
+                  :abs_path  # The absolute path to the view this object comes from
+     
+      #
+      # Creates an instance. Once created, it will have a handle to the remote
+      # core query object in order to perform subsequent calls. Call the done()
+      # method when this object is no longer used
+      #
+      # @param abs_path {String} a property path to the view the core query object will come from
+      # @param selector {String} a CSS selector. See SproutCore's CoreQuery object for more details
+      # @param driver {Object} driver to communicate with the selenium server
+      #
+      def initialize(abs_path, selector, driver)
+        @abs_path = abs_path
+        @selector = selector.nil? ? "" : selector
+        @driver = driver
+        @handle = INVALID_HANDLE
+        @size = 0
+        
+        @handle = @driver.get_sc_core_query(abs_path, selector)
+        @size = @driver.get_sc_core_query_size(@handle) if has_handle?
+      end
+     
+      #
+      # Returns the number of elements found by this core query object
+      #
+      def size()
+        return @size if has_handle?
+        return -1
+      end
+      
+      #
+      # Checks if this object has a handle to the remote core query object
+      #
+      def has_handle?()
+        return (not @handle == INVALID_HANDLE) 
+      end
+      
+      #
+      # Will clean up this object when no longer used 
+      #
+      def done()
+        @driver.sc_core_query_done(@handle)
+        @handle = INVALID_HANDLE
+      end
+      
+      #
+      # Get an element at a given index. Returns an instance of DOMElement
+      #
+      # @param index {Number} returns element if this object has a handle and
+      #        the index is within range
+      #
+      def [](index)
+        if has_handle? and (index > -1) and (index <= (@size - 1))
+          return Lebowski::Foundation::DOMElement.new @handle, index, @driver
+        end
+        return nil
+      end
+      
+      #
+      # Used to iterate through each element in this object. The block provided
+      # will be provided to argments: the element and its index. You can use this
+      # method as follows:
+      #
+      #   core_query.each do |element, index |
+      #     ...
+      #   end
+      #
+      def each(&block)
+        return if (not has_handle? or not block_given? or size <= 0) 
+        
+        for i in 0..size - 1 do
+          elem = Lebowski::Foundation::DOMElement.new @handle, i, @driver
+          yield elem, i
+        end
+      end
+      
+      #
+      # Used to fetch elements from this object. The block provided
+      # is used to return an element that will be added to the array
+      # of elements to be returned. If the block does not return an
+      # element then the element will not be added to the resulting 
+      # array. As an example:
+      #
+      #   elements = core_query.fetch { |element, index| element if element.text == 'foo' }
+      #
+      # The result array will then contain all elements in the core query
+      # object that have text equal to 'foo'. if no elements match then
+      # an empty array is returned.
+      #
+      # The block provided is to have the following setup:
+      #
+      #   do |element, index|    OR   { |element, index| ... }
+      #     ...
+      #   end
+      #
+      def fetch(&block)
+        return [] if not block_given? 
+        elems = []
+        each do |elem, index|
+          result = yield elem, index
+          elems << result if not result.nil?
+        end
+        return elems
+      end
+      
+      #
+      # Used to perform a check on the elements from this core query. The
+      # block provided is used to return true or false based of if the
+      # given element passed some condition. In addition to the block
+      # supplied to this method, you also pass in a condition about the
+      # check being perform, which can be one of the following:
+      #
+      #   :all - Check that all elements meet the block's checks
+      #   :any - Check that one or more elements meet the block's checks
+      #   :none - Check that no elements meet the block's checks
+      #   :one - Check that there is only one element that meets the block's checks
+      #
+      # If no condition argument is gien this :all is the default. 
+      #
+      # Here is an example of how to use this method:
+      #
+      #   meets_condition = core_query.check :all, do |elem, index|
+      #                       if elem.text == 'foo'
+      #                         true # element passes check
+      #                       else
+      #                         false # element does not pass check
+      #                       end
+      #                     end
+      #
+      # @see #all?
+      # @see #any?
+      # @see #none?
+      # @see #one?
+      #
+      def check(condition=nil, &block)
+        return false if not block_given?
+        counter = 0
+        each do |elem, index|
+          result = yield elem, index
+          counter = counter + 1 if result == true
+        end
+        
+        case condition
+        when :all
+          return counter == size
+        when :any
+          return counter > 0
+        when :none
+          return counter == 0
+        when :one
+          return counter == 1
+        else
+          return counter == size
+        end
+      end
+      
+      #
+      # Used to check if all of the element for this core query meet
+      # the conditions for the given block
+      #
+      # @see #check
+      #
+      def all?(&block)
+        check :all &block
+      end
+      
+      #
+      # Used to check if any of the element for this core query meet
+      # the conditions for the given block
+      #
+      # @see #check
+      #
+      def any?(&block)
+        check :any &block
+      end
+      
+      #
+      # Used to check if none of the element for this core query meet
+      # the conditions for the given block
+      #
+      # @see #check
+      #
+      def none?(&block)
+        check :none &block
+      end
+      
+      #
+      # Used to check if there is only one element for this core query that
+      # meets the conditions for the given block
+      #
+      # @see #check
+      #
+      def one?(&block)
+        check :one &block
+      end
+      
+      alias_method :element, :[]
+     
+    end
+    
+  end
+end