Пример #1
0
        /// <summary>
        /// For Unit Testing, allowing mocking of the LevelUpHttpRestfulService.  Note
        /// that the AssemblyInfo.cs file enables internals to be visible to the unit
        /// test project.
        /// </summary>
        internal static T Create <T>(AgentIdentifier identifier, LevelUpEnvironment enviornment, IRestfulService restService)
            where T : ILevelUpClientModule
        {
            var client = new LevelUpClient(GetDefaultLevelUpRequestEngine(identifier, enviornment, restService));

            return((T)(object)client);
        }
Пример #2
0
        /// <summary>
        /// Create a composed interface, containing a collection of the more fine-grained
        /// LevelUp client interfaces.
        /// </summary>
        /// <typeparam name="T">The type of composed interface to generate.</typeparam>
        /// <param name="identifier">An object that retains data about the caller
        /// (company name, etc.) as an informational and diagnostic tool for the
        /// LevelUp backend.</param>
        /// <param name="enviornment">The target enviornment (sandbox, production, etc.)</param>
        /// <returns>The LevelUp client interface of the specified type T.</returns>
        public static T CreateComposedInterface <T>(AgentIdentifier identifier, LevelUpEnvironment enviornment)
            where T : IComposedInterface
        {
            IRestfulService httpRestService = new LevelUpHttpRestfulService();
            var             client          = new LevelUpClient(GetDefaultLevelUpRequestEngine(identifier, enviornment, httpRestService));

            return((T)(object)client);
        }
Пример #3
0
        /// <summary>
        /// Create a LevelUp client interface with a set timeout value
        /// </summary>
        /// <typeparam name="T">The type of LevelUp client interface to generate.</typeparam>
        /// <param name="identifier">An object that retains data about the caller
        /// (company name, etc.) as an informational and diagnostic tool for the
        /// LevelUp backend.</param>
        /// <param name="enviornment">The target enviornment (sandbox, production, etc.)</param>
        /// <param name="timeoutInMs">Time out value in milliseconds</param>
        /// <returns>The LevelUp client interface of the specified type T.</returns>
        public static T Create <T>(AgentIdentifier identifier, LevelUpEnvironment enviornment, int timeoutInMs)
            where T : ILevelUpClientModule
        {
            IRestfulService httpRestService = new LevelUpHttpRestfulService(timeoutInMs);
            var             client          = new LevelUpClient(httpRestService, identifier, enviornment);

            return((T)(object)client);
        }
 /// <summary>
 /// Gets a LevelUpClient Module interface that will mimic, for any rest call, the provided
 /// expected RestResponse.  Callers are expected to populate this expected response, including
 /// the json content string, based on what they expect to come over the wire according to the
 /// LevelUp platform API docs.
 /// </summary>
 /// <typeparam name="T">The specific type of ILevelUpClientModule to return.</typeparam>
 /// <param name="expectedResponse">The desired RestResponse that the caller would want platform
 /// to produce.  Note that this response will be applied to every rest command. </param>
 /// <param name="expectedRequestUrl">If the caller wishes to verify the endpoint that is
 /// used in the request, they can do that here.</param>
 /// <param name="expectedAccessToken">If the caller wishes to verify authorization functionality
 /// for a specific command, they can provide an expected access token, without which the returned
 /// rest response will contain an unauthorized status code.</param>
 /// <param name="environmentToUse">Environment to use to build URI of the request.</param>
 internal static T GetMockedLevelUpModule <T>(RestResponse expectedResponse,
                                              string expectedRequestUrl,
                                              string expectedAccessToken,
                                              LevelUpEnvironment environmentToUse)
     where T : ILevelUpClientModule
 {
     return(GetMockedLevelUpModule <T, Request>(expectedResponse,
                                                null,
                                                expectedAccessToken: expectedAccessToken,
                                                expectedRequestUrl: expectedRequestUrl,
                                                environmentToUse: environmentToUse));
 }
        private static T GenerateMockLevelUpModuleWhereEveryHttpVerbDoesTheSameThing <T>(
            Func <string, string, string, string, IRestResponse> expectedResponseForAnyCall,
            LevelUpEnvironment targetEnvironment)
            where T : ILevelUpClientModule
        {
            var service = GenerateMockIRestfulService(
                expectedResponseForAnyCall,
                expectedResponseForAnyCall,
                (a, b, c) => expectedResponseForAnyCall(a, null, b, c),  // GET and DELETE return the same specified RestResponse
                (a, b, c) => expectedResponseForAnyCall(a, null, b, c)); // object, they just don't provide a body.

            return(LevelUpClientFactory.Create <T>(new AgentIdentifier("SDK Unit Tests", "", "", ""),
                                                   targetEnvironment,
                                                   service.Object));
        }
Пример #6
0
        /// <summary>
        /// Creates an IRequestVisitor<IResponse> (i.e. the "request execution engine") using the default
        /// implementation for each of the requisite visitors.  Unless a 3rd-party client wants to override
        /// a particular visitor (in order to modify the way that the SDK creates and interperates calls
        /// to the LevelUp api) for some reason, these defaults are what should be used in the creation of
        /// the LevelUpClient implementation class.
        /// </summary>
        private static IRequestVisitor <IResponse> GetDefaultLevelUpRequestEngine(AgentIdentifier identifier,
                                                                                  LevelUpEnvironment enviornment, IRestfulService httpRestService)
        {
            IRequestVisitor <string> endpointCreator = new RequestEndpointCreator(enviornment);

            IRequestVisitor <string> headerAuthorizationTokenCreator = new RequestHeaderTokenCreator();

            IRequestVisitor <Dictionary <HttpStatusCode, LevelUpRestWrapper.ResponseAction> > customHttpStatusCodeHandlers
                = new AdditionalHttpStatusCodeHandlers();

            IRequestVisitor <IResponse> requestExecutionEngine = new RequestExecutionEngine(httpRestService, identifier,
                                                                                            endpointCreator, headerAuthorizationTokenCreator, customHttpStatusCodeHandlers);

            return(requestExecutionEngine);
        }
        /// <summary>
        /// Gets a LevelUpClient Module interface that will mimic, for any rest call, the provided
        /// expected RestResponse.  Callers are expected to populate this expected response, including
        /// the json content string, based on what they expect to come over the wire according to the
        /// LevelUp platform API docs.
        /// </summary>
        /// <typeparam name="T">The specific type of ILevelUpClientModule to return.</typeparam>
        /// <typeparam name="U">The expected request model object type.</typeparam>
        /// <param name="expectedResponse">The desired RestResponse that the caller would want platform
        ///     to produce.  Note that this response will be applied to every rest command. </param>
        /// <param name="expectedRequestBody">If the caller wishes to verify the body data that is
        ///     used in the request, they can do that here.</param>
        /// <param name="expectedAccessToken">If the caller wishes to verify authorization functionality
        ///     for a specific command, they can provide an expected access token, without which the returned
        ///     rest response will contain an unauthorized status code.</param>
        /// <param name="expectedRequestUrl">If the caller wishes to verify the endpoint that is
        ///     used in the request, they can do that here.</param>
        /// <param name="environmentToUse">Environment to use to build URI of the request. Default value is Sandbox</param>
        internal static T GetMockedLevelUpModule <T, U>(RestResponse expectedResponse,
                                                        string expectedRequestBody,
                                                        string expectedAccessToken,
                                                        string expectedRequestUrl,
                                                        LevelUpEnvironment environmentToUse)
            where T : ILevelUpClientModule
            where U : Request
        {
            // This is not a very smart mock, in that every type of request will generate the same
            // response -- GET/POST/PUT/DELETE all just call this delegate.
            var returnsExpectedResponse = new Func <string, string, string, string, IRestResponse>(
                (string url, string body, string accessToken, string userAgent) =>
            {
                if (!string.IsNullOrEmpty(expectedRequestUrl) && expectedRequestUrl != url)
                {
                    Assert.Fail("The specified expected url [{0}] does not match " +
                                "the url generated in the code [{1}].", expectedRequestUrl, url);
                }

                if (!string.IsNullOrEmpty(expectedRequestBody))
                {
                    Type Q = typeof(U).GetProperty("Body")?.PropertyType ?? typeof(U);
                    TestUtilities.VerifyJsonIsEquivalent(expectedRequestBody, body, Q);
                }

                if (expectedAccessToken != null && !string.IsNullOrEmpty(accessToken) &&
                    !accessToken.Contains(expectedAccessToken))
                {
                    Assert.Fail("The specified expected access token [{0}] does not match " +
                                "the access token generated in code [{1}].", expectedAccessToken, accessToken);
                }

                return(expectedResponse);
            });

            return(GenerateMockLevelUpModuleWhereEveryHttpVerbDoesTheSameThing <T>(returnsExpectedResponse,
                                                                                   environmentToUse));
        }
        /// <summary>
        /// Gets a LevelUpClient Module interface that will mimic, for any rest call, the provided expected RestResponses
        /// using a paging format.  This mock will handle adding paging link headers to the returned RestResponse
        /// objects and serving up the subsequent RestResponse when those links are used.
        /// </summary>
        /// <typeparam name="T">A LevelUpModule type that uses paging.</typeparam>
        /// <param name="expectedResponses">A collection of expected response objects, which will each be treated
        /// as a page, in the correct paging order.</param>
        /// <param name="requestUrlBase">The url that is expected to retrieve the first page.</param>
        /// <param name="environmentToUse">Environment to use to build URI of the request.</param>
        internal static T GetMockedLevelUpModuleWithPaging <T>(RestResponse[] expectedResponses,
                                                               string requestUrlBase,
                                                               LevelUpEnvironment environmentToUse)
            where T : IQueryOrders
        {
            var len = expectedResponses.Length;

            if (len < 1)
            {
                throw new ArgumentException("This mock requires that the caller specify at least one expected response.");
            }

            var GetFullUrlForPage = new Func <int, string>(x => string.Format("{0}?page={1}", requestUrlBase, x));

            // Dictionary is indexed by the incoming url and contains a tuple that houses a response for that particular
            // incoming url and the url of the next page.
            var responses = new Dictionary <string, Tuple <RestResponse, string> >();

            // If the request does not specify a page number, we will return the first page of results, with any applicable link to page 2
            string urlForPageTwo = len > 1 ? GetFullUrlForPage(2) : null;

            responses.Add(requestUrlBase, new Tuple <RestResponse, string>(expectedResponses[0], urlForPageTwo));

            for (int i = 0; i < len; i++)
            {
                string pageUrl     = GetFullUrlForPage(i + 1);
                string nextPageUrl = (i + 2 <= len) ? GetFullUrlForPage(i + 2) : null;
                responses.Add(pageUrl, new Tuple <RestResponse, string>(expectedResponses[i], nextPageUrl));
            }

            var returnsExpectedResponse = new Func <string, string, string, string, IRestResponse>(
                (string url, string body, string accessToken, string userAgent) =>
            {
                if (!responses.ContainsKey(url))
                {
                    if (!url.ToLower().Contains(requestUrlBase.ToLower()))
                    {
                        Assert.Fail("The specified url [" + url +
                                    "] is unknown to the mocked LevelUpClient object.");
                    }

                    // If the specified page does not exist in the mock's record, but the base
                    // url is valid, we'll return a 204 as per the platform api docs.
                    return(new RestResponse {
                        StatusCode = HttpStatusCode.NoContent
                    });
                }

                Tuple <RestResponse, string> responseData = responses[url];

                RestResponse retval = responseData.Item1;
                if (responseData.Item2 != null)
                {
                    var header = new Parameter
                    {
                        Type  = ParameterType.HttpHeader,
                        Name  = "Link",
                        Value = string.Format("<{0}>; rel=\"next\"", responseData.Item2)
                    };
                    retval.Headers.Add(header);
                }
                return(retval);
            });

            return(GenerateMockLevelUpModuleWhereEveryHttpVerbDoesTheSameThing <T>(returnsExpectedResponse,
                                                                                   environmentToUse));
        }
Пример #9
0
 internal LevelUpClient(IRestfulService restService, AgentIdentifier identifier, LevelUpEnvironment targetEnviornment)
 {
     _restWrapper       = new LevelUpRestWrapper(restService, identifier);
     _targetEnviornment = targetEnviornment;
 }
 public RequestEndpointCreator(LevelUpEnvironment targetEnvironment)
 {
     TargetEnviornment = targetEnvironment;
 }