public void DeleteCatFromDatabase()
{
//Arrange
IAnimalRepository testrepo = DataTestService.GetInMemoryRepo();
var cat = new Cat()
{
Name = "TestKitty",
Description = "A fine test candidate",
Species = new Species
{
Name = "TestSpecies",
Description = "A test species"
},
SpeciesId = 0
};
testrepo.Save(cat);
//Act
testrepo.Delete(testrepo.Get(1).CatId); //Delete the cat we added to the db
//Assert
Assert.Empty(testrepo.Get()); //Assert that the database collection is empty
}
public void FindCatFromDatabase()
{
//Arrange we want a repo, fill it with a cat, then be able to find one by running the Find() method on its name
IAnimalRepository testrepo = DataTestService.GetInMemoryRepo();
var cat = new Cat()
{
Name = "TestKitty",
Description = "A fine test kitty",
Gender = Gender.Other,
SpeciesId = 0,
Species = new Species {
Name = "Testspecies", Description = "A species to test with", SpeciesId = 0
}
};
testrepo.Save(cat);
string searchString = "Test";
//Act we want to retrieve the cat, using its name
var result = testrepo.Find(searchString);
Assert.NotEmpty(result); //We do not want result to be empty of elements
Assert.Equal(cat.Name, result.First().Name.ToString()); //We expect there to only be one Cat in the list, i.e. the first element.
}
public void CatWithSameIDOverWritesCurrentCatInDB()
{
//Arrange
IAnimalRepository testrepo = DataTestService.GetInMemoryRepo();
var cat = new Cat()
{
Name = "TestKitty",
Description = "A fine test candidate"
};
testrepo.Save(cat);
var sameCat = testrepo.Get(1);
sameCat.Name = "TestKitty2";
//Act
testrepo.Save(sameCat);
//Assert
Assert.Single(testrepo.Get()); //We want there to still only be a single item in the list, since it should be overwritten
Assert.Equal(sameCat.Name, testrepo.Get(1).Name); //We want the name to have been updated
}
public AgendamentoService(IAgendamentoRepository agendamentoRepository, IVeterinarioRepository veterinarioRepository, IAnimalRepository animalRepository, IClienteRepository clienteRepository)
{
_agendamentoRepository = agendamentoRepository;
_veterinarioRepository = veterinarioRepository;
_animalRepository = animalRepository;
_clientesRepository = clienteRepository;
}
public AccountController(IUserHelper userHelper,
IConverterHelper converterHelper,
IMailHelper mailHelper,
IConfiguration configuration,
IClientRepository clientRepository,
IAdminRepository adminRepository,
IDoctorRepository doctorRepository,
IAppointmentRepository appointmentRepository,
IImageHelper imageHelper,
ISpecializationRepository specializationRepository,
IAnimalRepository animalRepository,
IDashBoardHelper dashBoardHelper)
{
_userHelper = userHelper;
_configuration = configuration;
_clientRepository = clientRepository;
_converterHelper = converterHelper;
_mailHelper = mailHelper;
_adminRepository = adminRepository;
_doctorRepository = doctorRepository;
_appointmentRepository = appointmentRepository;
_imageHelper = imageHelper;
_specializationRepository = specializationRepository;
_animalRepository = animalRepository;
_dashBoardHelper = dashBoardHelper;
}
public void TestSetup()
{
HelperMethods.InitialiseAutoMapper();
Mock <IContext> context = new Mock <IContext>();
context.Setup(x => x.Animals).Returns(mockAnimals);
context.Setup(x => x.Users).Returns(mockUsers);
context.Setup(x => x.AnimalTypes).Returns(mockAnimalTypes);
userRepository = new UserRepository(context.Object);
userManager = new UserManager(userRepository);
animalTypeRepository = new AnimalTypeRepository(context.Object);
animalTypeManager = new AnimalTypeManager(animalTypeRepository);
animalRepository = new AnimalRepository(context.Object);
animalStateManager = new AnimalStateManager();
animalManager = new AnimalManager(animalRepository, animalTypeManager, animalStateManager);
animalController = new AnimalController(userManager, animalManager, animalTypeManager);
}
public AnimalValidator(ICompanyRepository companyRepository, IAnimalRepository animalRepository)
{
this.companyRepository = companyRepository;
this.animalRepository = animalRepository;
// validation for name
RuleFor(animal => animal.Name)
.NotEmpty().WithLocalizedMessage(typeof(Errors), "ValidationRequired");
RuleFor(animal => animal.Name)
.MaximumLength(50).WithLocalizedMessage(typeof(Errors), "ValidationStringLength");
RuleFor(animal => animal.Name)
.Must(AnimalNameUniqueForCompany).WithLocalizedMessage(typeof(Errors), "ValidationUnique");
// validation for tattoo
RuleFor(animal => animal.Tattoo)
.Must(AnimalTattooUniqueForCompany).WithLocalizedMessage(typeof(Errors), "ValidationUnique");
// validation for gender (extra security)
RuleFor(animal => animal.Gender)
.Must(AnimalGenderDefined);
// validation for birth date
RuleFor(animal => animal.DateOfBirth)
.NotEmpty();
}
public void CatWithSameIDOverWritesCurrentCatInDB()
{
IAnimalRepository testrepo = DataTestService.GetInMemoryRepo();
var cat = new Cat()
{
Name = "TestKitty",
Description = "A fine test candidate"
};
testrepo.Save(cat);
var sameCat = testrepo.Get(1);
sameCat.Name = "TestKitty2";
testrepo.Save(sameCat);
Assert.Single(testrepo.Get());
Assert.Equal(sameCat.Name, testrepo.Get(1).Name);
}
public AnimalSheltersController(IAnimalShelterRepository animalShelterRepository, IAnimalRepository animalRepository,
IUserRepository userRepository)
{
_animalShelterRepository = animalShelterRepository;
_animalRepository = animalRepository;
_userRepository = userRepository;
}
public AnimalService(
IAnimalRepository repository,
IRecoverDataService recoverDataService,
IMapper mapper)
: base(repository, recoverDataService, mapper)
{
}
public BookingsController(IBookingRepository db1, IAccesoryRepository db2, IAnimalRepository db3, ICustomerRepository db4)
{
this.dbBooking = db1;
this.dbAccessory = db2;
this.dbAnimal = db3;
this.dbCustomer = db4;
}
public VisitorController(IAnimalRepository animalRepository,
IShelterRepository shelterRepository, IPostRepository postRepository)
{
_animalRepository = animalRepository;
_shelterRepository = shelterRepository;
_postRepository = postRepository;
}
public AnimalService(IAnimalRepository animalRepository, ISpeciesRepository speciesRepository, IMapper mapper, IUserRepository userRepository)
{
_animalRepository = animalRepository;
_speciesRepository = speciesRepository;
_userRepository = userRepository;
_mapper = mapper;
}
public AssetsService(IAssetsMainRepository assetsMainRep,
IAnimalRepository animalRep,
IBooksRepository bookRep,
ICarRepository carRep,
ILandRepository landRep,
IHouseRepository houseRep,
ICulturalrelicRepository culturalrelicRep,
IBuildingRepository buildingRep,
ISpecialRepository specialRep,
IGeneralRepository generalRep,
IAquairRepository aquairRep,
IClassCodeRepository classCodeRep,
IDiffResultRepository diffResultRep,
IDepartmentRepository deptRep,
IPlaceRepository placeRep,
ILedGerCachRepository ledGerCachRep,
IBorrowRepository borrowRep,
IBorrowDetailRepository borrowDetailRep,
IAquairDetailRepository aquairDetailRep,
IReturnDetailRepository returnDetailRep,
IRepairRepository repairRep,
IRepairDetailRepository repairDetailRep,
IScrapApllyRepository scrapApllyRep,
IScrapApplyDetailRepository srScrapApplyDetailRep,
IOrderListRepository orderListRep,
IInventoryRepository inventoryRep,
IInventoryDetailRepository inventoryDetailRep,
IServiceDetailRepository IServiceDetailRep
)
{
_assetsMainRep = assetsMainRep;
_animalRep = animalRep;
_bookRep = bookRep;
_carRep = carRep;
_houseRep = houseRep;
_landRep = landRep;
_culturalrelicRep = culturalrelicRep;
_buildingRep = buildingRep;
_specialRep = specialRep;
_generalRep = generalRep;
_aquairRep = aquairRep;
_classCodeRep = classCodeRep;
_diffResultRep = diffResultRep;
_deptRep = deptRep;
_placeRep = placeRep;
_ledGerCachRep = ledGerCachRep;
_borrowRep = borrowRep;
_borrowDetailRep = borrowDetailRep;
_aquairDetailRep = aquairDetailRep;
_returnDetailRep = returnDetailRep;
_repairRep = repairRep;
_repairDetailRep = repairDetailRep;
_scrapApllyRep = scrapApllyRep;
_srScrapApplyDetailRep = srScrapApplyDetailRep;
_orderListRep = orderListRep;
_inventoryRep = inventoryRep;
_inventoryDetailRep = inventoryDetailRep;
_IServiceDetailRep = IServiceDetailRep;
}
public AnimalsController(IAnimalRepository animalRepository, IPhotoRepository photoRepository,
IAnimalShelterRepository animalShelterRepository, IUserRepository userRepository)
{
_animalRepository = animalRepository;
_photoRepository = photoRepository;
_animalShelterRepository = animalShelterRepository;
_userRepository = userRepository;
}
public AnimalService(IAnimalRepository animalRepository,
IUserRepository userRepository,
IUserService userService)
{
_animalRepository = animalRepository;
_userRepository = userRepository;
_userService = userService;
}
public AnimaisController(
UserManager <ApplicationUser> userManager,
IAnimalRepository animalRepository
)
{
_userManager = userManager;
_animalRepository = animalRepository;
}
public ListingsController(IPetOwnerRepository po, IAnimalRepository animalRepo,
IListingRepository listingRepo, IEggRepository eggRepo)
{
_poRepo = po;
_aRepo = animalRepo;
_listingRepo = listingRepo;
_eggRepo = eggRepo;
}
public PetsController(IPetsViewRepository petsViewRepository,
IAnimalRepository animalRepository,
IMessaging messaging)
{
_petsViewRepository = petsViewRepository;
_animalRepository = animalRepository;
_messaging = messaging;
}
public static AnimalCatVM CreateAnimalCatDateVm(IAnimalRepository animalRepository)
{
return(new AnimalCatVM()
{
CatDate = new CatDate(),
CatSelectList = new SelectList(animalRepository.Get(), "CatId", "Name")
});
}
public void TestSetup()
{
Mock <IContext> context = new Mock <IContext>();
context.Setup(x => x.Animals).Returns(mockAnimals);
animalRepository = new AnimalRepository(context.Object);
}
public AnimalManager(IAnimalRepository animalRepository,
IAnimalTypeManager animalTypeManager,
IAnimalStateManager animalStateManager)
{
this.animalRepository = animalRepository;
this.animalTypeManager = animalTypeManager;
this.animalStateManager = animalStateManager;
}
public CompraGadoService(ICompraGadoRepository CompraGadoRepository, ICompraGadoValidar CompraGadoValidar, ICompraGadoItemRepository CompraGadoItemRepository, IPecuaristaRepository PecuaristaRepository, IAnimalRepository AnimalRepository)
: base(CompraGadoRepository)
{
_CompraGadoRepository = CompraGadoRepository;
_CompraGadoValidar = CompraGadoValidar;
_CompraGadoItemRepository = CompraGadoItemRepository;
_PecuaristaRepository = PecuaristaRepository;
_AnimalRepository = AnimalRepository;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="animalRepository"></param>
/// <param name="plantRepository"></param>
/// <param name="animalPlantHistoryRepository"></param>
public AnimalManagementService(
IAnimalRepository animalRepository,
IPlantRepository plantRepository,
IAnimalPlantHistoryRepository animalPlantHistoryRepository)
{
AnimalRepository = animalRepository;
PlantRepository = plantRepository;
AnimalPlantHistoryRepository = animalPlantHistoryRepository;
}
/// <summary>
/// Constructor takes three parameters and is handled automatically by ASP.NET
/// </summary>
/// <param name="poc">Constructor injection done by Services Providers</param>
/// <param name="animalRepo">Constructor injection done by Services Providers</param>
/// <param name="badgeRepository">Constructor injection done by Services Providers</param>
/// <param name="eggRepo">Constructor injection done by Services Providers</param>
public AnimalsController(IPetOwnerRepository poc, IAnimalRepository animalRepo,
IBadgeRepository badgeRepository, IEggRepository eggRepo, IItemRepository itemRepo)
{
_poc = poc;
_animalRepo = animalRepo;
_badgeRepo = badgeRepository;
_eggRepo = eggRepo;
_itemRepo = itemRepo;
}
public ScreenDrawer(IAnimalRepository animals)
{
Console.SetWindowSize(140, 47);
_animals = animals;
_showHelp = false;
_table = new BindedTable <Animal>(_animals.GetAll(), a => Tuple.Create <string, char, string>("Name|State|Health", '|', $"{a.ToString()}|{a.State}|{a.Health}/{a.MaxHealth}"));
_table.UsePageination();
CommandMessage = String.Empty;
EventMessage = String.Empty;
}
public WorkerFactory(ServiceProvider sp)
{
_sp = sp;
_sp.CreateScope();
_animalRepo = _sp.GetService <IAnimalRepository>();
_eggRepo = _sp.GetService <IEggRepository>();
_itemRepo = _sp.GetService <IItemRepository>();
_marketRepo = _sp.GetService <IMarketRepository>();
}
public ShelterController(IAnimalRepository animalRepository, IAdopterRepository adopterRepository,
IShelterRepository shelterRepository, IClaimProvider claimProvider, IAccessValidator accessValidator)
{
_animalRepository = animalRepository;
_adopterRepository = adopterRepository;
_shelterRepository = shelterRepository;
_shelterId = claimProvider.GetUserId();
_accessValidator = accessValidator;
}
public IndexModel(
IAnimalRepository animalRepository,
IAnimalCreateThirdOfLionsService animalCreateThirdOfLionsRepository,
IAnimalGetCreatedToday animalGetCreatedToday
)
{
_animalRepository = animalRepository;
_animalCreateThirdOfLionsRepository = animalCreateThirdOfLionsRepository;
_animalGetCreatedToday = animalGetCreatedToday;
}
public UserService(IUserRepository userRepository,
IAnimalToCareRepository animalToCareRepository,
IAnimalRepository animalRepository,
IEncrypter encrypter)
{
_userRepository = userRepository;
_animalToCareRepository = animalToCareRepository;
_animalRepository = animalRepository;
_encrypter = encrypter;
}