Rename transport version terminology (elastic#133492) (elastic#133512)

This commit further tweaks terminology for the new file-based transport
version system. Specially it renames:
named -> referable
unreferenced -> unreferable
latest -> upper_bound

Author: rjernst

build-tools-internal/src/integTest/groovy/org/elasticsearch/gradle/internal/transport/AbstractTransportVersionFuncTest.groovy

@@ -33,27 +33,27 @@ class AbstractTransportVersionFuncTest extends AbstractGradleFuncTest {
         }
     }
 
-    def namedTransportVersion(String name, String ids) {
-        javaResource("myserver", "transport/definitions/named/" + name + ".csv", ids)
+    def referableTransportVersion(String name, String ids) {
+        javaResource("myserver", "transport/definitions/referable/" + name + ".csv", ids)
     }
 
-    def unreferencedTransportVersion(String name, String id) {
-        javaResource("myserver", "transport/definitions/unreferenced/" + name + ".csv", id)
+    def unreferableTransportVersion(String name, String id) {
+        javaResource("myserver", "transport/definitions/unreferable/" + name + ".csv", id)
     }
 
-    def namedAndReferencedTransportVersion(String name, String ids) {
-        return namedAndReferencedTransportVersion(name, ids, "Test${name.capitalize()}")
+    def referableAndReferencedTransportVersion(String name, String ids) {
+        return referableAndReferencedTransportVersion(name, ids, "Test${name.capitalize()}")
     }
 
-    def namedAndReferencedTransportVersion(String name, String ids, String classname) {
+    def referableAndReferencedTransportVersion(String name, String ids, String classname) {
         javaSource("myserver", "org.elasticsearch", classname, "", """
             static final TransportVersion usage = TransportVersion.fromName("${name}");
         """)
-        namedTransportVersion(name, ids)
+        referableTransportVersion(name, ids)
     }
 
-    def latestTransportVersion(String branch, String name, String id) {
-        javaResource("myserver", "transport/latest/" + branch + ".csv","${name},${id}")
+    def transportVersionUpperBound(String branch, String name, String id) {
+        javaResource("myserver", "transport/upper_bounds/" + branch + ".csv","${name},${id}")
     }
 
     def validateReferencesFails(String project) {
@@ -87,11 +87,11 @@ class AbstractTransportVersionFuncTest extends AbstractGradleFuncTest {
             apply plugin: 'elasticsearch.transport-version-references'
             apply plugin: 'elasticsearch.transport-version-resources'
         """
-        namedTransportVersion("existing_91", "8012000")
-        namedTransportVersion("existing_92", "8123000,8012001")
-        unreferencedTransportVersion("initial_9_0_0", "8000000")
-        latestTransportVersion("9.2", "existing_92", "8123000")
-        latestTransportVersion("9.1", "existing_92", "8012001")
+        referableTransportVersion("existing_91", "8012000")
+        referableTransportVersion("existing_92", "8123000,8012001")
+        unreferableTransportVersion("initial_9_0_0", "8000000")
+        transportVersionUpperBound("9.2", "existing_92", "8123000")
+        transportVersionUpperBound("9.1", "existing_92", "8012001")
         // a mock version of TransportVersion, just here so we can compile Dummy.java et al
         javaSource("myserver", "org.elasticsearch", "TransportVersion", "", """
             public static TransportVersion fromName(String name) {

build-tools-internal/src/integTest/groovy/org/elasticsearch/gradle/internal/transport/TransportVersionValidationFuncTest.groovy

@@ -38,22 +38,22 @@ class TransportVersionValidationFuncTest extends AbstractTransportVersionFuncTes
 
     def "references must be defined"() {
         given:
-        namedTransportVersion("not_used", "1000000")
+        referableTransportVersion("not_used", "1000000")
         when:
         def result = validateResourcesFails()
         then:
         assertValidateResourcesFailure(result, "Transport version definition file " +
-            "[myserver/src/main/resources/transport/definitions/named/not_used.csv] is not referenced")
+            "[myserver/src/main/resources/transport/definitions/referable/not_used.csv] is not referenced")
     }
 
     def "names must be lowercase alphanum or underscore"() {
         given:
-        namedAndReferencedTransportVersion("${name}", "8100000", "TestNames")
+        referableAndReferencedTransportVersion("${name}", "8100000", "TestNames")
         when:
         def result = validateResourcesFails()
         then:
         assertValidateResourcesFailure(result, "Transport version definition file " +
-            "[myserver/src/main/resources/transport/definitions/named/${name}.csv] does not have a valid name, " +
+            "[myserver/src/main/resources/transport/definitions/referable/${name}.csv] does not have a valid name, " +
             "must be lowercase alphanumeric and underscore")
 
         where:
@@ -62,117 +62,117 @@ class TransportVersionValidationFuncTest extends AbstractTransportVersionFuncTes
 
     def "definitions contain at least one id"() {
         given:
-        namedAndReferencedTransportVersion("empty", "")
+        referableAndReferencedTransportVersion("empty", "")
         when:
         def result = validateResourcesFails()
         then:
         assertValidateResourcesFailure(result, "Transport version definition file " +
-            "[myserver/src/main/resources/transport/definitions/named/empty.csv] does not contain any ids")
+            "[myserver/src/main/resources/transport/definitions/referable/empty.csv] does not contain any ids")
     }
 
     def "definitions have ids in descending order"() {
         given:
-        namedAndReferencedTransportVersion("out_of_order", "8100000,8200000")
+        referableAndReferencedTransportVersion("out_of_order", "8100000,8200000")
         when:
         def result = validateResourcesFails()
         then:
         assertValidateResourcesFailure(result, "Transport version definition file " +
-            "[myserver/src/main/resources/transport/definitions/named/out_of_order.csv] does not have ordered ids")
+            "[myserver/src/main/resources/transport/definitions/referable/out_of_order.csv] does not have ordered ids")
     }
 
     def "definition ids are unique"() {
         given:
-        namedAndReferencedTransportVersion("duplicate", "8123000")
+        referableAndReferencedTransportVersion("duplicate", "8123000")
         when:
         def result = validateResourcesFails()
         then:
         assertValidateResourcesFailure(result, "Transport version definition file " +
-            "[myserver/src/main/resources/transport/definitions/named/existing_92.csv] contains id 8123000 already defined in " +
-            "[myserver/src/main/resources/transport/definitions/named/duplicate.csv]")
+            "[myserver/src/main/resources/transport/definitions/referable/existing_92.csv] contains id 8123000 already defined in " +
+            "[myserver/src/main/resources/transport/definitions/referable/duplicate.csv]")
     }
 
     def "definitions have bwc ids with non-zero patch part"() {
         given:
-        namedAndReferencedTransportVersion("patched", "8200000,8100000")
+        referableAndReferencedTransportVersion("patched", "8200000,8100000")
         when:
         def result = validateResourcesFails()
         then:
         assertValidateResourcesFailure(result, "Transport version definition file " +
-            "[myserver/src/main/resources/transport/definitions/named/patched.csv] contains bwc id [8100000] with a patch part of 0")
+            "[myserver/src/main/resources/transport/definitions/referable/patched.csv] contains bwc id [8100000] with a patch part of 0")
     }
 
     def "definitions have primary ids which cannot change"() {
         given:
-        namedTransportVersion("existing_92", "8500000")
+        referableTransportVersion("existing_92", "8500000")
         when:
         def result = validateResourcesFails()
         then:
         assertValidateResourcesFailure(result, "Transport version definition file " +
-            "[myserver/src/main/resources/transport/definitions/named/existing_92.csv] has modified primary id from 8123000 to 8500000")
+            "[myserver/src/main/resources/transport/definitions/referable/existing_92.csv] has modified primary id from 8123000 to 8500000")
     }
 
     def "cannot change committed ids to a branch"() {
         given:
-        namedTransportVersion("existing_92", "8123000,8012002")
+        referableTransportVersion("existing_92", "8123000,8012002")
         when:
         def result = validateResourcesFails()
         then:
         assertValidateResourcesFailure(result, "Transport version definition file " +
-            "[myserver/src/main/resources/transport/definitions/named/existing_92.csv] modifies existing patch id from 8012001 to 8012002")
+            "[myserver/src/main/resources/transport/definitions/referable/existing_92.csv] modifies existing patch id from 8012001 to 8012002")
     }
 
-    def "latest files must reference defined name"() {
+    def "upper bounds files must reference defined name"() {
         given:
-        latestTransportVersion("9.2", "dne", "8123000")
+        transportVersionUpperBound("9.2", "dne", "8123000")
         when:
         def result = validateResourcesFails()
         then:
-        assertValidateResourcesFailure(result, "Latest transport version file " +
-            "[myserver/src/main/resources/transport/latest/9.2.csv] contains transport version name [dne] which is not defined")
+        assertValidateResourcesFailure(result, "Transport version upper bound file " +
+            "[myserver/src/main/resources/transport/upper_bounds/9.2.csv] contains transport version name [dne] which is not defined")
     }
 
-    def "latest files id must exist in definition"() {
+    def "upper bound files id must exist in definition"() {
         given:
-        latestTransportVersion("9.2", "existing_92", "8124000")
+        transportVersionUpperBound("9.2", "existing_92", "8124000")
         when:
         def result = validateResourcesFails()
         then:
-        assertValidateResourcesFailure(result, "Latest transport version file " +
-            "[myserver/src/main/resources/transport/latest/9.2.csv] has id 8124000 which is not in definition " +
-            "[myserver/src/main/resources/transport/definitions/named/existing_92.csv]")
+        assertValidateResourcesFailure(result, "Transport version upper bound file " +
+            "[myserver/src/main/resources/transport/upper_bounds/9.2.csv] has id 8124000 which is not in definition " +
+            "[myserver/src/main/resources/transport/definitions/referable/existing_92.csv]")
     }
 
-    def "latest files have latest id within base"() {
+    def "upper bound files have latest id within base"() {
         given:
-        latestTransportVersion("9.0", "seemingly_latest", "8110001")
-        namedAndReferencedTransportVersion("original", "8110000")
-        namedAndReferencedTransportVersion("seemingly_latest", "8111000,8110001")
-        namedAndReferencedTransportVersion("actual_latest", "8112000,8110002")
+        transportVersionUpperBound("9.0", "seemingly_latest", "8110001")
+        referableAndReferencedTransportVersion("original", "8110000")
+        referableAndReferencedTransportVersion("seemingly_latest", "8111000,8110001")
+        referableAndReferencedTransportVersion("actual_latest", "8112000,8110002")
         when:
         def result = validateResourcesFails()
         then:
-        assertValidateResourcesFailure(result, "Latest transport version file " +
-            "[myserver/src/main/resources/transport/latest/9.0.csv] has id 8110001 from [seemingly_latest] with base 8110000 " +
+        assertValidateResourcesFailure(result, "Transport version upper bound file " +
+            "[myserver/src/main/resources/transport/upper_bounds/9.0.csv] has id 8110001 from [seemingly_latest] with base 8110000 " +
             "but another id 8110002 from [actual_latest] is later for that base")
     }
 
-    def "latest files cannot change base id"() {
+    def "upper bound files cannot change base id"() {
         given:
-        namedAndReferencedTransportVersion("original", "8013000")
-        namedAndReferencedTransportVersion("patch", "8015000,8013001")
-        latestTransportVersion("9.1", "patch", "8013001")
+        referableAndReferencedTransportVersion("original", "8013000")
+        referableAndReferencedTransportVersion("patch", "8015000,8013001")
+        transportVersionUpperBound("9.1", "patch", "8013001")
         when:
         def result = validateResourcesFails()
         then:
-        assertValidateResourcesFailure(result, "Latest transport version file " +
-            "[myserver/src/main/resources/transport/latest/9.1.csv] modifies base id from 8012000 to 8013000")
+        assertValidateResourcesFailure(result, "Transport version upper bound file " +
+            "[myserver/src/main/resources/transport/upper_bounds/9.1.csv] modifies base id from 8012000 to 8013000")
     }
 
     def "ids must be dense"() {
         given:
-        namedAndReferencedTransportVersion("original", "8013000")
-        namedAndReferencedTransportVersion("patch1", "8015000,8013002")
-        latestTransportVersion("9.0", "patch1", "8013002")
+        referableAndReferencedTransportVersion("original", "8013000")
+        referableAndReferencedTransportVersion("patch1", "8015000,8013002")
+        transportVersionUpperBound("9.0", "patch1", "8013002")
         when:
         def result = validateResourcesFails()
         then:
@@ -181,49 +181,49 @@ class TransportVersionValidationFuncTest extends AbstractTransportVersionFuncTes
 
     def "primary id must not be patch version"() {
         given:
-        namedAndReferencedTransportVersion("patch", "8015001")
+        referableAndReferencedTransportVersion("patch", "8015001")
         when:
         def result = validateResourcesFails()
         then:
         assertValidateResourcesFailure(result, "Transport version definition file " +
-            "[myserver/src/main/resources/transport/definitions/named/patch.csv] has patch version 8015001 as primary id")
+            "[myserver/src/main/resources/transport/definitions/referable/patch.csv] has patch version 8015001 as primary id")
     }
 
-    def "unreferenced directory is optional"() {
+    def "unreferable directory is optional"() {
         given:
-        file("myserver/src/main/resources/transport/unreferenced/initial_9_0_0.csv").delete()
-        file("myserver/src/main/resources/transport/unreferenced").deleteDir()
+        file("myserver/src/main/resources/transport/unreferable/initial_9_0_0.csv").delete()
+        file("myserver/src/main/resources/transport/unreferable").deleteDir()
         when:
         def result = gradleRunner(":myserver:validateTransportVersionResources").build()
         then:
         result.task(":myserver:validateTransportVersionResources").outcome == TaskOutcome.SUCCESS
     }
 
-    def "latest can refer to an unreferenced definition"() {
+    def "upper bound can refer to an unreferable definition"() {
         given:
-        unreferencedTransportVersion("initial_10.0.0", "10000000")
-        latestTransportVersion("10.0", "initial_10.0.0", "10000000")
+        unreferableTransportVersion("initial_10.0.0", "10000000")
+        transportVersionUpperBound("10.0", "initial_10.0.0", "10000000")
         when:
         def result = gradleRunner(":myserver:validateTransportVersionResources").build()
         then:
         result.task(":myserver:validateTransportVersionResources").outcome == TaskOutcome.SUCCESS
     }
 
-    def "named and unreferenced definitions cannot have the same name"() {
+    def "referable and unreferable definitions cannot have the same name"() {
         given:
-        unreferencedTransportVersion("existing_92", "10000000")
+        unreferableTransportVersion("existing_92", "10000000")
         when:
         def result = validateResourcesFails()
         then:
         assertValidateResourcesFailure(result, "Transport version definition file " +
-                "[myserver/src/main/resources/transport/definitions/named/existing_92.csv] " +
-                "has same name as unreferenced definition " +
-                "[myserver/src/main/resources/transport/definitions/unreferenced/existing_92.csv]")
+                "[myserver/src/main/resources/transport/definitions/referable/existing_92.csv] " +
+                "has same name as unreferable definition " +
+                "[myserver/src/main/resources/transport/definitions/unreferable/existing_92.csv]")
     }
 
-    def "unreferenced definitions can have primary ids that are patches"() {
+    def "unreferable definitions can have primary ids that are patches"() {
         given:
-        unreferencedTransportVersion("initial_10.0.1", "10000001")
+        unreferableTransportVersion("initial_10.0.1", "10000001")
         when:
         def result = gradleRunner(":myserver:validateTransportVersionResources").build()
         then: