ether-to-astro 1.2.0 → 1.3.0

package/tests/unit/astro-service/natal-service.test.ts

@@ -0,0 +1,126 @@
+import { describe, expect, it, vi } from 'vitest';
+import { NatalService } from '../../../src/astro-service/natal-service.js';
+import type { McpStartupDefaults } from '../../../src/entrypoint.js';
+import type { NatalChart, PlanetPosition } from '../../../src/types.js';
+
+function makePlanet(planet: PlanetPosition['planet'], longitude: number): PlanetPosition {
+  return {
+    planetId: 0,
+    planet,
+    longitude,
+    latitude: 0,
+    distance: 1,
+    speed: 1,
+    sign: 'Aries',
+    degree: longitude % 30,
+    isRetrograde: false,
+  };
+}
+
+function makeNatalChart(): NatalChart {
+  return {
+    name: 'Test User',
+    birthDate: { year: 1990, month: 6, day: 12, hour: 14, minute: 35 },
+    location: { latitude: 37.7749, longitude: -122.4194, timezone: 'America/Los_Angeles' },
+    planets: [makePlanet('Sun', 10), makePlanet('Moon', 20)],
+    julianDay: 2451545,
+    houseSystem: 'P',
+    utcDateTime: { year: 1990, month: 6, day: 12, hour: 21, minute: 35 },
+  };
+}
+
+function makeNatalService(mcpStartupDefaults: McpStartupDefaults = {}) {
+  const ephem = {
+    dateToJulianDay: vi.fn((date: Date) => date.getTime() / 86400000 + 2440587.5),
+    getAllPlanets: vi.fn(() => [makePlanet('Sun', 204), makePlanet('Moon', 270)]),
+  };
+  const houseCalc = {
+    calculateHouses: vi.fn(() => ({
+      ascendant: 270,
+      mc: 204,
+      cusps: [0, 270, 300, 330, 0, 30, 60, 90, 120, 150, 204, 240, 260],
+      system: 'W' as const,
+    })),
+  };
+  const isInitialized = vi.fn(() => true);
+
+  const natalService = new NatalService({
+    ephem: ephem as any,
+    houseCalc: houseCalc as any,
+    mcpStartupDefaults,
+    isInitialized,
+  });
+
+  return { natalService, ephem, houseCalc, isInitialized };
+}
+
+describe('When using the extracted NatalService', () => {
+  it('Given a polar latitude chart, then it preserves natal fallback house behavior', () => {
+    const { natalService } = makeNatalService();
+
+    const result = natalService.setNatalChart({
+      name: 'Polar User',
+      year: 1990,
+      month: 6,
+      day: 12,
+      hour: 14,
+      minute: 35,
+      latitude: 78,
+      longitude: 15,
+      timezone: 'UTC',
+      house_system: 'P',
+    });
+
+    expect(result.chart.houseSystem).toBe('W');
+    expect(result.data).toMatchObject({
+      name: 'Polar User',
+      requestedHouseSystem: 'P',
+      resolvedHouseSystem: 'W',
+      isPolar: true,
+    });
+  });
+
+  it('Given state and defaults, then it preserves server status and house validation behavior', () => {
+    const { natalService, isInitialized } = makeNatalService({
+      preferredTimezone: 'UTC',
+      preferredHouseStyle: 'W',
+      weekdayLabels: true,
+    });
+
+    const status = natalService.getServerStatus(makeNatalChart());
+    expect(isInitialized).toHaveBeenCalled();
+    expect(status.data).toMatchObject({
+      hasNatalChart: true,
+      natalChartName: 'Test User',
+      startupDefaults: {
+        preferredTimezone: 'UTC',
+        preferredHouseStyle: 'W',
+        weekdayLabels: true,
+      },
+      ephemerisInitialized: true,
+    });
+
+    expect(() => natalService.getHouses({ ...makeNatalChart(), julianDay: undefined })).toThrow(
+      /missing julianDay/i
+    );
+  });
+
+  it('Given missing Sun or Moon data, then it preserves the natal ephemeris error contract', () => {
+    const { natalService, ephem } = makeNatalService();
+    ephem.getAllPlanets.mockReturnValue([makePlanet('Sun', 200)]);
+
+    expect(() =>
+      natalService.setNatalChart({
+        name: 'No Moon',
+        year: 1990,
+        month: 1,
+        day: 1,
+        hour: 1,
+        minute: 1,
+        latitude: 1,
+        longitude: 1,
+        timezone: 'UTC',
+      })
+    ).toThrow(/Sun\/Moon/);
+  });
+});

package/tests/unit/astro-service/rising-sign-service.test.ts

@@ -0,0 +1,145 @@
+import { describe, expect, it, vi } from 'vitest';
+import { RisingSignService } from '../../../src/astro-service/rising-sign-service.js';
+
+function makeRisingSignService() {
+  const ephem = {
+    dateToJulianDay: vi.fn((date: Date) => date.getTime() / 86400000 + 2440587.5),
+  };
+  const houseCalc = {
+    calculateHouses: vi.fn(() => ({
+      ascendant: 0,
+      mc: 204,
+      cusps: [0, 270, 300, 330, 0, 30, 60, 90, 120, 150, 204, 240, 260],
+      system: 'P' as const,
+    })),
+  };
+
+  const risingSignService = new RisingSignService({
+    ephem: ephem as any,
+    houseCalc: houseCalc as any,
+  });
+
+  return { risingSignService, ephem, houseCalc };
+}
+
+describe('When using the extracted RisingSignService', () => {
+  it('Given date and location inputs, then it preserves deterministic sign-interval payloads', () => {
+    const { risingSignService, houseCalc } = makeRisingSignService();
+    houseCalc.calculateHouses.mockImplementation((jd: number) => {
+      const dayFraction = ((jd % 1) + 1) % 1;
+      const ascendant = (dayFraction * 360 * 12) % 360;
+      return {
+        ascendant,
+        mc: 204,
+        cusps: [0, 270, 300, 330, 0, 30, 60, 90, 120, 150, 204, 240, 260],
+        system: 'P' as const,
+      };
+    });
+
+    const result = risingSignService.getRisingSignWindows({
+      date: '2026-03-28',
+      latitude: 40.7128,
+      longitude: -74.006,
+      timezone: 'America/New_York',
+      mode: 'exact',
+    });
+
+    const windows = (result.data as any).windows;
+    expect((result.data as any)).toMatchObject({
+      date: '2026-03-28',
+      timezone: 'America/New_York',
+      mode: 'exact',
+    });
+    expect(windows[0]).toMatchObject({
+      sign: expect.any(String),
+      start: expect.any(String),
+      end: expect.any(String),
+      durationMs: expect.any(Number),
+    });
+    expect(windows[0].start).toMatch(/[-+]\d{2}:\d{2}$/);
+    expect(result.text).toContain('Rising Sign Windows');
+  });
+
+  it('Given multiple transitions inside one scan bucket, then exact mode emits every sign window', () => {
+    const { risingSignService, houseCalc } = makeRisingSignService();
+    const transitions = [
+      Date.parse('2026-03-28T00:10:00Z'),
+      Date.parse('2026-03-28T00:30:00Z'),
+      Date.parse('2026-03-28T00:50:00Z'),
+    ];
+
+    houseCalc.calculateHouses.mockImplementation((jd: number) => {
+      const date = new Date((jd - 2440587.5) * 86400000);
+      const millis = date.getTime();
+      const signIndex =
+        transitions.filter((transitionMs) => millis >= transitionMs).length % 2 === 0 ? 0 : 1;
+      return {
+        ascendant: signIndex * 30 + 0.1,
+        mc: 204,
+        cusps: [0, 270, 300, 330, 0, 30, 60, 90, 120, 150, 204, 240, 260],
+        system: 'P' as const,
+      };
+    });
+
+    const result = risingSignService.getRisingSignWindows({
+      date: '2026-03-28',
+      latitude: 40.7128,
+      longitude: -74.006,
+      timezone: 'UTC',
+      mode: 'exact',
+    });
+
+    const windows = (result.data as any).windows as Array<{ start: string; sign: string }>;
+    const firstHourWindows = windows.filter((window) => window.start < '2026-03-28T01:00:00+00:00');
+
+    expect(firstHourWindows).toHaveLength(4);
+    expect(firstHourWindows.map((window) => window.sign)).toEqual([
+      'Aries',
+      'Taurus',
+      'Aries',
+      'Taurus',
+    ]);
+    expect(result.text).toContain('Rising Sign Windows');
+  });
+
+  it('Given invalid location or timezone inputs, then it preserves clear validation errors', () => {
+    const { risingSignService } = makeRisingSignService();
+
+    expect(() =>
+      risingSignService.getRisingSignWindows({
+        date: '2026-03-28',
+        latitude: 95,
+        longitude: -74,
+        timezone: 'America/New_York',
+      })
+    ).toThrow(/Invalid latitude/);
+
+    expect(() =>
+      risingSignService.getRisingSignWindows({
+        date: '2026-03-28',
+        latitude: 40,
+        longitude: -190,
+        timezone: 'America/New_York',
+      })
+    ).toThrow(/Invalid longitude/);
+
+    expect(() =>
+      risingSignService.getRisingSignWindows({
+        date: '2026-03-28',
+        latitude: 40,
+        longitude: -74,
+        timezone: 'Nope/Not-A-Timezone',
+      })
+    ).toThrow(/Invalid timezone/);
+
+    expect(() =>
+      risingSignService.getRisingSignWindows({
+        date: '2026-03-28',
+        latitude: 40,
+        longitude: -74,
+        timezone: 'UTC',
+        mode: 'fast' as any,
+      })
+    ).toThrow(/Invalid mode/);
+  });
+});

package/tests/unit/astro-service/sky-service.test.ts

@@ -0,0 +1,130 @@
+import { describe, expect, it, vi } from 'vitest';
+import { SkyService } from '../../../src/astro-service/sky-service.js';
+import type { McpStartupDefaults } from '../../../src/entrypoint.js';
+import type { NatalChart, PlanetPosition, RiseSetTime } from '../../../src/types.js';
+
+function makePlanet(planet: PlanetPosition['planet'], longitude: number): PlanetPosition {
+  return {
+    planetId: 0,
+    planet,
+    longitude,
+    latitude: 0,
+    distance: 1,
+    speed: 1,
+    sign: 'Aries',
+    degree: longitude % 30,
+    isRetrograde: false,
+  };
+}
+
+function makeNatalChart(): NatalChart {
+  return {
+    name: 'Test User',
+    birthDate: { year: 1990, month: 6, day: 12, hour: 14, minute: 35 },
+    location: { latitude: 37.7749, longitude: -122.4194, timezone: 'America/Los_Angeles' },
+    planets: [makePlanet('Sun', 10), makePlanet('Moon', 20)],
+    julianDay: 2451545,
+    houseSystem: 'P',
+    utcDateTime: { year: 1990, month: 6, day: 12, hour: 21, minute: 35 },
+  };
+}
+
+function makeSkyService(mcpStartupDefaults: McpStartupDefaults = {}) {
+  const ephem = {
+    dateToJulianDay: vi.fn((date: Date) => date.getTime() / 86400000 + 2440587.5),
+    getAllPlanets: vi.fn(() => [makePlanet('Mercury', 42), { ...makePlanet('Saturn', 315), sign: 'Aquarius', isRetrograde: true }]),
+  };
+  const riseSetCalc = {
+    getAllRiseSet: vi.fn(async () => [
+      {
+        planet: 'Sun',
+        rise: new Date('2024-03-26T13:00:00Z'),
+        set: new Date('2024-03-27T01:00:00Z'),
+      },
+    ] as RiseSetTime[]),
+  };
+  const eclipseCalc = {
+    findNextSolarEclipse: vi.fn(() => ({
+      type: 'solar' as const,
+      date: new Date('2024-04-08T18:00:00Z'),
+      eclipseType: 'Total',
+      maxTime: new Date('2024-04-08T18:00:00Z'),
+    })),
+    findNextLunarEclipse: vi.fn(() => null),
+  };
+  const now = vi.fn(() => new Date('2024-03-26T12:00:00Z'));
+  const formatTimestamp = vi.fn((date: Date, timezone: string) => `${timezone}:${date.toISOString()}`);
+
+  const skyService = new SkyService({
+    ephem: ephem as any,
+    riseSetCalc: riseSetCalc as any,
+    eclipseCalc: eclipseCalc as any,
+    mcpStartupDefaults,
+    now,
+    formatTimestamp,
+  });
+
+  return { skyService, ephem, riseSetCalc, eclipseCalc, now, formatTimestamp };
+}
+
+describe('When using the extracted SkyService', () => {
+  it('Given current planetary motion, then it preserves retrograde and asteroid payloads', () => {
+    const { skyService, ephem } = makeSkyService({ preferredTimezone: 'UTC' });
+
+    const retro = skyService.getRetrogradePlanets();
+    expect(retro.data).toMatchObject({
+      date: '2024-03-26',
+      timezone: 'UTC',
+    });
+    expect((retro.data as any).planets).toEqual(
+      expect.arrayContaining([expect.objectContaining({ planet: 'Saturn', isRetrograde: true })])
+    );
+
+    ephem.getAllPlanets.mockReturnValueOnce([
+      { ...makePlanet('True Node', 120), sign: 'Leo' },
+      { ...makePlanet('Chiron', 210), sign: 'Scorpio', isRetrograde: true },
+    ]);
+    const asteroidPositions = skyService.getAsteroidPositions('UTC');
+    expect(asteroidPositions.text).toContain('Rx');
+  });
+
+  it('Given no retrograde planets, then it preserves the retrograde empty-state text', () => {
+    const { skyService, ephem } = makeSkyService();
+    ephem.getAllPlanets.mockReturnValue([{ ...makePlanet('Sun', 10), isRetrograde: false, speed: 1 }]);
+
+    const result = skyService.getRetrogradePlanets('UTC');
+    expect(result.text).toContain('No planets are currently retrograde');
+  });
+
+  it('Given runtime rise-set and eclipse lookups, then it preserves readable summaries', async () => {
+    const { skyService } = makeSkyService({ preferredTimezone: 'America/New_York' });
+
+    const riseSet = await skyService.getRiseSetTimes(makeNatalChart());
+    expect(riseSet.data).toMatchObject({
+      date: '2024-03-26',
+      timezone: 'America/Los_Angeles',
+    });
+    expect(riseSet.text).toContain('America/New_York');
+
+    const eclipses = skyService.getNextEclipses('UTC');
+    expect(eclipses.data).toMatchObject({
+      timezone: 'UTC',
+      eclipses: [expect.objectContaining({ type: 'solar', eclipseType: 'Total' })],
+    });
+    expect(eclipses.text).toContain('Next Solar Eclipse');
+  });
+
+  it('Given both eclipse types, then it includes both in the response payload', () => {
+    const { skyService, eclipseCalc } = makeSkyService();
+    eclipseCalc.findNextLunarEclipse.mockReturnValue({
+      type: 'lunar',
+      date: new Date('2024-09-18T00:00:00Z'),
+      eclipseType: 'Partial',
+      maxTime: new Date('2024-09-18T00:00:00Z'),
+    });
+
+    const result = skyService.getNextEclipses('UTC');
+    expect((result.data as any).eclipses).toHaveLength(2);
+    expect(result.text).toContain('Next Lunar Eclipse');
+  });
+});