Enh/ap 25699 migrate nodefuncs

org.knime.base.tests/src/org/knime/base/node/preproc/constantvalue/ConstantValueColumnKaiNodeInterfaceFactoryTest.java

@@ -0,0 +1,262 @@
+/*
+ * ------------------------------------------------------------------------
+ *
+ *  Copyright by KNIME AG, Zurich, Switzerland
+ *  Website: http://www.knime.com; Email: contact@knime.com
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License, Version 3, as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful, but
+ *  WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, see <http://www.gnu.org/licenses>.
+ *
+ *  Additional permission under GNU GPL version 3 section 7:
+ *
+ *  KNIME interoperates with ECLIPSE solely via ECLIPSE's plug-in APIs.
+ *  Hence, KNIME and ECLIPSE are both independent programs and are not
+ *  derived from each other. Should, however, the interpretation of the
+ *  GNU GPL Version 3 ("License") under any applicable laws result in
+ *  KNIME and ECLIPSE being a combined program, KNIME AG herewith grants
+ *  you the additional permission to use and propagate KNIME together with
+ *  ECLIPSE with only the license terms in place for ECLIPSE applying to
+ *  ECLIPSE and the GNU GPL Version 3 applying for KNIME, provided the
+ *  license terms of ECLIPSE themselves allow for the respective use and
+ *  propagation of ECLIPSE together with KNIME.
+ *
+ *  Additional permission relating to nodes for KNIME that extend the Node
+ *  Extension (and in particular that are based on subclasses of NodeModel,
+ *  NodeDialog, and NodeView) and that only interoperate with KNIME through
+ *  standard APIs ("Nodes"):
+ *  Nodes are deemed to be separate and independent programs and to not be
+ *  covered works.  Notwithstanding anything to the contrary in the
+ *  License, the License does not apply to Nodes, you are not required to
+ *  license Nodes under the License, and you are granted a license to
+ *  prepare and propagate Nodes, in each case even if such Nodes are
+ *  propagated with or for interoperation with KNIME.  The owner of a Node
+ *  may freely choose the license terms applicable to such Node, including
+ *  when such Node is propagated with or for interoperation with KNIME.
+ * ---------------------------------------------------------------------
+ *
+ * History
+ *   Apr 15, 2026 (Adrian Nembach, KNIME GmbH, Konstanz, Germany): created
+ */
+package org.knime.base.node.preproc.constantvalue;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.Mockito.mock;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.Set;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.knime.base.node.preproc.constantvalue.ConstantValueColumnKaiNodeInterfaceFactory.ConstantValueColumnKaiParameters;
+import org.knime.base.node.preproc.constantvalue.ConstantValueColumnKaiNodeInterfaceFactory.ConstantValueColumnKaiParameters.ConstantColumnEntry;
+import org.knime.base.node.preproc.constantvalue.ConstantValueColumnNodeSettings.NewColumnSettings;
+import org.knime.base.node.preproc.constantvalue.ConstantValueColumnNodeSettings.NewColumnSettings.AppendOrReplace;
+import org.knime.base.node.preproc.constantvalue.ConstantValueColumnNodeSettings.NewColumnSettings.CustomOrMissingValue;
+import org.knime.core.data.DataType;
+import org.knime.core.data.DataTypeRegistry;
+import org.knime.core.data.def.IntCell;
+import org.knime.core.data.def.StringCell;
+import org.knime.core.data.def.StringCell.StringCellFactory;
+import org.knime.core.node.InvalidSettingsException;
+import org.knime.node.parameters.NodeParametersInput;
+import org.knime.node.parameters.experimental.dynamic.extensions.createcell.CreateDataCellExtensionsUtil;
+import org.knime.node.parameters.experimental.dynamic.extensions.createcell.CreateDataCellParameters;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+
+@SuppressWarnings("restriction")
+class ConstantValueColumnKaiNodeInterfaceFactoryTest {
+
+    private MockedStatic<DataTypeRegistry> m_mockedStaticRegistry;
+
+    private static final Set<DataType> DATA_TYPES = Set.of(StringCell.TYPE, IntCell.TYPE);
+
+    @BeforeEach
+    void mockDataTypeRegistry() {
+        var realRegistry = DataTypeRegistry.getInstance();
+        var registrySpy = Mockito.spy(realRegistry);
+        Mockito.when(registrySpy.availableDataTypes()).thenAnswer(i -> {
+            i.callRealMethod();
+            return DATA_TYPES;
+        });
+        m_mockedStaticRegistry = Mockito.mockStatic(DataTypeRegistry.class, Mockito.CALLS_REAL_METHODS);
+        m_mockedStaticRegistry.when(DataTypeRegistry::getInstance).thenReturn(registrySpy);
+    }
+
+    @AfterEach
+    void closeRegistryMock() {
+        m_mockedStaticRegistry.close();
+    }
+
+    // -- toKaiParameters --
+
+    @Test
+    void testToKaiParametersAppendWithCustomValue() throws Exception {
+        var settings = new ConstantValueColumnNodeSettings();
+        var s = new NewColumnSettings();
+        s.m_replaceOrAppend = AppendOrReplace.APPEND;
+        s.m_columnNameToAppend = "MyColumn";
+        s.m_type = StringCellFactory.TYPE;
+        s.m_customOrMissingValue = CustomOrMissingValue.CUSTOM;
+        s.m_customValueParameters = fromStringParameters("hello");
+        settings.m_newColumnSettings = new NewColumnSettings[]{s};
+
+        var kai = ConstantValueColumnKaiNodeInterfaceFactory.toKaiParameters(settings);
+
+        assertThat(kai.m_columns).hasSize(1);
+        assertThat(kai.m_columns[0].m_appendOrReplace).isEqualTo(AppendOrReplace.APPEND);
+        assertThat(kai.m_columns[0].m_columnName).isEqualTo("MyColumn");
+        assertThat(kai.m_columns[0].m_type).isEqualTo(StringCell.class.getName());
+        assertThat(kai.m_columns[0].m_customOrMissingValue).isEqualTo(CustomOrMissingValue.CUSTOM);
+        assertThat(kai.m_columns[0].m_value).isEqualTo("hello");
+    }
+
+    @Test
+    void testToKaiParametersReplaceWithMissingValue() {
+        var s = new NewColumnSettings();
+        s.m_replaceOrAppend = AppendOrReplace.REPLACE;
+        s.m_columnNameToReplace = "ExistingColumn";
+        s.m_type = StringCellFactory.TYPE;
+        s.m_customOrMissingValue = CustomOrMissingValue.MISSING;
+        var settings = new ConstantValueColumnNodeSettings();
+        settings.m_newColumnSettings = new NewColumnSettings[]{s};
+
+        var kai = ConstantValueColumnKaiNodeInterfaceFactory.toKaiParameters(settings);
+
+        assertThat(kai.m_columns).hasSize(1);
+        assertThat(kai.m_columns[0].m_appendOrReplace).isEqualTo(AppendOrReplace.REPLACE);
+        assertThat(kai.m_columns[0].m_columnName).isEqualTo("ExistingColumn");
+        assertThat(kai.m_columns[0].m_customOrMissingValue).isEqualTo(CustomOrMissingValue.MISSING);
+        assertThat(kai.m_columns[0].m_value).isNull();
+    }
+
+    @Test
+    void testToKaiParametersPreservesMultipleColumnsInOrder() throws Exception {
+        var col1 = new NewColumnSettings();
+        col1.m_replaceOrAppend = AppendOrReplace.APPEND;
+        col1.m_columnNameToAppend = "First";
+        col1.m_type = StringCellFactory.TYPE;
+        col1.m_customOrMissingValue = CustomOrMissingValue.MISSING;
+        var col2 = new NewColumnSettings();
+        col2.m_replaceOrAppend = AppendOrReplace.APPEND;
+        col2.m_columnNameToAppend = "Second";
+        col2.m_type = IntCell.TYPE;
+        col2.m_customOrMissingValue = CustomOrMissingValue.CUSTOM;
+        col2.m_customValueParameters = fromStringParameters("42");
+        var settings = new ConstantValueColumnNodeSettings();
+        settings.m_newColumnSettings = new NewColumnSettings[]{col1, col2};
+
+        var kai = ConstantValueColumnKaiNodeInterfaceFactory.toKaiParameters(settings);
+
+        assertThat(kai.m_columns).hasSize(2);
+        assertThat(kai.m_columns[0].m_columnName).isEqualTo("First");
+        assertThat(kai.m_columns[1].m_columnName).isEqualTo("Second");
+        assertThat(kai.m_columns[1].m_value).isEqualTo("42");
+    }
+
+    // -- toRealNodeParameters --
+
+    @Test
+    void testToRealNodeParametersAppendCustomValue() throws InvalidSettingsException {
+        var kai = kaiParams(entry(AppendOrReplace.APPEND, "MyColumn", StringCell.class.getName(), CustomOrMissingValue.CUSTOM, "world"));
+
+        var result = ConstantValueColumnKaiNodeInterfaceFactory.toRealNodeParameters(kai);
+
+        assertThat(result.m_newColumnSettings).hasSize(1);
+        var s = result.m_newColumnSettings[0];
+        assertThat(s.m_replaceOrAppend).isEqualTo(AppendOrReplace.APPEND);
+        assertThat(s.m_columnNameToAppend).isEqualTo("MyColumn");
+        assertThat(s.m_type).isEqualTo(StringCell.TYPE);
+        assertThat(s.m_customOrMissingValue).isEqualTo(CustomOrMissingValue.CUSTOM);
+        assertThat(s.m_customValueParameters).isNotNull();
+        assertThat(s.m_customValueParameters.toString()).isEqualTo("world");
+    }
+
+    @Test
+    void testToRealNodeParametersReplaceColumn() throws InvalidSettingsException {
+        var kai = kaiParams(entry(AppendOrReplace.REPLACE, "OldColumn", StringCell.class.getName(), CustomOrMissingValue.MISSING, null));
+
+        var result = ConstantValueColumnKaiNodeInterfaceFactory.toRealNodeParameters(kai);
+
+        var s = result.m_newColumnSettings[0];
+        assertThat(s.m_replaceOrAppend).isEqualTo(AppendOrReplace.REPLACE);
+        assertThat(s.m_columnNameToReplace).isEqualTo("OldColumn");
+    }
+
+    @Test
+    void testToRealNodeParametersMissingValue() throws InvalidSettingsException {
+        var kai = kaiParams(entry(AppendOrReplace.APPEND, "Col", StringCell.class.getName(), CustomOrMissingValue.MISSING, null));
+
+        var result = ConstantValueColumnKaiNodeInterfaceFactory.toRealNodeParameters(kai);
+
+        var s = result.m_newColumnSettings[0];
+        assertThat(s.m_customOrMissingValue).isEqualTo(CustomOrMissingValue.MISSING);
+        assertThat(s.m_customValueParameters).isNull();
+    }
+
+    @Test
+    void testToRealNodeParametersUnknownTypeThrows() {
+        var kai = kaiParams(entry(AppendOrReplace.APPEND, "Col", "com.example.NoSuchCell", CustomOrMissingValue.MISSING, null));
+
+        var ex = assertThrows(InvalidSettingsException.class,
+            () -> ConstantValueColumnKaiNodeInterfaceFactory.toRealNodeParameters(kai));
+
+        assertThat(ex).hasMessageContaining("com.example.NoSuchCell");
+    }
+
+    @Test
+    void testToRealNodeParametersEmptyColumnsArrayThrows() {
+        var kai = new ConstantValueColumnKaiParameters();
+        kai.m_columns = new ConstantColumnEntry[0];
+
+        assertThrows(InvalidSettingsException.class,
+            () -> ConstantValueColumnKaiNodeInterfaceFactory.toRealNodeParameters(kai));
+    }
+
+    // -- helpers --
+
+    private static NodeParametersInput noContext() {
+        return mock(NodeParametersInput.class);
+    }
+
+    private static ConstantValueColumnKaiParameters kaiParams(final ConstantColumnEntry... entries) {
+        var params = new ConstantValueColumnKaiParameters();
+        params.m_columns = entries;
+        return params;
+    }
+
+    private static ConstantColumnEntry entry(final AppendOrReplace mode, final String columnName, final String type,
+        final CustomOrMissingValue customOrMissingValue, final String value) {
+        var e = new ConstantColumnEntry();
+        e.m_appendOrReplace = mode;
+        e.m_columnName = columnName;
+        e.m_type = type;
+        e.m_customOrMissingValue = customOrMissingValue;
+        e.m_value = value;
+        return e;
+    }
+
+    private static CreateDataCellParameters fromStringParameters(final String value)
+        throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException,
+        NoSuchFieldException {
+        var clazz = CreateDataCellExtensionsUtil.getFromStringCreateDataCellParametersClass();
+        var constructor = clazz.getDeclaredConstructor();
+        constructor.setAccessible(true);
+        var params = constructor.newInstance();
+        var field = clazz.getDeclaredField("m_value");
+        field.setAccessible(true);
+        field.set(params, value);
+        return params;
+    }
+}