public void DotNetTemplateMetadataMapper_Map(string templateJsonFile)
        {
            var content          = File.ReadAllText(templateJsonFile);
            var templateMetadata = DotNetTemplateMetadata.FromJson(content);
            var result           = new DotNetTemplateMetadataMapper().Map(templateMetadata);

            Assert.IsNotNull(result);
            Assert.IsTrue(result.Tags.Count() > 0);
            Assert.IsTrue(result.ConditionalTags.Count() > 0);
            Assert.IsTrue(result.ComputedTags.Count() > 0);
        }
        public TemplateMetadata GetMetadata(AppConfiguration.Template template)
        {
            TemplateMetadata metadata = null;

            var metadataFile = GetMetadataFile(template);

            if (metadataFile != null && !string.IsNullOrEmpty(metadataFile.Content))
            {
                try
                {
                    if (metadataFile.Name.EndsWith(DotNetTemplateMetadata.FILE_NAME, StringComparison.InvariantCultureIgnoreCase))
                    {
                        metadata = new DotNetTemplateMetadataMapper().Map(DotNetTemplateMetadata.FromJson(metadataFile.Content));
                    }
                    else
                    {
                        metadata = JsonSerializer.Deserialize <TemplateMetadata>(metadataFile.Content);
                    }
                }
                catch (Exception ex)
                {
                    var error = $"`{metadataFile.Name}` in `{template.SourceUrl}` must be in JSON";
                    Console.WriteLine(error + Environment.NewLine + ex.ToString());
                    throw new TemplateException(error, ex);
                }

                // Make sure the tags have keys. Names can be used to substitute keys.
                if (metadata.Tags != null)
                {
                    foreach (var tag in metadata.Tags.Where(x => string.IsNullOrEmpty(x.Key)))
                    {
                        tag.Key = tag.Name;
                    }
                    metadata.Tags = metadata.Tags.Where(x => !string.IsNullOrEmpty(x.Key));
                }

                if (metadata.ConditionalTags != null)
                {
                    foreach (var tag in metadata.ConditionalTags.Where(x => string.IsNullOrEmpty(x.Key)))
                    {
                        tag.Key = tag.Name;
                    }
                    metadata.ConditionalTags = metadata.ConditionalTags.Where(x => !string.IsNullOrEmpty(x.Key));
                }

                if (metadata.ComputedTags != null)
                {
                    metadata.ComputedTags = metadata.ComputedTags.Where(x => !string.IsNullOrEmpty(x.Key));
                }
            }

            return(metadata);
        }
        public void DotNetTemplateMetadataMapper_MapGeneratedSymbols(string templateJsonFile)
        {
            var content          = File.ReadAllText(templateJsonFile);
            var templateMetadata = DotNetTemplateMetadata.FromJson(content);
            var result           = new DotNetTemplateMetadataMapper().Map(templateMetadata);

            Assert.IsNotNull(result);

            var httpPortConstant = result.ComputedTags.FirstOrDefault(x => x.Key == "HttpPortConstant");

            Assert.AreEqual("5000", httpPortConstant.Expression);

            var httpPortReplacer = result.ComputedTags.FirstOrDefault(x => x.Key == "5000");

            Assert.AreEqual("HttpPort != null ? HttpPort : HttpPortConstant", httpPortReplacer.Expression);

            var gitHubProjectLower = result.ComputedTags.FirstOrDefault(x => x.Key == "GitHubProjectLower");

            Assert.AreEqual("lowerCase(GitHubProject)", gitHubProjectLower.Expression);
        }