public async Task LoadDiskSpaceResultTest_FileNotExist()
{
var savedResult = ComplianceInfo.ClearSystemComplianceItemResult <DiskSpaceInfo>();
var actual = await DiskSpace.LoadDiskSpaceResult().ConfigureAwait(false);
Assert.AreEqual(DiskSpaceInfo.Default, actual);
}
public async Task SaveAndLoadComplianceItemResultTest()
{
var testData = new SaveAndLoadTestData("A Name", "A description", 81.3452m);
Some <string> fileName = $@"c:\temp\{typeof(SaveAndLoadTestData).Name}.json";
var result = await ComplianceInfo.SaveComplianceItemResult <SaveAndLoadTestData>(testData, fileName);
result.Match <Unit>(unit =>
{
Assert.IsTrue(true);
return(Unit.Default);
}, exception =>
{
Assert.Fail();
return(Unit.Default);
});
var loadedTestData = await ComplianceInfo.LoadComplianceItemResult <SaveAndLoadTestData>(fileName);
var ignore = loadedTestData.Match <SaveAndLoadTestData>(
data =>
{
Assert.AreEqual("A Name", data.Name);
Assert.AreEqual("A description", data.Description);
Assert.AreEqual(new UDecimal(81.3452m), data.SomeNumber);
return(data);
},
exception =>
{
Assert.Fail(exception.Message);
throw exception;
});
}
public async Task SaveLoadDiskSpaceResultTest_Success()
{
var expected = new DiskSpaceInfo {
SccmCacheSize = 12, TotalFreeDiskSpace = 123
};
var savedResult = await ComplianceInfo.SaveSystemComplianceItemResult <DiskSpaceInfo>(expected).ConfigureAwait(false);
var actual = await DiskSpace.LoadDiskSpaceResult().ConfigureAwait(false);
Assert.AreEqual(expected, actual);
}
public static async Task <Result <ToastNotificationVisibility> > CheckDesktopData(
Some <NotificationProfile> userProfile, bool isDisabled)
{
var groupName = ToastGroups.CheckDesktopData;
var tag = ToastGroups.CheckDesktopData;
var desktopDataCheckIsDisabled = Profile.IsCheckDisabled(isDisabled, typeof(CheckDesktopDataCommand));
return(await CheckDesktopDataPure(
() => ComplianceInfo.LoadInfo(DesktopData.LoadDesktopDataInfo, info => info.HasDesktopData, ScheduledTasks.ComplianceUserMeasurements, true),
(desktopDataInfo) => DesktopData.ShowDesktopDataToastNotification(userProfile.Value, desktopDataInfo, tag, groupName),
() => ToastHelper.RemoveToastNotification(groupName), desktopDataCheckIsDisabled).ConfigureAwait(false));
}
public static async Task <Result <ToastNotificationVisibility> > CheckPasswordExpiry(Some <NotificationProfile> userProfile, bool isDisabled)
{
var groupName = ToastGroups.CheckPasswordExpiry;
var tag = ToastGroups.CheckPasswordExpiry;
var passwordExpiryCheckIsDisabled = Profile.IsCheckDisabled(isDisabled, typeof(CheckPasswordExpiryCommand));
bool IsNonCompliant(PasswordExpiryInfo info) => info.PasswordExpiryStatus == PasswordExpiryStatus.ExpiringSoon;
return(await CheckPasswordExpiryPure(
() => ComplianceInfo.LoadInfo <PasswordExpiryInfo>(PasswordExpire.LoadPasswordExpiryInfo, IsNonCompliant, ScheduledTasks.ComplianceUserMeasurements, true),
IsNonCompliant,
(passwordExpirationDate) => PasswordExpire.ShowPasswordExpiryToastNotification(userProfile, passwordExpirationDate, tag, groupName),
() => ToastHelper.RemoveToastNotification(groupName),
passwordExpiryCheckIsDisabled
).ConfigureAwait(false));
}
public static async Task <Result <ToastNotificationVisibility> > CheckSystemUptime(Some <NotificationProfile> userProfile, double maxUpTimeHours, bool isDisabled)
{
var category = typeof(CheckSystemUptimeCommand).GetPolicyCategory();
var policyMaxUptimeHours = Profile.GetIntegerPolicyValue(Context.Machine, category, "MaxUptimeHours", (int)maxUpTimeHours);
var groupName = ToastGroups.CheckSystemUptime;
var tag = ToastGroups.CheckSystemUptime;
var systemUptimeCheckIsDisabled = Profile.IsCheckDisabled(isDisabled, typeof(CheckSystemUptimeCommand));
bool IsNonCompliant(SystemUptimeInfo info) => info.Uptime.TotalHours > (double)policyMaxUptimeHours;
return(await CheckSystemUptimePure(() => ComplianceInfo.LoadInfo <SystemUptimeInfo>(SystemUptime.LoadSystemUptimeInfo, IsNonCompliant, ScheduledTasks.ComplianceSystemMeasurements, true),
IsNonCompliant,
(uptime) => SystemUptime.ShowSystemUptimeToastNotification(userProfile, tag, groupName, uptime),
() => ToastHelper.RemoveToastNotification(groupName),
systemUptimeCheckIsDisabled
).ConfigureAwait(false));
}
public async Task LoadInfoPureTest(string description, object data)
{
var testData = data as LoadInfoTestData;
Assert.IsNotNull(testData);
int loadInfoCount = 0;
var doubleCheckActionCount = 0;
Func <Task <TestInfo> > loadInfo = async() =>
{
loadInfoCount++;
if (loadInfoCount == 1)
{
return(await Task.FromResult(testData.Info));
}
if (loadInfoCount == 2 && testData.DoDoubleCheck)
{
return(await Task.FromResult(testData.DoubleCheckInfo));
}
throw new InvalidOperationException("Did not expect to call load info more times.");
};
Func <TestInfo, bool> isNonCompliant = info =>
{
return(!info.IsCompliant);
};
Func <bool> doDoubleCheck = () =>
{
return(testData.DoDoubleCheck);
};
Func <Task <Result <Unit> > > doubleCheckAction = async() =>
{
doubleCheckActionCount++;
if (testData.DoubleCheckFailed)
{
return(new Result <Unit>(new Exception("Double Check Failed")));
}
return(await Task.FromResult(new Result <Unit>(Unit.Default)));
};
var actual = await ComplianceInfo.LoadInfoPure(loadInfo, isNonCompliant, doDoubleCheck, doubleCheckAction);
Assert.AreEqual(testData.ExpectedInfo.Action, actual.Action, "InfoAction");
Assert.AreEqual(testData.ExpectedInfo.IsCompliant, actual.IsCompliant, "IsCompliant");
Assert.AreEqual(testData.LoadInfoCount, loadInfoCount, "Load info count");
Assert.AreEqual(testData.DoubleCheckActionCount, doubleCheckActionCount, "Double check action count");
}
public static async Task <Result <ToastNotificationVisibility> > CheckMissingMsUpdates(
Some <NotificationProfile> userProfile, int hoursToWaitBeforeNotifyUser, bool isDisabled)
{
var category = typeof(CheckMissingMsUpdatesCommand).GetPolicyCategory();
var policyHoursToWaitBeforeNotifyUser = Profile.GetIntegerPolicyValue(Context.Machine, category, "HoursToWaitBeforeNotifyingUser", (int)hoursToWaitBeforeNotifyUser);
var groupName = ToastGroups.CheckMissingMsUpdates;
var tag = ToastGroups.CheckMissingMsUpdates;
var systemUptimeCheckIsDisabled = Profile.IsCheckDisabled(isDisabled, typeof(CheckMissingMsUpdatesCommand));
bool IsNonCompliant(MissingMsUpdatesInfo info) => info.Updates.Count > 0 && info.Updates.Any(update => (DateTime.Now - update.FirstMeasuredMissing).TotalHours >= policyHoursToWaitBeforeNotifyUser);
return(await CheckMissingMsUpdatesPure(() => ComplianceInfo.LoadInfo(MissingMsUpdates.LoadMissingMsUpdatesInfo, IsNonCompliant, ScheduledTasks.ComplianceSystemMeasurements, true),
IsNonCompliant,
(info) => MissingMsUpdates.ShowMissingUpdatesToastNotification(userProfile, tag, groupName, info),
() => ToastHelper.RemoveToastNotification(groupName),
systemUptimeCheckIsDisabled
).ConfigureAwait(false));
}
/// <summary>
/// Check disk space compliance.
/// </summary>
/// <param name="notificationProfile"></param>
/// <param name="requiredFreeDiskSpace">Required free disk space in GB.</param>
/// <param name="subtractSccmCache">When set to true, disk space is compliant if: ((CurrentTotalFreeDiskSpace + CurrentSizeOfSccmCache) - requiredFreeDiskSpace) > 0</param>
/// <param name="isDisabled"></param>
/// <returns></returns>
public static async Task <Result <ToastNotificationVisibility> > CheckDiskSpace(Some <NotificationProfile> notificationProfile, UDecimal requiredFreeDiskSpace, bool subtractSccmCache, bool isDisabled)
{
var category = typeof(CheckDiskSpaceCommand).GetPolicyCategory();
var policyRequiredFreeDiskSpace = Profile.GetIntegerPolicyValue(Context.Machine, category, "RequiredFreeDiskSpace", (int)requiredFreeDiskSpace);
var policySubtractSccmCache = Profile.GetBooleanPolicyValue(Context.Machine, category, "SubtractSccmCache", subtractSccmCache);
var diskSpaceCheckIsDisabled = Profile.IsCheckDisabled(isDisabled, typeof(CheckDiskSpaceCommand));
var groupName = ToastGroups.CheckDiskSpace;
var tag = ToastGroups.CheckDiskSpace;
bool IsNonCompliant(DiskSpaceInfo spaceInfo) => RequiredCleanupAmount(spaceInfo, policyRequiredFreeDiskSpace, policySubtractSccmCache) > 0;
return(await CheckDiskSpaceCommand.CheckDiskSpacePure(
policyRequiredFreeDiskSpace,
policySubtractSccmCache,
() => ComplianceInfo.LoadInfo <DiskSpaceInfo>(DiskSpace.LoadDiskSpaceResult, IsNonCompliant, ScheduledTasks.ComplianceSystemMeasurements, true),
IsNonCompliant,
(requiredCleanupAmount) => DiskSpace.ShowDiskSpaceToastNotification(notificationProfile, requiredCleanupAmount, tag, groupName),
() => ToastHelper.RemoveToastNotification(groupName), diskSpaceCheckIsDisabled)
.ConfigureAwait(false));
}
public static async Task <Result <ToastNotificationVisibility> > CheckPendingReboot(Some <NotificationProfile> userProfile, bool isDisabled)
{
var groupName = ToastGroups.CheckPendingReboot;
var tag = ToastGroups.CheckPendingReboot;
var isPendingRebootCheckDisabled = Profile.IsCheckDisabled(isDisabled, typeof(CheckPendingRebootCommand));
bool IsNonCompliant(PendingRebootInfo info)
{
var newInfo = info.RemoveRebootSources(RebootSource.AllSources.Where(source => source.IsDisabled()));
return(newInfo.RebootIsPending);
}
return(await CheckPendingRebootPure(
() => ComplianceInfo.LoadInfo <PendingRebootInfo>(PendingReboot.LoadPendingRebootInfo, IsNonCompliant, ScheduledTasks.ComplianceSystemMeasurements, true),
IsNonCompliant,
(info, companyName) => PendingReboot.ShowPendingRebootToastNotification(userProfile, info, tag, groupName),
() => ToastHelper.RemoveToastNotification(groupName),
isPendingRebootCheckDisabled
).ConfigureAwait(false));
}
public async Task SaveLoadSystemComplianceItemResult_PendingRebootInfo_Test_Success()
{
var expected = new PendingRebootInfo {
RebootIsPending = true, Sources = new List <RebootSource>()
{
RebootSource.Cbs, RebootSource.Wuau
}
};
var savedResult = await ComplianceInfo.SaveSystemComplianceItemResult <PendingRebootInfo>(expected).ConfigureAwait(false);
var actual = await ComplianceInfo.LoadSystemComplianceItemResult <PendingRebootInfo>().ConfigureAwait(false);
actual.Match(act =>
{
AssertAreEqual(expected, act);
return(Unit.Default);
}, exception =>
{
Assert.Fail(exception.ToExceptionMessage());
return(Unit.Default);
});
}
public static async Task <PendingRebootInfo> LoadPendingRebootInfo()
{
return(await ComplianceInfo.LoadSystemComplianceItemResultOrDefault(PendingRebootInfo.Default).ConfigureAwait(false));
}
public static async Task <PasswordExpiryInfo> LoadPasswordExpiryInfo()
{
return(await ComplianceInfo.LoadUserComplianceItemResultOrDefault(PasswordExpiryInfo.Default).ConfigureAwait(false));
}
public static async Task <SystemUptimeInfo> LoadSystemUptimeInfo()
{
return(await ComplianceInfo.LoadSystemComplianceItemResultOrDefault(SystemUptimeInfo.Default).ConfigureAwait(false));
}
public static async Task <DesktopDataInfo> LoadDesktopDataInfo()
{
return(await ComplianceInfo.LoadUserComplianceItemResultOrDefault(DesktopDataInfo.Default).ConfigureAwait(false));
}
public static async Task <DiskSpaceInfo> LoadDiskSpaceResult()
{
return(await ComplianceInfo.LoadSystemComplianceItemResultOrDefault(DiskSpaceInfo.Default).ConfigureAwait(false));
}
public static async Task <MissingMsUpdatesInfo> LoadMissingMsUpdatesInfo()
{
return(await ComplianceInfo.LoadSystemComplianceItemResultOrDefault(MissingMsUpdatesInfo.Default).ConfigureAwait(false));
}
