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)); }