public async Task Test_GetRestaurantsListByUserAndPostCodeAsync_When_justEatIntegrationService_FinishCorrect_RestarauntDataIsNotNull_Result_NoError()
        {
            //Arrange
            DeliveryDetailsInfoRequest input = new DeliveryDetailsInfoRequest {
                UserData = new UserCredentials()
            };

            _justEatRepositoryMock.Mock_GetSettings_CustomReturn(new JustEatIntegrationSettings
            {
                RestaurantsRequestType = "POST"
            });

            _justEatIntegrationServiceMock.Mock_GetRestaurantDetailsByUserAndPostcode_CustomReturn(new JustEatRestarauntResponseData
            {
                Restaurants = new List <RestaurantShortDetails>(),
                Errors      = null
            });

            //Act
            DeliveryDetailsInfoResponse result = await _restaurantService.GetRestaurantsListByUserAndPostCodeAsync(input);

            //Arrange
            Assert.NotNull(result);
            Assert.Null(result.Error);
            Assert.NotNull(result.Restaurants);
            Assert.IsType <DeliveryDetailsInfoResponse>(result);
        }
        public async Task Test_GetRestaurantsListByUserAndPostCodeAsync_WhenInput_Null_Result_ArgumentNullException()
        {
            //Arrange
            DeliveryDetailsInfoRequest input = null;

            //Act
            Func <Task> act = async() => await _restaurantService.GetRestaurantsListByUserAndPostCodeAsync(input);

            //Arrange
            await Assert.ThrowsAsync <ArgumentNullException>(act);
        }
        public async Task Test_GetRestaurantsListByUserAndPostCodeAsync_When_JustEatRepository_Null_ArgumentNullException()
        {
            //Arrange
            DeliveryDetailsInfoRequest input = new DeliveryDetailsInfoRequest {
                UserData = new UserCredentials()
            };

            _justEatRepositoryMock.Mock_GetSettings_CustomReturn(null);

            //Act
            Func <Task> act = async() => await _restaurantService.GetRestaurantsListByUserAndPostCodeAsync(input);

            //Arrange
            await Assert.ThrowsAsync <ArgumentNullException>(act);
        }
        public async Task Test_GetRestaurantsListByUserAndPostCodeAsync_When_justEatIntegrationServiceThrowsEx_ResultEx()
        {
            //Arrange
            DeliveryDetailsInfoRequest input = new DeliveryDetailsInfoRequest {
                UserData = new UserCredentials()
            };

            _justEatRepositoryMock.Mock_GetSettings_CustomReturn(new JustEatIntegrationSettings
            {
                RestaurantsRequestType = "POST"
            });
            _justEatIntegrationServiceMock.Mock_GetRestaurantDetailsByUserAndPostcode_ThrowsException();

            //Act
            Func <Task> act = async() => await _restaurantService.GetRestaurantsListByUserAndPostCodeAsync(input);

            //Arrange
            await Assert.ThrowsAsync <Exception>(act);
        }
        public async Task Test_GetRestaurantsListByUserAndPostCodeAsync_When_ApiMethodConverterError_Result_InvalidEnumArgumentException()
        {
            //Arrange
            DeliveryDetailsInfoRequest input = new DeliveryDetailsInfoRequest {
                UserData = new UserCredentials()
            };

            _justEatRepositoryMock.Mock_GetSettings_CustomReturn(new JustEatIntegrationSettings
            {
                CoreUrl = "abc",
                RestaurantsRequestType = "abcasda"
            });

            //Act
            Func <Task> act = async() => await _restaurantService.GetRestaurantsListByUserAndPostCodeAsync(input);

            //Arrange
            await Assert.ThrowsAsync <InvalidEnumArgumentException>(act);
        }
        public async Task <DeliveryDetailsInfoResponse> GetRestaurantsListByUserAndPostCodeAsync(DeliveryDetailsInfoRequest deliveryDetails)
        {
            if (deliveryDetails == null || deliveryDetails.UserData == null)
            {
                //log
                throw new ArgumentNullException($"The ({nameof(deliveryDetails)}) object is null!");
            }

            JustEatIntegrationSettings integrationSettings = _justEatRepository.GetSettings();

            if (integrationSettings == null)
            {
                //log
                throw new ArgumentNullException($"The ({nameof(integrationSettings)}) object is null!");
            }

            string requestQuery = "";

            if (integrationSettings.QueryParameters != null && integrationSettings.QueryParameters.Count > 0)
            {
                bool           firtTime             = true;
                PropertyInfo[] requestPropertyInfos = typeof(DeliveryDetailsInfoRequest).GetProperties();
                foreach (var item in requestPropertyInfos)
                {
                    QueryParameter foundItem = integrationSettings.QueryParameters.SingleOrDefault(x => x.Description.ToLower() == item.Name.ToLower());

                    if (foundItem != null)
                    {
                        var objectValue = PropertyExtentions.GetPropValue <DeliveryDetailsInfoRequest>(deliveryDetails, item.Name);
                        if (firtTime)
                        {
                            requestQuery += $"?{foundItem.Key}={objectValue}";
                            firtTime      = false;
                        }
                        else
                        {
                            requestQuery += $"&{foundItem.Key}={objectValue}";
                        }
                    }
                }
            }

            var result = await _justEatIntegrationService.GetRestaurantListForUserByDeliveryPostcodeAsync(new IJustEatRequest <JustEatRestaurantsBasicRequest>()
            {
                ApiMethod = HttpApiMethodsTypeConverter.StringToEnum(integrationSettings.RestaurantsRequestType),
                AuthType  = HttpAuthType.BasicAuth,
                Header    = integrationSettings?.RequestHeader != null ? integrationSettings.RequestHeader.Select(x => new CustomHeader {
                    HeaderName = x.Key, HeaderValue = x.Value
                }).ToList() : null,
                Query       = requestQuery,
                CoreUrl     = integrationSettings.CoreUrl,
                Endpoint    = integrationSettings.RestaurantsEndpoint,
                RequestBody = new JustEatRestaurantsBasicRequest
                {
                    Username = deliveryDetails.UserData.UserName,
                    Password = deliveryDetails.UserData.Password,
                    Postcode = deliveryDetails.Postcode
                },
                TbodyRequired = true
            });

            if (result == null)
            {
                //log
                throw new ArgumentNullException($"Unpredicted error occured in {nameof(_justEatIntegrationService)} response");
            }

            return(new DeliveryDetailsInfoResponse
            {
                Restaurants = result.Restaurants != null?result.Restaurants.Select(x => new Models.Restaurant
                {
                    Id = x.DisplayId,
                    CuisineTypes = (x.CuisineTypes != null) ? x.CuisineTypes.Select(y => y.Name).ToList() : null,
                    Rating = (x.RatingDetails != null) ? x.RatingDetails.RatingAverage: 0,
                    ImageUrl = x.LogUrl,
                    Name = x.Name
                }).OrderBy(v => v.Id).ToList() : null,

                                  Error = (result.Errors != null && result.Errors.Count > 0) ? result.Errors[0] : null,
            });
        }