calagator 0.0.1.pre1

data/spec/models/calagator/source/parser_meetup_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+module Calagator
+
+describe Source::Parser::Meetup, :type => :model do
+  describe "with a meetup.com API key in secrets.yml" do
+    before do
+      SECRETS.meetup_api_key = "foo"
+    end
+
+    before(:each) do
+      meetup_url = "http://www.meetup.com/pdxpython/events/ldhnqyplbnb/"
+      api_url = "https://api.meetup.com/2/event/ldhnqyplbnb?key=foo&sign=true"
+
+      stub_request(:get, api_url).to_return(body: read_sample('meetup.json'), headers: { content_type: "application/json" })
+      @events = Source::Parser::Meetup.to_events(url: meetup_url)
+      @event = @events.first
+    end
+
+    it "should find one event" do
+      expect(@events.size).to eq 1
+    end
+
+    it "should set event details" do
+      expect(@event.title).to eq "eLearning Network Meetup"
+      expect(@event.start_time).to eq Time.zone.parse("Thu Aug 11 00:00:00 UTC 2011")
+    end
+
+    it "should tag Meetup events with automagic machine tags" do
+      expect(@event.tag_list).to eq ["meetup:event=ldhnqyplbnb", "meetup:group=eLearningNetwork"]
+    end
+
+    it "should populate a venue when structured data is provided" do
+      expect(@event.venue).to be_a Venue
+      expect(@event.venue.title).to eq "Green Dragon Bistro and Brewpub"
+      expect(@event.venue.street_address).to eq "928 SE 9th Ave"
+      expect(@event.venue.tag_list).to eq ["meetup:venue=774133"]
+    end
+  end
+
+  context "without a meetup API key" do
+    before do
+      SECRETS.meetup_api_key = nil
+    end
+
+    before(:each) do
+      url = "http://www.meetup.com/pdxpython/events/ldhnqyplbnb/ical"
+      stub_request(:get, url).to_return(body: read_sample('meetup.ics'))
+      @events = Source::Parser::Meetup.to_events(url: url)
+      @event = @events.first
+    end
+
+    it "should find one event" do
+      expect(@events.size).to eq 1
+    end
+
+    it "should set event details" do
+      expect(@event.title).to eq "eLearning Network Meetup"
+      expect(@event.start_time.to_date).to eq Date.parse("3011-08-11")
+    end
+
+    it "should populate a venue when structured data is provided" do
+      expect(@event.venue).to be_a Venue
+      expect(@event.venue.title).to eq "Green Dragon Bistro and Brewpub"
+    end
+  end
+end
+
+end

data/spec/models/calagator/source/parser_plancast_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+module Calagator
+
+describe Source::Parser::Plancast, :type => :model do
+
+  context do
+    before(:each) do
+      plancast_url = 'http://plancast.com/p/3cos/indiewebcamp'
+      api_url = 'http://api.plancast.com/02/plans/show.json?extensions=place&plan_id=3cos'
+      stub_request(:get, api_url).to_return(body: read_sample('plancast.json'), headers: { content_type: "application/json" })
+
+      @events = Source::Parser::Plancast.to_events(url: plancast_url)
+      @event = @events.first
+    end
+
+    it "should find one event" do
+      expect(@events.size).to eq 1
+    end
+
+    it "should set event details" do
+      expect(@event.title).to eq "IndieWebCamp"
+      expect(@event.start_time).to eq Time.zone.parse("Sat, 25 Jun 2011 00:00:00")
+    end
+
+    it "should tag Plancast events with automagic machine tags" do
+      expect(@event.tag_list).to eq ["plancast:plan=3cos"]
+    end
+
+    it "should populate a venue when structured data is provided" do
+      expect(@event.venue.title).to eq "Urban Airship"
+      expect(@event.venue.address).to eq "334 Northwest 11th Avenue, Portland, Oregon, United States"
+      expect(@event.venue.tag_list).to eq ["plancast:place=1520153"]
+    end
+  end
+
+  context "with missing venue" do
+    before(:each) do
+      plancast_url = 'http://plancast.com/p/3cos/indiewebcamp'
+      api_url = 'http://api.plancast.com/02/plans/show.json?extensions=place&plan_id=3cos'
+      stub_request(:get, api_url).to_return(body: read_sample('plancast_with_missing_venue.json'), headers: { content_type: "application/json" })
+      @events = Source::Parser::Plancast.to_events(url: plancast_url)
+      @event = @events.first
+    end
+
+    it "uses fallback when no venue is detected" do
+      expect(@event.venue.title).to eq "The Center of the Earth"
+      expect(@event.venue.address).to be_blank
+    end
+  end
+end
+
+end

data/spec/models/calagator/source/parser_spec.rb

@@ -0,0 +1,238 @@
+require 'spec_helper'
+
+module Calagator
+
+describe Source::Parser, "when reading content", :type => :model do
+  it "should read from a normal URL" do
+    stub_request(:get, "http://a.real/~url").to_return(body: "42")
+    expect(Source::Parser.read_url("http://a.real/~url")).to eq "42"
+  end
+
+  it "should raise an error when unauthorized" do
+    stub_request(:get, "http://a.private/~url").to_return(status: [401, "Forbidden"])
+    expect {
+      Source::Parser.read_url("http://a.private/~url")
+    }.to raise_error Source::Parser::HttpAuthenticationRequiredError
+  end
+end
+
+describe Source::Parser, "when subclassing", :type => :model do
+  it "should demand that #to_events is implemented" do
+    expect{ Source::Parser.new.to_events }.to raise_error NotImplementedError
+  end
+end
+
+describe Source::Parser, "when parsing events", :type => :model do
+  it "should have site-specific parsers first, then generics" do
+    expect(Source::Parser.parsers.to_a).to eq [
+      Source::Parser::Facebook,
+      Source::Parser::Meetup,
+      Source::Parser::Plancast,
+      Source::Parser::Hcal,
+      Source::Parser::Ical,
+    ]
+  end
+
+  it "should use first successful parser's results" do
+    events = [double]
+
+    body = {
+      name: "event",
+      start_time: "2010-01-01 12:00:00 UTC",
+      end_time: "2010-01-01 13:00:00 UTC"
+    }.to_json
+    stub_request(:get, "http://graph.facebook.com/omg").to_return(body: body, headers: { content_type: "application/json" })
+
+    expect(Source::Parser.to_events(url: "http://www.facebook.com/events/omg")).to have(1).event
+  end
+end
+
+describe Source::Parser, "checking duplicates when importing", :type => :model do
+  describe "with two identical events" do
+    before :each do
+      @venue_size_before_import = Venue.count
+      url = "http://mysample.hcal/"
+      @cal_source = Source.new(title: "Calendar event feed", url: url)
+      @cal_content = (%{
+      <div class="vevent">
+        <abbr class="dtstart" title="20080714"></abbr>
+        <abbr class="summary" title="Bastille Day"></abbr>
+        <abbr class="location" title="Arc de Triomphe"></abbr>
+      </div>
+      <div class="vevent">
+        <abbr class="dtstart" title="20080714"></abbr>
+        <abbr class="summary" title="Bastille Day"></abbr>
+        <abbr class="location" title="Arc de Triomphe"></abbr>
+      </div>})
+      stub_request(:get, url).to_return(body: @cal_content)
+      @events = @cal_source.to_events
+      @created_events = @cal_source.create_events!(:skip_old => false)
+    end
+
+    it "should only parse one event" do
+      expect(@events.size).to eq 1
+    end
+
+    it "should create only one event" do
+      expect(@created_events.size).to eq 1
+    end
+
+    it "should create only one venue" do
+      expect(Venue.count).to eq @venue_size_before_import + 1
+    end
+  end
+
+  describe "with an event" do
+    it "should retrieve an existing event if it's an exact duplicate" do
+      url = "http://mysample.hcal/"
+      hcal_source = Source.new(title: "Calendar event feed", url: url)
+      stub_request(:get, url).to_return(body: read_sample('hcal_event_duplicates_fixture.xml'))
+
+      event = hcal_source.to_events.first
+      event.save!
+
+      event2 = hcal_source.to_events.first
+      expect(event2).not_to be_a_new_record
+    end
+
+    it "an event with a orphaned exact duplicate should should remove duplicate marking" do
+      orphan = Event.create!(:title => "orphan", :start_time => Time.parse("July 14 2008"), :duplicate_of_id => 7142008 )
+      cal_content = %(
+        <div class="vevent">
+        <abbr class="summary" title="orphan"></abbr>
+        <abbr class="dtstart" title="20080714"></abbr>
+        </div>
+      )
+      url = "http://mysample.hcal/"
+      stub_request(:get, url).to_return(body: cal_content)
+
+      cal_source = Source.new(title: "Calendar event feed", url: url)
+      imported_event = cal_source.create_events!(:skip_old => false).first
+      expect(imported_event).not_to be_marked_as_duplicate
+    end
+  end
+
+  describe "should create two events when importing two non-identical events" do
+    # This behavior is tested under
+    #  describe Source::Parser::Hcal, "with hCalendar events" do
+    #  'it "should parse a page with multiple events" '
+  end
+
+  describe "two identical events with different venues" do
+    before(:each) do
+      cal_content = %(
+        <div class="vevent">
+          <abbr class="dtstart" title="20080714"></abbr>
+          <abbr class="summary" title="Bastille Day"></abbr>
+          <abbr class="location" title="Arc de Triomphe"></abbr>
+        </div>
+        <div class="vevent">
+          <abbr class="dtstart" title="20080714"></abbr>
+          <abbr class="summary" title="Bastille Day"></abbr>
+          <abbr class="location" title="Bastille"></abbr>
+        </div>
+      )
+      url = "http://mysample.hcal/"
+      stub_request(:get, url).to_return(body: cal_content)
+
+      cal_source = Source.new(title: "Calendar event feed", url: url)
+      @parsed_events  = cal_source.to_events
+      @created_events = cal_source.create_events!(:skip_old => false)
+    end
+
+    it "should parse two events" do
+      expect(@parsed_events.size).to eq 2
+    end
+
+    it "should create two events" do
+      expect(@created_events.size).to eq 2
+    end
+
+     it "should have different venues for the parsed events" do
+      expect(@parsed_events[0].venue).not_to eq @parsed_events[1].venue
+    end
+
+     it "should have different venues for the created events" do
+      expect(@created_events[0].venue).not_to eq @created_events[1].venue
+    end
+  end
+
+  it "should use an existing venue when importing an event whose venue matches a squashed duplicate"  do
+    dummy_source = Source.create!(:title => "Dummy", :url => "http://IcalEventWithSquashedVenue.com/")
+    master_venue = Venue.create!(:title => "Master")
+    squashed_venue = Venue.create!(
+      :title => "Squashed Duplicate Venue",
+      :duplicate_of_id => master_venue.id)
+
+    cal_content = %(
+      <div class="vevent">
+        <abbr class="dtstart" title="20090117"></abbr>
+        <abbr class="summary" title="Event with cloned venue"></abbr>
+        <abbr class="location" title="Squashed Duplicate Venue"></abbr>
+      </div>
+    )
+
+    url = "http://mysample.hcal/"
+    stub_request(:get, url).to_return(body: cal_content)
+
+    source = Source.new(title: "Event with squashed venue", url: url)
+
+    event = source.to_events(:skip_old => false).first
+    expect(event.venue.title).to eq "Master"
+  end
+
+  it "should use an existing venue when importing an event with a matching machine tag that describes a venue" do
+    venue = Venue.create!(:title => "Custom Urban Airship", :tag_list => "plancast:place=1520153")
+
+    plancast_url = 'http://plancast.com/p/3cos/indiewebcamp'
+    api_url = 'http://api.plancast.com/02/plans/show.json?extensions=place&plan_id=3cos'
+    stub_request(:get, api_url).to_return(body: read_sample('plancast.json'), headers: { content_type: "application/json" })
+
+    source = Source.new(title: "Event with duplicate machine-tagged venue", url: plancast_url)
+
+    event = source.to_events(:skip_old => false).first
+
+    expect(event.venue).to eq venue
+  end
+
+  describe "choosing parsers by matching URLs" do
+    { "Calagator::Source::Parser::Plancast" => "http://plancast.com/p/3cos/indiewebcamp",
+      "Calagator::Source::Parser::Meetup"   => "http://www.meetup.com/pdxweb/events/23287271/" }.each do |parser_name, url|
+
+      it "should only invoke the #{parser_name} parser when given #{url}" do
+        parser = parser_name.constantize
+        expect_any_instance_of(parser).to receive(:to_events).and_return([Event.new])
+        Source::Parser.parsers.reject{|p| p == parser }.each do |other_parser|
+          expect_any_instance_of(other_parser).not_to receive :to_events
+        end
+
+        stub_request(:get, url)
+        Source.new(:title => parser_name, :url => url).to_events
+      end
+    end
+  end
+end
+
+describe Source::Parser, "labels", :type => :model do
+  it "should have labels" do
+    expect(Source::Parser.labels).not_to be_blank
+  end
+
+  it "should have labels for each parser" do
+    expect(Source::Parser.labels.size).to eq Source::Parser.parsers.size
+  end
+
+  it "should use the label of the parser, as a string" do
+    label = Source::Parser.parsers.first.label.to_s
+    expect(Source::Parser.labels).to include label
+  end
+
+  it "should have sorted labels" do
+    labels = Source::Parser.labels
+    sorted = labels.sort_by(&:downcase)
+
+    expect(labels).to eq sorted
+  end
+end
+
+end

data/spec/models/calagator/source_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+module Calagator
+
+describe Source, "in general", :type => :model do
+  before(:each) do
+    @event = mock_model(Event,
+      :title => "Title",
+      :description => "Description",
+      :url => "http://my.url/",
+      :start_time => Time.now + 1.day,
+      :end_time => nil,
+      :venue => nil,
+      :duplicate_of_id => nil)
+  end
+
+  it "should create events for source from URL" do
+    expect(@event).to receive(:save!)
+
+    source = Source.new(:url => "http://my.url/")
+    expect(source).to receive(:to_events).and_return([@event])
+    expect(source.create_events!).to eq [@event]
+  end
+
+  it "should fail to create events for invalid sources" do
+    source = Source.new(:url => '\not valid/')
+    expect{ source.to_events }.to raise_error(ActiveRecord::RecordInvalid, /Url has invalid format/i)
+  end
+end
+
+describe Source, "when reading name", :type => :model do
+  before(:each) do
+    @title = "title"
+    @url = "http://my.url/"
+  end
+
+  before(:each) do
+    @source = Source.new
+  end
+
+  it "should return nil if no title is available" do
+    expect(@source.name).to be_nil
+  end
+
+  it "should use title if available" do
+    @source.title = @title
+    expect(@source.name).to eq @title
+  end
+
+  it "should use URL if available" do
+    @source.url = @url
+    expect(@source.name).to eq @url
+  end
+
+  it "should prefer to use title over URL if both are available" do
+    @source.title = @title
+    @source.url = @url
+
+    expect(@source.name).to eq @title
+  end
+end
+
+describe Source, "when parsing URLs", :type => :model do
+  before(:each) do
+    @http_url = 'http://upcoming.yahoo.com/event/390164/'
+    @ical_url = 'webcal://upcoming.yahoo.com/event/390164/'
+    @base_url = 'upcoming.yahoo.com/event/390164/'
+  end
+
+  before(:each) do
+    @source = Source.new
+  end
+
+  it "should not modify supported url schemes" do
+    @source.url = @http_url
+
+    expect(@source.url).to eq @http_url
+  end
+
+  it "should substitute http for unsupported url schemes" do
+    @source.url = @ical_url
+
+    expect(@source.url).to eq @http_url
+  end
+
+  it "should add the http prefix to urls without one" do
+    @source.url = @base_url
+
+    expect(@source.url).to eq @http_url
+  end
+
+  it "should strip leading and trailing whitespace from URL" do
+    source = Source.new
+    source.url = "     #{@http_url}     "
+    expect(source.url).to eq @http_url
+  end
+
+  it "should be invalid if given invalid URL" do
+    source = Source.new
+    source.url = '\O.o/'
+    expect(source.url).to be_nil
+    expect(source).not_to be_valid
+  end
+end
+
+describe Source, "find_or_create_from", :type => :model do
+  before do
+    @url = "http://foo.bar"
+  end
+
+  it "should return new, unsaved record if given no arguments" do
+    source = Source.find_or_create_from()
+
+    expect(source).to be_a_new_record
+  end
+
+  it "should return an existing or newly-created record" do
+    record = Source.new(:url => @url)
+    expect(Source).to receive(:find_or_create_by_url).and_return(record)
+
+    result = Source.find_or_create_from(:url => @url)
+    expect(record).to eq result
+  end
+
+  it "should set re-import flag if given" do
+    record = Source.new(:url => @url)
+    expect(record).to receive(:save)
+    expect(Source).to receive(:find_or_create_by_url).and_return(record)
+
+    result = Source.find_or_create_from(:url => @url, :reimport => true)
+    expect(result.reimport).to be_truthy
+  end
+end
+
+end