From 4d6463a6be6adcdbb21a14393f17498e9df603ba Mon Sep 17 00:00:00 2001 From: Alexander Linne Date: Fri, 24 Jul 2026 13:49:58 +0200 Subject: [PATCH] test: rewrite class syntax elements tests Signed-off-by: Alexander Linne --- ArchUnit.sln | 15 + .../Types/Classes/IAddClassCondition.cs | 2 + .../Types/Classes/IAddClassPredicate.cs | 2 + ArchUnitNETTests/ArchUnitNETTests.csproj | 1 + .../ClassAssemblyTestHelper.cs | 73 +++ .../Elements/ClassSyntaxElementsTests.cs | 444 +++++++++--------- ...xElementsTests.BeAbstractTest.verified.txt | 63 +++ ...ElementsTests.BeImmutableTest.verified.txt | 99 ++++ ...taxElementsTests.BeRecordTest.verified.txt | 63 +++ ...taxElementsTests.BeSealedTest.verified.txt | 63 +++ ...ementsTests.NotBeAbstractTest.verified.txt | 63 +++ ...mentsTests.NotBeImmutableTest.verified.txt | 63 +++ ...ElementsTests.NotBeRecordTest.verified.txt | 63 +++ ...ElementsTests.NotBeSealedTest.verified.txt | 63 +++ ArchUnitNETTests/StaticTestArchitectures.cs | 6 + .../ClassAssembly/ClassAssembly.csproj | 12 + .../ClassAssembly/ClassAssemblyClasses.cs | 47 ++ 17 files changed, 915 insertions(+), 227 deletions(-) create mode 100644 ArchUnitNETTests/AssemblyTestHelper/ClassAssemblyTestHelper.cs create mode 100644 ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.BeAbstractTest.verified.txt create mode 100644 ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.BeImmutableTest.verified.txt create mode 100644 ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.BeRecordTest.verified.txt create mode 100644 ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.BeSealedTest.verified.txt create mode 100644 ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.NotBeAbstractTest.verified.txt create mode 100644 ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.NotBeImmutableTest.verified.txt create mode 100644 ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.NotBeRecordTest.verified.txt create mode 100644 ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.NotBeSealedTest.verified.txt create mode 100644 TestAssemblies/ClassAssembly/ClassAssembly.csproj create mode 100644 TestAssemblies/ClassAssembly/ClassAssemblyClasses.cs diff --git a/ArchUnit.sln b/ArchUnit.sln index 04f1a4ae1..940ab8db6 100644 --- a/ArchUnit.sln +++ b/ArchUnit.sln @@ -61,6 +61,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MethodMemberAssembly", "Tes EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PropertyMemberAssembly", "TestAssemblies\PropertyMemberAssembly\PropertyMemberAssembly.csproj", "{1D0187EB-9D04-4CF3-AE63-0C0E97FCB49C}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ClassAssembly", "TestAssemblies\ClassAssembly\ClassAssembly.csproj", "{2C04EB93-5AE0-474C-B328-145A734A5E2B}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -407,6 +409,18 @@ Global {1D0187EB-9D04-4CF3-AE63-0C0E97FCB49C}.Release|x64.Build.0 = Release|Any CPU {1D0187EB-9D04-4CF3-AE63-0C0E97FCB49C}.Release|x86.ActiveCfg = Release|Any CPU {1D0187EB-9D04-4CF3-AE63-0C0E97FCB49C}.Release|x86.Build.0 = Release|Any CPU + {2C04EB93-5AE0-474C-B328-145A734A5E2B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {2C04EB93-5AE0-474C-B328-145A734A5E2B}.Debug|Any CPU.Build.0 = Debug|Any CPU + {2C04EB93-5AE0-474C-B328-145A734A5E2B}.Debug|x64.ActiveCfg = Debug|Any CPU + {2C04EB93-5AE0-474C-B328-145A734A5E2B}.Debug|x64.Build.0 = Debug|Any CPU + {2C04EB93-5AE0-474C-B328-145A734A5E2B}.Debug|x86.ActiveCfg = Debug|Any CPU + {2C04EB93-5AE0-474C-B328-145A734A5E2B}.Debug|x86.Build.0 = Debug|Any CPU + {2C04EB93-5AE0-474C-B328-145A734A5E2B}.Release|Any CPU.ActiveCfg = Release|Any CPU + {2C04EB93-5AE0-474C-B328-145A734A5E2B}.Release|Any CPU.Build.0 = Release|Any CPU + {2C04EB93-5AE0-474C-B328-145A734A5E2B}.Release|x64.ActiveCfg = Release|Any CPU + {2C04EB93-5AE0-474C-B328-145A734A5E2B}.Release|x64.Build.0 = Release|Any CPU + {2C04EB93-5AE0-474C-B328-145A734A5E2B}.Release|x86.ActiveCfg = Release|Any CPU + {2C04EB93-5AE0-474C-B328-145A734A5E2B}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -423,5 +437,6 @@ Global {ABCA0EC3-E47E-453E-B4CC-3446ED4F7643} = {B1191F18-91CB-4387-B775-A5EB64D3AC30} {05F40E4D-94EC-4DF7-B0FA-1BCBFDF56088} = {B1191F18-91CB-4387-B775-A5EB64D3AC30} {1D0187EB-9D04-4CF3-AE63-0C0E97FCB49C} = {B1191F18-91CB-4387-B775-A5EB64D3AC30} + {2C04EB93-5AE0-474C-B328-145A734A5E2B} = {B1191F18-91CB-4387-B775-A5EB64D3AC30} EndGlobalSection EndGlobal diff --git a/ArchUnitNET/Fluent/Syntax/Elements/Types/Classes/IAddClassCondition.cs b/ArchUnitNET/Fluent/Syntax/Elements/Types/Classes/IAddClassCondition.cs index 337fa7193..c9d1a2a39 100644 --- a/ArchUnitNET/Fluent/Syntax/Elements/Types/Classes/IAddClassCondition.cs +++ b/ArchUnitNET/Fluent/Syntax/Elements/Types/Classes/IAddClassCondition.cs @@ -8,12 +8,14 @@ public interface IAddClassCondition { TNextElement BeAbstract(); TNextElement BeSealed(); + TNextElement BeRecord(); TNextElement BeImmutable(); //Negations TNextElement NotBeAbstract(); TNextElement NotBeSealed(); + TNextElement NotBeRecord(); TNextElement NotBeImmutable(); } } diff --git a/ArchUnitNET/Fluent/Syntax/Elements/Types/Classes/IAddClassPredicate.cs b/ArchUnitNET/Fluent/Syntax/Elements/Types/Classes/IAddClassPredicate.cs index 957be5c3b..b84cf84c5 100644 --- a/ArchUnitNET/Fluent/Syntax/Elements/Types/Classes/IAddClassPredicate.cs +++ b/ArchUnitNET/Fluent/Syntax/Elements/Types/Classes/IAddClassPredicate.cs @@ -8,12 +8,14 @@ public interface IAddClassPredicate { TNextElement AreAbstract(); TNextElement AreSealed(); + TNextElement AreRecord(); TNextElement AreImmutable(); //Negations TNextElement AreNotAbstract(); TNextElement AreNotSealed(); + TNextElement AreNotRecord(); TNextElement AreNotImmutable(); } } diff --git a/ArchUnitNETTests/ArchUnitNETTests.csproj b/ArchUnitNETTests/ArchUnitNETTests.csproj index f5635d9c4..2d9c53971 100644 --- a/ArchUnitNETTests/ArchUnitNETTests.csproj +++ b/ArchUnitNETTests/ArchUnitNETTests.csproj @@ -34,6 +34,7 @@ + diff --git a/ArchUnitNETTests/AssemblyTestHelper/ClassAssemblyTestHelper.cs b/ArchUnitNETTests/AssemblyTestHelper/ClassAssemblyTestHelper.cs new file mode 100644 index 000000000..fbb5cce7c --- /dev/null +++ b/ArchUnitNETTests/AssemblyTestHelper/ClassAssemblyTestHelper.cs @@ -0,0 +1,73 @@ +using System; +using ArchUnitNET.Domain; +using ArchUnitNET.Domain.Extensions; +using ClassNamespace; + +namespace ArchUnitNETTests.AssemblyTestHelper; + +public class ClassAssemblyTestHelper : AssemblyTestHelper +{ + public sealed override Architecture Architecture => StaticTestArchitectures.ClassArchitecture; + + public Class RegularClass; + public Type RegularClassSystemType = typeof(RegularClass); + + public Class OtherRegularClass; + public Type OtherRegularClassSystemType = typeof(OtherRegularClass); + + public Class AbstractClass; + public Type AbstractClassSystemType = typeof(AbstractClass); + + public Class OtherAbstractClass; + public Type OtherAbstractClassSystemType = typeof(OtherAbstractClass); + + public Class SealedClass; + public Type SealedClassSystemType = typeof(SealedClass); + + public Class OtherSealedClass; + public Type OtherSealedClassSystemType = typeof(OtherSealedClass); + + public Class RecordClass; + public Type RecordClassSystemType = typeof(RecordClass); + + public Class OtherRecordClass; + public Type OtherRecordClassSystemType = typeof(OtherRecordClass); + + public Class ImmutableClass; + public Type ImmutableClassSystemType = typeof(ImmutableClass); + + public Class OtherImmutableClass; + public Type OtherImmutableClassSystemType = typeof(OtherImmutableClass); + + public Class MutableClass; + public Type MutableClassSystemType = typeof(MutableClass); + + public Class OtherMutableClass; + public Type OtherMutableClassSystemType = typeof(OtherMutableClass); + + public Class ClassWithoutMembers; + public Type ClassWithoutMembersSystemType = typeof(ClassWithoutMembers); + + public Class ClassWithOnlyStaticMembers; + public Type ClassWithOnlyStaticMembersSystemType = typeof(ClassWithOnlyStaticMembers); + + public ClassAssemblyTestHelper() + { + RegularClass = Architecture.GetClassOfType(typeof(RegularClass)); + OtherRegularClass = Architecture.GetClassOfType(typeof(OtherRegularClass)); + AbstractClass = Architecture.GetClassOfType(typeof(AbstractClass)); + OtherAbstractClass = Architecture.GetClassOfType(typeof(OtherAbstractClass)); + SealedClass = Architecture.GetClassOfType(typeof(SealedClass)); + OtherSealedClass = Architecture.GetClassOfType(typeof(OtherSealedClass)); + RecordClass = Architecture.GetClassOfType(typeof(RecordClass)); + OtherRecordClass = Architecture.GetClassOfType(typeof(OtherRecordClass)); + ImmutableClass = Architecture.GetClassOfType(typeof(ImmutableClass)); + OtherImmutableClass = Architecture.GetClassOfType(typeof(OtherImmutableClass)); + MutableClass = Architecture.GetClassOfType(typeof(MutableClass)); + OtherMutableClass = Architecture.GetClassOfType(typeof(OtherMutableClass)); + ClassWithoutMembers = Architecture.GetClassOfType(typeof(ClassWithoutMembers)); + ClassWithOnlyStaticMembers = Architecture.GetClassOfType( + typeof(ClassWithOnlyStaticMembers) + ); + } +} diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/ClassSyntaxElementsTests.cs b/ArchUnitNETTests/Fluent/Syntax/Elements/ClassSyntaxElementsTests.cs index e5a0b46ba..32253541f 100644 --- a/ArchUnitNETTests/Fluent/Syntax/Elements/ClassSyntaxElementsTests.cs +++ b/ArchUnitNETTests/Fluent/Syntax/Elements/ClassSyntaxElementsTests.cs @@ -1,279 +1,269 @@ -using System.Collections.Generic; -using System.Linq; -using ArchUnitNET.Domain; +using System.Threading.Tasks; +using ArchUnitNETTests.AssemblyTestHelper; using Xunit; using static ArchUnitNET.Fluent.ArchRuleDefinition; namespace ArchUnitNETTests.Fluent.Syntax.Elements { + // csharpier-ignore public class ClassSyntaxElementsTests { - public ClassSyntaxElementsTests() + [Fact] + public async Task BeAbstractTest() { - _classes = Architecture.Classes; - } + var helper = new ClassAssemblyTestHelper(); - private static readonly Architecture Architecture = - StaticTestArchitectures.ArchUnitNETTestArchitecture; - private readonly IEnumerable _classes; + helper.AddSnapshotHeader("No Violations"); + var should = Classes().That().Are(helper.AbstractClass).Should(); - [Fact] - public void AreAbstractTest() - { - foreach (var cls in _classes) - { - var clsIsAbstract = Classes().That().Are(cls).Should().BeAbstract(); - var clsIsNotAbstract = Classes().That().Are(cls).Should().NotBeAbstract(); - var abstractClassesDoNotIncludeType = Classes() - .That() - .AreAbstract() - .Should() - .NotBe(cls); - var notAbstractClassesDoNotIncludeType = Classes() - .That() - .AreNotAbstract() - .Should() - .NotBe(cls); - - Assert.Equal(cls.IsAbstract, clsIsAbstract.HasNoViolations(Architecture)); - Assert.Equal(!cls.IsAbstract, clsIsNotAbstract.HasNoViolations(Architecture)); - Assert.Equal( - !cls.IsAbstract, - abstractClassesDoNotIncludeType.HasNoViolations(Architecture) - ); - Assert.Equal( - cls.IsAbstract, - notAbstractClassesDoNotIncludeType.HasNoViolations(Architecture) - ); - } - - var abstractClassesAreAbstract = Classes().That().AreAbstract().Should().BeAbstract(); - var abstractClassesAreNotAbstract = Classes() - .That() - .AreAbstract() - .Should() - .NotBeAbstract(); - var notAbstractClassesAreAbstract = Classes() - .That() - .AreNotAbstract() - .Should() - .BeAbstract(); - var notAbstractClassesAreNotAbstract = Classes() - .That() - .AreNotAbstract() - .Should() - .NotBeAbstract(); - - Assert.True(abstractClassesAreAbstract.HasNoViolations(Architecture)); - Assert.False(abstractClassesAreNotAbstract.HasNoViolations(Architecture)); - Assert.False(notAbstractClassesAreAbstract.HasNoViolations(Architecture)); - Assert.True(notAbstractClassesAreNotAbstract.HasNoViolations(Architecture)); + helper.AddSnapshotSubHeader("Conditions"); + should.BeAbstract().AssertNoViolations(helper); + + helper.AddSnapshotSubHeader("Predicates"); + should.Be(Classes().That().AreAbstract()).AssertNoViolations(helper); + + helper.AddSnapshotHeader("Violations"); + should = Classes().That().Are(helper.RegularClass).Should(); + + helper.AddSnapshotSubHeader("Conditions"); + should.BeAbstract().AssertOnlyViolations(helper); + + helper.AddSnapshotSubHeader("Predicates"); + should.Be(Classes().That().AreAbstract()).AssertOnlyViolations(helper); + + helper.AddSnapshotHeader("Multiple inputs"); + Classes().That().Are(helper.AbstractClass, helper.OtherAbstractClass).Should().BeAbstract().AssertNoViolations(helper); + Classes().That().Are(helper.AbstractClass, helper.RegularClass).Should().BeAbstract().AssertAnyViolations(helper); + + await helper.AssertSnapshotMatches(); } [Fact] - public void AreEnumsTest() + public async Task NotBeAbstractTest() { - Assert.True( - Classes().That().AreNotEnums().Should().Be(Classes()).HasNoViolations(Architecture) - ); - Assert.True( - Classes().That().AreEnums().Should().NotExist().HasNoViolations(Architecture) - ); - Assert.True(Classes().Should().NotBeEnums().HasNoViolations(Architecture)); - Assert.False(Classes().Should().BeEnums().HasNoViolations(Architecture)); + var helper = new ClassAssemblyTestHelper(); + + helper.AddSnapshotHeader("No Violations"); + var should = Classes().That().Are(helper.RegularClass).Should(); + + helper.AddSnapshotSubHeader("Conditions"); + should.NotBeAbstract().AssertNoViolations(helper); + + helper.AddSnapshotSubHeader("Predicates"); + should.Be(Classes().That().AreNotAbstract()).AssertNoViolations(helper); + + helper.AddSnapshotHeader("Violations"); + should = Classes().That().Are(helper.AbstractClass).Should(); + + helper.AddSnapshotSubHeader("Conditions"); + should.NotBeAbstract().AssertOnlyViolations(helper); + + helper.AddSnapshotSubHeader("Predicates"); + should.Be(Classes().That().AreNotAbstract()).AssertOnlyViolations(helper); + + helper.AddSnapshotHeader("Multiple inputs"); + Classes().That().Are(helper.RegularClass, helper.OtherRegularClass).Should().NotBeAbstract().AssertNoViolations(helper); + Classes().That().Are(helper.RegularClass, helper.AbstractClass).Should().NotBeAbstract().AssertAnyViolations(helper); + + await helper.AssertSnapshotMatches(); } [Fact] - public void AreSealedTest() + public async Task BeSealedTest() { - foreach (var cls in _classes) - { - var clsIsSealed = Classes().That().Are(cls).Should().BeSealed(); - var clsIsNotSealed = Classes().That().Are(cls).Should().NotBeSealed(); - var sealedClassesDoNotIncludeType = Classes() - .That() - .AreSealed() - .Should() - .NotBe(cls); - var notSealedClassesDoNotIncludeType = Classes() - .That() - .AreNotSealed() - .Should() - .NotBe(cls); - - Assert.Equal(cls.IsSealed, clsIsSealed.HasNoViolations(Architecture)); - Assert.Equal(!cls.IsSealed, clsIsNotSealed.HasNoViolations(Architecture)); - Assert.Equal( - !cls.IsSealed, - sealedClassesDoNotIncludeType.HasNoViolations(Architecture) - ); - Assert.Equal( - cls.IsSealed, - notSealedClassesDoNotIncludeType.HasNoViolations(Architecture) - ); - } - - var sealedClassesAreSealed = Classes().That().AreSealed().Should().BeSealed(); - var sealedClassesAreNotSealed = Classes().That().AreSealed().Should().NotBeSealed(); - var notSealedClassesAreSealed = Classes().That().AreNotSealed().Should().BeSealed(); - var notSealedClassesAreNotSealed = Classes() - .That() - .AreNotSealed() - .Should() - .NotBeSealed(); - - Assert.True(sealedClassesAreSealed.HasNoViolations(Architecture)); - Assert.False(sealedClassesAreNotSealed.HasNoViolations(Architecture)); - Assert.False(notSealedClassesAreSealed.HasNoViolations(Architecture)); - Assert.True(notSealedClassesAreNotSealed.HasNoViolations(Architecture)); + var helper = new ClassAssemblyTestHelper(); + + helper.AddSnapshotHeader("No Violations"); + var should = Classes().That().Are(helper.SealedClass).Should(); + + helper.AddSnapshotSubHeader("Conditions"); + should.BeSealed().AssertNoViolations(helper); + + helper.AddSnapshotSubHeader("Predicates"); + should.Be(Classes().That().AreSealed()).AssertNoViolations(helper); + + helper.AddSnapshotHeader("Violations"); + should = Classes().That().Are(helper.RegularClass).Should(); + + helper.AddSnapshotSubHeader("Conditions"); + should.BeSealed().AssertOnlyViolations(helper); + + helper.AddSnapshotSubHeader("Predicates"); + should.Be(Classes().That().AreSealed()).AssertOnlyViolations(helper); + + helper.AddSnapshotHeader("Multiple inputs"); + Classes().That().Are(helper.SealedClass, helper.OtherSealedClass).Should().BeSealed().AssertNoViolations(helper); + Classes().That().Are(helper.SealedClass, helper.RegularClass).Should().BeSealed().AssertAnyViolations(helper); + + await helper.AssertSnapshotMatches(); } [Fact] - public void AreStructsTest() + public async Task NotBeSealedTest() { - Assert.True( - Classes() - .That() - .AreNotStructs() - .Should() - .Be(Classes()) - .HasNoViolations(Architecture) - ); - Assert.True( - Classes().That().AreStructs().Should().NotExist().HasNoViolations(Architecture) - ); - Assert.True(Classes().Should().NotBeStructs().HasNoViolations(Architecture)); - Assert.False(Classes().Should().BeStructs().HasNoViolations(Architecture)); + var helper = new ClassAssemblyTestHelper(); + + helper.AddSnapshotHeader("No Violations"); + var should = Classes().That().Are(helper.RegularClass).Should(); + + helper.AddSnapshotSubHeader("Conditions"); + should.NotBeSealed().AssertNoViolations(helper); + + helper.AddSnapshotSubHeader("Predicates"); + should.Be(Classes().That().AreNotSealed()).AssertNoViolations(helper); + + helper.AddSnapshotHeader("Violations"); + should = Classes().That().Are(helper.SealedClass).Should(); + + helper.AddSnapshotSubHeader("Conditions"); + should.NotBeSealed().AssertOnlyViolations(helper); + + helper.AddSnapshotSubHeader("Predicates"); + should.Be(Classes().That().AreNotSealed()).AssertOnlyViolations(helper); + + helper.AddSnapshotHeader("Multiple inputs"); + Classes().That().Are(helper.RegularClass, helper.OtherRegularClass).Should().NotBeSealed().AssertNoViolations(helper); + Classes().That().Are(helper.RegularClass, helper.SealedClass).Should().NotBeSealed().AssertAnyViolations(helper); + + await helper.AssertSnapshotMatches(); } [Fact] - public void AreValueTypesTest() + public async Task BeRecordTest() { - Assert.True( - Classes() - .That() - .AreNotValueTypes() - .Should() - .Be(Classes()) - .HasNoViolations(Architecture) - ); - Assert.True( - Classes().That().AreValueTypes().Should().NotExist().HasNoViolations(Architecture) - ); - Assert.True(Classes().Should().NotBeValueTypes().HasNoViolations(Architecture)); - Assert.False(Classes().Should().BeValueTypes().HasNoViolations(Architecture)); + var helper = new ClassAssemblyTestHelper(); + + helper.AddSnapshotHeader("No Violations"); + var should = Classes().That().Are(helper.RecordClass).Should(); + + helper.AddSnapshotSubHeader("Conditions"); + should.BeRecord().AssertNoViolations(helper); + + helper.AddSnapshotSubHeader("Predicates"); + should.Be(Classes().That().AreRecord()).AssertNoViolations(helper); + + helper.AddSnapshotHeader("Violations"); + should = Classes().That().Are(helper.RegularClass).Should(); + + helper.AddSnapshotSubHeader("Conditions"); + should.BeRecord().AssertOnlyViolations(helper); + + helper.AddSnapshotSubHeader("Predicates"); + should.Be(Classes().That().AreRecord()).AssertOnlyViolations(helper); + + helper.AddSnapshotHeader("Multiple inputs"); + Classes().That().Are(helper.RecordClass, helper.OtherRecordClass).Should().BeRecord().AssertNoViolations(helper); + Classes().That().Are(helper.RecordClass, helper.RegularClass).Should().BeRecord().AssertAnyViolations(helper); + + await helper.AssertSnapshotMatches(); } [Fact] - public void AreImmutableTest() + public async Task NotBeRecordTest() { - foreach (var cls in _classes) - { - var clsIsImmutable = Classes().That().Are(cls).Should().BeImmutable(); - var clsIsNotImmutable = Classes().That().Are(cls).Should().NotBeImmutable(); - var immutableClassesDoNotIncludeType = Classes() - .That() - .AreImmutable() - .Should() - .NotBe(cls); - var notImmutableClassesDoNotIncludeType = Classes() - .That() - .AreNotImmutable() - .Should() - .NotBe(cls); - - bool isImmutable = cls - .Members.Where(m => m.IsStatic == false) - .All(m => m.Writability.IsImmutable()); - Assert.Equal(isImmutable, clsIsImmutable.HasNoViolations(Architecture)); - Assert.Equal(!isImmutable, clsIsNotImmutable.HasNoViolations(Architecture)); - Assert.Equal( - !isImmutable, - immutableClassesDoNotIncludeType.HasNoViolations(Architecture) - ); - Assert.Equal( - isImmutable, - notImmutableClassesDoNotIncludeType.HasNoViolations(Architecture) - ); - } - - var immutableClassesAreImmutable = Classes() - .That() - .AreImmutable() - .Should() - .BeImmutable(); - var immutableClassesAreNotImmutable = Classes() - .That() - .AreImmutable() - .Should() - .NotBeImmutable(); - var notImmutableClassesAreImmutable = Classes() - .That() - .AreNotImmutable() - .Should() - .BeImmutable(); - var notImmutableClassesAreNotImmutabled = Classes() - .That() - .AreNotImmutable() - .Should() - .NotBeImmutable(); - - Assert.True(immutableClassesAreImmutable.HasNoViolations(Architecture)); - Assert.False(immutableClassesAreNotImmutable.HasNoViolations(Architecture)); - Assert.False(notImmutableClassesAreImmutable.HasNoViolations(Architecture)); - Assert.True(notImmutableClassesAreNotImmutabled.HasNoViolations(Architecture)); + var helper = new ClassAssemblyTestHelper(); + + helper.AddSnapshotHeader("No Violations"); + var should = Classes().That().Are(helper.RegularClass).Should(); + + helper.AddSnapshotSubHeader("Conditions"); + should.NotBeRecord().AssertNoViolations(helper); + + helper.AddSnapshotSubHeader("Predicates"); + should.Be(Classes().That().AreNotRecord()).AssertNoViolations(helper); + + helper.AddSnapshotHeader("Violations"); + should = Classes().That().Are(helper.RecordClass).Should(); + + helper.AddSnapshotSubHeader("Conditions"); + should.NotBeRecord().AssertOnlyViolations(helper); + + helper.AddSnapshotSubHeader("Predicates"); + should.Be(Classes().That().AreNotRecord()).AssertOnlyViolations(helper); + + helper.AddSnapshotHeader("Multiple inputs"); + Classes().That().Are(helper.RegularClass, helper.OtherRegularClass).Should().NotBeRecord().AssertNoViolations(helper); + Classes().That().Are(helper.RegularClass, helper.RecordClass).Should().NotBeRecord().AssertAnyViolations(helper); + + await helper.AssertSnapshotMatches(); } [Fact] - public void AreRecordTest() + public async Task BeImmutableTest() { - var recordsAreRecord = Classes().That().AreRecord().Should().BeRecord(); + var helper = new ClassAssemblyTestHelper(); - var recordsAreNotRecord = Classes().That().AreRecord().Should().NotBeRecord(); + helper.AddSnapshotHeader("No Violations"); + var should = Classes().That().Are(helper.ImmutableClass).Should(); - var notRecordsAreRecord = Classes().That().AreNotRecord().Should().BeRecord(); + helper.AddSnapshotSubHeader("Conditions"); + should.BeImmutable().AssertNoViolations(helper); - var notRecordsAreNotRecord = Classes().That().AreNotRecord().Should().NotBeRecord(); + helper.AddSnapshotSubHeader("Predicates"); + should.Be(Classes().That().AreImmutable()).AssertNoViolations(helper); - Assert.True(recordsAreRecord.HasNoViolations(Architecture)); - Assert.False(recordsAreNotRecord.HasNoViolations(Architecture)); - Assert.False(notRecordsAreRecord.HasNoViolations(Architecture)); - Assert.True(notRecordsAreNotRecord.HasNoViolations(Architecture)); - } + helper.AddSnapshotHeader("Violations"); + should = Classes().That().Are(helper.MutableClass).Should(); - private record ImmutableRecord(string Property, string AnotherProperty); + helper.AddSnapshotSubHeader("Conditions"); + should.BeImmutable().AssertOnlyViolations(helper); -#pragma warning disable 0169 -#pragma warning disable 0414 - private class ImmutableClass - { - private readonly string field; + helper.AddSnapshotSubHeader("Predicates"); + should.Be(Classes().That().AreImmutable()).AssertOnlyViolations(helper); - private readonly string initializedField = ""; + helper.AddSnapshotHeader("Multiple inputs"); + Classes().That().Are(helper.ImmutableClass, helper.OtherImmutableClass).Should().BeImmutable().AssertNoViolations(helper); + Classes().That().Are(helper.ImmutableClass, helper.MutableClass).Should().BeImmutable().AssertAnyViolations(helper); - public string Property { get; } + helper.AddSnapshotHeader("Class without members (vacuously immutable)"); + should = Classes().That().Are(helper.ClassWithoutMembers).Should(); - public string AnotherProperty { get; init; } - } -#pragma warning restore 0169 -#pragma warning restore 0414 + helper.AddSnapshotSubHeader("Conditions"); + should.BeImmutable().AssertNoViolations(helper); - private class ImmutableClassWithoutMembers { } + helper.AddSnapshotSubHeader("Predicates"); + should.Be(Classes().That().AreImmutable()).AssertNoViolations(helper); - private class ImmutableClassWithoutPropertiesAndFields - { - private void Method() { } + helper.AddSnapshotHeader("Class with only static members (vacuously immutable)"); + should = Classes().That().Are(helper.ClassWithOnlyStaticMembers).Should(); + + helper.AddSnapshotSubHeader("Conditions"); + should.BeImmutable().AssertNoViolations(helper); + + helper.AddSnapshotSubHeader("Predicates"); + should.Be(Classes().That().AreImmutable()).AssertNoViolations(helper); + + await helper.AssertSnapshotMatches(); } - private class ImmutableClassWithOnlyStaticMembers + [Fact] + public async Task NotBeImmutableTest() { - private const string ConstField = "const"; -#pragma warning disable 0169 - private static string StaticField; -#pragma warning restore 0169 - public static string StaticProperty { get; set; } + var helper = new ClassAssemblyTestHelper(); + + helper.AddSnapshotHeader("No Violations"); + var should = Classes().That().Are(helper.MutableClass).Should(); + + helper.AddSnapshotSubHeader("Conditions"); + should.NotBeImmutable().AssertNoViolations(helper); + + helper.AddSnapshotSubHeader("Predicates"); + should.Be(Classes().That().AreNotImmutable()).AssertNoViolations(helper); + + helper.AddSnapshotHeader("Violations"); + should = Classes().That().Are(helper.ImmutableClass).Should(); + + helper.AddSnapshotSubHeader("Conditions"); + should.NotBeImmutable().AssertOnlyViolations(helper); + + helper.AddSnapshotSubHeader("Predicates"); + should.Be(Classes().That().AreNotImmutable()).AssertOnlyViolations(helper); + + helper.AddSnapshotHeader("Multiple inputs"); + Classes().That().Are(helper.MutableClass, helper.OtherMutableClass).Should().NotBeImmutable().AssertNoViolations(helper); + Classes().That().Are(helper.MutableClass, helper.ImmutableClass).Should().NotBeImmutable().AssertAnyViolations(helper); - private static void Method() { } + await helper.AssertSnapshotMatches(); } } } diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.BeAbstractTest.verified.txt b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.BeAbstractTest.verified.txt new file mode 100644 index 000000000..755b2cb57 --- /dev/null +++ b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.BeAbstractTest.verified.txt @@ -0,0 +1,63 @@ +===== No Violations ===== + +----- Conditions ----- + +Query: Classes that are "ClassNamespace.AbstractClass" should be abstract +Result: True +Description: ClassNamespace.AbstractClass passed +Message: +All Evaluations passed + +----- Predicates ----- + +Query: Classes that are "ClassNamespace.AbstractClass" should be Classes that are abstract +Result: True +Description: ClassNamespace.AbstractClass passed +Message: +All Evaluations passed + +===== Violations ===== + +----- Conditions ----- + +Query: Classes that are "ClassNamespace.RegularClass" should be abstract +Result: False +Description: ClassNamespace.RegularClass is not abstract +Message: +"Classes that are "ClassNamespace.RegularClass" should be abstract" failed: + ClassNamespace.RegularClass is not abstract + + + +----- Predicates ----- + +Query: Classes that are "ClassNamespace.RegularClass" should be Classes that are abstract +Result: False +Description: ClassNamespace.RegularClass is not Classes that are abstract +Message: +"Classes that are "ClassNamespace.RegularClass" should be Classes that are abstract" failed: + ClassNamespace.RegularClass is not Classes that are abstract + + + +===== Multiple inputs ===== + +Query: Classes that are "ClassNamespace.AbstractClass" or "ClassNamespace.OtherAbstractClass" should be abstract +Result: True +Description: ClassNamespace.AbstractClass passed +Result: True +Description: ClassNamespace.OtherAbstractClass passed +Message: +All Evaluations passed + +Query: Classes that are "ClassNamespace.AbstractClass" or "ClassNamespace.RegularClass" should be abstract +Result: False +Description: ClassNamespace.RegularClass is not abstract +Result: True +Description: ClassNamespace.AbstractClass passed +Message: +"Classes that are "ClassNamespace.AbstractClass" or "ClassNamespace.RegularClass" should be abstract" failed: + ClassNamespace.RegularClass is not abstract + + + diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.BeImmutableTest.verified.txt b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.BeImmutableTest.verified.txt new file mode 100644 index 000000000..91b4017bc --- /dev/null +++ b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.BeImmutableTest.verified.txt @@ -0,0 +1,99 @@ +===== No Violations ===== + +----- Conditions ----- + +Query: Classes that are "ClassNamespace.ImmutableClass" should be immutable +Result: True +Description: ClassNamespace.ImmutableClass passed +Message: +All Evaluations passed + +----- Predicates ----- + +Query: Classes that are "ClassNamespace.ImmutableClass" should be Classes that are immutable +Result: True +Description: ClassNamespace.ImmutableClass passed +Message: +All Evaluations passed + +===== Violations ===== + +----- Conditions ----- + +Query: Classes that are "ClassNamespace.MutableClass" should be immutable +Result: False +Description: ClassNamespace.MutableClass is not immutable +Message: +"Classes that are "ClassNamespace.MutableClass" should be immutable" failed: + ClassNamespace.MutableClass is not immutable + + + +----- Predicates ----- + +Query: Classes that are "ClassNamespace.MutableClass" should be Classes that are immutable +Result: False +Description: ClassNamespace.MutableClass is not Classes that are immutable +Message: +"Classes that are "ClassNamespace.MutableClass" should be Classes that are immutable" failed: + ClassNamespace.MutableClass is not Classes that are immutable + + + +===== Multiple inputs ===== + +Query: Classes that are "ClassNamespace.ImmutableClass" or "ClassNamespace.OtherImmutableClass" should be immutable +Result: True +Description: ClassNamespace.ImmutableClass passed +Result: True +Description: ClassNamespace.OtherImmutableClass passed +Message: +All Evaluations passed + +Query: Classes that are "ClassNamespace.ImmutableClass" or "ClassNamespace.MutableClass" should be immutable +Result: True +Description: ClassNamespace.ImmutableClass passed +Result: False +Description: ClassNamespace.MutableClass is not immutable +Message: +"Classes that are "ClassNamespace.ImmutableClass" or "ClassNamespace.MutableClass" should be immutable" failed: + ClassNamespace.MutableClass is not immutable + + + +===== Class without members (vacuously immutable) ===== + +----- Conditions ----- + +Query: Classes that are "ClassNamespace.ClassWithoutMembers" should be immutable +Result: True +Description: ClassNamespace.ClassWithoutMembers passed +Message: +All Evaluations passed + +----- Predicates ----- + +Query: Classes that are "ClassNamespace.ClassWithoutMembers" should be Classes that are immutable +Result: True +Description: ClassNamespace.ClassWithoutMembers passed +Message: +All Evaluations passed + +===== Class with only static members (vacuously immutable) ===== + +----- Conditions ----- + +Query: Classes that are "ClassNamespace.ClassWithOnlyStaticMembers" should be immutable +Result: True +Description: ClassNamespace.ClassWithOnlyStaticMembers passed +Message: +All Evaluations passed + +----- Predicates ----- + +Query: Classes that are "ClassNamespace.ClassWithOnlyStaticMembers" should be Classes that are immutable +Result: True +Description: ClassNamespace.ClassWithOnlyStaticMembers passed +Message: +All Evaluations passed + diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.BeRecordTest.verified.txt b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.BeRecordTest.verified.txt new file mode 100644 index 000000000..d60d7e2ff --- /dev/null +++ b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.BeRecordTest.verified.txt @@ -0,0 +1,63 @@ +===== No Violations ===== + +----- Conditions ----- + +Query: Classes that are "ClassNamespace.RecordClass" should be record +Result: True +Description: ClassNamespace.RecordClass passed +Message: +All Evaluations passed + +----- Predicates ----- + +Query: Classes that are "ClassNamespace.RecordClass" should be Classes that are record +Result: True +Description: ClassNamespace.RecordClass passed +Message: +All Evaluations passed + +===== Violations ===== + +----- Conditions ----- + +Query: Classes that are "ClassNamespace.RegularClass" should be record +Result: False +Description: ClassNamespace.RegularClass is not record +Message: +"Classes that are "ClassNamespace.RegularClass" should be record" failed: + ClassNamespace.RegularClass is not record + + + +----- Predicates ----- + +Query: Classes that are "ClassNamespace.RegularClass" should be Classes that are record +Result: False +Description: ClassNamespace.RegularClass is not Classes that are record +Message: +"Classes that are "ClassNamespace.RegularClass" should be Classes that are record" failed: + ClassNamespace.RegularClass is not Classes that are record + + + +===== Multiple inputs ===== + +Query: Classes that are "ClassNamespace.RecordClass" or "ClassNamespace.OtherRecordClass" should be record +Result: True +Description: ClassNamespace.RecordClass passed +Result: True +Description: ClassNamespace.OtherRecordClass passed +Message: +All Evaluations passed + +Query: Classes that are "ClassNamespace.RecordClass" or "ClassNamespace.RegularClass" should be record +Result: False +Description: ClassNamespace.RegularClass is not record +Result: True +Description: ClassNamespace.RecordClass passed +Message: +"Classes that are "ClassNamespace.RecordClass" or "ClassNamespace.RegularClass" should be record" failed: + ClassNamespace.RegularClass is not record + + + diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.BeSealedTest.verified.txt b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.BeSealedTest.verified.txt new file mode 100644 index 000000000..042a0b7eb --- /dev/null +++ b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.BeSealedTest.verified.txt @@ -0,0 +1,63 @@ +===== No Violations ===== + +----- Conditions ----- + +Query: Classes that are "ClassNamespace.SealedClass" should be sealed +Result: True +Description: ClassNamespace.SealedClass passed +Message: +All Evaluations passed + +----- Predicates ----- + +Query: Classes that are "ClassNamespace.SealedClass" should be Classes that are sealed +Result: True +Description: ClassNamespace.SealedClass passed +Message: +All Evaluations passed + +===== Violations ===== + +----- Conditions ----- + +Query: Classes that are "ClassNamespace.RegularClass" should be sealed +Result: False +Description: ClassNamespace.RegularClass is not sealed +Message: +"Classes that are "ClassNamespace.RegularClass" should be sealed" failed: + ClassNamespace.RegularClass is not sealed + + + +----- Predicates ----- + +Query: Classes that are "ClassNamespace.RegularClass" should be Classes that are sealed +Result: False +Description: ClassNamespace.RegularClass is not Classes that are sealed +Message: +"Classes that are "ClassNamespace.RegularClass" should be Classes that are sealed" failed: + ClassNamespace.RegularClass is not Classes that are sealed + + + +===== Multiple inputs ===== + +Query: Classes that are "ClassNamespace.SealedClass" or "ClassNamespace.OtherSealedClass" should be sealed +Result: True +Description: ClassNamespace.SealedClass passed +Result: True +Description: ClassNamespace.OtherSealedClass passed +Message: +All Evaluations passed + +Query: Classes that are "ClassNamespace.SealedClass" or "ClassNamespace.RegularClass" should be sealed +Result: False +Description: ClassNamespace.RegularClass is not sealed +Result: True +Description: ClassNamespace.SealedClass passed +Message: +"Classes that are "ClassNamespace.SealedClass" or "ClassNamespace.RegularClass" should be sealed" failed: + ClassNamespace.RegularClass is not sealed + + + diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.NotBeAbstractTest.verified.txt b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.NotBeAbstractTest.verified.txt new file mode 100644 index 000000000..58a2dbef7 --- /dev/null +++ b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.NotBeAbstractTest.verified.txt @@ -0,0 +1,63 @@ +===== No Violations ===== + +----- Conditions ----- + +Query: Classes that are "ClassNamespace.RegularClass" should not be abstract +Result: True +Description: ClassNamespace.RegularClass passed +Message: +All Evaluations passed + +----- Predicates ----- + +Query: Classes that are "ClassNamespace.RegularClass" should be Classes that are not abstract +Result: True +Description: ClassNamespace.RegularClass passed +Message: +All Evaluations passed + +===== Violations ===== + +----- Conditions ----- + +Query: Classes that are "ClassNamespace.AbstractClass" should not be abstract +Result: False +Description: ClassNamespace.AbstractClass is abstract +Message: +"Classes that are "ClassNamespace.AbstractClass" should not be abstract" failed: + ClassNamespace.AbstractClass is abstract + + + +----- Predicates ----- + +Query: Classes that are "ClassNamespace.AbstractClass" should be Classes that are not abstract +Result: False +Description: ClassNamespace.AbstractClass is not Classes that are not abstract +Message: +"Classes that are "ClassNamespace.AbstractClass" should be Classes that are not abstract" failed: + ClassNamespace.AbstractClass is not Classes that are not abstract + + + +===== Multiple inputs ===== + +Query: Classes that are "ClassNamespace.RegularClass" or "ClassNamespace.OtherRegularClass" should not be abstract +Result: True +Description: ClassNamespace.RegularClass passed +Result: True +Description: ClassNamespace.OtherRegularClass passed +Message: +All Evaluations passed + +Query: Classes that are "ClassNamespace.RegularClass" or "ClassNamespace.AbstractClass" should not be abstract +Result: True +Description: ClassNamespace.RegularClass passed +Result: False +Description: ClassNamespace.AbstractClass is abstract +Message: +"Classes that are "ClassNamespace.RegularClass" or "ClassNamespace.AbstractClass" should not be abstract" failed: + ClassNamespace.AbstractClass is abstract + + + diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.NotBeImmutableTest.verified.txt b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.NotBeImmutableTest.verified.txt new file mode 100644 index 000000000..d7df91429 --- /dev/null +++ b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.NotBeImmutableTest.verified.txt @@ -0,0 +1,63 @@ +===== No Violations ===== + +----- Conditions ----- + +Query: Classes that are "ClassNamespace.MutableClass" should not be immutable +Result: True +Description: ClassNamespace.MutableClass passed +Message: +All Evaluations passed + +----- Predicates ----- + +Query: Classes that are "ClassNamespace.MutableClass" should be Classes that are not immutable +Result: True +Description: ClassNamespace.MutableClass passed +Message: +All Evaluations passed + +===== Violations ===== + +----- Conditions ----- + +Query: Classes that are "ClassNamespace.ImmutableClass" should not be immutable +Result: False +Description: ClassNamespace.ImmutableClass is immutable +Message: +"Classes that are "ClassNamespace.ImmutableClass" should not be immutable" failed: + ClassNamespace.ImmutableClass is immutable + + + +----- Predicates ----- + +Query: Classes that are "ClassNamespace.ImmutableClass" should be Classes that are not immutable +Result: False +Description: ClassNamespace.ImmutableClass is not Classes that are not immutable +Message: +"Classes that are "ClassNamespace.ImmutableClass" should be Classes that are not immutable" failed: + ClassNamespace.ImmutableClass is not Classes that are not immutable + + + +===== Multiple inputs ===== + +Query: Classes that are "ClassNamespace.MutableClass" or "ClassNamespace.OtherMutableClass" should not be immutable +Result: True +Description: ClassNamespace.MutableClass passed +Result: True +Description: ClassNamespace.OtherMutableClass passed +Message: +All Evaluations passed + +Query: Classes that are "ClassNamespace.MutableClass" or "ClassNamespace.ImmutableClass" should not be immutable +Result: False +Description: ClassNamespace.ImmutableClass is immutable +Result: True +Description: ClassNamespace.MutableClass passed +Message: +"Classes that are "ClassNamespace.MutableClass" or "ClassNamespace.ImmutableClass" should not be immutable" failed: + ClassNamespace.ImmutableClass is immutable + + + diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.NotBeRecordTest.verified.txt b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.NotBeRecordTest.verified.txt new file mode 100644 index 000000000..d17b4a38e --- /dev/null +++ b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.NotBeRecordTest.verified.txt @@ -0,0 +1,63 @@ +===== No Violations ===== + +----- Conditions ----- + +Query: Classes that are "ClassNamespace.RegularClass" should not be record +Result: True +Description: ClassNamespace.RegularClass passed +Message: +All Evaluations passed + +----- Predicates ----- + +Query: Classes that are "ClassNamespace.RegularClass" should be Classes that are not record +Result: True +Description: ClassNamespace.RegularClass passed +Message: +All Evaluations passed + +===== Violations ===== + +----- Conditions ----- + +Query: Classes that are "ClassNamespace.RecordClass" should not be record +Result: False +Description: ClassNamespace.RecordClass is record +Message: +"Classes that are "ClassNamespace.RecordClass" should not be record" failed: + ClassNamespace.RecordClass is record + + + +----- Predicates ----- + +Query: Classes that are "ClassNamespace.RecordClass" should be Classes that are not record +Result: False +Description: ClassNamespace.RecordClass is not Classes that are not record +Message: +"Classes that are "ClassNamespace.RecordClass" should be Classes that are not record" failed: + ClassNamespace.RecordClass is not Classes that are not record + + + +===== Multiple inputs ===== + +Query: Classes that are "ClassNamespace.RegularClass" or "ClassNamespace.OtherRegularClass" should not be record +Result: True +Description: ClassNamespace.RegularClass passed +Result: True +Description: ClassNamespace.OtherRegularClass passed +Message: +All Evaluations passed + +Query: Classes that are "ClassNamespace.RegularClass" or "ClassNamespace.RecordClass" should not be record +Result: True +Description: ClassNamespace.RegularClass passed +Result: False +Description: ClassNamespace.RecordClass is record +Message: +"Classes that are "ClassNamespace.RegularClass" or "ClassNamespace.RecordClass" should not be record" failed: + ClassNamespace.RecordClass is record + + + diff --git a/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.NotBeSealedTest.verified.txt b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.NotBeSealedTest.verified.txt new file mode 100644 index 000000000..5ee883d33 --- /dev/null +++ b/ArchUnitNETTests/Fluent/Syntax/Elements/Snapshots/ClassSyntaxElementsTests.NotBeSealedTest.verified.txt @@ -0,0 +1,63 @@ +===== No Violations ===== + +----- Conditions ----- + +Query: Classes that are "ClassNamespace.RegularClass" should not be sealed +Result: True +Description: ClassNamespace.RegularClass passed +Message: +All Evaluations passed + +----- Predicates ----- + +Query: Classes that are "ClassNamespace.RegularClass" should be Classes that are not sealed +Result: True +Description: ClassNamespace.RegularClass passed +Message: +All Evaluations passed + +===== Violations ===== + +----- Conditions ----- + +Query: Classes that are "ClassNamespace.SealedClass" should not be sealed +Result: False +Description: ClassNamespace.SealedClass is sealed +Message: +"Classes that are "ClassNamespace.SealedClass" should not be sealed" failed: + ClassNamespace.SealedClass is sealed + + + +----- Predicates ----- + +Query: Classes that are "ClassNamespace.SealedClass" should be Classes that are not sealed +Result: False +Description: ClassNamespace.SealedClass is not Classes that are not sealed +Message: +"Classes that are "ClassNamespace.SealedClass" should be Classes that are not sealed" failed: + ClassNamespace.SealedClass is not Classes that are not sealed + + + +===== Multiple inputs ===== + +Query: Classes that are "ClassNamespace.RegularClass" or "ClassNamespace.OtherRegularClass" should not be sealed +Result: True +Description: ClassNamespace.RegularClass passed +Result: True +Description: ClassNamespace.OtherRegularClass passed +Message: +All Evaluations passed + +Query: Classes that are "ClassNamespace.RegularClass" or "ClassNamespace.SealedClass" should not be sealed +Result: True +Description: ClassNamespace.RegularClass passed +Result: False +Description: ClassNamespace.SealedClass is sealed +Message: +"Classes that are "ClassNamespace.RegularClass" or "ClassNamespace.SealedClass" should not be sealed" failed: + ClassNamespace.SealedClass is sealed + + + diff --git a/ArchUnitNETTests/StaticTestArchitectures.cs b/ArchUnitNETTests/StaticTestArchitectures.cs index fdfe02d69..e4f871bcb 100644 --- a/ArchUnitNETTests/StaticTestArchitectures.cs +++ b/ArchUnitNETTests/StaticTestArchitectures.cs @@ -75,6 +75,12 @@ public static class StaticTestArchitectures .LoadAssemblies(typeof(PropertyMemberNamespace.ClassWithWritableProperty).Assembly) .Build(); + public static readonly Architecture ClassArchitecture = new ArchLoader() + .WithoutRuleEvaluationCache() + .WithoutArchitectureCache() + .LoadAssemblies(typeof(ClassNamespace.RegularClass).Assembly) + .Build(); + public static readonly Architecture ArchUnitNETTestAssemblyArchitecture = new ArchLoader() .LoadAssemblies(typeof(Class1).Assembly) .Build(); diff --git a/TestAssemblies/ClassAssembly/ClassAssembly.csproj b/TestAssemblies/ClassAssembly/ClassAssembly.csproj new file mode 100644 index 000000000..51fae4aaa --- /dev/null +++ b/TestAssemblies/ClassAssembly/ClassAssembly.csproj @@ -0,0 +1,12 @@ + + + net10.0 + enable + enable + true + false + True + ..\..\strongNameKey.snk + 1.0.0.0 + + diff --git a/TestAssemblies/ClassAssembly/ClassAssemblyClasses.cs b/TestAssemblies/ClassAssembly/ClassAssemblyClasses.cs new file mode 100644 index 000000000..0b1deb786 --- /dev/null +++ b/TestAssemblies/ClassAssembly/ClassAssemblyClasses.cs @@ -0,0 +1,47 @@ +namespace ClassNamespace; + +// Baseline (not abstract, not sealed, not a record) +public class RegularClass { } + +public class OtherRegularClass { } + +public abstract class AbstractClass { } + +public abstract class OtherAbstractClass { } + +public sealed class SealedClass { } + +public sealed class OtherSealedClass { } + +public record RecordClass { } + +public record OtherRecordClass { } + +public class ImmutableClass +{ + public readonly string Field = ""; + public string Property { get; } = ""; +} + +public class OtherImmutableClass +{ + public readonly string OtherField = ""; + public string OtherProperty { get; } = ""; +} + +public class MutableClass +{ + public string Property { get; set; } = ""; +} + +public class OtherMutableClass +{ + public string OtherProperty { get; set; } = ""; +} + +public class ClassWithoutMembers { } + +public class ClassWithOnlyStaticMembers +{ + public static string StaticProperty { get; set; } = ""; +}