public GetOrRegisterUserAsync()
{
_discordUser = MockHelper.CreateDiscordUser(0);
}
public async Task SimpleRegisted_ShouldRegisterAndReturnOK()
{
//это было самым трудным
int organizationContactPersonId = 33;
var identityHelper = new Mock <IIdentityHelper>();
identityHelper.Setup(d => d.FindUserById(It.IsAny <string>()))
.Returns <string>((userId) =>
{
ApplicationUser user = new ApplicationUser
{
Id = userId,
Email = "*****@*****.**",
//TableId = 1,
//TableName = "Employee",
UserName = "******"
};
return(user);
});
identityHelper.Setup(d => d.GetUserId(It.IsAny <IPrincipal>())).Returns(Guid.NewGuid().ToString());
var dbContext = new Mock <IAppDbContext>();
dbContext.Setup(d => d.ExecuteStoredProcedure <bool>(It.IsAny <string>(), It.IsAny <object[]>()))
.Returns <string, object[]>((query, parameters) =>
{
List <bool> list = new List <bool>();
if (query.Contains("IsEmployeeInformationFilled"))
{
list.Add(true);
}
return(list);
});
var personsData = new List <OrganizationContactPersonView>
{
new OrganizationContactPersonView {
Id = 33, FirstName = "Тест", SecondName = "Тестович", LastName = "Тестовый", Email = "*****@*****.**"
},
new OrganizationContactPersonView {
Id = 99, Email = "ddd", FirstName = "ss", SecondName = "ss", LastName = "ssss"
}
};
var persons = MockHelper.MockDbSet <OrganizationContactPersonView>(personsData);
dbContext.Setup(d => d.OrganizationContactPersonViews).Returns(persons.Object);
dbContext.Setup(d => d.Set <OrganizationContactPersonView>()).Returns(persons.Object);
var dbFactory = new Mock <IDbContextFactory>();
dbFactory.Setup(d => d.CreateDbContext()).Returns(dbContext.Object);
var request = new Mock <IRequest>();
request.Setup(d => d.FileCount()).Returns(1);
request.Setup(d => d.Collection()).Returns(new List <string> {
"one.jpg"
});
request.Setup(d => d.AppPath()).Returns("C://Projects//GTIWebAPI//GTIWebAPI//");
var novell = new Mock <INovelleDirectory>();
// novell.Setup(d => d.GenerateLogin(It.IsAny<string>())).Returns<string>((login) => { return login; });
OrganizationContactPersonView contactPerson = new OrganizationContactPersonView()
{
FirstName = "Sofia",
LastName = "Viazovsky",
Email = "*****@*****.**"
};
novell.Setup(d => d.CreateOrganization(It.IsAny <INovellOrganizationContactPerson>())).Returns(new NovellOrganizationContactPerson(contactPerson));
var context = new Mock <IApplicationDbContext>();
context.Setup(d => d.CreateOrganization(It.IsAny <string>(), It.IsAny <string>())).Returns(true);
context.Setup(d => d.GrantRightsToOrganization(It.IsAny <string>())).Returns(true);
var mockUS = new Mock <IUserStore <ApplicationUser> >();
var mockUM = new Mock <ApplicationUserManager>(mockUS.Object);
mockUM.Setup(d => d.AddToRoleAsync(It.IsAny <string>(), It.IsAny <string>())).Returns <string, string>
((a, b) =>
{
return(Task.FromResult <IdentityResult>(IdentityResult.Success));
});
mockUM.Setup(d => d.CreateAsync(It.IsAny <ApplicationUser>())).Returns <ApplicationUser>
((user) =>
{
return(Task.FromResult <IdentityResult>(IdentityResult.Success));
});
mockUM.Setup(d => d.CreateAsync(It.IsAny <ApplicationUser>(), It.IsAny <string>())).Returns <ApplicationUser, string>
((user, password) =>
{
return(Task.FromResult <IdentityResult>(IdentityResult.Success));
});
mockUM.Setup(d => d.SendEmailAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).Returns(Task.FromResult(default(object)));
var controller = new AccountController(dbFactory.Object, context.Object, request.Object, identityHelper.Object, novell.Object, mockUM.Object);
var result = await controller.SimpleRegisterOrganizationContactPerson(33) as OkResult;
Assert.IsNotNull(result);
}
public void ContentController_GetContentItemsByTerm_Returns_List_Of_ContentItems()
{
//Arrange
Mock <IDataService> mockDataService = new Mock <IDataService>();
mockDataService.Setup(ds => ds.GetContentItemsByTerm(Constants.TERM_ValidName)).Returns(MockHelper.CreateValidContentItemsReader(Constants.CONTENT_TaggedItemCount,
Constants.CONTENT_IndexedFalse,
Null.NullInteger,
Constants.TERM_ValidName));
ContentController controller = new ContentController(mockDataService.Object);
//Act
IQueryable <ContentItem> contentItems = controller.GetContentItemsByTerm(Constants.TERM_ValidName);
//Assert
Assert.AreEqual(Constants.CONTENT_TaggedItemCount, contentItems.Count());
}
public void ContentController_GetMetaData_Calls_DataService_On_Valid_Arguments()
{
//Arrange
Mock <IDataService> mockDataService = new Mock <IDataService>();
mockDataService.Setup(ds => ds.GetMetaData(Constants.CONTENT_ValidContentItemId)).Returns(MockHelper.CreateValidMetaDataReader());
ContentController controller = new ContentController(mockDataService.Object);
//Act
NameValueCollection metaData = controller.GetMetaData(Constants.CONTENT_ValidContentItemId);
//Assert
mockDataService.Verify(ds => ds.GetMetaData(Constants.CONTENT_ValidContentItemId));
}
public void ContentController_GetContentItem_Calls_DataService_On_Valid_ContentItemId()
{
//Arrange
Mock <IDataService> mockDataService = new Mock <IDataService>();
mockDataService.Setup(ds => ds.GetContentItem(Constants.CONTENT_ValidContentItemId)).Returns(MockHelper.CreateValidContentItemReader());
ContentController controller = new ContentController(mockDataService.Object);
//Act
ContentItem content = controller.GetContentItem(Constants.CONTENT_ValidContentItemId);
//Assert
mockDataService.Verify(ds => ds.GetContentItem(Constants.CONTENT_ValidContentItemId));
}
public void ContentController_GetContentItemsByTerm_Calls_DataService()
{
//Arrange
Mock <IDataService> mockDataService = new Mock <IDataService>();
mockDataService.Setup(ds => ds.GetContentItemsByTerm(Constants.TERM_ValidName)).Returns(MockHelper.CreateValidContentItemReader());
ContentController controller = new ContentController(mockDataService.Object);
//Act
IQueryable <ContentItem> contentItems = controller.GetContentItemsByTerm(Constants.TERM_ValidName);
//Assert
mockDataService.Verify(ds => ds.GetContentItemsByTerm(Constants.TERM_ValidName));
}
public Task <IList <PostDTO> > GetPostsUsingCouncilAsync(Guid councilGuid)
{
return(MockHelper.CreateMockPostsWithCouncilAsync(councilGuid));
}
public void Details_EventNull_ActionResult()
{
// Arrange
var mainUser = new User
{
Id = 1,
FirstName = "Unit",
LastName = "Test",
UserName = "******",
Mail = "*****@*****.**"
};
var users = new List <User>()
{
mainUser
}.AsQueryable();
var mainGroup = new Group
{
Id = 1,
Category = "Unit Category",
CreatedOn = DateTime.Now,
GroupName = "Unit Group",
GroupCreator = mainUser.Id,
Users = users.ToList()
};
var groups = new List <Group>()
{
mainGroup
}.AsQueryable();
var skills = new List <Skill>()
{
new Skill {
CreatedBy = mainUser, Id = 1
}
}.AsQueryable();
var mainEvent = new Event
{
Id = 1,
CreatedOn = DateTime.Now,
EventCreator = mainUser,
EventName = "Unit Event",
Group = mainGroup,
Skills = skills.ToList(),
};
var teams = new List <EventTeam>()
{
new EventTeam {
Event = mainEvent, Id = 1, Users = users.ToList()
}
}.AsQueryable();
mainEvent.Teams = teams.ToList();
var events = new List <Event>()
{
mainEvent
}.AsQueryable();
var mockContext = new Mock <Context>();
var mockEvents = MockHelper.MockDbSet(events);
mockContext.SetupGet(c => c.Events).Returns(mockEvents.Object);
var mockUserHelper = new Mock <IUserHelper>();
mockUserHelper.Setup(x => x.GetCurrentUser().Id).Returns(mainUser.Id);
var controller = new EventController(mockContext.Object, mockUserHelper.Object);
// Act
ViewResult resultEventNotNull = controller.Details(mainEvent.Id) as ViewResult;
RedirectToRouteResult resultEventNull = controller.Details(0) as RedirectToRouteResult;
// Assert
Assert.IsNotNull(resultEventNotNull);
Assert.IsNotNull(resultEventNull);
}
public void TermController_GetTermsByVocabulary_Returns_Terms_On_Valid_VocabularyId()
{
//Arrange
var mockDataService = new Mock <IDataService>();
mockDataService.Setup(ds => ds.GetTermsByVocabulary(Constants.TERM_ValidVocabulary1)).Returns(MockHelper.CreateValidTermsReader(Constants.TERM_ValidCountForVocabulary1,
v => Constants.TERM_ValidVocabulary1,
c => Constants.TERM_ValidContent1));
MockComponentProvider.CreateDataProvider().Setup(c => c.GetProviderPath()).Returns(String.Empty);
var termController = new TermController(mockDataService.Object);
//Act
var terms = termController.GetTermsByVocabulary(Constants.TERM_ValidVocabulary1).ToList();
//Assert
Assert.AreEqual(Constants.TERM_ValidCountForVocabulary1, terms.Count);
for (int i = 0; i < Constants.TERM_ValidCountForVocabulary1; i++)
{
Assert.AreEqual(i + Constants.TERM_ValidTermId, terms[i].TermId);
Assert.AreEqual(ContentTestHelper.GetTermName(i + Constants.TERM_ValidTermId), terms[i].Name);
}
}
public Task <IList <CommentDTO> > GetCommentsAsync(Guid postGuid)
{
return(MockHelper.CreateMockComments(postGuid));
}
public void TermController_GetTermsByContent_Returns_Terms_On_Valid_ContentItemId()
{
//Arrange
var mockDataService = new Mock <IDataService>();
mockDataService.Setup(ds => ds.GetTermsByContent(Constants.TERM_ValidContent1)).Returns(MockHelper.CreateValidTermsReader(Constants.TERM_ValidCountForContent1,
v => Constants.TERM_ValidVocabularyId,
c => Constants.TERM_ValidContent1));
var termController = new TermController(mockDataService.Object);
//Act
var terms = termController.GetTermsByContent(Constants.TERM_ValidContent1).ToList();
//Assert
Assert.AreEqual(Constants.TERM_ValidCountForContent1, terms.Count);
for (int i = 0; i < Constants.TERM_ValidCountForContent1; i++)
{
Assert.AreEqual(i + Constants.TERM_ValidTermId, terms[i].TermId);
Assert.AreEqual(ContentTestHelper.GetTermName(i + Constants.TERM_ValidTermId), terms[i].Name);
}
}
public void TermController_GetTermsByContent_Calls_DataService()
{
//Arrange
var mockDataService = new Mock <IDataService>();
mockDataService.Setup(ds => ds.GetTermsByContent(Constants.TERM_ValidContent1)).Returns(MockHelper.CreateValidTermsReader(Constants.TERM_ValidCountForContent1,
v => Constants.TERM_ValidVocabularyId,
c => Constants.TERM_ValidContent1));
var termController = new TermController(mockDataService.Object);
//Act
IQueryable <Term> terms = termController.GetTermsByContent(Constants.TERM_ValidContent1);
//Assert
mockDataService.Verify(ds => ds.GetTermsByContent(Constants.TERM_ValidContent1));
}
public void TermController_GetTerm_Returns_Term_On_Valid_TermId()
{
//Arrange
var mockDataService = new Mock <IDataService>();
mockDataService.Setup(ds => ds.GetTerm(Constants.TERM_ValidTermId)).Returns(MockHelper.CreateValidTermReader());
var termController = new TermController(mockDataService.Object);
//Act
var term = termController.GetTerm(Constants.TERM_ValidTermId);
//Assert
Assert.AreEqual(Constants.TERM_ValidTermId, term.TermId);
Assert.AreEqual(Constants.TERM_ValidName, term.Name);
}
public void TermController_GetTerm_Calls_DataService()
{
//Arrange
var mockDataService = new Mock <IDataService>();
mockDataService.Setup(ds => ds.GetTerm(Constants.TERM_ValidTermId)).Returns(MockHelper.CreateValidTermReader());
var termController = new TermController(mockDataService.Object);
//Act
Term term = termController.GetTerm(Constants.TERM_ValidTermId);
//Assert
mockDataService.Verify(ds => ds.GetTerm(Constants.TERM_ValidTermId));
}
public void Non_generic_DbSqlQuery_AsNoTracking_returns_new_object_with_no_tracking_flag_set()
{
var query = new DbSqlQuery(MockHelper.CreateInternalSqlSetQuery("query", 1, 2));
DynamicNoTrackingTest(query);
}
public void AddSkillPost_Flow_ViewResult()
{
// Arrange
var mainUser = new User
{
Id = 1,
FirstName = "Unit",
LastName = "Test",
UserName = "******",
Mail = "*****@*****.**"
};
var users = new List <User>()
{
mainUser
}.AsQueryable();
var mainEvent = new Event
{
Id = 1,
CreatedOn = DateTime.Now,
EventCreator = mainUser,
EventName = "Unit Event",
};
var events = new List <Event>()
{
mainEvent
}.AsQueryable();
var mainSkill = new Skill
{
CreatedBy = mainUser,
Id = 1,
Name = "Unit Skill"
};
var skills = new List <Skill>()
{
mainSkill
}.AsQueryable();
var mockContext = new Mock <Context>();
var mockEvents = MockHelper.MockDbSet(events);
mockContext.SetupGet(c => c.Events).Returns(mockEvents.Object);
var mockUsers = MockHelper.MockDbSet(users);
mockContext.SetupGet(c => c.Users).Returns(mockUsers.Object);
var mockSkills = MockHelper.MockDbSet(skills);
mockContext.SetupGet(c => c.Skills).Returns(mockSkills.Object);
var mockUserHelper = new Mock <IUserHelper>();
mockUserHelper.Setup(x => x.GetCurrentUser().Id).Returns(mainUser.Id);
var controller = new EventController(mockContext.Object, mockUserHelper.Object);
var vm = new EditVM
{
Id = mainEvent.Id,
NewSkillDescription = "Unit Skill Description",
NewSkillName = "Unit Skill Name"
};
// Act
ViewResult result = controller.AddSkill(vm) as ViewResult;
// Assert
Assert.IsNotNull(result);
}
public PurchaseServiceTest()
{
Db = MockHelper.GetDbContext <DbBookstore>();
MockRepository = new EFMockRepository(Db);
}
public void ContentController_GetContentItem_Returns_Null_On_InValid_ContentItemId()
{
//Arrange
Mock <IDataService> mockDataService = new Mock <IDataService>();
mockDataService.Setup(ds => ds.GetContentItem(Constants.CONTENT_InValidContentItemId)).Returns(MockHelper.CreateEmptyContentItemReader());
ContentController controller = new ContentController(mockDataService.Object);
//Act
ContentItem content = controller.GetContentItem(Constants.CONTENT_InValidContentItemId);
//Assert
Assert.IsNull(content);
}
public override async Task InitializeAsync()
{
var serverMock = MockHelper.CreateDiscordGuild(0);
_server = (await this.Servers.GetOrRegisterServerAsync(serverMock)).Entity;
}
public void ContentController_GetContentItem_Returns_ContentItem_On_Valid_ContentItemId()
{
//Arrange
Mock <IDataService> mockDataService = new Mock <IDataService>();
mockDataService.Setup(ds => ds.GetContentItem(Constants.CONTENT_ValidContentItemId)).Returns(MockHelper.CreateValidContentItemReader());
ContentController controller = new ContentController(mockDataService.Object);
//Act
ContentItem content = controller.GetContentItem(Constants.CONTENT_ValidContentItemId);
//Assert
Assert.AreEqual(Constants.CONTENT_ValidContentItemId, content.ContentItemId);
Assert.AreEqual(ContentTestHelper.GetContent(Constants.CONTENT_ValidContentItemId), content.Content);
Assert.AreEqual(ContentTestHelper.GetContentKey(Constants.CONTENT_ValidContentItemId), content.ContentKey);
}
public void ChangingSecurity()
{
var cachier = GetCachier();
var modelReader = Guid.NewGuid();
var modelWriter = Guid.NewGuid();
var elementReader = Guid.NewGuid();
var elementWriter = Guid.NewGuid();
var elemPermissions = new SecurityPermissions
{
AllowedForRead = new[] { elementReader },
AllowedForWrite = new[] { elementWriter }
};
var modelPermissions = new SecurityPermissions
{
AllowedForRead = new[] { modelReader },
AllowedForWrite = new[] { modelWriter }
};
cachier.Post(_singleModel.Key, modelPermissions);
cachier.Post(_dependentModel.Key, modelPermissions);
cachier.Post(_singleElement.Key, elemPermissions);
cachier.Post(_dependentElement.Key, elemPermissions);
var user1 = Guid.NewGuid();
var user2 = Guid.NewGuid();
var group1 = new SecurityGroup {
Groups = new[] { modelReader, elementReader, elementWriter }
};
var group2 = new SecurityGroup {
Groups = new[] { modelReader, elementReader, modelWriter }
};
cachier.Post(user1, group1);
cachier.Post(user2, group2);
Session.UserId = user1;
var elem = cachier.Get <Element>(_singleElement.Key);
Assert.IsNotNull(elem);
var model = cachier.Get <Model>(_singleModel.Key);
Assert.IsNotNull(model);
//запрещаем чтение из модели
group1.Groups = new[] { elementReader, elementWriter };
elem = cachier.Get <Element>(_singleElement.Key);
Assert.IsNotNull(elem);
model = cachier.Get <Model>(_singleModel.Key);
Assert.IsNotNull(model);
cachier.Post(user1, group1);
elem = cachier.Get <Element>(_singleElement.Key);
Assert.IsNotNull(elem);
model = cachier.Get <Model>(_singleModel.Key);
Assert.IsNull(model);
MockHelper.AwaitException <SecurityException>(() => cachier.Post(_singleModel.Key, _singleModel));
cachier.Post(_singleElement.Key, _singleElement);
//разрешаем только запись во все
group1.Groups = new[] { modelWriter, elementWriter };
cachier.Post(user1, group1);
cachier.Post(_singleModel.Key, _singleModel);
cachier.Post(_singleElement.Key, _singleElement);
Session.UserId = user2;
elem = cachier.Get <Element>(_singleElement.Key);
Assert.IsNotNull(elem);
model = cachier.Get <Model>(_singleModel.Key);
Assert.IsNotNull(model);
MockHelper.AwaitException <SecurityException>(() => cachier.Post(_singleElement.Key, _singleElement));
cachier.Post(_singleModel.Key, _singleModel);
}
public void ContentController_GetContentItemsByTerm_Returns_Empty_List_If_Term_Not_Used()
{
//Arrange
Mock <IDataService> mockDataService = new Mock <IDataService>();
mockDataService.Setup(ds => ds.GetContentItemsByTerm(Constants.TERM_UnusedName)).Returns(MockHelper.CreateEmptyContentItemReader());
ContentController controller = new ContentController(mockDataService.Object);
//Act
IQueryable <ContentItem> contentItems = controller.GetContentItemsByTerm(Constants.TERM_UnusedName);
//Assert
Assert.AreEqual(0, contentItems.Count());
}
public void DeferredSecurity()
{
var cachier = GetCachier();
ModelSecurityProvider.TimesWasUsed = 0;
var modelReader = Guid.NewGuid();
var modelWriter = Guid.NewGuid();
var elementReader = Guid.NewGuid();
var elementWriter = Guid.NewGuid();
var elemPermissions = new SecurityPermissions
{
AllowedForRead = new[] { elementReader },
AllowedForWrite = new[] { elementWriter }
};
var modelPermissions = new SecurityPermissions
{
AllowedForRead = new[] { modelReader },
AllowedForWrite = new[] { modelWriter }
};
cachier.Post(_singleModel.Key, modelPermissions);
cachier.Post(_dependentModel.Key, modelPermissions);
cachier.Post(_singleElement.Key, elemPermissions);
cachier.Post(_dependentElement.Key, elemPermissions);
var user1 = Guid.NewGuid();
var user2 = Guid.NewGuid();
var group1 = new SecurityGroup {
Groups = new[] { modelReader, elementReader, elementWriter }
};
var group2 = new SecurityGroup {
Groups = new[] { modelReader, elementReader, modelWriter }
};
cachier.Post(user1, group1);
cachier.Post(user2, group2);
Session.UserId = user1;
var elem = cachier.GetLater <Element>(_singleElement.Key);
var elem2 = cachier.GetLater <Element>(_dependentElement.Key);
Assert.IsNotNull(elem.Value);
Assert.IsNotNull(elem2.Value);
Assert.AreEqual(1, ModelSecurityProvider.TimesWasUsed);//серия должна взяться один раз
//после этого должы браться результаты серии закэшированные результаты
ModelSecurityProvider.TimesWasUsed = 0;
cachier.Post(_singleElement.Key, _singleElement);
cachier.Post(_dependentElement.Key, _dependentElement);
Assert.AreEqual(0, ModelSecurityProvider.TimesWasUsed);
Session.UserId = user2;
elem = cachier.GetLater <Element>(_singleElement.Key);
elem2 = cachier.GetLater <Element>(_dependentElement.Key);
Assert.IsNotNull(elem.Value);
Assert.IsNotNull(elem2.Value);
Assert.AreEqual(1, ModelSecurityProvider.TimesWasUsed);//серия должна взяться один раз
//после этого должы браться результаты серии закэшированные результаты
ModelSecurityProvider.TimesWasUsed = 0;
MockHelper.AwaitException <SecurityException>(() => cachier.Post(_singleElement.Key, _singleElement));
MockHelper.AwaitException <SecurityException>(() => cachier.Post(_dependentElement.Key, _dependentElement));
Assert.AreEqual(0, ModelSecurityProvider.TimesWasUsed);
}
public void ContentController_GetContentItemsByContentType_Invalid_Id_Returns_No_Elements()
{
var mock = new Mock <IDataService>();
mock.Setup(ds => ds.GetContentItemsByContentType(It.IsAny <int>())).Returns(MockHelper.CreateEmptyContentItemReader());
var controller = new ContentController(mock.Object);
var items = controller.GetContentItemsByContentType(-1).ToArray();
Assert.IsEmpty(items);
}
public void Can_Create_Service_Context()
{
var svcCtx = MockHelper.GetMockedServiceContext();
Assert.Pass();
}
public void ContentController_GetMetaData_Returns_NameValueCollection_Of_MetaData()
{
//Arrange
Mock <IDataService> mockDataService = new Mock <IDataService>();
mockDataService.Setup(ds => ds.GetMetaData(Constants.CONTENT_ValidContentItemId)).Returns(MockHelper.CreateValidMetaDataReader());
mockDataService.Setup(ds =>
ds.SynchronizeMetaData(
It.IsAny <ContentItem>(),
It.IsAny <IEnumerable <KeyValuePair <string, string> > >(),
It.IsAny <IEnumerable <KeyValuePair <string, string> > >()))
.Callback <ContentItem, IEnumerable <KeyValuePair <string, string> >, IEnumerable <KeyValuePair <string, string> > >(
(ci, added, deleted) =>
{
deleted.ToList().ForEach(
item => mockDataService.Object.DeleteMetaData(ci, item.Key, item.Value));
added.ToList().ForEach(
item => mockDataService.Object.AddMetaData(ci, item.Key, item.Value));
});
var controller = new ContentController(mockDataService.Object);
//Act
var metaData = controller.GetMetaData(Constants.CONTENT_ValidContentItemId);
//Assert
Assert.AreEqual(Constants.CONTENT_MetaDataCount, metaData.Count);
}
public void Team_Flow_ViewResult()
{
// Arrange
var mainUser = new User
{
Id = 1,
FirstName = "Unit",
LastName = "Test",
UserName = "******",
Mail = "*****@*****.**",
};
var ratings = new List <Rating>()
{
new Rating {
Mark = 6.0, Id = 1
}
}.AsQueryable();
var mainSkill = new Skill
{
Id = 1,
Name = "Unit Skill"
};
var userSkills = new List <UserSkill>()
{
new UserSkill {
Id = 1, Ratings = ratings.ToList(), User = mainUser, Skill = mainSkill
}
}.AsQueryable();
mainUser.UserSkills = userSkills.ToList();
var users = new List <User>()
{
mainUser
}.AsQueryable();
var mainTeam = new EventTeam
{
Id = 1,
Users = users.ToList()
};
var teams = new List <EventTeam>()
{
mainTeam
}.AsQueryable();
var mockContext = new Mock <Context>();
var mockTeams = MockHelper.MockDbSet(teams);
mockContext.SetupGet(c => c.EventTeams).Returns(mockTeams.Object);
var mockUsers = MockHelper.MockDbSet(users);
mockContext.SetupGet(c => c.Users).Returns(mockUsers.Object);
var mockUserSkills = MockHelper.MockDbSet(userSkills);
mockContext.SetupGet(c => c.UserSkills).Returns(mockUserSkills.Object);
var mockRatings = MockHelper.MockDbSet(ratings);
mockContext.SetupGet(c => c.Ratings).Returns(mockRatings.Object);
var controller = new EventController(mockContext.Object);
// Act
ViewResult result = controller.Team(mainTeam.Id) as ViewResult;
// Assert
Assert.IsNotNull(result);
}
public void SetAsProfilePicture_ShouldWork()
{
Guid pictureId = Guid.NewGuid();
var identityHelper = new Mock <IIdentityHelper>();
identityHelper.Setup(d => d.FindUserById(It.IsAny <string>()))
.Returns <string>((userId) =>
{
ApplicationUser user = new ApplicationUser
{
Id = userId,
Email = "*****@*****.**",
//TableId = 1,
//TableName = "Employee",
UserName = "******"
};
return(user);
});
identityHelper.Setup(d => d.GetUserId(It.IsAny <IPrincipal>())).Returns(Guid.NewGuid().ToString());
var dbContext = new Mock <IAppDbContext>();
dbContext.Setup(d => d.ExecuteStoredProcedure <bool>(It.IsAny <string>(), It.IsAny <object[]>()))
.Returns <string, object[]>((query, parameters) =>
{
List <bool> list = new List <bool>();
if (query.Contains("IsEmployeeInformationFilled"))
{
list.Add(true);
}
return(list);
});
var userImagesTestData = new List <UserImage>
{
new UserImage {
Id = pictureId, IsProfilePicture = false
},
new UserImage {
Id = Guid.NewGuid(), IsProfilePicture = false
},
new UserImage {
Id = Guid.NewGuid(), IsProfilePicture = true
}
};
var userImages = MockHelper.MockDbSet <UserImage>(userImagesTestData);
dbContext.Setup(d => d.UserImages).Returns(userImages.Object);
dbContext.Setup(d => d.Set <UserImage>()).Returns(userImages.Object);
var dbFactory = new Mock <IDbContextFactory>();
dbFactory.Setup(d => d.CreateDbContext()).Returns(dbContext.Object);
var request = new Mock <IRequest>();
request.Setup(d => d.FileCount()).Returns(1);
request.Setup(d => d.Collection()).Returns(new List <string> {
"one.jpg"
});
var controller = new AccountController(dbFactory.Object, identityHelper.Object, request.Object);
var result = controller.SetAsProfilePicture(pictureId) as OkNegotiatedContentResult <UserImage>;
Assert.IsNotNull(result);
Assert.AreEqual(pictureId, result.Content.Id);
}
public void GenerateTeamsPost_Flow_ActionResult()
{
// Arrange
var mainUser = new User
{
Id = 1,
FirstName = "Unit",
LastName = "Test",
UserName = "******",
Mail = "*****@*****.**",
Notifications = new List <Notification>(),
};
var secondUser = new User
{
Id = 2,
FirstName = "Unit2",
LastName = "Test2",
UserName = "******",
Mail = "*****@*****.**",
Notifications = new List <Notification>()
};
var ratings = new List <Rating>()
{
new Rating {
Mark = 6.0, Id = 1
}
}.AsQueryable();
var mainSkill = new Skill
{
Id = 1,
Name = "Unit Skill"
};
var userSkills1 = new List <UserSkill>()
{
new UserSkill {
Id = 1, Ratings = ratings.ToList(), User = mainUser, Skill = mainSkill
},
}.AsQueryable();
var userSkills2 = new List <UserSkill>()
{
new UserSkill {
Id = 2, Ratings = ratings.ToList(), User = secondUser, Skill = mainSkill
}
}.AsQueryable();
mainUser.UserSkills = userSkills1.ToList();
secondUser.UserSkills = userSkills2.ToList();
var users = new List <User>()
{
mainUser
}.AsQueryable();
var mainTeam = new EventTeam
{
Id = 1,
Users = users.ToList()
};
var teams = new List <EventTeam>()
{
mainTeam
}.AsQueryable();
var mainGroup = new Group
{
Id = 1,
Category = "Unit Category",
CreatedOn = DateTime.Now,
GroupName = "Unit Group",
GroupCreator = mainUser.Id,
Users = users.ToList()
};
var groups = new List <Group>()
{
mainGroup
}.AsQueryable();
var mainEvent = new Event
{
Id = 1,
CreatedOn = DateTime.Now,
EventCreator = mainUser,
EventName = "Unit Event",
Group = mainGroup,
Teams = teams.ToList()
};
var events = new List <Event>()
{
mainEvent
}.AsQueryable();
var notifications = new List <Notification>().AsQueryable();
var mockContext = new Mock <Context>();
var mockTeams = MockHelper.MockDbSet(teams);
mockContext.SetupGet(c => c.EventTeams).Returns(mockTeams.Object);
var mockEvents = MockHelper.MockDbSet(events);
mockContext.SetupGet(c => c.Events).Returns(mockEvents.Object);
var mockGroups = MockHelper.MockDbSet(groups);
mockContext.SetupGet(c => c.Groups).Returns(mockGroups.Object);
var mockUsers = MockHelper.MockDbSet(users);
mockContext.SetupGet(c => c.Users).Returns(mockUsers.Object);
var mockUserSkills1 = MockHelper.MockDbSet(userSkills1);
mockContext.SetupGet(c => c.UserSkills).Returns(mockUserSkills1.Object);
var mockUserSkills2 = MockHelper.MockDbSet(userSkills2);
mockContext.SetupGet(c => c.UserSkills).Returns(mockUserSkills2.Object);
var mockRatings = MockHelper.MockDbSet(ratings);
mockContext.SetupGet(c => c.Ratings).Returns(mockRatings.Object);
var controller = new EventController(mockContext.Object);
var vmTeamSizeBelowOne = new GenerateTeamsVM
{
TeamSize = 0,
EventId = mainEvent.Id
};
var vmAlgorithmTypeAverageTeams = new GenerateTeamsVM
{
TeamSize = 4,
EventId = mainEvent.Id,
AlgorithmType = Helpers.Enums.AlgorithmType.AverageTeams
};
var vmAlgorithmTypeBestTeam = new GenerateTeamsVM
{
TeamSize = 4,
EventId = mainEvent.Id,
AlgorithmType = Helpers.Enums.AlgorithmType.BestTeam
};
// Act
ViewResult resultTeamSizeBelowOne = controller.GenerateTeams(vmTeamSizeBelowOne) as ViewResult;
//RedirectToRouteResult resultAlgorithmTypeAverageTeams = controller.GenerateTeams(vmAlgorithmTypeAverageTeams) as RedirectToRouteResult;
//RedirectToRouteResult resultAlgorithmTypeBestTeam = controller.GenerateTeams(vmAlgorithmTypeBestTeam) as RedirectToRouteResult;
// Assert
Assert.IsNotNull(resultTeamSizeBelowOne);
//Assert.IsNotNull(resultAlgorithmTypeAverageTeams); TODO: Remove or fix unit test
//Assert.IsNotNull(resultAlgorithmTypeBestTeam); TODO: Remove or fix unit test
}
public virtual void Init()
{
MockHelper = new MockHelper();
}
public void TermController_GetTerm_Returns_Null_On_InValidTermId()
{
//Arrange
var mockDataService = new Mock <IDataService>();
mockDataService.Setup(ds => ds.GetTerm(Constants.TERM_InValidTermId)).Returns(MockHelper.CreateEmptyTermReader());
var termController = new TermController(mockDataService.Object);
//Act
Term term = termController.GetTerm(Constants.TERM_InValidTermId);
//Assert
Assert.IsNull(term);
}
