0

Mockito モッキング ライブラリに問題があります

2 つのテスト スイートを含む私の Junit4 テスト クラス。

テスト 1:

@Test
public void test1()
{
   Class class = new Class();
   Class classSpy = Mockito.spy(class);
   Mockito.when( classSpy.getExpectedValue()).thenReturn("expected_one");
}

そして2番目のテスト：

@Test
public void test2()
{
    Class class = new Class();
    Class classSpy = Mockito.spy(class);
    Mockito.when( classSpy.getExpectedValue()).thenReturn("expected_two");
}

そして私はテスト可能なクラスを持っています:

public class TestableClass
{
    x = class.getExpectedValue();
    //some code
}

問題は次のとおりです。

1 - テスト クラスを実行しtest1()、test2() 最初にtest1() デバッガを実行すると、x = "expected_one" すべて問題ないことが示されます - これは予期される動作です

2 - test2 が実行されています。テスト可能なクラスの x.. の行にブレークポイントを置き、x = "expected_one"

Mockito は、classSpy両方のテストでスパイ オブジェクト ( ) に同じ参照を使用しているようです。

助けてくれてありがとう

PS：私はmockito 1.9.0とjre 6.0.370.6を使用しています

ps:私は通常のセットアップ方法を持っています:

@Before
public void setUp(){

    testableClass = new TestableClass();
}

PS3: 完全なテスト スイート:

package xxx;

import java.io.File;
import java.io.IOException;

import junit.framework.Assert;

import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.mockito.Mockito;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import xxx.testdata.JUnitConstants;
import xxx.testdata.JUnitUtils;
import xxx.testdata.MockNode;


@SuppressWarnings( "deprecation" )
public class MONodeModifierTest
{

    private MONodeModifier moNodeModifier;
    private Document doc;
    static File file;



    @Before
    public void setUp(){

        doc = JUnitUtils.CreateXMLDocumentFromFile(file);
        moNodeModifier = new MONodeModifier(doc);
    }


    @Test
    public void createNodeTest(){

        Node inputMoNode = new MockNode();

        boolean nodeisCreated = moNodeModifier.createMONode( inputMoNode, doc );
        Assert.assertTrue(nodeisCreated);
    }

    @Test
    public void removeNodeTest(){

        final Node inputMoNode = new MockNode();
        NodeList nodeList = new NodeList(){

            @Override
            public Node item( int index )
            {
                return inputMoNode;
            }

            @Override
            public int getLength()
            {
                return 1;
            }};

        boolean nodeisRemoved = moNodeModifier.removeMONode( inputMoNode,nodeList );
        Assert.assertTrue(nodeisRemoved);
    }

    @Test
    public void updateMONodeWithPname(){

        Node node = new MockNode();
        NodeList nodeListMock = Mockito.mock( NodeList.class );
        Node nodeSpy = Mockito.spy(node);
        Mockito.when( nodeSpy.getChildNodes()).thenReturn( nodeListMock);
        Mockito.when( nodeSpy.getNodeName()).thenReturn( "p");

        Mockito.when( nodeListMock.getLength()).thenReturn( 1);
        Mockito.when( nodeListMock.item(Mockito.anyInt())).thenReturn( nodeSpy);

        boolean nodeisUpdated = moNodeModifier.updateMONode( nodeSpy, nodeListMock );
        Assert.assertTrue(nodeisUpdated);

        Mockito.verify( nodeSpy).setTextContent(Mockito.anyString());
    }

    @Test
    public void updateMONodeWithNonEmptyListName(){

        Node node = new MockNode();
        NodeList nodeListMock = Mockito.mock( NodeList.class );
        Node nodeSpy = Mockito.spy(node);
        Mockito.when( nodeSpy.getChildNodes()).thenReturn( nodeListMock);
        Mockito.when( nodeSpy.getNodeName()).thenReturn( "list");

        Mockito.when( nodeListMock.getLength()).thenReturn( 1).thenReturn( 1);
        Mockito.when( nodeListMock.item(Mockito.anyInt())).thenReturn( nodeSpy);


        boolean nodeisUpdated = moNodeModifier.updateMONode( nodeSpy, nodeListMock );
        Assert.assertTrue(nodeisUpdated);

        Mockito.verify( nodeSpy).replaceChild(Mockito.any(Node.class),Mockito.any(Node.class));
    }

    @Test
    public void updateNonExistMONodeType(){

        Node node = new MockNode();
        Node nodeSpy = Mockito.spy(node);

        NodeList nodeListMock = Mockito.mock( NodeList.class );

        Mockito.when( nodeSpy.getChildNodes()).thenReturn( nodeListMock);
        Mockito.when( nodeSpy.getNodeName()).thenReturn( "p");
        Mockito.when( nodeSpy.getNodeType()).thenReturn( (short) 1).thenReturn( (short) 1).thenReturn( (short) 1).thenReturn( (short) 2);

        Mockito.when( nodeListMock.getLength()).thenReturn( 1);
        Mockito.when( nodeListMock.item(Mockito.anyInt())).thenReturn( nodeSpy);


        boolean nodeisCreated = moNodeModifier.updateMONode( nodeSpy, nodeListMock );
        Assert.assertTrue(nodeisCreated);

        Mockito.verify( nodeSpy).appendChild(Mockito.any(Node.class));

    }

    @BeforeClass
    public static void prepareFileBeforeTests() throws IOException
    {
        file = JUnitUtils.copyFile(
            new File( "xx.xml" ), new File( "testfile.xml" ));
    }

    @AfterClass
    public static void deleteFileAfterTests()
    {
        JUnitUtils.deleteFile( new File(
            "testfile.xml" ) );
    }

}

そしてスパイクラス：

package xxx.testdata;

import org.w3c.dom.Attr;
import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.TypeInfo;
import org.w3c.dom.UserDataHandler;



    public class MockNode implements Node,Element,Attr
    {


        @Override
        public NodeList getChildNodes()
        {
            return new NodeList(){

                @Override
                public int getLength()
                {
                    return 1;
                }

                @Override
                public Node item( int index )
                {
                    return new MockNode();
                }};
        }

        @Override
        public String getNodeName()
        {
            return "name";
        }

        @Override
        public short getNodeType()
        {   
            return 1;
        }


    }

および updateMONode() メソッド:

boolean updateMONode( Node inputMoNode, NodeList targetNodeList )
{
    String inputMoDn = Utils.getAttrValue( inputMoNode, "distName" );
    for( int i = 0; i < targetNodeList.getLength(); i++ )
    {
        Node targetMoNode = targetNodeList.item( i );
        String targetMoDn = Utils.getAttrValue( targetMoNode, "distName" );
        if( (targetMoNode.getNodeType() == Node.ELEMENT_NODE) &&
            (inputMoNode.getNodeType() == Node.ELEMENT_NODE) )
        { 
            if( Utils.compareDns( targetMoDn, inputMoDn ) )
            {
                NodeList parameters = inputMoNode.getChildNodes();
                boolean isParameterChanged = false;
                boolean isChanged = false;
                for( int j = 0; j < parameters.getLength(); j++ )
                {
                    if( (parameters.item( j ).getNodeType() == Node.ELEMENT_NODE) )
                        isChanged =
                            updateParamNode(
                                parameters.item( j ), targetMoNode,
                                inputMoDn );
                    if( isChanged )
                    {
                        isParameterChanged = isChanged;
                        isUpdatedParameterNode = false;
                    }
                }
                if( isParameterChanged )
                {
                    return true;
                }
            }
        }
    }
    return false;
}
4

1 に答える 1

1

状況は、新しく作成されたスパイを に注入していないことだと思いますTestableClass。各テストで一意にスパイを作成しますが、新しく作成したスパイもテスト クラスのclassフィールドに割り当てますか?

于 2013-10-14T10:41:37.623 に答える