static void DelegateTest()
{
TestHandler th = new TestHandler(DoSomething);
th += new TestHandler(DoSomething);
th += new TestHandler(DoSomething);
th();
}
public void AuthorizeWithBasicAuthentication()
{
var logger = Substitute.For<ILog>();
var testHandler = new TestHandler((request, cancelation) =>
{
Assert.AreEqual("Basic",
request.Headers.Authorization.Scheme);
var authDetailsBytes = Convert.FromBase64String(request.Headers.Authorization.Parameter);
var authDetails = Encoding.GetEncoding("iso-8859-1").GetString(authDetailsBytes);
var authArray = authDetails.Split(':');
Assert.AreEqual("testToken", authArray[0]);
Assert.AreEqual("testSecret", authArray[1]);
return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK));
});
var credentials = new Credentials("testToken", "testSecret");
var handler = new AuthorizationHandler(credentials, logger) {InnerHandler = testHandler};
var client = new HttpClient(handler);
// ReSharper disable once MethodSupportsCancellation
var response = client.GetAsync("http://lodididki");
Assert.AreEqual(HttpStatusCode.OK, response.Result.StatusCode);
}
static void Main()
{
System.Console.WriteLine("Testing...");
TestHandler t = new TestHandler();
FunctionServer f = new FunctionServer(t);
f.Run();
}
public void VerifyExistanceOfExplicitUserAgent()
{
var customAgent = new List<ProductInfoHeaderValue>() { new ProductInfoHeaderValue("TEST", "123") };
var testHandler = new TestHandler(
(request, cancelation) =>
{
// Ensure User-Agent is sent
Assert.That(request.Headers.UserAgent, Is.Not.Null.Or.Empty);
Assert.That(request.Headers.UserAgent.Count, Is.EqualTo(2));
Assert.That(request.Headers.UserAgent, Has.Exactly(1).Matches<ProductInfoHeaderValue>(a => a.Product.Name == "TEST"));
return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK));
});
var clientWrapper = new HttpClientWrapper(customAgent, _versionHandler, _authorizationHandlerhandler, testHandler);
var client = clientWrapper.HttpClient;
// ReSharper disable once MethodSupportsCancellation
var response = client.GetAsync("http://lodididki");
Assert.AreEqual(HttpStatusCode.OK, response.Result.StatusCode);
}
public void setup()
{
_checkpointUnhandledBytesThreshold = 1000;
_checkpointProcessedEventsThreshold = 2000;
Given();
_bus = new InMemoryBus("bus");
_projectionCorrelationId = Guid.NewGuid();
_eventHandler = new TestHandler<EventReaderSubscriptionMessage.CommittedEventReceived>();
_checkpointHandler = new TestHandler<EventReaderSubscriptionMessage.CheckpointSuggested>();
_progressHandler = new TestHandler<EventReaderSubscriptionMessage.ProgressChanged>();
_subscriptionStartedHandler = new TestHandler<EventReaderSubscriptionMessage.SubscriptionStarted>();
_notAuthorizedHandler = new TestHandler<EventReaderSubscriptionMessage.NotAuthorized>();
_eofHandler = new TestHandler<EventReaderSubscriptionMessage.EofReached>();
_partitionEofHandler = new TestHandler<EventReaderSubscriptionMessage.PartitionEofReached>();
_partitionMeasuredHandler = new TestHandler<EventReaderSubscriptionMessage.PartitionMeasured>();
_bus.Subscribe(_eventHandler);
_bus.Subscribe(_checkpointHandler);
_bus.Subscribe(_progressHandler);
_bus.Subscribe(_eofHandler);
_bus.Subscribe(_partitionEofHandler);
_bus.Subscribe(_partitionMeasuredHandler);
_readerStrategy = CreateCheckpointStrategy();
_subscription = CreateProjectionSubscription();
When();
}
public void handlers_after_publishing_message_all_is_still_done_correctly()
{
var handler1 = new TestHandler<TestMessage>();
var handler2 = new TestHandler<TestMessage>();
var handler3 = new TestHandler<TestMessage>();
_bus.Subscribe<TestMessage>(handler1);
_bus.Subscribe<TestMessage>(handler2);
_bus.Subscribe<TestMessage>(handler3);
_bus.Publish(new TestMessage());
handler1.HandledMessages.Clear();
handler2.HandledMessages.Clear();
handler3.HandledMessages.Clear();
//just to ensure
Assert.That(handler1.HandledMessages.ContainsNo<TestMessage>() &&
handler2.HandledMessages.ContainsNo<TestMessage>() &&
handler3.HandledMessages.ContainsNo<TestMessage>());
_bus.Unsubscribe(handler1);
_bus.Unsubscribe(handler2);
_bus.Unsubscribe(handler3);
_bus.Publish(new TestMessage());
Assert.That(handler1.HandledMessages.ContainsNo<TestMessage>() &&
handler2.HandledMessages.ContainsNo<TestMessage>() &&
handler3.HandledMessages.ContainsNo<TestMessage>());
}
public void setup()
{
_subscribeProjectionHandler = new TestHandler<ReaderSubscriptionManagement.Subscribe>();
_writeEventHandler = new TestHandler<ClientMessage.WriteEvents>();
_bus.Subscribe(_subscribeProjectionHandler);
_bus.Subscribe(_writeEventHandler);
_stateHandler = GivenProjectionStateHandler();
_firstWriteCorrelationId = Guid.NewGuid();
_workerId = Guid.NewGuid();
var dispatcher = new ProjectionManagerMessageDispatcher(new Dictionary<Guid, IPublisher>{{_workerId, GetInputQueue()}});
_projectionCorrelationId = Guid.NewGuid();
_projectionConfig = GivenProjectionConfig();
var projectionProcessingStrategy = GivenProjectionProcessingStrategy();
_coreProjection = GivenCoreProjection(projectionProcessingStrategy);
_bus.Subscribe<CoreProjectionProcessingMessage.CheckpointCompleted>(_coreProjection);
_bus.Subscribe<CoreProjectionProcessingMessage.CheckpointLoaded>(_coreProjection);
_bus.Subscribe<CoreProjectionProcessingMessage.PrerecordedEventsLoaded>(_coreProjection);
_bus.Subscribe<CoreProjectionProcessingMessage.RestartRequested>(_coreProjection);
_bus.Subscribe<CoreProjectionProcessingMessage.Failed>(_coreProjection);
_bus.Subscribe(new AdHocHandler<ProjectionCoreServiceMessage.CoreTick>(tick => tick.Action()));
_bus.Subscribe(new AdHocHandler<ReaderCoreServiceMessage.ReaderTick>(tick => tick.Action()));
_bus.Subscribe<PartitionProcessingResultOutputBase>(dispatcher);
PreWhen();
When();
}
public void VersionHeaderTest()
{
const string versionHeaderValue = "3.2";
var testHandler = new TestHandler(
(request, cancelation) =>
{
var requestVersionHeader = request.Headers.FirstOrDefault(h => h.Key == VersioningHandler.API_VERSION_HEADER);
Assert.IsNotNull(requestVersionHeader);
Assert.That(requestVersionHeader.Value.FirstOrDefault(), Is.Not.Null.Or.Empty);
Assert.That(requestVersionHeader.Value.FirstOrDefault(), Is.EqualTo(versionHeaderValue));
return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK));
});
var handler = new VersioningHandler(versionHeaderValue) { InnerHandler = testHandler };
var client = new HttpClient(handler);
// ReSharper disable once MethodSupportsCancellation
var response = client.GetAsync("http://lodididki");
Assert.AreEqual(HttpStatusCode.OK, response.Result.StatusCode);
}
public void setup()
{
_subscribeProjectionHandler = new TestHandler<ReaderSubscriptionManagement.Subscribe>();
_writeEventHandler = new TestHandler<ClientMessage.WriteEvents>();
_bus.Subscribe(_subscribeProjectionHandler);
_bus.Subscribe(_writeEventHandler);
_stateHandler = _stateHandler
?? new FakeProjectionStateHandler(configureBuilder: _configureBuilderByQuerySource);
_firstWriteCorrelationId = Guid.NewGuid();
_projectionCorrelationId = Guid.NewGuid();
_projectionConfig = new ProjectionConfig(null,
_checkpointHandledThreshold, _checkpointUnhandledBytesThreshold, 1000, 250, true, true,
_createTempStreams, _stopOnEof);
_coreProjection = CoreProjection.CreateAndPrepare(
"projection", _version, _projectionCorrelationId, _bus, _stateHandler, _projectionConfig, _readDispatcher,
_writeDispatcher, _subscriptionDispatcher, null, _timeProvider);
_bus.Subscribe<CoreProjectionProcessingMessage.CheckpointCompleted>(_coreProjection);
_bus.Subscribe<CoreProjectionProcessingMessage.CheckpointLoaded>(_coreProjection);
_bus.Subscribe<CoreProjectionProcessingMessage.PrerecordedEventsLoaded>(_coreProjection);
_bus.Subscribe<CoreProjectionProcessingMessage.RestartRequested>(_coreProjection);
_bus.Subscribe<CoreProjectionProcessingMessage.Failed>(_coreProjection);
_bus.Subscribe<EventReaderSubscriptionMessage.CommittedEventReceived>(_coreProjection);
_bus.Subscribe<EventReaderSubscriptionMessage.CheckpointSuggested>(_coreProjection);
_bus.Subscribe<EventReaderSubscriptionMessage.EofReached>(_coreProjection);
_bus.Subscribe<EventReaderSubscriptionMessage.ProgressChanged>(_coreProjection);
_bus.Subscribe<EventReaderSubscriptionMessage.NotAuthorized>(_coreProjection);
_bus.Subscribe(new AdHocHandler<ProjectionCoreServiceMessage.CoreTick>(tick => tick.Action()));
_bus.Subscribe(new AdHocHandler<ReaderCoreServiceMessage.ReaderTick>(tick => tick.Action()));
PreWhen();
When();
}
public void setup()
{
_bus = new InMemoryBus("bus");
_listEventsHandler = new TestHandler<ClientMessage.ReadStreamEventsBackward>();
_bus.Subscribe(_listEventsHandler);
_ioDispatcher = new IODispatcher(_bus, new PublishEnvelope(_bus));
_subscriptionDispatcher =
new ReaderSubscriptionDispatcher
(_bus);
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.CommittedEventReceived>());
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.CheckpointSuggested>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.EofReached>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.PartitionEofReached>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.PartitionMeasured>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.ProgressChanged>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.SubscriptionStarted>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.NotAuthorized>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.ReaderAssignedReader>());
_bus.Subscribe(_ioDispatcher.BackwardReader);
_bus.Subscribe(_ioDispatcher.ForwardReader);
_bus.Subscribe(_ioDispatcher.Writer);
_bus.Subscribe(_ioDispatcher);
IProjectionStateHandler projectionStateHandler = new FakeProjectionStateHandler();
_projectionConfig = new ProjectionConfig(null, 5, 10, 1000, 250, true, true, false, false, false);
var version = new ProjectionVersion(1, 0, 0);
var projectionProcessingStrategy = new ContinuousProjectionProcessingStrategy(
"projection", version, projectionStateHandler, _projectionConfig,
projectionStateHandler.GetSourceDefinition(), null, _subscriptionDispatcher);
_coreProjection = projectionProcessingStrategy.Create(
Guid.NewGuid(), _bus, SystemAccount.Principal, _bus, _ioDispatcher, _subscriptionDispatcher,
new RealTimeProvider());
_coreProjection.Start();
}
public void setup()
{
_bus = new InMemoryBus("bus");
_listEventsHandler = new TestHandler<ClientMessage.ReadStreamEventsBackward>();
_bus.Subscribe(_listEventsHandler);
_readDispatcher = new RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted>(
_bus, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_bus));
_writeDispatcher = new RequestResponseDispatcher<ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted>(
_bus, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_bus));
_subscriptionDispatcher =
new PublishSubscribeDispatcher
<ReaderSubscriptionManagement.Subscribe,
ReaderSubscriptionManagement.ReaderSubscriptionManagementMessage, EventReaderSubscriptionMessage>
(_bus, v => v.SubscriptionId, v => v.SubscriptionId);
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.CommittedEventReceived>());
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.CheckpointSuggested>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.EofReached>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.ProgressChanged>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.NotAuthorized>());
_bus.Subscribe(_readDispatcher);
_bus.Subscribe(_writeDispatcher);
IProjectionStateHandler projectionStateHandler = new FakeProjectionStateHandler();
_projectionConfig = new ProjectionConfig(null, 5, 10, 1000, 250, true, true, false, false);
_coreProjection = CoreProjection.CreateAndPrepare(
"projection", new ProjectionVersion(1, 0, 0), Guid.NewGuid(), _bus, projectionStateHandler, _projectionConfig, _readDispatcher,
_writeDispatcher, _subscriptionDispatcher, null, new RealTimeProvider());
_coreProjection.Start();
}
public static void StartTest(string testName, TestHandler initCode, TestHandler loadCode, TestHandler updateCode, TestHandler drawCode)
{
using (TestGame game = new TestGame(testName,initCode,loadCode,updateCode,drawCode))
{
game.Run();
}
}
public void Setup()
{
_consumer = new TestHandler<Message>();
_bus = new InMemoryBus("temp");
_bus.Subscribe(_consumer);
ICheckpoint writerCheckpoint = new InMemoryCheckpoint(1000);
var ioDispatcher = new IODispatcher(_bus, new PublishEnvelope(_bus));
_readerService = new EventReaderCoreService(_bus, ioDispatcher, 10, writerCheckpoint, runHeadingReader: true);
_subscriptionDispatcher =
new ReaderSubscriptionDispatcher(_bus);
_spoolProcessingResponseDispatcher = new SpooledStreamReadingDispatcher(_bus);
_timeoutScheduler = new TimeoutScheduler();
_workerId = Guid.NewGuid();
_service = new ProjectionCoreService(
_workerId, _bus, _bus, _subscriptionDispatcher, new RealTimeProvider(), ioDispatcher,
_spoolProcessingResponseDispatcher, _timeoutScheduler);
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.CheckpointSuggested>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.CommittedEventReceived>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.EofReached>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.PartitionEofReached>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.PartitionMeasured>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.PartitionDeleted>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.ProgressChanged>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.SubscriptionStarted>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.NotAuthorized>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.ReaderAssignedReader>());
_bus.Subscribe(_spoolProcessingResponseDispatcher.CreateSubscriber<PartitionProcessingResult>());
_readerService.Handle(new Messages.ReaderCoreServiceMessage.StartReader());
_service.Handle(new ProjectionCoreServiceMessage.StartCore());
}
public void Skip_waiting_when_call_performed()
{
var handler = new TestHandler<int>();
handler.Handle(10);
Assert.DoesNotThrow(() => handler.WaitUntilCalled());
}
protected TestGame(string titleName, TestHandler initCode, TestHandler loadCode, TestHandler updateCode, TestHandler drawCode)
: base(titleName)
{
this.initCode = initCode;
this.loadCode = loadCode;
this.updateCode = updateCode;
this.drawCode = drawCode;
}
public TestSecurityMessageHandler(
bool isAllowed,
HttpResponseMessage responseMessage)
{
IsAllowed = isAllowed;
InnerHandler = new TestHandler(responseMessage);
}
public void message_of_child_type_then_all_subscribed_handlers_of_parent_type_should_handle_message()
{
var parentHandler = new TestHandler<ParentTestMessage>();
_bus.Subscribe<ParentTestMessage>(parentHandler);
_bus.Publish(new ChildTestMessage());
Assert.That(parentHandler.HandledMessages.ContainsSingle<ChildTestMessage>());
}
public void one_handler_to_one_message_it_should_be_handled()
{
var handler = new TestHandler<TestMessage>();
_bus.Subscribe<TestMessage>(handler);
_bus.Publish(new TestMessage());
Assert.That(handler.HandledMessages.ContainsSingle<TestMessage>());
}
public void Publish_calls_the_method_on_subscriber()
{
var simplePublishWay = new SimpleDispatcher();
var message = new TestMessage();
var handler = new TestHandler();
simplePublishWay.Invoke(message, handler);
Assert.That(handler.TestMessage, Is.SameAs(message));
}
public void Subscribe_adds_it_to_the_source_so_it_can_be_resolved()
{
var assignee = new SimpleSubscriber();
var handler = new TestHandler();
assignee.Subscribe(handler);
var handlers = assignee.ResolveHandlersFor(typeof(TestMessage));
Assert.That(handlers, Has.Member(handler));
}
public void handler_from_message_it_should_not_handle_this_message_anymore()
{
var handler = new TestHandler<TestMessage>();
_bus.Subscribe<TestMessage>(handler);
_bus.Unsubscribe<TestMessage>(handler);
_bus.Publish(new TestMessage());
Assert.That(handler.HandledMessages.IsEmpty());
}
public void GetEndpointAttributes_AcceptsUserHostAddressFormats(string format, EndpointAttributes expected)
{
var handler = new TestHandler();
var request = new Mock<IHttpRequest>();
request.Expect(req => req.UserHostAddress).Returns(format);
request.Expect(req => req.IsSecureConnection).Returns(false);
request.Expect(req => req.HttpMethod).Returns("GET");
Assert.AreEqual(expected | EndpointAttributes.HttpGet | EndpointAttributes.InSecure, request.Object.GetAttributes());
}
public void same_handler_from_same_message_multiple_times_app_doesnt_throw()
{
var handler = new TestHandler<TestMessage>();
Assert.DoesNotThrow(() =>
{
_bus.Unsubscribe<TestMessage>(handler);
_bus.Unsubscribe<TestMessage>(handler);
_bus.Unsubscribe<TestMessage>(handler);
});
}
public void Remove_removes_source()
{
var handler = new TestHandler();
_firstSource.Subscribe(handler);
_compositeSource.RemoveSource(_firstSource);
var results = GetListenersFromCompositeSource();
Assert.That(results, Is.Empty);
}
public void Should_no_throw_if_no_dispatcher_found_and_set_to_ignore()
{
var assignee = new SimpleSubscriber();
var handler = new TestHandler();
var message = new TestMessage();
var publisher = new Publisher(new PublisherSettings{IgnoreNoDispatcher = true},assignee, new[] { new SimpleDispatcher(new Rule(x => false)) });
assignee.Subscribe(handler);
Should.NotThrow(() => publisher.Publish(message));
}
public void Resolve_will_return_the_only_instance_of_handler_if_it_exists_in_many_sources()
{
var handler = new TestHandler();
_firstSource.Subscribe(handler);
_secondSource.Subscribe(handler);
var result = GetListenersFromCompositeSource();
Assert.That(result.Count, Is.EqualTo(1));
}
public void Should_remember_current_assembly()
{
var handler = new TestHandler();
IAssembly activeAssembly = null;
handler.OnBeginAssembly = x => activeAssembly = x;
var assembly = new AssemblyStub("Test.Assembly");
handler.BeginAssembly(assembly);
activeAssembly.ShouldBeSameAs(assembly);
}
public void Should_remember_current_method()
{
var handler = new TestHandler();
IMethod activeMethod = null;
handler.OnBeginMethod = x => activeMethod = x;
var method = new MethodStub("DoStuff");
handler.BeginMethod(method);
activeMethod.ShouldBeSameAs(method);
}
public void Should_remember_current_module()
{
var handler = new TestHandler();
IModule activeModule = null;
handler.OnBeginModule = x => activeModule = x;
var module = new ModuleStub("TestModule");
handler.BeginModule(module);
activeModule.ShouldBeSameAs(module);
}
public void Should_remember_current_type()
{
var handler = new TestHandler();
IType activeType = null;
handler.OnBeginType = x => activeType = x;
var type = new TypeStub("TestType");
handler.BeginType(type);
activeType.ShouldBeSameAs(type);
}
public async Task DeleteSendsCorrectPayload()
{
const string expectedId = "something";
Cosmos.PartitionKey partitionKey = new Cosmos.PartitionKey("pk");
Uri expectedRequestUri = new Uri($"/dbs/conflictsDb/colls/conflictsColl/conflicts/{expectedId}", UriKind.Relative);
ContainerCore container = CosmosConflictTests.GetMockedContainer((request, cancellationToken) => {
Assert.AreEqual(OperationType.Delete, request.OperationType);
Assert.AreEqual(ResourceType.Conflict, request.ResourceType);
Assert.AreEqual(expectedRequestUri, request.RequestUri);
return(TestHandler.ReturnSuccess());
});
ConflictProperties conflictSettings = new ConflictProperties();
conflictSettings.Id = expectedId;
await container.Conflicts.DeleteConflictAsync(partitionKey, conflictSettings);
}
public async Task ForwardChallengeWinsOverDefault()
{
var services = new ServiceCollection().ConfigureAuthTestServices();
var builder = services.AddAuthentication(o =>
{
o.DefaultScheme = DefaultScheme;
o.AddScheme <TestHandler2>("auth1", "auth1");
o.AddScheme <TestHandler>("specific", "specific");
});
RegisterAuth(builder, o =>
{
o.ForwardDefault = "auth1";
o.ForwardChallenge = "specific";
});
var specific = new TestHandler();
services.AddSingleton(specific);
var forwardDefault = new TestHandler2();
services.AddSingleton(forwardDefault);
var sp = services.BuildServiceProvider();
var context = new DefaultHttpContext();
context.RequestServices = sp;
await context.ChallengeAsync();
Assert.Equal(0, specific.SignOutCount);
Assert.Equal(0, specific.AuthenticateCount);
Assert.Equal(0, specific.ForbidCount);
Assert.Equal(1, specific.ChallengeCount);
Assert.Equal(0, specific.SignInCount);
Assert.Equal(0, forwardDefault.AuthenticateCount);
Assert.Equal(0, forwardDefault.ForbidCount);
Assert.Equal(0, forwardDefault.ChallengeCount);
Assert.Equal(0, forwardDefault.SignInCount);
Assert.Equal(0, forwardDefault.SignOutCount);
}
public async Task ForwardSignInWinsOverDefault()
{
if (SupportsSignIn)
{
var services = new ServiceCollection().AddLogging();
var builder = services.AddAuthentication(o =>
{
o.DefaultScheme = DefaultScheme;
o.AddScheme <TestHandler2>("auth1", "auth1");
o.AddScheme <TestHandler>("specific", "specific");
});
RegisterAuth(builder, o =>
{
o.ForwardDefault = "auth1";
o.ForwardSignIn = "specific";
});
var specific = new TestHandler();
services.AddSingleton(specific);
var forwardDefault = new TestHandler2();
services.AddSingleton(forwardDefault);
var sp = services.BuildServiceProvider();
var context = new DefaultHttpContext();
context.RequestServices = sp;
await context.SignInAsync(new ClaimsPrincipal(new ClaimsIdentity("whatever")));
Assert.Equal(1, specific.SignInCount);
Assert.Equal(0, specific.AuthenticateCount);
Assert.Equal(0, specific.ForbidCount);
Assert.Equal(0, specific.ChallengeCount);
Assert.Equal(0, specific.SignOutCount);
Assert.Equal(0, forwardDefault.AuthenticateCount);
Assert.Equal(0, forwardDefault.ForbidCount);
Assert.Equal(0, forwardDefault.ChallengeCount);
Assert.Equal(0, forwardDefault.SignInCount);
Assert.Equal(0, forwardDefault.SignOutCount);
}
}
/// <summary>
/// 尝试连接到手机：安装、运行相关软件
/// </summary>
/// <param name="error">错误处理</param>
/// <returns></returns>
public bool TryConnect(Action <ErrorResult> error)
{
const string package = "net.cflab.sockettransport";
var pm = new PackageHandler(Serial, error);
// 1.检测是否安装最新版本
var flag = pm.CheckInstall(package, "1.3.2", error);
if (!flag)
{
// 根据SDK版本判断是否自动授权
int.TryParse(Sdk, out var sdk);
var opt = sdk >= 23 ? "-r -g" : "-r";
// 未安装或版本不对时，安装APK
flag = pm.Install(AdbConnection.ApkPath, opt, error);
if (flag)
{
flag = pm.CheckInstall(package, AdbConnection.ApkVersion, error);
}
// 安装软件失败，返回false
if (!flag)
{
return(false);
}
}
// 2.尝试启动软件
flag = pm.Launch(package, error);
if (flag)
{
// 3.检测软件是否启动成功
flag = pm.IsRunning(package, error);
}
// 4.尝试连接到Apk端的Socket
if (!flag)
{
return(false);
}
var test = new TestHandler(Serial);
// 5.测试连接，循环检测5秒钟，共20次，等待软件启动延迟
flag = test.TestConnect(10101, 20, error);
return(flag);
}
public async Task HttpRetryHandler_MultipleTriesUntilSuccess()
{
// Arrange
var tries = 0;
var sent503 = false;
Func <HttpRequestMessage, HttpResponseMessage> handler = requestMessage =>
{
tries++;
// Return 503 for the first 2 tries
if (tries > 2)
{
return(new HttpResponseMessage(HttpStatusCode.OK));
}
else
{
sent503 = true;
return(new HttpResponseMessage(HttpStatusCode.ServiceUnavailable));
}
};
var retryHandler = new HttpRetryHandler();
var testHandler = new TestHandler(handler);
var httpClient = new HttpClient(testHandler);
var request = new HttpRetryHandlerRequest(httpClient, () => new HttpRequestMessage(HttpMethod.Get, TestUrl))
{
MaxTries = MaxTries,
RequestTimeout = Timeout.InfiniteTimeSpan,
RetryDelay = TimeSpan.Zero
};
var log = new TestLogger();
// Act
using (var response = await retryHandler.SendAsync(request, log, CancellationToken.None))
{
// Assert
Assert.True(sent503);
Assert.Equal(3, tries);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
}
static void ConnectRefused0(Bootstrap cb)
{
var handler = new TestHandler();
cb.Handler(handler);
var badAddress = new IPEndPoint(IPAddress.Loopback, UnassignedPort);
Task <IChannel> task = cb.ConnectAsync(badAddress);
var error = Assert.Throws <AggregateException>(() => task.Wait(DefaultTimeout));
Assert.Single(error.InnerExceptions);
Assert.IsType <ChannelException>(error.InnerException);
var exception = (ChannelException)error.InnerException;
Assert.IsType <OperationException>(exception.InnerException);
var operationException = (OperationException)exception.InnerException;
Assert.Equal(ErrorCode.ECONNREFUSED, operationException.ErrorCode);
Assert.Equal(0, handler.Active);
Assert.Null(handler.Error);
}
private void SaveTest()
{
TestHandler xTestHandler = new TestHandler();
Test xTest = new Test();
if (chkBoxAutoCorrectTest.IsEnabled)
{
xTest.IsAutoCorrect = true;
}
else
{
xTest.IsAutoCorrect = false;
}
xTest.Name = txtBoxTestName.Text;
xTestHandler.CreateTest(xTest, m_lxQuestions, m_lxAnswer, theTeacher.ID);
Clear(true);
}
/// <summary>
/// 测试自动取消订阅
/// </summary>
public void Test()
{
var handler = new TestHandler();
AddListener(handler.Handle);
evnetSource.Raise(new SubEventArgs()
{
Data = "hello"
});
handler = null;
//垃圾回收
GC.Collect();
GC.WaitForFullGCComplete();
evnetSource.Raise(new SubEventArgs()
{
Data = "world"
});
//output:
//hello
}
public async Task ReadCurrentGetsCorrectRID()
{
const string expectedRID = "something";
Cosmos.PartitionKey partitionKey = new Cosmos.PartitionKey("pk");
// Using "test" as container name because the Mocked DocumentClient has it hardcoded
Uri expectedRequestUri = new Uri($"dbs/conflictsDb/colls/test/docs/{expectedRID}", UriKind.Relative);
ContainerCore container = CosmosConflictTests.GetMockedContainer((request, cancellationToken) => {
Assert.AreEqual(OperationType.Read, request.OperationType);
Assert.AreEqual(ResourceType.Document, request.ResourceType);
Assert.AreEqual(expectedRequestUri, request.RequestUri);
return(TestHandler.ReturnSuccess());
});
ConflictProperties conflictSettings = new ConflictProperties();
conflictSettings.SourceResourceId = expectedRID;
await container.Conflicts.ReadCurrentAsync <JObject>(conflictSettings, partitionKey);
}
private void Given()
{
_it = new Core.Services.AwakeReaderService.AwakeService();
_eventRecord = new EventRecord(
100,
new PrepareLogRecord(
1500, Guid.NewGuid(), Guid.NewGuid(), 1500, 0, "Stream", 99, DateTime.UtcNow, PrepareFlags.Data,
"event", new byte[0], null));
_eventCommitted = new StorageMessage.EventCommitted(2000, _eventRecord, isTfEof: true);
_publisher = new InMemoryBus("bus");
_envelope = new PublishEnvelope(_publisher);
_handler = new TestHandler <TestMessage>();
_publisher.Subscribe(_handler);
_reply1 = new TestMessage(1);
_reply2 = new TestMessage(3);
_reply3 = new TestMessage(4);
_it.Handle(_eventCommitted);
}
public void Test_WriteBytes()
{
{
TestHandler <byte[]> test = (ref SliceWriter writer, byte[] value) => writer.WriteBytes(value);
PerformWriterTest(test, null, "");
PerformWriterTest(test, new byte[0], "");
PerformWriterTest(test, new byte[] { 66 }, "42");
PerformWriterTest(test, new byte[] { 65, 66, 67 }, "41 42 43");
}
{
TestHandler <Slice> test = (ref SliceWriter writer, Slice value) => writer.WriteBytes(in value);
PerformWriterTest(test, Slice.Nil, "");
PerformWriterTest(test, Slice.Empty, "");
PerformWriterTest(test, Slice.FromByte(66), "42");
PerformWriterTest(test, new byte[] { 65, 66, 67 }.AsSlice(), "41 42 43");
PerformWriterTest(test, new byte[] { 65, 66, 67, 68, 69 }.AsSlice(1, 3), "42 43 44");
}
}
public void setup0()
{
_envelope = null;
_timeProvider = new FakeTimeProvider();
_bus = new InMemoryBus("bus");
_queue = null;
_ioDispatcher = new IODispatcher(_bus, new PublishEnvelope(GetInputQueue()));
_readDispatcher = _ioDispatcher.BackwardReader;
_writeDispatcher = _ioDispatcher.Writer;
_bus.Subscribe(_ioDispatcher.ForwardReader);
_bus.Subscribe(_ioDispatcher.BackwardReader);
_bus.Subscribe(_ioDispatcher.ForwardReader);
_bus.Subscribe(_ioDispatcher.Writer);
_bus.Subscribe(_ioDispatcher.StreamDeleter);
_bus.Subscribe(_ioDispatcher);
_consumer = new TestHandler <Message>();
_bus.Subscribe(_consumer);
}
public async Task GivenAnEndpointAndPostObject_WhenCallingPostAsync_ThenTheGivenEndpointIsCalled()
{
var handler = new TestHandler(_ => new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new ObjectContent <SomeTestResponse>(new SomeTestResponse(), new JsonMediaTypeFormatter())
});
var client = CreateClient(handler);
var endpoint = "/endpoint";
await client.PostAsync <SomeTestResponse>(endpoint, new Dictionary <string, string>(), CancellationToken.None);
handler.ReceivedRequests
.First()
.RequestUri
.AbsolutePath
.Should()
.Be(endpoint);
}
public async Task DoesNotAddCorrelationIdToRequestWhenNotAvailable()
{
// Arrange
var correlatingHttpClientHandler = new CorrelatingHttpClientHandler();
var testHandler = new TestHandler();
correlatingHttpClientHandler.InnerHandler = testHandler;
// Act
using (var client = new HttpClient(correlatingHttpClientHandler))
{
await client.GetAsync("https://example");
}
// Assert
var request = testHandler.Requests.FirstOrDefault();
Assert.NotNull(request);
Assert.False(request.Headers.Contains(WebApiCorrelationHandler.CorrelationIdHttpHeaderName));
}
public async Task AddAsync_AnonymousType()
{
// Note: Generics and anonymous types don't mix, so this test isn't
// using the RunTableNameTest method and is instead copying it.
// Arrange
var handler = new TestHandler("{}");
var collector = CreateCollector <object>(handler, "Item");
// Act
await collector.AddAsync(new { id = "id", Text = "abc123", Deleted = true });
// Assert
Assert.Equal("https://someuri/tables/Item", handler.IssuedRequest.RequestUri.ToString());
// Make sure Mobile Services is treating this like a JObject rather than a Poco. Pocos have
// SystemProperties (like Deleted) stripped automatically. And make sure lowercase 'id' values are
// sent.
Assert.Equal("{\"id\":\"id\",\"Text\":\"abc123\",\"Deleted\":true}", handler.IssuedRequestContent);
}
public async Task Raise_Slowest_Last()
{
TestHandler first = new TestHandler();
TestHandler second = new TestHandler();
TestHandler third = new TestHandler()
{
Delay = TimeSpan.FromMilliseconds(100)
};
Func <EventArgs, CancellationToken, Task> handler = null;
handler += first.Handle;
handler += second.Handle;
handler += third.Handle;
await handler.RaiseAsync(EventArgs.Empty, default);
Assert.IsTrue(first.Completed);
Assert.IsTrue(second.Completed);
Assert.IsTrue(third.Completed);
}
private void Given()
{
_it = new Core.Services.AwakeReaderService.AwakeService();
_eventRecord = new EventRecord(
100,
new PrepareLogRecord(
1500, Guid.NewGuid(), Guid.NewGuid(), 1500, 0, "Stream", 99, DateTime.UtcNow, PrepareFlags.Data,
"event", new byte[0], null));
_eventCommitted = new StorageMessage.EventCommitted(2000, _eventRecord, isTfEof: true);
_publisher = new InMemoryBus("bus");
_envelope = new PublishEnvelope(_publisher);
_handler = new TestHandler <TestMessage>();
_publisher.Subscribe(_handler);
_reply1 = new TestMessage(1);
_reply2 = new TestMessage(2);
_reply3 = new TestMessage(3);
_reply4 = new TestMessage(4);
_reply5 = new TestMessage(5);
_correlationId1 = Guid.NewGuid();
_it.Handle(
new AwakeServiceMessage.SubscribeAwake(
_envelope, _correlationId1, "Stream", new TFPos(1000, 500), _reply1));
_correlationId2 = Guid.NewGuid();
_it.Handle(
new AwakeServiceMessage.SubscribeAwake(
_envelope, _correlationId2, "Stream", new TFPos(100000, 99500), _reply2));
_correlationId3 = Guid.NewGuid();
_it.Handle(
new AwakeServiceMessage.SubscribeAwake(
_envelope, _correlationId3, "Stream2", new TFPos(1000, 500), _reply3));
_correlationId4 = Guid.NewGuid();
_it.Handle(
new AwakeServiceMessage.SubscribeAwake(
_envelope, _correlationId4, null, new TFPos(1000, 500), _reply4));
_correlationId5 = Guid.NewGuid();
_it.Handle(
new AwakeServiceMessage.SubscribeAwake(
_envelope, _correlationId5, null, new TFPos(100000, 99500), _reply5));
}
public async Task VerifySendUsesOringianlContinuationOnDocumentClientExceptionAfterRetry()
{
Mock <PartitionRoutingHelper> partitionRoutingHelperMock = this.GetPartitionRoutingHelperMock();
//throw a DocumentClientException
partitionRoutingHelperMock.Setup(m => m.TryAddPartitionKeyRangeToContinuationTokenAsync(
It.IsAny <INameValueCollection>(),
It.IsAny <List <Range <string> > >(),
It.IsAny <IRoutingMapProvider>(),
It.Is <string>(x => x == CollectionId),
It.IsAny <ResolvedRangeInfo>(),
It.IsAny <ITrace>(),
It.IsAny <RntbdConstants.RntdbEnumerationDirection>()
)).ThrowsAsync(new DocumentClientException("error", HttpStatusCode.ServiceUnavailable, SubStatusCodes.Unknown));
PartitionKeyRangeHandler partitionKeyRangeHandler = new PartitionKeyRangeHandler(MockCosmosUtil.CreateMockCosmosClient(), partitionRoutingHelperMock.Object);
TestHandler testHandler = new TestHandler(async(request, cancellationToken) =>
{
ResponseMessage successResponse = await TestHandler.ReturnSuccess();
successResponse.Headers.Remove(HttpConstants.HttpHeaders.Continuation); //Clobber original continuation
return(successResponse);
});
partitionKeyRangeHandler.InnerHandler = testHandler;
//Pass valid collections path because it is required by DocumentServiceRequest's constructor. This can't be mocked because ToDocumentServiceRequest() is an extension method
RequestMessage initialRequest = new RequestMessage(HttpMethod.Get, new Uri($"{Paths.DatabasesPathSegment}/test/{Paths.CollectionsPathSegment}/test", UriKind.Relative))
{
OperationType = OperationType.ReadFeed
};
initialRequest.Headers.Add(HttpConstants.HttpHeaders.Continuation, Continuation);
ResponseMessage response = await partitionKeyRangeHandler.SendAsync(initialRequest, CancellationToken.None);
Assert.IsFalse(response.IsSuccessStatusCode);
Assert.AreEqual(System.Net.HttpStatusCode.ServiceUnavailable, response.StatusCode);
//Check if original continuation was restored
Assert.AreEqual(Continuation, response.Headers.GetValues(HttpConstants.HttpHeaders.Continuation).First());
Assert.AreEqual(Continuation, initialRequest.Headers.GetValues(HttpConstants.HttpHeaders.Continuation).First());
}
public async Task RetryHandlerHttpClientExceptionRefreshesLocations()
{
DocumentClient dc = new MockDocumentClient(RetryHandlerTests.TestUri, "test");
CosmosClient client = new CosmosClient(new CosmosClientConfiguration(RetryHandlerTests.TestUri.OriginalString, Guid.NewGuid().ToString()), dc);
Mock <IDocumentClientRetryPolicy> mockClientRetryPolicy = new Mock <IDocumentClientRetryPolicy>();
mockClientRetryPolicy.Setup(m => m.ShouldRetryAsync(It.IsAny <Exception>(), It.IsAny <CancellationToken>()))
.Returns <Exception, CancellationToken>((ex, tooken) => Task.FromResult(ShouldRetryResult.RetryAfter(TimeSpan.FromMilliseconds(1))));
Mock <IRetryPolicyFactory> mockRetryPolicy = new Mock <IRetryPolicyFactory>();
mockRetryPolicy.Setup(m => m.GetRequestPolicy())
.Returns(() => mockClientRetryPolicy.Object);
RetryHandler retryHandler = new RetryHandler(mockRetryPolicy.Object);
int handlerCalls = 0;
int expectedHandlerCalls = 2;
TestHandler testHandler = new TestHandler((request, response) => {
handlerCalls++;
if (handlerCalls == expectedHandlerCalls)
{
return(TestHandler.ReturnSuccess());
}
throw new HttpRequestException("DNS or some other network issue");
});
retryHandler.InnerHandler = testHandler;
RequestInvokerHandler invoker = new RequestInvokerHandler(client);
invoker.InnerHandler = retryHandler;
CosmosRequestMessage requestMessage = new CosmosRequestMessage(HttpMethod.Get, new System.Uri("https://dummy.documents.azure.com:443/dbs"));
requestMessage.Headers.Add(HttpConstants.HttpHeaders.PartitionKey, "[]");
requestMessage.ResourceType = ResourceType.Document;
requestMessage.OperationType = OperationType.Read;
await invoker.SendAsync(requestMessage, new CancellationToken());
Assert.AreEqual(expectedHandlerCalls, handlerCalls);
}
public async Task Cancels_OnlySlow()
{
TestHandler first = new TestHandler()
{
Delay = TimeSpan.FromMilliseconds(20)
};
TestHandler second = new TestHandler()
{
Delay = TimeSpan.FromMilliseconds(500)
};
TestHandler third = new TestHandler()
{
Delay = TimeSpan.FromMilliseconds(500)
};
CancellationTokenSource cancellation = new CancellationTokenSource();
Func <EventArgs, CancellationToken, Task> handler = null;
handler += first.Handle;
handler += second.Handle;
handler += third.Handle;
try
{
await Task.WhenAll(
Pause(
delay : TimeSpan.FromMilliseconds(100),
action : () => cancellation.Cancel()),
handler.RaiseAsync(EventArgs.Empty, cancellation.Token));
}
catch (TaskCanceledException)
{
}
Assert.IsTrue(first.Raised);
Assert.IsTrue(first.Completed);
Assert.IsTrue(second.Raised);
Assert.IsFalse(second.Completed);
Assert.IsTrue(third.Raised);
Assert.IsFalse(third.Completed);
}
public virtual void Setup()
{
_consumer = new TestHandler <Message>();
_bus = new InMemoryBus("temp");
_bus.Subscribe(_consumer);
ICheckpoint writerCheckpoint = new InMemoryCheckpoint(1000);
var ioDispatcher = new IODispatcher(_bus, new PublishEnvelope(_bus));
_readerService = new EventReaderCoreService(_bus, ioDispatcher, 10, writerCheckpoint,
runHeadingReader: true, faultOutOfOrderProjections: true);
_subscriptionDispatcher =
new ReaderSubscriptionDispatcher(_bus);
_spoolProcessingResponseDispatcher = new SpooledStreamReadingDispatcher(_bus);
_timeoutScheduler = new TimeoutScheduler();
_workerId = Guid.NewGuid();
_service = new ProjectionCoreService(
_workerId, _bus, _bus, _subscriptionDispatcher, new RealTimeProvider(), ioDispatcher,
_spoolProcessingResponseDispatcher, _timeoutScheduler);
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.CheckpointSuggested>());
_bus.Subscribe(_subscriptionDispatcher
.CreateSubscriber <EventReaderSubscriptionMessage.CommittedEventReceived>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.EofReached>());
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.PartitionEofReached>());
_bus.Subscribe(_subscriptionDispatcher
.CreateSubscriber <EventReaderSubscriptionMessage.PartitionMeasured>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.PartitionDeleted>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.ProgressChanged>());
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.SubscriptionStarted>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.NotAuthorized>());
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.ReaderAssignedReader>());
_bus.Subscribe(_spoolProcessingResponseDispatcher.CreateSubscriber <PartitionProcessingResult>());
var instanceCorrelationId = Guid.NewGuid();
_readerService.Handle(new ReaderCoreServiceMessage.StartReader(instanceCorrelationId));
_service.Handle(new ProjectionCoreServiceMessage.StartCore(instanceCorrelationId));
}
public static void Bench(string display, TestHandler handler)
{
var watch = new Stopwatch();
watch.Start();
if (NbThread == 1)
{
BenchThreadStart(handler);
}
else
{
List <Thread> threads = new List <Thread>();
for (int i = 0; i < NbThread; i++)
{
Thread thread = new Thread(BenchThreadStart);
threads.Add(thread);
thread.Start(handler);
}
foreach (Thread thread in threads)
{
thread.Join();
}
}
watch.Stop();
TimeSpan duration = watch.Elapsed;
Console.Write("Bench " + display + " ");
int reqSecond = (int)Math.Round((NbRequest * NbThread) / duration.TotalSeconds);
if (reqSecond < SlowRequestLevel)
{
Console.ForegroundColor = ConsoleColor.Red;
}
else
{
Console.ForegroundColor = ConsoleColor.DarkBlue;
}
Console.Write("{0}", reqSecond);
Console.ForegroundColor = ConsoleColor.Black;
Console.WriteLine(" req/s");
}
void TestTrigger(TestHandler testHandler,
Action <ResourceTriggerFilterDef> configurePolicyAction,
Action <ResourceTriggerFilterDef> doStuff)
{
var dummyPolicyType = Entity.Create <EntityType>();
dummyPolicyType.Name = "ResourceTriggerFilterTest type";
dummyPolicyType.Inherits.Add(Entity.Get <EntityType>("core:resourceTriggerFilterDef"));
dummyPolicyType.Save();
_toDelete.Add(dummyPolicyType.Id);
var factory = new TestFactory(dummyPolicyType, testHandler);
var policyCache = new ResourceTriggerFilterPolicyCache(factory.ToEnumerable());
using (var scope = Factory.Current.BeginLifetimeScope(builder =>
{
builder.Register(ctx => factory).As <IFilteredTargetHandlerFactory>();
builder.Register(ctx => policyCache).As <IResourceTriggerFilterPolicyCache>();
}))
using (Factory.SetCurrentScope(scope))
{
var dummyTriggerType = Entity.Create <EntityType>();
dummyTriggerType.Save();
_toDelete.Add(dummyTriggerType.Id);
var policy = Entity.Create(dummyPolicyType.Id).As <ResourceTriggerFilterDef>();
policy.TriggerEnabled = true;
policy.TriggeredOnType = dummyTriggerType;
policy.Save();
_toDelete.Add(policy.Id);
configurePolicyAction(policy);
testHandler.Clear();
doStuff(policy);
testHandler.Check();
}
}
public void setup()
{
_subscribeProjectionHandler = new TestHandler <ProjectionSubscriptionManagement.Subscribe>();
_writeEventHandler = new TestHandler <ClientMessage.WriteEvents>();
_bus.Subscribe(_subscribeProjectionHandler);
_bus.Subscribe(_writeEventHandler);
_stateHandler = _stateHandler
?? new FakeProjectionStateHandler(configureBuilder: _configureBuilderByQuerySource);
_firstWriteCorrelationId = Guid.NewGuid();
_projectionCorrelationId = Guid.NewGuid();
_coreProjection = new CoreProjection(
"projection", _projectionCorrelationId, _bus, _stateHandler,
new ProjectionConfig(
_projectionMode, _checkpointHandledThreshold, _checkpointUnhandledBytesThreshold, 1000, 250, true, true,
true), _readDispatcher, _writeDispatcher);
_coreProjection.Start();
When();
}
public static void Display(string desc, TestHandler handler)
{
var watch = new Stopwatch();
watch.Start();
var res = handler();
watch.Stop();
Console.Write($"Test {desc} in {watch.ElapsedMilliseconds} ms : ");
if (res)
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("DONE");
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("FAILS");
}
Console.ForegroundColor = ConsoleColor.Black;
}
public async Task CreateMobileServiceClient_AddsHandler(string apiKey, bool expectHeader)
{
// Arrange
var handler = new TestHandler();
var factory = new TestMobileServiceClientFactory(handler);
var client = EasyTableAttributeBindingProvider.CreateMobileServiceClient(factory, new Uri("https://someuri/"), apiKey);
var table = client.GetTable("FakeTable");
// Act
await table.ReadAsync(string.Empty);
// Assert
IEnumerable <string> values = null;
bool foundHeader = handler.IssuedRequest.Headers.TryGetValues(MobileServiceApiKeyHandler.ZumoApiKeyHeaderName, out values);
Assert.Equal(expectHeader, foundHeader);
if (expectHeader)
{
Assert.Equal("my_api_key", values.Single());
}
}
public async Task InvalidPartitionExceptionRetryHandlerDoesNotRetryOnSuccess()
{
CosmosClient client = MockCosmosUtil.CreateMockCosmosClient();
NamedCacheRetryHandler retryHandler = new NamedCacheRetryHandler();
int handlerCalls = 0;
int expectedHandlerCalls = 1;
TestHandler testHandler = new TestHandler((request, cancellationToken) => {
handlerCalls++;
return(TestHandler.ReturnSuccess());
});
retryHandler.InnerHandler = testHandler;
RequestInvokerHandler invoker = new RequestInvokerHandler(client, requestedClientConsistencyLevel: null);
invoker.InnerHandler = retryHandler;
RequestMessage requestMessage = new RequestMessage(HttpMethod.Get, new Uri("https://dummy.documents.azure.com:443/dbs"));
await invoker.SendAsync(requestMessage, new CancellationToken());
Assert.AreEqual(expectedHandlerCalls, handlerCalls);
}
public void NestedSequencesInPlace()
{
var ds = new DicomDataset(
new DicomUniqueIdentifier(DicomTag.SOPInstanceUID, "1.2.3"),
new DicomSequence(DicomTag.RTROIObservationsSequence,
new DicomDataset(new DicomUniqueIdentifier(DicomTag.SOPInstanceUID, "1.2.3"))));
var anon = GetAnonEngine(Mode.inplace);
var th = new TestHandler(new Dictionary <DicomTag, AnonFunc>()
{
{ DicomTag.SOPInstanceUID, (x, s, y) => { return(new DicomUniqueIdentifier(DicomTag.SOPInstanceUID, "3.2.1")); } }
}, null);
anon.RegisterHandler(th);
anon.Anonymize(ds);
Assert.AreEqual("3.2.1", ds.GetSingleValue <string>(DicomTag.SOPInstanceUID));
Assert.AreEqual(1, ds.GetSequence(DicomTag.RTROIObservationsSequence).Items.Count);
Assert.AreEqual("3.2.1", ds.GetSequence(DicomTag.RTROIObservationsSequence).Items[0].GetSingleValue <string>(DicomTag.SOPInstanceUID));
}
public async Task PartitionKeyRangeGoneRetryHandlerOnSuccess()
{
CosmosClient client = MockDocumentClient.CreateMockCosmosClient();
PartitionKeyRangeGoneRetryHandler retryHandler = new PartitionKeyRangeGoneRetryHandler(client);
int handlerCalls = 0;
int expectedHandlerCalls = 1;
TestHandler testHandler = new TestHandler((request, cancellationToken) => {
handlerCalls++;
return(TestHandler.ReturnSuccess());
});
retryHandler.InnerHandler = testHandler;
RequestInvokerHandler invoker = new RequestInvokerHandler(client);
invoker.InnerHandler = retryHandler;
CosmosRequestMessage requestMessage = new CosmosRequestMessage(HttpMethod.Get, new Uri("https://dummy.documents.azure.com:443/dbs"));
await invoker.SendAsync(requestMessage, new CancellationToken());
Assert.AreEqual(expectedHandlerCalls, handlerCalls);
}
public void RegisteredTriggerHandlersFire_OnCreate()
{
var testHandler = new TestHandler
{
ExpectedBeforeSaveCount = 1,
ExpectedAfterSaveCount = 1,
};
TestTrigger(testHandler,
(policy) =>
{
},
(policy) =>
{
var dummyObj = Entity.Create(policy.TriggeredOnType);
dummyObj.Save();
_toDelete.Add(dummyObj.Id);
}
);
}
