Architecture is a behavior.Test it with ArchUnitTS_Test it with ArchUnit libraries for TypeScript, Python, .NET, Ruby, Rust, Zig, Go, Java, and PHP.

import { projectFiles } from 'archunit';

it('keeps the domain independent', async () => {
  const rule = projectFiles()
    .inFolder('src/domain/**')
    .shouldNot()
    .dependOnFiles()
    .inFolder('src/infrastructure/**');

  await expect(rule).toPassAsync();
});

from archunitpython import project_files, assert_passes

def test_domain_stays_independent():
    rule = (
        project_files('src/')
        .in_folder('**/domain/**')
        .should_not()
        .depend_on_files()
        .in_folder('**/infrastructure/**')
    )
    assert_passes(rule)

using ArchUnitNet;
using ArchUnitNet.Testing.XUnit;

[Fact]
public async Task DomainStaysIndependent()
{
    var rule = ArchUnit.ProjectFiles("./App.csproj")
        .InPath("src/Domain/**")
        .ShouldNot()
        .DependOnFiles()
        .InPath("src/Infrastructure/**");

    await rule.PassesAsync();
}

require 'archunit'

RSpec.describe 'architecture' do
  it 'keeps API away from persistence' do
    rule = ArchUnit.project_files
      .in_folder('app/api/**')
      .should_not.depend_on_files
      .in_folder('app/database/**')

    expect(rule).to pass
  end
end

use archunit::{assert_passes, project_files};

#[test]
fn api_does_not_reach_database() {
    let rule = project_files()
        .in_path("src/api/**")
        .should_not()
        .depend_on_files()
        .in_path("src/database/**");

    assert_passes!(rule);
}

const std = @import("std");
const archunit = @import("archunit");

test "production files have no cycles" {
    var files = try archunit.files(std.testing.allocator, .{});
    defer files.deinit();
    var scope = try files.inPath(&.{.{ .glob = "src/**/*.zig" }});
    defer scope.deinit();
    var should = try scope.should();
    defer should.deinit();
    var rule = try should.haveNoCycles();
    defer rule.deinit(std.testing.allocator);
    try archunit.expectPasses(&rule, .init(.init(std.testing.allocator, std.testing.io)));
}

package architecture_test

import (
    "testing"
    archunit "github.com/LukasNiessen/ArchUnitGo"
)

func TestApiDoesNotTouchDatabase(t *testing.T) {
    rule := archunit.ProjectFiles(nil).
        InFolder("internal/api/**").
        ShouldNot().DependOnFiles().
        InFolder("internal/db/**")

    archunit.AssertPasses(t, rule, nil)
}

var rule = ArchUnit.projectFiles()
    .inFolder("src/main/java/**/api/**")
    .shouldNot()
    .dependOnFiles()
    .inFolder("src/main/java/**/infrastructure/**");

ArchAssert.passes(rule);

$rule = ArchUnit::projectFiles()
    ->inFolder('src/Api/**')
    ->shouldNot()
    ->dependOnFiles()
    ->inFolder('src/Infrastructure/**');

ArchAssert::passes($rule);