public void Test_Title_PropertyChange_Propagates()
{
// Arrange.
var testCase = new Mock <ITestCase>();
var vm = new TestCaseViewModel(testCase.Object, automationService.Object);
// Act/Assert.
AssertThat.PropertyChanged(vm,
p => p.Title,
() => testCase.Raise(tc => tc.PropertyChanged += null, new PropertyChangedEventArgs("Title")));
}
public void Test_Implementation_PropertyChange_Propagates_To_CanRemoveAutomation()
{
// Arrange.
var testCase = new Mock <ITestCase>();
var vm = new TestCaseViewModel(testCase.Object, automationService.Object);
// Act/Assert.
AssertThat.PropertyChanged(vm,
p => p.CanRemoveAutomation,
() => testCase.Raise(tc => tc.PropertyChanged += null, new PropertyChangedEventArgs("Implementation")));
}
public void Test_Title()
{
// Arrange.
var testCase = Mock.Of <ITestCase>(tc => tc.Title == "A test case");
var vm = new TestCaseViewModel(testCase, automationService.Object);
// Act.
var title = vm.Title;
// Assert.
Assert.Equal("A test case", title);
}
public void Test_Id()
{
// Arrange.
var testCase = Mock.Of <ITestCase>(tc => tc.Id == 112);
var vm = new TestCaseViewModel(testCase, automationService.Object);
// Act.
var id = vm.Id;
// Assert.
Assert.Equal(112, id);
}
// GET: TestCase/Edit/5
public async Task <IActionResult> Edit(string id, string TesterName, DateTime?FromPlannedDate, DateTime?ToPlannedDate, string SearchTestStatus, DateTime?FromUpdatedDate, DateTime?ToUpdatedDate)
{
if (id == null)
{
return(NotFound());
}
var testCase = await _context.TestCase.FindAsync(id);
if (testCase == null)
{
return(NotFound());
}
var testVariant = await(from variant in _context.TestVariant.Where(i => i.ID.Equals(testCase.TestVariantID, StringComparison.OrdinalIgnoreCase))
join scenario in _context.TestScenario
on variant.ScenarioID equals scenario.ID
select new { ProjectID = scenario.ProjectID, ScenarioID = scenario.ID }).FirstOrDefaultAsync();
if (testVariant == null)
{
return(NotFound());
}
if (!AuthorizeData(id))
{
return(Unauthorized());
}
if (!CanWrite(User.Identity.Name, testVariant.ProjectID))
{
return(Forbid());
}
var attachments = await _context.TestCaseAttachment.Where(i => i.TestCaseID.Equals(id, StringComparison.OrdinalIgnoreCase)).ToListAsync();
var testCaseViewModel = new TestCaseViewModel()
{
ProjectID = testVariant.ProjectID,
ScenarioID = testVariant.ScenarioID,
TesterName = TesterName,
FromPlannedDate = FromPlannedDate,
ToPlannedDate = ToPlannedDate,
SearchTestStatus = SearchTestStatus,
FromUpdatedDate = FromUpdatedDate,
ToUpdatedDate = ToUpdatedDate,
TestCase = testCase,
TestCaseAttachments = attachments
};
return(View(testCaseViewModel));
}
public void Test_AssociatedAutomation_Without_Implementation()
{
// Arrange.
var testCase = Mock.Of <ITestCase>(tc =>
tc.IsAutomated == false);
var vm = new TestCaseViewModel(testCase, automationService.Object);
// Act.
var implementation = vm.AssociatedAutomation;
// Assert.
Assert.Equal(string.Empty, implementation);
}
//to make action asynchronous - wrap the return type with async Task <>
public async Task <IActionResult> Post([FromBody] TestCaseViewModel testcase)
{
if (ModelState.IsValid)
{
var newTestCase = Mapper.Map <TestCase>(testcase);
_repository.AddTestCase(newTestCase);
if (await _repository.SaveChangesAsync())
{
return(Created($"/api/testcases/{testcase.Name}", Mapper.Map <TestCaseViewModel>(newTestCase)));
}
}
return(BadRequest("Failed to save test case."));
}
public ActionResult GetResult(string testCase, string resultName = null)
{
var tc = this.GetTestCase(testCase);
if (!tc.Executions.Any())
{
return(RedirectToAction(nameof(GetDefinition), new { testCase = testCase }));
}
var model = new TestCaseViewModel(tc);
model.SelectResult(resultName);
return(View("Result", model));
}
public void Test_AssociatedAutomation_With_Implementation()
{
// Arrange.
var testCase = Mock.Of <ITestCase>(tc =>
tc.IsAutomated &&
tc.Implementation == Mock.Of <ITestImplementation>(ti =>
ti.DisplayText == "test123"));
var vm = new TestCaseViewModel(testCase, automationService.Object);
// Act.
var implementation = vm.AssociatedAutomation;
// Assert.
Assert.Equal("test123", implementation);
}
private void EditTestCaseButton_Click(object sender, RoutedEventArgs e)
{
Button b = sender as Button;
if (b == null)
{
return;
}
TestCaseViewModel tc = b.Tag as TestCaseViewModel;
if (tc == null)
{
return;
}
EditTestCaseView.Show(tc);
}
// GET: TestCase/Create
public async Task <IActionResult> Create(string id)
{
if (!string.IsNullOrEmpty(id))
{
var clonedTestCase = await(from tc in _context.TestCase.Where(i => i.ID.Equals(id, StringComparison.OrdinalIgnoreCase))
join variant in _context.TestVariant
on tc.TestVariantID equals variant.ID
join scenario in _context.TestScenario
on variant.ScenarioID equals scenario.ID
select new TestCaseViewModel()
{
ProjectID = scenario.ProjectID, ScenarioID = scenario.ID, TestCase = tc
}).FirstOrDefaultAsync();
if (clonedTestCase == null)
{
return(NotFound());
}
clonedTestCase.TestCase.SetCreator(User.Identity.Name);
return(View(clonedTestCase));
}
TestCaseViewModel newCase = new TestCaseViewModel()
{
ProjectID = string.Empty,
ScenarioID = string.Empty,
TestCase = new TestCase()
{
TesterName = "?",
PlannedDate = new DateTime(2000, 1, 1),
TestStatus = TestStatuses.Open
}
};
newCase.TestCase.SetCreator(User.Identity.Name);
return(View(newCase));
}
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 <IActionResult> Import([Bind("ProjectID, DataFile")] ImportTestCaseViewModel importModel)
{
if (ModelState.IsValid)
{
if (!CanWrite(User.Identity.Name, importModel.ProjectID))
{
return(Forbid());
}
using (var stream = importModel.DataFile.OpenReadStream())
{
using (var excelPackage = new ExcelPackage(stream))
{
var workSheet = excelPackage.Workbook.Worksheets["TestCase"];
if (workSheet == null)
{
ModelState.AddModelError("", "Sheet 'TestCase' is not found.");
return(View(importModel));
}
int rowCount = workSheet.Dimension.Rows + 1;
List <TestCaseViewModel> inputTestCaseList = new List <TestCaseViewModel>();
for (int i = 2; i < rowCount; i++)
{
var inputTestCase = new TestCaseViewModel()
{
Index = i,
ScenarioID = workSheet.Cells[i, 10].GetValue <string>(),
VariantName = workSheet.Cells[i, 1].GetValue <string>(),
TestCase = new TestCase()
{
ID = workSheet.Cells[i, 11].GetValue <string>(),
TestCaseName = workSheet.Cells[i, 2].GetValue <string>(),
TestCaseSteps = workSheet.Cells[i, 3].GetValue <string>(),
ExpectedResult = workSheet.Cells[i, 4].GetValue <string>(),
ActualResult = workSheet.Cells[i, 5].GetValue <string>(),
TestStatus = workSheet.Cells[i, 6].GetValue <string>(),
Note = workSheet.Cells[i, 7].GetValue <string>(),
TesterName = workSheet.Cells[i, 8].GetValue <string>(),
PlannedDate = workSheet.Cells[i, 9].GetValue <DateTime>().Date
}
};
inputTestCaseList.Add(inputTestCase);
}
int errorCount = 0;
var newVariantList = new List <TestVariant>();
var newTestCaseList = new List <TestCase>();
var updatedTestCaseList = new List <TestCase>();
var inputScenarioIDList = inputTestCaseList.Select(i => new { i.ScenarioID }).Distinct().ToList();
var existingScenarioList = await(from s in _context.TestScenario.Where(i => i.ProjectID.Equals(importModel.ProjectID, StringComparison.OrdinalIgnoreCase))
join iS in inputScenarioIDList
on s.ID equals iS.ScenarioID
select s).ToListAsync();
var inputVariantIDList = inputTestCaseList.Select(i => new { i.ScenarioID, i.VariantName }).Distinct().ToList();
var existingVariantList = await(from v in _context.TestVariant
join iS in existingScenarioList
on v.ScenarioID equals iS.ID
join iv in inputVariantIDList
on new { v.ScenarioID, v.VariantName } equals new { iv.ScenarioID, iv.VariantName }
select v).ToListAsync();
var inputTestCaseIDList = inputTestCaseList.Select(i => new { i.TestCase.ID }).Distinct().ToList();
var existingTestCaseList = await(from c in _context.TestCase
join ic in inputTestCaseIDList
on c.ID equals ic.ID
select c).ToListAsync();
foreach (var inputTestCase in inputTestCaseList)
{
string errorMessage = string.Empty;
if (string.IsNullOrEmpty(inputTestCase.VariantName))
{
errorCount++;
errorMessage += "TestVariant is required. ";
}
if (string.IsNullOrEmpty(inputTestCase.TestCase.TestCaseName))
{
errorCount++;
errorMessage += "TestCaseName is required. ";
}
if (string.IsNullOrEmpty(inputTestCase.TestCase.TestCaseSteps))
{
errorCount++;
errorMessage += "TestCaseSteps is required. ";
}
if (string.IsNullOrEmpty(inputTestCase.TestCase.ExpectedResult))
{
errorCount++;
errorMessage += "ExpectedResult is required. ";
}
if (string.IsNullOrEmpty(inputTestCase.TestCase.TesterName))
{
errorCount++;
errorMessage += "TesterName is required. ";
}
var minDate = new DateTime(2000, 1, 1);
if (inputTestCase.TestCase.PlannedDate < minDate)
{
errorCount++;
errorMessage += $"PlannedDate must be a Date value >= {minDate.ToString("yyyy/MM/dd")}. ";
}
if (!TestStatuses.GetTestStatusesList().Contains(inputTestCase.TestCase.TestStatus))
{
errorCount++;
errorMessage += $"TestStatus must be {TestStatuses.GetTestStatusesString()}. ";
}
if (string.IsNullOrEmpty(inputTestCase.ScenarioID))
{
errorCount++;
errorMessage += "ScenarioID is required. ";
}
else
{
if (!existingScenarioList.Any(c => c.ID.Equals(inputTestCase.ScenarioID, StringComparison.OrdinalIgnoreCase)))
{
errorCount++;
errorMessage += "ScenarioID is invalid. ";
}
}
TestCase updatedTestCase = null;
if (!string.IsNullOrEmpty(inputTestCase.TestCase.ID))
{
updatedTestCase = existingTestCaseList.FirstOrDefault(c => c.ID.Equals(inputTestCase.TestCase.ID, StringComparison.OrdinalIgnoreCase));
if (updatedTestCase == null)
{
errorCount++;
errorMessage += "TestCaseID is invalid. ";
}
}
if (!string.IsNullOrEmpty(errorMessage))
{
workSheet.Cells[inputTestCase.Index, 12].Value = errorMessage;
}
else
{
var variant = existingVariantList.FirstOrDefault(v => v.VariantName.Equals(inputTestCase.VariantName, StringComparison.OrdinalIgnoreCase) &&
v.ScenarioID.Equals(inputTestCase.ScenarioID, StringComparison.OrdinalIgnoreCase));
if (variant == null)
{
variant = newVariantList.FirstOrDefault(v => v.VariantName.Equals(inputTestCase.VariantName, StringComparison.OrdinalIgnoreCase) &&
v.ScenarioID.Equals(inputTestCase.ScenarioID, StringComparison.OrdinalIgnoreCase));
if (variant == null)
{
variant = new TestVariant()
{
ScenarioID = inputTestCase.ScenarioID,
VariantName = inputTestCase.VariantName
};
variant.SetCreator(User.Identity.Name);
newVariantList.Add(variant);
}
}
if (updatedTestCase != null)
{
updatedTestCase.TestVariantID = variant.ID;
updatedTestCase.TestCaseName = inputTestCase.TestCase.TestCaseName;
updatedTestCase.TestCaseSteps = inputTestCase.TestCase.TestCaseSteps;
updatedTestCase.ExpectedResult = inputTestCase.TestCase.ExpectedResult;
updatedTestCase.ActualResult = inputTestCase.TestCase.ActualResult;
updatedTestCase.TestStatus = inputTestCase.TestCase.TestStatus;
updatedTestCase.Note = inputTestCase.TestCase.Note;
updatedTestCase.TesterName = inputTestCase.TestCase.TesterName;
updatedTestCase.PlannedDate = inputTestCase.TestCase.PlannedDate;
updatedTestCase.SetUpdater(User.Identity.Name);
updatedTestCaseList.Add(updatedTestCase);
}
else
{
var newTestCase = new TestCase()
{
TestVariantID = variant.ID,
TestCaseName = inputTestCase.TestCase.TestCaseName,
TestCaseSteps = inputTestCase.TestCase.TestCaseSteps,
ExpectedResult = inputTestCase.TestCase.ExpectedResult,
ActualResult = inputTestCase.TestCase.ActualResult,
TestStatus = inputTestCase.TestCase.TestStatus,
Note = inputTestCase.TestCase.Note,
TesterName = inputTestCase.TestCase.TesterName,
PlannedDate = inputTestCase.TestCase.PlannedDate
};
newTestCase.SetCreator(User.Identity.Name);
newTestCaseList.Add(newTestCase);
}
}
}
if (errorCount > 0)
{
return(File(excelPackage.GetAsByteArray(), importModel.DataFile.ContentType, importModel.DataFile.FileName));
}
await _context.AddRangeAsync(newVariantList);
_context.UpdateRange(updatedTestCaseList);
await _context.AddRangeAsync(newTestCaseList);
await _context.SaveChangesAsync();
}
}
return(RedirectToAction(nameof(Index), new { ProjectID = importModel.ProjectID }));
}
return(View(importModel));
}
public async Task <IActionResult> Edit(string id, string ProjectID, string ScenarioID, string TesterName, DateTime?FromPlannedDate, DateTime?ToPlannedDate, string SearchTestStatus, DateTime?FromUpdatedDate, DateTime?ToUpdatedDate, List <IFormFile> files,
List <TestCaseAttachment> TestCaseAttachments,
[Bind("TestCaseName,TestVariantID,TestCaseSteps,ExpectedResult,ActualResult,TesterName,PlannedDate,TestStatus,Note,ID,CreatedBy,CreatedDateTime,UpdatedBy,UpdatedDateTime,IsActive")] TestCase testCase)
{
if (id != testCase.ID)
{
return(NotFound());
}
if (!AuthorizeData(id))
{
return(Unauthorized());
}
if (!CanWrite(User.Identity.Name, ProjectID))
{
return(Forbid());
}
DateTime minDate = new DateTime(2000, 1, 1);
if (testCase?.PlannedDate < minDate)
{
ModelState.AddModelError("TestCase.PlannedDate", $"PlannedDate must be >= {minDate.ToString("yyyy/MM/dd")}");
}
if (ModelState.IsValid)
{
try
{
testCase.SetUpdater(User.Identity.Name);
_context.Update(testCase);
if (files.Count > 0)
{
List <TestCaseAttachment> attachments = new List <TestCaseAttachment>();
string subFolder = Path.Combine("datafile/testCaseAttachment/", ProjectID, ScenarioID, id);
string fullFolder = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", subFolder);
if (!Directory.Exists(fullFolder))
{
Directory.CreateDirectory(fullFolder);
}
foreach (var formFile in files)
{
if (formFile.Length > 0)
{
string filename = Guid.NewGuid().ToString() + Path.GetExtension(formFile.FileName);
string fullPath = Path.Combine(fullFolder, filename);
string filePath = Path.Combine(subFolder, filename);
using (var stream = new FileStream(fullPath, FileMode.Create))
{
await formFile.CopyToAsync(stream);
var attachment = new TestCaseAttachment()
{
TestCaseID = testCase.ID,
OriginalFileName = formFile.FileName,
FullFileName = filePath,
ContentType = formFile.ContentType
};
attachment.SetCreator(User.Identity.Name);
attachments.Add(attachment);
}
}
}
_context.TestCaseAttachment.AddRange(attachments);
}
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TestCaseExists(testCase.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index), new
{
ProjectID = ProjectID,
ScenarioID = ScenarioID,
VariantID = testCase.TestVariantID,
TesterName = TesterName,
FromPlannedDate = FromPlannedDate,
ToPlannedDate = ToPlannedDate,
SearchTestStatus = SearchTestStatus,
FromUpdatedDate = FromUpdatedDate,
ToUpdatedDate = ToUpdatedDate
}));
}
var testCaseViewModel = new TestCaseViewModel()
{
ProjectID = ProjectID,
ScenarioID = ScenarioID,
TesterName = TesterName,
FromPlannedDate = FromPlannedDate,
ToPlannedDate = ToPlannedDate,
SearchTestStatus = SearchTestStatus,
FromUpdatedDate = FromUpdatedDate,
ToUpdatedDate = ToUpdatedDate,
TestCase = testCase,
TestCaseAttachments = TestCaseAttachments
};
return(View(testCaseViewModel));
}
