org-toodledo-test.el

(require 'org-toodledo)
(require 'org-toodledo-sim)

(defvar org-toodledo-test-stop-on-error nil
  "Set to t to stop tests on first error.  Useful to leave buffers 
in the same state as when the test fails.")

(defun org-toodledo-test (&rest tests)
  "Org-toodledo tests"
  (interactive)

  (save-excursion
    (setq org-toodledo-log-level 3)
    (set-buffer (get-buffer-create "*Org-toodledo-log*"))
    (erase-buffer)

    (let ((org-toodledo-test-count 0)
          (org-toodledo-test-pass 0)
          (org-toodledo-test-fail 0)
          (debug-on-error t)
          (org-toodledo-test-msg-buf (get-buffer-create "*Org-toodledo-test-log*"))
          (org-toodledo-sync-message-time 0)
          )

      (setq org-toodledo-test-mode t)
      (setq org-toodledo-sim-mode nil)
      (pop-to-buffer org-toodledo-test-msg-buf)
      (erase-buffer)
      
      (when (null tests)
        (org-toodledo-test-cleanup))

      (org-toodledo-test-message "Starting tests")

      (let ((buf1 (get-buffer-create "*Org-toodledo-test-1*"))
            (buf2 (get-buffer-create "*Org-toodledo-test-2*")))

        (when (or (member 'basic tests) (null tests))
          ;; Create buf1 in org-mode, fill with a few tasks
          (org-toodledo-test-message "TEST: Creating 3 tasks in buf1")
          (org-toodledo-test-setup-buffer buf1)
          (org-toodledo-test-create-tasks 3)
          (org-toodledo-initialize "TASKS")
          (sit-for 2)

          ;; Create buf2 in org-mode, initialize, pull in tasks
          (org-toodledo-test-message "TEST: Syncing 3 tasks into buf2")
          (org-toodledo-test-setup-buffer buf2)
          (org-toodledo-initialize "TASKS")
          (org-toodledo-test-verify-tasks buf2 "Task 1" "Task 2" "Task 3")
          (sit-for 2)
          
          ;; Modify Task 1 and sync
          (org-toodledo-test-message "TEST: Modifying Task 1 in buf2")
          (org-toodledo-test-goto-task "Task 1")
          (end-of-line)
          (insert-string " - modified")
          (org-toodledo-test-equal (org-toodledo-sync) '(1 0 0 0 1 0 0) "Synced out 1 modified task")
          (sit-for 2)
          
          ;; Back to buf1, sync -- verify
          (org-toodledo-test-message "TEST: Syncing modified Task 1")
          (set-buffer buf1)
          (org-toodledo-test-equal (org-toodledo-sync) '(1 1 0 0 0 0 0) "Synced in 1 modified task")
          (org-toodledo-test-verify-tasks buf1 "Task 1 - modified" "Task 2" "Task 3")
          (sit-for 2)
          
          ;; Modify Task 3 and sync
          (org-toodledo-test-message "TEST: Modifying Task 3")
          (org-toodledo-test-goto-task "Task 3")
          (end-of-line)
          (insert-string " - modified")
          (org-toodledo-test-equal (org-toodledo-sync) '(1 0 0 0 1 0 0) "Synced out 1 modified task")
          (sit-for 2)

          ;; Back to buf2, sync -- verify
          (org-toodledo-test-message "TEST: Syncing modified Task 3")
          (set-buffer buf2)
          (org-toodledo-test-equal (org-toodledo-sync) '(1 1 0 0 0 0 0) "Synced in 1 modified task")
          (org-toodledo-test-verify-tasks buf2 "Task 1 - modified" "Task 2" "Task 3 - modified")
          (sit-for 2)

          ;; Compare all tasks between both buffers
          (org-toodledo-test-message "TEST: Comparing all tasks between buffers")
          (org-toodledo-test-compare-tasks buf1 buf2 "Task 1 - modified" "Task 2" "Task 3 - modified")

          (org-toodledo-test-message "TEST: Cleanup")
          (org-toodledo-test-cleanup)
          (sit-for 2)
          )
        
        ;; 
        ;; Encoding special chars
        ;;
        (when (or (member 'special tests) (null tests))
          (org-toodledo-test-message "TEST: Encoding special characters")
          (org-toodledo-test-setup-buffer buf2)
          (org-toodledo-test-message "Initializing buf2: %S" (org-toodledo-initialize "TASKS"))
          (sit-for 2)

          (org-toodledo-test-setup-buffer buf1)
          (org-toodledo-test-message "Initializing buf1: %S" (org-toodledo-initialize "TASKS"))
          (sit-for 2)

          (goto-char (point-max))
          (insert-string "** TODO ORGTOODLEDOTEST:Task é字\nBody é字")
          (org-toodledo-test-equal (org-toodledo-sync) '(1 0 0 1 0 0 0) 
                                   "Synced out 1 new task with special chars")
          (sit-for 2)

          (set-buffer buf2)
          (org-toodledo-test-equal (org-toodledo-sync) '(1 1 0 0 0 0 0) 
                                   "Synced in 1 task with special chars")
          (org-toodledo-test-compare-tasks buf1 buf2 "Task é字")
          (sit-for 2)

          (org-toodledo-test-message "TEST: Cleanup")
          (org-toodledo-test-cleanup)
          (sit-for 2)
          )
        
        ;;
        ;; Bulk test -- make sure more than 50 works
        ;;
        (when (or (member 'bulk tests) (null tests))
          (org-toodledo-test-setup-buffer buf2)
          (org-toodledo-initialize "TASKS")
          (sit-for 2)

          (org-toodledo-test-setup-buffer buf1)
          (org-toodledo-initialize "TASKS")
          (sit-for 2)

          (org-toodledo-test-message "TEST: Create 60 tasks")
          (set-buffer buf1)
          (org-toodledo-test-create-tasks 60 2 100)
          (org-toodledo-test-equal (org-toodledo-sync) '(60 0 0 60 0 0 0)
                                   "Synced 60 new tasks")
          (sit-for 2)
          
          (set-buffer buf2)
          (org-toodledo-test-equal (org-toodledo-sync) '(60 60 0 0 0 0 0)
                                   "Synced in 60 tasks")
          (sit-for 2)

          (org-toodledo-test-message "TEST: Cleanup")
          (org-toodledo-test-cleanup)
          (sit-for 2)
          )

        ;; 
        ;; Folder tests
        ;;
        (when (or (member 'folder tests) (null tests))
          (org-toodledo-test-setup-buffer buf2)
          (org-toodledo-initialize "TASKS")
          (sit-for 2)

          (org-toodledo-test-setup-buffer buf1)
          (org-toodledo-initialize "TASKS")
          (sit-for 2)

          (org-toodledo-test-message "TEST: Create 1 task")
          (set-buffer buf1)
          (org-toodledo-test-create-tasks 1 2 200)
          (org-toodledo-test-equal (org-toodledo-sync) '(1 0 0 1 0 0 0) "Synced out 1 new task from buf1")
          (sit-for 2)
          
          (set-buffer buf2)
          (org-toodledo-test-equal (org-toodledo-sync) '(1 1 0 0 0 0 0) "Synced in 1 task into buff2")
          (sit-for 2)

          (org-toodledo-test-goto-task "Task 200")
          (org-entry-put (point) "Folder" "TESTFOLDER")
          (org-toodledo-test-equal (org-toodledo-sync) '(1 0 0 0 1 0 0) 
                                   "Synced out 1 modified task from buf2 with folder")
          (sit-for 2)

          (set-buffer buf1)
          (org-toodledo-test-equal (org-toodledo-sync) '(1 1 0 0 0 0 0) 
                                   "Synced in 1 modified task into buf1 with folder")
          (sit-for 2)

          (org-toodledo-test-compare-tasks buf1 buf2 "Task 200")

          (org-toodledo-test-message "TEST: Cleanup")
          (org-toodledo-test-cleanup)
          (sit-for 2)
          )
        
        ;; 
        ;; Tag tests
        ;;
        (when (or (member 'tag tests) (null tests))
          (org-toodledo-test-setup-buffer buf2)
          (org-toodledo-initialize "TASKS")
          (sit-for 2)

          (org-toodledo-test-setup-buffer buf1)
          (org-toodledo-initialize "TASKS")
          (sit-for 2)

          (org-toodledo-test-message "TEST: Create 10 tasks")
          (set-buffer buf1)
          (org-toodledo-test-create-tasks 10 2 300)
          (org-toodledo-test-equal (org-toodledo-sync) '(10 0 0 10 0 0 0) "Synced out 10 new tasks from buf1")
          (sit-for 2)
          
          (set-buffer buf2)
          (org-toodledo-test-equal (org-toodledo-sync) '(10 10 0 0 0 0 0) "Synced in 10 task into buf2")
          (sit-for 2)

          (mapcar (lambda (id) 
                    (org-toodledo-test-goto-task (concat "Task " id))
                    (org-set-tags-to (list (concat "Foo" id))))
                  '("303" "305" "307"))
          (org-toodledo-test-equal (org-toodledo-sync) '(3 0 0 0 3 0 0) 
                                   "Synced out 3 modified task from buf2 with tags")
          (sit-for 2)

          (set-buffer buf1)
          (org-toodledo-test-equal (org-toodledo-sync) '(3 3 0 0 0 0 0) 
                                   "Synced in 3 modified task into buf1 with tags")
          (sit-for 2)

          (org-toodledo-test-compare-tasks buf1 buf2 
                                           "Task 300" "Task 301" "Task 302" "Task 303" "Task 304"
                                           "Task 305" "Task 306" "Task 307" "Task 308" "Task 309")

          (set-buffer buf1)
          (mapcar (lambda (id) 
                    (org-toodledo-test-goto-task (concat "Task " id))
                    (org-set-tags-to (list (concat "Foo" id) "@Bar")))
                  '("303" "305" "307"))

          (mapcar (lambda (id) 
                    (org-toodledo-test-goto-task (concat "Task " id))
                    (org-set-tags-to (list "@Bar")))
                  '("300" "304" "309"))
          (org-toodledo-test-equal (org-toodledo-sync) '(6 0 0 0 6 0 0) 
                                   "Synced out 6 modified task from buf1 with tags")
          (sit-for 2)

          (set-buffer buf2)
          (org-toodledo-test-equal (org-toodledo-sync) '(6 6 0 0 0 0 0) 
                                   "Synced in 6 modified task into buf2 with tags")
          (sit-for 2)

          (org-toodledo-test-compare-tasks buf1 buf2 
                                           "Task 300" "Task 301" "Task 302" "Task 303" "Task 304"
                                           "Task 305" "Task 306" "Task 307" "Task 308" "Task 309")

          (org-toodledo-test-message "TEST: Cleanup")
          (org-toodledo-test-cleanup)
          (sit-for 2)
          )
        
        ;; 
        ;; Simulated server tests
        ;;
        (when (or (member 'sim tests) (null tests))
          (setq org-toodledo-sim-curtime 1
                org-toodledo-sim-lastedit0-task 0
                org-toodledo-sim-lastdelete-task 0
                org-toodledo-sim-db-tasks nil
                org-toodledo-sim-db-deleted nil
                org-toodledo-sim-pro 0
                org-toodledo-sim-mode t)
            
          ;; Start with 2 tasks on the server
          (org-toodledo-test-message "TEST: creating 2 tasks in db to start")
          (org-toodledo-sim-db-new-task (org-toodledo-sim-make-task '("title". "ORGTOODLEDOTEST:Task 1")))
          (org-toodledo-sim-db-new-task (org-toodledo-sim-make-task '("title". "ORGTOODLEDOTEST:Task 2")))
          
          ;; Sync them into buf1
          (org-toodledo-test-message "TEST: initializing buf1")
          (set-buffer buf1)
          (org-toodledo-test-setup-buffer buf1)
          (org-toodledo-test-equal (org-toodledo-initialize "TASKS") '(2 2 0 0 0 0 0) 
                                   "Synced in initial tasks 1,2 into buf1")

          ;; Add 2 more tasks
          (org-toodledo-test-message "TEST: adding tasks 3,4 to buf1")
          (org-toodledo-test-create-tasks 2 2 3)
          (org-toodledo-test-equal (org-toodledo-sync) '(2 0 0 2 0 0 0) 
                                   "Synced out new tasks 3,4 from buf1")

          (org-toodledo-test-message "TEST: Syncing all 4 tasks into buf2")
          (set-buffer buf2)
          (org-toodledo-test-setup-buffer buf2)
          (org-toodledo-test-equal (org-toodledo-initialize "TASKS") '(4 4 0 0 0 0 0) 
                                   "Synced in initial tasks 1-4 into buf2")
          (org-toodledo-test-compare-tasks buf1 buf2 
                                           "Task 1" "Task 2" "Task 3" "Task 4")


          ;; Add tasks 5,6 to buf2
          (org-toodledo-test-message "TEST: Creating 2 more tasks in buf2")
          (org-toodledo-test-create-tasks 2 2 5)
          (org-toodledo-test-message "...simulating invalid-key")
          (setq org-toodledo-sim-invalid-key t) ;; inject and invalid-key, this should be handled silently
          (org-toodledo-test-equal (org-toodledo-sync) '(2 0 0 2 0 0 0) 
                                   "Synced out new tasks 5,6 from buf2")

          ;; Pull those new tasks 5,6 into buf1
          (org-toodledo-test-message "TEST: Pulling 2 latest tasks back into buf1")
          (set-buffer buf1)
          (org-toodledo-test-equal (org-toodledo-sync) '(2 2 0 0 0 0 0) 
                                   "Synced in new tasks 5,6 into buf1")

          ;; Delete tasks 2,4,6 in buf1
          (org-toodledo-test-message "TEST: Deleting 3 tasks in buf1")
          (mapc 
           (lambda (id) 
             (org-toodledo-test-goto-task (format "Task %d" id))
             (org-toodledo-mark-task-deleted)) 
           '(2 4 6))
          
          (org-toodledo-test-equal (org-toodledo-sync) '(3 0 0 0 0 3 0) 
                                   "Synced out deleted tasks 2,4,6 from buf1")

          ;; Sync in the deleted tasks into buf2
          (org-toodledo-test-message "TEST: Syncing 3 deleted tasks in buf2")
          (set-buffer buf2)
          (org-toodledo-test-equal (org-toodledo-sync) '(3 0 3 0 0 0 0) 
                                   "Synced in deleted tasks 2,4,6 into buf2")

          ;; Delete task 1 on the server *and* in buf1, and attempt a sync
          ;; which will cause an "Invalid ID error"
          (org-toodledo-test-message "TEST: Deleting 1 task from buf1 and on server to generate delete error")
          (set-buffer buf1)
          (org-toodledo-test-goto-task "Task 1")
          (let* ((task (org-toodledo-parse-current-task))
                 (id (org-toodledo-task-id task)))
            (org-toodledo-sim-db-delete-task id t))
          (org-toodledo-mark-task-deleted)
          (org-toodledo-test-equal (org-toodledo-sync) '(1 0 0 0 0 1 1) 
                                   "Attempted to sync out deleted task 1 from buf1 with error")

          ;; Simulate a task error with a bad context-id
          (org-toodledo-test-message "TEST: Creating task 7 with a simulated context-id error")
          (org-toodledo-test-create-tasks 1 2 7)
          (org-toodledo-test-goto-task "Task 7")
          (end-of-line)
          (insert-string " simerror=9")
          (org-toodledo-test-equal (org-toodledo-sync) '(1 0 0 1 0 0 1) 
                                   "Attempted to sync out task 7 from buf1 with error")
          
          ;; Fix the task
          (org-toodledo-test-message "TEST: Fixing task 7")
          (org-toodledo-test-goto-task "Task 7")
          (re-search-forward " simerror=9")
          (replace-match "")
          (org-toodledo-test-equal (org-toodledo-sync) '(1 0 0 1 0 0 0) 
                                   "Attempted to sync out task 7 from buf1 with no error")


          ;; Sync into buf2
          (org-toodledo-test-message "TEST: Syncing task 7 into buf2")
          (set-buffer buf2)
          (org-toodledo-test-equal (org-toodledo-sync) '(1 1 0 0 0 0 0) 
                                   "Sync in task 7 into buf2")
          (org-toodledo-test-compare-tasks buf1 buf2 "Task 3" "Task 5" "Task 7")
          
          ;; Make task 7 an error again
          (org-toodledo-test-message "TEST: Editing 7 with a simulated context-id error")
          (org-toodledo-test-goto-task "Task 7")
          (end-of-line)
          (insert-string " simerror=9")
          (org-toodledo-test-equal (org-toodledo-sync) '(1 0 0 0 1 0 1) 
                                   "Attempted to sync out task 7 from buf2 with error")
          )
        
        ;; 
        ;; Simulated server tests
        ;;
        (when (or (member 'sim-hier tests) (null tests))
          (setq org-toodledo-sim-curtime 1
                org-toodledo-sim-lastedit0-task 0
                org-toodledo-sim-lastdelete-task 0
                org-toodledo-sim-db-tasks nil
                org-toodledo-sim-db-deleted nil
                org-toodledo-sim-pro 1
                org-toodledo-sim-mode t)
            
          ;; Start with 2 tasks on the server
          (org-toodledo-test-message "TEST: creating 2 tasks in db to start")
          (org-toodledo-sim-db-new-task (org-toodledo-sim-make-task '("title". "ORGTOODLEDOTEST:Task 1")
                                                                    '("id" . "10010")))
          (org-toodledo-sim-db-new-task (org-toodledo-sim-make-task '("title". "ORGTOODLEDOTEST:Task 2")
                                                                    '("id" . "10011")
                                                                    '("parent" . "10010")))
          
          ;; Sync them into buf1
          (org-toodledo-test-message "TEST: initializing buf1")
          (set-buffer buf1)
          (org-toodledo-test-setup-buffer buf1)
          (org-toodledo-test-equal (org-toodledo-initialize "TASKS") '(2 2 0 0 0 0 0) 
                                   "Synced in initial tasks 1,2 into buf1")
          )
        
        ;; All done
        (setq org-toodledo-test-mode nil)
        (setq org-toodledo-sim-mode nil)
        
        (org-toodledo-test-message "Tests complete: %d/%d tests passed" 
                                   (- org-toodledo-test-count org-toodledo-test-fail) 
                                   org-toodledo-test-count)
        )
      )
    )
  )

(defun org-toodledo-test-message (str &rest args)
  (save-excursion
    (set-buffer org-toodledo-test-msg-buf)
    (end-of-buffer)
    (let ((msg (concat (apply 'format (append (list str) args)) "\n")))
      (insert (concat "[" (format-time-string "%H:%M:%S") "] " msg))
      (org-toodledo-debug msg))))

(defun org-toodledo-test-debug-buffer (buf)
  (save-excursion
    (set-buffer buf)
    (copy-region-as-kill (point-min) (point-max))
    (set-buffer (get-buffer-create "*Org-toodledo-debug*"))
    (end-of-buffer)
    (insert (concat "[" (format-time-string "%H:%M:%S") (format "] ========== Buffer %S ==========" buf) "\n"))
    (yank)
    (insert (concat "\n[" (format-time-string "%H:%M:%S") (format "] ========== End of buffer %S ==========" buf) "\n"))
    )
  )
                
(defun org-toodledo-test-check (value str &rest args)
  (setq org-toodledo-test-count (1+ org-toodledo-test-count))
  (cond 
   ((not (null value))
    (setq org-toodledo-test-pass (1+ org-toodledo-test-pass))
    (org-toodledo-test-message "PASSED: %s" (apply 'format (append (list str) args)))
    t)
   
   (t 
    (setq org-toodledo-test-fail (1+ org-toodledo-test-fail))
    (org-toodledo-test-message "FAILED: %s" (apply 'format (append (list str) args)))
    (org-toodledo-test-debug-buffer buf1)
    (org-toodledo-test-debug-buffer buf2)
    (when org-toodledo-test-stop-on-error (error "FAILED"))
    nil
   )))

(defun org-toodledo-test-equal (value1 value2 str &rest args)
  (setq org-toodledo-test-count (1+ org-toodledo-test-count))
  (cond 
   ((equal value1 value2)
    (setq org-toodledo-test-pass (1+ org-toodledo-test-pass))
    (org-toodledo-test-message "PASSED: %s" (apply 'format (append (list str) args))))
   
   (t
    (setq org-toodledo-test-fail (1+ org-toodledo-test-fail))
    (org-toodledo-test-message "FAILED: %s [%S != %S]" 
             (apply 'format (append (list str) args))
             value1 value2 
             )
    (org-toodledo-test-debug-buffer buf1)
    (org-toodledo-test-debug-buffer buf2)
    (when org-toodledo-test-stop-on-error (error "FAILED"))
    )))

(defun org-toodledo-test-goto-task (title &optional buffer)
  (if buffer
      (set-buffer buffer)
    (setq buffer (current-buffer)))
  (goto-char (point-min))
  (org-toodledo-test-check (re-search-forward (concat "ORGTOODLEDOTEST:" title "\\b") nil t)
                           "Find task '%s' in buffer '%S'" title (current-buffer))
  )

(defun org-toodledo-test-setup-buffer (name)
  (let ((buf (get-buffer-create name)))
    (set-buffer buf)
    (erase-buffer)
    (when (not (eq major-mode 'org-mode))
      (org-mode))
    (insert-string "* TASKS\n")
    )
  )

(defun org-toodledo-test-create-tasks (num &optional level start)
  (end-of-buffer)
  (let (result)
    (do ((i 0 (1+ i))) ((>= i num) nil)
      (insert-string (format "%s TODO ORGTOODLEDOTEST:Task %d\n" (make-string (or level 2) ?*) (+ i (or start 1))))
      (setq result (append result (list (format "Task %d" i)))))
    result))


(defun org-toodledo-test-cleanup()
  "Delete all test tasks"
  (interactive)
  (condition-case nil
      (progn
        (setq org-toodledo-test-mode t)
        (let ((buf (get-buffer-create "*Org-toodledo-cleanup*")))
          (set-buffer buf)
          (erase-buffer)
          (when (not (eq major-mode 'org-mode))
            (org-mode))
          (insert-string "* TASKS\n")
          (org-toodledo-initialize "TASKS")
          
          ;; Delete all tasks
          (goto-char (point-min))
          (while (re-search-forward "ORGTOODLEDOTEST" nil t)
            (org-toodledo-mark-task-deleted)
            )
          
          (org-toodledo-sync)
          )
        )
    )
  )

(defun org-toodledo-test-compare-tasks (buf1 buf2 &rest titles)
  (mapcar 
   (lambda (title)
     (let (task1 task2)
       ;; Get the task from buf1
       (set-buffer buf1)
       (when (org-toodledo-test-goto-task title)
         (setq task1 (org-toodledo-parse-current-task))
         
         ;; Get the task from buf2
         (set-buffer buf2)
         (when (org-toodledo-test-goto-task title)
           (setq task2 (org-toodledo-parse-current-task))
           
           ;; Compare all fields
           (mapc 
            (lambda (task1-assoc)
              (let* ((key1 (car task1-assoc))
                     (value1 (or (cdr task1-assoc) "0"))
                     (task2-assoc (assoc key1 task2))
                     (value2 (or (cdr task2-assoc) "0")))
                (when (member key1 '("id" "title" "status" "completed" "repeat" "repeatfrom" "context" "duedate" 
                                     "startdate" "folder" "goal" "priority" "note" "length" "parent" "hash" "tag"))
                  (org-toodledo-test-message "Comparing key %s='%s'" key1 value1)
                  (org-toodledo-test-check task2-assoc "Found key '%s' in task2" key1)
                  (org-toodledo-test-equal value1 value2 "Key '%s' values match" key1))))
            task1)))))
   titles
   )
  )

(defun org-toodledo-test-verify-tasks (buffer &rest titles)
  (set-buffer buffer)
  (goto-char (point-min))
  (let ((count 0))
    (while (re-search-forward "ORGTOODLEDOTEST" nil t)
      (setq count (1+ count)))
    (org-toodledo-test-equal 
     count (length titles) "Verify buffer %S has %d tasks" buffer (length titles))
    )
  
  (mapcar 
   (lambda (title)
     (org-toodledo-test-check 
      (save-excursion 
        (goto-char (point-min))
        (re-search-forward (concat "ORGTOODLEDOTEST:" title "\\b") nil t))
      "Find task in buffer %S: %s" buffer title))
   titles))

(provide 'org-toodledo-test)