public async Task CalculateChangesWithCodeSourceReturnsResultsForMultipleDefinitions() { var oldCode = new List <CodeSource> { new(TestNode.MultipleClasses) }; var newCode = new List <CodeSource> { new(TestNode.MultipleInterfaces) }; var options = new ComparerOptions(); var expected = new ChangeCalculatorResult(); var calculator = Substitute.For <IChangeCalculator>(); calculator.CalculateChanges( Arg.Is <IEnumerable <ITypeDefinition> >(x => x.OfType <ClassDefinition>().Count() == 2), Arg.Is <IEnumerable <ITypeDefinition> >(x => x.OfType <InterfaceDefinition>().Count() == 2), options).Returns(expected); var actual = await calculator.CalculateChanges(oldCode, newCode, options, CancellationToken.None) .ConfigureAwait(false); actual.Should().Be(expected); }
public async Task CalculateChangesWithCodeSourceReturnsResultsUsingProvidedOptions() { var oldCode = new List <CodeSource> { new(TestNode.ClassProperty) }; var newCode = new List <CodeSource> { new(TestNode.Field) }; var options = new ComparerOptions(); var expected = new ChangeCalculatorResult(); var calculator = Substitute.For <IChangeCalculator>(); calculator.CalculateChanges( Arg.Is <IEnumerable <ITypeDefinition> >(x => x.OfType <ClassDefinition>().First().Fields.Count == 0), Arg.Is <IEnumerable <ITypeDefinition> >(x => x.OfType <ClassDefinition>().First().Fields.Count == 1), options).Returns(expected); var actual = await calculator.CalculateChanges(oldCode, newCode, options, CancellationToken.None) .ConfigureAwait(false); actual.Should().Be(expected); }
public async Task CalculateChangesWithSyntaxNodesReturnsResultsForMultipleDefinitions() { var oldNode = await TestNode.Parse(TestNode.MultipleClasses).ConfigureAwait(false); var oldNodes = new List <SyntaxNode> { oldNode }; var newNode = await TestNode.Parse(TestNode.MultipleStructs).ConfigureAwait(false); var newNodes = new List <SyntaxNode> { newNode }; var options = new ComparerOptions(); var expected = new ChangeCalculatorResult(); var calculator = Substitute.For <IChangeCalculator>(); calculator.CalculateChanges( Arg.Is <IEnumerable <ITypeDefinition> >(x => x.OfType <ClassDefinition>().Count() == 2), Arg.Is <IEnumerable <ITypeDefinition> >(x => x.OfType <StructDefinition>().Count() == 2), options).Returns(expected); var actual = calculator.CalculateChanges(oldNodes, newNodes, options); actual.Should().Be(expected); }
public async Task CalculateChangesWithSyntaxNodesReturnsResultsUsingProvidedOptions() { var oldNode = await TestNode.Parse(TestNode.ClassProperty).ConfigureAwait(false); var oldNodes = new List <SyntaxNode> { oldNode }; var newNode = await TestNode.Parse(TestNode.Field).ConfigureAwait(false); var newNodes = new List <SyntaxNode> { newNode }; var options = new ComparerOptions(); var expected = new ChangeCalculatorResult(); var calculator = Substitute.For <IChangeCalculator>(); calculator.CalculateChanges( Arg.Is <IEnumerable <ITypeDefinition> >(x => x.OfType <ClassDefinition>().First().Fields.Count == 0), Arg.Is <IEnumerable <ITypeDefinition> >(x => x.OfType <ClassDefinition>().First().Fields.Count == 1), options).Returns(expected); var actual = calculator.CalculateChanges(oldNodes, newNodes, options); actual.Should().Be(expected); }
public ChangeCalculatorResult CalculateChanges(IEnumerable <ITypeDefinition> oldTypes, IEnumerable <ITypeDefinition> newTypes, ComparerOptions options) { oldTypes = oldTypes ?? throw new ArgumentNullException(nameof(oldTypes)); newTypes = newTypes ?? throw new ArgumentNullException(nameof(newTypes)); var result = new ChangeCalculatorResult(); var changes = _matchProcessor.CalculateChanges(oldTypes, newTypes, options); foreach (var change in changes) { if (change.ChangeType == SemVerChangeType.None) { continue; } _logger?.LogInformation($@"{change.ChangeType}: {change.Message}"); result.Add(change); } var changeType = result.ChangeType.ToString().ToLower(CultureInfo.CurrentCulture); _logger?.LogInformation("Calculated overall result as a {0} change.", changeType); return(result); }
public void CreatesWithDefaultProperties() { var actual = new ChangeCalculatorResult(); actual.ComparisonResults.Should().BeEmpty(); actual.ChangeType.Should().Be(SemVerChangeType.None); }
public void AddThrowsExceptionWithNullResult() { var sut = new ChangeCalculatorResult(); Action action = () => sut.Add(null !); action.Should().Throw <ArgumentNullException>(); }
public void AddSetsChangeTypeToInitialResult() { var result = new ComparisonResult(SemVerChangeType.Feature, null, null, Guid.NewGuid().ToString()); var sut = new ChangeCalculatorResult(); sut.Add(result); sut.ChangeType.Should().Be(result.ChangeType); sut.ComparisonResults.Should().HaveCount(1); sut.ComparisonResults.First().Should().Be(result); }
public void AddUpgradesChangeTypeWhenNewResultAddedWithGreaterChangeType() { var firstResult = new ComparisonResult(SemVerChangeType.Feature, null, null, Guid.NewGuid().ToString()); var secondResult = new ComparisonResult(SemVerChangeType.Breaking, null, null, Guid.NewGuid().ToString()); var sut = new ChangeCalculatorResult(); sut.Add(firstResult); sut.Add(secondResult); sut.ChangeType.Should().Be(secondResult.ChangeType); sut.ComparisonResults.Should().HaveCount(2); sut.ComparisonResults.First().Should().Be(firstResult); sut.ComparisonResults.Skip(1).First().Should().Be(secondResult); }