public void CalculateChangesReturnsGreatestChangeTypeFromMultipleResult(SemVerChangeType firstChangeType,
SemVerChangeType secondChangeType, SemVerChangeType expected, int resultCount)
{
var options = Model.UsingModule <ConfigurationModule>().Create <ComparerOptions>();
var oldTypes = Array.Empty <TestClassDefinition>();
var newTypes = Array.Empty <TestClassDefinition>();
var firstResult = new ComparisonResult(firstChangeType, null, null, Guid.NewGuid().ToString());
var secondResult = new ComparisonResult(secondChangeType, null, null, Guid.NewGuid().ToString());
var results = new List <ComparisonResult> {
firstResult, secondResult
};
var processor = Substitute.For <ITypeMatchProcessor>();
processor.CalculateChanges(oldTypes, newTypes, options).Returns(results);
var sut = new ChangeCalculator(processor, _logger);
var actual = sut.CalculateChanges(oldTypes, newTypes, options);
actual.ChangeType.Should().Be(expected);
actual.ComparisonResults.Should().HaveCount(resultCount);
if (firstChangeType != SemVerChangeType.None)
{
actual.ComparisonResults.Should().Contain(firstResult);
}
if (secondChangeType != SemVerChangeType.None)
{
actual.ComparisonResults.Should().Contain(secondResult);
}
}
public void CompareMatchDoesNotContinueEvaluationWhenModifierChangeIsBreaking()
{
var oldItem = new TestMethodDefinition();
var newItem = oldItem.JsonClone();
var match = new ItemMatch <IMethodDefinition>(oldItem, newItem);
var options = ComparerOptions.Default;
const SemVerChangeType changeType = SemVerChangeType.Breaking;
var message = Guid.NewGuid().ToString();
var result = new ComparisonResult(changeType, oldItem, newItem, message);
var results = new[] { result };
Service <IMethodModifiersComparer>()
.CompareMatch(
Arg.Is <ItemMatch <IModifiersElement <MethodModifiers> > >(x =>
x.OldItem == oldItem && x.NewItem == newItem),
options).Returns(results);
var actual = SUT.CompareMatch(match, options).ToList();
_output.WriteResults(actual);
actual.Should().HaveCount(1);
actual[0].Should().BeEquivalentTo(result);
Service <IGenericTypeElementComparer>().DidNotReceive()
.CompareMatch(Arg.Any <ItemMatch <IGenericTypeElement> >(), Arg.Any <ComparerOptions>());
Service <IParameterComparer>().DidNotReceive()
.CompareMatch(Arg.Any <ItemMatch <IParameterDefinition> >(), Arg.Any <ComparerOptions>());
}
public void CalculateChangesReturnsChangeTypeFromSingleResult(SemVerChangeType changeType, int expected)
{
var options = Model.UsingModule <ConfigurationModule>().Create <ComparerOptions>();
var oldTypes = Array.Empty <TestClassDefinition>();
var newTypes = Array.Empty <TestClassDefinition>();
var result = new ComparisonResult(changeType, null, null, Guid.NewGuid().ToString());
var results = new List <ComparisonResult> {
result
};
var processor = Substitute.For <ITypeMatchProcessor>();
processor.CalculateChanges(oldTypes, newTypes, options).Returns(results);
var sut = new ChangeCalculator(processor, _logger);
var actual = sut.CalculateChanges(oldTypes, newTypes, options);
actual.ChangeType.Should().Be(changeType);
actual.ComparisonResults.Should().HaveCount(expected);
if (expected > 0)
{
actual.ComparisonResults.Should().Contain(result);
}
}
public async Task EvaluatesChangeOfGenericTypeDefinitionsOnDeclaringType(
string oldClass,
string newClass,
string oldSignature,
string newSignature,
SemVerChangeType expected)
{
var oldCode = new List <CodeSource>
{
new(NoParameters
.Replace("public class MyClass", "public class " + oldClass)
.Replace("public string MyMethod()", "public string " + oldSignature))
};
var newCode = new List <CodeSource>
{
new(NoParameters
.Replace("public class MyClass", "public class " + newClass)
.Replace("public string MyMethod()", "public string " + newSignature))
};
var options = OptionsFactory.BuildOptions();
var result = await _calculator.CalculateChanges(oldCode, newCode, options, CancellationToken.None)
.ConfigureAwait(false);
result.ChangeType.Should().Be(expected);
}
public void StoreChange(
AccessModifiers oldModifiers,
AccessModifiers newModifiers,
SemVerChangeType changeType)
{
AddChange(oldModifiers, newModifiers, changeType);
}
public ComparisonResult(SemVerChangeType changeType, IItemDefinition?oldItem, IItemDefinition?newItem,
string message)
{
ChangeType = changeType;
OldItem = oldItem;
NewItem = newItem;
Message = message ?? throw new ArgumentNullException(nameof(message));
}
public void CalculateChangeReturnsExpectedValueForMemberDefinition(StructModifiers oldValue,
StructModifiers newValue,
SemVerChangeType expected)
{
var sut = new StructModifiersChangeTable();
var actual = sut.CalculateChange(oldValue, newValue);
actual.Should().Be(expected);
}
public void CalculateChangeReturnsExpectedValue(ClassModifiers oldValue,
ClassModifiers newValue,
SemVerChangeType expected)
{
var sut = new ClassModifiersChangeTable();
var actual = sut.CalculateChange(oldValue, newValue);
actual.Should().Be(expected);
}
// @formatter:on — enable formatter after this line
public void CalculateChangeReturnsExpectedValue(
PropertyModifiers oldModifiers,
PropertyModifiers newModifiers,
SemVerChangeType expected)
{
var sut = new PropertyModifiersChangeTable();
var actual = sut.CalculateChange(oldModifiers, newModifiers);
actual.Should().Be(expected);
}
public void PropertiesReturnParameterValues(SemVerChangeType changeType)
{
var message = Guid.NewGuid().ToString();
var newItem = Substitute.For <IPropertyDefinition>();
var oldItem = Substitute.For <IPropertyDefinition>();
var actual = new ComparisonResult(changeType, oldItem, newItem, message);
actual.Should().NotBeNull();
_output.WriteLine(actual.Message);
actual.ChangeType.Should().Be(changeType);
actual.OldItem.Should().Be(oldItem);
actual.NewItem.Should().Be(newItem);
actual.Message.Should().Be(message);
}
public async Task EvaluatesChangeOfModifiers(string oldModifiers, string newModifiers,
SemVerChangeType expected)
{
var oldCode = new List <CodeSource>
{
new(SingleField.Replace("string MyField", oldModifiers + " string MyField"))
};
var newCode = new List <CodeSource>
{
new(SingleField.Replace("string MyField", newModifiers + " string MyField"))
};
var options = OptionsFactory.BuildOptions();
var result = await _calculator.CalculateChanges(oldCode, newCode, options, CancellationToken.None)
.ConfigureAwait(false);
result.ChangeType.Should().Be(expected);
}
public void CompareMatchEvaluatesAttributeMatchesWhenBothItemsVisibleAndItemMatchIsNotBreaking(
bool firstItemVisible,
bool secondItemVisible, SemVerChangeType changeType, bool attributesEvaluated)
{
var firstItem = Substitute.For <IClassDefinition>();
var firstItemAttributes = Model.UsingModule <ConfigurationModule>().Create <List <TestAttributeDefinition> >();
var secondItem = Substitute.For <IClassDefinition>();
var secondItemAttributes = Model.UsingModule <ConfigurationModule>().Create <List <TestAttributeDefinition> >();
var itemResult = new ComparisonResult(changeType, firstItem, secondItem, Guid.NewGuid().ToString());
var attributeResult = new ComparisonResult(changeType, firstItemAttributes.Last(),
secondItemAttributes.Last(), Guid.NewGuid().ToString());
var attributeResults = new List <ComparisonResult> {
attributeResult
};
var match = new ItemMatch <IClassDefinition>(firstItem, secondItem);
var options = ComparerOptions.Default;
var attributeProcessor = Substitute.For <IAttributeMatchProcessor>();
firstItem.IsVisible.Returns(firstItemVisible);
secondItem.IsVisible.Returns(secondItemVisible);
attributeProcessor.CalculateChanges(firstItem.Attributes, secondItem.Attributes, options)
.Returns(attributeResults);
var sut = new Wrapper <IClassDefinition>(attributeProcessor, itemResult);
var actual = sut.CompareMatch(match, options).ToList();
_output.WriteResults(actual);
if (attributesEvaluated)
{
attributeProcessor.Received().CalculateChanges(firstItem.Attributes, secondItem.Attributes, options);
actual.Should().Contain(attributeResult);
}
else
{
attributeProcessor.DidNotReceive().CalculateChanges(Arg.Any <IEnumerable <IAttributeDefinition> >(),
Arg.Any <IEnumerable <IAttributeDefinition> >(), Arg.Any <ComparerOptions>());
}
}
public void OverallChangeTypeReturnsHighestResult(SemVerChangeType firstType,
SemVerChangeType secondType, SemVerChangeType expected)
{
var firstItem = new TestPropertyDefinition();
var secondItem = new TestPropertyDefinition();
var match = new ItemMatch <IPropertyDefinition>(firstItem, secondItem);
var firstResult = new ComparisonResult(firstType, match.OldItem, match.NewItem, Guid.NewGuid().ToString());
var secondResult =
new ComparisonResult(secondType, match.OldItem, match.NewItem, Guid.NewGuid().ToString());
var sut = new ChangeResultAggregator();
sut.AddResult(firstResult);
sut.AddResult(secondResult);
var actual = sut.OverallChangeType;
actual.Should().Be(expected);
}
public async Task EvaluatesAddingSetAccessorWithAccessModifiers(
string modifiers,
SemVerChangeType expected)
{
var oldCode = new List <CodeSource>
{
new(SingleProperty.Replace("set;", string.Empty))
};
var newCode = new List <CodeSource>
{
new(SingleProperty.Replace("set;", modifiers + " set;"))
};
var options = OptionsFactory.BuildOptions();
var result = await _calculator.CalculateChanges(oldCode, newCode, options, CancellationToken.None)
.ConfigureAwait(false);
result.ChangeType.Should().Be(expected);
}
public async Task EvaluatesChangeOfReturnType(
string oldValue,
string newValue,
SemVerChangeType expected)
{
var oldCode = new List <CodeSource>
{
new(NoParameters.Replace("public string MyMethod()", "public " + oldValue + "()"))
};
var newCode = new List <CodeSource>
{
new(NoParameters.Replace("public string MyMethod()", "public " + newValue + "()"))
};
var options = OptionsFactory.BuildOptions();
var result = await _calculator.CalculateChanges(oldCode, newCode, options, CancellationToken.None)
.ConfigureAwait(false);
result.ChangeType.Should().Be(expected);
}
public async Task EvaluatesChangesToAttribute(string updatedValue,
AttributeCompareOption compareOption,
SemVerChangeType expected)
{
var oldCode = new List <CodeSource>
{
new(SingleProperty)
};
var newCode = new List <CodeSource>
{
new(SingleProperty.Replace("[PropertyAttribute(344, true, myName: \"on the property\")]",
updatedValue))
};
var options = OptionsFactory.BuildOptions().Set(x => x.CompareAttributes = compareOption);
var result = await _calculator.CalculateChanges(oldCode, newCode, options, CancellationToken.None)
.ConfigureAwait(false);
result.ChangeType.Should().Be(expected);
}
public static void AddElementChangedResult <T>(this IChangeResultAggregator aggregator,
SemVerChangeType changeType,
ItemMatch <T> match,
IMessageFormatter messageFormatter,
FormatArguments arguments)
where T : IItemDefinition
{
aggregator = aggregator ?? throw new ArgumentNullException(nameof(aggregator));
match = match ?? throw new ArgumentNullException(nameof(match));
messageFormatter = messageFormatter ?? throw new ArgumentNullException(nameof(messageFormatter));
arguments = arguments ?? throw new ArgumentNullException(nameof(arguments));
var message = messageFormatter.FormatItemChangedMessage(match, arguments);
var result = new ComparisonResult(
changeType,
match.OldItem, match.NewItem,
message);
aggregator.AddResult(result);
}
public async Task ReturnsResultBasedOnAttributesOnClass(string updatedValue,
AttributeCompareOption compareOption,
SemVerChangeType expected)
{
var oldCode = new List <CodeSource>
{
new(TypeDefinitionCode.ClassWithAttribute)
};
var newCode = new List <CodeSource>
{
new(
TypeDefinitionCode.ClassWithAttribute.Replace("[JsonPropertyName(\"item\")]", updatedValue))
};
var options = OptionsFactory.BuildOptions().Set(x => x.CompareAttributes = compareOption);
var result = await _calculator.CalculateChanges(oldCode, newCode, options, CancellationToken.None)
.ConfigureAwait(false);
result.ChangeType.Should().Be(expected);
}
public void CalculateChangesReturnsResultFromComparer(SemVerChangeType changeType, bool expected)
{
var oldItem = new TestClassDefinition();
var oldItems = new List <IClassDefinition>
{
oldItem
};
var newItem = new TestClassDefinition();
var newItems = new List <IClassDefinition>
{
newItem
};
var match = new ItemMatch <IClassDefinition>(oldItem, newItem);
var matches = new List <ItemMatch <IClassDefinition> > {
match
};
var options = ComparerOptions.Default;
var matchResults = new MatchResults <IClassDefinition>(matches, Array.Empty <IClassDefinition>(),
Array.Empty <IClassDefinition>());
var message = Guid.NewGuid().ToString();
var result = new ComparisonResult(changeType, oldItem, newItem, message);
var results = new List <ComparisonResult> {
result
};
Service <IEvaluator <IClassDefinition> >().FindMatches(oldItems, newItems).Returns(matchResults);
Service <IItemComparer <IClassDefinition> >().CompareMatch(match, options).Returns(results);
var actual = SUT.CalculateChanges(oldItems, newItems, options);
if (expected)
{
actual.Should().BeEquivalentTo(results);
}
else
{
actual.Should().BeEmpty();
}
}
public void CalculateChangesReturnsResultsForAddedElementDefinitions(MethodModifiers modifiers,
SemVerChangeType expected)
{
var oldItems = Array.Empty <IMethodDefinition>();
var newItem = new TestMethodDefinition().Set(x =>
{
x.IsVisible = true;
x.Modifiers = modifiers;
});
var newItems = new List <IMethodDefinition>
{
newItem
};
var options = ComparerOptions.Default;
var matchResults = new MatchResults <IMethodDefinition>(Array.Empty <IMethodDefinition>(),
newItems);
Service <IMethodEvaluator>().FindMatches(oldItems, newItems).Returns(matchResults);
var actual = SUT.CalculateChanges(oldItems, newItems, options).ToList();
actual.Should().HaveCount(1);
actual[0].ChangeType.Should().Be(expected);
}
public void CompareMatchReturnsResultForRemovedModifiers()
{
var options = new ComparerOptions();
var fullName = Guid.NewGuid().ToString();
const SemVerChangeType expected = SemVerChangeType.Breaking;
var changeTable = Substitute.For <IAccessModifiersChangeTable>();
var oldElement = Substitute.For <IPropertyDefinition>();
var newElement = Substitute.For <IPropertyDefinition>();
oldElement.AccessModifiers.Returns(AccessModifiers.ProtectedInternal);
oldElement.DeclaredModifiers.Returns("protected internal sealed override");
newElement.FullName.Returns(fullName);
newElement.AccessModifiers.Returns(AccessModifiers.Private);
newElement.DeclaredModifiers.Returns("sealed override");
var match = new ItemMatch <IElementDefinition>(oldElement, newElement);
changeTable.CalculateChange(oldElement.AccessModifiers, newElement.AccessModifiers)
.Returns(expected);
var sut = new Wrapper(changeTable);
var actual = sut.RunCompareMatch(match, oldElement.AccessModifiers, newElement.AccessModifiers, options)
.ToList();
_output.WriteResults(actual);
actual.Should().NotBeEmpty();
var result = actual.Single();
result.ChangeType.Should().Be(expected);
result.OldItem.Should().Be(oldElement);
result.NewItem.Should().Be(newElement);
}
public async Task EvaluatesChangeOfMethodAttribute(
string oldAttribute,
string newAttribute,
AttributeCompareOption compareOptions,
SemVerChangeType expected)
{
var oldCode = new List <CodeSource>
{
new(NoParameters.Replace("public string MyMethod", oldAttribute + " public string MyMethod"))
};
var newCode = new List <CodeSource>
{
new(NoParameters.Replace("public string MyMethod", newAttribute + " public string MyMethod"))
};
var options = OptionsFactory.BuildOptions();
options.CompareAttributes = compareOptions;
var result = await _calculator.CalculateChanges(oldCode, newCode, options, CancellationToken.None)
.ConfigureAwait(false);
result.ChangeType.Should().Be(expected);
}
public void CompareMatchReturnsExpectedResultBasedOnFieldModifiers(FieldModifiers oldModifiers,
FieldModifiers newModifiers,
SemVerChangeType expected)
{
