コード例 #1
0
        public void Casing_issues_are_corrected()
        {
            var bicepFile = @"
resource resA 'My.Rp/resA@2020-01-01' = {
  name: 'resA'
  properties: {
    lowerCaseProp: 'abc'
    camelcaseprop: 'def'
    'lowerCaseQuoted=+.Prop': 'ghi'
    'camelcasequoted=+.prop': 'jkl'
    lowerCaseEnumProp: 'MyEnum'
    pascalCaseEnumProp: 'myenum'
    lowerCaseEnumUnionProp: 'MyEnum'
    pascalCaseEnumUnionProp: 'myenum'
  }
}

output myObj object = {
  lowerCaseProp: resA.properties.lowerCaseProp
  camelcaseprop: resA.properties.camelcaseprop
}
";

            var typeDefinition = ResourceTypeProviderHelper.CreateCustomResourceType("My.Rp/resA", "2020-01-01", TypeSymbolValidationFlags.WarnOnTypeMismatch,
                                                                                     new TypeProperty("lowercaseprop", LanguageConstants.String),
                                                                                     new TypeProperty("camelCaseProp", LanguageConstants.String),
                                                                                     new TypeProperty("lowercasequoted=+.prop", LanguageConstants.String),
                                                                                     new TypeProperty("camelCaseQuoted=+.Prop", LanguageConstants.String),
                                                                                     new TypeProperty("lowerCaseEnumProp", new StringLiteralType("myenum")),
                                                                                     new TypeProperty("pascalCaseEnumProp", new StringLiteralType("MyEnum")),
                                                                                     new TypeProperty("lowerCaseEnumUnionProp", UnionType.Create(new StringLiteralType("myenum"), new StringLiteralType("blahblah"))),
                                                                                     new TypeProperty("pascalCaseEnumUnionProp", UnionType.Create(new StringLiteralType("MyEnum"), new StringLiteralType("BlahBlah"))));
            var typeProvider = ResourceTypeProviderHelper.CreateMockTypeProvider(typeDefinition.AsEnumerable());

            var compilation = CompilationHelper.CreateCompilation(typeProvider, ("main.bicep", bicepFile));
            var rewriter    = new TypeCasingFixerRewriter(compilation.GetEntrypointSemanticModel());

            var newProgramSyntax = rewriter.Rewrite(compilation.SyntaxTreeGrouping.EntryPoint.ProgramSyntax);

            PrintHelper.PrettyPrint(newProgramSyntax).Should().Be(
                @"resource resA 'My.Rp/resA@2020-01-01' = {
  name: 'resA'
  properties: {
    lowercaseprop: 'abc'
    camelCaseProp: 'def'
    'lowercasequoted=+.prop': 'ghi'
    'camelCaseQuoted=+.Prop': 'jkl'
    lowerCaseEnumProp: 'myenum'
    pascalCaseEnumProp: 'MyEnum'
    lowerCaseEnumUnionProp: 'myenum'
    pascalCaseEnumUnionProp: 'MyEnum'
  }
}

output myObj object = {
  lowerCaseProp: resA.properties.lowercaseprop
  camelcaseprop: resA.properties.camelCaseProp
}");
        }
コード例 #2
0
        public void InheritedRelatedLocalAttributesShouldTrigger()
        {
            var syntaxTree    = SyntaxTreeTestFactory.FromTestFilePath("InheritedRelatedLocalAttribute.cs");
            var compilation   = CompilationHelper.CreateCompilation(new[] { syntaxTree });
            var transformable = TransformLocator.IsTransformable(compilation, syntaxTree);

            transformable.ShouldBe(true);
        }
コード例 #3
0
        public void UnrelatedAssemblyAttributesShouldNotTrigger()
        {
            var syntaxTree    = SyntaxTreeTestFactory.FromTestFilePath("UnrelatedAssemblyAttribute.cs");
            var compilation   = CompilationHelper.CreateCompilation(new[] { syntaxTree });
            var transformable = TransformLocator.IsTransformable(compilation, syntaxTree);

            transformable.ShouldBe(false);
        }
    private SourceText GenerateSource(AdditionalText additionalFile, string scalarFieldTypeMappingProviderTypeName)
    {
        var configurationOptions =
            new Dictionary <string, string>
        {
            { "build_property.GraphQlClientGenerator_ClassPrefix", "SourceGenerated" },
            { "build_property.GraphQlClientGenerator_ClassSuffix", "V2" },
            { "build_property.GraphQlClientGenerator_IncludeDeprecatedFields", "true" },
            { "build_property.GraphQlClientGenerator_CommentGeneration", "CodeSummary" },
            { "build_property.GraphQlClientGenerator_FloatTypeMapping", "Double" },
            { "build_property.GraphQlClientGenerator_BooleanTypeMapping", "Boolean" },
            { "build_property.GraphQlClientGenerator_IdTypeMapping", "String" },
            { "build_property.GraphQlClientGenerator_JsonPropertyGeneration", "Always" },
            { "build_property.GraphQlClientGenerator_CustomClassMapping", "Query:Tibber|RootMutation:TibberMutation Consumption:ConsumptionEntry;Production:ProductionEntry" },
            { "build_property.GraphQlClientGenerator_Headers", "Authorization:Basic XXX|X-REQUEST-ID:123456789" },
            { "build_property.GraphQlClientGenerator_HttpMethod", "GET" },
            { "build_property.GraphQlClientGenerator_EnumValueNaming", "CSharp" }
        };

        if (scalarFieldTypeMappingProviderTypeName is not null)
        {
            configurationOptions.Add("build_property.GraphQlClientGenerator_ScalarFieldTypeMappingProvider", scalarFieldTypeMappingProviderTypeName);
        }

        var compilerAnalyzerConfigOptionsProvider = new CompilerAnalyzerConfigOptionsProvider(new CompilerAnalyzerConfigOptions(configurationOptions));

        var compilation = CompilationHelper.CreateCompilation(null, "SourceGeneratorTestAssembly");

        var additionalFiles = new List <AdditionalText> {
            _fileGraphQlSchema
        };

        if (additionalFile is not null)
        {
            additionalFiles.Add(additionalFile);
        }

        var sourceGenerator = new GraphQlClientSourceGenerator();
        var driver          = CSharpGeneratorDriver.Create(new [] { sourceGenerator }, additionalFiles, optionsProvider: compilerAnalyzerConfigOptionsProvider);
        var csharpDriver    = driver.RunGenerators(compilation);
        var runResult       = csharpDriver.GetRunResult();
        var results         = runResult.Results;

        results.Length.ShouldBe(1);
        results[0].GeneratedSources.Length.ShouldBe(1);
        return(results[0].GeneratedSources[0].SourceText);
    }
コード例 #5
0
    private void CompileIntoAssembly(string sourceCode, string assemblyName)
    {
        var compilation       = CompilationHelper.CreateCompilation(sourceCode, assemblyName);
        var assemblyFileName  = Path.GetTempFileName();
        var result            = compilation.Emit(assemblyFileName);
        var compilationReport = String.Join(Environment.NewLine, result.Diagnostics.Where(l => l.Severity != DiagnosticSeverity.Hidden).Select(l => $"[{l.Severity}] {l}"));

        if (!String.IsNullOrEmpty(compilationReport))
        {
            _outputHelper.WriteLine(compilationReport);
        }

        var errorReport = String.Join(Environment.NewLine, result.Diagnostics.Where(l => l.Severity == DiagnosticSeverity.Error).Select(l => $"[{l.Severity}] {l}"));

        errorReport.ShouldBeNullOrEmpty();

        Assembly.LoadFrom(assemblyFileName);
    }
コード例 #6
0
        public void Nested_casing_issues_take_multiple_passes_to_correct()
        {
            var bicepFile = @"
resource resA 'My.Rp/resA@2020-01-01' = {
  name: 'resA'
  properties: {
    lowerCaseObj: {
      lowerCaseStr: 'test'
    }
  }
}

output myObj object = {
  lowerCaseProp: resA.properties.lowerCaseObj.lowerCaseStr
}
";

            var typeDefinition = ResourceTypeProviderHelper.CreateCustomResourceType("My.Rp/resA", "2020-01-01", TypeSymbolValidationFlags.WarnOnTypeMismatch,
                                                                                     new TypeProperty("lowercaseobj", new NamedObjectType("lowercaseobj", TypeSymbolValidationFlags.Default, new [] {
                new TypeProperty("lowercasestr", LanguageConstants.String)
            }, null)));
            var typeProvider = ResourceTypeProviderHelper.CreateMockTypeProvider(typeDefinition.AsEnumerable());

            var compilation = CompilationHelper.CreateCompilation(typeProvider, ("main.bicep", bicepFile));
            var rewriter    = new TypeCasingFixerRewriter(compilation.GetEntrypointSemanticModel());

            var newProgramSyntax   = rewriter.Rewrite(compilation.SyntaxTreeGrouping.EntryPoint.ProgramSyntax);
            var firstPassBicepFile = PrintHelper.PrettyPrint(newProgramSyntax);

            firstPassBicepFile.Should().Be(
                @"resource resA 'My.Rp/resA@2020-01-01' = {
  name: 'resA'
  properties: {
    lowercaseobj: {
      lowerCaseStr: 'test'
    }
  }
}

output myObj object = {
  lowerCaseProp: resA.properties.lowercaseobj.lowerCaseStr
}");

            compilation = CompilationHelper.CreateCompilation(typeProvider, ("main.bicep", firstPassBicepFile));
            rewriter    = new TypeCasingFixerRewriter(compilation.GetEntrypointSemanticModel());

            newProgramSyntax = rewriter.Rewrite(compilation.SyntaxTreeGrouping.EntryPoint.ProgramSyntax);
            PrintHelper.PrettyPrint(newProgramSyntax).Should().Be(
                @"resource resA 'My.Rp/resA@2020-01-01' = {
  name: 'resA'
  properties: {
    lowercaseobj: {
      lowercasestr: 'test'
    }
  }
}

output myObj object = {
  lowerCaseProp: resA.properties.lowercaseobj.lowercasestr
}");
        }