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) {