import akka.dispatch.OnComplete;
import com.google.common.annotations.Beta;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import org.opendaylight.controller.cluster.schema.provider.RemoteYangTextSourceProvider;
-import org.opendaylight.yangtools.util.concurrent.ExceptionMapper;
-import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceException;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceProvider;
*/
@Beta
public class RemoteSchemaProvider implements SchemaSourceProvider<YangTextSchemaSource> {
-
private static final Logger LOG = LoggerFactory.getLogger(RemoteSchemaProvider.class);
private final RemoteYangTextSourceProvider remoteRepo;
private final ExecutionContext executionContext;
- private static final ExceptionMapper<SchemaSourceException> MAPPER = new ExceptionMapper<SchemaSourceException>(
- "schemaDownload", SchemaSourceException.class) {
- @Override
- protected SchemaSourceException newWithCause(final String message, final Throwable throwable) {
- return new SchemaSourceException(message, throwable);
- }
- };
-
- public RemoteSchemaProvider(RemoteYangTextSourceProvider remoteRepo, ExecutionContext executionContext) {
+ public RemoteSchemaProvider(final RemoteYangTextSourceProvider remoteRepo,
+ final ExecutionContext executionContext) {
this.remoteRepo = remoteRepo;
this.executionContext = executionContext;
}
@Override
- public CheckedFuture<YangTextSchemaSource, SchemaSourceException> getSource(SourceIdentifier sourceIdentifier) {
+ public ListenableFuture<YangTextSchemaSource> getSource(final SourceIdentifier sourceIdentifier) {
LOG.trace("Getting yang schema source for {}", sourceIdentifier.getName());
Future<YangTextSchemaSourceSerializationProxy> result = remoteRepo.getYangTextSchemaSource(sourceIdentifier);
final SettableFuture<YangTextSchemaSource> res = SettableFuture.create();
result.onComplete(new OnComplete<YangTextSchemaSourceSerializationProxy>() {
@Override
- public void onComplete(Throwable throwable,
- YangTextSchemaSourceSerializationProxy yangTextSchemaSourceSerializationProxy) {
+ public void onComplete(final Throwable throwable,
+ final YangTextSchemaSourceSerializationProxy yangTextSchemaSourceSerializationProxy) {
if (yangTextSchemaSourceSerializationProxy != null) {
res.set(yangTextSchemaSourceSerializationProxy.getRepresentation());
}
res.setException(throwable);
}
}
-
}, executionContext);
- return Futures.makeChecked(res, MAPPER);
+ return res;
}
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.controller.cluster.schema.provider.impl;
+import static org.hamcrest.Matchers.instanceOf;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
import akka.dispatch.ExecutionContexts;
import akka.dispatch.Futures;
-import com.google.common.io.ByteSource;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.io.CharSource;
+import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.concurrent.ExecutionException;
import org.junit.Before;
import org.junit.Test;
-import org.mockito.Mockito;
import org.opendaylight.controller.cluster.schema.provider.RemoteYangTextSourceProvider;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
public class RemoteSchemaProviderTest {
-
private static final SourceIdentifier ID = RevisionSourceIdentifier.create("Test", Revision.of("2015-10-30"));
private RemoteSchemaProvider remoteSchemaProvider;
@Before
public void setUp() {
- mockedRemoteSchemaRepository = Mockito.mock(RemoteYangTextSourceProvider.class);
- ExecutionContexts.fromExecutorService(MoreExecutors.newDirectExecutorService());
+ mockedRemoteSchemaRepository = mock(RemoteYangTextSourceProvider.class);
remoteSchemaProvider = new RemoteSchemaProvider(mockedRemoteSchemaRepository,
- ExecutionContexts.fromExecutorService(MoreExecutors.newDirectExecutorService()));
+ ExecutionContexts.fromExecutor(MoreExecutors.directExecutor()));
}
@Test
- public void getExistingYangTextSchemaSource() throws IOException, SchemaSourceException {
- String source = "Test";
- YangTextSchemaSource schemaSource = YangTextSchemaSource.delegateForByteSource(
- ID, ByteSource.wrap(source.getBytes()));
- YangTextSchemaSourceSerializationProxy sourceProxy = new YangTextSchemaSourceSerializationProxy(schemaSource);
- Mockito.when(mockedRemoteSchemaRepository.getYangTextSchemaSource(ID))
- .thenReturn(Futures.successful(sourceProxy));
+ public void getExistingYangTextSchemaSource() throws IOException, InterruptedException, ExecutionException {
+ YangTextSchemaSource schemaSource = YangTextSchemaSource.delegateForByteSource(ID,
+ CharSource.wrap("Test").asByteSource(StandardCharsets.UTF_8));
+ doReturn(Futures.successful(new YangTextSchemaSourceSerializationProxy(schemaSource)))
+ .when(mockedRemoteSchemaRepository).getYangTextSchemaSource(ID);
- YangTextSchemaSource providedSource = remoteSchemaProvider.getSource(ID).checkedGet();
- assertEquals(providedSource.getIdentifier(), ID);
- assertArrayEquals(providedSource.read(), schemaSource.read());
+ YangTextSchemaSource providedSource = remoteSchemaProvider.getSource(ID).get();
+ assertEquals(ID, providedSource.getIdentifier());
+ assertArrayEquals(schemaSource.read(), providedSource.read());
}
- @Test(expected = SchemaSourceException.class)
- public void getNonExistingSchemaSource() throws Exception {
- Futures.failed(new Exception("halo"));
-
- Mockito.when(mockedRemoteSchemaRepository.getYangTextSchemaSource(ID)).thenReturn(
- Futures.failed(
- new SchemaSourceException("Source not provided")));
+ @Test
+ public void getNonExistingSchemaSource() throws InterruptedException {
+ doReturn(Futures.failed(new SchemaSourceException("Source not provided")))
+ .when(mockedRemoteSchemaRepository).getYangTextSchemaSource(ID);
- CheckedFuture<?, ?> sourceFuture = remoteSchemaProvider.getSource(ID);
+ ListenableFuture<YangTextSchemaSource> sourceFuture = remoteSchemaProvider.getSource(ID);
assertTrue(sourceFuture.isDone());
- sourceFuture.checkedGet();
+ try {
+ sourceFuture.get();
+ fail("Expected a failure to occur");
+ } catch (ExecutionException e) {
+ assertThat(e.getCause(), instanceOf(SchemaSourceException.class));
+ }
}
}