public async Task SmugglerBehaviorWhenServerIsDown() { var path = Path.GetTempFileName(); try { var connectionStringOptions = new RavenConnectionStringOptions { Url = "http://localhost:8078/", DefaultDatabase = "DoesNotExist" }; var smuggler = new SmugglerDatabaseApi(); var e = await AssertAsync.Throws <SmugglerException>(() => smuggler.ImportData( new SmugglerImportOptions <RavenConnectionStringOptions> { FromFile = path, To = connectionStringOptions })); Assert.Contains("Smuggler encountered a connection problem:", e.Message); e = await AssertAsync.Throws <SmugglerException>(() => smuggler.ExportData( new SmugglerExportOptions <RavenConnectionStringOptions> { ToFile = path, From = connectionStringOptions })); Assert.Contains("Smuggler encountered a connection problem:", e.Message); } finally { IOExtensions.DeleteFile(path); } }
public async Task MaxRevisions(string requestedStorage) { const string FileName = "file1.txt"; using (var store = NewStore(requestedStorage: requestedStorage, activeBundles: "Versioning")) { await store.AsyncFilesCommands.Configuration.SetKeyAsync(VersioningUtil.DefaultConfigurationName, new FileVersioningConfiguration { Id = VersioningUtil.DefaultConfigurationName, MaxRevisions = 3 }); await store.AsyncFilesCommands.UploadAsync(FileName, StringToStream(Content1)); await store.AsyncFilesCommands.UploadAsync(FileName, StringToStream(Content2)); await store.AsyncFilesCommands.UploadAsync(FileName, StringToStream(Content3)); await store.AsyncFilesCommands.UploadAsync(FileName, StringToStream(Content4)); var stream = await store.AsyncFilesCommands.DownloadAsync(FileName); Assert.NotNull(stream); Assert.Equal(Content4, StreamToString(stream)); await AssertAsync.Throws <FileNotFoundException>(async() => await store.AsyncFilesCommands.DownloadAsync(FileName + "/revisions/1")); stream = await store.AsyncFilesCommands.DownloadAsync(FileName + "/revisions/2"); Assert.NotNull(stream); Assert.Equal(Content2, StreamToString(stream)); stream = await store.AsyncFilesCommands.DownloadAsync(FileName + "/revisions/3"); Assert.NotNull(stream); Assert.Equal(Content3, StreamToString(stream)); } }
public async Task AsyncQueriesShouldThrowTheRightException_InsteadOfUnsupportedSyncOperationException() { var query = new SomeQuery { UserId = 1 }; var store = NewDocumentStore(); WaitForIndexing(store); using (var session = store.OpenAsyncSession()) { await CreateUsersAsync(session); await session.SaveChangesAsync(); var argumentException = await AssertAsync.Throws <ArgumentException>(async() => { var userId = "users/" + query.UserId; // Act. await session.Query <User>() .Where(x => x.Id == userId) .Where(i => i.OfficesIds.Any(o => o.In(query.OfficeIds))) //.Where(i => i.OfficesIds.ContainsAny(query.OfficeIds)) .FirstOrDefaultAsync(); }); Assert.Contains("Value cannot be null.", argumentException.ToString()); } }
public void SampleAssertProvider_ExecuteWithSingleException_Succeeds() { var sampleAssertProvider = new SampleAssertProvider(); AssertAsync.Throws <InvalidOperationException>( sampleAssertProvider.ExecuteWithSingleException); }
public void Example_program_1() { var cpu = new CPU { Program = new List <Instruction> { new NoOperation(0), new Accumulate(1), new Jump(4), new Accumulate(3), new Jump(-3), new Accumulate(-99), new Accumulate(1), new Jump(-4), new Accumulate(6) } }; AssertAsync.CompletesIn(3, () => { cpu.Run(); }); Assert.Equal(5, cpu.Accumulator); }
public async Task CorrelationOverflowGuardWorks() { var correlationId = -1; var endpoint = TestConfig.ServerEndpoint(); using (var server = new TcpServer(endpoint.Ip.Port, TestConfig.Log)) using (var conn = new Connection(endpoint, new ConnectionConfiguration(requestTimeout: TimeSpan.FromMilliseconds(5)), TestConfig.Log)) { server.OnReceivedAsync = data => { var context = KafkaDecoder.DecodeHeader(data.Skip(Request.IntegerByteSize)); correlationId = context.CorrelationId; return(Task.FromResult(0)); }; try { Connection.OverflowGuard = 10; await AssertAsync.Throws <TimeoutException>(() => conn.SendAsync(new MetadataRequest(), CancellationToken.None)); var initialCorrelation = correlationId; await AssertAsync.Throws <TimeoutException>(() => Task.WhenAll(Enumerable.Range(initialCorrelation, Connection.OverflowGuard - 1).Select(i => conn.SendAsync(new MetadataRequest(), CancellationToken.None)))); await AssertAsync.ThatEventually(() => correlationId > 1, () => $"correlation {correlationId}"); var currentCorrelation = correlationId; await AssertAsync.Throws <TimeoutException>(() => Task.WhenAll(Enumerable.Range(0, Connection.OverflowGuard / 2).Select(i => conn.SendAsync(new MetadataRequest(), CancellationToken.None)))); await AssertAsync.ThatEventually(() => correlationId < currentCorrelation, () => $"correlation {correlationId}"); } finally { Connection.OverflowGuard = int.MaxValue >> 1; } } }
//someTime failed public async Task ProducerShouldBlockWhenFullBufferReached() { int count = 0; //with max buffer set below the batch size, this should cause the producer to block until batch delay time. var scenario = new RoutingScenario(); scenario.Connection1.Add(ApiKey.Produce, async _ => { await Task.Delay(200); return(new ProduceResponse()); }); using (var producer = new Producer(scenario.CreateRouter(), new ProducerConfiguration(batchSize: 10, batchMaxDelay: TimeSpan.FromMilliseconds(500)))) { var senderTask = Task.Factory.StartNew(async() => { for (int i = 0; i < 3; i++) { await producer.SendAsync(new Message(i.ToString()), RoutingScenario.TestTopic, CancellationToken.None); TestConfig.Log.Info(() => LogEvent.Create($"Buffered {producer.BufferedMessageCount}, In Flight: {producer.InFlightMessageCount}")); Interlocked.Increment(ref count); } }); await AssertAsync.ThatEventually(() => count > 0 && producer.BufferedMessageCount == 1, () => $"buffered {producer.BufferedMessageCount}, count {count}"); TestConfig.Log.Info(() => LogEvent.Create("Waiting for the rest...")); await Task.WhenAny(senderTask, Task.Delay(5000)); Assert.That(senderTask.IsCompleted); Assert.That(producer.BufferedMessageCount, Is.EqualTo(1), "One message should be left in the buffer."); } }
public async Task MessagesStillLogWhenSendTimesOut() { var logger = new MemoryLog(); var received = 0; var timeout = TimeSpan.FromMilliseconds(100); var endpoint = TestConfig.ServerEndpoint(); using (var server = new TcpServer(endpoint.Ip.Port, TestConfig.Log)) using (var conn = new Connection(endpoint, new ConnectionConfiguration(requestTimeout: timeout, onRead: (e, read, elapsed) => Interlocked.Increment(ref received)), logger)) { await Task.WhenAny(server.ClientConnected, Task.Delay(TimeSpan.FromSeconds(3))); server.OnReceivedAsync = async data => { var context = KafkaDecoder.DecodeHeader(data.Skip(Request.IntegerByteSize)); await Task.Delay(timeout); await server.SendDataAsync(KafkaDecoder.EncodeResponseBytes(context, new MetadataResponse())); }; await AssertAsync.Throws <TimeoutException>(() => conn.SendAsync(new MetadataRequest(), CancellationToken.None)); await AssertAsync.ThatEventually(() => received > 0, () => $"received {received}"); await AssertAsync.ThatEventually(() => logger.LogEvents.Any(e => e.Item1 == LogLevel.Debug && e.Item2.Message.StartsWith("Timed out -----> (timed out or otherwise errored in client)")), () => logger.ToString(LogLevel.Debug)); } }
public async Task ReadShouldIgnoreMessageWithUnknownCorrelationId() { const int correlationId = 99; var onRead = 0; var log = new MemoryLog(); var config = new ConnectionConfiguration(onRead: (e, buffer, elapsed) => Interlocked.Increment(ref onRead)); var endpoint = TestConfig.ServerEndpoint(); using (var server = new TcpServer(endpoint.Ip.Port, TestConfig.Log)) using (var conn = new Connection(endpoint, config, log: log)) { //send correlation message await server.SendDataAsync(new ArraySegment <byte>(CreateCorrelationMessage(correlationId))); //wait for connection await Task.WhenAny(server.ClientConnected, Task.Delay(TimeSpan.FromSeconds(3))); await AssertAsync.ThatEventually(() => onRead > 0, () => $"read attempts {onRead}"); // shortly after receivedData, but still after await AssertAsync.ThatEventually(() => log.LogEvents.Any(e => e.Item1 == LogLevel.Warn && e.Item2.Message == $"Unexpected response (id {correlationId}, 4? bytes) from {endpoint}"), log.ToString); } }
public async Task Cannot_failover_writes_by_default() { var store1 = CreateStore(); var store2 = CreateStore(); TellFirstInstanceToReplicateToSecondInstance(); var serverClient = ((ServerClient)store1.DatabaseCommands); serverClient.ReplicationInformer.RefreshReplicationInformation(serverClient); using (var session = store1.OpenAsyncSession()) { await session.StoreAsync(new Company { Name = "Hibernating Rhinos" }); await session.SaveChangesAsync(); } await WaitForReplication(store2); servers[0].Dispose(); using (var session = store1.OpenAsyncSession()) { var company = await session.LoadAsync <Company>("companies/1"); Assert.NotNull(company); company.Name = "different"; var invalidOperationException = await AssertAsync.Throws <InvalidOperationException>(async() => await session.SaveChangesAsync()); Assert.Equal("Could not replicate POST operation to secondary node, failover behavior is: AllowReadsFromSecondaries", invalidOperationException.Message); } }
public async Task ProducerShouldReportCorrectNumberOfAsyncRequests() { var semaphore = new SemaphoreSlim(0); var scenario = new RoutingScenario(); //block the second call returning from send message async scenario.Connection1.Add(ApiKey.Produce, async _ => { await semaphore.WaitAsync(); return(new ProduceResponse()); }); var router = scenario.CreateRouter(); using (var producer = new Producer(router, new ProducerConfiguration(requestParallelization: 1, batchSize: 1))) { var messages = new[] { new Message("1") }; Assert.That(producer.ActiveSenders, Is.EqualTo(0)); var sendTask = producer.SendAsync(messages, RoutingScenario.TestTopic, CancellationToken.None); await AssertAsync.ThatEventually(() => producer.ActiveSenders >= 1, () => $"senders {producer.ActiveSenders}"); semaphore.Release(); await Task.WhenAny(sendTask, Task.Delay(2500)); Assert.That(sendTask.IsCompleted, Is.True, "Send task should be marked as completed."); Assert.That(producer.ActiveSenders, Is.EqualTo(0), "Async should now show zero count."); } }
public async Task WhenIndexDefinitionDidNotChangeThenWeShouldNotThrowErrorIfIndexIsInLockedErrorStateAsync() { using (var store = NewDocumentStore()) { var index = new People_ByName(); await index.ExecuteAsync(store).ConfigureAwait(false); store.DatabaseCommands.SetIndexLock(index.IndexName, IndexLockMode.LockedError); await index.ExecuteAsync(store).ConfigureAwait(false); await index.SideBySideExecuteAsync(store).ConfigureAwait(false); store.DatabaseCommands.SetIndexLock(index.IndexName, IndexLockMode.Unlock); var definition = index.CreateIndexDefinition(); definition.SortOptions["Name"] = SortOptions.Int; store.DatabaseCommands.PutIndex(index.IndexName, definition, true); store.DatabaseCommands.SetIndexLock(index.IndexName, IndexLockMode.LockedError); await AssertAsync.Throws <IndexCompilationException>(() => index.ExecuteAsync(store)); await AssertAsync.Throws <InvalidOperationException>(() => index.SideBySideExecuteAsync(store)); } }
public async Task RevisionsCannotBeDeletedWithoutProperSetting(string requestedStorage) { const string FileName = "file1.txt"; using (var store = NewStore(requestedStorage: requestedStorage, activeBundles: "Versioning")) { await store.AsyncFilesCommands.Configuration.SetKeyAsync(VersioningUtil.DefaultConfigurationName, new FileVersioningConfiguration { Id = VersioningUtil.DefaultConfigurationName }); await store.AsyncFilesCommands.UploadAsync(FileName, StringToStream(Content1)); await store.AsyncFilesCommands.UploadAsync(FileName, StringToStream(Content2)); var stream = await store.AsyncFilesCommands.DownloadAsync(FileName); Assert.NotNull(stream); Assert.Equal(Content2, StreamToString(stream)); stream = await store.AsyncFilesCommands.DownloadAsync(FileName + "/revisions/1"); Assert.NotNull(stream); Assert.Equal(Content1, StreamToString(stream)); var e = await AssertAsync.Throws <ErrorResponseException>(async() => await store.AsyncFilesCommands.DeleteAsync(FileName + "/revisions/1")); Assert.True(e.Message.Contains("Deleting a historical revision is not allowed")); stream = await store.AsyncFilesCommands.DownloadAsync(FileName + "/revisions/1"); Assert.NotNull(stream); Assert.Equal(Content1, StreamToString(stream)); } }
public async Task SaveIsIncompleteEnsureAllPendingOperationsAreCancelledStream(string storage) { using (var store = NewStore(requestedStorage: storage)) { using (var session = store.OpenAsyncSession()) { var fileStream = CreateUniformFileStream(128); session.RegisterUpload("test2.file", fileStream); session.RegisterUpload("test1.file", 128, x => { for (byte i = 0; i < 60; i++) { x.WriteByte(i); } }); session.RegisterRename("test2.file", "test3.file"); await AssertAsync.Throws <BadRequestException>(() => session.SaveChangesAsync()); var shouldExist = await session.LoadFileAsync("test2.file"); Assert.NotNull(shouldExist); var shouldNotExist = await session.LoadFileAsync("test3.file"); Assert.Null(shouldNotExist); } } }
public void SampleAssertProvider_ExecuteWithMultipleExceptions_Succeeds() { var sampleAssertProvider = new SampleAssertProvider(); AssertAsync.Throws <AggregateException>( sampleAssertProvider.ExecuteWithMultipleExceptions); }
public async Task ShouldDisposeEvenWhileAwaitingReadAndThrowException() { int readSize = 0; var config = new ConnectionConfiguration(onReading: (e, size) => readSize = size); var endpoint = TestConfig.ServerEndpoint(); using (CreateServer(endpoint.Ip.Port, TestConfig.Log)) { var transport = CreateTransport(endpoint, config, TestConfig.Log); try { await transport.ConnectAsync(CancellationToken.None); var buffer = new byte[4]; var taskResult = transport.ReadBytesAsync(new ArraySegment <byte>(buffer), CancellationToken.None); await AssertAsync.ThatEventually(() => readSize > 0, () => $"readSize {readSize}"); using (transport) { } transport = null; await taskResult.CancelAfter(); Assert.Fail("Expected ObjectDisposedException to be thrown"); } catch (ObjectDisposedException) { // expected } finally { transport?.Dispose(); } } }
public async Task When_replicating_and_a_document_is_already_there_will_result_in_conflict() { var store1 = CreateStore(); var store2 = CreateStore(); using (var session = store1.OpenAsyncSession()) { await session.StoreAsync(new Company()); await session.SaveChangesAsync(); } using (var session = store2.OpenAsyncSession()) { await session.StoreAsync(new Company { Name = "Company2" }); await session.SaveChangesAsync(); } TellFirstInstanceToReplicateToSecondInstance(); var conflictException = await AssertAsync.Throws <ConflictException>(async() => { for (int i = 0; i < RetriesCount; i++) { using (var session = store2.OpenAsyncSession()) { await session.LoadAsync <Company>("companies/1"); Thread.Sleep(100); } } }); Assert.Equal("Conflict detected on companies/1, conflict must be resolved before the document will be accessible", conflictException.Message); }
public async Task WriteAsyncShouldSendData() { var endpoint = TestConfig.ServerEndpoint(); using (var server = CreateServer(endpoint.Ip.Port, TestConfig.Log)) using (var transport = CreateTransport(endpoint, TestConfig.Options.ConnectionConfiguration, TestConfig.Log)) { const int testData = 99; var bytes = new byte[4]; int read = 0; #pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously server.OnReceivedAsync = async data => { var offset = Interlocked.Add(ref read, data.Count) - data.Count; for (var i = 0; i < data.Count; i++) { bytes[offset + i] = data.Array[data.Offset + i]; } }; #pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously await transport.ConnectAsync(CancellationToken.None); await transport.WriteBytesAsync(new ArraySegment <byte>(testData.ToBytes()), CancellationToken.None); await AssertAsync.ThatEventually(() => read == 4 && bytes.ToInt32() == testData, () => $"read {read}"); } }
public async Task WriteShouldCancelWhileSendingData() { var clientWriteAttempts = 0; var config = new ConnectionConfiguration(onWritingBytes: (e, payload) => Interlocked.Increment(ref clientWriteAttempts)); var endpoint = TestConfig.ServerEndpoint(); using (var server = CreateServer(endpoint.Ip.Port, TestConfig.Log)) { using (var transport = CreateTransport(endpoint, config, TestConfig.Log)) { using (var token = new CancellationTokenSource()) { await transport.ConnectAsync(token.Token); var write = transport.WriteBytesAsync(new ArraySegment <byte>(1.ToBytes()), token.Token); await Task.WhenAny(server.ClientConnected, Task.Delay(TimeSpan.FromSeconds(3))); await AssertAsync.ThatEventually(() => clientWriteAttempts == 1, () => $"attempts {clientWriteAttempts}"); //create a buffer write that will take a long time var data = Enumerable.Range(0, 1000000).Select(b => (byte)b).ToArray(); token.Cancel(); var taskResult = transport.WriteBytesAsync(new ArraySegment <byte>(data), token.Token, 6); await Task.WhenAny(taskResult, Task.Delay(TimeSpan.FromSeconds(2))).ConfigureAwait(false); Assert.That(taskResult.IsCanceled || !taskResult.IsFaulted, Is.True, "Task should have cancelled."); } } } }
public async Task BehaviorWhenServerIsDown() { using (var store = NewStore()) { var server = GetServer(); var outputDirectory = Path.Combine(server.Configuration.DataDirectory, "Export"); try { var options = new FilesConnectionStringOptions { Url = "http://localhost:8078/", DefaultFileSystem = store.DefaultFileSystem }; var smugglerApi = new SmugglerFilesApi(); var e = await AssertAsync.Throws <SmugglerException>(() => smugglerApi.ImportData(new SmugglerImportOptions <FilesConnectionStringOptions> { FromFile = outputDirectory.ToFullPath(), To = options })); Assert.Contains("Smuggler encountered a connection problem:", e.Message); e = await AssertAsync.Throws <SmugglerException>(() => smugglerApi.ExportData(new SmugglerExportOptions <FilesConnectionStringOptions> { ToFile = outputDirectory.ToFullPath(), From = options })); Assert.Contains("Smuggler encountered a connection problem:", e.Message); } finally { IOExtensions.DeleteDirectory(outputDirectory); } } }
public async Task ReadShouldThrowServerDisconnectedExceptionWhenDisconnected() { var disconnectedCount = 0; var endpoint = TestConfig.ServerEndpoint(); using (var server = CreateServer(endpoint.Ip.Port, TestConfig.Log)) { server.OnDisconnected = () => Interlocked.Increment(ref disconnectedCount); using (var transport = CreateTransport(endpoint, TestConfig.Options.ConnectionConfiguration, TestConfig.Log)) { await transport.ConnectAsync(CancellationToken.None); var buffer = new byte[48]; var taskResult = transport.ReadBytesAsync(new ArraySegment <byte>(buffer, 0, 4), CancellationToken.None); //wait till connected await Task.WhenAny(server.ClientConnected, Task.Delay(TimeSpan.FromSeconds(3))); server.DropConnection(); await AssertAsync.ThatEventually(() => disconnectedCount > 0, () => $"disconnected {disconnectedCount}"); await Task.WhenAny(taskResult, Task.Delay(1000)).ConfigureAwait(false); Assert.That(taskResult.IsFaulted, Is.True); Assert.That(taskResult.Exception.InnerException, Is.TypeOf <ConnectionException>()); } } }
public async Task SmugglerBehaviorWhenServerIsDown() { var options = new SmugglerOptions { BackupPath = Path.GetTempFileName() }; try { var smuggler = new SmugglerApi(options, new RavenConnectionStringOptions { Url = "http://localhost:8078/", DefaultDatabase = "DoesNotExist" }); var e = await AssertAsync.Throws <SmugglerException>(() => smuggler.ImportData(options)); Assert.Equal("Smuggler encountered a connection problem: 'Unable to connect to the remote server'.", e.Message); e = await AssertAsync.Throws <SmugglerException>(() => smuggler.ExportData(null, options, false)); Assert.Equal("Smuggler encountered a connection problem: 'Unable to connect to the remote server'.", e.Message); } finally { IOExtensions.DeleteDirectory(options.BackupPath); } }
public async Task SmugglerShouldThrowIfDatabaseDoesNotExist() { var options = new SmugglerOptions { BackupPath = Path.GetTempFileName() }; try { using (var store = NewRemoteDocumentStore()) { var smuggler = new SmugglerApi(options, new RavenConnectionStringOptions { Url = store.Url, DefaultDatabase = "DoesNotExist" }); var e = await AssertAsync.Throws <SmugglerException>(() => smuggler.ImportData(options)); Assert.Equal("Smuggler does not support database creation (database 'DoesNotExist' on server 'http://localhost:8079' must exist before running Smuggler).", e.Message); e = await AssertAsync.Throws <SmugglerException>(() => smuggler.ExportData(null, options, false)); Assert.Equal("Smuggler does not support database creation (database 'DoesNotExist' on server 'http://localhost:8079' must exist before running Smuggler).", e.Message); } } finally { IOExtensions.DeleteDirectory(options.BackupPath); } }
public async Task Can_disallow_failover() { var store1 = CreateStore(); var store2 = CreateStore(); store1.Conventions.FailoverBehavior = FailoverBehavior.FailImmediately; TellFirstInstanceToReplicateToSecondInstance(); var serverClient = ((ServerClient)store1.DatabaseCommands); serverClient.ReplicationInformer.RefreshReplicationInformation(serverClient); using (var session = store1.OpenAsyncSession()) { await session.StoreAsync(new Company { Name = "Hibernating Rhinos" }); await session.SaveChangesAsync(); } await WaitForReplication(store2); servers[0].Dispose(); using (var session = store1.OpenAsyncSession()) { await AssertAsync.Throws <HttpRequestException>(async() => await session.LoadAsync <Company>("companies/1")); } }
public async Task RevisionsCanBeDeletedWithProperSetting(string requestedStorage) { const string FileName = "file1.txt"; using (var store = NewStore(requestedStorage: requestedStorage, activeBundles: "Versioning", customConfig: configuration => configuration.Settings[Constants.FileSystem.Versioning.ChangesToRevisionsAllowed] = "true")) { await store.AsyncFilesCommands.Configuration.SetKeyAsync(VersioningUtil.DefaultConfigurationName, new FileVersioningConfiguration { Id = VersioningUtil.DefaultConfigurationName }); await store.AsyncFilesCommands.UploadAsync(FileName, StringToStream(Content1)); await store.AsyncFilesCommands.UploadAsync(FileName, StringToStream(Content2)); var stream = await store.AsyncFilesCommands.DownloadAsync(FileName); Assert.NotNull(stream); Assert.Equal(Content2, StreamToString(stream)); stream = await store.AsyncFilesCommands.DownloadAsync(FileName + "/revisions/1"); Assert.NotNull(stream); Assert.Equal(Content1, StreamToString(stream)); await store.AsyncFilesCommands.DeleteAsync(FileName + "/revisions/1"); await AssertAsync.Throws <FileNotFoundException>(async() => await store.AsyncFilesCommands.DownloadAsync(FileName + "/revisions/1")); } }
public IEnumerator CreateDuplicateAccountEmail() { yield return(EnsureTestUserExists()); Mock <EventHandler <AuthEvent> > eventHandler = new Mock <EventHandler <AuthEvent> >(); auth.OnEvent += eventHandler.Object; // test callback Mock <ICallbackHandler <FirebaseUser, FirebaseException> > callback = new Mock <ICallbackHandler <FirebaseUser, FirebaseException> >(); Task taskRegister = AssertAsync.Throws <FirebaseException>(() => { // this method creates a new user and also attempts to logs in with that user return(auth.RegisterUserWithEmail(TEST_EMAIL, TEST_PASSWORD) .WithCallback(callback.Object)); }); yield return(taskRegister.AsIEnumerator()); //LogAssert.Expect(LogType.Log, "CreateUserWithEmailAndPasswordAsync encountered an error: Firebase.FirebaseException: The email address is already in use by another account."); // no login or logout eventHandler.VerifyNoOtherCalls(); callback.Verify(c => c.OnFailure(It.IsAny <FirebaseException>()), Times.Once); callback.VerifyNoOtherCalls(); }
public async Task BetweenOperation_ShouldNotCreateFilesystem() { using (var store = NewStore()) { var smugglerApi = new SmugglerFilesApi(); var options = new SmugglerBetweenOptions <FilesConnectionStringOptions> { From = new FilesConnectionStringOptions { Url = store.Url, DefaultFileSystem = SourceFilesystem }, To = new FilesConnectionStringOptions { Url = store.Url, DefaultFileSystem = DestinationFilesystem } }; var exception = await AssertAsync.Throws <SmugglerException>(() => smugglerApi.Between(options)); Assert.True(exception.Message.StartsWith("Smuggler does not support file system creation (file system '" + SourceFilesystem + "' on server")); await store.AsyncFilesCommands.Admin.EnsureFileSystemExistsAsync(SourceFilesystem); exception = await AssertAsync.Throws <SmugglerException>(() => smugglerApi.Between(options)); Assert.True(exception.Message.StartsWith("Smuggler does not support file system creation (file system '" + DestinationFilesystem + "' on server")); } }
public async Task Should_throw_invalidoperationexception_when_both_method_inputs_and_x_http_method_override_header_are_specified() { await AssertAsync.Throws <InvalidOperationException>(async() => await this.browser.Post("/", with => { with.FormValue("_method", "DELETE"); with.Header("X-HTTP-Method-Override", "DELETE"); })); }
public async Task ConsumerThowsArgumentExceptionWhenMemberMetadataIsNotKnownByConsumer([Values(null, "", "unknown")] string protocolType) { var router = Substitute.For <IRouter>(); await AssertAsync.Throws <ArgumentOutOfRangeException>( () => router.CreateGroupConsumerAsync("group", protocolType, new ByteTypeMetadata("mine", new ArraySegment <byte>()), new ConsumerConfiguration(), ConnectionConfiguration.Defaults.Encoders(), CancellationToken.None), ex => ex.Message.StartsWith($"ProtocolType {protocolType} is unknown")); }
public void Start_Runs_The_Action_And_StopAction() { this.actionRunner.Start(); Thread.Sleep(100); this.actionRunner.Stop(); AssertAsync.IsTrue(() => this.actionHasRun, 200); AssertAsync.IsTrue(() => this.stopActionHasRun, 200); }