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 CompareMatchReturnsResultFromParameterComparer()
        {
            var oldParameter = new TestParameterDefinition();
            var oldParameters = new List <IParameterDefinition> {
                oldParameter
            }.AsReadOnly();
            var oldItem = new TestMethodDefinition().Set(x => x.Parameters = oldParameters);
            var newParameter = new TestParameterDefinition();
            var newParameters = new List <IParameterDefinition> {
                newParameter
            }.AsReadOnly();
            var newItem    = oldItem.JsonClone().Set(x => x.Parameters = newParameters);
            var match      = new ItemMatch <IMethodDefinition>(oldItem, newItem);
            var changeType = Model.Create <SemVerChangeType>();
            var message    = Guid.NewGuid().ToString();
            var result     = new ComparisonResult(changeType, oldItem, newItem, message);
            var results    = new[] { result };
            var options    = ComparerOptions.Default;

            Service <IParameterComparer>()
            .CompareMatch(
                Arg.Is <ItemMatch <IParameterDefinition> >(x =>
                                                           x.OldItem == oldParameter && x.NewItem == newParameter), options).Returns(results);

            var actual = SUT.CompareMatch(match, options).ToList();

            _output.WriteResults(actual);

            actual.Should().HaveCount(1);
            actual[0].Should().BeEquivalentTo(result);
        }
        public void CompareMatchReturnsEmptyChangesWhenGenericTypeParameterRenamed()
        {
            var oldTypeParameters = new List <string>
            {
                "T"
            }.AsReadOnly();
            var oldItem = new TestMethodDefinition().Set(x =>
            {
                x.Name    = "Original<T>";
                x.RawName = "Original";
                x.GenericTypeParameters = oldTypeParameters;
            });
            var newTypeParameters = new List <string>
            {
                "V"
            }.AsReadOnly();
            var newItem = oldItem.JsonClone().Set(x =>
            {
                x.Name    = "Original<V>";
                x.RawName = "Original";
                x.GenericTypeParameters = newTypeParameters;
            });
            var match   = new ItemMatch <IMethodDefinition>(oldItem, newItem);
            var options = ComparerOptions.Default;

            var actual = SUT.CompareMatch(match, options).ToList();

            _output.WriteResults(actual);

            actual.Should().BeEmpty();
        }
        public void CompareMatchReturnsBreakingWhenNameChangedWithGenericTypeParameters()
        {
            var genericTypeParameters = new List <string>
            {
                "T"
            }.AsReadOnly();
            var oldItem = new TestMethodDefinition().Set(x =>
            {
                x.Name    = "Original<T>";
                x.RawName = "Original";
                x.GenericTypeParameters = genericTypeParameters;
            });
            var newItem = oldItem.JsonClone().Set(x =>
            {
                x.Name    = "Renamed<T>";
                x.RawName = "Renamed";
            });
            var match   = new ItemMatch <IMethodDefinition>(oldItem, newItem);
            var options = ComparerOptions.Default;

            var actual = SUT.CompareMatch(match, options).ToList();

            _output.WriteResults(actual);
            actual.First().Message.Should().Contain("renamed");

            actual.Should().HaveCount(1);
            actual[0].ChangeType.Should().BeEquivalentTo(SemVerChangeType.Breaking);
        }
        public void CompareMatchReturnsEmptyWhenItemsMatch()
        {
            var oldItem = new TestMethodDefinition();
            var newItem = oldItem.JsonClone();
            var match   = new ItemMatch <IMethodDefinition>(oldItem, newItem);
            var options = ComparerOptions.Default;

            var actual = SUT.CompareMatch(match, options).ToList();

            _output.WriteResults(actual);

            actual.Should().BeEmpty();
        }
        public void CompareMatchReturnsBreakingWhenParameterRemoved()
        {
            var parameter = new TestParameterDefinition();
            var parameters = new List <IParameterDefinition> {
                parameter
            }.AsReadOnly();
            var oldItem = new TestMethodDefinition().Set(x => x.Parameters = parameters);
            var newItem = oldItem.JsonClone().Set(x => x.Parameters = Array.Empty <IParameterDefinition>());
            var match   = new ItemMatch <IMethodDefinition>(oldItem, newItem);
            var options = ComparerOptions.Default;

            var actual = SUT.CompareMatch(match, options).ToList();

            _output.WriteResults(actual);

            actual.Should().HaveCount(1);
            actual[0].ChangeType.Should().BeEquivalentTo(SemVerChangeType.Breaking);
            actual[0].Message.Should().Contain("removed");
            actual[0].Message.Should().Contain("parameter");
        }
        public void CompareMatchDoesNotContinueEvaluationWhenNameChanged()
        {
            var oldItem = new TestMethodDefinition();
            var newItem = oldItem.JsonClone().Set(x =>
            {
                x.Name    = "Renamed";
                x.RawName = "Renamed";
            });
            var match   = new ItemMatch <IMethodDefinition>(oldItem, newItem);
            var options = ComparerOptions.Default;

            var actual = SUT.CompareMatch(match, options).ToList();

            _output.WriteResults(actual);

            actual.Should().HaveCount(1);

            Service <IGenericTypeElementComparer>().DidNotReceive()
            .CompareMatch(Arg.Any <ItemMatch <IGenericTypeElement> >(), Arg.Any <ComparerOptions>());
            Service <IParameterComparer>().DidNotReceive()
            .CompareMatch(Arg.Any <ItemMatch <IParameterDefinition> >(), Arg.Any <ComparerOptions>());
        }