Implement convert_component! for StandardLoad <- PowerLoad

 - Define convert_component! for conversions from PowerLoad to
   StandardLoad
 - Add unit tests for this method along the lines of existing
   convert_component! unit tests
 - Refactor convert_component! unit tests to remove repetition

src/base.jl

@@ -1991,6 +1991,39 @@ function convert_component!(
     return
 end
 
+"""
+Converts a PowerLoad component to a StandardLoad component and replaces the original in the
+system. Does not set any fields in StandardLoad that lack a PowerLoad equivalent
+"""
+function convert_component!(
+    new_type::Type{StandardLoad},
+    old_load::PowerLoad,
+    sys::System;
+    kwargs...,
+)
+    new_load = new_type(;
+        name = get_name(old_load),
+        available = get_available(old_load),
+        bus = get_bus(old_load),
+        base_power = get_base_power(old_load),
+        constant_active_power = get_active_power(old_load),
+        constant_reactive_power = get_reactive_power(old_load),
+        max_constant_active_power = get_max_active_power(old_load),
+        max_constant_reactive_power = get_max_active_power(old_load),
+        dynamic_injector = get_dynamic_injector(old_load),
+        internal = deepcopy(get_internal(old_load)),
+        services = Device[],
+        time_series_container = InfrastructureSystems.TimeSeriesContainer(),
+    )
+    IS.assign_new_uuid!(new_load)
+    add_component!(sys, new_load)
+    copy_time_series!(new_load, old_load)
+    for service in get_services(old_load)
+        add_service!(new_load, service, sys)
+    end
+    remove_component!(sys, old_load)
+end
+
 function _validate_or_skip!(sys, component, skip_validation)
     if skip_validation && get_runchecks(sys)
         @warn(

test/test_powersystemconstructors.jl

@@ -132,26 +132,51 @@ end
 end
 
 @testset "Test component conversion" begin
-    test_conversion =
+    # Reusable resources for this testset
+    load_test_system = () -> System(joinpath(BAD_DATA, "case5_re.m"))
+    function setup_time_series!(sys::System, component::Component, ts_name::String)
+        dates = collect(
+            Dates.DateTime("2020-01-01T00:00:00"):Dates.Hour(1):Dates.DateTime(
+                "2020-01-01T23:00:00",
+            ),
+        )
+        data = collect(1:24)
+        ta = TimeSeries.TimeArray(dates, data, [get_name(component)])
+        time_series = SingleTimeSeries(; name = ts_name, data = ta)
+        add_time_series!(sys, component, time_series)
+        @test get_time_series(SingleTimeSeries, component, ts_name) isa SingleTimeSeries
+    end
+
+    function test_forward_conversion(
+        new_type::Type{<:Component},
+        old_component::Component,
+        sys,
+        component_name,
+        ts_name,
+    )
+        convert_component!(new_type, old_component, sys)
+        println(typeof(old_component))
+        @test isnothing(get_component(typeof(old_component), sys, component_name))
+        new_component = get_component(new_type, sys, component_name)
+        @test !isnothing(new_component)
+        @test get_name(new_component) == component_name
+        @test get_time_series(SingleTimeSeries, new_component, ts_name) isa SingleTimeSeries
+        return new_component
+    end
+
+    """Tests Line <-> MonitoredLine conversion"""
+    test_line_conversion =
         () -> begin
-            sys = System(joinpath(BAD_DATA, "case5_re.m"))
+            sys = load_test_system()
             l = get_component(Line, sys, "bus2-bus3-i_4")
-            initial_time = Dates.DateTime("2020-01-01T00:00:00")
-            dates = collect(
-                initial_time:Dates.Hour(1):Dates.DateTime("2020-01-01T23:00:00"),
-            )
-            data = collect(1:24)
-            ta = TimeSeries.TimeArray(dates, data, [get_name(l)])
-            name = "active_power_flow"
-            time_series = SingleTimeSeries(; name = name, data = ta)
-            add_time_series!(sys, l, time_series)
-            @test get_time_series(SingleTimeSeries, l, name) isa SingleTimeSeries
-            PSY.convert_component!(MonitoredLine, l, sys)
-            @test isnothing(get_component(Line, sys, "bus2-bus3-i_4"))
-            mline = get_component(MonitoredLine, sys, "bus2-bus3-i_4")
-            @test !isnothing(mline)
-            @test get_name(mline) == "bus2-bus3-i_4"
-            @test get_time_series(SingleTimeSeries, mline, name) isa SingleTimeSeries
+            ts_name = "active_power_flow"
+            setup_time_series!(sys, l, ts_name)
+
+            # Conversion to MonitoredLine
+            mline =
+                test_forward_conversion(MonitoredLine, l, sys, "bus2-bus3-i_4", ts_name)
+
+            # Conversion back (must be forced)
             @test_throws ErrorException convert_component!(
                 Line,
                 get_component(MonitoredLine, sys, "bus2-bus3-i_4"),
@@ -165,7 +190,23 @@ end
             )
             line = get_component(Line, sys, "bus2-bus3-i_4")
             @test !isnothing(mline)
-            @test get_time_series(SingleTimeSeries, line, name) isa SingleTimeSeries
+            @test get_time_series(SingleTimeSeries, line, ts_name) isa SingleTimeSeries
         end
-    @test_logs (:error,) min_level = Logging.Error match_mode = :any test_conversion()
+
+    """Tests PowerLoad --> StandardLoad conversion"""
+    test_load_conversion =
+        () -> begin
+            sys = load_test_system()
+            l = get_component(PowerLoad, sys, "bus2")
+            ts_name = "max_active_power"
+            setup_time_series!(sys, l, ts_name)
+
+            # Conversion to StandardLoad
+            sload = test_forward_conversion(StandardLoad, l, sys, "bus2", ts_name)
+
+            # Conversion back is not implemented
+        end
+
+    @test_logs (:error,) min_level = Logging.Error match_mode = :any test_line_conversion()
+    @test_logs (:error,) min_level = Logging.Error match_mode = :any test_load_conversion()
 end