-
<%= Date::MONTHNAMES[stat.month] %> <%= stat.year %>
+<%= link_to "#{stat.year}/#{stat.month}",
+ class: "group block p-6 bg-base-100 hover:bg-base-200/50 rounded-xl border border-base-300 hover:border-primary/40 hover:shadow-lg transition-all duration-200 hover:scale-[1.02]" do %>
-
- <%= link_to "Details", points_path(year: stat.year, month: stat.month),
- class: "link link-primary" %>
+
+
+
+ <%= "#{icon month_icon(stat)} #{Date::MONTHNAMES[stat.month]} #{stat.year}".html_safe %>
+
+
-
-
-
<%= number_with_delimiter stat.distance_in_unit(current_user.safe_settings.distance_unit).round %><%= current_user.safe_settings.distance_unit %>
+
+
+
+
+
+ <%= number_with_delimiter stat.distance_in_unit(current_user.safe_settings.distance_unit).round %>
+ <%= current_user.safe_settings.distance_unit %>
+
+
Total distance
+
+
+
+
+ <%= countries_and_cities_stat_for_month(stat) %>
-
-
- <%= countries_and_cities_stat_for_month(stat) %>
-
-
- <%= area_chart(
- stat.daily_distance.map { |day, distance_meters|
- [day, Stat.convert_distance(distance_meters, current_user.safe_settings.distance_unit).round]
- },
- height: '200px',
- suffix: " #{current_user.safe_settings.distance_unit}",
- xtitle: 'Day',
- ytitle: 'Distance'
- ) %>
-
+<% end %>
diff --git a/app/views/stats/_year.html.erb b/app/views/stats/_year.html.erb
index fc5fd1e6..e2168ef9 100644
--- a/app/views/stats/_year.html.erb
+++ b/app/views/stats/_year.html.erb
@@ -10,7 +10,13 @@
height: '200px',
suffix: " #{current_user.safe_settings.distance_unit}",
xtitle: 'Days',
- ytitle: 'Distance'
+ ytitle: 'Distance',
+ colors: [
+ '#397bb5', '#5A4E9D', '#3B945E',
+ '#7BC96F', '#FFD54F', '#FFA94D',
+ '#FF6B6B', '#FF8C42', '#C97E4F',
+ '#8B4513', '#5A2E2E', '#265d7d'
+ ]
) %>
diff --git a/app/views/stats/index.html.erb b/app/views/stats/index.html.erb
index fec5a373..706e30b3 100644
--- a/app/views/stats/index.html.erb
+++ b/app/views/stats/index.html.erb
@@ -39,9 +39,9 @@
<%= link_to year, "/stats/#{year}", class: 'underline hover:no-underline' %>
<%= link_to '[Map]', map_url(year_timespan(year)), class: 'underline hover:no-underline' %>
-
+
Last update: <%= human_date(stats.first.updated_at) %>
- <%= link_to '🔄', update_year_month_stats_path(year, :all), data: { turbo_method: :put }, class: 'text-sm text-gray-500 hover:underline' %>
+ <%= link_to icon('refresh-ccw'), update_year_month_stats_path(year, :all), data: { turbo_method: :put }, class: 'text-sm text-gray-500 hover:text-primary' %>
@@ -93,7 +93,13 @@
height: '200px',
suffix: " #{current_user.safe_settings.distance_unit}",
xtitle: 'Days',
- ytitle: 'Distance'
+ ytitle: 'Distance',
+ colors: [
+ '#397bb5', '#5A4E9D', '#3B945E',
+ '#7BC96F', '#FFD54F', '#FFA94D',
+ '#FF6B6B', '#FF8C42', '#C97E4F',
+ '#8B4513', '#5A2E2E', '#265d7d'
+ ]
) %>
diff --git a/app/views/stats/month.html.erb b/app/views/stats/month.html.erb
new file mode 100644
index 00000000..72d96b80
--- /dev/null
+++ b/app/views/stats/month.html.erb
@@ -0,0 +1,5 @@
+<% content_for :title, "#{Date::MONTHNAMES[@month]} #{@year} Monthly Digest" %>
+
+
+ <%= render partial: 'stats/month', locals: { year: @year, month: @month, stat: @stat, previous_stat: @previous_stat } %>
+
diff --git a/app/views/stats/public_month.html.erb b/app/views/stats/public_month.html.erb
new file mode 100644
index 00000000..dec15c15
--- /dev/null
+++ b/app/views/stats/public_month.html.erb
@@ -0,0 +1,185 @@
+
+
+
+
+
+
Shared Stats - <%= Date::MONTHNAMES[@month] %> <%= @year %>
+ <%= csrf_meta_tags %>
+ <%= csp_meta_tag %>
+
+ <%= stylesheet_link_tag "application", "data-turbo-track": "reload" %>
+ <%= javascript_importmap_tags %>
+
+
+
+
+
+
+
+ <% if @self_hosted %>
+
+
+ <% end %>
+
+
+
+
+
+
+
+
+
+
+ <%= "#{icon month_icon(@stat)} #{Date::MONTHNAMES[@month]} #{@year}".html_safe %>
+
+
Monthly Digest
+
+
+
+
+
+
+
Distance traveled
+
<%= distance_traveled(@user, @stat) %>
+
Total distance for this month
+
+
+
+
Active days
+
+ <%= active_days(@stat) %>
+
+
+ Days with tracked activity
+
+
+
+
+
Countries visited
+
+ <%= countries_visited(@stat) %>
+
+
+ Different countries
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Loading hexagons...
+
+
+
+
+
+
+
+
+
+
+ <%= icon 'trending-up' %> Daily Activity
+
+
+ <%= column_chart(
+ @stat.daily_distance.map { |day, distance_meters|
+ [day, Stat.convert_distance(distance_meters, 'km').round]
+ },
+ height: '200px',
+ suffix: " km",
+ xtitle: 'Day',
+ ytitle: 'Distance',
+ colors: [
+ '#570df8', '#f000b8', '#ffea00',
+ '#00d084', '#3abff8', '#ff5724',
+ '#8e24aa', '#3949ab', '#00897b',
+ '#d81b60', '#5e35b1', '#039be5',
+ '#43a047', '#f4511e', '#6d4c41',
+ '#757575', '#546e7a', '#d32f2f'
+ ],
+ library: {
+ plugins: {
+ legend: { display: false }
+ },
+ scales: {
+ x: {
+ grid: { color: 'rgba(0,0,0,0.1)' }
+ },
+ y: {
+ grid: { color: 'rgba(0,0,0,0.1)' }
+ }
+ }
+ }
+ ) %>
+
+
+ Peak day: <%= peak_day(@stat) %> • Quietest week: <%= quietest_week(@stat) %>
+
+
+
+
+
+
+
+
+ <%= icon 'earth' %> Countries & Cities
+
+
+ <% @stat.toponyms.each_with_index do |country, index| %>
+
+
+ <%= country['country'] %>
+ <%= country['cities'].length %> cities
+
+
+
+ <% end %>
+
+
+
+
+
+
Cities visited:
+ <% @stat.toponyms.each do |country| %>
+ <% country['cities'].first(5).each do |city| %>
+
<%= city['city'] %>
+ <% end %>
+ <% if country['cities'].length > 5 %>
+
+<%= country['cities'].length - 5 %> more
+ <% end %>
+ <% end %>
+
+
+
+
+
+
+
+ Powered by
Dawarich, your personal memories mapper.
+
+
+
+
+
+
+
+
diff --git a/config/initializers/devise.rb b/config/initializers/devise.rb
index e93579b9..7b207ed3 100644
--- a/config/initializers/devise.rb
+++ b/config/initializers/devise.rb
@@ -302,7 +302,7 @@ Devise.setup do |config|
# When set to false, does not sign a user in automatically after their password is
# changed. Defaults to true, so a user is signed in automatically after changing a password.
# config.sign_in_after_change_password = true
- config.responder.error_status = :unprocessable_entity
+ config.responder.error_status = :unprocessable_content
config.responder.redirect_status = :see_other
if Rails.env.production? && !DawarichSettings.self_hosted?
diff --git a/config/initializers/rails_icons.rb b/config/initializers/rails_icons.rb
new file mode 100644
index 00000000..b0d79e40
--- /dev/null
+++ b/config/initializers/rails_icons.rb
@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+RailsIcons.configure do |config|
+ config.default_library = 'lucide'
+ # config.default_variant = "" # Set a default variant for all libraries
+
+ # Override Lucide defaults
+ # config.libraries.lucide.default_variant = "" # Set a default variant for Lucide
+ # config.libraries.lucide.exclude_variants = [] # Exclude specific variants
+
+ # config.libraries.lucide.outline.default.css = "size-6"
+ # config.libraries.lucide.outline.default.stroke_width = "1.5"
+ # config.libraries.lucide.outline.default.data = {}
+end
diff --git a/config/routes.rb b/config/routes.rb
index 1c3b2dda..7e653ec4 100644
--- a/config/routes.rb
+++ b/config/routes.rb
@@ -70,10 +70,21 @@ Rails.application.routes.draw do
end
end
get 'stats/:year', to: 'stats#show', constraints: { year: /\d{4}/ }
+ get 'stats/:year/:month', to: 'stats#month', constraints: { year: /\d{4}/, month: /\d{1,2}/ }
put 'stats/:year/:month/update',
to: 'stats#update',
as: :update_year_month_stats,
constraints: { year: /\d{4}/, month: /\d{1,2}|all/ }
+ # Public shared stats routes
+ get 'shared/stats/:uuid', to: 'shared/stats#show', as: :shared_stat
+ # Backward compatibility
+ get 'shared/stats/:uuid', to: 'shared/stats#show', as: :public_stat
+
+ # Sharing management endpoint (requires auth)
+ patch 'stats/:year/:month/sharing',
+ to: 'shared/stats#update',
+ as: :sharing_stats,
+ constraints: { year: /\d{4}/, month: /\d{1,2}/ }
root to: 'home#index'
@@ -140,6 +151,11 @@ Rails.application.routes.draw do
namespace :maps do
resources :tile_usage, only: [:create]
+ resources :hexagons, only: [:index] do
+ collection do
+ get :bounds
+ end
+ end
end
post 'subscriptions/callback', to: 'subscriptions#callback'
diff --git a/config/schedule.yml b/config/schedule.yml
index 0dc3c9e8..f0fcb40a 100644
--- a/config/schedule.yml
+++ b/config/schedule.yml
@@ -30,12 +30,12 @@ cache_preheating_job:
class: "Cache::PreheatingJob"
queue: default
-# tracks_cleanup_job:
-# cron: "0 2 * * 0" # every Sunday at 02:00
-# class: "Tracks::CleanupJob"
-# queue: tracks
-
place_name_fetching_job:
cron: "30 0 * * *" # every day at 00:30
class: "Places::BulkNameFetchingJob"
queue: places
+
+daily_track_generation_job:
+ cron: "0 */4 * * *" # every 4 hours
+ class: "Tracks::DailyGenerationJob"
+ queue: tracks
diff --git a/db/data/20250704185707_create_tracks_from_points.rb b/db/data/20250704185707_create_tracks_from_points.rb
index 2972eac4..4860841f 100644
--- a/db/data/20250704185707_create_tracks_from_points.rb
+++ b/db/data/20250704185707_create_tracks_from_points.rb
@@ -2,33 +2,9 @@
class CreateTracksFromPoints < ActiveRecord::Migration[8.0]
def up
- puts "Starting bulk track creation for all users..."
+ # this data migration used to create tracks from existing points. It was deprecated
- total_users = User.count
- processed_users = 0
-
- User.find_each do |user|
- points_count = user.points.count
-
- if points_count > 0
- puts "Enqueuing track creation for user #{user.id} (#{points_count} points)"
-
- # Use explicit parameters for bulk historical processing:
- # - No time limits (start_at: nil, end_at: nil) = process ALL historical data
- Tracks::CreateJob.perform_later(
- user.id,
- start_at: nil,
- end_at: nil,
- mode: :bulk
- )
-
- processed_users += 1
- else
- puts "Skipping user #{user.id} (no tracked points)"
- end
- end
-
- puts "Enqueued track creation jobs for #{processed_users}/#{total_users} users"
+ nil
end
def down
diff --git a/db/data/20250709195003_recalculate_trips_distance.rb b/db/data/20250709195003_recalculate_trips_distance.rb
index 6c02bd3a..9353ac18 100644
--- a/db/data/20250709195003_recalculate_trips_distance.rb
+++ b/db/data/20250709195003_recalculate_trips_distance.rb
@@ -2,9 +2,7 @@
class RecalculateTripsDistance < ActiveRecord::Migration[8.0]
def up
- Trip.find_each do |trip|
- trip.enqueue_calculation_jobs
- end
+ Trip.find_each(&:enqueue_calculation_jobs)
end
def down
diff --git a/db/migrate/20250910224538_add_sharing_fields_to_stats.rb b/db/migrate/20250910224538_add_sharing_fields_to_stats.rb
new file mode 100644
index 00000000..b3194d82
--- /dev/null
+++ b/db/migrate/20250910224538_add_sharing_fields_to_stats.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class AddSharingFieldsToStats < ActiveRecord::Migration[8.0]
+ def change
+ add_column :stats, :sharing_settings, :jsonb, default: {}
+ add_column :stats, :sharing_uuid, :uuid
+ end
+end
diff --git a/db/migrate/20250910224714_add_index_to_stats_share_uuid.rb b/db/migrate/20250910224714_add_index_to_stats_share_uuid.rb
new file mode 100644
index 00000000..6e1d0bc3
--- /dev/null
+++ b/db/migrate/20250910224714_add_index_to_stats_share_uuid.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class AddIndexToStatsShareUuid < ActiveRecord::Migration[8.0]
+ disable_ddl_transaction!
+
+ def change
+ add_index :stats, :sharing_uuid, unique: true, algorithm: :concurrently
+ end
+end
diff --git a/db/schema.rb b/db/schema.rb
index 93080ae7..cfcab1ea 100644
--- a/db/schema.rb
+++ b/db/schema.rb
@@ -10,7 +10,7 @@
#
# It's strongly recommended that you check this file into your version control system.
-ActiveRecord::Schema[8.0].define(version: 2025_09_05_120121) do
+ActiveRecord::Schema[8.0].define(version: 2025_09_10_224714) do
# These are extensions that must be enabled in order to support this database
enable_extension "pg_catalog.plpgsql"
enable_extension "postgis"
@@ -220,8 +220,11 @@ ActiveRecord::Schema[8.0].define(version: 2025_09_05_120121) do
t.datetime "updated_at", null: false
t.bigint "user_id", null: false
t.jsonb "daily_distance", default: {}
+ t.jsonb "sharing_settings", default: {}
+ t.uuid "sharing_uuid"
t.index ["distance"], name: "index_stats_on_distance"
t.index ["month"], name: "index_stats_on_month"
+ t.index ["sharing_uuid"], name: "index_stats_on_sharing_uuid", unique: true
t.index ["user_id"], name: "index_stats_on_user_id"
t.index ["year"], name: "index_stats_on_year"
end
diff --git a/spec/factories/stats.rb b/spec/factories/stats.rb
index 4a2ade2a..724ddbfa 100644
--- a/spec/factories/stats.rb
+++ b/spec/factories/stats.rb
@@ -6,6 +6,8 @@ FactoryBot.define do
month { 1 }
distance { 1000 } # 1 km
user
+ sharing_settings { {} }
+ sharing_uuid { SecureRandom.uuid }
toponyms do
[
{
@@ -16,5 +18,31 @@ FactoryBot.define do
}, { 'cities' => [], 'country' => nil }
]
end
+
+ trait :with_sharing_enabled do
+ after(:create) do |stat, _evaluator|
+ stat.enable_sharing!(expiration: 'permanent')
+ end
+ end
+
+ trait :with_sharing_disabled do
+ sharing_settings do
+ {
+ 'enabled' => false,
+ 'expiration' => nil,
+ 'expires_at' => nil
+ }
+ end
+ end
+
+ trait :with_sharing_expired do
+ sharing_settings do
+ {
+ 'enabled' => true,
+ 'expiration' => '1h',
+ 'expires_at' => 1.hour.ago.iso8601
+ }
+ end
+ end
end
end
diff --git a/spec/jobs/tracks/cleanup_job_spec.rb b/spec/jobs/tracks/cleanup_job_spec.rb
deleted file mode 100644
index 66cb6923..00000000
--- a/spec/jobs/tracks/cleanup_job_spec.rb
+++ /dev/null
@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Tracks::CleanupJob, type: :job do
- let(:user) { create(:user) }
-
- describe '#perform' do
- context 'with old untracked points' do
- let!(:old_points) do
- create_points_around(user: user, count: 1, base_lat: 20.0, timestamp: 2.days.ago.to_i)
- create_points_around(user: user, count: 1, base_lat: 20.0, timestamp: 1.day.ago.to_i)
- end
- let!(:recent_points) do
- create_points_around(user: user, count: 2, base_lat: 20.0, timestamp: 1.hour.ago.to_i)
- end
- let(:generator) { instance_double(Tracks::Generator) }
-
- it 'processes only old untracked points' do
- expect(Tracks::Generator).to receive(:new)
- .and_return(generator)
-
- expect(generator).to receive(:call)
-
- described_class.new.perform(older_than: 1.day.ago)
- end
- end
-
- context 'with users having insufficient points' do
- let!(:single_point) do
- create_points_around(user: user, count: 1, base_lat: 20.0, timestamp: 2.days.ago.to_i)
- end
-
- it 'skips users with less than 2 points' do
- expect(Tracks::Generator).not_to receive(:new)
-
- described_class.new.perform(older_than: 1.day.ago)
- end
- end
-
- context 'with no old untracked points' do
- let(:track) { create(:track, user: user) }
- let!(:tracked_points) do
- create_points_around(user: user, count: 3, base_lat: 20.0, timestamp: 2.days.ago.to_i, track: track)
- end
-
- it 'does not process any users' do
- expect(Tracks::Generator).not_to receive(:new)
-
- described_class.new.perform(older_than: 1.day.ago)
- end
- end
-
- context 'with custom older_than parameter' do
- let!(:points) do
- create_points_around(user: user, count: 3, base_lat: 20.0, timestamp: 3.days.ago.to_i)
- end
- let(:generator) { instance_double(Tracks::Generator) }
-
- it 'uses custom threshold' do
- expect(Tracks::Generator).to receive(:new)
- .and_return(generator)
-
- expect(generator).to receive(:call)
-
- described_class.new.perform(older_than: 2.days.ago)
- end
- end
- end
-
- describe 'job configuration' do
- it 'uses tracks queue' do
- expect(described_class.queue_name).to eq('tracks')
- end
-
- it 'does not retry on failure' do
- expect(described_class.sidekiq_options_hash['retry']).to be false
- end
- end
-end
diff --git a/spec/jobs/tracks/create_job_spec.rb b/spec/jobs/tracks/create_job_spec.rb
deleted file mode 100644
index b23fea8d..00000000
--- a/spec/jobs/tracks/create_job_spec.rb
+++ /dev/null
@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Tracks::CreateJob, type: :job do
- let(:user) { create(:user) }
-
- describe '#perform' do
- let(:generator_instance) { instance_double(Tracks::Generator) }
-
- before do
- allow(Tracks::Generator).to receive(:new).and_return(generator_instance)
- allow(generator_instance).to receive(:call)
- allow(generator_instance).to receive(:call).and_return(2)
- end
-
- it 'calls the generator and creates a notification' do
- described_class.new.perform(user.id)
-
- expect(Tracks::Generator).to have_received(:new).with(
- user,
- start_at: nil,
- end_at: nil,
- mode: :daily
- )
- expect(generator_instance).to have_received(:call)
- end
-
- context 'with custom parameters' do
- let(:start_at) { 1.day.ago.beginning_of_day.to_i }
- let(:end_at) { 1.day.ago.end_of_day.to_i }
- let(:mode) { :daily }
-
- before do
- allow(Tracks::Generator).to receive(:new).and_return(generator_instance)
- allow(generator_instance).to receive(:call)
- allow(generator_instance).to receive(:call).and_return(1)
- end
-
- it 'passes custom parameters to the generator' do
- described_class.new.perform(user.id, start_at: start_at, end_at: end_at, mode: mode)
-
- expect(Tracks::Generator).to have_received(:new).with(
- user,
- start_at: start_at,
- end_at: end_at,
- mode: :daily
- )
- expect(generator_instance).to have_received(:call)
- end
- end
-
- context 'when generator raises an error' do
- let(:error_message) { 'Something went wrong' }
-
- before do
- allow(Tracks::Generator).to receive(:new).and_return(generator_instance)
- allow(generator_instance).to receive(:call).and_raise(StandardError, error_message)
- allow(ExceptionReporter).to receive(:call)
- end
-
- it 'reports the error using ExceptionReporter' do
- allow(ExceptionReporter).to receive(:call)
-
- described_class.new.perform(user.id)
-
- expect(ExceptionReporter).to have_received(:call).with(
- kind_of(StandardError),
- 'Failed to create tracks for user'
- )
- end
- end
-
- context 'when user does not exist' do
- before do
- allow(User).to receive(:find).with(999).and_raise(ActiveRecord::RecordNotFound)
- allow(ExceptionReporter).to receive(:call)
- allow(Notifications::Create).to receive(:new).and_return(instance_double(Notifications::Create, call: nil))
- end
-
- it 'handles the error gracefully and creates error notification' do
- expect { described_class.new.perform(999) }.not_to raise_error
-
- expect(ExceptionReporter).to have_received(:call)
- end
- end
-
- context 'when tracks are deleted and recreated' do
- let(:existing_tracks) { create_list(:track, 3, user: user) }
-
- before do
- allow(generator_instance).to receive(:call).and_return(2)
- end
-
- it 'returns the correct count of newly created tracks' do
- described_class.new.perform(user.id, mode: :incremental)
-
- expect(Tracks::Generator).to have_received(:new).with(
- user,
- start_at: nil,
- end_at: nil,
- mode: :incremental
- )
- expect(generator_instance).to have_received(:call)
- end
- end
- end
-
- describe 'queue' do
- it 'is queued on tracks queue' do
- expect(described_class.new.queue_name).to eq('tracks')
- end
- end
-
- context 'when not self-hosted' do
- let(:generator_instance) { instance_double(Tracks::Generator) }
- let(:notification_service) { instance_double(Notifications::Create) }
- let(:error_message) { 'Something went wrong' }
-
- before do
- allow(DawarichSettings).to receive(:self_hosted?).and_return(false)
- allow(Tracks::Generator).to receive(:new).and_return(generator_instance)
- allow(generator_instance).to receive(:call).and_raise(StandardError, error_message)
- allow(Notifications::Create).to receive(:new).and_return(notification_service)
- allow(notification_service).to receive(:call)
- end
-
- it 'does not create a failure notification' do
- described_class.new.perform(user.id)
-
- expect(notification_service).not_to have_received(:call)
- end
- end
-end
diff --git a/spec/jobs/tracks/daily_generation_job_spec.rb b/spec/jobs/tracks/daily_generation_job_spec.rb
new file mode 100644
index 00000000..c23d9243
--- /dev/null
+++ b/spec/jobs/tracks/daily_generation_job_spec.rb
@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Tracks::DailyGenerationJob, type: :job do
+ describe '#perform' do
+ let!(:active_user) { create(:user, settings: { 'minutes_between_routes' => 60, 'meters_between_routes' => 500 }) }
+ let!(:trial_user) { create(:user, :trial) }
+ let!(:inactive_user) { create(:user, :inactive) }
+
+ let!(:active_user_old_track) do
+ create(:track, user: active_user, start_at: 2.days.ago, end_at: 2.days.ago + 1.hour)
+ end
+ let!(:active_user_new_points) do
+ create_list(:point, 3, user: active_user, timestamp: 1.hour.ago.to_i)
+ end
+
+ let!(:trial_user_old_track) do
+ create(:track, user: trial_user, start_at: 3.days.ago, end_at: 3.days.ago + 1.hour)
+ end
+ let!(:trial_user_new_points) do
+ create_list(:point, 2, user: trial_user, timestamp: 30.minutes.ago.to_i)
+ end
+
+ before do
+ active_user.update!(points_count: active_user.points.count)
+ trial_user.update!(points_count: trial_user.points.count)
+
+ ActiveJob::Base.queue_adapter.enqueued_jobs.clear
+ end
+
+ it 'processes all active and trial users' do
+ expect { described_class.perform_now }.to \
+ have_enqueued_job(Tracks::ParallelGeneratorJob).twice
+ end
+
+ it 'does not process inactive users' do
+ # Clear points and tracks to make destruction possible
+ Point.destroy_all
+ Track.destroy_all
+
+ # Remove active and trial users to isolate test
+ active_user.destroy
+ trial_user.destroy
+
+ expect do
+ described_class.perform_now
+ end.not_to have_enqueued_job(Tracks::ParallelGeneratorJob)
+ end
+
+ it 'enqueues correct number of parallel generation jobs for users with new points' do
+ expect { described_class.perform_now }.to \
+ have_enqueued_job(Tracks::ParallelGeneratorJob).exactly(2).times
+ end
+
+ it 'enqueues parallel generation job for active user with correct parameters' do
+ expect { described_class.perform_now }.to \
+ have_enqueued_job(Tracks::ParallelGeneratorJob).with(
+ active_user.id,
+ hash_including(mode: 'daily')
+ )
+ end
+
+ it 'enqueues parallel generation job for trial user' do
+ expect { described_class.perform_now }.to \
+ have_enqueued_job(Tracks::ParallelGeneratorJob).with(
+ trial_user.id,
+ hash_including(mode: 'daily')
+ )
+ end
+
+ it 'does not enqueue jobs for users without new points' do
+ Point.destroy_all
+
+ expect { described_class.perform_now }.not_to \
+ have_enqueued_job(Tracks::ParallelGeneratorJob)
+ end
+
+ context 'when processing fails' do
+ before do
+ allow_any_instance_of(User).to receive(:tracks).and_raise(StandardError, 'Database error')
+ allow(ExceptionReporter).to receive(:call)
+
+ active_user.update!(points_count: 5)
+ trial_user.update!(points_count: 3)
+ end
+ it 'does not raise errors when processing fails' do
+ expect { described_class.perform_now }.not_to raise_error
+ end
+
+ it 'reports exceptions when processing fails' do
+ described_class.perform_now
+
+ expect(ExceptionReporter).to have_received(:call).at_least(:once)
+ end
+ end
+
+ context 'when user has no points' do
+ let!(:empty_user) { create(:user) }
+
+ it 'skips users with no points' do
+ expect { described_class.perform_now }.not_to \
+ have_enqueued_job(Tracks::ParallelGeneratorJob).with(empty_user.id, any_args)
+ end
+ end
+
+ context 'when user has tracks but no new points' do
+ let!(:user_with_current_tracks) { create(:user) }
+ let!(:recent_points) { create_list(:point, 2, user: user_with_current_tracks, timestamp: 1.hour.ago.to_i) }
+ let!(:recent_track) do
+ create(:track, user: user_with_current_tracks, start_at: 1.hour.ago, end_at: 30.minutes.ago)
+ end
+
+ before do
+ user_with_current_tracks.update!(points_count: user_with_current_tracks.points.count)
+ end
+
+ it 'skips users without new points since last track' do
+ expect { described_class.perform_now }.not_to \
+ have_enqueued_job(Tracks::ParallelGeneratorJob).with(user_with_current_tracks.id, any_args)
+ end
+ end
+ end
+end
diff --git a/spec/jobs/tracks/incremental_check_job_spec.rb b/spec/jobs/tracks/incremental_check_job_spec.rb
deleted file mode 100644
index c25d1299..00000000
--- a/spec/jobs/tracks/incremental_check_job_spec.rb
+++ /dev/null
@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Tracks::IncrementalCheckJob, type: :job do
- let(:user) { create(:user) }
- let(:point) { create(:point, user: user) }
-
- describe '#perform' do
- context 'with valid parameters' do
- let(:processor) { instance_double(Tracks::IncrementalProcessor) }
-
- it 'calls the incremental processor' do
- expect(Tracks::IncrementalProcessor).to receive(:new)
- .with(user, point)
- .and_return(processor)
-
- expect(processor).to receive(:call)
-
- described_class.new.perform(user.id, point.id)
- end
- end
- end
-
- describe 'job configuration' do
- it 'uses tracks queue' do
- expect(described_class.queue_name).to eq('tracks')
- end
- end
-
- describe 'integration with ActiveJob' do
- it 'enqueues the job' do
- expect do
- described_class.perform_later(user.id, point.id)
- end.to have_enqueued_job(described_class)
- .with(user.id, point.id)
- end
- end
-end
diff --git a/spec/jobs/tracks/parallel_generator_job_spec.rb b/spec/jobs/tracks/parallel_generator_job_spec.rb
index 7428dd2c..75c34738 100644
--- a/spec/jobs/tracks/parallel_generator_job_spec.rb
+++ b/spec/jobs/tracks/parallel_generator_job_spec.rb
@@ -125,31 +125,10 @@ RSpec.describe Tracks::ParallelGeneratorJob do
describe 'integration with existing track job patterns' do
let!(:point) { create(:point, user: user, timestamp: 1.day.ago.to_i) }
- it 'follows the same notification pattern as Tracks::CreateJob' do
- # Compare with existing Tracks::CreateJob behavior
- # Should create similar notifications and handle errors similarly
-
- expect {
- job.perform(user.id)
- }.not_to raise_error
- end
-
it 'can be queued and executed' do
- expect {
+ expect do
described_class.perform_later(user.id)
- }.to have_enqueued_job(described_class).with(user.id)
- end
-
- it 'supports the same parameter structure as Tracks::CreateJob' do
- # Should accept the same parameters that would be passed to Tracks::CreateJob
- expect {
- described_class.perform_later(
- user.id,
- start_at: 1.week.ago,
- end_at: Time.current,
- mode: :daily
- )
- }.to have_enqueued_job(described_class)
+ end.to have_enqueued_job(described_class).with(user.id)
end
end
end
diff --git a/spec/jobs/users/mailer_sending_job_spec.rb b/spec/jobs/users/mailer_sending_job_spec.rb
index ba4b1de9..2df6afa2 100644
--- a/spec/jobs/users/mailer_sending_job_spec.rb
+++ b/spec/jobs/users/mailer_sending_job_spec.rb
@@ -111,9 +111,9 @@ RSpec.describe Users::MailerSendingJob, type: :job do
it 'raises ActiveRecord::RecordNotFound' do
user.destroy
- expect {
+ expect do
described_class.perform_now(user.id, 'welcome')
- }.to raise_error(ActiveRecord::RecordNotFound)
+ end.not_to raise_error
end
end
end
diff --git a/spec/models/stat_spec.rb b/spec/models/stat_spec.rb
index ee4c477f..e6a5cadb 100644
--- a/spec/models/stat_spec.rb
+++ b/spec/models/stat_spec.rb
@@ -102,5 +102,165 @@ RSpec.describe Stat, type: :model do
expect(subject).to eq(points)
end
end
+
+ describe '#calculate_data_bounds' do
+ let(:stat) { create(:stat, year: 2024, month: 6, user:) }
+ let(:user) { create(:user) }
+
+ context 'when stat has points' do
+ before do
+ # Create test points within the month (June 2024)
+ create(:point,
+ user:,
+ latitude: 40.6,
+ longitude: -74.1,
+ timestamp: Time.new(2024, 6, 1, 12, 0).to_i)
+ create(:point,
+ user:,
+ latitude: 40.8,
+ longitude: -73.9,
+ timestamp: Time.new(2024, 6, 15, 15, 0).to_i)
+ create(:point,
+ user:,
+ latitude: 40.7,
+ longitude: -74.0,
+ timestamp: Time.new(2024, 6, 30, 18, 0).to_i)
+
+ # Points outside the month (should be ignored)
+ create(:point,
+ user:,
+ latitude: 41.0,
+ longitude: -75.0,
+ timestamp: Time.new(2024, 5, 31, 23, 59).to_i) # May
+ create(:point,
+ user:,
+ latitude: 39.0,
+ longitude: -72.0,
+ timestamp: Time.new(2024, 7, 1, 0, 1).to_i) # July
+ end
+
+ it 'returns correct bounding box for points within the month' do
+ result = stat.calculate_data_bounds
+
+ expect(result).to be_a(Hash)
+ expect(result[:min_lat]).to eq(40.6)
+ expect(result[:max_lat]).to eq(40.8)
+ expect(result[:min_lng]).to eq(-74.1)
+ expect(result[:max_lng]).to eq(-73.9)
+ expect(result[:point_count]).to eq(3)
+ end
+
+ context 'with points from different users' do
+ let(:other_user) { create(:user) }
+
+ before do
+ # Add points from a different user (should be ignored)
+ create(:point,
+ user: other_user,
+ latitude: 50.0,
+ longitude: -80.0,
+ timestamp: Time.new(2024, 6, 15, 12, 0).to_i)
+ end
+
+ it 'only includes points from the stat user' do
+ result = stat.calculate_data_bounds
+
+ expect(result[:min_lat]).to eq(40.6)
+ expect(result[:max_lat]).to eq(40.8)
+ expect(result[:min_lng]).to eq(-74.1)
+ expect(result[:max_lng]).to eq(-73.9)
+ expect(result[:point_count]).to eq(3) # Still only 3 points from the stat user
+ end
+ end
+
+ context 'with single point' do
+ let(:single_point_user) { create(:user) }
+ let(:single_point_stat) { create(:stat, year: 2024, month: 7, user: single_point_user) }
+
+ before do
+ create(:point,
+ user: single_point_user,
+ latitude: 45.5,
+ longitude: -122.65,
+ timestamp: Time.new(2024, 7, 15, 14, 30).to_i)
+ end
+
+ it 'returns bounds with same min and max values' do
+ result = single_point_stat.calculate_data_bounds
+
+ expect(result[:min_lat]).to eq(45.5)
+ expect(result[:max_lat]).to eq(45.5)
+ expect(result[:min_lng]).to eq(-122.65)
+ expect(result[:max_lng]).to eq(-122.65)
+ expect(result[:point_count]).to eq(1)
+ end
+ end
+
+ context 'with edge case coordinates' do
+ let(:edge_user) { create(:user) }
+ let(:edge_stat) { create(:stat, year: 2024, month: 8, user: edge_user) }
+
+ before do
+ # Test with extreme coordinate values
+ create(:point,
+ user: edge_user,
+ latitude: -90.0, # South Pole
+ longitude: -180.0, # Date Line West
+ timestamp: Time.new(2024, 8, 1, 0, 0).to_i)
+ create(:point,
+ user: edge_user,
+ latitude: 90.0, # North Pole
+ longitude: 180.0, # Date Line East
+ timestamp: Time.new(2024, 8, 31, 23, 59).to_i)
+ end
+
+ it 'handles extreme coordinate values correctly' do
+ result = edge_stat.calculate_data_bounds
+
+ expect(result[:min_lat]).to eq(-90.0)
+ expect(result[:max_lat]).to eq(90.0)
+ expect(result[:min_lng]).to eq(-180.0)
+ expect(result[:max_lng]).to eq(180.0)
+ expect(result[:point_count]).to eq(2)
+ end
+ end
+ end
+
+ context 'when stat has no points' do
+ let(:empty_user) { create(:user) }
+ let(:empty_stat) { create(:stat, year: 2024, month: 10, user: empty_user) }
+
+ it 'returns nil' do
+ result = empty_stat.calculate_data_bounds
+
+ expect(result).to be_nil
+ end
+ end
+
+ context 'when stat has points but none within the month timeframe' do
+ let(:empty_month_user) { create(:user) }
+ let(:empty_month_stat) { create(:stat, year: 2024, month: 9, user: empty_month_user) }
+
+ before do
+ # Create points outside the target month
+ create(:point,
+ user: empty_month_user,
+ latitude: 40.7,
+ longitude: -74.0,
+ timestamp: Time.new(2024, 8, 31, 23, 59).to_i) # August
+ create(:point,
+ user: empty_month_user,
+ latitude: 40.8,
+ longitude: -73.9,
+ timestamp: Time.new(2024, 10, 1, 0, 1).to_i) # October
+ end
+
+ it 'returns nil when no points exist in the month' do
+ result = empty_month_stat.calculate_data_bounds
+
+ expect(result).to be_nil
+ end
+ end
+ end
end
end
diff --git a/spec/models/user_spec.rb b/spec/models/user_spec.rb
index 94c225c5..928df596 100644
--- a/spec/models/user_spec.rb
+++ b/spec/models/user_spec.rb
@@ -329,5 +329,11 @@ RSpec.describe User, type: :model do
expect { user.export_data }.to have_enqueued_job(Users::ExportDataJob).with(user.id)
end
end
+
+ describe '#timezone' do
+ it 'returns the app timezone' do
+ expect(user.timezone).to eq(Time.zone.name)
+ end
+ end
end
end
diff --git a/spec/queries/hexagon_query_spec.rb b/spec/queries/hexagon_query_spec.rb
new file mode 100644
index 00000000..b9bf8183
--- /dev/null
+++ b/spec/queries/hexagon_query_spec.rb
@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe HexagonQuery, type: :query do
+ let(:user) { create(:user) }
+ let(:min_lon) { -74.1 }
+ let(:min_lat) { 40.6 }
+ let(:max_lon) { -73.9 }
+ let(:max_lat) { 40.8 }
+ let(:hex_size) { 500 }
+
+ describe '#initialize' do
+ it 'sets required parameters' do
+ query = described_class.new(
+ min_lon: min_lon,
+ min_lat: min_lat,
+ max_lon: max_lon,
+ max_lat: max_lat,
+ hex_size: hex_size
+ )
+
+ expect(query.min_lon).to eq(min_lon)
+ expect(query.min_lat).to eq(min_lat)
+ expect(query.max_lon).to eq(max_lon)
+ expect(query.max_lat).to eq(max_lat)
+ expect(query.hex_size).to eq(hex_size)
+ end
+
+ it 'sets optional parameters' do
+ start_date = '2024-06-01T00:00:00Z'
+ end_date = '2024-06-30T23:59:59Z'
+
+ query = described_class.new(
+ min_lon: min_lon,
+ min_lat: min_lat,
+ max_lon: max_lon,
+ max_lat: max_lat,
+ hex_size: hex_size,
+ user_id: user.id,
+ start_date: start_date,
+ end_date: end_date
+ )
+
+ expect(query.user_id).to eq(user.id)
+ expect(query.start_date).to eq(start_date)
+ expect(query.end_date).to eq(end_date)
+ end
+ end
+
+ describe '#call' do
+ let(:query) do
+ described_class.new(
+ min_lon: min_lon,
+ min_lat: min_lat,
+ max_lon: max_lon,
+ max_lat: max_lat,
+ hex_size: hex_size,
+ user_id: user.id
+ )
+ end
+
+ context 'with no points' do
+ it 'executes without error and returns empty result' do
+ result = query.call
+ expect(result.to_a).to be_empty
+ end
+ end
+
+ context 'with points in bounding box' do
+ before do
+ # Create test points within the bounding box
+ create(:point,
+ user:,
+ latitude: 40.7,
+ longitude: -74.0,
+ timestamp: Time.new(2024, 6, 15, 12, 0).to_i)
+ create(:point,
+ user:,
+ latitude: 40.75,
+ longitude: -73.95,
+ timestamp: Time.new(2024, 6, 16, 14, 0).to_i)
+ end
+
+ it 'returns hexagon results with expected structure' do
+ result = query.call
+ result_array = result.to_a
+
+ expect(result_array).not_to be_empty
+
+ first_hex = result_array.first
+ expect(first_hex).to have_key('geojson')
+ expect(first_hex).to have_key('hex_i')
+ expect(first_hex).to have_key('hex_j')
+ expect(first_hex).to have_key('point_count')
+ expect(first_hex).to have_key('earliest_point')
+ expect(first_hex).to have_key('latest_point')
+ expect(first_hex).to have_key('id')
+
+ # Verify geojson can be parsed
+ geojson = JSON.parse(first_hex['geojson'])
+ expect(geojson).to have_key('type')
+ expect(geojson).to have_key('coordinates')
+ end
+
+ it 'filters by user_id correctly' do
+ other_user = create(:user)
+ # Create points for a different user (should be excluded)
+ create(:point,
+ user: other_user,
+ latitude: 40.72,
+ longitude: -73.98,
+ timestamp: Time.new(2024, 6, 17, 16, 0).to_i)
+
+ result = query.call
+ result_array = result.to_a
+
+ # Should only include hexagons with the specified user's points
+ total_points = result_array.sum { |row| row['point_count'].to_i }
+ expect(total_points).to eq(2) # Only the 2 points from our user
+ end
+ end
+
+ context 'with date filtering' do
+ let(:query_with_dates) do
+ described_class.new(
+ min_lon: min_lon,
+ min_lat: min_lat,
+ max_lon: max_lon,
+ max_lat: max_lat,
+ hex_size: hex_size,
+ user_id: user.id,
+ start_date: '2024-06-15T00:00:00Z',
+ end_date: '2024-06-16T23:59:59Z'
+ )
+ end
+
+ before do
+ # Create points within and outside the date range
+ create(:point,
+ user:,
+ latitude: 40.7,
+ longitude: -74.0,
+ timestamp: Time.new(2024, 6, 15, 12, 0).to_i) # Within range
+ create(:point,
+ user:,
+ latitude: 40.71,
+ longitude: -74.01,
+ timestamp: Time.new(2024, 6, 20, 12, 0).to_i) # Outside range
+ end
+
+ it 'filters points by date range' do
+ result = query_with_dates.call
+ result_array = result.to_a
+
+ expect(result_array).not_to be_empty
+
+ # Should only include the point within the date range
+ total_points = result_array.sum { |row| row['point_count'].to_i }
+ expect(total_points).to eq(1)
+ end
+ end
+
+ context 'without user_id filter' do
+ let(:query_no_user) do
+ described_class.new(
+ min_lon: min_lon,
+ min_lat: min_lat,
+ max_lon: max_lon,
+ max_lat: max_lat,
+ hex_size: hex_size
+ )
+ end
+
+ before do
+ user1 = create(:user)
+ user2 = create(:user)
+
+ create(:point, user: user1, latitude: 40.7, longitude: -74.0, timestamp: Time.current.to_i)
+ create(:point, user: user2, latitude: 40.75, longitude: -73.95, timestamp: Time.current.to_i)
+ end
+
+ it 'includes points from all users' do
+ result = query_no_user.call
+ result_array = result.to_a
+
+ expect(result_array).not_to be_empty
+
+ # Should include points from both users
+ total_points = result_array.sum { |row| row['point_count'].to_i }
+ expect(total_points).to eq(2)
+ end
+ end
+ end
+
+ describe '#build_date_filter (private method behavior)' do
+ context 'when testing date filter behavior through query execution' do
+ it 'works correctly with start_date only' do
+ query = described_class.new(
+ min_lon: min_lon,
+ min_lat: min_lat,
+ max_lon: max_lon,
+ max_lat: max_lat,
+ hex_size: hex_size,
+ user_id: user.id,
+ start_date: '2024-06-15T00:00:00Z'
+ )
+
+ # Should execute without SQL syntax errors
+ expect { query.call }.not_to raise_error
+ end
+
+ it 'works correctly with end_date only' do
+ query = described_class.new(
+ min_lon: min_lon,
+ min_lat: min_lat,
+ max_lon: max_lon,
+ max_lat: max_lat,
+ hex_size: hex_size,
+ user_id: user.id,
+ end_date: '2024-06-30T23:59:59Z'
+ )
+
+ # Should execute without SQL syntax errors
+ expect { query.call }.not_to raise_error
+ end
+
+ it 'works correctly with both start_date and end_date' do
+ query = described_class.new(
+ min_lon: min_lon,
+ min_lat: min_lat,
+ max_lon: max_lon,
+ max_lat: max_lat,
+ hex_size: hex_size,
+ user_id: user.id,
+ start_date: '2024-06-01T00:00:00Z',
+ end_date: '2024-06-30T23:59:59Z'
+ )
+
+ # Should execute without SQL syntax errors
+ expect { query.call }.not_to raise_error
+ end
+ end
+ end
+end
\ No newline at end of file
diff --git a/spec/requests/api/v1/areas_spec.rb b/spec/requests/api/v1/areas_spec.rb
index 7be57513..c5f15948 100644
--- a/spec/requests/api/v1/areas_spec.rb
+++ b/spec/requests/api/v1/areas_spec.rb
@@ -49,7 +49,7 @@ RSpec.describe '/api/v1/areas', type: :request do
post api_v1_areas_url, headers: { 'Authorization' => "Bearer #{user.api_key}" },
params: { area: invalid_attributes }
- expect(response).to have_http_status(:unprocessable_entity)
+ expect(response).to have_http_status(:unprocessable_content)
end
end
end
@@ -85,7 +85,7 @@ RSpec.describe '/api/v1/areas', type: :request do
patch api_v1_area_url(area), headers: { 'Authorization' => "Bearer #{user.api_key}" },
params: { area: invalid_attributes }
- expect(response).to have_http_status(:unprocessable_entity)
+ expect(response).to have_http_status(:unprocessable_content)
end
end
end
diff --git a/spec/requests/api/v1/maps/hexagons_spec.rb b/spec/requests/api/v1/maps/hexagons_spec.rb
new file mode 100644
index 00000000..f3750cf8
--- /dev/null
+++ b/spec/requests/api/v1/maps/hexagons_spec.rb
@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe 'Api::V1::Maps::Hexagons', type: :request do
+ let(:user) { create(:user) }
+
+ before do
+ stub_request(:any, 'https://api.github.com/repos/Freika/dawarich/tags')
+ .to_return(status: 200, body: '[{"name": "1.0.0"}]', headers: {})
+ end
+
+ describe 'GET /api/v1/maps/hexagons' do
+ let(:valid_params) do
+ {
+ min_lon: -74.1,
+ min_lat: 40.6,
+ max_lon: -73.9,
+ max_lat: 40.8,
+ hex_size: 1000,
+ start_date: '2024-06-01T00:00:00Z',
+ end_date: '2024-06-30T23:59:59Z'
+ }
+ end
+
+ context 'with valid API key authentication' do
+ let(:headers) { { 'Authorization' => "Bearer #{user.api_key}" } }
+
+ before do
+ # Create test points within the date range and bounding box
+ 10.times do |i|
+ create(:point,
+ user:,
+ latitude: 40.7 + (i * 0.001), # Slightly different coordinates
+ longitude: -74.0 + (i * 0.001),
+ timestamp: Time.new(2024, 6, 15, 12, i).to_i) # Different times
+ end
+ end
+
+ it 'returns hexagon data successfully' do
+ get '/api/v1/maps/hexagons', params: valid_params, headers: headers
+
+ expect(response).to have_http_status(:success)
+
+ json_response = JSON.parse(response.body)
+ expect(json_response).to have_key('type')
+ expect(json_response['type']).to eq('FeatureCollection')
+ expect(json_response).to have_key('features')
+ expect(json_response['features']).to be_an(Array)
+ end
+
+ it 'requires all bbox parameters' do
+ incomplete_params = valid_params.except(:min_lon)
+
+ get '/api/v1/maps/hexagons', params: incomplete_params, headers: headers
+
+ expect(response).to have_http_status(:bad_request)
+
+ json_response = JSON.parse(response.body)
+ expect(json_response['error']).to include('Missing required parameters')
+ expect(json_response['error']).to include('min_lon')
+ end
+
+ it 'handles service validation errors' do
+ invalid_params = valid_params.merge(min_lon: 200) # Invalid longitude
+
+ get '/api/v1/maps/hexagons', params: invalid_params, headers: headers
+
+ expect(response).to have_http_status(:bad_request)
+ end
+
+ it 'uses custom hex_size when provided' do
+ custom_params = valid_params.merge(hex_size: 500)
+
+ get '/api/v1/maps/hexagons', params: custom_params, headers: headers
+
+ expect(response).to have_http_status(:success)
+ end
+ end
+
+ context 'with public sharing UUID' do
+ let(:stat) { create(:stat, :with_sharing_enabled, user:, year: 2024, month: 6) }
+ let(:uuid_params) { valid_params.merge(uuid: stat.sharing_uuid) }
+
+ before do
+ # Create test points within the stat's month
+ 15.times do |i|
+ create(:point,
+ user:,
+ latitude: 40.7 + (i * 0.002),
+ longitude: -74.0 + (i * 0.002),
+ timestamp: Time.new(2024, 6, 20, 10, i).to_i)
+ end
+ end
+
+ it 'returns hexagon data without API key' do
+ get '/api/v1/maps/hexagons', params: uuid_params
+
+ expect(response).to have_http_status(:success)
+
+ json_response = JSON.parse(response.body)
+ expect(json_response).to have_key('type')
+ expect(json_response['type']).to eq('FeatureCollection')
+ expect(json_response).to have_key('features')
+ end
+
+ it 'uses stat date range automatically' do
+ # Points outside the stat's month should not be included
+ 5.times do |i|
+ create(:point,
+ user:,
+ latitude: 40.7 + (i * 0.003),
+ longitude: -74.0 + (i * 0.003),
+ timestamp: Time.new(2024, 7, 1, 8, i).to_i) # July points
+ end
+
+ get '/api/v1/maps/hexagons', params: uuid_params
+
+ expect(response).to have_http_status(:success)
+ end
+
+ context 'with invalid sharing UUID' do
+ it 'returns not found' do
+ invalid_uuid_params = valid_params.merge(uuid: 'invalid-uuid')
+
+ get '/api/v1/maps/hexagons', params: invalid_uuid_params
+
+ expect(response).to have_http_status(:not_found)
+
+ json_response = JSON.parse(response.body)
+ expect(json_response['error']).to eq('Shared stats not found or no longer available')
+ end
+ end
+
+ context 'with expired sharing' do
+ let(:stat) { create(:stat, :with_sharing_expired, user:, year: 2024, month: 6) }
+
+ it 'returns not found' do
+ get '/api/v1/maps/hexagons', params: uuid_params
+
+ expect(response).to have_http_status(:not_found)
+
+ json_response = JSON.parse(response.body)
+ expect(json_response['error']).to eq('Shared stats not found or no longer available')
+ end
+ end
+
+ context 'with disabled sharing' do
+ let(:stat) { create(:stat, :with_sharing_disabled, user:, year: 2024, month: 6) }
+
+ it 'returns not found' do
+ get '/api/v1/maps/hexagons', params: uuid_params
+
+ expect(response).to have_http_status(:not_found)
+
+ json_response = JSON.parse(response.body)
+ expect(json_response['error']).to eq('Shared stats not found or no longer available')
+ end
+ end
+ end
+
+ context 'without authentication' do
+ it 'returns unauthorized' do
+ get '/api/v1/maps/hexagons', params: valid_params
+
+ expect(response).to have_http_status(:unauthorized)
+ end
+ end
+
+ context 'with invalid API key' do
+ let(:headers) { { 'Authorization' => 'Bearer invalid-key' } }
+
+ it 'returns unauthorized' do
+ get '/api/v1/maps/hexagons', params: valid_params, headers: headers
+
+ expect(response).to have_http_status(:unauthorized)
+ end
+ end
+ end
+
+ describe 'GET /api/v1/maps/hexagons/bounds' do
+ context 'with valid API key authentication' do
+ let(:headers) { { 'Authorization' => "Bearer #{user.api_key}" } }
+ let(:date_params) do
+ {
+ start_date: Time.new(2024, 6, 1).to_i,
+ end_date: Time.new(2024, 6, 30, 23, 59, 59).to_i
+ }
+ end
+
+ before do
+ # Create test points within the date range
+ create(:point, user:, latitude: 40.6, longitude: -74.1, timestamp: Time.new(2024, 6, 1, 12, 0).to_i)
+ create(:point, user:, latitude: 40.8, longitude: -73.9, timestamp: Time.new(2024, 6, 30, 15, 0).to_i)
+ create(:point, user:, latitude: 40.7, longitude: -74.0, timestamp: Time.new(2024, 6, 15, 10, 0).to_i)
+ end
+
+ it 'returns bounding box for user data' do
+ get '/api/v1/maps/hexagons/bounds', params: date_params, headers: headers
+
+ expect(response).to have_http_status(:success)
+
+ json_response = JSON.parse(response.body)
+ expect(json_response).to include('min_lat', 'max_lat', 'min_lng', 'max_lng', 'point_count')
+ expect(json_response['min_lat']).to eq(40.6)
+ expect(json_response['max_lat']).to eq(40.8)
+ expect(json_response['min_lng']).to eq(-74.1)
+ expect(json_response['max_lng']).to eq(-73.9)
+ expect(json_response['point_count']).to eq(3)
+ end
+
+ it 'returns not found when no points exist in date range' do
+ get '/api/v1/maps/hexagons/bounds',
+ params: { start_date: '2023-01-01T00:00:00Z', end_date: '2023-01-31T23:59:59Z' },
+ headers: headers
+
+ expect(response).to have_http_status(:not_found)
+
+ json_response = JSON.parse(response.body)
+ expect(json_response['error']).to eq('No data found for the specified date range')
+ expect(json_response['point_count']).to eq(0)
+ end
+ end
+
+ context 'with public sharing UUID' do
+ let(:stat) { create(:stat, :with_sharing_enabled, user:, year: 2024, month: 6) }
+
+ before do
+ # Create test points within the stat's month
+ create(:point, user:, latitude: 41.0, longitude: -74.5, timestamp: Time.new(2024, 6, 5, 9, 0).to_i)
+ create(:point, user:, latitude: 41.2, longitude: -74.2, timestamp: Time.new(2024, 6, 25, 14, 0).to_i)
+ end
+
+ it 'returns bounds for the shared stat period' do
+ get '/api/v1/maps/hexagons/bounds', params: { uuid: stat.sharing_uuid }
+
+ expect(response).to have_http_status(:success)
+
+ json_response = JSON.parse(response.body)
+ expect(json_response).to include('min_lat', 'max_lat', 'min_lng', 'max_lng', 'point_count')
+ expect(json_response['min_lat']).to eq(41.0)
+ expect(json_response['max_lat']).to eq(41.2)
+ expect(json_response['point_count']).to eq(2)
+ end
+
+ context 'with invalid sharing UUID' do
+ it 'returns not found' do
+ get '/api/v1/maps/hexagons/bounds', params: { uuid: 'invalid-uuid' }
+
+ expect(response).to have_http_status(:not_found)
+
+ json_response = JSON.parse(response.body)
+ expect(json_response['error']).to eq('Shared stats not found or no longer available')
+ end
+ end
+ end
+
+ context 'without authentication' do
+ it 'returns unauthorized' do
+ get '/api/v1/maps/hexagons/bounds',
+ params: { start_date: '2024-06-01T00:00:00Z', end_date: '2024-06-30T23:59:59Z' }
+
+ expect(response).to have_http_status(:unauthorized)
+ end
+ end
+ end
+end
diff --git a/spec/requests/api/v1/settings_spec.rb b/spec/requests/api/v1/settings_spec.rb
index 3f6673e5..470563b7 100644
--- a/spec/requests/api/v1/settings_spec.rb
+++ b/spec/requests/api/v1/settings_spec.rb
@@ -47,7 +47,7 @@ RSpec.describe 'Api::V1::Settings', type: :request do
it 'returns http unprocessable entity' do
patch "/api/v1/settings?api_key=#{api_key}", params: { settings: { route_opacity: 'invalid' } }
- expect(response).to have_http_status(:unprocessable_entity)
+ expect(response).to have_http_status(:unprocessable_content)
end
it 'returns an error message' do
diff --git a/spec/requests/api/v1/subscriptions_spec.rb b/spec/requests/api/v1/subscriptions_spec.rb
index 85e657e4..19fea01c 100644
--- a/spec/requests/api/v1/subscriptions_spec.rb
+++ b/spec/requests/api/v1/subscriptions_spec.rb
@@ -102,7 +102,7 @@ RSpec.describe 'Api::V1::Subscriptions', type: :request do
post '/api/v1/subscriptions/callback', params: { token: token }
- expect(response).to have_http_status(:unprocessable_entity)
+ expect(response).to have_http_status(:unprocessable_content)
expect(JSON.parse(response.body)['message']).to eq('Invalid subscription data received.')
end
end
diff --git a/spec/requests/api/v1/visits_spec.rb b/spec/requests/api/v1/visits_spec.rb
index a250635c..d5e9317a 100644
--- a/spec/requests/api/v1/visits_spec.rb
+++ b/spec/requests/api/v1/visits_spec.rb
@@ -81,9 +81,9 @@ RSpec.describe 'Api::V1::Visits', type: :request do
let(:existing_place) { create(:place, latitude: 52.52, longitude: 13.405) }
it 'creates a new visit' do
- expect {
+ expect do
post '/api/v1/visits', params: valid_create_params, headers: auth_headers
- }.to change { user.visits.count }.by(1)
+ end.to change { user.visits.count }.by(1)
expect(response).to have_http_status(:ok)
end
@@ -100,9 +100,9 @@ RSpec.describe 'Api::V1::Visits', type: :request do
end
it 'creates a place for the visit' do
- expect {
+ expect do
post '/api/v1/visits', params: valid_create_params, headers: auth_headers
- }.to change { Place.count }.by(1)
+ end.to change { Place.count }.by(1)
created_place = Place.last
expect(created_place.name).to eq('Test Visit')
@@ -114,9 +114,9 @@ RSpec.describe 'Api::V1::Visits', type: :request do
it 'reuses existing place when coordinates are exactly the same' do
create(:visit, user: user, place: existing_place)
- expect {
+ expect do
post '/api/v1/visits', params: valid_create_params, headers: auth_headers
- }.not_to change { Place.count }
+ end.not_to(change { Place.count })
json_response = JSON.parse(response.body)
expect(json_response['place']['id']).to eq(existing_place.id)
@@ -132,7 +132,7 @@ RSpec.describe 'Api::V1::Visits', type: :request do
it 'returns unprocessable entity status' do
post '/api/v1/visits', params: missing_name_params, headers: auth_headers
- expect(response).to have_http_status(:unprocessable_entity)
+ expect(response).to have_http_status(:unprocessable_content)
end
it 'returns error message' do
@@ -144,9 +144,9 @@ RSpec.describe 'Api::V1::Visits', type: :request do
end
it 'does not create a visit' do
- expect {
+ expect do
post '/api/v1/visits', params: missing_name_params, headers: auth_headers
- }.not_to change { Visit.count }
+ end.not_to(change { Visit.count })
end
end
end
@@ -199,7 +199,7 @@ RSpec.describe 'Api::V1::Visits', type: :request do
it 'renders a JSON response with errors for the visit' do
put "/api/v1/visits/#{visit.id}", params: invalid_attributes, headers: auth_headers
- expect(response).to have_http_status(:unprocessable_entity)
+ expect(response).to have_http_status(:unprocessable_content)
end
end
end
@@ -234,7 +234,7 @@ RSpec.describe 'Api::V1::Visits', type: :request do
it 'returns an error when fewer than 2 visits are specified' do
post '/api/v1/visits/merge', params: { visit_ids: [visit1.id] }, headers: auth_headers
- expect(response).to have_http_status(:unprocessable_entity)
+ expect(response).to have_http_status(:unprocessable_content)
json_response = JSON.parse(response.body)
expect(json_response['error']).to include('At least 2 visits must be selected')
end
@@ -264,7 +264,7 @@ RSpec.describe 'Api::V1::Visits', type: :request do
post '/api/v1/visits/merge', params: { visit_ids: [visit1.id, visit2.id] }, headers: auth_headers
- expect(response).to have_http_status(:unprocessable_entity)
+ expect(response).to have_http_status(:unprocessable_content)
json_response = JSON.parse(response.body)
expect(json_response['error']).to include('Failed to merge visits')
end
@@ -316,7 +316,7 @@ RSpec.describe 'Api::V1::Visits', type: :request do
post '/api/v1/visits/bulk_update', params: invalid_update_params, headers: auth_headers
- expect(response).to have_http_status(:unprocessable_entity)
+ expect(response).to have_http_status(:unprocessable_content)
json_response = JSON.parse(response.body)
expect(json_response['error']).to include('Invalid status')
end
@@ -329,9 +329,9 @@ RSpec.describe 'Api::V1::Visits', type: :request do
context 'when visit exists and belongs to current user' do
it 'deletes the visit' do
- expect {
+ expect do
delete "/api/v1/visits/#{visit.id}", headers: auth_headers
- }.to change { user.visits.count }.by(-1)
+ end.to change { user.visits.count }.by(-1)
expect(response).to have_http_status(:no_content)
end
@@ -363,9 +363,9 @@ RSpec.describe 'Api::V1::Visits', type: :request do
end
it 'does not delete the visit' do
- expect {
+ expect do
delete "/api/v1/visits/#{other_user_visit.id}", headers: auth_headers
- }.not_to change { Visit.count }
+ end.not_to(change { Visit.count })
end
end
diff --git a/spec/requests/exports_spec.rb b/spec/requests/exports_spec.rb
index 89658348..8fd9f43c 100644
--- a/spec/requests/exports_spec.rb
+++ b/spec/requests/exports_spec.rb
@@ -70,7 +70,7 @@ RSpec.describe '/exports', type: :request do
it 'renders a response with 422 status (i.e. to display the "new" template)' do
post(exports_url, params:)
- expect(response).to have_http_status(:unprocessable_entity)
+ expect(response).to have_http_status(:unprocessable_content)
end
end
end
diff --git a/spec/requests/imports_spec.rb b/spec/requests/imports_spec.rb
index 56eb3333..09481269 100644
--- a/spec/requests/imports_spec.rb
+++ b/spec/requests/imports_spec.rb
@@ -62,9 +62,10 @@ RSpec.describe 'Imports', type: :request do
end
it 'prevents viewing other users import' do
- expect {
- get import_path(other_import)
- }.to raise_error(Pundit::NotAuthorizedError)
+ get import_path(other_import)
+
+ expect(response).to redirect_to(root_path)
+ expect(flash[:alert]).to eq('You are not authorized to perform this action.')
end
end
@@ -98,9 +99,10 @@ RSpec.describe 'Imports', type: :request do
end
it 'prevents access to new import form' do
- expect {
- get new_import_path
- }.to raise_error(Pundit::NotAuthorizedError)
+ get new_import_path
+
+ expect(response).to redirect_to(root_path)
+ expect(flash[:alert]).to eq('You are not authorized to perform this action.')
end
end
diff --git a/spec/requests/settings/background_jobs_spec.rb b/spec/requests/settings/background_jobs_spec.rb
index 64b415af..f2bea2cd 100644
--- a/spec/requests/settings/background_jobs_spec.rb
+++ b/spec/requests/settings/background_jobs_spec.rb
@@ -18,7 +18,7 @@ RSpec.describe '/settings/background_jobs', type: :request do
get settings_background_jobs_url
expect(response).to redirect_to(root_url)
- expect(flash[:notice]).to eq('You are not authorized to perform this action.')
+ expect(flash[:alert]).to eq('You are not authorized to perform this action.')
end
end
@@ -32,7 +32,7 @@ RSpec.describe '/settings/background_jobs', type: :request do
get settings_background_jobs_url
expect(response).to redirect_to(root_url)
- expect(flash[:notice]).to eq('You are not authorized to perform this action.')
+ expect(flash[:alert]).to eq('You are not authorized to perform this action.')
end
context 'when job name is start_immich_import' do
@@ -104,7 +104,7 @@ RSpec.describe '/settings/background_jobs', type: :request do
get settings_background_jobs_url
expect(response).to redirect_to(root_url)
- expect(flash[:notice]).to eq('You are not authorized to perform this action.')
+ expect(flash[:alert]).to eq('You are not authorized to perform this action.')
end
end
@@ -118,7 +118,7 @@ RSpec.describe '/settings/background_jobs', type: :request do
get settings_background_jobs_url
expect(response).to redirect_to(root_url)
- expect(flash[:notice]).to eq('You are not authorized to perform this action.')
+ expect(flash[:alert]).to eq('You are not authorized to perform this action.')
end
context 'when user is an admin' do
@@ -128,7 +128,7 @@ RSpec.describe '/settings/background_jobs', type: :request do
get settings_background_jobs_url
expect(response).to redirect_to(root_url)
- expect(flash[:notice]).to eq('You are not authorized to perform this action.')
+ expect(flash[:alert]).to eq('You are not authorized to perform this action.')
end
end
end
@@ -138,7 +138,7 @@ RSpec.describe '/settings/background_jobs', type: :request do
post settings_background_jobs_url, params: { job_name: 'start_reverse_geocoding' }
expect(response).to redirect_to(root_url)
- expect(flash[:notice]).to eq('You are not authorized to perform this action.')
+ expect(flash[:alert]).to eq('You are not authorized to perform this action.')
end
context 'when job name is start_immich_import' do
@@ -146,7 +146,7 @@ RSpec.describe '/settings/background_jobs', type: :request do
post settings_background_jobs_url, params: { job_name: 'start_immich_import' }
expect(response).to redirect_to(root_url)
- expect(flash[:notice]).to eq('You are not authorized to perform this action.')
+ expect(flash[:alert]).to eq('You are not authorized to perform this action.')
end
end
@@ -155,7 +155,7 @@ RSpec.describe '/settings/background_jobs', type: :request do
post settings_background_jobs_url, params: { job_name: 'start_photoprism_import' }
expect(response).to redirect_to(root_url)
- expect(flash[:notice]).to eq('You are not authorized to perform this action.')
+ expect(flash[:alert]).to eq('You are not authorized to perform this action.')
end
end
@@ -166,7 +166,7 @@ RSpec.describe '/settings/background_jobs', type: :request do
get settings_background_jobs_url
expect(response).to redirect_to(root_url)
- expect(flash[:notice]).to eq('You are not authorized to perform this action.')
+ expect(flash[:alert]).to eq('You are not authorized to perform this action.')
end
end
end
diff --git a/spec/requests/settings/users_spec.rb b/spec/requests/settings/users_spec.rb
index 51079587..2ef8a6a6 100644
--- a/spec/requests/settings/users_spec.rb
+++ b/spec/requests/settings/users_spec.rb
@@ -64,7 +64,7 @@ RSpec.describe '/settings/users', type: :request do
it 'renders a response with 422 status (i.e. to display the "new" template)' do
post settings_users_url, params: { user: invalid_attributes }
- expect(response).to have_http_status(:unprocessable_entity)
+ expect(response).to have_http_status(:unprocessable_content)
end
end
end
@@ -101,7 +101,7 @@ RSpec.describe '/settings/users', type: :request do
get settings_users_url
expect(response).to redirect_to(root_url)
- expect(flash[:notice]).to eq('You are not authorized to perform this action.')
+ expect(flash[:alert]).to eq('You are not authorized to perform this action.')
end
end
@@ -110,7 +110,7 @@ RSpec.describe '/settings/users', type: :request do
post settings_users_url, params: { user: valid_attributes }
expect(response).to redirect_to(root_url)
- expect(flash[:notice]).to eq('You are not authorized to perform this action.')
+ expect(flash[:alert]).to eq('You are not authorized to perform this action.')
end
end
@@ -121,7 +121,7 @@ RSpec.describe '/settings/users', type: :request do
patch settings_user_url(user), params: { user: valid_attributes }
expect(response).to redirect_to(root_url)
- expect(flash[:notice]).to eq('You are not authorized to perform this action.')
+ expect(flash[:alert]).to eq('You are not authorized to perform this action.')
end
end
end
diff --git a/spec/requests/shared/stats_spec.rb b/spec/requests/shared/stats_spec.rb
new file mode 100644
index 00000000..cf711b54
--- /dev/null
+++ b/spec/requests/shared/stats_spec.rb
@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe 'Shared::Stats', type: :request do
+ before do
+ stub_request(:any, 'https://api.github.com/repos/Freika/dawarich/tags')
+ .to_return(status: 200, body: '[{"name": "1.0.0"}]', headers: {})
+ end
+
+ context 'public sharing' do
+ let(:user) { create(:user) }
+ let(:stat) { create(:stat, :with_sharing_enabled, user:, year: 2024, month: 6) }
+
+ describe 'GET /shared/stats/:uuid' do
+ context 'with valid sharing UUID' do
+ before do
+ # Create some test points for data bounds calculation
+ create_list(:point, 5, user:, timestamp: Time.new(2024, 6, 15).to_i)
+ end
+
+ it 'renders the public month view' do
+ get shared_stat_url(stat.sharing_uuid)
+
+ expect(response).to have_http_status(:success)
+ expect(response.body).to include('Monthly Digest')
+ expect(response.body).to include('June 2024')
+ end
+
+ it 'includes required content in response' do
+ get shared_stat_url(stat.sharing_uuid)
+
+ expect(response.body).to include('June 2024')
+ expect(response.body).to include('Monthly Digest')
+ expect(response.body).to include('data-public-stat-map-uuid-value')
+ expect(response.body).to include(stat.sharing_uuid)
+ end
+ end
+
+ context 'with invalid sharing UUID' do
+ it 'redirects to root with alert' do
+ get shared_stat_url('invalid-uuid')
+
+ expect(response).to redirect_to(root_path)
+ expect(flash[:alert]).to eq('Shared stats not found or no longer available')
+ end
+ end
+
+ context 'with expired sharing' do
+ let(:stat) { create(:stat, :with_sharing_expired, user:, year: 2024, month: 6) }
+
+ it 'redirects to root with alert' do
+ get shared_stat_url(stat.sharing_uuid)
+
+ expect(response).to redirect_to(root_path)
+ expect(flash[:alert]).to eq('Shared stats not found or no longer available')
+ end
+ end
+
+ context 'with disabled sharing' do
+ let(:stat) { create(:stat, :with_sharing_disabled, user:, year: 2024, month: 6) }
+
+ it 'redirects to root with alert' do
+ get shared_stat_url(stat.sharing_uuid)
+
+ expect(response).to redirect_to(root_path)
+ expect(flash[:alert]).to eq('Shared stats not found or no longer available')
+ end
+ end
+
+ context 'when stat has no points' do
+ it 'renders successfully' do
+ get shared_stat_url(stat.sharing_uuid)
+
+ expect(response).to have_http_status(:success)
+ expect(response.body).to include('Monthly Digest')
+ end
+ end
+ end
+
+ describe 'PATCH /stats/:year/:month/sharing' do
+ context 'when user is signed in' do
+ let!(:stat_to_share) { create(:stat, user:, year: 2024, month: 6) }
+
+ before { sign_in user }
+
+ context 'enabling sharing' do
+ it 'enables sharing and returns success' do
+ patch sharing_stats_path(year: 2024, month: 6),
+ params: { enabled: '1' },
+ as: :json
+
+ expect(response).to have_http_status(:success)
+
+ json_response = JSON.parse(response.body)
+ expect(json_response['success']).to be(true)
+ expect(json_response['sharing_url']).to be_present
+ expect(json_response['message']).to eq('Sharing enabled successfully')
+
+ stat_to_share.reload
+ expect(stat_to_share.sharing_enabled?).to be(true)
+ expect(stat_to_share.sharing_uuid).to be_present
+ end
+
+ it 'sets custom expiration when provided' do
+ patch sharing_stats_path(year: 2024, month: 6),
+ params: { enabled: '1', expiration: '1_week' },
+ as: :json
+
+ expect(response).to have_http_status(:success)
+ stat_to_share.reload
+ expect(stat_to_share.sharing_enabled?).to be(true)
+ end
+ end
+
+ context 'disabling sharing' do
+ let!(:enabled_stat) { create(:stat, :with_sharing_enabled, user:, year: 2024, month: 7) }
+
+ it 'disables sharing and returns success' do
+ patch sharing_stats_path(year: 2024, month: 7),
+ params: { enabled: '0' },
+ as: :json
+
+ expect(response).to have_http_status(:success)
+
+ json_response = JSON.parse(response.body)
+ expect(json_response['success']).to be(true)
+ expect(json_response['message']).to eq('Sharing disabled successfully')
+
+ enabled_stat.reload
+ expect(enabled_stat.sharing_enabled?).to be(false)
+ end
+ end
+
+ context 'when stat does not exist' do
+ it 'returns not found' do
+ patch sharing_stats_path(year: 2024, month: 12),
+ params: { enabled: '1' },
+ as: :json
+
+ expect(response).to have_http_status(:not_found)
+ end
+ end
+ end
+
+ context 'when user is not signed in' do
+ it 'returns unauthorized' do
+ patch sharing_stats_path(year: 2024, month: 6),
+ params: { enabled: '1' },
+ as: :json
+
+ expect(response).to have_http_status(:unauthorized)
+ end
+ end
+ end
+ end
+end
diff --git a/spec/requests/trips_spec.rb b/spec/requests/trips_spec.rb
index af654048..53549905 100644
--- a/spec/requests/trips_spec.rb
+++ b/spec/requests/trips_spec.rb
@@ -114,7 +114,7 @@ RSpec.describe '/trips', type: :request do
it "renders a response with 422 status (i.e. to display the 'new' template)" do
post trips_url, params: { trip: invalid_attributes }
- expect(response).to have_http_status(:unprocessable_entity)
+ expect(response).to have_http_status(:unprocessable_content)
end
end
end
@@ -151,7 +151,7 @@ RSpec.describe '/trips', type: :request do
it 'renders a response with 422 status' do
patch trip_url(trip), params: { trip: invalid_attributes }
- expect(response).to have_http_status(:unprocessable_entity)
+ expect(response).to have_http_status(:unprocessable_content)
end
end
end
diff --git a/spec/services/tracks/generator_spec.rb b/spec/services/tracks/generator_spec.rb
deleted file mode 100644
index 6f352b86..00000000
--- a/spec/services/tracks/generator_spec.rb
+++ /dev/null
@@ -1,260 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Tracks::Generator do
- let(:user) { create(:user) }
- let(:safe_settings) { user.safe_settings }
-
- before do
- allow(user).to receive(:safe_settings).and_return(safe_settings)
- end
-
- describe '#call' do
- context 'with bulk mode' do
- let(:generator) { described_class.new(user, mode: :bulk) }
-
- context 'with sufficient points' do
- let!(:points) { create_points_around(user: user, count: 5, base_lat: 20.0) }
-
- it 'generates tracks from all points' do
- expect { generator.call }.to change(Track, :count).by(1)
- end
-
- it 'cleans existing tracks' do
- existing_track = create(:track, user: user)
- generator.call
- expect(Track.exists?(existing_track.id)).to be false
- end
-
- it 'associates points with created tracks' do
- generator.call
- expect(points.map(&:reload).map(&:track)).to all(be_present)
- end
-
- it 'properly handles point associations when cleaning existing tracks' do
- # Create existing tracks with associated points
- existing_track = create(:track, user: user)
- existing_points = create_list(:point, 3, user: user, track: existing_track)
-
- # Verify points are associated
- expect(existing_points.map(&:reload).map(&:track_id)).to all(eq(existing_track.id))
-
- # Run generator which should clean existing tracks and create new ones
- generator.call
-
- # Verify the old track is deleted
- expect(Track.exists?(existing_track.id)).to be false
-
- # Verify the points are no longer associated with the deleted track
- expect(existing_points.map(&:reload).map(&:track_id)).to all(be_nil)
- end
- end
-
- context 'with insufficient points' do
- let!(:points) { create_points_around(user: user, count: 1, base_lat: 20.0) }
-
- it 'does not create tracks' do
- expect { generator.call }.not_to change(Track, :count)
- end
- end
-
- context 'with time range' do
- let!(:old_points) { create_points_around(user: user, count: 3, base_lat: 20.0, timestamp: 2.days.ago.to_i) }
- let!(:new_points) { create_points_around(user: user, count: 3, base_lat: 21.0, timestamp: 1.day.ago.to_i) }
-
- it 'only processes points within range' do
- generator = described_class.new(
- user,
- start_at: 1.day.ago.beginning_of_day,
- end_at: 1.day.ago.end_of_day,
- mode: :bulk
- )
-
- generator.call
- track = Track.last
- expect(track.points.count).to eq(3)
- end
- end
- end
-
- context 'with incremental mode' do
- let(:generator) { described_class.new(user, mode: :incremental) }
-
- context 'with untracked points' do
- let!(:points) { create_points_around(user: user, count: 3, base_lat: 22.0, track_id: nil) }
-
- it 'processes untracked points' do
- expect { generator.call }.to change(Track, :count).by(1)
- end
-
- it 'associates points with created tracks' do
- generator.call
- expect(points.map(&:reload).map(&:track)).to all(be_present)
- end
- end
-
- context 'with end_at specified' do
- let!(:early_points) { create_points_around(user: user, count: 2, base_lat: 23.0, timestamp: 2.hours.ago.to_i) }
- let!(:late_points) { create_points_around(user: user, count: 2, base_lat: 24.0, timestamp: 1.hour.ago.to_i) }
-
- it 'only processes points up to end_at' do
- generator = described_class.new(user, end_at: 1.5.hours.ago, mode: :incremental)
- generator.call
-
- expect(Track.count).to eq(1)
- expect(Track.first.points.count).to eq(2)
- end
- end
-
- context 'without existing tracks' do
- let!(:points) { create_points_around(user: user, count: 3, base_lat: 25.0) }
-
- it 'does not clean existing tracks' do
- existing_track = create(:track, user: user)
- generator.call
- expect(Track.exists?(existing_track.id)).to be true
- end
- end
- end
-
- context 'with daily mode' do
- let(:today) { Date.current }
- let(:generator) { described_class.new(user, start_at: today, mode: :daily) }
-
- let!(:today_points) { create_points_around(user: user, count: 3, base_lat: 26.0, timestamp: today.beginning_of_day.to_i) }
- let!(:yesterday_points) { create_points_around(user: user, count: 3, base_lat: 27.0, timestamp: 1.day.ago.to_i) }
-
- it 'only processes points from specified day' do
- generator.call
- track = Track.last
- expect(track.points.count).to eq(3)
- end
-
- it 'cleans existing tracks for the day' do
- existing_track = create(:track, user: user, start_at: today.beginning_of_day)
- generator.call
- expect(Track.exists?(existing_track.id)).to be false
- end
-
- it 'properly handles point associations when cleaning daily tracks' do
- # Create existing tracks with associated points for today
- existing_track = create(:track, user: user, start_at: today.beginning_of_day)
- existing_points = create_list(:point, 3, user: user, track: existing_track)
-
- # Verify points are associated
- expect(existing_points.map(&:reload).map(&:track_id)).to all(eq(existing_track.id))
-
- # Run generator which should clean existing tracks for the day and create new ones
- generator.call
-
- # Verify the old track is deleted
- expect(Track.exists?(existing_track.id)).to be false
-
- # Verify the points are no longer associated with the deleted track
- expect(existing_points.map(&:reload).map(&:track_id)).to all(be_nil)
- end
- end
-
- context 'with empty points' do
- let(:generator) { described_class.new(user, mode: :bulk) }
-
- it 'does not create tracks' do
- expect { generator.call }.not_to change(Track, :count)
- end
- end
-
- context 'with threshold configuration' do
- let(:generator) { described_class.new(user, mode: :bulk) }
-
- before do
- allow(safe_settings).to receive(:meters_between_routes).and_return(1000)
- allow(safe_settings).to receive(:minutes_between_routes).and_return(90)
- end
-
- it 'uses configured thresholds' do
- expect(generator.send(:distance_threshold_meters)).to eq(1000)
- expect(generator.send(:time_threshold_minutes)).to eq(90)
- end
- end
-
- context 'with invalid mode' do
- it 'raises argument error' do
- expect do
- described_class.new(user, mode: :invalid).call
- end.to raise_error(ArgumentError, /Unknown mode/)
- end
- end
- end
-
- describe 'segmentation behavior' do
- let(:generator) { described_class.new(user, mode: :bulk) }
-
- context 'with points exceeding time threshold' do
- let!(:points) do
- [
- create_points_around(user: user, count: 1, base_lat: 29.0, timestamp: 90.minutes.ago.to_i),
- create_points_around(user: user, count: 1, base_lat: 29.0, timestamp: 60.minutes.ago.to_i),
- # Gap exceeds threshold 👇👇👇
- create_points_around(user: user, count: 1, base_lat: 29.0, timestamp: 10.minutes.ago.to_i),
- create_points_around(user: user, count: 1, base_lat: 29.0, timestamp: Time.current.to_i)
- ]
- end
-
- before do
- allow(safe_settings).to receive(:minutes_between_routes).and_return(45)
- end
-
- it 'creates separate tracks for segments' do
- expect { generator.call }.to change(Track, :count).by(2)
- end
- end
-
- context 'with points exceeding distance threshold' do
- let!(:points) do
- [
- create_points_around(user: user, count: 2, base_lat: 29.0, timestamp: 20.minutes.ago.to_i),
- create_points_around(user: user, count: 2, base_lat: 29.0, timestamp: 15.minutes.ago.to_i),
- # Large distance jump 👇👇👇
- create_points_around(user: user, count: 2, base_lat: 28.0, timestamp: 10.minutes.ago.to_i),
- create_points_around(user: user, count: 1, base_lat: 28.0, timestamp: Time.current.to_i)
- ]
- end
-
- before do
- allow(safe_settings).to receive(:meters_between_routes).and_return(200)
- end
-
- it 'creates separate tracks for segments' do
- expect { generator.call }.to change(Track, :count).by(2)
- end
- end
- end
-
- describe 'deterministic behavior' do
- let!(:points) { create_points_around(user: user, count: 10, base_lat: 28.0) }
-
- it 'produces same results for bulk and incremental modes' do
- # Generate tracks in bulk mode
- bulk_generator = described_class.new(user, mode: :bulk)
- bulk_generator.call
- bulk_tracks = user.tracks.order(:start_at).to_a
-
- # Clear tracks and generate incrementally
- user.tracks.destroy_all
- incremental_generator = described_class.new(user, mode: :incremental)
- incremental_generator.call
- incremental_tracks = user.tracks.order(:start_at).to_a
-
- # Should have same number of tracks
- expect(incremental_tracks.size).to eq(bulk_tracks.size)
-
- # Should have same track boundaries (allowing for small timing differences)
- bulk_tracks.zip(incremental_tracks).each do |bulk_track, incremental_track|
- expect(incremental_track.start_at).to be_within(1.second).of(bulk_track.start_at)
- expect(incremental_track.end_at).to be_within(1.second).of(bulk_track.end_at)
- expect(incremental_track.distance).to be_within(10).of(bulk_track.distance)
- end
- end
- end
-end
diff --git a/spec/services/tracks/incremental_processor_spec.rb b/spec/services/tracks/incremental_processor_spec.rb
deleted file mode 100644
index 165af52d..00000000
--- a/spec/services/tracks/incremental_processor_spec.rb
+++ /dev/null
@@ -1,249 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Tracks::IncrementalProcessor do
- let(:user) { create(:user) }
- let(:safe_settings) { user.safe_settings }
-
- before do
- allow(user).to receive(:safe_settings).and_return(safe_settings)
- allow(safe_settings).to receive(:minutes_between_routes).and_return(30)
- allow(safe_settings).to receive(:meters_between_routes).and_return(500)
- end
-
- describe '#call' do
- context 'with imported points' do
- let(:imported_point) { create(:point, user: user, import: create(:import)) }
- let(:processor) { described_class.new(user, imported_point) }
-
- it 'does not process imported points' do
- expect(Tracks::CreateJob).not_to receive(:perform_later)
-
- processor.call
- end
- end
-
- context 'with first point for user' do
- let(:new_point) { create(:point, user: user) }
- let(:processor) { described_class.new(user, new_point) }
-
- it 'processes first point' do
- expect(Tracks::CreateJob).to receive(:perform_later)
- .with(user.id, start_at: nil, end_at: nil, mode: :incremental)
- processor.call
- end
- end
-
- context 'with thresholds exceeded' do
- let(:previous_point) { create(:point, user: user, timestamp: 1.hour.ago.to_i) }
- let(:new_point) { create(:point, user: user, timestamp: Time.current.to_i) }
- let(:processor) { described_class.new(user, new_point) }
-
- before do
- # Create previous point first
- previous_point
- end
-
- it 'processes when time threshold exceeded' do
- expect(Tracks::CreateJob).to receive(:perform_later)
- .with(user.id, start_at: nil, end_at: Time.zone.at(previous_point.timestamp), mode: :incremental)
- processor.call
- end
- end
-
- context 'with existing tracks' do
- let(:existing_track) { create(:track, user: user, end_at: 2.hours.ago) }
- let(:previous_point) { create(:point, user: user, timestamp: 1.hour.ago.to_i) }
- let(:new_point) { create(:point, user: user, timestamp: Time.current.to_i) }
- let(:processor) { described_class.new(user, new_point) }
-
- before do
- existing_track
- previous_point
- end
-
- it 'uses existing track end time as start_at' do
- expect(Tracks::CreateJob).to receive(:perform_later)
- .with(user.id, start_at: existing_track.end_at, end_at: Time.zone.at(previous_point.timestamp), mode: :incremental)
- processor.call
- end
- end
-
- context 'with distance threshold exceeded' do
- let(:previous_point) do
- create(:point, user: user, timestamp: 10.minutes.ago.to_i, lonlat: 'POINT(0 0)')
- end
- let(:new_point) do
- create(:point, user: user, timestamp: Time.current.to_i, lonlat: 'POINT(1 1)')
- end
- let(:processor) { described_class.new(user, new_point) }
-
- before do
- # Create previous point first
- previous_point
- # Mock distance calculation to exceed threshold
- allow_any_instance_of(Point).to receive(:distance_to).and_return(1.0) # 1 km = 1000m
- end
-
- it 'processes when distance threshold exceeded' do
- expect(Tracks::CreateJob).to receive(:perform_later)
- .with(user.id, start_at: nil, end_at: Time.zone.at(previous_point.timestamp), mode: :incremental)
- processor.call
- end
- end
-
- context 'with thresholds not exceeded' do
- let(:previous_point) { create(:point, user: user, timestamp: 10.minutes.ago.to_i) }
- let(:new_point) { create(:point, user: user, timestamp: Time.current.to_i) }
- let(:processor) { described_class.new(user, new_point) }
-
- before do
- # Create previous point first
- previous_point
- # Mock distance to be within threshold
- allow_any_instance_of(Point).to receive(:distance_to).and_return(0.1) # 100m
- end
-
- it 'does not process when thresholds not exceeded' do
- expect(Tracks::CreateJob).not_to receive(:perform_later)
- processor.call
- end
- end
- end
-
- describe '#should_process?' do
- let(:processor) { described_class.new(user, new_point) }
-
- context 'with imported point' do
- let(:new_point) { create(:point, user: user, import: create(:import)) }
-
- it 'returns false' do
- expect(processor.send(:should_process?)).to be false
- end
- end
-
- context 'with first point for user' do
- let(:new_point) { create(:point, user: user) }
-
- it 'returns true' do
- expect(processor.send(:should_process?)).to be true
- end
- end
-
- context 'with thresholds exceeded' do
- let(:previous_point) { create(:point, user: user, timestamp: 1.hour.ago.to_i) }
- let(:new_point) { create(:point, user: user, timestamp: Time.current.to_i) }
-
- before do
- previous_point # Create previous point
- end
-
- it 'returns true when time threshold exceeded' do
- expect(processor.send(:should_process?)).to be true
- end
- end
-
- context 'with thresholds not exceeded' do
- let(:previous_point) { create(:point, user: user, timestamp: 10.minutes.ago.to_i) }
- let(:new_point) { create(:point, user: user, timestamp: Time.current.to_i) }
-
- before do
- previous_point # Create previous point
- allow_any_instance_of(Point).to receive(:distance_to).and_return(0.1) # 100m
- end
-
- it 'returns false when thresholds not exceeded' do
- expect(processor.send(:should_process?)).to be false
- end
- end
- end
-
- describe '#exceeds_thresholds?' do
- let(:processor) { described_class.new(user, new_point) }
- let(:previous_point) { create(:point, user: user, timestamp: 1.hour.ago.to_i) }
- let(:new_point) { create(:point, user: user, timestamp: Time.current.to_i) }
-
- context 'with time threshold exceeded' do
- before do
- allow(safe_settings).to receive(:minutes_between_routes).and_return(30)
- end
-
- it 'returns true' do
- result = processor.send(:exceeds_thresholds?, previous_point, new_point)
- expect(result).to be true
- end
- end
-
- context 'with distance threshold exceeded' do
- before do
- allow(safe_settings).to receive(:minutes_between_routes).and_return(120) # 2 hours
- allow(safe_settings).to receive(:meters_between_routes).and_return(400)
- allow_any_instance_of(Point).to receive(:distance_to).and_return(0.5) # 500m
- end
-
- it 'returns true' do
- result = processor.send(:exceeds_thresholds?, previous_point, new_point)
- expect(result).to be true
- end
- end
-
- context 'with neither threshold exceeded' do
- before do
- allow(safe_settings).to receive(:minutes_between_routes).and_return(120) # 2 hours
- allow(safe_settings).to receive(:meters_between_routes).and_return(600)
- allow_any_instance_of(Point).to receive(:distance_to).and_return(0.1) # 100m
- end
-
- it 'returns false' do
- result = processor.send(:exceeds_thresholds?, previous_point, new_point)
- expect(result).to be false
- end
- end
- end
-
- describe '#time_difference_minutes' do
- let(:processor) { described_class.new(user, new_point) }
- let(:point1) { create(:point, user: user, timestamp: 1.hour.ago.to_i) }
- let(:point2) { create(:point, user: user, timestamp: Time.current.to_i) }
- let(:new_point) { point2 }
-
- it 'calculates time difference in minutes' do
- result = processor.send(:time_difference_minutes, point1, point2)
- expect(result).to be_within(1).of(60) # Approximately 60 minutes
- end
- end
-
- describe '#distance_difference_meters' do
- let(:processor) { described_class.new(user, new_point) }
- let(:point1) { create(:point, user: user) }
- let(:point2) { create(:point, user: user) }
- let(:new_point) { point2 }
-
- before do
- allow(point1).to receive(:distance_to).with(point2).and_return(1.5) # 1.5 km
- end
-
- it 'calculates distance difference in meters' do
- result = processor.send(:distance_difference_meters, point1, point2)
- expect(result).to eq(1500) # 1.5 km = 1500 m
- end
- end
-
- describe 'threshold configuration' do
- let(:processor) { described_class.new(user, create(:point, user: user)) }
-
- before do
- allow(safe_settings).to receive(:minutes_between_routes).and_return(45)
- allow(safe_settings).to receive(:meters_between_routes).and_return(750)
- end
-
- it 'uses configured time threshold' do
- expect(processor.send(:time_threshold_minutes)).to eq(45)
- end
-
- it 'uses configured distance threshold' do
- expect(processor.send(:distance_threshold_meters)).to eq(750)
- end
- end
-end
diff --git a/spec/services/tracks/parallel_generator_spec.rb b/spec/services/tracks/parallel_generator_spec.rb
index 26d89802..eebe107b 100644
--- a/spec/services/tracks/parallel_generator_spec.rb
+++ b/spec/services/tracks/parallel_generator_spec.rb
@@ -80,15 +80,15 @@ RSpec.describe Tracks::ParallelGenerator do
end
it 'enqueues time chunk processor jobs' do
- expect {
+ expect do
generator.call
- }.to have_enqueued_job(Tracks::TimeChunkProcessorJob).at_least(:once)
+ end.to have_enqueued_job(Tracks::TimeChunkProcessorJob).at_least(:once)
end
it 'enqueues boundary resolver job with delay' do
- expect {
+ expect do
generator.call
- }.to have_enqueued_job(Tracks::BoundaryResolverJob).at(be >= 5.minutes.from_now)
+ end.to have_enqueued_job(Tracks::BoundaryResolverJob).at(be >= 5.minutes.from_now)
end
it 'logs the operation' do
@@ -108,9 +108,9 @@ RSpec.describe Tracks::ParallelGenerator do
end
it 'does not enqueue any jobs' do
- expect {
+ expect do
generator.call
- }.not_to have_enqueued_job
+ end.not_to have_enqueued_job
end
end
@@ -133,14 +133,14 @@ RSpec.describe Tracks::ParallelGenerator do
context 'daily mode' do
let(:options) { { mode: :daily, start_at: 1.day.ago.beginning_of_day } }
- it 'cleans tracks for the specific day' do
+ it 'preserves existing tracks' do
expect(user.tracks.count).to eq(2)
generator.call
- # Should only clean tracks from the specified day
+ # Daily mode should preserve all existing tracks
remaining_tracks = user.tracks.count
- expect(remaining_tracks).to be < 2
+ expect(remaining_tracks).to eq(2)
end
end
@@ -161,8 +161,8 @@ RSpec.describe Tracks::ParallelGenerator do
let(:start_time) { 3.days.ago }
let(:end_time) { 1.day.ago }
let(:options) { { start_at: start_time, end_at: end_time, mode: :bulk } }
- let!(:track_in_range) { create(:track, user: user, start_at: 2.days.ago) }
- let!(:track_out_of_range) { create(:track, user: user, start_at: 1.week.ago) }
+ let!(:track_in_range) { create(:track, user: user, start_at: 2.days.ago, end_at: 2.days.ago + 1.hour) }
+ let!(:track_out_of_range) { create(:track, user: user, start_at: 1.week.ago, end_at: 1.week.ago + 1.hour) }
it 'only cleans tracks within the specified range' do
expect(user.tracks.count).to eq(2)
@@ -191,37 +191,21 @@ RSpec.describe Tracks::ParallelGenerator do
create(:point, user: user, timestamp: (10 - i).days.ago.to_i)
end
- expect {
+ expect do
generator.call
- }.to have_enqueued_job(Tracks::BoundaryResolverJob)
+ end.to have_enqueued_job(Tracks::BoundaryResolverJob)
.with(user.id, kind_of(String))
end
it 'ensures minimum delay for boundary resolver' do
# Even with few chunks, should have minimum delay
- expect {
+ expect do
generator.call
- }.to have_enqueued_job(Tracks::BoundaryResolverJob)
+ end.to have_enqueued_job(Tracks::BoundaryResolverJob)
.at(be >= 5.minutes.from_now)
end
end
- context 'error handling in private methods' do
- it 'handles unknown mode in should_clean_tracks?' do
- generator.instance_variable_set(:@mode, :unknown)
-
- expect(generator.send(:should_clean_tracks?)).to be false
- end
-
- it 'raises error for unknown mode in clean_existing_tracks' do
- generator.instance_variable_set(:@mode, :unknown)
-
- expect {
- generator.send(:clean_existing_tracks)
- }.to raise_error(ArgumentError, 'Unknown mode: unknown')
- end
- end
-
context 'user settings integration' do
let(:mock_settings) { double('SafeSettings') }
@@ -277,15 +261,17 @@ RSpec.describe Tracks::ParallelGenerator do
describe '#enqueue_chunk_jobs' do
let(:session_id) { 'test-session' }
- let(:chunks) { [
- { chunk_id: 'chunk1', start_timestamp: 1.day.ago.to_i },
- { chunk_id: 'chunk2', start_timestamp: 2.days.ago.to_i }
- ] }
+ let(:chunks) do
+ [
+ { chunk_id: 'chunk1', start_timestamp: 1.day.ago.to_i },
+ { chunk_id: 'chunk2', start_timestamp: 2.days.ago.to_i }
+ ]
+ end
it 'enqueues job for each chunk' do
- expect {
+ expect do
generator.send(:enqueue_chunk_jobs, session_id, chunks)
- }.to have_enqueued_job(Tracks::TimeChunkProcessorJob)
+ end.to have_enqueued_job(Tracks::TimeChunkProcessorJob)
.exactly(2).times
end
@@ -303,24 +289,24 @@ RSpec.describe Tracks::ParallelGenerator do
let(:session_id) { 'test-session' }
it 'enqueues boundary resolver with estimated delay' do
- expect {
+ expect do
generator.send(:enqueue_boundary_resolver, session_id, 5)
- }.to have_enqueued_job(Tracks::BoundaryResolverJob)
+ end.to have_enqueued_job(Tracks::BoundaryResolverJob)
.with(user.id, session_id)
.at(be >= 2.minutes.from_now)
end
it 'uses minimum delay for small chunk counts' do
- expect {
+ expect do
generator.send(:enqueue_boundary_resolver, session_id, 1)
- }.to have_enqueued_job(Tracks::BoundaryResolverJob)
+ end.to have_enqueued_job(Tracks::BoundaryResolverJob)
.at(be >= 5.minutes.from_now)
end
it 'scales delay with chunk count' do
- expect {
+ expect do
generator.send(:enqueue_boundary_resolver, session_id, 20)
- }.to have_enqueued_job(Tracks::BoundaryResolverJob)
+ end.to have_enqueued_job(Tracks::BoundaryResolverJob)
.at(be >= 10.minutes.from_now)
end
end
diff --git a/spec/services/tracks/session_manager_spec.rb b/spec/services/tracks/session_manager_spec.rb
index 61f5a1df..aefc55f7 100644
--- a/spec/services/tracks/session_manager_spec.rb
+++ b/spec/services/tracks/session_manager_spec.rb
@@ -28,10 +28,10 @@ RSpec.describe Tracks::SessionManager do
it 'creates a new session with default values' do
result = manager.create_session(metadata)
-
+
expect(result).to eq(manager)
expect(manager.session_exists?).to be true
-
+
session_data = manager.get_session_data
expect(session_data['status']).to eq('pending')
expect(session_data['total_chunks']).to eq(0)
@@ -45,7 +45,7 @@ RSpec.describe Tracks::SessionManager do
it 'sets TTL on the cache entry' do
manager.create_session(metadata)
-
+
# Check that the key exists and will expire
expect(Rails.cache.exist?(manager.send(:cache_key))).to be true
end
@@ -59,7 +59,7 @@ RSpec.describe Tracks::SessionManager do
it 'returns session data when session exists' do
metadata = { test: 'data' }
manager.create_session(metadata)
-
+
data = manager.get_session_data
expect(data).to be_a(Hash)
expect(data['metadata']).to eq(metadata.deep_stringify_keys)
@@ -85,9 +85,9 @@ RSpec.describe Tracks::SessionManager do
it 'updates existing session data' do
updates = { status: 'processing', total_chunks: 5 }
result = manager.update_session(updates)
-
+
expect(result).to be true
-
+
data = manager.get_session_data
expect(data['status']).to eq('processing')
expect(data['total_chunks']).to eq(5)
@@ -96,7 +96,7 @@ RSpec.describe Tracks::SessionManager do
it 'returns false when session does not exist' do
manager.cleanup_session
result = manager.update_session({ status: 'processing' })
-
+
expect(result).to be false
end
@@ -104,9 +104,9 @@ RSpec.describe Tracks::SessionManager do
original_metadata = { mode: 'bulk' }
manager.cleanup_session
manager.create_session(original_metadata)
-
+
manager.update_session({ status: 'processing' })
-
+
data = manager.get_session_data
expect(data['metadata']).to eq(original_metadata.stringify_keys)
expect(data['status']).to eq('processing')
@@ -120,9 +120,9 @@ RSpec.describe Tracks::SessionManager do
it 'marks session as processing with total chunks' do
result = manager.mark_started(10)
-
+
expect(result).to be true
-
+
data = manager.get_session_data
expect(data['status']).to eq('processing')
expect(data['total_chunks']).to eq(10)
@@ -137,9 +137,9 @@ RSpec.describe Tracks::SessionManager do
end
it 'increments completed chunks counter' do
- expect {
+ expect do
manager.increment_completed_chunks
- }.to change {
+ end.to change {
manager.get_session_data['completed_chunks']
}.from(0).to(1)
end
@@ -156,17 +156,17 @@ RSpec.describe Tracks::SessionManager do
end
it 'increments tracks created counter by 1 by default' do
- expect {
+ expect do
manager.increment_tracks_created
- }.to change {
+ end.to change {
manager.get_session_data['tracks_created']
}.from(0).to(1)
end
it 'increments tracks created counter by specified amount' do
- expect {
+ expect do
manager.increment_tracks_created(5)
- }.to change {
+ end.to change {
manager.get_session_data['tracks_created']
}.from(0).to(5)
end
@@ -184,9 +184,9 @@ RSpec.describe Tracks::SessionManager do
it 'marks session as completed with timestamp' do
result = manager.mark_completed
-
+
expect(result).to be true
-
+
data = manager.get_session_data
expect(data['status']).to eq('completed')
expect(data['completed_at']).to be_present
@@ -200,11 +200,11 @@ RSpec.describe Tracks::SessionManager do
it 'marks session as failed with error message and timestamp' do
error_message = 'Something went wrong'
-
+
result = manager.mark_failed(error_message)
-
+
expect(result).to be true
-
+
data = manager.get_session_data
expect(data['status']).to eq('failed')
expect(data['error_message']).to eq(error_message)
@@ -239,35 +239,6 @@ RSpec.describe Tracks::SessionManager do
end
end
- describe '#progress_percentage' do
- before do
- manager.create_session
- end
-
- it 'returns 0 when session does not exist' do
- manager.cleanup_session
- expect(manager.progress_percentage).to eq(0)
- end
-
- it 'returns 100 when total chunks is 0' do
- expect(manager.progress_percentage).to eq(100)
- end
-
- it 'calculates correct percentage' do
- manager.mark_started(4)
- 2.times { manager.increment_completed_chunks }
-
- expect(manager.progress_percentage).to eq(50.0)
- end
-
- it 'rounds to 2 decimal places' do
- manager.mark_started(3)
- manager.increment_completed_chunks
-
- expect(manager.progress_percentage).to eq(33.33)
- end
- end
-
describe '#cleanup_session' do
before do
manager.create_session
@@ -275,9 +246,9 @@ RSpec.describe Tracks::SessionManager do
it 'removes session from cache' do
expect(manager.session_exists?).to be true
-
+
manager.cleanup_session
-
+
expect(manager.session_exists?).to be false
end
end
@@ -287,53 +258,30 @@ RSpec.describe Tracks::SessionManager do
it 'creates and returns a session manager' do
result = described_class.create_for_user(user_id, metadata)
-
+
expect(result).to be_a(described_class)
expect(result.user_id).to eq(user_id)
expect(result.session_exists?).to be true
-
+
data = result.get_session_data
expect(data['metadata']).to eq(metadata.deep_stringify_keys)
end
end
- describe '.find_session' do
- it 'returns nil when session does not exist' do
- result = described_class.find_session(user_id, 'non-existent')
- expect(result).to be_nil
- end
-
- it 'returns session manager when session exists' do
- manager.create_session
-
- result = described_class.find_session(user_id, session_id)
-
- expect(result).to be_a(described_class)
- expect(result.user_id).to eq(user_id)
- expect(result.session_id).to eq(session_id)
- end
- end
-
- describe '.cleanup_expired_sessions' do
- it 'returns true (no-op with Rails.cache TTL)' do
- expect(described_class.cleanup_expired_sessions).to be true
- end
- end
-
describe 'cache key scoping' do
it 'uses user-scoped cache keys' do
expected_key = "track_generation:user:#{user_id}:session:#{session_id}"
actual_key = manager.send(:cache_key)
-
+
expect(actual_key).to eq(expected_key)
end
it 'prevents cross-user session access' do
manager.create_session
other_manager = described_class.new(999, session_id)
-
+
expect(manager.session_exists?).to be true
expect(other_manager.session_exists?).to be false
end
end
-end
\ No newline at end of file
+end
diff --git a/spec/services/users/export_import_integration_spec.rb b/spec/services/users/export_import_integration_spec.rb
index 66e3c6a0..2be18ee7 100644
--- a/spec/services/users/export_import_integration_spec.rb
+++ b/spec/services/users/export_import_integration_spec.rb
@@ -5,7 +5,7 @@ require 'rails_helper'
RSpec.describe 'Users Export-Import Integration', type: :service do
let(:original_user) { create(:user, email: 'original@example.com') }
let(:target_user) { create(:user, email: 'target@example.com') }
- let(:temp_archive_path) { Rails.root.join('tmp', 'test_export.zip') }
+ let(:temp_archive_path) { Rails.root.join('tmp/test_export.zip') }
after do
File.delete(temp_archive_path) if File.exist?(temp_archive_path)
@@ -40,17 +40,12 @@ RSpec.describe 'Users Export-Import Integration', type: :service do
Rails.logger.level = original_log_level
end
- puts "Import stats: #{import_stats.inspect}"
-
user_notifications_count = original_user.notifications.where.not(
title: ['Data import completed', 'Data import failed', 'Export completed', 'Export failed']
).count
target_counts = calculate_user_entity_counts(target_user)
- puts "Original counts: #{original_counts.inspect}"
- puts "Target counts: #{target_counts.inspect}"
-
expect(target_counts[:areas]).to eq(original_counts[:areas])
expect(target_counts[:imports]).to eq(original_counts[:imports])
expect(target_counts[:exports]).to eq(original_counts[:exports])
@@ -184,18 +179,22 @@ RSpec.describe 'Users Export-Import Integration', type: :service do
import_stats = import_service.import
# Verify all entities were imported correctly
- expect(import_stats[:places_created]).to eq(original_places_count),
+ expect(import_stats[:places_created]).to \
+ eq(original_places_count),
"Expected #{original_places_count} places to be created, got #{import_stats[:places_created]}"
- expect(import_stats[:visits_created]).to eq(original_visits_count),
+ expect(import_stats[:visits_created]).to \
+ eq(original_visits_count),
"Expected #{original_visits_count} visits to be created, got #{import_stats[:visits_created]}"
# Verify the imported user has access to all their data
imported_places_count = import_user.places.distinct.count
imported_visits_count = import_user.visits.count
- expect(imported_places_count).to eq(original_places_count),
+ expect(imported_places_count).to \
+ eq(original_places_count),
"Expected user to have access to #{original_places_count} places, got #{imported_places_count}"
- expect(imported_visits_count).to eq(original_visits_count),
+ expect(imported_visits_count).to \
+ eq(original_visits_count),
"Expected user to have #{original_visits_count} visits, got #{imported_visits_count}"
# Verify specific visits have their place associations
@@ -205,7 +204,7 @@ RSpec.describe 'Users Export-Import Integration', type: :service do
# Verify place names are preserved
place_names = visits_with_places.map { |v| v.place.name }.sort
- expect(place_names).to eq(['Gym', 'Home', 'Office'])
+ expect(place_names).to eq(%w[Gym Home Office])
# Cleanup
temp_export_file.unlink
@@ -216,12 +215,13 @@ RSpec.describe 'Users Export-Import Integration', type: :service do
private
def create_full_user_dataset(user)
- user.update!(settings: {
- 'distance_unit' => 'km',
- 'timezone' => 'America/New_York',
- 'immich_url' => 'https://immich.example.com',
- 'immich_api_key' => 'test-api-key'
- })
+ user.update!(settings:
+ {
+ 'distance_unit' => 'km',
+ 'timezone' => 'America/New_York',
+ 'immich_url' => 'https://immich.example.com',
+ 'immich_api_key' => 'test-api-key'
+ })
usa = create(:country, name: 'United States', iso_a2: 'US', iso_a3: 'USA')
canada = create(:country, name: 'Canada', iso_a2: 'CA', iso_a3: 'CAN')
@@ -271,37 +271,32 @@ RSpec.describe 'Users Export-Import Integration', type: :service do
visit3 = create(:visit, user: user, place: nil, name: 'Unknown Location')
create_list(:point, 5,
- user: user,
- import: import1,
- country: usa,
- visit: visit1,
- latitude: 40.7589,
- longitude: -73.9851
- )
+ user: user,
+ import: import1,
+ country: usa,
+ visit: visit1,
+ latitude: 40.7589,
+ longitude: -73.9851)
create_list(:point, 3,
- user: user,
- import: import2,
- country: canada,
- visit: visit2,
- latitude: 40.7128,
- longitude: -74.0060
- )
+ user: user,
+ import: import2,
+ country: canada,
+ visit: visit2,
+ latitude: 40.7128,
+ longitude: -74.0060)
create_list(:point, 2,
- user: user,
- import: nil,
- country: nil,
- visit: nil
- )
+ user: user,
+ import: nil,
+ country: nil,
+ visit: nil)
create_list(:point, 2,
- user: user,
- import: import1,
- country: usa,
- visit: visit3
- )
-
+ user: user,
+ import: import1,
+ country: usa,
+ visit: visit3)
end
def calculate_user_entity_counts(user)
@@ -342,11 +337,13 @@ RSpec.describe 'Users Export-Import Integration', type: :service do
latitude: 40.7589, longitude: -73.9851
).first
- if original_office_points && target_office_points
- expect(target_office_points.import.name).to eq(original_office_points.import.name) if original_office_points.import
- expect(target_office_points.country.name).to eq(original_office_points.country.name) if original_office_points.country
- expect(target_office_points.visit.name).to eq(original_office_points.visit.name) if original_office_points.visit
+ return unless original_office_points && target_office_points
+
+ expect(target_office_points.import.name).to eq(original_office_points.import.name) if original_office_points.import
+ if original_office_points.country
+ expect(target_office_points.country.name).to eq(original_office_points.country.name)
end
+ expect(target_office_points.visit.name).to eq(original_office_points.visit.name) if original_office_points.visit
end
def verify_settings_preserved(original_user, target_user)
@@ -375,9 +372,9 @@ RSpec.describe 'Users Export-Import Integration', type: :service do
original_export = original_user.exports.find_by(name: 'Q1 2024 Export')
target_export = target_user.exports.find_by(name: 'Q1 2024 Export')
- if original_export&.file&.attached?
- expect(target_export).to be_present
- expect(target_export.file).to be_attached
- end
+ return unless original_export&.file&.attached?
+
+ expect(target_export).to be_present
+ expect(target_export.file).to be_attached
end
end