Added Missing code coverage tests

Author: AndrewMorgan1

tests/TokenKit.Tests/Registry/JsonModelRegistryTests.cs

@@ -75,5 +75,42 @@ public void GetAll_Should_Filter_By_Provider()
             Assert.Equal(2, openaiModels.Count);
             Assert.All(openaiModels, m => Assert.Equal("OpenAI", m.Provider));
         }
+
+        [Fact]
+        public void Constructor_ShouldDeserializeValidJsonFile()
+        {
+            // Arrange
+            var tempDir = Path.Combine(Path.GetTempPath(), $"TokenKitTests_{Guid.NewGuid()}");
+            Directory.CreateDirectory(tempDir);
+            var filePath = Path.Combine(tempDir, "models.data.json");
+
+            var models = new List<ModelInfo>
+            {
+                new() { Id = "gpt-4o", Provider = "OpenAI", MaxTokens = 100000, InputPricePer1K = 0.005m, OutputPricePer1K = 0.015m, Encoding = "cl100k_base" }
+            };
+            File.WriteAllText(filePath, System.Text.Json.JsonSerializer.Serialize(models));
+
+            // Act
+            var registry = new JsonModelRegistry(filePath);
+            var result = registry.GetAll();
+
+            // Assert
+            Assert.Single(result);
+            Assert.Equal("gpt-4o", result[0].Id);
+        }
+
+        [Fact]
+        public void Constructor_ShouldFallbackToEmptyList_WhenFileEmpty()
+        {
+            var tempDir = Path.Combine(Path.GetTempPath(), $"TokenKitTests_{Guid.NewGuid()}");
+            Directory.CreateDirectory(tempDir);
+            var filePath = Path.Combine(tempDir, "models.data.json");
+            File.WriteAllText(filePath, ""); // empty file => Deserialize returns null, triggers ?? new()
+
+            var registry = new JsonModelRegistry(filePath);
+            var result = registry.GetAll();
+
+            Assert.Empty(result);
+        }
     }
 }

tests/TokenKit.Tests/Services/SimpleTokenizerEngineTests.cs

@@ -0,0 +1,45 @@
+using TokenKit.Core.Implementations;
+using TokenKit.Core.Interfaces;
+using TokenKit.Core.Models;
+
+namespace TokenKit.Tests.Services
+{
+    public class SimpleTokenizerEngineTests
+    {
+        private readonly ITokenizerEngine _engine = new SimpleTokenizerEngine();
+        private readonly ModelInfo _model = new() { Id = "test", Encoding = "none" };
+
+        [Fact]
+        public void CountTokens_ShouldReturnZero_WhenTextIsNullOrWhitespace()
+        {
+            Assert.Equal(0, _engine.CountTokens(null!, _model));   // null
+            Assert.Equal(0, _engine.CountTokens("", _model));       // empty
+            Assert.Equal(0, _engine.CountTokens("   ", _model));    // whitespace
+            Assert.Equal(0, _engine.CountTokens("\n\r\t", _model)); // control chars
+        }
+
+        [Fact]
+        public void CountTokens_ShouldReturnCorrectCount_ForSimpleText()
+        {
+            var text = "Hello world from TokenKit";
+            var count = _engine.CountTokens(text, _model);
+
+            Assert.Equal(4, count); // 4 words
+        }
+
+        [Fact]
+        public void CountTokens_ShouldHandleMixedWhitespaceCorrectly()
+        {
+            var text = "Hello\tworld\nfrom   TokenKit\rrocks";
+            var count = _engine.CountTokens(text, _model);
+
+            Assert.Equal(5, count);
+        }
+
+        [Fact]
+        public void Name_ShouldBeSimple()
+        {
+            Assert.Equal("simple", _engine.Name);
+        }
+    }
+}

tests/TokenKit.Tests/Services/TokenizerTests.cs

@@ -95,6 +95,54 @@ public async Task InvalidEngine_ShouldFallbackToDefault()
             Assert.Equal("simple", result.Engine);
         }
 
+        [Fact]
+        public async Task Analyze_ShouldThrow_WhenModelIsUnknown()
+        {
+            // Arrange: minimal Core setup with empty registry
+            var services = new ServiceCollection();
+            services.AddSingleton<IModelRegistry>(new InMemoryModelRegistry(Array.Empty<ModelInfo>()));
+            services.AddSingleton<ITokenizerEngine, SimpleTextEncoder>();
+            services.AddSingleton<ICostEstimator, BasicCostEstimator>();
+            services.AddSingleton<ITokenKitCore, TokenKitCore>();
+
+            var core = services.BuildServiceProvider().GetRequiredService<ITokenKitCore>();
+
+            // Act & Assert
+            var ex = await Assert.ThrowsAsync<ArgumentException>(async () =>
+            {
+                await core.AnalyzeAsync(new AnalyzeRequest
+                {
+                    Text = "This should fail",
+                    ModelId = "non-existent-model"
+                });
+            });
+
+            Assert.Contains("Unknown model", ex.Message);
+        }
+
+        [Fact]
+        public async Task Validate_ShouldThrow_WhenModelIsUnknown()
+        {
+            var services = new ServiceCollection();
+            services.AddSingleton<IModelRegistry>(new InMemoryModelRegistry(Array.Empty<ModelInfo>()));
+            services.AddSingleton<ITokenizerEngine, SimpleTextEncoder>();
+            services.AddSingleton<ICostEstimator, BasicCostEstimator>();
+            services.AddSingleton<ITokenKitCore, TokenKitCore>();
+
+            var core = services.BuildServiceProvider().GetRequiredService<ITokenKitCore>();
+
+            var ex = await Assert.ThrowsAsync<ArgumentException>(async () =>
+            {
+                await core.ValidateAsync(new ValidateRequest
+                {
+                    Text = "Some text",
+                    ModelId = "non-existent-model"
+                });
+            });
+
+            Assert.Contains("Unknown model", ex.Message);
+        }
+
         private sealed class InMemoryModelRegistry : IModelRegistry
         {
             private readonly List<ModelInfo> _models;