Mockito thenThrow cannot be catch

I am using Mockito to mock the method of service layer.
This is my test code.

@InjectMocks
MyServiceImpl myServiceImpl;
@Mock
MyDAO myDAO;

@Rule
public ExpectedException exceptionRule = ExpectedException.none();

@Test
public void getAllFail(){
  Mockito.when(myDAO.getAll().thenThrow(new DataException("mock"));
  exceptionRule.expect(ServiceException.class);
  myServiceImpl.getAllData();
}

service code

@Service
public class myServiceImpl extends myService{
  private final MyDAO myDAO;
  ...
  @Override
  public List getAllData(){
    try{
      return myDAO.getAll();
    } catch (DataException exception){
      throw new ServiceException("exception");
    }
  }
}

At first I thought that by mocking DAO class to throw exception, it would be caught by catch and turn into ServiceException but the result was

java.lang.AssertionError:
Expected an instance of com.example.exception.ServiceException
    but: <com.example.exception.DataException: mock> is a com.example.exception.DataException

How can I test exception of my service in this case? Please guide me. Thank you in advance.

I think you need to use Assertions.assertThrows when you are expecting an exception from a method call and you need chain the exception properly. Here is how I have done it.

Service class with exceptions and method calls

import org.springframework.stereotype.Service;

import java.util.Collections;
import java.util.List;

@Service
public class SampleTestService {
    private final MyDao myDao;


    public SampleTestService(MyDao myDao) {
        this.myDao = myDao;
    }

    public List<String> getData() {
        try {
            return myDao.getStringList();
        } catch (MyDao.DataException dataException) {
            throw new ServiceException("Error getting data");
        }
    }

    static class ServiceException extends RuntimeException {
        public ServiceException(String message) {
            super(message);
        }
    }

}

class MyDao {
    public List<String> getStringList() {
        return Collections.emptyList();
    }

    static class DataException extends RuntimeException {
        public DataException(String message) {
            super(message);
        }
    }
}

Unit Test class in action

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.springframework.test.context.junit.jupiter.SpringExtension;

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

@ExtendWith(SpringExtension.class)
class SampleTestServiceTest {

//    private final MyDao myDao = mock(MyDao.class);

    @Mock
    MyDao myDao;

    @Test
    void testDaoThrowsException() {
        Mockito.when(myDao.getStringList()).thenThrow(new MyDao.DataException("Error connecting to database"));
        SampleTestService sampleTestService = new SampleTestService(myDao);
        Assertions.assertThrows(SampleTestService.ServiceException.class,
                () -> {
                    sampleTestService.getData();
                });
    }

    @Test
    void testDaoReturnData() {
        List<String> colors = Arrays.asList("red", "green", "blue");
        Mockito.when(myDao.getStringList()).thenReturn(colors);
        SampleTestService sampleTestService = new SampleTestService(myDao);
        List<String> data = sampleTestService.getData();
        Assertions.assertEquals(3, data.size());
        Assertions.assertSame(data, colors);
    }
}