@symbiosis-lab/moss-plugin-matters 1.4.2

package/features/download/self-correcting.feature

@@ -0,0 +1,83 @@
+Feature: Self-correcting reference updates
+  As a Matters user
+  I want image references to be automatically updated after download
+  So that my markdown files reference local assets correctly
+
+  Scenario: Updates references when assets already exist
+    Given a mock Tauri environment
+    And an in-memory filesystem
+    And a markdown file with remote image URLs
+    And the assets already exist locally
+    When I run downloadMediaAndUpdate
+    Then no downloads should occur
+    And all image references should be updated to local paths
+
+  Scenario: Downloads and updates in single pass
+    Given a mock Tauri environment
+    And an in-memory filesystem
+    And a markdown file with remote image URLs
+    And no assets exist locally
+    When I run downloadMediaAndUpdate
+    Then all images should be downloaded
+    And all image references should be updated to local paths
+
+  Scenario: Resumes correctly after interruption
+    Given a mock Tauri environment
+    And an in-memory filesystem
+    And a markdown file with multiple remote image URLs
+    And some assets already exist locally
+    When I run downloadMediaAndUpdate
+    Then only missing assets should be downloaded
+    And all image references should be updated to local paths
+
+  Scenario: Handles cross-CDN URLs with same UUID
+    Given a mock Tauri environment
+    And an in-memory filesystem
+    And a markdown file with cover and body images using different CDNs
+    And both URLs contain the same UUID
+    When I run downloadMediaAndUpdate
+    Then only one download should occur
+    And both cover and body references should point to the same local file
+
+  Scenario: Idempotent operation
+    Given a mock Tauri environment
+    And an in-memory filesystem
+    And a markdown file with local image references
+    And all assets exist locally
+    When I run downloadMediaAndUpdate twice
+    Then no downloads should occur
+    And the file should not be modified
+
+  # ============================================================================
+  # Incremental Write Behavior Tests
+  # These tests verify the core design principle: files are written immediately
+  # after processing, not batched at the end. This ensures partial progress is
+  # saved if the process is interrupted.
+  # ============================================================================
+
+  Scenario: Files are written immediately after processing (not batched)
+    Given a mock Tauri environment
+    And an in-memory filesystem
+    And three markdown files each containing a unique remote image
+    And downloads are configured to succeed for all files
+    When I run downloadMediaAndUpdate
+    Then all three files should have updated references
+    And all three files should be written to disk
+
+  Scenario: Early files are saved when later downloads fail
+    Given a mock Tauri environment
+    And an in-memory filesystem
+    And three markdown files each containing a unique remote image
+    And the second file's download is configured to fail
+    When I run downloadMediaAndUpdate
+    Then the first file should have updated references and be written
+    And the second file should still have remote references
+    And the third file should have updated references and be written
+
+  Scenario: Write happens per-file not per-image
+    Given a mock Tauri environment
+    And an in-memory filesystem
+    And a markdown file with three remote images
+    And all three downloads are configured to succeed
+    When I run downloadMediaAndUpdate
+    Then the file should be written exactly once with all three references updated

package/features/download/worker-pool.feature

@@ -0,0 +1,29 @@
+Feature: Worker Pool Concurrency
+  As a developer
+  I want downloads to respect concurrency limits
+  So that we don't overwhelm the server
+
+  Scenario: Respects concurrency limit of 5
+    Given a mock Tauri environment
+    Given an in-memory filesystem
+    Given 20 images to download with delay
+    When I start downloading all images
+    Then at most 5 downloads should run concurrently
+    And all 20 downloads should complete successfully
+
+  Scenario: Tracks download progress
+    Given a mock Tauri environment
+    Given an in-memory filesystem
+    Given 10 images to download
+    When I start downloading all images
+    Then progress events should be reported
+    And the final progress should show all images completed
+
+  Scenario: Handles mixed success and failure
+    Given a mock Tauri environment
+    Given an in-memory filesystem
+    Given 5 images where 2 will fail with 404
+    When I start downloading all images
+    Then 3 downloads should succeed
+    And 2 downloads should be marked as failed
+    And the result should report both successes and failures

package/features/social/fetch-social-data.feature

@@ -0,0 +1,40 @@
+@e2e @real-api
+Feature: Fetch Social Data
+  As a user, I want to download comments, donations, and appreciations
+  So that I can display them on my static site
+
+  Background:
+    Given I am using the Matters test environment
+
+  Scenario: Fetch comments for an article
+    Given I have a test article shortHash
+    When I fetch comments for the article
+    Then I should receive an array of comments
+    And each comment should have id, content, createdAt, and author
+
+  Scenario: Fetch donations for an article
+    Given I have a test article shortHash
+    When I fetch donations for the article
+    Then I should receive an array of donations
+    And each donation should have id and sender details
+
+  Scenario: Fetch appreciations for an article
+    Given I have a test article shortHash
+    When I fetch appreciations for the article
+    Then I should receive an array of appreciations
+    And each appreciation should have amount, createdAt, and sender
+
+  Scenario: Save social data to .moss/social/matters.json
+    Given I have fetched social data for an article
+    When I save the social data
+    Then the file .moss/social/matters.json should exist
+    And it should contain the schemaVersion "1.0.0"
+    And it should contain data for the article shortHash
+
+  Scenario: Merge new social data with existing
+    Given I have existing social data for an article
+    And I fetch new social data
+    When I merge the social data
+    Then new items should be added
+    And existing items should be preserved
+    And no items should be duplicated

package/features/steps/api.steps.ts

@@ -0,0 +1,180 @@
+import { loadFeature, describeFeature } from "@amiceli/vitest-cucumber";
+import { expect } from "vitest";
+import {
+  apiConfig,
+  graphqlQueryPublic,
+  USER_ARTICLES_QUERY,
+  USER_COLLECTIONS_QUERY,
+} from "../../src/api";
+import type {
+  UserArticlesQuery,
+  UserCollectionsQuery,
+  UserProfileQuery,
+} from "../../src/__generated__/types";
+
+const feature = await loadFeature("features/api/fetch-articles.feature");
+
+describeFeature(feature, ({ Scenario }) => {
+  // Test state
+  let articlesResult: UserArticlesQuery | null = null;
+  let profileResult: UserProfileQuery | null = null;
+  let collectionsResult: UserCollectionsQuery | null = null;
+  let allArticles: NonNullable<NonNullable<UserArticlesQuery["user"]>["articles"]["edges"]> = [];
+  let queryError: Error | null = null;
+
+  Scenario("Fetch public user articles", ({ Given, When, Then, And }) => {
+    Given("the matters.icu test environment", () => {
+      apiConfig.endpoint = "https://server.matters.icu/graphql";
+      apiConfig.queryMode = "user";
+    });
+
+    When("I query articles for user {string}", async (_ctx, userName: string) => {
+      try {
+        articlesResult = await graphqlQueryPublic<UserArticlesQuery>(
+          USER_ARTICLES_QUERY,
+          { userName }
+        );
+        queryError = null;
+      } catch (error) {
+        queryError = error as Error;
+        articlesResult = null;
+      }
+    });
+
+    Then("I should receive a list of articles", () => {
+      expect(articlesResult).not.toBeNull();
+      expect(articlesResult?.user).not.toBeNull();
+      expect(articlesResult?.user?.articles.edges).toBeDefined();
+      expect(articlesResult?.user?.articles.edges?.length).toBeGreaterThan(0);
+    });
+
+    And("each article should have id, title, shortHash, and content", () => {
+      const edges = articlesResult?.user?.articles.edges ?? [];
+      for (const edge of edges) {
+        expect(edge.node.id).toBeDefined();
+        expect(edge.node.title).toBeDefined();
+        expect(edge.node.shortHash).toBeDefined();
+        expect(edge.node.content).toBeDefined();
+      }
+    });
+  });
+
+  Scenario("Handle pagination for users with many articles", ({ Given, When, Then, And }) => {
+    Given("the matters.icu test environment", () => {
+      apiConfig.endpoint = "https://server.matters.icu/graphql";
+      apiConfig.queryMode = "user";
+    });
+
+    When("I fetch all articles for user {string} with pagination", async (_ctx, userName: string) => {
+      allArticles = [];
+      let cursor: string | undefined;
+
+      do {
+        const data = await graphqlQueryPublic<UserArticlesQuery>(
+          USER_ARTICLES_QUERY,
+          { userName, after: cursor }
+        );
+
+        if (!data.user) break;
+
+        const edges = data.user.articles.edges ?? [];
+        allArticles.push(...edges);
+
+        cursor = data.user.articles.pageInfo.hasNextPage
+          ? (data.user.articles.pageInfo.endCursor ?? undefined)
+          : undefined;
+      } while (cursor);
+    });
+
+    Then("I should receive all articles across multiple pages", () => {
+      expect(allArticles.length).toBeGreaterThan(0);
+    });
+
+    And("all articles should have unique shortHashes", () => {
+      const shortHashes = allArticles.map((e) => e.node.shortHash);
+      const uniqueHashes = new Set(shortHashes);
+      expect(uniqueHashes.size).toBe(shortHashes.length);
+    });
+  });
+
+  Scenario("Fetch user profile", ({ Given, When, Then }) => {
+    Given("the matters.icu test environment", () => {
+      apiConfig.endpoint = "https://server.matters.icu/graphql";
+      apiConfig.queryMode = "user";
+    });
+
+    // Use inline query without settings field (settings is private and requires auth)
+    When("I query profile for user {string}", async (_ctx, userName: string) => {
+      const PUBLIC_PROFILE_QUERY = `
+        query UserProfile($userName: String!) {
+          user(input: { userName: $userName }) {
+            id
+            userName
+            displayName
+            info {
+              description
+              profileCover
+            }
+            avatar
+          }
+        }
+      `;
+      profileResult = await graphqlQueryPublic<UserProfileQuery>(
+        PUBLIC_PROFILE_QUERY,
+        { userName }
+      );
+    });
+
+    Then("I should receive profile with userName and displayName", () => {
+      expect(profileResult?.user).not.toBeNull();
+      expect(profileResult?.user?.userName).toBeDefined();
+      expect(profileResult?.user?.displayName).toBeDefined();
+    });
+  });
+
+  Scenario("Fetch user collections", ({ Given, When, Then }) => {
+    Given("the matters.icu test environment", () => {
+      apiConfig.endpoint = "https://server.matters.icu/graphql";
+      apiConfig.queryMode = "user";
+    });
+
+    When("I query collections for user {string}", async (_ctx, userName: string) => {
+      collectionsResult = await graphqlQueryPublic<UserCollectionsQuery>(
+        USER_COLLECTIONS_QUERY,
+        { userName }
+      );
+    });
+
+    Then("I should receive a list of collections or empty list", () => {
+      // User might have no collections, which is valid
+      expect(collectionsResult?.user).not.toBeNull();
+      expect(collectionsResult?.user?.collections).toBeDefined();
+      // edges can be empty array or array with items - both are valid
+      expect(Array.isArray(collectionsResult?.user?.collections.edges)).toBe(true);
+    });
+  });
+
+  Scenario("Handle non-existent user gracefully", ({ Given, When, Then }) => {
+    Given("the matters.icu test environment", () => {
+      apiConfig.endpoint = "https://server.matters.icu/graphql";
+      apiConfig.queryMode = "user";
+    });
+
+    When("I query articles for user {string}", async (_ctx, userName: string) => {
+      try {
+        articlesResult = await graphqlQueryPublic<UserArticlesQuery>(
+          USER_ARTICLES_QUERY,
+          { userName }
+        );
+        queryError = null;
+      } catch (error) {
+        queryError = error as Error;
+        articlesResult = null;
+      }
+    });
+
+    Then("the query should return null user", () => {
+      expect(articlesResult?.user).toBeNull();
+    });
+  });
+});