libyui_client 0.4.0

data/lib/libyui_client/error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module LibyuiClient
+  module Error
+    class LibyuiClientError < StandardError; end
+
+    class TimeoutError < LibyuiClientError; end
+
+    class WidgetNotFoundError < LibyuiClientError; end
+
+    class ItemNotFoundInWidgetError < LibyuiClientError; end
+  end
+end

data/lib/libyui_client/filter_extractor.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module LibyuiClient
+  class FilterExtractor
+    attr_reader :full, :plain, :regex
+
+    def initialize(filter)
+      @full = build_filters(filter)
+      @plain = @full.reject { |_, v| v.is_a? Regexp }
+      @regex = @full.select { |_, v| v.is_a? Regexp }
+    end
+
+    def to_s
+      full.to_s
+    end
+
+    private
+
+    def build_filters(hash)
+      filter = {}
+      filter[:id] = hash[:id]
+      # Replace '&' in label filter as search is not possible when it contains the character
+      filter[:label] = hash[:label].is_a?(String) ? hash[:label].tr('&', '') : hash[:label]
+      filter[:type] = hash[:class] if hash.key?(:class)
+      filter.compact
+    end
+  end
+end

data/lib/libyui_client/http/http_client.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module LibyuiClient
+  module Http
+    module HttpClient
+      module_function
+
+      def http_get(uri)
+        LibyuiClient.logger.debug("Request: [GET] #{uri}")
+        res = Net::HTTP.get_response(uri)
+        LibyuiClient.logger.debug("Response: [#{res.code}]\n#{res.body}")
+        res
+      end
+
+      def http_post(uri)
+        LibyuiClient.logger.debug("Request: [POST] #{uri}")
+        # a trick how to add query parameters to a POST request,
+        # the usual Net::HTTP.post(uri, data) does not allow using a query
+        req = Net::HTTP::Post.new("#{uri.path}?#{uri.query}")
+        http = Net::HTTP.new(uri.host, uri.port)
+        res = http.request(req)
+        LibyuiClient.logger.debug("Response: [#{res.code}]\n#{res.body}")
+        res
+      end
+
+      def compose_uri(host, port, path, params = {})
+        URI::HTTP.build(
+          host: host,
+          port: port,
+          path: path,
+          query: URI.encode_www_form(params)
+        )
+      end
+    end
+  end
+end

data/lib/libyui_client/http/response.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module LibyuiClient
+  module Http
+    class Response
+      def initialize(res)
+        @res = res
+      end
+
+      def body(regex_filter: {})
+        result = JSON.parse(@res.body, symbolize_names: true)
+        result.select do |widget|
+          regex_filter.all? { |key, value| value.match(widget[key.to_sym]) }
+        end
+      rescue JSON::ParserError => e
+        LibyuiClient.logger.error("Error while parsing JSON from response:\n"\
+      "#{e.message}\n#{e.backtrace.inspect}")
+      end
+    end
+  end
+end

data/lib/libyui_client/http/version_controller.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module LibyuiClient
+  module Http
+    class VersionController
+      def initialize(host:, port:)
+        @host = host
+        @port = port
+        @timeout = LibyuiClient.timeout
+        @interval = LibyuiClient.interval
+      end
+
+      # Gets server api version, so one could compare compatibility and detect
+      # if newer version was deployed
+      # @return server side REST API version
+      def api_version
+        Wait.until(timeout: @timeout, interval: @interval) do
+          res = HttpClient.http_get(HttpClient.compose_uri(@host, @port, '/version'))
+          raise Error::LibyuiClientError unless res.is_a?(Net::HTTPOK)
+
+          JSON.parse(res.body)['api_version']
+        end
+      end
+    end
+  end
+end

data/lib/libyui_client/http/widget_controller.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module LibyuiClient
+  module Http
+    class WidgetController
+      def initialize(host:, port:)
+        @host = host
+        @port = port
+        @timeout = LibyuiClient.timeout
+        @interval = LibyuiClient.interval
+      end
+
+      # Find a widget using the filter.
+      # @param filter [Hash] identifiers to find a widget
+      # @return [Response]
+      def find(filter)
+        res = nil
+        Wait.until(timeout: @timeout, interval: @interval) do
+          uri = HttpClient.compose_uri(@host, @port, "/#{API_VERSION}/widgets", filter)
+          res = HttpClient.http_get(uri)
+          Response.new(res) if res.is_a?(Net::HTTPOK)
+        end
+      rescue Error::TimeoutError
+        rescue_errors(res)
+      end
+
+      # Perform an action on the widget.
+      # @param filter [Hash] identifiers to find a widget
+      # @param action [Hash] what to do with the widget
+      # @return [Response]
+      def send_action(filter, action)
+        res = nil
+        Wait.until(timeout: @timeout, interval: @interval) do
+          uri = HttpClient.compose_uri(@host, @port, "/#{API_VERSION}/widgets",
+                                       filter.merge(action))
+          res = HttpClient.http_post(uri)
+          Response.new(res) if res.is_a?(Net::HTTPOK)
+        end
+      rescue Error::TimeoutError
+        rescue_errors(res)
+      end
+
+      private
+
+      def rescue_errors(response)
+        raise Error::WidgetNotFoundError if response.is_a?(Net::HTTPNotFound)
+
+        raise Error::ItemNotFoundInWidgetError if response.is_a?(Net::HTTPUnprocessableEntity)
+
+        raise Error::LibyuiClientError
+      end
+    end
+  end
+end

data/lib/libyui_client/local_process.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# Client to interact with YAST UI rest api framework for integration testing
+module LibyuiClient
+  class LocalProcess
+    # default timeout for process
+    DEFAULT_TIMEOUT_PROCESS = 2
+
+    # start the application in background
+    # @param application [String] the command to start
+    def start_app(application)
+      @app_host = 'localhost'
+      @app_port = port
+
+      # another app already running?
+      raise "The port #{@app_host}:#{@app_port} is already open!" if port_open?(@app_host, @app_port)
+
+      LibyuiClient.logger.debug("Starting #{application}...")
+      # create a new process group so easily we will be able
+      # to kill all its sub-processes
+      @app_pid = spawn(application, pgroup: true)
+      wait_for_port(@app_host, @app_port)
+      LibyuiClient.logger.debug("App started: '#{application}'")
+    end
+
+    # kill the process if it is still running after finishing a scenario
+    def kill_app
+      return unless @app_pid
+
+      Process.waitpid(@app_pid, Process::WNOHANG)
+      LibyuiClient.logger.debug("Sending KILL signal for PID #{@app_pid}")
+      Process.kill('-KILL', @app_pid)
+    rescue Errno::ECHILD, Errno::ESRCH
+      # the process has already exited
+      @app_pid = nil
+    end
+
+    private
+
+    # set the application introspection port for communication
+    def port
+      ENV['YUI_HTTP_PORT'] ||= '9999'
+    end
+
+    # is the target port open?
+    # @param host [String] the host to connect to
+    # @param port [Integer] the port number
+    # @return [Boolean] true if the port is open, false otherwise
+    def port_open?(host, port)
+      TCPSocket.new(host, port).close
+      true
+    rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+      false
+    end
+
+    # wait until the specified port is open or until the timeout is reached
+    # @param host [String] the host to connect to
+    # @param port [Integer] the port number
+    # @raise LibyuiClient::Error::TimeoutError if the port is not opened in time
+    def wait_for_port(host, port)
+      Wait.until(timeout: LibyuiClient.timeout, interval: LibyuiClient.interval) do
+        LibyuiClient.logger.debug("Waiting for #{host}:#{port}...")
+        port_open?(host, port)
+      end
+    end
+
+    # optionally allow a short delay between the steps to watch the UI changes
+    def add_step_delay
+      delay = ENV['STEP_DELAY'].to_f
+      sleep(delay) if delay.positive?
+    end
+  end
+end

data/lib/libyui_client/logger.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'logger'
+
+module LibyuiClient
+  class Logger
+    extend Forwardable
+
+    def_delegators :@logger, :debug, :debug?,
+                   :info, :info?,
+                   :warn, :warn?,
+                   :error, :error?,
+                   :fatal, :fatal?,
+                   :level
+
+    def initialize
+      @logger = create_logger($stdout)
+    end
+
+    def create_logger(output)
+      logger = ::Logger.new(output)
+      logger.progname = 'LibyuiClient'
+      logger.level = default_level
+      logger
+    end
+
+    def default_level
+      ENV['DEBUG'] ? :debug : :info
+    end
+  end
+end

data/lib/libyui_client/timer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module LibyuiClient
+  module Timer
+    module_function
+
+    # Execute code block with the interval until timeout reached.
+    # @param timeout [Numeric] how many time in seconds to wait
+    # @param interval [Numeric] time in seconds between attempts
+    def wait(timeout, interval)
+      return yield if timeout.zero?
+
+      end_time = Time.now.to_f + timeout
+      while Time.now.to_f <= end_time
+        yield
+        sleep interval
+      end
+    end
+  end
+end

data/lib/libyui_client/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module LibyuiClient
+  VERSION = '0.4.0'
+  API_VERSION = 'v1'
+end

data/lib/libyui_client/wait.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module LibyuiClient
+  module Wait
+    def self.until(timeout:, interval:, message: nil, object: nil)
+      Timer.wait(timeout, interval) do
+        result = yield(object)
+        return result if result
+      end
+      raise Error::TimeoutError, "timed out after #{timeout} seconds. #{message}"
+    end
+
+    def self.while(timeout:, interval:, message: nil, object: nil)
+      Timer.wait(timeout, interval) do
+        result = yield(object)
+        return unless result
+      end
+      raise Error::TimeoutError, "timed out after #{timeout} seconds. #{message}"
+    end
+  end
+end

data/lib/libyui_client/waitable.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module LibyuiClient
+  module Waitable
+    # Waits until the block evaluation will return true, raises Error::TimeoutError on timeout.
+    # @param timeout [Numeric] how long to wait (in seconds). Default is LibyuiClient.timeout.
+    # @param interval [Numeric] time in seconds between attempts. Default is LibyuiClient.interval.
+    # @param message [String] message to be sent in case timeout is reached.
+    # @raise Error::TimeoutError
+    # @return [Waitable] waitable object
+    # @example Wait for checkbox to be checked
+    #   app.checkbox(id: 'test').wait_until(&:checked?)
+    def wait_until(timeout: LibyuiClient.timeout, interval: LibyuiClient.interval, message: nil, &block)
+      @timeout = timeout
+      @interval = interval
+      Wait.until(timeout: timeout, interval: interval, message: message, object: self, &block)
+      @timeout = LibyuiClient.timeout
+      @interval = LibyuiClient.interval
+      self
+    end
+
+    # Waits while the block evaluation returns true, raises Error::TimeoutError on timeout.
+    # @param timeout [Numeric] how long to wait (in seconds). Default is LibyuiClient.timeout.
+    # @param interval [Numeric] time in seconds between attempts. Default is LibyuiClient.interval.
+    # @param message [String] message to be sent in case timeout is reached.
+    # @raise Error::TimeoutError
+    # @return [Waitable] waitable object
+    # @example Wait for checkbox to be unchecked
+    #   app.checkbox(id: 'test').wait_while(&:checked?)
+    def wait_while(timeout: LibyuiClient.timeout, interval: LibyuiClient.interval, message: nil, &block)
+      @timeout = timeout
+      @interval = interval
+      Wait.while(timeout: timeout, interval: interval, message: message, object: self, &block)
+      @timeout = LibyuiClient.timeout
+      @interval = LibyuiClient.interval
+      self
+    end
+  end
+end

data/lib/libyui_client/widgets.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module LibyuiClient
+  module Widgets
+    require 'libyui_client/waitable'
+    require 'libyui_client/widgets/base'
+    require 'libyui_client/widgets/bargraph'
+    require 'libyui_client/widgets/button'
+    require 'libyui_client/widgets/checkbox'
+    require 'libyui_client/widgets/combobox'
+    require 'libyui_client/widgets/datefield'
+    require 'libyui_client/widgets/label'
+    require 'libyui_client/widgets/menubutton'
+    require 'libyui_client/widgets/multilinebox'
+    require 'libyui_client/widgets/numberbox'
+    require 'libyui_client/widgets/progressbar'
+    require 'libyui_client/widgets/radiobutton'
+    require 'libyui_client/widgets/selectionbox'
+    require 'libyui_client/widgets/tab'
+    require 'libyui_client/widgets/table'
+    require 'libyui_client/widgets/textbox'
+    require 'libyui_client/widgets/timefield'
+    require 'libyui_client/widgets/label'
+    require 'libyui_client/widgets/richtext'
+    require 'libyui_client/widgets/tree'
+    # Class representing a Wizard UI. It can be YWizard
+    class Wizard < Widgets::Base
+    end
+  end
+end

data/lib/libyui_client/widgets/bargraph.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module LibyuiClient
+  module Widgets
+    # Class representing a bar graph in the UI, namely YBarGraph.
+    class Bargraph < Widgets::Base
+      # Returns the list of segments in the bar graph. Each segment is defined by
+      # label and value. Segment length is defined by proportional ratio of the
+      # segment value. For instance, if segment values are 100, 200, 700: it means
+      # first segment will take 100/1000=10%, second 20% and third one 70% accordingly.
+      # @return [Array] array of [Hash] objects with :label and :value keys which
+      #                 store label and segment value for given segment
+      # @example Get segments from the bargraph with id "test_id"
+      # {
+      #   "class" : "YBarGraph",
+      #   "id" : "test_id",
+      #   "segments" :
+      #   [
+      #     {
+      #       "label" : "Windows\nused\n%1 MB",
+      #       "value" : 600
+      #     },
+      #     {
+      #       "label" : "Windows\nfree\n%1 MB",
+      #       "value" : 350
+      #     },
+      #     {
+      #       "label" : "Linux\n%1 MB",
+      #       "value" : 800
+      #     }
+      #   ],
+      # }
+      # @example
+      #   app.bargraph(id: 'test_id').segments
+      # @example
+      #   app.bargraph(id: 'test_id').segments[1][:value]
+      # @example
+      #   app.bargraph(id: 'test_id').segments[1][:label]
+      def segments
+        property(:segments)
+      end
+
+      # Returns the labels list of all segments in the bar graph.
+      # @return [Array] array of labels in order they are stored in segments hash.
+      # @example Get labels of the segments in the bargraph with id "test_id"
+      # @example
+      #   app.bargraph(id: 'test_id').labels
+      def labels
+        segments.map { |segment| segment[:label] }
+      end
+
+      # Returns the values list of all segments in the bar graph.
+      # @return [Array] array of values in order they are stored in segments hash.
+      # @example Get values of the segments in the bargraph with id "test_id"
+      # @example
+      #   app.bargraph(id: 'test_id').values
+      def values
+        segments.map { |segment| segment[:value] }
+      end
+    end
+  end
+end