Esempio n. 1
0
  @Test
  public void queryWithOrderingAndSearchFilter() throws IOException, NoSuchMethodException {
    ServiceLocator locator = container;
    ArticleRepository repository = locator.resolve(ArticleRepository.class);

    Random random = new Random();
    int projectID = random.nextInt();
    Article article1 =
        new Article()
            .setProjectID(projectID)
            .setSku(UUID.randomUUID().toString().substring(0, 10))
            .setTitle("Article A");
    Article article2 =
        new Article()
            .setProjectID(projectID)
            .setSku(UUID.randomUUID().toString().substring(0, 10))
            .setTitle("Article Z");
    repository.insert(Arrays.asList(article1, article2));

    ArticleGridRepository gridRepository = locator.resolve(ArticleGridRepository.class);
    Specification<ArticleGrid> spec =
        new ArticleGrid.filterSearch().setProjectID(projectID).setFilter("article");

    JinqMetaModel jmm = locator.resolve(JinqMetaModel.class);
    Method method = ArticleGrid.class.getMethod("getTitle");
    Query.Compare<ArticleGrid, ?> order = jmm.findGetter(method);

    List<ArticleGrid> list = gridRepository.query(spec).sortedDescendingBy(order).list();

    Assert.assertEquals(2, list.size());
    Assert.assertEquals(article2.getID(), list.get(0).getID());
    Assert.assertEquals(article1.getID(), list.get(1).getID());
  }
Esempio n. 2
0
 // @Test
 public void numberFunctions() throws IOException {
   ServiceLocator locator = container;
   DataContext db = locator.resolve(DataContext.class);
   LocalDate ld = LocalDate.now();
   Clicked cl = new Clicked().setDate(ld);
   db.submit(cl);
   Query<Clicked> query = db.query(Clicked.class);
   String uri = cl.getURI();
   // TODO: produces incorrect queries
   boolean found1 =
       query.anyMatch(
           it ->
               Long.valueOf(3).equals(it.getBigint()) && it.getEn() == En.A
                   || it.getURI().toUpperCase().equals(uri));
   boolean found2 =
       query.anyMatch(
           it ->
               3L >= it.getBigint() && it.getDate() == LocalDate.now()
                   || Integer.valueOf(it.getURI()).equals(Integer.valueOf(uri)));
   boolean found3 =
       query.anyMatch(
           it ->
               Long.valueOf(3).equals(it.getBigint()) && it.getEn() == En.B
                   || it.getURI().toUpperCase().equals(uri));
   En b = En.B;
   boolean found4 = query.anyMatch(it -> it.getEn() == b || it.getURI().toUpperCase().equals(uri));
   Assert.assertTrue(found1);
   Assert.assertTrue(found2);
   Assert.assertTrue(found3);
   Assert.assertTrue(found4);
 }
Esempio n. 3
0
  @Test
  public void stringOrderingViaLambda() throws IOException {
    ServiceLocator locator = container;
    InfoRepository infoRepository = locator.resolve(InfoRepository.class);

    String id = UUID.randomUUID().toString();

    List<Info> infos = new ArrayList<Info>();
    for (char letter = 'A'; letter < 'Z'; letter++) {
      infos.add(
          new Info()
              .setCode(String.format("code %s %c", id, letter))
              .setName(String.format("name %s %c", id, letter)));
    }

    infoRepository.insert(infos);

    Specification<Info> filter = it -> it.getCode().startsWith("code " + id);

    List<Info> found =
        infoRepository
            .search(filter)
            .stream()
            .sorted((a, b) -> a.getName().compareTo(b.getName()))
            .collect(Collectors.toList());

    List<Info> infosAscByName =
        infoRepository.query().filter(filter).sortedBy(Info::getName).list();
    Assert.assertEquals(found, infosAscByName);

    List<Info> infosDescByName =
        infoRepository.query().filter(filter).sortedDescendingBy(Info::getName).list();
    Collections.reverse(infosDescByName);
    Assert.assertEquals(found, infosDescByName);
  }
Esempio n. 4
0
  @Test
  public void testTimestampQueryingAndOrder() throws IOException {
    ServiceLocator locator = container;
    SearchByTimestampAndOrderByTimestampRepository analysisGridRepository =
        locator.resolve(SearchByTimestampAndOrderByTimestampRepository.class);

    String marker = UUID.randomUUID().toString();
    OffsetDateTime dt1 = OffsetDateTime.now();
    OffsetDateTime dt2 = dt1.plusDays(1);
    OffsetDateTime dt3 = dt1.plusDays(2);
    OffsetDateTime dt4 = dt1.plusDays(3);

    SearchByTimestampAndOrderByTimestamp[] arr =
        new SearchByTimestampAndOrderByTimestamp[] {
          new SearchByTimestampAndOrderByTimestamp().setOndate(dt1).setMarker(marker),
          new SearchByTimestampAndOrderByTimestamp().setOndate(dt2).setMarker(marker),
          new SearchByTimestampAndOrderByTimestamp().setOndate(dt3).setMarker(marker),
          new SearchByTimestampAndOrderByTimestamp().setOndate(dt4).setMarker(marker)
        };
    analysisGridRepository.insert(arr);

    List<SearchByTimestampAndOrderByTimestamp> queryResults =
        analysisGridRepository
            .query(it -> it.getMarker().equals(marker) && it.getOndate().isAfter(dt2))
            .sortedDescendingBy(SearchByTimestampAndOrderByTimestamp::getOndate)
            .list();
    Assert.assertEquals(queryResults.size(), arr.length - 2);
    Assert.assertTrue(queryResults.get(0).getOndate().isEqual(dt4));
  }
Esempio n. 5
0
 @Test
 public void staticMemberAccess() throws IOException {
   ServiceLocator locator = container;
   DataContext db = locator.resolve(DataContext.class);
   Query<Document> query = db.query(Document.class);
   boolean found = query.anyMatch(it -> it.equals(Document.MEANING_OF_LIFE()));
   Assert.assertFalse(found);
 }
Esempio n. 6
0
 @Test
 public void floatType() throws IOException {
   ServiceLocator locator = container;
   DataContext db = locator.resolve(DataContext.class);
   boolean notFound =
       db.query(Composite.class).anyMatch(it -> (float) it.getSimple().getNumber() == 4.2f);
   Assert.assertFalse(notFound);
 }
Esempio n. 7
0
 @Test
 public void queryWithRegisteredSpecification() throws IOException {
   ServiceLocator locator = container;
   NextRepository repository = locator.resolve(NextRepository.class);
   String uri = repository.insert(new Next());
   int id = Integer.parseInt(uri);
   long size = repository.query(new Next.BetweenIds(id, id)).count();
   Assert.assertEquals(1, size);
 }
Esempio n. 8
0
  // query too complex for JINQ, fallback to DSL Platform expression
  @Test
  public void queryWithComplexSpecification() throws IOException, NoSuchMethodException {
    ServiceLocator locator = container;
    AnalysisGridRepository analysisGridRepository = locator.resolve(AnalysisGridRepository.class);

    AnalysisGrid.filterSearch filter = new AnalysisGrid.filterSearch();
    Optional<AnalysisGrid> results =
        analysisGridRepository.query(it -> true).filter(filter::test).findFirst();
    Assert.assertNotNull(results);
  }
Esempio n. 9
0
 @Test
 public void simpleQuery() throws IOException {
   ServiceLocator locator = container;
   NextRepository repository = locator.resolve(NextRepository.class);
   repository.insert(new Next());
   List<Next> search = repository.search();
   Query<Next> stream = repository.query();
   List<Next> list = stream.list();
   Assert.assertEquals(search.size(), list.size());
 }
Esempio n. 10
0
 @Test
 public void willRecognizeSpecificationOnSql() throws IOException {
   ServiceLocator locator = container;
   DataContext db = locator.resolve(DataContext.class);
   LocalDate ld = LocalDate.now();
   Clicked cl = new Clicked().setDate(ld);
   db.submit(cl);
   long count = db.query(ClickedList.class).filter(new ClickedList.FindAt(ld)).count();
   Assert.assertTrue(count > 0);
 }
Esempio n. 11
0
 @Test
 public void willUseRewrittenSpecificationInSearch() throws IOException {
   ServiceLocator locator = container;
   DataContext db = locator.resolve(DataContext.class);
   LocalDate ld = LocalDate.now().plusDays(15);
   Clicked cl = new Clicked().setDate(ld);
   db.submit(cl);
   List<ClickedList> found = db.search(ClickedList.class, new ClickedList.FindAt(ld));
   Assert.assertTrue(found.size() > 0);
 }
Esempio n. 12
0
 @Test
 public void searchWithFilter() throws IOException {
   ServiceLocator locator = container;
   NextRepository repository = locator.resolve(NextRepository.class);
   String uri = repository.insert(new Next());
   int id = Integer.parseInt(uri);
   List<Next> found = repository.search(next -> next.getID() == id);
   Assert.assertEquals(1, found.size());
   Assert.assertEquals(id, found.get(0).getID());
 }
Esempio n. 13
0
 @Test
 public void queryWithFilter() throws IOException {
   ServiceLocator locator = container;
   NextRepository repository = locator.resolve(NextRepository.class);
   String uri = repository.insert(new Next());
   int id = Integer.parseInt(uri);
   Optional<Next> found = repository.query().filter(next -> next.getID() == id).findAny();
   Assert.assertTrue(found.isPresent());
   Assert.assertEquals(id, found.get().getID());
 }
Esempio n. 14
0
 @Test
 public void canUseQueryDirectly() throws IOException, ReflectiveOperationException {
   ServiceLocator locator = container;
   DataContext db = locator.resolve(DataContext.class);
   LocalDate ld = LocalDate.now().plusDays(15);
   Clicked cl = new Clicked().setDate(ld);
   db.submit(cl);
   List<ClickedList> found =
       locator.resolve(Query.class, ClickedList.class).filter(new ClickedList.FindAt(ld)).list();
   Assert.assertTrue(found.size() > 0);
 }
Esempio n. 15
0
 @Test
 public void queryWithNotFilter() throws IOException {
   ServiceLocator locator = container;
   NextRepository repository = locator.resolve(NextRepository.class);
   String uri = repository.insert(new Next());
   int id = Integer.parseInt(uri);
   Specification<Next> filter = next -> next.getID() == id + 1;
   Optional<Next> found = repository.query().filter(filter).findAny();
   Assert.assertFalse(found.isPresent());
   // found = repository.query().filter(filter.negate()).findAny();
   // Assert.assertTrue(found.isPresent());
 }
Esempio n. 16
0
 @Test
 public void toStringAndValueOf() throws IOException {
   ServiceLocator locator = container;
   NextRepository repository = locator.resolve(NextRepository.class);
   String uri = repository.insert(new Next());
   int id = Integer.parseInt(uri);
   List<Next> found =
       repository.search(
           it -> String.valueOf(it.getID()).equals(uri) && id == Integer.valueOf(it.getURI()));
   Assert.assertEquals(1, found.size());
   Assert.assertEquals(id, found.get(0).getID());
 }
Esempio n. 17
0
 @Test
 public void collectionContainsQuery() throws IOException {
   ServiceLocator locator = container;
   NextRepository repository = locator.resolve(NextRepository.class);
   String uri = repository.insert(new Next());
   int id = Integer.parseInt(uri);
   List<Integer> numbers = Arrays.asList(-1, 0, id);
   List<Next> found =
       repository.query().filter(it -> numbers.contains(it.getID())).limit(2).list();
   Assert.assertEquals(1, found.size());
   Assert.assertEquals(id, found.get(0).getID());
 }
Esempio n. 18
0
 @Test
 public void queryWithLimit() throws IOException {
   ServiceLocator locator = container;
   NextRepository repository = locator.resolve(NextRepository.class);
   String[] uris = repository.insert(Arrays.asList(new Next(), new Next()));
   Assert.assertEquals(2, uris.length);
   int id1 = Integer.parseInt(uris[0]);
   int id2 = Integer.parseInt(uris[1]);
   List<Next> found =
       repository.query(next -> next.getID() == id1 || next.getID() == id2).limit(1).list();
   Assert.assertEquals(1, found.size());
 }
Esempio n. 19
0
 @Test
 public void queryWithFilterAndCount() throws IOException {
   ServiceLocator locator = container;
   NextRepository repository = locator.resolve(NextRepository.class);
   String uri = repository.insert(new Next());
   int id = Integer.parseInt(uri);
   long found = repository.query().filter(next -> next.getID() == id).count();
   Assert.assertEquals(1, found);
   found = repository.query().filter(next -> false).count();
   Assert.assertEquals(0, found);
   found = repository.query().filter(next -> true).count();
   Assert.assertNotEquals(0, found);
 }
Esempio n. 20
0
 @Test
 public void willUseRewrittenSpecificationInBulk() throws Exception {
   ServiceLocator locator = container;
   DataContext db = locator.resolve(DataContext.class);
   RepositoryBulkReader reader = locator.resolve(RepositoryBulkReader.class);
   LocalDate ld = LocalDate.now().plusDays(44);
   Clicked cl = new Clicked().setDate(ld).setNumber(BigDecimal.valueOf(111));
   db.submit(cl);
   Callable<List<ClickedSeq>> found =
       reader.search(ClickedSeq.class, new ClickedSeq.OnDateOrNumber(ld, 111));
   reader.execute();
   Assert.assertTrue(found.call().size() > 0);
 }
Esempio n. 21
0
 // @Test
 public void nestedSubqueryWithStream() throws IOException {
   ServiceLocator locator = container;
   DataContext db = locator.resolve(DataContext.class);
   // TODO: does not work yet
   boolean notFound =
       db.query(Composite.class)
           .anyMatch(
               it ->
                   it.getEntities()
                       .stream()
                       .anyMatch(e -> e.getDetail1().stream().anyMatch(d -> d.getFf() == 4.2f)));
   Assert.assertFalse(notFound);
 }
Esempio n. 22
0
 @Test
 public void uuidFunctions() throws IOException {
   ServiceLocator locator = container;
   CompositeRepository repository = locator.resolve(CompositeRepository.class);
   UUID id = UUID.randomUUID();
   String uri = repository.insert(new Composite().setId(id));
   Composite found =
       repository.query().filter(it -> it.getId().toString().equals(uri)).findAny().get();
   Assert.assertEquals(id, found.getId());
   found =
       repository.query().filter(it -> UUID.fromString(it.getURI()).equals(id)).findAny().get();
   Assert.assertEquals(id, found.getId());
 }
Esempio n. 23
0
 @Test
 public void queryWithFilterAndFindAny() throws IOException {
   ServiceLocator locator = container;
   NextRepository repository = locator.resolve(NextRepository.class);
   String uri = repository.insert(new Next());
   int id = Integer.parseInt(uri);
   repository.insert(new Next());
   boolean found = repository.query().anyMatch(next -> next.getID() == id);
   Assert.assertTrue(found);
   found = repository.query().allMatch(next -> next.getID() == id);
   Assert.assertFalse(found);
   found = repository.query().noneMatch(next -> next.getID() == id);
   Assert.assertFalse(found);
   found = repository.query().noneMatch(next -> next.getID() == id + 2);
   Assert.assertTrue(found);
 }
Esempio n. 24
0
 @Test
 public void offsetDateTimeFunctions() throws IOException {
   ServiceLocator locator = container;
   DataContext db = locator.resolve(DataContext.class);
   Clicked cl = new Clicked();
   db.submit(cl);
   Query<Clicked> query = db.query(Clicked.class);
   OffsetDateTime dt = cl.getQueuedAt();
   boolean found =
       query.anyMatch(
           it -> it.getURI().equals(cl.getURI()) && it.getProcessedAt().compareTo(dt) == 0);
   boolean notFound =
       query.anyMatch(
           it -> it.getURI().equals(cl.getURI()) && it.getProcessedAt().compareTo(dt) != 0);
   Assert.assertTrue(found);
   Assert.assertFalse(notFound);
 }
Esempio n. 25
0
 @Test
 public void substringMethods() throws IOException {
   ServiceLocator locator = container;
   CompositeRepository repository = locator.resolve(CompositeRepository.class);
   UUID id = UUID.randomUUID();
   repository.insert(
       new Composite().setId(id).setSimple(new Simple().setText("xxx" + id + "yyy")));
   List<Composite> found =
       repository
           .query()
           .filter(it -> it.getId().equals(id))
           .filter(it -> it.getSimple().getText().substring(3).equals(id.toString() + "yyy"))
           .filter(it -> it.getSimple().getText().substring(0, 3).equals("xxx"))
           .list();
   Assert.assertEquals(1, found.size());
   Assert.assertEquals(id, found.get(0).getId());
 }
Esempio n. 26
0
 @Test
 public void sendDomainObjectAsArgument() throws IOException {
   ServiceLocator locator = container;
   CompositeRepository repository = locator.resolve(CompositeRepository.class);
   UUID id = UUID.randomUUID();
   Random rnd = new Random();
   int next = rnd.nextInt(100000);
   repository.insert(
       new Composite().setId(id).setSimple(new Simple().setEn(En.A).setNumber(next)));
   Simple simple = new Simple().setEn(En.A).setNumber(next);
   Composite found =
       repository
           .query()
           .filter(it -> it.getSimple().getNumber() == simple.getNumber())
           .sortedBy(it -> it.getId())
           .findFirst()
           .get();
   Assert.assertEquals(id, found.getId());
 }
Esempio n. 27
0
 @Test
 public void localDateFunctions() throws IOException {
   ServiceLocator locator = container;
   DataContext db = locator.resolve(DataContext.class);
   LocalDate ld = LocalDate.now();
   Clicked cl = new Clicked().setDate(ld);
   db.submit(cl);
   Query<Clicked> query = db.query(Clicked.class);
   String uri = cl.getURI();
   boolean found1 =
       query.anyMatch(it -> it.getURI().equals(uri) && ld.compareTo(it.getDate()) == 0);
   boolean found2 =
       query.anyMatch(
           it -> it.getURI().equals(uri) && ld.equals(it.getDate()) && ld.isEqual(it.getDate()));
   boolean notFound =
       query.anyMatch(it -> it.getURI().equals(uri) && ld.compareTo(it.getDate()) != 0);
   Assert.assertTrue(found1);
   Assert.assertTrue(found2);
   Assert.assertFalse(notFound);
 }
Esempio n. 28
0
 @Test
 public void modOperator() throws IOException {
   ServiceLocator locator = container;
   NextRepository repository = locator.resolve(NextRepository.class);
   long total = repository.query().count();
   long totalEven = repository.query(it -> it.getID() % 2 == 0).count();
   long totalOdd = repository.query(it -> it.getID() % 2 != 0).count();
   Assert.assertEquals(total, totalEven, totalOdd);
   String uri = repository.insert(new Next());
   int id = Integer.parseInt(uri);
   long newTotal = repository.query().count();
   long newTotalEven = repository.query(it -> it.getID() % 2 == 0).count();
   long newTotalOdd = repository.query(it -> it.getID() % 2 != 0).count();
   Assert.assertEquals(newTotal, newTotalEven, newTotalOdd);
   Assert.assertEquals(total + 1, newTotal);
   if (id % 2 == 0) {
     Assert.assertEquals(totalEven + 1, newTotalEven);
   } else {
     Assert.assertEquals(totalOdd + 1, newTotalOdd);
   }
 }
Esempio n. 29
0
  @Test
  public void testSQLMapping() throws IOException {
    ServiceLocator locator = container;
    CoverageUpdateRepository covUpdateRepo = locator.resolve(CoverageUpdateRepository.class);
    CoverageVersions1Repository covVersionsRepo =
        locator.resolve(CoverageVersions1Repository.class);

    String suppID = UUID.randomUUID().toString();
    covUpdateRepo.submit(new CoverageUpdate().setSupplierID(suppID));
    try {
      Thread.sleep(100);
    } catch (InterruptedException ignore) {
    }
    covUpdateRepo.submit(new CoverageUpdate().setSupplierID(suppID));

    List<CoverageVersions1> items =
        covVersionsRepo.query(it -> it.getSupplierID().equals(suppID)).list();
    Assert.assertEquals(items.size(), 2);
    Assert.assertNotEquals(
        items.get(0).getProcessedAt().isEqual(items.get(1).getProcessedAt()), true);
  }
Esempio n. 30
0
  /* package */ @SuppressWarnings({"unchecked"})
  void register() {
    ServiceLocator locator = getServiceLocator();

    ActiveDescriptor<?> myselfReified = locator.reifyDescriptor(this);

    DynamicConfigurationService dcs = locator.getService(DynamicConfigurationService.class);
    DynamicConfiguration dc = dcs.createDynamicConfiguration();

    //        habitat.add(this);
    HK2Loader loader = this.model.classLoaderHolder;

    Set<Type> ctrs = new HashSet<Type>();
    ctrs.add(myselfReified.getImplementationClass());

    if (ConfigBean.class.isAssignableFrom(this.getClass())) {
      ctrs.add(ConfigBean.class);
    }

    DomDescriptor<Dom> domDesc =
        new DomDescriptor<Dom>(
            this, ctrs, Singleton.class, getImplementation(), new HashSet<Annotation>());
    domDesc.setLoader(loader);
    domDescriptor = dc.addActiveDescriptor(domDesc, false);

    String key = getKey();
    for (String contract : model.contracts) {
      ActiveDescriptor<Dom> alias = new AliasDescriptor<Dom>(locator, domDescriptor, contract, key);
      dc.addActiveDescriptor(alias, false);
    }
    if (key != null) {
      ActiveDescriptor<Dom> alias =
          new AliasDescriptor<Dom>(locator, domDescriptor, model.targetTypeName, key);
      dc.addActiveDescriptor(alias, false);
    }

    dc.commit();

    serviceHandle = getHabitat().getServiceHandle(domDescriptor);
  }