netconf/mdsal-netconf-connector/src/test/java/org/opendaylight/netconf/mdsal/connector/ops/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
   9 package org.opendaylight.netconf.mdsal.connector.ops;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.fail;
  13 import static org.mockito.ArgumentMatchers.any;
  14 import static org.mockito.Mockito.doReturn;
  15 import static org.mockito.Mockito.verify;
  16 import static org.mockito.Mockito.verifyZeroInteractions;
  17 import static org.mockito.MockitoAnnotations.initMocks;
  18 import static org.opendaylight.netconf.mdsal.connector.ops.AbstractNetconfOperationTest.RPC_REPLY_OK;
  19 import static org.opendaylight.netconf.mdsal.connector.ops.AbstractNetconfOperationTest.SESSION_ID_FOR_REPORTING;
  20 import static org.opendaylight.netconf.mdsal.connector.ops.AbstractNetconfOperationTest.executeOperation;
  21 import static org.opendaylight.netconf.mdsal.connector.ops.AbstractNetconfOperationTest.verifyResponse;
  22
  23 import com.google.common.util.concurrent.Futures;
  24 import java.util.Collections;
  25 import org.custommonkey.xmlunit.XMLUnit;
  26 import org.junit.Before;
  27 import org.junit.Test;
  28 import org.mockito.Mock;
  29 import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
  30 import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
  31 import org.opendaylight.netconf.api.DocumentedException;
  32 import org.opendaylight.netconf.mdsal.connector.DOMDataTransactionValidator;
  33 import org.opendaylight.netconf.mdsal.connector.DOMDataTransactionValidator.ValidationFailedException;
  34 import org.opendaylight.netconf.mdsal.connector.TransactionProvider;
  35 import org.w3c.dom.Document;
  36
  37 public class ValidateTest {
  38     @Mock
  39     private DOMDataTransactionValidator noopValidator;
  40     @Mock
  41     private DOMDataTransactionValidator failingValidator;
  42     @Mock
  43     private DOMDataReadWriteTransaction readWriteTx;
  44     @Mock
  45     private DOMDataBroker dataBroker;
  46
  47     @Before
  48     public void setUp() throws Exception {
  49         initMocks(this);
  50         doReturn(Futures.immediateCheckedFuture(null)).when(noopValidator).validate(any());
  51         doReturn(Futures.immediateFailedCheckedFuture(new ValidationFailedException("invalid data")))
  52             .when(failingValidator).validate(any());
  53         doReturn(readWriteTx).when(dataBroker).newReadWriteTransaction();
  54         XMLUnit.setIgnoreWhitespace(true);
  55     }
  56
  57     @Test
  58     public void testValidateUnsupported() throws Exception {
  59         whenValidatorIsNotDefined();
  60         try {
  61             validate("messages/mapping/validate/validate.xml");
  62             fail("Should have failed - <validate> not supported");
  63         } catch (final DocumentedException e) {
  64             assertEquals(DocumentedException.ErrorSeverity.ERROR, e.getErrorSeverity());
  65             assertEquals(DocumentedException.ErrorTag.OPERATION_NOT_SUPPORTED, e.getErrorTag());
  66             assertEquals(DocumentedException.ErrorType.PROTOCOL, e.getErrorType());
  67         }
  68     }
  69
  70     @Test
  71     public void testSourceMissing() throws Exception {
  72         whenUsingValidator(noopValidator);
  73         try {
  74             validate("messages/mapping/validate/validate_no_source.xml");
  75             fail("Should have failed - <source> element is missing");
  76         } catch (final DocumentedException e) {
  77             assertEquals(DocumentedException.ErrorSeverity.ERROR, e.getErrorSeverity());
  78             assertEquals(DocumentedException.ErrorTag.MISSING_ELEMENT, e.getErrorTag());
  79             assertEquals(DocumentedException.ErrorType.PROTOCOL, e.getErrorType());
  80         }
  81     }
  82
  83     @Test
  84     public void testSourceRunning() throws Exception {
  85         whenUsingValidator(noopValidator);
  86         try {
  87             validate("messages/mapping/validate/validate_running.xml");
  88             fail("Should have failed - <running/> is not supported");
  89         } catch (final DocumentedException e) {
  90             assertEquals(DocumentedException.ErrorSeverity.ERROR, e.getErrorSeverity());
  91             assertEquals(DocumentedException.ErrorTag.OPERATION_NOT_SUPPORTED, e.getErrorTag());
  92             assertEquals(DocumentedException.ErrorType.PROTOCOL, e.getErrorType());
  93         }
  94     }
  95
  96     @Test
  97     public void testValidateEmptyTx() throws Exception {
  98         whenUsingValidator(noopValidator);
  99         verifyResponse(validate("messages/mapping/validate/validate.xml"), RPC_REPLY_OK);
 100         verifyZeroInteractions(noopValidator);
 101     }
 102
 103     @Test
 104     public void testValidate() throws Exception {
 105         whenUsingValidator(noopValidator);
 106         final TransactionProvider transactionProvider = initCandidateTransaction();
 107         verifyResponse(validate("messages/mapping/validate/validate.xml", transactionProvider), RPC_REPLY_OK);
 108         verify(noopValidator).validate(readWriteTx);
 109     }
 110
 111     @Test
 112     public void testValidateFailed() throws Exception {
 113         whenUsingValidator(failingValidator);
 114         final TransactionProvider transactionProvider = initCandidateTransaction();
 115         try {
 116             validate("messages/mapping/validate/validate.xml", transactionProvider);
 117             fail("Should have failed - operation failed");
 118         } catch (final DocumentedException e) {
 119             assertEquals(DocumentedException.ErrorSeverity.ERROR, e.getErrorSeverity());
 120             assertEquals(DocumentedException.ErrorTag.OPERATION_FAILED, e.getErrorTag());
 121             assertEquals(DocumentedException.ErrorType.APPLICATION, e.getErrorType());
 122         }
 123     }
 124
 125     private void whenValidatorIsNotDefined() {
 126         doReturn(Collections.emptyMap()).when(dataBroker).getSupportedExtensions();
 127     }
 128
 129     private void whenUsingValidator(final DOMDataTransactionValidator validator) {
 130         doReturn(Collections.singletonMap(DOMDataTransactionValidator.class, validator))
 131             .when(dataBroker).getSupportedExtensions();
 132     }
 133
 134     private TransactionProvider initCandidateTransaction() {
 135         final TransactionProvider transactionProvider = new TransactionProvider(dataBroker, SESSION_ID_FOR_REPORTING);
 136         transactionProvider.getOrCreateTransaction();
 137         return transactionProvider;
 138     }
 139
 140     private Document validate(final String resource,
 141                               final TransactionProvider transactionProvider) throws Exception {
 142         final Validate validate = new Validate(SESSION_ID_FOR_REPORTING, transactionProvider);
 143         return executeOperation(validate, resource);
 144     }
 145
 146     private Document validate(final String resource) throws Exception {
 147         return validate(resource, new TransactionProvider(dataBroker, SESSION_ID_FOR_REPORTING));
 148     }
 149 }