public void OffsetTest()
{
var request = new PlaceAutocompleteRequest
{
ApiKey = base.ApiKey,
Input = "abbeyjibberish",
Location = new Entities.Common.Location(53.4635332, -2.2419169),
Radius = 30000
};
PlaceAutocompleteResponse result = GoogleMaps.PlaceAutocomplete.Query(request);
AssertInconclusive.NotExceedQuota(result);
Assert.AreEqual(Status.ZERO_RESULTS, result.Status, "results for jibberish");
var offsetRequest = new PlaceAutocompleteRequest
{
ApiKey = base.ApiKey,
Input = "abbeyjibberish",
Offset = 5,
Location = new Entities.Common.Location(53.4635332, -2.2419169)
};
PlaceAutocompleteResponse offsetResult = GoogleMaps.PlaceAutocomplete.Query(offsetRequest);
AssertInconclusive.NotExceedQuota(result);
Assert.AreEqual(Status.OK, offsetResult.Status, "results using offset");
}
public async Task ShouldReplaceUriViaOnUriCreatedAsync()
{
var request = new DistanceMatrixRequest
{
Origins = new[] { "placeholder" },
Destinations = new[] { "3,4" },
ApiKey = ApiKey
};
Uri OnUriCreated(Uri uri)
{
var builder = new UriBuilder(uri);
var tmp = builder.Query.Replace("placeholder", "1,2").Remove(0, 1);
builder.Query = tmp;
return(builder.Uri);
}
GoogleMaps.DistanceMatrix.OnUriCreated += OnUriCreated;
try
{
var result = await GoogleMaps.DistanceMatrix.QueryAsync(request);
AssertInconclusive.NotExceedQuota(result);
Assert.AreEqual(DistanceMatrixStatusCodes.OK, result.Status, result.ErrorMessage);
Assert.AreEqual("1,2", result.OriginAddresses.First());
}
finally
{
GoogleMaps.DistanceMatrix.OnUriCreated -= OnUriCreated;
}
}
public void ShouldPassRawDataToOnRawResponseReceived()
{
var request = new DistanceMatrixRequest
{
ApiKey = ApiKey,
Origins = new[] { "placeholder" },
Destinations = new[] { "3,4" },
};
HttpContent rawData = null;
void OnRawResponseReceived(HttpResponseMessage data) => rawData = data.Content;
GoogleMaps.DistanceMatrix.OnRawResponseReceived += OnRawResponseReceived;
try
{
var result = GoogleMaps.DistanceMatrix.Query(request);
AssertInconclusive.NotExceedQuota(result);
Assert.AreEqual(DistanceMatrixStatusCodes.OK, result.Status, result.ErrorMessage);
Assert.IsNotNull(rawData);
}
finally
{
GoogleMaps.DistanceMatrix.OnRawResponseReceived -= OnRawResponseReceived;
}
}
public void ShouldReplaceUriViaOnUriCreated()
{
var request = new DistanceMatrixRequest
{
ApiKey = ApiKey,
Origins = new[] { "placeholder" },
Destinations = new[] { "3,4" },
};
UriCreatedDelegate onUriCreated = delegate(Uri uri)
{
var builder = new UriBuilder(uri);
builder.Query = builder.Query.Replace("placeholder", "1,2");
return(builder.Uri);
};
GoogleMaps.DistanceMatrix.OnUriCreated += onUriCreated;
try
{
var result = GoogleMaps.DistanceMatrix.Query(request);
AssertInconclusive.NotExceedQuota(result);
Assert.AreEqual(DistanceMatrixStatusCodes.OK, result.Status, result.ErrorMessage);
Assert.AreEqual("1,2", result.OriginAddresses.First());
}
finally
{
GoogleMaps.DistanceMatrix.OnUriCreated -= onUriCreated;
}
}
public void Directions_ExceedingRouteLength()
{
var request = new DirectionsRequest
{
Origin = "NYC, USA", Destination = "Miami, USA", Waypoints = new string[]
{
"Seattle, USA",
"Dallas, USA",
"Naginey, USA",
"Edmonton, Canada",
"Seattle, USA",
"Dallas, USA",
"Naginey, USA",
"Edmonton, Canada",
"Seattle, USA",
"Dallas, USA",
"Naginey, USA",
"Edmonton, Canada"
},
ApiKey = ApiKey
};
var result = GoogleMaps.Directions.Query(request);
AssertInconclusive.NotExceedQuota(result);
Assert.AreEqual(DirectionsStatusCodes.MAX_ROUTE_LENGTH_EXCEEDED, result.Status, result.ErrorMessage);
}
public void ReturnsOpeningTimes()
{
var request = new PlacesDetailsRequest
{
ApiKey = ApiKey,
PlaceId = GetMyPlaceId(),
};
PlacesDetailsResponse result = GoogleMaps.PlacesDetails.Query(request);
AssertInconclusive.NotExceedQuota(result);
Assert.AreEqual(Status.OK, result.Status);
// commented out because seems like google doesn't have opening hours for this place anymore
/*
* Assert.AreEqual(7, result.Result.OpeningHours.Periods.Count());
* var sundayPeriod = result.Result.OpeningHours.Periods.First();
* Assert.That(sundayPeriod.OpenTime.Day, Is.EqualTo(DayOfWeek.Sunday));
* Assert.That(sundayPeriod.OpenTime.Time, Is.GreaterThanOrEqualTo(0));
* Assert.That(sundayPeriod.OpenTime.Time, Is.LessThanOrEqualTo(2359));
* Assert.That(sundayPeriod.CloseTime.Time, Is.GreaterThanOrEqualTo(0));
* Assert.That(sundayPeriod.CloseTime.Time, Is.LessThanOrEqualTo(2359));
*/
}
public void ShouldPassRawDataToOnRawResponseRecivied()
{
var request = new DistanceMatrixRequest
{
ApiKey = ApiKey,
Origins = new[] { "placeholder" },
Destinations = new[] { "3,4" },
};
var rawData = new byte[0];
RawResponseReciviedDelegate onRawResponseRecivied = data => rawData = data;
GoogleMaps.DistanceMatrix.OnRawResponseRecivied += onRawResponseRecivied;
try
{
var result = GoogleMaps.DistanceMatrix.Query(request);
AssertInconclusive.NotExceedQuota(result);
Assert.AreEqual(DistanceMatrixStatusCodes.OK, result.Status, result.ErrorMessage);
CollectionAssert.IsNotEmpty(rawData);
}
finally
{
GoogleMaps.DistanceMatrix.OnRawResponseRecivied -= onRawResponseRecivied;
}
}
public void Directions_WithIcons()
{
var depTime = DateTime.Today
.AddDays(1)
.AddHours(13);
var request = new DirectionsRequest
{
Origin = "T-centralen, Stockholm, Sverige",
Destination = "Kungsträdgården, Stockholm, Sverige",
TravelMode = TravelMode.Transit,
DepartureTime = depTime,
Language = "sv",
ApiKey = ApiKey
};
DirectionsResponse result = GoogleMaps.Directions.Query(request);
AssertInconclusive.NotExceedQuota(result);
var route = result.Routes.First();
var leg = route.Legs.First();
var steps = leg.Steps;
Assert.IsNotEmpty(steps.Where(s =>
s.TransitDetails?
.Lines?
.Vehicle?
.Icon != null));
}
public void Directions_VerifyBounds()
{
var request = new DirectionsRequest
{
Origin = "Genk, Belgium",
Destination = "Brussels, Belgium",
TravelMode = TravelMode.Driving,
ApiKey = ApiKey
};
DirectionsResponse result = GoogleMaps.Directions.Query(request);
AssertInconclusive.NotExceedQuota(result);
var route = result.Routes.First();
Assert.NotNull(route);
Assert.NotNull(route.Bounds);
Assert.Greater(route.Bounds.NorthEast.Latitude, 50);
Assert.Greater(route.Bounds.NorthEast.Longitude, 3);
Assert.Greater(route.Bounds.SouthWest.Latitude, 50);
Assert.Greater(route.Bounds.SouthWest.Longitude, 3);
Assert.Greater(route.Bounds.Center.Latitude, 50);
Assert.Greater(route.Bounds.Center.Longitude, 3);
}
public void CheckLargerThenEarthRadius()
{
var request = CreatePlaceAutocompleteRequest("RIX", 30000000);
PlaceAutocompleteResponse result = GoogleMaps.PlaceAutocomplete.Query(request);
AssertInconclusive.NotExceedQuota(result);
Assert.AreNotEqual(Status.ZERO_RESULTS, result.Status);
}
public async Task CheckNegativeRadiusAsync()
{
var request = CreatePlaceAutocompleteRequest("RIX", -1);
PlaceAutocompleteResponse result = await GoogleMaps.PlaceAutocomplete.QueryAsync(request);
AssertInconclusive.NotExceedQuota(result);
Assert.AreNotEqual(Status.ZERO_RESULTS, result.Status);
}
public void DirectionsAsync_SumOfStepDistancesCorrect()
{
var request = new DirectionsRequest {
Origin = "285 Bedford Ave, Brooklyn, NY, USA", Destination = "185 Broadway Ave, Manhattan, NY, USA", ApiKey = ApiKey
};
var result = GoogleMaps.Directions.QueryAsync(request).Result;
AssertInconclusive.NotExceedQuota(result);
Assert.AreEqual(DirectionsStatusCodes.OK, result.Status, result.ErrorMessage);
Assert.Greater(result.Routes.First().Legs.First().Steps.Sum(s => s.Distance.Value), 100);
}
public void TimeZone_Correct_OverviewPath()
{
TimeZoneRequest request = new TimeZoneRequest();
request.Location = new Location(55.866413, 12.501063);
request.Language = "en";
TimeZoneResponse result = GoogleMaps.TimeZone.Query(request);
AssertInconclusive.NotExceedQuota(result);
Assert.AreEqual(Status.OK, result.Status);
}
public void Directions_WithWayPoints()
{
var request = new DirectionsRequest {
Origin = "NYC, USA", Destination = "Miami, USA", Waypoints = new string[] { "Philadelphia, USA" }, OptimizeWaypoints = true, ApiKey = ApiKey
};
var result = GoogleMaps.Directions.Query(request);
AssertInconclusive.NotExceedQuota(result);
Assert.AreEqual(DirectionsStatusCodes.OK, result.Status, result.ErrorMessage);
Assert.AreEqual(156097, result.Routes.First().Legs.First().Steps.Sum(s => s.Distance.Value), 10 * 1000);
StringAssert.Contains("Philadelphia", result.Routes.First().Legs.First().EndAddress);
}
public void ReturnsPhotos()
{
var request = new PlacesDetailsRequest
{
ApiKey = ApiKey,
PlaceId = "ChIJZ3VuVMQdLz4REP9PWpQ4SIY"
};
PlacesDetailsResponse result = GoogleMaps.PlacesDetails.Query(request);
AssertInconclusive.NotExceedQuota(result);
Assert.AreEqual(Status.OK, result.Status);
Assert.IsNotEmpty(result.Result.Photos);
}
public void ElevationAsync_ReturnsCorrectElevation()
{
var request = new ElevationRequest
{
ApiKey = ApiKey,
Locations = new[] { new Location(40.7141289, -73.9614074) }
};
var result = GoogleMaps.Elevation.Query(request);
AssertInconclusive.NotExceedQuota(result);
Assert.AreEqual(Entities.Elevation.Response.Status.OK, result.Status);
Assert.AreEqual(16.92, result.Results.First().Elevation, 1.0);
}
public async Task TimeZone_Correct_OverviewPathAsync()
{
TimeZoneRequest request = new TimeZoneRequest
{
Location = new Location(55.866413, 12.501063),
Language = "en",
ApiKey = ApiKey
};
TimeZoneResponse result = await GoogleMaps.TimeZone.QueryAsync(request);
AssertInconclusive.NotExceedQuota(result);
Assert.AreEqual(Status.OK, result.Status);
}
public void ReturnsStronglyTypedPriceLevel()
{
var request = new PlacesDetailsRequest
{
ApiKey = ApiKey,
PlaceId = GetMyPlaceId(),
};
PlacesDetailsResponse result = GoogleMaps.PlacesDetails.Query(request);
AssertInconclusive.NotExceedQuota(result);
Assert.AreEqual(Status.OK, result.Status);
Assert.That(new PriceLevel[] { result.Result.PriceLevel.Value }, Is.SubsetOf(anyPriceLevel));
}
public void ReturnsNotFoundForWrongReferenceString()
{
var request = new PlacesDetailsRequest
{
ApiKey = base.ApiKey,
// Needs to be a correct looking reference. 1 character too short or long and google will return INVALID_REQUEST instead.
PlaceId = "ChIJbWWgrQAVkFQReAwrXXWzlYs"
};
PlacesDetailsResponse result = GoogleMaps.PlacesDetails.Query(request);
AssertInconclusive.NotExceedQuota(result);
Assert.AreEqual(Status.NOT_FOUND, result.Status);
}
public void ReverseGeocoding_ReturnsCorrectAddress()
{
var request = new GeocodingRequest
{
ApiKey = ApiKey,
Location = new Location(40.7141289, -73.9614074)
};
var result = GoogleMaps.Geocode.Query(request);
AssertInconclusive.NotExceedQuota(result);
Assert.AreEqual(Status.OK, result.Status);
StringAssert.Contains("Bedford Ave, Brooklyn, NY 11211, USA", result.Results.First().FormattedAddress);
}
public async Task ReturnsStronglyTypedPriceLevelAsync()
{
var request = new PlacesDetailsRequest
{
ApiKey = ApiKey,
PlaceId = await GetMyPlaceIdAsync()
};
PlacesDetailsResponse result = await GoogleMaps.PlacesDetails.QueryAsync(request);
AssertInconclusive.NotExceedQuota(result);
Assert.AreEqual(Status.OK, result.Status);
Assert.NotNull(result.Result.PriceLevel);
Assert.That(new PriceLevel[] { result.Result.PriceLevel.Value }, Is.SubsetOf(_anyPriceLevel));
}
public void Geocoding_ReturnsCorrectLocation()
{
var request = new GeocodingRequest
{
ApiKey = ApiKey,
Address = "285 Bedford Ave, Brooklyn, NY 11211, USA"
};
var result = GoogleMaps.Geocode.Query(request);
AssertInconclusive.NotExceedQuota(result);
Assert.AreEqual(Status.OK, result.Status);
// 40.{*}, -73.{*}
StringAssert.IsMatch("40\\.\\d*,-73\\.\\d*", result.Results.First().Geometry.Location.LocationString);
}
public void ReturnsResults()
{
var request = new PlacesFindRequest
{
ApiKey = ApiKey,
Input = "pizza chicago il",
InputType = InputType.TextQuery
};
PlacesFindResponse result = GoogleMaps.PlacesFind.Query(request);
AssertInconclusive.NotExceedQuota(result);
Assert.AreEqual(Status.OK, result.Status);
Assert.IsNotEmpty(result.Candidates);
}
public void Directions_ErrorMessage()
{
var request = new DirectionsRequest
{
ApiKey = "UNIT-TEST-FAKE-KEY", // Wrong API Key
Origin = "285 Bedford Ave, Brooklyn, NY, USA",
Destination = "185 Broadway Ave, Manhattan, NY, USA"
};
var result = GoogleMaps.Directions.Query(request);
AssertInconclusive.NotExceedQuota(result);
Assert.AreEqual(DirectionsStatusCodes.REQUEST_DENIED, result.Status);
Assert.IsNotNull(result.ErrorMessage);
Assert.IsNotEmpty(result.ErrorMessage);
}
public void ReturnsPhotos()
{
var request = new PlacesTextRequest
{
ApiKey = ApiKey,
Query = "1600 Pennsylvania Ave NW",
Types = "address"
};
PlacesTextResponse result = GoogleMaps.PlacesText.Query(request);
AssertInconclusive.NotExceedQuota(result);
Assert.AreEqual(Status.OK, result.Status);
Assert.That(result.Results, Is.Not.Null.And.Not.Empty);
}
public void ReturnsFormattedAddress()
{
var request = new PlacesTextRequest
{
ApiKey = ApiKey,
Query = "1 smith st parramatta",
Types = "address"
};
PlacesTextResponse result = GoogleMaps.PlacesText.Query(request);
AssertInconclusive.NotExceedQuota(result);
Assert.AreEqual(Status.OK, result.Status);
Assert.AreEqual("1 Smith St, Parramatta NSW 2150, Australia", result.Results.First().FormattedAddress);
}
public void ShouldReturnImperialUnitsIfImperialPassedAsParameter()
{
var request = new DistanceMatrixRequest
{
ApiKey = ApiKey,
Units = DistanceMatrixUnitSystems.imperial,
Origins = new[] { "49.64265,12.50088" },
Destinations = new[] { "53.64308,10.52726" },
};
var result = GoogleMaps.DistanceMatrix.Query(request);
AssertInconclusive.NotExceedQuota(result);
Assert.True(result.Rows.First().Elements.First().Distance.Text.Contains("mi"));
}
public void ReturnsNoResults()
{
var request = new PlaceAutocompleteRequest
{
ApiKey = base.ApiKey,
Input = "zxqtrb",
Location = new Entities.Common.Location(53.4635332, -2.2419169),
Radius = 30000
};
PlaceAutocompleteResponse result = GoogleMaps.PlaceAutocomplete.Query(request);
AssertInconclusive.NotExceedQuota(result);
Assert.AreEqual(Status.ZERO_RESULTS, result.Status);
}
public void ReturnsNearbySearchRequest()
{
var request = new PlacesRequest
{
ApiKey = ApiKey,
Keyword = "pizza",
Radius = 10000,
Location = new Location(47.611162, -122.337644), //Seattle, Washington, USA
};
PlacesResponse result = GoogleMaps.Places.Query(request);
AssertInconclusive.NotExceedQuota(result);
Assert.AreEqual(Status.OK, result.Status);
Assert.IsTrue(result.Results.Count() > 5);
}
public void CheckForExpectedRoad(string aSearch, string anExpected)
{
var request = new PlaceAutocompleteRequest
{
ApiKey = base.ApiKey,
Input = aSearch,
Location = new GoogleMapsApi.Entities.Common.Location(53.4635332, -2.2419169),
Radius = 30000
};
PlaceAutocompleteResponse result = GoogleMaps.PlaceAutocomplete.Query(request);
AssertInconclusive.NotExceedQuota(result);
Assert.AreNotEqual(Status.ZERO_RESULTS, result.Status);
Assert.That(result.Results.Any(t => t.Description.ToUpper().Contains(anExpected)));
}
