/** @author Rafael Steil */
public class TopicWatchTopicEventTestCase {
  private Mockery context = TestCaseUtils.newMockery();
  private TopicWatchDao repository = context.mock(TopicWatchDao.class);
  private TopicWatchTopicEvent event = new TopicWatchTopicEvent(repository);

  @Test
  public void deleted() {
    final Topic topic = new Topic();
    topic.setId(2);

    context.checking(
        new Expectations() {
          {
            one(repository).removeSubscription(topic);
          }
        });

    event.deleted(topic);
    context.assertIsSatisfied();
  }
}
/** @author Rafael Steil */
public class AvatarServiceTestCase {
  private Mockery context = TestCaseUtils.newMockery();
  private AvatarRepository repository = context.mock(AvatarRepository.class);
  private JForumConfig config = context.mock(JForumConfig.class);
  private AvatarService service = new AvatarService(config, repository);

  @Test(expected = NullPointerException.class)
  public void addNullExpectException() {
    service.add(null, null);
  }

  @Test(expected = ValidationException.class)
  public void addWithIdExpectException() {
    Avatar avatar = new Avatar();
    avatar.setId(1);

    context.checking(
        new Expectations() {
          {
            one(config).getBoolean(ConfigKeys.AVATAR_ALLOW_GALLERY);
            will(returnValue(true));
            one(config).getBoolean(ConfigKeys.AVATAR_ALLOW_UPLOAD);
            will(returnValue(true));
          }
        });

    service.add(avatar);
  }

  @Test(expected = ValidationException.class)
  public void updateWithoutIdExpectException() {
    Avatar avatar = new Avatar();
    avatar.setId(0);

    context.checking(
        new Expectations() {
          {
            one(config).getBoolean(ConfigKeys.AVATAR_ALLOW_GALLERY);
            will(returnValue(true));
            one(config).getBoolean(ConfigKeys.AVATAR_ALLOW_UPLOAD);
            will(returnValue(true));
          }
        });

    service.update(avatar, null);
  }

  @Test
  public void addExpectSuccess() throws IOException {
    final Avatar avatar = new Avatar();
    File tempFile = File.createTempFile("jforum", "tests");
    tempFile.deleteOnExit();
    final String tempDir = tempFile.getParent();

    File file = new File(this.getClass().getResource("/smilies/smilie.gif").getFile());
    TestCaseUtils.copyFile(file, tempFile);

    UploadedFile uploadedFile =
        new DefaultUploadedFile(new FileInputStream(file), file.getAbsolutePath(), "");

    context.checking(
        new Expectations() {
          {
            one(config).getApplicationPath();
            will(returnValue(tempDir));
            one(config).getValue(ConfigKeys.AVATAR_GALLERY_DIR);
            will(returnValue(""));
            one(config).getBoolean(ConfigKeys.AVATAR_ALLOW_GALLERY);
            will(returnValue(true));
            one(config).getBoolean(ConfigKeys.AVATAR_ALLOW_UPLOAD);
            will(returnValue(true));
            one(config).getLong(ConfigKeys.AVATAR_MAX_SIZE);
            will(returnValue(10000l));
            one(config).getInt(ConfigKeys.AVATAR_MAX_WIDTH);
            will(returnValue(800));
            one(config).getInt(ConfigKeys.AVATAR_MAX_HEIGHT);
            will(returnValue(600));
            one(config).getInt(ConfigKeys.AVATAR_MIN_WIDTH);
            will(returnValue(1));
            one(config).getInt(ConfigKeys.AVATAR_MIN_HEIGHT);
            will(returnValue(1));
            one(repository).add(avatar);
          }
        });

    service.add(avatar, uploadedFile);
    context.assertIsSatisfied();
    Assert.assertNotNull(avatar.getFileName());

    File expectedFile = new File(String.format("%s/%s/%s", tempDir, "", avatar.getFileName()));
    expectedFile.deleteOnExit();

    Assert.assertTrue(expectedFile.exists());
  }

  @Test(expected = NullPointerException.class)
  public void updateNullExpectException() {
    service.update(null, null);
  }

  @Test
  public void updateImageShouldDeleteOldImage() throws IOException {
    final File currentFile = File.createTempFile("avatar", "tests");
    currentFile.deleteOnExit();

    final Avatar currentAvatar = new Avatar();
    currentAvatar.setId(1);
    currentAvatar.setAvatarType(AvatarType.AVATAR_GALLERY);
    currentAvatar.setFileName(currentFile.getName());

    context.checking(
        new Expectations() {
          {
            one(repository).get(1);
            will(returnValue(currentAvatar));
            atLeast(1).of(config).getApplicationPath();
            will(returnValue(currentFile.getParent()));
            atLeast(1).of(config).getValue(ConfigKeys.AVATAR_GALLERY_DIR);
            will(returnValue(""));
            one(config).getBoolean(ConfigKeys.AVATAR_ALLOW_GALLERY);
            will(returnValue(true));
            one(config).getBoolean(ConfigKeys.AVATAR_ALLOW_UPLOAD);
            will(returnValue(true));
            one(config).getLong(ConfigKeys.AVATAR_MAX_SIZE);
            will(returnValue(10000l));
            one(config).getInt(ConfigKeys.AVATAR_MAX_WIDTH);
            will(returnValue(800));
            one(config).getInt(ConfigKeys.AVATAR_MAX_HEIGHT);
            will(returnValue(600));
            one(config).getInt(ConfigKeys.AVATAR_MIN_WIDTH);
            will(returnValue(1));
            one(config).getInt(ConfigKeys.AVATAR_MIN_HEIGHT);
            will(returnValue(1));
            one(repository).update(currentAvatar);
          }
        });

    File originalFile = new File(this.getClass().getResource("/smilies/smilie.gif").getFile());
    File newFile = File.createTempFile("jforum", "tests");
    TestCaseUtils.copyFile(originalFile, newFile);

    UploadedFile uploadedFile =
        new DefaultUploadedFile(new FileInputStream(newFile), newFile.getAbsolutePath(), "");

    String oldDiskName = currentAvatar.getFileName();

    Avatar newAvatar = new Avatar();
    newAvatar.setId(1);
    newAvatar.setAvatarType(AvatarType.AVATAR_GALLERY);
    service.update(newAvatar, uploadedFile);
    context.assertIsSatisfied();

    Assert.assertEquals(newAvatar.getAvatarType(), currentAvatar.getAvatarType());
    Assert.assertFalse(currentFile.exists());
    Assert.assertFalse(currentAvatar.getFileName().equals(oldDiskName));

    new File(String.format("%s/%s", currentFile.getParent(), currentAvatar.getFileName())).delete();
  }

  @Test
  public void deleteUsingNullShouldIgnore() {
    context.checking(
        new Expectations() {
          {
          }
        });
    Avatar avatar = null;
    service.delete(avatar);
  }

  @Test
  public void deleteExpectSuccess() {
    context.checking(
        new Expectations() {
          {
            Avatar s1 = new Avatar();
            s1.setId(1);
            s1.setFileName(Long.toString(System.currentTimeMillis()));
            Avatar s2 = new Avatar();
            s2.setId(2);
            s2.setFileName(Long.toString(System.currentTimeMillis()));

            String applicationPath =
                new File(this.getClass().getResource("").getFile()).getParent();

            atLeast(1).of(config).getApplicationPath();
            will(returnValue(applicationPath));
            atLeast(1).of(config).getValue(ConfigKeys.AVATAR_GALLERY_DIR);
            will(returnValue(""));

            one(repository).get(1);
            will(returnValue(s1));
            one(repository).remove(s1);

            one(repository).get(2);
            will(returnValue(s2));
            one(repository).remove(s2);
          }
        });

    service.delete(1, 2);
    context.assertIsSatisfied();
  }
}
/** @author Rafael Steil */
public class GroupAdminControllerTestCase extends AdminTestCase {
  private Mockery context = TestCaseUtils.newMockery();
  private GroupAdminController controller;
  private GroupRepository repository = context.mock(GroupRepository.class);
  private GroupService service = context.mock(GroupService.class);
  private CategoryRepository categoryRepository = context.mock(CategoryRepository.class);
  private UserSession userSession = context.mock(UserSession.class);
  private RoleManager roleManager = context.mock(RoleManager.class);
  private Result mockResult = context.mock(MockResult.class);
  private HttpServletRequest mockRequest = context.mock(HttpServletRequest.class);
  private GroupAdminController mockGroupAdminController = context.mock(GroupAdminController.class);

  public GroupAdminControllerTestCase() {
    super(GroupAdminController.class);
  }

  @Test
  public void permissions() {
    context.checking(
        new Expectations() {
          {
            one(repository).get(1);
            will(returnValue(new Group()));
            one(roleManager).isAdministrator();
            will(returnValue(true));
            one(categoryRepository).getAllCategories();
            will(returnValue(new ArrayList<Category>()));
            one(repository).getAllGroups();
            will(returnValue(new ArrayList<Group>()));

            one(mockResult).include("group", new Group());
            one(mockResult).include("groups", new ArrayList<Group>());
            one(mockResult).include("categories", new ArrayList<Category>());
            // TODO: fix PermOption				one(mockResult).include("permissions", new
            // PermissionOptions());
          }
        });

    controller.permissions(1);
    context.assertIsSatisfied();
  }

  @Test
  public void permissionsSave() {
    // TODO: fix PermOption		final PermissionOptions permissions = new PermissionOptions();

    context.checking(
        new Expectations() {
          {
            one(roleManager).isAdministrator();
            will(returnValue(true));
            // TODO: fix PermOption		one(service).savePermissions(1, permissions);
            one(mockResult).redirectTo(controller);
            will(returnValue(mockGroupAdminController));
            one(mockGroupAdminController).list();
          }
        });

    // TODO: fix PermOption	controller.permissionsSave(1, permissions);
    context.assertIsSatisfied();
  }

  @Test
  public void deleteIsFullAdministratorShouldAllow() {
    context.checking(
        new Expectations() {
          {
            one(roleManager).isAdministrator();
            will(returnValue(true));
            one(service).delete(1, 2);
            one(mockResult).redirectTo(controller);
            will(returnValue(mockGroupAdminController));
            one(mockGroupAdminController).list();
          }
        });

    controller.delete(1, 2);
    context.assertIsSatisfied();
  }

  @Test
  public void deleteIsNotFullAdministratorShouldIgnore() {
    context.checking(
        new Expectations() {
          {
            one(roleManager).isAdministrator();
            will(returnValue(false));
            one(mockResult).redirectTo(controller);
            will(returnValue(mockGroupAdminController));
            one(mockGroupAdminController).list();
          }
        });

    controller.delete(1, 2);
    context.assertIsSatisfied();
  }

  @Test
  public void list() {
    context.checking(
        new Expectations() {
          {
            one(repository).getAllGroups();
            will(returnValue(new ArrayList<Group>()));
            one(mockResult).include("groups", new ArrayList<Group>());
          }
        });

    controller.list();
    context.assertIsSatisfied();
  }

  @Test
  public void editExpectsAGroup() {
    context.checking(
        new Expectations() {
          {
            one(roleManager).isAdministrator();
            will(returnValue(true));
            one(repository).get(2);
            will(returnValue(new Group()));
            one(mockResult).include("group", new Group());
            one(mockResult).forwardTo(controller);
            will(returnValue(mockGroupAdminController));
            one(mockGroupAdminController).add();
          }
        });

    controller.edit(2);
    context.assertIsSatisfied();
  }

  @Test
  public void editSaveIsFullAdministratorExpectsSuccess() {
    final Group group = new Group();

    context.checking(
        new Expectations() {
          {
            one(roleManager).isAdministrator();
            will(returnValue(true));

            one(service).update(group);
            one(mockResult).redirectTo(controller);
            will(returnValue(mockGroupAdminController));
            one(mockGroupAdminController).list();
          }
        });

    controller.editSave(group);
    context.assertIsSatisfied();
  }

  @Test
  public void editSaveIsGroupManagerExpectsSuccess() {
    final Group group = new Group();

    context.checking(
        new Expectations() {
          {
            one(roleManager).isAdministrator();
            will(returnValue(false));
            one(roleManager).isGroupManager(group.getId());
            will(returnValue(true));

            one(service).update(group);
            one(mockResult).redirectTo(controller);
            will(returnValue(mockGroupAdminController));
            one(mockGroupAdminController).list();
          }
        });

    controller.editSave(group);
    context.assertIsSatisfied();
  }

  @Test
  public void editSaveIsNotFullAdministratorAndNotGroupManagerShouldIgnore() {
    final Group group = new Group();

    context.checking(
        new Expectations() {
          {
            one(roleManager).isAdministrator();
            will(returnValue(false));
            one(roleManager).isGroupManager(group.getId());
            will(returnValue(false));

            one(mockResult).redirectTo(controller);
            will(returnValue(mockGroupAdminController));
            one(mockGroupAdminController).list();
          }
        });

    controller.editSave(group);
    context.assertIsSatisfied();
  }

  @Test
  public void addSaveIsFullAdministratorShouldAllow() {
    context.checking(
        new Expectations() {
          {
            one(roleManager).isAdministrator();
            will(returnValue(true));
            one(service).add(with(aNonNull(Group.class)));
            one(mockResult).redirectTo(controller);
            will(returnValue(mockGroupAdminController));
            one(mockGroupAdminController).list();
          }
        });

    controller.addSave(new Group());
    context.assertIsSatisfied();
  }

  @Test
  public void addSaveIsNotFullAdministratorShouldIgnore() {
    context.checking(
        new Expectations() {
          {
            one(roleManager).isAdministrator();
            will(returnValue(false));
            one(mockResult).redirectTo(controller);
            will(returnValue(mockGroupAdminController));
            one(mockGroupAdminController).list();
          }
        });

    controller.addSave(new Group());
    context.assertIsSatisfied();
  }

  @Test
  public void addIsNotFullAdministratorShouldIgnore() {
    context.checking(
        new Expectations() {
          {
            one(roleManager).isAdministrator();
            will(returnValue(false));
            one(mockResult).redirectTo(controller);
            will(returnValue(mockGroupAdminController));
            one(mockGroupAdminController).list();
          }
        });

    controller.add();
    context.assertIsSatisfied();
  }

  @Test
  public void addIsFullAdministratorShouldAllow() {
    context.checking(
        new Expectations() {
          {
            one(roleManager).isAdministrator();
            will(returnValue(true));
          }
        });

    controller.add();
    context.assertIsSatisfied();
  }

  @Before
  public void setup() {
    controller =
        new GroupAdminController(
            service, repository, categoryRepository, mockResult, userSession, mockRequest);

    context.checking(
        new Expectations() {
          {
            allowing(userSession).getRoleManager();
            will(returnValue(roleManager));
          }
        });
  }
}