adding new non-exception-based arn parsing logic

RanVaknin · RanVaknin · commit 8ae1dad50d72 · 2025-06-06T10:48:25.000-07:00
diff --git a/core/arns/src/main/java/software/amazon/awssdk/arns/Arn.java b/core/arns/src/main/java/software/amazon/awssdk/arns/Arn.java
@@ -138,6 +138,71 @@ public static Builder builder() {
         return new DefaultBuilder();
     }
 
+    /**
+     * Attempts to parse the given string into an {@link Arn}. If the input string is not a valid ARN,
+     * this method returns {@link Optional#empty()} instead of throwing an exception.
+     * <p>
+     * Returns an empty Optional if the input string is not a valid ARN.
+     * When successful, the resource is accessible entirely as a string through
+     * {@link #resourceAsString()}. Where correctly formatted, a parsed resource
+     * containing resource type, resource and qualifier is available through
+     * {@link #resource()}.
+     *
+     * @param arn A string containing an ARN to parse.
+     * @return An {@link Optional} containing the parsed {@link Arn} if valid, or empty if invalid.
+     */
+    public static Optional<Arn> tryFromString(String arn) {
+        if (arn == null) {
+            return Optional.empty();
+        }
+
+        int arnColonIndex = arn.indexOf(':');
+        if (arnColonIndex < 0 || !"arn".equals(arn.substring(0, arnColonIndex))) {
+            return Optional.empty();
+        }
+
+        int partitionColonIndex = arn.indexOf(':', arnColonIndex + 1);
+        if (partitionColonIndex < 0) {
+            return Optional.empty();
+        }
+
+        String partition = arn.substring(arnColonIndex + 1, partitionColonIndex);
+
+        int serviceColonIndex = arn.indexOf(':', partitionColonIndex + 1);
+        if (serviceColonIndex < 0) {
+            return Optional.empty();
+        }
+        String service = arn.substring(partitionColonIndex + 1, serviceColonIndex);
+
+        int regionColonIndex = arn.indexOf(':', serviceColonIndex + 1);
+        if (regionColonIndex < 0) {
+            return Optional.empty();
+        }
+        String region = arn.substring(serviceColonIndex + 1, regionColonIndex);
+
+        int accountColonIndex = arn.indexOf(':', regionColonIndex + 1);
+        if (accountColonIndex < 0) {
+            return Optional.empty();
+        }
+        String accountId = arn.substring(regionColonIndex + 1, accountColonIndex);
+
+        String resource = arn.substring(accountColonIndex + 1);
+        if (resource.isEmpty()) {
+            return Optional.empty();
+        }
+
+
+        Arn resultArn = builder()
+                  .partition(partition)
+                  .service(service)
+                  .region(region)
+                  .accountId(accountId)
+                  .resource(resource)
+                  .build();
+
+        return Optional.of(resultArn);
+    }
+
     /**
      * Parses a given string into an {@link Arn}. The resource is accessible entirely as a
      * string through {@link #resourceAsString()}. Where correctly formatted, a parsed
diff --git a/core/arns/src/test/java/software/amazon/awssdk/arns/ArnTest.java b/core/arns/src/test/java/software/amazon/awssdk/arns/ArnTest.java
@@ -17,8 +17,14 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
+import java.util.Optional;
+import java.util.stream.Stream;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 
 public class ArnTest {
 
@@ -311,4 +317,108 @@ public void invalidArnWithoutAccountId_ThrowsIllegalArgumentException() {
         String arnString = "arn:aws:s3:us-east-1:";
         assertThatThrownBy(() -> Arn.fromString(arnString)).hasMessageContaining("Malformed ARN");
     }
+
+    private static Stream<Arguments> validArnTestCases() {
+        return Stream.of(
+            // Test case name, ARN string
+            Arguments.of("Basic Resource", "arn:aws:s3:us-east-1:12345678910:myresource"),
+            Arguments.of("Minimal Requirements", "arn:aws:foobar:::myresource"),
+            Arguments.of("Qualified Resource", "arn:aws:s3:us-east-1:12345678910:myresource:foobar:1"),
+            Arguments.of("Minimal Resources", "arn:aws:s3:::bucket"),
+            Arguments.of("Without Region", "arn:aws:iam::123456789012:root"),
+            Arguments.of("Resource Type And Resource", "arn:aws:s3:us-east-1:12345678910:bucket:foobar"),
+            Arguments.of("Resource Type And Resource And Qualifier", "arn:aws:s3:us-east-1:12345678910:bucket:foobar:1"),
+            Arguments.of("Resource Type And Resource With Slash", "arn:aws:s3:us-east-1:12345678910:bucket/foobar"),
+            Arguments.of("Resource Type And Resource And Qualifier With Slash", "arn:aws:s3:us-east-1:12345678910:bucket/foobar/1"),
+            Arguments.of("Without Region", "arn:aws:s3::123456789012:myresource"),
+            Arguments.of("Without AccountId", "arn:aws:s3:us-east-1::myresource"),
+            Arguments.of("Resource Containing Dots", "arn:aws:s3:us-east-1:12345678910:myresource:foobar.1")
+        );
+    }
+
+    private static Stream<Arguments> invalidArnTestCases() {
+        return Stream.of(
+            // Test case name, ARN string
+            Arguments.of("Without Partition", "arn::s3:us-east-1:12345678910:myresource"),
+            Arguments.of("Without Service", "arn:aws::us-east-1:12345678910:myresource"),
+            Arguments.of("Without Resource", "arn:aws:s3:us-east-1:12345678910:"),
+            Arguments.of("Invalid ARN", "arn:aws:"),
+            Arguments.of("Doesn't Start With ARN", "fakearn:aws:"),
+            Arguments.of("Invalid Without Partition", "arn:"),
+            Arguments.of("Invalid Without Service", "arn:aws:"),
+            Arguments.of("Invalid Without Region", "arn:aws:s3:"),
+            Arguments.of("Invalid Without AccountId", "arn:aws:s3:us-east-1:")
+        );
+    }
+
+    private static Stream<Arguments> exceptionThrowingArnTestCases() {
+        return Stream.of(
+            Arguments.of("Without Partition", "arn::s3:us-east-1:12345678910:myresource"),
+            Arguments.of("Without Service", "arn:aws::us-east-1:12345678910:myresource")
+        );
+    }
+
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("validArnTestCases")
+    public void optionalArnFromString_ValidArns_ReturnsPopulatedOptional(String testName, String arnString) {
+        Optional<Arn> optionalArn = Arn.tryFromString(arnString);
+
+        assertThat(optionalArn).isPresent();
+
+        // Compare with the original fromString implementation
+        Arn expectedArn = Arn.fromString(arnString);
+        Arn actualArn = optionalArn.get();
+
+        assertThat(actualArn.partition()).isEqualTo(expectedArn.partition());
+        assertThat(actualArn.service()).isEqualTo(expectedArn.service());
+        assertThat(actualArn.region()).isEqualTo(expectedArn.region());
+        assertThat(actualArn.accountId()).isEqualTo(expectedArn.accountId());
+        assertThat(actualArn.resourceAsString()).isEqualTo(expectedArn.resourceAsString());
+
+        // Verify the ARN string representation matches
+        assertThat(actualArn.toString()).isEqualTo(arnString);
+    }
+
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("invalidArnTestCases")
+    public void optionalArnFromString_InvalidArns_ReturnsEmptyOptional(String testName, String arnString) {
+        Optional<Arn> optionalArn = Arn.tryFromString(arnString);
+        assertThat(optionalArn).isEmpty();
+    }
+
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("exceptionThrowingArnTestCases")
+    public void tryFromString_InvalidArns_ShouldThrowExceptions(String testName, String arnString) {
+        assertThrows(IllegalArgumentException.class, () -> {
+            Arn.tryFromString(arnString);
+        });
+    }
+
+    @Test
+    public void optionalArnFromString_NullInput_ReturnsEmptyOptional() {
+        Optional<Arn> optionalArn = Arn.tryFromString(null);
+        assertThat(optionalArn).isEmpty();
+    }
+
+    @ParameterizedTest(name = "Resource parsing: {0}")
+    @MethodSource("validArnTestCases")
+    public void tryFromString_ResourceParsing_MatchesOriginalImplementation(String testName, String arnString) {
+        // Skip test cases that would throw exceptions in the resource parsing
+        if (arnString.contains("bucket:") || arnString.contains("bucket/")) {
+            Optional<Arn> optionalArn = Arn.tryFromString(arnString);
+            assertThat(optionalArn).isPresent();
+
+            Arn expectedArn = Arn.fromString(arnString);
+            Arn actualArn = optionalArn.get();
+
+            // Verify resource parsing
+            ArnResource expectedResource = expectedArn.resource();
+            ArnResource actualResource = actualArn.resource();
+
+            assertThat(actualResource.resourceType()).isEqualTo(expectedResource.resourceType());
+            assertThat(actualResource.resource()).isEqualTo(expectedResource.resource());
+            assertThat(actualResource.qualifier()).isEqualTo(expectedResource.qualifier());
+        }
+    }
+
 }
