public void NullNotEqual()
{
UserNeed a = new UserNeed(0, "test");
bool isEqual = a.Equals(null);
Assert.That(isEqual, Is.False);
}
public void AreEqual()
{
UserNeed a = new UserNeed(0, "test");
UserNeed b = new UserNeed(0, "test");
bool isEqual = a.Equals(b);
Assert.That(isEqual, Is.True);
}
public void SameReferenceIsEqual()
{
UserNeed a = new UserNeed(0, "test");
// ReSharper disable once EqualExpressionComparison
bool isEqual = a.Equals(a);
Assert.That(isEqual, Is.True);
}
public void OtherTypeNotEqual()
{
UserNeed a = new UserNeed(0, "test");
// ReSharper disable once SuspiciousTypeConversion.Global
bool isEqual = a.Equals(0);
Assert.That(isEqual, Is.False);
}
public void HashCodesAreDifferent()
{
UserNeed a = new UserNeed(0, "test");
UserNeed b = new UserNeed(0, "test2");
int hashCodeA = a.GetHashCode();
int hashCodeB = b.GetHashCode();
Assert.That(hashCodeA, Is.Not.EqualTo(hashCodeB));
}
public static string UserNeed(this IUrlHelper urlHelper, UserNeed userNeed)
{
var url = $"/requirements/{userNeed.NumberFullyQualified}";
if (urlHelper == null)
{
return(url);
}
return(urlHelper.Content($"~{url}"));
}
public void GeneratesTraceabilityCorrectly()
{
Specification specification = new Specification(0, "");
Requirement requirement = new Requirement(0, "");
requirement.AddSpecification(specification);
UserNeed userNeed = new UserNeed(0, "");
userNeed.AddRequirement(requirement);
string actualTraceabilityText = TraceabilityGenerator.Generate(new[] { userNeed });
string expectedTraceabilityText = $"UN-000{Environment.NewLine}\tREQ-000{Environment.NewLine}\t\tSPEC-000";
Assert.That(actualTraceabilityText, Is.EqualTo(expectedTraceabilityText));
}
public static List <UserNeed> CreateUnOrderUserNeeds()
{
Specification specification = new Specification(1, "First spec");
Specification secondSpecification = new Specification(2, "Second spec");
Requirement requirement = new Requirement(1, "First requirement");
requirement.AddSpecification(secondSpecification);
requirement.AddSpecification(specification);
Requirement secondRequirement = new Requirement(2, "Second requirement");
UserNeed userNeed = new UserNeed(1, "First user need");
userNeed.AddRequirement(secondRequirement);
userNeed.AddRequirement(requirement);
return(new[] { userNeed }.ToList());
}
public void LabelIsCorrect()
{
UserNeed a = new UserNeed(0, "test");
Assert.That(a.Label, Is.EqualTo("UN-000"));
}
public UserNeed ParseUserNeed(string content)
{
var yaml = _yamlParser.ParseYaml(content);
if (yaml.Yaml == null)
{
yaml = new YamlParseResult(Newtonsoft.Json.JsonConvert.DeserializeObject("{}"), yaml.Markdown);
}
StringBuilder userNeed = new StringBuilder();
StringBuilder validationMethod = new StringBuilder();
StringBuilder current = null;
using (var stringReader = new StringReader(yaml.Markdown))
{
string line;
while ((line = stringReader.ReadLine()) != null)
{
if (line == "# User Need")
{
current = userNeed;
}
else if (line == "# Validation Method")
{
current = validationMethod;
}
else
{
if (current == null)
{
throw new DocGenException($"Content '{line}' should be within a user need or validation method");
}
current.AppendLine(line);
}
}
}
var result = new UserNeed();
string number = yaml.Yaml?.Number;
if (string.IsNullOrEmpty(number))
{
throw new DocGenException("You must provider a number");
}
if (!TryParseVersion(number, out Version version))
{
throw new DocGenException($"Invalid number format {number}");
}
result.Number = version;
result.Title = yaml.Yaml?.Title;
result.Category = yaml.Yaml?.Category;
result.Description = userNeed.ToString();
result.ValidationMethod = validationMethod.ToString();
result.Description = result.Description.TrimEnd(Environment.NewLine.ToCharArray());
result.ValidationMethod = result.ValidationMethod.TrimEnd(Environment.NewLine.ToCharArray());
if (string.IsNullOrEmpty(result.Title))
{
throw new DocGenException("Title is required");
}
if (string.IsNullOrEmpty(result.Category))
{
throw new DocGenException("Category is required");
}
if (string.IsNullOrEmpty(result.Description))
{
throw new DocGenException("You must provide description");
}
if (string.IsNullOrEmpty(result.ValidationMethod))
{
throw new DocGenException("You must provide a validation method");
}
return(result);
}
private async Task <ProductRequirement> BuildRequirementsFromDirectoryProductRequirement(string directory, UserNeed userNeed)
{
var index = Path.Combine(directory, "index.md");
var directoryName = Path.GetFileName(directory.TrimEnd(Path.DirectorySeparatorChar));
if (!File.Exists(index))
{
throw new DocGenException($"File 'index.md' doesn't exist for product requirement {directoryName}");
}
ProductRequirement productRequirement;
try
{
productRequirement = _requirementsParser.ParseProductRequirement(File.ReadAllText(index));
}
catch (Exception ex)
{
throw new DocGenException($"Error parsing index.md for product requirement {directoryName}: {ex.Message}");
}
productRequirement.UserNeed = userNeed;
productRequirement.Key = directoryName;
foreach (var dir in Directory.GetDirectories(directory).OrderBy(x => x))
{
var childDirName = Path.GetFileName(dir.TrimEnd(Path.DirectorySeparatorChar));
if (childDirName.Equals("tests", StringComparison.InvariantCultureIgnoreCase))
{
// process tests
foreach (var file in Directory.GetFiles(dir, "*.md").OrderBy(x => x))
{
var testCase = _requirementsParser.ParseTestCase(File.ReadAllText(file));
testCase.ProductRequirement = productRequirement;
testCase.Key = Path.GetFileNameWithoutExtension(file);
productRequirement.TestCases.Add(testCase);
}
}
else
{
// process software specification
productRequirement.SoftwareSpecifications.Add(await BuildRequirementsFromDirectorySoftwareSpecification(dir, productRequirement));
}
}
var duplicateNumbers = productRequirement.SoftwareSpecifications.GroupBy(x => x.Number)
.Where(x => x.Count() > 1)
.Select(x => x.Key)
.ToList();
if (duplicateNumbers.Any())
{
var first = duplicateNumbers.First();
var duplicateUserNeeds = productRequirement.SoftwareSpecifications.Where(x => x.Number == first).ToList();
throw new DocGenException($"Duplicate number '{first}' for software specifications '{string.Join(",", duplicateUserNeeds.Select(x => x.Key).ToArray())}'");
}
AssertUniqueNumbersForTestCases(productRequirement.TestCases);
productRequirement.SoftwareSpecifications = productRequirement.SoftwareSpecifications.OrderBy(x => x.Number).ToList();
productRequirement.TestCases = productRequirement.TestCases.OrderBy(x => x.Number).ToList();
return(productRequirement);
}
