renderers/opflex/src/test/java/org/opendaylight/groupbasedpolicy/renderer/opflex/EprContextTest.java

   1 /*
   2  * Copyright (C) 2014 Cisco Systems, Inc.
   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  *  Authors : Thomas Bachman
   9  */
  10
  11 package org.opendaylight.groupbasedpolicy.renderer.opflex;
  12
  13 import static org.junit.Assert.assertTrue;
  14 import static org.mockito.Mockito.mock;
  15 import static org.mockito.Mockito.verify;
  16 import static org.mockito.Mockito.when;
  17
  18 import java.util.ArrayList;
  19 import java.util.List;
  20 import java.util.concurrent.Executors;
  21 import java.util.concurrent.ScheduledExecutorService;
  22
  23 import org.junit.Before;
  24 import org.junit.Test;
  25 import org.mockito.Mock;
  26 import org.mockito.MockitoAnnotations;
  27 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  28 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  29 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  30 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  31 import org.slf4j.Logger;
  32 import org.slf4j.LoggerFactory;
  33
  34 import com.google.common.util.concurrent.CheckedFuture;
  35
  36
  37
  38 /**
  39  *
  40  */
  41 public class EprContextTest implements EprContext.EprCtxCallback {
  42     protected static final Logger logger = LoggerFactory.getLogger(L2EprOperationTest.class);
  43
  44     @Mock
  45     private WriteTransaction mockWriter;
  46     @Mock
  47     private DataBroker mockDataProvider;
  48     @Mock
  49     private EprOperation mockOperation;
  50     @Mock
  51     private WriteTransaction mockWriteTransaction;
  52     @Mock
  53     private ReadOnlyTransaction mockReadTransaction;
  54     @Mock
  55     CheckedFuture<Void, TransactionCommitFailedException> mockFuture;
  56
  57     private ScheduledExecutorService executor;
  58     private EprContext ec;
  59     private int callbacks;
  60
  61
  62         @Override
  63         public void callback(EprContext ctx) {
  64                 this.callbacks += 1;
  65         }
  66
  67         @Before
  68     public void setUp() throws Exception {
  69         MockitoAnnotations.initMocks(this);
  70         executor = Executors.newScheduledThreadPool(1);
  71
  72         ec = new EprContext(null, null, mockDataProvider, executor);
  73         ec.addOperation(mockOperation);
  74      }
  75
  76     @Test
  77     public void testCreate() throws Exception {
  78         when(mockDataProvider.newWriteOnlyTransaction()).thenReturn(mockWriteTransaction);
  79         when(mockWriteTransaction.submit()).thenReturn(mockFuture);
  80         ec.createEp();
  81         verify(mockOperation).put(mockWriteTransaction);
  82         verify(mockFuture).addListener(ec, executor);
  83     }
  84
  85     @Test
  86     public void testDelete() throws Exception {
  87         when(mockDataProvider.newWriteOnlyTransaction()).thenReturn(mockWriteTransaction);
  88         when(mockWriteTransaction.submit()).thenReturn(mockFuture);
  89         ec.deleteEp();
  90         verify(mockOperation).delete(mockWriteTransaction);
  91         verify(mockFuture).addListener(ec, executor);
  92
  93     }
  94
  95     @Test
  96     public void testLookup() throws Exception {
  97         when(mockDataProvider.newReadOnlyTransaction()).thenReturn(mockReadTransaction);
  98         ec.lookupEndpoint();
  99         verify(mockOperation).setCallback(ec);
 100         verify(mockOperation).read(mockReadTransaction, executor);
 101
 102     }
 103
 104     @Test
 105     public void testCallback() throws Exception {
 106                 List<EprOperation> ops = new ArrayList<EprOperation>();
 107
 108                 EprOperation op1 = mock(EprOperation.class);
 109                 EprOperation op2 = mock(EprOperation.class);
 110                 EprOperation op3 = mock(EprOperation.class);
 111                 EprOperation op4 = mock(EprOperation.class);
 112
 113                 ops.add(op1);
 114                 ops.add(op2);
 115                 ops.add(op3);
 116                 ops.add(op4);
 117
 118         when(mockDataProvider.newReadOnlyTransaction()).thenReturn(mockReadTransaction);
 119
 120         this.callbacks = 0;
 121                 ec.setCallback(this);
 122
 123                 for (EprOperation op: ops) {
 124                         ec.addOperation(op);
 125                 }
 126                 assertTrue(this.callbacks == 0);
 127
 128                 ec.lookupEndpoint();
 129
 130                 for (EprOperation op: ops) {
 131                         ec.callback(op);
 132                 }
 133                 assertTrue(this.callbacks == 0);
 134                 ec.callback(mockOperation);
 135                 assertTrue(this.callbacks == 1);
 136
 137     }
 138
 139 }