Java 使用Olingo/ODATA 4编写ExpressionVisitor集成测试

我正在用Java语言和Olingo框架实现一个关于OData标准第4版的web服务。我需要自定义

$filter

的响应。我实现了一个访问者。我需要实现一个集成测试来尝试一种不同的语法，并防止将来维护时出现回归错误

对于V2，我找到了以下代码：

@Test
public void printExpressionWithProperty() throws Exception {
  //Use a mocked edmProvider for this tutorial
  TestEdmProvider provider = new TestEdmProvider();
  Edm edm = RuntimeDelegate.createEdm(provider);
  EdmEntityType entityType = edm.getEntityType(TestEdmProvider.NAMESPACE_1, TestEdmProvider.ENTITY_TYPE_1_1.getName());

  String rawExpression = "EmployeeId eq '1'";
  FilterExpression expression = UriParser.parseFilter (null, entityType, rawExpression);
  String whereClause = (String) expression.accept(new JdbcSimpleStringVisitor());
  System.out.println("Raw: " + rawExpression + " ------> Whereclause: " + whereClause);
  System.out.println();
}

不幸的是，

UriParser.parseFilter

在v4中不存在

我试过这个：

public class MyVisitorTest {

    private final FullQualifiedName NAME1 = new FullQualifiedName("testNamespace1", "myfield");
    private final OData odata = OData.newInstance();

    public EdmEntityType createEntityType(final FullQualifiedName fqn) {
        if (NAME1.equals(fqn)) {
            EdmEntityType entityType = mock(EdmEntityType.class);
            when(entityType.getNamespace()).thenReturn(fqn.getNamespace());
            when(entityType.getName()).thenReturn(fqn.getName());
            return entityType;
        }
        return null;
    }


    private Expression parseExpression(final String expressionString)
            throws UriParserException, UriValidationException {

        UriTokenizer tokenizer = new UriTokenizer(expressionString);

        EdmEntityType entityType = createEntityType(NAME1);

        Edm edm = mock(Edm.class);
        when(edm.getEntityType(NAME1)).thenReturn(entityType);

        final Expression expression = new ExpressionParser(edm, odata).parse(tokenizer, null, null, null);
        assertNotNull(expression);
        assertTrue(tokenizer.next(UriTokenizer.TokenKind.EOF));
        return expression;
    }

    @Test
    public void simpleTest() throws UriParserException, UriValidationException, ODataApplicationException, ExpressionVisitException {

        String exp = "myfield gt 2019-01-01T00:00:00Z";
        Expression e = parseExpression(exp);

        MyVisitor myVisitor = new MyVisitor();
        String result = (String) e.accept(startEndMeasureVisitor);
        assertEquals(result.toString(), "MyResult");
    }
}

但它不起作用，它向我发送了以下消息：

属性路径必须遵循结构化类型

---

因此，我正在寻找使我的单元测试工作的任何想法，或者如果您有工作示例要共享…

当涉及到单元测试时，我会专注于单独测试每个过滤器方法。例如，如果

visitBinaryOperator

根据输入返回预期值，依此类推

我不是命名方面的专家，但我将您的测试称为集成测试。这里，我将重点介绍测试中准备的

FilterOption

。在您的原始应用程序中，ApacheOlingo将创建此

过滤器选项

，并且此部分已经（应该）在Olingo中进行了测试

当我使用ApacheOlingo时，我经常提到，尤其是服务器测试和服务器tecsvc。验证Olingo本身是如何测试的

---

我建议您看看，因为它可能对您的集成测试有用。

现在，由于模型的跟踪功能（对遗留代码非常有用），我得到了新版本的

parseExpression

方法，可以回答我的问题

class A implements EdmStructuredType, EdmPrimitiveType {

    @Override
    public boolean isCompatible(EdmPrimitiveType edmPrimitiveType) {
        return false;
    }

    @Override
    public Class<?> getDefaultType() {
        return null;
    }

    @Override
    public boolean validate(String s, Boolean aBoolean, Integer integer, Integer integer1, Integer integer2, Boolean aBoolean1) {
        return false;
    }

    @Override
    public <T> T valueOfString(String s, Boolean aBoolean, Integer integer, Integer integer1, Integer integer2, Boolean aBoolean1, Class<T> aClass) throws EdmPrimitiveTypeException {
        return null;
    }

    @Override
    public String valueToString(Object o, Boolean aBoolean, Integer integer, Integer integer1, Integer integer2, Boolean aBoolean1) throws EdmPrimitiveTypeException {
        return null;
    }

    @Override
    public String toUriLiteral(String s) {
        return null;
    }

    @Override
    public String fromUriLiteral(String s) throws EdmPrimitiveTypeException {
        return null;
    }

    @Override
    public EdmElement getProperty(String s) {
        return null;
    }

    @Override
    public List<String> getPropertyNames() {
        return null;
    }

    @Override
    public EdmProperty getStructuralProperty(String s) {
        return null;
    }

    @Override
    public EdmNavigationProperty getNavigationProperty(String s) {
        return null;
    }

    @Override
    public List<String> getNavigationPropertyNames() {
        return null;
    }

    @Override
    public EdmStructuredType getBaseType() {
        return null;
    }

    @Override
    public boolean compatibleTo(EdmType edmType) {
        return false;
    }

    @Override
    public boolean isOpenType() {
        return false;
    }

    @Override
    public boolean isAbstract() {
        return false;
    }

    @Override
    public EdmAnnotation getAnnotation(EdmTerm edmTerm, String s) {
        return null;
    }

    @Override
    public List<EdmAnnotation> getAnnotations() {
        return null;
    }

    @Override
    public FullQualifiedName getFullQualifiedName() {
        return null;
    }

    @Override
    public String getNamespace() {
        return null;
    }

    @Override
    public EdmTypeKind getKind() {
        return null;
    }

    @Override
    public String getName() {
        return null;
    }
}


private Expression parseExpression(final String expressionString)
        throws UriParserException, UriValidationException {

    UriTokenizer tokenizer = new UriTokenizer(expressionString);

    Edm edm = mock(A.class, withSettings().defaultAnswer(RETURNS_SMART_NULLS));
    EdmProperty employeeIdTypeEdmElement = mock(EdmProperty.class, RETURNS_SMART_NULLS);

    when(edmType.getProperty("EmployeeId")).thenReturn(measureTypeEdmElement);

    when(edmType.getKind()).thenReturn(EdmTypeKind.PRIMITIVE);
    when(edmType.isCompatible(new EdmDate())).thenReturn(true);

    when(employeeIdTypeEdmElement.getName()).thenReturn("EmployeeId");
    when(employeeIdTypeEdmElement.getType()).thenReturn(edmType);
    when(employeeIdTypeEdmElement.isCollection()).thenReturn(false);


    final Expression expression = new ExpressionParser(edm, odata).parse(tokenizer, edmType, null, null);
    assertNotNull(expression);
    assertTrue(tokenizer.next(UriTokenizer.TokenKind.EOF));
    return expression;
}

A类实现EdmStructuredType、EdmPrimitiveType{
@凌驾
公共布尔值不可计算（EdmPrimitiveType EdmPrimitiveType）{
返回false；
}
@凌驾
公共类getDefaultType（）{
返回null；
}
@凌驾
公共布尔值验证（字符串s、布尔值aBoolean、整数整型、整数整型1、整数整型2、布尔值aBoolean 1）{
返回false；
}
@凌驾
公共T值字符串（字符串s、布尔aBoolean、整型整数、整型整数1、整型整数2、布尔aBoolean 1、类aClass）引发EdmPrimitiveTypeException{
返回null；
}
@凌驾
公共字符串valueToString（对象o，布尔型aBoolean，整型整数，整型整数1，整型整数2，布尔型aBoolean1）引发EdmPrimitiveTypeException{
返回null；
}
@凌驾
公共字符串（字符串s）{
返回null；
}
@凌驾
来自UriLiteral的公共字符串（字符串s）引发EdmPrimitiveTypeException{
返回null；
}
@凌驾
公共元素getProperty（字符串s）{
返回null；
}
@凌驾
公共列表getPropertyNames（）{
返回null；
}
@凌驾
公共属性getStructuralProperty（字符串s）{
返回null；
}
@凌驾
公共EdmNavigationProperty getNavigationProperty（字符串s）{
返回null；
}
@凌驾
公共列表getNavigationPropertyNames（）{
返回null；
}
@凌驾
公共EdmStructuredType getBaseType（）{
返回null；
}
@凌驾
公共布尔兼容对象（EdmType EdmType）{
返回false；
}
@凌驾
公共布尔等熵类型（）{
返回false；
}
@凌驾
公共布尔值（）{
返回false；
}
@凌驾
公共EdmAnnotation getAnnotation（EdmTerm EdmTerm，字符串s）{
返回null；
}
@凌驾
公共列表getAnnotations（）{
返回null；
}
@凌驾
public FullQualifiedName getFullQualifiedName（）{
返回null；
}
@凌驾
公共字符串getNamespace（）{
返回null；
}
@凌驾
公共EdmTypeKind getKind（）{
返回null；
}
@凌驾
公共字符串getName（）{
返回null；
}
}
专用表达式parseExpression（最终字符串表达式字符串）
抛出UriParserException、UriValidationException{
UriTokenizer标记器=新的UriTokenizer（expressionString）；
Edm Edm=mock（A.class，withSettings（）.defaultAnswer（返回\u SMART\u null））；
EdmProperty employeeIdTypeEdmElement=mock（EdmProperty.class，返回\u SMART\u null）；
当（edmType.getProperty（“EmployeeId”）。然后返回（MeasureTypeedElement）；
当（edmType.getKind（））.thenReturn（EdmTypeKind.PRIMITIVE）；
当（edmType.isCompatible（new EdmDate（））。然后返回（true）；
当（EmployeeIDTypedElement.getName（））。然后返回（“EmployeeId”）；
当（EmployeeIDTypedElement.getType（））。然后返回（edmType）；
当（EmployeeIDTypedElement.isCollection（））。然后返回（false）；
final Expression Expression=new ExpressionParser（edm，odata）.parse（标记器，edmType，null，null）；
assertNotNull（表达式）；
assertTrue（tokenizer.next（UriTokenizer.TokenKind.EOF））；
返回表达式；
}

---

如果它对某人有帮助，maybee可以对其进行优化，免费填写以供建议。

好的，关于集成测试，我将重命名我的问题。Olingo代码源也是我灵感的主要来源。谢谢你们的建议，这似乎是一个很好的方式来解决我的问题，结合。我会让你知道它是否有效。这可不容易。。。odata服务器测试和odata服务器tecsvc模块不适用于4.5.0 olingo maven repo。是的，我只能在maven Central中找到4.0.0-beta-02-RC01。您可以尝试使用此版本，也可以自己重写所有内容。我看不到其他选项：/嗯，可能是e2e测试的选项，您可以使用OData客户端或普通HTTP客户端对准备好的数据库执行带有

$filter

的请求。老实说，我是这样测试的，并且使用了单元测试。谢谢你的建议，这是一个好主意，而且我已经实现了r