gerrit.opnfv Code Review - moon.git/blob

   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.aaa.authn.mdsal.store;
  10
  11 import static org.mockito.Mockito.mock;
  12 import static org.mockito.Mockito.when;
  13 import com.google.common.base.Optional;
  14 import com.google.common.util.concurrent.CheckedFuture;
  15 import java.util.concurrent.ExecutionException;
  16 import org.opendaylight.aaa.api.IDMStoreUtil;
  17 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  18 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  19 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  20 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  21 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  22 import org.opendaylight.yang.gen.v1.urn.aaa.yang.authn.claims.rev141029.Authentication;
  23 import org.opendaylight.yang.gen.v1.urn.aaa.yang.authn.claims.rev141029.authentication.Domain;
  24 import org.opendaylight.yang.gen.v1.urn.aaa.yang.authn.claims.rev141029.authentication.DomainBuilder;
  25 import org.opendaylight.yang.gen.v1.urn.aaa.yang.authn.claims.rev141029.authentication.DomainKey;
  26 import org.opendaylight.yang.gen.v1.urn.aaa.yang.authn.claims.rev141029.authentication.Grant;
  27 import org.opendaylight.yang.gen.v1.urn.aaa.yang.authn.claims.rev141029.authentication.GrantBuilder;
  28 import org.opendaylight.yang.gen.v1.urn.aaa.yang.authn.claims.rev141029.authentication.GrantKey;
  29 import org.opendaylight.yang.gen.v1.urn.aaa.yang.authn.claims.rev141029.authentication.Role;
  30 import org.opendaylight.yang.gen.v1.urn.aaa.yang.authn.claims.rev141029.authentication.RoleBuilder;
  31 import org.opendaylight.yang.gen.v1.urn.aaa.yang.authn.claims.rev141029.authentication.RoleKey;
  32 import org.opendaylight.yang.gen.v1.urn.aaa.yang.authn.claims.rev141029.authentication.User;
  33 import org.opendaylight.yang.gen.v1.urn.aaa.yang.authn.claims.rev141029.authentication.UserBuilder;
  34 import org.opendaylight.yang.gen.v1.urn.aaa.yang.authn.claims.rev141029.authentication.UserKey;
  35 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  36
  37 public class IDMStoreTestUtil {
  38     /* DataBroker mocked with Mokito */
  39     protected static DataBroker dataBroker = mock(DataBroker.class);
  40     protected static WriteTransaction wrt = mock(WriteTransaction.class);
  41     protected static ReadOnlyTransaction rot = null;
  42
  43     static {
  44         rot = (ReadOnlyTransaction) DataBrokerReadMocker.addMock(ReadOnlyTransaction.class);
  45         when(dataBroker.newReadOnlyTransaction()).thenReturn(rot);
  46         when(dataBroker.newWriteOnlyTransaction()).thenReturn(wrt);
  47     }
  48
  49     /* Domain Data Object Instance */
  50     public Domain domain = createdomain();
  51
  52     /* Domain create Method */
  53     public Domain createdomain() {
  54         /* Start of Domain builder */
  55         DomainBuilder domainbuilder = new DomainBuilder();
  56         domainbuilder.setName("SETNAME");
  57         domainbuilder.setDomainid("SETNAME");
  58         domainbuilder.setKey(new DomainKey("SETNAME"));
  59         domainbuilder.setDescription("SETDESCRIPTION");
  60         domainbuilder.setEnabled(true);
  61         /* End of Domain builder */
  62         return domainbuilder.build();
  63     }
  64
  65     /* Role Data Object Instance */
  66     public Role role = createrole();
  67
  68     /* Role create Method */
  69     public Role createrole() {
  70         /* Start of Role builder */
  71         RoleBuilder rolebuilder = new RoleBuilder();
  72         rolebuilder.setRoleid("SETNAME@SETNAME");
  73         rolebuilder.setName("SETNAME");
  74         rolebuilder.setKey(new RoleKey(rolebuilder.getRoleid()));
  75         rolebuilder.setDomainid(createdomain().getDomainid());
  76         rolebuilder.setDescription("SETDESCRIPTION");
  77         /* End of Role builder */
  78         return rolebuilder.build();
  79     }
  80
  81     /* User Data Object Instance */
  82     public User user = createuser();
  83
  84     /* User create Method */
  85     public User createuser() {
  86         /* Start of User builder */
  87         UserBuilder userbuilder = new UserBuilder();
  88         userbuilder.setUserid("SETNAME@SETNAME");
  89         userbuilder.setName("SETNAME");
  90         userbuilder.setKey(new UserKey(userbuilder.getUserid()));
  91         userbuilder.setDomainid(createdomain().getDomainid());
  92         userbuilder.setEmail("SETEMAIL");
  93         userbuilder.setPassword("SETPASSWORD");
  94         userbuilder.setSalt("SETSALT");
  95         userbuilder.setEnabled(true);
  96         userbuilder.setDescription("SETDESCRIPTION");
  97         /* End of User builder */
  98         return userbuilder.build();
  99     }
 100
 101     /* Grant Data Object Instance */
 102     public Grant grant = creategrant();
 103
 104     /* Grant create Method */
 105     public Grant creategrant() {
 106         /* Start of Grant builder */
 107         GrantBuilder grantbuilder = new GrantBuilder();
 108         grantbuilder.setDomainid(createdomain().getDomainid());
 109         grantbuilder.setRoleid(createrole().getRoleid());
 110         grantbuilder.setUserid(createuser().getUserid());
 111         grantbuilder.setGrantid(IDMStoreUtil.createGrantid(grantbuilder.getUserid(),
 112                 grantbuilder.getDomainid(), grantbuilder.getRoleid()));
 113         grantbuilder.setKey(new GrantKey(grantbuilder.getGrantid()));
 114         /* End of Grant builder */
 115         return grantbuilder.build();
 116     }
 117
 118     /* InstanceIdentifier for Grant instance grant */
 119     public InstanceIdentifier<Grant> grantID = InstanceIdentifier.create(Authentication.class)
 120                                                                  .child(Grant.class,
 121                                                                          creategrant().getKey());
 122
 123     /* Mokito DataBroker method for grant Data Object */
 124     public void addMokitoForgrant() throws NoSuchMethodException, SecurityException, InterruptedException, ExecutionException {
 125         CheckedFuture<Optional<Grant>, ReadFailedException> read = mock(CheckedFuture.class);
 126         DataBrokerReadMocker.getMocker(rot).addWhen("read",
 127                 new Object[] { LogicalDatastoreType.CONFIGURATION, grantID }, read);
 128         Optional<Grant> optional = mock(Optional.class);
 129         when(read.get()).thenReturn(optional);
 130         when(optional.get()).thenReturn(grant);
 131         when(optional.isPresent()).thenReturn(true);
 132     }
 133
 134     /* InstanceIdentifier for Domain instance domain */
 135     public InstanceIdentifier<Domain> domainID = InstanceIdentifier.create(Authentication.class)
 136                                                                    .child(Domain.class,
 137                                                                            new DomainKey(
 138                                                                                    new String(
 139                                                                                            "SETNAME")));
 140
 141     /* Mokito DataBroker method for domain Data Object */
 142     public void addMokitoFordomain() throws NoSuchMethodException, SecurityException, InterruptedException, ExecutionException {
 143         CheckedFuture<Optional<Domain>, ReadFailedException> read = mock(CheckedFuture.class);
 144         DataBrokerReadMocker.getMocker(rot).addWhen("read",
 145                 new Object[] { LogicalDatastoreType.CONFIGURATION, domainID }, read);
 146         Optional<Domain> optional = mock(Optional.class);
 147         when(read.get()).thenReturn(optional);
 148         when(optional.get()).thenReturn(domain);
 149         when(optional.isPresent()).thenReturn(true);
 150     }
 151
 152     /* InstanceIdentifier for Role instance role */
 153     public InstanceIdentifier<Role> roleID = InstanceIdentifier.create(Authentication.class).child(
 154             Role.class, createrole().getKey());
 155
 156     /* Mokito DataBroker method for role Data Object */
 157     public void addMokitoForrole() throws NoSuchMethodException, SecurityException, InterruptedException, ExecutionException {
 158         CheckedFuture<Optional<Role>, ReadFailedException> read = mock(CheckedFuture.class);
 159         DataBrokerReadMocker.getMocker(rot).addWhen("read",
 160                 new Object[] { LogicalDatastoreType.CONFIGURATION, roleID }, read);
 161         Optional<Role> optional = mock(Optional.class);
 162         when(read.get()).thenReturn(optional);
 163         when(optional.get()).thenReturn(role);
 164         when(optional.isPresent()).thenReturn(true);
 165     }
 166
 167     /* InstanceIdentifier for User instance user */
 168     public InstanceIdentifier<User> userID = InstanceIdentifier.create(Authentication.class).child(
 169             User.class, createuser().getKey());
 170
 171     /* Mokito DataBroker method for user Data Object */
 172     public void addMokitoForuser() throws NoSuchMethodException, SecurityException, InterruptedException, ExecutionException {
 173         CheckedFuture<Optional<User>, ReadFailedException> read = mock(CheckedFuture.class);
 174         DataBrokerReadMocker.getMocker(rot).addWhen("read",
 175                 new Object[] { LogicalDatastoreType.CONFIGURATION, userID }, read);
 176         Optional<User> optional = mock(Optional.class);
 177         when(read.get()).thenReturn(optional);
 178         when(optional.get()).thenReturn(user);
 179         when(optional.isPresent()).thenReturn(true);
 180     }
 181 }