1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
/*
* Copyright (c) 2016 Cisco and/or its affiliates.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package io.fd.honeycomb.test.tools;
import io.fd.honeycomb.test.tools.annotations.InjectablesProcessor;
import io.fd.honeycomb.test.tools.factories.ChildNodeDataFactory;
import io.fd.honeycomb.test.tools.factories.RootNodeDataFactory;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.lang.reflect.Parameter;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import javax.annotation.Nullable;
import org.apache.commons.lang3.StringUtils;
import org.junit.runners.BlockJUnit4ClassRunner;
import org.junit.runners.model.FrameworkMethod;
import org.junit.runners.model.InitializationError;
import org.junit.runners.model.Statement;
import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
import org.opendaylight.yangtools.sal.binding.generator.impl.ModuleInfoBackedContext;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.data.impl.codec.DeserializationException;
import org.opendaylight.yangtools.yang.data.util.AbstractModuleStringInstanceIdentifierCodec;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class HoneycombTestRunner extends BlockJUnit4ClassRunner implements YangContextProducer, InjectablesProcessor {
private static final Logger LOG = LoggerFactory.getLogger(HoneycombTestRunner.class);
private SchemaContext schemaContext;
private BindingToNormalizedNodeCodec serializer;
private AbstractModuleStringInstanceIdentifierCodec iidParser;
private ChildNodeDataFactory childNodeDataFactory;
private RootNodeDataFactory rootNodeDataFactory;
public HoneycombTestRunner(final Class<?> klass) throws InitializationError {
super(klass);
}
@Override
protected Object createTest() throws Exception {
final Object test = super.createTest();
LOG.debug("Initializing test {}", test);
// Get schema context from annotated method
final ModuleInfoBackedContext ctx = getCheckedModuleInfoContext(test);
schemaContext = ctx.getSchemaContext();
// Create serializer from it in order to later transform NormalizedNodes into BA
serializer = createSerializer(ctx, schemaContext);
// Create InstanceIdentifier Codec in order to later transform string represented IID into YangInstanceIdentifier
iidParser = getIIDCodec(ctx);
childNodeDataFactory = new ChildNodeDataFactory(schemaContext, serializer, iidParser);
rootNodeDataFactory = new RootNodeDataFactory(schemaContext, serializer, iidParser);
injectFields(test);
return test;
}
@Override
protected void validatePublicVoidNoArgMethods(final Class<? extends Annotation> annotation, final boolean isStatic,
final List<Throwable> errors) {
// ignores this check,in case its super needed, can be implemented, but without checking no args(because of custom invoker)
}
/**
* Allows method parameters injection
* */
@Override
protected Statement methodInvoker(final FrameworkMethod method, final Object test) {
return new InjectableTestMethodInvoker(method, test, Arrays.stream(method.getMethod().getParameters())
.map(this::injectValueOrNull)
.collect(Collectors.toList())
.toArray());
}
private Object injectValueOrNull(final Parameter parameter) {
return isInjectable(parameter)
? getData(resourcePath(parameter), instanceIdentifier(parameter).orNull(), parameter.getType())
: null;
}
/**
* Inject fields with dat from @InjectTestData.resourcePath
*/
private void injectFields(final Object testInstance) {
// iterate over all injectable fields
injectableFields(testInstance.getClass()).forEach(field -> {
LOG.debug("Processing field {}", field);
injectField(field, testInstance,
getData(resourcePath(field), instanceIdentifier(field).orNull(), field.getType()));
});
}
private DataObject getData(final String resourcePath, @Nullable final String identifier,
final Class<?> injectedType) {
try {
if (StringUtils.isNotEmpty(identifier)) {
LOG.debug("Processing {} as child node {}", injectedType, identifier);
return childNodeDataFactory.getChildNodeData(identifier, resourcePath);
} else {
LOG.debug("Processing {} as root node", injectedType);
return rootNodeDataFactory.getRootNodeData(getRootInstanceIdentifier(injectedType), resourcePath);
}
} catch (DeserializationException | IOException e) {
throw new IllegalStateException(e);
}
}
}
|