public TaxonomyService(
ITaxonomyRepository taxonomyRepository,
ILogWrapper logger)
{
TaxonomyRepository = taxonomyRepository;
Logger = logger;
}
public JobProfileCategoryRepositoryUnitTests()
{
fakeSearchService = A.Fake <ISearchQueryService <JobProfileIndex> >();
fakeMapper = A.Fake <IMapper>();
dummyTaxon = GetDummyTaxon("categoryTwo");
fakeTaxonomyRepository = A.Fake <ITaxonomyRepository>();
}
public PostService(IPostRepository postRepository, IUserRepository userRepository, ITaxonomyRepository taxonomyRepository, IMapperService mapperService)
{
_postRepository = postRepository;
_userRepository = userRepository;
_taxonomyRepository = taxonomyRepository;
_mapperService = mapperService;
}
public ConsistRepositoryContext(ILogger logger = null)
{
Dapper.DefaultTypeMap.MatchNamesWithUnderscores = true;
var conection = ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString;
_connection = new TransactedOracleConnection(conection);
TaxonomyReportRepository = new TaxonomyReportRepository(_connection, logger);
LocalReportRepository = new LocalReportRepository(_connection, logger);
PeriodTypeRepository = new PeriodTypeRepository(_connection, logger);
LocalEntityRepository = new LocalEntityRepository(_connection, logger);
TaxonomyRepository = new TaxonomyRepository(_connection, logger);
}
/// <summary>
/// Constructor where all the required dependencies are injected
/// </summary>
/// <param name="errorSettings"></param>
/// <param name="taxonomySettings"></param>
/// <param name="generalSettings"></param>
/// <param name="spoAuthorization"></param>
/// <param name="matterCenterServiceFunctions"></param>
/// <param name="taxonomyRepository"></param>
public TaxonomyController(IOptions <ErrorSettings> errorSettings,
IOptions <TaxonomySettings> taxonomySettings,
IOptions <GeneralSettings> generalSettings,
ISPOAuthorization spoAuthorization,
IMatterCenterServiceFunctions matterCenterServiceFunctions,
ITaxonomyRepository taxonomyRepository, ICustomLogger customLogger, IOptions <LogTables> logTables)
{
this.errorSettings = errorSettings.Value;
this.taxonomySettings = taxonomySettings.Value;
this.generalSettings = generalSettings.Value;
this.spoAuthorization = spoAuthorization;
this.matterCenterServiceFunctions = matterCenterServiceFunctions;
this.taxonomyRepository = taxonomyRepository;
this.customLogger = customLogger;
this.logTables = logTables.Value;
}
/// <summary>
/// Constructor where all the required dependencies are injected
/// </summary>
/// <param name="errorSettings"></param>
/// <param name="taxonomySettings"></param>
/// <param name="generalSettings"></param>
/// <param name="spoAuthorization"></param>
/// <param name="matterCenterServiceFunctions"></param>
/// <param name="taxonomyRepository"></param>
public TaxonomyController(IOptions<ErrorSettings> errorSettings,
IOptions<TaxonomySettings> taxonomySettings,
IOptions<GeneralSettings> generalSettings,
ISPOAuthorization spoAuthorization,
IMatterCenterServiceFunctions matterCenterServiceFunctions,
ITaxonomyRepository taxonomyRepository, ICustomLogger customLogger, IOptions<LogTables> logTables)
{
this.errorSettings = errorSettings.Value;
this.taxonomySettings = taxonomySettings.Value;
this.generalSettings = generalSettings.Value;
this.spoAuthorization = spoAuthorization;
this.matterCenterServiceFunctions = matterCenterServiceFunctions;
this.taxonomyRepository = taxonomyRepository;
this.customLogger = customLogger;
this.logTables = logTables.Value;
}
/// <summary>
/// Initializes a new instance of the <see cref="PreSearchFiltersController"/> class.
/// </summary>
/// <param name="applicationLogger">application logger</param>
/// <param name="preSearchFiltersFactory">Sitefinity Repository to use</param>
/// <param name="preSearchFilterStateManager">Pre search filter state manager</param>
/// <param name="autoMapper">Instance of auto mapper</param>
/// <param name="searchQueryService">Instance of search query service</param>
/// <param name="buildSearchFilterService">Instance of search filter service</param>
/// <param name="asyncHelper">Instance of asyncHelper</param>
/// <param name="taxonomyRepository">Instance of taxonomyRepository</param>
public PreSearchFiltersController(
IApplicationLogger applicationLogger,
IMapper autoMapper,
IPreSearchFiltersFactory preSearchFiltersFactory,
IPreSearchFilterStateManager preSearchFilterStateManager,
ISearchQueryService <JobProfileIndex> searchQueryService,
IBuildSearchFilterService buildSearchFilterService,
IAsyncHelper asyncHelper,
ITaxonomyRepository taxonomyRepository) : base(applicationLogger)
{
this.preSearchFiltersFactory = preSearchFiltersFactory;
this.autoMapper = autoMapper;
this.preSearchFilterStateManager = preSearchFilterStateManager;
this.searchQueryService = searchQueryService;
this.buildSearchFilterService = buildSearchFilterService;
this.asyncHelper = asyncHelper;
this.taxonomyRepository = taxonomyRepository;
}
private void SetUpFakesAndCalls(bool addNotApplicable = true)
{
psfRepositoryFactoryFake = A.Fake <IPreSearchFiltersFactory>(ops => ops.Strict());
loggerFake = A.Fake <IApplicationLogger>();
A.Fake <IWebAppContext>(ops => ops.Strict());
psfFakeIntrestRepository = A.Fake <IPreSearchFiltersRepository <PsfInterest> >(ops => ops.Strict());
psfFakeEnablerRepository = A.Fake <IPreSearchFiltersRepository <PsfEnabler> >(ops => ops.Strict());
psfFakeQalificationsRepository = A.Fake <IPreSearchFiltersRepository <PsfEntryQualification> >(ops => ops.Strict());
psfFakeTrainingRepository = A.Fake <IPreSearchFiltersRepository <PsfTrainingRoute> >(ops => ops.Strict());
psfFakeJobAreaRepository = A.Fake <IPreSearchFiltersRepository <PsfJobArea> >(ops => ops.Strict());
psfFakeCareerFocusRepository = A.Fake <IPreSearchFiltersRepository <PsfCareerFocus> >(ops => ops.Strict());
psfFakePreferredTaskTypeRepository = A.Fake <IPreSearchFiltersRepository <PsfPreferredTaskType> >(ops => ops.Strict());
fakeBuildSearchFilterService = A.Fake <IBuildSearchFilterService>(ops => ops.Strict());
fakeSearchQueryService = A.Fake <ISearchQueryService <JobProfileIndex> >(ops => ops.Strict());
fakeTaxonomyRepository = A.Fake <ITaxonomyRepository>(ops => ops.Strict());
fakeAsyncHelper = new AsyncHelper();
A.Fake <IMapper>(ops => ops.Strict());
//Set up call
A.CallTo(() => psfFakeIntrestRepository.GetAllFilters()).Returns(GetTestFilterRepoOptions <PsfInterest>(addNotApplicable));
A.CallTo(() => psfFakeEnablerRepository.GetAllFilters()).Returns(GetTestFilterRepoOptions <PsfEnabler>(addNotApplicable));
A.CallTo(() => psfFakeQalificationsRepository.GetAllFilters()).Returns(GetTestFilterRepoOptions <PsfEntryQualification>(addNotApplicable));
A.CallTo(() => psfFakeTrainingRepository.GetAllFilters()).Returns(GetTestFilterRepoOptions <PsfTrainingRoute>(addNotApplicable));
A.CallTo(() => psfFakeJobAreaRepository.GetAllFilters()).Returns(GetTestFilterRepoOptions <PsfJobArea>(addNotApplicable));
A.CallTo(() => psfFakeCareerFocusRepository.GetAllFilters()).Returns(GetTestFilterRepoOptions <PsfCareerFocus>(addNotApplicable));
A.CallTo(() => psfFakePreferredTaskTypeRepository.GetAllFilters()).Returns(GetTestFilterRepoOptions <PsfPreferredTaskType>(addNotApplicable));
A.CallTo(() => fakeTaxonomyRepository.GetMany(A <Expression <Func <HierarchicalTaxon, bool> > > ._)).Returns(new EnumerableQuery <HierarchicalTaxon>(new List <HierarchicalTaxon>()));
A.CallTo(() => psfRepositoryFactoryFake.GetRepository <PsfInterest>()).Returns(psfFakeIntrestRepository);
A.CallTo(() => psfRepositoryFactoryFake.GetRepository <PsfEnabler>()).Returns(psfFakeEnablerRepository);
A.CallTo(() => psfRepositoryFactoryFake.GetRepository <PsfEntryQualification>()).Returns(psfFakeQalificationsRepository);
A.CallTo(() => psfRepositoryFactoryFake.GetRepository <PsfTrainingRoute>()).Returns(psfFakeTrainingRepository);
A.CallTo(() => psfRepositoryFactoryFake.GetRepository <PsfJobArea>()).Returns(psfFakeJobAreaRepository);
A.CallTo(() => psfRepositoryFactoryFake.GetRepository <PsfCareerFocus>()).Returns(psfFakeCareerFocusRepository);
A.CallTo(() => psfRepositoryFactoryFake.GetRepository <PsfPreferredTaskType>()).Returns(psfFakePreferredTaskTypeRepository);
}
public JobProfileCategoryRepository(ISearchQueryService <JobProfileIndex> jobprofileSearchQueryService, IMapper mapper, ITaxonomyRepository taxonomyRepository)
{
this.jobprofileSearchQueryService = jobprofileSearchQueryService;
this.mapper = mapper;
this.taxonomyRepository = taxonomyRepository;
}
public TaxonomyService(ITaxonomyRepository taxonomyRepository)
{
_taxonomyRepository = taxonomyRepository;
}
public void Setup()
{
_articleRepository = MockRepository.GenerateStub<IArticleRepository>();
_articleTaxonomyRepository = MockRepository.GenerateStub<IArticleTaxonomyRepository>();
_staticContentLinkService = MockRepository.GenerateStub<IStaticContentLinkService>();
_urlHelper = MockRepository.GenerateStub<IUrlHelper>();
_taxonomyRepository = MockRepository.GenerateStub<ITaxonomyRepository>();
_articleService = new ArticleService(_articleRepository, _articleTaxonomyRepository, _taxonomyRepository);
_objectUnderTest = new ArticleController(_articleService, _staticContentLinkService, _urlHelper);
_objectUnderTest.Request = new HttpRequestMessage();
_objectUnderTest.Request.SetConfiguration(new HttpConfiguration());
}
public TaxonomyService(ITaxonomyRepository taxonomyRepository, IMapperService mapperService)
{
_taxonomyRepository = taxonomyRepository;
_mapperService = mapperService;
}
public ArticleService(IArticleRepository articleRepository, IArticleTaxonomyRepository articleTaxonomyRepository, ITaxonomyRepository taxonomyRepository)
{
_articleRepository = articleRepository;
_articleTaxonomyRepository = articleTaxonomyRepository;
_taxonomyRepository = taxonomyRepository;
}
public PostService(IPostRepository postRepository, IUserRepository userRepository, ITaxonomyRepository taxonomyRepository)
{
_postRepository = postRepository;
_userRepository = userRepository;
_taxonomyRepository = taxonomyRepository;
}
public TaxonomyModel(ILogger <TaxonomyModel> logger, ITaxonomyRepository taxonomyRepository, IExamsRepository examsRepository)
{
_logger = logger;
_taxonomyRepository = taxonomyRepository;
_examsRepository = examsRepository;
}
