refactor: Move all test data to YAML files

Arpith Siromoney · Arpith Siromoney · commit c488ff5d1467 · 2025-10-12T20:05:05.000-07:00
Extracted hardcoded test data from both JS and Go tests into
shared YAML files in testdata/ directory. This ensures both
test suites use exactly the same test data.

Changes:
- Added new test data to testdata/test-cases.yaml:
  - redis_key_prefix_tests
  - build_article_key_tests
  - process_article_tests
  - extract_article_ids_tests
  - generate_article_body_tests

- Updated src/lib/feedUtils.test.js to use YAML data for all tests
- Updated feedfetcher/utils_test.go to use YAML data for all tests

All tests passing:
- JavaScript: 29 tests ✓ (7 articleUtils + 22 feedUtils)
- Go: 38 tests ✓ (7 articles + 31 utils)
diff --git a/feedfetcher/utils_test.go b/feedfetcher/utils_test.go
@@ -39,6 +39,39 @@ type UtilsTestCases struct {
 		Input       *Article `yaml:"input"`
 		Expected    bool     `yaml:"expected"`
 	} `yaml:"article_validation_tests"`
+
+	RedisKeyPrefixTests []struct {
+		Description string `yaml:"description"`
+		Key         string `yaml:"key"`
+		Expected    string `yaml:"expected"`
+	} `yaml:"redis_key_prefix_tests"`
+
+	BuildArticleKeyTests []struct {
+		Description string `yaml:"description"`
+		Input       string `yaml:"input"`
+		Expected    string `yaml:"expected"`
+	} `yaml:"build_article_key_tests"`
+
+	ProcessArticleTests []struct {
+		Description string `yaml:"description"`
+		Input       struct {
+			Article Article `yaml:"article"`
+			FeedURI string  `yaml:"feedURI"`
+		} `yaml:"input"`
+		Expected Article `yaml:"expected"`
+	} `yaml:"process_article_tests"`
+
+	ExtractArticleIdsTests []struct {
+		Description string   `yaml:"description"`
+		Input       []string `yaml:"input"`
+		Expected    []string `yaml:"expected"`
+	} `yaml:"extract_article_ids_tests"`
+
+	GenerateArticleBodyTests []struct {
+		Description  string  `yaml:"description"`
+		Input        Article `yaml:"input"`
+		ExpectedJSON bool    `yaml:"expected_json"`
+	} `yaml:"generate_article_body_tests"`
 }
 
 func TestBuildRequestHeaders(t *testing.T) {
@@ -84,23 +117,55 @@ func TestBuildRedisKeys(t *testing.T) {
 }
 
 func TestBuildArticleKey(t *testing.T) {
-	hashValue := "13a0bebeed5b348147d880a1a4917587"
-	result := BuildArticleKey(hashValue)
-	expected := RedisArticlePrefix + hashValue
-	if result != expected {
-		t.Errorf("Article key mismatch: got %s, want %s", result, expected)
+	data, err := os.ReadFile("../testdata/test-cases.yaml")
+	if err != nil {
+		t.Fatalf("Failed to read test data: %v", err)
+	}
+
+	var testCases UtilsTestCases
+	if err := yaml.Unmarshal(data, &testCases); err != nil {
+		t.Fatalf("Failed to parse test data: %v", err)
+	}
+
+	for _, tc := range testCases.BuildArticleKeyTests {
+		t.Run(tc.Description, func(t *testing.T) {
+			result := BuildArticleKey(tc.Input)
+			if result != tc.Expected {
+				t.Errorf("Article key mismatch: got %s, want %s", result, tc.Expected)
+			}
+		})
 	}
 }
 
 func TestRedisKeyPrefixConstants(t *testing.T) {
-	if RedisFeedPrefix != "feed:" {
-		t.Errorf("RedisFeedPrefix: got %s, want feed:", RedisFeedPrefix)
+	data, err := os.ReadFile("../testdata/test-cases.yaml")
+	if err != nil {
+		t.Fatalf("Failed to read test data: %v", err)
 	}
-	if RedisArticlesPrefix != "articles:" {
-		t.Errorf("RedisArticlesPrefix: got %s, want articles:", RedisArticlesPrefix)
+
+	var testCases UtilsTestCases
+	if err := yaml.Unmarshal(data, &testCases); err != nil {
+		t.Fatalf("Failed to parse test data: %v", err)
 	}
-	if RedisArticlePrefix != "article:" {
-		t.Errorf("RedisArticlePrefix: got %s, want article:", RedisArticlePrefix)
+
+	for _, tc := range testCases.RedisKeyPrefixTests {
+		t.Run(tc.Description, func(t *testing.T) {
+			var actual string
+			switch tc.Key {
+			case "REDIS_FEED_PREFIX":
+				actual = RedisFeedPrefix
+			case "REDIS_ARTICLES_PREFIX":
+				actual = RedisArticlesPrefix
+			case "REDIS_ARTICLE_PREFIX":
+				actual = RedisArticlePrefix
+			default:
+				t.Fatalf("Unknown constant key: %s", tc.Key)
+			}
+
+			if actual != tc.Expected {
+				t.Errorf("%s mismatch: got %s, want %s", tc.Key, actual, tc.Expected)
+			}
+		})
 	}
 }
 
@@ -147,72 +212,89 @@ func TestIsValidArticle(t *testing.T) {
 }
 
 func TestProcessArticle(t *testing.T) {
-	article := Article{
-		GUID:    "https://xkcd.com/3153/",
-		Title:   "Test Article",
-		PubDate: "2024-10-10T00:00:00Z",
+	data, err := os.ReadFile("../testdata/test-cases.yaml")
+	if err != nil {
+		t.Fatalf("Failed to read test data: %v", err)
 	}
-	feedURI := "https://xkcd.com/atom.xml"
-
-	result := ProcessArticle(article, feedURI)
 
-	if result.Hash != "13a0bebeed5b348147d880a1a4917587" {
-		t.Errorf("Hash mismatch: got %s", result.Hash)
-	}
-	if result.Score != 1728518400000 {
-		t.Errorf("Score mismatch: got %d", result.Score)
-	}
-	if result.FeedURL != feedURI {
-		t.Errorf("FeedURL mismatch: got %s", result.FeedURL)
-	}
-	if result.GUID != article.GUID {
-		t.Errorf("GUID mismatch: got %s", result.GUID)
+	var testCases UtilsTestCases
+	if err := yaml.Unmarshal(data, &testCases); err != nil {
+		t.Fatalf("Failed to parse test data: %v", err)
 	}
-	if result.Title != article.Title {
-		t.Errorf("Title mismatch: got %s", result.Title)
+
+	for _, tc := range testCases.ProcessArticleTests {
+		t.Run(tc.Description, func(t *testing.T) {
+			result := ProcessArticle(tc.Input.Article, tc.Input.FeedURI)
+
+			if result.Hash != tc.Expected.Hash {
+				t.Errorf("Hash mismatch: got %s, want %s", result.Hash, tc.Expected.Hash)
+			}
+			if result.Score != tc.Expected.Score {
+				t.Errorf("Score mismatch: got %d, want %d", result.Score, tc.Expected.Score)
+			}
+			if result.FeedURL != tc.Expected.FeedURL {
+				t.Errorf("FeedURL mismatch: got %s, want %s", result.FeedURL, tc.Expected.FeedURL)
+			}
+			if result.GUID != tc.Expected.GUID {
+				t.Errorf("GUID mismatch: got %s, want %s", result.GUID, tc.Expected.GUID)
+			}
+			if result.Title != tc.Expected.Title {
+				t.Errorf("Title mismatch: got %s, want %s", result.Title, tc.Expected.Title)
+			}
+		})
 	}
 }
 
 func TestExtractArticleIds(t *testing.T) {
-	keys := []string{
-		"article:13a0bebeed5b348147d880a1a4917587",
-		"article:21664da7ee05988c62d1f516f3442411",
-		"article:3fa08ba1591ba3683e87265ee9300946",
+	data, err := os.ReadFile("../testdata/test-cases.yaml")
+	if err != nil {
+		t.Fatalf("Failed to read test data: %v", err)
 	}
 
-	result := ExtractArticleIds(keys)
-
-	expected := []string{
-		"13a0bebeed5b348147d880a1a4917587",
-		"21664da7ee05988c62d1f516f3442411",
-		"3fa08ba1591ba3683e87265ee9300946",
+	var testCases UtilsTestCases
+	if err := yaml.Unmarshal(data, &testCases); err != nil {
+		t.Fatalf("Failed to parse test data: %v", err)
 	}
 
-	if !reflect.DeepEqual(result, expected) {
-		t.Errorf("ExtractArticleIds mismatch:\ngot:  %+v\nwant: %+v", result, expected)
+	for _, tc := range testCases.ExtractArticleIdsTests {
+		t.Run(tc.Description, func(t *testing.T) {
+			result := ExtractArticleIds(tc.Input)
+
+			if !reflect.DeepEqual(result, tc.Expected) {
+				t.Errorf("ExtractArticleIds mismatch:\ngot:  %+v\nwant: %+v", result, tc.Expected)
+			}
+		})
 	}
 }
 
 func TestGenerateArticleBody(t *testing.T) {
-	article := Article{
-		GUID:  "test-guid",
-		Title: "Test Article",
-		Hash:  "abc123",
-		Score: 1234567890,
-	}
-
-	result, err := GenerateArticleBody(article)
+	data, err := os.ReadFile("../testdata/test-cases.yaml")
 	if err != nil {
-		t.Fatalf("GenerateArticleBody failed: %v", err)
+		t.Fatalf("Failed to read test data: %v", err)
 	}
 
-	var parsed Article
-	if err := json.Unmarshal([]byte(result), &parsed); err != nil {
-		t.Fatalf("Failed to parse generated JSON: %v", err)
+	var testCases UtilsTestCases
+	if err := yaml.Unmarshal(data, &testCases); err != nil {
+		t.Fatalf("Failed to parse test data: %v", err)
 	}
 
-	if parsed.GUID != article.GUID || parsed.Title != article.Title ||
-		parsed.Hash != article.Hash || parsed.Score != article.Score {
-		t.Errorf("Parsed article doesn't match original:\ngot:  %+v\nwant: %+v", parsed, article)
+	for _, tc := range testCases.GenerateArticleBodyTests {
+		t.Run(tc.Description, func(t *testing.T) {
+			result, err := GenerateArticleBody(tc.Input)
+			if err != nil {
+				t.Fatalf("GenerateArticleBody failed: %v", err)
+			}
+
+			var parsed Article
+			if err := json.Unmarshal([]byte(result), &parsed); err != nil {
+				t.Fatalf("Failed to parse generated JSON: %v", err)
+			}
+
+			// Verify round-trip
+			if parsed.GUID != tc.Input.GUID || parsed.Title != tc.Input.Title ||
+				parsed.Hash != tc.Input.Hash || parsed.Score != tc.Input.Score {
+				t.Errorf("Parsed article doesn't match original:\ngot:  %+v\nwant: %+v", parsed, tc.Input)
+			}
+		})
 	}
 }
diff --git a/src/lib/feedUtils.test.js b/src/lib/feedUtils.test.js
@@ -49,17 +49,21 @@ testCases.redis_keys_tests.forEach((testCase) => {
 });
 
 // Test buildArticleKey
-test('buildArticleKey creates correct format', () => {
-  const hashValue = '13a0bebeed5b348147d880a1a4917587';
-  const result = feedUtils.buildArticleKey(hashValue);
-  assert.strictEqual(result, `${feedUtils.REDIS_ARTICLE_PREFIX}${hashValue}`);
+testCases.build_article_key_tests.forEach((testCase) => {
+  test(testCase.description, () => {
+    const result = feedUtils.buildArticleKey(testCase.input);
+    assert.strictEqual(result, testCase.expected,
+      `Article key mismatch: got ${result}, expected ${testCase.expected}`);
+  });
 });
 
 // Test Redis key prefix constants
-test('Redis prefix constants are defined', () => {
-  assert.strictEqual(feedUtils.REDIS_FEED_PREFIX, 'feed:');
-  assert.strictEqual(feedUtils.REDIS_ARTICLES_PREFIX, 'articles:');
-  assert.strictEqual(feedUtils.REDIS_ARTICLE_PREFIX, 'article:');
+testCases.redis_key_prefix_tests.forEach((testCase) => {
+  test(testCase.description, () => {
+    const constantValue = feedUtils[testCase.key];
+    assert.strictEqual(constantValue, testCase.expected,
+      `${testCase.key} mismatch: got ${constantValue}, expected ${testCase.expected}`);
+  });
 });
 
 // Test shouldStoreArticle
@@ -84,53 +88,47 @@ testCases.article_validation_tests.forEach((testCase) => {
 });
 
 // Test processArticle
-test('processArticle adds hash, score, and feedurl', () => {
-  const article = {
-    guid: 'https://xkcd.com/3153/',
-    title: 'Test Article',
-    pubDate: '2025-10-10T00:00:00Z',
-  };
-  const feedURI = 'https://xkcd.com/atom.xml';
-
-  const result = feedUtils.processArticle(article, feedURI, hash, score);
-
-  assert.strictEqual(result.hash, '13a0bebeed5b348147d880a1a4917587');
-  assert.strictEqual(result.score, 1760054400000);
-  assert.strictEqual(result.feedurl, feedURI);
-  assert.strictEqual(result.guid, article.guid);
-  assert.strictEqual(result.title, article.title);
+testCases.process_article_tests.forEach((testCase) => {
+  test(testCase.description, () => {
+    const result = feedUtils.processArticle(
+      testCase.input.article,
+      testCase.input.feedURI,
+      hash,
+      score
+    );
+
+    assert.strictEqual(result.hash, testCase.expected.hash,
+      `Hash mismatch: got ${result.hash}, expected ${testCase.expected.hash}`);
+    assert.strictEqual(result.score, testCase.expected.score,
+      `Score mismatch: got ${result.score}, expected ${testCase.expected.score}`);
+    assert.strictEqual(result.feedurl, testCase.expected.feedurl,
+      `FeedURL mismatch: got ${result.feedurl}, expected ${testCase.expected.feedurl}`);
+    assert.strictEqual(result.guid, testCase.expected.guid,
+      `GUID mismatch: got ${result.guid}, expected ${testCase.expected.guid}`);
+    assert.strictEqual(result.title, testCase.expected.title,
+      `Title mismatch: got ${result.title}, expected ${testCase.expected.title}`);
+  });
 });
 
 // Test extractArticleIds
-test('extractArticleIds strips article: prefix', () => {
-  const keys = [
-    'article:13a0bebeed5b348147d880a1a4917587',
-    'article:21664da7ee05988c62d1f516f3442411',
-    'article:3fa08ba1591ba3683e87265ee9300946',
-  ];
-
-  const result = feedUtils.extractArticleIds(keys);
-
-  assert.deepStrictEqual(result, [
-    '13a0bebeed5b348147d880a1a4917587',
-    '21664da7ee05988c62d1f516f3442411',
-    '3fa08ba1591ba3683e87265ee9300946',
-  ]);
+testCases.extract_article_ids_tests.forEach((testCase) => {
+  test(testCase.description, () => {
+    const result = feedUtils.extractArticleIds(testCase.input);
+    assert.deepStrictEqual(result, testCase.expected,
+      `Article IDs mismatch: got ${JSON.stringify(result)}, expected ${JSON.stringify(testCase.expected)}`);
+  });
 });
 
 // Test generateArticleBody
-test('generateArticleBody produces valid JSON', () => {
-  const article = {
-    guid: 'test-guid',
-    title: 'Test Article',
-    hash: 'abc123',
-    score: 1234567890,
-  };
-
-  const result = feedUtils.generateArticleBody(article);
-  const parsed = JSON.parse(result);
-
-  assert.deepStrictEqual(parsed, article);
+testCases.generate_article_body_tests.forEach((testCase) => {
+  test(testCase.description, () => {
+    const result = feedUtils.generateArticleBody(testCase.input);
+    const parsed = JSON.parse(result);
+
+    // Verify it produces valid JSON and round-trips correctly
+    assert.deepStrictEqual(parsed, testCase.input,
+      `Article body mismatch: got ${JSON.stringify(parsed)}, expected ${JSON.stringify(testCase.input)}`);
+  });
 });
 
 // Print summary
diff --git a/testdata/test-cases.yaml b/testdata/test-cases.yaml
