plugins/netconf-server-mdsal/src/test/java/org/opendaylight/netconf/server/mdsal/operations/ValidateTest.java

   1 /*
   2  * Copyright (c) 2018 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.netconf.server.mdsal.operations;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertThrows;
  12 import static org.mockito.ArgumentMatchers.any;
  13 import static org.mockito.Mockito.doReturn;
  14 import static org.mockito.Mockito.verify;
  15 import static org.mockito.Mockito.verifyNoMoreInteractions;
  16 import static org.opendaylight.netconf.server.mdsal.operations.AbstractNetconfOperationTest.RPC_REPLY_OK;
  17 import static org.opendaylight.netconf.server.mdsal.operations.AbstractNetconfOperationTest.SESSION_ID_FOR_REPORTING;
  18 import static org.opendaylight.netconf.server.mdsal.operations.AbstractNetconfOperationTest.executeOperation;
  19 import static org.opendaylight.netconf.server.mdsal.operations.AbstractNetconfOperationTest.verifyResponse;
  20
  21 import java.util.List;
  22 import org.custommonkey.xmlunit.XMLUnit;
  23 import org.junit.Before;
  24 import org.junit.Test;
  25 import org.junit.runner.RunWith;
  26 import org.mockito.Answers;
  27 import org.mockito.Mock;
  28 import org.mockito.junit.MockitoJUnitRunner;
  29 import org.opendaylight.mdsal.dom.api.DOMDataBroker;
  30 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
  31 import org.opendaylight.netconf.api.DocumentedException;
  32 import org.opendaylight.netconf.server.mdsal.DOMDataTransactionValidator;
  33 import org.opendaylight.netconf.server.mdsal.DOMDataTransactionValidator.ValidationFailedException;
  34 import org.opendaylight.netconf.server.mdsal.TransactionProvider;
  35 import org.opendaylight.yangtools.util.concurrent.FluentFutures;
  36 import org.opendaylight.yangtools.yang.common.ErrorSeverity;
  37 import org.opendaylight.yangtools.yang.common.ErrorTag;
  38 import org.opendaylight.yangtools.yang.common.ErrorType;
  39 import org.w3c.dom.Document;
  40
  41 @RunWith(MockitoJUnitRunner.StrictStubs.class)
  42 public class ValidateTest {
  43     @Mock
  44     private DOMDataTransactionValidator noopValidator;
  45     @Mock
  46     private DOMDataTransactionValidator failingValidator;
  47     @Mock
  48     private DOMDataTreeReadWriteTransaction readWriteTx;
  49     @Mock(answer = Answers.CALLS_REAL_METHODS)
  50     private DOMDataBroker dataBroker;
  51
  52     @Before
  53     public void setUp() {
  54         doReturn(FluentFutures.immediateNullFluentFuture()).when(noopValidator).validate(any());
  55         doReturn(FluentFutures.immediateFailedFluentFuture(new ValidationFailedException("invalid data")))
  56             .when(failingValidator).validate(any());
  57         doReturn(readWriteTx).when(dataBroker).newReadWriteTransaction();
  58         XMLUnit.setIgnoreWhitespace(true);
  59     }
  60
  61     @Test
  62     public void testValidateUnsupported() throws Exception {
  63         whenValidatorIsNotDefined();
  64         final DocumentedException e = assertThrows(DocumentedException.class,
  65             () -> validate("messages/mapping/validate/validate.xml"));
  66         assertEquals(ErrorSeverity.ERROR, e.getErrorSeverity());
  67         assertEquals(ErrorTag.OPERATION_NOT_SUPPORTED, e.getErrorTag());
  68         assertEquals(ErrorType.PROTOCOL, e.getErrorType());
  69     }
  70
  71     @Test
  72     public void testSourceMissing() throws Exception {
  73         whenUsingValidator(noopValidator);
  74         final DocumentedException e = assertThrows(DocumentedException.class,
  75             () -> validate("messages/mapping/validate/validate_no_source.xml"));
  76         assertEquals(ErrorSeverity.ERROR, e.getErrorSeverity());
  77         assertEquals(ErrorTag.MISSING_ELEMENT, e.getErrorTag());
  78         assertEquals(ErrorType.PROTOCOL, e.getErrorType());
  79     }
  80
  81     @Test
  82     public void testSourceRunning() throws Exception {
  83         whenUsingValidator(noopValidator);
  84         final DocumentedException e = assertThrows(DocumentedException.class,
  85             () -> validate("messages/mapping/validate/validate_running.xml"));
  86         assertEquals(ErrorSeverity.ERROR, e.getErrorSeverity());
  87         assertEquals(ErrorTag.OPERATION_NOT_SUPPORTED, e.getErrorTag());
  88         assertEquals(ErrorType.PROTOCOL, e.getErrorType());
  89     }
  90
  91     @Test
  92     public void testValidateEmptyTx() throws Exception {
  93         whenUsingValidator(noopValidator);
  94         verifyResponse(validate("messages/mapping/validate/validate.xml"), RPC_REPLY_OK);
  95         verifyNoMoreInteractions(noopValidator);
  96     }
  97
  98     @Test
  99     public void testValidate() throws Exception {
 100         whenUsingValidator(noopValidator);
 101         final TransactionProvider transactionProvider = initCandidateTransaction();
 102         verifyResponse(validate("messages/mapping/validate/validate.xml", transactionProvider), RPC_REPLY_OK);
 103         verify(noopValidator).validate(readWriteTx);
 104     }
 105
 106     @Test
 107     public void testValidateFailed() throws Exception {
 108         whenUsingValidator(failingValidator);
 109         final TransactionProvider transactionProvider = initCandidateTransaction();
 110         final DocumentedException e = assertThrows(DocumentedException.class,
 111             () -> validate("messages/mapping/validate/validate.xml", transactionProvider));
 112         assertEquals(ErrorSeverity.ERROR, e.getErrorSeverity());
 113         assertEquals(ErrorTag.OPERATION_FAILED, e.getErrorTag());
 114         assertEquals(ErrorType.APPLICATION, e.getErrorType());
 115     }
 116
 117     private void whenValidatorIsNotDefined() {
 118         doReturn(List.of()).when(dataBroker).supportedExtensions();
 119     }
 120
 121     private void whenUsingValidator(final DOMDataTransactionValidator validator) {
 122         doReturn(List.of(validator)).when(dataBroker).supportedExtensions();
 123     }
 124
 125     private TransactionProvider initCandidateTransaction() {
 126         final TransactionProvider transactionProvider = new TransactionProvider(dataBroker, SESSION_ID_FOR_REPORTING);
 127         transactionProvider.getOrCreateTransaction();
 128         return transactionProvider;
 129     }
 130
 131     private static Document validate(final String resource,  final TransactionProvider transactionProvider)
 132             throws Exception {
 133         final Validate validate = new Validate(SESSION_ID_FOR_REPORTING, transactionProvider);
 134         return executeOperation(validate, resource);
 135     }
 136
 137     private Document validate(final String resource) throws Exception {
 138         return validate(resource, new TransactionProvider(dataBroker, SESSION_ID_FOR_REPORTING));
 139     }
 140 }