yui_rest_client 0.5.0

data/lib/yui_rest_client/actions.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module YuiRestClient
+  module Actions
+    PRESS = 'press'
+    TOGGLE = 'toggle'
+    CHECK = 'check'
+    UNCHECK = 'uncheck'
+    SELECT = 'select'
+    ENTER_TEXT = 'enter_text'
+  end
+end

data/lib/yui_rest_client/app.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+module YuiRestClient
+  class App
+    # Used to initialize main entry point of YuiRestClient and set host and port
+    # for the application under control.
+    # @param host [String] host address (e.g. 'localhost', '192.168.0.1')
+    # @param port [String] port opened for communication (e.g. '9999')
+    def initialize(host:, port:)
+      @host = host
+      @port = port
+      @widget_controller = Http::WidgetController.new(host: host, port: port)
+      @version_controller = Http::VersionController.new(host: host, port: port)
+    end
+
+    # Initializes new instance of Bargraph with the filter provided.
+    # Does not make request to libyui-rest-api.
+    # @param filter [Hash] filter to find a widget
+    # @return [Widgets::Bargraph] new instance of Table
+    # @example
+    #   app.bargraph(id: 'id', label: 'label', class: 'YBarGraph')
+    def bargraph(filter)
+      Widgets::Bargraph.new(@widget_controller, FilterExtractor.new(filter))
+    end
+
+    # Initializes new instance of Button with the filter provided.
+    # Does not make request to libyui-rest-api.
+    # @param filter [Hash] filter to find a widget
+    # @return [Widgets::Button] new instance of Button
+    # @example
+    #   app.button(id: 'id', label: 'label', class: 'YPushButton')
+    def button(filter)
+      Widgets::Button.new(@widget_controller, FilterExtractor.new(filter))
+    end
+
+    # Initializes new instance of Checkbox with the filter provided.
+    # Does not make request to libyui-rest-api.
+    # @param filter [Hash] filter to find a widget
+    # @return [Widgets::Checkbox] new instance of Checkbox
+    # @example
+    #   app.checkbox(id: 'id', label: 'label', class: 'YCheckBox')
+    def checkbox(filter)
+      Widgets::Checkbox.new(@widget_controller, FilterExtractor.new(filter))
+    end
+
+    # Initializes new instance of Combobox with the filter provided.
+    # Does not make request to libyui-rest-api.
+    # @param filter [Hash] filter to find a widget
+    # @return [Widgets::Combobox] new instance of Combobox
+    # @example
+    #   app.combobox(id: 'id', label: 'label', class: 'YComboBox')
+    def combobox(filter)
+      Widgets::Combobox.new(@widget_controller, FilterExtractor.new(filter))
+    end
+
+    # Initializes new instance of Datefield with the filter provided.
+    # Does not make request to libyui-rest-api.
+    # @param filter [Hash] filter to find a widget
+    # @return [Widgets::Datefield] new instance of Datefield
+    # @example
+    #   app.datefield(id: 'id', label: 'label', class: 'YDateField')
+    def datefield(filter)
+      Widgets::Datefield.new(@widget_controller, FilterExtractor.new(filter))
+    end
+
+    # Initializes new instance of Label with the filter provided.
+    # Does not make request to libyui-rest-api.
+    # @param filter [Hash] filter to find a widget
+    # @return [Widgets::Label] new instance of Label
+    # @example
+    #   app.label(id: 'id', label: 'label', class: 'YLabel')
+    def label(filter)
+      Widgets::Label.new(@widget_controller, FilterExtractor.new(filter))
+    end
+
+    # Initializes new instance of Menubutton with the filter provided.
+    # Does not make request to libyui-rest-api.
+    # @param filter [Hash] filter to find a widget
+    # @return [Widgets::Menubutton] new instance of Menubutton
+    # @example
+    #   app.menubutton(id: 'id', label: 'label', class: 'YMenuButton')
+    def menubutton(filter)
+      Widgets::Menubutton.new(@widget_controller, FilterExtractor.new(filter))
+    end
+
+    # Initializes new instance of Multilinebox with the filter provided.
+    # Does not make request to libyui-rest-api.
+    # @param filter [Hash] filter to find a widget
+    # @return [Widgets::Multilinebox] new instance of Multilinebox
+    # @example
+    #   app.multilinebox(id: 'id', label: 'label', class: 'YMultiLineEdit')
+    def multilinebox(filter)
+      Widgets::Multilinebox.new(@widget_controller, FilterExtractor.new(filter))
+    end
+
+    # Initializes new instance of Numberbox with the filter provided.
+    # Does not make request to libyui-rest-api.
+    # @param filter [Hash] filter to find a widget
+    # @return [Widgets::Numberbox] new instance of Numberbox
+    # @example
+    #   app.numberbox(id: 'id', label: 'label', class: 'YIntField')
+    def numberbox(filter)
+      Widgets::Numberbox.new(@widget_controller, FilterExtractor.new(filter))
+    end
+
+    # Initializes new instance of Progressbar with the filter provided.
+    # Does not make request to libyui-rest-api.
+    # @param filter [Hash] filter to find a widget
+    # @return [Widgets::Progressbar] new instance of Progressbar
+    # @example
+    #   app.progressbar(id: 'id', label: 'label', class: 'YProgressBar')
+    def progressbar(filter)
+      Widgets::Progressbar.new(@widget_controller, FilterExtractor.new(filter))
+    end
+
+    # Initializes new instance of Radiobutton with the filter provided.
+    # Does not make request to libyui-rest-api.
+    # @param filter [Hash] filter to find a widget
+    # @return [Widgets::Radiobutton] new instance of Radiobutton
+    # @example
+    #   app.radiobutton(id: 'id', label: 'label', class: 'YRadioButton')
+    def radiobutton(filter)
+      Widgets::Radiobutton.new(@widget_controller, FilterExtractor.new(filter))
+    end
+
+    # Initializes new instance of Richtext with the filter provided.
+    # Does not make request to libyui-rest-api.
+    # @param filter [Hash] filter to find a widget
+    # @return [Widgets::Richtext] new instance of Richtext
+    # @example
+    #   app.richtext(id: 'id', label: 'label', class: 'YRichText')
+    def richtext(filter)
+      Widgets::Richtext.new(@widget_controller, FilterExtractor.new(filter))
+    end
+
+    # Initializes new instance of Selectionbox with the filter provided.
+    # Does not make request to libyui-rest-api.
+    # @param filter [Hash] filter to find a widget
+    # @return [Widgets::Selectionbox] new instance of Selectionbox
+    # @example
+    #   app.selectionbox(id: 'id', label: 'label', class: 'YSelectionBox')
+    def selectionbox(filter)
+      Widgets::Selectionbox.new(@widget_controller, FilterExtractor.new(filter))
+    end
+
+    # Initializes new instance of Tab with the filter provided.
+    # Does not make request to libyui-rest-api.
+    # @param filter [Hash] filter to find a widget
+    # @return [Widgets::Tab] new instance of Tab
+    # @example
+    #   app.tab(id: 'id', label: 'label', class: 'YDumbTab')
+    def tab(filter)
+      Widgets::Tab.new(@widget_controller, FilterExtractor.new(filter))
+    end
+
+    # Initializes new instance of Table with the filter provided.
+    # Does not make request to libyui-rest-api.
+    # @param filter [Hash] filter to find a widget
+    # @return [Widgets::Table] new instance of Table
+    # @example
+    #   app.table(id: 'id', label: 'label', class: 'YTable')
+    def table(filter)
+      Widgets::Table.new(@widget_controller, FilterExtractor.new(filter))
+    end
+
+    # Initializes new instance of time field with the filter provided.
+    # Does not make request to libyui-rest-api.
+    # @param filter [Hash] filter to find a widget
+    # @return [Widgets::Timefield] new instance of Table
+    # @example
+    #   app.timefield(id: 'id', label: 'label', class: 'YTimeField')
+    def timefield(filter)
+      Widgets::Timefield.new(@widget_controller, FilterExtractor.new(filter))
+    end
+
+    # Initializes new instance of Textbox with the filter provided.
+    # Does not make request to libyui-rest-api.
+    # @param filter [Hash] filter to find a widget
+    # @return [Widgets::Textbox] new instance of Textbox
+    # @example
+    #   app.textbox(id: 'id', label: 'label', class: 'YInputField')
+    def textbox(filter)
+      Widgets::Textbox.new(@widget_controller, FilterExtractor.new(filter))
+    end
+
+    # Initializes new instance of Tree with the filter provided.
+    # Does not make request to libyui-rest-api.
+    # @param filter [Hash] filter to find a widget
+    # @return [Widgets::Tree] new instance of Tree
+    # @example
+    #   app.tree(id: 'id', label: 'label', class: 'YTree')
+    def tree(filter)
+      Widgets::Tree.new(@widget_controller, FilterExtractor.new(filter))
+    end
+
+    # Initializes new instance of Wizard with the filter provided.
+    # Does not make request to libyui-rest-api.
+    # @param filter [Hash] filter to find a widget
+    # @return [Widgets::Wizard] new instance of Wizard
+    # @example
+    #   app.wizard(id: 'id', label: 'label', class: 'YWizard')
+    def wizard(filter)
+      Widgets::Wizard.new(@widget_controller, FilterExtractor.new(filter))
+    end
+
+    # Returns client side libyui REST API version
+    # @return libyui client REST API version
+    def client_api_version
+      API_VERSION
+    end
+
+    # Returns server side libyui REST API version
+    # @return libyui server REST API version
+    def server_api_version
+      @version_controller.api_version
+    end
+
+    # Validates if server side REST API is compatible with client inside
+    # @return true if version is compatible, false if not or any error while
+    #         receiving version from the server
+    def check_api_version
+      YuiRestClient.logger.info("Client API version: #{API_VERSION}")
+      server_api_v = server_api_version
+      raise Error::YuiRestClientError if server_api_v.nil?
+
+      YuiRestClient.logger.info("Server API version: #{server_api_v}")
+      server_api_v <= client_api_version
+    end
+  end
+end

data/lib/yui_rest_client/error.rb

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

data/lib/yui_rest_client/filter_extractor.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module YuiRestClient
+  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/yui_rest_client/http/http_client.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module YuiRestClient
+  module Http
+    module HttpClient
+      module_function
+
+      def http_get(uri)
+        YuiRestClient.logger.debug("Request: [GET] #{uri}")
+        res = Net::HTTP.get_response(uri)
+        YuiRestClient.logger.debug("Response: [#{res.code}]\n#{res.body}")
+        res
+      end
+
+      def http_post(uri)
+        YuiRestClient.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)
+        YuiRestClient.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/yui_rest_client/http/response.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module YuiRestClient
+  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
+        YuiRestClient.logger.error("Error while parsing JSON from response:\n"\
+      "#{e.message}\n#{e.backtrace.inspect}")
+      end
+    end
+  end
+end

data/lib/yui_rest_client/http/version_controller.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module YuiRestClient
+  module Http
+    class VersionController
+      def initialize(host:, port:)
+        @host = host
+        @port = port
+        @timeout = YuiRestClient.timeout
+        @interval = YuiRestClient.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::YuiRestClientError unless res.is_a?(Net::HTTPOK)
+
+          JSON.parse(res.body)['api_version']
+        end
+      end
+    end
+  end
+end

data/lib/yui_rest_client/http/widget_controller.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module YuiRestClient
+  module Http
+    class WidgetController
+      def initialize(host:, port:)
+        @host = host
+        @port = port
+        @timeout = YuiRestClient.timeout
+        @interval = YuiRestClient.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::YuiRestClientError
+      end
+    end
+  end
+end

data/lib/yui_rest_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 YuiRestClient
+  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)
+
+      YuiRestClient.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)
+      YuiRestClient.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)
+      YuiRestClient.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 YuiRestClient::Error::TimeoutError if the port is not opened in time
+    def wait_for_port(host, port)
+      Wait.until(timeout: YuiRestClient.timeout, interval: YuiRestClient.interval) do
+        YuiRestClient.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