roko.li/sharee.bike-App
5
0
Fork 0
mirror of https://dev.azure.com/TeilRad/sharee.bike%20App/_git/Code synced 2025-06-22 05:47:28 +02:00
Code Issues Projects Releases Packages Wiki Activity

Version 3.0.338

Browse source
This commit is contained in:
Anja Müller-Meißner 2022-09-06 16:08:19 +02:00 • committed by Anja
parent 573fe77e12
commit 0468955d49
751 changed files with 62747 additions and 60672 deletions
Download patch file Download diff file Expand all files Collapse all files

406
TestTINKLib/Fixtures/ObjectTests/Connector/CopriCallsHttpReference.cs
View file

@ -10,281 +10,281 @@ using TINK.Repository.Response;
namespace UITest.Fixtures.Connector
{
/// <summary>
/// Object which manages calls to copri.
/// </summary>
public class CopriCallsHttpsReference
{
/// <summary> Logs user in. </summary>
/// <param name="copriHost">Host to connect to. </param>
/// <param name="merchantId">Id of the merchant.</param>
/// <param name="mailAddress">Mailaddress of user to log in.</param>
/// <param name="password">Password to log in.</param>
/// <param name="deviceId">Id specifying user and hardware.</param>
/// <remarks>Response which holds auth cookie <see cref="ResponseBase.authcookie"/></remarks>
public static AuthorizationResponse DoAuthorizeCall(
string copriHost,
string merchantId,
string mailAddress,
string password,
string deviceId)
{
/// <summary>
/// Object which manages calls to copri.
/// </summary>
public class CopriCallsHttpsReference
{
/// <summary> Logs user in. </summary>
/// <param name="copriHost">Host to connect to. </param>
/// <param name="merchantId">Id of the merchant.</param>
/// <param name="mailAddress">Mailaddress of user to log in.</param>
/// <param name="password">Password to log in.</param>
/// <param name="deviceId">Id specifying user and hardware.</param>
/// <remarks>Response which holds auth cookie <see cref="ResponseBase.authcookie"/></remarks>
public static AuthorizationResponse DoAuthorizeCall(
string copriHost,
string merchantId,
string mailAddress,
string password,
string deviceId)
{
#if !WINDOWS_UWP
var l_oCommand = string.Format(
"request=authorization&merchant_id={0}&user_id={1}&user_pw={2}&hw_id={3}",
merchantId,
mailAddress,
password,
deviceId);
var l_oCommand = string.Format(
"request=authorization&merchant_id={0}&user_id={1}&user_pw={2}&hw_id={3}",
merchantId,
mailAddress,
password,
deviceId);
/// Extract session cookie from response.
/// Extract session cookie from response.
string response = string.Empty;
string response = string.Empty;
response = Post(l_oCommand, copriHost);
response = Post(l_oCommand, copriHost);
return JsonConvert.DeserializeObject<ResponseContainer<AuthorizationResponse>>(response)?.shareejson;
return JsonConvert.DeserializeObject<ResponseContainer<AuthorizationResponse>>(response)?.shareejson;
#else
return null;
#endif
}
}
/// <summary> Logs user out. </summary>
/// <param name="copriHost">Host to connect to. </param>
/// <param name="merchantId">Id of the merchant.</param>
/// <param name="sessionCookie"> Cookie which identifies user.</param>
public static AuthorizationoutResponse DoAuthoutCall(
string copriHost,
string merchantId,
string sessionCookie)
{
/// <summary> Logs user out. </summary>
/// <param name="copriHost">Host to connect to. </param>
/// <param name="merchantId">Id of the merchant.</param>
/// <param name="sessionCookie"> Cookie which identifies user.</param>
public static AuthorizationoutResponse DoAuthoutCall(
string copriHost,
string merchantId,
string sessionCookie)
{
#if !WINDOWS_UWP
var l_oCommand = string.Format(
"request=authout&authcookie={0}{1}",
sessionCookie,
merchantId);
var l_oCommand = string.Format(
"request=authout&authcookie={0}{1}",
sessionCookie,
merchantId);
string l_oLogoutResponse;
string l_oLogoutResponse;
l_oLogoutResponse = Post(l_oCommand, copriHost);
l_oLogoutResponse = Post(l_oCommand, copriHost);
/// Extract session cookie from response.
return JsonConvert.DeserializeObject<ResponseContainer<AuthorizationoutResponse>>(l_oLogoutResponse)?.shareejson;
/// Extract session cookie from response.
return JsonConvert.DeserializeObject<ResponseContainer<AuthorizationoutResponse>>(l_oLogoutResponse)?.shareejson;
#else
return null;
#endif
}
}
/// <summary>
/// Get list of stations from file.
/// </summary>
/// <param name="p_strCopriHost">URL of the copri host to connect to.</param>
/// <param name="p_strMerchantId">Id of the merchant.</param>
/// <param name="p_strCookie">Auto cookie of user if user is logged in.</param>
/// <returns>List of files.</returns>
public static StationsAvailableResponse GetStationsAllCall(
string p_strCopriHost,
string p_strMerchantId,
string p_strCookie = null)
{
var l_oCommand = string.Format(
"request=stations_all&authcookie={0}{1}",
p_strCookie,
p_strMerchantId);
/// <summary>
/// Get list of stations from file.
/// </summary>
/// <param name="p_strCopriHost">URL of the copri host to connect to.</param>
/// <param name="p_strMerchantId">Id of the merchant.</param>
/// <param name="p_strCookie">Auto cookie of user if user is logged in.</param>
/// <returns>List of files.</returns>
public static StationsAvailableResponse GetStationsAllCall(
string p_strCopriHost,
string p_strMerchantId,
string p_strCookie = null)
{
var l_oCommand = string.Format(
"request=stations_all&authcookie={0}{1}",
p_strCookie,
p_strMerchantId);
#if !WINDOWS_UWP
string l_oStationsAllResponse;
string l_oStationsAllResponse;
l_oStationsAllResponse = Post(l_oCommand, p_strCopriHost);
l_oStationsAllResponse = Post(l_oCommand, p_strCopriHost);
// Extract bikes from response.
return JsonConvert.DeserializeObject<ResponseContainer<StationsAvailableResponse>>(l_oStationsAllResponse)?.shareejson;
// Extract bikes from response.
return JsonConvert.DeserializeObject<ResponseContainer<StationsAvailableResponse>>(l_oStationsAllResponse)?.shareejson;
#else
return null;
#endif
}
}
/// <summary>
/// Gets a list of bikes from Copri.
/// </summary>
/// <param name="copriHost">URL of the copri host to connect to.</param>
/// <param name="p_strMerchantId">Id of the merchant.</param>
/// <param name="p_strSessionCookie">Cookie to authenticate user.</param>
/// <returns>Response holding list of bikes.</returns>
public static BikesAvailableResponse GetBikesAvailableCall(
string copriHost,
string merchantId,
string sessionCookie = null)
{
/// <summary>
/// Gets a list of bikes from Copri.
/// </summary>
/// <param name="copriHost">URL of the copri host to connect to.</param>
/// <param name="p_strMerchantId">Id of the merchant.</param>
/// <param name="p_strSessionCookie">Cookie to authenticate user.</param>
/// <returns>Response holding list of bikes.</returns>
public static BikesAvailableResponse GetBikesAvailableCall(
string copriHost,
string merchantId,
string sessionCookie = null)
{
#if !WINDOWS_UWP
string l_oCommand =
$"request=bikes_available&system=all&authcookie={sessionCookie ?? string.Empty}{merchantId}";
string l_oCommand =
$"request=bikes_available&system=all&authcookie={sessionCookie ?? string.Empty}{merchantId}";
string response;
string response;
response = Post(l_oCommand, copriHost);
response = Post(l_oCommand, copriHost);
// Extract bikes from response.
return CopriCallsStatic.DeserializeResponse<BikesAvailableResponse>(response);
// Extract bikes from response.
return CopriCallsStatic.DeserializeResponse<BikesAvailableResponse>(response);
#else
return null;
#endif
}
}
/// <summary>
/// Gets a list of bikes reserved/ booked by acctive user from Copri.
/// </summary>
/// <param name="p_strMerchantId">Id of the merchant.</param>
/// <param name="p_strSessionCookie">Cookie to authenticate user.</param>
/// <returns>Response holding list of bikes.</returns>
public static BikesReservedOccupiedResponse GetBikesOccupiedCall(
string copriHost,
string merchantId,
string sessionCookie)
{
/// <summary>
/// Gets a list of bikes reserved/ booked by acctive user from Copri.
/// </summary>
/// <param name="p_strMerchantId">Id of the merchant.</param>
/// <param name="p_strSessionCookie">Cookie to authenticate user.</param>
/// <returns>Response holding list of bikes.</returns>
public static BikesReservedOccupiedResponse GetBikesOccupiedCall(
string copriHost,
string merchantId,
string sessionCookie)
{
#if !WINDOWS_UWP
string l_oCommand = !string.IsNullOrEmpty(sessionCookie)
? $"request=user_bikes_occupied&system=all&authcookie={sessionCookie}{merchantId}"
: "request=bikes_available";
string l_oCommand = !string.IsNullOrEmpty(sessionCookie)
? $"request=user_bikes_occupied&system=all&authcookie={sessionCookie}{merchantId}"
: "request=bikes_available";
string l_oBikesOccupiedResponse;
string l_oBikesOccupiedResponse;
l_oBikesOccupiedResponse = Post(l_oCommand, copriHost);
l_oBikesOccupiedResponse = Post(l_oCommand, copriHost);
// Extract bikes from response.
return CopriCallsStatic.DeserializeResponse<BikesReservedOccupiedResponse>(l_oBikesOccupiedResponse);
// Extract bikes from response.
return CopriCallsStatic.DeserializeResponse<BikesReservedOccupiedResponse>(l_oBikesOccupiedResponse);
#else
return null;
#endif
}
}
/// <summary>
/// Gets booking request response.
/// </summary>
/// <param name="p_strMerchantId">Id of the merchant.</param>
/// <param name="p_iBikeId">Id of the bike to book.</param>
/// <param name="p_strSessionCookie">Cookie identifying the user.</param>
/// <returns>Response on booking request.</returns>
public static ReservationBookingResponse DoReserveCall(
string copriHost,
string p_strMerchantId,
string p_iBikeId,
string p_strSessionCookie)
{
/// <summary>
/// Gets booking request response.
/// </summary>
/// <param name="p_strMerchantId">Id of the merchant.</param>
/// <param name="p_iBikeId">Id of the bike to book.</param>
/// <param name="p_strSessionCookie">Cookie identifying the user.</param>
/// <returns>Response on booking request.</returns>
public static ReservationBookingResponse DoReserveCall(
string copriHost,
string p_strMerchantId,
string p_iBikeId,
string p_strSessionCookie)
{
#if !WINDOWS_UWP
string l_oCommand = string.Format(
"request=booking_request&bike={0}&authcookie={1}{2}",
p_iBikeId,
p_strSessionCookie,
p_strMerchantId);
string l_oCommand = string.Format(
"request=booking_request&bike={0}&authcookie={1}{2}",
p_iBikeId,
p_strSessionCookie,
p_strMerchantId);
string l_oBikesAvaialbeResponse = Post(l_oCommand, copriHost);
string l_oBikesAvaialbeResponse = Post(l_oCommand, copriHost);
// Extract bikes from response.
return JsonConvert.DeserializeObject<ResponseContainer<ReservationBookingResponse>>(l_oBikesAvaialbeResponse)?.shareejson;
// Extract bikes from response.
return JsonConvert.DeserializeObject<ResponseContainer<ReservationBookingResponse>>(l_oBikesAvaialbeResponse)?.shareejson;
#else
return null;
#endif
}
}
/// <summary>
/// Gets canel booking request response.
/// </summary>
/// <param name="p_strMerchantId">Id of the merchant.</param>
/// <param name="p_iBikeId">Id of the bike to book.</param>
/// <param name="p_strSessionCookie">Cookie of the logged in user.</param>
/// <returns>Response on cancel booking request.</returns>
public static ReservationCancelReturnResponse DoCancelReservationCall(
string copriHost,
string p_strMerchantId,
string p_iBikeId,
string p_strSessionCookie)
{
/// <summary>
/// Gets canel booking request response.
/// </summary>
/// <param name="p_strMerchantId">Id of the merchant.</param>
/// <param name="p_iBikeId">Id of the bike to book.</param>
/// <param name="p_strSessionCookie">Cookie of the logged in user.</param>
/// <returns>Response on cancel booking request.</returns>
public static ReservationCancelReturnResponse DoCancelReservationCall(
string copriHost,
string p_strMerchantId,
string p_iBikeId,
string p_strSessionCookie)
{
#if !WINDOWS_UWP
string l_oCommand = string.Format(
"request=booking_cancel&bike={0}&authcookie={1}{2}",
p_iBikeId,
p_strSessionCookie,
p_strMerchantId);
string l_oBikesAvaialbeResponse;
string l_oCommand = string.Format(
"request=booking_cancel&bike={0}&authcookie={1}{2}",
p_iBikeId,
p_strSessionCookie,
p_strMerchantId);
string l_oBikesAvaialbeResponse;
l_oBikesAvaialbeResponse = Post(l_oCommand, copriHost);
l_oBikesAvaialbeResponse = Post(l_oCommand, copriHost);
// Extract bikes from response.
return JsonConvert.DeserializeObject<ResponseContainer<ReservationCancelReturnResponse>>(l_oBikesAvaialbeResponse)?.shareejson;
// Extract bikes from response.
return JsonConvert.DeserializeObject<ResponseContainer<ReservationCancelReturnResponse>>(l_oBikesAvaialbeResponse)?.shareejson;
#else
return null;
#endif
}
}
/// <summary>
/// Gets a list of bikes from Copri.
/// </summary>
/// <param name="p_strSessionCookie">Cookie to authenticate user.</param>
/// <returns></returns>
private static string Post(
string p_strCommand,
string p_strURL)
{
/// <summary>
/// Gets a list of bikes from Copri.
/// </summary>
/// <param name="p_strSessionCookie">Cookie to authenticate user.</param>
/// <returns></returns>
private static string Post(
string p_strCommand,
string p_strURL)
{
#if !WINDOWS_UWP
var l_strHost = p_strURL;
var l_strHost = p_strURL;
// Returns a http request.
var l_oRequest = WebRequest.Create(l_strHost);
// Returns a http request.
var l_oRequest = WebRequest.Create(l_strHost);
l_oRequest.Method = "POST";
l_oRequest.ContentType = "application/x-www-form-urlencoded";
l_oRequest.Method = "POST";
l_oRequest.ContentType = "application/x-www-form-urlencoded";
byte[] l_oPostData = Encoding.UTF8.GetBytes(p_strCommand);
byte[] l_oPostData = Encoding.UTF8.GetBytes(p_strCommand);
l_oRequest.ContentLength = l_oPostData.Length;
l_oRequest.ContentLength = l_oPostData.Length;
// Get the request stream.
using (Stream l_oDataStream = l_oRequest.GetRequestStream())
{
// Write the data to the request stream.
l_oDataStream.Write(l_oPostData, 0, l_oPostData.Length);
}
// Get the request stream.
using (Stream l_oDataStream = l_oRequest.GetRequestStream())
{
// Write the data to the request stream.
l_oDataStream.Write(l_oPostData, 0, l_oPostData.Length);
}
// Get the response.
var l_oResponse = l_oRequest.GetResponse() as HttpWebResponse;
// Get the response.
var l_oResponse = l_oRequest.GetResponse() as HttpWebResponse;
if (l_oResponse == null)
{
throw new Exception(string.Format("Reserve request failed. Response form from server was not of expected type."));
}
if (l_oResponse == null)
{
throw new Exception(string.Format("Reserve request failed. Response form from server was not of expected type."));
}
if (l_oResponse.StatusCode != HttpStatusCode.OK)
{
throw new CommunicationException(string.Format(
"Posting request {0} failed. Expected status code is {1} but was {2}.",
p_strCommand,
HttpStatusCode.OK,
l_oResponse.StatusCode));
}
if (l_oResponse.StatusCode != HttpStatusCode.OK)
{
throw new CommunicationException(string.Format(
"Posting request {0} failed. Expected status code is {1} but was {2}.",
p_strCommand,
HttpStatusCode.OK,
l_oResponse.StatusCode));
}
string responseFromServer = string.Empty;
string responseFromServer = string.Empty;
// Get the request stream.
using (Stream l_oDataStream = l_oResponse.GetResponseStream())
using (StreamReader l_oReader = new StreamReader(l_oDataStream))
{
// Read the content.
responseFromServer = l_oReader.ReadToEnd();
// Get the request stream.
using (Stream l_oDataStream = l_oResponse.GetResponseStream())
using (StreamReader l_oReader = new StreamReader(l_oDataStream))
{
// Read the content.
responseFromServer = l_oReader.ReadToEnd();
// Display the content.
Console.WriteLine(responseFromServer);
// Display the content.
Console.WriteLine(responseFromServer);
// Clean up the streams.
l_oResponse.Close();
}
// Clean up the streams.
l_oResponse.Close();
}
return responseFromServer;
return responseFromServer;
#else
return null;
#endif
}
}
}
}
}

72
TestTINKLib/Fixtures/ObjectTests/Connector/Exception/TestAuthcookieNotDefinedException.cs
View file

@ -5,45 +5,45 @@ using TINK.Repository.Response;
namespace TestTINKLib.Fixtures.ObjectTests.Connector.Exception
{
[TestFixture]
public class TestAuthcookieNotDefinedException
{
[Test]
public void TestConstruct()
{
Assert.AreEqual(
"Can not test.\r\nDie Sitzung ist abgelaufen. Bitte neu anmelden.",
(new AuthcookieNotDefinedException(
"Can not test.",
JsonConvert.DeserializeObject<ResponseBase>(@"{ ""response_state"" : ""Some inner error description""}"))).Message);
}
[TestFixture]
public class TestAuthcookieNotDefinedException
{
[Test]
public void TestConstruct()
{
Assert.AreEqual(
"Can not test.\r\nDie Sitzung ist abgelaufen. Bitte neu anmelden.",
(new AuthcookieNotDefinedException(
"Can not test.",
JsonConvert.DeserializeObject<ResponseBase>(@"{ ""response_state"" : ""Some inner error description""}"))).Message);
}
[Test]
public void TestTestIsAuthcookieNotDefined_False()
{
var response = JsonConvert.DeserializeObject<BikesReservedOccupiedResponse>(@"{ ""response_state"" : ""OK"" }");
Assert.That(AuthcookieNotDefinedException.IsAuthcookieNotDefined(response, "Test context", out AuthcookieNotDefinedException exception),
Is.EqualTo(false));
}
[Test]
public void TestTestIsAuthcookieNotDefined_False()
{
var response = JsonConvert.DeserializeObject<BikesReservedOccupiedResponse>(@"{ ""response_state"" : ""OK"" }");
Assert.That(AuthcookieNotDefinedException.IsAuthcookieNotDefined(response, "Test context", out AuthcookieNotDefinedException exception),
Is.EqualTo(false));
}
[Test]
public void TestIsAuthcookieNotDefined_TrueLegacy()
{
var response = JsonConvert.DeserializeObject<ResponseBase>($"{{ \"response_state\" : \"Failure 1003: authcookie not defined\" }}");
Assert.That(AuthcookieNotDefinedException.IsAuthcookieNotDefined(response, "Test context", out AuthcookieNotDefinedException exception),
Is.EqualTo(true));
[Test]
public void TestIsAuthcookieNotDefined_TrueLegacy()
{
var response = JsonConvert.DeserializeObject<ResponseBase>($"{{ \"response_state\" : \"Failure 1003: authcookie not defined\" }}");
Assert.That(AuthcookieNotDefinedException.IsAuthcookieNotDefined(response, "Test context", out AuthcookieNotDefinedException exception),
Is.EqualTo(true));
Assert.That(exception, !Is.Null);
}
Assert.That(exception, !Is.Null);
}
[Test]
public void TestIsAuthcookieNotDefined_False()
{
var response = JsonConvert.DeserializeObject<ResponseBase>($"{{ \"response_state\" : \"Failure 1001: authcookie not defined\" }}");
Assert.That(AuthcookieNotDefinedException.IsAuthcookieNotDefined(response, "Test context", out AuthcookieNotDefinedException exception),
Is.EqualTo(true));
[Test]
public void TestIsAuthcookieNotDefined_False()
{
var response = JsonConvert.DeserializeObject<ResponseBase>($"{{ \"response_state\" : \"Failure 1001: authcookie not defined\" }}");
Assert.That(AuthcookieNotDefinedException.IsAuthcookieNotDefined(response, "Test context", out AuthcookieNotDefinedException exception),
Is.EqualTo(true));
Assert.That(exception, !Is.Null);
}
}
Assert.That(exception, !Is.Null);
}
}
}

54
TestTINKLib/Fixtures/ObjectTests/Connector/Filter/TestIntersectFilter.cs
View file

@ -5,36 +5,36 @@ using TINK.Model.Connector.Filter;
namespace TestTINKLib.Fixtures.ObjectTests.Connector.Filter
{
[TestFixture]
public class TestIntersectFilter
{
[Test]
public void TestDoFilter_Null()
{
var filter = new IntersectGroupFilter(new List<string> { "Tonk" });
[TestFixture]
public class TestIntersectFilter
{
[Test]
public void TestDoFilter_Null()
{
var filter = new IntersectGroupFilter(new List<string> { "Tonk" });
Assert.AreEqual(1, filter.DoFilter(null).Count());
Assert.AreEqual(
"Tonk",
filter.DoFilter(null).ToArray()[0],
"Do not apply filtering when null is passed as argement (null-filter).");
}
Assert.AreEqual(1, filter.DoFilter(null).Count());
Assert.AreEqual(
"Tonk",
filter.DoFilter(null).ToArray()[0],
"Do not apply filtering when null is passed as argement (null-filter).");
}
[Test]
public void TestDoFilter_Empty()
{
var filter = new IntersectGroupFilter(new List<string> { "Tonk" });
[Test]
public void TestDoFilter_Empty()
{
var filter = new IntersectGroupFilter(new List<string> { "Tonk" });
Assert.AreEqual(0, filter.DoFilter(new List<string>()).Count());
}
Assert.AreEqual(0, filter.DoFilter(new List<string>()).Count());
}
[Test]
public void TestDoFilter()
{
var filter = new IntersectGroupFilter(new List<string> { "FR_001", "FR_009" });
[Test]
public void TestDoFilter()
{
var filter = new IntersectGroupFilter(new List<string> { "FR_001", "FR_009" });
Assert.AreEqual(1, filter.DoFilter(new List<string> { "FR_001", "FR_007" }).Count());
Assert.AreEqual("FR_001", filter.DoFilter(new List<string> { "FR_001", "FR_007" }).ToArray()[0]);
}
}
Assert.AreEqual(1, filter.DoFilter(new List<string> { "FR_001", "FR_007" }).Count());
Assert.AreEqual("FR_001", filter.DoFilter(new List<string> { "FR_001", "FR_007" }).ToArray()[0]);
}
}
}

24
TestTINKLib/Fixtures/ObjectTests/Connector/Filter/TestNullFilter.cs
View file

@ -5,16 +5,16 @@ using TINK.Model.Connector.Filter;
namespace TestTINKLib.Fixtures.ObjectTests.Connector.Filter
{
[TestFixture]
public class TestNullFilter
{
[Test]
public void TestDoFilter()
{
var filter = new NullGroupFilter();
Assert.IsNull(filter.DoFilter(null));
Assert.AreEqual(0, filter.DoFilter(new List<string>()).Count());
Assert.AreEqual(1, filter.DoFilter(new List<string> { "Hello" }).Count());
}
}
[TestFixture]
public class TestNullFilter
{
[Test]
public void TestDoFilter()
{
var filter = new NullGroupFilter();
Assert.IsNull(filter.DoFilter(null));
Assert.AreEqual(0, filter.DoFilter(new List<string>()).Count());
Assert.AreEqual(1, filter.DoFilter(new List<string> { "Hello" }).Count());
}
}
}

184
TestTINKLib/Fixtures/ObjectTests/Connector/Query/TestCachedQuery.cs
View file

@ -10,10 +10,10 @@ using TINK.Services.CopriApi;
namespace TestTINKLib.Fixtures.ObjectTests.Connector.Query
{
[TestFixture]
public class TestCachedQuery
{
private const string BIKESAVAILABLE = @"{
[TestFixture]
public class TestCachedQuery
{
private const string BIKESAVAILABLE = @"{
""copri_version"" : ""4.1.0.0"",
""bikes"" : {},
""response_state"" : ""OK"",
@ -31,7 +31,7 @@ namespace TestTINKLib.Fixtures.ObjectTests.Connector.Query
}
}";
private const string STATIONSALL = @"{
private const string STATIONSALL = @"{
""copri_version"" : ""4.1.0.0"",
""stations"" : {
""5"" : {
@ -71,7 +71,7 @@ namespace TestTINKLib.Fixtures.ObjectTests.Connector.Query
""apiserver"" : ""https://tinkwwp.copri-bike.de""
}";
private const string STATIONSALLEMPTY = @"{
private const string STATIONSALLEMPTY = @"{
""copri_version"" : ""4.1.0.0"",
""stations"" : {
},
@ -84,115 +84,115 @@ namespace TestTINKLib.Fixtures.ObjectTests.Connector.Query
""apiserver"" : ""https://tinkwwp.copri-bike.de""
}";
[Test]
public async Task TestGetStations_StationsFromCache()
{
var server = MockRepository.GenerateMock<ICachedCopriServer>();
[Test]
public async Task TestGetStations_StationsFromCache()
{
var server = MockRepository.GenerateMock<ICachedCopriServer>();
server.Stub(x => x.GetStations(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<StationsAvailableResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<StationsAvailableResponse>(STATIONSALL),
new GeneralData(),
new System.Exception("Bang when getting stations..."))));
server.Stub(x => x.GetStations(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<StationsAvailableResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<StationsAvailableResponse>(STATIONSALL),
new GeneralData(),
new System.Exception("Bang when getting stations..."))));
server.Stub(x => x.GetBikesAvailable(Arg<bool>.Matches(fromCache => fromCache == true))).Return(Task.Run(() => new Result<BikesAvailableResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE),
new GeneralData())));
server.Stub(x => x.GetBikesAvailable(Arg<bool>.Matches(fromCache => fromCache == true))).Return(Task.Run(() => new Result<BikesAvailableResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE),
new GeneralData())));
var result = await new CachedQuery(server).GetBikesAndStationsAsync();
var result = await new CachedQuery(server).GetBikesAndStationsAsync();
Assert.AreEqual(3, result.Response.StationsAll.Count);
Assert.AreEqual(1, result.Response.Bikes.Count);
Assert.AreEqual(typeof(CopriCallsMonkeyStore), result.Source);
Assert.AreEqual("Bang when getting stations...", result.Exception.Message);
}
Assert.AreEqual(3, result.Response.StationsAll.Count);
Assert.AreEqual(1, result.Response.Bikes.Count);
Assert.AreEqual(typeof(CopriCallsMonkeyStore), result.Source);
Assert.AreEqual("Bang when getting stations...", result.Exception.Message);
}
[Test]
public async Task TestGetStations_BikesAvailableFromCache()
{
var server = MockRepository.GenerateMock<ICachedCopriServer>();
[Test]
public async Task TestGetStations_BikesAvailableFromCache()
{
var server = MockRepository.GenerateMock<ICachedCopriServer>();
server.Stub(x => x.GetStations(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<StationsAvailableResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<StationsAvailableResponse>(STATIONSALLEMPTY),
new GeneralData())));
server.Stub(x => x.GetStations(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<StationsAvailableResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<StationsAvailableResponse>(STATIONSALLEMPTY),
new GeneralData())));
server.Stub(x => x.GetBikesAvailable(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<BikesAvailableResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE),
new GeneralData(),
new System.Exception("Bang when getting bikes..."))));
server.Stub(x => x.GetBikesAvailable(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<BikesAvailableResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE),
new GeneralData(),
new System.Exception("Bang when getting bikes..."))));
server.Stub(x => x.GetStations(Arg<bool>.Matches(fromCache => fromCache == true))).Return(Task.Run(() => new Result<StationsAvailableResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<StationsAvailableResponse>(STATIONSALL),
new GeneralData())));
server.Stub(x => x.GetStations(Arg<bool>.Matches(fromCache => fromCache == true))).Return(Task.Run(() => new Result<StationsAvailableResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<StationsAvailableResponse>(STATIONSALL),
new GeneralData())));
var result = await new CachedQuery(server).GetBikesAndStationsAsync();
var result = await new CachedQuery(server).GetBikesAndStationsAsync();
Assert.AreEqual(3, result.Response.StationsAll.Count);
Assert.AreEqual(1, result.Response.Bikes.Count);
Assert.AreEqual(typeof(CopriCallsMonkeyStore), result.Source);
Assert.AreEqual("Bang when getting bikes...", result.Exception.Message);
}
Assert.AreEqual(3, result.Response.StationsAll.Count);
Assert.AreEqual(1, result.Response.Bikes.Count);
Assert.AreEqual(typeof(CopriCallsMonkeyStore), result.Source);
Assert.AreEqual("Bang when getting bikes...", result.Exception.Message);
}
[Test]
public async Task TestGetStations()
{
var server = MockRepository.GenerateMock<ICachedCopriServer>();
[Test]
public async Task TestGetStations()
{
var server = MockRepository.GenerateMock<ICachedCopriServer>();
server.Stub(x => x.GetStations(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<StationsAvailableResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<StationsAvailableResponse>(STATIONSALL),
new GeneralData())));
server.Stub(x => x.GetStations(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<StationsAvailableResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<StationsAvailableResponse>(STATIONSALL),
new GeneralData())));
server.Stub(x => x.GetBikesAvailable(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<BikesAvailableResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE),
new GeneralData())));
server.Stub(x => x.GetBikesAvailable(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<BikesAvailableResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE),
new GeneralData())));
server.Stub(x => x.AddToCache(Arg<Result<StationsAvailableResponse>>.Is.Anything));
server.Stub(x => x.AddToCache(Arg<Result<BikesAvailableResponse>>.Is.Anything));
server.Stub(x => x.AddToCache(Arg<Result<StationsAvailableResponse>>.Is.Anything));
server.Stub(x => x.AddToCache(Arg<Result<BikesAvailableResponse>>.Is.Anything));
var result = await new CachedQuery(server).GetBikesAndStationsAsync();
var result = await new CachedQuery(server).GetBikesAndStationsAsync();
Assert.AreEqual(3, result.Response.StationsAll.Count);
Assert.AreEqual(1, result.Response.Bikes.Count);
Assert.AreEqual(typeof(CopriCallsHttps), result.Source);
Assert.IsNull(result.Exception);
}
Assert.AreEqual(3, result.Response.StationsAll.Count);
Assert.AreEqual(1, result.Response.Bikes.Count);
Assert.AreEqual(typeof(CopriCallsHttps), result.Source);
Assert.IsNull(result.Exception);
}
[Test]
public async Task TestGetBikes()
{
var server = MockRepository.GenerateMock<ICachedCopriServer>();
[Test]
public async Task TestGetBikes()
{
var server = MockRepository.GenerateMock<ICachedCopriServer>();
server.Stub(x => x.GetBikesAvailable()).Return(Task.Run(() => new Result<BikesAvailableResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE),
new GeneralData())));
server.Stub(x => x.GetBikesAvailable()).Return(Task.Run(() => new Result<BikesAvailableResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE),
new GeneralData())));
server.Stub(x => x.AddToCache(Arg<Result<BikesAvailableResponse>>.Is.Anything));
server.Stub(x => x.AddToCache(Arg<Result<BikesAvailableResponse>>.Is.Anything));
var result = await new CachedQuery(server).GetBikesAsync();
var result = await new CachedQuery(server).GetBikesAsync();
Assert.AreEqual(1, result.Response.Count);
Assert.AreEqual(typeof(CopriCallsHttps), result.Source);
Assert.IsNull(result.Exception);
}
Assert.AreEqual(1, result.Response.Count);
Assert.AreEqual(typeof(CopriCallsHttps), result.Source);
Assert.IsNull(result.Exception);
}
[Test]
public async Task TestGetBikesOccupied()
{
var server = MockRepository.GenerateMock<ICachedCopriServer>();
[Test]
public async Task TestGetBikesOccupied()
{
var server = MockRepository.GenerateMock<ICachedCopriServer>();
var result = await new CachedQuery(server).GetBikesOccupiedAsync();
var result = await new CachedQuery(server).GetBikesOccupiedAsync();
Assert.AreEqual(0, result.Response.Count);
Assert.AreEqual(typeof(CopriCallsMonkeyStore), result.Source);
Assert.AreEqual(result.Exception.Message, "Abfrage der reservierten/ gebuchten Räder nicht möglich. Kein Benutzer angemeldet.");
}
}
Assert.AreEqual(0, result.Response.Count);
Assert.AreEqual(typeof(CopriCallsMonkeyStore), result.Source);
Assert.AreEqual(result.Exception.Message, "Abfrage der reservierten/ gebuchten Räder nicht möglich. Kein Benutzer angemeldet.");
}
}
}

378
TestTINKLib/Fixtures/ObjectTests/Connector/Query/TestCachedQueryLoggedIn.cs
View file

@ -13,10 +13,10 @@ using TINK.Services.CopriApi;
namespace TestTINKLib.Fixtures.ObjectTests.Connector.Query
{
[TestFixture]
public class TestCachedQueryLoggedIn
{
private const string BIKESAVAILABLE = @"{
[TestFixture]
public class TestCachedQueryLoggedIn
{
private const string BIKESAVAILABLE = @"{
""copri_version"" : ""4.1.0.0"",
""bikes"" : {},
""response_state"" : ""OK"",
@ -34,7 +34,7 @@ namespace TestTINKLib.Fixtures.ObjectTests.Connector.Query
}
}";
private const string BIKESAVAILABLEEMPTY = @"{
private const string BIKESAVAILABLEEMPTY = @"{
""copri_version"" : ""4.1.0.0"",
""bikes"" : {},
""response_state"" : ""OK"",
@ -45,7 +45,7 @@ namespace TestTINKLib.Fixtures.ObjectTests.Connector.Query
}
}";
private const string BIKESOCCUPIED = @"{
private const string BIKESOCCUPIED = @"{
""authcookie"" : ""6103_f782a208d9399291ba8d086b5dcc2509_12345678"",
""debuglevel"" : ""2"",
""user_group"" : [ ""TINK"" ],
@ -78,7 +78,7 @@ namespace TestTINKLib.Fixtures.ObjectTests.Connector.Query
}
}";
private const string STATIONSALL = @"{
private const string STATIONSALL = @"{
""copri_version"" : ""4.1.0.0"",
""stations"" : {
""5"" : {
@ -118,7 +118,7 @@ namespace TestTINKLib.Fixtures.ObjectTests.Connector.Query
""apiserver"" : ""https://tinkwwp.copri-bike.de""
}";
private const string STATIONSALLEMPTY = @"{
private const string STATIONSALLEMPTY = @"{
""copri_version"" : ""4.1.0.0"",
""stations"" : {
},
@ -131,233 +131,233 @@ namespace TestTINKLib.Fixtures.ObjectTests.Connector.Query
""apiserver"" : ""https://tinkwwp.copri-bike.de""
}";
[Test]
public async Task TestGetStations_StationsFromCache()
{
var server = MockRepository.GenerateMock<ICachedCopriServer>();
[Test]
public async Task TestGetStations_StationsFromCache()
{
var server = MockRepository.GenerateMock<ICachedCopriServer>();
server.Stub(x => x.GetStations(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<StationsAvailableResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<StationsAvailableResponse>(STATIONSALL),
new GeneralData(),
new System.Exception("Bang when getting stations..."))));
server.Stub(x => x.GetStations(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<StationsAvailableResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<StationsAvailableResponse>(STATIONSALL),
new GeneralData(),
new System.Exception("Bang when getting stations..."))));
server.Stub(x => x.GetBikesAvailable(Arg<bool>.Matches(fromCache => fromCache == true))).Return(Task.Run(() => new Result<BikesAvailableResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE),
new GeneralData())));
server.Stub(x => x.GetBikesAvailable(Arg<bool>.Matches(fromCache => fromCache == true))).Return(Task.Run(() => new Result<BikesAvailableResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE),
new GeneralData())));
server.Stub(x => x.GetBikesOccupied(Arg<bool>.Matches(fromCache => fromCache == true))).Return(Task.Run(() => new Result<BikesReservedOccupiedResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<BikesReservedOccupiedResponse>(BIKESOCCUPIED),
new GeneralData())));
server.Stub(x => x.GetBikesOccupied(Arg<bool>.Matches(fromCache => fromCache == true))).Return(Task.Run(() => new Result<BikesReservedOccupiedResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<BikesReservedOccupiedResponse>(BIKESOCCUPIED),
new GeneralData())));
var result = await new CachedQueryLoggedIn(server, "123", "a@b", () => DateTime.Now).GetBikesAndStationsAsync();
var result = await new CachedQueryLoggedIn(server, "123", "a@b", () => DateTime.Now).GetBikesAndStationsAsync();
Assert.AreEqual(3, result.Response.StationsAll.Count);
Assert.AreEqual(2, result.Response.Bikes.Count);
Assert.AreEqual(typeof(CopriCallsMonkeyStore), result.Source);
Assert.AreEqual("Bang when getting stations...", result.Exception.Message);
}
Assert.AreEqual(3, result.Response.StationsAll.Count);
Assert.AreEqual(2, result.Response.Bikes.Count);
Assert.AreEqual(typeof(CopriCallsMonkeyStore), result.Source);
Assert.AreEqual("Bang when getting stations...", result.Exception.Message);
}
[Test]
public async Task TestGetStations_BikesAvailableFromCache()
{
var server = MockRepository.GenerateMock<ICachedCopriServer>();
[Test]
public async Task TestGetStations_BikesAvailableFromCache()
{
var server = MockRepository.GenerateMock<ICachedCopriServer>();
server.Stub(x => x.GetStations(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<StationsAvailableResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<StationsAvailableResponse>(STATIONSALLEMPTY),
new GeneralData())));
server.Stub(x => x.GetStations(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<StationsAvailableResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<StationsAvailableResponse>(STATIONSALLEMPTY),
new GeneralData())));
server.Stub(x => x.GetBikesAvailable(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<BikesAvailableResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE),
new GeneralData(),
new System.Exception("Bang when getting bikes..."))));
server.Stub(x => x.GetBikesAvailable(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<BikesAvailableResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE),
new GeneralData(),
new System.Exception("Bang when getting bikes..."))));
server.Stub(x => x.GetBikesOccupied(Arg<bool>.Matches(fromCache => fromCache == true))).Return(Task.Run(() => new Result<BikesReservedOccupiedResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<BikesReservedOccupiedResponse>(BIKESOCCUPIED),
new GeneralData())));
server.Stub(x => x.GetBikesOccupied(Arg<bool>.Matches(fromCache => fromCache == true))).Return(Task.Run(() => new Result<BikesReservedOccupiedResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<BikesReservedOccupiedResponse>(BIKESOCCUPIED),
new GeneralData())));
server.Stub(x => x.GetStations(Arg<bool>.Matches(fromCache => fromCache == true))).Return(Task.Run(() => new Result<StationsAvailableResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<StationsAvailableResponse>(STATIONSALL),
new GeneralData())));
server.Stub(x => x.GetStations(Arg<bool>.Matches(fromCache => fromCache == true))).Return(Task.Run(() => new Result<StationsAvailableResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<StationsAvailableResponse>(STATIONSALL),
new GeneralData())));
var result = await new CachedQueryLoggedIn(server, "123", "a@b", () => DateTime.Now).GetBikesAndStationsAsync();
var result = await new CachedQueryLoggedIn(server, "123", "a@b", () => DateTime.Now).GetBikesAndStationsAsync();
Assert.AreEqual(3, result.Response.StationsAll.Count);
Assert.AreEqual(2, result.Response.Bikes.Count);
Assert.AreEqual(typeof(CopriCallsMonkeyStore), result.Source);
Assert.AreEqual("Bang when getting bikes...", result.Exception.Message);
}
Assert.AreEqual(3, result.Response.StationsAll.Count);
Assert.AreEqual(2, result.Response.Bikes.Count);
Assert.AreEqual(typeof(CopriCallsMonkeyStore), result.Source);
Assert.AreEqual("Bang when getting bikes...", result.Exception.Message);
}
[Test]
public async Task TestGetStations_BikesOccupiedFromCache()
{
var server = MockRepository.GenerateMock<ICachedCopriServer>();
[Test]
public async Task TestGetStations_BikesOccupiedFromCache()
{
var server = MockRepository.GenerateMock<ICachedCopriServer>();
server.Stub(x => x.GetStations(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<StationsAvailableResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<StationsAvailableResponse>(STATIONSALLEMPTY),
new GeneralData())));
server.Stub(x => x.GetStations(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<StationsAvailableResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<StationsAvailableResponse>(STATIONSALLEMPTY),
new GeneralData())));
server.Stub(x => x.GetBikesAvailable(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<BikesAvailableResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLEEMPTY),
new GeneralData())));
server.Stub(x => x.GetBikesAvailable(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<BikesAvailableResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLEEMPTY),
new GeneralData())));
server.Stub(x => x.GetBikesOccupied(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<BikesReservedOccupiedResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<BikesReservedOccupiedResponse>(BIKESOCCUPIED),
new GeneralData(),
new System.Exception("Bang when getting bikes occupied..."))));
server.Stub(x => x.GetBikesOccupied(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<BikesReservedOccupiedResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<BikesReservedOccupiedResponse>(BIKESOCCUPIED),
new GeneralData(),
new System.Exception("Bang when getting bikes occupied..."))));
server.Stub(x => x.GetBikesAvailable(Arg<bool>.Matches(fromCache => fromCache == true))).Return(Task.Run(() => new Result<BikesAvailableResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE),
new GeneralData())));
server.Stub(x => x.GetBikesAvailable(Arg<bool>.Matches(fromCache => fromCache == true))).Return(Task.Run(() => new Result<BikesAvailableResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE),
new GeneralData())));
server.Stub(x => x.GetStations(Arg<bool>.Matches(fromCache => fromCache == true))).Return(Task.Run(() => new Result<StationsAvailableResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<StationsAvailableResponse>(STATIONSALL),
new GeneralData())));
server.Stub(x => x.GetStations(Arg<bool>.Matches(fromCache => fromCache == true))).Return(Task.Run(() => new Result<StationsAvailableResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<StationsAvailableResponse>(STATIONSALL),
new GeneralData())));
var result = await new CachedQueryLoggedIn(server, "123", "a@b", () => DateTime.Now).GetBikesAndStationsAsync();
var result = await new CachedQueryLoggedIn(server, "123", "a@b", () => DateTime.Now).GetBikesAndStationsAsync();
Assert.AreEqual(3, result.Response.StationsAll.Count);
Assert.AreEqual(2, result.Response.Bikes.Count);
Assert.AreEqual(typeof(CopriCallsMonkeyStore), result.Source);
Assert.AreEqual("Bang when getting bikes occupied...", result.Exception.Message);
}
Assert.AreEqual(3, result.Response.StationsAll.Count);
Assert.AreEqual(2, result.Response.Bikes.Count);
Assert.AreEqual(typeof(CopriCallsMonkeyStore), result.Source);
Assert.AreEqual("Bang when getting bikes occupied...", result.Exception.Message);
}
[Test]
public async Task TestGetStations()
{
var server = MockRepository.GenerateMock<ICachedCopriServer>();
[Test]
public async Task TestGetStations()
{
var server = MockRepository.GenerateMock<ICachedCopriServer>();
server.Stub(x => x.GetStations(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<StationsAvailableResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<StationsAvailableResponse>(STATIONSALL),
new GeneralData())));
server.Stub(x => x.GetStations(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<StationsAvailableResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<StationsAvailableResponse>(STATIONSALL),
new GeneralData())));
server.Stub(x => x.GetBikesAvailable(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<BikesAvailableResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE),
new GeneralData())));
server.Stub(x => x.GetBikesAvailable(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<BikesAvailableResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE),
new GeneralData())));
server.Stub(x => x.GetBikesOccupied(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<BikesReservedOccupiedResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<BikesReservedOccupiedResponse>(BIKESOCCUPIED),
new GeneralData())));
server.Stub(x => x.GetBikesOccupied(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<BikesReservedOccupiedResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<BikesReservedOccupiedResponse>(BIKESOCCUPIED),
new GeneralData())));
server.Stub(x => x.AddToCache(Arg<Result<StationsAvailableResponse>>.Is.Anything));
server.Stub(x => x.AddToCache(Arg<Result<BikesAvailableResponse>>.Is.Anything));
server.Stub(x => x.AddToCache(Arg<Result<BikesReservedOccupiedResponse>>.Is.Anything));
server.Stub(x => x.AddToCache(Arg<Result<StationsAvailableResponse>>.Is.Anything));
server.Stub(x => x.AddToCache(Arg<Result<BikesAvailableResponse>>.Is.Anything));
server.Stub(x => x.AddToCache(Arg<Result<BikesReservedOccupiedResponse>>.Is.Anything));
var result = await new CachedQueryLoggedIn(server, "123", "a@b", () => DateTime.Now).GetBikesAndStationsAsync();
var result = await new CachedQueryLoggedIn(server, "123", "a@b", () => DateTime.Now).GetBikesAndStationsAsync();
Assert.AreEqual(3, result.Response.StationsAll.Count);
Assert.AreEqual(2, result.Response.Bikes.Count);
Assert.AreEqual(typeof(CopriCallsHttps), result.Source);
Assert.IsNull(result.Exception);
}
Assert.AreEqual(3, result.Response.StationsAll.Count);
Assert.AreEqual(2, result.Response.Bikes.Count);
Assert.AreEqual(typeof(CopriCallsHttps), result.Source);
Assert.IsNull(result.Exception);
}
[Test]
public async Task TestGetBikes_BikesAvailableFromCache()
{
var server = MockRepository.GenerateMock<ICachedCopriServer>();
[Test]
public async Task TestGetBikes_BikesAvailableFromCache()
{
var server = MockRepository.GenerateMock<ICachedCopriServer>();
server.Stub(x => x.GetBikesAvailable()).Return(Task.Run(() => new Result<BikesAvailableResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE),
new GeneralData(),
new System.Exception("Bang, bikes avail..."))));
server.Stub(x => x.GetBikesAvailable()).Return(Task.Run(() => new Result<BikesAvailableResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE),
new GeneralData(),
new System.Exception("Bang, bikes avail..."))));
server.Stub(x => x.GetBikesOccupied(Arg<bool>.Matches(fromCache => fromCache == true))).Return(Task.Run(() => new Result<BikesReservedOccupiedResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<BikesReservedOccupiedResponse>(BIKESOCCUPIED),
new GeneralData())));
server.Stub(x => x.GetBikesOccupied(Arg<bool>.Matches(fromCache => fromCache == true))).Return(Task.Run(() => new Result<BikesReservedOccupiedResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<BikesReservedOccupiedResponse>(BIKESOCCUPIED),
new GeneralData())));
var result = await new CachedQueryLoggedIn(server, "123", "a@b", () => DateTime.Now).GetBikesAsync();
var result = await new CachedQueryLoggedIn(server, "123", "a@b", () => DateTime.Now).GetBikesAsync();
Assert.AreEqual(2, result.Response.Count);
Assert.AreEqual(typeof(CopriCallsMonkeyStore), result.Source);
Assert.AreEqual("Bang, bikes avail...", result.Exception.Message);
}
Assert.AreEqual(2, result.Response.Count);
Assert.AreEqual(typeof(CopriCallsMonkeyStore), result.Source);
Assert.AreEqual("Bang, bikes avail...", result.Exception.Message);
}
[Test]
public async Task TestGetBikes_BikesOccupiedFromCache()
{
var server = MockRepository.GenerateMock<ICachedCopriServer>();
[Test]
public async Task TestGetBikes_BikesOccupiedFromCache()
{
var server = MockRepository.GenerateMock<ICachedCopriServer>();
server.Stub(x => x.GetBikesAvailable(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<BikesAvailableResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLEEMPTY),
new GeneralData())));
server.Stub(x => x.GetBikesAvailable(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<BikesAvailableResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLEEMPTY),
new GeneralData())));
server.Stub(x => x.GetBikesOccupied(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<BikesReservedOccupiedResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<BikesReservedOccupiedResponse>(BIKESOCCUPIED),
new GeneralData(),
new System.Exception("Bang, error bikes occupied"))));
server.Stub(x => x.GetBikesOccupied(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<BikesReservedOccupiedResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<BikesReservedOccupiedResponse>(BIKESOCCUPIED),
new GeneralData(),
new System.Exception("Bang, error bikes occupied"))));
server.Stub(x => x.GetBikesAvailable(Arg<bool>.Matches(fromCache => fromCache == true))).Return(Task.Run(() => new Result<BikesAvailableResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE),
new GeneralData())));
server.Stub(x => x.GetBikesAvailable(Arg<bool>.Matches(fromCache => fromCache == true))).Return(Task.Run(() => new Result<BikesAvailableResponse>(
typeof(CopriCallsMonkeyStore),
JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE),
new GeneralData())));
var result = await new CachedQueryLoggedIn(server, "123", "a@b", () => DateTime.Now).GetBikesAsync();
var result = await new CachedQueryLoggedIn(server, "123", "a@b", () => DateTime.Now).GetBikesAsync();
Assert.AreEqual(2, result.Response.Count);
Assert.AreEqual(typeof(CopriCallsMonkeyStore), result.Source);
Assert.AreEqual("Bang, error bikes occupied", result.Exception.Message);
}
Assert.AreEqual(2, result.Response.Count);
Assert.AreEqual(typeof(CopriCallsMonkeyStore), result.Source);
Assert.AreEqual("Bang, error bikes occupied", result.Exception.Message);
}
[Test]
public async Task TestGetBikes()
{
var server = Substitute.For<ICachedCopriServer>();
[Test]
public async Task TestGetBikes()
{
var server = Substitute.For<ICachedCopriServer>();
server.GetBikesAvailable().Returns(Task.Run(() => new Result<BikesAvailableResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE),
new GeneralData())));
server.GetBikesAvailable().Returns(Task.Run(() => new Result<BikesAvailableResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE),
new GeneralData())));
server.GetBikesOccupied().Returns(Task.Run(() => new Result<BikesReservedOccupiedResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<BikesReservedOccupiedResponse>(BIKESOCCUPIED),
new GeneralData())));
server.GetBikesOccupied().Returns(Task.Run(() => new Result<BikesReservedOccupiedResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<BikesReservedOccupiedResponse>(BIKESOCCUPIED),
new GeneralData())));
var result = await new CachedQueryLoggedIn(server, "123", "a@b", () => DateTime.Now).GetBikesAsync();
var result = await new CachedQueryLoggedIn(server, "123", "a@b", () => DateTime.Now).GetBikesAsync();
Assert.AreEqual(2, result.Response.Count);
Assert.AreEqual(typeof(CopriCallsHttps), result.Source);
Assert.IsNull(result.Exception);
}
Assert.AreEqual(2, result.Response.Count);
Assert.AreEqual(typeof(CopriCallsHttps), result.Source);
Assert.IsNull(result.Exception);
}
[Test]
public async Task TestGetBikesOccupied()
{
var server = Substitute.For<ICachedCopriServer>();
[Test]
public async Task TestGetBikesOccupied()
{
var server = Substitute.For<ICachedCopriServer>();
server.GetBikesAvailable().Returns(Task.Run(() => new Result<BikesAvailableResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<BikesAvailableResponse>("{}"),
new GeneralData())));
server.GetBikesAvailable().Returns(Task.Run(() => new Result<BikesAvailableResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<BikesAvailableResponse>("{}"),
new GeneralData())));
server.GetBikesOccupied().Returns(Task.Run(() => new Result<BikesReservedOccupiedResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<BikesReservedOccupiedResponse>(BIKESOCCUPIED),
new GeneralData())));
server.GetBikesOccupied().Returns(Task.Run(() => new Result<BikesReservedOccupiedResponse>(
typeof(CopriCallsHttps),
JsonConvert.DeserializeObject<BikesReservedOccupiedResponse>(BIKESOCCUPIED),
new GeneralData())));
var result = await new CachedQueryLoggedIn(server, "123", "a@b", () => DateTime.Now).GetBikesOccupiedAsync();
var result = await new CachedQueryLoggedIn(server, "123", "a@b", () => DateTime.Now).GetBikesOccupiedAsync();
Assert.AreEqual(1, result.Response.Count);
Assert.AreEqual(typeof(CopriCallsHttps), result.Source);
Assert.IsNull(result.Exception);
}
}
Assert.AreEqual(1, result.Response.Count);
Assert.AreEqual(typeof(CopriCallsHttps), result.Source);
Assert.IsNull(result.Exception);
}
}
}

36
TestTINKLib/Fixtures/ObjectTests/Connector/Response/TestBikesAvailableResponse.cs
View file

@ -6,23 +6,23 @@ using static TINK.Repository.CopriCallsMemory;
namespace TestTINKLib.Fixtures.Connector
{
[TestFixture]
public class TestBikesAvailableResponse
{
[Test]
public void TestDeserialize_StateAvailable()
{
// Deserialize object and verify.
var l_oContainer = GetBikesAvailable(TinkApp.MerchantId, sampleSet: SampleSets.Set2, stageIndex: 1);
Assert.AreEqual(12, l_oContainer.bikes.Count);
[TestFixture]
public class TestBikesAvailableResponse
{
[Test]
public void TestDeserialize_StateAvailable()
{
// Deserialize object and verify.
var l_oContainer = GetBikesAvailable(TinkApp.MerchantId, sampleSet: SampleSets.Set2, stageIndex: 1);
Assert.AreEqual(12, l_oContainer.bikes.Count);
// Check first entry.
Assert.AreEqual("Cargo Trike", l_oContainer.bikes["3399"].description);
Assert.AreEqual("26", l_oContainer.bikes["3399"].bike);
Assert.AreEqual("available", l_oContainer.bikes["3399"].state);
Assert.AreEqual("47.6586936667", l_oContainer.bikes["3399"].gps.latitude);
Assert.AreEqual("9.16863116667", l_oContainer.bikes["3399"].gps.longitude);
Assert.AreEqual("4", l_oContainer.bikes["3399"].station);
}
}
// Check first entry.
Assert.AreEqual("Cargo Trike", l_oContainer.bikes["3399"].description);
Assert.AreEqual("26", l_oContainer.bikes["3399"].bike);
Assert.AreEqual("available", l_oContainer.bikes["3399"].state);
Assert.AreEqual("47.6586936667", l_oContainer.bikes["3399"].gps.latitude);
Assert.AreEqual("9.16863116667", l_oContainer.bikes["3399"].gps.longitude);
Assert.AreEqual("4", l_oContainer.bikes["3399"].station);
}
}
}

74
TestTINKLib/Fixtures/ObjectTests/Connector/Response/TestBikesOccupiedResponse.cs
View file

@ -6,46 +6,46 @@ using static TINK.Repository.CopriCallsMemory;
namespace TestTINKLib.Fixtures.Connector.Response
{
[TestFixture]
public class TestBikesOccupiedResponse
{
[Test]
public void TestDeserialize()
{
// Deserialize object and verify.
var l_oContainer = GetBikesOccupied("4da3044c8657a04ba60e2eaa753bc51a", SampleSets.Set2, 1);
[TestFixture]
public class TestBikesOccupiedResponse
{
[Test]
public void TestDeserialize()
{
// Deserialize object and verify.
var l_oContainer = GetBikesOccupied("4da3044c8657a04ba60e2eaa753bc51a", SampleSets.Set2, 1);
Assert.AreEqual(2, l_oContainer.bikes_occupied.Count);
Assert.AreEqual(2, l_oContainer.bikes_occupied.Count);
// Check first entry.
Assert.AreEqual("3630", l_oContainer.bikes_occupied["87781"].timeCode);
Assert.AreEqual("occupied", l_oContainer.bikes_occupied["87781"].state);
Assert.AreEqual("5", l_oContainer.bikes_occupied["87781"].station);
Assert.AreEqual("Cargo Long", l_oContainer.bikes_occupied["87781"].description);
Assert.AreEqual("2017-11-28 11:01:51.637747+01", l_oContainer.bikes_occupied["87781"].start_time);
Assert.AreEqual("8", l_oContainer.bikes_occupied["87781"].bike);
// Check first entry.
Assert.AreEqual("3630", l_oContainer.bikes_occupied["87781"].timeCode);
Assert.AreEqual("occupied", l_oContainer.bikes_occupied["87781"].state);
Assert.AreEqual("5", l_oContainer.bikes_occupied["87781"].station);
Assert.AreEqual("Cargo Long", l_oContainer.bikes_occupied["87781"].description);
Assert.AreEqual("2017-11-28 11:01:51.637747+01", l_oContainer.bikes_occupied["87781"].start_time);
Assert.AreEqual("8", l_oContainer.bikes_occupied["87781"].bike);
// Check first entry.
Assert.AreEqual("2931", l_oContainer.bikes_occupied["87782"].timeCode);
Assert.AreEqual("occupied", l_oContainer.bikes_occupied["87782"].state);
Assert.AreEqual("4", l_oContainer.bikes_occupied["87782"].station);
Assert.AreEqual("Cargo Long", l_oContainer.bikes_occupied["87782"].description);
Assert.AreEqual("2017-11-28 13:06:55.147368+01", l_oContainer.bikes_occupied["87782"].start_time);
Assert.AreEqual("7", l_oContainer.bikes_occupied["87782"].bike);
}
// Check first entry.
Assert.AreEqual("2931", l_oContainer.bikes_occupied["87782"].timeCode);
Assert.AreEqual("occupied", l_oContainer.bikes_occupied["87782"].state);
Assert.AreEqual("4", l_oContainer.bikes_occupied["87782"].station);
Assert.AreEqual("Cargo Long", l_oContainer.bikes_occupied["87782"].description);
Assert.AreEqual("2017-11-28 13:06:55.147368+01", l_oContainer.bikes_occupied["87782"].start_time);
Assert.AreEqual("7", l_oContainer.bikes_occupied["87782"].bike);
}
[Test]
public void TestDeserialize_StateReserved()
{
// Deserialize object and verify.
var l_oContainer = CopriCallsMemory.GetBikesOccupied("4da3044c8657a04ba60e2eaa753bc51a", SampleSets.Set2, 2);
Assert.AreEqual(3, l_oContainer.bikes_occupied.Count);
[Test]
public void TestDeserialize_StateReserved()
{
// Deserialize object and verify.
var l_oContainer = CopriCallsMemory.GetBikesOccupied("4da3044c8657a04ba60e2eaa753bc51a", SampleSets.Set2, 2);
Assert.AreEqual(3, l_oContainer.bikes_occupied.Count);
// Check first entry.
Assert.AreEqual("Cargo Long", l_oContainer.bikes_occupied["2360"].description);
Assert.AreEqual("5", l_oContainer.bikes_occupied["2360"].bike);
Assert.AreEqual("reserved", l_oContainer.bikes_occupied["2360"].state);
Assert.AreEqual("4", l_oContainer.bikes_occupied["2360"].station);
}
}
// Check first entry.
Assert.AreEqual("Cargo Long", l_oContainer.bikes_occupied["2360"].description);
Assert.AreEqual("5", l_oContainer.bikes_occupied["2360"].bike);
Assert.AreEqual("reserved", l_oContainer.bikes_occupied["2360"].state);
Assert.AreEqual("4", l_oContainer.bikes_occupied["2360"].station);
}
}
}

78
TestTINKLib/Fixtures/ObjectTests/Connector/Response/TestBookingResponse.cs
View file

@ -6,49 +6,49 @@ using static TINK.Repository.CopriCallsMemory;
namespace TestTINKLib.Fixtures.Connector.Response
{
[TestFixture]
public class TestBookingResponse
{
[Test]
public void TestDeserialize()
{
// Deserialize object and verify.
var l_oContainer = CopriCallsMemory.DoReserve("8", "b76b97e43a2d76b8499f32e6dd597af8", SampleSets.Set2, 1);
[TestFixture]
public class TestBookingResponse
{
[Test]
public void TestDeserialize()
{
// Deserialize object and verify.
var l_oContainer = CopriCallsMemory.DoReserve("8", "b76b97e43a2d76b8499f32e6dd597af8", SampleSets.Set2, 1);
Assert.AreEqual(2, l_oContainer.bikes_occupied.Count);
Assert.AreEqual("3630", l_oContainer.timeCode);
Assert.AreEqual("OK: requested bike 8", l_oContainer.response_state);
Assert.AreEqual(2, l_oContainer.bikes_occupied.Count);
Assert.AreEqual("3630", l_oContainer.timeCode);
Assert.AreEqual("OK: requested bike 8", l_oContainer.response_state);
// Check first entry which is bike #8
Assert.AreEqual("3630", l_oContainer.bikes_occupied["87781"].timeCode);
Assert.AreEqual("occupied", l_oContainer.bikes_occupied["87781"].state);
Assert.AreEqual("5", l_oContainer.bikes_occupied["87781"].station);
Assert.AreEqual("Cargo Long", l_oContainer.bikes_occupied["87781"].description);
Assert.AreEqual("2017-11-28 11:01:51.637747+01", l_oContainer.bikes_occupied["87781"].start_time);
Assert.AreEqual("8", l_oContainer.bikes_occupied["87781"].bike);
}
// Check first entry which is bike #8
Assert.AreEqual("3630", l_oContainer.bikes_occupied["87781"].timeCode);
Assert.AreEqual("occupied", l_oContainer.bikes_occupied["87781"].state);
Assert.AreEqual("5", l_oContainer.bikes_occupied["87781"].station);
Assert.AreEqual("Cargo Long", l_oContainer.bikes_occupied["87781"].description);
Assert.AreEqual("2017-11-28 11:01:51.637747+01", l_oContainer.bikes_occupied["87781"].start_time);
Assert.AreEqual("8", l_oContainer.bikes_occupied["87781"].bike);
}
[Test]
public void TestGetIsBookingResponseSucceeded()
{
// Create response to check
var l_oResponse = DoReserve(
"8",
"4da3044c8657a04ba60e2eaa753bc51a",
SampleSets.Set2,
1);
[Test]
public void TestGetIsBookingResponseSucceeded()
{
// Create response to check
var l_oResponse = DoReserve(
"8",
"4da3044c8657a04ba60e2eaa753bc51a",
SampleSets.Set2,
1);
Assert.AreEqual(
"4da3044c8657a04ba60e2eaa753bc51aoiF2kahH",
l_oResponse.authcookie);
Assert.AreEqual(
"4da3044c8657a04ba60e2eaa753bc51aoiF2kahH",
l_oResponse.authcookie);
Assert.AreEqual(
"OK: requested bike 8",
l_oResponse.response_state);
Assert.AreEqual(
"OK: requested bike 8",
l_oResponse.response_state);
Assert.NotNull(
l_oResponse.GetIsReserveResponseOk("8"),
"Booking did succeed, response must not be null.");
}
}
Assert.NotNull(
l_oResponse.GetIsReserveResponseOk("8"),
"Booking did succeed, response must not be null.");
}
}
}

50
TestTINKLib/Fixtures/ObjectTests/Connector/Response/TestResponseBase.cs
View file

@ -5,25 +5,25 @@ using NUnit.Framework;
namespace TINK.Repository.Response
{
[TestFixture]
public class TestResponseBase
{
[Test]
public void TestDeserialize()
{
// Deserialize object and verify.
var l_oContainer = CopriCallsMemory.DoAuthorize("javaminister@gmail.com", "javaminister", "HwId1000000000000");
[TestFixture]
public class TestResponseBase
{
[Test]
public void TestDeserialize()
{
// Deserialize object and verify.
var l_oContainer = CopriCallsMemory.DoAuthorize("javaminister@gmail.com", "javaminister", "HwId1000000000000");
// Check first entry.
Assert.AreEqual("authorization", l_oContainer.response);
Assert.AreEqual("4da3044c8657a04ba60e2eaa753bc51a", l_oContainer.authcookie);
Assert.AreEqual("OK", l_oContainer.response_state);
}
// Check first entry.
Assert.AreEqual("authorization", l_oContainer.response);
Assert.AreEqual("4da3044c8657a04ba60e2eaa753bc51a", l_oContainer.authcookie);
Assert.AreEqual("OK", l_oContainer.response_state);
}
[Test]
public void TestToString()
{
var l_oResponse = JsonConvert.DeserializeObject<ResponseBase>(@"
[Test]
public void TestToString()
{
var l_oResponse = JsonConvert.DeserializeObject<ResponseBase>(@"
{
""response_state"": ""OhMyState"",
""response"": ""HabGsagt"",
@ -32,12 +32,12 @@ namespace TINK.Repository.Response
""copri_version"":""123""
}");
Assert.AreEqual(
"Response state is \"OhMyState\", " +
$"auth cookie is \"lecker1\" and response is \"die Antwort\", " +
$"code \"HabGsagt\"" +
$"response text \"die Antwort\".",
l_oResponse.ToString());
}
}
Assert.AreEqual(
"Response state is \"OhMyState\", " +
$"auth cookie is \"lecker1\" and response is \"die Antwort\", " +
$"code \"HabGsagt\"" +
$"response text \"die Antwort\".",
l_oResponse.ToString());
}
}
}

128
TestTINKLib/Fixtures/ObjectTests/Connector/Response/TestResponseHelper.cs
View file

@ -6,81 +6,81 @@ using TINK.Repository.Response;
namespace TestTINKLib.Fixtures.ObjectTests.Connector.Response
{
[TestFixture]
public class TestResponseHelper
{
[Test]
public void TestGetIsResponseOk_BikesOccupied_Ok()
{
var l_oResponse = JsonConvert.DeserializeObject<BikesReservedOccupiedResponse>(@"{ ""response_state"" : ""OK"" }");
Assert.NotNull(l_oResponse.GetIsResponseOk(ResponseHelper.BIKES_OCCUPIED_ACTIONTEXT));
}
[TestFixture]
public class TestResponseHelper
{
[Test]
public void TestGetIsResponseOk_BikesOccupied_Ok()
{
var l_oResponse = JsonConvert.DeserializeObject<BikesReservedOccupiedResponse>(@"{ ""response_state"" : ""OK"" }");
Assert.NotNull(l_oResponse.GetIsResponseOk(ResponseHelper.BIKES_OCCUPIED_ACTIONTEXT));
}
[Test]
public void TestGetIsResponseOk_BikesOccupied_AuthcookieNotDefined()
{
var l_oResponseBase = JsonConvert.DeserializeObject<ResponseBase>($"{{ \"response_state\" : \"Failure 1003: authcookie not defined\" }}");
Assert.Throws<AuthcookieNotDefinedException>(() => l_oResponseBase.GetIsResponseOk("Get not succeed"));
}
[Test]
public void TestGetIsResponseOk_BikesOccupied_AuthcookieNotDefined()
{
var l_oResponseBase = JsonConvert.DeserializeObject<ResponseBase>($"{{ \"response_state\" : \"Failure 1003: authcookie not defined\" }}");
Assert.Throws<AuthcookieNotDefinedException>(() => l_oResponseBase.GetIsResponseOk("Get not succeed"));
}
[Test]
public void TestGetIsResponseOk_NoBikes()
{
var l_oResponse = JsonConvert.DeserializeObject<ReservationBookingResponse>(
@"{ ""response_state"" : ""OK"", " +
@"""authcookie"" : ""KeksoiF2kahH"" }");
[Test]
public void TestGetIsResponseOk_NoBikes()
{
var l_oResponse = JsonConvert.DeserializeObject<ReservationBookingResponse>(
@"{ ""response_state"" : ""OK"", " +
@"""authcookie"" : ""KeksoiF2kahH"" }");
Assert.That(() => l_oResponse.GetIsReserveResponseOk("8"), Throws.Exception.TypeOf<System.Exception>());
}
Assert.That(() => l_oResponse.GetIsReserveResponseOk("8"), Throws.Exception.TypeOf<System.Exception>());
}
[Test]
public void TestGetIsResposeOk_Booking_Declined()
{
var l_oResponse = JsonConvert.DeserializeObject<ReservationBookingResponse>(@"{ ""response_state"" : ""OK: booking_request declined. max count of 8 occupied bikes has been reached"", ""authcookie"" : ""KeksoiF2kahH"" }");
Assert.AreEqual(
8,
Assert.Throws<BookingDeclinedException>(() => l_oResponse.GetIsReserveResponseOk("8")).MaxBikesCount);
}
[Test]
public void TestGetIsResposeOk_Booking_Declined()
{
var l_oResponse = JsonConvert.DeserializeObject<ReservationBookingResponse>(@"{ ""response_state"" : ""OK: booking_request declined. max count of 8 occupied bikes has been reached"", ""authcookie"" : ""KeksoiF2kahH"" }");
Assert.AreEqual(
8,
Assert.Throws<BookingDeclinedException>(() => l_oResponse.GetIsReserveResponseOk("8")).MaxBikesCount);
}
[Test]
public void TestGetIsResposeOk_Logout_AutcookieUnknown()
{
var l_oResponse = JsonConvert.DeserializeObject<AuthorizationoutResponse>($"{{ \"response_state\" : \"Failure 1004: authcookie not defined\"}}");
[Test]
public void TestGetIsResposeOk_Logout_AutcookieUnknown()
{
var l_oResponse = JsonConvert.DeserializeObject<AuthorizationoutResponse>($"{{ \"response_state\" : \"Failure 1004: authcookie not defined\"}}");
Assert.Throws<AuthcookieNotDefinedException>(() => l_oResponse.GetIsResponseOk());
}
Assert.Throws<AuthcookieNotDefinedException>(() => l_oResponse.GetIsResponseOk());
}
[Test]
public void TestGetIsReturnBikeResponseOk_Error()
{
var l_oResponse = JsonConvert.DeserializeObject<DoReturnResponse>(
@"{ ""response_state"" : ""Failure 1234"", " +
@"""authcookie"" : ""KeksoiF2kahH"" }");
[Test]
public void TestGetIsReturnBikeResponseOk_Error()
{
var l_oResponse = JsonConvert.DeserializeObject<DoReturnResponse>(
@"{ ""response_state"" : ""Failure 1234"", " +
@"""authcookie"" : ""KeksoiF2kahH"" }");
Assert.That(
() => l_oResponse.GetIsReturnBikeResponseOk("8"),
Throws.Exception.TypeOf<InvalidResponseException<ResponseBase>>());
}
Assert.That(
() => l_oResponse.GetIsReturnBikeResponseOk("8"),
Throws.Exception.TypeOf<InvalidResponseException<ResponseBase>>());
}
[Test]
public void TestGetIsReturnBikeResponseOk_ErrorNotAtStation()
{
var l_oResponse = JsonConvert.DeserializeObject<DoReturnResponse>(
@"{ ""response_state"" : ""Failure 2178: bike 1545 out of GEO fencing. 15986 meter distance to next station 66. OK: bike 1545 locked confirmed"", " +
@"""authcookie"" : ""KeksoiF2kahH"" }");
[Test]
public void TestGetIsReturnBikeResponseOk_ErrorNotAtStation()
{
var l_oResponse = JsonConvert.DeserializeObject<DoReturnResponse>(
@"{ ""response_state"" : ""Failure 2178: bike 1545 out of GEO fencing. 15986 meter distance to next station 66. OK: bike 1545 locked confirmed"", " +
@"""authcookie"" : ""KeksoiF2kahH"" }");
Assert.That(() => l_oResponse.GetIsReturnBikeResponseOk("8"), Throws.Exception.TypeOf<NotAtStationException>());
}
Assert.That(() => l_oResponse.GetIsReturnBikeResponseOk("8"), Throws.Exception.TypeOf<NotAtStationException>());
}
[Test]
public void TestGetIsReturnBikeResponseOk_ErrorNoGPSData()
{
var l_oResponse = JsonConvert.DeserializeObject<DoReturnResponse>(
@"{ ""response_state"" : ""Failure 2245: No GPS data, state change forbidden."", " +
@"""authcookie"" : ""KeksoiF2kahH"" }");
[Test]
public void TestGetIsReturnBikeResponseOk_ErrorNoGPSData()
{
var l_oResponse = JsonConvert.DeserializeObject<DoReturnResponse>(
@"{ ""response_state"" : ""Failure 2245: No GPS data, state change forbidden."", " +
@"""authcookie"" : ""KeksoiF2kahH"" }");
Assert.That(() => l_oResponse.GetIsReturnBikeResponseOk("8"), Throws.Exception.TypeOf<NoGPSDataException>());
}
}
Assert.That(() => l_oResponse.GetIsReturnBikeResponseOk("8"), Throws.Exception.TypeOf<NoGPSDataException>());
}
}
}

58
TestTINKLib/Fixtures/ObjectTests/Connector/Response/TestStationsAllResponse.cs
View file

@ -6,36 +6,36 @@ using static TINK.Repository.CopriCallsMemory;
namespace TestTINKLib.Fixtures.Connector
{
[TestFixture]
public class TestStationsAllResponse
{
[Test]
public void TestDeserialize()
{
// Deserialize object and verify.
var l_oContainer = GetStationsAll(TinkApp.MerchantId, p_eSampleSet: SampleSets.Set2, p_lStageIndex: 1);
Assert.AreEqual(9, l_oContainer.stations.Count);
[TestFixture]
public class TestStationsAllResponse
{
[Test]
public void TestDeserialize()
{
// Deserialize object and verify.
var l_oContainer = GetStationsAll(TinkApp.MerchantId, p_eSampleSet: SampleSets.Set2, p_lStageIndex: 1);
Assert.AreEqual(9, l_oContainer.stations.Count);
// Check first entry (type TINK).
Assert.AreEqual("4", l_oContainer.stations["5786"].station);
Assert.AreEqual("TINK", string.Join(",", l_oContainer.stations["5786"].station_group));
Assert.IsNull(l_oContainer.stations["5786"].description);
Assert.AreEqual("47.6586936667", l_oContainer.stations["5786"].gps.latitude);
Assert.AreEqual("9.16863116667", l_oContainer.stations["5786"].gps.longitude);
// Check first entry (type TINK).
Assert.AreEqual("4", l_oContainer.stations["5786"].station);
Assert.AreEqual("TINK", string.Join(",", l_oContainer.stations["5786"].station_group));
Assert.IsNull(l_oContainer.stations["5786"].description);
Assert.AreEqual("47.6586936667", l_oContainer.stations["5786"].gps.latitude);
Assert.AreEqual("9.16863116667", l_oContainer.stations["5786"].gps.longitude);
// Check Konrad entry.
Assert.AreEqual("14", l_oContainer.stations["14"].station);
Assert.AreEqual("Konrad", string.Join(",", l_oContainer.stations["14"].station_group));
Assert.AreEqual(string.Empty, l_oContainer.stations["14"].description);
Assert.AreEqual("47.66698054007847", l_oContainer.stations["14"].gps.latitude);
Assert.AreEqual("9.169303178787231", l_oContainer.stations["14"].gps.longitude);
// Check Konrad entry.
Assert.AreEqual("14", l_oContainer.stations["14"].station);
Assert.AreEqual("Konrad", string.Join(",", l_oContainer.stations["14"].station_group));
Assert.AreEqual(string.Empty, l_oContainer.stations["14"].description);
Assert.AreEqual("47.66698054007847", l_oContainer.stations["14"].gps.latitude);
Assert.AreEqual("9.169303178787231", l_oContainer.stations["14"].gps.longitude);
// Check TINK/ Konrad entry.
Assert.AreEqual("31", l_oContainer.stations["31"].station);
Assert.AreEqual("TINK,Konrad", string.Join(",", l_oContainer.stations["31"].station_group));
Assert.AreEqual("Südstadt Station", l_oContainer.stations["31"].description);
Assert.AreEqual("47.69489", l_oContainer.stations["31"].gps.latitude);
Assert.AreEqual("9.19", l_oContainer.stations["31"].gps.longitude);
}
}
// Check TINK/ Konrad entry.
Assert.AreEqual("31", l_oContainer.stations["31"].station);
Assert.AreEqual("TINK,Konrad", string.Join(",", l_oContainer.stations["31"].station_group));
Assert.AreEqual("Südstadt Station", l_oContainer.stations["31"].description);
Assert.AreEqual("47.69489", l_oContainer.stations["31"].gps.latitude);
Assert.AreEqual("9.19", l_oContainer.stations["31"].gps.longitude);
}
}
}

86
TestTINKLib/Fixtures/ObjectTests/Connector/TestCommandLoggedIn.cs
View file

@ -10,64 +10,64 @@ using TINK.Repository.Response;
namespace TestTINKLib.Fixtures.ObjectTests.Connector
{
[TestFixture]
public class TestCommandLoggedIn
{
/// <summary> Verifies, that logout leads to expected call on copri server. </summary>
[Test]
public void TestDoLogout()
{
var l_oServer = MockRepository.GenerateStub<ICopriServer>();
[TestFixture]
public class TestCommandLoggedIn
{
/// <summary> Verifies, that logout leads to expected call on copri server. </summary>
[Test]
public void TestDoLogout()
{
var l_oServer = MockRepository.GenerateStub<ICopriServer>();
l_oServer.Stub(x => x.DoAuthoutAsync()).Return(Task.Run(() => JsonConvert.DeserializeObject<AuthorizationoutResponse>("{ \"response_state\" : \"OK\", \"authcookie\" : \"1\"}")));
l_oServer.Stub(x => x.DoAuthoutAsync()).Return(Task.Run(() => JsonConvert.DeserializeObject<AuthorizationoutResponse>("{ \"response_state\" : \"OK\", \"authcookie\" : \"1\"}")));
var l_oCmd = new CommandLoggedIn(l_oServer, "MeinKeks", "EMehl", () => DateTime.Now);
var l_oCmd = new CommandLoggedIn(l_oServer, "MeinKeks", "EMehl", () => DateTime.Now);
LoginStateChangedEventArgs l_oEventArgs = null;
l_oCmd.LoginStateChanged += (sender, eventargs) => l_oEventArgs = eventargs;
LoginStateChangedEventArgs l_oEventArgs = null;
l_oCmd.LoginStateChanged += (sender, eventargs) => l_oEventArgs = eventargs;
l_oCmd.DoLogout().Wait();
l_oCmd.DoLogout().Wait();
l_oServer.AssertWasCalled(x => x.DoAuthoutAsync());
Assert.IsNotNull(l_oEventArgs);
}
l_oServer.AssertWasCalled(x => x.DoAuthoutAsync());
Assert.IsNotNull(l_oEventArgs);
}
/// <summary> Verifies, that logout leads to expected call on copri server. </summary>
[Test]
public void TestDoLogout_AuthcookieNotDefined()
{
var l_oServer = MockRepository.GenerateStub<ICopriServer>();
/// <summary> Verifies, that logout leads to expected call on copri server. </summary>
[Test]
public void TestDoLogout_AuthcookieNotDefined()
{
var l_oServer = MockRepository.GenerateStub<ICopriServer>();
l_oServer.Stub(x => x.DoAuthoutAsync()).Throw(new AuthcookieNotDefinedException("Testing action", JsonConvert.DeserializeObject<ResponseBase>(@"{ ""response_state"" : ""Some inner error description""}")));
l_oServer.Stub(x => x.DoAuthoutAsync()).Throw(new AuthcookieNotDefinedException("Testing action", JsonConvert.DeserializeObject<ResponseBase>(@"{ ""response_state"" : ""Some inner error description""}")));
var l_oCmd = new CommandLoggedIn(l_oServer, "MeinKeks", "EMehl", () => DateTime.Now);
var l_oCmd = new CommandLoggedIn(l_oServer, "MeinKeks", "EMehl", () => DateTime.Now);
LoginStateChangedEventArgs l_oEventArgs = null;
l_oCmd.LoginStateChanged += (sender, eventargs) => l_oEventArgs = eventargs;
LoginStateChangedEventArgs l_oEventArgs = null;
l_oCmd.LoginStateChanged += (sender, eventargs) => l_oEventArgs = eventargs;
l_oCmd.DoLogout().Wait();
l_oCmd.DoLogout().Wait();
l_oServer.AssertWasCalled(x => x.DoAuthoutAsync());
Assert.IsNotNull(l_oEventArgs);
}
l_oServer.AssertWasCalled(x => x.DoAuthoutAsync());
Assert.IsNotNull(l_oEventArgs);
}
/// <summary> Verifies, that logout leads to expected call on copri server. </summary>
[Test]
public void TestDoLogout_Exception()
{
var l_oServer = MockRepository.GenerateStub<ICopriServer>();
/// <summary> Verifies, that logout leads to expected call on copri server. </summary>
[Test]
public void TestDoLogout_Exception()
{
var l_oServer = MockRepository.GenerateStub<ICopriServer>();
l_oServer.Stub(x => x.DoAuthoutAsync()).Throw(new System.Exception("Sometheing went wrong."));
l_oServer.Stub(x => x.DoAuthoutAsync()).Throw(new System.Exception("Sometheing went wrong."));
var l_oCmd = new CommandLoggedIn(l_oServer, "MeinKeks", "EMehl", () => DateTime.Now);
var l_oCmd = new CommandLoggedIn(l_oServer, "MeinKeks", "EMehl", () => DateTime.Now);
LoginStateChangedEventArgs l_oEventArgs = null;
l_oCmd.LoginStateChanged += (sender, eventargs) => l_oEventArgs = eventargs;
LoginStateChangedEventArgs l_oEventArgs = null;
l_oCmd.LoginStateChanged += (sender, eventargs) => l_oEventArgs = eventargs;
Assert.Throws<AggregateException>(() => l_oCmd.DoLogout().Wait());
Assert.Throws<AggregateException>(() => l_oCmd.DoLogout().Wait());
l_oServer.AssertWasCalled(x => x.DoAuthoutAsync());
Assert.IsNull(l_oEventArgs);
}
}
l_oServer.AssertWasCalled(x => x.DoAuthoutAsync());
Assert.IsNull(l_oEventArgs);
}
}
}

138
TestTINKLib/Fixtures/ObjectTests/Connector/TestConnector.cs
View file

@ -7,84 +7,84 @@ using TINK.Repository;
namespace TestTINKLib.Fixtures.ObjectTests.Connector
{
[TestFixture]
public class TestConnector
{
/// <summary>
/// Verifies that factory method returns correcty type depending on session cookie.
/// </summary>
[Test]
public void TestCommandFactory()
{
var l_oCopri = MockRepository.GenerateStub<ICachedCopriServer>();
[TestFixture]
public class TestConnector
{
/// <summary>
/// Verifies that factory method returns correcty type depending on session cookie.
/// </summary>
[Test]
public void TestCommandFactory()
{
var l_oCopri = MockRepository.GenerateStub<ICachedCopriServer>();
// Construct not logged in version of connector.
var l_oCommand = new TINK.Model.Connector.Connector(
new System.Uri("http://1.2.3.4"),
new AppContextInfo("oiF2kahH", "sharee.bike.test", new Version(3, 0, 267)),
null /*UI language */,
"", // Not logged in
"",
server: l_oCopri).Command;
// Construct not logged in version of connector.
var l_oCommand = new TINK.Model.Connector.Connector(
new System.Uri("http://1.2.3.4"),
new AppContextInfo("oiF2kahH", "sharee.bike.test", new Version(3, 0, 267)),
null /*UI language */,
"", // Not logged in
"",
server: l_oCopri).Command;
Assert.AreEqual(typeof(Command), l_oCommand.GetType());
}
Assert.AreEqual(typeof(Command), l_oCommand.GetType());
}
/// <summary>
/// Verifies that factory method returns correcty type depending on session cookie.
/// </summary>
[Test]
public void TestCommandFactory_LoggedIn()
{
var l_oCopri = MockRepository.GenerateStub<ICachedCopriServer>();
/// <summary>
/// Verifies that factory method returns correcty type depending on session cookie.
/// </summary>
[Test]
public void TestCommandFactory_LoggedIn()
{
var l_oCopri = MockRepository.GenerateStub<ICachedCopriServer>();
var l_oCommand = new TINK.Model.Connector.Connector(
new System.Uri("http://1.2.3.4"),
new AppContextInfo("oiF2kahH", "sharee.bike.test", new Version(3, 0, 267)),
null /*UI language */,
"123", // Logged in
"a@b",
server: l_oCopri).Command;
var l_oCommand = new TINK.Model.Connector.Connector(
new System.Uri("http://1.2.3.4"),
new AppContextInfo("oiF2kahH", "sharee.bike.test", new Version(3, 0, 267)),
null /*UI language */,
"123", // Logged in
"a@b",
server: l_oCopri).Command;
Assert.AreEqual(typeof(CommandLoggedIn), l_oCommand.GetType());
}
Assert.AreEqual(typeof(CommandLoggedIn), l_oCommand.GetType());
}
/// <summary>
/// Verifies that factory method returns correcty type depending on session cookie.
/// </summary>
[Test]
public void TestQueryFactory_CachedServer()
{
var l_oCopri = MockRepository.GenerateStub<ICachedCopriServer>();
/// <summary>
/// Verifies that factory method returns correcty type depending on session cookie.
/// </summary>
[Test]
public void TestQueryFactory_CachedServer()
{
var l_oCopri = MockRepository.GenerateStub<ICachedCopriServer>();
var l_oQuery = new TINK.Model.Connector.Connector(
new Uri("http://1.2.3.4"),
new AppContextInfo("oiF2kahH", "sharee.bike.test", new Version(3, 0, 267)),
null /*UI language */,
"",
"",
server: l_oCopri).Query;
var l_oQuery = new TINK.Model.Connector.Connector(
new Uri("http://1.2.3.4"),
new AppContextInfo("oiF2kahH", "sharee.bike.test", new Version(3, 0, 267)),
null /*UI language */,
"",
"",
server: l_oCopri).Query;
Assert.AreEqual(typeof(CachedQuery), l_oQuery.GetType());
}
Assert.AreEqual(typeof(CachedQuery), l_oQuery.GetType());
}
/// <summary>
/// Verifies that factory method returns correcty type depending on session cookie.
/// </summary>
[Test]
public void TestQueryFactory_LoggedIn()
{
var l_oCopri = MockRepository.GenerateStub<ICachedCopriServer>();
/// <summary>
/// Verifies that factory method returns correcty type depending on session cookie.
/// </summary>
[Test]
public void TestQueryFactory_LoggedIn()
{
var l_oCopri = MockRepository.GenerateStub<ICachedCopriServer>();
var l_oQuery = new TINK.Model.Connector.Connector(
new System.Uri("http://1.2.3.4"),
new AppContextInfo("oiF2kahH", "sharee.bike.test", new Version(3, 0, 267)),
null /*UI language */,
"123",
"a@b",
server: l_oCopri).Query;
var l_oQuery = new TINK.Model.Connector.Connector(
new System.Uri("http://1.2.3.4"),
new AppContextInfo("oiF2kahH", "sharee.bike.test", new Version(3, 0, 267)),
null /*UI language */,
"123",
"a@b",
server: l_oCopri).Query;
Assert.AreEqual(typeof(CachedQueryLoggedIn), l_oQuery.GetType());
}
}
Assert.AreEqual(typeof(CachedQueryLoggedIn), l_oQuery.GetType());
}
}
}

130
TestTINKLib/Fixtures/ObjectTests/Connector/TestConnectorCache.cs
View file

@ -6,80 +6,80 @@ using TINK.Repository;
namespace TestTINKLib.Fixtures.ObjectTests.Connector
{
[TestFixture]
public class TestConnectorCache
{
/// <summary>
/// Verifies that factory method returns correcty type depending on session cookie.
/// </summary>
[Test]
public void TestCommandFactory()
{
var l_oCopri = MockRepository.GenerateStub<ICopriServer>();
[TestFixture]
public class TestConnectorCache
{
/// <summary>
/// Verifies that factory method returns correcty type depending on session cookie.
/// </summary>
[Test]
public void TestCommandFactory()
{
var l_oCopri = MockRepository.GenerateStub<ICopriServer>();
// Construct not logged in version of connector.
var l_oCommand = new ConnectorCache(
new AppContextInfo("MyMerchId", "MyApp", new Version(1, 2)),
null /*UI language */,
"", // Not logged in
"",
l_oCopri).Command;
// Construct not logged in version of connector.
var l_oCommand = new ConnectorCache(
new AppContextInfo("MyMerchId", "MyApp", new Version(1, 2)),
null /*UI language */,
"", // Not logged in
"",
l_oCopri).Command;
Assert.AreEqual(typeof(Command), l_oCommand.GetType());
}
Assert.AreEqual(typeof(Command), l_oCommand.GetType());
}
/// <summary>
/// Verifies that factory method returns correcty type depending on session cookie.
/// </summary>
[Test]
public void TestCommandFactory_LoggedIn()
{
var l_oCopri = MockRepository.GenerateStub<ICopriServer>();
/// <summary>
/// Verifies that factory method returns correcty type depending on session cookie.
/// </summary>
[Test]
public void TestCommandFactory_LoggedIn()
{
var l_oCopri = MockRepository.GenerateStub<ICopriServer>();
var l_oCommand = new ConnectorCache(
new AppContextInfo("MyMerchId", "MyApp", new Version(1, 2)),
null /*UI language */,
"123", // Logged in
"a@b",
l_oCopri).Command;
var l_oCommand = new ConnectorCache(
new AppContextInfo("MyMerchId", "MyApp", new Version(1, 2)),
null /*UI language */,
"123", // Logged in
"a@b",
l_oCopri).Command;
Assert.AreEqual(typeof(CommandLoggedIn), l_oCommand.GetType());
}
Assert.AreEqual(typeof(CommandLoggedIn), l_oCommand.GetType());
}
/// <summary>
/// Verifies that factory method returns correcty type depending on session cookie.
/// </summary>
[Test]
public void TestQueryFactory_CachedServer()
{
var l_oCopri = MockRepository.GenerateStub<ICopriServer>();
/// <summary>
/// Verifies that factory method returns correcty type depending on session cookie.
/// </summary>
[Test]
public void TestQueryFactory_CachedServer()
{
var l_oCopri = MockRepository.GenerateStub<ICopriServer>();
var l_oQuery = new ConnectorCache(
new AppContextInfo("MyMerchId", "MyApp", new Version(1, 2)),
null /*UI language */,
"",
"",
l_oCopri).Query;
var l_oQuery = new ConnectorCache(
new AppContextInfo("MyMerchId", "MyApp", new Version(1, 2)),
null /*UI language */,
"",
"",
l_oCopri).Query;
Assert.AreEqual(typeof(TINK.Model.Connector.Query), l_oQuery.GetType());
}
Assert.AreEqual(typeof(TINK.Model.Connector.Query), l_oQuery.GetType());
}
/// <summary>
/// Verifies that factory method returns correcty type depending on session cookie.
/// </summary>
[Test]
public void TestQueryFactory_LoggedIn()
{
var l_oCopri = MockRepository.GenerateStub<ICopriServer>();
/// <summary>
/// Verifies that factory method returns correcty type depending on session cookie.
/// </summary>
[Test]
public void TestQueryFactory_LoggedIn()
{
var l_oCopri = MockRepository.GenerateStub<ICopriServer>();
var l_oQuery = new ConnectorCache(
new AppContextInfo("MyMerchId", "MyApp", new Version(1, 2)),
null /*UI language */,
"123",
"a@b",
l_oCopri).Query;
var l_oQuery = new ConnectorCache(
new AppContextInfo("MyMerchId", "MyApp", new Version(1, 2)),
null /*UI language */,
"123",
"a@b",
l_oCopri).Query;
Assert.AreEqual(typeof(QueryLoggedIn), l_oQuery.GetType());
}
}
Assert.AreEqual(typeof(QueryLoggedIn), l_oQuery.GetType());
}
}
}

970
TestTINKLib/Fixtures/ObjectTests/Connector/TestCopriCallsHttps.cs
View file

File diff suppressed because it is too large Load diff

110
TestTINKLib/Fixtures/ObjectTests/Connector/TestCopriCallsMemory.cs.cs
View file

@ -9,66 +9,66 @@ using static TINK.Repository.CopriCallsMemory;
namespace TestTINKLib.Fixtures.Connector.Request
{
[TestFixture]
public class TestCopriCallsMemory
{
[Test]
public void TestConsistency()
{
foreach (SampleSets l_oSampleSet in Enum.GetValues(typeof(SampleSets)))
{
var l_oCopri = new CopriCallsMemory("MyMerchId", l_oSampleSet, 1, "4da3044c8657a04ba60e2eaa753bc51a");
[TestFixture]
public class TestCopriCallsMemory
{
[Test]
public void TestConsistency()
{
foreach (SampleSets l_oSampleSet in Enum.GetValues(typeof(SampleSets)))
{
var l_oCopri = new CopriCallsMemory("MyMerchId", l_oSampleSet, 1, "4da3044c8657a04ba60e2eaa753bc51a");
for (var l_iStageIndex = 1; l_iStageIndex <= l_oCopri.StagesCount; l_iStageIndex++)
{
Assert.That(l_oCopri.GetBikesAvailableAsync().Result?.bikes, Is.Not.Null, $"There must be at least one bike for sample set {l_oSampleSet}, stage {l_iStageIndex}.");
VerifyBikeIdIsUnique(l_oCopri);
for (var l_iStageIndex = 1; l_iStageIndex <= l_oCopri.StagesCount; l_iStageIndex++)
{
Assert.That(l_oCopri.GetBikesAvailableAsync().Result?.bikes, Is.Not.Null, $"There must be at least one bike for sample set {l_oSampleSet}, stage {l_iStageIndex}.");
VerifyBikeIdIsUnique(l_oCopri);
Assert.IsNull(
l_oCopri.GetBikesAvailableAsync().Result.bikes.Values.FirstOrDefault(x => x.state != "available"),
"Bikes available must return bikes which are all of state available.");
Assert.IsNull(
l_oCopri.GetBikesAvailableAsync().Result.bikes.Values.FirstOrDefault(x => x.state != "available"),
"Bikes available must return bikes which are all of state available.");
Assert.IsNull(
l_oCopri.GetBikesOccupiedAsync().Result.bikes_occupied.Values.FirstOrDefault(x => x.state == "available"),
"Bikes occupied must return bikes which are either reserved or booked.");
}
}
}
Assert.IsNull(
l_oCopri.GetBikesOccupiedAsync().Result.bikes_occupied.Values.FirstOrDefault(x => x.state == "available"),
"Bikes occupied must return bikes which are either reserved or booked.");
}
}
}
/// <summary>
/// Test consistency for a single sample set,
/// </summary>
/// <param name="p_oMemory"></param>
private void VerifyBikeIdIsUnique(CopriCallsMemory p_oMemory)
{
Dictionary<string, BikeInfoBase> l_oChecker = new Dictionary<string, BikeInfoBase>();
/// <summary>
/// Test consistency for a single sample set,
/// </summary>
/// <param name="p_oMemory"></param>
private void VerifyBikeIdIsUnique(CopriCallsMemory p_oMemory)
{
Dictionary<string, BikeInfoBase> l_oChecker = new Dictionary<string, BikeInfoBase>();
var l_oBikesAvailable = p_oMemory.GetBikesAvailableAsync().Result;
foreach (var l_oBike in l_oBikesAvailable.bikes.Values)
{
Assert.IsFalse(
l_oChecker.Keys.Contains(l_oBike.bike),
string.Format(
"Bike form available bikes with id {0} already exist in dictionary. Sample set is {1}, stage index {2}.",
l_oBike.bike,
p_oMemory.ActiveSampleSet,
p_oMemory.ActiveStageIndex));
var l_oBikesAvailable = p_oMemory.GetBikesAvailableAsync().Result;
foreach (var l_oBike in l_oBikesAvailable.bikes.Values)
{
Assert.IsFalse(
l_oChecker.Keys.Contains(l_oBike.bike),
string.Format(
"Bike form available bikes with id {0} already exist in dictionary. Sample set is {1}, stage index {2}.",
l_oBike.bike,
p_oMemory.ActiveSampleSet,
p_oMemory.ActiveStageIndex));
l_oChecker.Add(l_oBike.bike, l_oBike);
}
l_oChecker.Add(l_oBike.bike, l_oBike);
}
var l_oBikesOccupied = p_oMemory.GetBikesOccupiedAsync().Result;
foreach (var l_oBike in l_oBikesOccupied.bikes_occupied.Values)
{
Assert.IsFalse(
l_oChecker.Keys.Contains(l_oBike.bike),
string.Format(
"Bike from occupied bikes with id {0} already exist in dictionary. Sample set is {1}, stage index {2}.",
l_oBike.bike,
p_oMemory.ActiveSampleSet,
p_oMemory.ActiveStageIndex));
l_oChecker.Add(l_oBike.bike, l_oBike);
}
}
}
var l_oBikesOccupied = p_oMemory.GetBikesOccupiedAsync().Result;
foreach (var l_oBike in l_oBikesOccupied.bikes_occupied.Values)
{
Assert.IsFalse(
l_oChecker.Keys.Contains(l_oBike.bike),
string.Format(
"Bike from occupied bikes with id {0} already exist in dictionary. Sample set is {1}, stage index {2}.",
l_oBike.bike,
p_oMemory.ActiveSampleSet,
p_oMemory.ActiveStageIndex));
l_oChecker.Add(l_oBike.bike, l_oBike);
}
}
}
}

124
TestTINKLib/Fixtures/ObjectTests/Connector/TestCopriCallsStatic.cs
View file

@ -5,13 +5,13 @@ using TINK.Repository.Response;
namespace TestTINKLib.Fixtures.ObjectTests.Connector.Request
{
[TestFixture]
public class TestCopriCallsStatic
{
[Test]
public void TestDeserializeObjectBikesAvailableValidResponse()
{
const string VALID_RESPONSE = @"
[TestFixture]
public class TestCopriCallsStatic
{
[Test]
public void TestDeserializeObjectBikesAvailableValidResponse()
{
const string VALID_RESPONSE = @"
{
""shareejson"": {
@ -34,23 +34,23 @@ namespace TestTINKLib.Fixtures.ObjectTests.Connector.Request
}
";
// Ensure that answer holds a valid bike.
var l_oBike = CopriCallsStatic.DeserializeResponse<BikesAvailableResponse>(VALID_RESPONSE).bikes.FirstOrDefault().Value;
Assert.NotNull(l_oBike, "Response must contain at leas one bike.");
Assert.Greater(l_oBike.description.Length, 0, "Bike despcription must never be empty.");
Assert.AreEqual(l_oBike.bike, "26");
Assert.That(
l_oBike.station,
Is.EqualTo("4"),
"Station index must never be negative");
Assert.AreEqual("available", l_oBike.state);
Assert.That(l_oBike.gps, Is.Not.Null, "Gps position must never be empty.");
}
// Ensure that answer holds a valid bike.
var l_oBike = CopriCallsStatic.DeserializeResponse<BikesAvailableResponse>(VALID_RESPONSE).bikes.FirstOrDefault().Value;
Assert.NotNull(l_oBike, "Response must contain at leas one bike.");
Assert.Greater(l_oBike.description.Length, 0, "Bike despcription must never be empty.");
Assert.AreEqual(l_oBike.bike, "26");
Assert.That(
l_oBike.station,
Is.EqualTo("4"),
"Station index must never be negative");
Assert.AreEqual("available", l_oBike.state);
Assert.That(l_oBike.gps, Is.Not.Null, "Gps position must never be empty.");
}
[Test]
public void TestDeserializeObjectBikesAvailableValidResponse_NoDescription()
{
const string INVALID_RESPONSE = @"
[Test]
public void TestDeserializeObjectBikesAvailableValidResponse_NoDescription()
{
const string INVALID_RESPONSE = @"
{
""shareejson"": {
@ -72,20 +72,20 @@ namespace TestTINKLib.Fixtures.ObjectTests.Connector.Request
}
";
// Ensure that answer holds a valid bike.
var l_oBike = CopriCallsStatic.DeserializeResponse<BikesAvailableResponse>(INVALID_RESPONSE).bikes.FirstOrDefault().Value;
Assert.NotNull(l_oBike, "Response must contain at leas one bike.");
Assert.IsNull(l_oBike.description);
Assert.That(l_oBike.bike, Is.Not.Null);
Assert.That(l_oBike.station, Is.Not.Null);
Assert.AreEqual("available", l_oBike.state);
Assert.That(l_oBike.gps, Is.Not.Null, "Gps position must never be empty.");
}
// Ensure that answer holds a valid bike.
var l_oBike = CopriCallsStatic.DeserializeResponse<BikesAvailableResponse>(INVALID_RESPONSE).bikes.FirstOrDefault().Value;
Assert.NotNull(l_oBike, "Response must contain at leas one bike.");
Assert.IsNull(l_oBike.description);
Assert.That(l_oBike.bike, Is.Not.Null);
Assert.That(l_oBike.station, Is.Not.Null);
Assert.AreEqual("available", l_oBike.state);
Assert.That(l_oBike.gps, Is.Not.Null, "Gps position must never be empty.");
}
[Test]
public void TestDeserializeObjectBikesAvailableValidResponse_NoBikeId()
{
const string VALID_RESPONSE = @"
[Test]
public void TestDeserializeObjectBikesAvailableValidResponse_NoBikeId()
{
const string VALID_RESPONSE = @"
{
""shareejson"": {
@ -105,20 +105,20 @@ namespace TestTINKLib.Fixtures.ObjectTests.Connector.Request
}
}";
// Ensure that answer holds a valid bike.
var l_oBike = CopriCallsStatic.DeserializeResponse<BikesAvailableResponse>(VALID_RESPONSE).bikes.FirstOrDefault().Value;
Assert.NotNull(l_oBike, "Response must contain at leas one bike.");
Assert.Greater(l_oBike.description.Length, 0, "Bike despcription must never be empty.");
Assert.That(l_oBike.bike, Is.Null);
Assert.That(l_oBike.station, Is.Not.Null);
Assert.AreEqual("available", l_oBike.state);
Assert.That(l_oBike.gps, Is.Not.Null, "Gps position must never be empty.");
}
// Ensure that answer holds a valid bike.
var l_oBike = CopriCallsStatic.DeserializeResponse<BikesAvailableResponse>(VALID_RESPONSE).bikes.FirstOrDefault().Value;
Assert.NotNull(l_oBike, "Response must contain at leas one bike.");
Assert.Greater(l_oBike.description.Length, 0, "Bike despcription must never be empty.");
Assert.That(l_oBike.bike, Is.Null);
Assert.That(l_oBike.station, Is.Not.Null);
Assert.AreEqual("available", l_oBike.state);
Assert.That(l_oBike.gps, Is.Not.Null, "Gps position must never be empty.");
}
[Test]
public void TestDeserializeObjectBikesOccupiedValidResponse()
{
const string VALID_RESPONSE = @"
[Test]
public void TestDeserializeObjectBikesOccupiedValidResponse()
{
const string VALID_RESPONSE = @"
{
""shareejson"": {
""response_state"": ""OK"",
@ -147,17 +147,17 @@ namespace TestTINKLib.Fixtures.ObjectTests.Connector.Request
}
}";
// Ensure that answer holds a valid bike.
var l_oBike = CopriCallsStatic.DeserializeResponse<BikesReservedOccupiedResponse>(VALID_RESPONSE).bikes_occupied.FirstOrDefault().Value;
Assert.NotNull(l_oBike, "Response must contain at leas one bike.");
Assert.Greater(l_oBike.description.Length, 0, "Bike despcription must never be empty.");
Assert.That(l_oBike.bike, Is.Not.Null);
Assert.That(l_oBike.station, Is.Not.Null);
Assert.Greater(l_oBike.state.Length, 0, "State info must never be null or empty.");
// Todo: Requested bikes do not have a gps position. What is about booked bikes?
// Assert.Greater(l_oBike.gps.Length, 0, "Gps position must never be empty.");
Assert.Greater(l_oBike.start_time.Length, 0, "Time when request/ booking was performed must never be null or empty.");
Assert.Greater(l_oBike.timeCode.Length, 0, "Booking code must never be null or empty.");
}
}
// Ensure that answer holds a valid bike.
var l_oBike = CopriCallsStatic.DeserializeResponse<BikesReservedOccupiedResponse>(VALID_RESPONSE).bikes_occupied.FirstOrDefault().Value;
Assert.NotNull(l_oBike, "Response must contain at leas one bike.");
Assert.Greater(l_oBike.description.Length, 0, "Bike despcription must never be empty.");
Assert.That(l_oBike.bike, Is.Not.Null);
Assert.That(l_oBike.station, Is.Not.Null);
Assert.Greater(l_oBike.state.Length, 0, "State info must never be null or empty.");
// Todo: Requested bikes do not have a gps position. What is about booked bikes?
// Assert.Greater(l_oBike.gps.Length, 0, "Gps position must never be empty.");
Assert.Greater(l_oBike.start_time.Length, 0, "Time when request/ booking was performed must never be null or empty.");
Assert.Greater(l_oBike.timeCode.Length, 0, "Booking code must never be null or empty.");
}
}
}

98
TestTINKLib/Fixtures/ObjectTests/Connector/TestCopriServerUriList.cs
View file

@ -5,61 +5,61 @@ using TINK.Model.Services.CopriApi.ServerUris;
namespace TestTINKLib.Fixtures.ObjectTests.Connector
{
[TestFixture]
public class TestCopriServerUriList
{
[Test]
public void TestConstruct()
{
var l_oUri = new CopriServerUriList();
[TestFixture]
public class TestCopriServerUriList
{
[Test]
public void TestConstruct()
{
var l_oUri = new CopriServerUriList();
Assert.Greater(l_oUri.Uris.Count, 0, "There must be at least one uri");
Assert.NotNull(l_oUri.ActiveUri);
}
Assert.Greater(l_oUri.Uris.Count, 0, "There must be at least one uri");
Assert.NotNull(l_oUri.ActiveUri);
}
[Test]
public void TestConstruct_AryStringString()
{
var l_oUri = new CopriServerUriList(
(new List<Uri> { new Uri("http://1.2.3.4"), new Uri("http://2.3.4.5"), new Uri("http://3.4.5.6") }).ToArray(),
new Uri("http://2.3.4.5"));
[Test]
public void TestConstruct_AryStringString()
{
var l_oUri = new CopriServerUriList(
(new List<Uri> { new Uri("http://1.2.3.4"), new Uri("http://2.3.4.5"), new Uri("http://3.4.5.6") }).ToArray(),
new Uri("http://2.3.4.5"));
Assert.AreEqual(3, l_oUri.Uris.Count);
Assert.AreEqual(new Uri("http://2.3.4.5"), l_oUri.ActiveUri);
}
Assert.AreEqual(3, l_oUri.Uris.Count);
Assert.AreEqual(new Uri("http://2.3.4.5"), l_oUri.ActiveUri);
}
[Test]
public void TestConstruct_AryStringString_NullList()
{
Assert.Throws<ArgumentException>(() => new CopriServerUriList(
null,
new Uri("http://2.3.4.5")));
}
[Test]
public void TestConstruct_AryStringString_NullList()
{
Assert.Throws<ArgumentException>(() => new CopriServerUriList(
null,
new Uri("http://2.3.4.5")));
}
[Test]
public void TestConstruct_AryStringString_InvalidList()
{
Assert.Throws<ArgumentException>(() => new CopriServerUriList(
(new List<Uri>()).ToArray(),
new Uri("http://2.3.4.5")));
}
[Test]
public void TestConstruct_AryStringString_InvalidList()
{
Assert.Throws<ArgumentException>(() => new CopriServerUriList(
(new List<Uri>()).ToArray(),
new Uri("http://2.3.4.5")));
}
[Test]
public void TestConstruct_AryStringString_InvalidActiveUri()
{
Assert.Throws<ArgumentException>(() => new CopriServerUriList(
(new List<Uri> { new Uri("http://1.2.3.4"), new Uri("http://2.3.4.5"), new Uri("http://3.4.5.6") }).ToArray(),
new Uri("http://9.9.9.9")));
}
[Test]
public void TestConstruct_AryStringString_InvalidActiveUri()
{
Assert.Throws<ArgumentException>(() => new CopriServerUriList(
(new List<Uri> { new Uri("http://1.2.3.4"), new Uri("http://2.3.4.5"), new Uri("http://3.4.5.6") }).ToArray(),
new Uri("http://9.9.9.9")));
}
[Test]
public void TestDefaultActiveUri()
{
Assert.AreEqual(
"https://shareeapp-primary.copri.eu/APIjsonserver",
CopriServerUriList.DefaultActiveUri.AbsoluteUri,
"In production environment, server address must always be app.tink-konstanz.de/APIjsonserver.");
}
}
[Test]
public void TestDefaultActiveUri()
{
Assert.AreEqual(
"https://shareeapp-primary.copri.eu/APIjsonserver",
CopriServerUriList.DefaultActiveUri.AbsoluteUri,
"In production environment, server address must always be app.tink-konstanz.de/APIjsonserver.");
}
}
}

150
TestTINKLib/Fixtures/ObjectTests/Connector/TestFilter.cs
View file

@ -9,94 +9,94 @@ using TINK.Repository;
namespace TestTINKLib.Fixtures.ObjectTests.Connector
{
/// <summary> Tests filter object. </summary>
[TestFixture]
public class TestFilter
{
/// <summary> Tests all stations. </summary>
[Test]
public void TestGetStationsAll()
{
var connector = new ConnectorCache(
new AppContextInfo("MyMerchId", "MyApp", new Version(1, 2)),
null /*UI language */,
string.Empty,
string.Empty,
new CopriCallsMemory001());
/// <summary> Tests filter object. </summary>
[TestFixture]
public class TestFilter
{
/// <summary> Tests all stations. </summary>
[Test]
public void TestGetStationsAll()
{
var connector = new ConnectorCache(
new AppContextInfo("MyMerchId", "MyApp", new Version(1, 2)),
null /*UI language */,
string.Empty,
string.Empty,
new CopriCallsMemory001());
var filter = new FilteredConnector(new List<string> { FilterHelper.CARGOBIKE, FilterHelper.CITYBIKE }, connector);
var stations = filter.Query.GetBikesAndStationsAsync().Result.Response;
Assert.AreEqual(41, stations.StationsAll.Count()); // Count of stations was 9 before switching to data provider CopriCallsMemory(CopriCallsMemory.SampleSets.Set2, 1)
var filter = new FilteredConnector(new List<string> { FilterHelper.CARGOBIKE, FilterHelper.CITYBIKE }, connector);
var stations = filter.Query.GetBikesAndStationsAsync().Result.Response;
Assert.AreEqual(41, stations.StationsAll.Count()); // Count of stations was 9 before switching to data provider CopriCallsMemory(CopriCallsMemory.SampleSets.Set2, 1)
filter = new FilteredConnector(new List<string> { FilterHelper.CARGOBIKE }, connector);
stations = filter.Query.GetBikesAndStationsAsync().Result.Response;
Assert.AreEqual(27, stations.StationsAll.Count());
filter = new FilteredConnector(new List<string> { FilterHelper.CARGOBIKE }, connector);
stations = filter.Query.GetBikesAndStationsAsync().Result.Response;
Assert.AreEqual(27, stations.StationsAll.Count());
filter = new FilteredConnector(new List<string> { FilterHelper.CITYBIKE }, connector);
stations = filter.Query.GetBikesAndStationsAsync().Result.Response;
Assert.AreEqual(21, stations.StationsAll.Count());
filter = new FilteredConnector(new List<string> { FilterHelper.CITYBIKE }, connector);
stations = filter.Query.GetBikesAndStationsAsync().Result.Response;
Assert.AreEqual(21, stations.StationsAll.Count());
filter = new FilteredConnector(new List<string> { "AGroupNamedNonsensDoesNotExist" }, connector);
stations = filter.Query.GetBikesAndStationsAsync().Result.Response;
Assert.AreEqual(0, stations.StationsAll.Count());
filter = new FilteredConnector(new List<string> { "AGroupNamedNonsensDoesNotExist" }, connector);
stations = filter.Query.GetBikesAndStationsAsync().Result.Response;
Assert.AreEqual(0, stations.StationsAll.Count());
filter = new FilteredConnector(new List<string>(), connector);
stations = filter.Query.GetBikesAndStationsAsync().Result.Response;
Assert.AreEqual(41, stations.StationsAll.Count());
filter = new FilteredConnector(new List<string>(), connector);
stations = filter.Query.GetBikesAndStationsAsync().Result.Response;
Assert.AreEqual(41, stations.StationsAll.Count());
filter = new FilteredConnector(null, connector);
stations = filter.Query.GetBikesAndStationsAsync().Result.Response;
Assert.AreEqual(41, stations.StationsAll.Count(), "Null means filter none.");
}
filter = new FilteredConnector(null, connector);
stations = filter.Query.GetBikesAndStationsAsync().Result.Response;
Assert.AreEqual(41, stations.StationsAll.Count(), "Null means filter none.");
}
/// <summary> Tests all stations. </summary>
[Test]
public void TestGetBikesAll()
{
var l_oConnector = new ConnectorCache(
new AppContextInfo("MyMerchId", "MyApp", new Version(1, 2)),
null /*UI language */,
string.Empty,
string.Empty,
new CopriCallsMemory001());
/// <summary> Tests all stations. </summary>
[Test]
public void TestGetBikesAll()
{
var l_oConnector = new ConnectorCache(
new AppContextInfo("MyMerchId", "MyApp", new Version(1, 2)),
null /*UI language */,
string.Empty,
string.Empty,
new CopriCallsMemory001());
var l_oFilter = new FilteredConnector(new List<string> { FilterHelper.CARGOBIKE, FilterHelper.CITYBIKE }, l_oConnector);
var l_oBikes = l_oFilter.Query.GetBikesAsync().Result.Response;
Assert.AreEqual(8, l_oBikes.Count()); // Count of stations was 12 CopriCallsMemory(CopriCallsMemory.SampleSets.Set2, 1)
var l_oFilter = new FilteredConnector(new List<string> { FilterHelper.CARGOBIKE, FilterHelper.CITYBIKE }, l_oConnector);
var l_oBikes = l_oFilter.Query.GetBikesAsync().Result.Response;
Assert.AreEqual(8, l_oBikes.Count()); // Count of stations was 12 CopriCallsMemory(CopriCallsMemory.SampleSets.Set2, 1)
l_oFilter = new FilteredConnector(new List<string> { FilterHelper.CARGOBIKE }, l_oConnector);
l_oBikes = l_oFilter.Query.GetBikesAsync().Result.Response;
Assert.AreEqual(3, l_oBikes.Count()); // Was 11
l_oFilter = new FilteredConnector(new List<string> { FilterHelper.CARGOBIKE }, l_oConnector);
l_oBikes = l_oFilter.Query.GetBikesAsync().Result.Response;
Assert.AreEqual(3, l_oBikes.Count()); // Was 11
l_oFilter = new FilteredConnector(new List<string> { FilterHelper.CITYBIKE }, l_oConnector);
l_oBikes = l_oFilter.Query.GetBikesAsync().Result.Response;
Assert.AreEqual(5, l_oBikes.Count()); // Was 1
l_oFilter = new FilteredConnector(new List<string> { FilterHelper.CITYBIKE }, l_oConnector);
l_oBikes = l_oFilter.Query.GetBikesAsync().Result.Response;
Assert.AreEqual(5, l_oBikes.Count()); // Was 1
l_oFilter = new FilteredConnector(new List<string> { "AGroupNamedNonsensDoesNotExist" }, l_oConnector);
l_oBikes = l_oFilter.Query.GetBikesAsync().Result.Response;
Assert.AreEqual(0, l_oBikes.Count());
l_oFilter = new FilteredConnector(new List<string> { "AGroupNamedNonsensDoesNotExist" }, l_oConnector);
l_oBikes = l_oFilter.Query.GetBikesAsync().Result.Response;
Assert.AreEqual(0, l_oBikes.Count());
l_oFilter = new FilteredConnector(new List<string>(), l_oConnector);
l_oBikes = l_oFilter.Query.GetBikesAsync().Result.Response;
Assert.AreEqual(8, l_oBikes.Count(), "List with zero element means filter all."); // Was 12
l_oFilter = new FilteredConnector(new List<string>(), l_oConnector);
l_oBikes = l_oFilter.Query.GetBikesAsync().Result.Response;
Assert.AreEqual(8, l_oBikes.Count(), "List with zero element means filter all."); // Was 12
l_oFilter = new FilteredConnector(null, l_oConnector);
l_oBikes = l_oFilter.Query.GetBikesAsync().Result.Response;
Assert.AreEqual(8, l_oBikes.Count(), "Null means filter none.");
}
l_oFilter = new FilteredConnector(null, l_oConnector);
l_oBikes = l_oFilter.Query.GetBikesAsync().Result.Response;
Assert.AreEqual(8, l_oBikes.Count(), "Null means filter none.");
}
[Test]
public void TestIsConnected()
{
var connector = Substitute.For<IConnector>();
connector.IsConnected.Returns(true);
Assert.IsTrue(new FilteredConnector(new List<string>(), connector).IsConnected);
var dummy = connector.Received().IsConnected;
[Test]
public void TestIsConnected()
{
var connector = Substitute.For<IConnector>();
connector.IsConnected.Returns(true);
Assert.IsTrue(new FilteredConnector(new List<string>(), connector).IsConnected);
var dummy = connector.Received().IsConnected;
connector = Substitute.For<IConnector>();
connector.IsConnected.Returns(false);
Assert.IsFalse(new FilteredConnector(new List<string>(), connector).IsConnected);
dummy = connector.Received().IsConnected;
}
}
connector = Substitute.For<IConnector>();
connector.IsConnected.Returns(false);
Assert.IsFalse(new FilteredConnector(new List<string>(), connector).IsConnected);
dummy = connector.Received().IsConnected;
}
}
}