|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System;
using System.Runtime.CompilerServices;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Description;
using Infrastructure.Common;
using TestTypes;
using Xunit;
public static class ContractDescriptionTest
{
[WcfFact]
public static void Manually_Generated_Service_Type()
{
// -----------------------------------------------------------------------------------------------
// IDescriptionTestsService:
// Contains 2 operations, synchronous versions only.
// -----------------------------------------------------------------------------------------------
string results = ContractDescriptionTestHelper.ValidateContractDescription<IDescriptionTestsService>(new ContractDescriptionData
{
Operations = new OperationDescriptionData[]
{
new OperationDescriptionData
{
Name = "MessageRequestReply",
IsOneWay = false,
HasTask = false,
Messages = new MessageDescriptionData[]
{
new MessageDescriptionData
{
Action = "http://tempuri.org/IDescriptionTestsService/MessageRequestReply",
Direction = MessageDirection.Input
},
new MessageDescriptionData
{
Action = "http://tempuri.org/IDescriptionTestsService/MessageRequestReplyResponse",
Direction = MessageDirection.Output
}
}
},
new OperationDescriptionData
{
Name = "Echo",
IsOneWay = false,
HasTask = false,
Messages = new MessageDescriptionData[]
{
new MessageDescriptionData
{
Action = "http://tempuri.org/IDescriptionTestsService/Echo",
Direction = MessageDirection.Input
},
new MessageDescriptionData
{
Action = "http://tempuri.org/IDescriptionTestsService/EchoResponse",
Direction = MessageDirection.Output
}
}
}
}
});
// Assert.True because results contains informative error failure
Assert.True(results == null, results);
}
[WcfFact]
public static void SvcUtil_Generated_Service_Type()
{
// -----------------------------------------------------------------------------------------------
// IDescriptionTestsServiceGenerated:
// Generated via SvcUtil and contains sync and Task versions of same 2 operations as above.
// -----------------------------------------------------------------------------------------------
string results = ContractDescriptionTestHelper.ValidateContractDescription<IDescriptionTestsServiceGenerated>(new ContractDescriptionData
{
Operations = new OperationDescriptionData[]
{
new OperationDescriptionData
{
Name = "MessageRequestReply",
IsOneWay = false,
HasTask = true,
Messages = new MessageDescriptionData[]
{
new MessageDescriptionData
{
Action = "http://tempuri.org/IDescriptionTestsService/MessageRequestReply",
Direction = MessageDirection.Input
},
new MessageDescriptionData
{
Action = "http://tempuri.org/IDescriptionTestsService/MessageRequestReplyResponse",
Direction = MessageDirection.Output
}
}
},
new OperationDescriptionData
{
Name = "Echo",
IsOneWay = false,
HasTask = true,
Messages = new MessageDescriptionData[]
{
new MessageDescriptionData
{
Action = "http://tempuri.org/IDescriptionTestsService/Echo",
Direction = MessageDirection.Input
},
new MessageDescriptionData
{
Action = "http://tempuri.org/IDescriptionTestsService/EchoResponse",
Direction = MessageDirection.Output
}
}
}
}
});
// Assert.True because results contains informative error failure
Assert.True(results == null, results);
}
[WcfFact]
public static void MessageContract_Service_Type()
{
// -----------------------------------------------------------------------------------------------
// IFeedbackService:
// Service exposes a single async operation that uses MessageContract.
// This variant tests the a MessageContract can build "typed messages" for the ContractDescription.
// -----------------------------------------------------------------------------------------------
string results = ContractDescriptionTestHelper.ValidateContractDescription<IFeedbackService>(new ContractDescriptionData
{
Operations = new OperationDescriptionData[]
{
new OperationDescriptionData
{
Name = "Feedback",
IsOneWay = false,
HasTask = true,
Messages = new MessageDescriptionData[]
{
new MessageDescriptionData
{
Action = "http://app.my.com/MyFeedback/Feedback",
Direction = MessageDirection.Input,
MessageType = typeof(FeedbackRequest)
},
new MessageDescriptionData
{
Action = "*",
Direction = MessageDirection.Output,
MessageType = typeof(FeedbackResponse)
}
}
}
}
});
// Assert.True because results contains informative error failure
Assert.True(results == null, results);
}
[WcfFact]
public static void Duplex_ContractDescription_Builds_From_ServiceContract()
{
// Arrange
CustomBinding binding = new CustomBinding();
binding.Elements.Add(new TextMessageEncodingBindingElement());
binding.Elements.Add(new HttpTransportBindingElement());
EndpointAddress address = new EndpointAddress(FakeAddress.HttpAddress);
//Act
ChannelFactory<IDuplexHello> factory = new ChannelFactory<IDuplexHello>(binding, address);
ContractDescription contract = factory.Endpoint.Contract;
// Assert
Assert.NotNull(contract);
Assert.Equal<Type>(typeof(IHelloCallbackContract), contract.CallbackContractType);
// Duplex contracts capture operations from both the service and the callback type
Assert.Equal(2, contract.Operations.Count);
OperationDescription operation = contract.Operations.Find("Hello");
Assert.True(operation != null, "Failed to find Hello operation in contract.");
Assert.True(operation.IsOneWay, "Expected Hello operation to be IsOneWay.");
operation = contract.Operations.Find("Reply");
Assert.True(operation != null, "Failed to find Reply operation in contract.");
Assert.True(operation.IsOneWay, "Expected Reply operation to be IsOneWay.");
}
[WcfFact]
public static void ContractDescription_GetContract()
{
// Simple validation of the newly exposed "public ContractDescription GetContract(Type contractType);" method
ContractDescription contractDescription = ContractDescription.GetContract(typeof(IDescriptionTestsService));
Assert.Equal(typeof(IDescriptionTestsService).Name, contractDescription.ContractType.Name);
Assert.Equal("http://tempuri.org/", contractDescription.Namespace);
}
[WcfFact]
public static void OperationDescription_BeginEndSyncMethod_Property()
{
ContractDescription contractDescription = ContractDescription.GetContract(typeof(IDescriptionTestsServiceBeginEndGenerated));
Assert.Equal(2, contractDescription.Operations.Count);
foreach(OperationDescription operation in contractDescription.Operations)
{
Assert.NotNull(operation.BeginMethod);
Assert.NotNull(operation.EndMethod);
if(operation.Name.Equals("Echo"))
{
Assert.Equal(typeof(IDescriptionTestsServiceBeginEndGenerated).GetMethod(nameof(IDescriptionTestsServiceBeginEndGenerated.BeginEcho)), operation.BeginMethod);
Assert.Equal(typeof(IDescriptionTestsServiceBeginEndGenerated).GetMethod(nameof(IDescriptionTestsServiceBeginEndGenerated.EndEcho)), operation.EndMethod);
}
else
{
Assert.Equal(typeof(IDescriptionTestsServiceBeginEndGenerated).GetMethod(nameof(IDescriptionTestsServiceBeginEndGenerated.BeginMessageRequestReply)), operation.BeginMethod);
Assert.Equal(typeof(IDescriptionTestsServiceBeginEndGenerated).GetMethod(nameof(IDescriptionTestsServiceBeginEndGenerated.EndMessageRequestReply)), operation.EndMethod);
}
}
contractDescription = ContractDescription.GetContract(typeof(IDescriptionTestsService));
Assert.Equal(2, contractDescription.Operations.Count);
foreach (OperationDescription operation in contractDescription.Operations)
{
Assert.NotNull(operation.SyncMethod);
if (operation.Name.Equals("Echo"))
{
Assert.Equal(typeof(IDescriptionTestsService).GetMethod(nameof(IDescriptionTestsService.Echo)), operation.SyncMethod);
}
else
{
Assert.Equal(typeof(IDescriptionTestsService).GetMethod(nameof(IDescriptionTestsService.MessageRequestReply)), operation.SyncMethod);
}
}
}
}
|