tutor-service/internal/httpapi/diagnostic_test.go

package httpapi

import (
	"bytes"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"testing"

	"tutor/internal/config"
	"tutor/internal/interview"
	"tutor/internal/learnermemory"
	"tutor/internal/ontology"
	"tutor/internal/progression"
	"tutor/internal/workflows"
)

func TestDiagnosticHTTPFlow(t *testing.T) {
	memory := learnermemory.NewService(learnermemory.NewMemoryStore())
	service := interview.NewService(interview.NewMemoryStore(), workflows.NewStubRunner(), memory)
	progress := progression.NewService(memory)
	onto := ontology.NewService(ontology.NewMemoryStore())
	handler := NewHandler(config.Config{Environment: "test", ModelKey: "deepseek-v4-flash"}, service, memory, progress, onto)
	routes := handler.Routes()

	createBody := bytes.NewBufferString(`{
		"user_id":"user-1",
		"target_role":"junior backend developer",
		"stack":["go","postgres"],
		"interview_timeline":"30 days"
	}`)
	createReq := httptest.NewRequest(http.MethodPost, "/api/v1/diagnostic-sessions", createBody)
	createRec := httptest.NewRecorder()
	routes.ServeHTTP(createRec, createReq)

	if createRec.Code != http.StatusCreated {
		t.Fatalf("create status = %d, body = %s", createRec.Code, createRec.Body.String())
	}

	var session interview.Session
	if err := json.NewDecoder(createRec.Body).Decode(&session); err != nil {
		t.Fatalf("decode create response: %v", err)
	}
	if len(session.Questions) == 0 {
		t.Fatal("expected questions")
	}

	answerBody := bytes.NewBufferString(`{
		"question_id":"` + session.Questions[0].ID + `",
		"answer_text":"Idempotent requests can be retried safely because repeated calls have the same intended effect."
	}`)
	answerReq := httptest.NewRequest(http.MethodPost, "/api/v1/diagnostic-sessions/"+session.ID+"/answers", answerBody)
	answerRec := httptest.NewRecorder()
	routes.ServeHTTP(answerRec, answerReq)

	if answerRec.Code != http.StatusCreated {
		t.Fatalf("answer status = %d, body = %s", answerRec.Code, answerRec.Body.String())
	}

	var answer interview.Answer
	if err := json.NewDecoder(answerRec.Body).Decode(&answer); err != nil {
		t.Fatalf("decode answer response: %v", err)
	}
	if len(answer.Grade.Evidence) == 0 {
		t.Fatal("expected grade evidence")
	}

	getReq := httptest.NewRequest(http.MethodGet, "/api/v1/diagnostic-sessions/"+session.ID, nil)
	getRec := httptest.NewRecorder()
	routes.ServeHTTP(getRec, getReq)

	if getRec.Code != http.StatusOK {
		t.Fatalf("get status = %d, body = %s", getRec.Code, getRec.Body.String())
	}
	var loaded interview.Session
	if err := json.NewDecoder(getRec.Body).Decode(&loaded); err != nil {
		t.Fatalf("decode get response: %v", err)
	}
	if len(loaded.Answers) != 1 {
		t.Fatalf("answers = %d, want 1", len(loaded.Answers))
	}

	memoryReq := httptest.NewRequest(http.MethodGet, "/api/v1/learners/user-1/memory", nil)
	memoryRec := httptest.NewRecorder()
	routes.ServeHTTP(memoryRec, memoryReq)

	if memoryRec.Code != http.StatusOK {
		t.Fatalf("memory status = %d, body = %s", memoryRec.Code, memoryRec.Body.String())
	}
	var snapshot learnermemory.Snapshot
	if err := json.NewDecoder(memoryRec.Body).Decode(&snapshot); err != nil {
		t.Fatalf("decode memory response: %v", err)
	}
	if snapshot.Profile.UserID != "user-1" {
		t.Fatalf("memory profile user = %q", snapshot.Profile.UserID)
	}
	if len(snapshot.Mastery) == 0 {
		t.Fatal("expected mastery entries")
	}

	readinessReq := httptest.NewRequest(http.MethodGet, "/api/v1/learners/user-1/readiness-map", nil)
	readinessRec := httptest.NewRecorder()
	routes.ServeHTTP(readinessRec, readinessReq)

	if readinessRec.Code != http.StatusOK {
		t.Fatalf("readiness status = %d, body = %s", readinessRec.Code, readinessRec.Body.String())
	}

	challengeReq := httptest.NewRequest(http.MethodGet, "/api/v1/learners/user-1/next-challenge", nil)
	challengeRec := httptest.NewRecorder()
	routes.ServeHTTP(challengeRec, challengeReq)

	if challengeRec.Code != http.StatusOK {
		t.Fatalf("challenge status = %d, body = %s", challengeRec.Code, challengeRec.Body.String())
	}
}