Reformat all code.

Basically, in Emacs for each file: select all text and
`indent-region`.

- This also removes one redundant comment, and
- fixes an error with json decoding where the `json-read-from-string`
  was actually not within the intended `unless` clause (which explains
  the warning about "result of (string-equal "" json-string) will be
  ignored" which I never understood.

1 files changed, 210 insertions, 210 deletions

diff --git a/test/mastodon-tl-tests.el b/test/mastodon-tl-tests.el
index 24de5d0..4edf5d5 100644
--- a/test/mastodon-tl-tests.el
+++ b/test/mastodon-tl-tests.el
@@ -114,19 +114,19 @@
 (ert-deftest as-string-1 ()
   "Should accept a string or number and return a string."
   (let ((id "1000"))
-      (should (string= (mastodon-tl--as-string id) id))))
+    (should (string= (mastodon-tl--as-string id) id))))
 
 (ert-deftest as-string-2 ()
   "Should accept a string or number and return a string."
   (let ((id 1000))
-      (should (string= (mastodon-tl--as-string id) (number-to-string id)))))
+    (should (string= (mastodon-tl--as-string id) (number-to-string id)))))
 
 (ert-deftest more-json ()
   "Should request toots older than max_id."
   (let ((mastodon-instance-url "https://instance.url"))
     (with-mock
-      (mock (mastodon-http--get-json "https://instance.url/api/v1/timelines/foo?max_id=12345"))
-      (mastodon-tl--more-json "timelines/foo" 12345))))
+     (mock (mastodon-http--get-json "https://instance.url/api/v1/timelines/foo?max_id=12345"))
+     (mastodon-tl--more-json "timelines/foo" 12345))))
 
 (ert-deftest more-json-id-string ()
   "Should request toots older than max_id.
@@ -135,8 +135,8 @@
 a string or a numeric."
   (let ((mastodon-instance-url "https://instance.url"))
     (with-mock
-      (mock (mastodon-http--get-json "https://instance.url/api/v1/timelines/foo?max_id=12345"))
-      (mastodon-tl--more-json "timelines/foo" "12345"))))
+     (mock (mastodon-http--get-json "https://instance.url/api/v1/timelines/foo?max_id=12345"))
+     (mastodon-tl--more-json "timelines/foo" "12345"))))
 
 (ert-deftest update-json-id-string ()
   "Should request toots more recent than since_id.
@@ -145,8 +145,8 @@ a string or a numeric."
 a string or a numeric."
   (let ((mastodon-instance-url "https://instance.url"))
     (with-mock
-      (mock (mastodon-http--get-json "https://instance.url/api/v1/timelines/foo?since_id=12345"))
-      (mastodon-tl--updated-json "timelines/foo" "12345"))))
+     (mock (mastodon-http--get-json "https://instance.url/api/v1/timelines/foo?since_id=12345"))
+     (mastodon-tl--updated-json "timelines/foo" "12345"))))
 
 (ert-deftest mastodon-tl--relative-time-description ()
   "Should format relative time as expected"
@@ -156,10 +156,10 @@ a string or a numeric."
               (weeks (n) (* n (days 7)))
               (years (n) (* n (days 365)))
               (format-seconds-since (seconds)
-                                    (let ((timestamp (time-subtract (current-time) (seconds-to-time seconds))))
-                                      (mastodon-tl--relative-time-description timestamp)))
+                (let ((timestamp (time-subtract (current-time) (seconds-to-time seconds))))
+                  (mastodon-tl--relative-time-description timestamp)))
               (check (seconds expected)
-                     (should (string= (format-seconds-since seconds) expected))))
+                (should (string= (format-seconds-since seconds) expected))))
     (check 1 "less than a minute ago")
     (check 59 "less than a minute ago")
     (check 60 "one minute ago")
@@ -195,33 +195,33 @@ a string or a numeric."
                 (weeks (n) (* n (days 7)))
                 (years (n) (* n (days 365.25)))
                 (next-update (seconds-ago)
-                             (let* ((timestamp (time-subtract current-time
-                                                              (seconds-to-time seconds-ago))))
-                               (cdr (mastodon-tl--relative-time-details timestamp current-time))))
+                  (let* ((timestamp (time-subtract current-time
+                                                   (seconds-to-time seconds-ago))))
+                    (cdr (mastodon-tl--relative-time-details timestamp current-time))))
                 (check (seconds-ago)
-                       (let* ((timestamp (time-subtract current-time (seconds-to-time seconds-ago)))
-                              (at-now (mastodon-tl--relative-time-description timestamp current-time))
-                              (at-one-second-before (mastodon-tl--relative-time-description
-                                                     timestamp
-                                                     (time-subtract (next-update seconds-ago)
-                                                                    (seconds-to-time 1))))
-                              (at-result (mastodon-tl--relative-time-description
-                                          timestamp
-                                          (next-update seconds-ago))))
-                         (when nil  ;; change to t to debug test failures
-                           (prin1 (format "\nFor %s: %s / %s"
-                                          seconds-ago
-                                          (time-to-seconds
-                                           (time-subtract (next-update seconds-ago)
-                                                          timestamp))
-                                          (round
-                                           (time-to-seconds
-                                            (time-subtract (next-update seconds-ago)
-                                                           current-time))))))
-                         ;; a second earlier the description is the same as at current time
-                         (should (string= at-now at-one-second-before))
-                         ;; but at the result time it is different
-                         (should-not (string= at-one-second-before at-result)))))
+                  (let* ((timestamp (time-subtract current-time (seconds-to-time seconds-ago)))
+                         (at-now (mastodon-tl--relative-time-description timestamp current-time))
+                         (at-one-second-before (mastodon-tl--relative-time-description
+                                                timestamp
+                                                (time-subtract (next-update seconds-ago)
+                                                               (seconds-to-time 1))))
+                         (at-result (mastodon-tl--relative-time-description
+                                     timestamp
+                                     (next-update seconds-ago))))
+                    (when nil  ;; change to t to debug test failures
+                      (prin1 (format "\nFor %s: %s / %s"
+                                     seconds-ago
+                                     (time-to-seconds
+                                      (time-subtract (next-update seconds-ago)
+                                                     timestamp))
+                                     (round
+                                      (time-to-seconds
+                                       (time-subtract (next-update seconds-ago)
+                                                      current-time))))))
+                    ;; a second earlier the description is the same as at current time
+                    (should (string= at-now at-one-second-before))
+                    ;; but at the result time it is different
+                    (should-not (string= at-one-second-before at-result)))))
       (check 0)
       (check 1)
       (check 59)
@@ -253,39 +253,39 @@ a string or a numeric."
   (let ((mastodon-tl--show-avatars-p nil)
         (timestamp (cdr (assoc 'created_at mastodon-tl-test-base-toot))))
     (with-mock
-      (mock (date-to-time timestamp) => '(22782 21551))
-      (mock (format-time-string mastodon-toot-timestamp-format '(22782 21551)) => "2999-99-99 00:11:22")
-
-      (let ((byline (mastodon-tl--byline mastodon-tl-test-base-toot
-                                             'mastodon-tl--byline-author
-                                             'mastodon-tl--byline-boosted))
-	    (handle-location 20))
-	(should (string= (substring-no-properties
-			  byline)
-			 "Account 42 (@acct42@example.space) 2999-99-99 00:11:22
+     (mock (date-to-time timestamp) => '(22782 21551))
+     (mock (format-time-string mastodon-toot-timestamp-format '(22782 21551)) => "2999-99-99 00:11:22")
+
+     (let ((byline (mastodon-tl--byline mastodon-tl-test-base-toot
+                                        'mastodon-tl--byline-author
+                                        'mastodon-tl--byline-boosted))
+	   (handle-location 20))
+       (should (string= (substring-no-properties
+			 byline)
+			"Account 42 (@acct42@example.space) 2999-99-99 00:11:22
   ------------
 "))
-	(should (eq (get-text-property handle-location 'mastodon-tab-stop byline)
-                    'user-handle))
-        (should (string= (get-text-property handle-location 'mastodon-handle byline)
-                         "@acct42@example.space"))
-	(should (equal (get-text-property handle-location 'help-echo byline)
-                   "Browse user profile of @acct42@example.space"))))))
+       (should (eq (get-text-property handle-location 'mastodon-tab-stop byline)
+                   'user-handle))
+       (should (string= (get-text-property handle-location 'mastodon-handle byline)
+                        "@acct42@example.space"))
+       (should (equal (get-text-property handle-location 'help-echo byline)
+                      "Browse user profile of @acct42@example.space"))))))
 
 (ert-deftest mastodon-tl--byline-regular-with-avatar ()
   "Should format the regular toot correctly."
   (let ((mastodon-tl--show-avatars-p t)
         (timestamp (cdr (assoc 'created_at mastodon-tl-test-base-toot))))
     (with-mock
-      (stub create-image => '(image "fake data"))
-      (mock (date-to-time timestamp) => '(22782 21551))
-      (mock (format-time-string mastodon-toot-timestamp-format '(22782 21551)) => "2999-99-99 00:11:22")
-
-      (should (string= (substring-no-properties
-                        (mastodon-tl--byline mastodon-tl-test-base-toot
-                                             'mastodon-tl--byline-author
-                                             'mastodon-tl--byline-boosted))
-                       "Account 42 (@acct42@example.space) 2999-99-99 00:11:22
+     (stub create-image => '(image "fake data"))
+     (mock (date-to-time timestamp) => '(22782 21551))
+     (mock (format-time-string mastodon-toot-timestamp-format '(22782 21551)) => "2999-99-99 00:11:22")
+
+     (should (string= (substring-no-properties
+                       (mastodon-tl--byline mastodon-tl-test-base-toot
+                                            'mastodon-tl--byline-author
+                                            'mastodon-tl--byline-boosted))
+                      "Account 42 (@acct42@example.space) 2999-99-99 00:11:22
   ------------
 ")))))
 
@@ -295,14 +295,14 @@ a string or a numeric."
          (toot (cons '(reblogged . t) mastodon-tl-test-base-toot))
          (timestamp (cdr (assoc 'created_at toot))))
     (with-mock
-      (mock (date-to-time timestamp) => '(22782 21551))
-      (mock (format-time-string mastodon-toot-timestamp-format '(22782 21551)) => "2999-99-99 00:11:22")
-
-      (should (string= (substring-no-properties
-                        (mastodon-tl--byline toot
-                                             'mastodon-tl--byline-author
-                                             'mastodon-tl--byline-boosted))
-                       "(B) Account 42 (@acct42@example.space) 2999-99-99 00:11:22
+     (mock (date-to-time timestamp) => '(22782 21551))
+     (mock (format-time-string mastodon-toot-timestamp-format '(22782 21551)) => "2999-99-99 00:11:22")
+
+     (should (string= (substring-no-properties
+                       (mastodon-tl--byline toot
+                                            'mastodon-tl--byline-author
+                                            'mastodon-tl--byline-boosted))
+                      "(B) Account 42 (@acct42@example.space) 2999-99-99 00:11:22
   ------------
 ")))))
 
@@ -312,14 +312,14 @@ a string or a numeric."
          (toot (cons '(favourited . t) mastodon-tl-test-base-toot))
          (timestamp (cdr (assoc 'created_at toot))))
     (with-mock
-      (mock (date-to-time timestamp) => '(22782 21551))
-      (mock (format-time-string mastodon-toot-timestamp-format '(22782 21551)) => "2999-99-99 00:11:22")
-
-      (should (string= (substring-no-properties
-                        (mastodon-tl--byline toot
-                                             'mastodon-tl--byline-author
-                                             'mastodon-tl--byline-boosted))
-                       "(F) Account 42 (@acct42@example.space) 2999-99-99 00:11:22
+     (mock (date-to-time timestamp) => '(22782 21551))
+     (mock (format-time-string mastodon-toot-timestamp-format '(22782 21551)) => "2999-99-99 00:11:22")
+
+     (should (string= (substring-no-properties
+                       (mastodon-tl--byline toot
+                                            'mastodon-tl--byline-author
+                                            'mastodon-tl--byline-boosted))
+                      "(F) Account 42 (@acct42@example.space) 2999-99-99 00:11:22
   ------------
 ")))))
 
@@ -330,14 +330,14 @@ a string or a numeric."
          (toot `((favourited . t) (reblogged . t) ,@mastodon-tl-test-base-toot))
          (timestamp (cdr (assoc 'created_at toot))))
     (with-mock
-      (mock (date-to-time timestamp) => '(22782 21551))
-      (mock (format-time-string mastodon-toot-timestamp-format '(22782 21551)) => "2999-99-99 00:11:22")
-
-      (should (string= (substring-no-properties
-                        (mastodon-tl--byline toot
-                                             'mastodon-tl--byline-author
-                                             'mastodon-tl--byline-boosted))
-                       "(B) (F) Account 42 (@acct42@example.space) 2999-99-99 00:11:22
+     (mock (date-to-time timestamp) => '(22782 21551))
+     (mock (format-time-string mastodon-toot-timestamp-format '(22782 21551)) => "2999-99-99 00:11:22")
+
+     (should (string= (substring-no-properties
+                       (mastodon-tl--byline toot
+                                            'mastodon-tl--byline-author
+                                            'mastodon-tl--byline-boosted))
+                      "(B) (F) Account 42 (@acct42@example.space) 2999-99-99 00:11:22
   ------------
 ")))))
 
@@ -349,31 +349,31 @@ a string or a numeric."
          (timestamp (cdr (assoc 'created_at toot)))
          (original-timestamp (cdr (assoc 'created_at original-toot))))
     (with-mock
-      ;; We don't expect to use the toot's timestamp but the timestamp of the
-      ;; reblogged toot:
-      (mock (date-to-time timestamp) => '(1 2))
-      (mock (format-time-string mastodon-toot-timestamp-format '(1 2)) => "reblogging time")
-      (mock (date-to-time original-timestamp) => '(3 4))
-      (mock (format-time-string mastodon-toot-timestamp-format '(3 4)) => "original time")
-
-      (let ((byline (mastodon-tl--byline toot
-					 'mastodon-tl--byline-author
-					 'mastodon-tl--byline-boosted))
-	    (handle1-location 20)
-	    (handle2-location 65))
-	(should (string= (substring-no-properties byline)
-			 "Account 42 (@acct42@example.space)
+     ;; We don't expect to use the toot's timestamp but the timestamp of the
+     ;; reblogged toot:
+     (mock (date-to-time timestamp) => '(1 2))
+     (mock (format-time-string mastodon-toot-timestamp-format '(1 2)) => "reblogging time")
+     (mock (date-to-time original-timestamp) => '(3 4))
+     (mock (format-time-string mastodon-toot-timestamp-format '(3 4)) => "original time")
+
+     (let ((byline (mastodon-tl--byline toot
+					'mastodon-tl--byline-author
+					'mastodon-tl--byline-boosted))
+	   (handle1-location 20)
+	   (handle2-location 65))
+       (should (string= (substring-no-properties byline)
+			"Account 42 (@acct42@example.space)
  Boosted Account 43 (@acct43@example.space) original time
   ------------
 "))
-	(should (eq (get-text-property handle1-location 'mastodon-tab-stop byline)
-                'user-handle))
-	(should (equal (get-text-property handle1-location 'help-echo byline)
-		       "Browse user profile of @acct42@example.space"))
-	(should (eq (get-text-property handle2-location 'mastodon-tab-stop byline)
-                'user-handle))
-	(should (equal (get-text-property handle2-location 'help-echo byline)
-                   "Browse user profile of @acct43@example.space"))))))
+       (should (eq (get-text-property handle1-location 'mastodon-tab-stop byline)
+                   'user-handle))
+       (should (equal (get-text-property handle1-location 'help-echo byline)
+		      "Browse user profile of @acct42@example.space"))
+       (should (eq (get-text-property handle2-location 'mastodon-tab-stop byline)
+                   'user-handle))
+       (should (equal (get-text-property handle2-location 'help-echo byline)
+                      "Browse user profile of @acct43@example.space"))))))
 
 (ert-deftest mastodon-tl--byline-reblogged-with-avatars ()
   "Should format the reblogged toot correctly."
@@ -383,19 +383,19 @@ a string or a numeric."
          (timestamp (cdr (assoc 'created_at toot)))
          (original-timestamp (cdr (assoc 'created_at original-toot))))
     (with-mock
-      ;; We don't expect to use the toot's timestamp but the timestamp of the
-      ;; reblogged toot:
-      (stub create-image => '(image "fake data"))
-      (mock (date-to-time timestamp) => '(1 2))
-      (mock (format-time-string mastodon-toot-timestamp-format '(1 2)) => "reblogging time")
-      (mock (date-to-time original-timestamp) => '(3 4))
-      (mock (format-time-string mastodon-toot-timestamp-format '(3 4)) => "original time")
-
-      (should (string= (substring-no-properties
-                        (mastodon-tl--byline toot
-                                             'mastodon-tl--byline-author
-                                             'mastodon-tl--byline-boosted))
-                       "Account 42 (@acct42@example.space)
+     ;; We don't expect to use the toot's timestamp but the timestamp of the
+     ;; reblogged toot:
+     (stub create-image => '(image "fake data"))
+     (mock (date-to-time timestamp) => '(1 2))
+     (mock (format-time-string mastodon-toot-timestamp-format '(1 2)) => "reblogging time")
+     (mock (date-to-time original-timestamp) => '(3 4))
+     (mock (format-time-string mastodon-toot-timestamp-format '(3 4)) => "original time")
+
+     (should (string= (substring-no-properties
+                       (mastodon-tl--byline toot
+                                            'mastodon-tl--byline-author
+                                            'mastodon-tl--byline-boosted))
+                      "Account 42 (@acct42@example.space)
  Boosted Account 43 (@acct43@example.space) original time
   ------------
 ")))))
@@ -408,17 +408,17 @@ a string or a numeric."
          (timestamp (cdr (assoc 'created_at toot)))
          (original-timestamp (cdr (assoc 'created_at original-toot))))
     (with-mock
-      ;; We don't expect to use the toot's timestamp but the timestamp of the
-      ;; reblogged toot:
-      (mock (date-to-time timestamp) => '(1 2))
-      (mock (format-time-string mastodon-toot-timestamp-format '(1 2)) => "reblogging time")
-      (mock (date-to-time original-timestamp) => '(3 4))
-      (mock (format-time-string mastodon-toot-timestamp-format '(3 4)) => "original time")
-
-      (should (string= (substring-no-properties
-                        (mastodon-tl--byline toot
-                                             'mastodon-tl--byline-author
-                                             'mastodon-tl--byline-boosted))
+     ;; We don't expect to use the toot's timestamp but the timestamp of the
+     ;; reblogged toot:
+     (mock (date-to-time timestamp) => '(1 2))
+     (mock (format-time-string mastodon-toot-timestamp-format '(1 2)) => "reblogging time")
+     (mock (date-to-time original-timestamp) => '(3 4))
+     (mock (format-time-string mastodon-toot-timestamp-format '(3 4)) => "original time")
+
+     (should (string= (substring-no-properties
+                       (mastodon-tl--byline toot
+                                            'mastodon-tl--byline-author
+                                            'mastodon-tl--byline-boosted))
                       "(B) (F) Account 42 (@acct42@example.space)
  Boosted Account 43 (@acct43@example.space) original time
   ------------
@@ -429,17 +429,17 @@ a string or a numeric."
   (let ((mastodon-tl--show-avatars-p nil)
         (timestamp (cdr (assoc 'created_at mastodon-tl-test-base-toot))))
     (with-mock
-      (mock (date-to-time timestamp) => '(22782 21551))
-      (mock (current-time) => '(22782 22000))
-      (mock (format-time-string mastodon-toot-timestamp-format '(22782 21551)) => "2999-99-99 00:11:22")
-
-      (let* ((formatted-string (mastodon-tl--byline mastodon-tl-test-base-toot
-                                                    'mastodon-tl--byline-author
-                                                    'mastodon-tl--byline-boosted))
-             (timestamp-start (string-match "2999-99-99" formatted-string))
-             (properties (text-properties-at timestamp-start formatted-string)))
-        (should (equal '(22782 21551) (plist-get properties 'timestamp)))
-        (should (string-equal "7 minutes ago" (plist-get properties 'display)))))))
+     (mock (date-to-time timestamp) => '(22782 21551))
+     (mock (current-time) => '(22782 22000))
+     (mock (format-time-string mastodon-toot-timestamp-format '(22782 21551)) => "2999-99-99 00:11:22")
+
+     (let* ((formatted-string (mastodon-tl--byline mastodon-tl-test-base-toot
+                                                   'mastodon-tl--byline-author
+                                                   'mastodon-tl--byline-boosted))
+            (timestamp-start (string-match "2999-99-99" formatted-string))
+            (properties (text-properties-at timestamp-start formatted-string)))
+       (should (equal '(22782 21551) (plist-get properties 'timestamp)))
+       (should (string-equal "7 minutes ago" (plist-get properties 'display)))))))
 
 (ert-deftest mastodon-tl--consider-timestamp-for-updates-no-active-callback ()
   "Should update the timestamp update variables as expected."
@@ -454,33 +454,33 @@ a string or a numeric."
 
       ;; something a later update doesn't update:
       (with-mock
-        (mock (mastodon-tl--relative-time-details 'fake-timestamp) =>
-              (cons "xxx ago" (time-add long-in-the-future (seconds-to-time 100))))
+       (mock (mastodon-tl--relative-time-details 'fake-timestamp) =>
+             (cons "xxx ago" (time-add long-in-the-future (seconds-to-time 100))))
 
-        (mastodon-tl--consider-timestamp-for-updates 'fake-timestamp)
+       (mastodon-tl--consider-timestamp-for-updates 'fake-timestamp)
 
-        (should (null mastodon-tl--timestamp-update-timer))
-        (should (eq mastodon-tl--timestamp-next-update long-in-the-future)))
+       (should (null mastodon-tl--timestamp-update-timer))
+       (should (eq mastodon-tl--timestamp-next-update long-in-the-future)))
 
       ;; something only shortly sooner doesn't update:
       (with-mock
-        (mock (mastodon-tl--relative-time-details 'fake-timestamp) =>
-              (cons "xxx ago" (time-subtract long-in-the-future (seconds-to-time 9))))
+       (mock (mastodon-tl--relative-time-details 'fake-timestamp) =>
+             (cons "xxx ago" (time-subtract long-in-the-future (seconds-to-time 9))))
 
-        (mastodon-tl--consider-timestamp-for-updates 'fake-timestamp)
+       (mastodon-tl--consider-timestamp-for-updates 'fake-timestamp)
 
-        (should (null mastodon-tl--timestamp-update-timer))
-        (should (eq mastodon-tl--timestamp-next-update long-in-the-future)))
+       (should (null mastodon-tl--timestamp-update-timer))
+       (should (eq mastodon-tl--timestamp-next-update long-in-the-future)))
 
       ;; something much sooner, does update
       (with-mock
-        (mock (mastodon-tl--relative-time-details 'fake-timestamp) =>
-              (cons "xxx ago"  soon-in-the-future))
+       (mock (mastodon-tl--relative-time-details 'fake-timestamp) =>
+             (cons "xxx ago"  soon-in-the-future))
 
-        (mastodon-tl--consider-timestamp-for-updates 'fake-timestamp)
+       (mastodon-tl--consider-timestamp-for-updates 'fake-timestamp)
 
-        (should (null mastodon-tl--timestamp-update-timer))
-        (should (eq mastodon-tl--timestamp-next-update soon-in-the-future)))
+       (should (null mastodon-tl--timestamp-update-timer))
+       (should (eq mastodon-tl--timestamp-next-update soon-in-the-future)))
       )))
 
 (ert-deftest mastodon-tl--consider-timestamp-for-updates-with-active-callback ()
@@ -496,27 +496,27 @@ a string or a numeric."
 
       ;; something a later update doesn't update:
       (with-mock
-        (mock (mastodon-tl--relative-time-details 'fake-timestamp) =>
-              (cons "xxx ago" (time-add long-in-the-future (seconds-to-time 100))))
+       (mock (mastodon-tl--relative-time-details 'fake-timestamp) =>
+             (cons "xxx ago" (time-add long-in-the-future (seconds-to-time 100))))
 
-        (mastodon-tl--consider-timestamp-for-updates 'fake-timestamp)
+       (mastodon-tl--consider-timestamp-for-updates 'fake-timestamp)
 
-        (should (eq 'initial-timer mastodon-tl--timestamp-update-timer))
-        (should (eq mastodon-tl--timestamp-next-update long-in-the-future)))
+       (should (eq 'initial-timer mastodon-tl--timestamp-update-timer))
+       (should (eq mastodon-tl--timestamp-next-update long-in-the-future)))
 
       ;; something much sooner, does update
       (with-mock
-        (mock (mastodon-tl--relative-time-details 'fake-timestamp) =>
-              (cons "xxx ago"  soon-in-the-future))
-        (mock (cancel-timer 'initial-timer))
-        (mock (run-at-time soon-in-the-future nil
-                           #'mastodon-tl--update-timestamps-callback
-                           (current-buffer) nil) => 'new-timer)
+       (mock (mastodon-tl--relative-time-details 'fake-timestamp) =>
+             (cons "xxx ago"  soon-in-the-future))
+       (mock (cancel-timer 'initial-timer))
+       (mock (run-at-time soon-in-the-future nil
+                          #'mastodon-tl--update-timestamps-callback
+                          (current-buffer) nil) => 'new-timer)
 
-        (mastodon-tl--consider-timestamp-for-updates 'fake-timestamp)
+       (mastodon-tl--consider-timestamp-for-updates 'fake-timestamp)
 
-        (should (eq 'new-timer mastodon-tl--timestamp-update-timer))
-        (should (eq mastodon-tl--timestamp-next-update soon-in-the-future)))
+       (should (eq 'new-timer mastodon-tl--timestamp-update-timer))
+       (should (eq mastodon-tl--timestamp-next-update soon-in-the-future)))
       )))
 
 (ert-deftest mastodon-tl--find-property-range--no-tag ()
@@ -769,45 +769,45 @@ constant."
   (let ((now (current-time))
         markers)
     (cl-labels ((insert-timestamp (n)
-                                  (insert (format "\nSome text before timestamp %s:" n))
-                                  (insert (propertize
-                                           (format "timestamp #%s" n)
-                                           'timestamp (time-subtract now (seconds-to-time (* 60 n)))
-                                           'display (format "unset %s" n)))
-                                  (push (copy-marker (point)) markers)
-                                  (insert " some more text.")))
+                  (insert (format "\nSome text before timestamp %s:" n))
+                  (insert (propertize
+                           (format "timestamp #%s" n)
+                           'timestamp (time-subtract now (seconds-to-time (* 60 n)))
+                           'display (format "unset %s" n)))
+                  (push (copy-marker (point)) markers)
+                  (insert " some more text.")))
       (with-temp-buffer
         (cl-dotimes (n 12) (insert-timestamp (+ n 2)))
         (setq markers (nreverse markers))
 
         (with-mock
-          (mock (current-time) => now)
-          (stub run-at-time => 'fake-timer)
-
-          ;; make the initial call
-          (mastodon-tl--update-timestamps-callback (current-buffer) nil)
-          (should (equal '("2 minutes ago" "3 minutes ago" "4 minutes ago" "5 minutes ago" "6 minutes ago"
-                           "unset 7" "unset 8" "unset 9" "unset 10" "unset 11" "unset 12" "unset 13")
-                         (tl-tests--property-values-at 'display
-                                                       (tl-tests--all-regions-with-property 'timestamp))))
-
-          ;; fake the follow-up call
-          (mastodon-tl--update-timestamps-callback (current-buffer) (nth 4 markers))
-          (should (equal '("2 minutes ago" "3 minutes ago" "4 minutes ago" "5 minutes ago" "6 minutes ago"
-                           "7 minutes ago" "8 minutes ago" "9 minutes ago" "10 minutes ago" "11 minutes ago"
-                           "unset 12" "unset 13")
-                         (tl-tests--property-values-at 'display
-                                                       (tl-tests--all-regions-with-property 'timestamp))))
-          (should (null (marker-position (nth 4 markers))))
-
-          ;; fake the follow-up call
-          (mastodon-tl--update-timestamps-callback (current-buffer) (nth 9 markers))
-          (should (equal '("2 minutes ago" "3 minutes ago" "4 minutes ago" "5 minutes ago" "6 minutes ago"
-                           "7 minutes ago" "8 minutes ago" "9 minutes ago" "10 minutes ago" "11 minutes ago"
-                           "12 minutes ago" "13 minutes ago")
-                         (tl-tests--property-values-at 'display
-                                                       (tl-tests--all-regions-with-property 'timestamp))))
-          (should (null (marker-position (nth 9 markers)))))))))
+         (mock (current-time) => now)
+         (stub run-at-time => 'fake-timer)
+
+         ;; make the initial call
+         (mastodon-tl--update-timestamps-callback (current-buffer) nil)
+         (should (equal '("2 minutes ago" "3 minutes ago" "4 minutes ago" "5 minutes ago" "6 minutes ago"
+                          "unset 7" "unset 8" "unset 9" "unset 10" "unset 11" "unset 12" "unset 13")
+                        (tl-tests--property-values-at 'display
+                                                      (tl-tests--all-regions-with-property 'timestamp))))
+
+         ;; fake the follow-up call
+         (mastodon-tl--update-timestamps-callback (current-buffer) (nth 4 markers))
+         (should (equal '("2 minutes ago" "3 minutes ago" "4 minutes ago" "5 minutes ago" "6 minutes ago"
+                          "7 minutes ago" "8 minutes ago" "9 minutes ago" "10 minutes ago" "11 minutes ago"
+                          "unset 12" "unset 13")
+                        (tl-tests--property-values-at 'display
+                                                      (tl-tests--all-regions-with-property 'timestamp))))
+         (should (null (marker-position (nth 4 markers))))
+
+         ;; fake the follow-up call
+         (mastodon-tl--update-timestamps-callback (current-buffer) (nth 9 markers))
+         (should (equal '("2 minutes ago" "3 minutes ago" "4 minutes ago" "5 minutes ago" "6 minutes ago"
+                          "7 minutes ago" "8 minutes ago" "9 minutes ago" "10 minutes ago" "11 minutes ago"
+                          "12 minutes ago" "13 minutes ago")
+                        (tl-tests--property-values-at 'display
+                                                      (tl-tests--all-regions-with-property 'timestamp))))
+         (should (null (marker-position (nth 9 markers)))))))))
 
 (ert-deftest mastodon-tl--has-spoiler ()
   "Should be able to detect toots with spoiler text as expected"
@@ -925,13 +925,13 @@ constant."
 
 (ert-deftest mastodon-tl--extract-hashtag-from-url-wrong-instance ()
   (should (null (mastodon-tl--extract-hashtag-from-url
-		  "https://example.org/tags/foo"
-		  "https://other.example.org"))))
+		 "https://example.org/tags/foo"
+		 "https://other.example.org"))))
 
 (ert-deftest mastodon-tl--extract-hashtag-from-url-not-tag ()
   (should (null (mastodon-tl--extract-hashtag-from-url
-		  "https://example.org/@userid"
-		  "https://example.org"))))
+		 "https://example.org/@userid"
+		 "https://example.org"))))
 
 (ert-deftest mastodon-tl--userhandles ()
   "Should recognise iserhandles in a toot and add the required properties to it."