public async Task <IActionResult> SubmitForReview(SubmitTestForReviewViewModel model)
{
try
{
var client = new GithubApiClient();
var pullRequest = client.GetPullRequest(model.PullRequestId);
if (pullRequest.title == null)
{
throw new Exception("Entered pull request does not exist.");
}
var user = await _usersProvider.GetUser(User.GetUserId());
await _testLabProvider.SubmitForReview(model.TestId, model.PullRequestId, user);
var test = await _testLabProvider.GetTest(model.TestId);
return(RedirectToAction("TestSuite", "TestLab", new { @id = test.TestSuite.Id }));
}
catch (Exception e)
{
Console.WriteLine(e);
ModelState.AddModelError(string.Empty, e.Message);
}
return(View(model));
}
public async Task RefreshTestSuits(long id, SystemUser user)
{
var gitClient = new GithubApiClient();
var firstSuits = await GetSuite(id);
var newGitHubIssues = gitClient.GetIssuesForProject(firstSuits.GitHubProjectId);
var trClient = new TestRailApiClient();
var testSuit = await GetSuite(id);
foreach (var issue in newGitHubIssues.GitHubIssues)
{
var seekingElement = testSuit.TestCases.FirstOrDefault(p => p.GitHubId == issue.number);
if (seekingElement != null)
{
continue;
}
//add new issue
var newTest = ExtractTestCase(user, issue, trClient, testSuit);
testSuit.TestCases.Add(newTest);
}
_dbContext.TestSuites.Update(testSuit);
await _dbContext.SaveChangesAsync();
}
public async Task GetAsync_String_Success_Returns_Null_WhenNoSuccessCode()
{
// Arrange
var url = "https://api.github.com/users/test";
var baseUrl = "https://api.github.com";
var mediaTypeHeader = "application/json";
var userAgent = "mvc-github-api-client";
var mockMessageHandler = new Mock <HttpMessageHandler>();
mockMessageHandler.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
.ReturnsAsync(new HttpResponseMessage
{
StatusCode = HttpStatusCode.NotFound
});
var httpClient = new HttpClient(mockMessageHandler.Object);
var httpClientFactoryMock = new Mock <IHttpClientFactory>(MockBehavior.Strict);
httpClientFactoryMock.Setup(f => f.CreateHttpClient(baseUrl, mediaTypeHeader, userAgent)).Returns(httpClient);
GithubApiClient githubApiClient = new GithubApiClient(httpClientFactoryMock.Object);
// Act
string result = await githubApiClient.GetAsync(url);
// Assert
Assert.Null(result);
}
public async Task GetAsync_String_Fail_ThrowsException()
{
// Arrange
var url = "https://api.github.com/users/test";
var baseUrl = "https://api.github.com";
var mediaTypeHeader = "application/json";
var userAgent = "mvc-github-api-client";
var mockMessageHandler = new Mock <HttpMessageHandler>();
mockMessageHandler.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
.Throws <HttpRequestException>();
var httpClient = new HttpClient(mockMessageHandler.Object);
var httpClientFactoryMock = new Mock <IHttpClientFactory>(MockBehavior.Strict);
httpClientFactoryMock.Setup(f => f.CreateHttpClient(baseUrl, mediaTypeHeader, userAgent)).Returns(httpClient);
GithubApiClient githubApiClient = new GithubApiClient(httpClientFactoryMock.Object);
// Act & Assert
await Assert.ThrowsAsync <HttpRequestException>(async() =>
{
await githubApiClient.GetAsync(url);
});
}
public async void GetRepositories()
{
var apiClient = new GithubApiClient();
var repositories = await apiClient.GetRepositories();
Assert.NotNull(repositories);
Assert.True(repositories.ToList().Count > 0);
}
public async Task SetAnalysisState(long stepId, AnalysisResolution resolution, bool isAlreadyExists, int issueId, string title, string message, long suiteId, SystemUser user)
{
var suite = await _dbContext.TestSuites.FirstOrDefaultAsync(p => p.Id == suiteId);
var gitClient = new GithubApiClient(user.GitHubAccount, user.GitHubToken);
var step = await GetStep(stepId);
if (step == null)
{
throw new Exception("Can't find requested step!");
}
var newAnalysis = new StepAnalysisItem
{
AddedBy = user,
AnalysisResolution = resolution,
Message = message
};
switch (resolution)
{
case AnalysisResolution.CannotReproduce:
if (isAlreadyExists)
{
var existingIssue = gitClient.GetIssue(issueId);
if (existingIssue == null)
{
throw new Exception("Can't find requested issue id");
}
//gitClient.AddComment(issueId, message);
newAnalysis.GitHubId = issueId;
}
else
{
var issue = gitClient.CreateNewIssue(title, message, suite.GitHubProjectId);
newAnalysis.GitHubId = issue.number;
await _testLabProvider.AddNewIssue(issue.number, suiteId, user);
}
break;
case AnalysisResolution.KnownIssue:
//gitClient.AddComment(issueId, message);
newAnalysis.GitHubId = issueId;
break;
case AnalysisResolution.NewIssue:
var newIssue = gitClient.CreateNewIssue(title, message, suite.GitHubProjectId);
newAnalysis.GitHubId = newIssue.number;
await _testLabProvider.AddNewIssue(newIssue.number, suiteId, user);
break;
default:
throw new ArgumentOutOfRangeException(nameof(resolution), resolution, null);
}
step.StepAnalysisItem.Add(newAnalysis);
await _dbContext.SaveChangesAsync();
}
public async Task <GitHubPullRequest> CreateNewPullRequest(long id, string login, string token, string title, string body)
{
var test = await GetTest(id);
var client = new GithubApiClient(login, token);
var pr = client.CreateNewPullRequest(title, body,
test.GitHubId.ToString());
client.AddAssignees(pr.number, new[] { login });
return(pr);
}
public async Task <long> AddNewIssue(int issueId, long testSuiteId, SystemUser user)
{
var existingIssue = await _dbContext.TestCases
.Include(p => p.TestSuite)
.FirstOrDefaultAsync(p => p.GitHubId == issueId);
if (existingIssue != null)
{
throw new Exception($@"The issue {issueId} was already added to {existingIssue.TestSuite?.Name} test suite.");
}
var testSuite = await GetSuite(testSuiteId);
var client = new GithubApiClient();
var issue = client.GetIssue(issueId);
var newTestCase = new TestCase
{
GitHubId = issue.number,
IsIssue = !issue.body.Contains("testrail"),
Name = issue.title,
Status = Status.ReadyForAutomation,
Message = issue.body
};
newTestCase.HistoryItems.Add(new TestCaseHistory
{
Message = "added issue from the GitHub",
Author = user,
});
if (!newTestCase.IsIssue && int.TryParse(issue.body.Split('/').Last(), out var trId))
{
var trClient = new TestRailApiClient();
var testRailIssue = trClient.GetTest(trId);
newTestCase.TestSteps = new List <TestStep>();
var steps = new List <TestStep>();
foreach (var customStepsSeparated in testRailIssue.custom_steps_separated)
{
steps.Add(new TestStep
{
Actual = customStepsSeparated.content,
Expected = customStepsSeparated.expected,
SortIndex = testRailIssue.custom_steps_separated.IndexOf(customStepsSeparated)
});
}
newTestCase.TestSteps = steps;
}
testSuite.TestCases.Add(newTestCase);
_dbContext.TestSuites.Update(testSuite);
await _dbContext.SaveChangesAsync();
return(newTestCase.Id);
}
public async Task GetAsync_Object_Success_Returns_Result()
{
// Arrange
var url = "https://api.github.com/users/test";
var baseUrl = "https://api.github.com";
var mediaTypeHeader = "application/json";
var userAgent = "mvc-github-api-client";
var responseJson = "{\"login\":\"test\"}";
var userResult = new GithubUser
{
UserName = "******"
};
var mockMessageHandler = new Mock <HttpMessageHandler>();
mockMessageHandler.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
.ReturnsAsync(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(responseJson)
});
var httpClient = new HttpClient(mockMessageHandler.Object);
var httpClientFactoryMock = new Mock <IHttpClientFactory>(MockBehavior.Strict);
httpClientFactoryMock.Setup(f => f.CreateHttpClient(baseUrl, mediaTypeHeader, userAgent)).Returns(httpClient);
GithubApiClient githubApiClient = new GithubApiClient(httpClientFactoryMock.Object);
// Act
GithubUser result = await githubApiClient.GetAsync <GithubUser>(url);
// Assert
Assert.NotNull(result);
Assert.IsType <GithubUser>(result);
Assert.Equal(userResult.UserName, result.UserName);
}
public async Task <IActionResult> Account(AccountViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
var user = await _usersProvider.GetUser(User.GetUserId());
user.GithubAliases = model.GitHubAliases?.Split(',');
if (model.GitHubLogin != user.GitHubAccount)
{
var apiClient = new GithubApiClient();
if (!apiClient.UserExists(model.GitHubLogin))
{
throw new Exception("GitHub User with provided login does not exist.");
}
}
user.GitHubAccount = model.GitHubLogin;
if (model.GitHubToken != user.GitHubToken)
{
var client = new GithubApiClient(user.GitHubAccount, model.GitHubToken);
if (!client.CredentialsAreValid())
{
throw new Exception("Specified token is not valid");
}
}
user.GitHubToken = model.GitHubToken;
user.Name = model.Name;
await _usersProvider.UpdateUser(user);
}
catch (Exception e)
{
ModelState.AddModelError(string.Empty, e.Message);
}
return(View(model));
}
public async Task UpdateTestsUser(int userId, int testId, bool isAssignee, SystemUser who)
{
var testToUpdate = await GetTest(testId);
var user = await _dbContext.SystemUsers.FirstOrDefaultAsync(p => p.Id == userId);
if (isAssignee)
{
testToUpdate.Assignee = user;
testToUpdate.HistoryItems.Add(new TestCaseHistory
{
Author = who,
Message = $@"changed assignee to <strong>{user.Name}</strong>"
});
if (!string.IsNullOrEmpty(user.GitHubToken))
{
var client = new GithubApiClient(user.GitHubAccount, user.GitHubToken);
client.AddAssignees(testToUpdate.GitHubId, new [] { user.GitHubAccount });
}
}
else
{
testToUpdate.Reviewer = user;
testToUpdate.HistoryItems.Add(new TestCaseHistory
{
Author = who,
Message = $@"changed reviewer to <strong>{user.Name}</strong>"
});
if (!string.IsNullOrEmpty(user.GitHubToken) && testToUpdate.PullRequestId != 0)
{
var client = new GithubApiClient(user.GitHubAccount, user.GitHubToken);
client.AddReviewer(testToUpdate.PullRequestId, new [] { user.GitHubAccount });
}
}
await UpdateTest(testToUpdate);
}
public async Task <IActionResult> TestCase(int id)
{
var gitClient = new GithubApiClient();
var model = new TestCaseViewModel
{
TestCase = await _testLabProvider.GetTest(id),
Users = await _usersProvider.GetAllUsers(),
};
model.GitHubComments = gitClient.GetCommentsForIssue(model.TestCase.GitHubId);
if (model.TestCase.PullRequestId == 0)
{
return(View(model));
}
try
{
model.PullRequestComment = gitClient.GetPullRequestComments(model.TestCase.PullRequestId);
}
catch (Exception e)
{
Console.WriteLine(e);
}
return(View(model));
}
public async Task AddNewTestSuite(int id, SystemUser systemUser)
{
var existingSuite = await _dbContext.TestSuites.CountAsync(p => p.GitHubProjectId == id) > 0;
if (existingSuite)
{
throw new Exception("Test suite with this project id was already added.");
}
var gitClient = new GithubApiClient();
var testRailClient = new TestRailApiClient();
var issues = gitClient.GetIssuesForProject(id);
var newTestSuite = new TestSuite
{
Name = issues.Name,
GitHubProjectId = id,
TestCases = new List <TestCase>(),
AddedOn = issues.AddedOn,
Description = issues.Body
};
foreach (var issue in issues.GitHubIssues)
{
var newTest = ExtractTestCase(systemUser, issue, testRailClient, newTestSuite);
newTestSuite.TestCases.Add(newTest);
}
var afterExistingSuite = await _dbContext.TestSuites.CountAsync(p => p.GitHubProjectId == id) > 0;
if (afterExistingSuite)
{
throw new Exception("Test suite with this project id was already added.");
}
_dbContext.TestSuites.Add(newTestSuite);
await _dbContext.SaveChangesAsync();
}
public static GitHubBranch GetBranch(string name)
{
var client = new GithubApiClient();
return(client.GetBranch(name));
}
public async Task <AnalysisResult> SetTestAnalysisState(
SystemUser user,
int testSuiteId,
int status,
long analysisId,
int issueId,
string title,
string message,
bool isAlreadyExists)
{
var analysis = await _dbContext.AnalysisResults
.Include(p => p.IdentifiedAt)
.ThenInclude(p => p.Test)
.FirstOrDefaultAsync(p => p.Id == analysisId);
var analysisState = (AnalysisStatus)status;
var gitClient = new GithubApiClient(user.GitHubAccount, user.GitHubToken);
var testSuite = await _dbContext.TestSuites.FirstOrDefaultAsync(p => p.Id == testSuiteId);
switch (analysisState)
{
case AnalysisStatus.NewIssue:
var newIssue = gitClient.CreateNewIssue(title, message, testSuite.GitHubProjectId);
analysis.GitHubId = newIssue.number;
await _testLabProvider.AddNewIssue(newIssue.number, testSuite.Id, user);
break;
case AnalysisStatus.KnownIssue:
var existingKnownIssue = gitClient.GetIssue(issueId);
if (existingKnownIssue == null)
{
throw new Exception("Can't find requested issue id");
}
analysis.GitHubId = issueId;
break;
case AnalysisStatus.CantReproduce:
if (isAlreadyExists)
{
var existingIssue = gitClient.GetIssue(issueId);
if (existingIssue == null)
{
throw new Exception("Can't find requested issue id");
}
analysis.GitHubId = issueId;
}
else
{
var issue = gitClient.CreateNewIssue(title, message, testSuite.GitHubProjectId);
analysis.GitHubId = issue.number;
await _testLabProvider.AddNewIssue(issue.number, testSuite.Id, user);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
analysis.FinishedOn = DateTime.Now;
analysis.Message = message;
analysis.AnalysisStatus = analysisState;
_dbContext.AnalysisResults.Update(analysis);
//find the same steps within tests and apply the same analysis result
if (analysisState == AnalysisStatus.NewIssue || analysisState == AnalysisStatus.KnownIssue)
{
var testName = analysis.IdentifiedAt.Test.Name;
var stepMessage = analysis.IdentifiedAt.Message;
var similarTests = await _dbContext.Tests
.Include(p => p.Steps)
.Where(p => p.Name == testName &&
p.AnalysisResult == null &&
p.Steps.Any(step => !step.IsPassed) &&
p.Steps.Any(z => z.Message == stepMessage))
.ToListAsync();
foreach (var similarTest in similarTests)
{
var newAnalysis = new AnalysisResult
{
AnalysisStatus = AnalysisStatus.KnownIssue,
By = analysis.By,
FinishedOn = DateTime.Now,
GitHubId = analysis.GitHubId,
Message = analysis.Message,
IdentifiedAt = similarTest.Steps.FirstOrDefault(p => !p.IsPassed)
};
similarTest.AnalysisResult = newAnalysis;
_dbContext.Tests.Update(similarTest);
}
}
await _dbContext.SaveChangesAsync();
return(analysis);
}
public async Task <IActionResult> SwitchState(int id, int statusId, string returnurl)
{
var test = await _testLabProvider.GetTest(id);
var who = await _usersProvider.GetUser(User.GetUserId());
var statusType = (Status)statusId;
var historyItem = new TestCaseHistory
{
Author = who,
Message = $@"changed status from <strong>{test.Status.GetDescription()}</strong> to <strong>{statusType.GetDescription()}</strong>"
};
switch (statusType)
{
case Status.New:
break;
case Status.ReadyForAutomation:
break;
case Status.InProgress:
test.Assignee = who;
test.StartedOn = DateTime.Now;
if (!string.IsNullOrEmpty(who.GitHubToken))
{
var gitClient = new GithubApiClient(who.GitHubAccount, who.GitHubToken);
gitClient.AddAssignees(test.GitHubId, new [] { who.GitHubAccount });
}
break;
case Status.ToCrossPlatform:
break;
case Status.ReadyForReview:
return(RedirectToAction("SubmitForReview", "TestLab", new { @id = id }));
case Status.ReviewStarted:
test.Reviewer = who;
if (!string.IsNullOrEmpty(who.GitHubToken))
{
var gitClient = new GithubApiClient(who.GitHubAccount, who.GitHubToken);
gitClient.AddReviewer(test.PullRequestId, new [] { who.GitHubAccount });
}
break;
case Status.CannotAutomate:
break;
case Status.Finished:
test.FinishedOn = DateTime.Now;
break;
case Status.ChangesRequested:
return(RedirectToAction("RequestChange", "TestLab", new { @id = id }));
case Status.Fixed:
break;
default:
throw new ArgumentOutOfRangeException();
}
test.Status = statusType;
test.HistoryItems.Add(historyItem);
await _testLabProvider.UpdateTest(test);
if (string.IsNullOrEmpty(returnurl))
{
return(Redirect(Url.RouteUrl(new { controller = "TestLab", action = "TestSuite" }) + "/" +
test.TestSuite.Id + "#test-" + test.Id));
}
else
{
return(LocalRedirect(returnurl));
}
}
public void TestGit()
{
var gitClient = new GithubApiClient("", "");
gitClient.AddComment(2747, "Added by mistake");
}
public static GitHubPullRequest GetPullRequest(int id)
{
var client = new GithubApiClient();
return(client.GetPullRequest(id));
}
