Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

14.5 KB
Raw Blame
/**
 * Apple Health Ingest Service Tests
 *
 * Tests for upsert logic: latest write wins, data updates correctly,
 * identical points are skipped, and concurrent writes serialize per-date.
 */

import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { mkdtemp, rm, writeFile } from 'fs/promises';
import { tmpdir } from 'os';
import { join } from 'path';
import { PATHS } from '../lib/fileUtils.js';

// Mock PATHS to use a temp directory
const tempDirs = [];
beforeEach(async () => {
  const tempDir = await mkdtemp(join(tmpdir(), 'portos-ahIngest-test-'));
  tempDirs.push(tempDir);
  // Override PATHS.health for this test
  Object.defineProperty(PATHS, 'health', {
    value: tempDir,
    configurable: true,
  });
});

afterEach(async () => {
  for (const dir of tempDirs) {
    await rm(dir, { recursive: true, force: true }).catch(() => {});
  }
  tempDirs.length = 0;
});

const { extractDateStr, upsertPoints, mergeIntoDay, ingestHealthData } = await import('./appleHealthIngest.js');

describe('extractDateStr', () => {
  it('extracts YYYY-MM-DD from an Apple Health timestamp', () => {
    expect(extractDateStr('2024-01-15 08:30:00 -0800')).toBe('2024-01-15');
    expect(extractDateStr('2024-12-31 23:59:59 +0000')).toBe('2024-12-31');
  });

  it('returns null for invalid dates', () => {
    expect(extractDateStr('not-a-date')).toBeNull();
    expect(extractDateStr('')).toBeNull();
    expect(extractDateStr(null)).toBeNull();
    expect(extractDateStr(undefined)).toBeNull();
  });
});

describe('upsertPoints', () => {
  it('adds new points when existing array is empty', () => {
    const newPoints = [
      { date: '2024-01-15 00:00:00 -0800', qty: 300 },
      { date: '2024-01-15 12:00:00 -0800', qty: 500 },
    ];
    const result = upsertPoints([], newPoints);

    expect(result.added).toBe(2);
    expect(result.updated).toBe(0);
    expect(result.result).toHaveLength(2);
    expect(result.result[0].qty).toBe(300);
    expect(result.result[1].qty).toBe(500);
  });

  it('updates existing point when date matches', () => {
    const existing = [
      { date: '2024-01-15 00:00:00 -0800', qty: 300 },
    ];
    const newPoints = [
      { date: '2024-01-15 00:00:00 -0800', qty: 9000 },
    ];
    const result = upsertPoints(existing, newPoints);

    expect(result.added).toBe(0);
    expect(result.updated).toBe(1);
    expect(result.result).toHaveLength(1);
    expect(result.result[0].qty).toBe(9000);
  });

  it('skips identical points without counting as added or updated', () => {
    const existing = [
      { date: '2024-01-15 00:00:00 -0800', qty: 300 },
    ];
    const newPoints = [
      { date: '2024-01-15 00:00:00 -0800', qty: 300 },
    ];
    const result = upsertPoints(existing, newPoints);

    expect(result.added).toBe(0);
    expect(result.updated).toBe(0);
    expect(result.result).toHaveLength(1);
    expect(result.result[0].qty).toBe(300);
  });

  it('mixes adds, updates, and skips correctly', () => {
    const existing = [
      { date: '2024-01-15 00:00:00 -0800', qty: 300 }, // will be updated
      { date: '2024-01-15 06:00:00 -0800', qty: 400 }, // will be skipped (identical)
    ];
    const newPoints = [
      { date: '2024-01-15 00:00:00 -0800', qty: 9000 }, // update
      { date: '2024-01-15 06:00:00 -0800', qty: 400 },  // skip (identical)
      { date: '2024-01-15 12:00:00 -0800', qty: 500 },  // add
    ];
    const result = upsertPoints(existing, newPoints);

    expect(result.added).toBe(1);
    expect(result.updated).toBe(1);
    expect(result.result).toHaveLength(3);
    // Check the values
    expect(result.result.find(p => p.date === '2024-01-15 00:00:00 -0800').qty).toBe(9000);
    expect(result.result.find(p => p.date === '2024-01-15 06:00:00 -0800').qty).toBe(400);
    expect(result.result.find(p => p.date === '2024-01-15 12:00:00 -0800').qty).toBe(500);
  });
});

describe('mergeIntoDay', () => {
  it('creates a new day file when it does not exist', async () => {
    const result = await mergeIntoDay('2024-01-15', 'step_count', [
      { date: '2024-01-15 00:00:00 -0800', qty: 9000 },
    ]);

    expect(result.added).toBe(1);
    expect(result.updated).toBe(0);
    expect(result.totalPoints).toBe(1);

    // Verify file was written
    const dayPath = join(PATHS.health, '2024-01-15.json');
    const content = await import('fs/promises').then(m => m.readFile(dayPath, 'utf-8'));
    const data = JSON.parse(content);
    expect(data.metrics.step_count).toHaveLength(1);
    expect(data.metrics.step_count[0].qty).toBe(9000);
  });

  it('updates an existing day value with a larger value', async () => {
    const dayPath = join(PATHS.health, '2024-01-15.json');
    await writeFile(dayPath, JSON.stringify({
      date: '2024-01-15',
      metrics: {
        step_count: [
          { date: '2024-01-15 08:00:00 -0800', qty: 300 },
        ],
      },
      updated: new Date().toISOString(),
    }), 'utf-8');

    // Re-sync with more complete data
    const result = await mergeIntoDay('2024-01-15', 'step_count', [
      { date: '2024-01-15 08:00:00 -0800', qty: 9000 },
    ]);

    expect(result.added).toBe(0);
    expect(result.updated).toBe(1);
    expect(result.totalPoints).toBe(1);

    const content = await import('fs/promises').then(m => m.readFile(dayPath, 'utf-8'));
    const data = JSON.parse(content);
    expect(data.metrics.step_count[0].qty).toBe(9000);
  });

  it('does not rewrite file when ingesting identical point', async () => {
    const dayPath = join(PATHS.health, '2024-01-15.json');
    const originalTime = new Date('2024-01-01T00:00:00Z').toISOString();
    await writeFile(dayPath, JSON.stringify({
      date: '2024-01-15',
      metrics: {
        step_count: [
          { date: '2024-01-15 08:00:00 -0800', qty: 300 },
        ],
      },
      updated: originalTime,
    }), 'utf-8');

    // Ingest identical point
    const result = await mergeIntoDay('2024-01-15', 'step_count', [
      { date: '2024-01-15 08:00:00 -0800', qty: 300 },
    ]);

    expect(result.added).toBe(0);
    expect(result.updated).toBe(0);

    const content = await import('fs/promises').then(m => m.readFile(dayPath, 'utf-8'));
    const data = JSON.parse(content);
    // File should not have been rewritten, so updated timestamp should still match original
    expect(data.updated).toBe(originalTime);
  });

  it('handles multiple metrics in same day', async () => {
    await mergeIntoDay('2024-01-15', 'step_count', [
      { date: '2024-01-15 08:00:00 -0800', qty: 9000 },
    ]);

    await mergeIntoDay('2024-01-15', 'heart_rate', [
      { date: '2024-01-15 10:00:00 -0800', qty: 72 },
    ]);

    const dayPath = join(PATHS.health, '2024-01-15.json');
    const content = await import('fs/promises').then(m => m.readFile(dayPath, 'utf-8'));
    const data = JSON.parse(content);

    expect(data.metrics.step_count).toHaveLength(1);
    expect(data.metrics.step_count[0].qty).toBe(9000);
    expect(data.metrics.heart_rate).toHaveLength(1);
    expect(data.metrics.heart_rate[0].qty).toBe(72);
  });
});

describe('ingestHealthData', () => {
  it('ingests new data and reports added records', async () => {
    const payload = {
      data: {
        metrics: [
          {
            name: 'step_count',
            data: [
              { date: '2024-01-15 08:00:00 -0800', qty: 9000 },
              { date: '2024-01-15 18:00:00 -0800', qty: 5000 },
            ],
          },
        ],
      },
    };

    const result = await ingestHealthData(payload);

    expect(result.recordsIngested).toBe(2);
    expect(result.recordsUpdated).toBe(0);
    expect(result.recordsSkipped).toBe(0);
    expect(result.daysAffected).toBe(1);
  });

  it('updates existing values and reports separately', async () => {
    const dayPath = join(PATHS.health, '2024-01-15.json');
    await writeFile(dayPath, JSON.stringify({
      date: '2024-01-15',
      metrics: {
        step_count: [
          { date: '2024-01-15 08:00:00 -0800', qty: 300 }, // partial value
        ],
      },
      updated: new Date().toISOString(),
    }), 'utf-8');

    // Re-sync with complete data
    const payload = {
      data: {
        metrics: [
          {
            name: 'step_count',
            data: [
              { date: '2024-01-15 08:00:00 -0800', qty: 9000 }, // updated
            ],
          },
        ],
      },
    };

    const result = await ingestHealthData(payload);

    expect(result.recordsIngested).toBe(0);
    expect(result.recordsUpdated).toBe(1);
    expect(result.recordsSkipped).toBe(0);
    expect(result.daysAffected).toBe(1);
  });

  it('distinguishes dupes (identical) from updates', async () => {
    const dayPath = join(PATHS.health, '2024-01-15.json');
    const originalTime = new Date('2024-01-01T00:00:00Z').toISOString();
    await writeFile(dayPath, JSON.stringify({
      date: '2024-01-15',
      metrics: {
        step_count: [
          { date: '2024-01-15 08:00:00 -0800', qty: 9000, origin: 'hae' },
        ],
      },
      updated: originalTime,
    }), 'utf-8');

    // Re-sync with identical data
    const payload = {
      data: {
        metrics: [
          {
            name: 'step_count',
            data: [
              { date: '2024-01-15 08:00:00 -0800', qty: 9000 }, // identical
            ],
          },
        ],
      },
    };

    const result = await ingestHealthData(payload);

    expect(result.recordsIngested).toBe(0);
    expect(result.recordsUpdated).toBe(0);
    expect(result.recordsSkipped).toBe(1); // counted as dupe
  });

  it('re-stamps a legacy point (no origin) as an update exactly once, then treats it as a dupe (#8450)', async () => {
    const dayPath = join(PATHS.health, '2024-01-16.json');
    await writeFile(dayPath, JSON.stringify({
      date: '2024-01-16',
      metrics: {
        step_count: [
          { date: '2024-01-16 08:00:00 -0800', qty: 9000 }, // pre-#8450: no origin stamp
        ],
      },
      updated: new Date('2024-01-01T00:00:00Z').toISOString(),
    }), 'utf-8');

    const payload = {
      data: {
        metrics: [
          { name: 'step_count', data: [{ date: '2024-01-16 08:00:00 -0800', qty: 9000 }] },
        ],
      },
    };

    // First re-sync after upgrading: same value, but ingestHealthData now
    // stamps origin, so the stored point differs from the legacy one and is
    // counted as an update (self-healing one-time migration).
    const first = await ingestHealthData(payload);
    expect(first.recordsIngested).toBe(0);
    expect(first.recordsUpdated).toBe(1);
    expect(first.recordsSkipped).toBe(0);

    // Second re-sync: the stored point now carries origin: 'hae' too, so it's
    // a true dupe again.
    const second = await ingestHealthData(payload);
    expect(second.recordsIngested).toBe(0);
    expect(second.recordsUpdated).toBe(0);
    expect(second.recordsSkipped).toBe(1);
  });

  it('mixes additions, updates, and dupes in one ingest', async () => {
    const dayPath = join(PATHS.health, '2024-01-15.json');
    const originalTime = new Date('2024-01-01T00:00:00Z').toISOString();
    await writeFile(dayPath, JSON.stringify({
      date: '2024-01-15',
      metrics: {
        step_count: [
          { date: '2024-01-15 08:00:00 -0800', qty: 300, origin: 'hae' },    // will be updated
          { date: '2024-01-15 12:00:00 -0800', qty: 400, origin: 'hae' },    // will be skipped (dupe)
        ],
      },
      updated: originalTime,
    }), 'utf-8');

    const payload = {
      data: {
        metrics: [
          {
            name: 'step_count',
            data: [
              { date: '2024-01-15 08:00:00 -0800', qty: 9000 },  // update
              { date: '2024-01-15 12:00:00 -0800', qty: 400 },   // dupe (identical)
              { date: '2024-01-15 18:00:00 -0800', qty: 500 },   // add
            ],
          },
        ],
      },
    };

    const result = await ingestHealthData(payload);

    expect(result.recordsIngested).toBe(1); // 1 added
    expect(result.recordsUpdated).toBe(1);  // 1 updated
    expect(result.recordsSkipped).toBe(1);  // 1 dupe (identical)
  });

  it('handles multiple days and metrics', async () => {
    const payload = {
      data: {
        metrics: [
          {
            name: 'step_count',
            data: [
              { date: '2024-01-14 08:00:00 -0800', qty: 8000 },
              { date: '2024-01-15 08:00:00 -0800', qty: 9000 },
            ],
          },
          {
            name: 'heart_rate',
            data: [
              { date: '2024-01-14 10:00:00 -0800', qty: 70 },
              { date: '2024-01-15 10:00:00 -0800', qty: 72 },
            ],
          },
        ],
      },
    };

    const result = await ingestHealthData(payload);

    expect(result.metricsProcessed).toBe(2);
    expect(result.recordsIngested).toBe(4);
    expect(result.daysAffected).toBe(2);

    // Verify both day files exist
    const content14 = await import('fs/promises').then(m =>
      m.readFile(join(PATHS.health, '2024-01-14.json'), 'utf-8')
    );
    const data14 = JSON.parse(content14);
    expect(data14.metrics.step_count).toHaveLength(1);
    expect(data14.metrics.heart_rate).toHaveLength(1);

    const content15 = await import('fs/promises').then(m =>
      m.readFile(join(PATHS.health, '2024-01-15.json'), 'utf-8')
    );
    const data15 = JSON.parse(content15);
    expect(data15.metrics.step_count).toHaveLength(1);
    expect(data15.metrics.heart_rate).toHaveLength(1);
  });

  it('normalizes metric name aliases', async () => {
    const payload = {
      data: {
        metrics: [
          {
            name: 'heart_rate_variability', // HAE short name
            data: [
              { date: '2024-01-15 08:00:00 -0800', qty: 25 },
            ],
          },
        ],
      },
    };

    const result = await ingestHealthData(payload);

    expect(result.recordsIngested).toBe(1);

    const dayPath = join(PATHS.health, '2024-01-15.json');
    const content = await import('fs/promises').then(m => m.readFile(dayPath, 'utf-8'));
    const data = JSON.parse(content);
    // Should be stored under the normalized name
    expect(data.metrics.heart_rate_variability_sdnn).toHaveLength(1);
  });

  it('skips records with invalid date strings', async () => {
    const payload = {
      data: {
        metrics: [
          {
            name: 'step_count',
            data: [
              { date: '2024-01-15 08:00:00 -0800', qty: 9000 },
              { date: 'invalid-date', qty: 5000 },
              { date: '2024-01-15 18:00:00 -0800', qty: 2000 },
            ],
          },
        ],
      },
    };

    const result = await ingestHealthData(payload);

    expect(result.recordsIngested).toBe(2);
    expect(result.recordsSkipped).toBe(1); // invalid-date
  });
});