Ejemplo n.º 1
0
        public void QueryStringWithEnumerablesCanBeFormattedEnumerable()
        {
            var settings = new RefitSettings {
                UrlParameterFormatter = new TestEnumerableUrlParameterFormatter()
            };
            var fixture = new RequestBuilderImplementation(typeof(IDummyHttpApi), settings);

            var factory = fixture.BuildRequestFactoryForMethod("QueryWithEnumerable");

            var list = new List <int>
            {
                1, 2, 3
            };

            var output = factory(new object[] { list });

            var uri = new Uri(new Uri("http://api"), output.RequestUri);

            Assert.Equal("/query?numbers=1%2C2%2C3", uri.PathAndQuery);
        }
Ejemplo n.º 2
0
        public async Task HitTheNpmJs()
        {
            var mockHttp = new MockHttpMessageHandler();

            var settings = new RefitSettings {
                HttpMessageHandlerFactory = () => mockHttp
            };

            mockHttp.Expect(HttpMethod.Get, "https://registry.npmjs.org/congruence")
            .Respond("application/json", "{ '_id':'congruence', '_rev':'rev' , 'name':'name'}");



            var fixture = RestService.For <INpmJs>("https://registry.npmjs.org", settings);
            var result  = await fixture.GetCongruence();

            Assert.Equal("congruence", result._id);

            mockHttp.VerifyNoOutstandingExpectation();
        }
Ejemplo n.º 3
0
        public async Task GenericMethodOverloadTest4()
        {
            var mockHttp = new MockHttpMessageHandler();

            var settings = new RefitSettings
            {
                HttpMessageHandlerFactory = () => mockHttp
            };

            mockHttp.Expect(HttpMethod.Get, "https://httpbin.org/get")
            .WithHeaders("X-Refit", "99")
            .WithQueryString("param", "foo")
            .Respond("application/json", "{'url': 'https://httpbin.org/get', 'args': {'param': 'foo'}}");

            var fixture = RestService.For <IUseOverloadedGenericMethods <HttpBinGet, string, int> >("https://httpbin.org/", settings);

            var result = await fixture.Get("foo", 99);

            Assert.Equal("foo", result.Args["param"]);
        }
Ejemplo n.º 4
0
        public async Task GenericMethodOverloadTest2()
        {
            var mockHttp = new MockHttpMessageHandler();

            var settings = new RefitSettings
            {
                HttpMessageHandlerFactory = () => mockHttp
            };


            mockHttp.Expect(HttpMethod.Get, "https://httpbin.org/status/403")
            .Respond(HttpStatusCode.Forbidden);


            var fixture = RestService.For <IUseOverloadedGenericMethods <HttpBinGet, string, int> >("https://httpbin.org/", settings);

            var resp = await fixture.Get(403);

            Assert.Equal(HttpStatusCode.Forbidden, resp.StatusCode);
        }
Ejemplo n.º 5
0
        public async Task PostStringDefaultToRequestBin()
        {
            var mockHttp = new MockHttpMessageHandler();

            var settings = new RefitSettings
            {
                HttpMessageHandlerFactory = () => mockHttp
            };

            mockHttp.Expect(HttpMethod.Post, "http://httpbin.org/foo")
            .WithContent("raw string")
            .Respond(HttpStatusCode.OK);

            var fixture = RestService.For <IRequestBin>("http://httpbin.org/", settings);


            await fixture.PostRawStringDefault("raw string");

            mockHttp.VerifyNoOutstandingExpectation();
        }
Ejemplo n.º 6
0
        public async Task GenericMethodOverloadTest3()
        {
            var mockHttp = new MockHttpMessageHandler();

            var settings = new RefitSettings
            {
                HttpMessageHandlerFactory = () => mockHttp
            };

            mockHttp.Expect(HttpMethod.Get, "https://httpbin.org/get")
            .WithQueryString("someVal", "201")
            .Respond("application/json", "some-T-value");


            var fixture = RestService.For <IUseOverloadedGenericMethods <HttpBinGet, string, int> >("https://httpbin.org/", settings);

            var result = await fixture.Get <string>(201);

            Assert.Equal("some-T-value", result);
        }
Ejemplo n.º 7
0
        public CertifyClient(
            string apiKey,
            string apiSecret,
            CertifyClientOptions?options = null)
        {
            options ??= new();

            var refitSettings = new RefitSettings
            {
                ContentSerializer = new NewtonsoftJsonContentSerializer(
                    new JsonSerializerSettings
                {
                    MissingMemberHandling = MissingMemberHandling.Ignore,
                }),
            };

            _httpClient = new HttpClient(
                new AuthenticatedHttpClientHandler(
                    apiKey ?? throw new ArgumentNullException(nameof(apiKey)),
                    apiSecret ?? throw new ArgumentNullException(nameof(apiSecret))
                    ))
            {
                // This address should NOT end in "/" as the interface method paths are added to the end of this and Refit requires they start with "/"
                BaseAddress = new Uri("https://api.certify.com/v1"),
                Timeout     = options.Timeout
            };

            CpdLists           = RestService.For <ICpdLists>(_httpClient, refitSettings);
            Departments        = RestService.For <IDepartments>(_httpClient, refitSettings);
            EmpGlds            = RestService.For <IEmpGlds>(_httpClient, refitSettings);
            ExpenseCategories  = RestService.For <IExpenseCategories>(_httpClient, refitSettings);
            ExpenseReports     = RestService.For <IExpenseReports>(_httpClient, refitSettings);
            Expenses           = RestService.For <IExpenses>(_httpClient, refitSettings);
            ExpenseReportGlds  = RestService.For <IExpenseReportGlds>(_httpClient, refitSettings);
            InvoiceReports     = RestService.For <IInvoiceReports>(_httpClient, refitSettings);
            Invoices           = RestService.For <IInvoices>(_httpClient, refitSettings);
            MileageRates       = RestService.For <IMileageRates>(_httpClient, refitSettings);
            MileageRateDetails = RestService.For <IMileageRateDetails>(_httpClient, refitSettings);
            Receipts           = RestService.For <IReceipts>(_httpClient, refitSettings);
            Users = RestService.For <IUsers>(_httpClient, refitSettings);
        }
Ejemplo n.º 8
0
        public async Task GenericMethodOverloadTest()
        {
            var mockHttp = new MockHttpMessageHandler();

            var settings = new RefitSettings
            {
                HttpMessageHandlerFactory = () => mockHttp
            };

            mockHttp.Expect(HttpMethod.Get, "https://httpbin.org/")
            .Respond(HttpStatusCode.OK, "text/html", "OK");

            mockHttp.Expect(HttpMethod.Get, "https://httpbin.org/status/403")
            .Respond(HttpStatusCode.Forbidden);

            mockHttp.Expect(HttpMethod.Get, "https://httpbin.org/get")
            .WithHeaders("X-Refit", "99")
            .WithQueryString("param", "foo")
            .Respond("application/json", "{'url': 'https://httpbin.org/get', 'args': {'param': 'foo'}}");

            mockHttp.Expect(HttpMethod.Get, "https://httpbin.org/get")
            .WithHeaders("X-Refit", "foo")
            .WithQueryString("param", "99")
            .Respond("application/json", "{'url': 'https://httpbin.org/get', 'args': {'param': '99'}}");


            var fixture   = RestService.For <IUseOverloadedGenericMethods <HttpBinGet, string, int> >("https://httpbin.org/", settings);
            var plainText = await fixture.Get();

            var resp = await fixture.Get(403);

            var result = await fixture.Get("foo", 99);

            var result2 = await fixture.Get(99, "foo");

            Assert.True(!String.IsNullOrWhiteSpace(plainText));
            Assert.Equal(HttpStatusCode.Forbidden, resp.StatusCode);

            Assert.Equal("foo", result.Args["param"]);
            Assert.Equal("99", result2.Args["param"]);
        }
        public static IHttpClientBuilder AddApiClient <T>(this IServiceCollection services, Action <HttpClient> configureClient) where T : class
        {
            var refitSettings = new RefitSettings
            {
                ContentSerializer = new JsonContentSerializer(
                    new JsonSerializerSettings
                {
                    NullValueHandling = NullValueHandling.Ignore,
                    ContractResolver  = new CamelCasePropertyNamesContractResolver()
                })
            };

            if (!services.Any(svc => svc.ImplementationType == typeof(HttpLoggingHandler)))
            {
                services.AddTransient <HttpLoggingHandler>();
            }

            return(services.AddRefitClient <T>(refitSettings)
                   .ConfigureHttpClient(configureClient)
                   .AddHttpMessageHandler <HttpLoggingHandler>());
        }
Ejemplo n.º 10
0
        public async Task PostToRequestBin()
        {
            var mockHttp = new MockHttpMessageHandler();

            var settings = new RefitSettings {
                HttpMessageHandlerFactory = () => mockHttp
            };

            mockHttp.Expect(HttpMethod.Post, "http://httpbin.org/1h3a5jm1")
            .Respond(HttpStatusCode.OK);

            var fixture = RestService.For <IRequestBin>("http://httpbin.org/", settings);

            try {
                await fixture.Post();
            } catch (ApiException ex) {
                // we should be good but maybe a 404 occurred
            }

            mockHttp.VerifyNoOutstandingExpectation();
        }
Ejemplo n.º 11
0
        public async Task PostStringUrlToRequestBin()
        {
            var mockHttp = new MockHttpMessageHandler();

            var settings = new RefitSettings
            {
                HttpMessageHandlerFactory = () => mockHttp
            };

            mockHttp.Expect(HttpMethod.Post, "http://httpbin.org/foo")
            .WithContent("url%26string")
            .WithHeaders("Content-Type", "application/x-www-form-urlencoded; charset=utf-8")
            .Respond(HttpStatusCode.OK);

            var fixture = RestService.For <IRequestBin>("http://httpbin.org/", settings);


            await fixture.PostRawStringUrlEncoded("url&string");

            mockHttp.VerifyNoOutstandingExpectation();
        }
Ejemplo n.º 12
0
        public async Task GetWithDecimal()
        {
            var mockHttp = new MockHttpMessageHandler();
            var settings = new RefitSettings
            {
                HttpMessageHandlerFactory = () => mockHttp
            };

            mockHttp.Expect(HttpMethod.Get, "http://foo/withDecimal")
            .WithExactQueryString(new[] { new KeyValuePair <string, string>("value", "3.456") })
            .Respond("application/json", "Ok");

            var fixture = RestService.For <IApiWithDecimal>("http://foo", settings);

            const decimal val = 3.456M;


            var result = await fixture.GetWithDecimal(val);

            mockHttp.VerifyNoOutstandingExpectation();
        }
Ejemplo n.º 13
0
        public async Task ServiceOutsideNamespaceGetRequest()
        {
            var mockHttp = new MockHttpMessageHandler();
            var settings = new RefitSettings
            {
                HttpMessageHandlerFactory = () => mockHttp
            };

            mockHttp.Expect(HttpMethod.Get, "http://foo/")
            // We can't add HttpContent to a GET request,
            // because HttpClient doesn't allow it and it will
            // blow up at runtime
            .With(r => r.Content == null)
            .Respond("application/json", "Ok");

            var fixture = RestService.For <IServiceWithoutNamespace>("http://foo", settings);

            await fixture.GetRoot();

            mockHttp.VerifyNoOutstandingExpectation();
        }
Ejemplo n.º 14
0
        public async Task DoesntAddAutoAddContentToHeadRequest()
        {
            var mockHttp = new MockHttpMessageHandler();
            var settings = new RefitSettings
            {
                HttpMessageHandlerFactory = () => mockHttp
            };

            mockHttp.Expect(HttpMethod.Head, "http://foo/nobody")
            // We can't add HttpContent to a HEAD request,
            // because HttpClient doesn't allow it and it will
            // blow up at runtime
            .With(r => r.Content == null)
            .Respond("application/json", "Ok");

            var fixture = RestService.For <IBodylessApi>("http://foo", settings);

            await fixture.Head();

            mockHttp.VerifyNoOutstandingExpectation();
        }
Ejemplo n.º 15
0
        /// <summary>
        /// 封装Refit,默认将Cookie添加到Header中
        /// </summary>
        /// <typeparam name="TInterface"></typeparam>
        /// <param name="services"></param>
        /// <param name="host"></param>
        /// <returns></returns>
        private static IServiceCollection AddBiliBiliClientApi <TInterface>(this IServiceCollection services, string host)
            where TInterface : class
        {
            var settings = new RefitSettings(new SystemTextJsonContentSerializer(JsonSerializerOptionsBuilder.DefaultOptions));

            services.AddRefitClient <TInterface>(settings)
            .ConfigureHttpClient((sp, c) =>
            {
                c.DefaultRequestHeaders.Add("Cookie",
                                            sp.GetRequiredService <IOptionsMonitor <BiliBiliCookieOptions> >().CurrentValue.ToString());
                c.DefaultRequestHeaders.Add("User-Agent",
                                            sp.GetRequiredService <IOptionsMonitor <SecurityOptions> >().CurrentValue.UserAgent);
                c.BaseAddress = new Uri(host);
            })
            .AddHttpMessageHandler(sp => new MyHttpClientDelegatingHandler(
                                       sp.GetRequiredService <ILogger <MyHttpClientDelegatingHandler> >(),
                                       sp.GetRequiredService <IOptionsMonitor <SecurityOptions> >()
                                       ));

            return(services);
        }
Ejemplo n.º 16
0
        public void UpdateApiUrl(string newApiUrl)
        {
            // TODO: As you go through and implement the various APIs, update these from the fake to the real
            ProfilesAPI = new FakeProfilesAPI();
            HomeAPI     = new FakeHomeAPI();
            LoginAPI    = new FakeLoginAPI();


            //ProfilesAPI = RestService.For<IProfilesAPI>(HttpClientFactory.Create(newApiUrl));
            //HomeAPI = RestService.For<IHomeAPI>(HttpClientFactory.Create(newApiUrl));

            var productsRefitSettings = new RefitSettings {
                ContentSerializer = new JsonContentSerializer(ProductPerDTOJsonConverter.Settings)
            };

            ProductsAPI = RestService.For <IProductsAPI>(HttpClientFactory.Create(newApiUrl), productsRefitSettings);



            //LoginAPI = RestService.For<ILoginAPI>(HttpClientFactory.Create(newApiUrl));
        }
        public async void AuthenticatedHandlerUsesAuth()
        {
            var handler  = new MockHttpMessageHandler();
            var settings = new RefitSettings()
            {
                AuthorizationHeaderValueGetter = () => Task.FromResult("tokenValue"),
                HttpMessageHandlerFactory      = () => handler
            };

            handler.Expect(HttpMethod.Get, "http://api/auth")
            .WithHeaders("Authorization", "Bearer tokenValue")
            .Respond("text/plain", "Ok");

            var fixture = RestService.For <IMyAuthenticatedService>("http://api", settings);

            var result = await fixture.GetAuthenticated();

            handler.VerifyNoOutstandingExpectation();

            Assert.Equal("Ok", result);
        }
        public async Task ProvideFactoryWhichAlwaysReturnsException_WithoutResult()
        {
            var handler   = new MockHttpMessageHandler();
            var exception = new Exception("I like to fail");
            var settings  = new RefitSettings()
            {
                HttpMessageHandlerFactory = () => handler,
                ExceptionFactory          = _ => Task.FromResult <Exception>(exception)
            };

            handler.Expect(HttpMethod.Put, "http://api/put-without-result")
            .Respond(HttpStatusCode.OK);

            var fixture = RestService.For <IMyService>("http://api", settings);

            var thrownException = await Assert.ThrowsAsync <Exception>(() => fixture.PutWithoutResult());

            Assert.Equal(exception, thrownException);

            handler.VerifyNoOutstandingExpectation();
        }
        /// <summary>
        /// Adds a Refit client for <see cref="TClient"/> and automatically applies the
        /// options for <typeparamref name="TOptions"/>.
        /// <see cref="HttpClientBuilderExtensions.ConfigureWithOptions"/> for more information.
        /// </summary>
        /// <typeparam name="TClient">The Refit Client interface.</typeparam>
        /// <typeparam name="TOptions">The type of <see cref="HttpClientOptions"/>.</typeparam>
        /// <param name="services">The <see cref="IServiceCollection"/>.</param>
        /// <param name="configuration">The <see cref="IConfiguration"/>.</param>
        /// <param name="key">
        /// The configuration section key name to use.
        /// If not provided, it will be the <typeparamref name="T"/> type name without the -Options prefix.
        /// (see <see cref="ConfigurationExtensions.DefaultOptionsName(Type)"/>.
        /// </param>
        /// <param name="refitSettings">
        /// Custom <see cref="RefitSettings"/> to apply, if any.</param>
        /// <returns>The configured <see cref="IHttpClientBuilder"/>, that can be further customized.</returns>
        public static IHttpClientBuilder AddRefitClient <TClient, TOptions>(
            this IServiceCollection services,
            IConfiguration configuration,
            string?key = null,
            RefitSettings?refitSettings = null)
            where TClient : class
            where TOptions : HttpClientOptions, new()
        {
            services.BindOptionsToConfigurationAndValidate <TOptions>(configuration, key: key);

            var options = configuration.ReadOptionsAndValidate <TOptions>(key);

            if (refitSettings is null)
            {
                if ("xml".Equals(options.Serializer, StringComparison.OrdinalIgnoreCase))
                {
                    refitSettings = new RefitSettings(new XmlContentSerializer());
                }
                else
                {
                    var jsonSerializerOptions = new JsonSerializerOptions
                    {
                        IgnoreNullValues            = true,
                        PropertyNameCaseInsensitive = true,
                        WriteIndented = true,
                    };

                    jsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());
                    jsonSerializerOptions.Converters.Add(new JsonTimeSpanConverter());
                    jsonSerializerOptions.Converters.Add(new JsonNullableTimeSpanConverter());
                    refitSettings = new RefitSettings(new SystemTextJsonContentSerializer(jsonSerializerOptions));
                }
            }

            return(services
                   .AddSingleton(provider => RequestBuilder.ForType <TClient>(refitSettings))
                   .AddHttpClient(typeof(TClient).Name)
                   .ConfigureWithOptions <TOptions>(configuration, key: key)
                   .AddTypedClient((client, serviceProvider) => RestService.For(client, serviceProvider.GetService <IRequestBuilder <TClient> >())));
        }
Ejemplo n.º 20
0
        public async Task MultipartUploadShouldWorkWithAnObject(Type contentSerializerType, string mediaType)
        {
            if (!(Activator.CreateInstance(contentSerializerType) is IContentSerializer serializer))
            {
                throw new ArgumentException($"{contentSerializerType.FullName} does not implement {nameof(IContentSerializer)}");
            }

            var model1 = new ModelObject
            {
                Property1 = "M1.prop1",
                Property2 = "M1.prop2"
            };

            var handler = new MockHttpMessageHandler
            {
                Asserts = async content =>
                {
                    var parts = content.ToList();

                    Assert.Single(parts);

                    Assert.Equal("theObject", parts[0].Headers.ContentDisposition.Name);
                    Assert.Null(parts[0].Headers.ContentDisposition.FileName);
                    Assert.Equal(mediaType, parts[0].Headers.ContentType.MediaType);
                    var result0 = await serializer.DeserializeAsync <ModelObject>(parts[0]).ConfigureAwait(false);

                    Assert.Equal(model1.Property1, result0.Property1);
                    Assert.Equal(model1.Property2, result0.Property2);
                }
            };

            var settings = new RefitSettings()
            {
                HttpMessageHandlerFactory = () => handler,
                ContentSerializer         = serializer
            };

            var fixture = RestService.For <IRunscopeApi>(BaseAddress, settings);
            var result  = await fixture.UploadJsonObject(model1);
        }
Ejemplo n.º 21
0
        public async Task HitTheGitHubUserApiAsObservableApiResponse()
        {
            var mockHttp = new MockHttpMessageHandler();

            var settings = new RefitSettings
            {
                HttpMessageHandlerFactory = () => mockHttp,
                ContentSerializer         = new JsonContentSerializer(new JsonSerializerSettings()
                {
                    ContractResolver = new SnakeCasePropertyNamesContractResolver()
                })
            };

            var responseMessage = new HttpResponseMessage()
            {
                StatusCode = HttpStatusCode.OK,
                Content    = new StringContent("{ 'login':'******', 'avatar_url':'http://foo/bar' }", System.Text.Encoding.UTF8, "application/json"),
            };

            responseMessage.Headers.Add("Cookie", "Value");

            mockHttp.Expect(HttpMethod.Get, "https://api.github.com/users/octocat").Respond(req => responseMessage);

            var fixture = RestService.For <IGitHubApi>("https://api.github.com", settings);

            var result = await fixture.GetUserObservableWithMetadata("octocat")
                         .Timeout(TimeSpan.FromSeconds(10));

            Assert.True(result.Headers.Any());
            Assert.True(result.IsSuccessStatusCode);
            Assert.NotNull(result.ReasonPhrase);
            Assert.NotNull(result.RequestMessage);
            Assert.False(result.StatusCode == default);
            Assert.NotNull(result.Version);
            Assert.Equal("octocat", result.Content.Login);
            Assert.False(string.IsNullOrEmpty(result.Content.AvatarUrl));

            mockHttp.VerifyNoOutstandingExpectation();
        }
Ejemplo n.º 22
0
        public MtDataReaderClient(string url, string apiKey, string userAgent)
        {
            var httpMessageHandler = new ApiKeyHeaderHttpClientHandler(
                new UserAgentHeaderHttpClientHandler(
                    new RetryingHttpClientHandler(new HttpClientHandler(), 6, TimeSpan.FromSeconds(5)),
                    userAgent),
                apiKey);
            var settings = new RefitSettings {
                HttpMessageHandlerFactory = () => httpMessageHandler
            };

            AssetPairsRead        = AddCaching(RestService.For <IAssetPairsReadingApi>(url, settings));
            AccountHistory        = RestService.For <IAccountHistoryApi>(url, settings);
            AccountsApi           = RestService.For <IAccountsApi>(url, settings);
            AccountAssetPairsRead = RestService.For <IAccountAssetPairsReadingApi>(url, settings);
            TradeMonitoringRead   = RestService.For <ITradeMonitoringReadingApi>(url, settings);
            TradingConditionsRead = RestService.For <ITradingConditionsReadingApi>(url, settings);
            AccountGroups         = RestService.For <IAccountGroupsReadingApi>(url, settings);
            Dictionaries          = RestService.For <IDictionariesReadingApi>(url, settings);
            Routes   = RestService.For <IRoutesReadingApi>(url, settings);
            Settings = RestService.For <ISettingsReadingApi>(url, settings);
        }
Ejemplo n.º 23
0
        public MarketPlaceClient(string baseEndPoint, Information info, Func <Task <string> > authorizationHeaderValueGetter, HttpMessageHandler innerHandler = null)
        {
            MarketPlaceHttpHeaders marketPlaceHttpHeaders = new MarketPlaceHttpHeaders(info);

            RefitSettings refitSetting = new RefitSettings
            {
                HttpMessageHandlerFactory = () => new MetricHttpHandler(new MarketPlaceHeadersHandler(marketPlaceHttpHeaders, innerHandler)),
                JsonSerializerSettings    = new JsonSerializerSettings {
                    NullValueHandling = NullValueHandling.Ignore
                },
                AuthorizationHeaderValueGetter = authorizationHeaderValueGetter
            };

            _apiClient = RestService.For <IMarketPlaceClient>(baseEndPoint, refitSetting);
            //var httpHandler = new HttpClientHandler();
            //httpHandler.Proxy = new WebProxy("http://192.168.1.9:9000");
            //var httpClient = new HttpClient(httpHandler);
            //httpClient.BaseAddress = new Uri(baseEndPoint);
            //
            //
            //_apiClient = RestService.For<IMarketPlaceClient>(httpClient, refitSetting);
        }
Ejemplo n.º 24
0
        public async Task ShouldRetHttpResponseMessage()
        {
            var mockHttp = new MockHttpMessageHandler();

            var settings = new RefitSettings {
                HttpMessageHandlerFactory = () => mockHttp,
                JsonSerializerSettings    = new JsonSerializerSettings()
                {
                    ContractResolver = new SnakeCasePropertyNamesContractResolver()
                }
            };

            mockHttp.When(HttpMethod.Get, "https://api.github.com/")
            .Respond(HttpStatusCode.OK);


            var fixture = RestService.For <IGitHubApi>("https://api.github.com", settings);
            var result  = await fixture.GetIndex();

            Assert.NotNull(result);
            Assert.True(result.IsSuccessStatusCode);
        }
Ejemplo n.º 25
0
        public Client(string rootUrl, JsonSerializerOptions jsonSerializerOptions)
        {
            var settings = new RefitSettings(new SystemTextJsonContentSerializer(jsonSerializerOptions));

            RepositoryDataApi       = RestService.For <IRepositoryDataApi>(rootUrl, settings);
            AccountTokenHistoryApi  = RestService.For <IAccountTokenHistoryApi>(rootUrl, settings);
            ConnectionUrlHistoryApi = RestService.For <IConnectionUrlHistoryApi>(rootUrl, settings);
            KeyValuesApi            = RestService.For <IKeyValuesApi>(rootUrl, settings);
            KeyValuesHistoryApi     = RestService.For <IKeyValuesHistoryApi>(rootUrl, settings);
            LocksApi        = RestService.For <ILocksApi>(rootUrl, settings);
            NetworksApi     = RestService.For <INetworksApi>(rootUrl, settings);
            RepositoriesApi = RestService.For <IRepositoriesApi>(rootUrl, settings);
            RepositoriesUpdateHistoryApi = RestService.For <IRepositoriesUpdateHistoryApi>(rootUrl, settings);
            RolesApi               = RestService.For <IRolesApi>(rootUrl, settings);
            SecretKeyValuesApi     = RestService.For <ISecretKeyValuesApi>(rootUrl, settings);
            ServiceTokenHistoryApi = RestService.For <IServiceTokenHistoryApi>(rootUrl, settings);
            ServiceTokensApi       = RestService.For <IServiceTokensApi>(rootUrl, settings);
            TokensApi              = RestService.For <ITokensApi>(rootUrl, settings);
            UserActionsHistoryApi  = RestService.For <IUserActionsHistoryApi>(rootUrl, settings);
            UsersApi               = RestService.For <IUsersApi>(rootUrl, settings);
            UserSignInHistoryApi   = RestService.For <IUserSignInHistoryApi>(rootUrl, settings);
        }
Ejemplo n.º 26
0
        /// <summary>
        /// 注册Rpc服务(跨服务之间的同步通讯)
        /// </summary>
        /// <typeparam name="TRpcService">Rpc服务接口</typeparam>
        /// <param name="serviceName">在注册中心注册的服务名称,或者服务的Url</param>
        /// <param name="policies">Polly策略</param>
        /// <param name="token">Token,可空</param>
        protected virtual void AddRpcService <TRpcService>(string serviceName
                                                           , List <IAsyncPolicy <HttpResponseMessage> > policies
                                                           , Func <Task <string> > token = null
                                                           ) where TRpcService : class, IRpcService
        {
            var  prefix          = serviceName.Substring(0, 7);
            bool isConsulAdderss = (prefix == "http://" || prefix == "https:/") ? false : true;

            var refitSettings = new RefitSettings(new SystemTextJsonContentSerializer(SystemTextJsonHelper.GetAdncDefaultOptions()));
            //注册RefitClient,设置httpclient生命周期时间,默认也是2分钟。
            var clientbuilder = _services.AddRefitClient <TRpcService>(refitSettings)
                                .SetHandlerLifetime(TimeSpan.FromMinutes(2));

            //从consul获取地址
            if (isConsulAdderss)
            {
                clientbuilder.ConfigureHttpClient(c => c.BaseAddress = new Uri($"http://{serviceName}"))
                .AddHttpMessageHandler(() =>
                {
                    return(new ConsulDiscoveryDelegatingHandler(_consulConfig.ConsulUrl, token));
                });
            }
            else
            {
                clientbuilder.ConfigureHttpClient((options) =>
                {
                    options.BaseAddress = new Uri(serviceName);
                });
            }

            //添加polly相关策略
            if (policies != null && policies.Any())
            {
                foreach (var policy in policies)
                {
                    clientbuilder.AddPolicyHandler(policy);
                }
            }
        }
Ejemplo n.º 27
0
        public static void AddDotnetWebApiBenchApiRefitClients(this IServiceCollection services, string apiAddress, bool allowInvalidCerts = false)
        {
            services.AddTransient <AuthenticationHandler>(ctx => new AuthenticationHandler(apiAddress));

            RefitSettings refitSettings = new RefitSettings()
            {
                ContentSerializer = new NewtonsoftJsonContentSerializer()
            };

            List <IHttpClientBuilder> httpClientBuilders = new List <IHttpClientBuilder>();

            httpClientBuilders.Add(services.AddRefitClient <IProductsClient>(refitSettings));
            httpClientBuilders.Add(services.AddRefitClient <IOrdersClient>(refitSettings));
            httpClientBuilders.Add(services.AddRefitClient <ICustomersClient>(refitSettings));
            httpClientBuilders.Add(services.AddRefitClient <IHeartbeatClient>(refitSettings));

            foreach (IHttpClientBuilder clientBuilder in httpClientBuilders)
            {
                clientBuilder.ConfigureHttpClient((client) =>
                {
                    client.BaseAddress = new Uri(apiAddress);
                })
                .AddHttpMessageHandler <AuthenticationHandler>();

                if (allowInvalidCerts)
                {
                    var noSslCheckHandler = new HttpClientHandler();
                    noSslCheckHandler.ClientCertificateOptions = ClientCertificateOption.Manual;
                    noSslCheckHandler.UseProxy = false;
                    noSslCheckHandler.ServerCertificateCustomValidationCallback =
                        (httpRequestMessage, cert, cetChain, policyErrors) =>
                    {
                        return(true);
                    };

                    clientBuilder.ConfigurePrimaryHttpMessageHandler(() => noSslCheckHandler);
                }
            }
        }
Ejemplo n.º 28
0
        public async Task ComplexDynamicQueryparametersTest()
        {
            var mockHttp = new MockHttpMessageHandler();

            var settings = new RefitSettings
            {
                HttpMessageHandlerFactory = () => mockHttp
            };

            mockHttp.Expect(HttpMethod.Get, "https://httpbin.org/get")
            .Respond("application/json", "{'url': 'https://httpbin.org/get?hardcoded=true&FirstName=John&LastName=Rambo&Addr_Zip=9999&Addr_Street=HomeStreet 99&MetaData_Age=99&MetaData_Initials=JR&MetaData_Birthday=10%2F31%2F1918 4%3A21%3A16 PM&Other=12345&Other=10%2F31%2F2017 4%3A21%3A17 PM&Other=696e8653-6671-4484-a65f-9485af95fd3a', 'args': { 'Addr_Street': 'HomeStreet 99', 'Addr_Zip': '9999', 'FirstName': 'John', 'LastName': 'Rambo', 'MetaData_Age': '99', 'MetaData_Birthday': '10/31/1981 4:32:59 PM', 'MetaData_Initials': 'JR', 'Other': ['12345','10/31/2017 4:32:59 PM','60282dd2-f79a-4400-be01-bcb0e86e7bc6'], 'hardcoded': 'true'}}");

            var myParams = new MyComplexQueryParams
            {
                FirstName = "John",
                LastName  = "Rambo"
            };

            myParams.Address.Postcode = 9999;
            myParams.Address.Street   = "HomeStreet 99";

            myParams.MetaData.Add("Age", 99);
            myParams.MetaData.Add("Initials", "JR");
            myParams.MetaData.Add("Birthday", new DateTime(1981, 10, 31, 16, 24, 59));

            myParams.Other.Add(12345);
            myParams.Other.Add(new DateTime(2017, 10, 31, 16, 24, 59));
            myParams.Other.Add(new Guid("60282dd2-f79a-4400-be01-bcb0e86e7bc6"));


            var fixture = RestService.For <IHttpBinApi <HttpBinGet, MyComplexQueryParams, int> >("https://httpbin.org", settings);

            var resp = await fixture.GetQuery(myParams);

            Assert.Equal("John", resp.Args["FirstName"]);
            Assert.Equal("Rambo", resp.Args["LastName"]);
            Assert.Equal("9999", resp.Args["Addr_Zip"]);
        }
Ejemplo n.º 29
0
        public static void Configure(IConfiguration configuration, IServiceCollection services)
        {
            var funzaSettings = configuration.GetSection("FunzaSettings").Get <FunzaSettings>();

            var settings = new RefitSettings();

            services.AddRefitClient <IInternalSecurityClient>()
            .ConfigureHttpClient(c =>
            {
                c.BaseAddress = new Uri(new Uri(funzaSettings.FunzaUrl), "security");

                //var policies = new IAsyncPolicy[] {
                //    c.CustomRefreshTokenConfiguration(),
                //    c.CustomLoggingConfiguration()
                //};

                //(c as CustomHttpClient).Policies = Policy.WrapAsync(policies);
            });

            services.AddRefitClient <IInternalQuoteClient>()
            .AddTypedClient <CustomHttpClient>(c => new CustomHttpClient())
            .ConfigureHttpClient(c => {
                c.BaseAddress = new Uri(new Uri(funzaSettings.FunzaUrl), "quotes");

                //var policies = new IAsyncPolicy[] {
                //    c.CustomRefreshTokenConfiguration(),
                //    c.CustomLoggingConfiguration()
                //};

                //(c as CustomHttpClient).Policies = Policy.WrapAsync(policies);
            });

            services.AddRefitClient <IInternalSyncClient>()
            .AddTypedClient <CustomHttpClient>(c => new CustomHttpClient())
            .ConfigureHttpClient(c => {
                c.BaseAddress = new Uri(new Uri(funzaSettings.FunzaUrl), "sync");
            });
        }
Ejemplo n.º 30
0
        public static void InitiateRefitServices(this IServiceCollection services, IConfiguration configuration)
        {
            var appSettingsOption = configuration.Get <Settings>();

            var settings = new RefitSettings
            {
            };

            services.AddRefitClient <IUserApi>(settings)
            .ConfigureHttpClient(c =>
            {
                c.BaseAddress = new Uri(appSettingsOption.RefitUrls.UserApi);
            });

            services.AddRefitClient <IPatientApi>(settings)
            .ConfigureHttpClient(c =>
            {
                c.BaseAddress = new Uri(appSettingsOption.RefitUrls.PatientApi);
            });

            services.AddRefitClient <IClinicApi>(settings)
            .ConfigureHttpClient(c =>
            {
                c.BaseAddress = new Uri(appSettingsOption.RefitUrls.ClinicApi);
            });

            services.AddRefitClient <IConsultationApi>(settings)
            .ConfigureHttpClient(c =>
            {
                c.BaseAddress = new Uri(appSettingsOption.RefitUrls.ConsultationApi);
            });

            services.AddRefitClient <IAppointmentApi>(settings)
            .ConfigureHttpClient(c =>
            {
                c.BaseAddress = new Uri(appSettingsOption.RefitUrls.AppointmentApi);
            });
        }
Ejemplo n.º 31
0
        public async Task CustomParmeterFormatter()
        {
            var settings = new RefitSettings { UrlParameterFormatter = new TestUrlParameterFormatter("custom-parameter") };
            var fixture = new RequestBuilderImplementation(typeof(IDummyHttpApi), settings);

            var factory = fixture.BuildRequestFactoryForMethod("FetchSomeStuff");
            var output = factory(new object[] { 5 });

            var uri = new Uri(new Uri("http://api"), output.RequestUri);
            Assert.AreEqual("/foo/bar/custom-parameter", uri.PathAndQuery);
        }