public AsyncChainEndToEndTests(TestFixture fixture)
{
_fixture = fixture;
_resolver = new RandomNameResolver();
_hostConfig = new JobHostConfiguration()
{
NameResolver = _resolver,
TypeLocator = new FakeTypeLocator(typeof(AsyncChainEndToEndTests))
};
_defaultExceptionHandler = new TestExceptionHandler();
_hostConfig.AddService <IWebJobsExceptionHandler>(_defaultExceptionHandler);
_hostConfig.Queues.MaxPollingInterval = TimeSpan.FromSeconds(2);
_storageAccount = fixture.StorageAccount;
_timeoutJobDelay = TimeSpan.FromMinutes(5);
ILoggerFactory loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(_loggerProvider);
_hostConfig.LoggerFactory = loggerFactory;
_hostConfig.Aggregator.IsEnabled = false; // makes validation easier
CloudQueueClient queueClient = _storageAccount.CreateCloudQueueClient();
string queueName = _resolver.ResolveInString(TestQueueName);
_testQueue = queueClient.GetQueueReference(queueName);
if (!_testQueue.CreateIfNotExistsAsync().Result)
{
_testQueue.ClearAsync().Wait();
}
}
public async Task DynamicConcurrency_Queues()
{
// Reinitialize the name resolver to avoid conflicts
_resolver = new RandomNameResolver();
DynamicConcurrencyTestJob.InvocationCount = 0;
IHost host = new HostBuilder()
.ConfigureDefaultTestHost <DynamicConcurrencyTestJob>(b =>
{
b.AddAzureStorageQueues();
b.Services.AddOptions <ConcurrencyOptions>().Configure(options =>
{
options.DynamicConcurrencyEnabled = true;
});
})
.ConfigureServices(services =>
{
services.AddSingleton <INameResolver>(_resolver);
})
.ConfigureLogging((context, b) =>
{
b.SetMinimumLevel(LogLevel.Debug);
})
.Build();
MethodInfo methodInfo = typeof(DynamicConcurrencyTestJob).GetMethod("ProcessMessage", BindingFlags.Public | BindingFlags.Static);
string functionId = $"{methodInfo.DeclaringType.FullName}.{methodInfo.Name}";
var concurrencyManager = host.Services.GetServices <ConcurrencyManager>().SingleOrDefault();
var concurrencyStatus = concurrencyManager.GetStatus(functionId);
Assert.AreEqual(1, concurrencyStatus.CurrentConcurrency);
// write a bunch of queue messages
int numMessages = 300;
string queueName = _resolver.ResolveInString(DynamicConcurrencyQueueName);
await WriteQueueMessages(queueName, numMessages);
// start the host
await host.StartAsync();
// wait for all messages to be processed
await TestHelpers.Await(() =>
{
return(DynamicConcurrencyTestJob.InvocationCount >= numMessages);
});
await host.StopAsync();
// ensure we've dynamically increased concurrency
concurrencyStatus = concurrencyManager.GetStatus(functionId);
Assert.GreaterOrEqual(concurrencyStatus.CurrentConcurrency, 5);
// check a few of the concurrency logs
var concurrencyLogs = host.GetTestLoggerProvider().GetAllLogMessages().Where(p => p.Category == LogCategories.Concurrency).Select(p => p.FormattedMessage).ToList();
int concurrencyIncreaseLogCount = concurrencyLogs.Count(p => p.Contains("ProcessMessage Increasing concurrency"));
Assert.GreaterOrEqual(concurrencyIncreaseLogCount, 3);
}
private async Task AsyncChainEndToEndInternal()
{
_resolver = new RandomNameResolver();
JobHostConfiguration hostConfiguration = new JobHostConfiguration()
{
NameResolver = _resolver,
TypeLocator = new FakeTypeLocator(typeof(AsyncChainEndToEndTests))
};
_storageAccount = CloudStorageAccount.Parse(hostConfiguration.StorageConnectionString);
JobHost host = new JobHost(hostConfiguration);
await host.StartAsync();
await host.CallAsync(typeof(AsyncChainEndToEndTests).GetMethod("WriteStartDataMessageToQueue"));
_functionCompletedEvent.WaitOne();
// Stop async waits for the function to complete
await host.StopAsync();
await host.CallAsync(typeof(AsyncChainEndToEndTests).GetMethod("ReadResultBlob"));
Assert.Equal("async works", _finalBlobContent);
}
/// <summary>
/// There is a function that takes > 10 minutes and listens to a queue.
/// </summary>
/// <remarks>Ignored because it takes a long time. Can be enabled on demand</remarks>
// Uncomment the Fact attribute to run
//[Fact(Timeout = 20 * 60 * 1000)]
public void QueueMessageLeaseRenew()
{
_messageFoundAgain = false;
RandomNameResolver nameResolver = new RandomNameResolver();
JobHostConfiguration hostConfig = new JobHostConfiguration()
{
NameResolver = nameResolver,
TypeLocator = new FakeTypeLocator(typeof(LeaseExpirationTests))
};
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(hostConfig.StorageConnectionString);
CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient();
CloudQueue queue = queueClient.GetQueueReference(nameResolver.ResolveInString(TestQueueName));
try
{
queue.CreateIfNotExists();
queue.AddMessage(new CloudQueueMessage("Test"));
_tokenSource = new CancellationTokenSource();
JobHost host = new JobHost(hostConfig);
_tokenSource.Token.Register(host.Stop);
host.RunAndBlock();
Assert.False(_messageFoundAgain);
}
finally
{
queue.DeleteIfExists();
}
}
private void ServiceBusEndToEndInternal()
{
// Reinitialize the name resolver to avoid naming conflicts
_nameResolver = new RandomNameResolver();
JobHostConfiguration config = new JobHostConfiguration()
{
NameResolver = _nameResolver,
TypeLocator = new FakeTypeLocator(this.GetType())
};
_namespaceManager = NamespaceManager.CreateFromConnectionString(config.ServiceBusConnectionString);
CreateStartMessage(config.ServiceBusConnectionString);
JobHost host = new JobHost(config);
_topicSubscriptionCalled1 = new ManualResetEvent(initialState: false);
_topicSubscriptionCalled2 = new ManualResetEvent(initialState: false);
host.Start();
bool signaled = WaitHandle.WaitAll(
new WaitHandle[] { _topicSubscriptionCalled1, _topicSubscriptionCalled2 },
2 * 60 * 1000);
// Wait for the host to terminate
host.Stop();
Assert.True(signaled);
Assert.Equal("E2E-SBQueue2SBQueue-SBQueue2SBTopic-topic-1", _resultMessage1);
Assert.Equal("E2E-SBQueue2SBQueue-SBQueue2SBTopic-topic-2", _resultMessage2);
}
public IHost ConfigureHost(LogLevel logLevel)
{
_resolver = new RandomNameResolver();
IHost host = new HostBuilder()
.ConfigureDefaultTestHost <HttpDependencyCollectionTests>(b =>
{
b.AddAzureStorage();
})
.ConfigureServices(services =>
{
services.AddSingleton <INameResolver>(_resolver);
services.Configure <FunctionResultAggregatorOptions>(o =>
{
o.IsEnabled = false;
});
})
.ConfigureLogging(b =>
{
b.SetMinimumLevel(logLevel);
b.AddApplicationInsightsWebJobs(o => o.InstrumentationKey = _mockApplicationInsightsKey);
})
.Build();
TelemetryConfiguration telemteryConfiguration = host.Services.GetService <TelemetryConfiguration>();
telemteryConfiguration.TelemetryChannel = _channel;
StorageAccountProvider provider = host.Services.GetService <StorageAccountProvider>();
CloudStorageAccount storageAccount = provider.GetHost().SdkObject;
_blobClient = storageAccount.CreateCloudBlobClient();
_queueClient = storageAccount.CreateCloudQueueClient();
_inputContainerName = _resolver.ResolveInString(InputContainerNamePattern);
_outputContainerName = _resolver.ResolveInString(OutputContainerNamePattern);
_triggerContainerName = _resolver.ResolveInString(TriggerContainerNamePattern);
_outputQueueName = _resolver.ResolveInString(OutputQueueNamePattern);
_triggerQueueName = _resolver.ResolveInString(TriggerQueueNamePattern);
CloudBlobContainer inContainer = _blobClient.GetContainerReference(_inputContainerName);
CloudBlobContainer outContainer = _blobClient.GetContainerReference(_outputContainerName);
CloudBlobContainer triggerContainer = _blobClient.GetContainerReference(_triggerContainerName);
CloudQueue outputQueue = _queueClient.GetQueueReference(_outputQueueName);
_triggerQueue = _queueClient.GetQueueReference(_triggerQueueName);
inContainer.CreateIfNotExistsAsync().Wait();
outContainer.CreateIfNotExistsAsync().Wait();
triggerContainer.CreateIfNotExistsAsync().Wait();
outputQueue.CreateIfNotExistsAsync().Wait();
_triggerQueue.CreateIfNotExistsAsync().Wait();
CloudBlockBlob inBlob = inContainer.GetBlockBlobReference("in");
inBlob.UploadTextAsync("TestData").Wait();
return(host);
}
public ServiceBusEndToEndTests()
{
_serviceBusConfig = new ServiceBusConfiguration();
_nameResolver = new RandomNameResolver();
_secondaryConnectionString = AmbientConnectionStringProvider.Instance.GetConnectionString("ServiceBusSecondary");
_loggerFactory.AddProvider(_loggerProvider);
}
public ServiceBusEndToEndTests()
{
_serviceBusConfig = new ServiceBusConfiguration();
_nameResolver = new RandomNameResolver();
_namespaceManager = NamespaceManager.CreateFromConnectionString(_serviceBusConfig.ConnectionString);
_secondaryConnectionString = AmbientConnectionStringProvider.Instance.GetConnectionString("ServiceBusSecondary");
_secondaryNamespaceManager = NamespaceManager.CreateFromConnectionString(_secondaryConnectionString);
}
public AsyncChainEndToEndTests(TestFixture fixture)
{
_resolver = new RandomNameResolver();
_hostConfig = new JobHostConfiguration()
{
NameResolver = _resolver,
TypeLocator = new FakeTypeLocator(typeof(AsyncChainEndToEndTests))
};
_storageAccount = fixture.StorageAccount;
}
public BlobTriggerEndToEndTests()
{
_nameResolver = new RandomNameResolver();
var storageConnectionString = new JobHostConfiguration().StorageConnectionString;
_storageAccount = CloudStorageAccount.Parse(storageConnectionString);
CloudBlobClient blobClient = _storageAccount.CreateCloudBlobClient();
_testContainer = blobClient.GetContainerReference(_nameResolver.ResolveInString(SingleTriggerContainerName));
Assert.False(_testContainer.ExistsAsync().Result);
_testContainer.CreateAsync().Wait();
}
public ServiceBusSessionsBusEndToEndTests()
{
var config = new ConfigurationBuilder()
.AddEnvironmentVariables()
.AddTestSettings()
.Build();
_connectionString = config.GetConnectionStringOrSetting(ServiceBus.Constants.DefaultConnectionStringName);
_nameResolver = new RandomNameResolver();
Cleanup().GetAwaiter().GetResult();
}
public AsyncChainEndToEndTests(TestFixture fixture)
{
_resolver = new RandomNameResolver();
_hostConfig = new JobHostConfiguration()
{
NameResolver = _resolver,
TypeLocator = new FakeTypeLocator(typeof(AsyncChainEndToEndTests))
};
_hostConfig.Queues.MaxPollingInterval = TimeSpan.FromSeconds(2);
_storageAccount = fixture.StorageAccount;
}
public async Task MaxDegreeOfParallelism_Queues(int batchSize, int maxExpectedParallelism)
{
_receivedMessages = 0;
_currentSimultaneouslyRunningFunctions = 0;
_maxSimultaneouslyRunningFunctions = 0;
_numberOfQueueMessages = batchSize * 3;
RandomNameResolver nameResolver = new RandomNameResolver();
IHost host = new HostBuilder()
.ConfigureDefaultTestHost <ParallelExecutionTests>(b =>
{
b.AddAzureStorage();
})
.ConfigureServices(services =>
{
services.AddSingleton <INameResolver>(nameResolver);
services.Configure <QueuesOptions>(o => o.BatchSize = batchSize);
})
.Build();
StorageAccount storageAccount = host.GetStorageAccount();
_queueClient = storageAccount.CreateCloudQueueClient();
CloudQueue queue = _queueClient.GetQueueReference(nameResolver.ResolveInString(TestQueueName));
await queue.CreateIfNotExistsAsync();
for (int i = 0; i < _numberOfQueueMessages; i++)
{
int sleepTimeInSeconds = i % 2 == 0 ? 5 : 1;
await queue.AddMessageAsync(new CloudQueueMessage(sleepTimeInSeconds.ToString()));
}
using (_allMessagesProcessed = new ManualResetEvent(initialState: false))
using (host)
{
await host.StartAsync();
_allMessagesProcessed.WaitOne(TimeSpan.FromSeconds(90));
await host.StopAsync();
}
Assert.Equal(_numberOfQueueMessages, _receivedMessages);
Assert.Equal(0, _currentSimultaneouslyRunningFunctions);
// the actual value will vary sometimes based on the speed of the machine
// running the test.
int delta = _maxSimultaneouslyRunningFunctions - maxExpectedParallelism;
Assert.True(delta == 0 || delta == 1, $"Expected delta of 0 or 1. Actual: {delta}.");
}
public void MaxDegreeOfParallelism_Queues(int batchSize)
{
_receivedMessages = 0;
_currentSimultaneouslyRunningFunctions = 0;
_maxSimultaneouslyRunningFunctions = 0;
int expectedMaxSimultaneouslyRunningFunctions = (int)Math.Floor(batchSize + 0.5 * batchSize);
_numberOfQueueMessages = batchSize * 3;
RandomNameResolver nameResolver = new RandomNameResolver();
JobHostConfiguration hostConfiguration = new JobHostConfiguration()
{
NameResolver = nameResolver,
TypeLocator = new FakeTypeLocator(typeof(ParallelExecutionTests)),
};
hostConfiguration.Queues.BatchSize = batchSize;
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(hostConfiguration.StorageConnectionString);
CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient();
CloudQueue queue = queueClient.GetQueueReference(nameResolver.ResolveInString(TestQueueName));
queue.CreateIfNotExists();
try
{
for (int i = 0; i < _numberOfQueueMessages; i++)
{
int sleepTimeInSeconds = i % 2 == 0 ? 5 : 1;
queue.AddMessage(new CloudQueueMessage(sleepTimeInSeconds.ToString()));
}
using (_allMessagesProcessed = new ManualResetEvent(initialState: false))
using (JobHost host = new JobHost(hostConfiguration))
{
host.Start();
_allMessagesProcessed.WaitOne(TimeSpan.FromSeconds(90));
host.Stop();
}
Assert.Equal(_numberOfQueueMessages, _receivedMessages);
Assert.Equal(0, _currentSimultaneouslyRunningFunctions);
Assert.Equal(expectedMaxSimultaneouslyRunningFunctions, _maxSimultaneouslyRunningFunctions);
}
finally
{
queue.DeleteIfExists();
}
}
public ServiceBusEndToEndTests()
{
var config = new ConfigurationBuilder()
.AddEnvironmentVariables()
.Build();
var configSection = Utility.GetExtensionConfigurationSection(config, "ServiceBus");
_primaryConnectionString = configSection.GetConnectionString("Primary");
_secondaryConnectionString = configSection.GetConnectionString("Secondary");
_nameResolver = new RandomNameResolver();
Cleanup().GetAwaiter().GetResult();
}
public Task <JobHostContext> CreateAndLogHostStartedAsync(JobHost host, CancellationToken shutdownToken, CancellationToken cancellationToken)
{
INameResolver nameResolver = new RandomNameResolver();
JobHostConfiguration config = new JobHostConfiguration
{
NameResolver = nameResolver,
TypeLocator = TypeLocator
};
return(JobHostContextFactory.CreateAndLogHostStartedAsync(
host, StorageAccountProvider, QueueConfiguration, TypeLocator, DefaultJobActivator.Instance, nameResolver,
ConsoleProvider, new JobHostConfiguration(), shutdownToken, cancellationToken, BackgroundExceptionDispatcher, HostIdProvider, FunctionExecutor,
FunctionIndexProvider, BindingProvider, HostInstanceLoggerProvider, FunctionInstanceLoggerProvider,
FunctionOutputLoggerProvider));
}
public ServiceBusEndToEndTests()
{
var config = new ConfigurationBuilder()
.AddEnvironmentVariables()
.AddTestSettings()
.Build();
_eventWait = new ManualResetEvent(initialState: false);
_primaryConnectionString = config.GetConnectionStringOrSetting(ServiceBus.Constants.DefaultConnectionStringName);
_secondaryConnectionString = config.GetConnectionStringOrSetting(SecondaryConnectionStringKey);
_nameResolver = new RandomNameResolver();
Cleanup().GetAwaiter().GetResult();
}
public async Task InitializeAsync(WebJobsTestEnvironment testEnvironment)
{
RandomNameResolver nameResolver = new RandomNameResolver();
CacheMock = CreateMockFunctionDataCache();
CacheMock
.Setup(c => c.IsEnabled)
.Returns(true);
IFunctionDataCache cache = CacheMock.Object;
Host = new HostBuilder()
.ConfigureDefaultTestHost <CacheableBlobsEndToEndTests>(b =>
{
b.AddAzureStorageBlobs().AddAzureStorageQueues();
b.AddAzureStorageCoreServices();
})
.ConfigureServices(services =>
{
services.AddSingleton <INameResolver>(nameResolver)
.AddSingleton(cache);
})
.Build();
JobHost = Host.GetJobHost();
BlobServiceClient = new BlobServiceClient(testEnvironment.PrimaryStorageAccountConnectionString);
BlobContainer = BlobServiceClient.GetBlobContainerClient(nameResolver.ResolveInString(ContainerName));
Assert.False(await BlobContainer.ExistsAsync());
await BlobContainer.CreateAsync();
OutputBlobContainer = BlobServiceClient.GetBlobContainerClient(nameResolver.ResolveInString(OutputContainerName));
await Host.StartAsync();
// Upload some test blobs
BlockBlobClient blob = BlobContainer.GetBlockBlobClient(InputBlobName);
await blob.UploadTextAsync(TestData);
// Get information about the uploaded blob
BlobProperties blobProperties = await blob.GetPropertiesAsync();
string blobId = blob.Uri.ToString();
string blobVersion = blobProperties.ETag.ToString();
_expectedBlobCacheKey = new FunctionDataCacheKey(blobId, blobVersion);
}
public async Task MaxDegreeOfParallelism_Queues(int batchSize, int maxExpectedParallelism)
{
_receivedMessages = 0;
_currentSimultaneouslyRunningFunctions = 0;
_maxSimultaneouslyRunningFunctions = 0;
_numberOfQueueMessages = batchSize * 3;
RandomNameResolver nameResolver = new RandomNameResolver();
JobHostConfiguration hostConfiguration = new JobHostConfiguration()
{
NameResolver = nameResolver,
TypeLocator = new FakeTypeLocator(typeof(ParallelExecutionTests)),
};
hostConfiguration.AddService <IWebJobsExceptionHandler>(new TestExceptionHandler());
hostConfiguration.Queues.BatchSize = batchSize;
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(hostConfiguration.StorageConnectionString);
_queueClient = storageAccount.CreateCloudQueueClient();
CloudQueue queue = _queueClient.GetQueueReference(nameResolver.ResolveInString(TestQueueName));
await queue.CreateIfNotExistsAsync();
for (int i = 0; i < _numberOfQueueMessages; i++)
{
int sleepTimeInSeconds = i % 2 == 0 ? 5 : 1;
await queue.AddMessageAsync(new CloudQueueMessage(sleepTimeInSeconds.ToString()));
}
using (_allMessagesProcessed = new ManualResetEvent(initialState: false))
using (JobHost host = new JobHost(hostConfiguration))
{
host.Start();
_allMessagesProcessed.WaitOne(TimeSpan.FromSeconds(90));
host.Stop();
}
Assert.Equal(_numberOfQueueMessages, _receivedMessages);
Assert.Equal(0, _currentSimultaneouslyRunningFunctions);
// the actual value will vary sometimes based on the speed of the machine
// running the test.
int delta = _maxSimultaneouslyRunningFunctions - maxExpectedParallelism;
Assert.True(delta == 0 || delta == 1);
}
public AsyncCancellationEndToEndTests()
{
_resolver = new RandomNameResolver();
_hostConfiguration = new JobHostConfiguration()
{
NameResolver = _resolver,
TypeLocator = new FakeTypeLocator(typeof(AsyncCancellationEndToEndTests))
};
_storageAccount = CloudStorageAccount.Parse(_hostConfiguration.StorageConnectionString);
_invokeInFunction = () => { };
_tokenCancelled = false;
_functionStarted = new ManualResetEvent(initialState: false);
_functionCompleted = new ManualResetEvent(initialState: false);
}
private async Task EndToEndTest(bool uploadBlobBeforeHostStart)
{
// Reinitialize the name resolver to avoid conflicts
_resolver = new RandomNameResolver();
IHost host = new HostBuilder()
.ConfigureDefaultTestHost <AzureStorageEndToEndTests>(b =>
{
b.AddAzureStorage();
})
.ConfigureServices(services =>
{
services.AddSingleton <INameResolver>(_resolver);
})
.Build();
if (uploadBlobBeforeHostStart)
{
// The function will be triggered fast because the blob is already there
await UploadTestObject();
}
// The jobs host is started
JobHost jobHost = host.GetJobHost();
_functionChainWaitHandle = new ManualResetEvent(initialState: false);
await host.StartAsync();
if (!uploadBlobBeforeHostStart)
{
await WaitForTestFunctionsToStart();
await UploadTestObject();
}
var waitTime = TimeSpan.FromSeconds(15);
bool signaled = _functionChainWaitHandle.WaitOne(waitTime);
// Stop the host and wait for it to finish
await host.StopAsync();
Assert.True(signaled, $"[{DateTime.UtcNow.ToString("HH:mm:ss.fff")}] Function chain did not complete in {waitTime}. Logs:{Environment.NewLine}{host.GetTestLoggerProvider().GetLogString()}");
// Verify
await VerifyTableResultsAsync();
}
public LeaseExpirationTests()
{
RandomNameResolver nameResolver = new RandomNameResolver();
_config = new JobHostConfiguration()
{
NameResolver = nameResolver,
TypeLocator = new FakeTypeLocator(typeof(LeaseExpirationTests))
};
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(_config.StorageConnectionString);
_queueClient = storageAccount.CreateCloudQueueClient();
_queue = _queueClient.GetQueueReference(nameResolver.ResolveInString(TestQueueName));
_queue.CreateIfNotExistsAsync().Wait();
}
public Task <JobHostContext> CreateAndLogHostStartedAsync(CancellationToken shutdownToken, CancellationToken cancellationToken)
{
ITypeLocator typeLocator = new DefaultTypeLocator(new StringWriter());
INameResolver nameResolver = new RandomNameResolver();
JobHostConfiguration config = new JobHostConfiguration
{
NameResolver = nameResolver,
TypeLocator = typeLocator
};
return(JobHostContextFactory.CreateAndLogHostStartedAsync(
StorageAccountProvider, config.Queues, typeLocator, DefaultJobActivator.Instance, nameResolver,
new NullConsoleProvider(), new JobHostConfiguration(), shutdownToken, cancellationToken,
new FixedHostIdProvider(Guid.NewGuid().ToString("N")),
null, new EmptyFunctionIndexProvider(),
null, new NullHostInstanceLoggerProvider(), new NullFunctionInstanceLoggerProvider(), new NullFunctionOutputLoggerProvider()));
}
public BlobTriggerEndToEndTests()
{
_nameResolver = new RandomNameResolver();
// pull from a default host
var host = new HostBuilder()
.ConfigureDefaultTestHost(b =>
{
b.AddAzureStorageBlobs().AddAzureStorageQueues();
})
.Build();
_blobServiceClient = new BlobServiceClient(TestEnvironment.PrimaryStorageAccountConnectionString);
_testContainer = _blobServiceClient.GetBlobContainerClient(_nameResolver.ResolveInString(SingleTriggerContainerName));
Assert.False(_testContainer.ExistsAsync().Result);
_testContainer.CreateAsync().Wait();
}
public BlobTriggerEndToEndTests()
{
_timesProcessed = 0;
_nameResolver = new RandomNameResolver();
_hostConfiguration = new JobHostConfiguration()
{
NameResolver = _nameResolver,
TypeLocator = new FakeTypeLocator(this.GetType()),
};
_storageAccount = CloudStorageAccount.Parse(_hostConfiguration.StorageConnectionString);
CloudBlobClient blobClient = _storageAccount.CreateCloudBlobClient();
_testContainer = blobClient.GetContainerReference(_nameResolver.ResolveInString(SingleTriggerContainerName));
Assert.False(_testContainer.Exists());
_testContainer.Create();
}
private async Task EndToEndTest(bool uploadBlobBeforeHostStart)
{
// Reinitialize the name resolver to avoid conflicts
_resolver = new RandomNameResolver();
JobHostConfiguration hostConfig = new JobHostConfiguration()
{
NameResolver = _resolver,
TypeLocator = new FakeTypeLocator(
this.GetType(),
typeof(BlobToCustomObjectBinder))
};
hostConfig.AddService <IWebJobsExceptionHandler>(new TestExceptionHandler());
if (uploadBlobBeforeHostStart)
{
// The function will be triggered fast because the blob is already there
await UploadTestObject();
}
// The jobs host is started
JobHost host = new JobHost(hostConfig);
_functionChainWaitHandle = new ManualResetEvent(initialState: false);
host.Start();
if (!uploadBlobBeforeHostStart)
{
await WaitForTestFunctionsToStart();
await UploadTestObject();
}
bool signaled = _functionChainWaitHandle.WaitOne(15 * 1000);
// Stop the host and wait for it to finish
host.Stop();
Assert.True(signaled);
// Verify
await VerifyTableResultsAsync();
}
private void EndToEndTestInternal(bool uploadBlobBeforeHostStart)
{
// Reinitialize the name resolver to avoid conflicts
_resolver = new RandomNameResolver();
JobHostConfiguration hostConfig = new JobHostConfiguration()
{
NameResolver = _resolver,
TypeLocator = new FakeTypeLocator(
this.GetType(),
typeof(BlobToCustomObjectBinder))
};
_storageAccount = CloudStorageAccount.Parse(hostConfig.StorageConnectionString);
if (uploadBlobBeforeHostStart)
{
// The function will be triggered fast because the blob is already there
UploadTestObject();
}
// The jobs host is started
JobHost host = new JobHost(hostConfig);
_functionChainWaitHandle = new ManualResetEvent(initialState: false);
host.Start();
if (!uploadBlobBeforeHostStart)
{
WaitForTestFunctionsToStart();
UploadTestObject();
}
bool signaled = _functionChainWaitHandle.WaitOne(15 * 60 * 1000);
// Stop the host and wait for it to finish
host.Stop();
Assert.True(signaled);
// Verify
VerifyTableResults();
}
public ServiceBusSessionsBusEndToEndTests(ITestOutputHelper output)
{
outputLogger = output;
var config = new ConfigurationBuilder()
.AddEnvironmentVariables()
.AddTestSettings()
.Build();
// Add all test configuration to the environment as WebJobs requires a few of them to be in the environment
foreach (var kv in config.AsEnumerable())
{
Environment.SetEnvironmentVariable(kv.Key, kv.Value);
}
_connectionString = config.GetConnectionStringOrSetting(ServiceBus.Constants.DefaultConnectionStringName);
_nameResolver = new RandomNameResolver();
Cleanup().GetAwaiter().GetResult();
}
public BlobTriggerEndToEndTests()
{
_nameResolver = new RandomNameResolver();
// pull from a default host
var host = new HostBuilder()
.ConfigureDefaultTestHost(b =>
{
b.AddAzureStorageBlobs().AddAzureStorageQueues();
})
.Build();
var provider = host.Services.GetService <StorageAccountProvider>();
_storageAccount = provider.GetHost();
var blobClient = _storageAccount.CreateBlobServiceClient();
_testContainer = blobClient.GetBlobContainerClient(_nameResolver.ResolveInString(SingleTriggerContainerName));
Assert.False(_testContainer.ExistsAsync().Result);
_testContainer.CreateAsync().Wait();
}
public IHost ConfigureHost()
{
_resolver = new RandomNameResolver();
IHost host = new HostBuilder()
.ConfigureDefaultTestHost <ServiceBusRequestAndDependencyCollectionTests>(b =>
{
b.AddAzureStorage();
b.AddServiceBus();
})
.ConfigureLogging(b =>
{
b.SetMinimumLevel(LogLevel.Information);
b.AddApplicationInsights(o => o.InstrumentationKey = _mockApplicationInsightsKey);
})
.Build();
TelemetryConfiguration telemteryConfiguration = host.Services.GetService <TelemetryConfiguration>();
telemteryConfiguration.TelemetryChannel = _channel;
return(host);
}
