Java easymock预期不工作，仍在调用实际方法

我想测试

MessageProcessor1.listAllKeyword

方法，它依次 调用

HbaseUtil1.getAllKeyword

方法。首先，我必须处理与静态初始值设定项和构造函数相关的问题。问题是初始化HBASE DB连接。我使用powerMock来抑制静态调用和构造函数调用，效果很好

尽管我模拟了

HbaseUtil1.getAllKeyword

方法，但实际方法正在被调用并执行所有HBase代码，导致异常，其中HBase服务器未启动。

EasyMock.expect（hbaseUtil.getAllKeyword（“msg”、“u1”））.andReturn（expectedList）

请告诉我如何避免实际的方法调用。我尝试了很多方法，但都不管用

public class MessageProcessor1 
{
    private static Logger logger = Logger.getLogger("MQ-Processor");
    private final static String CLASS_NAME = "MessageProcessor";
    private static boolean keywordsTableExists = false;
    public static PropertiesLoader props;
    HbaseUtil1 hbaseUtil;
    /**
     * For checking if table exists in HBase. If doesn't exists, will create a
     * new table. This runs only once when class is loaded.
     */
    static {
        props = new PropertiesLoader();
        String[] userTablefamilys = {
                props.getProperty(Constants.COLUMN_FAMILY_NAME_COMMON_KEYWORDS),
                props.getProperty(Constants.COLUMN_FAMILY_NAME_USER_KEYWORDS) };
        keywordsTableExists = new HbaseUtil()
        .creatTable(props.getProperty(Constants.HBASE_TABLE_NAME),
                userTablefamilys);
    }

    /**
     * This will load new configuration every time this class instantiated.
     */
    {
        props = new PropertiesLoader();
    }

    public String listAllKeyword(String userId) throws IOException {
        HbaseUtil1 util = new HbaseUtil1();
        Map<String, List<String>> projKeyMap = new HashMap<String, List<String>>();
        //logger.info(CLASS_NAME+": inside listAllKeyword method");
        //logger.debug("passed id : "+userId);
        List<String> qualifiers = util.getAllKeyword("msg", userId);

        List<String> keywords = null;
        for (String qualifier : qualifiers) {
            String[] token = qualifier.split(":");

            if (projKeyMap.containsKey(token[0])) {
                projKeyMap.get(token[0]).add(token[1]);
            } else {
                keywords = new ArrayList<String>();
                keywords.add(token[1]);
                projKeyMap.put(token[0], keywords);
            }
        }

        List<Project> projects = buildProject(projKeyMap);
        Gson gson = new GsonBuilder().excludeFieldsWithoutExposeAnnotation()
                .create();
        System.out.println("Json projects:::" + gson.toJson(projects));
        //logger.debug("list all keyword based on project::::"+ gson.toJson(projects));
        //return gson.toJson(projects);
        return "raj";
    }

    private List<Project> buildProject(Map<String, List<String>> projKeyMap) {

        List<Project> projects = new ArrayList<Project>();
        Project proj = null;
        Set<String> keySet = projKeyMap.keySet();
        for (String hKey : keySet) {
            proj = new Project(hKey, projKeyMap.get(hKey));
            projects.add(proj);

        }
        return projects;
    }

    //@Autowired
    //@Qualifier("hbaseUtil1")
    public void setHbaseUtil(HbaseUtil1 hbaseUtil) {
        this.hbaseUtil = hbaseUtil;
    }

}



public class HbaseUtil1 {

    private static Logger logger = Logger.getLogger("MQ-Processor");
    private final static String CLASS_NAME = "HbaseUtil";
    private static Configuration conf = null;

    public HbaseUtil1() {
        PropertiesLoader props = new PropertiesLoader();
        conf = HBaseConfiguration.create();
        conf.set(HConstants.ZOOKEEPER_QUORUM, props
                .getProperty(Constants.HBASE_CONFIGURATION_ZOOKEEPER_QUORUM));
        conf.set(
                HConstants.ZOOKEEPER_CLIENT_PORT,
                props.getProperty(Constants.HBASE_CONFIGURATION_ZOOKEEPER_CLIENT_PORT));
        conf.set("hbase.zookeeper.quorum", props
                .getProperty(Constants.HBASE_CONFIGURATION_ZOOKEEPER_QUORUM));
        conf.set(
                "hbase.zookeeper.property.clientPort",
                props.getProperty(Constants.HBASE_CONFIGURATION_ZOOKEEPER_CLIENT_PORT));
    }

    public List<String> getAllKeyword(String tableName, String rowKey)
            throws IOException {
        List<String> qualifiers = new ArrayList<String>();
        HTable table = new HTable(conf, tableName);
        Get get = new Get(rowKey.getBytes());
        Result rs = table.get(get);

        for (KeyValue kv : rs.raw()) {

            System.out.println("KV: " + kv + ", keyword: "
                    + Bytes.toString(kv.getRow()) + ", quaifier: "
                    + Bytes.toString(kv.getQualifier()) + ", family: "
                    + Bytes.toString(kv.getFamily()) + ", value: "
                    + Bytes.toString(kv.getValue()));
            qualifiers.add(new String(kv.getQualifier()));
        }
        table.close();
        return qualifiers;

    }
    /**
     * Create a table
     * 
     * @param tableName
     *            name of table to be created.
     * @param familys
     *            Array of the name of column families to be created with table
     * @throws IOException
     */
    public boolean creatTable(String tableName, String[] familys) {
        HBaseAdmin admin = null;
        boolean tableCreated = false;
        try {
            admin = new HBaseAdmin(conf);
            if (!admin.tableExists(tableName)) {
                HTableDescriptor tableDesc = new HTableDescriptor(tableName);
                for (int i = 0; i < familys.length; i++) {
                    tableDesc.addFamily(new HColumnDescriptor(familys[i]));
                }
                admin.createTable(tableDesc);
                System.out.println("create table " + tableName + " ok.");
            }
            tableCreated = true;
            admin.close();
        } catch (MasterNotRunningException e1) {
            e1.printStackTrace();
        } catch (ZooKeeperConnectionException e1) {
            e1.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return tableCreated;
    }

}

Below is my Test class.

@RunWith(PowerMockRunner.class)
@PrepareForTest(MessageProcessor1.class)
@SuppressStaticInitializationFor("com.serendio.msg.mqProcessor.MessageProcessor1")
public class MessageProcessorTest1 {

    private MessageProcessor1 messageProcessor;
    private HbaseUtil1 hbaseUtil;

    @Before
    public void setUp() {
        messageProcessor = new MessageProcessor1();
        hbaseUtil = EasyMock.createMock(HbaseUtil1.class);
    }


    @Test
    public void testListAllKeyword(){
        List<String> expectedList = new ArrayList<String>();
        expectedList.add("raj:abc");
        suppress(constructor(HbaseUtil1.class));
        //suppress(method(HbaseUtil1.class, "getAllKeyword"));

        try {
            EasyMock.expect(hbaseUtil.getAllKeyword("msg", "u1")).andReturn(expectedList);
            EasyMock.replay();
            assertEquals("raj", messageProcessor.listAllKeyword("u1"));
        } catch (IOException e) {
            e.printStackTrace();
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}

公共类消息处理器1
{
私有静态记录器=Logger.getLogger（“MQ处理器”）；
私有最终静态字符串CLASS_NAME=“MessageProcessor”；
私有静态布尔关键字StableExists=false；
公共静态属性加载程序道具；
hbaseUtil 1 hbaseUtil；
/**
*用于检查HBase中是否存在表。如果不存在，将创建
*新表。加载类时仅运行一次。
*/
静止的{
props=新属性加载器（）；
字符串[]userTablefamilys={
props.getProperty（常量、列、族、名称、常用关键字），
getProperty（常量.列\族\名\用户\关键字）}；
关键字StableExists=newHBaseutil（）
.createTable（props.getProperty（Constants.HBASE\u TABLE\u NAME），
用户表（家庭）；
}
/**
*这将在每次实例化该类时加载新配置。
*/
{
props=新属性加载器（）；
}
公共字符串listAllKeyword（字符串用户ID）引发IOException{
HbaseUtil1 util=新的HbaseUtil1（）；
Map projKeyMap=newhashmap（）；
//info（CLASS_NAME+“：inside listalKeyword方法”）；
//debug（“传递id:+userId”）；
列表限定符=util.getAllKeyword（“msg”，userId）；
列表关键字=null；
for（字符串限定符：限定符）{
字符串[]标记=限定符。拆分（：“”）；
if（projKeyMap.containsKey（令牌[0]））{
projKeyMap.get（令牌[0]）.add（令牌[1]）；
}否则{
关键词=新ArrayList（）；
关键词.add（令牌[1]）；
projKeyMap.put（令牌[0]，关键字）；
}
}
列表项目=构建项目（projKeyMap）；
Gson Gson=new GsonBuilder（）.excludeFieldsWithoutExposeAnnotation（）
.create（）；
System.out.println（“Json项目：：”+gson.toJson（项目））；
//debug（“根据项目列出所有关键字：”+gson.toJson（项目））；
//返回gson.toJson（项目）；
返回“raj”；
}
私有列表构建项目（Map projKeyMap）{
列表项目=新建ArrayList（）；
proj=null；
Set keySet=projKeyMap.keySet（）；
for（字符串hKey:keySet）{
proj=新项目（hKey，projKeyMap.get（hKey））；
项目.增加（项目）；
}
返回项目；
}
//@自动连线
//@限定符（“hbaseUtil1”）
公共无效设置hbaseUtil（HbaseUtil1 hbaseUtil）{
this.hbaseUtil=hbaseUtil；
}
}
公共类HbaseUtil1{
私有静态记录器=Logger.getLogger（“MQ处理器”）；
私有最终静态字符串CLASS_NAME=“HbaseUtil”；
私有静态配置conf=null；
公共HbaseUtil1（）{
PropertiesLoader props=新的PropertiesLoader（）；
conf=HBaseConfiguration.create（）；
conf.set（HConstants.ZOOKEEPER_QUORUM，道具
.getProperty（Constants.HBASE\u CONFIGURATION\u zoockeeper\u QUORUM））；
形态集合(
HConstants.ZOOKEEPER\u客户端\u端口，
getProperty（Constants.HBASE_配置_ZOOKEEPER_客户端_端口））；
conf.set（“hbase.zookeeper.quorum”），道具
.getProperty（Constants.HBASE\u CONFIGURATION\u zoockeeper\u QUORUM））；
形态集合(
“hbase.zookeeper.property.clientPort”，
getProperty（Constants.HBASE_配置_ZOOKEEPER_客户端_端口））；
}
公共列表getAllKeyword（字符串表名、字符串行键）
抛出IOException{
列表限定符=新的ArrayList（）；
HTable table=新的HTable（conf，tableName）；
Get=newget（rowKey.getBytes（））；
结果rs=table.get（get）；
对于（键值kv:rs.raw（））{
System.out.println（“KV:+KV+”，关键字：
+Bytes.toString（kv.getRow（））+“，Quaizer:”
+Bytes.toString（kv.getQualifier（））+“，族：”
+Bytes.toString（kv.getFamily（））+“，值：”
+toString（kv.getValue（））；
add（新字符串（kv.getQualifier（））；
}
table.close（）；
返回限定符；
}
/**
*创建一个表
* 
*@param tableName
*要创建的表的名称。
*@param familys
*要使用表创建的列族名称的数组
*@抛出异常
*/
公共布尔表（字符串表名，字符串[]族）{
HBaseAdmin admin=null；
布尔tableCreated=false；
试一试{
admin=新的HBaseAdmin（conf）；
如果（！admin.tableExists（tableName））{
HTableDescriptor tableDesc=新的HTableDescriptor（tableName）；
对于（int i=0；i public String listAllKeyword(String userId) throws IOException {
     HbaseUtil1 util = new HbaseUtil1();
     ...