public static int Main(string[] args) { BicepDeploymentsInterop.Initialize(); var program = new Program(AzResourceTypeProvider.CreateWithAzTypes(), Console.Out, Console.Error, ThisAssembly.AssemblyFileVersion); return(program.Run(args)); }
public void AzResourceTypeProvider_can_deserialize_all_types_without_throwing(ResourceTypeGenerationFlags flags) { var resourceTypeProvider = AzResourceTypeProvider.CreateWithAzTypes(); var availableTypes = resourceTypeProvider.GetAvailableTypes(); // sanity check - we know there should be a lot of types available var expectedTypeCount = 3000; availableTypes.Should().HaveCountGreaterThan(expectedTypeCount); foreach (var availableType in availableTypes) { resourceTypeProvider.HasType(availableType).Should().BeTrue(); var resourceType = resourceTypeProvider.GetType(availableType, flags); try { var visited = new HashSet <TypeSymbol>(); VisitAllReachableTypes(resourceType, visited); } catch (Exception exception) { throw new InvalidOperationException($"Deserializing type {availableType.FormatName()} failed", exception); } } }
public void AzResourceTypeProvider_can_deserialize_all_types_without_throwing() { var resourceTypeProvider = new AzResourceTypeProvider(); var knownTypes = GetAllKnownTypes().ToImmutableArray(); // sanity check - we know there should be a lot of types available knownTypes.Should().HaveCountGreaterThan(500); foreach (var knownType in knownTypes) { resourceTypeProvider.HasType(knownType).Should().BeTrue(); var knownResourceType = resourceTypeProvider.GetType(knownType); try { var visited = new HashSet <TypeSymbol>(); VisitAllReachableTypes(knownResourceType, visited); } catch (Exception exception) { throw new InvalidOperationException($"Deserializing type {knownType.FormatName()} failed", exception); } } }
public ResourceType GetType(ResourceTypeReference reference, ResourceTypeGenerationFlags flags) { var bodyType = new ObjectType(reference.FormatName(), TypeSymbolValidationFlags.Default, LanguageConstants.CreateResourceProperties(reference), null); var resourceType = new ResourceType(reference, ResourceScope.Tenant | ResourceScope.ManagementGroup | ResourceScope.Subscription | ResourceScope.ResourceGroup | ResourceScope.Resource, bodyType); return(AzResourceTypeProvider.SetBicepResourceProperties(resourceType, flags)); }
public void VisitorShouldProduceNoChainForNonInlinedVariables(string variableName) { var compilation = new Compilation(AzResourceTypeProvider.CreateWithAzTypes(), SyntaxTreeGroupingFactory.CreateFromText(Text, BicepTestConstants.FileResolver)); VariableDeclarationSyntax variable = GetVariableByName(compilation, variableName); InlineDependencyVisitor.ShouldInlineVariable(compilation.GetEntrypointSemanticModel(), variable, out var chain).Should().BeFalse(); chain.Should().BeEmpty(); }
public void AzResourceTypeProvider_can_list_all_types_without_throwing() { var resourceTypeProvider = new AzResourceTypeProvider(); var availableTypes = resourceTypeProvider.GetAvailableTypes(); // sanity check - we know there should be a lot of types available availableTypes.Should().HaveCountGreaterThan(2000); }
public static Compilation CopyFilesAndCreateCompilation(this DataSet dataSet, TestContext testContext, out string outputDirectory, out Uri fileUri) { outputDirectory = dataSet.SaveFilesToTestDirectory(testContext); fileUri = PathHelper.FilePathToFileUrl(Path.Combine(outputDirectory, DataSet.TestFileMain)); var syntaxTreeGrouping = SyntaxTreeGroupingBuilder.Build(BicepTestConstants.FileResolver, new Workspace(), fileUri); return(new Compilation(AzResourceTypeProvider.CreateWithAzTypes(), syntaxTreeGrouping)); }
public void AzResourceTypeProvider_can_deserialize_all_types_without_throwing(ResourceTypeGenerationFlags flags) { var resourceTypeProvider = AzResourceTypeProvider.CreateWithAzTypes(); var availableTypes = resourceTypeProvider.GetAvailableTypes(); // sanity check - we know there should be a lot of types available var expectedTypeCount = 3000; availableTypes.Should().HaveCountGreaterThan(expectedTypeCount); foreach (var availableType in availableTypes) { resourceTypeProvider.HasType(availableType).Should().BeTrue(); var resourceType = resourceTypeProvider.GetType(availableType, flags); try { var visited = new HashSet <TypeSymbol>(); VisitAllReachableTypes(resourceType, visited); } catch (Exception exception) { throw new InvalidOperationException($"Deserializing type {availableType.FormatName()} failed", exception); } bool IsSymbolicProperty(TypeProperty property) { var type = property.TypeReference.Type; return(type is IScopeReference || type == LanguageConstants.ResourceOrResourceCollectionRefItem || type == LanguageConstants.ResourceOrResourceCollectionRefArray); } /* * This test is the most expensive one because it deserializes all the types. * Creating a separate test to add a bit of extra validation would basically double the runtime of the Az provider tests. */ { // some types include a top-level scope property that is different than our own scope property // so we need to filter by type var topLevelProperties = GetTopLevelProperties(resourceType); var symbolicProperties = topLevelProperties.Where(property => IsSymbolicProperty(property)); symbolicProperties.Should().NotBeEmpty(); symbolicProperties.Should().OnlyContain(property => property.Flags.HasFlag(TypePropertyFlags.DisallowAny), $"because all symbolic properties in type '{availableType.FullyQualifiedType}' and api version '{availableType.ApiVersion}' should have the {nameof(TypePropertyFlags.DisallowAny)} flag."); var loopVariantProperties = topLevelProperties.Where(property => ExpectedLoopVariantProperties.Contains(property.Name) && (!string.Equals(property.Name, LanguageConstants.ResourceScopePropertyName, LanguageConstants.IdentifierComparison) || IsSymbolicProperty(property))); loopVariantProperties.Should().NotBeEmpty(); loopVariantProperties.Should().OnlyContain(property => property.Flags.HasFlag(TypePropertyFlags.LoopVariant), $"because all loop variant properties in type '{availableType.FullyQualifiedType}' and api version '{availableType.ApiVersion}' should have the {nameof(TypePropertyFlags.LoopVariant)} flag."); if (flags.HasFlag(ResourceTypeGenerationFlags.NestedResource)) { // syntactically nested resources should not have the parent property topLevelProperties.Should().NotContain(property => string.Equals(property.Name, LanguageConstants.ResourceParentPropertyName, LanguageConstants.IdentifierComparison)); } } } }
public void ZeroMatchingNodes_Create_ShouldThrow() { const string text = "var foo = 42"; var compilation = new Compilation(AzResourceTypeProvider.CreateWithAzTypes(), SyntaxTreeGroupingFactory.CreateFromText(text)); Action fail = () => BicepCompletionContext.Create(compilation, text.Length + 2); fail.Should().Throw <ArgumentException>().WithMessage("The specified offset 14 is outside the span of the specified ProgramSyntax node."); }
public void AzResourceTypeProvider_can_list_all_types_without_throwing(ResourceScope scopeType) { var resourceTypeProvider = new AzResourceTypeProvider(); var availableTypes = resourceTypeProvider.GetAvailableTypes(scopeType); // sanity check - we know there should be a lot of types available var expectedTypeCount = scopeType == ResourceScope.ResourceGroup ? 2000 : 100; availableTypes.Should().HaveCountGreaterThan(expectedTypeCount); }
public void AzResourceTypeProvider_can_list_all_types_without_throwing() { var resourceTypeProvider = AzResourceTypeProvider.CreateWithAzTypes(); var availableTypes = resourceTypeProvider.GetAvailableTypes(); // sanity check - we know there should be a lot of types available var expectedTypeCount = 3000; availableTypes.Should().HaveCountGreaterThan(expectedTypeCount); }
public static ResourceTypeComponents CreateCustomResourceType(string fullyQualifiedType, string apiVersion, TypeSymbolValidationFlags validationFlags, params TypeProperty[] customProperties) { var reference = ResourceTypeReference.Parse($"{fullyQualifiedType}@{apiVersion}"); var resourceProperties = AzResourceTypeProvider.GetCommonResourceProperties(reference) .Concat(new TypeProperty("properties", new ObjectType("properties", validationFlags, customProperties, null), TypePropertyFlags.Required)); var bodyType = new ObjectType(reference.FormatName(), validationFlags, resourceProperties, null); return(new ResourceTypeComponents(reference, ResourceScope.Tenant | ResourceScope.ManagementGroup | ResourceScope.Subscription | ResourceScope.ResourceGroup | ResourceScope.Resource, bodyType)); }
public void VisitorShouldProduceCorrectChainForInlinedVariables(string variableName, string expectedChain) { var compilation = new Compilation(AzResourceTypeProvider.CreateWithAzTypes(), SyntaxTreeGroupingFactory.CreateFromText(Text, BicepTestConstants.FileResolver)); VariableDeclarationSyntax variable = GetVariableByName(compilation, variableName); InlineDependencyVisitor.ShouldInlineVariable(compilation.GetEntrypointSemanticModel(), variable, out var chain).Should().BeTrue(); chain.Should().NotBeNull(); var actualChain = string.Join(',', (IEnumerable <string>)chain !); actualChain.Should().Be(expectedChain); }
public void AzResourceTypeProvider_should_warn_for_missing_resource_types() { Compilation createCompilation(string program) => new Compilation(AzResourceTypeProvider.CreateWithAzTypes(), SyntaxTreeGroupingFactory.CreateFromText(program)); // Missing top-level properties - should be an error var compilation = createCompilation(@" resource missingResource 'Mock.Rp/madeUpResourceType@2020-01-01' = { name: 'missingResource' } "); compilation.Should().HaveDiagnostics(new [] {
public static int Main(string[] args) { string profilePath = MulticoreJIT.GetMulticoreJITPath(); ProfileOptimization.SetProfileRoot(profilePath); ProfileOptimization.StartProfile("bicep.profile"); Console.OutputEncoding = TemplateEmitter.UTF8EncodingWithoutBom; BicepDeploymentsInterop.Initialize(); var program = new Program(new InvocationContext(AzResourceTypeProvider.CreateWithAzTypes(), Console.Out, Console.Error, ThisAssembly.AssemblyFileVersion)); return(program.Run(args)); }
public void VisitorShouldCalculateInliningInBulk() { var compilation = new Compilation(AzResourceTypeProvider.CreateWithAzTypes(), SyntaxTreeGroupingFactory.CreateFromText(Text, BicepTestConstants.FileResolver)); var inlineVariables = InlineDependencyVisitor.GetVariablesToInline(compilation.GetEntrypointSemanticModel()); inlineVariables.Should().Contain(new[] { GetVariableSymbolByName(compilation, "keys"), GetVariableSymbolByName(compilation, "indirection"), GetVariableSymbolByName(compilation, "runtimeLoop"), GetVariableSymbolByName(compilation, "runtimeLoop2") }); }
public static async Task Main(string[] args) => await RunWithCancellationAsync(async cancellationToken => { // the server uses JSON-RPC over stdin & stdout to communicate, // so be careful not to use console for logging! var server = new Server( Console.OpenStandardInput(), Console.OpenStandardOutput(), new Server.CreationOptions { ResourceTypeProvider = AzResourceTypeProvider.CreateWithAzTypes(), FileResolver = new FileResolver(), }); await server.RunAsync(cancellationToken); });
public void AzResourceTypeProvider_can_deserialize_all_types_without_throwing(ResourceTypeGenerationFlags flags) { var resourceTypeProvider = AzResourceTypeProvider.CreateWithAzTypes(); var availableTypes = resourceTypeProvider.GetAvailableTypes(); // sanity check - we know there should be a lot of types available var expectedTypeCount = 3000; availableTypes.Should().HaveCountGreaterThan(expectedTypeCount); foreach (var availableType in availableTypes) { resourceTypeProvider.HasType(availableType).Should().BeTrue(); var resourceType = resourceTypeProvider.GetType(availableType, flags); try { var visited = new HashSet <TypeSymbol>(); VisitAllReachableTypes(resourceType, visited); } catch (Exception exception) { throw new InvalidOperationException($"Deserializing type {availableType.FormatName()} failed", exception); } bool IsSymbolicProperty(TypeProperty property) { var type = property.TypeReference.Type; return(type is IScopeReference || type == LanguageConstants.ResourceOrResourceCollectionRefItem || type == LanguageConstants.ResourceOrResourceCollectionRefArray); } /* * This test is the most expensive one because it deserializes all the types. * Creating a separate test to add a bit of extra validation would basically double the runtime of the Az provider tests. */ { // some types include a top-level scope property that is different than our own scope property // so we need to filter by type var topLevelProperties = GetTopLevelProperties(resourceType); var symbolicProperties = topLevelProperties.Where(property => IsSymbolicProperty(property)); symbolicProperties.Should().NotBeEmpty(); symbolicProperties.Should().OnlyContain(property => property.Flags.HasFlag(TypePropertyFlags.DisallowAny)); } } }
public static async Task Main() => await RunWithCancellationAsync(async cancellationToken => { string profilePath = MulticoreJIT.GetMulticoreJITPath(); ProfileOptimization.SetProfileRoot(profilePath); ProfileOptimization.StartProfile("bicepserver.profile"); // the server uses JSON-RPC over stdin & stdout to communicate, // so be careful not to use console for logging! var server = new Server( Console.OpenStandardInput(), Console.OpenStandardOutput(), new Server.CreationOptions { ResourceTypeProvider = AzResourceTypeProvider.CreateWithAzTypes(), FileResolver = new FileResolver() }); await server.RunAsync(cancellationToken); });
public void Decompiler_generates_expected_bicep_files_with_diagnostics(ExampleData example) { // save all the files in the containing directory to disk so that we can test module resolution var parentStream = Path.GetDirectoryName(example.BicepStreamName) !.Replace('\\', '/'); var outputDirectory = FileHelper.SaveEmbeddedResourcesWithPathPrefix(TestContext, typeof(DecompilationTests).Assembly, parentStream); var bicepFileName = Path.Combine(outputDirectory, Path.GetFileName(example.BicepStreamName)); var jsonFileName = Path.Combine(outputDirectory, Path.GetFileName(example.JsonStreamName)); var typeProvider = AzResourceTypeProvider.CreateWithAzTypes(); var(bicepUri, filesToSave) = TemplateDecompiler.DecompileFileWithModules(typeProvider, new FileResolver(), PathHelper.FilePathToFileUrl(jsonFileName)); var syntaxTrees = filesToSave.Select(kvp => SyntaxTree.Create(kvp.Key, kvp.Value)); var workspace = new Workspace(); workspace.UpsertSyntaxTrees(syntaxTrees); var syntaxTreeGrouping = SyntaxTreeGroupingBuilder.Build(new FileResolver(), workspace, bicepUri); var compilation = new Compilation(typeProvider, syntaxTreeGrouping); var diagnosticsBySyntaxTree = compilation.GetAllDiagnosticsBySyntaxTree(); using (new AssertionScope()) { foreach (var syntaxTree in syntaxTreeGrouping.SyntaxTrees) { var exampleExists = File.Exists(syntaxTree.FileUri.LocalPath); exampleExists.Should().BeTrue($"Generated example \"{syntaxTree.FileUri.LocalPath}\" should be checked in"); var diagnostics = diagnosticsBySyntaxTree[syntaxTree]; var bicepOutput = filesToSave[syntaxTree.FileUri]; var sourceTextWithDiags = OutputHelper.AddDiagsToSourceText(bicepOutput, Environment.NewLine, diagnostics, diag => OutputHelper.GetDiagLoggingString(bicepOutput, outputDirectory, diag)); File.WriteAllText(syntaxTree.FileUri.LocalPath + ".actual", sourceTextWithDiags); sourceTextWithDiags.Should().EqualWithLineByLineDiffOutput( TestContext, exampleExists ? File.ReadAllText(syntaxTree.FileUri.LocalPath) : "", expectedLocation: Path.Combine("src", "Bicep.Decompiler.IntegrationTests", parentStream, Path.GetRelativePath(outputDirectory, syntaxTree.FileUri.LocalPath)), actualLocation: syntaxTree.FileUri.LocalPath + ".actual"); } } }
private static ResourceTypeComponents DiscriminatedPropertiesTestsType2() { var resourceType = ResourceTypeReference.Parse("Test.Rp/discriminatedPropertiesTests2@2020-01-01"); var bodyAProps = new ObjectType( "BodyAProperties", TypeSymbolValidationFlags.WarnOnTypeMismatch, new[] { new TypeProperty("propA", LanguageConstants.String, TypePropertyFlags.None, "This is the description for propA!"), }, null); var bodyBProps = new ObjectType( "BodyBProperties", TypeSymbolValidationFlags.WarnOnTypeMismatch, new[] { new TypeProperty("propB", LanguageConstants.String, TypePropertyFlags.None, "This is the description for propB!"), }, null); var propertiesType = new DiscriminatedObjectType( "properties", TypeSymbolValidationFlags.Default, "propType", new[] { new ObjectType("BodyA", TypeSymbolValidationFlags.Default, AzResourceTypeProvider.GetCommonResourceProperties(resourceType).Concat(new [] { new TypeProperty("propType", new StringLiteralType("PropertiesA"), TypePropertyFlags.None, "This is the propType of body A"), new TypeProperty("values", bodyAProps, TypePropertyFlags.None, "These are the properties for body A"), }), null), new ObjectType("BodyB", TypeSymbolValidationFlags.Default, AzResourceTypeProvider.GetCommonResourceProperties(resourceType).Concat(new [] { new TypeProperty("propType", new StringLiteralType("PropertiesB"), TypePropertyFlags.None, "This is the propType of body B"), new TypeProperty("values", bodyBProps, TypePropertyFlags.None, "These are the properties for body B"), }), null), }); return(new ResourceTypeComponents(resourceType, ResourceScope.ResourceGroup, new ObjectType(resourceType.FormatName(), TypeSymbolValidationFlags.Default, AzResourceTypeProvider.GetCommonResourceProperties(resourceType).Concat(new[] { new TypeProperty("properties", propertiesType, TypePropertyFlags.Required, "properties property"), }), null))); }
private async Task <BicepTelemetryEvent> ResolveCompletionAsync(string text, string prefix, Position position) { var fileSystemDict = new Dictionary <Uri, string>(); var telemetryReceived = new TaskCompletionSource <BicepTelemetryEvent>(); var client = await IntegrationTestHelper.StartServerWithClientConnectionAsync( TestContext, options => { options.OnTelemetryEvent <BicepTelemetryEvent>(telemetry => telemetryReceived.SetResult(telemetry)); }, resourceTypeProvider : AzResourceTypeProvider.CreateWithAzTypes(), fileResolver : new InMemoryFileResolver(fileSystemDict)); var mainUri = DocumentUri.FromFileSystemPath("/main.bicep"); fileSystemDict[mainUri.ToUri()] = text; client.TextDocument.DidOpenTextDocument(TextDocumentParamHelper.CreateDidOpenDocumentParams(mainUri, fileSystemDict[mainUri.ToUri()], 1)); var completions = await client.RequestCompletion(new CompletionParams { TextDocument = new TextDocumentIdentifier(mainUri), Position = position, }); CompletionItem completionItem = completions.Where(x => x.Kind == CompletionItemKind.Snippet && x.Label == prefix).First(); Command? command = completionItem.Command; JArray? arguments = command !.Arguments; BicepTelemetryEvent?telemetryEvent = arguments !.First().ToObject <BicepTelemetryEvent>(); await client.ResolveCompletion(completionItem); await client.Workspace.ExecuteCommand(command); return(await IntegrationTestHelper.WithTimeoutAsync(telemetryReceived.Task)); }
public DefaultNamespaceProvider(IAzResourceTypeLoader azResourceTypeLoader, IFeatureProvider featureProvider) { this.azResourceTypeProvider = new AzResourceTypeProvider(azResourceTypeLoader); this.featureProvider = featureProvider; }
public async Task HoveringOverSymbolReferencesAndDeclarationsShouldProduceHovers(DataSet dataSet) { var compilation = dataSet.CopyFilesAndCreateCompilation(TestContext, out _, out var fileUri); var uri = DocumentUri.From(fileUri); var client = await IntegrationTestHelper.StartServerWithTextAsync(this.TestContext, dataSet.Bicep, uri, resourceTypeProvider : AzResourceTypeProvider.CreateWithAzTypes(), fileResolver : BicepTestConstants.FileResolver); var symbolTable = compilation.ReconstructSymbolTable(); var lineStarts = compilation.SyntaxTreeGrouping.EntryPoint.LineStarts; var symbolReferences = SyntaxAggregator.Aggregate( compilation.SyntaxTreeGrouping.EntryPoint.ProgramSyntax, new List <SyntaxBase>(), (accumulated, node) => { if (node is ISymbolReference || node is ITopLevelNamedDeclarationSyntax) { accumulated.Add(node); } return(accumulated); }, accumulated => accumulated); foreach (var symbolReference in symbolReferences) { // by default, request a hover on the first character of the syntax, but for certain syntaxes, this doesn't make sense. // for example on an instance function call 'az.resourceGroup()', it only makes sense to request a hover on the 3rd character. var nodeForHover = symbolReference switch { ITopLevelDeclarationSyntax d => d.Keyword, ResourceAccessSyntax r => r.ResourceName, FunctionCallSyntaxBase f => f.Name, _ => symbolReference, }; var hover = await client.RequestHover(new HoverParams { TextDocument = new TextDocumentIdentifier(uri), Position = TextCoordinateConverter.GetPosition(lineStarts, nodeForHover.Span.Position) }); // fancy method to give us some annotated source code to look at if any assertions fail :) using (new AssertionScope().WithVisualCursor(compilation.SyntaxTreeGrouping.EntryPoint, nodeForHover.Span.ToZeroLengthSpan())) { if (!symbolTable.TryGetValue(symbolReference, out var symbol)) { if (symbolReference is InstanceFunctionCallSyntax && compilation.GetEntrypointSemanticModel().GetSymbolInfo(symbolReference) is FunctionSymbol ifcSymbol) { ValidateHover(hover, ifcSymbol); break; } // symbol ref not bound to a symbol hover.Should().BeNull(); continue; } switch (symbol !.Kind) {
private static void RegisterServices(CreationOptions creationOptions, IServiceCollection services) { // using type based registration so dependencies can be injected automatically // without manually constructing up the graph services.AddSingleton <IResourceTypeProvider>(services => creationOptions.ResourceTypeProvider ?? AzResourceTypeProvider.CreateWithAzTypes()); services.AddSingleton <ISnippetsProvider>(services => creationOptions.SnippetsProvider ?? new SnippetsProvider()); services.AddSingleton <IFileResolver>(services => creationOptions.FileResolver ?? new FileResolver()); services.AddSingleton <IWorkspace, Workspace>(); services.AddSingleton <ICompilationManager, BicepCompilationManager>(); services.AddSingleton <ICompilationProvider, BicepCompilationProvider>(); services.AddSingleton <ISymbolResolver, BicepSymbolResolver>(); services.AddSingleton <ICompletionProvider, BicepCompletionProvider>(); }
public ResourceType GetType(ResourceTypeReference reference, ResourceTypeGenerationFlags flags) => AzResourceTypeProvider.SetBicepResourceProperties(typeDictionary[reference], flags);
private static ResourceTypeComponents FallbackPropertyTestsType() { var resourceType = ResourceTypeReference.Parse("Test.Rp/fallbackProperties@2020-01-01"); var propertiesType = new ObjectType("Properties", TypeSymbolValidationFlags.WarnOnTypeMismatch, new[] { new TypeProperty("required", LanguageConstants.String, TypePropertyFlags.Required, "This is a property which is required."), }, null); return(new ResourceTypeComponents(resourceType, ResourceScope.ResourceGroup, new ObjectType(resourceType.FormatName(), TypeSymbolValidationFlags.Default, AzResourceTypeProvider.GetCommonResourceProperties(resourceType).Concat(new[] { new TypeProperty("properties", propertiesType, TypePropertyFlags.Required, "properties property"), }).Concat( AzResourceTypeProvider.KnownTopLevelResourceProperties().Where(p => !string.Equals(p.Name, "properties", LanguageConstants.IdentifierComparison)) .Select(p => new TypeProperty(p.Name, p.TypeReference, TypePropertyFlags.None, "Property that does something important")) ), null))); }
private static ResourceTypeComponents BasicTestsType() { var resourceType = ResourceTypeReference.Parse("Test.Rp/basicTests@2020-01-01"); return(new ResourceTypeComponents(resourceType, ResourceScope.ResourceGroup, new ObjectType(resourceType.FormatName(), TypeSymbolValidationFlags.Default, AzResourceTypeProvider.GetCommonResourceProperties(resourceType).Concat(new[] { new TypeProperty("kind", LanguageConstants.String, TypePropertyFlags.ReadOnly, "kind property"), }), null))); }
private static ResourceTypeComponents ReadWriteTestsType() { var resourceType = ResourceTypeReference.Parse("Test.Rp/readWriteTests@2020-01-01"); var propertiesType = new ObjectType("Properties", TypeSymbolValidationFlags.WarnOnTypeMismatch, new[] { new TypeProperty("readwrite", LanguageConstants.String, TypePropertyFlags.None, "This is a property which supports reading AND writing!"), new TypeProperty("readonly", LanguageConstants.String, TypePropertyFlags.ReadOnly, "This is a property which only supports reading."), new TypeProperty("writeonly", LanguageConstants.String, TypePropertyFlags.WriteOnly, "This is a property which only supports writing."), new TypeProperty("required", LanguageConstants.String, TypePropertyFlags.Required, "This is a property which is required."), }, null); return(new ResourceTypeComponents(resourceType, ResourceScope.ResourceGroup, new ObjectType(resourceType.FormatName(), TypeSymbolValidationFlags.Default, AzResourceTypeProvider.GetCommonResourceProperties(resourceType).Concat(new[] { new TypeProperty("properties", propertiesType, TypePropertyFlags.Required, "properties property"), }), null))); }
public static IResourceTypeProvider CreateProviderWithTypes(IEnumerable <ResourceType> resourceTypes) => AzResourceTypeProvider.CreateWithLoader(new TestResourceTypeLoader(resourceTypes), false);