Examples with Key org.projectnessie.versioned.Key used on opensource projects

Example 16 with Key

use of org.projectnessie.versioned.Key in project nessie by projectnessie.

the class AbstractCommits method commitNonConflictingOperations.

/*
   * Test:
   * - Create a new branch
   * - Add a commit for 3 keys
   * - Add a commit based on initial commit for first key
   * - Add a commit based on initial commit for second key
   * - Add a commit based on initial commit for third  key
   * - Check commit metadata
   * - Check keys for each commit hash
   * - Check values for each commit hash
   */
@Test
public void commitNonConflictingOperations() throws Exception {
    final BranchName branch = BranchName.of("foo");
    store().create(branch, Optional.empty());
    final Hash initialCommit = commit("Initial Commit").put("t1", V_1_1).put("t2", V_2_1).put("t3", V_3_1).toBranch(branch);
    final Hash t1Commit = commit("T1 Commit").fromReference(initialCommit).put("t1", V_1_2).toBranch(branch);
    final Hash t2Commit = commit("T2 Commit").fromReference(initialCommit).delete("t2").toBranch(branch);
    final Hash t3Commit = commit("T3 Commit").fromReference(initialCommit).unchanged("t3").toBranch(branch);
    final Hash extraCommit = commit("Extra Commit").fromReference(t1Commit).put("t1", V_1_3).put("t3", V_3_2).toBranch(branch);
    final Hash newT2Commit = commit("New T2 Commit").fromReference(t2Commit).put("t2", NEW_v2_1).toBranch(branch);
    assertThat(commitsList(branch, false)).contains(commit(newT2Commit, "New T2 Commit"), commit(extraCommit, "Extra Commit"), commit(t3Commit, "T3 Commit"), commit(t2Commit, "T2 Commit"), commit(t1Commit, "T1 Commit"), commit(initialCommit, "Initial Commit"));
    try (Stream<Key> keys = store().getKeys(branch).map(WithType::getValue)) {
        assertThat(keys).containsExactlyInAnyOrder(Key.of("t1"), Key.of("t2"), Key.of("t3"));
    }
    assertThat(store().getValues(branch, Arrays.asList(Key.of("t1"), Key.of("t2"), Key.of("t3")))).containsExactlyInAnyOrderEntriesOf(ImmutableMap.of(Key.of("t1"), V_1_3, Key.of("t2"), NEW_v2_1, Key.of("t3"), V_3_2));
    assertThat(store().getValues(newT2Commit, Arrays.asList(Key.of("t1"), Key.of("t2"), Key.of("t3")))).containsExactlyInAnyOrderEntriesOf(ImmutableMap.of(Key.of("t1"), V_1_3, Key.of("t2"), NEW_v2_1, Key.of("t3"), V_3_2));
    assertThat(store().getValues(extraCommit, Arrays.asList(Key.of("t1"), Key.of("t2"), Key.of("t3")))).containsExactlyInAnyOrderEntriesOf(ImmutableMap.of(Key.of("t1"), V_1_3, Key.of("t3"), V_3_2));
    assertThat(store().getValues(t3Commit, Arrays.asList(Key.of("t1"), Key.of("t2"), Key.of("t3")))).containsExactlyInAnyOrderEntriesOf(ImmutableMap.of(Key.of("t1"), V_1_2, Key.of("t3"), V_3_1));
    assertThat(store().getValues(t2Commit, Arrays.asList(Key.of("t1"), Key.of("t2"), Key.of("t3")))).containsExactlyInAnyOrderEntriesOf(ImmutableMap.of(Key.of("t1"), V_1_2, Key.of("t3"), V_3_1));
    assertThat(store().getValues(t1Commit, Arrays.asList(Key.of("t1"), Key.of("t2"), Key.of("t3")))).containsExactlyInAnyOrderEntriesOf(ImmutableMap.of(Key.of("t1"), V_1_2, Key.of("t2"), V_2_1, Key.of("t3"), V_3_1));
}

Example 17 with Key

use of org.projectnessie.versioned.Key in project nessie by projectnessie.

the class AbstractCommits method commitSomeOperations.

/*
   * Test:
   * - Create a new branch
   * - Add 3 commits in succession with no conflicts to it with put and delete operations
   * - Check commit metadata
   * - Check keys for each commit hash
   * - Check values for each commit hash
   */
@Test
public void commitSomeOperations() throws Exception {
    final BranchName branch = BranchName.of("foo");
    store().create(branch, Optional.empty());
    final Hash initialCommit = commit("Initial Commit").put("t1", V_1_1).put("t2", V_2_1).put("t3", V_3_1).toBranch(branch);
    final Hash secondCommit = commit("Second Commit").put("t1", V_1_2).delete("t2").delete("t3").put("t4", V_4_1).toBranch(branch);
    final Hash thirdCommit = commit("Third Commit").put("t2", V_2_2).unchanged("t4").toBranch(branch);
    assertThat(commitsList(branch, false)).contains(commit(thirdCommit, "Third Commit"), commit(secondCommit, "Second Commit"), commit(initialCommit, "Initial Commit"));
    try (Stream<Key> keys = store().getKeys(branch).map(WithType::getValue)) {
        assertThat(keys).containsExactlyInAnyOrder(Key.of("t1"), Key.of("t2"), Key.of("t4"));
    }
    try (Stream<Key> keys = store().getKeys(secondCommit).map(WithType::getValue)) {
        assertThat(keys).containsExactlyInAnyOrder(Key.of("t1"), Key.of("t4"));
    }
    try (Stream<Key> keys = store().getKeys(initialCommit).map(WithType::getValue)) {
        assertThat(keys).containsExactlyInAnyOrder(Key.of("t1"), Key.of("t2"), Key.of("t3"));
    }
    assertThat(store().getValues(secondCommit, Arrays.asList(Key.of("t1"), Key.of("t2"), Key.of("t3"), Key.of("t4")))).containsExactlyInAnyOrderEntriesOf(ImmutableMap.of(Key.of("t1"), V_1_2, Key.of("t4"), V_4_1));
    assertThat(store().getValues(initialCommit, Arrays.asList(Key.of("t1"), Key.of("t2"), Key.of("t3"), Key.of("t4")))).containsExactlyInAnyOrderEntriesOf(ImmutableMap.of(Key.of("t1"), V_1_1, Key.of("t2"), V_2_1, Key.of("t3"), V_3_1));
    assertThat(store().getValue(branch, Key.of("t1"))).isEqualTo(V_1_2);
    assertThat(store().getValue(branch, Key.of("t2"))).isEqualTo(V_2_2);
    assertThat(store().getValue(branch, Key.of("t3"))).isNull();
    assertThat(store().getValue(branch, Key.of("t4"))).isEqualTo(V_4_1);
    assertThat(store().getValue(secondCommit, Key.of("t1"))).isEqualTo(V_1_2);
    assertThat(store().getValue(secondCommit, Key.of("t2"))).isNull();
    assertThat(store().getValue(secondCommit, Key.of("t3"))).isNull();
    assertThat(store().getValue(secondCommit, Key.of("t4"))).isEqualTo(V_4_1);
    assertThat(store().getValue(initialCommit, Key.of("t1"))).isEqualTo(V_1_1);
    assertThat(store().getValue(initialCommit, Key.of("t2"))).isEqualTo(V_2_1);
    assertThat(store().getValue(initialCommit, Key.of("t3"))).isEqualTo(V_3_1);
    assertThat(store().getValue(initialCommit, Key.of("t4"))).isNull();
}

Example 18 with Key

use of org.projectnessie.versioned.Key in project nessie by projectnessie.

the class AbstractMerge method mergeWithConflictingKeys.

@Test
protected void mergeWithConflictingKeys() throws VersionStoreException {
    final BranchName foo = BranchName.of("foofoo");
    final BranchName bar = BranchName.of("barbar");
    store().create(foo, Optional.of(this.initialHash));
    store().create(bar, Optional.of(this.initialHash));
    // we're essentially modifying the same key on both branches and then merging one branch into
    // the other and expect a conflict
    Key key1 = Key.of("some_key1");
    Key key2 = Key.of("some_key2");
    store().commit(foo, Optional.empty(), commitMessage("commit 1"), Collections.singletonList(Put.of(key1, VALUE_1)));
    store().commit(bar, Optional.empty(), commitMessage("commit 2"), Collections.singletonList(Put.of(key1, VALUE_2)));
    store().commit(foo, Optional.empty(), commitMessage("commit 3"), Collections.singletonList(Put.of(key2, VALUE_3)));
    Hash barHash = store().commit(bar, Optional.empty(), commitMessage("commit 4"), Collections.singletonList(Put.of(key2, VALUE_4)));
    assertThatThrownBy(() -> store().merge(barHash, foo, Optional.empty(), Function.identity())).isInstanceOf(ReferenceConflictException.class).hasMessageContaining("The following keys have been changed in conflict:").hasMessageContaining(key1.toString()).hasMessageContaining(key2.toString());
}

Example 19 with Key

use of org.projectnessie.versioned.Key in project nessie by projectnessie.

the class AbstractMerge method nonEmptyFastForwardMerge.

@Test
protected void nonEmptyFastForwardMerge() throws VersionStoreException {
    final Key key = Key.of("t1");
    final BranchName etl = BranchName.of("etl");
    final BranchName review = BranchName.of("review");
    store().create(etl, Optional.of(initialHash));
    store().create(review, Optional.of(initialHash));
    store().commit(etl, Optional.empty(), commitMessage("commit 1"), Collections.singletonList(Put.of(key, VALUE_1)));
    store().merge(store().hashOnReference(etl, Optional.empty()), review, Optional.empty(), Function.identity());
    store().commit(etl, Optional.empty(), commitMessage("commit 2"), Collections.singletonList(Put.of(key, VALUE_2)));
    store().merge(store().hashOnReference(etl, Optional.empty()), review, Optional.empty(), Function.identity());
    assertEquals(store().getValue(review, key), VALUE_2);
}

Example 20 with Key

use of org.projectnessie.versioned.Key in project nessie by projectnessie.

the class TreeApiImpl method getEntries.

@Override
public EntriesResponse getEntries(String namedRef, EntriesParams params) throws NessieNotFoundException {
    Preconditions.checkArgument(params.pageToken() == null, "Paging not supported");
    WithHash<NamedRef> refWithHash = namedRefWithHashOrThrow(namedRef, params.hashOnRef());
    // all existing VersionStore implementations have to read all keys anyways so we don't get much
    try {
        List<EntriesResponse.Entry> entries;
        try (Stream<EntriesResponse.Entry> entryStream = getStore().getKeys(refWithHash.getHash()).map(key -> EntriesResponse.Entry.builder().name(fromKey(key.getValue())).type((Type) key.getType()).build())) {
            Stream<EntriesResponse.Entry> entriesStream = filterEntries(entryStream, params.filter());
            if (params.namespaceDepth() != null && params.namespaceDepth() > 0) {
                entriesStream = entriesStream.filter(e -> e.getName().getElements().size() >= params.namespaceDepth()).map(e -> truncate(e, params.namespaceDepth())).distinct();
            }
            entries = entriesStream.collect(ImmutableList.toImmutableList());
        }
        return EntriesResponse.builder().addAllEntries(entries).build();
    } catch (ReferenceNotFoundException e) {
        throw new NessieReferenceNotFoundException(e.getMessage(), e);
    }
}