repo stringclasses 1k values | file_url stringlengths 96 373 | file_path stringlengths 11 294 | content stringlengths 0 32.8k | language stringclasses 1 value | license stringclasses 6 values | commit_sha stringclasses 1k values | retrieved_at stringdate 2026-01-04 14:45:56 2026-01-04 18:30:23 | truncated bool 2 classes |
|---|---|---|---|---|---|---|---|---|
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/PersonDeepProtectedHidden.java | jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/PersonDeepProtectedHidden.java | package com.sap.olingo.jpa.processor.core.testmodel;
import java.time.LocalDate;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import jakarta.persistence.Column;
import jakarta.persistence.Convert;
import jakarta.persistence.DiscriminatorValue;
import jakarta.persistence.Embedded;
import jakarta.persistence.Entity;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmIgnore;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmProtectedBy;
@EdmIgnore // Only
@Entity(name = "PersonDeepProtected")
@DiscriminatorValue(value = "1")
public class PersonDeepProtectedHidden extends BusinessPartnerProtected {// #NOSONAR use equal method from
// BusinessPartner
@Convert(converter = DateConverter.class)
@Column(name = "\"BirthDay\"")
private LocalDate birthDay;
@Convert(converter = AccessRightsConverter.class)
@Column(name = "\"AccessRights\"")
private AccessRights[] accessRights;
@Embedded
private AddressDeepProtected inhouseAddress;
@Embedded
@EdmProtectedBy(name = "Creator", path = "created/by")
@EdmProtectedBy(name = "Updator", path = "updated/by")
private final AdministrativeInformation protectedAdminInfo = new AdministrativeInformation();
public PersonDeepProtectedHidden() {
type = "1";
}
public LocalDate getBirthDay() {
return birthDay;
}
public void setBirthDay(final LocalDate birthDay) {
this.birthDay = birthDay;
}
public Short getAccessRights() {
return new AccessRightsConverter().convertToDatabaseColumn(accessRights);
}
public List<AccessRights> getAccessRightsAsList() {
return accessRights == null ? Collections.emptyList() : Arrays.asList(accessRights);
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/BusinessPartner.java | jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/BusinessPartner.java | package com.sap.olingo.jpa.processor.core.testmodel;
import java.math.BigDecimal;
import java.sql.Date;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Collection;
import jakarta.persistence.AssociationOverride;
import jakarta.persistence.CascadeType;
import jakarta.persistence.Column;
import jakarta.persistence.Convert;
import jakarta.persistence.DiscriminatorColumn;
import jakarta.persistence.Embedded;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.Id;
import jakarta.persistence.Inheritance;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.OneToMany;
import jakarta.persistence.PrePersist;
import jakarta.persistence.Table;
import jakarta.persistence.Version;
import org.apache.olingo.commons.api.edm.provider.annotation.CsdlConstantExpression.ConstantExpressionType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmAnnotation;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmDescriptionAssociation;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmEntityType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmIgnore;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmParameter;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmVisibleFor;
@Inheritance
@DiscriminatorColumn(name = "\"Type\"")
@Entity(name = "BusinessPartner")
@Table(schema = "\"OLINGO\"", name = "\"BusinessPartner\"")
@EdmEntityType(extensionProvider = EmptyQueryExtensionProvider.class)
@EdmFunction(
name = "CountRoles",
functionName = "COUNT_ROLES",
returnType = @EdmFunction.ReturnType(isCollection = true),
parameter = { @EdmParameter(name = "Amount", parameterName = "a", type = String.class),
})
@EdmFunction(
name = "max",
functionName = "MAX",
isBound = false,
hasFunctionImport = false,
returnType = @EdmFunction.ReturnType(type = BigDecimal.class, isCollection = false),
parameter = { @EdmParameter(name = "Path", parameterName = "path", type = String.class)
},
visibleFor = @EdmVisibleFor("Person"))
@EdmFunction(
name = "IsPrime",
functionName = "IS_PRIME",
isBound = false,
hasFunctionImport = true,
returnType = @EdmFunction.ReturnType(type = Boolean.class, isNullable = false),
parameter = { @EdmParameter(name = "Number", type = BigDecimal.class, precision = 32, scale = 0) })
public abstract class BusinessPartner implements KeyAccess {
@Id
@Column(name = "\"ID\"")
protected String iD;
@Version
@Column(name = "\"ETag\"", nullable = false)
protected long eTag;
@Column(name = "\"Type\"", length = 1, insertable = false, updatable = false, nullable = false)
protected String type;
@Column(name = "\"CreatedAt\"", precision = 2, insertable = false, updatable = false)
@Convert(converter = DateTimeConverter.class)
private LocalDateTime creationDateTime;
@EdmIgnore
@Column(name = "\"CustomString1\"")
@Convert(converter = StringConverter.class)
private String customString1;
@EdmIgnore
@Column(name = "\"CustomString2\"")
private String customString2;
@EdmIgnore
@Column(name = "\"CustomNum1\"", precision = 16, scale = 5)
private BigDecimal customNum1;
@EdmIgnore
@Column(name = "\"CustomNum2\"", precision = 34)
private BigDecimal customNum2;
@Column(name = "\"Country\"", length = 4)
private String country;
@EdmAnnotation(term = "Core.IsLanguageDependent", constantExpression = @EdmAnnotation.ConstantExpression(
type = ConstantExpressionType.Bool, value = "true"))
@EdmDescriptionAssociation(languageAttribute = "key/language", descriptionAttribute = "name",
valueAssignments = {
@EdmDescriptionAssociation.valueAssignment(attribute = "key/codePublisher", value = "ISO"),
@EdmDescriptionAssociation.valueAssignment(attribute = "key/codeID", value = "3166-1") })
@OneToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
@JoinColumn(name = "\"DivisionCode\"", referencedColumnName = "\"Country\"")
private Collection<AdministrativeDivisionDescription> locationName;
@Embedded
protected CommunicationData communicationData;
@Embedded
@AssociationOverride(name = "countryName",
joinColumns = @JoinColumn(referencedColumnName = "\"Address.Country\"", name = "\"ISOCode\""))
@AssociationOverride(name = "regionName",
joinColumns = {
@JoinColumn(referencedColumnName = "\"Address.RegionCodePublisher\"", name = "\"CodePublisher\""),
@JoinColumn(referencedColumnName = "\"Address.RegionCodeID\"", name = "\"CodeID\""),
@JoinColumn(referencedColumnName = "\"Address.Region\"", name = "\"DivisionCode\"") })
private PostalAddressData address = new PostalAddressData();
@Embedded
private AdministrativeInformation administrativeInformation = new AdministrativeInformation();
@OneToMany(mappedBy = "businessPartner", fetch = FetchType.LAZY, cascade = CascadeType.REMOVE)
private Collection<BusinessPartnerRole> roles;
public BusinessPartner() { // NOSONAR
super();
}
@Override
public boolean equals(final Object object) {
if (object instanceof final BusinessPartner other)
return iD != null ? iD.equals(other.iD) : other.iD == null;
return false;
}
public PostalAddressData getAddress() {
return address;
}
public AdministrativeInformation getAdministrativeInformation() {
return administrativeInformation;
}
public CommunicationData getCommunicationData() {
return communicationData;
}
public String getCountry() {
return country;
}
public LocalDateTime getCreationDateTime() {
return creationDateTime;
}
public BigDecimal getCustomNum1() {
return customNum1;
}
public BigDecimal getCustomNum2() {
return customNum2;
}
public String getCustomString1() {
return customString1;
}
public String getCustomString2() {
return customString2;
}
public long getETag() {
return eTag;
}
public String getID() {
return iD;
}
@Override
public Object getKey() {
return iD;
}
public Collection<BusinessPartnerRole> getRoles() {
if (roles == null)
roles = new ArrayList<>();
return roles;
}
public String getType() {
return type;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((iD == null) ? 0 : iD.hashCode());
return result;
}
public void setAddress(final PostalAddressData address) {
this.address = address;
}
public void setAdministrativeInformation(final AdministrativeInformation administrativeInformation) {
this.administrativeInformation = administrativeInformation;
}
public void setCommunicationData(final CommunicationData communicationData) {
this.communicationData = communicationData;
}
public void setCountry(final String country) {
this.country = country;
}
public void setCreationDateTime(final LocalDateTime creationDateTime) {
this.creationDateTime = creationDateTime;
}
public void setCustomNum1(final BigDecimal customNum1) {
this.customNum1 = customNum1;
}
public void setCustomNum2(final BigDecimal customNum2) {
this.customNum2 = customNum2;
}
public void setCustomString1(final String customString1) {
this.customString1 = customString1;
}
public void setCustomString2(final String customString2) {
this.customString2 = customString2;
}
public void setETag(final long eTag) {
this.eTag = eTag;
}
public void setID(final String iD) {
this.iD = iD;
}
public void setRoles(final Collection<BusinessPartnerRole> roles) {
this.roles = roles;
}
public void setType(final String type) {
this.type = type;
}
@PrePersist
public void onCreate() {
administrativeInformation = new AdministrativeInformation();
final ChangeInformation created = new ChangeInformation("99", Date.valueOf(LocalDate.now()));
administrativeInformation.setCreated(created);
administrativeInformation.setUpdated(created);
}
public Collection<AdministrativeDivisionDescription> getLocationName() {
return locationName;
}
public void setLocationName(final Collection<AdministrativeDivisionDescription> locationName) {
this.locationName = locationName;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/InheritanceByJoinAccount.java | jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/InheritanceByJoinAccount.java | package com.sap.olingo.jpa.processor.core.testmodel;
import java.math.BigDecimal;
import java.util.List;
import jakarta.persistence.Column;
import jakarta.persistence.DiscriminatorColumn;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Inheritance;
import jakarta.persistence.InheritanceType;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.OneToMany;
import jakarta.persistence.Table;
@Entity(name = "InheritanceAccount")
@Inheritance(strategy = InheritanceType.JOINED)
@DiscriminatorColumn(name = "\"Type\"")
@Table(schema = "\"OLINGO\"", name = "\"InheritanceByJoinAccount\"")
public class InheritanceByJoinAccount {
@Id
@Column(name = "\"ID\"")
private String accountId;
@Column(name = "\"Owner\"")
private String owner;
@Column(name = "\"Type\"", length = 31)
private String type;
@Column(name = "\"Amount\"", scale = 5, precision = 16)
private BigDecimal amount;
@OneToMany
@JoinColumn(name = "\"AccountID\"", referencedColumnName = "\"ID\"", insertable = false, updatable = false,
nullable = true)
private List<InheritanceByJoinTransaction> transactions;
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/MembershipKey.java | jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/MembershipKey.java | package com.sap.olingo.jpa.processor.core.testmodel;
import java.io.Serializable;
import jakarta.persistence.Column;
import jakarta.persistence.Id;
public class MembershipKey implements Serializable {
/**
*
*/
private static final long serialVersionUID = -2197928070426048826L;
@Id
@Column(name = "\"PersonID\"", length = 32)
private String personID;
@Id
@Column(name = "\"TeamID\"", length = 32)
private String teamID;
public MembershipKey() {
// Needed to be used as IdClass
}
public MembershipKey(final String personID, final String teamID) {
super();
this.personID = personID;
this.teamID = teamID;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((personID == null) ? 0 : personID.hashCode());
result = prime * result + ((teamID == null) ? 0 : teamID.hashCode());
return result;
}
@Override
public boolean equals(final Object obj) {
if (this == obj) return true;
if (obj == null) return false;
if (getClass() != obj.getClass()) return false;
final MembershipKey other = (MembershipKey) obj;
if (personID == null) {
if (other.personID != null) return false;
} else if (!personID.equals(other.personID)) return false;
if (teamID == null) {
if (other.teamID != null) return false;
} else if (!teamID.equals(other.teamID)) return false;
return true;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/StringConverter.java | jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/StringConverter.java | package com.sap.olingo.jpa.processor.core.testmodel;
import jakarta.persistence.AttributeConverter;
import jakarta.persistence.Converter;
//This converter has to be mentioned at all columns it is applicable
@Converter(autoApply = false)
public class StringConverter implements AttributeConverter<String, String> {
@Override
public String convertToDatabaseColumn(final String entityString) {
return entityString;
}
@Override
public String convertToEntityAttribute(final String dbString) {
return dbString;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/CollectionWithTransient.java | jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/CollectionWithTransient.java | package com.sap.olingo.jpa.processor.core.testmodel;
import java.util.List;
import jakarta.persistence.CollectionTable;
import jakarta.persistence.Column;
import jakarta.persistence.ElementCollection;
import jakarta.persistence.Embedded;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.Table;
import jakarta.persistence.Transient;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmTransient;
import com.sap.olingo.jpa.processor.core.errormodel.DummyPropertyCalculator;
@Entity
@Table(schema = "\"OLINGO\"", name = "\"Collections\"")
public class CollectionWithTransient {
@Id
@Column(name = "\"ID\"")
private String iD;
// Collection as part of complex
@Embedded
private CollectionPartOfComplex complex;
// Collection with nested complex
@ElementCollection(fetch = FetchType.LAZY)
@CollectionTable(schema = "\"OLINGO\"", name = "\"NestedComplex\"",
joinColumns = @JoinColumn(name = "\"ID\""))
private List<CollectionNestedComplexWithTransient> nested; // Must not be assigned to an ArrayList
@Transient
@EdmTransient(calculator = DummyPropertyCalculator.class)
private List<String> transientComment;
public String getID() {
return iD;
}
public void setID(final String iD) {
this.iD = iD;
}
public CollectionPartOfComplex getComplex() {
return complex;
}
public void setComplex(final CollectionPartOfComplex complex) {
this.complex = complex;
}
public List<CollectionNestedComplexWithTransient> getNested() {
return nested;
}
public void setNested(final List<CollectionNestedComplexWithTransient> nested) {
this.nested = nested;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((iD == null) ? 0 : iD.hashCode());
return result;
}
@Override
public boolean equals(final Object obj) {
if (this == obj) return true;
if (obj == null) return false;
if (getClass() != obj.getClass()) return false;
final CollectionWithTransient other = (CollectionWithTransient) obj;
if (iD == null) {
if (other.iD != null) return false;
} else if (!iD.equals(other.iD)) return false;
return true;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/DateConverter.java | jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/DateConverter.java | package com.sap.olingo.jpa.processor.core.testmodel;
import java.sql.Date;
import java.time.LocalDate;
import jakarta.persistence.AttributeConverter;
import jakarta.persistence.Converter;
//This converter has to be mentioned at all columns it is applicable
@Converter(autoApply = false)
public class DateConverter implements AttributeConverter<LocalDate, Date> {
@Override
public Date convertToDatabaseColumn(final LocalDate locDate) {
return (locDate == null ? null : Date.valueOf(locDate));
}
@Override
public LocalDate convertToEntityAttribute(final Date sqlDate) {
return (sqlDate == null ? null : sqlDate.toLocalDate());
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/PersonDeepProtected.java | jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/PersonDeepProtected.java | package com.sap.olingo.jpa.processor.core.testmodel;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.List;
import jakarta.persistence.CollectionTable;
import jakarta.persistence.Column;
import jakarta.persistence.ElementCollection;
import jakarta.persistence.Embedded;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.Table;
import jakarta.persistence.Version;
import org.apache.olingo.commons.api.edm.provider.annotation.CsdlConstantExpression.ConstantExpressionType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmAnnotation;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmProtectedBy;
@Entity(name = "PersonProtected")
@Table(schema = "\"OLINGO\"", name = "\"PersonProtected\"")
public class PersonDeepProtected {// #NOSONAR use equal method from BusinessPartner
// CREATE VIEW
// AS
//SELECT b."ID",b."ETag",b."NameLine1",b."NameLine2",b."CreatedBy",b."CreatedAt",b."UpdatedBy",b."UpdatedAt"
@Id
@Column(name = "\"ID\"")
protected String iD;
@Version
@Column(name = "\"ETag\"", nullable = false)
protected long eTag;
@Column(name = "\"NameLine1\"")
private String firstName;
@Column(name = "\"NameLine2\"")
private String lastName;
@Column(name = "\"CreatedAt\"", precision = 3, insertable = false, updatable = false)
private Timestamp creationDateTime;
@Embedded
private AddressDeepProtected inhouseAddress;
@Embedded
@EdmProtectedBy(name = "Creator", path = "created/by")
@EdmProtectedBy(name = "Updator", path = "updated/by")
private AdministrativeInformation protectedAdminInfo = new AdministrativeInformation();
// To test that claims are respected also when retrieving collection!
@EdmAnnotation(term = "Core.Description", qualifier = "Address",
constantExpression = @EdmAnnotation.ConstantExpression(type = ConstantExpressionType.String,
value = "Address for inhouse Mail"))
@ElementCollection(fetch = FetchType.LAZY)
@CollectionTable(schema = "\"OLINGO\"", name = "\"InhouseAddress\"",
joinColumns = @JoinColumn(name = "\"ParentID\""))
private final List<InhouseAddress> inhouseAddresses = new ArrayList<>();
public String getID() {
return iD;
}
public void setID(final String iD) {
this.iD = iD;
}
public String getLastName() {
return lastName;
}
public void setLastName(final String lastName) {
this.lastName = lastName;
}
public AddressDeepProtected getInhouseAddress() {
return inhouseAddress;
}
public void setInhouseAddress(final AddressDeepProtected inhouseAddress) {
this.inhouseAddress = inhouseAddress;
}
public AdministrativeInformation getProtectedAdminInfo() {
return protectedAdminInfo;
}
public void setProtectedAdminInfo(final AdministrativeInformation protectedAdminInfo) {
this.protectedAdminInfo = protectedAdminInfo;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((iD == null) ? 0 : iD.hashCode());
return result;
}
@Override
public boolean equals(final Object obj) {
if (this == obj) return true;
if (obj == null) return false;
if (getClass() != obj.getClass()) return false;
final PersonDeepProtected other = (PersonDeepProtected) obj;
if (iD == null) {
if (other.iD != null) return false;
} else if (!iD.equals(other.iD)) return false;
return true;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/DateTimeTest.java | jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/DateTimeTest.java | package com.sap.olingo.jpa.processor.core.testmodel;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.Date;
import jakarta.persistence.Column;
import jakarta.persistence.Convert;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import jakarta.persistence.Temporal;
import jakarta.persistence.TemporalType;
/**
* Test for time conversion
* @author Oliver Grande
* @since 1.0.1
* Created 2020-10-31
*/
@Entity(name = "DateTimeTest")
@Table(schema = "\"OLINGO\"", name = "\"BusinessPartner\"")
public class DateTimeTest {
@Id
@Column(name = "\"ID\"")
protected String iD;
@Column(name = "\"CreatedAt\"", precision = 3, insertable = false, updatable = false)
@Convert(converter = DateTimeConverter.class)
private LocalDateTime creationDateTime;
@Column(name = "\"CreatedAt\"", precision = 9)
@Temporal(TemporalType.TIMESTAMP)
private Date at;
@Column(name = "\"BirthDay\"")
private LocalDate birthDay;
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/InheritanceByJoinSavingAccount.java | jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/InheritanceByJoinSavingAccount.java | package com.sap.olingo.jpa.processor.core.testmodel;
import java.math.BigDecimal;
import jakarta.persistence.Column;
import jakarta.persistence.DiscriminatorValue;
import jakarta.persistence.Entity;
import jakarta.persistence.PrimaryKeyJoinColumn;
import jakarta.persistence.Table;
@DiscriminatorValue("SavingAccount")
@Entity(name = "InheritanceSavingAccount")
@Table(schema = "\"OLINGO\"", name = "\"InheritanceByJoinSavingAccount\"")
@PrimaryKeyJoinColumn(name = "\"ID\"")
public class InheritanceByJoinSavingAccount extends InheritanceByJoinAccount {
@Column(name = "\"InterestRate\"", precision = 5, scale = 2)
private BigDecimal interestRate;
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/InheritanceByJoinLockedSavingAccount.java | jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/InheritanceByJoinLockedSavingAccount.java | package com.sap.olingo.jpa.processor.core.testmodel;
import jakarta.persistence.Column;
import jakarta.persistence.DiscriminatorValue;
import jakarta.persistence.Entity;
import jakarta.persistence.PrimaryKeyJoinColumn;
import jakarta.persistence.Table;
@DiscriminatorValue("LockedSavingAccount")
@Entity(name = "InheritanceLockedSavingAccount")
@Table(schema = "\"OLINGO\"", name = "\"InheritanceByJoinLockedSavingAccount\"")
@PrimaryKeyJoinColumn(name = "\"AccountId\"")
public class InheritanceByJoinLockedSavingAccount extends InheritanceByJoinSavingAccount {
@Column(name = "\"LockingPeriod\"")
private int lockingPeriod;
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/TransientRefComplex.java | jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/TransientRefComplex.java | /**
*
*/
package com.sap.olingo.jpa.processor.core.testmodel;
import jakarta.persistence.Column;
import jakarta.persistence.Embedded;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import jakarta.persistence.Transient;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmTransient;
/**
* @author Oliver Grande
* Created: 08.12.2019
*
*/
@Entity(name = "TransientRefComplex")
@Table(schema = "\"OLINGO\"", name = "\"BusinessPartner\"")
public class TransientRefComplex {
@Id
@Column(name = "\"ID\"")
protected String iD;
@EdmTransient(requiredAttributes = { "addr/building" }, calculator = FullNameCalculator.class)
@Transient
private String concatenatedName;
@Embedded
private InhouseAddressWithGroup addr;
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/NestedComplex.java | jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/NestedComplex.java | package com.sap.olingo.jpa.processor.core.testmodel;
import jakarta.persistence.Column;
import jakarta.persistence.Embedded;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.IdClass;
import jakarta.persistence.Table;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmIgnore;
@EdmIgnore
@Entity
@Table(schema = "\"OLINGO\"", name = "\"NestedComplex\"")
@IdClass(NestedComplexKey.class)
public class NestedComplex {
@EdmIgnore
@Id
@Column(name = "\"ID\"")
private String iD;
@Id
@Column(name = "\"Number\"")
private Long number;
@Embedded
private CollectionInnerComplex inner;
public Long getNumber() {
return number;
}
public void setNumber(final Long number) {
this.number = number;
}
public CollectionInnerComplex getInner() {
return inner;
}
public void setInner(final CollectionInnerComplex inner) {
this.inner = inner;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/ImageLoader.java | jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/ImageLoader.java | package com.sap.olingo.jpa.processor.core.testmodel;
import static org.junit.jupiter.api.Assertions.fail;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URL;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.Persistence;
import jakarta.persistence.Query;
public class ImageLoader {
/**
*
*/
private static final String SELECT_PERSON_IMAGE =
"SELECT * FROM \"OLINGO\".\"PersonImage\" WHERE ID = '$&1'";
private static final String SELECT_ORGANIZATION_IMAGE =
"SELECT * FROM \"OLINGO\".\"OrganizationImage\" WHERE ID = '$&1'";
private static final String PATH = "images/";
private static final String ENTITY_MANAGER_DATA_SOURCE = "jakarta.persistence.nonJtaDataSource";
private static final String PUNIT_NAME = "com.sap.olingo.jpa";
public static void main(final String[] args) throws IOException {
final ImageLoader i = new ImageLoader();
final EntityManager em = createEntityManager();
i.loadPerson(em, "OlingoOrangeTM.png", "99");
}
public void loadPerson(final EntityManager em, final String imageName, final String businessPartnerID)
throws IOException {
final byte[] image = loadImage(imageName);
storePersonImageDB(em, image, businessPartnerID, SELECT_PERSON_IMAGE);
}
public void loadPerson(final String imageName, final String businessPartnerID) throws IOException {
final byte[] image = loadImage(imageName);
storePersonImageDB(createEntityManager(), image, businessPartnerID, SELECT_PERSON_IMAGE);
}
public void loadOrg(final EntityManager em, final String imageName, final String businessPartnerID)
throws IOException {
final byte[] image = loadImage(imageName);
storeOrgImageDB(em, image, businessPartnerID, SELECT_ORGANIZATION_IMAGE);
}
public void loadOrg(final String imageName, final String businessPartnerID) throws IOException {
final byte[] image = loadImage(imageName);
storeOrgImageDB(createEntityManager(), image, businessPartnerID, SELECT_ORGANIZATION_IMAGE);
}
private void storePersonImageDB(final EntityManager em, final byte[] image, final String businessPartnerID,
final String query) {
final String s = query.replace("$&1", businessPartnerID);
final Query q = em.createNativeQuery(s, PersonImage.class);
@SuppressWarnings("unchecked")
final List<PersonImage> result = q.getResultList();
result.get(0).setImage(image);
updateDB(em, result);
final Query storedImageQ = em.createNativeQuery(s, PersonImage.class);
@SuppressWarnings("unchecked")
final List<PersonImage> result2 = storedImageQ.getResultList();
final byte[] storedImage = result2.get(0).getImage();
compareImage(image, storedImage);
}
private void storeOrgImageDB(final EntityManager em, final byte[] image, final String businessPartnerID,
final String query) {
final String s = query.replace("$&1", businessPartnerID);
final Query q = em.createNativeQuery(s, OrganizationImage.class);
@SuppressWarnings("unchecked")
final List<OrganizationImage> result = q.getResultList();
result.get(0).setImage(image);
updateDB(em, result);
final Query storedImageQ = em.createNativeQuery(s, OrganizationImage.class);
@SuppressWarnings("unchecked")
final List<OrganizationImage> result2 = storedImageQ.getResultList();
final byte[] storedImage = result2.get(0).getImage();
compareImage(image, storedImage);
}
private void updateDB(final EntityManager em, final List<?> result) {
em.getTransaction().begin();
em.persist(result.get(0));
em.getTransaction().commit();
}
private static EntityManager createEntityManager() {
final Map<String, Object> properties = new HashMap<>();
properties.put(ENTITY_MANAGER_DATA_SOURCE, DataSourceHelper.createDataSource(DataSourceHelper.DB_H2));
try (EntityManagerFactory emf = Persistence.createEntityManagerFactory(PUNIT_NAME, properties)) {
return emf.createEntityManager();
}
}
private void compareImage(final byte[] image, final byte[] storedImage) {
if (image.length != storedImage.length)
fail("[Image]: length miss match");
else {
for (int i = 0; i < image.length; i++) {
if (image[i] != storedImage[i]) {
fail("[Image]: mismatch at" + Integer.toString(i));
break;
}
}
}
}
public void storeImageLocal(final byte[] storedImage, final String fileName) throws IOException {
final String home = System.getProperty("user.home");
final String filePath = home + "\\Downloads\\" + fileName;
try (final OutputStream o = new FileOutputStream(filePath)) {
o.write(storedImage);
o.flush();
}
}
private byte[] loadImage(final String imageName) throws IOException {
final String path = PATH + imageName;
byte[] image = null;
final URL u = this.getClass().getClassLoader().getResource(path);
try (final InputStream i = u.openStream()) {
image = new byte[i.available()];
final int noBytes = i.read(image);
if (noBytes == -1)
return new byte[] {};
return image;
}
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/DummyEmbeddedToIgnore.java | jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/DummyEmbeddedToIgnore.java | package com.sap.olingo.jpa.processor.core.testmodel;
import java.sql.Blob;
import java.sql.Clob;
import jakarta.persistence.Basic;
import jakarta.persistence.Column;
import jakarta.persistence.Embeddable;
import jakarta.persistence.FetchType;
import jakarta.persistence.Lob;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmIgnore;
@EdmIgnore
@Embeddable
public class DummyEmbeddedToIgnore {
@Lob
@Column(name = "\"Command\"")
@Basic(fetch = FetchType.LAZY)
private Clob command;
@Lob
@Column(name = "\"LargeBytes\"")
@Basic(fetch = FetchType.LAZY)
private Blob largeBytes;
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/InhouseAddressWithProtection.java | jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/InhouseAddressWithProtection.java | package com.sap.olingo.jpa.processor.core.testmodel;
import jakarta.persistence.Column;
import jakarta.persistence.Embeddable;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmProtectedBy;
@Embeddable
public class InhouseAddressWithProtection {
@Column(name = "\"Task\"", length = 32, nullable = false) // Workaround olingo problem
private String taskID;
@Column(name = "\"Building\"", length = 10)
@EdmProtectedBy(name = "BuildingNumber")
private String building;
@Column(name = "\"Floor\"")
private Short floor;
@Column(name = "\"RoomNumber\"")
private Integer roomNumber;
public InhouseAddressWithProtection() {
// Needed by JPA
}
public InhouseAddressWithProtection(final String taskID, final String building) {
this.setTaskID(taskID);
this.setBuilding(building);
}
public String getBuilding() {
return building;
}
public void setBuilding(final String building) {
this.building = building;
}
public Short getFloor() {
return floor;
}
public void setFloor(final Short floor) {
this.floor = floor;
}
public Integer getRoomNumber() {
return roomNumber;
}
public void setRoomNumber(final Integer roomNumber) {
this.roomNumber = roomNumber;
}
public String getTaskID() {
return taskID;
}
public void setTaskID(final String taskID) {
this.taskID = taskID;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/LocaleEnumeration.java | jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/LocaleEnumeration.java | package com.sap.olingo.jpa.processor.core.testmodel;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
public class LocaleEnumeration implements Enumeration<Locale> { // NOSONAR
private final Iterator<Locale> keys;
public LocaleEnumeration(final List<Locale> keySet) {
keys = keySet.iterator();
}
@Override
public boolean hasMoreElements() {
return keys.hasNext();
}
@Override
public Locale nextElement() {
return keys.next();
}
} | java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/JoinSource.java | jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/JoinSource.java | package com.sap.olingo.jpa.processor.core.testmodel;
import java.util.List;
import jakarta.persistence.Column;
import jakarta.persistence.Embedded;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.JoinTable;
import jakarta.persistence.OneToMany;
import jakarta.persistence.Table;
@Entity(name = "JoinSource")
@Table(schema = "\"OLINGO\"", name = "\"JoinSource\"")
public class JoinSource {
@Id
@Column(name = "\"SourceKey\"")
private Integer sourceID;
@OneToMany
@JoinTable(name = "\"JoinRelation\"", schema = "\"OLINGO\"",
joinColumns = @JoinColumn(name = "\"SourceID\""),
inverseJoinColumns = @JoinColumn(name = "\"TargetID\""))
private List<JoinTarget> oneToMany;
@OneToMany
@JoinTable(name = "\"JoinHiddenRelation\"", schema = "\"OLINGO\"",
joinColumns = @JoinColumn(name = "\"SourceID\""),
inverseJoinColumns = @JoinColumn(name = "\"TargetID\""))
private List<JoinTarget> oneToManyHidden;
@Embedded
private JoinComplex complex;
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/CurrentUser.java | jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/CurrentUser.java | package com.sap.olingo.jpa.processor.core.testmodel;
import jakarta.persistence.DiscriminatorValue;
import jakarta.persistence.Entity;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmEntityType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmTopLevelElementRepresentation;
//Problem with multi-level inheritance hierarchy Inheritance Type SINGLE_TABLE. Therefore inherit also from
//Business Partner
@Entity(name = "CurrentUser")
@DiscriminatorValue(value = "1")
@EdmEntityType(as = EdmTopLevelElementRepresentation.AS_SINGLETON_ONLY,
extensionProvider = CurrentUserQueryExtension.class)
public class CurrentUser extends Person {}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/AdministrativeDivisionDescription.java | jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/AdministrativeDivisionDescription.java | package com.sap.olingo.jpa.processor.core.testmodel;
import jakarta.persistence.Column;
import jakarta.persistence.EmbeddedId;
import jakarta.persistence.Entity;
import jakarta.persistence.Table;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmSearchable;
@Entity
@Table(schema = "\"OLINGO\"", name = "\"AdministrativeDivisionDescription\"")
public class AdministrativeDivisionDescription implements KeyAccess {
@EmbeddedId
private AdministrativeDivisionDescriptionKey key;
@EdmSearchable
@Column(name = "\"Name\"", length = 100, updatable = false)
private String name;
public String getName() {
return name;
}
public void setName(final String name) {
this.name = name;
}
@Override
public AdministrativeDivisionDescriptionKey getKey() {
return key;
}
public void setKey(final AdministrativeDivisionDescriptionKey key) {
this.key = key;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/CollectionInnerComplex.java | jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/CollectionInnerComplex.java | package com.sap.olingo.jpa.processor.core.testmodel;
import java.math.BigInteger;
import java.time.Instant;
import jakarta.persistence.Column;
import jakarta.persistence.Convert;
import jakarta.persistence.Embeddable;
import com.sap.olingo.jpa.metadata.converter.TimeInstantLongConverter;
@Embeddable
public class CollectionInnerComplex {
@Column(name = "\"Figure1\"")
private Long figure1;
@Column(name = "\"Figure2\"")
@Convert(converter = TimeInstantLongConverter.class)
private Instant figure2;
@Column(name = "\"Figure3\"")
private BigInteger figure3;
public Long getFigure1() {
return figure1;
}
public void setFigure1(final Long figure1) {
this.figure1 = figure1;
}
public Instant getFigure2() {
return figure2;
}
public void setFigure2(final Instant figure2) {
this.figure2 = figure2;
}
public BigInteger getFigure3() {
return figure3;
}
public void setFigure3(final BigInteger figure3) {
this.figure3 = figure3;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/ComplexBaseType.java | jpa/odata-jpa-test/src/main/java/com/sap/olingo/jpa/processor/core/testmodel/ComplexBaseType.java | package com.sap.olingo.jpa.processor.core.testmodel;
import jakarta.persistence.Column;
import jakarta.persistence.Embeddable;
@Embeddable
public class ComplexBaseType {
@Column
private String oneAttribute;
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/test/java/com/sap/olingo/jpa/metadata/converter/OffsetDateTimeConverterTest.java | jpa/odata-jpa-annotation/src/test/java/com/sap/olingo/jpa/metadata/converter/OffsetDateTimeConverterTest.java | /**
*
*/
package com.sap.olingo.jpa.metadata.converter;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import java.time.OffsetDateTime;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
/**
* @author Oliver Grande
* @since 1.0.7
* 18.01.2022
*/
class OffsetDateTimeConverterTest {
private OffsetDateTimeConverter cut;
@BeforeEach
void setup() {
cut = new OffsetDateTimeConverter();
}
@Test
void testConervertToDBNull() {
assertNull(cut.convertToDatabaseColumn(null));
}
@Test
void testConervertToDB() {
final ZonedDateTime zdt = ZonedDateTime
.of(1972, 12, 6, 12, 17, 7, 0, ZoneId.of(ZoneId.SHORT_IDS.get("HST")));
final OffsetDateTime act = cut.convertToDatabaseColumn(zdt);
assertEquals(1972, act.getYear());
assertEquals(-10 * 3600, act.getOffset().getTotalSeconds());
}
@Test
void testConervertToEntityNull() {
assertNull(cut.convertToEntityAttribute(null));
}
@Test
void testConervertToEntity() {
final OffsetDateTime odt = OffsetDateTime
.of(1972, 12, 6, 12, 17, 7, 0, ZoneOffset.ofHours(-10));
final ZonedDateTime act = cut.convertToEntityAttribute(odt);
assertEquals(1972, act.getYear());
assertEquals("-10:00", act.getZone().getId());
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/test/java/com/sap/olingo/jpa/metadata/converter/TimeInstantLongConverterTest.java | jpa/odata-jpa-annotation/src/test/java/com/sap/olingo/jpa/metadata/converter/TimeInstantLongConverterTest.java | /**
*
*/
package com.sap.olingo.jpa.metadata.converter;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import java.time.Instant;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
/**
* @author Oliver Grande
* @since 1.0.9
* 18.01.2022
*/
class TimeInstantLongConverterTest {
private static final long EPOCH_MILLIS = 1000000;
private TimeInstantLongConverter cut;
@BeforeEach
void setup() {
cut = new TimeInstantLongConverter();
}
@Test
void testConervertToDBNull() {
assertNull(cut.convertToDatabaseColumn(null));
}
@Test
void testConervertToDB() {
final Instant inst = Instant.ofEpochMilli(EPOCH_MILLIS);
final Number act = cut.convertToDatabaseColumn(inst);
assertEquals(EPOCH_MILLIS, act);
}
@Test
void testConervertToEntityNull() {
assertNull(cut.convertToEntityAttribute(null));
}
@Test
void testConervertToEntity() {
final Instant act = cut.convertToEntityAttribute(EPOCH_MILLIS);
assertEquals(EPOCH_MILLIS / 1000, act.getEpochSecond());
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/test/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmTransientPropertyCalculatorTest.java | jpa/odata-jpa-annotation/src/test/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmTransientPropertyCalculatorTest.java | /**
*
*/
package com.sap.olingo.jpa.metadata.core.edm.annotation;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import jakarta.persistence.Tuple;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
/**
* @author Oliver Grande
* @since 1.0.9
* 18.01.2022
*/
class EdmTransientPropertyCalculatorTest {
private EdmTransientPropertyCalculator<String> cut;
private Tuple tuple;
@BeforeEach
void setup() {
cut = new calculatorImpl();
tuple = mock(Tuple.class);
}
@Test
void testDefaultCalculatePropertyReturnsNull() {
assertNull(cut.calculateProperty(tuple));
}
@Test
void testDefaultCalculateCollectionPropertyReturnsEmptyList() {
assertNotNull(cut.calculateCollectionProperty(tuple));
assertTrue(cut.calculateCollectionProperty(tuple).isEmpty());
}
static class calculatorImpl implements EdmTransientPropertyCalculator<String> {}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/test/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmEnumerationTest.java | jpa/odata-jpa-annotation/src/test/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmEnumerationTest.java | /**
*
*/
package com.sap.olingo.jpa.metadata.core.edm.annotation;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import jakarta.persistence.AttributeConverter;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
/**
* @author Oliver Grande
* @since 1.0.9
* 18.01.2022
*/
class EdmEnumerationTest {
private AttributeConverter<Enum<?>[], Integer> cut;
@BeforeEach
void setup() {
cut = new EdmEnumeration.DummyConverter();
}
@Test
void testConvertToDatabaseColumnReturnsNull() {
final EdmTopLevelElementRepresentation[] data = {};
assertNull(cut.convertToDatabaseColumn(data));
}
@Test
void testConvertToDatabaseColumnReturnsOrdinal() {
final EdmFunctionType[] data = { EdmFunctionType.JavaClass };
assertEquals(1, cut.convertToDatabaseColumn(data));
}
@Test
void testConvertToDatabaseColumnReturnsOrdinalOfFirst() {
final EdmTopLevelElementRepresentation[] data = { EdmTopLevelElementRepresentation.AS_SINGLETON,
EdmTopLevelElementRepresentation.AS_ENTITY_SET };
assertEquals(3, cut.convertToDatabaseColumn(data));
}
@Test
void testConvertToDatabaseColumnReturnsNullOnEmpty() {
assertNull(cut.convertToDatabaseColumn(null));
}
@Test
void testConvertToEntityAttributeReturnsFirst() {
assertNull(cut.convertToEntityAttribute(10));
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/odata/v4/core/annotation/Immutable.java | jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/odata/v4/core/annotation/Immutable.java | package com.sap.olingo.jpa.metadata.odata.v4.core.annotation;
import static java.lang.annotation.ElementType.FIELD;
import java.lang.annotation.Target;
/**
* OData core annotation <i>Immutable</i> <br>
* A value for this non-key property can be provided on insert and remains unchanged on update
* @author Oliver Grande
*
*/
@Target(FIELD)
public @interface Immutable {
boolean value() default true;
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/converter/TimeInstantLongConverter.java | jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/converter/TimeInstantLongConverter.java | package com.sap.olingo.jpa.metadata.converter;
import java.time.Instant;
import jakarta.persistence.AttributeConverter;
import jakarta.persistence.Converter;
/**
* Default converter to convert from {@link Long} to {@link java.time.Instant}.
*
* @author Oliver Grande
* @since 1.0.0-RC
*/
@Converter(autoApply = false)
public class TimeInstantLongConverter implements AttributeConverter<Instant, Number> {
@Override
public Number convertToDatabaseColumn(final Instant instant) {
return instant == null ? null : instant.toEpochMilli();
}
@Override
public Instant convertToEntityAttribute(final Number epochMillis) {
return epochMillis == null ? null : Instant.ofEpochMilli(epochMillis.longValue());
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/converter/OffsetDateTimeConverter.java | jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/converter/OffsetDateTimeConverter.java | package com.sap.olingo.jpa.metadata.converter;
import java.time.OffsetDateTime;
import java.time.ZonedDateTime;
import jakarta.persistence.AttributeConverter;
import jakarta.persistence.Converter;
/**
* Default converter to convert from {@link java.time.OffsetDateTime} to {@link java.time.ZonedDateTime}. This is
* required, as Olingo 4.7.1 only supports ZonedDateTime, where as JPA 2.2 supports OffsetDateTime.
* @author Oliver Grande
* @since 09.03.2020
*
*/
@Converter(autoApply = false)
public class OffsetDateTimeConverter implements AttributeConverter<ZonedDateTime, OffsetDateTime> {
@Override
public OffsetDateTime convertToDatabaseColumn(final ZonedDateTime zonedDateTime) {
return zonedDateTime == null ? null : zonedDateTime.toOffsetDateTime();
}
@Override
public ZonedDateTime convertToEntityAttribute(final OffsetDateTime dateTimeWithOffset) {
return dateTimeWithOffset == null ? null : dateTimeWithOffset.toZonedDateTime();
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmDescriptionAssociation.java | jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmDescriptionAssociation.java | package com.sap.olingo.jpa.metadata.core.edm.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Marks an association to an entity that contains a language/locale dependent description of a coded value. E.g the
* Association to a country name for an attribute containing the country iso code.<p>
* The association shall be annotated as OneToOne or OneToMany (as the key is not completely given), insertable = false
* and updatable = false. It is mapped to a property with the name of the association<p>
* One and only one of the fields of LanguageAttribute - LocaleAttribute has to be filled. To ensure that, in case
* multiple descriptions are available, the right one the chosen the Description Attribute has to be named<p>
* @author Oliver Grande
*
*/
@Target({ ElementType.FIELD })
@Retention(value = RetentionPolicy.RUNTIME)
@Inherited
public @interface EdmDescriptionAssociation {
String descriptionAttribute();
String languageAttribute() default "";
String localeAttribute() default "";
@interface valueAssignment {
String attribute() default "";
String value() default "";
}
valueAssignment[] valueAssignments() default {};
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmGeospatial.java | jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmGeospatial.java | package com.sap.olingo.jpa.metadata.core.edm.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.apache.olingo.commons.api.edm.geo.Geospatial.Dimension;
import org.apache.olingo.commons.api.edm.geo.SRID;
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.PARAMETER, ElementType.ANNOTATION_TYPE, ElementType.FIELD })
public @interface EdmGeospatial {
/**
* Olingo Geospatial dimension. Possible Values are GEOMETRY and GEOGRAPHY.
* @return
*/
Dimension dimension() default Dimension.GEOGRAPHY;
/**
* Non negative integer value of the Spatial Reference System Identifier (SRID). Value range is described in
* {@link SRID} are taken.<br>
* If no value is set than the EdmGeospatial is ignored within function parameter.
* @return
*/
String srid() default "";
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmProtections.java | jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmProtections.java | package com.sap.olingo.jpa.metadata.core.edm.annotation;
import static java.lang.annotation.ElementType.FIELD;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Allows to combine either multiple claims for a simple attribute, which will be combined with AND,
* or to be able to protect multiple attributes at a complex attribute.
* @author Oliver Grande
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(FIELD)
public @interface EdmProtections {
public abstract EdmProtectedBy[] value();
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmTransient.java | jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmTransient.java | /**
*
*/
package com.sap.olingo.jpa.metadata.core.edm.annotation;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
/**
* The annotation marks attributes that are transient, but shall be part of the Edm.<br>
* Please note that the attribute needs the corresponding JPA annotation {@link Transient} as well.
* @author Oliver Grande
* Created: 25.11.2019
*/
@Target({ FIELD })
@Retention(value = RUNTIME)
public @interface EdmTransient {
/**
* Optional: An array of path to attributes that need to be present to build the annotated one. In case the path
* is composed, path segments joined together by forward slashes (/) e.g <i>address/cityName</i>.
* </p>
* The correctness
* of the path is check when the entity type is build.
*/
String[] requiredAttributes() default {};
/**
* A calculator is an implementation of {@link EdmTransientPropertyCalculator}. It provides the transient property or
* property collection.
* @return
*/
Class<? extends EdmTransientPropertyCalculator<?>> calculator(); // NOSONAR
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmMediaStream.java | jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmMediaStream.java | package com.sap.olingo.jpa.metadata.core.edm.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Marks an attribute as one that is a data stream. Two options are given to describe the content. Either static as
* string (contentType) or dynamically in another attribute (contentTypeAttribute). Exactly on has to be given.
* @author Oliver Grande
*
*/
@Target({ ElementType.FIELD })
@Retention(value = RetentionPolicy.RUNTIME)
public @interface EdmMediaStream {
boolean stream() default true;
String contentType() default "";
String contentTypeAttribute() default "";
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmFunctionType.java | jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmFunctionType.java | package com.sap.olingo.jpa.metadata.core.edm.annotation;
public enum EdmFunctionType {
UserDefinedFunction, // NOSONAR
JavaClass // NOSONAR
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmAlias.java | jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmAlias.java | package com.sap.olingo.jpa.metadata.core.edm.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* @author Oliver Grande
*
*/
@Target({ ElementType.TYPE, ElementType.FIELD })
@Retention(value = RetentionPolicy.RUNTIME)
@Inherited
public @interface EdmAlias {
String name();
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmQueryExtensionProvider.java | jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmQueryExtensionProvider.java | /**
*
*/
package com.sap.olingo.jpa.metadata.core.edm.annotation;
import javax.annotation.CheckForNull;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.Expression;
import jakarta.persistence.criteria.From;
/**
* Provides a set to methods to extend or influence the generated query.
* <p>
*
* An instance of the extension provider is created once per OData request. That is, it could be created multiple times
* per http request in case of $batch requests.
* <p>
* An implementing class may provide <b>one</b> constructor having no parameter or a combination of the following:
* <ul>
* <li>All header: com.sap.olingo.jpa.metadata.api.JPAHttpHeaderMap</li></li>
* <li>Access to own request parameter: com.sap.olingo.jpa.metadata.api.JPARequestParameterMap</li>
* </ul>
*
* <b>
* This currently under construction. Method interfaces may change incompatible in the upcoming releases.
* </b>
* @author Oliver Grande
* @since 1.0.3
* 10.10.2021
*/
public interface EdmQueryExtensionProvider {
/**
* Provide an additional WHERE condition. This condition will be concatenated using AND
*/
@CheckForNull
Expression<Boolean> getFilterExtension(final CriteriaBuilder cb, final From<?, ?> from);
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmFunction.java | jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmFunction.java | package com.sap.olingo.jpa.metadata.core.edm.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Metadata of a function, see <a href =
* "http://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/part3-csdl/odata-v4.0-errata02-os-part3-csdl-complete.html#_Toc406398010">
* edm:Function.</a>
* <p>
* @author Oliver Grande
*
*/
@Repeatable(EdmFunctions.class)
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.TYPE, ElementType.METHOD })
public @interface EdmFunction {
/**
* Define if the return type for the function. It can be a collection (entity set) or
* an single entity (entity).
*
*/
@interface ReturnType {
/**
* @return <code>true</code> if a collection is returned,
* otherwise <code>false</code> if a single entity is returned.
*/
boolean isCollection() default false;
// facets
boolean isNullable() default true;
int maxLength() default -1;
int precision() default -1;
int scale() default -1;
EdmGeospatial srid() default @EdmGeospatial();
/**
* Define the return type for the function import.
* <p>
*
* @return Class of java parameter (row) type. This can be either a simple type like <code> Integer.class</code> or
* the POJO defining an Entity. If the type is not set and the
* function is defined at an JPA Entity POJO, the corresponding Entity Type is used. In addition, in case of an
* unbound function, no out-bound parameter is set.
*/
Class<?> type() default Object.class;
}
/**
* Defines the name of the function in the service document. This is a required attribute for database based functions
* and can be omitted for java based functions.
* @return
*/
String name() default "";
EdmParameter[] parameter() default {};
/**
* Defines the name of a User Defined Function on the database
* @return
*/
String functionName() default "";
/**
* Indicates that the Function is bound.
* <p>
* If isBound is false a function is treated as <i>unbound</i>, so it can be accessed either via a Function Import or
* be used in <i>filter</i> or <i>orderby</i> expression. Otherwise the function is treated as bound.
* For details see:
* <a href =
* "http://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/part3-csdl/odata-v4.0-errata02-os-part3-csdl-complete.html#_Toc406398013"
* />OData Version 4.0 Part 3 - 12.2.2 Attribute IsBound</a>
* <p>
* <b>If the function is java based isBound is ignored and always set to false</b>
* @return
*/
boolean isBound() default true;
/**
* Indicates that a Function Import shall be generated into the Container. For details see:
* <a href =
* "http://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/part3-csdl/odata-v4.0-errata02-os-part3-csdl-complete.html#_Toc406398042"
* />OData Version 4.0 Part 3 - 13.6 Element edm:FunctionImport</a>
* <p>
* hasFunctionImport is handled as follows:
* <p>
* <ol>
* <li>For <b>bound</b> functions hasFunctionImport is always treated as <b>false</b></li>
* <li>For <b>unbound</b> functions in case hasFunctionImport is <b>true</b> a function import is generated, which
* allows to be call a function from the container
* </ol>
* <b>If the function is java based hasFunctionImport is ignored and always set to true</b>
* @return
*/
boolean hasFunctionImport() default false;
/**
* Bound functions that return an entity or a collection of entities MAY specify a value for the EntitySetPath
* attribute if determination of the entity set for the return type is contingent on the binding parameter.
* <p>
* The value for the EntitySetPath attribute consists of a series of segments joined together with forward slashes.
* <p>
* The first segment of the entity set path MUST be the name of the binding parameter. The remaining segments of the
* entity set path MUST represent navigation segments or type casts.
* <p>
* <a href =
* "http://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/part3-csdl/odata-v4.0-errata02-os-part3-csdl-complete.html#_Toc406398015"
* />OData Version 4.0 Part 3 - 13.6 Element edm:FunctionImport</a>
* <p>
*
*/
String entitySetPath() default "";
/**
* Define the return type of this function
*
* @return return type of this function
*/
ReturnType returnType();
/**
* Restrict the access to the function to the give user groups. Default is unrestricted access.
*/
EdmVisibleFor visibleFor() default @EdmVisibleFor;
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmAnnotation.java | jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmAnnotation.java | package com.sap.olingo.jpa.metadata.core.edm.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.apache.olingo.commons.api.edm.provider.annotation.CsdlConstantExpression.ConstantExpressionType;
/**
* Can be used to annotate attributes. The annotations are converted into OData annotations.
* For details see
* <a href=
* "http://docs.oasis-open.org/odata/odata/v4.0/errata03/os/complete/part3-csdl/odata-v4.0-errata03-os-part3-csdl-complete.html#_Toc453752630"
* >OData Version 4.0 Part 3 - 14.3 Element edm:Annotation</a>
*
* @author Oliver Grande
*
*/
@Target({ ElementType.TYPE, ElementType.FIELD })
@Retention(value = RetentionPolicy.RUNTIME)
public @interface EdmAnnotation {
/**
* Full qualified name of term, e.g. Core.MediaType
*/
String term();
/**
* An annotation element MAY provide a SimpleIdentifier value for the Qualifier attribute.
* The qualifier attribute allows annotation authors a means of conditionally applying an annotation.
*/
String qualifier() default "";
ConstantExpression constantExpression() default @ConstantExpression(type = ConstantExpressionType.Int,
value = "default");
DynamicExpression dynamicExpression() default @DynamicExpression();
@interface ConstantExpression {
ConstantExpressionType type();
String value() default "";
}
@interface DynamicExpression {
String path() default "";
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmParameter.java | jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmParameter.java | package com.sap.olingo.jpa.metadata.core.edm.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.PARAMETER, ElementType.ANNOTATION_TYPE })
public @interface EdmParameter {
boolean isCollection() default false;
// facets
boolean isNullable() default true;
int maxLength() default -1;
/**
* Mandatory name of the parameter. The name
* may adopt by the name builder to fulfill naming conventions.
* <br>
* There is no fallback for JAVA based functions and actions.
* @return
*/
String name();
/**
* Defines the name of the input parameter at a user defined function. Not supported for actions.
* @return Parameter name
*/
String parameterName() default "";
int precision() default -1;
int scale() default -1;
EdmGeospatial srid() default @EdmGeospatial();
/**
* Define the parameter type in case of user defined function.
* <p>
*
* @return Class of java parameter (row) type. This can be either a simple type like <code> Integer.class</code> or
* the POJO defining an Entity.
*/
Class<?> type() default Object.class;
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmProtectedBy.java | jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmProtectedBy.java | package com.sap.olingo.jpa.metadata.core.edm.annotation;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
/**
* Describes which authorization claim shall be used to filter the annotated attribute. In case multiple attributes of
* an entity are annotated they are connected via an AND operation. This annotation is respected also if the attribute
* is marked to be ignored.
* @author Oliver Grande
*
*/
@Repeatable(EdmProtections.class)
@Retention(RUNTIME)
@Target(FIELD)
public @interface EdmProtectedBy {
/**
* Name of the authorization claim
* @return
*/
String name();
/**
* Optional: At embedded attributes the path to the attribute that shall be protected by the claim. In case the path
* is composed, path segments joined together by forward slashes (/).</p> The correctness of the pass is check late
* during request processing.
* @return
*/
String path() default "";
/**
* Optional: In case the protected attributes is of type string also wildcards are supported. '*' and '%' representing
* zero or more characters and '+' as well as '_' for a single character.
*/
boolean wildcardSupported() default true;
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmIgnore.java | jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmIgnore.java | /**
*
*/
package com.sap.olingo.jpa.metadata.core.edm.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* @author Oliver Grande
*
*/
@Target({ ElementType.TYPE, ElementType.FIELD })
@Retention(value = RetentionPolicy.RUNTIME)
public @interface EdmIgnore {
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmEntityType.java | jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmEntityType.java | /**
*
*/
package com.sap.olingo.jpa.metadata.core.edm.annotation;
import static com.sap.olingo.jpa.metadata.core.edm.annotation.EdmTopLevelElementRepresentation.AS_ENTITY_SET;
import static java.lang.annotation.ElementType.TYPE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
/**
* Describes the characteristics of the generated OData artifact of the annotated type. In case this annotation is
* missing, it is assumed that the type represents an Entity Set.
* @author Oliver Grande
* @since 26.04.2021
*
*/
@Retention(RUNTIME)
@Target(TYPE)
public @interface EdmEntityType {
/**
* Indicates what the type represents. This could be an Entity Set, an Entity Type or a (nullable) Singleton.
*/
EdmTopLevelElementRepresentation as() default AS_ENTITY_SET;
/**
* Query Extension Provider provides a set to methods to extend or influence the generated query. This may be from
* interest in case a subset of records shall be represented by an Entity Set or Singleton and it is not possible to
* use a database view.
* <p>
*
* Query Extension Provider are inherited. One that is given at a sub type overrides one that is given at the super
* type or base type.
*/
Class<? extends EdmQueryExtensionProvider> extensionProvider() default EdmQueryExtensionProvider.class;
EdmVisibleFor visibleFor() default @EdmVisibleFor;
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmEnumeration.java | jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmEnumeration.java | package com.sap.olingo.jpa.metadata.core.edm.annotation;
import static java.lang.annotation.ElementType.TYPE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import jakarta.persistence.AttributeConverter;
import jakarta.persistence.Enumerated;
/**
* Annotation to tag Java enumerations that shall be provided via an OData service. For details about OData Enumerations
* see: <a
* href=
* "http://docs.oasis-open.org/odata/odata/v4.0/errata03/os/complete/part3-csdl/odata-v4.0-errata03-os-part3-csdl-complete.html#_Toc453752565">10
* Enumeration Type</a>.
* The following conversion rule have been established:
* <ul>
* <li>Name is taken from the enumeration name</li>
* <li>UnderlyingType is derived from the converter, if no converter is provided Edm.Int32 is taken and a
* field in an entity pojo needed to be annotated with <code>@Enumerated</code>.</li>
* <li>Member</li>
* <ul>
* <li>Name is the name of a constant</li>
* <li>Value is determined via the converter, if no converter is provided the value is determined via the method
* ordinal</li>
* </ul>
* </ul>
* @author Oliver Grande
*
*/
@Retention(RUNTIME)
@Target(TYPE)
public @interface EdmEnumeration {
/**
* Converter to convert enumeration value into a number. If no converter is provided, the ordinal is taken.
*/
Class<? extends AttributeConverter<? extends Enum<?>[], ? extends Number>> converter() default DummyConverter.class; // NOSONAR
boolean isFlags() default false;
/**
* Converter shall be optional, as java does not support <code>default null</code> a
* dummy converter implementation is needed.
*/
static class DummyConverter implements AttributeConverter<Enum<?>[], Integer> {
@Override
public Integer convertToDatabaseColumn(final Enum<?>[] attributes) {
if (attributes == null || attributes.length == 0)
return null;
return attributes[0].ordinal();
}
@Enumerated
@Override
public Enum<?>[] convertToEntityAttribute(final Integer dbData) {
return null; // NOSONAR
}
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmVisibleFor.java | jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmVisibleFor.java | package com.sap.olingo.jpa.metadata.core.edm.annotation;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
/**
* The annotation can be used to assign on the one hand attributes or properties and n the other hand entities to user
* or visibility groups.
* <ul>
* <li>In case an entity is annotated, the entity and navigation targeting the entity are only visible and accessible if
* one of the given groups are available.</li>
* <li>In case an attribute is annotated and such a group is provided during a GET request all properties that are
* assigned to that group and all properties that are assigned to no group, or in other words that are not annotated,
* get selected. For properties that belong to another group are requested, a null value is returned.
* <p>
*
* <b>Note:</b> Keys, mandatory fields as well as association or navigation properties can not be annotated</li>
* </ul>
* @author Oliver Grande
*
*/
@Retention(RUNTIME)
@Target({ FIELD })
public @interface EdmVisibleFor {
/**
* List of user groups an attribute or property or entity belongs to.
* @return
*/
String[] value() default {};
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/ValidatorStrength.java | jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/ValidatorStrength.java | package com.sap.olingo.jpa.metadata.core.edm.annotation;
/**
* Strength of the entity tag (ETag) validator according to
* <a href="https://datatracker.ietf.org/doc/html/rfc7232#section-2.1">RFC 7232 Section-2.1</a><br>
* In case DEFAULT is chosen, in case the attribute marked with {@link jakarta.persistence.Version} is seen as WEAK in
* case it is of type {@link java.sql.Timestamp},
* otherwise as STRONG.
*
* @author Oliver Grande
* @since 24.06.2024
* @version 2.1.3
*/
public enum ValidatorStrength {
DEFAULT,
WEAK,
STRONG;
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmTopLevelElementRepresentation.java | jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmTopLevelElementRepresentation.java | package com.sap.olingo.jpa.metadata.core.edm.annotation;
/**
* @author Oliver Grande
* Created: 01.05.2021
*
*/
public enum EdmTopLevelElementRepresentation {
/**
* Allows to state that a jpa entity is exposed as odata entity type only.
*/
AS_ENTITY_TYPE,
/**
* Allows to state that a jpa entity is exposed not only as odata entity type only, but also as entity set.
*/
AS_ENTITY_SET,
/**
* Allows to mark a jpa entity as an additional entity set of another entity type.
* This is only allowed for leafs in an inheritance hierarchy. The jpa entity must not have own columns<p>
* <a href=
* "https://docs.oasis-open.org/odata/odata/v4.0/errata03/os/complete/part3-csdl/odata-v4.0-errata03-os-part3-csdl-complete.html#_Toc453752596"
* >OData Version 4.0 Part 3 - 13 Entity Container Example 30</a>
*/
AS_ENTITY_SET_ONLY,
/**
* Allows to state that a jpa entity is exposed not only as odata entity type only, but also as singleton.
*/
AS_SINGLETON,
/**
* Allows to mark a jpa entity as an additional singleton of another entity type.
* This is only allowed for leafs in an inheritance hierarchy. The jpa entity must not have own columns<p>
* <a href=
* "https://docs.oasis-open.org/odata/odata/v4.0/errata03/os/complete/part3-csdl/odata-v4.0-errata03-os-part3-csdl-complete.html#_Toc453752596"
* >OData Version 4.0 Part 3 - 13 Entity Container Example 30</a>
*/
AS_SINGLETON_ONLY;
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmFunctions.java | jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmFunctions.java | package com.sap.olingo.jpa.metadata.core.edm.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface EdmFunctions {
public abstract EdmFunction[] value();
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmTransientPropertyCalculator.java | jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmTransientPropertyCalculator.java | /**
*
*/
package com.sap.olingo.jpa.metadata.core.edm.annotation;
import java.util.Collections;
import java.util.List;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import jakarta.persistence.Tuple;
/**
* Transient property converter.
* <p>
* A converter take a row returned from the database and calculates, based on its values, either one additional value or
* a collection of values.<br>
* The converter is mentioned in the {@link EdmTransient} annotation at a POJO attribute. E.g.:
* <p>
* <code>
* {@literal @}EdmTransient(requiredAttributes = { "lastName", "firstName" }, calculator = FullNameCalculator.class)<br>
* {@literal @}Transient<br>
* private String fullName;<br>
* </code>
* <p>
*
* An instance of the converter is created once per OData request. That is, it could be created multiple times per http
* request in case of $batch requests.
* <p>
* An implementing class may provide <b>one</b> constructor having no parameter or a combination of the following:
* <ul>
* <li>An Entity Manager: jakarta.persistence.EntityManager</li>
* <li>All header: com.sap.olingo.jpa.metadata.api.JPAHttpHeaderMap</li>
* <li>Access to own request parameter: com.sap.olingo.jpa.metadata.api.JPARequestParameterMap</li>
* </ul>
* @author Oliver Grande<br>
* Created: 14.03.2020
*
*/
public interface EdmTransientPropertyCalculator<I> {
/**
* This method is called in case the transient property is a primitive, simple property.
* @param row One row read from the database
* @return Calculated value for the property
*/
default @Nullable I calculateProperty(@Nonnull final Tuple row) {
return null;
}
/**
* This method is called in case the transient property is a collection property.
* @param row One row read from the database
* @return List of calculated values for the collection property
*/
default @Nonnull List<I> calculateCollectionProperty(@Nonnull final Tuple row) {
return Collections.emptyList();
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmAction.java | jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmAction.java | package com.sap.olingo.jpa.metadata.core.edm.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction.ReturnType;
/**
* Metadata of an action, see <a href =
* "http://docs.oasis-open.org/odata/odata/v4.0/errata03/os/complete/part3-csdl/odata-v4.0-errata03-os-part3-csdl-complete.html#_Toc453752579">
* edm:Action</a>.
* <p>
* @author Oliver Grande
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.METHOD })
public @interface EdmAction {
/**
* Defines the name of the action. If not given, the Java method name is taken.
* @return
*/
String name() default "";
/**
* Define additional facet information for the return type of an action
*
* @return return type of this action
*/
ReturnType returnType() default @ReturnType();
/**
* Indicates that the action is bound. Default is <b>false</b>.
* <p>
* <b>Unbound</b> actions are invoked through an action import. Bound actions are invoked by appending a segment
* containing
* the qualified action name to a segment of the appropriate binding parameter type within the resource path.
* For details see:
* <a href =
* "http://docs.oasis-open.org/odata/odata/v4.0/errata03/os/complete/part3-csdl/odata-v4.0-errata03-os-part3-csdl-complete.html#_Toc453752581"
* />OData Version 4.0 Part 3 - 12.1.2 Attribute IsBound</a>.
* <p>
* In case the action is <b>bound</b>, the method implementing action needs at least on parameter. The first parameter
* is taken as binding parameter. A bound action can be overloaded. Only the binding parameter shall differ. See also:
* <a href =
* "https://docs.oasis-open.org/odata/odata-csdl-json/v4.01/odata-csdl-json-v4.01.html#_Toc38466442"
* />OData Version 4.01 CSDl JSON - 12.2 Action Overloads</a> and
*
* <a href =
* "https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part1-protocol.html#_Toc31359015"
* />OData Version 4.01 Part 1 - 11.5.5.2 Action Overload Resolution</a>.
* The processor has to create an instance of the corresponding JPA entity and needs to provide the key attributes.
* * The instance is created using {@link com.sap.olingo.jpa.processor.core.processor.JPAInstanceCreator}. The
* requirements are described there. It is not verified if the instance of the bound entity exists.
* <p>
* @return
*/
boolean isBound() default false;
/**
* Bound actions that return an entity or a collection of entities MAY specify a value for the EntitySetPath
* attribute, if determination of the entity set for the return type is contingent on the binding parameter.
* <p>
* See:
* <a href =
* "http://docs.oasis-open.org/odata/odata/v4.0/errata03/os/complete/part3-csdl/odata-v4.0-errata03-os-part3-csdl-complete.html#_Toc453752582"
* />OData Version 4.0 Part 3 - 12.1.3 Attribute EntitySetPath</a>
* <p>
* @return
*/
String entitySetPath() default "";
/**
* Restrict the access to the action to the give user groups. Default is unrestricted access.
*/
EdmVisibleFor visibleFor() default @EdmVisibleFor;
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmSearchable.java | jpa/odata-jpa-annotation/src/main/java/com/sap/olingo/jpa/metadata/core/edm/annotation/EdmSearchable.java | package com.sap.olingo.jpa.metadata.core.edm.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Marks an attribute as searchable
* @author Oliver Grande
*
*/
@Target({ ElementType.FIELD })
@Retention(value = RetentionPolicy.RUNTIME)
public @interface EdmSearchable {
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/ArchitectureTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/ArchitectureTest.java | package com.sap.olingo.jpa.processor.cb;
import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes;
import static com.tngtech.archunit.library.Architectures.layeredArchitecture;
import com.tngtech.archunit.junit.AnalyzeClasses;
import com.tngtech.archunit.junit.ArchTest;
import com.tngtech.archunit.lang.ArchRule;
@AnalyzeClasses(packages = "com.sap.olingo.jpa.processor.cb")
class ArchitectureTest { // NOSONAR
@ArchTest
static final ArchRule visibilityRule = classes()
.that()
.resideInAPackage("..impl..")
.should()
.notBePublic()
.orShould()
.haveNameMatching(
"com.sap.olingo.jpa.processor.cb.impl.EntityManagerWrapper");
@ArchTest
static final ArchRule layerRule = layeredArchitecture()
.consideringAllDependencies()
.layer("Api").definedBy("..api..")
.layer("Implementation").definedBy("..impl..")
.layer("Reuse").definedBy("..joiner..", "..exceptions..")
.whereLayer("Api").mayNotBeAccessedByAnyLayer()
.whereLayer("Implementation").mayOnlyBeAccessedByLayers("Api")
.whereLayer("Reuse").mayOnlyBeAccessedByLayers("Implementation");
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/joiner/ExpressionJoinerTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/joiner/ExpressionJoinerTest.java | package com.sap.olingo.jpa.processor.cb.joiner;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.Expression;
import jakarta.persistence.criteria.Predicate;
import jakarta.persistence.criteria.Predicate.BooleanOperator;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
class ExpressionJoinerTest {
private CriteriaBuilder cb;
private ExpressionJoiner cut;
private Expression<Boolean> first;
private Predicate and;
private Predicate or;
@SuppressWarnings("unchecked")
@BeforeEach
void setup() {
cb = mock(CriteriaBuilder.class);
and = mock(Predicate.class);
or = mock(Predicate.class);
when(cb.and(any(), any())).thenReturn(and);
when(cb.or(any(), any())).thenReturn(or);
first = mock(Expression.class);
cut = new ExpressionJoiner(cb, BooleanOperator.AND);
}
@Test
void testMergeReturnsThis() {
assertEquals(cut, cut.merge());
}
@Test
void testAddFirst() {
assertEquals(cut, cut.add(first));
assertEquals(first, cut.finish());
}
@SuppressWarnings("unchecked")
@Test
void testAddTwoWithAnd() {
final Expression<Boolean> second = mock(Expression.class);
cut.add(first);
assertEquals(cut, cut.add(second));
assertEquals(and, cut.finish());
}
@SuppressWarnings("unchecked")
@Test
void testAddTwoWithOr() {
final Expression<Boolean> second = mock(Expression.class);
cut = new ExpressionJoiner(cb, BooleanOperator.OR);
cut.add(first);
assertEquals(cut, cut.add(second));
assertEquals(or, cut.finish());
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/joiner/StringBuilderJoinerTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/joiner/StringBuilderJoinerTest.java | package com.sap.olingo.jpa.processor.cb.joiner;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
class StringBuilderJoinerTest {
private static final String DELIMITER = "//";
private StringBuilderJoiner<SqlConvertible> cut;
private StringBuilder statement;
private SqlConvertible first;
@BeforeEach
void setup() {
statement = new StringBuilder();
cut = new StringBuilderJoiner<>(statement, DELIMITER);
first = mock(SqlConvertible.class);
when(first.asSQL(statement)).thenAnswer(new AsSqlAnswer());
}
@Test
void testMergeReturnsThis() {
assertEquals(cut, cut.merge());
}
@Test
void testFinishReturnsEmptyString() {
assertEquals("", cut.finish());
}
@Test
void testAddFirst() {
assertEquals(cut, cut.add(first));
assertEquals("Test", statement.toString());
}
@Test
void testAddSecond() {
final SqlConvertible second = mock(SqlConvertible.class);
when(second.asSQL(statement)).thenAnswer(new AsSqlAnswer());
assertEquals(cut, cut.add(first));
assertEquals(cut, cut.add(second));
assertEquals("", cut.finish());
assertEquals("Test//Test", statement.toString());
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/joiner/AsSqlAnswer.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/joiner/AsSqlAnswer.java | package com.sap.olingo.jpa.processor.cb.joiner;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
class AsSqlAnswer implements Answer<StringBuilder> {
@Override
public StringBuilder answer(final InvocationOnMock invocation) throws Throwable {
final StringBuilder statement = invocation.getArgument(0);
return statement.append("Test");
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/TypeConverterTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/TypeConverterTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static com.sap.olingo.jpa.processor.cb.impl.TypeConverter.convert;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.params.provider.Arguments.arguments;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import java.time.Duration;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.OffsetDateTime;
import java.time.OffsetTime;
import java.time.ZonedDateTime;
import java.util.TimeZone;
import java.util.stream.Stream;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
class TypeConverterTest {
static Stream<Arguments> numericConversion() {
return Stream.of( // expected; source;target
arguments(Byte.valueOf("65"), "A".getBytes()[0], Byte.class),
arguments(Short.valueOf((short) 5), Byte.valueOf("5"), Short.class),
arguments(Short.valueOf((short) 5), Integer.valueOf(5), Short.class),
arguments(Integer.valueOf(5), Byte.valueOf("5"), Integer.class),
arguments(Integer.valueOf(5), Short.valueOf((short) 5), Integer.class),
arguments(Integer.valueOf(5), Long.valueOf(5), Integer.class),
arguments(Long.valueOf(5), Byte.valueOf("5"), Long.class),
arguments(Long.valueOf(5), Short.valueOf((short) 5), Long.class),
arguments(Long.valueOf(5), Integer.valueOf(5), Long.class),
arguments(Long.valueOf(5), BigInteger.valueOf(5), Long.class),
arguments(Long.valueOf(5), BigDecimal.valueOf(5), Long.class),
arguments(Float.valueOf(5), Byte.valueOf("5"), Float.class),
arguments(Float.valueOf(5), Short.valueOf((short) 5), Float.class),
arguments(Float.valueOf(5), Integer.valueOf(5), Float.class),
arguments(Float.valueOf(5), Long.valueOf(5), Float.class),
arguments(Float.valueOf(10), BigInteger.TEN, Float.class),
arguments(Float.valueOf(10), BigDecimal.TEN, Float.class),
arguments(Double.valueOf(5), Byte.valueOf("5"), Double.class),
arguments(Double.valueOf(5), Short.valueOf((short) 5), Double.class),
arguments(Double.valueOf(5), Integer.valueOf(5), Double.class),
arguments(Double.valueOf(5), Long.valueOf(5), Double.class),
arguments(Double.valueOf(5), Float.valueOf(5), Double.class),
arguments(Double.valueOf(10), BigInteger.TEN, Double.class),
arguments(Double.valueOf(10), BigDecimal.TEN, Double.class),
arguments(BigInteger.TEN, Byte.valueOf("10"), BigInteger.class),
arguments(BigInteger.TEN, Short.valueOf((short) 10), BigInteger.class),
arguments(BigInteger.TEN, Integer.valueOf(10), BigInteger.class),
arguments(BigInteger.TEN, Long.valueOf(10), BigInteger.class),
arguments(BigInteger.TEN, BigDecimal.valueOf(10), BigInteger.class),
arguments(BigDecimal.TEN, Byte.valueOf("10"), BigDecimal.class),
arguments(BigDecimal.TEN, Short.valueOf((short) 10), BigDecimal.class),
arguments(BigDecimal.TEN, Integer.valueOf(10), BigDecimal.class),
arguments(BigDecimal.TEN, Long.valueOf(10), BigDecimal.class),
arguments(BigDecimal.valueOf(10.0), Float.valueOf(10), BigDecimal.class),
arguments(BigDecimal.valueOf(10.0), Double.valueOf(10), BigDecimal.class),
arguments(BigDecimal.TEN, BigInteger.TEN, BigDecimal.class),
arguments(Short.valueOf((short) 10), Byte.valueOf("10"), short.class),
arguments(Integer.valueOf(10), Byte.valueOf("10"), int.class),
arguments(Long.valueOf(5), Byte.valueOf("5"), long.class),
arguments(Float.valueOf(5), Byte.valueOf("5"), float.class),
arguments(Double.valueOf(10), Byte.valueOf("10"), double.class));
}
static Stream<Arguments> numericConversionNotSupported() {
return Stream.of(
arguments(Long.valueOf(5), Short.class),
arguments(Float.valueOf(5), Short.class),
arguments(Double.valueOf(5), Short.class),
arguments(BigInteger.TEN, Short.class),
arguments(BigDecimal.TEN, Short.class),
// arguments(Long.valueOf(5), Integer.class),
arguments(Float.valueOf(5), Integer.class),
arguments(Double.valueOf(5), Integer.class),
arguments(BigInteger.TEN, Integer.class),
arguments(BigDecimal.TEN, Integer.class),
arguments(Float.valueOf(5.3F), Long.class),
arguments(Double.valueOf(5), Long.class),
arguments(Double.valueOf(5), Float.class),
arguments(Float.valueOf(10), BigInteger.class),
arguments(Double.valueOf(10), BigInteger.class));
// arguments(BigDecimal.TEN, BigInteger.class));
}
static Stream<Arguments> infinityValueConversion() {
return Stream.of(
arguments(Double.POSITIVE_INFINITY, BigDecimal.class),
arguments(Double.NEGATIVE_INFINITY, BigDecimal.class),
arguments(Float.POSITIVE_INFINITY, BigDecimal.class),
arguments(Float.NEGATIVE_INFINITY, BigDecimal.class));
}
static Stream<Arguments> nanValueConversion() {
return Stream.of(
arguments(Double.NaN, BigDecimal.class),
arguments(Float.NaN, BigDecimal.class));
}
static Stream<Arguments> booleanConversion() {
return Stream.of(
arguments(Boolean.TRUE, "true"),
arguments(Boolean.TRUE, "TrUe"),
arguments(Boolean.FALSE, "false"),
arguments(Boolean.FALSE, "Test"),
arguments(Boolean.TRUE, 10),
arguments(Boolean.TRUE, 5L),
arguments(Boolean.TRUE, 5L),
arguments(Boolean.TRUE, 5.5F),
arguments(Boolean.FALSE, 0),
arguments(Boolean.FALSE, BigInteger.ZERO));
}
static Stream<Arguments> temporalConversion() {
return Stream.of(
arguments(Instant.parse("2007-12-03T10:15:30.05Z"), Long.valueOf(1196676930050L), Instant.class),
arguments(Instant.parse("2007-12-03T10:15:30.05Z"), "2007-12-03T10:15:30.05Z", Instant.class),
arguments(Instant.parse("2007-12-03T10:15:30.05Z").minusMillis(TimeZone.getDefault().getRawOffset()), Timestamp
.valueOf("2007-12-03 10:15:30.05"), Instant.class),
arguments(LocalDate.parse("2007-12-03"), Date.valueOf("2007-12-03"), LocalDate.class),
arguments(LocalDate.parse("2007-12-03"), Timestamp.valueOf("2007-12-03 00:00:00"), LocalDate.class),
arguments(LocalDate.parse("2007-12-03"), "2007-12-03", LocalDate.class),
// arguments(Instant.parse("2007-12-03T10:15:30.05Z"), "2007-12-03T10:15:30.05Z", Time.class),
arguments(LocalTime.parse("10:15:30"), Time.valueOf("10:15:30"), LocalTime.class),
arguments(LocalTime.parse("10:15:30"), "10:15:30", LocalTime.class),
arguments(LocalDateTime.parse("2007-12-03T10:15:30.05"), Timestamp.valueOf("2007-12-03 10:15:30.05"),
LocalDateTime.class),
arguments(LocalDateTime.parse("2007-12-03T10:15:30.05"), "2007-12-03T10:15:30.05", LocalDateTime.class),
arguments(OffsetTime.parse("10:15:30+01:00"), "10:15:30+01:00", OffsetTime.class),
arguments(OffsetDateTime.parse("2007-12-03T10:15:30+01:00"), "2007-12-03T10:15:30+01:00",
OffsetDateTime.class),
arguments(Timestamp.valueOf("2007-12-03 10:15:30.05"), LocalDateTime.parse("2007-12-03T10:15:30.05"),
Timestamp.class),
arguments(Timestamp.valueOf("2007-12-03 00:00:00"), LocalDate.parse("2007-12-03"),
Timestamp.class),
arguments(Timestamp.valueOf("2007-12-03 10:15:30.05"), "2007-12-03 10:15:30.05", Timestamp.class));
}
static Stream<Arguments> durationConversion() {
return Stream.of(
arguments(Duration.ofHours(3L), Long.valueOf(10800L), Duration.class),
arguments(Duration.ofHours(3L), "PT3H", Duration.class));
}
static Stream<Arguments> temporalConversionNotSupported() {
return Stream.of(
arguments(OffsetDateTime.parse("2007-12-03T10:15:30+01:00"), LocalDateTime.class),
arguments(Integer.valueOf(10), LocalDateTime.class),
arguments("Test", LocalDateTime.class),
arguments(Integer.valueOf(10), LocalTime.class));
}
@Test
void testToString() {
assertEquals("123456789", convert(Integer.valueOf(123456789), String.class));
}
@ParameterizedTest
@MethodSource("numericConversion")
void testConvertNumeric(final Object exp, final Object source, final Class<?> targetType) {
assertEquals(exp, convert(source, targetType));
}
@ParameterizedTest
@MethodSource("numericConversionNotSupported")
void testConvertNumericThrowsExceptionOnUnsupported(final Object source, final Class<?> targetType) {
final IllegalArgumentException act = assertThrows(IllegalArgumentException.class,
() -> convert(source, targetType));
assertTrue(act.getMessage().contains("@Convert required"));
}
@ParameterizedTest
@MethodSource("infinityValueConversion")
void testConvertNumericInfinityValue(final Object source, final Class<?> targetType) {
final IllegalArgumentException act = assertThrows(IllegalArgumentException.class,
() -> convert(source, targetType));
assertTrue(act.getMessage().contains("infinity value"));
}
@ParameterizedTest
@MethodSource("nanValueConversion")
void testConvertNumericNaN(final Object source, final Class<?> targetType) {
final IllegalArgumentException act = assertThrows(IllegalArgumentException.class,
() -> convert(source, targetType));
assertTrue(act.getMessage().contains("'Not A Number'"));
}
@ParameterizedTest
@MethodSource("booleanConversion")
void testConvertBoolean(final Object exp, final Object source) {
assertEquals(exp, convert(source, Boolean.class));
}
@ParameterizedTest
@MethodSource("temporalConversion")
void testConvertTemporal(final Object exp, final Object source, final Class<?> targetType) {
assertEquals(exp, convert(source, targetType));
}
@ParameterizedTest
@MethodSource("durationConversion")
void testConvertDuration(final Object exp, final Object source, final Class<?> targetType) {
assertEquals(exp, convert(source, targetType));
}
@Test
void testConvertNumericThrowsExceptionWrongString() {
assertThrows(IllegalArgumentException.class, () -> convert("Test", Integer.class));
}
@ParameterizedTest
@MethodSource("temporalConversionNotSupported")
void testConvertTemporalThrowsException(final Object source, final Class<?> targetType) {
assertThrows(IllegalArgumentException.class, () -> convert(source, targetType));
}
@Test
void testConvertTemporalThrowsExceptionOnUnsupported() {
final Timestamp timestamp = Timestamp.valueOf("2007-12-03 00:00:00");
assertThrows(IllegalArgumentException.class, () -> convert(timestamp, ZonedDateTime.class));
}
@Test
void testConvertDurationThrowsExceptionOnUnsupported() {
final Integer i = 10;
assertThrows(IllegalArgumentException.class, () -> convert(i, Duration.class));
}
@Test
void testConvertStringToCharacter() {
assertEquals('A', convert("A", Character.class));
}
@Test
void testConvertStringToCharacterEmpty() {
assertEquals(' ', convert("", Character.class));
}
@Test
void testConvertStringToCharacterThrowsExceptionOnWrongLength() {
assertThrows(IllegalArgumentException.class, () -> convert("AA", Character.class));
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/CompoundSelectionImplTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/CompoundSelectionImplTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.withSettings;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map.Entry;
import jakarta.persistence.criteria.Path;
import jakarta.persistence.criteria.Selection;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAPath;
import com.sap.olingo.jpa.processor.cb.joiner.SqlConvertible;
class CompoundSelectionImplTest {
private CompoundSelectionImpl<Long> cut;
private Selection<?> expression;
private List<Selection<?>> selections;
@BeforeEach
void setup() {
expression = mock(ExpressionImpl.class, withSettings()
.extraInterfaces(Selection.class));
selections = new ArrayList<>();
selections.add(expression);
when(expression.getAlias()).thenReturn("Test");
when(expression.getJavaType()).thenAnswer(new Answer<Class<?>>() {
@Override
public Class<?> answer(final InvocationOnMock invocation) throws Throwable {
return Long.class;
}
});
cut = new CompoundSelectionImpl<>(selections, Long.class, new AliasBuilder("S"));
}
@Test
void testIsCompoundSelection() {
assertTrue(cut.isCompoundSelection());
}
@Test
void testGetCompoundSelectionItems() {
final List<Selection<?>> act = cut.getCompoundSelectionItems();
assertEquals(selections.size(), act.size());
assertEquals(selections.get(0), ((SqlSelection<?>) act.get(0)).getSelection());
}
@Test
void testAsSQLFromExpression() {
final StringBuilder statement = new StringBuilder();
when(((SqlConvertible) expression).asSQL(any(StringBuilder.class))).thenReturn(statement);
assertEquals(statement, cut.asSQL(statement));
}
@Test
void testAsSQLFromPath() {
final PathImpl<?> path = mock(PathImpl.class, withSettings()
.extraInterfaces(Selection.class));
@SuppressWarnings("unchecked")
final Path<Object> pathElement = (Path<Object>) mock(ExpressionImpl.class, withSettings()
.extraInterfaces(SqlConvertible.class, Path.class));
final StringBuilder statement = new StringBuilder();
when(path.resolvePathElements()).thenReturn(Collections.singletonList(pathElement));
when(((SqlConvertible) pathElement).asSQL(any(StringBuilder.class))).thenReturn(statement);
selections.clear();
selections.add(path);
cut = new CompoundSelectionImpl<>(selections, Long.class, new AliasBuilder("S"));
assertEquals(statement, cut.asSQL(statement));
}
@Test
void testResolveSelectionLateExpression() {
final List<Entry<String, JPAPath>> act = cut.resolveSelectionLate();
assertEquals(1, act.size());
assertEquals("Test", act.get(0).getKey());
assertEquals(Long.class, act.get(0).getValue().getLeaf().getType());
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/CriteriaQueryImplTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/CriteriaQueryImplTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.Arrays;
import java.util.List;
import java.util.Map.Entry;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.CriteriaQuery;
import jakarta.persistence.criteria.Expression;
import jakarta.persistence.criteria.Order;
import jakarta.persistence.criteria.Root;
import jakarta.persistence.criteria.Selection;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAPath;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAServiceDocument;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.processor.cb.ProcessorSelection;
import com.sap.olingo.jpa.processor.cb.ProcessorSqlPatternProvider;
import com.sap.olingo.jpa.processor.cb.exceptions.InternalServerError;
import com.sap.olingo.jpa.processor.core.testmodel.AdministrativeDivision;
import com.sap.olingo.jpa.processor.core.testmodel.Organization;
class CriteriaQueryImplTest extends BuilderBaseTest {
private CriteriaQueryImpl<Object> cut;
private CriteriaBuilder cb;
private ProcessorSqlPatternProvider sqlPattern;
@BeforeEach
void setup() {
sqlPattern = new SqlDefaultPattern();
cb = new CriteriaBuilderImpl(sd, sqlPattern);
cut = new CriteriaQueryImpl<>(Object.class, sd, cb, sqlPattern);
}
@Test
void testSetDistinctTrue() {
cut.distinct(true);
assertTrue(cut.isDistinct());
}
@Test
void testSetDistinctFalse() {
cut.distinct(false);
assertFalse(cut.isDistinct());
}
@Test
void testCreateSelectFromAttribute() {
final Root<?> adminDivision = cut.from(AdministrativeDivision.class);
final CriteriaQuery<Object> act = cut.multiselect(adminDivision.get("codeID"));
assertNotNull(act);
}
@Test
void testCreateOrderByWithArray() {
final Root<?> adminDivision = cut.from(AdministrativeDivision.class);
final CriteriaQuery<Object> act = cut.orderBy(cb.desc(adminDivision.get("codeID")));
assertNotNull(act.getOrderList());
assertEquals(1, act.getOrderList().size());
}
@Test
void testCreateOrderByWithList() {
final Root<?> adminDivision = cut.from(AdministrativeDivision.class);
final CriteriaQuery<Object> act = cut.orderBy(Arrays.asList(cb.desc(adminDivision.get("codeID")), cb.asc(
adminDivision.get("divisionCode"))));
assertNotNull(act.getOrderList());
assertEquals(2, act.getOrderList().size());
}
@Test
void testResetOrderByWithArray() {
final Root<?> adminDivision = cut.from(AdministrativeDivision.class);
final Order[] nullArray = null;
cut.orderBy(Arrays.asList(cb.desc(adminDivision.get("codeID")), cb.asc(adminDivision.get("divisionCode"))));
CriteriaQuery<Object> act = cut.orderBy(nullArray);
assertNotNull(act.getOrderList());
assertEquals(0, act.getOrderList().size());
}
@Test
void testResetOrderByWithList() {
final Root<?> adminDivision = cut.from(AdministrativeDivision.class);
final List<Order> nullList = null;
cut.orderBy(Arrays.asList(cb.desc(adminDivision.get("codeID")), cb.asc(adminDivision.get("divisionCode"))));
CriteriaQuery<Object> act = cut.orderBy(nullList);
assertNotNull(act.getOrderList());
assertEquals(0, act.getOrderList().size());
}
@Test
void testWithBaseClass() {
final StringBuilder statement = new StringBuilder();
final Root<?> act = cut.from(Organization.class);
cut.multiselect(act.get("iD"));
assertEquals("SELECT E0.\"ID\" S0 FROM \"OLINGO\".\"BusinessPartner\" E0 WHERE (E0.\"Type\" = ?1)",
cut.asSQL(statement).toString());
}
@Test
void testGroupBy() {
final StringBuilder statement = new StringBuilder();
final Root<?> act = cut.from(Organization.class);
cut.groupBy(act.get("aBCClass"), act.get("name2"));
cut.multiselect(act.get("aBCClass"), act.get("name2"));
assertEquals(
"SELECT E0.\"ABCClass\" S0, E0.\"NameLine2\" S1 FROM \"OLINGO\".\"BusinessPartner\" E0 "
+ "WHERE (E0.\"Type\" = ?1) GROUP BY E0.\"ABCClass\", E0.\"NameLine2\"",
cut.asSQL(statement).toString());
}
@Test
void testReplaceGroupByEmpty() {
final Expression<?>[] nullArray = null;
final StringBuilder statement = new StringBuilder();
final Root<?> act = cut.from(Organization.class);
cut.groupBy(act.get("aBCClass"), act.get("name2"));
cut.multiselect(act.get("aBCClass"), act.get("name2"));
cut.groupBy(nullArray);
assertEquals(
"SELECT E0.\"ABCClass\" S0, E0.\"NameLine2\" S1 FROM \"OLINGO\".\"BusinessPartner\" E0 "
+ "WHERE (E0.\"Type\" = ?1)",
cut.asSQL(statement).toString());
}
@Test
void testHaving() {
final StringBuilder statement = new StringBuilder();
final Root<?> act = cut.from(Organization.class);
cut.having(cb.gt(cb.count(act.get("iD")), 1));
cut.groupBy(act.get("name2"));
cut.multiselect(act.get("aBCClass"), act.get("name2"));
assertEquals(
"""
SELECT E0."ABCClass" S0, E0."NameLine2" S1 FROM "OLINGO"."BusinessPartner" E0 \
WHERE (E0."Type" = ?2) \
GROUP BY E0."NameLine2" \
HAVING (COUNT(E0."ID") > ?1)""",
cut.asSQL(statement).toString());
}
@Test
void testDefaultImplementationOnPathWrapper() {
final Root<?> act = cut.from(Organization.class);
cut.multiselect(act.get("aBCClass"), act.get("name2"));
final Selection<Object> selection = cut.getSelection();
final List<Entry<String, JPAPath>> resolvedSelections = ((ProcessorSelection<?>) selection).getResolvedSelection();
assertNotNull(resolvedSelections.get(0).getValue());
}
@Test
void testFromRethrowsException() throws ODataJPAModelException {
final JPAServiceDocument serviceDocument = mock(JPAServiceDocument.class);
when(serviceDocument.getEntity(any(Class.class))).thenThrow(ODataJPAModelException.class);
cut = new CriteriaQueryImpl<>(Object.class, serviceDocument, cb, sqlPattern);
assertThrows(InternalServerError.class, () -> cut.from(AdministrativeDivision.class));
}
@Test
void testGetFirstResultWhenNotSet() {
assertEquals(0, cut.getFirstResult());
}
@Test
void testGetFirstResultReturnsSetValue() {
cut.setFirstResult(122);
assertEquals(122, cut.getFirstResult());
}
@Test
void testGetMaxResultsWhenNotSet() {
assertEquals(Integer.MAX_VALUE, cut.getMaxResults());
}
@Test
void testGetMaxResultsReturnsSetValue() {
cut.setMaxResults(122);
assertEquals(122, cut.getMaxResults());
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/CompoundPathImplTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/CompoundPathImplTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.From;
import jakarta.persistence.criteria.Path;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEntityType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAPath;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.processor.core.testmodel.Organization;
class CompoundPathImplTest extends BuilderBaseTest {
private From<Organization, Organization> root;
private AliasBuilder ab;
private JPAEntityType et;
private CompoundPathImpl cut;
private List<Path<Comparable<?>>> paths;
@BeforeEach
void setup() throws ODataJPAModelException {
ab = new AliasBuilder();
et = sd.getEntity("Organizations");
paths = new ArrayList<>();
root = new FromImpl<>(et, ab, mock(CriteriaBuilder.class));
cut = new CompoundPathImpl(paths);
}
@Test
void testAsSQLOnePath() throws ODataJPAModelException {
final String exp = "(E0.\"Address.StreetName\")";
final JPAPath jpaPath = et.getPath("Address/StreetName");
final PathImpl<Comparable<?>> sqlPath = new PathImpl<>(jpaPath, Optional.of((PathImpl<?>) root), et, Optional
.empty());
paths.add(sqlPath);
assertEquals(exp, cut.asSQL(new StringBuilder()).toString());
}
@Test
void testAsSQLTwoPath() throws ODataJPAModelException {
final String exp = "(E0.\"Address.StreetName\", E0.\"ID\")";
final JPAPath jpaPath1 = et.getPath("Address/StreetName");
final PathImpl<Comparable<?>> sqlPath1 = new PathImpl<>(jpaPath1, Optional.of((PathImpl<?>) root), et, Optional
.empty());
paths.add(sqlPath1);
final JPAPath jpaPath2 = et.getPath("ID");
final PathImpl<Comparable<?>> sqlPath2 = new PathImpl<>(jpaPath2, Optional.of((PathImpl<?>) root), et, Optional
.empty());
paths.add(sqlPath2);
assertEquals(exp, cut.asSQL(new StringBuilder()).toString());
}
@Test
void testIsEmptyTrue() {
assertTrue(cut.isEmpty());
}
@Test
void testIsEmptyFalse() throws ODataJPAModelException {
final JPAPath jpaPath2 = et.getPath("ID");
final PathImpl<Comparable<?>> sqlPath2 = new PathImpl<>(jpaPath2, Optional.of((PathImpl<?>) root), et, Optional
.empty());
paths.add(sqlPath2);
assertFalse(cut.isEmpty());
}
@Test
void testGetFirstThrowsExceptionIfPathIsEmpty() {
assertThrows(IllegalStateException.class, () -> cut.getFirst());
}
@Test
void testGetFirstReturnsFirst() throws ODataJPAModelException {
final JPAPath jpaPath1 = et.getPath("Address/StreetName");
final PathImpl<Comparable<?>> sqlPath1 = new PathImpl<>(jpaPath1, Optional.of((PathImpl<?>) root), et, Optional
.empty());
paths.add(sqlPath1);
final JPAPath jpaPath2 = et.getPath("ID");
final PathImpl<Comparable<?>> sqlPath2 = new PathImpl<>(jpaPath2, Optional.of((PathImpl<?>) root), et, Optional
.empty());
paths.add(sqlPath2);
assertEquals(sqlPath1, cut.getFirst());
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/CollectionJoinImplTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/CollectionJoinImplTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.Arrays;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.metadata.api.JPAJoinColumn;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAssociationPath;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPACollectionAttribute;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEntityType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAJoinTable;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAPath;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.processor.cb.ProcessorCriteriaBuilder;
import com.sap.olingo.jpa.processor.cb.exceptions.NotImplementedException;
import com.sap.olingo.jpa.processor.core.testmodel.InhouseAddressTable;
import com.sap.olingo.jpa.processor.core.testmodel.Person;
class CollectionJoinImplTest {
private ProcessorCriteriaBuilder cb;
private AliasBuilder ab;
private FromImpl<?, ?> parent;
private JPAPath path;
private JPACollectionAttribute attribute;
private JPAAssociationPath associationPath;
private JPAJoinTable joinTable;
private JPAJoinColumn joinColumn;
private JPAEntityType targetType;
private JPAEntityType sourceType;
private CollectionJoinImpl<?, ?> cut;
@BeforeEach
void setup() throws ODataJPAModelException {
ab = new AliasBuilder();
parent = mock(FromImpl.class);
path = mock(JPAPath.class);
attribute = mock(JPACollectionAttribute.class);
associationPath = mock(JPAAssociationPath.class);
joinTable = mock(JPAJoinTable.class);
joinColumn = mock(JPAJoinColumn.class);
targetType = mock(JPAEntityType.class);
sourceType = mock(JPAEntityType.class);
when(path.getLeaf()).thenReturn(attribute);
when(attribute.asAssociation()).thenReturn(associationPath);
when(attribute.getInternalName()).thenReturn("Test");
when(associationPath.getJoinTable()).thenReturn(joinTable);
when(associationPath.getTargetType()).thenReturn(targetType);
when(associationPath.getSourceType()).thenReturn(sourceType);
when(joinTable.getRawInverseJoinInformation()).thenReturn(Arrays.asList(joinColumn));
when(joinTable.getEntityType()).thenReturn(sourceType);
when(sourceType.getTypeClass()).thenAnswer(new ClassAnswer(Person.class));
when(sourceType.getInternalName()).thenReturn("Dummy");
when(targetType.getTypeClass()).thenAnswer(new ClassAnswer(InhouseAddressTable.class));
when(targetType.getInternalName()).thenReturn("InhouseAddressTable");
cut = new CollectionJoinImpl<>(path, parent, ab, cb, null);
}
@Test
void testAsSql() throws ODataJPAModelException {
final StringBuilder stmt = new StringBuilder();
when(attribute.asAssociation()).thenThrow(ODataJPAModelException.class);
assertThrows(IllegalStateException.class, () -> cut.asSQL(stmt));
}
@Test
void testResolvePathElementsRethrowsException() throws ODataJPAModelException {
when(attribute.getStructuredType()).thenThrow(ODataJPAModelException.class);
when(attribute.isComplex()).thenReturn(true);
assertThrows(IllegalStateException.class, () -> cut.resolvePathElements());
}
@Test
void testGetPathListRethrowsException() throws ODataJPAModelException {
when(attribute.getStructuredType()).thenThrow(ODataJPAModelException.class);
when(attribute.isComplex()).thenReturn(true);
assertThrows(IllegalStateException.class, () -> cut.getPathList());
}
@Test
void testGetAttributeNotImplemented() {
assertThrows(NotImplementedException.class, () -> cut.getAttribute());
}
@SuppressWarnings("unlikely-arg-type")
@Test
void testEquals() {
assertTrue(cut.equals(cut)); // NOSONAR
assertFalse(cut.equals(null));// NOSONAR
assertFalse(cut.equals("Test"));// NOSONAR
}
@Test
void testDeterminedType() {
assertEquals(targetType, cut.st);
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/PredicateImplTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/PredicateImplTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.params.provider.Arguments.arguments;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.withSettings;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;
import jakarta.persistence.Tuple;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.CriteriaBuilder.In;
import jakarta.persistence.criteria.CriteriaQuery;
import jakarta.persistence.criteria.Expression;
import jakarta.persistence.criteria.Path;
import jakarta.persistence.criteria.Predicate;
import jakarta.persistence.criteria.Root;
import jakarta.persistence.criteria.Subquery;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import com.sap.olingo.jpa.processor.cb.exceptions.NotImplementedException;
import com.sap.olingo.jpa.processor.cb.impl.PredicateImpl.NotPredicate;
import com.sap.olingo.jpa.processor.cb.joiner.SqlConvertible;
import com.sap.olingo.jpa.processor.core.testmodel.AdministrativeDivision;
class PredicateImplTest extends BuilderBaseTest {
private PredicateImpl cut;
private StringBuilder statement;
private CriteriaQuery<Tuple> query;
static Stream<Arguments> notImplemented() throws NoSuchMethodException, SecurityException {
final Class<PredicateImpl> clazz = PredicateImpl.class;
return Stream.of(
arguments(clazz.getMethod("in", Expression.class)),
arguments(clazz.getMethod("in", Collection.class)),
arguments(clazz.getMethod("in", Expression[].class)),
arguments(clazz.getMethod("in", Object[].class)),
arguments(clazz.getMethod("getCompoundSelectionItems")),
arguments(clazz.getMethod("getJavaType")),
arguments(clazz.getMethod("as", Class.class)));
}
@BeforeEach
void setup() {
cut = new PredicateImpl.NotPredicate(mock(SqlConvertible.class));
final CriteriaBuilder cb = new CriteriaBuilderImpl(sd, new SqlDefaultPattern());
statement = new StringBuilder();
query = cb.createTupleQuery();
}
@ParameterizedTest
@MethodSource("notImplemented")
void testThrowsNotImplemented(final Method method) throws IllegalAccessException, IllegalArgumentException {
testNotImplemented(method, cut);
}
@Test
void testAliasSet() {
cut.alias("Test");
assertEquals("Test", cut.getAlias());
}
@Test
void testAliasReset() {
cut.alias("Test");
cut.alias(null);
assertNull(cut.getAlias());
}
@Test
void testInCreated() {
@SuppressWarnings("unchecked")
final Subquery<Long> subQuery = mock(Subquery.class, withSettings().extraInterfaces(SqlConvertible.class));
final Predicate in = new PredicateImpl.In<>(Collections.emptyList(), subQuery);
assertNotNull(in);
}
@Test
void testInGetExpressionReturnsFirstPath() {
final Root<?> adminDivision = query.from(AdministrativeDivision.class);
final List<Path<?>> paths = Arrays.asList(adminDivision.get("codeID"), adminDivision.get("parentCodeID"));
@SuppressWarnings("unchecked")
final Subquery<Long> subQuery = mock(Subquery.class, withSettings().extraInterfaces(SqlConvertible.class));
final In<?> act = new PredicateImpl.In<>(paths, subQuery);
assertEquals(paths.get(0), act.getExpression());
}
@SuppressWarnings("unchecked")
@Test
void testInValueNotImplemented() {
final Subquery<Long> subQuery = mock(Subquery.class, withSettings().extraInterfaces(SqlConvertible.class));
final In<Integer> act = new PredicateImpl.In<>(Collections.emptyList(), subQuery);
assertThrows(NotImplementedException.class, () -> act.value(mock(Expression.class)));
}
@Test
void testInAsSqlGeneratePath() {
final String exp = ("(E0.\"CodeID\", E0.\"CodePublisher\") IN ()");
final Root<?> adminDivision = query.from(AdministrativeDivision.class);
final List<Path<?>> paths = Arrays.asList(adminDivision.get("codeID"), adminDivision.get("codePublisher"));
@SuppressWarnings("unchecked")
final Subquery<Long> subQuery = mock(Subquery.class, withSettings().extraInterfaces(SqlConvertible.class));
when(((SqlConvertible) subQuery).asSQL(statement)).thenAnswer(new Answer<StringBuilder>() {
@Override
public StringBuilder answer(final InvocationOnMock invocation) throws Throwable {
final StringBuilder stmt = ((StringBuilder) invocation.getArgument(0));
stmt.append("");
return stmt;
}
});
final In<?> act = new PredicateImpl.In<>(paths, subQuery);
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@SuppressWarnings("unchecked")
@Test
void testInAsSqlGenerateSubQuery() {
final String exp = ("() IN (Test)");
final Subquery<Long> subQuery = mock(Subquery.class, withSettings().extraInterfaces(SqlConvertible.class));
when(((SqlConvertible) subQuery).asSQL(statement)).thenAnswer(new Answer<StringBuilder>() {
@Override
public StringBuilder answer(final InvocationOnMock invocation) throws Throwable {
final StringBuilder stmt = ((StringBuilder) invocation.getArgument(0));
stmt.append("Test");
return stmt;
}
});
final In<?> act = new PredicateImpl.In<>(Collections.emptyList(), subQuery);
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@Test
void testInCreatedFromExpression() {
@SuppressWarnings("unchecked")
final Path<String> path = mock(Path.class);
final Predicate in = new PredicateImpl.In<>(path, null);
assertNotNull(in);
}
@SuppressWarnings("unchecked")
@Test
void testInAddExpressionValue() {
final Path<String> path = mock(Path.class);
final Subquery<String> subQuery = mock(Subquery.class, withSettings().extraInterfaces(SqlConvertible.class));
final In<String> in = new PredicateImpl.In<>(path, null);
assertNotNull(in.value(subQuery));
}
@SuppressWarnings("unchecked")
@Test
void testInThrowsExceptionOnMultipleAddExpressionValue() {
final Path<String> path = mock(Path.class);
final Subquery<String> subQuery = mock(Subquery.class, withSettings().extraInterfaces(SqlConvertible.class));
final In<String> in = new PredicateImpl.In<>(path, null);
in.value(subQuery);
assertThrows(NotImplementedException.class, () -> in.value(subQuery));
}
@SuppressWarnings("unchecked")
@Test
void testInAddFixValue() {
final Path<String> path = mock(Path.class);
final In<String> in = new PredicateImpl.In<>(path, new ParameterBuffer());
assertNotNull(in.value("Test"));
}
@SuppressWarnings("unchecked")
@Test
void testInAddMultipleFixValue() {
final Path<String> path = mock(Path.class);
final In<String> in = new PredicateImpl.In<>(path, new ParameterBuffer());
assertNotNull(in.value("Test1").value("Test2").value("Test3"));
}
@SuppressWarnings("unchecked")
@Test
void testInThrowsExceptionOnAddExpressionIfFixValueExists() {
final Path<String> path = mock(Path.class);
final Subquery<String> subQuery = mock(Subquery.class, withSettings().extraInterfaces(SqlConvertible.class));
final In<String> in = new PredicateImpl.In<>(path, new ParameterBuffer());
in.value("Test1");
assertThrows(IllegalStateException.class, () -> in.value(subQuery));
}
@SuppressWarnings("unchecked")
@Test
void testInThrowsExceptionOnAddFixValueIfExpressionExists() {
final Path<String> path = mock(Path.class);
final Subquery<String> subQuery = mock(Subquery.class, withSettings().extraInterfaces(SqlConvertible.class));
final In<String> in = new PredicateImpl.In<>(path, new ParameterBuffer());
in.value(subQuery);
assertThrows(IllegalStateException.class, () -> in.value("Test1"));
}
@Test
void testInAddMultipleFixValueAsSQL() {
final String exp = ("() IN (?1, ?2, ?3)");
final ParameterBuffer parameter = new ParameterBuffer();
final In<String> in = new PredicateImpl.In<>(Collections.emptyList(), parameter);
in.value("Test1").value("Test2").value("Test3");
assertEquals(exp, ((PredicateImpl.In<String>) in).asSQL(statement).toString());
assertEquals(3, parameter.getParameters().size());
}
@Test
void testIsCompoundSelectionFalse() {
assertFalse(cut.isCompoundSelection());
}
@Test
void testNotReturnsNegation() {
assertTrue(cut.not() instanceof NotPredicate);
}
@Test
void testGetExpressionsReturnsEmptyList() {
assertTrue(cut.getExpressions().isEmpty());
}
@Test
void testGetOperator() {
assertNull(cut.getOperator());
}
static Stream<Arguments> illegalArgumentsAndOr() throws SecurityException {
final var predicate = mock(Predicate.class, withSettings().extraInterfaces(SqlConvertible.class));
return Stream.of(
arguments(null, "Array is null"),
arguments(new Predicate[] {}, "Array is empty"),
arguments(new Predicate[] { predicate }, "Array one entry"),
arguments(new Predicate[] { predicate, null }, "Array first entry null"),
arguments(new Predicate[] { null, predicate }, "Array second entry null"));
}
@ParameterizedTest
@MethodSource("illegalArgumentsAndOr")
void testAndThrowsException(final Predicate[] restrictions, final String text) {
assertThrows(IllegalArgumentException.class, () -> PredicateImpl.and(restrictions), text);
}
@ParameterizedTest
@MethodSource("illegalArgumentsAndOr")
void testOrThrowsException(final Predicate[] restrictions, final String text) {
assertThrows(IllegalArgumentException.class, () -> PredicateImpl.or(restrictions), text);
}
static Stream<Arguments> legalArgumentsAndOr() throws SecurityException {
final var predicate = mock(Predicate.class, withSettings().extraInterfaces(SqlConvertible.class));
return Stream.of(
arguments(new Predicate[] { predicate, predicate }, "Array two entries"),
arguments(new Predicate[] { predicate, predicate, predicate }, "Array three entries"));
}
@ParameterizedTest
@MethodSource("legalArgumentsAndOr")
void testAndReturnsPredicate(final Predicate[] restrictions, final String text) {
final var act = PredicateImpl.and(restrictions);
assertNotNull(act, text);
}
@ParameterizedTest
@MethodSource("legalArgumentsAndOr")
void testOrReturnsPredicate(final Predicate[] restrictions, final String text) {
final var act = PredicateImpl.or(restrictions);
assertNotNull(act, text);
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/CriteriaBuilderOverallTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/CriteriaBuilderOverallTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.sql.Timestamp;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.List;
import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.Tuple;
import jakarta.persistence.TypedQuery;
import jakarta.persistence.criteria.CriteriaQuery;
import jakarta.persistence.criteria.Expression;
import jakarta.persistence.criteria.Join;
import jakarta.persistence.criteria.Path;
import jakarta.persistence.criteria.Predicate;
import jakarta.persistence.criteria.Root;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAServiceDocument;
import com.sap.olingo.jpa.processor.cb.ProcessorCriteriaBuilder;
import com.sap.olingo.jpa.processor.cb.ProcessorSqlPatternProvider;
import com.sap.olingo.jpa.processor.cb.joiner.SqlConvertible;
import com.sap.olingo.jpa.processor.core.testmodel.AdministrativeDivision;
import com.sap.olingo.jpa.processor.core.testmodel.AdministrativeDivisionDescription;
import com.sap.olingo.jpa.processor.core.testmodel.BusinessPartnerProtected;
import com.sap.olingo.jpa.processor.core.testmodel.DateTimeTest;
import com.sap.olingo.jpa.processor.core.testmodel.Organization;
import com.sap.olingo.jpa.processor.core.testmodel.Person;
import com.sap.olingo.jpa.processor.core.testmodel.Team;
abstract class CriteriaBuilderOverallTest {
protected ProcessorCriteriaBuilder cb;
protected EntityManager em;
protected StringBuilder statement;
protected CriteriaQuery<Tuple> query;
void setup(final EntityManagerFactory emf, final JPAServiceDocument sd,
final ProcessorSqlPatternProvider sqlPattern) {
em = new EntityManagerWrapper(emf.createEntityManager(), sd, sqlPattern);
cb = (ProcessorCriteriaBuilder) em.getCriteriaBuilder();
assertNotNull(cb);
statement = new StringBuilder();
query = cb.createTupleQuery();
}
@Test
void testCriteriaBuilderImplReturnsSQLQuery() {
assertTrue(query instanceof SqlConvertible);
}
@Test
void testSimpleQueryAll() {
final Root<?> team = query.from(Team.class);
query.multiselect(team);
((SqlConvertible) query).asSQL(statement);
assertEquals("SELECT E0.\"Active\" S0, E0.\"TeamKey\" S1, E0.\"Name\" S2 FROM \"OLINGO\".\"Team\" E0", statement
.toString().trim());
final TypedQuery<Tuple> typedQuery = em.createQuery(query);
final List<Tuple> act = typedQuery.getResultList();
assertEquals(4, act.size());
assertNotNull(act.get(0));
}
@Test
void testSimpleQueryMultiSelect() {
final Root<?> org = query.from(Organization.class);
query.multiselect(org.get("type").alias("count"), org.get("iD"), org.get("eTag"));
((SqlConvertible) query).asSQL(statement);
assertEquals(
"SELECT E0.\"Type\" S0, E0.\"ID\" S1, E0.\"ETag\" S2 FROM \"OLINGO\".\"BusinessPartner\" E0 WHERE (E0.\"Type\" = ?1)",
statement.toString().trim());
final TypedQuery<Tuple> typedQuery = em.createQuery(query);
final List<Tuple> act = typedQuery.getResultList();
assertEquals(10, act.size());
assertNotNull(act.get(0));
assertEquals("2", act.get(0).get("count"));
}
@Test
void testWhereWithMultipleAnd() {
// SELECT E0."CodeID" FROM "OLINGO"."AdministrativeDivision" E0 WHERE (((E0."DivisionCode" = ?) AND (E0."CodeID" =
// ?)) AND (E0."CodePublisher" = ?))
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
query.multiselect(administrativeDivision.get("codeID"));
final Predicate[] restrictions = new Predicate[3];
restrictions[0] = cb.equal(administrativeDivision.get("codeID"), "NUTS2");
restrictions[1] = cb.equal(administrativeDivision.get("divisionCode"), "BE34");
restrictions[2] = cb.equal(administrativeDivision.get("codePublisher"), "Eurostat");
query.where(cb.and(restrictions));
((SqlConvertible) query).asSQL(statement);
final TypedQuery<Tuple> typedQuery = em.createQuery(query);
final List<Tuple> act = typedQuery.getResultList();
assertNotNull(typedQuery);
assertEquals(1, act.size());
}
@Test
void testSimpleLikeQueryAll() {
final Root<?> adminDiv = query.from(AdministrativeDivision.class);
query.multiselect(adminDiv.get("codeID"));
query.where(cb.like(adminDiv.get("codeID"), "%6-1"));
((SqlConvertible) query).asSQL(statement);
assertEquals("SELECT E0.\"CodeID\" S0 FROM \"OLINGO\".\"AdministrativeDivision\" E0 WHERE (E0.\"CodeID\" LIKE ?1)",
statement.toString().trim());
final TypedQuery<Tuple> typedQuery = em.createQuery(query);
final List<Tuple> act = typedQuery.getResultList();
assertEquals(4, act.size());
assertNotNull(act.get(0));
}
@Test
void testSimpleLikeQueryAllWithEscape() {
final Root<?> adminDiv = query.from(AdministrativeDivision.class);
final Expression<String> p = cb.literal("%6-1");
final Expression<Character> e = cb.literal('/');
query.multiselect(adminDiv.get("codeID"));
query.where(cb.like(adminDiv.get("codeID"), p, e));
((SqlConvertible) query).asSQL(statement);
assertEquals(
"SELECT E0.\"CodeID\" S0 FROM \"OLINGO\".\"AdministrativeDivision\" E0 WHERE (E0.\"CodeID\" LIKE ?1 ESCAPE ?2)",
statement.toString().trim());
final TypedQuery<Tuple> typedQuery = em.createQuery(query);
final List<Tuple> act = typedQuery.getResultList();
assertEquals(4, act.size());
assertNotNull(act.get(0));
}
@Test
void testOrderByClause() {
final Root<?> team = query.from(Team.class);
query.multiselect(team);
query.orderBy(cb.asc(team.get("name")));
((SqlConvertible) query).asSQL(statement);
assertEquals(
"SELECT E0.\"Active\" S0, E0.\"TeamKey\" S1, E0.\"Name\" S2 FROM \"OLINGO\".\"Team\" E0 ORDER BY E0.\"Name\" ASC",
statement
.toString().trim());
final TypedQuery<Tuple> typedQuery = em.createQuery(query);
final List<Tuple> act = typedQuery.getResultList();
assertEquals(4, act.size());
assertNotNull(act.get(0));
}
@Test
void testOrderByClauseTwoElements() {
final Root<?> team = query.from(Team.class);
query.multiselect(team);
query.orderBy(cb.asc(team.get("name")), cb.desc(team.get("iD")));
((SqlConvertible) query).asSQL(statement);
assertEquals(
"SELECT E0.\"Active\" S0, E0.\"TeamKey\" S1, E0.\"Name\" S2 FROM \"OLINGO\".\"Team\" E0 ORDER BY E0.\"Name\" ASC, E0.\"TeamKey\" DESC",
statement.toString().trim());
final TypedQuery<Tuple> typedQuery = em.createQuery(query);
final List<Tuple> act = typedQuery.getResultList();
assertEquals(4, act.size());
assertNotNull(act.get(0));
}
@Test
void testSimpleToLowerQuery() {
final Root<?> adminDiv = query.from(AdministrativeDivisionDescription.class);
final Expression<Boolean> equal = cb.equal(adminDiv.get("language"), "de");
final Expression<Boolean> lower = cb.equal(cb.lower(adminDiv.get("name")), "brandenburg");
query.multiselect(adminDiv.get("codeID"));
query.where(cb.and(equal, lower));
((SqlConvertible) query).asSQL(statement);
assertEquals(
"SELECT E0.\"CodeID\" S0 FROM \"OLINGO\".\"AdministrativeDivisionDescription\" E0 WHERE ((E0.\"LanguageISO\" = ?1) AND (LOWER(E0.\"Name\") = ?2))",
statement.toString().trim());
final TypedQuery<Tuple> typedQuery = em.createQuery(query);
final List<Tuple> act = typedQuery.getResultList();
assertEquals(1, act.size());
assertNotNull(act.get(0));
}
@Test
void testSimpleSubstringQuery() {
final Root<?> adminDiv = query.from(AdministrativeDivisionDescription.class);
final Expression<Boolean> equal = cb.equal(adminDiv.get("language"), "de");
final Expression<String> sub = cb.substring(adminDiv.get("name"), 1, 5);
final Expression<Boolean> lower = cb.equal(cb.lower(sub), "north");
query.multiselect(adminDiv.get("codeID"));
query.where(cb.and(equal, lower));
((SqlConvertible) query).asSQL(statement);
assertEquals(
expectedQuerySubstring(),
statement.toString().trim());
final TypedQuery<Tuple> typedQuery = em.createQuery(query);
final List<Tuple> act = typedQuery.getResultList();
assertEquals(2, act.size());
assertNotNull(act.get(0));
}
// SELECT "CodeID" FROM "OLINGO"."AdministrativeDivisionDescription" WHERE (("LanguageISO" = 'de') AND
// (LOWER(SUBSTR("Name", 1, 5)) = 'north'))
@Test
void testSimpleLocateQuery() {
final Root<?> adminDiv = query.from(AdministrativeDivision.class);
final Expression<Integer> locate = cb.locate(adminDiv.get("divisionCode"), "3");
query.multiselect(adminDiv.get("codeID"));
query.where(cb.equal(locate, 4));
((SqlConvertible) query).asSQL(statement);
assertEquals(
"SELECT E0.\"CodeID\" S0 FROM \"OLINGO\".\"AdministrativeDivision\" E0 WHERE (LOCATE(?1, E0.\"DivisionCode\") = ?2)",
statement.toString().trim());
final TypedQuery<Tuple> typedQuery = em.createQuery(query);
final List<Tuple> act = typedQuery.getResultList();
assertEquals(7, act.size());
assertNotNull(act.get(0));
}
@Test
void testSimpleConcatQuery() {
final Root<?> person = query.from(Person.class);
final Expression<String> concat = cb.concat(cb.concat(person.get("lastName"), ","), person.get("firstName"));
query.multiselect(person.get("iD"));
query.where(cb.equal(concat, "Mustermann,Max"));
((SqlConvertible) query).asSQL(statement);
assertEquals(
expectedQueryConcat(),
statement.toString().trim());
final TypedQuery<Tuple> typedQuery = em.createQuery(query);
final List<Tuple> act = typedQuery.getResultList();
assertEquals(1, act.size());
assertNotNull(act.get(0));
}
@Test
void testSimpleTimestampQuery() {
final Root<?> person = query.from(Person.class);
final Expression<Timestamp> locate = person.get("administrativeInformation").get("created").get("at");
query.multiselect(person.get("iD"), person.get("creationDateTime"));
query.where(cb.lessThan(locate, cb.currentTimestamp()));
((SqlConvertible) query).asSQL(statement);
assertEquals(
"SELECT E0.\"ID\" S0, E0.\"CreatedAt\" S1 FROM \"OLINGO\".\"BusinessPartner\" E0 WHERE ((E0.\"CreatedAt\" < CURRENT_TIMESTAMP) AND (E0.\"Type\" = ?1))",
statement.toString().trim());
final TypedQuery<Tuple> typedQuery = em.createQuery(query);
final List<Tuple> act = typedQuery.getResultList();
assertEquals(3, act.size());
assertNotNull(act.get(0));
}
@Test
void testSelectPrimitiveCollectionProperty() {
final Root<?> org = query.from(Organization.class);
final Join<Object, Object> comment = org.join("comment");
final Path<Object> id = org.get("iD");
id.alias("ID");
comment.alias("Comment");
query.multiselect(id, comment);
query.where(cb.equal(id, '1'));
final TypedQuery<Tuple> typedQuery = em.createQuery(query);
final List<Tuple> act = typedQuery.getResultList();
assertEquals(2, act.size());
}
@Test
void testSelectComplexCollectionProperty() {
final Root<?> org = query.from(Person.class);
final Join<Object, Object> addr = org.join("inhouseAddress");
final Path<Object> id = org.get("iD");
id.alias("ID");
addr.alias("inhouseAddress");
query.multiselect(id, addr);
query.where(cb.equal(id, "99"));
final TypedQuery<Tuple> typedQuery = em.createQuery(query);
final List<Tuple> act = typedQuery.getResultList();
assertEquals(2, act.size());
assertNotNull(act.get(0).get("inhouseAddress.Building"));
}
@Test
void testSelectCountOneKey() {
// SELECT COUNT(DISTINCT(*)) FROM "OLINGO"."BusinessPartnerProtected" E0 WHERE (E0."UserName" = ?)
final CriteriaQuery<Number> qc = cb.createQuery(Number.class);
final Root<?> org = qc.from(BusinessPartnerProtected.class);
qc.multiselect(cb.countDistinct(org));
qc.where(cb.equal(org.get("userName"), "Willi"));
final TypedQuery<Number> tq = em.createQuery(qc);
final Long act = tq.getSingleResult().longValue();
assertEquals(3L, act);
}
@Test
void testSelectDateTime() {
final Root<?> dateTime = query.from(DateTimeTest.class);
final Path<Object> id = dateTime.get("iD");
query.multiselect(dateTime);
query.where(cb.equal(id, "99"));
final TypedQuery<Tuple> typedQuery = em.createQuery(query);
final List<Tuple> act = typedQuery.getResultList();
assertEquals(1, act.size());
assertEquals(LocalDate.parse("1999-04-01"), act.get(0).get("S0"));
assertEquals(LocalDateTime.parse("2016-01-20T09:21:23"), act.get(0).get("S2"));
}
@Test
void testSelectLimitOffset() {
final Root<?> person = query.from(Person.class);
query.multiselect(person.get("iD"));
final TypedQuery<Tuple> typedQuery = em.createQuery(query);
typedQuery.setFirstResult(1);
typedQuery.setMaxResults(1);
((SqlConvertible) query).asSQL(statement);
assertEquals(expectedQueryLimitOffset(), statement.toString().trim());
final List<Tuple> act = typedQuery.getResultList();
assertEquals(1, act.size());
assertNotNull(act.get(0));
}
protected String expectedQueryLimitOffset() {
return "SELECT E0.\"ID\" S0 FROM \"OLINGO\".\"BusinessPartner\" E0 WHERE (E0.\"Type\" = ?1) LIMIT 1 OFFSET 1";
}
protected String expectedQueryConcat() {
return "SELECT E0.\"ID\" S0 FROM \"OLINGO\".\"BusinessPartner\" E0 WHERE ((CONCAT(CONCAT(E0.\"NameLine2\", ?1), E0.\"NameLine1\") = ?2) AND (E0.\"Type\" = ?3))";
}
protected String expectedQuerySubstring() {
return "SELECT E0.\"CodeID\" S0 FROM \"OLINGO\".\"AdministrativeDivisionDescription\" E0 WHERE ((E0.\"LanguageISO\" = ?1) AND (LOWER(SUBSTRING(E0.\"Name\", ?2, ?3)) = ?4))";
}
} | java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/TupleImplTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/TupleImplTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.sql.Timestamp;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import jakarta.persistence.Tuple;
import jakarta.persistence.TupleElement;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAttribute;
import com.sap.olingo.jpa.processor.cb.ProcessorSelection;
import com.sap.olingo.jpa.processor.cb.testobjects.UserType;
import com.sap.olingo.jpa.processor.core.testmodel.DateTimeConverter;
class TupleImplTest {
private static final int NO_ELEMENTS = 7;
private static final String SECOND_VALUE = "Second";
private static final String THIRD_VALUE = "Third";
private static final String FIRST_VALUE = "First";
private static final String TIME_VALUE = "Timestamp";
private static final String ENUM_VALUE_STRING = "EnumeratedString";
private static final String ENUM_VALUE_ORDINAL = "EnumeratedOrdinal";
private static final String ENUM_VALUE_ERROR = "EnumeratedError";
private Tuple cut;
private final Object[] values = { "Hello", "World", 3, Timestamp.valueOf("2019-01-25 14:00:25"), "INTERACTIVE", 0,
"2019-01-25" };
private Map<String, Integer> selectionIndex;
private List<Entry<String, JPAAttribute>> selPath;
@BeforeEach
void setup() {
selPath = new ArrayList<>(NO_ELEMENTS);
selectionIndex = new HashMap<>(NO_ELEMENTS);
selectionIndex.put(FIRST_VALUE, 0);
selectionIndex.put(SECOND_VALUE, 1);
selectionIndex.put(THIRD_VALUE, 2);
selectionIndex.put(TIME_VALUE, 3);
selectionIndex.put(ENUM_VALUE_STRING, 4);
selectionIndex.put(ENUM_VALUE_ORDINAL, 5);
selectionIndex.put(ENUM_VALUE_ERROR, 6);
selPath.add(new ProcessorSelection.SelectionAttribute(FIRST_VALUE, mockAttribute(FIRST_VALUE, String.class)));
selPath.add(new ProcessorSelection.SelectionAttribute(SECOND_VALUE, mockAttribute(SECOND_VALUE, String.class)));
selPath.add(new ProcessorSelection.SelectionAttribute(THIRD_VALUE, mockAttribute(THIRD_VALUE, Integer.class)));
selPath.add(new ProcessorSelection.SelectionAttribute(TIME_VALUE, mockAttributeWithConverter(TIME_VALUE)));
selPath.add(new ProcessorSelection.SelectionAttribute(ENUM_VALUE_STRING, mockAttributeEnumerated(ENUM_VALUE_STRING,
String.class)));
selPath.add(new ProcessorSelection.SelectionAttribute(ENUM_VALUE_ORDINAL, mockAttributeEnumerated(
ENUM_VALUE_ORDINAL, Integer.class)));
selPath.add(new ProcessorSelection.SelectionAttribute(ENUM_VALUE_ERROR, mockAttributeEnumerated(ENUM_VALUE_ERROR,
LocalDate.class)));
cut = new TupleImpl(values, selPath, selectionIndex);
}
@Test
void testToArrayReturnsCopyOf() {
assertArrayEquals(values, cut.toArray());
assertNotEquals(values, cut.toArray());
}
@Test
void testGetByIndexReturnsCorrectValue() {
assertEquals("World", cut.get(1));
assertEquals("Hello", cut.get(0));
}
@Test
void testGetByIndexThrowsExceptionOnInvalidIndex() {
assertThrows(IllegalArgumentException.class, () -> cut.get(NO_ELEMENTS));
assertThrows(IllegalArgumentException.class, () -> cut.get(-1));
}
@Test
void testGetByAliasReturnsCorrectValue() {
assertEquals("World", cut.get(SECOND_VALUE));
assertEquals("Hello", cut.get(FIRST_VALUE));
}
@Test
void testGetByAliasReturnsConverted() {
final Double act = cut.get(THIRD_VALUE, Double.class);
assertNotNull(act);
}
@Test
void testGetByAliasThrowsExceptionOnInvalidValue() {
assertThrows(IllegalArgumentException.class, () -> cut.get("Willi"));
}
@Test
void testGetByIndexWithCastReturnsCorrectValue() {
assertEquals(3, cut.get(2, Number.class));
}
@Test
void testGetByIndexWithCastThrowsExceptionOnInvalidIndex() {
assertThrows(IllegalArgumentException.class, () -> cut.get(NO_ELEMENTS, Number.class));
assertThrows(IllegalArgumentException.class, () -> cut.get(-1, Number.class));
}
@Test
void testGetByAliasWithCastReturnsCorrectValue() {
assertEquals(3, cut.get(THIRD_VALUE, Number.class));
}
@Test
void testGetByAliasWithCastThrowsExceptionOnInvalidValue() {
assertThrows(IllegalArgumentException.class, () -> cut.get("Willi", Number.class));
}
@Test
void testGetByAliasWithCastThrowsExceptionOnInvalidCast() {
assertThrows(IllegalArgumentException.class, () -> cut.get(FIRST_VALUE, Double.class));
}
@Test
void testGetTupleElements() {
final List<TupleElement<?>> act = cut.getElements();
boolean secondFound = false;
assertEquals(NO_ELEMENTS, act.size());
for (final TupleElement<?> t : act) {
if (SECOND_VALUE.equals(t.getAlias())) {
assertEquals(String.class, t.getJavaType());
assertEquals("World", cut.get(t));
secondFound = true;
}
}
assertTrue(secondFound);
}
@Test
void testTupleReturnsConvertedValue() {
cut = new TupleImpl(values, selPath, selectionIndex);
assertTrue(cut.get(TIME_VALUE) instanceof LocalDateTime);
}
@Test
void testTupleReturnsEnumeratedStringConvertedValue() {
cut = new TupleImpl(values, selPath, selectionIndex);
final var act = cut.get(ENUM_VALUE_STRING);
assertTrue(act instanceof UserType);
assertEquals("INTERACTIVE", ((UserType) act).toString());
}
@Test
void testTupleReturnsEnumeratedOrdinalConvertedValue() {
cut = new TupleImpl(values, selPath, selectionIndex);
final var act = cut.get(ENUM_VALUE_ORDINAL);
assertTrue(act instanceof UserType);
assertEquals("BATCH", ((UserType) act).toString());
}
@Test
void testTupleThrowsExceptionEnumeratedWrongType() {
cut = new TupleImpl(values, selPath, selectionIndex);
assertThrows(IllegalArgumentException.class, () -> cut.get(ENUM_VALUE_ERROR));
}
private JPAAttribute mockAttribute(final String alias, final Class<?> clazz) {
final JPAAttribute a = mock(JPAAttribute.class);
when(a.getType()).thenAnswer(new Answer<Class<?>>() {
@Override
public Class<?> answer(final InvocationOnMock invocation) throws Throwable {
return clazz;
}
});
return a;
}
private JPAAttribute mockAttributeWithConverter(final String alias) {
final JPAAttribute attribute = mockAttribute(alias, Timestamp.class);
doReturn(new DateTimeConverter()).when(attribute).getConverter();
doReturn(new DateTimeConverter()).when(attribute).getRawConverter();
return attribute;
}
private JPAAttribute mockAttributeEnumerated(final String alias, final Class<?> dbType) {
final JPAAttribute attribute = mockAttribute(alias, UserType.class);
when(attribute.isEnum()).thenReturn(true);
doReturn(dbType).when(attribute).getDbType();
return attribute;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/AggregationExpressionTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/AggregationExpressionTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
import java.util.Arrays;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.From;
import jakarta.persistence.criteria.Path;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAttribute;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEntityType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.processor.core.testmodel.AdministrativeDivision;
class AggregationExpressionTest extends BuilderBaseTest {
private ExpressionImpl.AggregationExpression<Long> cut;
private Path<?> path;
private JPAEntityType et;
private From<AdministrativeDivision, AdministrativeDivision> root;
private AliasBuilder ab;
private StringBuilder stmt;
private FromImpl<AdministrativeDivision, AdministrativeDivision> spyRoot;
private JPAEntityType mockEt;
@BeforeEach
void setup() throws ODataJPAModelException {
ab = new AliasBuilder();
et = sd.getEntity(AdministrativeDivision.class);
root = new FromImpl<>(et, ab, mock(CriteriaBuilder.class));
path = root.get("area");
stmt = new StringBuilder();
mockEt = mock(JPAEntityType.class);
}
@Test
void testGetExpressionReturnsProvidedExpression() {
cut = new ExpressionImpl.AggregationExpression<>(SqlAggregation.COUNT, path);
assertEquals(path, cut.getExpression());
}
@Test
void testAsSQLGeneratesForPath() {
final String exp = "AVG(E0.\"Area\")";
cut = new ExpressionImpl.AggregationExpression<>(SqlAggregation.AVG, path);
assertEquals(exp, cut.asSQL(stmt).toString());
}
@Test
void testAsSQLGeneratesForFrom() {
final String exp = "COUNT(E0.\"CodePublisher\")";
// The following is not supported by DB: E0.\"CodePublisher\", E0.\"CodeID\", E0.\"DivisionCode\")";
cut = new ExpressionImpl.AggregationExpression<>(SqlAggregation.COUNT, root);
assertEquals(exp, cut.asSQL(stmt).toString());
}
@Test
void testAsSQLReThrowsExceptionOnMissingKey() throws ODataJPAModelException {
spyRoot = (FromImpl<AdministrativeDivision, AdministrativeDivision>) spy(root);
spyRoot.st = mockEt;
cut = new ExpressionImpl.AggregationExpression<>(SqlAggregation.COUNT, spyRoot);
when(mockEt.getKey()).thenThrow(ODataJPAModelException.class);
assertThrows(IllegalArgumentException.class, () -> cut.asSQL(stmt));
}
@Test
void testAsSQLReThrowsExceptionOnMissingPath() throws ODataJPAModelException {
final JPAAttribute mockPath = mock(JPAAttribute.class);
spyRoot = (FromImpl<AdministrativeDivision, AdministrativeDivision>) spy(root);
spyRoot.st = mockEt;
cut = new ExpressionImpl.AggregationExpression<>(SqlAggregation.COUNT, spyRoot);
when(mockEt.getKey()).thenReturn(Arrays.asList(mockPath));
when(mockPath.getExternalName()).thenReturn("Test");
when(mockEt.getPath("Test")).thenThrow(ODataJPAModelException.class);
assertThrows(IllegalStateException.class, () -> cut.asSQL(stmt));
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/SimpleJoinTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/SimpleJoinTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.Arrays;
import jakarta.persistence.Tuple;
import jakarta.persistence.criteria.JoinType;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.metadata.api.JPAJoinColumn;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAssociationPath;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.processor.cb.ProcessorCriteriaQuery;
import com.sap.olingo.jpa.processor.cb.exceptions.NotImplementedException;
import com.sap.olingo.jpa.processor.core.testmodel.BusinessPartner;
import com.sap.olingo.jpa.processor.core.testmodel.BusinessPartnerRole;
class SimpleJoinTest extends BuilderBaseTest {
private SimpleJoin<BusinessPartner, BusinessPartnerRole> cut;
private AliasBuilder ab;
private CriteriaBuilderImpl cb;
@BeforeEach
void setup() throws ODataJPAModelException {
ab = new AliasBuilder();
cb = new CriteriaBuilderImpl(sd, new SqlDefaultPattern());
final ProcessorCriteriaQuery<Tuple> q = cb.createTupleQuery();
final JPAAssociationPath path = sd.getEntity(BusinessPartner.class).getAssociationPath("Roles");
cut = new SimpleJoin<>(path, JoinType.INNER, q.from(BusinessPartner.class), ab, cb);
final JPAJoinColumn joinColumn = mock(JPAJoinColumn.class);
when(joinColumn.getName()).thenReturn("One");
when(joinColumn.getReferencedColumnName()).thenReturn("Two");
cut.createOn(Arrays.asList(joinColumn));
}
@Test
void testGetOn() {
assertNotNull(cut.getOn());
}
@Test
void testGetJoinType() {
assertEquals(JoinType.INNER, cut.getJoinType());
}
@Test
void testGetAttributeNotImplemented() {
assertThrows(NotImplementedException.class, () -> cut.getAttribute());
}
@Test
void testHashCode() {
assertNotEquals(0, cut.hashCode());
}
@SuppressWarnings("unlikely-arg-type")
@Test
void testEquals() {
assertTrue(cut.equals(cut)); // NOSONAR
assertFalse(cut.equals(null)); // NOSONAR
assertFalse(cut.equals("Willi")); // NOSONAR
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/SelectionImplTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/SelectionImplTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
class SelectionImplTest {
private SqlSelection<Long> selection;
private SelectionImpl<Long> cut;
@SuppressWarnings("unchecked")
@BeforeEach
void setup() {
selection = mock(SqlSelection.class);
when(selection.asSQL(any())).thenReturn(new StringBuilder("Dummy"));
cut = new SelectionImpl<>(selection, Long.class, new AliasBuilder("X"));
}
@Test
void testGetAliasReturnsGeneratedStringNotSet() {
assertEquals("X0", cut.getAlias());
}
@Test
void testGetAliasReturnsSetValue() {
assertEquals(cut, cut.alias("Selection"));
assertEquals("Selection", cut.getAlias());
}
@Test
void testAliasValueNotChanged() {
assertEquals(cut, cut.alias("Selection"));
assertEquals(cut, cut.alias("Error"));
assertEquals("Selection", cut.getAlias());
}
@Test
void testGetJavaType() {
assertEquals(Long.class, cut.getJavaType());
}
@Test
void testCompoundSelections() {
assertFalse(cut.isCompoundSelection());
assertThrows(IllegalStateException.class, () -> cut.getCompoundSelectionItems());
}
@Test
void testAsSql() {
assertEquals("Dummy X0", cut.asSQL(new StringBuilder()).toString());
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/BuilderBaseTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/BuilderBaseTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
import static org.mockito.Mockito.spy;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import javax.sql.DataSource;
import jakarta.persistence.EntityManagerFactory;
import org.apache.olingo.commons.api.ex.ODataException;
import org.junit.jupiter.api.BeforeAll;
import com.sap.olingo.jpa.metadata.api.JPAEdmProvider;
import com.sap.olingo.jpa.metadata.api.JPAEntityManagerFactory;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEdmNameBuilder;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAServiceDocument;
import com.sap.olingo.jpa.processor.cb.exceptions.NotImplementedException;
import com.sap.olingo.jpa.processor.core.testmodel.DataSourceHelper;
abstract class BuilderBaseTest {
protected static final String PUNIT_NAME = "com.sap.olingo.jpa";
protected static final String[] enumPackages = { "com.sap.olingo.jpa.processor.core.testmodel" };
protected static EntityManagerFactory emf;
protected static JPAServiceDocument sd;
protected static JPAEdmProvider edmProvider;
protected static JPAEdmNameBuilder nameBuilder;
protected static DataSource ds;
@BeforeAll
public static void classSetup() throws ODataException {
ds = DataSourceHelper.createDataSource(DataSourceHelper.DB_HSQLDB);
emf = JPAEntityManagerFactory.getEntityManagerFactory(PUNIT_NAME, ds);
edmProvider = new JPAEdmProvider(PUNIT_NAME, emf, null, enumPackages);
sd = spy(edmProvider.getServiceDocument());
sd.getEdmEntityContainer();
}
protected void testNotImplemented(final Method method, final Object cut) throws IllegalAccessException {
try {
invokeMethod(method, cut);
} catch (final InvocationTargetException e) {
assertTrue(e.getCause() instanceof NotImplementedException);
return;
}
fail();
}
protected Object invokeMethod(final Method method, final Object cut) throws IllegalAccessException,
InvocationTargetException {
if (method.getParameterCount() >= 1) {
final Class<?>[] params = method.getParameterTypes();
final List<Object> paramValues = new ArrayList<>(method.getParameterCount());
for (int i = 0; i < method.getParameterCount(); i++) {
if (params[i] == char.class)
paramValues.add(' ');
else if (params[i] == int.class)
paramValues.add(2);
else
paramValues.add(null);
}
return method.invoke(cut, paramValues.toArray());
} else {
return method.invoke(cut);
}
}
protected Object invokeMethod(final Method method, final Object cut, final Object... paramValues)
throws IllegalAccessException,
InvocationTargetException {
if (method.getParameterCount() >= 1) {
return method.invoke(cut, paramValues);
} else {
return method.invoke(cut);
}
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/CriteriaUpdateImplTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/CriteriaUpdateImplTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.CriteriaUpdate;
import jakarta.persistence.criteria.Path;
import jakarta.persistence.criteria.Predicate;
import jakarta.persistence.metamodel.EntityType;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAServiceDocument;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.processor.cb.ProcessorSqlPatternProvider;
import com.sap.olingo.jpa.processor.cb.exceptions.InternalServerError;
import com.sap.olingo.jpa.processor.cb.exceptions.NotImplementedException;
import com.sap.olingo.jpa.processor.cb.joiner.SqlConvertible;
import com.sap.olingo.jpa.processor.core.testmodel.AdministrativeDivision;
class CriteriaUpdateImplTest extends BuilderBaseTest {
private EntityType<AdministrativeDivision> entity;
private CriteriaUpdate<AdministrativeDivision> cut;
private CriteriaBuilder cb;
private ProcessorSqlPatternProvider sqlPattern;
@BeforeEach
void setup() {
final var parameterBuffer = new ParameterBuffer();
sqlPattern = new SqlDefaultPattern();
cb = new CriteriaBuilderImpl(sd, sqlPattern);
cut = new CriteriaUpdateImpl<>(sd, cb, parameterBuffer, AdministrativeDivision.class, sqlPattern);
}
@Test
void testGetRootReturnsValue() {
assertNotNull(cut.getRoot());
}
@Test
void testGetFromReturnsRoot() {
assertEquals(cut.getRoot(), cut.from(AdministrativeDivision.class));
assertEquals(cut.getRoot(), cut.from(entity));
}
@Test
void testWhereWithExpression() {
final var sql = new StringBuilder();
final var root = cut.getRoot();
final Path<Object> publisher = root.get("codePublisher");
final var act = cut.where(cb.equal(publisher, "ISO"));
assertEquals(cut, act);
((SqlConvertible) cut).asSQL(sql);
assertTrue(sql.toString().contains("WHERE (E0.\"CodePublisher\" = ?1)"));
}
@Test
void testWhereWithPredicateThrowsException() {
final Predicate predicate = mock(Predicate.class);
assertThrows(NotImplementedException.class, () -> cut.where(new Predicate[] { predicate }));
}
@Test
void testSetWithPathAndValue() {
final var sql = new StringBuilder();
final var root = cut.getRoot();
final Path<String> publisher = root.get("codePublisher");
final var act = cut.set(publisher, "DIN");
assertEquals(cut, act);
((SqlConvertible) cut).asSQL(sql);
assertTrue(sql.toString().contains("SET E0.\"CodePublisher\" = ?1"));
}
@Test
void testGetRestrictionThrowsException() {
assertThrows(NotImplementedException.class, () -> cut.getRestriction());
}
@Test
void testSubqueryNotNull() {
assertNotNull(cut.subquery(AdministrativeDivision.class));
}
@Test
void testParameterBufferReturned() {
assertNotNull(((CriteriaUpdateImpl<AdministrativeDivision>) cut).getParameterBuffer());
}
@Test
void testConstructorThrowsExceptionOnUnknowEt() throws ODataJPAModelException {
final var parameters = new ParameterBuffer();
final JPAServiceDocument service = mock(JPAServiceDocument.class);
when(service.getEntity(AdministrativeDivision.class)).thenThrow(ODataJPAModelException.class);
assertThrows(InternalServerError.class, () -> new CriteriaUpdateImpl<>(service, cb, parameters,
AdministrativeDivision.class, sqlPattern));
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/CriteriaBuilderImplTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/CriteriaBuilderImplTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.params.provider.Arguments.arguments;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.time.LocalDate;
import java.util.Collection;
import java.util.Map;
import java.util.stream.Stream;
import jakarta.persistence.Tuple;
import jakarta.persistence.criteria.CollectionJoin;
import jakarta.persistence.criteria.CriteriaBuilder.Coalesce;
import jakarta.persistence.criteria.CriteriaBuilder.Trimspec;
import jakarta.persistence.criteria.CriteriaQuery;
import jakarta.persistence.criteria.Expression;
import jakarta.persistence.criteria.Join;
import jakarta.persistence.criteria.ListJoin;
import jakarta.persistence.criteria.MapJoin;
import jakarta.persistence.criteria.Order;
import jakarta.persistence.criteria.Path;
import jakarta.persistence.criteria.Predicate;
import jakarta.persistence.criteria.Root;
import jakarta.persistence.criteria.Selection;
import jakarta.persistence.criteria.SetJoin;
import jakarta.persistence.criteria.Subquery;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import com.sap.olingo.jpa.processor.cb.exceptions.NotImplementedException;
import com.sap.olingo.jpa.processor.cb.impl.ExpressionImpl.ConcatExpression;
import com.sap.olingo.jpa.processor.cb.impl.ExpressionImpl.ParameterExpression;
import com.sap.olingo.jpa.processor.cb.joiner.SqlConvertible;
import com.sap.olingo.jpa.processor.core.testmodel.AccessRights;
import com.sap.olingo.jpa.processor.core.testmodel.AdministrativeDivision;
import com.sap.olingo.jpa.processor.core.testmodel.AdministrativeDivisionDescription;
import com.sap.olingo.jpa.processor.core.testmodel.BusinessPartnerRole;
import com.sap.olingo.jpa.processor.core.testmodel.Organization;
import com.sap.olingo.jpa.processor.core.testmodel.Person;
class CriteriaBuilderImplTest extends BuilderBaseTest {
CriteriaBuilderImpl cut;
private StringBuilder statement;
private CriteriaQuery<Tuple> query;
static Stream<Arguments> notImplemented() throws NoSuchMethodException, SecurityException {
final Class<CriteriaBuilderImpl> c = CriteriaBuilderImpl.class;
return Stream.of(
arguments(c.getMethod("isTrue", Expression.class)),
arguments(c.getMethod("isFalse", Expression.class)),
arguments(c.getMethod("sum", Expression.class)),
arguments(c.getMethod("sumAsDouble", Expression.class)),
arguments(c.getMethod("sumAsLong", Expression.class)),
arguments(c.getMethod("avg", Expression.class)),
arguments(c.getMethod("max", Expression.class)),
arguments(c.getMethod("min", Expression.class)),
arguments(c.getMethod("greatest", Expression.class)),
arguments(c.getMethod("least", Expression.class)),
arguments(c.getMethod("neg", Expression.class)),
arguments(c.getMethod("abs", Expression.class)),
arguments(c.getMethod("trim", Trimspec.class, Expression.class)),
arguments(c.getMethod("trim", Trimspec.class, Expression.class, Expression.class)),
arguments(c.getMethod("trim", Expression.class, Expression.class)),
arguments(c.getMethod("trim", char.class, Expression.class)),
arguments(c.getMethod("trim", Trimspec.class, char.class, Expression.class)),
arguments(c.getMethod("toBigDecimal", Expression.class)),
arguments(c.getMethod("toBigInteger", Expression.class)),
arguments(c.getMethod("toDouble", Expression.class)),
arguments(c.getMethod("toFloat", Expression.class)),
arguments(c.getMethod("toInteger", Expression.class)),
arguments(c.getMethod("toLong", Expression.class)),
arguments(c.getMethod("toString", Expression.class)),
arguments(c.getMethod("array", Selection[].class)),
arguments(c.getMethod("tuple", Selection[].class)),
arguments(c.getMethod("construct", Class.class, Selection[].class)),
arguments(c.getMethod("values", Map.class)),
arguments(c.getMethod("keys", Map.class)),
arguments(c.getMethod("treat", Root.class, Class.class)),
arguments(c.getMethod("treat", Path.class, Class.class)),
arguments(c.getMethod("treat", MapJoin.class, Class.class)),
arguments(c.getMethod("treat", ListJoin.class, Class.class)),
arguments(c.getMethod("treat", SetJoin.class, Class.class)),
arguments(c.getMethod("treat", CollectionJoin.class, Class.class)),
arguments(c.getMethod("treat", Join.class, Class.class)),
arguments(c.getMethod("isEmpty", Expression.class)),
arguments(c.getMethod("isNotEmpty", Expression.class)),
arguments(c.getMethod("isMember", Expression.class, Expression.class)),
arguments(c.getMethod("isMember", Object.class, Expression.class)),
arguments(c.getMethod("isNotMember", Expression.class, Expression.class)),
arguments(c.getMethod("isNotMember", Object.class, Expression.class)),
arguments(c.getMethod("size", Expression.class)),
arguments(c.getMethod("size", Collection.class)),
arguments(c.getMethod("nullif", Expression.class, Expression.class)),
arguments(c.getMethod("nullif", Expression.class, Object.class)),
arguments(c.getMethod("nullLiteral", Class.class)),
arguments(c.getMethod("disjunction")),
arguments(c.getMethod("conjunction")),
arguments(c.getMethod("selectCase")),
arguments(c.getMethod("selectCase", Expression.class)),
arguments(c.getMethod("parameter", Class.class)),
arguments(c.getMethod("parameter", Class.class, String.class)),
arguments(c.getMethod("currentDate")),
arguments(c.getMethod("currentTime")),
arguments(c.getMethod("sign", Expression.class)),
arguments(c.getMethod("ceiling", Expression.class)),
arguments(c.getMethod("floor", Expression.class)),
arguments(c.getMethod("exp", Expression.class)),
arguments(c.getMethod("power", Expression.class, Expression.class)),
arguments(c.getMethod("power", Expression.class, Number.class)),
arguments(c.getMethod("round", Expression.class, Integer.class)),
arguments(c.getMethod("localDate")),
arguments(c.getMethod("localDateTime")),
arguments(c.getMethod("localTime")),
arguments(c.getMethod("ln", Expression.class)),
arguments(c.getMethod("sqrt", Expression.class)));
}
static Stream<Arguments> binaryImplemented() throws NoSuchMethodException, SecurityException {
final Class<CriteriaBuilderImpl> c = CriteriaBuilderImpl.class;
return Stream.of(
arguments(c.getMethod("equal", Expression.class, Expression.class),
"(E0.\"CodeID\" = E0.\"ParentCodeID\")"),
arguments(c.getMethod("notEqual", Expression.class, Expression.class),
"(E0.\"CodeID\" <> E0.\"ParentCodeID\")"),
arguments(c.getMethod("greaterThanOrEqualTo", Expression.class, Expression.class),
"(E0.\"CodeID\" >= E0.\"ParentCodeID\")"),
arguments(c.getMethod("greaterThan", Expression.class, Expression.class),
"(E0.\"CodeID\" > E0.\"ParentCodeID\")"),
arguments(c.getMethod("lessThanOrEqualTo", Expression.class, Expression.class),
"(E0.\"CodeID\" <= E0.\"ParentCodeID\")"),
arguments(c.getMethod("lessThan", Expression.class, Expression.class),
"(E0.\"CodeID\" < E0.\"ParentCodeID\")"));
}
static Stream<Arguments> binaryValueImplemented() throws NoSuchMethodException, SecurityException {
final Class<CriteriaBuilderImpl> c = CriteriaBuilderImpl.class;
return Stream.of(
arguments(c.getMethod("equal", Expression.class, Object.class),
"(E0.\"CodeID\" = ?1)"),
arguments(c.getMethod("notEqual", Expression.class, Object.class),
"(E0.\"CodeID\" <> ?1)"),
arguments(c.getMethod("greaterThanOrEqualTo", Expression.class, Comparable.class),
"(E0.\"CodeID\" >= ?1)"),
arguments(c.getMethod("greaterThan", Expression.class, Comparable.class),
"(E0.\"CodeID\" > ?1)"),
arguments(c.getMethod("lessThanOrEqualTo", Expression.class, Comparable.class),
"(E0.\"CodeID\" <= ?1)"),
arguments(c.getMethod("lessThan", Expression.class, Comparable.class),
"(E0.\"CodeID\" < ?1)"));
}
static Stream<Arguments> binaryImplementedNumeric() throws NoSuchMethodException, SecurityException {
final Class<CriteriaBuilderImpl> c = CriteriaBuilderImpl.class;
return Stream.of(
arguments(c.getMethod("ge", Expression.class, Expression.class),
"(E0.\"Area\" >= E0.\"Population\")"),
arguments(c.getMethod("gt", Expression.class, Expression.class),
"(E0.\"Area\" > E0.\"Population\")"),
arguments(c.getMethod("le", Expression.class, Expression.class),
"(E0.\"Area\" <= E0.\"Population\")"),
arguments(c.getMethod("lt", Expression.class, Expression.class),
"(E0.\"Area\" < E0.\"Population\")"),
arguments(c.getMethod("sum", Expression.class, Expression.class),
"(E0.\"Area\" + E0.\"Population\")"),
arguments(c.getMethod("diff", Expression.class, Expression.class),
"(E0.\"Area\" - E0.\"Population\")"),
arguments(c.getMethod("prod", Expression.class, Expression.class),
"(E0.\"Area\" * E0.\"Population\")"),
arguments(c.getMethod("quot", Expression.class, Expression.class),
"(E0.\"Area\" / E0.\"Population\")"),
arguments(c.getMethod("mod", Expression.class, Expression.class),
"(E0.\"Area\" % E0.\"Population\")"));
}
static Stream<Arguments> binaryValueImplementedNumeric() throws NoSuchMethodException, SecurityException {
final Class<CriteriaBuilderImpl> c = CriteriaBuilderImpl.class;
return Stream.of(
arguments(c.getMethod("ge", Expression.class, Number.class),
"(E0.\"Area\" >= ?1)"),
arguments(c.getMethod("gt", Expression.class, Number.class),
"(E0.\"Area\" > ?1)"),
arguments(c.getMethod("le", Expression.class, Number.class),
"(E0.\"Area\" <= ?1)"),
arguments(c.getMethod("lt", Expression.class, Number.class),
"(E0.\"Area\" < ?1)"),
arguments(c.getMethod("sum", Expression.class, Number.class),
"(E0.\"Area\" + ?1)"),
arguments(c.getMethod("diff", Expression.class, Number.class),
"(E0.\"Area\" - ?1)"),
arguments(c.getMethod("prod", Expression.class, Number.class),
"(E0.\"Area\" * ?1)"),
arguments(c.getMethod("quot", Expression.class, Number.class),
"(E0.\"Area\" / ?1)"),
arguments(c.getMethod("mod", Expression.class, Integer.class),
"(E0.\"Area\" % ?1)"));
}
static Stream<Arguments> binaryValueImplementedNumericInverse() throws NoSuchMethodException, SecurityException {
final Class<CriteriaBuilderImpl> c = CriteriaBuilderImpl.class;
return Stream.of(
arguments(c.getMethod("sum", Number.class, Expression.class),
"(?1 + E0.\"Area\")"),
arguments(c.getMethod("diff", Number.class, Expression.class),
"(?1 - E0.\"Area\")"),
arguments(c.getMethod("prod", Number.class, Expression.class),
"(?1 * E0.\"Area\")"),
arguments(c.getMethod("quot", Number.class, Expression.class),
"(?1 / E0.\"Area\")"),
arguments(c.getMethod("mod", Integer.class, Expression.class),
"(?1 % E0.\"Area\")"));
}
static Stream<Arguments> unaryFunctionsImplemented() throws NoSuchMethodException, SecurityException {
final Class<CriteriaBuilderImpl> c = CriteriaBuilderImpl.class;
return Stream.of(
arguments(c.getMethod("lower", Expression.class), "LOWER(E0.\"Name\")"),
arguments(c.getMethod("upper", Expression.class), "UPPER(E0.\"Name\")"),
arguments(c.getMethod("trim", Expression.class), "TRIM(E0.\"Name\")"));
}
static Stream<Arguments> subQueryExpressionsImplemented() throws NoSuchMethodException, SecurityException {
final Class<CriteriaBuilderImpl> c = CriteriaBuilderImpl.class;
return Stream.of(
arguments(c.getMethod("any", Subquery.class),
"ANY (SELECT ?1 S0 FROM \"OLINGO\".\"AdministrativeDivision\" E0)"),
arguments(c.getMethod("all", Subquery.class),
"ALL (SELECT ?1 S0 FROM \"OLINGO\".\"AdministrativeDivision\" E0)"),
arguments(c.getMethod("exists", Subquery.class),
"EXISTS (SELECT ?1 S0 FROM \"OLINGO\".\"AdministrativeDivision\" E0)"),
arguments(c.getMethod("some", Subquery.class),
"SOME (SELECT ?1 S0 FROM \"OLINGO\".\"AdministrativeDivision\" E0)"));
}
@BeforeEach
void setup() {
cut = new CriteriaBuilderImpl(sd, new SqlDefaultPattern());
statement = new StringBuilder();
query = cut.createTupleQuery();
}
@ParameterizedTest
@MethodSource("notImplemented")
void testThrowsNotImplemented(final Method m) throws IllegalAccessException, IllegalArgumentException {
testNotImplemented(m, cut);
}
@ParameterizedTest
@MethodSource("binaryImplemented")
void testBinaryExpressionWithExpression(final Method m, final String exp) throws IllegalAccessException,
IllegalArgumentException, InvocationTargetException {
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Object[] params = { administrativeDivision.get("codeID"), administrativeDivision.get("parentCodeID") };
final Predicate act = (Predicate) m.invoke(cut, params);
assertNotNull(act);
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
assertEquals(0, cut.getParameterBuffer().getParameters().size());
}
@ParameterizedTest
@MethodSource("binaryValueImplemented")
void testBinaryExpressionWithObject(final Method m, final String exp) throws IllegalAccessException,
IllegalArgumentException, InvocationTargetException {
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Object[] params = { administrativeDivision.get("codeID"), "NUTS2" };
final Predicate act = (Predicate) m.invoke(cut, params);
assertNotNull(act);
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
assertEquals(1, cut.getParameterBuffer().getParameters().size());
for (final ParameterExpression<?, ?> parameter : cut.getParameterBuffer().getParameters().values()) {
if (parameter.getPosition() == 1)
assertEquals("NUTS2", parameter.getValue());
}
}
@ParameterizedTest
@MethodSource("binaryImplementedNumeric")
void testBinaryNumericExpressionWithExpression(final Method m, final String exp) throws IllegalAccessException,
IllegalArgumentException, InvocationTargetException {
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Object[] params = { administrativeDivision.get("area"), administrativeDivision.get("population") };
final Expression<?> act = (Expression<?>) m.invoke(cut, params);
assertNotNull(act);
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
assertEquals(0, cut.getParameterBuffer().getParameters().size());
}
@ParameterizedTest
@MethodSource("binaryValueImplementedNumeric")
void testBinaryNumericExpressionWithObject(final Method m, final String exp) throws IllegalAccessException,
IllegalArgumentException, InvocationTargetException {
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Object[] params = { administrativeDivision.get("area"), 1000 };
final Expression<?> act = (Expression<?>) m.invoke(cut, params);
assertNotNull(act);
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
assertEquals(1, cut.getParameterBuffer().getParameters().size());
for (final ParameterExpression<?, ?> parameter : cut.getParameterBuffer().getParameters().values()) {
if (parameter.getPosition() == 1)
assertEquals(1000, parameter.getValue());
}
}
@ParameterizedTest
@MethodSource("binaryValueImplementedNumericInverse")
void testBinaryNumericExpressionWithObjectFirst(final Method m, final String exp)
throws IllegalAccessException,
IllegalArgumentException, InvocationTargetException {
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Object[] params = { 1000, administrativeDivision.get("area") };
final Expression<?> act = (Expression<?>) m.invoke(cut, params);
assertNotNull(act);
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
assertEquals(1, cut.getParameterBuffer().getParameters().size());
for (final ParameterExpression<?, ?> parameter : cut.getParameterBuffer().getParameters().values()) {
if (parameter.getPosition() == 1)
assertEquals(1000, parameter.getValue());
}
}
@ParameterizedTest
@MethodSource("unaryFunctionsImplemented")
void testCreateUnaryFunction(final Method m, final String exp) throws IllegalAccessException,
IllegalArgumentException, InvocationTargetException {
final Root<?> administrativeDivision = query.from(AdministrativeDivisionDescription.class);
final Object[] params = { administrativeDivision.get("name") };
final Expression<?> act = (Expression<?>) m.invoke(cut, params);
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@ParameterizedTest
@MethodSource("subQueryExpressionsImplemented")
void testCreateSubQuery(final Method m, final String exp) throws IllegalAccessException,
IllegalArgumentException, InvocationTargetException {
final Subquery<Long> sub = query.subquery(Long.class);
sub.select(cut.literal(1L));
sub.from(AdministrativeDivision.class);
final Object[] params = { sub };
final Expression<?> act = (Expression<?>) m.invoke(cut, params);
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@Test
void testReturnsObjectQuery() {
assertNotNull(cut.createQuery());
assertEquals(Object.class, cut.createQuery().getResultType());
}
@Test
void testReturnsTupleQuery() {
assertNotNull(cut.createTupleQuery());
assertEquals(Tuple.class, cut.createTupleQuery().getResultType());
}
@Test
void testReturnsLongQuery() {
assertNotNull(cut.createQuery(Long.class));
assertEquals(Long.class, cut.createQuery(Long.class).getResultType());
}
@Test
void testCreateCriteriaUpdateThrowsNotImplemented() {
assertNotNull(cut.createCriteriaUpdate(Organization.class));
}
@Test
void testCreateCriteriaDeleteThrowsNotImplemented() {
assertThrows(NotImplementedException.class, () -> cut.createCriteriaDelete(Organization.class));
}
@Test
void testCreateEqualThrowsNullPointerExpressionNull() {
assertThrows(NullPointerException.class, () -> cut.equal(null, "NUTS2"));
}
@Test
void testCreateGeExpressionWithExpression() {
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Predicate act = cut.ge(administrativeDivision.get("area"), administrativeDivision.get("population"));
assertNotNull(act);
assertEquals("(E0.\"Area\" >= E0.\"Population\")", ((SqlConvertible) act).asSQL(statement).toString());
assertEquals(0, cut.getParameterBuffer().getParameters().size());
}
@Test
void testThrowsNullPointerExpressionNull() {
assertThrows(NullPointerException.class, () -> cut.equal(null, "NUTS2"));
}
@Test
void testCreateAnd() {
final String exp = "((E0.\"CodeID\" = ?1) AND (E0.\"DivisionCode\" = ?2))";
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Predicate restriction1 = cut.equal(administrativeDivision.get("codeID"), "NUTS2");
final Predicate restriction2 = cut.equal(administrativeDivision.get("divisionCode"), "BE34");
final Predicate act = cut.and(restriction1, restriction2);
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@Test
void testCreateMultiAnd() {
final String exp = "(((E0.\"CodeID\" = ?1) AND (E0.\"DivisionCode\" = ?2)) AND (E0.\"CodePublisher\" = ?3))";
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Predicate[] restrictions = new Predicate[3];
restrictions[0] = cut.equal(administrativeDivision.get("codeID"), "NUTS2");
restrictions[1] = cut.equal(administrativeDivision.get("divisionCode"), "BE34");
restrictions[2] = cut.equal(administrativeDivision.get("codePublisher"), "Eurostat");
final Predicate act = cut.and(restrictions);
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@Test
void testCreateMultiAndThrowsExceptionOnWrongParameter() {
final Predicate[] rNull = null;
assertThrows(IllegalArgumentException.class, () -> cut.and(rNull));
final Predicate[] rEmpty = new Predicate[3];
assertThrows(IllegalArgumentException.class, () -> cut.and(rEmpty));
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Predicate[] rOneEntry = new Predicate[1];
rOneEntry[0] = cut.equal(administrativeDivision.get("codeID"), "NUTS2");
assertThrows(IllegalArgumentException.class, () -> cut.and(rOneEntry));
}
@Test
void testCreateOneOr() {
final String exp = "((E0.\"CodeID\" = ?1) OR (E0.\"CodeID\" = ?2))";
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Predicate one = cut.equal(administrativeDivision.get("codeID"), "NUTS2");
final Predicate two = cut.equal(administrativeDivision.get("codeID"), "NUTS3");
final Predicate act = cut.or(one, two);
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@Test
void testCreateMultiOrThrowsExceptionOnWrongParameter() {
final Predicate[] rNull = null;
assertThrows(IllegalArgumentException.class, () -> cut.or(rNull));
final Predicate[] rEmpty = new Predicate[3];
assertThrows(IllegalArgumentException.class, () -> cut.or(rEmpty));
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Predicate[] rOneEntry = new Predicate[1];
rOneEntry[0] = cut.equal(administrativeDivision.get("codeID"), "NUTS2");
assertThrows(IllegalArgumentException.class, () -> cut.and(rOneEntry));
}
@Test
void testCreateMultiOr() {
final String exp = "(((E0.\"CodeID\" = ?1) OR (E0.\"DivisionCode\" = ?2)) OR (E0.\"CodePublisher\" = ?3))";
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Predicate[] restrictions = new Predicate[3];
restrictions[0] = cut.equal(administrativeDivision.get("codeID"), "NUTS2");
restrictions[1] = cut.equal(administrativeDivision.get("divisionCode"), "BE34");
restrictions[2] = cut.equal(administrativeDivision.get("codePublisher"), "Eurostat");
final Predicate act = cut.or(restrictions);
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@Test
void testCreateNot() {
final String exp = "(NOT (E0.\"CodeID\" = ?1))";
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Predicate one = cut.equal(administrativeDivision.get("codeID"), "NUTS2");
final Predicate act = cut.not(one);
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@Test
void testLiteralExpressionReturnsParameter() {
final String exp = "?1";
final Expression<LocalDate> act = cut.literal(LocalDate.now());
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
assertNotNull(cut.getParameterBuffer());
assertEquals(1, cut.getParameterBuffer().getParameters().size());
}
@Test
void testLiteralThrowsExceptionOnNullValue() {
assertThrows(IllegalArgumentException.class, () -> cut.literal(null));
}
@Test
void testCreateLengthFunction() {
final String exp = "LENGTH(E0.\"Name\")";
final Root<?> administrativeDivision = query.from(AdministrativeDivisionDescription.class);
final Expression<Integer> act = cut.length(administrativeDivision.get("name"));
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@Test
void testCreateLikeExpressionWithString() {
final String exp = "(E0.\"CodeID\" LIKE ?1)";
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Predicate act = cut.like(administrativeDivision.get("codeID"), "6-1");
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@Test
void testCreateNotLikeExpressionWithString() {
final String exp = "(NOT (E0.\"CodeID\" LIKE ?1))";
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Predicate act = cut.notLike(administrativeDivision.get("codeID"), "6-1");
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@Test
void testCreateLikeExpressionWithStringAndEscape() {
final String exp = "(E0.\"CodeID\" LIKE ?1 ESCAPE ?2)";
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Predicate act = cut.like(administrativeDivision.get("codeID"), "%6-1", '/');
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@Test
void testCreateNotLikeExpressionWithStringAndEscape() {
final String exp = "(NOT (E0.\"CodeID\" LIKE ?1 ESCAPE ?2))";
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Predicate act = cut.notLike(administrativeDivision.get("codeID"), "%6-1", '/');
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@Test
void testCreateLikeExpressionWithLiteral() {
final String exp = "(E0.\"CodeID\" LIKE ?1)";
final Expression<String> literal = cut.literal("%6-1");
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Predicate act = cut.like(administrativeDivision.get("codeID"), literal);
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@Test
void testCreateNotLikeExpressionWithLiteral() {
final String exp = "(NOT (E0.\"CodeID\" LIKE ?1))";
final Expression<String> literal = cut.literal("%6-1");
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Predicate act = cut.notLike(administrativeDivision.get("codeID"), literal);
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@Test
void testCreateLikeExpressionWithLiteralLiteral() {
final String exp = "(E0.\"CodeID\" LIKE ?1 ESCAPE ?2)";
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Expression<String> p = cut.literal("6-1");
final Expression<Character> e = cut.literal('/');
final Predicate act = cut.like(administrativeDivision.get("codeID"), p, e);
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@Test
void testCreateNotLikeExpressionWithLiteralLiteral() {
final String exp = "(NOT (E0.\"CodeID\" LIKE ?1 ESCAPE ?2))";
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Expression<String> p = cut.literal("6-1");
final Expression<Character> e = cut.literal('/');
final Predicate act = cut.notLike(administrativeDivision.get("codeID"), p, e);
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@Test
void testCreateLikeExpressionWithLiteralString() {
final String exp = "(E0.\"CodeID\" LIKE ?2 ESCAPE ?1)";
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Expression<Character> e = cut.literal('/');
final Predicate act = cut.like(administrativeDivision.get("codeID"), "%6-1", e);
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@Test
void testCreateNotLikeExpressionWithLiteralString() {
final String exp = "(NOT (E0.\"CodeID\" LIKE ?2 ESCAPE ?1))";
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Expression<Character> e = cut.literal('/');
final Predicate act = cut.notLike(administrativeDivision.get("codeID"), "%6-1", e);
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@Test
void testCreateLikeExpressionWithStringLiteral() {
final String exp = "(E0.\"CodeID\" LIKE ?1 ESCAPE ?2)";
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Expression<String> p = cut.literal("6-1");
final Predicate act = cut.like(administrativeDivision.get("codeID"), p, '/');
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@Test
void testCreateNotLikeExpressionWithStringLiteral() {
final String exp = "(NOT (E0.\"CodeID\" LIKE ?1 ESCAPE ?2))";
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Expression<String> p = cut.literal("6-1");
final Predicate act = cut.notLike(administrativeDivision.get("codeID"), p, '/');
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@Test
void testCreateOrderByDescending() {
final String exp = "E0.\"CodeID\" DESC";
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Order act = cut.desc(administrativeDivision.get("codeID"));
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@Test
void testCreateOrderByAscending() {
final String exp = "E0.\"CodeID\" ASC";
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Order act = cut.asc(administrativeDivision.get("codeID"));
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@Test
void testCreateOrderByAscendingCount() {
final String exp = "COUNT(E0.\"CodeID\") ASC";
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Expression<?> count = cut.count(administrativeDivision.get("codeID"));
final Order act = cut.asc(count);
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@Test
void testCreateOrderByEntity() {
final String exp = "E0.\"CodePublisher\" ASC, E0.\"CodeID\" ASC, E0.\"DivisionCode\" ASC";
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Order act = cut.asc(administrativeDivision);
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@Test
void testCreateIsNull() {
final String exp = "(E0.\"ParentCodeID\" IS NULL)";
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Expression<?> act = cut.isNull(administrativeDivision.get("parentCodeID"));
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@Test
void testCreateIsNotNull() {
final String exp = "(E0.\"ParentCodeID\" IS NOT NULL)";
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Expression<?> act = cut.isNotNull(administrativeDivision.get("parentCodeID"));
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@Test
void testCreateLocateExpressionWithStringNull() {
final String exp = "LOCATE(?1, E0.\"DivisionCode\")";
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Expression<Integer> act = cut.locate(administrativeDivision.get("divisionCode"), "3");
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@Test
void testCreateLocateExpressionWithLiteralNull() {
final String exp = "LOCATE(?1, E0.\"DivisionCode\")";
final Expression<String> literal = cut.literal("3");
final Root<?> administrativeDivision = query.from(AdministrativeDivision.class);
final Expression<Integer> act = cut.locate(administrativeDivision.get("divisionCode"), literal);
assertEquals(exp, ((SqlConvertible) act).asSQL(statement).toString());
}
@Test
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | true |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/ExpressionImplTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/ExpressionImplTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.params.provider.Arguments.arguments;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.stream.Stream;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.Expression;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEntityType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.processor.cb.exceptions.NotImplementedException;
import com.sap.olingo.jpa.processor.cb.impl.ExpressionImpl.DistinctExpression;
import com.sap.olingo.jpa.processor.core.testmodel.Country;
class ExpressionImplTest {
private static final String PUNIT_NAME = "com.sap.olingo.jpa";
private ExpressionImpl<Long> cut;
static Stream<Arguments> notImplemented() throws NoSuchMethodException, SecurityException {
final Class<ExpressionTest> c = ExpressionImplTest.ExpressionTest.class;
return Stream.of(
arguments(c.getMethod("as", Class.class)),
arguments(c.getMethod("in", Collection.class)),
arguments(c.getMethod("in", Expression[].class)),
arguments(c.getMethod("in", Expression.class)),
arguments(c.getMethod("in", Object[].class)),
arguments(c.getMethod("isNotNull")),
arguments(c.getMethod("isNull")),
arguments(c.getMethod("getCompoundSelectionItems")));
}
@BeforeEach
void setup() {
cut = new ExpressionTest();
}
@ParameterizedTest
@MethodSource("notImplemented")
void testThrowsNotImplemented(final Method m) throws IllegalArgumentException {
InvocationTargetException e;
if (m.getParameterCount() >= 1) {
final Class<?>[] params = m.getParameterTypes();
final List<Object> paramValues = new ArrayList<>(m.getParameterCount());
for (int i = 0; i < m.getParameterCount(); i++) {
if (params[i] == char.class)
paramValues.add(' ');
else
paramValues.add(null);
}
e = assertThrows(InvocationTargetException.class, () -> m.invoke(cut, paramValues.toArray()));
} else {
e = assertThrows(InvocationTargetException.class, () -> m.invoke(cut));
}
assertTrue(e.getCause() instanceof NotImplementedException);
}
@Test
void testIsCompoundSelectionReturnsFalse() {
assertFalse(cut.isCompoundSelection());
}
@Test
void testGetAliasReturnsEmptyStringIfNotSet() {
assertEquals("", cut.getAlias());
}
@Test
void testGetAliasReturnsAliceSet() {
cut.alias(PUNIT_NAME);
assertEquals(PUNIT_NAME, cut.getAlias());
}
@Test
void testGetAliasThrowsExceptionOnSecondCall() {
cut.alias(PUNIT_NAME);
assertThrows(IllegalAccessError.class, () -> cut.alias("Test"));
}
@Test
void testGetJavaTypeReturnsNull() {
assertNull(cut.getJavaType());
}
@Test
void testDistinctExpressionRethrowsAsIllegalStateException() throws ODataJPAModelException {
final JPAEntityType type = mock(JPAEntityType.class);
final AliasBuilder ab = new AliasBuilder();
final CriteriaBuilder cb = mock(CriteriaBuilder.class);
when(type.getKey()).thenThrow(ODataJPAModelException.class);
when(type.getTypeClass()).thenAnswer(new Answer<Class<Country>>() {
@Override
public Class<Country> answer(final InvocationOnMock invocation) throws Throwable {
return Country.class;
}
});
final FromImpl<?, ?> p = new FromImpl<>(type, ab, cb);
final DistinctExpression<Long> act = new ExpressionImpl.DistinctExpression<>(p);
final StringBuilder sb = new StringBuilder();
assertThrows(IllegalStateException.class, () -> act.asSQL(sb));
}
private static class ExpressionTest extends ExpressionImpl<Long> {
@Override
public StringBuilder asSQL(final StringBuilder statement) {
return statement;
}
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/OrderImplTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/OrderImplTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.withSettings;
import jakarta.persistence.criteria.Expression;
import jakarta.persistence.criteria.Order;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import com.sap.olingo.jpa.processor.cb.joiner.SqlConvertible;
class OrderImplTest {
private SqlConvertible expression;
private OrderImpl cut;
private StringBuilder stmt;
@BeforeEach
void setup() {
expression = mock(SqlConvertible.class, withSettings().extraInterfaces(Expression.class));
cut = new OrderImpl(true, expression);
}
@Test
void testGetExpression() {
assertEquals(expression, cut.getExpression());
}
@Test
void testIsAscending() {
assertTrue(cut.isAscending());
}
@Test
void testRevers() {
final Order act = cut.reverse();
assertFalse(act.isAscending());
assertEquals(expression, act.getExpression());
}
@Test
void testAsSqlSimplePrimitive() {
stmt = new StringBuilder();
when(expression.asSQL(stmt)).thenAnswer(new Answer<StringBuilder>() {
@Override
public StringBuilder answer(final InvocationOnMock invocation) throws Throwable {
final StringBuilder sb = invocation.getArgument(0);
return sb.append("Test");
}
});
final String exp = "Test ASC";
assertEquals(exp, cut.asSQL(stmt).toString());
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/ClassAnswer.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/ClassAnswer.java | package com.sap.olingo.jpa.processor.cb.impl;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
class ClassAnswer implements Answer<Class<?>> {
private final Class<?> clazz;
protected ClassAnswer(final Class<?> clazz) {
this.clazz = clazz;
}
@Override
public Class<?> answer(final InvocationOnMock invocation) throws Throwable {
return clazz;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/SqlJoinTypeTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/SqlJoinTypeTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import jakarta.persistence.criteria.JoinType;
import org.junit.jupiter.api.Test;
class SqlJoinTypeTest {
@Test
void testGetJoinTypeReturnsValue() {
assertEquals(JoinType.INNER, SqlJoinType.INNER.getJoinType());
assertEquals(JoinType.LEFT, SqlJoinType.LEFT.getJoinType());
assertEquals(JoinType.RIGHT, SqlJoinType.RIGHT.getJoinType());
}
@Test
void testByJoinType() {
assertEquals(SqlJoinType.INNER, SqlJoinType.byJoinType(JoinType.INNER));
assertEquals(SqlJoinType.INNER, SqlJoinType.byJoinType(JoinType.INNER));
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/CriteriaBuilderH2Test.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/CriteriaBuilderH2Test.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import javax.sql.DataSource;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.Tuple;
import jakarta.persistence.TypedQuery;
import jakarta.persistence.criteria.Expression;
import jakarta.persistence.criteria.Root;
import org.apache.olingo.commons.api.ex.ODataException;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.metadata.api.JPAEdmProvider;
import com.sap.olingo.jpa.metadata.api.JPAEntityManagerFactory;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAServiceDocument;
import com.sap.olingo.jpa.processor.cb.ProcessorCriteriaQuery;
import com.sap.olingo.jpa.processor.cb.ProcessorSubquery;
import com.sap.olingo.jpa.processor.core.testmodel.AdministrativeDivision;
import com.sap.olingo.jpa.processor.core.testmodel.DataSourceHelper;
class CriteriaBuilderH2Test extends CriteriaBuilderOverallTest {
private static final String PUNIT_NAME = "com.sap.olingo.jpa";
private static final String[] enumPackages = { "com.sap.olingo.jpa.processor.core.testmodel" };
private static EntityManagerFactory emf;
private static JPAServiceDocument sd;
private static JPAEdmProvider edmProvider;
private static DataSource ds;
@BeforeAll
public static void classSetup() throws ODataException {
ds = DataSourceHelper.createDataSource(DataSourceHelper.DB_H2);
emf = JPAEntityManagerFactory.getEntityManagerFactory(PUNIT_NAME, ds);
edmProvider = new JPAEdmProvider(PUNIT_NAME, emf, null, enumPackages);
sd = edmProvider.getServiceDocument();
sd.getEdmEntityContainer();
}
@BeforeEach
public void setup() {
super.setup(emf, sd, null);
}
@Test
void testRowNumberSupport() {
final List<Object> list = new ArrayList<>(1);
final ProcessorCriteriaQuery<Tuple> cq = cb.createTupleQuery();
final ProcessorSubquery<?> nuts3RowQuery = cq.subquery(AdministrativeDivision.class);
@SuppressWarnings("unchecked")
final ProcessorSubquery<List<Comparable<?>>> nuts2Query = (ProcessorSubquery<List<Comparable<?>>>) nuts3RowQuery
.subquery(list.getClass());
final ProcessorSubquery<?> nuts2RowQuery = nuts2Query.subquery(AdministrativeDivision.class);
@SuppressWarnings("unchecked")
final ProcessorSubquery<List<Comparable<?>>> nuts1 = (ProcessorSubquery<List<Comparable<?>>>) nuts2RowQuery
.subquery(list.getClass());
final Root<?> nuts3Root = cq.from(nuts3RowQuery);
final Root<AdministrativeDivision> nuts3RowRoot = nuts3RowQuery.from(AdministrativeDivision.class);
final Root<AdministrativeDivision> nuts2Root = nuts2Query.from(nuts2RowQuery);
final Root<AdministrativeDivision> nuts2RowRoot = nuts2RowQuery.from(AdministrativeDivision.class);
final Root<AdministrativeDivision> nuts1Root = nuts1.from(AdministrativeDivision.class);
nuts1.multiselect(nuts1Root.get("codePublisher"), nuts1Root.get("codeID"), nuts1Root.get("divisionCode"));
nuts1.where(cb.equal(nuts1Root.get("codeID"), "NUTS1"));
nuts1.orderBy(cb.asc(nuts1Root.get("codePublisher")), cb.asc(nuts1Root.get("codeID")), cb.asc(nuts1Root.get(
"divisionCode")));
nuts1.setMaxResults(4);
nuts1.setFirstResult(1);
final Expression<Long> nuts2RowNo = createRowNumber(nuts2RowRoot);
nuts2RowQuery.multiselect(nuts2RowRoot, nuts2RowNo);
nuts2RowQuery.where(cb.in(Arrays.asList(nuts2RowRoot.get("codePublisher"), nuts2RowRoot.get("parentCodeID"),
nuts2RowRoot.get("parentDivisionCode")), nuts1));
nuts2Query.multiselect(nuts2Root.get("codePublisher"), nuts2Root.get("codeID"), nuts2Root.get("divisionCode"));
nuts2Query.where(cb.lt(nuts2Root.get("row_no"), 3));
final Expression<Long> nuts3RowNo = createRowNumber(nuts3RowRoot);
nuts3RowQuery.multiselect(nuts3RowRoot, nuts3RowNo);
nuts3RowQuery.where(cb.in(Arrays.asList(nuts3RowRoot.get("codePublisher"), nuts3RowRoot.get("parentCodeID"),
nuts3RowRoot.get("parentDivisionCode")), nuts2Query));
cq.multiselect(nuts3Root.get("codePublisher"), nuts3Root.get("codeID"), nuts3Root.get("divisionCode").alias(
"divisionCode"));
cq.where(cb.and(cb.gt(nuts3Root.get("row_no"), 1),
cb.lt(nuts3Root.get("row_no"), 3)));
final TypedQuery<Tuple> typedQuery = em.createQuery(cq);
// typedQuery.setMaxResults(4);
final List<Tuple> result = typedQuery.getResultList();
assertNotNull(result);
assertEquals(3, result.size());
assertEquals("BE212", result.get(0).get("divisionCode"));
}
@SuppressWarnings({ "unchecked" })
private Expression<Long> createRowNumber(final Root<AdministrativeDivision> root) {
return (Expression<Long>) cb.rowNumber()
.orderBy(cb.asc(root))
.partitionBy(root.get("codePublisher"), root.get("parentCodeID"), root.get("parentDivisionCode"))
.alias("row_no");
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/SubqueryImplTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/SubqueryImplTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.params.provider.Arguments.arguments;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.withSettings;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Stream;
import jakarta.persistence.criteria.CollectionJoin;
import jakarta.persistence.criteria.CompoundSelection;
import jakarta.persistence.criteria.Expression;
import jakarta.persistence.criteria.Join;
import jakarta.persistence.criteria.ListJoin;
import jakarta.persistence.criteria.MapJoin;
import jakarta.persistence.criteria.Order;
import jakarta.persistence.criteria.Predicate;
import jakarta.persistence.criteria.Root;
import jakarta.persistence.criteria.Selection;
import jakarta.persistence.criteria.SetJoin;
import jakarta.persistence.metamodel.EntityType;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEntityType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.processor.cb.ProcessorCriteriaBuilder;
import com.sap.olingo.jpa.processor.cb.ProcessorSqlPatternProvider;
import com.sap.olingo.jpa.processor.core.testmodel.Person;
class SubqueryImplTest extends BuilderBaseTest {
private SubqueryImpl<Long> cut;
private ProcessorCriteriaBuilder cb;
private AliasBuilder aliasBuilder;
private CriteriaQueryImpl<?> parent;
private ProcessorSqlPatternProvider patternProvider;
@SuppressWarnings("rawtypes")
static Stream<Arguments> notImplemented() throws NoSuchMethodException, SecurityException {
final Class<SubqueryImpl> clazz = SubqueryImpl.class;
return Stream.of(
arguments(clazz.getMethod("correlate", Join.class)),
arguments(clazz.getMethod("correlate", CollectionJoin.class)),
arguments(clazz.getMethod("correlate", SetJoin.class)),
arguments(clazz.getMethod("correlate", ListJoin.class)),
arguments(clazz.getMethod("correlate", MapJoin.class)),
arguments(clazz.getMethod("correlate", Root.class)),
arguments(clazz.getMethod("getCorrelatedJoins")),
arguments(clazz.getMethod("isNull")),
arguments(clazz.getMethod("isNotNull")),
arguments(clazz.getMethod("in", Object[].class)),
arguments(clazz.getMethod("in", Expression[].class)),
arguments(clazz.getMethod("in", Collection.class)),
arguments(clazz.getMethod("in", Expression.class)),
arguments(clazz.getMethod("as", Class.class)),
arguments(clazz.getMethod("alias", String.class)),
arguments(clazz.getMethod("where", Predicate[].class)),
arguments(clazz.getMethod("getAlias")));
}
@SuppressWarnings("rawtypes")
static Stream<Arguments> returnsSelf() throws NoSuchMethodException, SecurityException {
final Class<SubqueryImpl> clazz = SubqueryImpl.class;
return Stream.of(
arguments(clazz.getMethod("select", Expression.class), mock(Expression.class)),
arguments(clazz.getMethod("where", Expression.class), mock(Expression.class)),
arguments(clazz.getMethod("groupBy", List.class), new ArrayList<>()),
arguments(clazz.getMethod("groupBy", Expression[].class), new Predicate[] {}),
arguments(clazz.getMethod("having", Expression.class), mock(Predicate.class)),
arguments(clazz.getMethod("having", Predicate[].class), new Predicate[] {}),
arguments(clazz.getMethod("distinct", boolean.class), true),
arguments(clazz.getMethod("setMaxResults", Integer.class), Integer.valueOf(10)),
arguments(clazz.getMethod("setFirstResult", Integer.class), Integer.valueOf(10)),
arguments(clazz.getMethod("multiselect", List.class), new ArrayList<>()),
arguments(clazz.getMethod("multiselect", Selection[].class), new Selection[] {}),
arguments(clazz.getMethod("orderBy", List.class), new ArrayList<>()),
arguments(clazz.getMethod("orderBy", Order[].class), new Order[] {}));
}
@BeforeEach
void setup() {
cb = mock(ProcessorCriteriaBuilder.class);
aliasBuilder = mock(AliasBuilder.class);
parent = mock(CriteriaQueryImpl.class);
patternProvider = spy(SqlDefaultPattern.class);
when(parent.getServiceDocument()).thenReturn(sd);
cut = new SubqueryImpl<>(Long.class, parent, aliasBuilder, cb, patternProvider, sd);
}
@ParameterizedTest
@MethodSource("notImplemented")
void testThrowsNotImplemented(final Method method) throws IllegalAccessException {
testNotImplemented(method, cut);
}
@ParameterizedTest
@MethodSource("returnsSelf")
void testReturnsSelf(final Method method, final Object param) throws IllegalAccessException,
InvocationTargetException {
assertEquals(cut, invokeMethod(method, cut, param));
}
@Test
void testGroupByArray() {
@SuppressWarnings("unchecked")
final Expression<Long> expression = mock(Expression.class);
cut.groupBy(expression);
assertEquals(expression, cut.getGroupList().get(0));
}
@Test
void testGroupByList() {
@SuppressWarnings("unchecked")
final Expression<Long> expression = mock(Expression.class);
cut.groupBy(Arrays.asList(expression));
assertEquals(expression, cut.getGroupList().get(0));
}
@Test
void testHaving() {
final Expression<Boolean> expression = mock(Predicate.class);
cut.having(expression);
assertEquals(expression, cut.getGroupRestriction());
}
@Test
void testHavingArray() {
final Predicate predicate = mock(Predicate.class);
final Predicate[] predicates = { predicate };
cut.having(predicates);
assertEquals(predicate, cut.getGroupRestriction());
}
@Test
void testDistinct() {
cut.distinct(true);
assertTrue(cut.isDistinct());
}
@Test
void testGetParent() {
assertEquals(parent, cut.getParent());
}
@Test
void testGetContainingQuery() {
assertEquals(parent, cut.getContainingQuery());
}
@SuppressWarnings("unchecked")
@Test
void testFromReturnsRoot() throws ODataJPAModelException {
final JPAEntityType et = mock(JPAEntityType.class);
final EntityType<Person> jpaEt = mock(EntityType.class);
when(jpaEt.getJavaType()).thenReturn(Person.class);
when(sd.getEntity(Person.class)).thenReturn(et);
when(et.getTypeClass()).thenAnswer(new ClassAnswer(Person.class));
when(aliasBuilder.getNext()).thenReturn("Test");
assertNotNull(cut.from(jpaEt));
assertNotNull(cut.getRoots());
assertEquals(1, cut.getRoots().size());
}
@Test
void testGetSelection() {
@SuppressWarnings("unchecked")
final Expression<Long> expression = mock(Expression.class);
cut.select(expression);
assertNotNull(cut.getSelection());
assertEquals(expression, cut.getSelection());
}
@Test
void testGetRestriction() {
final Expression<Boolean> restriction = mock(Predicate.class);
cut.where(restriction);
assertNotNull(cut.getRestriction());
assertEquals(restriction, cut.getRestriction());
}
@Test
void testGetCompoundSelectionItemsReturnsEmptyList() {
assertNotNull(cut.getCompoundSelectionItems());
assertTrue(cut.getCompoundSelectionItems().isEmpty());
}
@Test
void testGetCompoundSelectionItemsReturnsResolvedSelection() {
@SuppressWarnings("unchecked")
final Expression<Long> expression = mock(Expression.class, withSettings().extraInterfaces(CompoundSelection.class));
when(expression.getCompoundSelectionItems())
.thenReturn(Arrays.asList(mock(Expression.class), mock(Expression.class)));
cut.select(expression);
assertNotNull(cut.getCompoundSelectionItems());
assertEquals(1, cut.getCompoundSelectionItems().size());
}
@Test
void testGetCompoundSelectionItemsReturnsSelection() {
@SuppressWarnings("unchecked")
final Expression<Long> expression = mock(Expression.class);
cut.select(expression);
assertNotNull(cut.getCompoundSelectionItems());
assertEquals(1, cut.getCompoundSelectionItems().size());
assertEquals(expression, ((SelectionImpl<?>) cut.getCompoundSelectionItems().get(0)).selection);
}
@Test
void testAsSQLUsesSqlPatternForLimit() {
var statement = new StringBuilder();
@SuppressWarnings("unchecked")
final ExpressionImpl<Long> expression = mock(ExpressionImpl.class);
when(expression.asSQL(any())).thenReturn(statement);
cut.select(expression);
cut.setNumberOfResults(10);
cut.asSQL(statement);
verify(patternProvider, times(1)).getMaxResultsPattern();
}
@Test
void testAsSQLUsesSqlPatternForOffset() {
var statement = new StringBuilder();
@SuppressWarnings("unchecked")
final ExpressionImpl<Long> expression = mock(ExpressionImpl.class);
when(expression.asSQL(any())).thenReturn(statement);
cut.select(expression);
cut.setFirstResult(8);
cut.asSQL(statement);
verify(patternProvider, times(1)).getFirstResultPattern();
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/SubqueryRootImplTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/SubqueryRootImplTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.mock;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAServiceDocument;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.processor.cb.ProcessorSubquery;
import com.sap.olingo.jpa.processor.cb.exceptions.NotImplementedException;
class SubqueryRootImplTest {
private SubqueryRootImpl<?> cut;
private ProcessorSubquery<?> processor;
private JPAServiceDocument sd;
private AliasBuilder aliasBuilder;
@BeforeEach
void setup() throws ODataJPAModelException {
processor = mock(ProcessorSubquery.class);
sd = mock(JPAServiceDocument.class);
aliasBuilder = new AliasBuilder();
cut = new SubqueryRootImpl<>(processor, aliasBuilder, sd);
}
@Test
void testHashCode() {
assertNotEquals(31, cut.hashCode());
}
@Test
void testGetModelThrowsException() {
assertThrows(NotImplementedException.class, () -> cut.getModel());
}
@Test
void testEquals() throws ODataJPAModelException {
final ProcessorSubquery<?> otherQuery = mock(ProcessorSubquery.class);
final SubqueryRootImpl<?> other = new SubqueryRootImpl<>(otherQuery, aliasBuilder, sd);
assertEquals(cut, cut);
assertNotEquals(cut, null); // NOSONAR
assertNotEquals(cut, other);
}
@Test
void testEqualsOtherClass() {
final FromImpl<?, ?> other = mock(FromImpl.class);
assertNotEquals(cut, other);
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/JPAAttributeWrapperTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/JPAAttributeWrapperTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.params.provider.Arguments.arguments;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collection;
import java.util.stream.Stream;
import jakarta.persistence.criteria.Selection;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
class JPAAttributeWrapperTest {
private Selection<String> selection;
private JPAAttributeWrapper cut;
@SuppressWarnings("unchecked")
@BeforeEach
void setup() {
selection = mock(Selection.class);
when(selection.getJavaType()).thenAnswer(new Answer<Class<String>>() {
@Override
public Class<String> answer(final InvocationOnMock invocation) throws Throwable {
return String.class;
}
});
cut = new JPAAttributeWrapper(selection);
}
static Stream<Arguments> returnsNull() throws NoSuchMethodException, SecurityException {
final Class<JPAAttributeWrapper> c = JPAAttributeWrapper.class;
return Stream.of(
arguments(c.getMethod("getExternalFQN")),
arguments(c.getMethod("getExternalName")),
arguments(c.getMethod("getInternalName")),
arguments(c.getMethod("getConverter")),
arguments(c.getMethod("getRawConverter")),
arguments(c.getMethod("getEdmType")),
arguments(c.getMethod("getProperty")),
arguments(c.getMethod("getStructuredType")),
arguments(c.getMethod("getCalculatorConstructor")),
arguments(c.getMethod("getJavaType")));
}
static Stream<Arguments> returnsFalse() throws NoSuchMethodException, SecurityException {
final Class<JPAAttributeWrapper> c = JPAAttributeWrapper.class;
return Stream.of(
arguments(c.getMethod("isAssociation")),
arguments(c.getMethod("isCollection")),
arguments(c.getMethod("isComplex")),
arguments(c.getMethod("isEnum")),
arguments(c.getMethod("isEtag")),
arguments(c.getMethod("isKey")),
arguments(c.getMethod("isSearchable")),
arguments(c.getMethod("hasProtection")),
arguments(c.getMethod("isTransient")));
}
static Stream<Arguments> returnsEmptyCollection() throws NoSuchMethodException, SecurityException {
final Class<JPAAttributeWrapper> c = JPAAttributeWrapper.class;
return Stream.of(
arguments(c.getMethod("getProtectionClaimNames")),
arguments(c.getMethod("getRequiredProperties")));
}
@ParameterizedTest
@MethodSource("returnsNull")
void testMethodReturnsNull(final Method m) throws IllegalAccessException, IllegalArgumentException,
InvocationTargetException {
assertNull(m.invoke(cut));
}
@ParameterizedTest
@MethodSource("returnsFalse")
void testMethodReturnsFalse(final Method m) throws IllegalAccessException, IllegalArgumentException,
InvocationTargetException {
assertFalse((Boolean) m.invoke(cut));
}
@ParameterizedTest
@MethodSource("returnsEmptyCollection")
void testMethodReturnsEmptyCollection(final Method m) throws IllegalAccessException, IllegalArgumentException,
InvocationTargetException {
assertTrue(((Collection<?>) m.invoke(cut)).isEmpty());
}
@Test
void testGetProtectionPathReturnsEmpty() throws ODataJPAModelException {
assertTrue(cut.getProtectionPath("Test").isEmpty());
}
@Test
void testGetType() {
assertEquals(String.class, cut.getType());
}
@Test
void testGetDbType() {
assertEquals(String.class, cut.getDbType());
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/UpdateQueryImplTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/UpdateQueryImplTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
import static org.junit.jupiter.params.provider.Arguments.arguments;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.atLeastOnce;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.stream.Stream;
import jakarta.persistence.EntityManager;
import jakarta.persistence.Query;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
class UpdateQueryImplTest extends BuilderBaseTest {
private UpdateQueryImpl cut;
private CriteriaUpdateImpl<?> updateQuery;
private ParameterBuffer parameter;
private EntityManager em;
@BeforeEach
void setup() {
em = mock(EntityManager.class);
updateQuery = mock(CriteriaUpdateImpl.class);
parameter = new ParameterBuffer();
when(updateQuery.getParameterBuffer()).thenReturn(parameter);
cut = new UpdateQueryImpl(em, updateQuery);
}
static Stream<Arguments> illegalStateException() throws NoSuchMethodException, SecurityException {
final Class<UpdateQueryImpl> c = UpdateQueryImpl.class;
return Stream.of(
arguments(c.getMethod("getResultList")),
arguments(c.getMethod("getSingleResult")),
arguments(c.getMethod("setMaxResults", int.class)),
arguments(c.getMethod("setFirstResult", int.class)));
}
@ParameterizedTest
@MethodSource("illegalStateException")
void testThrowsNotImplemented(final Method method) throws IllegalAccessException, IllegalArgumentException {
testIllegalStateException(method, cut);
}
@Test
void testGetMaxResultsReturnsZero() {
assertEquals(0, cut.getMaxResults());
}
@Test
void testGetFirstResultReturnsZero() {
assertEquals(0, cut.getFirstResult());
}
@Test
void testUnwrap() {
assertNotNull(cut.unwrap(Query.class));
}
@Test
void testExecuteUpdate() {
final Query query = mock(Query.class);
parameter.addValue(10);
when(em.createNativeQuery(anyString())).thenReturn(query);
when(query.executeUpdate()).thenReturn(10);
when(updateQuery.asSQL(any())).thenReturn(new StringBuilder("UPDATE"));
final var result = cut.executeUpdate();
assertEquals(10, result);
verify(query, atLeastOnce()).setParameter(anyInt(), any());
}
protected void testIllegalStateException(final Method method, final Object cut) throws IllegalAccessException {
try {
invokeMethod(method, cut);
} catch (final InvocationTargetException e) {
assertTrue(e.getCause() instanceof IllegalStateException);
return;
}
fail();
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/JPAPathWrapperTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/JPAPathWrapperTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.params.provider.Arguments.arguments;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;
import jakarta.persistence.criteria.Selection;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAttribute;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAElement;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAPath;
class JPAPathWrapperTest {
private static final String ALIAS = "Example";
private Selection<String> selection;
private JPAPathWrapper cut;
@SuppressWarnings("unchecked")
@BeforeEach
void setup() {
selection = mock(Selection.class);
when(selection.getJavaType()).thenAnswer(new Answer<Class<String>>() {
@Override
public Class<String> answer(final InvocationOnMock invocation) throws Throwable {
return String.class;
}
});
when(selection.getAlias()).thenReturn(ALIAS);
cut = new JPAPathWrapper(selection);
}
static Stream<Arguments> returnsFalse() throws NoSuchMethodException, SecurityException {
final Class<JPAPathWrapper> c = JPAPathWrapper.class;
return Stream.of(
arguments(c.getMethod("ignore")),
arguments(c.getMethod("isTransient")));
}
@ParameterizedTest
@MethodSource("returnsFalse")
void testMethodReturnsFalse(final Method m) throws IllegalAccessException, IllegalArgumentException,
InvocationTargetException {
assertFalse((Boolean) m.invoke(cut));
}
@Test
void testIsPartOfGroupsIsFalse() {
assertFalse(cut.isPartOfGroups(Collections.singletonList("Test")));
}
@Test
void testGetAlias() {
assertEquals(ALIAS, cut.getAlias());
}
@Test
void testGetDBFieldNameNull() {
assertNull(cut.getDBFieldName());
}
@Test
void testGetPathReturnsLeaf() {
final List<JPAElement> act = cut.getPath();
assertEquals(1, act.size());
assertEquals(String.class, ((JPAAttribute) act.get(0)).getType());
}
@Test
void testCompareTo() {
final JPAPath path = mock(JPAPath.class);
when(path.getAlias()).thenReturn(ALIAS);
assertEquals(0, cut.compareTo(path));
when(path.getAlias()).thenReturn("Test.Test");
assertTrue(cut.compareTo(path) < 0);
when(path.getAlias()).thenReturn("Alpha");
assertTrue(cut.compareTo(path) > 0);
}
@Test
void testGetPathAsString() {
assertEquals(ALIAS, cut.getPathAsString());
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/TypedQueryImplTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/TypedQueryImplTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.sql.Date;
import java.time.LocalDate;
import java.util.Calendar;
import java.util.GregorianCalendar;
import jakarta.persistence.EntityManager;
import jakarta.persistence.FlushModeType;
import jakarta.persistence.LockModeType;
import jakarta.persistence.Parameter;
import jakarta.persistence.PersistenceException;
import jakarta.persistence.Query;
import jakarta.persistence.TemporalType;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
class TypedQueryImplTest extends BuilderBaseTest {
private TypedQueryImpl<Long> cut;
private EntityManager em;
private CriteriaQueryImpl<Long> cq;
private ParameterBuffer parameterBuffer;
private Query q;
@SuppressWarnings("unchecked")
@BeforeEach
void setup() {
em = mock(EntityManager.class);
cq = mock(CriteriaQueryImpl.class);
parameterBuffer = new ParameterBuffer();
q = mock(Query.class);
when(cq.asSQL(any())).thenReturn(new StringBuilder().append("Test"));
when(em.createNativeQuery("Test")).thenReturn(q);
cut = new TypedQueryImpl<>(cq, em, parameterBuffer);
}
@Test
void testExecuteUpdate() {
cut.executeUpdate();
verify(q).executeUpdate();
}
@Test
void testGetFirstResult() {
cut.getFirstResult();
verify(cq).getFirstResult();
}
@Test
void testGetParameterByPosition() {
final var exp = parameterBuffer.addValue("Test");
final var act = cut.getParameter(1);
assertEquals(exp, act);
}
@Test
void testGetParameterByPositionThrowsIfNoParameterAtPosition() {
parameterBuffer.addValue("Test");
assertThrows(IllegalArgumentException.class, () -> cut.getParameter(2));
}
@Test
void testGetParameterByPositionType() {
final var exp = parameterBuffer.addValue(Integer.valueOf(100));
final var act = cut.getParameter(1, Integer.class);
assertEquals(exp, act);
}
@Test
void testGetParameterByPositionTypeThrowsIfNoParameterAtPosition() {
parameterBuffer.addValue(Integer.valueOf(100));
assertThrows(IllegalArgumentException.class, () -> cut.getParameter(2, Integer.class));
}
@Test
void testGetParameterByPositionTypeThrowsWrongType() {
parameterBuffer.addValue(Integer.valueOf(100));
assertThrows(IllegalArgumentException.class, () -> cut.getParameter(1, String.class));
}
@Test
void testGetParameterByName() {
final var exp = parameterBuffer.addValue(Integer.valueOf(100));
assertEquals(exp, cut.getParameter("1"));
}
@Test
void testGetParameterByNameThrowsIfNameNotANumber() {
parameterBuffer.addValue(Integer.valueOf(100));
assertThrows(IllegalArgumentException.class, () -> cut.getParameter("1.2"));
}
@Test
void testGetParameterByNameType() {
final var exp = parameterBuffer.addValue(Integer.valueOf(100));
assertEquals(exp, cut.getParameter("1", Integer.class));
}
@Test
void testGetParameterByNameTypeThrowsWrongType() {
parameterBuffer.addValue(Integer.valueOf(100));
assertThrows(IllegalArgumentException.class, () -> cut.getParameter("1", String.class));
}
@Test
void testGetParameters() {
final var exp = parameterBuffer.addValue(Integer.valueOf(100));
final var act = cut.getParameters();
assertEquals(1, act.size());
assertTrue(act.contains(exp));
}
@Test
void testGetParameterValueByPosition() {
final var exp = parameterBuffer.addValue("Test");
final var act = cut.getParameterValue(1);
assertEquals(exp, act);
}
@Test
void testGetParameterValueByPositionFails() {
parameterBuffer.addValue("Test");
assertThrows(IllegalArgumentException.class, () -> cut.getParameterValue(2));
}
@Test
void testGetParameterValueByParameter() {
final var exp = parameterBuffer.addValue("Test");
parameterBuffer.addValue(Integer.valueOf(100));
assertEquals("Test", cut.getParameterValue(exp));
}
@SuppressWarnings("unchecked")
@Test
void testGetParameterValueByParameterThrowsIfParameterNotExists() {
final var dummy = mock(Parameter.class);
parameterBuffer.addValue(Integer.valueOf(100));
assertThrows(IllegalArgumentException.class, () -> cut.getParameterValue(dummy));
}
@Test
void testGetParameterValueByName() {
parameterBuffer.addValue(Integer.valueOf(100));
assertEquals(100, cut.getParameterValue("1"));
}
@Test
void testIsBound() {
final var act = parameterBuffer.addValue(Integer.valueOf(10));
assertTrue(cut.isBound(act));
}
@Test
void testSetFirstResult() {
assertEquals(cut, cut.setFirstResult(1));
verify(cq).setFirstResult(1);
}
@Test
void testSetGetFlushMode() {
assertEquals(cut, cut.setFlushMode(FlushModeType.AUTO));
assertEquals(FlushModeType.AUTO, cut.getFlushMode());
}
@Test
void testSetGetHint() {
assertEquals(cut, cut.setHint("Test", "Test"));
final var act = cut.getHints();
assertEquals(1, act.size());
assertEquals("Test", act.get("Test"));
}
@Test
void testSetGetLockMode() {
assertEquals(cut, cut.setLockMode(LockModeType.OPTIMISTIC));
assertEquals(LockModeType.OPTIMISTIC, cut.getLockMode());
}
@Test
void testSetMaxResults() {
assertEquals(cut, cut.setMaxResults(1));
verify(cq).setMaxResults(1);
}
@Test
void testGetMaxResults() {
cut.getMaxResults();
verify(cq).getMaxResults();
}
@Test
void testSetParameterTemporalByPosition() {
final Calendar value = new GregorianCalendar();
assertThrows(IllegalStateException.class, () -> cut.setParameter(1, value, TemporalType.TIMESTAMP));
}
@Test
void testSetParameterTemporalDateByPosition() {
final Date value = Date.valueOf(LocalDate.now());
assertThrows(IllegalStateException.class, () -> cut.setParameter(2, value, TemporalType.DATE));
}
@Test
void testSetParameterPosition() {
assertThrows(IllegalStateException.class, () -> cut.setParameter(1, "Test"));
}
@Test
void testSetParameterByTemporalByParameter() {
@SuppressWarnings("unchecked")
final Parameter<Calendar> param = mock(Parameter.class);
final Calendar value = new GregorianCalendar();
assertThrows(IllegalStateException.class, () -> cut.setParameter(param, value, TemporalType.TIMESTAMP));
}
@Test
void testSetParameterByTemporalDateByParameter() {
@SuppressWarnings("unchecked")
final Parameter<java.util.Date> param = mock(Parameter.class);
final Date value = Date.valueOf(LocalDate.now());
assertThrows(IllegalStateException.class, () -> cut.setParameter(param, value, TemporalType.DATE));
}
@Test
void testSetParameterByValue() {
@SuppressWarnings("unchecked")
final Parameter<Integer> param = mock(Parameter.class);
assertThrows(IllegalStateException.class, () -> cut.setParameter(param, 1));
}
@Test
void testSetParameterByTemporalCalendarByName() {
final Calendar value = new GregorianCalendar();
assertThrows(IllegalStateException.class, () -> cut.setParameter("Test", value, TemporalType.TIME));
}
@Test
void testSetParameterByTemporalDateByName() {
final Date value = Date.valueOf(LocalDate.now());
assertThrows(IllegalStateException.class, () -> cut.setParameter("Test", value, TemporalType.DATE));
}
@Test
void testSetParameterByName() {
assertThrows(IllegalStateException.class, () -> cut.setParameter("Test", "Test"));
}
@Test
void testUnwrapThrowsException() {
assertThrows(PersistenceException.class, () -> cut.unwrap(String.class));
}
@Test
void testUnwrap() {
assertNotNull(cut.unwrap(Query.class));
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/CriteriaBuilderHSQLDBTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/CriteriaBuilderHSQLDBTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import javax.sql.DataSource;
import jakarta.persistence.EntityManagerFactory;
import org.apache.olingo.commons.api.ex.ODataException;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import com.sap.olingo.jpa.metadata.api.JPAEdmProvider;
import com.sap.olingo.jpa.metadata.api.JPAEntityManagerFactory;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAServiceDocument;
import com.sap.olingo.jpa.processor.core.testmodel.DataSourceHelper;
class CriteriaBuilderHSQLDBTest extends CriteriaBuilderOverallTest {
private static final String PUNIT_NAME = "com.sap.olingo.jpa";
private static final String[] enumPackages = { "com.sap.olingo.jpa.processor.core.testmodel" };
private static EntityManagerFactory emf;
private static JPAServiceDocument sd;
private static JPAEdmProvider edmProvider;
private static DataSource ds;
@BeforeAll
static void classSetup() throws ODataException {
ds = DataSourceHelper.createDataSource(DataSourceHelper.DB_HSQLDB);
emf = JPAEntityManagerFactory.getEntityManagerFactory(PUNIT_NAME, ds);
edmProvider = new JPAEdmProvider(PUNIT_NAME, emf, null, enumPackages);
sd = edmProvider.getServiceDocument();
sd.getEdmEntityContainer();
}
@BeforeEach
void setup() {
super.setup(emf, sd, null);
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/EntityManagerWrapperTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/EntityManagerWrapperTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.params.provider.Arguments.arguments;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.clearInvocations;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Stream;
import jakarta.persistence.EntityGraph;
import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.EntityTransaction;
import jakarta.persistence.FlushModeType;
import jakarta.persistence.LockModeType;
import jakarta.persistence.Query;
import jakarta.persistence.StoredProcedureQuery;
import jakarta.persistence.TypedQuery;
import jakarta.persistence.criteria.CriteriaDelete;
import jakarta.persistence.criteria.CriteriaUpdate;
import jakarta.persistence.metamodel.Metamodel;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAServiceDocument;
import com.sap.olingo.jpa.processor.cb.exceptions.NotImplementedException;
import com.sap.olingo.jpa.processor.core.testmodel.Person;
class EntityManagerWrapperTest {
private EntityManagerWrapper cut;
private JPAServiceDocument sd;
private static EntityManagerFactory emf;
private static EntityManager em;
private static Person entity;
private static Query query;
private static CriteriaUpdate<?> cu;
private static CriteriaDelete<?> cd;
private static EntityGraph<?> graph;
private static List<EntityGraph<? super EntityManager>> graphs;
private static StoredProcedureQuery storedProcedure;
private static Map<String, Object> properties;
private static EntityTransaction transaction;
private static Metamodel metamodel;
private static TypedQuery<String> typedQuery;
@SuppressWarnings({ "unchecked", "rawtypes" })
@BeforeAll
static void classSetup() {
entity = new Person();
emf = mock(EntityManagerFactory.class);
em = mock(EntityManager.class);
query = mock(Query.class);
typedQuery = mock(TypedQuery.class);
cu = mock(CriteriaUpdate.class);
cd = mock(CriteriaDelete.class);
graph = mock(EntityGraph.class);
graphs = new ArrayList<>();
graphs.add((EntityGraph<? super EntityManager>) graph);
properties = new HashMap<>();
transaction = mock(EntityTransaction.class);
metamodel = mock(Metamodel.class);
when(em.merge(entity)).thenReturn(entity);
when(em.contains(entity)).thenReturn(false);
when(em.getLockMode(entity)).thenReturn(LockModeType.OPTIMISTIC);
when(em.createQuery(anyString())).thenReturn(query);
when(em.createQuery(cu)).thenReturn(query);
when(em.createQuery(cd)).thenReturn(query);
when(em.createNamedQuery(anyString())).thenReturn(query);
when(em.createNamedQuery(anyString(), eq(String.class))).thenReturn(typedQuery);
when(em.unwrap(EntityManager.class)).thenReturn(em);
when(em.isJoinedToTransaction()).thenReturn(false);
when(em.createEntityGraph(EntityManager.class)).thenReturn((EntityGraph<EntityManager>) graph);
when(em.createEntityGraph("Test")).thenReturn((EntityGraph) graph);
when(em.getEntityGraphs(EntityManager.class)).thenReturn(graphs);
when(em.getEntityGraph("Test")).thenReturn((EntityGraph) graph);
when(em.createNamedStoredProcedureQuery("Test")).thenReturn(storedProcedure);
when(em.createStoredProcedureQuery("Test")).thenReturn(storedProcedure);
when(em.getFlushMode()).thenReturn(FlushModeType.COMMIT);
when(em.getProperties()).thenReturn(properties);
when(em.isJoinedToTransaction()).thenReturn(true);
when(em.getDelegate()).thenReturn("Test");
when(em.isOpen()).thenReturn(false);
when(em.getTransaction()).thenReturn(transaction);
when(em.getEntityManagerFactory()).thenReturn(emf);
when(em.getMetamodel()).thenReturn(metamodel);
when(em.find(EntityManager.class, "Test")).thenReturn(em);
when(em.getReference(EntityManager.class, "Test")).thenReturn(em);
when(em.createNativeQuery("Test", EntityManager.class)).thenReturn(query);
when(em.createStoredProcedureQuery("Test", new Class[0])).thenReturn(storedProcedure);
when(em.createStoredProcedureQuery("Test", new String[0])).thenReturn(storedProcedure);
}
@BeforeEach
void setup() {
sd = mock(JPAServiceDocument.class);
cut = new EntityManagerWrapper(em, sd, null);
}
static Stream<Arguments> parameterFreeMethod() throws NoSuchMethodException, SecurityException {
final Class<EntityManager> c = EntityManager.class;
return Stream.of(
arguments(c.getMethod("flush"), null),
arguments(c.getMethod("getFlushMode"), FlushModeType.COMMIT),
arguments(c.getMethod("getProperties"), properties),
arguments(c.getMethod("joinTransaction"), null),
arguments(c.getMethod("isOpen"), false),
arguments(c.getMethod("getDelegate"), "Test"),
arguments(c.getMethod("close"), null),
arguments(c.getMethod("getEntityManagerFactory"), emf),
arguments(c.getMethod("isJoinedToTransaction"), true),
arguments(c.getMethod("getTransaction"), transaction),
arguments(c.getMethod("clear"), null),
arguments(c.getMethod("getMetamodel"), metamodel));
}
static Stream<Arguments> oneParameterMethod() throws NoSuchMethodException, SecurityException {
final Class<EntityManager> c = EntityManager.class;
final String dummy = "Test";
return Stream.of(
arguments(c.getMethod("persist", Object.class), dummy, null),
arguments(c.getMethod("merge", Object.class), entity, entity),
arguments(c.getMethod("remove", Object.class), dummy, null),
arguments(c.getMethod("setFlushMode", FlushModeType.class), FlushModeType.COMMIT, null),
arguments(c.getMethod("refresh", Object.class), dummy, null),
arguments(c.getMethod("detach", Object.class), dummy, null),
arguments(c.getMethod("contains", Object.class), entity, false),
arguments(c.getMethod("getLockMode", Object.class), entity, LockModeType.OPTIMISTIC),
arguments(c.getMethod("createQuery", String.class), dummy, query),
arguments(c.getMethod("createQuery", CriteriaUpdate.class), cu, query),
arguments(c.getMethod("createQuery", CriteriaDelete.class), cd, query),
arguments(c.getMethod("createNativeQuery", String.class), dummy, null),
arguments(c.getMethod("createNamedQuery", String.class), dummy, query),
arguments(c.getMethod("createNamedStoredProcedureQuery", String.class), dummy, storedProcedure),
arguments(c.getMethod("createStoredProcedureQuery", String.class), dummy, storedProcedure),
arguments(c.getMethod("unwrap", Class.class), c, em),
arguments(c.getMethod("createEntityGraph", Class.class), c, graph),
arguments(c.getMethod("createEntityGraph", String.class), dummy, graph),
arguments(c.getMethod("getEntityGraph", String.class), dummy, graph),
arguments(c.getMethod("getEntityGraphs", Class.class), c, graphs)
);
}
static Stream<Arguments> twoParameterMethod() throws NoSuchMethodException, SecurityException {
final Class<EntityManager> c = EntityManager.class;
final String dummy = "Test";
return Stream.of(
arguments(c.getMethod("find", Class.class, Object.class), c, dummy, em),
arguments(c.getMethod("getReference", Class.class, Object.class), c, dummy, em),
arguments(c.getMethod("lock", Object.class, LockModeType.class), dummy, LockModeType.OPTIMISTIC, null),
arguments(c.getMethod("refresh", Object.class, LockModeType.class), dummy, LockModeType.OPTIMISTIC, null),
arguments(c.getMethod("refresh", Object.class, Map.class), dummy, new HashMap<>(), null),
arguments(c.getMethod("setProperty", String.class, Object.class), dummy, dummy, null),
arguments(c.getMethod("createNativeQuery", String.class, Class.class), dummy, c, query),
arguments(c.getMethod("createNamedQuery", String.class, Class.class), dummy, String.class, typedQuery),
arguments(c.getMethod("createStoredProcedureQuery", String.class, Class[].class), dummy, new Class[0],
storedProcedure),
arguments(c.getMethod("createStoredProcedureQuery", String.class, String[].class), dummy, new String[0],
storedProcedure));
}
static Stream<Arguments> nParameterMethod() throws NoSuchMethodException, SecurityException {
final Class<EntityManager> c = EntityManager.class;
final String dummy = "Test";
return Stream.of(
arguments(c.getMethod("find", Class.class, Object.class, Map.class), c, dummy, new HashMap<>(), dummy),
arguments(c.getMethod("find", Class.class, Object.class, LockModeType.class), c, dummy, LockModeType.NONE,
dummy),
arguments(c.getMethod("find", Class.class, Object.class, LockModeType.class, Map.class), c, dummy,
LockModeType.OPTIMISTIC, new HashMap<>()),
arguments(c.getMethod("lock", Object.class, LockModeType.class, Map.class), dummy, LockModeType.NONE,
new HashMap<>(), dummy),
arguments(c.getMethod("refresh", Object.class, LockModeType.class, Map.class), dummy, LockModeType.NONE,
new HashMap<>(), dummy));
}
static Stream<Arguments> notImplementedMethod() throws NoSuchMethodException, SecurityException {
final Class<EntityManager> c = EntityManager.class;
final String dummy = "Test";
return Stream.of(
arguments(c.getMethod("createNativeQuery", String.class, String.class), dummy, dummy),
arguments(c.getMethod("createQuery", String.class, Class.class), dummy, c));
}
@ParameterizedTest
@MethodSource("parameterFreeMethod")
void testOriginalIsCalledNoParameter(final Method m, final Object r) throws IllegalAccessException,
IllegalArgumentException, InvocationTargetException {
if (m.getParameterCount() == 0) {
clearInvocations(em);
final Object response = m.invoke(cut);
final EntityManager v = verify(em);
m.invoke(v);
if (r != null)
assertEquals(r, response);
}
}
@ParameterizedTest
@MethodSource("oneParameterMethod")
void testOriginalIsCalledOneParameter(final Method m, final Object p, final Object r)
throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
if (m.getParameterCount() == 1) {
final Object response = m.invoke(cut, p);
final EntityManager v = verify(em);
m.invoke(v, p);
if (r != null)
assertEquals(r, response);
}
}
@ParameterizedTest
@MethodSource("twoParameterMethod")
void testOriginalIsCalledTwoParameter(final Method m, final Object p1, final Object p2, final Object r)
throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
if (m.getParameterCount() == 2) {
final Object response = m.invoke(cut, p1, p2);
final EntityManager v = verify(em);
m.invoke(v, p1, p2);
if (r != null)
assertEquals(r, response);
}
}
@ParameterizedTest
@MethodSource("notImplementedMethod")
void testThrowsNotImplemented(final Method m, final Object p1, final Object p2)
throws IllegalArgumentException {
Exception e = null;
if (m.getParameterCount() == 1) {
e = assertThrows(InvocationTargetException.class, () -> m.invoke(cut, p1));
} else if (m.getParameterCount() == 2) {
e = assertThrows(InvocationTargetException.class, () -> m.invoke(cut, p1, p2));
}
assertTrue(e.getCause() instanceof NotImplementedException);
}
@ParameterizedTest
@MethodSource("nParameterMethod")
void testOriginalIsCalledMoreParameter(final Method m, final Object p1, final Object p2, final Object p3,
final Object p4) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
if (m.getParameterCount() == 3) {
m.invoke(cut, p1, p2, p3);
final EntityManager v = verify(em);
m.invoke(v, p1, p2, p3);
} else if (m.getParameterCount() == 4) {
m.invoke(cut, p1, p2, p3, p4);
final EntityManager v = verify(em);
m.invoke(v, p1, p2, p3, p4);
}
}
@Test
void testGetCriteriaBuilderThrowsExceptionOnClosed() {
when(em.isOpen()).thenReturn(false);
assertThrows(IllegalStateException.class, () -> cut.getCriteriaBuilder());
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/PathImplTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/PathImplTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.params.provider.Arguments.arguments;
import static org.mockito.Mockito.mock;
import java.lang.reflect.Method;
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.From;
import jakarta.persistence.criteria.Path;
import jakarta.persistence.metamodel.MapAttribute;
import jakarta.persistence.metamodel.PluralAttribute;
import jakarta.persistence.metamodel.SingularAttribute;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEntityType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAPath;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.processor.core.testmodel.Organization;
class PathImplTest extends BuilderBaseTest {
private PathImpl<?> cut;
private JPAEntityType et;
protected From<Organization, Organization> root;
private AliasBuilder ab;
@SuppressWarnings("rawtypes")
static Stream<Arguments> notImplemented() throws NoSuchMethodException, SecurityException {
final Class<PathImpl> c = PathImpl.class;
return Stream.of(
arguments(c.getMethod("getModel")),
arguments(c.getMethod("type")),
arguments(c.getMethod("get", MapAttribute.class)),
arguments(c.getMethod("get", PluralAttribute.class)),
arguments(c.getMethod("get", SingularAttribute.class)));
}
@BeforeEach
void setup() throws ODataJPAModelException {
ab = new AliasBuilder();
et = sd.getEntity("Organizations");
final JPAPath path = et.getPath("Address/StreetName");
root = new FromImpl<>(et, ab, mock(CriteriaBuilder.class));
cut = new PathImpl<>(path, Optional.of((PathImpl<?>) root), et, Optional.empty());
}
@ParameterizedTest
@MethodSource("notImplemented")
void testThrowsNotImplemented(final Method m) throws IllegalAccessException, IllegalArgumentException {
testNotImplemented(m, cut);
}
@Test
void testCutNotNull() {
assertNotNull(cut);
}
@Test
void testToStringReturnsValue() {
assertNotNull(cut.toString());
assertTrue(cut.toString().startsWith("PathImpl [path="));
}
@Test
void testGetParentPath() {
assertNotNull(cut.getParentPath());
assertEquals(root, cut.getParentPath());
}
@Test
void testGetParentPathReturnsNullIfNotPresent() throws ODataJPAModelException {
final JPAPath path = et.getPath("Address/StreetName");
cut = new PathImpl<>(path, Optional.empty(), et, Optional.empty());
assertNull(cut.getParentPath());
}
@Test
void testGetPathList() {
final List<JPAPath> act = cut.getPathList();
assertFalse(act.isEmpty());
assertEquals("Address/StreetName", act.get(0).getAlias());
}
@Test
void testGetPathListThrowsExceptionOnMissingPath() {
cut = new PathImpl<>(Optional.empty(), Optional.of((PathImpl<?>) root), et, Optional.empty());
assertThrows(IllegalStateException.class, () -> cut.getPathList());
}
@Test
void testAsSqlReturnsDBFilesName() {
final StringBuilder act = new StringBuilder();
cut.asSQL(act);
assertEquals("E0.\"Address.StreetName\"", act.toString());
}
@Test
void testAsSqlReturnsDBFilesNameWithTableAlias() {
root.alias("t0");
final StringBuilder act = new StringBuilder();
cut.asSQL(act);
assertEquals("E0.\"Address.StreetName\"", act.toString());
}
@Test
void testGetReturnsComplexEmbedId() throws ODataJPAModelException {
et = sd.getEntity("AdministrativeDivisionDescriptions");
root = new FromImpl<>(et, ab, mock(CriteriaBuilder.class));
final Path<Object> act = root.get("key").get("language");
assertNotNull(act);
}
@Test
void testGetReturnsResolvedEmbeddedId() throws ODataJPAModelException {
et = sd.getEntity("AdministrativeDivisions");
root = new FromImpl<>(et, ab, mock(CriteriaBuilder.class));
final Path<Object> act = root.get("codePublisher");
assertNotNull(act);
}
@Test
void testGetThrowsExceptionOnPrimitive() throws ODataJPAModelException {
et = sd.getEntity("AdministrativeDivisions");
root = new FromImpl<>(et, ab, mock(CriteriaBuilder.class));
final Path<Object> publisher = root.get("codePublisher");
assertThrows(IllegalArgumentException.class, () -> publisher.get("unknown"));
}
@Test
void testGetThrowsExceptionOnUnKnownAttribute() throws ODataJPAModelException {
et = sd.getEntity("AdministrativeDivisions");
root = new FromImpl<>(et, ab, mock(CriteriaBuilder.class));
assertThrows(IllegalArgumentException.class, () -> root.get("unknown"));
}
@Test
void testEquals() throws ODataJPAModelException {
final JPAPath equalPath = et.getPath("Address/StreetName");
final JPAPath notEqualPath = et.getPath("Address/HouseNumber");
final PathImpl<Organization> other1 = new PathImpl<>(Optional.empty(), Optional.empty(), et, Optional.empty());
final PathImpl<Organization> other2 = new PathImpl<>(notEqualPath, Optional.empty(), et, Optional.empty());
final PathImpl<Organization> other3 = new PathImpl<>(equalPath, Optional.of((PathImpl<?>) root), et, Optional
.empty());
final PathImpl<Organization> other4 = new PathImpl<>(equalPath, Optional.empty(), et, Optional.of("E2"));
final PathImpl<Organization> other5 = new PathImpl<>(equalPath, Optional.empty(), et, Optional.empty());
assertFalse(cut.equals("Test")); // NOSONAR
assertNotEquals(other1, cut);
assertNotEquals(cut, other1);
assertNotEquals(other2, cut);
assertNotEquals(other4, cut);
assertNotEquals(other5, cut);
assertEquals(other1, other1);
assertEquals(cut, cut);
assertEquals(other3, cut);
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/ArithmeticExpressionTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/ArithmeticExpressionTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.mock;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.From;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEntityType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.processor.cb.impl.ExpressionImpl.ArithmeticExpression;
import com.sap.olingo.jpa.processor.core.testmodel.AdministrativeDivision;
class ArithmeticExpressionTest extends BuilderBaseTest {
private ExpressionImpl.ArithmeticExpression<Long> cut;
private From<AdministrativeDivision, AdministrativeDivision> root;
private PathImpl<Long> left;
private PathImpl<Long> right;
private JPAEntityType et;
private AliasBuilder ab;
private StringBuilder stmt;
@SuppressWarnings({ "unchecked", "rawtypes" })
@BeforeEach
public void setup() throws ODataJPAModelException {
ab = new AliasBuilder();
et = sd.getEntity(AdministrativeDivision.class);
root = new FromImpl<>(et, ab, mock(CriteriaBuilder.class));
left = (PathImpl) root.get("area");
right = (PathImpl) root.get("population");
stmt = new StringBuilder();
cut = new ArithmeticExpression<>(right, left, SqlArithmetic.QUOT);
}
@Test
void testAsSql() {
final String exp = "(E0.\"Population\" / E0.\"Area\")";
assertEquals(exp, cut.asSQL(stmt).toString());
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/ParameterExpressionImplTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/ParameterExpressionImplTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.DynamicTest.dynamicTest;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.Optional;
import java.util.stream.Stream;
import jakarta.persistence.AttributeConverter;
import jakarta.persistence.criteria.Expression;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestFactory;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAttribute;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEntityType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAPath;
import com.sap.olingo.jpa.processor.cb.impl.ExpressionImpl.ParameterExpression;
import com.sap.olingo.jpa.processor.core.testmodel.ABCClassification;
class ParameterExpressionImplTest {
private ParameterExpression<?, Object> cut;
@BeforeEach
void setup() {
cut = new ParameterExpression<>(10, "Value");
}
@Test
void testGetNameReturnsNull() {
assertEquals("10", cut.getName());
}
@Test
void testGetPosition() {
assertEquals(10, cut.getPosition());
}
@Test
void testGetParameterType() {
assertEquals(String.class, cut.getParameterType());
}
@Test
void testGetJavaType() {
assertEquals(String.class, cut.getJavaType());
}
@Test
void testAsSQL() {
final StringBuilder statement = new StringBuilder();
final String exp = "?10";
assertEquals(exp, cut.asSQL(statement).toString());
}
@Test
void testGetValue() {
assertEquals("Value", cut.getValue());
}
@Test
void testGetValueIsEnum() {
final JPAEntityType et = mock(JPAEntityType.class);
final JPAPath jpaPath = mock(JPAPath.class);
final JPAAttribute leaf = mock(JPAAttribute.class);
final PathImpl<?> path = new PathImpl<>(jpaPath, Optional.empty(), et, Optional.empty());
when(jpaPath.getLeaf()).thenReturn(leaf);
when(leaf.isEnum()).thenReturn(true);
cut = new ParameterExpression<>(10, ABCClassification.C);
cut.setPath(path);
assertEquals(2, cut.getValue());
}
@SuppressWarnings("unchecked")
@Test
void testGetValueWithConverter() {
final AttributeConverter<Object, Object> converter = mock(AttributeConverter.class);
final JPAEntityType et = mock(JPAEntityType.class);
final JPAPath pX = mock(JPAPath.class);
final JPAAttribute aX = mock(JPAAttribute.class);
final Expression<?> x = new PathImpl<>(pX, Optional.empty(), et, Optional.of("P1"));
when(pX.getLeaf()).thenReturn(aX);
when(aX.getConverter()).thenReturn(null);
when(aX.getRawConverter()).thenReturn(converter);
when(converter.convertToDatabaseColumn(any())).thenReturn("db");
cut = new ParameterExpression<>(2, "attribute", x);
assertEquals("db", cut.getValue());
}
@SuppressWarnings("unchecked")
@Test
void testGetValueHasConverterDifferentType() {
final JPAEntityType et = mock(JPAEntityType.class);
final JPAPath jpaPath = mock(JPAPath.class);
final JPAAttribute leaf = mock(JPAAttribute.class);
final AttributeConverter<Object, Object> converter = mock(AttributeConverter.class);
final PathImpl<?> path = new PathImpl<>(jpaPath, Optional.empty(), et, Optional.empty());
when(jpaPath.getLeaf()).thenReturn(leaf);
when(leaf.getConverter()).thenReturn(converter);
when(leaf.getRawConverter()).thenReturn(converter);
when(converter.convertToDatabaseColumn("Value")).thenReturn(Integer.valueOf(100));
cut.setPath(path);
assertEquals(100, cut.getValue());
}
@SuppressWarnings("unchecked")
@Test
void testGetValueHasConverterSameType() {
final JPAEntityType et = mock(JPAEntityType.class);
final JPAPath jpaPath = mock(JPAPath.class);
final JPAAttribute leaf = mock(JPAAttribute.class);
final AttributeConverter<Object, Object> converter = mock(AttributeConverter.class);
final PathImpl<?> path = new PathImpl<>(jpaPath, Optional.empty(), et, Optional.empty());
when(jpaPath.getLeaf()).thenReturn(leaf);
when(leaf.getConverter()).thenReturn(converter);
when(leaf.getRawConverter()).thenReturn(converter);
when(converter.convertToDatabaseColumn("Value")).thenReturn("eulaV");
cut.setPath(path);
assertEquals("eulaV", cut.getValue());
}
@TestFactory
Stream<DynamicTest> testIsEqual() {
final JPAEntityType et = mock(JPAEntityType.class);
final JPAPath pX = mock(JPAPath.class);
final JPAAttribute aX = mock(JPAAttribute.class);
final JPAPath pY = mock(JPAPath.class);
final JPAAttribute aY = mock(JPAAttribute.class);
when(pX.getLeaf()).thenReturn(aX);
when(pY.getLeaf()).thenReturn(aY);
final Expression<?> x = new PathImpl<>(pX, Optional.empty(), et, Optional.of("P1"));
final Expression<?> y = new PathImpl<>(pY, Optional.empty(), et, Optional.of("P2"));
cut.setPath(x);
return Stream.of(
dynamicTest("Not Equals a String", () -> assertNotEquals("A String", cut)),
dynamicTest("Not Equals other Value", () -> assertNotEquals(new ParameterExpression<>(2, "Value2", x), cut)),
dynamicTest("Not Equals other Path", () -> assertNotEquals(new ParameterExpression<>(2, "Value", y), cut)),
dynamicTest("Is Equal same Value and Path", () -> assertEquals(new ParameterExpression<>(2, "Value", x), cut)),
dynamicTest("Is Equal Self", () -> assertEquals(cut, cut)));
}
@Test
void testToStringContainsValue() {
assertTrue(cut.toString().contains("Value"));
}
@Test
void testHashCodeNotZero() {
assertNotEquals(0, cut.hashCode());
}
@Test
void testConstructorWithPath() {
final String pathString = "TestString";
final JPAEntityType et = mock(JPAEntityType.class);
final JPAPath pX = mock(JPAPath.class);
final JPAAttribute aX = mock(JPAAttribute.class);
final Expression<?> x = new PathImpl<>(pX, Optional.empty(), et, Optional.of("P1"));
when(pX.getLeaf()).thenReturn(aX);
when(pX.toString()).thenReturn(pathString);
cut = new ParameterExpression<>(2, "Value2", x);
assertTrue(cut.toString().contains(pathString));
}
@Test
void testConstructorWithExpression() {
final Expression<?> x = mock(Expression.class);
cut = new ParameterExpression<>(2, "Value2", x);
assertTrue(cut.toString().contains("jpaPath=Optional.empty"));
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/InheritanceJoinTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/InheritanceJoinTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import jakarta.persistence.Tuple;
import jakarta.persistence.criteria.JoinType;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEntityType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.processor.cb.ProcessorCriteriaQuery;
import com.sap.olingo.jpa.processor.cb.exceptions.InternalServerError;
import com.sap.olingo.jpa.processor.cb.exceptions.NotImplementedException;
import com.sap.olingo.jpa.processor.cb.joiner.SqlConvertible;
import com.sap.olingo.jpa.processor.core.testmodel.InheritanceByJoinAccount;
import com.sap.olingo.jpa.processor.core.testmodel.InheritanceByJoinCompoundSub;
import com.sap.olingo.jpa.processor.core.testmodel.InheritanceByJoinCompoundSuper;
import com.sap.olingo.jpa.processor.core.testmodel.InheritanceByJoinCurrentAccount;
class InheritanceJoinTest extends BuilderBaseTest {
private AliasBuilder aliasBuilder;
private CriteriaBuilderImpl cb;
private InheritanceJoin<InheritanceByJoinCurrentAccount, InheritanceByJoinAccount> cut;
@BeforeEach
void setup() throws ODataJPAModelException {
aliasBuilder = new AliasBuilder();
cb = new CriteriaBuilderImpl(sd, new SqlDefaultPattern());
final var et = sd.getEntity(InheritanceByJoinCurrentAccount.class);
final ProcessorCriteriaQuery<Tuple> query = cb.createTupleQuery();
cut = new InheritanceJoin<>(et, query.from(InheritanceByJoinCurrentAccount.class), aliasBuilder, cb);
}
@Test
void testGetJoinType() {
assertEquals(JoinType.INNER, cut.getJoinType());
}
@Test
void testGetAttributeNotImplemented() {
assertThrows(NotImplementedException.class, () -> cut.getAttribute());
}
@Test
void testGetOnThrowsInternalErrorOnException() throws ODataJPAModelException {
final ProcessorCriteriaQuery<Tuple> query = cb.createTupleQuery();
final JPAEntityType subType = mock(JPAEntityType.class);
final JPAEntityType superType = sd.getEntity(InheritanceByJoinAccount.class);
when(subType.getInheritanceInformation()).thenThrow(ODataJPAModelException.class);
when(subType.getBaseType()).thenReturn(superType);
cut = new InheritanceJoin<>(subType, query.from(InheritanceByJoinCurrentAccount.class), aliasBuilder, cb);
assertThrows(InternalServerError.class, () -> cut.getOn());
}
@Test
void testGetOnReturnsList() throws ODataJPAModelException {
final ProcessorCriteriaQuery<Tuple> query = cb.createTupleQuery();
final JPAEntityType subType = sd.getEntity(InheritanceByJoinCompoundSub.class);
InheritanceJoin<InheritanceByJoinCompoundSub, InheritanceByJoinCompoundSuper> join = new InheritanceJoin<>(subType,
query.from(InheritanceByJoinCompoundSub.class), aliasBuilder, cb);
var act = join.getOn();
assertNotNull(act);
var statement = new StringBuilder();
((SqlConvertible) act).asSQL(statement);
assertTrue(statement.toString().contains("E0.\"PartCode\" = E1.\"DivisionCode\""));
}
@Test
void testGetSuperTypeThrowsInternalErrorOnException() throws ODataJPAModelException {
final ProcessorCriteriaQuery<Tuple> query = cb.createTupleQuery();
final JPAEntityType subType = mock(JPAEntityType.class);
when(subType.getBaseType()).thenThrow(ODataJPAModelException.class);
assertThrows(InternalServerError.class, () -> new InheritanceJoin<>(subType, query.from(
InheritanceByJoinCurrentAccount.class), aliasBuilder, cb));
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/JoinTableJoinTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/JoinTableJoinTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import jakarta.persistence.Tuple;
import jakarta.persistence.criteria.JoinType;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAssociationPath;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.processor.cb.ProcessorCriteriaQuery;
import com.sap.olingo.jpa.processor.cb.ProcessorSqlPatternProvider;
import com.sap.olingo.jpa.processor.cb.exceptions.NotImplementedException;
import com.sap.olingo.jpa.processor.core.testmodel.Person;
import com.sap.olingo.jpa.processor.core.testmodel.Team;
class JoinTableJoinTest extends BuilderBaseTest {
private JoinTableJoin<Person, Team> cut;
private AliasBuilder ab;
private CriteriaBuilderImpl cb;
private ProcessorCriteriaQuery<Tuple> query;
private JPAAssociationPath path;
private ProcessorSqlPatternProvider sqlPattern;
@BeforeEach
void setup() throws ODataJPAModelException {
sqlPattern = new SqlDefaultPattern();
ab = new AliasBuilder();
cb = new CriteriaBuilderImpl(sd, sqlPattern);
query = cb.createTupleQuery();
path = sd.getEntity(Person.class).getAssociationPath("Teams");
cut = new JoinTableJoin<>(path, JoinType.LEFT, query.from(Person.class), ab, cb);
}
@Test
void testConstructor() {
assertNotNull(cut);
}
@Test
void testGetAttributeNotImplemented() {
assertThrows(NotImplementedException.class, () -> cut.getAttribute());
}
@Test
void testHashCode() {
assertNotEquals(0, cut.hashCode());
}
@Test
void testEquals() {
assertTrue(cut.equals(cut)); // NOSONAR
assertFalse(cut.equals(null)); // NOSONAR
}
@Test
void testJoinTypeInner() {
assertEquals(JoinType.INNER, cut.getJoinType());
}
@Test
void testGetParentReturnsInnerJoin() throws ODataJPAModelException {
final JoinTableJoin<Person, Team> other = new JoinTableJoin<>(path, JoinType.RIGHT, query.from(Person.class), ab,
cb);
final AbstractJoinImp<?, Person> act = (AbstractJoinImp<?, Person>) cut.getParent();
assertNotNull(act);
assertFalse(act.equals(cut)); // NOSONAR
assertTrue(act.equals(act)); // NOSONAR
assertFalse(act.equals(other.getParent())); // NOSONAR
assertNotEquals(0, act.hashCode());
assertThrows(NotImplementedException.class, () -> act.getAttribute());
assertEquals(JoinType.LEFT, act.getJoinType());
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/InheritanceInfoTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/InheritanceInfoTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import jakarta.persistence.InheritanceType;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEntityType;
import com.sap.olingo.jpa.processor.cb.testobjects.SubJoined;
import com.sap.olingo.jpa.processor.cb.testobjects.SubTablePerClass;
import com.sap.olingo.jpa.processor.core.testmodel.Organization;
class InheritanceInfoTest {
private InheritanceInfo cut;
private JPAEntityType et;
@BeforeEach
void setup() {
et = mock(JPAEntityType.class);
}
@Test
void testNoInheritance() {
doReturn(Long.class).when(et).getTypeClass();
cut = new InheritanceInfo(et);
assertFalse(cut.getBaseClass().isPresent());
}
@Test
void testDiscriminatorColumn() {
doReturn(Organization.class).when(et).getTypeClass();
cut = new InheritanceInfo(et);
assertTrue(cut.getBaseClass().isPresent());
assertEquals(InheritanceType.SINGLE_TABLE, cut.getInheritanceType().get());
assertEquals("\"Type\"", cut.getDiscriminatorColumn().get());
}
@Test
void testJoined() {
doReturn(SubJoined.class).when(et).getTypeClass();
cut = new InheritanceInfo(et);
assertTrue(cut.getBaseClass().isPresent());
assertEquals(InheritanceType.JOINED, cut.getInheritanceType().get());
assertFalse(cut.getDiscriminatorColumn().isPresent());
}
@Test
void testTablePerClass() {
doReturn(SubTablePerClass.class).when(et).getTypeClass();
cut = new InheritanceInfo(et);
assertTrue(cut.getBaseClass().isPresent());
assertEquals(InheritanceType.TABLE_PER_CLASS, cut.getInheritanceType().get());
assertFalse(cut.getDiscriminatorColumn().isPresent());
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/CriteriaBuilderDerbyTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/CriteriaBuilderDerbyTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.Arrays;
import javax.sql.DataSource;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.criteria.Expression;
import jakarta.persistence.criteria.Root;
import org.apache.olingo.commons.api.ex.ODataException;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.metadata.api.JPAEdmProvider;
import com.sap.olingo.jpa.metadata.api.JPAEntityManagerFactory;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAServiceDocument;
import com.sap.olingo.jpa.processor.cb.ProcessorSqlFunction;
import com.sap.olingo.jpa.processor.cb.ProcessorSqlOperator;
import com.sap.olingo.jpa.processor.cb.ProcessorSqlParameter;
import com.sap.olingo.jpa.processor.cb.ProcessorSqlPattern;
import com.sap.olingo.jpa.processor.cb.ProcessorSqlPatternProvider;
import com.sap.olingo.jpa.processor.cb.joiner.SqlConvertible;
import com.sap.olingo.jpa.processor.core.testmodel.DataSourceHelper;
import com.sap.olingo.jpa.processor.core.testmodel.Person;
class CriteriaBuilderDerbyTest extends CriteriaBuilderOverallTest {
private static final String PUNIT_NAME = "com.sap.olingo.jpa";
private static final String[] enumPackages = { "com.sap.olingo.jpa.processor.core.testmodel" };
private static EntityManagerFactory emf;
private static JPAServiceDocument sd;
private static JPAEdmProvider edmProvider;
private static DataSource ds;
@BeforeAll
static void classSetup() throws ODataException {
ds = DataSourceHelper.createDataSource(DataSourceHelper.DB_DERBY);
emf = JPAEntityManagerFactory.getEntityManagerFactory(PUNIT_NAME, ds);
edmProvider = new JPAEdmProvider(PUNIT_NAME, emf, null, enumPackages);
sd = edmProvider.getServiceDocument();
sd.getEdmEntityContainer();
}
@BeforeEach
void setup() {
super.setup(emf, sd, new SqlPattern());
}
@Override
@Test
void testSimpleConcatQuery() {
final Root<?> person = query.from(Person.class);
final Expression<String> concat = cb.concat(cb.concat(person.get("lastName"), ","), person.get("firstName"));
query.multiselect(person.get("iD"));
query.where(cb.equal(concat, "Mustermann,Max"));
((SqlConvertible) query).asSQL(statement);
assertEquals(
expectedQueryConcat(),
statement.toString().trim());
// Test need to be skipped, as the following error occurs:
// Internal Exception: java.sql.SQLSyntaxErrorException: Comparisons between 'LONG VARCHAR (UCS_BASIC)' and 'LONG
// VARCHAR (UCS_BASIC)' are not supported.
}
@Override
protected String expectedQueryLimitOffset() {
return "SELECT E0.\"ID\" S0 FROM \"OLINGO\".\"BusinessPartner\" E0 WHERE (E0.\"Type\" = ?1) OFFSET 1 ROWS FETCH NEXT 1 ROWS ONLY";
}
@Override
protected String expectedQuerySubstring() {
return "SELECT E0.\"CodeID\" S0 FROM \"OLINGO\".\"AdministrativeDivisionDescription\" E0 WHERE ((E0.\"LanguageISO\" = ?1) AND (LOWER(SUBSTR(E0.\"Name\", ?2, ?3)) = ?4))";
}
@Override
protected String expectedQueryConcat() {
return "SELECT E0.\"ID\" S0 FROM \"OLINGO\".\"BusinessPartner\" E0 WHERE ((((E0.\"NameLine2\" || ?1) || E0.\"NameLine1\") = ?2) AND (E0.\"Type\" = ?3))";
}
private static class SqlPattern implements ProcessorSqlPatternProvider {
@Override
public ProcessorSqlPattern getConcatenatePattern() {
return new ProcessorSqlOperator(Arrays.asList(
new ProcessorSqlParameter(VALUE_PLACEHOLDER, false),
new ProcessorSqlParameter(" || ", VALUE_PLACEHOLDER, false)));
}
@Override
public ProcessorSqlFunction getSubStringPattern() {
return new ProcessorSqlFunction("SUBSTR", Arrays.asList(
new ProcessorSqlParameter(VALUE_PLACEHOLDER, false),
new ProcessorSqlParameter(COMMA_SEPARATOR, START_PLACEHOLDER, false),
new ProcessorSqlParameter(COMMA_SEPARATOR, LENGTH_PLACEHOLDER, true)));
}
@Override
public String getMaxResultsPattern() {
return "FETCH NEXT #VALUE# ROWS ONLY";
}
@Override
public String getFirstResultPattern() {
return "OFFSET #VALUE# ROWS";
}
@Override
public boolean maxResultsFirst() {
return false;
}
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/AliasBuilderTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/AliasBuilderTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
class AliasBuilderTest {
private AliasBuilder cut;
@BeforeEach
void setup() {
cut = new AliasBuilder();
}
@Test
void getFirstAlias() {
assertEquals("E0", cut.getNext());
}
@Test
void getSecondAlias() {
cut.getNext();
assertEquals("E1", cut.getNext());
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/FromImplTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/FromImplTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.params.provider.Arguments.arguments;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;
import jakarta.persistence.InheritanceType;
import jakarta.persistence.criteria.Expression;
import jakarta.persistence.criteria.From;
import jakarta.persistence.criteria.Join;
import jakarta.persistence.criteria.JoinType;
import jakarta.persistence.criteria.Path;
import jakarta.persistence.criteria.Predicate;
import jakarta.persistence.metamodel.CollectionAttribute;
import jakarta.persistence.metamodel.ListAttribute;
import jakarta.persistence.metamodel.MapAttribute;
import jakarta.persistence.metamodel.PluralAttribute;
import jakarta.persistence.metamodel.SetAttribute;
import jakarta.persistence.metamodel.SingularAttribute;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEntityType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.processor.cb.exceptions.InternalServerError;
import com.sap.olingo.jpa.processor.cb.exceptions.NotImplementedException;
import com.sap.olingo.jpa.processor.cb.joiner.SqlConvertible;
import com.sap.olingo.jpa.processor.core.testmodel.BusinessPartner;
import com.sap.olingo.jpa.processor.core.testmodel.CurrentUser;
import com.sap.olingo.jpa.processor.core.testmodel.InheritanceByJoinAccount;
import com.sap.olingo.jpa.processor.core.testmodel.InheritanceByJoinCompoundSub;
import com.sap.olingo.jpa.processor.core.testmodel.InheritanceByJoinCurrentAccount;
import com.sap.olingo.jpa.processor.core.testmodel.InheritanceByJoinLockedSavingAccount;
import com.sap.olingo.jpa.processor.core.testmodel.InheritanceByJoinSavingAccount;
import com.sap.olingo.jpa.processor.core.testmodel.Organization;
import com.sap.olingo.jpa.processor.core.testmodel.Person;
class FromImplTest extends BuilderBaseTest {
private From<Organization, Organization> cut;
private AliasBuilder ab;
private CriteriaBuilderImpl cb;
@SuppressWarnings("rawtypes")
static Stream<Arguments> notImplemented() throws NoSuchMethodException, SecurityException {
final Class<FromImpl> clazz = FromImpl.class;
return Stream.of(
arguments(clazz.getMethod("fetch", String.class)),
arguments(clazz.getMethod("fetch", String.class, JoinType.class)),
arguments(clazz.getMethod("fetch", SingularAttribute.class)),
arguments(clazz.getMethod("fetch", SingularAttribute.class, JoinType.class)),
arguments(clazz.getMethod("fetch", PluralAttribute.class)),
arguments(clazz.getMethod("fetch", PluralAttribute.class, JoinType.class)),
arguments(clazz.getMethod("join", SetAttribute.class)),
arguments(clazz.getMethod("join", SetAttribute.class, JoinType.class)),
arguments(clazz.getMethod("join", MapAttribute.class)),
arguments(clazz.getMethod("join", MapAttribute.class, JoinType.class)),
arguments(clazz.getMethod("join", ListAttribute.class)),
arguments(clazz.getMethod("join", ListAttribute.class, JoinType.class)),
arguments(clazz.getMethod("join", CollectionAttribute.class)),
arguments(clazz.getMethod("join", CollectionAttribute.class, JoinType.class)),
arguments(clazz.getMethod("join", SingularAttribute.class, JoinType.class)),
arguments(clazz.getMethod("joinCollection", String.class)),
arguments(clazz.getMethod("joinCollection", String.class, JoinType.class)),
arguments(clazz.getMethod("joinSet", String.class)),
arguments(clazz.getMethod("joinSet", String.class, JoinType.class)),
arguments(clazz.getMethod("joinMap", String.class)),
arguments(clazz.getMethod("joinMap", String.class, JoinType.class)),
arguments(clazz.getMethod("joinList", String.class)),
arguments(clazz.getMethod("joinList", String.class, JoinType.class)),
arguments(clazz.getMethod("join", SingularAttribute.class)),
arguments(clazz.getMethod("isCorrelated")),
arguments(clazz.getMethod("getCorrelationParent")));
}
@BeforeEach
void setup() throws ODataJPAModelException {
final JPAEntityType et = sd.getEntity(Organization.class);
cb = mock(CriteriaBuilderImpl.class);
ab = new AliasBuilder();
when(cb.getServiceDocument()).thenReturn(sd);
cut = new FromImpl<>(et, ab, cb);
}
@Test
void testCutNotNull() {
assertNotNull(cut);
}
@Test
void testAsSqlReturnsDBTableNameWithoutAlias() {
final StringBuilder act = new StringBuilder();
((SqlConvertible) cut).asSQL(act);
assertEquals("\"OLINGO\".\"BusinessPartner\" E0", act.toString());
}
@Test
void testAsSqlReturnsDBTableNameWithAlias() {
final StringBuilder act = new StringBuilder();
cut.alias("t0");
((SqlConvertible) cut).asSQL(act);
assertEquals("\"OLINGO\".\"BusinessPartner\" E0", act.toString());
}
@Test
void testGetByNameReturnsPathToAttribute() {
final Path<String> act = cut.get("iD");
assertNotNull(act);
}
@ParameterizedTest
@MethodSource("notImplemented")
void testThrowsNotImplemented(final Method method) throws IllegalArgumentException {
InvocationTargetException exception;
if (method.getParameterCount() >= 1) {
final Class<?>[] params = method.getParameterTypes();
final List<Object> paramValues = new ArrayList<>(method.getParameterCount());
for (int i = 0; i < method.getParameterCount(); i++) {
if (params[i] == char.class)
paramValues.add(' ');
else
paramValues.add(null);
}
exception = assertThrows(InvocationTargetException.class, () -> method.invoke(cut, paramValues.toArray()));
} else {
exception = assertThrows(InvocationTargetException.class, () -> method.invoke(cut));
}
assertTrue(exception.getCause() instanceof NotImplementedException);
}
@Test
void testCreateJoinByNavigationAttributeName() {
final String exp =
"\"OLINGO\".\"BusinessPartner\" E0 INNER JOIN \"OLINGO\".\"BusinessPartnerRole\" E1 ON (E0.\"ID\" = E1.\"BusinessPartnerID\")";
final StringBuilder statement = new StringBuilder();
final Join<?, ?> act = cut.join("roles");
assertNotNull(act);
assertEquals(1, cut.getJoins().size());
assertTrue(cut.getJoins().contains(act));
((SqlConvertible) cut).asSQL(statement);
assertEquals(exp, statement.toString());
}
@Test
void testCreateJoinByComplexAttributeName() {
final String exp = "\"OLINGO\".\"BusinessPartner\" E0";
final StringBuilder statement = new StringBuilder();
final Join<?, ?> act = cut.join("address");
assertNotNull(act);
assertEquals(1, cut.getJoins().size());
((SqlConvertible) cut).asSQL(statement);
assertEquals(exp, statement.toString());
}
@Test
void testCreateJoinByDescriptionAttributeName() {
final String exp =
"""
"OLINGO"."BusinessPartner" E0 \
LEFT OUTER JOIN "OLINGO"."AdministrativeDivisionDescription" E1 \
ON (E0."Country" = E1."DivisionCode")""";
final StringBuilder statement = new StringBuilder();
final Join<?, ?> act = cut.join("locationName");
assertNotNull(act);
assertEquals(1, cut.getJoins().size());
((SqlConvertible) cut).asSQL(statement);
assertEquals(exp, statement.toString());
}
@Test
void testCreateJoinByDescriptionViaComplexAttributeName() {
final String exp =
"""
"OLINGO"."BusinessPartner" E0 \
LEFT OUTER JOIN "OLINGO"."CountryDescription" E2 \
ON (E0."Address.Country" = E2."ISOCode")""";
final StringBuilder statement = new StringBuilder();
final Join<?, ?> act = cut.join("address").join("countryName");
assertNotNull(act);
assertEquals(1, cut.getJoins().size());
((SqlConvertible) cut).asSQL(statement);
assertEquals(exp, statement.toString());
}
// "Organizations?$select=Name1&$filter=SupportEngineers/any(d:d/LastName eq 'Doe')");
@Test
void testCreateJoinViaJoinTable() {
final String exp =
"""
"OLINGO"."BusinessPartner" E0 \
INNER JOIN ("OLINGO"."SupportRelationship" E1 \
INNER JOIN "OLINGO"."BusinessPartner" E2 \
ON (E1."PersonID" = E2."ID")) \
ON (E0."ID" = E1."OrganizationID")""";
final StringBuilder statement = new StringBuilder();
final Join<?, ?> act = cut.join("supportEngineers");
assertNotNull(act);
assertEquals(1, cut.getJoins().size());
((SqlConvertible) cut).asSQL(statement);
assertEquals(exp, statement.toString());
}
@Test
void testCreateJoinByCollectionAttributeName() {
final String exp =
"""
"OLINGO"."BusinessPartner" E0 \
INNER JOIN "OLINGO"."Comment" E1 \
ON (E0."ID" = E1."BusinessPartnerID")""";
final StringBuilder statement = new StringBuilder();
final Join<?, ?> act = cut.join("comment");
assertNotNull(act);
assertEquals(1, cut.getJoins().size());
((SqlConvertible) cut).asSQL(statement);
assertEquals(exp, statement.toString());
}
@Test
void testCreateLeftJoinByCollectionAttributeName() {
final String exp =
"""
"OLINGO"."BusinessPartner" E0 \
LEFT OUTER JOIN "OLINGO"."Comment" E1 \
ON (E0."ID" = E1."BusinessPartnerID")""";
final StringBuilder statement = new StringBuilder();
final Join<?, ?> act = cut.join("comment", JoinType.LEFT);
assertNotNull(act);
assertEquals(1, cut.getJoins().size());
((SqlConvertible) cut).asSQL(statement);
assertEquals(exp, statement.toString());
}
@Test
void testGetJavaType() {
assertEquals(Organization.class, cut.getJavaType());
}
@Test
void testAsWithSuperType() {
assertNotNull(cut.as(BusinessPartner.class));
}
@Test
void testAsWithSubType() throws ODataJPAModelException {
final JPAEntityType et = sd.getEntity(BusinessPartner.class);
cut = new FromImpl<>(et, ab, cb);
final Expression<Organization> act = cut.as(Organization.class);
assertNotNull(act);
}
@Test
void testGetInheritanceTypeSingleTable() {
assertEquals(InheritanceType.SINGLE_TABLE, ((FromImpl<Organization, Organization>) cut).getInheritanceType().get());
}
@Test
void testGetInheritanceTypeMultiLevelSingleTable() throws ODataJPAModelException {
final JPAEntityType type = sd.getEntity(CurrentUser.class);
final FromImpl<CurrentUser, CurrentUser> from = new FromImpl<>(type, ab, cb);
assertEquals(InheritanceType.SINGLE_TABLE, from.getInheritanceType().get());
}
@Test
void testGetInheritanceTypeJoined() throws ODataJPAModelException {
final JPAEntityType type = sd.getEntity(InheritanceByJoinCurrentAccount.class);
final FromImpl<CurrentUser, CurrentUser> from = new FromImpl<>(type, ab, cb);
assertEquals(InheritanceType.JOINED, from.getInheritanceType().get());
}
@Test
void testGetInheritanceTypeMultiLevelJoined() throws ODataJPAModelException {
final JPAEntityType type = sd.getEntity(InheritanceByJoinLockedSavingAccount.class);
final FromImpl<CurrentUser, CurrentUser> from = new FromImpl<>(type, ab, cb);
assertEquals(InheritanceType.JOINED, from.getInheritanceType().get());
}
@Test
void testGetInheritanceJoinedAsSql() throws ODataJPAModelException {
final JPAEntityType type = sd.getEntity(InheritanceByJoinCurrentAccount.class);
final FromImpl<CurrentUser, CurrentUser> from = new FromImpl<>(type, ab, cb);
var statement = new StringBuilder();
from.asSQL(statement);
assertTrue(statement.toString().contains("INNER JOIN"));
}
@Test
void testGetInheritanceJoinedWhere() throws ODataJPAModelException {
final Predicate exp = mock(Predicate.class);
final JPAEntityType type = sd.getEntity(InheritanceByJoinCurrentAccount.class);
final FromImpl<CurrentUser, CurrentUser> from = new FromImpl<>(type, ab, cb);
when(cb.equal(any(PathImpl.class), any(String.class))).thenReturn(exp);
assertNull(from.createInheritanceWhere());
}
@Test
void testGetInheritanceJoinedWhereNullOnIntermediate() throws ODataJPAModelException {
final JPAEntityType type = sd.getEntity(InheritanceByJoinLockedSavingAccount.class);
final FromImpl<CurrentUser, CurrentUser> from = new FromImpl<>(type, ab, cb);
assertTrue(from.getInheritanceJoin().isPresent());
var act = from.getInheritanceJoin().get();
assertNull(act.createInheritanceWhere());
}
@Test
void testGetInheritanceJoinedWhereNullDiscriminatorColumnNotFound() throws ODataJPAModelException {
final JPAEntityType type = sd.getEntity(InheritanceByJoinCompoundSub.class);
final FromImpl<CurrentUser, CurrentUser> from = new FromImpl<>(type, ab, cb);
assertNull(from.createInheritanceWhere());
}
@Test
void testGetInheritanceJoinedGetAlias() throws ODataJPAModelException {
final JPAEntityType type = sd.getEntity(InheritanceByJoinLockedSavingAccount.class);
final JPAEntityType parentType = sd.getEntity(InheritanceByJoinSavingAccount.class);
final JPAEntityType grandParentType = sd.getEntity(InheritanceByJoinAccount.class);
final FromImpl<CurrentUser, CurrentUser> from = new FromImpl<>(type, ab, cb);
final var parent = from.getInheritanceJoin().get();
final var grandParent = parent.getInheritanceJoin().get();
var id = type.getKeyPath().get(0);
assertEquals(from.tableAlias, from.getAlias(id));
var parentId = parentType.getKeyPath().get(0);
assertEquals(parent.tableAlias, parent.getAlias(parentId));
var grandParentId = grandParentType.getKeyPath().get(0);
assertEquals(grandParent.tableAlias, grandParent.getAlias(grandParentId));
var typePath = type.getPath("Type");
assertEquals(grandParent.tableAlias, from.getAlias(typePath));
var ratePath = type.getPath("InterestRate");
assertEquals(parent.tableAlias, from.getAlias(ratePath));
}
@Test
void testGetInheritanceJoinedGetAliasThrowsExceptionOnModelException() throws ODataJPAModelException {
final JPAEntityType type = spy(sd.getEntity(InheritanceByJoinSavingAccount.class));
when(type.getDeclaredAttribute(anyString())).thenThrow(ODataJPAModelException.class);
final FromImpl<CurrentUser, CurrentUser> from = new FromImpl<>(type, ab, cb);
var ratePath = type.getPath("InterestRate");
assertThrows(InternalServerError.class, () -> from.getAlias(ratePath));
}
@Test
void testAsUnknownTypeThrowsException() {
assertThrows(IllegalArgumentException.class, () -> cut.as(Integer.class));
}
@Test
void testAsRethrowsModelException() throws ODataJPAModelException {
when(sd.getEntity(Person.class)).thenThrow(ODataJPAModelException.class);
assertThrows(IllegalArgumentException.class, () -> cut.as(Person.class));
}
@Test
void testJoinThrowsExceptionOnUnknownAttribute() {
assertThrows(IllegalArgumentException.class, () -> cut.join("dummy"));
}
@Test
void testGetFetchesReturnsEmpty() {
assertEquals(0, cut.getFetches().size());
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/ExpressionPathTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/impl/ExpressionPathTest.java | package com.sap.olingo.jpa.processor.cb.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.params.provider.Arguments.arguments;
import java.lang.reflect.Method;
import java.util.Optional;
import java.util.stream.Stream;
import jakarta.persistence.metamodel.MapAttribute;
import jakarta.persistence.metamodel.PluralAttribute;
import jakarta.persistence.metamodel.SingularAttribute;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import com.sap.olingo.jpa.processor.cb.impl.ExpressionImpl.ExpressionPath;
class ExpressionPathTest extends BuilderBaseTest {
private Optional<String> name;
private String tableAlias;
private StringBuilder stmt;
private ExpressionPath<Long> cut;
@SuppressWarnings("rawtypes")
static Stream<Arguments> notImplemented() throws NoSuchMethodException, SecurityException {
final Class<ExpressionPath> c = ExpressionPath.class;
return Stream.of(
arguments(c.getMethod("getModel")),
arguments(c.getMethod("getParentPath")),
arguments(c.getMethod("get", SingularAttribute.class)),
arguments(c.getMethod("get", PluralAttribute.class)),
arguments(c.getMethod("get", MapAttribute.class)),
arguments(c.getMethod("get", String.class)),
arguments(c.getMethod("type")));
}
@BeforeEach
void setup() {
name = Optional.of("area");
tableAlias = "X2";
stmt = new StringBuilder();
cut = new ExpressionPath<>(name, tableAlias);
}
@ParameterizedTest
@MethodSource("notImplemented")
void testThrowsNotImplemented(final Method m) throws IllegalAccessException, IllegalArgumentException {
testNotImplemented(m, cut);
}
@Test
void testAsSql() {
final String exp = "X2.area";
assertEquals(exp, cut.asSQL(stmt).toString());
}
@Test
void testAsSqlThrowsExceptionOnMissingName() {
name = Optional.empty();
cut = new ExpressionPath<>(name, tableAlias);
assertThrows(IllegalStateException.class, () -> cut.asSQL(stmt));
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/api/EntityManagerFactoryWrapperTest.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/api/EntityManagerFactoryWrapperTest.java | package com.sap.olingo.jpa.processor.cb.api;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.params.provider.Arguments.arguments;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Stream;
import jakarta.persistence.Cache;
import jakarta.persistence.EntityGraph;
import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.PersistenceUnitUtil;
import jakarta.persistence.Query;
import jakarta.persistence.SynchronizationType;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.metamodel.Metamodel;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAServiceDocument;
import com.sap.olingo.jpa.processor.cb.impl.EntityManagerWrapper;
class EntityManagerFactoryWrapperTest {
private EntityManagerFactoryWrapper cut;
private static EntityManagerFactory emf;
private static EntityManager em;
private JPAServiceDocument sd;
private static Metamodel metamodel;
private static Map<String, Object> properties;
private static Cache cache;
private static PersistenceUnitUtil punitUtil;
@BeforeAll
static void classSetup() {
emf = mock(EntityManagerFactory.class);
em = mock(EntityManager.class);
metamodel = mock(Metamodel.class);
properties = new HashMap<>();
cache = mock(Cache.class);
punitUtil = mock(PersistenceUnitUtil.class);
when(emf.createEntityManager()).thenReturn(em);
when(emf.getMetamodel()).thenReturn(metamodel);
when(emf.isOpen()).thenReturn(true);
when(emf.getProperties()).thenReturn(properties);
when(emf.getCache()).thenReturn(cache);
when(emf.getPersistenceUnitUtil()).thenReturn(punitUtil);
when(emf.unwrap(EntityManagerFactory.class)).thenReturn(emf);
when(em.isOpen()).thenReturn(true);
}
@BeforeEach
void setup() {
sd = mock(JPAServiceDocument.class);
cut = new EntityManagerFactoryWrapper(emf, sd, null);
}
static Stream<Arguments> method() throws NoSuchMethodException, SecurityException {
final Class<EntityManagerFactory> clazz = EntityManagerFactory.class;
final EntityGraph<?> entityGraph = mock(EntityGraph.class);
final Query query = mock(Query.class);
final String dummy = "Test";
return Stream.of(
arguments(clazz.getMethod("getMetamodel"), dummy, dummy, metamodel),
arguments(clazz.getMethod("isOpen"), dummy, dummy, Boolean.TRUE),
arguments(clazz.getMethod("close"), dummy, dummy, null),
arguments(clazz.getMethod("getProperties"), dummy, dummy, properties),
arguments(clazz.getMethod("getCache"), dummy, dummy, cache),
arguments(clazz.getMethod("unwrap", Class.class), clazz, dummy, emf),
arguments(clazz.getMethod("getPersistenceUnitUtil"), dummy, dummy, punitUtil),
arguments(clazz.getMethod("addNamedQuery", String.class, Query.class), dummy, query, null),
arguments(clazz.getMethod("addNamedEntityGraph", String.class, EntityGraph.class), dummy, entityGraph, null));
}
static Stream<Arguments> emWrapperMethod() throws NoSuchMethodException, SecurityException {
final Class<EntityManagerFactory> clazz = EntityManagerFactory.class;
final String dummy = "Test";
return Stream.of(
arguments(clazz.getMethod("createEntityManager"), dummy, dummy),
arguments(clazz.getMethod("createEntityManager", Map.class), new HashMap<>(), dummy),
arguments(clazz.getMethod("createEntityManager", SynchronizationType.class), SynchronizationType.SYNCHRONIZED,
dummy),
arguments(clazz.getMethod("createEntityManager", SynchronizationType.class, Map.class),
SynchronizationType.SYNCHRONIZED, new HashMap<>()));
}
@ParameterizedTest
@MethodSource("method")
void testOriginalCalled(final Method method, final Object p1, final Object p2, final Object ret)
throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
Object result = null;
if (method.getParameterCount() == 0) {
result = method.invoke(cut);
final EntityManagerFactory v = verify(emf);
method.invoke(v);
} else if (method.getParameterCount() == 1) {
result = method.invoke(cut, p1);
final EntityManagerFactory v = verify(emf);
method.invoke(v, p1);
} else if (method.getParameterCount() == 2) {
result = method.invoke(cut, p1, p2);
final EntityManagerFactory v = verify(emf);
method.invoke(v, p1, p2);
}
if (ret != null) {
assertEquals(ret, result);
}
}
@ParameterizedTest
@MethodSource("emWrapperMethod")
void testEmWrapperCreated(final Method method, final Object p1, final Object p2)
throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
Object result = null;
if (method.getParameterCount() == 0) {
result = method.invoke(cut);
} else if (method.getParameterCount() == 1) {
result = method.invoke(cut, p1);
} else if (method.getParameterCount() == 2) {
result = method.invoke(cut, p1, p2);
}
assertTrue(result instanceof EntityManagerWrapper);
}
@Test
void testCbWrapperCreated() {
assertTrue(cut.getCriteriaBuilder() instanceof CriteriaBuilder);
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/testobjects/UserType.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/testobjects/UserType.java | package com.sap.olingo.jpa.processor.cb.testobjects;
public enum UserType {
BATCH, INTERACTIVE;
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/testobjects/SuperTablePerClass.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/testobjects/SuperTablePerClass.java | package com.sap.olingo.jpa.processor.cb.testobjects;
import jakarta.persistence.Entity;
import jakarta.persistence.Inheritance;
import jakarta.persistence.InheritanceType;
@Entity(name = "Super")
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
public class SuperTablePerClass {
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/testobjects/SubJoined.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/testobjects/SubJoined.java | package com.sap.olingo.jpa.processor.cb.testobjects;
import jakarta.persistence.PrimaryKeyJoinColumn;
@PrimaryKeyJoinColumn(name = "\"Key1\"", referencedColumnName = "\"Value1\"")
public class SubJoined extends SuperJoined {
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/testobjects/SuperJoined.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/testobjects/SuperJoined.java | package com.sap.olingo.jpa.processor.cb.testobjects;
import jakarta.persistence.Entity;
import jakarta.persistence.Inheritance;
import jakarta.persistence.InheritanceType;
@Entity(name = "Super")
@Inheritance(strategy = InheritanceType.JOINED)
public class SuperJoined {
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/testobjects/SubTablePerClass.java | jpa/odata-jpa-processor-cb/src/test/java/com/sap/olingo/jpa/processor/cb/testobjects/SubTablePerClass.java | package com.sap.olingo.jpa.processor.cb.testobjects;
public class SubTablePerClass extends SuperTablePerClass {
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/main/java/com/sap/olingo/jpa/processor/cb/exceptions/InternalServerError.java | jpa/odata-jpa-processor-cb/src/main/java/com/sap/olingo/jpa/processor/cb/exceptions/InternalServerError.java | package com.sap.olingo.jpa.processor.cb.exceptions;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
public class InternalServerError extends RuntimeException {
private static final long serialVersionUID = -2239224331308130011L;
public InternalServerError(ODataJPAModelException e) {
super(e);
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-processor-cb/src/main/java/com/sap/olingo/jpa/processor/cb/exceptions/SqlParameterException.java | jpa/odata-jpa-processor-cb/src/main/java/com/sap/olingo/jpa/processor/cb/exceptions/SqlParameterException.java | package com.sap.olingo.jpa.processor.cb.exceptions;
public class SqlParameterException extends RuntimeException {
/**
*
*/
private static final long serialVersionUID = 3404311627671683055L;
public SqlParameterException(final String message) {
super(message);
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.