-
Notifications
You must be signed in to change notification settings - Fork 1
/
WcfProxyTests.cs
176 lines (153 loc) · 5.73 KB
/
WcfProxyTests.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
extern alias CastleDll;
extern alias MoqDll;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Xunit;
using MoqDll.Moq;
using System.ServiceModel;
using ProxyGenerator = CastleDll.Castle.DynamicProxy.ProxyGenerator;
using IInterceptor = CastleDll.Castle.DynamicProxy.IInterceptor;
using ProxyGenerationOptions = CastleDll.Castle.DynamicProxy.ProxyGenerationOptions;
using IInvocation = CastleDll.Castle.DynamicProxy.IInvocation;
using IProxyTargetAccessor = CastleDll.Castle.DynamicProxy.IProxyTargetAccessor;
using System.ServiceModel.Channels;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Reflection;
namespace WcfClientIsolator.Tests
{
public class WcfProxyTests : IDisposable
{
#region "Setup & Teardown"
Uri uri = new Uri("net.tcp://localhost:8000/HelloWorld");
ServiceHost service;
public WcfProxyTests()
{
service = new ServiceHost(typeof(HelloWorldService), uri);
var binding = new NetTcpBinding();
service.AddServiceEndpoint(typeof(IHelloWorldService), binding, uri);
service.Open();
}
public void Dispose()
{
service.Close();
}
#endregion
[Fact]
public void wcf_channel_throws_communication_object_faulted_exception_if_disposed_while_faulted()
{
var channel = ChannelFactory<IHelloWorldService>
.CreateChannel(new NetTcpBinding(), new EndpointAddress(uri));
Assert.Throws<CommunicationObjectFaultedException>(delegate
{
using ((IClientChannel)channel)
{
channel.ThrowException();
}
});
}
[Fact]
public void wcf_proxy_does_not_throw_communication_object_faulted_exception_when_faulted_channel_disposed()
{
// Arrange
Func<object> createChannel = () =>
ChannelFactory<IHelloWorldService>
.CreateChannel(new NetTcpBinding(), new EndpointAddress(uri));
var factory = new WcfProxyFactory();
var proxy = factory.Create<IDisposableHelloWorldService>(createChannel);
Assert.Throws<FaultException>(delegate
{
using (proxy)
{
proxy.ThrowException();
}
});
}
[Fact]
public void wcf_proxy_fowards_calls_to_wcf_channel()
{
// Arrange
Func<object> createChannel = () =>
ChannelFactory<IHelloWorldService>
.CreateChannel(new NetTcpBinding(), new EndpointAddress(uri));
var factory = new WcfProxyFactory();
var proxy = factory.Create<IDisposableHelloWorldService>(createChannel);
// Act
var result = proxy.HelloWorld();
// Assert
Assert.Equal("Hello World!", result);
}
[Fact]
public void wcf_proxy_refreshes_faulted_channel_before_invoking()
{
// Arrange
Func<object> createChannel = () =>
ChannelFactory<IHelloWorldService>
.CreateChannel(new NetTcpBinding(), new EndpointAddress(uri));
var factory = new WcfProxyFactory();
var proxy = factory.Create<IDisposableHelloWorldService>(createChannel);
// Act
try
{
proxy.ThrowException();
}
catch
{
}
// Assert
var accessor = proxy as IProxyTargetAccessor;
var manager = accessor.DynProxyGetTarget() as IWcfChannelManager;
Assert.Equal(CommunicationState.Faulted, manager.Channel.State);
Assert.DoesNotThrow(delegate
{
proxy.HelloWorld();
});
}
[Fact]
public void wcf_proxy_disposes_faulted_channel_without_throwing()
{
// Arrange
Func<object> createChannel = () =>
ChannelFactory<IHelloWorldService>
.CreateChannel(new NetTcpBinding(), new EndpointAddress(uri));
var factory = new WcfProxyFactory();
var proxy = factory.Create<IDisposableHelloWorldService>(createChannel);
// Act
try
{
proxy.ThrowException();
}
catch
{
}
// Assert
Assert.DoesNotThrow(delegate
{
proxy.Dispose();
});
}
[Fact]
public void can_inject_mock_service_implementation_into_service_host()
{
// Arrange
MoqDll.Castle.DynamicProxy.Generators.
AttributesToAvoidReplicating.Add(typeof(ServiceContractAttribute));
var helloWorldService = new Mock<IHelloWorldService>();
helloWorldService.Setup(s => s.HelloWorld()).Returns("mocked result");
var uri = new Uri("net.tcp://localhost:8001/HelloWorld");
var service = new ServiceHost(helloWorldService.Object, uri);
var binding = new NetTcpBinding();
service.AddServiceEndpoint(typeof(IHelloWorldService), binding, uri);
service.Description.Behaviors.Find<ServiceBehaviorAttribute>()
.InstanceContextMode = InstanceContextMode.Single;
service.Open();
var client = ChannelFactory<IHelloWorldService>.CreateChannel(new NetTcpBinding(), new EndpointAddress(uri));
// Act
var result = client.HelloWorld();
service.Close();
Assert.Equal("mocked result", result);
}
}
}