Ejemplo n.º 1
0
        public async Task ReconcileIntegrationTest()
        {
            var client          = new VstsRestClient(_config.Organization, _config.Token);
            var projectId       = (await client.GetAsync(Project.Properties(_config.Project))).Id;
            var releasePipeline = await client.GetAsync(ReleaseManagement.Definition(_config.Project, "1"))
                                  .ConfigureAwait(false);

            await ManagePermissions
            .ForReleasePipeline(client, projectId, releasePipeline.Id, releasePipeline.Path)
            .Permissions(Release.DeleteReleasePipelines)
            .SetToAsync(PermissionId.Allow);

            var rule = new NobodyCanDeleteReleases(client);

            (await rule.EvaluateAsync(projectId, releasePipeline))
            .ShouldBe(false);

            await rule.ReconcileAsync(projectId, releasePipeline.Id);

            await Policy
            .Handle <Exception>()
            .WaitAndRetryAsync(Constants.NumRetries, t => TimeSpan.FromSeconds(t))
            .ExecuteAsync(async() =>
            {
                (await rule.EvaluateAsync(projectId, releasePipeline)).ShouldBe(true);
            });
        }
        public async Task Exclude(string group)
        {
            // Arrange
            CustomizePermission(PermissionId.Allow, Release.AdministerReleasePermissions);
            CustomizeApplicationGroup(group);

            // Act
            var rule   = new NobodyCanDeleteReleases(_fixture.Create <IVstsRestClient>());
            var result = await rule.EvaluateAsync(_fixture.Create <string>(), _fixture.Create <Response.ReleaseDefinition>());

            // Assert
            result
            .Value
            .ShouldBeTrue();
        }
        public async Task Reconcile()
        {
            // Arrange
            CustomizePermission(PermissionId.Allow, Release.DeleteReleases);
            var client = _fixture.Create <IVstsRestClient>();

            // Act
            var rule = new NobodyCanDeleteReleases(client);
            await rule.ReconcileAsync(_fixture.Create <string>(), _fixture.Create <string>());

            // Assert
            await client
            .Received(_fixture.RepeatCount *_fixture.RepeatCount)      // identities * permissions
            .PostAsync(Arg.Any <IVstsRequest <Permissions.UpdateWrapper, object> >(), Arg.Any <Permissions.UpdateWrapper>());
        }
        public async Task EvaluateTrue(
            [CombinatorialValues(PermissionId.Deny, PermissionId.DenyInherited, PermissionId.NotSet)] int permissionId,
            [CombinatorialValues(
                 Release.DeleteReleases,
                 Release.AdministerReleasePermissions,
                 Release.DeleteReleasePipelines)] int permissionBit)
        {
            // Arrange
            CustomizePermission(permissionId, permissionBit);

            // Act
            var rule   = new NobodyCanDeleteReleases(_fixture.Create <IVstsRestClient>());
            var result = await rule.EvaluateAsync(_fixture.Create <string>(), _fixture.Create <Response.ReleaseDefinition>());

            // Assert
            result
            .Value
            .ShouldBeTrue();
        }