lazy-check 1.0.0

data/lib/lazy/check/checker_test.rb

@@ -0,0 +1,137 @@
+module Lazy
+class Checker
+class Test
+
+  # Instance Lazy::Checker principale qui lance les tests
+  # 
+  attr_reader :checker
+
+  # Données du test
+  # 
+  # Doit contenir :
+  #   - :url    [String] Adresse à visiter
+  #   - :checks [Array] Liste des checks à faire
+  # 
+  attr_reader :data
+
+  # Instanciation d'un test
+  # 
+  # @param data [Hash] Table de données du test
+  # 
+  def initialize(checker, data)
+    @checker = checker
+    @data = data
+    check_data
+  end
+
+  # On procède à ce test qui doit réussir
+  # Ça consiste à :
+  #   - si :checks est défini : boucler sur tous les :checks pour
+  #     ce test dans la recette.
+  #   - si :redirect_to est défini : vérifier qu'on obtient bien une
+  #     redirection.
+  #   - si :response est défini : vérifier que c'est bien la réponse
+  # 
+  # Cf. checker_url.rb pour le détail
+  # 
+  def check(**options)
+    if data.key?(:checks)
+      check_with_checks(**options)
+    else
+      check_autre(**options)
+    end
+  end
+
+  def check_with_checks(**options)
+    data[:checks].each do |dcheck|
+      check_case = CheckCase.new(urler, dcheck, checker.reporter)
+      result = check_case.check
+      if result === true
+        # Success
+      elsif result === false
+        # Failure
+      else
+        # Unknown result — Résultat inconnu
+      end
+    end
+  end
+
+  # Pour checker la redirection ou l'http response
+  def check_autre(**options)
+    churl = CheckedUrl.new(data.merge(urler: urler, reporter: reporter))
+    churl.check(**options)
+  end
+
+  def urler
+    @urler ||= begin
+      full_url = checker.base ? File.join(checker.base, url) : url
+      Url.new(full_url)
+    end
+  end
+
+  def url
+    @url ||= data[:url]
+  end
+
+  # raccourci
+  def reporter
+    checker.reporter
+  end
+
+  private
+
+
+    def check_data
+      # -- Pour simplifier l'écriture des erreurs --
+      data_keys   = data.keys.pretty_join
+      data_class  = data.class.name
+      # -- Tests de validité --
+      data.is_a?(Hash)                    || raise(ERRORS[300] % {c: data_class})
+      data.key?(:url)                     || raise(ERRORS[300] % {ks: data_keys})
+      err = check_url(data[:url])
+      err.nil?                            || raise(ERRORS[302] % {e: err, u: data[:url]})
+      data.key?(:name)                    || raise(ERRORS[307] % {ks: data_keys})
+      if data.key?(:checks)
+        data[:checks].is_a?(Array)        || raise(ERRORS[309] % {c: data_class})
+      elsif data.key?(:redirect_to)
+        data[:redirect_to].is_a?(String)  || raise(ERRORS[310] % {a: data[:redirect_to].inspect, c: data[:redirect_to].class.name})
+        data[:redirect_to].start_with?('http')  || raise(ERRORS[311] % {a: data[:redirect_to].inspect})
+      elsif data.key?(:response)
+        data[:response].is_a?(Integer)    || raise(ERRORS[312] % {a:data[:response].inspect, c: data[:response].class.name})
+      else
+        raise(ERRORS[308] % {ks: data_keys})
+      end
+    end
+
+    # S'assure que +url+ est une url valide. @return nil si c'est le
+    # cas où l'erreur dans le cas contraire.
+    # 
+    # @note 
+    # 
+    #   Ce qu'on appelle une +url+ ici peut être un URI (https://...)
+    #   ou le code résultant du chargement de cette URI, qui sera 
+    #   reconnaissable parce qu'il commence par "<" et finit par ">"
+    #   (oui, c'est de la reconnaissance paresseuse…)
+    # 
+    def check_url(url)
+      url                     || raise(ERRORS[303])
+      url.is_a?(String)       || raise(ERRORS[304] % {c: url.class.name})
+      if url.match?(/^<.+>$/.freeze)
+        # Du code HTML/XML
+      else
+        if checker.base?
+          # Pas à tester le début
+        else
+          url.start_with?('http') || raise(ERRORS[305])
+        end
+        not(url.match?(/ /))    || raise(ERRORS[306])
+      end
+    rescue Exception => e
+      return e.message
+    else
+      return nil
+    end
+
+end #/class Test
+end #/class Checker
+end #/module Lazy

data/lib/lazy/check/checker_url.rb

@@ -0,0 +1,117 @@
+require 'net/http'
+require 'nokogiri'
+
+module Lazy
+class Checker
+class Url
+
+  attr_reader :uri_string
+  
+  # Instanciation d'un test
+  # 
+  # @param uri [String] URL ou code
+  # 
+  def initialize(uri)
+    @uri_string = uri.strip
+  end
+
+  # @return Nokogiri Document
+  def nokogiri
+    @nokogiri ||= Nokogiri::XML(code_html)#.tap { |n| dbg("Classe : #{n.class}".bleu)}
+  end
+
+  # -- Predicate Methods --
+
+  # @return true si la page a pu être chargée correctement
+  def ok?
+    not(code_html.nil?)
+  end
+
+  # @return true si la page est une redirection
+  # @note la redirection se trouve dans @redirect_to
+  def redirection?
+    code_html.nil? && not(@redirect_to.nil?)
+  end
+
+  # @return la redirection
+  # 
+  # @note Il faut avoir appelé #code_html ou #read avant de
+  # pouvoir l'utiliser.
+  def redirect_to
+    @redirect_to
+  end
+
+  # @return la response.value
+  # @note Il faut que #code_html ou #read ait été appelé avant
+  def rvalue
+    @rvalue
+  end
+
+  def code_html
+    @code_html ||= readit
+  end
+  
+  def readit
+    if uri_string.start_with?('http')
+      uri = URI(uri_string)
+      begin
+        response = Net::HTTP.get_response(uri)
+      rescue SocketError => e
+        @rvalue = e.message.match(/([4][0-9][0-9])/).to_a[1].to_i
+        return
+      rescue Net::HTTPServerException => e
+        @rvalue = e.message.match(/([4][0-9][0-9])/).to_a[1].to_i
+        return
+      rescue Net::HTTPClientException => e
+        @rvalue = e.message.match(/([4][0-9][0-9])/).to_a[1].to_i
+        return
+      end
+      begin
+        @rvalue = response.value
+      # rescue Net::HTTPServerException => e
+      #   @rvalue = e.message.match(/([4][0-9][0-9])/).to_a[1].to_i
+      #   puts "rvalue: #{@rvalue.inspect}".jaune
+      #   exit
+      #   return
+      rescue Net::HTTPClientException => e
+        @rvalue = e.message.match(/([4][0-9][0-9])/).to_a[1].to_i
+        return
+      end
+      case response
+      when Net::HTTPSuccess
+        body = response.body # toute la page html
+        @rvalue = response.code.to_i
+        # dbg("response.value = #{response.methods.inspect}".bleu)
+        # dbg("response.code = #{response.code.inspect}".bleu)
+        if body.match?(REG_REDIRECTION)
+          #
+          # -- la page html définit une redirection par
+          #    balise meta --
+          # 
+          @redirect_to = body.match(REG_REDIRECTION).to_a[1].strip
+          return nil
+        else
+          # 
+          # Un corps de page normal (note : <html>...</html>)
+          # 
+          return body
+        end
+      when Net::HTTPRedirect
+        @redirect_to = response['location']
+        return nil
+      else
+        return nil
+      end
+    elsif uri_string.start_with?('<') and uri_string.end_with?('>')
+      uri_string
+    else
+      raise ArgumentError.new(ERRORS[201] % {a:uri_string.inspect})
+    end
+  end
+
+  REG_REDIRECTION = /<meta.+http-equiv="refresh".+content="[0-9]+;(.+)">/.freeze
+
+
+end #/class Url
+end #/class Checker
+end #/module Lazy

data/lib/lazy/check/constants.rb

@@ -0,0 +1,17 @@
+module Lazy
+
+KNOWN_LANGS = ['fr','en']
+
+lang = ENV['LANG'][0..1] || 'en'
+# lang = 'en' # pour tester
+lang = 'en' unless KNOWN_LANGS.include?(lang)
+LANG = lang
+
+APP_FOLDER = File.dirname(File.dirname(File.dirname(__dir__)))
+
+YAML_OPTIONS = {symbolize_names:true, aliases:true, permitted_classes:[Date,Integer,Float]}
+
+ERRORS    = YAML.safe_load(File.read(File.join(__dir__,'locales',LANG,'errors.yaml')), **YAML_OPTIONS)
+MESSAGES  = YAML.safe_load(File.read(File.join(__dir__,'locales',LANG,'messages.yaml')), **YAML_OPTIONS)
+
+end #/module Lazy

data/lib/lazy/check/locales/en/errors.yaml

@@ -0,0 +1,13 @@
+---
+1000: |
+  Lazy::Checker::CheckCase instanciation requires a Lazy::Checker::Url (first argument).
+  Actual value is %{a}::%{c}.
+1001: |
+  Lazy::Checker::CheckCase instanciation requires a Hash (second argument).
+  Actual value is %{a}::%{c}.
+1002: |
+  CheckCase data should define :tag value (tag name with at least id or css class).
+  They only define : %{ks}.
+1003: |
+  :tag value of the CheckCase data should define at least a id (tagName#id) or a css 
+  class (tagName.css_class). '%{a}' defines neither.

data/lib/lazy/check/locales/fr/errors.yaml

@@ -0,0 +1,142 @@
+---
+# -- Erreurs de recette --
+200: |
+  Le fichier recette '%{path}' est introuvable.
+201: |
+  La donnée %{a} n'est pas valide, pour instancier un Checker::Url. Il faudrait soit
+  une URL (conforme) soit un code HTML (valide).
+202: |
+  Le fichier recette ne contient aucune donnée.
+203: |
+  Les données de la recette devraient être une table (Hash) pas un %{c}.
+204: |
+  La recette devrait définir la clé :tests. Elle ne définit que les clés %{ks}.
+205: |
+  Les données :tests devraient être un Array, pas un %{c}.
+206: |
+  La recette doit définir son nom avec la clé :name.
+
+# -- Erreurs de la définition d'un test --
+
+300: |
+  Les données du test devraient être une table Hash, pas un %{c}.
+301: |
+  La table du test devrait définir la propriété :url, qui est la page à atteindre. 
+  Je ne trouve que les propriétés %{ks}.
+302: |
+  L'URL fournie (%{u}) n'est pas valide : %{e}.
+303: |
+  elle doit être définie, pas nil.
+304: |
+  elle doit être un string, pas un %{c}.
+305: |
+  elle doit obligatoirement commencer par 'http' ou 'https'.
+306: |
+  elle ne devrait contenir aucune espace…
+307: |
+  Un test doit définir son nom (dans :name), il ne définit que les clés
+  %{ks}.
+308: |
+  Un test doit définir les checks à faire dans une propriété qui s'appelle
+  justement :checks. Le test ne définit que les propriétés %{ks}…
+309: |
+  Les checks à faire pour le test (:checks) devraient être une liste
+  Array, par un %{c}.
+310: |
+  La redirection %{a} devrait être une chaine de caractères, pas un %{c}.
+311: |
+  La redirection %{a} devrait commencer par 'http[s]'…
+312: |
+  Pour tester la réponse HTTP, il faut donner le nombre attendu, donc il
+  faut donner un Integer, or %{a} est un %{c}. 
+  Par exemple : 404.
+800: |
+  -- INUTILISÉ --
+1000: |
+  L'instanciation de Lazy::Checker::CheckCase nécessite un Lazy::Checker::Url
+  en premier argument. La valeur est %{a}::%{c}.
+1001: |
+  L'instanciation de Lazy::Checker::CheckCase nécessite un Hash en second
+  argument, une table définissant ce cas de test. La valeur est %{a}::%{c}…
+1002: |
+  Les données du CheckCase devraient définir :tag, la balise avec son
+  identifiant et ses classes CSS. Elles ne définissent que :
+  %{ks}.
+1003: |
+  La donnée :tag du check case devrait au moins définir un identifiant (tag#id)
+  ou une classe CSS (tag.css). '%{a}' ne définit ni l'un ni l'autre.
+1004: |
+  Dans la donnée :tag, :count (%{a}) devrait être un nombre, pas un %{c}…
+2000: |
+  Définition de :contains erroné. Doit être une table (définissant au moins
+  :tag), un string (un texte à contenir ou une balise avec identifiant et/ou
+  class CSS) ou une liste de ces éléments. La classe de l'élément, quoi qu'il
+  en soit, ne peut être %{c}.
+
+# --- Les erreurs de check de la page ---
+
+4999: |
+  Aucun élément %{tag} n'a été trouvé alors qu'on en 
+  attendait %{e}.
+5000: |
+  Mauvais compte. On attend %{e} éléments %{tag}. On en a trouvé
+  %{a} dans la page.
+5001: |
+  Le contenu de %{tag} devrait être vide. Mais il contient le texte "%{a}".
+5002: |
+  Le contenu de %{tag} ne devrait pas être vide. Or il l'est.
+5003: |
+  Le contenu de %{tag} ne devrait comporter aucun texte, or 
+  il contient %{a}.
+5004: |
+  Le contenu de %{tag} devrait comporter du texte, or il n'en affiche
+  aucun.
+5010: |
+  On devrait trouver %{tag} contenant %{e}. Les problèmes suivants ont été
+  rencontrés : %{a}.
+5011: |
+  On devrait trouver %{tag} contenant le texte %{e}.
+5020: |
+  devrait contenir la chaine %{e}
+5021: |
+  devrait contenir la tag définie par %{e}
+5030: |
+  devrait définir les attributs
+5031: |
+  attributs manquants ou inégaux : %{e}.
+5032: |
+  le contenu n'est pas assez long. Il devrait faire au moins %{e} caractères,
+  il en fait %{a}.
+5033: |
+  le contenu est trop long. Il devrait faire moins de %{e} caractères, or il
+  en fait %{a}.
+
+5500: |
+  L'URL n'est pas redirigée. Elle aurait dû être redirigée vers
+  %{e}
+5501: |
+  L'URL est redirigée vers la mauvaise adresse. Elle aurait dû être redirigée
+  vers : %{e}
+  Elle est redirigée vers : %{a}.
+5502: |
+  L'HTTP Response attendue n'est pas la bonne…
+  On attendait la réponse : %{e}
+  On a reçu la réponse    : %{a} 
+5503: |
+  Erreur 404. La page %{e} est introuvable.
+6000: |
+  Le premier argument de Lazy::Checker.check doit être du code XML valide.
+  Or, %{se}.
+6001: |
+  %{a} n'est pas un String, c'est un %{c}.
+6002: |
+  un code XML valide se trouve enroulé dans un nœud racine. Ce n'est pas le
+  cas pour %{a}…
+6003: |
+  la donnée est nulle (nil).
+6010: |
+  Le second argument de Lazy::Checker.check doit être une table Hash valide
+  donc un Hash contenant les bonnes clés : %{se}
+6011: |
+  %{a} n'est pas un Hash, c'est un %{c}…
+

data/lib/lazy/check/locales/fr/messages.yaml

@@ -0,0 +1,18 @@
+---
+# -- Termes de messages --
+10: 'nombre '
+11: 'longueur '
+12: 'longueur min '
+13: 'longueur max '
+14: 'vide'
+15: 'non vide'
+16: 'contenant'
+17: 'contenant le texte'
+20: 'seulement parmi les enfants directs'
+21: 'avec les attributs'
+
+# -- Les messages de retour des checks --
+
+4999: |
+  La balise %{tag} a été trouvée avec les données attendues :
+  %{f_data}

data/lib/lazy/check/reporter.rb

@@ -0,0 +1,84 @@
+#
+# Class Lazy::Checker::Reporter
+# 
+# Pour établie le rapport de fin.
+# 
+module Lazy
+class Checker
+  class Reporter
+
+    attr_reader :checker
+
+    def initialize(checker)
+      @checker = checker
+    end
+
+    #
+    # Affichage du rapport
+    # 
+    def display
+      puts "\n\n"
+      puts "#{checker.name}".jaune
+      puts "-"* checker.name.length
+      nombre_erreurs = @failures.count
+      if true #verbose? # TODO À RÉGLER
+        display_list_resultats(success = true)
+      end
+      if nombre_erreurs > 0
+        display_list_resultats(success = false)
+      end
+      color = nombre_erreurs > 0 ? :red : :vert
+      msg = "Success #{@successs.count} Failures #{@failures.count} Temps #{formated_duree}"
+      puts "-" * msg.length
+      puts msg.send(color)
+    end
+
+    def add_success(check_case)
+      @successs << check_case
+    end
+    def add_failure(check_case)
+      @failures << check_case
+    end
+
+    # Pour afficher la liste de succès ou de failures
+    def display_list_resultats(success)
+      methode = success ? :message   : :errors
+      color   = success ? :vert      : :red
+      liste   = success ? @successs  : @failures
+      prefix  = success ? 'SUCCESS'  : 'FAILURE'
+
+      max_index = liste.count + 1
+      max_len_index = "[#{prefix} #{max_index}] ".length
+      indent = ' ' * max_len_index
+      liste.each_with_index do |checkedthing, idx|
+        index_str = "[#{prefix} #{idx + 1}]".ljust(max_len_index)
+        puts "#{index_str}#{checkedthing.send(methode).split("\n").join("\n#{indent}")}".send(color)
+      end
+    end
+
+    def start
+      @start_time = Time.now
+      @successs = []
+      @failures = []
+    end
+
+    def end
+      @end_time = Time.now
+    end
+
+    def formated_duree
+      @formated_duree ||= begin
+        if duree < 0.10
+          "#{(duree.to_f * 1000).round(4)} ms"
+        else
+          "#{duree.round(4)} s"
+        end
+      end
+    end
+    def duree
+      @duree ||= @end_time - @start_time
+    end
+
+  end #/class Reporter
+end #/class Checker
+end #/module Lazy

data/lib/lazy/check/version.rb

@@ -0,0 +1,5 @@
+module Lazy
+  module Check
+    VERSION = "1.0.0"
+  end
+end

data/lib/lazy/check.rb

@@ -0,0 +1,18 @@
+require 'clir'
+require 'yaml'
+require 'nokogiri'
+require "lazy/check/version"
+require 'lazy/check/constants'
+require "lazy/check/checker"
+require "lazy/check/checker_test"
+require "lazy/check/checker_url"
+require "lazy/check/checked_tag"
+require "lazy/check/checked_url"
+require 'lazy/check/Nokogiri_extension'
+require "lazy/check/checker_case"
+require "lazy/check/checker_code"
+require "lazy/check/reporter"
+
+def dbg(msg)
+  STDOUT.write "\n#{msg}"
+end

data/recipe.yaml

@@ -0,0 +1 @@
+---

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: lazy-check
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- PhilippePerret
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-09-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-color
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: clir
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ce gem permet de façon paresseuse mais néanmoins sérieuse de tester qu'un
+  site web est valide au niveau de ses pages et de son contenu.
+email:
+- philippe.perret@yahoo.fr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- Notes-developper.md
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lazy-check.gemspec
+- lib/lazy/check.rb
+- lib/lazy/check/Nokogiri_extension.rb
+- lib/lazy/check/checked_tag.rb
+- lib/lazy/check/checked_url.rb
+- lib/lazy/check/checker.rb
+- lib/lazy/check/checker_case.rb
+- lib/lazy/check/checker_code.rb
+- lib/lazy/check/checker_test.rb
+- lib/lazy/check/checker_url.rb
+- lib/lazy/check/constants.rb
+- lib/lazy/check/locales/en/errors.yaml
+- lib/lazy/check/locales/fr/errors.yaml
+- lib/lazy/check/locales/fr/messages.yaml
+- lib/lazy/check/reporter.rb
+- lib/lazy/check/version.rb
+- recipe.yaml
+homepage: https://rubygems.org/gems/lazy-check
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://rubygems.org/gems/lazy-check
+  source_code_uri: https://github.com/PhilippePerret/gem-lazy-check
+  changelog_uri: https://github.com/PhilippePerret/gem-lazy-check/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: Vérification paresseuse d'un site web
+test_files: []