errors_test.go

package mysa

import (
	"errors"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"
)

func TestUnauthenticatedError(t *testing.T) {
	t.Run("Error message without cause", func(t *testing.T) {
		err := &UnauthenticatedError{Message: "session expired"}
		if err.Error() != "session expired" {
			t.Errorf("Error() = %v, want %v", err.Error(), "session expired")
		}
	})

	t.Run("Error message with cause", func(t *testing.T) {
		cause := errors.New("token invalid")
		err := &UnauthenticatedError{Message: "session expired", Cause: cause}
		if !strings.Contains(err.Error(), "session expired") {
			t.Errorf("Error() should contain message")
		}
		if !strings.Contains(err.Error(), "token invalid") {
			t.Errorf("Error() should contain cause")
		}
	})

	t.Run("Unwrap returns cause", func(t *testing.T) {
		cause := errors.New("token invalid")
		err := &UnauthenticatedError{Message: "session expired", Cause: cause}
		if err.Unwrap() != cause {
			t.Errorf("Unwrap() = %v, want %v", err.Unwrap(), cause)
		}
	})

	t.Run("Is ErrNotAuthenticated", func(t *testing.T) {
		err := &UnauthenticatedError{Message: "test"}
		if !errors.Is(err, ErrNotAuthenticated) {
			t.Errorf("errors.Is(err, ErrNotAuthenticated) = false, want true")
		}
	})
}

func TestMysaApiError(t *testing.T) {
	t.Run("Error message without body", func(t *testing.T) {
		err := &MysaApiError{
			StatusCode: 404,
			Status:     "404 Not Found",
			URL:        "https://api.example.com/test",
			Body:       "",
		}
		expected := "Mysa API error: https://api.example.com/test returned 404 (404 Not Found)"
		if err.Error() != expected {
			t.Errorf("Error() = %v, want %v", err.Error(), expected)
		}
	})

	t.Run("Error message with body", func(t *testing.T) {
		err := &MysaApiError{
			StatusCode: 400,
			Status:     "400 Bad Request",
			URL:        "https://api.example.com/test",
			Body:       "invalid request",
		}
		if !strings.Contains(err.Error(), "invalid request") {
			t.Errorf("Error() should contain body")
		}
	})

	t.Run("IsNotFound", func(t *testing.T) {
		err := &MysaApiError{StatusCode: 404}
		if !err.IsNotFound() {
			t.Errorf("IsNotFound() = false, want true")
		}
		err.StatusCode = 200
		if err.IsNotFound() {
			t.Errorf("IsNotFound() = true, want false")
		}
	})

	t.Run("IsUnauthorized", func(t *testing.T) {
		err := &MysaApiError{StatusCode: 401}
		if !err.IsUnauthorized() {
			t.Errorf("IsUnauthorized() = false, want true")
		}
		err.StatusCode = 200
		if err.IsUnauthorized() {
			t.Errorf("IsUnauthorized() = true, want false")
		}
	})
}

func TestNewMysaApiError(t *testing.T) {
	// Create a test server that returns an error
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusBadRequest)
		w.Write([]byte(`{"error": "bad request"}`))
	}))
	defer server.Close()

	// Make a request
	resp, err := http.Get(server.URL)
	if err != nil {
		t.Fatalf("failed to make request: %v", err)
	}
	defer resp.Body.Close()

	apiErr := NewMysaApiError(resp)
	if apiErr.StatusCode != 400 {
		t.Errorf("StatusCode = %v, want 400", apiErr.StatusCode)
	}
	if !strings.Contains(apiErr.Body, "bad request") {
		t.Errorf("Body = %v, want to contain 'bad request'", apiErr.Body)
	}
}

func TestMqttPublishError(t *testing.T) {
	cause := errors.New("connection lost")
	err := &MqttPublishError{
		Topic:    "/v1/dev/abc/in",
		Attempts: 3,
		Cause:    cause,
	}

	if !strings.Contains(err.Error(), "/v1/dev/abc/in") {
		t.Errorf("Error() should contain topic")
	}
	if !strings.Contains(err.Error(), "3") {
		t.Errorf("Error() should contain attempts")
	}
	if err.Unwrap() != cause {
		t.Errorf("Unwrap() = %v, want %v", err.Unwrap(), cause)
	}
}

func TestDeviceError(t *testing.T) {
	t.Run("Error message without cause", func(t *testing.T) {
		err := &DeviceError{DeviceId: "device-123", Message: "not found"}
		expected := "device device-123: not found"
		if err.Error() != expected {
			t.Errorf("Error() = %v, want %v", err.Error(), expected)
		}
	})

	t.Run("Error message with cause", func(t *testing.T) {
		cause := errors.New("timeout")
		err := &DeviceError{DeviceId: "device-123", Message: "failed", Cause: cause}
		if !strings.Contains(err.Error(), "device-123") {
			t.Errorf("Error() should contain device ID")
		}
		if !strings.Contains(err.Error(), "timeout") {
			t.Errorf("Error() should contain cause")
		}
	})

	t.Run("Is ErrDeviceNotFound", func(t *testing.T) {
		err := &DeviceError{DeviceId: "test", Message: "not found"}
		if !errors.Is(err, ErrDeviceNotFound) {
			t.Errorf("errors.Is(err, ErrDeviceNotFound) = false, want true")
		}
	})
}