java Mockito验证抽象方法

我在验证对被测类的方法的调用时遇到了一个问题，使用verify（）方法它告诉我们没有对该方法进行调用，该方法在超类（loadFile（String））中定义为抽象

查找以下代码：

public abstract class FileParser {
public Iterator<String> loadFile(FileSettingsToSend fileSetting) {

        System.out.println("file before staged");
        try {
        if(!movFile("staged",fileSetting)) 
             return null;
        System.out.println("file after move "+fileSetting.getFile().getAbsolutePath());
        boolean isValidFormatFile = fileValidator.checkFileFormat(fileSetting);
        if (!isValidFormatFile) {
            System.out.println("file format is not valid");
            return null;
        }

            return readBlock(fileSetting);
        } catch (Exception e) {
            System.out.println(e.getMessage());
            return null;
        } finally {

        }

        //return null;
    }

    public abstract Iterator<String> readBlock(FileSettingsToSend fileSettingsToSend)
            throws JsonProcessingException, IOException;
}

public  class JsonFileParser extends FileParser {

    public final ObjectMapper mapper = new ObjectMapper();

    @Autowired
    public JsonFileParser(FileValidator jsonFileValidatorService, FileAttributeService fileAttributeService) {
        super(jsonFileValidatorService, fileAttributeService);
    }

    @Override
    public Iterator<String> readBlock(FileSettingsToSend fileSetting) throws JsonProcessingException, IOException {
        ObjectMapper mapper = new ObjectMapper();
        System.out.println("inside readBlock json implementation");
        List<String> listAttribute = fileAttributeService.getAttributes(fileSetting.getDiretoryPath());
        String[] blocDelimitor = fileAttributeService.getDelimitorRepositpry(fileSetting.getDiretoryPath());
        System.out.println("after validator");
        final JsonNode root = mapper.readTree(fileSetting.getFile());
        if (root == null)
            return null;
        Iterator<JsonNode> nodeIterator = root.elements();
        System.out.println("Data is " + root);
        return new Iterator<String>() {
            JsonNode node;

            @Override
            public boolean hasNext() {

                return nodeIterator.hasNext();
            }

            @Override
            public String next() {
                int i = 0;
                node = nodeIterator.next();
                System.out.println("after nex " + node.toString());
                Arrays.stream(blocDelimitor).forEach(e -> {
                    node = node.path(e);
                    System.out.println("inside next " + node.toString());
                });
                String result = null;
                if (node.isArray()) {
                    System.out.println("It is Array");
                    for (JsonNode node1 : node) {

                        if (i != 0)
                            result = result + "," + listAttribute.stream().map(e -> e + "=" + node1.get(e))
                                    .collect(Collectors.joining(","));
                        else
                            result = listAttribute.stream().map(e -> e + "=" + node1.get(e))
                                    .collect(Collectors.joining(","));
                        i++;
                    }
                } else
                    result = listAttribute.stream().map(e -> e + "=" + node.get(e)).collect(Collectors.joining(","));
                return result;
            }

        };

    }

行verify（jsonFileParser，times（1））.readBlock（anyObject（）；返回false；表示未调用jsonFileParser的loadFile方法 你能告诉我为什么不打电话吗。

---

谢谢。

发生这种情况是因为您在创建

JsonFileParser

之后初始化了mock。请注意，

@Before

方法是在初始化测试类的所有字段之后执行的

因此，您将

null

依赖项传递给类。对

null

FileValidator

的调用会抛出

NullPointerException

，但您会在catch块中吞下它

通常，建议验证传递给构造函数和方法的参数，以便在出现错误时快速失败。例如，Java提供了一个方便的方法来验证传递的参数是否为非null

类似地，吞下每一个异常通常是一种不好的做法。例如，在您的示例中，您希望抛出

IOException

和

JsonProcessingException

。最好显式捕获这些异常，并让程序崩溃（或至少记录一条警告）

---

最后，模拟和间谍很容易被过度使用。通常，使用界面的伪实现就足够了。根据您对代码的控制程度，您可能还希望对其进行重构，以避免使用间谍。在您可以自由更改的代码中使用间谍可能表明存在架构问题。

谢谢您的回答，我想我不明白你关于重构我的代码的回答，你的意思是在单独的类中分离movFile方法以避免间谍？如果是，分离此方法还有其他好处吗？关于异常，我希望由另一个类（层）处理，特别是在控制层中处理

    @Mock
    FileValidator jsonFileValidatorService;
    @Mock
    FileAttributeService fileAttributeService;
    JsonFileParser jsonFileParserMock = new JsonFileParser(jsonFileValidatorService, fileAttributeService);

    @Test
    public void validatorNotTrue() throws JsonProcessingException, IOException{

        when(jsonFileValidatorService.checkFileFormat( anyObject() )).thenReturn(true);
        JsonFileParser jsonFileParser  = Mockito.spy(jsonFileParserMock);
        doReturn(true).when(jsonFileParser).movFile(anyString(),anyObject() );
        assertNull(jsonFileParser.loadFile(null));

        verify(jsonFileParser, times(1)).movFile(anyString(),anyObject());
        assertTrue(jsonFileParser.movFile(anyString(), anyObject()));
        assertTrue(jsonFileValidatorService.checkFileFormat( anyObject() ));

        //exception.expect(Exception.class);
        verify(jsonFileParser,times(1)).readBlock(anyObject();

    }

    @BeforeClass
    public static  void settingUp(){

    }

    @Before
    public void initMock(){
        MockitoAnnotations.initMocks(this);
    }