public static async Task TestVersionUpdated()
{
TypeMap.Register.New <IRestCaller>(
() => new FakeRestCaller(@"{""url"":""http://localhost/AxCrypt/Downloads.html"",""version"":""2.0.307.0"",""revision"":307}")
);
DateTime utcNow = DateTime.UtcNow;
((FakeNow)New <INow>()).TimeFunction = () => { return(utcNow); };
Version thisVersion = new Version(2, 0, 300, 0);
Version newVersion = new Version(2, 0, 307, 0);
Uri updateWebPageUrl = new Uri("http://www.axantum.com/");
VersionEventArgs eventArgs = null;
AxCryptUpdateCheck updateCheck = new AxCryptUpdateCheck(thisVersion);
updateCheck.AxCryptUpdate += (object sender, VersionEventArgs e) =>
{
eventArgs = e;
};
await updateCheck.CheckInBackgroundAsync(DateTime.MinValue, DownloadVersion.VersionUnknown.ToString(), updateWebPageUrl, String.Empty);
Assert.That(eventArgs, Is.Not.Null, "The VersionUpdate event should be called with non-null VersionEventArgs.");
Assert.That(eventArgs.DownloadVersion.CalculateStatus(thisVersion, utcNow, eventArgs.LastUpdateCheck), Is.EqualTo(VersionUpdateStatus.NewerVersionIsAvailable), "The new version was newer.");
Assert.That(eventArgs.DownloadVersion.Url, Is.EqualTo(new Uri("http://localhost/AxCrypt/Downloads.html")), "The right URL should be passed in the event args.");
Assert.That(eventArgs.DownloadVersion.Version, Is.EqualTo(newVersion), "The new version should be passed back.");
}
public static async Task TestInvalidVersionReturned()
{
TypeMap.Register.New <IRestCaller>(
() => new FakeRestCaller(@"{""url"":""http://localhost/AxCrypt/Downloads.html"",""version"":""x.y.z.z"",""revision"":207}")
);
DateTime utcNow = DateTime.UtcNow;
((FakeNow)New <INow>()).TimeFunction = () => { return(utcNow); };
Version thisVersion = new Version(2, 0, 300, 0);
Uri updateWebPageUrl = new Uri("http://www.axantum.com/");
VersionEventArgs eventArgs = null;
AxCryptUpdateCheck updateCheck = new AxCryptUpdateCheck(thisVersion);
updateCheck.AxCryptUpdate += (object sender, VersionEventArgs e) =>
{
eventArgs = e;
};
await updateCheck.CheckInBackgroundAsync(DateTime.MinValue, DownloadVersion.VersionUnknown.ToString(), updateWebPageUrl, String.Empty);
Assert.That(eventArgs, Is.Not.Null, "The VersionUpdate event should be called even when an invalid version is returned.");
Assert.That(eventArgs.DownloadVersion.CalculateStatus(thisVersion, utcNow, eventArgs.LastUpdateCheck), Is.EqualTo(VersionUpdateStatus.LongTimeSinceLastSuccessfulCheck), "No check has been performed previously and no new version is known.");
Assert.That(eventArgs.DownloadVersion.Url, Is.EqualTo(new Uri("http://www.axantum.com/")), "The right URL should be passed in the event args.");
Assert.That(eventArgs.DownloadVersion.Version, Is.EqualTo(DownloadVersion.VersionUnknown), "The version is not known since it could not be parsed.");
}
public static async Task TestExceptionDuringVersionCallButRecentlyChecked()
{
FakeRestCaller restCaller = new FakeRestCaller(@"{""url"":""http://localhost/AxCrypt/Downloads.html"",""version"":""2.0.400.0"",""revision"":300}");
restCaller.Calling += (object sender, EventArgs e) => { throw new InvalidOperationException("Oops - a forced exception during the call."); };
TypeMap.Register.New <IRestCaller>(
() => restCaller
);
DateTime utcNow = DateTime.UtcNow;
((FakeNow)New <INow>()).TimeFunction = () => { return(utcNow); };
Version thisVersion = new Version(2, 0, 300, 0);
Uri updateWebPageUrl = new Uri("http://www.axantum.com/");
VersionEventArgs eventArgs = null;
AxCryptUpdateCheck updateCheck = new AxCryptUpdateCheck(thisVersion);
updateCheck.AxCryptUpdate += (object sender, VersionEventArgs e) =>
{
eventArgs = e;
};
await updateCheck.CheckInBackgroundAsync(utcNow.AddDays(-2), DownloadVersion.VersionUnknown.ToString(), updateWebPageUrl, String.Empty);
Assert.That(eventArgs, Is.Not.Null, "The VersionUpdate event should be called with non-null VersionEventArgs.");
Assert.That(eventArgs.DownloadVersion.CalculateStatus(thisVersion, utcNow, eventArgs.LastUpdateCheck), Is.EqualTo(VersionUpdateStatus.ShortTimeSinceLastSuccessfulCheck), "Although the check failed, a check was recently made a short time ago.");
Assert.That(eventArgs.DownloadVersion.Url, Is.EqualTo(updateWebPageUrl), "The original URL should be passed since the call failed.");
Assert.That(eventArgs.DownloadVersion.Version, Is.EqualTo(DownloadVersion.VersionUnknown), "An unknown version should be returned, since the call failed.");
}
public static async Task TestVersionAlreadyCheckedRecently()
{
bool wasCalled = false;
FakeRestCaller restCaller = new FakeRestCaller(@"{""U"":""http://localhost/AxCrypt/Downloads.html"",""V"":""2.0.400.0"",""R"":300,""S"":0,""M"":""OK""}");
restCaller.Calling += (object sender, EventArgs e) => { wasCalled = true; };
TypeMap.Register.New <IRestCaller>(
() => restCaller
);
DateTime utcNow = DateTime.UtcNow;
((FakeNow)New <INow>()).TimeFunction = () => { return(utcNow); };
Version thisVersion = new Version(2, 0, 300, 0);
Uri updateWebPageUrl = new Uri("http://www.axantum.com/");
VersionEventArgs eventArgs = null;
AxCryptUpdateCheck updateCheck = new AxCryptUpdateCheck(thisVersion);
updateCheck.AxCryptUpdate += (object sender, VersionEventArgs e) =>
{
eventArgs = e;
};
await updateCheck.CheckInBackgroundAsync(utcNow.AddHours(-1), thisVersion.ToString(), updateWebPageUrl, String.Empty);
Assert.That(eventArgs, Is.Not.Null, "The VersionUpdate event should be called with non-null VersionEventArgs.");
Assert.That(eventArgs.DownloadVersion.CalculateStatus(thisVersion, utcNow, eventArgs.LastUpdateCheck), Is.EqualTo(VersionUpdateStatus.IsUpToDate), "No check should be made, and it is assumed this version is up to date.");
Assert.That(eventArgs.DownloadVersion.Url, Is.EqualTo(updateWebPageUrl), "The original URL should be passed in the event args since no call is made.");
Assert.That(wasCalled, Is.False, "The web caller should never be called.");
Assert.That(eventArgs.DownloadVersion.Version, Is.EqualTo(thisVersion), "The new version should not be passed back, since no call should be made.");
}
private void DisposeInternal()
{
if (_axCryptUpdateCheck != null)
{
Resolve.SessionNotify.RemoveCommand(HandleSessionChangedAsync);
_axCryptUpdateCheck.AxCryptUpdate -= Handle_VersionUpdate;
_axCryptUpdateCheck = null;
}
}
public void TestUpdateCheckWhenSigningIn()
{
AxCryptUpdateCheck mockedUpdateCheck = null;
TypeMap.Register.New <AxCryptUpdateCheck>(() => mockedUpdateCheck = new Mock <AxCryptUpdateCheck>(new Version(2, 0, 200, 0)).Object);
using (MainViewModel mvm = New <MainViewModel>())
{
mvm.LoggedOn = true;
}
Mock.Get <AxCryptUpdateCheck>(mockedUpdateCheck).Verify(x => x.CheckInBackgroundAsync(It.Is <DateTime>((d) => d == Resolve.UserSettings.LastUpdateCheckUtc), It.IsAny <string>(), It.IsAny <Uri>(), It.IsAny <string>()));
}
public MainViewModel(FileSystemState fileSystemState, UserSettings userSettings)
{
_fileSystemState = fileSystemState;
_userSettings = userSettings;
_axCryptUpdateCheck = New <AxCryptUpdateCheck>();
_axCryptUpdateCheck.AxCryptUpdate += Handle_VersionUpdate;
InitializePropertyValues();
BindPropertyChangedEvents();
SubscribeToModelEvents();
}
public static void TestArgumentNullException()
{
string nullVersion = null;
Uri nullUrl = null;
Version thisVersion = new Version(2, 0, 300, 0);
Version newVersion = new Version(2, 0, 307, 0);
Uri updateWebPageUrl = new Uri("http://www.axantum.com/");
AxCryptUpdateCheck updateCheck = new AxCryptUpdateCheck(thisVersion);
Assert.ThrowsAsync <ArgumentNullException>(async() => { await updateCheck.CheckInBackgroundAsync(DateTime.MinValue, nullVersion, updateWebPageUrl, String.Empty); }, "Null argument should throw.");
Assert.ThrowsAsync <ArgumentNullException>(async() => { await updateCheck.CheckInBackgroundAsync(DateTime.MinValue, newVersion.ToString(), nullUrl, String.Empty); }, "Null argument should throw.");
}
public static async Task TestVersionUpdatedWithInvalidVersionFormatFromServer()
{
TypeMap.Register.New <IRestCaller>(
// The version returned has 5 components - bad!
() => new FakeRestCaller(@"{""url"":""http://localhost/AxCrypt/Downloads.html"",""version"":""2.0.307.0.0"",""revision"":307}")
);
DateTime utcNow = DateTime.UtcNow;
((FakeNow)New <INow>()).TimeFunction = () => { return(utcNow); };
Version thisVersion = new Version(2, 0, 300, 0);
Uri updateWebPageUrl = new Uri("http://www.axantum.com/");
VersionEventArgs eventArgs = null;
AxCryptUpdateCheck updateCheck = new AxCryptUpdateCheck(thisVersion);
updateCheck.AxCryptUpdate += (object sender, VersionEventArgs e) =>
{
eventArgs = e;
};
await updateCheck.CheckInBackgroundAsync(DateTime.MinValue, DownloadVersion.VersionUnknown.ToString(), updateWebPageUrl, String.Empty);
Assert.That(eventArgs, Is.Not.Null, "The VersionUpdate event should be called with non-null VersionEventArgs.");
Assert.That(eventArgs.DownloadVersion.CalculateStatus(thisVersion, utcNow, eventArgs.LastUpdateCheck), Is.EqualTo(VersionUpdateStatus.LongTimeSinceLastSuccessfulCheck), "This is not a successful check, and it was DateTime.MinValue since the last.");
Assert.That(eventArgs.DownloadVersion.Url, Is.EqualTo(new Uri("http://www.axantum.com/")), "The right URL should be passed in the event args.");
Assert.That(eventArgs.DownloadVersion.Version, Is.EqualTo(DownloadVersion.VersionUnknown), "The new version has 5 components, and should be parsed as unknown.");
TypeMap.Register.New <IRestCaller>(
// The version returned is an empty string - bad!
() => new FakeRestCaller(@"{""url"":""http://localhost/AxCrypt/Downloads.html"",""version"":"""",""revision"":307}")
);
updateCheck = new AxCryptUpdateCheck(thisVersion);
updateCheck.AxCryptUpdate += (object sender, VersionEventArgs e) =>
{
eventArgs = e;
};
await updateCheck.CheckInBackgroundAsync(DateTime.MinValue, DownloadVersion.VersionUnknown.ToString(), updateWebPageUrl, String.Empty);
Assert.That(eventArgs, Is.Not.Null, "The VersionUpdate event should be called with non-null VersionEventArgs.");
Assert.That(eventArgs.DownloadVersion.CalculateStatus(thisVersion, utcNow, eventArgs.LastUpdateCheck), Is.EqualTo(VersionUpdateStatus.LongTimeSinceLastSuccessfulCheck), "This is not a successful check, and it was DateTime.MinValue since the last.");
Assert.That(eventArgs.DownloadVersion.Url, Is.EqualTo(new Uri("http://www.axantum.com/")), "The right URL should be passed in the event args.");
Assert.That(eventArgs.DownloadVersion.Version, Is.EqualTo(DownloadVersion.VersionUnknown), "The new version is an empty string and should be parsed as unknown.");
}
public static async Task TestOnlyOneCallMadeWhenCheckIsMadeWithCheckPending()
{
int calls = 0;
ManualResetEvent wait = new ManualResetEvent(false);
FakeRestCaller restCaller = new FakeRestCaller(@"{""url"":""http://localhost/AxCrypt/Downloads.html"",""version"":""2.0.400.0"",""revision"":300}");
restCaller.Calling += (object sender, EventArgs e) => { wait.WaitOne(); ++calls; };
TypeMap.Register.New <IRestCaller>(
() => restCaller
);
DateTime utcNow = DateTime.UtcNow;
((FakeNow)New <INow>()).TimeFunction = () => { return(utcNow); };
Version thisVersion = new Version(2, 0, 300, 0);
Version newVersion = new Version(2, 0, 400, 0);
Uri updateWebPageUrl = new Uri("http://www.axantum.com/");
VersionEventArgs eventArgs = null;
AxCryptUpdateCheck updateCheck = new AxCryptUpdateCheck(thisVersion);
updateCheck.AxCryptUpdate += (object sender, VersionEventArgs e) =>
{
eventArgs = e;
};
Task t1 = updateCheck.CheckInBackgroundAsync(DateTime.MinValue, DownloadVersion.VersionUnknown.ToString(), updateWebPageUrl, String.Empty);
await updateCheck.CheckInBackgroundAsync(DateTime.MinValue, DownloadVersion.VersionUnknown.ToString(), updateWebPageUrl, String.Empty);
wait.Set();
await t1;
Assert.That(eventArgs, Is.Not.Null, "The VersionUpdate event should be called with non-null VersionEventArgs.");
Assert.That(eventArgs.DownloadVersion.CalculateStatus(thisVersion, utcNow, eventArgs.LastUpdateCheck), Is.EqualTo(VersionUpdateStatus.NewerVersionIsAvailable), "One check should be made, indicating a newer version is available.");
Assert.That(eventArgs.DownloadVersion.Url, Is.EqualTo(new Uri("http://localhost/AxCrypt/Downloads.html")), "The new URL should be passed since a call is made.");
Assert.That(calls, Is.EqualTo(1), "The web caller should only be called once.");
Assert.That(eventArgs.DownloadVersion.Version, Is.EqualTo(newVersion), "The new version should be passed back, since one call should be made.");
}
private void BindPropertyChangedEvents()
{
BindPropertyChangedInternal(nameof(DragAndDropFiles), (IEnumerable <string> files) => { DragAndDropFilesTypes = DetermineFileTypes(files.Select(f => New <IDataItem>(f))); });
BindPropertyChangedInternal(nameof(DragAndDropFiles), (IEnumerable <string> files) => { DroppableAsRecent = DetermineDroppableAsRecent(files.Select(f => New <IDataItem>(f))); });
BindPropertyChangedInternal(nameof(DragAndDropFiles), (IEnumerable <string> files) => { DroppableAsWatchedFolder = DetermineDroppableAsWatchedFolder(files.Select(f => New <IDataItem>(f))); });
BindPropertyChangedInternal(nameof(RecentFilesComparer), (ActiveFileComparer comparer) => { SetRecentFilesComparer(); });
BindPropertyChangedInternal(nameof(LoggedOn), (bool loggedOn) => LicenseUpdate.Execute(null));
BindPropertyChangedInternal(nameof(LoggedOn), async(bool loggedOn) => { if (loggedOn)
{
await AxCryptUpdateCheck.ExecuteAsync(_userSettings.LastUpdateCheckUtc);
}
});
BindPropertyChanged(nameof(DebugMode), (bool enabled) => { UpdateDebugMode(enabled); });
BindPropertyChanged(nameof(LoggedOn), (bool loggedOn) => EncryptFileEnabled = loggedOn || !License.Has(LicenseCapability.EncryptNewFiles));
BindPropertyChanged(nameof(License), async(LicenseCapabilities policy) => await SetWatchedFoldersAsync());
BindPropertyChanged(nameof(EncryptionUpgradeMode), (EncryptionUpgradeMode mode) => Resolve.UserSettings.EncryptionUpgradeMode = mode);
BindPropertyChanged(nameof(FolderOperationMode), async(FolderOperationMode mode) => await SetFolderOperationMode(mode));
}
