feat: book api service implementation

go.mod

···
 	github.com/spf13/cobra v1.9.1
 )
 
-require github.com/google/uuid v1.6.0
+require (
+	github.com/google/uuid v1.6.0
+	golang.org/x/time v0.12.0
+)
 
 require (
 	github.com/charmbracelet/bubbletea v1.3.4 // indirect

go.sum

···
 golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 golang.org/x/text v0.24.0 h1:dd5Bzh4yt5KYA8f9CJHCP4FB4D51c2c6JvN37xJJkJ0=
 golang.org/x/text v0.24.0/go.mod h1:L8rBsPeo2pSS+xqN0d5u2ikmjtmoJbDBT1b7nHvFCdU=
+golang.org/x/time v0.12.0 h1:ScB/8o8olJvc+CQPWrK3fPZNfh7qgwCrY0zJmoEQLSE=
+golang.org/x/time v0.12.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/services/services.go

···
 
 import (
 	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+	"time"
 
 	"github.com/stormlightlabs/noteleaf/internal/models"
+	"golang.org/x/time/rate"
+)
+
+const (
+	// Open Library API endpoints
+	openLibraryBaseURL = "https://openlibrary.org"
+	openLibrarySearch  = openLibraryBaseURL + "/search.json"
+
+	// Rate limiting: 180 requests per minute = 3 requests per second
+	requestsPerSecond = 3
+	burstLimit        = 5
+
+	// User agent
+	// TODO: See https://www.digitalocean.com/community/tutorials/using-ldflags-to-set-version-information-for-go-applications
+	userAgent string = "Noteleaf/1.0.0 ([e-mail])"
 )
 
 // APIService defines the contract for API interactions
 type APIService interface {
 	Get(ctx context.Context, id string) (*models.Model, error)
-	Search(ctx context.Context, page, limit int) ([]*models.Model, error)
+	Search(ctx context.Context, query string, page, limit int) ([]*models.Model, error)
 	Check(ctx context.Context) error
 	Close() error
 }
+
+// BookService implements APIService for Open Library
+type BookService struct {
+	client  *http.Client
+	limiter *rate.Limiter
+	baseURL string // Allow configurable base URL for testing
+}
+
+// NewBookService creates a new book service with rate limiting
+func NewBookService() *BookService {
+	return &BookService{
+		client: &http.Client{
+			Timeout: 30 * time.Second,
+		},
+		limiter: rate.NewLimiter(rate.Limit(requestsPerSecond), burstLimit),
+		baseURL: openLibraryBaseURL,
+	}
+}
+
+// NewBookServiceWithBaseURL creates a book service with custom base URL (for testing)
+func NewBookServiceWithBaseURL(baseURL string) *BookService {
+	return &BookService{
+		client: &http.Client{
+			Timeout: 30 * time.Second,
+		},
+		limiter: rate.NewLimiter(rate.Limit(requestsPerSecond), burstLimit),
+		baseURL: baseURL,
+	}
+}
+
+// OpenLibrarySearchResponse represents the search response from Open Library
+type OpenLibrarySearchResponse struct {
+	NumFound      int                    `json:"numFound"`
+	Start         int                    `json:"start"`
+	NumFoundExact bool                   `json:"numFoundExact"`
+	Docs          []OpenLibrarySearchDoc `json:"docs"`
+}
+
+// OpenLibrarySearchDoc represents a book document in search results
+type OpenLibrarySearchDoc struct {
+	Key              string   `json:"key"`
+	Title            string   `json:"title"`
+	AuthorName       []string `json:"author_name"`
+	FirstPublishYear int      `json:"first_publish_year"`
+	PublishYear      []int    `json:"publish_year"`
+	Edition_count    int      `json:"edition_count"`
+	ISBN             []string `json:"isbn"`
+	PublisherName    []string `json:"publisher"`
+	Subject          []string `json:"subject"`
+	CoverI           int      `json:"cover_i"`
+	HasFulltext      bool     `json:"has_fulltext"`
+	PublicScanB      bool     `json:"public_scan_b"`
+	ReadinglogCount  int      `json:"readinglog_count"`
+	WantToReadCount  int      `json:"want_to_read_count"`
+	CurrentlyReading int      `json:"currently_reading_count"`
+	AlreadyReadCount int      `json:"already_read_count"`
+}
+
+// OpenLibraryWork represents a work details from Open Library
+type OpenLibraryWork struct {
+	Key              string                 `json:"key"`
+	Title            string                 `json:"title"`
+	Authors          []OpenLibraryAuthorRef `json:"authors"`
+	Description      any                    `json:"description"` // Can be string or object
+	Subjects         []string               `json:"subjects"`
+	Covers           []int                  `json:"covers"`
+	FirstPublishDate string                 `json:"first_publish_date"`
+}
+
+// OpenLibraryAuthorRef represents an author reference in a work
+type OpenLibraryAuthorRef struct {
+	Author OpenLibraryAuthorKey `json:"author"`
+	Type   OpenLibraryType      `json:"type"`
+}
+
+// OpenLibraryAuthorKey represents an author key
+type OpenLibraryAuthorKey struct {
+	Key string `json:"key"`
+}
+
+// OpenLibraryType represents a type reference
+type OpenLibraryType struct {
+	Key string `json:"key"`
+}
+
+// Search searches for books using the Open Library API
+func (bs *BookService) Search(ctx context.Context, query string, page, limit int) ([]*models.Model, error) {
+	if err := bs.limiter.Wait(ctx); err != nil {
+		return nil, fmt.Errorf("rate limit wait failed: %w", err)
+	}
+
+	// Build search URL
+	params := url.Values{}
+	params.Add("q", query)
+	params.Add("offset", strconv.Itoa((page-1)*limit))
+	params.Add("limit", strconv.Itoa(limit))
+	params.Add("fields", "key,title,author_name,first_publish_year,edition_count,isbn,publisher,subject,cover_i,has_fulltext")
+
+	searchURL := bs.baseURL + "/search.json?" + params.Encode()
+
+	req, err := http.NewRequestWithContext(ctx, "GET", searchURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Set("User-Agent", userAgent)
+	req.Header.Set("Accept", "application/json")
+
+	resp, err := bs.client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to make request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("API returned status %d", resp.StatusCode)
+	}
+
+	var searchResp OpenLibrarySearchResponse
+	if err := json.NewDecoder(resp.Body).Decode(&searchResp); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	// Convert to models
+	var books []*models.Model
+	for _, doc := range searchResp.Docs {
+		book := bs.searchDocToBook(doc)
+		var model models.Model = book
+		books = append(books, &model)
+	}
+
+	return books, nil
+}
+
+// Get retrieves a specific book by Open Library work key
+func (bs *BookService) Get(ctx context.Context, id string) (*models.Model, error) {
+	if err := bs.limiter.Wait(ctx); err != nil {
+		return nil, fmt.Errorf("rate limit wait failed: %w", err)
+	}
+
+	// Ensure id starts with /works/
+	workKey := id
+	if !strings.HasPrefix(workKey, "/works/") {
+		workKey = "/works/" + id
+	}
+
+	workURL := bs.baseURL + workKey + ".json"
+
+	req, err := http.NewRequestWithContext(ctx, "GET", workURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Set("User-Agent", userAgent)
+	req.Header.Set("Accept", "application/json")
+
+	resp, err := bs.client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to make request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode == http.StatusNotFound {
+		return nil, fmt.Errorf("book not found: %s", id)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("API returned status %d", resp.StatusCode)
+	}
+
+	var work OpenLibraryWork
+	if err := json.NewDecoder(resp.Body).Decode(&work); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	book := bs.workToBook(work)
+	var model models.Model = book
+	return &model, nil
+}
+
+// Check verifies the API connection
+func (bs *BookService) Check(ctx context.Context) error {
+	if err := bs.limiter.Wait(ctx); err != nil {
+		return fmt.Errorf("rate limit wait failed: %w", err)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, "GET", bs.baseURL+"/search.json?q=test&limit=1", nil)
+	if err != nil {
+		return fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Set("User-Agent", userAgent)
+
+	resp, err := bs.client.Do(req)
+	if err != nil {
+		return fmt.Errorf("failed to connect to Open Library: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("open Library API returned status %d", resp.StatusCode)
+	}
+
+	return nil
+}
+
+// Close cleans up the service resources
+//
+//	HTTP client doesn't need explicit cleanup
+func (bs *BookService) Close() error {
+	return nil
+}
+
+// Helper functions
+
+func (bs *BookService) searchDocToBook(doc OpenLibrarySearchDoc) *models.Book {
+	book := &models.Book{
+		Title:  doc.Title,
+		Status: "queued",
+		Added:  time.Now(),
+	}
+
+	if len(doc.AuthorName) > 0 {
+		book.Author = strings.Join(doc.AuthorName, ", ")
+	}
+
+	// Set publication year as pages (approximation)
+	if doc.FirstPublishYear > 0 {
+		// We don't have page count, so we'll leave it as 0
+		// Could potentially estimate based on edition count or other factors
+	}
+
+	var notes []string
+	if doc.Edition_count > 0 {
+		notes = append(notes, fmt.Sprintf("%d editions", doc.Edition_count))
+	}
+	if len(doc.PublisherName) > 0 {
+		notes = append(notes, "Publishers: "+strings.Join(doc.PublisherName, ", "))
+	}
+	if doc.CoverI > 0 {
+		notes = append(notes, fmt.Sprintf("Cover ID: %d", doc.CoverI))
+	}
+
+	if len(notes) > 0 {
+		book.Notes = strings.Join(notes, " | ")
+	}
+
+	return book
+}
+
+func (bs *BookService) workToBook(work OpenLibraryWork) *models.Book {
+	book := &models.Book{
+		Title:  work.Title,
+		Status: "queued",
+		Added:  time.Now(),
+	}
+
+	// Extract author names (would need additional API calls to get full names)
+	if len(work.Authors) > 0 {
+		// For now, just use the keys
+		var authorKeys []string
+		for _, author := range work.Authors {
+			key := strings.TrimPrefix(author.Author.Key, "/authors/")
+			authorKeys = append(authorKeys, key)
+		}
+		book.Author = strings.Join(authorKeys, ", ")
+	}
+
+	if work.Description != nil {
+		switch desc := work.Description.(type) {
+		case string:
+			book.Notes = desc
+		case map[string]any:
+			if value, ok := desc["value"].(string); ok {
+				book.Notes = value
+			}
+		}
+	}
+
+	if book.Notes == "" && len(work.Subjects) > 0 {
+		subjects := work.Subjects
+		if len(subjects) > 5 {
+			subjects = subjects[:5]
+		}
+		book.Notes = "Subjects: " + strings.Join(subjects, ", ")
+	}
+
+	return book
+}

internal/services/services_test.go

···
 package services
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestBookService(t *testing.T) {
+	t.Run("NewBookService", func(t *testing.T) {
+		service := NewBookService()
+
+		if service == nil {
+			t.Fatal("NewBookService should return a non-nil service")
+		}
+
+		if service.client == nil {
+			t.Error("BookService should have a non-nil HTTP client")
+		}
+
+		if service.limiter == nil {
+			t.Error("BookService should have a non-nil rate limiter")
+		}
+
+		if service.limiter.Limit() != requestsPerSecond {
+			t.Errorf("Expected rate limit of %v, got %v", requestsPerSecond, service.limiter.Limit())
+		}
+	})
+
+	t.Run("Search", func(t *testing.T) {
+		t.Run("successful search", func(t *testing.T) {
+			mockResponse := OpenLibrarySearchResponse{
+				NumFound: 2,
+				Start:    0,
+				Docs: []OpenLibrarySearchDoc{
+					{
+						Key:              "/works/OL45804W",
+						Title:            "Fantastic Mr. Fox",
+						AuthorName:       []string{"Roald Dahl"},
+						FirstPublishYear: 1970,
+						Edition_count:    25,
+						PublisherName:    []string{"Puffin Books", "Viking Press"},
+						Subject:          []string{"Children's literature", "Foxes", "Fiction"},
+						CoverI:           8739161,
+					},
+					{
+						Key:              "/works/OL123456W",
+						Title:            "The BFG",
+						AuthorName:       []string{"Roald Dahl"},
+						FirstPublishYear: 1982,
+						Edition_count:    15,
+						PublisherName:    []string{"Jonathan Cape"},
+						CoverI:           456789,
+					},
+				},
+			}
+
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				if r.URL.Path != "/search.json" {
+					t.Errorf("Expected path /search.json, got %s", r.URL.Path)
+				}
+
+				query := r.URL.Query()
+				if query.Get("q") != "roald dahl" {
+					t.Errorf("Expected query 'roald dahl', got %s", query.Get("q"))
+				}
+				if query.Get("limit") != "10" {
+					t.Errorf("Expected limit '10', got %s", query.Get("limit"))
+				}
+				if query.Get("offset") != "0" {
+					t.Errorf("Expected offset '0', got %s", query.Get("offset"))
+				}
+
+				if r.Header.Get("User-Agent") != userAgent {
+					t.Errorf("Expected User-Agent %s, got %s", userAgent, r.Header.Get("User-Agent"))
+				}
+
+				w.Header().Set("Content-Type", "application/json")
+				json.NewEncoder(w).Encode(mockResponse)
+			}))
+			defer server.Close()
+
+			service := NewBookServiceWithBaseURL(server.URL)
+			ctx := context.Background()
+			results, err := service.Search(ctx, "roald dahl", 1, 10)
+
+			if err != nil {
+				t.Fatalf("Search should not return error: %v", err)
+			}
+
+			if len(results) == 0 {
+				t.Error("Search should return at least one result")
+			}
+
+			if results[0] == nil {
+				t.Fatal("First result should not be nil")
+			}
+		})
+
+		t.Run("handles API error", func(t *testing.T) {
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusInternalServerError)
+			}))
+			defer server.Close()
+
+			service := NewBookServiceWithBaseURL(server.URL)
+			ctx := context.Background()
+
+			_, err := service.Search(ctx, "test", 1, 10)
+			if err == nil {
+				t.Error("Search should return error for API failure")
+			}
+
+			if !strings.Contains(err.Error(), "API returned status 500") {
+				t.Errorf("Error should mention status code, got: %v", err)
+			}
+		})
+
+		t.Run("handles malformed JSON", func(t *testing.T) {
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.Header().Set("Content-Type", "application/json")
+				w.Write([]byte("invalid json"))
+			}))
+			defer server.Close()
+
+			service := NewBookServiceWithBaseURL(server.URL)
+			ctx := context.Background()
+
+			_, err := service.Search(ctx, "test", 1, 10)
+			if err == nil {
+				t.Error("Search should return error for malformed JSON")
+			}
+
+			if !strings.Contains(err.Error(), "failed to decode response") {
+				t.Errorf("Error should mention decode failure, got: %v", err)
+			}
+		})
+
+		t.Run("handles context cancellation", func(t *testing.T) {
+			service := NewBookService()
+			ctx, cancel := context.WithCancel(context.Background())
+			cancel()
+
+			_, err := service.Search(ctx, "test", 1, 10)
+			if err == nil {
+				t.Error("Search should return error for cancelled context")
+			}
+		})
+
+		t.Run("respects pagination", func(t *testing.T) {
+			service := NewBookService()
+			ctx := context.Background()
+
+			_, err := service.Search(ctx, "test", 2, 5)
+			if err != nil {
+				t.Logf("Expected error for actual API call: %v", err)
+			}
+		})
+	})
+
+	t.Run("Get", func(t *testing.T) {
+		t.Run("successful get by work key", func(t *testing.T) {
+			mockWork := OpenLibraryWork{
+				Key:   "/works/OL45804W",
+				Title: "Fantastic Mr. Fox",
+				Authors: []OpenLibraryAuthorRef{
+					{
+						Author: OpenLibraryAuthorKey{Key: "/authors/OL34184A"},
+					},
+				},
+				Description: "A story about a clever fox who outsmarts three mean farmers.",
+				Subjects:    []string{"Children's literature", "Foxes", "Fiction"},
+				Covers:      []int{8739161, 8739162},
+			}
+
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				if !strings.HasPrefix(r.URL.Path, "/works/") {
+					t.Errorf("Expected path to start with /works/, got %s", r.URL.Path)
+				}
+				if !strings.HasSuffix(r.URL.Path, ".json") {
+					t.Errorf("Expected path to end with .json, got %s", r.URL.Path)
+				}
+
+				if r.Header.Get("User-Agent") != userAgent {
+					t.Errorf("Expected User-Agent %s, got %s", userAgent, r.Header.Get("User-Agent"))
+				}
+
+				w.Header().Set("Content-Type", "application/json")
+				json.NewEncoder(w).Encode(mockWork)
+			}))
+			defer server.Close()
+
+			service := NewBookServiceWithBaseURL(server.URL)
+			ctx := context.Background()
+
+			result, err := service.Get(ctx, "OL45804W")
+			if err != nil {
+				t.Fatalf("Get should not return error: %v", err)
+			}
+
+			if result == nil {
+				t.Fatal("Get should return a non-nil result")
+			}
+		})
+
+		t.Run("handles work key with /works/ prefix", func(t *testing.T) {
+			service := NewBookService()
+			ctx := context.Background()
+
+			_, err1 := service.Get(ctx, "OL45804W")
+			_, err2 := service.Get(ctx, "/works/OL45804W")
+
+			if (err1 == nil) != (err2 == nil) {
+				t.Errorf("Both key formats should behave similarly. Error1: %v, Error2: %v", err1, err2)
+			}
+		})
+
+		t.Run("handles not found", func(t *testing.T) {
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusNotFound)
+			}))
+			defer server.Close()
+
+			service := NewBookServiceWithBaseURL(server.URL)
+			ctx := context.Background()
+
+			_, err := service.Get(ctx, "nonexistent")
+			if err == nil {
+				t.Error("Get should return error for non-existent work")
+			}
+
+			if !strings.Contains(err.Error(), "book not found") {
+				t.Errorf("Error should mention book not found, got: %v", err)
+			}
+		})
+
+		t.Run("handles API error", func(t *testing.T) {
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusInternalServerError)
+			}))
+			defer server.Close()
+
+			service := NewBookServiceWithBaseURL(server.URL)
+			ctx := context.Background()
+
+			_, err := service.Get(ctx, "test")
+			if err == nil {
+				t.Error("Get should return error for API failure")
+			}
+
+			if !strings.Contains(err.Error(), "API returned status 500") {
+				t.Errorf("Error should mention status code, got: %v", err)
+			}
+		})
+	})
+
+	t.Run("Check", func(t *testing.T) {
+		t.Run("successful check", func(t *testing.T) {
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				// Verify it's a search request with test query
+				if r.URL.Path != "/search.json" {
+					t.Errorf("Expected path /search.json, got %s", r.URL.Path)
+				}
+
+				query := r.URL.Query()
+				if query.Get("q") != "test" {
+					t.Errorf("Expected query 'test', got %s", query.Get("q"))
+				}
+				if query.Get("limit") != "1" {
+					t.Errorf("Expected limit '1', got %s", query.Get("limit"))
+				}
+
+				// Verify User-Agent
+				if r.Header.Get("User-Agent") != userAgent {
+					t.Errorf("Expected User-Agent %s, got %s", userAgent, r.Header.Get("User-Agent"))
+				}
+
+				w.WriteHeader(http.StatusOK)
+				w.Write([]byte(`{"numFound": 1, "docs": []}`))
+			}))
+			defer server.Close()
+
+			service := NewBookServiceWithBaseURL(server.URL)
+			ctx := context.Background()
+
+			// Test with mock server
+			err := service.Check(ctx)
+			if err != nil {
+				t.Errorf("Check should not return error for healthy API: %v", err)
+			}
+		})
+
+		t.Run("handles API failure", func(t *testing.T) {
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusServiceUnavailable)
+			}))
+			defer server.Close()
+
+			service := NewBookServiceWithBaseURL(server.URL)
+			ctx := context.Background()
+
+			err := service.Check(ctx)
+			if err == nil {
+				t.Error("Check should return error for API failure")
+			}
+
+			if !strings.Contains(err.Error(), "open Library API returned status 503") {
+				t.Errorf("Error should mention API status, got: %v", err)
+			}
+		})
+
+		t.Run("handles network error", func(t *testing.T) {
+			service := NewBookService()
+			ctx, cancel := context.WithTimeout(context.Background(), 1*time.Millisecond)
+			defer cancel()
+
+			err := service.Check(ctx)
+			if err == nil {
+				t.Error("Check should return error for network failure")
+			}
+		})
+	})
+
+	t.Run("Close", func(t *testing.T) {
+		service := NewBookService()
+		err := service.Close()
+		if err != nil {
+			t.Errorf("Close should not return error: %v", err)
+		}
+	})
+
+	t.Run("RateLimiting", func(t *testing.T) {
+		t.Run("respects rate limits", func(t *testing.T) {
+			service := NewBookService()
+			ctx := context.Background()
+
+			start := time.Now()
+			var errors []error
+
+			for range 5 {
+				_, err := service.Search(ctx, "test", 1, 1)
+				errors = append(errors, err)
+			}
+
+			elapsed := time.Since(start)
+
+			// Should take some time due to rate limiting
+			// NOTE: This test might be flaky depending on network conditions
+			t.Logf("5 requests took %v", elapsed)
+
+			allFailed := true
+			for _, err := range errors {
+				if err == nil {
+					allFailed = false
+					break
+				}
+			}
+
+			if allFailed {
+				t.Log("All requests failed, which is expected for rate limiting test")
+			}
+		})
+	})
+
+	t.Run("Conversion Functions", func(t *testing.T) {
+		t.Run("searchDocToBook conversion", func(t *testing.T) {
+			service := NewBookService()
+			doc := OpenLibrarySearchDoc{
+				Key:              "/works/OL45804W",
+				Title:            "Test Book",
+				AuthorName:       []string{"Author One", "Author Two"},
+				FirstPublishYear: 1999,
+				Edition_count:    5,
+				PublisherName:    []string{"Test Publisher"},
+				CoverI:           12345,
+			}
+
+			book := service.searchDocToBook(doc)
+
+			if book.Title != "Test Book" {
+				t.Errorf("Expected title 'Test Book', got %s", book.Title)
+			}
+
+			if book.Author != "Author One, Author Two" {
+				t.Errorf("Expected author 'Author One, Author Two', got %s", book.Author)
+			}
+
+			if book.Status != "queued" {
+				t.Errorf("Expected status 'queued', got %s", book.Status)
+			}
+
+			if !strings.Contains(book.Notes, "5 editions") {
+				t.Errorf("Expected notes to contain edition count, got %s", book.Notes)
+			}
+
+			if !strings.Contains(book.Notes, "Test Publisher") {
+				t.Errorf("Expected notes to contain publisher, got %s", book.Notes)
+			}
+		})
+
+		t.Run("workToBook conversion with string description", func(t *testing.T) {
+			service := NewBookService()
+			work := OpenLibraryWork{
+				Key:   "/works/OL45804W",
+				Title: "Test Work",
+				Authors: []OpenLibraryAuthorRef{
+					{Author: OpenLibraryAuthorKey{Key: "/authors/OL123A"}},
+					{Author: OpenLibraryAuthorKey{Key: "/authors/OL456A"}},
+				},
+				Description: "This is a test description",
+				Subjects:    []string{"Fiction", "Adventure", "Classic"},
+			}
+
+			book := service.workToBook(work)
+
+			if book.Title != "Test Work" {
+				t.Errorf("Expected title 'Test Work', got %s", book.Title)
+			}
+
+			if book.Author != "OL123A, OL456A" {
+				t.Errorf("Expected author 'OL123A, OL456A', got %s", book.Author)
+			}
+
+			if book.Notes != "This is a test description" {
+				t.Errorf("Expected notes to be description, got %s", book.Notes)
+			}
+		})
+
+		t.Run("workToBook conversion with object description", func(t *testing.T) {
+			service := NewBookService()
+			work := OpenLibraryWork{
+				Title: "Test Work",
+				Description: map[string]any{
+					"type":  "/type/text",
+					"value": "Object description",
+				},
+			}
+
+			book := service.workToBook(work)
+
+			if book.Notes != "Object description" {
+				t.Errorf("Expected notes to be object description, got %s", book.Notes)
+			}
+		})
+
+		t.Run("workToBook uses subjects when no description", func(t *testing.T) {
+			service := NewBookService()
+			work := OpenLibraryWork{
+				Title:    "Test Work",
+				Subjects: []string{"Fiction", "Adventure", "Classic", "Literature", "Drama", "Extra"},
+			}
+
+			book := service.workToBook(work)
+
+			if !strings.Contains(book.Notes, "Subjects:") {
+				t.Errorf("Expected notes to contain subjects, got %s", book.Notes)
+			}
+
+			if !strings.Contains(book.Notes, "Fiction") {
+				t.Errorf("Expected notes to contain Fiction, got %s", book.Notes)
+			}
+
+			subjectCount := strings.Count(book.Notes, ",") + 1
+			if subjectCount > 5 {
+				t.Errorf("Expected max 5 subjects, got %d in: %s", subjectCount, book.Notes)
+			}
+		})
+	})
+
+	t.Run("Interface Compliance", func(t *testing.T) {
+		t.Run("implements APIService interface", func(t *testing.T) {
+			var _ APIService = &BookService{}
+			var _ APIService = NewBookService()
+		})
+	})
+
+	t.Run("UserAgent header", func(t *testing.T) {
+		expectedFormat := "Noteleaf/1.0.0 ([e-mail])"
+		if userAgent != expectedFormat {
+			t.Errorf("User agent should follow the required format. Expected %s, got %s", expectedFormat, userAgent)
+		}
+	})
+
+	t.Run("Constants", func(t *testing.T) {
+		t.Run("API endpoints are correct", func(t *testing.T) {
+			if openLibraryBaseURL != "https://openlibrary.org" {
+				t.Errorf("Base URL should be https://openlibrary.org, got %s", openLibraryBaseURL)
+			}
+
+			if openLibrarySearch != "https://openlibrary.org/search.json" {
+				t.Errorf("Search URL should be https://openlibrary.org/search.json, got %s", openLibrarySearch)
+			}
+		})
+
+		t.Run("rate limiting constants are correct", func(t *testing.T) {
+			if requestsPerSecond != 3 {
+				t.Errorf("Requests per second should be 3 (180/60), got %d", requestsPerSecond)
+			}
+
+			if burstLimit < requestsPerSecond {
+				t.Errorf("Burst limit should be at least equal to requests per second, got %d", burstLimit)
+			}
+		})
+	})
+}