Package org.projectnessie.jaxrs.tests

Class AbstractRelativeReferences

  • Direct Known Subclasses:
    BaseTestNessieRest.RelativeReferences
    public abstract class AbstractRelativeReferences
extends java.lang.Object
    A set of tests specifically aimed at testing relative references in API v2.

    • Constructor Detail

      • AbstractRelativeReferences

        protected AbstractRelativeReferences​(BaseTestNessieRest outer)

    • Method Detail

      • createReferenceFromBranchUnambiguous

        @Test
public void createReferenceFromBranchUnambiguous()
        Can create a reference from a branch + unambiguous target hash. Expect a 200 response with the created reference.

      • createReferenceFromBranchAmbiguous

        @Test
public void createReferenceFromBranchAmbiguous()
        Cannot create a reference from a branch + ambiguous target hash (writing operation). The hash must contain a starting commit ID. Expect a BAD_REQUEST error.

      • createReferenceFromBranchHead

        @Test
public void createReferenceFromBranchHead()
        Cannot create a reference from a branch + missing target hash. Expect a BAD_REQUEST error.

      • createReferenceFromTagUnambiguous

        @Test
public void createReferenceFromTagUnambiguous()
        Can create a reference from a tag + unambiguous target hash. Expect a 200 response with the created reference.

      • createReferenceFromTagAmbiguous

        @Test
public void createReferenceFromTagAmbiguous()
        Cannot create a reference from a tag + ambiguous target hash (writing operation). The hash must contain a starting commit ID. Expect a BAD_REQUEST error.

      • createReferenceFromTagHead

        @Test
public void createReferenceFromTagHead()
        Cannot create a reference from a tag + missing target hash. Expect a BAD_REQUEST error.

      • createReferenceFromDetachedUnambiguous

        @Test
public void createReferenceFromDetachedUnambiguous()
        Can create a reference from a DETACHED + unambiguous target hash. Expect a 200 response with the created reference.

      • createReferenceFromDetachedAmbiguous

        @Test
public void createReferenceFromDetachedAmbiguous()
        Cannot create a reference from a DETACHED + ambiguous target hash (writing operation). The hash must contain a starting commit ID. Expect a BAD_REQUEST error.

      • assignReferenceFromBranchUnambiguous

        @Test
public void assignReferenceFromBranchUnambiguous()
        Can assign a reference from a branch + unambiguous expected hash, and the hash is the current HEAD of the reference. Expect a 200 response.

      • assignReferenceFromBranchUnambiguousNotAtExpectedHash

        @Test
public void assignReferenceFromBranchUnambiguousNotAtExpectedHash()
        Cannot assign a reference from a branch + unambiguous expected hash, when the hash is not the current head of the reference. Expect a REFERENCE_CONFLICT error.

      • assignReferenceFromBranchUnambiguousExpectedHashUnreachable

        @Test
public void assignReferenceFromBranchUnambiguousExpectedHashUnreachable()
        Cannot assign a reference from a branch + unambiguous expected hash, when the hash is not reachable from the current head of the reference. Expect a REFERENCE_CONFLICT error.

      • assignReferenceFromBranchUnambiguousExpectedHashNonExistent

        @Test
public void assignReferenceFromBranchUnambiguousExpectedHashNonExistent()
        Cannot assign a reference from a branch + unambiguous expected hash, when the hash does not exist. Expect a REFERENCE_NOT_FOUND error.

      • assignReferenceFromBranchAmbiguous

        @Test
public void assignReferenceFromBranchAmbiguous()
        Cannot assign a reference from a branch + ambiguous expected hash (writing operation). The hash must contain a starting commit ID. Expect a BAD_REQUEST error.

      • assignReferenceFromBranchHead

        @Test
public void assignReferenceFromBranchHead()
        Cannot assign a reference from a branch + missing expected hash. Expect a BAD_REQUEST error.

      • assignReferenceFromTagUnambiguous

        @Test
public void assignReferenceFromTagUnambiguous()
        Can assign a reference from a tag + unambiguous expected hash, and the hash is the current HEAD of the reference. Expect a 200 response.

      • assignReferenceFromTagUnambiguousNotAtExpectedHash

        @Test
public void assignReferenceFromTagUnambiguousNotAtExpectedHash()
        Cannot assign a reference from a tag + unambiguous expected hash, when the hash is not the current head of the reference. Expect a REFERENCE_CONFLICT error.

      • assignReferenceFromTagUnambiguousExpectedHashUnreachable

        @Test
public void assignReferenceFromTagUnambiguousExpectedHashUnreachable()
        Cannot assign a reference from a tag + unambiguous expected hash, when the hash is not reachable from the current head of the reference. Expect a REFERENCE_CONFLICT error.

      • assignReferenceFromTagUnambiguousExpectedHashNonExistent

        @Test
public void assignReferenceFromTagUnambiguousExpectedHashNonExistent()
        Cannot assign a reference from a tag + unambiguous expected hash, when the hash does not exist. Expect a REFERENCE_NOT_FOUND error.

      • assignReferenceFromTagAmbiguous

        @Test
public void assignReferenceFromTagAmbiguous()
        Cannot assign a reference from a tag + ambiguous expected hash (writing operation). The hash must contain a starting commit ID. Expect a BAD_REQUEST error.

      • assignReferenceFromTagHead

        @Test
public void assignReferenceFromTagHead()
        Cannot assign a reference from a tag + missing expected hash. Expect a BAD_REQUEST error.

      • assignReferenceFromDetachedUnambiguous

        @Test
public void assignReferenceFromDetachedUnambiguous()
        Cannot assign a reference from a DETACHED ref (assign-from ref must be a branch or a tag). Expect a BAD_REQUEST error.

      • assignReferenceFromDetachedAmbiguous

        @Test
public void assignReferenceFromDetachedAmbiguous()
        Cannot assign a reference from a DETACHED ref (assign-from ref must be a branch or a tag). Expect a BAD_REQUEST error.

      • assignReferenceToBranchUnambiguous

        @Test
public void assignReferenceToBranchUnambiguous()
        Can assign a reference to a branch + unambiguous target hash. Expect a 200 response with the updated reference.

      • assignReferenceToBranchAmbiguous

        @Test
public void assignReferenceToBranchAmbiguous()
        Cannot assign a reference to a branch + ambiguous target hash. Expect a BAD_REQUEST error.

      • assignReferenceToBranchHead

        @Test
public void assignReferenceToBranchHead()
        Cannot assign a reference to a branch + missing target hash. Expect a BAD_REQUEST error.

      • assignReferenceToTagUnambiguous

        @Test
public void assignReferenceToTagUnambiguous()
        Can assign a reference to a tag + unambiguous target hash. Expect a 200 response with the updated reference.

      • assignReferenceToTagAmbiguous

        @Test
public void assignReferenceToTagAmbiguous()
        Cannot assign a reference to a tag + ambiguous target hash (writing operation). Expect a BAD_REQUEST error.

      • assignReferenceToTagHead

        @Test
public void assignReferenceToTagHead()
        Cannot assign a reference to a tag + missing target hash. Expect a BAD_REQUEST error.

      • assignReferenceToDetachedUnambiguous

        @Test
public void assignReferenceToDetachedUnambiguous()
        Can assign a reference to a DETACHED + unambiguous target hash. Expect a 200 response with the updated reference.

      • assignReferenceToDetachedAmbiguous

        @Test
public void assignReferenceToDetachedAmbiguous()
        Cannot assign a reference to a DETACHED + ambiguous target hash (writing operation). The hash must contain a starting commit ID. Expect a BAD_REQUEST error.

      • deleteReferenceUnambiguous

        @Test
public void deleteReferenceUnambiguous()
        Can delete a reference at an unambiguous expected hash, and the hash is the current HEAD of the reference. Expect a 200 response with the deleted reference.

      • deleteReferenceUnambiguousNotAtExpectedHash

        @Test
public void deleteReferenceUnambiguousNotAtExpectedHash()
        Cannot delete a reference at an unambiguous expected hash, when the hash is not the current HEAD of the reference. Expect a REFERENCE_CONFLICT error.

      • deleteReferenceUnambiguousExpectedHashUnreachable

        @Test
public void deleteReferenceUnambiguousExpectedHashUnreachable()
        Cannot delete a reference at an unambiguous expected hash, when the hash is not reachable from the current HEAD of the reference. Expect a REFERENCE_CONFLICT error.

      • deleteReferenceUnambiguousExpectedHashNonExistent

        @Test
public void deleteReferenceUnambiguousExpectedHashNonExistent()
        Cannot delete a reference at an unambiguous expected hash, when the hash does not exist. Expect a REFERENCE_NOT_FOUND error.

      • deleteReferenceAmbiguous

        @Test
public void deleteReferenceAmbiguous()
        Cannot delete a reference at an ambiguous expected hash (writing operation). The hash must contain a starting commit ID. Expect a BAD_REQUEST error.

      • deleteReferenceHead

        @Test
public void deleteReferenceHead()
        Cannot delete a reference without expected hash. Expect a BAD_REQUEST error.

      • commitToBranchHead

        @Test
public void commitToBranchHead()
        Cannot commit to a branch without expected hash. Expect a BAD_REQUEST error.

      • commitToTagUnambiguous

        @Test
public void commitToTagUnambiguous()
        Cannot commit to a tag + unambiguous expected hash (target reference must be a branch), even if the hash is unambiguous.

      • commitToTagAmbiguous

        @Test
public void commitToTagAmbiguous()
        Cannot commit to a tag + ambiguous expected hash (target reference must be a branch).

      • commitToTagHead

        @Test
public void commitToTagHead()
        Cannot commit to a tag without expected hash (target reference must be a branch).

      • commitToDetachedUnambiguous

        @Test
public void commitToDetachedUnambiguous()
        Cannot commit to a DETACHED ref (target reference must be a branch). Expect a BAD_REQUEST error.

      • commitToDetachedAmbiguous

        @Test
public void commitToDetachedAmbiguous()
        Cannot commit to a DETACHED ref (target reference must be a branch). Expect a BAD_REQUEST error.

      • mergeFromBranchHead

        @Test
public void mergeFromBranchHead()
        Cannot merge from a reference without source hash. Expect a BAD_REQUEST error.

      • mergeFromTagUnambiguous

        @Test
public void mergeFromTagUnambiguous()
        Can merge from a tag + unambiguous source hash. Expect a 200 response with the merge result.

      • mergeFromTagAmbiguous

        @Test
public void mergeFromTagAmbiguous()
        Cannot merge from a tag + ambiguous source hash (writing operation). The hash must contain a starting commit ID. Expect a BAD_REQUEST error.

      • mergeFromTagHead

        @Test
public void mergeFromTagHead()
        Cannot merge from a tag without source hash. Expect a BAD_REQUEST error.

      • mergeFromDetachedUnambiguous

        @Test
public void mergeFromDetachedUnambiguous()
        Can merge from a DETACHED ref + unambiguous source hash. Expect a 200 response with the merge result.

      • mergeFromDetachedAmbiguous

        @Test
public void mergeFromDetachedAmbiguous()
        Cannot merge from a DETACHED ref + ambiguous source hash (writing operation). The hash must contain a starting commit ID. Expect a BAD_REQUEST error.

      • mergeToBranchHead

        @Test
public void mergeToBranchHead()
        Cannot merge to a branch without expected hash. Expect a BAD_REQUEST error.

      • mergeToTagUnambiguous

        @Test
public void mergeToTagUnambiguous()
        Cannot merge to a tag (target reference must be a branch), even with unambiguous expected hash. Expect a BAD_REQUEST error.

      • mergeToTagAmbiguous

        @Test
public void mergeToTagAmbiguous()
        Cannot merge to a tag (target reference must be a branch). Expect a BAD_REQUEST error.

      • mergeToTagHead

        @Test
public void mergeToTagHead()
        Cannot merge to a tag without expected hash (target reference must be a branch). Expect a BAD_REQUEST error.

      • mergeToDetachedUnambiguous

        @Test
public void mergeToDetachedUnambiguous()
        Cannot merge to a DETACHED ref (target reference must be a branch), even with unambiguous expected hash. Expect a BAD_REQUEST error.

      • mergeToDetachedAmbiguous

        @Test
public void mergeToDetachedAmbiguous()
        Cannot merge to a DETACHED ref (target reference must be a branch). Expect a BAD_REQUEST error.

      • transplantFromTagUnambiguous

        @Test
public void transplantFromTagUnambiguous()
        Can transplant from a tag + unambiguous source hash. Expect a 200 response with the transplant result.

      • transplantFromTagAmbiguous

        @Test
public void transplantFromTagAmbiguous()
        Cannot transplant from a tag + ambiguous source hash (writing operation). The hash must contain a starting commit ID. Expect a BAD_REQUEST error.

      • transplantFromDetachedUnambiguous

        @Test
public void transplantFromDetachedUnambiguous()
        Can transplant from a DETACHED ref + unambiguous source hash. Expect a 200 response with the transplant result.

      • transplantFromDetachedAmbiguous

        @Test
public void transplantFromDetachedAmbiguous()
        Cannot transplant from a DETACHED ref + ambiguous source hash (writing operation). The hash must contain a starting commit ID. Expect a BAD_REQUEST error.

      • transplantToBranchHead

        @Test
public void transplantToBranchHead()
        Cannot transplant to a branch without expected hash. Expect a BAD_REQUEST error.

      • transplantToTagUnambiguous

        @Test
public void transplantToTagUnambiguous()
        Cannot transplant to a tag (target reference must be a branch), even with unambiguous expected hash. Expect a BAD_REQUEST error.

      • transplantToTagAmbiguous

        @Test
public void transplantToTagAmbiguous()
        Cannot transplant to a tag (target reference must be a branch). Expect a BAD_REQUEST error.

      • transplantToTagHead

        @Test
public void transplantToTagHead()
        Cannot transplant to a tag without expected hash (target reference must be a branch).

      • transplantToDetachedUnambiguous

        @Test
public void transplantToDetachedUnambiguous()
        Cannot transplant to a DETACHED ref (target reference must be a branch), even with unambiguous expected hash. Expect a BAD_REQUEST error.

      • transplantToDetachedAmbiguous

        @Test
public void transplantToDetachedAmbiguous()
        Cannot transplant to a DETACHED ref (target reference must be a branch). Expect a BAD_REQUEST error.