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

Example 16 with Branch

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

the class AbstractRestNamespace method testNamespaceMergeWithConflict.

@Test
public void testNamespaceMergeWithConflict() throws BaseNessieClientServerException {
    Branch base = createBranch("merge-base");
    Branch branch = createBranch("merge-branch");
    Namespace ns = Namespace.parse("a.b.c");
    // create a namespace on the base branch
    getApi().createNamespace().namespace(ns).refName(base.getName()).create();
    base = (Branch) getApi().getReference().refName(base.getName()).get();
    // create a table with the same name on the other branch
    IcebergTable table = IcebergTable.of("merge-table1", 42, 42, 42, 42);
    branch = getApi().commitMultipleOperations().branchName(branch.getName()).hash(branch.getHash()).commitMeta(CommitMeta.fromMessage("test-merge-branch1")).operation(Put.of(ContentKey.of("a", "b", "c"), table)).commit();
    Branch finalBase = base;
    Branch finalBranch = branch;
    assertThatThrownBy(() -> getApi().mergeRefIntoBranch().branch(finalBase).fromRef(finalBranch).merge()).isInstanceOf(NessieReferenceConflictException.class).hasMessage("The following keys have been changed in conflict: 'a.b.c'");
    LogResponse log = getApi().getCommitLog().refName(base.getName()).untilHash(base.getHash()).get();
    // merging should not have been possible ("test-merge-branch1" shouldn't be in the commits)
    assertThat(log.getLogEntries().stream().map(LogEntry::getCommitMeta).map(CommitMeta::getMessage)).containsExactly("create namespace a.b.c");
    List<Entry> entries = getApi().getEntries().refName(base.getName()).get().getEntries();
    assertThat(entries.stream().map(Entry::getName)).containsExactly(ContentKey.of(ns.getElements()));
    assertThat(getApi().getNamespace().refName(base.getName()).namespace(ns).get()).isNotNull();
}

Example 17 with Branch

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

the class AbstractRestNamespace method testNamespacesRetrieval.

@Test
public void testNamespacesRetrieval() throws BaseNessieClientServerException {
    Branch branch = createBranch("namespace");
    Namespace one = Namespace.parse("a.b.c");
    Namespace two = Namespace.parse("a.b.d");
    Namespace three = Namespace.parse("x.y.z");
    Namespace four = Namespace.parse("one.two");
    for (Namespace namespace : Arrays.asList(one, two, three, four)) {
        assertThat(getApi().createNamespace().refName(branch.getName()).namespace(namespace).create()).isNotNull();
    }
    assertThat(getApi().getMultipleNamespaces().refName(branch.getName()).get().getNamespaces()).containsExactlyInAnyOrder(one, two, three, four);
    assertThat(getApi().getMultipleNamespaces().refName(branch.getName()).namespace(Namespace.EMPTY).get().getNamespaces()).containsExactlyInAnyOrder(one, two, three, four);
    assertThat(getApi().getMultipleNamespaces().refName(branch.getName()).namespace("a").get().getNamespaces()).containsExactlyInAnyOrder(one, two);
    assertThat(getApi().getMultipleNamespaces().refName(branch.getName()).namespace("a.b").get().getNamespaces()).containsExactlyInAnyOrder(one, two);
    assertThat(getApi().getMultipleNamespaces().refName(branch.getName()).namespace("a.b.c").get().getNamespaces()).containsExactlyInAnyOrder(one);
    assertThat(getApi().getMultipleNamespaces().refName(branch.getName()).namespace("a.b.d").get().getNamespaces()).containsExactlyInAnyOrder(two);
    assertThat(getApi().getMultipleNamespaces().refName(branch.getName()).namespace("x").get().getNamespaces()).containsExactly(three);
    assertThat(getApi().getMultipleNamespaces().refName(branch.getName()).namespace("z").get().getNamespaces()).isEmpty();
    assertThat(getApi().getMultipleNamespaces().refName(branch.getName()).namespace("on").get().getNamespaces()).containsExactly(four);
}

Example 18 with Branch

use of org.projectnessie.model.Branch 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 19 with Branch

use of org.projectnessie.model.Branch 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 20 with Branch

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

the class AbstractRestCommitLog method commitLogPaging.

@Test
public void commitLogPaging() throws BaseNessieClientServerException {
    Branch branch = createBranch("commitLogPaging");
    int commits = 95;
    int pageSizeHint = 10;
    String currentHash = branch.getHash();
    List<String> allMessages = new ArrayList<>();
    for (int i = 0; i < commits; i++) {
        String msg = "message-for-" + i;
        allMessages.add(msg);
        IcebergTable tableMeta = IcebergTable.of("some-file-" + i, 42, 42, 42, 42);
        String nextHash = getApi().commitMultipleOperations().branchName(branch.getName()).hash(currentHash).commitMeta(CommitMeta.fromMessage(msg)).operation(Put.of(ContentKey.of("table"), tableMeta)).commit().getHash();
        assertNotEquals(currentHash, nextHash);
        currentHash = nextHash;
    }
    Collections.reverse(allMessages);
    verifyPaging(branch.getName(), commits, pageSizeHint, allMessages, null);
    List<CommitMeta> completeLog = StreamingUtil.getCommitLogStream(getApi(), c -> c.refName(branch.getName()).fetch(FetchOption.MINIMAL), OptionalInt.of(pageSizeHint)).map(LogEntry::getCommitMeta).collect(Collectors.toList());
    assertEquals(completeLog.stream().map(CommitMeta::getMessage).collect(Collectors.toList()), allMessages);
}