public void ConstructorDefaultTest()
{
var request = new SpeedLimitsRequest();
Assert.IsTrue(request.IsSsl);
Assert.AreEqual(Units.Kph, request.Unit);
}
public void GetQueryStringParametersWhenPlacesTest()
{
var request = new SpeedLimitsRequest
{
Key = "key",
Places = new[]
{
new Place("place1"),
new Place("place2")
}
};
var queryStringParameters = request.GetQueryStringParameters();
Assert.IsNotNull(queryStringParameters);
var place1 = queryStringParameters.FirstOrDefault(x => x.Key == "placeId");
var place1Expected = request.Places.First().ToString();
Assert.IsNotNull(place1);
Assert.AreEqual(place1Expected, place1.Value);
var place2 = queryStringParameters.LastOrDefault(x => x.Key == "placeId");
var place2Expected = request.Places.Last().ToString();
Assert.IsNotNull(place2);
Assert.AreEqual(place2Expected, place2.Value);
}
public void GetQueryStringParametersWhenPathTest()
{
var request = new SpeedLimitsRequest
{
Key = "key",
Path = new[]
{
new Coordinate(1, 1),
new Coordinate(2, 2)
}
};
var queryStringParameters = request.GetQueryStringParameters();
Assert.IsNotNull(queryStringParameters);
var key = queryStringParameters.SingleOrDefault(x => x.Key == "key");
var keyExpected = request.Key;
Assert.IsNotNull(key);
Assert.AreEqual(keyExpected, key.Value);
var path = queryStringParameters.FirstOrDefault(x => x.Key == "path");
var pathExpected = string.Join("|", request.Path);
Assert.IsNotNull(path);
Assert.AreEqual(pathExpected, path.Value);
}
public void NearestRoadsWhenPathIsNullAndPlaceIdsIsNullTest()
{
var request = new SpeedLimitsRequest
{
Key = this.ApiKey
};
var exception = Assert.Throws<ArgumentException>(() => GoogleMaps.SpeedLimits.Query(request));
Assert.IsNotNull(exception);
Assert.AreEqual(exception.Message, "Path or PlaceId's is required.");
}
public void SpeedLimitsWhenKeyIsStringEmptyTest()
{
var request = new SpeedLimitsRequest
{
Key = string.Empty,
Path = new[] { new Entities.Maps.Roads.Common.Location(0, 0) }
};
var exception = Assert.Throws<ArgumentException>(() => GoogleMaps.SpeedLimits.Query(request));
Assert.IsNotNull(exception);
Assert.AreEqual(exception.Message, "Key is required.");
}
public void SpeedLimitsWhenPlaceIdsTest()
{
var request = new SpeedLimitsRequest
{
Key = this.ApiKey,
PlaceIds = new[] { "test" }
};
var result = GoogleMaps.SpeedLimits.Query(request);
Assert.IsNotNull(result);
Assert.AreEqual(Status.Ok, result.Status);
}
public void SpeedLimitsWhenAsyncTest()
{
var request = new SpeedLimitsRequest
{
Key = this.ApiKey,
Path = new[] { new Location(0, 0) }
};
var result = GoogleMaps.SpeedLimits.QueryAsync(request).Result;
Assert.IsNotNull(result);
Assert.AreEqual(Status.Ok, result.Status);
}
public void SpeedLimitsWhenPlaceIdsCountIsGreaterThanAllowedTest()
{
var request = new SpeedLimitsRequest
{
Key = this.ApiKey,
PlaceIds = new string[101]
};
var exception = Assert.Throws<ArgumentException>(() => GoogleMaps.SpeedLimits.Query(request));
Assert.IsNotNull(exception);
Assert.AreEqual(exception.Message, "Max 100 PlaceId's is allowed.");
}
public void NearestRoadsWhenPathIsEmptyAndPlaceIdsIsEmptyTest()
{
var request = new SpeedLimitsRequest()
{
Key = this.ApiKey,
Path = new Entities.Maps.Roads.Common.Location[0],
PlaceIds = new string[0]
};
var exception = Assert.Throws<ArgumentException>(() => GoogleMaps.SpeedLimits.Query(request));
Assert.IsNotNull(exception);
Assert.AreEqual(exception.Message, "Path or PlaceId's is required.");
}
public void SpeedLimitsWhenKeyIsNullTest()
{
var request = new SpeedLimitsRequest
{
Key = null,
Path = new[] { new Location(0, 0) }
};
var exception = Assert.Throws <ArgumentException>(() => GoogleMaps.SpeedLimits.Query(request));
Assert.IsNotNull(exception);
Assert.AreEqual(exception.Message, "Key is required");
}
public void GetQueryStringParametersTest()
{
var request = new SpeedLimitsRequest
{
Key = "abc",
Path = new[]
{
new Location(1, 1),
new Location(2, 2)
}
};
Assert.DoesNotThrow(() => request.GetQueryStringParameters());
}
public void SpeedLimitsAsyncCancelledTest()
{
var request = new SpeedLimitsRequest
{
Key = this.ApiKey,
Path = new[] { new Entities.Maps.Roads.Common.Location(0, 0) }
};
var cancellationTokenSource = new CancellationTokenSource();
var task = GoogleMaps.SpeedLimits.QueryAsync(request, cancellationTokenSource.Token);
cancellationTokenSource.Cancel();
var exception = Assert.Throws<OperationCanceledException>(() => task.Wait(cancellationTokenSource.Token));
Assert.IsNotNull(exception);
Assert.AreEqual(exception.Message, "The operation was canceled.");
}
public void GetQueryStringParametersWhenPathIsNullAndPlaceIdsIsNullTest()
{
var request = new SpeedLimitsRequest
{
Key = "abc"
};
var exception = Assert.Throws <ArgumentException>(() =>
{
var parameters = request.GetQueryStringParameters();
Assert.IsNull(parameters);
});
Assert.IsNotNull(exception);
Assert.AreEqual(exception.Message, "Path or PlaceId's is required");
}
public void GetQueryStringParametersWhenKeyIsStringEmptyTest()
{
var request = new SpeedLimitsRequest
{
Key = string.Empty
};
var exception = Assert.Throws <ArgumentException>(() =>
{
var parameters = request.GetQueryStringParameters();
Assert.IsNull(parameters);
});
Assert.IsNotNull(exception);
Assert.AreEqual(exception.Message, "'Key' is required");
}
public void GetQueryStringParametersWhenKeyIsNullTest()
{
var request = new SpeedLimitsRequest
{
Key = null,
Path = new[] { new Location(0, 0) }
};
var exception = Assert.Throws <ArgumentException>(() =>
{
var parameters = request.GetQueryStringParameters();
Assert.IsNull(parameters);
});
Assert.IsNotNull(exception);
Assert.AreEqual(exception.Message, "Key is required");
}
public void GetQueryStringParametersWhenPathAndTooManyTest()
{
var request = new SpeedLimitsRequest
{
Key = "key",
Path = new Coordinate[101]
};
var exception = Assert.Throws <ArgumentException>(() =>
{
var parameters = request.GetQueryStringParameters();
Assert.IsNull(parameters);
});
Assert.IsNotNull(exception);
Assert.AreEqual(exception.Message, "'Path' must contain equal or less than 100 coordinates");
}
public void GetUriWhenPlaceIdsTest()
{
var request = new SpeedLimitsRequest
{
Key = "abc",
PlaceIds = new[]
{
"abc",
"def"
}
};
var uri = request.GetUri();
Assert.IsNotNull(uri);
Assert.AreEqual($"/v1/speedLimits?key={request.Key}&placeId={Uri.EscapeDataString(request.PlaceIds.First())}&placeId={Uri.EscapeDataString(request.PlaceIds.Last())}", uri.PathAndQuery);
}
public void GetUriTest()
{
var request = new SpeedLimitsRequest
{
Key = "abc",
Path = new[]
{
new Location(1, 1),
new Location(2, 2)
}
};
var uri = request.GetUri();
Assert.IsNotNull(uri);
Assert.AreEqual($"/v1/speedLimits?key={request.Key}&path={Uri.EscapeDataString(string.Join("|", request.Path))}", uri.PathAndQuery);
}
public void GetQueryStringParametersWhenPlaceIdsCountIsGreaterThanAllowedTest()
{
var request = new SpeedLimitsRequest
{
Key = "abc",
PlaceIds = new string[101]
};
var exception = Assert.Throws <ArgumentException>(() =>
{
var parameters = request.GetQueryStringParameters();
Assert.IsNull(parameters);
});
Assert.IsNotNull(exception);
Assert.AreEqual(exception.Message, "Max PlaceId's exceeded");
}
public void SpeedLimitsWhenPathIsNullAndPlaceIdsIsNullTest()
{
var request = new SpeedLimitsRequest
{
Key = this.ApiKey
};
var exception = Assert.Throws <AggregateException>(() => GoogleMaps.SpeedLimits.QueryAsync(request).Wait());
Assert.IsNotNull(exception);
var innerException = exception.InnerException;
Assert.IsNotNull(innerException);
Assert.AreEqual(typeof(GoogleApiException), innerException.GetType());
Assert.AreEqual(innerException.Message, "Path or PlaceId's is required");
}
public void SpeedLimitsTest()
{
var request = new SpeedLimitsRequest
{
Key = this.ApiKey,
Path = new[]
{
new Entities.Maps.Roads.Common.Location(60.170880, 24.942795),
new Entities.Maps.Roads.Common.Location(60.170879, 24.942796),
new Entities.Maps.Roads.Common.Location(60.170877, 24.942796)
}
};
var result = GoogleMaps.SpeedLimits.Query(request);
Assert.IsNotNull(result);
Assert.AreEqual(Status.Ok, result.Status);
}
public void GetQueryStringParametersWhenPathIsEmptyAndPlaceIdsIsEmptyTest()
{
var request = new SpeedLimitsRequest
{
Key = this.ApiKey,
Path = new Location[0],
PlaceIds = new string[0]
};
var exception = Assert.Throws <ArgumentException>(() =>
{
var parameters = request.GetQueryStringParameters();
Assert.IsNull(parameters);
});
Assert.IsNotNull(exception);
Assert.AreEqual(exception.Message, "Path or PlaceId's is required");
}
public void SpeedLimitsWhenKeyIsNullTest()
{
var request = new SpeedLimitsRequest
{
Key = null,
Path = new[] { new Location(0, 0) }
};
var exception = Assert.Throws <AggregateException>(() => GoogleMaps.SpeedLimits.QueryAsync(request).Wait());
Assert.IsNotNull(exception);
var innerException = exception.InnerException;
Assert.IsNotNull(innerException);
Assert.AreEqual(typeof(GoogleApiException), innerException.GetType());
Assert.AreEqual(innerException.Message, "Key is required");
}
public void SpeedLimitsWhenPlaceIdsCountIsGreaterThanAllowedTest()
{
var request = new SpeedLimitsRequest
{
Key = this.ApiKey,
PlaceIds = new string[101]
};
var exception = Assert.Throws <AggregateException>(() => GoogleMaps.SpeedLimits.QueryAsync(request).Wait());
Assert.IsNotNull(exception);
var innerException = exception.InnerException;
Assert.IsNotNull(innerException);
Assert.AreEqual(typeof(GoogleApiException), innerException.GetType());
Assert.AreEqual(innerException.Message, "Max PlaceId's exceeded");
}
public void SpeedLimitsWhenKeyIsStringEmptyTest()
{
var request = new SpeedLimitsRequest
{
Key = string.Empty,
Path = new[] { new Location(0, 0) }
};
var exception = Assert.Throws <AggregateException>(() => GoogleMaps.SpeedLimits.Query(request));
Assert.IsNotNull(exception);
Assert.AreEqual("One or more errors occurred.", exception.Message);
var innerException = exception.InnerException;
Assert.IsNotNull(innerException);
Assert.AreEqual(typeof(GoogleApiException), innerException.GetType());
Assert.AreEqual(innerException.Message, "Key is required");
}
public void SpeedLimitsWhenPathIsEmptyAndPlaceIdsIsEmptyTest()
{
var request = new SpeedLimitsRequest
{
Key = this.ApiKey,
Path = new Location[0],
PlaceIds = new string[0]
};
var exception = Assert.Throws <AggregateException>(() => GoogleMaps.SpeedLimits.QueryAsync(request).Wait());
Assert.IsNotNull(exception);
Assert.AreEqual("One or more errors occurred.", exception.Message);
var innerException = exception.InnerException;
Assert.IsNotNull(innerException);
Assert.AreEqual(typeof(GoogleApiException), innerException.GetType());
Assert.AreEqual(innerException.Message, "Path or PlaceId's is required");
}
public void SpeedLimitsAsyncWhenTimeoutTest()
{
var request = new SpeedLimitsRequest
{
Key = this.ApiKey,
Path = new[] { new Entities.Maps.Roads.Common.Location(0, 0) }
};
var exception = Assert.Throws<AggregateException>(() =>
{
var result = GoogleMaps.SpeedLimits.QueryAsync(request, TimeSpan.FromMilliseconds(1)).Result;
Assert.IsNull(result);
});
Assert.IsNotNull(exception);
Assert.AreEqual(exception.Message, "One or more errors occurred.");
var innerException = exception.InnerException;
Assert.IsNotNull(innerException);
Assert.AreEqual(innerException.GetType(), typeof(TaskCanceledException));
Assert.AreEqual(innerException.Message, "A task was canceled.");
}
public void SpeedLimitsWhenInvalidKeyTest()
{
var request = new SpeedLimitsRequest
{
Key = "test",
Path = new[]
{
new Location(60.170880, 24.942795),
new Location(60.170879, 24.942796),
new Location(60.170877, 24.942796)
}
};
var exception = Assert.Throws <AggregateException>(() => GoogleMaps.SpeedLimits.QueryAsync(request).Wait());
Assert.IsNotNull(exception);
var innerException = exception.InnerExceptions.FirstOrDefault();
Assert.IsNotNull(innerException);
Assert.AreEqual(typeof(GoogleApiException).ToString(), innerException.GetType().ToString());
Assert.AreEqual("Response status code does not indicate success: 400 (Bad Request).", innerException.Message);
}
