How to use method of org.mockito.internal.configuration.injection.scanner.MockScanner class

1package prueba_mod_1;
2
3import static org.junit.jupiter.api.Assertions.assertEquals;
4import java.util.ArrayList;
5import java.util.Arrays;
6import java.util.HashSet;
7import java.util.Scanner;
8import java.util.Set;
9
10import org.mockito.Mockito.*;
11import org.mockito.internal.configuration.injection.scanner.MockScanner;
12import org.mockito.internal.util.collections.Sets;
13import org.junit.jupiter.api.BeforeAll;
14import org.junit.jupiter.api.DisplayName;
15import org.junit.jupiter.api.Test;
16
17import org.mockito.Mock;
18import org.mockito.Mockito;
19import org.mockito.invocation.InvocationOnMock;
20import org.mockito.runners.MockitoJUnitRunner;
21
22import dominio.Alumno;
23import dominio.Materia;
24import dominio.Materia.Materias;
25import servicios.AlumnosServicios;
26import utilidades.PromedioServicio;
27import vistas.Menu;
28
29//Método crearAlumnoTest para verificar el funcionamiento de crearAlumno.
30//Método agregarMateriaTest para verificar el funcionamiento de agregarMateria.
31//Método materiasPorAlumnosTest, usando mock para verificar el funcionamiento de
32//materiasPorAlumnos.
33//Método listarAlumnosTest para verificar el funcionamiento de listarAlumnosTest.
34
35
36
37@DisplayName("Testing Promedio")
38class Tests {
39
40private final AlumnosServicios alumnoServicio = new AlumnosServicios();
41	@Test
42	void promedioTest() {
43		ArrayList<Float> notas = new ArrayList(Arrays.asList(4.3f,4.4f,3.7f,3.6f)); //promedio = 4.0f
44		float promedioRespuesta = PromedioServicio.promedioServicioImp(notas);
45		assertEquals(promedioRespuesta, 4.0);
46	}
47
48	
49//	@Test 
50	void crearAlumnoTest() {
51//		Scanner scanner = new Scanner(System.in);
52//		mockingSet.add("17430249-9");
53//		mockingSet.add("Kamal Fontirroig");
54//		mockingSet.add("Mi Casa");
55//	
56//		mockScanner.addPreparedMocks(mockingSet);
57//	
58
59		Alumno alumnoEsperado = new Alumno("17430249-9", "Kamal Fontirroig", "Mi Casa" );
60		Alumno alumnoRespuesta = alumnoServicio.crearAlumno();
61
62		assertEquals(alumnoRespuesta.rut, alumnoEsperado.rut);
63		assertEquals(alumnoRespuesta.nombre, alumnoEsperado.nombre);
64		assertEquals(alumnoRespuesta.direccion, alumnoEsperado.direccion);
65		
66	}
67
68
69
70//@Test
71void agregarMateriaTest() {
72	Alumno alumno = new Alumno("17430249-9", "Kamal Fontirroig", "Mi Casa" );
73	 alumnoServicio.crearAlumno(alumno);
74	 Menu menu = new Menu();
75	 boolean exito = alumnoServicio.agregarMateria(menu);
76	 assertEquals(exito, true);
77}
78
79
80@Test
81public void materiasPorAlumnoTest(){
82	Alumno alumno = new Alumno("17430249-9", "Kamal Fontirroig", "Mi Casa" );
83	 alumnoServicio.crearAlumno(alumno);
84	 Materia materia = new Materia();
85	 ArrayList<Materia> listaMateriasEsperada = new ArrayList<>();
86	 materia.nombreMateria = Materias.CIENCIAS;
87	 alumnoServicio.mapaAlumnos.get("17430249-9").listaMateria.add(materia);
88	 listaMateriasEsperada.add(materia);
89	 materia.nombreMateria = Materias.LENGUAJE;
90	 alumnoServicio.mapaAlumnos.get("17430249-9").listaMateria.add(materia);
91	 listaMateriasEsperada.add(materia);
92	 materia.nombreMateria = Materias.MATEMATICAS;
93	 alumnoServicio.mapaAlumnos.get("17430249-9").listaMateria.add(materia);
94	 listaMateriasEsperada.add(materia);
95	 materia.nombreMateria = Materias.HISTORIA;
96	 alumnoServicio.mapaAlumnos.get("17430249-9").listaMateria.add(materia);
97	 listaMateriasEsperada.add(materia);
98	 
99	 for (int i = 0; i< 4; i++){
100	assertEquals(alumnoServicio.mapaAlumnos.get("17430249-9").listaMateria.get(i).nombreMateria, listaMateriasEsperada.get(i).nombreMateria);
101	 }
102}
103}
104////create a mock scanner
105//Scanner mockScanner = mock(Scanner.class);
106////set up the scanner
107//when(mockScanner.nextLine()).thenReturn("add 5");
108//
109//InputOutput inputOutput= new InputOutput(mockScanner);
110//
111////assert output
112//assertEquals("add 5", inputOutput.getInput());
113//
114////added bonus - you can verify that your scanner's nextline() method is
115////actually called See Mockito.verify
116//verify(mockScanner).nextLine();
117//
118//
119//
120//void MyTest {
121//
122//	  @Test
123//	  public void shouldTakeUserInput() {
124//	    systemInMock.provideLines("add 5", "another line");
125//	    InputOutput inputOutput = new InputOutput();
126//	    assertEquals("add 5", inputOutput.getInput());
127//	  }

Source: Tests.java

package prueba_mod_1;

import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

import org.mockito.Mockito.*;
import org.mockito.internal.configuration.injection.scanner.MockScanner;
import org.mockito.internal.util.collections.Sets;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.runners.MockitoJUnitRunner;

import dominio.Alumno;
import dominio.Materia;
import dominio.Materia.Materias;
import servicios.AlumnosServicios;
import utilidades.PromedioServicio;
import vistas.Menu;

//Método crearAlumnoTest para verificar el funcionamiento de crearAlumno.
//Método agregarMateriaTest para verificar el funcionamiento de agregarMateria.
//Método materiasPorAlumnosTest, usando mock para verificar el funcionamiento de
//materiasPorAlumnos.
//Método listarAlumnosTest para verificar el funcionamiento de listarAlumnosTest.



@DisplayName("Testing Promedio")
class Tests {

private final AlumnosServicios alumnoServicio = new AlumnosServicios();
	@Test
	void promedioTest() {
		ArrayList<Float> notas = new ArrayList(Arrays.asList(4.3f,4.4f,3.7f,3.6f)); //promedio = 4.0f
		float promedioRespuesta = PromedioServicio.promedioServicioImp(notas);
		assertEquals(promedioRespuesta, 4.0);
	}

	
//	@Test 
	void crearAlumnoTest() {
//		Scanner scanner = new Scanner(System.in);
//		mockingSet.add("17430249-9");
//		mockingSet.add("Kamal Fontirroig");
//		mockingSet.add("Mi Casa");
//	
//		mockScanner.addPreparedMocks(mockingSet);
//	

		Alumno alumnoEsperado = new Alumno("17430249-9", "Kamal Fontirroig", "Mi Casa" );
		Alumno alumnoRespuesta = alumnoServicio.crearAlumno();

		assertEquals(alumnoRespuesta.rut, alumnoEsperado.rut);
		assertEquals(alumnoRespuesta.nombre, alumnoEsperado.nombre);
		assertEquals(alumnoRespuesta.direccion, alumnoEsperado.direccion);
		
	}



//@Test
void agregarMateriaTest() {
	Alumno alumno = new Alumno("17430249-9", "Kamal Fontirroig", "Mi Casa" );
	 alumnoServicio.crearAlumno(alumno);
	 Menu menu = new Menu();
	 boolean exito = alumnoServicio.agregarMateria(menu);
	 assertEquals(exito, true);
}


@Test
public void materiasPorAlumnoTest(){
	Alumno alumno = new Alumno("17430249-9", "Kamal Fontirroig", "Mi Casa" );
	 alumnoServicio.crearAlumno(alumno);
	 Materia materia = new Materia();
	 ArrayList<Materia> listaMateriasEsperada = new ArrayList<>();
	 materia.nombreMateria = Materias.CIENCIAS;
	 alumnoServicio.mapaAlumnos.get("17430249-9").listaMateria.add(materia);
	 listaMateriasEsperada.add(materia);
	 materia.nombreMateria = Materias.LENGUAJE;
	 alumnoServicio.mapaAlumnos.get("17430249-9").listaMateria.add(materia);
	 listaMateriasEsperada.add(materia);
	 materia.nombreMateria = Materias.MATEMATICAS;
	 alumnoServicio.mapaAlumnos.get("17430249-9").listaMateria.add(materia);
	 listaMateriasEsperada.add(materia);
	 materia.nombreMateria = Materias.HISTORIA;
	 alumnoServicio.mapaAlumnos.get("17430249-9").listaMateria.add(materia);
	 listaMateriasEsperada.add(materia);
	 
	 for (int i = 0; i< 4; i++){
	assertEquals(alumnoServicio.mapaAlumnos.get("17430249-9").listaMateria.get(i).nombreMateria, listaMateriasEsperada.get(i).nombreMateria);
	 }
}
}
////create a mock scanner
//Scanner mockScanner = mock(Scanner.class);
////set up the scanner
//when(mockScanner.nextLine()).thenReturn("add 5");
//
//InputOutput inputOutput= new InputOutput(mockScanner);
//
////assert output
//assertEquals("add 5", inputOutput.getInput());
//
////added bonus - you can verify that your scanner's nextline() method is
////actually called See Mockito.verify
//verify(mockScanner).nextLine();
//
//
//
//void MyTest {
//
//	  @Test
//	  public void shouldTakeUserInput() {
//	    systemInMock.provideLines("add 5", "another line");
//	    InputOutput inputOutput = new InputOutput();
//	    assertEquals("add 5", inputOutput.getInput());
//	  }

1/*
2 * Copyright (c) 2007 Mockito contributors
3 * This program is made available under the terms of the MIT License.
4 */
5package org.mockito.internal.configuration.injection.scanner;
6
7import org.mockito.Mock;
8import org.mockito.MockitoAnnotations;
9import org.mockito.Spy;
10import org.mockito.internal.util.MockUtil;
11import org.mockito.internal.util.reflection.FieldReader;
12
13import java.lang.reflect.Field;
14import java.util.Set;
15
16import static org.mockito.internal.util.collections.Sets.newMockSafeHashSet;
17
18/**
19 * Scan mocks, and prepare them if needed.
20 */
21public class MockScanner {
22    private final MockUtil mockUtil = new MockUtil();
23    private final Object instance;
24    private final Class<?> clazz;
25
26    /**
27     * Creates a MockScanner.
28     *
29     * @param instance The test instance
30     * @param clazz    The class in the type hierarchy of this instance.
31     */
32    public MockScanner(Object instance, Class<?> clazz) {
33        this.instance = instance;
34        this.clazz = clazz;
35    }
36
37    /**
38     * Add the scanned and prepared mock instance to the given collection.
39     *
40     * <p>
41     * The preparation of mocks consists only in defining a MockName if not already set.
42     * </p>
43     *
44     * @param mocks Set of mocks
45     */
46    public void addPreparedMocks(Set<Object> mocks) {
47        mocks.addAll(scan());
48    }
49
50    /**
51     * Scan and prepare mocks for the given <code>testClassInstance</code> and <code>clazz</code> in the type hierarchy.
52     *
53     * @return A prepared set of mock
54     */
55    private Set<Object> scan() {
56        Set<Object> mocks = newMockSafeHashSet();
57        for (Field field : clazz.getDeclaredFields()) {
58            // mock or spies only
59            FieldReader fieldReader = new FieldReader(instance, field);
60
61            Object mockInstance = preparedMock(fieldReader.read(), field);
62            if (mockInstance != null) {
63                mocks.add(mockInstance);
64            }
65        }
66        return mocks;
67    }
68
69    private Object preparedMock(Object instance, Field field) {
70        if (isAnnotatedByMockOrSpy(field)) {
71            return instance;
72        } else if (isMockOrSpy(instance)) {
73            mockUtil.maybeRedefineMockName(instance, field.getName());
74            return instance;
75        }
76        return null;
77    }
78
79    private boolean isAnnotatedByMockOrSpy(Field field) {
80        return null != field.getAnnotation(Spy.class)
81                || null != field.getAnnotation(Mock.class)
82                || null != field.getAnnotation(MockitoAnnotations.Mock.class);
83    }
84
85    private boolean isMockOrSpy(Object instance) {
86        return mockUtil.isMock(instance)
87                || mockUtil.isSpy(instance);
88    }
89}
90

Source: MockScanner.java

/*
 * Copyright (c) 2007 Mockito contributors
 * This program is made available under the terms of the MIT License.
 */
package org.mockito.internal.configuration.injection.scanner;

import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.mockito.Spy;
import org.mockito.internal.util.MockUtil;
import org.mockito.internal.util.reflection.FieldReader;

import java.lang.reflect.Field;
import java.util.Set;

import static org.mockito.internal.util.collections.Sets.newMockSafeHashSet;

/**
 * Scan mocks, and prepare them if needed.
 */
public class MockScanner {
    private final MockUtil mockUtil = new MockUtil();
    private final Object instance;
    private final Class<?> clazz;

    /**
     * Creates a MockScanner.
     *
     * @param instance The test instance
     * @param clazz    The class in the type hierarchy of this instance.
     */
    public MockScanner(Object instance, Class<?> clazz) {
        this.instance = instance;
        this.clazz = clazz;
    }

    /**
     * Add the scanned and prepared mock instance to the given collection.
     *
     * <p>
     * The preparation of mocks consists only in defining a MockName if not already set.
     * </p>
     *
     * @param mocks Set of mocks
     */
    public void addPreparedMocks(Set<Object> mocks) {
        mocks.addAll(scan());
    }

    /**
     * Scan and prepare mocks for the given <code>testClassInstance</code> and <code>clazz</code> in the type hierarchy.
     *
     * @return A prepared set of mock
     */
    private Set<Object> scan() {
        Set<Object> mocks = newMockSafeHashSet();
        for (Field field : clazz.getDeclaredFields()) {
            // mock or spies only
            FieldReader fieldReader = new FieldReader(instance, field);

            Object mockInstance = preparedMock(fieldReader.read(), field);
            if (mockInstance != null) {
                mocks.add(mockInstance);
            }
        }
        return mocks;
    }

    private Object preparedMock(Object instance, Field field) {
        if (isAnnotatedByMockOrSpy(field)) {
            return instance;
        } else if (isMockOrSpy(instance)) {
            mockUtil.maybeRedefineMockName(instance, field.getName());
            return instance;
        }
        return null;
    }

    private boolean isAnnotatedByMockOrSpy(Field field) {
        return null != field.getAnnotation(Spy.class)
                || null != field.getAnnotation(Mock.class)
                || null != field.getAnnotation(MockitoAnnotations.Mock.class);
    }

    private boolean isMockOrSpy(Object instance) {
        return mockUtil.isMock(instance)
                || mockUtil.isSpy(instance);
    }
}