public void GetEntitiesWithoutLoginOK()
{
List <Country> fakeCountries = new List <Country>
{
new Country {
Iso = "BEL", Iso2 = "BE", Name = "Belgium"
},
new Country {
Iso = "ITA", Iso2 = "IT", Name = "Italy"
}
};
string content = JsonConvert.SerializeObject(fakeCountries, new JsonSerializerSettings
{
DateTimeZoneHandling = DateTimeZoneHandling.Utc
});
Mock <HttpWebRequest> mockWebRequest = FakeWebRequest.CreateRequestWithResponse(content);
mockWebRequest.SetupSet(r => r.Method = "GET").Verifiable();
List <Country> countries = request.GetEntityList <Country>().GetAwaiter().GetResult();
UriBuilder uriBuilder = new UriBuilder("https://api.aproplan.com/rest/countries");
string expectedUrl = AproplanApiUtility.BuildRestUrl(request.ApiRootUrl, "countries", request.ApiVersion, request.RequesterId);
Assert.AreEqual(expectedUrl, FakeWebRequest.Instance.UriCalled[0].ToString());
Assert.AreEqual(2, countries.Count);
Assert.AreEqual(fakeCountries[0].Id, countries[0].Id);
Assert.AreEqual(fakeCountries[1].Id, countries[1].Id);
mockWebRequest.Verify();
}
public void GetEntitiesWithoutLoginNOK()
{
string content = "";
Mock <HttpWebRequest> mockWebRequest = FakeWebRequest.CreateRequestWithResponse(content);
mockWebRequest.SetupSet(r => r.Method = "GET").Verifiable();
try
{
request.GetEntityList <Meeting>().GetAwaiter().GetResult();
Assert.Fail("An exception should occur");
}
catch (Exception ex)
{
ApiException apiException = ex as ApiException;
if (apiException != null)
{
Assert.AreEqual("Cannot call API without to be connected", apiException.Message);
Assert.AreEqual("NOT_CONNECTED", apiException.Code);
}
else
{
Assert.Fail("Wrong exception thrown", ex);
}
}
}
public void GetEntityIdsOK()
{
var projectId = Guid.NewGuid();
List <Guid> expectedGuid = new List <Guid> {
Guid.NewGuid(), Guid.NewGuid()
};
string content = JsonConvert.SerializeObject(expectedGuid, new JsonSerializerSettings
{
DateTimeZoneHandling = DateTimeZoneHandling.Utc
});
Mock <HttpWebRequest> mockWebRequest = FakeWebRequest.CreateRequestWithResponse(content);
mockWebRequest.SetupSet(r => r.Method = "GET").Verifiable();
var id = Guid.NewGuid();
Filter filter = Filter.IsNotNull("Subject");
List <Guid> guids = request.GetEntityIds <Note>(projectId, filter).GetAwaiter().GetResult();
string expectedUrl = AproplanApiUtility.BuildRestUrl(request.ApiRootUrl, "notesids", request.ApiVersion, request.RequesterId, request.TokenInfo.Token);
expectedUrl += "&filter=" + AproplanApiUtility.EncodeUrl(filter.ToString()) + "&projectid=" + projectId;
Assert.AreEqual(expectedUrl, FakeWebRequest.Instance.UriCalled[0].ToString());
Assert.AreEqual(expectedGuid.Count, 2);
Assert.AreEqual(expectedGuid[0], guids[0]);
Assert.AreEqual(expectedGuid[1], guids[1]);
mockWebRequest.Verify();
}
public void GetEntityByIdsWithSeveralValOK()
{
var projectId = Guid.NewGuid();
List <Note> notes = NoteUtility.GetFakeSimpleNotes();
string content = JsonConvert.SerializeObject(notes, new JsonSerializerSettings
{
DateTimeZoneHandling = DateTimeZoneHandling.Utc
});
Mock <HttpWebRequest> mockWebRequest = FakeWebRequest.CreateRequestWithResponse(content);
mockWebRequest.SetupSet(r => r.Method = "GET").Verifiable();
Guid[] ids = notes.Select((n => n.Id)).ToArray();
List <Note> resultNotes = request.GetEntityByIds <Note>(ids, projectId).GetAwaiter().GetResult();
string filter = Filter.In("Id", ids).ToString();
string expectedUrl = AproplanApiUtility.BuildRestUrl(request.ApiRootUrl, "notes", request.ApiVersion, request.RequesterId, request.TokenInfo.Token);
expectedUrl += "&filter=" + AproplanApiUtility.EncodeUrl(filter) + "&projectid=" + projectId;
Assert.AreEqual(expectedUrl, FakeWebRequest.Instance.UriCalled[0].ToString());
Assert.AreEqual(notes.Count, resultNotes.Count);
for (int i = 0; i < notes.Count; i++)
{
var expectedNote = notes[i];
Assert.AreEqual(expectedNote.Id, resultNotes[i].Id);
}
mockWebRequest.Verify();
}
public void GetEntityByIdOK()
{
var projectId = Guid.NewGuid();
Note note = NoteUtility.GetFakeSimpleNotes()[0];
string content = JsonConvert.SerializeObject(new List <Note> {
note
}, new JsonSerializerSettings
{
DateTimeZoneHandling = DateTimeZoneHandling.Utc
});
Mock <HttpWebRequest> mockWebRequest = FakeWebRequest.CreateRequestWithResponse(content);
mockWebRequest.SetupSet(r => r.Method = "GET").Verifiable();
Note resultNote = request.GetEntityById <Note>(note.Id, projectId).GetAwaiter().GetResult();
string filter = string.Format("Filter.Eq(Id,{0})", note.Id);
string expectedUrl = AproplanApiUtility.BuildRestUrl(request.ApiRootUrl, "notes", request.ApiVersion, request.RequesterId, request.TokenInfo.Token);
expectedUrl += "&filter=" + AproplanApiUtility.EncodeUrl(filter) + "&projectid=" + projectId;
Assert.AreEqual(expectedUrl, FakeWebRequest.Instance.UriCalled[0].ToString());
Assert.AreEqual(note.Id, resultNote.Id);
mockWebRequest.Verify();
}
public void LoginWithBadCredentialsReturnsUser()
{
WebRequest.RegisterPrefix(request.ApiRootUrl, FakeWebRequest.Instance);
Mock <HttpWebRequest> mockWebRequest = FakeWebRequest.CreateRequestWithResponse("");
mockWebRequest.SetupSet(r => r.Method = "POST").Verifiable();
mockWebRequest.SetupSet(r => r.ContentType = "application/json").Verifiable();
try
{
User user = request.Login("*****@*****.**", "aproplan").GetAwaiter().GetResult();
Assert.Fail("No exception thrown");
}
catch (Exception ex)
{
ApiException apiException = ex as ApiException;
if (apiException != null)
{
Assert.AreEqual("Your login or password is not correct", apiException.Message);
Assert.AreEqual("INVALID_CREDENTIALS", apiException.Code);
Assert.AreEqual(401, apiException.ReturnCode);
}
else
{
Assert.Fail("Wrong exception thrown");
}
}
}
public void LoginWithGoodCredentialsReturnsUser()
{
dynamic json = new
{
UserInfo = UserUtility.CreateUser("*****@*****.**", "John Smith"),
Token = Guid.NewGuid(),
ValidityStart = DateTime.Now.ToUniversalTime().ToString("o"),
ValidityLimit = DateTime.Now.ToUniversalTime().AddMinutes(10).ToString("o")
};
string content = JsonConvert.SerializeObject(json);
Mock <HttpWebRequest> mockWebRequest = FakeWebRequest.CreateRequestWithResponse(content);
mockWebRequest.SetupSet(r => r.Method = "POST").Verifiable();
mockWebRequest.SetupSet(r => r.ContentType = "application/json").Verifiable();
User user = request.Login("*****@*****.**", "aproplan").GetAwaiter().GetResult();
UriBuilder uriBuilder = new UriBuilder("https://api.aproplan.com/rest/simpleloginsecure");
string expectedUrl = AproplanApiUtility.BuildRestUrl(request.ApiRootUrl, "simpleloginsecure", request.ApiVersion, request.RequesterId);
dynamic requestData = AproplanApiUtility.GetRequestData <ExpandoObject>(mockWebRequest);
Assert.AreEqual(expectedUrl, FakeWebRequest.Instance.UriCalled[0].ToString());
Assert.AreEqual(json.UserInfo.Id, user.Id);
Assert.AreEqual("*****@*****.**", requestData.alias);
Assert.AreEqual("aproplan", requestData.pass);
Assert.AreEqual(json.UserInfo.Id, request.CurrentUser.Id);
Assert.AreEqual(DateTime.Parse(json.ValidityStart).ToLocalTime(), request.TokenInfo.ValidityStart);
Assert.AreEqual(DateTime.Parse(json.ValidityLimit).ToLocalTime(), request.TokenInfo.ValidityLimit);
mockWebRequest.Verify();
}
public void RenewTokenValid()
{
DateTime currentTokenStart = DateTime.Now.AddMinutes(-6);
AproplanApiUtility.FakeLogin(request, currentTokenStart);
Guid oldToken = request.TokenInfo.Token;
dynamic json = new
{
Token = Guid.NewGuid(),
ValidityStart = DateTime.Now.ToUniversalTime().ToString("o"),
ValidityLimit = DateTime.Now.ToUniversalTime().AddMinutes(10).ToString("o")
};
string content = JsonConvert.SerializeObject(json);
Mock <HttpWebRequest> mockWebRequest = FakeWebRequest.CreateRequestWithResponse(content);
mockWebRequest.SetupSet(r => r.Method = "GET").Verifiable();
var tokenInfo = request.RenewToken().GetAwaiter().GetResult();
string expectedUrl = AproplanApiUtility.BuildRestUrl(request.ApiRootUrl, "renewtoken", request.ApiVersion, request.RequesterId, oldToken);
Assert.AreEqual(expectedUrl, FakeWebRequest.Instance.UriCalled[1].ToString());
Assert.AreEqual(json.Token, request.TokenInfo.Token);
Assert.AreEqual(DateTime.Parse(json.ValidityStart).ToLocalTime(), request.TokenInfo.ValidityStart);
Assert.AreEqual(DateTime.Parse(json.ValidityLimit).ToLocalTime(), request.TokenInfo.ValidityLimit);
}
public void GetEntityByIdWithoutResultOK()
{
string content = JsonConvert.SerializeObject(new List <Note>(), new JsonSerializerSettings
{
DateTimeZoneHandling = DateTimeZoneHandling.Utc
});
Mock <HttpWebRequest> mockWebRequest = FakeWebRequest.CreateRequestWithResponse(content);
mockWebRequest.SetupSet(r => r.Method = "GET").Verifiable();
var id = Guid.NewGuid();
Note resultNote = request.GetEntityById <Note>(id).GetAwaiter().GetResult();
Assert.IsNull(resultNote);
mockWebRequest.Verify();
}
public void RenewTokenWhileInvalidPeriod()
{
DateTime currentTokenStart = DateTime.Now.AddMinutes(-11);
AproplanApiUtility.FakeLogin(request, currentTokenStart);
Guid oldToken = request.TokenInfo.Token;
dynamic json = new
{
Token = Guid.NewGuid(),
ValidityStart = DateTime.Now.ToUniversalTime().ToString("o"),
ValidityLimit = DateTime.Now.ToUniversalTime().AddMinutes(10).ToString("o")
};
string content = JsonConvert.SerializeObject(json);
Mock <HttpWebRequest> mockWebRequest = FakeWebRequest.CreateRequestWithResponse(content);
mockWebRequest.SetupSet(r => r.Method = "GET").Verifiable();
try
{
var tokenInfo = request.RenewToken().GetAwaiter().GetResult();
Assert.Fail("An exception should be thrown");
}
catch (Exception ex)
{
ApiException apiException = ex as ApiException;
if (apiException != null)
{
Assert.AreEqual("Your current token is invalid, use login method instead", apiException.Message);
Assert.AreEqual("TOKEN_EXPIRED", apiException.Code);
}
else
{
Assert.Fail("Wrong exception thrown");
}
}
}
public void GetEntityByIdsWithQueryParamsOK()
{
var projectId = Guid.NewGuid();
Note note = NoteUtility.GetFakeSimpleNotes()[0];
string content = JsonConvert.SerializeObject(new List <Note> {
note
}, new JsonSerializerSettings
{
DateTimeZoneHandling = DateTimeZoneHandling.Utc
});
Mock <HttpWebRequest> mockWebRequest = FakeWebRequest.CreateRequestWithResponse(content);
mockWebRequest.SetupSet(r => r.Method = "GET").Verifiable();
Guid[] ids = new Guid[] { note.Id };
List <Note> resultNotes = request.GetEntityByIds <Note>(ids, projectId, null, new Dictionary <string, string> {
{ "testparam", "john" }
}).GetAwaiter().GetResult();
string filter = Filter.Eq("Id", note.Id).ToString();
string expectedUrl = AproplanApiUtility.BuildRestUrl(request.ApiRootUrl, "notes", request.ApiVersion, request.RequesterId, request.TokenInfo.Token);
expectedUrl += "&filter=" + AproplanApiUtility.EncodeUrl(filter) + "&projectid=" + projectId + "&testparam=john";
Assert.AreEqual(expectedUrl, FakeWebRequest.Instance.UriCalled[0].ToString());
Assert.AreEqual(1, resultNotes.Count);
Assert.AreEqual(note.Id, resultNotes[0].Id);
mockWebRequest.Verify();
}
