模拟类和接口

如何解决模拟类和接口

您好，到目前为止，我一直在尝试在测试中使用模仿。这是我的问题：我可以模拟一个接口，以便实现该接口的每个类的行为都与模拟中描述的一样吗？

这是我正在测试的方法：

public static boolean initNewCluster(ServerConfiguration conf) throws Exception {
    return runFunctionWithRegistrationManager(conf,rm -> {
        try {
            return rm.initNewCluster();
        } catch (Exception e) {
            System.out.println("MOCK WORKS!!! \n");
            throw new UncheckedExecutionException(e.getMessage(),e);
        }
    });
}

我需要模拟调用rm.initNewCluster（）。现在，这是使用initNewCluster（）作为方法的接口：

@LimitedPrivate
@Evolving
public interface RegistrationManager extends AutoCloseable {

    

    /**
     * Initializes new cluster by creating required znodes for the cluster. If
     * ledgersrootpath is already existing then it will error out.
     *
     * @return returns true if new cluster is successfully created or false if it failed to initialize.
     * @throws Exception
     */

    boolean initNewCluster() throws Exception;

这是实现此接口的类：

    /**
     * ZooKeeper Based {@link RegistrationManager}.
     */
    @Slf4j
    public class ZKRegistrationManager implements RegistrationManager {
    
        private static final Function<Throwable,BKException> EXCEPTION_FUNC = cause -> {
            if (cause instanceof BKException) {
                log.error("Failed to get bookie list : ",cause);
                return (BKException) cause;
            } else if (cause instanceof InterruptedException) {
                log.error("Interrupted reading bookie list : ",cause);
                return new BKInterruptedException();
            } else {
                return new MetaStoreException();
            }
        };
    
        private final ServerConfiguration conf;
        private final ZooKeeper zk;
        private final List<ACL> zkAcls;
        private final LayoutManager layoutManager;
    
        private volatile boolean zkRegManagerInitialized = false;
    
        // ledgers root path
        private final String ledgersRootPath;
        // cookie path
        private final String cookiePath;
        // registration paths
        protected final String bookieRegistrationPath;
        protected final String bookieReadonlyRegistrationPath;
        // session timeout in milliseconds
        private final int zkTimeoutMs;
    
        public ZKRegistrationManager(ServerConfiguration conf,ZooKeeper zk,RegistrationListener listener) {
            this(conf,zk,ZKMetadataDriverBase.resolveZkLedgersRootPath(conf),listener);
        }
    
        public ZKRegistrationManager(ServerConfiguration conf,String ledgersRootPath,RegistrationListener listener) {
            this.conf = conf;
            this.zk = zk;
            this.zkAcls = ZkUtils.getACLs(conf);
            this.ledgersRootPath = ledgersRootPath;
            this.cookiePath = ledgersRootPath + "/" + COOKIE_NODE;
            this.bookieRegistrationPath = ledgersRootPath + "/" + AVAILABLE_NODE;
            this.bookieReadonlyRegistrationPath = this.bookieRegistrationPath + "/" + READONLY;
            this.zkTimeoutMs = conf.getZkTimeout();
    
            this.layoutManager = new ZkLayoutManager(
                zk,ledgersRootPath,zkAcls);
    
            this.zk.register(event -> {
                if (!zkRegManagerInitialized) {
                    // do nothing until first registration
                    return;
                }
                // Check for expired connection.
                if (event.getType().equals(EventType.None)
                    && event.getState().equals(KeeperState.Expired)) {
                    listener.onRegistrationExpired();
                }
            });
        }
    
.
.
.
.
.
.
    
    
       
    
        @Override
        public boolean initNewCluster() throws Exception {
            System.out.println("I have been called ! \n");
            String zkServers = ZKMetadataDriverBase.resolveZkServers(conf);
            String instanceIdPath = ledgersRootPath + "/" + INSTANCEID;
            log.info("Initializing ZooKeeper metadata for new cluster,ZKServers: {} ledger root path: {}",zkServers,ledgersRootPath);
    
            boolean ledgerRootExists = null != zk.exists(ledgersRootPath,false);
    
            if (ledgerRootExists) {
                log.error("Ledger root path: {} already exists",ledgersRootPath);
                return false;
            }
    
            List<Op> multiOps = Lists.newArrayListWithExpectedSize(4);
    
            // Create ledgers root node
            multiOps.add(Op.create(ledgersRootPath,EMPTY_BYTE_ARRAY,zkAcls,CreateMode.PERSISTENT));
    
            // create available bookies node
            multiOps.add(Op.create(bookieRegistrationPath,CreateMode.PERSISTENT));
    
            // create readonly bookies node
            multiOps.add(Op.create(
                bookieReadonlyRegistrationPath,CreateMode.PERSISTENT));
    
            // create INSTANCEID
            String instanceId = UUID.randomUUID().toString();
            multiOps.add(Op.create(instanceIdPath,instanceId.getBytes(UTF_8),CreateMode.PERSISTENT));
    
            // execute the multi ops
            zk.multi(multiOps);
    
            // creates the new layout and stores in zookeeper
            AbstractZkLedgerManagerFactory.newLedgerManagerFactory(conf,layoutManager);
    
            log.info("Successfully initiated cluster. ZKServers: {} ledger root path: {} instanceId: {}",instanceId);
            return true;
        }
    
        
    }

这是我的考试课：

package org.apache.bookkeeper.client;


import org.apache.bookkeeper.conf.ServerConfiguration;
import org.apache.bookkeeper.discover.RegistrationManager;
import org.apache.bookkeeper.discover.ZKRegistrationManager;
import org.apache.bookkeeper.meta.LayoutManager;
import org.apache.bookkeeper.test.BookKeeperClusterTestCase;
import org.apache.bookkeeper.test.ZooKeeperCluster;
import org.apache.bookkeeper.test.ZooKeeperUtil;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.ACL;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.mockito.InjectMocks;
import org.mockito.Mock;



import java.util.Arrays;
import java.util.Collection;
import java.util.List;

import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;


@RunWith(value= Parameterized.class)
public class BookKeeperAdminInitNewClusterTest extends BookKeeperClusterTestCase {

    private boolean result;
    private ServerConfiguration conf;
    private String confType ;

    private static final int numOfBookies = 2;
    private final int lostBookieRecoveryDelayInitValue = 1800;


    @Mock
    RegistrationManager mockedRM = mock(RegistrationManager.class) ;
  


    @Parameterized.Parameters
    public static Collection<Object[]> getTestParameters(){
        return Arrays.asList(new Object[][]{

                //last parameter states if the method rm.initNewCluster() called inside
                // BookKeeperAdmin.initNewCluster(conf) must be mocked or not

                //{true,"new" },//{false,"null" },"wrong"},{false,"mock"},//caso di test introdotto per portare la branch coverage al 100%
                                    // entrando nella clausola catch del metodo initNewCluste()

        });

    }



    public BookKeeperAdminInitNewClusterTest(boolean result,String conf) throws Exception {

        super(numOfBookies,480);
        baseConf.setLostBookieRecoveryDelay(lostBookieRecoveryDelayInitValue);
        baseConf.setOpenLedgerRereplicationGracePeriod(String.valueOf(30000));
        setAutoRecoveryEnabled(true);

        this.result = result;
        this.confType = conf;


    }

    @Test
    public void testInitNewCluster() throws Exception {

        boolean realResult ;


        if(confType == "null"){

            this.conf = null;

        }else if( confType == "wrong"){

            this.conf = new ServerConfiguration().setMetadataServiceUri("zk+hierarchical://127.0.0.1/ledgers");

        }else if(confType == "new") {

            this.conf = new ServerConfiguration(baseConf);
            String ledgersRootPath = "/testledgers";
            this.conf.setMetadataServiceUri(newMetadataServiceUri(ledgersRootPath));

        }else if(confType == "mock"){



            this.conf = new ServerConfiguration(baseConf);
            String ledgersRootPath = "/testledgers";
            this.conf.setMetadataServiceUri(newMetadataServiceUri(ledgersRootPath));
   

            when(mockedRM.initNewCluster()).thenThrow(new Exception());



        }


        try {

            realResult = BookKeeperAdmin.initNewCluster(conf);

        } catch (Exception e) {
            realResult = false ;
            e.printStackTrace();

        }
        assertEquals(result,realResult);
    }

}`

问题是当BookKeeperAdmin.initNewCluster（conf）被调用时，它导致实现方法initNewCluster（）的调用，而不是我嘲笑的那个！希望大家能帮忙，大家好！

如何解决模拟类和接口

相关推荐