package com.nisum.webfluxreactivemongodb;

import com.nisum.webfluxreactivemongodb.controller.ProductController;
import com.nisum.webfluxreactivemongodb.dto.ProductDto;
import com.nisum.webfluxreactivemongodb.service.ProductService;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.reactive.WebFluxTest;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.web.reactive.server.WebTestClient;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.when;

@RunWith(SpringJUnit4ClassRunner.class)
@WebFluxTest({ ProductService.class, ProductController.class })
class WebfluxReactiveMongodbApplicationTests {

	@Autowired
	WebTestClient webTestClient;

	@MockBean
	ProductService productService;

	@Test
	void addProductTest() {
		Mono<ProductDto> productDtoMono = Mono.just(new ProductDto(1,"tv",4,15000.00));
		when(productService.saveProduct(productDtoMono)).thenReturn(productDtoMono);

		webTestClient.post().uri("/api/products")
				.body(Mono.just(productDtoMono),ProductDto.class)
				.exchange()
				.expectStatus().isOk();//200
	}
    @Test
	void getProductsTest(){
		Flux<ProductDto> productDtoFlux=Flux.just(new ProductDto(1,"tv",4,15000.00),
		new ProductDto(2,"mobile",5,20000.00));
		when(productService.getAllProducts()).thenReturn(productDtoFlux);

		Flux<ProductDto> responseBody = webTestClient.get().uri("/api/products")
				.exchange()
				.expectStatus().isOk()
				.returnResult(ProductDto.class)
				.getResponseBody();

		StepVerifier.create(responseBody)
				.expectSubscription()
				.expectNext(new ProductDto(1,"tv",4,15000.00))
				.expectNext(new ProductDto(2,"mobile",5,20000.00))
				.verifyComplete();
	}

	@Test
	void getProductByIdTest(){
		Mono<ProductDto> productDtoMono = Mono.just(new ProductDto(2,"mobile",5,20000.00));
		when(productService.getProduct(2)).thenReturn(productDtoMono);


		Flux<ProductDto> responseBody = webTestClient.get().uri("/api/products/2")
				.exchange()
				.expectStatus().isOk()
				.returnResult(ProductDto.class)
				.getResponseBody();

		StepVerifier.create(responseBody)
				.expectSubscription()
				.expectNextMatches(productDto -> productDto.getName().equals("mobile"))
				.verifyComplete();


	}
	@Test
	void updateProductTest(){
		Mono<ProductDto> productDtoMono = Mono.just(new ProductDto(3,"laptop",2,50000.00));
		when(productService.updateProduct(productDtoMono,3)).thenReturn(productDtoMono);

		webTestClient.put().uri("/api/products/3")
				.body(Mono.just(productDtoMono),ProductDto.class)
				.exchange()
				.expectStatus().isOk();
	}
@Test
	void deleteProductTest(){
		given(productService.deleteProduct(3)).willReturn(Mono.empty());

		webTestClient.delete().uri("/api/products/3")
				.exchange()
				.expectStatus().isOk();
	}
//	@Test
//	void productBetweenRangeTest(){
//		Flux<ProductDto> productDtoMono = Flux.just(new ProductDto(2,"mobile",5,20000.00));
//		when(productService.getProductInRange(0,1000000)).thenReturn(productDtoMono);
//
//
//		Flux<ProductDto> responseBody = webTestClient.get().uri("/api/products/product-range")
//				.exchange()
//				.expectStatus().isOk()
//				.returnResult(ProductDto.class)
//				.getResponseBody();
//
//		StepVerifier.create(responseBody)
//				.expectSubscription()
//				.verifyComplete();
//
//
//	}

}