Encapsulating and mocking

Suppose I have class with simple dependency:

public interface Dependency {
    int doSomething(int value);
}

public final class A implements SomeInterface {
    private final Dependency dep;

    public A (Dependency dep) {
        this.dep = dep;
    }

    @Override
    public int add(final int x) {
        return x + dep.doSomething(x);
    }
}

And I'm writing test using mocks:

public class TestA {
    private Dependency mockDep;
    private SomeInterface a;

    @Before
    public void setUp() {
        mockDep = Mockito.mock(Dependency.class);
        a = new A(mockDep);
    }

    @Test
    public void shouldAdd() {
        final int x = 5;
        when(mockDep.doSomething(x)).thenReturn(6);

        int actual = a.add(x);

        assertThat(actual, is(11));

        verify(mockDep, times(1)).doSomething();
        verifyNoMoreInteractions(mockDep);
    }
}

So far so good.

So the question is: do we violate encapsulation of class A by verifying how exactly the dependency was used? Does it really needed to test that dependency was used in exactly that way? Shouldn't we test A like a black-box (delete verify invocations from test case and leave just assertThat)? And how to deal with dependencies in such case?

The reason I'm asking is that I caught myself writing good amount of verification dependency code and it seems that we start to test actual internal realization details about class. And I feel uncomfortable about that because when I will try to rewrite this realization details in another way I need to rewrite test cases although the result of add for example will be the same. If I would test my class as a black-box I can change realization details and still be sure that given input will give same output.

Or it is necessary to actually test exactly the realization details and that is the point of unit-test itself? It seems somewhat wrong for me.