ArchUnitNET/ExampleTest/LimitationsOnReleaseTest.cs at type-syntax-elements-tests · TNG/ArchUnitNET · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
using System.Linq;
using System.Threading.Tasks;
using ArchUnitNET.Domain;
using ArchUnitNET.Domain.Extensions;
using ArchUnitNET.Loader;
using ArchUnitNET.xUnit;
using Xunit;
using static ArchUnitNET.Fluent.ArchRuleDefinition;

namespace ExampleTest
{
    public class LimitationsOnReleaseTest
    {
        private static readonly Architecture Architecture = new ArchLoader()
            .LoadAssembly(typeof(LimitationsOnReleaseTest).Assembly)
            .Build();

        private static IType _edgeCaseDataClass = Architecture.GetClassOfType(typeof(EdgeCaseData));
        private static IType _missingDependencyClass = Architecture.GetClassOfType(
            typeof(MissingDependencyClass)
        );

        [Fact]
        public void CastTest()
        {
            var typeDependencies = _edgeCaseDataClass
                .Members.Where(t =>
                    t.FullName.Contains(nameof(EdgeCaseData.MethodWithCastDependency))
                )
                .ToList()
                .First()
                .GetTypeDependencies()
                .ToList();

            Assert.Contains(_missingDependencyClass, typeDependencies);
        }

        [Fact]
        public void NullVariableTest()
        {
            var methodWithCastDependencyDependencies = _edgeCaseDataClass
                .Members.Where(t =>
                    t.FullName.Contains(nameof(EdgeCaseData.MethodWithNullVariable))
                )
                .ToList()
                .First()
                .GetTypeDependencies()
                .ToList();

            Assert.Contains(_missingDependencyClass, methodWithCastDependencyDependencies);
        }

        [Fact]
        public void TypeOfDependencyTest()
        {
            var methodWithTypeOfDependencyDependencies = _edgeCaseDataClass
                .Members.Where(t =>
                    t.FullName.Contains(nameof(EdgeCaseData.MethodWithTypeOfDependency))
                )
                .ToList()
                .First()
                .GetTypeDependencies()
                .ToList();

            Assert.Contains(_missingDependencyClass, methodWithTypeOfDependencyDependencies);
        }

        [Fact]
        public void AsyncMethodDependencyTest()
        {
            Classes()
                .That()
                .Are(typeof(AsyncUser))
                .Should()
                .CallAny(MethodMembers().That().HaveName("MethodAsync()"))
                .Check(Architecture);
        }
    }

#pragma warning disable 219
    internal class EdgeCaseData
    {
        public void MethodWithTypeOfDependency()
        {
            var a = typeof(MissingDependencyClass);
        }

        public void MethodWithCastDependency()
        {
            var a = (MissingDependencyClass)new SubClass();
        }

        public void MethodWithNullVariable()
        {
            MissingDependencyClass a = null;
        }
    }

    internal class MissingDependencyClass { }

    internal class SubClass : MissingDependencyClass { }

    internal class AsyncService
    {
        public async Task MethodAsync()
        {
            await Task.Delay(100);
        }
    }

    internal class AsyncUser
    {
        private readonly AsyncService _asyncService = new AsyncService();

        public async Task UseAsyncService()
        {
            await _asyncService.MethodAsync();
        }
    }
}
#pragma warning restore 219