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