com.orientechnologies.orient.core.command.OCommandRequest Java Examples

@Before
public void setup() {
  when(variableResolverAdapterManager.get(FORMAT)).thenReturn(assetVariableResolver);
  when(assetVariableResolver.fromDocument(assetDocument)).thenReturn(variableSource);

  when(bucketDocument.getRecord()).thenReturn(bucketDocument);
  when(bucketDocument.field("repository_name", String.class)).thenReturn(REPOSITORY_NAME);
  when(bucketDocument.getIdentity()).thenReturn(mock(ORID.class));

  when(assetDocument.getClassName()).thenReturn("asset");
  when(assetDocument.getRecord()).thenReturn(assetDocument);
  when(assetDocument.field("bucket", OIdentifiable.class)).thenReturn(bucketDocument);
  when(assetDocument.field("name", String.class)).thenReturn(PATH);
  when(assetDocument.field("format", String.class)).thenReturn(FORMAT);

  when(commandRequest.execute(any(Map.class))).thenReturn(Collections.singletonList(assetDocument));
  when(database.command(any(OCommandRequest.class))).thenReturn(commandRequest);

  when(selectorManager.newSelectorConfiguration()).thenAnswer(invocation -> new OrientSelectorConfiguration());

  underTest = new ContentExpressionFunction(variableResolverAdapterManager, selectorManager, contentAuthHelper);
}
 

private void mockPagesOfComponents() {
  OCommandRequest oCommandRequest1 = getCommandRequest(10,
      testData(taskOlderThan.minusDays(1), "my.company", "foo", "1.0-SNAPSHOT"),
      testData(taskOlderThan.minusDays(2), "my.company", "bar", "2.0-SNAPSHOT"));
  OCommandRequest oCommandRequest2 = getCommandRequest(10,
      // non-match, not a snapshot
      testData(taskOlderThan.minusDays(1), "your.company", "biz", "1.0")
  );
  OCommandRequest oCommandRequest3 = getCommandRequest(10,
      testData(taskOlderThan.minusDays(2), "this.company", "baz", "3.0-SNAPSHOT")
  );
  OCommandRequest oCommandRequest4 = getCommandRequest(5,
      testData(taskOlderThan.minusDays(3), "my.company", "foo", "0.1-SNAPSHOT"),
      testData(taskOlderThan.minusDays(6), "your.company", "biz", "1.0-SNAPSHOT"),
      // non-match, this is same day
      testData(taskOlderThan, "that.company", "fizz", "1.2.3-SNAPSHOT")
  );

  when(oDatabaseDocumentTx.command(any(OCommandScript.class)))
      .thenReturn(oCommandRequest1, oCommandRequest2, oCommandRequest3, oCommandRequest4);
}
 

@Override
public Object execute(final T descriptor, final Object repositoryInstance,
                      final Object... arguments) throws Throwable {
    final SqlCommandDescriptor desc;
    final OCommandRequest query;
    try {
        desc = createQueryDescriptor(descriptor, arguments);
        amendCommandDescriptor(desc, descriptor, repositoryInstance, arguments);

        query = createQueryCommand(descriptor, desc);
        amendCommand(query, descriptor, repositoryInstance, arguments);
    } catch (Exception ex) {
        throw new CommandMethodException(String.format("Failed to prepare command '%s' execution",
                descriptor.command), ex);
    }

    return executeCommand(descriptor, desc, query);
}
 

@Test
public void testExecute() {
  Set<String> params = ImmutableSet.of("1", "2");

  ArgumentCaptor<OSQLSynchQuery> argumentCaptor = ArgumentCaptor.forClass(OSQLSynchQuery.class);
  OCommandRequest oCommandRequest = mock(OCommandRequest.class);
  when(db.command(argumentCaptor.capture())).thenReturn(oCommandRequest);
  when(oCommandRequest.execute(params)).thenReturn(newArrayList(new ODocument(), new ODocument()));

  List<Entity> results = underTest.execute(db, params);

  assertThat(argumentCaptor.getValue().getText(), equalTo("SELECT FROM test WHERE test IN['1','2']"));
  assertThat(results, notNullValue());
  assertThat(results.size(), equalTo(2));
}
 

@Override
public OCommandResultListener processListener(final OCommandRequest command,
                                              final Object listener,
                                              final Injector injector,
                                              final Class<?> conversionTarget) {
    checkExec(command instanceof OLiveQuery,
            "Live listener (@%s parameter) can only be used with @%s",
            Listen.class.getSimpleName(), LiveQuery.class.getSimpleName());
    return wrap(listener, injector, conversionTarget);
}
 

@Override
@SuppressWarnings("unchecked")
public void amendCommand(final OCommandRequest query, final CommandMethodDescriptor descriptor,
                         final Object instance, final Object... arguments) {
    final ListenParamDescriptor extDesc = (ListenParamDescriptor) descriptor
            .extDescriptors.get(ListenParamExtension.KEY);
    final Object listener = arguments[extDesc.position];
    // null listener makes no sense: method is void and results are not handled anywhere
    checkExec(listener != null, "Listener can't be null");

    ((OCommandRequestAbstract) query).setResultListener(extDesc.handler
            .processListener(query, listener, injector, resolveTargetType(listener.getClass(), extDesc.generic)));
}
 

@SuppressWarnings("unchecked")
private void amendCommand(final OCommandRequest query, final T descriptor,
                          final Object instance, final Object... arguments) {
    for (CommandExtension ext : descriptor.amendExtensions) {
        ext.amendCommand(query, descriptor, instance, arguments);
    }
}
 

@Override
public OCommandResultListener processListener(final OCommandRequest command,
                                              final Object listener,
                                              final Injector injector,
                                              final Class<?> conversionTarget) {
    checkExec(command instanceof OCommandRequestAbstract,
            "@%s can't be applied to query, because command object %s doesn't support it",
            Listen.class.getSimpleName(), command.getClass().getName());
    return wrap(listener, injector, conversionTarget, ((OSQLQuery) command).getText());
}
 

@Override
protected OCommandRequest createQueryCommand(final CommandMethodDescriptor descriptor,
                                             final SqlCommandDescriptor desc) {
    final boolean blocking = (Boolean) descriptor.extDescriptors.get(EXT_BLOCKING);
    // correct listener will be set by @Listen extension
    if (blocking) {
        return new OSQLAsynchQuery(desc.command);
    } else {
        return new OSQLNonBlockingQuery(desc.command, null);
    }
}
 

@Override
public void amendCommand(final OCommandRequest query, final CommandMethodDescriptor descriptor,
                         final Object instance, final Object... arguments) {
    @SuppressWarnings("unchecked")
    final Map<String, Integer> vars = (Map<String, Integer>) descriptor.extDescriptors.get(KEY);
    final OCommandContext context = query.getContext();
    for (Map.Entry<String, Integer> entry : vars.entrySet()) {
        context.setVariable(entry.getKey(), arguments[entry.getValue()]);
    }
}
 

@Override
public OCommandRequest wrapCommand(final OCommandRequest command) {
    return provider.get().command(command);
}
 

@Override
public OCommandRequest wrapCommand(final OCommandRequest command) {
    return provider.get().command(command);
}
 

@Override
public OCommandRequest wrapCommand(final OCommandRequest command) {
    return provider.get().command(command);
}
 

@Override
public void amendCommand(final OCommandRequest query, final CommandMethodDescriptor descriptor,
                         final Object instance, final Object... arguments) {
    // not needed
}
 

@Override
public void amendCommand(final OCommandRequest query, final CommandMethodDescriptor descriptor,
                         final Object instance, final Object... arguments) {
    // not used
}
 

@Override
public void amendCommand(final OCommandRequest query, final CommandMethodDescriptor descriptor,
                         final Object instance, final Object... arguments) {
    // not needed
}
 

@Override
public void amendCommand(final OCommandRequest query, final CommandMethodDescriptor descriptor,
                         final Object instance, final Object... arguments) {
    // not needed
}
 

@Override
public void amendCommand(final OCommandRequest query, final CommandMethodDescriptor descriptor,
                         final Object instance, final Object... arguments) {
    // not needed
}
 

@Override
public void amendCommand(final OCommandRequest query, final CommandMethodDescriptor descriptor,
                         final Object instance, final Object... arguments) {
    // not needed
}
 

@Override
public void amendCommand(final OCommandRequest query, final CommandMethodDescriptor descriptor,
                         final Object instance, final Object... arguments) {
    // not required
}
 

@Override
protected OCommandRequest createQueryCommand(final CommandMethodDescriptor descriptor,
                                             final SqlCommandDescriptor desc) {
    // live listener will be applied by @Listen extension
    return new OLiveQuery<Object>(desc.command, null);
}
 

@Override
protected OCommandRequest createQueryCommand(final CommandMethodDescriptor descriptor,
                                             final SqlCommandDescriptor desc) {
    return new OCommandFunction(desc.command);
}
 

@Override
protected OCommandRequest createQueryCommand(final ScriptCommandMethodDescriptor descriptor,
                                             final SqlCommandDescriptor desc) {
    return new OCommandScript(descriptor.language, desc.command);
}
 

/**
 * Checks listener compatibility with command object and wraps listener if required.
 *
 * @param command          command object
 * @param listener         listener instance (passed in annotated parameter)
 * @param injector         injector instance
 * @param conversionTarget target conversion type or null if no conversion required
 * @return processed listener to apply to command
 */
OCommandResultListener processListener(OCommandRequest command,
                                       Object listener,
                                       Injector injector,
                                       Class<?> conversionTarget);
 

/**
 * Actual command object depends on query type and have to be chosen by exact extension.
 *
 * @param descriptor repository method descriptor
 * @param desc       query descriptor
 * @return query command request object
 */
protected abstract OCommandRequest createQueryCommand(T descriptor, SqlCommandDescriptor desc);
 

/**
 * Called after query object creation. Use it to modify request command object.
 * <p>
 * Note: this is raw command object, not tied to connection. After extension command attached to
 * exact connection type, which wraps command object with another command (to apply security,
 * result conversions etc).
 *
 * @param query      query command request
 * @param descriptor repository method descriptor
 * @param instance   repository instance
 * @param arguments  method execution arguments
 */
void amendCommand(OCommandRequest query, T descriptor, Object instance, Object... arguments);
 

/**
 * Called to bind command to connection.
 * Query will work without wrapping in document mode. Wrapped commend ties result to connection specific objects.
 *
 * @param command command
 * @return command bound to connection
 */
OCommandRequest wrapCommand(OCommandRequest command);