Esempio n. 1
0
        public void GivenIStartedOn(int definitionId, KeyValuePair <string, string> teamProject)
        {
            var service = new VstsService();

            service.CreateReleaseAsync(Config.Account, teamProject.Value, definitionId, Config.Token).Wait();

            Thread.Sleep(TimeSpan.FromSeconds(2));
        }
Esempio n. 2
0
        public async Task CreateReleaseAsyncTest()
        {
            var accountName = "myaccount";
            var projectName = "myproject";
            var service     = new VstsService();
            int id          = 1;

            var builds = new List <Build> {
                new Build {
                    Id = 12345, LastChangedDate = DateTime.Now
                }
            };

            await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.CreateReleaseAsync(null, projectName, id, this.token));

            await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.CreateReleaseAsync(accountName, null, id, this.token));

            await Assert.ThrowsExceptionAsync <ArgumentOutOfRangeException>(async() => await service.CreateReleaseAsync(accountName, projectName, 0, this.token));

            await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.CreateReleaseAsync(accountName, projectName, id, null));

            using (ShimsContext.Create())
            {
                var shimBuildHttpClient = new ShimBuildHttpClient();

                shimBuildHttpClient.SendAsyncOf1HttpMethodGuidObjectApiResourceVersionHttpContentIEnumerableOfKeyValuePairOfStringStringObjectCancellationTokenFuncOfHttpResponseMessageCancellationTokenTaskOfM0 <IPagedList <Build> >((method, guid, arg3, apiResourceVersion, content, queryParams, arg7, cancellationToken, arg9) =>
                                                                                                                                                                                                                                        Task.Run(
                                                                                                                                                                                                                                            () => new PagedList <Build>(builds, string.Empty) as IPagedList <Build>,
                                                                                                                                                                                                                                            cancellationToken));

                InitializeConnectionShim(new VssHttpClientBase[]
                {
                    GetAccountHttpClient(new List <Account>
                    {
                        new Account(Guid.Empty)
                        {
                            AccountName = "myaccount",
                            AccountUri  = new Uri("https://myaccount.visualstudio.com")
                        }
                    }),
                    GetProfileHttpClient(new Profile()),
                    new ShimReleaseHttpClientBase(new ShimReleaseHttpClient2())
                    {
                        GetReleaseDefinitionAsyncStringInt32IEnumerableOfStringObjectCancellationToken = (project, definitionId, filters, userState, cancellationToken) => Task.Run(
                            () =>
                        {
                            return(new ReleaseDefinition()
                            {
                                Artifacts = new List <Artifact>
                                {
                                    new Artifact
                                    {
                                        IsPrimary = true,
                                        Alias = "mybuildartifcat",
                                        DefinitionReference = new Dictionary <string, ArtifactSourceReference>
                                        {
                                            { "definition", new ArtifactSourceReference {
                                                  Id = "1234"
                                              } }
                                        },
                                        Type = ArtifactTypes.BuildArtifactType
                                    }
                                }
                            });
                        }),
                        CreateReleaseAsyncReleaseStartMetadataStringObjectCancellationToken = (startMetadata, project, userState, cancellationToken) => Task.Run(
                            () =>
                        {
                            Assert.AreEqual(projectName, project);
                            return(new Release());
                        },
                            cancellationToken)
                    },
                    shimBuildHttpClient.Instance
                });

                await service.CreateReleaseAsync(accountName, projectName, id, this.token);
            }
        }