private LoggedUserModel RegisterTestUser(InMemoryHttpServer httpServer, UserModel testUser)
{
var response = httpServer.Post("api/users/register", testUser);
var contentString = response.Content.ReadAsStringAsync().Result;
var userModel = JsonConvert.DeserializeObject<LoggedUserModel>(contentString);
return userModel;
}
public void PostStudent_WhenValid_ShouldReturnStatusCode201()
{
var mockRepository = Mock.Create<IRepository<Student>>();
Mock.Arrange(() => mockRepository
.Add(Arg.Matches<Student>(st => st.FirstName == "Pesho" && st.LastName == "Peshev")))
.Returns(
new Student()
{
FirstName = "Pesho",
LastName = "Peshev"
}
);
var server =
new InMemoryHttpServer<Student>("http://localhost/", mockRepository);
var response = server.CreatePostRequest("api/students",
new Student()
{
FirstName = "Pesho",
LastName = "Peshev",
});
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
}
public void GetStudents()
{
//var school = new School().AddSchoolToDatabase(
var mockRepository = Mock.Create<DbStudentRepository>();
bool added = false;
var student = new Student()
.AddFirstName("ivan")
.AddLastName("petkov")
.AddAge(8)
.AddGrade(2)
.AddSchoolId(1);
//IQueryable
Mock.Arrange(() => mockRepository.All())
.DoInstead(() => added = true)
.Returns((new Student[] {student, student}).AsQueryable());
var server = new InMemoryHttpServer<Student>("http://localhost/", mockRepository);
var responce = server.CreateGetRequest("api/students");
Assert.AreEqual(responce.StatusCode, HttpStatusCode.OK);
Assert.IsTrue(added);
}
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 GetAll_WhenOneStudent_ShouldReturnStatusCode200AndNotNullContent()
{
var mockRepository = Mock.Create<IRepository<Student>>();
var studentToAdd = new Student()
{
LastName = "Johnson",
Age = 20,
Grade = 12
};
IQueryable<Student> studentEntities = (new List<Student>() { studentToAdd }).AsQueryable();
Mock.Arrange(() => mockRepository.GetAll())
.Returns(() => studentEntities.AsQueryable());
var server = new InMemoryHttpServer<Student>("http://localhost/",
mockRepository);
var response = server.CreateGetRequest("api/students");
var str = response.Content.ReadAsStringAsync();
// The str.Results is an array in string form. When it is empty, it always return "[]" string,
// meaning that if it has content, its length is greater than 2. The approach shown in the lecture
// is not working - the Assert always passes.
Assert.IsTrue(str.Result.Length > 2);
}
public void GetAll_WhenMultipleStudents_ShouldReturnStatusCode200AndNotNullContent()
{
var mockRepository = Mock.Create<IRepository<Student>>();
var studentToAdd = new Student()
{
LastName = "Johnson",
Age = 20,
Grade = 12
};
var secondStudentToAdd = new Student()
{
LastName = "Davis",
Age = 16,
Grade = 10
};
IQueryable<Student> studentEntities = (new List<Student>() { studentToAdd, secondStudentToAdd }).AsQueryable();
Mock.Arrange(() => mockRepository.GetAll())
.Returns(() => studentEntities.AsQueryable());
var server = new InMemoryHttpServer<Student>("http://localhost/",
mockRepository);
var response = server.CreateGetRequest("api/students");
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
var str = response.Content.ReadAsStringAsync();
Assert.IsTrue(str.Result.Length > 2);
}
public void Add_Valid_ShouldReturnStatusCode200AndNotNullContent()
{
var mockUnitOfWork = Mock.Create<IUnitOfWork>();
School school = new School() { Location = "Location", Name = "Name" };
Student studentEntity = new Student()
{
FirstName = "Pesho",
LastName = "Peshov",
Age = 16,
Grade = 10,
School = school,
Marks = new List<Mark>() { new Mark() { Subject = "math", Value = 6 } }
};
bool isItemAdded = false;
Mock.Arrange(() => mockUnitOfWork.SchoolsRepository.Get(Arg.IsAny<int>()))
.Returns(school);
Mock.Arrange(() => mockUnitOfWork.StudentsRepository.Add(Arg.IsAny<Student>()))
.DoInstead(() => isItemAdded = true)
.Returns(studentEntity);
var server = new InMemoryHttpServer<Student>("http://localhost/", mockUnitOfWork);
var response = server.CreatePostRequest("api/students", studentEntity);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.IsTrue(isItemAdded);
Assert.IsNotNull(response.Content);
}
public void TestInit()
{
var type = typeof(UsersController);
tran = new TransactionScope();
var routes = new List <Route>
{
new Route(
"PostsApi",
"api/posts/{postId}/comment",
new { controller = "posts", action = "comment" }),
new Route(
"UsersApi",
"api/users/{action}",
new
{
controller = "users"
}),
new Route(
"DefaultApi",
"api/{controller}/{id}",
new { id = RouteParameter.Optional }),
};
this.httpServer = new InMemoryHttpServer("http://localhost/", routes);
}
private LoggedUserModel RegisterTestUser(InMemoryHttpServer httpServer, UserModel testUser)
{
var response = httpServer.Post("api/users/register", testUser);
var contentString = response.Content.ReadAsStringAsync().Result;
var userModel = JsonConvert.DeserializeObject <LoggedUserModel>(contentString);
return(userModel);
}
public void PostNewBugWithoutLogDateAndEmptyDescriptionShouldReturn400()
{
var bugLoggerData = this.MockUnitOfWorkForActionAll();
var bug = new CreateBugModel();
var server = new InMemoryHttpServer <Bug>(InMemoryServerUrl, bugLoggerData);
var response = server.CreatePostRequest("/api/Bugs/Create", bug);
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
}
public void GetAllWhenThereAreBugsInDatabaseShouldReturnStatus200AndNonEmptyContent()
{
var bugLoggerData = this.MockUnitOfWorkForActionAll();
var server = new InMemoryHttpServer <Bug>(InMemoryServerUrl, bugLoggerData);
var response = server.CreateGetRequest("/api/Bugs/All");
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.IsNotNull(response.Content);
}
public void OpenTransaction()
{
transaction = new TransactionScope();
httpServer = new InMemoryHttpServer("http://localhost/", new EfRepository<User>(new BlogSystemContext()), new HashSet<Route>()
{
new Route("UsersApi", "api/users/{action}", new { controller = "users" }),
new Route("DefaultApi", "api/{controller}/{id}", new { id = RouteParameter.Optional }),
});
}
public void GetAllWhenThereAreBugsInDatabaseShouldReturnStatus200AndNonEmptyContent()
{
var bugLoggerData = this.MockUnitOfWorkForActionAll();
var server = new InMemoryHttpServer<Bug>(InMemoryServerUrl, bugLoggerData);
var response = server.CreateGetRequest("/api/Bugs/All");
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.IsNotNull(response.Content);
}
public void OpenTransaction()
{
transaction = new TransactionScope();
httpServer = new InMemoryHttpServer("http://localhost/", new EfRepository <User>(new BlogSystemContext()), new HashSet <Route>()
{
new Route("UsersApi", "api/users/{action}", new { controller = "users" }),
new Route("DefaultApi", "api/{controller}/{id}", new { id = RouteParameter.Optional }),
});
}
public void Add_ValidStudent_ResponseShouldBeOkAndContentNotNull()
{
var repository = new FakeRepository<Student>();
var server = new InMemoryHttpServer<Student>("http://localhost/", repository);
var response = server.CreateGetRequest("api/students");
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.IsNotNull(response.Content);
}
public void PostNewBugWhenTextIsNullShouldReturn400()
{
var repo = Mock.Create<IBugTrackerData>();
var bug = new Bug { Text = null };
var server = new InMemoryHttpServer<Bug>(InMemoryServerUrl, repo);
var response = server.CreatePostRequest("/api/Bugs/Log", bug);
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
}
public void GetAllStudentsTest()
{
var repository = new FakeStudentRepository();
var school = new TownSchool { Name = "School", Location = "Town" };
var student = new Student { FirstName = "Ivan", LastName = "Ivanov", Age = 9, Grade = 4, TownSchool = school };
repository.entities.Add(student);
var server = new InMemoryHttpServer("http://localhost/");
var response = server.CreateGetRequest("api/students");
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.IsNotNull(response.Content);
}
public void PostNewBugWhenDescriptionIsNullShouldReturn400()
{
var bugLoggerData = this.MockUnitOfWorkForActionAll();
var bug = new CreateBugModel()
{
Description = null,
LogDate = DateTime.Now
};
var server = new InMemoryHttpServer<Bug>(InMemoryServerUrl, bugLoggerData);
var response = server.CreatePostRequest("/api/Bugs/Create", bug);
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
}
public void PostNewValidBugShouldReturn201()
{
var bugLoggerData = this.MockUnitOfWorkForActionAll();
var bug = new CreateBugModel()
{
Description = "bug-1",
LogDate = DateTime.Now
};
var server = new InMemoryHttpServer <Bug>(InMemoryServerUrl, bugLoggerData);
var response = server.CreatePostRequest("/api/Bugs/Create", bug);
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
}
public void GetStudentInvalidTest()
{
var repository = new FakeStudentRepository();
var school = new TownSchool { Name = "School", Location = "Town" };
var firstStudent = new Student { FirstName = "Ivan", LastName = "Ivanov", Age = 9, Grade = 4, TownSchool = school };
var secondStudent = new Student { FirstName = "Peter", LastName = "Petrov", Age = 15, Grade = 9, TownSchool = school };
repository.entities.Add(firstStudent);
repository.entities.Add(secondStudent);
var server = new InMemoryHttpServer("http://localhost/");
var response = server.CreateGetRequest("api/students/3");
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
}
public void PostNewBugWhenTextIsValidShouldReturn201AndLocationHeader()
{
var mockUnitOfWork = Mock.Create<IBugTrackerData>();
var bug = this.GetValidBug();
Mock.Arrange(() => mockUnitOfWork.Bugs.Add(Arg.IsAny<Bug>())).Returns(() => bug);
var server = new InMemoryHttpServer<Bug>(InMemoryServerUrl, mockUnitOfWork);
var response = server.CreatePostRequest("/api/Bugs/Log", bug);
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
Assert.IsNotNull(response.Headers.Location);
}
public void PostTeamWorkWhenNameIsNullShouldReturnStatusCode400()
{
var mockRepository = Mock.Create<ITwsData>();
Mock.Arrange(() => mockRepository.TeamWorks
.Add(Arg.Matches<TeamWork>(cat => cat.Name == null)))
.Throws<NullReferenceException>();
var server = new InMemoryHttpServer<TeamWork>("http://localhost/", mockRepository.TeamWorks);
var response = server.CreatePostRequest("/teamwork/create", Entities.GetValidTeamWork());
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
}
public void PostEmptyStudent()
{
//var school = new School().AddSchoolToDatabase(
var mockRepository = Mock.Create<DbStudentRepository>();
var student = new Student();
Mock.Arrange(() => mockRepository.Add(Arg.IsAny<Student>()))
.Throws(new DbEntityValidationException());
var server = new InMemoryHttpServer<Student>("http://localhost/", mockRepository);
var responce = server.CreatePostRequest("api/students", JsonConvert.SerializeObject(student));
Assert.AreEqual((int)responce.StatusCode, 500);
}
public void GetAllWhenOneTeamWorkShouldReturnStatusCode200AndNotNullContent()
{
var mockRepository = Mock.Create<ITwsData>();
var models = new List<TeamWork>();
models.Add(Entities.GetValidTeamWork());
Mock.Arrange(() => mockRepository.TeamWorks.All())
.Returns(() => models.AsQueryable());
var server = new InMemoryHttpServer<TeamWork>("http://localhost/", mockRepository.TeamWorks);
var response = server.CreateGetRequest("/teamwork/all");
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.IsNotNull(response.Content);
}
public void GetAll_WhenNoStudents_ShouldReturnStatusCode200AndNotNullContent()
{
var mockRepository = Mock.Create<IRepository<Student>>();
var models = new List<Student>();
Mock.Arrange(() => mockRepository.All())
.Returns(() => models.AsQueryable());
var server = new InMemoryHttpServer<Student>("http://localhost/",
mockRepository);
var response = server.CreateGetRequest("api/students");
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.IsNotNull(response.Content);
}
public void TestInit()
{
var type = typeof(UsersController);
scope = new TransactionScope();
var routes = new List<Route>
{
new Route(
"TagsApi",
"api/tags/{tagId}/posts",
new
{
controller = "tags",
action = "posts"
}),
new Route(
"PostsApi",
"api/posts/{postId}/comment",
new
{
controller = "posts",
action = "comment"
}),
new Route(
"UsersApi",
"api/users/{action}",
new
{
controller = "users"
}),
new Route(
"DefaultApi",
"api/{controller}/{id}",
new
{
id = RouteParameter.Optional
})
};
this.httpServer = new InMemoryHttpServer("http://localhost/", routes);
}
public void GetStudentBySubjectMarkTest()
{
var repository = new FakeStudentRepository();
var school = new TownSchool { Name = "School", Location = "Town" };
var firstStudent = new Student { FirstName = "Ivan", LastName = "Ivanov", Age = 9, Grade = 4, TownSchool = school };
var secondStudent = new Student { FirstName = "Peter", LastName = "Petrov", Age = 15, Grade = 9, TownSchool = school };
firstStudent.Marks.Add(new Mark { Subject = "Math", Value = 5, Student = firstStudent });
secondStudent.Marks.Add(new Mark { Subject = "History", Value = 4, Student = secondStudent });
secondStudent.Marks.Add(new Mark { Subject = "IT", Value = 6, Student = secondStudent });
repository.entities.Add(firstStudent);
repository.entities.Add(secondStudent);
var server = new InMemoryHttpServer("http://localhost/");
var response = server.CreateGetRequest("api/students?subject=Math&value=5");
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.IsNotNull(response.Content);
}
public void PostStudent_WhenNameIsNull_ShouldReturnStatusCode400()
{
var mockRepository = Mock.Create<IRepository<Student>>();
Mock.Arrange(() => mockRepository
.Add(Arg.Matches<Student>(st => st.FirstName == null)))
.Throws<NullReferenceException>();
var server =
new InMemoryHttpServer<Student>("http://localhost/", mockRepository);
var response = server.CreatePostRequest("api/Student",
new Student()
);
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
}
public void GetAllWhenBugsInDbShouldReturnStatus200AndNonEmptyContent()
{
var mockUnitOfWork = Mock.Create<IBugTrackerData>();
Bug[] bugs =
{
new Bug { Id = 1, LogDate = DateTime.Today, Status = Status.Pending, Text = "SomeText" },
new Bug { Id = 2, LogDate = DateTime.Today, Status = Status.Pending, Text = "SomeText" },
new Bug { Id = 2, LogDate = DateTime.Today, Status = Status.Pending, Text = "SomeText" }
};
Mock.Arrange(() => mockUnitOfWork.Bugs).Returns((IRepository<Bug>)bugs.AsQueryable());
var server = new InMemoryHttpServer<Bug>(InMemoryServerUrl, mockUnitOfWork);
var response = server.CreateGetRequest("/api/Bugs/All");
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.IsNotNull(response.Content);
}
public void PostCategory_WhenNameIsNull_ShouldReturnStatusCode400()
{
var mockRepository = Mock.Create<IRepository<Category>>();
Mock.Arrange(() => mockRepository
.Add(Arg.Matches<Category>(cat => cat.Name == null)))
.Throws<NullReferenceException>();
var server =
new InMemoryHttpServer<Category>("http://localhost/", mockRepository);
var response = server.CreatePostRequest("api/categories",
new Category()
{
Name = null
});
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
}
public void GetAll_WhenOneCategory_ShouldReturnStatusCode200AndNotNullContent()
{
var mockRepository = Mock.Create<IRepository<Student>>();
var models = new List<Student>();
models.Add(new Student()
{
FirstName = "Test Cat"
});
//Mock.Arrange(() => mockRepository.All())
// .Returns(() => models.AsQueryable());
var server = new InMemoryHttpServer<Student>("http://localhost/",
mockRepository);
var response = server.CreateGetRequest("api/categories");
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.IsNotNull(response.Content);
}
public void AddThreeStudents_GetByMathResult_CheckIsCountCorrect()
{
var firstStudent = MakeSimpleStudent("Nikolay", "Kostov", 4.00);
var secondStudent = MakeSimpleStudent("Svetlin", "Nakov", 5.00);
var thirdStudent = MakeSimpleStudent("Doncho", "Minkov", 6.00);
var repository = new FakeRepository<Student>();
var server = new InMemoryHttpServer<Student>("http://localhost/", repository);
// Post student
server.CreatePostRequest("api/students", firstStudent);
server.CreatePostRequest("api/students", secondStudent);
server.CreatePostRequest("api/students", thirdStudent);
// Get all students that have a mark for MATH and it is above 5.00
var responseStudents = server
.CreateGetRequest("api/students?subject=math&value=5.00")
.Content.ReadAsAsync<List<Student>>().Result;
Assert.AreEqual(2, responseStudents.Count);
}
public void Add_ValidStudent_CheckUserNamesAndCount()
{
var repository = new FakeRepository<Student>();
string firstName = "Nikolay";
string lastName = "Kostov";
double mathValue = 5.00;
var student = MakeSimpleStudent(firstName, lastName, mathValue);
var server = new InMemoryHttpServer<Student>("http://localhost/", repository);
// Post student
var request = server.CreatePostRequest("api/students", student);
// Get posted student
var responseStudent = server.CreateGetRequest("api/students").Content.ReadAsAsync<List<Student>>().Result;
Assert.AreEqual(1, responseStudent.Count);
Assert.AreEqual(firstName, responseStudent[0].FirstName);
Assert.AreEqual(lastName, responseStudent[0].LastName);
}
public void Add_StudentWithoutSchool_ShouldReturnStatusCode500()
{
var mockUnitOfWork = Mock.Create<IUnitOfWork>();
Student studentEntity = new Student()
{
FirstName = "Pesho",
LastName = "Peshov",
Age = 16,
Grade = 10,
Marks = new List<Mark>() { new Mark() { Subject = "math", Value = 6 } }
};
Mock.Arrange(() => mockUnitOfWork.StudentsRepository
.Add(Arg.Matches<Student>(st => st.School == null)))
.Throws<ArgumentNullException>();
var server = new InMemoryHttpServer<Student>("http://localhost/", mockUnitOfWork);
var response = server.CreatePostRequest("api/students", studentEntity);
Assert.AreEqual(HttpStatusCode.InternalServerError, response.StatusCode);
}
public void GetAll_WhenOneStudent_ShouldReturnStatusCode200AndNotNullContent()
{
var mockRepository = Mock.Create<IRepository<Student>>();
var models = new List<Student>();
models.Add(new Student()
{
Age = 10,
FirstName = "Nikolay",
LastName = "Kostadinov",
Grade = 4
});
Mock.Arrange(() => mockRepository.All())
.Returns(() => models.AsQueryable());
var server = new InMemoryHttpServer<Student>("http://localhost/",
mockRepository);
var response = server.CreateGetRequest("api/Student");
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.IsNotNull(response.Content);
}
public void GetAll_WhenNoStudents_ShouldReturnStatusCode200AndNullContent()
{
var mockRepository = Mock.Create<IRepository<Student>>();
IQueryable<Student> studentEntities = (new List<Student>()).AsQueryable();
Mock.Arrange(() => mockRepository.GetAll())
.Returns(() => studentEntities.AsQueryable());
var server = new InMemoryHttpServer<Student>("http://localhost/",
mockRepository);
var response = server.CreateGetRequest("api/students");
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
var str = response.Content.ReadAsStringAsync();
Assert.IsTrue(str.Result.Length == 2);
}
public void TestInitialize()
{
this.server = new InMemoryHttpServer <TravelClass>(
IN_MEMORY_SERVER_URL,
TestObjectFactoryRepositories.GetTravelClassesRepository());
}
public void TestInitialize()
{
this.server = new InMemoryHttpServer <LegInstance>(
IN_MEMORY_SERVER_URL,
TestObjectFactoryRepositories.GetLegInstancesRepository());
}
public void TestInitialize()
{
this.server = new InMemoryHttpServer <Airport>(
IN_MEMORY_SERVER_URL,
TestObjectFactoryRepositories.GetAirportsRepository());
}
