private TType CreateProxyWithMixin <TType>(ProxyKind kind, params object[] mixins)
{
var options = new ProxyGenerationOptions(new ProxyNothingHook());
foreach (var mixin in mixins)
{
options.AddMixinInstance(mixin);
}
switch (kind)
{
case ProxyKind.Class:
return((TType)generator.CreateClassProxy(typeof(object), Type.EmptyTypes, options));
case ProxyKind.WithoutTarget:
return((TType)generator.CreateInterfaceProxyWithoutTarget(typeof(IEmpty), Type.EmptyTypes, options));
case ProxyKind.WithTarget:
return((TType)generator.CreateInterfaceProxyWithTarget(typeof(IEmpty), Type.EmptyTypes, new Empty(), options));
case ProxyKind.WithTargetInterface:
return((TType)generator.CreateInterfaceProxyWithTargetInterface(typeof(IEmpty), new Empty(), options));
}
Assert.Fail("Invalid proxy kind {0}", kind);
return(default(TType));
}
public void Explicit_inclusion_of_base_interfaces_not_significant(ProxyKind kind)
{
var first = Proxy(kind, typeof(IBase), typeof(ISub1));
var second = Proxy(kind, typeof(ISub1));
Assert.AreSame(first.GetType(), second.GetType());
}
public void Order_of_additional_interfaces_not_significant(ProxyKind kind)
{
var first = Proxy(kind, typeof(IOne), typeof(ITwo));
var second = Proxy(kind, typeof(ITwo), typeof(IOne));
Assert.AreSame(first.GetType(), second.GetType());
}
private object Proxy(ProxyKind kind, params Type[] additionalInterfacesToProxy)
{
switch (kind)
{
case ProxyKind.Class:
return(generator.CreateClassProxy(
typeof(SimpleClass),
additionalInterfacesToProxy
));
case ProxyKind.WithoutTarget:
return(generator.CreateInterfaceProxyWithoutTarget(
typeof(IEmpty),
additionalInterfacesToProxy
));
case ProxyKind.WithTarget:
return(generator.CreateInterfaceProxyWithTarget(
typeof(IEmpty),
additionalInterfacesToProxy,
new Empty()
));
case ProxyKind.WithTargetInterface:
return(generator.CreateInterfaceProxyWithTarget(
typeof(IEmpty),
additionalInterfacesToProxy,
new Empty()
));
default:
Assert.Fail(string.Format("Invalid proxy kind: {0}", kind));
return(null); //to satisfy the compiler
}
}
public async Task Run(
TestContext ctx,
[WebTestFeatures.SelectProxyKind(IncludeSSL = true)] ProxyKind kind,
HttpServer server, Handler handler, CancellationToken cancellationToken)
{
var oldCount = server.CountRequests;
HttpOperation operation;
if (kind == ProxyKind.Unauthenticated)
{
operation = new TraditionalOperation(
server, handler, true, HttpOperationFlags.AbortAfterClientExits,
HttpStatusCode.ProxyAuthenticationRequired, WebExceptionStatus.ProtocolError);
}
else
{
operation = new TraditionalOperation(
server, handler, true);
}
try {
await operation.Run(ctx, cancellationToken).ConfigureAwait(false);
var newCount = server.CountRequests;
ctx.Assert(newCount, Is.GreaterThan(oldCount), "used proxy");
} finally {
operation.Dispose();
}
}
public async Task RunAuthentication(
TestContext ctx,
[WebTestFeatures.SelectProxyKind(IncludeSSL = true)] ProxyKind kind,
HttpServer server, [AuthenticationType] AuthenticationType authType,
Handler handler, CancellationToken cancellationToken)
{
var authHandler = new AuthenticationHandler(authType, handler);
HttpOperation operation;
if (kind == ProxyKind.Unauthenticated)
{
operation = new TraditionalOperation(server, authHandler, true,
HttpOperationFlags.AbortAfterClientExits,
HttpStatusCode.ProxyAuthenticationRequired, WebExceptionStatus.ProtocolError);
}
else
{
operation = new TraditionalOperation(server, authHandler, true);
}
try {
await operation.Run(ctx, cancellationToken).ConfigureAwait(false);
} finally {
operation.Dispose();
}
}
public void Duplicated_interfaces_not_significant(ProxyKind kind)
{
var first = Proxy(kind, typeof(IOne), typeof(IOne));
var second = Proxy(kind, typeof(IOne));
Assert.AreSame(first.GetType(), second.GetType());
}
private void VerifyProxyTypeCompatilibily(ProxyKind compatibleProxy)
{
if (this.proxyType != ProxyKind.Unspecified && this.proxyType != compatibleProxy)
{
throw new InvalidOperationException("Proxy autodetect is incompatible with manual settings");
}
}
public void Mixin_method_explicit(ProxyKind kind)
{
var proxy = CreateProxyWithMixin <ISimpleInterface>(kind, new SimpleInterfaceExplicit());
var result = -1;
Assert.DoesNotThrow(() => result = proxy.Do());
Assert.AreEqual(5, result);
}
public void Mixin_method_generic(ProxyKind kind)
{
var proxy = CreateProxyWithMixin <IGenericInterface>(kind, new GenericClass());
var result = -1;
Assert.DoesNotThrow(() => result = proxy.GenericMethod <int>());
Assert.AreEqual(0, result);
}
public void Target_method_generic([Values(ProxyKind.WithTarget, ProxyKind.WithTargetInterface)] ProxyKind kind)
{
var proxy = CreateProxy <IGenericInterface>(kind, new GenericClass());
int result = -1;
Assert.DoesNotThrow(() => result = proxy.GenericMethod <int>());
Assert.AreEqual(0, result);
}
public void Target_method_explicit([Values(ProxyKind.WithTarget, ProxyKind.WithTargetInterface)] ProxyKind kind)
{
var proxy = CreateProxy <ISimpleInterface>(kind, new ClassWithExplicitInterface());
int result = -1;
Assert.DoesNotThrow(() => result = proxy.Do());
Assert.AreEqual(5, result);
}
/// <summary>
/// Initializes a new instance of the <see cref="Proxy"/> class with the given proxy settings.
/// </summary>
/// <param name="settings">A dictionary of settings to use with the proxy.</param>
public Proxy(Dictionary <string, object> settings)
{
if (settings == null)
{
throw new ArgumentNullException("settings", "settings dictionary cannot be null");
}
if (settings.ContainsKey("proxyType"))
{
ProxyKind rawType = (ProxyKind)Enum.Parse(typeof(ProxyKind), settings["proxyType"].ToString(), true);
this.Kind = rawType;
}
if (settings.ContainsKey("ftpProxy"))
{
this.FtpProxy = settings["ftpProxy"].ToString();
}
if (settings.ContainsKey("httpProxy"))
{
this.HttpProxy = settings["httpProxy"].ToString();
}
if (settings.ContainsKey("noProxy"))
{
this.NoProxy = settings["noProxy"].ToString();
}
if (settings.ContainsKey("proxyAutoconfigUrl"))
{
this.ProxyAutoConfigUrl = settings["proxyAutoconfigUrl"].ToString();
}
if (settings.ContainsKey("sslProxy"))
{
this.SslProxy = settings["sslProxy"].ToString();
}
if (settings.ContainsKey("socksProxy"))
{
this.SocksProxy = settings["socksProxy"].ToString();
}
if (settings.ContainsKey("socksUsername"))
{
this.SocksUserName = settings["socksUsername"].ToString();
}
if (settings.ContainsKey("socksPassword"))
{
this.SocksPassword = settings["socksPassword"].ToString();
}
if (settings.ContainsKey("autodetect"))
{
this.IsAutoDetect = (bool)settings["autodetect"];
}
}
public void Mixin_method(
[Values(ProxyKind.Class, ProxyKind.WithoutTarget, ProxyKind.WithTarget, ProxyKind.WithTargetInterface)] ProxyKind
kind)
{
var proxy = CreateProxyWithMixin <ISimpleInterface>(kind, new ClassWithInterface());
int result = -1;
Assert.DoesNotThrow(() => result = proxy.Do());
Assert.AreEqual(5, result);
}
/// <summary>
/// Adds addresses to the list of addresses against which the proxy will not be used.
/// </summary>
/// <param name="addressesToAdd">An <see cref="IEnumerable{T}"/> object of arguments to add.</param>
public void AddBypassAddresses(IEnumerable <string> addressesToAdd)
{
if (addressesToAdd == null)
{
throw new ArgumentNullException("addressesToAdd", "addressesToAdd must not be null");
}
this.VerifyProxyTypeCompatilibily(ProxyKind.Manual);
this.proxyKind = ProxyKind.Manual;
this.noProxyAddresses.AddRange(addressesToAdd);
}
private void VerifyProxyTypeCompatilibily(ProxyKind compatibleProxy)
{
if (this.proxyKind != ProxyKind.Unspecified && this.proxyKind != compatibleProxy)
{
throw new InvalidOperationException(
string.Format(CultureInfo.InvariantCulture,
"Specified proxy type {0} is not compatible with current setting {1}",
compatibleProxy.ToString().ToUpperInvariant(), this.proxyKind.ToString().ToUpperInvariant())
);
}
}
public void Mixin_method_out_ref_parameters(ProxyKind kind)
{
var proxy = CreateProxyWithMixin <IWithRefOut>(kind, new WithRefOut());
int[] result = { -1 };
Assert.DoesNotThrow(() => proxy.Did(ref result[0]));
Assert.AreEqual(5, result[0]);
result[0] = -1;
Assert.DoesNotThrow(() => proxy.Do(out result[0]));
Assert.AreEqual(5, result[0]);
}
public void AdditionalInterfaces_method(ProxyKind kind)
{
var proxy = CreateProxyWithAdditionalInterface <IWithRefOut>(kind);
int result = -1;
Assert.DoesNotThrow(() => proxy.Do(out result));
Assert.AreEqual(0, result);
result = -1;
Assert.DoesNotThrow(() => proxy.Did(ref result));
Assert.AreEqual(-1, result);
}
public void Target_method_out_ref_parameters(
[Values(ProxyKind.WithTarget, ProxyKind.WithTargetInterface)] ProxyKind kind)
{
var proxy = CreateProxy <IWithRefOut>(kind, new WithRefOut());
int result = -1;
Assert.DoesNotThrow(() => proxy.Do(out result));
Assert.AreEqual(5, result);
result = -1;
Assert.DoesNotThrow(() => proxy.Did(ref result));
Assert.AreEqual(5, result);
}
public ITypeModificationTracker CreateProxy(Type baseType, ProxyKind proxyKind)
{
ArgumentUtility.CheckNotNull("baseType", baseType);
var incrementedCounter = Interlocked.Increment(ref _counter);
var name = string.Format("{0}_{1}Proxy_{2}", baseType.Name, proxyKind, incrementedCounter);
var attributes = TypeAttributes.Public | TypeAttributes.BeforeFieldInit | (baseType.IsTypePipeSerializable() ? TypeAttributes.Serializable : 0);
var proxyType = CreateType(name, baseType.Namespace, attributes, baseType, null);
var constructorBodies = CopyConstructors(baseType, proxyType);
return(new ProxyTypeModificationTracker(proxyType, constructorBodies));
}
private TType CreateProxy <TType>(ProxyKind kind, TType target)
{
var options = new ProxyGenerationOptions(new ProxyNothingHook());
switch (kind)
{
case ProxyKind.WithTarget:
return((TType)generator.CreateInterfaceProxyWithTarget(typeof(TType), Type.EmptyTypes, target, options));
case ProxyKind.WithTargetInterface:
return((TType)generator.CreateInterfaceProxyWithTargetInterface(typeof(TType), target, options));
}
Assert.Fail("Invalid proxy kind {0}", kind);
return(default(TType));
}
private object Proxy(ProxyKind kind, params Type[] additionalInterfacesToProxy)
{
switch (kind)
{
case ProxyKind.Class:
return generator.CreateClassProxy(typeof(SimpleClass), additionalInterfacesToProxy);
case ProxyKind.WithoutTarget:
return generator.CreateInterfaceProxyWithoutTarget(typeof(IEmpty), additionalInterfacesToProxy);
case ProxyKind.WithTarget:
return generator.CreateInterfaceProxyWithTarget(typeof(IEmpty), additionalInterfacesToProxy, new Empty());
case ProxyKind.WithTargetInterface:
return generator.CreateInterfaceProxyWithTarget(typeof(IEmpty), additionalInterfacesToProxy, new Empty());
default:
Assert.Fail(string.Format("Invalid proxy kind: {0}", kind));
return null; //to satisfy the compiler
}
}
public Task RunAuthentication(
TestContext ctx,
[WebTestFeatures.SelectProxyKind(IncludeSSL = true)] ProxyKind kind,
HttpServer server, [AuthenticationType] AuthenticationType authType,
Handler handler, CancellationToken cancellationToken)
{
var authHandler = new AuthenticationHandler(authType, handler);
if (kind == ProxyKind.Unauthenticated)
{
return(TestRunner.RunTraditional(
ctx, server, authHandler, cancellationToken, false,
HttpStatusCode.ProxyAuthenticationRequired, WebExceptionStatus.ProtocolError));
}
else
{
return(TestRunner.RunTraditional(
ctx, server, authHandler, cancellationToken, false));
}
}
public async Task Run(
TestContext ctx,
[WebTestFeatures.SelectProxyKind(IncludeSSL = true)] ProxyKind kind,
HttpServer server, Handler handler, CancellationToken cancellationToken)
{
var oldCount = server.CountRequests;
if (kind == ProxyKind.Unauthenticated)
{
await TestRunner.RunTraditional(
ctx, server, handler, cancellationToken, false,
HttpStatusCode.ProxyAuthenticationRequired, WebExceptionStatus.ProtocolError);
}
else
{
await TestRunner.RunTraditional(
ctx, server, handler, cancellationToken, false).ConfigureAwait(false);
var newCount = server.CountRequests;
ctx.Assert(newCount, Is.GreaterThan(oldCount), "used proxy");
}
}
private TType CreateProxyWithAdditionalInterface <TType>(ProxyKind kind)
{
var options = new ProxyGenerationOptions(new ProxyNothingHook());
var interfaces = new[] { typeof(TType) };
switch (kind)
{
case ProxyKind.Class:
return((TType)generator.CreateClassProxy(typeof(object), interfaces, options));
case ProxyKind.WithoutTarget:
return((TType)generator.CreateInterfaceProxyWithoutTarget(typeof(IEmpty), interfaces, options));
case ProxyKind.WithTarget:
return((TType)generator.CreateInterfaceProxyWithTarget(typeof(IEmpty), interfaces, new Empty(), options));
case ProxyKind.WithTargetInterface:
return((TType)generator.CreateInterfaceProxyWithTargetInterface(typeof(IEmpty), interfaces, new Empty(), options));
}
Assert.Fail("Invalid proxy kind {0}", kind);
return(default(TType));
}
/// <summary>
/// Creates the proxy object.
/// </summary>
/// <param name="proxyKind">Kind of the proxy.</param>
/// <param name="proxyBaseType">Type of the proxy base.</param>
/// <param name="proxyBaseInstance">The proxy base instance.</param>
/// <returns>System.Object.</returns>
/// <exception cref="System.Exception">Proxy object can not be abstract or interface!</exception>
/// <exception cref="System.NotImplementedException">Not yet! This case reevaluate in other project!\nYou can see in Dynoxygen project in Github.</exception>
/// <remarks>Rachistructure</remarks>
/// TODO Edit XML Comment Template for CreateProxyObject
public static object CreateProxyObject(ProxyKind proxyKind, Type proxyBaseType, object proxyBaseInstance)
{
Type baseType = proxyBaseType;
object proxiesObject = null;
if (baseType.IsAbstract || baseType.IsInterface)
{
throw new Exception("Proxy object can not be abstract or interface!");
}
if (baseType.IsClass)
{
switch (proxyKind)
{
case ProxyKind.RealProxy:
dynamic instance = Convert.ChangeType(proxyBaseInstance, proxyBaseType);
if (instance != null)
{
proxiesObject = new RealProxyBuilder(baseType, ref instance).GetTransparentProxy();
}
else
{
proxiesObject = new RealProxyBuilder(baseType).GetTransparentProxy();
}
break;
case ProxyKind.DynamicProxy:
throw new NotImplementedException("Not yet! This case reevaluate in other project!\nYou can see in Dynoxygen project in Github.");
break;
default:
break;
}
}
return(proxiesObject);
}
private void VerifyProxyTypeCompatilibily(ProxyKind compatibleProxy)
{
if (this.proxyKind != ProxyKind.Unspecified && this.proxyKind != compatibleProxy)
{
throw new InvalidOperationException("Proxy autodetect is incompatible with manual settings");
}
}
private void VerifyProxyTypeCompatilibily(ProxyKind compatibleProxy)
{
if (this.proxyKind != ProxyKind.Unspecified && this.proxyKind != compatibleProxy)
{
string errorMessage = string.Format(
CultureInfo.InvariantCulture,
"Specified proxy type {0} is not compatible with current setting {1}",
compatibleProxy.ToString().ToUpperInvariant(),
this.proxyKind.ToString().ToUpperInvariant());
throw new InvalidOperationException(errorMessage);
}
}
public void Duplicated_interfaces_not_significant(ProxyKind kind)
{
var first = Proxy(kind, typeof(IOne), typeof(IOne));
var second = Proxy(kind, typeof(IOne));
Assert.AreSame(first.GetType(), second.GetType());
}
/// <summary>
/// Initializes a new instance of the <see cref="Proxy"/> class with the given proxy settings.
/// </summary>
/// <param name="settings">A dictionary of settings to use with the proxy.</param>
public Proxy(Dictionary <string, object> settings)
{
if (settings == null)
{
throw new ArgumentNullException("settings", "settings dictionary cannot be null");
}
if (settings.ContainsKey("proxyType"))
{
ProxyKind rawType = (ProxyKind)Enum.Parse(typeof(ProxyKind), settings["proxyType"].ToString(), true);
this.Kind = rawType;
}
if (settings.ContainsKey("ftpProxy"))
{
this.FtpProxy = settings["ftpProxy"].ToString();
}
if (settings.ContainsKey("httpProxy"))
{
this.HttpProxy = settings["httpProxy"].ToString();
}
if (settings.ContainsKey("noProxy"))
{
List <string> bypassAddresses = new List <string>();
string addressesAsString = settings["noProxy"] as string;
if (addressesAsString != null)
{
bypassAddresses.AddRange(addressesAsString.Split(';'));
}
else
{
object[] addressesAsArray = settings["noProxy"] as object[];
if (addressesAsArray != null)
{
foreach (object address in addressesAsArray)
{
bypassAddresses.Add(address.ToString());
}
}
}
this.AddBypassAddresses(bypassAddresses);
}
if (settings.ContainsKey("proxyAutoconfigUrl"))
{
this.ProxyAutoConfigUrl = settings["proxyAutoconfigUrl"].ToString();
}
if (settings.ContainsKey("sslProxy"))
{
this.SslProxy = settings["sslProxy"].ToString();
}
if (settings.ContainsKey("socksProxy"))
{
this.SocksProxy = settings["socksProxy"].ToString();
}
if (settings.ContainsKey("socksUsername"))
{
this.SocksUserName = settings["socksUsername"].ToString();
}
if (settings.ContainsKey("socksPassword"))
{
this.SocksPassword = settings["socksPassword"].ToString();
}
if (settings.ContainsKey("autodetect"))
{
this.IsAutoDetect = (bool)settings["autodetect"];
}
}
public void Explicit_inclusion_of_base_interfaces_not_significant(ProxyKind kind)
{
var first = Proxy(kind, typeof(IBase), typeof(ISub1));
var second = Proxy(kind, typeof(ISub1));
Assert.AreSame(first.GetType(), second.GetType());
}
public void Order_of_additional_interfaces_not_significant(ProxyKind kind)
{
var first = Proxy(kind, typeof(IOne), typeof(ITwo));
var second = Proxy(kind, typeof(ITwo), typeof(IOne));
Assert.AreSame(first.GetType(), second.GetType());
}
public UseProxyKindAttribute(ProxyKind kind)
{
this.kind = kind;
this.identifier = Type.Name;
}
/// <summary>
/// Creates the proxy object.
/// </summary>
/// <typeparam name="TProxyBaseType">The type of the proxy base type.</typeparam>
/// <param name="kind">The kind.</param>
/// <returns>TProxyBaseType.</returns>
/// <remarks>Rachistructure</remarks>
public static TProxyBaseType CreateProxyObject <TProxyBaseType>(ProxyKind kind = ProxyKind.RealProxy)
{
return((TProxyBaseType)CreateProxyObject(kind, typeof(TProxyBaseType), null));
}
/// <summary>
/// Initializes a new instance of the <see cref="Proxy"/> class with the given proxy settings.
/// </summary>
/// <param name="settings">A dictionary of settings to use with the proxy.</param>
public Proxy(Dictionary <string, object> settings)
{
if (settings == null)
{
throw new ArgumentNullException("settings", "settings dictionary cannot be null");
}
if (settings.ContainsKey("proxyType") && settings["proxyType"] != null)
{
// Special-case "PAC" since that is the correct serialization.
if (settings["proxyType"].ToString().ToLowerInvariant() == "pac")
{
this.Kind = ProxyKind.ProxyAutoConfigure;
}
else
{
ProxyKind rawType = (ProxyKind)Enum.Parse(typeof(ProxyKind), settings["proxyType"].ToString(), true);
this.Kind = rawType;
}
}
if (settings.ContainsKey("ftpProxy") && settings["ftpProxy"] != null)
{
this.FtpProxy = settings["ftpProxy"].ToString();
}
if (settings.ContainsKey("httpProxy") && settings["httpProxy"] != null)
{
this.HttpProxy = settings["httpProxy"].ToString();
}
if (settings.ContainsKey("noProxy") && settings["noProxy"] != null)
{
List <string> bypassAddresses = new List <string>();
string addressesAsString = settings["noProxy"] as string;
if (addressesAsString != null)
{
bypassAddresses.AddRange(addressesAsString.Split(';'));
}
else
{
object[] addressesAsArray = settings["noProxy"] as object[];
if (addressesAsArray != null)
{
foreach (object address in addressesAsArray)
{
bypassAddresses.Add(address.ToString());
}
}
}
this.AddBypassAddresses(bypassAddresses);
}
if (settings.ContainsKey("proxyAutoconfigUrl") && settings["proxyAutoconfigUrl"] != null)
{
this.ProxyAutoConfigUrl = settings["proxyAutoconfigUrl"].ToString();
}
if (settings.ContainsKey("sslProxy") && settings["sslProxy"] != null)
{
this.SslProxy = settings["sslProxy"].ToString();
}
if (settings.ContainsKey("socksProxy") && settings["socksProxy"] != null)
{
this.SocksProxy = settings["socksProxy"].ToString();
}
if (settings.ContainsKey("socksUsername") && settings["socksUsername"] != null)
{
this.SocksUserName = settings["socksUsername"].ToString();
}
if (settings.ContainsKey("socksPassword") && settings["socksPassword"] != null)
{
this.SocksPassword = settings["socksPassword"].ToString();
}
if (settings.ContainsKey("socksVersion") && settings["socksVersion"] != null)
{
this.SocksVersion = Convert.ToInt32(settings["socksVersion"]);
}
if (settings.ContainsKey("autodetect") && settings["autodetect"] != null)
{
this.IsAutoDetect = (bool)settings["autodetect"];
}
}
