public override void Setup()
{
base.Setup();
MockProxy.Where_GetLastKnownLocationAsync_returns(null);
MockProxy.Where_GetCurrentLocationAsync_returns(new Location(12, 22, DateTimeOffset.Now));
}
public void CustomTestProxy_TestFirstRequestRegex()
{
MockProxy mockSite = new MockProxy();
string first = "GET / HTTP/1.1\r\n";
string second = "POST /r1 HTTP/1.1\r\n\r\np1=1234\r\n";
string third = "POST /r2 HTTP/1.1\r\n\r\np2=1234\r\n\r\n";
mockSite.MockSite.AddRequestResponse(first, "HTTP/1.1 200 OK\r\n\r\nbla");
mockSite.MockSite.AddRequestResponse(second, "HTTP/1.1 200 OK\r\n\r\nroot:0:0");
mockSite.MockSite.AddRequestResponse(third, "HTTP/1.1 200 OK\r\n\r\nroot:0:0");
mockSite.Start();
CustomTestsFile testFile = GetCustomTestFile();
TrafficViewerFile testDataStore = new TrafficViewerFile();
MockTestController mockTestController = new MockTestController();
SequentialAttackProxy testProxy = new SequentialAttackProxy(mockTestController, testFile, testDataStore);
testFile.PatternOfFirstRequestToTest = "r2";
testProxy.Start();
SendRequestThroughTestProxy(first, testProxy, mockSite);
SendRequestThroughTestProxy(second, testProxy, mockSite);
SendRequestThroughTestProxy(third, testProxy, mockSite);
testProxy.Stop();
Assert.IsFalse(mockTestController.IssuesFound.ContainsKey("p1"));
Assert.IsTrue(mockTestController.IssuesFound.ContainsKey("p2"));
}
public async Task IF_location_returned_is_invalid_SHOULD_error()
{
//Arrange
var result1 = new TaskCompletionSource <IGpsLocation>();
var result2 = new TaskCompletionSource <Exception>();
//Act
var disposable = Sut.Connect(_requirements)
.Subscribe(next =>
{
result1.SetResult(next);
}, ex =>
{
result2.SetResult(ex);
});
//Assert
MockProxy.Where_GetCurrentLocationAsync_returns(new Location(0, 2));
_testScheduler.AdvanceBy(1000);
var first = await result1.Task;
Assert.That(first.Latitude, Is.EqualTo(0));
MockProxy.Where_GetCurrentLocationAsync_returns(new Location(0, 2222, DateTimeOffset.Now));
_testScheduler.AdvanceBy(1000);
var second = await result2.Task;
Assert.That(second.ToError(), Is.EqualTo(GeolocationErrors.InvalidLongitude));
MockAnalyticsService.VerifyTrace(GeolocationErrors.InvalidLongitude.ToString(), LogSeverity.Error);
disposable.Dispose();
}
public void ThrowsIfInterfaceHasEvents()
{
var clientProxy = new MockProxy();
var ex = Assert.Throws <InvalidOperationException>(() => TypedClientBuilder <IEventsClient> .Build(clientProxy));
Assert.Equal("Type must not contain events.", ex.Message);
}
public async Task DoNotCallPlatformProxyAsync()
{
// Arrange
using (var harness = new MockHttpAndServiceBundle())
{
harness.HttpManager.AddInstanceDiscoveryMockHandler();
var mockProxy = new MockProxy();
var app = PublicClientApplicationBuilder.Create(TestConstants.ClientId)
.WithAuthority(new Uri(ClientApplicationBase.DefaultAuthority), true)
.WithHttpManager(harness.HttpManager)
.WithPlatformProxy(mockProxy)
.WithRedirectUri("http://localhost")
.BuildConcrete();
app.ServiceBundle.ConfigureMockWebUI();
harness.HttpManager.AddSuccessTokenResponseMockHandlerForPost(TestConstants.AuthorityCommonTenant);
// Act
await app
.AcquireTokenInteractive(TestConstants.s_scope)
.ExecuteAsync()
.ConfigureAwait(false);
// Assert - NoDeviceIdProxy would fail if InternalGetDeviceId is called
Assert.IsFalse(mockProxy.InternalDeviceIdWasCalled);
}
}
public void ThrowsIfProvidedAStruct()
{
var clientProxy = new MockProxy();
var ex = Assert.Throws <InvalidOperationException>(() => TypedClientBuilder <ValueTask> .Build(clientProxy));
Assert.Equal("Type must be an interface.", ex.Message);
}
public void ThrowsIfProvidedADelegate()
{
var clientProxy = new MockProxy();
var ex = Assert.Throws <InvalidOperationException>(() => TypedClientBuilder <EventHandler> .Build(clientProxy));
Assert.Equal("Type must be an interface.", ex.Message);
}
public void ThrowsIfInterfaceHasNonTaskReturns()
{
var clientProxy = new MockProxy();
var ex = Assert.Throws <InvalidOperationException>(() => TypedClientBuilder <IStringMethodClient> .Build(clientProxy));
Assert.Equal($"Cannot generate proxy implementation for '{typeof(IStringMethodClient).FullName}.{nameof(IStringMethodClient.Method)}'. All client proxy methods must return '{typeof(Task).FullName}'.", ex.Message);
}
public void Finalizer_Any()
{
WeakReference <ProxyObjectBase> weakReference = null;
new Action(() =>
{
var proxy = new MockProxy();
weakReference = new WeakReference <ProxyObjectBase>(proxy, true);
})();
GC.Collect(); //first finalization (mark as finalized)
GC.WaitForPendingFinalizers();
new Action(() =>
{
weakReference.TryGetTarget(out var target);
Assert.IsTrue(ProxyObjectBase.FinalizeRequested.ContainsKey(target.DtoGuid), "Object did not save itself!");
target.FinalizeProxy();
})();
GC.Collect(); //first finalization (mark as finalized)
GC.WaitForPendingFinalizers();
GC.Collect(); //collect finalized
GC.WaitForPendingFinalizers();
Assert.IsTrue(ProxyObjectBase.FinalizeRequested.Count == 0, "There should be no Finalization Requests at this point!");
Assert.IsFalse(weakReference.TryGetTarget(out _), "GetTarget should not return anything!");
}
public async Task IF_location_throws_exception_SHOULD_error()
{
//Arrange
var result1 = new TaskCompletionSource <IGpsLocation>();
var result2 = new TaskCompletionSource <Exception>();
//Act
var disposable = Sut.Connect(_requirements)
.Subscribe(next =>
{
result1.SetResult(next);
}, ex =>
{
result2.SetResult(ex);
});
//Assert
MockProxy.Where_GetCurrentLocationAsync_returns(new Location(0, 2));
_testScheduler.AdvanceBy(1000);
var first = await result1.Task;
Assert.That(first.Latitude, Is.EqualTo(0));
MockProxy.Where_GetCurrentLocationAsync_throws(new Exception("oops"));
_testScheduler.AdvanceBy(1000);
var second = await result2.Task;
Assert.That(second.ToError(), Is.EqualTo(GeolocationErrors.Unexpected));
Assert.That(second.InnerException.Message, Is.EqualTo("oops"));
MockAnalyticsService.VerifyLogException <Exception>("oops");
disposable.Dispose();
}
public void ThrowsIfInterfaceMethodHasRefParam()
{
var clientProxy = new MockProxy();
var ex = Assert.Throws <InvalidOperationException>(() => TypedClientBuilder <IRefParamMethodClient> .Build(clientProxy));
Assert.Equal(
$"Cannot generate proxy implementation for '{typeof(IRefParamMethodClient).FullName}.{nameof(IRefParamMethodClient.Method)}'. Client proxy methods must not have 'ref' parameters.", ex.Message);
}
static public IRecordDescriptionRepository CreateRepository()
{
#if USE_MOCK
var proxy = new MockProxy <MockRecordDescriptionRepository>(new MockRecordDescriptionRepository());
return(proxy.GetTransparentProxy());
#else
return(new RecordDescriptionRepository());
#endif
}
public static IRecordDescriptionRepository CreateRepository()
{
#if USE_MOCK
var proxy = new MockProxy<MockRecordDescriptionRepository>(new MockRecordDescriptionRepository());
return proxy.GetTransparentProxy();
#else
return new RecordDescriptionRepository();
#endif
}
public void GetReference_AnyDto_ReturnGuid()
{
ClientReferenceResolver clientReferenceResolver = new ClientReferenceResolver();
var mockObject = new MockProxy();
var guid = clientReferenceResolver.GetReference(this, mockObject);
Assert.AreEqual(mockObject.DtoGuid.ToString(), guid);
}
public void ResolveReference_NonReferenced_ReturnNull()
{
ClientReferenceResolver clientReferenceResolver = new ClientReferenceResolver();
var mockObject = new MockProxy();
var proxy = clientReferenceResolver.ResolveReference(this, mockObject.DtoGuid.ToString());
Assert.IsNull(proxy);
}
public void IsReferenced_AnyDto_ReturnTrue()
{
ClientReferenceResolver clientReferenceResolver = new ClientReferenceResolver();
var mockObject = new MockProxy();
var referenced = clientReferenceResolver.IsReferenced(this, mockObject);
Assert.IsTrue(referenced);
}
public RTObjectMock(ComponentProfile prof, List<PortService> ports)
{
_profile = prof;
_ports = ports;
var proxy = new MockProxy<ExecutionContextMock>(new ExecutionContextMock());
_execs = new List<ExecutionContext>() { proxy.GetTransparentProxy() };
State = LifeCycleState.INACTIVE_STATE;
}
public void ResolveReferenceGuid_NonReferenced_ReturnNull()
{
ClientReferenceResolver clientReferenceResolver = new ClientReferenceResolver();
PrivateObject po = new PrivateObject(clientReferenceResolver);
var mockObject = new MockProxy();
var proxy = clientReferenceResolver.ResolveReference(mockObject.DtoGuid);
Assert.IsNull(proxy, "Proxy not null!");
}
public void ResolveReferenceGuid_Referenced_ReturnProxy()
{
ClientReferenceResolver clientReferenceResolver = new ClientReferenceResolver();;
PrivateObject po = new PrivateObject(clientReferenceResolver);
var mockObject = new MockProxy();
clientReferenceResolver.AddReference(this, mockObject.DtoGuid.ToString(), mockObject);
var proxy = clientReferenceResolver.ResolveReference(mockObject.DtoGuid);
Assert.AreEqual(mockObject, proxy, "Object are not the same!");
}
public void ResolveReference_ReferencedAlive_ReturnDto()
{
ClientReferenceResolver clientReferenceResolver = new ClientReferenceResolver();
var mockObject = new MockProxy();
clientReferenceResolver.AddReference(this, mockObject.DtoGuid.ToString(), mockObject);
var proxy = clientReferenceResolver.ResolveReference(this, mockObject.DtoGuid.ToString());
Assert.AreEqual(mockObject, proxy);
}
public async Task SHOULD_get_and_publish_current_location_again_after_interval_elapses()
{
//Arrange
MockProxy.Where_GetCurrentLocationAsync_returns_sequence(new List <Location>
{
new Location(0, 2),
new Location(1, 2),
new Location(2, 4),
new Location(3, 6),
});
var result1 = new TaskCompletionSource <IGpsLocation>();
var result2 = new TaskCompletionSource <IGpsLocation>();
var result3 = new TaskCompletionSource <IGpsLocation>();
var count = 0;
//Act
var disposable = Sut.Connect(_requirements)
.Subscribe(next =>
{
count++;
if (count == 1)
{
result1.SetResult(next);
}
else if (count == 2)
{
result2.SetResult(next);
}
else if (count == 3)
{
result3.SetResult(next);
}
});
//Assert
_testScheduler.AdvanceBy(1000);
var first = await result1.Task;
Assert.That(first.Latitude, Is.EqualTo(0));
_testScheduler.AdvanceBy(1000);
var second = await result2.Task;
Assert.That(second.Latitude, Is.EqualTo(1));
_testScheduler.AdvanceBy(1000);
var third = await result3.Task;
Assert.That(third.Latitude, Is.EqualTo(2));
MockAnalyticsService.Mock.Verify(x => x.Debug("Updated location published",
It.IsAny <Dictionary <string, object> >()), Times.Exactly(3));
disposable.Dispose();
}
public async Task IF_current_location_is_null_SHOULD_warn()
{
//Arrange
MockProxy.Where_GetCurrentLocationAsync_returns(null);
//Act
Sut.Connect(_requirements).Subscribe(next => { }, ex => { ExceptionTaskCompletionSource.SetResult(ex); });
//Assert
MockAnalyticsService.VerifyTrace("Current location is null", LogSeverity.Warning);
}
public async Task IF_last_known_location_is_null_SHOULD_trace()
{
//Arrange
MockProxy.Where_GetLastKnownLocationAsync_returns(null);
//Act
Sut.Connect(_requirements).Subscribe(next => { }, ex => { ExceptionTaskCompletionSource.SetResult(ex); });
//Assert
MockAnalyticsService.VerifyTrace("Last known location is null");
}
public async Task IF_location_returned_is_null_SHOULD_warn()
{
//Act
var disposable = Sut.Connect(_requirements)
.Subscribe(next => { });
//Assert
MockProxy.Where_GetCurrentLocationAsync_returns(null);
_testScheduler.AdvanceBy(1000);
MockAnalyticsService.VerifyTrace("Updated location is null", LogSeverity.Warning);
disposable.Dispose();
}
public async Task ThrowsIfReturnMethodUsedWithoutSingleClientProxy()
{
var clientProxy = new MockProxy();
var typedProxy = TypedClientBuilder <ITestClient> .Build(clientProxy);
var objArg = new object();
var ex = await Assert.ThrowsAsync <InvalidOperationException>(() => typedProxy.GetValue(102, objArg, "test")).DefaultTimeout();
Assert.Equal("InvokeAsync only works with Single clients.", ex.Message);
Assert.Empty(clientProxy.Sends);
}
public async Task IF_API_call_throws_SHOULD_return_Error()
{
//Arrange
MockProxy.Where_GetLocationsFromAddressAsync_throws(new Exception("oops"));
//Act
var result = await Sut.FromAddressAsync(_addressString);
//Assert
Assert.That(result.IsError(GeolocationErrors.GpsLookupFailed));
MockAnalyticsService.VerifyLogException <Exception>("oops");
}
public void ExpectSetOfTPropertyActionOfT_can_setup_verifiable_mock()
{
// Arrange
var m = new MockProxy <TextWriter>(new Mock <TextWriter>());
m.ExpectSet <string>(_ => _.NewLine = "\n");
// Act
m.Object.NewLine = "\n";
// Assert
m.Verify();
}
public async Task IF_no_locations_found_SHOULD_Error_and_trace()
{
//Arrange
MockProxy.Where_GetLocationsFromAddressAsync_returns(new List <Location>());
//Act
var result = await Sut.FromAddressAsync(_addressString);
//Assert
MockAnalyticsService.VerifyTrace("No GPS coordinates found for given address", LogSeverity.Warning);
MockAnalyticsService.VerifyTraceProperty("Address", _addressString);
Assert.That(result.IsError(GeolocationErrors.GpsCoordinatesNotFound));
}
public override void Setup()
{
base.Setup();
_addressString = "6 Terrace Road";
_location = new Location
{
Latitude = 11,
Longitude = 22
};
MockProxy.Where_GetLocationsFromAddressAsync_returns(_location);
}
public void ExpectExpressionOfActionOfT_can_setup_verifiable_mock()
{
// Arrange
var m = new MockProxy <TextWriter>(new Mock <TextWriter>());
m.Expect(_ => _.WriteLine(42));
// Act
m.Object.WriteLine(42);
// Assert
m.Verify();
}
public async Task IF_no_placemarks_found_SHOULD_Error_and_trace()
{
//Arrange
MockProxy.Where_GetPlacemarksFromLocationAsync_returns(new List <Placemark>());
//Act
var result = await Sut.ToAddressAsync(_gpsLocation);
//Assert
MockAnalyticsService.VerifyTrace("No address found for Gps coordinates", LogSeverity.Warning);
MockAnalyticsService.VerifyTraceProperty(nameof(GpsLocation), _gpsLocation);
Assert.That(result.IsError(GeolocationErrors.AddressNotFound));
}
void DoSetupForAutoMock(MockProxy proxy, MethodInfo dlgtMethod, ISpecimenContext context)
{
var setup = default(object);
using (InstanceGetters.DisableProcessing())
{
var proxyType = proxy.GetType();
var setupMethod = GetSetupMethod(proxyType, dlgtMethod);
var expression = GetExpression(setupMethod.GetParameters()[0].ParameterType, dlgtMethod, context);
setup = setupMethod.Invoke(proxy, new object[] { expression });
}
DoReturnsForAutoMock(setup, context);
}
public static RTObjectMock CreateRTObject(string typeName, string instanceName, params PortService[] ports)
{
var profile = new ComponentProfile()
{
category = "",
instance_name = instanceName,
description = "",
type_name = typeName,
vendor = "",
version = "",
port_profiles = ports.Select(p => p.get_port_profile()).ToArray(),
parent = null,
properties = new NameValue[0]
};
var proxy = new MockProxy<RTObjectMock>(new RTObjectMock(profile, ports.ToList()));
return proxy.GetTransparentProxy();
}
public static OutPortServiceMock CreateOutPortService(string name, string dataType)
{
var portProfile = new PortProfile()
{
name = name,
connector_profiles = new ConnectorProfile[0],
interfaces = new PortInterfaceProfile[0],
owner = null,
port_ref = null,
properties = new[]{
NameValueExtension.Create("port.port_type","DataOutPort"),
NameValueExtension.Create("dataport.data_type",dataType),
NameValueExtension.Create("dataport.subscription_type","flush,new,periodic"),
NameValueExtension.Create("dataport.dataflow_type","push,pull"),
NameValueExtension.Create("dataport.interface_type","corba_cdr"),
}
};
var proxy = new MockProxy<OutPortServiceMock>(new OutPortServiceMock(portProfile));
return proxy.GetTransparentProxy();
}
public static NamingServiceMock CreateNamingService(string host, int port)
{
var proxy = new MockProxy<NamingServiceMock>(new NamingServiceMock(host,port));
return proxy.GetTransparentProxy();
}
