Projects >> zanata-server >>db97c39ad5f2b2210cb752ce2d8d7df135ebe84e

Chunk
Conflicting content 
@Getter
@AllArgsConstructor
@NoArgsConstructor
<<<<<<< HEAD
public abstract class SlugEntityBase extends ModelEntityBase {
=======
public abstract class SlugEntityBase extends ModelEntityBase
{
>>>>>>> 6885e3ee57e1a3c84cfeb7f85496587e4038b01a

    private static final long serialVersionUID = -1911540675412928681L;
Solution content 
@AllArgsConstructor
@NoArgsConstructor
public abstract class SlugEntityBase extends ModelEntityBase
{

   private static final long serialVersionUID = -1911540675412928681L;
   private String slug;
File
SlugEntityBase.java
Developer's decision
Version 1
Kind of conflict
Class signature
Chunk
Conflicting content 
 */
package org.zanata.model.tm;

<<<<<<< HEAD
=======
import java.util.HashMap;
import java.util.HashSet;
>>>>>>> 6885e3ee57e1a3c84cfeb7f85496587e4038b01a
import java.util.Map;
import java.util.Set;
Solution content 
 */
package org.zanata.model.tm;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
File
TransMemory.java
Developer's decision
Version 2
Kind of conflict
Import
Chunk
Conflicting content 
import javax.annotation.Nonnull;
import javax.persistence.Access;
import javax.persistence.AccessType;
<<<<<<< HEAD
import javax.persistence.Column;
import javax.persistence.ElementCollection;
import javax.persistence.Entity;
import javax.persistence.EnumType;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.MapKeyColumn;
import javax.persistence.MapKeyEnumerated;
=======
import javax.persistence.Basic;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.ElementCollection;
import javax.persistence.Entity;
import javax.persistence.JoinTable;
import javax.persistence.Lob;
import javax.persistence.MapKeyClass;
>>>>>>> 6885e3ee57e1a3c84cfeb7f85496587e4038b01a
import javax.persistence.OneToMany;

import lombok.AccessLevel;
Solution content 
import javax.persistence.Access;
import javax.persistence.AccessType;
import javax.persistence.Basic;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.ElementCollection;
import javax.persistence.Entity;
import javax.persistence.JoinTable;
import javax.persistence.Lob;
import javax.persistence.MapKeyClass;
import javax.persistence.OneToMany;

import org.zanata.model.SlugEntityBase;

import lombok.AccessLevel;
File
TransMemory.java
Developer's decision
Manual
Kind of conflict
Import
Chunk
Conflicting content 
@ToString(exclude = "translationUnits")
@Data
@Access(AccessType.FIELD)
<<<<<<< HEAD
public class TransMemory extends SlugEntityBase implements HasTMMetadata {
    private static final long serialVersionUID = 1L;

    private String description;

    // This is the BCP-47 language code. Null means any source language (*all*
    // in TMX)
    @Column(name = "source_language", nullable = true)
    private String sourceLanguage;

    public static TransMemory tm(String slug) {
        TransMemory tm = new TransMemory();
        tm.setSlug(slug);
        return tm;
    }

    @Setter(AccessLevel.PROTECTED)
    @OneToMany(mappedBy = "translationMemory", orphanRemoval = true)
    private Set translationUnits = Sets.newHashSet();

    /**
     * Map values are Json strings containing metadata for the particular type
     * of translation memory
     */
    @ElementCollection
    @MapKeyEnumerated(EnumType.STRING)
    @MapKeyColumn(name = "metadata_type")
    @JoinTable(name = "TransMemory_Metadata", joinColumns = { @JoinColumn(
            name = "trans_memory_id") })
    @Column(name = "metadata", length = Integer.MAX_VALUE)
    private Map metadata = Maps.newHashMap();
=======
public class TransMemory extends SlugEntityBase
{
   public enum TransMemoryMetadata
   {
      DEFAULT;
   }

   @Getter @Setter
   @Column
   private String name;
>>>>>>> 6885e3ee57e1a3c84cfeb7f85496587e4038b01a

    @Override
    public String getMetadata(TMMetadataType tmType) {
Solution content 
@ToString(exclude = "translationUnits")
@Access(AccessType.FIELD)
public class TransMemory extends SlugEntityBase
{
   public enum TransMemoryMetadata
   {
      DEFAULT;
   }

   @Getter @Setter
   private String description;
File
TransMemory.java
Developer's decision
Combination
Kind of conflict
Annotation
Attribute
Class signature
Enum declaration
Chunk
Conflicting content 
        return metadata.get(tmType);
    }

<<<<<<< HEAD
    @Override
    public void setMetadata(@Nonnull TMMetadataType tmType, String metadata) {
        this.metadata.put(tmType, metadata);
    }
=======
   @Getter @Setter
   @ElementCollection
   @MapKeyClass(TransMemoryMetadata.class)
   @JoinTable(name = "TransMemory_Metadata")
   @Lob
   private Map metadata = new HashMap();

>>>>>>> 6885e3ee57e1a3c84cfeb7f85496587e4038b01a
}
Solution content 
   @Getter @Setter
   @ElementCollection
   @MapKeyClass(TransMemoryMetadata.class)
   @JoinTable(name = "TransMemory_Metadata")
   @Lob
   private Map metadata = new HashMap();

}
File
TransMemory.java
Developer's decision
Version 2
Kind of conflict
Annotation
Attribute
Method invocation
Chunk
Conflicting content 
 */
<<<<<<< HEAD

 *         href="mailto:pahuang@redhat.com">pahuang@redhat.com
 * @author Patrick Huang >>>>>> 6885e3ee57e1a3c84cfeb7f85496587e4038b01a
}
Solution content 
 */
public class SlugEntityBaseTest
{
   @NoArgsConstructor
   static class SlugClass extends SlugEntityBase
   {
      public SlugClass(String slug)
      {
         super(slug);
      }
   }
   @Test
   public void lombokToStringAndEqualsTest() {
      SlugEntityBase entity = new SlugClass();

      entity.setSlug("abc");
      entity.setId(1L);
      entity.setVersionNum(2);
      assertThat(entity.toString(), containsString("[id=1,versionNum=2], slug=abc)"));

      SlugEntityBase other = new SlugClass("abc");
      assertThat(entity.equals(other), equalTo(false));

      other.setId(entity.getId());
      other.setVersionNum(entity.getVersionNum());
      assertThat(entity, equalTo(other));

      assertThat(entity.hashCode(), equalTo(other.hashCode()));

   }
}
File
SlugEntityBaseTest.java
Developer's decision
Version 1
Kind of conflict
Annotation
Class declaration
Class signature
Method declaration
Chunk
Conflicting content 
import java.util.List;

<<<<<<< HEAD
import javax.persistence.Query;

import org.dbunit.operation.DatabaseOperation;
=======
import org.dbunit.operation.DatabaseOperation;
import org.hamcrest.Matchers;
>>>>>>> 6885e3ee57e1a3c84cfeb7f85496587e4038b01a
import org.hibernate.criterion.Restrictions;
import org.testng.annotations.Test;
import org.zanata.ZanataDbunitJpaTest;
Solution content 
import java.util.List;

import org.dbunit.operation.DatabaseOperation;
import org.hibernate.criterion.Restrictions;
import org.testng.annotations.Test;
import org.zanata.ZanataDbunitJpaTest;
File
TransMemoryJPATest.java
Developer's decision
Combination
Kind of conflict
Import
Chunk
Conflicting content 
   {
 * @author Carlos Munoz camunoz@redhat.com
 */
<<<<<<< HEAD
public class TransMemoryJPATest extends ZanataDbunitJpaTest {
    /**
    *
    */
    private static final int NUM_TRANS_UNITS = 5;

    @Override
    protected void prepareDBUnitOperations() {
        beforeTestOperations.add(new DataSetOperation(
                "org/zanata/test/model/ClearAllTables.dbunit.xml",
                DatabaseOperation.DELETE_ALL));
    }

    private TransMemory createDefaultTransMemoryInstance() {
        TransMemory tm = new TransMemory();
        tm.setSlug("new-trans-memory");
        return tm;
    }

    private TransMemory loadTM(String slug) {
        return (TransMemory) super.getSession()
                .createCriteria(TransMemory.class)
                .add(Restrictions.naturalId().set("slug", slug)).uniqueResult();
    }

    @Test
    public void save() throws Exception {
        TransMemory tm = createDefaultTransMemoryInstance();
        super.getEm().persist(tm);

        TransMemory stored = loadTM("new-trans-memory");

        assertThat(stored.getSlug(), is(tm.getSlug()));
    }

    @Test
    public void saveWithMetadata() throws Exception {
        TransMemory tm = createDefaultTransMemoryInstance();
        String defaultMetadataVal = "This is a test";
        tm.getMetadata().put(TMMetadataType.TMX14, defaultMetadataVal);
        super.getEm().persist(tm);

        TransMemory stored = loadTM("new-trans-memory");
        assertThat(stored.getSlug(), is(tm.getSlug()));
        assertThat(stored.getMetadata().size(), is(tm.getMetadata().size()));
        assertThat(stored.getMetadata().get(TMMetadataType.TMX14),
                equalTo(defaultMetadataVal));
    }

    @Test
    public void saveWithTransUnits() throws Exception {
        TransMemory tm = createDefaultTransMemoryInstance();

        // add some units
        for (int i = 0; i < NUM_TRANS_UNITS; i++) {
            TransMemoryUnit unit = new TransMemoryUnit("uid:" + i);
            unit.setTranslationMemory(tm);
            unit.setSourceLanguage("en-US");
            unit.setTransUnitId("unit-id-" + i);
            tm.getTranslationUnits().add(unit);
        }

        super.getEm().persist(tm);

        // Fetch it, should have the same elements
        TransMemory stored = loadTM("new-trans-memory");

        assertThat(stored.getTranslationUnits().size(), is(NUM_TRANS_UNITS));
    }

    @Test
    public void saveTransUnitsWithMetadata() throws Exception {
        TransMemory tm = createDefaultTransMemoryInstance();

        // add some units
        for (int i = 0; i < NUM_TRANS_UNITS; i++) {
            TransMemoryUnit unit = new TransMemoryUnit("uid:" + i);
            unit.setTranslationMemory(tm);
            unit.setSourceLanguage("en-US");
            unit.setTransUnitId("unit-id-" + i);
            unit.setMetadata(TMMetadataType.TMX14, "Metadata " + i);
            tm.getTranslationUnits().add(unit);
        }

        super.getEm().persist(tm);

        // Fetch it, should have the same elements
        TransMemory stored = loadTM("new-trans-memory");

        assertThat(stored.getTranslationUnits().size(), is(NUM_TRANS_UNITS));
        for (TransMemoryUnit tu : tm.getTranslationUnits()) {
            assertThat(tu.getMetadata(TMMetadataType.TMX14),
                    startsWith("Metadata "));
        }
    }

    @Test
    public void saveTransUnitVariants() throws Exception {
        // Save them from the bottom up, as that is probably how it will need to
        // be done due to the large amount of them
        saveWithTransUnits();

        // Fetch the translation memory
        TransMemory stored = loadTM("new-trans-memory");

        // For each trans unit, generate some variants
        for (TransMemoryUnit tu : stored.getTranslationUnits()) {
            TransMemoryUnitVariant tuvES =
                    new TransMemoryUnitVariant("es",
                            "Mensaje de Prueba");
            TransMemoryUnitVariant tuvEN =
                    new TransMemoryUnitVariant("en-US",
                            "Test Message");
            TransMemoryUnitVariant tuvFR =
                    new TransMemoryUnitVariant("fr",
                            "Message de test");

            tu.getTransUnitVariants().put(tuvES.getLanguage(), tuvES);
            tu.getTransUnitVariants().put(tuvEN.getLanguage(), tuvEN);
            tu.getTransUnitVariants().put(tuvFR.getLanguage(), tuvFR);

            super.getEm().merge(tu);
        }

        // Verify they were saved
        List results = queryTUVs().getResultList();
        assertThat(results.size(), greaterThan(0));
    }

    @Test
    public void saveTransUnitVariantWithFormatting() throws Exception {
        // Save them from the bottom up, as that is probably how it will need to
        // be done due to the large amount of them
        saveWithTransUnits();

        // Fetch the translation memory
        TransMemory stored = loadTM("new-trans-memory");

        // Store a Trans unit variant with formatting
        TransMemoryUnit tu = stored.getTranslationUnits().iterator().next();
        TransMemoryUnitVariant tuvES =
                new TransMemoryUnitVariant("es",
                        "Mensaje <b>de<b> Prueba");

        tu.getTransUnitVariants().put(tuvES.getLanguage(), tuvES);

        super.getEm().merge(tu);

        // Verify they were saved
        TransMemoryUnitVariant tuv =
                (TransMemoryUnitVariant) queryTUVs().getSingleResult();
        assertThat(tuv.getPlainTextSegment(), equalTo("Mensaje de Prueba"));
    }

    private Query queryTUVs() {
        return getEm()
                .createQuery(
                        "select tu.transUnitVariants from TransMemoryUnit tu where tu.translationMemory.slug = 'new-trans-memory'");
    }
=======
public class TransMemoryJPATest extends ZanataDbunitJpaTest
{
   @Override
   protected void prepareDBUnitOperations()
   {
      beforeTestOperations.add(new DataSetOperation("org/zanata/test/model/ClearAllTables.dbunit.xml", DatabaseOperation.DELETE_ALL));
   }

   private TransMemory createDefaultTransMemoryInstance()
   {
      TransMemory tm = new TransMemory();
      tm.setName("New Trans Memory");
      tm.setSlug("new-trans-memory");
      return tm;
   }

   private TransMemory getTransMemory(String slug)
      return (TransMemory)
            super.getSession().createCriteria(TransMemory.class).add(Restrictions.naturalId().set("slug", slug))
                  .uniqueResult();
   }

   @Test
   public void save() throws Exception
   {
      TransMemory tm = createDefaultTransMemoryInstance();
      super.getEm().persist(tm);

      TransMemory stored = getTransMemory("new-trans-memory");

      assertThat(stored.getName(), is(tm.getName()));
   }

   @Test
   public void saveWithMetadata() throws Exception
   {
      TransMemory tm = createDefaultTransMemoryInstance();
      String defaultMetadataVal = "This is a test";
      tm.getMetadata().put(TransMemory.TransMemoryMetadata.DEFAULT, defaultMetadataVal);
      super.getEm().persist(tm);

      TransMemory stored = getTransMemory("new-trans-memory");
      assertThat(stored.getName(), is(tm.getName()));
      assertThat(stored.getMetadata().size(), is( tm.getMetadata().size() ));
      assertThat(stored.getMetadata().get(TransMemory.TransMemoryMetadata.DEFAULT), equalTo(defaultMetadataVal));
   }

   @Test
   public void saveWithTransUnits() throws Exception
   {
      TransMemory tm = createDefaultTransMemoryInstance();

      // add some units
      for( int i = 0; i<5; i++ )
      {
         TMTranslationUnit unit = new TMTranslationUnit();
         unit.setTranslationMemory(tm);
         unit.setSourceLanguage("en-US");
         unit.setTransUnitId("unit-id-" + i);
         tm.getTranslationUnits().add(unit);
      }

      super.getEm().persist(tm);

      // Fetch it, should have the same elements
      TransMemory stored = getTransMemory("new-trans-memory");

      assertThat(stored.getTranslationUnits().size(), is(5));
   }

   @Test
   public void saveTransUnitsWithMetadata() throws Exception
   {
      TransMemory tm = createDefaultTransMemoryInstance();

      // add some units
      for( int i = 0; i<5; i++ )
      {
         TMTranslationUnit unit = new TMTranslationUnit();
         unit.setTranslationMemory(tm);
         unit.setSourceLanguage("en-US");
         unit.setTransUnitId("unit-id-" + i);
         unit.getMetadata().put(TMTranslationUnit.TMTranslationUnitMetadata.DEFAULT, "Metadata " + i);
         tm.getTranslationUnits().add(unit);
      }

      super.getEm().persist(tm);

      // Fetch it, should have the same elements
      TransMemory stored = getTransMemory("new-trans-memory");

      assertThat(stored.getTranslationUnits().size(), is(5));
      for( TMTranslationUnit tu : tm.getTranslationUnits() )
      {
         assertThat(tu.getMetadata().size(), is(1));
         assertThat(tu.getMetadata().get(TMTranslationUnit.TMTranslationUnitMetadata.DEFAULT), startsWith("Metadata "));
      }
   }

   @Test
   public void saveTransUnitVariants() throws Exception
   {
      // Save them from the bottom up, as that is probably how it will need to be done due to the large amount of them
      saveWithTransUnits();

      // Fetch the translation memory
      TransMemory stored = getTransMemory("new-trans-memory");

      // For each trans unit, generate some variants
      for(TMTranslationUnit tu : stored.getTranslationUnits())
      {
         TMTransUnitVariant tuvES = new TMTransUnitVariant("es", "Mensaje de Prueba");
         TMTransUnitVariant tuvEN = new TMTransUnitVariant("en-US", "Test Message");
         TMTransUnitVariant tuvFR = new TMTransUnitVariant("fr", "Message de test");

         tu.getTransUnitVariants().put(tuvES.getLanguage(), tuvES);
         tu.getTransUnitVariants().put(tuvEN.getLanguage(), tuvEN);
         tu.getTransUnitVariants().put(tuvFR.getLanguage(), tuvFR);

         super.getEm().merge(tu);
      }

      // Verify they were saved
      List results = getEm().createQuery("from TMTransUnitVariant").getResultList();
      assertThat(results.size(), greaterThan(0));
   }
>>>>>>> 6885e3ee57e1a3c84cfeb7f85496587e4038b01a
}
Solution content 
 */
public class TransMemoryJPATest extends ZanataDbunitJpaTest
{
   @Override
   protected void prepareDBUnitOperations()
   {
      beforeTestOperations.add(new DataSetOperation("org/zanata/test/model/ClearAllTables.dbunit.xml", DatabaseOperation.DELETE_ALL));
   }

   private TransMemory createDefaultTransMemoryInstance()
   {
      TransMemory tm = new TransMemory();
      tm.setName("New Trans Memory");
      tm.setSlug("new-trans-memory");
      return tm;
   }

   private TransMemory getTransMemory(String slug)
   {
      return (TransMemory)
            super.getSession().createCriteria(TransMemory.class).add(Restrictions.naturalId().set("slug", slug))
                  .uniqueResult();
   }

   @Test
   public void save() throws Exception
   {
      TransMemory tm = createDefaultTransMemoryInstance();
      super.getEm().persist(tm);

      TransMemory stored = getTransMemory("new-trans-memory");

      assertThat(stored.getName(), is(tm.getName()));
   }

   @Test
   public void saveWithMetadata() throws Exception
   {
      TransMemory tm = createDefaultTransMemoryInstance();
      String defaultMetadataVal = "This is a test";
      tm.getMetadata().put(TransMemory.TransMemoryMetadata.DEFAULT, defaultMetadataVal);
      super.getEm().persist(tm);

      TransMemory stored = getTransMemory("new-trans-memory");
      assertThat(stored.getName(), is(tm.getName()));
      assertThat(stored.getMetadata().size(), is( tm.getMetadata().size() ));
      assertThat(stored.getMetadata().get(TransMemory.TransMemoryMetadata.DEFAULT), equalTo(defaultMetadataVal));
   }

   @Test
   public void saveWithTransUnits() throws Exception
   {
      TransMemory tm = createDefaultTransMemoryInstance();

      // add some units
      for( int i = 0; i<5; i++ )
      {
         TMTranslationUnit unit = new TMTranslationUnit();
         unit.setTranslationMemory(tm);
         unit.setSourceLanguage("en-US");
         unit.setTransUnitId("unit-id-" + i);
         tm.getTranslationUnits().add(unit);
      }

      super.getEm().persist(tm);

      // Fetch it, should have the same elements
      TransMemory stored = getTransMemory("new-trans-memory");

      assertThat(stored.getTranslationUnits().size(), is(5));
   }

   @Test
   public void saveTransUnitsWithMetadata() throws Exception
   {
      TransMemory tm = createDefaultTransMemoryInstance();

      // add some units
      for( int i = 0; i<5; i++ )
      {
         TMTranslationUnit unit = new TMTranslationUnit();
         unit.setTranslationMemory(tm);
         unit.setSourceLanguage("en-US");
         unit.setTransUnitId("unit-id-" + i);
         unit.getMetadata().put(TMTranslationUnit.TMTranslationUnitMetadata.DEFAULT, "Metadata " + i);
         tm.getTranslationUnits().add(unit);
      }

      super.getEm().persist(tm);

      // Fetch it, should have the same elements
      TransMemory stored = getTransMemory("new-trans-memory");

      assertThat(stored.getTranslationUnits().size(), is(5));
      for( TMTranslationUnit tu : tm.getTranslationUnits() )
      {
         assertThat(tu.getMetadata().size(), is(1));
         assertThat(tu.getMetadata().get(TMTranslationUnit.TMTranslationUnitMetadata.DEFAULT), startsWith("Metadata "));
      }
   }

   @Test
   public void saveTransUnitVariants() throws Exception
   {
      // Save them from the bottom up, as that is probably how it will need to be done due to the large amount of them
      saveWithTransUnits();

      // Fetch the translation memory
      TransMemory stored = getTransMemory("new-trans-memory");

      // For each trans unit, generate some variants
      for(TMTranslationUnit tu : stored.getTranslationUnits())
      {
         TMTransUnitVariant tuvES = new TMTransUnitVariant("es", "Mensaje de Prueba");
         TMTransUnitVariant tuvEN = new TMTransUnitVariant("en-US", "Test Message");
         TMTransUnitVariant tuvFR = new TMTransUnitVariant("fr", "Message de test");

         tu.getTransUnitVariants().put(tuvES.getLanguage(), tuvES);
         tu.getTransUnitVariants().put(tuvEN.getLanguage(), tuvEN);
         tu.getTransUnitVariants().put(tuvFR.getLanguage(), tuvFR);

         super.getEm().merge(tu);
      }

      // Verify they were saved
      List results = getEm().createQuery(
            "select tu.transUnitVariants from TMTranslationUnit tu where tu.translationMemory.slug = 'new-trans-memory'").getResultList();
      assertThat(results.size(), greaterThan(0));
   }

   @Test
   public void saveTransUnitVariantWithFormatting() throws Exception
   {
      // Save them from the bottom up, as that is probably how it will need to be done due to the large amount of them
      saveWithTransUnits();

      // Fetch the translation memory
      TransMemory stored = getTransMemory("new-trans-memory");

      // Store a Trans unit variant with formatting
      TMTranslationUnit tu = stored.getTranslationUnits().iterator().next();
      TMTransUnitVariant tuvES = new TMTransUnitVariant("es", "Mensaje <b>de<b> Prueba");

      tu.getTransUnitVariants().put(tuvES.getLanguage(), tuvES);

      super.getEm().merge(tu);

      // Verify they were saved
      TMTransUnitVariant tuv
            = (TMTransUnitVariant)getEm().createQuery(
               "select tu.transUnitVariants from TMTranslationUnit tu where tu.translationMemory.slug = 'new-trans-memory'").getSingleResult();
      assertThat(tuv.getPlainTextSegment(), equalTo("Mensaje de Prueba"));
   }
}
File
TransMemoryJPATest.java
Developer's decision
Manual
Kind of conflict
Annotation
Class signature
Method declaration