Пример #1
0
  private GetObjectStub(boolean withTypeMapping) {
    this.withTypeMapping = withTypeMapping;

    storIOSQLite = mock(StorIOSQLite.class);
    internal = mock(StorIOSQLite.Internal.class);

    when(storIOSQLite.internal()).thenReturn(internal);

    query = Query.builder().table("test_table").build();

    rawQuery =
        RawQuery.builder().query("select * from who_cares").observesTables("test_table").build();

    //noinspection unchecked
    getResolver = mock(GetResolver.class);
    cursor = mock(Cursor.class);

    item = new TestItem();

    when(cursor.getCount()).thenReturn(1);

    when(cursor.moveToNext())
        .thenAnswer(
            new Answer<Boolean>() {
              int invocationsCount = 0;

              @Override
              public Boolean answer(InvocationOnMock invocation) throws Throwable {
                return invocationsCount++ < 1;
              }
            });

    when(storIOSQLite.get()).thenReturn(new PreparedGet.Builder(storIOSQLite));

    when(storIOSQLite.observeChangesInTables(eq(singleton(query.table()))))
        .thenReturn(Observable.<Changes>empty());

    assertThat(rawQuery.observesTables()).isNotNull();

    when(storIOSQLite.observeChangesInTables(rawQuery.observesTables()))
        .thenReturn(Observable.<Changes>empty());

    when(getResolver.performGet(storIOSQLite, query)).thenReturn(cursor);

    when(getResolver.performGet(storIOSQLite, rawQuery)).thenReturn(cursor);

    when(getResolver.mapFromCursor(cursor)).thenReturn(item);

    //noinspection unchecked
    typeMapping = mock(SQLiteTypeMapping.class);

    if (withTypeMapping) {
      when(internal.typeMapping(TestItem.class)).thenReturn(typeMapping);
      when(typeMapping.getResolver()).thenReturn(getResolver);
    }
  }
Пример #2
0
 @Test
 public void testFirstOrDefault() throws Exception {
   Observable.empty()
       .firstOrDefault(99)
       .subscribe(
           next -> print("next: %s", next), Throwable::printStackTrace, () -> print("complete!"));
 }
Пример #3
0
  @Test
  public void testDistinctOfNoneWithKeySelector() {
    Observable<String> src = Observable.empty();
    Observable.create(distinct(src, TO_UPPER_WITH_EXCEPTION)).subscribe(w);

    verify(w, never()).onNext(anyString());
    verify(w, never()).onError(any(Throwable.class));
    verify(w, times(1)).onCompleted();
  }
Пример #4
0
  @Test
  public void testDistinctOfNone() {
    Observable<String> src = Observable.empty();
    Observable.create(distinct(src)).subscribe(w);

    verify(w, never()).onNext(anyString());
    verify(w, never()).onError(any(Throwable.class));
    verify(w, times(1)).onCompleted();
  }
Пример #5
0
  private Observable<V> fromMemory(User user, K key) {
    UserMemoryCache<K, V> userMemoryCache = userMemoryCaches.get(user);

    if (!userMemoryCache.containsKey(key)) {
      return Observable.empty();
    } else {
      Pair<Long, V> cachedValue = userMemoryCache.get(key);
      long cachedSince = DateUtils.getCurrentTimestamp() - cachedValue.first;

      if (cachedSince < staleThreshold) {
        return Observable.just(userMemoryCache.get(key).second);
      } else {
        // Value has expired
        userMemoryCache.remove(key);
        return Observable.empty();
      }
    }
  }
Пример #6
0
  public static void main(String... args) {
    // initialize
    DiscoveryAndLoadBalancer.getFactory();
    // hystrix stream => http://localhost:9999
    startHystrixMetricsStream();

    System.out.println("Server => Starting at http://localhost:8080/");
    System.out.println("   Sample URLs: ");
    System.out.println("      - http://localhost:8080/device/home?userId=123");
    System.out.println("----------------------------------------------------------------");

    // start web services => http://localhost:8080
    RxNetty.createHttpServer(
            8080,
            (request, response) -> {
              if (request.getPath().contains("favicon.ico")) {
                return Observable.empty();
              }
              // System.out.println("Server => Request: " + request.getPath());
              return Observable.defer(
                      () -> {
                        HystrixRequestContext.initializeContext();
                        try {
                          return handleRoutes(request, response);
                        } catch (Throwable e) {
                          System.err.println("Server => Error [" + request.getPath() + "] => " + e);
                          response.setStatus(HttpResponseStatus.BAD_REQUEST);
                          return response.writeStringAndFlush(
                              "Error 500: Bad Request\n" + e.getMessage() + "\n");
                        }
                      })
                  .onErrorResumeNext(
                      error -> {
                        System.err.println("Server => Error: " + error.getMessage());
                        error.printStackTrace();
                        return writeError(request, response, "Failed: " + error.getMessage());
                      })
                  .doOnTerminate(
                      () -> {
                        if (HystrixRequestContext.isCurrentThreadInitialized()) {
                          System.out.println(
                              "Server => Request ["
                                  + request.getPath()
                                  + "] => "
                                  + HystrixRequestLog.getCurrentRequest()
                                      .getExecutedCommandsAsString());
                          HystrixRequestContext.getContextForCurrentThread().shutdown();
                        } else {
                          System.err.println(
                              "HystrixRequestContext not initialized for thread: "
                                  + Thread.currentThread());
                        }
                        response.close();
                      });
            })
        .startAndWait();
  }
Пример #7
0
  @Test
  public void loadEmptyRepo() {
    when(repo.getModificationId()).thenReturn("modif id");
    when(repo.getEventsSubscribedOnProperScheduler()).thenReturn(Observable.empty());
    sut.loadEvents(false, callback);

    List<IEvent> emptyList = new ArrayList<>();
    verify(callback).onEventsLoadingStarted("modif id");
    verify(callback).onEventsLoadingFinished(emptyList, "modif id");
  }
  @Test
  public void testSingleWithEmpty() {
    Observable<Integer> observable = Observable.<Integer>empty().single();

    @SuppressWarnings("unchecked")
    Observer<Integer> observer = (Observer<Integer>) mock(Observer.class);
    observable.subscribe(observer);

    InOrder inOrder = inOrder(observer);
    inOrder.verify(observer, times(1)).onError(isA(NoSuchElementException.class));
    inOrder.verifyNoMoreInteractions();
  }
  @Override
  public Observable<Message> getMessages(final ExtractionParameters parameters) {
    // validate parameters
    try {
      validateParameters(parameters);
    } catch (SocialException e) {
      logger.error(e);
      e.printStackTrace();
      return Observable.empty();
    }

    return getRunnerInstance().getMessages(parameters);
  }
Пример #10
0
  @Test
  public void testSingleOrDefaultWithEmpty() {
    Observable<Integer> observable = Observable.<Integer>empty().singleOrDefault(1);

    @SuppressWarnings("unchecked")
    Observer<Integer> observer = (Observer<Integer>) mock(Observer.class);
    observable.subscribe(observer);

    InOrder inOrder = inOrder(observer);
    inOrder.verify(observer, times(1)).onNext(1);
    inOrder.verify(observer, times(1)).onCompleted();
    inOrder.verifyNoMoreInteractions();
  }
  /**
   * @param webPageEntity
   * @return
   * @throws Exception
   */
  @Override
  public Observable<ProductEntity> parse(WebPageEntity webPageEntity) {
    HashSet<ProductEntity> result = new HashSet<>();
    try {
      ProductEntity product;
      String productName = null;
      String url = null;
      String regularPrice = null;
      String specialPrice = null;
      String productImage = null;
      String description = null;
      Map<String, String> attr = new HashMap<>();
      String[] category = null;

      url = webPageEntity.getUrl();

      Document document = Jsoup.parse(webPageEntity.getContent(), webPageEntity.getUrl());
      productName = document.select(".naitem").text();
      LOGGER.info("Parsing {}, page={}", productName, webPageEntity.getUrl());

      if (!document.select(".outofstock").isEmpty()) {
        return Observable.empty();
      }

      productImage = document.select(".itemImgDiv img.itemDetailImg").attr("abs:src");
      String priceText = document.select(".itemDetailPrice").text().replace("\\xEF\\xBF\\xBD", " ");
      Matcher matcher = pricePattern.matcher(priceText);
      if (matcher.find()) {
        regularPrice = matcher.group().replace(",", "");
      }
      description = document.select(".itemDescription").text();
      category = getNormalizedCategories(webPageEntity);

      product =
          new ProductEntity(
              productName,
              url,
              regularPrice,
              specialPrice,
              productImage,
              description,
              attr,
              category);
      result.add(product);
    } catch (Exception e) {
      LOGGER.error("Failed to parse: {}", webPageEntity, e);
    }
    return Observable.from(result).doOnNext(e -> parseResultCounter.inc());
  }
 public Observable<SoftwareUpdateData> makeUpdate() {
   Observable<SoftwareUpdateData> observable =
       updateHandler
           .triggerUpdate()
           .flatMap(
               new Func1<Boolean, Observable<SoftwareUpdateData>>() {
                 @Override
                 public Observable<SoftwareUpdateData> call(Boolean ignored) {
                   return refresh();
                 }
               })
           .subscribeOn(Schedulers.io())
           .observeOn(AndroidSchedulers.mainThread())
           .share();
   observable.onErrorResumeNext(Observable.<SoftwareUpdateData>empty()).subscribe();
   return observable;
 }
Пример #13
0
 @Test
 public void testSingleDoesNotRequestMoreThanItNeedsToEmitErrorFromEmpty() {
   final AtomicLong request = new AtomicLong();
   try {
     Observable.empty()
         .doOnRequest(
             new Action1<Long>() {
               @Override
               public void call(Long n) {
                 request.addAndGet(n);
               }
             })
         .toBlocking()
         .single();
   } catch (NoSuchElementException e) {
     assertEquals(2, request.get());
   }
 }
Пример #14
0
  private void displayTags(List<Tag> tags_) {
    List<Tag> tags = inMemoryCacheService.enhanceTags(feedItem.getId(), tags_);
    this.tags = ImmutableList.copyOf(tags);

    // show tags now
    infoLineView.setTags(toMap(tags, tag -> Vote.NEUTRAL));

    // and update tags with votes later.
    voteService
        .getTagVotes(tags)
        .filter(votes -> !votes.isEmpty())
        .onErrorResumeNext(Observable.<Map<Long, Vote>>empty())
        .compose(bindToLifecycle())
        .subscribe(
            votes ->
                infoLineView.setTags(
                    toMap(tags, tag -> firstNonNull(votes.get(tag.getId()), Vote.NEUTRAL))));

    hideProgressIfLoop(tags);
  }
  @Test
  public void testNextWithEmpty() {
    Observable<String> obs = Observable.<String>empty().observeOn(Schedulers.newThread());
    Iterator<String> it = next(obs).iterator();

    assertFalse(it.hasNext());
    try {
      it.next();
      fail("At the end of an iterator should throw a NoSuchElementException");
    } catch (NoSuchElementException e) {
    }

    // If the observable is completed, hasNext always returns false and next always throw a
    // NoSuchElementException.
    assertFalse(it.hasNext());
    try {
      it.next();
      fail("At the end of an iterator should throw a NoSuchElementException");
    } catch (NoSuchElementException e) {
    }
  }
Пример #16
0
  @Override
  public Observable<? extends Thing<?>> findThingForId(String id) {
    if (!id.startsWith("projectId:")) {
      return Observable.empty();
    }

    try {
      String id_string = id.split(":")[1];
      Integer id_int = Integer.parseInt(id_string);

      String projectName = um.getGroup(id_int);
      Group g = um.getAllGroups().get(projectName);

      Thing<Group> groupThing = wrapGroup(g);

      return Observable.just(groupThing);

    } catch (Exception e) {
      throw new ThingRuntimeException(
          "Can't parse group id " + id + ": " + e.getLocalizedMessage());
    }
  }
Пример #17
0
 @Override
 public final Observable<SqlSchema> definition() {
   return Observable.empty();
 }
  @Override
  public Observable<ProductEntity> parse(WebPageEntity webPageEntity) {
    HashSet<ProductEntity> result = new HashSet<>();

    try {
      ProductEntity product;
      String productName = null;
      String url = null;
      String regularPrice = null;
      String specialPrice = null;
      String productImage = null;
      String description = null;
      Map<String, String> attr = new HashMap<>();
      String[] category = null;

      url = webPageEntity.getUrl();

      Document document = Jsoup.parse(webPageEntity.getContent(), webPageEntity.getUrl());
      if (!document.select(".saleImage").isEmpty()) {
        return Observable.empty();
      }

      productName = document.select("div.innercontentDiv > div > div > h2").text();
      if (productName.isEmpty()) {
        return Observable.empty();
      }

      LOGGER.info("Parsing {}, page={}", productName, webPageEntity.getUrl());

      String manufacturer =
          document.select(".product-details__title .product__manufacturer").text();
      if (!manufacturer.isEmpty()) {
        attr.put("manufacturer", manufacturer);
      }
      productImage = document.select("div.imgLiquidNoFill a").attr("abs:src");
      if (productImage.isEmpty()) {
        productImage = document.select(".es-carousel img").attr("abs:src");
      }

      regularPrice =
          parsePrice(
              webPageEntity,
              document.select("#desPrice > li:nth-child(1) > span.pricetag.show").text());
      specialPrice = document.select("#desPrice > li:nth-child(2) > span.pricetag.show").text();
      if (!specialPrice.isEmpty()) {
        specialPrice = parsePrice(webPageEntity, specialPrice);
      }
      description = document.select("#TabbedPanels1 > div > div:nth-child(1)").text();

      Iterator<Element> labels =
          document.select("table.productTbl > tbody > tr > td:nth-child(1)").iterator();
      Iterator<Element> values =
          document.select("table.productTbl > tbody > tr > td:nth-child(2)").iterator();

      while (labels.hasNext()) {
        String specName =
            CaseFormat.LOWER_UNDERSCORE.to(
                CaseFormat.LOWER_CAMEL,
                labels.next().text().replace(' ', '_').replace(":", "").trim());
        String specValue = values.next().text();
        if (specName.contains("department")) {
          category = getNormalizedCategories(webPageEntity, specValue);
        } else {
          attr.put(specName, specValue);
        }
      }
      if (category == null) {
        LOGGER.warn("Category not found");
      }

      product =
          new ProductEntity(
              productName,
              url,
              regularPrice,
              specialPrice,
              productImage,
              description,
              attr,
              category);
      result.add(product);
    } catch (Exception e) {
      LOGGER.error("Failed to parse: {}", webPageEntity, e);
    }
    return Observable.from(result).doOnNext(e -> parseResultCounter.inc());
  }
 @NonNull
 @Override
 public Observable<Changes> observeChangesOfUris(@NonNull Set<Uri> uris) {
   return Observable.empty();
 }
Пример #20
0
  private Observable<Navajo> processNavajoEvent(
      NavajoStreamEvent n, Subscriber<? super Navajo> subscriber) {
    switch (n.type()) {
      case NAVAJO_STARTED:
        createHeader((NavajoHead) n.body());
        return Observable.<Navajo>empty();

      case MESSAGE_STARTED:
        Message prMessage = null;
        if (!messageStack.isEmpty()) {
          prMessage = messageStack.peek();
        }
        String mode = (String) n.attribute("mode");

        Message msg =
            NavajoFactory.getInstance().createMessage(assemble, n.path(), Message.MSG_TYPE_SIMPLE);
        msg.setMode(mode);
        if (prMessage == null) {
          assemble.addMessage(msg);
        } else {
          prMessage.addMessage(msg);
        }
        messageStack.push(msg);
        tagStack.push(n.path());
        return Observable.<Navajo>empty();
      case MESSAGE:
        Message msgParent = messageStack.pop();
        tagStack.pop();
        Msg mm = (Msg) n.body();
        List<Prop> msgProps = mm.properties();
        for (Prop e : msgProps) {
          msgParent.addProperty(createTmlProperty(e));
        }
        for (Entry<String, Binary> e : pushBinaries.entrySet()) {
          msgParent.addProperty(createBinaryProperty(e.getKey(), e.getValue()));
        }
        pushBinaries.clear();
        return Observable.<Navajo>empty();
      case ARRAY_STARTED:
        tagStack.push(n.path());
        String path = currentPath();
        AtomicInteger cnt = arrayCounts.get(path);
        if (cnt == null) {
          cnt = new AtomicInteger();
          arrayCounts.put(path, cnt);
        }
        //			cnt.incrementAndGet();
        Message parentMessage = null;
        if (!messageStack.isEmpty()) {
          parentMessage = messageStack.peek();
        }

        Message arr =
            NavajoFactory.getInstance().createMessage(assemble, n.path(), Message.MSG_TYPE_ARRAY);
        if (parentMessage == null) {
          assemble.addMessage(arr);
        } else {
          parentMessage.addMessage(arr);
        }
        messageStack.push(arr);
        return Observable.<Navajo>empty();
      case ARRAY_DONE:
        String apath = currentPath();
        arrayCounts.remove(apath);
        this.messageStack.pop();
        return Observable.<Navajo>empty();
      case ARRAY_ELEMENT_STARTED:
        String arrayElementName = tagStack.peek();
        String arrayPath = currentPath();
        AtomicInteger currentCount = arrayCounts.get(arrayPath);
        String ind = "@" + currentCount.getAndIncrement();
        tagStack.push(ind);
        arrayPath = currentPath();
        Message newElt =
            NavajoFactory.getInstance()
                .createMessage(assemble, arrayElementName, Message.MSG_TYPE_ARRAY_ELEMENT);
        Message arrParent = messageStack.peek();
        arrParent.addElement(newElt);
        messageStack.push(newElt);
        return Observable.<Navajo>empty();
      case ARRAY_ELEMENT:
        tagStack.pop();
        Message elementParent = messageStack.pop();
        Msg msgElement = (Msg) n.body();
        List<Prop> elementProps = msgElement.properties();
        for (Prop e : elementProps) {
          elementParent.addProperty(createTmlProperty(e));
        }
        for (Entry<String, Binary> e : pushBinaries.entrySet()) {
          elementParent.addProperty(createBinaryProperty(e.getKey(), e.getValue()));
        }
        pushBinaries.clear();

        return Observable.<Navajo>empty();

      case MESSAGE_DEFINITION_STARTED:
        // TODO
        return Observable.<Navajo>empty();
      case MESSAGE_DEFINITION:
        // TODO
        //			tagStack.push(n.path());
        //			deferredMessages.get(stripIndex(n.path())).setDefinitionMessage((Message) n.body());
        return Observable.<Navajo>empty();
      case NAVAJO_DONE:
        if (subscriber != null) {
          subscriber.onNext(assemble);
        }
        return Observable.<Navajo>just(assemble);

      case BINARY_STARTED:
        try {
          String name = n.path();
          this.currentBinary = new Binary();
          this.currentBinary.startPushRead();
          this.pushBinaries.put(name, currentBinary);
          return Observable.<Navajo>empty();
        } catch (IOException e1) {
          return Observable.error(e1);
        }

      case BINARY_CONTENT:
        try {
          if (this.currentBinary == null) {
            // whoops;
          }
          this.currentBinary.pushContent((String) n.body());
          return Observable.<Navajo>empty();
        } catch (IOException e1) {
          return Observable.error(e1);
        }

      case BINARY_DONE:
        try {
          this.currentBinary.finishPushContent();
          return Observable.<Navajo>empty();
        } catch (IOException e1) {
          return Observable.error(e1);
        }
      default:
        return Observable.<Navajo>empty();
    }
  }
Пример #21
0
 @Override
 public final Observable<Model> mapping() {
   return Observable.empty();
 }