public virtual void SetUp()
{
log4net.Config.XmlConfigurator.Configure(Assembly.GetExecutingAssembly().GetManifestResourceStream("DotNetOpenAuth.Test.Logging.config"));
MessageBase.LowSecurityMode = true;
this.messageDescriptions = new MessageDescriptionCollection();
SetMockHttpContext();
}
public virtual void SetUp()
{
MessageBase.LowSecurityMode = true;
this.messageDescriptions = new MessageDescriptionCollection();
this.HostFactories = new MockingHostFactories();
SetMockHttpContext();
}
static void Main(string[] args)
{
ContractDescription contract = ContractDescription.GetContract(typeof(IContract));
OperationDescription op = contract.Operations[0];
MessageDescriptionCollection mdc = op.Messages;
MessageDescription md = mdc.Find("http://SomeAction");
ICollection <MessageDescription> col = mdc.FindAll("http://SomeAction");
foreach (MessageDescription desc in col)
{
Console.WriteLine("Action = {0}", desc.Action);
}
}
internal static UnauthorizedTokenRequest CreateTestRequestTokenMessage(MessageDescriptionCollection messageDescriptions, MessageReceivingEndpoint endpoint)
{
endpoint = endpoint ?? new MessageReceivingEndpoint("https://www.google.com/accounts/OAuthGetRequestToken", HttpDeliveryMethods.AuthorizationHeaderRequest | HttpDeliveryMethods.GetRequest);
UnauthorizedTokenRequest message = new UnauthorizedTokenRequest(endpoint, Protocol.V10.Version);
message.ConsumerKey = "nerdbank.org";
((ITamperResistantOAuthMessage)message).ConsumerSecret = "nerdbanksecret";
var signedMessage = (ITamperResistantOAuthMessage)message;
signedMessage.HttpMethod = "GET";
signedMessage.SignatureMethod = "HMAC-SHA1";
MessageDictionary dictionary = messageDescriptions.GetAccessor(message);
dictionary["oauth_timestamp"] = "1222665749";
dictionary["oauth_nonce"] = "fe4045a3f0efdd1e019fa8f8ae3f5c38";
dictionary["scope"] = "http://www.google.com/m8/feeds/";
return(message);
}
public OperationDescription(string name, ContractDescription declaringContract)
{
if (name == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("name");
}
if (name.Length == 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new ArgumentOutOfRangeException("name", SR.SFxOperationDescriptionNameCannotBeEmpty));
}
_name = new XmlName(name, true /*isEncoded*/);
if (declaringContract == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("declaringContract");
}
_declaringContract = declaringContract;
_isInitiating = true;
_faults = new FaultDescriptionCollection();
_messages = new MessageDescriptionCollection();
_behaviors = new KeyedByTypeCollection<IOperationBehavior>();
_knownTypes = new Collection<Type>();
}
// Methods
public OperationDescription(string name, ContractDescription declaringContract)
{
this.validateRpcWrapperName = true;
if (name == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("name");
}
if (name.Length == 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("name", SR.GetString("SFxOperationDescriptionNameCannotBeEmpty")));
}
this.name = new XmlName(name, true);
if (declaringContract == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("declaringContract");
}
this.declaringContract = declaringContract;
this.isInitiating = true;
this.isTerminating = false;
this.faults = new FaultDescriptionCollection();
this.messages = new MessageDescriptionCollection();
this.behaviors = new KeyedByTypeCollection<IOperationBehavior>();
this.knownTypes = new Collection<Type>();
}
private CodeExpression[] ExportMessages (MessageDescriptionCollection messages, CodeMemberMethod method, bool return_args)
{
CodeExpression [] args = null;
foreach (MessageDescription md in messages) {
if (md.Direction == MessageDirection.Output) {
if (md.Body.ReturnValue != null) {
ExportDataContract (md.Body.ReturnValue);
method.ReturnType = md.Body.ReturnValue.CodeTypeReference;
}
continue;
}
if (return_args)
args = new CodeExpression [md.Body.Parts.Count];
MessagePartDescriptionCollection parts = md.Body.Parts;
for (int i = 0; i < parts.Count; i++) {
ExportDataContract (parts [i]);
method.Parameters.Add (
new CodeParameterDeclarationExpression (
parts [i].CodeTypeReference,
parts [i].Name));
if (return_args)
args [i] = new CodeArgumentReferenceExpression (parts [i].Name);
}
}
return args;
}
/// <summary>
/// Generates all the message descriptions for a given set of message types and versions.
/// </summary>
/// <param name="messageTypes">The message types.</param>
/// <param name="versions">The message versions.</param>
/// <param name="descriptionsCache">The cache to use when obtaining the message descriptions.</param>
/// <returns>The generated/retrieved message descriptions.</returns>
private static IEnumerable <MessageDescription> GetMessageDescriptions(ICollection <Type> messageTypes, ICollection <Version> versions, MessageDescriptionCollection descriptionsCache)
{
Requires.NotNull(messageTypes, "messageTypes");
Requires.NotNull(descriptionsCache, "descriptionsCache");
Contract.Ensures(Contract.Result <IEnumerable <MessageDescription> >() != null);
// Get all the MessageDescription objects through the standard cache,
// so that perhaps it will be a quick lookup, or at least it will be
// stored there for a quick lookup later.
var messageDescriptions = new List <MessageDescription>(messageTypes.Count * versions.Count);
messageDescriptions.AddRange(from version in versions
from messageType in messageTypes
select descriptionsCache.Get(messageType, version));
return(messageDescriptions);
}
public DataContractMessagesFormatter(MessageDescriptionCollection messages, DataContractFormatAttribute attr)
: base(messages)
{
this.attr = attr;
}
public BaseMessagesFormatter(MessageDescriptionCollection messages)
{
this.messages = messages;
}
public DataContractMessagesFormatter (MessageDescriptionCollection messages, DataContractFormatAttribute attr)
: base (messages)
{
this.attr = attr;
}
public XmlMessagesFormatter (MessageDescriptionCollection messages, XmlSerializerFormatAttribute attr)
: base (messages)
{
this.attr = attr;
}
// Helper method to validate the given ContractDescription has the expected type and operations.
public static string ValidateContractDescription(ContractDescription contract, Type expectedType, ContractDescriptionData expectedContract)
{
OperationDescriptionData[] expectedOperations = expectedContract.Operations;
#if DEBUGGING
DumpContractDescription(contract);
#endif
StringBuilder errorBuilder = new StringBuilder();
string prefix = String.Format(" Contract type: {0}", expectedType);
try
{
// ContractType must match expected type
Type contractType = contract.ContractType;
if (!expectedType.Equals(contractType))
{
errorBuilder.AppendLine(String.Format("{0} expected Type = {0}, actual = {1}", prefix, expectedType, contractType));
}
// Must have exactly the expected number of OperationDescriptions
OperationDescriptionCollection ops = contract.Operations;
if (ops.Count != expectedOperations.Length)
{
errorBuilder.AppendLine(String.Format("{0} operations.Count: expected={1}, actual = {2}", prefix, expectedOperations.Length, ops.Count));
}
foreach (OperationDescriptionData expectedOp in expectedOperations)
{
// Must have each operation by name
OperationDescription op = ops.Find(expectedOp.Name);
if (op == null)
{
errorBuilder.AppendLine(String.Format("{0} operations: could not find operation {1}", prefix, expectedOp.Name));
}
else
{
// Has expected operation name
if (!op.Name.Equals(expectedOp.Name))
{
errorBuilder.AppendLine(String.Format("{0} expected operation Name = {1}, actual = {2}",
prefix, expectedOp.Name, op.Name));
}
// Has expected one-way setting
if (op.IsOneWay != expectedOp.IsOneWay)
{
errorBuilder.AppendLine(String.Format("{0} expected operation {1}.IsOneWay = {2}, actual = {3}",
prefix, expectedOp.Name, expectedOp.IsOneWay, op.IsOneWay));
}
// If contains XxxAsync operation, op.TaskMethod will be non-null. Verify it as expected.
bool hasTask = op.TaskMethod != null;
if (hasTask != expectedOp.HasTask)
{
errorBuilder.AppendLine(String.Format("{0} expected operation {1}.HasTask = {2}, actual = {3}",
prefix, expectedOp.Name, expectedOp.HasTask, hasTask));
}
// Validate each MessageDescription for each OperationDescription
MessageDescriptionCollection messages = op.Messages;
foreach (MessageDescriptionData messageData in expectedOp.Messages)
{
// Must find each expected MessageDescription by Action name
MessageDescription messageDesc = messages.FirstOrDefault(m => m.Action.Equals(messageData.Action));
if (messageDesc == null)
{
errorBuilder.AppendLine(String.Format("{0} could not find expected message action {1} in operation {2}",
prefix, messageData.Action, op.Name));
}
else
{
// Must have expected direction
if (messageDesc.Direction != messageData.Direction)
{
errorBuilder.AppendLine(String.Format("{0} message action {1} expected Direction = {2}, actual = {3}",
prefix, messageData.Action, messageData.Direction, messageDesc.Direction));
}
// MessageType is non-null for operations containing MessageContract types.
// Verify we were able to build a "typed message" from the MessageContract.
if (messageData.MessageType != null && !messageData.MessageType.Equals(messageDesc.MessageType))
{
errorBuilder.AppendLine(String.Format("{0} message action {1} expected MessageType = {2}, actual = {3}",
prefix, messageData.Action, messageData.MessageType, messageDesc.MessageType));
}
}
}
}
}
}
catch (Exception ex)
{
errorBuilder.AppendLine(String.Format("{0} unexpected exception was caught: {1}",
prefix, ex.ToString()));
}
return(errorBuilder.Length == 0 ? null : errorBuilder.ToString());
}
internal TestChannel(MessageDescriptionCollection messageDescriptions, IHostFactories hostFactories = null)
: this(hostFactories) {
this.MessageDescriptions = messageDescriptions;
}
public XmlMessagesFormatter(MessageDescriptionCollection messages, XmlSerializerFormatAttribute attr)
: base(messages)
{
this.attr = attr;
}
internal TestChannel(MessageDescriptionCollection messageDescriptions)
: this()
{
this.MessageDescriptions = messageDescriptions;
}
private CodeExpression[] ExportMessages (MessageDescriptionCollection messages, CodeMemberMethod method, bool return_args)
{
CodeExpression [] args = null;
foreach (MessageDescription md in messages) {
if (!md.IsRequest) {
if (md.Body.ReturnValue != null) {
ExportDataContract (md.Body.ReturnValue);
#if USE_DATA_CONTRACT_IMPORTER
method.ReturnType = md.Body.ReturnValue.CodeTypeReference;
#else
method.ReturnType = new CodeTypeReference (GetCodeTypeName (md.Body.ReturnValue.TypeName));
#endif
}
continue;
}
if (return_args)
args = new CodeExpression [md.Body.Parts.Count];
MessagePartDescriptionCollection parts = md.Body.Parts;
for (int i = 0; i < parts.Count; i++) {
ExportDataContract (parts [i]);
method.Parameters.Add (
new CodeParameterDeclarationExpression (
#if USE_DATA_CONTRACT_IMPORTER
parts [i].CodeTypeReference,
#else
new CodeTypeReference (GetCodeTypeName (parts [i].TypeName)),
#endif
parts [i].Name));
if (return_args)
args [i] = new CodeArgumentReferenceExpression (parts [i].Name);
}
}
return args;
}
internal static UnauthorizedTokenRequest CreateTestRequestTokenMessageNoOAuthVersion(MessageDescriptionCollection messageDescriptions, MessageReceivingEndpoint endpoint)
{
endpoint = endpoint ?? new MessageReceivingEndpoint("https://www.google.com/accounts/OAuthGetRequestToken", HttpDeliveryMethods.AuthorizationHeaderRequest | HttpDeliveryMethods.GetRequest);
var parts = new Dictionary <string, string>();
parts["oauth_consumer_key"] = "nerdbank.org";
parts["oauth_timestamp"] = "1222665749";
parts["oauth_nonce"] = "fe4045a3f0efdd1e019fa8f8ae3f5c38";
parts["scope"] = "http://www.google.com/m8/feeds/";
parts["oauth_signature_method"] = "HMAC-SHA1";
parts["oauth_signature"] = "anything non-empty";
UnauthorizedTokenRequest message = new UnauthorizedTokenRequest(endpoint, Protocol.V10.Version);
MessageDictionary dictionary = messageDescriptions.GetAccessor(message);
MessageSerializer.Get(typeof(UnauthorizedTokenRequest)).Deserialize(parts, dictionary);
return(message);
}
/// <summary>
/// Generates all the message descriptions for a given set of message types and versions.
/// </summary>
/// <param name="messageTypes">The message types.</param>
/// <param name="versions">The message versions.</param>
/// <param name="descriptionsCache">The cache to use when obtaining the message descriptions.</param>
/// <returns>The generated/retrieved message descriptions.</returns>
private static IEnumerable<MessageDescription> GetMessageDescriptions(ICollection<Type> messageTypes, ICollection<Version> versions, MessageDescriptionCollection descriptionsCache)
{
Requires.NotNull(messageTypes, "messageTypes");
Requires.NotNull(descriptionsCache, "descriptionsCache");
Contract.Ensures(Contract.Result<IEnumerable<MessageDescription>>() != null);
// Get all the MessageDescription objects through the standard cache,
// so that perhaps it will be a quick lookup, or at least it will be
// stored there for a quick lookup later.
var messageDescriptions = new List<MessageDescription>(messageTypes.Count * versions.Count);
messageDescriptions.AddRange(from version in versions
from messageType in messageTypes
select descriptionsCache.Get(messageType, version));
return messageDescriptions;
}
public BaseMessagesFormatter (MessageDescriptionCollection messages)
{
this.messages = messages;
}
private static IEnumerable <MessageDescription> GetMessageDescriptions(ICollection <Type> messageTypes, ICollection <Version> versions, MessageDescriptionCollection descriptionsCache)
{
var messageDescriptions = new List <MessageDescription>(messageTypes.Count * versions.Count);
messageDescriptions.AddRange(from version in versions
from messageType in messageTypes
select descriptionsCache.Get(messageType, version));
return(messageDescriptions);
}
static MessageDescriptionCollection MessageContractToMessagesDescription (
Type src, string defaultNamespace, string action)
{
MessageContractAttribute mca =
ContractDescriptionGenerator.GetMessageContractAttribute (src);
if (mca == null)
throw new ArgumentException (String.Format ("Type {0} and its ancestor types do not have MessageContract attribute.", src));
MessageDescriptionCollection messages = new MessageDescriptionCollection ();
messages.Add (ContractDescriptionGenerator.CreateMessageDescription (src, defaultNamespace, action, true, mca));
messages.Add (ContractDescriptionGenerator.CreateMessageDescription (src, defaultNamespace, action, false, mca));
return messages;
}
