fixed some missing test cases

Author: AndrewMorgan1

tests/PromptStream.AI.Tests/Models/ModelSpecShimTests.cs

@@ -0,0 +1,107 @@
+using PromptStream.AI.Integration.Legacy;
+using System.Text.Json;
+
+namespace PromptStream.AI.Tests.Models
+{
+    public class ModelSpecShimTests
+    {
+        [Fact]
+        public void ToModelSpec_ShouldMapModernFieldsDirectly()
+        {
+            var shim = new ModelSpecShim
+            {
+                Id = "gpt-4o",
+                Family = "OpenAI",
+                TokenizerName = "tiktoken",
+                MaxInputTokens = 16000,
+                MaxOutputTokens = 2048,
+                InputPricePer1K = 2.5m,
+                OutputPricePer1K = 10.0m
+            };
+
+            var model = shim.ToModelSpec();
+
+            Assert.Equal("gpt-4o", model.Id);
+            Assert.Equal("OpenAI", model.Family);
+            Assert.Equal("tiktoken", model.TokenizerName);
+            Assert.Equal(16000, model.MaxInputTokens);
+            Assert.Equal(2048, model.MaxOutputTokens);
+            Assert.Equal(2.5m, model.InputPricePer1K);
+            Assert.Equal(10.0m, model.OutputPricePer1K);
+        }
+
+        [Fact]
+        public void LegacyPromptCost_ShouldSetInputPrice_WhenZero()
+        {
+            var shim = new ModelSpecShim();
+            shim.LegacyPromptCostPer1K = 0.75m; // triggers setter
+
+            Assert.Equal(0.75m, shim.InputPricePer1K);
+        }
+
+        [Fact]
+        public void LegacyPromptCost_ShouldNotOverride_WhenAlreadySet()
+        {
+            var shim = new ModelSpecShim { InputPricePer1K = 2.0m };
+            shim.LegacyPromptCostPer1K = 0.75m;
+
+            Assert.Equal(2.0m, shim.InputPricePer1K);
+        }
+
+        [Fact]
+        public void LegacyCompletionCost_ShouldSetOutputPrice_WhenZero()
+        {
+            var shim = new ModelSpecShim();
+            shim.LegacyCompletionCostPer1K = 5.0m; // triggers setter
+
+            Assert.Equal(5.0m, shim.OutputPricePer1K);
+        }
+
+        [Fact]
+        public void LegacyCompletionCost_ShouldNotOverride_WhenAlreadySet()
+        {
+            var shim = new ModelSpecShim { OutputPricePer1K = 8.0m };
+            shim.LegacyCompletionCostPer1K = 10.0m;
+
+            Assert.Equal(8.0m, shim.OutputPricePer1K);
+        }
+
+        [Fact]
+        public void ToModelSpec_ShouldApplyDefaultMaxInput_WhenZero()
+        {
+            var shim = new ModelSpecShim
+            {
+                Id = "claude-sonnet-4",
+                Family = "Anthropic",
+                TokenizerName = "cltk",
+                MaxInputTokens = 0, // triggers fallback
+                InputPricePer1K = 1.5m,
+                OutputPricePer1K = 6.0m
+            };
+
+            var model = shim.ToModelSpec();
+            Assert.Equal(128000, model.MaxInputTokens);
+            Assert.Equal(1.5m, model.InputPricePer1K);
+            Assert.Equal(6.0m, model.OutputPricePer1K);
+        }
+
+        [Fact]
+        public void JsonDeserialization_ShouldMapLegacyFields_WhenModernMissing()
+        {
+            var json = """
+            {
+                "Id": "gpt-3.5-turbo",
+                "Family": "OpenAI",
+                "PromptCostPer1K": 0.0015,
+                "CompletionCostPer1K": 0.0020
+            }
+            """;
+
+            var shim = JsonSerializer.Deserialize<ModelSpecShim>(json);
+            Assert.NotNull(shim);
+            Assert.Equal("gpt-3.5-turbo", shim!.Id);
+            Assert.Equal(0.0015m, shim.InputPricePer1K);
+            Assert.Equal(0.0020m, shim.OutputPricePer1K);
+        }
+    }
+}

tests/PromptStream.AI.Tests/Services/PromptStreamServiceTests_Extra.cs

@@ -0,0 +1,125 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Threading.Tasks;
+using Flow.AI.Core.Interfaces;
+using Flow.AI.Core.Models;
+using PromptStream.AI.Models;
+using PromptStream.AI.Services;
+using TokenFlow.Core.Models;
+using Xunit;
+
+namespace PromptStream.AI.Tests.Services
+{
+    public class MockModelClient : IModelClient
+    {
+        public Task<PromptResponse> GenerateAsync(string prompt)
+        {
+            return Task.FromResult(new PromptResponse
+            {
+                Content = "Mocked response",
+                TimestampUtc = DateTime.UtcNow
+            });
+        }
+    }
+
+    public class PromptStreamServiceTests_Extra
+    {
+        private readonly PromptStreamService _service;
+        private readonly Type _shimType;
+
+        public PromptStreamServiceTests_Extra()
+        {
+            _service = new PromptStreamService(
+                new MockTokenProvider(),
+                null,
+                new MockModelClient(),
+                "nonexistent-model",
+                50);
+
+            _shimType = typeof(PromptStreamService)
+                .GetNestedType("ModelSpecShim", BindingFlags.NonPublic)!;
+        }
+
+        [Fact]
+        public void AnalyzePrompt_ShouldHandleMissingRegistryResource_AndHitCatchBlock()
+        {
+            var template = new PromptTemplate { Template = "Test prompt" };
+            var variables = new Dictionary<string, string>();
+
+            var (validation, summary) = _service.AnalyzePrompt(template, variables);
+
+            Assert.NotNull(validation);
+            Assert.True(validation.IsValid);
+            Assert.NotNull(summary);
+            Assert.True(summary.TotalTokens >= 0);
+        }
+
+        [Fact]
+        public void AnalyzePrompt_ShouldFallbackToDefaultModel_WhenModelNotFound()
+        {
+            var template = new PromptTemplate { Template = "Fallback model test" };
+            var variables = new Dictionary<string, string>();
+
+            var (validation, summary) = _service.AnalyzePrompt(template, variables);
+
+            Assert.True(validation.IsValid);
+            Assert.Equal(validation.TokenCount, summary.TotalTokens);
+            Assert.True(summary.EstimatedCost >= 0);
+        }
+
+        [Fact]
+        public void ModelSpecShim_LegacySetters_ShouldAssignValuesOnlyWhenZero()
+        {
+            var shim = Activator.CreateInstance(_shimType)!;
+
+            // Accessors via reflection
+            var inProp = _shimType.GetProperty("InputPricePer1K")!;
+            var outProp = _shimType.GetProperty("OutputPricePer1K")!;
+            var legacyInProp = _shimType.GetProperty("LegacyPromptCostPer1K")!;
+            var legacyOutProp = _shimType.GetProperty("LegacyCompletionCostPer1K")!;
+
+            inProp.SetValue(shim, 0m);
+            outProp.SetValue(shim, 0m);
+
+            // Case 1: assign legacy values when zero
+            legacyInProp.SetValue(shim, 1.5m);
+            legacyOutProp.SetValue(shim, 3.0m);
+
+            Assert.Equal(1.5m, (decimal)inProp.GetValue(shim)!);
+            Assert.Equal(3.0m, (decimal)outProp.GetValue(shim)!);
+
+            // Case 2: should NOT override non-zero values
+            legacyInProp.SetValue(shim, 9.9m);
+            legacyOutProp.SetValue(shim, 9.9m);
+
+            Assert.Equal(1.5m, (decimal)inProp.GetValue(shim)!);
+            Assert.Equal(3.0m, (decimal)outProp.GetValue(shim)!);
+        }
+
+        [Fact]
+        public void ModelSpecShim_ToModelSpec_ShouldReturnValidModelSpec()
+        {
+            var shim = Activator.CreateInstance(_shimType)!;
+
+            // Reflection property setup
+            _shimType.GetProperty("Id")!.SetValue(shim, "gpt-4o-mini");
+            _shimType.GetProperty("Family")!.SetValue(shim, "OpenAI");
+            _shimType.GetProperty("TokenizerName")!.SetValue(shim, "tiktoken");
+            _shimType.GetProperty("MaxInputTokens")!.SetValue(shim, 0);
+            _shimType.GetProperty("InputPricePer1K")!.SetValue(shim, 2.5m);
+            _shimType.GetProperty("OutputPricePer1K")!.SetValue(shim, 10.0m);
+
+            // Call ToModelSpec() via reflection
+            var toModelSpecMethod = _shimType.GetMethod("ToModelSpec")!;
+            var modelSpec = (ModelSpec)toModelSpecMethod.Invoke(shim, null)!;
+
+            Assert.Equal("gpt-4o-mini", modelSpec.Id);
+            Assert.Equal("OpenAI", modelSpec.Family);
+            Assert.Equal("tiktoken", modelSpec.TokenizerName);
+            Assert.Equal(128000, modelSpec.MaxInputTokens);
+            Assert.Equal(2.5m, modelSpec.InputPricePer1K);
+            Assert.Equal(10.0m, modelSpec.OutputPricePer1K);
+        }
+    }
+}