Merge pull request 'Merge h_d's cleanups' (#8) from h_d/mastodon.el:cleanups into develop

Reviewed-on: https://git.blast.noho.st/mouse/mastodon.el/pulls/8

7 files changed, 390 insertions, 390 deletions

diff --git a/test/mastodon-auth-tests.el b/test/mastodon-auth-tests.el
index 7daa4db..69c34a4 100644
--- a/test/mastodon-auth-tests.el
+++ b/test/mastodon-auth-tests.el
@@ -45,10 +45,10 @@
   "Should generate token and return JSON response."
   (with-temp-buffer
     (with-mock
-      (mock (mastodon-auth--generate-token) => (progn
-                                                  (insert "\n\n{\"access_token\":\"abcdefg\"}")
-                                                  (current-buffer)))
-      (should (equal (mastodon-auth--get-token) '(:access_token "abcdefg"))))))
+     (mock (mastodon-auth--generate-token) => (progn
+                                                (insert "\n\n{\"access_token\":\"abcdefg\"}")
+                                                (current-buffer)))
+     (should (equal (mastodon-auth--get-token) '(:access_token "abcdefg"))))))
 
 (ert-deftest access-token-found ()
   "Should return value in `mastodon-auth--token-alist' if found."
@@ -61,6 +61,6 @@
   (let ((mastodon-instance-url "https://instance.url")
         (mastodon-auth--token nil))
     (with-mock
-      (mock (mastodon-auth--get-token) => '(:access_token "foobaz"))
-      (should (string= (mastodon-auth--access-token) "foobaz"))
-      (should (equal mastodon-auth--token-alist '(("https://instance.url" . "foobaz")))))))
+     (mock (mastodon-auth--get-token) => '(:access_token "foobaz"))
+     (should (string= (mastodon-auth--access-token) "foobaz"))
+     (should (equal mastodon-auth--token-alist '(("https://instance.url" . "foobaz")))))))
diff --git a/test/mastodon-client-tests.el b/test/mastodon-client-tests.el
index dfe175b..d7f750d 100644
--- a/test/mastodon-client-tests.el
+++ b/test/mastodon-client-tests.el
@@ -17,30 +17,30 @@
   "Should return client registration JSON."
   (with-temp-buffer
     (with-mock
-      (mock (mastodon-client--register) => (progn
-                                                   (insert "\n\n{\"foo\":\"bar\"}")
-                                                   (current-buffer)))
-      (should (equal (mastodon-client--fetch) '(:foo "bar"))))))
+     (mock (mastodon-client--register) => (progn
+                                            (insert "\n\n{\"foo\":\"bar\"}")
+                                            (current-buffer)))
+     (should (equal (mastodon-client--fetch) '(:foo "bar"))))))
 
 (ert-deftest store-1 ()
   "Should return the client plist."
   (let ((mastodon-instance-url "http://mastodon.example")
         (plist '(:client_id "id" :client_secret "secret")))
     (with-mock
-      (mock (mastodon-client--token-file) => "stubfile.plstore")
-      (mock (mastodon-client--fetch) => '(:client_id "id" :client_secret "secret"))
-      (let* ((plstore (plstore-open "stubfile.plstore"))
-             (client (cdr (plstore-get plstore "mastodon-http://mastodon.example"))))
-        (should (equal (mastodon-client--store) plist))))))
+     (mock (mastodon-client--token-file) => "stubfile.plstore")
+     (mock (mastodon-client--fetch) => '(:client_id "id" :client_secret "secret"))
+     (let* ((plstore (plstore-open "stubfile.plstore"))
+            (client (cdr (plstore-get plstore "mastodon-http://mastodon.example"))))
+       (should (equal (mastodon-client--store) plist))))))
 
 (ert-deftest store-2 ()
-   "Should store client in `mastodon-client--token-file'."
-   (let* ((mastodon-instance-url "http://mastodon.example")
-          (plstore (plstore-open "stubfile.plstore"))
-          (client (cdr (plstore-get plstore "mastodon-http://mastodon.example"))))
-     (plstore-close plstore)
-     (should (string= (plist-get client :client_id) "id"))
-     (should (string= (plist-get client :client_secret) "secret"))))
+  "Should store client in `mastodon-client--token-file'."
+  (let* ((mastodon-instance-url "http://mastodon.example")
+         (plstore (plstore-open "stubfile.plstore"))
+         (client (cdr (plstore-get plstore "mastodon-http://mastodon.example"))))
+    (plstore-close plstore)
+    (should (string= (plist-get client :client_id) "id"))
+    (should (string= (plist-get client :client_secret) "secret"))))
 
 (ert-deftest read-finds-match ()
   "Should return mastodon client from `mastodon-token-file' if it exists."
@@ -60,8 +60,8 @@
 (ert-deftest read-empty-store ()
   "Should return nil if mastodon client is not present in the plstore."
   (with-mock
-    (mock (mastodon-client--token-file) => "fixture/empty.plstore")
-    (should (equal (mastodon-client--read) nil))))
+   (mock (mastodon-client--token-file) => "fixture/empty.plstore")
+   (should (equal (mastodon-client--read) nil))))
 
 (ert-deftest client-set-and-matching ()
   "Should return `mastondon-client' if `mastodon-client--client-details-alist' is non-nil and instance url is included."
@@ -75,29 +75,29 @@
   (let ((mastodon-instance-url "http://mastodon.example")
         (mastodon-client--client-details-alist '(("http://other.example" :wrong))))
     (with-mock
-      (mock (mastodon-client--read) => '(:client_id "foo" :client_secret "bar"))
-      (should (equal (mastodon-client) '(:client_id "foo" :client_secret "bar")))
-      (should (equal mastodon-client--client-details-alist
-                     '(("http://mastodon.example" :client_id "foo" :client_secret "bar")
-                       ("http://other.example" :wrong)))))))
+     (mock (mastodon-client--read) => '(:client_id "foo" :client_secret "bar"))
+     (should (equal (mastodon-client) '(:client_id "foo" :client_secret "bar")))
+     (should (equal mastodon-client--client-details-alist
+                    '(("http://mastodon.example" :client_id "foo" :client_secret "bar")
+                      ("http://other.example" :wrong)))))))
 
 (ert-deftest client-unset ()
   "Should read from `mastodon-token-file' if available."
   (let ((mastodon-instance-url "http://mastodon.example")
         (mastodon-client--client-details-alist nil))
     (with-mock
-      (mock (mastodon-client--read) => '(:client_id "foo" :client_secret "bar"))
-      (should (equal (mastodon-client) '(:client_id "foo" :client_secret "bar")))
-      (should (equal mastodon-client--client-details-alist
-                     '(("http://mastodon.example" :client_id "foo" :client_secret "bar")))))))
+     (mock (mastodon-client--read) => '(:client_id "foo" :client_secret "bar"))
+     (should (equal (mastodon-client) '(:client_id "foo" :client_secret "bar")))
+     (should (equal mastodon-client--client-details-alist
+                    '(("http://mastodon.example" :client_id "foo" :client_secret "bar")))))))
 
 (ert-deftest client-unset-and-not-in-storage ()
   "Should store client data in plstore if it can't be read."
   (let ((mastodon-instance-url "http://mastodon.example")
         (mastodon-client--client-details-alist nil))
     (with-mock
-      (mock (mastodon-client--read))
-      (mock (mastodon-client--store) => '(:client_id "foo" :client_secret "baz"))
-      (should (equal (mastodon-client) '(:client_id "foo" :client_secret "baz")))
-      (should (equal mastodon-client--client-details-alist
-                     '(("http://mastodon.example" :client_id "foo" :client_secret "baz")))))))
+     (mock (mastodon-client--read))
+     (mock (mastodon-client--store) => '(:client_id "foo" :client_secret "baz"))
+     (should (equal (mastodon-client) '(:client_id "foo" :client_secret "baz")))
+     (should (equal mastodon-client--client-details-alist
+                    '(("http://mastodon.example" :client_id "foo" :client_secret "baz")))))))
diff --git a/test/mastodon-http-tests.el b/test/mastodon-http-tests.el
index d0f715e..03d4f94 100644
--- a/test/mastodon-http-tests.el
+++ b/test/mastodon-http-tests.el
@@ -4,6 +4,6 @@
   "Should make a `url-retrieve' of the given URL."
   (let ((callback-double (lambda () "double")))
     (with-mock
-      (mock (mastodon-http--url-retrieve-synchronously "https://foo.bar/baz"))
-      (mock (mastodon-auth--access-token) => "test-token")
-      (mastodon-http--get "https://foo.bar/baz"))))
+     (mock (mastodon-http--url-retrieve-synchronously "https://foo.bar/baz"))
+     (mock (mastodon-auth--access-token) => "test-token")
+     (mastodon-http--get "https://foo.bar/baz"))))
diff --git a/test/mastodon-media-tests.el b/test/mastodon-media-tests.el
index 20993f9..b537dfe 100644
--- a/test/mastodon-media-tests.el
+++ b/test/mastodon-media-tests.el
@@ -3,143 +3,143 @@
 (ert-deftest mastodon-media:get-avatar-rendering ()
   "Should return text with all expected properties."
   (with-mock
-    (mock (image-type-available-p 'imagemagick) => t)
-    (mock (create-image * (when (version< emacs-version "27.1") 'imagemagick) t :height 123) => :mock-image)
-
-    (let* ((mastodon-media--avatar-height 123)
-           (result (mastodon-media--get-avatar-rendering "http://example.org/img.png"))
-           (result-no-properties (substring-no-properties result))
-           (properties (text-properties-at 0 result)))
-      (should (string= "  " result-no-properties))
-      (should (string= "http://example.org/img.png" (plist-get properties 'media-url)))
-      (should (eq 'needs-loading (plist-get properties 'media-state)))
-      (should (eq 'avatar (plist-get properties 'media-type)))
-      (should (eq :mock-image (plist-get properties 'display))))))
+   (mock (image-type-available-p 'imagemagick) => t)
+   (mock (create-image * (when (version< emacs-version "27.1") 'imagemagick) t :height 123) => :mock-image)
+
+   (let* ((mastodon-media--avatar-height 123)
+          (result (mastodon-media--get-avatar-rendering "http://example.org/img.png"))
+          (result-no-properties (substring-no-properties result))
+          (properties (text-properties-at 0 result)))
+     (should (string= "  " result-no-properties))
+     (should (string= "http://example.org/img.png" (plist-get properties 'media-url)))
+     (should (eq 'needs-loading (plist-get properties 'media-state)))
+     (should (eq 'avatar (plist-get properties 'media-type)))
+     (should (eq :mock-image (plist-get properties 'display))))))
 
 (ert-deftest mastodon-media:get-media-link-rendering ()
   "Should return text with all expected properties."
   (with-mock
-    (mock (create-image * nil t) => :mock-image)
-
-    (let* ((mastodon-media--preview-max-height 123)
-           (result (mastodon-media--get-media-link-rendering "http://example.org/img.png"))
-           (result-no-properties (substring-no-properties result))
-           (properties (text-properties-at 0 result)))
-      (should (string= "[img] " result-no-properties))
-      (should (string= "http://example.org/img.png" (plist-get properties 'media-url)))
-      (should (eq 'needs-loading (plist-get properties 'media-state)))
-      (should (eq 'media-link (plist-get properties 'media-type)))
-      (should (eq :mock-image (plist-get properties 'display))))))
+   (mock (create-image * nil t) => :mock-image)
+
+   (let* ((mastodon-media--preview-max-height 123)
+          (result (mastodon-media--get-media-link-rendering "http://example.org/img.png"))
+          (result-no-properties (substring-no-properties result))
+          (properties (text-properties-at 0 result)))
+     (should (string= "[img] " result-no-properties))
+     (should (string= "http://example.org/img.png" (plist-get properties 'media-url)))
+     (should (eq 'needs-loading (plist-get properties 'media-state)))
+     (should (eq 'media-link (plist-get properties 'media-type)))
+     (should (eq :mock-image (plist-get properties 'display))))))
 
 (ert-deftest mastodon-media:load-image-from-url:avatar-with-imagemagic ()
   "Should make the right call to url-retrieve."
   (let ((url "http://example.org/image.png")
         (mastodon-media--avatar-height 123))
     (with-mock
-      (mock (image-type-available-p 'imagemagick) => t)
-      (mock (create-image
-             *
-             (when (version< emacs-version "27.1") 'imagemagick)
-             t :height 123) => '(image foo))
-      (mock (copy-marker 7) => :my-marker )
-      (mock (url-retrieve
-             url
-             #'mastodon-media--process-image-response
-             `(:my-marker (:height 123) 1 ,url))
-            => :called-as-expected)
-
-      (with-temp-buffer
-        (insert (concat "Start:"
-                        (mastodon-media--get-avatar-rendering "http://example.org/img.png")
-                        ":rest"))
-
-        (should (eq :called-as-expected (mastodon-media--load-image-from-url url 'avatar 7 1)))))))
+     (mock (image-type-available-p 'imagemagick) => t)
+     (mock (create-image
+            *
+            (when (version< emacs-version "27.1") 'imagemagick)
+            t :height 123) => '(image foo))
+     (mock (copy-marker 7) => :my-marker )
+     (mock (url-retrieve
+            url
+            #'mastodon-media--process-image-response
+            `(:my-marker (:height 123) 1 ,url))
+           => :called-as-expected)
+
+     (with-temp-buffer
+       (insert (concat "Start:"
+                       (mastodon-media--get-avatar-rendering "http://example.org/img.png")
+                       ":rest"))
+
+       (should (eq :called-as-expected (mastodon-media--load-image-from-url url 'avatar 7 1)))))))
 
 (ert-deftest mastodon-media:load-image-from-url:avatar-without-imagemagic ()
   "Should make the right call to url-retrieve."
   (let ((url "http://example.org/image.png"))
     (with-mock
-      (mock (image-type-available-p 'imagemagick) => nil)
-      (mock (create-image * nil t) => '(image foo))
-      (mock (copy-marker 7) => :my-marker )
-      (mock (url-retrieve
-             url
-             #'mastodon-media--process-image-response
-             `(:my-marker () 1 ,url))
-            => :called-as-expected)
-
-      (with-temp-buffer
-        (insert (concat "Start:"
-                        (mastodon-media--get-avatar-rendering "http://example.org/img.png")
-                        ":rest"))
-
-        (should (eq :called-as-expected (mastodon-media--load-image-from-url url 'avatar 7 1)))))))
+     (mock (image-type-available-p 'imagemagick) => nil)
+     (mock (create-image * nil t) => '(image foo))
+     (mock (copy-marker 7) => :my-marker )
+     (mock (url-retrieve
+            url
+            #'mastodon-media--process-image-response
+            `(:my-marker () 1 ,url))
+           => :called-as-expected)
+
+     (with-temp-buffer
+       (insert (concat "Start:"
+                       (mastodon-media--get-avatar-rendering "http://example.org/img.png")
+                       ":rest"))
+
+       (should (eq :called-as-expected (mastodon-media--load-image-from-url url 'avatar 7 1)))))))
 
 (ert-deftest mastodon-media:load-image-from-url:media-link-with-imagemagic ()
   "Should make the right call to url-retrieve."
   (let ((url "http://example.org/image.png"))
     (with-mock
-      (mock (image-type-available-p 'imagemagick) => t)
-      (mock (create-image * nil t) => '(image foo))
-      (mock (copy-marker 7) => :my-marker )
-      (mock (url-retrieve
-             "http://example.org/image.png"
-             #'mastodon-media--process-image-response
-             '(:my-marker (:max-height 321) 5 "http://example.org/image.png"))
-            => :called-as-expected)
-      (with-temp-buffer
-        (insert (concat "Start:"
-                        (mastodon-media--get-media-link-rendering url)
-                        ":rest"))
-        (let ((mastodon-media--preview-max-height 321))
-          (should (eq :called-as-expected (mastodon-media--load-image-from-url url 'media-link 7 5))))))))
+     (mock (image-type-available-p 'imagemagick) => t)
+     (mock (create-image * nil t) => '(image foo))
+     (mock (copy-marker 7) => :my-marker )
+     (mock (url-retrieve
+            "http://example.org/image.png"
+            #'mastodon-media--process-image-response
+            '(:my-marker (:max-height 321) 5 "http://example.org/image.png"))
+           => :called-as-expected)
+     (with-temp-buffer
+       (insert (concat "Start:"
+                       (mastodon-media--get-media-link-rendering url)
+                       ":rest"))
+       (let ((mastodon-media--preview-max-height 321))
+         (should (eq :called-as-expected (mastodon-media--load-image-from-url url 'media-link 7 5))))))))
 
 (ert-deftest mastodon-media:load-image-from-url:media-link-without-imagemagic ()
   "Should make the right call to url-retrieve."
   (let ((url "http://example.org/image.png"))
     (with-mock
-      (mock (image-type-available-p 'imagemagick) => nil)
-      (mock (create-image * nil t) => '(image foo))
-      (mock (copy-marker 7) => :my-marker )
-      (mock (url-retrieve
-             "http://example.org/image.png"
-             #'mastodon-media--process-image-response
-             '(:my-marker () 5 "http://example.org/image.png"))
-            => :called-as-expected)
-
-      (with-temp-buffer
-        (insert (concat "Start:"
-                        (mastodon-media--get-avatar-rendering url)
-                        ":rest"))
-        (let ((mastodon-media--preview-max-height 321))
-          (should (eq :called-as-expected (mastodon-media--load-image-from-url url 'media-link 7 5))))))))
+     (mock (image-type-available-p 'imagemagick) => nil)
+     (mock (create-image * nil t) => '(image foo))
+     (mock (copy-marker 7) => :my-marker )
+     (mock (url-retrieve
+            "http://example.org/image.png"
+            #'mastodon-media--process-image-response
+            '(:my-marker () 5 "http://example.org/image.png"))
+           => :called-as-expected)
+
+     (with-temp-buffer
+       (insert (concat "Start:"
+                       (mastodon-media--get-avatar-rendering url)
+                       ":rest"))
+       (let ((mastodon-media--preview-max-height 321))
+         (should (eq :called-as-expected (mastodon-media--load-image-from-url url 'media-link 7 5))))))))
 
 (ert-deftest mastodon-media:load-image-from-url:url-fetching-fails ()
   "Should cope with failures in url-retrieve."
   (let ((url "http://example.org/image.png")
         (mastodon-media--avatar-height 123))
     (with-mock
-      (mock (image-type-available-p 'imagemagick) => t)
-      (mock (create-image
-             *
-             (when (version< emacs-version "27.1") 'imagemagick)
-             t :height 123) => '(image foo))
-      (stub url-retrieve => (error "url-retrieve failed"))
-
-      (with-temp-buffer
-        (insert (concat "Start:"
-                        (mastodon-media--get-avatar-rendering "http://example.org/img.png")
-                        ":rest"))
-
-        (should (eq :loading-failed (mastodon-media--load-image-from-url url 'avatar 7 1)))
-        ;; the media state was updated so we won't load this again: 
-        (should (eq 'loading-failed (get-text-property 7 'media-state)))))))
+     (mock (image-type-available-p 'imagemagick) => t)
+     (mock (create-image
+            *
+            (when (version< emacs-version "27.1") 'imagemagick)
+            t :height 123) => '(image foo))
+     (stub url-retrieve => (error "url-retrieve failed"))
+
+     (with-temp-buffer
+       (insert (concat "Start:"
+                       (mastodon-media--get-avatar-rendering "http://example.org/img.png")
+                       ":rest"))
+
+       (should (eq :loading-failed (mastodon-media--load-image-from-url url 'avatar 7 1)))
+       ;; the media state was updated so we won't load this again: 
+       (should (eq 'loading-failed (get-text-property 7 'media-state)))))))
 
 (ert-deftest mastodon-media:process-image-response ()
   "Should process the HTTP response and adjust the source buffer."
   (with-temp-buffer
     (with-mock
-      (let ((source-buffer (current-buffer))
+     (let ((source-buffer (current-buffer))
            used-marker
            saved-marker)
        (insert "start:")
@@ -175,35 +175,35 @@
 (ert-deftest mastodon-media:inline-images ()
   "Should process all media in buffer."
   (with-mock
-    ;; Stub needed for the test setup:
-    (stub create-image => '(image ignored))
-
-    (let (marker-media-link marker-media-link-bad-url marker-false-media marker-avatar)
-      (with-temp-buffer
-        (insert "Some text before\n")
-        (setq marker-media-link (copy-marker (point)))
-        (insert (mastodon-media--get-media-link-rendering "http://example.org/i.jpg")
-                " some more text ")
-        (setq marker-media-link-bad-url (copy-marker (point)))
-        (insert (mastodon-media--get-media-link-rendering "/files/small/missing.png")
-                " some more text ")
-        (setq marker-false-media (copy-marker (point)))
-        (insert
-         ;; text that looks almost like an avatar but lacks the media-url property
-         (propertize "this won't be processed"
-                     'media-state 'needs-loading
-                     'media-type 'avatar)
-         "even more text ")
-        (setq marker-avatar (copy-marker (point)))
-        (insert (mastodon-media--get-avatar-rendering "http://example.org/avatar.png")
-                " end of text")
-        (goto-char (point-min))
-
-        ;; stub for the actual test:
-        (stub mastodon-media--load-image-from-url)
-        (mastodon-media--inline-images (point-min) (point-max))
-
-        (should (eq 'loading (get-text-property marker-media-link 'media-state)))
-        (should (eq 'invalid-url (get-text-property marker-media-link-bad-url 'media-state)))
-        (should (eq 'loading (get-text-property marker-avatar 'media-state)))
-        (should (eq 'needs-loading (get-text-property marker-false-media 'media-state)))))))
+   ;; Stub needed for the test setup:
+   (stub create-image => '(image ignored))
+
+   (let (marker-media-link marker-media-link-bad-url marker-false-media marker-avatar)
+     (with-temp-buffer
+       (insert "Some text before\n")
+       (setq marker-media-link (copy-marker (point)))
+       (insert (mastodon-media--get-media-link-rendering "http://example.org/i.jpg")
+               " some more text ")
+       (setq marker-media-link-bad-url (copy-marker (point)))
+       (insert (mastodon-media--get-media-link-rendering "/files/small/missing.png")
+               " some more text ")
+       (setq marker-false-media (copy-marker (point)))
+       (insert
+        ;; text that looks almost like an avatar but lacks the media-url property
+        (propertize "this won't be processed"
+                    'media-state 'needs-loading
+                    'media-type 'avatar)
+        "even more text ")
+       (setq marker-avatar (copy-marker (point)))
+       (insert (mastodon-media--get-avatar-rendering "http://example.org/avatar.png")
+               " end of text")
+       (goto-char (point-min))
+
+       ;; stub for the actual test:
+       (stub mastodon-media--load-image-from-url)
+       (mastodon-media--inline-images (point-min) (point-max))
+
+       (should (eq 'loading (get-text-property marker-media-link 'media-state)))
+       (should (eq 'invalid-url (get-text-property marker-media-link-bad-url 'media-state)))
+       (should (eq 'loading (get-text-property marker-avatar 'media-state)))
+       (should (eq 'needs-loading (get-text-property marker-false-media 'media-state)))))))
diff --git a/test/mastodon-notifications-test.el b/test/mastodon-notifications-test.el
index 778d350..3047ae6 100644
--- a/test/mastodon-notifications-test.el
+++ b/test/mastodon-notifications-test.el
@@ -185,8 +185,8 @@
   "Ensure get request format for notifictions is accurate."
   (let ((mastodon-instance-url "https://instance.url"))
     (with-mock
-      (mock (mastodon-http--get-json "https://instance.url/api/v1/notifications" ))
-      (mastodon-notifications--get))))
+     (mock (mastodon-http--get-json "https://instance.url/api/v1/notifications" ))
+     (mastodon-notifications--get))))
 
 (defun mastodon-notifications--test-type (fun sample)
   "Test notification draw functions.
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."
diff --git a/test/mastodon-toot-tests.el b/test/mastodon-toot-tests.el
index 06da870..abc66d0 100644
--- a/test/mastodon-toot-tests.el
+++ b/test/mastodon-toot-tests.el
@@ -41,6 +41,6 @@
 
 (ert-deftest cancel ()
   (with-mock
-    (mock (kill-buffer-and-window))
-    (mastodon-toot--cancel)
-    (mock-verify)))
+   (mock (kill-buffer-and-window))
+   (mastodon-toot--cancel)
+   (mock-verify)))