public void BuildConfiguration_ReadFromEnvironmentalAppSettings()
{
var sut = EswDevOpsSdk.BuildConfiguration(AssemblyDirectory, "ENV1");
sut["KeyENV1AppSettings"].Should().BeEquivalentTo("ENV1AppSettingsValue");
}
public async Task RemoveTests(OperationPhase operationPhase)
{
using (var scope = Fixture.Container.BeginLifetimeScope())
{
var cl = scope.Resolve <HttpClient>();
var azure = scope.ResolveKeyed <IAzure>(EswDevOpsSdk.GetEnvironment());
var resourceGroup = await EnsureResourceGroupExists(azure, TestResourceGroupName, Region.EuropeNorth);
var scaleSet = await GetScaleSet(azure);
await Prepare(azure, operationPhase, resourceGroup, scaleSet, IdentityName);
var identity = await FindIdentity(azure, resourceGroup, IdentityName);
var msi = CreateMangedIdentityAssignment();
await cl.PostJsonToActor(Fixture.TestMiddlewareUri, "ManagedIdentity", "Remove", msi);
var deletedIdentity = await FindIdentity(azure, resourceGroup, IdentityName);
deletedIdentity.Should().BeNull($"identity {IdentityName} should be deleted.");
if (identity != null)
{
var updatedScaleSet = await GetScaleSet(azure);
if (updatedScaleSet.ManagedServiceIdentityType == ResourceIdentityType.SystemAssignedUserAssigned ||
updatedScaleSet.ManagedServiceIdentityType == ResourceIdentityType.UserAssigned)
{
updatedScaleSet.UserAssignedManagedServiceIdentityIds.Should().NotBeNull();
updatedScaleSet.UserAssignedManagedServiceIdentityIds.Should().NotContain(identity.Id);
}
// TODO: if possible check whether the managed identity had been unassigned from the scale set before it has been deleted.
}
}
}
public void BuildConfiguration_ReadFromCoreAppSettings()
{
Environment.SetEnvironmentVariable(EswDevOpsSdk.EnvironmentEnvVariable, "ENV1", EnvironmentVariableTarget.Process); //process level is fine here
var sut = EswDevOpsSdk.BuildConfiguration(AssemblyDirectory);
sut["KeyRootAppSettings"].Should().BeEquivalentTo("AppSettingsValue");
}
protected override void Load(ContainerBuilder builder)
{
builder.Register(c => EswDevOpsSdk.BuildConfiguration());
builder.RegisterType <ClusterNotifier>().SingleInstance();
builder.Register(c => new FabricClient());
builder.Register <IBigBrother>(c =>
{
var config = c.Resolve <IConfigurationRoot>();
var bbInsKey = config["BBInstrumentationKey"];
return(new BigBrother(bbInsKey, bbInsKey));
})
.SingleInstance();
builder.Register(c => HttpPolicyExtensions.HandleTransientHttpError()
.WaitAndRetryAsync(new[]
{
//TODO: configure these timeouts and add jitter policy
TimeSpan.FromSeconds(1),
TimeSpan.FromSeconds(5),
TimeSpan.FromSeconds(10)
}))
.As <IAsyncPolicy <HttpResponseMessage> >()
.SingleInstance();
builder.Register(c => new PolicyHttpMessageHandler(c.Resolve <IAsyncPolicy <HttpResponseMessage> >()))
.SingleInstance();
builder.Register(c => new HttpClient(c.Resolve <PolicyHttpMessageHandler>()))
.SingleInstance();
}
private string GetAccessToken(bool includeRealApiClaim = false)
{
var config = EswDevOpsSdk.BuildConfiguration();
var generator = new TokenGenerator();
var issuer = config["STSIssuer"];
var claims = new List <Claim>
{
new Claim("client_id", "esw.toolingIntTestClient"),
new Claim("sub", "blah"),
new Claim("idp", "oidc-azure"),
new Claim("Scope", "openid"),
new Claim("Scope", "profile"),
new Claim("Scope", "esw.toolingIntTest"),
new Claim("amr", "external")
};
if (includeRealApiClaim)
{
claims.Add(new Claim("Scope", "esw.toolingInt"));
}
return(generator.CreateAccessToken($"{issuer}", new List <string>
{
$"{issuer}/resources",
"esw.toolingIntTest"
}, claims, 3600));
}
protected override void Load(ContainerBuilder builder)
{
builder.Register(c =>
{
var tokenProvider = new AzureServiceTokenProvider();
var tokenProviderAdapter = new AzureServiceTokenProviderAdapter(tokenProvider);
return(new TokenCredentials(tokenProviderAdapter));
});
builder.Register(c =>
{
var tokenCredentials = c.Resolve <TokenCredentials>();
var client = RestClient.Configure()
.WithEnvironment(AzureEnvironment.AzureGlobalCloud)
.WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic)
.WithCredentials(new AzureCredentials(tokenCredentials, tokenCredentials, string.Empty,
AzureEnvironment.AzureGlobalCloud))
.Build();
return(Azure.Authenticate(client, string.Empty));
});
foreach (DeploymentEnvironment env in Enum.GetValues(typeof(DeploymentEnvironment)))
{
var subscriptionId = EswDevOpsSdk.GetSierraDeploymentSubscriptionId(env);
builder.Register(c =>
{
var authenticated = c.Resolve <Azure.IAuthenticated>();
return(authenticated.WithSubscription(subscriptionId));
}).Keyed <IAzure>(env).InstancePerLifetimeScope();
}
}
private async Task <string> GetAccessToken(bool includeRealApiClaim = false)
{
var config = EswDevOpsSdk.BuildConfiguration();
var generator = new TokenGenerator();
var certificate = new X509Certificate2(Convert.FromBase64String(config["STSSigningCert"]), "");
var issuer = config["STSIssuer"];
var claims = new List <Claim>
{
new Claim("client_id", "esw.toolingIntTestClient"),
new Claim("sub", "blah"),
new Claim("idp", "oidc-azure"),
new Claim("Scope", "openid"),
new Claim("Scope", "profile"),
new Claim("Scope", "esw.toolingIntTest"),
new Claim("amr", "external")
};
if (includeRealApiClaim)
{
claims.Add(new Claim("Scope", "esw.toolingInt"));
}
return(await generator.CreateAccessTokenAsync($"{issuer}", new List <string>
{
$"{issuer}/resources",
"esw.toolingIntTest"
}, certificate, 3600, claims));
}
public async Task AddTest(bool resourceGroupExists)
{
using (var scope = Fixture.Container.BeginLifetimeScope())
{
var cl = scope.Resolve <HttpClient>();
var azure = scope.ResolveKeyed <IAzure>(EswDevOpsSdk.GetEnvironment());
await PrepareResourceGroup(resourceGroupExists, azure);
try
{
var rg = TestResourceGroupRequest();
var actorResponse = await cl.PostJsonToActor(Fixture.TestMiddlewareUri, "ResourceGroup", "Add", rg);
actorResponse.Should().NotBeNull();
actorResponse.ResourceId.Should().NotBeNullOrEmpty();
actorResponse.State.Should().Be(EntityStateEnum.Created);
await Task.Delay(TimeSpan.FromSeconds(5));
var isResourceGroupCreated = await azure.ResourceGroups.ContainAsync(TestResourceGroupName);
isResourceGroupCreated.Should()
.BeTrue($"the resource {TestResourceGroupName} group should be created in the {azure.SubscriptionId} subscription, but the actor reported that it created {actorResponse.ResourceId}.");
var createdResourceGroup = await azure.ResourceGroups.GetByNameAsync(TestResourceGroupName);
createdResourceGroup.Should().NotBeNull();
createdResourceGroup.Region.Should().Be(Fixture.TestRegion);
actorResponse.ResourceId.Should().Be(createdResourceGroup.Id);
}
finally
{
await DeleteResourceGroup(azure, TestResourceGroupName);
}
}
}
public void BuildConfiguration_NonTestMode()
{
var sut = EswDevOpsSdk.BuildConfiguration(AssemblyDirectory);
sut["KeyTestAppSettings"].Should().BeNullOrEmpty();
}
/// <summary>
/// constructor logic
///
/// it invokes the tenant api to create the tenant so that other tests dependent on this fixture do not have to concern with the set up
/// </summary>
public TenantL3TestFixture()
{
var builder = new ContainerBuilder();
builder.RegisterModule(new CoreModule(true));
builder.RegisterModule(new VstsModule());
builder.Register(c => new SierraDbContext
{
ConnectionString = c.Resolve <IConfigurationRoot>()["SierraDbConnectionString"]
});
builder.Register(c =>
{
TestConfig = new TestConfig();
var config = EswDevOpsSdk.BuildConfiguration(true);
config.GetSection("TestConfig").Bind(TestConfig);
return(TestConfig);
});
Container = builder.Build();
TestConfig = Container.Resolve <TestConfig>();
EnsureTenantCreated().Wait(TenantApiTimeout);
//load tenant into memory
using (var scope = Container.BeginLifetimeScope())
{
var dbContext = scope.Resolve <SierraDbContext>();
TenantUnderTest = dbContext.LoadCompleteTenantAsync(TenantCode).Result;
}
}
public void ForCIReturnWEOnly()
{
Environment.SetEnvironmentVariable(EswDevOpsSdk.DeploymentRegionEnvVariable, null, EnvironmentVariableTarget.User);
Environment.SetEnvironmentVariable(EswDevOpsSdk.DeploymentRegionEnvVariable, null, EnvironmentVariableTarget.Process);
Environment.SetEnvironmentVariable(EswDevOpsSdk.DeploymentRegionEnvVariable, null, EnvironmentVariableTarget.Machine);
Environment.SetEnvironmentVariable(EswDevOpsSdk.DeploymentRegionEnvVariable, "West Europe", EnvironmentVariableTarget.Machine);
EswDevOpsSdk.CreateDeploymentContext(DeploymentEnvironment.CI).PreferredRegions.Should().ContainInOrder("West Europe");
}
public void ForAllProductionRegions(string regionValue, string[] expectedRegionHierarchy)
{
Environment.SetEnvironmentVariable(EswDevOpsSdk.DeploymentRegionEnvVariable, null, EnvironmentVariableTarget.User);
Environment.SetEnvironmentVariable(EswDevOpsSdk.DeploymentRegionEnvVariable, null, EnvironmentVariableTarget.Process);
Environment.SetEnvironmentVariable(EswDevOpsSdk.DeploymentRegionEnvVariable, null, EnvironmentVariableTarget.Machine);
Environment.SetEnvironmentVariable(EswDevOpsSdk.DeploymentRegionEnvVariable, regionValue, EnvironmentVariableTarget.Machine);
EswDevOpsSdk.CreateDeploymentContext().PreferredRegions.Should().ContainInOrder(expectedRegionHierarchy);
}
public void GetSubscriptionId_works_for_known_environments()
{
var environmentNames = Enum.GetNames(typeof(DeploymentEnvironment));
foreach (var environmentName in environmentNames)
{
Environment.SetEnvironmentVariable(EswDevOpsSdk.EnvironmentEnvVariable, environmentName, EnvironmentVariableTarget.Process);
var subscriptionId = EswDevOpsSdk.GetSubscriptionId();
subscriptionId.Should().NotBeNullOrEmpty();
}
}
public void GetDeploymentSubscriptionIdTest(DeploymentEnvironment environmentName, DeploymentEnvironment deploymentEnvironmentName, object resultEnvironmentSubscription)
{
Environment.SetEnvironmentVariable(EswDevOpsSdk.EnvironmentEnvVariable, environmentName.ToString(), EnvironmentVariableTarget.Process);
var expectedSubscriptionId = resultEnvironmentSubscription as string == SierraIntegration
? EswDevOpsSdk.SierraIntegrationSubscriptionId
: EswDevOpsSdk.GetSubscriptionId(deploymentEnvironmentName);
var subscriptionId = EswDevOpsSdk.GetSierraDeploymentSubscriptionId(deploymentEnvironmentName);
subscriptionId.Should().Be(expectedSubscriptionId);
}
public void BuildConfiguration_EnvironmentOverwrites()
{
Environment.SetEnvironmentVariable("OPTION2", "fromEnv", EnvironmentVariableTarget.Process);
Environment.SetEnvironmentVariable("OPTION5", "fromEnv", EnvironmentVariableTarget.Process);
var sut = EswDevOpsSdk.BuildConfiguration(AssemblyDirectory, "ORDER");
sut["Option1"].Should().BeEquivalentTo("fromOrderAppSetting");
sut["Option2"].Should().BeEquivalentTo("fromEnv");
sut["Option3"].Should().BeEquivalentTo("value3");
sut["Option4"].Should().BeEquivalentTo("fromKV");
sut["Option5"].Should().BeEquivalentTo("fromENV");
}
protected override void Load(ContainerBuilder builder)
{
var config = EswDevOpsSdk.BuildConfiguration(TestMode);
builder.RegisterInstance(config)
.As <IConfigurationRoot>()
.SingleInstance();
builder.Register <IBigBrother>(c =>
{
var insKey = c.Resolve <IConfigurationRoot>()["BBInstrumentationKey"];
return(new BigBrother(insKey, insKey));
})
.SingleInstance();
}
public Startup(IHostingEnvironment env)
{
try
{
_configuration = EswDevOpsSdk.BuildConfiguration(env.ContentRootPath, env.EnvironmentName);
var internalKey = _configuration["BBInstrumentationKey"];
_bb = new BigBrother(internalKey, internalKey);
_bb.UseEventSourceSink().ForExceptions();
}
catch (Exception e)
{
BigBrother.Write(e);
throw;
}
}
public void GeEnvironmentTest(string envValue, DeploymentEnvironment env)
{
var prevEnv = Environment.GetEnvironmentVariable(EswDevOpsSdk.EnvironmentEnvVariable);
Environment.SetEnvironmentVariable(EswDevOpsSdk.EnvironmentEnvVariable, envValue, EnvironmentVariableTarget.Process);
try
{
var currentEnvironment = EswDevOpsSdk.GetEnvironment();
currentEnvironment.Should().Be(env);
}
finally
{
Environment.SetEnvironmentVariable(EswDevOpsSdk.EnvironmentEnvVariable, prevEnv, EnvironmentVariableTarget.Process);
}
}
public ActorTestsFixture()
{
if (string.IsNullOrWhiteSpace(EswDevOpsSdk.GetEnvironmentName()))
{
var defaultTestExecutionEnvironment = DeploymentEnvironment.Development.ToString();
System.Environment.SetEnvironmentVariable(EswDevOpsSdk.EnvironmentEnvVariable, defaultTestExecutionEnvironment);
EswDevOpsSdk.GetEnvironmentName().Should().Be(defaultTestExecutionEnvironment);
}
var builder = new ContainerBuilder();
builder.RegisterModule(new CoreModule(true));
builder.RegisterModule(new VstsModule());
builder.RegisterModule(new AzureManagementFluentModule());
builder.Register(c => new SierraDbContext
{
ConnectionString = c.Resolve <IConfigurationRoot>()["SierraDbConnectionString"]
});
builder.Register(c => new HttpClient {
Timeout = TimeSpan.FromSeconds(200)
});
builder.Register(c =>
{
var testConfig = new TestConfig();
var config = EswDevOpsSdk.BuildConfiguration(true);
config.GetSection("TestConfig").Bind(testConfig);
TestMiddlewareUri = $"{testConfig.ApiUrl}test";
TestRegion = string.IsNullOrEmpty(testConfig.RegionName)
? Region.EuropeNorth
: Region.Create(testConfig.RegionName);
Environment = Enum.Parse <DeploymentEnvironment>(testConfig.Environment, true);
DeploymentSubscriptionId = EswDevOpsSdk.SierraIntegrationSubscriptionId;
return(testConfig);
});
Container = builder.Build();
//trigger set up
Container.Resolve <TestConfig>();
}
/// <summary>
/// Uses the desired default configurations. Environment taken from EnvVariable "ENVIRONMENT" if not passed.
/// Builds configuration sources in the following order:
/// - 1. Environment variables
/// - 2. Command line arguments
/// - 3. Json file (appsettings.json, followed by appsettings.{env}.json)
/// Note:
/// - appsettings.{env}.json WILL override appsettings.json file settings.
/// </summary>
/// <param name="builder">The configuration builder to bind to.</param>
/// <param name="appSettingsPath">The application settings path.</param>
/// <param name="environment">Specify the environment - optional, as its loaded from the ENVIRONMENT env variable if not set here.</param>
/// <returns>The configuration builder after config has been added.</returns>
public static IConfigurationBuilder UseDefaultConfigs(this IConfigurationBuilder builder, string appSettingsPath = "appsettings.json", string environment = null)
{
builder.AddEnvironmentVariables()
.AddCommandLine(Environment.GetCommandLineArgs())
.AddJsonFile(appSettingsPath, true);
var env = EswDevOpsSdk.GetEnvironmentName();
if (!string.IsNullOrEmpty(environment))
{
env = environment;
}
if (!string.IsNullOrEmpty(env))
{
builder.AddJsonFile($"appsettings.{env}.json", true, true);
}
return(builder);
}
public async Task AddTest(OperationPhase operationPhase)
{
using (var scope = Fixture.Container.BeginLifetimeScope())
{
var cl = scope.Resolve <HttpClient>();
var azure = scope.ResolveKeyed <IAzure>(EswDevOpsSdk.GetEnvironment());
var resourceGroup = await EnsureResourceGroupExists(azure, TestResourceGroupName, Region.EuropeNorth);
var scaleSet = await GetScaleSet(azure);
await Prepare(azure, operationPhase, resourceGroup, scaleSet, IdentityName);
var msi = CreateMangedIdentityAssignment();
var actorResponse = await cl.PostJsonToActor(Fixture.TestMiddlewareUri, "ManagedIdentity", "Add", msi);
actorResponse.Should().NotBeNull();
actorResponse.IdentityId.Should().NotBeNullOrEmpty();
actorResponse.State.Should().Be(EntityStateEnum.Created);
var policy = Policy
.Handle <CloudException>()
.OrResult <IIdentity>(x => x == null)
.WaitAndRetryAsync(3, retryAttempt =>
TimeSpan.FromSeconds(Math.Pow(2, retryAttempt))
);
var capturedIdentity =
await policy.ExecuteAndCaptureAsync(() => azure.Identities.GetByIdAsync(actorResponse.IdentityId));
capturedIdentity.Result.Should().NotBeNull(
$"the identity {actorResponse.IdentityId} should be created in {azure.SubscriptionId} subscription");
capturedIdentity.Result.Name.Should().Be(msi.IdentityName);
capturedIdentity.Result.ResourceGroupName.Should().Be(msi.ResourceGroupName);
var modifiedScaleSet = await GetScaleSet(azure);
var isAssigned = IsIdentityAssigned(modifiedScaleSet, capturedIdentity.Result);
isAssigned.Should()
.BeTrue($"the identity {capturedIdentity.Result.Id} should be assigned to the scale set {modifiedScaleSet.Id}");
}
}
public async Task RemoveTests(bool resourceGroupExists)
{
using (var scope = Fixture.Container.BeginLifetimeScope())
{
var cl = scope.Resolve <HttpClient>();
var azure = scope.ResolveKeyed <IAzure>(EswDevOpsSdk.GetEnvironment());
await PrepareResourceGroup(resourceGroupExists, azure);
try
{
await cl.PostJsonToActor(Fixture.TestMiddlewareUri, "ResourceGroup", "Remove", TestResourceGroupRequest());
await Task.Delay(TimeSpan.FromSeconds(5));
var exists = await azure.ResourceGroups.ContainAsync(TestResourceGroupName);
exists.Should().BeFalse();
}
finally
{
await DeleteResourceGroup(azure, TestResourceGroupName);
}
}
}
private async Task CustomizeNonRingPipeline(VstsReleaseDefinition model, ReleaseDefinition pipeline)
{
//load sf endpoints
var connectionEndpoints =
await _taskAgentHttpClient.GetServiceEndpointsAsync(_vstsConfiguration.VstsTargetProjectId);
//set up source trigger
var sourceTrigger = (ArtifactSourceTrigger)pipeline.Triggers.First();
sourceTrigger.ArtifactAlias = model.BuildDefinition.ToString();
var clonedEnvStages = new List <ReleaseDefinitionEnvironment>();
var rank = 1;
//relink to target build definition
foreach (var e in pipeline.Environments)
{
if (!Enum.TryParse(e.Name, true, out DeploymentEnvironment sierraEnvironment))
{
throw new Exception($"Release template #{pipeline.Id} contains unrecognized environment - {e.Name}");
}
if (model.SkipEnvironments != null && model.SkipEnvironments.Contains(sierraEnvironment))
{
continue;
}
ReleaseDefinitionEnvironment predecessor = null;
foreach (var r in EswDevOpsSdk.GetRegionSequence(sierraEnvironment, default))
{
var regionEnv = e.DeepClone();
var phase = regionEnv.DeployPhases.First();
var envInput = (AgentDeploymentInput)phase.GetDeploymentInput();
envInput.ArtifactsDownloadInput.DownloadInputs.First().Alias = model.BuildDefinition.ToString();
regionEnv.Name = $"{e.Name} - {r}";
regionEnv.Rank = rank++;
regionEnv.Id = regionEnv.Rank;
//link condition to predecessor (region)
if (predecessor != null)
{
regionEnv.Conditions = new List <Condition>(new[]
{
new Condition(predecessor.Name, ConditionType.EnvironmentState,
"4" /*find the documentation for this value*/)
});
}
//re-point to correct SF instance
var sfDeployStep =
phase.WorkflowTasks.FirstOrDefault(t => t.TaskId == Guid.Parse(VstsSfDeployTaskId));
if (sfDeployStep == null)
{
throw new Exception(
$"Release template #{pipeline.Id} does not contain expected Task {VstsSfDeployTaskId} for {e.Name} environment");
}
var expectedConnectionName =
$"esw-{r.ToRegionCode().ToLowerInvariant()}-fabric-{e.Name.ToLowerInvariant()}";
var sfConnection = connectionEndpoints.FirstOrDefault(c => c.Name == expectedConnectionName);
if (sfConnection == null)
{
throw new Exception(
$"SF Endpoint {expectedConnectionName} not found in VSTS project {_vstsConfiguration.VstsTargetProjectId}");
}
sfDeployStep.Inputs[VstsSfDeployTaskConnectionNameInput] = sfConnection.Id.ToString();
//set region in manifest
var sfUpdaterStep =
phase.WorkflowTasks.FirstOrDefault(t => t.TaskId == Guid.Parse(VstsSfUpdateTaskId));
if (sfUpdaterStep == null)
{
throw new Exception(
$"Release template {pipeline.Name} does not contain expected Task {VstsSfUpdateTaskId} for {e.Name} environment");
}
sfUpdaterStep.Inputs[VstsSfUpdateTaskRegionInput] = r.ToRegionName();
clonedEnvStages.Add(regionEnv);
predecessor = regionEnv;
}
}
pipeline.Environments = clonedEnvStages;
//set tenant specific variables
pipeline.Variables["TenantCode"].Value = model.TenantCode;
pipeline.Variables["PortNumber"].Value = "11111"; //TODO: link to port management
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="env">hosting environment</param>
public Startup(IHostingEnvironment env)
{
_configuration = EswDevOpsSdk.BuildConfiguration(env.ContentRootPath, env.EnvironmentName);
AppSettings = _configuration.GetSection("App").Get <AppSettings>();
_bb = new BigBrother(AppSettings.Telemetry.InstrumentationKey, AppSettings.Telemetry.InternalKey);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="env">hosting environment</param>
public Startup(IHostingEnvironment env)
{
_configuration = EswDevOpsSdk.BuildConfiguration(env.ContentRootPath, env.EnvironmentName);
_configuration.GetSection("Telemetry").Bind(_telemetrySettings);
_bb = new BigBrother(_telemetrySettings.InstrumentationKey, _telemetrySettings.InternalKey);
}
public void BuildConfiguration_MSIAuthenticationTest()
{
var sut = EswDevOpsSdk.BuildConfiguration(AssemblyDirectory, "CI");
sut["keyVaultItem"].Should().Be("keyVaultItemValue");
}
public void BuildConfiguration_ReadFromEnvironmentalVariable()
{
var sut = EswDevOpsSdk.BuildConfiguration(AssemblyDirectory);
sut["PATH"].Should().NotBeNullOrEmpty();
}
public void GetRegionSequence_ForAllEnvironments(DeploymentEnvironment env, DeploymentRegion source, DeploymentRegion[] expected)
{
var ret = EswDevOpsSdk.GetRegionSequence(env, source);
ret.Should().ContainInOrder(expected).And.HaveCount(expected.Length);
}