Defensive programming against client code if I myself implement the client code and the Interface?

Question

I'm writing an application in Python. Somewhere, I write a model layer composed with classes, and, any of them, say:

class Orders:

has a bound method whose signature is :

def delete(self, id=None, name=None):

I need id or name not to be None. Then, here is my question:

Since I myself write the model layer and the client code, which would be something like:

model.Orders().delete(id=1234)

Would be good practice to check the parameters inside the delete method with code like:

if not any((id, name)):
    raise ValueError('Order Id or Order name must be provided')

?

I think, since I write the two sides, I will always call the delete method providing one of the parameters avoiding checking and saving a lot of code. I expect the model layer will reach 2 or 3 thousand lines, interfacing a database server.

I put a specific example, but I'd appreciate an answer for the general case.

Answer 1

This was discussed here and here.

I would add, however, that since Python does not support mutually exclusive arguments by default, the clean way would be to provide two public interfaces: delete_by_id, delete_by_name; and these ones call a private method _delete. This way the facade to users of the class is clear and enforces the arguments nicely, while from within the class you reuse the code.

Answer 2

In general case, according to me, it is always a good practice to prevent error and misuse in your code. It is true that you can save a lot of coding but what is the price? Someday in the future you will be using this code not remembering to provide one of the two parameters and you can lose hours in debuging. Or maybe you could opensource your code and someone trying to use it may have some problem.