public async Task UpdateLatestScan_Updates()
{
string hostId = Guid.NewGuid().ToString();
string storageAccountName = Guid.NewGuid().ToString();
string containerName = Guid.NewGuid().ToString();
var account = new FakeStorageAccount();
var client = account.CreateBlobClient();
var container = client.GetContainerReference(HostContainerNames.Hosts);
container.CreateIfNotExists();
DateTime now = DateTime.UtcNow;
DateTime past = now.AddMinutes(-1);
var blob = GetBlockBlobReference(client, hostId, storageAccountName, containerName);
blob.UploadText(string.Format("{{ 'LatestScan' : '{0}' }}", past.ToString("o")));
var manager = new StorageBlobScanInfoManager(hostId, client);
await manager.UpdateLatestScanAsync(storageAccountName, containerName, now);
var scanInfo = GetBlockBlobReference(client, hostId, storageAccountName, containerName).DownloadText();
var scanInfoJson = JObject.Parse(scanInfo);
var storedTime = (DateTime)scanInfoJson["LatestScan"];
Assert.Equal(now, storedTime);
Assert.Equal(now, await manager.LoadLatestScanAsync(storageAccountName, containerName));
}
public async Task StaticInit()
{
IStorageAccount account = new FakeStorageAccount();
var config = TestHelpers.NewConfig(account);
// Can do the static init. Get the binders.
var ctx = config.CreateStaticServices();
var provider = ctx.GetService <IBindingProvider>();
var attr = new BlobAttribute("container/path", FileAccess.Read);
var result1 = await ScriptHelpers.CanBindAsync(provider, attr, typeof(TextReader));
var result2 = await ScriptHelpers.CanBindAsync(provider, attr, typeof(TextWriter));
Assert.True(result1);
Assert.False(result2);
// Can now set type locator and types, do indexing, and run.
// Important that we're able to set this *after* we've queried the binding graph.
config.TypeLocator = new FakeTypeLocator(typeof(ProgramSimple));
var expected = "123";
using (var jobHost = new JobHost(config))
{
var method = typeof(ProgramSimple).GetMethod("Test");
jobHost.Call(method, new { value = expected });
Assert.Equal(expected, ProgramSimple._value);
}
}
public async Task Blob_IfBoundToCloudBlockBlob_BindsAndCreatesContainerButNotBlob()
{
// Act
var account = new FakeStorageAccount();
var prog = new BindToCloudBlockBlobProgram();
IHost host = new HostBuilder()
.ConfigureDefaultTestHost <BindToCloudBlockBlobProgram>(prog, builder =>
{
builder.AddAzureStorage()
.UseStorage(account);
})
.Build();
var jobHost = host.GetJobHost <BindToCloudBlockBlobProgram>();
await jobHost.CallAsync(nameof(BindToCloudBlockBlobProgram.Run));
var result = prog.Result;
// Assert
Assert.NotNull(result);
Assert.Equal(BlobName, result.Name);
Assert.NotNull(result.Container);
Assert.Equal(ContainerName, result.Container.Name);
CloudBlobContainer container = GetContainerReference(account, ContainerName);
Assert.True(await container.ExistsAsync());
CloudBlockBlob blob = container.GetBlockBlobReference(BlobName);
Assert.False(await blob.ExistsAsync());
}
public async Task Trigger_CanBeInstanceMethod()
{
// Arrange
string expectedGuid = Guid.NewGuid().ToString();
CloudQueueMessage expectedMessage = new CloudQueueMessage(expectedGuid);
var account = new FakeStorageAccount();
await account.AddQueueMessageAsync(expectedMessage, QueueName);
var prog = new InstanceProgram();
IHost host = new HostBuilder()
.ConfigureDefaultTestHost <InstanceProgram>(prog, builder =>
{
builder.AddAzureStorage()
.UseStorage(account);
})
.Build();
// Act
var jobHost = host.GetJobHost <InstanceProgram>();
var result = await jobHost.RunTriggerAsync <CloudQueueMessage>();
// Assert
Assert.Equal(expectedGuid, result.AsString);
}
// Helper for quickly testing indexing errors
public static void AssertIndexingError <TProgram>(string methodName, string expectedErrorMessage)
{
// Need to pass an account to get passed initial validation checks.
IStorageAccount account = new FakeStorageAccount();
var host = TestHelpers.NewJobHost <TProgram>(account);
host.AssertIndexingError(methodName, expectedErrorMessage);
}
private static async Task <StorageAccount> CreateFakeStorageAccountAsync()
{
var account = new FakeStorageAccount();
// make sure our system containers are present
var container = await CreateContainerAsync(account, "azure-webjobs-hosts");
return(account);
}
public void Table_SingleOut_Supported()
{
IStorageAccount account = new FakeStorageAccount();
var host = TestHelpers.NewJobHost <BindToSingleOutProgram>(account);
host.Call("Run");
AssertStringProperty(account, "Property", "1234");
}
private static IStorageAccount CreateFakeStorageAccount()
{
var account = new FakeStorageAccount();
// make sure our system containers are present
var container = CreateContainer(account, "azure-webjobs-hosts");
return(account);
}
public void Table_ResolvedName()
{
IStorageAccount account = new FakeStorageAccount();
var host = TestHelpers.NewJobHost <BindToICollectorITableEntityResolvedTableProgram>(account);
host.Call("Run", new { t1 = "ZZ" });
AssertStringProperty(account, "Property", "123", "TaZZ");
AssertStringProperty(account, "Property", "456", "ZZxZZ");
}
private static async Task<TResult> CallQueueTriggerAsync<TResult>(object message, Type programType,
Action<TaskCompletionSource<TResult>> setTaskSource)
{
var account = new FakeStorageAccount();
var method = programType.GetMethod("Run");
Assert.NotNull(method);
var result = await FunctionalTest.CallAsync<TResult>(account, programType, method, new Dictionary<string, object>
{
{ "message", message }
}, setTaskSource);
return result;
}
public async Task LoadLatestScan_NoContainer_ReturnsNull()
{
string hostId = Guid.NewGuid().ToString();
string storageAccountName = Guid.NewGuid().ToString();
string containerName = Guid.NewGuid().ToString();
var account = new FakeStorageAccount();
var client = account.CreateBlobClient();
// by default there is no table in this client
var manager = new StorageBlobScanInfoManager(hostId, client);
var result = await manager.LoadLatestScanAsync(storageAccountName, containerName);
Assert.Null(result);
}
public async Task LoadLatestScan_NoBlob_ReturnsNull()
{
string hostId = Guid.NewGuid().ToString();
string storageAccountName = Guid.NewGuid().ToString();
string containerName = Guid.NewGuid().ToString();
var account = new FakeStorageAccount();
var client = account.CreateCloudBlobClient();
var container = client.GetContainerReference(HostContainerNames.Hosts);
await container.CreateIfNotExistsAsync();
var manager = new StorageBlobScanInfoManager(hostId, client);
var result = await manager.LoadLatestScanAsync(storageAccountName, containerName);
Assert.Null(result);
}
public async Task Stop_TriggersCancellationToken()
{
StorageAccount account = new FakeStorageAccount();
CloudQueue queue = await CreateQueueAsync(account, QueueName);
CloudQueueMessage message = new CloudQueueMessage("ignore");
await queue.AddMessageAsync(message);
var host = new HostBuilder()
.ConfigureDefaultTestHost <CallbackCancellationTokenProgram>(c =>
{
c.AddAzureStorage();
c.Services.AddSingleton <StorageAccountProvider>(_ => new FakeStorageAccountProvider(account));
})
.Build();
using (host)
{
int secondsToWait = 5;
// Start and wait for the function to be invoked.
await host.StartAsync();
bool completed = _functionStarted.Task.WaitUntilCompleted(secondsToWait * 1000);
Assert.True(completed, $"Function did not start in {secondsToWait} seconds.");
// Stop the host and let the function know it can continue.
Task stopTask = host.StopAsync();
_stopHostCalled.TrySetResult(null);
completed = _testTaskSource.Task.WaitUntilCompleted(secondsToWait * 1000);
Assert.True(completed, $"Host did not shut down in {secondsToWait} seconds.");
// Give a nicer test failure message for faulted tasks.
if (_testTaskSource.Task.Status == TaskStatus.Faulted)
{
await _testTaskSource.Task;
}
Assert.Equal(TaskStatus.RanToCompletion, _testTaskSource.Task.Status);
stopTask.WaitUntilCompleted(3 * 1000);
Assert.Equal(TaskStatus.RanToCompletion, stopTask.Status);
}
}
public async Task Trigger_IfClassIsDisposable_Disposes()
{
// Arrange
CloudQueueMessage expectedMessage = new CloudQueueMessage("ignore");
var account = new FakeStorageAccount();
await account.AddQueueMessageAsync(expectedMessage, QueueName);
IHost host = new HostBuilder()
.ConfigureDefaultTestHost <DisposeInstanceProgram>(builder =>
{
builder.UseStorage(account);
})
.Build();
// Act & Assert
var jobHost = host.GetJobHost <DisposeInstanceProgram>();
var result = await jobHost.RunTriggerAsync <object>(DisposeInstanceProgram.TaskSource);
}
public async Task LoadLatestScan_Returns_Timestamp()
{
string hostId = "host-" + Guid.NewGuid().ToString();
string storageAccountName = "account=" + Guid.NewGuid().ToString();
string containerName = "container-" + Guid.NewGuid().ToString();
var account = new FakeStorageAccount();
var client = account.CreateCloudBlobClient();
var container = client.GetContainerReference(HostContainerNames.Hosts);
await container.CreateIfNotExistsAsync();
DateTime now = DateTime.UtcNow;
var blob = GetBlockBlobReference(client, hostId, storageAccountName, containerName);
await blob.UploadTextAsync(string.Format("{{ \"LatestScan\" : \"{0}\" }}", now.ToString("o")));
var manager = new StorageBlobScanInfoManager(hostId, client);
var result = await manager.LoadLatestScanAsync(storageAccountName, containerName);
Assert.Equal(now, result);
}
public void FlushAfterAdd_PersistsEntity()
{
// Arrange
var account = new FakeStorageAccount();
var client = account.CreateCloudTableClient();
var table = client.GetTableReference("Table");
TableEntityWriter <ITableEntity> product = new TableEntityWriter <ITableEntity>(table);
const string partitionKey = "PK";
const string rowKey = "RK";
DynamicTableEntity entity = new DynamicTableEntity(partitionKey, rowKey);
product.Add(entity);
// Act
product.FlushAsync().GetAwaiter().GetResult();
// Assert
DynamicTableEntity persisted = table.Retrieve <DynamicTableEntity>(partitionKey, rowKey);
Assert.NotNull(persisted);
}
public async Task Trigger_IfClassConstructorHasDependencies_CanUseCustomJobActivator()
{
// Arrange
const string expectedResult = "abc";
Mock <IFactory <string> > resultFactoryMock = new Mock <IFactory <string> >(MockBehavior.Strict);
resultFactoryMock.Setup(f => f.Create()).Returns(expectedResult);
IFactory <string> resultFactory = resultFactoryMock.Object;
Mock <IJobActivator> activatorMock = new Mock <IJobActivator>(MockBehavior.Strict);
activatorMock.Setup(a => a.CreateInstance <InstanceCustomActivatorProgram>())
.Returns(() => new InstanceCustomActivatorProgram(resultFactory));
IJobActivator activator = activatorMock.Object;
CloudQueueMessage message = new CloudQueueMessage("ignore");
var account = new FakeStorageAccount();
await account.AddQueueMessageAsync(message, QueueName);
IHost host = new HostBuilder()
.ConfigureDefaultTestHost <InstanceCustomActivatorProgram>(builder =>
{
builder.UseStorage(account);
}, null, activator)
.Build();
// Act
var jobHost = host.GetJobHost <InstanceCustomActivatorProgram>();
Assert.NotNull(jobHost);
var result = await jobHost.RunTriggerAsync <string>(InstanceCustomActivatorProgram.TaskSource);
// Assert
Assert.Same(expectedResult, result);
}
public async Task UpdateLatestScan_Inserts()
{
string hostId = Guid.NewGuid().ToString();
string storageAccountName = Guid.NewGuid().ToString();
string containerName = Guid.NewGuid().ToString();
var account = new FakeStorageAccount();
var client = account.CreateCloudBlobClient();
var container = client.GetContainerReference(HostContainerNames.Hosts);
await container.CreateIfNotExistsAsync();
DateTime now = DateTime.UtcNow;
var manager = new StorageBlobScanInfoManager(hostId, client);
await manager.UpdateLatestScanAsync(storageAccountName, containerName, now);
var scanInfo = GetBlockBlobReference(client, hostId, storageAccountName, containerName).DownloadText();
var scanInfoJson = JObject.Parse(scanInfo);
var storedTime = (DateTime)(scanInfoJson["LatestScan"]);
Assert.Equal(now, storedTime);
Assert.Equal(now, await manager.LoadLatestScanAsync(storageAccountName, containerName));
}
