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); }
/// <summary> /// Constructs delivery client /// </summary> private IDeliveryClient GetDeliveryClient(string projectId, bool usePreview, string previewApiKey) { var client = DeliveryClientBuilder.WithOptions( builder => { var config = builder .WithProjectId(projectId); if (!usePreview) { // do not use preview return config.UseProductionApi.WaitForLoadingNewContent .Build(); } if (string.IsNullOrEmpty(previewApiKey)) { throw new ArgumentNullException($"Preview api key is not set for project '{projectId}'"); } // use preview return config.UsePreviewApi(previewApiKey).WaitForLoadingNewContent .Build(); }) .WithInlineContentItemsResolver(new DefaultContentItemResolver()) .WithTypeProvider(new CustomTypeProvider()) .Build(); return client; }
private IDeliveryClient GetCachedDeliveryClient() { mockHttp.When($"{baseUrl}/items") .WithQueryString(new[] { new KeyValuePair <string, string>("system.type", Article.Codename), new KeyValuePair <string, string>("limit", "3"), new KeyValuePair <string, string>("depth", "0"), new KeyValuePair <string, string>("order", "elements.post_date[asc]") }) .Respond("application/json", File.ReadAllText(Path.Combine(Environment.CurrentDirectory, "Fixtures\\CachedDeliveryClient\\articles.json"))); var httpClient = mockHttp.ToHttpClient(); var projectOptions = Options.Create(new ProjectOptions { CacheTimeoutSeconds = 60, DeliveryOptions = new DeliveryOptions { ProjectId = guid } }); var memoryCacheOptions = Options.Create(new MemoryCacheOptions { Clock = new TestClock(), ExpirationScanFrequency = new TimeSpan(0, 0, 5) }); var cacheManager = new ReactiveCacheManager(projectOptions, new MemoryCache(memoryCacheOptions), new DependentFormatResolver(), new WebhookListener()); return(new CachedDeliveryClient(projectOptions, cacheManager, DeliveryClientBuilder.WithOptions(o => projectOptions.Value.DeliveryOptions).WithCodeFirstTypeProvider(new Models.CustomTypeProvider()).WithHttpClient(httpClient).Build())); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { // Adds services required for using options. services.AddOptions(); // Register the IConfiguration instance which ProjectOptions binds against. services.Configure <ProjectOptions>(Configuration); var deliveryOptions = new DeliveryOptions(); Configuration.GetSection(nameof(DeliveryOptions)).Bind(deliveryOptions); services.AddSingleton <IWebhookListener>(sp => new WebhookListener()); services.AddSingleton <IDependentTypesResolver>(sp => new DependentFormatResolver()); services.AddSingleton <ICacheManager>(sp => new ReactiveCacheManager( sp.GetRequiredService <IOptions <ProjectOptions> >(), sp.GetRequiredService <IMemoryCache>(), sp.GetRequiredService <IDependentTypesResolver>(), sp.GetRequiredService <IWebhookListener>())); services.AddScoped <KenticoCloudSignatureActionFilter>(); services.AddSingleton <IDeliveryClient>(sp => new CachedDeliveryClient( sp.GetRequiredService <IOptions <ProjectOptions> >(), sp.GetRequiredService <ICacheManager>(), DeliveryClientBuilder.WithOptions(_ => deliveryOptions) .WithCodeFirstTypeProvider(new CustomTypeProvider()) .WithContentLinkUrlResolver(new CustomContentLinkUrlResolver()) .Build()) ); HtmlHelperExtensions.ProjectOptions = services.BuildServiceProvider().GetService <IOptions <ProjectOptions> >(); services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1); }
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 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); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { // Adds services required for using options. services.AddOptions(); // Register the IConfiguration instance which ProjectOptions binds against. services.Configure <ProjectOptions>(Configuration); var deliveryOptions = new DeliveryOptions(); Configuration.GetSection(nameof(DeliveryOptions)).Bind(deliveryOptions); IDeliveryClient BuildBaseClient(IServiceProvider sp) => DeliveryClientBuilder .WithOptions(_ => deliveryOptions) .WithTypeProvider(new CustomTypeProvider()) .WithContentLinkUrlResolver(new CustomContentLinkUrlResolver()) .Build(); // Use cached client version based on the use case services.AddCachingClient(BuildBaseClient, options => { options.StaleContentExpiration = TimeSpan.FromSeconds(2); options.DefaultExpiration = TimeSpan.FromMinutes(10); }); //services.AddWebhookInvalidatedCachingClient(BuildBaseClient, options => //{ // options.StaleContentExpiration = TimeSpan.FromSeconds(2); // options.DefaultExpiration = TimeSpan.FromHours(24); //}); HtmlHelperExtensions.ProjectOptions = Configuration.Get <ProjectOptions>(); services.AddControllersWithViews(); }
public static IServiceCollection AddKenticoDelivery(this IServiceCollection services, IConfiguration configuration) { services.Configure <KenticoOptions>(configuration.GetSection("KenticoOptions")) .AddSingleton <ICacheManager, CacheManager>() .AddTransient <IDependencyResolver, DependencyResolver>() .AddTransient <ICodeFirstTypeProvider, ContentTypeProvider>() .AddTransient <IContentLinkUrlResolver, ContentLinkUrlResolver>() .AddDeliveryClient(configuration) .AddScoped <IDeliveryClient>(sp => new CachedDeliveryClient( sp.GetRequiredService <ICacheManager>(), DeliveryClientBuilder .WithOptions(_ => sp.GetRequiredService <IOptionsSnapshot <KenticoOptions> >().Value) .WithCodeFirstTypeProvider(sp.GetRequiredService <ICodeFirstTypeProvider>()) .WithContentLinkUrlResolver(sp.GetRequiredService <IContentLinkUrlResolver>()) .Build(), CreatePreviewDeliveryClientOrNull(sp), sp.GetRequiredService <IDependencyResolver>() )); var kenticoOptions = services.BuildServiceProvider().GetRequiredService <IOptionsSnapshot <KenticoOptions> >().Value; HtmlHelperExtensions.ResponsiveImagesEnabled = kenticoOptions.ResponsiveImagesEnabled; HtmlHelperExtensions.ResponsiveWidths = kenticoOptions.ResponsiveWidths; return(services); }
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); }
private CachedDeliveryClient GetCachedDeliveryClient(Action mockAction = null, Func <RequestCount, RequestCount> mockFunc = null, RequestCount actualHttpRequests = null) { HttpClient httpClient = null; DeliveryOptions deliveryOptions = null; if (mockAction != null) { InitClientPrerequisites(out httpClient, out deliveryOptions, mockAction: mockAction); } else if (mockFunc != null && actualHttpRequests != null) { InitClientPrerequisites(out httpClient, out deliveryOptions, mockFunc: mockFunc, actualHttpRequests: actualHttpRequests); } var projectOptions = Options.Create(new ProjectOptions { CacheTimeoutSeconds = 60, DeliveryOptions = deliveryOptions }); var memoryCacheOptions = Options.Create(new MemoryCacheOptions { Clock = new TestClock(), ExpirationScanFrequency = new TimeSpan(0, 0, 5) }); var cacheManager = new ReactiveCacheManager(projectOptions, new MemoryCache(memoryCacheOptions), new DependentFormatResolver(), new WebhookListener()); return(new CachedDeliveryClient(projectOptions, cacheManager , DeliveryClientBuilder.WithOptions(o => deliveryOptions).WithCodeFirstTypeProvider(new Models.CustomTypeProvider()).WithHttpClient(httpClient).Build())); }
private IDeliveryClient CreateClient() { var builder = DeliveryClientBuilder .WithOptions(options => { var opt2 = options.WithProjectId(ProjectId); if (!string.IsNullOrWhiteSpace(PreviewApiKey)) { return(opt2.UsePreviewApi(PreviewApiKey).Build()); } if (!string.IsNullOrEmpty(ProductionApiKey)) { return(opt2.UseProductionApi(ProductionApiKey).Build()); } return(opt2.UseProductionApi().Build()); }); foreach (var action in ConfigureClientActions) { action(builder); } return(builder.Build()); }
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 Scenario(IMemoryCache memoryCache, HttpClient httpClient, DeliveryOptions deliveryOptions, Dictionary <string, int> requestCounter) { _requestCounter = requestCounter; _cacheManager = new CacheManager(memoryCache, Options.Create(new CacheOptions())); var baseClient = DeliveryClientBuilder.WithOptions(_ => deliveryOptions).WithHttpClient(httpClient).Build(); CachingClient = new CachingDeliveryClient(_cacheManager, baseClient); }
public Scenario(IDistributedCache distributedCache, HttpClient httpClient, DeliveryOptions deliveryOptions, Dictionary <string, int> requestCounter) { _requestCounter = requestCounter; _cacheManager = new DistributedCacheManager(distributedCache, Options.Create(new DeliveryCacheOptions())); var baseClient = DeliveryClientBuilder.WithOptions(_ => deliveryOptions).WithDeliveryHttpClient(new DeliveryHttpClient(httpClient)).Build(); CachingClient = new DeliveryClientCache(_cacheManager, baseClient); }
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 MovieListing(KontentKeys keys) { client = DeliveryClientBuilder .WithOptions(builder => builder .WithProjectId(keys.ProjectId) .UsePreviewApi(keys.PreviewApiKey) .Build()) .Build(); }
private IDeliveryClient GetDeliveryClient() => DeliveryClientBuilder .WithOptions(builder => builder .WithProjectId(coreContext.Region.ProjectId) .UseProductionApi(coreContext.Region.DeliveryApiSecureAccessKey) .Build()) .WithInlineContentItemsResolver(new Field()) .WithTypeProvider(new KenticoKontentTypeProvider()) .Build();
public BaseController() { Client = DeliveryClientBuilder .WithOptions(builder => builder .WithProjectId("09fc0115-dd4d-00c7-5bd9-5f73836aee81") .UseProductionApi .WithMaxRetryAttempts(5) .Build()) .Build(); }
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 Scenario(IMemoryCache memoryCache, CacheExpirationType cacheExpirationType, HttpClient httpClient, DeliveryOptions deliveryOptions, Dictionary <string, int> requestCounter) { _requestCounter = requestCounter; _cacheManager = new MemoryCacheManager(memoryCache, Options.Create(new DeliveryCacheOptions { DefaultExpirationType = cacheExpirationType })); var baseClient = DeliveryClientBuilder.WithOptions(_ => deliveryOptions).WithDeliveryHttpClient(new DeliveryHttpClient(httpClient)).Build(); CachingClient = new DeliveryClientCache(_cacheManager, baseClient); }
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 static IDeliveryClient CreateDeliveryClient() { // Use the provider to get environment variables ConfigurationManagerProvider provider = new ConfigurationManagerProvider(); // Build DeliveryOptions with default or explicit values var options = provider.GetDeliveryOptions(); options.ProjectId = options.ProjectId ?? AppSettingProvider.DefaultProjectId.ToString(); var clientInstance = DeliveryClientBuilder.WithOptions(o => options) .WithTypeProvider(new CustomTypeProvider()) .WithContentLinkUrlResolver(new CustomContentLinkUrlResolver()).Build(); return(clientInstance); }
public void BuildWithDeliveryOptions_ReturnsDeliveryClientWithDeliveryOptions() { var guid = new Guid(ProjectId); var deliveryClient = (Delivery.DeliveryClient)DeliveryClientBuilder .WithOptions(builder => builder .WithProjectId(guid) .UsePreviewApi(PreviewApiKey) .WithCustomEndpoint(PreviewEndpoint) .Build() ).Build(); Assert.Equal(ProjectId, deliveryClient.DeliveryOptions.ProjectId); Assert.True(deliveryClient.DeliveryOptions.UsePreviewApi); Assert.Equal(PreviewEndpoint, deliveryClient.DeliveryOptions.PreviewEndpoint); }
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); }
private static void InitKontent(KontentConfig config) { ContentManagementOptions cmoptions = new ContentManagementOptions { ProjectId = config.ProjectID, ApiKey = config.ApiKey }; KontentHelper.Init( DeliveryClientBuilder .WithOptions(builder => builder .WithProjectId(config.ProjectID) .UsePreviewApi(config.PreviewKey) .Build()) .Build(), new ContentManagementClient(cmoptions)); }
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()); } }
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(); }