diff --git a/app/views/stats/index.html.erb b/app/views/stats/index.html.erb
index bac6e0bd..96050095 100644
--- a/app/views/stats/index.html.erb
+++ b/app/views/stats/index.html.erb
@@ -4,7 +4,7 @@
<% end %>
<%= column_chart(
- Stat.year_distance(year, current_user),
+ Stat.year_distance(year, current_user).map { |month_name, distance_meters|
+ [month_name, Stat.convert_distance(distance_meters, current_user.safe_settings.distance_unit).round(2)]
+ },
height: '200px',
suffix: " #{current_user.safe_settings.distance_unit}",
xtitle: 'Days',
diff --git a/app/views/trips/_countries.html.erb b/app/views/trips/_countries.html.erb
index 01fc652b..69a7fe08 100644
--- a/app/views/trips/_countries.html.erb
+++ b/app/views/trips/_countries.html.erb
@@ -2,7 +2,7 @@
diff --git a/app/views/trips/_distance.html.erb b/app/views/trips/_distance.html.erb
index e6e4d13d..6bb835e6 100644
--- a/app/views/trips/_distance.html.erb
+++ b/app/views/trips/_distance.html.erb
@@ -1,5 +1,5 @@
<% if trip.distance.present? %>
-
<%= trip.distance %> <%= distance_unit %>
+
<%= trip.distance_for_user(current_user).round %> <%= distance_unit %>
<% else %>
Calculating...
diff --git a/app/views/trips/_trip.html.erb b/app/views/trips/_trip.html.erb
index f78e78a0..c65373a1 100644
--- a/app/views/trips/_trip.html.erb
+++ b/app/views/trips/_trip.html.erb
@@ -5,7 +5,7 @@
<%= trip.name %>
- <%= "#{human_date(trip.started_at)} – #{human_date(trip.ended_at)}, #{trip.distance} #{current_user.safe_settings.distance_unit}" %>
+ <%= "#{human_date(trip.started_at)} – #{human_date(trip.ended_at)}, #{trip.distance_for_user(current_user).round} #{current_user.safe_settings.distance_unit}" %>
'0.5',
- 'meters_between_routes' => '100',
- 'minutes_between_routes' => '100',
+ 'meters_between_routes' => '500',
+ 'minutes_between_routes' => '30',
'fog_of_war_meters' => '100',
- 'time_threshold_minutes' => '100',
- 'merge_threshold_minutes' => '100',
+ 'time_threshold_minutes' => '30',
+ 'merge_threshold_minutes' => '15',
'maps' => {
'distance_unit' => 'km'
}
diff --git a/spec/fixtures/files/geojson/export_same_points.json b/spec/fixtures/files/geojson/export_same_points.json
index 3f6845cc..9a510998 100644
--- a/spec/fixtures/files/geojson/export_same_points.json
+++ b/spec/fixtures/files/geojson/export_same_points.json
@@ -1 +1 @@
-{"type":"FeatureCollection","features":[{"type":"Feature","geometry":{"type":"Point","coordinates":[37.6173,55.755826]},"properties":{"battery_status":"unplugged","ping":"MyString","battery":1,"tracker_id":"MyString","topic":"MyString","altitude":1,"longitude":"37.6173","velocity":"0","trigger":"background_event","bssid":"MyString","ssid":"MyString","connection":"wifi","vertical_accuracy":1,"accuracy":1,"timestamp":1609459200,"latitude":"55.755826","mode":1,"inrids":[],"in_regions":[],"city":null,"country":null,"geodata":{},"course":null,"course_accuracy":null,"external_track_id":null}},{"type":"Feature","geometry":{"type":"Point","coordinates":[37.6173,55.755826]},"properties":{"battery_status":"unplugged","ping":"MyString","battery":1,"tracker_id":"MyString","topic":"MyString","altitude":1,"longitude":"37.6173","velocity":"0","trigger":"background_event","bssid":"MyString","ssid":"MyString","connection":"wifi","vertical_accuracy":1,"accuracy":1,"timestamp":1609459201,"latitude":"55.755826","mode":1,"inrids":[],"in_regions":[],"city":null,"country":null,"geodata":{},"course":null,"course_accuracy":null,"external_track_id":null}},{"type":"Feature","geometry":{"type":"Point","coordinates":[37.6173,55.755826]},"properties":{"battery_status":"unplugged","ping":"MyString","battery":1,"tracker_id":"MyString","topic":"MyString","altitude":1,"longitude":"37.6173","velocity":"0","trigger":"background_event","bssid":"MyString","ssid":"MyString","connection":"wifi","vertical_accuracy":1,"accuracy":1,"timestamp":1609459202,"latitude":"55.755826","mode":1,"inrids":[],"in_regions":[],"city":null,"country":null,"geodata":{},"course":null,"course_accuracy":null,"external_track_id":null}},{"type":"Feature","geometry":{"type":"Point","coordinates":[37.6173,55.755826]},"properties":{"battery_status":"unplugged","ping":"MyString","battery":1,"tracker_id":"MyString","topic":"MyString","altitude":1,"longitude":"37.6173","velocity":"0","trigger":"background_event","bssid":"MyString","ssid":"MyString","connection":"wifi","vertical_accuracy":1,"accuracy":1,"timestamp":1609459203,"latitude":"55.755826","mode":1,"inrids":[],"in_regions":[],"city":null,"country":null,"geodata":{},"course":null,"course_accuracy":null,"external_track_id":null}},{"type":"Feature","geometry":{"type":"Point","coordinates":[37.6173,55.755826]},"properties":{"battery_status":"unplugged","ping":"MyString","battery":1,"tracker_id":"MyString","topic":"MyString","altitude":1,"longitude":"37.6173","velocity":"0","trigger":"background_event","bssid":"MyString","ssid":"MyString","connection":"wifi","vertical_accuracy":1,"accuracy":1,"timestamp":1609459204,"latitude":"55.755826","mode":1,"inrids":[],"in_regions":[],"city":null,"country":null,"geodata":{},"course":null,"course_accuracy":null,"external_track_id":null}},{"type":"Feature","geometry":{"type":"Point","coordinates":[37.6173,55.755826]},"properties":{"battery_status":"unplugged","ping":"MyString","battery":1,"tracker_id":"MyString","topic":"MyString","altitude":1,"longitude":"37.6173","velocity":"0","trigger":"background_event","bssid":"MyString","ssid":"MyString","connection":"wifi","vertical_accuracy":1,"accuracy":1,"timestamp":1609459205,"latitude":"55.755826","mode":1,"inrids":[],"in_regions":[],"city":null,"country":null,"geodata":{},"course":null,"course_accuracy":null,"external_track_id":null}},{"type":"Feature","geometry":{"type":"Point","coordinates":[37.6173,55.755826]},"properties":{"battery_status":"unplugged","ping":"MyString","battery":1,"tracker_id":"MyString","topic":"MyString","altitude":1,"longitude":"37.6173","velocity":"0","trigger":"background_event","bssid":"MyString","ssid":"MyString","connection":"wifi","vertical_accuracy":1,"accuracy":1,"timestamp":1609459206,"latitude":"55.755826","mode":1,"inrids":[],"in_regions":[],"city":null,"country":null,"geodata":{},"course":null,"course_accuracy":null,"external_track_id":null}},{"type":"Feature","geometry":{"type":"Point","coordinates":[37.6173,55.755826]},"properties":{"battery_status":"unplugged","ping":"MyString","battery":1,"tracker_id":"MyString","topic":"MyString","altitude":1,"longitude":"37.6173","velocity":"0","trigger":"background_event","bssid":"MyString","ssid":"MyString","connection":"wifi","vertical_accuracy":1,"accuracy":1,"timestamp":1609459207,"latitude":"55.755826","mode":1,"inrids":[],"in_regions":[],"city":null,"country":null,"geodata":{},"course":null,"course_accuracy":null,"external_track_id":null}},{"type":"Feature","geometry":{"type":"Point","coordinates":[37.6173,55.755826]},"properties":{"battery_status":"unplugged","ping":"MyString","battery":1,"tracker_id":"MyString","topic":"MyString","altitude":1,"longitude":"37.6173","velocity":"0","trigger":"background_event","bssid":"MyString","ssid":"MyString","connection":"wifi","vertical_accuracy":1,"accuracy":1,"timestamp":1609459208,"latitude":"55.755826","mode":1,"inrids":[],"in_regions":[],"city":null,"country":null,"geodata":{},"course":null,"course_accuracy":null,"external_track_id":null}},{"type":"Feature","geometry":{"type":"Point","coordinates":[37.6173,55.755826]},"properties":{"battery_status":"unplugged","ping":"MyString","battery":1,"tracker_id":"MyString","topic":"MyString","altitude":1,"longitude":"37.6173","velocity":"0","trigger":"background_event","bssid":"MyString","ssid":"MyString","connection":"wifi","vertical_accuracy":1,"accuracy":1,"timestamp":1609459209,"latitude":"55.755826","mode":1,"inrids":[],"in_regions":[],"city":null,"country":null,"geodata":{},"course":null,"course_accuracy":null,"external_track_id":null}}]}
+{"type":"FeatureCollection","features":[{"type":"Feature","geometry":{"type":"Point","coordinates":[37.6173,55.755826]},"properties":{"battery_status":"unplugged","ping":"MyString","battery":1,"tracker_id":"MyString","topic":"MyString","altitude":1,"longitude":"37.6173","velocity":"0","trigger":"background_event","bssid":"MyString","ssid":"MyString","connection":"wifi","vertical_accuracy":1,"accuracy":1,"timestamp":1609459200,"latitude":"55.755826","mode":1,"inrids":[],"in_regions":[],"city":null,"country":null,"geodata":{},"course":null,"course_accuracy":null,"external_track_id":null,"track_id":null}},{"type":"Feature","geometry":{"type":"Point","coordinates":[37.6173,55.755826]},"properties":{"battery_status":"unplugged","ping":"MyString","battery":1,"tracker_id":"MyString","topic":"MyString","altitude":1,"longitude":"37.6173","velocity":"0","trigger":"background_event","bssid":"MyString","ssid":"MyString","connection":"wifi","vertical_accuracy":1,"accuracy":1,"timestamp":1609459201,"latitude":"55.755826","mode":1,"inrids":[],"in_regions":[],"city":null,"country":null,"geodata":{},"course":null,"course_accuracy":null,"external_track_id":null,"track_id":null}},{"type":"Feature","geometry":{"type":"Point","coordinates":[37.6173,55.755826]},"properties":{"battery_status":"unplugged","ping":"MyString","battery":1,"tracker_id":"MyString","topic":"MyString","altitude":1,"longitude":"37.6173","velocity":"0","trigger":"background_event","bssid":"MyString","ssid":"MyString","connection":"wifi","vertical_accuracy":1,"accuracy":1,"timestamp":1609459202,"latitude":"55.755826","mode":1,"inrids":[],"in_regions":[],"city":null,"country":null,"geodata":{},"course":null,"course_accuracy":null,"external_track_id":null,"track_id":null}},{"type":"Feature","geometry":{"type":"Point","coordinates":[37.6173,55.755826]},"properties":{"battery_status":"unplugged","ping":"MyString","battery":1,"tracker_id":"MyString","topic":"MyString","altitude":1,"longitude":"37.6173","velocity":"0","trigger":"background_event","bssid":"MyString","ssid":"MyString","connection":"wifi","vertical_accuracy":1,"accuracy":1,"timestamp":1609459203,"latitude":"55.755826","mode":1,"inrids":[],"in_regions":[],"city":null,"country":null,"geodata":{},"course":null,"course_accuracy":null,"external_track_id":null,"track_id":null}},{"type":"Feature","geometry":{"type":"Point","coordinates":[37.6173,55.755826]},"properties":{"battery_status":"unplugged","ping":"MyString","battery":1,"tracker_id":"MyString","topic":"MyString","altitude":1,"longitude":"37.6173","velocity":"0","trigger":"background_event","bssid":"MyString","ssid":"MyString","connection":"wifi","vertical_accuracy":1,"accuracy":1,"timestamp":1609459204,"latitude":"55.755826","mode":1,"inrids":[],"in_regions":[],"city":null,"country":null,"geodata":{},"course":null,"course_accuracy":null,"external_track_id":null,"track_id":null}},{"type":"Feature","geometry":{"type":"Point","coordinates":[37.6173,55.755826]},"properties":{"battery_status":"unplugged","ping":"MyString","battery":1,"tracker_id":"MyString","topic":"MyString","altitude":1,"longitude":"37.6173","velocity":"0","trigger":"background_event","bssid":"MyString","ssid":"MyString","connection":"wifi","vertical_accuracy":1,"accuracy":1,"timestamp":1609459205,"latitude":"55.755826","mode":1,"inrids":[],"in_regions":[],"city":null,"country":null,"geodata":{},"course":null,"course_accuracy":null,"external_track_id":null,"track_id":null}},{"type":"Feature","geometry":{"type":"Point","coordinates":[37.6173,55.755826]},"properties":{"battery_status":"unplugged","ping":"MyString","battery":1,"tracker_id":"MyString","topic":"MyString","altitude":1,"longitude":"37.6173","velocity":"0","trigger":"background_event","bssid":"MyString","ssid":"MyString","connection":"wifi","vertical_accuracy":1,"accuracy":1,"timestamp":1609459206,"latitude":"55.755826","mode":1,"inrids":[],"in_regions":[],"city":null,"country":null,"geodata":{},"course":null,"course_accuracy":null,"external_track_id":null,"track_id":null}},{"type":"Feature","geometry":{"type":"Point","coordinates":[37.6173,55.755826]},"properties":{"battery_status":"unplugged","ping":"MyString","battery":1,"tracker_id":"MyString","topic":"MyString","altitude":1,"longitude":"37.6173","velocity":"0","trigger":"background_event","bssid":"MyString","ssid":"MyString","connection":"wifi","vertical_accuracy":1,"accuracy":1,"timestamp":1609459207,"latitude":"55.755826","mode":1,"inrids":[],"in_regions":[],"city":null,"country":null,"geodata":{},"course":null,"course_accuracy":null,"external_track_id":null,"track_id":null}},{"type":"Feature","geometry":{"type":"Point","coordinates":[37.6173,55.755826]},"properties":{"battery_status":"unplugged","ping":"MyString","battery":1,"tracker_id":"MyString","topic":"MyString","altitude":1,"longitude":"37.6173","velocity":"0","trigger":"background_event","bssid":"MyString","ssid":"MyString","connection":"wifi","vertical_accuracy":1,"accuracy":1,"timestamp":1609459208,"latitude":"55.755826","mode":1,"inrids":[],"in_regions":[],"city":null,"country":null,"geodata":{},"course":null,"course_accuracy":null,"external_track_id":null,"track_id":null}},{"type":"Feature","geometry":{"type":"Point","coordinates":[37.6173,55.755826]},"properties":{"battery_status":"unplugged","ping":"MyString","battery":1,"tracker_id":"MyString","topic":"MyString","altitude":1,"longitude":"37.6173","velocity":"0","trigger":"background_event","bssid":"MyString","ssid":"MyString","connection":"wifi","vertical_accuracy":1,"accuracy":1,"timestamp":1609459209,"latitude":"55.755826","mode":1,"inrids":[],"in_regions":[],"city":null,"country":null,"geodata":{},"course":null,"course_accuracy":null,"external_track_id":null,"track_id":null}}]}
diff --git a/spec/jobs/tracks/create_job_spec.rb b/spec/jobs/tracks/create_job_spec.rb
new file mode 100644
index 00000000..cf88c8a2
--- /dev/null
+++ b/spec/jobs/tracks/create_job_spec.rb
@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Tracks::CreateJob, type: :job do
+ let(:user) { create(:user) }
+
+ describe '#perform' do
+ let(:service_instance) { instance_double(Tracks::CreateFromPoints) }
+ let(:notification_service) { instance_double(Notifications::Create) }
+
+ before do
+ allow(Tracks::CreateFromPoints).to receive(:new).with(user).and_return(service_instance)
+ allow(service_instance).to receive(:call).and_return(3)
+ allow(Notifications::Create).to receive(:new).and_return(notification_service)
+ allow(notification_service).to receive(:call)
+ end
+
+ it 'calls the service and creates a notification' do
+ described_class.new.perform(user.id)
+
+ expect(Tracks::CreateFromPoints).to have_received(:new).with(user)
+ expect(service_instance).to have_received(:call)
+ expect(Notifications::Create).to have_received(:new).with(
+ user: user,
+ kind: :info,
+ title: 'Tracks Generated',
+ content: 'Created 3 tracks from your location data. Check your tracks section to view them.'
+ )
+ expect(notification_service).to have_received(:call)
+ end
+
+ context 'when service raises an error' do
+ let(:error_message) { 'Something went wrong' }
+ let(:service_instance) { instance_double(Tracks::CreateFromPoints) }
+ let(:notification_service) { instance_double(Notifications::Create) }
+
+ before do
+ allow(Tracks::CreateFromPoints).to receive(:new).with(user).and_return(service_instance)
+ allow(service_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 'creates an error notification' do
+ described_class.new.perform(user.id)
+
+ expect(Notifications::Create).to have_received(:new).with(
+ user: user,
+ kind: :error,
+ title: 'Track Generation Failed',
+ content: "Failed to generate tracks from your location data: #{error_message}"
+ )
+ expect(notification_service).to have_received(: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
+ it 'handles the error gracefully and creates error notification' 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))
+
+ # Should not raise an error because it's caught by the rescue block
+ expect { described_class.new.perform(999) }.not_to raise_error
+
+ expect(ExceptionReporter).to have_received(:call)
+ end
+ end
+ end
+
+ describe 'queue' do
+ it 'is queued on default queue' do
+ expect(described_class.new.queue_name).to eq('default')
+ end
+ end
+end
diff --git a/spec/models/point_spec.rb b/spec/models/point_spec.rb
index 7b5acd77..eb56f84e 100644
--- a/spec/models/point_spec.rb
+++ b/spec/models/point_spec.rb
@@ -8,6 +8,7 @@ RSpec.describe Point, type: :model do
it { is_expected.to belong_to(:user) }
it { is_expected.to belong_to(:country).optional }
it { is_expected.to belong_to(:visit).optional }
+ it { is_expected.to belong_to(:track).optional }
end
describe 'validations' do
@@ -28,6 +29,17 @@ RSpec.describe Point, type: :model do
expect(point.country_id).to eq(country.id)
end
end
+
+ describe '#recalculate_track' do
+ let(:point) { create(:point, track: track) }
+ let(:track) { create(:track) }
+
+ it 'recalculates the track' do
+ expect(track).to receive(:recalculate_path_and_distance!)
+
+ point.update(lonlat: 'POINT(-79.85581250721961 15.854775993302411)')
+ end
+ end
end
describe 'scopes' do
@@ -108,5 +120,16 @@ RSpec.describe Point, type: :model do
expect(point.lat).to eq(2)
end
end
+
+ describe '#trigger_incremental_track_generation' do
+ let(:point) do
+ create(:point, track: track, import_id: nil, timestamp: 1.hour.ago.to_i, reverse_geocoded_at: 1.hour.ago)
+ end
+ let(:track) { create(:track) }
+
+ it 'enqueues Tracks::IncrementalGeneratorJob' do
+ expect { point.send(:trigger_incremental_track_generation) }.to have_enqueued_job(Tracks::IncrementalGeneratorJob).with(point.user_id, point.recorded_at.to_date.to_s, 5)
+ end
+ end
end
end
diff --git a/spec/models/stat_spec.rb b/spec/models/stat_spec.rb
index 90337f2f..ee4c477f 100644
--- a/spec/models/stat_spec.rb
+++ b/spec/models/stat_spec.rb
@@ -29,7 +29,7 @@ RSpec.describe Stat, type: :model do
create(:point, user:, lonlat: 'POINT(2 2)', timestamp: DateTime.new(year, 1, 1, 2))
end
- before { expected_distance[0][1] = 156.88 }
+ before { expected_distance[0][1] = 156_876 }
it 'returns distance by day' do
expect(subject).to eq(expected_distance)
diff --git a/spec/models/track_spec.rb b/spec/models/track_spec.rb
new file mode 100644
index 00000000..70ed1f2d
--- /dev/null
+++ b/spec/models/track_spec.rb
@@ -0,0 +1,193 @@
+require 'rails_helper'
+
+RSpec.describe Track, type: :model do
+ describe 'associations' do
+ it { is_expected.to belong_to(:user) }
+ it { is_expected.to have_many(:points).dependent(:nullify) }
+ end
+
+ describe 'validations' do
+ subject { build(:track) }
+
+ it { is_expected.to validate_presence_of(:start_at) }
+ it { is_expected.to validate_presence_of(:end_at) }
+ it { is_expected.to validate_presence_of(:original_path) }
+ it { is_expected.to validate_numericality_of(:distance).is_greater_than_or_equal_to(0) }
+ it { is_expected.to validate_numericality_of(:avg_speed).is_greater_than_or_equal_to(0) }
+ it { is_expected.to validate_numericality_of(:duration).is_greater_than_or_equal_to(0) }
+ end
+
+ describe '.last_for_day' do
+ let(:user) { create(:user) }
+ let(:other_user) { create(:user) }
+ let(:target_day) { Date.current }
+
+ context 'when user has tracks on the target day' do
+ let!(:early_track) do
+ create(:track, user: user,
+ start_at: target_day.beginning_of_day + 1.hour,
+ end_at: target_day.beginning_of_day + 2.hours)
+ end
+
+ let!(:late_track) do
+ create(:track, user: user,
+ start_at: target_day.beginning_of_day + 3.hours,
+ end_at: target_day.beginning_of_day + 4.hours)
+ end
+
+ let!(:other_user_track) do
+ create(:track, user: other_user,
+ start_at: target_day.beginning_of_day + 5.hours,
+ end_at: target_day.beginning_of_day + 6.hours)
+ end
+
+ it 'returns the track that ends latest on that day for the user' do
+ result = Track.last_for_day(user, target_day)
+ expect(result).to eq(late_track)
+ end
+
+ it 'does not return tracks from other users' do
+ result = Track.last_for_day(user, target_day)
+ expect(result).not_to eq(other_user_track)
+ end
+ end
+
+ context 'when user has tracks on different days' do
+ let!(:yesterday_track) do
+ create(:track, user: user,
+ start_at: target_day.yesterday.beginning_of_day + 1.hour,
+ end_at: target_day.yesterday.beginning_of_day + 2.hours)
+ end
+
+ let!(:tomorrow_track) do
+ create(:track, user: user,
+ start_at: target_day.tomorrow.beginning_of_day + 1.hour,
+ end_at: target_day.tomorrow.beginning_of_day + 2.hours)
+ end
+
+ let!(:target_day_track) do
+ create(:track, user: user,
+ start_at: target_day.beginning_of_day + 1.hour,
+ end_at: target_day.beginning_of_day + 2.hours)
+ end
+
+ it 'returns only the track from the target day' do
+ result = Track.last_for_day(user, target_day)
+ expect(result).to eq(target_day_track)
+ end
+ end
+
+ context 'when user has no tracks on the target day' do
+ let!(:yesterday_track) do
+ create(:track, user: user,
+ start_at: target_day.yesterday.beginning_of_day + 1.hour,
+ end_at: target_day.yesterday.beginning_of_day + 2.hours)
+ end
+
+ it 'returns nil' do
+ result = Track.last_for_day(user, target_day)
+ expect(result).to be_nil
+ end
+ end
+
+ context 'when passing a Time object instead of Date' do
+ let!(:track) do
+ create(:track, user: user,
+ start_at: target_day.beginning_of_day + 1.hour,
+ end_at: target_day.beginning_of_day + 2.hours)
+ end
+
+ it 'correctly handles Time objects' do
+ result = Track.last_for_day(user, target_day.to_time)
+ expect(result).to eq(track)
+ end
+ end
+
+ context 'when track spans midnight' do
+ let!(:spanning_track) do
+ create(:track, user: user,
+ start_at: target_day.beginning_of_day - 1.hour,
+ end_at: target_day.beginning_of_day + 1.hour)
+ end
+
+ it 'includes tracks that end on the target day' do
+ result = Track.last_for_day(user, target_day)
+ expect(result).to eq(spanning_track)
+ end
+ end
+ end
+
+ describe 'Calculateable concern' do
+ let(:user) { create(:user) }
+ let(:track) { create(:track, user: user, distance: 1000, avg_speed: 25, duration: 3600) }
+ let!(:points) do
+ [
+ create(:point, user: user, track: track, lonlat: 'POINT(13.404954 52.520008)', timestamp: 1.hour.ago.to_i),
+ create(:point, user: user, track: track, lonlat: 'POINT(13.405954 52.521008)', timestamp: 30.minutes.ago.to_i),
+ create(:point, user: user, track: track, lonlat: 'POINT(13.406954 52.522008)', timestamp: Time.current.to_i)
+ ]
+ end
+
+ describe '#calculate_path' do
+ it 'updates the original_path with calculated path' do
+ original_path_before = track.original_path
+ track.calculate_path
+
+ expect(track.original_path).not_to eq(original_path_before)
+ expect(track.original_path).to be_present
+ end
+ end
+
+ describe '#calculate_distance' do
+ it 'updates the distance based on points' do
+ track.calculate_distance
+
+ expect(track.distance).to be > 0
+ expect(track.distance).to be_a(Numeric)
+ end
+
+ it 'stores distance in meters consistently' do
+ allow(Point).to receive(:total_distance).and_return(1500) # 1500 meters
+
+ track.calculate_distance
+
+ expect(track.distance).to eq(1500) # Should be stored as meters regardless of user unit preference
+ end
+ end
+
+ describe '#recalculate_distance!' do
+ it 'recalculates and saves the distance' do
+ original_distance = track.distance
+
+ track.recalculate_distance!
+
+ track.reload
+ expect(track.distance).not_to eq(original_distance)
+ end
+ end
+
+ describe '#recalculate_path!' do
+ it 'recalculates and saves the path' do
+ original_path = track.original_path
+
+ track.recalculate_path!
+
+ track.reload
+ expect(track.original_path).not_to eq(original_path)
+ end
+ end
+
+ describe '#recalculate_path_and_distance!' do
+ it 'recalculates both path and distance and saves' do
+ original_distance = track.distance
+ original_path = track.original_path
+
+ track.recalculate_path_and_distance!
+
+ track.reload
+ expect(track.distance).not_to eq(original_distance)
+ expect(track.original_path).not_to eq(original_path)
+ end
+ end
+ end
+end
diff --git a/spec/models/trip_spec.rb b/spec/models/trip_spec.rb
index 7b2bf233..eecf3fb8 100644
--- a/spec/models/trip_spec.rb
+++ b/spec/models/trip_spec.rb
@@ -137,4 +137,49 @@ RSpec.describe Trip, type: :model do
end
end
end
+
+ describe 'Calculateable concern' do
+ let(:user) { create(:user) }
+ let(:trip) { create(:trip, user: user) }
+ let!(:points) do
+ [
+ create(:point, user: user, lonlat: 'POINT(13.404954 52.520008)', timestamp: trip.started_at.to_i + 1.hour),
+ create(:point, user: user, lonlat: 'POINT(13.404955 52.520009)', timestamp: trip.started_at.to_i + 2.hours),
+ create(:point, user: user, lonlat: 'POINT(13.404956 52.520010)', timestamp: trip.started_at.to_i + 3.hours)
+ ]
+ end
+
+ describe '#calculate_distance' do
+ it 'stores distance in user preferred unit for Trip model' do
+ allow(user).to receive(:safe_settings).and_return(double(distance_unit: 'km'))
+ allow(Point).to receive(:total_distance).and_return(2.5) # 2.5 km
+
+ trip.calculate_distance
+
+ expect(trip.distance).to eq(3) # Should be rounded, in km
+ end
+ end
+
+ describe '#recalculate_distance!' do
+ it 'recalculates and saves the distance' do
+ original_distance = trip.distance
+
+ trip.recalculate_distance!
+
+ trip.reload
+ expect(trip.distance).not_to eq(original_distance)
+ end
+ end
+
+ describe '#recalculate_path!' do
+ it 'recalculates and saves the path' do
+ original_path = trip.path
+
+ trip.recalculate_path!
+
+ trip.reload
+ expect(trip.path).not_to eq(original_path)
+ end
+ end
+ end
end
diff --git a/spec/models/user_spec.rb b/spec/models/user_spec.rb
index 2b431d44..a1c5601f 100644
--- a/spec/models/user_spec.rb
+++ b/spec/models/user_spec.rb
@@ -14,6 +14,7 @@ RSpec.describe User, type: :model do
it { is_expected.to have_many(:visits).dependent(:destroy) }
it { is_expected.to have_many(:places).through(:visits) }
it { is_expected.to have_many(:trips).dependent(:destroy) }
+ it { is_expected.to have_many(:tracks).dependent(:destroy) }
end
describe 'enums' do
@@ -87,11 +88,11 @@ RSpec.describe User, type: :model do
describe '#total_distance' do
subject { user.total_distance }
- let!(:stat1) { create(:stat, user:, distance: 10) }
- let!(:stat2) { create(:stat, user:, distance: 20) }
+ let!(:stat1) { create(:stat, user:, distance: 10_000) }
+ let!(:stat2) { create(:stat, user:, distance: 20_000) }
it 'returns sum of distances' do
- expect(subject).to eq(30)
+ expect(subject).to eq(30) # 30 km
end
end
diff --git a/spec/requests/api/v1/stats_spec.rb b/spec/requests/api/v1/stats_spec.rb
index 89cdc8e4..43e8f142 100644
--- a/spec/requests/api/v1/stats_spec.rb
+++ b/spec/requests/api/v1/stats_spec.rb
@@ -21,7 +21,7 @@ RSpec.describe 'Api::V1::Stats', type: :request do
end
let(:expected_json) do
{
- totalDistanceKm: stats_in_2020.map(&:distance).sum + stats_in_2021.map(&:distance).sum,
+ totalDistanceKm: (stats_in_2020.map(&:distance).sum + stats_in_2021.map(&:distance).sum) / 1000,
totalPointsTracked: points_in_2020.count + points_in_2021.count,
totalReverseGeocodedPoints: points_in_2020.count + points_in_2021.count,
totalCountriesVisited: 1,
@@ -29,7 +29,7 @@ RSpec.describe 'Api::V1::Stats', type: :request do
yearlyStats: [
{
year: 2021,
- totalDistanceKm: 12,
+ totalDistanceKm: (stats_in_2021.map(&:distance).sum / 1000).to_i,
totalCountriesVisited: 1,
totalCitiesVisited: 1,
monthlyDistanceKm: {
@@ -49,7 +49,7 @@ RSpec.describe 'Api::V1::Stats', type: :request do
},
{
year: 2020,
- totalDistanceKm: 12,
+ totalDistanceKm: (stats_in_2020.map(&:distance).sum / 1000).to_i,
totalCountriesVisited: 1,
totalCitiesVisited: 1,
monthlyDistanceKm: {
diff --git a/spec/serializers/point_serializer_spec.rb b/spec/serializers/point_serializer_spec.rb
index 2f2a9742..d7ae5336 100644
--- a/spec/serializers/point_serializer_spec.rb
+++ b/spec/serializers/point_serializer_spec.rb
@@ -33,7 +33,8 @@ RSpec.describe PointSerializer do
'geodata' => point.geodata,
'course' => point.course,
'course_accuracy' => point.course_accuracy,
- 'external_track_id' => point.external_track_id
+ 'external_track_id' => point.external_track_id,
+ 'track_id' => point.track_id
}
end
diff --git a/spec/serializers/stats_serializer_spec.rb b/spec/serializers/stats_serializer_spec.rb
index 2fba6656..eef34e59 100644
--- a/spec/serializers/stats_serializer_spec.rb
+++ b/spec/serializers/stats_serializer_spec.rb
@@ -40,7 +40,7 @@ RSpec.describe StatsSerializer do
end
let(:expected_json) do
{
- "totalDistanceKm": stats_in_2020.map(&:distance).sum + stats_in_2021.map(&:distance).sum,
+ "totalDistanceKm": (stats_in_2020.map(&:distance).sum + stats_in_2021.map(&:distance).sum) / 1000,
"totalPointsTracked": points_in_2020.count + points_in_2021.count,
"totalReverseGeocodedPoints": points_in_2020.count + points_in_2021.count,
"totalCountriesVisited": 1,
@@ -48,7 +48,7 @@ RSpec.describe StatsSerializer do
"yearlyStats": [
{
"year": 2021,
- "totalDistanceKm": 12,
+ "totalDistanceKm": (stats_in_2021.map(&:distance).sum / 1000).to_i,
"totalCountriesVisited": 1,
"totalCitiesVisited": 1,
"monthlyDistanceKm": {
@@ -68,7 +68,7 @@ RSpec.describe StatsSerializer do
},
{
"year": 2020,
- "totalDistanceKm": 12,
+ "totalDistanceKm": (stats_in_2020.map(&:distance).sum / 1000).to_i,
"totalCountriesVisited": 1,
"totalCitiesVisited": 1,
"monthlyDistanceKm": {
diff --git a/spec/serializers/track_serializer_spec.rb b/spec/serializers/track_serializer_spec.rb
new file mode 100644
index 00000000..42f99175
--- /dev/null
+++ b/spec/serializers/track_serializer_spec.rb
@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe TrackSerializer do
+ describe '#call' do
+ let(:user) { create(:user) }
+
+ context 'when serializing user tracks with track IDs' do
+ subject(:serializer) { described_class.new(user, track_ids).call }
+
+ let!(:track1) { create(:track, user: user, start_at: 2.hours.ago, end_at: 1.hour.ago) }
+ let!(:track2) { create(:track, user: user, start_at: 4.hours.ago, end_at: 3.hours.ago) }
+ let!(:track3) { create(:track, user: user, start_at: 6.hours.ago, end_at: 5.hours.ago) }
+ let(:track_ids) { [track1.id, track2.id] }
+
+ it 'returns an array of serialized tracks' do
+ expect(serializer).to be_an(Array)
+ expect(serializer.length).to eq(2)
+ end
+
+ it 'serializes each track correctly' do
+ serialized_ids = serializer.map { |track| track[:id] }
+ expect(serialized_ids).to contain_exactly(track1.id, track2.id)
+ expect(serialized_ids).not_to include(track3.id)
+ end
+
+ it 'formats timestamps as ISO8601 for all tracks' do
+ serializer.each do |track|
+ expect(track[:start_at]).to match(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/)
+ expect(track[:end_at]).to match(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/)
+ end
+ end
+
+ it 'includes all required fields for each track' do
+ serializer.each do |track|
+ expect(track.keys).to contain_exactly(
+ :id, :start_at, :end_at, :distance, :avg_speed, :duration,
+ :elevation_gain, :elevation_loss, :elevation_max, :elevation_min, :original_path
+ )
+ end
+ end
+
+ it 'handles numeric values correctly' do
+ serializer.each do |track|
+ expect(track[:distance]).to be_a(Numeric)
+ expect(track[:avg_speed]).to be_a(Numeric)
+ expect(track[:duration]).to be_a(Numeric)
+ expect(track[:elevation_gain]).to be_a(Numeric)
+ expect(track[:elevation_loss]).to be_a(Numeric)
+ expect(track[:elevation_max]).to be_a(Numeric)
+ expect(track[:elevation_min]).to be_a(Numeric)
+ end
+ end
+
+ it 'orders tracks by start_at in ascending order' do
+ serialized_tracks = serializer
+ expect(serialized_tracks.first[:id]).to eq(track2.id) # Started 4 hours ago
+ expect(serialized_tracks.second[:id]).to eq(track1.id) # Started 2 hours ago
+ end
+ end
+
+ context 'when track IDs belong to different users' do
+ subject(:serializer) { described_class.new(user, track_ids).call }
+
+ let(:other_user) { create(:user) }
+ let!(:user_track) { create(:track, user: user) }
+ let!(:other_user_track) { create(:track, user: other_user) }
+ let(:track_ids) { [user_track.id, other_user_track.id] }
+
+ it 'only returns tracks belonging to the specified user' do
+ serialized_ids = serializer.map { |track| track[:id] }
+ expect(serialized_ids).to contain_exactly(user_track.id)
+ expect(serialized_ids).not_to include(other_user_track.id)
+ end
+ end
+
+ context 'when track IDs array is empty' do
+ subject(:serializer) { described_class.new(user, []).call }
+
+ it 'returns an empty array' do
+ expect(serializer).to eq([])
+ end
+ end
+
+ context 'when track IDs contain non-existent IDs' do
+ subject(:serializer) { described_class.new(user, track_ids).call }
+
+ let!(:existing_track) { create(:track, user: user) }
+ let(:track_ids) { [existing_track.id, 999999] }
+
+ it 'only returns existing tracks' do
+ serialized_ids = serializer.map { |track| track[:id] }
+ expect(serialized_ids).to contain_exactly(existing_track.id)
+ expect(serializer.length).to eq(1)
+ end
+ end
+ end
+end
diff --git a/spec/services/stats/calculate_month_spec.rb b/spec/services/stats/calculate_month_spec.rb
index 83069d08..275c46a9 100644
--- a/spec/services/stats/calculate_month_spec.rb
+++ b/spec/services/stats/calculate_month_spec.rb
@@ -53,15 +53,17 @@ RSpec.describe Stats::CalculateMonth do
lonlat: 'POINT(9.77973105800526 52.72859111523629)')
end
- context 'when units are kilometers' do
+ context 'when calculating distance' do
it 'creates stats' do
expect { calculate_stats }.to change { Stat.count }.by(1)
end
- it 'calculates distance' do
+ it 'calculates distance in meters consistently' do
calculate_stats
- expect(user.stats.last.distance).to eq(339)
+ # Distance should be calculated in meters regardless of user unit preference
+ # The actual distance between the test points is approximately 340 km = 340,000 meters
+ expect(user.stats.last.distance).to be_within(1000).of(340_000)
end
context 'when there is an error' do
@@ -79,33 +81,16 @@ RSpec.describe Stats::CalculateMonth do
end
end
- context 'when units are miles' do
+ context 'when user prefers miles' do
before do
user.update(settings: { maps: { distance_unit: 'mi' } })
end
- it 'creates stats' do
- expect { calculate_stats }.to change { Stat.count }.by(1)
- end
-
- it 'calculates distance' do
+ it 'still stores distance in meters (same as km users)' do
calculate_stats
- expect(user.stats.last.distance).to eq(211)
- end
-
- context 'when there is an error' do
- before do
- allow(Stat).to receive(:find_or_initialize_by).and_raise(StandardError)
- end
-
- it 'does not create stats' do
- expect { calculate_stats }.not_to(change { Stat.count })
- end
-
- it 'creates a notification' do
- expect { calculate_stats }.to change { Notification.count }.by(1)
- end
+ # Distance stored should be the same regardless of user preference (meters)
+ expect(user.stats.last.distance).to be_within(1000).of(340_000)
end
end
end
diff --git a/spec/services/tracks/create_from_points_spec.rb b/spec/services/tracks/create_from_points_spec.rb
new file mode 100644
index 00000000..00307ffe
--- /dev/null
+++ b/spec/services/tracks/create_from_points_spec.rb
@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Tracks::CreateFromPoints do
+ let(:user) { create(:user) }
+ let(:service) { described_class.new(user) }
+
+ describe '#initialize' do
+ it 'sets user and thresholds from user settings' do
+ expect(service.user).to eq(user)
+ expect(service.distance_threshold_meters).to eq(user.safe_settings.meters_between_routes.to_i)
+ expect(service.time_threshold_minutes).to eq(user.safe_settings.minutes_between_routes.to_i)
+ end
+
+ context 'with custom user settings' do
+ before do
+ user.update!(settings: user.settings.merge({
+ 'meters_between_routes' => 1000,
+ 'minutes_between_routes' => 60
+ }))
+ end
+
+ it 'uses custom settings' do
+ service = described_class.new(user)
+ expect(service.distance_threshold_meters).to eq(1000)
+ expect(service.time_threshold_minutes).to eq(60)
+ end
+ end
+ end
+
+ describe '#call' do
+ context 'with no points' do
+ it 'returns 0 tracks created' do
+ expect(service.call).to eq(0)
+ end
+ end
+
+ context 'with insufficient points' do
+ let!(:single_point) { create(:point, user: user, timestamp: 1.hour.ago.to_i) }
+
+ it 'returns 0 tracks created' do
+ expect(service.call).to eq(0)
+ end
+ end
+
+ context 'with points that form a single track' do
+ let(:base_time) { 1.hour.ago }
+ let!(:points) do
+ [
+ create(:point, user: user, timestamp: base_time.to_i,
+ lonlat: 'POINT(-74.0060 40.7128)', altitude: 10),
+ create(:point, user: user, timestamp: (base_time + 5.minutes).to_i,
+ lonlat: 'POINT(-74.0070 40.7130)', altitude: 15),
+ create(:point, user: user, timestamp: (base_time + 10.minutes).to_i,
+ lonlat: 'POINT(-74.0080 40.7132)', altitude: 20)
+ ]
+ end
+
+ it 'creates one track' do
+ expect { service.call }.to change(Track, :count).by(1)
+ end
+
+ it 'returns 1 track created' do
+ expect(service.call).to eq(1)
+ end
+
+ it 'sets track attributes correctly' do
+ service.call
+ track = Track.last
+
+ expect(track.user).to eq(user)
+ expect(track.start_at).to be_within(1.second).of(base_time)
+ expect(track.end_at).to be_within(1.second).of(base_time + 10.minutes)
+ expect(track.duration).to eq(600) # 10 minutes in seconds
+ expect(track.original_path).to be_present
+ expect(track.distance).to be > 0
+ expect(track.avg_speed).to be > 0
+ expect(track.elevation_gain).to eq(10) # 20 - 10
+ expect(track.elevation_loss).to eq(0)
+ expect(track.elevation_max).to eq(20)
+ expect(track.elevation_min).to eq(10)
+ end
+
+ it 'associates points with the track' do
+ service.call
+ track = Track.last
+ expect(points.map(&:reload).map(&:track)).to all(eq(track))
+ end
+ end
+
+ context 'with points that should be split by time' do
+ let(:base_time) { 2.hours.ago }
+ let!(:points) do
+ [
+ # First track
+ create(:point, user: user, timestamp: base_time.to_i,
+ lonlat: 'POINT(-74.0060 40.7128)'),
+ create(:point, user: user, timestamp: (base_time + 5.minutes).to_i,
+ lonlat: 'POINT(-74.0070 40.7130)'),
+
+ # Gap > time threshold (default 30 minutes)
+ create(:point, user: user, timestamp: (base_time + 45.minutes).to_i,
+ lonlat: 'POINT(-74.0080 40.7132)'),
+ create(:point, user: user, timestamp: (base_time + 50.minutes).to_i,
+ lonlat: 'POINT(-74.0090 40.7134)')
+ ]
+ end
+
+ it 'creates two tracks' do
+ expect { service.call }.to change(Track, :count).by(2)
+ end
+
+ it 'returns 2 tracks created' do
+ expect(service.call).to eq(2)
+ end
+ end
+
+ context 'with points that should be split by distance' do
+ let(:base_time) { 1.hour.ago }
+ let!(:points) do
+ [
+ # First track - close points
+ create(:point, user: user, timestamp: base_time.to_i,
+ lonlat: 'POINT(-74.0060 40.7128)'),
+ create(:point, user: user, timestamp: (base_time + 1.minute).to_i,
+ lonlat: 'POINT(-74.0061 40.7129)'),
+
+ # Far point (> distance threshold, but within time threshold)
+ create(:point, user: user, timestamp: (base_time + 2.minutes).to_i,
+ lonlat: 'POINT(-74.0500 40.7500)'), # ~5km away
+ create(:point, user: user, timestamp: (base_time + 3.minutes).to_i,
+ lonlat: 'POINT(-74.0501 40.7501)')
+ ]
+ end
+
+ it 'creates two tracks' do
+ expect { service.call }.to change(Track, :count).by(2)
+ end
+ end
+
+ context 'with existing tracks' do
+ let!(:existing_track) { create(:track, user: user) }
+ let!(:points) do
+ [
+ create(:point, user: user, timestamp: 1.hour.ago.to_i,
+ lonlat: 'POINT(-74.0060 40.7128)'),
+ create(:point, user: user, timestamp: 50.minutes.ago.to_i,
+ lonlat: 'POINT(-74.0070 40.7130)')
+ ]
+ end
+
+ it 'destroys existing tracks and creates new ones' do
+ expect { service.call }.to change(Track, :count).by(0) # -1 + 1
+ expect(Track.exists?(existing_track.id)).to be false
+ end
+ end
+
+ context 'with mixed elevation data' do
+ let!(:points) do
+ [
+ create(:point, user: user, timestamp: 1.hour.ago.to_i,
+ lonlat: 'POINT(-74.0060 40.7128)', altitude: 100),
+ create(:point, user: user, timestamp: 50.minutes.ago.to_i,
+ lonlat: 'POINT(-74.0070 40.7130)', altitude: 150),
+ create(:point, user: user, timestamp: 40.minutes.ago.to_i,
+ lonlat: 'POINT(-74.0080 40.7132)', altitude: 120)
+ ]
+ end
+
+ it 'calculates elevation correctly' do
+ service.call
+ track = Track.last
+
+ expect(track.elevation_gain).to eq(50) # 150 - 100
+ expect(track.elevation_loss).to eq(30) # 150 - 120
+ expect(track.elevation_max).to eq(150)
+ expect(track.elevation_min).to eq(100)
+ end
+ end
+
+ context 'with points missing altitude data' do
+ let!(:points) do
+ [
+ create(:point, user: user, timestamp: 1.hour.ago.to_i,
+ lonlat: 'POINT(-74.0060 40.7128)', altitude: nil),
+ create(:point, user: user, timestamp: 50.minutes.ago.to_i,
+ lonlat: 'POINT(-74.0070 40.7130)', altitude: nil)
+ ]
+ end
+
+ it 'uses default elevation values' do
+ service.call
+ track = Track.last
+
+ expect(track.elevation_gain).to eq(0)
+ expect(track.elevation_loss).to eq(0)
+ expect(track.elevation_max).to eq(0)
+ expect(track.elevation_min).to eq(0)
+ end
+ end
+ end
+
+ describe 'private methods' do
+ describe '#should_start_new_track?' do
+ let(:point1) { build(:point, timestamp: 1.hour.ago.to_i, lonlat: 'POINT(-74.0060 40.7128)') }
+ let(:point2) { build(:point, timestamp: 50.minutes.ago.to_i, lonlat: 'POINT(-74.0070 40.7130)') }
+
+ it 'returns false when previous point is nil' do
+ result = service.send(:should_start_new_track?, point1, nil)
+ expect(result).to be false
+ end
+
+ it 'returns true when time threshold is exceeded' do
+ # Create a point > 30 minutes later (default threshold)
+ later_point = build(:point, timestamp: 29.minutes.ago.to_i, lonlat: 'POINT(-74.0070 40.7130)')
+
+ result = service.send(:should_start_new_track?, later_point, point1)
+ expect(result).to be true
+ end
+
+ it 'returns true when distance threshold is exceeded' do
+ # Create a point far away (> 500m default threshold)
+ far_point = build(:point, timestamp: 59.minutes.ago.to_i, lonlat: 'POINT(-74.0500 40.7500)')
+
+ result = service.send(:should_start_new_track?, far_point, point1)
+ expect(result).to be true
+ end
+
+ it 'returns false when both thresholds are not exceeded' do
+ result = service.send(:should_start_new_track?, point2, point1)
+ expect(result).to be false
+ end
+ end
+
+ describe '#calculate_distance_kilometers' do
+ let(:point1) { build(:point, lonlat: 'POINT(-74.0060 40.7128)') }
+ let(:point2) { build(:point, lonlat: 'POINT(-74.0070 40.7130)') }
+
+ it 'calculates distance between two points in kilometers' do
+ distance = service.send(:calculate_distance_kilometers, point1, point2)
+ expect(distance).to be > 0
+ expect(distance).to be < 0.2 # Should be small distance for close points (in km)
+ end
+ end
+
+ describe '#calculate_average_speed' do
+ it 'calculates speed correctly' do
+ # 1000 meters in 100 seconds = 10 m/s = 36 km/h
+ speed = service.send(:calculate_average_speed, 1000, 100)
+ expect(speed).to eq(36.0)
+ end
+
+ it 'returns 0 for zero duration' do
+ speed = service.send(:calculate_average_speed, 1000, 0)
+ expect(speed).to eq(0.0)
+ end
+
+ it 'returns 0 for zero distance' do
+ speed = service.send(:calculate_average_speed, 0, 100)
+ expect(speed).to eq(0.0)
+ end
+ end
+
+ describe '#calculate_track_distance' do
+ let(:points) do
+ [
+ build(:point, lonlat: 'POINT(-74.0060 40.7128)'),
+ build(:point, lonlat: 'POINT(-74.0070 40.7130)')
+ ]
+ end
+
+ it 'stores distance in meters by default' do
+ distance = service.send(:calculate_track_distance, points)
+ expect(distance).to eq(87)
+ end
+ end
+ end
+end
diff --git a/spec/services/tracks/generator_spec.rb b/spec/services/tracks/generator_spec.rb
new file mode 100644
index 00000000..2463c1bf
--- /dev/null
+++ b/spec/services/tracks/generator_spec.rb
@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Tracks::Generator do
+ let(:user) { create(:user) }
+ let(:point_loader) { double('PointLoader') }
+ let(:incomplete_segment_handler) { double('IncompleteSegmentHandler') }
+ let(:track_cleaner) { double('TrackCleaner') }
+
+ let(:generator) do
+ described_class.new(
+ user,
+ point_loader: point_loader,
+ incomplete_segment_handler: incomplete_segment_handler,
+ track_cleaner: track_cleaner
+ )
+ end
+
+ before do
+ allow_any_instance_of(Users::SafeSettings).to receive(:meters_between_routes).and_return(500)
+ allow_any_instance_of(Users::SafeSettings).to receive(:minutes_between_routes).and_return(60)
+ allow_any_instance_of(Users::SafeSettings).to receive(:distance_unit).and_return('km')
+ end
+
+ describe '#call' do
+ context 'with no points to process' do
+ before do
+ allow(track_cleaner).to receive(:cleanup)
+ allow(point_loader).to receive(:load_points).and_return([])
+ end
+
+ it 'returns 0 tracks created' do
+ result = generator.call
+ expect(result).to eq(0)
+ end
+
+ it 'does not call incomplete segment handler' do
+ expect(incomplete_segment_handler).not_to receive(:should_finalize_segment?)
+ expect(incomplete_segment_handler).not_to receive(:handle_incomplete_segment)
+ expect(incomplete_segment_handler).not_to receive(:cleanup_processed_data)
+
+ generator.call
+ end
+ end
+
+ context 'with points that create tracks' do
+ let!(:points) do
+ [
+ create(:point, user: user, lonlat: 'POINT(-74.0060 40.7128)', timestamp: 1.hour.ago.to_i, latitude: 40.7128, longitude: -74.0060),
+ create(:point, user: user, lonlat: 'POINT(-74.0050 40.7138)', timestamp: 30.minutes.ago.to_i, latitude: 40.7138, longitude: -74.0050),
+ create(:point, user: user, lonlat: 'POINT(-74.0040 40.7148)', timestamp: 10.minutes.ago.to_i, latitude: 40.7148, longitude: -74.0040)
+ ]
+ end
+
+ before do
+ allow(track_cleaner).to receive(:cleanup)
+ allow(point_loader).to receive(:load_points).and_return(points)
+ allow(incomplete_segment_handler).to receive(:should_finalize_segment?).and_return(true)
+ allow(incomplete_segment_handler).to receive(:cleanup_processed_data)
+ end
+
+ it 'creates tracks from segments' do
+ expect { generator.call }.to change { Track.count }.by(1)
+ end
+
+ it 'returns the number of tracks created' do
+ result = generator.call
+ expect(result).to eq(1)
+ end
+
+ it 'calls cleanup on processed data' do
+ expect(incomplete_segment_handler).to receive(:cleanup_processed_data)
+ generator.call
+ end
+
+ it 'assigns points to the created track' do
+ generator.call
+ points.each(&:reload)
+ track_ids = points.map(&:track_id).uniq.compact
+ expect(track_ids.size).to eq(1)
+ end
+ end
+
+ context 'with incomplete segments' do
+ let!(:points) do
+ [
+ create(:point, user: user, lonlat: 'POINT(-74.0060 40.7128)', timestamp: 5.minutes.ago.to_i, latitude: 40.7128, longitude: -74.0060),
+ create(:point, user: user, lonlat: 'POINT(-74.0050 40.7138)', timestamp: 4.minutes.ago.to_i, latitude: 40.7138, longitude: -74.0050)
+ ]
+ end
+
+ before do
+ allow(track_cleaner).to receive(:cleanup)
+ allow(point_loader).to receive(:load_points).and_return(points)
+ allow(incomplete_segment_handler).to receive(:should_finalize_segment?).and_return(false)
+ allow(incomplete_segment_handler).to receive(:handle_incomplete_segment)
+ allow(incomplete_segment_handler).to receive(:cleanup_processed_data)
+ end
+
+ it 'does not create tracks' do
+ expect { generator.call }.not_to change { Track.count }
+ end
+
+ it 'handles incomplete segments' do
+ expect(incomplete_segment_handler).to receive(:handle_incomplete_segment).with(points)
+ generator.call
+ end
+
+ it 'returns 0 tracks created' do
+ result = generator.call
+ expect(result).to eq(0)
+ end
+ end
+
+ context 'with mixed complete and incomplete segments' do
+ let!(:old_points) do
+ [
+ create(:point, user: user, lonlat: 'POINT(-74.0060 40.7128)', timestamp: 2.hours.ago.to_i, latitude: 40.7128, longitude: -74.0060),
+ create(:point, user: user, lonlat: 'POINT(-74.0050 40.7138)', timestamp: 1.hour.ago.to_i, latitude: 40.7138, longitude: -74.0050)
+ ]
+ end
+
+ let!(:recent_points) do
+ [
+ create(:point, user: user, lonlat: 'POINT(-74.0040 40.7148)', timestamp: 3.minutes.ago.to_i, latitude: 40.7148, longitude: -74.0040),
+ create(:point, user: user, lonlat: 'POINT(-74.0030 40.7158)', timestamp: 2.minutes.ago.to_i, latitude: 40.7158, longitude: -74.0030)
+ ]
+ end
+
+ before do
+ allow(track_cleaner).to receive(:cleanup)
+ allow(point_loader).to receive(:load_points).and_return(old_points + recent_points)
+
+ # First segment (old points) should be finalized
+ # Second segment (recent points) should be incomplete
+ call_count = 0
+ allow(incomplete_segment_handler).to receive(:should_finalize_segment?) do |segment_points|
+ call_count += 1
+ call_count == 1 # Only finalize first segment
+ end
+
+ allow(incomplete_segment_handler).to receive(:handle_incomplete_segment)
+ allow(incomplete_segment_handler).to receive(:cleanup_processed_data)
+ end
+
+ it 'creates tracks for complete segments only' do
+ expect { generator.call }.to change { Track.count }.by(1)
+ end
+
+ it 'handles incomplete segments' do
+ # Note: The exact behavior depends on segmentation logic
+ # The important thing is that the method can be called without errors
+ generator.call
+ # Test passes if no exceptions are raised
+ expect(true).to be_truthy
+ end
+
+ it 'returns the correct number of tracks created' do
+ result = generator.call
+ expect(result).to eq(1)
+ end
+ end
+
+ context 'with insufficient points for track creation' do
+ let!(:single_point) do
+ [create(:point, user: user, lonlat: 'POINT(-74.0060 40.7128)', timestamp: 1.hour.ago.to_i, latitude: 40.7128, longitude: -74.0060)]
+ end
+
+ before do
+ allow(track_cleaner).to receive(:cleanup)
+ allow(point_loader).to receive(:load_points).and_return(single_point)
+ allow(incomplete_segment_handler).to receive(:should_finalize_segment?).and_return(true)
+ allow(incomplete_segment_handler).to receive(:cleanup_processed_data)
+ end
+
+ it 'does not create tracks with less than 2 points' do
+ expect { generator.call }.not_to change { Track.count }
+ end
+
+ it 'returns 0 tracks created' do
+ result = generator.call
+ expect(result).to eq(0)
+ end
+ end
+
+ context 'error handling' do
+ before do
+ allow(track_cleaner).to receive(:cleanup)
+ allow(point_loader).to receive(:load_points).and_raise(StandardError, 'Point loading failed')
+ end
+
+ it 'propagates errors from point loading' do
+ expect { generator.call }.to raise_error(StandardError, 'Point loading failed')
+ end
+ end
+ end
+
+ describe 'strategy pattern integration' do
+ context 'with bulk processing strategies' do
+ let(:bulk_loader) { Tracks::PointLoaders::BulkLoader.new(user) }
+ let(:ignore_handler) { Tracks::IncompleteSegmentHandlers::IgnoreHandler.new(user) }
+ let(:replace_cleaner) { Tracks::TrackCleaners::ReplaceCleaner.new(user) }
+
+ let(:bulk_generator) do
+ described_class.new(
+ user,
+ point_loader: bulk_loader,
+ incomplete_segment_handler: ignore_handler,
+ track_cleaner: replace_cleaner
+ )
+ end
+
+ let!(:existing_track) { create(:track, user: user) }
+ let!(:points) do
+ [
+ create(:point, user: user, lonlat: 'POINT(-74.0060 40.7128)', timestamp: 1.hour.ago.to_i, latitude: 40.7128, longitude: -74.0060),
+ create(:point, user: user, lonlat: 'POINT(-74.0050 40.7138)', timestamp: 30.minutes.ago.to_i, latitude: 40.7138, longitude: -74.0050)
+ ]
+ end
+
+ it 'behaves like bulk processing' do
+ initial_count = Track.count
+ bulk_generator.call
+ # Bulk processing replaces existing tracks with new ones
+ # The final count depends on how many valid tracks can be created from the points
+ expect(Track.count).to be >= 0
+ end
+ end
+
+ context 'with incremental processing strategies' do
+ let(:incremental_loader) { Tracks::PointLoaders::IncrementalLoader.new(user) }
+ let(:buffer_handler) { Tracks::IncompleteSegmentHandlers::BufferHandler.new(user, Date.current, 5) }
+ let(:noop_cleaner) { Tracks::TrackCleaners::NoOpCleaner.new(user) }
+
+ let(:incremental_generator) do
+ described_class.new(
+ user,
+ point_loader: incremental_loader,
+ incomplete_segment_handler: buffer_handler,
+ track_cleaner: noop_cleaner
+ )
+ end
+
+ let!(:existing_track) { create(:track, user: user) }
+
+ before do
+ # Mock the incremental loader to return some points
+ allow(incremental_loader).to receive(:load_points).and_return([])
+ end
+
+ it 'behaves like incremental processing' do
+ expect { incremental_generator.call }.not_to change { Track.count }
+ end
+ end
+ end
+end
diff --git a/spec/services/tracks/redis_buffer_spec.rb b/spec/services/tracks/redis_buffer_spec.rb
new file mode 100644
index 00000000..e50ab4cc
--- /dev/null
+++ b/spec/services/tracks/redis_buffer_spec.rb
@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Tracks::RedisBuffer do
+ let(:user_id) { 123 }
+ let(:day) { Date.current }
+ let(:buffer) { described_class.new(user_id, day) }
+
+ describe '#initialize' do
+ it 'stores user_id and converts day to Date' do
+ expect(buffer.user_id).to eq(user_id)
+ expect(buffer.day).to eq(day)
+ expect(buffer.day).to be_a(Date)
+ end
+
+ it 'handles string date input' do
+ buffer = described_class.new(user_id, '2024-01-15')
+ expect(buffer.day).to eq(Date.parse('2024-01-15'))
+ end
+
+ it 'handles Time input' do
+ time = Time.current
+ buffer = described_class.new(user_id, time)
+ expect(buffer.day).to eq(time.to_date)
+ end
+ end
+
+ describe '#store' do
+ let(:user) { create(:user) }
+ let!(:points) do
+ [
+ create(:point, user: user, lonlat: 'POINT(-74.0060 40.7128)', timestamp: 1.hour.ago.to_i),
+ create(:point, user: user, lonlat: 'POINT(-74.0070 40.7130)', timestamp: 30.minutes.ago.to_i)
+ ]
+ end
+
+ it 'stores points in Redis cache' do
+ expect(Rails.cache).to receive(:write).with(
+ "track_buffer:#{user_id}:#{day.strftime('%Y-%m-%d')}",
+ anything,
+ expires_in: 7.days
+ )
+
+ buffer.store(points)
+ end
+
+ it 'serializes points correctly' do
+ buffer.store(points)
+
+ stored_data = Rails.cache.read("track_buffer:#{user_id}:#{day.strftime('%Y-%m-%d')}")
+
+ expect(stored_data).to be_an(Array)
+ expect(stored_data.size).to eq(2)
+
+ first_point = stored_data.first
+ expect(first_point[:id]).to eq(points.first.id)
+ expect(first_point[:timestamp]).to eq(points.first.timestamp)
+ expect(first_point[:lat]).to eq(points.first.lat)
+ expect(first_point[:lon]).to eq(points.first.lon)
+ expect(first_point[:user_id]).to eq(points.first.user_id)
+ end
+
+ it 'does nothing when given empty array' do
+ expect(Rails.cache).not_to receive(:write)
+ buffer.store([])
+ end
+
+ it 'logs debug message when storing points' do
+ expect(Rails.logger).to receive(:debug).with(
+ "Stored 2 points in buffer for user #{user_id}, day #{day}"
+ )
+
+ buffer.store(points)
+ end
+ end
+
+ describe '#retrieve' do
+ context 'when buffer exists' do
+ let(:stored_data) do
+ [
+ {
+ id: 1,
+ lonlat: 'POINT(-74.0060 40.7128)',
+ timestamp: 1.hour.ago.to_i,
+ lat: 40.7128,
+ lon: -74.0060,
+ altitude: 100,
+ velocity: 5.0,
+ battery: 80,
+ user_id: user_id
+ },
+ {
+ id: 2,
+ lonlat: 'POINT(-74.0070 40.7130)',
+ timestamp: 30.minutes.ago.to_i,
+ lat: 40.7130,
+ lon: -74.0070,
+ altitude: 105,
+ velocity: 6.0,
+ battery: 75,
+ user_id: user_id
+ }
+ ]
+ end
+
+ before do
+ Rails.cache.write(
+ "track_buffer:#{user_id}:#{day.strftime('%Y-%m-%d')}",
+ stored_data
+ )
+ end
+
+ it 'returns the stored point data' do
+ result = buffer.retrieve
+
+ expect(result).to eq(stored_data)
+ expect(result.size).to eq(2)
+ end
+ end
+
+ context 'when buffer does not exist' do
+ it 'returns empty array' do
+ result = buffer.retrieve
+ expect(result).to eq([])
+ end
+ end
+
+ context 'when Redis read fails' do
+ before do
+ allow(Rails.cache).to receive(:read).and_raise(StandardError.new('Redis error'))
+ end
+
+ it 'returns empty array and logs error' do
+ expect(Rails.logger).to receive(:error).with(
+ "Failed to retrieve buffered points for user #{user_id}, day #{day}: Redis error"
+ )
+
+ result = buffer.retrieve
+ expect(result).to eq([])
+ end
+ end
+ end
+
+ describe '#clear' do
+ before do
+ Rails.cache.write(
+ "track_buffer:#{user_id}:#{day.strftime('%Y-%m-%d')}",
+ [{ id: 1, timestamp: 1.hour.ago.to_i }]
+ )
+ end
+
+ it 'deletes the buffer from cache' do
+ buffer.clear
+
+ expect(Rails.cache.read("track_buffer:#{user_id}:#{day.strftime('%Y-%m-%d')}")).to be_nil
+ end
+
+ it 'logs debug message' do
+ expect(Rails.logger).to receive(:debug).with(
+ "Cleared buffer for user #{user_id}, day #{day}"
+ )
+
+ buffer.clear
+ end
+ end
+
+ describe '#exists?' do
+ context 'when buffer exists' do
+ before do
+ Rails.cache.write(
+ "track_buffer:#{user_id}:#{day.strftime('%Y-%m-%d')}",
+ [{ id: 1 }]
+ )
+ end
+
+ it 'returns true' do
+ expect(buffer.exists?).to be true
+ end
+ end
+
+ context 'when buffer does not exist' do
+ it 'returns false' do
+ expect(buffer.exists?).to be false
+ end
+ end
+ end
+
+ describe 'buffer key generation' do
+ it 'generates correct Redis key format' do
+ expected_key = "track_buffer:#{user_id}:#{day.strftime('%Y-%m-%d')}"
+
+ # Access private method for testing
+ actual_key = buffer.send(:buffer_key)
+
+ expect(actual_key).to eq(expected_key)
+ end
+
+ it 'handles different date formats consistently' do
+ date_as_string = '2024-03-15'
+ date_as_date = Date.parse(date_as_string)
+
+ buffer1 = described_class.new(user_id, date_as_string)
+ buffer2 = described_class.new(user_id, date_as_date)
+
+ expect(buffer1.send(:buffer_key)).to eq(buffer2.send(:buffer_key))
+ end
+ end
+
+ describe 'integration test' do
+ let(:user) { create(:user) }
+ let!(:points) do
+ [
+ create(:point, user: user, lonlat: 'POINT(-74.0060 40.7128)', timestamp: 2.hours.ago.to_i),
+ create(:point, user: user, lonlat: 'POINT(-74.0070 40.7130)', timestamp: 1.hour.ago.to_i)
+ ]
+ end
+
+ it 'stores and retrieves points correctly' do
+ # Store points
+ buffer.store(points)
+ expect(buffer.exists?).to be true
+
+ # Retrieve points
+ retrieved_points = buffer.retrieve
+ expect(retrieved_points.size).to eq(2)
+
+ # Verify data integrity
+ expect(retrieved_points.first[:id]).to eq(points.first.id)
+ expect(retrieved_points.last[:id]).to eq(points.last.id)
+
+ # Clear buffer
+ buffer.clear
+ expect(buffer.exists?).to be false
+ expect(buffer.retrieve).to eq([])
+ end
+ end
+end
diff --git a/spec/services/tracks/track_builder_spec.rb b/spec/services/tracks/track_builder_spec.rb
new file mode 100644
index 00000000..0c0b4d26
--- /dev/null
+++ b/spec/services/tracks/track_builder_spec.rb
@@ -0,0 +1,326 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Tracks::TrackBuilder do
+ # Create a test class that includes the concern for testing
+ let(:test_class) do
+ Class.new do
+ include Tracks::TrackBuilder
+
+ def initialize(user)
+ @user = user
+ end
+
+ private
+
+ attr_reader :user
+ end
+ end
+
+ let(:user) { create(:user) }
+ let(:builder) { test_class.new(user) }
+
+ before do
+ # Set up user settings for consistent testing
+ allow_any_instance_of(Users::SafeSettings).to receive(:distance_unit).and_return('km')
+ end
+
+ describe '#create_track_from_points' do
+ context 'with valid points' do
+ let!(:points) do
+ [
+ create(:point, user: user, lonlat: 'POINT(-74.0060 40.7128)',
+ timestamp: 2.hours.ago.to_i, altitude: 100),
+ create(:point, user: user, lonlat: 'POINT(-74.0070 40.7130)',
+ timestamp: 1.hour.ago.to_i, altitude: 110),
+ create(:point, user: user, lonlat: 'POINT(-74.0080 40.7132)',
+ timestamp: 30.minutes.ago.to_i, altitude: 105)
+ ]
+ end
+
+ it 'creates a track with correct attributes' do
+ track = builder.create_track_from_points(points)
+
+ expect(track).to be_persisted
+ expect(track.user).to eq(user)
+ expect(track.start_at).to be_within(1.second).of(Time.zone.at(points.first.timestamp))
+ expect(track.end_at).to be_within(1.second).of(Time.zone.at(points.last.timestamp))
+ expect(track.distance).to be > 0
+ expect(track.duration).to eq(90.minutes.to_i)
+ expect(track.avg_speed).to be > 0
+ expect(track.original_path).to be_present
+ end
+
+ it 'calculates elevation statistics correctly' do
+ track = builder.create_track_from_points(points)
+
+ expect(track.elevation_gain).to eq(10) # 110 - 100
+ expect(track.elevation_loss).to eq(5) # 110 - 105
+ expect(track.elevation_max).to eq(110)
+ expect(track.elevation_min).to eq(100)
+ end
+
+ it 'associates points with the track' do
+ track = builder.create_track_from_points(points)
+
+ points.each(&:reload)
+ expect(points.map(&:track)).to all(eq(track))
+ end
+ end
+
+ context 'with insufficient points' do
+ let(:single_point) { [create(:point, user: user)] }
+
+ it 'returns nil for single point' do
+ result = builder.create_track_from_points(single_point)
+ expect(result).to be_nil
+ end
+
+ it 'returns nil for empty array' do
+ result = builder.create_track_from_points([])
+ expect(result).to be_nil
+ end
+ end
+
+ context 'when track save fails' do
+ let(:points) do
+ [
+ create(:point, user: user, timestamp: 1.hour.ago.to_i),
+ create(:point, user: user, timestamp: 30.minutes.ago.to_i)
+ ]
+ end
+
+ before do
+ allow_any_instance_of(Track).to receive(:save).and_return(false)
+ end
+
+ it 'returns nil and logs error' do
+ expect(Rails.logger).to receive(:error).with(
+ /Failed to create track for user #{user.id}/
+ )
+
+ result = builder.create_track_from_points(points)
+ expect(result).to be_nil
+ end
+ end
+ end
+
+ describe '#build_path' do
+ let(:points) do
+ [
+ create(:point, lonlat: 'POINT(-74.0060 40.7128)'),
+ create(:point, lonlat: 'POINT(-74.0070 40.7130)')
+ ]
+ end
+
+ it 'builds path using Tracks::BuildPath service' do
+ expect(Tracks::BuildPath).to receive(:new).with(
+ points.map(&:lonlat)
+ ).and_call_original
+
+ result = builder.build_path(points)
+ expect(result).to respond_to(:as_text) # RGeo geometry object
+ end
+ end
+
+ describe '#calculate_track_distance' do
+ let(:points) do
+ [
+ create(:point, user: user, lonlat: 'POINT(-74.0060 40.7128)'),
+ create(:point, user: user, lonlat: 'POINT(-74.0070 40.7130)')
+ ]
+ end
+
+ before do
+ # Mock Point.total_distance to return distance in meters
+ allow(Point).to receive(:total_distance).and_return(1500) # 1500 meters
+ end
+
+ it 'stores distance in meters regardless of user unit preference' do
+ result = builder.calculate_track_distance(points)
+ expect(result).to eq(1500) # Always stored as meters
+ end
+
+ it 'rounds distance to nearest meter' do
+ allow(Point).to receive(:total_distance).and_return(1500.7)
+ result = builder.calculate_track_distance(points)
+ expect(result).to eq(1501) # Rounded to nearest meter
+ end
+ end
+
+ describe '#calculate_duration' do
+ let(:start_time) { 2.hours.ago.to_i }
+ let(:end_time) { 1.hour.ago.to_i }
+ let(:points) do
+ [
+ double(timestamp: start_time),
+ double(timestamp: end_time)
+ ]
+ end
+
+ it 'calculates duration in seconds' do
+ result = builder.calculate_duration(points)
+ expect(result).to eq(1.hour.to_i)
+ end
+ end
+
+ describe '#calculate_average_speed' do
+ context 'with valid distance and duration' do
+ it 'calculates speed in km/h' do
+ distance_meters = 1000 # 1 km
+ duration_seconds = 3600 # 1 hour
+
+ result = builder.calculate_average_speed(distance_meters, duration_seconds)
+ expect(result).to eq(1.0) # 1 km/h
+ end
+
+ it 'rounds to 2 decimal places' do
+ distance_meters = 1500 # 1.5 km
+ duration_seconds = 1800 # 30 minutes
+
+ result = builder.calculate_average_speed(distance_meters, duration_seconds)
+ expect(result).to eq(3.0) # 3 km/h
+ end
+ end
+
+ context 'with invalid inputs' do
+ it 'returns 0.0 for zero duration' do
+ result = builder.calculate_average_speed(1000, 0)
+ expect(result).to eq(0.0)
+ end
+
+ it 'returns 0.0 for zero distance' do
+ result = builder.calculate_average_speed(0, 3600)
+ expect(result).to eq(0.0)
+ end
+
+ it 'returns 0.0 for negative duration' do
+ result = builder.calculate_average_speed(1000, -3600)
+ expect(result).to eq(0.0)
+ end
+ end
+ end
+
+ describe '#calculate_elevation_stats' do
+ context 'with elevation data' do
+ let(:points) do
+ [
+ double(altitude: 100),
+ double(altitude: 150),
+ double(altitude: 120),
+ double(altitude: 180),
+ double(altitude: 160)
+ ]
+ end
+
+ it 'calculates elevation gain correctly' do
+ result = builder.calculate_elevation_stats(points)
+ expect(result[:gain]).to eq(110) # (150-100) + (180-120) = 50 + 60 = 110
+ end
+
+ it 'calculates elevation loss correctly' do
+ result = builder.calculate_elevation_stats(points)
+ expect(result[:loss]).to eq(50) # (150-120) + (180-160) = 30 + 20 = 50
+ end
+
+ it 'finds max elevation' do
+ result = builder.calculate_elevation_stats(points)
+ expect(result[:max]).to eq(180)
+ end
+
+ it 'finds min elevation' do
+ result = builder.calculate_elevation_stats(points)
+ expect(result[:min]).to eq(100)
+ end
+ end
+
+ context 'with no elevation data' do
+ let(:points) do
+ [
+ double(altitude: nil),
+ double(altitude: nil)
+ ]
+ end
+
+ it 'returns default elevation stats' do
+ result = builder.calculate_elevation_stats(points)
+ expect(result).to eq({
+ gain: 0,
+ loss: 0,
+ max: 0,
+ min: 0
+ })
+ end
+ end
+
+ context 'with mixed elevation data' do
+ let(:points) do
+ [
+ double(altitude: 100),
+ double(altitude: nil),
+ double(altitude: 150)
+ ]
+ end
+
+ it 'ignores nil values' do
+ result = builder.calculate_elevation_stats(points)
+ expect(result[:gain]).to eq(50) # 150 - 100
+ expect(result[:loss]).to eq(0)
+ expect(result[:max]).to eq(150)
+ expect(result[:min]).to eq(100)
+ end
+ end
+ end
+
+ describe '#default_elevation_stats' do
+ it 'returns hash with zero values' do
+ result = builder.default_elevation_stats
+ expect(result).to eq({
+ gain: 0,
+ loss: 0,
+ max: 0,
+ min: 0
+ })
+ end
+ end
+
+ describe 'user method requirement' do
+ let(:invalid_class) do
+ Class.new do
+ include Tracks::TrackBuilder
+ # Does not implement user method
+ end
+ end
+
+ it 'raises NotImplementedError when user method is not implemented' do
+ invalid_builder = invalid_class.new
+ expect { invalid_builder.send(:user) }.to raise_error(
+ NotImplementedError,
+ "Including class must implement user method"
+ )
+ end
+ end
+
+ describe 'integration test' do
+ let!(:points) do
+ [
+ create(:point, user: user, lonlat: 'POINT(-74.0060 40.7128)',
+ timestamp: 2.hours.ago.to_i, altitude: 100),
+ create(:point, user: user, lonlat: 'POINT(-74.0070 40.7130)',
+ timestamp: 1.hour.ago.to_i, altitude: 120)
+ ]
+ end
+
+ it 'creates a complete track end-to-end' do
+ expect { builder.create_track_from_points(points) }.to change(Track, :count).by(1)
+
+ track = Track.last
+ expect(track.user).to eq(user)
+ expect(track.points).to match_array(points)
+ expect(track.distance).to be > 0
+ expect(track.duration).to eq(1.hour.to_i)
+ expect(track.elevation_gain).to eq(20)
+ end
+ end
+end
diff --git a/spec/services/visits/suggest_spec.rb b/spec/services/visits/suggest_spec.rb
index 14e7c1dd..167b9ba9 100644
--- a/spec/services/visits/suggest_spec.rb
+++ b/spec/services/visits/suggest_spec.rb
@@ -8,29 +8,7 @@ RSpec.describe Visits::Suggest do
let(:start_at) { Time.zone.local(2020, 1, 1, 0, 0, 0) }
let(:end_at) { Time.zone.local(2020, 1, 1, 2, 0, 0) }
- let!(:points) do
- [
- # first visit
- create(:point, :with_known_location, user:, timestamp: start_at),
- create(:point, :with_known_location, user:, timestamp: start_at + 5.minutes),
- create(:point, :with_known_location, user:, timestamp: start_at + 10.minutes),
- create(:point, :with_known_location, user:, timestamp: start_at + 15.minutes),
- create(:point, :with_known_location, user:, timestamp: start_at + 20.minutes),
- create(:point, :with_known_location, user:, timestamp: start_at + 25.minutes),
- create(:point, :with_known_location, user:, timestamp: start_at + 30.minutes),
- create(:point, :with_known_location, user:, timestamp: start_at + 35.minutes),
- create(:point, :with_known_location, user:, timestamp: start_at + 40.minutes),
- create(:point, :with_known_location, user:, timestamp: start_at + 45.minutes),
- create(:point, :with_known_location, user:, timestamp: start_at + 50.minutes),
- create(:point, :with_known_location, user:, timestamp: start_at + 55.minutes),
- # end of first visit
- # second visit
- create(:point, :with_known_location, user:, timestamp: start_at + 95.minutes),
- create(:point, :with_known_location, user:, timestamp: start_at + 100.minutes),
- create(:point, :with_known_location, user:, timestamp: start_at + 105.minutes)
- # end of second visit
- ]
- end
+ let!(:points) { create_visit_points(user, start_at) }
let(:geocoder_struct) do
Struct.new(:data) do
@@ -97,12 +75,23 @@ RSpec.describe Visits::Suggest do
end
context 'when reverse geocoding is enabled' do
+ # Use a different time range to avoid interference with main tests
+ let(:reverse_geocoding_start_at) { Time.zone.local(2020, 6, 1, 0, 0, 0) }
+ let(:reverse_geocoding_end_at) { Time.zone.local(2020, 6, 1, 2, 0, 0) }
+
before do
allow(DawarichSettings).to receive(:reverse_geocoding_enabled?).and_return(true)
+ # Create points for reverse geocoding test in a separate time range
+ create_visit_points(user, reverse_geocoding_start_at)
+ clear_enqueued_jobs
end
- it 'reverse geocodes visits' do
- expect { subject }.to have_enqueued_job(ReverseGeocodingJob).exactly(2).times
+ it 'enqueues reverse geocoding jobs for created visits' do
+ described_class.new(user, start_at: reverse_geocoding_start_at, end_at: reverse_geocoding_end_at).call
+
+ expect(enqueued_jobs.count).to eq(2)
+ expect(enqueued_jobs).to all(have_job_class('ReverseGeocodingJob'))
+ expect(enqueued_jobs).to all(have_arguments_starting_with('place'))
end
end
@@ -113,9 +102,51 @@ RSpec.describe Visits::Suggest do
it 'does not reverse geocode visits' do
expect_any_instance_of(Visit).not_to receive(:async_reverse_geocode)
-
subject
end
end
end
+
+ private
+
+ def create_visit_points(user, start_time)
+ [
+ # first visit
+ create(:point, :with_known_location, user:, timestamp: start_time),
+ create(:point, :with_known_location, user:, timestamp: start_time + 5.minutes),
+ create(:point, :with_known_location, user:, timestamp: start_time + 10.minutes),
+ create(:point, :with_known_location, user:, timestamp: start_time + 15.minutes),
+ create(:point, :with_known_location, user:, timestamp: start_time + 20.minutes),
+ create(:point, :with_known_location, user:, timestamp: start_time + 25.minutes),
+ create(:point, :with_known_location, user:, timestamp: start_time + 30.minutes),
+ create(:point, :with_known_location, user:, timestamp: start_time + 35.minutes),
+ create(:point, :with_known_location, user:, timestamp: start_time + 40.minutes),
+ create(:point, :with_known_location, user:, timestamp: start_time + 45.minutes),
+ create(:point, :with_known_location, user:, timestamp: start_time + 50.minutes),
+ create(:point, :with_known_location, user:, timestamp: start_time + 55.minutes),
+ # end of first visit
+
+ # second visit
+ create(:point, :with_known_location, user:, timestamp: start_time + 95.minutes),
+ create(:point, :with_known_location, user:, timestamp: start_time + 100.minutes),
+ create(:point, :with_known_location, user:, timestamp: start_time + 105.minutes)
+ # end of second visit
+ ]
+ end
+
+ def clear_enqueued_jobs
+ ActiveJob::Base.queue_adapter.enqueued_jobs.clear
+ end
+
+ def enqueued_jobs
+ ActiveJob::Base.queue_adapter.enqueued_jobs
+ end
+
+ def have_job_class(job_class)
+ satisfy { |job| job['job_class'] == job_class }
+ end
+
+ def have_arguments_starting_with(first_argument)
+ satisfy { |job| job['arguments'].first == first_argument }
+ end
end
diff --git a/spec/support/redis.rb b/spec/support/redis.rb
new file mode 100644
index 00000000..6ffa0528
--- /dev/null
+++ b/spec/support/redis.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+RSpec.configure do |config|
+ config.before(:each) do
+ # Clear the cache before each test
+ Rails.cache.clear
+ end
+end