Fix and move getVersionSupportedLocale test to service class

zanata-war/src/main/java/org/zanata/webtrans/server/rpc/GetLocaleListHandler.java

@@ -1,89 +1,62 @@
 package org.zanata.webtrans.server.rpc;
 
-import java.util.ArrayList;
 import java.util.List;
-import javax.annotation.Nonnull;
-
-import net.customware.gwt.dispatch.server.ExecutionContext;
-import net.customware.gwt.dispatch.shared.ActionException;
 
 import org.jboss.seam.ScopeType;
 import org.jboss.seam.annotations.In;
 import org.jboss.seam.annotations.Name;
 import org.jboss.seam.annotations.Scope;
-import org.zanata.dao.LocaleDAO;
-import org.zanata.dao.ProjectDAO;
-import org.zanata.dao.ProjectIterationDAO;
 import org.zanata.model.HLocale;
-import org.zanata.model.HProject;
-import org.zanata.model.HProjectIteration;
 import org.zanata.security.ZanataIdentity;
+import org.zanata.service.LocaleService;
 import org.zanata.webtrans.server.ActionHandlerFor;
 import org.zanata.webtrans.shared.model.IdForLocale;
 import org.zanata.webtrans.shared.model.Locale;
 import org.zanata.webtrans.shared.model.ProjectIterationId;
 import org.zanata.webtrans.shared.rpc.GetLocaleList;
 import org.zanata.webtrans.shared.rpc.GetLocaleListResult;
+import com.google.common.collect.Lists;
+
+import net.customware.gwt.dispatch.server.ExecutionContext;
+import net.customware.gwt.dispatch.shared.ActionException;
 
 @Name("webtrans.gwt.GetLocaleListHandler")
 @Scope(ScopeType.STATELESS)
 @ActionHandlerFor(GetLocaleList.class)
-public class GetLocaleListHandler extends AbstractActionHandler<GetLocaleList,
-        GetLocaleListResult> {
+public class GetLocaleListHandler extends
+        AbstractActionHandler<GetLocaleList, GetLocaleListResult> {
     @In
     private ZanataIdentity identity;
+
     @In
-    private LocaleDAO localeDAO;
-    @In
-    private ProjectIterationDAO projectIterationDAO;
-    @In
-    private ProjectDAO projectDAO;
-    private ProjectIterationId iterationId;
-    private String projectSlug;
+    private LocaleService localeServiceImpl;
 
     @Override
     public GetLocaleListResult execute(GetLocaleList action,
-    ExecutionContext context) throws ActionException {
+            ExecutionContext context) throws ActionException {
         identity.checkLoggedIn();
 
-        iterationId = action.getWorkspaceId().getProjectIterationId();
-        projectSlug = iterationId.getProjectSlug();
-
-        List<Locale> locales = new ArrayList<Locale>();
+        ProjectIterationId iterationId =
+                action.getWorkspaceId().getProjectIterationId();
+        String projectSlug = iterationId.getProjectSlug();
 
-        List<HLocale> hLocales = getLocaleList();
+        List<HLocale> hLocales =
+                localeServiceImpl.getSupportedLanguageByProjectIteration(
+                        projectSlug, iterationId.getIterationSlug());
 
+        List<Locale> locales = Lists.newArrayList();
         for (HLocale hLocale : hLocales) {
-            Locale locale = new Locale(new IdForLocale(hLocale.getId(),
-                    hLocale.getLocaleId()), hLocale.retrieveDisplayName());
+            Locale locale =
+                    new Locale(new IdForLocale(hLocale.getId(),
+                            hLocale.getLocaleId()),
+                            hLocale.retrieveDisplayName());
             locales.add(locale);
         }
         return new GetLocaleListResult(locales);
     }
 
     @Override
     public void rollback(GetLocaleList action, GetLocaleListResult result,
-    ExecutionContext context) throws ActionException {
-    }
-
-    /**
-     *
-     * @return the current locales for this iteration
-     */
-    private List<HLocale> getLocaleList() {
-        HProjectIteration iteration = projectIterationDAO.getBySlug(projectSlug,
-                iterationId.getIterationSlug());
-        if (iteration.isOverrideLocales()) {
-            return new ArrayList<HLocale>(iteration.getCustomizedLocales());
-        }
-        return getSupportedLanguageByProject(projectSlug);
-    }
-
-    private List<HLocale> getSupportedLanguageByProject(@Nonnull String project) {
-        HProject proj = projectDAO.getBySlug(project);
-        if (proj.isOverrideLocales()) {
-            return new ArrayList<HLocale>(proj.getCustomizedLocales());
-        }
-        return localeDAO.findAllActiveAndEnabledByDefault();
+            ExecutionContext context) throws ActionException {
     }
 }

zanata-war/src/main/java/org/zanata/webtrans/shared/model/IdForLocale.java

@@ -2,8 +2,8 @@
 
 import java.io.Serializable;
 
-import com.google.gwt.user.client.rpc.IsSerializable;
 import org.zanata.common.LocaleId;
+import com.google.gwt.user.client.rpc.IsSerializable;
 
 //@Immutable
 public class IdForLocale implements Identifier<Long>, IsSerializable, Serializable {

zanata-war/src/test/java/org/zanata/service/impl/LocaleServiceImplTest.java

@@ -21,35 +21,85 @@
 package org.zanata.service.impl;
 
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 
+import org.hamcrest.Matchers;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.testng.Assert;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
 import org.zanata.common.LocaleId;
 import org.zanata.dao.LocaleDAO;
+import org.zanata.dao.ProjectDAO;
+import org.zanata.dao.ProjectIterationDAO;
 import org.zanata.model.HLocale;
+import org.zanata.model.HProject;
+import org.zanata.model.HProjectIteration;
 
+import static org.hamcrest.MatcherAssert.assertThat;
 import static org.mockito.Mockito.when;
 
 @Test(groups = { "business-tests" })
 public class LocaleServiceImplTest {
     private LocaleServiceImpl testLocaleServiceImpl;
+
+    @Mock
+    private ProjectIterationDAO projectIterationDAO;
+
+    @Mock
+    private ProjectDAO projectDAO;
+
+    @Mock
+    private LocaleDAO localeDAO;
+
+    @Mock
+    private HProject hProject;
+
     @Mock
-    private LocaleDAO mockDAO;
+    private HProjectIteration hProjectIteration;
+
+    private String projectSlug = "project";
+    private String versionSlug = "master";
 
     @BeforeMethod(firstTimeOnly = true)
     public void setup() {
         MockitoAnnotations.initMocks(this);
+
         this.testLocaleServiceImpl = new LocaleServiceImpl();
-        this.testLocaleServiceImpl.setLocaleDAO(mockDAO);
+        this.testLocaleServiceImpl.setProjectIterationDAO(projectIterationDAO);
+        this.testLocaleServiceImpl.setProjectDAO(projectDAO);
+        this.testLocaleServiceImpl.setLocaleDAO(localeDAO);
+
+        Set<HLocale> iterationLocales = new HashSet<HLocale>();
+        iterationLocales.add(new HLocale(LocaleId.EN_US));
+        iterationLocales.add(new HLocale(LocaleId.DE));
+
+        when(hProjectIteration.getId()).thenReturn(1L);
+        when(hProjectIteration.getCustomizedLocales()).thenReturn(
+                iterationLocales);
+        when(projectIterationDAO.getBySlug(projectSlug, versionSlug))
+                .thenReturn(hProjectIteration);
+
+        Set<HLocale> projectLocales = new HashSet<HLocale>();
+        projectLocales.add(new HLocale(LocaleId.ES));
+        when(hProject.getId()).thenReturn(1L);
+        when(hProject.getCustomizedLocales()).thenReturn(projectLocales);
+        when(projectDAO.getBySlug(projectSlug)).thenReturn(hProject);
+
+        List<HLocale> defaultLocales = new ArrayList<HLocale>();
+        defaultLocales.add(new HLocale(LocaleId.FR));
+        defaultLocales.add(new HLocale(LocaleId.EN));
+        defaultLocales.add(new HLocale(LocaleId.DE));
+        when(localeDAO.findAllActiveAndEnabledByDefault()).thenReturn(
+                defaultLocales);
     }
 
     @Test
     public void testGetAllJavaLanguages() throws Exception {
-        List<LocaleId> loc = this.testLocaleServiceImpl.getAllJavaLanguages();
+        List<LocaleId> loc = testLocaleServiceImpl.getAllJavaLanguages();
         StringBuilder st = new StringBuilder("");
         for (LocaleId localeId : loc) {
             st.append(localeId.getId() + ",");
@@ -67,12 +117,56 @@ public void testGetAllSupportedLanguages() {
         List<HLocale> lan = new ArrayList<HLocale>();
         lan.add(new HLocale(new LocaleId("as-IN")));
         lan.add(new HLocale(new LocaleId("pt-BR")));
-        when(mockDAO.findAll()).thenReturn(lan);
-        List<HLocale> sup = this.testLocaleServiceImpl.getAllLocales();
+        when(localeDAO.findAll()).thenReturn(lan);
+        List<HLocale> sup = testLocaleServiceImpl.getAllLocales();
         Assert.assertEquals(sup.size(), 2);
         String loc1 = sup.get(0).getLocaleId().getId();
         Assert.assertEquals(loc1, "as-IN");
         String loc2 = sup.get(1).getLocaleId().getId();
         Assert.assertEquals(loc2, "pt-BR");
     }
+
+    @Test
+    public void testVersionLocale() {
+        when(hProject.isOverrideLocales()).thenReturn(true);
+        when(hProjectIteration.isOverrideLocales()).thenReturn(true);
+
+        List<HLocale> result =
+                testLocaleServiceImpl.getSupportedLanguageByProjectIteration(
+                        projectSlug, versionSlug);
+
+        assertThat(result, Matchers.hasSize(2));
+        assertThat(result.get(0).getLocaleId(),
+                Matchers.equalTo(LocaleId.EN_US));
+        assertThat(result.get(1).getLocaleId(), Matchers.equalTo(LocaleId.DE));
+    }
+
+    @Test
+    public void testVersionLocaleWithOverriddenProjectLocales() {
+        when(hProject.isOverrideLocales()).thenReturn(true);
+
+        List<HLocale> result =
+                testLocaleServiceImpl.getSupportedLanguageByProjectIteration(
+                        projectSlug, versionSlug);
+
+        assertThat(result, Matchers.hasSize(1));
+        assertThat(result.get(0).getLocaleId(), Matchers.equalTo(LocaleId.ES));
+    }
+
+    @Test
+    public void testVersionLocaleWithNoOverridden() throws Exception {
+        when(hProjectIteration.isOverrideLocales()).thenReturn(false);
+        when(hProject.isOverrideLocales()).thenReturn(false);
+
+        List<HLocale> result =
+                testLocaleServiceImpl.getSupportedLanguageByProjectIteration(
+                        projectSlug, versionSlug);
+
+        assertThat(result, Matchers.hasSize(3));
+
+        assertThat(result.get(0).getLocaleId(), Matchers.equalTo(LocaleId.FR));
+        assertThat(result.get(1).getLocaleId(), Matchers.equalTo(LocaleId.EN));
+        assertThat(result.get(2).getLocaleId(), Matchers.equalTo(LocaleId.DE));
+    }
+
 }