Spock 和 Groovy：变量赋值导致 null

Question

I have a problem with a test in Spock:

@Subject
def mutation = new OrderedServicesMutation(long list of constructor elements here)

def "should order service and create address"() {
    given:
    def command = new OrderServiceCommand(1L, 2L, new Date(), "SomeAddress")
    def user = new User(id: command.userId)
    def address = new String()
    def service = new Service(id: command.serviceId)
    and:
    userRepository.findById(command.userId) >> Optional.of(user)
    serviceRepository.findById(command.serviceId) >> Optional.of(service)

    when:
    def result = mutation.orderService(command)

    then:
    with(result) {
        user == user
        address == address
        service == service
    }
}

OrderedServicesMutation.java:

@Component
@AllArgsConstructor
public class OrderedServicesMutation implements GraphQLMutationResolver {

// imports removed for readibility

    @Transactional
@PreAuthorize("hasAnyAuthority('ACCOUNT_OWNER','USER')")
public OrderedService orderService(OrderServiceCommand command) {
    OrderedService orderedService = orderedServiceRepository.save(
            orderedServiceMapper.mapWithHistory(
                    userRepository.findById(command.getUserId()).orElseThrow(() -> new NotFoundException(User.class)),
                    command.getAddress(),
                    serviceRepository.findById(command.getServiceId()).orElseThrow(() -> new NotFoundException(Service.class)),
                    command.getDate()
            )
    );
    orderedServicePublisher.publish(orderedService);

    return orderedService;
}

The method should return an object of type OrderedService , and it normally is during runtime, but when I am running this test, I get:

Target of 'with' block must not be null

Debugging the test shows me that the result variable is null...

Why is Spock not assigning the result of mutation.orderService(command) to the result variable?

Answer 1

You could mock the answer of Repository.save to have it return whatever it received during test execution:

and:
1 * orderedServiceRepository.save(_) >> { args -> args[0] }

Not that declaring receiving anything (_) would be a good practice in most cases. At least, you could specify the type of the argument like so: (_ as OrderedService) .

Also using a closure would be Groovier:

result.with {
  assert it.user == user
  assert it.address == address
  assert it.service == service
}

I think you need the asserts inside the closure, not sure about when using it as a function like you did.

It's also a good practice to add the cardinality so you know how many times a mock was called.

By the end, you could also make sure no more interactions were made to any of the declared mocks, which is great for making sure there aren't any unexpected interactions:

and: 'No more interactions'
0 * _

This is how I'd write this Specification:

def "should order service and create address"() {
    given:
    def command = new OrderServiceCommand(1L, 2L, new Date(), "SomeAddress")
    def user = new User(id: command.userId)
    def address = new String()
    def service = new Service(id: command.serviceId)

    when:
    def result = mutation.orderService(command)

    then:
    1 * userRepository.findById(command.userId) >> Optional.of(user)

    and: 
    1 * serviceRepository.findById(command.serviceId) >> Optional.of(service)

    and:
    1 * orderedServiceRepository.save(_ as OrderedService) >> { args -> args[0] }

    and: 'Make sure Publisher receives correct OrderedService' // if you wish to do so
    1 * orderedServicePublisher.publish(_) >> { OrderedService arg ->
      assert arg.user == user
      assert arg.address == address
      assert arg.service == service
    }

    and: // don't really see why use with closure here
    result.user == user
    result.address == address
    result.service == service

    and: 'No more interactions'
    0 * _
}