public static void TestExceptionDuringVersionCallButRecentlyChecked()
{
FakeWebCaller webCaller = new FakeWebCaller(@"{""U"":""http://localhost/AxCrypt/Downloads.html"",""V"":""2.0.400.0"",""R"":300,""S"":0,""M"":""OK""}");
webCaller.Calling += (object sender, EventArgs e) => { throw new InvalidOperationException("Oops - a forced exception during the call."); };
SetupAssembly.FakeRuntimeEnvironment.WebCallerCreator = () =>
{
return(webCaller);
};
DateTime utcNow = DateTime.UtcNow;
SetupAssembly.FakeRuntimeEnvironment.TimeFunction = () => { return(utcNow); };
Version thisVersion = new Version(2, 0, 300, 0);
Uri restApiUrl = new Uri("http://localhost/RestApi.asxh/axcrypt2version");
Uri updateWebPageUrl = new Uri("http://www.axantum.com/");
VersionEventArgs eventArgs = null;
using (UpdateCheck updateCheck = new UpdateCheck(thisVersion))
{
updateCheck.VersionUpdate += (object sender, VersionEventArgs e) =>
{
eventArgs = e;
};
updateCheck.CheckInBackground(utcNow.AddDays(-2), UpdateCheck.VersionUnknown.ToString(), restApiUrl, updateWebPageUrl);
updateCheck.WaitForBackgroundCheckComplete();
}
Assert.That(eventArgs, Is.Not.Null, "The VersionUpdate event should be called with non-null VersionEventArgs.");
Assert.That(eventArgs.VersionUpdateStatus, Is.EqualTo(VersionUpdateStatus.ShortTimeSinceLastSuccessfulCheck), "Although the check failed, a check was recently made a short time ago.");
Assert.That(eventArgs.UpdateWebpageUrl, Is.EqualTo(updateWebPageUrl), "The original URL should be passed since the call failed.");
Assert.That(eventArgs.Version, Is.EqualTo(UpdateCheck.VersionUnknown), "An unknown version should be returned, since the call failed.");
}
public static void TestInvalidVersionReturned()
{
SetupAssembly.FakeRuntimeEnvironment.WebCallerCreator = () =>
{
return(new FakeWebCaller(@"{""U"":""http://localhost/AxCrypt/Downloads.html"",""V"":""x.y.z.z"",""R"":207,""S"":0,""M"":""OK""}"));
};
DateTime utcNow = DateTime.UtcNow;
SetupAssembly.FakeRuntimeEnvironment.TimeFunction = () => { return(utcNow); };
Version thisVersion = new Version(2, 0, 300, 0);
Uri restApiUrl = new Uri("http://localhost/RestApi.asxh/axcrypt2version");
Uri updateWebPageUrl = new Uri("http://www.axantum.com/");
VersionEventArgs eventArgs = null;
using (UpdateCheck updateCheck = new UpdateCheck(thisVersion))
{
updateCheck.VersionUpdate += (object sender, VersionEventArgs e) =>
{
eventArgs = e;
};
updateCheck.CheckInBackground(DateTime.MinValue, UpdateCheck.VersionUnknown.ToString(), restApiUrl, updateWebPageUrl);
updateCheck.WaitForBackgroundCheckComplete();
}
Assert.That(eventArgs, Is.Not.Null, "The VersionUpdate event should be called even when an invalid version is returned.");
Assert.That(eventArgs.VersionUpdateStatus, Is.EqualTo(VersionUpdateStatus.LongTimeSinceLastSuccessfulCheck), "No check has been performed previously and no new version is known.");
Assert.That(eventArgs.UpdateWebpageUrl, Is.EqualTo(new Uri("http://localhost/AxCrypt/Downloads.html")), "The right URL should be passed in the event args.");
Assert.That(eventArgs.Version, Is.EqualTo(UpdateCheck.VersionUnknown), "The version is not known since it could not be parsed.");
}
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 void TestVersionUpdated()
{
SetupAssembly.FakeRuntimeEnvironment.WebCallerCreator = () =>
{
return(new FakeWebCaller(@"{""U"":""http://localhost/AxCrypt/Downloads.html"",""V"":""2.0.307.0"",""R"":307,""S"":0,""M"":""OK""}"));
};
DateTime utcNow = DateTime.UtcNow;
SetupAssembly.FakeRuntimeEnvironment.TimeFunction = () => { return(utcNow); };
Version thisVersion = new Version(2, 0, 300, 0);
Version newVersion = new Version(2, 0, 307, 0);
Uri restApiUrl = new Uri("http://localhost/RestApi.asxh/axcrypt2version");
Uri updateWebPageUrl = new Uri("http://www.axantum.com/");
VersionEventArgs eventArgs = null;
using (UpdateCheck updateCheck = new UpdateCheck(thisVersion))
{
updateCheck.VersionUpdate += (object sender, VersionEventArgs e) =>
{
eventArgs = e;
};
updateCheck.CheckInBackground(DateTime.MinValue, UpdateCheck.VersionUnknown.ToString(), restApiUrl, updateWebPageUrl);
updateCheck.WaitForBackgroundCheckComplete();
}
Assert.That(eventArgs, Is.Not.Null, "The VersionUpdate event should be called with non-null VersionEventArgs.");
Assert.That(eventArgs.VersionUpdateStatus, Is.EqualTo(VersionUpdateStatus.NewerVersionIsAvailable), "The new version was newer.");
Assert.That(eventArgs.UpdateWebpageUrl, Is.EqualTo(new Uri("http://localhost/AxCrypt/Downloads.html")), "The right URL should be passed in the event args.");
Assert.That(eventArgs.Version, Is.EqualTo(newVersion), "The new version should be passed back.");
}
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 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 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 async void Updater_DownloadingCompleted(object sender, VersionEventArgs e)
{
Settings.CurrentSettings.NotifyUpdates = true;
Settings.CurrentSettings.Save();
await progressDialog.CloseAsync();
await NotifyDownloaded(e.CurrentVersion, e.LatestVersion, e.Changelog);
}
private void StudioVersionAdded(object sender, VersionEventArgs e)
{
BrowserType type = GetBrowserType(e.Version.Settings.GetMultipleChoiceSetting("BrowserType"));
if (!Selenium.ContainsKey(type))
{
(bool debugModeOn, SettingsCollection browserSettings)settings = GetDebugSettings(Studio.CurrentProject.Settings.GetSubSettings("debugSettings"), type);
Studio.ScheduleBackgroundTask(new StartSeleniumTask(type, settings.browserSettings));
}
}
private void Handle_VersionUpdate(object sender, VersionEventArgs e)
{
_userSettings.LastUpdateCheckUtc = New <INow>().Utc;
_userSettings.NewestKnownVersion = e.DownloadVersion.Version.ToString();
_userSettings.UpdateUrl = e.DownloadVersion.Url;
_userSettings.UpdateLevel = e.DownloadVersion.Level;
VersionUpdateStatus = e.DownloadVersion.CalculateStatus(New <IVersion>().Current, New <INow>().Utc, e.LastUpdateCheck);
DownloadVersion = e.DownloadVersion;
}
private async void Updater_UpdateAvailable(object sender, VersionEventArgs e)
{
if (e.UpdateDownloaded)
{
if (Settings.CurrentSettings.NotifyUpdates || UpdateDownloaded)
{
await NotifyDownloaded(e.CurrentVersion, e.LatestVersion, e.Changelog);
}
else
{
UpdateDownloaded = true;
MainWindow.buttonUpdate.Content = "Update downloaded";
}
}
else
{
if (Settings.CurrentSettings.NotifyUpdates || UpdateAvailable)
{
string message = $"An update is available, would you like to download it now?\n" +
$"Current version: {e.CurrentVersion}\n" +
$"Latest version: {e.LatestVersion}\n\n" +
$"Changelog:\n" +
$"{e.Changelog}";
MessageDialogResult result = await MainWindow.ShowMessageAsync("Update available", message, MessageDialogStyle.AffirmativeAndNegative);
if (result == MessageDialogResult.Affirmative)
{
Settings.CurrentSettings.NotifyUpdates = true;
Settings.CurrentSettings.Save();
Updater.DownloadUpdate();
}
else
{
Settings.CurrentSettings.NotifyUpdates = false;
Settings.CurrentSettings.Save();
UpdateAvailable = true;
MainWindow.buttonUpdate.Content = "Update available";
}
}
else
{
if (Settings.CurrentSettings.NotifyUpdates)
{
Settings.CurrentSettings.NotifyUpdates = false;
Settings.CurrentSettings.Save();
}
UpdateAvailable = true;
UpdateDownloaded = false;
MainWindow.buttonUpdate.Content = "Update available";
}
}
}
private void HandleVersionUpdateEvent(object sender, VersionEventArgs e)
{
Settings.Default.LastUpdateCheckUtc = OS.Current.UtcNow;
Settings.Default.NewestKnownVersion = e.Version.ToString();
Settings.Default.Save();
_updateUrl = e.UpdateWebpageUrl;
ThreadSafeUi(() =>
{
UpdateVersionStatus(e.VersionUpdateStatus, e.Version);
});
}
public static void TestVersionUpdatedWithInvalidVersionFormatFromServer()
{
SetupAssembly.FakeRuntimeEnvironment.WebCallerCreator = () =>
{
// The version returned has 5 components - bad!
return(new FakeWebCaller(@"{""U"":""http://localhost/AxCrypt/Downloads.html"",""V"":""2.0.307.0.0"",""R"":307,""S"":0,""M"":""OK""}"));
};
DateTime utcNow = DateTime.UtcNow;
SetupAssembly.FakeRuntimeEnvironment.TimeFunction = () => { return(utcNow); };
Version thisVersion = new Version(2, 0, 300, 0);
Uri restApiUrl = new Uri("http://localhost/RestApi.asxh/axcrypt2version");
Uri updateWebPageUrl = new Uri("http://www.axantum.com/");
VersionEventArgs eventArgs = null;
using (UpdateCheck updateCheck = new UpdateCheck(thisVersion))
{
updateCheck.VersionUpdate += (object sender, VersionEventArgs e) =>
{
eventArgs = e;
};
updateCheck.CheckInBackground(DateTime.MinValue, UpdateCheck.VersionUnknown.ToString(), restApiUrl, updateWebPageUrl);
updateCheck.WaitForBackgroundCheckComplete();
}
Assert.That(eventArgs, Is.Not.Null, "The VersionUpdate event should be called with non-null VersionEventArgs.");
Assert.That(eventArgs.VersionUpdateStatus, Is.EqualTo(VersionUpdateStatus.LongTimeSinceLastSuccessfulCheck), "This is not a successful check, and it was DateTime.MinValue since the last.");
Assert.That(eventArgs.UpdateWebpageUrl, Is.EqualTo(new Uri("http://localhost/AxCrypt/Downloads.html")), "The right URL should be passed in the event args.");
Assert.That(eventArgs.Version, Is.EqualTo(UpdateCheck.VersionUnknown), "The new version has 5 components, and should be parsed as unknown.");
SetupAssembly.FakeRuntimeEnvironment.WebCallerCreator = () =>
{
// The version returned is an empty string - bad!
return(new FakeWebCaller(@"{""U"":""http://localhost/AxCrypt/Downloads.html"",""V"":"""",""R"":307,""S"":0,""M"":""OK""}"));
};
using (UpdateCheck updateCheck = new UpdateCheck(thisVersion))
{
updateCheck.VersionUpdate += (object sender, VersionEventArgs e) =>
{
eventArgs = e;
};
updateCheck.CheckInBackground(DateTime.MinValue, UpdateCheck.VersionUnknown.ToString(), restApiUrl, updateWebPageUrl);
updateCheck.WaitForBackgroundCheckComplete();
}
Assert.That(eventArgs, Is.Not.Null, "The VersionUpdate event should be called with non-null VersionEventArgs.");
Assert.That(eventArgs.VersionUpdateStatus, Is.EqualTo(VersionUpdateStatus.LongTimeSinceLastSuccessfulCheck), "This is not a successful check, and it was DateTime.MinValue since the last.");
Assert.That(eventArgs.UpdateWebpageUrl, Is.EqualTo(new Uri("http://localhost/AxCrypt/Downloads.html")), "The right URL should be passed in the event args.");
Assert.That(eventArgs.Version, Is.EqualTo(UpdateCheck.VersionUnknown), "The new version is an empty string and should be parse as unknown.");
}
protected void On_PublishVersionInfo(object sender, VersionEventArgs e)
{
if (!e.UserID.Equals(Guid.Empty))
{
litAuthorInfo.Text = GetPageInfo(PageNameUtil.Decode(WikiPage), e.UserID, e.Date);
}
else
{
litAuthorInfo.Text = string.Empty;
}
hlVersionPage.Text = string.Format(WikiResource.cmdVersionTemplate, e.Version);
hlVersionPage.NavigateUrl = ActionHelper.GetViewPagePath(this.ResolveUrlLC("PageHistoryList.aspx"), PageNameUtil.Decode(WikiPage));
hlVersionPage.Visible = Action.Equals(ActionOnPage.View) || Action.Equals(ActionOnPage.CategoryView);
//litVersionSeparator.Visible = hlEditPage.Visible;
}
private void port_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
SerialPort sp = (SerialPort)sender;
byte[] buff = new byte[sp.BytesToRead];
sp.Read(buff, 0, buff.Length);
if ((buff[0] & 0xc0) == 0xc0) // status
{
if (OnStatusReturned != null)
{
StatusEventArgs args = new StatusEventArgs(buff[0].ToString());
OnStatusReturned(this, args);
}
}
else if ((buff[0] & 0xc0) == 0x80) // speed pot
{
if (OnSpeedPotChanged != null)
{
int speed = calculateSpeedPotSetting(buff[0]);
currentSpeed = speed;
SpeedPotEventArgs args = new SpeedPotEventArgs(speed);
OnSpeedPotChanged(this, args);
}
}
else // echo
{
if (!versionFound)
{
versionFound = true;
if (OnVersionReturned != null)
{
VersionEventArgs args = new VersionEventArgs(buff[0].ToString());
OnVersionReturned(this, args);
}
}
else
{
if (OnEchoReturned != null)
{
EchoEventArgs args = new EchoEventArgs(Encoding.ASCII.GetString(buff));
OnEchoReturned(this, args);
}
}
}
}
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 void TestOnlyOneCallMadeWhenCheckIsMadeWithCheckPending()
{
int calls = 0;
ManualResetEvent wait = new ManualResetEvent(false);
FakeWebCaller webCaller = new FakeWebCaller(@"{""U"":""http://localhost/AxCrypt/Downloads.html"",""V"":""2.0.400.0"",""R"":300,""S"":0,""M"":""OK""}");
webCaller.Calling += (object sender, EventArgs e) => { wait.WaitOne(); ++calls; };
SetupAssembly.FakeRuntimeEnvironment.WebCallerCreator = () =>
{
return(webCaller);
};
DateTime utcNow = DateTime.UtcNow;
SetupAssembly.FakeRuntimeEnvironment.TimeFunction = () => { return(utcNow); };
Version thisVersion = new Version(2, 0, 300, 0);
Version newVersion = new Version(2, 0, 400, 0);
Uri restApiUrl = new Uri("http://localhost/RestApi.asxh/axcrypt2version");
Uri updateWebPageUrl = new Uri("http://www.axantum.com/");
VersionEventArgs eventArgs = null;
using (UpdateCheck updateCheck = new UpdateCheck(thisVersion))
{
updateCheck.VersionUpdate += (object sender, VersionEventArgs e) =>
{
eventArgs = e;
};
updateCheck.CheckInBackground(DateTime.MinValue, UpdateCheck.VersionUnknown.ToString(), restApiUrl, updateWebPageUrl);
updateCheck.CheckInBackground(DateTime.MinValue, UpdateCheck.VersionUnknown.ToString(), restApiUrl, updateWebPageUrl);
wait.Set();
updateCheck.WaitForBackgroundCheckComplete();
}
Assert.That(eventArgs, Is.Not.Null, "The VersionUpdate event should be called with non-null VersionEventArgs.");
Assert.That(eventArgs.VersionUpdateStatus, Is.EqualTo(VersionUpdateStatus.NewerVersionIsAvailable), "One check should be made, indicating a newer version is available.");
Assert.That(eventArgs.UpdateWebpageUrl, 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.Version, Is.EqualTo(newVersion), "The new version should be passed back, since one call should be made.");
}
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.");
}
public static void TestVersionAlreadyCheckedRecently()
{
bool wasCalled = false;
FakeWebCaller webCaller = new FakeWebCaller(@"{""U"":""http://localhost/AxCrypt/Downloads.html"",""V"":""2.0.400.0"",""R"":300,""S"":0,""M"":""OK""}");
webCaller.Calling += (object sender, EventArgs e) => { wasCalled = true; };
SetupAssembly.FakeRuntimeEnvironment.WebCallerCreator = () =>
{
return(webCaller);
};
DateTime utcNow = DateTime.UtcNow;
SetupAssembly.FakeRuntimeEnvironment.TimeFunction = () => { return(utcNow); };
Version thisVersion = new Version(2, 0, 300, 0);
Uri restApiUrl = new Uri("http://localhost/RestApi.asxh/axcrypt2version");
Uri updateWebPageUrl = new Uri("http://www.axantum.com/");
VersionEventArgs eventArgs = null;
using (UpdateCheck updateCheck = new UpdateCheck(thisVersion))
{
updateCheck.VersionUpdate += (object sender, VersionEventArgs e) =>
{
eventArgs = e;
};
updateCheck.CheckInBackground(utcNow.AddHours(-1), thisVersion.ToString(), restApiUrl, updateWebPageUrl);
updateCheck.WaitForBackgroundCheckComplete();
}
Assert.That(eventArgs, Is.Not.Null, "The VersionUpdate event should be called with non-null VersionEventArgs.");
Assert.That(eventArgs.VersionUpdateStatus, Is.EqualTo(VersionUpdateStatus.IsUpToDateOrRecentlyChecked), "No check should be made, and it is assumed this version is up to date.");
Assert.That(eventArgs.UpdateWebpageUrl, 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.Version, Is.EqualTo(thisVersion), "The new version should not be passed back, since no call should be made.");
}
private void Communication_VersionResponse(object sender, VersionEventArgs e)
{
}
private void Communication_VersionResponse(object sender, VersionEventArgs e)
{
Messages.Add($"RECV: Version: version={e.Version}");
}
/// <summary>
/// Callback in the event of a successful response of a GetVersion request sent to a MeterBoard32
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Client_OnVersionReceived(object sender, VersionEventArgs e)
{
Invoke((MethodInvoker) delegate {
ShowInfo(string.Format("MeterBoard version {0} (based on MicroPython {1})", e.MeterBoardVersion, e.MicroPythonVersion));
});
}