currency-converter 1.1.0 → 1.2.1

data/lib/currency_converter/converter.rb

@@ -14,10 +14,11 @@ module CurrencyConverter
   # The Converter class performs currency conversions using exchange rates.
   # It retrieves rates from an external API and caches them for performance.
   class Converter
-    def initialize(api_key: CurrencyConverter.configuration.api_key)
-      # Initializes the API client with the provided or configured API key.
+    def initialize(api_key: CurrencyConverter.configuration.api_key,
+                   timeout: CurrencyConverter.configuration.timeout)
+      # Initializes the API client with the provided or configured API key and timeout.
       # Initializes a caching object for exchange rates.
-      @api_client = APIClient.new(api_key)
+      @api_client = APIClient.new(api_key, timeout: timeout)
       @cache = Cache.new
     end
 
@@ -26,13 +27,21 @@ module CurrencyConverter
     # @param from_currency [String] the source currency code (e.g., "USD")
     # @param to_currency [String] the target currency code (e.g., "EUR")
     # @return [Float] the converted amount
+    # @raise [CurrencyConverter::InvalidAmountError] if amount is invalid
+    # @raise [CurrencyConverter::InvalidCurrencyError] if currency code is invalid
     # @raise [CurrencyConverter::APIError] if conversion fails due to API or network errors
     def convert(amount, from_currency, to_currency)
+      validate_amount(amount)
+      validate_currency_code(from_currency, "from_currency")
+      validate_currency_code(to_currency, "to_currency")
+
       rate = fetch_exchange_rate(from_currency, to_currency)
       (amount * rate).round(2)
     rescue CurrencyConverter::RateNotFoundError => e
       log_error("Conversion failed: #{e.message}")
       raise CurrencyConverter::APIError, "Conversion failed: #{e.message}"
+    rescue CurrencyConverter::InvalidAmountError, CurrencyConverter::InvalidCurrencyError
+      raise # Re-raise validation errors as-is
     rescue StandardError => e
       log_error("Conversion failed: #{e.message}")
       raise
@@ -46,7 +55,8 @@ module CurrencyConverter
     # @param to_currency [String] the target currency code
     # @return [Float] the exchange rate
     def fetch_exchange_rate(from_currency, to_currency)
-      @cache.fetch("#{from_currency}_#{to_currency}") do
+      cache_duration = CurrencyConverter.configuration.cache_duration
+      @cache.fetch("#{from_currency}_#{to_currency}", expires_in: cache_duration) do
         @api_client.get_rate(from_currency, to_currency)
       end
     end
@@ -56,5 +66,35 @@ module CurrencyConverter
     def log_error(message)
       CurrencyConverter.configuration.logger.error(message)
     end
+
+    # Validates the amount parameter.
+    # @param amount [Numeric] the amount to validate
+    # @raise [InvalidAmountError] if amount is invalid
+    def validate_amount(amount)
+      if amount.nil?
+        raise InvalidAmountError, "Amount cannot be nil"
+      elsif !amount.is_a?(Numeric)
+        raise InvalidAmountError, "Amount must be a number, got #{amount.class}"
+      elsif amount.negative?
+        raise InvalidAmountError, "Amount cannot be negative (got #{amount})"
+      end
+    end
+
+    # Validates the currency code parameter.
+    # @param currency_code [String] the currency code to validate
+    # @param param_name [String] the parameter name for error messages
+    # @raise [InvalidCurrencyError] if currency code is invalid
+    def validate_currency_code(currency_code, param_name)
+      if currency_code.nil?
+        raise InvalidCurrencyError, "#{param_name} cannot be nil"
+      elsif !currency_code.is_a?(String)
+        raise InvalidCurrencyError, "#{param_name} must be a string, got #{currency_code.class}"
+      elsif currency_code.empty?
+        raise InvalidCurrencyError, "#{param_name} cannot be empty"
+      elsif !currency_code.match?(/\A[A-Z]{3}\z/)
+        raise InvalidCurrencyError,
+              "#{param_name} must be a 3-letter uppercase code (e.g., 'USD'), got '#{currency_code}'"
+      end
+    end
   end
 end

data/lib/currency_converter/errors.rb

@@ -6,4 +6,13 @@ module CurrencyConverter
 
   # Custom error class for cases where a specific exchange rate is not found.
   class RateNotFoundError < StandardError; end
+
+  # Custom error class for invalid amount inputs.
+  class InvalidAmountError < StandardError; end
+
+  # Custom error class for invalid currency code inputs.
+  class InvalidCurrencyError < StandardError; end
+
+  # Custom error class for timeout errors.
+  class TimeoutError < StandardError; end
 end

data/lib/currency_converter/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CurrencyConverter
-  VERSION = "1.1.0"
+  VERSION = "1.2.1"
 end

data/manual_integration_test.rb

@@ -0,0 +1,157 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Manual Integration Test for CurrencyConverter v1.2.0
+# This script tests the gem with real API calls
+
+$LOAD_PATH.unshift File.expand_path("lib", __dir__)
+require "currency_converter"
+
+puts "=" * 80
+puts "CurrencyConverter v1.2.0 - Manual Integration Test"
+puts "=" * 80
+puts
+
+# Test 1: Open Access Mode (without API key)
+puts "TEST 1: Open Access Mode (no API key)"
+puts "-" * 80
+CurrencyConverter.configure do |config|
+  config.api_key = nil
+  config.cache_duration = 60
+  config.timeout = 10
+end
+
+converter = CurrencyConverter::Converter.new
+begin
+  result = converter.convert(100, "USD", "EUR")
+  puts "✅ Convert 100 USD to EUR: #{result} EUR"
+  puts "   API Mode: v6 Open Access"
+rescue StandardError => e
+  puts "❌ FAILED: #{e.class} - #{e.message}"
+end
+puts
+
+# Test 2: Cache functionality
+puts "TEST 2: Cache Hit (should use cached value)"
+puts "-" * 80
+begin
+  result2 = converter.convert(100, "USD", "EUR")
+  puts "✅ Second conversion (cached): #{result2} EUR"
+  puts "   Should be instant (from cache)"
+rescue StandardError => e
+  puts "❌ FAILED: #{e.class} - #{e.message}"
+end
+puts
+
+# Test 3: Different currency pair
+puts "TEST 3: Different Currency Pair"
+puts "-" * 80
+begin
+  result = converter.convert(100, "USD", "GBP")
+  puts "✅ Convert 100 USD to GBP: #{result} GBP"
+rescue StandardError => e
+  puts "❌ FAILED: #{e.class} - #{e.message}"
+end
+puts
+
+# Test 4: Input Validation - Negative Amount
+puts "TEST 4: Input Validation - Negative Amount"
+puts "-" * 80
+begin
+  converter.convert(-100, "USD", "EUR")
+  puts "❌ FAILED: Should have raised InvalidAmountError"
+rescue CurrencyConverter::InvalidAmountError => e
+  puts "✅ Correctly raised InvalidAmountError: #{e.message}"
+rescue StandardError => e
+  puts "❌ FAILED: Wrong error type - #{e.class}"
+end
+puts
+
+# Test 5: Input Validation - Invalid Currency Code
+puts "TEST 5: Input Validation - Invalid Currency Code"
+puts "-" * 80
+begin
+  converter.convert(100, "usd", "EUR")
+  puts "❌ FAILED: Should have raised InvalidCurrencyError"
+rescue CurrencyConverter::InvalidCurrencyError => e
+  puts "✅ Correctly raised InvalidCurrencyError: #{e.message}"
+rescue StandardError => e
+  puts "❌ FAILED: Wrong error type - #{e.class}"
+end
+puts
+
+# Test 6: Input Validation - Nil Amount
+puts "TEST 6: Input Validation - Nil Amount"
+puts "-" * 80
+begin
+  converter.convert(nil, "USD", "EUR")
+  puts "❌ FAILED: Should have raised InvalidAmountError"
+rescue CurrencyConverter::InvalidAmountError => e
+  puts "✅ Correctly raised InvalidAmountError: #{e.message}"
+rescue StandardError => e
+  puts "❌ FAILED: Wrong error type - #{e.class}"
+end
+puts
+
+# Test 7: Zero amount (edge case, should work)
+puts "TEST 7: Zero Amount (should work)"
+puts "-" * 80
+begin
+  result = converter.convert(0, "USD", "EUR")
+  puts "✅ Convert 0 USD to EUR: #{result} EUR"
+rescue StandardError => e
+  puts "❌ FAILED: #{e.class} - #{e.message}"
+end
+puts
+
+# Test 8: Decimal amounts
+puts "TEST 8: Decimal Amounts"
+puts "-" * 80
+begin
+  result = converter.convert(99.99, "USD", "EUR")
+  puts "✅ Convert 99.99 USD to EUR: #{result} EUR"
+rescue StandardError => e
+  puts "❌ FAILED: #{e.class} - #{e.message}"
+end
+puts
+
+# Test 9: Large numbers
+puts "TEST 9: Large Numbers"
+puts "-" * 80
+begin
+  result = converter.convert(1_000_000, "USD", "EUR")
+  puts "✅ Convert 1,000,000 USD to EUR: #{result} EUR"
+rescue StandardError => e
+  puts "❌ FAILED: #{e.class} - #{e.message}"
+end
+puts
+
+# Test 10: Performance - Multiple Conversions
+puts "TEST 10: Performance Test (10 conversions)"
+puts "-" * 80
+start_time = Time.now
+successes = 0
+begin
+  10.times do
+    converter.convert(100, "USD", "EUR")
+    successes += 1
+  end
+  elapsed = Time.now - start_time
+  puts "✅ Completed 10 conversions in #{elapsed.round(3)} seconds"
+  puts "   Average: #{(elapsed / 10 * 1000).round(2)}ms per conversion"
+  puts "   (Most should be cached, so very fast)"
+rescue StandardError => e
+  puts "❌ FAILED after #{successes} conversions: #{e.class} - #{e.message}"
+end
+puts
+
+puts "=" * 80
+puts "Integration Test Complete!"
+puts "=" * 80
+puts
+puts "Note: These tests use real API calls. If they fail, it might be due to:"
+puts "  - Network connectivity issues"
+puts "  - API rate limiting"
+puts "  - API service downtime"
+puts
+puts "For full test coverage, run: bundle exec rake spec"

data/spec/currency_converter/api_client_spec.rb

@@ -4,21 +4,172 @@ require "currency_converter"
 require "webmock/rspec"
 
 RSpec.describe CurrencyConverter::APIClient do
-  let(:client) { described_class.new("test_key") }
-
   describe "#get_rate" do
-    it "returns the exchange rate for a valid currency pair" do
-      stub_request(:get, "https://api.exchangerate-api.com/v4/latest/USD")
-        .to_return(body: { rates: { "EUR" => 0.85 } }.to_json)
+    context "with authenticated v6 API (with API key)" do
+      let(:client) { described_class.new("test_api_key_123", timeout: 5) }
+
+      it "logs authenticated API mode on initialization" do
+        logger = instance_double(Logger, info: nil)
+        allow(CurrencyConverter).to receive(:configuration).and_return(
+          double(logger: logger, timeout: 10)
+        )
+        expect(logger).to receive(:info).with(/Using v6 authenticated API/)
+
+        described_class.new("test_key")
+      end
+
+      it "handles nil logger gracefully" do
+        allow(CurrencyConverter).to receive(:configuration).and_return(
+          double(logger: nil, timeout: 10)
+        )
+
+        expect { described_class.new("test_key") }.not_to raise_error
+      end
+
+      it "returns the exchange rate for a valid currency pair" do
+        stub_request(:get, "https://v6.exchangerate-api.com/v6/test_api_key_123/latest/USD")
+          .to_return(body: { result: "success", conversion_rates: { "EUR" => 0.85 } }.to_json)
+
+        expect(client.get_rate("USD", "EUR")).to eq(0.85)
+      end
+
+      it "uses custom timeout configuration" do
+        custom_client = described_class.new("test_api_key_123", timeout: 15)
+        stub_request(:get, "https://v6.exchangerate-api.com/v6/test_api_key_123/latest/USD")
+          .to_return(body: { result: "success", conversion_rates: { "EUR" => 0.85 } }.to_json)
+
+        expect(custom_client.get_rate("USD", "EUR")).to eq(0.85)
+      end
+
+      it "raises APIError for invalid API key" do
+        stub_request(:get, "https://v6.exchangerate-api.com/v6/test_api_key_123/latest/USD")
+          .to_return(body: { result: "error", "error-type" => "invalid-key" }.to_json)
+
+        expect { client.get_rate("USD", "EUR") }
+          .to raise_error(CurrencyConverter::APIError, /Invalid API key/)
+      end
+
+      it "raises APIError for quota reached" do
+        stub_request(:get, "https://v6.exchangerate-api.com/v6/test_api_key_123/latest/USD")
+          .to_return(body: { result: "error", "error-type" => "quota-reached" }.to_json)
+
+        expect { client.get_rate("USD", "EUR") }
+          .to raise_error(CurrencyConverter::APIError, /rate limit quota reached/)
+      end
+
+      it "raises APIError for inactive account" do
+        stub_request(:get, "https://v6.exchangerate-api.com/v6/test_api_key_123/latest/USD")
+          .to_return(body: { result: "error", "error-type" => "inactive-account" }.to_json)
+
+        expect { client.get_rate("USD", "EUR") }
+          .to raise_error(CurrencyConverter::APIError, /account is inactive/)
+      end
+    end
+
+    context "with open access v6 API (without API key)" do
+      let(:client) { described_class.new(nil, timeout: 5) }
+
+      it "logs open access API mode on initialization" do
+        logger = instance_double(Logger, info: nil)
+        allow(CurrencyConverter).to receive(:configuration).and_return(
+          double(logger: logger, timeout: 10)
+        )
+        expect(logger).to receive(:info).with(/Using v6 open access API/)
+
+        described_class.new(nil)
+      end
+
+      it "returns the exchange rate using open access endpoint" do
+        stub_request(:get, "https://open.er-api.com/v6/latest/USD")
+          .to_return(body: { result: "success", rates: { "EUR" => 0.85 } }.to_json)
+
+        expect(client.get_rate("USD", "EUR")).to eq(0.85)
+      end
+
+      it "works with empty string API key" do
+        empty_key_client = described_class.new("", timeout: 5)
+        stub_request(:get, "https://open.er-api.com/v6/latest/USD")
+          .to_return(body: { result: "success", rates: { "GBP" => 0.76 } }.to_json)
+
+        expect(empty_key_client.get_rate("USD", "GBP")).to eq(0.76)
+      end
+
+      it "supports conversion_rates field (v6 format)" do
+        stub_request(:get, "https://open.er-api.com/v6/latest/USD")
+          .to_return(body: { result: "success", conversion_rates: { "JPY" => 156.84 } }.to_json)
+
+        expect(client.get_rate("USD", "JPY")).to eq(156.84)
+      end
+    end
+
+    context "with error scenarios" do
+      let(:client) { described_class.new("test_key", timeout: 5) }
+
+      it "raises a RateNotFoundError if the rate is missing" do
+        stub_request(:get, "https://v6.exchangerate-api.com/v6/test_key/latest/USD")
+          .to_return(body: { result: "success", conversion_rates: {} }.to_json)
+
+        expect { client.get_rate("USD", "EUR") }
+          .to raise_error(CurrencyConverter::RateNotFoundError, /EUR rate not available/)
+      end
+
+      it "raises an APIError for invalid JSON response" do
+        stub_request(:get, "https://v6.exchangerate-api.com/v6/test_key/latest/USD")
+          .to_return(body: "invalid json")
+
+        expect { client.get_rate("USD", "EUR") }
+          .to raise_error(CurrencyConverter::APIError, /Invalid API response format/)
+      end
+
+      it "raises a TimeoutError when request times out" do
+        stub_request(:get, "https://v6.exchangerate-api.com/v6/test_key/latest/USD")
+          .to_timeout
+
+        expect { client.get_rate("USD", "EUR") }
+          .to raise_error(CurrencyConverter::TimeoutError, /Request timed out/)
+      end
+
+      it "raises an APIError for network errors" do
+        stub_request(:get, "https://v6.exchangerate-api.com/v6/test_key/latest/USD")
+          .to_raise(SocketError.new("Failed to open TCP connection"))
+
+        expect { client.get_rate("USD", "EUR") }
+          .to raise_error(CurrencyConverter::APIError, /Network error/)
+      end
+
+      it "raises an APIError for unsupported currency code" do
+        stub_request(:get, "https://v6.exchangerate-api.com/v6/test_key/latest/USD")
+          .to_return(body: { result: "error", "error-type" => "unsupported-code" }.to_json)
+
+        expect { client.get_rate("USD", "XYZ") }
+          .to raise_error(CurrencyConverter::APIError, /Unsupported currency code/)
+      end
+
+      it "raises an APIError for unknown error types" do
+        stub_request(:get, "https://v6.exchangerate-api.com/v6/test_key/latest/USD")
+          .to_return(body: { result: "error", "error-type" => "some-unknown-error" }.to_json)
+
+        expect { client.get_rate("USD", "EUR") }
+          .to raise_error(CurrencyConverter::APIError, /API error: some-unknown-error/)
+      end
+
+      it "raises an APIError when error type is nil" do
+        stub_request(:get, "https://v6.exchangerate-api.com/v6/test_key/latest/USD")
+          .to_return(body: { result: "error" }.to_json)
 
-      expect(client.get_rate("USD", "EUR")).to eq(0.85)
+        expect { client.get_rate("USD", "EUR") }
+          .to raise_error(CurrencyConverter::APIError, /API error: unknown error/)
+      end
     end
 
-    it "raises a RateNotFoundError if the rate is missing" do
-      stub_request(:get, "https://api.exchangerate-api.com/v4/latest/USD")
-        .to_return(body: { rates: {} }.to_json)
+    context "with default timeout" do
+      it "uses default timeout when not specified" do
+        default_client = described_class.new("test_key")
+        stub_request(:get, "https://v6.exchangerate-api.com/v6/test_key/latest/USD")
+          .to_return(body: { result: "success", conversion_rates: { "GBP" => 0.76 } }.to_json)
 
-      expect { client.get_rate("USD", "EUR") }.to raise_error(CurrencyConverter::RateNotFoundError)
+        expect(default_client.get_rate("USD", "GBP")).to eq(0.76)
+      end
     end
   end
 end

data/spec/currency_converter/cache_spec.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# frozen_string_literal: true
-
 require "currency_converter"
 
 RSpec.describe CurrencyConverter::Cache do
@@ -13,15 +11,55 @@ RSpec.describe CurrencyConverter::Cache do
 
   let(:cache) { described_class.new }
 
-  it "caches values for the specified duration" do
-    # Cache a value for the key "test_key"
-    # rubocop:disable Style/RedundantFetchBlock
-    result = cache.fetch("test_key") { 100 }
-    expect(result).to eq(100)
+  describe "#fetch" do
+    it "caches values and returns cached value on subsequent calls" do
+      result = cache.fetch("test_key", expires_in: 60) { "original_value" }
+      expect(result).to eq("original_value")
+
+      # Second fetch should return cached value
+      cached_result = cache.fetch("test_key", expires_in: 60) { "new_value" }
+      expect(cached_result).to eq("original_value")
+    end
+
+    it "respects the expires_in parameter" do
+      # Cache with 1 second expiration
+      result = cache.fetch("expiring_key", expires_in: 1) { "first_value" }
+      expect(result).to eq("first_value")
+
+      # Immediately fetching should return cached value
+      cached_result = cache.fetch("expiring_key", expires_in: 1) { "second_value" }
+      expect(cached_result).to eq("first_value")
+
+      # After expiration, should return new value
+      sleep 1.1 # Wait for expiration
+      expired_result = cache.fetch("expiring_key", expires_in: 1) { "third_value" }
+      expect(expired_result).to eq("third_value")
+    end
 
-    # Try fetching the value again, it should return the cached value
-    cached_result = cache.fetch("test_key") { 200 }
-    expect(cached_result).to eq(100) # Cached value should be returned
-    # rubocop:enable Style/RedundantFetchBlock
+    it "returns fresh data when no expires_in is provided" do
+      # rubocop:disable Style/RedundantFetchBlock
+      result = cache.fetch("no_expiry_key") { "value_1" }
+      expect(result).to eq("value_1")
+
+      # Without expiration, values stay cached indefinitely
+      cached_result = cache.fetch("no_expiry_key") { "value_2" }
+      expect(cached_result).to eq("value_1")
+      # rubocop:enable Style/RedundantFetchBlock
+    end
+
+    it "handles different cache keys independently" do
+      result1 = cache.fetch("key_1", expires_in: 60) { "value_1" }
+      result2 = cache.fetch("key_2", expires_in: 60) { "value_2" }
+
+      expect(result1).to eq("value_1")
+      expect(result2).to eq("value_2")
+
+      # Both should be cached
+      cached_result1 = cache.fetch("key_1", expires_in: 60) { "new_value_1" }
+      cached_result2 = cache.fetch("key_2", expires_in: 60) { "new_value_2" }
+
+      expect(cached_result1).to eq("value_1")
+      expect(cached_result2).to eq("value_2")
+    end
   end
 end

data/spec/currency_converter/converter_spec.rb

@@ -5,24 +5,137 @@ require "currency_converter"
 RSpec.describe CurrencyConverter::Converter do
   let(:converter) { described_class.new }
 
-  # Simulate a missing exchange rate to trigger the error handling
-  before do
-    allow_any_instance_of(CurrencyConverter::APIClient)
-      .to receive(:get_rate)
-      .and_raise(CurrencyConverter::RateNotFoundError, "EUR rate not available")
-  end
+  describe "#convert" do
+    context "with valid inputs" do
+      before do
+        allow_any_instance_of(CurrencyConverter::APIClient)
+          .to receive(:get_rate)
+          .and_return(0.85)
+      end
 
-  it "raises an APIError if the conversion fails due to missing rate" do
-    expect { converter.convert(100, "USD", "EUR") }.to raise_error(CurrencyConverter::APIError, /Conversion failed/)
-  end
+      it "performs the conversion successfully" do
+        result = converter.convert(100, "USD", "EUR")
+        expect(result).to eq(85.0)
+      end
+
+      it "handles zero amount" do
+        result = converter.convert(0, "USD", "EUR")
+        expect(result).to eq(0.0)
+      end
+
+      it "handles decimal amounts" do
+        result = converter.convert(100.50, "USD", "EUR")
+        expect(result).to eq(85.43)
+      end
+    end
+
+    context "with API errors" do
+      before do
+        allow_any_instance_of(CurrencyConverter::APIClient)
+          .to receive(:get_rate)
+          .and_raise(CurrencyConverter::RateNotFoundError, "EUR rate not available")
+      end
+
+      it "raises an APIError if the conversion fails due to missing rate" do
+        expect { converter.convert(100, "USD", "EUR") }
+          .to raise_error(CurrencyConverter::APIError, /Conversion failed/)
+      end
+
+      it "logs error when conversion fails" do
+        logger = instance_double(Logger, error: nil, info: nil)
+        allow(CurrencyConverter.configuration).to receive(:logger).and_return(logger)
+
+        expect(logger).to receive(:error).with(/Conversion failed/)
+
+        begin
+          converter.convert(100, "USD", "EUR")
+        rescue CurrencyConverter::APIError
+          # Expected error
+        end
+      end
+
+      it "re-raises StandardError exceptions with logging" do
+        allow_any_instance_of(CurrencyConverter::APIClient)
+          .to receive(:get_rate)
+          .and_raise(StandardError, "Unexpected error")
+
+        logger = instance_double(Logger, error: nil, info: nil)
+        allow(CurrencyConverter.configuration).to receive(:logger).and_return(logger)
+
+        expect(logger).to receive(:error).with(/Conversion failed/)
+
+        expect { converter.convert(100, "USD", "EUR") }
+          .to raise_error(StandardError, "Unexpected error")
+      end
+    end
+
+    context "with invalid amount" do
+      it "raises InvalidAmountError when amount is nil" do
+        expect { converter.convert(nil, "USD", "EUR") }
+          .to raise_error(CurrencyConverter::InvalidAmountError, "Amount cannot be nil")
+      end
+
+      it "does not log validation errors" do
+        logger = instance_double(Logger, error: nil, info: nil)
+        allow(CurrencyConverter.configuration).to receive(:logger).and_return(logger)
+
+        expect(logger).not_to receive(:error)
+
+        expect { converter.convert(nil, "USD", "EUR") }
+          .to raise_error(CurrencyConverter::InvalidAmountError)
+      end
+
+      it "raises InvalidAmountError when amount is not numeric" do
+        expect { converter.convert("100", "USD", "EUR") }
+          .to raise_error(CurrencyConverter::InvalidAmountError, /Amount must be a number/)
+      end
+
+      it "raises InvalidAmountError when amount is negative" do
+        expect { converter.convert(-100, "USD", "EUR") }
+          .to raise_error(CurrencyConverter::InvalidAmountError, /Amount cannot be negative/)
+      end
+    end
+
+    context "with invalid currency codes" do
+      it "raises InvalidCurrencyError when from_currency is nil" do
+        expect { converter.convert(100, nil, "EUR") }
+          .to raise_error(CurrencyConverter::InvalidCurrencyError, "from_currency cannot be nil")
+      end
+
+      it "raises InvalidCurrencyError when to_currency is nil" do
+        expect { converter.convert(100, "USD", nil) }
+          .to raise_error(CurrencyConverter::InvalidCurrencyError, "to_currency cannot be nil")
+      end
+
+      it "raises InvalidCurrencyError when from_currency is not a string" do
+        expect { converter.convert(100, 123, "EUR") }
+          .to raise_error(CurrencyConverter::InvalidCurrencyError, /from_currency must be a string/)
+      end
+
+      it "raises InvalidCurrencyError when from_currency is empty" do
+        expect { converter.convert(100, "", "EUR") }
+          .to raise_error(CurrencyConverter::InvalidCurrencyError, "from_currency cannot be empty")
+      end
+
+      it "raises InvalidCurrencyError when from_currency is not 3 letters" do
+        expect { converter.convert(100, "US", "EUR") }
+          .to raise_error(CurrencyConverter::InvalidCurrencyError, /must be a 3-letter uppercase code/)
+      end
+
+      it "raises InvalidCurrencyError when from_currency is not uppercase" do
+        expect { converter.convert(100, "usd", "EUR") }
+          .to raise_error(CurrencyConverter::InvalidCurrencyError, /must be a 3-letter uppercase code/)
+      end
 
-  it "performs the conversion successfully when rate is available" do
-    # Simulate a successful exchange rate retrieval
-    allow_any_instance_of(CurrencyConverter::APIClient)
-      .to receive(:get_rate)
-      .and_return(0.85)
+      it "raises InvalidCurrencyError when from_currency contains numbers" do
+        expect { converter.convert(100, "US1", "EUR") }
+          .to raise_error(CurrencyConverter::InvalidCurrencyError, /must be a 3-letter uppercase code/)
+      end
 
-    result = converter.convert(100, "USD", "EUR")
-    expect(result).to eq(85.0)
+      it "raises InvalidCurrencyError when to_currency is invalid" do
+        expect { converter.convert(100, "USD", "euro") }
+          .to raise_error(CurrencyConverter::InvalidCurrencyError, /must be a 3-letter uppercase code/)
+      end
+    end
   end
 end