Merge pull request #4 from scientist-labs/simplecov

Add SimpleCov and improve test coverage

Author: cpetersen

ruby_llm-red_candle.gemspec

@@ -44,4 +44,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec", "~> 3.12"
   spec.add_development_dependency "rubocop", "~> 1.0"
   spec.add_development_dependency "rubocop-rspec", "~> 3.0"
+  spec.add_development_dependency "simplecov", "~> 0.22"
 end

spec/ruby_llm/red_candle/chat_spec.rb

@@ -282,6 +282,59 @@
       expect(final_chunk).to be_a(RubyLLM::Chunk)
       expect(final_chunk.content).to eq("")
     end
+
+    it "returns a Message with accumulated content and token estimates" do
+      tokens = %w[Hello world !]
+
+      allow(mock_model).to receive(:generate_stream) do |_prompt, config:, &block|
+        tokens.each { |token| block.call(token) }
+      end
+
+      payload = {
+        messages: messages,
+        model: "TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF",
+        temperature: 0.7
+      }
+
+      result = provider.perform_streaming_completion!(payload) { |_chunk| }
+
+      expect(result).to be_a(RubyLLM::Message)
+      expect(result.role).to eq(:assistant)
+      expect(result.content).to eq("Helloworld!")
+      expect(result.model_id).to eq("TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF")
+      expect(result.input_tokens).to be_a(Integer)
+      expect(result.output_tokens).to be_a(Integer)
+    end
+
+    it "wraps streaming errors with helpful messages" do
+      allow(mock_model).to receive(:generate_stream).and_raise(StandardError, "stream error")
+
+      payload = {
+        messages: messages,
+        model: "TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF",
+        temperature: 0.7
+      }
+
+      expect { provider.perform_streaming_completion!(payload) { |_| } }.to raise_error(
+        RubyLLM::Error,
+        /Generation failed for TheBloke\/TinyLlama.*stream error/
+      )
+    end
+
+    it "provides helpful message for OOM errors during streaming" do
+      allow(mock_model).to receive(:generate_stream).and_raise(StandardError, "out of memory")
+
+      payload = {
+        messages: messages,
+        model: "TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF",
+        temperature: 0.7
+      }
+
+      expect { provider.perform_streaming_completion!(payload) { |_| } }.to raise_error(
+        RubyLLM::Error,
+        /Out of memory.*Try using a smaller model/m
+      )
+    end
   end
 
   describe "message formatting" do

spec/ruby_llm/red_candle/streaming_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe RubyLLM::RedCandle::Streaming do
+  let(:config) { RubyLLM::Configuration.new }
+  let(:provider) { RubyLLM::RedCandle::Provider.new(config) }
+  let(:mock_model) { instance_double(Candle::LLM) }
+
+  before do
+    allow(provider).to receive(:ensure_model_loaded!).and_return(mock_model)
+    allow(mock_model).to receive(:respond_to?).with(:apply_chat_template).and_return(true)
+    allow(mock_model).to receive(:apply_chat_template).and_return("formatted prompt")
+  end
+
+  describe "#stream" do
+    let(:messages) { [{ role: "user", content: "Test message" }] }
+
+    context "when stream: true" do
+      it "calls perform_streaming_completion!" do
+        tokens = %w[Hello world]
+
+        allow(mock_model).to receive(:generate_stream) do |_prompt, config:, &block|
+          tokens.each { |token| block.call(token) }
+        end
+
+        payload = {
+          messages: messages,
+          model: "TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF",
+          temperature: 0.7,
+          stream: true
+        }
+
+        chunks = []
+        provider.stream(payload) { |chunk| chunks << chunk }
+
+        # Should receive token chunks plus final empty chunk
+        expect(chunks.size).to eq(3)
+        expect(chunks[0].content).to eq("Hello")
+        expect(chunks[1].content).to eq("world")
+        expect(chunks[2].content).to eq("")
+      end
+    end
+
+    context "when stream: false" do
+      it "yields a single chunk with complete result" do
+        allow(mock_model).to receive(:generate).and_return("Complete response")
+
+        payload = {
+          messages: messages,
+          model: "TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF",
+          temperature: 0.7,
+          stream: false
+        }
+
+        chunks = []
+        provider.stream(payload) { |chunk| chunks << chunk }
+
+        expect(chunks.size).to eq(1)
+        expect(chunks[0][:content]).to eq("Complete response")
+        expect(chunks[0][:role]).to eq("assistant")
+      end
+    end
+
+    context "when stream is nil (defaults to non-streaming)" do
+      it "yields a single chunk with complete result" do
+        allow(mock_model).to receive(:generate).and_return("Complete response")
+
+        payload = {
+          messages: messages,
+          model: "TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF",
+          temperature: 0.7
+        }
+
+        chunks = []
+        provider.stream(payload) { |chunk| chunks << chunk }
+
+        expect(chunks.size).to eq(1)
+        expect(chunks[0][:content]).to eq("Complete response")
+      end
+    end
+  end
+
+  describe "#stream_processor" do
+    it "returns nil for compatibility" do
+      expect(provider.send(:stream_processor)).to be_nil
+    end
+  end
+
+  describe "#process_stream_response" do
+    it "returns the response unchanged" do
+      response = { content: "test" }
+      expect(provider.send(:process_stream_response, response)).to eq(response)
+    end
+  end
+end

spec/spec_helper.rb

@@ -1,5 +1,13 @@
 # frozen_string_literal: true
 
+require "simplecov"
+SimpleCov.start do
+  add_filter "/spec/"
+  add_group "Provider", "lib/ruby_llm/red_candle"
+  enable_coverage :branch
+  minimum_coverage line: 80, branch: 70
+end
+
 require "bundler/setup"
 require "ruby_llm-red_candle"