sxp-integration/sxp-ep-provider/src/test/java/org/opendaylight/groupbasedpolicy/sxp/ep/provider/impl/dao/EPPolicyTemplateDaoFacadeImplTest.java

   1 /*
   2  * Copyright (c) 2016 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.groupbasedpolicy.sxp.ep.provider.impl.dao;
  10
  11 import com.google.common.base.Optional;
  12 import com.google.common.collect.Iterables;
  13 import com.google.common.util.concurrent.Futures;
  14 import com.google.common.util.concurrent.ListenableFuture;
  15 import java.util.Collection;
  16 import java.util.Collections;
  17 import java.util.concurrent.ExecutionException;
  18 import org.hamcrest.BaseMatcher;
  19 import org.hamcrest.Description;
  20 import org.junit.Assert;
  21 import org.junit.Before;
  22 import org.junit.Rule;
  23 import org.junit.Test;
  24 import org.junit.rules.ExpectedException;
  25 import org.junit.runner.RunWith;
  26 import org.mockito.Mock;
  27 import org.mockito.Mockito;
  28 import org.mockito.runners.MockitoJUnitRunner;
  29 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  30 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  31 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  32 import org.opendaylight.groupbasedpolicy.sxp.ep.provider.api.EPPolicyTemplateProvider;
  33 import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.SgtGeneratorImpl;
  34 import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.SimpleCachedDao;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.model.rev160302.TemplateGenerated;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.model.rev160302.sxp.ep.mapper.EndpointPolicyTemplateBySgt;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.model.rev160302.sxp.ep.mapper.EndpointPolicyTemplateBySgtBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.Sgt;
  41
  42 /**
  43  * Test for {@link EPPolicyTemplateDaoFacadeImpl}.
  44  */
  45 @RunWith(MockitoJUnitRunner.class)
  46 public class EPPolicyTemplateDaoFacadeImplTest {
  47
  48     private static final Sgt SGT = new Sgt(42);
  49     private static final TenantId TENANT_ID = new TenantId("tenant-01");
  50     private static final EndpointGroupId EPG_ID = new EndpointGroupId("epg-01");
  51     private static final TransactionCommitFailedException TX_EXCEPTION = new TransactionCommitFailedException("unit-txSubmit-error");
  52
  53     @Rule
  54     public ExpectedException thrownRule = ExpectedException.none();
  55
  56     @Mock
  57     private EPPolicyTemplateDaoImpl delegateDao;
  58     @Mock
  59     private SimpleCachedDao<Sgt, EndpointPolicyTemplateBySgt> delegateCachedDao;
  60     @Mock
  61     private DataBroker dataBroker;
  62     @Mock
  63     private EPPolicyTemplateProvider provider;
  64     @Mock
  65     private SgtGeneratorImpl sgtGeneratorImpl;
  66     @Mock
  67     private WriteTransaction wTx;
  68
  69
  70     private EndpointPolicyTemplateBySgtBuilder templateBld;
  71     private EPPolicyTemplateDaoFacadeImpl facade;
  72     private EndpointPolicyTemplateBySgt first;
  73
  74     @Before
  75     public void setUp() throws Exception {
  76         Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture((Void) null));
  77         Mockito.when(dataBroker.newWriteOnlyTransaction()).thenReturn(wTx);
  78         templateBld = new EndpointPolicyTemplateBySgtBuilder()
  79                 .setTenant(TENANT_ID)
  80                 .setSgt(SGT)
  81                 .setEndpointGroups(Collections.singletonList(EPG_ID));
  82
  83         facade = new EPPolicyTemplateDaoFacadeImpl(dataBroker, delegateDao, delegateCachedDao, sgtGeneratorImpl);
  84     }
  85
  86     @Test
  87     public void testRead_trivial() throws Exception {
  88         final EndpointPolicyTemplateBySgt template = templateBld.build();
  89         Mockito.when(delegateDao.read(SGT)).thenReturn(Futures.immediateFuture(Optional.of(template)));
  90
  91         final ListenableFuture<Optional<EndpointPolicyTemplateBySgt>> actual = facade.read(SGT);
  92         Assert.assertTrue(actual.isDone());
  93         Assert.assertTrue(actual.get().isPresent());
  94         Assert.assertEquals(template, actual.get().get());
  95     }
  96
  97     @Test
  98     public void testRead_success() throws Exception {
  99         final EndpointPolicyTemplateBySgt template = templateBld
 100                 .setOrigin(TemplateGenerated.class)
 101                 .build();
 102
 103         Mockito.when(delegateDao.read(SGT)).thenReturn(Futures.immediateFuture(Optional.absent()));
 104         Mockito.when(provider.provideTemplate(SGT)).thenReturn(Futures.immediateFuture(java.util.Optional.of(template)));
 105         Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
 106         facade.setTemplateProvider(provider);
 107
 108
 109         final ListenableFuture<Optional<EndpointPolicyTemplateBySgt>> actual = facade.read(SGT);
 110         Assert.assertTrue(actual.isDone());
 111         Assert.assertTrue(actual.get().isPresent());
 112         Assert.assertEquals(template, actual.get().get());
 113     }
 114
 115     @Test
 116     public void testRead_failNoProvider() throws Exception {
 117         Mockito.when(delegateDao.read(SGT)).thenReturn(Futures.immediateFuture(Optional.absent()));
 118
 119         final ListenableFuture<Optional<EndpointPolicyTemplateBySgt>> actual = facade.read(SGT);
 120         Assert.assertTrue(actual.isDone());
 121         Assert.assertFalse(actual.get().isPresent());
 122     }
 123
 124     @Test
 125     public void testRead_failProviderMiss() throws Exception {
 126         Mockito.when(delegateDao.read(SGT)).thenReturn(Futures.immediateFuture(Optional.absent()));
 127         Mockito.when(provider.provideTemplate(SGT)).thenReturn(Futures.immediateFuture(java.util.Optional.empty()));
 128         facade.setTemplateProvider(provider);
 129
 130
 131         final ListenableFuture<Optional<EndpointPolicyTemplateBySgt>> actual = facade.read(SGT);
 132         Assert.assertTrue(actual.isDone());
 133         Assert.assertFalse(actual.get().isPresent());
 134     }
 135
 136     @Test
 137     public void testRead_failProviderStoreError() throws Exception {
 138         Mockito.when(delegateDao.read(SGT)).thenReturn(Futures.immediateFuture(Optional.absent()));
 139         final EndpointPolicyTemplateBySgt template = templateBld
 140                 .setOrigin(TemplateGenerated.class)
 141                 .build();
 142
 143         Mockito.when(delegateDao.read(SGT)).thenReturn(Futures.immediateFuture(Optional.absent()));
 144         Mockito.when(provider.provideTemplate(SGT)).thenReturn(Futures.immediateFailedCheckedFuture(TX_EXCEPTION));
 145         facade.setTemplateProvider(provider);
 146
 147         final ListenableFuture<Optional<EndpointPolicyTemplateBySgt>> actual = facade.read(SGT);
 148         Assert.assertTrue(actual.isDone());
 149
 150         // prepare exception rule
 151         thrownRule.expect(ExecutionException.class);
 152         thrownRule.expectCause(new BaseMatcher<Throwable>() {
 153             @Override
 154             public boolean matches(final Object item) {
 155                 return TX_EXCEPTION == item;
 156             }
 157
 158             @Override
 159             public void describeTo(final Description description) {
 160                 description.appendText("TransactionCommitFailedException");
 161             }
 162         });
 163         actual.get();
 164     }
 165
 166     @Test
 167     public void testReadBy() throws Exception {
 168         Mockito.when(sgtGeneratorImpl.generateNextSgt(delegateCachedDao))
 169                 .thenReturn(java.util.Optional.empty())
 170                 .thenReturn(java.util.Optional.of(new Sgt(42)));
 171
 172         final EpPolicyTemplateValueKey lookupKey = new EpPolicyTemplateValueKey(TENANT_ID,
 173                 Collections.singletonList(EPG_ID), Collections.emptyList());
 174
 175         final ListenableFuture<Collection<EndpointPolicyTemplateBySgt>> templateFail = facade.readBy(lookupKey);
 176         Assert.assertTrue(templateFail.isDone());
 177         Assert.assertTrue(templateFail.get().isEmpty());
 178
 179         final ListenableFuture<Collection<EndpointPolicyTemplateBySgt>> templateSuccess = facade.readBy(lookupKey);
 180         Assert.assertTrue(templateSuccess.isDone());
 181         final Collection<EndpointPolicyTemplateBySgt> templateBag = templateSuccess.get();
 182         Assert.assertFalse(templateBag.isEmpty());
 183         first = Iterables.getFirst(templateBag, null);
 184         Assert.assertNotNull(templateBag);
 185         Assert.assertEquals(TemplateGenerated.class, first.getOrigin());
 186         Assert.assertEquals(Collections.singletonList(EPG_ID), Iterables.getFirst(templateBag, null).getEndpointGroups());
 187         Assert.assertTrue(Iterables.getFirst(templateBag, null).getConditions().isEmpty());
 188         Assert.assertEquals(42, Iterables.getFirst(templateBag, null).getSgt().getValue().intValue());
 189     }
 190 }