Increase test coverage

Author: langestefan

Project.toml

@@ -1,7 +1,10 @@
 name = "SolarPosition"
 uuid = "5b9d1343-a731-5a90-8730-7bf8d89bf3eb"
-authors = ["Stefan de Lange"]
 version = "0.1.0"
+authors = ["Stefan de Lange"]
+
+[workspace]
+projects = ["test", "docs"]
 
 [deps]
 Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
@@ -29,10 +32,10 @@ Makie = "0.24"
 ModelingToolkit = "10.3.0 - 10.26.1"
 OhMyThreads = "0.8"
 StructArrays = "0.7"
+Symbolics = "6,7"
 Tables = "1"
 Test = "1"
 TimeZones = "1.22.0"
-Symbolics = "6,7"
 julia = "1.10"
 
 [extras]
@@ -41,6 +44,3 @@ Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
 test = ["Aqua", "Test"]
-
-[workspace]
-projects = ["test", "docs"]

test/test-deltat.jl

@@ -147,3 +147,25 @@ end
 
     @test deltat_values[1] < deltat_values[end]
 end
+
+@testset "ΔT edge cases" begin
+    # Test years before -1999 (should warn and return extrapolated value)
+    @test_logs (:warn, r"ΔT is undefined") calculate_deltat(DateTime(-2500, 6, 1))
+
+    # Test years after 3000 (should warn and return extrapolated value)
+    @test_logs (:warn, r"ΔT is undefined") calculate_deltat(DateTime(3500, 6, 1))
+
+    # Test year ranges that hit specific polynomial cases
+    # 1860-1900 range
+    dt1 = calculate_deltat(DateTime(1870, 6, 1))
+    @test dt1 isa Float64
+
+    # 1900-1920 range
+    dt2 = calculate_deltat(DateTime(1910, 6, 1))
+    @test dt2 isa Float64
+
+    # 1941-1961 range (line 50)
+    dt3 = calculate_deltat(DateTime(1950, 6, 1))
+    @test dt3 isa Float64
+    @test dt3 > 0.0
+end

test/test-interface.jl

@@ -290,3 +290,76 @@ end
         @test isfinite(res.equation_of_time)
     end
 end
+
+@testset "Base.show methods" begin
+    @testset "Observer show" begin
+        obs = Observer(45.0, 10.0, 100.0)
+        str = sprint(show, obs)
+        @test occursin("Observer", str)
+        @test occursin("45.0", str)
+        @test occursin("10.0", str)
+        @test occursin("100.0", str)
+    end
+
+    @testset "SolPos show" begin
+        pos = SolPos(180.0, 45.0, 45.0)
+        str = sprint(show, pos)
+        @test occursin("SolPos", str)
+        @test occursin("180.0", str)
+        @test occursin("45.0", str)
+    end
+
+    @testset "ApparentSolPos show" begin
+        pos = ApparentSolPos(180.0, 45.0, 45.0, 46.0, 44.0)
+        str = sprint(show, pos)
+        @test occursin("ApparentSolPos", str)
+        @test occursin("180.0", str)
+        @test occursin("45.0", str)
+        @test occursin("46.0", str)
+        @test occursin("44.0", str)
+    end
+
+    @testset "SPASolPos show" begin
+        pos = SPASolPos(180.0, 45.0, 45.0, 46.0, 44.0, 5.0)
+        str = sprint(show, pos)
+        @test occursin("SPASolPos", str)
+        @test occursin("180.0", str)
+        @test occursin("45.0", str)
+        @test occursin("5.0", str)
+    end
+end
+
+@testset "Union{DateTime,ZonedDateTime} vector handling" begin
+    obs = Observer(45.0, 10.0, 100.0)
+    dt1 = DateTime(2020, 6, 21, 12, 0, 0)
+    dt2 = ZonedDateTime(2020, 6, 21, 13, 0, 0, tz"UTC")
+
+    # mixed vector of DateTime and ZonedDateTime
+    dts = Union{DateTime,ZonedDateTime}[dt1, dt2]
+    positions = solar_position(obs, dts, PSA())
+    @test length(positions) == 2
+    @test positions isa StructVector
+
+    # in-place version
+    pos = StructVector{SolPos{Float64}}(undef, 2)
+    solar_position!(pos, obs, dts, PSA())
+    @test length(pos) == 2
+    @test all(p -> p isa SolPos, pos)
+end
+
+@testset "Table interface with copy" begin
+    # non-mutating solar_position function for tables
+    obs = Observer(45.0, 10.0, 100.0)
+    df = DataFrame(
+        datetime = [DateTime(2020, 6, 21, 12, 0, 0), DateTime(2020, 6, 21, 13, 0, 0)],
+    )
+
+    # returns copy
+    df_result = solar_position(df, obs, PSA())
+
+    # should not be modified
+    @test !hasproperty(df, :azimuth)
+    @test hasproperty(df_result, :azimuth)
+    @test hasproperty(df_result, :elevation)
+    @test hasproperty(df_result, :zenith)
+end

test/test-noaa.jl

@@ -84,4 +84,22 @@
         )
         @test isapprox(res_with_refraction.zenith, res_no_refraction.zenith, atol = 1e-10)
     end
+
+    @testset "NOAA edge cases" begin
+        obs = Observer(45.0, 10.0, 100.0)
+
+        # Test time that produces negative true_solar_time / 4.0
+        # This should trigger the hour_angle < 0 branch
+        dt = DateTime(2020, 1, 1, 0, 0, 0)
+        pos = solar_position(obs, dt, NOAA(), NoRefraction())
+        @test pos isa SolPos
+        @test isfinite(pos.azimuth)
+
+        # Test time that produces positive true_solar_time / 4.0 (line 88)
+        # Solar noon should trigger the else branch
+        dt_noon = DateTime(2020, 6, 21, 12, 0, 0)
+        pos_noon = solar_position(obs, dt_noon, NOAA(), NoRefraction())
+        @test pos_noon isa SolPos
+        @test isfinite(pos_noon.azimuth)
+    end
 end

test/test-ohmythreads.jl

@@ -50,8 +50,7 @@ spafields = (
         end
 
         @testset "solar_position with ZonedDateTime" begin
-            tz = tz"UTC"
-            zoned_times = [ZonedDateTime(dt, tz) for dt in times]
+            zoned_times = [ZonedDateTime(dt, tz"UTC") for dt in times]
             zoned_serial_results = solar_position(obs, zoned_times, PSA(), NoRefraction())
             results = solar_position(obs, zoned_times, PSA(), NoRefraction(), scheduler)
             @test length(results) == n

test/test-psa.jl

@@ -53,4 +53,10 @@
             @test res_alg isa ApparentSolPos
         end
     end
+
+    @testset "PSA coefficient error" begin
+        obs = Observer(45.0, 10.0, 100.0)
+        dt = DateTime(2020, 6, 21, 12, 0, 0)
+        @test_throws ErrorException solar_position(obs, dt, PSA(9999))
+    end
 end

test/test-refraction.jl

@@ -107,3 +107,24 @@ end
     @test refraction(SPARefraction(101325.0, 12.0, 0.0), -0.26667) != 0.0
     @test refraction(SPARefraction(101325.0, 12.0, 0.0), -0.26668) != 1.0
 end
+
+@testset "SPARefraction constructor variants" begin
+
+    ref1 = SPARefraction()
+    @test ref1.pressure == 101325.0
+    @test ref1.temperature == 12.0
+    @test ref1.refraction_limit == -0.5667
+
+    # with pressure and temperature
+    ref2 = SPARefraction(100000.0, 15.0)
+    @test ref2.pressure == 100000.0
+    @test ref2.temperature == 15.0
+    @test ref2.refraction_limit == -0.5667
+
+    # refraction works
+    obs = Observer(45.0, 10.0, 100.0)
+    dt = DateTime(2020, 6, 21, 12, 0, 0)
+    pos = solar_position(obs, dt, SPA(), ref2)
+    @test pos isa SPASolPos
+    @test pos.apparent_elevation != pos.elevation
+end

test/test-spa.jl

@@ -87,4 +87,91 @@
         @test all(r -> -180.0 <= r.azimuth <= 360.0, results)
         @test all(r -> -90.0 <= r.elevation <= 90.0, results)
     end
+
+    @testset "SPA edge cases" begin
+        obs = Observer(45.0, 10.0, 5000.0)  # High altitude to test parallax terms
+
+        # Test with extreme latitude close to poles
+        obs_pole = Observer(89.99, 10.0, 100.0)
+        dt = DateTime(2020, 6, 21, 12, 0, 0)
+        pos = solar_position(obs_pole, dt, SPA())
+        @test pos isa SPASolPos
+
+        # Test equation of time limits
+        dt_eot = DateTime(2020, 11, 3, 6, 0, 0)
+        pos_eot = solar_position(obs, dt_eot, SPA())
+        @test -20.0 <= pos_eot.equation_of_time <= 20.0
+    end
+
+    @testset "SPA x_term and y_term functions" begin
+        # These functions are used internally by SPA but not directly tested
+        # They should be covered by creating SPAObserver instances
+        obs1 = SolarPosition.Positioning.SPAObserver(45.0, 10.0, 0.0)
+        @test obs1.x != 0.0
+        @test obs1.y != 0.0
+
+        obs2 = SolarPosition.Positioning.SPAObserver(45.0, 10.0, 5000.0)
+        @test obs2.x != obs1.x  # Different altitude should give different x
+        @test obs2.y != obs1.y  # Different altitude should give different y
+
+        # Test alternative constructor with keyword argument (line 107)
+        obs3 = SolarPosition.Positioning.SPAObserver(45.0, 10.0; altitude = 100.0)
+        @test obs3.altitude == 100.0
+        @test obs3.latitude == 45.0
+        @test obs3.longitude == 10.0
+
+        # Test internal helper functions directly (lines 281-290)
+        u = SolarPosition.Positioning.u_term(45.0)
+        @test u isa Float64
+        @test isfinite(u)
+
+        x = SolarPosition.Positioning.x_term(u, 45.0, 100.0)
+        @test x isa Float64
+        @test isfinite(x)
+
+        y = SolarPosition.Positioning.y_term(u, 45.0, 100.0)
+        @test y isa Float64
+        @test isfinite(y)
+    end
+
+    @testset "SPA pole warnings for SPAObserver" begin
+        # Test north pole warning
+        @test_logs (:warn, r"Latitude is 90") SolarPosition.Positioning.SPAObserver(
+            90.0,
+            0.0,
+            0.0,
+        )
+
+        # Test south pole warning
+        @test_logs (:warn, r"Latitude is -90") SolarPosition.Positioning.SPAObserver(
+            -90.0,
+            0.0,
+            0.0,
+        )
+    end
+
+    @testset "SPA equation of time limits" begin
+        obs = Observer(45.0, 10.0, 100.0)
+
+        # Test time that produces E > 20.0 (should subtract 1440)
+        # This is rare but can happen at specific dates/times
+        dt1 = DateTime(2020, 1, 1, 0, 0, 0)
+        pos1 = solar_position(obs, dt1, SPA())
+        @test pos1 isa SPASolPos
+        @test -20.0 <= pos1.equation_of_time <= 20.0
+
+        # Test multiple dates to increase chance of hitting edge cases (line 377)
+        # Try dates near perihelion and aphelion when equation of time extremes occur
+        test_dates = [
+            DateTime(2020, 1, 3, 0, 0, 0),   # Near perihelion
+            DateTime(2020, 7, 4, 0, 0, 0),   # Near aphelion
+            DateTime(2020, 2, 12, 0, 0, 0),  # E might be positive extreme
+            DateTime(2020, 11, 3, 0, 0, 0),  # E might be negative extreme
+        ]
+
+        for dt in test_dates
+            pos = solar_position(obs, dt, SPA())
+            @test -20.0 <= pos.equation_of_time <= 20.0
+        end
+    end
 end

test/test-usno.jl

@@ -85,4 +85,20 @@
         @test res.elevation > 85.0
         @test res.zenith < 5.0
     end
+
+    @testset "USNO with DefaultRefraction" begin
+
+        obs = Observer(45.0, 10.0, 100.0)
+        dt = DateTime(2020, 6, 21, 12, 0, 0)
+        pos = solar_position(obs, dt, USNO())
+        @test pos isa SolPos
+        @test !hasfield(typeof(pos), :apparent_elevation)
+
+        # result_type is correctly set
+        @test SolarPosition.Positioning.result_type(
+            USNO,
+            SolarPosition.Refraction.DefaultRefraction,
+            Float64,
+        ) == SolPos{Float64}
+    end
 end

test/test-walraven.jl

@@ -21,4 +21,22 @@
         @test isapprox(res.zenith, exp_zen, atol = 1e-6)
         @test isapprox(res.azimuth, exp_az, atol = 1e-6)
     end
+
+    @testset "Walraven edge cases" begin
+        obs = Observer(45.0, 10.0, 100.0)
+
+        # Test leap year edge case
+        # February 29 in a leap year
+        dt_leap = DateTime(2020, 2, 29, 12, 0, 0)
+        pos = solar_position(obs, dt_leap, Walraven())
+        @test pos isa SolPos
+
+        # Test edge case with negative δ that's not leap*4 (line 33)
+        # Early in the year when δ < 0
+        dt_neg = DateTime(2020, 1, 2, 0, 0, 0)
+        pos = solar_position(obs, dt_neg, Walraven())
+        @test pos isa SolPos
+        @test isfinite(pos.azimuth)
+        @test isfinite(pos.elevation)
+    end
 end