koalagator 2.0.0 → 2.1.0

data/spec/models/calagator/venue/search_spec.rb

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Calagator
-  describe Venue::Search, type: :model do
-    describe '#venues' do
-      before do
-        @open_venue = create(:venue,
-                            title: 'Open Town',
-                            description: 'baz',
-                            wifi: false,
-                            tag_list: %w[foo])
-        @closed_venue = create(:venue,
-                              title: 'Closed Down',
-                              closed: true,
-                              wifi: false,
-                              tag_list: %w[bar])
-        @wifi_venue = create(:venue,
-                            title: 'Internetful',
-                            wifi: true,
-                            tag_list: %w[foo bar])
-      end
-
-      describe 'with no parameters' do
-        subject { described_class.new }
-
-        it 'does not include closed venues' do
-          expect(subject.venues).to match_array([@open_venue, @wifi_venue])
-        end
-
-        it 'does not declare results' do
-          expect(subject).not_to be_results
-        end
-      end
-
-      describe 'and showing all venues' do
-        it 'includes closed venues when asked to with the include_closed parameter' do
-          subject = described_class.new all: '1', include_closed: '1'
-          expect(subject.venues).to match_array([@open_venue, @closed_venue, @wifi_venue])
-        end
-
-        it 'includes ONLY closed venues when asked to with the closed parameter' do
-          subject = described_class.new all: '1', closed: '1'
-          expect(subject.venues).to eq([@closed_venue])
-        end
-
-        it 'declares results' do
-          subject = described_class.new all: '1'
-          expect(subject).to be_results
-        end
-      end
-
-      describe 'when searching' do
-        describe 'for public wifi (and no keyword)' do
-          it 'onlies include results with public wifi' do
-            subject = described_class.new query: '', wifi: '1'
-            expect(subject.venues).to eq([@wifi_venue])
-          end
-
-          it 'declares results' do
-            subject = described_class.new query: '', wifi: '1'
-            expect(subject).to be_results
-          end
-        end
-
-        describe 'when searching by keyword' do
-          it 'finds venues by title' do
-            subject = described_class.new query: 'Open Town'
-            expect(subject.venues).to eq([@open_venue])
-          end
-
-          it 'finds venues by description' do
-            subject = described_class.new query: 'baz'
-            expect(subject.venues).to eq([@open_venue])
-          end
-
-          describe 'and requiring public wifi' do
-            it 'does not find venues without public wifi' do
-              subject = described_class.new query: 'baz', wifi: '1'
-              expect(subject.venues).to be_empty
-            end
-          end
-
-          it 'declares results' do
-            subject = described_class.new query: 'Open Town'
-            expect(subject).to be_results
-          end
-        end
-      end
-
-      it 'is able to return events matching specific tag' do
-        subject = described_class.new tag: 'foo'
-        expect(subject.venues).to match_array([@open_venue, @wifi_venue])
-      end
-
-      it 'declares results' do
-        subject = described_class.new tag: 'foo'
-        expect(subject).to be_results
-      end
-
-      describe 'handling exceptions' do
-        subject(:venue_search) { described_class.new }
-
-        before { allow(Venue).to receive(:non_duplicates).and_raise(ActiveRecord::StatementInvalid, 'bad times') }
-
-        before { venue_search.venues }
-
-        it 'sets a failure message' do
-          expect(venue_search.failure_message).to eq('There was an error completing your search.')
-        end
-
-        it 'is a hard failure' do
-          expect(venue_search).to be_hard_failure
-        end
-      end
-    end
-  end
-end

data/spec/models/calagator/venue_search_spec.rb

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Calagator
-  describe Venue, type: :model do
-    shared_examples_for '#search' do
-      it 'returns everything when searching by empty string' do
-        venue1 = create(:venue)
-        venue2 = create(:venue)
-        expect(described_class.search('')).to match_array([venue1, venue2])
-      end
-
-      it 'searches venue titles by substring' do
-        venue1 = create(:venue, title: 'wtfbbq')
-        venue2 = create(:venue, title: 'zomg!')
-        expect(described_class.search('zomg')).to eq([venue2])
-      end
-
-      it 'searches venue descriptions by substring' do
-        venue1 = create(:venue, description: 'wtfbbq')
-        venue2 = create(:venue, description: 'zomg!')
-        expect(described_class.search('zomg')).to eq([venue2])
-      end
-
-      it 'searches venue tags by exact match' do
-        venue1 = create(:venue, tag_list: %w[wtf bbq zomg])
-        venue2 = create(:venue, tag_list: %w[wtf bbq omg])
-        expect(described_class.search('omg')).to eq([venue2])
-      end
-
-      it 'searches case-insensitively' do
-        venue1 = create(:venue, title: 'WTFBBQ')
-        venue2 = create(:venue, title: 'ZOMG!')
-        expect(described_class.search('zomg')).to eq([venue2])
-      end
-
-      it 'sorts by title' do
-        venue2 = create(:venue, title: 'zomg')
-        venue1 = create(:venue, title: 'omg')
-        expect(described_class.search('', order: 'name')).to eq([venue1, venue2])
-      end
-
-      it 'can limit to venues with wifi' do
-        venue1 = create(:venue, wifi: false)
-        venue2 = create(:venue, wifi: true)
-        expect(described_class.search('', wifi: true)).to eq([venue2])
-      end
-
-      it 'excludes closed venues' do
-        venue1 = create(:venue, closed: true)
-        venue2 = create(:venue, closed: false)
-        expect(described_class.search('')).to eq([venue2])
-      end
-
-      it 'can include closed venues' do
-        venue1 = create(:venue, closed: true)
-        venue2 = create(:venue, closed: false)
-        expect(described_class.search('', include_closed: true)).to match_array([venue1, venue2])
-      end
-
-      it 'can limit number of venues' do
-        create_list(:venue, 2)
-        expect(described_class.search('', limit: 1).count).to eq(1)
-      end
-
-      it 'does not search multiple terms' do
-        venue2 = create(:venue, title: 'zomg')
-        venue1 = create(:venue, title: 'omg')
-        expect(described_class.search('zomg omg')).to eq([])
-      end
-
-      it 'ANDs terms together to narrow search results' do
-        venue2 = create(:venue, title: 'zomg omg')
-        venue1 = create(:venue, title: 'zomg cats')
-        expect(described_class.search('zomg omg')).to eq([venue2])
-      end
-    end
-
-    describe 'Sql' do
-      around do |example|
-        original = Venue::SearchEngine.kind
-        Venue::SearchEngine.kind = :sql
-        example.run
-        Venue::SearchEngine.kind = original
-      end
-
-      it_behaves_like '#search'
-
-      it 'is using the sql search engine' do
-        expect(Venue::SearchEngine.kind).to eq(:sql)
-      end
-    end
-
-    describe 'Sunspot' do
-      around do |example|
-        server_running = begin
-          # Try opening the configured port. If it works, it's running.
-          TCPSocket.new('127.0.0.1', Sunspot::Rails.configuration.port).close
-          true
-                         rescue Errno::ECONNREFUSED
-                           false
-        end
-
-        if server_running
-          Event::SearchEngine.use(:sunspot)
-          Venue::SearchEngine.use(:sunspot)
-          Event.reindex
-          described_class.reindex
-          example.run
-        else
-          pending 'Solr not running. Start with `rake sunspot:solr:start RAILS_ENV=test`'
-        end
-      end
-
-      it_behaves_like '#search'
-
-      it 'is using the sunspot search engine' do
-        expect(Venue::SearchEngine.kind).to eq(:sunspot)
-      end
-    end
-  end
-end

data/spec/models/calagator/venue_spec.rb

@@ -1,391 +0,0 @@
-# frozen_string_literal: true
-
-# == Schema Information
-#
-# Table name: venues
-#
-#  id              :integer          not null, primary key
-#  access_notes    :text
-#  address         :string
-#  closed          :boolean          default(FALSE)
-#  country         :string
-#  description     :text
-#  email           :string
-#  events_count    :integer
-#  latitude        :decimal(7, 4)
-#  locality        :string
-#  longitude       :decimal(7, 4)
-#  postal_code     :string
-#  region          :string
-#  street_address  :string
-#  telephone       :string
-#  title           :string
-#  url             :string
-#  wifi            :boolean          default(FALSE)
-#  created_at      :datetime
-#  updated_at      :datetime
-#  duplicate_of_id :integer
-#  source_id       :integer
-#
-require 'spec_helper'
-
-module Calagator
-  describe Venue, type: :model do
-    it 'is valid' do
-      venue = described_class.new(title: 'My Event')
-      expect(venue).to be_valid
-    end
-
-    it 'adds an http prefix to urls missing this before save' do
-      venue = described_class.new(title: 'My Event', url: 'google.com')
-      expect(venue).to be_valid
-    end
-
-    it 'validates denylisted words' do
-      DenylistValidator.any_instance.stub(patterns: [/\bcialis\b/, /\bviagra\b/])
-      venue = described_class.new(title: 'Foo bar cialis')
-      expect(venue).not_to be_valid
-    end
-
-    describe 'latitude validation' do
-      specify do
-        venue = described_class.new(latitude: -91)
-        expect(venue).to have(1).error_on(:latitude)
-      end
-
-      specify do
-        venue = described_class.new(latitude: -89)
-        expect(venue).to have(0).errors_on(:latitude)
-      end
-    end
-
-    describe 'longitude validation' do
-      specify do
-        venue = described_class.new(longitude: -181)
-        expect(venue).to have(1).error_on(:longitude)
-      end
-
-      specify do
-        venue = described_class.new(longitude: -179)
-        expect(venue).to have(0).errors_on(:longitude)
-      end
-    end
-
-    describe 'when validating' do
-      let(:attributes) { { title: 'My Venue' } }
-      let(:bad_data) { ' blargie ' }
-      let(:expected_data) { bad_data.strip }
-
-      %i[title description address street_address locality region postal_code country email telephone].each do |field|
-        it "strips whitespace from #{field}" do
-          venue = described_class.new(attributes.merge(field => bad_data))
-          venue.valid?
-          expect(venue.send(field)).to eq(expected_data)
-        end
-      end
-
-      it 'strips whitespace from url' do
-        venue = described_class.new(attributes.merge(url: bad_data))
-        venue.valid?
-        expect(venue.url).to eq("http://#{expected_data}")
-      end
-    end
-
-    describe 'when finding exact duplicates' do
-      it 'ignores attributes like created_at' do
-        venue1 = described_class.create!(title: 'this', description: 'desc', created_at: Time.now.in_time_zone)
-        venue2 = described_class.new(title: 'this', description: 'desc', created_at: Time.now.in_time_zone.yesterday)
-
-        expect(venue2.find_exact_duplicates).to include(venue1)
-      end
-
-      it 'ignores source_id' do
-        venue1 = described_class.create!(title: 'this', description: 'desc', source_id: '1')
-        venue2 = described_class.new(title: 'this', description: 'desc', source_id: '2')
-
-        expect(venue2.find_exact_duplicates).to include(venue1)
-      end
-
-      it 'does not match non-duplicates' do
-        described_class.create!(title: 'this', description: 'desc')
-        venue2 = described_class.new(title: 'that', description: 'desc')
-
-        expect(venue2.find_exact_duplicates).to be_blank
-      end
-    end
-
-    describe 'when finding duplicates [integration test]' do
-      subject! do
-        create(:venue, title: 'Venue A')
-      end
-
-      it 'does not match totally different records' do
-        create(:venue)
-        expect(described_class.find_duplicates_by_type('title')).to be_empty
-      end
-
-      it 'does not match similar records when not searching by duplicated fields' do
-        create :venue, title: subject.title
-        expect(described_class.find_duplicates_by_type('description')).to be_empty
-      end
-
-      it 'matches similar records when searching by duplicated fields' do
-        venue = create(:venue, title: subject.title)
-        expect(described_class.find_duplicates_by_type('title')).to eq([subject.title] => [subject, venue])
-      end
-
-      it 'matches similar records when searching by :any' do
-        venue = create(:venue, title: subject.title)
-        expect(described_class.find_duplicates_by_type('any')).to eq([nil] => [subject, venue])
-      end
-
-      it 'does not match similar records when searching by multiple fields where not all are duplicated' do
-        create(:venue, title: subject.title)
-        expect(described_class.find_duplicates_by_type('title,description')).to be_empty
-      end
-
-      it 'matches similar records when searching by multiple fields where all are duplicated' do
-        venue = create(:venue, title: subject.title, description: subject.description)
-        expect(described_class.find_duplicates_by_type('title,description')).to \
-          eq([subject.title, subject.description] => [subject, venue])
-      end
-
-      it 'does not match dissimilar records when searching by :all' do
-        create(:venue)
-        expect(described_class.find_duplicates_by_type('all')).to be_empty
-      end
-
-      it 'matches similar records when searching by :all' do
-        attributes = subject.attributes.reject { |key| key == 'id' }
-        venue = described_class.create!(attributes)
-        expect(described_class.find_duplicates_by_type('all')).to eq([nil] => [subject, venue])
-      end
-
-      it 'matches non duplicate venues when searching by na' do
-        venue = create(:venue, title: 'Venue B')
-        expect(described_class.find_duplicates_by_type('na')).to eq([nil] => [subject, venue])
-      end
-    end
-
-    describe 'when checking for squashing' do
-      before do
-        @primary = described_class.create!(title: 'primary')
-        @duplicate_first = described_class.create!(title: '1st duplicate', duplicate_of_id: @primary.id)
-        @duplicate_second = described_class.create!(title: '2nd duplicate', duplicate_of_id: @duplicate_first.id)
-      end
-
-      it 'recognizes a primary' do
-        expect(@primary).to be_a_primary
-      end
-
-      it 'recognizes a duplicate' do
-        expect(@duplicate_first).to be_a_duplicate
-      end
-
-      it 'does not think that a duplicate is a primary' do
-        expect(@duplicate_second).not_to be_a_primary
-      end
-
-      it 'does not think that a primary is a duplicate' do
-        expect(@primary).not_to be_a_duplicate
-      end
-
-      it 'returns the originator of a child' do
-        expect(@duplicate_first.originator).to eq @primary
-      end
-
-      it 'returns the originator of a grandchild' do
-        expect(@duplicate_second.originator).to eq @primary
-      end
-
-      it 'returns a primary as its own originator' do
-        expect(@primary.originator).to eq @primary
-      end
-    end
-
-    describe 'when squashing duplicates' do
-      before do
-        @primary_venue    = described_class.create!(title: 'primary')
-        @subprimary_venue = described_class.create!(title: 'Subprimary')
-        @child_venue     = described_class.create!(title: 'Child', duplicate_of: @subprimary_venue)
-        @venues          = [@primary_venue, @subprimary_venue, @child_venue]
-
-        @event_at_child_venue = Event.create!(title: 'Event at child venue', venue: @child_venue, start_time: Time.now.in_time_zone)
-        @event_at_subprimary_venue = Event.create!(title: 'Event at subprimary venue', venue: @subprimary_venue, start_time: Time.now.in_time_zone)
-        @events = [@event_at_child_venue, @event_at_subprimary_venue]
-      end
-
-      it 'squashes a single duplicate' do
-        described_class.squash(@primary_venue, @subprimary_venue)
-
-        expect(@subprimary_venue.duplicate_of).to eq @primary_venue
-        expect(@subprimary_venue).to be_duplicate
-      end
-
-      it 'squashes multiple duplicates' do
-        described_class.squash(@primary_venue, [@subprimary_venue, @child_venue])
-
-        expect(@subprimary_venue.duplicate_of).to eq @primary_venue
-        expect(@child_venue.duplicate_of).to eq @primary_venue
-      end
-
-      it 'squashes duplicates recursively' do
-        described_class.squash(@primary_venue, @subprimary_venue)
-
-        expect(@subprimary_venue.duplicate_of).to eq @primary_venue
-        @child_venue.reload # Needed because child was queried through DB, not object graph
-        expect(@child_venue.duplicate_of).to eq @primary_venue
-      end
-
-      it 'transfers events of duplicates' do
-        expect(@venues.map { |venue| venue.events.count }).to eq [0, 1, 1]
-
-        described_class.squash(@primary_venue, @subprimary_venue)
-
-        expect(@venues.map { |venue| venue.events.count }).to eq [2, 0, 0]
-
-        events = @venues.flat_map(&:events).each(&:reload)
-        expect(events.map(&:venue)).to all(eq @primary_venue)
-      end
-    end
-  end
-
-  describe 'Venue geocoding', type: :model do
-    before do
-      @venue = Venue.new(title: 'title', address: 'test')
-      @geo_failure = double('geo', success: false)
-      @geo_success = double('geo', success: true, lat: 0.0, lng: 0.0,
-                                   street_address: '622 SE Grand Ave.', city: 'Portland',
-                                   state: 'OR', country_code: '', zip: '97214')
-      @geocodable_address = "#{@geo_success.street_address}, #{@geo_success.city}" \
-                            "#{@geo_success.state} #{@geo_success.zip}"
-    end
-
-    it 'is valid even if not yet geocoded' do
-      expect(@venue).to be_valid
-    end
-
-    it 'reports its location properly if it has one' do
-      expect do
-        @venue.latitude = 45.0
-        @venue.longitude = -122.0
-      end.to change { @venue.location }.from(false).to([BigDecimal('45.0'), BigDecimal('-122.0')])
-    end
-
-    describe 'with geocoding' do
-      # Enable geocoding for just these tests
-      around do |example|
-        original = Venue::Geocoder.perform_geocoding
-        Venue::Geocoder.perform_geocoding = true
-        example.run
-        Venue::Geocoder.perform_geocoding = original
-      end
-
-      it 'geocodes automatically on save' do
-        expect(Geokit::Geocoders::MultiGeocoder).to receive(:geocode).once.and_return(@geo_success)
-        @venue.save
-      end
-
-      it "does not geocode automatically unless there's an address" do
-        @venue.address = ''
-        expect(Geokit::Geocoders::MultiGeocoder).not_to receive(:geocode)
-        @venue.save
-      end
-
-      it 'does not geocode automatically if already geocoded' do
-        @venue.latitude = @venue.longitude = 0.0
-        expect(Geokit::Geocoders::MultiGeocoder).not_to receive(:geocode)
-        @venue.save
-      end
-
-      it 'does not fail if the geocoder returns failure' do
-        expect(Geokit::Geocoders::MultiGeocoder).to receive(:geocode).once.and_return(@geo_failure)
-        @venue.save
-      end
-
-      it 'fills in empty addressing fields' do
-        expect(Geokit::Geocoders::MultiGeocoder).to receive(:geocode).once.and_return(@geo_success)
-        @venue.save
-        expect(@venue.street_address).to eq @geo_success.street_address
-        expect(@venue.locality).to eq @geo_success.city
-        expect(@venue.region).to eq @geo_success.state
-        expect(@venue.postal_code).to eq @geo_success.zip
-      end
-
-      it 'leaves non-empty addressing fields alone' do
-        @venue.locality = 'Cleveland'
-        expect(Geokit::Geocoders::MultiGeocoder).to receive(:geocode).once.and_return(@geo_success)
-        @venue.save
-        expect(@venue.locality).to eq 'Cleveland'
-      end
-
-      it 'does not overwrite present fields with empty values' do
-        @venue.country = 'US'
-        expect(Geokit::Geocoders::MultiGeocoder).to receive(:geocode).once.and_return(@geo_success)
-        @venue.save
-        expect(@venue.country).to eq 'US'
-      end
-
-      it 'overwrites latitude and longitude values if forced' do
-        @venue.latitude = @venue.longitude = 1.0
-        @venue.force_geocoding = '1'
-        expect(Geokit::Geocoders::MultiGeocoder).to receive(:geocode).once.and_return(@geo_success)
-        @venue.save
-        expect(@venue.latitude).to eq 0.0
-        expect(@venue.longitude).to eq 0.0
-      end
-    end
-  end
-
-  describe 'Venue geocode addressing', type: :model do
-    before do
-      @venue = Venue.new(title: 'title')
-    end
-
-    it "uses the street address fields if they're present" do
-      @venue.attributes = {
-        street_address: 'street_address',
-        locality: 'locality',
-        region: 'region',
-        postal_code: 'postal_code',
-        country: 'country',
-        address: 'address'
-      }
-      expect(@venue.geocode_address).to eq 'street_address, locality region postal_code country'
-    end
-
-    it "falls back to 'address' field if street address fields are blank" do
-      @venue.attributes = { street_address: '', address: 'address' }
-      expect(@venue.geocode_address).to eq 'address'
-    end
-  end
-
-  describe 'when versioning' do
-    it 'has versions' do
-      expect(Venue.new.versions).to eq []
-    end
-
-    it 'creates a new version after updating' do
-      venue = create :venue
-      expect(venue.versions.count).to eq 1
-
-      venue.title += ' (change)'
-
-      venue.save!
-      expect(venue.versions.count).to eq 2
-    end
-
-    it 'stores prior content in each version' do
-      venue = create :venue, title: "Original Venue"
-      original_title = venue.title
-
-      new_title = venue.title += ' (change)'
-      venue.title = new_title
-      venue.save!
-
-      expect(venue.title).to eq new_title # Updated title
-      expect(venue.versions.first.reify.title).to eq original_title # Venue title before update
-      expect(venue.versions.last.reify).to eq nil # Before state on creation is nil
-    end
-  end
-end

data/spec/models/tag_spec.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe ActsAsTaggableOn::Tag, type: :model do
-  describe 'handling machine tags' do
-    context 'when valid' do
-      subject do
-        described_class.new(name: 'meetup:group=1234')
-      end
-
-      it 'parses a machine tag into components' do
-        expect(subject.machine_tag.namespace).to eq 'meetup'
-        expect(subject.machine_tag.predicate).to eq 'group'
-        expect(subject.machine_tag.value).to eq '1234'
-      end
-
-      it 'generates a url for supported namespaces/predicates' do
-        expect(subject.machine_tag.url).to eq 'http://www.meetup.com/1234'
-      end
-
-      it "redirects to 'defunct' page with archive url as query param when using a defunct provider" do
-        @event = create(:event, tag_list: 'upcoming:event=1234')
-        event_date = @event.start_time.strftime('%Y%m%d')
-        expect(@event.tags.last.machine_tag.url).to eq "http://my-calagator.org/defunct?url=https://web.archive.org/web/#{event_date}/http://upcoming.yahoo.com/event/1234"
-      end
-
-      it 'redirects correctly for venue tags also' do
-        @venue = create(:venue, tag_list: 'upcoming:venue=1234')
-        venue_date = @venue.created_at.strftime('%Y%m%d')
-        expect(@venue.tags.last.machine_tag.url).to eq "http://my-calagator.org/defunct?url=https://web.archive.org/web/#{venue_date}/http://upcoming.yahoo.com/venue/1234"
-      end
-    end
-
-    describe '#venue?' do
-      it 'knows when its a venue' do
-        subject = described_class.new(name: 'upcoming:venue=1234')
-        expect(subject.machine_tag).to be_venue
-      end
-
-      it 'knows when its not a venue' do
-        subject = described_class.new(name: 'meetup:group=1234')
-        expect(subject.machine_tag).not_to be_venue
-      end
-    end
-
-    context 'when invalid' do
-      subject do
-        described_class.new(name: 'not a machine tag')
-      end
-
-      it 'has empty properties when the tag is not a machine tag' do
-        expect(subject.machine_tag.url).to be_nil
-        expect(subject.machine_tag.namespace).to be_nil
-        expect(subject.machine_tag.predicate).to be_nil
-        expect(subject.machine_tag.value).to be_nil
-      end
-    end
-  end
-end