AuctionManagerUnitTest.java

package unitTest;

import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.text.ParseException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.Random;
import java.util.function.Function;
import java.util.stream.Stream;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestFactory;
import org.junit.jupiter.api.function.Executable;
import org.junit.jupiter.api.function.ThrowingConsumer;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;

import exceptions.BidBelowZeroException;
import exceptions.ImageInvalidException;
import project.Auction;
import project.AuctionManager;
import project.Bid;
import project.Category;
import project.Item;
import project.ItemPicture;
import project.User;

public class AuctionManagerUnitTest {

	@BeforeEach
	public void reset() {

		Item.items = new ArrayList<Item>();
		User.users = new ArrayList<User>();
		Auction.auctions = new ArrayList<Auction>();
		Category.categories = new ArrayList<Category>();

	}

	@TestFactory
	public Collection<DynamicTest> checkTimeTest() {

		AuctionManager am = AuctionManager.getInstance();
		User user = User.getInstance();
		Auction a = Auction.getInstance();
		Date endDate = AuctionManager.parseDate("03/12/2019 10:00:00");
		a.setEnd(endDate);
		am.setAuction(a);

		ArrayList<Bid> bidList = new ArrayList<Bid>();

		for (int x = 0; x < 10; x++) {
			Date d = AuctionManager.parseDate("03/12/2059 " + x + ":00:00");
			Bid b = new Bid(d, 10, user, a);
			bidList.add(b);
		}

		a.setBids(bidList);

		ArrayList<Date> rightList = new ArrayList<Date>();

		for (int x = 0; x < 10; x++) {

			String dateToParse = "03/12/2019 0" + x + ":00:00";

			Date d = AuctionManager.parseDate(dateToParse);
			rightList.add(d);

		}

		ArrayList<Date> wrongList = new ArrayList<Date>();
		for (int x = 10; x < 20; x++) {

			String dateToParse = "03/12/2019 " + x + ":00:00";

			Date d = AuctionManager.parseDate(dateToParse);
			wrongList.add(d);

		}

		Collection<DynamicTest> dynamicTests = new ArrayList<DynamicTest>();

		for (int e = 0; e < rightList.size(); e++) {

			Date toRemove = rightList.get(e);
			Executable exec = () -> assertTrue(am.checkTime(toRemove));
			DynamicTest dTest = DynamicTest.dynamicTest("Before end date", exec);

			dynamicTests.add(dTest);
		}

		for (int e = 0; e < wrongList.size(); e++) {
			Date toRemove = wrongList.get(e);
			Executable exec = () -> assertFalse(am.checkTime(toRemove));
			DynamicTest dTest = DynamicTest.dynamicTest("After end date", exec);

			dynamicTests.add(dTest);
		}

		return dynamicTests;
	}

	@Test
	public void checkTimeTwoBidsTest() {

		Date commonDate = AuctionManager.parseDate("03/12/2019 10:00:00");
		User user = User.getInstance();
		AuctionManager auctionManager = AuctionManager.getInstance();
		Auction auction = Auction.getInstance();

		auctionManager.setAuction(auction);
		Bid a = new Bid(commonDate, 10, user, auction);

		ArrayList<Bid> toSet = auction.getBids();
		toSet.add(a);

		auction.setBids(toSet);

		Bid b = new Bid(commonDate, 10, user, auction);

		assertFalse(auctionManager.checkTime(b.getDate()));
	}

	@ParameterizedTest
	@ValueSource(ints = { -4, -3, -2, -1, 0, 1, 2, 3, 4, 5 })
	public void placeBidTestOpenAuction(int toCheck) throws BidBelowZeroException, ParseException {

		AuctionManager auctionManager = AuctionManager.getInstance();
		Auction auction = Auction.getInstance();
		User user = User.getInstance();

		Date rightEndDate = AuctionManager.parseDate("03/12/2021 10:00:00");

		// Sets the auction related to the AuctionManager with a valid date
		auction.setEnd(rightEndDate);
		auctionManager.setAuction(auction);

		if (toCheck < 1) {

			assertThrows(BidBelowZeroException.class, () -> auctionManager.placeBid(user, toCheck));

		} else {

			assertTrue(auctionManager.placeBid(user, toCheck));

		}

	}

	@TestFactory
	public Collection<DynamicTest> placeBidTestEndedAuction() {

		AuctionManager auctionManager = AuctionManager.getInstance();
		Auction auction = Auction.getInstance();
		User user = User.getInstance();

		// Sets the auction related to the AuctionManager with a valid date
		auctionManager.setAuction(auction);

		ArrayList<Integer> values = new ArrayList<Integer>();

		for (int e = -4; e < 6; e++) {

			values.add(e);

		}

		Collection<DynamicTest> dynamicTests = new ArrayList<DynamicTest>();

		// Change the date of the auction managed by the manager with a wrong date and
		// re-run the test
		Date wrongEndDate = AuctionManager.parseDate("03/12/2008 10:00:00");
		auction.setEnd(wrongEndDate);

		for (int e = 0; e < 10; e++) {

			DynamicTest dTest;
			int toCheck = values.get(e);

			if (toCheck < 1) {
				Executable exec = () -> assertThrows(BidBelowZeroException.class,
						() -> auctionManager.placeBid(user, toCheck));
				dTest = DynamicTest.dynamicTest("Value below zero with ended Auction", exec);
			} else {
				Executable exec = () -> assertFalse(auctionManager.placeBid(user, toCheck));
				dTest = DynamicTest.dynamicTest("Value over zero with ended Auction", exec);
			}

			dynamicTests.add(dTest);
		}

		return dynamicTests;
	}
	
	@TestFactory
	public Collection<DynamicTest> externalAddBidTestFalse() {
		
		Auction auction = Auction.getInstance();
		User user = User.getInstance();
		AuctionManager manager = AuctionManager.getInstance();
		ArrayList<Integer> values = new ArrayList<Integer>();
		
		manager.setAuction(auction);
		
		for(int i = 1; i < 6; i++) {
			values.add(i);	
		}
		
		Collection<DynamicTest> dynamicTests = new ArrayList<DynamicTest>();

		for (int e = 0; e < 5; e++) {

			DynamicTest dTest;
			auction.setPrice(10);
			int toCheck = values.get(e);

			Executable exec = () -> assertFalse(manager.placeBid(user, toCheck));
			dTest = DynamicTest.dynamicTest("Lower bid than current auction price", exec);

			dynamicTests.add(dTest);
		}

		return dynamicTests;
		
	}
	

	@ParameterizedTest
	@ValueSource(ints = { 2, 3, 4, 5, 6 })
	public void externalAddBidTrue(int toCheck) throws BidBelowZeroException, ParseException {

		Auction auction = Auction.getInstance();
		User user = User.getInstance();
		AuctionManager manager = AuctionManager.getInstance();
		
		auction.setPrice(1);
		manager.setAuction(auction);

		assertTrue(manager.placeBid(user, toCheck));

	}

}