Added tests for new calculate module functions.

Author: theriftlab

immanuel/classes/wrap.py

@@ -263,7 +263,7 @@ def __init__(self, object: dict) -> None:
         self.direct = self._movement == calc.DIRECT
         self.stationary = self._movement == calc.STATIONARY
         self.retrograde = self._movement == calc.RETROGRADE
-        self.typical = calculate.object_movement_typical(object)
+        self.typical = calculate.is_object_movement_typical(object)
         self.formatted = _(names.OBJECT_MOVEMENTS[self._movement], gender(object['index']))
 
     def __str__(self) -> str:

immanuel/tools/calculate.py

@@ -79,7 +79,7 @@ def object_movement(object: dict | float) -> int:
     return calc.DIRECT if speed > calc.STATION_SPEED else calc.RETROGRADE
 
 
-def object_movement_typical(object: dict) -> bool:
+def is_object_movement_typical(object: dict) -> bool:
     """ Returns whether an object's movement is typical, ie. direct for planets,
     retrograde for nodes, stationary for Parts and eclipses. """
     if object['index'] in (

tests/test_calculate.py

@@ -120,6 +120,52 @@ def test_object_movement(day_jd, coords):
     assert calculate.object_movement(part_of_fortune) == calc.STATIONARY
 
 
+def test_is_object_movement_typical(day_jd, coords):
+    sun, north_node, part_of_fortune = ephemeris.objects((chart.SUN, chart.NORTH_NODE, chart.PART_OF_FORTUNE), day_jd, *coords, chart.PLACIDUS, calc.DAY_NIGHT_FORMULA).values()
+    # Direct
+    assert calculate.is_object_movement_typical(sun) == True
+    sun['speed'] *= -1
+    assert calculate.is_object_movement_typical(sun) == False
+    # Retrograde
+    assert calculate.is_object_movement_typical(north_node) == True
+    north_node['speed'] *= -1
+    assert calculate.is_object_movement_typical(north_node) == False
+    # Stationed
+    assert calculate.is_object_movement_typical(part_of_fortune) == True
+    part_of_fortune['speed'] *= -1
+    assert calculate.is_object_movement_typical(part_of_fortune) == True
+
+
+def test_relative_position(day_jd, coords):
+    sun, mercury, neptune = ephemeris.objects((chart.SUN, chart.MERCURY, chart.NEPTUNE), day_jd, *coords).values()
+    assert calculate.relative_position(sun, mercury) == calc.ORIENTAL
+    assert calculate.relative_position(sun, neptune) == calc.OCCIDENTAL
+    assert calculate.relative_position(mercury, neptune) == calc.OCCIDENTAL
+    assert calculate.relative_position(neptune, mercury) == calc.ORIENTAL
+
+
+def test_is_in_sect_day(day_jd, coords):
+    sun, moon, mercury, venus, mars, jupiter, saturn = ephemeris.objects((chart.SUN, chart.MOON, chart.MERCURY, chart.VENUS, chart.MARS, chart.JUPITER, chart.SATURN), day_jd, *coords).values()
+    assert calculate.is_in_sect(sun, True) == True
+    assert calculate.is_in_sect(jupiter, True) == True
+    assert calculate.is_in_sect(saturn, True) == True
+    assert calculate.is_in_sect(moon, True) == False
+    assert calculate.is_in_sect(venus, True) == False
+    assert calculate.is_in_sect(mars, True) == False
+    assert calculate.is_in_sect(mercury, True, sun) == (calculate.relative_position(sun, mercury) == calc.ORIENTAL)
+
+
+def test_is_in_sect_night(night_jd, coords):
+    sun, moon, mercury, venus, mars, jupiter, saturn = ephemeris.objects((chart.SUN, chart.MOON, chart.MERCURY, chart.VENUS, chart.MARS, chart.JUPITER, chart.SATURN), night_jd, *coords).values()
+    assert calculate.is_in_sect(sun, False) == False
+    assert calculate.is_in_sect(jupiter, False) == False
+    assert calculate.is_in_sect(saturn, False) == False
+    assert calculate.is_in_sect(moon, False) == True
+    assert calculate.is_in_sect(venus, False) == True
+    assert calculate.is_in_sect(mars, False) == True
+    assert calculate.is_in_sect(mercury, False, sun) == (calculate.relative_position(sun, mercury) == calc.OCCIDENTAL)
+
+
 def test_is_out_of_bounds(day_jd, coords):
     sun, mercury = ephemeris.objects((chart.SUN, chart.MERCURY), day_jd, *coords, chart.PLACIDUS).values()
     assert calculate.is_out_of_bounds(sun, day_jd) is False

tests/test_charts.py

@@ -20,7 +20,8 @@
 from pytest import fixture
 
 from immanuel import charts
-from immanuel.const import calc, chart, names
+from immanuel.classes import wrap
+from immanuel.const import calc, chart, dignities, names
 from immanuel.setup import settings
 from immanuel.tools import convert
 
@@ -95,6 +96,167 @@ def test_subject(dob, lat, lon, native, julian_date):
     assert ambiguous_native.date_time_ambiguous == True
 
 
+def test_wrapped_data(native):
+    settings.objects.append(chart.PRE_NATAL_LUNAR_ECLIPSE)
+    natal_chart = charts.Natal(native)
+
+    # Angle
+    longitude = natal_chart.objects[chart.SUN].longitude
+    assert longitude.raw == 280.6237802656368
+    assert longitude.formatted == '280°37\'26"'
+    assert longitude.direction == '+'
+    assert longitude.degrees == 280
+    assert longitude.minutes == 37
+    assert longitude.seconds == 26
+
+    # Aspect
+    aspect = natal_chart.aspects[chart.SUN][chart.MOON]
+    assert aspect.active == chart.MOON
+    assert aspect.passive == chart.SUN
+    assert aspect.type == names.ASPECTS[calc.SEXTILE]
+    assert aspect.aspect == calc.SEXTILE
+    assert aspect.orb == settings.planet_orbs[calc.SEXTILE]
+    assert type(aspect.distance) is wrap.Angle                      # Tested separately, just ensure type
+    assert type(aspect.difference) is wrap.Angle                    # Tested separately, just ensure type
+
+    # AspectCondition
+    assert aspect.condition.associate == True
+    assert aspect.condition.dissociate == False
+    assert aspect.condition.formatted == names.ASPECT_CONDITIONS[calc.ASSOCIATE]
+
+    # AspectMovement
+    assert aspect.movement.applicative == False
+    assert aspect.movement.exact == False
+    assert aspect.movement.separative == True
+    assert aspect.movement.formatted == names.ASPECT_MOVEMENTS[calc.SEPARATIVE]
+
+    # Coordinates
+    assert type(natal_chart.native.coordinates.latitude) is wrap.Angle      # Tested separately, just ensure type
+    assert type(natal_chart.native.coordinates.longitude) is wrap.Angle     # Tested separately, just ensure type
+
+    # DateTime
+    date_time = natal_chart.native.date_time
+    assert type(date_time.datetime) is datetime
+    assert date_time.timezone == 'PST'
+    assert date_time.ambiguous == False
+    assert date_time.julian == 2451545.25
+    assert date_time.deltat == 0.0007387629899254968
+    assert date_time.sidereal_time == '16:54:13'
+
+    # MoonPhase
+    moon_phase = natal_chart.moon_phase
+    assert moon_phase.new_moon == False
+    assert moon_phase.waxing_crescent == False
+    assert moon_phase.first_quarter == False
+    assert moon_phase.waxing_gibbous == False
+    assert moon_phase.full_moon == False
+    assert moon_phase.disseminating == False
+    assert moon_phase.third_quarter == True
+    assert moon_phase.balsamic == False
+    assert moon_phase.formatted == names.MOON_PHASES[calc.THIRD_QUARTER]
+
+    # Object
+    sun = natal_chart.objects[chart.SUN]
+    assert sun.index == chart.SUN
+    assert sun.name == names.PLANETS[chart.SUN]
+    assert sun.distance == 0.9833259257690341
+    assert sun.speed == 1.0194579691359147
+    assert sun.out_of_bounds == False
+    assert sun.in_sect == True
+    assert sun.score == 3
+
+    assert type(sun.latitude) is wrap.Angle             # Tested separately, just ensure type
+    assert type(sun.longitude) is wrap.Angle            # Tested separately, just ensure type
+    assert type(sun.sign_longitude) is wrap.Angle       # Tested separately, just ensure type
+    assert type(sun.declination) is wrap.Angle          # Tested separately, just ensure type
+
+    # ObjectType
+    assert sun.type.index == chart.PLANET
+    assert sun.type.name == names.OBJECTS[chart.PLANET]
+
+    # Sign
+    assert sun.sign.number == chart.CAPRICORN
+    assert sun.sign.name == names.SIGNS[chart.CAPRICORN]
+    assert sun.sign.element == names.ELEMENTS[chart.EARTH]
+    assert sun.sign.modality == names.MODALITIES[chart.CARDINAL]
+
+    # Decan
+    assert sun.decan.number == chart.DECAN2
+    assert sun.decan.name == names.DECANS[chart.DECAN2]
+
+    # House
+    assert sun.house.index == chart.HOUSE11
+    assert sun.house.number == 11
+    assert sun.house.name == names.HOUSES[chart.HOUSE11]
+
+    # ObjectMovement
+    assert sun.movement.direct == True
+    assert sun.movement.stationary == False
+    assert sun.movement.retrograde == False
+    assert sun.movement.typical == True
+    assert sun.movement.formatted == names.OBJECT_MOVEMENTS[calc.DIRECT]
+
+    # DignityState
+    assert sun.dignities.ruler == False
+    assert sun.dignities.exalted == False
+    assert sun.dignities.triplicity_ruler == False
+    assert sun.dignities.term_ruler == False
+    assert sun.dignities.face_ruler == False
+    assert sun.dignities.mutual_reception_ruler == False
+    assert sun.dignities.mutual_reception_exalted == False
+    assert sun.dignities.mutual_reception_triplicity_ruler == True
+    assert sun.dignities.mutual_reception_term_ruler == False
+    assert sun.dignities.mutual_reception_face_ruler == False
+    assert sun.dignities.detriment == False
+    assert sun.dignities.fall == False
+    assert sun.dignities.peregrine == False
+    assert sun.dignities.formatted == [
+        names.DIGNITIES[dignities.MUTUAL_RECEPTION_TRIPLICITY_RULER],
+    ]
+
+    # EclipseType
+    eclipse = natal_chart.objects[chart.PRE_NATAL_LUNAR_ECLIPSE]
+    assert eclipse.eclipse_type.total == False
+    assert eclipse.eclipse_type.annular == False
+    assert eclipse.eclipse_type.partial == True
+    assert eclipse.eclipse_type.annular_total == False
+    assert eclipse.eclipse_type.penumbral == False
+    assert eclipse.eclipse_type.formatted == names.ECLIPSE_TYPES[chart.PARTIAL]
+
+    assert type(eclipse.date_time) is wrap.DateTime         # Tested separately, just ensure type
+
+    # Subject
+    subject = natal_chart.native
+    assert type(subject.date_time) is wrap.DateTime         # Tested separately, just ensure type
+    assert type(subject.coordinates) is wrap.Coordinates    # Tested separately, just ensure type
+
+    # Weightings
+    weightings = natal_chart.weightings
+    assert type(weightings.elements) is wrap.Elements       # Tested separately, just ensure type
+    assert type(weightings.modalities) is wrap.Modalities   # Tested separately, just ensure type
+    assert type(weightings.quadrants) is wrap.Quadrants     # Tested separately, just ensure type
+
+    # Elements
+    elements = natal_chart.weightings.elements
+    assert type(elements.fire) is list
+    assert type(elements.earth) is list
+    assert type(elements.air) is list
+    assert type(elements.water) is list
+
+    # Modalities
+    modalities = natal_chart.weightings.modalities
+    assert type(modalities.cardinal) is list
+    assert type(modalities.fixed) is list
+    assert type(modalities.mutable) is list
+
+    # Quadrants
+    quadrants = natal_chart.weightings.quadrants
+    assert type(quadrants.first) is list
+    assert type(quadrants.second) is list
+    assert type(quadrants.third) is list
+    assert type(quadrants.fourth) is list
+
+
 def test_natal(native, lat, lon):
     natal_chart = charts.Natal(native)