public void ShouldReturnContentTypeNameAsPascalCase(string contentType)
        {
            var result = new ContentTypeQueryResourceBuilder(contentType)
                         .Build();

            Assert.Equal("someContentType {}", result);
        }
        public void ShouldAddNestedFieldWithNameAsPascalCase(string fieldName)
        {
            var builder = new ContentTypeQueryResourceBuilder("someContentType");

            builder.WithNestedField(fieldName);

            Assert.Equal("someContentType { someNestedField {} }", builder.Build());
        }
        public void ShouldbeAbleToAddStringArgument()
        {
            var builder = new ContentTypeQueryResourceBuilder("someContentType");

            builder.WithQueryStringArgument("arg", "a string");

            Assert.Equal("someContentType(arg: \"a string\") {}", builder.Build());
        }
        public void ShouldbeAbleToAddArgument()
        {
            var builder = new ContentTypeQueryResourceBuilder("someContentType");

            builder.WithQueryArgument("arg", "1");

            Assert.Equal("someContentType(arg: 1) {}", builder.Build());
        }
        public void ShouldbeAbleToAddMultiInputArgument()
        {
            var builder = new ContentTypeQueryResourceBuilder("someContentType");

            builder.WithQueryArgument("arg", "a", "1");
            builder.WithQueryArgument("arg", "b", "2");

            Assert.Equal("someContentType(arg:{a: 1, b: 2}) {}", builder.Build());
        }
        public void ShouldbeAbleToAddNestedFieldsMultipleLevelsDeep()
        {
            var builder = new ContentTypeQueryResourceBuilder("someContentType");

            builder.WithField("field");
            builder.WithNestedField("nestedField").WithNestedField("nestednestedField").WithField("nestedChild");

            Assert.Equal("someContentType { field nestedField { nestednestedField { nestedChild } } }", builder.Build());
        }
        public void ShouldbeAbleToCombineNonNestedAndNestedFields()
        {
            var builder = new ContentTypeQueryResourceBuilder("someContentType");

            builder.WithField("field");
            builder.WithNestedField("nestedField").WithField("nestedChild");

            Assert.Equal("someContentType { field nestedField { nestedChild } }", builder.Build());
        }
        public void ShouldNotBeAbleToAddDuplicateArguments()
        {
            var builder = new ContentTypeQueryResourceBuilder("someContentType");

            builder.WithQueryArgument("arg", "a");

            Assert.Throws <Exception>(() => builder.WithQueryArgument("arg", "b"));
            Assert.Throws <Exception>(() => builder.WithQueryArgument("arg", "b", "2"));
            Assert.Throws <Exception>(() => builder.WithNestedQueryArgument("arg", "b", "2"));
        }
        public override async Task InitializeAsync(PermissionsContext permissionsContext = null)
        {
            await base.InitializeAsync();

            var body = new ContentTypeQueryResourceBuilder("blogPost")
                       .WithField("contentItemId").Build() +
                       new ContentTypeQueryResourceBuilder("blog")
                       .WithField("contentItemId").Build() +
                       new ContentTypeQueryResourceBuilder("taxonomy")
                       .WithField("contentItemId").Build();

            var result = await GraphQLClient.Content.Query(body);

            var blogPostContentItemId = result["data"]["blogPost"].First["contentItemId"].ToString();

            var content = await Client.GetAsync($"api/content/{blogPostContentItemId}");

            BlogPost = await content.Content.ReadAsAsync <ContentItem>();

            BlogContentItemId = result["data"]["blog"].First["contentItemId"].ToString();

            TagsTaxonomyContentItemId = result["data"]["taxonomy"][1]["contentItemId"].ToString();
        }