A condition on an argument used in multiple calls of a method: enforced by caller or by the method?

Question

Let's assume I have an object a of a class A. It has a method that needs an argument in form of another object of a particular type - but the argument should also be in particular state, because the operation performed by the method (let's say it's querying an external service, but it could be something else) requires it.

class A(object):
    def action(self, argument):

        return do_something(argument)

The first solution that comes to my mind is simple: the method should enforce a condition on the input data. It should test it for required state and then either raise an exception or modify the state:

class A(object):
    def action(self, argument):
        if argument.state == False:
            raise Exception()

        return do_something(argument)

class A(object):
    def action(self, argument):
        if argument.state == False:
            argument.change_state()

        return do_something(argument)

However, the instance we are talking about is only one of many instances of the A. All these instances should perform the same operation on input data: testing it for a particular state and then enforcing it, or just raising an exception. It seems they could use a shared instance of parameter whose required state is already enforced by an external caller, instance of class B:

class B(object):
    def action(self, argument):
        argument.change_state()
        for a in self.instances_of_A:
            yield a.action(argument)

Because I think the operation performed by the method wouldn't be properly encapsulated without enforcing the required state of argument inside the method, I think it should be moved to the former caller. The object a and all other instances of class A would just provide data necessary for performing the operation.

class B(object):
    def action(self, argument):
        argument.change_state()
        for a in self.instances_of_A:
            yield  do_something(argument, a.data)

However, there is another problem: the operation returns a value that could be interpreted in a way related to instance of A to get another piece of data - and now it seems like the operation do_something should be encapsulated in a method of class A.

How should I solve this problem? Should I simply keep the current design and make object a return data that could be used to interpret return code provided by the operation? Perhaps I should use chain of command pattern and modify class A to delegate the operation to other instances of A? What are the other ways I could handle it?

Answer 1

I guess you need to introduce a simple DTO into your scheme. Take your agrument, check if it is in a valid state and put that state into a new DTO object. In your last example, you can do that inside your B::action method.

This way you will no longer need any state checking because this DTO is always in a valid state by definition. A will enforce its contract by accepting only this DTO for an operation.