public OpenApiSteps(
ScenarioContext scenarioContext,
FeatureContext featureContext)
{
this.scenarioContext = scenarioContext;
this.serviceProvider = ContainerBindings.GetServiceProvider(featureContext);
}
public async Task WhenIUseTheOperationsControlClientToCreateAnOperation(Table table)
{
string idName = table.Rows[0]["IdName"];
Guid id = this.ScenarioContext.Get <Guid>(idName);
string resourceLocation = table.Rows[0]["ResourceLocation"];
long expireAfter = long.Parse(table.Rows[0]["ExpireAfter"]);
string body = table.Rows[0]["Body"];
IServiceProvider serviceProvider = ContainerBindings.GetServiceProvider(this.FeatureContext);
IMarainOperationsControl client = serviceProvider.GetRequiredService <IMarainOperationsControl>();
var transientTenantManager = TransientTenantManager.GetInstance(this.FeatureContext);
await Exceptions.ExecuteAndStoreExceptionAsync(
this.ScenarioContext,
async() =>
{
CreateOperationHeaders result = await client.CreateOperationAsync(
transientTenantManager.PrimaryTransientClient.Id,
id,
resourceLocation,
expireAfter,
body).ConfigureAwait(false);
this.ScenarioContext.Set(result);
}).ConfigureAwait(false);
}
private static EnrollmentConfigurationItem[] GetClaimsConfig(FeatureContext featureContext)
{
IConfiguration configuration = ContainerBindings
.GetServiceProvider(featureContext)
.GetRequiredService <IConfiguration>();
// Load the config items we need:
BlobStorageConfiguration claimPermissionsStoreStorageConfiguration =
configuration.GetSection("TestBlobStorageConfiguration").Get <BlobStorageConfiguration>()
?? new BlobStorageConfiguration();
claimPermissionsStoreStorageConfiguration.Container = "claimpermissions";
BlobStorageConfiguration resourceAccessRuleSetsStoreStorageConfiguration =
configuration.GetSection("TestBlobStorageConfiguration").Get <BlobStorageConfiguration>()
?? new BlobStorageConfiguration();
resourceAccessRuleSetsStoreStorageConfiguration.Container = "resourceaccessrulesets";
return(new EnrollmentConfigurationItem[]
{
new EnrollmentBlobStorageConfigurationItem
{
Key = "claimPermissionsStore",
Configuration = claimPermissionsStoreStorageConfiguration,
},
new EnrollmentBlobStorageConfigurationItem
{
Key = "resourceAccessRuleSetsStore",
Configuration = resourceAccessRuleSetsStoreStorageConfiguration,
},
});
}
public static async Task SetupCosmosDbAccountKeys(FeatureContext featureContext)
{
IServiceProvider serviceProvider = ContainerBindings.GetServiceProvider(featureContext);
IConfigurationRoot configRoot = serviceProvider.GetRequiredService <IConfigurationRoot>();
CosmosDbSettings settings = configRoot.Get <CosmosDbSettings>();
if (settings.CosmosDbKeySecretName == null)
{
throw new NullReferenceException("CosmosDbKeySecretName must be set in config.");
}
string keyVaultName = configRoot["KeyVaultName"];
string secret = await SecretHelper.GetSecretFromConfigurationOrKeyVaultAsync(
configRoot,
"kv:" + settings.CosmosDbKeySecretName,
keyVaultName,
settings.CosmosDbKeySecretName).ConfigureAwait(false);
string partitionKeyPath = configRoot["CosmosDbPartitionKeyPath"];
featureContext.Set(partitionKeyPath, CosmosDbContextKeys.PartitionKeyPath);
featureContext.Set(settings);
featureContext.Set(secret, CosmosDbContextKeys.AccountKey);
}
public static void WriteOutput(FeatureContext featureContext)
{
ILogger <FunctionsController> logger = ContainerBindings.GetServiceProvider(featureContext).GetRequiredService <ILogger <FunctionsController> >();
FunctionsController functionsController = FunctionsBindings.GetFunctionsController(featureContext);
logger.LogAllAndClear(functionsController.GetFunctionsOutput());
}
public async Task WhenIAcquireTheLease()
{
var policy = this.scenarioContext.Get <LeasePolicy>();
Lease lease = null;
var leaseProvider = ContainerBindings.GetServiceProvider(this.featureContext).GetRequiredService <ILeaseProvider>();
try
{
if (!this.scenarioContext.TryGetValue(out lease))
{
lease = await leaseProvider.AcquireAsync(policy);
this.scenarioContext.Set(lease);
}
else
{
lease = await leaseProvider.AcquireAsync(policy);
}
}
catch (AggregateException ex)
{
this.scenarioContext.Add("AggregateException", ex);
}
catch (Exception ex)
{
this.scenarioContext.Add("Exception", ex);
}
this.scenarioContext.Set(lease);
}
public ApiSteps(FeatureContext featureContext, ScenarioContext scenarioContext)
{
this.featureContext = featureContext;
this.scenarioContext = scenarioContext;
this.serviceProvider = ContainerBindings.GetServiceProvider(this.featureContext);
}
public static async Task ClearDownTransientTenantContentStore(FeatureContext context)
{
ITenant transientTenant = TransientTenantManager.GetInstance(context).PrimaryTransientClient;
IServiceProvider serviceProvider = ContainerBindings.GetServiceProvider(context);
if (transientTenant != null && serviceProvider != null)
{
await context.RunAndStoreExceptionsAsync(async() =>
{
ITenantedWorkflowStoreFactory workflowStoreFactory = serviceProvider.GetRequiredService <ITenantedWorkflowStoreFactory>();
IWorkflowStore workflowStore = await workflowStoreFactory.GetWorkflowStoreForTenantAsync(transientTenant).ConfigureAwait(false);
if (workflowStore is CosmosWorkflowStore cosmosWorkflowStore)
{
await cosmosWorkflowStore.Container.DeleteContainerAsync().ConfigureAwait(false);
}
}).ConfigureAwait(false);
await context.RunAndStoreExceptionsAsync(async() =>
{
ITenantedWorkflowInstanceStoreFactory workflowInstanceStoreFactory = serviceProvider.GetRequiredService <ITenantedWorkflowInstanceStoreFactory>();
var workflowInstanceStore = (CosmosWorkflowInstanceStore)await workflowInstanceStoreFactory.GetWorkflowInstanceStoreForTenantAsync(transientTenant).ConfigureAwait(false);
await workflowInstanceStore.Container.DeleteContainerAsync().ConfigureAwait(false);
}).ConfigureAwait(false);
}
}
public static async Task SetupCosmosDbDatabaseForFeature(FeatureContext featureContext)
{
CosmosDbSettings settings = featureContext.Get <CosmosDbSettings>();
if (settings.CosmosDbAccountUri == null)
{
throw new NullReferenceException("CosmosDbAccountUri must be set in config.");
}
ICosmosClientBuilderFactory clientBuilderFactory = ContainerBindings.GetServiceProvider(featureContext).GetRequiredService <ICosmosClientBuilderFactory>();
string accountKey = featureContext.Get <string>(CosmosDbContextKeys.AccountKey);
CosmosClientBuilder builder;
if (clientBuilderFactory is null)
{
builder = new CosmosClientBuilder(settings.CosmosDbAccountUri, accountKey);
}
else
{
builder = clientBuilderFactory.CreateCosmosClientBuilder(settings.CosmosDbAccountUri, accountKey);
}
builder = builder
.WithConnectionModeDirect();
CosmosClient client = builder.Build();
Database database = await client.CreateDatabaseIfNotExistsAsync(settings.CosmosDbDatabaseName, settings.CosmosDbDefaultOfferThroughput).ConfigureAwait(false);
featureContext.Set(client, CosmosDbContextKeys.CosmosDbClient);
featureContext.Set(database, CosmosDbContextKeys.CosmosDbDatabase);
}
public async Task ThenTheWorkflowInstanceWithIdShouldContainContextItems(string instanceId, Table expectedContextItems)
{
ITenantedWorkflowInstanceStoreFactory instanceStoreFactory = ContainerBindings.GetServiceProvider(this.featureContext)
.GetService <ITenantedWorkflowInstanceStoreFactory>();
ITenantProvider tenantProvider = ContainerBindings.GetServiceProvider(this.featureContext)
.GetService <ITenantProvider>();
IWorkflowInstanceStore instanceStore = await instanceStoreFactory.GetWorkflowInstanceStoreForTenantAsync(tenantProvider.Root).ConfigureAwait(false);
WorkflowInstance instance = await WorkflowRetryHelper.ExecuteWithStandardTestRetryRulesAsync(
() => instanceStore.GetWorkflowInstanceAsync(instanceId)).ConfigureAwait(false);
Assert.AreEqual(
expectedContextItems.Rows.Count,
instance.Context.Count,
"The number of context items in the workflow instance is different to the number of items in the specified list");
foreach (TableRow current in expectedContextItems.Rows)
{
Assert.IsTrue(
instance.Context.TryGetValue(current[0], out string actualValue),
$"The instance context does not contain expected item with key '{current[0]}'");
Assert.AreEqual(current[1], actualValue, $"The instance context does not contain the expected value for key '{current[0]}'");
}
}
public async Task GivenIHaveCreatedAndPersistedANewInstanceOfTheDataCatalogWorkflowWithId(string workflowId)
{
IWorkflowMessageQueue workflowMessageQueue =
ContainerBindings.GetServiceProvider(this.featureContext).GetService <IWorkflowMessageQueue>();
Workflow workflow = DataCatalogWorkflowFactory.Create(workflowId, workflowMessageQueue);
ITenantedWorkflowStoreFactory storeFactory =
ContainerBindings.GetServiceProvider(this.featureContext).GetService <ITenantedWorkflowStoreFactory>();
ITenantProvider tenantProvider =
ContainerBindings.GetServiceProvider(this.featureContext).GetService <ITenantProvider>();
IWorkflowStore store = await storeFactory.GetWorkflowStoreForTenantAsync(tenantProvider.Root).ConfigureAwait(false);
await WorkflowRetryHelper.ExecuteWithStandardTestRetryRulesAsync(async() =>
{
try
{
Workflow oldWorkflow = await store.GetWorkflowAsync(workflowId).ConfigureAwait(false);
workflow.ETag = oldWorkflow.ETag;
}
catch (WorkflowNotFoundException)
{
// Don't care if there is no old workflow.
}
await store.UpsertWorkflowAsync(workflow).ConfigureAwait(false);
}).ConfigureAwait(false);
}
public static async Task CreateContentStateTestData(FeatureContext featureContext)
{
ITenantedContentStoreFactory contentStoreFactory = ContainerBindings.GetServiceProvider(featureContext).GetRequiredService <ITenantedContentStoreFactory>();
IContentStore store = await contentStoreFactory.GetContentStoreForTenantAsync(featureContext.GetCurrentTenantId()).ConfigureAwait(false);
for (int i = 0; i < 30; i++)
{
var state = new ContentState
{
Id = Guid.NewGuid().ToString(),
ContentId = SpecHelpers.ParseSpecValue <string>(featureContext, $"{{Content{i}.Id}}"),
Slug = SpecHelpers.ParseSpecValue <string>(featureContext, $"{{Content{i}.Slug}}"),
WorkflowId = "workflow1id",
ChangedBy = new CmsIdentity(Guid.NewGuid().ToString(), Guid.NewGuid().ToString()),
};
if (i < 4)
{
state.StateName = "draft";
}
else if (i < 29)
{
state.StateName = "published";
}
else
{
state.StateName = "archived";
}
ContentState storedContentState = await store.SetContentWorkflowStateAsync(state.Slug, state.ContentId, state.WorkflowId, state.StateName, state.ChangedBy).ConfigureAwait(false);
featureContext.Set(storedContentState, $"Content{i}-State");
}
}
public static async Task CreateContentTestData(FeatureContext featureContext)
{
ITenantedContentStoreFactory contentStoreFactory = ContainerBindings.GetServiceProvider(featureContext).GetRequiredService <ITenantedContentStoreFactory>();
IContentStore store = await contentStoreFactory.GetContentStoreForTenantAsync(featureContext.GetCurrentTenantId()).ConfigureAwait(false);
for (int i = 0; i < 30; i++)
{
var content = new Content
{
Id = Guid.NewGuid().ToString(),
Slug = "slug",
Tags = new List <string> {
"First tag", "Second tag"
},
CategoryPaths = new List <string> {
"/standard/content;", "/books/hobbit;", "/books/lotr"
},
Author = new CmsIdentity(Guid.NewGuid().ToString(), "Bilbo Baggins"),
Title = "This is the title",
Description = "A description of the content",
Culture = CultureInfo.GetCultureInfo("en-GB"),
};
Content storedContent = await store.StoreContentAsync(content).ConfigureAwait(false);
featureContext.Set(storedContent, "Content" + i);
}
}
public void GivenIAddAnEmbeddedResourceToTheHalDocumentT()
{
HalDocument document = this.scenarioContext.Get <HalDocument>();
IHalDocumentFactory halDocumentFactory = ContainerBindings.GetServiceProvider(this.scenarioContext).GetService <IHalDocumentFactory>();
document.AddEmbeddedResource("somerel", halDocumentFactory.CreateHalDocument());
}
public void GivenIHaveCreatedAnInstanceOfHalDocumentFromTheDomainClass()
{
IHalDocumentFactory halDocumentFactory = ContainerBindings.GetServiceProvider(this.scenarioContext).GetService <IHalDocumentFactory>();
HalDocument halDocument = halDocumentFactory.CreateHalDocumentFrom(this.scenarioContext.Get <TestDomainClass>());
this.scenarioContext.Set(halDocument);
}
public void WhenISerializeTheContentObjectCalled(string instanceName, string resultName)
{
object instance = this.scenarioContext.Get <object>(instanceName);
string serializedValue = JsonConvert.SerializeObject(instance, ContainerBindings.GetServiceProvider(this.featureContext).GetRequiredService <IJsonSerializerSettingsProvider>().Instance);
this.scenarioContext.Set(serializedValue, resultName);
}
public void GivenIDraftTheContentCalled(string contentName)
{
Content content = this.scenarioContext.Get <Content>(contentName);
FakeContentStore fakeContentStore = ContainerBindings.GetServiceProvider(this.featureContext).GetService <FakeContentStore>();
fakeContentStore.SetContentState(content, ContentPublicationContentState.Draft);
}
public static async Task SetupTransientTenant(FeatureContext featureContext)
{
ITenantProvider tenantProvider = ContainerBindings.GetServiceProvider(featureContext).GetRequiredService <ITenantProvider>();
var transientTenantManager = TransientTenantManager.GetInstance(featureContext);
await transientTenantManager.EnsureInitialised().ConfigureAwait(false);
// Create a transient service tenant for testing purposes.
ITenant transientServiceTenant = await transientTenantManager.CreateTransientServiceTenantFromEmbeddedResourceAsync(
typeof(TransientTenantBindings).Assembly,
"Marain.UserNotifications.Specs.ServiceManifests.UserNotificationsServiceManifest.jsonc").ConfigureAwait(false);
// Now update the service Id in our configuration and in the function configuration
UpdateServiceConfigurationWithTransientTenantId(featureContext, transientServiceTenant);
// Now we need to construct a transient client tenant for the test, and enroll it in the new
// transient service.
ITenant transientClientTenant = await transientTenantManager.CreateTransientClientTenantAsync().ConfigureAwait(false);
await transientTenantManager.AddEnrollmentAsync(
transientClientTenant.Id,
transientServiceTenant.Id,
GetUserNotificationsConfig(featureContext)).ConfigureAwait(false);
// TODO: Temporary hack to work around the fact that the transient tenant manager no longer holds the latest
// version of the tenants it's tracking; see https://github.com/marain-dotnet/Marain.TenantManagement/issues/28
transientTenantManager.PrimaryTransientClient = await tenantProvider.GetTenantAsync(transientClientTenant.Id).ConfigureAwait(false);
}
private static EnrollmentConfigurationItem[] GetOperationsConfig(FeatureContext featureContext)
{
IConfiguration configuration = ContainerBindings
.GetServiceProvider(featureContext)
.GetRequiredService <IConfiguration>();
// Can't create a logger using the generic type of this class because it's static, so we'll do it using
// the feature context instead.
ILogger <FeatureContext> logger = ContainerBindings
.GetServiceProvider(featureContext)
.GetRequiredService <ILogger <FeatureContext> >();
BlobStorageConfiguration blobStorageConfiguration =
configuration.GetSection("TestBlobStorageConfiguration").Get <BlobStorageConfiguration>()
?? new BlobStorageConfiguration();
if (string.IsNullOrEmpty(blobStorageConfiguration.AccountName))
{
logger.LogDebug("No configuration value 'TestBlobStorageConfiguration:AccountName' provided; using local storage emulator.");
}
return(new EnrollmentConfigurationItem[]
{
new EnrollmentBlobStorageConfigurationItem
{
Key = "operationsStore",
Configuration = blobStorageConfiguration,
},
});
}
public async Task GivenIHaveUsedTheTenantStoreToCreateANewClientTenantCalled(string clientName)
{
ITenantStore service = ContainerBindings.GetServiceProvider(this.scenarioContext).GetRequiredService <ITenantStore>();
ITenant newTenant = await service.CreateClientTenantAsync(clientName).ConfigureAwait(false);
this.scenarioContext.Set(newTenant.Id, clientName);
}
private async Task EnrollTenantForService(
string enrollingTenantName,
string serviceTenantName,
string?enrollmentConfigurationName = null)
{
ITenantStore managementService =
ContainerBindings.GetServiceProvider(this.scenarioContext).GetRequiredService <ITenantStore>();
ITenantProvider tenantProvider = ContainerBindings.GetServiceProvider(this.scenarioContext).GetRequiredService <ITenantProvider>();
ITenant enrollingTenant = await tenantProvider.GetTenantAsync(this.scenarioContext.Get <string>(enrollingTenantName)).ConfigureAwait(false);
ITenant serviceTenant = await tenantProvider.GetTenantAsync(this.scenarioContext.Get <string>(serviceTenantName)).ConfigureAwait(false);
List <EnrollmentConfigurationItem> enrollmentConfiguration =
string.IsNullOrEmpty(enrollmentConfigurationName)
? new List <EnrollmentConfigurationItem>()
: this.scenarioContext.Get <List <EnrollmentConfigurationItem> >(enrollmentConfigurationName);
await CatchException.AndStoreInScenarioContextAsync(
this.scenarioContext,
() => managementService.EnrollInServiceAsync(
enrollingTenant,
serviceTenant,
enrollmentConfiguration.ToArray())).ConfigureAwait(false);
}
public async Task ThenThereIsAServiceTenantWithId(string expectedServiceTenantId)
{
ITenantProvider tenantProvider = ContainerBindings.GetServiceProvider(this.scenarioContext).GetRequiredService <ITenantProvider>();
ITenant tenant = await tenantProvider.GetTenantAsync(expectedServiceTenantId).ConfigureAwait(false);
Assert.AreEqual(WellKnownTenantIds.ServiceTenantParentId, tenant.GetRequiredParentId());
}
public async Task ThenTheTenantWithIdIsCalled(string tenantId, string expectedTenantName)
{
ITenantProvider tenantProvider = ContainerBindings.GetServiceProvider(this.scenarioContext).GetRequiredService <ITenantProvider>();
ITenant tenant = await tenantProvider.GetTenantAsync(tenantId).ConfigureAwait(false);
Assert.AreEqual(expectedTenantName, tenant.Name);
}
public async Task ThenTheTenancyProviderContainsTenantsAsChildrenOfTheRootTenant(int expectedTenantCount)
{
ITenantStore tenantStore = ContainerBindings.GetServiceProvider(this.scenarioContext).GetRequiredService <ITenantStore>();
TenantCollectionResult rootTenantChildren = await tenantStore.GetChildrenAsync(tenantStore.Root.Id).ConfigureAwait(false);
Assert.AreEqual(expectedTenantCount, rootTenantChildren.Tenants.Count);
}
public Task WhenIUseTheTenantStoreToInitialiseTheTenancyProviderUsingTheForceOption()
{
ITenantStore service = ContainerBindings.GetServiceProvider(this.scenarioContext).GetRequiredService <ITenantStore>();
return(CatchException.AndStoreInScenarioContextAsync(
this.scenarioContext,
() => service.InitialiseTenancyProviderAsync(true)));
}
public static void InitializeMocksToEnableInvocation(ScenarioContext scenarioContext)
{
OperationInvokerTestContext invokerContext = ContainerBindings.GetServiceProvider(scenarioContext).GetRequiredService <OperationInvokerTestContext>();
invokerContext.ParameterBuilder
.Setup(pb => pb.BuildParametersAsync(It.IsAny <object>(), It.IsAny <OpenApiOperationPathTemplate>()))
.ReturnsAsync(new Dictionary <string, object>());
}
public void GivenIDetokenizeTheLease()
{
var leaseToken = this.scenarioContext.Get <string>("LeaseToken");
var leaseProvider = ContainerBindings.GetServiceProvider(this.featureContext).GetRequiredService <ILeaseProvider>();
Lease lease = leaseProvider.FromLeaseToken(leaseToken);
this.scenarioContext.Set <Lease>(lease);
}
public void GivenISerializeThePropertyBag()
{
IJsonSerializerOptionsProvider settingsProvider = ContainerBindings.GetServiceProvider(this.featureContext).GetService <IJsonSerializerOptionsProvider>();
PropertyBag propertyBag = this.scenarioContext.Get <PropertyBag>();
this.scenarioContext.Set(JsonSerializer.Serialize(propertyBag, settingsProvider.Instance), "Result");
}
public async Task GivenIHaveAlreadyAcquiredTheLease()
{
var leaseProvider = ContainerBindings.GetServiceProvider(this.featureContext).GetRequiredService <ILeaseProvider>();
var policy = this.scenarioContext.Get <LeasePolicy>();
var lease = await leaseProvider.AcquireAsync(policy);
this.scenarioContext.Set(lease);
}
public void GivenIHaveAnInstanceOfAContentObjectCalled(string instanceName, string contentType, Table table)
{
Assert.AreEqual(1, table.RowCount);
object instance = table.CreateInstance(() => ContainerBindings.GetServiceProvider(this.featureContext).GetContent(contentType));
this.scenarioContext.Set(instance, instanceName);
}