private static void AddCosmosDbContainerForCleanup( SpecFlowContext context, Container container, Database?database = null) { if (!context.ContainsKey(CosmosDbContainersToDelete)) { context.Set(new List <Container>(), CosmosDbContainersToDelete); } if (database is not null) { if (!context.ContainsKey(CosmosDbDatabasesToDelete)) { context.Set(new List <Database>(), CosmosDbDatabasesToDelete); } List <Database> databasesToDelete = context.Get <List <Database> >(CosmosDbDatabasesToDelete); databasesToDelete.Add(database); } List <Container> containers = context.Get <List <Container> >(CosmosDbContainersToDelete); containers.Add(container); }
private static bool TryGetInstance <T>(SpecFlowContext context, string key, out T instance) { instance = default(T); try { instance = key == null ? context.Get <T>() : context.Get <T>(key); return(true); } catch (Exception) { return(false); } }
private static void DisposeServiceProvider(SpecFlowContext context) { if (context.Get <IServiceProvider>(ServiceProviderKey) is IDisposable spDisposable) { spDisposable.Dispose(); } }
private static void CompleteContainerSetup(SpecFlowContext context) { context.Set(false, ContainerBindingPhaseKey); ServiceCollection serviceCollection = context.Get <ServiceCollection>(ServiceCollectionKey); IServiceProvider service = serviceCollection.BuildServiceProvider(); context.Set(service, ServiceProviderKey); }
protected static void LogTestSession(SpecFlowContext context) { var testSession = context.Get <TestSession>(); Trace.WriteLine("Finished scenario with:\n" + $"Ukprn: {testSession.Ukprn}\n" + $"Job ID: {testSession.JobId}\n" + $"Learners:\n" + $"\t{string.Join("\n\t", testSession.Learners)}"); }
private static IServiceProvider GetServiceProvider(SpecFlowContext context, string messageForBuildInProgressError) { bool serviceBuildInProgress = VerifyBindingAvailable(context); if (serviceBuildInProgress) { throw new InvalidOperationException(messageForBuildInProgressError); } return(context.Get <IServiceProvider>(ServiceProviderKey)); }
protected static void CleanUpTestSession(SpecFlowContext context) { if (!context.ContainsKey("container_scope")) { return; } var scope = context.Get <ILifetimeScope>("container_scope"); context.Remove("container_scope"); scope.Dispose(); }
private static async Task TeardownCosmosDBDatabasesCoreAsync( SpecFlowContext context) { if (context.ContainsKey(CosmosDbDatabasesToDelete)) { await Task.WhenAll(context.Get <List <Database> >(CosmosDbDatabasesToDelete) .DistinctBy(database => database.Id) .Select(async database => await database.DeleteAsync().ConfigureAwait(false))) .ConfigureAwait(false); } }
/// <summary> /// Create a container against a database. /// </summary> /// <param name="partitionKeyPath">The partition key path to use when creating the container.</param> /// <param name="databaseContext">The context from which to get the <see cref="Database"/>.</param> /// <param name="containerContext">The context into which to store the <see cref="Container"/>, or null if you do not need to store it.</param> /// <param name="containerKey">The key at which to store the <see cref="Container"/>, or null if you do not need to store it.</param> /// <returns>A task that completes when the container has been created.</returns> internal static async Task <Container> CreateContainer(string partitionKeyPath, SpecFlowContext databaseContext, ScenarioContext?containerContext = null, string?containerKey = null) { Database database = databaseContext.Get <Database>(CosmosDbContextKeys.CosmosDbDatabase); Container container = await database.CreateContainerIfNotExistsAsync("client-" + Guid.NewGuid(), partitionKeyPath).ConfigureAwait(false); if (containerContext != null && containerKey != null) { containerContext.Set(container, containerKey); CosmosDbContextBindings.AddScenarioLevelCosmosDbContainerForCleanup(containerContext, container); } return(container); }
//public static ScenarioStepContext GetStepContext(this SpecFlowContext context) //{ // var result = context.GetOrDefault<ScenarioStepContext>("__stepContext__", null); // if (result != null) return result; // // If this method was called with a step context then use it otherwise set to null. // SetStepContext(context, context as ScenarioStepContext); // return context.Get<ScenarioStepContext>("__stepContext__"); //} //public static void SetStepContext(this SpecFlowContext context, ScenarioStepContext value) // => context.Set(value, "__stepContext__"); //public static ScenarioContext GetScenarioContext(this SpecFlowContext context) //{ // var result = context.GetOrDefault<ScenarioContext>("__scenarioContext__", null); // if (result != null) return result; // // If this method was called with a scenario context then use it otherwise set to null. // SetScenarioContext(context, context as ScenarioContext); // return context.Get<ScenarioContext>("__scenarioContext__"); //} //public static void SetScenarioContext(this SpecFlowContext context, ScenarioContext value) // => context.Set(value, "__scenarioContext__"); public static FeatureContext GetFeatureContext(this SpecFlowContext context) { var result = context.GetOrDefault <FeatureContext>("__featureContext__", null); if (result != null) { return(result); } // If this method was called with a feature context then use it otherwise set to null. SetFeatureContext(context, context as FeatureContext); return(context.Get <FeatureContext>("__featureContext__")); }
private static IWebDriver CreateSeleniumDriver(this SpecFlowContext specFlowContext, IConfiguration configuration) { System.Enum.TryParse(configuration[Constants.EnvironmentVariableKeys.Browser], true, out BrowserTypes browser); switch (browser) { case BrowserTypes.Edge: EdgeOptions egdeOptions = new EdgeOptions { PageLoadStrategy = PageLoadStrategy.Normal, UseChromium = true }; EdgeDriverService edgeDriverService = EdgeDriverService.CreateChromiumService(configuration[Constants.EnvironmentVariableKeys.EdgeWebDriver]); specFlowContext.Set((IWebDriver) new EdgeDriver(edgeDriverService, egdeOptions)); break; case BrowserTypes.Firefox: specFlowContext.Set((IWebDriver) new FirefoxDriver()); break; case BrowserTypes.InternetExplorer: InternetExplorerOptions internetExplorerOptions = new InternetExplorerOptions() { BrowserVersion = configuration[Constants.EnvironmentVariableKeys.InternetExplorerVersion], IgnoreZoomLevel = true }; specFlowContext.Set((IWebDriver) new InternetExplorerDriver(internetExplorerOptions)); break; case BrowserTypes.Safari: SafariDriverService safariDriverService = SafariDriverService.CreateDefaultService(); SafariOptions safariOptions = new SafariOptions(); safariOptions.PageLoadStrategy = PageLoadStrategy.Normal; specFlowContext.Set((IWebDriver) new SafariDriver(safariDriverService)); break; default: { ChromeDriverService chromeDriverService = ChromeDriverService.CreateDefaultService(); chromeDriverService.SuppressInitialDiagnosticInformation = true; specFlowContext.Set((IWebDriver) new ChromeDriver(chromeDriverService)); } break; } return(specFlowContext.Get <IWebDriver>()); }
private static void ConfigureServices( SpecFlowContext context, Action <IServiceCollection> configure, string exceptionMessageIfBuildNotInProgress) { bool serviceBuildInProgress = VerifyBindingAvailable(context); if (!serviceBuildInProgress) { throw new InvalidOperationException(exceptionMessageIfBuildNotInProgress); } ServiceCollection serviceCollection = context.Get <ServiceCollection>(ServiceCollectionKey); configure(serviceCollection); }
private static async Task TeardownCosmosDBContainersCoreAsync(SpecFlowContext context) { if (context.ContainsKey(CosmosDbContainersToDelete)) { // We run this way not so much because we want to delete everything at once, // but because this way we do actually attempt every deletion, and then report // any failures at the end in one big AggregateException. await Task.WhenAll(context.Get <List <Container> >(CosmosDbContainersToDelete) .Select(async container => { try { await container.DeleteContainerAsync().ConfigureAwait(false); } catch (InvalidOperationException x) when(x.Message == "Unable to use database throughput in a database that has already been created.") { // Swallow this because it's an expected exception in certain test scenarios. } })) .ConfigureAwait(false); } }
private static Container GetCosmosContainer(SpecFlowContext containerContext, string containerKey = CosmosDbContextKeys.CosmosDbContainer) { return(containerContext.Get <Container>(containerKey)); }
public static CalculatorProcess Process(this SpecFlowContext context) { return(context.Get <CalculatorProcess>("Process")); }
public static int ProcessId(this SpecFlowContext context) { return(context.Get <int>("ProcessId")); }
public static T Get <T>(SpecFlowContext context, string key) { return(context.Get <T>(key)); }