Get up and running with Kimi, GLM, MiniMax, DeepSeek, gpt-oss, Qwen, Gemma and other models.
package server
import (
"bytes"
"context"
"crypto/sha256"
"encoding/json"
"errors"
"fmt"
"net"
"net/http"
"net/http/httptest"
"net/url"
"os"
"strconv"
"strings"
"sync"
"sync/atomic"
"testing"
"time"
"github.com/ollama/ollama/api"
gguftest "github.com/ollama/ollama/internal/testutil/gguf"
"github.com/ollama/ollama/manifest"
"github.com/ollama/ollama/template"
"github.com/ollama/ollama/types/model"
"github.com/ollama/ollama/version"
)
func TestModelFromManifestReusesConfigReadForRunnerSelection(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
name := model.ParseName("legacy-runner-selection")
config, err := manifest.NewLayer(strings.NewReader(`{"model_format":"safetensors"}`), "application/vnd.docker.container.image.v1+json")
if err != nil {
t.Fatal(err)
}
data, err := json.Marshal(manifest.Manifest{SchemaVersion: 2, Config: config})
if err != nil {
t.Fatal(err)
}
if err := manifest.WriteManifestData(name, data); err != nil {
t.Fatal(err)
}
selected, err := manifest.ParseNamedManifestForRunner(name, manifest.RunnerMLX)
if err != nil {
t.Fatal(err)
}
configPath, err := manifest.BlobsPath(config.Digest)
if err != nil {
t.Fatal(err)
}
if err := os.Remove(configPath); err != nil {
t.Fatal(err)
}
m, err := modelFromManifest(name, selected)
if err != nil {
t.Fatal(err)
}
if m.Config.ModelFormat != "safetensors" {
t.Fatalf("model format = %q, want safetensors", m.Config.ModelFormat)
}
}
func TestPruneLayersSkipsRecentOrphans(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
recentDigest := "sha256:0000000000000000000000000000000000000000000000000000000000000001"
oldDigest := "sha256:0000000000000000000000000000000000000000000000000000000000000002"
for _, digest := range []string{recentDigest, oldDigest} {
p, err := manifest.BlobsPath(digest)
if err != nil {
t.Fatal(err)
}
if err := os.WriteFile(p, nil, 0o644); err != nil {
t.Fatal(err)
}
}
oldPath, err := manifest.BlobsPath(oldDigest)
if err != nil {
t.Fatal(err)
}
oldTime := time.Now().Add(-layerPruneGracePeriod - time.Hour)
if err := os.Chtimes(oldPath, oldTime, oldTime); err != nil {
t.Fatal(err)
}
if err := PruneLayers(); err != nil {
t.Fatal(err)
}
recentPath, err := manifest.BlobsPath(recentDigest)
if err != nil {
t.Fatal(err)
}
if _, err := os.Stat(recentPath); err != nil {
t.Fatalf("recent orphan was pruned: %v", err)
}
if _, err := os.Stat(oldPath); !os.IsNotExist(err) {
t.Fatalf("old orphan still exists: %v", err)
}
}
func TestGenerationDefaultsFromMetadata(t *testing.T) {
file, err := os.CreateTemp(t.TempDir(), "model-*.gguf")
if err != nil {
t.Fatal(err)
}
if err := gguftest.Write(file, gguftest.KV{
"general.architecture": "llama",
"general.sampling.top_k": uint32(40),
"general.sampling.top_p": int32(1),
"general.sampling.min_p": float32(0),
"general.sampling.typ_p": float32(0.95),
"general.sampling.temp": uint32(1),
"general.sampling.penalty_last_n": float32(64),
"general.sampling.penalty_repeat": float32(1.05),
"general.sampling.penalty_freq": uint32(0),
"general.sampling.penalty_present": int32(0),
"general.sampling.xtc_threshold": float32(0.5),
"general.sampling.mirostat_tau": float32(5),
}, nil); err != nil {
t.Fatal(err)
}
if err := file.Close(); err != nil {
t.Fatal(err)
}
md, err := extractGGUFMetadata(file.Name())
if err != nil {
t.Fatal(err)
}
defaults := generationDefaultsFromMetadata(md)
check := func(key string, want any) {
t.Helper()
if got := defaults[key]; got != want {
t.Fatalf("%s = %#v, want %#v", key, got, want)
}
}
check("top_k", int64(40))
check("top_p", float64(1))
check("min_p", float64(0))
check("typical_p", float64(0.95))
check("temperature", float64(1))
check("repeat_last_n", int64(64))
check("repeat_penalty", float64(1.05))
check("frequency_penalty", float64(0))
check("presence_penalty", float64(0))
if _, ok := defaults["mirostat_tau"]; ok {
t.Fatal("mirostat_tau should not be mapped to an Ollama option")
}
if _, ok := defaults["xtc_threshold"]; ok {
t.Fatal("xtc_threshold should not be mapped to an Ollama option")
}
}
func TestGetModelTemplateMetadata(t *testing.T) {
customTemplate := "CUSTOM {{ .Prompt }}"
t.Run("records chat template and Go TEMPLATE layer", func(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
t.Setenv("OLLAMA_GO_TEMPLATE", "")
_, digest := createBinFile(t, gguftest.KV{
"general.architecture": "llama",
"tokenizer.chat_template": "{{ bos_token }}{{ messages[0]['content'] }}",
}, nil)
writeTestModelManifest(t, "template-disabled", digest, customTemplate)
m, err := GetModelForRunner("template-disabled", "")
if err != nil {
t.Fatal(err)
}
if !m.HasChatTemplate {
t.Fatal("expected GGUF chat template to be detected")
}
if !m.HasGoTemplate {
t.Fatal("expected Go TEMPLATE layer to be detected")
}
if got := m.Template.String(); got != customTemplate {
t.Fatalf("template = %q, want %q", got, customTemplate)
}
})
t.Run("prefers chat template when Go TEMPLATE has fewer capabilities", func(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
t.Setenv("OLLAMA_GO_TEMPLATE", "")
_, digest := createBinFile(t, gguftest.KV{
"general.architecture": "llama",
"tokenizer.chat_template": "{% if tools %}{{ tools }}{% endif %}{{ messages[0]['content'] }}",
}, nil)
writeTestModelManifest(t, "chat-template-tools", digest, customTemplate)
m, err := GetModelForRunner("chat-template-tools", "")
if err != nil {
t.Fatal(err)
}
if !m.PreferChatTemplate {
t.Fatal("expected chat template to be preferred")
}
if got := m.CheckCapabilities(model.CapabilityTools); got != nil {
t.Fatalf("expected tools capability, got %v", got)
}
})
t.Run("prefers Qwen chat template with tools and inferred thinking", func(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
t.Setenv("OLLAMA_GO_TEMPLATE", "")
_, digest := createBinFile(t, gguftest.KV{
"general.architecture": "llama",
"tokenizer.chat_template": "{% if tools %}{{ tools }}{% endif %}{% set content = (content.split('</think>')|last) %}",
}, nil)
writeTestModelManifest(t, "chat-template-tools-thinking", digest, "{{ range .Messages }}{{ if .Thinking }}<think>{{ .Thinking }}</think>{{ end }}{{ .Content }}{{ end }}")
m, err := GetModelForRunner("chat-template-tools-thinking", "")
if err != nil {
t.Fatal(err)
}
if !m.PreferChatTemplate {
t.Fatal("expected chat template to be preferred")
}
if got := m.CheckCapabilities(model.CapabilityTools); got != nil {
t.Fatalf("expected tools capability, got %v", got)
}
if got := m.CheckCapabilities(model.CapabilityThinking); got != nil {
t.Fatalf("expected thinking capability, got %v", got)
}
})
t.Run("prefers chat template with stronger tool round trip", func(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
t.Setenv("OLLAMA_GO_TEMPLATE", "")
_, digest := createBinFile(t, gguftest.KV{
"general.architecture": "llama",
"tokenizer.chat_template": `{% if tools %}{{ tools }}{% endif %}
{% for message in messages %}
{% if message.tool_calls %}
{% for tool_call in message.tool_calls %}{{ tool_call.function.name }}{% endfor %}
{% endif %}
{% if message.role == 'tool' %}tool_response {{ message.content }}{% endif %}
{% endfor %}`,
}, nil)
writeTestModelManifest(t, "chat-template-tool-round-trip", digest, `{{ if .Tools }}tools{{ end }}
{{ range .Messages }}
{{ range .ToolCalls }}{{ .Function.Name }}{{ end }}
{{ end }}`)
m, err := GetModelForRunner("chat-template-tool-round-trip", "")
if err != nil {
t.Fatal(err)
}
if !m.PreferChatTemplate {
t.Fatal("expected chat template to be preferred")
}
if got := m.CheckCapabilities(model.CapabilityTools); got != nil {
t.Fatalf("expected tools capability, got %v", got)
}
})
t.Run("keeps Go TEMPLATE when chat template has weaker tool support", func(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
t.Setenv("OLLAMA_GO_TEMPLATE", "")
_, digest := createBinFile(t, gguftest.KV{
"general.architecture": "llama",
"tokenizer.chat_template": `{%- if tools and not available_tools -%}
{{- set available_tools = tools -}}
{%- endif -%}
{%- if available_tools -%}
{{ '<|start_of_role|>available_tools<|end_of_role|>' }}{{ available_tools | tojson }}{{ '<|end_of_text|>' }}
{%- endif -%}
{%- if thinking -%}<think></think><response></response>{%- endif -%}
{%- for message in messages -%}
{{ '<|start_of_role|>' + message['role'] + '<|end_of_role|>' + message['content'] + '<|end_of_text|>' }}
{%- endfor -%}`,
}, nil)
writeTestModelManifest(t, "chat-template-weaker-tools", digest, `{{ if .Tools }}tools{{ end }}
{{ range .Messages }}
{{ if eq .Role "tool" }}tool_response{{ else }}{{ .Role }}{{ end }}
{{ if .ToolCalls }}<|tool_call|>{{ range .ToolCalls }}{{ .Function.Name }}{{ end }}{{ else }}{{ .Content }}{{ end }}
{{ end }}`)
m, err := GetModelForRunner("chat-template-weaker-tools", "")
if err != nil {
t.Fatal(err)
}
if m.PreferChatTemplate {
t.Fatal("expected Go TEMPLATE to be preferred")
}
if got := m.CheckCapabilities(model.CapabilityTools); got != nil {
t.Fatalf("expected tools capability, got %v", got)
}
if got := m.CheckCapabilities(model.CapabilityThinking); got == nil {
t.Fatal("expected thinking capability to remain unavailable on Go TEMPLATE path")
}
})
t.Run("prefers Mistral chat template with tool call IDs", func(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
t.Setenv("OLLAMA_GO_TEMPLATE", "")
_, digest := createBinFile(t, map[string]any{
"general.architecture": "llama",
"tokenizer.chat_template": `{% if tools %}{{ tools }}{% endif %}
{% for message in messages %}
{% if message.get('tool_calls') %}{% for tool_call in message.tool_calls %}[TOOL_CALLS]{{ tool_call.function.name }}[CALL_ID]{{ tool_call.id }}[ARGS]{{ tool_call['function']['arguments']|tojson }}{% endfor %}{% endif %}
{% if message['role'] == 'tool' %}tool_response{{ message['content'] }}{% endif %}
{% endfor %}`,
}, nil)
writeTestModelManifest(t, "chat-template-tool-call-ids", digest, `{{ if .Tools }}tools{{ end }}
{{ range .Messages }}
{{ if eq .Role "tool" }}tool_response{{ else }}{{ .Role }}{{ end }}
{{ if .ToolCalls }}[TOOL_CALLS]{{ range .ToolCalls }}{{ .Function.Name }}[CALL_ID]0[ARGS]{{ .Function.Arguments }}{{ end }}{{ else }}{{ .Content }}{{ end }}
{{ end }}`)
m, err := GetModelForRunner("chat-template-tool-call-ids", "")
if err != nil {
t.Fatal(err)
}
if !m.PreferChatTemplate {
t.Fatal("expected chat template to be preferred")
}
if got := m.CheckCapabilities(model.CapabilityTools); got != nil {
t.Fatalf("expected tools capability, got %v", got)
}
})
t.Run("respects explicit Go TEMPLATE enablement", func(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
t.Setenv("OLLAMA_GO_TEMPLATE", "1")
_, digest := createBinFile(t, gguftest.KV{
"general.architecture": "llama",
"tokenizer.chat_template": "{% if tools %}{{ tools }}{% endif %}{{ messages[0]['content'] }}",
}, nil)
writeTestModelManifest(t, "go-template-forced", digest, customTemplate)
m, err := GetModelForRunner("go-template-forced", "")
if err != nil {
t.Fatal(err)
}
if m.PreferChatTemplate {
t.Fatal("expected explicit Go TEMPLATE setting to suppress chat_template preference")
}
if got := m.CheckCapabilities(model.CapabilityTools); got == nil {
t.Fatal("expected tools capability to be unavailable when Go TEMPLATE is explicitly enabled")
}
})
t.Run("respects explicit Go TEMPLATE disablement", func(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
t.Setenv("OLLAMA_GO_TEMPLATE", "0")
_, digest := createBinFile(t, gguftest.KV{
"general.architecture": "llama",
"tokenizer.chat_template": "{% if tools %}{{ tools }}{% endif %}{{ messages[0]['content'] }}",
}, nil)
writeTestModelManifest(t, "go-template-disabled", digest, customTemplate)
m, err := GetModelForRunner("go-template-disabled", "")
if err != nil {
t.Fatal(err)
}
if m.PreferChatTemplate {
t.Fatal("expected explicit Go TEMPLATE setting to suppress chat_template preference")
}
if got := m.CheckCapabilities(model.CapabilityTools); got != nil {
t.Fatalf("expected tools capability from GGUF chat_template, got %v", got)
}
})
t.Run("records missing chat template", func(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
t.Setenv("OLLAMA_GO_TEMPLATE", "")
_, digest := createBinFile(t, gguftest.KV{
"general.architecture": "llama",
}, nil)
writeTestModelManifest(t, "missing-chat-template", digest, customTemplate)
m, err := GetModelForRunner("missing-chat-template", "")
if err != nil {
t.Fatal(err)
}
if m.HasChatTemplate {
t.Fatal("expected missing GGUF chat template")
}
if !m.HasGoTemplate {
t.Fatal("expected Go TEMPLATE layer to be detected")
}
})
}
func writeTestModelManifest(t *testing.T, name, digest, tmpl string) {
t.Helper()
modelLayer, err := manifest.NewLayerFromLayer(digest, "application/vnd.ollama.image.model", "")
if err != nil {
t.Fatal(err)
}
templateLayer, err := manifest.NewLayer(strings.NewReader(tmpl), "application/vnd.ollama.image.template")
if err != nil {
t.Fatal(err)
}
layers := []manifest.Layer{modelLayer, templateLayer}
configLayer, err := createConfigLayer(model.ConfigV2{
ModelFormat: "gguf",
ModelFamily: "llama",
ModelFamilies: []string{"llama"},
})
if err != nil {
t.Fatal(err)
}
if err := manifest.WriteManifest(model.ParseName(name), *configLayer, layers); err != nil {
t.Fatal(err)
}
}
// loadTestMetadata fills in what GetModel would have read from the metadata
// files, so
// hand-built models resolve capabilities the same way loaded ones do.
func loadTestMetadata(t *testing.T, m *Model) {
t.Helper()
if m.ModelPath != "" {
md, err := extractGGUFMetadata(m.ModelPath)
if err != nil {
t.Fatalf("metadata for %s: %v", m.ModelPath, err)
}
m.metadata = md
}
m.projectorMetadata = nil
for _, path := range m.ProjectorPaths {
md, err := extractGGUFMetadata(path)
if err != nil {
t.Fatalf("projector metadata for %s: %v", path, err)
}
m.projectorMetadata = append(m.projectorMetadata, md)
}
}
func TestPushLayersForManifestListIncludesChildManifests(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
writeChild := func(name, runner, formatName, layerMediaType string) (manifest.Manifest, manifest.Layer, manifest.Layer) {
t.Helper()
config, err := manifest.NewLayer(strings.NewReader(name+" config"), "application/vnd.docker.container.image.v1+json")
if err != nil {
t.Fatal(err)
}
layer, err := manifest.NewLayer(strings.NewReader(name+" layer"), layerMediaType)
if err != nil {
t.Fatal(err)
}
if err := manifest.WriteManifestWithMetadata(model.ParseName(name), config, []manifest.Layer{layer}, runner, formatName); err != nil {
t.Fatal(err)
}
mf, err := manifest.ParseNamedManifestForRunner(model.ParseName(name), runner)
if err != nil {
t.Fatal(err)
}
return *mf, config, layer
}
mlx, mlxConfig, mlxLayer := writeChild("library/push-mlx:latest", manifest.RunnerMLX, manifest.FormatSafetensors, manifest.MediaTypeImageTensor)
ggml, ggmlConfig, ggmlLayer := writeChild("library/push-ggml:latest", manifest.RunnerGGML, manifest.FormatGGUF, "application/vnd.ollama.image.model")
mlxRef, err := manifest.NewManifestReference(mlx.BlobDigest(), mlx.Runner, mlx.Format)
if err != nil {
t.Fatal(err)
}
ggmlRef, err := manifest.NewManifestReference(ggml.BlobDigest(), ggml.Runner, ggml.Format)
if err != nil {
t.Fatal(err)
}
layers, err := pushLayersForManifestList(manifest.Manifest{
SchemaVersion: 2,
MediaType: manifest.MediaTypeManifestList,
Manifests: []manifest.Manifest{mlxRef, ggmlRef},
})
if err != nil {
t.Fatal(err)
}
want := map[string]string{
mlx.BlobDigest(): manifest.MediaTypeManifest,
ggml.BlobDigest(): manifest.MediaTypeManifest,
mlxConfig.Digest: mlxConfig.MediaType,
mlxLayer.Digest: mlxLayer.MediaType,
ggmlConfig.Digest: ggmlConfig.MediaType,
ggmlLayer.Digest: ggmlLayer.MediaType,
}
if len(layers) != len(want) {
t.Fatalf("layer count = %d, want %d: %#v", len(layers), len(want), layers)
}
for _, layer := range layers {
if wantMediaType, ok := want[layer.Digest]; !ok {
t.Fatalf("unexpected layer digest %q", layer.Digest)
} else if layer.MediaType != wantMediaType {
t.Fatalf("layer %q media type = %q, want %q", layer.Digest, layer.MediaType, wantMediaType)
}
if layer.Size == 0 {
t.Fatalf("layer %q has zero size", layer.Digest)
}
}
if !hasTensorLayers(layers) {
t.Fatal("manifest list push layers did not preserve tensor media type")
}
}
func TestCopyModelNarrowsManifestListToLocalChildren(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
writeChild := func(name, runner, formatName string) manifest.Manifest {
t.Helper()
config, err := manifest.NewLayer(strings.NewReader(name+" config"), "application/vnd.docker.container.image.v1+json")
if err != nil {
t.Fatal(err)
}
layer, err := manifest.NewLayer(strings.NewReader(name+" layer"), "application/vnd.ollama.image.model")
if err != nil {
t.Fatal(err)
}
if err := manifest.WriteManifestWithMetadata(model.ParseName(name), config, []manifest.Layer{layer}, runner, formatName); err != nil {
t.Fatal(err)
}
mf, err := manifest.ParseNamedManifestForRunner(model.ParseName(name), runner)
if err != nil {
t.Fatal(err)
}
return *mf
}
local := writeChild("library/narrow-local:latest", manifest.RunnerGGML, manifest.FormatGGUF)
localRef, err := manifest.NewManifestReference(local.BlobDigest(), local.Runner, local.Format)
if err != nil {
t.Fatal(err)
}
// A child the registry advertised but pull never materialized.
absentRef, err := manifest.NewManifestReference(fmt.Sprintf("sha256:%064d", 1), manifest.RunnerMLX, manifest.FormatSafetensors)
if err != nil {
t.Fatal(err)
}
writeList := func(name string, refs []manifest.Manifest) model.Name {
t.Helper()
n := model.ParseName(name)
if _, err := manifest.WriteManifestList(n, refs); err != nil {
t.Fatal(err)
}
return n
}
t.Run("drops absent children and warns", func(t *testing.T) {
src := writeList("library/narrow-src:latest", []manifest.Manifest{localRef, absentRef})
dst := model.ParseName("library/narrow-dst:latest")
warning, err := CopyModel(src, dst)
if err != nil {
t.Fatalf("CopyModel() = %v, want nil", err)
}
if !strings.Contains(warning, manifest.RunnerMLX) {
t.Errorf("warning = %q, want it to name the dropped %s child", warning, manifest.RunnerMLX)
}
data, err := manifest.ReadManifestData(dst)
if err != nil {
t.Fatal(err)
}
var copied manifest.Manifest
if err := json.Unmarshal(data, &copied); err != nil {
t.Fatal(err)
}
if len(copied.Manifests) != 1 {
t.Fatalf("copy has %d children, want 1: %#v", len(copied.Manifests), copied.Manifests)
}
if got := copied.Manifests[0].BlobDigest(); got != local.BlobDigest() {
t.Errorf("copied child digest = %q, want %q", got, local.BlobDigest())
}
})
t.Run("fully local list is copied verbatim", func(t *testing.T) {
src := writeList("library/intact-src:latest", []manifest.Manifest{localRef})
dst := model.ParseName("library/intact-dst:latest")
warning, err := CopyModel(src, dst)
if err != nil {
t.Fatalf("CopyModel() = %v, want nil", err)
}
if warning != "" {
t.Errorf("warning = %q, want none", warning)
}
srcData, err := manifest.ReadManifestData(src)
if err != nil {
t.Fatal(err)
}
dstData, err := manifest.ReadManifestData(dst)
if err != nil {
t.Fatal(err)
}
if !bytes.Equal(srcData, dstData) {
t.Errorf("copy differs from source:\n got %s\nwant %s", dstData, srcData)
}
})
t.Run("no local children is an error", func(t *testing.T) {
src := writeList("library/empty-src:latest", []manifest.Manifest{absentRef})
dst := model.ParseName("library/empty-dst:latest")
if _, err := CopyModel(src, dst); !errors.Is(err, manifest.ErrNoCompatibleManifest) {
t.Fatalf("CopyModel() = %v, want ErrNoCompatibleManifest", err)
}
if _, err := manifest.ReadManifestData(dst); err == nil {
t.Error("destination manifest was written despite the error")
}
})
}
func TestPullModelManifestListDownloadsSelectedChildOnly(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
oldVersion := version.Version
t.Cleanup(func() { version.Version = oldVersion })
version.Version = "0.40.0-rc0"
configData := []byte(`{"architecture":"test","requires":"0.40.0"}`)
configDigest := fmt.Sprintf("sha256:%x", sha256.Sum256(configData))
layerData := bytes.Repeat([]byte("selected tensor layer"), 64)
layerDigest := fmt.Sprintf("sha256:%x", sha256.Sum256(layerData))
child := manifest.Manifest{
SchemaVersion: 2,
MediaType: manifest.MediaTypeManifest,
Runner: manifest.RunnerLlamaCPP,
Format: manifest.FormatGGUF,
Config: manifest.Layer{
MediaType: "application/vnd.docker.container.image.v1+json",
Digest: configDigest,
Size: int64(len(configData)),
},
Layers: []manifest.Layer{
{
MediaType: manifest.MediaTypeImageTensor,
Digest: layerDigest,
Size: int64(len(layerData)),
},
},
}
childData, err := json.Marshal(child)
if err != nil {
t.Fatal(err)
}
childDigest := fmt.Sprintf("sha256:%x", sha256.Sum256(childData))
childRef, err := manifest.NewManifestReference(childDigest, manifest.RunnerLlamaCPP, manifest.FormatGGUF)
if err != nil {
t.Fatal(err)
}
unselectedDigest := "sha256:" + strings.Repeat("f", 64)
unselectedRef, err := manifest.NewManifestReference(unselectedDigest, manifest.RunnerGGML, manifest.FormatGGUF)
if err != nil {
t.Fatal(err)
}
parent := manifest.Manifest{
SchemaVersion: 2,
MediaType: manifest.MediaTypeManifestList,
Manifests: []manifest.Manifest{childRef, unselectedRef},
}
parentData, err := json.Marshal(parent)
if err != nil {
t.Fatal(err)
}
blobs := map[string][]byte{
childDigest: childData,
configDigest: configData,
layerDigest: layerData,
}
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
switch {
case r.Method == http.MethodGet && r.URL.Path == "/v2/library/test/manifests/latest":
w.Header().Set("Content-Type", manifest.MediaTypeManifestList)
w.Header().Set("Content-Length", strconv.Itoa(len(parentData)))
_, _ = w.Write(parentData)
case (r.Method == http.MethodHead || r.Method == http.MethodGet) && strings.HasPrefix(r.URL.Path, "/v2/library/test/blobs/"):
digest := strings.TrimPrefix(r.URL.Path, "/v2/library/test/blobs/")
if digest == unselectedDigest {
t.Errorf("requested unselected child manifest %s", digest)
http.Error(w, "unselected child requested", http.StatusNotFound)
return
}
data, ok := blobs[digest]
if !ok {
http.NotFound(w, r)
return
}
w.Header().Set("Content-Length", strconv.Itoa(len(data)))
if r.Method == http.MethodGet {
_, _ = w.Write(data)
}
default:
http.NotFound(w, r)
}
}))
defer ts.Close()
name := strings.TrimPrefix(ts.URL, "http://") + "/library/test:latest"
// Blobs download in parallel, so progress arrives from several goroutines.
var mu sync.Mutex
var progress []api.ProgressResponse
if err := PullModel(t.Context(), name, "", ®istryOptions{Insecure: true}, func(resp api.ProgressResponse) {
mu.Lock()
defer mu.Unlock()
progress = append(progress, resp)
}); err != nil {
t.Fatal(err)
}
payloadTotal := int64(len(configData) + len(layerData))
childManifestTotal := int64(len(childData))
if payloadTotal == childManifestTotal {
t.Fatalf("test fixture payload total equals child manifest size: %d", payloadTotal)
}
var sawPayloadProgress bool
for _, resp := range progress {
if resp.Digest != "sha256:model" {
continue
}
if resp.Total == childManifestTotal {
t.Fatalf("reported child manifest as model progress: %#v", resp)
}
if resp.Total == payloadTotal {
sawPayloadProgress = true
}
}
if !sawPayloadProgress {
t.Fatalf("missing selected payload progress with total %d in %#v", payloadTotal, progress)
}
n := model.ParseName(name)
gotParentData, err := manifest.ReadManifestData(n)
if err != nil {
t.Fatal(err)
}
if !bytes.Equal(gotParentData, parentData) {
t.Fatal("named manifest does not contain the parent manifest list")
}
m, err := manifest.ParseNamedManifest(n)
if err != nil {
t.Fatal(err)
}
if m.Runner != manifest.RunnerLlamaCPP {
t.Fatalf("runner = %q, want %q", m.Runner, manifest.RunnerLlamaCPP)
}
if m.Config.Digest != configDigest {
t.Fatalf("config digest = %q, want %q", m.Config.Digest, configDigest)
}
for _, digest := range []string{childDigest, configDigest, layerDigest} {
path, err := manifest.BlobsPath(digest)
if err != nil {
t.Fatal(err)
}
if _, err := os.Stat(path); err != nil {
t.Fatalf("expected blob %s to exist: %v", digest, err)
}
}
path, err := manifest.BlobsPath(unselectedDigest)
if err != nil {
t.Fatal(err)
}
if _, err := os.Stat(path); !os.IsNotExist(err) {
t.Fatalf("unselected child manifest blob exists: %v", err)
}
}
func TestModelCapabilities(t *testing.T) {
decisionModelPath, _ := createBinFile(t, gguftest.KV{
"general.architecture": "qwen35",
"qwen35.decision.type": "clef",
"tokenizer.chat_template": `{% if tools %}{{ tools }}{% endif %}<think>{{ messages }}</think>`,
}, []*gguftest.Tensor{})
// Create completion model (llama architecture without vision)
completionModelPath, _ := createBinFile(t, gguftest.KV{
"general.architecture": "llama",
}, []*gguftest.Tensor{})
ggufToolTemplateModelPath, _ := createBinFile(t, gguftest.KV{
"general.architecture": "llama",
"tokenizer.chat_template": `{% if tools %}<tool_call>{{ tools }}</tool_call>{% endif %}<think>{{ messages[0]['content'] }}</think>`,
}, []*gguftest.Tensor{})
// Create vision model (llama architecture with vision block count)
visionModelPath, _ := createBinFile(t, gguftest.KV{
"general.architecture": "llama",
"llama.vision.block_count": uint32(1),
}, []*gguftest.Tensor{})
// Create embedding model (bert architecture with pooling type)
embeddingModelPath, _ := createBinFile(t, gguftest.KV{
"general.architecture": "bert",
"bert.pooling_type": uint32(1),
}, []*gguftest.Tensor{})
audioProjectorPath, _ := createBinFile(t, gguftest.KV{
"general.architecture": "clip",
"clip.has_audio_encoder": true,
"vision.projector_type": "pixtral",
"clip.vision.block_count": uint32(1),
}, []*gguftest.Tensor{})
nemotronOmniModelPath, _ := createBinFile(t, gguftest.KV{
"general.architecture": "nemotron_h_omni",
"nemotron_h_omni.vision.block_count": uint32(1),
"nemotron_h_omni.audio.block_count": uint32(1),
"nemotron_h_omni.embedding_length": uint32(1),
"nemotron_h_omni.attention.head_count": uint32(1),
}, []*gguftest.Tensor{})
suppressedAudioProjectorPath, _ := createBinFile(t, gguftest.KV{
"general.architecture": "clip",
"clip.has_audio_encoder": true,
"vision.projector_type": "gemma4v",
"clip.vision.block_count": uint32(1),
}, []*gguftest.Tensor{})
toolsInsertTemplate, err := template.Parse("{{ .prompt }}{{ if .tools }}{{ .tools }}{{ end }}{{ if .suffix }}{{ .suffix }}{{ end }}")
if err != nil {
t.Fatalf("Failed to parse template: %v", err)
}
chatTemplate, err := template.Parse("{{ .prompt }}")
if err != nil {
t.Fatalf("Failed to parse template: %v", err)
}
toolsTemplate, err := template.Parse("{{ .prompt }}{{ if .tools }}{{ .tools }}{{ end }}")
if err != nil {
t.Fatalf("Failed to parse template: %v", err)
}
testModels := []struct {
name string
model Model
expectedCaps []model.Capability
}{
{
name: "Clef exposes decision instead of completion",
model: Model{
ModelPath: decisionModelPath,
},
expectedCaps: []model.Capability{model.CapabilityDecision},
},
{
name: "Clef filters inherited generation capabilities",
model: Model{
ModelPath: decisionModelPath,
ProjectorPaths: []string{visionModelPath},
Config: model.ConfigV2{Capabilities: []string{"decision", "vision", "completion", "insert", "tools", "thinking"}},
},
expectedCaps: []model.Capability{model.CapabilityDecision, model.CapabilityVision},
},
{
name: "model with image generation capability via config",
model: Model{
Config: model.ConfigV2{
Capabilities: []string{"image"},
},
},
expectedCaps: []model.Capability{model.CapabilityImage},
},
{
name: "model with image and vision capability (image editing)",
model: Model{
Config: model.ConfigV2{
Capabilities: []string{"image", "vision"},
},
},
expectedCaps: []model.Capability{model.CapabilityImage, model.CapabilityVision},
},
{
name: "model with completion capability",
model: Model{
ModelPath: completionModelPath,
Template: chatTemplate,
},
expectedCaps: []model.Capability{model.CapabilityCompletion},
},
{
name: "model with completion, tools, and insert capability",
model: Model{
ModelPath: completionModelPath,
Template: toolsInsertTemplate,
},
expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityTools, model.CapabilityInsert},
},
{
name: "model with tools capability",
model: Model{
ModelPath: completionModelPath,
Template: toolsTemplate,
},
expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityTools},
},
{
name: "model with GGUF chat_template tools and thinking",
model: Model{
ModelPath: ggufToolTemplateModelPath,
},
expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityTools, model.CapabilityThinking},
},
{
name: "model with Go TEMPLATE ignores GGUF chat_template capabilities",
model: Model{
ModelPath: ggufToolTemplateModelPath,
Template: chatTemplate,
HasGoTemplate: true,
HasChatTemplate: true,
},
expectedCaps: []model.Capability{model.CapabilityCompletion},
},
{
name: "model with tools capability from config and parser",
model: Model{
Config: model.ConfigV2{
Capabilities: []string{"completion", "tools"},
Parser: "qwen3-coder",
},
Template: chatTemplate,
},
expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityTools},
},
{
name: "model with vision capability",
model: Model{
ModelPath: visionModelPath,
Template: chatTemplate,
},
expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityVision},
},
{
name: "model with vision, tools, and insert capability",
model: Model{
ModelPath: visionModelPath,
Template: toolsInsertTemplate,
},
expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityVision, model.CapabilityTools, model.CapabilityInsert},
},
{
name: "model with embedding capability",
model: Model{
ModelPath: embeddingModelPath,
Template: chatTemplate,
},
expectedCaps: []model.Capability{model.CapabilityEmbedding},
},
{
name: "model with audio projector capability",
model: Model{
ModelPath: completionModelPath,
ProjectorPaths: []string{audioProjectorPath},
Template: chatTemplate,
},
expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityVision, model.CapabilityAudio},
},
{
name: "model with parser and projector capabilities without template",
model: Model{
ModelPath: completionModelPath,
ProjectorPaths: []string{audioProjectorPath},
Config: model.ConfigV2{
Parser: "functiongemma",
},
},
expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityVision, model.CapabilityAudio, model.CapabilityTools},
},
{
name: "gemma4 projector exposes audio capability",
model: Model{
ModelPath: completionModelPath,
ProjectorPaths: []string{suppressedAudioProjectorPath},
Template: chatTemplate,
},
expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityVision, model.CapabilityAudio},
},
{
name: "gemma4 gguf exposes audio capability",
model: Model{
ModelPath: completionModelPath,
ProjectorPaths: []string{audioProjectorPath},
Config: model.ConfigV2{
Renderer: gemma4RendererSmall,
Capabilities: []string{"audio"},
},
Template: chatTemplate,
},
expectedCaps: []model.Capability{model.CapabilityAudio, model.CapabilityCompletion, model.CapabilityVision},
},
{
name: "nemotron3 gguf suppresses audio capability",
model: Model{
ModelPath: nemotronOmniModelPath,
Template: chatTemplate,
},
expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityVision},
},
{
name: "nemotron3 projector suppresses audio capability",
model: Model{
ModelPath: completionModelPath,
ProjectorPaths: []string{audioProjectorPath},
Config: model.ConfigV2{
ModelFamily: "nemotron_h_omni",
},
Template: chatTemplate,
},
expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityVision},
},
{
name: "nemotron3 safetensors exposes vision and suppresses audio",
model: Model{
Config: model.ConfigV2{
ModelFormat: "safetensors",
Parser: "nemotron-3-nano",
Renderer: "nemotron-3-nano",
Capabilities: []string{"completion", "vision", "audio"},
},
Template: chatTemplate,
},
expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityVision, model.CapabilityTools, model.CapabilityThinking},
},
{
name: "nemotron3.5 safetensors exposes vision and suppresses audio",
model: Model{
Config: model.ConfigV2{
ModelFormat: "safetensors",
Parser: "nemotron-3.5-nano",
Renderer: "nemotron-3.5-nano",
Capabilities: []string{"completion", "vision", "audio"},
},
Template: chatTemplate,
},
expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityVision, model.CapabilityTools, model.CapabilityThinking},
},
}
// compare two slices of model.Capability regardless of order
compareCapabilities := func(a, b []model.Capability) bool {
if len(a) != len(b) {
return false
}
aCount := make(map[model.Capability]int)
for _, cap := range a {
aCount[cap]++
}
bCount := make(map[model.Capability]int)
for _, cap := range b {
bCount[cap]++
}
for cap, count := range aCount {
if bCount[cap] != count {
return false
}
}
return true
}
for _, tt := range testModels {
t.Run(tt.name, func(t *testing.T) {
loadTestMetadata(t, &tt.model)
// Test Capabilities method
caps := tt.model.Capabilities()
if !compareCapabilities(caps, tt.expectedCaps) {
t.Errorf("Expected capabilities %v, got %v", tt.expectedCaps, caps)
}
})
}
}
func TestModelCheckCapabilities(t *testing.T) {
// Create simple model file for tests that don't depend on GGUF content
completionModelPath, _ := createBinFile(t, gguftest.KV{
"general.architecture": "llama",
}, []*gguftest.Tensor{})
// Create vision model (llama architecture with vision block count)
visionModelPath, _ := createBinFile(t, gguftest.KV{
"general.architecture": "llama",
"llama.vision.block_count": uint32(1),
}, []*gguftest.Tensor{})
// Create embedding model (bert architecture with pooling type)
embeddingModelPath, _ := createBinFile(t, gguftest.KV{
"general.architecture": "bert",
"bert.pooling_type": uint32(1),
}, []*gguftest.Tensor{})
toolsInsertTemplate, err := template.Parse("{{ .prompt }}{{ if .tools }}{{ .tools }}{{ end }}{{ if .suffix }}{{ .suffix }}{{ end }}")
if err != nil {
t.Fatalf("Failed to parse template: %v", err)
}
chatTemplate, err := template.Parse("{{ .prompt }}")
if err != nil {
t.Fatalf("Failed to parse template: %v", err)
}
toolsTemplate, err := template.Parse("{{ .prompt }}{{ if .tools }}{{ .tools }}{{ end }}")
if err != nil {
t.Fatalf("Failed to parse template: %v", err)
}
tests := []struct {
name string
model Model
checkCaps []model.Capability
expectedErrMsg string
}{
{
name: "completion model without tools capability",
model: Model{
ModelPath: completionModelPath,
Template: chatTemplate,
},
checkCaps: []model.Capability{model.CapabilityTools},
expectedErrMsg: "does not support tools",
},
{
name: "model with all needed capabilities",
model: Model{
ModelPath: completionModelPath,
Template: toolsInsertTemplate,
},
checkCaps: []model.Capability{model.CapabilityTools, model.CapabilityInsert},
},
{
name: "model missing insert capability",
model: Model{
ModelPath: completionModelPath,
Template: toolsTemplate,
},
checkCaps: []model.Capability{model.CapabilityInsert},
expectedErrMsg: "does not support insert",
},
{
name: "model missing vision capability",
model: Model{
ModelPath: completionModelPath,
Template: toolsTemplate,
},
checkCaps: []model.Capability{model.CapabilityVision},
expectedErrMsg: "does not support vision",
},
{
name: "model with vision capability",
model: Model{
ModelPath: visionModelPath,
Template: chatTemplate,
},
checkCaps: []model.Capability{model.CapabilityVision},
},
{
name: "model with embedding capability",
model: Model{
ModelPath: embeddingModelPath,
Template: chatTemplate,
},
checkCaps: []model.Capability{model.CapabilityEmbedding},
},
{
name: "unknown capability",
model: Model{
ModelPath: completionModelPath,
Template: chatTemplate,
},
checkCaps: []model.Capability{"unknown"},
expectedErrMsg: "unknown capability",
},
{
name: "model missing image generation capability",
model: Model{
ModelPath: completionModelPath,
Template: chatTemplate,
},
checkCaps: []model.Capability{model.CapabilityImage},
expectedErrMsg: "does not support image generation",
},
{
name: "model with image generation capability",
model: Model{
Config: model.ConfigV2{
Capabilities: []string{"image"},
},
},
checkCaps: []model.Capability{model.CapabilityImage},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
loadTestMetadata(t, &tt.model)
// Test CheckCapabilities method
err := tt.model.CheckCapabilities(tt.checkCaps...)
if tt.expectedErrMsg == "" {
if err != nil {
t.Errorf("Expected no error, got: %v", err)
}
} else {
if err == nil {
t.Errorf("Expected error containing %q, got nil", tt.expectedErrMsg)
} else if !strings.Contains(err.Error(), tt.expectedErrMsg) {
t.Errorf("Expected error containing %q, got: %v", tt.expectedErrMsg, err)
}
}
})
}
}
func TestPullModelManifest(t *testing.T) {
cases := []struct {
name string
manifest string
}{
{
name: "pretty printed",
manifest: `{ "schemaVersion": 2, "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
"config": { "digest": "sha256:abc", "mediaType": "application/vnd.docker.container.image.v1+json", "size": 50 },
"layers": [{ "digest": "sha256:t1", "mediaType": "application/vnd.ollama.image.tensor", "size": 1024, "name": "model.weight" }]
}`,
},
{
name: "non-standard field order",
manifest: `{"layers":[{"size":999,"digest":"sha256:def","mediaType":"application/vnd.ollama.image.model"}],"schemaVersion":2,"config":{"size":50,"digest":"sha256:abc","mediaType":"application/vnd.docker.container.image.v1+json"},"mediaType":"application/vnd.docker.distribution.manifest.v2+json"}`,
},
}
for _, tt := range cases {
t.Run(tt.name, func(t *testing.T) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(tt.manifest))
}))
defer ts.Close()
n := model.ParseName("test/model:latest")
n.ProtocolScheme = "http"
n.Host = strings.TrimPrefix(ts.URL, "http://")
mf, data, err := pullModelManifest(t.Context(), n, ®istryOptions{})
if err != nil {
t.Fatal(err)
}
// Raw bytes must be byte-for-byte identical to what the server sent
if string(data) != tt.manifest {
t.Fatalf("raw bytes differ from server response")
}
// SHA256 of returned data must match the expected registry digest
expectedDigest := fmt.Sprintf("%x", sha256.Sum256([]byte(tt.manifest)))
gotDigest := fmt.Sprintf("%x", sha256.Sum256(data))
if gotDigest != expectedDigest {
t.Fatalf("digest mismatch\ngot: %s\nwant: %s", gotDigest, expectedDigest)
}
// Parsed manifest must still be usable
if mf.SchemaVersion != 2 {
t.Fatalf("schemaVersion = %d, want 2", mf.SchemaVersion)
}
if mf.Config.Digest == "" {
t.Fatal("config digest is empty")
}
if len(mf.Layers) == 0 {
t.Fatal("expected at least one layer")
}
})
}
}
// TestPullModelDuplicateDigestVerifiesBlob pulls a manifest whose config and
// layer share a digest. The registry redirects blob downloads via Location to
// an "internal" path serving bytes that don't match the digest, so PullModel
// must reject the pull with errDigestMismatch.
func TestPullModelDuplicateDigestVerifiesBlob(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
const bogusDigest = "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
backendURL := ""
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
switch {
case strings.Contains(r.URL.Path, "/manifests/"):
w.Header().Set("Content-Type", "application/vnd.docker.distribution.manifest.v2+json")
fmt.Fprintf(w, `{
"schemaVersion": 2,
"mediaType": "application/vnd.docker.distribution.manifest.v2+json",
"config": {
"mediaType": "application/vnd.ollama.image.config",
"digest": %q,
"size": 5
},
"layers": [{
"mediaType": "application/vnd.ollama.image.model",
"digest": %q,
"size": 5
}]
}`, bogusDigest, bogusDigest)
case strings.Contains(r.URL.Path, "/internal/blobs/"):
w.Write([]byte("attacker-controlled-bytes"))
case strings.Contains(r.URL.Path, "/blobs/"):
w.Header().Set("Location", backendURL+"/internal"+r.URL.Path)
w.WriteHeader(http.StatusOK)
default:
http.NotFound(w, r)
}
}))
defer ts.Close()
backendURL = ts.URL
u, err := url.Parse(ts.URL)
if err != nil {
t.Fatal(err)
}
n := model.ParseName(u.Host + "/test/attack")
n.ProtocolScheme = "http"
err = PullModel(t.Context(), n.String(), "", ®istryOptions{Insecure: true}, func(api.ProgressResponse) {})
if !errors.Is(err, errDigestMismatch) {
t.Fatalf("PullModel = %v, want errDigestMismatch (unverified blob would persist)", err)
}
}
// TestPullManifestRejectsCrossHostRedirect: a registry can't redirect a
// pull at an internal address; cross-host redirects to public addresses
// (hf.co's CDN) are fine. --insecure opts out.
func TestPullManifestRejectsCrossHostRedirect(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
var internalHit atomic.Bool
internal := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
internalHit.Store(true)
}))
defer internal.Close()
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, internal.URL+r.URL.Path, http.StatusFound)
}))
defer ts.Close()
requestURL, err := url.Parse(ts.URL + "/v2/test/attack/manifests/latest")
if err != nil {
t.Fatal(err)
}
// Default policy: cross-host redirect is refused before any request
// leaves for the internal host. (regOpts nil exercises the makeRequest
// default; the insecure protocol check doesn't apply at this level.)
blockedResp, err := makeRequest(t.Context(), http.MethodGet, requestURL, nil, nil, ®istryOptions{})
// On a CheckRedirect failure the client returns the pre-redirect
// response with its body already closed; close again defensively to
// satisfy bodyclose (double close is a no-op).
if blockedResp != nil && blockedResp.Body != nil {
blockedResp.Body.Close()
}
if !errors.Is(err, errBlockedRedirect) {
t.Fatalf("makeRequest = %v, want errBlockedRedirect", err)
}
if internalHit.Load() {
t.Fatal("internal host received a request despite the blocked redirect")
}
// Insecure opts out: the cross-host redirect is followed.
resp, err := makeRequest(t.Context(), http.MethodGet, requestURL, nil, nil, ®istryOptions{Insecure: true})
if err != nil {
t.Fatalf("makeRequest with Insecure = %v, want redirect followed", err)
}
resp.Body.Close()
if !internalHit.Load() {
t.Fatal("redirect target was not reached with Insecure set")
}
}
// TestPullManifestRedirectPolicy: cross-host redirects are blocked by
// default except between allowlisted hosts.
func TestPullManifestRedirectPolicy(t *testing.T) {
for _, tc := range []struct {
name string
origin string // registry host receiving the initial request
target string // redirect target
allowed bool
}{
{name: "hf to cdn sibling", origin: "hf.co", target: "us.aws.cdn.hf.co", allowed: true},
{name: "hf to huggingface", origin: "hf.co", target: "huggingface.co", allowed: true},
{name: "ollama registry to cdn", origin: "registry.ollama.ai", target: "cdn.ollama.com", allowed: true},
{name: "public third party", origin: "hf.co", target: "93.184.216.34", allowed: false},
{name: "other registry cross-host", origin: "registry.example.com", target: "cdn.example.com", allowed: false},
} {
t.Run(tc.name, func(t *testing.T) {
var hit bool
cdn := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
hit = true
w.Write([]byte("ok"))
}))
defer cdn.Close()
_, cdnPort, err := net.SplitHostPort(strings.TrimPrefix(cdn.URL, "http://"))
if err != nil {
t.Fatal(err)
}
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, "http://"+net.JoinHostPort(tc.target, cdnPort)+r.URL.Path, http.StatusFound)
}))
defer ts.Close()
// Steer all dials at the local servers so tests stay offline.
prev := testMakeRequestDialContext
testMakeRequestDialContext = func(ctx context.Context, network, addr string) (net.Conn, error) {
host, _, err := net.SplitHostPort(addr)
if err != nil {
return nil, err
}
if host == tc.target {
addr = net.JoinHostPort("127.0.0.1", cdnPort)
} else {
_, port, _ := net.SplitHostPort(strings.TrimPrefix(ts.URL, "http://"))
addr = net.JoinHostPort("127.0.0.1", port)
}
return new(net.Dialer).DialContext(ctx, network, addr)
}
defer func() { testMakeRequestDialContext = prev }()
requestURL, err := url.Parse(ts.URL + "/v2/unsloth/model/manifests/latest")
if err != nil {
t.Fatal(err)
}
requestURL.Host = net.JoinHostPort(tc.origin, requestURL.Port())
resp, err := makeRequest(t.Context(), http.MethodGet, requestURL, nil, nil, ®istryOptions{})
if tc.allowed {
if err != nil {
t.Fatalf("makeRequest = %v, want %s -> %s followed", err, tc.origin, tc.target)
}
resp.Body.Close()
if !hit {
t.Fatal("redirect target not reached")
}
return
}
if !errors.Is(err, errBlockedRedirect) {
t.Fatalf("makeRequest = %v, want errBlockedRedirect", err)
}
if hit {
t.Fatal("blocked redirect target received a request")
}
})
}
}
func TestCheckPullRequires(t *testing.T) {
tests := []struct {
name string
requires string
clientVersion string
wantErr bool
wantMessage string
}{
{
name: "empty requires passes",
requires: "",
clientVersion: "0.33.3",
},
{
name: "older requirement passes",
requires: "0.33.0",
clientVersion: "0.33.3",
},
{
name: "exact requirement passes",
requires: "0.33.3",
clientVersion: "0.33.3",
},
{
name: "release candidate satisfies release requirement",
requires: "0.40.0",
clientVersion: "0.40.0-rc0",
},
{
name: "development release candidate satisfies release requirement",
requires: "0.40.0",
clientVersion: "0.40.0-rc0-g75b952780f",
},
{
name: "prerelease with build metadata satisfies release requirement",
requires: "v0.40.0",
clientVersion: "0.40.0-beta.1+build.2",
},
{
name: "release candidate does not satisfy newer patch requirement",
requires: "0.40.1",
clientVersion: "0.40.0-rc0-g75b952780f",
wantErr: true,
wantMessage: "model requires ollama version v0.40.1 or newer (current version is v0.40.0-rc0-g75b952780f)",
},
{
name: "older release candidate fails",
requires: "0.40.0",
clientVersion: "0.39.0-rc1",
wantErr: true,
wantMessage: "model requires ollama version v0.40.0 or newer (current version is v0.39.0-rc1)",
},
{
name: "malformed prerelease fails",
requires: "0.40.0",
clientVersion: "0.40.0-rc?",
wantErr: true,
wantMessage: "model requires ollama version v0.40.0 or newer (current version is v0.40.0-rc?)",
},
{
name: "newer requirement fails",
requires: "0.35.0",
clientVersion: "0.33.3",
wantErr: true,
wantMessage: "model requires ollama version v0.35.0 or newer (current version is v0.33.3)",
},
{
name: "dev build skips check",
requires: "99.0.0",
clientVersion: "0.0.0",
},
{
name: "v-prefixed requirement passes",
requires: "v0.33.0",
clientVersion: "0.33.3",
},
{
name: "malformed requirement fails open",
requires: "banana",
clientVersion: "0.33.3",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
err := checkPullRequires(tt.requires, tt.clientVersion)
if tt.wantErr {
if err == nil {
t.Fatalf("checkPullRequires(%q, %q) = nil, want error", tt.requires, tt.clientVersion)
}
if err.Error() != tt.wantMessage {
t.Fatalf("checkPullRequires error = %q, want %q", err.Error(), tt.wantMessage)
}
return
}
if err != nil {
t.Fatalf("checkPullRequires(%q, %q) = %v, want nil", tt.requires, tt.clientVersion, err)
}
})
}
}
func TestCheckPullRequiresUsesRunningVersion(t *testing.T) {
oldVersion := version.Version
t.Cleanup(func() { version.Version = oldVersion })
// A dev build skips the check, but a stamped client that is too old
// must fail the pull before any model layers are downloaded.
version.Version = "0.33.3"
if err := checkPullRequires("0.35.0", version.Version); err == nil {
t.Fatal("expected stamped client below requires to fail")
}
}