private ID2LUserContext GetUserContext(Dictionary <string, object> licenseSettings, string userId, string userKey, string hostUrl)
{
var host = new HostSpec("https", hostUrl, 443);
var context = InitializeAppContext(licenseSettings);
return(context.CreateUserContext(userId, userKey, host));
}
public Uri GetTokenRedirectUrl(Uri returnUrl, string hostUrl, Dictionary <string, object> licenseSettings)
{
var m_valenceHost = new HostSpec("https", hostUrl, 443);
var context = InitializeAppContext(licenseSettings);
return(context.CreateUrlForAuthentication(m_valenceHost, returnUrl));
}
Uri ID2LAppContext.CreateUrlForAuthentication( HostSpec authenticatingHost, Uri landingUri )
{
var uriBuilder = authenticatingHost.ToUriBuilder();
uriBuilder.Path = AUTHENTICATION_SERVICE_URI_PATH;
uriBuilder.Query = BuildAuthenticationUriQueryString( landingUri );
return uriBuilder.Uri;
}
private static ID2LUserContext InterceptUserTokens(HostSpec host, ID2LAppContext appContext)
{
// Start HTTP server and listen for the redirect after a successful auth
var httpListener = new HttpListener();
httpListener.Prefixes.Add("http://localhost:31337/result/");
httpListener.Start();
// This call blocks until we get a response
var ctx = httpListener.GetContext();
// The LMS returns the user tokens via query parameters to the value provided originally in x_target
// TODO: deal with "failed to login" case
var userContext = appContext.CreateUserContext(ctx.Request.Url, host);
// Send some JavaScript to close the browser popup
// This is not 100% effective: for example, Firefox will ignore this.
const string RESPONSE = "<!doctype html><meta charset=\"utf-8\"><script>window.close();</script><h1>You may now close your window</h1><p>You may or may not see this message, depending on your browser</p>";
byte[] buffer = System.Text.Encoding.UTF8.GetBytes(RESPONSE);
ctx.Response.ContentType = "text/html";
ctx.Response.ContentLength64 = buffer.Length;
ctx.Response.OutputStream.Write(buffer, 0, buffer.Length);
ctx.Response.OutputStream.Close();
httpListener.Stop();
return(userContext);
}
public HomeController( )
{
var appFactory = new D2LAppContextFactory();
m_valenceAppContext = appFactory.Create(APP_ID, APP_KEY);
m_valenceHost = new HostSpec("https", LMS_URL, 443);
}
private ID2LUserContext CreateUserOperationContext()
{
var apiHost = new HostSpec(m_scheme, m_host, m_port);
var opContext = m_appContext.CreateUserContext(m_userId, m_userKey, apiHost);
return(opContext);
}
static void Main()
{
// This is the LMS we will interact with
var host = new HostSpec("https", "lms.valence.desire2learn.com", 443);
// The appId/appKey come from our app.config - it is good to seperate access keys from the code that uses them.
// Ideally you wouldn't have production keys committed to source control.
string appId = ConfigurationManager.AppSettings["appId"];
string appKey = ConfigurationManager.AppSettings["appKey"];
// This is the port we will temporarily host a server on to intercept the user tokens after a successful login
int port = int.Parse(ConfigurationManager.AppSettings["serverPort"]);
// Create url for the user to login. If they have already done so they will not actually have to type their password (maybe).
var appContextFactory = new D2LAppContextFactory();
var appContext = appContextFactory.Create(appId, appKey);
var authUrl = appContext.CreateUrlForAuthentication(host, new Uri("http://localhost:" + port + "/result/"));
OpenBrowser(authUrl);
// This call will block until we have a result
// TODO: you'll want better control flow and error handling here
var userContext = InterceptUserTokens(host, appContext);
// Now we can call Valence
DoApiStuff(host.Scheme + "://" + host.Host + ":" + host.Port, userContext);
// Pause the terminal
Console.ReadKey();
}
public ActionResult Index()
{
var param = Session[SESSION_KEY] as SessionParameters;
if (param == null)
{
ViewBag.ErrorMessage = "Unable to retrieve required session param.";
return(View("BookError"));
}
if (param.LtiUri == null)
{
ViewBag.ErrorMessage = "LTI param are not valid.";
return(View("BookError"));
}
// retrieve the required version information from the LMS
var factory = new D2LAppContextFactory();
var appContext = factory.Create(m_defaultAppId, m_defaultAppKey);
var hostInfo = new HostSpec(param.LtiUri.Scheme, param.LtiUri.Host, param.LtiUri.Port);
ID2LUserContext context = appContext.CreateUserContext(Request.Url, hostInfo);
if (context == null)
{
ViewBag.ErrorMessage = "Unable to create user context.";
return(View("BookError"));
}
param.UserContext = context;
return(RedirectToAction("Assigned"));
}
public HomeController( )
{
var appFactory = new D2LAppContextFactory();
m_valenceAppContext = appFactory.Create(m_appId, m_appKey);
m_valenceHost = new HostSpec("https", LMS_URL, 443);
}
public void AppContext_CreateUrlForAuth_IfHostSpecSaysHttps_ReturnsUri_WhereSchemeIsHttps() {
var hostSpec = new HostSpec( "https", TestConstants.HOST_NAME, 443 );
Uri uri = m_appContext.CreateUrlForAuthentication( hostSpec, m_landingUri );
Assert.AreEqual( "https", uri.Scheme );
}
public void AppContext_CreateUrlForAuth_ReturnsUri_WherePortNumber_MatchesInput() {
const int expectedPortNumber = 44480;
var hostSpec = new HostSpec( "https", TestConstants.HOST_NAME, expectedPortNumber );
Uri uri = m_appContext.CreateUrlForAuthentication( hostSpec, m_landingUri );
Assert.AreEqual( expectedPortNumber, uri.Port );
}
public void AppContext_CreateUrlForAuth_ReturnsUri_WhereHost_MatchesInput() {
const string expectedHost = "asdf.com";
var hostSpec = new HostSpec( "https", expectedHost, TestConstants.PORT );
Uri uri = m_appContext.CreateUrlForAuthentication( hostSpec, m_landingUri );
Assert.AreEqual( expectedHost, uri.Host );
}
public void AppContext_CreateUrlForAuth_IfHostSpecSaysHttps_ReturnsUri_WhereSchemeIsHttps()
{
var hostSpec = new HostSpec("https", TestConstants.HOST_NAME, 443);
Uri uri = m_appContext.CreateUrlForAuthentication(hostSpec, m_landingUri);
Assert.AreEqual("https", uri.Scheme);
}
Uri ID2LAppContext.CreateUrlForAuthentication(HostSpec authenticatingHost, Uri landingUri)
{
var uriBuilder = authenticatingHost.ToUriBuilder();
uriBuilder.Path = AUTHENTICATION_SERVICE_URI_PATH;
uriBuilder.Query = BuildAuthenticationUriQueryString(landingUri);
return(uriBuilder.Uri);
}
public void SendRequest_WhenBadHostSpec_UnhandledException()
{
var badApiHost = new HostSpec(ChangeScheme(m_scheme), m_host, m_port);
var badAnonContext = m_appContext.CreateAnonymousUserContext(badApiHost);
var request = PrepareApiRequest(badAnonContext, GET_VERSIONS_ROUTE);
Assert.Throws <WebException>(() => request.GetResponse());
}
public void SendRequest_WhenBadHostSpec_UnhandledException()
{
HostSpec badApiHost = new HostSpec(ChangeScheme(ConfigHelper.Scheme), ConfigHelper.Host, ConfigHelper.Port);
ID2LUserContext badAnonContext = ContextProvider.AnonUserContext(badApiHost);
HttpWebRequest request = RequestProvider.PrepareApiRequest(badAnonContext, RouteProvider.VersionsRoute);
Assert.Throws <WebException>(() => { using (HttpWebResponse response = request.GetResponse() as HttpWebResponse) { } });
}
public void AppContext_CreateUrlForAuth_ReturnsUri_WhereHost_MatchesInput()
{
const string expectedHost = "asdf.com";
var hostSpec = new HostSpec("https", expectedHost, TestConstants.PORT);
Uri uri = m_appContext.CreateUrlForAuthentication(hostSpec, m_landingUri);
Assert.AreEqual(expectedHost, uri.Host);
}
/// <summary>
/// Constructs a D2LUserContext with the parameters provided
/// </summary>
/// <param name="timestampProvider">The system timestamp provider</param>
/// <param name="appId">The D2L app ID</param>
/// <param name="appKey">The D2L app key</param>
/// <param name="userId">The D2L user ID to be used</param>
/// <param name="userKey">The D2L user key to be used</param>
/// <param name="apiHost">The host information of the server to make API calls to</param>
internal D2LUserContext( ITimestampProvider timestampProvider, string appId, string appKey, string userId, string userKey, HostSpec apiHost )
{
m_appId = appId;
m_appKey = appKey;
m_userId = userId;
m_userKey = userKey;
m_apiHost = apiHost;
m_timestampProvider = timestampProvider;
}
public void AppContext_CreateUrlForAuth_ReturnsUri_WherePortNumber_MatchesInput()
{
const int expectedPortNumber = 44480;
var hostSpec = new HostSpec("https", TestConstants.HOST_NAME, expectedPortNumber);
Uri uri = m_appContext.CreateUrlForAuthentication(hostSpec, m_landingUri);
Assert.AreEqual(expectedPortNumber, uri.Port);
}
public ValenceAuthenticator CreateAuthenticator()
{
D2LAppContextFactory contextFactory = new D2LAppContextFactory();
ID2LAppContext appContext = contextFactory.Create(m_appId, m_appKey);
HostSpec valenceHost = new HostSpec("https", m_lmsUrl, 443);
ID2LUserContext userContext = appContext.CreateUserContext(m_userId, m_userKey, valenceHost);
return(new ValenceAuthenticator(userContext));
}
public void AppContext_CreateUserContext_FromAuthCallbackUri_SaveProps_HostMatches() {
const string expectedHost = "univ.edu";
var apiHost = new HostSpec( "https", expectedHost, 443 );
var userContext = m_appContext.CreateUserContext( m_authCallbackUri, apiHost );
var savedProps = userContext.SaveUserContextProperties();
Assert.AreEqual( expectedHost, savedProps.HostName );
}
/// <summary>
/// Constructs a D2LUserContext with the parameters provided
/// </summary>
/// <param name="timestampProvider">The system timestamp provider</param>
/// <param name="appId">The D2L app ID</param>
/// <param name="appKey">The D2L app key</param>
/// <param name="userId">The D2L user ID to be used</param>
/// <param name="userKey">The D2L user key to be used</param>
/// <param name="apiHost">The host information of the server to make API calls to</param>
internal D2LUserContext(ITimestampProvider timestampProvider, string appId, string appKey, string userId, string userKey, HostSpec apiHost)
{
m_appId = appId;
m_appKey = appKey;
m_userId = userId;
m_userKey = userKey;
m_apiHost = apiHost;
m_timestampProvider = timestampProvider;
}
public void AppContext_CreateUserContext_FromAuthCallbackUri_SaveProps_PortMatches() {
const int expectedPort = 2228;
var apiHost = new HostSpec( "https", TestConstants.HOST_NAME, expectedPort );
var userContext = m_appContext.CreateUserContext( m_authCallbackUri, apiHost );
var savedProps = userContext.SaveUserContextProperties();
Assert.AreEqual( expectedPort, savedProps.Port );
}
/*
* Creates a new ID2LUserContext object
*
* @return
* an instance of a ID2LUserContext
*/
public static ID2LUserContext GetD2LUserContext()
{
D2LAppContextFactory factory = new D2LAppContextFactory();
ID2LAppContext appContext = factory.Create(Utility.GetAppIdValence(), Utility.GetAppKeyValence());
HostSpec hostInfo = new HostSpec(Utility.GetSchemaValence(), Utility.GetHostValence(), Utility.GetPortValence());
ID2LUserContext userContext = appContext.CreateUserContext(Utility.GetUserIdValence(), Utility.GetUserKeyValence(), hostInfo);
return(userContext);
}
public void SendRequest_AtUrlForAuthentication_ResponseReceived()
{
var hostSpec = new HostSpec(m_scheme, m_host, m_port);
var landingUrl = new UriBuilder(m_scheme, m_host, m_port, GET_ORGANIZATION_INFO_ROUTE).Uri;
var uri = m_appContext.CreateUrlForAuthentication(hostSpec, landingUrl);
var request = CreateRequest(uri);
Assert.DoesNotThrow(() => request.GetResponse());
}
public void UserContext_CreateAuthUri_SchemeMatches() {
const string expectedScheme = "spdy";
var apiHost = new HostSpec( expectedScheme, TestConstants.HOST_NAME, TestConstants.PORT );
var userContext = m_appContext.CreateUserContext(
TestConstants.USER_ID, TestConstants.USER_KEY, apiHost );
Uri authUri = userContext.CreateAuthenticatedUri( TestConstants.API_PATH, "GET" );
Assert.AreEqual( expectedScheme, authUri.Scheme );
}
public void AppContext_CreateUserContext_FromAuthCallbackUri_SaveProps_SchemeMatches()
{
const string expectedScheme = "foo";
var apiHost = new HostSpec(expectedScheme, TestConstants.HOST_NAME, TestConstants.PORT);
var userContext = m_appContext.CreateUserContext(m_authCallbackUri, apiHost);
var savedProps = userContext.SaveUserContextProperties();
Assert.AreEqual(expectedScheme, savedProps.Scheme);
}
public void AppContext_CreateUserContext_FromAuthCallbackUri_SaveProps_HostMatches()
{
const string expectedHost = "univ.edu";
var apiHost = new HostSpec("https", expectedHost, 443);
var userContext = m_appContext.CreateUserContext(m_authCallbackUri, apiHost);
var savedProps = userContext.SaveUserContextProperties();
Assert.AreEqual(expectedHost, savedProps.HostName);
}
public void AppContext_CreateUserContext_FromAuthCallbackUri_SaveProps_PortMatches()
{
const int expectedPort = 2228;
var apiHost = new HostSpec("https", TestConstants.HOST_NAME, expectedPort);
var userContext = m_appContext.CreateUserContext(m_authCallbackUri, apiHost);
var savedProps = userContext.SaveUserContextProperties();
Assert.AreEqual(expectedPort, savedProps.Port);
}
public void UserContext_CreateAuthUri_PortMatches()
{
const int expectedPort = 1905;
var apiHost = new HostSpec("https", TestConstants.HOST_NAME, expectedPort);
var userContext = m_appContext.CreateUserContext(
TestConstants.USER_ID, TestConstants.USER_KEY, apiHost);
Uri authUri = userContext.CreateAuthenticatedUri(TestConstants.API_PATH, "GET");
Assert.AreEqual(expectedPort, authUri.Port);
}
public void UserContext_CreateAuthUri_HostNameMatches()
{
const string expectedHost = "myuniv.edu";
var apiHost = new HostSpec("https", expectedHost, TestConstants.PORT);
var userContext = m_appContext.CreateUserContext(
TestConstants.USER_ID, TestConstants.USER_KEY, apiHost);
Uri authUri = userContext.CreateAuthenticatedUri(TestConstants.API_PATH, "GET");
Assert.AreEqual(expectedHost, authUri.Host);
}
public void UserContext_CreateAuthUri_SchemeMatches()
{
const string expectedScheme = "spdy";
var apiHost = new HostSpec(expectedScheme, TestConstants.HOST_NAME, TestConstants.PORT);
var userContext = m_appContext.CreateUserContext(
TestConstants.USER_ID, TestConstants.USER_KEY, apiHost);
Uri authUri = userContext.CreateAuthenticatedUri(TestConstants.API_PATH, "GET");
Assert.AreEqual(expectedScheme, authUri.Scheme);
}
ID2LUserContext ID2LAppContext.CreateUserContext(
Uri authenticationCallbackUri, HostSpec apiHost ) {
var parsingResult = HttpUtility.ParseQueryString( authenticationCallbackUri.Query );
string userId = parsingResult[USER_ID_CALLBACK_PARAMETER];
string userKey = parsingResult[USER_KEY_CALLBACK_PARAMETER];
if( userId == null || userKey == null ) {
return null;
}
return new D2LUserContext( m_appId, m_appKey, userId, userKey, apiHost );
}
public void AppContext_CreateUrlForAuth_RespectsURIEncodingInCallbackURL()
{
var hostSpec = new HostSpec( "https", TestConstants.HOST_NAME, 443 );
Uri uri = m_appContext.CreateUrlForAuthentication( hostSpec, new Uri(TestConstants.ESCAPED_CALLBACK) );
var regex = new Regex(@"x_target=([^&]*)");
var match = regex.Match( uri.AbsoluteUri );
Assert.IsTrue( match.Success );
string val = match.Groups[1].Value;
Assert.AreEqual(Uri.EscapeDataString(TestConstants.ESCAPED_CALLBACK).ToLower(), val.ToLower(), "Full Uri: " + uri.AbsoluteUri);
}
public void AppContext_CreateWebUrlForAuth_LandingUriHasSpecialChars_ReturnsUri_AndQueryParam_x_target_MatchesEncodedLandingUrl()
{
const string unencodedUrl = "http://univ.edu/d2l/api/resource?foo=bar";
string encodedUrl = HttpUtility.UrlEncode(unencodedUrl);
var hostSpec = new HostSpec("https", TestConstants.HOST_NAME, TestConstants.PORT);
Uri uri = m_appContext.CreateUrlForAuthentication(hostSpec, new Uri(unencodedUrl));
string parameter = GetUriQueryParameter(uri, "x_target");
Assert.AreEqual(encodedUrl, parameter);
}
public void SendRequest_AtUrlForAuthentication_StatusCodeIs200()
{
var hostSpec = new HostSpec(m_scheme, m_host, m_port);
var landingUrl = new UriBuilder(m_scheme, m_host, m_port, GET_ORGANIZATION_INFO_ROUTE).Uri;
var uri = m_appContext.CreateUrlForAuthentication(hostSpec, landingUrl);
var request = CreateRequest(uri);
using (var response = request.GetResponse() as HttpWebResponse) {
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
}
}
public void AppContext_CreateUrlForAuth_RespectsURIEncodingInCallbackURL()
{
var hostSpec = new HostSpec("https", TestConstants.HOST_NAME, 443);
Uri uri = m_appContext.CreateUrlForAuthentication(hostSpec, new Uri(TestConstants.ESCAPED_CALLBACK));
var regex = new Regex(@"x_target=([^&]*)");
var match = regex.Match(uri.AbsoluteUri);
Assert.IsTrue(match.Success);
string val = match.Groups[1].Value;
Assert.AreEqual(Uri.EscapeDataString(TestConstants.ESCAPED_CALLBACK).ToLower(), val.ToLower(), "Full Uri: " + uri.AbsoluteUri);
}
ID2LUserContext ID2LAppContext.CreateUserContext(
Uri authenticationCallbackUri, HostSpec apiHost)
{
var parsingResult = HttpUtility.ParseQueryString(authenticationCallbackUri.Query);
string userId = parsingResult[USER_ID_CALLBACK_PARAMETER];
string userKey = parsingResult[USER_KEY_CALLBACK_PARAMETER];
if (userId == null || userKey == null)
{
return(null);
}
return(new D2LUserContext(m_timestampProvider, m_appId, m_appKey, userId, userKey, apiHost));
}
public Context(Configuration config)
{
var appFactory = new D2LAppContextFactory();
ValenceAppContext = appFactory.Create(config["appId"], config["appKey"]);
ValenceHost = new HostSpec("https", config["lmsUrl"], 443);
Client = new RestClient("https://" + config["lmsUrl"]);
if (File.Exists(".bs-auth"))
{
ValenceUserContext = ValenceAppContext.CreateUserContext(new Uri(File.ReadAllText(".bs-auth")), ValenceHost);
}
else
{
ValenceUserContext = null;
}
}
private Uri GenerateAuthRedirect(Uri returnUri, Uri requestUri)
{
if ((requestUri == null) || (returnUri == null))
{
throw new ArgumentNullException();
}
var factory = new D2LAppContextFactory();
var appContext = factory.Create(m_defaultAppId, m_defaultAppKey);
var resultUri = new UriBuilder(requestUri.Scheme,
requestUri.Host,
requestUri.Port,
requestUri.AbsolutePath).Uri;
var host = new HostSpec(returnUri.Scheme, returnUri.Host, returnUri.Port);
var redirectUri = appContext.CreateUrlForAuthentication(host, resultUri);
return(redirectUri);
}
ID2LUserContext ID2LAppContext.CreateUserContext(
string userId, string userKey, HostSpec apiHost ) {
return new D2LUserContext( m_appId, m_appKey, userId, userKey, apiHost );
}
public void SetUpTestObjects()
{
m_testHostSpec = new HostSpec( "https", TestConstants.HOST_NAME, TestConstants.PORT );
m_landingUri = new Uri( TestConstants.API_URL );
}
public void AppContext_CreateWebUrlForAuth_LandingUriHasSpecialChars_ReturnsUri_AndQueryParam_x_target_MatchesEncodedLandingUrl()
{
const string unencodedUrl = "http://univ.edu/d2l/api/resource?foo=bar";
string encodedUrl = HttpUtility.UrlEncode( unencodedUrl );
var hostSpec = new HostSpec( "https", TestConstants.HOST_NAME, TestConstants.PORT );
Uri uri = m_appContext.CreateUrlForAuthentication( hostSpec, new Uri( unencodedUrl ) );
string parameter = GetUriQueryParameter( uri, "x_target" );
Assert.AreEqual( encodedUrl, parameter );
}
/// <summary>
/// Constructs a D2LUserContext with the parameters provided
/// </summary>
/// <param name="appId">The D2L app ID</param>
/// <param name="appKey">The D2L app key</param>
/// <param name="userId">The D2L user ID to be used</param>
/// <param name="userKey">The D2L user key to be used</param>
/// <param name="apiHost">The host information of the server to make API calls to</param>
internal D2LUserContext( string appId, string appKey, string userId, string userKey, HostSpec apiHost ) {
m_appId = appId;
m_appKey = appKey;
m_userId = userId;
m_userKey = userKey;
m_apiHost = apiHost;
m_timestampProvider = ObjectFactory.GetInstance<ITimestampProvider>();
}
ID2LUserContext ID2LAppContext.CreateAnonymousUserContext( HostSpec apiHost ) {
return new D2LUserContext( m_appId, m_appKey, null, null, apiHost );
}
ID2LUserContext ID2LAppContext.CreateUserContext( UserContextProperties savedProps ) {
var apiHost = new HostSpec( savedProps.Scheme, savedProps.HostName, savedProps.Port );
return new D2LUserContext( m_appId, m_appKey, savedProps.UserId, savedProps.UserKey, apiHost );
}
public void AppContext_CreateUserContext_FromAuthCallbackUri_SaveProps_SchemeMatches()
{
const string expectedScheme = "foo";
var apiHost = new HostSpec( expectedScheme, TestConstants.HOST_NAME, TestConstants.PORT );
var userContext = m_appContext.CreateUserContext( m_authCallbackUri, apiHost );
var savedProps = userContext.SaveUserContextProperties();
Assert.AreEqual( expectedScheme, savedProps.Scheme );
}
public void UserContext_CreateAuthUri_HostNameMatches() {
const string expectedHost = "myuniv.edu";
var apiHost = new HostSpec( "https", expectedHost, TestConstants.PORT );
var userContext = m_appContext.CreateUserContext(
TestConstants.USER_ID, TestConstants.USER_KEY, apiHost );
Uri authUri = userContext.CreateAuthenticatedUri( TestConstants.API_PATH, "GET" );
Assert.AreEqual( expectedHost, authUri.Host );
}
public void SendRequest_WhenBadHostSpec_UnhandledException()
{
HostSpec badApiHost = new HostSpec( ChangeScheme( ConfigHelper.Scheme ), ConfigHelper.Host, ConfigHelper.Port );
ID2LUserContext badAnonContext = ContextProvider.AnonUserContext( badApiHost );
HttpWebRequest request = RequestProvider.PrepareApiRequest( badAnonContext, RouteProvider.VersionsRoute );
Assert.Throws<WebException>( () => { using( HttpWebResponse response = request.GetResponse() as HttpWebResponse ) { } } );
}
public void SetUpTestObjects()
{
m_authCallbackUri = TestUtils.CreateTestAuthenticationCallbackUri(
TestConstants.USER_ID, TestConstants.USER_KEY );
m_apiHost = new HostSpec( "https", TestConstants.HOST_NAME, TestConstants.PORT );
}
public void UserContext_CreateAuthUri_PortMatches() {
const int expectedPort = 1905;
var apiHost = new HostSpec( "https", TestConstants.HOST_NAME, expectedPort );
var userContext = m_appContext.CreateUserContext(
TestConstants.USER_ID, TestConstants.USER_KEY, apiHost );
Uri authUri = userContext.CreateAuthenticatedUri( TestConstants.API_PATH, "GET" );
Assert.AreEqual( expectedPort, authUri.Port );
}
