public void Count_ReturnsCorrectCount()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>().UseInMemoryDatabase(Guid.NewGuid().ToString()).Options;
using (var dbContext = new ApplicationDbContext(options))
{
Employee employee = new Employee()
{
FirstName = "Ivan",
MiddleName = "Ivanov",
LastName = "Ivanov",
PhoneNumber = "0897924218",
Email = "*****@*****.**",
Town = "Sofia",
Address = "address 1",
};
dbContext.Employees.Add(employee);
dbContext.SaveChanges();
var employeesService = new EmployeesService(dbContext);
int employeesCount = employeesService.Count();
Assert.Equal(1, employeesCount);
}
}
public async Task Hire_SavesEmployeeData_WhenEmployeeDataIsCorrect()
{
#region ARRANGE
var employeesService = new EmployeesService(inMemoryDbContext);
Employee employee = new Employee()
{
FirstName = "First",
MiddleName = "Middle",
LastName = "Last Record",
Department = EDepartment.IT,
HomeAddress = "Home",
MonthlySalaryInEUR = 1234M,
WorkAddress = "Office"
};
var initialRecordsCount = inMemoryDbContext.Employees.Count();
#endregion
#region ACT
await employeesService.HireAsync(employee);
var finalRecordsCount = inMemoryDbContext.Employees.Count();
var lastRecord = await inMemoryDbContext.Employees.LastOrDefaultAsync();
#endregion
#region ASSERT
Assert.True(finalRecordsCount > initialRecordsCount);
Assert.NotNull(lastRecord);
Assert.Equal(lastRecord.LastName, employee.LastName);
#endregion
}
public async Task GetBySearchCriteriaAsyncShouldWorkCorrectlyWithMiddleName()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var dbContext = new ApplicationDbContext(options);
var userRepo = new EfDeletableEntityRepository <ApplicationUser>(dbContext);
var service = new EmployeesService(userRepo);
await userRepo.AddAsync(new ApplicationUser
{
FirstName = "ivan",
LastName = "ivanov",
MiddleName = "ivanov",
EGN = "1234567890",
});
await userRepo.SaveChangesAsync();
var model = new EmployeeSearchModel
{
MiddleName = "ivanov",
};
var customers = await service.GetBySearchCriteriaAsync <EmployeeModel, EmployeeSearchModel>(model);
Assert.Single(customers);
Assert.Collection(
customers,
x => Assert.Equal("ivanov", x.MiddleName));
}
public async Task AddEmployeeAsyncTest_WithCoreectData_ShouldReturnTrue()
{
var context = SteuDbContextInMemoryFactory.InitializeContext();
MapperInitializer.InitializeMapper();
var repository = new EfDeletableEntityRepository <SteuUser>(context);
var service = new EmployeesService(repository, this.GetMockUserManager().Object);
await repository.AddAsync(new SteuUser()
{
Id = "asdasd",
UserName = "******",
Company = new Company()
{
Name = "Pesho Ltd",
},
});
await repository.SaveChangesAsync();
AddEmployeeInputModel model = new AddEmployeeInputModel()
{
FirstName = "Gosho",
LastName = "Goshov",
Username = "******",
Email = "*****@*****.**",
Password = "******",
ConfirmPassword = "******",
};
var actualResult = await service.AddEmployeeAsync("asdasd", model);
Assert.True(actualResult);
}
public async void UpsertEmployeeAsync_ShouldCallAddEmployee()
{
// Arrange
var employee = new Employee
{
Id = 0,
FirstName = "John",
LastName = "Dou",
MediaInteractivaEmployee = true,
Pet = new Pet {
Id = 73, Name = "Dick", Type = "duck", OwnerId = 23
}
};
var employeesRepoMock = new Mock <IBaseRepository <Employee> >();
var employeesService = new EmployeesService(employeesRepoMock.Object);
// Act
await employeesService.UpsertEmployeeAsync(employee);
// Assert
employeesRepoMock.Verify(x => x.AddAsync(employee), Times.Once);
employeesRepoMock.Verify(x => x.UpdateAsync(It.IsAny <Employee>()), Times.Never);
}
public ActionResult <List <EmployeesRegionsDTO> > Employees(int id)
{
var employeeService = new EmployeesService();
var bode = employeeService.GetEmployeesRegionsById(id);
return(bode);
}
public HolidayTests(ITestOutputHelper output)
{
_output = output;
var setup = new SetUp();
setup.Initialize();
_context = setup.HolidayDbContext;
var mapper = setup.Mapper;
var userManager = setup.InitializeUserManager();
_holidaysCount = setup.GetCount("holidays");
_configuration = setup.GetConfiguration();
_timeService = new TimeService();
var mockUserService = new Mock <IUserService>().Object;
var mockOvertimeUtility = new Mock <IOvertimeUtility>().Object;
_holidaysRepository = new HolidaysRepository(_context);
_employeesRepository = new EmployeesRepository(_context, userManager);
_clientsRepository = new ClientsRepository(_context);
var holidayGuidsRepository = new HolidayGuidsRepository(_context);
var mockNotificationSettingsService = new Mock <INotificationSettingsService>().Object;
_employeesService = new EmployeesService(_employeesRepository, mapper, mockOvertimeUtility, _timeService,
mockUserService, mockNotificationSettingsService, _configuration);
_holidaysService = new HolidaysService(_holidaysRepository, _employeesRepository, mapper, _timeService,
mockOvertimeUtility, _clientsRepository, mockUserService, _configuration, holidayGuidsRepository);
}
public async Task GetByIdWithVaidId()
{
ApplicationDbContext dbContext = new ApplicationDbContext(new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString()).Options);
var service = new EmployeesService(new EfDeletableEntityRepository <Employee>(dbContext));
var date = DateTime.UtcNow;
await service.AddAsync(
"Ivan Ivanov",
"*****@*****.**",
"08888888888",
date,
"1");
var employee = await dbContext.Employees.FirstOrDefaultAsync();
var result = service.GetById <EmployeeViewModel>(employee.Id);
Assert.Equal(employee.FullName, result.FullName);
Assert.Equal(employee.Email, result.Email);
Assert.Equal(employee.PhoneNumber, result.PhoneNumber);
Assert.Equal(employee.StartWorkDate, result.StartWorkDate);
Assert.Equal(employee.GamingHallId, result.GamingHallId);
dbContext.Database.EnsureDeleted();
dbContext.Dispose();
}
public async Task ExistAsyncShouldReturnTrueWhenExists()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var dbContext = new ApplicationDbContext(options);
var userRepo = new EfDeletableEntityRepository <ApplicationUser>(dbContext);
var service = new EmployeesService(userRepo);
await userRepo.AddAsync(new ApplicationUser
{
FirstName = "ivan",
LastName = "ivanov",
MiddleName = "ivanov",
EGN = "1234567890",
});
await userRepo.SaveChangesAsync();
var customerId = (await userRepo.AllAsNoTracking()
.FirstOrDefaultAsync()).Id;
Assert.True(await service.ExistAsync(customerId));
}
public async void GetEmployeeByIdAsync_ShouldReturnEmployee()
{
// Arrange
var employee = new Employee
{
Id = 23,
FirstName = "John",
LastName = "Dou",
MediaInteractivaEmployee = true,
Pet = new Pet {
Id = 73, Name = "Dick", Type = "duck", OwnerId = 23
}
};
var employeesRepoMock = new Mock <IBaseRepository <Employee> >();
employeesRepoMock.Setup(x => x.GetByIdAsync(It.IsAny <int>())).ReturnsAsync(employee);
var employeesService = new EmployeesService(employeesRepoMock.Object);
// Act
var result = await employeesService.GetEmployeeByIdAsync(employee.Id);
// Arrange
Assert.IsAssignableFrom <Employee>(result);
Assert.Equal(employee.Id, result.Id);
Assert.Equal(employee.FirstName, result.FirstName);
Assert.Equal(employee.LastName, result.LastName);
}
protected void cmdSynchronous_Click(object sender, EventArgs e)
{
// Record the start time.
DateTime startTime = DateTime.Now;
// Get the web service data.
EmployeesService proxy = new EmployeesService();
try
{
GridView1.DataSource = proxy.GetEmployeesSlow();
}
catch (Exception err)
{
lblInfo.Text = "Problem contacting web service.";
return;
}
GridView1.DataBind();
// Perform some other time-consuming tasks.
DoSomethingSlow();
// Determine the total time taken.
TimeSpan timeTaken = DateTime.Now.Subtract(startTime);
lblInfo.Text = "Synchronous operations took " + timeTaken.TotalSeconds +
" seconds.";
}
public async Task AllWithValidId()
{
ApplicationDbContext dbContext = new ApplicationDbContext(new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options);
var service = new EmployeesService(new EfDeletableEntityRepository <Employee>(dbContext));
var date = DateTime.UtcNow;
for (int i = 1; i <= 5; i++)
{
await service.AddAsync(
"Ivan Ivanov" + i,
"*****@*****.**",
"08888888888",
date,
"1");
}
var results = service.All <EmployeeViewModel>("1");
int count = 0;
foreach (var result in results)
{
count++;
Assert.Equal("Ivan Ivanov" + count, result.FullName);
Assert.Equal("*****@*****.**", result.Email);
Assert.Equal("08888888888", result.PhoneNumber);
Assert.Equal(date, result.StartWorkDate);
Assert.Equal("1", result.GamingHallId);
}
Assert.Equal(5, count);
dbContext.Database.EnsureDeleted();
dbContext.Dispose();
}
public async Task AllWithNullId()
{
ApplicationDbContext dbContext = new ApplicationDbContext(new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options);
var service = new EmployeesService(new EfDeletableEntityRepository <Employee>(dbContext));
var date = DateTime.UtcNow;
for (int i = 1; i <= 5; i++)
{
await service.AddAsync(
"Ivan Ivanov" + i,
"*****@*****.**",
"08888888888",
date,
"1");
}
var results = service.All <EmployeeViewModel>(null);
int count = 0;
foreach (var result in results)
{
count++;
}
Assert.Equal(0, count);
dbContext.Dispose();
}
protected void cmdGetData_Click(object sender, EventArgs e)
{
// Create the proxy.
EmployeesService proxy = new EmployeesService();
// This timeout will apply to all web service method calls.
proxy.Timeout = 3000; // 3,000 milliseconds is 3 seconds.
DataSet ds = null;
try
{
// Call the web service and get the results.
ds = proxy.GetEmployees();
}
catch (System.Net.WebException err)
{
if (err.Status == WebExceptionStatus.Timeout)
{
lblResult.Text = "Web service timed out after 3 seconds.";
}
else
{
lblResult.Text = "Another type of problem occurred.";
}
}
// Bind the results.
if (ds != null)
{
GridView1.DataSource = ds.Tables[0];
GridView1.DataBind();
}
}
public EmployeesController(EmployeeManagementMVCContext context, IConfiguration configuration)
{
_context = context;
Configuration = configuration;
EmployeeIQ = _context.Employee;
EmployeesService = new EmployeesService(_context, Configuration);
}
public void TestGetAllByDeparmentId()
{
// Parameter named to avoid confusion.
EmployeesService service = CreateService();
IEnumerable <Employee> employees1 = service.GetAll(1);
// The service must always return a collection, even when empty.
Assert.NotNull(employees1);
// The service must return two items according to test configuration.
Assert.Equal(2, employees1.Count());
Employee firstEmployee = employees1.First();
//Checks if the employees are according to test configuration.
Assert.Equal(1, firstEmployee.Id);
Assert.Equal("Dan", firstEmployee.FirstName);
Assert.Equal("Loden", firstEmployee.LastName);
Assert.Equal("Nature Inspector", firstEmployee.JobTitle);
Assert.Equal("4652 Bates Brothers Road Hilliard, OH 43026", firstEmployee.MailingAddress);
// Second test is to assert that the filter was not a lucky hit.
IEnumerable <Employee> employees2 = service.GetAll(2);
Assert.NotNull(employees2);
Assert.Equal(2, employees2.Count());
Employee firstEmployee2 = employees2.First();
Assert.Equal(3, firstEmployee2.Id);
Assert.Equal("Teresa", firstEmployee2.FirstName);
Assert.Equal("Hill", firstEmployee2.LastName);
Assert.Equal("Construction Equipment Technician", firstEmployee2.JobTitle);
Assert.Equal("3789 Cook Hill Road Stamford, CT 06995", firstEmployee2.MailingAddress);
}
public async Task GetByIdAsyncShouldWorkCorrectly()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var dbContext = new ApplicationDbContext(options);
var userRepo = new EfDeletableEntityRepository <ApplicationUser>(dbContext);
var service = new EmployeesService(userRepo);
await userRepo.AddAsync(new ApplicationUser
{
FirstName = "ivan",
LastName = "ivanov",
MiddleName = "ivanov",
EGN = "1234567890",
});
await userRepo.SaveChangesAsync();
var customerId = (await userRepo.AllAsNoTracking()
.FirstOrDefaultAsync()).Id;
var customer = await service.GetByIdAsync <EmployeeModel>(customerId);
Assert.Equal("ivan", customer.FirstName);
Assert.Equal("1234567890", customer.EGN);
Assert.Equal("ivanov", customer.LastName);
}
protected void cmdAsynchronous_Click(object sender, EventArgs e)
{
// Record the start time.
DateTime startTime = DateTime.Now;
// Start the web service on another thread.
EmployeesService proxy = new EmployeesService();
GetEmployeesDelegate async = new GetEmployeesDelegate(proxy.GetEmployeesSlow);
IAsyncResult handle = async.BeginInvoke(null, null);
// Perform some other time-consuming tasks.
DoSomethingSlow();
// Retrieve the result. If it isn't ready, wait.
try
{
GridView1.DataSource = async.EndInvoke(handle);
}
catch (Exception err)
{
lblInfo.Text = "Problem contacting web service.";
return;
}
GridView1.DataBind();
// Determine the total time taken.
TimeSpan timeTaken = DateTime.Now.Subtract(startTime);
lblInfo.Text = "Asynchronous operations took " + timeTaken.TotalSeconds +
" seconds.";
}
public async Task AddEmployeeAsyncTest_WithNullUserId_ShouldReturnArgumentNullException()
{
var context = SteuDbContextInMemoryFactory.InitializeContext();
MapperInitializer.InitializeMapper();
var repository = new EfDeletableEntityRepository <SteuUser>(context);
var service = new EmployeesService(repository, this.GetMockUserManager().Object);
await repository.AddAsync(new SteuUser()
{
Id = "asdasd",
UserName = "******",
Company = new Company()
{
Name = "Pesho Ltd",
},
});
await repository.SaveChangesAsync();
AddEmployeeInputModel model = new AddEmployeeInputModel()
{
FirstName = "Gosho",
LastName = "Goshov",
Username = "******",
Email = "*****@*****.**",
Password = "******",
ConfirmPassword = "******",
};
await Assert.ThrowsAsync <ArgumentNullException>(()
=> service.AddEmployeeAsync(null, model));
}
public async void DeleteEmployeeAsync_ShouldCallDeleteEmployee()
{
// Arrange
var employee = new Employee
{
Id = 23,
FirstName = "John",
LastName = "Dou",
MediaInteractivaEmployee = true,
Pet = new Pet {
Id = 73, Name = "Dick", Type = "duck", OwnerId = 23
}
};
var employeesRepoMock = new Mock <IBaseRepository <Employee> >();
employeesRepoMock.Setup(x => x.GetByIdAsync(It.IsAny <int>())).ReturnsAsync(employee);
var employeesService = new EmployeesService(employeesRepoMock.Object);
// Act
await employeesService.DeleteEmployeeAsync(employee.Id);
// Assert
employeesRepoMock.Verify(x => x.DeleteAsync(employee.Id), Times.Once);
}
public async Task CreateAsyncReturnsCorrect()
{
var id = Guid.NewGuid().ToString();
var user = new CarpetUser
{
Id = id,
FirstName = "Иван",
LastName = "Иванов",
PhoneNumber = "0888777444",
Email = "*****@*****.**",
UserName = "******",
};
var roleAdminId = Guid.NewGuid().ToString();
var role = new CarpetRole {
Id = roleAdminId, Name = GlobalConstants.AdministratorRoleName
};
var roleOperatorId = Guid.NewGuid().ToString();
var roleOperator = new CarpetRole {
Id = roleOperatorId, Name = GlobalConstants.OperatorRoleName
};
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "CreateAsyncReturnsCorrect")
.Options;
var dbContext = new ApplicationDbContext(options);
dbContext.Users.Add(user);
dbContext.Roles.Add(role);
dbContext.Roles.Add(roleOperator);
await dbContext.SaveChangesAsync();
var repository = new EfDeletableEntityRepository <Employee>(dbContext);
var service = new EmployeesService(repository, dbContext);
var userFrom = dbContext.Users.First();
var employeeId = Guid.NewGuid().ToString();
var employee = new EmployeeCreateInputModel
{
Id = id,
FirstName = "Иван",
LastName = "Иванов",
PhoneNumber = "0888777444",
Salary = 1000m,
RoleName = GlobalConstants.OperatorRoleName,
};
var employeeFromDbFirst = await service.CreateAsync(employee, string.Empty);
await service.DeleteByIdAsync(employeeFromDbFirst.Id);
var employeeFromDb = await service.CreateAsync(employee, string.Empty);
Assert.NotEqual(employeeFromDb.Id, employeeFromDbFirst.Id);
Assert.Equal(employeeFromDb.PhoneNumber, employeeFromDbFirst.PhoneNumber);
Assert.Equal(employeeFromDb.PhoneNumber, employeeFromDbFirst.PhoneNumber);
Assert.Equal(employee.PhoneNumber, employeeFromDb.PhoneNumber);
}
public async Task DeleteByIdAsyncWithWrongIdReturnsError()
{
var id = Guid.NewGuid().ToString();
var user = new CarpetUser
{
Id = id,
FirstName = "Иван",
LastName = "Иванов",
PhoneNumber = "0888777444",
Email = "*****@*****.**",
UserName = "******",
};
var roleAdminId = Guid.NewGuid().ToString();
var role = new CarpetRole {
Id = roleAdminId, Name = GlobalConstants.AdministratorRoleName
};
var roleOperatorId = Guid.NewGuid().ToString();
var roleOperator = new CarpetRole {
Id = roleOperatorId, Name = GlobalConstants.OperatorRoleName
};
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "DeleteByIdAsyncWithWrongIdReturnsError")
.Options;
var dbContext = new ApplicationDbContext(options);
dbContext.Users.Add(user);
dbContext.Roles.Add(role);
dbContext.Roles.Add(roleOperator);
await dbContext.SaveChangesAsync();
var repository = new EfDeletableEntityRepository <Employee>(dbContext);
var service = new EmployeesService(repository, dbContext);
var wrongId = Guid.NewGuid().ToString();
var employee = new EmployeeCreateInputModel
{
Id = id,
FirstName = "Иван",
LastName = "Иванов",
PhoneNumber = "0888777444",
Salary = 1000m,
RoleName = GlobalConstants.OperatorRoleName,
};
var employeeDelete = new EmployeeDeleteInputModel
{
Id = wrongId,
};
var result = await service.CreateAsync(employee, string.Empty);
var exception = await Assert.ThrowsAsync <NullReferenceException>(() => service.DeleteByIdAsync(employeeDelete.Id));
Assert.Equal(string.Format(string.Format(EmployeeConstants.NullReferenceId, wrongId)), exception.Message);
}
protected void cmdGetData_Click(object sender, EventArgs e)
{
// Create the proxy.
EmployeesService proxy = new EmployeesService();
// Call the web service and get the results.
GridView1.DataSource = proxy.GetEmployees();
GridView1.DataBind();
}
public EmployeesServiceTests()
{
long Id = singleEntity.Id;
Mock = DefaultContextMock.GetMock();
MockSet = SetUpMock.SetUpFor(testEntities);
Mock.Setup(c => c.Set <Employee>()).Returns(MockSet.Object);
Mock.Setup(c => c.Employee).Returns(MockSet.Object);
testedService = new EmployeesService(Mock.Object);
}
public IEnumerable <EmployeeSummary> GetEmployees(Guid?departmentId = null,
string city = null)
{
using (var service = new EmployeesService())
{
var employees = service.GetEmployees();
return(FilterEmployees(employees, departmentId, city)
.Select(employee => ConvertToEmployeeSummary(employee)));
}
}
public async Task CreateEmployee_NameNotSpecified_Fail()
{
var dto = new CreateEmployeeDTO();
await using var dbContext = GetDbContext();
var service = new EmployeesService(dbContext);
var result = await service.CreateEmployee(dto);
Assert.IsTrue(result.IsFailure);
}
public void TestInitialize()
{
_mock = AutoMock.GetLoose();
_service = _mock.Create <EmployeesService>();
Mapper.Reset();
Mapper.Initialize(cfg => { cfg.AddProfile <EmployeeProfile>(); });
}
static void Main()
{
UnitOfWork work = new UnitOfWork();
EmployeesService service = new EmployeesService(work);
Console.WriteLine(service.GetEmployeeByName("Guy").LastName);
//SoftuniContext context= new SoftuniContext();
// context.Employees.FirstOrDefault(employee => employee.FirstName == "Guy");
}
public async Task GetByUsernameAsyncReturnsCorrect()
{
var id = Guid.NewGuid().ToString();
var user = new CarpetUser
{
Id = id,
FirstName = "Иван",
LastName = "Иванов",
PhoneNumber = "0888777444",
Email = "*****@*****.**",
UserName = "******",
};
var roleAdminId = Guid.NewGuid().ToString();
var role = new CarpetRole {
Id = roleAdminId, Name = GlobalConstants.AdministratorRoleName
};
var roleOperatorId = Guid.NewGuid().ToString();
var roleOperator = new CarpetRole {
Id = roleOperatorId, Name = GlobalConstants.OperatorRoleName
};
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "GetByUsernameAsyncReturnsCorrect")
.Options;
var dbContext = new ApplicationDbContext(options);
dbContext.Users.Add(user);
dbContext.Roles.Add(role);
dbContext.Roles.Add(roleOperator);
await dbContext.SaveChangesAsync();
var repository = new EfDeletableEntityRepository <Employee>(dbContext);
var service = new EmployeesService(repository, dbContext);
var employee = new EmployeeCreateInputModel
{
Id = id,
FirstName = "Иван",
LastName = "Иванов",
PhoneNumber = "0888777444",
Salary = 1000m,
RoleName = GlobalConstants.OperatorRoleName,
};
var result = await service.CreateAsync(employee, string.Empty);
var username = await dbContext.Employees.FirstOrDefaultAsync(x => x.Id == result.Id);
var actual = await service.GetIdByUserNameAsync(username.User.UserName);
var employees = await service.GetAllAsync <EmployeeIndexViewModel>().ToListAsync();
Assert.Equal(result.Id, actual);
Assert.Single(employees);
}
public void TestGetAllByDepartmentIdNonExisting()
{
EmployeesService service = CreateService();
IEnumerable <Employee> employees = service.GetAll(3);
// The service must always return a collection, even when empty.
Assert.NotNull(employees);
// The service must return no items according to test configuration.
Assert.Empty(employees);
}
public void TestGetAll()
{
EmployeesService service = CreateService();
IEnumerable <Employee> employees = service.GetAll();
// The service must always return a collection, even when empty.
Assert.NotNull(employees);
// The service must return four items according to test configuration.
Assert.Equal(4, employees.Count());
}
private void Callback(IAsyncResult asyncResult)
{
// Retrieve the proxy from state.
EmployeesService proxy = (EmployeesService)asyncResult.AsyncState;
// Complete the call.
DataSet ds = proxy.EndGetEmployees(asyncResult);
// Update the user interface on the right thread.
this.Invoke(new UpdateGridDelegate(UpdateGrid), new object[] { ds });
}
public async Task CreateEmployee_NameSpecified_ContactsEmpty_Success()
{
var dto = new CreateEmployeeDTO {
Name = "name"
};
await using var dbContext = GetDbContext();
var service = new EmployeesService(dbContext);
var result = await service.CreateEmployee(dto);
Assert.IsTrue(result.IsSuccess);
}
protected void cmdGetData_Click(object sender, EventArgs e)
{
// Create the proxy.
EmployeesService proxy = new EmployeesService();
Uri newUrl = new Uri(proxy.Url);
proxy.Url = newUrl.Scheme + "://" + newUrl.Host + ":8080" + newUrl.AbsolutePath;
// Call the web service and get the results.
GridView1.DataSource = proxy.GetEmployees();
GridView1.DataBind();
}
/// <summary>
/// 删除
/// </summary>
/// <param name="id">员工id</param>
/// <returns></returns>
public async Task RemoveEmp(Guid id)
{
using IEmployeesService employeesService = new EmployeesService();
if (await employeesService.GetAllAsync().AnyAsync(i => i.Id == id))
{
var emp = employeesService.GetAllAsync().FirstOrDefault(i => i.Id == id);
if (emp != null)
{
await employeesService.RemoveAsync(id);
}
}
}
private void cmdGetData_Click(object sender, EventArgs e)
{
this.Cursor = Cursors.WaitCursor;
// Create the proxy.
EmployeesService proxy = new EmployeesService();
// Bind the results.
dataGridView1.DataSource = proxy.GetEmployees();
this.Cursor = Cursors.Default;
}
private void cmdError_Click(object sender, EventArgs e)
{
EmployeesService proxy = new EmployeesService();
try
{
int count = proxy.GetEmployeesCountError();
}
catch (SoapException err)
{
MessageBox.Show("Original error was: " + err.Detail.InnerText);
}
}
protected void cmdTest_Click(object sender, EventArgs e)
{
EmployeesService proxy = new EmployeesService();
proxy.GetEmployeesLogged();
}
protected void cmdCallWithout_Click(object sender, EventArgs e)
{
EmployeesService proxy = new EmployeesService();
GridView1.DataSource = proxy.GetEmployeesWseSecured();
GridView1.DataBind();
}
protected void cmdMultiple_Click(object sender, EventArgs e)
{
// Record the start time.
DateTime startTime = DateTime.Now;
EmployeesService proxy = new EmployeesService();
GetEmployeesDelegate async = new GetEmployeesDelegate(proxy.GetEmployeesSlow);
// Call three methods asynchronously.
IAsyncResult handle1 = async.BeginInvoke(null, null);
IAsyncResult handle2 = async.BeginInvoke(null, null);
IAsyncResult handle3 = async.BeginInvoke(null, null);
// Create an array of WaitHandle objects.
WaitHandle[] waitHandles = {handle1.AsyncWaitHandle,
handle2.AsyncWaitHandle, handle3.AsyncWaitHandle};
// Wait for all the calls to finish.
WaitHandle.WaitAll(waitHandles);
// You can now retrieve the results.
DataSet ds1 = async.EndInvoke(handle1);
DataSet ds2 = async.EndInvoke(handle2);
DataSet ds3 = async.EndInvoke(handle3);
// Merge all the results into one table and display it.
DataSet dsMerge = new DataSet();
dsMerge.Merge(ds1);
dsMerge.Merge(ds2);
dsMerge.Merge(ds3);
GridView1.DataSource = dsMerge;
GridView1.DataBind();
// Determine the total time taken.
TimeSpan timeTaken = DateTime.Now.Subtract(startTime);
lblInfo.Text = "Calling three methods took " + timeTaken.TotalSeconds +
" seconds.";
}