public async Task TestBatchApiRequestsOneRequestAsync()
        {
            Trace.WriteLine("POST /batch");

            // Start the batch request
            BatchApiRequest.StartNewBatchRequest();

            try
            {
                // Make the API calls to be batched
                await Template.GetTemplatesAsync();

                // Make the batch API Reqeust
                var batchResponses = await BatchApiRequest.SendBatchApiRequest();

                // Validate the response to the batch API request
                ValidateBatchApiCallResponses(batchResponses, 1);

                // Validate the response to the individual API call
                ValidateIndividualBatchedApiCallResponse <List <Template> >(batchResponses[0]);
            }
            catch (AggregateException exception)
            {
                Assert.Fail(exception.ToString());
            }
        }
        public async Task TestBatchApiRequestsAbortRequestAsync()
        {
            Trace.WriteLine("POST /batch");

            // Start the batch request
            BatchApiRequest.StartNewBatchRequest();

            try
            {
                // Make the API call to be batched
                await Template.GetTemplatesAsync();

                // Abort the batch request
                BatchApiRequest.AbortBatchRequest();

                // Make another API call and make sure it goes through
                var snippets = await Snippet.GetSnippetsAsync();

                SendwithusClientTest.ValidateResponse(snippets);

                // Make the aborted batch API Reqeust anyways
                var batchResponses = await BatchApiRequest.SendBatchApiRequest();

                // Make sure no API calls were included in the batch request (empty request)
                ValidateBatchApiCallResponses(batchResponses, 0);
            }
            catch (AggregateException exception)
            {
                Assert.Fail(exception.ToString());
            }
        }
Пример #3
0
        public long DetermineRequiredDiskSpace(BatchApiRequest request)
        {
            if (request.Operation.Equals(LfsOperationNames.UPLOAD))
            {
                return(request.Objects.Sum(o => o.Size));
            }

            return(0L);
        }
        public ActionResult GitLfsBatchAPI(string repositoryName, BatchApiRequest requestObj)
        {
            Guid userGuid = User.Id();
            var  result   = LfsService.GetBatchApiResponse(Request.Url.Scheme, Request.Url.Authority, Request.ApplicationPath,
                                                           repositoryName, Request.AcceptTypes, requestObj, userGuid);

            Response.StatusCode = result.HttpStatusCode;
            return(Content(
                       Newtonsoft.Json.JsonConvert.SerializeObject(result.Content, this.LfsService.GetJsonSerializerSettings()),
                       GitLfsConsts.GIT_LFS_CONTENT_TYPE));
        }
        public async Task TestBatchApiRequestsTenRequestsAsync()
        {
            Trace.WriteLine("POST /batch");

            // Start the batch request
            BatchApiRequest.StartNewBatchRequest();

            // Make the API calls to be batched (at least one of each type)
            try
            {
                await TemplateTest.BuildAndSendCreateTemplateRequestWithAllParametersAsync(); // POST

                await Snippet.GetSnippetsAsync();                                             // GET

                await Customer.GetCustomerAsync(CustomerTest.DEFAULT_CUSTOMER_EMAIL_ADDRESS); // GET

                await RenderTest.BuildAndSendRenderTemplateRequestWithAllParametersId();      // POST

                await Log.GetLogEventsAsync(BatchApiRequestTest.DEFAULT_LOG_ID);              // GET

                await Customer.GetCustomerAsync(CustomerTest.DEFAULT_CUSTOMER_EMAIL_ADDRESS); // GET

                await EmailTest.BuildAndSendEmailWithAllParametersAsync();                    // POST

                await DripCampaign.GetDripCampaignsAsync();                                   // GET

                await Customer.GetCustomerAsync(CustomerTest.DEFAULT_CUSTOMER_EMAIL_ADDRESS); // GET

                await Customer.GetCustomerAsync(CustomerTest.DEFAULT_CUSTOMER_EMAIL_ADDRESS); // GET

                // Make the batch Api Reqeust
                var batchResponses = await BatchApiRequest.SendBatchApiRequest();

                // Validate the response to the batch API request
                ValidateBatchApiCallResponses(batchResponses, 10);

                // Validate the response to the individual API calls
                ValidateIndividualBatchedApiCallResponse <Template>(batchResponses[0]);
                ValidateIndividualBatchedApiCallResponse <List <Snippet> >(batchResponses[1]);
                ValidateIndividualBatchedApiCallResponse <Customer>(batchResponses[2]);
                ValidateIndividualBatchedApiCallResponse <RenderTemplateResponse>(batchResponses[3]);
                ValidateIndividualBatchedApiCallResponse <List <Log> >(batchResponses[4]);
                ValidateIndividualBatchedApiCallResponse <Customer>(batchResponses[5]);
                ValidateIndividualBatchedApiCallResponse <EmailResponse>(batchResponses[6]);
                ValidateIndividualBatchedApiCallResponse <List <DripCampaignDetails> >(batchResponses[7]);
                ValidateIndividualBatchedApiCallResponse <Customer>(batchResponses[8]);
                ValidateIndividualBatchedApiCallResponse <Customer>(batchResponses[9]);
            }
            catch (AggregateException exception)
            {
                Assert.Fail(exception.ToString());
            }
        }
Пример #6
0
        /// <summary>
        /// Sends an HTTP DELETE request and returns the reponse as a JSON string
        /// </summary>
        /// <param name="resource">The resource identifier for the resource to be called (after /api/<version></version>/)</param>
        /// <returns>The response content in the form of a JSON string</returns>
        /// <exception cref="AggregateException">Thrown when the API response status code is not success or when the API call times out</exception>
        /// <exception cref="InvalidOperationException">Thrown when the call is made in batch mode but the current batch has no more room for additional API calls</exception>
        public static async Task <string> SendDeleteRequestAsync(string resource)
        {
            using (var client = new HttpClient())
            {
                // Prepare the DELETE request
                ConfigureHttpClient(client);
                var uri = BuildFullResourceString(resource);

                // If batch mode is enabled then add the request to the current batch of requests to send later on
                if (BatchApiRequest.IsBatchApiModeEnabled() == true)
                {
                    BatchApiRequest.AddApiRequest(new BatchApiRequest(uri, "DELETE"));
                    return(String.Empty);
                }
                // Otherwise, send the DELETE request
                else
                {
                    return(await RunWithRetries(() => client.DeleteAsync(uri)));
                }
            }
        }
        private async Task <BatchRequestResponse> SendBatchRequestAsync(Func <Task> executeRequests)
        {
            BatchApiRequest.StartNewBatchRequest();

            try
            {
                bool isBatchSuccess = true;
                var  data           = new List <object>();

                await executeRequests();

                List <BatchApiResponse> batchResponses = await BatchApiRequest.SendBatchApiRequest();

                for (int i = 0; i < batchResponses.Count; i++)
                {
                    BatchApiResponse batchResponse = batchResponses[i];
                    if (batchResponse.status_code != 200)
                    {
                        isBatchSuccess = false;
                        BatchApiRequest.AbortBatchRequest();
                        break;
                    }
                    var body = batchResponses[i].GetBody <object>();
                    data.Add(body);
                }

                var response = new BatchRequestResponse(isBatchSuccess, "200", data.ToJson());
                return(response);
            }
            catch (AggregateException ex)
            {
                BatchApiRequest.AbortBatchRequest();
                return(new BatchRequestResponse(false, "500", null, ex.ToString()));
            }
            catch (InvalidOperationException ex)
            {
                BatchApiRequest.AbortBatchRequest();
                return(new BatchRequestResponse(false, "500", null, ex.ToString()));
            }
        }
        public async Task TestBatchApiRequestsPauseAndResumeRequestAsync()
        {
            Trace.WriteLine("POST /batch");

            // Start the batch request
            BatchApiRequest.StartNewBatchRequest();

            try
            {
                // Make the API call to be batched
                await Template.GetTemplatesAsync();

                // Pause the batch request
                BatchApiRequest.PauseBatchRequest();

                // Make another API call and make sure it goes through
                var snippets = await Snippet.GetSnippetsAsync();

                SendwithusClientTest.ValidateResponse(snippets);

                // Resume the batch request and add another API call to it
                BatchApiRequest.ResumeBatchRequest();
                await Customer.GetCustomerAsync(CustomerTest.DEFAULT_CUSTOMER_EMAIL_ADDRESS);

                // Make the final batch request
                var batchResponses = await BatchApiRequest.SendBatchApiRequest();

                // Make sure both API calls were included in the batch request
                ValidateBatchApiCallResponses(batchResponses, 2);

                // Valideate each of those requests
                ValidateIndividualBatchedApiCallResponse <List <Template> >(batchResponses[0]);
                ValidateIndividualBatchedApiCallResponse <Customer>(batchResponses[1]);
            }
            catch (AggregateException exception)
            {
                Assert.Fail(exception.ToString());
            }
        }
Пример #9
0
        /// <summary>
        /// Sends an HTTP PUT request and returns the reponse as a JSON string
        /// </summary>
        /// <param name="resource">The resource identifier for the resource to be called (after /api/<version>/)</param>
        /// <param name="content">The object to be sent with the PUT request. Will be converted to JSON in this function</param>
        /// <returns>The response content in the form of a JSON string</returns>
        /// <exception cref="AggregateException">Thrown when the API response status code is not success or when the API call times out</exception>
        /// <exception cref="InvalidOperationException">Thrown when making a Batch API Request that has already reached the maxmimum API calls per batch request</exception>
        public static async Task <string> SendPutRequestAsync(string resource, object content)
        {
            using (var client = new HttpClient())
            {
                // Prepare the PUT request
                ConfigureHttpClient(client);
                var uri         = BuildFullResourceString(resource);
                var httpContent = ConvertObjectToJsonHttpContent(content);

                // If batch mode is enabled then add the request to the current batch of requests to send later on
                if (BatchApiRequest.IsBatchApiModeEnabled() == true)
                {
                    BatchApiRequest.AddApiRequest(new BatchApiRequest(uri, "PUT", content));
                    return(String.Empty);
                }
                // Otherwise, send the PUT request
                else
                {
                    return(await RunWithRetries(() => client.PutAsync(uri, httpContent)));
                }
            }
        }
Пример #10
0
        /// <summary>
        /// Sends an HTTP GET request and returns the reponse as a JSON string
        /// </summary>
        /// <param name="resource">The resource identifier for the resource to be called (after /api/<version>/)</param>
        /// <param name="queryParameters">The query parameters to use with the API call</param>
        /// <returns>The response content in the form of a JSON string</returns>
        /// <exception cref="AggregateException">Thrown when the API response status code is not success or when the API call times out</exception>
        /// <exception cref="InvalidOperationException">Thrown when making a Batch API Request that has already reached the maxmimum API calls per batch request</exception>
        public static async Task <string> SendGetRequestAsync(string resource, Dictionary <string, object> queryParameters)
        {
            using (var client = new HttpClient())
            {
                // Prepare the GET request
                ConfigureHttpClient(client);
                var queryString = ConvertQueryParametersToQueryString(queryParameters);
                var uri         = String.Format("{0}{1}", BuildFullResourceString(resource), queryString);

                // If batch mode is enabled then add the request to the current batch of requests to send later on
                if (BatchApiRequest.IsBatchApiModeEnabled() == true)
                {
                    BatchApiRequest.AddApiRequest(new BatchApiRequest(uri, "GET"));
                    return(String.Empty);
                }
                // Otherwise, send the GET request
                else
                {
                    return(await RunWithRetries(() => client.GetAsync(uri)));
                }
            }
        }
        public async Task TestBatchApiRequestsTwelveRequestsWithoutOverrideAsync()
        {
            Trace.WriteLine("POST /batch");

            // Start the batch request
            BatchApiRequest.StartNewBatchRequest();

            // Override the maximum number of API calls that can be included in this batch
            BatchApiRequest.OverrideMaximumBatchRequests(12);

            // Make the API calls to be batched (at least one of each type)
            try
            {
                await TemplateTest.BuildAndSendCreateTemplateRequestWithAllParametersAsync(); // POST

                await Snippet.GetSnippetsAsync();                                             // GET

                await Customer.GetCustomerAsync(CustomerTest.DEFAULT_CUSTOMER_EMAIL_ADDRESS); // GET

                await RenderTest.BuildAndSendRenderTemplateRequestWithAllParametersId();      // POST

                await Log.GetLogEventsAsync(BatchApiRequestTest.DEFAULT_LOG_ID);              // GET

                await Customer.GetCustomerAsync(CustomerTest.DEFAULT_CUSTOMER_EMAIL_ADDRESS); // GET

                await EmailTest.BuildAndSendEmailWithAllParametersAsync();                    // POST

                await DripCampaign.GetDripCampaignsAsync();                                   // GET

                await Customer.GetCustomerAsync(CustomerTest.DEFAULT_CUSTOMER_EMAIL_ADDRESS); // GET

                await Customer.GetCustomerAsync(CustomerTest.DEFAULT_CUSTOMER_EMAIL_ADDRESS); // GET

                await Customer.GetCustomerAsync(CustomerTest.DEFAULT_CUSTOMER_EMAIL_ADDRESS); // GET

                // Make the batch Api Request
                var batchResponses = await BatchApiRequest.SendBatchApiRequest();

                // Validate the response to the batch API request
                ValidateBatchApiCallResponses(batchResponses, 11);

                // Validate the response to the individual API calls
                ValidateIndividualBatchedApiCallResponse <Template>(batchResponses[0]);
                ValidateIndividualBatchedApiCallResponse <List <Snippet> >(batchResponses[1]);
                ValidateIndividualBatchedApiCallResponse <Customer>(batchResponses[2]);
                ValidateIndividualBatchedApiCallResponse <RenderTemplateResponse>(batchResponses[3]);
                ValidateIndividualBatchedApiCallResponse <List <Log> >(batchResponses[4]);
                ValidateIndividualBatchedApiCallResponse <Customer>(batchResponses[5]);
                ValidateIndividualBatchedApiCallResponse <EmailResponse>(batchResponses[6]);
                ValidateIndividualBatchedApiCallResponse <List <DripCampaignDetails> >(batchResponses[7]);
                ValidateIndividualBatchedApiCallResponse <Customer>(batchResponses[8]);
                ValidateIndividualBatchedApiCallResponse <Customer>(batchResponses[9]);
                ValidateIndividualBatchedApiCallResponse <Customer>(batchResponses[10]);
            }
            catch (InvalidOperationException exception)
            {
                Trace.WriteLine(String.Format("Successfully caught exception triggered by adding too many API calls to the batch API request. Error message: {0}", exception.Message));
                Assert.IsTrue(true);
            }
            finally
            {
                // Return the max batch request limit to its default value
                BatchApiRequest.SetMaximumBatchRequestsToDefault();
            }
        }
        public async Task TestBatchApiRequestsElevenRequestsWithoutOverrideAsync()
        {
            Trace.WriteLine("POST /batch");

            // Start the batch request
            BatchApiRequest.StartNewBatchRequest();

            try
            {
                // Make the API calls to be batched (at least one of each type)
                await TemplateTest.BuildAndSendCreateTemplateRequestWithAllParametersAsync(); // POST

                await Snippet.GetSnippetsAsync();                                             // GET

                await Customer.GetCustomerAsync(CustomerTest.DEFAULT_CUSTOMER_EMAIL_ADDRESS); // GET

                await RenderTest.BuildAndSendRenderTemplateRequestWithAllParametersId();      // POST

                await Log.GetLogEventsAsync(BatchApiRequestTest.DEFAULT_LOG_ID);              // GET

                await Customer.GetCustomerAsync(CustomerTest.DEFAULT_CUSTOMER_EMAIL_ADDRESS); // GET

                await EmailTest.BuildAndSendEmailWithAllParametersAsync();                    // POST

                await DripCampaign.GetDripCampaignsAsync();                                   // GET

                await Customer.GetCustomerAsync(CustomerTest.DEFAULT_CUSTOMER_EMAIL_ADDRESS); // GET

                await Customer.GetCustomerAsync(CustomerTest.DEFAULT_CUSTOMER_EMAIL_ADDRESS); // GET

                // Add the 11th API Request
                try
                {
                    await Customer.GetCustomerAsync(CustomerTest.DEFAULT_CUSTOMER_EMAIL_ADDRESS); // GET
                }
                catch (InvalidOperationException exception)
                {
                    Trace.WriteLine(String.Format("Successfully caught exception triggered by adding too many API calls to the batch API request. Error message: {0}", exception.Message));
                    Assert.IsTrue(true);
                }

                // Send the batch AP Request and make sure it still goes through (with the previous 10 requests included)
                var batchResponses = await BatchApiRequest.SendBatchApiRequest();

                // Validate the response to the batch API request
                ValidateBatchApiCallResponses(batchResponses, 10);

                // Validate the response to the individual API calls
                ValidateIndividualBatchedApiCallResponse <Template>(batchResponses[0]);
                ValidateIndividualBatchedApiCallResponse <List <Snippet> >(batchResponses[1]);
                ValidateIndividualBatchedApiCallResponse <Customer>(batchResponses[2]);
                ValidateIndividualBatchedApiCallResponse <RenderTemplateResponse>(batchResponses[3]);
                await Log.GetLogEventsAsync(BatchApiRequestTest.DEFAULT_LOG_ID); // GET

                ValidateIndividualBatchedApiCallResponse <Customer>(batchResponses[5]);
                ValidateIndividualBatchedApiCallResponse <EmailResponse>(batchResponses[6]);
                ValidateIndividualBatchedApiCallResponse <List <DripCampaignDetails> >(batchResponses[7]);
                ValidateIndividualBatchedApiCallResponse <Customer>(batchResponses[8]);
                ValidateIndividualBatchedApiCallResponse <Customer>(batchResponses[9]);
            }
            catch (AggregateException exception)
            {
                Assert.Fail(exception.ToString());
            }
        }
Пример #13
0
        public GitLfsResult GetBatchApiResponse(string urlScheme, string urlAuthority, string requestApplicationPath, string repositoryName, string[] acceptTypes, BatchApiRequest requestObj, Guid userId)
        {
            // Validate the request.
            if (!acceptTypes
                .Select(at => at.Split(new[] { ';' }))
                .SelectMany(list => list)
                .Any(at => at.Equals("application/vnd.git-lfs+json")))
            {
                return(GitLfsResult.From(
                           Newtonsoft.Json.JsonConvert.SerializeObject(
                               new BatchApiErrorResponse()
                {
                    Message = "Invalid ContentType."
                }),
                           406,
                           GitLfsConsts.GIT_LFS_CONTENT_TYPE));
            }

            // Check permissions
            RepositoryAccessLevel accessLevelRequested;

            if (requestObj.Operation.Equals(LfsOperationNames.DOWNLOAD))
            {
                accessLevelRequested = RepositoryAccessLevel.Pull;
            }
            else if (requestObj.Operation.Equals(LfsOperationNames.UPLOAD))
            {
                accessLevelRequested = RepositoryAccessLevel.Push;
            }
            else
            {
                accessLevelRequested = RepositoryAccessLevel.Administer;
            }

            bool authorized = RepositoryPermissionService.HasPermission(userId, RepositoryRepository.GetRepository(repositoryName).Id, accessLevelRequested);

            if (!authorized)
            {
                return(GitLfsResult.From(
                           Newtonsoft.Json.JsonConvert.SerializeObject(
                               new BatchApiErrorResponse()
                {
                    Message = "You do not have the required permissions."
                }),
                           403,
                           GitLfsConsts.GIT_LFS_CONTENT_TYPE));
            }

            if (requestObj == null)
            {
                return(GitLfsResult.From(
                           Newtonsoft.Json.JsonConvert.SerializeObject(
                               new BatchApiErrorResponse()
                {
                    Message = "Cannot parse request body."
                }),
                           400,
                           GitLfsConsts.GIT_LFS_CONTENT_TYPE));
            }


            // Process the request.
            var    requestedTransferAdapters     = requestObj.Transfers ?? (new string[] { LfsTransferProviderNames.BASIC });
            string firstSupportedTransferAdapter = requestedTransferAdapters.FirstOrDefault(t => t.Equals(LfsTransferProviderNames.BASIC));

            if (firstSupportedTransferAdapter != null)
            {
                string transferAdapterToUse = firstSupportedTransferAdapter;
                var    requiredSpace        = DetermineRequiredDiskSpace(requestObj);
                if (StorageProvider.SufficientSpace(requiredSpace))
                {
                    BatchApiResponse responseObj = new BatchApiResponse()
                    {
                        Transfer = transferAdapterToUse,
                        Objects  = requestObj.Objects
                                   .Select(ro => new { ro, ActionFactory = new LfsActionFactory() })
                                   .Select(x => new BatchApiResponse.BatchApiObject()
                        {
                            Oid           = x.ro.Oid,
                            Size          = x.ro.Size,
                            Authenticated = true,
                            Actions       = x.ActionFactory.CreateBatchApiObjectActions(urlScheme, urlAuthority, requestApplicationPath, requestObj.Operation, x.ro, repositoryName, StorageProvider)
                        })
                                   .ToArray()
                    };


                    return(GitLfsResult.From(responseObj, 200, GitLfsConsts.GIT_LFS_CONTENT_TYPE));
                }
                else
                {
                    return(GitLfsResult.From(new BatchApiErrorResponse()
                    {
                        Message = "Insufficient storage space."
                    }, 507, GitLfsConsts.GIT_LFS_CONTENT_TYPE));
                }
            }
            else
            {
                // None of the requested transfer adapters are supported.
                return(GitLfsResult.From(new BatchApiErrorResponse()
                {
                    Message = $"None of the requested transfer adapters are supported."
                }, 400, GitLfsConsts.GIT_LFS_CONTENT_TYPE));
            }
        }