Esempio n. 1
0
        private static IEnumerable<SyntaxNode> GetReferencedNodes(SyntaxNode node, SutInfo sutInfo)
        {
            var symbolModel = node.GetModelFromNode(sutInfo.SemanticModel.Compilation);

            if (symbolModel == null)
                return new SyntaxNode[0];

            var symbol = symbolModel.GetSymbolInfo(node).Symbol;

            if (symbol == null || symbol.Locations.All(x => !x.IsInSource))
                return new SyntaxNode[0];

            var sutType = sutInfo.SymbolInfo.Symbol as INamedTypeSymbol;
            var symbolType = symbol as INamedTypeSymbol;

            //constraint to get nodes for current sut type or base type of it
            if (sutType != null
                && !IsTypesEquals(symbolType, sutType)
                && !IsTypesEquals(symbol.ContainingType, sutType)
                && !IsTypesEquals(symbol.ContainingType?.ConstructedFrom, sutType.ConstructedFrom)
                && !IsTypesEquals(symbolType, sutType.BaseType)
                && !IsTypesEquals(symbol.ContainingType, sutType.BaseType)
                && !IsTypesEquals(symbol.ContainingType?.ConstructedFrom, sutType.BaseType?.ConstructedFrom))
            {
                return new SyntaxNode[0];
            }

            return symbol.DeclaringSyntaxReferences
                         .SelectMany(z => z.GetSyntax()
                         .DescendantNodes());
        }
Esempio n. 2
0
 private static Func<Fields, bool> DontHaveSetups(SutInfo suitableSut)
 {
     return syntax => !IsExistInSetups(syntax, suitableSut.InjectedFields);
 }
Esempio n. 3
0
        private static IEnumerable<Fields> GetUsings(ExpressionSyntax expression, ISymbol symbol, SutInfo suitableSut, SemanticModel semanticModel, Dictionary<string, ITypeSymbol> sutSubstitutions)
        {
            var syntax = expression.Parents(x => (x as UsingStatementSyntax)?.Declaration
                                                                             .Variables
                                                                             .Any(y => y.DescendantNodes()
                                                                                        .Any(z => z == expression)) == true) as UsingStatementSyntax;

            if (syntax == null) return Enumerable.Empty<Fields>();

            var methodSymbol = symbol as IMethodSymbol;
            var propertySymbol = symbol as IPropertySymbol;

            if (methodSymbol == null && propertySymbol == null)
                return Enumerable.Empty<Fields>();

            var containingType = (methodSymbol?.ReturnType ?? propertySymbol?.GetMethod?.ReturnType);

            var disposable = containingType?.Interfaces.FirstOrDefault(x => x.Name == "IDisposable");

            if(disposable == null)
                return Enumerable.Empty<Fields>();

            var disposeMethod = disposable.GetMembers("Dispose").First();

            return syntax.Declaration.Variables.Select(x => new Fields
            {
                Expression = expression,
                MethodOrPropertySymbol = disposeMethod,
                FieldsToSetup = GetFieldsToSetup(suitableSut, semanticModel, containingType, sutSubstitutions)
            });
        }
Esempio n. 4
0
 private static IEnumerable<FieldsSetups> GetFieldsToSetup(SutInfo suitableSut,
     SemanticModel semanticModel,
     ISymbol symbol,
     Dictionary<string, ITypeSymbol> sutSubstitutions)
 {
     return suitableSut.InjectedFields.Find(IsCorrespondingField(semanticModel, symbol, sutSubstitutions))
         .Select(z => new FieldsSetups
         {
             Field = z.Data.Field.Declaration.Variables.Select(f => f.Identifier.ValueText),
             Substitutions = (z.Data.Field.Declaration.Type as GenericNameSyntax)?.TypeArgumentList
                                                                                  .Arguments
                                                                                  .Select(y => GetSubstitutions(semanticModel, y))
                                                                                  .SelectMany(s => s)
                                                                                  .ToDictionary(s => s.Key, s => s.Value),
             SutSubstitutions = sutSubstitutions
         }).ToArray();
 }
Esempio n. 5
0
 private static IEnumerable<Fields> GetInvokedMethodsOfMocks(
     IEnumerable<ExpressionSyntax> methodsAndPropertyInvokations,
     SemanticModel model,
     SutInfo suitableSut,
     SemanticModel semanticModel,
     Dictionary<string, ITypeSymbol> sutSubstitutions)
 {
     var invokedMethodsOfMocks = methodsAndPropertyInvokations.Select(x => new
     {
         x.GetModelFromExpression(model)?.GetSymbolInfo(x).Symbol,
         Expression = x
     }).SelectMany(x => new[] {new Fields
         {
             Expression = x.Expression,
             MethodOrPropertySymbol = x.Symbol,
             FieldsToSetup = GetFieldsToSetup(suitableSut, semanticModel, x.Symbol, sutSubstitutions)
         }}.Concat(GetUsings(x.Expression, x.Symbol, suitableSut, semanticModel, sutSubstitutions)))
         .Where(x => x.FieldsToSetup.Any())
         .ToArray();
     return invokedMethodsOfMocks;
 }