public async Task GetCollectionOfEHObj_ShouldReturn404_WhenNotFound()
{
var mock = new Moq.Mock <IWebObjectService>();
mock.Setup(m => m.GetEmployeeHoursForAnEmployee(0)).Returns(new System.Collections.Generic.List <WebEmployeeHours>()
{
new WebEmployeeHours()
{
Value = 15f, TimePeriod = "20.1.2019-26.01.2019", EmployeeId = 0, Id = 0
},
new WebEmployeeHours()
{
Value = 10f, TimePeriod = "27.01.2019-02.02.2019", EmployeeId = 0, Id = 1
}
});
using (var testServer = new TestServerBuilder()
.WithMock <IWebObjectService>(typeof(IWebObjectService), mock)
.Build())
{
var client = testServer.CreateClient();
var response = await client.GetAsync("/api/employee_hours/list/999");
Assert.Equal(System.Net.HttpStatusCode.NotFound, response.StatusCode);
}
}
public async Task GetEmployee_WhenSomeData()
{
await dbContext.Employees.AddAsync(new Employee { Name = "Ola Dwa", Email = "*****@*****.**", DateOfBirth = new DateTime(2000, 1, 29) });
await dbContext.Employees.AddAsync(new Employee { Name = "Ola Trzy", Email = "*****@*****.**" });
await dbContext.SaveChangesAsync();
using (var testServer = new TestServerBuilder()
.Build())
{
var client = testServer.CreateClient();
var response = await client.GetAsync("/api/employees/1");
Assert.Equal(System.Net.HttpStatusCode.OK, response.StatusCode);
var jsonString = await response.Content.ReadAsStringAsync();
var actual = JObject.Parse(jsonString);
Debug.WriteLine(actual);
var expected = new JObject {
{ "name", "Ola Dwa" },
{ "id", 1 },
{ "isManager", false },
{ "email", "*****@*****.**" },
{ "dateOfBirth", "2000-01-29" }
};
Assert.True(JToken.DeepEquals(expected, actual));
}
}
public async Task ShouldReturnJsonListOfEmployees_WhenNoError()
{
var mock = new Moq.Mock <IWebObjectService>();
mock.Setup(m => m.GetAllEmployees()).Returns(new System.Collections.Generic.List <WebEmployee>()
{
new WebEmployee()
{
Name = "John"
},
new WebEmployee()
{
Name = "Jane"
}
});
using (var testServer = new TestServerBuilder()
.WithMock <IWebObjectService>(typeof(IWebObjectService), mock)
.Build())
{
var client = testServer.CreateClient();
var response = await client.GetAsync("/api/employees/list");
Assert.Equal(System.Net.HttpStatusCode.OK, response.StatusCode);
var jsonString = await response.Content.ReadAsStringAsync();
var items = JArray.Parse(jsonString);
Assert.Equal(2, items.Count);
}
}
public async Task ShouldReturnJsonEmployee_WhenExists()
{
var mock = new Moq.Mock <IWebObjectService>();
mock.Setup(m => m.GetEmployee(33)).Returns(
new WebEmployee()
{
Name = "John", ID = 33
}
);
using (var testServer = new TestServerBuilder()
.WithMock <IWebObjectService>(typeof(IWebObjectService), mock)
.Build())
{
var client = testServer.CreateClient();
var response = await client.GetAsync("/api/employees/33");
Assert.Equal(System.Net.HttpStatusCode.OK, response.StatusCode);
var jsonString = await response.Content.ReadAsStringAsync();
var actual = JObject.Parse(jsonString);
Debug.WriteLine(actual);
var expected = new JObject {
{ "name", "John" },
{ "id", 33 },
{ "isManager", false }
};
Debug.WriteLine(actual);
Assert.True(JToken.DeepEquals(expected, actual));
}
}
public async Task GetOneEHObj_ShouldReturnOneObj_WhenFound()
{
var mock = new Moq.Mock <IWebObjectService>();
mock.Setup(m => m.GetOneEmployeeHours(77)).Returns(
new WebEmployeeHours()
{
Value = 15f, TimePeriod = "20.1.2019-26.01.2019", EmployeeId = 0, Id = 77
}
);
using (var testServer = new TestServerBuilder()
.WithMock <IWebObjectService>(typeof(IWebObjectService), mock)
.Build())
{
var client = testServer.CreateClient();
var response = await client.GetAsync("/api/employee_hours/77");
Assert.Equal(System.Net.HttpStatusCode.OK, response.StatusCode);
var jsonString = await response.Content.ReadAsStringAsync();
var actual = JObject.Parse(jsonString);
Debug.WriteLine(actual);
var expected = new JObject {
{ "value", 15.0 },
{ "id", 77 },
{ "timePeriod", "20.1.2019-26.01.2019" },
{ "employeeId", 0 }
};
Assert.True(JToken.DeepEquals(expected, actual));
}
}
public async Task GetForEmployee_ShouldReturn200_WhenExists()
{
var mock = new Moq.Mock <IWebObjectService>();
mock.Setup(m => m.GetSalariesForAnEmployee(3)).Returns(new System.Collections.Generic.List <WebSalary>()
{
new WebSalary()
{
ID = 1, TimePeriod = "01.02.2019-09.02.2019", EmployeeId = 3, Value = 100f
},
new WebSalary()
{
ID = 2, TimePeriod = "01.02.2019-09.02.2019", EmployeeId = 3, Value = 1044f
}
});
using (var testServer = new TestServerBuilder()
.WithMock <IWebObjectService>(typeof(IWebObjectService), mock)
.Build())
{
var client = testServer.CreateClient();
var response = await client.GetAsync("/api/salaries/list/3");
Assert.Equal(System.Net.HttpStatusCode.OK, response.StatusCode);
var jsonString = await response.Content.ReadAsStringAsync();
var items = JArray.Parse(jsonString);
Assert.Equal(2, items.Count);
}
}
public async Task GetSalaries_WhenNoData()
{
using (var testServer = new TestServerBuilder()
.Build())
{
var client = testServer.CreateClient();
var response = await client.GetAsync("/api/salaries/list");
Assert.Equal(System.Net.HttpStatusCode.OK, response.StatusCode);
}
}
public async Task GetEmployee_WhenNoData()
{
using (var testServer = new TestServerBuilder()
.Build())
{
var client = testServer.CreateClient();
var response = await client.GetAsync("/api/employees/100");
Assert.Equal(System.Net.HttpStatusCode.NotFound, response.StatusCode);
}
}
public async Task PostEmployee_Success()
{
using (var testServer = new TestServerBuilder()
.Build())
{
var client = testServer.CreateClient();
var myJson = "{ 'email': '*****@*****.**', 'name': 'ewa' }";
HttpContent requestContent = new StringContent(myJson, Encoding.UTF8, "application/json");
var response = await client.PostAsync("/api/employees", requestContent);
Assert.Equal(System.Net.HttpStatusCode.Created, response.StatusCode);
}
}
public async Task DeleteUserShouldRespond401WhenNoAuth()
{
var mock = new Moq.Mock <IUserRepository>();
using (var testServer = new TestServerBuilder()
.WithMock <IUserRepository>(typeof(IUserRepository), mock)
.Build())
{
var client = testServer.CreateClient();
var response = await client.DeleteAsync("/api/user/[email protected]");
Assert.Equal(System.Net.HttpStatusCode.Unauthorized, response.StatusCode);
}
}
public async Task PostNewUserShouldReturn409WhenAlreadyExists()
{
var mock = new Moq.Mock <IUserRepository>();
mock.Setup(m => m.CreateUser(It.IsAny <string>())).ThrowsAsync(new UserAlreadyExistsException());
using (var testServer = new TestServerBuilder()
.WithMock <IUserRepository>(typeof(IUserRepository), mock)
.Build())
{
var client = testServer.CreateClient();
var response = await client.PostAsync("/api/user/[email protected]", new StringContent(""));
Assert.Equal(System.Net.HttpStatusCode.Conflict, response.StatusCode);
}
}
public async Task GetForEmployee_ShouldReturn404_WhenNoData()
{
var mock = new Moq.Mock <IWebObjectService>();
mock.Setup(m => m.GetSalariesForAnEmployee(1)).Returns((List <WebSalary>)(null));
using (var testServer = new TestServerBuilder()
.WithMock <IWebObjectService>(typeof(IWebObjectService), mock)
.Build())
{
var client = testServer.CreateClient();
var response = await client.GetAsync("/api/salaries/list/1");
Assert.Equal(System.Net.HttpStatusCode.NotFound, response.StatusCode);
}
}
public async Task GetEmployeesList_WhenNoData()
{
using (var testServer = new TestServerBuilder()
.Build())
{
var client = testServer.CreateClient();
var response = await client.GetAsync("/api/employees/list");
Assert.Equal(System.Net.HttpStatusCode.OK, response.StatusCode);
var jsonString = await response.Content.ReadAsStringAsync();
var items = JArray.Parse(jsonString);
Assert.Empty(items);
}
}
public async Task PostEmployee_EmailNotSet()
{
using (var testServer = new TestServerBuilder()
.Build())
{
var client = testServer.CreateClient();
var myJson = "{ 'employeeId': 33 }";
HttpContent requestContent = new StringContent(myJson, Encoding.UTF8, "application/json");
var response = await client.PostAsync("/api/employees", requestContent);
Assert.Equal(System.Net.HttpStatusCode.BadRequest, response.StatusCode);
var jsonString = await response.Content.ReadAsStringAsync();
Assert.Equal("Problem when adding the object to database: Email was empty", jsonString);
}
}
public async Task ShouldReturnJsonListOfEmployees()
{
await dbContext.Employees.AddAsync(new Employee { Name = "Ola Dwa", Email = "*****@*****.**" });
await dbContext.SaveChangesAsync();
using (var testServer = new TestServerBuilder()
.With(b => b.RegisterModule <BranchOfficeAutofacModule>())
.Build())
{
var client = testServer.CreateClient();
var result = await client.GetStringAsync("/api/employees/list");
var items = JArray.Parse(result);
Assert.Single(items);
}
}
public async Task ShouldDeleteUserInRepositoryWhenRequestedByManager()
{
var mock = new Moq.Mock <IUserRepository>();
mock.Setup(m => m.DeleteUser(It.IsAny <string>())).Returns(Task.CompletedTask);
mock.Setup(m => m.IsValidAsync("*****@*****.**", "pass")).ReturnsAsync(true);
mock.Setup(m => m.IsManager("*****@*****.**")).ReturnsAsync(true);
using (var testServer = new TestServerBuilder()
.WithMock <IUserRepository>(typeof(IUserRepository), mock)
.Build())
{
var client = testServer.CreateClient();
client.AddBasicAuthHeader("*****@*****.**", "pass");
var response = await client.DeleteAsync("/api/user/[email protected]");
Assert.Equal(System.Net.HttpStatusCode.OK, response.StatusCode);
}
}
public async Task PostOneEHObj_ShouldSucceed_UnitTest()
{
var mock = new Moq.Mock <IWebObjectService>();
mock.Setup(m => m.AddEmployeeHours(Moq.It.IsAny <WebEmployeeHours>()));
using (var testServer = new TestServerBuilder()
.WithMock <IWebObjectService>(typeof(IWebObjectService), mock)
.Build())
{
var client = testServer.CreateClient();
var myJson = "{ 'employeeId': 33 }";
HttpContent requestContent = new StringContent(myJson, Encoding.UTF8, "application/json");
var response = await client.PostAsync("/api/employee_hours", requestContent);
Assert.Equal(System.Net.HttpStatusCode.Created, response.StatusCode);
}
mock.Verify(m => m.AddEmployeeHours(Moq.It.IsAny <WebEmployeeHours>()), Moq.Times.Once);
}
public async Task ShouldCreateNewUserInRepository()
{
var mock = new Moq.Mock <IUserRepository>();
mock.Setup(m => m.CreateUser(It.IsAny <string>())).ReturnsAsync("pass");
using (var testServer = new TestServerBuilder()
.WithMock <IUserRepository>(typeof(IUserRepository), mock)
.Build())
{
var client = testServer.CreateClient();
var response = await client.PostAsync("/api/user/[email protected]", new StringContent(""));
Assert.Equal(System.Net.HttpStatusCode.OK, response.StatusCode);
var jsonString = await response.Content.ReadAsStringAsync();
var items = JsonConvert.DeserializeObject <UserCreatedResponse>(jsonString);
Assert.Equal("pass", items.Password);
}
}
public async Task EditOneEHObj_ShouldReturn404_WhenNotFound()
{
var mock = new Moq.Mock <IWebObjectService>();
mock.Setup(m => m.GetOneEmployeeHours(77)).Returns(
(WebEmployeeHours)null
);
using (var testServer = new TestServerBuilder()
.WithMock <IWebObjectService>(typeof(IWebObjectService), mock)
.Build())
{
var client = testServer.CreateClient();
var myJson = "{ 'employeeId': 33, 'Value': 15, 'TimePeriod': '20.1.2019-26.01.2019', 'HoursCount': 99, 'id': 77 }";
HttpContent requestContent = new StringContent(myJson, Encoding.UTF8, "application/json");
var response = await client.PutAsync("/api/employee_hours", requestContent);
Assert.Equal(System.Net.HttpStatusCode.NotFound, response.StatusCode);
}
}
public async Task ShouldNotReturnJsonEmployee_WhenNotExists()
{
var mock = new Moq.Mock <IWebObjectService>();
mock.Setup(m => m.GetEmployee(33)).Returns(
new WebEmployee()
{
Name = "John", ID = 33
}
);
using (var testServer = new TestServerBuilder()
.WithMock <IWebObjectService>(typeof(IWebObjectService), mock)
.Build())
{
var client = testServer.CreateClient();
var response = await client.GetAsync("/api/employees/100");
Assert.Equal(System.Net.HttpStatusCode.NotFound, response.StatusCode);
}
}
public async Task DeleteOneEHObj_ShouldReturn202_WhenFound_RealWebService()
{
var mock = new Moq.Mock <IDataAccessObjectService>();
mock.Setup(m => m.DeleteEmployeeHours(77));
mock.Setup(m => m.GetOneEmployeeHours(77)).Returns(
new EmployeeHours {
EmployeeId = 1, EmployeeHoursId = 77, TimePeriod = "aa", Value = 100
});
using (var testServer = new TestServerBuilder()
.WithMock <IDataAccessObjectService>(typeof(IDataAccessObjectService), mock)
.Build())
{
var client = testServer.CreateClient();
var response = await client.DeleteAsync("/api/employee_hours/77");
Assert.Equal(System.Net.HttpStatusCode.Accepted, response.StatusCode);
}
mock.Verify(x => x.DeleteEmployeeHours(77), Moq.Times.Once);
}
public async Task DeleteOneEHObj_ShouldReturn202_WhenFound()
{
var mock = new Moq.Mock <IWebObjectService>();
mock.Setup(m => m.GetOneEmployeeHours(77)).Returns(
new WebEmployeeHours()
{
Value = 15, TimePeriod = "20.1.2019-26.01.2019", EmployeeId = 1, Id = 77
}
);
using (var testServer = new TestServerBuilder()
.WithMock <IWebObjectService>(typeof(IWebObjectService), mock)
.Build())
{
var client = testServer.CreateClient();
var response = await client.DeleteAsync("/api/employee_hours/77");
Assert.Equal(System.Net.HttpStatusCode.Accepted, response.StatusCode);
}
}
public async Task PostOneEHObj_ShouldFail_WhenAddingToDBThrowsException()
{
var mockDB = new Moq.Mock <IDataAccessObjectService>();
mockDB.Setup(m => m.AddEmployeeHours(Moq.It.IsAny <EmployeeHours>(), false)).Throws <ArgumentException>();
using (var testServer = new TestServerBuilder()
.WithMock <IDataAccessObjectService>(typeof(IDataAccessObjectService), mockDB)
.Build())
{
var client = testServer.CreateClient();
var myJson = "{ 'employeeId': 33 }";
HttpContent requestContent = new StringContent(myJson, Encoding.UTF8, "application/json");
var response = await client.PostAsync("/api/employee_hours", requestContent);
Assert.Equal(System.Net.HttpStatusCode.BadRequest, response.StatusCode);
var jsonString = await response.Content.ReadAsStringAsync();
Assert.Equal("Problem when adding the object to database: Value does not fall within the expected range.", jsonString);
}
mockDB.Verify(m => m.AddEmployeeHours(Moq.It.IsAny <EmployeeHours>(), false), Moq.Times.Once);
}
public async Task GetEmployeesList_WhenSomeData()
{
await dbContext.Employees.AddAsync(new Employee { Name = "Ola Dwa", Email = "*****@*****.**" });
await dbContext.Employees.AddAsync(new Employee { Name = "Ola Trzy", Email = "*****@*****.**" });
await dbContext.SaveChangesAsync();
using (var testServer = new TestServerBuilder()
.Build())
{
var client = testServer.CreateClient();
var response = await client.GetAsync("/api/employees/list");
Assert.Equal(System.Net.HttpStatusCode.OK, response.StatusCode);
var jsonString = await response.Content.ReadAsStringAsync();
var items = JArray.Parse(jsonString);
Assert.Equal(2, items.Count);
}
}
public async Task GetEHColl_WhenSomeData()
{
await dbContext.EmployeeHoursCollection.AddAsync(
new EmployeeHours { EmployeeHoursId = 100, Value = 100f, TimePeriod = "02.01.2019_08.01.2019", EmployeeId = 33 });
await dbContext.EmployeeHoursCollection.AddAsync(
new EmployeeHours { EmployeeHoursId = 102, Value = 100f, TimePeriod = "02.01.2019_08.01.2019", EmployeeId = 33 });
await dbContext.SaveChangesAsync();
using (var testServer = new TestServerBuilder()
.Build())
{
var client = testServer.CreateClient();
var response = await client.GetAsync("/api/employee_hours/list/33");
Assert.Equal(System.Net.HttpStatusCode.OK, response.StatusCode);
var jsonString = await response.Content.ReadAsStringAsync();
var items = JArray.Parse(jsonString);
Assert.Equal(2, items.Count);
}
}
public async Task EditOneEHObj_ShouldFail_WhenEditingInDBThrowsException()
{
var mockDB = new Moq.Mock <IDataAccessObjectService>();
mockDB.Setup(m => m.GetOneEmployeeHours(77)).
Returns(new EmployeeHours {
EmployeeHoursId = 77, Value = 100f, TimePeriod = "02.01.2019_08.01.2019", EmployeeId = 4
});
mockDB.Setup(m => m.GetOneEmployee(33)).
Returns((Employee)null);
mockDB.Setup(m => m.EditEmployeeHours(Moq.It.IsAny <EmployeeHours>())).Throws <ArgumentException>();
using (var testServer = new TestServerBuilder()
.WithMock <IDataAccessObjectService>(typeof(IDataAccessObjectService), mockDB)
.Build())
{
var client = testServer.CreateClient();
var myJson = "{ 'employeeId': 33, 'Value': 15, 'TimePeriod': '20.1.2019-26.01.2019', 'HoursCount': 99, 'id': 77 }";
HttpContent requestContent = new StringContent(myJson, Encoding.UTF8, "application/json");
var response = await client.PutAsync("/api/employee_hours", requestContent);
Assert.Equal(System.Net.HttpStatusCode.BadRequest, response.StatusCode);
}
}
