arch_test

Archotes

Archtest est un outil de test d'architecture basé sur des règles. Il applique des analyses statiques sur le projet de rouille spécifié pour extraire les relations d'utilisation.

Caractéristiques

• Détecter les dépendances cycliques au niveau du niveau ou du module sage
• Interdire l'accès des parents
• Définissez des relations de couche comme MayNotAccess , MayOnlyAccess , MyNotBeAccessedBy , MayOnlyBeAccessedBy
• Et plus, veuillez consulter la documentation.

Installer

Vous pouvez l'installer soit comme sous-commande de cargo, soit comme un package dans vos dépendances de développeur.

 # Sub command
cargo install cargo-archtest --force

# Package
[dev-dependencies]
arch_test_core = "*"

Comment l'utiliser

Utilisation de la commande de cargaison

Définissez dans le chemin de la racine du fret Un fichier appelé architecture.json . Remplissez-le en fonction de la structure Specification . Exemple:

{
  "layer_names" : [ " analyzer " , " parser " , " domain_values " , " entities " , " materials " , " services " , " tests " , " utils " ],
  "access_rules" : [
    " NoLayerCyclicDependencies " ,
    " NoModuleCyclicDependencies " ,
    " NoParentAccess " ,
    {
      "MayNotAccess" : {
        "accessor" : " parser " ,
        "accessed" : [ " analyzer " ],
        "when_same_parent" : true
      }
    },
    {
      "MayOnlyBeAccessedBy" : {
        "accessors" : [ " services " , " tests " ],
        "accessed" : " materials " ,
        "when_same_parent" : false
      }
    },
    {
      "MayNotBeAccessedBy" : {
        "accessors" : [ " materials " , " domain_values " , " entities " , " utils " ],
        "accessed" : " services " ,
        "when_same_parent" : true
      }
    }
  ]
}

Utilisation d'un test de rouille

Vous pouvez utiliser la structure Architecture afin de définir votre architecture. Ensuite, vous le vérifiez pour les échecs.

 let architecture = Architecture :: new ( hash_set ! [ "analyzer" . to_owned ( ) , "parser" . to_owned ( ) , ... ] )
. with_access_rule ( NoParentAccess )
. with_access_rule ( NoModuleCyclicDependencies )
. with_access_rule ( NoLayerCyclicDependencies )
...
. with_access_rule ( MayNotAccess :: new (
    "materials" . to_owned ( ) ,
    hash_set ! [ "tests" . to_owned ( ) ] ,
    true ,
) ) ;
let module_tree = ModuleTree :: new ( "src/lib.rs" ) ;
assert ! ( architecture . validate_access_rules ( ) . is_ok ( ) ) ;
assert ! ( architecture . check_access_rules ( & module_tree ) . is_ok ( ) ) ;

Si vous êtes intéressé par l'échec, vous pouvez l'imprimer comme ceci:

architecture . check_access_rules ( & module_tree ) . err ( ) . unwrap ( ) . print ( module_tree . tree ( ) ) ; 

Intégration continue

Vous pouvez l'utiliser en intégration continue en utilisant l'une ou l'autre méthodes. Si vous décidez d'utiliser la commande de cargaison sur GitHub, l'extrait suivant vous permettra de tester votre projet.

 arch_test :
  name : ArchTest
  runs-on : ubuntu-latest
  steps :
    - uses : actions/checkout@v2
    - uses : actions-rs/[email protected]
      with :
        crate : cargo-archtest
        version : latest
    - run : cargo archtest