/// <summary>
/// Creates a new Discord RPC Client using the steam uri scheme.
/// </summary>
/// <param name="applicationID">The ID of the application created at discord's developers portal.</param>
/// <param name="steamID">The steam ID of the app. This is used to launch Join / Spectate through steam URI scheme instead of manual launching</param>
/// <param name="registerUriScheme">Should a URI scheme be registered for Join / Spectate functionality? If false, the Join / Spectate functionality will be disabled.</param>
/// <param name="pipe">The pipe to connect too. -1 for first available pipe.</param>
/// <param name="client">The pipe client to use and communicate to discord through</param>
/// <param name="logger">The logger used to report messages. Its recommended to assign here so it can report the results of RegisterUriScheme.</param>
public DiscordRpcClient(string applicationID, string steamID, bool registerUriScheme, int pipe, INamedPipeClient client, ILogger logger = null)
{
//Store our values
ApplicationID = applicationID;
SteamID = steamID;
HasRegisteredUriScheme = registerUriScheme;
ProcessID = System.Diagnostics.Process.GetCurrentProcess().Id;
_pipe = pipe;
_logger = logger == null ? new NullLogger() : logger;
//If we are to register the URI scheme, do so.
//The UriScheme.RegisterUriScheme function takes steamID as a optional parameter, its null by default.
// this means it will handle a null steamID for us :)
if (registerUriScheme)
{
UriScheme.RegisterUriScheme(_logger, applicationID, steamID);
}
//Create the RPC client
connection = new RpcConnection(ApplicationID, ProcessID, TargetPipe, client)
{
ShutdownOnly = _shutdownOnly
};
connection.Logger = this._logger;
}
/// <summary>
/// Initializes a new instance of the <see cref="NetWatcher"/> class.
/// </summary>
/// <param name="requestUri">The request URI to monitor for changes.</param>
/// <param name="period">The time interval between periodic signaling for changes of provided <paramref name="requestUri"/>.</param>
/// <param name="dueTime">The amount of time to delay before the associated <see cref="Watcher"/> starts signaling. Specify negative one (-1) milliseconds to prevent the signaling from starting. Specify zero (0) to start the signaling immediately.</param>
/// <param name="checkResponseData">if set to <c>true</c>, a MD5 hash check of the response data is used to determine a change state of the resource; <c>false</c> to check only for the last modification of the resource.</param>
/// <remarks>Monitors the provided <paramref name="requestUri"/> for changes in an interval specified by <paramref name="period"/>, determined by <paramref name="checkResponseData"/>.</remarks>
public NetWatcher(Uri requestUri, TimeSpan dueTime, TimeSpan period, bool checkResponseData) : base(dueTime, period)
{
if (requestUri == null)
{
throw new ArgumentNullException(nameof(requestUri));
}
UriScheme scheme = UriSchemeConverter.FromString(requestUri.Scheme);
switch (scheme)
{
case UriScheme.File:
case UriScheme.Ftp:
case UriScheme.Http:
case UriScheme.Https:
break;
default:
throw new ArgumentException("The provided Uri does not have a valid scheme attached. Allowed schemes for now is File, FTP, HTTP or HTTPS.", nameof(requestUri));
}
RequestUri = requestUri;
Scheme = scheme;
UtcCreated = DateTime.UtcNow;
CheckResponseData = checkResponseData;
Signature = SignatureDefault;
}
public void CreateWithUriRequestReturnsCorrectResult()
{
// Fixture setup
var request = typeof(Uri);
object expectedUriScheme = new UriScheme("ftp");
object expectedAuthority = Guid.NewGuid().ToString();
var context = new DelegatingSpecimenContext
{
OnResolve = r =>
{
if (typeof(UriScheme).Equals(r))
{
return(expectedUriScheme);
}
if (typeof(string).Equals(r))
{
return(expectedAuthority);
}
return(new NoSpecimen(r));
}
};
var sut = new UriGenerator();
// Exercise system
var result = (Uri)sut.Create(request, context);
// Verify outcome
var expectedUri = new Uri(expectedUriScheme + "://" + expectedAuthority);
Assert.Equal(expectedUri, result);
// Teardown
}
public void ExistingSchemeIsUpdated(UriScheme scheme, string expectedScheme)
{
FluentUriBuilder.From(fullTestUri)
.Scheme(scheme)
.ToUri()
.Scheme
.Should().Be(expectedScheme);
}
public static string ToName(this UriScheme uriScheme)
{
var tokensByUriScheme = UriSchemeNames.NamesByUriScheme.Value;
var token = tokensByUriScheme[uriScheme];
return(token);
}
public BindingConfiguration(string url, UriScheme scheme, SiteType siteType, string certificate, bool requireSni = false)
{
Url = url;
Scheme = scheme;
SiteType = siteType;
Certificate = certificate;
RequireSni = requireSni;
}
public BindingConfiguration(string url, UriScheme scheme, SiteType siteType, string certificate, bool requireSni = false)
{
Url = url;
Scheme = scheme;
SiteType = siteType;
Certificate = certificate;
RequireSni = requireSni;
}
/// <summary>
/// <c>BasicClient</c> constructor.
/// </summary>
/// <param name="host">The hostname of the InSites server.</param>
/// <param name="username">A username associated with an InSites login.</param>
/// <param name="password">The password of the specified user.</param>
public APIClient(UriScheme scheme, string host, string username, string password, int port)
{
Byte[] byteAuthorizationToken = System.Text.Encoding.ASCII.GetBytes(username + ":" + password);
this.authHeaderValue = Convert.ToBase64String(byteAuthorizationToken);
this.hostIP = host;
this.scheme = scheme.ToString().ToLower();
this.sessionCookie = string.Empty;
}
/// <summary>
/// Converts the specified <paramref name="value"/> of a protocol-relative <see cref="string"/> to its equivalent <see cref="Uri"/>.
/// </summary>
/// <param name="value">The <see cref="string"/> to be converted.</param>
/// <param name="protocol">The desired protocol of the <paramref name="value"/> to be converted.</param>
/// <param name="relativeReference">The relative reference that <paramref name="value"/> must begin with. Default is <see cref="StringUtility.NetworkPathReference"/>.</param>
/// <returns>An <see cref="Uri"/> that is equivalent to <paramref name="value"/> with the specified <paramref name="protocol"/> as <see cref="Uri.Scheme"/>.</returns>
public static Uri FromProtocolRelativeUri(string value, UriScheme protocol, string relativeReference)
{
Validator.ThrowIfNullOrEmpty(value, nameof(value));
Validator.ThrowIfNullOrEmpty(relativeReference, nameof(relativeReference));
Validator.ThrowIfFalse(value.StartsWith(relativeReference, StringComparison.OrdinalIgnoreCase), nameof(value), string.Format(CultureInfo.InvariantCulture, "The specified value did not start with the the expected value of: {0}.", relativeReference));
int relativeReferenceLength = relativeReference.Length;
return(new Uri(value.Remove(0, relativeReferenceLength).Insert(0, string.Format(CultureInfo.InvariantCulture, "{0}://", StringConverter.FromUriScheme(protocol)))));
}
public void SchemeIsUsedIfSpecified(UriScheme scheme, string expectedScheme)
{
FluentUriBuilder.Create()
.Scheme(scheme)
.Host("example.com")
.ToUri()
.Scheme
.Should().Be(expectedScheme);
}
public void SutIsEquatable()
{
// Arrange
// Act
var sut = new UriScheme();
// Assert
Assert.IsAssignableFrom <IEquatable <UriScheme> >(sut);
}
internal static int DefaultPortForScheme(String name)
{
UriScheme entry = (UriScheme)schemes[name];
if ((entry = (UriScheme)schemes[name]) != null)
{
return(entry.port);
}
return(-1);
}
public void SutIsEquatable()
{
// Fixture setup
// Exercise system
var sut = new UriScheme();
// Verify outcome
Assert.IsAssignableFrom <IEquatable <UriScheme> >(sut);
// Teardown
}
public ToggleHttpHttpsAttribute(
UriScheme uriScheme = UriScheme.Http)
{
TargetUriScheme = uriScheme;
#if DEBUG
//set DEBUG ports
HttpPort = 55892;
HttpsPort = 44301;
#endif
}
public void SutEqualsOtherSutWhenBothSchemesAreDefault()
{
// Arrange
var sut = new UriScheme();
var other = new UriScheme();
// Act
bool result = sut.Equals(other);
// Assert
Assert.True(result);
}
public void InitializeWithDefaultConstructorSetsCorrectScheme()
{
// Arrange
var sut = new UriScheme();
string expectedScheme = "http";
// Act
string result = sut.Scheme;
// Assert
Assert.Equal(expectedScheme, result);
}
/// <summary>
/// Create the specified URI.
/// </summary>
/// <param name="uri">The URI.</param>
/// <returns></returns>
private UriScheme Creat(Uri uri)
{
UriScheme temp = new UriScheme
{
Host = uri.Host,
Segments = Segments(uri).ToList(),
Parameters = Parameters(uri).ToList()
};
return(temp);
}
public void GetHashCodeWhenSchemeIsDefaultReturnsCorrectResult()
{
// Arrange
var sut = new UriScheme();
// Act
int result = sut.GetHashCode();
// Assert
int expectedHashCode = "http".GetHashCode();
Assert.Equal(expectedHashCode, result);
}
public void SutDoesNotEqualNullObject()
{
// Arrange
var sut = new UriScheme();
object other = null;
// Act
bool result = sut.Equals(other);
// Assert
Assert.False(result);
}
public void ToStringReturnsCorrectResult()
{
// Arrange
string expected = "http";
var sut = new UriScheme("http");
// Act
var result = sut.ToString();
// Assert
Assert.Equal(expected, result);
}
public void InitializeWithSchemeParameterSetsCorrectScheme()
{
// Arrange
string expectedScheme = "http";
var sut = new UriScheme("http");
// Act
string result = sut.Scheme;
// Assert
Assert.Equal(expectedScheme, result);
}
public void SutDoesNotEqualAnonymousObject()
{
// Arrange
var sut = new UriScheme();
var anonymousObject = new object();
// Act
bool result = sut.Equals(anonymousObject);
// Assert
Assert.False(result);
}
public void InitializeWithSchemeParameterSetsCorrectScheme()
{
// Fixture setup
string expectedScheme = "http";
var sut = new UriScheme("http");
// Exercise system
string result = sut.Scheme;
// Verify outcome
Assert.Equal(expectedScheme, result);
// Teardown
}
public void SutDoesNotEqualOtherSutWhenSchemesDiffer()
{
// Arrange
var sut = new UriScheme("a");
var other = new UriScheme("b");
// Act
bool result = sut.Equals(other);
// Assert
Assert.False(result);
}
public void ToStringReturnsCorrectResult()
{
// Fixture setup
string expected = "http";
var sut = new UriScheme("http");
// Exercise system
var result = sut.ToString();
// Verify outcome
Assert.Equal(expected, result);
// Teardown
}
public void InitializeWithDefaultConstructorSetsCorrectScheme()
{
// Fixture setup
var sut = new UriScheme();
string expectedScheme = "http";
// Exercise system
string result = sut.Scheme;
// Verify outcome
Assert.Equal(expectedScheme, result);
// Teardown
}
public void ToStringReturnsCorrectResult()
{
// Fixture setup
string expected = "http";
var sut = new UriScheme("http");
// Exercise system
var result = sut.ToString();
// Verify outcome
Assert.Equal(expected, result);
// Teardown
}
public void InitializeWithSchemeParameterSetsCorrectScheme()
{
// Fixture setup
string expectedScheme = "http";
var sut = new UriScheme("http");
// Exercise system
string result = sut.Scheme;
// Verify outcome
Assert.Equal(expectedScheme, result);
// Teardown
}
public void GetHashCodeWhenSchemeIsDefaultReturnsCorrectResult()
{
// Fixture setup
var sut = new UriScheme();
// Exercise system
int result = sut.GetHashCode();
// Verify outcome
int expectedHashCode = "http".GetHashCode();
Assert.Equal(expectedHashCode, result);
// Teardown
}
public void InitializeWithDefaultConstructorSetsCorrectScheme()
{
// Fixture setup
var sut = new UriScheme();
string expectedScheme = "http";
// Exercise system
string result = sut.Scheme;
// Verify outcome
Assert.Equal(expectedScheme, result);
// Teardown
}
public void SutEqualsOtherSutWhenBothSchemesAreDefault()
{
// Fixture setup
var sut = new UriScheme();
var other = new UriScheme();
// Exercise system
bool result = sut.Equals(other);
// Verify outcome
Assert.True(result);
// Teardown
}
public void SutDoesNotEqualNullObject()
{
// Fixture setup
var sut = new UriScheme();
object other = null;
// Exercise system
bool result = sut.Equals(other);
// Verify outcome
Assert.False(result);
// Teardown
}
public HttpRequestUriBuilder(UriScheme uriScheme, string host, string path = "")
{
// https://tools.ietf.org/html/rfc7230#section-2.7.3
// The scheme and host are case-insensitive and normally provided in lowercase;
// all other components are compared in a case-sensitive manner.
if (host is null)
{
throw new FormatException("Host identifier cannot be null.");
}
var h = host.Trim().TrimEnd('/').TrimStart(uriScheme.ToString() + "://", StringComparison.OrdinalIgnoreCase);
// https://tools.ietf.org/html/rfc7230#section-2.7.1
// A sender MUST NOT generate an "http" URI with an empty host identifier.
if (h == "")
{
throw new FormatException("Host identifier is empty.");
}
Host = h;
Scheme = uriScheme.ToString().ToLowerInvariant();
if (uriScheme == UriScheme.http)
{
// https://tools.ietf.org/html/rfc7230#section-2.7.1
// [http] If the port subcomponent is empty or not given, TCP port 80(the reserved port
// for WWW services) is the default.
Port = 80;
}
else if (uriScheme == UriScheme.https)
{
// https://tools.ietf.org/html/rfc7230#section-2.7.2
// [https] TCP port 443 is the default if the port subcomponent is empty or not given
Port = 443;
}
// Because we want to tolerate http:// and https:// in the host we also want to make sure it does not contradict the scheme
foreach (UriScheme scheme in Enum.GetValues(typeof(UriScheme)))
{
// if host starts with http:// or https:// then check
if (host.StartsWith(scheme.ToString() + "://", StringComparison.OrdinalIgnoreCase))
{
// if the currently iterated scheme does not equal the provided scheme
if (scheme != uriScheme)
{
throw new FormatException("uriScheme not consistent with host identifier.");
}
}
}
Path = path;
}
/// <summary>
/// Konstruktor
/// </summary>
/// <param name="scheme"></param>
/// <param name="authority">Die Zuständigkeit (z.B. [email protected]:8080)</param>
/// <param name="uri">Die Uri</param>
public UriAbsolute(UriScheme scheme, UriAuthority authority, IUri uri)
{
Scheme = scheme;
Authority = authority;
if (uri != null)
{
(Path as List <IUriPathSegment>).AddRange(uri.Path.Select(x => new UriPathSegment(x.Value, x.Tag) as IUriPathSegment));
(Query as List <UriQuerry>).AddRange(uri.Query.Select(x => new UriQuerry(x.Key, x.Value)));
Fragment = uri.Fragment;
}
}
public void CreateWithUriSchemeRequestReturnsCorrectResult()
{
// Fixture setup
var sut = new UriSchemeGenerator();
var request = typeof(UriScheme);
// Exercise system
var dummyContext = new DelegatingSpecimenContext();
var result = sut.Create(request, dummyContext);
// Verify outcome
var expectedResult = new UriScheme();
Assert.Equal(expectedResult, result);
// Teardown
}
public void SutDoesNotEqualOtherSutWhenSchemesDiffer()
{
// Fixture setup
var sut = new UriScheme("a");
var other = new UriScheme("b");
// Exercise system
bool result = sut.Equals(other);
// Verify outcome
Assert.False(result);
// Teardown
}
public void SutDoesNotEqualNullObject()
{
// Fixture setup
var sut = new UriScheme();
object other = null;
// Exercise system
bool result = sut.Equals(other);
// Verify outcome
Assert.False(result);
// Teardown
}
public BindingConfiguration(string url, UriScheme scheme, SiteType siteType)
: this(url, scheme, siteType, null, false)
{
}
public void SutIsEquatable()
{
// Fixture setup
// Exercise system
var sut = new UriScheme();
// Verify outcome
Assert.IsAssignableFrom<IEquatable<UriScheme>>(sut);
// Teardown
}
public void GetHashCodeWhenSchemeIsNotDefaultReturnsCorrectResult()
{
// Fixture setup
var scheme = "https";
var sut = new UriScheme(scheme);
// Exercise system
int result = sut.GetHashCode();
// Verify outcome
int expectedHashCode = scheme.GetHashCode();
Assert.Equal(expectedHashCode, result);
// Teardown
}
private static Uri CreateAnonymous(UriScheme scheme, string authority)
{
return new Uri(scheme + "://" + authority);
}
public void SutEqualsOtherSutWhenSchemesAreEqual()
{
// Fixture setup
var scheme = "https";
var sut = new UriScheme(scheme);
var other = new UriScheme(scheme);
// Exercise system
bool result = sut.Equals(other);
// Verify outcome
Assert.True(result);
// Teardown
}
public void ExistingSchemeIsUpdated(UriScheme scheme, string expectedScheme)
{
FluentUriBuilder.From(fullTestUri)
.Scheme(scheme)
.ToUri()
.Scheme
.Should().Be(expectedScheme);
}
public void CreateWithUriRequestReturnsCorrectResult()
{
// Fixture setup
var request = typeof(Uri);
object expectedUriScheme = new UriScheme("ftp");
object expectedAuthority = Guid.NewGuid().ToString();
var context = new DelegatingSpecimenContext
{
OnResolve = r =>
{
if (typeof(UriScheme).Equals(r))
{
return expectedUriScheme;
}
if (typeof(string).Equals(r))
{
return expectedAuthority;
}
return new NoSpecimen(r);
}
};
var sut = new UriGenerator();
// Exercise system
var result = (Uri)sut.Create(request, context);
// Verify outcome
var expectedUri = new Uri(expectedUriScheme + "://" + expectedAuthority);
Assert.Equal(expectedUri, result);
// Teardown
}
/// <summary>
/// Initializes a new instance of the <see cref="UrlBuilder"/> class
/// with the specified scheme and host.
/// </summary>
/// <param name="scheme">An Internet access protocol.</param>
/// <param name="host">A DNS-style domain name or IP address.</param>
/// <param name="port">An IP port number for the service.</param>
/// <param name="path">The path to the Internet resource.</param>
/// <param name="extraValue">A query string or fragment identifier.</param>
/// <exception cref="System.ArgumentException">
/// <paramref name="extraValue"/> is neither <see langword="null"/>
/// nor <see cref="System.String.Empty">System.String.Empty</see>, nor
/// does a valid fragment identifier begin with a number sign (#), nor
/// a valid query string begin with a question mark (?).
/// </exception>
/// <exception cref="System.ArgumentOutOfRangeException">
/// <paramref name="port"/> is less than -1 or greater than 65,535.
/// </exception>
public UrlBuilder(UriScheme scheme, string host, int port, string path, string extraValue)
{
this.builder = new UriBuilder(scheme, host, port, path, extraValue);
this.queryParameters = new QueryStringParametersDictionary(this.builder.Query);
}
public void SutDoesNotEqualAnonymousObject()
{
// Fixture setup
var sut = new UriScheme();
var anonymousObject = new object();
// Exercise system
bool result = sut.Equals(anonymousObject);
// Verify outcome
Assert.False(result);
// Teardown
}
/// <summary>
/// Initializes a new instance of the <see cref="UrlBuilder"/> class
/// with the specified scheme and host.
/// </summary>
/// <param name="scheme">An Internet access protocol.</param>
/// <param name="host">A DNS-style domain name or IP address.</param>
/// <param name="port">An IP port number for the service.</param>
/// <param name="path">The path to the Internet resource.</param>
/// <exception cref="System.ArgumentOutOfRangeException">
/// <paramref name="port"/> is less than -1 or greater than 65,535.
/// </exception>
public UrlBuilder(UriScheme scheme, string host, int port, string path)
{
this.builder = new UriBuilder(scheme, host, port, path);
this.queryParameters = new QueryStringParametersDictionary();
}
public void SutEqualsOtherObjectWhenBothSchemesAreDefault()
{
// Fixture setup
var sut = new UriScheme();
object other = new UriScheme();
// Exercise system
bool result = sut.Equals(other);
// Verify outcome
Assert.True(result);
// Teardown
}
/// <summary>
/// Sets or updates the protocol scheme of the URI.
/// </summary>
/// <param name="scheme">
/// The new value of the protocol scheme.
/// </param>
/// <returns>
/// A <see cref="FluentUriBuilder"/> instance to allow chaining.
/// </returns>
public FluentUriBuilder Scheme(UriScheme scheme)
{
switch (scheme)
{
case UriScheme.File:
this.scheme = "file";
break;
case UriScheme.Ftp:
this.scheme = "ftp";
break;
case UriScheme.Gopher:
this.scheme = "gopher";
break;
case UriScheme.Http:
this.scheme = "http";
break;
case UriScheme.Https:
this.scheme = "https";
break;
case UriScheme.Mailto:
this.scheme = "mailto";
break;
case UriScheme.News:
this.scheme = "news";
break;
default:
throw new ArgumentOutOfRangeException(nameof(scheme));
}
return this;
}
public void SchemeIsUsedIfSpecified(UriScheme scheme, string expectedScheme)
{
FluentUriBuilder.Create()
.Scheme(scheme)
.Host("example.com")
.ToUri()
.Scheme
.Should().Be(expectedScheme);
}
