307 lines
14 KiB
C#
307 lines
14 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
|
|
namespace BizTalkCheckmkPulse.Tests
|
|
{
|
|
internal static class Program
|
|
{
|
|
private static readonly List<string> Failures = new List<string>();
|
|
private static int ExecutedTests;
|
|
|
|
private static int Main()
|
|
{
|
|
Run("SelfTestEmitsAllStableServices", SelfTestEmitsAllStableServices);
|
|
Run("UnavailableSourcesAreUnknown", UnavailableSourcesAreUnknown);
|
|
Run("UnknownApplicationDoesNotCreateService", UnknownApplicationDoesNotCreateService);
|
|
Run("KnownApplicationCreatesService", KnownApplicationCreatesService);
|
|
Run("ServerNamesAreComparedWithoutWql", ServerNamesAreComparedWithoutWql);
|
|
Run("GroupSettingQueryUsesDocumentedSchema", GroupSettingQueryUsesDocumentedSchema);
|
|
Run("ProviderSqlLoginFailureIsPermission", ProviderSqlLoginFailureIsPermission);
|
|
Run("RejectedSqlPrincipalIsExtracted", RejectedSqlPrincipalIsExtracted);
|
|
Run("PlatformPermissionPropagatesToSqlDiscovery", PlatformPermissionPropagatesToSqlDiscovery);
|
|
Run("SnapshotRoundTripPreservesLines", SnapshotRoundTripPreservesLines);
|
|
Run("SnapshotRejectsTampering", SnapshotRejectsTampering);
|
|
Run("SnapshotRejectsStaleData", SnapshotRejectsStaleData);
|
|
Run("SnapshotRejectsDifferentMachine", SnapshotRejectsDifferentMachine);
|
|
Run("SnapshotReportsMissingFile", SnapshotReportsMissingFile);
|
|
Run("SnapshotFailureEmitsStableUnknownServices", SnapshotFailureEmitsStableUnknownServices);
|
|
|
|
if (Failures.Count == 0)
|
|
{
|
|
Console.WriteLine("PASS: " + ExecutedTests + " tests");
|
|
return 0;
|
|
}
|
|
|
|
foreach (var failure in Failures)
|
|
{
|
|
Console.Error.WriteLine("FAIL: " + failure);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
private static void SelfTestEmitsAllStableServices()
|
|
{
|
|
var lines = new CheckmkLocalFormatter(new MonitoringOptions()).FormatSelfTest().ToArray();
|
|
AssertEqual(6, lines.Length, "self-test line count");
|
|
AssertEqual(6, lines.Distinct(StringComparer.Ordinal).Count(), "unique self-test lines");
|
|
Assert(lines.All(x => x.StartsWith("0 \"BizTalk ", StringComparison.Ordinal)), "every self-test line must be OK");
|
|
Assert(lines.Any(x => x.Contains("\"BizTalk Event Log\"")), "Event Log service missing");
|
|
}
|
|
|
|
private static void UnavailableSourcesAreUnknown()
|
|
{
|
|
var lines = new CheckmkLocalFormatter(new MonitoringOptions()).Format(new ProbeResult()).Take(6).ToArray();
|
|
AssertEqual(6, lines.Length, "stable service count");
|
|
Assert(lines.All(x => x.StartsWith("3 \"BizTalk ", StringComparison.Ordinal)), "unavailable sources must be UNKNOWN");
|
|
}
|
|
|
|
private static void UnknownApplicationDoesNotCreateService()
|
|
{
|
|
var options = new MonitoringOptions { EmitPerApplicationSuspensionServices = true };
|
|
var result = CreateSuspensionResult("(unknown)");
|
|
var lines = new CheckmkLocalFormatter(options).Format(result).ToArray();
|
|
AssertEqual(6, lines.Length, "unknown application must not create a dynamic service");
|
|
}
|
|
|
|
private static void KnownApplicationCreatesService()
|
|
{
|
|
var options = new MonitoringOptions { EmitPerApplicationSuspensionServices = true };
|
|
var result = CreateSuspensionResult("Orders");
|
|
var lines = new CheckmkLocalFormatter(options).Format(result).ToArray();
|
|
AssertEqual(7, lines.Length, "known application should create one dynamic service");
|
|
Assert(lines.Any(x => x.Contains("\"BizTalk Suspended Orders\"")), "known application service missing");
|
|
}
|
|
|
|
private static void ServerNamesAreComparedWithoutWql()
|
|
{
|
|
Assert(WmiBizTalkProbe.IsSameServer("BIZTALK01.corp.example", "biztalk01"), "FQDN and short name must match");
|
|
Assert(WmiBizTalkProbe.IsSameServer(@"\\BIZ-TALK+01", "biz-talk+01.example"), "special characters must be compared client-side");
|
|
Assert(!WmiBizTalkProbe.IsSameServer("BIZTALK01", "BIZTALK02"), "different servers must not match");
|
|
}
|
|
|
|
private static void GroupSettingQueryUsesDocumentedSchema()
|
|
{
|
|
var query = WmiBizTalkProbe.GroupSettingQuery;
|
|
Assert(query.Contains("FROM MSBTS_GroupSetting"), "MSBTS_GroupSetting query missing");
|
|
Assert(query.Contains("BizTalkOperatorGroup"), "configured operator group property missing");
|
|
Assert(query.Contains("BizTalkReadOnlyUserGroup"), "configured read-only group property missing");
|
|
Assert(query.Contains("SubscriptionDBServerName"), "master MessageBox server property missing");
|
|
Assert(query.Contains("SubscriptionDBName"), "master MessageBox database property missing");
|
|
Assert(query.IndexOf("MessageBoxSetting", StringComparison.OrdinalIgnoreCase) < 0, "unsupported MessageBoxSetting class present");
|
|
}
|
|
|
|
private static void ProviderSqlLoginFailureIsPermission()
|
|
{
|
|
var exception = new COMException(
|
|
"Internal error from OLEDB provider: 'Login failed for user 'BEW\\AV23AGPWBIO1$'.'",
|
|
unchecked((int)0x80131904));
|
|
AssertEqual(
|
|
DiagnosticCategory.Permission,
|
|
WmiBizTalkProbe.ClassifyWmiException(exception),
|
|
"provider SQL login classification");
|
|
}
|
|
|
|
private static void RejectedSqlPrincipalIsExtracted()
|
|
{
|
|
var message = "Internal error from OLEDB provider: 'Login failed for user 'BEW\\AV23AGPWBIO1$'.'";
|
|
AssertEqual(
|
|
"BEW\\AV23AGPWBIO1$",
|
|
WmiBizTalkProbe.ExtractSqlLoginPrincipal(message),
|
|
"rejected SQL principal");
|
|
}
|
|
|
|
private static void PlatformPermissionPropagatesToSqlDiscovery()
|
|
{
|
|
var result = new ProbeResult();
|
|
result.Diagnostics.Add(new ProbeDiagnostic
|
|
{
|
|
Area = DiagnosticArea.Wmi,
|
|
Category = DiagnosticCategory.Permission,
|
|
Component = "MSBTS_GroupSetting",
|
|
Required = true
|
|
});
|
|
|
|
new SqlConnectivityProbe(new MonitoringOptions()).Query(result);
|
|
|
|
var discovery = result.Diagnostics.Single(x =>
|
|
x.Area == DiagnosticArea.Sql
|
|
&& x.Component == "BizTalk database discovery");
|
|
AssertEqual(
|
|
DiagnosticCategory.Permission,
|
|
discovery.Category,
|
|
"SQL discovery classification");
|
|
}
|
|
|
|
private static void SnapshotRoundTripPreservesLines()
|
|
{
|
|
WithTemporarySnapshot((path, store) =>
|
|
{
|
|
var lines = new CheckmkLocalFormatter(new MonitoringOptions()).FormatSelfTest().ToArray();
|
|
var generated = DateTime.UtcNow;
|
|
store.Write(lines, generated, "DOMAIN\\collector$");
|
|
var result = store.Read(generated.AddSeconds(10), TimeSpan.FromMinutes(3));
|
|
|
|
Assert(result.IsSuccess, "snapshot should be readable: " + result.Error);
|
|
AssertEqual(lines.Length, result.Lines.Count, "snapshot line count");
|
|
Assert(lines.SequenceEqual(result.Lines), "snapshot payload changed");
|
|
|
|
var replacement = lines.Select(x => x.Replace("Self test OK", "Replacement OK")).ToArray();
|
|
store.Write(replacement, generated.AddSeconds(30), "DOMAIN\\collector$");
|
|
var replaced = store.Read(generated.AddSeconds(40), TimeSpan.FromMinutes(3));
|
|
Assert(replaced.IsSuccess, "replaced snapshot should be readable");
|
|
Assert(replacement.SequenceEqual(replaced.Lines), "atomic replacement payload changed");
|
|
});
|
|
}
|
|
|
|
private static void SnapshotRejectsTampering()
|
|
{
|
|
WithTemporarySnapshot((path, store) =>
|
|
{
|
|
var lines = new CheckmkLocalFormatter(new MonitoringOptions()).FormatSelfTest().ToArray();
|
|
store.Write(lines, DateTime.UtcNow, "DOMAIN\\collector$");
|
|
var content = File.ReadAllText(path, Encoding.UTF8);
|
|
File.WriteAllText(path, content.Replace("Self test OK", "Tampered output"), new UTF8Encoding(false));
|
|
|
|
var result = store.Read(DateTime.UtcNow, TimeSpan.FromMinutes(3));
|
|
Assert(!result.IsSuccess, "tampered snapshot must be rejected");
|
|
Assert(result.Error.IndexOf("SHA-256", StringComparison.OrdinalIgnoreCase) >= 0, "tamper reason should mention SHA-256");
|
|
});
|
|
}
|
|
|
|
private static void SnapshotRejectsStaleData()
|
|
{
|
|
WithTemporarySnapshot((path, store) =>
|
|
{
|
|
var lines = new CheckmkLocalFormatter(new MonitoringOptions()).FormatSelfTest().ToArray();
|
|
var generated = DateTime.UtcNow.AddMinutes(-10);
|
|
store.Write(lines, generated, "DOMAIN\\collector$");
|
|
|
|
var result = store.Read(DateTime.UtcNow, TimeSpan.FromMinutes(3));
|
|
Assert(!result.IsSuccess, "stale snapshot must be rejected");
|
|
Assert(result.Error.IndexOf("stale", StringComparison.OrdinalIgnoreCase) >= 0, "stale reason missing");
|
|
});
|
|
}
|
|
|
|
private static void SnapshotRejectsDifferentMachine()
|
|
{
|
|
WithTemporarySnapshot((path, store) =>
|
|
{
|
|
var lines = new CheckmkLocalFormatter(new MonitoringOptions()).FormatSelfTest().ToArray();
|
|
store.Write(lines, DateTime.UtcNow, "DOMAIN\\collector$");
|
|
var content = File.ReadAllText(path, Encoding.UTF8);
|
|
var currentMachine = Convert.ToBase64String(Encoding.UTF8.GetBytes(Environment.MachineName));
|
|
var otherMachine = Convert.ToBase64String(Encoding.UTF8.GetBytes("OTHER-SERVER"));
|
|
File.WriteAllText(
|
|
path,
|
|
content.Replace("machineBase64=" + currentMachine, "machineBase64=" + otherMachine),
|
|
new UTF8Encoding(false));
|
|
|
|
var result = store.Read(DateTime.UtcNow, TimeSpan.FromMinutes(3));
|
|
Assert(!result.IsSuccess, "snapshot for another machine must be rejected");
|
|
Assert(result.Error.IndexOf("different machine", StringComparison.OrdinalIgnoreCase) >= 0, "machine mismatch reason missing");
|
|
});
|
|
}
|
|
|
|
private static void SnapshotReportsMissingFile()
|
|
{
|
|
WithTemporarySnapshot((path, store) =>
|
|
{
|
|
var result = store.Read(DateTime.UtcNow, TimeSpan.FromMinutes(3));
|
|
Assert(!result.IsSuccess, "missing snapshot must be rejected");
|
|
Assert(result.Error.IndexOf("does not exist", StringComparison.OrdinalIgnoreCase) >= 0, "missing file reason missing");
|
|
});
|
|
}
|
|
|
|
private static void SnapshotFailureEmitsStableUnknownServices()
|
|
{
|
|
var lines = new CheckmkLocalFormatter(new MonitoringOptions())
|
|
.FormatSnapshotFailure("Snapshot file does not exist.")
|
|
.ToArray();
|
|
AssertEqual(6, lines.Length, "snapshot failure stable service count");
|
|
Assert(lines.All(x => x.StartsWith("3 \"BizTalk ", StringComparison.Ordinal)), "snapshot failure must be UNKNOWN");
|
|
Assert(lines.All(x => x.Contains("Scheduled Task")), "snapshot failure must contain provider action");
|
|
}
|
|
|
|
private static void WithTemporarySnapshot(Action<string, SnapshotStore> test)
|
|
{
|
|
var directory = Path.Combine(Path.GetTempPath(), "BizTalkCheckmkPulse.Tests." + Guid.NewGuid().ToString("N"));
|
|
Directory.CreateDirectory(directory);
|
|
var path = Path.Combine(directory, "snapshot.txt");
|
|
try
|
|
{
|
|
test(path, new SnapshotStore(path, 1048576));
|
|
}
|
|
finally
|
|
{
|
|
if (Directory.Exists(directory))
|
|
{
|
|
Directory.Delete(directory, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static ProbeResult CreateSuspensionResult(string applicationName)
|
|
{
|
|
var result = new ProbeResult();
|
|
result.Platform.SuspendedInstancesDataAvailable = true;
|
|
result.SuspendedInstances.Add(new SuspendedInstance
|
|
{
|
|
ApplicationName = applicationName,
|
|
ServiceName = "TestService",
|
|
Kind = SuspendedKind.Resumable
|
|
});
|
|
return result;
|
|
}
|
|
|
|
private static void Run(string name, Action test)
|
|
{
|
|
ExecutedTests++;
|
|
try
|
|
{
|
|
test();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Failures.Add(name + ": " + ex.Message);
|
|
}
|
|
}
|
|
|
|
private static void Assert(bool condition, string message)
|
|
{
|
|
if (!condition)
|
|
{
|
|
throw new InvalidOperationException(message);
|
|
}
|
|
}
|
|
|
|
private static void AssertEqual(int expected, int actual, string label)
|
|
{
|
|
if (expected != actual)
|
|
{
|
|
throw new InvalidOperationException(label + ": expected " + expected + ", actual " + actual);
|
|
}
|
|
}
|
|
|
|
private static void AssertEqual(DiagnosticCategory expected, DiagnosticCategory actual, string label)
|
|
{
|
|
if (expected != actual)
|
|
{
|
|
throw new InvalidOperationException(label + ": expected " + expected + ", actual " + actual);
|
|
}
|
|
}
|
|
|
|
private static void AssertEqual(string expected, string actual, string label)
|
|
{
|
|
if (!string.Equals(expected, actual, StringComparison.Ordinal))
|
|
{
|
|
throw new InvalidOperationException(label + ": expected " + expected + ", actual " + actual);
|
|
}
|
|
}
|
|
}
|
|
}
|