com.arangodb.springframework.testdata.Customer

@Test
public void findTest() {
    final Customer customer1 = new Customer("%_\\name", "%surname%", 20);
    repository.save(customer1);
    repository.save(new Customer("_\\name", "%surname%", 20));
    repository.save(new Customer("%_\\name", "%surname", 20));
    repository.save(new Customer("%_\\name", "surname%", 18));
    final Customer retrieved = repository.findByNameStartsWithAndSurnameEndsWithAndAgeBetween("%_\\", "%", 19, 20);
    replacedertEquals(customer1, retrieved);
}

@Test
public void findNearTest() {
    john.setLocation(new int[] { 2, 2 });
    bob.setLocation(new int[] { 50, 45 });
    repository.saveAll(customers);
    final Customer[] retrieved = repository.findByLocationNear(new Point(10, 20));
    final Customer[] check = { john, bob };
    replacedertTrue(equals(check, retrieved, cmp, eq, true));
}

@Test
public void findOneByIdNamedQueryTest() {
    repository.saveAll(customers);
    final Customer retrieved = repository.findOneByIdNamedQuery(john.getId());
    replacedertEquals(john, retrieved);
}

@Test(expected = ArangoDBException.clreplaced)
public void findOneByIdInNamedCollectionAqlRejectedTest() {
    repository.saveAll(customers);
    final Customer retrieved = repository.findOneByIdInNamedCollectionAqlRejected(john.getId().split("/")[0], john.getId());
    replacedertEquals(john, retrieved);
}

@Test(expected = ArangoDBException.clreplaced)
public void findOneByIdInIncorrectNamedCollectionAqlTest() {
    repository.saveAll(customers);
    final Customer retrieved = repository.findOneByIdInIncorrectNamedCollectionAql(john.getId().split("/")[0], john.getId(), john.getId());
    replacedertEquals(john, retrieved);
}

@Test(expected = ArangoDBException.clreplaced)
public void findOneByIdInNamedCollectionAqlWithUnusedParamTest() {
    repository.saveAll(customers);
    final Customer retrieved = repository.findOneByIdInNamedCollectionAqlWithUnusedParam(john.getId().split("/")[0], john.getId(), john.getId());
    replacedertEquals(john, retrieved);
}

@Test(expected = ArangoDBException.clreplaced)
public void findOneByIdInCollectionAqlWithUnusedParamTest() {
    repository.saveAll(customers);
    final Customer retrieved = repository.findOneByIdInCollectionAqlWithUnusedParam(john.getId().split("/")[0], john.getId(), john.getId());
    replacedertEquals(john, retrieved);
}

@Test
public void findOneTest() {
    repository.save(john);
    final String id = john.getId();
    Customer customer = repository.findById(id).get();
    replacedertEquals("customers do not match", john, customer);
    john.setAge(100);
    repository.save(john);
    customer = repository.findById(id).get();
    replacedertEquals("customers do not match", john, customer);
}

/**
 * @author Christian Lechner
 */
public clreplaced SaveEventTest extends AbstractArangoTest {

    @Autowired
    private CustomerEventListener listener;

    private Customer john;

    private Customer bob;

    private List<Customer> customers;

    public SaveEventTest() {
        super(Customer.clreplaced);
    }

    @Before
    public void createMockCustomers() {
        john = new Customer("John", "Smith", 20);
        bob = new Customer("Bob", "Thompson", 40);
        customers = new ArrayList<>();
        customers.add(john);
        customers.add(bob);
    }

    @Before
    public void clearEvents() {
        listener.beforeSaveEvents.clear();
        listener.afterSaveEvents.clear();
    }

    @Test
    public void insertSingleSaveEvent() {
        template.insert(john);
        replacedertThat(listener.beforeSaveEvents.size(), is(1));
        replacedertThat(listener.beforeSaveEvents.get(0).getSource(), is(john));
        replacedertThat(listener.afterSaveEvents.size(), is(1));
        replacedertThat(listener.afterSaveEvents.get(0).getSource(), is(john));
    }

    @Test
    public void insertMultiSaveEvent() {
        template.insert(john);
        template.insert(customers, Customer.clreplaced);
        replacedertThat(listener.beforeSaveEvents.size(), is(3));
        for (final BeforeSaveEvent<Customer> event : listener.beforeSaveEvents) {
            replacedertThat(event.getSource(), isIn(customers));
        }
        replacedertThat(listener.afterSaveEvents.size(), is(2));
        for (final AfterSaveEvent<Customer> event : listener.afterSaveEvents) {
            replacedertThat(event.getSource(), isIn(customers));
        }
    }

    @Test
    public void updateSingleSaveEvent() {
        template.insert(john);
        listener.beforeSaveEvents.clear();
        listener.afterSaveEvents.clear();
        john.setAge(30);
        template.update(john.getId(), john);
        replacedertThat(listener.beforeSaveEvents.size(), is(1));
        replacedertThat(listener.beforeSaveEvents.get(0).getSource(), is(john));
        replacedertThat(listener.afterSaveEvents.size(), is(1));
        replacedertThat(listener.afterSaveEvents.get(0).getSource(), is(john));
    }

    @Test
    public void updateMultiSaveEvent() {
        template.insert(customers, Customer.clreplaced);
        listener.beforeSaveEvents.clear();
        listener.afterSaveEvents.clear();
        john.setId("non-existing-id");
        bob.setAge(30);
        template.update(customers, Customer.clreplaced);
        replacedertThat(listener.beforeSaveEvents.size(), is(2));
        for (final BeforeSaveEvent<Customer> event : listener.beforeSaveEvents) {
            replacedertThat(event.getSource(), isIn(customers));
        }
        replacedertThat(listener.afterSaveEvents.size(), is(1));
        replacedertThat(listener.afterSaveEvents.get(0).getSource(), is(bob));
    }

    @Test
    public void replaceSingleSaveEvent() {
        template.insert(john);
        listener.beforeSaveEvents.clear();
        listener.afterSaveEvents.clear();
        john.setAge(30);
        template.replace(john.getId(), john);
        replacedertThat(listener.beforeSaveEvents.size(), is(1));
        replacedertThat(listener.beforeSaveEvents.get(0).getSource(), is(john));
        replacedertThat(listener.afterSaveEvents.size(), is(1));
        replacedertThat(listener.afterSaveEvents.get(0).getSource(), is(john));
    }

    @Test
    public void replaceMultiSaveEvent() {
        template.insert(customers, Customer.clreplaced);
        listener.beforeSaveEvents.clear();
        listener.afterSaveEvents.clear();
        john.setId("non-existing-id");
        bob.setAge(30);
        template.replace(customers, Customer.clreplaced);
        replacedertThat(listener.beforeSaveEvents.size(), is(2));
        for (final BeforeSaveEvent<Customer> event : listener.beforeSaveEvents) {
            replacedertThat(event.getSource(), isIn(customers));
        }
        replacedertThat(listener.afterSaveEvents.size(), is(1));
        replacedertThat(listener.afterSaveEvents.get(0).getSource(), is(bob));
    }
}

/**
 * @author Christian Lechner
 */
public clreplaced DeleteEventTest extends AbstractArangoTest {

    @Autowired
    private CustomerEventListener listener;

    private Customer john;

    private Customer bob;

    private List<Customer> customers;

    public DeleteEventTest() {
        super(Customer.clreplaced);
    }

    @Before
    public void createMockCustomers() {
        john = new Customer("John", "Smith", 20);
        bob = new Customer("Bob", "Thompson", 40);
        customers = new ArrayList<>();
        customers.add(john);
        customers.add(bob);
    }

    @Before
    public void clearEvents() {
        listener.beforeDeleteEvents.clear();
        listener.afterDeleteEvents.clear();
    }

    @Test
    public void deleteSingleDeleteEvent() {
        template.insert(john);
        template.delete(john.getId(), Customer.clreplaced);
        replacedertThat(listener.beforeDeleteEvents.size(), is(1));
        replacedertThat(listener.beforeDeleteEvents.get(0).getSource(), is(john.getId()));
        replacedertThat(listener.afterDeleteEvents.size(), is(1));
        replacedertThat(listener.afterDeleteEvents.get(0).getSource(), is(john.getId()));
    }

    @Test
    public void deleteMultiDeleteEvent() {
        template.insert(customers, Customer.clreplaced);
        final List<Object> ids = customers.stream().map(c -> c.getId()).collect(Collectors.toList());
        ids.set(0, "non-existing-id");
        template.delete(ids, Customer.clreplaced);
        replacedertThat(listener.beforeDeleteEvents.size(), is(2));
        for (final BeforeDeleteEvent<Customer> event : listener.beforeDeleteEvents) {
            replacedertThat(event.getSource(), isIn(ids));
        }
        replacedertThat(listener.afterDeleteEvents.size(), is(1));
        replacedertThat(listener.afterDeleteEvents.get(0).getSource(), is(bob.getId()));
    }
}

/**
 * @author Christian Lechner
 */
public clreplaced AfterLoadEventTest extends AbstractArangoTest {

    @Autowired
    private CustomerEventListener listener;

    private Customer john;

    private Customer bob;

    private List<Customer> customers;

    public AfterLoadEventTest() {
        super(Customer.clreplaced);
    }

    @Before
    public void createMockCustomers() {
        john = new Customer("John", "Smith", 20);
        bob = new Customer("Bob", "Thompson", 40);
        customers = new ArrayList<>();
        customers.add(john);
        customers.add(bob);
    }

    @Before
    public void clearEvents() {
        listener.afterLoadEvents.clear();
    }

    @Test
    public void findSingleAfterLoadEvent() {
        template.insert(john);
        template.find(john.getId(), Customer.clreplaced);
        replacedertThat(listener.afterLoadEvents.size(), is(1));
        replacedertThat(listener.afterLoadEvents.get(0).getSource(), is(john));
    }

    @Test
    public void findMultiAfterLoadEvent() {
        template.insert(customers, Customer.clreplaced);
        template.find(customers.stream().map(elem -> elem.getId()).collect(Collectors.toList()), Customer.clreplaced);
        replacedertThat(listener.afterLoadEvents.size(), is(2));
        for (final AfterLoadEvent<Customer> event : listener.afterLoadEvents) {
            replacedertThat(event.getSource(), isIn(customers));
        }
    }

    @Test
    public void findAllAfterLoadEvent() {
        template.insert(customers, Customer.clreplaced);
        template.findAll(Customer.clreplaced).forEach(elem -> {
        // trigger conversion
        });
        replacedertThat(listener.afterLoadEvents.size(), is(2));
        for (final AfterLoadEvent<Customer> event : listener.afterLoadEvents) {
            replacedertThat(event.getSource(), isIn(customers));
        }
    }

    @Test
    public void findByQueryAfterLoadEvent() {
        template.insert(customers, Customer.clreplaced);
        template.query("FOR c IN @@collection FILTER c.name == @name RETURN c", new MapBuilder().put("@collection", Customer.clreplaced).put("name", john.getName()).get(), Customer.clreplaced).forEach(elem -> {
        // trigger conversion
        });
        replacedertThat(listener.afterLoadEvents.size(), is(1));
        for (final AfterLoadEvent<Customer> event : listener.afterLoadEvents) {
            replacedertThat(event.getSource(), is(john));
        }
    }
}

@Test
public void findOneByExampleTest() {
    repository.save(john);
    final Customer customer = repository.findOne(Example.of(john)).get();
    replacedertEquals("customers do not match", john, customer);
}

/**
 * Created by F625633 on 12/07/2017.
 */
public abstract clreplaced AbstractArangoRepositoryTest extends AbstractArangoTest {

    @Autowired
    protected CustomerRepository repository;

    @Autowired
    protected ShoppingCartRepository shoppingCartRepository;

    protected Customer john;

    protected Customer bob;

    protected Set<Customer> customers;

    protected Set<String> ids;

    protected Comparator<Object> cmp = Comparator.comparing(o -> ((Customer) o).getId());

    protected BiPredicate<Object, Object> eq = (a, b) -> cmp.compare(a, b) == 0;

    @SuppressWarnings("unchecked")
    protected Comparator<Object> geoCmp = Comparator.comparing(o -> ((GeoResult<Customer>) o).getContent().getId());

    protected BiPredicate<Object, Object> geoEq = (o1, o2) -> geoCmp.compare(o1, o2) == 0;

    public AbstractArangoRepositoryTest() {
        super(Customer.clreplaced, Address.clreplaced, ShoppingCart.clreplaced, Product.clreplaced, Material.clreplaced, Contains.clreplaced, Owns.clreplaced);
    }

    @Before
    public void createMockCustomers() {
        john = new Customer("John", "Smith", 20);
        bob = new Customer("Bob", "Thompson", 40);
        customers = new HashSet<>();
        customers.add(john);
        customers.add(bob);
        ids = new HashSet<>();
    }

    @SuppressWarnings({ "rawtypes", "unchecked" })
    protected boolean equals(final Object it1, final Object it2, final Comparator<Object> cmp, final BiPredicate<Object, Object> eq, final boolean shouldOrderMatter) {
        final Function<Object, List> iterableToSortedList = it -> {
            final List l = new ArrayList();
            if (it != null) {
                if (it.getClreplaced().isArray()) {
                    final Object[] array = (Object[]) it;
                    for (final Object e : array) {
                        l.add(e);
                    }
                } else {
                    final Iterable iterable = (Iterable) it;
                    for (final Object e : iterable) {
                        l.add(e);
                    }
                }
            }
            if (!shouldOrderMatter) {
                l.sort(cmp);
            }
            return l;
        };
        final List l1 = iterableToSortedList.apply(it1);
        final List l2 = iterableToSortedList.apply(it2);
        if (l1.size() != l2.size()) {
            return false;
        }
        for (int i = 0; i < l1.size(); ++i) {
            if (!eq.test(l1.get(i), l2.get(i))) {
                return false;
            }
        }
        return true;
    }
}

@Test
public void countTest() {
    final List<Integer> integerList = new LinkedList<>();
    integerList.add(99);
    integerList.add(999);
    repository.save(new Customer("", "", 19));
    final Customer customer = new Customer("", "", 17);
    customer.setIntegerList(integerList);
    repository.save(customer);
    repository.save(new Customer("", "", 18));
    final int retrieved = repository.countByAgeGreaterThanOrStringArrayNullAndIntegerList(18, integerList);
    replacedertEquals(2, retrieved);
}

@Test
public void findByStringContainingIgnoreCase() {
    final Customer c1 = new Customer("abc", "", 0);
    final Customer c2 = new Customer("Abc", "", 0);
    final Customer c3 = new Customer("abcd", "", 0);
    final Customer c4 = new Customer("ab", "", 0);
    repository.save(c1);
    repository.save(c2);
    repository.save(c3);
    repository.save(c4);
    final Collection<Customer> toBeRetrieved = new LinkedList<>();
    toBeRetrieved.add(c1);
    toBeRetrieved.add(c2);
    toBeRetrieved.add(c3);
    final Collection<Customer> retrieved = repository.findByNameContainingIgnoreCase("abc");
    replacedertTrue(equals(retrieved, toBeRetrieved, cmp, eq, false));
}

@Test
public void findByStringContaining() {
    final Customer c1 = new Customer("abc", "", 0);
    final Customer c2 = new Customer("Abc", "", 0);
    final Customer c3 = new Customer("abcd", "", 0);
    final Customer c4 = new Customer("ab", "", 0);
    repository.save(c1);
    repository.save(c2);
    repository.save(c3);
    repository.save(c4);
    final Collection<Customer> toBeRetrieved = new LinkedList<>();
    toBeRetrieved.add(c1);
    toBeRetrieved.add(c3);
    final Collection<Customer> retrieved = repository.findByNameContaining("abc");
    replacedertTrue(equals(retrieved, toBeRetrieved, cmp, eq, false));
}

@Test
public void existsAndStringListAllIgnoreCaseTest() {
    final List<String> stringList = new LinkedList<>();
    stringList.add("qweRty");
    final List<String> stringList2 = new LinkedList<>();
    stringList2.add("qwerty");
    final List<String> stringList3 = new LinkedList<>();
    stringList3.add("qwety");
    final List<Customer> toBeRetrieved = new LinkedList<>();
    final Customer customer1 = new Customer("", "", 0);
    customer1.setStringList(stringList);
    customer1.setNestedCustomer(new Customer("nested", "", 0));
    toBeRetrieved.add(customer1);
    repository.saveAll(toBeRetrieved);
    final Customer customer2 = new Customer("", "", 0);
    customer2.setStringList(stringList3);
    repository.save(customer2);
    template.insert(new IncompleteCustomer("Incomplete", stringList2));
    final Customer[] retrieved = repository.findByNestedCustomerAliveExistsAndStringListAllIgnoreCase(stringList2);
    replacedertTrue(equals(toBeRetrieved, retrieved, cmp, eq, false));
}

@Test
public void findOneByOverridingNameAndBindVarsAqlTest() {
    repository.saveAll(customers);
    final Map<String, Object> bindVars = new HashMap<>();
    bindVars.put("id", john.getId());
    bindVars.put("name", john.getId() + "random");
    final Customer retrieved = repository.findOneByNameAndBindVarsAql(john.getName(), bindVars);
    replacedertEquals(john, retrieved);
}

@Test
public void findOneByIdAndNameWithBindVarsAqlTest() {
    repository.saveAll(customers);
    final Map<String, Object> bindVars = new HashMap<>();
    bindVars.put("id", john.getId());
    bindVars.put("0", john.getName() + "random");
    final Customer retrieved = repository.findOneByIdAndNameWithBindVarsAql(john.getName(), bindVars);
    replacedertEquals(john, retrieved);
}

@Test
public void findOneByComplementingNameAndBindVarsAqlTest() {
    repository.saveAll(customers);
    final Map<String, Object> bindVars = new HashMap<>();
    bindVars.put("id", john.getId());
    final Customer retrieved = repository.findOneByNameAndBindVarsAql(john.getName(), bindVars);
    replacedertEquals(john, retrieved);
}

@SuppressWarnings("deprecation")
@Test
public void upsertReplace() {
    final Customer customer = new Customer("John", "Doe", 30);
    template.upsert(customer, UpsertStrategy.REPLACE);
    replacedertThat(template.find(customer.getId(), Customer.clreplaced).get().getAge(), is(30));
    customer.setAge(35);
    template.upsert(customer, UpsertStrategy.REPLACE);
    replacedertThat(template.find(customer.getId(), Customer.clreplaced).get().getAge(), is(35));
}

@Test
public void findTopOrderTest() {
    final String[] stringArray = { "b", "Cf", "aaA" };
    final List<Integer> integerList = new LinkedList<>();
    integerList.add(666);
    final int[] ages = { 7, 11, 19 };
    final String[] names = { "cTa", "Rfh", "JwA" };
    final List<Customer> toBeRetrieved = new LinkedList<>();
    final Customer customer1 = new Customer("JwA", "", 11);
    customer1.setStringArray(stringArray);
    toBeRetrieved.add(customer1);
    final Customer customer2 = new Customer("zzz", "", 19);
    customer2.setIntegerList(integerList);
    toBeRetrieved.add(customer2);
    final Customer customer3 = new Customer("cTa", "", 19);
    customer3.setStringArray(stringArray);
    toBeRetrieved.add(customer3);
    repository.saveAll(toBeRetrieved);
    final Customer customer4 = new Customer("AAA", "", 19);
    customer4.setIntegerList(integerList);
    repository.save(customer4);
    final Customer customer5 = new Customer("CtA", "", 6);
    customer5.setStringArray(stringArray);
    repository.save(customer5);
    final Customer customer6 = new Customer("rFH", "", 7);
    customer6.setIntegerList(integerList);
    repository.save(customer6);
    final Iterable<Customer> retrieved = repository.findTop3ByAgeInAndStringArrayIgnoreCaseOrNameNotInAndIntegerListIgnoreCaseOrderByAgeAscNameDescAllIgnoreCase(ages, new String[] { "B", "cF", "AAa" }, names, integerList);
    replacedertTrue(equals(toBeRetrieved, retrieved, cmp, eq, true));
}

@Test
public void twoRelationsSingleLevelTest() {
    final List<Customer> toBeRetrieved = new LinkedList<>();
    final List<Customer> customers = new LinkedList<>();
    List<Customer> retrieved;
    final Customer john = new Customer("John", "Smith", 52);
    final Customer adam = new Customer("Adam", "Smith", 294);
    final Customer matt = new Customer("Matt", "Smith", 34);
    final Product phone = new Product("phone");
    final Product car = new Product("car");
    final Product chair = new Product("chair");
    template.insert(phone);
    template.insert(car);
    template.insert(chair);
    customers.add(john);
    customers.add(matt);
    customers.add(adam);
    repository.saveAll(customers);
    template.insert(new Owns(john, phone));
    template.insert(new Owns(john, car));
    template.insert(new Owns(adam, chair));
    template.insert(new Owns(matt, phone));
    template.insert(new Owns(matt, car));
    template.insert(new Owns(matt, chair));
    toBeRetrieved.add(john);
    toBeRetrieved.add(matt);
    retrieved = repository.getByOwnsNameAndOwns2Name(phone.getName(), phone.getName());
    replacedertTrue(equals(toBeRetrieved, retrieved, cmp, eq, false));
}

@Test
public void NotContainingTest() {
    final Collection<Customer> toBeRetrieved = new LinkedList<>();
    final Customer customer1 = new Customer("A", "B", 55);
    final Customer customer2 = new Customer("C", "D", 44);
    customer1.setStringArray(new String[] { "hello", "greetings" });
    customer2.setStringArray(new String[] { "goodbye", "see you later" });
    toBeRetrieved.add(customer2);
    repository.save(customer1);
    repository.save(customer2);
    final Collection<Customer> retrieved = repository.findByStringArrayNotContainingIgnoreCase("Hello");
    replacedertTrue(equals(retrieved, toBeRetrieved, cmp, eq, false));
}

@Test
public void polygonTest() {
    final int[][] locations = { { 11, 31 }, { 20, 20 }, { 20, 40 }, { 70, 30 }, { 40, 10 }, { -10, -10 }, { -10, 20 }, { -10, 60 }, { 30, 50 }, { 10, 20 }, { 5, 30 } };
    final Customer[] customers = new Customer[11];
    final List<Customer> toBeRetrieved = new LinkedList<>();
    for (int i = 0; i < customers.length; ++i) {
        customers[i] = new Customer("", "", 0);
        customers[i].setLocation(locations[i]);
        repository.save(customers[i]);
        if (i < 3) {
            toBeRetrieved.add(customers[i]);
        }
    }
    final Polygon polygon = new Polygon(new Point(0, 0), new Point(30, 60), new Point(50, 0), new Point(30, 10), new Point(30, 20));
    final List<Customer> retrieved = repository.findByLocationWithin(polygon);
    replacedertTrue(equals(toBeRetrieved, retrieved, cmp, eq, false));
}

@Test
public void geoResultTest() {
    final Customer customer1 = new Customer("", "", 0);
    customer1.setLocation(new int[] { 7, 5 });
    repository.save(customer1);
    final Customer customer2 = new Customer("", "", 0);
    customer2.setLocation(new int[] { 70, 50 });
    repository.save(customer2);
    final double distance = convertAngleToDistance(10);
    final GeoResult<Customer> retrieved = repository.queryByLocationWithin(new Point(1, 2), distance);
    final double expectedDistanceInMeters = getDistanceBetweenPoints(new Point(5, 7), new Point(1, 2));
    final double expectedNormalizedDistance = expectedDistanceInMeters / 1000.0 / Metrics.KILOMETERS.getMultiplier();
    replacedertEquals(customer1, retrieved.getContent());
    replacedertEquals(expectedNormalizedDistance, retrieved.getDistance().getNormalizedValue(), 0.000000001);
}

@Test
public void findDistinctOrderTest() {
    final String[] stringArray = { "b", "Cf", "aaA" };
    final List<Integer> integerList = new LinkedList<>();
    integerList.add(666);
    final List<Customer> toBeRetrieved = new LinkedList<>();
    toBeRetrieved.add(new Customer("A", "", 99));
    final Customer customer1 = new Customer("dt", "", 0);
    customer1.setStringArray(stringArray);
    toBeRetrieved.add(customer1);
    final Customer customer2 = new Customer("dt", "", 1);
    customer2.setIntegerList(integerList);
    toBeRetrieved.add(customer2);
    repository.saveAll(toBeRetrieved);
    repository.save(new Customer("aaa", "", 17));
    final Customer customer3 = new Customer("DTHB", "", 17);
    customer3.setStringArray(stringArray);
    repository.save(customer3);
    final Customer[] retrieved = repository.findDistinctByAgeGreaterThanEqualOrStringArrayAndNameBeforeOrIntegerListOrderByNameAscAgeAscAllIgnoreCase(18, new String[] { "B", "cF", "AAa" }, "dThB", integerList);
    replacedertTrue(equals(toBeRetrieved, retrieved, cmp, eq, true));
}

@Test
public void findByLocationWithinBoxTest() {
    final List<Customer> toBeRetrieved = new LinkedList<>();
    final Customer customer1 = new Customer("", "", 0);
    customer1.setLocation(new int[] { 10, 10 });
    toBeRetrieved.add(customer1);
    repository.saveAll(toBeRetrieved);
    final Customer customer2 = new Customer("", "", 0);
    customer2.setLocation(new int[] { 0, 0 });
    repository.save(customer2);
    final Customer customer3 = new Customer("", "", 0);
    customer3.setLocation(new int[] { 0, 10 });
    repository.save(customer3);
    final Customer customer4 = new Customer("", "", 0);
    customer4.setLocation(new int[] { 0, 20 });
    repository.save(customer4);
    final Customer customer5 = new Customer("", "", 0);
    customer5.setLocation(new int[] { 10, 0 });
    repository.save(customer5);
    final Customer customer6 = new Customer("", "", 0);
    customer6.setLocation(new int[] { 10, 20 });
    repository.save(customer6);
    final Customer customer7 = new Customer("", "", 0);
    customer7.setLocation(new int[] { 20, 0 });
    repository.save(customer7);
    final Customer customer8 = new Customer("", "", 0);
    customer8.setLocation(new int[] { 20, 10 });
    repository.save(customer8);
    final Customer customer9 = new Customer("", "", 0);
    customer9.setLocation(new int[] { 20, 20 });
    repository.save(customer9);
    final List<Customer> retrieved = repository.findByLocationWithin(new Box(new Point(5, 5), new Point(15, 15)));
    replacedertTrue(equals(toBeRetrieved, retrieved, cmp, eq, false));
}

@Test
public void relationsSingleLevelTest() {
    final List<Customer> toBeRetrieved = new LinkedList<>();
    final List<Customer> customers = new LinkedList<>();
    List<Customer> retrieved;
    final Customer john = new Customer("John", "Smith", 52);
    final Customer adam = new Customer("Adam", "Smith", 294);
    final Customer matt = new Customer("Matt", "Smith", 34);
    final Product phone = new Product("phone");
    final Product car = new Product("car");
    final Product chair = new Product("chair");
    template.insert(phone);
    template.insert(car);
    template.insert(chair);
    customers.add(john);
    customers.add(matt);
    customers.add(adam);
    repository.saveAll(customers);
    template.insert(new Owns(john, phone));
    template.insert(new Owns(john, car));
    template.insert(new Owns(adam, chair));
    template.insert(new Owns(matt, phone));
    template.insert(new Owns(matt, car));
    template.insert(new Owns(matt, chair));
    toBeRetrieved.add(john);
    toBeRetrieved.add(matt);
    retrieved = repository.getByOwnsName(phone.getName());
    replacedertTrue(equals(toBeRetrieved, retrieved, cmp, eq, false));
}

@Test
public void staticAndDynamicSortTest() {
    final List<Customer> toBeRetrieved = new LinkedList<>();
    toBeRetrieved.add(new Customer("Tony", "1", 5));
    toBeRetrieved.add(new Customer("Tony", "2", 3));
    toBeRetrieved.add(new Customer("Tony", "2", 4));
    repository.saveAll(toBeRetrieved);
    repository.save(new Customer("Stark", "0", 0));
    final Customer[] retrieved = repository.findByNameOrderBySurnameAsc(Sort.by("age"), "Tony");
    replacedertTrue(equals(toBeRetrieved, retrieved, cmp, eq, true));
}

@Test
public void replaceDoreplacedent() {
    final DoreplacedentEnreplacedy res = template.insert(new Customer("John", "Doe", 30));
    final DoreplacedentEnreplacedy replaceDoreplacedent = template.replace(res.getId(), new Customer("Jane", "Doe", 26));
    replacedertThat(replaceDoreplacedent, is(notNullValue()));
    final Customer customer = template.find(res.getId(), Customer.clreplaced).get();
    replacedertThat(customer, is(notNullValue()));
    replacedertThat(customer.getName(), is("Jane"));
    replacedertThat(customer.getSurname(), is("Doe"));
    replacedertThat(customer.getAge(), is(26));
}

@Test
public void updateDoreplacedent() {
    final DoreplacedentEnreplacedy res = template.insert(new Customer("John", "Doe", 30));
    template.update(res.getId(), new Customer("Jane", "Doe", 26));
    final Customer customer = template.find(res.getId(), Customer.clreplaced).get();
    replacedertThat(customer, is(notNullValue()));
    replacedertThat(customer.getName(), is("Jane"));
    replacedertThat(customer.getSurname(), is("Doe"));
    replacedertThat(customer.getAge(), is(26));
}

@SuppressWarnings("deprecation")
@Test
public void upsertReplaceMultiple() {
    final Customer c1 = new Customer("John", "Doe", 30);
    final Customer c2 = new Customer("John2", "Doe2", 30);
    template.upsert(Arrays.asList(c1, c2), UpsertStrategy.REPLACE);
    replacedertThat(template.find(c1.getId(), Customer.clreplaced).get().getAge(), is(30));
    replacedertThat(template.find(c2.getId(), Customer.clreplaced).get().getAge(), is(30));
    c1.setAge(35);
    c2.setAge(35);
    final Customer c3 = new Customer("John3", "Doe2", 30);
    template.upsert(Arrays.asList(c1, c2, c3), UpsertStrategy.REPLACE);
    replacedertThat(template.find(c1.getId(), Customer.clreplaced).get().getAge(), is(35));
    replacedertThat(template.find(c2.getId(), Customer.clreplaced).get().getAge(), is(35));
    replacedertThat(template.find(c3.getId(), Customer.clreplaced).get().getAge(), is(30));
}

@SuppressWarnings("deprecation")
@Test
public void upsertUpdate() {
    final Customer customer = new Customer("John", "Doe", 30);
    template.upsert(customer, UpsertStrategy.UPDATE);
    replacedertThat(template.find(customer.getId(), Customer.clreplaced).get().getAge(), is(30));
    customer.setAge(35);
    template.upsert(customer, UpsertStrategy.UPDATE);
    replacedertThat(template.find(customer.getId(), Customer.clreplaced).get().getAge(), is(35));
}

@Test
public void relationsMultiLevelTest() {
    final List<Customer> toBeRetrieved = new LinkedList<>();
    final List<Customer> customers = new LinkedList<>();
    List<Customer> retrieved;
    final Customer john = new Customer("John", "Smith", 52);
    final Customer adam = new Customer("Adam", "Smith", 294);
    final Customer matt = new Customer("Matt", "Smith", 34);
    final Product phone = new Product("phone");
    final Product car = new Product("car");
    final Product chair = new Product("chair");
    template.insert(phone);
    template.insert(car);
    template.insert(chair);
    final Material wood = new Material("wood");
    final Material metal = new Material("metal");
    final Material glreplaced = new Material("glreplaced");
    template.insert(wood);
    template.insert(metal);
    template.insert(glreplaced);
    customers.add(john);
    customers.add(matt);
    customers.add(adam);
    repository.saveAll(customers);
    template.insert(new Owns(john, phone));
    template.insert(new Owns(john, car));
    template.insert(new Owns(adam, chair));
    template.insert(new Owns(matt, phone));
    template.insert(new Owns(matt, car));
    template.insert(new Owns(matt, chair));
    template.insert(new Contains(phone, glreplaced));
    template.insert(new Contains(car, metal));
    template.insert(new Contains(car, glreplaced));
    template.insert(new Contains(chair, wood));
    toBeRetrieved.add(adam);
    toBeRetrieved.add(matt);
    retrieved = repository.getByOwnsContainsName(wood.getName());
    replacedertTrue(equals(toBeRetrieved, retrieved, cmp, eq, false));
}

@Test
public void findTopDistinctTest() {
    final List<Customer> toBeRetrieved = new LinkedList<>();
    final Customer customer1 = new Customer("A", "", 0);
    final List<Integer> integerList = new LinkedList<>();
    integerList.add(99);
    customer1.setIntegerList(integerList);
    toBeRetrieved.add(customer1);
    final Customer customer2 = new Customer("B", "", 0);
    customer2.setStringArray(new String[] { "stRing" });
    toBeRetrieved.add(customer2);
    repository.saveAll(toBeRetrieved);
    final Customer customer3 = new Customer("C", "", 0);
    customer3.setIntegerList(integerList);
    repository.save(customer3);
    repository.save(new Customer("A", "", 0));
    final Collection<Customer> retrieved = repository.findTop2DistinctByStringArrayContainingIgnoreCaseOrIntegerListNotNullIgnoreCaseOrderByNameAsc("string");
    replacedertTrue(equals(toBeRetrieved, retrieved, cmp, eq, true));
}

@Test
public void exampleWithLikeAndEscapingTest() {
    String NAME = "Abc+Def";
    final Customer enreplacedy = new Customer(NAME, "surname", 10);
    repository.save(enreplacedy);
    final Customer probe = new Customer();
    probe.setName("Abc+De%");
    probe.setAge(10);
    final Example<Customer> example = Example.of(probe);
    final Optional<Customer> retrieved = repository.findOne(example);
    replacedertThat(retrieved.isPresent(), is(false));
}

@Test
public void findAllByExampleTest() {
    final List<Customer> toBeRetrieved = new LinkedList<>();
    final Customer check1 = new Customer("B", "X", 0);
    final Customer check2 = new Customer("B", "Y", 0);
    toBeRetrieved.add(new Customer("A", "Z", 0));
    toBeRetrieved.add(check1);
    toBeRetrieved.add(check2);
    toBeRetrieved.add(new Customer("C", "V", 0));
    repository.saveAll(toBeRetrieved);
    final Example<Customer> example = Example.of(new Customer("B", null, 0));
    final Iterable<?> retrieved = repository.findAll(example);
    final List<Customer> retrievedList = new LinkedList<>();
    retrieved.forEach(e -> retrievedList.add((Customer) e));
    final List<Customer> checkList = new LinkedList<>();
    checkList.add(check1);
    checkList.add(check2);
    replacedertTrue(equals(checkList, retrievedList, cmp, eq, false));
}

@Test
public void existsByExampleTest() {
    final List<Customer> toBeRetrieved = new LinkedList<>();
    final Customer checker = new Customer("I", "Exist", 25, true);
    toBeRetrieved.add(new Customer("A", "Z", 0));
    toBeRetrieved.add(new Customer("B", "X", 0));
    toBeRetrieved.add(new Customer("B", "Y", 0));
    toBeRetrieved.add(new Customer("C", "V", 0));
    toBeRetrieved.add(checker);
    repository.saveAll(toBeRetrieved);
    final Example<Customer> example = Example.of(checker);
    final boolean exists = repository.exists(example);
    replacedertTrue(exists);
}

@Test
public void getDoreplacedent() {
    final DoreplacedentEnreplacedy res = template.insert(new Customer("John", "Doe", 30, new Address("22162–1010")));
    final Customer customer = template.find(res.getId(), Customer.clreplaced).get();
    replacedertThat(customer, is(notNullValue()));
    replacedertThat(customer.getName(), is("John"));
    replacedertThat(customer.getSurname(), is("Doe"));
    replacedertThat(customer.getAge(), is(30));
    replacedertThat(customer.getAddress(), is(notNullValue()));
    replacedertThat(customer.getAddress().getZipCode(), is("22162–1010"));
}

@Test
public void getAllDoreplacedents() {
    final Customer c1 = new Customer("John", "Doe", 30);
    final Customer c2 = new Customer("John2", "Doe", 30);
    template.insert(Arrays.asList(c1, c2), Customer.clreplaced);
    final Iterable<Customer> customers = template.findAll(Customer.clreplaced);
    replacedertThat(customers, is(notNullValue()));
    replacedertThat(StreamSupport.stream(customers.spliterator(), false).map((e) -> e.getId()).collect(Collectors.toList()), hasItems(c1.getId(), c2.getId()));
}

@SuppressWarnings("deprecation")
@Test
public void upsertUpdateMultiple() {
    final Customer c1 = new Customer("John", "Doe", 30);
    final Customer c2 = new Customer("John2", "Doe2", 30);
    template.upsert(Arrays.asList(c1, c2), UpsertStrategy.UPDATE);
    replacedertThat(template.find(c1.getId(), Customer.clreplaced).get().getAge(), is(30));
    replacedertThat(template.find(c2.getId(), Customer.clreplaced).get().getAge(), is(30));
    c1.setAge(35);
    c2.setAge(35);
    final Customer c3 = new Customer("John3", "Doe2", 30);
    template.upsert(Arrays.asList(c1, c2, c3), UpsertStrategy.UPDATE);
    replacedertThat(template.find(c1.getId(), Customer.clreplaced).get().getAge(), is(35));
    replacedertThat(template.find(c2.getId(), Customer.clreplaced).get().getAge(), is(35));
    replacedertThat(template.find(c3.getId(), Customer.clreplaced).get().getAge(), is(30));
}

@Test
public void findWithinOrNearTest() {
    final List<Customer> toBeRetrieved = new LinkedList<>();
    final Customer customer1 = new Customer("---", "", 0);
    customer1.setLocation(new int[] { 45, 2 });
    toBeRetrieved.add(customer1);
    final Customer customer2 = new Customer("+++", "", 0);
    customer2.setLocation(new int[] { 60, 1 });
    toBeRetrieved.add(customer2);
    repository.saveAll(toBeRetrieved);
    final Customer customer3 = new Customer("---", "", 0);
    customer3.setLocation(new int[] { 0, 180 });
    repository.save(customer3);
    final double distanceInMeters = convertAngleToDistance(30);
    final Distance distance = new Distance(distanceInMeters / 1000, Metrics.KILOMETERS);
    final Circle circle = new Circle(new Point(0, 20), distance);
    final Iterable<Customer> retrieved = repository.findByLocationWithinOrNameAndLocationNear(circle, "+++", new Point(0, 0));
    replacedertTrue(equals(toBeRetrieved, retrieved, cmp, eq, false));
}

@Test
public void startingWithByExampleTest() {
    final List<Customer> toBeRetrieved = new LinkedList<>();
    final Customer check = new Customer("Abba", "Bbaaaa", 100);
    toBeRetrieved.add(check);
    toBeRetrieved.add(new Customer("Baabba", "", 67));
    toBeRetrieved.add(new Customer("B", "", 43));
    toBeRetrieved.add(new Customer("C", "", 76));
    repository.saveAll(toBeRetrieved);
    final Example<Customer> example = Example.of(new Customer(null, "bb", 100), ExampleMatcher.matching().withMatcher("surname", match -> match.startsWith()).withIgnoreCase("surname").withIgnoreNullValues());
    final Customer retrieved = repository.findOne(example).get();
    replacedertEquals(check, retrieved);
}

@Test
public void findAllByExampleWhitArrayStringTest() {
    final List<Customer> toBeRetrieved = new LinkedList<>();
    final Customer customer1 = new Customer("AbbaXP", "BbaaaaXZ", 1001);
    final Customer customer2 = new Customer("Bwa?[a.b]baAaGH", "", 67);
    customer1.setStringList(Arrays.asList("testA", "testB", "testC"));
    customer2.setStringList(Arrays.asList("test1", "test2", "test3"));
    toBeRetrieved.add(customer1);
    toBeRetrieved.add(customer2);
    repository.saveAll(toBeRetrieved);
    final Customer exampleCustomer = new Customer("AbbaXP", "BbaaaaXZ", 1001);
    exampleCustomer.setStringList(Arrays.asList("testB"));
    final Example<Customer> example = Example.of(exampleCustomer);
    final Customer retrieved = repository.findOne(example).get();
    replacedertEquals(customer1, retrieved);
}

@Test
public void plusSignExampleTest() {
    String NAME = "Abc+Def";
    final Customer enreplacedy = new Customer(NAME, "surname", 10);
    repository.save(enreplacedy);
    final Customer probe = new Customer();
    probe.setName(NAME);
    probe.setAge(10);
    final Example<Customer> example = Example.of(probe);
    final Optional<Customer> retrieved = repository.findOne(example);
    replacedertThat(retrieved.isPresent(), is(true));
    replacedertThat(retrieved.get().getName(), is(NAME));
}

@Test
public void getDoreplacedents() {
    final Customer c1 = new Customer("John", "Doe", 30);
    final Customer c2 = new Customer("John2", "Doe", 30);
    template.insert(Arrays.asList(c1, c2), Customer.clreplaced);
    final Iterable<Customer> customers = template.find(Arrays.asList(c1.getId(), c2.getId()), Customer.clreplaced);
    replacedertThat(customers, is(notNullValue()));
    replacedertThat(StreamSupport.stream(customers.spliterator(), false).map((e) -> e.getId()).collect(Collectors.toList()), hasItems(c1.getId(), c2.getId()));
    for (final Customer customer : customers) {
        replacedertThat(customer.getArangoId(), is(notNullValue()));
    }
}

@Test
public void geoResultsTest() {
    final List<Customer> toBeRetrieved = new LinkedList<>();
    final Customer customer1 = new Customer("", "", 0);
    customer1.setLocation(new int[] { 43, 21 });
    toBeRetrieved.add(customer1);
    final Customer customer2 = new Customer("", "", 0);
    customer2.setLocation(new int[] { 21, 43 });
    toBeRetrieved.add(customer2);
    repository.saveAll(toBeRetrieved);
    final Customer customer3 = new Customer("", "", 0);
    customer3.setLocation(new int[] { 70, 50 });
    repository.save(customer3);
    final Customer customer4 = new Customer("", "", 0);
    customer4.setLocation(new int[] { 3, 2 });
    repository.save(customer4);
    final Bound<Double> lowerBound = Bound.inclusive(convertAngleToDistance(30));
    final Bound<Double> upperBound = Bound.inclusive(convertAngleToDistance(50));
    final GeoResults<Customer> retrieved = repository.findByLocationWithin(new Point(1, 0), Range.of(lowerBound, upperBound));
    final List<GeoResult<Customer>> expectedGeoResults = new LinkedList<>();
    expectedGeoResults.add(new GeoResult<>(customer1, new Distance(getDistanceBetweenPoints(new Point(1, 0), new Point(21, 43)) / 1000, Metrics.KILOMETERS)));
    expectedGeoResults.add(new GeoResult<>(customer2, new Distance(getDistanceBetweenPoints(new Point(1, 0), new Point(43, 21)) / 1000, Metrics.KILOMETERS)));
    replacedertTrue(equals(expectedGeoResults, retrieved, geoCmp, geoEq, false));
}

@Test
public void geoPageTest() {
    final Customer customer1 = new Customer("", "", 0);
    customer1.setLocation(new int[] { 2, 0 });
    repository.save(customer1);
    final Customer customer2 = new Customer("", "", 0);
    customer2.setLocation(new int[] { 3, 0 });
    repository.save(customer2);
    final Customer customer3 = new Customer("", "", 0);
    customer3.setLocation(new int[] { 4, 0 });
    repository.save(customer3);
    final Customer customer4 = new Customer("", "", 0);
    customer4.setLocation(new int[] { 6, 0 });
    repository.save(customer4);
    final GeoPage<Customer> retrieved = repository.findByLocationNear(new Point(0, 0), PageRequest.of(1, 2));
    final List<GeoResult<Customer>> expectedGeoResults = new LinkedList<>();
    expectedGeoResults.add(new GeoResult<>(customer3, new Distance(getDistanceBetweenPoints(new Point(0, 0), new Point(0, 4)) / 1000, Metrics.KILOMETERS)));
    expectedGeoResults.add(new GeoResult<>(customer4, new Distance(getDistanceBetweenPoints(new Point(0, 0), new Point(0, 6)) / 1000, Metrics.KILOMETERS)));
    replacedertEquals(4, retrieved.getTotalElements());
    replacedertEquals(2, retrieved.getTotalPages());
    replacedertTrue(equals(expectedGeoResults, retrieved, geoCmp, geoEq, true));
}

@Test
public void findWithinAndWithinTest() {
    final List<Customer> toBeRetrieved = new LinkedList<>();
    final Customer customer1 = new Customer("+++", "", 0);
    customer1.setLocation(new int[] { 80, 0 });
    toBeRetrieved.add(customer1);
    final Customer customer2 = new Customer("vvv", "", 0);
    customer2.setLocation(new int[] { 10, 0 });
    toBeRetrieved.add(customer2);
    repository.saveAll(toBeRetrieved);
    final Customer customer3 = new Customer("--d", "", 0);
    customer3.setLocation(new int[] { 19, 0 });
    repository.save(customer3);
    final Customer customer4 = new Customer("--r", "", 0);
    customer4.setLocation(new int[] { 6, 0 });
    repository.save(customer4);
    final Customer customer5 = new Customer("-!r", "", 0);
    customer5.setLocation(new int[] { 0, 0 });
    repository.save(customer5);
    final int distance = (int) convertAngleToDistance(11);
    final Bound<Integer> lowerBound = Bound.inclusive((int) convertAngleToDistance(5));
    final Bound<Integer> upperBound = Bound.inclusive((int) convertAngleToDistance(15));
    final Collection<Customer> retrieved = repository.findByLocationWithinAndLocationWithinOrName(new Point(0, 20), distance, new Ring<>(new Point(0, 0), Range.of(lowerBound, upperBound)), "+++");
    replacedertTrue(equals(toBeRetrieved, retrieved, cmp, eq, false));
}

See More Examples