api_ollama 0.2.0

Ollama local LLM runtime API client for HTTP communication.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! Basic unit tests for `api_ollama` crate functionality.

use api_ollama::{ 
  OllamaClient, 
  ChatMessage,
  MessageRole,
  ChatRequest, 
  GenerateRequest
};
use core::time::Duration;

#[ test ]
fn test_ollama_client_new()
{
  let client = OllamaClient::new( "http://test.local:11434".to_string(), OllamaClient::recommended_timeout_fast() );
  // We can't directly test private fields but we can test the client was created
  // by attempting to use it (though it will fail without a real server)
  let _ = client;
}

#[ test ]
fn test_ollama_client_default()
{
  let client = OllamaClient::default();
  // Test that default client is created successfully
  let _ = client;
}

#[ test ]
fn test_ollama_client_with_timeout()
{
  let client = OllamaClient::new( "http://test.local:11434".to_string(), OllamaClient::recommended_timeout_fast() )
    .with_timeout( Duration::from_secs( 60 ) );
  let _ = client;
}

#[ test ]
fn test_message_creation()
{
  let message = ChatMessage
  {
    role : MessageRole::User,
    content : "Hello, world!".to_string(),
    images : None,
    #[ cfg( feature = "tool_calling" ) ]
    tool_calls : None,
  };
  
  assert_eq!( message.role, MessageRole::User );
  assert_eq!( message.content, "Hello, world!" );
}

#[ test ]
fn test_chat_request_creation()
{
  let messages = vec!
  [
    ChatMessage
    {
      role : MessageRole::User,
      content : "Hello".to_string(),
      images : None,
      #[ cfg( feature = "tool_calling" ) ]
      tool_calls : None,
    }
  ];
  
  let request = ChatRequest
  {
    model : "test-model".to_string(),
    messages,
    stream : Some( false ),
    options : None,
    #[ cfg( feature = "tool_calling" ) ]
    tools : None,
    #[ cfg( feature = "tool_calling" ) ]
    tool_messages : None,
  };
  
  assert_eq!( request.model, "test-model" );
  assert_eq!( request.messages.len(), 1 );
  assert_eq!( request.stream, Some( false ) );
}

#[ test ]
fn test_generate_request_creation()
{
  let request = GenerateRequest
  {
    model : "test-model".to_string(),
    prompt : "Tell me a joke".to_string(),
    stream : Some( false ),
    options : None,
  };
  
  assert_eq!( request.model, "test-model" );
  assert_eq!( request.prompt, "Tell me a joke" );
  assert_eq!( request.stream, Some( false ) );
}

#[ test ]
fn test_serialization_deserialization()
{
  let message = ChatMessage
  {
    role : MessageRole::Assistant,
    content : "Hello there!".to_string(),
    images : None,
    #[ cfg( feature = "tool_calling" ) ]
    tool_calls : None,
  };
  
  // Test that ChatMessage can be serialized and deserialized
  let serialized = serde_json::to_string( &message ).expect( "Failed to serialize message" );
  let deserialized : ChatMessage = serde_json::from_str( &serialized ).expect( "Failed to deserialize message" );
  
  assert_eq!( deserialized.role, message.role );
  assert_eq!( deserialized.content, message.content );
}

#[ tokio::test ]
async fn test_client_is_available_unreachable_server()
{
  // Test with unreachable server - should return false
  let mut client = OllamaClient::new( "http://unreachable.test:99999".to_string(), OllamaClient::recommended_timeout_fast() )
    .with_timeout( Duration::from_millis( 100 ) );
    
  let result = client.is_available().await;
  assert!( !result );
}