public void Setup()
{
_systemClock = MockRepository.GenerateStub<ISystemClock>();
_logger = MockRepository.GenerateMock<ILogger>(); //a Mock, because it's key to the test assertions
_messagingService = new MessagingService(_logger);
_supportCase = new SupportCase("Interacting with the logger", _systemClock);
}
public DisciplineView(ISystemDiscipline discipline, ISystemClock clock)
{
this.discipline = discipline;
clock.TickEvent += ClockTickEvent;
UpdateProperties();
}
public DevicesView(ISystemClock clock, ISystemDevices devices)
{
this.devices = devices;
this.clock = clock;
Update();
}
public void SetUp()
{
_systemClock = MockRepository.GenerateMock<ISystemClock>();
_systemClock.Stub(arg => arg.LocalDateTime).Return(new DateTime(2012, 1, 1, 0, 0, 0, DateTimeKind.Local));
_helper = new FormsAuthenticationHelper(_systemClock);
_cookie = _helper.GenerateTicket(_systemClock.LocalDateTime.AddYears(1), @"{ ""P"": ""V"" }", persistent:true);
}
public void TestInitialize()
{
generator = new MockSystemGenerator();
clock = new SystemClock();
engine = new Engine(clock, generator);
engine.NewRequestEvent += engine_NewRequestEvent;
}
public DeleteFieldRules(ISystemClock systemClock)
{
_systemClock = systemClock;
Rules = new List<IRule>();
Rules.Add(new FieldHasNoOutstandingTasks());
Rules.Add(new FieldHasNoOutstandingEvents(_systemClock));
}
public void TestInitialize()
{
clock = new SystemClock();
systemDiscipline = new Fifo();
systemDiscipline.TotalSize = size;
InitializeQueue();
}
public void SetUp()
{
_path = Path.GetTempFileName();
File.WriteAllText(_path, ".css { text-align: right; }");
_bundle = new Bundle().File("file1");
_fileSystem = MockRepository.GenerateMock<IFileSystem>();
_fileSystem.Stub(arg => arg.AbsolutePath("file1")).Return(_path);
_fileSystem
.Stub(arg => arg.OpenFile(_path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
.WhenCalled(arg => arg.ReturnValue = File.OpenRead(_path))
.Return(null);
_concatenator = MockRepository.GenerateMock<IAssetConcatenator>();
_concatenator
.Stub(arg => arg.Concatenate(Arg<IEnumerable<string>>.Is.Anything))
.WhenCalled(arg => arg.ReturnValue = ((IEnumerable<string>)arg.Arguments.First()).First())
.Return(null);
_transformer = MockRepository.GenerateMock<IAssetTransformer>();
_transformer
.Stub(arg => arg.Transform(Arg<string>.Is.Anything))
.WhenCalled(arg => arg.ReturnValue = arg.Arguments.First())
.Return(null);
_watcher = new BundleWatcher(_bundle, _fileSystem, _concatenator, _transformer);
_httpRuntime = MockRepository.GenerateMock<IHttpRuntime>();
_systemClock = MockRepository.GenerateMock<ISystemClock>();
_systemClock.Stub(arg => arg.UtcDateTime).Return(new DateTime(2012, 1, 1, 0, 0, 0, DateTimeKind.Utc));
_routeId = Guid.NewGuid();
_cssBundleWatcherRoute = new CssBundleWatcherRoute("route", _routeId, "relative", _watcher, _httpRuntime, _systemClock);
}
public void Setup()
{
_systemClock = MockRepository.GenerateStub<ISystemClock>();
_logger = new MockLogger();
_messagingService = new MessagingService(_logger);
_supportCase = new SupportCase("Looking at the logs", _systemClock);
}
private IMemoryCache CreateCache(ISystemClock clock)
{
return new MemoryCache(new MemoryCacheOptions()
{
Clock = clock,
CompactOnMemoryPressure = false,
});
}
public AspNetRuntimeCache(IHttpRuntime httpRuntime, ISystemClock systemClock)
{
systemClock.ThrowIfNull("systemClock");
systemClock.ThrowIfNull("systemClock");
_httpRuntime = httpRuntime;
_systemClock = systemClock;
}
public FormsAuthenticationHelper(IFormsAuthenticationConfiguration configuration, ISystemClock systemClock)
{
configuration.ThrowIfNull("configuration");
systemClock.ThrowIfNull("systemClock");
_configuration = configuration;
_systemClock = systemClock;
}
public QueuingSystem(ISystemConfiguration configuration, ISystemClock clock, IEngine engine, ISystemStatistics statistics)
{
Statistics = statistics;
Configuration = configuration;
Configuration.Devices.RequestHandledEvent += OnRequestHandled;
engine.NewRequestEvent += OnNewRequest;
clock.TickEvent += OnTickEvent;
}
public RunView(IQueuingSystem system, ISystemClock clock)
{
this.clock = clock;
this.system = system;
runCommand = new RelayCommand(Run);
stopCommand = new RelayCommand(Stop);
continueCommand = new RelayCommand(Continue);
resetCommand = new RelayCommand(Reset);
}
public void TestInitialize()
{
generator = new MockSystemGenerator();
request = Request.New(1, generator.NextProcessingTime, 1);
clock = new SystemClock();
d1 = new Device(clock);
d1.RequestHandledEvent += d1_RequestHandledEvent;
}
// Internal for testing
internal DateHeaderValueManager(
ISystemClock systemClock,
TimeSpan timeWithoutRequestsUntilIdle,
TimeSpan timerInterval)
{
_systemClock = systemClock;
_timeWithoutRequestsUntilIdle = timeWithoutRequestsUntilIdle;
_timerInterval = timerInterval;
}
public void TestInitialize()
{
generator = new MockSystemGenerator();
clock = new SystemClock();
devices = new SystemDevices(clock);
devices.Add(new Device(clock));
devices.Add(new Device(clock));
}
public DatabaseOperations(
string connectionString, string schemaName, string tableName, ISystemClock systemClock)
{
ConnectionString = connectionString;
SchemaName = schemaName;
TableName = tableName;
SystemClock = systemClock;
SqlQueries = new SqlQueries(schemaName, tableName);
}
public DefaultNonceValidator(IAntiCsrfConfiguration configuration, IAntiCsrfNonceRepository nonceRepository, ISystemClock systemClock)
{
configuration.ThrowIfNull("configuration");
nonceRepository.ThrowIfNull("nonceRepository");
systemClock.ThrowIfNull("systemClock");
_configuration = configuration;
_nonceRepository = nonceRepository;
_systemClock = systemClock;
}
public GraphGenerator()
{
this.InitializeComponent();
clock = App.Container.Resolve<ISystemClock>();
generator = App.Container.Resolve<ISystemGenerator>();
clock.TickEvent += clock_TickEvent;
// LineG
}
public InProcSessionCacheFixture() {
_nowUtc = new DateTime(2015, 10, 20, 21, 36, 14, DateTimeKind.Utc);
_fakeSystemClock = A.Fake<ISystemClock>();
ConfigureSystemClock_ToReturn(_nowUtc);
_inProcSessionCache = new InProcSessionCache(_fakeSystemClock);
_expiredSession = new InProcSession(new SessionId(Guid.NewGuid(), false), A.Dummy<ISession>(), _nowUtc.AddMinutes(-20), TimeSpan.FromMinutes(15));
_activeSession = new InProcSession(new SessionId(Guid.NewGuid(), false), A.Dummy<ISession>(), _nowUtc.AddMinutes(-3), TimeSpan.FromMinutes(15));
_inProcSessionCache.Set(_expiredSession);
_inProcSessionCache.Set(_activeSession);
_numberOfSessions = 2;
}
public DefaultGenerator(IAntiCsrfConfiguration configuration, IAntiCsrfNonceRepository nonceRepository, IGuidFactory guidFactory, ISystemClock systemClock)
{
configuration.ThrowIfNull("configuration");
nonceRepository.ThrowIfNull("nonceRepository");
guidFactory.ThrowIfNull("guidFactory");
systemClock.ThrowIfNull("systemClock");
_configuration = configuration;
_nonceRepository = nonceRepository;
_guidFactory = guidFactory;
_systemClock = systemClock;
}
public SqlServerCache(IOptions<SqlServerCacheOptions> options)
{
var cacheOptions = options.Value;
if (string.IsNullOrEmpty(cacheOptions.ConnectionString))
{
throw new ArgumentException(
$"{nameof(SqlServerCacheOptions.ConnectionString)} cannot be empty or null.");
}
if (string.IsNullOrEmpty(cacheOptions.SchemaName))
{
throw new ArgumentException(
$"{nameof(SqlServerCacheOptions.SchemaName)} cannot be empty or null.");
}
if (string.IsNullOrEmpty(cacheOptions.TableName))
{
throw new ArgumentException(
$"{nameof(SqlServerCacheOptions.TableName)} cannot be empty or null.");
}
if (cacheOptions.ExpiredItemsDeletionInterval.HasValue &&
cacheOptions.ExpiredItemsDeletionInterval.Value < MinimumExpiredItemsDeletionInterval)
{
throw new ArgumentException(
$"{nameof(SqlServerCacheOptions.ExpiredItemsDeletionInterval)} cannot be less the minimum " +
$"value of {MinimumExpiredItemsDeletionInterval.TotalMinutes} minutes.");
}
_systemClock = cacheOptions.SystemClock ?? new SystemClock();
_expiredItemsDeletionInterval =
cacheOptions.ExpiredItemsDeletionInterval ?? DefaultExpiredItemsDeletionInterval;
_deleteExpiredCachedItemsDelegate = DeleteExpiredCacheItems;
// SqlClient library on Mono doesn't have support for DateTimeOffset and also
// it doesn't have support for apis like GetFieldValue, GetFieldValueAsync etc.
// So we detect the platform to perform things differently for Mono vs. non-Mono platforms.
if (PlatformHelper.IsMono)
{
_dbOperations = new MonoDatabaseOperations(
cacheOptions.ConnectionString,
cacheOptions.SchemaName,
cacheOptions.TableName,
_systemClock);
}
else
{
_dbOperations = new DatabaseOperations(
cacheOptions.ConnectionString,
cacheOptions.SchemaName,
cacheOptions.TableName,
_systemClock);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SvnRevisionLabeller"/> class.
/// </summary>
/// <param name="systemClock">The system clock implementation that will be used when calculating date-based
/// revision numbers.</param>
public SvnRevisionLabeller(ISystemClock systemClock)
{
_systemClock = systemClock;
Major = 1;
Minor = 0;
Build = -1;
Pattern = "(major).(minor).(build).(revision)";
Executable = "svn.exe";
ResetBuildAfterVersionChange = true;
_rebuild = 0;
}
/// <summary>
/// Creates a new MemoryCache instance.
/// </summary>
/// <param name="clock"></param>
/// <param name="listenForMemoryPressure"></param>
public MemoryCache([NotNull] IOptions<MemoryCacheOptions> optionsAccessor)
{
var options = optionsAccessor.Options;
_entries = new Dictionary<string, CacheEntry>(StringComparer.Ordinal);
_entryLock = new ReaderWriterLockSlim();
_entryExpirationNotification = EntryExpired;
_clock = options.Clock ?? new SystemClock();
if (options.ListenForMemoryPressure)
{
GcNotification.Register(DoMemoryPreassureCollection, state: null);
}
_expirationScanFrequency = options.ExpirationScanFrequency;
_lastExpirationScan = _clock.UtcNow;
}
/// <summary>
/// Internal Constructor
/// </summary>
/// <param name="originalNow"></param>
/// <param name="systemNow"></param>
/// <param name="checkNow"></param>
/// <param name="expectedCount"></param>
/// <param name="nowFactory"></param>
internal SystemClockFixture(DateTime originalNow, DateTime systemNow,
Func<DateTime, DateTime> checkNow, int expectedCount, Func<DateTime> nowFactory)
{
_originalNow = originalNow;
_checkNow = checkNow;
_expectedCount = expectedCount;
_nowFactory = nowFactory;
// Verify before and after installation.
Verify(_checkNow(_originalNow), expectedCount - 1, nowFactory);
_clock = SystemClock.Install(systemNow);
Verify(_checkNow(systemNow), expectedCount, nowFactory);
}
public void SetUp()
{
_systemClock = MockRepository.GenerateMock<ISystemClock>();
_handler = new CacheableResponseHandler(_systemClock);
_httpRequest = MockRepository.GenerateMock<HttpRequestBase>();
_httpRequest.Stub(arg => arg.Headers).Return(new NameValueCollection());
_httpResponse = MockRepository.GenerateMock<HttpResponseBase>();
_httpResponse.Stub(arg => arg.Headers).Return(new NameValueCollection());
_cachePolicy = MockRepository.GenerateMock<ICachePolicy>();
_cachePolicy.Stub(arg => arg.Clone()).Return(_cachePolicy);
_cachePolicy.Stub(arg => arg.ClientCacheExpirationUtcTimestamp).Return(DateTime.UtcNow);
_response = MockRepository.GenerateMock<IResponse>();
_response.Stub(arg => arg.CachePolicy).Return(_cachePolicy);
_response.Stub(arg => arg.Cookies).Return(Enumerable.Empty<Cookie>());
_response.Stub(arg => arg.Headers).Return(Enumerable.Empty<Header>());
_response.Stub(arg => arg.StatusCode).Return(new StatusAndSubStatusCode(HttpStatusCode.OK));
_response.Stub(arg => arg.GetContent()).Return(new byte[0]);
_cache = MockRepository.GenerateMock<ICache>();
}
/// <summary>
/// Creates a new MemoryCache instance.
/// </summary>
/// <param name="clock"></param>
/// <param name="listenForMemoryPressure"></param>
public MemoryCache(IOptions<MemoryCacheOptions> optionsAccessor)
{
if (optionsAccessor == null)
{
throw new ArgumentNullException(nameof(optionsAccessor));
}
var options = optionsAccessor.Value;
_entries = new Dictionary<object, CacheEntry>();
_entryLock = new ReaderWriterLockSlim();
_entryExpirationNotification = EntryExpired;
_clock = options.Clock ?? new SystemClock();
if (options.CompactOnMemoryPressure)
{
GcNotification.Register(DoMemoryPreassureCollection, state: null);
}
_expirationScanFrequency = options.ExpirationScanFrequency;
_lastExpirationScan = _clock.UtcNow;
}
public void TestInitialize()
{
generator = new MockSystemGenerator();
clock = new SystemClock();
engine = new Engine(clock, generator);
devices = new SystemDevices(clock);
systemDiscipline = new Fifo {TotalSize = 10};
configuration = new SystemConfiguration(generator, devices, systemDiscipline);
statistics = new SystemStatistics();
system = new QueuingSystem(configuration, clock, engine, statistics);
InitializeDevices();
}
public ApiAuthHandler(IOptionsMonitor <ApiAuthOptions> options, ILoggerFactory logger, UrlEncoder encoder,
ISystemClock clock, ApiClientFactory factory)
: base(options, logger, encoder, clock)
{
Factory = factory;
}
public RoomItemGroupCommandHandler(IMapper mapper, IEventPublisher eventPublisher, IOptionsRepository optionsRepository, ISystemClock clock)
{
_mapper = mapper;
_eventPublisher = eventPublisher;
_optionsRepository = optionsRepository;
_clock = clock;
}
public SystemTokenAuthenticationHandler(IOptionsMonitor <Opts> options, ILoggerFactory logger,
UrlEncoder encoder, ISystemClock clock, IDatabase db) : base(options,
logger, encoder, clock)
{
_db = db;
}
public MPassSamlHandler(IOptionsMonitor <MPassSamlOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock)
: base(options, logger, encoder, clock)
{
}
public GetFeatureQueryHandlerTests()
{
this._clock = this.GivenClock();
}
public TodoItemDefinition(IResourceGraph resourceGraph, ISystemClock systemClock)
: base(resourceGraph)
{
_systemClock = systemClock;
}
public HttpConnection(HttpConnectionContext context)
{
_context = context;
_systemClock = _context.ServiceContext.SystemClock;
}
/// <summary>
/// Dependency-injection constructor
/// </summary>
/// <param name="clock"></param>
public Clock(ISystemClock clock)
{
InternalClock = clock;
}
/// <summary>
/// Siteminder Authentication Constructir
/// </summary>
/// <param name="configureOptions"></param>
/// <param name="loggerFactory"></param>
/// <param name="encoder"></param>
/// <param name="clock"></param>
public SiteminderAuthenticationHandler(IOptionsMonitor <SiteMinderAuthOptions> configureOptions, ILoggerFactory loggerFactory, UrlEncoder encoder, ISystemClock clock)
: base(configureOptions, loggerFactory, encoder, clock)
{
_logger = Log.Logger;
_ms_logger = loggerFactory.CreateLogger(typeof(SiteminderAuthenticationHandler));
_options = new SiteMinderAuthOptions();
}
public LinCmsResourceOwnerPasswordValidator(ISystemClock clock, AuditBaseRepository <LinUser> useRepository)
{
_clock = clock;
_useRepository = useRepository;
}
public UserSession(IHttpContextAccessor httpContextAccessor, IAuthenticationSchemeProvider schemes, IAuthenticationHandlerProvider handlers, IdentityServerOptions options, ISystemClock clock, ILogger <IUserSession> logger) : base(httpContextAccessor, schemes, handlers, options, clock, logger)
{
}
public ApiKeyAuthenticationHandler(IOptionsMonitor <ApiKeyAuthenticationOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock, IServiceProvider serviceProvider)
: base(options, logger, encoder, clock)
{
ServiceProvider = serviceProvider;
}
/// <summary>
/// Initializes a new instance of the <see cref="DeviceAuthorizationResponseGenerator"/> class.
/// </summary>
/// <param name="options">The options.</param>
/// <param name="userCodeService">The user code service.</param>
/// <param name="deviceFlowCodeService">The device flow code service.</param>
/// <param name="clock">The clock.</param>
/// <param name="logger">The logger.</param>
public DeviceAuthorizationResponseGenerator(IdentityServerOptions options, IUserCodeService userCodeService, IDeviceFlowCodeService deviceFlowCodeService, ISystemClock clock, ILogger <DeviceAuthorizationResponseGenerator> logger)
{
Options = options;
UserCodeService = userCodeService;
DeviceFlowCodeService = deviceFlowCodeService;
Clock = clock;
Logger = logger;
}
public TestAuthenticationHandler(IOptionsMonitor <TestAuthenticationOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock) : base(options, logger, encoder, clock)
{
}
public BasicAuthenticationHandler(IApiSignInManager apiSignInManager, IUserManager userManager, IOptionsMonitor <BasicAuthenticationOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock)
: base(options, logger, encoder, clock)
{
_apiSignInManager = apiSignInManager;
_userManager = userManager;
}
public ApiAuthenticationHandler(IOptionsMonitor <ApiAuthenticationOptions> options, UserManager <IdentityUser> userManager, IDataProtectionProvider dp, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock)
: base(options, logger, encoder, clock)
{
_log = logger.CreateLogger("ApiAuthenticationHandler");
if (dp == null)
{
return;
}
_format = new TicketDataFormat(dp.CreateProtector("APIAuthentication"));
_userManager = userManager;
}
public DiagnosticFactory(OperationEventSource eventSource, ISystemClock clock, IDiagnosticContext context)
{
EventSource = eventSource;
Clock = clock;
Context = context;
}
public FacadeAuthenticationHandler(AuthenticationClient client, IOptionsMonitor <FacadeAuthenticationOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock)
: base(options, logger, encoder, clock)
{
_client = client;
}
public ApiKeyAuthenticator(IOptionsMonitor <ApiKeyAuthOptions> options, ILoggerFactory logger,
UrlEncoder encoder, ISystemClock clock) : base(options, logger, encoder, clock)
{
_options = options;
}
public BearerTokenAuthenticationHandler(IOptionsMonitor <TokenAuthenticationOptions> options,
ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock, IConfiguration configuration)
: base(options, logger, encoder, clock)
{
_configuration = configuration;
}
public TokenAuthenticationHandler(IOptionsSnapshot <TokenAuthenticationOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock) : base(options, logger, encoder, clock)
{
}
public ApiAuthenticationHandler(IOptionsMonitor <AuthenticationSchemeOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock, IApiUserService userService)
: base(options, logger, encoder, clock)
{
service = userService;
}
private void Init(HttpContext context)
{
_options = _options ?? context.RequestServices.GetRequiredService <IdentityServerOptions>();
_clock = _clock ?? context.RequestServices.GetRequiredService <ISystemClock>();
_logoutMessageStore = _logoutMessageStore ?? context.RequestServices.GetRequiredService <IMessageStore <LogoutMessage> >();
}
public BasicAuthenticationHandler(IOptionsMonitor <AuthenticationSchemeOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock) : base(options, logger, encoder, clock)
{
}
public Heartbeat(IHeartbeatHandler[] callbacks, ISystemClock systemClock, IKestrelTrace trace)
{
_callbacks = callbacks;
_systemClock = systemClock;
_trace = trace;
}
public TwitterHandler2(IOptionsMonitor <TwitterOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock)
: base(options, logger, encoder, clock)
{
}
public AuthHandler(IOptionsMonitor <AuthOptions> options, ILoggerFactory logger, UrlEncoder encoder,
ISystemClock clock) : base(options, logger, encoder, clock)
{
}
public SvnRevisionLabellerStub(ISystemClock systemClock)
: base(systemClock)
{
}
public AssignIsBeforeStrategyToFeatureCommandTests()
{
this._clock = this.GivenClock();
}
public AzureStorageTableSasUri(ISystemClock clock)
{
_clock = clock;
}
public SwapSystemClock(ISystemClock replacementInstance)
{
_originalInstance = SystemClock.Instance;
SystemClock.Instance = replacementInstance;
}
