(fwoar.sp-user:define-package :stream-provider.tests
  (:use :cl :stream-provider :should-test))
(in-package :stream-provider.tests)

(defparameter *test-string-provider* (make-instance 'string-provider))
(defparameter *test-file-provider* (make-instance 'file-provider :root #p"/nowhere/"))

(defmethod stream-key ((provider (eql *test-string-provider*)) (item string))
  item)

(defmethod stream-key ((provider (eql *test-file-provider*)) (item string))
  item)

(deftest stream-key-returns-specified-pathname ()
    (let* ((stored-item "foo")
	   (expected-pathname (pathname "foo")))
      (should be equal
	      (stream-key *test-string-provider* stored-item)
	      expected-pathname)))



(deftest stream-key-for-file-provider-is-relative-to-root ()
    (let* ((stored-item "/nowhere/foo")
	   (expected-pathname (pathname "foo")))
      (should be equal
	      expected-pathname
	      (stream-key *test-file-provider* stored-item))))

(defclass object-to-store ()
  ((%name :reader name :initarg :name :initform (error "need a name"))
   (%value :reader value :initarg :value :initform (error "need a value"))))

(defclass test-provider (string-provider)
  ())

(defmethod stream-key ((provider test-provider) (item object-to-store))
  (name item))

(defun store (provider item)
  (with-storage-stream (s item provider)
    (write-sequence (value item) s)))

(deftest with-storage-stream-writes-to-right-place ()
    (let* ((name "foo")
	   (value "bar bar")
	   (object (make-instance 'object-to-store
				  :name name
				  :value value))
	   (provider (make-instance 'test-provider)))
      (should be equal
	      (store provider object)
	      value
	      (babel:octets-to-string
	       (gethash (stream-key provider object)
			(streams provider))))))