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

Example 1 with WithType

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

the class NamespaceApiImpl method deleteNamespace.

@Override
public void deleteNamespace(NamespaceParams params) throws NessieReferenceNotFoundException, NessieNamespaceNotEmptyException, NessieNamespaceNotFoundException {
    BranchName branch = branchFromRefName(params.getRefName());
    try {
        Namespace namespace = getNamespace(params, branch);
        Delete delete = Delete.of(ContentKey.of(namespace.getElements()));
        Callable<Void> validator = () -> {
            try (Stream<WithType<Key, Type>> keys = getStore().getKeys(branch)) {
                if (keys.anyMatch(k -> Namespace.of(k.getValue().getElements()).name().startsWith(params.getNamespace().name()) && k.getType() != Type.NAMESPACE)) {
                    throw namespaceNotEmptyException(params);
                }
            }
            return null;
        };
        commit(branch, "delete namespace " + namespace.name(), TreeApiImpl.toOp(delete), validator);
    } catch (ReferenceNotFoundException | ReferenceConflictException e) {
        throw new NessieReferenceNotFoundException(e.getMessage(), e);
    }
}

Example 2 with WithType

use of org.projectnessie.versioned.WithType 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 3 with WithType

use of org.projectnessie.versioned.WithType 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();
}