Examples with Reference org.projectnessie.model.Reference used on opensource projects

Example 6 with Reference

use of org.projectnessie.model.Reference in project nessie by projectnessie.

the class AbstractSparkSqlTest method testAssignTagTo.

@Test
void testAssignTagTo() throws NessieConflictException, NessieNotFoundException {
    String random = "randomTag";
    assertThat(sql("CREATE TAG %s IN nessie", random)).containsExactly(row("Tag", random, hash));
    List<Object[]> commits = commitAndReturnLog(refName);
    sql("USE REFERENCE %s IN nessie", refName);
    sql("MERGE BRANCH %s INTO main IN nessie", refName);
    Reference main = api.getReference().refName("main").get();
    assertThat(sql("ASSIGN TAG %s TO main IN nessie", random)).containsExactly(row("Tag", random, main.getHash()));
    commits = fetchLog("main");
    for (Object[] commit : commits) {
        String currentHash = (String) commit[2];
        assertThat(sql("ASSIGN TAG %s TO main AT %s IN nessie", random, currentHash)).containsExactly(row("Tag", random, currentHash));
    }
    String invalidHash = "abc";
    String unknownHash = "dd8d46a3dd5478ce69749a5455dba29d74f6d1171188f4c21d0e15ff4a0a9a9c";
    String invalidTag = "invalidTag";
    assertThatThrownBy(() -> sql("ASSIGN TAG %s TO main AT %s IN nessie", random, invalidHash)).isInstanceOf(IllegalArgumentException.class).hasMessage(Validation.HASH_MESSAGE + " - but was: " + invalidHash);
    assertThatThrownBy(() -> sql("ASSIGN TAG %s TO main AT %s IN nessie", random, unknownHash)).isInstanceOf(NessieNotFoundException.class).hasMessage(String.format("Could not find commit '%s' in reference '%s'.", unknownHash, "main"));
    assertThatThrownBy(() -> sql("ASSIGN TAG %s TO %s AT %s IN nessie", random, invalidTag, hash)).isInstanceOf(NessieNotFoundException.class).hasMessage(String.format("Named reference '%s' not found", invalidTag));
}

Example 7 with Reference

use of org.projectnessie.model.Reference in project nessie by projectnessie.

the class ReadReferences method execute.

@Override
public void execute() {
    try (NessieApiV1 api = createNessieApiInstance()) {
        spec.commandLine().getOut().printf("Reading all references\n\n");
        List<Reference> references = api.getAllReferences().get().getReferences();
        references.forEach(reference -> spec.commandLine().getOut().printf(reference + "\n"));
        spec.commandLine().getOut().printf("\nDone reading all references\n\n");
    }
}

Example 8 with Reference

use of org.projectnessie.model.Reference in project nessie by projectnessie.

the class AbstractRestRefLog method testReflog.

@Test
public void testReflog() throws BaseNessieClientServerException {
    String tagName = "tag1_test_reflog";
    String branch1 = "branch1_test_reflog";
    String branch2 = "branch2_test_reflog";
    String branch3 = "branch3_test_reflog";
    String root = "ref_name_test_reflog";
    List<Tuple> expectedEntries = new ArrayList<>(12);
    // reflog 1: creating the default branch0
    Branch branch0 = createBranch(root);
    expectedEntries.add(Tuple.tuple(root, "CREATE_REFERENCE"));
    // reflog 2: create tag1
    Reference createdTag = getApi().createReference().sourceRefName(branch0.getName()).reference(Tag.of(tagName, branch0.getHash())).create();
    expectedEntries.add(Tuple.tuple(tagName, "CREATE_REFERENCE"));
    // reflog 3: create branch1
    Reference createdBranch1 = getApi().createReference().sourceRefName(branch0.getName()).reference(Branch.of(branch1, branch0.getHash())).create();
    expectedEntries.add(Tuple.tuple(branch1, "CREATE_REFERENCE"));
    // reflog 4: create branch2
    Reference createdBranch2 = getApi().createReference().sourceRefName(branch0.getName()).reference(Branch.of(branch2, branch0.getHash())).create();
    expectedEntries.add(Tuple.tuple(branch2, "CREATE_REFERENCE"));
    // reflog 5: create branch2
    Branch createdBranch3 = (Branch) getApi().createReference().sourceRefName(branch0.getName()).reference(Branch.of(branch3, branch0.getHash())).create();
    expectedEntries.add(Tuple.tuple(branch3, "CREATE_REFERENCE"));
    // reflog 6: commit on default branch0
    IcebergTable meta = IcebergTable.of("meep", 42, 42, 42, 42);
    branch0 = getApi().commitMultipleOperations().branchName(branch0.getName()).hash(branch0.getHash()).commitMeta(CommitMeta.builder().message("dummy commit log").properties(ImmutableMap.of("prop1", "val1", "prop2", "val2")).build()).operation(Operation.Put.of(ContentKey.of("meep"), meta)).commit();
    expectedEntries.add(Tuple.tuple(root, "COMMIT"));
    // reflog 7: assign tag
    getApi().assignTag().tagName(tagName).hash(createdTag.getHash()).assignTo(branch0).assign();
    expectedEntries.add(Tuple.tuple(tagName, "ASSIGN_REFERENCE"));
    // reflog 8: assign ref
    getApi().assignBranch().branchName(branch1).hash(createdBranch1.getHash()).assignTo(branch0).assign();
    expectedEntries.add(Tuple.tuple(branch1, "ASSIGN_REFERENCE"));
    // reflog 9: merge
    getApi().mergeRefIntoBranch().branchName(branch2).hash(createdBranch2.getHash()).fromRefName(branch1).fromHash(branch0.getHash()).merge();
    expectedEntries.add(Tuple.tuple(branch2, "MERGE"));
    // reflog 10: transplant
    getApi().transplantCommitsIntoBranch().hashesToTransplant(ImmutableList.of(Objects.requireNonNull(branch0.getHash()))).fromRefName(branch1).branch(createdBranch3).transplant();
    expectedEntries.add(Tuple.tuple(branch3, "TRANSPLANT"));
    // reflog 11: delete branch
    getApi().deleteBranch().branchName(branch1).hash(branch0.getHash()).delete();
    expectedEntries.add(Tuple.tuple(branch1, "DELETE_REFERENCE"));
    // reflog 12: delete tag
    getApi().deleteTag().tagName(tagName).hash(branch0.getHash()).delete();
    expectedEntries.add(Tuple.tuple(tagName, "DELETE_REFERENCE"));
    // In the reflog output new entry will be the head. Hence, reverse the expected list
    Collections.reverse(expectedEntries);
    RefLogResponse refLogResponse = getApi().getRefLog().get();
    // verify reflog entries
    assertThat(refLogResponse.getLogEntries().subList(0, 12)).extracting(RefLogResponse.RefLogResponseEntry::getRefName, RefLogResponse.RefLogResponseEntry::getOperation).isEqualTo(expectedEntries);
    // verify pagination (limit and token)
    RefLogResponse refLogResponse1 = getApi().getRefLog().maxRecords(2).get();
    assertThat(refLogResponse1.getLogEntries()).isEqualTo(refLogResponse.getLogEntries().subList(0, 2));
    assertThat(refLogResponse1.isHasMore()).isTrue();
    RefLogResponse refLogResponse2 = getApi().getRefLog().pageToken(refLogResponse1.getToken()).get();
    // should start from the token.
    assertThat(refLogResponse2.getLogEntries().get(0).getRefLogId()).isEqualTo(refLogResponse1.getToken());
    assertThat(refLogResponse2.getLogEntries().subList(0, 10)).isEqualTo(refLogResponse.getLogEntries().subList(2, 12));
    // verify startHash and endHash
    RefLogResponse refLogResponse3 = getApi().getRefLog().fromHash(refLogResponse.getLogEntries().get(10).getRefLogId()).get();
    assertThat(refLogResponse3.getLogEntries().subList(0, 2)).isEqualTo(refLogResponse.getLogEntries().subList(10, 12));
    RefLogResponse refLogResponse4 = getApi().getRefLog().fromHash(refLogResponse.getLogEntries().get(3).getRefLogId()).untilHash(refLogResponse.getLogEntries().get(5).getRefLogId()).get();
    assertThat(refLogResponse4.getLogEntries()).isEqualTo(refLogResponse.getLogEntries().subList(3, 6));
    // use invalid reflog id f1234d75178d892a133a410355a5a990cf75d2f33eba25d575943d4df632f3a4
    // computed using Hash.of(
    // UnsafeByteOperations.unsafeWrap(newHasher().putString("invalid",
    // StandardCharsets.UTF_8).hash().asBytes()));
    assertThatThrownBy(() -> getApi().getRefLog().fromHash("f1234d75178d892a133a410355a5a990cf75d2f33eba25d575943d4df632f3a4").get()).isInstanceOf(NessieRefLogNotFoundException.class).hasMessageContaining("RefLog entry for 'f1234d75178d892a133a410355a5a990cf75d2f33eba25d575943d4df632f3a4' does not exist");
    // verify source hashes for assign reference
    assertThat(refLogResponse.getLogEntries().get(4).getSourceHashes()).isEqualTo(Collections.singletonList(createdBranch1.getHash()));
    // verify source hashes for merge
    assertThat(refLogResponse.getLogEntries().get(3).getSourceHashes()).isEqualTo(Collections.singletonList(branch0.getHash()));
    // verify source hashes for transplant
    assertThat(refLogResponse.getLogEntries().get(2).getSourceHashes()).isEqualTo(Collections.singletonList(branch0.getHash()));
    // test filter with stream
    List<RefLogResponse.RefLogResponseEntry> filteredResult = StreamingUtil.getReflogStream(getApi(), builder -> builder.filter("reflog.operation == 'ASSIGN_REFERENCE' " + "&& reflog.refName == 'tag1_test_reflog'"), OptionalInt.empty()).collect(Collectors.toList());
    assertThat(filteredResult.size()).isEqualTo(1);
    assertThat(filteredResult.get(0)).extracting(RefLogResponse.RefLogResponseEntry::getRefName, RefLogResponse.RefLogResponseEntry::getOperation).isEqualTo(expectedEntries.get(5).toList());
}

Example 9 with Reference

use of org.projectnessie.model.Reference in project nessie by projectnessie.

the class AbstractRestReferences method filterReferences.

@Test
public void filterReferences() throws BaseNessieClientServerException {
    Branch b1 = getApi().commitMultipleOperations().branch(createBranch("refs.branch.1")).commitMeta(CommitMeta.fromMessage("some awkward message")).operation(Put.of(ContentKey.of("hello.world.BaseTable"), IcebergView.of("path1", 1, 1, "Spark", "SELECT ALL THE THINGS"))).commit();
    Branch b2 = getApi().commitMultipleOperations().branch(createBranch("other-development")).commitMeta(CommitMeta.fromMessage("invent awesome things")).operation(Put.of(ContentKey.of("cool.stuff.Caresian"), IcebergView.of("path2", 1, 1, "Spark", "CARTESIAN JOINS ARE AWESOME"))).commit();
    Branch b3 = getApi().commitMultipleOperations().branch(createBranch("archive")).commitMeta(CommitMeta.fromMessage("boring old stuff")).operation(Put.of(ContentKey.of("super.old.Numbers"), IcebergView.of("path3", 1, 1, "Spark", "AGGREGATE EVERYTHING"))).commit();
    Tag t1 = (Tag) getApi().createReference().reference(Tag.of("my-tag", b2.getHash())).sourceRefName(b2.getName()).create();
    assertThat(getApi().getAllReferences().filter("ref.name == 'other-development'").get().getReferences()).hasSize(1).allSatisfy(ref -> assertThat(ref).isInstanceOf(Branch.class).extracting(Reference::getName, Reference::getHash).containsExactly(b2.getName(), b2.getHash()));
    assertThat(getApi().getAllReferences().filter("refType == 'TAG'").get().getReferences()).allSatisfy(ref -> assertThat(ref).isInstanceOf(Tag.class));
    assertThat(getApi().getAllReferences().filter("refType == 'BRANCH'").get().getReferences()).allSatisfy(ref -> assertThat(ref).isInstanceOf(Branch.class));
    assertThat(getApi().getAllReferences().filter("has(refMeta.numTotalCommits) && refMeta.numTotalCommits < 0").get().getReferences()).isEmpty();
    assertThat(getApi().getAllReferences().fetch(FetchOption.ALL).filter("commit.message == 'invent awesome things'").get().getReferences()).hasSize(2).allSatisfy(ref -> assertThat(ref.getName()).isIn(b2.getName(), t1.getName()));
    assertThat(getApi().getAllReferences().fetch(FetchOption.ALL).filter("refType == 'TAG' && commit.message == 'invent awesome things'").get().getReferences()).hasSize(1).allSatisfy(ref -> assertThat(ref.getName()).isEqualTo(t1.getName()));
}

Example 10 with Reference

use of org.projectnessie.model.Reference in project nessie by projectnessie.

the class AbstractRestReferences method testSingleReferenceHasMetadataProperties.

@Test
public void testSingleReferenceHasMetadataProperties() throws BaseNessieClientServerException {
    String branchName = "singleBranchHasMetadataProperties";
    String tagName = "singleTagHasMetadataProperties";
    int numCommits = 10;
    Reference r = getApi().createReference().reference(Branch.of(branchName, null)).create();
    String currentHash = r.getHash();
    currentHash = createCommits(r, 1, numCommits, currentHash);
    getApi().createReference().reference(Tag.of(tagName, currentHash)).sourceRefName(r.getName()).create();
    // not fetching additional metadata for a single branch
    Reference ref = getApi().getReference().refName(branchName).get();
    assertThat(ref).isNotNull().isInstanceOf(Branch.class);
    assertThat(ref).isNotNull().isInstanceOf(Branch.class).extracting("metadata").isNull();
    // not fetching additional metadata for a single tag
    ref = getApi().getReference().refName(tagName).get();
    assertThat(ref).isNotNull().isInstanceOf(Tag.class).extracting("metadata").isNull();
    // fetching additional metadata for a single branch
    ref = getApi().getReference().refName(branchName).fetch(FetchOption.ALL).get();
    assertThat(ref).isNotNull().isInstanceOf(Branch.class);
    verifyMetadataProperties(numCommits, 0, (Branch) ref, getApi().getReference().refName("main").get(), numCommits);
    // fetching additional metadata for a single tag
    ref = getApi().getReference().refName(tagName).fetch(FetchOption.ALL).get();
    assertThat(ref).isNotNull().isInstanceOf(Tag.class);
    verifyMetadataProperties((Tag) ref);
}