tests

Author: Alex Peck

BitFaster.Caching.UnitTests/Lru/ClassicLruTests.cs

@@ -118,7 +118,51 @@ public void WhenItemIsAddedThenRetrievedHitRatioIsHalf()
             lru.GetOrAdd(1, valueFactory.Create);
             bool result = lru.TryGet(1, out var value);
 
+#pragma warning disable CS0618 // Type or member is obsolete
             lru.HitRatio.Should().Be(0.5);
+#pragma warning restore CS0618 // Type or member is obsolete
+        }
+
+        [Fact]
+        public void MetricsAreEnabled()
+        {
+            lru.Metrics.IsEnabled.Should().BeTrue();
+        }
+
+        [Fact]
+        public void WhenItemIsAddedThenRetrievedMetricHitRatioIsHalf()
+        {
+            lru.GetOrAdd(1, valueFactory.Create);
+            bool result = lru.TryGet(1, out var value);
+
+            lru.Metrics.HitRatio.Should().Be(0.5);
+        }
+
+        [Fact]
+        public void WhenItemIsAddedThenRetrievedMetricHitsIs1()
+        {
+            lru.GetOrAdd(1, valueFactory.Create);
+            bool result = lru.TryGet(1, out var value);
+
+            lru.Metrics.Hits.Should().Be(1);
+        }
+
+        [Fact]
+        public void WhenItemIsAddedThenRetrievedMetricTotalIs2()
+        {
+            lru.GetOrAdd(1, valueFactory.Create);
+            bool result = lru.TryGet(1, out var value);
+
+            lru.Metrics.Total.Should().Be(2);
+        }
+
+        [Fact]
+        public void WhenItemDoesNotExistTryGetIncrementsMiss()
+        {
+            lru.GetOrAdd(1, valueFactory.Create);
+            bool result = lru.TryGet(1, out var value);
+
+            lru.Metrics.Misses.Should().Be(1);
         }
 
         [Fact]

BitFaster.Caching.UnitTests/Lru/ConcurrentLruTests.cs

@@ -189,6 +189,15 @@ public void WhenItemIsAddedThenRetrievedHitRatioIsHalf()
 #pragma warning restore CS0618 // Type or member is obsolete
         }
 
+        [Fact]
+        public void WhenItemIsAddedThenRetrievedMetricHitRatioIsHalf()
+        {
+            lru.GetOrAdd(1, valueFactory.Create);
+            bool result = lru.TryGet(1, out var value);
+
+            lru.Metrics.HitRatio.Should().Be(0.5);
+        }
+
         [Fact]
         public void WhenKeyIsRequestedItIsCreatedAndCached()
         {

BitFaster.Caching.UnitTests/Lru/NoTelemetryPolicyTests.cs

@@ -17,6 +17,30 @@ public void HitRatioIsZero()
             counter.HitRatio.Should().Be(0);
         }
 
+        [Fact]
+        public void TotalIsZero()
+        {
+            counter.Total.Should().Be(0);
+        }
+
+        [Fact]
+        public void HitsIsZero()
+        {
+            counter.Hits.Should().Be(0);
+        }
+
+        [Fact]
+        public void MissesIsZero()
+        {
+            counter.Misses.Should().Be(0);
+        }
+
+        [Fact]
+        public void IsEnabledIsFalse()
+        {
+            counter.IsEnabled.Should().BeFalse();
+        }
+
         [Fact]
         public void IncrementHitCountIsNoOp()
         {

BitFaster.Caching.UnitTests/Lru/TelemetryPolicyTests.cs

@@ -11,6 +11,36 @@ public class TelemetryPolicyTests
     {
         private TelemetryPolicy<int, int> telemetryPolicy = default;
 
+        [Fact]
+        public void WhenHitTotalIs1()
+        {
+            telemetryPolicy.Total.Should().Be(0);
+            telemetryPolicy.IncrementHit();
+            telemetryPolicy.Total.Should().Be(1);
+        }
+
+        [Fact]
+        public void WhenHitHitsIs1()
+        {
+            telemetryPolicy.Hits.Should().Be(0);
+            telemetryPolicy.IncrementHit();
+            telemetryPolicy.Hits.Should().Be(1);
+        }
+
+        [Fact]
+        public void WhenMissMissesIs1()
+        {
+            telemetryPolicy.Misses.Should().Be(0);
+            telemetryPolicy.IncrementMiss();
+            telemetryPolicy.Misses.Should().Be(1);
+        }
+
+        [Fact]
+        public void IsEnabledIsTrue()
+        {
+            telemetryPolicy.IsEnabled.Should().BeTrue();
+        }
+
         [Fact]
         public void WhenHitCountAndTotalCountAreEqualRatioIs1()
         {

BitFaster.Caching.UnitTests/ScopedCacheTests.cs

@@ -38,6 +38,16 @@ public void WhenItemIsAddedCountIsCorrect()
             this.cache.Count.Should().Be(1);
         }
 
+        [Fact]
+        public void WhenItemIsAddedThenLookedUpMetricsAreCorrect()
+        {
+            this.cache.AddOrUpdate(1, new Disposable());
+            this.cache.ScopedGetOrAdd(1, k => new Scoped<Disposable>(new Disposable()));
+
+            this.cache.Metrics.Misses.Should().Be(0);
+            this.cache.Metrics.Hits.Should().Be(1);
+        }
+
         [Fact]
         public void WhenKeyDoesNotExistAddOrUpdateAddsNewItem()
         {

BitFaster.Caching/Lru/ClassicLru.cs

@@ -56,6 +56,7 @@ public ClassicLru(int concurrencyLevel, int capacity, IEqualityComparer<K> compa
         /// <summary>
         /// Gets the ratio of hits to misses, where a value of 1 indicates 100% hits.
         /// </summary>
+        [ObsoleteAttribute("This property is obsolete. Use Metrics instead.", false)]
         public double HitRatio => this.Metrics.HitRatio;
 
         ///<inheritdoc/>