Fix test coverage

core/download.ts

@@ -73,6 +73,7 @@ export function createTextResponse(
           warning('Parse JSON error', e.message)
           return null
         } else {
+          /* c8 ignore next 2 */
           throw e
         }
       }

core/environment.ts

@@ -72,16 +72,20 @@ let currentEnvironment: Environment | undefined
 let listeners: EnvironmentListener[] = []
 let unbinds: ((() => void) | void)[] = []
 
-export function onEnvironment(ch: EnvironmentListener): void {
+function runEnvListener(listener: EnvironmentListener): void {
+  let unbind = listener(currentEnvironment!)
+  if (Array.isArray(unbind)) {
+    unbinds.push(...unbind)
+  } else {
+    unbinds.push(unbind)
+  }
+}
+
+export function onEnvironment(cb: EnvironmentListener): void {
   if (currentEnvironment) {
-    let unbind = ch(currentEnvironment)
-    if (Array.isArray(unbind)) {
-      unbinds.push(...unbind)
-    } else {
-      unbinds.push(unbind)
-    }
+    runEnvListener(cb)
   }
-  listeners.push(ch)
+  listeners.push(cb)
 }
 
 export function setupEnvironment<Router extends BaseRouter>(
@@ -104,12 +108,7 @@ export function setupEnvironment<Router extends BaseRouter>(
   }
 
   for (let listener of listeners) {
-    let unbind = listener(currentEnvironment)
-    if (Array.isArray(unbind)) {
-      unbinds.push(...unbind)
-    } else {
-      unbinds.push(unbind)
-    }
+    runEnvListener(listener)
   }
 }
 

core/feed.ts

@@ -55,6 +55,7 @@ onMount($hasFeeds, () => {
     }
   })
 
+  /* c8 ignore next 4 */
   return () => {
     unbindClient()
     unbindFeeds?.()

core/router.ts

@@ -5,7 +5,7 @@ import { fastCategories } from './fast.js'
 import { hasFeeds } from './feed.js'
 import { computeFrom, readonlyExport } from './lib/stores.js'
 import { userId } from './settings.js'
-import { slowFeeds } from './slow.js'
+import { slowCategories } from './slow.js'
 
 export interface Routes {
   about: {}
@@ -76,8 +76,17 @@ function redirect(route: ParamlessRouteName | Route): Route {
   return { ...open(route), redirect: true }
 }
 
-function isNumber(value: number | string): boolean {
-  return typeof value === 'number' || /^\d+$/.test(value)
+function validateNumber(
+  value: number | string,
+  cb: (fixed: number) => Route
+): Route {
+  if (typeof value === 'number') {
+    return cb(value)
+  } else if (/^\d+$/.test(value)) {
+    return cb(parseInt(value))
+  } else {
+    return open('notFound')
+  }
 }
 
 let $router = atom<Route>({ params: {}, route: 'home' })
@@ -87,99 +96,88 @@ export const router = readonlyExport($router)
 onEnvironment(({ baseRouter }) => {
   return computeFrom(
     $router,
-    [baseRouter, userId, hasFeeds, fastCategories, slowFeeds],
-    (page, user, withFeeds, fast, slow) => {
-      if (!page) {
+    [baseRouter, userId, hasFeeds, fastCategories, slowCategories],
+    (route, user, withFeeds, fast, slowUnread) => {
+      if (!route) {
         return open('notFound')
       } else if (user) {
-        if (GUEST.has(page.route) || page.route === 'home') {
+        if (GUEST.has(route.route) || route.route === 'home') {
           if (withFeeds) {
             return redirect({ params: {}, route: 'slow' })
           } else {
             return redirect('welcome')
           }
-        } else if (page.route === 'welcome' && withFeeds) {
+        } else if (route.route === 'welcome' && withFeeds) {
           return redirect('slow')
-        } else if (page.route === 'settings') {
+        } else if (route.route === 'settings') {
           return redirect('interface')
-        } else if (page.route === 'feeds') {
-          return redirect('categories')
-        } else if (page.route === 'fast') {
-          if (!page.params.category && !fast.isLoading) {
+        } else if (route.route === 'feeds') {
+          return redirect('add')
+        } else if (route.route === 'fast') {
+          if (!route.params.category && !fast.isLoading) {
             return redirect({
               params: { category: fast.categories[0].id },
               route: 'fast'
             })
           }
-          if (page.params.category && !fast.isLoading) {
+          if (route.params.category && !fast.isLoading) {
             let category = fast.categories.find(
-              i => i.id === page.params.category
+              i => i.id === route.params.category
             )
             if (!category) {
               return open('notFound')
             }
           }
-          if (page.params.since) {
-            if (isNumber(page.params.since)) {
-              let since =
-                typeof page.params.since === 'number'
-                  ? page.params.since
-                  : parseInt(page.params.since)
-              return open({
+          if (route.params.since) {
+            return validateNumber(route.params.since, since => {
+              return {
+                ...route,
                 params: {
-                  ...page.params,
+                  ...route.params,
                   since
-                },
-                route: 'fast'
-              })
-            } else {
-              return open('notFound')
-            }
-          }
-        } else if (page.route === 'slow') {
-          if (!page.params.feed && !slow.isLoading) {
-            return redirect({
-              params: { feed: slow.feeds[0]?.id || '', page: 1 },
-              route: 'slow'
+                }
+              }
             })
           }
-          if (page.params.feed && !slow.isLoading) {
-            let feed = slow.feeds.find(f => f.id === page.params.feed)
-            if (!feed) {
-              return open('notFound')
+        } else if (route.route === 'slow') {
+          if (!route.params.feed && !slowUnread.isLoading) {
+            let firstCategory = slowUnread.tree[0]
+            if (firstCategory) {
+              let feeds = firstCategory[1]
+              let feedData = feeds[0]
+              if (feedData) {
+                return redirect({
+                  params: { feed: feedData[0].id || '' },
+                  route: 'slow'
+                })
+              }
             }
           }
 
-          if (page.params.page) {
-            if (isNumber(page.params.page)) {
-              let currentPage =
-                typeof page.params.page === 'number'
-                  ? page.params.page
-                  : parseInt(page.params.page)
-              return open({
+          if (route.params.page) {
+            return validateNumber(route.params.page, page => {
+              return {
+                ...route,
                 params: {
-                  ...page.params,
-                  page: currentPage
-                },
-                route: 'slow'
-              })
-            } else {
-              return open('notFound')
-            }
+                  ...route.params,
+                  page
+                }
+              }
+            })
           } else {
             return open({
               params: {
-                ...page.params,
+                ...route.params,
                 page: 1
               },
               route: 'slow'
             })
           }
         }
-      } else if (!GUEST.has(page.route)) {
+      } else if (!GUEST.has(route.route)) {
         return open('start')
       }
-      return page
+      return route
     },
     (oldRoute, newRoute) => {
       return (

core/slow.ts

@@ -9,9 +9,9 @@ import {
 } from './category.js'
 import { client } from './client.js'
 import { onEnvironment } from './environment.js'
-import { BROKEN_FEED, type FeedValue, loadFeed, loadFeeds } from './feed.js'
+import { BROKEN_FEED, type FeedValue, loadFeed } from './feed.js'
 import { listenMany, readonlyExport } from './lib/stores.js'
-import { getPost, getPosts, loadPosts, type PostValue } from './post.js'
+import { getPost, loadPosts, type PostValue } from './post.js'
 import { type Route, router } from './router.js'
 
 export type SlowCategoriesTree = [CategoryValue, [FeedValue, number][]][]
@@ -120,20 +120,8 @@ let $posts = atom<SlowPostsValue>({ isLoading: true })
 
 export const slowPosts = readonlyExport($posts)
 
-export type SlowFeedsValue =
-  | { feeds: FeedValue[]; isLoading: false }
-  | { isLoading: true }
-
-let $slowFeeds = atom<SlowFeedsValue>({ isLoading: true })
-
-export const slowFeeds = readonlyExport($slowFeeds)
-
 let POSTS_PER_PAGE = 100
 
-export function setSlowPostsPerPage(value: number): void {
-  POSTS_PER_PAGE = value
-}
-
 let $totalPosts = atom<number>(0)
 
 export const totalSlowPosts = readonlyExport($totalPosts)
@@ -175,16 +163,12 @@ let postUnbind: (() => void) | undefined
 async function load(feedId: string, page: number = 1): Promise<void> {
   $page.set(page)
 
-  let [feedPosts, feeds] = await Promise.all([
-    loadPosts({ feedId, reading: 'slow' }),
-    loadFeeds({ reading: 'slow' })
-  ])
+  let feedPosts = await loadPosts({ feedId, reading: 'slow' })
   let sorted = feedPosts.sort((a, b) => b.publishedAt - a.publishedAt)
   let fromIndex = (page - 1) * POSTS_PER_PAGE
   let posts = sorted.slice(fromIndex, fromIndex + POSTS_PER_PAGE)
 
   $posts.set({ isLoading: false, list: posts })
-  $slowFeeds.set({ feeds, isLoading: false })
   $totalPosts.set(feedPosts.length)
   $totalPages.set(Math.ceil(feedPosts.length / POSTS_PER_PAGE))
 }
@@ -214,30 +198,14 @@ onEnvironment(({ openRoute }) => {
       }
     }),
     router.listen(page => {
-      if (notSynced(page) && page.params.feed) {
-        loadSlowPosts(page.params.feed, page.params.page)
-      }
       if (page.route === 'slow') {
         if (page.params.feed) {
-          if ($currentFeed.get() !== page.params.feed) {
-            postsUnbind?.()
-            postsUnbind = getPosts({ feedId: page.params.feed }).subscribe(
-              posts => {
-                if (posts.isLoading) {
-                  $posts.set({ isLoading: true })
-                } else {
-                  $posts.set({ isLoading: false, list: posts.list })
-                }
-              }
-            )
+          if (notSynced(page)) {
+            loadSlowPosts(page.params.feed, page.params.page)
           }
         } else {
-          postsUnbind?.()
-          postsUnbind = undefined
-          $posts.set({
-            isLoading: false,
-            list: []
-          })
+          $currentFeed.set(undefined)
+          $posts.set({ isLoading: false, list: [] })
         }
         if (page.params.post) {
           if ($post.get()?.id !== page.params.post) {

core/test/download.test.ts

@@ -220,6 +220,14 @@ test('detects content type', async () => {
     }).contentType,
     'application/custom'
   )
+  equal(
+    createTextResponse('custom', {
+      headers: new Headers({
+        'content-type': 'text/plain; charset=utf-8'
+      })
+    }).contentType,
+    'text/plain'
+  )
   equal(
     createTextResponse('<html></html>', {
       headers: new Headers({ 'content-type': 'text/html' })

core/test/environment.test.ts

@@ -17,29 +17,39 @@ test('throws on current environment if it is not set', () => {
 
 test('runs callback when environment will be set', () => {
   let calls: string[] = []
-  let cleans = 0
+  let cleans = ''
   onEnvironment(env => {
     calls.push(env.locale.get())
     return () => {
-      cleans += 1
+      cleans += '1'
     }
   })
+  onEnvironment(() => {
+    return [
+      () => {
+        cleans += '2'
+      },
+      () => {
+        cleans += '3'
+      }
+    ]
+  })
   deepStrictEqual(calls, [])
 
   setupEnvironment({ ...getTestEnvironment(), locale: atom('fr') })
   deepStrictEqual(calls, ['fr'])
-  equal(cleans, 0)
+  equal(cleans, '')
 
   setupEnvironment({ ...getTestEnvironment(), locale: atom('ru') })
   deepStrictEqual(calls, ['fr', 'ru'])
-  equal(cleans, 1)
+  equal(cleans, '123')
 
   let after: string[] = []
   onEnvironment(env => {
     after.push(env.locale.get())
   })
   deepStrictEqual(after, ['ru'])
-  equal(cleans, 1)
+  equal(cleans, '123')
 })
 
 test('returns current environment', () => {

core/test/fast.test.ts

@@ -477,8 +477,6 @@ test('tracks current post', async () => {
     route: 'fast'
   })
   equal(openedFastPost.get()?.id, post3)
-  equal(openedFastPost.get()?.isLoading, true)
-  await setTimeout(10)
   equal(openedFastPost.get()?.isLoading, false)
   equal((openedFastPost.get() as PostValue).title, '3')
 })