public async Task TestGet_CheckProperties()
{
var dependentType = new DependentType
{
Name = "name",
DependentTypeId = 1,
SevisDependentTypeCode = "code"
};
context.DependentTypes.Add(dependentType);
Action <PagedQueryResults <DependentTypeDTO> > tester = (results) =>
{
Assert.AreEqual(1, results.Total);
Assert.AreEqual(1, results.Results.Count);
var firstResult = results.Results.First();
Assert.AreEqual(dependentType.DependentTypeId, firstResult.Id);
Assert.AreEqual(dependentType.Name, firstResult.Name);
Assert.AreEqual(dependentType.SevisDependentTypeCode, firstResult.SevisDependentTypeCode);
};
var defaultSorter = new ExpressionSorter <DependentTypeDTO>(x => x.Id, SortDirection.Ascending);
var queryOperator = new QueryableOperator <DependentTypeDTO>(0, 10, defaultSorter);
var serviceResults = service.Get(queryOperator);
var serviceResultsAsync = await service.GetAsync(queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public void TestToQueryableOperator_ToManyProperties()
{
var start = 0;
var limit = 10;
var defaultSorter = new ExpressionSorter <PagingQueryBindingModelTestClass>(x => x.A, SortDirection.Ascending);
var sorter = new ExpressionSorter <PagingQueryBindingModelTestClass>(x => x.A, SortDirection.Ascending);
var model = new PagingQueryBindingModel <PagingQueryBindingModelTestClass>
{
Start = start,
Limit = limit
};
var keyword = "hello";
model.Keyword.Add(keyword);
var queryOperator = model.ToQueryableOperator(defaultSorter,
x => x.A,
x => x.B,
x => x.C,
x => x.D,
x => x.E,
x => x.F,
x => x.G,
x => x.H,
x => x.I,
x => x.J,
x => x.K);
}
public async Task TestGetEvaluations_Filter()
{
var evaluation1 = new PersonEvaluationNote
{
EvaluationNoteId = 1
};
var evaluation2 = new PersonEvaluationNote
{
EvaluationNoteId = 2
};
context.PersonEvaluationNotes.Add(evaluation1);
context.PersonEvaluationNotes.Add(evaluation2);
Action <PagedQueryResults <EvaluationNoteDTO> > tester = (results) =>
{
Assert.AreEqual(1, results.Total);
Assert.AreEqual(1, results.Results.Count);
var firstResult = results.Results.First();
Assert.AreEqual(evaluation1.EvaluationNoteId, firstResult.EvaluationNoteId);
};
var defaultSorter = new ExpressionSorter <EvaluationNoteDTO>(x => x.EvaluationNoteId, SortDirection.Descending);
var queryOperator = new QueryableOperator <EvaluationNoteDTO>(0, 1, defaultSorter);
queryOperator.Filters.Add(new ExpressionFilter <EvaluationNoteDTO>(x => x.EvaluationNoteId, ComparisonType.Equal, evaluation1.EvaluationNoteId));
var serviceResults = service.Get(queryOperator);
var serviceResultsAsync = await service.GetAsync(queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public async Task TestGet_CheckProperties()
{
var participantStatus = new ParticipantStatus
{
Status = ParticipantStatus.Active.Value,
ParticipantStatusId = ParticipantStatus.Active.Id,
};
context.ParticipantStatuses.Add(participantStatus);
Action <PagedQueryResults <ParticipantStatusDTO> > tester = (results) =>
{
Assert.AreEqual(1, results.Total);
Assert.AreEqual(1, results.Results.Count);
var firstResult = results.Results.First();
Assert.AreEqual(participantStatus.ParticipantStatusId, firstResult.Id);
Assert.AreEqual(participantStatus.Status, firstResult.Name);
};
var defaultSorter = new ExpressionSorter <ParticipantStatusDTO>(x => x.Id, SortDirection.Ascending);
var queryOperator = new QueryableOperator <ParticipantStatusDTO>(0, 10, defaultSorter);
var serviceResults = service.Get(queryOperator);
var serviceResultsAsync = await service.GetAsync(queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public async Task TestGetFocusCategoriesByProgramId_Filter()
{
var program = new Program
{
ProgramId = 1
};
var focus1 = new Focus
{
FocusId = 1,
FocusName = "focus1",
};
var category1 = new Category
{
CategoryId = 1,
CategoryName = "cat1",
Focus = focus1,
FocusId = focus1.FocusId,
};
var focus2 = new Focus
{
FocusId = 2,
FocusName = "focus2",
};
var category2 = new Category
{
CategoryId = 2,
CategoryName = "cat2",
Focus = focus2,
FocusId = focus2.FocusId,
};
program.Categories.Add(category1);
program.Categories.Add(category2);
context.Programs.Add(program);
context.Foci.Add(focus1);
context.Categories.Add(category1);
context.Foci.Add(focus2);
context.Categories.Add(category2);
Action <PagedQueryResults <FocusCategoryDTO> > tester = (results) =>
{
Assert.AreEqual(1, results.Total);
Assert.AreEqual(1, results.Results.Count);
var firstResult = results.Results.First();
Assert.AreEqual(category2.FocusId, firstResult.Id);
};
var defaultSorter = new ExpressionSorter <FocusCategoryDTO>(x => x.Name, SortDirection.Descending);
var queryOperator = new QueryableOperator <FocusCategoryDTO>(0, 10, defaultSorter);
queryOperator.Filters.Add(new ExpressionFilter <FocusCategoryDTO>(x => x.Name, ComparisonType.Equal, category2.CategoryName));
var serviceResults = service.GetFocusCategoriesByProgramId(program.ProgramId, queryOperator);
var serviceResultsAsync = await service.GetFocusCategoriesByProgramIdAsync(program.ProgramId, queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public async Task TestGetEvaluations_CheckProperties()
{
var evaluation = new PersonEvaluationNote
{
EvaluationNoteId = 1,
EvaluationNote = "Test evaluation note"
};
context.PersonEvaluationNotes.Add(evaluation);
Action <PagedQueryResults <EvaluationNoteDTO> > tester = (results) =>
{
Assert.AreEqual(1, results.Total);
Assert.AreEqual(1, results.Results.Count);
var firstResult = results.Results.First();
Assert.AreEqual(evaluation.EvaluationNoteId, firstResult.EvaluationNoteId);
Assert.AreEqual(evaluation.EvaluationNote, firstResult.EvaluationNote);
};
var defaultSorter = new ExpressionSorter <EvaluationNoteDTO>(x => x.EvaluationNoteId, SortDirection.Ascending);
var queryOperator = new QueryableOperator <EvaluationNoteDTO>(0, 10, defaultSorter);
var serviceResults = service.Get(queryOperator);
var serviceResultsAsync = await service.GetAsync(queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public async Task TestGet_CheckProperties()
{
var maritalStatus = new MaritalStatus
{
MaritalStatusId = 1,
Status = "Single"
};
context.MaritalStatuses.Add(maritalStatus);
Action <PagedQueryResults <SimpleLookupDTO> > tester = (results) =>
{
Assert.AreEqual(1, results.Total);
Assert.AreEqual(1, results.Results.Count);
var firstResult = results.Results.First();
Assert.AreEqual(maritalStatus.MaritalStatusId, firstResult.Id);
Assert.AreEqual(maritalStatus.Description, firstResult.Value);
};
var defaultSorter = new ExpressionSorter <SimpleLookupDTO>(x => x.Id, SortDirection.Ascending);
var queryOperator = new QueryableOperator <SimpleLookupDTO>(0, 10, defaultSorter);
var serviceResults = service.Get(queryOperator);
var serviceResultsAsync = await service.GetAsync(queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public async Task TestGetFocusCategoriesByOfficeId_Sort()
{
var office = new Organization
{
OrganizationId = 1
};
var focus1 = new Focus
{
FocusId = 1,
FocusName = "focus1",
Office = office,
OfficeId = office.OrganizationId
};
var focus2 = new Focus
{
FocusId = 2,
FocusName = "focus2",
Office = office,
OfficeId = office.OrganizationId
};
var category1 = new Category
{
CategoryId = 1,
CategoryName = "cat1",
Focus = focus1,
FocusId = focus1.FocusId,
};
var category2 = new Category
{
CategoryId = 2,
CategoryName = "cat2",
Focus = focus2,
FocusId = focus2.FocusId,
};
context.Organizations.Add(office);
context.Foci.Add(focus2);
context.Foci.Add(focus1);
context.Categories.Add(category2);
context.Categories.Add(category1);
Action <PagedQueryResults <FocusCategoryDTO> > tester = (results) =>
{
Assert.AreEqual(2, results.Total);
Assert.AreEqual(2, results.Results.Count);
Assert.AreEqual(category2.CategoryId, results.Results.First().Id);
Assert.AreEqual(category1.CategoryId, results.Results.Last().Id);
};
var defaultSorter = new ExpressionSorter <FocusCategoryDTO>(x => x.Name, SortDirection.Descending);
var queryOperator = new QueryableOperator <FocusCategoryDTO>(0, 10, defaultSorter);
queryOperator.Sorters.Add(new ExpressionSorter <FocusCategoryDTO>(x => x.FocusName, SortDirection.Descending));
var serviceResults = service.GetFocusCategoriesByOfficeId(office.OrganizationId, queryOperator);
var serviceResultsAsync = await service.GetFocusCategoriesByOfficeIdAsync(office.OrganizationId, queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public async Task TestGetUsers_CheckProperties()
{
var user1 = new UserAccount
{
AdGuid = Guid.NewGuid(),
DisplayName = "display1",
EmailAddress = "email1",
FirstName = "first1",
LastName = "last1",
PrincipalId = 1,
};
context.UserAccounts.Add(user1);
Action <PagedQueryResults <UserDTO> > tester = (testResults) =>
{
Assert.AreEqual(1, testResults.Total);
Assert.AreEqual(1, testResults.Results.Count);
var firstResult = testResults.Results.First();
Assert.AreEqual(user1.AdGuid, firstResult.AdGuid);
Assert.AreEqual(user1.DisplayName, firstResult.DisplayName);
Assert.AreEqual(user1.EmailAddress, firstResult.Email);
Assert.AreEqual(user1.FirstName, firstResult.FirstName);
Assert.AreEqual(user1.PrincipalId, firstResult.PrincipalId);
};
var defaultSorter = new ExpressionSorter <UserDTO>(x => x.AdGuid, SortDirection.Ascending);
var queryOperator = new QueryableOperator <UserDTO>(0, 10, defaultSorter);
var results = service.GetUsers(queryOperator);
var resultsAsync = await service.GetUsersAsync(queryOperator);
tester(results);
tester(resultsAsync);
}
public async Task TestGetProjectStati_DefaultSort()
{
var instance1 = new LookupServiceTestDTO
{
Id = 1,
Value = "A"
};
var instance2 = new LookupServiceTestDTO
{
Id = 2,
Value = "B"
};
var list = new List <LookupServiceTestDTO> {
instance1, instance2
};
list = list.OrderBy(x => x.Value).ToList();
list.ForEach(x => context.LookupServiceTestDTOs.Add(x));
Action <PagedQueryResults <LookupServiceTestDTO> > tester = (results) =>
{
Assert.AreEqual(2, results.Total);
Assert.AreEqual(2, results.Results.Count);
Assert.AreEqual(instance2.Id, results.Results.First().Id);
Assert.AreEqual(instance1.Id, results.Results.Last().Id);
};
var defaultSorter = new ExpressionSorter <LookupServiceTestDTO>(x => x.Value, SortDirection.Descending);
var queryOperator = new QueryableOperator <LookupServiceTestDTO>(0, 10, defaultSorter);
var serviceResults = service.Get(queryOperator);
var serviceResultsAsync = await service.GetAsync(queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public async Task TestGet_CheckProperties()
{
var gender = new Gender
{
GenderId = 1,
GenderName = "genderName"
};
context.Genders.Add(gender);
Action <PagedQueryResults <SimpleLookupDTO> > tester = (results) =>
{
Assert.AreEqual(1, results.Total);
Assert.AreEqual(1, results.Results.Count);
var firstResult = results.Results.First();
Assert.AreEqual(gender.GenderId, firstResult.Id);
Assert.AreEqual(gender.GenderName, firstResult.Value);
};
var defaultSorter = new ExpressionSorter <SimpleLookupDTO>(x => x.Id, SortDirection.Ascending);
var queryOperator = new QueryableOperator <SimpleLookupDTO>(0, 10, defaultSorter);
var serviceResults = service.Get(queryOperator);
var serviceResultsAsync = await service.GetAsync(queryOperator);
}
public async Task TestGetOrganizationTypes_CheckProperties()
{
var orgType = new OrganizationType
{
OrganizationTypeId = 1,
OrganizationTypeName = "theme"
};
context.OrganizationTypes.Add(orgType);
Action <PagedQueryResults <OrganizationTypeDTO> > tester = (results) =>
{
Assert.AreEqual(1, results.Total);
Assert.AreEqual(1, results.Results.Count);
var firstResult = results.Results.First();
Assert.AreEqual(orgType.OrganizationTypeId, firstResult.Id);
Assert.AreEqual(orgType.OrganizationTypeName, firstResult.Name);
};
var defaultSorter = new ExpressionSorter <OrganizationTypeDTO>(x => x.Id, SortDirection.Ascending);
var queryOperator = new QueryableOperator <OrganizationTypeDTO>(0, 10, defaultSorter);
var serviceResults = service.Get(queryOperator);
var serviceResultsAsync = await service.GetAsync(queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public async Task TestGetJustificationObjectivesByOfficeId_Sort()
{
var office = new Organization
{
OrganizationId = 1
};
var justification1 = new Justification
{
JustificationId = 1,
JustificationName = "just1",
Office = office,
OfficeId = office.OrganizationId
};
var justification2 = new Justification
{
JustificationId = 2,
JustificationName = "just2",
Office = office,
OfficeId = office.OrganizationId
};
var objective1 = new Objective
{
Justification = justification1,
JustificationId = justification1.JustificationId,
ObjectiveId = 1,
ObjectiveName = "obj1",
};
var objective2 = new Objective
{
Justification = justification1,
JustificationId = justification1.JustificationId,
ObjectiveId = 2,
ObjectiveName = "obj2",
};
context.Organizations.Add(office);
context.Objectives.Add(objective1);
context.Objectives.Add(objective2);
context.Justifications.Add(justification1);
context.Justifications.Add(justification2);
Action <PagedQueryResults <JustificationObjectiveDTO> > tester = (results) =>
{
Assert.AreEqual(2, results.Total);
Assert.AreEqual(2, results.Results.Count);
Assert.AreEqual(objective1.ObjectiveId, results.Results.First().Id);
Assert.AreEqual(objective2.ObjectiveId, results.Results.Last().Id);
};
var defaultSorter = new ExpressionSorter <JustificationObjectiveDTO>(x => x.Name, SortDirection.Descending);
var queryOperator = new QueryableOperator <JustificationObjectiveDTO>(0, 10, defaultSorter);
queryOperator.Sorters.Add(new ExpressionSorter <JustificationObjectiveDTO>(x => x.JustificationName, SortDirection.Descending));
var serviceResults = service.GetJustificationObjectivesByOfficeId(office.OrganizationId, queryOperator);
var serviceResultsAsync = await service.GetJustificationObjectivesByOfficeIdAsync(office.OrganizationId, queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public async Task TestGetContacts_Paging()
{
var contact1 = new Contact
{
ContactId = 1,
};
var contact2 = new Contact
{
ContactId = 2,
};
context.Contacts.Add(contact2);
context.Contacts.Add(contact1);
Action <PagedQueryResults <ContactDTO> > tester = (results) =>
{
Assert.AreEqual(2, results.Total);
Assert.AreEqual(1, results.Results.Count);
};
var defaultSorter = new ExpressionSorter <ContactDTO>(x => x.Id, SortDirection.Descending);
var queryOperator = new QueryableOperator <ContactDTO>(0, 1, defaultSorter);
var serviceResults = service.GetContacts(queryOperator);
var serviceResultsAsync = await service.GetContactsAsync(queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public async Task TestGetMemberships_CheckProperties()
{
var membership = new Membership
{
MembershipId = 1,
Name = "name"
};
context.Memberships.Add(membership);
Action <PagedQueryResults <MembershipDTO> > tester = (results) =>
{
Assert.AreEqual(1, results.Total);
Assert.AreEqual(1, results.Results.Count);
var firstResult = results.Results.First();
Assert.AreEqual(membership.MembershipId, firstResult.Id);
Assert.AreEqual(membership.Name, firstResult.Name);
};
var defaultSorter = new ExpressionSorter <MembershipDTO>(x => x.Id, SortDirection.Ascending);
var queryOperator = new QueryableOperator <MembershipDTO>(0, 10, defaultSorter);
var serviceResults = service.Get(queryOperator);
var serviceResultsAsync = await service.GetAsync(queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public async Task TestGet_CheckProperties()
{
var facebook = new SocialMediaType
{
SocialMediaTypeId = SocialMediaType.Facebook.Id,
SocialMediaTypeName = SocialMediaType.Facebook.Value,
Url = "url"
};
context.SocialMediaTypes.Add(facebook);
Action <PagedQueryResults <SocialMediaTypeDTO> > tester = (results) =>
{
Assert.AreEqual(1, results.Total);
Assert.AreEqual(1, results.Results.Count);
var firstResult = results.Results.First();
Assert.AreEqual(facebook.SocialMediaTypeId, firstResult.Id);
Assert.AreEqual(facebook.SocialMediaTypeName, firstResult.Name);
Assert.AreEqual(facebook.Url, firstResult.Url);
};
var defaultSorter = new ExpressionSorter <SocialMediaTypeDTO>(x => x.Id, SortDirection.Ascending);
var queryOperator = new QueryableOperator <SocialMediaTypeDTO>(0, 10, defaultSorter);
var serviceResults = service.Get(queryOperator);
var serviceResultsAsync = await service.GetAsync(queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public async Task TestGet_CheckProperties()
{
var addressType = new AddressType
{
AddressName = AddressType.Business.Value,
AddressTypeId = AddressType.Business.Id
};
context.AddressTypes.Add(addressType);
Action <PagedQueryResults <AddressTypeDTO> > tester = (results) =>
{
Assert.AreEqual(1, results.Total);
Assert.AreEqual(1, results.Results.Count);
var firstResult = results.Results.First();
Assert.AreEqual(addressType.AddressTypeId, firstResult.Id);
Assert.AreEqual(addressType.AddressName, firstResult.Name);
};
var defaultSorter = new ExpressionSorter <AddressTypeDTO>(x => x.Id, SortDirection.Ascending);
var queryOperator = new QueryableOperator <AddressTypeDTO>(0, 10, defaultSorter);
var serviceResults = service.Get(queryOperator);
var serviceResultsAsync = await service.GetAsync(queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public async Task TestGet_CheckProperties()
{
var focus = new Focus
{
FocusId = 1,
FocusName = "f"
};
context.Foci.Add(focus);
Action <PagedQueryResults <FocusDTO> > tester = (results) =>
{
Assert.AreEqual(1, results.Total);
Assert.AreEqual(1, results.Results.Count);
var firstResult = results.Results.First();
Assert.AreEqual(focus.FocusId, firstResult.Id);
Assert.AreEqual(focus.FocusName, firstResult.Name);
};
var defaultSorter = new ExpressionSorter <FocusDTO>(x => x.Id, SortDirection.Ascending);
var queryOperator = new QueryableOperator <FocusDTO>(0, 10, defaultSorter);
var serviceResults = service.Get(queryOperator);
var serviceResultsAsync = await service.GetAsync(queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public async Task TestGet_CheckProperties()
{
var locationType = new LocationType
{
LocationTypeName = LocationType.City.Value,
LocationTypeId = LocationType.City.Id
};
context.LocationTypes.Add(locationType);
Action <PagedQueryResults <SimpleLookupDTO> > tester = (results) =>
{
Assert.AreEqual(1, results.Total);
Assert.AreEqual(1, results.Results.Count);
var firstResult = results.Results.First();
Assert.AreEqual(locationType.LocationTypeId, firstResult.Id);
Assert.AreEqual(locationType.LocationTypeName, firstResult.Value);
};
var defaultSorter = new ExpressionSorter <SimpleLookupDTO>(x => x.Id, SortDirection.Ascending);
var queryOperator = new QueryableOperator <SimpleLookupDTO>(0, 10, defaultSorter);
var serviceResults = service.Get(queryOperator);
var serviceResultsAsync = await service.GetAsync(queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public async Task TestGet_CheckProperties()
{
var moneyFlowSourceRecipientType = new MoneyFlowSourceRecipientType
{
MoneyFlowSourceRecipientTypeId = 1,
TypeName = "type"
};
context.MoneyFlowSourceRecipientTypes.Add(moneyFlowSourceRecipientType);
Action <PagedQueryResults <MoneyFlowSourceRecipientTypeDTO> > tester = (results) =>
{
Assert.AreEqual(1, results.Total);
Assert.AreEqual(1, results.Results.Count);
var firstResult = results.Results.First();
Assert.AreEqual(moneyFlowSourceRecipientType.MoneyFlowSourceRecipientTypeId, firstResult.Id);
Assert.AreEqual(moneyFlowSourceRecipientType.TypeName, firstResult.Name);
};
var defaultSorter = new ExpressionSorter <MoneyFlowSourceRecipientTypeDTO>(x => x.Id, SortDirection.Ascending);
var queryOperator = new QueryableOperator <MoneyFlowSourceRecipientTypeDTO>(0, 10, defaultSorter);
var serviceResults = service.Get(queryOperator);
var serviceResultsAsync = await service.GetAsync(queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public void TestExtensions_Apply_HasSorter()
{
var list = new List <QueryableOperatorTestClass>();
list.Add(new QueryableOperatorTestClass
{
Id = 2
});
list.Add(new QueryableOperatorTestClass
{
Id = 1
});
list = list.OrderBy(x => x.Id).ToList();
var defaultSorter = new ExpressionSorter <QueryableOperatorTestClass>(x => x.Id, SortDirection.Ascending);
var actualSorter = new ExpressionSorter <QueryableOperatorTestClass>(x => x.Id, SortDirection.Descending);
var queryOperator = new QueryableOperator <QueryableOperatorTestClass>(0, 10, defaultSorter, null, new List <ISorter> {
actualSorter
});
var query = list.AsQueryable().Apply(queryOperator);
var testList = query.ToList();
var expectedList = list.OrderByDescending(x => x.Id).ToList();
CollectionAssert.AreEqual(expectedList, testList);
}
public void TestExtensions_Apply_HasFilter()
{
var list = new List <QueryableOperatorTestClass>();
list.Add(new QueryableOperatorTestClass
{
Id = 2
});
list.Add(new QueryableOperatorTestClass
{
Id = 1
});
list = list.OrderBy(x => x.Id).ToList();
var filterValue = 1;
var defaultSorter = new ExpressionSorter <QueryableOperatorTestClass>(x => x.Id, SortDirection.Ascending);
var filter = new ExpressionFilter <QueryableOperatorTestClass>(x => x.Id, ComparisonType.Equal, filterValue);
var queryOperator = new QueryableOperator <QueryableOperatorTestClass>(0, 10, defaultSorter, new List <IFilter> {
filter
}, null);
var query = list.AsQueryable().Apply(queryOperator);
var testList = query.ToList();
Assert.AreEqual(1, testList.Count);
Assert.AreEqual(filterValue, testList.First().Id);
}
public async Task TestGetGoals_CheckProperties()
{
var goal = new Goal
{
GoalId = 1,
GoalName = "goal"
};
context.Goals.Add(goal);
Action <PagedQueryResults <GoalDTO> > tester = (results) =>
{
Assert.AreEqual(1, results.Total);
Assert.AreEqual(1, results.Results.Count);
var firstResult = results.Results.First();
Assert.AreEqual(goal.GoalId, firstResult.Id);
Assert.AreEqual(goal.GoalName, firstResult.Name);
};
var defaultSorter = new ExpressionSorter <GoalDTO>(x => x.Id, SortDirection.Ascending);
var queryOperator = new QueryableOperator <GoalDTO>(0, 10, defaultSorter);
var serviceResults = service.Get(queryOperator);
var serviceResultsAsync = await service.GetAsync(queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public void TestToString_DefaultSorterOnly()
{
var defaultSorter = new ExpressionSorter <QueryableOperatorTestClass>(x => x.Id, SortDirection.Ascending);
var queryOperator = new QueryableOperator <QueryableOperatorTestClass>(0, 10, defaultSorter, null, null);
Assert.IsNotNull(queryOperator.ToString());
}
public async Task TestGetMemberships_Filter()
{
var membership1 = new Membership
{
MembershipId = 1,
};
var membership2 = new Membership
{
MembershipId = 2,
};
context.Memberships.Add(membership1);
context.Memberships.Add(membership2);
Action <PagedQueryResults <MembershipDTO> > tester = (results) =>
{
Assert.AreEqual(1, results.Total);
Assert.AreEqual(1, results.Results.Count);
var firstResult = results.Results.First();
Assert.AreEqual(membership1.MembershipId, firstResult.Id);
};
var defaultSorter = new ExpressionSorter <MembershipDTO>(x => x.Id, SortDirection.Descending);
var queryOperator = new QueryableOperator <MembershipDTO>(0, 1, defaultSorter);
queryOperator.Filters.Add(new ExpressionFilter <MembershipDTO>(x => x.Id, ComparisonType.Equal, membership1.MembershipId));
var serviceResults = service.Get(queryOperator);
var serviceResultsAsync = await service.GetAsync(queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public void TestConstructor()
{
var direction = SortDirection.Ascending;
var sorter = new ExpressionSorter <ExpresssionSorterTestClass>(x => x.Id, direction);
Assert.AreEqual("Id", sorter.Property);
Assert.AreEqual(direction.Value, sorter.Direction);
}
public void TestCreateGetProjectsByPersonIdQuery_NoProjects()
{
var defaultSorter = new ExpressionSorter <ParticipantTimelineDTO>(x => x.Name, SortDirection.Ascending);
var queryOperator = new QueryableOperator <ParticipantTimelineDTO>(0, 10, defaultSorter);
var projects = ProjectQueries.CreateGetProjectsByPersonIdQuery(context, 1, queryOperator);
Assert.AreEqual(0, projects.Count());
}
public void TestCreateGetParticipantPersonSevisCommStatusesByParticipantIdQuery_Filtered()
{
var userAccount = new UserAccount
{
PrincipalId = 100,
DisplayName = "display name",
EmailAddress = "email"
};
var participant = new Participant
{
ParticipantId = 1,
ProjectId = 100
};
var participantPerson = new ParticipantPerson
{
ParticipantId = participant.ParticipantId,
Participant = participant
};
participant.ParticipantPerson = participantPerson;
var sevisCommStatus = new SevisCommStatus
{
SevisCommStatusId = 500,
SevisCommStatusName = "sevis comm status name"
};
var status = new ParticipantPersonSevisCommStatus
{
Id = 1,
AddedOn = DateTimeOffset.UtcNow,
BatchId = "batchId",
ParticipantId = participant.ParticipantId,
ParticipantPerson = participantPerson,
PrincipalId = userAccount.PrincipalId,
SevisCommStatus = sevisCommStatus,
SevisCommStatusId = sevisCommStatus.SevisCommStatusId,
SevisOrgId = "sevis org Id",
SevisUsername = "******"
};
context.UserAccounts.Add(userAccount);
context.Participants.Add(participant);
context.ParticipantPersons.Add(participantPerson);
context.SevisCommStatuses.Add(sevisCommStatus);
context.ParticipantPersonSevisCommStatuses.Add(status);
var defaultSorter = new ExpressionSorter <ParticipantPersonSevisCommStatusDTO>(x => x.AddedOn, SortDirection.Descending);
var filter = new ExpressionFilter <ParticipantPersonSevisCommStatusDTO>(x => x.BatchId, ComparisonType.Equal, status.BatchId);
var queryOperator = new QueryableOperator <ParticipantPersonSevisCommStatusDTO>(0, 1, defaultSorter);
queryOperator.Filters.Add(filter);
var results = ParticipantPersonsSevisQueries.CreateGetParticipantPersonSevisCommStatusesByParticipantIdQuery(context, participant.ProjectId, participant.ParticipantId, queryOperator);
Assert.AreEqual(1, results.Count());
var firstResult = results.First();
Assert.AreEqual(status.Id, firstResult.Id);
}
public async Task TestGetJustificationObjectivesByProgramId_Filtered()
{
var program = new Program
{
ProgramId = 1
};
var justification1 = new Justification
{
JustificationId = 1,
JustificationName = "just1",
};
var justification2 = new Justification
{
JustificationId = 2,
JustificationName = "just2",
};
var objective1 = new Objective
{
Justification = justification1,
JustificationId = justification1.JustificationId,
ObjectiveId = 1,
ObjectiveName = "obj1",
};
var objective2 = new Objective
{
Justification = justification1,
JustificationId = justification1.JustificationId,
ObjectiveId = 2,
ObjectiveName = "obj2",
};
program.Objectives.Add(objective1);
program.Objectives.Add(objective2);
context.Objectives.Add(objective1);
context.Objectives.Add(objective2);
context.Justifications.Add(justification1);
context.Justifications.Add(justification2);
context.Programs.Add(program);
Action <PagedQueryResults <JustificationObjectiveDTO> > tester = (results) =>
{
Assert.AreEqual(1, results.Total);
Assert.AreEqual(1, results.Results.Count);
Assert.AreEqual(objective1.ObjectiveName, results.Results.First().Name);
};
var defaultSorter = new ExpressionSorter <JustificationObjectiveDTO>(x => x.Name, SortDirection.Descending);
var queryOperator = new QueryableOperator <JustificationObjectiveDTO>(0, 10, defaultSorter);
queryOperator.Filters.Add(new ExpressionFilter <JustificationObjectiveDTO>(x => x.Name, ComparisonType.Equal, objective1.ObjectiveName));
var serviceResults = service.GetJustificationObjectivesByProgramId(program.ProgramId, queryOperator);
var serviceResultsAsync = await service.GetJustificationObjectivesByProgramIdAsync(program.ProgramId, queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public void TestCreateGetProjectsByPersonIdQuery_CheckRelationships()
{
var person = new Person
{
PersonId = 1
};
var org = new Organization
{
OrganizationId = 1
};
var program = new Program
{
ProgramId = 1,
Owner = org,
OwnerId = org.OrganizationId
};
var project = new Project
{
ProjectId = 1,
ProgramId = program.ProgramId,
ParentProgram = program
};
var participant = new Participant
{
ParticipantId = 1,
Person = person,
PersonId = person.PersonId,
Project = project,
ProjectId = project.ProjectId
};
context.Participants.Add(participant);
var defaultSorter = new ExpressionSorter <ParticipantTimelineDTO>(x => x.Name, SortDirection.Ascending);
var queryOperator = new QueryableOperator <ParticipantTimelineDTO>(0, 10, defaultSorter);
var projects = ProjectQueries.CreateGetProjectsByPersonIdQuery(context, person.PersonId, queryOperator);
Assert.AreEqual(1, projects.Count());
var projectResult = projects.FirstOrDefault();
Assert.AreEqual(project.ProjectId, projectResult.ProjectId);
Assert.AreEqual(program.ProgramId, projectResult.ProgramId);
Assert.AreEqual(org.OrganizationId, projectResult.OfficeId);
}
