public Request Build()
        {
            var request = _request;

            _request = CreateDefaultRequest();

            return request;
        }
        public void SetUp()
        {
            _aRequest = new Request();
            _retrievedPlaces = new Client.Resources.Places();
            _placeSearchResult = new PlaceSearchResult();
            _aLicenseInfo = new LicenseInfo { Login = "******", Key = "key" };

            _mockedSearchRequestBuilder = new Mock<IRequestBuilder>();
            _mockedRetriever = new Mock<IResourceRetriever>();
            _mockedConverter = new Mock<IPlacesConverter>();

            _provider = new PlaceSearcher(
                _mockedRetriever.Object,
                _mockedConverter.Object,
                _mockedSearchRequestBuilder.Object);
        }
        public void SetUp()
        {
            _aRequest = new Request();

            _anOkHttpResponse = new HttpResponse { Success = true, StatusCode = 200, Body = "body-content" };
            _anInvalidHttpResponse = new HttpResponse { Success = false, StatusCode = 400 };
            _anNotFoundHttpResponse = new HttpResponse { Success = false, StatusCode = 404 };

            _mockedRequestBuilder = new Mock<IHttpRequestBuilder>();
            _mockedHttpClient = new Mock<IHttpClient>();
            _mockedSerializer = new Mock<IXmlSerializerWrapper>();

            _retriever = new ResourceRetriever(
                _mockedRequestBuilder.Object,
                _mockedHttpClient.Object,
                _mockedSerializer.Object);
        }
        public string For(Request request)
        {
            var uriQuery = _uriQueryBuilder.Build(request.Arguments);

            var uriQueryWithStartIndex =
                String.Format(
                    "{0}{1}",
                    uriQuery,
                    CreateQueryStringForStartIndex(request));

            return String.Format(
                "{0}{1}{2}",
                _configurationWrapper.ValueFor(BaseUriKey),
                request.UriPath,
                uriQueryWithStartIndex != String.Empty
                    ? String.Format("?{0}", uriQueryWithStartIndex)
                    : String.Empty);
        }
        public void SetUp()
        {
            _request = new Request
                                 {
                                     Arguments = new List<KeyValuePair<string, string>>(),
                                     UriPath = "uri/path",
                                     StartsAtIndex = 0
                                 };

            _mockedConfiguration = new Mock<IConfigurationWrapper>();
            _mockedConfiguration
                .Setup(it => it.ValueFor(It.IsAny<string>()))
                .Returns("base-uri");

            _mockedUriQueryBuilder = new Mock<IUriQueryBuilder>();
            _mockedUriQueryBuilder
                .Setup(it => it.Build(It.IsAny<IEnumerable<KeyValuePair<string, string>>>()))
                .Returns("query-built");

            _builder = new UriBuilder(_mockedConfiguration.Object, _mockedUriQueryBuilder.Object);
        }
        private void CreateSearchRequest()
        {
            _request = new Request
            {
                LicenseKey = "key",
                LicenseLogin = "******",
                Arguments = new List<KeyValuePair<string, string>>
                                                     {
                                                         new KeyValuePair<string, string>("latitude", "-12.432"),
                                                         new KeyValuePair<string, string>("longitude", "-24.124"),
                                                         new KeyValuePair<string, string>("radius", "3")
                                                     }

            };
        }
        private PlaceSearchResult RetrievePlacesFor(Request searchRequest)
        {
            var places = _retriever.From<Resources.Places>(searchRequest);

            return _converter.ToEntity(places);
        }
 public HttpRequest For(Request request)
 {
     var uriBuilt = _uriBuilder.For(request);
     return CreateHttpRequest(request.LicenseLogin, request.LicenseKey, uriBuilt);
 }
 private static string CreateQueryStringForStartIndex(Request request)
 {
     return request.StartsAtIndex > 0
         ? String.Format("&start={0}", request.StartsAtIndex)
         : String.Empty ;
 }
 public RequestBuilder()
 {
     _request = CreateDefaultRequest();
 }
        private CategorySearcherTest GivenTheRequestCanBeBuilt()
        {
            _requestBuilt = new Request();

            _mockedRequestBuilder
                .Setup(it => it.WithLicenseInfo(It.IsAny<string>(), It.IsAny<string>()))
                .Returns(_mockedRequestBuilder.Object);
            _mockedRequestBuilder
                .Setup(it => it.WithUriPath(It.IsAny<string>()))
                .Returns(_mockedRequestBuilder.Object);
            _mockedRequestBuilder
                .Setup(it => it.WithStartIndex(It.IsAny<int>()))
                .Returns(_mockedRequestBuilder.Object);
            _mockedRequestBuilder
                .Setup(it => it.Build())
                .Returns(_requestBuilt);

            return this;
        }