public MainWindowViewModel()
{
ClientsService cs = new ClientsService();
foreach (Client client in cs.GetAllAsync().Result)
{
ClientsList.Add(client);
}
/* Clients_Click = new DelegateCommand(openClientsWindow);
* AddEvent_Click = new DelegateCommand(Browse);
* Insurinces_Click = new DelegateCommand(serialize);*/
}
public void GetAllTests()
{
AutoMapperConfig.RegisterMappings(typeof(CreateCaseInputViewModel).GetTypeInfo().Assembly);
var mockUser1 = new Mock <ApplicationUser>();
mockUser1.Setup(x => x.Roles.Count).Returns(1);
mockUser1.Setup(x => x.CreatedOn).Returns(DateTime.UtcNow);
mockUser1.Setup(x => x.Id).Returns("1");
var mockUser2 = new Mock <ApplicationUser>();
mockUser2.Setup(x => x.Roles.Count).Returns(2);
mockUser2.Setup(x => x.CreatedOn).Returns(DateTime.UtcNow);
mockUser2.Setup(x => x.Id).Returns("2");
var mockUser3 = new Mock <ApplicationUser>();
mockUser3.Setup(x => x.Roles.Count).Returns(1);
mockUser3.Setup(x => x.CreatedOn).Returns(DateTime.UtcNow.AddDays(1));
mockUser3.Setup(x => x.Id).Returns("3");
var mockUser4 = new Mock <ApplicationUser>();
mockUser4.Setup(x => x.Roles.Count).Returns(1);
mockUser4.Setup(x => x.CreatedOn).Returns(DateTime.UtcNow.AddDays(2));
mockUser4.Setup(x => x.Id).Returns("4");
var clientsList = new List <ApplicationUser>();
clientsList.Add(mockUser1.Object);
clientsList.Add(mockUser2.Object);
clientsList.Add(mockUser3.Object);
clientsList.Add(mockUser4.Object);
var usersMockRepo = new Mock <IDeletableEntityRepository <ApplicationUser> >();
usersMockRepo.Setup(x => x.AllAsNoTracking())
.Returns(clientsList.AsQueryable);
var clientsService = new ClientsService(usersMockRepo.Object, null);
var result = clientsService.GetAll <SingleClientViewModel>(1, 2);
Assert.Equal("4", result.First().Id);
Assert.Equal(2, result.Count());
var result2 = clientsService.GetAll <SingleClientViewModel>(2, 2);
Assert.Single(result2);
}
public void ShouldRemoveClient()
{
// Arrange
this.clientTableRepository = Substitute.For <IClientTableRepository>();
this.clientTableRepository.ContainsById(Arg.Is(55)).Returns(true);
ClientsService clientsService = new ClientsService(this.clientTableRepository);
// Act
clientsService.RemoveClient(55);
// Assert
this.clientTableRepository.Received(1).Deactivate(55);
this.clientTableRepository.Received(1).SaveChanges();
}
public void GetClientByCaseIdTests()
{
AutoMapperConfig.RegisterMappings(typeof(CreateCaseInputViewModel).GetTypeInfo().Assembly);
// prep users
var mockUser1 = new Mock <ApplicationUser>();
mockUser1.Setup(x => x.Id).Returns("1");
var mockUser2 = new Mock <ApplicationUser>();
mockUser2.Setup(x => x.Id).Returns("2");
var clientsList = new List <ApplicationUser>();
clientsList.Add(mockUser1.Object);
clientsList.Add(mockUser2.Object);
var usersMockRepo = new Mock <IDeletableEntityRepository <ApplicationUser> >();
usersMockRepo.Setup(x => x.AllAsNoTracking())
.Returns(clientsList.AsQueryable);
// prep cases
var mockCase1 = new Mock <Case>();
mockCase1.Setup(x => x.Id).Returns("1");
mockCase1.Setup(x => x.ClientId).Returns("1");
var mockCase2 = new Mock <Case>();
mockCase2.Setup(x => x.Id).Returns("2");
mockCase2.Setup(x => x.ClientId).Returns("5");
var casesList = new List <Case>();
casesList.Add(mockCase1.Object);
casesList.Add(mockCase2.Object);
var casesMockRepo = new Mock <IDeletableEntityRepository <Case> >();
casesMockRepo.Setup(x => x.AllAsNoTracking())
.Returns(casesList.AsQueryable);
var clientsService = new ClientsService(usersMockRepo.Object, casesMockRepo.Object);
var result = clientsService.GetClientByCaseId("1");
Assert.Equal("1", result.Id);
}
public async Task EditAsync_ShouldReturn_True_AfterEntytyISEdited()
{
var db = this.GetDatabase();
var mapper = this.GetMapper();
var client = new Client
{
Id = 1,
Name = "Петров 96",
Address = "София Младост 6",
Bulstat = "BG063698652",
EGN = "9865321455",
AccountableName = "Иван Петров",
ContactName = "Иван Петров",
Telephone = "0895 69 32 14",
Notes = "без забележки",
IsDeleted = false,
Email = "*****@*****.**"
};
await db.Clients.AddAsync(client);
await db.SaveChangesAsync();
var clientService = new ClientsService(db, mapper);
//Act
var result = await clientService.EditAsync(1, "Иван NEW", "София 6 NEW", "Иван Петров", "9865321455", false, "Петров 96", "без забележки", "0895 69 32 14", "*****@*****.**");
var savedEntry = await db.Clients.FirstOrDefaultAsync(x => x.Name == "Петров 96");
//Assert
result
.Should()
.BeTrue();
savedEntry
.Should()
.NotBeNull();
savedEntry
.Should()
.BeOfType <Client>();
savedEntry
.Should()
.Match <Client>(x => x.AccountableName == "Иван NEW" &&
x.Address == "София 6 NEW" &&
x.Telephone == "0895 69 32 14" &&
x.Email == "*****@*****.**");
}
public void Initialize()
{
clientTableRepository = Substitute.For <IClientTableRepository>();
clientTableRepository.GetById(1).Returns(new ClientEntity()
{
Id = 1,
Balance = 0M,
Name = "Vlad Blood"
});
clientTableRepository.GetClientsInOrangeZone()
.Returns(new List <ClientEntity>());
clientTableRepository.GetClientsInBlackZone()
.Returns(new List <ClientEntity>());
clientsService = new ClientsService(clientTableRepository);
}
public RegisterModel(
UserManager <IdentityUser> userManager,
SignInManager <IdentityUser> signInManager,
ILogger <RegisterModel> logger,
ClientsService clientsService,
AdminsService adminsService,
IEmailSender emailSender)
{
_userManager = userManager;
_signInManager = signInManager;
_logger = logger;
_emailSender = emailSender;
this.clientsService = clientsService;
this.adminsService = adminsService;
}
public void GetClient_Should_return_client_When_client_exists()
{
// Arrange
var fakeRepository = new Mock <IClientsRepository>();
fakeRepository.Setup(x => x.GetClient(It.IsAny <int>())).Returns(new ClientDto {
Id = 1, Name = "Panama"
});
var sut = new ClientsService(fakeRepository.Object);
// Act
var result = sut.GetClient(1);
//Assert
result.Name.Should().Be("Panama");
}
public void ShouldThrowExceptionIfValidationRegDataFailed()
{
// Arrange
this.clientTableRepository = Substitute.For <IClientTableRepository>();
ClientsService clientsService = new ClientsService(this.clientTableRepository);
ClientRegistrationInfo args = new ClientRegistrationInfo();
args.LastName = "M";
args.FirstName = "LomonosovLomonosovLom";
args.PhoneNumber = "0";
// Act
clientsService.Validation(args);
// Assert
}
public void CreateClient_ResponseCaught_ShouldReturnId()
{
RequestManager.ResetCalls();
var taskId = Guid.NewGuid();
var name = "test client 1";
var email = "test client email 1";
var data = string.Empty;
var clientId = Guid.NewGuid();
var date = DateTime.UtcNow;
var callbackQueueName = taskId + "_" + "CallbackQueue";
var callbackQueueName1 = "";
var type = "";
var message = "";
RequestManager.Setup(x => x.TryToExecute(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.Callback <string, string, string>((typeParam, messageParam, callbackQueueNameParam) =>
{
type = typeParam;
callbackQueueName1 = callbackQueueNameParam;
message = messageParam;
})
.Returns(new RequestResult {
Result = true, Value = JsonConvert.SerializeObject(new { clientId })
});
var service = new ClientsService(RequestManager.Object);
var result = service.CreateClient(new Cliient {
Name = name, Email = email
});
NodeService.Verify(x => x.GetHotNodeId(currency), Times.Once);
RequestManager.Verify(x => x.TryToExecute(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()), Times.Once);
Assert.AreEqual(result.Id, clientId);
Assert.IsFalse(result.TaskId.HasValue);
Assert.IsTrue(message.Contains(callbackQueueName));
Assert.IsTrue(message.Contains(taskId.ToString()));
Assert.IsTrue(message.Contains(name));
Assert.IsTrue(message.Contains(email));
Assert.AreEqual(type, MessageType.Clients.ToString());
Assert.AreEqual(callbackQueueName1, callbackQueueName);
Assert.IsFalse(data.Contains(callbackQueueName));
Assert.IsFalse(data.Contains(taskId.ToString()));
Assert.IsTrue(data.Contains(name));
Assert.IsTrue(data.Contains(email));
}
static void Main(string[] args)
{
ClientsRegistrationService clientsRegistrationService = new ClientsRegistrationService();
// Client registration
ClientsService clientsService1 = clientsRegistrationService.AddClients(2);
ClientsService clientsService2 = clientsRegistrationService.AddClients(3);
ClientsService clientsService3 = clientsRegistrationService.AddClients(4);
ClientsService clientsService4 = clientsRegistrationService.AddClients(1);
// Clients get the menu
var Menu = clientsService1.GetMenu();
foreach (var salat in Menu)
{
Console.WriteLine("Salat name: {0} || Cost: {1}", salat.Name, salat.Cost);
}
// Clients make order
List <VegetableSalad> order1 = clientsService1.MakeOrder(new List <SaladOrder> {
new VinaigretteSaladOrder(), new GalaxySaladOrder()
});
List <VegetableSalad> order2 = clientsService2.MakeOrder(new List <SaladOrder> {
new VinaigretteSaladOrder(), new GalaxySaladOrder()
});
List <VegetableSalad> order3 = clientsService3.MakeOrder(new List <SaladOrder> {
new GalaxySaladOrder()
});
List <VegetableSalad> order4 = clientsService4.MakeOrder(new List <SaladOrder> {
new VinaigretteSaladOrder(), new GalaxySaladOrder()
});
// Get Sum of the order
//float BillSum1 = clientsService1.GetBill();
//float BillSum2 = clientsService2.GetBill();
//float BillSum3 = clientsService3.GetBill();
//float BillSum4 = clientsService4.GetBill();
//Console.WriteLine(BillSum1);
//Console.WriteLine(BillSum2);
//Console.WriteLine(BillSum3);
//Console.WriteLine(BillSum4);
// LeaveFeedback
clientsService1.LeaveFeedback("It's restauraunt have big potential", "Dima");
}
public async Task RemoveClient_NoProblems_RemoveSuccessfully()
{
// Arrange
var id = Guid.NewGuid();
var sut = new ClientsService(
this.clientsRepositoryMock.Object,
this.mapper);
// Act
await sut.DeleteClient(id);
// Assert
this.clientsRepositoryMock
.Verify(
q => q.Remove(It.Is <Guid>(param => param == id)),
Times.Once);
}
public Factory()
{
DbContext = new DefaultContext();
AccountsService = new AccountsService(DbContext);
ClientsService = new ClientsService(DbContext);
OpeningsService = new OpeningsService(DbContext);
DocumentsService = new DocumentsService(DbContext);
ReportsService = new ReportsService(DbContext);
DataInitializatorService = new DataInitializatorService(DbContext);
ProfitLossService = new ProfitLossService(this);
BalanceService = new BalanceService(this);
AccountsPrintService = new AccountsPrintService(this);
OpeningsPrintService = new OpeningsPrintService(this);
DocumentsPrintService = new DocumentsPrintService(this);
ReportsPrintService = new ReportsPrintService(this);
ProfitLossPrintService = new ProfitAndLossPrintService(this);
BalancePrintService = new BalancePrintService(this);
}
public async Task TestAddingInsurance()
{
var service = new ClientsService();
var client = await AddTestClient(service);
client.Insurances.Add(new VehicleInsuranceEntry {
CarPlate = "TST101010"
});
await service.SaveChangesAsync();
client = await service.FirstAsync(c => c.Name == "Test");
Assert.IsTrue(client.Insurances.Any());
service.Dispose();
}
public RecipesForm(RecipesService recipesService,
RecipesMedicamentsService recipesMedicamentsService,
MedicamentsService medicamentsService,
ClientsService clientsService,
DiseasesService diseasesService,
RecipeCreator recipeCreator)
{
_recipesService = recipesService;
_recipesMedicamentsService = recipesMedicamentsService;
_medicamentsService = medicamentsService;
_clientsService = clientsService;
_diseasesService = diseasesService;
_recipeCreator = recipeCreator;
InitializeComponent();
_recipesDataGridViewService = new DataGridViewService(RecipesDataGridView);
}
public async Task TestUpdatingClient()
{
var service = new ClientsService();
await AddTestClient(service);
var client = await service.FirstAsync(c => c.Name == "Test");
client.Name = "Test1Updated";
service.Update(client);
await service.SaveChangesAsync();
client = await service.FirstAsync(c => c.Name == "Test1Updated");
Assert.IsTrue(client != null);
service.Dispose();
}
public void ShouldRegisterNewClient()
{
//Arrange
ClientsService clientsService = new ClientsService(clientsTableRepository, accountTableRepository, stockPriceTableRepository, stockOfClientTableRepository, logger);
ClientRegistrationInfo args = new ClientRegistrationInfo();
args.Name = "John";
args.Surname = "Jaymson";
args.PhoneNumber = "+78908901234";
//Act
var clientId = clientsService.RegisterNewClient(args);
//Assert
clientsTableRepository.Received(1).Add(Arg.Is <ClientEntity>(
w => w.Name == args.Name &&
w.Surname == args.Surname &&
w.PhoneNumber == args.PhoneNumber));
clientsTableRepository.Received(1).SaveChanges();
}
public async Task GetAverageVotesShouldReturnCorrectValue()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var dbContext = new ApplicationDbContext(options);
var repository = new EfRepository <Vote>(dbContext);
var clientRepository = new EfDeletableEntityRepository <Client>(dbContext);
var workoutslistRepository = new EfDeletableEntityRepository <WorkoutsList>(dbContext);
var clientsService = new ClientsService(clientRepository, workoutslistRepository);
var service = new VotesService(repository, clientsService);
var vote1 = new Vote()
{
Id = 1, CoachId = "id", Value = 4,
};
var vote2 = new Vote()
{
Id = 2, CoachId = "id", Value = 2,
};
var vote3 = new Vote()
{
Id = 3, CoachId = "id", Value = 5,
};
var vote4 = new Vote()
{
Id = 4, CoachId = "id2", Value = 4,
};
dbContext.Add(vote1);
dbContext.Add(vote2);
dbContext.Add(vote3);
dbContext.Add(vote4);
await dbContext.SaveChangesAsync();
var result = service.GetAverageVotes("id");
var resultTwo = service.GetAverageVotes("id2");
Assert.Equal(3.6666666666666665, result);
Assert.Equal(4, resultTwo);
}
public void GetClientById_Returns_ClientExists()
{
var existingClientId = Guid.NewGuid();
var client = new Client
{
Id = existingClientId,
UserId = Guid.NewGuid(),
FirstName = "firstName",
LastName = "lastName"
};
clientRepositoryMock.Setup(clientRepositoryMock => clientRepositoryMock.GetClientByUserId(existingClientId)).Returns(client);
clientsService = new ClientsService(clientRepositoryMock.Object, reviewRepositoryMock.Object);
var searchedClient = clientsService.GetClientById(existingClientId.ToString());
Assert.IsNotNull(searchedClient);
}
public void ClientsService_Authenticate_NonExistingEmail_ReturnsNull()
{
//Arrange
string email = ArrangeProvider._EMAIL_;
Client client = ArrangeProvider.GetClient(id: email);
var mockRepo = new Mock <IClientsRepository>();
mockRepo.Setup(x => x.GetClientByEmail(email)).Returns(client);
var options = ArrangeProvider.GetAppSettingslOption();
var mapper = ArrangeProvider.GetMapper();
var service = new ClientsService(options, mapper, mockRepo.Object);
//Act
var result = service.Authenticate(ArrangeProvider._EMAIL2_);
//Assert
Assert.IsNull(result);
}
//Ajouter Client
private void ajouterClient()
{
//Vide les champs
tb_codeClient.Text = ClientsService.getcdClientmax().ToString();
tb_raisonSocial.Text = null;
tb_adressePostale.Text = null;
tb_codePostale.Text = null;
tb_ville.Text = null;
tb_pays.Text = null;
//Active la modification des champs
tb_raisonSocial.ReadOnly = false;
tb_adressePostale.ReadOnly = false;
tb_codePostale.ReadOnly = false;
tb_ville.ReadOnly = false;
tb_pays.ReadOnly = false;
//Affiche les boutons de validation
bt_valider.Visible = true;
bt_annuler.Visible = true;
}
public void GetClientById_ThrowsEntityNotFound_ClientDoesntExist()
{
var nonExistingClient = Guid.NewGuid().ToString();
var existingClient = Guid.NewGuid();
var client = new Client
{
Id = existingClient,
FirstName = "firstName",
LastName = "lastName"
};
clientRepositoryMock.Setup(clientRepositoryMock => clientRepositoryMock.GetClientByUserId(existingClient)).Returns(client);
clientsService = new ClientsService(clientRepositoryMock.Object, reviewRepositoryMock.Object);
Assert.ThrowsException <EntityNotFoundException>(() =>
{
clientsService.GetClientById(nonExistingClient);
});
}
public App(IPhraseProvider phraseProvider, IInputOutput inputOutputModule, ISettingsProvider settingsProvider,
ClientsService clientsService, TradingService tradingService, ShowDbInfoService showDbInfoService)
{
this.phraseProvider = phraseProvider;
this.inputOutputModule = inputOutputModule;
this.clientsService = clientsService;
this.tradingService = tradingService;
this.showDbInfoService = showDbInfoService;
try
{
this.gameSettings = settingsProvider.GetGameSettings();
}
catch (ArgumentException ex)
{
inputOutputModule.WriteOutput(ex.Message);
this.gameSettings = null;
return;
}
}
public void ClientsService_GetClientById_NonExistingId_ReturnsNull()
{
//Arrange
string id = ArrangeProvider._ID1_;
Client client = ArrangeProvider.GetClient(id: id);
var mockRepo = new Mock <IClientsRepository>();
mockRepo.Setup(x => x.GetClientById(id)).Returns(client);
var options = ArrangeProvider.GetAppSettingslOption();
var mapper = ArrangeProvider.GetMapper();
var service = new ClientsService(options, mapper, mockRepo.Object);
//Act
var result = service.GetClientById(ArrangeProvider._ID0_);
//Assert
Assert.IsNull(result);
}
public void ClientsService_GetClientByName_NonExistingName_ReturnsNull()
{
//Arrange
string name = ArrangeProvider._NAME_;
Client client = ArrangeProvider.GetClient(email: name);
var mockRepo = new Mock <IClientsRepository>();
mockRepo.Setup(x => x.GetClientByName(name)).Returns(client);
var options = ArrangeProvider.GetAppSettingslOption();
var mapper = ArrangeProvider.GetMapper();
var service = new ClientsService(options, mapper, mockRepo.Object);
//Act
var result = service.GetClientByName(ArrangeProvider._NAME2_);
//Assert
Assert.IsNull(result);
}
public async Task UpdateClient_NoProblems_UpdatedSuccessfully()
{
// Arrange
var clientEntity = new ClientEntity(Guid.NewGuid(), "Client 1");
var clientModel = this.mapper.Map <ClientModel>(clientEntity);
var sut = new ClientsService(
this.clientsRepositoryMock.Object,
this.mapper);
// Act
await sut.UpdateClient(clientModel);
// Assert
this.clientsRepositoryMock
.Verify(
q => q.Update(It.Is <ClientEntity>(param =>
param.Id == clientEntity.Id &&
param.Name == clientEntity.Name)),
Times.Once);
}
public async Task SetVoteShouldChangeVoteValueCorrectly()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var dbContext = new ApplicationDbContext(options);
var repository = new EfRepository <Vote>(dbContext);
var clientRepository = new EfDeletableEntityRepository <Client>(dbContext);
var client = new Client
{
Id = "clientId",
Name = "random",
Phone = "088",
PositionPlayed = PositionName.Center,
User = new ApplicationUser {
Id = "clientuserId", Email = "*****@*****.**"
},
UserId = "clientuserId",
};
await dbContext.Clients.AddAsync(client);
await dbContext.SaveChangesAsync();
var workoutslistRepository = new EfDeletableEntityRepository <WorkoutsList>(dbContext);
var clientsService = new ClientsService(clientRepository, workoutslistRepository);
var service = new VotesService(repository, clientsService);
await service.SetVoteAsync("coachId", "clientuserId", 2);
await service.SetVoteAsync("coachId", "clientuserId", 5);
var count = repository.All();
var vote = await repository.All().FirstAsync(x => x.CoachId == "coachId");
Assert.Equal(1, await count.CountAsync());
Assert.Equal(5, vote.Value);
}
public async Task EditAsync_ShouldReturn_False_IfClientDoNotExists()
{
var db = this.GetDatabase();
var mapper = this.GetMapper();
var client = new Client
{
Name = "Петров 96",
Address = "София Младост 6",
Bulstat = "BG063698652",
EGN = "9865321455",
AccountableName = "Иван Петров",
ContactName = "Иван Петров",
Telephone = "0895 69 32 14",
Notes = "без забележки",
IsDeleted = false,
Email = "*****@*****.**"
};
await db.Clients.AddAsync(client);
await db.SaveChangesAsync();
var clientService = new ClientsService(db, mapper);
//Act
var result = await clientService.EditAsync(2, "Иван NEW", "София 6 NEW", "Иван Петров", "9865321455", false, "Петров 96", "без забележки", "0895 69 32 14", " Greda");
var savedEntry = await db.FindAsync <Client>(2);
//Assert
result
.Should()
.BeFalse();
savedEntry
.Should()
.BeNull();
}
public void ShouldNotRegisterNewTypeOfStockIfItExists()
{
//Arrange
ClientsService clientsService = new ClientsService(clientsTableRepository, accountTableRepository, stockPriceTableRepository, stockOfClientTableRepository, logger);
StockPriceInfo args = new StockPriceInfo()
{
TypeOfStock = "A",
PriceOfStock = 10
};
StockPriceEntity stockPrice = new StockPriceEntity();
stockPriceTableRepository.GetStockPriceEntityByStockType(Arg.Is <string>(w => w == args.TypeOfStock.ToUpper())).Returns(stockPrice);
//Act
clientsService.RegisterNewTypeOfStock(args);
//Assert
stockPriceTableRepository.Received(1).Add(Arg.Is <StockPriceEntity>(
w => w.TypeOfStock == args.TypeOfStock &&
w.PriceOfStock == args.PriceOfStock));
stockPriceTableRepository.Received(1).SaveChanges();
}
public void ClientsService_Authenticate_ExistingEmailAndSpecificRole_ReturnsValidJWDTokenWithSameRole()
{
//Arrange
string email = ArrangeProvider._EMAIL_;
string role = Role.Admin;
Client client = ArrangeProvider.GetClient(id: email, role: role);
var mockRepo = new Mock <IClientsRepository>();
mockRepo.Setup(x => x.GetClientByEmail(email)).Returns(client);
var options = ArrangeProvider.GetAppSettingslOption();
var mapper = ArrangeProvider.GetMapper();
var service = new ClientsService(options, mapper, mockRepo.Object);
//Act
var result = service.Authenticate(ArrangeProvider._EMAIL_);
//Assert
Assert.AreEqual(role, result.Role);
}
