public void AddAddsItemToCache() { // arrange const string key = "key"; const string value = "value"; // act _cache.Add(key, value); // assert _cache.Get().Should().HaveCount(1); _cache.Get(key).Should().BeEquivalentTo(value); }
/// <summary> /// Get the status of the selected component /// </summary> /// <returns>Dependency object containing the status and other information</returns> public Dependency GetHealth() { //Prevent multiple parallel invocations lock (lockObj) { //Initially assume status is down attachedDependency.Status = Enums.DependencyStatus.DOWN; try { if (cache.IsCached) { if (cacheManager.Contains(attachedDependency.Name)) { return(cacheManager.GetData <Dependency>(attachedDependency.Name)); } } SetHealthImplementation(); if (cache.IsCached) { //TODO: cache policy/expiry handling cacheManager.Add <Dependency>(attachedDependency.Name, attachedDependency); } } catch { //TODO: Log? } return(attachedDependency); } }
public void ChainCacheGet_Success() { Customer customer = TestData.CreateCustomer(); // Create the 2 Caches ICache localCache = new InMemoryCache(); ICache remoteCache = new InMemoryCache(); // Add item to remoteCache remoteCache.Add <Customer>(customer.Id, customer); // IChainedCache // Hookup the cache Chain ChainedCache chainedCache = new ChainedCache(); chainedCache.LinkFirst(remoteCache); chainedCache.LinkFirst(localCache); // This should have 1 miss (debug it to ensure) Customer cachedCustomer = (Customer)chainedCache.Get(customer.Id); // This should have 0 miss (debug it to ensure) since it was added in the last Get() cachedCustomer = (Customer)chainedCache.Get(customer.Id); // Assert Assert.IsNotNull(cachedCustomer); }
} // end of GenerateSqlSlowDict method #endregion private static methods declarations #region private methods declarations /// <summary>Saves single row & slow changing metric</summary> private void WriteSlowSingleRowToRepository(int targetId, MetricGroup metricGroup, ProbeResultingData data) { int dataMatches; string dataSqlStmt; object[] newValues; // compare with in-memory data dataMatches = this.CompareSlowSingleRowWithInMemoryData(targetId, metricGroup, data, this.reposConn); // generate SQL statement dataSqlStmt = GenerateSqlSingleRowSlow(targetId, metricGroup, dataMatches, data); _logger.Trace(dataSqlStmt); SqlServerProbe.ExecuteSql(dataSqlStmt, targetId, metricGroup); // update in-memory data newValues = new object[data.NumberOfColumns]; for (int i = 0; i < data.NumberOfColumns; i++) { newValues[i] = data.values[0, i]; } if (dataMatches == -1) { InMemoryCache.Add(InMemoryCache.GetCacheKey(targetId, metricGroup), -1, new object[] { targetId }, newValues); } else { Configuration.inMemoryCache[InMemoryCache.GetCacheKey(targetId, metricGroup)].UpdateRowValues(new object[] { targetId }, newValues); } } // end of WriteSlowSingleRowToRepository function
public ImportJob( IImportJobRepository importJobRepository, InMemoryCache <TradeAccountModel> tradeAcccountModel, InMemoryCache <TradeMasterAccountModel> tradeMasterAccountModel, InMemoryCache <TradeInstrumentModel> tradeInstrumentModel, InMemoryCache <TradeFeeTypeModel> tradeFeeTypesModel, IContract wcf, FileNameMatcher fileNameMatcher, IExtractFileService extractFileService) : base(wcf) { _job = Job.Import; _tradeAccountModel = tradeAcccountModel; _tradeInstrumentModel = tradeInstrumentModel; _tradeFeeTypesModel = tradeFeeTypesModel; _tradeMasterAccountModel = tradeMasterAccountModel; _importJobRepository = importJobRepository; _extractFileService = extractFileService; _fileNameMatcher = fileNameMatcher; using (var tradeContext = _importJobRepository.BeginOperation()) { foreach (var masterAccount in _importJobRepository.GetAllMasterAccounts()) { _tradeMasterAccountModel.Add(masterAccount.AccountName, new TradeMasterAccountModel { Id = masterAccount.Id }); } foreach (var instrument in _importJobRepository.GetTradeInstrument()) { _tradeInstrumentModel.Add(instrument.InstrumentName, new TradeInstrumentModel { Id = instrument.Id }); } foreach (var trade in _importJobRepository.GetTradeAccount()) { _tradeAccountModel.Add(trade.AccountName, new TradeAccountModel { Id = trade.Id }); } foreach (var tradeFeeType in _importJobRepository.GetTradeFeeType()) { _tradeFeeTypesModel.Add(tradeFeeType.TradeFeeTypeName, new TradeFeeTypeModel { Id = tradeFeeType.Id }); } } }
public void Return_True_When_A_Value_Is_Successfully_Added() { // Arrange const string cacheName = "SuperHeroesCache"; var cache = new InMemoryCache( cacheName ); var superman = new SuperHero { SuperHeroName = "Superman", RealFirstName = "Clark", RealLastName = "Kent" }; // Act var valueAdded = cache.Add( superman.SuperHeroName, superman ); // Assert Assert.True( valueAdded ); }
public void Return_False_When_A_Null_Value_Is_Added() { // Arrange const string cacheName = "SuperHeroesCache"; var cache = new InMemoryCache( cacheName ); SuperHero superman = null; // Act var valueAdded = cache.Add( "Superman", superman ); // Assert Assert.False( valueAdded ); }
public ImportJob( IImportJobRepository importJobRepository, InMemoryCache <TradeAccountModel> tradeAcccountModel, InMemoryCache <TradeInstrumentModel> tradeInstrumentModel, InMemoryCache <TradeFeeTypeModel> tradeFeeTypesModel, FileNameMatcher fileNameMatcher, IExtractFileService extractFileService) { var jobInterval = ConfigurationManager.AppSettings["job:ImportJobInterval"]; if (string.IsNullOrEmpty(jobInterval)) { throw new ConfigurationErrorsException("Please add 'job:ImportJobInterval' settigns to .config file."); } JobInterval = int.Parse(jobInterval); _tradeAccountModel = tradeAcccountModel; _tradeInstrumentModel = tradeInstrumentModel; _tradeFeeTypesModel = tradeFeeTypesModel; _importJobRepository = importJobRepository; _extractFileService = extractFileService; _fileNameMatcher = fileNameMatcher; using (var tradeContext = _importJobRepository.BeginOperation()) { foreach (var instrument in _importJobRepository.GetTradeInstrument()) { _tradeInstrumentModel.Add(instrument.InstrumentName, new TradeInstrumentModel { Id = instrument.Id }); } foreach (var trade in _importJobRepository.GetTradeAccount()) { _tradeAccountModel.Add(trade.AccountName, new TradeAccountModel { Id = trade.Id }); } foreach (var tradeFeeType in _importJobRepository.GetTradeFeeType()) { _tradeFeeTypesModel.Add(tradeFeeType.TradeFeeTypeName, new TradeFeeTypeModel { Id = tradeFeeType.Id }); } } }
public void GoingOverTheAllowedMemoryShouldTriggerAnImmediateCleanUp() { var timeMock = new Mock <ICurrentDateAndTimeProvider>(MockBehavior.Strict); timeMock.Setup(x => x.GetCurrentDateTime()).Returns(DateTime.UtcNow.AddDays(-1)); using (InMemoryCache cache = new InMemoryCache(_cleanupInterval, 1000, timeMock.Object)) { cache.SetLastExpirationScan(DateTime.MinValue); cache.Add(Guid.NewGuid().ToString(), new CachedObject { ObjectSize = 10000, Value = _testObject1, ExpireAt = DateTime.UtcNow.AddDays(-1) }); WaitFor(0.1); Assert.Equal(0, cache.Count); } }
public void AddGetRemove_Success() { // Arrange Customer customer = TestData.CreateCustomer(); ICache cache = new InMemoryCache(); // Add, Get and Assert cache.Add(customer.Id.ToString(), customer); object customerObject = cache.Get(customer.Id.ToString()); // Assert Assert.IsNotNull(customerObject); Assert.IsInstanceOfType(customerObject, typeof(Customer)); // Remove and Assert cache.Remove(customer.Id.ToString()); customerObject = cache.Get(customer.Id.ToString()); Assert.IsNull(customerObject); }
public void AddingLargeItemsToCacheShouldDelayTheCleanUpUntilMaximumAllowedItemIsReached() { var cleanupInterval = TimeSpan.FromSeconds(5); using (InMemoryCache cache = new InMemoryCache(cleanupInterval, 1000)) { var sw = Stopwatch.StartNew(); var cpt = 0; while (sw.Elapsed < cleanupInterval.Subtract(TimeSpan.FromMilliseconds(200))) { cache.Add(Guid.NewGuid().ToString(), new CachedObject { ObjectSize = 10000, Value = _testObject1, ExpireAt = DateTime.UtcNow.AddDays(-1) }); WaitFor(0.1); cpt++; Assert.NotEqual(0, cache.Count); } WaitFor(0.5); Assert.Equal(0, cache.Count); } }
public async Task <IPEndPoint> ResolveAsync(string endpoint, int port, IpVersion ipVersion = IpVersion.IpV4, CancellationToken token = default(CancellationToken)) { string cacheKey = $"{endpoint}:{port}:{ipVersion}"; if (port < IPEndPoint.MinPort || port > IPEndPoint.MaxPort) { throw new ArgumentOutOfRangeException(nameof(port)); } if (cache.HasKey(cacheKey)) { return(cache.Get <IPEndPoint>(cacheKey)); } var addressFamily = ipVersion.HasFlag(IpVersion.IpV4) ? AddressFamily.InterNetwork : AddressFamily.InterNetworkV6; token.ThrowIfCancellationRequested(); IPEndPoint ipEndpoint; var ipAddress = TryGetIpAddress(endpoint); if (ipAddress != null) { ipEndpoint = new IPEndPoint(ipAddress, port); cache.Add(cacheKey, ipEndpoint, TimeSpan.FromMinutes(60)); return(ipEndpoint); } try { #if NET40 var allAddresses = Dns.GetHostAddresses(endpoint); #else var allAddresses = await Dns.GetHostAddressesAsync(endpoint); #endif var firstAddressInFamily = allAddresses.FirstOrDefault(x => x.AddressFamily == addressFamily); if (firstAddressInFamily != null) { ipEndpoint = new IPEndPoint(firstAddressInFamily, port); cache.Add(cacheKey, ipEndpoint, TimeSpan.FromMinutes(60)); return(ipEndpoint); } if (addressFamily == AddressFamily.InterNetwork && ipVersion.HasFlag(IpVersion.IpV6)) { ipEndpoint = await ResolveAsync(endpoint, port, IpVersion.IpV6, token); if (ipEndpoint != null) { cache.Add(cacheKey, ipEndpoint, TimeSpan.FromMinutes(60)); return(ipEndpoint); } } var firstAddress = allAddresses.FirstOrDefault(); if (firstAddress == null) { return(null); } switch (firstAddress.AddressFamily) { case AddressFamily.InterNetwork: #if NET40 ipEndpoint = new IPEndPoint(firstAddress, port); #else ipEndpoint = new IPEndPoint(firstAddress.MapToIPv6(), port); #endif break; case AddressFamily.InterNetworkV6: #if NET40 ipEndpoint = new IPEndPoint(firstAddress, port); #else ipEndpoint = new IPEndPoint(firstAddress.MapToIPv4(), port); #endif break; default: return(null); } cache.Add(cacheKey, ipEndpoint, TimeSpan.FromMinutes(60)); return(ipEndpoint); } catch { return(null); } }
public void CountShouldReturnTheNumberOfItemsInTheCache() { Assert.Equal(0, _cache.Count); _cache.Add(_testObject1.Value.ToString(), new CachedObject { ObjectSize = 1, Value = _testObject1 }); Assert.Equal(1, _cache.Count); Assert.Equal(1, _cache.OrderedCacheKeysCount); Assert.Equal(1, _cache.EstimatedMemorySize); _cache.Add(_testObject2.Value.ToString(), new CachedObject { ObjectSize = 2, Value = _testObject2 }); Assert.Equal(2, _cache.Count); Assert.Equal(2, _cache.OrderedCacheKeysCount); Assert.Equal(3, _cache.EstimatedMemorySize); _cache.Remove(_testObject1.Value.ToString()); Assert.Equal(1, _cache.Count); Assert.Equal(1, _cache.OrderedCacheKeysCount); Assert.Equal(2, _cache.EstimatedMemorySize); }