MessageServiceTestTDD.java :  » JPA » cz-zcu-kiv-jet-jpa » cz » zcu » kiv » jet » jpa » service » Java Open Source

package cz.zcu.kiv.jet.jpa.service;

import static org.junit.Assert.*;

import java.sql.Date;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.databene.contiperf.PerfTest;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;

import cz.zcu.kiv.jet.jpa.domain.Blip;
import cz.zcu.kiv.jet.jpa.domain.Group;
import cz.zcu.kiv.jet.jpa.domain.Message;
import cz.zcu.kiv.jet.jpa.domain.Participant;
import cz.zcu.kiv.jet.jpa.domain.User;
import cz.zcu.kiv.jet.jpa.exception.ObjectAlreadyExistsException;
import cz.zcu.kiv.jet.jpa.exception.ObjectBadAttributesException;
import cz.zcu.kiv.jet.jpa.exception.ObjectNotFoundException;


@ContextConfiguration({ "/appctx-main.xml", "/appctx-orm.xml" })
@PerfTest(invocations = 1, threads = 1)
public class MessageServiceTestTDD extends AbstractJUnit4SpringContextTests {
  
  @Autowired
  private MessageService messageService;

  /** User service dependency. */
  @Autowired
  private UserService userService;
  
  private Set<Participant> particip = new HashSet<Participant>();
  
  
  /* -----------------getMessage---------------------- */
  
  @Test (expected=ObjectNotFoundException.class)
  public void testGetMessageObjectNotFound() {
    //ocekavam null?? kdyz to padne na te vyjimce?
    assertNull("Message isnt null", messageService.getMessage(-1));
  }
  
  @Test
  public void testGetMessageObjectFound() {    
    List<User> users = new ArrayList<User>();
    User user = createUser("john1", "password", "Doe", "john.doe@example.org");
    
    particip.add(user);
    users.add(user);
    
    Message msg = createMessage(particip);
    
    assertEquals(msg.getId(), (messageService.getMessage(msg.getId())).getId());
    
    //tady to pada, ale je to nutny pro opakovane spousteni testu
    //userService.deleteUsers(users);
  }
  
  
  /* -----------------getHeadBlipsByUser---------------------- */
  
  @Test (expected=IllegalArgumentException.class)
  public void testGetHeadBlipsByUserIllegalArgument() {
    assertNull("Blips arent null", messageService.getHeadBlipsByUser(null));
  }
  
  @Test (expected=ObjectNotFoundException.class)
  public void testGetHeadBlipsByUserObjectsNotFound() {
    assertNull("Blips arent null", messageService.getHeadBlipsByUser(new User()));
  }
  
  @Test
  public void testGetHeadBlipsByUserObjectsFound() {
    User user = createUser("david", "password", "Fore", "david.fore@example.org");
    particip.add(user);
    
    Message msg = createMessage(particip);
    List<Blip> blips = createBlips(user, msg);
    
    assertEquals(blips.get(0).getId(), (messageService.getHeadBlipsByUser(user)).get(0).getId());
  }
  
  
  /* -----------------getHeadBlipsByGroup---------------------- */
  
  @Test (expected=IllegalArgumentException.class)
  public void testGetHeadBlipsByGroupIllegalArgument() {
    assertNull("Blips arent null", messageService.getHeadBlipsByGroup(null));
  }
  
  @Test (expected=ObjectNotFoundException.class)
  public void testGetHeadBlipsByGroupObjectsNotFound() {
    assertNull("Blips arent null", messageService.getHeadBlipsByGroup(new Group()));
  }
  
  @Test
  public void testGetHeadBlipsByGroupObjectsFound() {
    User user = createUser("david1", "password", "Fore", "david.fore@example.org");
    Group group = createGroup("group1");
    particip.add(group);
    
    
    Message msg = createMessage(particip);
    List<Blip> blips = createBlips(user, msg);
    
    assertEquals(blips.get(0).getId(), (messageService.getHeadBlipsByGroup(group)).get(0).getId());
  }
  
  
  /* -----------------getHeadBlipsMyGroup---------------------- */
  
  @Test (expected=IllegalArgumentException.class)
  public void testGetHeadBlipsMyGroupIllegalArgument() {
    assertNull("Blips arent null", messageService.getHeadBlipsMyGroup(null));
  }
  
  @Test (expected=ObjectNotFoundException.class)
  public void testGetHeadBlipsMyGroupObjectsNotFound() {
    assertNull("Blips arent null", messageService.getHeadBlipsMyGroup(new User()));
  }
  
  @Test
  public void testGetHeadBlipsMyGroupObjectsFound() {
    User user = createUser("david2", "password", "Fore", "david.fore@example.org");
    User user2 = createUser("potmesil", "password", "Smisek", "potme.smich@example.org");
    Group group = createGroup("group2");
    userService.addUserToGroup(user, group);
    
    particip.add(group);
    
    Message msg = createMessage(particip);
    List<Blip> blips = createBlips(user2, msg);
    
    assertEquals(blips.get(0).getId(), (messageService.getHeadBlipsMyGroup(user)).get(0).getId());
  }
  
  
  /* -----------------getAllBlipsByRootMessage---------------------- */
  
  @Test (expected=IllegalArgumentException.class)
  public void testGetAllBlipsByRootMessageIllegalArgument() {
    assertNull("Blips arent null", messageService.getAllBlipsByRootMessage(null));
  }
  
  @Test (expected=ObjectNotFoundException.class)
  public void testGetAllBlipsByRootMessageObjectsNotFound() {
    assertNull("Blips arent null", messageService.getAllBlipsByRootMessage(new Message()));
  }
  
  @Test
  public void testGetAllBlipsByRootMessageObjectFound() {    
    List<User> users = new ArrayList<User>();
    User user = createUser("john3", "password", "Doe", "john.doe@example.org");
    
    particip.add(user);
    users.add(user);
    
    Message msg = createMessage(particip);
    List<Blip> blips = createBlips(user, msg);
    
    assertEquals(blips.get(0).getId(), messageService.getAllBlipsByRootMessage(msg).get(0).getId());
  }
  
  
  /* -----------------addMessage---------------------- */
  
  @Test (expected=IllegalArgumentException.class)
  public void testAddMessageIllegalArgument() {
    assertNull("Blips arent null", messageService.addMessage(null));
  }
  
  @Test (expected=ObjectBadAttributesException.class)
  public void testAddMessageBadAttributes() {
    messageService.addMessage(new Message());
  }
  
  @Test (expected=ObjectAlreadyExistsException.class)
  public void testAddMessageObjectAlreadyExists() {
    List<User> users = new ArrayList<User>();
    User user = createUser("john4", "password", "Doe", "john.doe@example.org");
    
    particip.add(user);
    users.add(user);
    
    createMessage(particip);
    createMessage(particip);
  }
  
  @Test
  public void testAddMessageObjectAdded() {
    List<User> users = new ArrayList<User>();
    User user = createUser("john4", "password", "Doe", "john.doe@example.org");
    
    particip.add(user);
    users.add(user);
    
    Message msg = createMessage(particip);
    
    assertNotNull(messageService.getMessage(msg.getId()));
  }
  
  
  /* -----------------addBlip---------------------- */
  
  @Test (expected=IllegalArgumentException.class)
  public void testAddBlipIllegalArgument() {
    assertNull("Blips arent null", messageService.addBlip(null));
  }
  
  @Test (expected=ObjectBadAttributesException.class)
  public void testaddBlipBadAttributes() {
    messageService.addBlip(new Blip());
  }
  
  @Test (expected=ObjectAlreadyExistsException.class)
  public void testaddBlipObjectAlreadyExists() {
    List<User> users = new ArrayList<User>();
    User user = createUser("john4", "password", "Doe", "john.doe@example.org");
    
    particip.add(user);
    users.add(user);

    Message msg = createMessage(particip);
    
    createBlips(user, msg);
    createBlips(user, msg);
  }
  
  @Test
  public void testaddBlipObjectAdded() {
    List<User> users = new ArrayList<User>();
    User user = createUser("john4", "password", "Doe", "john.doe@example.org");
    
    particip.add(user);
    users.add(user);
    
    Message msg = createMessage(particip);
    
    createBlips(user, msg);
    
    assertNotNull(messageService.getHeadBlipsByUser(user));
  }
  
  
  /* -----------------deleteBlips---------------------- */
  
  @Test (expected=IllegalArgumentException.class)
  public void testDeleteBlipsIllegalArgument() {
    messageService.deleteBlips(null);
  }
  
  @Test (expected=ObjectNotFoundException.class)
  public void testDeleteBlipsNotFound() {
    messageService.deleteBlips(new ArrayList<Blip>());
  }
  
  @Test
  public void testDeleteBlipsObjectDeleted() {    
    List<User> users = new ArrayList<User>();
    User user = createUser("john5", "password", "Doe", "john.doe@example.org");
    
    particip.add(user);
    users.add(user);
    
    Message msg = createMessage(particip);
    List<Blip> blips = createBlips(user, msg);
    
    messageService.deleteBlips(blips);  
    
    assertNull(messageService.getHeadBlipsByUser(user));
  }
  
  
  /* -----------------deleteMessages---------------------- */
  
  @Test (expected=IllegalArgumentException.class)
  public void testDeleteMessagesIllegalArgument() {
    messageService.deleteMessages(null);
  }
  
  @Test (expected=ObjectNotFoundException.class)
  public void testDeleteMessagesNotFound() {
    messageService.deleteMessages(new ArrayList<Message>());
  }
  
  @Test
  public void testDeleteMessagesObjectDeleted() {    
    List<User> users = new ArrayList<User>();
    List<Message> messages = new ArrayList<Message>();
    User user = createUser("john6", "password", "Doe", "john.doe@example.org");
    
    particip.add(user);
    users.add(user);
    
    messages.add(createMessage(particip));
    
    messageService.deleteMessages(messages);  
    
    assertNull(messageService.getMessage(messages.get(0).getId()));
  }
  
  
  /* -----------------pomocne metody pro plneni databaze---------------------- */
  
  private Message createMessage(Set<Participant> part) {
    Message msg = new Message();
    Date date = new Date(System.currentTimeMillis());
    msg.setCreated(date);
    msg.setParticipants(part);
    msg.setUpdated(date);
    return messageService.addMessage(msg);
  }
  
  private User createUser(String username, String password, String name, String email) {
    User u = new User();
    u.setUsername(username);
    u.setPassword(password);
    u.setName(name);
    u.setEmail(email);
    u.setSurname("Jan");
    return userService.storeUser(u);
  }
  
  private Group createGroup(String name) {
    Group g = new Group();
    g.setName(name);
    return userService.storeGroup(g);
  }
  
  private List<Blip> createBlips(final User user, Message rootMessage) {
    List<Blip> blips = new ArrayList<Blip>();
    
    Blip blip = new Blip();
    blip.setAutor(user);
    blip.setContents("testovaci zprava, head blip");
    // blip.setParent(null);
    blip.setRootMessage(rootMessage);
    blips.add(messageService.addBlip(blip));

    Blip blip1 = new Blip();
    blip1.setAutor(user);
    blip1.setContents("testovaci zprava, notHeadBlip");
    blip1.setParent(blip);
    blip1.setRootMessage(rootMessage);
    blips.add(messageService.addBlip(blip1));
    
    return blips;
  }
}