simple-rss 2.0.0 → 2.2.0

data/test/base/feed_merging_and_diffing_test.rb

@@ -0,0 +1,140 @@
+require "test_helper"
+
+class FeedMergingAndDiffingTest < Test::Unit::TestCase
+  def setup
+    @feed_one = SimpleRSS.parse <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <rss version="2.0">
+        <channel>
+          <title>Feed One</title>
+          <item>
+            <guid>shared-guid</guid>
+            <title>Shared (older)</title>
+            <pubDate>Mon, 01 Jan 2024 10:00:00 UTC</pubDate>
+          </item>
+          <item>
+            <guid>one-guid</guid>
+            <title>Only One</title>
+            <pubDate>Mon, 01 Jan 2024 11:00:00 UTC</pubDate>
+          </item>
+          <item>
+            <title>Unidentified One</title>
+          </item>
+        </channel>
+      </rss>
+    XML
+
+    @feed_two = SimpleRSS.parse <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <rss version="2.0">
+        <channel>
+          <title>Feed Two</title>
+          <item>
+            <guid>shared-guid</guid>
+            <title>Shared (newer)</title>
+            <pubDate>Mon, 01 Jan 2024 12:00:00 UTC</pubDate>
+          </item>
+          <item>
+            <link>https://example.com/two-only</link>
+            <title>Only Two</title>
+            <pubDate>Mon, 01 Jan 2024 13:00:00 UTC</pubDate>
+          </item>
+          <item>
+            <title>Unidentified Two</title>
+          </item>
+        </channel>
+      </rss>
+    XML
+  end
+
+  def test_merge_dedupes_and_sorts_newest_first
+    merged = @feed_one.merge(@feed_two)
+    titles = merged.map { |item| item[:title] }
+
+    assert_equal [
+      "Only Two",
+      "Shared (newer)",
+      "Only One",
+      "Unidentified One",
+      "Unidentified Two"
+    ], titles
+  end
+
+  def test_class_merge_combines_multiple_feeds
+    merged = SimpleRSS.merge(@feed_one, @feed_two)
+
+    assert_equal 5, merged.size
+    assert_equal "Only Two", merged.first[:title]
+  end
+
+  def test_diff_reports_added_and_removed_items
+    old_feed = SimpleRSS.parse <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <rss version="2.0">
+        <channel>
+          <title>Old Feed</title>
+          <item>
+            <guid>stay</guid>
+            <title>Stay</title>
+          </item>
+          <item>
+            <guid>remove</guid>
+            <title>Remove</title>
+          </item>
+        </channel>
+      </rss>
+    XML
+
+    new_feed = SimpleRSS.parse <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <rss version="2.0">
+        <channel>
+          <title>New Feed</title>
+          <item>
+            <guid>stay</guid>
+            <title>Stay</title>
+          </item>
+          <item>
+            <guid>add</guid>
+            <title>Add</title>
+          </item>
+        </channel>
+      </rss>
+    XML
+
+    diff = old_feed.diff(new_feed)
+
+    assert_equal(["Add"], diff[:added].map { |item| item[:title] })
+    assert_equal(["Remove"], diff[:removed].map { |item| item[:title] })
+  end
+
+  def test_dedupe_mutates_items_and_keeps_unidentified_entries
+    feed = SimpleRSS.parse <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <rss version="2.0">
+        <channel>
+          <title>Dedupe Feed</title>
+          <item>
+            <guid>duplicate</guid>
+            <title>First duplicate</title>
+          </item>
+          <item>
+            <guid>duplicate</guid>
+            <title>Second duplicate</title>
+          </item>
+          <item>
+            <title>Unidentified One</title>
+          </item>
+          <item>
+            <title>Unidentified Two</title>
+          </item>
+        </channel>
+      </rss>
+    XML
+
+    result = feed.dedupe
+
+    assert_same feed, result
+    assert_equal(["First duplicate", "Unidentified One", "Unidentified Two"], feed.items.map { |item| item[:title] })
+  end
+end

data/test/base/fetch_integration_test.rb

@@ -0,0 +1,25 @@
+require "test_helper"
+
+# Integration tests that require network access
+# These are skipped by default, run with NETWORK_TESTS=1
+class FetchIntegrationTest < Test::Unit::TestCase
+  def test_fetch_real_feed
+    omit unless ENV["NETWORK_TESTS"]
+    rss = SimpleRSS.fetch("https://feeds.bbci.co.uk/news/rss.xml", timeout: 10)
+    assert_kind_of SimpleRSS, rss
+    assert rss.title
+    assert rss.items.any?
+  end
+
+  def test_fetch_stores_caching_headers
+    omit unless ENV["NETWORK_TESTS"]
+    rss = SimpleRSS.fetch("https://feeds.bbci.co.uk/news/rss.xml", timeout: 10)
+    assert(rss.etag || rss.last_modified, "Expected ETag or Last-Modified header")
+  end
+
+  def test_fetch_follows_redirect
+    omit unless ENV["NETWORK_TESTS"]
+    rss = SimpleRSS.fetch("https://github.com/cardmagic/simple-rss/commits/master.atom", timeout: 10)
+    assert_kind_of SimpleRSS, rss
+  end
+end

data/test/base/fetch_test.rb

@@ -0,0 +1,90 @@
+require "test_helper"
+require "net/http"
+
+class FetchTest < Test::Unit::TestCase
+  def setup
+    @sample_feed = File.read(File.dirname(__FILE__) + "/../data/rss20.xml")
+  end
+
+  # Test attr_readers exist and default to nil for parsed feeds
+
+  def test_etag_attr_reader_exists
+    rss = SimpleRSS.parse(@sample_feed)
+    assert_respond_to rss, :etag
+  end
+
+  def test_last_modified_attr_reader_exists
+    rss = SimpleRSS.parse(@sample_feed)
+    assert_respond_to rss, :last_modified
+  end
+
+  def test_etag_nil_for_parsed_feed
+    rss = SimpleRSS.parse(@sample_feed)
+    assert_nil rss.etag
+  end
+
+  def test_last_modified_nil_for_parsed_feed
+    rss = SimpleRSS.parse(@sample_feed)
+    assert_nil rss.last_modified
+  end
+
+  # Test fetch class method exists
+
+  def test_fetch_class_method_exists
+    assert_respond_to SimpleRSS, :fetch
+  end
+
+  # Test fetch with invalid URL raises error
+
+  def test_fetch_raises_on_invalid_host
+    # Socket::ResolutionError was added in Ruby 3.3, use SocketError for older versions
+    expected_errors = [SocketError, Errno::ECONNREFUSED, SimpleRSSError]
+    expected_errors << Socket::ResolutionError if defined?(Socket::ResolutionError)
+    assert_raise(*expected_errors) do
+      SimpleRSS.fetch("http://this-host-does-not-exist-12345.invalid/feed.xml", timeout: 1)
+    end
+  end
+
+  # Test fetch options are accepted
+
+  def test_fetch_accepts_etag_option
+    # Just verify it doesn't raise an ArgumentError
+    assert_nothing_raised do
+      SimpleRSS.fetch("http://localhost:1/feed.xml", etag: '"abc123"', timeout: 0.1)
+    rescue StandardError
+      # Expected - connection will fail
+    end
+  end
+
+  def test_fetch_accepts_last_modified_option
+    assert_nothing_raised do
+      SimpleRSS.fetch("http://localhost:1/feed.xml", last_modified: "Wed, 21 Oct 2015 07:28:00 GMT", timeout: 0.1)
+    rescue StandardError
+      # Expected - connection will fail
+    end
+  end
+
+  def test_fetch_accepts_headers_option
+    assert_nothing_raised do
+      SimpleRSS.fetch("http://localhost:1/feed.xml", headers: { "X-Custom" => "test" }, timeout: 0.1)
+    rescue StandardError
+      # Expected - connection will fail
+    end
+  end
+
+  def test_fetch_accepts_timeout_option
+    assert_nothing_raised do
+      SimpleRSS.fetch("http://localhost:1/feed.xml", timeout: 0.1)
+    rescue StandardError
+      # Expected - connection will fail
+    end
+  end
+
+  def test_fetch_accepts_follow_redirects_option
+    assert_nothing_raised do
+      SimpleRSS.fetch("http://localhost:1/feed.xml", follow_redirects: false, timeout: 0.1)
+    rescue StandardError
+      # Expected - connection will fail
+    end
+  end
+end

data/test/base/filtering_and_validation_test.rb

@@ -0,0 +1,187 @@
+require "test_helper"
+
+class FilteringAndValidationTest < Test::Unit::TestCase
+  def setup
+    @rss09 = SimpleRSS.parse open(File.dirname(__FILE__) + "/../data/rss09.rdf")
+    @rss20 = SimpleRSS.parse open(File.dirname(__FILE__) + "/../data/rss20.xml")
+    @atom = SimpleRSS.parse open(File.dirname(__FILE__) + "/../data/atom.xml")
+  end
+
+  def test_feed_type_for_known_formats
+    assert_equal :rss1, @rss09.feed_type
+    assert_equal :rss2, @rss20.feed_type
+    assert_equal :atom, @atom.feed_type
+  end
+
+  def test_feed_type_unknown_for_non_standard_feed
+    feed = SimpleRSS.parse <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <feed>
+        <title>Unknown Feed</title>
+        <entry>
+          <title>Post</title>
+        </entry>
+      </feed>
+    XML
+
+    assert_equal :unknown, feed.feed_type
+  end
+
+  def test_class_valid_returns_true_for_well_formed_feed
+    xml = <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <rss version="2.0">
+        <channel>
+          <title>Valid Feed</title>
+          <link>http://example.com</link>
+          <item>
+            <title>Post</title>
+          </item>
+        </channel>
+      </rss>
+    XML
+
+    assert_equal true, SimpleRSS.valid?(xml)
+  end
+
+  def test_class_valid_returns_false_for_invalid_feed
+    invalid_xml = open(File.dirname(__FILE__) + "/../data/not-rss.xml").read
+
+    assert_equal false, SimpleRSS.valid?(invalid_xml)
+  end
+
+  def test_class_valid_returns_false_when_source_read_fails
+    unreadable_source = Object.new
+    unreadable_source.define_singleton_method(:read) do
+      raise IOError, "stream closed"
+    end
+
+    assert_equal false, SimpleRSS.valid?(unreadable_source)
+  end
+
+  def test_instance_valid_requires_metadata_and_items
+    valid_feed = SimpleRSS.parse <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <rss version="2.0">
+        <channel>
+          <title>Valid Feed</title>
+          <item>
+            <title>Post</title>
+          </item>
+        </channel>
+      </rss>
+    XML
+
+    invalid_feed = SimpleRSS.parse <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <rss version="2.0">
+        <channel>
+          <description>No title and no link</description>
+          <item>
+            <description>Body only</description>
+          </item>
+        </channel>
+      </rss>
+    XML
+
+    empty_feed = SimpleRSS.parse <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <rss version="2.0">
+        <channel>
+          <title>No Items</title>
+        </channel>
+      </rss>
+    XML
+
+    assert_equal true, valid_feed.valid?
+    assert_equal false, invalid_feed.valid?
+    assert_equal false, empty_feed.valid?
+  end
+
+  def test_items_since_filters_by_date
+    threshold = Time.parse("Wed Aug 24 13:30:00 UTC 2005")
+
+    filtered = @rss20.items_since(threshold)
+
+    assert_equal 1, filtered.size
+    assert_operator filtered.first[:pubDate], :>, threshold
+  end
+
+  def test_items_by_category_matches_strings_and_arrays
+    feed_with_string_category = SimpleRSS.parse <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <rss version="2.0">
+        <channel>
+          <title>String Category Feed</title>
+          <item>
+            <title>Ruby News</title>
+            <category>Technology</category>
+          </item>
+          <item>
+            <title>Sports News</title>
+            <category>Sports</category>
+          </item>
+        </channel>
+      </rss>
+    XML
+
+    feed_with_array_category = SimpleRSS.parse(
+      <<~XML,
+        <?xml version="1.0" encoding="UTF-8"?>
+        <rss version="2.0">
+          <channel>
+            <title>Array Category Feed</title>
+            <item>
+              <title>Dev Update</title>
+              <category>Technology</category>
+              <category>Ruby</category>
+            </item>
+          </channel>
+        </rss>
+      XML
+      array_tags: [:category]
+    )
+
+    string_results = feed_with_string_category.items_by_category("tech")
+    array_results = feed_with_array_category.items_by_category("ruby")
+
+    assert_equal 1, string_results.size
+    assert_equal "Ruby News", string_results.first[:title]
+    assert_equal 1, array_results.size
+    assert_equal "Dev Update", array_results.first[:title]
+  end
+
+  def test_search_matches_title_description_summary_and_content
+    feed = SimpleRSS.parse <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <rss version="2.0">
+        <channel>
+          <title>Search Feed</title>
+          <item>
+            <title>Ruby Patterns</title>
+            <description>Language design</description>
+          </item>
+          <item>
+            <title>Other Topic</title>
+            <description>Talks about BREAKING updates</description>
+          </item>
+          <item>
+            <title>Third Topic</title>
+            <summary>A quick ruby summary</summary>
+          </item>
+          <item>
+            <title>Fourth Topic</title>
+            <content>Deep dive into Ruby internals</content>
+          </item>
+        </channel>
+      </rss>
+    XML
+
+    ruby_results = feed.search("ruby")
+    breaking_results = feed.search("breaking")
+
+    assert_equal 3, ruby_results.size
+    assert_equal 1, breaking_results.size
+    assert_equal "Other Topic", breaking_results.first[:title]
+  end
+end

data/test/base/hash_xml_serialization_test.rb

@@ -0,0 +1,142 @@
+require "test_helper"
+
+class HashXmlSerializationTest < Test::Unit::TestCase
+  def setup
+    @rss20 = SimpleRSS.parse open(File.dirname(__FILE__) + "/../data/rss20.xml")
+    @atom = SimpleRSS.parse open(File.dirname(__FILE__) + "/../data/atom.xml")
+  end
+
+  # to_hash tests
+
+  def test_to_hash_returns_hash
+    result = @rss20.to_hash
+    assert_kind_of Hash, result
+  end
+
+  def test_to_hash_includes_feed_title
+    result = @rss20.to_hash
+    assert_equal "Technoblog", result[:title]
+  end
+
+  def test_to_hash_includes_items
+    result = @rss20.to_hash
+    assert_kind_of Array, result[:items]
+    assert_equal 10, result[:items].size
+  end
+
+  def test_to_hash_is_alias_for_as_json
+    assert_equal @rss20.as_json, @rss20.to_hash
+  end
+
+  # to_xml RSS 2.0 tests
+
+  def test_to_xml_returns_string
+    result = @rss20.to_xml
+    assert_kind_of String, result
+  end
+
+  def test_to_xml_default_format_is_rss2
+    result = @rss20.to_xml
+    assert_match(/<rss version="2.0">/, result)
+  end
+
+  def test_to_xml_rss2_has_xml_declaration
+    result = @rss20.to_xml(format: :rss2)
+    assert_match(/^<\?xml version="1.0" encoding="UTF-8"\?>/, result)
+  end
+
+  def test_to_xml_rss2_has_channel
+    result = @rss20.to_xml(format: :rss2)
+    assert_match(/<channel>/, result)
+    assert_match(%r{</channel>}, result)
+  end
+
+  def test_to_xml_rss2_has_title
+    result = @rss20.to_xml(format: :rss2)
+    assert_match(%r{<title>Technoblog</title>}, result)
+  end
+
+  def test_to_xml_rss2_has_link
+    result = @rss20.to_xml(format: :rss2)
+    assert_match(%r{<link>http://tech.rufy.com</link>}, result)
+  end
+
+  def test_to_xml_rss2_has_items
+    result = @rss20.to_xml(format: :rss2)
+    assert_match(/<item>/, result)
+    assert_match(%r{</item>}, result)
+  end
+
+  def test_to_xml_rss2_item_has_title
+    result = @rss20.to_xml(format: :rss2)
+    assert_match(/<item>\n<title>/, result)
+  end
+
+  def test_to_xml_rss2_item_has_guid
+    result = @rss20.to_xml(format: :rss2)
+    assert_match(%r{<guid>http://tech.rufy.com/entry/\d+</guid>}, result)
+  end
+
+  def test_to_xml_rss2_escapes_special_characters
+    rss = SimpleRSS.parse('<rss version="2.0"><channel><title>Test &amp; Title</title><item><title>Item &lt;1&gt;</title></item></channel></rss>')
+    result = rss.to_xml(format: :rss2)
+    assert_match(/&amp;/, result)
+  end
+
+  # to_xml Atom tests
+
+  def test_to_xml_atom_format
+    result = @atom.to_xml(format: :atom)
+    assert_match(%r{<feed xmlns="http://www.w3.org/2005/Atom">}, result)
+  end
+
+  def test_to_xml_atom_has_title
+    result = @atom.to_xml(format: :atom)
+    assert_match(%r{<title>dive into mark</title>}, result)
+  end
+
+  def test_to_xml_atom_has_link
+    result = @atom.to_xml(format: :atom)
+    assert_match(%r{<link href="http://example.org/" rel="alternate"/>}, result)
+  end
+
+  def test_to_xml_atom_has_entries
+    result = @atom.to_xml(format: :atom)
+    assert_match(/<entry>/, result)
+    assert_match(%r{</entry>}, result)
+  end
+
+  def test_to_xml_atom_entry_has_title
+    result = @atom.to_xml(format: :atom)
+    assert_match(%r{<entry>\n<title>Atom draft-07 snapshot</title>}, result)
+  end
+
+  # Error handling
+
+  def test_to_xml_raises_on_unknown_format
+    assert_raise(ArgumentError) { @rss20.to_xml(format: :unknown) }
+  end
+
+  def test_to_xml_error_message_includes_supported_formats
+    error = assert_raise(ArgumentError) { @rss20.to_xml(format: :foo) }
+    assert_match(/Supported: :rss2, :atom/, error.message)
+  end
+
+  # Round-trip tests
+
+  def test_to_xml_rss2_can_be_reparsed
+    xml = @rss20.to_xml(format: :rss2)
+    reparsed = SimpleRSS.parse(xml)
+
+    assert_equal "Technoblog", reparsed.title
+    assert_equal 10, reparsed.items.size
+  end
+
+  def test_to_xml_atom_can_be_reparsed
+    xml = @atom.to_xml(format: :atom)
+    reparsed = SimpleRSS.parse(xml)
+
+    assert_equal "dive into mark", reparsed.title
+    assert_equal 1, reparsed.items.size
+  end
+end

data/test/base/json_serialization_test.rb

@@ -0,0 +1,81 @@
+require "test_helper"
+require "json"
+
+class JsonSerializationTest < Test::Unit::TestCase
+  def setup
+    @rss20 = SimpleRSS.parse open(File.dirname(__FILE__) + "/../data/rss20.xml")
+    @atom = SimpleRSS.parse open(File.dirname(__FILE__) + "/../data/atom.xml")
+  end
+
+  def test_as_json_returns_hash
+    result = @rss20.as_json
+    assert_kind_of Hash, result
+  end
+
+  def test_as_json_includes_feed_title
+    result = @rss20.as_json
+    assert_equal "Technoblog", result[:title]
+  end
+
+  def test_as_json_includes_feed_link
+    result = @rss20.as_json
+    assert_equal "http://tech.rufy.com", result[:link]
+  end
+
+  def test_as_json_includes_items
+    result = @rss20.as_json
+    assert_kind_of Array, result[:items]
+    assert_equal 10, result[:items].size
+  end
+
+  def test_as_json_items_have_title
+    result = @rss20.as_json
+    assert result[:items].first[:title].include?("some_string.starts_with?")
+  end
+
+  def test_as_json_converts_time_to_iso8601
+    result = @rss20.as_json
+    pub_date = result[:items].first[:pubDate]
+    assert_kind_of String, pub_date
+    assert_match(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/, pub_date)
+  end
+
+  def test_as_json_works_with_atom
+    result = @atom.as_json
+    assert_equal "dive into mark", result[:title]
+    assert_equal 1, result[:items].size
+  end
+
+  def test_to_json_returns_string
+    result = @rss20.to_json
+    assert_kind_of String, result
+  end
+
+  def test_to_json_is_valid_json
+    result = @rss20.to_json
+    parsed = JSON.parse(result)
+    assert_kind_of Hash, parsed
+  end
+
+  def test_to_json_roundtrip
+    json_string = @rss20.to_json
+    parsed = JSON.parse(json_string, symbolize_names: true)
+
+    assert_equal "Technoblog", parsed[:title]
+    assert_equal 10, parsed[:items].size
+    assert parsed[:items].first[:title].include?("some_string.starts_with?")
+  end
+
+  def test_as_json_excludes_nil_feed_tags
+    result = @rss20.as_json
+    # Feed tags that weren't in the source shouldn't appear
+    refute result.key?(:subtitle)
+    refute result.key?(:id)
+  end
+
+  def test_as_json_accepts_options_parameter
+    # Should not raise, even if options aren't used yet
+    result = @rss20.as_json(only: [:title])
+    assert_kind_of Hash, result
+  end
+end