muck-services 3.0.0 → 3.1.0

data/test/rails_test/spec/models/entry_spec.rb

@@ -1,195 +0,0 @@
-# == Schema Information
-#
-# Table name: entries
-#
-#  id                      :integer(4)      not null, primary key
-#  feed_id                 :integer(4)      not null
-#  permalink               :string(2083)    default(""), not null
-#  author                  :string(2083)
-#  title                   :text            default(""), not null
-#  description             :text
-#  content                 :text
-#  unique_content          :boolean(1)
-#  published_at            :datetime        not null
-#  entry_updated_at        :datetime
-#  harvested_at            :datetime
-#  oai_identifier          :string(2083)
-#  language_id             :integer(4)
-#  direct_link             :string(2083)
-#  indexed_at              :datetime        default(Fri Jan 01 01:01:01 UTC 1971), not null
-#  relevance_calculated_at :datetime        default(Fri Jan 01 01:01:01 UTC 1971), not null
-#  popular                 :text
-#  relevant                :text
-#  other                   :text
-#  grain_size              :string(255)     default("unknown")
-#  comment_count           :integer(4)      default(0)
-#
-
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe Entry do
-
-  describe "entry instance" do
-    before do
-      @entry = Factory(:entry)
-    end
-    
-    it { should belong_to :feed }
-
-    describe "recommender_entry" do
-      it "should return an entry if the direct_link matches the specified uri" do
-        uri = Factory.next(:uri)
-        e = Factory.create(:entry, :direct_link => uri)
-        Entry.recommender_entry(uri).id.should == e.id
-      end
-
-      it "should return an entry if the permalink matches the specified uri" do
-        uri = Factory.next(:uri)
-        e = Factory.create(:entry, :permalink => uri)
-        Entry.recommender_entry(uri).id.should == e.id
-      end
-
-      it "should return an empty entry with the specified uri if the specified uri doesn't match" do
-        uri = Factory.next(:uri)
-        e = Factory.create(:entry, :permalink => uri)
-        Entry.recommender_entry(uri).should_not be_nil
-        Entry.recommender_entry(uri).permalink.should == uri
-      end
-    end
-
-    describe "resource_uri" do
-      it "should return the permalink when no direct_link is specified" do
-        @entry.direct_link = nil
-        @entry.resource_uri.should == @entry.permalink
-      end
-
-      it "should return the direct_link when a direct_link is specified" do
-        @entry.direct_link = Factory.next(:uri)
-        @entry.resource_uri.should == @entry.direct_link
-      end
-    end
-    
-    describe "search" do
-      # it "should search indexes for ruby" do
-      #   Entry.search('ruby', 'all', 'en', 10, 0)
-      # end
-      it "should raise invalid language error" do
-        lambda{
-          Entry.search('ruby', 'all', 'foo', 10, 0)          
-        }.should raise_error(MuckServices::Exceptions::LanguageNotSupported)
-      end
-    end
-
-    describe "normalized_uri" do
-      it "should remove the trailing file name from any url that ends in index.*" do
-        index_uri = 'http://example.com/some_dir/'
-        ['html','aspx','shtm','htm','asp','php','cfm','jsp','shtml','jhtml'].each { |ext|
-          Entry.normalized_uri(index_uri + 'index.' + ext).should == index_uri
-        }
-      end
-    end
-
-    describe "recommendation requested omitting certain feeds" do
-      it "should not contain entries from those feeds" do
-        feed1_id = Factory(:feed).id
-        feed2_id = Factory(:feed).id
-        feed1_id.should_not == feed2_id
-        Recommendation.create(:entry_id => @entry.id, :dest_entry_id => Factory.create(:entry, :feed_id => feed1_id).id)
-        Recommendation.create(:entry_id => @entry.id, :dest_entry_id => Factory.create(:entry, :feed_id => feed2_id).id)
-        r = @entry.related_entries.top(false, 5, feed2_id.to_s)
-        r.length.should == 1
-        r.each { |e| assert_not_equal feed2_id, e.feed_id}
-      end
-    end
-
-    describe "with 3 recommendations" do
-      before do
-        3.times { |n| Recommendation.create(:entry_id => @entry.id,
-                      :dest_entry_id => Factory(:entry).id, :relevance => n.to_f/10.0) }
-      end
-
-      it "should have 3 related_entries" do
-        @entry.related_entries.top.length.should == 3
-      end
-
-      it "should return only 2 if specified" do
-        @entry.related_entries.top(true,2).length.should == 2
-      end
-
-      it "should return results in order of relevance by default" do
-        related_entries = @entry.related_entries.top
-        related_entries[1].relevance.should < related_entries[0].relevance
-        related_entries[2].relevance.should < related_entries[1].relevance
-      end
-
-    end
-    
-    describe "recommendation requested without details" do
-      it "should not have an author" do
-        Recommendation.create(:entry_id => @entry.id,
-                              :dest_entry_id => Factory.create(:entry, :author => Factory.next(:name)).id,
-                              :relevance => '.3')
-        lambda{
-          @entry.related_entries.top.first.author          
-        }.should raise_error
-      end
-
-      it "should have basic fields" do
-        title = Factory.next(:name)
-        collection = Factory.next(:name)
-        feed_id = Factory(:feed, :short_title => collection).id
-        dest_entry_id = Factory.create(:entry, :title => title, :feed_id => feed_id).id
-        relevance = '.3'
-        recommendation_id = Recommendation.create(:entry_id => @entry.id, :relevance => relevance,
-               :dest_entry_id => dest_entry_id).id.to_s
-        r = @entry.related_entries.top(true).first
-        lambda do
-          r.recommendation_id.should == recommendation_id
-          r.relevance.to_f.should == relevance.to_f
-          r.title.should == title
-          r.collection.should == collection
-          r.dest_entry_id.should_not be_nil
-        end.should_not raise_error
-      end
-    end
-
-    describe "recommendation requested with details" do
-      it "should have basic and detailed fields" do
-        title = Factory.next(:name)
-        collection = Factory.next(:name)
-        author = Factory.next(:name)
-        published_at = DateTime.now
-        clicks = 23
-        average_time_at_dest = 44
-        description = Factory.next(:name)
-        permalink = Factory.next(:uri)
-        direct_uri = Factory.next(:uri)
-        feed_id = Factory(:feed, :short_title => collection).id
-        relevance = '.3'
-        dest_entry_id = Factory.create(:entry, :feed_id => feed_id, :title => title,
-               :author => author, :published_at => published_at, :permalink => permalink,
-               :direct_link => direct_uri, :description => description).id
-        recommendation_id = Recommendation.create(:entry_id => @entry.id, :relevance => relevance,
-               :avg_time_at_dest => average_time_at_dest, :clicks => clicks, :dest_entry_id => dest_entry_id).id.to_s
-        r = @entry.related_entries.top(true).first
-        lambda do
-          r.recommendation_id.should == recommendation_id
-          r.relevance.to_f.should == relevance.to_f
-          r.title.should == title
-          r.collection.should == collection
-          r.dest_entry_id.should_not be_nil
-
-          r.author.should == author
-#          r.published_at.should == published_at
-          r.clicks.to_i.should == clicks
-          r.permalink.should == permalink
-          r.direct_uri.should == direct_uri
-          r.average_time_at_dest.to_i.should == average_time_at_dest
-          r.description.should == description
-        end.should_not raise_error
-      end
-    end
-
-  end
-  
-end

data/test/rails_test/spec/models/feed_parent_spec.rb

@@ -1,22 +0,0 @@
-# == Schema Information
-#
-# Table name: feed_parents
-#
-#  id           :integer(4)      not null, primary key
-#  feed_id      :integer(4)
-#  ownable_id   :integer(4)
-#  ownable_type :string(255)
-#  created_at   :datetime
-#  updated_at   :datetime
-#
-
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe FeedParent do
-
-  describe "A feed parent instance" do
-    it { should belong_to :feed }
-    it { should belong_to :ownable }
-  end
-  
-end

data/test/rails_test/spec/models/feed_spec.rb

@@ -1,204 +0,0 @@
-# == Schema Information
-#
-# Table name: feeds
-#
-#  id                         :integer(4)      not null, primary key
-#  uri                        :string(2083)
-#  display_uri                :string(2083)
-#  title                      :string(1000)
-#  short_title                :string(100)
-#  description                :text
-#  tag_filter                 :string(1000)
-#  top_tags                   :text
-#  priority                   :integer(4)      default(10)
-#  status                     :integer(4)      default(1)
-#  last_requested_at          :datetime        default(Wed Jan 01 00:00:00 UTC 1969)
-#  last_harvested_at          :datetime        default(Wed Jan 01 00:00:00 UTC 1969)
-#  harvest_interval           :integer(4)      default(86400)
-#  failed_requests            :integer(4)      default(0)
-#  error_message              :text
-#  service_id                 :integer(4)      default(0)
-#  login                      :string(255)
-#  password                   :string(255)
-#  created_at                 :datetime
-#  updated_at                 :datetime
-#  entries_changed_at         :datetime
-#  harvested_from_display_uri :string(2083)
-#  harvested_from_title       :string(1000)
-#  harvested_from_short_title :string(100)
-#  entries_count              :integer(4)
-#  default_language_id        :integer(4)      default(0)
-#  default_grain_size         :string(255)     default("unknown")
-#  contributor_id             :integer(4)
-#  etag                       :string(255)
-#
-
-require File.dirname(__FILE__) + '/../spec_helper'
-
-# Used to test muck_content_permission
-describe Feed do
-
-  describe "A feed instance" do
-    before do
-      @feed = Factory(:feed)
-    end
-    
-    it { should have_many :feed_parents }
-    it { should have_many :entries }
-    it { should belong_to :contributor }
-    it { should belong_to :default_language }
-    it { should belong_to :service }
-    
-    it { should validate_presence_of :uri }
-    it { should validate_uniqueness_of :uri }
-    
-    it { should scope_by_title }
-    it { should scope_newer_than }
-    it { should scope_by_newest }
-    
-    it "should set 24 hours as default interval" do
-      @feed.harvest_interval_hours.should == 24
-    end
-    
-    it "should set harvest interval by hours" do
-      @feed.harvest_interval_hours = 10
-      @feed.harvest_interval.should == 10 * 3600
-    end
-    
-    describe "named scope" do
-      describe "banned" do
-        before do
-          @feed = Factory(:feed, :status => MuckServices::Status::BANNED)
-          @feed_not = Factory(:feed)
-        end
-        it "should find feeds that are banned" do
-          Feed.banned.should include(@feed)
-        end
-        it "should not find feeds that are not banned" do
-          Feed.banned.should_not include(@feed_not)
-        end
-      end
-      describe "valid" do
-        before do
-          @feed = Factory(:feed, :status => 0)
-          @feed_not = Factory(:feed, :status => MuckServices::Status::BANNED)
-        end
-        it "should find valid feeds" do
-          Feed.valid.should include(@feed)
-        end
-        it "should not find invalid feeds" do
-          Feed.valid.should_not include(@feed_not)
-        end
-      end
-    end
-    
-  end
-  
-  describe "Feed status" do
-    before do
-      @feed = Factory(:feed)
-    end
-    it "should be banned" do
-      @feed.status = MuckServices::Status::BANNED
-      @feed.banned?.should be_true
-    end
-    it "should be approved" do
-      @feed.status = MuckServices::Status::APPROVED
-      @feed.banned?.should be_false
-    end
-    it "should be pending" do
-      @feed.status = MuckServices::Status::PENDING
-      @feed.pending?.should be_true
-    end
-  end
-  
-  describe "Get feed information" do
-    it "shouldGet feed information" do
-      Feed.gather_information(TEST_URI)
-    end
-    it "shouldDiscover feeds from url" do
-      Feed.discover_feeds(TEST_URI)
-    end
-    it "shouldDiscover feeds from xml url" do
-      Feed.discover_feeds(TEST_XML_URI)[0].url.should == TEST_XML_URI
-    end
-  end
-  
-  describe "Harvest feed" do
-    before do
-      @feed = Factory(:feed, :uri => TEST_RSS_URI, :display_uri => TEST_URI)
-    end
-    it "should get new entries" do
-      entries = @feed.harvest
-      entries.length.should > 0
-    end
-  end
-  
-  describe "Delete feed if unused" do
-    before do
-      @user = Factory(:user)
-      @identity_user = Factory(:user)
-      @delete_feed = Factory(:feed, :contributor => @user)
-      @dont_delete_feed = Factory(:feed, :contributor => @user)
-      @identity_user.own_feeds << @dont_delete_feed
-    end
-    it "should delete feed" do
-      @delete_feed.delete_if_unused(@user).should be_true
-    end
-    it "should not delete feed" do
-      @dont_delete_feed.delete_if_unused(@user).should be_false
-    end
-  end
-  
-  describe "global feed and references" do
-    before do
-      @global_feed = Factory(:feed)
-      @user = Factory(:user)
-      @feed = Factory(:feed)
-      @user.feeds << @feed
-      @feed.reload
-      @identity_feed = Factory(:feed)
-      @user.own_feeds << @identity_feed
-      @identity_feed.reload
-      @aggregation_feed = Factory(:feed)
-      @aggregation = Factory(:aggregation, :ownable => @user)
-      @aggregation.feeds << @aggregation_feed
-    end
-
-    describe "referenced feed" do
-      describe "feed" do
-        it "should be non-global" do
-          @feed.global?.should be_false
-        end
-        it "should be in use" do
-          @feed.in_use?.should be_true
-        end
-      end
-      describe "identity feed" do
-        it "should be non-global" do
-          @identity_feed.global?.should be_false
-        end
-        it "should be in use" do
-          @identity_feed.in_use?.should be_true
-        end
-      end
-      describe "aggregation feed" do
-        it "should be non-global" do
-          @aggregation_feed.global?.should be_false
-        end
-        it "should be in use" do
-          @aggregation_feed.in_use?.should be_true
-        end
-      end
-    end
-    describe "global feed" do
-      it "should be a global feed" do
-        @global_feed.global?.should be_true
-      end
-      it "should not be in use" do
-        @global_feed.in_use?.should be_false
-      end
-    end
-  end
-  
-end

data/test/rails_test/spec/models/identity_feed_spec.rb

@@ -1,18 +0,0 @@
-# == Schema Information
-#
-# Table name: identity_feeds
-#
-#  id           :integer(4)      not null, primary key
-#  feed_id      :integer(4)      not null
-#  ownable_id   :integer(4)      not null
-#  ownable_type :string(255)     not null
-#
-
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe IdentityFeed do
-  describe "identity feed" do
-    it { should belong_to :ownable }
-    it { should belong_to :feed }
-  end
-end

data/test/rails_test/spec/models/oai_endpoint_spec.rb

@@ -1,78 +0,0 @@
-# == Schema Information
-#
-# Table name: oai_endpoints
-#
-#  id                  :integer(4)      not null, primary key
-#  uri                 :string(2083)
-#  display_uri         :string(2083)
-#  metadata_prefix     :string(255)
-#  title               :string(1000)
-#  short_title         :string(100)
-#  contributor_id      :integer(4)
-#  status              :integer(4)
-#  default_language_id :integer(4)
-#  created_at          :datetime
-#  updated_at          :datetime
-#
-
-require File.dirname(__FILE__) + '/../spec_helper'
-
-# Used to test muck_content_permission
-describe OaiEndpoint do
-
-  describe "An oai endpoint instance" do
-    before do
-      @oai_endpoint = Factory(:oai_endpoint)
-    end
-    
-    it { should belong_to :contributor }
-    it { should belong_to :default_language }
-    it { should validate_presence_of :uri }
-    it { should scope_by_title }
-    it { should scope_newer_than }
-    it { should scope_by_newest }
-
-    describe "named scope" do
-      describe "banned" do
-        before do
-          @oai_endpoint = Factory(:oai_endpoint, :status => MuckServices::Status::BANNED)
-          @oai_endpoint_not = Factory(:oai_endpoint)
-        end
-        it "should find oai_endpoints that are banned" do
-          OaiEndpoint.banned.should include(@oai_endpoint)
-        end
-        it "should not find oai_endpoints that are not banned" do
-          OaiEndpoint.banned.should_not include(@oai_endpoint_not)
-        end
-      end
-      describe "valid" do
-        before do
-          @oai_endpoint = Factory(:oai_endpoint, :status => 0)
-          @oai_endpoint_not = Factory(:oai_endpoint, :status => MuckServices::Status::BANNED)
-        end
-        it "should find valid oai_endpoints" do
-          OaiEndpoint.valid.should include(@oai_endpoint)
-        end
-        it "should not find invalid oai_endpoints" do
-          OaiEndpoint.valid.should_not include(@oai_endpoint_not)
-        end
-      end
-    end
-    
-  end
-  
-  describe "banned/unbanned" do
-    before do
-      @oai_endpoint = Factory(:oai_endpoint)
-    end
-    it "should be banned" do
-      @oai_endpoint.status = -1
-      @oai_endpoint.banned?.should be_true
-    end
-    it "should not be banned" do
-      @oai_endpoint.status = 0
-      @oai_endpoint.banned?.should be_false
-    end
-  end
-  
-end