Esempio n. 1
0
  @Test
  public void shouldReturnNullResponseIfLibraryBackendFails() throws Exception {
    when(syncTemplate.postForObject(
            anyString(), eq(JsonConverter.toJson(request)), eq(String.class)))
        .thenThrow(new RuntimeException("Some server error"));

    messEngine.send(mergeRequest);

    @SuppressWarnings("unchecked")
    Message<SyncValueObject> response =
        (Message<SyncValueObject>)
            messEngine.getMessage(MessEngineConstants.SYNC_LIBRARY_MERGE_RESPONSE);
    assertNotNull(response);
    assertNull(response.getBody());
  }
Esempio n. 2
0
  @Test
  public void shouldForwardMergeRequestsToLibraryBackend() throws Exception {
    when(syncTemplate.postForObject(
            anyString(), eq(JsonConverter.toJson(request)), eq(String.class)))
        .thenReturn(JsonConverter.toJson(expectedResponse));

    messEngine.send(mergeRequest);

    @SuppressWarnings("unchecked")
    Message<SyncValueObject> response =
        (Message<SyncValueObject>)
            messEngine.getMessage(MessEngineConstants.SYNC_LIBRARY_MERGE_RESPONSE);
    assertNotNull(response);
    assertEquals(expectedResponse, response.getBody());
  }
Esempio n. 3
0
 @Test
 public void shouldDeletePendingEmails() throws Exception {
   Message<?> message =
       new AllMessage<String>(MessEngineConstants.DELETE_PENDING_EMAILS_TYPE, "delete");
   messEngine.send(message);
   verify(defaultTemplate).delete(anyString(), eq(message.getBody()));
 }
Esempio n. 4
0
  @Test
  public void shouldGetLocalFeeds() throws Exception {
    when(defaultTemplate.getForObject(anyString(), eq(String.class), eq(feedUserIdRequest)))
        .thenReturn(JsonConverter.toJson(expectedFeedResponse));

    messEngine.send(localFeedsRequest);
    @SuppressWarnings("unchecked")
    Message<FeedsResponse> response =
        (Message<FeedsResponse>) messEngine.getMessage(MessEngineConstants.FEEDS_LOCAL_RESPONSE);

    assertNotNull(response);
    assertEquals(expectedFeedResponse.getFeeds(), response.getBody().getFeeds());
    assertEquals(expectedFeedResponse.getOwnerId(), response.getBody().getOwnerId());
    assertEquals(
        expectedFeedResponse.getCurrentServerTime(), response.getBody().getCurrentServerTime());
  }
Esempio n. 5
0
  @SuppressWarnings("unchecked")
  @Test
  // TODO Hacer m�s complejo este test
  public void shouldProcessContactListRequest() throws Exception {
    String email = "*****@*****.**";
    List<ContactInfo> contactlist = new ArrayList<ContactInfo>();
    AllMessage<String> request =
        new AllMessage<String>(MessEngineConstants.CONTACT_LIST_REQUEST_TYPE, email);
    when(defaultTemplate.getForObject(anyString(), any(Class.class), eq(request)))
        .thenReturn(contactlist);

    messEngine.send(request);

    Message<List<ContactInfo>> response =
        (Message<List<ContactInfo>>)
            messEngine.getMessage(MessEngineConstants.CONTACT_LIST_RESPONSE_TYPE);
    assertNotNull(response);
  }
Esempio n. 6
0
  @Test
  public void shouldReturnSameRequestWithoutEventsIfCannotCommitDeltaToLibraryBackend()
      throws Exception {
    when(syncTemplate.postForObject(
            anyString(), eq(JsonConverter.toJson(request)), eq(String.class)))
        .thenThrow(new RuntimeException("Some server error"));
    assertNotNull(request.getEvents());

    messEngine.send(commitRequest);

    @SuppressWarnings("unchecked")
    Message<SyncValueObject> response =
        (Message<SyncValueObject>)
            messEngine.getMessage(MessEngineConstants.SYNC_SEND_DELTA_RESPONSE);
    assertNotNull(response);
    assertEquals(request, response.getBody());
    assertNull(request.getEvents());
  }
Esempio n. 7
0
  @Test
  public void shouldGetAlerts() throws Exception {
    @SuppressWarnings("deprecation")
    MusicContentAlert alert =
        new MusicContentAlert(
            new ContactInfo(), new ContactInfo(), new Date(), new ModelCollection(), "message");
    List<Alert> expectedList = new ArrayList<Alert>();
    expectedList.add(alert);
    String userId = "userID";
    when(defaultTemplate.getForObject(anyString(), eq(String.class), eq(userId)))
        .thenReturn(JsonConverter.toJson(expectedList));
    messEngine.send(new AllMessage<String>(MessEngineConstants.ALERTS_REQUEST_TYPE, userId));

    verify(defaultTemplate).getForObject(anyString(), eq(String.class), eq(userId));

    Message<?> responseMessage = messEngine.getMessage(MessEngineConstants.ALERTS_RESPONSE_TYPE);
    assertNotNull(responseMessage);
    assertEquals(expectedList, responseMessage.getBody());
  }
Esempio n. 8
0
  @Test
  public void shouldPutAlert() throws Exception {
    @SuppressWarnings("deprecation")
    MusicContentAlert alert =
        new MusicContentAlert(
            new ContactInfo(), new ContactInfo(), new Date(), new ModelCollection(), "message");
    messEngine.send(new AllMessage<Alert>(MessEngineConstants.PUT_ALERT_TYPE, alert));

    verify(defaultTemplate).put(anyString(), eq(JsonConverter.toJson(alert)), eq(alert.getId()));
  }
Esempio n. 9
0
 @Test
 public void shouldUpdateContactProfile() throws Exception {
   @SuppressWarnings("deprecation")
   ContactInfo contactInfo = new ContactInfo();
   contactInfo.setEmail("*****@*****.**");
   contactInfo.setId(1L);
   Message<?> message =
       new AllMessage<ContactInfo>(
           MessEngineConstants.UPDATE_CONTACT_PROFILE_REQUEST, contactInfo);
   when(defaultTemplate.postForObject(
           anyString(), eq(JsonConverter.toJson(contactInfo)), eq(String.class)))
       .thenReturn(JsonConverter.toJson(contactInfo));
   messEngine.send(message);
   verify(defaultTemplate)
       .postForObject(anyString(), eq(JsonConverter.toJson(contactInfo)), eq(String.class));
   Message<?> response =
       messEngine.getMessage(MessEngineConstants.UPDATE_CONTACT_PROFILE_RESPONSE);
   assertNotNull(response);
   assertEquals(contactInfo, response.getBody());
 }
Esempio n. 10
0
  @Test
  public void shouldForwardCommitRequestToLibraryBackendAndReturnResponseWithoutEvents()
      throws Exception {
    when(syncTemplate.postForObject(
            anyString(), eq(JsonConverter.toJson(request)), eq(String.class)))
        .thenReturn(JsonConverter.toJson(expectedResponse));
    assertNotNull(request.getEvents());
    assertNotNull(expectedResponse.getEvents());

    messEngine.send(commitRequest);

    @SuppressWarnings("unchecked")
    Message<SyncValueObject> response =
        (Message<SyncValueObject>)
            messEngine.getMessage(MessEngineConstants.SYNC_SEND_DELTA_RESPONSE);
    assertNotNull(response);
    SyncValueObject actualResponse = response.getBody();
    assertEquals(expectedResponse, actualResponse);
    assertNull(actualResponse.getEvents());
  }
Esempio n. 11
0
  @Test
  public void shouldProcessDeleteContactsMessage() throws Exception {
    String body = "contactIds";
    String sender = "sender";
    AllMessage<String> message =
        new AllMessage<String>(MessEngineConstants.DELETE_CONTACTS_TYPE, body);
    message.putProperty(MessEngineConstants.SENDER_ID, sender);

    messEngine.send(message);

    verify(defaultTemplate).delete(anyString(), eq(sender), eq(body));
  }
Esempio n. 12
0
  @Test
  public void shouldCreatePendingEmail() throws Exception {
    final PendingEmail pendingEmail = new PendingEmail(1L, "*****@*****.**");
    Message<?> message =
        new AllMessage<PendingEmail>(MessEngineConstants.SEND_EMAIL_TYPE, pendingEmail);
    when(defaultTemplate.postForObject(
            anyString(), eq(JsonConverter.toJson(message.getBody())), eq(String.class)))
        .thenAnswer(
            new Answer<String>() {
              @Override
              public String answer(InvocationOnMock invocation) throws Throwable {
                pendingEmail.setId(100L);
                return JsonConverter.toJson(pendingEmail);
              }
            });
    messEngine.send(message);

    assertNotNull(pendingEmail.getId());
    Message<?> response = messEngine.getMessage(MessEngineConstants.PUSH_PENDING_EMAIL_TYPE);
    assertNotNull(response);
    PendingEmail actual = (PendingEmail) response.getBody();
    assertEquals(pendingEmail.getId(), actual.getId());
  }
Esempio n. 13
0
  @Test
  public void shouldDeleteAlert() throws Exception {
    final String id = "id";
    Alert alert =
        new AbstractAlert() {
          @Override
          public String getId() {
            return id;
          }
        };
    messEngine.send(new AllMessage<Alert>(MessEngineConstants.DELETE_ALERT_TYPE, alert));

    verify(defaultTemplate).delete(anyString(), eq(alert.getId()));
  }
Esempio n. 14
0
  @Before
  public void setup() {
    MockitoAnnotations.initMocks(this);
    messEngine.setup(allServerAdapter);
    when(clientSettings.getProperty(anyString())).thenReturn("some url");

    allServerAdapter.initialize();

    mergeRequest =
        new AllMessage<SyncValueObject>(MessEngineConstants.SYNC_LIBRARY_MERGE_REQUEST, request);
    commitRequest =
        new AllMessage<SyncValueObject>(MessEngineConstants.SYNC_SEND_DELTA_REQUEST, request);
    initFeedRequests();
  }