public void RedirectionWithAuthorizationHeaders(Type handlerType)
{
TestRuntime.AssertSystemVersion(ApplePlatform.MacOSX, 10, 9, throwIfOtherPlatform: false);
TestRuntime.AssertSystemVersion(ApplePlatform.iOS, 7, 0, throwIfOtherPlatform: false);
bool containsAuthorizarion = false;
bool containsHeaders = false;
string json = "";
bool done = false;
Exception ex = null;
TestRuntime.RunAsync(DateTime.Now.AddSeconds(30), async() =>
{
try {
HttpClient client = new HttpClient(GetHandler(handlerType));
client.BaseAddress = NetworkResources.Httpbin.Uri;
var byteArray = new UTF8Encoding().GetBytes("username:password");
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(byteArray));
var result = await client.GetAsync(NetworkResources.Httpbin.GetRedirectUrl(3));
// get the data returned from httpbin which contains the details of the requested performed.
json = await result.Content.ReadAsStringAsync();
containsAuthorizarion = json.Contains("Authorization");
containsHeaders = json.Contains("headers"); // ensure we do have the headers in the response
} catch (Exception e) {
ex = e;
} finally {
done = true;
}
}, () => done);
if (!done) // timeouts happen in the bots due to dns issues, connection issues etc.. we do not want to fail
{
Assert.Inconclusive("Request timedout.");
}
else if (!containsHeaders)
{
Assert.Inconclusive("Response from httpbin does not contain headers, therefore we cannot ensure that if the authoriation is present.");
}
else
{
Assert.IsFalse(containsAuthorizarion, $"Authorization header did reach the final destination. {json}");
Assert.IsNull(ex, $"Exception {ex} for {json}");
}
}
public void TestNSUrlSessionHandlerCookieContainer()
{
var url = NetworkResources.Httpbin.CookiesUrl;
var cookie = new Cookie("cookie", "chocolate-chip");
var cookieContainer = new CookieContainer();
cookieContainer.Add(new Uri(url), cookie);
string managedCookieResult = null;
string nativeCookieResult = null;
Exception ex = null;
var completed = false;
TestRuntime.RunAsync(DateTime.Now.AddSeconds(30), async() => {
try {
var managedHandler = new HttpClientHandler()
{
AllowAutoRedirect = false,
CookieContainer = cookieContainer,
};
var managedClient = new HttpClient(managedHandler);
var managedResponse = await managedClient.GetAsync(url);
managedCookieResult = await managedResponse.Content.ReadAsStringAsync();
var nativeHandler = new NSUrlSessionHandler()
{
AllowAutoRedirect = true,
CookieContainer = cookieContainer,
};
var nativeClient = new HttpClient(nativeHandler);
var nativeResponse = await nativeClient.GetAsync(url);
nativeCookieResult = await nativeResponse.Content.ReadAsStringAsync();
} catch (Exception e) {
ex = e;
} finally {
completed = true;
}
}, () => completed);
Assert.IsNull(ex, "Exception");
Assert.IsNotNull(managedCookieResult, "Managed cookies result");
Assert.IsNotNull(nativeCookieResult, "Native cookies result");
Assert.AreEqual(managedCookieResult, nativeCookieResult, "Cookies");
}
public void TestNSUrlSessionDefaultDisableCookiesWithManagedContainer()
{
// simple test. send a request with a set-cookie url, get the data
// and ensure that the second request does not send any cookies.
var url = NetworkResources.Httpbin.GetSetCookieUrl("cookie", "chocolate-chip");
string nativeSetCookieResult = null;
string nativeCookieResult = null;
var cookieContainer = new CookieContainer();
Exception ex = null;
var completed = false;
TestRuntime.RunAsync(DateTime.Now.AddSeconds(30), async() => {
try {
var nativeHandler = new NSUrlSessionHandler()
{
AllowAutoRedirect = true,
UseCookies = false,
};
var nativeClient = new HttpClient(nativeHandler);
var nativeResponse = await nativeClient.GetAsync(url);
nativeSetCookieResult = await nativeResponse.Content.ReadAsStringAsync();
// got the response, preform a second queries to the cookies endpoint to get
// the actual cookies sent from the storage
nativeResponse = await nativeClient.GetAsync(NetworkResources.Httpbin.CookiesUrl);
nativeCookieResult = await nativeResponse.Content.ReadAsStringAsync();
} catch (Exception e) {
ex = e;
} finally {
completed = true;
}
}, () => completed);
Assert.IsNull(ex, "Exception");
Assert.IsNotNull(nativeSetCookieResult, "Native set-cookies result");
Assert.IsNotNull(nativeCookieResult, "Native cookies result");
Assert.IsFalse(nativeCookieResult.Contains("chocolate-chip"));
var cookiesFromServer = cookieContainer.GetCookies(new Uri(url));
Assert.AreEqual(0, cookiesFromServer.Count, "Cookies received from server.");
}
[Ignore("System.EntryPointNotFoundException: AppleCryptoNative_SecKeychainItemCopyKeychain")] // https://github.com/dotnet/runtime/issues/36897
#endif
public void TestNSUrlSessionHandlerCookies()
{
var managedCookieResult = false;
var nativeCookieResult = false;
Exception ex = null;
var completed = false;
IEnumerable <string> nativeCookies = null;
IEnumerable <string> managedCookies = null;
TestRuntime.RunAsync(DateTime.Now.AddSeconds(30), async() =>
{
var url = NetworkResources.Httpbin.GetSetCookieUrl("cookie", "chocolate-chip");
try {
var managedHandler = new HttpClientHandler()
{
AllowAutoRedirect = false,
};
var managedClient = new HttpClient(managedHandler);
var managedResponse = await managedClient.GetAsync(url);
managedCookieResult = managedResponse.Headers.TryGetValues("Set-Cookie", out managedCookies);
var nativeHandler = new NSUrlSessionHandler()
{
AllowAutoRedirect = false,
};
nativeHandler.AllowAutoRedirect = true;
var nativeClient = new HttpClient(nativeHandler);
var nativeResponse = await nativeClient.GetAsync(url);
nativeCookieResult = nativeResponse.Headers.TryGetValues("Set-Cookie", out nativeCookies);
} catch (Exception e) {
ex = e;
} finally {
completed = true;
}
}, () => completed);
Assert.IsNull(ex, "Exception");
Assert.IsTrue(managedCookieResult, $"Failed to get managed cookies");
Assert.IsTrue(nativeCookieResult, $"Failed to get native cookies");
Assert.AreEqual(1, managedCookies.Count(), $"Managed Cookie Count");
Assert.AreEqual(1, nativeCookies.Count(), $"Native Cookie Count");
Assert.That(nativeCookies.First(), Does.StartWith("cookie=chocolate-chip;"), $"Native Cookie Value");
Assert.That(managedCookies.First(), Does.StartWith("cookie=chocolate-chip;"), $"Managed Cookie Value");
}
public void FSEventFileChangedTest()
{
string path = Path.Combine(dirPath, "TempFileToWatch.txt");
var taskCompletionSource = new TaskCompletionSource <FSEventStreamEventsArgs> ();
FSEventStreamEventsArgs args = null;
TestRuntime.RunAsync(TimeSpan.FromSeconds(30), async() => {
fsEventStream.Events += (sender, eventArgs) => {
taskCompletionSource.SetResult(eventArgs);
watchedFileChanged = true;
};
fsEventStream.ScheduleWithRunLoop(CFRunLoop.Current);
fsEventStreamStarted = fsEventStream.Start();
File.AppendAllText(path, "Hello World!");
Assert.IsTrue(File.Exists(path));
args = await taskCompletionSource.Task.ConfigureAwait(false);
}, () => watchedFileChanged);
Assert.IsNotNull(args, "Null args");
}
public void DnsFailure(Type handlerType)
{
bool done = false;
Exception ex = null;
TestRuntime.RunAsync(DateTime.Now.AddSeconds(30), async() =>
{
try {
HttpClient client = new HttpClient(GetHandler(handlerType));
var s = await client.GetStringAsync("http://doesnotexist.xamarin.com");
} catch (Exception e) {
ex = e;
} finally {
done = true;
}
}, () => done);
Assert.IsNotNull(ex, "Exception");
// The handlers throw different types of exceptions, so we can't assert much more than that something went wrong.
}
public void DispatchBarrierAsync()
{
TestRuntime.AssertSystemVersion(PlatformName.iOS, 8, 0, throwIfOtherPlatform: false);
TestRuntime.AssertSystemVersion(PlatformName.MacOSX, 10, 10, throwIfOtherPlatform: false);
using (var queue = new DispatchQueue("DispatchBarrierAsync")) {
var called = false;
var callback = new Action(() => called = true);
queue.DispatchBarrierAsync(callback);
TestRuntime.RunAsync(TimeSpan.FromSeconds(5), () => { }, () => called);
Assert.IsTrue(called, "Called");
called = false;
using (var dg = new DispatchBlock(callback)) {
queue.DispatchBarrierAsync(dg);
dg.Wait(TimeSpan.FromSeconds(5));
}
Assert.IsTrue(called, "Called DispatchBlock");
}
}
public void GuidedAccessConfigureAccessibilityFeaturesTest()
{
TestRuntime.AssertXcodeVersion(10, 2);
var gotError = false;
var didSuccess = true;
var done = false;
TestRuntime.RunAsync(DateTime.Now.AddSeconds(30), async() => {
try {
var res = await UIGuidedAccessRestriction.ConfigureAccessibilityFeaturesAsync(UIGuidedAccessAccessibilityFeature.Zoom, true);
gotError = res.Error != null; // We expect an error back from the API call.
didSuccess = res.Success; // We expect false since monotouch-tests app is not run in kiosk mode.
} finally {
done = true;
}
}, () => done);
Assert.NotNull(gotError, "Error was null.");
Assert.IsFalse(didSuccess, "Somehow this succeeded, are we running monotouch-tests app in kiosk mode?");
}
public void GHIssue8342(HttpStatusCode expectedStatus, string validUsername, string validPassword, string username, string password)
{
// create a http client to use with some creds that we do know are not valid
var handler = new NSUrlSessionHandler()
{
Credentials = new NetworkCredential(username, password, "")
};
var client = new HttpClient(handler);
bool done = false;
HttpStatusCode httpStatus = HttpStatusCode.NotFound;
Exception ex = null;
TestRuntime.RunAsync(DateTime.Now.AddSeconds(30), async() => {
try {
var result = await client.GetAsync($"https://httpbin.org/basic-auth/{validUsername}/{validPassword}");
httpStatus = result.StatusCode;
} catch (Exception e) {
ex = e;
} finally {
done = true;
}
}, () => done);
if (!done) // timeouts happen in the bots due to dns issues, connection issues etc.. we do not want to fail
{
Assert.Inconclusive("Request timedout.");
}
else
{
if (httpStatus == HttpStatusCode.BadGateway || httpStatus == HttpStatusCode.GatewayTimeout)
{
TestRuntime.IgnoreInCI("Transient network failure - ignore in CI");
}
Assert.IsNull(ex, "Exception not null");
Assert.AreEqual(expectedStatus, httpStatus, "Status not ok");
}
}
public void NoRetainCyclesExpectedTest()
{
var thread = new Thread(delegate() {
MyParentView.weakcount = 0;
for (int i = 0; i < totalTestObjects; i++)
{
var parent = new MyParentView(useWeak: true);
parent.TouchButton();
}
});
thread.Start();
thread.Join();
GC.Collect(0);
GC.Collect();
GC.WaitForPendingFinalizers();
GC.WaitForPendingFinalizers();
TestRuntime.RunAsync(DateTime.Now.AddSeconds(30), () => { }, () => MyParentView.weakcount < totalTestObjects);
Assert.That(MyParentView.weakcount, Is.LessThan(totalTestObjects), "No retain cycles expected");
}
void CallAnimateImage(bool useUrl, CGImageAnimation.CGImageSourceAnimationHandler handler)
{
tcs = new TaskCompletionSource <bool> ();
status = (CGImageAnimationStatus)1; /* CGImageAnimationStatus.Ok == 0 */
bool done = false;
TestRuntime.RunAsync(TimeSpan.FromSeconds(30), async() => {
if (useUrl)
{
status = CGImageAnimation.AnimateImage(imageUrl, null, handler);
}
else
{
status = CGImageAnimation.AnimateImage(imageData, null, handler);
}
await tcs.Task;
done = true;
},
() => done);
tcs = null;
}
public void RegistrarTest()
{
Exception ex = null;
var done = new ManualResetEvent(false);
var success = false;
Task.Run(async() => {
try {
var config = NSUrlSessionConfiguration.DefaultSessionConfiguration;
config.WeakProtocolClasses = NSArray.FromNSObjects(new Class(typeof(CustomUrlProtocol)));
var session = NSUrlSession.FromConfiguration(config);
var custom_url = new NSUrl("foo://server");
using (var task = await session.CreateDownloadTaskAsync(custom_url)) {
success = true;
}
} catch (Exception e) {
ex = e;
} finally {
done.Set();
}
});
Assert.IsTrue(TestRuntime.RunAsync(DateTime.Now.AddSeconds(10), () => { }, () => done.WaitOne(0)), "Timed out");
Assert.IsNull(ex, "Exception");
Assert.IsTrue(custom_url_protocol_instance.Called_DidCompleteWithError, "DidCompleteWithError");
// if DidReceiveChallenge is called or not seems to vary between test runs, so we can't assert it.
//Assert.IsFalse (custom_url_protocol_instance.Called_DidReceiveChallenge, "DidReceiveChallenge");
Assert.IsTrue(custom_url_protocol_instance.Called_DidReceiveData, "DidReceiveData");
Assert.IsTrue(custom_url_protocol_instance.Called_DidReceiveResponse, "DidReceiveResponse");
Assert.IsTrue(custom_url_protocol_instance.Called_StartLoading, "StartLoading");
Assert.IsTrue(custom_url_protocol_instance.Called_StopLoading, "StopLoading");
Assert.IsFalse(custom_url_protocol_instance.Called_WillPerformHttpRedirection, "WillPerformHttpRedirection");
Assert.IsTrue(CustomUrlProtocol.Called_CanInitWithRequest, "CanInitWithRequest");
Assert.IsTrue(CustomUrlProtocol.Called_GetCanonicalRequest, "GetCanonicalRequest");
Assert.IsTrue(success, "Success");
}
public void CreateResponseAuth()
{
CFHTTPMessage response = null;
var done = false;
var taskCompletionSource = new TaskCompletionSource <CFHTTPMessage> ();
// the following code has to be in a diff thread, else, we are blocking the current loop, not cool
// perform a request so that we fail in the auth, then create the auth object and check the count
TestRuntime.RunAsync(DateTime.Now.AddSeconds(30), async() => {
using (var request = CFHTTPMessage.CreateRequest(
new Uri(NetworkResources.Httpbin.GetStatusCodeUrl(HttpStatusCode.Unauthorized)), "GET", null)) {
request.SetBody(Array.Empty <byte> ()); // empty body, we are not interested
using (var stream = CFStream.CreateForHTTPRequest(request)) {
Assert.IsNotNull(stream, "Null stream");
// we are only interested in the completed event
stream.ClosedEvent += (sender, e) => {
taskCompletionSource.SetResult(stream.GetResponseHeader());
done = true;
};
// enable events and run in the current loop
stream.EnableEvents(CFRunLoop.Main, CFRunLoop.ModeDefault);
stream.Open();
response = await taskCompletionSource.Task;
}
}
}, () => done);
if (!done)
{
TestRuntime.IgnoreInCI("Transient network failure - ignore in CI");
}
Assert.IsTrue(done, "Network request completed");
using (var auth = CFHTTPAuthentication.CreateFromResponse(response)) {
Assert.NotNull(auth, "Null Auth");
Assert.IsTrue(auth.IsValid, "Auth is valid");
Assert.That(TestRuntime.CFGetRetainCount(auth.Handle), Is.EqualTo((nint)1), "RetainCount");
}
}
public void TestNSurlSessionHandlerCookieContainerSetCookie()
{
var url = NetworkResources.Httpbin.GetSetCookieUrl("cookie", "chocolate-chip");
var cookieContainer = new CookieContainer();
string nativeCookieResult = null;
Exception ex = null;
var completed = false;
TestRuntime.RunAsync(DateTime.Now.AddSeconds(30), async() => {
try {
var nativeHandler = new NSUrlSessionHandler()
{
AllowAutoRedirect = true,
CookieContainer = cookieContainer,
};
var nativeClient = new HttpClient(nativeHandler);
var nativeResponse = await nativeClient.GetAsync(url);
nativeCookieResult = await nativeResponse.Content.ReadAsStringAsync();
} catch (Exception e) {
ex = e;
} finally {
completed = true;
}
}, () => completed);
if (!completed)
{
TestRuntime.IgnoreInCI("Transient network failure - ignore in CI");
}
Assert.IsTrue(completed, "Network request completed");
Assert.IsNull(ex, "Exception");
Assert.IsNotNull(nativeCookieResult, "Native cookies result");
var cookiesFromServer = cookieContainer.GetCookies(new Uri(url));
Assert.AreEqual(1, cookiesFromServer.Count, "Cookies received from server.");
}
public void DownloadDataAsync()
{
TestRuntime.AssertXcodeVersion(5, 0);
bool completed = false;
int failed_iteration = -1;
Exception ex = null;
TestRuntime.RunAsync(DateTime.Now.AddSeconds(30), async() => {
try {
for (int i = 0; i < 5; i++)
{
// Use the default configuration so we can make use of the shared cookie storage.
var session = NSUrlSession.FromConfiguration(NSUrlSessionConfiguration.DefaultSessionConfiguration);
var downloadUri = new Uri("https://google.com");
var downloadResponse = await session.CreateDownloadTaskAsync(downloadUri);
var tempLocation = downloadResponse.Location;
if (!File.Exists(tempLocation.Path))
{
Console.WriteLine("#{1} {0} does not exists", tempLocation, i);
failed_iteration = i;
break;
}
}
} catch (Exception e) {
ex = e;
} finally {
completed = true;
}
}, () => completed);
Assert.IsNull(ex, "Exception");
Assert.AreEqual(-1, failed_iteration, "Failed");
}
public void TestPACParsingAsyncNoProxy()
{
TestRuntime.IgnoreInCI("CI bots might have proxies setup and will mean that the test will fail when trying to assert they are empty.");
CFProxy [] proxies = null;
NSError error = null;
NSObject cbClient = null;
bool done = false;
string pacPath = Path.Combine(NSBundle.MainBundle.BundlePath, "example.pac");
var script = File.ReadAllText(pacPath);
var targetUri = new Uri("http://docs.xamarin.com");
Exception ex;
bool foundProxies;
// similar to the other tests, but we want to ensure that the async/await API works
TestRuntime.RunAsync(DateTime.Now.AddSeconds(30), async() => {
try {
CancellationTokenSource cancelSource = new CancellationTokenSource();
CancellationToken cancelToken = cancelSource.Token;
var result = await CFNetwork.ExecuteProxyAutoConfigurationScriptAsync(script, targetUri, cancelToken);
proxies = result.proxies;
error = result.error;
} catch (Exception e) {
ex = e;
} finally {
done = true;
}
}, () => done);
Assert.IsNull(cbClient, "Null client");
Assert.IsNull(error, "Null error");
Assert.IsNotNull(proxies, "Not null proxies");
Assert.AreEqual(1, proxies.Length, "Proxies length");
Assert.AreEqual(CFProxyType.None, proxies [0].ProxyType);
}
public void LoadHtmlAsync_NSUrl()
{
var completed = false;
string d = Path.Combine(NSBundle.MainBundle.ResourcePath, "access-denied.html");
string g = Path.Combine(NSBundle.MainBundle.ResourcePath, "access-granted.html");
TestRuntime.RunAsync(DateTime.Now.AddSeconds(3000), async() => {
using (var denied = NSUrl.FromFilename(d))
using (var granted = NSUrl.FromFilename(g)) {
var options = new NSAttributedStringDocumentAttributes {
ReadAccessUrl = granted
};
var r1 = await NSAttributedString.LoadFromHtmlAsync(granted, options);
Assert.That(r1.AttributedString.Value, Is.EqualTo("Granted"), "granted by options");
#if false
// this does not match my interpretation of the (headers) docs
var r2 = await NSAttributedString.LoadFromHtmlAsync(denied, options);
Assert.That(r2.AttributedString.Value, Is.Not.EqualTo("Denied"), "denied by options");
#endif
completed = true;
}
}, () => completed);
Assert.True(completed, "completed");
}
public void CreateDataTaskAsync()
{
if (!TestRuntime.CheckSystemAndSDKVersion(7, 0))
{
Assert.Inconclusive("requires iOS7");
}
NSUrlSession session = NSUrlSession.SharedSession;
var url = new NSUrl("http://www.xamarin.com");
var tmpfile = Path.GetTempFileName();
File.WriteAllText(tmpfile, "TMPFILE");
var file_url = NSUrl.FromFilename(tmpfile);
var file_data = NSData.FromFile(tmpfile);
var request = new NSUrlRequest(url);
var completed = false;
var timeout = 30;
/* CreateDataTask */
completed = false;
Assert.IsTrue(TestRuntime.RunAsync(DateTime.Now.AddSeconds(timeout), async() => {
await session.CreateDataTaskAsync(request);
completed = true;
}, () => completed), "CreateDataTask a");
completed = false;
Assert.IsTrue(TestRuntime.RunAsync(DateTime.Now.AddSeconds(timeout), async() => {
await session.CreateDataTaskAsync(url);
completed = true;
}, () => completed), "CreateDataTask b");
/* CreateDownloadTask */
completed = false;
Assert.IsTrue(TestRuntime.RunAsync(DateTime.Now.AddSeconds(timeout), async() => {
await session.CreateDownloadTaskAsync(request);
completed = true;
}, () => completed), "CreateDownloadTask a");
completed = false;
Assert.IsTrue(TestRuntime.RunAsync(DateTime.Now.AddSeconds(timeout), async() => {
await session.CreateDownloadTaskAsync(url);
completed = true;
}, () => completed), "CreateDownloadTask b");
/* CreateUploadTask */
completed = false;
Assert.IsTrue(TestRuntime.RunAsync(DateTime.Now.AddSeconds(timeout), async() => {
try {
await session.CreateUploadTaskAsync(request, file_url);
} catch /* (Exception ex) */ {
// Console.WriteLine ("Ex: {0}", ex);
} finally {
completed = true;
}
}, () => completed), "CreateUploadTask a");
completed = false;
Assert.IsTrue(TestRuntime.RunAsync(DateTime.Now.AddSeconds(timeout), async() => {
try {
await session.CreateUploadTaskAsync(request, file_data);
} catch /* (Exception ex) */ {
// Console.WriteLine ("Ex: {0}", ex);
} finally {
completed = true;
}
}, () => completed), "CreateUploadTask b");
}
public void GHIssue8344()
{
var username = "******";
var password = "******";
var url = $"https://httpbin.org/basic-auth/{username}/{password}";
// perform two requests, one that will get a 200 with valid creds, one that wont and assert that
// the second call does get a 401
// create a http client to use with some creds that we do know are not valid
var firstHandler = new NSUrlSessionHandler()
{
Credentials = new NetworkCredential(username, password, "")
};
var firstClient = new HttpClient(firstHandler);
bool done = false;
HttpStatusCode httpStatus = HttpStatusCode.NotFound;
Exception ex = null;
TestRuntime.RunAsync(DateTime.Now.AddSeconds(30), async() => {
try {
var result = await firstClient.GetAsync(url);
httpStatus = result.StatusCode;
} catch (Exception e) {
ex = e;
} finally {
done = true;
}
}, () => done);
if (!done) // timeouts happen in the bots due to dns issues, connection issues etc.. we do not want to fail
{
Assert.Inconclusive("First request timedout.");
}
else
{
Assert.IsNull(ex, "First request exception not null");
Assert.AreEqual(HttpStatusCode.OK, httpStatus, "First status not ok");
}
// exactly same operation, diff handler, wrong password, should fail
var secondHandler = new NSUrlSessionHandler()
{
Credentials = new NetworkCredential(username, password + password, "")
};
var secondClient = new HttpClient(secondHandler);
done = false;
httpStatus = HttpStatusCode.NotFound;
ex = null;
TestRuntime.RunAsync(DateTime.Now.AddSeconds(30), async() => {
try {
var result = await secondClient.GetAsync(url);
httpStatus = result.StatusCode;
} catch (Exception e) {
ex = e;
} finally {
done = true;
}
}, () => done);
if (!done) // timeouts happen in the bots due to dns issues, connection issues etc.. we do not want to fail
{
Assert.Inconclusive("Second request timedout.");
}
else
{
Assert.IsNull(ex, "Second request exception not null");
Assert.AreEqual(HttpStatusCode.Unauthorized, httpStatus, "Second status not ok");
}
}
public void RejectSslCertificatesServicePointManager(Type handlerType)
{
TestRuntime.AssertSystemVersion(PlatformName.MacOSX, 10, 9, throwIfOtherPlatform: false);
TestRuntime.AssertSystemVersion(PlatformName.iOS, 7, 0, throwIfOtherPlatform: false);
#if __MACOS__
if (handlerType == typeof(NSUrlSessionHandler) && TestRuntime.CheckSystemVersion(PlatformName.MacOSX, 10, 10, 0) && !TestRuntime.CheckSystemVersion(PlatformName.MacOSX, 10, 11, 0))
{
Assert.Ignore("Fails on macOS 10.10: https://github.com/xamarin/maccore/issues/1645");
}
#endif
bool validationCbWasExecuted = false;
bool customValidationCbWasExecuted = false;
bool invalidServicePointManagerCbWasExcuted = false;
bool done = false;
Exception ex = null;
Type expectedExceptionType = null;
HttpResponseMessage result = null;
var handler = GetHandler(handlerType);
if (handler is HttpClientHandler ch)
{
expectedExceptionType = typeof(AuthenticationException);
ch.ServerCertificateCustomValidationCallback = (sender, certificate, chain, errors) => {
validationCbWasExecuted = true;
// return false, since we want to test that the exception is raised
return(false);
};
ServicePointManager.ServerCertificateValidationCallback = (sender, certificate, chain, errors) => {
invalidServicePointManagerCbWasExcuted = true;
return(false);
};
}
else if (handler is NSUrlSessionHandler ns)
{
expectedExceptionType = typeof(WebException);
ns.TrustOverride += (a, b) => {
validationCbWasExecuted = true;
// return false, since we want to test that the exception is raised
return(false);
};
}
else
{
Assert.Fail($"Invalid HttpMessageHandler: '{handler.GetType ()}'.");
}
TestRuntime.RunAsync(DateTime.Now.AddSeconds(30), async() =>
{
try {
HttpClient client = new HttpClient(handler);
client.BaseAddress = NetworkResources.Httpbin.Uri;
var byteArray = new UTF8Encoding().GetBytes("username:password");
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(byteArray));
result = await client.GetAsync(NetworkResources.Httpbin.GetRedirectUrl(3));
} catch (Exception e) {
ex = e;
} finally {
done = true;
ServicePointManager.ServerCertificateValidationCallback = null;
}
}, () => done);
if (!done) // timeouts happen in the bots due to dns issues, connection issues etc.. we do not want to fail
{
Assert.Inconclusive("Request timedout.");
}
else
{
// the ServicePointManager.ServerCertificateValidationCallback will never be executed.
Assert.False(invalidServicePointManagerCbWasExcuted);
Assert.True(validationCbWasExecuted);
// assert the exception type
Assert.IsNotNull(ex, (result == null)? "Expected exception is missing and got no result" : $"Expected exception but got {result.Content.ReadAsStringAsync ().Result}");
Assert.IsInstanceOf(typeof(HttpRequestException), ex);
Assert.IsNotNull(ex.InnerException);
Assert.IsInstanceOf(expectedExceptionType, ex.InnerException);
}
}
public void CreateDataTaskAsync()
{
TestRuntime.AssertXcodeVersion(5, 0);
NSUrlSession session = NSUrlSession.SharedSession;
var url = new NSUrl("https://www.microsoft.com");
var tmpfile = Path.GetTempFileName();
File.WriteAllText(tmpfile, "TMPFILE");
var file_url = NSUrl.FromFilename(tmpfile);
var file_data = NSData.FromFile(tmpfile);
var request = new NSUrlRequest(url);
var completed = false;
var timeout = 30;
/* CreateDataTask */
completed = false;
Assert.IsTrue(TestRuntime.RunAsync(DateTime.Now.AddSeconds(timeout), async() => {
await session.CreateDataTaskAsync(request);
completed = true;
}, () => completed), "CreateDataTask a");
completed = false;
Assert.IsTrue(TestRuntime.RunAsync(DateTime.Now.AddSeconds(timeout), async() => {
await session.CreateDataTaskAsync(url);
completed = true;
}, () => completed), "CreateDataTask b");
/* CreateDownloadTask */
completed = false;
Assert.IsTrue(TestRuntime.RunAsync(DateTime.Now.AddSeconds(timeout), async() => {
await session.CreateDownloadTaskAsync(request);
completed = true;
}, () => completed), "CreateDownloadTask a");
completed = false;
Assert.IsTrue(TestRuntime.RunAsync(DateTime.Now.AddSeconds(timeout), async() => {
await session.CreateDownloadTaskAsync(url);
completed = true;
}, () => completed), "CreateDownloadTask b");
/* CreateUploadTask */
completed = false;
Assert.IsTrue(TestRuntime.RunAsync(DateTime.Now.AddSeconds(timeout), async() => {
try {
var uploadRequest = new NSMutableUrlRequest(url);
uploadRequest.HttpMethod = "POST";
await session.CreateUploadTaskAsync(uploadRequest, file_url);
} catch /* (Exception ex) */ {
// Console.WriteLine ("Ex: {0}", ex);
} finally {
completed = true;
}
}, () => completed), "CreateUploadTask a");
completed = false;
Assert.IsTrue(TestRuntime.RunAsync(DateTime.Now.AddSeconds(timeout), async() => {
try {
var uploadRequest = new NSMutableUrlRequest(url);
uploadRequest.HttpMethod = "POST";
await session.CreateUploadTaskAsync(uploadRequest, file_data);
} catch /* (Exception ex) */ {
// Console.WriteLine ("Ex: {0}", ex);
} finally {
completed = true;
}
}, () => completed), "CreateUploadTask b");
}
void Trust_Leaf_Only(SecTrust trust, SecPolicy policy)
{
Assert.That(CFGetRetainCount(trust.Handle), Is.EqualTo((nint)1), "RetainCount(trust)");
Assert.That(CFGetRetainCount(policy.Handle), Is.EqualTo((nint)2), "RetainCount(policy)");
// that certificate stopped being valid on September 30th, 2013 so we validate it with a date earlier than that
trust.SetVerifyDate(new DateTime(635108745218945450, DateTimeKind.Utc));
// the system was able to construct the chain based on the single certificate
var expectedTrust = SecTrustResult.RecoverableTrustFailure;
#if __MACOS__
if (!TestRuntime.CheckSystemVersion(PlatformName.MacOSX, 10, 9))
{
expectedTrust = SecTrustResult.Unspecified;
}
#endif
Assert.That(Evaluate(trust, true), Is.EqualTo(expectedTrust), "Evaluate");
using (var queue = new DispatchQueue("TrustAsync")) {
bool assert = false; // we don't want to assert in another queue
bool called = false;
var err = trust.Evaluate(DispatchQueue.MainQueue, (t, result) => {
assert = t.Handle == trust.Handle && result == expectedTrust;
called = true;
});
Assert.That(err, Is.EqualTo(SecStatusCode.Success), "async1/err");
TestRuntime.RunAsync(TimeSpan.FromSeconds(5), () => { }, () => called);
Assert.True(assert, "async1");
}
if (TestRuntime.CheckXcodeVersion(11, 0))
{
using (var queue = new DispatchQueue("TrustErrorAsync")) {
bool assert = false; // we don't want to assert in another queue
bool called = false;
var err = trust.Evaluate(DispatchQueue.MainQueue, (t, result, error) => {
assert = t.Handle == trust.Handle && !result && error != null;
called = true;
});
Assert.That(err, Is.EqualTo(SecStatusCode.Success), "async2/err");
TestRuntime.RunAsync(TimeSpan.FromSeconds(5), () => { }, () => called);
Assert.True(assert, "async2");
}
}
#if __MACOS__
var hasNetworkFetchAllowed = TestRuntime.CheckSystemVersion(PlatformName.MacOSX, 10, 9);
#else
var hasNetworkFetchAllowed = TestRuntime.CheckXcodeVersion(5, 0);
#endif
if (hasNetworkFetchAllowed)
{
Assert.True(trust.NetworkFetchAllowed, "NetworkFetchAllowed-1");
trust.NetworkFetchAllowed = false;
Assert.False(trust.NetworkFetchAllowed, "NetworkFetchAllowed-2");
trust.SetPolicy(policy);
var policies = trust.GetPolicies();
Assert.That(policies.Length, Is.EqualTo(1), "Policies.Length");
Assert.That(policies [0].Handle, Is.EqualTo(policy.Handle), "Handle");
}
}
public void TestStateChangesHandler()
{
// In the test we are doing the following:
//
// 1. Start a browser. At this point, we have no listeners (unless someone is exposing it in the lab)
// and therefore the browser cannot find any services/listeners.
// 2. Start a listener that is using the same type/domain pair that the browser expects.
// 3. Browser picks up the new listener, and sends an event (service found).
// 4. Listener stops, and the service disappears.
// 5. The browser is not yet canceled, so it picks up that the service/listener is not longer then and returns it.
//
// The test will block until the different events are set by the callbacks that are executed in a diff thread.
bool firstRun = true;
bool eventsDone = false;
bool listeningDone = false;
Exception ex = null;
var changesEvent = new AutoResetEvent(false);
var browserReady = new AutoResetEvent(false);
var finalEvent = new AutoResetEvent(false);
TestRuntime.RunAsync(DateTime.Now.AddSeconds(30), async() => {
// start the browser, before the listener
browser.SetStateChangesHandler((st, er) => {
Assert.IsNotNull(st, "State");
Assert.IsNull(er, "Error");
if (st == NWBrowserState.Ready)
{
browserReady.Set();
}
});
browser.SetChangesHandler((oldResult, newResult) => {
// first time, listener appears, so we do not have an old result, second time
// listener goes, so we do not have a new result
try {
if (firstRun)
{
Assert.IsNull(oldResult, "oldResult first run.");
Assert.IsNotNull(newResult, "newResult first run");
firstRun = false;
}
else
{
Assert.IsNotNull(oldResult, "oldResult first run.");
Assert.IsNull(newResult, "newResult first run");
}
} catch (Exception e) {
ex = e;
} finally {
changesEvent.Set();
eventsDone = true;
}
});
browser.Start();
browserReady.WaitOne(30000);
using (var advertiser = NWAdvertiseDescriptor.CreateBonjourService("MonoTouchFixtures.Network", type))
using (var tcpOptions = NWProtocolOptions.CreateTcp())
using (var tlsOptions = NWProtocolOptions.CreateTls())
using (var paramenters = NWParameters.CreateTcp()) {
paramenters.ProtocolStack.PrependApplicationProtocol(tlsOptions);
paramenters.ProtocolStack.PrependApplicationProtocol(tcpOptions);
paramenters.IncludePeerToPeer = true;
using (var listener = NWListener.Create("1234", paramenters)) {
listener.SetQueue(DispatchQueue.CurrentQueue);
listener.SetAdvertiseDescriptor(advertiser);
// we need the connection handler, else we will get an exception
listener.SetNewConnectionHandler((c) => { });
listener.SetStateChangedHandler((s, e) => {
if (e != null)
{
Console.WriteLine($"Got error {e.ErrorCode} {e.ErrorDomain} '{e.CFError.FailureReason}' {e.ToString ()}");
}
});
listener.Start();
changesEvent.WaitOne(30000);
listener.Cancel();
listeningDone = true;
finalEvent.Set();
}
}
}, () => eventsDone);
finalEvent.WaitOne(30000);
Assert.IsTrue(eventsDone);
Assert.IsTrue(listeningDone);
Assert.IsNull(ex, "Exception");
browser.Cancel();
}
public void DrawTest()
{
// Render an image with a pattern, and show it briefly on screen.
// It's supposed to show a blue oval with green plus signs inside.
TestRuntime.RunAsync(DateTime.Now.AddSeconds(0.1), () => { }, () => true, GetRenderedPattern());
}