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);
}
