public async Task <ActionResult> Index() { IDeliveryClient c = DeliveryClientBuilder.WithProjectId("975bf280-fd91-488c-994c-2f04416e5ee3").Build(); var i = await c.GetItemAsync("on_roasts"); return(View()); }
public async void GetItemsAsync_SerializeAndDeserialize() { // Arrange string url = $"{_baseUrl}/items"; _mockHttp .When(url) .WithQueryString("system.type=article") .Respond("application/json", await File.ReadAllTextAsync(Path.Combine(Environment.CurrentDirectory, $"Fixtures{Path.DirectorySeparatorChar}full_articles.json"))); var client = DeliveryClientBuilder.WithProjectId(_projectId).WithTypeProvider(new CustomTypeProvider()).WithDeliveryHttpClient(new DeliveryHttpClient(_mockHttp.ToHttpClient())).Build(); // Act var response = await client.GetItemsAsync <Article>(); var serializedResponse = response.ToBson(); var deserializedResponse = serializedResponse.FromBson <DeliveryItemListingResponse <Article> >(); // Assert item equality response.Should().BeEquivalentTo(deserializedResponse, o => o.IgnoringCyclicReferences().DateTimesBsonCorrection()); // Assert the first item - check collections and DateTimes var firstItem = response.Items.FirstOrDefault(); var firstDeserializedItem = deserializedResponse.Items.FirstOrDefault(); Assert.NotEmpty(firstDeserializedItem.TeaserImage); Assert.NotEmpty(firstDeserializedItem.Personas); Assert.Equal(firstItem.PostDate, firstDeserializedItem.PostDate); }
public void BuildWithOptionalSteps_ReturnsDeliveryClientWithSetInstances() { var mockModelProvider = A.Fake <IModelProvider>(); var mockRetryPolicyProvider = A.Fake <IRetryPolicyProvider>(); var mockPropertyMapper = A.Fake <IPropertyMapper>(); var mockContentLinkUrlResolver = A.Fake <IContentLinkUrlResolver>(); var mockInlineContentItemsProcessor = A.Fake <IInlineContentItemsProcessor>(); var mockDefaultInlineContentItemsResolver = A.Fake <IInlineContentItemsResolver <object> >(); var mockUnretrievedInlineContentItemsResolver = A.Fake <IInlineContentItemsResolver <UnretrievedContentItem> >(); var mockAnContentItemsResolver = A.Fake <IInlineContentItemsResolver <CompleteContentItemModel> >(); var mockTypeProvider = A.Fake <ITypeProvider>(); var mockDeliveryHttpClient = new DeliveryHttpClient(new MockHttpMessageHandler().ToHttpClient()); var deliveryClient = (Delivery.DeliveryClient)DeliveryClientBuilder .WithProjectId(ProjectId) .WithDeliveryHttpClient(mockDeliveryHttpClient) .WithContentLinkUrlResolver(mockContentLinkUrlResolver) .WithInlineContentItemsProcessor(mockInlineContentItemsProcessor) .WithInlineContentItemsResolver(mockDefaultInlineContentItemsResolver) .WithInlineContentItemsResolver(mockUnretrievedInlineContentItemsResolver) .WithInlineContentItemsResolver(mockAnContentItemsResolver) .WithModelProvider(mockModelProvider) .WithPropertyMapper(mockPropertyMapper) .WithRetryPolicyProvider(mockRetryPolicyProvider) .WithTypeProvider(mockTypeProvider) .Build(); Assert.Equal(ProjectId, deliveryClient.DeliveryOptions.CurrentValue.ProjectId); Assert.Equal(mockModelProvider, deliveryClient.ModelProvider); Assert.Equal(mockRetryPolicyProvider, deliveryClient.RetryPolicyProvider); Assert.Equal(mockTypeProvider, deliveryClient.TypeProvider); Assert.Equal(mockDeliveryHttpClient, deliveryClient.DeliveryHttpClient); }
public async Task IntegrationTest(bool cmApi) { var mockHttp = new MockHttpMessageHandler(); mockHttp.When("https://deliver.kontent.ai/*") .Respond("application/json", File.ReadAllText(Path.Combine(AppContext.BaseDirectory, "Fixtures/types.json"))); var httpClient = mockHttp.ToHttpClient(); var mockOptions = new Mock <IOptions <CodeGeneratorOptions> >(); mockOptions.Setup(x => x.Value).Returns(new CodeGeneratorOptions { Namespace = "CustomNamespace", OutputDir = TEMP_DIR, ContentManagementApi = cmApi }); var client = DeliveryClientBuilder.WithProjectId(PROJECT_ID).WithDeliveryHttpClient(new DeliveryHttpClient(httpClient)).Build(); var codeGenerator = new CodeGenerator(mockOptions.Object, client); await codeGenerator.GenerateContentTypeModels(); await codeGenerator.GenerateTypeProvider(); Assert.True(Directory.GetFiles(Path.GetFullPath(TEMP_DIR)).Length > 10); foreach (var filepath in Directory.EnumerateFiles(Path.GetFullPath(TEMP_DIR))) { Assert.DoesNotContain(".Generated.cs", Path.GetFileName(filepath)); } // Cleanup Directory.Delete(TEMP_DIR, true); }
public async void InitializeMultipleInlineContentItemsResolvers() { string url = $"{_baseUrl}/items/"; const string tweetPrefix = "Tweet resolver: "; const string hostedVideoPrefix = "Video resolver: "; _mockHttp .When($"{url}{"coffee_beverages_explained"}") .Respond("application/json", File.ReadAllText(Path.Combine(Environment.CurrentDirectory, $"Fixtures{Path.DirectorySeparatorChar}DeliveryClient{Path.DirectorySeparatorChar}coffee_beverages_explained.json"))); var deliveryClient = DeliveryClientBuilder .WithProjectId(_guid) .WithInlineContentItemsResolver(InlineContentItemsResolverFactory.Instance .ResolveTo <Tweet>(tweet => tweetPrefix + tweet.TweetLink)) .WithInlineContentItemsResolver(InlineContentItemsResolverFactory.Instance .ResolveTo <HostedVideo>(video => hostedVideoPrefix + video.VideoHost.First().Name)) .WithTypeProvider(new CustomTypeProvider()) .WithHttpClient(_mockHttp.ToHttpClient()) .Build(); var article = await deliveryClient.GetItemAsync <Article>("coffee_beverages_explained"); Assert.Contains(tweetPrefix, article.Item.BodyCopy); Assert.Contains(hostedVideoPrefix, article.Item.BodyCopy); }
public async Task Index_ReturnsAViewResult_WithAnArticle() { // Arrange var config = new Mock <IConfiguration>(); MockHttpMessageHandler mockHttp = new MockHttpMessageHandler(); mockHttp.When($"https://deliver.kontent.ai/975bf280-fd91-488c-994c-2f04416e5ee3/items?elements.url_pattern=on_roasts&depth=1&language={CultureInfo.CurrentCulture}&system.type=article") .Respond("application/json", File.ReadAllText(Path.Combine(Environment.CurrentDirectory, $"on_roasts.json"))); IDeliveryClient client = DeliveryClientBuilder.WithProjectId("975bf280-fd91-488c-994c-2f04416e5ee3").WithDeliveryHttpClient(new DeliveryHttpClient(mockHttp.ToHttpClient())).WithTypeProvider(new CustomTypeProvider()).Build(); var factory = new Mock <IDeliveryClientFactory>(); factory.Setup(m => m.Get()).Returns(client); ArticlesController controller = new ArticlesController(config.Object, factory.Object); // Act var result = await controller.Show("on_roasts"); // Assert var viewResult = Assert.IsType <ViewResult>(result); var viewModel = Assert.IsType <Article>(viewResult.ViewData.Model); Assert.Equal("On Roasts", viewModel.Title); }
public static async Task <Song> GetSong(string kontentProjectId, int trackNumber) { IDeliveryClient client = DeliveryClientBuilder.WithProjectId(kontentProjectId).Build(); DeliveryItemListingResponse <Song> song = await client.GetItemsAsync <Song>(new EqualsFilter("elements.track_number", trackNumber.ToString())); return(song.Items[0]); }
public IDeliveryClient GetDeliveryClient() { if (_deliveryClient == null) { var projectId = _configuration.GetValue <string>("DeliveryOptions:ProjectId"); _deliveryClient = DeliveryClientBuilder.WithProjectId(projectId).WithHttpClient(_httpClient).WithTypeProvider(_typeProvider).Build(); } return(_deliveryClient); }
public void BuildWithOptionalStepsAndCustomProvider_ReturnsDeliveryClientWithSetInstances() { var modelProvider = new FakeModelProvider(); var deliveryClient = (Delivery.DeliveryClient)DeliveryClientBuilder .WithProjectId(ProjectId) .WithModelProvider(modelProvider) .Build(); Assert.Equal(modelProvider, deliveryClient.ModelProvider); }
public static async Task Main(string[] args) { IDeliveryClient client = DeliveryClientBuilder.WithProjectId(ProjectId).WithTypeProvider(new CustomTypeProvider()).Build(); var articles = await client.GetItemsAsync <Article>(); foreach (var article in articles.Items) { Console.WriteLine($"The article '{article.Title}' was posted on {article.PostDate.Value.ToShortDateString()}."); } Console.ReadLine(); }
public async Task <ViewResult> Index() { IDeliveryClient client = DeliveryClientBuilder .WithProjectId("<ProjectID>") .Build(); var response = await client.GetItemAsync <Homepage>( "employers", new DepthParameter(3) ); return(View(response.Item)); }
public async Task IntegrationTest_RunAsync_GeneratePartials_CorrectFiles() { var mockHttp = new MockHttpMessageHandler(); mockHttp.When("https://deliver.kontent.ai/*") .Respond("application/json", await File.ReadAllTextAsync(Path.Combine(AppContext.BaseDirectory, "Fixtures/delivery_types.json"))); var httpClient = mockHttp.ToHttpClient(); const string transformFilename = "Generated"; var mockOptions = new Mock <IOptions <CodeGeneratorOptions> >(); mockOptions.Setup(x => x.Value).Returns(new CodeGeneratorOptions { DeliveryOptions = new DeliveryOptions { ProjectId = ProjectId }, Namespace = "CustomNamespace", OutputDir = TempDir, FileNameSuffix = transformFilename, GeneratePartials = true, WithTypeProvider = false, StructuredModel = false, ManagementApi = false }); var deliveryClient = DeliveryClientBuilder.WithProjectId(ProjectId) .WithDeliveryHttpClient(new DeliveryHttpClient(httpClient)).Build(); var codeGenerator = new DeliveryCodeGenerator(mockOptions.Object, new FileSystemOutputProvider(mockOptions.Object), deliveryClient); await codeGenerator.RunAsync(); var allFilesCount = Directory.GetFiles(Path.GetFullPath(TempDir), "*.cs").Length; var generatedCount = Directory.GetFiles(Path.GetFullPath(TempDir), $"*.{transformFilename}.cs").Length; Assert.Equal(allFilesCount, generatedCount * 2); foreach (var filepath in Directory.EnumerateFiles(Path.GetFullPath(TempDir), $"*.{transformFilename}.cs")) { var customFileExists = File.Exists(filepath.Replace($".{transformFilename}", "")); Assert.True(customFileExists); } // Cleanup Directory.Delete(TempDir, true); }
public static async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Function, "get", Route = null)] HttpRequest req, ILogger log, ExecutionContext context) { log.LogInformation("C# HTTP trigger function processed a request."); var config = new ConfigurationBuilder() .SetBasePath(context.FunctionAppDirectory) .AddJsonFile("local.settings.json", optional: true, reloadOnChange: true) .AddEnvironmentVariables() .Build(); IDeliveryClient client = DeliveryClientBuilder.WithProjectId(config["KontentProjectId"]).Build(); DeliveryItemListingResponse <Song> listingResponse = await client.GetItemsAsync <Song>(); var songs = listingResponse.Items.Select(x => x.Title).ToArray(); string API_KEY = config["NEXMO_API_KEY"]; string API_SECRET = config["NEXMO_API_SECRET"]; var nexmoClient = new Client(creds: new Nexmo.Api.Request.Credentials( nexmoApiKey: API_KEY, nexmoApiSecret: API_SECRET)); var results = nexmoClient.SMS.Send(new SMS.SMSRequest { from = req.Query["to"], to = req.Query["msisdn"], text = ConvertToNumberedList(songs) }); return(new OkObjectResult(songs)); string ConvertToNumberedList(IEnumerable <string> songs) { StringBuilder sb = new StringBuilder(); int songNumber = 1; foreach (var s in songs) { sb.AppendLine($"{songNumber++} - {s}"); } return(sb.ToString()); } }
private static async Task <AbstractResponse> GetAbstractResponseInstance(bool shouldBeStaleContent) { var itemsResponse = new { items = Enumerable.Empty <object>(), modular_content = new Dictionary <string, object>() }; var staleContentHeaderValue = shouldBeStaleContent ? "1" : "0"; var mockHandler = new MockHttpMessageHandler(); var responseHeaders = new[] { new KeyValuePair <string, string>("X-Stale-Content", staleContentHeaderValue) }; mockHandler.When("*").Respond(responseHeaders, "application/json", JsonConvert.SerializeObject(itemsResponse)); var httpClient = mockHandler.ToHttpClient(); var client = DeliveryClientBuilder.WithProjectId(Guid.NewGuid()).WithHttpClient(httpClient).Build(); return(await client.GetItemsAsync()); }
public async Task Setup() { var projectId = Guid.NewGuid(); var baseUrl = $"https://deliver.kontent.ai/{projectId}"; var mockHttp = new MockHttpMessageHandler(); mockHttp .When($"{baseUrl}/items/on_roasts") .Respond("application/json", await File.ReadAllTextAsync(Path.Combine(Environment.CurrentDirectory, $"Fixtures{Path.DirectorySeparatorChar}on_roasts.json"))); mockHttp .When($"{baseUrl}/items") .WithQueryString("system.type=article") .Respond("application/json", await File.ReadAllTextAsync(Path.Combine(Environment.CurrentDirectory, $"Fixtures{Path.DirectorySeparatorChar}full_articles.json"))); _client = DeliveryClientBuilder.WithProjectId(projectId).WithTypeProvider(new CustomTypeProvider()).WithDeliveryHttpClient(new DeliveryHttpClient(mockHttp.ToHttpClient())).Build(); }
public async Task IntegrationTestWithGeneratePartials(bool cmApi) { var mockHttp = new MockHttpMessageHandler(); mockHttp.When("https://deliver.kontent.ai/*") .Respond("application/json", File.ReadAllText(Path.Combine(AppContext.BaseDirectory, "Fixtures/types.json"))); var httpClient = mockHttp.ToHttpClient(); const string transformFilename = "Generated"; var mockOptions = new Mock <IOptions <CodeGeneratorOptions> >(); mockOptions.Setup(x => x.Value).Returns(new CodeGeneratorOptions { DeliveryOptions = new DeliveryOptions { ProjectId = PROJECT_ID }, Namespace = "CustomNamespace", OutputDir = TEMP_DIR, FileNameSuffix = transformFilename, GeneratePartials = true, ContentManagementApi = cmApi }); var client = DeliveryClientBuilder.WithProjectId(PROJECT_ID).WithDeliveryHttpClient(new DeliveryHttpClient(httpClient)).Build(); var codeGenerator = new CodeGenerator(mockOptions.Object, client); await codeGenerator.GenerateContentTypeModels(); var allFilesCount = Directory.GetFiles(Path.GetFullPath(TEMP_DIR), "*.cs").Length; var generatedCount = Directory.GetFiles(Path.GetFullPath(TEMP_DIR), $"*.{transformFilename}.cs").Length; Assert.Equal(allFilesCount, generatedCount * 2); foreach (var filepath in Directory.EnumerateFiles(Path.GetFullPath(TEMP_DIR), $"*.{transformFilename}.cs")) { var customFileExists = File.Exists(filepath.Replace($".{transformFilename}", "")); Assert.True(customFileExists); } // Cleanup Directory.Delete(TEMP_DIR, true); }
public void BuildWithoutOptionalSteps_ReturnsDeliveryClientWithDefaultImplementations() { var expectedResolvableInlineContentItemsTypes = new[] { typeof(object), typeof(UnretrievedContentItem), typeof(UnknownContentItem) }; var deliveryClient = (Delivery.DeliveryClient)DeliveryClientBuilder .WithProjectId(_guid) .Build(); var actualResolvableInlineContentItemTypes = GetResolvableInlineContentItemTypes(deliveryClient); Assert.NotNull(deliveryClient.ModelProvider); Assert.NotNull(deliveryClient.TypeProvider); Assert.NotNull(deliveryClient.DeliveryHttpClient); Assert.NotNull(deliveryClient.RetryPolicyProvider); Assert.Equal(expectedResolvableInlineContentItemsTypes, actualResolvableInlineContentItemTypes); }
public static async Task <string> GetStringifiedSongList(string kontentProjectId) { IDeliveryClient client = DeliveryClientBuilder.WithProjectId(kontentProjectId).Build(); DeliveryItemListingResponse <Song> listingResponse = await client.GetItemsAsync <Song>(); var songs = listingResponse.Items.OrderBy(x => x.TrackNumber).Select(x => $"{x.TrackNumber} - {x.Title}").ToArray(); return(ConvertToNumberedList(songs)); string ConvertToNumberedList(IEnumerable <string> songList) { StringBuilder sb = new StringBuilder(); foreach (var s in songList) { sb.AppendLine(s); } return(sb.ToString()); } }
public void IntegrationTestWithGeneratedSuffix(bool cmApi) { var mockHttp = new MockHttpMessageHandler(); mockHttp.When("https://deliver.kontent.ai/*") .Respond("application/json", File.ReadAllText(Path.Combine(AppContext.BaseDirectory, "Fixtures/types.json"))); var httpClient = mockHttp.ToHttpClient(); const string transformFilename = "Generated"; var mockOptions = new Mock <IOptions <CodeGeneratorOptions> >(); mockOptions.Setup(x => x.Value).Returns(new CodeGeneratorOptions { DeliveryOptions = new DeliveryOptions { ProjectId = PROJECT_ID }, Namespace = "CustomNamespace", OutputDir = TEMP_DIR, FileNameSuffix = transformFilename, ContentManagementApi = cmApi }); var client = DeliveryClientBuilder.WithProjectId(PROJECT_ID).WithHttpClient(httpClient).Build(); var codeGenerator = new CodeGenerator(mockOptions.Object, client); codeGenerator.GenerateContentTypeModels(); Assert.True(Directory.GetFiles(Path.GetFullPath(TEMP_DIR)).Length > 10); foreach (var filepath in Directory.EnumerateFiles(Path.GetFullPath(TEMP_DIR))) { Assert.EndsWith($".{transformFilename}.cs", Path.GetFileName(filepath)); } // Cleanup Directory.Delete(TEMP_DIR, true); }
public async Task IntegrationTest_RunAsync_CorrectFiles() { var mockHttp = new MockHttpMessageHandler(); mockHttp.When("https://deliver.kontent.ai/*") .Respond("application/json", await File.ReadAllTextAsync(Path.Combine(AppContext.BaseDirectory, "Fixtures/delivery_types.json"))); var httpClient = mockHttp.ToHttpClient(); var mockOptions = new Mock <IOptions <CodeGeneratorOptions> >(); mockOptions.Setup(x => x.Value).Returns(new CodeGeneratorOptions { DeliveryOptions = new DeliveryOptions { ProjectId = ProjectId }, Namespace = "CustomNamespace", OutputDir = TempDir, ManagementApi = false, GeneratePartials = false, WithTypeProvider = false, StructuredModel = false }); var deliveryClient = DeliveryClientBuilder.WithProjectId(ProjectId).WithDeliveryHttpClient(new DeliveryHttpClient(httpClient)).Build(); var codeGenerator = new DeliveryCodeGenerator(mockOptions.Object, new FileSystemOutputProvider(mockOptions.Object), deliveryClient); await codeGenerator.RunAsync(); Assert.Equal(NumberOfContentTypes, Directory.GetFiles(Path.GetFullPath(TempDir)).Length); Assert.NotEmpty(Directory.EnumerateFiles(Path.GetFullPath(TempDir), "*.Generated.cs")); Assert.NotEmpty(Directory.EnumerateFiles(Path.GetFullPath(TempDir)).Where(p => !p.Contains("*.Generated.cs"))); Assert.Empty(Directory.EnumerateFiles(Path.GetFullPath(TempDir), "*TypeProvider.cs")); // Cleanup Directory.Delete(TempDir, true); }
public void BuildWithOptionalStepsWithCustomResolvers_ReturnsDeliveryClientWithSetInstances() { var mockDefaultInlineContentItemsResolver = A.Fake <IInlineContentItemsResolver <object> >(); var mockUnretrievedInlineContentItemsResolver = A.Fake <IInlineContentItemsResolver <UnretrievedContentItem> >(); var mockCompleteContentItemsResolver = A.Fake <IInlineContentItemsResolver <CompleteContentItemModel> >(); var expectedResolvableInlineContentItemsTypes = new[] { typeof(object), typeof(UnretrievedContentItem), typeof(CompleteContentItemModel), typeof(UnknownContentItem) }; var deliveryClient = (Delivery.DeliveryClient)DeliveryClientBuilder .WithProjectId(ProjectId) .WithInlineContentItemsResolver(mockDefaultInlineContentItemsResolver) .WithInlineContentItemsResolver(mockUnretrievedInlineContentItemsResolver) .WithInlineContentItemsResolver(mockCompleteContentItemsResolver) .Build(); var actualResolvableInlineContentItemTypes = GetResolvableInlineContentItemTypes(deliveryClient); Assert.Equal(ProjectId, deliveryClient.DeliveryOptions.ProjectId); Assert.Equal(expectedResolvableInlineContentItemsTypes, actualResolvableInlineContentItemTypes); }
public async void GetItemAsync_SerializeAndDeserialize() { // Arrange string url = $"{_baseUrl}/items/brazil_natural_barra_grande"; _mockHttp .When(url) .Respond("application/json", await File.ReadAllTextAsync(Path.Combine(Environment.CurrentDirectory, $"Fixtures{Path.DirectorySeparatorChar}brazil_natural_barra_grande.json"))); var client = DeliveryClientBuilder.WithProjectId(_projectId).WithTypeProvider(new CustomTypeProvider()).WithDeliveryHttpClient(new DeliveryHttpClient(_mockHttp.ToHttpClient())).Build(); // Act var response = await client.GetItemAsync <Coffee>("brazil_natural_barra_grande"); var serializedResponse = response.ToBson(); var deserializedResponse = serializedResponse.FromBson <DeliveryItemResponse <Coffee> >(); // Assert item equality (apply precision correction for DateTime when deserializing) response.Should().BeEquivalentTo(deserializedResponse, o => o.DateTimesBsonCorrection()); // Check that collections are ok Assert.NotEmpty(deserializedResponse.Item.Image); Assert.NotEmpty(deserializedResponse.Item.Processing); }
public KontentHelper(IConfiguration configuration) { var projectId = configuration["KontentProjectID"]; this.deliveryClient = DeliveryClientBuilder.WithProjectId(projectId).Build(); }
public void BuildWithProjectId_ReturnsDeliveryClientWithProjectIdSet() { var deliveryClient = (Delivery.DeliveryClient)DeliveryClientBuilder.WithProjectId(ProjectId).Build(); Assert.Equal(ProjectId, deliveryClient.DeliveryOptions.ProjectId); }
public void BuildWithOptionsAndNullPropertyMapper_ThrowsArgumentNullException() { var builderStep = DeliveryClientBuilder.WithProjectId(_guid); Assert.Throws <ArgumentNullException>(() => builderStep.WithPropertyMapper(null)); }
public void BuildWithOptionsAndNullInlineContentItemsProcessor_ThrowsArgumentNullException() { var builderStep = DeliveryClientBuilder.WithProjectId(_guid); Assert.Throws <ArgumentNullException>(() => builderStep.WithInlineContentItemsProcessor(null)); }
public void BuildWithOptionsAndNullContentLinUrlResolver_ThrowsArgumentNullException() { var builderStep = DeliveryClientBuilder.WithProjectId(_guid); Assert.Throws <ArgumentNullException>(() => builderStep.WithContentLinkUrlResolver(null)); }
public void BuildWithOptionsAndNullResiliencePolicyProvider_ThrowsArgumentNullException() { var builderStep = DeliveryClientBuilder.WithProjectId(_guid); Assert.Throws <ArgumentNullException>(() => builderStep.WithRetryPolicyProvider(null)); }