public void StudentControllerGetSingleRecordTest()
{
//arrange
var mockRepository = Mock.Create<IRepository<Student>>();
var studentToAdd = new Student()
{
Age = 10,
Grade = 4,
FirstName = "Nikolay",
LastName = "Kostadinov",
};
IList<Student> studentEntities = new List<Student>();
studentEntities.Add(studentToAdd);
Mock.Arrange(() => mockRepository.All())
.Returns(() => studentEntities.AsQueryable());
var studentController = new StudentController(mockRepository);
var studentModels = studentEntities.AsQueryable().Select(StudentDetailedModel.FormStudent).First();
var expected = studentModels;
//act
var actual = studentController.Get(0);
// assert
Assert.AreEqual(expected.FirstName, actual.FirstName);
}
public void ExecuteDynamicQueryObject()
{
var source = new List<Product>
{
new Product {Name = "NPatterns", Version = 1.2},
new Product {Name = "NPatterns.Messaging.IoC",Version = 1.1},
new Product {Name = "NPatterns.ObjectRelational.EF",Version = 1.0},
new Product {Name = null,Version = 0}
};
var query = new QueryObject(new DynamicQueryObjectExecutor());
query.Add(new Criteria { Field = "Name", Operator = CriteriaOperator.IsNotNull });
var criteriaGroup = new CriteriaGroup { Operator = CriteriaGroupOperator.Or };
criteriaGroup.Criterias.Add(new Criteria { Field = "Name", Operator = CriteriaOperator.IsEqualTo, Value = "npatterns" });
criteriaGroup.Criterias.Add(new Criteria { Field = "Name", Operator = CriteriaOperator.EndsWith, Value = "ioc" });
query.Add(criteriaGroup);
query.Add(new SortDescription { Field = "Version", Direction = SortDirection.Ascending });
var result = query.Execute(source.AsQueryable()).ToList();
Assert.AreEqual(2, result.Count);
Assert.IsTrue(result[0].Version < result[1].Version);
query.Add(new Criteria { Field = "Version", Operator = CriteriaOperator.IsEqualTo, Value = 1.0 }, CriteriaGroupOperator.Or);
var result2 = query.Execute(source.AsQueryable()).ToList();
Assert.AreEqual(3, result2.Count);
}
/// <summary>
/// Tests patient and appointment lists.
/// </summary>
/// <param name="appts">List of appointments to substitute in our mockup.</param>
/// <param name="patients">List of patients to substitute in our mockup.</param>
/// <param name="compare_date">The date to compare in our mockup.</param>
/// <returns></returns>
private static IEnumerable<Transaction> TestPatientsAndAppointments(
List<appointment_data> appts,
List<patient_data> patients,
DateTime compare_date)
{
var mock_appts = new Mock<DbSet<appointment_data>>();
mock_appts.As<IQueryable<appointment_data>>().Setup(m => m.Provider)
.Returns(appts.AsQueryable<appointment_data>().Provider);
mock_appts.As<IQueryable<appointment_data>>().Setup(m => m.Expression)
.Returns(appts.AsQueryable<appointment_data>().Expression);
mock_appts.As<IQueryable<appointment_data>>().Setup(m => m.ElementType)
.Returns(appts.AsQueryable<appointment_data>().ElementType);
mock_appts.As<IQueryable<appointment_data>>().Setup(m => m.GetEnumerator())
.Returns(appts.AsQueryable<appointment_data>().GetEnumerator());
var mock_patients = new Mock<DbSet<patient_data>>();
mock_patients.As<IQueryable<patient_data>>().Setup(m => m.Provider)
.Returns(patients.AsQueryable<patient_data>().Provider);
mock_patients.As<IQueryable<patient_data>>().Setup(m => m.Expression)
.Returns(patients.AsQueryable<patient_data>().Expression);
mock_patients.As<IQueryable<patient_data>>().Setup(m => m.ElementType)
.Returns(patients.AsQueryable<patient_data>().ElementType);
mock_patients.As<IQueryable<patient_data>>().Setup(m => m.GetEnumerator())
.Returns(patients.AsQueryable<patient_data>().GetEnumerator());
var fake_entities = new Mock<broadlyEntities>();
fake_entities.Setup(c => c.appointment_data).Returns(mock_appts.Object);
fake_entities.Setup(c => c.patient_data).Returns(mock_patients.Object);
IEnumerable<Transaction> transactions = DataSource.GetTransactions(compare_date, fake_entities.Object);
Assert.IsNotNull(transactions);
Assert.IsTrue(transactions is IQueryable);
Assert.IsTrue(transactions is IQueryable<Transaction>);
foreach (Transaction transaction in transactions)
{
// There is an email
Assert.IsTrue(!string.IsNullOrEmpty(transaction.PatientEmail));
// The appoinment time matches
Assert.IsTrue(transaction.AppointmentTime == compare_date);
// There is a transaction with this Id
appointment_data appt = appts.Find(x => x.appointment_id == transaction.AppointmentId);
Assert.IsNotNull(appt);
// There is a patient with the appt's Id
patient_data patient = patients.Find(x => x.patient_id == appt.patient_id);
Assert.IsNotNull(patient);
// Check content
Assert.IsTrue(transaction.AppointmentId == appt.appointment_id);
Assert.IsTrue(transaction.AppointmentTime == appt.scheduled);
Assert.IsTrue(appt.status == "completed");
Assert.IsTrue(transaction.PatientFirstName == patient.first_name);
Assert.IsTrue(transaction.PatientLastName == patient.last_name);
Assert.IsTrue(transaction.PatientId == patient.patient_id);
Assert.IsTrue(transaction.PatientPhone == patient.phone);
}
return transactions;
}
public void EnsureICanDeleteLessonTest()
{
//Arrange
List<Lesson> my_list = new List<Lesson>();
Mock<CContext> mock_context = new Mock<CContext>();
Mock<DbSet<Teacher>> mock_teacher = new Mock<DbSet<Teacher>>();
Mock<DbSet<Student>> mock_student = new Mock<DbSet<Student>>();
Mock<DbSet<Payment>> mock_payment = new Mock<DbSet<Payment>>();
Mock<DbSet<Lesson>> mock_lesson = new Mock<DbSet<Lesson>>();
var data = my_list.AsQueryable();
mock_lesson.As<IQueryable<Lesson>>().Setup(m => m.Provider).Returns(data.Provider);
mock_lesson.As<IQueryable<Lesson>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
mock_lesson.As<IQueryable<Lesson>>().Setup(m => m.ElementType).Returns(data.ElementType);
mock_lesson.As<IQueryable<Lesson>>().Setup(m => m.Expression).Returns(data.Expression);
mock_lesson.Setup(m => m.Add(It.IsAny<Lesson>())).Callback((Lesson b) => my_list.Add(b));
mock_lesson.Setup(m => m.Remove(It.IsAny<Lesson>())).Callback((Lesson b) => my_list.Remove(b));
mock_context.Setup(m => m.Lessons).Returns(mock_lesson.Object);
Repository Repo = new Repository(mock_context.Object);
my_list.Add(new Lesson { LessonId = 1, Title = "Private" });
//Act
bool Success = Repo.DeleteLesson(1);
//Assert
Assert.AreEqual(0, Repo.Context.Lessons.Count());
}
public void DeleteMethodShouldReturnProperAnswerModel()
{
var user3 = new ApplicationUser() { Id = "3asdfasdfgahasre", UserName = "******" };
var cat = new Category() { CategoryId = 10, AgeRating=AgeRating.Mature, Name="Category 1" };
List<ApplicationUser> users = new List<ApplicationUser> { new ApplicationUser() { Id = "1asdfasdfgahasre" } };
var quest = new Question() { QuestionId = 10, Creator = user3, Category = cat, Title = "Q Title", Text = "Q Text", IsApproved = true, DateAsked = DateTime.Now };
var list = new List<Answer>();
for (int i = 1; i < 6; i++)
{
list.Add(new Answer()
{
AnswerId = i,
Comment = "Comment" + i,
User = new ApplicationUser() { Id = "1asdfasdfgahasre", UserName = "******" },
DateAnswered = DateTime.Now,
Question = quest,
IsRead = true, IsReported=true, IsVoted=false,
});
}
var ansRepoMock = new Mock<IRepository<Answer>>();
ansRepoMock.Setup(ur => ur.All()).Returns(list.AsQueryable());
var uofMock = new Mock<IUowData>();
uofMock.Setup(x => x.Answers).Returns(() => { return ansRepoMock.Object; });
var controller = new AnswersController(uofMock.Object);
var viewResult = controller.Delete(2) as ViewResult;
var model = viewResult.Model;
var modelAsAM = model as AnswerView;
Assert.IsNotNull(modelAsAM, "Delete action returns null.");
Assert.IsNotNull(model, "The model is null.");
}
public void ToGoogleDataTable()
{
var list = new List<Custom1>();
list.Add(new Custom1()
{
Property1 = "foo1",
Property2 = 7
});
list.Add(new Custom1()
{
Property1 = "foo2",
Property2 = 14
});
list.Add(new Custom1()
{
Property1 = "foo3",
Property2 = 21
});
var table = list.AsQueryable().ToGoogleDataTable();
Assert.IsNotNull(table);
Assert.AreEqual(3, table.Rows.Count);
Assert.AreEqual(2, table.Columns.Count);
var firstCol = table.Columns.First();
Assert.AreEqual("Property1", firstCol.Id);
Assert.AreEqual(ColumnDataType.String, firstCol.DataType);
var firstRow = table.Rows.First();
Assert.AreEqual(2, firstRow.Cells.Count);
Assert.AreEqual("foo1", firstRow.Cells.First().Value);
}
public void Before_Each_Test()
{
console = MockRepository.GenerateMock<IConsoleFacade>();
repository = MockRepository.GenerateMock<IRepository<GameObject>>();
player = MockRepository.GenerateMock<IPlayer>();
dbPlayer = new GameObject() { GameObjectId = 3, Location = dbHallway, Location_Id = 8, Description = "Just some dude." };
player.Stub(qq => qq.Id).Return(3);
dbHallway = new GameObject() { Name = "Hallway", Description = " It's a hallway", GameObjectId = 8 };
dbBall = new GameObject() { Name = "Ball", Description = "A shiny rubber ball", Location = dbPlayer, Location_Id = 3 };
dbRing = new GameObject() { Name = "Ring", Description = "A simple gold ring", Location = dbHallway, Location_Id = 8 };
dbExit = new GameObject() {Name = "Exit", Description ="", Location= dbHallway, Location_Id = 8, GameObjectId = 16, Type = "Exit", Destination = 8 };
dbPlayer.Inventory.Add(dbBall);
dbHallway.Inventory.Add(dbPlayer);
dbHallway.Inventory.Add(dbRing);
dbHallway.Inventory.Add(dbExit);
dbList = new List<GameObject>() { dbPlayer, dbBall, dbRing, dbExit, dbHallway };
repository.Stub(qq => qq.AsQueryable()).Return(dbList.AsQueryable());
exit = new ExitAlias() { AliasId = 2, ExitId = 16, Alais = "North" };
exit2 = new ExitAlias() { AliasId = 2, ExitId = 16, Alais = "Hall" };
dbExit.ExitAliases.Add(exit);
dbExit.ExitAliases.Add(exit2);
aliasList = new List<ExitAlias> { exit, exit2 };
}
public void AddWhenAssignmentIsValidShouldAddAssignment()
{
var repository = Mock.Create<ITwsData>();
var assignmentEntity = Entities.GetValidAssignment();
var teamWorkEntity = Entities.GetValidTeamWork();
teamWorkEntity.Assignments.Add(assignmentEntity);
IList<TeamWork> teamworkEntities = new List<TeamWork>();
teamworkEntities.Add(teamWorkEntity);
IList<Assignment> assignmentEntities = new List<Assignment>();
assignmentEntities.Add(assignmentEntity);
Mock.Arrange(() => repository.Assignments.All())
.Returns(() => assignmentEntities.AsQueryable());
Mock.Arrange(() => repository.TeamWorks.All())
.Returns(() => teamworkEntities.AsQueryable());
var controller = new AssignmentController(repository);
var assignmentModels = controller.ByTeamwork(0);
var negotiatedResult = assignmentModels as OkNegotiatedContentResult<IQueryable<AssignmentModel>>;
Assert.IsNotNull(negotiatedResult);
Assert.AreEqual<string>(assignmentEntity.Name, negotiatedResult.Content.FirstOrDefault().Name);
}
public void Can_Get_Details()
{
// Arrange
// - create the mock repository
Mock<IEventStore> mock = new Mock<IEventStore>();
var allEvents = new List<IEvent<IIdentity>>()
{
new ProductAddedToOrder() {Id = new OrderId(777), Date = DateTime.Now, Version = 1},
new ProductAddedToOrder() {Id = new OrderId(777), Date = DateTime.Now, Version = 3},
new ProductAddedToOrder() {Id = new OrderId(777), Date = DateTime.Now, Version = 5}
};
mock.Setup(m => m.GetEventsForAggregate<IIdentity>(It.IsAny<IIdentity>())).Returns(allEvents.AsQueryable());
// create instance of a controller
EventViewerController controller = new EventViewerController(mock.Object);
// Action: try to find event with Version = 3
string result = (string)((ViewResultBase)controller.Details("777", 3)).ViewData["EventDetails"];
// Assert
Assert.IsTrue(result.Length > 0);
Assert.IsTrue(result.Contains("\"Version\": 3,"));
}
public void AddBug_WhenBugTextIsValid_ShouldBeAddedToRepoWithLogDateAndStatusPending()
{
var bugs = new List<Bug>();
var bug = new BugModel()
{
Text = "NEW TEST BUG"
};
var data = Mock.Create<IBugLoggerData>();
Mock.Arrange(() => data.Bugs.All())
.Returns(() => bugs.AsQueryable());
Mock.Arrange(() => data.SaveChanges())
.DoInstead(() => bugs.Add(new Bug() { Text = "NEW TEST BUG" }));
var controller = new BugsController(data);
this.SetupController(controller);
//act
controller.PostBug(bug);
//assert
Assert.AreEqual(data.Bugs.All().Count(), 1);
var bugInDb = data.Bugs.All().FirstOrDefault();
Assert.AreEqual(bug.Text, bugInDb.Text);
Assert.IsNotNull(bugInDb.LogDate);
Assert.AreEqual(Status.Pending, bugInDb.Status);
}
public void Notification_On_Event_Cancelled()
{
//Arrange
var theHost = new Person { PersonId = 3, FirstName = "Matt", LastName = "Harmin" };
var peopleList = new List<Person>
{
new Person {PersonId = 1, FirstName = "Joe", LastName = "Smith" },
new Person {PersonId = 2, FirstName = "Sally", LastName = "Hardy" },
};
var theEvent = new Event
{
EventId = 1,
Title = "My Test Event",
StartDate = DateTime.Now,
Coordinator = theHost,
RegisteredInvites = peopleList
};
A.CallTo(() => EventRepo.GetAll()).Returns(new List<Event> { theEvent }.AsQueryable());
A.CallTo(() => PersonRepo.GetAll()).Returns(peopleList.AsQueryable());
A.CallTo(() => InvitationRepo.GetAll()).Returns(new List<PendingInvitation>().AsQueryable());
//Act
var notification = NotifyService.GetNotificationForEventCancelled(theEvent.EventId, 1, 0);
//Assert
string hostName = string.Format("{0} {1}", theHost.FirstName, theHost.LastName);
string expectedMessage = string.Format(Constants.MESSAGE_CANCELLED_TEMPLATE, theEvent.Title,
hostName);
Assert.AreEqual(notification.Title, Constants.MESSAGE_CANCELLED_TITLE);
Assert.AreEqual(notification.Message, expectedMessage);
}
public void Notification_On_Attendee_Removed()
{
//Arrange
var theHost = new Person { PersonId = 3, FirstName = "Matt", LastName = "Harmin" };
var thePerson = new Person{PersonId = 1, FirstName = "Joe", LastName = "Smith", NotifyWithFacebook = true, NotifyWithEmail = false};
var theEvent = new Event { EventId = 1, Title = "My Test Event", StartDate = DateTime.Now, Coordinator = theHost };
var personList = new List<Person>{thePerson};
var eventList = new List<Event>{theEvent};
A.CallTo(() => PersonRepo.GetAll()).Returns(personList.AsQueryable());
A.CallTo(() => EventRepo.GetAll()).Returns(eventList.AsQueryable());
A.CallTo(() => InvitationRepo.GetAll()).Returns(new List<PendingInvitation>().AsQueryable());
//Act
var notification = NotifyService.GetPersonRemovedFromEventNotification(theEvent.EventId, thePerson.PersonId, 0);
//Assert
string hostName = string.Format("{0} {1}", theHost.FirstName, theHost.LastName);
string expectedMessage = string.Format(Constants.MESSAGE_REMOVE_TEMPLATE, hostName,
theEvent.Title, theEvent.StartDate.ToShortDateString(),
theEvent.StartDate.ToShortTimeString());
Assert.AreEqual(notification.SendToEmail, personList[0].NotifyWithEmail);
Assert.AreEqual(notification.SendToFacebook, personList[0].NotifyWithFacebook);
Assert.AreEqual(notification.Title, Constants.MESSAGE_REMOVE_TITLE);
Assert.AreEqual(notification.Message, expectedMessage);
}
public void HasPermission_AuthorAccessingControllerPermissionExplicitlyDenied_False()
{
// ARRANGE
List<RolePermission> rolePermissions = new List<RolePermission>
{
new RolePermission
{
Controller = "LookupTypes",
Action = string.Empty,
Role = "Author",
IsAllowed = false
},
new RolePermission
{
Controller = "Assets",
Action = "Delete",
Role = "Viewer",
IsAllowed = true
},
};
PermissionHelper permissionHelper = new PermissionHelper(rolePermissions.AsQueryable());
// ACT
bool hasPermission = permissionHelper.HasPermission(EnumHelper.Roles.Author, "LookupTypes", "Delete");
// ASSERT
Assert.IsFalse(hasPermission);
}
public void HasPermission_Admin_True()
{
// ARRANGE
List<RolePermission> rolePermissions = new List<RolePermission>
{
new RolePermission
{
Controller = "LookupTypes",
Action = "Index",
Role = "Admin"
},
new RolePermission
{
Controller = "LookupTypes",
Action = "Detail",
Role = "Admin"
}
};
PermissionHelper permissionHelper = new PermissionHelper(rolePermissions.AsQueryable());
// ACT
bool hasPermission = permissionHelper.HasPermission(EnumHelper.Roles.Admin, "LookupTypes", "Index");
// ASSERT
Assert.IsTrue(hasPermission);
}
public UserSpecTests()
{
var users = new List<User>();
users.Add(new User("andrebaltieri", "andrebaltieri"));
_users = users.AsQueryable();
}
public void GivenThatPageIsSecondOne_WhenCreatingPagedList_ThenPreviousPageNumberIsOne()
{
var superset = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var pagedList = new PagedList<int>(superset.AsQueryable(), 2, 1);
Assert.AreEqual(1, pagedList.PreviousPageNumber.Value);
}
public void TestIndexMethod()
{
var users = new List<ApplicationUser> {
new ApplicationUser {
FirstName = "Tom",
LastName = "Michaelson",
UserName = "******"
},
new ApplicationUser {
FirstName = "Frank",
LastName = "Stromdahl",
UserName = "******"
},
new ApplicationUser {
FirstName = "Ed",
LastName = "Cantata",
UserName = "******"
}
};
var mockRepo = new Mock<IRepository>();
mockRepo.Setup(mock => mock.Query<ApplicationUser>()).Returns(users.AsQueryable());
var homeController = new HomeController(mockRepo.Object);
var results = homeController.Index() as ViewResult;
var model = results.Model as IList<ApplicationUser>;
Assert.AreEqual("Ed", model.First().FirstName);
}
public void TestSomeWorkToResume()
{
using (Microsoft.QualityTools.Testing.Fakes.ShimsContext.Create())
{
int counterDelete = 0;
int counterSaveC = 0;
PdfConversion.Server.DataService.Fakes.ShimFileStatusRepositoryFactory.GetRepository = () =>
{
var shim = new PdfConversion.Server.DataService.Fakes.StubIRepository<FileStatusEntity>();
shim.SaveChanges = () => { counterSaveC++; };
shim.DeleteT0 = ent => { counterDelete++; };
shim.SearchForExpressionOfFuncOfT0Boolean = a =>
{
var ls = new List<FileStatusEntity>();
for(int i =0;i<10;i++)
ls.Add(new FileStatusEntity());
return ls.AsQueryable<FileStatusEntity>();
};
return shim;
};
int counterMoves = 0;
System.IO.Fakes.ShimFile.MoveStringString = (a, b) => { counterMoves++; };
WorkResumer resumer = new WorkResumer("folfer", "temp", "title", "author");
resumer.Resume();
Assert.IsTrue(counterMoves == 10);
Assert.IsTrue(counterDelete == 10);
Assert.IsTrue(counterSaveC == 1);
}
}
public void Can_Paginate()
{
// Arrange
// create the mock repository
Mock<IEventStore> mock = new Mock<IEventStore>();
var allEvents = new List<IEvent<IIdentity>>()
{
new UserCreated(new UserId("*****@*****.**")) {Version = 1, Date = DateTime.Now},
new UserCreated(new UserId("*****@*****.**")) {Version = 2, Date = DateTime.Now},
new UserCreated(new UserId("*****@*****.**")) {Version = 3, Date = DateTime.Now},
new UserCreated(new UserId("*****@*****.**")) {Version = 4, Date = DateTime.Now},
new UserCreated(new UserId("*****@*****.**")) {Version = 5, Date = DateTime.Now}
};
mock.Setup(m => m.GetEventsForAggregate<IIdentity>(It.IsAny<IIdentity>())).Returns(allEvents.AsQueryable());
// create instance of a controller; set the page size
EventViewerController controller = new EventViewerController(mock.Object);
controller.PageSize = 3;
// Action
EventViewerViewModel result = (EventViewerViewModel)((ViewResultBase)controller.Index("1", null, 2)).Model;
// Assert
EventViewModel[] eventArray = result.Events.ToArray();
Assert.IsTrue(eventArray.Length == 2);
Assert.AreEqual(eventArray[0].EventVersion, 4);
Assert.AreEqual(eventArray[1].EventVersion, 5);
}
public void GetAllIssuesTest()
{
Mock<IProjectRepository> fakeProjectRepo = new Mock<IProjectRepository>();
Mock<IIssueRepository> fakeIssueRepo = new Mock<IIssueRepository>();
Mock<IStateWorkflowRepository> fakeStateWorkflowRepo = new Mock<IStateWorkflowRepository>();
Mock<ICommentRepository> fakeCommentRepo = new Mock<ICommentRepository>();
var issueService = new IssueService(fakeIssueRepo.Object, fakeCommentRepo.Object);
var firstIssueId = Guid.NewGuid();
var secondIssueId = Guid.NewGuid();
var thirdIssueId = Guid.NewGuid();
var fourthIssueId = Guid.NewGuid();
var firstIssue = new Issue() { Active = true, CodeNumber = 1, Description = "firstIssue", Id = firstIssueId, Name = "first", Type = Entities.IssueType.Bug };
var secondIssue = new Issue() { Active = true, CodeNumber = 2, Description = "secondIssue", Id = firstIssueId, Name = "second", Type = Entities.IssueType.Task };
var thirdIssue = new Issue() { Active = true, CodeNumber = 3, Description = "thirdIssue", Id = firstIssueId, Name = "third", Type = Entities.IssueType.Question };
var fourthIssue = new Issue() { Active = true, CodeNumber = 4, Description = "fourthIssue", Id = firstIssueId, Name = "fourth", Type = Entities.IssueType.Bug };
List<Issue> issues = new List<Issue>()
{
firstIssue,secondIssue,thirdIssue,fourthIssue
};
fakeIssueRepo.Setup(i => i.Fetch()).Returns(issues.AsQueryable());
var actual = issueService.GetAllIssues();
Assert.AreEqual(actual.Count, 4);
}
public void AssignClusterCoordinator_appends_a_ClusterCoordinatorLogEntry()
{
var clusterCoordinator = new ClusterCoordinator
{
Id = 1,
DisasterId = _disaster.Id,
ClusterId = _cluster.Id,
PersonId = _person.Id,
Person = _person,
Cluster = _cluster,
Disaster = _disaster
};
var coordinatorList = new List<ClusterCoordinator>();
_dataService.Setup(x => x.ClusterCoordinators).Returns(coordinatorList.AsQueryable());
_dataService.Setup(
x => x.AddClusterCoordinator(It.Is<ClusterCoordinator>(cc => cc.DisasterId == _disaster.Id &&
cc.ClusterId == _cluster.Id &&
cc.PersonId == _person.Id)))
.Callback(() => coordinatorList.Add(clusterCoordinator));
_clusterCoordinatorService.AssignClusterCoordinator(clusterCoordinator.DisasterId, clusterCoordinator.ClusterId, clusterCoordinator.PersonId);
_dataService.Verify(x => x.AddClusterCoordinator(It.IsAny<ClusterCoordinator>()), Times.Once());
_dataService.Verify(x => x.AppendClusterCoordinatorLogEntry(
It.Is<ClusterCoordinatorLogEntry>(cc => cc.DisasterId == clusterCoordinator.DisasterId &&
cc.DisasterName == clusterCoordinator.Disaster.Name &&
cc.ClusterId == clusterCoordinator.ClusterId &&
cc.ClusterName == clusterCoordinator.Cluster.Name &&
cc.PersonId == clusterCoordinator.PersonId &&
cc.PersonName == clusterCoordinator.Person.FullName &&
cc.Event == ClusterCoordinatorEvents.Assigned)));
}
public void GetByProjectCodeAndIssueNumberTest()
{
Mock<IProjectRepository> fakeProjectRepo = new Mock<IProjectRepository>();
Mock<IIssueRepository> fakeIssueRepo = new Mock<IIssueRepository>();
Mock<IStateWorkflowRepository> fakeStateWorkflowRepo = new Mock<IStateWorkflowRepository>();
Mock<ICommentRepository> fakeCommentRepo = new Mock<ICommentRepository>();
var issueService = new IssueService(fakeIssueRepo.Object, fakeCommentRepo.Object);
var firstProject = new Project() { Code = "COD"};
var secodProject = new Project() { Code = "COP" };
var firstIssueId = Guid.NewGuid();
var secondIssueId = Guid.NewGuid();
var thirdIssueId = Guid.NewGuid();
var fourthIssueId = Guid.NewGuid();
var firstIssue = new Issue() { Active = true, CodeNumber = 1, Description = "firstIssue", Id = firstIssueId, Name = "first", Type = Entities.IssueType.Bug, Project = firstProject };
var secondIssue = new Issue() { Active = true, CodeNumber = 2, Description = "secondIssue", Id = firstIssueId, Name = "second", Type = Entities.IssueType.Task, Project = secodProject };
var thirdIssue = new Issue() { Active = true, CodeNumber = 3, Description = "thirdIssue", Id = firstIssueId, Name = "third", Type = Entities.IssueType.Question, Project = secodProject };
var fourthIssue = new Issue() { Active = true, CodeNumber = 4, Description = "fourthIssue", Id = firstIssueId, Name = "fourth", Type = Entities.IssueType.Bug, Project = secodProject };
List<Issue> issues = new List<Issue>()
{
firstIssue,secondIssue,thirdIssue,fourthIssue
};
fakeIssueRepo.Setup(i => i.Fetch()).Returns(issues.AsQueryable());
var actual = issueService.GetByProjectCodeAndIssueNumber("COD", 1);
var expected = firstIssue;
Assert.AreEqual(expected, actual);
}
public void QueryableExtensions_Test_ToPage()
{
IList<User> list = new List<User>();
list.Add(new User(){Id = 1,Name = "zhangsan1",Age = 18,Address = "四川"});
list.Add(new User() { Id = 2, Name = "zhangsan2", Age = 18, Address = "四川" });
list.Add(new User() { Id = 3, Name = "zhangsan3", Age = 18, Address = "四川" });
list.Add(new User() { Id = 4, Name = "zhangsan4", Age = 18, Address = "四川" });
list.Add(new User() { Id = 5, Name = "zhangsan5", Age = 18, Address = "四川" });
IQueryable<User> query = list.AsQueryable();
PagedResult<User> page = query.ToPage<User>();
PagedResult<User> page1 = query.ToPage<User>(new Pager(1,1));
SortCondition[] sort = new SortCondition[] { new SortCondition<User>(o => o.Id, ListSortDirection.Descending) };
PagedResult<User> page2 = query.ToPage<User>(o=>o.Name.Contains("zhangsan"), new Pager(1, 1, sort));
Assert.AreEqual(list.Count, page.Data.Count);
Assert.AreEqual(1, page1.Data.Count);
Assert.AreEqual(1, page2.Data.Count);
Assert.AreEqual(5, page2.Data.First().Id);
var entity = query.FirstOrDefault();
var entity1 = query.FirstOrDefault(o => o.Age == 20);
var entity2 = query.Single();
}
public void Index()
{
// DBのモックを用意する
var mockset = new Mock<DbSet<BoardEntity>>();
var mockcontext = new Mock<BoardDbContext>();
var originalData = new List<BoardEntity> {
new BoardEntity { Id = 1, Title = "A", Text = "a" },
new BoardEntity { Id = 2, Title = "B", Text = "b" },
new BoardEntity { Id = 3, Title = "C", Text = "c" },
};
var data = originalData.AsQueryable();
// 各メソッドの返り値をモックに差し替える
mockset.As<IQueryable<BoardEntity>>().Setup( m => m.Provider ).Returns( data.Provider );
mockset.As<IQueryable<BoardEntity>>().Setup( m => m.Expression ).Returns( data.Expression );
mockset.As<IQueryable<BoardEntity>>().Setup( m => m.ElementType ).Returns( data.ElementType );
mockset.As<IQueryable<BoardEntity>>().Setup( m => m.GetEnumerator() ).Returns( data.GetEnumerator() );
mockcontext.Setup( m => m.Boards ).Returns( mockset.Object );
var controller = new BoardController( mockcontext.Object );
ViewResult result = controller.Index() as ViewResult;
// モデルのデータがちゃんとDBのデータを取得出来ているか検証
var model = result.Model as BoardListModel;
Assert.AreSame( originalData[0], model.Boards[0] );
Assert.AreSame( originalData[1], model.Boards[1] );
Assert.AreSame( originalData[2], model.Boards[2] );
Assert.IsNotNull( result );
}
public void Initialize()
{
//Initialize_data
User user1 = new User() { Id = 1, Email = "123", CreatedTime = DateTime.Now, Name = "user1", NickName = "梁贵", Password = "******", };
User user2 = new User() { Id = 2, Email = "123", CreatedTime = DateTime.Now, Name = "user2", NickName = "梁贵2", Password = "******", };
_users = new List<User> { user1, user2 };
Role role1 = new Role() { Id = 1, Name = "role1", Remark = "role1" };
Role role2 = new Role() { Id = 2, Name = "role2", Remark = "role2" };
_roles = new List<Role> { role1, role2 };
user1.Roles = _roles;
//Initialize_interface
_unitOfWork = Substitute.For<IUnitOfWork>();
_identityService = Substitute.For<IdentityService>(_unitOfWork);
_userRepository = Substitute.For<IRepository<User, int>>();
_roleRepository = Substitute.For<IRepository<Role, int>>();
_userRepository.GetByKey(Arg.Any<int>()).ReturnsForAnyArgs(x => _users.Find(r => r.Id == (int)x[0]));
_userRepository.Entities.Returns(_users.AsQueryable());
_roleRepository.Entities.Returns(_roles.AsQueryable());
_roleRepository.GetByKey(Arg.Any<int>()).Returns(x => _roles.Find(r => r.Id == (int)x[0]));
_identityService.UserRepository.Returns(_userRepository);
_identityService.RoleRepository.Returns(_roleRepository);
}
public void GetManagementUriSucceeds()
{
// Arrange
var managementUriName = SchedulerAppSettings.Keys.EXTERNAL_WORKFLOW_MANAGEMENT_URI_NAME;
var managementUri = new ManagementUri()
{
Id = 42
,
Name = managementUriName
,
ManagementCredentialId = 5
};
var managementUris = new List<ManagementUri>()
{
managementUri
};
var dataServiceQuery = Mock.Create<DataServiceQuery<ManagementUri>>();
Mock.Arrange(() => dataServiceQuery.Where(e => e.Name == managementUriName))
.IgnoreInstance()
.Returns(managementUris.AsQueryable())
.MustBeCalled();
var sut = new ActivitiPluginConfigurationManager();
// Act
var result = sut.GetManagementUri(dataServiceQuery, managementUriName);
// Assert
Assert.AreEqual(managementUriName, result.Name);
}
public void IndexMethodShouldReturnProperNumberOfAnswers()
{
List<ApplicationUser> users = new List<ApplicationUser> { new ApplicationUser() { Id = "1asdfasdfgahasre" } };
var list = new List<Answer>();
for (int i = 1; i < 6; i++)
{
list.Add(new Answer()
{
AnswerId = i,
Comment = "Comment" + i,
User = new ApplicationUser() { Id = "1asdfasdfgahasre" },
DateAnswered = DateTime.Now,
Question = new Question() { QuestionId = i+10},
IsRead = true,
});
}
var ansRepoMock = new Mock<IRepository<Answer>>();
ansRepoMock.Setup(x => x.All()).Returns(list.AsQueryable());
var uofMock = new Mock<IUowData>();
uofMock.Setup(x => x.Answers).Returns(() => { return ansRepoMock.Object; });
var controller = new AnswersController(uofMock.Object);
var viewResult = controller.Index() as ViewResult;
var model = viewResult.Model;
var modelAsIenum = model as IEnumerable<TellToAsk.Areas.Administration.Models.AnswerModel>;
Assert.IsNotNull(viewResult, "Index action returns null.");
Assert.IsNotNull(model, "The model is null.");
Assert.AreEqual(5, modelAsIenum.Count());
}
public void TestConversionServiceErroneousResponseFromDataService()
{
ConversionService serv = new ConversionService();
using (Microsoft.QualityTools.Testing.Fakes.ShimsContext.Create())
{
PdfConversion.Server.DataService.Fakes.ShimFileStatusRepositoryFactory.GetRepository = () =>
{
var shim = new PdfConversion.Server.DataService.Fakes.StubIRepository<FileStatusEntity>();
shim.SaveChanges = () => { };
shim.SearchForExpressionOfFuncOfT0Boolean = a =>
{
var ls = new List<FileStatusEntity>();
var entity = new FileStatusEntity();
entity.FileState = FileState.Erroneous;
ls.Add(entity);
return ls.AsQueryable<FileStatusEntity>();
};
return shim;
};
var status = serv.GetFileState("test");
Assert.IsTrue(status == PdfConversionService.API.FileState.Erroneous);
}
}
public void GetById_WhenOneStudentMatchTheId_ShouldReturnStatusCode200AndOneStudent()
{
var mockRepository = Mock.Create<IRepository<Student>>();
var models = new List<Student>();
models.Add(new Student()
{
StudentId = 1,
FirstName = "Peter",
LastName = "Petrov",
Grade = 5,
Age = 18,
});
Mock.Arrange(() => mockRepository.Get(1))
.Returns(() => models.AsQueryable().Where(s=>s.StudentId ==1).FirstOrDefault());
var server = new InMemoryHttpServer<Student>("http://localhost/",
mockRepository);
var response = server.CreateGetRequest("api/students/1");
var content = JsonConvert.DeserializeObject<Student>((response.Content.ReadAsStringAsync().Result));
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.IsTrue(content.StudentId == 1);
}
public void GivenThatPageIsFirstOne_WhenCreatingPagedList_ThenPreviousPageNumberIsNull()
{
var superset = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var pagedList = new PagedList<int>(superset.AsQueryable(), 1, 1);
Assert.IsNull(pagedList.PreviousPageNumber);
}
