test: Add test for PythonValueRangeFactory and use correct token name in Sonarcloud action (#64)

Author: Christopher-Chianelli

.github/workflows/sonarcloud.yml

@@ -110,5 +110,5 @@ jobs:
         working-directory: ./timefold-solver-python
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          SONARCLOUD_TOKEN: ${{ secrets.SONARCLOUD_TOKEN }}
+          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
         run: mvn -B -Psonarcloud-analysis validate org.sonarsource.scanner.maven:sonar-maven-plugin:sonar -Dsonar.organization=timefold -Dsonar.projectKey=TimefoldAI_timefold-solver-python -Dsonar.host.url=https://sonarcloud.io -Dsonar.pullrequest.key=${{ github.event.pull_request.number }} -Dsonar.pullrequest.branch=${{ github.event.pull_request.head.ref }} -Dsonar.scm.revision=${{ github.event.pull_request.head.sha }}

pom.xml

@@ -15,11 +15,10 @@
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     <version.apache.collections4>4.4</version.apache.collections4>
     <maven.compiler.release>17</maven.compiler.release>
-    <sonar.moduleKey>${project.artifactId}</sonar.moduleKey>
-    <sonar.organization>timefold</sonar.organization>
+    <sonar.moduleKey>${project.groupId}:${project.artifactId}</sonar.moduleKey>
     <sonar.sources>src/main/java,src/main/python</sonar.sources>
     <sonar.tests>src/test/java,tests</sonar.tests>
-    <sonar.python.version>3.9,3.10,3.11</sonar.python.version>
+    <sonar.python.version>3.10,3.11,3.12</sonar.python.version>
     <sonar.python.coverage.reportPaths>target/coverage.xml,jpyinterpreter/target/coverage.xml</sonar.python.coverage.reportPaths>
   </properties>
 

timefold-solver-python-core/src/test/java/ai/timefold/solver/python/PythonValueRangeFactoryTest.java

@@ -0,0 +1,87 @@
+package ai.timefold.solver.python;
+
+import static org.assertj.core.api.Assertions.as;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+
+import ai.timefold.jpyinterpreter.types.numeric.PythonBoolean;
+import ai.timefold.jpyinterpreter.types.numeric.PythonFloat;
+import ai.timefold.jpyinterpreter.types.numeric.PythonInteger;
+import ai.timefold.solver.core.api.domain.valuerange.CountableValueRange;
+
+import org.assertj.core.api.InstanceOfAssertFactories;
+import org.junit.jupiter.api.Test;
+
+class PythonValueRangeFactoryTest {
+
+    @Test
+    void createIntValueRange() {
+        assertThat(PythonValueRangeFactory.createIntValueRange(BigInteger.valueOf(10), BigInteger.valueOf(15)))
+                .extracting(CountableValueRange::createOriginalIterator,
+                        as(InstanceOfAssertFactories.iterator(PythonInteger.class)))
+                .toIterable()
+                .containsExactly(
+                        PythonInteger.valueOf(10),
+                        PythonInteger.valueOf(11),
+                        PythonInteger.valueOf(12),
+                        PythonInteger.valueOf(13),
+                        PythonInteger.valueOf(14));
+    }
+
+    @Test
+    void createIntValueRangeWithStep() {
+        assertThat(PythonValueRangeFactory.createIntValueRange(BigInteger.valueOf(10), BigInteger.valueOf(20),
+                BigInteger.valueOf(2)))
+                .extracting(CountableValueRange::createOriginalIterator,
+                        as(InstanceOfAssertFactories.iterator(PythonInteger.class)))
+                .toIterable()
+                .containsExactly(
+                        PythonInteger.valueOf(10),
+                        PythonInteger.valueOf(12),
+                        PythonInteger.valueOf(14),
+                        PythonInteger.valueOf(16),
+                        PythonInteger.valueOf(18));
+    }
+
+    @Test
+    void createFloatValueRange() {
+        assertThat(PythonValueRangeFactory.createFloatValueRange(BigDecimal.valueOf(10), BigDecimal.valueOf(15)))
+                .extracting(CountableValueRange::createOriginalIterator,
+                        as(InstanceOfAssertFactories.iterator(PythonFloat.class)))
+                .toIterable()
+                .containsExactly(
+                        PythonFloat.valueOf(10),
+                        PythonFloat.valueOf(11),
+                        PythonFloat.valueOf(12),
+                        PythonFloat.valueOf(13),
+                        PythonFloat.valueOf(14));
+    }
+
+    @Test
+    void createFloatValueRangeWithStep() {
+        assertThat(PythonValueRangeFactory.createFloatValueRange(BigDecimal.valueOf(10), BigDecimal.valueOf(20),
+                BigDecimal.valueOf(2)))
+                .extracting(CountableValueRange::createOriginalIterator,
+                        as(InstanceOfAssertFactories.iterator(PythonFloat.class)))
+                .toIterable()
+                .containsExactly(
+                        PythonFloat.valueOf(10),
+                        PythonFloat.valueOf(12),
+                        PythonFloat.valueOf(14),
+                        PythonFloat.valueOf(16),
+                        PythonFloat.valueOf(18));
+    }
+
+    @Test
+    void createBooleanValueRange() {
+        assertThat(PythonValueRangeFactory.createBooleanValueRange())
+                .extracting(CountableValueRange::createOriginalIterator,
+                        as(InstanceOfAssertFactories.iterator(PythonBoolean.class)))
+                .toIterable()
+                .containsExactly(
+                        PythonBoolean.FALSE,
+                        PythonBoolean.TRUE);
+    }
+}