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 void TestPrioritiesMaps()
{
var(webClient, webClientFactory) = MockWebClientFactory(
new Dictionary <string, object>
{
{ requestUrl, data_priorities_1 }
});
var client = new TestRailApiClient(
data_config,
webClientFactory.Object);
var priorities = client.Priorities;
Assert.That(priorities, Has.Count.EqualTo(4));
Assert.That(priorities, Does.ContainKey("P1 - Don't Test"));
Assert.That(priorities, Does.ContainKey("P3 - Test If Time"));
Assert.That(priorities, Does.ContainKey("P1"));
Assert.That(priorities, Does.ContainKey("P2"));
var prioritiesById = client.PrioritiesById;
Assert.That(prioritiesById, Has.Count.EqualTo(3));
Assert.That(prioritiesById, Does.ContainKey(1));
Assert.That(prioritiesById, Does.ContainKey(2));
Assert.That(prioritiesById, Does.ContainKey(3));
}
public void TestStatusesMaps()
{
var(webClient, webClientFactory) = MockWebClientFactory(
new Dictionary <string, object>
{
{ requestUrl, data_statuses_1 }
});
var client = new TestRailApiClient(
data_config,
webClientFactory.Object);
var statuses = client.Statuses;
Assert.That(statuses, Has.Count.EqualTo(4));
Assert.That(statuses, Does.ContainKey("status-1"));
Assert.That(statuses, Does.ContainKey("status-2"));
Assert.That(statuses, Does.ContainKey("STATUS"));
Assert.That(statuses, Does.ContainKey("STATUS 3"));
var statusesById = client.StatusesById;
Assert.That(statusesById, Has.Count.EqualTo(3));
Assert.That(statusesById, Does.ContainKey(1));
Assert.That(statusesById, Does.ContainKey(2));
Assert.That(statusesById, Does.ContainKey(3));
}
public async Task TestPrioritiesCaching()
{
var(webClient, webClientFactory) = MockWebClientFactory(
new Dictionary <string, object>
{
{ requestUrl, data_priorities_1 }
});
var client = new TestRailApiClient(
data_config,
webClientFactory.Object);
var priorities1 = client.Priorities;
webClient.Verify(
c => c.OpenReadTaskAsync(It.Is <string>(address => address == requestUrl)),
Times.Exactly(1));
var priorities2 = client.Priorities;
webClient.Verify(
c => c.OpenReadTaskAsync(It.Is <string>(address => address == requestUrl)),
Times.Exactly(1));
var prioritiesById1 = client.PrioritiesById;
webClient.Verify(
c => c.OpenReadTaskAsync(It.Is <string>(address => address == requestUrl)),
Times.Exactly(1));
var prioritiesById2 = client.PrioritiesById;
webClient.Verify(
c => c.OpenReadTaskAsync(It.Is <string>(address => address == requestUrl)),
Times.Exactly(1));
var priorities = await client.GetPrioritiesAsync();
webClient.Verify(
c => c.OpenReadTaskAsync(It.Is <string>(address => address == requestUrl)),
Times.Exactly(2));
var priorities3 = client.Priorities;
webClient.Verify(
c => c.OpenReadTaskAsync(It.Is <string>(address => address == requestUrl)),
Times.Exactly(2));
var prioritiesById3 = client.PrioritiesById;
webClient.Verify(
c => c.OpenReadTaskAsync(It.Is <string>(address => address == requestUrl)),
Times.Exactly(2));
}
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 TestInvalidConfig(TestRailApiClientConfiguration config)
{
Assert.CatchAsync <TestRailClientException>(async() =>
{
var(webClient, webClientFactory) = MockWebClientFactory(
new Dictionary <string, object>
{
{ "https://test:1234/index.php?/api/v2/get_statuses", data_statuses_1 }
});
var client = new TestRailApiClient(
config,
webClientFactory.Object);
});
}
public async Task TestValidUrlInConfig(string apiUrl)
{
var(webClient, webClientFactory) = MockWebClientFactory(
new Dictionary <string, object>
{
{ "https://test:1234/index.php?/api/v2/get_statuses", data_statuses_1 }
});
var client = new TestRailApiClient(
new TestRailApiClientConfiguration
{
Url = apiUrl,
UserName = "******",
AppKey = "qwerasdfzxcv",
},
webClientFactory.Object);
var statuses = await client.GetStatusesAsync();
Assert.That(statuses, Has.Length.GreaterThan(0));
}
public async Task RefreshTestSteps(int id)
{
var test = await GetTest(id);
var client = new TestRailApiClient();
var testRailTest = client.GetTest(test.TestRailId);
test.Preconditions = testRailTest.custom_preconds;
var newSteps = new List <TestStep>();
testRailTest.custom_steps_separated.ForEach(p => newSteps.Add(new TestStep
{
Actual = p.content,
Expected = p.expected,
SortIndex = testRailTest.custom_steps_separated.IndexOf(p)
}));
foreach (var testTestStep in test.TestSteps.ToList())
{
test.TestSteps.Remove(testTestStep);
}
test.TestSteps = newSteps;
await UpdateTest(test);
}
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();
}
private static TestCase ExtractTestCase(SystemUser systemUser, GitHubIssue issue, TestRailApiClient testRailClient,
TestSuite newTestSuite)
{
var testId = issue.body.Split('/').Last();
TestRailTest testRailTest = null;
TestCase newTest;
if (int.TryParse(testId, out var tId))
{
testRailTest = testRailClient.GetTest(tId);
newTestSuite.TestRailId = testRailTest.suite_id;
newTest = new TestCase
{
Name = testRailTest.title,
GitHubId = issue.number,
Status = Status.New,
TestRailId = testRailTest.id,
TestSteps = new List <TestStep>(),
Preconditions = testRailTest.custom_preconds
};
}
else
{
newTest = new TestCase
{
Name = issue.title,
GitHubId = issue.number,
Status = Status.ReadyForAutomation,
Message = issue.body,
IsIssue = true
};
}
if (issue.Column == "Done")
{
newTest.Status = Status.Finished;
newTest.FinishedOn = issue.closed_at ?? DateTime.MinValue;
newTest.StartedOn = issue.created_at ?? DateTime.MinValue;
newTest.Assignee = systemUser;
newTest.HistoryItems.Add(new TestCaseHistory
{
Message = "status updated automatically on import"
});
}
var steps = new List <TestStep>();
if (testRailTest != null)
{
foreach (var customStepsSeparated in testRailTest.custom_steps_separated)
{
steps.Add(new TestStep
{
Actual = customStepsSeparated.content,
Expected = customStepsSeparated.expected,
SortIndex = testRailTest.custom_steps_separated.IndexOf(customStepsSeparated)
});
}
}
newTest.TestSteps = steps;
newTest.HistoryItems.Add(new TestCaseHistory
{
Author = systemUser,
Message = "added test from Git Hub"
});
return(newTest);
}
