metamaps--metamaps/spec/services/map_activity_service_spec.rb
Connor Turland 7ee96bf6c6 Into master: two finger pan/zoom, map and topic follows (for internal testing) on the UI, map activity emails (#1084)
* fix topic spec

* fix synapse/mapping spec

* brakeman csrf warning suppressed :|

* follows for maps in the ui for internal testing only still (#1072)

* follows for maps in the ui for testers

* require user for these actions

* match how map follow works

* include ability to unfollow from email

* fixup templates

* add unfollow_from_email to the policies

* Update _cheatsheet.html.erb

Clean up text, clarify, and bring in line with current functionality

* topicsRegex and synapsesRegex should allow commas (#1073)

* even better import csv regexes

* prevent double prompt on file drop import

* topic card in react (#1031)

* its coming along

* links bar

* scssify a bunch

* metacode image working a bit better

* metacode selector in react topic card

* riek editing for name field on topic card

* riek submit on enter

* factor out Title and Links from Topic Card component, but not the listeners

* create working Desc editor

* styling is much better now

* textarea min height for desc

* disallow images in topic card markdown

* shift enter is linebreak, enter is save

* attachments split out, but it's pretty buggy

* move listeners into Links.js

* slightly wider metacodeTitle

* fix positioning on metacode selector

* fix metacode selection

* move metacode and permissions into subcomponents

* fixes

* prevent editing on desc/title if not authorized to edit

* fix topic card draggability

* fix embedly

* fix md test

* remove the removed link card manually with jquery

* fix test syntax

* eslint

* more eslin

* reuse authorizedToEdit

* convert metacode sets to a json object for react

* add the html in react whoop

* fix metacode styling

* sort wasn't working

* finishing metacode select

* readd the above link input border

* fix syntax

* multiline title editable textarea

* more portable metacode selector component

* factor out #metacodeOptions into one react component with a callback :D:D:D

* render metacodeOptions in right click menu with react

* render metacodeOptions in right click menu with react

* fix up right click menu's metacode editing

* fix topic card title character counter

* ignore metamaps secret bundle in ag

* simplify Attachments props

* factor out embedly card into its own component; it seems to help

* link resetter

* fix edit icon on title in topic card

* move mapCount and synapseCount hover/click logic to react

* fix up the showMore control

* metacode selection tweaks

* tweak links bar spacing in topic card

* rubocop

* remove TODOs

* more badass permissions selector

* close permission selector when you click outside

* fix overeager metacode selector

* more modular attachments component

* fix bug in Desc.js

* fix right click styling

* permission changes are different than edit rights

* bad module ref

* ensure maxLength on topic titles

* hellz yeah (#1074)

* fix drop from two touches to one

* don't commit activity service

* ability to select/unselect all metacodes in custom set with keyboard shortcut (fix #390) (#1078)

* ability to select/unselect all metacodes in custom set with keyboard shortcut

* select all button

* nicer all/none buttons

* set up react testing (#1080)

* install mocha-webpack. also switch hark to npm version instead of github version

* well, mocha-webpack runs

* add jsdom for tests

* upgrade to webpack 2

* fix npm run test errors

* ImportDialogBox component tests

* Fixes bug where pressing delete key while editing text will suggest... (#1083)

* Fixes bug where pressing delete key while editing text will suggest the deletion of selected map entities

* Changed the DEL key to remove entities instead of delete them

* temporarily disable code climate duplication engine

* add topic following for internal testing

* daily map activity emails (#1081)

* data prepared, task setup

* add the basics of the email template

* cover granular permissions

* unfollow this map

* break out permissions tests better

* rename so test runs
2017-03-06 22:49:46 -05:00

398 lines
19 KiB
Ruby

require 'rails_helper'
RSpec.describe MapActivityService do
let(:map) { create(:map, created_at: 1.week.ago) }
let(:other_user) { create(:user) }
let(:email_user) { create(:user) }
let(:empty_response) { {stats:{}} }
it 'includes nothing if nothing happened' do
response = MapActivityService.summarize_data(map, email_user)
expect(response).to eq (empty_response)
end
describe 'topics added to map' do
it 'includes a topic added within the last 24 hours' do
topic = create(:topic)
mapping = create(:mapping, user: other_user, map: map, mappable: topic, created_at: 6.hours.ago)
event = Event.find_by(kind: 'topic_added_to_map', eventable_id: topic.id)
event.update_columns(created_at: 6.hours.ago)
response = MapActivityService.summarize_data(map, email_user)
expect(response[:stats][:topics_added]).to eq(1)
expect(response[:topics_added]).to eq([event])
end
it 'includes a topic added, then removed, then re-added within the last 24 hours' do
topic = create(:topic)
mapping = create(:mapping, user: other_user, map: map, mappable: topic, created_at: 6.hours.ago)
Event.find_by(kind: 'topic_added_to_map', eventable_id: topic.id).update_columns(created_at: 6.hours.ago)
mapping.updated_by = other_user
mapping.destroy
Event.find_by(kind: 'topic_removed_from_map', eventable_id: topic.id).update_columns(created_at: 5.hours.ago)
mapping2 = create(:mapping, user: other_user, map: map, mappable: topic, created_at: 4.hours.ago)
event = Event.where("meta->>'mapping_id' = ?", mapping2.id.to_s).first
event.update_columns(created_at: 4.hours.ago)
response = MapActivityService.summarize_data(map, email_user)
expect(response[:stats][:topics_added]).to eq(1)
expect(response[:topics_added]).to eq([event])
end
it 'excludes a topic removed then re-added within the last 24 hours' do
topic = create(:topic)
mapping = create(:mapping, user: other_user, map: map, mappable: topic, created_at: 25.hours.ago)
Event.find_by(kind: 'topic_added_to_map', eventable_id: topic.id).update_columns(created_at: 25.hours.ago)
mapping.updated_by = other_user
mapping.destroy
Event.find_by(kind: 'topic_removed_from_map', eventable_id: topic.id).update_columns(created_at: 6.hours.ago)
mapping2 = create(:mapping, user: other_user, map: map, mappable: topic, created_at: 5.hours.ago)
Event.where(kind: 'topic_added_to_map').where("meta->>'mapping_id' = ?", mapping2.id.to_s).first.update_columns(created_at: 5.hours.ago)
response = MapActivityService.summarize_data(map, email_user)
expect(response).to eq (empty_response)
end
it 'excludes a topic added outside the last 24 hours' do
topic = create(:topic)
mapping = create(:mapping, user: other_user, map: map, mappable: topic, created_at: 25.hours.ago)
Event.find_by(kind: 'topic_added_to_map', eventable_id: topic.id).update_columns(created_at: 25.hours.ago)
response = MapActivityService.summarize_data(map, email_user)
expect(response).to eq (empty_response)
end
it 'excludes topics added by the user who will receive the data' do
topic = create(:topic)
topic2 = create(:topic)
mapping = create(:mapping, user: other_user, map: map, mappable: topic, created_at: 5.hours.ago)
event = Event.find_by(kind: 'topic_added_to_map', eventable_id: topic.id)
event.update_columns(created_at: 5.hours.ago)
mapping2 = create(:mapping, user: email_user, map: map, mappable: topic2, created_at: 5.hours.ago)
Event.find_by(kind: 'topic_added_to_map', eventable_id: topic2.id).update_columns(created_at: 5.hours.ago)
response = MapActivityService.summarize_data(map, email_user)
expect(response[:stats][:topics_added]).to eq(1)
expect(response[:topics_added]).to eq([event])
end
end
describe 'topics moved on map' do
it 'includes ones moved within the last 24 hours' do
topic = create(:topic)
create(:mapping, user: email_user, map: map, mappable: topic, created_at: 5.hours.ago)
event = Events::TopicMovedOnMap.publish!(topic, map, other_user, {})
event.update(created_at: 6.hours.ago)
response = MapActivityService.summarize_data(map, email_user)
expect(response[:stats][:topics_moved]).to eq(1)
end
it 'only includes each topic that was moved in the count once' do
topic = create(:topic)
topic2 = create(:topic)
create(:mapping, user: email_user, map: map, mappable: topic, created_at: 5.hours.ago)
create(:mapping, user: email_user, map: map, mappable: topic2, created_at: 5.hours.ago)
event = Events::TopicMovedOnMap.publish!(topic, map, other_user, {})
event.update(created_at: 6.hours.ago)
event2 = Events::TopicMovedOnMap.publish!(topic, map, other_user, {})
event2.update(created_at: 5.hours.ago)
event3 = Events::TopicMovedOnMap.publish!(topic2, map, other_user, {})
event3.update(created_at: 5.hours.ago)
response = MapActivityService.summarize_data(map, email_user)
expect(response[:stats][:topics_moved]).to eq(2)
end
it 'excludes ones moved outside the last 24 hours' do
topic = create(:topic)
create(:mapping, user: email_user, map: map, mappable: topic, created_at: 5.hours.ago)
event = Events::TopicMovedOnMap.publish!(topic, map, other_user, {})
event.update(created_at: 25.hours.ago)
response = MapActivityService.summarize_data(map, email_user)
expect(response).to eq (empty_response)
end
it 'excludes ones moved by the user who will receive the data' do
topic = create(:topic)
create(:mapping, user: email_user, map: map, mappable: topic, created_at: 5.hours.ago)
event = Events::TopicMovedOnMap.publish!(topic, map, email_user, {})
event.update(created_at: 5.hours.ago)
response = MapActivityService.summarize_data(map, email_user)
expect(response).to eq (empty_response)
end
end
describe 'topics removed from map' do
it 'includes a topic removed within the last 24 hours' do
topic = create(:topic)
mapping = create(:mapping, user: other_user, map: map, mappable: topic, created_at: 25.hours.ago)
Event.find_by(kind: 'topic_added_to_map', eventable_id: topic.id).update_columns(created_at: 25.hours.ago)
mapping.updated_by = other_user
mapping.destroy
event = Event.find_by(kind: 'topic_removed_from_map', eventable_id: topic.id)
event.update_columns(created_at: 6.hours.ago)
response = MapActivityService.summarize_data(map, email_user)
expect(response[:stats][:topics_removed]).to eq(1)
expect(response[:topics_removed]).to eq([event])
end
it 'excludes a topic removed outside the last 24 hours' do
topic = create(:topic)
mapping = create(:mapping, user: other_user, map: map, mappable: topic, created_at: 26.hours.ago)
Event.find_by(kind: 'topic_added_to_map', eventable_id: topic.id).update_columns(created_at: 26.hours.ago)
mapping.updated_by = other_user
mapping.destroy
Event.find_by(kind: 'topic_removed_from_map', eventable_id: topic.id).update_columns(created_at: 25.hours.ago)
response = MapActivityService.summarize_data(map, email_user)
expect(response).to eq (empty_response)
end
it 'excludes topics removed by the user who will receive the data' do
topic = create(:topic)
topic2 = create(:topic)
mapping = create(:mapping, user: other_user, map: map, mappable: topic, created_at: 25.hours.ago)
Event.find_by(kind: 'topic_added_to_map', eventable_id: topic.id).update_columns(created_at: 25.hours.ago)
mapping2 = create(:mapping, user: email_user, map: map, mappable: topic2, created_at: 25.hours.ago)
Event.find_by(kind: 'topic_added_to_map', eventable_id: topic2.id).update_columns(created_at: 25.hours.ago)
mapping.updated_by = other_user
mapping.destroy
mapping2.updated_by = email_user
mapping2.destroy
event = Event.find_by(kind: 'topic_removed_from_map', eventable_id: topic.id)
event.update_columns(created_at: 5.hours.ago)
Event.find_by(kind: 'topic_removed_from_map', eventable_id: topic2.id).update_columns(created_at: 5.hours.ago)
response = MapActivityService.summarize_data(map, email_user)
expect(response[:stats][:topics_removed]).to eq(1)
expect(response[:topics_removed]).to eq([event])
end
end
describe 'synapses added to map' do
it 'includes a synapse added within the last 24 hours' do
synapse = create(:synapse)
mapping = create(:mapping, user: other_user, map: map, mappable: synapse, created_at: 6.hours.ago)
event = Event.find_by(kind: 'synapse_added_to_map', eventable_id: synapse.id)
event.update_columns(created_at: 6.hours.ago)
response = MapActivityService.summarize_data(map, email_user)
expect(response[:stats][:synapses_added]).to eq(1)
expect(response[:synapses_added]).to eq([event])
end
it 'includes a synapse added, then removed, then re-added within the last 24 hours' do
synapse = create(:synapse)
mapping = create(:mapping, user: other_user, map: map, mappable: synapse, created_at: 6.hours.ago)
Event.find_by(kind: 'synapse_added_to_map', eventable_id: synapse.id).update_columns(created_at: 6.hours.ago)
mapping.updated_by = other_user
mapping.destroy
Event.find_by(kind: 'synapse_removed_from_map', eventable_id: synapse.id).update_columns(created_at: 5.hours.ago)
mapping2 = create(:mapping, user: other_user, map: map, mappable: synapse, created_at: 4.hours.ago)
event = Event.where(kind: 'synapse_added_to_map').where("meta->>'mapping_id' = ?", mapping2.id.to_s).first
event.update_columns(created_at: 4.hours.ago)
response = MapActivityService.summarize_data(map, email_user)
expect(response[:stats][:synapses_added]).to eq(1)
expect(response[:synapses_added]).to eq([event])
end
it 'excludes a synapse removed then re-added within the last 24 hours' do
synapse = create(:synapse)
mapping = create(:mapping, user: other_user, map: map, mappable: synapse, created_at: 25.hours.ago)
Event.find_by(kind: 'synapse_added_to_map', eventable_id: synapse.id).update_columns(created_at: 25.hours.ago)
mapping.updated_by = other_user
mapping.destroy
Event.find_by(kind: 'synapse_removed_from_map', eventable_id: synapse.id).update_columns(created_at: 6.hours.ago)
mapping2 = create(:mapping, user: other_user, map: map, mappable: synapse, created_at: 5.hours.ago)
Event.where(kind: 'synapse_added_to_map').where("meta->>'mapping_id' = ?", mapping2.id.to_s).first.update_columns(created_at: 5.hours.ago)
response = MapActivityService.summarize_data(map, email_user)
expect(response).to eq (empty_response)
end
it 'excludes a synapse added outside the last 24 hours' do
synapse = create(:synapse)
mapping = create(:mapping, user: other_user, map: map, mappable: synapse, created_at: 25.hours.ago)
Event.find_by(kind: 'synapse_added_to_map', eventable_id: synapse.id).update_columns(created_at: 25.hours.ago)
response = MapActivityService.summarize_data(map, email_user)
expect(response).to eq (empty_response)
end
it 'excludes synapses added by the user who will receive the data' do
synapse = create(:synapse)
synapse2 = create(:synapse)
mapping = create(:mapping, user: other_user, map: map, mappable: synapse, created_at: 5.hours.ago)
event = Event.find_by(kind: 'synapse_added_to_map', eventable_id: synapse.id)
event.update_columns(created_at: 5.hours.ago)
mapping2 = create(:mapping, user: email_user, map: map, mappable: synapse2, created_at: 5.hours.ago)
Event.find_by(kind: 'synapse_added_to_map', eventable_id: synapse2.id).update_columns(created_at: 5.hours.ago)
response = MapActivityService.summarize_data(map, email_user)
expect(response[:stats][:synapses_added]).to eq(1)
expect(response[:synapses_added]).to eq([event])
end
end
describe 'synapses removed from map' do
it 'includes a synapse removed within the last 24 hours' do
synapse = create(:synapse)
mapping = create(:mapping, user: other_user, map: map, mappable: synapse, created_at: 25.hours.ago)
Event.find_by(kind: 'synapse_added_to_map', eventable_id: synapse.id).update_columns(created_at: 25.hours.ago)
mapping.updated_by = other_user
mapping.destroy
event = Event.find_by(kind: 'synapse_removed_from_map', eventable_id: synapse.id)
event.update_columns(created_at: 6.hours.ago)
response = MapActivityService.summarize_data(map, email_user)
expect(response[:stats][:synapses_removed]).to eq(1)
expect(response[:synapses_removed]).to eq([event])
end
it 'excludes a synapse removed outside the last 24 hours' do
synapse = create(:synapse)
mapping = create(:mapping, user: other_user, map: map, mappable: synapse, created_at: 25.hours.ago)
Event.find_by(kind: 'synapse_added_to_map', eventable_id: synapse.id).update_columns(created_at: 25.hours.ago)
mapping.updated_by = other_user
mapping.destroy
Event.find_by(kind: 'synapse_removed_from_map', eventable_id: synapse.id).update_columns(created_at: 25.hours.ago)
response = MapActivityService.summarize_data(map, email_user)
expect(response).to eq (empty_response)
end
it 'excludes synapses removed by the user who will receive the data' do
synapse = create(:synapse)
synapse2 = create(:synapse)
mapping = create(:mapping, user: other_user, map: map, mappable: synapse, created_at: 25.hours.ago)
Event.find_by(kind: 'synapse_added_to_map', eventable_id: synapse.id).update_columns(created_at: 25.hours.ago)
mapping2 = create(:mapping, user: email_user, map: map, mappable: synapse2, created_at: 25.hours.ago)
Event.find_by(kind: 'synapse_added_to_map', eventable_id: synapse2.id).update_columns(created_at: 25.hours.ago)
mapping.updated_by = other_user
mapping.destroy
mapping2.updated_by = email_user
mapping2.destroy
event = Event.find_by(kind: 'synapse_removed_from_map', eventable_id: synapse.id)
event.update_columns(created_at: 5.hours.ago)
Event.find_by(kind: 'synapse_removed_from_map', eventable_id: synapse2.id).update_columns(created_at: 5.hours.ago)
response = MapActivityService.summarize_data(map, email_user)
expect(response[:stats][:synapses_removed]).to eq(1)
expect(response[:synapses_removed]).to eq([event])
end
end
it 'handles permissions for topics added' do
new_topic = nil
new_private_topic = nil
Timecop.freeze(10.hours.ago) do
new_topic = create(:topic, permission: 'commons', user: other_user)
create(:mapping, map: map, mappable: new_topic, user: other_user)
new_private_topic = create(:topic, permission: 'private', user: other_user)
create(:mapping, map: map, mappable: new_private_topic, user: other_user)
end
Timecop.return
response = MapActivityService.summarize_data(map, email_user)
expect(response[:stats]).to eq({
topics_added: 1
})
expect(response[:topics_added].map(&:eventable_id)).to include(new_topic.id)
expect(response[:topics_added].map(&:eventable_id)).to_not include(new_private_topic.id)
end
it 'handles permissions for topics removed' do
old_topic = nil
old_private_topic = nil
old_topic_mapping = nil
old_private_topic_mapping = nil
Timecop.freeze(2.days.ago) do
old_topic = create(:topic, permission: 'commons', user: other_user)
old_topic_mapping = create(:mapping, map: map, mappable: old_topic, user: other_user)
old_private_topic = create(:topic, permission: 'private', user: other_user)
old_private_topic_mapping = create(:mapping, map: map, mappable: old_private_topic, user: other_user)
end
Timecop.return
Timecop.freeze(10.hours.ago) do
# visible
old_topic_mapping.updated_by = other_user
old_topic_mapping.destroy
# not visible
old_private_topic_mapping.updated_by = other_user
old_private_topic_mapping.destroy
end
Timecop.return
response = MapActivityService.summarize_data(map, email_user)
expect(response[:stats]).to eq({
topics_removed: 1
})
expect(response[:topics_removed].map(&:eventable_id)).to include(old_topic.id)
expect(response[:topics_removed].map(&:eventable_id)).to_not include(old_private_topic.id)
end
it 'handles permissions for synapses added' do
new_synapse = nil
new_private_synapse = nil
Timecop.freeze(10.hours.ago) do
# visible
new_synapse = create(:synapse, permission: 'commons', user: other_user)
create(:mapping, map: map, mappable: new_synapse, user: other_user)
# not visible
new_private_synapse = create(:synapse, permission: 'private', user: other_user)
create(:mapping, map: map, mappable: new_private_synapse, user: other_user)
end
Timecop.return
response = MapActivityService.summarize_data(map, email_user)
expect(response[:stats]).to eq({
synapses_added: 1
})
expect(response[:synapses_added].map(&:eventable_id)).to include(new_synapse.id)
expect(response[:synapses_added].map(&:eventable_id)).to_not include(new_private_synapse.id)
end
it 'handles permissions for synapses removed' do
old_synapse = nil
old_private_synapse = nil
old_synapse_mapping = nil
old_private_synapse_mapping = nil
Timecop.freeze(2.days.ago) do
old_synapse = create(:synapse, permission: 'commons', user: other_user)
old_synapse_mapping = create(:mapping, map: map, mappable: old_synapse, user: other_user)
old_private_synapse = create(:synapse, permission: 'private', user: other_user)
old_private_synapse_mapping = create(:mapping, map: map, mappable: old_private_synapse, user: other_user)
end
Timecop.return
Timecop.freeze(10.hours.ago) do
# visible
old_synapse_mapping.updated_by = other_user
old_synapse_mapping.destroy
# not visible
old_private_synapse_mapping.updated_by = other_user
old_private_synapse_mapping.destroy
end
Timecop.return
response = MapActivityService.summarize_data(map, email_user)
expect(response[:stats]).to eq({
synapses_removed: 1
})
expect(response[:synapses_removed].map(&:eventable_id)).to include(old_synapse.id)
expect(response[:synapses_removed].map(&:eventable_id)).to_not include(old_private_synapse.id)
end
describe 'messages in the map chat' do
it 'counts messages within the last 24 hours' do
create(:message, resource: map, created_at: 6.hours.ago)
create(:message, resource: map, created_at: 5.hours.ago)
response = MapActivityService.summarize_data(map, email_user)
expect(response[:stats][:messages_sent]).to eq(2)
end
it 'does not count messages outside the last 24 hours' do
create(:message, resource: map, created_at: 25.hours.ago)
create(:message, resource: map, created_at: 5.hours.ago)
response = MapActivityService.summarize_data(map, email_user)
expect(response[:stats][:messages_sent]).to eq(1)
end
it 'does not count messages sent by the person who will receive the data' do
create(:message, resource: map, created_at: 5.hours.ago, user: other_user)
create(:message, resource: map, created_at: 5.hours.ago, user: email_user)
response = MapActivityService.summarize_data(map, email_user)
expect(response[:stats][:messages_sent]).to eq(1)
end
end
end