ether-to-astro 1.0.0

package/tests/unit/houses.test.ts

@@ -0,0 +1,205 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import { HouseCalculator } from '../../src/houses.js';
+import { EphemerisCalculator } from '../../src/ephemeris.js';
+import { bowenYangChart, polarChart } from '../fixtures/bowen-yang-chart.js';
+
+describe('When calculating house cusps for a natal chart', () => {
+  let ephem: EphemerisCalculator;
+  let houseCalc: HouseCalculator;
+
+  beforeAll(async () => {
+    ephem = new EphemerisCalculator();
+    await ephem.init();
+    houseCalc = new HouseCalculator(ephem);
+  });
+
+  describe('Given Bowen Yang\'s birth data in Brisbane', () => {
+    it('should calculate Placidus houses', () => {
+      const birthDate = new Date(Date.UTC(
+        bowenYangChart.birthDate.year,
+        bowenYangChart.birthDate.month - 1,
+        bowenYangChart.birthDate.day,
+        bowenYangChart.birthDate.hour,
+        bowenYangChart.birthDate.minute
+      ));
+      const jd = ephem.dateToJulianDay(birthDate);
+      
+      const houses = houseCalc.calculateHouses(
+        jd,
+        bowenYangChart.location.latitude,
+        bowenYangChart.location.longitude,
+        'P'
+      );
+      
+      expect(houses.cusps).toHaveLength(13); // 12 houses + duplicate of 1st
+      expect(houses.ascendant).toBeGreaterThanOrEqual(0);
+      expect(houses.ascendant).toBeLessThan(360);
+      expect(houses.mc).toBeGreaterThanOrEqual(0);
+      expect(houses.mc).toBeLessThan(360);
+    });
+
+    it('should calculate Koch house system', () => {
+      const birthDate = new Date(Date.UTC(
+        bowenYangChart.birthDate.year,
+        bowenYangChart.birthDate.month - 1,
+        bowenYangChart.birthDate.day,
+        bowenYangChart.birthDate.hour,
+        bowenYangChart.birthDate.minute
+      ));
+      const jd = ephem.dateToJulianDay(birthDate);
+      
+      const houses = houseCalc.calculateHouses(
+        jd,
+        bowenYangChart.location.latitude,
+        bowenYangChart.location.longitude,
+        'K'
+      );
+      
+      expect(houses.cusps).toHaveLength(13);
+      expect(houses.ascendant).toBeDefined();
+      expect(houses.mc).toBeDefined();
+    });
+
+    it('should calculate Whole Sign houses', () => {
+      const birthDate = new Date(Date.UTC(
+        bowenYangChart.birthDate.year,
+        bowenYangChart.birthDate.month - 1,
+        bowenYangChart.birthDate.day,
+        bowenYangChart.birthDate.hour,
+        bowenYangChart.birthDate.minute
+      ));
+      const jd = ephem.dateToJulianDay(birthDate);
+      
+      const houses = houseCalc.calculateHouses(
+        jd,
+        bowenYangChart.location.latitude,
+        bowenYangChart.location.longitude,
+        'W'
+      );
+      
+      expect(houses.cusps).toHaveLength(13);
+      
+      // Whole sign houses should be 30° apart
+      for (let i = 1; i < 12; i++) {
+        const diff = (houses.cusps[i + 1] - houses.cusps[i] + 360) % 360;
+        expect(diff).toBeCloseTo(30, 0);
+      }
+    });
+
+    it('should calculate Equal houses', () => {
+      const birthDate = new Date(Date.UTC(
+        bowenYangChart.birthDate.year,
+        bowenYangChart.birthDate.month - 1,
+        bowenYangChart.birthDate.day,
+        bowenYangChart.birthDate.hour,
+        bowenYangChart.birthDate.minute
+      ));
+      const jd = ephem.dateToJulianDay(birthDate);
+      
+      const houses = houseCalc.calculateHouses(
+        jd,
+        bowenYangChart.location.latitude,
+        bowenYangChart.location.longitude,
+        'E'
+      );
+      
+      expect(houses.cusps).toHaveLength(13);
+      
+      // Equal houses should be exactly 30° apart
+      for (let i = 1; i < 12; i++) {
+        const diff = (houses.cusps[i + 1] - houses.cusps[i] + 360) % 360;
+        expect(diff).toBeCloseTo(30, 0);
+      }
+    });
+
+    it('should determine Ascendant correctly', () => {
+      const birthDate = new Date(Date.UTC(
+        bowenYangChart.birthDate.year,
+        bowenYangChart.birthDate.month - 1,
+        bowenYangChart.birthDate.day,
+        bowenYangChart.birthDate.hour,
+        bowenYangChart.birthDate.minute
+      ));
+      const jd = ephem.dateToJulianDay(birthDate);
+      
+      const houses = houseCalc.calculateHouses(
+        jd,
+        bowenYangChart.location.latitude,
+        bowenYangChart.location.longitude,
+        'P'
+      );
+      
+      // Ascendant should equal the 1st house cusp
+      expect(houses.ascendant).toBeCloseTo(houses.cusps[1], 1);
+    });
+
+    it('should determine Midheaven (MC) correctly', () => {
+      const birthDate = new Date(Date.UTC(
+        bowenYangChart.birthDate.year,
+        bowenYangChart.birthDate.month - 1,
+        bowenYangChart.birthDate.day,
+        bowenYangChart.birthDate.hour,
+        bowenYangChart.birthDate.minute
+      ));
+      const jd = ephem.dateToJulianDay(birthDate);
+      
+      const houses = houseCalc.calculateHouses(
+        jd,
+        bowenYangChart.location.latitude,
+        bowenYangChart.location.longitude,
+        'P'
+      );
+      
+      // MC should equal the 10th house cusp
+      expect(houses.mc).toBeCloseTo(houses.cusps[10], 1);
+    });
+  });
+
+  describe('When handling edge cases', () => {
+    it('should handle polar latitudes', () => {
+      const birthDate = new Date(Date.UTC(
+        polarChart.birthDate.year,
+        polarChart.birthDate.month - 1,
+        polarChart.birthDate.day,
+        polarChart.birthDate.hour,
+        polarChart.birthDate.minute
+      ));
+      const jd = ephem.dateToJulianDay(birthDate);
+      
+      // Polar regions can have issues with some house systems
+      // Should not throw, but may have unusual values
+      expect(() => {
+        houseCalc.calculateHouses(
+          jd,
+          polarChart.location.latitude,
+          polarChart.location.longitude,
+          'P'
+        );
+      }).not.toThrow();
+    });
+
+    it('should handle southern hemisphere correctly', () => {
+      const birthDate = new Date(Date.UTC(
+        bowenYangChart.birthDate.year,
+        bowenYangChart.birthDate.month - 1,
+        bowenYangChart.birthDate.day,
+        bowenYangChart.birthDate.hour,
+        bowenYangChart.birthDate.minute
+      ));
+      const jd = ephem.dateToJulianDay(birthDate);
+      
+      // Brisbane is in southern hemisphere (negative latitude)
+      expect(bowenYangChart.location.latitude).toBeLessThan(0);
+      
+      const houses = houseCalc.calculateHouses(
+        jd,
+        bowenYangChart.location.latitude,
+        bowenYangChart.location.longitude,
+        'P'
+      );
+      
+      expect(houses.cusps).toHaveLength(13);
+      expect(houses.ascendant).toBeGreaterThanOrEqual(0);
+    });
+  });
+});

package/tests/unit/profile-store.test.ts

@@ -0,0 +1,163 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+import {
+  ProfileStoreError,
+  resolveProfileFilePath,
+  loadResolvedProfileFile,
+  resolveProfileSelection,
+} from '../../src/profile-store.js';
+
+function sampleProfileFile(): string {
+  return JSON.stringify(
+    {
+      version: 1,
+      defaultProfile: 'elwyn',
+      profiles: {
+        elwyn: {
+          name: 'Elwyn',
+          year: 1988,
+          month: 6,
+          day: 12,
+          hour: 14,
+          minute: 35,
+          latitude: 37.7749,
+          longitude: -122.4194,
+          timezone: 'America/Los_Angeles',
+          house_system: 'W',
+          birth_time_disambiguation: 'reject',
+        },
+        nick: {
+          name: 'Nick',
+          year: 1987,
+          month: 3,
+          day: 4,
+          hour: 9,
+          minute: 15,
+          latitude: 37,
+          longitude: -122,
+          timezone: 'America/Los_Angeles',
+        },
+      },
+    },
+    null,
+    2
+  );
+}
+
+async function makeDir(name: string): Promise<string> {
+  const dir = path.join(tmpdir(), `astro-profile-test-${name}-${Date.now()}`);
+  await mkdir(dir, { recursive: true });
+  return dir;
+}
+
+describe('profile store', () => {
+  it('resolves defaultProfile from local .astro.json', async () => {
+    const cwd = await makeDir('default');
+    await writeFile(path.join(cwd, '.astro.json'), sampleProfileFile(), 'utf8');
+
+    const resolved = await resolveProfileSelection({ cwd, homeDir: cwd });
+    expect(resolved?.profileName).toBe('elwyn');
+    expect(resolved?.profile.timezone).toBe('America/Los_Angeles');
+  });
+
+  it('applies profile precedence from ASTRO_PROFILE env', async () => {
+    const cwd = await makeDir('env-profile');
+    await writeFile(path.join(cwd, '.astro.json'), sampleProfileFile(), 'utf8');
+
+    const resolved = await resolveProfileSelection({
+      cwd,
+      homeDir: cwd,
+      env: { ...process.env, ASTRO_PROFILE: 'nick' },
+    });
+    expect(resolved?.profileName).toBe('nick');
+  });
+
+  it('uses explicit profileName over env and file default', async () => {
+    const cwd = await makeDir('explicit-precedence');
+    await writeFile(path.join(cwd, '.astro.json'), sampleProfileFile(), 'utf8');
+    const resolved = await resolveProfileSelection({
+      cwd,
+      homeDir: cwd,
+      profileName: 'nick',
+      env: { ...process.env, ASTRO_PROFILE: 'elwyn' },
+    });
+    expect(resolved?.profileName).toBe('nick');
+  });
+
+  it('prefers local profile file over home profile file', async () => {
+    const cwd = await makeDir('local-over-home-cwd');
+    const home = await makeDir('local-over-home-home');
+    await writeFile(path.join(home, '.astro.json'), sampleProfileFile().replaceAll('elwyn', 'home-default'), 'utf8');
+    await writeFile(path.join(cwd, '.astro.json'), sampleProfileFile(), 'utf8');
+    const pathResult = await resolveProfileFilePath({ cwd, homeDir: home }, true);
+    expect(pathResult).toBe(path.join(cwd, '.astro.json'));
+  });
+
+  it('throws PROFILE_NOT_FOUND for missing explicit profile', async () => {
+    const cwd = await makeDir('missing-profile');
+    await writeFile(path.join(cwd, '.astro.json'), sampleProfileFile(), 'utf8');
+
+    await expect(
+      resolveProfileSelection({ cwd, homeDir: cwd, profileName: 'does-not-exist' })
+    ).rejects.toMatchObject<Partial<ProfileStoreError>>({ code: 'PROFILE_NOT_FOUND' });
+  });
+
+  it('throws PROFILE_FILE_NOT_FOUND when profile file is required and missing', async () => {
+    const cwd = await makeDir('missing-file');
+
+    await expect(loadResolvedProfileFile({ cwd, homeDir: cwd })).rejects.toMatchObject<
+      Partial<ProfileStoreError>
+    >({ code: 'PROFILE_FILE_NOT_FOUND' });
+  });
+
+  it('throws INVALID_PROFILE_FILE for invalid JSON', async () => {
+    const cwd = await makeDir('invalid-json');
+    await writeFile(path.join(cwd, '.astro.json'), '{invalid json}', 'utf8');
+
+    await expect(loadResolvedProfileFile({ cwd, homeDir: cwd })).rejects.toMatchObject<
+      Partial<ProfileStoreError>
+    >({ code: 'INVALID_PROFILE_FILE' });
+  });
+
+  it('throws DEFAULT_PROFILE_NOT_FOUND when default profile key is invalid', async () => {
+    const cwd = await makeDir('bad-default');
+    await writeFile(
+      path.join(cwd, '.astro.json'),
+      JSON.stringify({
+        version: 1,
+        defaultProfile: 'ghost',
+        profiles: {
+          elwyn: JSON.parse(sampleProfileFile()).profiles.elwyn,
+        },
+      }),
+      'utf8'
+    );
+
+    await expect(resolveProfileSelection({ cwd, homeDir: cwd })).rejects.toMatchObject<
+      Partial<ProfileStoreError>
+    >({ code: 'DEFAULT_PROFILE_NOT_FOUND' });
+  });
+
+  it('throws PROFILE_VALIDATION_FAILED for invalid enum fields', async () => {
+    const cwd = await makeDir('enum-invalid');
+    await writeFile(
+      path.join(cwd, '.astro.json'),
+      JSON.stringify({
+        version: 1,
+        profiles: {
+          bad: {
+            ...JSON.parse(sampleProfileFile()).profiles.elwyn,
+            house_system: 'Z',
+          },
+        },
+      }),
+      'utf8'
+    );
+
+    await expect(loadResolvedProfileFile({ cwd, homeDir: cwd })).rejects.toMatchObject<
+      Partial<ProfileStoreError>
+    >({ code: 'PROFILE_VALIDATION_FAILED' });
+  });
+});

package/tests/unit/real-user-charts.test.ts

@@ -0,0 +1,148 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import { EphemerisCalculator } from '../../src/ephemeris.js';
+import { HouseCalculator } from '../../src/houses.js';
+import type { NatalChart } from '../../src/types.js';
+
+/**
+ * Real user test case: Oct 17 1977, 1:06 PM EDT, Beaver Falls PA
+ * 
+ * This test validates the exact chart from the user session that exposed
+ * multiple time handling bugs:
+ * - Bug 1: Moon was showing as Sagittarius instead of 0° Capricorn
+ * - Bug 2: Ascendant was showing as Gemini instead of 0° Capricorn  
+ * - Bug 3: MC was incorrect due to 4-hour time offset
+ * 
+ * User confirmed correct values:
+ * - Sun: 24° Libra
+ * - Moon: 0°09' Capricorn (0.15°)
+ * - Ascendant: 0° Capricorn
+ * - MC: 24° Libra
+ */
+describe('Real user chart: Oct 17 1977, 1:06 PM EDT, Beaver Falls PA', () => {
+  let ephem: EphemerisCalculator;
+  let houseCalc: HouseCalculator;
+
+  beforeAll(async () => {
+    ephem = new EphemerisCalculator();
+    await ephem.init();
+    houseCalc = new HouseCalculator(ephem);
+  });
+
+  it('should calculate Moon at 0° Capricorn (not Sagittarius)', () => {
+    // User reported: Moon should be 0°09' Capricorn
+    // Bug: Was showing Sagittarius due to time conversion error
+    // 1:06 PM EDT = 17:06 UTC (EDT is UTC-4)
+    
+    const birthDate = new Date(Date.UTC(1977, 9, 17, 17, 6)); // Oct 17, 5:06 PM UTC
+    const jd = ephem.dateToJulianDay(birthDate);
+    const positions = ephem.getAllPlanets(jd, [1]); // Moon
+    const moon = positions[0];
+    
+    expect(moon.sign).toBe('Capricorn');
+    expect(moon.degree).toBeCloseTo(0.15, 0); // 0°09' ≈ 0.15°
+  });
+
+  it('should calculate Ascendant at ~0° Capricorn (not Gemini)', () => {
+    // User confirmed: Ascendant 0° Capricorn
+    // Bug: Was showing Gemini Ascendant (4 hours off)
+    
+    const birthDate = new Date(Date.UTC(1977, 9, 17, 17, 6));
+    const jd = ephem.dateToJulianDay(birthDate);
+    const houses = houseCalc.calculateHouses(
+      jd,
+      40.7509,  // Beaver Falls, PA
+      -80.3198,
+      'P'
+    );
+    
+    // Ascendant should be in Capricorn (270-300°)
+    expect(houses.ascendant).toBeGreaterThanOrEqual(270);
+    expect(houses.ascendant).toBeLessThan(300);
+    
+    // More specifically, should be very close to 0° Capricorn (270°)
+    expect(houses.ascendant).toBeCloseTo(270, 0);
+  });
+
+  it('should calculate MC at 24° Libra', () => {
+    // User confirmed: MC 24° Libra
+    // MC at 24° Libra = 204° (180° + 24°)
+    
+    const birthDate = new Date(Date.UTC(1977, 9, 17, 17, 6));
+    const jd = ephem.dateToJulianDay(birthDate);
+    const houses = houseCalc.calculateHouses(
+      jd,
+      40.7509,
+      -80.3198,
+      'P'
+    );
+    
+    // MC should be in Libra (180-210°)
+    expect(houses.mc).toBeGreaterThanOrEqual(180);
+    expect(houses.mc).toBeLessThan(210);
+    
+    // More specifically, should be around 204° (24° Libra)
+    expect(houses.mc).toBeCloseTo(204, 1);
+  });
+
+  it('should calculate Sun at 24° Libra', () => {
+    // User confirmed: Sun 24° Libra
+    
+    const birthDate = new Date(Date.UTC(1977, 9, 17, 17, 6));
+    const jd = ephem.dateToJulianDay(birthDate);
+    const positions = ephem.getAllPlanets(jd, [0]); // Sun
+    const sun = positions[0];
+    
+    expect(sun.sign).toBe('Libra');
+    expect(sun.degree).toBeCloseTo(24.22, 1); // Actual: 24°13'
+  });
+
+  it('should have Moon conjunct Ascendant (both at 0° Capricorn)', () => {
+    // User noted: Moon conjunct Ascendant at 0° Capricorn
+    // This is a significant chart feature
+    
+    const birthDate = new Date(Date.UTC(1977, 9, 17, 17, 6));
+    const jd = ephem.dateToJulianDay(birthDate);
+    
+    const positions = ephem.getAllPlanets(jd, [1]); // Moon
+    const moon = positions[0];
+    
+    const houses = houseCalc.calculateHouses(jd, 40.7509, -80.3198, 'P');
+    
+    // Both should be in Capricorn
+    expect(moon.sign).toBe('Capricorn');
+    expect(houses.ascendant).toBeGreaterThanOrEqual(270);
+    expect(houses.ascendant).toBeLessThan(300);
+    
+    // Moon longitude and Ascendant should be very close
+    const moonLon = moon.longitude;
+    const ascLon = houses.ascendant;
+    const diff = Math.abs(moonLon - ascLon);
+    
+    expect(diff).toBeLessThan(5); // Within 5° conjunction
+  });
+
+  it('should have Sun conjunct MC (both at 24° Libra)', () => {
+    // User noted: Sun at 24° Libra, MC at 24° Libra
+    // Sun conjunct MC is a powerful chart signature
+    
+    const birthDate = new Date(Date.UTC(1977, 9, 17, 17, 6));
+    const jd = ephem.dateToJulianDay(birthDate);
+    
+    const positions = ephem.getAllPlanets(jd, [0]); // Sun
+    const sun = positions[0];
+    
+    const houses = houseCalc.calculateHouses(jd, 40.7509, -80.3198, 'P');
+    
+    // Both should be in Libra around 24°
+    expect(sun.sign).toBe('Libra');
+    expect(houses.mc).toBeGreaterThanOrEqual(180);
+    expect(houses.mc).toBeLessThan(210);
+    
+    // Sun longitude and MC should be very close
+    const sunLon = sun.longitude;
+    const mcLon = houses.mc;
+    const diff = Math.abs(sunLon - mcLon);
+    
+    expect(diff).toBeLessThan(2); // Within 2° conjunction
+  });
+});

package/tests/unit/riseset.test.ts

@@ -0,0 +1,106 @@
+import { describe, expect, it, vi } from 'vitest';
+import { RiseSetCalculator } from '../../src/riseset.js';
+
+describe('When calculating rise/set events', () => {
+  it('Given Swiss Ephemeris success and no-event flags, then rise/set fields map correctly', () => {
+    const riseTrans = vi
+      .fn()
+      .mockReturnValueOnce({ flag: 1, data: 2451545.25 })
+      .mockReturnValueOnce({ flag: -2 })
+      .mockReturnValueOnce({ flag: 1, data: 2451545.5 })
+      .mockReturnValueOnce({ flag: 1, data: 2451545.75 });
+
+    const ephem = {
+      eph: { rise_trans: riseTrans },
+      julianDayToDate: vi.fn((jd: number) => new Date((jd - 2440587.5) * 86400000)),
+      dateToJulianDay: vi.fn(() => 2451545),
+    };
+
+    const calc = new RiseSetCalculator(ephem as any);
+    const result = calc.calculateRiseSet(2451545, 0, 40, -74, 0);
+
+    expect(result.planet).toBe('Sun');
+    expect(result.rise).toBeInstanceOf(Date);
+    expect(result.set).toBeUndefined();
+    expect(result.upperMeridianTransit).toBeInstanceOf(Date);
+  });
+
+  it('Given a hard rise_trans failure flag, then calculation throws an error', () => {
+    const ephem = {
+      eph: { rise_trans: vi.fn(() => ({ flag: -1, error: 'boom' })) },
+      julianDayToDate: vi.fn(),
+    };
+    const calc = new RiseSetCalculator(ephem as any);
+    expect(() => calc.calculateRiseSet(2451545, 0, 40, -74)).toThrow(/calculation failed/i);
+  });
+
+  it('Given per-planet failures in getAllRiseSet, then remaining planets are still returned', async () => {
+    const calc = new RiseSetCalculator({
+      eph: {},
+      dateToJulianDay: vi.fn(() => 2451545),
+    } as any);
+    const spy = vi.spyOn(calc, 'calculateRiseSet');
+    spy.mockImplementation((jd, planetId) => {
+      if (planetId === 3) {
+        throw new Error('planet failed');
+      }
+      return { planet: String(planetId) } as any;
+    });
+
+    const results = await calc.getAllRiseSet(new Date('2024-03-26T00:00:00Z'), 40, -74);
+    expect(results.length).toBe(9);
+  });
+
+  it('Given invalid ranges or invalid date inputs, then validation errors are raised', async () => {
+    const calc = new RiseSetCalculator({
+      eph: { rise_trans: vi.fn() },
+      dateToJulianDay: vi.fn(() => 2451545),
+      julianDayToDate: vi.fn(),
+    } as any);
+
+    expect(() => calc.calculateRiseSet(2451545, 0, 99, -74)).toThrow(/Invalid latitude/);
+    await expect(calc.getAllRiseSet(new Date('invalid'), 40, -74)).rejects.toThrow(/Invalid date/);
+  });
+
+  it('Given getSunRiseSet, then current instant is used as the anchor and Sun is requested', async () => {
+    const ephem = {
+      eph: {},
+      dateToJulianDay: vi.fn(() => 2451545),
+    };
+    const calc = new RiseSetCalculator(ephem as any);
+    const spy = vi.spyOn(calc, 'calculateRiseSet').mockReturnValue({ planet: 'Sun' } as any);
+    const result = await calc.getSunRiseSet(40, -74);
+    expect(ephem.dateToJulianDay).toHaveBeenCalledTimes(1);
+    expect(spy).toHaveBeenCalledWith(2451545, 0, 40, -74, 0);
+    expect(result.planet).toBe('Sun');
+  });
+
+  it('Given uninitialized ephemeris, then all public methods throw not-initialized errors', async () => {
+    const calc = new RiseSetCalculator({ eph: null } as any);
+    expect(() => calc.calculateRiseSet(2451545, 0, 40, -74)).toThrow(/not initialized/i);
+    await expect(calc.getAllRiseSet(new Date(), 40, -74)).rejects.toThrow(/not initialized/i);
+    await expect(calc.getSunRiseSet(40, -74)).rejects.toThrow(/not initialized/i);
+  });
+
+  it('Given invalid longitude or altitude, then calculateRiseSet rejects the input', () => {
+    const calc = new RiseSetCalculator({
+      eph: { rise_trans: vi.fn(() => ({ flag: -2 })) },
+      julianDayToDate: vi.fn(),
+    } as any);
+    expect(() => calc.calculateRiseSet(2451545, 0, 40, Number.NaN)).toThrow(/Invalid longitude/);
+    expect(() => calc.calculateRiseSet(2451545, 0, 40, -74, Number.NaN)).toThrow(/Invalid altitude/);
+  });
+
+  it('Given a successful flag without finite event data, then event fields remain undefined', () => {
+    const ephem = {
+      eph: {
+        rise_trans: vi.fn(() => ({ flag: 1, data: Number.NaN })),
+      },
+      julianDayToDate: vi.fn(),
+    };
+    const calc = new RiseSetCalculator(ephem as any);
+    const result = calc.calculateRiseSet(2451545, 0, 40, -74);
+    expect(result.rise).toBeUndefined();
+    expect(result.set).toBeUndefined();
+  });
+});