ServiceControl/src/ServiceControl.Persistence.Tests/MonitoringDataStoreTests.cs at 5ace667954eb3951f23a3d8dccc9ad8966556b07 · Particular/ServiceControl · 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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
namespace ServiceControl.Persistence.Tests
{
    using System;
    using System.Linq;
    using System.Threading.Tasks;
    using Microsoft.Extensions.Logging.Abstractions;
    using NUnit.Framework;
    using ServiceControl.Monitoring;
    using ServiceControl.Operations;
    using ServiceControl.Persistence;

    class MonitoringDataStoreTests : PersistenceTestBase
    {
        [Test]
        public async Task Endpoints_load_from_dataStore_into_monitor()
        {
            var endpointInstanceMonitoring = new EndpointInstanceMonitoring(new FakeDomainEvents(), NullLogger<EndpointInstanceMonitor>.Instance);
            var endpoint1 = new EndpointDetails() { HostId = Guid.NewGuid(), Host = "Host1", Name = "Name1" };
            await MonitoringDataStore.CreateIfNotExists(endpoint1);

            CompleteDatabaseOperation();
            await MonitoringDataStore.WarmupMonitoringFromPersistence(endpointInstanceMonitoring);

            Assert.That(endpointInstanceMonitoring.GetKnownEndpoints().Count(w => w.HostDisplayName == endpoint1.Host), Is.EqualTo(1));
        }

        [Test]
        public async Task Endpoints_added_more_than_once_are_treated_as_same_endpoint()
        {
            var endpointInstanceMonitoring = new EndpointInstanceMonitoring(new FakeDomainEvents(), NullLogger<EndpointInstanceMonitor>.Instance);
            var endpoint1 = new EndpointDetails() { HostId = Guid.NewGuid(), Host = "Host1", Name = "Name1" };
            await MonitoringDataStore.CreateIfNotExists(endpoint1);
            await MonitoringDataStore.CreateIfNotExists(endpoint1);

            CompleteDatabaseOperation();
            await MonitoringDataStore.WarmupMonitoringFromPersistence(endpointInstanceMonitoring);

            Assert.That(endpointInstanceMonitoring.GetKnownEndpoints().Count(w => w.HostDisplayName == endpoint1.Host), Is.EqualTo(1));
        }

        [Test]
        public async Task Updating_existing_endpoint_does_not_create_new_ones()
        {
            var endpointInstanceMonitoring = new EndpointInstanceMonitoring(new FakeDomainEvents(), NullLogger<EndpointInstanceMonitor>.Instance);
            var endpoint1 = new EndpointDetails() { HostId = Guid.NewGuid(), Host = "Host1", Name = "Name1" };
            await MonitoringDataStore.CreateIfNotExists(endpoint1);
            await MonitoringDataStore.CreateOrUpdate(endpoint1, endpointInstanceMonitoring);

            CompleteDatabaseOperation();
            await MonitoringDataStore.WarmupMonitoringFromPersistence(endpointInstanceMonitoring);

            Assert.That(endpointInstanceMonitoring.GetKnownEndpoints().Count(w => w.HostDisplayName == endpoint1.Host), Is.EqualTo(1));
        }

        [Test]
        public async Task Endpoint_is_created_if_doesnt_exist()
        {
            var endpointInstanceMonitoring = new EndpointInstanceMonitoring(new FakeDomainEvents(), NullLogger<EndpointInstanceMonitor>.Instance);
            var endpoint1 = new EndpointDetails() { HostId = Guid.NewGuid(), Host = "Host1", Name = "Name1" };
            var endpoint2 = new EndpointDetails() { HostId = Guid.NewGuid(), Host = "Host2", Name = "Name2" };
            await MonitoringDataStore.CreateIfNotExists(endpoint1);
            await MonitoringDataStore.CreateIfNotExists(endpoint2);

            CompleteDatabaseOperation();
            await MonitoringDataStore.WarmupMonitoringFromPersistence(endpointInstanceMonitoring);

            Assert.That(endpointInstanceMonitoring.GetKnownEndpoints().Count(w => w.HostDisplayName == endpoint1.Host || w.HostDisplayName == endpoint2.Host), Is.EqualTo(2));
        }

        [Test]
        public async Task Endpoint_is_created_if_doesnt_exist_on_update()
        {
            var endpointInstanceMonitoring = new EndpointInstanceMonitoring(new FakeDomainEvents(), NullLogger<EndpointInstanceMonitor>.Instance);
            var endpoint1 = new EndpointDetails() { HostId = Guid.NewGuid(), Host = "Host1", Name = "Name1" };
            var endpoint2 = new EndpointDetails() { HostId = Guid.NewGuid(), Host = "Host2", Name = "Name2" };
            await MonitoringDataStore.CreateIfNotExists(endpoint1);
            await MonitoringDataStore.CreateOrUpdate(endpoint2, endpointInstanceMonitoring);

            CompleteDatabaseOperation();
            await MonitoringDataStore.WarmupMonitoringFromPersistence(endpointInstanceMonitoring);

            Assert.That(endpointInstanceMonitoring.GetKnownEndpoints().Count(w => w.HostDisplayName == endpoint1.Host || w.HostDisplayName == endpoint2.Host), Is.EqualTo(2));
        }

        [Test]
        public async Task Endpoint_is_updated()
        {
            var endpointInstanceMonitoring = new EndpointInstanceMonitoring(new FakeDomainEvents(), NullLogger<EndpointInstanceMonitor>.Instance);
            var endpoint1 = new EndpointDetails() { HostId = Guid.NewGuid(), Host = "Host1", Name = "Name1" };
            await MonitoringDataStore.CreateIfNotExists(endpoint1);

            CompleteDatabaseOperation();
            await MonitoringDataStore.WarmupMonitoringFromPersistence(endpointInstanceMonitoring);
            Assert.That(endpointInstanceMonitoring.IsMonitored(endpointInstanceMonitoring.GetEndpoints()[0].Id), Is.False);

            await MonitoringDataStore.UpdateEndpointMonitoring(endpoint1, true);
            endpointInstanceMonitoring = new EndpointInstanceMonitoring(new FakeDomainEvents(), NullLogger<EndpointInstanceMonitor>.Instance);

            CompleteDatabaseOperation();
            await MonitoringDataStore.WarmupMonitoringFromPersistence(endpointInstanceMonitoring);
            Assert.That(endpointInstanceMonitoring.IsMonitored(endpointInstanceMonitoring.GetEndpoints()[0].Id), Is.True);
        }


        [Test]
        public async Task Endpoint_is_deleted()
        {
            var endpointInstanceMonitoring = new EndpointInstanceMonitoring(new FakeDomainEvents(), NullLogger<EndpointInstanceMonitor>.Instance);
            var endpoint1 = new EndpointDetails() { HostId = Guid.NewGuid(), Host = "Host1", Name = "Name1" };
            await MonitoringDataStore.CreateIfNotExists(endpoint1);

            CompleteDatabaseOperation();
            await MonitoringDataStore.WarmupMonitoringFromPersistence(endpointInstanceMonitoring);
            Assert.That(endpointInstanceMonitoring.GetKnownEndpoints().Count(w => w.HostDisplayName == endpoint1.Host), Is.EqualTo(1));

            await MonitoringDataStore.Delete(endpointInstanceMonitoring.GetEndpoints()[0].Id);

            endpointInstanceMonitoring = new EndpointInstanceMonitoring(new FakeDomainEvents(), NullLogger<EndpointInstanceMonitor>.Instance);

            CompleteDatabaseOperation();
            await MonitoringDataStore.WarmupMonitoringFromPersistence(endpointInstanceMonitoring);
            Assert.That(endpointInstanceMonitoring.GetKnownEndpoints().Count(w => w.HostDisplayName == endpoint1.Host), Is.EqualTo(0));
        }

        [Test]
        public async Task Unit_of_work_detects_endpoint()
        {
            var knownEndpoint = new KnownEndpoint
            {
                HostDisplayName = "Host1",
                EndpointDetails = new EndpointDetails { Host = "Host1", HostId = Guid.NewGuid(), Name = "Endpoint" }
            };

            using (var unitOfWork = await UnitOfWorkFactory.StartNew())
            {
                await unitOfWork.Monitoring.RecordKnownEndpoint(knownEndpoint);

                await unitOfWork.Complete(TestContext.CurrentContext.CancellationToken);
            }

            CompleteDatabaseOperation();

            var knownEndpoints = await MonitoringDataStore.GetAllKnownEndpoints();

            Assert.That(knownEndpoints, Has.Count.EqualTo(1));
            var fromStorage = knownEndpoints[0];

            Assert.Multiple(() =>
            {
                Assert.That(fromStorage.EndpointDetails.Host, Is.EqualTo(knownEndpoint.EndpointDetails.Host), "EndpointDetails.Host should match");
                Assert.That(fromStorage.EndpointDetails.HostId, Is.EqualTo(knownEndpoint.EndpointDetails.HostId), "EndpointDetails.HostId should match");
                Assert.That(fromStorage.EndpointDetails.Name, Is.EqualTo(knownEndpoint.EndpointDetails.Name), "EndpointDetails.Name should match");
                Assert.That(fromStorage.Monitored, Is.EqualTo(knownEndpoint.Monitored), "Monitored should match");
            });
        }
    }
}