lazy-check 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 763c1844791d4316d45e4d40b086e708ff10ec136c1aed5168bf1e1055b52200
+  data.tar.gz: 20c67417035d9daf100977c26a15075333a6cd9fc66ac38373bc66a2d8f6a01f
+SHA512:
+  metadata.gz: d68d5aaaf638e3540780c23d778d1de189df696778d6c92e1ba6ec0d6f3cc894ff28032bbb0270dc4c81cf3dee4a13de3c47b787dc3da1ae431e847fd478574b
+  data.tar.gz: 3340e1c675e78edcd698c0a30206232add999f8061c60613a1703caf2256bf6bfec5c9e7894959bba159b3f099e15216bc542ab83165693ca70ab00e13a1a418

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.7.3
+before_install: gem install bundler -v 2.1.4

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# 0.0.01
+
+* Création du gem

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in lazy-check.gemspec
+gemspec
+
+gem "rake", "~> 12.0"
+gem "minitest", "~> 5.0"

data/Gemfile.lock

@@ -0,0 +1,48 @@
+PATH
+  remote: .
+  specs:
+    lazy-check (0.1.0)
+      clir
+      nokogiri
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    clir (0.22.1)
+      json
+      tty-prompt
+    json (2.6.3)
+    mini_portile2 (2.8.4)
+    minitest (5.20.0)
+    minitest-color (0.0.2)
+      minitest (~> 5)
+    nokogiri (1.15.4)
+      mini_portile2 (~> 2.8.2)
+      racc (~> 1.4)
+    pastel (0.8.0)
+      tty-color (~> 0.5)
+    racc (1.7.1)
+    rake (12.3.3)
+    tty-color (0.6.0)
+    tty-cursor (0.7.1)
+    tty-prompt (0.23.1)
+      pastel (~> 0.8)
+      tty-reader (~> 0.8)
+    tty-reader (0.9.0)
+      tty-cursor (~> 0.7)
+      tty-screen (~> 0.8)
+      wisper (~> 2.0)
+    tty-screen (0.8.1)
+    wisper (2.0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  lazy-check!
+  minitest (~> 5.0)
+  minitest-color
+  rake (~> 12.0)
+
+BUNDLED WITH
+   2.1.4

data/Notes-developper.md

@@ -0,0 +1,39 @@
+# Lazy::Checker, notes développeur
+
+## Fonctionnement général du check
+
+L'utilisateur crée une instance `Lazy::Checker` (`checker.rb`) avec une adresse de recette (ou la recette présente dans le dossier où a été ouvert le Terminal)
+
+L'utilisateur appelle alors la méthode `#check` de cette instance, avec ou sans options (pour le moment, les options permettent seulement de déterminer si on doit afficher le résultat ou le retourner.
+
+La méthode `#check` vérifie si la recette est valide, et appelle le cas échéant la méthode `#proceed_check` avec les options.
+
+La méthode `Lazy::Checker#proceed_check` crée un rapporteur (`Lazy::Checker::Reporter`), le démarre et boucle sur chaque test de la propriété `:tests de la recette` (un `Array`).
+
+Pour chaque test, la méthode crée une instance `Lazy::Checker::Test` en lui donnant en argument l'instance checker (donc elle-même) et les données du test.
+
+> Parmi ces données de test se trouve `:url` qui détermine l'adresse URI qu'il va falloir tester, ainsi que `:checks` qui détermine la liste des checks à effectuer.
+
+Une fois tous les tests instanciés, on appelle leur méthode `#check`. Cette méthode boucle sur la propriété `:checks` des données du check, instancie un `Lazy::Checker::CheckCase` et appelle sa méthode `#check`.
+
+La méthode `Lazy::Checker::CheckCase#check` crée une instance `Lazy::Checker::CheckedTag` à partir des données du cas (celles qui contiennent `:tag`, `:text`, `:contains`, etc.) et vérifie que ce « tag » appartienne bien au conteneur défini par l'URL à l'aide de la méthode `#is_in?` qui est, pourrait-on dire, le cœur de ce gem.
+
+La méthode `#is_in?` retourne true ou false et crée respectivement un succès ou un échec dans le rapporteur.
+
+
+~~~yaml
+# --- La recette --- #=> instance Lazy::Checker
+name: Test d'une page internet
+base:  https:://mon_site.com # toutes les adresses sont vues par là
+# Les tests
+tests: 
+  - name: Nom du premier test #=> instance Lazy::Checker::Test
+    url: relative/to/page
+    checks:
+			# :url + 1 :check =>  instance Lazy::Checker::CheckCase
+			- tag: div#mondiv.content   #=> instance Lazy::Checker::CheckedTag
+        count: 1
+        text: "Bonjour tout le monde !"
+      - tag: div#autre_div            #=>  instance Lazy::Checker::CheckedTag
+
+

data/README.md

@@ -0,0 +1,148 @@
+# Lazy::Check
+
+Ce gem permet de tester de façon paresseuse un site web.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'lazy-check'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install lazy-check
+
+## Usage
+
+### Pour un test simple
+
+Si on a juste du code XML-like à tester, on peut utiliser la méthode `Lazy::Checker.check`.
+
+~~~ruby
+require 'lazy-check'
+
+code = "<root><div class="contient">du texte</div></root>"
+check = {tag: 'div.contient', text: "du texte"}
+Lazy::Checker.check(code, check)
+# => Écrit :
+#       -------------------------------------
+#       Succès 1 Failure 0 Temps ...
+~~~
+
+On peut aussi obtenir les résultats en retour de méthode (c'est un `Lazy::Checker::Reporter`)
+
+~~~ruby
+Lazy::Checker.check(code, check, **{return_result: true})
+# => Reporter
+~~~
+
+> Noter que dans ce cas-là, rien n'est écrit en console.
+
+## Pour un test avec recette
+
+Une « recette » est un fichier `YAML` qui définit l'url d'une page internet, ainsi que les checks à effectuer dessus. Cf. ci-dessous.
+
+~~~ruby
+require "lazy-check"
+
+checker = Lazy::Checker.new("path/to/recipe.yaml")
+checker.check
+# => Produit le résultat
+~~~
+
+Si la recette se trouve là où le terminal se trouve, il suffit de faire :
+
+~~~ruby
+require "lazy-check"
+
+Lazy::Checker.new.check
+~~~
+
+La recette (`recipe.yaml`) définit les vérifications qu'il faut effectuer.
+
+~~~yaml
+---
+name: "Nom général de la recette"
+base: https://www.mon.domaine.net
+tests:
+  - name: "Le premier test"
+    url: "" # donc la base
+    checks:
+      - name: "Existence du DIV#content avec du texte"
+        tag: 'div#content'
+        empty: false
+      - name: "Existence du SPAN#range sans texte"
+        tag: 'span#range'
+        empty: true
+  
+  - name: "Une redirection"
+    url: "redirection.html"
+    redirect_to: "https://nouvelle.url.net"
+
+  - name: "Une page erronée"
+    url: "page_inexistante.html"
+    response: 404
+~~~
+
+### Check Properties
+
+~~~yaml
+tag:                  [String] Le sélector
+count:             [Integer] Nombre attendu d'éléments
+empty:            [Bool] Si true, doit être vide ou non vide
+direct_child:   [Bool] Si true, doit être un enfant direct
+text:                 [String] Le texte qui doit être contenu
+contains:       [String|Array] Ce que doit contenir la page
+min_length: 		[Integer] La longueur minimum du contenu (text seulement)
+max_length: 		[Integer] La longueur maximum du contenu (text seulement)
+~~~
+
+## Exemples
+
+Simplement vérifier qu’une page réponde correctement :
+
+~~~yaml
+# recipe.yaml
+---
+name: "La page existe"
+base: 'https://monsite.net'
+tests: 
+	- name: "La page index.html existe et répond correctement"
+		url:  'index.html'
+		response: 200
+~~~
+
+Vérifier qu’une page contient les éléments de base
+
+~~~yaml
+# recipe.yaml
+---
+name: "Check simple de l'existence des éléments de base"
+base: 'https://monsite.net'
+tests: 
+	- name: "La page base.html contient les éléments de base"
+		url:  'index.html'
+		checks:
+			- tag: 'header'
+			- tag: 'section#body'
+			- tag: 'footer'
+~~~
+
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/PhilippePerret/lazy-check.
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "lazy/check"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lazy-check.gemspec

@@ -0,0 +1,34 @@
+require_relative 'lib/lazy/check/version'
+
+Gem::Specification.new do |s|
+  s.name          = "lazy-check"
+  s.version       = Lazy::Check::VERSION
+  s.authors       = ["PhilippePerret"]
+  s.email         = ["philippe.perret@yahoo.fr"]
+
+  s.summary       = %q{Vérification paresseuse d'un site web}
+  s.description   = %q{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.}
+  s.homepage      = "https://rubygems.org/gems/lazy-check"
+  s.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'minitest-color'
+
+  s.add_dependency 'clir'
+  s.add_dependency 'nokogiri'
+
+  s.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  s.metadata["homepage_uri"] = s.homepage
+  s.metadata["source_code_uri"] = "https://github.com/PhilippePerret/gem-lazy-check"
+  s.metadata["changelog_uri"] = "https://github.com/PhilippePerret/gem-lazy-check/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  s.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|features)/}) }
+  end
+  s.bindir        = "exe"
+  s.executables   = s.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/lazy/check/Nokogiri_extension.rb

@@ -0,0 +1,147 @@
+#
+# Cf. code sur Github
+# https://github.com/sparklemotion/nokogiri/blob/main/lib/nokogiri/xml/node.rb
+#
+module Nokogiri
+  class XML::Element
+
+    # Liste [Array] des erreurs rencontrées au cours d'un check
+    # Il faut penser initialiser (@errors = []) cette valeur au 
+    # début d'un check
+    attr_reader :errors
+
+    def traverse_children(&block)
+      children.each { |ch| ch.traverse(&block) }
+    end
+
+    # @return true si le node est vraiment vide
+    def empty?
+      not(children?) && content.empty?
+    end
+
+    def children?
+      elements && elements.count > 0
+    end
+
+    def has_text?
+      not(text.empty?)
+    end
+
+    def has_no_text?
+      text.empty?
+    end
+
+    # Test du contenu
+    # 
+    # @return true si le node courant contient tout ce qui est défini
+    # dans +required+
+    # 
+    # @param required [String|Hash|Array] les choses qu'on doit 
+    #                 trouver dans le noeud. Ça peut être un simple
+    #                 texte définissant soit un texte soit une balise, 
+    #                 une table définissant une balise ou une liste 
+    #                 de ces différentes choses.
+    def contains?(requireds)
+      @errors = []
+      @ok     = true
+      requireds = [requireds] unless requireds.is_a?(Array)
+
+      #
+      # Recherche sur tous les éléments requis
+      # 
+      # On ne s'arrête pas, même si une erreur a été trouvée, pour
+      # pouvoir les relever toutes.
+      # 
+      requireds.each do |required|
+        # 
+        # Qu'est-ce qu'on doit chercher ?
+        # 
+        case required
+        when String
+          if required.match?(/[^ ]/) && required.match?(/[#.]/)
+            contains_as_tag?({tag: required})
+          else
+            contains_as_string?(required)
+          end
+        when Hash
+          contains_as_tag?(required)
+        else
+          # Erreur d'implémentation, je dois m'arrêter
+          raise CheckCaseError.new(Lazy::ERRORS[2000] % {c: required.class.name})
+        end
+      end
+
+      return @errors.empty? # true si OK
+    end
+    #/ contains?
+
+
+    # @return true si le node contient le texte +searched+
+    # (mais ce retour ne sert pas à grand-chose, en fait, et même
+    #  à rien)
+    # Surtout : ajoute une erreur à @errors si une erreur est
+    # rencontrées.
+    # 
+    # @note
+    #     alias   #match?
+    # 
+    def contains_as_string?(searched)
+      if text.include?(searched)
+        return true
+      else
+        add_error(Lazy::ERRORS[5020] % {e: searched})
+        return false
+      end
+    end
+    alias :match? :contains_as_string?
+
+    # @return true si le node contient le node +dtag+ ou produit
+    # une erreur dans @errors
+    # 
+    def contains_as_tag?(dtag)
+      ctag = Lazy::Checker::CheckedTag.new(dtag)
+      if ctag.is_in?(self)
+        return true
+      else
+        add_error(Lazy::ERRORS[5021] % {e: dtag.inspect})
+        return false
+      end
+    end
+
+    # @return [Array] Liste des attributs qui manque à l'élément
+    # par rapport à attrs
+    def attributes?(attrs)
+      miss_attrs = []
+      attrs.each do |attr_name, attr_value|
+        attr_name = attr_name.to_s
+        if self.key?(attr_name) 
+          # L'attribut existe
+          if self.attr(attr_name) == attr_value
+            # … et sa valeur est la bonne
+            next
+          else
+            # … mais sa valeur est différente
+            miss_attrs << "attribut #{attr_name} existe, mais avec la valeur #{self.attr(attr_name).inspect}, pas #{attr_value.inspect}."
+          end
+        else
+          miss_attrs << "pas d'attribut #{attr_name.inspect}"
+        end
+      end
+      return miss_attrs
+    end
+
+    def add_error(err)
+      @errors ||= []
+      @errors << err
+    end
+
+    def id
+      @id ||= self['id']
+    end
+
+    # @return [Integer] La longueur du texte
+    def length
+      @length ||= text.length
+    end
+  end #/class XML::Element
+end #/module Nokogiri