public async Task WhenICreatedAServiceHook(KeyValuePair <string, string> teamProject) { var service = new VstsService(); var teamProjects = await service.GetProjects(Config.Account, Config.Token); var tp = teamProjects.FirstOrDefault(p => p.Name.Equals(teamProject.Value, StringComparison.OrdinalIgnoreCase)); var subscription = new Subscription { ConsumerActionId = "httpRequest", ConsumerId = "webHooks", ConsumerInputs = new Dictionary <string, string> { { "url", "https://myservice/myhookeventreceiver" } }, EventType = "build.complete", PublisherId = "tfs", PublisherInputs = new Dictionary <string, string> { { "buildStatus", "Failed" }, { "definitionName", "Build 1" }, { "projectId", tp.Id.ToString() } }, ResourceVersion = "1.0-preview.1" }; subscription = await service.CreateSubscription(Config.Account, subscription, Config.Token); ScenarioContext.Current["SubscriptionId"] = subscription.Id; }
public async Task GetBuildTest() { var accountName = "myaccount"; var teamProjectName = "myproject"; var service = new VstsService(); var id = 1; await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.GetBuildAsync(null, teamProjectName, id, this.token)); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.GetBuildAsync(accountName, null, id, this.token)); await Assert.ThrowsExceptionAsync <ArgumentOutOfRangeException>(async() => await service.GetBuildAsync(accountName, teamProjectName, 0, this.token)); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.GetBuildAsync(accountName, teamProjectName, 1, null)); using (ShimsContext.Create()) { var client = new ShimBuildHttpClientBase(new ShimBuildHttpClient()); InitializeConnectionShim(client.Instance); client.GetBuildAsyncStringInt32StringObjectCancellationToken = (teamProject, buildId, arg3, arg4, cancellationToken) => Task.Run( () => { teamProject.Should().Be(teamProjectName); buildId.Should().Be(id); return(new Build()); }, cancellationToken); await service.GetBuildAsync(accountName, teamProjectName, id, this.token); } }
public async void VstsService_GetWorkItemById_ReturnsWorkItem(long id) { var sut = new VstsService(); var result = sut.GetIssueAsync(id); Assert.IsType <Issue>(result); }
public async Task ThenIDeleteTheServiceHook() { var subscriptionId = (Guid)ScenarioContext.Current["SubscriptionId"]; var service = new VstsService(); await service.DeleteSubscription(Config.Account, subscriptionId, Config.Token); }
public void GivenIHaveAnApprovalForRelease(KeyValuePair <string, string> teamProject, int releaseDefinitionId) { var service = new VstsService(); var approvals = service.GetApprovals(Config.Account, teamProject.Value, Config.Profile).Result; Config.Approval = approvals.FirstOrDefault(a => a.ReleaseDefinitionReference.Id.Equals(releaseDefinitionId)); }
public async Task GetReleaseAsyncTest() { var accountName = "myaccount"; var projectName = "myproject"; var release = new Release(); var releaseId = 99; var service = new VstsService(); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.GetReleaseAsync(null, projectName, releaseId, this.token)); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.GetReleaseAsync(accountName, null, releaseId, this.token)); await Assert.ThrowsExceptionAsync <ArgumentOutOfRangeException>(async() => await service.GetReleaseAsync(accountName, projectName, -10, this.token)); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.GetReleaseAsync(accountName, projectName, releaseId, null)); using (ShimsContext.Create()) { var client = new ShimReleaseHttpClientBase(new ShimReleaseHttpClient2()) { GetReleaseAsyncStringInt32NullableOfBooleanIEnumerableOfStringObjectCancellationToken = (teamProject, id, arg3, arg4, arg5, cancellationToken) => Task.Run( () => { teamProject.Should().Be(projectName); id.Should().Be(releaseId); return(release); }, cancellationToken) }; } }
public async Task GetBuildDefinitionsTest() { var service = new VstsService(); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.GetBuildDefinitionsAsync(null, "myproject", this.token)); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.GetBuildDefinitionsAsync("myaccount", null, this.token)); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.GetBuildDefinitionsAsync("myaccount", "myproject", null)); using (ShimsContext.Create()) { var expected = new List <BuildDefinitionReference>(); var clients = new VssHttpClientBase[] { new ShimBuildHttpClient { GetDefinitionsAsyncStringStringStringStringNullableOfDefinitionQueryOrderNullableOfInt32StringNullableOfDateTimeIEnumerableOfInt32StringNullableOfDateTimeNullableOfDateTimeObjectCancellationToken = (s, s1, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, cancellationToken) => Task.Run(() => expected, cancellationToken) }.Instance }; InitializeConnectionShim(clients); IEnumerable <BuildDefinitionReference> actual = await service.GetBuildDefinitionsAsync("myaccount", "myproject", this.token); expected.ShouldAllBeEquivalentTo(actual); } }
public void ThenIsRejectedWithComment(KeyValuePair <string, string> teamProject) { var service = new VstsService(); var approval = service.GetApproval(Config.Account, teamProject.Value, Config.Approval.Id, Config.Profile.Token).Result; approval.Status.Should().Be(ApprovalStatus.Rejected); }
public void ThenACreatedReleaseShouldExistOn(KeyValuePair <string, string> teamProject) { var service = new VstsService(); var build = service.GetReleaseAsync(Config.Account, teamProject.Value, Config.ReleaseId, Config.Token).Result; build.Should().NotBeNull(); }
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)); }
public void ThenABuildWithIdShouldExist(KeyValuePair <string, string> teamProject) { var service = new VstsService(); var build = service.GetBuildAsync(Config.Account, teamProject.Value, Config.BuildId, Config.Token).Result; build.Should().NotBeNull(); }
public async Task ThenIListTheServiceHook() { var service = new VstsService(); var subscriptions = await service.GetSubscriptions(Config.Account, Config.Token); subscriptions.Should().HaveCount(1); }
public async Task ThenIGetTheServiceHook() { var subscriptionId = (Guid)ScenarioContext.Current["SubscriptionId"]; var service = new VstsService(); var subscription = await service.GetSubscription(Config.Account, subscriptionId, Config.Token); subscription.Should().NotBeNull(); }
public void GivenNoApprovalsAreWaitingIn(KeyValuePair <string, string> teamProject) { var service = new VstsService(); var approvals = service.GetApprovals(Config.Account, teamProject.Value, Config.Profile).Result; foreach (var approval in approvals) { service.ChangeApprovalStatus(Config.Account, teamProject.Value, Config.Profile, approval.Id, ApprovalStatus.Rejected, string.Empty).Wait(); } }
public async Task GetApprovalTest() { var accountName = "myaccount"; var projectName = "myproject"; var service = new VstsService(); int id = 1; await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.GetApproval(null, projectName, id, this.token)); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.GetApproval(accountName, null, id, this.token)); await Assert.ThrowsExceptionAsync <ArgumentOutOfRangeException>(async() => await service.GetApproval(accountName, projectName, 0, this.token)); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.GetApproval(accountName, projectName, id, null)); using (ShimsContext.Create()) { var expected = new ReleaseApproval { Id = 1234, ApprovalType = ApprovalType.Undefined }; 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()) { GetApprovalAsyncStringInt32NullableOfBooleanObjectCancellationToken = (project, approvalId, includeHistory, objectState, cancellationToken) => Task.Run( () => { expected.Id = approvalId; return(expected); }, cancellationToken) }.Instance }); ReleaseApproval actual = await service.GetApproval(accountName, projectName, id, this.token); Assert.IsNotNull(actual); Assert.AreEqual(expected, actual); Assert.AreEqual(id, actual.Id); } }
public void GeStandards() { var httpHelperMock = new Mock <IVstsClient>(); var mockLogger = new Mock <ILog>(MockBehavior.Loose); httpHelperMock.Setup(m => m.Get(It.IsAny <string>())).Returns(AllIdsResponse); var vsts = new VstsService(_appServiceSettings, new GitDynamicModelGenerator(), new JsonMetaDataConvert(null), httpHelperMock.Object, mockLogger.Object); var standards = vsts.GetStandards(); Assert.AreEqual(5, standards.Count()); }
public void ShouldReturnNewDictionaryIfBlobsAreNull() { var httpHelperMock = new Mock <IVstsClient>(); var mockLogger = new Mock <ILog>(MockBehavior.Loose); httpHelperMock.Setup(m => m.Get(It.IsAny <string>())).Returns(AllIdsResponse); var vsts = new VstsService(_appServiceSettings, new GitDynamicModelGenerator(), null, httpHelperMock.Object, mockLogger.Object); httpHelperMock.Setup(m => m.Get(It.IsAny <string>())).Returns(string.Empty); var ids = vsts.GetAllFileContents(_appServiceSettings.VstsGitGetFilesUrl); Assert.AreEqual(ids, new Dictionary <string, string>()); }
public void GivenIsAuthorized() { var authService = new AuthenticationService(); var vstsService = new VstsService(); var botData = Config.GetBotData(); botData.LoadAsync(CancellationToken.None).Wait(); if (!botData.UserData.TryGetValue("userData", out UserData data)) { data = new UserData(); } var refreshToken = Config.RefreshToken; if (data.Profile != null && !Config.RefreshTokenReinitialize) { refreshToken = data.Profile.Token.RefreshToken; } Config.RefreshTokenReinitialize = false; var oldToken = new OAuthToken { AppSecret = Config.AppSecret, AuthorizeUrl = Config.AuthorizeUrl, RefreshToken = refreshToken }; var token = authService.GetToken(oldToken).Result; var p = vstsService.GetProfile(token).Result; var accounts = vstsService.GetAccounts(token, p.Id).Result; var profile = new Profile { Accounts = accounts.Select(a => a.AccountName).ToList(), Id = p.Id, Token = token }; data.Profiles.Clear(); data.SelectProfile(profile); botData.UserData.SetValue("userData", data); botData.FlushAsync(CancellationToken.None).Wait(); Config.Profile = profile; Config.Token = token; }
public void GetIds() { var httpHelperMock = new Mock <IVstsClient>(); var mockLogger = new Mock <ILog>(MockBehavior.Loose); httpHelperMock.Setup(m => m.Get(It.IsAny <string>())).Returns(AllIdsResponse); var vsts = new VstsService(_appServiceSettings, new GitDynamicModelGenerator(), null, httpHelperMock.Object, mockLogger.Object); var ids = vsts.GetExistingStandardIds(); Debug.Assert(ids != null, "ids != null"); Assert.AreEqual(5, ids.Count()); Assert.IsTrue(ids.Contains("13")); Assert.IsFalse(ids.Contains("14")); }
public async Task GetReleaseAsyncTest() { var accountName = "myaccount"; var projectName = "myproject"; var releaseId = 99; var service = new VstsService(); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.GetReleaseAsync(null, projectName, releaseId, this.token)); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.GetReleaseAsync(accountName, null, releaseId, this.token)); await Assert.ThrowsExceptionAsync <ArgumentOutOfRangeException>(async() => await service.GetReleaseAsync(accountName, projectName, -10, this.token)); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.GetReleaseAsync(accountName, projectName, releaseId, null)); }
public async Task GetProfileTest() { var service = new VstsService(); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.GetProfile(null)); using (ShimsContext.Create()) { var expected = new Profile(); InitializeConnectionShim(GetProfileHttpClient(expected)); Profile actual = await service.GetProfile(this.token); Assert.AreEqual(expected, actual); } }
public async Task GetProjectsTest() { var account = "anaccount"; var service = new VstsService(); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.GetProjects(null, this.token)); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.GetProjects(account, null)); using (ShimsContext.Create()) { var accounts = new List <Account> { new Account(Guid.Empty) { AccountName = "myaccount", AccountUri = new Uri("https://myaccount.visualstudio.com") } }; var expected = new List <TeamProjectReference> { new TeamProjectReference { Id = Guid.NewGuid(), Name = "My Project", Url = "https://myaccount.visualstudio.com/my%20project" } }; var clients = new VssHttpClientBase[] { GetAccountHttpClient(accounts), GetProjectHttpClient(expected), GetProfileHttpClient(new Profile()) }; InitializeConnectionShim(clients); // await Assert.ThrowsExceptionAsync<ArgumentOutOfRangeException>(async () => await service.GetProjects("someaccount", this.token)); IEnumerable <TeamProjectReference> actual = await service.GetProjects(accounts[0].AccountName, this.token); expected.ShouldAllBeEquivalentTo(actual); } }
public async Task GetAccountsTest() { var service = new VstsService(); Guid memberId = Guid.NewGuid(); await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => service.GetAccounts(null, memberId)); using (ShimsContext.Create()) { var expected = new List <Account>(); InitializeConnectionShim(GetAccountHttpClient(expected)); IList <Account> actual = await service.GetAccounts(this.token, memberId); Assert.AreEqual(expected, actual); } }
public void GivenIsAuthorized() { var authService = new AuthenticationService(Config.AppSecret, Config.AuthorizeUrl); var vstsService = new VstsService(); var data = Config.BotState.GetUserData(ChannelIds.Directline, Config.UserName); var profile = data.GetProperty <VstsProfile>("Profile"); var refreshToken = Config.RefreshToken; if (profile != null && !Config.RefreshTokenReinitialize) { refreshToken = profile.Token.RefreshToken; } Config.RefreshTokenReinitialize = false; var token = authService.GetToken(new OAuthToken { RefreshToken = refreshToken }).Result; var p = vstsService.GetProfile(token).Result; var accounts = vstsService.GetAccounts(token, p.Id).Result; profile = new VstsProfile { Accounts = accounts.Select(a => a.AccountName).ToList(), Id = p.Id, DisplayName = p.DisplayName, EmailAddress = p.EmailAddress, Token = token }; data.SetProfile(profile); data.SetProfiles(new List <VstsProfile> { profile }); Config.BotState.SetUserDataAsync(ChannelIds.Directline, Config.UserName, data).Wait(); Config.Profile = profile; Config.Token = token; }
public async Task GetReleaseDefinitionsAsyncTest() { var accountName = "myaccount"; var projectName = "myproject"; var service = new VstsService(); var expected = new List <ReleaseDefinition>(); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.GetBuildDefinitionsAsync(null, projectName, this.token)); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.GetBuildDefinitionsAsync(accountName, null, this.token)); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.GetBuildDefinitionsAsync(accountName, projectName, null)); using (ShimsContext.Create()) { var client = new ShimReleaseHttpClientBase(new ShimReleaseHttpClient2()) { GetReleaseDefinitionsAsyncStringStringNullableOfReleaseDefinitionExpandsStringStringNullableOfInt32StringNullableOfReleaseDefinitionQueryOrderStringNullableOfBooleanIEnumerableOfStringIEnumerableOfStringIEnumerableOfStringObjectCancellationToken = (teamProject, s1, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, cancellationToken) => Task.Run( () => { teamProject.Should().Be(projectName); return(expected); }, cancellationToken) }; InitializeConnectionShim(client); var actual = await service.GetReleaseDefinitionsAsync(accountName, projectName, this.token); actual.ShouldBeEquivalentTo(expected); } }
public async Task ChangeApprovalStatusTest() { var account = "MyAccount"; var project = "MyProject"; const int id = 1234; var comment = "My comment"; var status = ApprovalStatus.Undefined; var profile = new VstsProfile { Id = Guid.NewGuid(), Token = this.token, EmailAddress = "*****@*****.**" }; var service = new VstsService(); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.ChangeApprovalStatus(null, project, profile, id, status, comment)); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.ChangeApprovalStatus(account, null, profile, id, status, comment)); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.ChangeApprovalStatus(account, project, null, id, status, comment)); using (ShimsContext.Create()) { ReleaseApproval updatedApproval = null; 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()) { GetApprovalAsyncStringInt32NullableOfBooleanObjectCancellationToken = (p, i, includeHistory, userState, cancellationToken) => Task.Run( () => new ReleaseApproval { Id = i }, cancellationToken), UpdateReleaseApprovalAsyncReleaseApprovalStringInt32ObjectCancellationToken = (releaseApproval, p, i, userState, cancellationToken) => Task.Run( delegate { Assert.AreEqual(project, p); updatedApproval = releaseApproval; return(updatedApproval); }, cancellationToken) }.Instance }); await service.ChangeApprovalStatus(account, project, profile, 4, ApprovalStatus.Canceled, comment); Assert.IsNotNull(updatedApproval); Assert.AreEqual(4, updatedApproval.Id); Assert.AreEqual(ApprovalStatus.Canceled, updatedApproval.Status); Assert.AreEqual(comment, updatedApproval.Comments); } }
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); } }
public async Task GetApprovalsTest() { var accountName = "MyAccount"; var projectName = "MyProject"; var profile = new VstsProfile { Id = Guid.NewGuid(), Token = this.token, EmailAddress = "*****@*****.**" }; var service = new VstsService(); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.GetApprovals(null, projectName, profile)); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.GetApprovals(accountName, null, profile)); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await service.GetApprovals(accountName, projectName, null)); using (ShimsContext.Create()) { var expected = new List <ReleaseApproval> { new ReleaseApproval { Id = 1234, ApprovalType = ApprovalType.Undefined } }; InitializeConnectionShim(new VssHttpClientBase[] { GetAccountHttpClient(new List <Account> { new Account(Guid.Empty) { AccountName = "myaccount", AccountUri = new Uri("https://myaccount.visualstudio.com") } }), GetProfileHttpClient(new Profile()), new ShimReleaseHttpClient2 { GetApprovalsAsync2StringStringNullableOfApprovalStatusIEnumerableOfInt32NullableOfApprovalTypeNullableOfInt32NullableOfInt32NullableOfReleaseQueryOrderNullableOfBooleanObjectCancellationToken = (project, assignedToFilter, statusFilter, releaseIdsFilter, typeFilter, top, continuationToken, queryOrder, includeMyGroupApprovals, userState, cancellationToken) => Task.Run( () => (IPagedCollection <ReleaseApproval>) new StubIPagedCollection <ReleaseApproval> { CountGet = () => expected.Count, ItemGetInt32 = i => expected[i] }, cancellationToken) }.Instance }); IList <ReleaseApproval> actual = await service.GetApprovals(accountName, projectName, profile); Assert.AreEqual(expected.Count, actual.Count); for (var i = 0; i < actual.Count; i++) { Assert.AreEqual(expected[i], actual[i]); } } }