Q:

Dependency Injection - Proper use of interfaces?

I've been reading about DI and best practices, and still haven't found the answer to this question. When should I use interfaces?

Some developers suggest to add interface for every object that is being injected. This would make a modular application.
Some other are against this.

So my question is which one is correct?
EDIT:
Below are the two sides, I still don't see the advantage of using interfaces. In both cases I can easily mock classes, and change the implementations
Using interfaces
bind(IUserStorage.class).to(UserStorage.class);
// Unit test
bind(IUserStorage.class).to(Mock(UserStorage.class));

Not using interfaces
bind(UserStorage.class).to(UserStorage.class);
// Unit test
bind(UserStorage.class).to(Mock(UserStorage.class));

A:

I can't believe using interfaces is againt OOP principles!
I would definitely use interfaces in this scenario. It means you're loosely coupling your components and can easy mock and/or substitute alternatives. Lots of DI frameworks will use the interfaces in order to provide additional functionality (e.g. create proxy objects mapped to the real objects, but with additional features).
As such I would try and use interfaces for all but the most trivial of injected objects. At some stage you're going to want to make use of substitutability, framework code generation etc. and retrofitting interface usage is an additional pain that it's easy to avoid at the beginning of a project.

A:

Interface based design is the cornerstone of IoC, here is a short description of Interface-based design (Sorry that I'm referencing my own blog, but I just finished an article about this, it was an extract from my MS Thesis):

Nandigam et al. defines Interface-based design as "a way of developing
  object-oriented systems where one consciously and proactively defines
  and uses interfaces wherever possible in a design to reap the benefits
  of designing with interfaces" [Nan09]. Applications with an
  interface-based design follow the principle "program to an interface,
  not an implementation". This principle brings the following benefits
  to the resulting system [Dav03]: flexibility (describes the system
  robustness to change), extensibility (the ease with which a system may
  accommodate additions) and pluggability (the ability that allows
  substitutions of objects with identical interfaces at run-time).

Once you mix interface design with IoC you obtain the following benefits:

Tasks are decoupled from the implementation.
Increases modularity where modules rely on other modules solely on their contracts (interfaces).
Increases pluggability and replacing a module does not have a cascading effect on other modules.

To answer your question, I would use interfaces for different types of modules. For example, one per service or repository. 
I do not create interfaces for controllers or Model classes (MVC apps).
All this, as a side effect, facilitates testing.

