prism_checker 0.0.1

data/lib/prism_checker/item_checker/item_check/regexp.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module PrismChecker
+  module ItemChecker
+    module ItemCheck
+      module Regexp
+        def check(_element, value, expectation)
+          value =~ expectation
+        end
+
+        def error_message(_element, value, expectation)
+          "Expected '#{value}' to match /#{expectation.source}/"
+        end
+      end
+    end
+  end
+end

data/lib/prism_checker/item_checker/item_check/string.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module PrismChecker
+  module ItemChecker
+    module ItemCheck
+      module String
+        def check(_element, value, expectation)
+          if PrismChecker.string_comparison == :inclusion
+            value.to_s.include?(expectation)
+          else
+            value == expectation
+          end
+        end
+
+        def error_message(_element, value, expectation)
+          if PrismChecker.string_comparison == :inclusion
+            "Expected '#{value}' to include '#{expectation}'"
+          else
+            "Expected '#{value}' to be equal '#{expectation}'"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/prism_checker/item_checker/item_value/array.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module PrismChecker
+  module ItemChecker
+    module ItemValue
+      module Array
+        def value(elements)
+          elements.map(&:to_s).join(' ')
+        end
+      end
+    end
+  end
+end

data/lib/prism_checker/item_checker/item_value/element.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module PrismChecker
+  module ItemChecker
+    module ItemValue
+      module Element
+        def value(element)
+          element.text
+        end
+      end
+    end
+  end
+end

data/lib/prism_checker/item_checker/item_value/elements.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module PrismChecker
+  module ItemChecker
+    module ItemValue
+      module Elements
+        def value(elements)
+          elements.map(&:text).join(' ')
+        end
+      end
+    end
+  end
+end

data/lib/prism_checker/item_checker/item_value/image.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module PrismChecker
+  module ItemChecker
+    module ItemValue
+      module Image
+        def value(image)
+          image['src']
+        end
+      end
+    end
+  end
+end

data/lib/prism_checker/item_checker/item_value/input.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module PrismChecker
+  module ItemChecker
+    module ItemValue
+      module Input
+        def value(input)
+          input.value
+        end
+      end
+    end
+  end
+end

data/lib/prism_checker/item_checker/item_value/page.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module PrismChecker
+  module ItemChecker
+    module ItemValue
+      module Page
+        def value(page)
+          page.find('body')&.text || page.text
+        end
+      end
+    end
+  end
+end

data/lib/prism_checker/item_checker/item_value/string.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module PrismChecker
+  module ItemChecker
+    module ItemValue
+      module String
+        def value(element)
+          element
+        end
+      end
+    end
+  end
+end

data/lib/prism_checker/item_checker/item_value/textarea.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module PrismChecker
+  module ItemChecker
+    module ItemValue
+      module Textarea
+        def value(textarea)
+          textarea.value
+        end
+      end
+    end
+  end
+end

data/lib/prism_checker/item_checker/nil.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'item_check/string'
+require_relative 'item_check/regexp'
+require_relative 'item_value/string'
+
+module PrismChecker
+  module ItemChecker
+    module Nil
+      class String
+        def self.value(_element); end
+
+        def self.check(_element, _value, _expectation)
+          false
+        end
+
+        def self.error_message(_element, _value, expectation)
+          "Expected '#{expectation}', got nil"
+        end
+      end
+
+      class Regexp
+        def self.value(_element); end
+
+        def self.check(_element, _value, _expectation)
+          false
+        end
+
+        def self.error_message(_element, _value, expectation)
+          "Expected '/#{expectation.source}/', got nil"
+        end
+      end
+    end
+  end
+end

data/lib/prism_checker/item_checker/page.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative 'item_value/page'
+require_relative 'item_check/string'
+require_relative 'item_check/regexp'
+
+module PrismChecker
+  module ItemChecker
+    module Page
+      class String
+        extend ItemValue::Page
+        extend ItemCheck::String
+      end
+
+      class Empty
+        extend ItemValue::Page
+        extend ItemCheck::Empty
+      end
+
+      class Regexp
+        extend ItemValue::Page
+        extend ItemCheck::Regexp
+      end
+
+      class Loaded
+        def self.value(_element); end
+
+        def self.check(page, _value, _expectation)
+          page.loaded?
+        end
+
+        def self.error_message(_element, _value, _expectation)
+          'Page is not loaded'
+        end
+      end
+    end
+  end
+end

data/lib/prism_checker/item_checker/string.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'item_check/string'
+require_relative 'item_check/regexp'
+require_relative 'item_value/string'
+
+module PrismChecker
+  module ItemChecker
+    module String
+      class String
+        extend ItemValue::String
+        extend ItemCheck::String
+      end
+
+      class Empty
+        extend ItemValue::String
+        extend ItemCheck::Empty
+      end
+
+      class Regexp
+        extend ItemValue::String
+        extend ItemCheck::Regexp
+      end
+    end
+  end
+end

data/lib/prism_checker/item_checker/textarea.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'item_value/textarea'
+require_relative 'item_check/string'
+require_relative 'item_check/regexp'
+
+module PrismChecker
+  module ItemChecker
+    module Textarea
+      class String
+        extend ItemValue::Textarea
+        extend ItemCheck::String
+      end
+
+      class Empty
+        extend ItemValue::Textarea
+        extend ItemCheck::Empty
+      end
+
+      class Regexp
+        extend ItemValue::Textarea
+        extend ItemCheck::Regexp
+      end
+    end
+  end
+end

data/lib/prism_checker/item_classifier.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module PrismChecker
+  class ItemClassifier
+    @elements_map = [
+      %i[checkbox element_checkbox?],
+      %i[radio element_radio?],
+      %i[input element_input?],
+      %i[textarea element_textarea?],
+      %i[select element_select?],
+      %i[image element_image?],
+      %i[element element?],
+      %i[elements elements?],
+      %i[section section?],
+      %i[sections sections?],
+      %i[page page?],
+      %i[array array?],
+      %i[string string?],
+      %i[boolean boolean?],
+      %i[nil element_nil?]
+    ]
+
+    def self.classify(element)
+      @elements_map.each do |data|
+        type = data[0]
+        probe = data[1]
+        if probe.is_a? Symbol
+          return type if send(probe, element)
+        elsif probe.call(element)
+          return type
+        end
+      end
+
+      :other
+    end
+
+    def self.page?(element)
+      element.is_a?(SitePrism::Page)
+    end
+
+    def self.section?(element)
+      element.is_a?(SitePrism::Section)
+    end
+
+    def self.sections?(element)
+      element.all?(SitePrism::Section)
+    rescue StandardError
+      false
+    end
+
+    def self.element?(element)
+      element.is_a?(Capybara::Node::Element)
+    end
+
+    def self.elements?(element)
+      element.all?(Capybara::Node::Element)
+    rescue StandardError
+      false
+    end
+
+    def self.array?(element)
+      element.is_a?(::Array)
+    end
+
+    def self.string?(element)
+      element.is_a?(::String)
+    end
+
+    def self.element_image?(element)
+      return false unless element?(element)
+      return false unless element.tag_name == 'img'
+
+      true
+    end
+
+    def self.element_input?(element)
+      return false unless element?(element)
+      return false unless element.tag_name == 'input'
+
+      true
+    end
+
+    def self.element_textarea?(element)
+      return false unless element?(element)
+      return false unless element.tag_name == 'textarea'
+
+      true
+    end
+
+    def self.element_select?(element)
+      return false unless element?(element)
+      return false unless element.tag_name == 'select'
+
+      true
+    end
+
+    def self.element_checkbox?(element)
+      return false unless element?(element)
+      return false unless element['type'] == 'checkbox'
+
+      true
+    end
+
+    def self.element_radio?(element)
+      return false unless element?(element)
+      return false unless element['type'] == 'radio'
+
+      true
+    end
+
+    def self.boolean?(element)
+      return true if element.is_a?(TrueClass)
+      return true if element.is_a?(FalseClass)
+
+      false
+    end
+
+    def self.element_nil?(element)
+      element.nil?
+    end
+
+    def self.add(type, probe, position = 0)
+      @elements_map.insert(position, [type, probe])
+    end
+  end
+end

data/lib/prism_checker/node/array.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+module PrismChecker
+  module Node
+    class Array < PrismChecker::Node::Base
+      attr_reader :children
+
+      def initialize(checker, parent, name, expectation)
+        super
+        @children = []
+      end
+
+      def add_child(idx, child)
+        @children[idx] = child
+      end
+
+      def walk_through(level = 0, &block)
+        yield self, level
+        @children.each do |c|
+          c.walk_through(level + 1, &block)
+        end
+      end
+    end
+  end
+end

data/lib/prism_checker/node/bad_expectation.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module PrismChecker
+  module Node
+    class BadExpectation < StandardError; end
+  end
+end

data/lib/prism_checker/node/base.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require_relative 'check_fail'
+require_relative 'bad_expectation'
+require_relative '../element_wrapper'
+require_relative '../absence_expectation'
+require_relative '../item_classifier'
+
+module PrismChecker
+  module Node
+    class Base
+      attr_reader :name, :status, :error, :parent, :checker, :expectation
+
+      def initialize(checker, parent, name, expectation)
+        @parent = parent
+        @checker = checker
+        @name = name
+        @expectation = build_expectation(expectation)
+        @element = nil
+        @status = 'Not checked'
+        @error = nil
+        @timeout = Capybara.default_max_wait_time
+        @type = nil
+        @checked_element = nil
+      end
+
+      def build_expectation(expectation)
+        if expectation.is_a?(Symbol) && expectation.start_with?('absent')
+          delay = expectation == :absent ? 0 : Integer(expectation.to_s.split('absent').last)
+
+          return AbsenceExpectation.new(delay)
+        end
+
+        expectation
+      rescue ArgumentError
+        expectation
+      end
+
+      def root?
+        parent.is_a?(Checker)
+      end
+
+      def failure?
+        @status == 'Fail' || @status == 'Error'
+      end
+
+      def success?
+        @status == 'Ok'
+      end
+
+      def element
+        return @checked_element if @checked_element
+
+        if root?
+          @checker.item
+        elsif parent.is_a?(Node::Hash)
+          if parent.element.is_a?(Capybara::Node::Element)
+            ElementWrapper.new(parent.element).send(@name)
+          else
+            parent.element.send(@name)
+          end
+        elsif parent.is_a?(Node::Array)
+          parent.element[@name]
+        end
+      end
+
+      def wait_until_true(timeout = @timeout, &block)
+        SitePrism::Waiter.wait_until_true(timeout, &block)
+      rescue SitePrism::TimeoutError
+        false
+      end
+
+      def check_wrapper
+        yield
+        @status = 'Ok'
+      rescue Node::CheckFail => e
+        @error = e
+        @status = 'Fail'
+        raise
+      rescue StandardError => e
+        @error = e
+        @status = 'Error'
+        raise
+      end
+
+      def check_absence
+        sleep expectation.delay
+
+        check_wrapper do
+          result = wait_until_true(0.1) do
+            parent.element.public_send("has_no_#{name}?")
+          end
+
+          raise Node::CheckFail, 'Element is present' unless result
+        end
+      end
+
+      def path
+        result = []
+        p = self
+
+        while p.is_a? Base
+          result << p.name
+          p = p.parent
+        end
+
+        result.reverse
+      end
+
+      def type(element)
+        @type ||= ItemClassifier.classify(element)
+      end
+
+      def check
+        return check_absence if expectation.is_a?(AbsenceExpectation)
+
+        check_wrapper do
+          element = self.element
+          element_type = type(element)
+          checkers = CheckDispatcher.checkers(self, element, expectation, element_type)
+          value = nil
+          checkers.each do |checker|
+            result = wait_until_true do
+              element = self.element if element.is_a? ::Array
+
+              value = checker.value(element)
+              checker.check(element, value, expectation)
+            end
+
+            unless result
+              raise Node::CheckFail, checker.error_message(element, value, expectation)
+            end
+          end
+
+          @checked_element = element
+        end
+      end
+    end
+  end
+end

data/lib/prism_checker/node/check_fail.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module PrismChecker
+  module Node
+    class CheckFail < StandardError; end
+  end
+end

data/lib/prism_checker/node/expectation.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative '../item_classifier'
+require_relative '../check_dispatcher'
+
+module PrismChecker
+  module Node
+    class Expectation < PrismChecker::Node::Base
+      def walk_through(level = 0)
+        yield self, level
+      end
+    end
+  end
+end

data/lib/prism_checker/node/hash.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module PrismChecker
+  module Node
+    class Hash < PrismChecker::Node::Base
+      attr_reader :children
+
+      def initialize(checker, parent, name, expectation)
+        super
+        @children = {}
+      end
+
+      def add_child(name, child)
+        @children[name] = child
+      end
+
+      def walk_through(level = 0, &block)
+        yield self, level
+        @children.each_value do |child|
+          child.walk_through(level + 1, &block)
+        end
+      end
+    end
+  end
+end