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);
}
