                 }
             }) { (groupResult) in
                 DispatchQueue.main.async {
-                    self.isUpdating = false
                     switch groupResult {
                     case .success(let itemKeys):
                         print("🥶group completion: \(articleKey), itemKeyCount: \(itemKeys.count)")
+                        self.didFetchArticle(with: articleKey)
                         self.spotlightManager.addToIndex(url: articleURL as NSURL)
                         self.updateFetchesInProcessCount()
-                        updateAgain()
                     case .failure(let error):
                         print("🥶failure in groupCompletion of \(articleKey): \(error)")
                         self.updateFetchesInProcessCount()
-                        updateAgain()
+                        self.didFailToFetchArticle(with: articleKey, error: error)
                     }
+                    updateAgain()
                 }
             }
         } else {

        }
        
        let updateAgain = {
            DispatchQueue.main.asyncAfter(deadline: .now() + (0.1 * Double(NSEC_PER_SEC))) {
                self.isUpdating = false
                self.update()
            }

                articleCacheController.remove(groupKey: articleKey, itemCompletion: { (itemResult) in
                    switch itemResult {
                    case .success(let itemKey):
                        print("🙈successfully removed \(itemKey)")
                    case .failure(let error):
                        print("🙈failure in itemCompletion of \(articleKey): \(error)")
                    }
                }) { (groupResult) in
                    DispatchQueue.main.async {
                        switch groupResult {
                        case .success:
                            print("🙈success in groupCompletion of \(articleKey)")
                            self.didRemoveArticle(with: articleKey)
                            self.updateFetchesInProcessCount()
                        case .failure:
                            print("🙈failure in groupCompletion of \(articleKey)")
                            break
                        }
                        updateAgain()
                    }
                }
            } else {
                noArticleToDeleteCompletion()
            }
        }
    }
    
    func didFetchArticle(with key: String) {
        operateOnArticles(with: key) { (article) in
            article.isDownloaded = true
        }
    }
    
    func didFailToFetchArticle(with key: String, error: Error) {
        operateOnArticles(with: key) { (article) in
            article.updatePropertiesForError(error as NSError)
            article.isDownloaded = false
        }
    }

    func didRemoveArticle(with key: String) {
        operateOnArticles(with: key) { (article) in
            article.isDownloaded = false
        }
    }
    
    func operateOnArticles(with key: String, articleBlock: (WMFArticle) -> Void) {
        do {
            let articles = try dataStore.viewContext.fetchArticles(withKey: key)
            for article in articles {
                articleBlock(article)
            }
        } catch (let error) {
            DDLogError("Error fetching WMFArticles after caching: \(error)");
        }
