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-processor/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAODataDefaultTransactionFactoryTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAODataDefaultTransactionFactoryTest.java | package com.sap.olingo.jpa.processor.core.api;
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.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityTransaction;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.processor.core.api.JPAODataTransactionFactory.JPAODataTransaction;
import com.sap.olingo.jpa.processor.core.exception.ODataJPATransactionException;
class JPAODataDefaultTransactionFactoryTest {
private JPAODataDefaultTransactionFactory cut;
private EntityManager em;
private EntityTransaction transaction;
@BeforeEach
void setup() {
em = mock(EntityManager.class);
transaction = mock(EntityTransaction.class);
when(em.getTransaction()).thenReturn(transaction);
}
@Test
void testCreateFactory() {
cut = new JPAODataDefaultTransactionFactory(em);
assertNotNull(cut);
}
@Test
void testCreateTransaction() throws ODataJPATransactionException {
cut = new JPAODataDefaultTransactionFactory(em);
assertNotNull(cut.createTransaction());
}
@Test
void testCreateTransactionThrowsExceptionIfActive() throws ODataJPATransactionException {
when(transaction.isActive()).thenReturn(true);
cut = new JPAODataDefaultTransactionFactory(em);
cut.createTransaction();
assertThrows(ODataJPATransactionException.class, () -> cut.createTransaction());
}
@Test
void testCreateTransactionThrowsExceptionIfActiveThrows() throws ODataJPATransactionException {
when(transaction.isActive()).thenThrow(IllegalStateException.class);
cut = new JPAODataDefaultTransactionFactory(em);
cut.createTransaction();
assertThrows(ODataJPATransactionException.class, () -> cut.createTransaction());
}
@Test
void testCreateTransactionCreateNewTransactionIfOldNotActive() throws ODataJPATransactionException {
when(transaction.isActive()).thenReturn(false);
cut = new JPAODataDefaultTransactionFactory(em);
cut.createTransaction();
assertNotNull(cut.createTransaction());
}
@Test
void testIsActiveReturnFalseIfNoTransactionHasBeenCreated() {
cut = new JPAODataDefaultTransactionFactory(em);
assertFalse(cut.hasActiveTransaction());
}
@Test
void testIsActiveReturnTrueIfTransactionHasBeenCreated() throws ODataJPATransactionException {
when(transaction.isActive()).thenReturn(true);
cut = new JPAODataDefaultTransactionFactory(em);
cut.createTransaction();
assertTrue(cut.hasActiveTransaction());
}
@Test
void testIsActiveReturnTrueIfTransactionIsActive() throws ODataJPATransactionException {
when(transaction.isActive()).thenReturn(true);
cut = new JPAODataDefaultTransactionFactory(em);
cut.createTransaction();
assertTrue(cut.hasActiveTransaction());
}
@Test
void testIsActiveReturnFalseIfTransactionIsNotActive() throws ODataJPATransactionException {
when(transaction.isActive()).thenReturn(false);
cut = new JPAODataDefaultTransactionFactory(em);
cut.createTransaction();
assertFalse(cut.hasActiveTransaction());
}
@Test
void testIsActiveReturnTrueIfTransactionThrowsException() throws ODataJPATransactionException {
when(transaction.isActive()).thenThrow(IllegalStateException.class);
cut = new JPAODataDefaultTransactionFactory(em);
cut.createTransaction();
assertTrue(cut.hasActiveTransaction());
}
@Test
void testIsActiveReturnTrueNotCreatedButActiveTransactionThrowsException() {
when(transaction.isActive()).thenReturn(true);
cut = new JPAODataDefaultTransactionFactory(em);
assertTrue(cut.hasActiveTransaction());
}
@Test
void testCommitIsCalled() throws ODataJPATransactionException {
cut = new JPAODataDefaultTransactionFactory(em);
final JPAODataTransaction act = cut.createTransaction();
act.commit();
verify(transaction, times(1)).commit();
}
@Test
void testCommitRethrowsException() throws ODataJPATransactionException {
when(em.getTransaction()).thenReturn(transaction);
doThrow(RuntimeException.class).when(transaction).commit();
cut = new JPAODataDefaultTransactionFactory(em);
final JPAODataTransaction act = cut.createTransaction();
assertThrows(ODataJPATransactionException.class, act::commit);
}
@Test
void testRollbackIsCalled() throws ODataJPATransactionException {
when(em.getTransaction()).thenReturn(transaction);
cut = new JPAODataDefaultTransactionFactory(em);
final JPAODataTransaction act = cut.createTransaction();
act.rollback();
verify(transaction, times(1)).rollback();
}
@Test
void testRollbackRethrowsException() throws ODataJPATransactionException {
when(em.getTransaction()).thenReturn(transaction);
doThrow(RuntimeException.class).when(transaction).rollback();
cut = new JPAODataDefaultTransactionFactory(em);
final JPAODataTransaction act = cut.createTransaction();
assertThrows(ODataJPATransactionException.class, act::rollback);
}
@Test
void testRollbackOnlyIsCalled() throws ODataJPATransactionException {
when(em.getTransaction()).thenReturn(transaction);
cut = new JPAODataDefaultTransactionFactory(em);
final JPAODataTransaction act = cut.createTransaction();
act.rollbackOnly();
verify(transaction, times(1)).getRollbackOnly();
}
@Test
void testRollbackOnlyRethrowsException() throws ODataJPATransactionException {
when(em.getTransaction()).thenReturn(transaction);
when(transaction.getRollbackOnly()).thenThrow(RuntimeException.class);
cut = new JPAODataDefaultTransactionFactory(em);
final JPAODataTransaction act = cut.createTransaction();
assertThrows(ODataJPATransactionException.class, act::rollbackOnly);
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/api/JPADefaultErrorProcessorTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/api/JPADefaultErrorProcessorTest.java | package com.sap.olingo.jpa.processor.core.api;
import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
import static org.mockito.Mockito.mock;
import org.apache.olingo.commons.api.format.ContentType;
import org.apache.olingo.server.api.OData;
import org.apache.olingo.server.api.ODataResponse;
import org.apache.olingo.server.api.ODataServerError;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
class JPADefaultErrorProcessorTest {
private JPADefaultErrorProcessor cut;
@BeforeEach
void setup() {
cut = new JPADefaultErrorProcessor();
}
@Test
void testInitDoesNotThrowException() {
assertDoesNotThrow(() -> cut.init(null, null));
}
@Test
void testProcessErrorDoesNotThrowException() {
final ODataServerError error = mock(ODataServerError.class);
final ODataResponse response = mock(ODataResponse.class);
cut.init(OData.newInstance(), null);
assertDoesNotThrow(() -> cut.processError(null, response, error, ContentType.JSON));
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAODataClaimProviderTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAODataClaimProviderTest.java | package com.sap.olingo.jpa.processor.core.api;
import static org.junit.jupiter.api.Assertions.assertFalse;
import java.util.List;
import java.util.Optional;
import org.junit.jupiter.api.Test;
class JPAODataClaimProviderTest {
@Test
void testDefaultImplementationsReturnsEmpty() {
final JPAODataClaimProvider cut = new DummyImpl();
final Optional<String> act = cut.user();
assertFalse(act.isPresent());
}
private static class DummyImpl implements JPAODataClaimProvider {
@Override
public List<JPAClaimsPair<?>> get(final String attributeName) {
return 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/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAODataExternalRequestContextTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAODataExternalRequestContextTest.java | package com.sap.olingo.jpa.processor.core.api;
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.mockito.Mockito.mock;
import java.util.Arrays;
import java.util.List;
import java.util.Locale;
import jakarta.persistence.EntityManager;
import org.apache.olingo.server.api.debug.DebugSupport;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.processor.core.api.JPAODataExternalRequestContext.Builder;
class JPAODataExternalRequestContextTest {
private Builder cut;
@BeforeEach
void setup() {
cut = JPAODataRequestContext.with();
}
@Test
void testSetClaimsProvider() {
final JPAODataClaimProvider provider = mock(JPAODataClaimProvider.class);
assertEquals(cut, cut.setClaimsProvider(provider));
final JPAODataRequestContext act = cut.build();
assertEquals(provider, act.getClaimsProvider().get());
}
@Test
void testSetGroupsProvider() {
final JPAODataGroupProvider provider = mock(JPAODataGroupProvider.class);
assertEquals(cut, cut.setGroupsProvider(provider));
final JPAODataRequestContext act = cut.build();
assertEquals(provider, act.getGroupsProvider().get());
}
@Test
void testSetCUDRequestHandler() {
final JPACUDRequestHandler cudRequestHandler = mock(JPACUDRequestHandler.class);
assertEquals(cut, cut.setCUDRequestHandler(cudRequestHandler));
final JPAODataRequestContext act = cut.build();
assertEquals(cudRequestHandler, act.getCUDRequestHandler());
}
@Test
void testSetDebugSupport() {
final DebugSupport debugSupport = mock(DebugSupport.class);
assertEquals(cut, cut.setDebugSupport(debugSupport));
final JPAODataRequestContext act = cut.build();
assertEquals(debugSupport, act.getDebuggerSupport());
}
@Test
void testSetEntityManager() {
final EntityManager em = mock(EntityManager.class);
assertEquals(cut, cut.setEntityManager(em));
final JPAODataRequestContext act = cut.build();
assertEquals(em, act.getEntityManager());
}
@Test
void testSetTransactionFactory() {
final JPAODataTransactionFactory em = mock(JPAODataTransactionFactory.class);
assertEquals(cut, cut.setTransactionFactory(em));
final JPAODataRequestContext act = cut.build();
assertEquals(em, act.getTransactionFactory());
}
@Test
void testSetOneParameter() {
final String key = "MyKey";
final Integer value = 10;
assertEquals(cut, cut.setParameter(key, value));
final JPAODataRequestContext act = cut.build();
assertEquals(value, act.getRequestParameter().get(key));
assertTrue(act.getRequestParameter().containsKey(key));
}
@Test
void testSetTwoParameter() {
final String key1 = "MyKey1";
final Integer value1 = 10;
assertEquals(cut, cut.setParameter(key1, value1));
final String key2 = "MyKey2";
final Integer value2 = 50;
assertEquals(cut, cut.setParameter(key2, value2));
final JPAODataRequestContext act = cut.build();
assertEquals(value2, act.getRequestParameter().get(key2));
assertTrue(act.getRequestParameter().containsKey(key2));
}
@Test
void testReplaceParameter() {
final String key1 = "MyKey1";
final Integer value1 = 10;
assertEquals(cut, cut.setParameter(key1, value1));
final Integer value2 = 50;
assertEquals(cut, cut.setParameter(key1, value2));
final JPAODataRequestContext act = cut.build();
assertEquals(value2, act.getRequestParameter().get(key1));
}
@Test
void testGetLocalesNotNull() {
assertNotNull(cut.build().getLocales());
}
@Test
void testSetLocalesFromList() {
assertEquals(cut, cut.setLocales(Arrays.asList(Locale.US, Locale.ENGLISH, Locale.CANADA_FRENCH)));
final List<Locale> act = cut.build().getLocales();
assertTrue(act.contains(Locale.ENGLISH));
}
@Test
void testSetLocale() {
assertEquals(cut, cut.setLocales(Locale.ENGLISH));
final List<Locale> act = cut.build().getLocales();
assertTrue(act.contains(Locale.ENGLISH));
}
@Test
void testSetVersion() {
assertEquals(cut, cut.setVersion("V10"));
assertEquals("V10", cut.build().getVersion());
}
@Test
void testVersionIsDefaultIfNotSet() {
assertEquals(JPAODataApiVersionAccess.DEFAULT_VERSION, cut.build().getVersion());
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAODataRequestHandlerTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAODataRequestHandlerTest.java | package com.sap.olingo.jpa.processor.core.api;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.ArgumentMatchers.isA;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.io.IOException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletRequestWrapper;
import jakarta.servlet.http.HttpServletResponse;
import org.apache.olingo.commons.api.ex.ODataException;
import org.apache.olingo.server.api.OData;
import org.apache.olingo.server.api.ODataHttpHandler;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.ArgumentMatcher;
import com.sap.olingo.jpa.processor.core.util.IntegrationTestHelper;
import com.sap.olingo.jpa.processor.core.util.TestBase;
class JPAODataRequestHandlerTest extends TestBase {
private JPAODataRequestHandler cut;
private HttpServletRequest request;
private HttpServletResponse response;
private static final String PUNIT_NAME = "com.sap.olingo.jpa";
@BeforeEach
void setup() throws IOException {
request = IntegrationTestHelper.getRequestMock("http://localhost:8080/Test/Olingo.svc/Organizations",
new StringBuilder(), headers);
response = IntegrationTestHelper.getResponseMock();
}
@Test
void testGetHandlerProvidingSessionContext() throws ODataException {
final JPAODataSessionContextAccess sessionContext = JPAODataServiceContext.with()
.setDataSource(dataSource)
.setPUnit(PUNIT_NAME)
.build();
cut = new JPAODataRequestHandler(sessionContext);
assertNotNull(cut);
}
@Test
void testPropertiesInstanceProvidingSessionContext() throws ODataException {
final JPAODataSessionContextAccess context = JPAODataServiceContext.with()
.setDataSource(dataSource).setPUnit(PUNIT_NAME).build();
cut = new JPAODataRequestHandler(context);
assertNotNull(cut.odata);
}
@Test
void testProcessOnlyProvidingSessionContext() throws ODataException {
final JPAODataSessionContextAccess context = JPAODataServiceContext.with()
.setDataSource(dataSource)
.setPUnit(PUNIT_NAME)
.setTypePackage(enumPackages)
.build();
new JPAODataRequestHandler(context).process(request, response);
assertEquals(200, getStatus());
}
@Test
void testProcessWithEntityManagerProvidingSessionContext() throws ODataException {
final JPAODataSessionContextAccess sessionContext = JPAODataServiceContext.with()
.setDataSource(dataSource)
.setPUnit(PUNIT_NAME)
.setTypePackage(enumPackages)
.build();
cut = new JPAODataRequestHandler(sessionContext);
cut.process(request, response);
assertEquals(200, getStatus());
}
@Test
void testProcessOnlyProvidingSessionContextWithEm() throws ODataException {
final JPAODataSessionContextAccess sessionContext = JPAODataServiceContext.with()
.setPUnit(PUNIT_NAME)
.setTypePackage(enumPackages)
.build();
final JPAODataRequestContext requestContext = JPAODataRequestContext.with()
.setEntityManager(emf.createEntityManager())
.build();
cut = new JPAODataRequestHandler(sessionContext, requestContext);
cut.process(request, response);
assertEquals(200, getStatus());
}
@Test
void testMappingPathInSessionContextCreatesMapper() throws ODataException {
final OData odata = mock(OData.class);
final ODataHttpHandler handler = mock(ODataHttpHandler.class);
when(odata.createHandler(any())).thenReturn(handler);
final JPAODataSessionContextAccess context = JPAODataServiceContext.with()
.setDataSource(dataSource)
.setPUnit(PUNIT_NAME)
.setRequestMappingPath("/test")
.build();
cut = new JPAODataRequestHandler(context, odata);
cut.process(request, response);
verify(handler, times(1)).process(isA(HttpServletRequestWrapper.class), any());
}
@Test
void testEmptyMappingPathInSessionContextNoMapper() throws ODataException {
final OData odata = mock(OData.class);
final ODataHttpHandler handler = mock(ODataHttpHandler.class);
when(odata.createHandler(any())).thenReturn(handler);
final JPAODataSessionContextAccess context = JPAODataServiceContext.with()
.setDataSource(dataSource)
.setPUnit(PUNIT_NAME)
.build();
cut = new JPAODataRequestHandler(context, odata);
cut.process(request, response);
verify(handler, times(1)).process(argThat(new HttpRequestMatcher()), any());
}
@Test
void testEmptyMappingPathInSessionContextEmptyMapper() throws ODataException {
final OData odata = mock(OData.class);
final ODataHttpHandler handler = mock(ODataHttpHandler.class);
when(odata.createHandler(any())).thenReturn(handler);
final JPAODataSessionContextAccess context = JPAODataServiceContext.with()
.setDataSource(dataSource)
.setPUnit(PUNIT_NAME)
.setRequestMappingPath("")
.build();
cut = new JPAODataRequestHandler(context, odata);
cut.process(request, response);
verify(handler, times(1)).process(argThat(new HttpRequestMatcher()), any());
}
public static class HttpRequestMatcher implements ArgumentMatcher<HttpServletRequest> {
@Override
public boolean matches(final HttpServletRequest argument) {
return argument instanceof HttpServletRequest && !(argument instanceof HttpServletRequestWrapper);
}
}
public int getStatus() {
final ArgumentCaptor<Integer> status = ArgumentCaptor.forClass(Integer.class);
verify(response).setStatus(status.capture());
return status.getValue();
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAODataSessionContextAccessTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAODataSessionContextAccessTest.java | package com.sap.olingo.jpa.processor.core.api;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import java.util.List;
import org.apache.olingo.commons.api.edmx.EdmxReference;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.metadata.core.edm.extension.vocabularies.AnnotationProvider;
import com.sap.olingo.jpa.processor.cb.ProcessorSqlPatternProvider;
import com.sap.olingo.jpa.processor.core.database.JPAODataDatabaseOperations;
class JPAODataSessionContextAccessTest {
private JPAODataSessionContextAccess cut;
@BeforeEach
void setup() {
cut = new JPAODataSessionContextAccessDouble();
}
@Test
void testDefaultGetErrorProcessor() {
assertNull(cut.getErrorProcessor());
}
@Test
void testDefaultGetVersion() {
assertNull(cut.getApiVersion("Test"));
}
@Test
void testDefaultGetBatchProcessorFactory() {
assertNull(cut.getBatchProcessorFactory());
}
@Test
void testDefaultUseAbsoluteContextURL() {
assertFalse(cut.useAbsoluteContextURL());
}
private static class JPAODataSessionContextAccessDouble implements JPAODataSessionContextAccess {
@Override
public JPAODataDatabaseProcessor getDatabaseProcessor() {
return null;
}
@Override
public JPAODataDatabaseOperations getOperationConverter() {
return null;
}
@Override
public List<EdmxReference> getReferences() {
return null;
}
@Override
public JPAODataPagingProvider getPagingProvider() {
return null;
}
@Override
public List<AnnotationProvider> getAnnotationProvider() {
return null;
}
@Override
public JPAODataQueryDirectives getQueryDirectives() {
return null;
}
@Override
public ProcessorSqlPatternProvider getSqlPatternProvider() {
return null;
}
@Override
public JPAODataApiVersionAccess getApiVersion(final String id) {
return 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/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAClaimsPairTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAClaimsPairTest.java | package com.sap.olingo.jpa.processor.core.api;
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.assertTrue;
import org.junit.jupiter.api.Test;
class JPAClaimsPairTest {
@Test
void checkCreateIntegerPairOnlyMin() {
final JPAClaimsPair<Integer> cut = new JPAClaimsPair<>(7);
assertEquals((Integer) 7, cut.min);
assertEquals((Integer) null, cut.max);
}
@Test
void checkCreateIntegerPairNoUpperBoundary() {
final JPAClaimsPair<Integer> cut = new JPAClaimsPair<>(7);
assertFalse(cut.hasUpperBoundary);
}
@Test
void checkCreateIntegerPair() {
final JPAClaimsPair<Integer> cut = new JPAClaimsPair<>(7, 10);
assertEquals((Integer) 7, cut.min);
assertEquals((Integer) 10, cut.max);
}
@Test
void checkCreateIntegerPairUpperBoundary() {
final JPAClaimsPair<Integer> cut = new JPAClaimsPair<>(7, 10);
assertTrue(cut.hasUpperBoundary);
}
@Test
void checkHasToStringMethod() {
final JPAClaimsPair<Integer> cut = new JPAClaimsPair<>(7, 10);
final String act = cut.toString();
assertNotNull(act);
assertTrue(act.contains("7"));
}
@Test
void checkCastIntegerValueToLong() {
final JPAClaimsPair<Integer> cut = new JPAClaimsPair<>(7, 10);
assertEquals(7, (int) cut.minAs());
assertEquals(10, (int) cut.maxAs());
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAErrorProcessorWrapperTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAErrorProcessorWrapperTest.java | package com.sap.olingo.jpa.processor.core.api;
import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import org.apache.olingo.commons.api.format.ContentType;
import org.apache.olingo.server.api.OData;
import org.apache.olingo.server.api.ODataRequest;
import org.apache.olingo.server.api.ODataResponse;
import org.apache.olingo.server.api.ODataServerError;
import org.apache.olingo.server.api.ServiceMetadata;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
class JPAErrorProcessorWrapperTest {
private JPAErrorProcessor errorProcessor;
private JPAErrorProcessorWrapper cut;
@BeforeEach
void setup() {
errorProcessor = mock(JPAErrorProcessor.class);
cut = new JPAErrorProcessorWrapper(errorProcessor);
}
@Test
void testInit() {
final OData odata = mock(OData.class);
final ServiceMetadata metadata = mock(ServiceMetadata.class);
assertDoesNotThrow(() -> cut.init(odata, metadata));
}
@Test
void testProcessErrorCallsErrorProcessor() {
final ODataRequest request = mock(ODataRequest.class);
final ODataResponse response = mock(ODataResponse.class);
final ODataServerError serverError = mock(ODataServerError.class);
final ContentType responseFormat = ContentType.APPLICATION_JSON;
cut.processError(request, response, serverError, responseFormat);
verify(errorProcessor, times(1)).processError(request, serverError);
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAODataApiVersionTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAODataApiVersionTest.java | package com.sap.olingo.jpa.processor.core.api;
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.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
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 org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.metadata.api.JPAApiVersion;
import com.sap.olingo.jpa.metadata.api.JPAEntityManagerFactory;
import com.sap.olingo.jpa.metadata.core.edm.mapper.impl.JPADefaultEdmNameBuilder;
import com.sap.olingo.jpa.processor.cb.ProcessorSqlPatternProvider;
import com.sap.olingo.jpa.processor.core.testmodel.DataSourceHelper;
class JPAODataApiVersionTest {
private static final String VERSION_ID = "V12";
private static final String PATH = "test/v12";
private static DataSource dataSource;
private static final String PUNIT_NAME = "com.sap.olingo.jpa";
private JPAApiVersion version;
private ProcessorSqlPatternProvider sqlPattern;
private JPAODataApiVersion cut;
private EntityManagerFactory emf;
@BeforeAll
public static void classSetup() {
dataSource = DataSourceHelper.createDataSource(DataSourceHelper.DB_HSQLDB);
}
@BeforeEach
void setup() throws ODataException {
emf = JPAEntityManagerFactory.getEntityManagerFactory(PUNIT_NAME, dataSource);
sqlPattern = mock(ProcessorSqlPatternProvider.class);
version = mock(JPAApiVersion.class);
when(version.getId()).thenReturn(VERSION_ID);
when(version.getRequestMappingPath()).thenReturn(PATH);
when(version.getEntityManagerFactory()).thenReturn(emf);
cut = new JPAODataApiVersion(version, new JPADefaultEdmNameBuilder(PUNIT_NAME), List.of(), sqlPattern);
}
@Test
void testGetId() {
assertEquals(VERSION_ID, cut.getId());
}
@Test
void testGetMappingPath() {
assertEquals(PATH, cut.getMappingPath());
}
@SuppressWarnings("unchecked")
@Test
void testGetEntityManagerFactory() {
try {
final Class<? extends EntityManagerFactory> wrapperClass = (Class<? extends EntityManagerFactory>) Class
.forName("com.sap.olingo.jpa.processor.cb.api.EntityManagerFactoryWrapper");
if (wrapperClass != null) {
assertTrue(cut.getEntityManagerFactory().getClass().isAssignableFrom(wrapperClass));
} else {
assertEquals(emf, cut.getEntityManagerFactory());
}
} catch (final ClassNotFoundException e) {
assertEquals(emf, cut.getEntityManagerFactory());
}
}
@Test
void testGetEdmProvider() {
assertNotNull(cut.getEdmProvider());
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAODataQueryDirectivesTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAODataQueryDirectivesTest.java | package com.sap.olingo.jpa.processor.core.api;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.apache.olingo.commons.api.ex.ODataException;
import org.junit.jupiter.api.Test;
class JPAODataQueryDirectivesTest {
@Test
void testBuildWithoutSettingMaxZero() throws ODataException {
final JPAODataSessionContextAccess act = JPAODataServiceContext.with()
.useQueryDirectives().build().build();
assertEquals(0, act.getQueryDirectives().getMaxValuesInInClause());
}
@Test
void testBuildProvideSetValue() throws ODataException {
final JPAODataSessionContextAccess act = JPAODataServiceContext.with()
.useQueryDirectives().maxValuesInInClause(300).build().build();
assertEquals(300, act.getQueryDirectives().getMaxValuesInInClause());
}
@Test
void testContextReturnDirectivesWithZero() throws ODataException {
final JPAODataSessionContextAccess act = JPAODataServiceContext.with().build();
assertEquals(0, act.getQueryDirectives().getMaxValuesInInClause());
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAODataServiceContextBuilderTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAODataServiceContextBuilderTest.java | package com.sap.olingo.jpa.processor.core.api;
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.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
import java.net.URI;
import java.net.URISyntaxException;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import javax.annotation.Nonnull;
import javax.sql.DataSource;
import org.apache.olingo.commons.api.edm.FullQualifiedName;
import org.apache.olingo.commons.api.edm.provider.CsdlAnnotation;
import org.apache.olingo.commons.api.edm.provider.CsdlEntityType;
import org.apache.olingo.commons.api.edm.provider.annotation.CsdlConstantExpression;
import org.apache.olingo.commons.api.edm.provider.annotation.CsdlConstantExpression.ConstantExpressionType;
import org.apache.olingo.commons.api.edmx.EdmxReference;
import org.apache.olingo.commons.api.ex.ODataException;
import org.apache.olingo.server.api.processor.ErrorProcessor;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.metadata.api.JPAApiVersion;
import com.sap.olingo.jpa.metadata.api.JPAEdmMetadataPostProcessor;
import com.sap.olingo.jpa.metadata.api.JPAEdmProvider;
import com.sap.olingo.jpa.metadata.api.JPAEntityManagerFactory;
import com.sap.olingo.jpa.metadata.core.edm.extension.vocabularies.AnnotationProvider;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEdmNameBuilder;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.IntermediateEntityTypeAccess;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.IntermediateNavigationPropertyAccess;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.IntermediatePropertyAccess;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.IntermediateReferenceList;
import com.sap.olingo.jpa.metadata.core.edm.mapper.impl.JPADefaultEdmNameBuilder;
import com.sap.olingo.jpa.processor.cb.ProcessorSqlPatternProvider;
import com.sap.olingo.jpa.processor.core.api.example.JPAExamplePagingProvider;
import com.sap.olingo.jpa.processor.core.database.JPADefaultDatabaseProcessor;
import com.sap.olingo.jpa.processor.core.database.JPAODataDatabaseOperations;
import com.sap.olingo.jpa.processor.core.database.JPAPostgresqlSqlPatternProvider;
import com.sap.olingo.jpa.processor.core.testmodel.DataSourceHelper;
class JPAODataServiceContextBuilderTest {
private static final String PUNIT_NAME = "com.sap.olingo.jpa";
private static final String[] enumPackages = { "com.sap.olingo.jpa.processor.core.testmodel" };
private JPAODataSessionContextAccess cut;
private static DataSource dataSource;
@BeforeAll
public static void classSetup() {
dataSource = DataSourceHelper.createDataSource(DataSourceHelper.DB_HSQLDB);
}
@Test
void checkBuilderAvailable() {
assertNotNull(JPAODataServiceContext.with());
}
@Test
void checkSetDataSourceAndPUnit() throws ODataException {
cut = JPAODataServiceContext.with()
.setDataSource(dataSource)
.setPUnit(PUNIT_NAME)
.build();
final JPAEdmProvider act = cut.getApiVersion(JPAODataApiVersionAccess.DEFAULT_VERSION)
.getEdmProvider();
assertNotNull(act);
}
// @Test
// void checkEmptyArrayOnNoPackagesProvided() throws ODataException {
// cut = JPAODataServiceContext.with()
// .setDataSource(dataSource)
// .setPUnit(PUNIT_NAME)
// .build();
//
// assertNotNull(cut.getPackageName());
// assertEquals(0, cut.getPackageName().size());
// }
//
// @Test
// void checkArrayOnProvidedPackages() throws ODataException {
// cut = JPAODataServiceContext.with()
// .setDataSource(dataSource)
// .setPUnit(PUNIT_NAME)
// .setTypePackage("org.apache.olingo.jpa.bl", "com.sap.olingo.jpa.processor.core.testmodel")
// .build();
//
// assertNotNull(cut.getPackageName());
// assertEquals(2, cut.getPackageName().size());
// }
@Test
void checkReturnsProvidedPagingProvider() throws ODataException {
final JPAODataPagingProvider provider = new JPAExamplePagingProvider(Collections.emptyMap());
cut = JPAODataServiceContext.with()
.setDataSource(dataSource)
.setPUnit(PUNIT_NAME)
.setPagingProvider(provider)
.build();
assertNotNull(cut.getPagingProvider());
assertEquals(provider, cut.getPagingProvider());
}
@Test
void checkReturnsDefaultPagingProviderIfNotProvider() throws ODataException {
cut = JPAODataServiceContext.with()
.setDataSource(dataSource)
.setPUnit(PUNIT_NAME)
.build();
assertTrue(cut.getPagingProvider() instanceof JPADefaultPagingProvider);
}
@Test
void checkEmptyListOnNoReferencesProvided() throws ODataException {
cut = JPAODataServiceContext.with()
.setDataSource(dataSource)
.setPUnit(PUNIT_NAME)
.build();
assertNotNull(cut.getReferences());
assertTrue(cut.getReferences().isEmpty());
}
@Test
void checkReturnsReferencesProvider() throws ODataException, URISyntaxException {
final List<EdmxReference> references = new ArrayList<>(1);
references.add(new EdmxReference(new URI("http://exapmle.com/odata4/v1")));
cut = JPAODataServiceContext.with()
.setDataSource(dataSource)
.setPUnit(PUNIT_NAME)
.setReferences(references)
.build();
assertEquals(1, cut.getReferences().size());
}
@Test
void checkReturnsOperation() throws ODataException {
final JPAODataDatabaseOperations operations = new JPADefaultDatabaseProcessor();
cut = JPAODataServiceContext.with()
.setDataSource(dataSource)
.setPUnit(PUNIT_NAME)
.setOperationConverter(operations)
.build();
assertNotNull(cut.getOperationConverter());
assertEquals(operations, cut.getOperationConverter());
}
@Test
void checkReturnsDatabaseProcessor() throws ODataException {
final JPAODataDatabaseProcessor processor = new JPADefaultDatabaseProcessor();
cut = JPAODataServiceContext.with()
.setDataSource(dataSource)
.setPUnit(PUNIT_NAME)
.setDatabaseProcessor(processor)
.build();
assertNotNull(cut.getDatabaseProcessor());
assertEquals(processor, cut.getDatabaseProcessor());
}
@Test
void checkReturnsSqlPatternProvider() throws ODataException {
final ProcessorSqlPatternProvider provider = new JPAPostgresqlSqlPatternProvider();
cut = JPAODataServiceContext.with()
.setDataSource(dataSource)
.setPUnit(PUNIT_NAME)
.setSqlPatternProvider(provider)
.build();
assertNotNull(cut.getSqlPatternProvider());
assertEquals(provider, cut.getSqlPatternProvider());
}
@Test
void checkJPAEdmContainsPostProcessor() throws ODataException {
final JPAEdmMetadataPostProcessor processor = new TestEdmPostProcessor();
cut = JPAODataServiceContext.with()
.setDataSource(dataSource)
.setPUnit(PUNIT_NAME)
.setTypePackage(enumPackages)
.setMetadataPostProcessor(processor)
.build();
assertNotNull(cut.getApiVersion(JPAODataApiVersionAccess.DEFAULT_VERSION)
.getEdmProvider());
final CsdlEntityType act = cut.getApiVersion(JPAODataApiVersionAccess.DEFAULT_VERSION)
.getEdmProvider().getEntityType(new FullQualifiedName(PUNIT_NAME, "BusinessPartner"));
assertEquals(1L, act.getAnnotations().stream().filter(a -> a.getTerm().equals("Permissions")).count());
}
@Test
void checkReturnsErrorProcessor() throws ODataException {
final ErrorProcessor processor = new JPADefaultErrorProcessor();
cut = JPAODataServiceContext.with()
.setDataSource(dataSource)
.setPUnit(PUNIT_NAME)
.setErrorProcessor(processor)
.build();
assertNotNull(cut.getErrorProcessor());
assertEquals(processor, cut.getErrorProcessor());
}
@Test
void checkThrowsExceptionOnDBConnectionProblem() throws SQLException {
final DataSource dataSourceSpy = spy(dataSource);
when(dataSourceSpy.getConnection()).thenThrow(SQLException.class);
assertThrows(ODataException.class, () -> JPAODataServiceContext.with()
.setDataSource(dataSourceSpy)
.setPUnit(PUNIT_NAME)
.build());
}
@Test
void checkJPAEdmContainsDefaultNameBuilder() throws ODataException {
cut = JPAODataServiceContext.with()
.setDataSource(dataSource)
.setPUnit(PUNIT_NAME)
.setTypePackage(enumPackages)
.build();
final JPAEdmProvider act = cut.getApiVersion(JPAODataApiVersionAccess.DEFAULT_VERSION)
.getEdmProvider();
assertNotNull(act);
assertNotNull(act.getEdmNameBuilder());
assertTrue(act.getEdmNameBuilder() instanceof JPADefaultEdmNameBuilder);
}
@Test
void checkJPAEdmContainsCustomNameBuilder() throws ODataException {
final JPAEdmNameBuilder nameBuilder = mock(JPAEdmNameBuilder.class);
when(nameBuilder.getNamespace()).thenReturn("unit.test");
cut = JPAODataServiceContext.with()
.setDataSource(dataSource)
.setPUnit(PUNIT_NAME)
.setTypePackage(enumPackages)
.setEdmNameBuilder(nameBuilder)
.build();
final JPAEdmProvider act = cut.getApiVersion(JPAODataApiVersionAccess.DEFAULT_VERSION)
.getEdmProvider();
assertNotNull(act);
assertNotNull(act.getEdmNameBuilder());
assertEquals(nameBuilder, act.getEdmNameBuilder());
}
@Test
void checkReturnsMappingPath() throws ODataException {
final String exp = "test/v1";
cut = JPAODataServiceContext.with()
.setDataSource(dataSource)
.setPUnit(PUNIT_NAME)
.setRequestMappingPath(exp)
.build();
assertEquals(exp, cut.getApiVersion(JPAODataApiVersionAccess.DEFAULT_VERSION)
.getMappingPath());
}
@Test
void checkReturnsBatchProcessorFactory() throws ODataException {
final TestBatchProcessorFactory exp = new TestBatchProcessorFactory();
cut = JPAODataServiceContext.with()
.setDataSource(dataSource)
.setPUnit(PUNIT_NAME)
.setBatchProcessorFactory(exp)
.build();
assertEquals(exp, cut.getBatchProcessorFactory());
}
@Test
void checkReturnsDefaultBatchProcessorFactoryIfNotProvided() throws ODataException {
cut = JPAODataServiceContext.with()
.setDataSource(dataSource)
.setPUnit(PUNIT_NAME)
.build();
assertTrue(cut.getBatchProcessorFactory() instanceof JPADefaultBatchProcessorFactory);
}
@Test
void checkReturnsFalseAsDefaultForUseAbsoluteContextURL() throws ODataException {
cut = JPAODataServiceContext.with()
.setDataSource(dataSource)
.setPUnit(PUNIT_NAME)
.build();
assertFalse(cut.useAbsoluteContextURL());
}
@Test
void checkReturnsTrueForUseAbsoluteContextURLIfSet() throws ODataException {
cut = JPAODataServiceContext.with()
.setDataSource(dataSource)
.setPUnit(PUNIT_NAME)
.setUseAbsoluteContextURL(true)
.build();
assertTrue(cut.useAbsoluteContextURL());
}
@Test
void checkReturnsFalseForUseAbsoluteContextURLIfSet() throws ODataException {
cut = JPAODataServiceContext.with()
.setDataSource(dataSource)
.setPUnit(PUNIT_NAME)
.setUseAbsoluteContextURL(false)
.build();
assertFalse(cut.useAbsoluteContextURL());
}
@Test
void checkReturnsEmptyAnnotationProviderList() throws ODataException {
cut = JPAODataServiceContext.with()
.setDataSource(dataSource)
.setPUnit(PUNIT_NAME)
.setUseAbsoluteContextURL(false)
.build();
assertTrue(cut.getAnnotationProvider().isEmpty());
}
@Test
void checkReturnAnnotationProviderList() throws ODataException {
final AnnotationProvider provider1 = mock(AnnotationProvider.class);
final AnnotationProvider provider2 = mock(AnnotationProvider.class);
cut = JPAODataServiceContext.with()
.setDataSource(dataSource)
.setPUnit(PUNIT_NAME)
.setUseAbsoluteContextURL(false)
.setAnnotationProvider(provider1, provider2)
.build();
assertEquals(2, cut.getAnnotationProvider().size());
assertTrue(cut.getAnnotationProvider().contains(provider1));
assertTrue(cut.getAnnotationProvider().contains(provider2));
}
@Test
void checkReturnsProvidedVersion() throws ODataException {
final var emf = JPAEntityManagerFactory.getEntityManagerFactory(PUNIT_NAME, dataSource);
cut = JPAODataServiceContext.with()
.setPUnit(PUNIT_NAME)
.setVersions(
JPAApiVersion.with()
.setId("V1")
.setEntityManagerFactory(emf)
.build())
.build();
assertNotNull(cut.getApiVersion("V1"));
}
@Test
void checkReturnsDefaultVersion() throws ODataException {
final var emf = JPAEntityManagerFactory.getEntityManagerFactory(PUNIT_NAME, dataSource);
cut = JPAODataServiceContext.with()
.setPUnit(PUNIT_NAME)
.setEntityManagerFactory(emf)
.build();
assertNotNull(cut.getApiVersion(JPAODataApiVersionAccess.DEFAULT_VERSION));
}
private static class TestEdmPostProcessor implements JPAEdmMetadataPostProcessor {
@Override
public void processNavigationProperty(final IntermediateNavigationPropertyAccess property,
final String jpaManagedTypeClassName) {
// Default shall do nothing
}
@Override
public void processProperty(final IntermediatePropertyAccess property, final String jpaManagedTypeClassName) {
// Default shall do nothing
}
@Override
public void provideReferences(final IntermediateReferenceList references) {
// Default shall do nothing
}
@Override
public void processEntityType(final IntermediateEntityTypeAccess entity) {
if (entity.getExternalName().equals("BusinessPartner")) {
final CsdlAnnotation annotation = new CsdlAnnotation();
annotation.setTerm("Permissions");
annotation.setExpression(new CsdlConstantExpression(ConstantExpressionType.EnumMember, "3"));
entity.addAnnotations(Collections.singletonList(annotation));
}
}
}
private static class TestBatchProcessorFactory implements JPAODataBatchProcessorFactory<JPAODataBatchProcessor> {
@Override
public JPAODataBatchProcessor getBatchProcessor(@Nonnull final JPAODataSessionContextAccess serviceContext,
@Nonnull final JPAODataRequestContextAccess requestContext) {
return 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/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAODataClaimsProviderTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAODataClaimsProviderTest.java | package com.sap.olingo.jpa.processor.core.api;
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.assertTrue;
import java.util.List;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
class JPAODataClaimsProviderTest {
private JPAODataClaimsProvider cut;
@BeforeEach
void setup() {
cut = new JPAODataClaimsProvider();
}
@Test
void checkAddSinglePairReturnsOne() {
cut.add("Test", new JPAClaimsPair<>("Hugo"));
final List<JPAClaimsPair<?>> claims = cut.get("Test");
assertNotNull(claims);
assertEquals(1, claims.size());
}
@Test
void checkAddThreeSinglePairsReturnsThree() {
cut.add("Test", new JPAClaimsPair<>("Hugo"));
cut.add("Test", new JPAClaimsPair<>("Willi"));
cut.add("Test", new JPAClaimsPair<>("Walter"));
final List<JPAClaimsPair<?>> claims = cut.get("Test");
assertNotNull(claims);
assertEquals(3, claims.size());
}
@Test
void checkNotProvidedAttributeReturnsEmptyList() {
final List<JPAClaimsPair<?>> claims = cut.get("Test");
assertNotNull(claims);
assertEquals(0, claims.size());
}
@Test
void checkAddTwoAttributesSinglePairs() {
cut.add("Test", new JPAClaimsPair<>("Hugo"));
cut.add("Dummy", new JPAClaimsPair<>("Willi"));
List<JPAClaimsPair<?>> claims = cut.get("Test");
assertNotNull(claims);
assertEquals(1, claims.size());
claims = cut.get("Dummy");
assertNotNull(claims);
assertEquals(1, claims.size());
}
@Test
void checkCreateWithUser() {
assertNotNull(new JPAODataClaimsProvider("Willi"));
}
@Test
void checkUserReturnedWhenInConstructor() {
assertTrue(new JPAODataClaimsProvider("Willi").user().isPresent());
}
@Test
void checkUserNotPresentWhenNotInConstructor() {
assertFalse(cut.user().isPresent());
}
@Test
void checkToString() {
assertNotNull(cut.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/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAODataContextAccessDouble.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAODataContextAccessDouble.java | package com.sap.olingo.jpa.processor.core.api;
import static org.junit.jupiter.api.Assertions.fail;
import java.sql.SQLException;
import java.util.Collections;
import java.util.List;
import javax.sql.DataSource;
import jakarta.persistence.EntityManagerFactory;
import org.apache.olingo.commons.api.edmx.EdmxReference;
import org.apache.olingo.commons.api.ex.ODataException;
import com.sap.olingo.jpa.metadata.api.JPAEdmProvider;
import com.sap.olingo.jpa.metadata.core.edm.extension.vocabularies.AnnotationProvider;
import com.sap.olingo.jpa.processor.cb.ProcessorSqlPatternProvider;
import com.sap.olingo.jpa.processor.core.database.JPAAbstractDatabaseProcessor;
import com.sap.olingo.jpa.processor.core.database.JPADefaultDatabaseProcessor;
import com.sap.olingo.jpa.processor.core.database.JPAODataDatabaseOperations;
import com.sap.olingo.jpa.processor.core.database.JPAODataDatabaseProcessorFactory;
public class JPAODataContextAccessDouble implements JPAODataSessionContextAccess {
private final DataSource dataSource;
private final JPAAbstractDatabaseProcessor processor;
private final JPAODataPagingProvider pagingProvider;
private final AnnotationProvider annotationProvider;
private JPAODataQueryDirectives directives;
private final ProcessorSqlPatternProvider sqlPatternProvider;
private final JPAODataApiVersionAccess version;
public JPAODataContextAccessDouble(final JPAEdmProvider edmProvider, final EntityManagerFactory emf,
final DataSource dataSource,
final JPAODataPagingProvider provider, final AnnotationProvider annotationProvider,
final ProcessorSqlPatternProvider sqlPatternProvider, final String... packages) {
super();
this.dataSource = dataSource;
this.processor = new JPADefaultDatabaseProcessor();
this.pagingProvider = provider != null ? provider : new JPADefaultPagingProvider();
this.annotationProvider = annotationProvider;
this.sqlPatternProvider = sqlPatternProvider;
this.version = new JPAODataApiVersion(JPAODataApiVersionAccess.DEFAULT_VERSION, edmProvider, emf);
try {
this.directives = JPAODataServiceContext.with()
.setEntityManagerFactory(emf)
.setPUnit(edmProvider.getEdmNameBuilder().getNamespace())
.useQueryDirectives()
.maxValuesInInClause(3)
.build()
.build()
.getQueryDirectives();
} catch (final ODataException e) {
this.directives = null;
}
}
@Override
public List<EdmxReference> getReferences() {
fail();
return null;
}
@Override
public JPAODataDatabaseOperations getOperationConverter() {
return processor instanceof JPAODataDatabaseOperations
? (JPAODataDatabaseOperations) processor
: new JPADefaultDatabaseProcessor();
}
@Override
public JPAODataDatabaseProcessor getDatabaseProcessor() {
try {
return new JPAODataDatabaseProcessorFactory().create(dataSource);
} catch (final SQLException e) {
fail();
}
return null;
}
@Override
public JPAODataPagingProvider getPagingProvider() {
return pagingProvider;
}
@Override
public List<AnnotationProvider> getAnnotationProvider() {
return Collections.singletonList(annotationProvider);
}
@Override
public JPAODataQueryDirectives getQueryDirectives() {
return directives;
}
@Override
public ProcessorSqlPatternProvider getSqlPatternProvider() {
return sqlPatternProvider;
}
@Override
public JPAODataApiVersionAccess getApiVersion(final String id) {
return version;
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/api/JPADefaultPagingProviderTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/api/JPADefaultPagingProviderTest.java | package com.sap.olingo.jpa.processor.core.api;
import static org.junit.jupiter.api.Assertions.assertEquals;
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.api.Assertions.fail;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import org.apache.olingo.server.api.ODataApplicationException;
import org.apache.olingo.server.api.uri.UriInfo;
import org.apache.olingo.server.api.uri.queryoption.SkipOption;
import org.apache.olingo.server.api.uri.queryoption.TopOption;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.processor.core.exception.ODataJPAQueryException;
class JPADefaultPagingProviderTest {
private JPAODataPagingProvider cut;
private UriInfo uriInfo;
private SkipOption skipOption;
private TopOption topOption;
@BeforeEach
void setup() {
cut = new JPADefaultPagingProvider();
uriInfo = mock(UriInfo.class);
skipOption = mock(SkipOption.class);
topOption = mock(TopOption.class);
}
@Test
void testGetNextPageReturnsEmptyOptional() {
assertTrue(cut.getNextPage("Test", null, null, null, null).isEmpty());
}
@Test
void testGetFirstPageReturnsSkipZeroIfAbsence() throws ODataApplicationException {
when(uriInfo.getSkipOption()).thenReturn(null);
final var act = cut.getFirstPage(null, null, uriInfo, null, null, null);
assertEquals(0, act.orElseGet(() -> fail("No page found")).skip());
}
@Test
void testGetFirstPageReturnsSkipAsRequested() throws ODataApplicationException {
when(skipOption.getValue()).thenReturn(99);
when(uriInfo.getSkipOption()).thenReturn(skipOption);
final var act = cut.getFirstPage(null, null, uriInfo, null, null, null);
assertEquals(99, act.orElseGet(() -> fail("No page found")).skip());
}
@Test
void testGetFirstPageReturnsTopMaxIfAbsence() throws ODataApplicationException {
when(uriInfo.getTopOption()).thenReturn(null);
final var act = cut.getFirstPage(null, null, uriInfo, null, null, null);
assertEquals(Integer.MAX_VALUE, act.orElseGet(() -> fail("No page found")).top());
}
@Test
void testGetFirstPageReturnsTopAsRequested() throws ODataApplicationException {
when(topOption.getValue()).thenReturn(99);
when(uriInfo.getTopOption()).thenReturn(topOption);
final var act = cut.getFirstPage(null, null, uriInfo, null, null, null);
assertEquals(99, act.orElseGet(() -> fail("No page found")).top());
}
@Test
void testGetFirstPageReturnsTopAndSkipAsRequested() throws ODataApplicationException {
when(topOption.getValue()).thenReturn(13);
when(uriInfo.getTopOption()).thenReturn(topOption);
when(skipOption.getValue()).thenReturn(99);
when(uriInfo.getSkipOption()).thenReturn(skipOption);
final var act = cut.getFirstPage(null, null, uriInfo, null, null, null);
assertEquals(13, act.orElseGet(() -> fail("No page found")).top());
assertEquals(99, act.orElseGet(() -> fail("No page found")).skip());
assertNull(act.get().skipToken());
}
@Test
void testGetFirstPageThrowsExceptionSkipNegative() {
when(skipOption.getValue()).thenReturn(-99);
when(uriInfo.getSkipOption()).thenReturn(skipOption);
assertThrows(ODataJPAQueryException.class, () -> cut.getFirstPage(null, null, uriInfo, null, null, null));
}
@Test
void testGetFirstPageThrowsExceptionTopNegative() {
when(topOption.getValue()).thenReturn(-99);
when(uriInfo.getTopOption()).thenReturn(topOption);
assertThrows(ODataJPAQueryException.class, () -> cut.getFirstPage(null, null, uriInfo, null, null, 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/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAODataServiceDocumentProcessorTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAODataServiceDocumentProcessorTest.java | package com.sap.olingo.jpa.processor.core.api;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import org.apache.olingo.commons.api.edm.Edm;
import org.apache.olingo.commons.api.edm.EdmEntityContainer;
import org.apache.olingo.commons.api.format.ContentType;
import org.apache.olingo.server.api.OData;
import org.apache.olingo.server.api.ODataApplicationException;
import org.apache.olingo.server.api.ODataLibraryException;
import org.apache.olingo.server.api.ODataRequest;
import org.apache.olingo.server.api.ODataResponse;
import org.apache.olingo.server.api.ServiceMetadata;
import org.apache.olingo.server.api.uri.UriInfo;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.processor.core.util.matcher.InputStreamMatcher;
class JPAODataServiceDocumentProcessorTest {
private JPAODataServiceDocumentProcessor cut;
private JPAODataSessionContextAccess sessionContext;
private ServiceMetadata metadata;
private ODataRequest request;
private ODataResponse response;
private UriInfo uriInfo;
private Edm edm;
private EdmEntityContainer container;
@BeforeEach
void setup() {
sessionContext = mock(JPAODataSessionContextAccess.class);
edm = mock(Edm.class);
container = mock(EdmEntityContainer.class);
metadata = mock(ServiceMetadata.class);
request = mock(ODataRequest.class);
response = mock(ODataResponse.class);
uriInfo = mock(UriInfo.class);
when(edm.getEntityContainer()).thenReturn(container);
when(metadata.getEdm()).thenReturn(edm);
}
@Test
void testInstanceCanBeCreated() {
assertNotNull(new JPAODataServiceDocumentProcessor(sessionContext));
}
@Test
void testInitCanBeCalled() {
cut = new JPAODataServiceDocumentProcessor(sessionContext);
cut.init(OData.newInstance(), metadata);
assertNotNull(cut);
}
@Test
void testCreateServiceDocumentWithRelativeMetadataUrl() throws ODataApplicationException,
ODataLibraryException {
when(sessionContext.useAbsoluteContextURL()).thenReturn(false);
cut = new JPAODataServiceDocumentProcessor(sessionContext);
cut.init(OData.newInstance(), metadata);
cut.readServiceDocument(request, response, uriInfo, ContentType.APPLICATION_JSON);
verify(response).setContent(argThat(new InputStreamMatcher("\"@odata.context\":\"$metadata\"")));
}
@Test
void testCreateServiceDocumentWithAbsoluteMetadataUrl() throws ODataApplicationException,
ODataLibraryException {
when(sessionContext.useAbsoluteContextURL()).thenReturn(true);
when(request.getRawBaseUri()).thenReturn("http://localhost:8080/test");
cut = new JPAODataServiceDocumentProcessor(sessionContext);
cut.init(OData.newInstance(), metadata);
cut.readServiceDocument(request, response, uriInfo, ContentType.APPLICATION_JSON);
verify(response).setContent(argThat(new InputStreamMatcher(
"\"@odata.context\":\"http://localhost:8080/test/$metadata\"")));
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/api/BatchRequestTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/api/BatchRequestTest.java | package com.sap.olingo.jpa.processor.core.api;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import java.io.IOException;
import java.util.List;
import org.apache.olingo.commons.api.ex.ODataException;
import org.junit.jupiter.api.Test;
import com.fasterxml.jackson.databind.JsonNode;
import com.sap.olingo.jpa.processor.core.util.IntegrationTestHelper;
import com.sap.olingo.jpa.processor.core.util.TestBase;
class BatchRequestTest extends TestBase {
@Test
void testOneGetRequestGetResponse() throws IOException, ODataException {
final StringBuffer requestBody = createBodyOneGet();
final IntegrationTestHelper helper = new IntegrationTestHelper(emf, "$batch", requestBody);
final List<String> act = helper.getRawBatchResult();
assertNotNull(act);
}
@Test
void testOneGetRequestCheckStatus() throws IOException, ODataException {
final StringBuffer requestBody = createBodyOneGet();
final IntegrationTestHelper helper = new IntegrationTestHelper(emf, "$batch", requestBody);
assertEquals(200, helper.getBatchResultStatus(1));
}
@Test
void testOneGetRequestCheckValue() throws IOException, ODataException {
final StringBuffer requestBody = createBodyOneGet();
final IntegrationTestHelper helper = new IntegrationTestHelper(emf, "$batch", requestBody);
final JsonNode value = helper.getBatchResult(1);
assertEquals("3", value.get("ID").asText());
}
@Test
void testTwoGetRequestSecondFailCheckStatus() throws IOException, ODataException {
final StringBuffer requestBody = createBodyTwoGetOneFail();
final IntegrationTestHelper helper = new IntegrationTestHelper(emf, "$batch", requestBody);
assertEquals(404, helper.getBatchResultStatus(2));
}
@Test
void testTwoGetRequestCheckValue() throws IOException, ODataException {
final StringBuffer requestBody = createBodyTwoGet();
final IntegrationTestHelper helper = new IntegrationTestHelper(emf, "$batch", requestBody);
JsonNode value = helper.getBatchResult(1);
System.out.println(value);
assertEquals(200, helper.getBatchResultStatus(1));
assertNotNull(value.get("ID"));
assertEquals("3", value.get("ID").asText());
value = helper.getBatchResult(2);
System.out.println(value);
assertEquals(200, helper.getBatchResultStatus(2));
assertNotNull(value.get("ID"));
assertEquals("5", value.get("ID").asText());
}
private StringBuffer createBodyTwoGetOneFail() {
final StringBuffer requestBody = new StringBuffer("--abc123\r\n");
requestBody.append("Content-Type: application/http\r\n");
requestBody.append("Content-Transfer-Encoding: binary\r\n");
requestBody.append("\r\n");
requestBody.append("GET Organizations('3') HTTP/1.1\r\n");
requestBody.append("Content-Type: application/json\r\n");
requestBody.append("\r\n");
requestBody.append("\r\n");
requestBody.append("--abc123\r\n");
requestBody.append("Content-Type: application/http\r\n");
requestBody.append("Content-Transfer-Encoding: binary\r\n");
requestBody.append("\r\n");
requestBody.append("GET AdministrativeDivision HTTP/1.1\r\n");
requestBody.append("Content-Type: application/json\r\n");
requestBody.append("\r\n");
requestBody.append("\r\n");
requestBody.append("--abc123--");
return requestBody;
}
private StringBuffer createBodyTwoGet() {
final StringBuffer requestBody = new StringBuffer("--abc123\r\n");
requestBody.append("Content-Type: application/http\r\n");
requestBody.append("Content-Transfer-Encoding: binary\r\n");
requestBody.append("\r\n");
requestBody.append("GET Organizations('3') HTTP/1.1\r\n");
requestBody.append("Content-Type: application/json\r\n");
requestBody.append("\r\n");
requestBody.append("\r\n");
requestBody.append("--abc123\r\n");
requestBody.append("Content-Type: application/http\r\n");
requestBody.append("Content-Transfer-Encoding: binary\r\n");
requestBody.append("\r\n");
requestBody.append("GET Organizations('5') HTTP/1.1\r\n");
requestBody.append("Content-Type: application/json\r\n");
requestBody.append("\r\n");
requestBody.append("\r\n");
requestBody.append("--abc123--");
return requestBody;
}
private StringBuffer createBodyOneGet() {
final StringBuffer requestBody = new StringBuffer("--abc123\r\n");
requestBody.append("Content-Type: application/http\r\n");
requestBody.append("Content-Transfer-Encoding: binary\r\n");
requestBody.append("\r\n");
requestBody.append("GET Organizations('3') HTTP/1.1\r\n");
requestBody.append("Content-Type: application/json\r\n");
requestBody.append("\r\n");
requestBody.append("\r\n");
requestBody.append("--abc123--");
return requestBody;
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAODataGroupsProviderTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAODataGroupsProviderTest.java | package com.sap.olingo.jpa.processor.core.api;
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.util.Arrays;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
class JPAODataGroupsProviderTest {
private JPAODataGroupsProvider cut;
@BeforeEach
void setup() {
cut = new JPAODataGroupsProvider();
}
@Test
void getEmptyListIfNoGroupProvided() {
assertNotNull(cut.getGroups());
assertTrue(cut.getGroups().isEmpty());
}
@Test
void getReturnsOneProvidedGroup() {
cut.addGroup("Willi");
assertEquals(1, cut.getGroups().size());
assertEquals("Willi", cut.getGroups().get(0));
}
@Test
void getReturnsTwoSeparateProvidedGroup() {
cut.addGroup("Willi");
cut.addGroup("Hugo");
assertEquals(2, cut.getGroups().size());
assertTrue(cut.getGroups().contains("Willi"));
assertTrue(cut.getGroups().contains("Hugo"));
}
@Test
void getReturnsOneIgnoreNullSeparateProvidedGroup() {
cut.addGroup("Willi");
cut.addGroup(null);
assertEquals(1, cut.getGroups().size());
assertTrue(cut.getGroups().contains("Willi"));
}
@Test
void getReturnsProvidedGroupArray() {
cut.addGroups("Hugo", "Willi");
assertEquals(2, cut.getGroups().size());
assertTrue(cut.getGroups().contains("Willi"));
assertTrue(cut.getGroups().contains("Hugo"));
}
@Test
void getReturnsProvidedGroupCollection() {
cut.addGroups(Arrays.asList("Hugo", null, "Willi"));
assertEquals(2, cut.getGroups().size());
assertTrue(cut.getGroups().contains("Willi"));
assertTrue(cut.getGroups().contains("Hugo"));
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAAbstractCUDRequestHandlerTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAAbstractCUDRequestHandlerTest.java | package com.sap.olingo.jpa.processor.core.api;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.apache.olingo.commons.api.http.HttpStatusCode;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.processor.core.exception.ODataJPAProcessorException;
class JPAAbstractCUDRequestHandlerTest {
private JPAAbstractCUDRequestHandler cut;
@BeforeEach
void setup() {
cut = new ExampleJPAAbstractCUDRequestHandler();
}
@Test
void testThrowsNotImplementedOnDelete() {
final ODataJPAProcessorException act = assertThrows(ODataJPAProcessorException.class, () -> cut.deleteEntity(null,
null));
assertEquals(HttpStatusCode.NOT_IMPLEMENTED.getStatusCode(), act.getStatusCode());
}
@Test
void testThrowsNotImplementedOnUpdate() {
final ODataJPAProcessorException act = assertThrows(ODataJPAProcessorException.class, () -> cut.updateEntity(null,
null, null));
assertEquals(HttpStatusCode.NOT_IMPLEMENTED.getStatusCode(), act.getStatusCode());
}
@Test
void testThrowsNotImplementedOnCreate() {
final ODataJPAProcessorException act = assertThrows(ODataJPAProcessorException.class, () -> cut.createEntity(null,
null));
assertEquals(HttpStatusCode.NOT_IMPLEMENTED.getStatusCode(), act.getStatusCode());
}
private class ExampleJPAAbstractCUDRequestHandler extends JPAAbstractCUDRequestHandler {
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAODataBatchProcessorTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAODataBatchProcessorTest.java | package com.sap.olingo.jpa.processor.core.api;
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.ArgumentMatchers.any;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.List;
import jakarta.persistence.EntityManager;
import jakarta.persistence.OptimisticLockException;
import jakarta.persistence.RollbackException;
import org.apache.olingo.commons.api.format.PreferenceName;
import org.apache.olingo.commons.api.http.HttpStatusCode;
import org.apache.olingo.server.api.OData;
import org.apache.olingo.server.api.ODataApplicationException;
import org.apache.olingo.server.api.ODataLibraryException;
import org.apache.olingo.server.api.ODataRequest;
import org.apache.olingo.server.api.ODataResponse;
import org.apache.olingo.server.api.ServiceMetadata;
import org.apache.olingo.server.api.batch.BatchFacade;
import org.apache.olingo.server.api.deserializer.batch.BatchRequestPart;
import org.apache.olingo.server.api.deserializer.batch.ODataResponsePart;
import org.apache.olingo.server.api.prefer.Preferences;
import org.apache.olingo.server.api.prefer.Preferences.Preference;
import org.apache.olingo.server.api.serializer.BatchSerializerException;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import com.sap.olingo.jpa.processor.core.api.JPAODataTransactionFactory.JPAODataTransaction;
import com.sap.olingo.jpa.processor.core.exception.ODataJPAProcessException;
import com.sap.olingo.jpa.processor.core.exception.ODataJPAProcessorException;
import com.sap.olingo.jpa.processor.core.exception.ODataJPATransactionException;
import com.sap.olingo.jpa.processor.core.processor.JPAEmptyDebugger;
class JPAODataBatchProcessorTest {
private JPAODataBatchProcessor cut;
@Mock
private EntityManager em;
@Mock
private JPAODataTransaction transaction;
@Mock
private OData odata;
@Mock
private ServiceMetadata serviceMetadata;
@Mock
private BatchFacade facade;
@Mock
private ODataRequest request;
@Mock
private ODataResponse response;
@Mock
private RollbackException e;
@Mock
private JPAODataSessionContextAccess context;
@Mock
private JPACUDRequestHandler cudHandler;
@Mock
private JPAODataRequestContextAccess requestContext;
@Mock
private JPAODataTransactionFactory factory;
@Mock
private JPAODataSessionContextAccess sessionContext;
private List<ODataRequest> requests;
@BeforeEach
void setup() throws ODataJPATransactionException {
MockitoAnnotations.openMocks(this);
when(requestContext.getEntityManager()).thenReturn(em);
when(requestContext.getCUDRequestHandler()).thenReturn(cudHandler);
when(requestContext.getTransactionFactory()).thenReturn(factory);
when(factory.createTransaction()).thenReturn(transaction);
// final JPAODataCRUDContextAccess sessionContext = new JPAODataContextAccessDouble(edmProvider, ds, provider,
// functionPackage);
cut = new JPAODataBatchProcessor(sessionContext, requestContext);
cut.init(odata, serviceMetadata);
requests = new ArrayList<>();
requests.add(request);
when(requestContext.getDebugger()).thenReturn(new JPAEmptyDebugger());
}
@Test
void whenNotOptimisticLockRollBackExceptionThenThrowODataJPAProcessorExceptionWithHttpCode500()
throws ODataApplicationException, ODataLibraryException {
when(response.getStatusCode()).thenReturn(HttpStatusCode.OK.getStatusCode());
when(facade.handleODataRequest(request)).thenReturn(response);
doThrow(e).when(transaction).commit();
final ODataJPAProcessorException act = assertThrows(ODataJPAProcessorException.class,
() -> cut.processChangeSet(facade, requests));
assertEquals(HttpStatusCode.INTERNAL_SERVER_ERROR.getStatusCode(), act.getStatusCode());
}
@Test
void whenOptimisticLockRollBackExceptionThenThrowODataJPAProcessorExceptionWithHttpCode412()
throws ODataApplicationException, ODataLibraryException {
when(response.getStatusCode()).thenReturn(HttpStatusCode.OK.getStatusCode());
when(facade.handleODataRequest(request)).thenReturn(response);
doThrow(e).when(transaction).commit();
when(e.getCause()).thenReturn(new OptimisticLockException());
final ODataJPAProcessorException act = assertThrows(ODataJPAProcessorException.class,
() -> cut.processChangeSet(facade, requests));
assertEquals(HttpStatusCode.PRECONDITION_FAILED.getStatusCode(), act.getStatusCode());
}
@Test
void whenSuccessfulThenCallValidateChanges() throws ODataApplicationException,
ODataLibraryException {
cut = new JPAODataBatchProcessor(sessionContext, requestContext);
when(response.getStatusCode()).thenReturn(HttpStatusCode.OK.getStatusCode());
when(facade.handleODataRequest(request)).thenReturn(response);
cut.processChangeSet(facade, requests);
verify(cudHandler, times(1)).validateChanges(em);
}
@Test
void whenValidateChangesThrowsThenRollbackAndThrow() throws ODataApplicationException,
ODataLibraryException {
cut = new JPAODataBatchProcessor(sessionContext, requestContext);
final ODataJPAProcessException error = new ODataJPAProcessorException(
ODataJPAProcessorException.MessageKeys.GETTER_NOT_FOUND, HttpStatusCode.BAD_REQUEST);
when(response.getStatusCode()).thenReturn(HttpStatusCode.OK.getStatusCode());
when(facade.handleODataRequest(request)).thenReturn(response);
doThrow(error).when(cudHandler).validateChanges(em);
assertThrows(ODataJPAProcessorException.class, () -> cut.processChangeSet(facade, requests));
verify(transaction, never()).commit();
verify(transaction, times(1)).rollback();
}
//ODataLibraryException
@Test
void whenODataLibraryExceptionThrowsThenRollbackAndThrow() throws ODataApplicationException,
ODataLibraryException {
cut = new JPAODataBatchProcessor(sessionContext, requestContext);
final ODataLibraryException error = new BatchSerializerException("",
BatchSerializerException.MessageKeys.MISSING_CONTENT_ID, "");
when(response.getStatusCode()).thenReturn(HttpStatusCode.OK.getStatusCode());
when(facade.handleODataRequest(request)).thenThrow(error);
assertThrows(ODataLibraryException.class, () -> cut.processChangeSet(facade, requests));
verify(transaction, never()).commit();
verify(transaction, times(1)).rollback();
}
@Test
void whenNoExceptionOccurredThenCommit() throws ODataApplicationException, ODataLibraryException {
when(response.getStatusCode()).thenReturn(HttpStatusCode.OK.getStatusCode());
when(facade.handleODataRequest(request)).thenReturn(response);
final ODataResponsePart act = cut.processChangeSet(facade, requests);
verify(transaction, times(1)).commit();
assertTrue(act.isChangeSet());
}
@Test
void whenProcessChangeSetReturnsUnsuccessfulCallThenRollback() throws ODataApplicationException,
ODataLibraryException {
cut = new JPAODataBatchProcessor(sessionContext, requestContext);
when(response.getStatusCode()).thenReturn(HttpStatusCode.BAD_REQUEST.getStatusCode());
when(facade.handleODataRequest(request)).thenReturn(response);
final ODataResponsePart act = cut.processChangeSet(facade, requests);
verify(cudHandler, never()).validateChanges(em);
verify(transaction, never()).commit();
verify(transaction, times(1)).rollback();
assertFalse(act.isChangeSet());
}
@Test
void whenTransactionCouldNotBeCreatedThenThrowWith501() throws ODataApplicationException,
ODataLibraryException {
when(factory.createTransaction()).thenThrow(new ODataJPATransactionException());
when(response.getStatusCode()).thenReturn(HttpStatusCode.OK.getStatusCode());
final ODataJPAProcessorException act = assertThrows(ODataJPAProcessorException.class, () -> cut.processChangeSet(
facade, requests));
assertEquals(HttpStatusCode.NOT_IMPLEMENTED.getStatusCode(), act.getStatusCode());
verify(facade, never()).handleODataRequest(any());
}
@Test
void whenNoContinueHeaderContinueOnErrorReturnsFalse() {
final Preferences preferences = mock(Preferences.class);
when(preferences.getPreference(PreferenceName.CONTINUE_ON_ERROR.getName())).thenReturn(null);
assertFalse(cut.continueOnError(preferences));
}
@Test
void whenContinueHeaderNoValueContinueOnErrorReturnsTrue() {
final Preferences preferences = mock(Preferences.class);
final Preference continueOnError = mock(Preference.class);
when(preferences.getPreference(PreferenceName.CONTINUE_ON_ERROR.getName())).thenReturn(continueOnError);
when(continueOnError.getValue()).thenReturn(null);
assertTrue(cut.continueOnError(preferences));
}
@Test
void whenContinueHeaderTrueContinueOnErrorReturnsTrue() {
final Preferences preferences = mock(Preferences.class);
final Preference continueOnError = mock(Preference.class);
when(preferences.getPreference(PreferenceName.CONTINUE_ON_ERROR.getName())).thenReturn(continueOnError);
when(continueOnError.getValue()).thenReturn("true");
assertTrue(cut.continueOnError(preferences));
}
@Test
void whenContinueHeaderFalseContinueOnErrorReturnsFalse() {
final Preferences preferences = mock(Preferences.class);
final Preference continueOnError = mock(Preference.class);
when(preferences.getPreference(PreferenceName.CONTINUE_ON_ERROR.getName())).thenReturn(continueOnError);
when(continueOnError.getValue()).thenReturn("false");
assertFalse(cut.continueOnError(preferences));
}
@Test
void whenNotContinueOnErrorSecondNotPerformed() throws ODataApplicationException, ODataLibraryException {
final List<BatchRequestPart> requestParts = createBatchRequest();
final ODataResponsePart response = mock(ODataResponsePart.class);
final List<ODataResponse> responses = createBatchPartResponse(400);
when(facade.handleBatchRequest(requestParts.get(0))).thenReturn(response);
when(response.getResponses()).thenReturn(responses);
cut.executeBatchParts(facade, requestParts, false);
verify(facade, times(1)).handleBatchRequest(any());
}
@Test
void whenContinueOnErrorSecondPerformed() throws ODataApplicationException, ODataLibraryException {
final List<BatchRequestPart> requestParts = createBatchRequest();
final ODataResponsePart response1 = mock(ODataResponsePart.class);
final ODataResponsePart response2 = mock(ODataResponsePart.class);
final List<ODataResponse> responses1 = createBatchPartResponse(400);
final List<ODataResponse> responses2 = createBatchPartResponse(200);
when(facade.handleBatchRequest(requestParts.get(0))).thenReturn(response1);
when(response1.getResponses()).thenReturn(responses1);
when(facade.handleBatchRequest(requestParts.get(1))).thenReturn(response2);
when(response2.getResponses()).thenReturn(responses2);
final List<ODataResponsePart> act = cut.executeBatchParts(facade, requestParts, true);
verify(facade, times(2)).handleBatchRequest(any());
assertEquals(2, act.size());
}
@Test
void whenNotContinueOnErrorSecondPerformedNoFailure() throws ODataApplicationException, ODataLibraryException {
final List<BatchRequestPart> requestParts = createBatchRequest();
final ODataResponsePart response1 = mock(ODataResponsePart.class);
final ODataResponsePart response2 = mock(ODataResponsePart.class);
final List<ODataResponse> responses1 = createBatchPartResponse(200);
final List<ODataResponse> responses2 = createBatchPartResponse(200);
when(facade.handleBatchRequest(requestParts.get(0))).thenReturn(response1);
when(response1.getResponses()).thenReturn(responses1);
when(facade.handleBatchRequest(requestParts.get(1))).thenReturn(response2);
when(response2.getResponses()).thenReturn(responses2);
final List<ODataResponsePart> act = cut.executeBatchParts(facade, requestParts, false);
verify(facade, times(2)).handleBatchRequest(any());
assertEquals(2, act.size());
}
private List<BatchRequestPart> createBatchRequest() {
final List<BatchRequestPart> requestParts = new ArrayList<>();
final BatchRequestPart part1 = mock(BatchRequestPart.class);
final BatchRequestPart part2 = mock(BatchRequestPart.class);
requestParts.add(part1);
requestParts.add(part2);
return requestParts;
}
private List<ODataResponse> createBatchPartResponse(final int statusCode) {
final List<ODataResponse> responses = new ArrayList<>();
final ODataResponse response = mock(ODataResponse.class);
responses.add(response);
when(response.getStatusCode()).thenReturn(statusCode);
return responses;
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAODataRequestProcessorTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/api/JPAODataRequestProcessorTest.java | package com.sap.olingo.jpa.processor.core.api;
import static com.sap.olingo.jpa.processor.core.api.example.JPAExampleModifyException.MessageKeys.MODIFY_NOT_ALLOWED;
import static com.sap.olingo.jpa.processor.core.exception.ODataJPAProcessorException.MessageKeys.NO_METADATA_PROVIDER;
import static org.apache.olingo.commons.api.format.ContentType.JSON;
import static org.apache.olingo.commons.api.http.HttpStatusCode.INTERNAL_SERVER_ERROR;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyList;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;
import jakarta.persistence.EntityManager;
import jakarta.persistence.OptimisticLockException;
import jakarta.persistence.RollbackException;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;
import org.apache.olingo.commons.api.data.Entity;
import org.apache.olingo.commons.api.edm.EdmAction;
import org.apache.olingo.commons.api.edm.EdmEntitySet;
import org.apache.olingo.commons.api.edm.EdmPrimitiveType;
import org.apache.olingo.commons.api.edm.EdmProperty;
import org.apache.olingo.commons.api.edm.EdmReturnType;
import org.apache.olingo.commons.api.edm.constants.EdmTypeKind;
import org.apache.olingo.commons.api.ex.ODataException;
import org.apache.olingo.commons.api.format.ContentType;
import org.apache.olingo.commons.api.http.HttpHeader;
import org.apache.olingo.commons.api.http.HttpMethod;
import org.apache.olingo.commons.api.http.HttpStatusCode;
import org.apache.olingo.server.api.OData;
import org.apache.olingo.server.api.ODataApplicationException;
import org.apache.olingo.server.api.ODataRequest;
import org.apache.olingo.server.api.ODataResponse;
import org.apache.olingo.server.api.ServiceMetadata;
import org.apache.olingo.server.api.deserializer.DeserializerException;
import org.apache.olingo.server.api.deserializer.DeserializerResult;
import org.apache.olingo.server.api.deserializer.ODataDeserializer;
import org.apache.olingo.server.api.prefer.Preferences;
import org.apache.olingo.server.api.prefer.Preferences.Return;
import org.apache.olingo.server.api.serializer.ODataSerializer;
import org.apache.olingo.server.api.serializer.SerializerException;
import org.apache.olingo.server.api.serializer.SerializerResult;
import org.apache.olingo.server.api.uri.UriInfo;
import org.apache.olingo.server.api.uri.UriParameter;
import org.apache.olingo.server.api.uri.UriResource;
import org.apache.olingo.server.api.uri.UriResourceAction;
import org.apache.olingo.server.api.uri.UriResourceComplexProperty;
import org.apache.olingo.server.api.uri.UriResourceEntitySet;
import org.apache.olingo.server.api.uri.UriResourceKind;
import org.apache.olingo.server.api.uri.UriResourcePrimitiveProperty;
import org.apache.olingo.server.api.uri.UriResourceProperty;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.function.Executable;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import com.sap.olingo.jpa.metadata.api.JPAEdmProvider;
import com.sap.olingo.jpa.metadata.api.JPAHttpHeaderMap;
import com.sap.olingo.jpa.metadata.api.JPARequestParameterMap;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAction;
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.JPAOperationResultParameter;
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.core.api.example.JPAExampleModifyException;
import com.sap.olingo.jpa.processor.core.exception.ODataJPAProcessorException;
import com.sap.olingo.jpa.processor.core.modify.JPAUpdateResult;
import com.sap.olingo.jpa.processor.core.testobjects.TestJavaActionNoParameter;
class JPAODataRequestProcessorTest {
private static final String ODATA_VERSION = "4.00";
private static JPAODataRequestProcessor cut;
private static EntityManager em;
private static JPAODataClaimsProvider claims;
private JPAODataSessionContextAccess sessionContext;
private static ODataRequest request;
private static ODataResponse response;
private static UriInfo uriInfo;
private OData odata;
private static ServiceMetadata serviceMetadata;
private static List<UriResource> resourceParts;
private JPAODataRequestContextAccess requestContext;
private ODataDeserializer deserializer;
private ODataSerializer serializer;
private SerializerResult serializerResult;
private static JPAServiceDebugger debugger;
private static JPAEntityType et;
static Stream<Executable> modifyMediaTypeMethodsProvider() {
return Stream.of(() -> {
cut.createMediaEntity(null, null, null, null, null);
}, () -> {
cut.updateMediaEntity(null, null, null, null, null);
}, () -> {
cut.deleteMediaEntity(null, null, null);
});
}
static Stream<Executable> updatePrimitiveValueMethodsProvider() {
return Stream.of(() -> {
cut.updatePrimitiveValue(null, null, null, null, null);
});
}
static Stream<Executable> notSupportedMethodsProvider() {
return Stream.of(
() -> {
cut.updatePrimitiveValue(null, null, null, null, null);
},
() -> {
cut.updateComplex(null, null, null, null, null);
},
() -> {
cut.deletePrimitiveValue(request, response, uriInfo);
});
}
static Stream<Executable> supportedDeletingMethodsProvider() {
return Stream.of(
() -> {
cut.deleteEntity(request, response, uriInfo);
},
() -> {
cut.deleteComplex(request, response, uriInfo);
},
() -> {
cut.deletePrimitive(request, response, uriInfo);
},
() -> {
cut.deleteComplexCollection(request, response, uriInfo);
},
() -> {
cut.deletePrimitiveCollection(request, response, uriInfo);
});
}
static Stream<Executable> supportedUpdatingMethodsProvider() {
return Stream.of(
() -> {
cut.updateComplexCollection(request, response, uriInfo, JSON, JSON);
},
() -> {
cut.updatePrimitive(request, response, uriInfo, JSON,
JSON);
},
() -> {
cut.updatePrimitiveCollection(request, response, uriInfo, JSON,
JSON);
});
}
static Stream<Executable> supportedCreatingMethodsProvider() {
return Stream.of(
() -> {
cut.createEntity(request, response, uriInfo, JSON, JSON);
});
}
static Stream<Executable> supportedModifyingMethodsProvider() {
return Stream.concat(
Stream.concat(supportedUpdatingMethodsProvider(), supportedDeletingMethodsProvider()),
supportedCreatingMethodsProvider());
}
static Stream<Executable> supportedReadingMethodsProvider() {
return Stream.of(
() -> {
cut.countEntityCollection(request, response, uriInfo);
},
() -> {
cut.createEntity(request, response, uriInfo, JSON, JSON);
},
() -> {
cut.readComplex(request, response, uriInfo, JSON);
},
() -> {
cut.readComplexCollection(request, response, uriInfo, JSON);
},
() -> {
cut.readEntity(request, response, uriInfo, JSON);
},
() -> {
cut.readEntityCollection(request, response, uriInfo, JSON);
},
() -> {
cut.readPrimitive(request, response, uriInfo, JSON);
},
() -> {
cut.readPrimitiveCollection(request, response, uriInfo, JSON);
},
() -> {
cut.readPrimitiveValue(request, response, uriInfo, JSON);
},
() -> {
cut.readMediaEntity(request, response, uriInfo, JSON);
},
() -> {
cut.processActionPrimitive(request, response, uriInfo, JSON,
JSON);
},
() -> {
cut.processActionVoid(request, response, uriInfo, JSON);
});
}
static Stream<Executable> supportedMethodsProvider() {
return Stream.concat(supportedModifyingMethodsProvider(), supportedReadingMethodsProvider());
}
static Stream<Executable> throwsSerializerExceptionMethodsProvider() {
return Stream.of(() -> {
cut.createEntity(request, response, uriInfo, JSON, JSON);
}, () -> {
cut.updateEntity(request, response, uriInfo, JSON, JSON);
}, () -> {
cut.readEntity(request, response, uriInfo, JSON);
});
}
@BeforeAll
static void classSetup() {
em = mock(EntityManager.class);
claims = new JPAODataClaimsProvider();
request = mock(ODataRequest.class);
response = mock(ODataResponse.class);
uriInfo = mock(UriInfo.class);
serviceMetadata = mock(ServiceMetadata.class);
resourceParts = new ArrayList<>(0);
final UriResource resourcePart = mock(UriResource.class);
resourceParts.add(resourcePart);
debugger = mock(JPAServiceDebugger.class);
et = mock(JPAEntityType.class);
when(uriInfo.getUriResourceParts()).thenReturn(resourceParts);
when(resourcePart.getKind()).thenReturn(UriResourceKind.navigationProperty);
}
@BeforeEach
void setup() throws ODataException {
final List<String> versionList = Collections.singletonList(ODATA_VERSION);
final Preferences prefer = mock(Preferences.class);
odata = mock(OData.class);
sessionContext = mock(JPAODataSessionContextAccess.class);
requestContext = mock(JPAODataRequestContextAccess.class);
deserializer = mock(ODataDeserializer.class);
serializer = mock(ODataSerializer.class);
serializerResult = mock(SerializerResult.class);
createServiceDocument();
when(requestContext.getClaimsProvider()).thenReturn(Optional.ofNullable(claims));
when(requestContext.getEntityManager()).thenReturn(em);
when(requestContext.getRequestParameter()).thenReturn(mock(JPARequestParameterMap.class));
when(requestContext.getHeader()).thenReturn(mock(JPAHttpHeaderMap.class));
when(requestContext.getDebugger()).thenReturn(debugger);
when(odata.createDeserializer(any())).thenReturn(deserializer);
when(odata.createDeserializer(any(), eq(versionList))).thenReturn(deserializer);
when(odata.createPreferences(any())).thenReturn(prefer);
when(odata.createSerializer(any(), anyList())).thenReturn(serializer);
when(prefer.getReturn()).thenReturn(Return.MINIMAL);
when(request.getHeaders(HttpHeader.ODATA_VERSION)).thenReturn(versionList);
final DeserializerResult deserializerResult = mock(DeserializerResult.class);
final Entity entity = mock(Entity.class);
when(deserializer.entity(any(), any())).thenReturn(deserializerResult);
when(deserializerResult.getEntity()).thenReturn(entity);
when(serializer.primitive(any(), any(), any(), any())).thenReturn(serializerResult);
cut = new JPAODataRequestProcessor(sessionContext, requestContext);
cut.init(odata, serviceMetadata);
}
@ParameterizedTest
@MethodSource("modifyMediaTypeMethodsProvider")
void checkModifyMediaEntityThrowsNotImplemented(final Executable m) {
final ODataJPAProcessorException act = assertThrows(ODataJPAProcessorException.class, m);
assertEquals(HttpStatusCode.NOT_IMPLEMENTED.getStatusCode(), act.getStatusCode());
}
@ParameterizedTest
@MethodSource("notSupportedMethodsProvider")
void checkNutSupportedThrowsNotImplemented(final Executable method) {
final ODataJPAProcessorException act = assertThrows(ODataJPAProcessorException.class, method);
assertEquals(HttpStatusCode.NOT_IMPLEMENTED.getStatusCode(), act.getStatusCode());
}
@ParameterizedTest
@MethodSource("throwsSerializerExceptionMethodsProvider")
void checkCreateEntityPropagateSerializerException(final Executable method) throws SerializerException {
when(odata.createSerializer(JSON, Collections.emptyList()))
.thenThrow(SerializerException.class);
assertThrows(ODataException.class, method);
}
@Test
void checkUpdateEntityPropagateSerializerException() throws SerializerException {
when(odata.createSerializer(JSON, Collections.emptyList()))
.thenThrow(SerializerException.class);
assertThrows(ODataException.class, () -> {
cut.updateEntity(request, response, uriInfo, JSON, JSON);
});
}
@Test
void checkDeleteEntityCallsDelete() throws ODataException {
when(request.getMethod()).thenReturn(HttpMethod.DELETE);
final JPACUDRequestHandler handler = mock(JPACUDRequestHandler.class);
final JPAServiceDocument sd = prepareRequest(handler);
final JPAEntityType otherEt = mock(JPAEntityType.class);
final UriResourceEntitySet entitySet = createEntitySet(sd, otherEt);
resourceParts.add(entitySet);
cut.deleteEntity(request, response, uriInfo);
verify(handler).deleteEntity(any(), eq(em));
}
@Test
void checkDeleteEntityRethrowExceptionOnHandlerFail() throws ODataException {
when(request.getMethod()).thenReturn(HttpMethod.DELETE);
final JPACUDRequestHandler handler = mock(JPACUDRequestHandler.class);
final JPAServiceDocument sd = prepareRequest(handler);
final JPAEntityType otherEt = mock(JPAEntityType.class);
final UriResourceEntitySet entitySet = createEntitySet(sd, otherEt);
resourceParts.add(entitySet);
doThrow(new JPAExampleModifyException(
MODIFY_NOT_ALLOWED, HttpStatusCode.BAD_REQUEST)).when(handler).deleteEntity(any(), eq(em));
assertThrows(JPAExampleModifyException.class, () -> cut.deleteEntity(request, response, uriInfo));
}
static Stream<Pair<Executable, UriResourceProperty>> deletingMethods() throws ODataJPAModelException {
final Executable deleteComplex = () -> {
cut.deleteComplex(request, response, uriInfo);
};
final Executable deleteComplexCollection = () -> {
cut.deleteComplexCollection(request, response, uriInfo);
};
final Executable deletePrimitive = () -> {
cut.deletePrimitive(request, response, uriInfo);
};
final Executable deletePrimitiveCollection = () -> {
cut.deletePrimitiveCollection(request, response, uriInfo);
};
return Stream.of(
new ImmutablePair<>(deleteComplex, createComplexType(et)),
new ImmutablePair<>(deleteComplexCollection, createComplexType(et)),
new ImmutablePair<>(deletePrimitive, createPrimitiveType(et)),
new ImmutablePair<>(deletePrimitiveCollection, createPrimitiveType(et)));
}
@ParameterizedTest
@MethodSource("deletingMethods")
void checkDeleteElementCallsUpdate(final Pair<Executable, UriResourceProperty> test) throws Throwable {
when(request.getMethod()).thenReturn(HttpMethod.DELETE);
final JPACUDRequestHandler handler = mock(JPACUDRequestHandler.class);
final JPAServiceDocument sd = prepareRequest(handler);
final UriResourceEntitySet entitySet = createEntitySet(sd, et);
resourceParts.add(entitySet);
resourceParts.add(test.getRight());
test.getLeft().execute();
verify(handler).updateEntity(any(), eq(em), eq(HttpMethod.DELETE));
}
@ParameterizedTest
@MethodSource("deletingMethods")
void checkDeleteElementRethrowsRollbackAsPreconditionFailed(final Pair<Executable, UriResourceProperty> test)
throws ODataException {
when(request.getMethod()).thenReturn(HttpMethod.DELETE);
final JPACUDRequestHandler handler = mock(JPACUDRequestHandler.class);
final JPAServiceDocument sd = prepareRequest(handler);
final UriResourceEntitySet entitySet = createEntitySet(sd, et);
when(handler.updateEntity(any(), any(), any())).thenThrow(new RollbackException(
new OptimisticLockException()));
resourceParts.add(entitySet);
resourceParts.add(test.getRight());
final ODataJPAProcessorException act = assertThrows(ODataJPAProcessorException.class, test.getLeft());
assertEquals(HttpStatusCode.PRECONDITION_FAILED.getStatusCode(), act.getStatusCode());
}
@Test
void checkDeleteEntityRethrowsRollbackAsPreconditionFailed() throws ODataException {
when(request.getMethod()).thenReturn(HttpMethod.DELETE);
final JPACUDRequestHandler handler = mock(JPACUDRequestHandler.class);
final JPAServiceDocument sd = prepareRequest(handler);
final UriResourceEntitySet entitySet = createEntitySet(sd, et);
doThrow(new RollbackException(new OptimisticLockException())).when(handler).deleteEntity(any(), eq(em));
resourceParts.add(entitySet);
final ODataJPAProcessorException act = assertThrows(ODataJPAProcessorException.class, () -> cut.deleteEntity(
request, response, uriInfo));
assertEquals(HttpStatusCode.PRECONDITION_FAILED.getStatusCode(), act.getStatusCode());
}
@Test
void checkDeletePrimitiveRethrowExceptionOnHandlerFail() throws ODataException {
when(request.getMethod()).thenReturn(HttpMethod.DELETE);
final JPACUDRequestHandler handler = mock(JPACUDRequestHandler.class);
final JPAServiceDocument sd = prepareRequest(handler);
final JPAEntityType otherEt = mock(JPAEntityType.class);
final UriResourceEntitySet entitySet = createEntitySet(sd, otherEt);
final UriResourcePrimitiveProperty primitiveProperty = createPrimitiveType(otherEt);
resourceParts.add(entitySet);
resourceParts.add(primitiveProperty);
when(handler.updateEntity(any(), eq(em), eq(HttpMethod.DELETE))).thenThrow(new JPAExampleModifyException(
MODIFY_NOT_ALLOWED, HttpStatusCode.BAD_REQUEST));
assertThrows(JPAExampleModifyException.class, () -> cut.deletePrimitive(request, response, uriInfo));
}
@Test
void checkDeletePrimitiveCollectionRethrowExceptionOnHandlerFail() throws ODataException {
when(request.getMethod()).thenReturn(HttpMethod.DELETE);
final JPACUDRequestHandler handler = mock(JPACUDRequestHandler.class);
final JPAServiceDocument sd = prepareRequest(handler);
final JPAEntityType otherEt = mock(JPAEntityType.class);
final UriResourceEntitySet entitySet = createEntitySet(sd, otherEt);
final UriResourcePrimitiveProperty primitiveProperty = createPrimitiveType(otherEt);
resourceParts.add(entitySet);
resourceParts.add(primitiveProperty);
when(handler.updateEntity(any(), eq(em), eq(HttpMethod.DELETE))).thenThrow(new JPAExampleModifyException(
MODIFY_NOT_ALLOWED, HttpStatusCode.BAD_REQUEST));
assertThrows(JPAExampleModifyException.class, () -> cut.deletePrimitiveCollection(request, response, uriInfo));
}
@Test
void checkDeleteComplexCollectionRethrowExceptionOnHandlerFail() throws ODataException {
when(request.getMethod()).thenReturn(HttpMethod.DELETE);
final JPACUDRequestHandler handler = mock(JPACUDRequestHandler.class);
final JPAServiceDocument sd = prepareRequest(handler);
final JPAEntityType otherEt = mock(JPAEntityType.class);
final UriResourceEntitySet entitySet = createEntitySet(sd, otherEt);
final UriResourceComplexProperty complexProperty = createComplexType(otherEt);
resourceParts.add(entitySet);
resourceParts.add(complexProperty);
when(handler.updateEntity(any(), eq(em), eq(HttpMethod.DELETE))).thenThrow(new JPAExampleModifyException(
MODIFY_NOT_ALLOWED, HttpStatusCode.BAD_REQUEST));
assertThrows(JPAExampleModifyException.class, () -> cut.deleteComplexCollection(request, response, uriInfo));
}
@ParameterizedTest
@MethodSource("supportedMethodsProvider")
void checkThrowProcessorExceptionOnODataException(final Executable m) throws ODataException {
final ODataSerializer otherSerializer = mock(ODataSerializer.class);
when(odata.createSerializer(JSON, Collections.emptyList())).thenReturn(otherSerializer);
prepareRequestThrowsException();
final ODataApplicationException act = assertThrows(ODataApplicationException.class, m);
assertEquals(HttpStatusCode.INTERNAL_SERVER_ERROR.getStatusCode(), act.getStatusCode());
}
@Test
void checkUpdateEntityCallsUpdate() throws ODataException {
when(request.getMethod()).thenReturn(HttpMethod.PATCH);
final JPACUDRequestHandler handler = mock(JPACUDRequestHandler.class);
final JPAServiceDocument sd = prepareRequest(handler);
final JPAEntityType otherEt = mock(JPAEntityType.class);
final UriResourceEntitySet entitySet = createEntitySet(sd, otherEt);
final JPAUpdateResult result = new JPAUpdateResult(false, null);
when(handler.updateEntity(any(), any(), any())).thenReturn(result);
resourceParts.add(entitySet);
cut.updateEntity(request, response, uriInfo, ContentType.JSON, ContentType.JSON);
verify(handler).updateEntity(any(), eq(em), eq(HttpMethod.PATCH));
}
@Test
void checkUpdateEntityRethrowsRollbackAsPreconditionFailed() throws ODataException {
when(request.getMethod()).thenReturn(HttpMethod.PATCH);
final JPACUDRequestHandler handler = mock(JPACUDRequestHandler.class);
final JPAServiceDocument sd = prepareRequest(handler);
final JPAEntityType otherEt = mock(JPAEntityType.class);
final UriResourceEntitySet entitySet = createEntitySet(sd, otherEt);
when(handler.updateEntity(any(), any(), any())).thenThrow(new RollbackException(
new OptimisticLockException()));
resourceParts.add(entitySet);
final ODataJPAProcessorException act = assertThrows(ODataJPAProcessorException.class, () -> cut.updateEntity(
request, response, uriInfo, ContentType.JSON, ContentType.JSON));
assertEquals(HttpStatusCode.PRECONDITION_FAILED.getStatusCode(), act.getStatusCode());
}
@Test
void checkActionWithReturnIsPerformed() throws ODataException, NoSuchMethodException, SecurityException {
when(request.getMethod()).thenReturn(HttpMethod.POST);
final JPACUDRequestHandler handler = mock(JPACUDRequestHandler.class);
final EdmPrimitiveType edmReturnType = mock(EdmPrimitiveType.class);
final EdmReturnType returnType = mock(EdmReturnType.class);
final JPAServiceDocument sd = prepareRequest(handler);
final UriResourceAction action = createAction(sd, returnType);
when(returnType.isCollection()).thenReturn(Boolean.FALSE);
when(returnType.getType()).thenReturn(edmReturnType);
when(edmReturnType.getKind()).thenReturn(EdmTypeKind.PRIMITIVE);
resourceParts.add(action);
cut.processActionPrimitive(request, response, uriInfo, JSON, JSON);
verify(response).setStatusCode(HttpStatusCode.OK.getStatusCode());
}
@Test
void checkActionWithVoidIsPerformed() throws ODataException, NoSuchMethodException, SecurityException {
final ODataResponse otherResponse = mock(ODataResponse.class);
when(request.getMethod()).thenReturn(HttpMethod.POST);
final JPACUDRequestHandler handler = mock(JPACUDRequestHandler.class);
final JPAServiceDocument sd = prepareRequest(handler);
final UriResourceAction action = createAction(sd, null);
resourceParts.add(action);
cut.processActionVoid(request, otherResponse, uriInfo, JSON);
verify(otherResponse).setStatusCode(HttpStatusCode.OK.getStatusCode());
}
private UriResourceAction createAction(final JPAServiceDocument sd, final EdmReturnType returnType)
throws DeserializerException, NoSuchMethodException, SecurityException {
final JPAAction jpaAction = mock(JPAAction.class);
final EdmAction edmAction = mock(EdmAction.class);
final UriResourceAction action = mock(UriResourceAction.class);
when(action.getKind()).thenReturn(UriResourceKind.action);
when(action.getAction()).thenReturn(edmAction);
when(edmAction.getReturnType()).thenReturn(returnType);
when(sd.getAction(edmAction)).thenReturn(jpaAction);
when(jpaAction.getConstructor()).thenAnswer(new Answer<Constructor<?>>() {
@Override
public Constructor<?> answer(final InvocationOnMock invocation) throws Throwable {
return TestJavaActionNoParameter.class.getConstructor();
}
});
final Method method = TestJavaActionNoParameter.class.getMethod("unboundReturnPrimitiveNoParameter");
when(jpaAction.getMethod()).thenReturn(method);
final DeserializerResult deserializerValue = mock(DeserializerResult.class);
when(deserializer.actionParameters(any(), any())).thenReturn(deserializerValue);
when(deserializerValue.getActionParameters()).thenReturn(Collections.emptyMap());
final JPAOperationResultParameter jpaResultParameter = mock(JPAOperationResultParameter.class);
when(jpaAction.getResultParameter()).thenReturn(jpaResultParameter);
when(jpaResultParameter.isCollection()).thenReturn(Boolean.FALSE);
return action;
}
private UriResourceEntitySet createEntitySet(final JPAServiceDocument sd, final JPAEntityType et)
throws ODataJPAModelException {
final EdmEntitySet edmEntitySet = mock(EdmEntitySet.class);
final UriResourceEntitySet entitySet = mock(UriResourceEntitySet.class);
final List<UriParameter> keyPredicate = new ArrayList<>();
when(entitySet.getKind()).thenReturn(UriResourceKind.entitySet);
when(entitySet.getEntitySet()).thenReturn(edmEntitySet);
when(entitySet.getKeyPredicates()).thenReturn(keyPredicate);
when(edmEntitySet.getName()).thenReturn("Organizations");
when(sd.getEntity(anyString())).thenReturn(et);
return entitySet;
}
private JPAServiceDocument prepareRequest(final JPACUDRequestHandler handler) throws ODataException {
resourceParts.clear();
final JPAServiceDocument sd = createServiceDocument();
when(requestContext.getCUDRequestHandler()).thenReturn(handler);
return sd;
}
private JPAServiceDocument createServiceDocument() throws ODataException {
final JPAServiceDocument sd = mock(JPAServiceDocument.class);
final JPAEdmProvider edmProvider = mock(JPAEdmProvider.class);
when(requestContext.getEdmProvider()).thenReturn(edmProvider);
when(edmProvider.getServiceDocument()).thenReturn(sd);
return sd;
}
private void prepareRequestThrowsException() throws ODataException {
resourceParts.clear();
final JPACUDRequestHandler handler = mock(JPACUDRequestHandler.class);
final JPAServiceDocument sd = prepareRequest(handler);
final JPAEntityType otherEt = mock(JPAEntityType.class);
final UriResourceEntitySet entitySet = createEntitySet(sd, otherEt);
resourceParts.add(entitySet);
when(requestContext.getEdmProvider())
.thenThrow(new ODataJPAProcessorException(NO_METADATA_PROVIDER, INTERNAL_SERVER_ERROR));
}
private static UriResourceComplexProperty createComplexType(final JPAEntityType et) throws ODataJPAModelException {
final EdmProperty edmProperty = mock(EdmProperty.class);
final UriResourceComplexProperty complexProperty = mock(UriResourceComplexProperty.class);
final JPAPath path = mock(JPAPath.class);
final JPAAttribute jpaAttribute = mock(JPAAttribute.class);
when(complexProperty.getKind()).thenReturn(UriResourceKind.complexProperty);
when(complexProperty.getProperty()).thenReturn(edmProperty);
when(edmProperty.getName()).thenReturn("Address");
when(et.getPath("Address")).thenReturn(path);
when(path.getLeaf()).thenReturn(jpaAttribute);
when(jpaAttribute.getInternalName()).thenReturn("address");
return complexProperty;
}
private static UriResourcePrimitiveProperty createPrimitiveType(final JPAEntityType et)
throws ODataJPAModelException {
final EdmProperty edmProperty = mock(EdmProperty.class);
final UriResourcePrimitiveProperty primitiveProperty = mock(UriResourcePrimitiveProperty.class);
final JPAPath path = mock(JPAPath.class);
final JPAAttribute jpaAttribute = mock(JPAAttribute.class);
when(primitiveProperty.getKind()).thenReturn(UriResourceKind.primitiveProperty);
when(primitiveProperty.getProperty()).thenReturn(edmProperty);
when(edmProperty.getName()).thenReturn("Name1");
when(et.getPath("Name1")).thenReturn(path);
when(path.getLeaf()).thenReturn(jpaAttribute);
when(jpaAttribute.getInternalName()).thenReturn("name1");
return primitiveProperty;
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/api/example/JPAExamplePagingProviderTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/api/example/JPAExamplePagingProviderTest.java | package com.sap.olingo.jpa.processor.core.api.example;
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.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import org.apache.olingo.commons.api.edm.EdmEntitySet;
import org.apache.olingo.commons.api.edm.EdmProperty;
import org.apache.olingo.commons.api.edm.EdmType;
import org.apache.olingo.server.api.ODataApplicationException;
import org.apache.olingo.server.api.uri.UriInfo;
import org.apache.olingo.server.api.uri.UriInfoResource;
import org.apache.olingo.server.api.uri.UriResource;
import org.apache.olingo.server.api.uri.UriResourceEntitySet;
import org.apache.olingo.server.api.uri.UriResourceKind;
import org.apache.olingo.server.api.uri.UriResourcePrimitiveProperty;
import org.apache.olingo.server.api.uri.queryoption.OrderByItem;
import org.apache.olingo.server.api.uri.queryoption.OrderByOption;
import org.apache.olingo.server.api.uri.queryoption.SkipOption;
import org.apache.olingo.server.api.uri.queryoption.SystemQueryOptionKind;
import org.apache.olingo.server.api.uri.queryoption.TopOption;
import org.apache.olingo.server.api.uri.queryoption.expression.Member;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.processor.core.api.JPAODataPage;
import com.sap.olingo.jpa.processor.core.query.JPACountQuery;
class JPAExamplePagingProviderTest {
private JPACountQuery countQuery;
@BeforeEach
void setup() throws ODataApplicationException {
countQuery = mock(JPACountQuery.class);
when(countQuery.countResults()).thenReturn(10L);
}
@Test
void testReturnDefaultTopSkipPageSize2() throws ODataApplicationException {
final UriInfo info = buildUriInfo();
final JPAExamplePagingProvider cut = createOrganizationCut(2);
final Optional<JPAODataPage> act = cut.getFirstPage(null, null, info, null, countQuery, null);
assertEquals(0, act.get().skip());
assertEquals(2, act.get().top());
assertNotNull(toODataString(act.get().skipToken().toString()));
assertEquals(info, act.get().uriInfo());
}
@Test
void testReturnDefaultTopSkipPageSize5() throws ODataApplicationException {
final UriInfo info = buildUriInfo();
final JPAExamplePagingProvider cut = createOrganizationCut(5);
final Optional<JPAODataPage> act = cut.getFirstPage(null, null, info, null, countQuery, null);
assertEquals(0, act.get().skip());
assertEquals(5, act.get().top());
assertNotNull(toODataString(act.get().skipToken().toString()));
assertEquals(info, act.get().uriInfo());
}
@Test
void testReturnDefaultTopSkipPageSizeOther() throws ODataApplicationException {
final UriInfo info = buildUriInfo("AdministrativeDivisions", "AdministrativeDivision");
final JPAExamplePagingProvider cut = createOrganizationCut(5);
when(countQuery.countResults()).thenReturn(12L);
final Optional<JPAODataPage> act = cut.getFirstPage(null, null, info, null, countQuery, null);
assertEquals(0, act.get().skip());
assertEquals(10, act.get().top());
assertNotNull(toODataString(act.get().skipToken().toString()));
assertEquals(info, act.get().uriInfo());
}
@Test
void testReturnDefaultTopSkipPageSize5NextPage() throws ODataApplicationException {
final UriInfo info = buildUriInfo();
final JPAExamplePagingProvider cut = createOrganizationCut(5);
Optional<JPAODataPage> act = cut.getFirstPage(null, null, info, null, countQuery, null);
act = cut.getNextPage(toODataString(act.get().skipToken().toString()), null, null, null, null);
assertEquals(5, act.get().skip());
assertEquals(5, act.get().top());
assertEquals(info, act.get().uriInfo());
}
@Test
void testReturnNullIfEntitySetIsUnknown() throws ODataApplicationException {
final UriInfo info = buildUriInfo();
final JPAExamplePagingProvider cut = createPersonCut(5);
final Optional<JPAODataPage> act = cut.getFirstPage(null, null, info, null, countQuery, null);
assertTrue(act.isEmpty());
}
@Test
void testReturnNullIfEntitySetIsUnknownButMaxPageSizeHeader() throws ODataApplicationException {
final UriInfo info = buildUriInfo();
final JPAExamplePagingProvider cut = createPersonCut(5);
final Optional<JPAODataPage> act = cut.getFirstPage(null, null, info, 3, countQuery, null);
assertTrue(act.isEmpty());
}
@Test
void testReturnGetFirstPageRespectMaxPageSizeHeader() throws ODataApplicationException {
final UriInfo info = buildUriInfo();
final JPAExamplePagingProvider cut = createOrganizationCut(5);
final Optional<JPAODataPage> act = cut.getFirstPage(null, null, info, 3, countQuery, null);
assertEquals(0, act.get().skip());
assertEquals(3, act.get().top());
assertNotNull(toODataString(act.get().skipToken().toString()));
assertEquals(info, act.get().uriInfo());
}
@Test
void testReturnGetNextPageRespectMaxPageSizeHeader() throws ODataApplicationException {
final UriInfo info = buildUriInfo();
final JPAExamplePagingProvider cut = createOrganizationCut(5);
Optional<JPAODataPage> act = cut.getFirstPage(null, null, info, 3, countQuery, null);
act = cut.getNextPage(toODataString(act.get().skipToken().toString()), null, null, null, null);
assertEquals(3, act.get().skip());
assertEquals(3, act.get().top());
assertNotNull(toODataString((act.get().skipToken().toString())));
assertEquals(info, act.get().uriInfo());
}
@Test
void testReturnSkipTokenNullAtLastPage() throws ODataApplicationException {
final UriInfo info = buildUriInfo();
final JPAExamplePagingProvider cut = createOrganizationCut(5);
Optional<JPAODataPage> act = cut.getFirstPage(null, null, info, null, countQuery, null);
act = cut.getNextPage(toODataString(act.get().skipToken().toString()), null, null, null, null);
assertNull(act.get().skipToken());
}
@Test
void testReturnSkipTokenNullOnlyOnePage() throws ODataApplicationException {
final UriInfo info = buildUriInfo("AdministrativeDivisions", "AdministrativeDivision");
final JPAExamplePagingProvider cut = createOrganizationCut(5);
final Optional<JPAODataPage> act = cut.getFirstPage(null, null, info, null, countQuery, null);
assertNull(act.get().skipToken());
}
@Test
void testReturnSkipTokenIfNotLastPage() throws ODataApplicationException {
final UriInfo info = buildUriInfo();
final JPAExamplePagingProvider cut = createOrganizationCut(2);
Optional<JPAODataPage> act = cut.getFirstPage(null, null, info, null, countQuery, null);
act = cut.getNextPage(toODataString(act.get().skipToken().toString()), null, null, null, null);
assertNotNull(toODataString(act.get().skipToken().toString()));
}
@Test
void testReturnThirdPage() throws ODataApplicationException {
final UriInfo info = buildUriInfo();
final JPAExamplePagingProvider cut = createOrganizationCut(2);
Optional<JPAODataPage> act = cut.getFirstPage(null, null, info, null, countQuery, null);
act = cut.getNextPage(toODataString(act.get().skipToken().toString()), null, null, null, null);
act = cut.getNextPage(toODataString(act.get().skipToken().toString()), null, null, null, null);
assertNotNull(toODataString(act.get().skipToken().toString()));
}
@Test
void testRespectTopSkipOfUriFirstPageLowerMaxSize() throws ODataApplicationException {
final UriInfo info = buildUriInfo();
addTopSkipToUri(info);
final JPAExamplePagingProvider cut = createOrganizationCut(10);
final Optional<JPAODataPage> act = cut.getFirstPage(null, null, info, null, countQuery, null);
assertEquals(2, act.get().skip());
assertEquals(7, act.get().top());
}
@Test
void testRespectTopSkipOfUriFirstPage() throws ODataApplicationException {
final UriInfo info = buildUriInfo();
addTopSkipToUri(info);
final JPAExamplePagingProvider cut = createOrganizationCut(5);
final Optional<JPAODataPage> act = cut.getFirstPage(null, null, info, null, countQuery, null);
assertEquals(2, act.get().skip());
assertEquals(5, act.get().top());
}
@Test
void testRespectTopSkipOfUriNextPage() throws ODataApplicationException {
final UriInfo info = buildUriInfo();
addTopSkipToUri(info);
final JPAExamplePagingProvider cut = createOrganizationCut(5);
Optional<JPAODataPage> act = cut.getFirstPage(null, null, info, null, countQuery, null);
act = cut.getNextPage(toODataString(act.get().skipToken().toString()), null, null, null, null);
assertEquals(7, act.get().skip());
assertEquals(2, act.get().top());
}
@Test
void testNoSkipTokenIfRealNoReturnedLowerPage() throws ODataApplicationException {
final UriInfo info = buildUriInfo();
addTopSkipToUri(info, 8, 10);
final JPAExamplePagingProvider cut = createOrganizationCut(5);
final Optional<JPAODataPage> act = cut.getFirstPage(null, null, info, null, countQuery, null);
assertNull(act.get().skipToken());
assertEquals(8, act.get().skip());
}
@Test
void testBufferFull() throws ODataApplicationException {
final UriInfo info = buildUriInfo();
final Map<String, Integer> sizes = new HashMap<>();
sizes.put("Organizations", 2);
final JPAExamplePagingProvider cut = new JPAExamplePagingProvider(sizes, 2);
final Optional<JPAODataPage> first = cut.getFirstPage(null, null, info, null, countQuery, null);
assertNotNull(cut.getNextPage((first.get().skipToken()).toString(), null, null, null, null));
final Optional<JPAODataPage> second = cut.getNextPage(first.get().skipToken().toString(), null, null, null, null);
assertTrue(cut.getNextPage((second.get().skipToken()).toString(), null, null, null, null).isPresent());
final Optional<JPAODataPage> third = cut.getNextPage((second.get().skipToken().toString()), null, null, null, null);
assertTrue(cut.getNextPage(third.get().skipToken().toString(), null, null, null, null).isPresent());
assertTrue(cut.getNextPage(first.get().skipToken().toString(), null, null, null, null).isEmpty());
}
@Test
void testBufferNotFull() throws ODataApplicationException {
final UriInfo info = buildUriInfo();
final Map<String, Integer> sizes = new HashMap<>();
sizes.put("Organizations", 2);
final JPAExamplePagingProvider cut = new JPAExamplePagingProvider(sizes, 10);
final Optional<JPAODataPage> first = cut.getFirstPage(null, null, info, null, countQuery, null);
assertNotNull(cut.getNextPage(first.get().skipToken().toString(), null, null, null, null));
final Optional<JPAODataPage> second = cut.getNextPage(first.get().skipToken().toString(), null, null, null, null);
assertTrue(cut.getNextPage(second.get().skipToken().toString(), null, null, null, null).isPresent());
final Optional<JPAODataPage> third = cut.getNextPage(second.get().skipToken().toString(), null, null, null, null);
assertTrue(cut.getNextPage(third.get().skipToken().toString(), null, null, null, null).isPresent());
assertTrue(cut.getNextPage(first.get().skipToken().toString(), null, null, null, null).isPresent());
}
private UriInfo buildUriInfo() {
return buildUriInfo("Organizations", "Organization");
}
private UriInfo buildUriInfo(final String esName, final String etName) {
final UriInfo uriInfo = mock(UriInfo.class);
final UriResourceEntitySet uriEs = mock(UriResourceEntitySet.class);
final EdmEntitySet es = mock(EdmEntitySet.class);
final EdmType type = mock(EdmType.class);
final OrderByOption order = mock(OrderByOption.class);
final OrderByItem orderItem = mock(OrderByItem.class);
final Member orderExpression = mock(Member.class);
final UriInfoResource orderResourcePath = mock(UriInfoResource.class);
final UriResourcePrimitiveProperty orderResourcePathItem = mock(UriResourcePrimitiveProperty.class);
final EdmProperty orderProperty = mock(EdmProperty.class);
final List<OrderByItem> orderItems = new ArrayList<>();
final List<UriResource> orderResourcePathItems = new ArrayList<>();
orderItems.add(orderItem);
orderResourcePathItems.add(orderResourcePathItem);
when(uriEs.getKind()).thenReturn(UriResourceKind.entitySet);
when(uriEs.getEntitySet()).thenReturn(es);
when(uriEs.getType()).thenReturn(type);
when(es.getName()).thenReturn(esName);
when(type.getNamespace()).thenReturn("com.sap.olingo.jpa");
when(type.getName()).thenReturn(etName);
when(order.getKind()).thenReturn(SystemQueryOptionKind.ORDERBY);
when(orderItem.isDescending()).thenReturn(true);
when(orderItem.getExpression()).thenReturn(orderExpression);
when(orderExpression.getResourcePath()).thenReturn(orderResourcePath);
when(orderResourcePath.getUriResourceParts()).thenReturn(orderResourcePathItems);
when(orderResourcePathItem.getProperty()).thenReturn(orderProperty);
when(orderProperty.getName()).thenReturn("ID");
when(order.getOrders()).thenReturn(orderItems);
final List<UriResource> resourceParts = new ArrayList<>();
resourceParts.add(uriEs);
when(uriInfo.getUriResourceParts()).thenReturn(resourceParts);
when(uriInfo.getOrderByOption()).thenReturn(order);
return uriInfo;
}
private void addTopSkipToUri(final UriInfo info) {
addTopSkipToUri(info, 2, 7);
}
private void addTopSkipToUri(final UriInfo info, final int skip, final int top) {
final SkipOption skipOption = mock(SkipOption.class);
final TopOption topOption = mock(TopOption.class);
when(skipOption.getValue()).thenReturn(skip);
when(topOption.getValue()).thenReturn(top);
when(info.getSkipOption()).thenReturn(skipOption);
when(info.getTopOption()).thenReturn(topOption);
}
private JPAExamplePagingProvider createOrganizationCut(final int size) {
final Map<String, Integer> sizes = new HashMap<>();
sizes.put("Organizations", size);
sizes.put("AdministrativeDivisions", 10);
return new JPAExamplePagingProvider(sizes);
}
private JPAExamplePagingProvider createPersonCut(final int size) {
final Map<String, Integer> sizes = new HashMap<>();
sizes.put("Persons", size);
return new JPAExamplePagingProvider(sizes);
}
private String toODataString(final String skipToken) {
return "'" + skipToken + "'";
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/api/example/JPAExampleCUDRequestHandlerTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/api/example/JPAExampleCUDRequestHandlerTest.java | package com.sap.olingo.jpa.processor.core.api.example;
import static java.util.Collections.emptySet;
import static java.util.Collections.singletonList;
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.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Member;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import jakarta.persistence.EntityManager;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.metamodel.EntityType;
import jakarta.persistence.metamodel.Metamodel;
import jakarta.persistence.metamodel.SingularAttribute;
import org.apache.olingo.commons.api.ex.ODataException;
import org.apache.olingo.commons.api.http.HttpMethod;
import org.apache.olingo.commons.api.http.HttpStatusCode;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.internal.creation.MockSettingsImpl;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAssociationPath;
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.metadata.core.edm.mapper.api.JPAProtectionInfo;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.processor.core.api.JPAClaimsPair;
import com.sap.olingo.jpa.processor.core.api.JPAODataClaimProvider;
import com.sap.olingo.jpa.processor.core.exception.ODataJPAProcessException;
import com.sap.olingo.jpa.processor.core.modify.JPAUpdateResult;
import com.sap.olingo.jpa.processor.core.processor.JPAModifyUtil;
import com.sap.olingo.jpa.processor.core.processor.JPARequestEntity;
import com.sap.olingo.jpa.processor.core.processor.JPARequestLink;
import com.sap.olingo.jpa.processor.core.testmodel.AdministrativeDivision;
import com.sap.olingo.jpa.processor.core.testmodel.AdministrativeDivisionKey;
import com.sap.olingo.jpa.processor.core.testmodel.Collection;
import com.sap.olingo.jpa.processor.core.testmodel.DeepProtectedExample;
import com.sap.olingo.jpa.processor.core.testmodel.InhouseAddress;
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.PersonDeepProtected;
import com.sap.olingo.jpa.processor.core.testmodel.PostalAddressData;
import com.sap.olingo.jpa.processor.core.testobjects.OrganizationWithAudit;
import com.sap.olingo.jpa.processor.core.util.TestBase;
import com.sap.olingo.jpa.processor.core.util.TestHelper;
class JPAExampleCUDRequestHandlerTest extends TestBase {
private JPAExampleCUDRequestHandler cut;
private EntityManager em;
private Metamodel metamodel;
private JPARequestEntity requestEntity;
private Map<String, Object> data;
private Map<String, Object> keys;
private Map<JPAAssociationPath, List<JPARequestLink>> relationLinks;
@BeforeEach
void setup() throws ODataException {
helper = new TestHelper(emf, PUNIT_NAME);
em = mock(EntityManager.class);
requestEntity = mock(JPARequestEntity.class);
metamodel = mock(Metamodel.class);
data = new HashMap<>();
keys = new HashMap<>();
relationLinks = new HashMap<>();
doReturn(new JPAModifyUtil()).when(requestEntity).getModifyUtil();
doReturn(data).when(requestEntity).getData();
doReturn(keys).when(requestEntity).getKeys();
doReturn(metamodel).when(em).getMetamodel();
doReturn(emptySet()).when(metamodel).getEntities();
doReturn(relationLinks).when(requestEntity).getRelationLinks();
cut = new JPAExampleCUDRequestHandler();
}
@Test
void checkCreateEntity() throws ODataJPAProcessException, ODataJPAModelException {
final Object act = createAdminDiv();
assertNotNull(act);
assertEquals("NUTS2", ((AdministrativeDivision) act).getCodeID());
verify(em).persist(act);
}
@Test
void checkCreateEntityWithPrimitiveCollection() throws ODataJPAProcessException, ODataJPAModelException {
doReturn(helper.getJPAEntityType("Organizations")).when(requestEntity).getEntityType();
final List<String> comments = new ArrayList<>(2);
comments.add("This is just test");
comments.add("YAT");
data.put("iD", "504");
data.put("comment", comments);
final Organization act = (Organization) cut.createEntity(requestEntity, em);
assertNotNull(act);
assertEquals("504", act.getID());
assertFalse(act.getComment().isEmpty());
verify(em).persist(act);
}
@Test
void checkCreateEntityWithComplexCollection() throws ODataJPAProcessException, ODataJPAModelException {
doReturn(helper.getJPAEntityType("Persons")).when(requestEntity).getEntityType();
final List<Map<String, Object>> inhouseAddrs = new ArrayList<>(2);
final Map<String, Object> addr1 = new HashMap<>(4);
addr1.put("roomNumber", 32);
addr1.put("floor", 2);
addr1.put("building", "7");
addr1.put("taskID", "MAIN");
inhouseAddrs.add(addr1);
final Map<String, Object> addr2 = new HashMap<>(4);
addr2.put("roomNumber", 245);
addr2.put("floor", -3);
addr2.put("building", "1");
addr2.put("taskID", "DEV");
inhouseAddrs.add(addr2);
data.put("iD", "707");
data.put("inhouseAddress", inhouseAddrs);
final Person act = (Person) cut.createEntity(requestEntity, em);
assertNotNull(act);
assertEquals("707", act.getID());
assertEquals(2, act.getInhouseAddress().size());
assertNotNull(act.getInhouseAddress().get(0).getTaskID());
verify(em).persist(act);
}
@Test
void checkCreateEntityWithComplexCollcetionInitialyNull() throws ODataJPAProcessException,
ODataJPAModelException {
assertNull(new Collection().getNested());
doReturn(helper.getJPAEntityType("Collections")).when(requestEntity).getEntityType();
final Map<String, Object> complex = new HashMap<>();
final List<Map<String, Object>> nested = new ArrayList<>();
final Map<String, Object> nestedItem = new HashMap<>();
final Map<String, Object> inner = new HashMap<>();
final List<String> comment = new ArrayList<>();
inner.put("figure1", 100L);
nestedItem.put("inner", inner);
nestedItem.put("number", 50L);
nested.add(nestedItem);
comment.add("How about this");
complex.put("number", 25L);
complex.put("comment", comment);
data.put("iD", "707");
data.put("complex", complex);
data.put("nested", nested);
final Collection act = (Collection) cut.createEntity(requestEntity, em);
assertNotNull(act);
assertEquals("707", act.getID());
assertNotNull(act.getNested());
assertEquals(1, act.getNested().size());
assertEquals(50L, act.getNested().get(0).getNumber());
assertEquals(100L, act.getNested().get(0).getInner().getFigure1());
assertNotNull(act.getComplex());
assertNotNull(act.getComplex().getComment());
assertEquals(1, act.getComplex().getComment().size());
}
@Test
void checkCreateDeepEntity() throws ODataJPAProcessException, ODataJPAModelException {
// http://localhost:8080/tutorial/v1/AdministrativeDivisions(DivisionCode='DE5',CodeID='NUTS1',CodePublisher='Eurostat')/Children
// key : "divisionCode=DE5, codeID=NUTS1, codePublisher=Eurostat"
// jpaDeepEntities = JPAAssPath ; JPARequestEntity
final JPAEntityType et = helper.getJPAEntityType("AdministrativeDivisions");
final JPAAssociationPath path = et.getAssociationPath("Children");
final Map<JPAAssociationPath, List<JPARequestEntity>> deepEntities = new HashMap<>();
final JPARequestEntity deepEntity = mock(JPARequestEntity.class);
final Map<String, Object> deepData = new HashMap<>();
final AdministrativeDivision parent = new AdministrativeDivision(new AdministrativeDivisionKey("Eurostat", "NUTS1",
"DE5"));
doReturn(et).when(requestEntity).getEntityType();
keys.put("divisionCode", "DE5");
keys.put("codeID", "NUTS1");
keys.put("codePublisher", "Eurostat");
doReturn(deepEntities).when(requestEntity).getRelatedEntities();
deepEntities.put(path, Arrays.asList(deepEntity));
doReturn(et).when(deepEntity).getEntityType();
doReturn(deepData).when(deepEntity).getData();
doReturn(new JPAModifyUtil()).when(deepEntity).getModifyUtil();
deepData.put("DivisionCode", "DE52");
deepData.put("CodeID", "NUTS2");
deepData.put("CodePublisher", "Eurostat");
deepData.put("CountryCode", "DEU");
doReturn(parent).when(em).getReference(eq(et.getTypeClass()), any());
final AdministrativeDivision act = (AdministrativeDivision) cut.createEntity(requestEntity, em);
cut.validateChanges(em);
assertNotNull(act.getChildren());
assertEquals(1, act.getChildren().size());
}
@Test
void checkCreateLinkedThrowsExceptionTargetNotFound() throws ODataJPAProcessException, ODataJPAModelException {
// http://localhost:8080/tutorial/v1/AdministrativeDivisions(DivisionCode='DE5',CodeID='NUTS1',CodePublisher='Eurostat')/Children
// key : "divisionCode=DE5, codeID=NUTS1, codePublisher=Eurostat"
// jpaDeepEntities = JPAAssPath ; JPARequestEntity
final JPAEntityType et = helper.getJPAEntityType("AdministrativeDivisions");
final JPAAssociationPath path = et.getAssociationPath("Parent");
final List<JPARequestLink> links = new ArrayList<>();
final JPARequestLink link = mock(JPARequestLink.class);
final AdministrativeDivisionKey parentKey = new AdministrativeDivisionKey("Eurostat", "NUTS1", "DE5");
doReturn(et).when(requestEntity).getEntityType();
data.put("divisionCode", "DE52");
data.put("codeID", "NUTS2");
data.put("codePublisher", "Eurostat");
doReturn(Collections.emptyMap()).when(requestEntity).getRelatedEntities();
final Map<String, Object> relatedKey = new HashMap<>();
relatedKey.put("divisionCode", "DE5");
relatedKey.put("codeID", "NUTS1");
relatedKey.put("codePublisher", "Eurostat");
doReturn(null).when(em).find(et.getTypeClass(), parentKey);
relationLinks.put(path, links);
doReturn(et).when(link).getEntityType();
doReturn(relatedKey).when(link).getRelatedKeys();
links.add(link);
cut.createEntity(requestEntity, em);
final ODataJPAProcessException act = assertThrows(ODataJPAProcessException.class, () -> cut.validateChanges(em));
assertEquals(HttpStatusCode.BAD_REQUEST.getStatusCode(), act.getStatusCode());
}
@Test
void checkCreateLinkedEntityOneToMany() throws ODataJPAProcessException, ODataJPAModelException {
// http://localhost:8080/tutorial/v1/AdministrativeDivisions(DivisionCode='DE5',CodeID='NUTS1',CodePublisher='Eurostat')/Children
// key : "divisionCode=DE5, codeID=NUTS1, codePublisher=Eurostat"
// jpaDeepEntities = JPAAssPath ; JPARequestEntity
final JPAEntityType et = helper.getJPAEntityType("AdministrativeDivisions");
final JPAAssociationPath path = et.getAssociationPath("Parent");
final List<JPARequestLink> links = new ArrayList<>();
final JPARequestLink link = mock(JPARequestLink.class);
final AdministrativeDivisionKey parentKey = new AdministrativeDivisionKey("Eurostat", "NUTS1", "DE5");
final AdministrativeDivision parent = new AdministrativeDivision(parentKey);
doReturn(et).when(requestEntity).getEntityType();
data.put("divisionCode", "DE52");
data.put("codeID", "NUTS2");
data.put("codePublisher", "Eurostat");
doReturn(Collections.emptyMap()).when(requestEntity).getRelatedEntities();
final Map<String, Object> relatedKey = new HashMap<>();
relatedKey.put("divisionCode", "DE5");
relatedKey.put("codeID", "NUTS1");
relatedKey.put("codePublisher", "Eurostat");
doReturn(parent).when(em).find(et.getTypeClass(), parentKey);
relationLinks.put(path, links);
doReturn(et).when(link).getEntityType();
doReturn(relatedKey).when(link).getRelatedKeys();
links.add(link);
final AdministrativeDivision act = (AdministrativeDivision) cut.createEntity(requestEntity, em);
cut.validateChanges(em);
assertNotNull(act.getParent());
assertEquals(parentKey.getCodeID(), act.getParentCodeID());
assertEquals(parentKey.getDivisionCode(), act.getParentDivisionCode());
assertEquals(parentKey.getCodePublisher(), act.getCodePublisher());
}
@Test
void checkCreateLinkedEntityManyToOne() throws ODataJPAProcessException, ODataJPAModelException {
// http://localhost:8080/tutorial/v1/AdministrativeDivisions(DivisionCode='DE5',CodeID='NUTS1',CodePublisher='Eurostat')/Children
// key : "divisionCode=DE5, codeID=NUTS1, codePublisher=Eurostat"
// jpaDeepEntities = JPAAssPath ; JPARequestEntity
final JPAEntityType et = helper.getJPAEntityType("AdministrativeDivisions");
final JPAAssociationPath path = et.getAssociationPath("Children");
final List<JPARequestLink> links = new ArrayList<>();
final JPARequestLink link = mock(JPARequestLink.class);
final AdministrativeDivisionKey key = new AdministrativeDivisionKey("Eurostat", "NUTS1", "DE5");
final AdministrativeDivision target = new AdministrativeDivision(key);
final AdministrativeDivisionKey childKey = new AdministrativeDivisionKey("Eurostat", "NUTS2", "DE52");
final AdministrativeDivision child = new AdministrativeDivision(childKey);
doReturn(et).when(requestEntity).getEntityType();
data.put("divisionCode", "DE5");
data.put("codeID", "NUTS1");
data.put("codePublisher", "Eurostat");
doReturn(Collections.emptyMap()).when(requestEntity).getRelatedEntities();
doReturn(null, target).when(em).find(et.getTypeClass(), key);
final Map<String, Object> relatedKey = new HashMap<>();
relatedKey.put("divisionCode", "DE52");
relatedKey.put("codeID", "NUTS2");
relatedKey.put("codePublisher", "Eurostat");
doReturn(child).when(em).find(et.getTypeClass(), childKey);
relationLinks.put(path, links);
doReturn(et).when(link).getEntityType();
doReturn(relatedKey).when(link).getRelatedKeys();
links.add(link);
final AdministrativeDivision act = (AdministrativeDivision) cut.createEntity(requestEntity, em);
cut.validateChanges(em);
assertEquals(act.getCodeID(), child.getParentCodeID());
assertEquals(act.getDivisionCode(), child.getParentDivisionCode());
assertEquals(act.getCodePublisher(), child.getCodePublisher());
assertNotNull(act.getChildren());
// assertEquals(1, act.getChildren().size()); //NOSONAR
}
@Test
void checkCreateEntityAutoId() throws ODataJPAProcessException, ODataJPAModelException {
final EntityType<?> jpaEt = mock(EntityType.class);
final Set<EntityType<?>> jpaEts = new HashSet<>();
final SingularAttribute<?, ?> at = mock(SingularAttribute.class);
final Member atAsMember = mock(Member.class, new MockSettingsImpl<>().extraInterfaces(AnnotatedElement.class));
final GeneratedValue generatedValue = mock(GeneratedValue.class);
jpaEts.add(jpaEt);
doReturn(true).when(jpaEt).hasSingleIdAttribute();
doReturn(jpaEts).when(metamodel).getEntities();
doReturn("AdministrativeDivision").when(jpaEt).getName();
doReturn(at).when(jpaEt).getId(any());
doReturn(atAsMember).when(at).getJavaMember();
doReturn(generatedValue).when((AnnotatedElement) atAsMember).getAnnotation(GeneratedValue.class);
final Object act = createAdminDiv();
assertNotNull(act);
assertEquals("NUTS2", ((AdministrativeDivision) act).getCodeID());
verify(em, times(2)).persist(act);
verify(em, never()).find(any(), any());
}
@Test
void checkCreateEntityWithoutAutoId() throws ODataJPAProcessException, ODataJPAModelException {
final EntityType<?> jpaEt = mock(EntityType.class);
final Set<EntityType<?>> jpaEts = new HashSet<>();
final SingularAttribute<?, ?> at = mock(SingularAttribute.class);
final Member atAsMember = mock(Member.class, new MockSettingsImpl<>().extraInterfaces(AnnotatedElement.class));
jpaEts.add(jpaEt);
doReturn(jpaEts).when(metamodel).getEntities();
doReturn("AdministrativeDivision").when(jpaEt).getName();
doReturn(at).when(jpaEt).getId(any());
doReturn(atAsMember).when(at).getJavaMember();
doReturn(null).when((AnnotatedElement) atAsMember).getAnnotation(GeneratedValue.class);
final Object act = createAdminDiv();
assertNotNull(act);
assertEquals("NUTS2", ((AdministrativeDivision) act).getCodeID());
verify(em).persist(act);
verify(em).find(any(), any());
}
@Test
void checkCreateEntityAutoIdIdNotFound() throws ODataJPAProcessException, ODataJPAModelException {
final EntityType<?> jpaEt = mock(EntityType.class);
final Set<EntityType<?>> jpaEts = new HashSet<>();
jpaEts.add(jpaEt);
doReturn(jpaEts).when(metamodel).getEntities();
doReturn("AdministrativeDivision").when(jpaEt).getName();
doReturn(null).when(jpaEt).getId(any());
final Object act = createAdminDiv();
assertNotNull(act);
assertEquals("NUTS2", ((AdministrativeDivision) act).getCodeID());
verify(em).persist(act);
verify(em).find(any(), any());
}
@Test
void checkCreateEntityAutoIdNoJpaEntityType() throws ODataJPAProcessException, ODataJPAModelException {
final Set<EntityType<?>> jpaEts = new HashSet<>();
doReturn(jpaEts).when(metamodel).getEntities();
final Object act = createAdminDiv();
assertNotNull(act);
assertEquals("NUTS2", ((AdministrativeDivision) act).getCodeID());
verify(em).persist(act);
verify(em).find(any(), any());
}
@Test
void checkUpdateEntityNotFoundUpsertsEntity() throws ODataJPAModelException, ODataJPAProcessException {
final String id = "100";
final Organization beforeImage = new Organization(id);
final JPAEntityType et = helper.getJPAEntityType("Organizations");
beforeImage.setName1("Example Ltd");
doReturn(et).when(requestEntity).getEntityType();
doReturn(null).when(em).find(eq(et.getTypeClass()), any());
data.put("name1", "Example SE");
keys.put("iD", id);
final var act = cut.updateEntity(requestEntity, em, HttpMethod.PATCH);
assertNotNull(act);
assertTrue(act.wasCreate());
final Organization org = (Organization) act.modifiedEntity();
assertEquals("100", org.getID());
}
@Test
void checkDeleteSimplePrimitiveProperty() throws ODataJPAProcessException, ODataJPAModelException {
final String id = "1";
final Organization beforeImage = new Organization(id);
beforeImage.setName1("Example Ltd");
doReturn(helper.getJPAEntityType("Organizations")).when(requestEntity).getEntityType();
doReturn(beforeImage).when(em).find(Organization.class, id);
data.put("name1", null);
keys.put("iD", id);
final JPAUpdateResult act = cut.updateEntity(requestEntity, em, HttpMethod.DELETE);
assertFalse(act.wasCreate());
assertNull(((Organization) act.modifiedEntity()).getName1());
}
@Test
void checkDeletePrimitiveCollectionProperty() throws ODataJPAProcessException, ODataJPAModelException {
final String id = "1";
final Organization beforeImage = new Organization(id);
beforeImage.getComment().add("YAC");
doReturn(helper.getJPAEntityType("Organizations")).when(requestEntity).getEntityType();
doReturn(beforeImage).when(em).find(Organization.class, id);
data.put("comment", null);
keys.put("iD", id);
final JPAUpdateResult act = cut.updateEntity(requestEntity, em, HttpMethod.DELETE);
assertFalse(act.wasCreate());
assertNull(((Organization) act.modifiedEntity()).getComment());
}
@Test
void checkDeleteSimpleComplexProperty() throws ODataJPAProcessException, ODataJPAModelException {
final String id = "1";
final Organization beforeImage = new Organization(id);
beforeImage.setAddress(new PostalAddressData());
doReturn(helper.getJPAEntityType("Organizations")).when(requestEntity).getEntityType();
doReturn(beforeImage).when(em).find(Organization.class, id);
data.put("address", null);
keys.put("iD", id);
final JPAUpdateResult act = cut.updateEntity(requestEntity, em, HttpMethod.DELETE);
assertFalse(act.wasCreate());
assertNull(((Organization) act.modifiedEntity()).getAddress());
}
@Test
void checkDeleteComplexCollectionProperty() throws ODataJPAProcessException, ODataJPAModelException {
final String id = "2";
final Person beforeImage = new Person();
beforeImage.setID(id);
beforeImage.getInhouseAddress().add(new InhouseAddress("DEV", "D-2"));
doReturn(helper.getJPAEntityType("Persons")).when(requestEntity).getEntityType();
doReturn(beforeImage).when(em).find(Person.class, id);
data.put("inhouseAddress", null);
keys.put("iD", id);
final JPAUpdateResult act = cut.updateEntity(requestEntity, em, HttpMethod.DELETE);
assertFalse(act.wasCreate());
assertNull(((Person) act.modifiedEntity()).getInhouseAddress());
}
@Test
void checkDeleteSimplePrimitivePropertyDeep() throws ODataJPAProcessException, ODataJPAModelException {
final String id = "1";
final Organization beforeImage = new Organization(id);
final PostalAddressData addr = new PostalAddressData();
final Map<String, Object> addrData = new HashMap<>();
addr.setPOBox("23145-1235");
addr.setCityName("Hamburg");
beforeImage.setAddress(addr);
beforeImage.setName1("Example Ltd");
doReturn(helper.getJPAEntityType("Organizations")).when(requestEntity).getEntityType();
doReturn(beforeImage).when(em).find(Organization.class, id);
data.put("address", addrData);
addrData.put("pOBox", null);
keys.put("iD", id);
final JPAUpdateResult act = cut.updateEntity(requestEntity, em, HttpMethod.DELETE);
assertFalse(act.wasCreate());
assertNull(((Organization) act.modifiedEntity()).getAddress().getPOBox());
assertEquals("Hamburg", ((Organization) act.modifiedEntity()).getAddress().getCityName());
}
@Test
void checkDeleteEntity() throws ODataJPAProcessException, ODataJPAModelException {
final String id = "1";
final Organization beforeImage = new Organization(id);
doReturn(beforeImage).when(em).find(Organization.class, id);
doReturn(helper.getJPAEntityType("Organizations")).when(requestEntity).getEntityType();
keys.put("iD", id);
cut.deleteEntity(requestEntity, em);
verify(em).remove(beforeImage);
}
@Test
void checkDeleteNoErrorIfEntityDoesNotExists() throws ODataJPAProcessException, ODataJPAModelException {
final String id = "1";
final Organization beforeImage = new Organization(id);
doReturn(null).when(em).find(Organization.class, id);
doReturn(helper.getJPAEntityType("Organizations")).when(requestEntity).getEntityType();
keys.put("iD", id);
cut.deleteEntity(requestEntity, em);
verify(em, times(0)).remove(beforeImage);
}
@Test
void checkPatchOneSimplePrimitiveValue() throws ODataJPAModelException, ODataJPAProcessException {
final JPAUpdateResult act = updateSimplePrimitiveValue();
assertFalse(act.wasCreate());
assertEquals("Example SE", ((Organization) act.modifiedEntity()).getName1());
}
@Test
void checkPatchOneSimpleComplexValue() throws ODataJPAModelException, ODataJPAProcessException {
final String id = "1";
final Organization beforeImage = new Organization(id);
final PostalAddressData beforeAddr = new PostalAddressData();
final Map<String, Object> changedAddr = new HashMap<>();
beforeImage.setAddress(beforeAddr);
beforeAddr.setHouseNumber("45A");
beforeAddr.setCityName("Test");
beforeAddr.setPostalCode("12345");
doReturn(helper.getJPAEntityType("Organizations")).when(requestEntity).getEntityType();
doReturn(beforeImage).when(em).find(Organization.class, id);
changedAddr.put("houseNumber", "45");
changedAddr.put("streetName", "Example Street");
data.put("address", changedAddr);
keys.put("iD", id);
final JPAUpdateResult act = cut.updateEntity(requestEntity, em, HttpMethod.DELETE);
assertFalse(act.wasCreate());
assertNotNull(((Organization) act.modifiedEntity()).getAddress());
final PostalAddressData afterImage = ((Organization) act.modifiedEntity()).getAddress();
assertEquals("45", afterImage.getHouseNumber());
assertEquals("Test", afterImage.getCityName());
assertEquals("12345", afterImage.getPostalCode());
assertEquals("Example Street", afterImage.getStreetName());
}
@Test
void checkPatchEmptyComplexCollectionProperty() throws ODataJPAProcessException, ODataJPAModelException {
final String id = "2";
final Person beforeImage = new Person();
final List<Map<String, Object>> newInhouseAddresses = new ArrayList<>(2);
beforeImage.setID(id);
beforeImage.getInhouseAddress().add(new InhouseAddress("DEV", "D-2"));
doReturn(helper.getJPAEntityType("Persons")).when(requestEntity).getEntityType();
doReturn(beforeImage).when(em).find(Person.class, id);
data.put("inhouseAddress", newInhouseAddresses);
keys.put("iD", id);
final JPAUpdateResult act = cut.updateEntity(requestEntity, em, HttpMethod.DELETE);
assertFalse(act.wasCreate());
assertNotNull(((Person) act.modifiedEntity()).getInhouseAddress());
assertTrue(((Person) act.modifiedEntity()).getInhouseAddress().isEmpty());
}
@Test
void checkPatchComplexCollectionProperty() throws ODataJPAProcessException, ODataJPAModelException {
final String id = "2";
final Person beforeImage = new Person();
final List<Map<String, Object>> newInhouseAddresses = new ArrayList<>(2);
beforeImage.setID(id);
beforeImage.getInhouseAddress().add(new InhouseAddress("DEV", "D-2"));
doReturn(helper.getJPAEntityType("Persons")).when(requestEntity).getEntityType();
doReturn(beforeImage).when(em).find(Person.class, id);
final Map<String, Object> addr1 = new HashMap<>();
addr1.put("taskID", "MAIN");
addr1.put("floor", "U1");
newInhouseAddresses.add(addr1);
final Map<String, Object> addr2 = new HashMap<>();
addr2.put("taskID", "EDU");
addr2.put("floor", "E");
newInhouseAddresses.add(addr2);
data.put("inhouseAddress", newInhouseAddresses);
keys.put("iD", id);
final JPAUpdateResult act = cut.updateEntity(requestEntity, em, HttpMethod.PATCH);
assertFalse(act.wasCreate());
assertNotNull(((Person) act.modifiedEntity()).getInhouseAddress());
final List<InhouseAddress> actInhouseAddrs = ((Person) act.modifiedEntity()).getInhouseAddress();
assertEquals(2, actInhouseAddrs.size());
assertTrue(actInhouseAddrs.get(0).getBuilding() == null || actInhouseAddrs.get(0).getBuilding().isEmpty());
assertTrue(actInhouseAddrs.get(1).getBuilding() == null || actInhouseAddrs.get(1).getBuilding().isEmpty());
}
@Test
void checkPatchOnePrimitiveCollectionValue() throws ODataJPAModelException, ODataJPAProcessException {
final String id = "1";
final Organization beforeImage = new Organization(id);
final List<String> newComments = Arrays.asList("This is a test", "YAT");
beforeImage.getComment().add("YAC");
doReturn(helper.getJPAEntityType("Organizations")).when(requestEntity).getEntityType();
doReturn(beforeImage).when(em).find(Organization.class, id);
data.put("comment", newComments);
keys.put("iD", id);
final JPAUpdateResult act = cut.updateEntity(requestEntity, em, HttpMethod.DELETE);
assertFalse(act.wasCreate());
assertNotNull(((Organization) act.modifiedEntity()).getComment());
final List<String> actComments = ((Organization) act.modifiedEntity()).getComment();
assertEquals(2, actComments.size());
assertTrue(actComments.contains("YAT"));
assertTrue(actComments.contains("This is a test"));
}
@Test
void checkPatchCreateBindingLinkBetweenTwoEntities() throws ODataJPAModelException,
ODataJPAProcessException {
/*
* URL: ../AdministrativeDivisions(DivisionCode='DE51',CodeID='NUTS2',CodePublisher='Eurostat')
* Body:
* "Parent@odata.bind": ["AdministrativeDivisions(DivisionCode='DE5',CodeID='NUTS1',CodePublisher='Eurostat')" ]
*/
final JPAEntityType et = helper.getJPAEntityType("AdministrativeDivisions");
final JPAAssociationPath path = et.getAssociationPath("Children");
final JPARequestLink link = mock(JPARequestLink.class);
final Map<String, Object> childKeys = new HashMap<>();
final AdministrativeDivision parent = new AdministrativeDivision(new AdministrativeDivisionKey("Eurostat", "NUTS1",
"DE5"));
final AdministrativeDivision child = new AdministrativeDivision(new AdministrativeDivisionKey("Eurostat", "NUTS2",
"DE51"));
doReturn(et).when(requestEntity).getEntityType();
keys.put("divisionCode", "DE5");
keys.put("codeID", "NUTS1");
keys.put("codePublisher", "Eurostat");
relationLinks.put(path, Arrays.asList(link));
doReturn(et).when(link).getEntityType();
doReturn(childKeys).when(link).getRelatedKeys();
childKeys.put("divisionCode", "DE51");
childKeys.put("codeID", "NUTS2");
childKeys.put("codePublisher", "Eurostat");
doReturn(childKeys).when(link).getValues();
doReturn(parent).when(em).find(et.getTypeClass(), parent.getKey());
doReturn(child).when(em).find(et.getTypeClass(), child.getKey());
final JPAUpdateResult act = cut.updateEntity(requestEntity, em, HttpMethod.DELETE);
assertNotNull(act);
assertEquals(parent, act.modifiedEntity());
assertEquals(1, parent.getChildren().size());
assertEquals("DE51", parent.getChildren().get(0).getDivisionCode());
}
@Test
void checkAuditFieldsSetOnCreate() throws ODataJPAModelException, ODataJPAProcessException {
final OrganizationWithAudit act = createOrganization();
cut.validateChanges(em);
assertNotNull(act.getCreatedBy());
assertNotNull(act.getCreatedAt());
assertEquals(act.getCreatedBy(), act.getUpdatedBy());
assertEquals(act.getCreatedAt(), act.getUpdatedAt());
}
@Test
void checkAuditFieldsSetOnUpdate() throws ODataJPAModelException, ODataJPAProcessException {
final OrganizationWithAudit act = (OrganizationWithAudit) updateOrganization().modifiedEntity();
cut.validateChanges(em);
assertNotNull(act.getUpdatedBy());
assertNotNull(act.getUpdatedAt());
assertNotEquals(act.getCreatedBy(), act.getUpdatedBy());
assertNotEquals(act.getCreatedAt(), act.getUpdatedAt());
}
@Test
void checkAuthorizationsCreateRejectsNotClaimsNotAllowed() {
final JPAExampleModifyException act = assertThrows(JPAExampleModifyException.class,
() -> createPersonProtected(null));
assertEquals(HttpStatusCode.FORBIDDEN.getStatusCode(), act.getStatusCode());
}
@Test
void checkAuthorizationsCreateRejectsAttributeNotPresent() {
final JPAODataClaimProvider claims = mock(JPAODataClaimProvider.class);
final JPAExampleModifyException act = assertThrows(JPAExampleModifyException.class, () -> createPersonProtected(
claims));
assertEquals(HttpStatusCode.FORBIDDEN.getStatusCode(), act.getStatusCode());
}
@Test
void checkAuthorizationsCreateRejectsAttributeNotMatch() {
final JPAClaimsPair<String> claim = new JPAClaimsPair<>("DOT01");
final JPAODataClaimProvider claims = mock(JPAODataClaimProvider.class);
when(claims.get("BuildingNumber")).thenReturn(singletonList(claim));
final JPAExampleModifyException act = assertThrows(JPAExampleModifyException.class,
() -> createPersonProtected(claims));
assertEquals(HttpStatusCode.FORBIDDEN.getStatusCode(), act.getStatusCode());
}
@Test
void checkAuthorizationsCreateRejectedOnlyOneProvided() {
final JPAClaimsPair<String> claim = new JPAClaimsPair<>("MID*");
| 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/src/test/java/com/sap/olingo/jpa/processor/core/modify/JPAEntityNavigationLinkResultTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/modify/JPAEntityNavigationLinkResultTest.java | package com.sap.olingo.jpa.processor.core.modify;
import static com.sap.olingo.jpa.processor.core.converter.JPAExpandResult.ROOT_RESULT_KEY;
import static java.util.Optional.empty;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.mock;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import jakarta.persistence.Tuple;
import org.apache.olingo.commons.api.ex.ODataException;
import org.apache.olingo.server.api.OData;
import org.apache.olingo.server.api.ODataApplicationException;
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.core.api.JPAODataRequestContext;
import com.sap.olingo.jpa.processor.core.api.JPAODataRequestContextAccess;
import com.sap.olingo.jpa.processor.core.api.JPAODataSessionContextAccess;
import com.sap.olingo.jpa.processor.core.converter.JPAExpandResult;
import com.sap.olingo.jpa.processor.core.converter.JPATupleChildConverter;
import com.sap.olingo.jpa.processor.core.processor.JPAODataInternalRequestContext;
import com.sap.olingo.jpa.processor.core.query.JPAExpandQueryResult;
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.util.ServiceMetadataDouble;
import com.sap.olingo.jpa.processor.core.util.TestBase;
import com.sap.olingo.jpa.processor.core.util.TestHelper;
import com.sap.olingo.jpa.processor.core.util.TupleDouble;
import com.sap.olingo.jpa.processor.core.util.UriHelperDouble;
class JPAEntityNavigationLinkResultTest extends TestBase {
private JPATupleChildConverter childConverter;
private List<Tuple> jpaCreateResult;
private UriHelperDouble uriHelper;
private Map<String, String> keyPredicates;
private final Map<String, List<Tuple>> createResult = new HashMap<>(1);
private JPAODataRequestContextAccess requestContext;
private JPAODataRequestContext context;
private JPAODataSessionContextAccess sessionContext;
private OData odata;
@BeforeEach
void setup() throws ODataException {
helper = new TestHelper(emf, PUNIT_NAME);
createHeaders();
jpaCreateResult = new ArrayList<>();
createResult.put(ROOT_RESULT_KEY, jpaCreateResult);
uriHelper = new UriHelperDouble();
keyPredicates = new HashMap<>();
uriHelper.setKeyPredicates(keyPredicates, "ID");
context = mock(JPAODataRequestContext.class);
sessionContext = mock(JPAODataSessionContextAccess.class);
odata = mock(OData.class);
requestContext = new JPAODataInternalRequestContext(context, sessionContext, odata);
childConverter = new JPATupleChildConverter(helper.sd, uriHelper, new ServiceMetadataDouble(nameBuilder,
"Organization"),
requestContext);
}
@Test
void checkConvertsOneResultOneKeyWithLink() throws ODataApplicationException, ODataJPAModelException {
final var et = helper.getJPAEntityType(Organization.class);
final var assoziation = et.getAssociationPath("Roles");
final Map<String, Object> result = new HashMap<>();
keyPredicates.put("1", "'1'");
result.put("ID", "1");
jpaCreateResult.add(new TupleDouble(result));
final var jpaResult = new JPAExpandQueryResult(createResult, null, et, List.of(), empty());
final var linkResult = new JPAEntityNavigationLinkResult(et, List.of(new BusinessPartnerRole("1", "2")), headers,
childConverter, assoziation.getForeignKeyColumns());
final Map<JPAAssociationPath, JPAExpandResult> childResults = Map.of(et.getAssociationPath("Roles"), linkResult);
jpaResult.putChildren(childResults);
final var act = childConverter.getResult(jpaResult, List.of()).get(ROOT_RESULT_KEY);
assertEquals(1, act.getEntities().size());
assertEquals("Organizations" + "('1')", act.getEntities().get(0).getId().getPath());
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/modify/JPAConversionHelperEntityTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/modify/JPAConversionHelperEntityTest.java | package com.sap.olingo.jpa.processor.core.modify;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.apache.olingo.server.api.serializer.SerializerException;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.processor.core.exception.ODataJPAProcessorException;
import com.sap.olingo.jpa.processor.core.testmodel.AdministrativeDivisionDescription;
import com.sap.olingo.jpa.processor.core.testmodel.AdministrativeDivisionDescriptionKey;
import com.sap.olingo.jpa.processor.core.testmodel.BusinessPartnerRole;
import com.sap.olingo.jpa.processor.core.testmodel.Organization;
class JPAConversionHelperEntityTest extends JPAConversionHelperTest {
@BeforeEach
void setUp() {
cut = new JPAConversionHelper();
}
@Override
@Test
public void testConvertSimpleKeyToLocation() throws ODataJPAProcessorException, SerializerException,
ODataJPAModelException {
final Organization newPOJO = new Organization();
newPOJO.setID("35");
prepareConvertSimpleKeyToLocation();
final String act = cut.convertKeyToLocal(odata, request, edmEntitySet, et, newPOJO);
assertEquals("localhost.test/Organisation('35')", act);
}
@Override
@Test
public void testConvertCompoundKeyToLocation() throws ODataJPAProcessorException, SerializerException,
ODataJPAModelException {
final BusinessPartnerRole newPOJO = new BusinessPartnerRole();
newPOJO.setBusinessPartnerID("35");
newPOJO.setRoleCategory("A");
prepareConvertCompoundKeyToLocation();
final String act = cut.convertKeyToLocal(odata, request, edmEntitySet, et, newPOJO);
assertEquals("localhost.test/BusinessPartnerRoles(BusinessPartnerID='35',RoleCategory='A')", act);
}
@Override
@Test
public void testConvertEmbeddedIdToLocation() throws ODataJPAProcessorException, SerializerException,
ODataJPAModelException {
final AdministrativeDivisionDescription newPOJO = new AdministrativeDivisionDescription();
final AdministrativeDivisionDescriptionKey primaryKey = new AdministrativeDivisionDescriptionKey();
primaryKey.setCodeID("NUTS1");
primaryKey.setCodePublisher("Eurostat");
primaryKey.setDivisionCode("BE1");
primaryKey.setLanguage("fr");
newPOJO.setKey(primaryKey);
prepareConvertEmbeddedIdToLocation();
final String act = cut.convertKeyToLocal(odata, request, edmEntitySet, et, newPOJO);
assertEquals(
"localhost.test/AdministrativeDivisionDescriptions(DivisionCode='BE1',CodeID='NUTS1',CodePublisher='Eurostat',Language='fr')",
act);
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/modify/JPAMapResultTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/modify/JPAMapResultTest.java | package com.sap.olingo.jpa.processor.core.modify;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.olingo.server.api.OData;
import org.apache.olingo.server.api.ODataApplicationException;
import org.junit.jupiter.api.BeforeEach;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.processor.core.converter.JPATupleChildConverter;
import com.sap.olingo.jpa.processor.core.processor.JPARequestEntity;
import com.sap.olingo.jpa.processor.core.util.ServiceMetadataDouble;
import com.sap.olingo.jpa.processor.core.util.TestHelper;
class JPAMapResultTest extends JPACreateResultTest {
List<JPARequestEntity> children;
@BeforeEach
void setUp() throws Exception {
headers = new HashMap<>();
jpaEntity = new HashMap<String, Object>();
helper = new TestHelper(emf, PUNIT_NAME);
et = helper.getJPAEntityType("Organizations");
children = new ArrayList<>();
converter = new JPATupleChildConverter(helper.sd, OData.newInstance()
.createUriHelper(), new ServiceMetadataDouble(nameBuilder, "Organizations"), requestContext);
}
@SuppressWarnings("unchecked")
@Override
protected void createCutProvidesEmptyMap() throws ODataJPAModelException, ODataApplicationException {
// Make Map equal to empty Organization instance
((Map<String, Object>) jpaEntity).put("type", "2");
((Map<String, Object>) jpaEntity).put("comment", new ArrayList<>(1));
cut = new JPAMapResult(et, (Map<String, Object>) jpaEntity, headers, converter);
}
@SuppressWarnings("unchecked")
@Override
protected void createCutGetResultSimpleEntity() throws ODataJPAModelException, ODataApplicationException {
((Map<String, Object>) jpaEntity).put("businessPartnerID", "34");
((Map<String, Object>) jpaEntity).put("roleCategory", "A");
cut = new JPAMapResult(et, (Map<String, Object>) jpaEntity, headers, converter);
}
@SuppressWarnings("unchecked")
@Override
protected void createCutGetResultEntityWithTransient() throws ODataJPAModelException, ODataApplicationException {
((Map<String, Object>) jpaEntity).put("iD", "1222");
((Map<String, Object>) jpaEntity).put("firstName", "Hans");
((Map<String, Object>) jpaEntity).put("lastName", "Hubert");
((Map<String, Object>) jpaEntity).put("fullName", "Hubert, Hans");
cut = new JPAMapResult(et, (Map<String, Object>) jpaEntity, headers, converter);
}
@SuppressWarnings("unchecked")
@Override
protected void createCutGetResultWithOneLevelEmbedded() throws ODataJPAModelException, ODataApplicationException {
final Map<String, Object> key = new HashMap<>();
key.put("codeID", "A");
key.put("language", "en");
((Map<String, Object>) jpaEntity).put("name", "Hugo");
((Map<String, Object>) jpaEntity).put("key", key);
cut = new JPAMapResult(et, (Map<String, Object>) jpaEntity, headers, converter);
}
@SuppressWarnings("unchecked")
@Override
protected void createCutGetResultWithTwoLevelEmbedded() throws ODataJPAModelException,
ODataApplicationException {
final long time = new Date().getTime();
final Map<String, Object> created = new HashMap<>();
created.put("by", "99");
created.put("at", new Timestamp(time));
final Map<String, Object> admin = new HashMap<>();
admin.put("created", created);
admin.put("updated", created);
((Map<String, Object>) jpaEntity).put("iD", "01");
((Map<String, Object>) jpaEntity).put("customString1", "Dummy");
((Map<String, Object>) jpaEntity).put("administrativeInformation", admin);
cut = new JPAMapResult(et, (Map<String, Object>) jpaEntity, headers, converter);
}
@SuppressWarnings("unchecked")
@Override
protected void createCutGetResultWithDescriptionProperty() throws ODataJPAModelException, ODataApplicationException {
et = helper.getJPAEntityType("Organizations");
jpaEntity = new HashMap<>(3);
final Map<String, Object> description = new HashMap<>(2);
final Map<String, Object> descriptionKey = new HashMap<>(4);
descriptionKey.put("codePublisher", "ISO");
descriptionKey.put("codeID", "3166");
descriptionKey.put("divisionCode", "DEU");
descriptionKey.put("language", "en");
description.put("key", descriptionKey);
description.put("name", "MyDivision");
((Map<String, Object>) jpaEntity).put("iD", "Willi");
((Map<String, Object>) jpaEntity).put("eTag", Long.valueOf("7"));
((Map<String, Object>) jpaEntity).put("codePublisher", "Eurostat");
((Map<String, Object>) jpaEntity).put("locationName", Arrays.asList(description));
cut = new JPAMapResult(et, (Map<String, Object>) jpaEntity, headers, converter);
}
@SuppressWarnings("unchecked")
@Override
protected void createCutGetResultWithWithOneLinked() throws ODataJPAModelException, ODataApplicationException {
prepareAdminWithChildren();
cut = new JPAMapResult(et, (Map<String, Object>) jpaEntity, headers, converter);
}
@SuppressWarnings("unchecked")
@Override
protected void createCutGetResultWithWithTwoLinked() throws ODataJPAModelException, ODataApplicationException {
prepareAdminWithChildren();
final Map<String, Object> childProperties = new HashMap<>();
final JPARequestEntity child = mock(JPARequestEntity.class);
when(child.getEntityType()).thenReturn(et);
when(child.getData()).thenReturn(childProperties);
childProperties.put("codeID", "NUTS2");
childProperties.put("divisionCode", "BE22");
childProperties.put("codePublisher", "Eurostat");
childProperties.put("parentCodeID", "NUTS1");
childProperties.put("parentDivisionCode", "BE2");
children.add(child);
cut = new JPAMapResult(et, (Map<String, Object>) jpaEntity, headers, converter);
}
@SuppressWarnings("unchecked")
private void prepareAdminWithChildren() throws ODataJPAModelException, ODataApplicationException {
et = helper.getJPAEntityType("AdministrativeDivisions");
((Map<String, Object>) jpaEntity).put("codeID", "NUTS1");
((Map<String, Object>) jpaEntity).put("divisionCode", "BE2");
((Map<String, Object>) jpaEntity).put("codePublisher", "Eurostat");
final Map<String, Object> childProperties = new HashMap<>();
final JPARequestEntity child = mock(JPARequestEntity.class);
when(child.getEntityType()).thenReturn(et);
when(child.getData()).thenReturn(childProperties);
childProperties.put("codeID", "NUTS2");
childProperties.put("divisionCode", "BE21");
childProperties.put("codePublisher", "Eurostat");
childProperties.put("parentCodeID", "NUTS1");
childProperties.put("parentDivisionCode", "BE2");
children.add(child);
((Map<String, Object>) jpaEntity).put("children", children);
cut = new JPAMapResult(et, (Map<String, Object>) jpaEntity, headers, converter);
}
@SuppressWarnings("unchecked")
@Override
protected void createCutGetResultEntityWithSimpleCollection() throws ODataJPAModelException,
ODataApplicationException {
((Map<String, Object>) jpaEntity).put("iD", "1");
((Map<String, Object>) jpaEntity).put("comment", Arrays.asList("First", "Second"));
cut = new JPAMapResult(et, (Map<String, Object>) jpaEntity, headers, converter);
}
@SuppressWarnings("unchecked")
@Override
protected void createCutGetResultEntityWithComplexCollection() throws ODataJPAModelException,
ODataApplicationException {
et = helper.getJPAEntityType("Persons");
((Map<String, Object>) jpaEntity).put("iD", "1");
final Map<String, Object> addr1 = new HashMap<>();
final Map<String, Object> addr2 = new HashMap<>();
addr1.put("building", "A");
addr1.put("taskID", "DEV");
addr2.put("building", "C");
addr2.put("taskID", "MAIN");
((Map<String, Object>) jpaEntity).put("inhouseAddress", Arrays.asList(addr1, addr2));
cut = new JPAMapResult(et, (Map<String, Object>) jpaEntity, headers, converter);
}
@SuppressWarnings("unchecked")
@Override
protected void createCutGetResultEntityWithComplexWithCollection() throws ODataJPAModelException,
ODataApplicationException {
et = helper.getJPAEntityType("Collections");
final Map<String, Object> complex = new HashMap<>();
((Map<String, Object>) jpaEntity).put("iD", "1");
((Map<String, Object>) jpaEntity).put("complex", complex);
complex.put("number", 2L);
final Map<String, Object> addr1 = new HashMap<>();
final Map<String, Object> addr2 = new HashMap<>();
addr1.put("building", "A");
addr1.put("taskID", "DEV");
addr2.put("building", "C");
addr2.put("taskID", "MAIN");
complex.put("address", Arrays.asList(addr1, addr2));
cut = new JPAMapResult(et, (Map<String, Object>) jpaEntity, headers, converter);
}
@SuppressWarnings("unchecked")
@Override
protected void createCutGetResultEntityWithNestedComplexCollection() throws ODataJPAModelException,
ODataApplicationException {
et = helper.getJPAEntityType("Collections");
((Map<String, Object>) jpaEntity).put("iD", "1");
final Map<String, Object> nested1 = new HashMap<>();
final Map<String, Object> nested2 = new HashMap<>();
final Map<String, Object> inner1 = new HashMap<>();
final Map<String, Object> inner2 = new HashMap<>();
nested1.put("inner", inner1);
nested2.put("inner", inner2);
nested1.put("number", 100L);
nested1.put("number", 200L);
inner1.put("figure1", 1L);
inner1.put("figure3", 3L);
inner2.put("figure1", 11L);
inner2.put("figure3", 13L);
((Map<String, Object>) jpaEntity).put("nested", Arrays.asList(nested1, nested2));
cut = new JPAMapResult(et, (Map<String, Object>) jpaEntity, headers, converter);
}
@SuppressWarnings("unchecked")
@Override
protected void createCutGetResultEntityWithDeepComplexWithCollection() throws ODataJPAModelException,
ODataApplicationException {
et = helper.getJPAEntityType("CollectionDeeps");
final Map<String, Object> firstLevel = new HashMap<>();
final Map<String, Object> secondLevel = new HashMap<>();
((Map<String, Object>) jpaEntity).put("iD", "1");
((Map<String, Object>) jpaEntity).put("firstLevel", firstLevel);
firstLevel.put("levelID", 2);
firstLevel.put("secondLevel", secondLevel);
secondLevel.put("number", 2L);
final Map<String, Object> addr1 = new HashMap<>();
final Map<String, Object> addr2 = new HashMap<>();
addr1.put("building", "A");
addr1.put("taskID", "DEV");
addr2.put("building", "C");
addr2.put("taskID", "MAIN");
secondLevel.put("address", Arrays.asList(addr1, addr2));
cut = new JPAMapResult(et, (Map<String, Object>) jpaEntity, headers, converter);
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/modify/JPAEntityResultTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/modify/JPAEntityResultTest.java | package com.sap.olingo.jpa.processor.core.modify;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import org.apache.olingo.server.api.OData;
import org.apache.olingo.server.api.ODataApplicationException;
import org.junit.jupiter.api.BeforeEach;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.processor.core.converter.JPATupleChildConverter;
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.AdministrativeDivisionDescriptionKey;
import com.sap.olingo.jpa.processor.core.testmodel.BusinessPartner;
import com.sap.olingo.jpa.processor.core.testmodel.BusinessPartnerRole;
import com.sap.olingo.jpa.processor.core.testmodel.Collection;
import com.sap.olingo.jpa.processor.core.testmodel.CollectionDeep;
import com.sap.olingo.jpa.processor.core.testmodel.CollectionFirstLevelComplex;
import com.sap.olingo.jpa.processor.core.testmodel.CollectionInnerComplex;
import com.sap.olingo.jpa.processor.core.testmodel.CollectionNestedComplex;
import com.sap.olingo.jpa.processor.core.testmodel.CollectionPartOfComplex;
import com.sap.olingo.jpa.processor.core.testmodel.CollectionSecondLevelComplex;
import com.sap.olingo.jpa.processor.core.testmodel.InhouseAddress;
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.util.ServiceMetadataDouble;
import com.sap.olingo.jpa.processor.core.util.TestHelper;
class JPAEntityResultTest extends JPACreateResultTest {
@BeforeEach
void setUp() throws Exception {
headers = new HashMap<>();
jpaEntity = new Organization();
helper = new TestHelper(emf, PUNIT_NAME);
et = helper.getJPAEntityType("Organizations");
converter = new JPATupleChildConverter(helper.sd, OData.newInstance()
.createUriHelper(), new ServiceMetadataDouble(nameBuilder, "Organizations"), requestContext);
}
@Override
protected void createCutProvidesEmptyMap() throws ODataJPAModelException, ODataApplicationException {
cut = new JPAEntityResult(et, jpaEntity, headers, converter);
}
@Override
protected void createCutGetResultSimpleEntity() throws ODataJPAModelException, ODataApplicationException {
jpaEntity = new BusinessPartnerRole();
((BusinessPartnerRole) jpaEntity).setBusinessPartnerID("34");
((BusinessPartnerRole) jpaEntity).setRoleCategory("A");
cut = new JPAEntityResult(et, jpaEntity, headers, converter);
}
@Override
protected void createCutGetResultEntityWithTransient() throws ODataJPAModelException, ODataApplicationException {
jpaEntity = new Person();
((Person) jpaEntity).setID("1222");
((Person) jpaEntity).setFirstName("Hans");
((Person) jpaEntity).setLastName("Hubert");
cut = new JPAEntityResult(et, jpaEntity, headers, converter);
}
@Override
protected void createCutGetResultWithOneLevelEmbedded() throws ODataJPAModelException, ODataApplicationException {
final AdministrativeDivisionDescriptionKey key = new AdministrativeDivisionDescriptionKey();
key.setCodeID("A");
key.setLanguage("en");
jpaEntity = new AdministrativeDivisionDescription();
((AdministrativeDivisionDescription) jpaEntity).setName("Hugo");
((AdministrativeDivisionDescription) jpaEntity).setKey(key);
cut = new JPAEntityResult(et, jpaEntity, headers, converter);
}
@Override
protected void createCutGetResultWithTwoLevelEmbedded() throws ODataJPAModelException,
ODataApplicationException {
jpaEntity = new Organization();
((Organization) jpaEntity).onCreate();
((Organization) jpaEntity).setID("01");
((Organization) jpaEntity).setCustomString1("Dummy");
cut = new JPAEntityResult(et, jpaEntity, headers, converter);
}
@Override
protected void createCutGetResultWithDescriptionProperty() throws ODataJPAModelException, ODataApplicationException {
et = helper.getJPAEntityType("Organizations");
jpaEntity = new Organization();
final AdministrativeDivisionDescription description = new AdministrativeDivisionDescription();
description.setKey(new AdministrativeDivisionDescriptionKey("ISO", "3166", "DEU", "en"));
description.setName("MyDivision");
((BusinessPartner) jpaEntity).setLocationName(Arrays.asList(description));
((BusinessPartner) jpaEntity).setID("Willi");
((BusinessPartner) jpaEntity).setETag(7l);
cut = new JPAEntityResult(et, jpaEntity, headers, converter);
}
@Override
protected void createCutGetResultWithWithOneLinked() throws ODataJPAModelException, ODataApplicationException {
et = helper.getJPAEntityType("AdministrativeDivisions");
jpaEntity = new AdministrativeDivision();
final AdministrativeDivision child = new AdministrativeDivision();
final List<AdministrativeDivision> children = new ArrayList<>();
children.add(child);
((AdministrativeDivision) jpaEntity).setChildren(children);
child.setCodeID("NUTS2");
child.setDivisionCode("BE21");
child.setCodePublisher("Eurostat");
child.setParentCodeID("NUTS1");
child.setParentDivisionCode("BE2");
((AdministrativeDivision) jpaEntity).setCodeID("NUTS1");
((AdministrativeDivision) jpaEntity).setDivisionCode("BE2");
((AdministrativeDivision) jpaEntity).setCodePublisher("Eurostat");
cut = new JPAEntityResult(et, jpaEntity, headers, converter);
}
@Override
protected void createCutGetResultWithWithTwoLinked() throws ODataJPAModelException, ODataApplicationException {
createCutGetResultWithWithOneLinked();
final AdministrativeDivision child = new AdministrativeDivision();
final List<AdministrativeDivision> children = ((AdministrativeDivision) jpaEntity).getChildren();
children.add(child);
child.setCodeID("NUTS2");
child.setDivisionCode("BE22");
child.setCodePublisher("Eurostat");
child.setParentCodeID("NUTS1");
child.setParentDivisionCode("BE2");
cut = new JPAEntityResult(et, jpaEntity, headers, converter);
}
@Override
protected void createCutGetResultEntityWithSimpleCollection() throws ODataJPAModelException,
ODataApplicationException {
final Organization organization = new Organization();
final List<String> comment = organization.getComment();
comment.add("First");
comment.add("Second");
organization.setID("1");
jpaEntity = organization;
cut = new JPAEntityResult(et, jpaEntity, headers, converter);
}
@Override
protected void createCutGetResultEntityWithComplexCollection() throws ODataJPAModelException,
ODataApplicationException {
et = helper.getJPAEntityType("Persons");
final Person person = new Person();
final List<InhouseAddress> addresses = person.getInhouseAddress();
InhouseAddress address = new InhouseAddress();
address.setBuilding("A");
address.setTaskID("DEV");
addresses.add(address);
address = new InhouseAddress();
address.setBuilding("C");
address.setTaskID("MAIN");
addresses.add(address);
jpaEntity = person;
cut = new JPAEntityResult(et, jpaEntity, headers, converter);
}
@Override
protected void createCutGetResultEntityWithComplexWithCollection() throws ODataJPAModelException,
ODataApplicationException {
et = helper.getJPAEntityType("Collections");
final Collection collection = new Collection();
final CollectionPartOfComplex complex = new CollectionPartOfComplex();
final List<InhouseAddress> addresses = complex.getAddress();
complex.setNumber(2L);
collection.setComplex(complex);
InhouseAddress address = new InhouseAddress();
address.setBuilding("A");
address.setTaskID("DEV");
addresses.add(address);
address = new InhouseAddress();
address.setBuilding("C");
address.setTaskID("MAIN");
addresses.add(address);
jpaEntity = collection;
cut = new JPAEntityResult(et, jpaEntity, headers, converter);
}
@Override
protected void createCutGetResultEntityWithNestedComplexCollection() throws ODataJPAModelException,
ODataApplicationException {
et = helper.getJPAEntityType("Collections");
final Collection collection = new Collection();
final List<CollectionNestedComplex> nested = new ArrayList<>();
collection.setNested(nested);
CollectionNestedComplex nestedItem = new CollectionNestedComplex();
CollectionInnerComplex inner = new CollectionInnerComplex();
inner.setFigure1(1L);
inner.setFigure3(BigInteger.valueOf(3L));
nestedItem.setInner(inner);
nestedItem.setNumber(100L);
nested.add(nestedItem);
nestedItem = new CollectionNestedComplex();
inner = new CollectionInnerComplex();
inner.setFigure1(11L);
inner.setFigure3(BigInteger.valueOf(13L));
nestedItem.setInner(inner);
nestedItem.setNumber(200L);
nested.add(nestedItem);
jpaEntity = collection;
cut = new JPAEntityResult(et, jpaEntity, headers, converter);
}
@Override
protected void createCutGetResultEntityWithDeepComplexWithCollection() throws ODataJPAModelException,
ODataApplicationException {
et = helper.getJPAEntityType("CollectionDeeps");
final CollectionDeep collection = new CollectionDeep();
final CollectionFirstLevelComplex firstLevel = new CollectionFirstLevelComplex();
final CollectionSecondLevelComplex secondLevel = new CollectionSecondLevelComplex();
final List<InhouseAddress> addresses = secondLevel.getAddress();
collection.setID("27");
collection.setFirstLevel(firstLevel);
firstLevel.setLevelID(3);
firstLevel.setSecondLevel(secondLevel);
InhouseAddress address = new InhouseAddress();
address.setBuilding("A");
address.setTaskID("DEV");
addresses.add(address);
address = new InhouseAddress();
address.setBuilding("C");
address.setTaskID("MAIN");
addresses.add(address);
jpaEntity = collection;
cut = new JPAEntityResult(et, jpaEntity, headers, converter);
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/modify/JPAConversionHelperMapTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/modify/JPAConversionHelperMapTest.java | package com.sap.olingo.jpa.processor.core.modify;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.when;
import java.util.HashMap;
import java.util.Map;
import org.apache.olingo.server.api.serializer.SerializerException;
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.exception.ODataJPAModelException;
import com.sap.olingo.jpa.processor.core.exception.ODataJPAProcessorException;
import com.sap.olingo.jpa.processor.core.testmodel.Organization;
public class JPAConversionHelperMapTest extends JPAConversionHelperTest {
@BeforeEach
public void setUp() {
cut = new JPAConversionHelper();
}
@Override
@Test
public void testConvertCompoundKeyToLocation() throws ODataJPAProcessorException, SerializerException,
ODataJPAModelException {
final Map<String, Object> newPOJO = new HashMap<>();
newPOJO.put("businessPartnerID", "35");
newPOJO.put("roleCategory", "A");
prepareConvertCompoundKeyToLocation();
final String act = cut.convertKeyToLocal(odata, request, edmEntitySet, et, newPOJO);
assertEquals("localhost.test/BusinessPartnerRoles(BusinessPartnerID='35',RoleCategory='A')", act);
}
@Override
@Test
public void testConvertEmbeddedIdToLocation() throws ODataJPAProcessorException, SerializerException,
ODataJPAModelException {
final Map<String, Object> newPOJO = new HashMap<>();
final Map<String, Object> primaryKey = new HashMap<>();
primaryKey.put("codeID", "NUTS1");
primaryKey.put("codePublisher", "Eurostat");
primaryKey.put("divisionCode", "BE1");
primaryKey.put("language", "fr");
newPOJO.put("key", primaryKey);
prepareConvertEmbeddedIdToLocation();
final String act = cut.convertKeyToLocal(odata, request, edmEntitySet, et, newPOJO);
assertEquals(
"localhost.test/AdministrativeDivisionDescriptions(DivisionCode='BE1',CodeID='NUTS1',CodePublisher='Eurostat',Language='fr')",
act);
}
@Override
@Test
public void testConvertSimpleKeyToLocation() throws ODataJPAProcessorException, SerializerException,
ODataJPAModelException {
final Map<String, Object> newPOJO = new HashMap<>();
newPOJO.put("iD", "35");
prepareConvertSimpleKeyToLocation();
when(et.getTypeClass()).then(new Answer<Class<?>>() {
@Override
public Class<?> answer(final InvocationOnMock invocation) throws Throwable {
return Organization.class;
}
});
final String act = cut.convertKeyToLocal(odata, request, edmEntitySet, et, newPOJO);
assertEquals("localhost.test/Organisation('35')", act);
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/modify/AbstractJPAEntityBasedResultTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/modify/AbstractJPAEntityBasedResultTest.java | package com.sap.olingo.jpa.processor.core.modify;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.mockito.Mockito.mock;
import org.apache.olingo.commons.api.ex.ODataException;
import org.apache.olingo.server.api.ODataApplicationException;
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.core.converter.JPAExpandResult;
import com.sap.olingo.jpa.processor.core.converter.JPAResultConverter;
import com.sap.olingo.jpa.processor.core.testmodel.AdministrativeDivision;
import com.sap.olingo.jpa.processor.core.util.TestBase;
abstract class AbstractJPAEntityBasedResultTest extends TestBase {
JPAResultConverter converter;
@BeforeEach
void setup() throws ODataException {
getHelper();
converter = mock(JPAResultConverter.class);
}
@Test
void testConvertEntityResult() throws ODataJPAModelException, ODataApplicationException {
final var et = helper.getJPAEntityType(AdministrativeDivision.class);
final var division = createAdministrativeDivision();
final var act = createResult(et, division);
assertEquals(1, act.getResults().size());
final var actRoot = act.getResult(JPAExpandResult.ROOT_RESULT_KEY).get(0);
assertNotNull(actRoot);
assertEquals("ISO", actRoot.get("CodePublisher"));
}
abstract Object createAdministrativeDivision();
abstract JPACreateResult createResult(final JPAEntityType et, final Object result) throws ODataJPAModelException,
ODataApplicationException;
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/modify/TestJPACUDRequestHelper.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/modify/TestJPACUDRequestHelper.java | package com.sap.olingo.jpa.processor.core.modify;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
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.api.Assertions.fail;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Stream;
import jakarta.persistence.AttributeConverter;
import org.apache.olingo.commons.api.data.ComplexValue;
import org.apache.olingo.commons.api.data.Entity;
import org.apache.olingo.commons.api.data.Property;
import org.apache.olingo.commons.api.data.ValueType;
import org.apache.olingo.commons.api.edm.EdmComplexType;
import org.apache.olingo.commons.api.edm.EdmEntitySet;
import org.apache.olingo.commons.api.edm.EdmEntityType;
import org.apache.olingo.commons.api.edm.EdmPrimitiveType;
import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeException;
import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeKind;
import org.apache.olingo.commons.api.edm.EdmProperty;
import org.apache.olingo.commons.api.edm.FullQualifiedName;
import org.apache.olingo.commons.api.edm.constants.EdmTypeKind;
import org.apache.olingo.commons.api.edm.provider.CsdlProperty;
import org.apache.olingo.commons.api.format.ContentType;
import org.apache.olingo.commons.api.http.HttpHeader;
import org.apache.olingo.commons.api.http.HttpStatusCode;
import org.apache.olingo.server.api.OData;
import org.apache.olingo.server.api.ODataRequest;
import org.apache.olingo.server.api.uri.UriResource;
import org.apache.olingo.server.api.uri.UriResourceComplexProperty;
import org.apache.olingo.server.api.uri.UriResourceEntitySet;
import org.apache.olingo.server.api.uri.UriResourceKind;
import org.apache.olingo.server.api.uri.UriResourceProperty;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
import org.mockito.ArgumentMatchers;
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;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAStructuredType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.processor.core.exception.ODataJPAProcessException;
import com.sap.olingo.jpa.processor.core.exception.ODataJPAProcessorException;
import com.sap.olingo.jpa.processor.core.query.EdmBindingTargetInfo;
import com.sap.olingo.jpa.processor.core.testmodel.ABCClassification;
import com.sap.olingo.jpa.processor.core.testmodel.AccessRights;
import com.sap.olingo.jpa.processor.core.testmodel.AccessRightsConverter;
import com.sap.olingo.jpa.processor.core.testmodel.BusinessPartnerRole;
import com.sap.olingo.jpa.processor.core.testmodel.DateConverter;
class TestJPACUDRequestHelper {
private static final String COMMENT_INT_PROPERTY_NAME = "comment";
private static final String COMMENT_EXT_PROPERTY_NAME = "Comment";
private static final String INHOUSE_EXT_PROPERTY_NAME = "InhouseAddress";
private JPAConversionHelper cut;
private List<UriResource> uriResourceParts;
private ODataRequest request;
private List<String> headers;
@BeforeEach
void setUp() {
request = mock(ODataRequest.class);
headers = new ArrayList<>(1);
uriResourceParts = new ArrayList<>();
cut = new JPAConversionHelper();
}
@Test
void testConvertEmptyInputStream() throws UnsupportedEncodingException {
final EdmBindingTargetInfo etsInfo = mock(EdmBindingTargetInfo.class);
final EdmEntitySet ets = mock(EdmEntitySet.class);
final UriResourceEntitySet uriEs = mock(UriResourceEntitySet.class);
final InputStream is = new ByteArrayInputStream("".getBytes("UTF-8"));
uriResourceParts.add(uriEs);
when(uriEs.getEntitySet()).thenReturn(ets);
when(uriEs.getKind()).thenReturn(UriResourceKind.entitySet);
when(request.getBody()).thenReturn(is);
when(etsInfo.getEdmBindingTarget()).thenReturn(ets);
when(etsInfo.getTargetEdmBindingTarget()).thenReturn(ets);
try {
cut.convertInputStream(OData.newInstance(), request, ContentType.APPLICATION_JSON, uriResourceParts);
} catch (final ODataJPAProcessorException e) {
assertEquals(HttpStatusCode.BAD_REQUEST.getStatusCode(), e.getStatusCode());
return;
}
fail();
}
@SuppressWarnings("unchecked")
@Test
void testConvertInputStreamComplexColectionProperty() throws UnsupportedEncodingException,
ODataJPAProcessorException, EdmPrimitiveTypeException {
final EdmEntitySet edmEntitySet = mock(EdmEntitySet.class);
final EdmEntityType edmEntityType = mock(EdmEntityType.class);
final EdmProperty edmPropertyInhouse = mock(EdmProperty.class);
final EdmComplexType edmTypeInhouse = mock(EdmComplexType.class);
final UriResourceEntitySet uriEs = mock(UriResourceEntitySet.class);
final UriResourceComplexProperty uriProperty = mock(UriResourceComplexProperty.class);
final FullQualifiedName fqn = new FullQualifiedName("test", "Person");
final FullQualifiedName fqnString = new FullQualifiedName("test", "Person");
final List<String> propertyNames = new ArrayList<>();
propertyNames.add(INHOUSE_EXT_PROPERTY_NAME);
uriResourceParts.add(uriEs);
uriResourceParts.add(uriProperty);
when(uriEs.getEntitySet()).thenReturn(edmEntitySet);
when(uriEs.getKind()).thenReturn(UriResourceKind.entitySet);
when(uriProperty.getProperty()).thenReturn(edmPropertyInhouse);
when(uriProperty.getKind()).thenReturn(UriResourceKind.complexProperty);
when(edmTypeInhouse.getFullQualifiedName()).thenReturn(fqnString);
when(edmTypeInhouse.getKind()).thenReturn(EdmTypeKind.COMPLEX);
when(edmTypeInhouse.getName()).thenReturn(INHOUSE_EXT_PROPERTY_NAME);
when(edmTypeInhouse.getPropertyNames()).thenReturn(Arrays.asList("RoomNumber", "Floor", "TaskID", "Building"));
EdmProperty edmProperty = createPropertyMock("RoomNumber", EdmPrimitiveTypeKind.Int32, Integer.class, 25);
when(edmTypeInhouse.getProperty("RoomNumber")).thenReturn(edmProperty);
edmProperty = createPropertyMock("Floor", EdmPrimitiveTypeKind.Int16, Short.class, 2);
when(edmTypeInhouse.getProperty("Floor")).thenReturn(edmProperty);
edmProperty = createPropertyMock("TaskID", EdmPrimitiveTypeKind.String, String.class, "DEV");
when(edmTypeInhouse.getProperty("TaskID")).thenReturn(edmProperty);
edmProperty = createPropertyMock("Building", EdmPrimitiveTypeKind.String, String.class, "2");
when(edmTypeInhouse.getProperty("Building")).thenReturn(edmProperty);
when(edmEntitySet.getEntityType()).thenReturn(edmEntityType);
when(edmEntityType.getFullQualifiedName()).thenReturn(fqn);
when(edmEntityType.getPropertyNames()).thenReturn(propertyNames);
when(edmEntityType.getProperty(INHOUSE_EXT_PROPERTY_NAME)).thenReturn(edmPropertyInhouse);
when(edmPropertyInhouse.getName()).thenReturn(INHOUSE_EXT_PROPERTY_NAME);
when(edmPropertyInhouse.getType()).thenReturn(edmTypeInhouse);
when(edmPropertyInhouse.isCollection()).thenReturn(true);
final InputStream is = new ByteArrayInputStream(
"{\"value\": [{\"RoomNumber\": 25, \"Floor\": 2,\"TaskID\": \"DEV\", \"Building\": \"2\" }]}".getBytes(
"UTF-8"));
when(request.getBody()).thenReturn(is);
final Entity act = cut.convertInputStream(OData.newInstance(), request, ContentType.APPLICATION_JSON,
uriResourceParts);
assertEquals(ValueType.COLLECTION_COMPLEX, act.getProperty(INHOUSE_EXT_PROPERTY_NAME).getValueType());
final List<ComplexValue> actValue = (List<ComplexValue>) act.getProperty(INHOUSE_EXT_PROPERTY_NAME).getValue();
assertEquals(1, actValue.size());
final ComplexValue actInhouseMail = actValue.get(0);
assertNotNull(actInhouseMail.getValue().get(0).getValue());
}
@Test
void testConvertInputStreamEntitySet() throws UnsupportedEncodingException, ODataJPAProcessorException,
EdmPrimitiveTypeException {
prepareEntitySet();
final InputStream is = new ByteArrayInputStream("{\"ID\" : \"35\"}".getBytes("UTF-8"));
when(request.getBody()).thenReturn(is);
final Entity act = cut.convertInputStream(OData.newInstance(), request, ContentType.APPLICATION_JSON,
uriResourceParts);
assertEquals("35", act.getProperty("ID").getValue());
}
@Test
void testConvertInputStreamEntitySetWithAnnotationV400() throws UnsupportedEncodingException,
ODataJPAProcessorException, EdmPrimitiveTypeException {
headers.add("4.00");
prepareEntitySet();
final InputStream is = new ByteArrayInputStream(
"{\"@odata.context\": \"$metadata#test.Organisation\", \"@odata.type\": \"#test.Organisation\", \"ID\" : \"35\"}"
.getBytes("UTF-8"));
when(request.getBody()).thenReturn(is);
when(request.getHeaders(HttpHeader.ODATA_VERSION)).thenReturn(headers);
final Entity act = cut.convertInputStream(OData.newInstance(), request, ContentType.APPLICATION_JSON,
uriResourceParts);
assertEquals("35", act.getProperty("ID").getValue());
}
@Test
void testConvertInputStreamEntitySetWithAnnotationV401() throws UnsupportedEncodingException,
ODataJPAProcessorException, EdmPrimitiveTypeException {
headers.add("4.01");
prepareEntitySet();
final InputStream is = new ByteArrayInputStream(
"{\"@context\": \"$metadata#test.Organisation\", \"@type\": \"#test.Organisation\", \"ID\" : \"35\"}"
.getBytes("UTF-8"));
when(request.getBody()).thenReturn(is);
when(request.getHeaders(HttpHeader.ODATA_VERSION)).thenReturn(headers);
final Entity act = cut.convertInputStream(OData.newInstance(), request, ContentType.APPLICATION_JSON,
uriResourceParts);
assertEquals("35", act.getProperty("ID").getValue());
}
@Test
void testConvertInputStreamEntitySetThrowsExceptionOnAnnotationMismatch() throws UnsupportedEncodingException,
EdmPrimitiveTypeException {
prepareEntitySet();
final InputStream is = new ByteArrayInputStream(
"{\"@context\": \"$metadata#com.sap.olingo.jpa.Organization\", \"@type\": \"#com.sap.olingo.jpa.Organization\", \"ID\" : \"35\"}"
.getBytes("UTF-8"));
when(request.getBody()).thenReturn(is);
assertThrows(ODataJPAProcessorException.class, () -> cut.convertInputStream(OData.newInstance(), request,
ContentType.APPLICATION_JSON, uriResourceParts));
}
@SuppressWarnings("unchecked")
@Test
void testConvertInputStreamPrimitiveCollectionProperty() throws UnsupportedEncodingException,
ODataJPAProcessorException, EdmPrimitiveTypeException {
final EdmEntitySet edmEntitySet = mock(EdmEntitySet.class);
final EdmEntityType edmEntityType = mock(EdmEntityType.class);
final EdmProperty edmPropertyName = mock(EdmProperty.class);
final EdmPrimitiveType edmTypeName = mock(EdmPrimitiveType.class);
final UriResourceEntitySet uriEs = mock(UriResourceEntitySet.class);
final UriResourceProperty uriProperty = mock(UriResourceProperty.class);
final FullQualifiedName fqn = new FullQualifiedName("test", "Organisation");
final FullQualifiedName fqnString = new FullQualifiedName("test", "Organisation");
final List<String> propertyNames = new ArrayList<>();
propertyNames.add(COMMENT_EXT_PROPERTY_NAME);
uriResourceParts.add(uriEs);
uriResourceParts.add(uriProperty);
when(uriEs.getEntitySet()).thenReturn(edmEntitySet);
when(uriEs.getKind()).thenReturn(UriResourceKind.entitySet);
when(uriProperty.getProperty()).thenReturn(edmPropertyName);
when(uriProperty.getKind()).thenReturn(UriResourceKind.primitiveProperty);
when(edmTypeName.getFullQualifiedName()).thenReturn(fqnString);
when(edmTypeName.getKind()).thenReturn(EdmTypeKind.PRIMITIVE);
when(edmTypeName.getName()).thenReturn("String");
when(edmTypeName.valueOfString(ArgumentMatchers.eq("YAC"), ArgumentMatchers.anyBoolean(), ArgumentMatchers
.anyInt(), ArgumentMatchers.anyInt(), ArgumentMatchers.anyInt(), ArgumentMatchers.anyBoolean(),
(Class<String>) ArgumentMatchers.any())).thenReturn("YAC");
when(edmTypeName.valueOfString(ArgumentMatchers.eq("WTN"), ArgumentMatchers.anyBoolean(), ArgumentMatchers
.anyInt(), ArgumentMatchers.anyInt(), ArgumentMatchers.anyInt(), ArgumentMatchers.anyBoolean(),
(Class<String>) ArgumentMatchers.any())).thenReturn("WTN");
when(edmEntitySet.getEntityType()).thenReturn(edmEntityType);
when(edmEntityType.getFullQualifiedName()).thenReturn(fqn);
when(edmEntityType.getPropertyNames()).thenReturn(propertyNames);
when(edmEntityType.getProperty(COMMENT_EXT_PROPERTY_NAME)).thenReturn(edmPropertyName);
when(edmPropertyName.getName()).thenReturn(COMMENT_EXT_PROPERTY_NAME);
when(edmPropertyName.getType()).thenReturn(edmTypeName);
when(edmPropertyName.isCollection()).thenReturn(true);
final InputStream is = new ByteArrayInputStream("{ \"value\": [\"YAC\",\"WTN\"] }".getBytes("UTF-8"));
when(request.getBody()).thenReturn(is);
final Entity act = cut.convertInputStream(OData.newInstance(), request, ContentType.APPLICATION_JSON,
uriResourceParts);
assertEquals(ValueType.COLLECTION_PRIMITIVE, act.getProperty(COMMENT_EXT_PROPERTY_NAME).getValueType());
final List<String> actValue = (List<String>) act.getProperty(COMMENT_EXT_PROPERTY_NAME).getValue();
assertEquals(2, actValue.size());
assertEquals("YAC", actValue.get(0));
assertEquals("WTN", actValue.get(1));
}
static Stream<ByteArrayInputStream> stringIntAndListProvider() throws UnsupportedEncodingException {
return Arrays.asList(new ByteArrayInputStream("{\"value\" : \"Willi\"}".getBytes("UTF-8")), // Primitive
new ByteArrayInputStream("{\"value\" : \"Willi\"}".getBytes("UTF-8")), // WithAnnotationV400
new ByteArrayInputStream( // WithAnnotationV401
"{ \"@jpa.odata.context\": \"$metadata#Organisations\", \"value\" : \"Willi\"}".getBytes("UTF-8")))
.stream();
}
@ParameterizedTest
@MethodSource("stringIntAndListProvider")
void testConvertInputStreamSimpleProperty(final InputStream is) throws ODataJPAProcessorException,
EdmPrimitiveTypeException {
final ODataRequest otherRequest = preparePrimitiveSimpleProperty();
when(otherRequest.getBody()).thenReturn(is);
final Entity act = cut.convertInputStream(OData.newInstance(), otherRequest, ContentType.APPLICATION_JSON,
uriResourceParts);
assertEquals("Willi", act.getProperty("Name2").getValue());
}
@Test
void testConvertPropertiesConvertException() throws ODataJPAModelException {
final List<Property> odataProperties = new ArrayList<>();
final JPAStructuredType st = mock(JPAStructuredType.class);
final Property propertyID = mock(Property.class);
when(propertyID.getValueType()).thenReturn(ValueType.PRIMITIVE);
when(propertyID.getName()).thenReturn("iD");
when(propertyID.getValue()).thenReturn("35");
odataProperties.add(propertyID);
when(st.getPath(ArgumentMatchers.anyString())).thenThrow(new ODataJPAModelException(new NullPointerException()));
try {
cut.convertProperties(OData.newInstance(), st, odataProperties);
} catch (final ODataJPAProcessException e) {
assertEquals(HttpStatusCode.INTERNAL_SERVER_ERROR.getStatusCode(), e.getStatusCode());
return;
}
fail();
}
@SuppressWarnings("unchecked")
@Test
void testConvertPropertiesEmptyComplexCollectionProperty() throws ODataJPAProcessException,
ODataJPAModelException {
final List<Property> odataProperties = new ArrayList<>();
final List<ComplexValue> odataComment = new ArrayList<>();
final JPAStructuredType st = createMetadataForSimpleProperty("Address", "address");
final JPAStructuredType nb = createMetadataForSimpleProperty("Number", "number");
final JPAAttribute attributeAddress = mock(JPAAttribute.class);
when(attributeAddress.getStructuredType()).thenReturn(nb);
when(st.getAttribute("address")).thenReturn(Optional.of(attributeAddress));
final Property propertyAddress = mock(Property.class);
when(propertyAddress.getValueType()).thenReturn(ValueType.COLLECTION_COMPLEX);
when(propertyAddress.getName()).thenReturn("Address");
when(propertyAddress.getValue()).thenReturn(odataComment);
odataProperties.add(propertyAddress);
final Map<String, Object> act = cut.convertProperties(OData.newInstance(), st, odataProperties);
assertNotNull(act.get("address"));
assertEquals(0, ((List<Map<String, Object>>) act.get("address")).size());
}
@Test
void testConvertPropertiesEmptyList() throws ODataJPAProcessException {
final List<Property> odataProperties = new ArrayList<>();
final JPAStructuredType st = mock(JPAStructuredType.class);
final Map<String, Object> act = cut.convertProperties(OData.newInstance(), st, odataProperties);
assertNotNull(act);
assertEquals(0, act.size());
}
@Test
void testConvertPropertiesEmptySimpleCollectionProperty() throws ODataJPAProcessException,
ODataJPAModelException {
final List<Property> odataProperties = new ArrayList<>();
final List<String> odataComment = new ArrayList<>();
final JPAStructuredType st = createMetadataForSimpleProperty(COMMENT_EXT_PROPERTY_NAME, COMMENT_INT_PROPERTY_NAME);
final Property propertyComment = mock(Property.class);
when(propertyComment.getValueType()).thenReturn(ValueType.COLLECTION_PRIMITIVE);
when(propertyComment.getName()).thenReturn(COMMENT_EXT_PROPERTY_NAME);
when(propertyComment.getValue()).thenReturn(odataComment);
odataProperties.add(propertyComment);
final Map<String, Object> act = cut.convertProperties(OData.newInstance(), st, odataProperties);
assertNotNull(act.get(COMMENT_INT_PROPERTY_NAME));
assertTrue(((List<?>) act.get(COMMENT_INT_PROPERTY_NAME)).isEmpty());
}
@SuppressWarnings("unchecked")
@Test
void testConvertPropertiesOneComplexCollectionProperty() throws ODataJPAProcessException,
ODataJPAModelException {
final List<Property> odataProperties = new ArrayList<>();
final List<ComplexValue> odataComment = new ArrayList<>();
final List<Property> addressProperties = new ArrayList<>();
final JPAStructuredType st = createMetadataForSimpleProperty("Address", "address");
final JPAStructuredType nb = createMetadataForSimpleProperty("Number", "number");
final JPAAttribute attributeAddress = mock(JPAAttribute.class);
when(attributeAddress.getStructuredType()).thenReturn(nb);
when(st.getAttribute("address")).thenReturn(Optional.of(attributeAddress));
final ComplexValue cv1 = mock(ComplexValue.class);
final Property propertyNumber = mock(Property.class);
when(propertyNumber.getValueType()).thenReturn(ValueType.PRIMITIVE);
when(propertyNumber.getName()).thenReturn("Number");
when(propertyNumber.getValue()).thenReturn(32);
addressProperties.add(propertyNumber);
when(cv1.getValue()).thenReturn(addressProperties);
odataComment.add(cv1);
final Property propertyAddress = mock(Property.class);
when(propertyAddress.getValueType()).thenReturn(ValueType.COLLECTION_COMPLEX);
when(propertyAddress.getName()).thenReturn("Address");
when(propertyAddress.getValue()).thenReturn(odataComment);
odataProperties.add(propertyAddress);
final Map<String, Object> act = cut.convertProperties(OData.newInstance(), st, odataProperties);
assertNotNull(act.get("address"));
assertEquals(1, ((List<Map<String, Object>>) act.get("address")).size());
final Map<String, Object> actAddr = (Map<String, Object>) ((List<?>) act.get("address")).get(0);
assertEquals(32, actAddr.get("number"));
}
@Test
void testConvertPropertiesOneComplexProperty() throws ODataJPAProcessException, ODataJPAModelException {
final List<Property> odataProperties = new ArrayList<>();
final JPAStructuredType st = mock(JPAStructuredType.class);
final Property propertyID = mock(Property.class);
final JPAAttribute attribute = mock(JPAAttribute.class);
final JPAPath pathID = mock(JPAPath.class);
final CsdlProperty edmProperty = mock(CsdlProperty.class);
when(st.getPath("ID")).thenReturn(pathID);
when(pathID.getLeaf()).thenReturn(attribute);
when(attribute.getInternalName()).thenReturn("iD");
final Answer<?> a = (new Answer<>() {
@Override
public Object answer(final InvocationOnMock invocation) {
return String.class;
}
});
when(attribute.getType()).thenAnswer(a);
when(attribute.getProperty()).thenReturn(edmProperty);
when(edmProperty.getMaxLength()).thenReturn(100);
when(propertyID.getValueType()).thenReturn(ValueType.PRIMITIVE);
when(propertyID.getName()).thenReturn("ID");
when(propertyID.getValue()).thenReturn("35");
odataProperties.add(propertyID);
final ComplexValue cv = new ComplexValue();
final List<JPAElement> addressPathElements = new ArrayList<>();
final JPAElement addressElement = mock(JPAElement.class);
addressPathElements.add(addressElement);
when(addressElement.getInternalName()).thenReturn("address");
final Property propertyAddress = mock(Property.class);
when(propertyAddress.getValueType()).thenReturn(ValueType.COMPLEX);
when(propertyAddress.getName()).thenReturn("Address");
when(propertyAddress.getValue()).thenReturn(cv);
odataProperties.add(propertyAddress);
final JPAPath pathAddress = mock(JPAPath.class);
when(st.getPath("Address")).thenReturn(pathAddress);
when(pathAddress.getPath()).thenReturn(addressPathElements);
final JPAAttribute attributeAddress = mock(JPAAttribute.class);
when(st.getAttribute("address")).thenReturn(Optional.of(attributeAddress));
final Map<String, Object> act = cut.convertProperties(OData.newInstance(), st, odataProperties);
assertNotNull(act);
assertEquals(2, act.size());
assertTrue(act.get("address") instanceof Map<?, ?>);
}
@Test
void testConvertPropertiesOneEnumPropertyWithConverter() throws ODataJPAProcessException,
ODataJPAModelException {
final List<Property> odataProperties = new ArrayList<>();
final JPAStructuredType st = mock(JPAStructuredType.class);
final Property propertyID = mock(Property.class);
final JPAAttribute attribute = mock(JPAAttribute.class);
final JPAPath path = mock(JPAPath.class);
final CsdlProperty edmProperty = mock(CsdlProperty.class);
when(st.getPath("AccessRights")).thenReturn(path);
when(path.getLeaf()).thenReturn(attribute);
when(attribute.getInternalName()).thenReturn("accessRights");
final Answer<?> a = (new Answer<>() {
@Override
public Object answer(final InvocationOnMock invocation) {
return AccessRights.class;
}
});
when(attribute.getType()).thenAnswer(a);
when(attribute.getProperty()).thenReturn(edmProperty);
when(attribute.getConverter()).thenAnswer(new Answer<AttributeConverter<?, ?>>() {
@Override
public AttributeConverter<?, ?> answer(final InvocationOnMock invocation) throws Throwable {
return new AccessRightsConverter();
}
});
when(edmProperty.getMaxLength()).thenReturn(100);
when(propertyID.getValueType()).thenReturn(ValueType.ENUM);
when(propertyID.getName()).thenReturn("AccessRights");
when(propertyID.getValue()).thenReturn((short) 8);
odataProperties.add(propertyID);
final Map<String, Object> act = cut.convertProperties(OData.newInstance(), st, odataProperties);
assertNotNull(act);
assertEquals(1, act.size());
final AccessRights[] actProperty = (AccessRights[]) act.get("accessRights");
assertArrayEquals(new Object[] { AccessRights.DELETE }, actProperty);
}
@Test
void testConvertPropertiesOneEnumPropertyWithoutConverter() throws ODataJPAProcessException,
ODataJPAModelException {
final List<Property> odataProperties = new ArrayList<>();
final JPAStructuredType st = mock(JPAStructuredType.class);
final Property propertyID = mock(Property.class);
final JPAAttribute attribute = mock(JPAAttribute.class);
final JPAPath path = mock(JPAPath.class);
final CsdlProperty edmProperty = mock(CsdlProperty.class);
when(st.getPath("ABCClass")).thenReturn(path);
when(path.getLeaf()).thenReturn(attribute);
when(attribute.getInternalName()).thenReturn("aBCClass");
final Answer<?> a = (new Answer<>() {
@Override
public Object answer(final InvocationOnMock invocation) {
return ABCClassification.class;
}
});
when(attribute.getType()).thenAnswer(a);
when(attribute.getProperty()).thenReturn(edmProperty);
when(attribute.isEnum()).thenReturn(true);
when(propertyID.getValueType()).thenReturn(ValueType.ENUM);
when(propertyID.getName()).thenReturn("ABCClass");
when(propertyID.getValue()).thenReturn(1);
odataProperties.add(propertyID);
final Map<String, Object> act = cut.convertProperties(OData.newInstance(), st, odataProperties);
assertNotNull(act);
assertEquals(1, act.size());
assertEquals(ABCClassification.B, act.get("aBCClass"));
}
@Test
void testConvertPropertiesOnePrimitiveProperty() throws ODataJPAProcessException, ODataJPAModelException {
final List<Property> odataProperties = new ArrayList<>();
final JPAStructuredType st = mock(JPAStructuredType.class);
final Property propertyID = mock(Property.class);
final JPAAttribute attribute = mock(JPAAttribute.class);
final JPAPath path = mock(JPAPath.class);
final CsdlProperty edmProperty = mock(CsdlProperty.class);
when(st.getPath("ID")).thenReturn(path);
when(path.getLeaf()).thenReturn(attribute);
when(attribute.getInternalName()).thenReturn("iD");
final Answer<?> a = (new Answer<>() {
@Override
public Object answer(final InvocationOnMock invocation) {
return String.class;
}
});
when(attribute.getType()).thenAnswer(a);
when(attribute.getProperty()).thenReturn(edmProperty);
when(edmProperty.getMaxLength()).thenReturn(100);
when(propertyID.getValueType()).thenReturn(ValueType.PRIMITIVE);
when(propertyID.getName()).thenReturn("ID");
when(propertyID.getValue()).thenReturn("35");
odataProperties.add(propertyID);
final Map<String, Object> act = cut.convertProperties(OData.newInstance(), st, odataProperties);
assertNotNull(act);
assertEquals(1, act.size());
assertEquals("35", act.get("iD"));
}
@Test
void testConvertPropertiesOneSimpleCollectionProperty() throws ODataJPAProcessException,
ODataJPAModelException {
final List<Property> odataProperties = new ArrayList<>();
final List<String> odataComment = new ArrayList<>();
final JPAStructuredType st = createMetadataForSimpleProperty(COMMENT_EXT_PROPERTY_NAME, COMMENT_INT_PROPERTY_NAME);
odataComment.add("First Test");
final Property propertyComment = mock(Property.class);
when(propertyComment.getValueType()).thenReturn(ValueType.COLLECTION_PRIMITIVE);
when(propertyComment.getName()).thenReturn(COMMENT_EXT_PROPERTY_NAME);
when(propertyComment.getValue()).thenReturn(odataComment);
odataProperties.add(propertyComment);
final Map<String, Object> act = cut.convertProperties(OData.newInstance(), st, odataProperties);
assertNotNull(act.get(COMMENT_INT_PROPERTY_NAME));
assertEquals(1, ((List<?>) act.get(COMMENT_INT_PROPERTY_NAME)).size());
assertEquals("First Test", ((List<?>) act.get(COMMENT_INT_PROPERTY_NAME)).get(0));
}
@SuppressWarnings("unchecked")
@Test
void testConvertPropertiesTwoComplexCollectionProperty() throws ODataJPAProcessException,
ODataJPAModelException {
final List<Property> odataProperties = new ArrayList<>();
final List<ComplexValue> odataComment = new ArrayList<>();
final JPAStructuredType st = createMetadataForSimpleProperty("Address", "address");
final JPAStructuredType nb = createMetadataForSimpleProperty("Number", "number");
final JPAAttribute attributeAddress = mock(JPAAttribute.class);
when(attributeAddress.getStructuredType()).thenReturn(nb);
when(st.getAttribute("address")).thenReturn(Optional.of(attributeAddress));
List<Property> addressProperties = new ArrayList<>();
final ComplexValue cv1 = mock(ComplexValue.class);
Property propertyNumber = mock(Property.class);
when(propertyNumber.getValueType()).thenReturn(ValueType.PRIMITIVE);
when(propertyNumber.getName()).thenReturn("Number");
when(propertyNumber.getValue()).thenReturn(32);
addressProperties.add(propertyNumber);
when(cv1.getValue()).thenReturn(addressProperties);
addressProperties = new ArrayList<>();
final ComplexValue cv2 = mock(ComplexValue.class);
propertyNumber = mock(Property.class);
when(propertyNumber.getValueType()).thenReturn(ValueType.PRIMITIVE);
when(propertyNumber.getName()).thenReturn("Number");
when(propertyNumber.getValue()).thenReturn(16);
addressProperties.add(propertyNumber);
when(cv2.getValue()).thenReturn(addressProperties);
odataComment.add(cv1);
odataComment.add(cv2);
final Property propertyAddress = mock(Property.class);
when(propertyAddress.getValueType()).thenReturn(ValueType.COLLECTION_COMPLEX);
when(propertyAddress.getName()).thenReturn("Address");
when(propertyAddress.getValue()).thenReturn(odataComment);
odataProperties.add(propertyAddress);
final Map<String, Object> act = cut.convertProperties(OData.newInstance(), st, odataProperties);
assertNotNull(act.get("address"));
assertEquals(2, ((List<Map<String, Object>>) act.get("address")).size());
final Map<String, Object> actAddr1 = (Map<String, Object>) ((List<?>) act.get("address")).get(0);
assertEquals(32, actAddr1.get("number"));
final Map<String, Object> actAddr2 = (Map<String, Object>) ((List<?>) act.get("address")).get(1);
assertEquals(16, actAddr2.get("number"));
}
@Test
void testConvertPropertiesTwoSimpleCollectionProperty() throws ODataJPAProcessException,
ODataJPAModelException {
final List<Property> odataProperties = new ArrayList<>();
final List<String> odataComment = new ArrayList<>();
final JPAStructuredType st = createMetadataForSimpleProperty(COMMENT_EXT_PROPERTY_NAME, COMMENT_INT_PROPERTY_NAME);
odataComment.add("First Test");
odataComment.add("Second Test");
final Property propertyComment = mock(Property.class);
when(propertyComment.getValueType()).thenReturn(ValueType.COLLECTION_PRIMITIVE);
when(propertyComment.getName()).thenReturn(COMMENT_EXT_PROPERTY_NAME);
when(propertyComment.getValue()).thenReturn(odataComment);
odataProperties.add(propertyComment);
final Map<String, Object> act = cut.convertProperties(OData.newInstance(), st, odataProperties);
assertNotNull(act.get(COMMENT_INT_PROPERTY_NAME));
assertEquals(2, ((List<?>) act.get(COMMENT_INT_PROPERTY_NAME)).size());
assertEquals("First Test", ((List<?>) act.get(COMMENT_INT_PROPERTY_NAME)).get(0));
assertEquals("Second Test", ((List<?>) act.get(COMMENT_INT_PROPERTY_NAME)).get(1));
}
@Test
void testConvertPropertiesUnknownValueType() {
final List<Property> odataProperties = new ArrayList<>();
final JPAStructuredType st = mock(JPAStructuredType.class);
final Property propertyID = mock(Property.class);
when(propertyID.getValueType()).thenReturn(ValueType.COLLECTION_ENTITY);
when(propertyID.getName()).thenReturn("ID");
when(propertyID.getValue()).thenReturn("35");
odataProperties.add(propertyID);
try {
cut.convertProperties(OData.newInstance(), st, odataProperties);
} catch (final ODataJPAProcessException e) {
assertEquals(HttpStatusCode.NOT_IMPLEMENTED.getStatusCode(), e.getStatusCode());
return;
}
fail();
}
@Disabled("Different Instances")
@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/src/test/java/com/sap/olingo/jpa/processor/core/modify/JPAConversionHelperTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/modify/JPAConversionHelperTest.java | package com.sap.olingo.jpa.processor.core.modify;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.fail;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.List;
import org.apache.olingo.commons.api.data.Entity;
import org.apache.olingo.commons.api.data.Property;
import org.apache.olingo.commons.api.edm.Edm;
import org.apache.olingo.commons.api.edm.EdmEntitySet;
import org.apache.olingo.commons.api.edm.EdmEntityType;
import org.apache.olingo.commons.api.edm.EdmStructuredType;
import org.apache.olingo.server.api.OData;
import org.apache.olingo.server.api.ODataRequest;
import org.apache.olingo.server.api.deserializer.DeserializerException;
import org.apache.olingo.server.api.serializer.SerializerException;
import org.apache.olingo.server.api.uri.UriHelper;
import org.apache.olingo.server.api.uri.UriParameter;
import org.apache.olingo.server.api.uri.UriResourceEntitySet;
import org.apache.olingo.server.api.uri.queryoption.ExpandOption;
import org.apache.olingo.server.api.uri.queryoption.SelectOption;
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.api.JPAPath;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAStructuredType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.processor.core.exception.ODataJPAProcessorException;
abstract class JPAConversionHelperTest {
protected JPAConversionHelper cut;
protected EdmEntitySet edmEntitySet;
protected ODataRequest request;
protected OData odata;
protected JPAEntityType et;
public JPAConversionHelperTest() {
super();
}
@Test
abstract void testConvertCompoundKeyToLocation() throws ODataJPAProcessorException, SerializerException,
ODataJPAModelException;
@Test
abstract void testConvertEmbeddedIdToLocation() throws ODataJPAProcessorException, SerializerException,
ODataJPAModelException;
@Test
abstract void testConvertSimpleKeyToLocation() throws ODataJPAProcessorException, SerializerException,
ODataJPAModelException;
protected void prepareConvertCompoundKeyToLocation() throws ODataJPAModelException {
final List<JPAPath> keyPath = new ArrayList<>();
request = mock(ODataRequest.class);
et = mock(JPAEntityType.class);
when(request.getRawBaseUri()).thenReturn("localhost.test");
when(et.getKeyPath()).thenReturn(keyPath);
edmEntitySet = mock(EdmEntitySet.class);
addKeyAttribute(keyPath, "BusinessPartnerID", "businessPartnerID");
addKeyAttribute(keyPath, "RoleCategory", "roleCategory");
odata = mock(OData.class);
UriHelper uriHelper = new UriHelperSpy(UriHelperSpy.COMPOUND_KEY);
when(odata.createUriHelper()).thenReturn(uriHelper);
}
protected void prepareConvertSimpleKeyToLocation() throws ODataJPAModelException {
final List<JPAPath> keyPath = new ArrayList<>();
request = mock(ODataRequest.class);
et = mock(JPAEntityType.class);
when(request.getRawBaseUri()).thenReturn("localhost.test");
edmEntitySet = mock(EdmEntitySet.class);
when(et.getKeyPath()).thenReturn(keyPath);
addKeyAttribute(keyPath, "ID", "iD");
odata = mock(OData.class);
UriHelper uriHelper = new UriHelperSpy(UriHelperSpy.SINGLE);
when(odata.createUriHelper()).thenReturn(uriHelper);
}
void addKeyAttribute(final List<JPAPath> keyPath, final String externalName, final String internalName) {
JPAPath key;
JPAAttribute keyAttribute;
key = mock(JPAPath.class);
keyPath.add(key);
keyAttribute = mock(JPAAttribute.class);
when(keyAttribute.getExternalName()).thenReturn(externalName);
when(keyAttribute.getInternalName()).thenReturn(internalName);
when(key.getLeaf()).thenReturn(keyAttribute);
}
protected void prepareConvertEmbeddedIdToLocation() throws ODataJPAModelException {
List<JPAPath> keyPath = new ArrayList<>();
request = mock(ODataRequest.class);
when(request.getRawBaseUri()).thenReturn("localhost.test");
edmEntitySet = mock(EdmEntitySet.class);
et = mock(JPAEntityType.class);
when(et.getKeyPath()).thenReturn(keyPath);
JPAPath key = mock(JPAPath.class);
keyPath.add(key);
JPAAttribute keyAttribute = mock(JPAAttribute.class);
when(keyAttribute.getExternalName()).thenReturn("Key");
when(keyAttribute.getInternalName()).thenReturn("key");
when(keyAttribute.isComplex()).thenReturn(true);
when(keyAttribute.isKey()).thenReturn(true);
when(key.getLeaf()).thenReturn(keyAttribute);
JPAStructuredType st = mock(JPAStructuredType.class);
when(keyAttribute.getStructuredType()).thenReturn(st);
keyPath = new ArrayList<>();
when(st.getPathList()).thenReturn(keyPath);
addKeyAttribute(keyPath, "CodeID", "codeID");
addKeyAttribute(keyPath, "CodePublisher", "codePublisher");
addKeyAttribute(keyPath, "DivisionCode", "divisionCode");
addKeyAttribute(keyPath, "Language", "language");
odata = mock(OData.class);
UriHelper uriHelper = new UriHelperSpy(UriHelperSpy.EMBEDDED_ID);
when(odata.createUriHelper()).thenReturn(uriHelper);
}
class UriHelperSpy implements UriHelper {
public static final String EMBEDDED_ID = "EmbeddedId";
public static final String COMPOUND_KEY = "CompoundKey";
public static final String SINGLE = "SingleID";
private final String mode;
public UriHelperSpy(String mode) {
this.mode = mode;
}
@Override
public String buildCanonicalURL(EdmEntitySet edmEntitySet, Entity entity) throws SerializerException {
if (mode.equals(EMBEDDED_ID)) {
assertEquals(4, entity.getProperties().size());
int found = 0;
for (final Property property : entity.getProperties()) {
if (property.getName().equals("DivisionCode") && property.getValue().equals("BE1"))
found++;
else if (property.getName().equals("Language") && property.getValue().equals("fr"))
found++;
}
assertEquals(2, found, "Not all key attributes found");
return "AdministrativeDivisionDescriptions(DivisionCode='BE1',CodeID='NUTS1',CodePublisher='Eurostat',Language='fr')";
} else if (mode.equals(COMPOUND_KEY)) {
assertEquals(2, entity.getProperties().size());
int found = 0;
for (final Property property : entity.getProperties()) {
if (property.getName().equals("BusinessPartnerID") && property.getValue().equals("35"))
found++;
else if (property.getName().equals("RoleCategory") && property.getValue().equals("A"))
found++;
}
assertEquals(2, found, "Not all key attributes found");
return "BusinessPartnerRoles(BusinessPartnerID='35',RoleCategory='A')";
} else if (mode.equals(SINGLE)) {
assertEquals(1, entity.getProperties().size());
assertEquals("35", entity.getProperties().get(0).getValue());
return "Organisation('35')";
}
fail();
return null;
}
@Override
public String buildContextURLKeyPredicate(List<UriParameter> keys) throws SerializerException {
fail();
return null;
}
@Override
public String buildContextURLSelectList(EdmStructuredType type, ExpandOption expand, SelectOption select)
throws SerializerException {
fail();
return null;
}
@Override
public String buildKeyPredicate(EdmEntityType edmEntityType, Entity entity) throws SerializerException {
fail();
return null;
}
@Override
public UriResourceEntitySet parseEntityId(Edm edm, String entityId, String rawServiceRoot)
throws DeserializerException {
fail();
return 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/src/test/java/com/sap/olingo/jpa/processor/core/modify/JPACreateResultTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/modify/JPACreateResultTest.java | package com.sap.olingo.jpa.processor.core.modify;
import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
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.assertTrue;
import static org.mockito.Mockito.mock;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import jakarta.persistence.Tuple;
import jakarta.persistence.TupleElement;
import org.apache.olingo.commons.api.data.ComplexValue;
import org.apache.olingo.server.api.OData;
import org.apache.olingo.server.api.ODataApplicationException;
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.api.JPAEntityType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.processor.core.api.JPAODataRequestContext;
import com.sap.olingo.jpa.processor.core.api.JPAODataRequestContextAccess;
import com.sap.olingo.jpa.processor.core.api.JPAODataSessionContextAccess;
import com.sap.olingo.jpa.processor.core.converter.JPACollectionResult;
import com.sap.olingo.jpa.processor.core.converter.JPAExpandResult;
import com.sap.olingo.jpa.processor.core.converter.JPATupleChildConverter;
import com.sap.olingo.jpa.processor.core.processor.JPAODataInternalRequestContext;
import com.sap.olingo.jpa.processor.core.util.ServiceMetadataDouble;
import com.sap.olingo.jpa.processor.core.util.TestBase;
abstract class JPACreateResultTest extends TestBase {
protected JPAExpandResult cut;
protected JPAEntityType et;
protected Object jpaEntity;
protected JPATupleChildConverter converter;
protected JPAODataRequestContextAccess requestContext;
protected JPAODataRequestContext context;
protected JPAODataSessionContextAccess sessionContext;
protected OData odata;
JPACreateResultTest() {
super();
context = mock(JPAODataRequestContext.class);
sessionContext = mock(JPAODataSessionContextAccess.class);
odata = mock(OData.class);
requestContext = new JPAODataInternalRequestContext(context, sessionContext, odata);
}
@Test
void testGetChildrenProvidesEmptyMap() throws ODataJPAModelException, ODataApplicationException {
converter = new JPATupleChildConverter(helper.sd, OData.newInstance()
.createUriHelper(), new ServiceMetadataDouble(nameBuilder, "Organizations"), requestContext);
createCutProvidesEmptyMap();
final Map<JPAAssociationPath, JPAExpandResult> act = cut.getChildren();
assertNotNull(act);
assertEquals(1, act.size());
}
@Test
void testGetResultSimpleEntity() throws ODataJPAModelException, ODataApplicationException {
et = helper.getJPAEntityType("BusinessPartnerRoles");
createCutGetResultSimpleEntity();
final List<Tuple> act = cut.getResult("root");
assertNotNull(act);
assertEquals(1, act.size());
assertEquals("34", act.get(0).get("BusinessPartnerID"));
}
@Test
void testGetResultEntityWithTransient() throws ODataJPAModelException, ODataApplicationException {
et = helper.getJPAEntityType("Persons");
createCutGetResultEntityWithTransient();
final List<Tuple> act = cut.getResult("root");
assertNotNull(act);
assertEquals(1, act.size());
assertEquals("Hubert, Hans", act.get(0).get("FullName"));
}
@Test
void testGetResultWithOneLevelEmbedded() throws ODataJPAModelException, ODataApplicationException {
et = helper.getJPAEntityType("AdministrativeDivisionDescriptions");
createCutGetResultWithOneLevelEmbedded();
final List<Tuple> act = cut.getResult("root");
assertNotNull(act);
assertEquals(1, act.size());
assertEquals("A", act.get(0).get("CodeID"));
assertEquals("Hugo", act.get(0).get("Name"));
}
@Test
void testGetResultWithTwoLevelEmbedded() throws ODataJPAModelException, ODataApplicationException {
createCutGetResultWithTwoLevelEmbedded();
final List<Tuple> act = cut.getResult("root");
assertNotNull(act);
assertEquals(1, act.size());
assertEquals("01", act.get(0).get("ID"));
assertEquals("99", act.get(0).get("AdministrativeInformation/Created/By"));
}
@Test
void testGetResultWithOneLinked() throws ODataJPAModelException, ODataApplicationException {
createCutGetResultWithWithOneLinked();
final Map<JPAAssociationPath, JPAExpandResult> act = cut.getChildren();
assertNotNull(act);
assertEquals(1, act.size());
for (final JPAAssociationPath actPath : act.keySet()) {
assertEquals("Children", actPath.getAlias());
final List<Tuple> subResult = act.get(actPath).getResult("Eurostat/NUTS1/BE2");
assertEquals(1, subResult.size());
assertEquals("BE21", subResult.get(0).get("DivisionCode"));
}
}
@Test
void testGetResultWithDescriptionProperty() throws ODataJPAModelException, ODataApplicationException {
createCutGetResultWithDescriptionProperty();
final List<Tuple> act = cut.getResult("root");
assertEquals(1, act.size());
final Tuple actResult = act.get(0);
assertEquals(7L, actResult.get("ETag"));
assertEquals("MyDivision", actResult.get("LocationName"));
}
@Test
void testGetResultWithTwoLinked() throws ODataJPAModelException, ODataApplicationException {
createCutGetResultWithWithTwoLinked();
final Map<JPAAssociationPath, JPAExpandResult> act = cut.getChildren();
assertNotNull(act);
assertEquals(1, act.size());
for (final JPAAssociationPath actPath : act.keySet()) {
assertEquals("Children", actPath.getAlias());
final List<Tuple> subResult = act.get(actPath).getResult("Eurostat/NUTS1/BE2");
assertEquals(2, subResult.size());
}
}
@Test
void testGetResultWithPrimitiveCollection() throws ODataJPAModelException, ODataApplicationException {
createCutGetResultEntityWithSimpleCollection();
final Map<JPAAssociationPath, JPAExpandResult> act = cut.getChildren();
assertDoesNotContain(cut.getResult("root"), "Comment");
assertNotNull(act);
assertFalse(act.isEmpty());
for (final Entry<JPAAssociationPath, JPAExpandResult> entity : act.entrySet()) {
assertEquals(1, entity.getValue().getResults().size());
assertEquals("Comment", entity.getKey().getAlias());
final Collection<Object> actConverted = ((JPACollectionResult) entity.getValue()).getPropertyCollection(
JPAExpandResult.ROOT_RESULT_KEY);
assertEquals(2, actConverted.size());
for (final Object o : actConverted) {
assertNotNull(o);
assertFalse(((String) o).isEmpty());
}
}
}
@Test
void testGetResultWithComplexCollection() throws ODataJPAModelException, ODataApplicationException {
createCutGetResultEntityWithComplexCollection();
final Map<JPAAssociationPath, JPAExpandResult> act = cut.getChildren();
assertDoesNotContain(cut.getResult("root"), "InhouseAddress");
assertNotNull(act);
assertFalse(act.isEmpty());
for (final Entry<JPAAssociationPath, JPAExpandResult> entity : act.entrySet()) {
assertEquals(1, entity.getValue().getResults().size());
assertEquals("InhouseAddress", entity.getKey().getAlias());
final Collection<Object> actConverted = ((JPACollectionResult) entity.getValue()).getPropertyCollection(
JPAExpandResult.ROOT_RESULT_KEY);
assertEquals(2, actConverted.size());
for (final Object o : actConverted) {
assertNotNull(o);
assertFalse(((ComplexValue) o).getValue().isEmpty());
}
}
}
@Test
void testGetResultWithComplexContainingCollection() throws ODataJPAModelException, ODataApplicationException {
createCutGetResultEntityWithComplexWithCollection();
final Map<JPAAssociationPath, JPAExpandResult> act = cut.getChildren();
boolean found = false;
assertDoesNotContain(cut.getResult("root"), "Complex/Address");
assertNotNull(act);
assertFalse(act.isEmpty());
for (final Entry<JPAAssociationPath, JPAExpandResult> entity : act.entrySet()) {
if (entity.getKey().getAlias().equals("Complex/Address")) {
found = true;
assertEquals(1, entity.getValue().getResults().size());
assertEquals("Complex/Address", entity.getKey().getAlias());
final Collection<Object> actConverted = ((JPACollectionResult) entity.getValue()).getPropertyCollection(
JPAExpandResult.ROOT_RESULT_KEY);
assertEquals(2, actConverted.size());
for (final Object o : actConverted) {
assertNotNull(o);
assertFalse(((ComplexValue) o).getValue().isEmpty());
}
}
}
assertTrue(found);
}
@Test
void testGetResultWithContainingNestedComplexCollection() throws ODataJPAModelException,
ODataApplicationException {
createCutGetResultEntityWithNestedComplexCollection();
final Map<JPAAssociationPath, JPAExpandResult> act = cut.getChildren();
boolean found = false;
assertDoesNotContain(cut.getResult("root"), "Nested");
assertNotNull(act);
assertFalse(act.isEmpty());
for (final Entry<JPAAssociationPath, JPAExpandResult> entity : act.entrySet()) {
if (entity.getKey().getAlias().equals("Nested")) {
found = true;
assertEquals(1, entity.getValue().getResults().size());
assertEquals("Nested", entity.getKey().getAlias());
final Collection<Object> actConverted = ((JPACollectionResult) entity.getValue()).getPropertyCollection(
JPAExpandResult.ROOT_RESULT_KEY);
assertEquals(2, actConverted.size());
for (final Object o : actConverted) {
assertNotNull(o);
assertFalse(((ComplexValue) o).getValue().isEmpty());
}
}
}
assertTrue(found);
}
@Test
void testGetResultWithDeepComplexContainingCollection() throws ODataJPAModelException,
ODataApplicationException {
createCutGetResultEntityWithDeepComplexWithCollection();
final Map<JPAAssociationPath, JPAExpandResult> act = cut.getChildren();
boolean found = false;
assertDoesNotContain(cut.getResult("root"), "FirstLevel/SecondLevel/Address");
assertNotNull(act);
assertFalse(act.isEmpty());
for (final Entry<JPAAssociationPath, JPAExpandResult> entity : act.entrySet()) {
if (entity.getKey().getAlias().equals("FirstLevel/SecondLevel/Address")) {
found = true;
assertEquals(1, entity.getValue().getResults().size());
assertEquals("FirstLevel/SecondLevel/Address", entity.getKey().getAlias());
final Collection<Object> actConverted = ((JPACollectionResult) entity.getValue()).getPropertyCollection(
JPAExpandResult.ROOT_RESULT_KEY);
assertEquals(2, actConverted.size());
for (final Object o : actConverted) {
assertNotNull(o);
assertFalse(((ComplexValue) o).getValue().isEmpty());
}
}
}
assertTrue(found);
}
@Test
void testHasCountReturns() throws ODataJPAModelException, ODataApplicationException {
createCutProvidesEmptyMap();
assertFalse(cut.hasCount());
}
@Test
void testConvertNoException() throws ODataJPAModelException, ODataApplicationException {
createCutProvidesEmptyMap();
assertDoesNotThrow(() -> cut.convert(converter));
}
@Test
void testGetRequestedSelectionReturnsEmptyList() throws ODataJPAModelException, ODataApplicationException {
createCutProvidesEmptyMap();
assertEquals(List.of(), cut.getRequestedSelection());
}
@Test
void testGetSkipTokenReturnsNull() throws ODataJPAModelException, ODataApplicationException {
createCutProvidesEmptyMap();
assertNull(cut.getSkipToken(List.of()));
}
@Test
void testRemoveResultProvidesNullOnSecondCall() throws ODataJPAModelException, ODataApplicationException {
createCutGetResultSimpleEntity();
assertNotNull(cut.removeResult("root"));
assertNull(cut.removeResult("root"));
}
private void assertDoesNotContain(final List<Tuple> result, final String prefix) {
for (final Tuple t : result) {
for (final TupleElement<?> e : t.getElements())
assertFalse(e.getAlias().startsWith(prefix), e.getAlias() + " violates prefix check: " + prefix);
}
}
protected abstract void createCutProvidesEmptyMap() throws ODataJPAModelException, ODataApplicationException;
protected abstract void createCutGetResultEntityWithDeepComplexWithCollection() throws ODataJPAModelException,
ODataApplicationException;
protected abstract void createCutGetResultEntityWithNestedComplexCollection() throws ODataJPAModelException,
ODataApplicationException;
protected abstract void createCutGetResultEntityWithComplexCollection() throws ODataJPAModelException,
ODataApplicationException;
protected abstract void createCutGetResultWithWithTwoLinked() throws ODataJPAModelException,
ODataApplicationException;
protected abstract void createCutGetResultWithWithOneLinked() throws ODataJPAModelException,
ODataApplicationException;
protected abstract void createCutGetResultWithDescriptionProperty() throws ODataJPAModelException,
ODataApplicationException;
protected abstract void createCutGetResultSimpleEntity() throws ODataJPAModelException, ODataApplicationException;
protected abstract void createCutGetResultWithOneLevelEmbedded() throws ODataJPAModelException,
ODataApplicationException;
protected abstract void createCutGetResultWithTwoLevelEmbedded() throws ODataJPAModelException,
ODataApplicationException;
protected abstract void createCutGetResultEntityWithSimpleCollection() throws ODataJPAModelException,
ODataApplicationException;
protected abstract void createCutGetResultEntityWithComplexWithCollection() throws ODataJPAModelException,
ODataApplicationException;
protected abstract void createCutGetResultEntityWithTransient() throws ODataJPAModelException,
ODataApplicationException;
} | 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/src/test/java/com/sap/olingo/jpa/processor/core/converter/JPATupleRowConverterTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/converter/JPATupleRowConverterTest.java | package com.sap.olingo.jpa.processor.core.converter;
import static org.junit.jupiter.api.Assertions.assertEquals;
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.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.List;
import jakarta.persistence.Tuple;
import org.apache.olingo.commons.api.data.Entity;
import org.apache.olingo.commons.api.edm.Edm;
import org.apache.olingo.commons.api.edm.EdmEntityType;
import org.apache.olingo.commons.api.edm.FullQualifiedName;
import org.apache.olingo.commons.api.ex.ODataRuntimeException;
import org.apache.olingo.server.api.ODataApplicationException;
import org.apache.olingo.server.api.ServiceMetadata;
import org.apache.olingo.server.api.serializer.SerializerException;
import org.apache.olingo.server.api.uri.UriHelper;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEntitySet;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEntityType;
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.core.api.JPAODataRequestContextAccess;
import com.sap.olingo.jpa.processor.core.exception.ODataJPAQueryException;
class JPATupleRowConverterTest {
private static final String SET_NAME = "TestSet";
private static final String ENTITY_NAME = "TestEntity";
private static final FullQualifiedName ENTITY_FQN = new FullQualifiedName("Namespace", ENTITY_NAME);
private JPATupleRowConverter cut;
private EdmEntityType edmEntity;
private JPAEntityType jpaEntity;
private JPAEntitySet jpaEntitySet;
private JPAServiceDocument sd;
private UriHelper uriHelper;
private Edm edm;
private ServiceMetadata serviceMetadata;
private JPAODataRequestContextAccess requestContext;
@BeforeEach
void setup() throws ODataApplicationException, ODataJPAModelException {
jpaEntity = mock(JPAEntityType.class);
jpaEntitySet = mock(JPAEntitySet.class);
sd = mock(JPAServiceDocument.class);
uriHelper = mock(UriHelper.class);
edm = mock(Edm.class);
edmEntity = mock(EdmEntityType.class);
serviceMetadata = mock(ServiceMetadata.class);
requestContext = mock(JPAODataRequestContextAccess.class);
when(serviceMetadata.getEdm()).thenReturn(edm);
when(sd.getEntitySet(jpaEntity)).thenReturn(jpaEntitySet);
when(jpaEntitySet.getExternalName()).thenReturn(SET_NAME);
when(jpaEntity.getExternalFQN()).thenReturn(ENTITY_FQN);
when(edm.getEntityType(ENTITY_FQN)).thenReturn(edmEntity);
cut = new JPATupleRowConverter(jpaEntity, sd, uriHelper, serviceMetadata, requestContext);
}
@Test
void testGetResultFromJPAExpandResultReturnsNull() throws ODataApplicationException {
assertNull(cut.getResult(null, List.of()));
}
@Test
void testCreateIdFromEntity() throws SerializerException, URISyntaxException {
final var exp = new URI("TestSet('ABC')");
final var entity = mock(Entity.class);
when(uriHelper.buildKeyPredicate(edmEntity, entity)).thenReturn("'ABC'");
final var act = cut.createId(entity);
assertEquals(exp, act);
}
@Test
void testCreateIdFromEntityRethrowsSerializerException() throws SerializerException {
final var entity = mock(Entity.class);
when(uriHelper.buildKeyPredicate(edmEntity, entity)).thenThrow(SerializerException.class);
assertThrows(ODataRuntimeException.class, () -> cut.createId(entity));
}
@Test
void testCreateIdFromEntityIgnoresIllegalArgumentException() throws SerializerException {
final var entity = mock(Entity.class);
when(uriHelper.buildKeyPredicate(edmEntity, entity)).thenThrow(IllegalArgumentException.class);
assertNull(cut.createId(entity));
}
@Test
void testCreateIdFromEntityRethrowsURISyntaxException() throws SerializerException {
final var entity = mock(Entity.class);
when(uriHelper.buildKeyPredicate(edmEntity, entity)).thenReturn("'A:BC'");
assertThrows(ODataRuntimeException.class, () -> cut.createId(entity));
}
@Test
void testCreateIdFromRow() throws SerializerException, URISyntaxException, ODataApplicationException,
ODataJPAModelException {
final var exp = new URI("TestSet('ABC')");
final Entity odataEntity = new Entity();
final Tuple row = mock(Tuple.class);
when(jpaEntity.getKey()).thenReturn(List.of());
when(uriHelper.buildKeyPredicate(edmEntity, odataEntity)).thenReturn("'ABC'");
cut.createId(jpaEntity, row, odataEntity, new ArrayList<>());
assertEquals(exp, odataEntity.getId());
}
@Test
void testCreateIdFromRowRethrowsException() throws SerializerException, ODataJPAModelException {
final Entity odataEntity = new Entity();
final Tuple row = mock(Tuple.class);
when(jpaEntity.getKey()).thenThrow(ODataJPAModelException.class);
when(uriHelper.buildKeyPredicate(edmEntity, odataEntity)).thenReturn("'ABC'");
final var act = assertThrows(ODataApplicationException.class, () -> cut.createId(jpaEntity, row, odataEntity,
new ArrayList<>()));
assertTrue(act.getCause() instanceof ODataJPAModelException);
}
@Test
void testDetermineSetName() throws ODataJPAQueryException {
assertEquals(SET_NAME, cut.determineSetName(jpaEntity));
}
@Test
void testDetermineSetNameReturnsEmptyStringIfEsNotFoud() throws ODataJPAQueryException, ODataJPAModelException {
when(sd.getEntitySet(jpaEntity)).thenReturn(null);
assertEquals("", cut.determineSetName(jpaEntity));
}
@Test
void testDetermineSetNameRethrowsException() throws ODataJPAModelException {
when(sd.getEntitySet(jpaEntity)).thenThrow(ODataJPAModelException.class);
final var act = assertThrows(ODataJPAQueryException.class, () -> cut.determineSetName(jpaEntity));
assertTrue(act.getCause() instanceof ODataJPAModelException);
}
@Test
void testCreateEtagRethrowsException() throws ODataJPAModelException {
when(jpaEntity.hasEtag()).thenThrow(ODataJPAModelException.class);
final var act = assertThrows(ODataJPAQueryException.class, () -> cut.createEtag(jpaEntity, null, null));
assertTrue(act.getCause() instanceof ODataJPAModelException);
}
} | 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/src/test/java/com/sap/olingo/jpa/processor/core/converter/JPAEntityResultConverterTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/converter/JPAEntityResultConverterTest.java | package com.sap.olingo.jpa.processor.core.converter;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import org.apache.olingo.commons.api.edm.EdmEntityType;
import org.apache.olingo.commons.api.ex.ODataException;
import org.apache.olingo.server.api.OData;
import org.apache.olingo.server.api.ODataApplicationException;
import org.apache.olingo.server.api.serializer.SerializerException;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.processor.core.api.JPAODataEtagHelper;
import com.sap.olingo.jpa.processor.core.serializer.JPAEntityCollectionExtension;
import com.sap.olingo.jpa.processor.core.testmodel.AdministrativeDivision;
import com.sap.olingo.jpa.processor.core.testmodel.Person;
import com.sap.olingo.jpa.processor.core.util.EdmEntityTypeDouble;
import com.sap.olingo.jpa.processor.core.util.TestBase;
import com.sap.olingo.jpa.processor.core.util.TestHelper;
import com.sap.olingo.jpa.processor.core.util.UriHelperDouble;
class JPAEntityResultConverterTest extends TestBase {
public static final int NO_POSTAL_ADDRESS_FIELDS = 8;
public static final int NO_ADMIN_INFO_FIELDS = 2;
private JPAEntityResultConverter cut;
private List<Object> jpaQueryResult;
private UriHelperDouble uriHelper;
private JPAODataEtagHelper etagHelper;
@BeforeEach
void setup() throws ODataException {
helper = new TestHelper(emf, PUNIT_NAME);
etagHelper = mock(JPAODataEtagHelper.class);
jpaQueryResult = new ArrayList<>();
final HashMap<String, String> keyStrings = new HashMap<>();
keyStrings.put("BE21", "DivisionCode='BE21',CodeID='NUTS2',CodePublisher='Eurostat'");
keyStrings.put("BE22", "DivisionCode='BE22',CodeID='NUTS2',CodePublisher='Eurostat'");
uriHelper = new UriHelperDouble();
uriHelper.setKeyPredicates(keyStrings, "DivisionCode");
cut = new JPAEntityResultConverter(uriHelper, helper.sd,
jpaQueryResult, new EdmEntityTypeDouble(nameBuilder, "AdministrativeDivision"), etagHelper);
}
@Test
void checkConvertsEmptyResult() throws ODataApplicationException, SerializerException, URISyntaxException {
assertNotNull(cut.getResult());
}
@Test
void checkConvertsOneResult() throws ODataApplicationException, SerializerException, URISyntaxException {
final AdministrativeDivision division = firstResult();
jpaQueryResult.add(division);
final JPAEntityCollectionExtension act = cut.getResult();
assertEquals(1, act.getEntities().size());
}
@Test
void checkConvertsTwoResult() throws ODataApplicationException, SerializerException, URISyntaxException {
jpaQueryResult.add(firstResult());
jpaQueryResult.add(secondResult());
final JPAEntityCollectionExtension act = cut.getResult();
assertEquals(2, act.getEntities().size());
}
@Test
void checkConvertsOneResultOneElement() throws ODataApplicationException, SerializerException,
URISyntaxException {
final AdministrativeDivision division = firstResult();
jpaQueryResult.add(division);
final JPAEntityCollectionExtension act = cut.getResult();
assertEquals(1, act.getEntities().size());
assertEquals("BE21", act.getEntities().get(0).getProperty("DivisionCode").getValue().toString());
}
@Test
void checkConvertsOneResultMultiElement() throws ODataApplicationException, SerializerException,
URISyntaxException {
final AdministrativeDivision division = firstResult();
jpaQueryResult.add(division);
final JPAEntityCollectionExtension act = cut.getResult();
assertEquals(1, act.getEntities().size());
assertEquals("BE21", act.getEntities().get(0).getProperty("DivisionCode").getValue().toString());
assertEquals("BE2", act.getEntities().get(0).getProperty("ParentDivisionCode").getValue().toString());
assertEquals("0", act.getEntities().get(0).getProperty("Population").getValue().toString());
}
@Test
void testEtagAdded() throws ODataJPAModelException, SerializerException, ODataApplicationException,
URISyntaxException {
final var personEntityType = helper.getJPAEntityType(Person.class);
final var personEdmType = mock(EdmEntityType.class);
when(personEdmType.getNamespace()).thenReturn(personEntityType.getExternalFQN().getNamespace());
when(personEdmType.getName()).thenReturn(personEntityType.getExternalFQN().getName());
final var result = new Person();
result.setID("123");
result.setETag(12);
final List<Person> results = Arrays.asList(result);
when(etagHelper.asEtag(any(), eq(12L))).thenReturn("\"12\"");
cut = new JPAEntityResultConverter(OData.newInstance().createUriHelper(), helper.sd, results, personEdmType,
etagHelper);
final var act = cut.getResult();
assertEquals(1, act.getEntities().size());
assertEquals("\"12\"", act.getEntities().get(0).getETag());
}
AdministrativeDivision firstResult() {
final AdministrativeDivision division = new AdministrativeDivision();
division.setCodePublisher("Eurostat");
division.setCodeID("NUTS2");
division.setDivisionCode("BE21");
division.setCountryCode("BEL");
division.setParentCodeID("NUTS1");
division.setParentDivisionCode("BE2");
division.setAlternativeCode("");
division.setArea(0);
division.setPopulation(0);
return division;
}
private Object secondResult() {
final AdministrativeDivision division = new AdministrativeDivision();
division.setCodePublisher("Eurostat");
division.setCodeID("NUTS2");
division.setDivisionCode("BE22");
division.setCountryCode("BEL");
division.setParentCodeID("NUTS1");
division.setParentDivisionCode("BE2");
division.setAlternativeCode("");
division.setArea(0);
division.setPopulation(0);
return division;
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/serializer/TestJPASerializeEntityCollection.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/serializer/TestJPASerializeEntityCollection.java | package com.sap.olingo.jpa.processor.core.serializer;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.List;
import org.apache.olingo.commons.api.edm.EdmType;
import org.apache.olingo.commons.api.format.ContentType;
import org.apache.olingo.server.api.serializer.ODataSerializer;
import org.apache.olingo.server.api.serializer.SerializerException;
import org.apache.olingo.server.api.uri.UriResource;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.processor.core.exception.ODataJPASerializerException;
import com.sap.olingo.jpa.processor.core.util.matcher.EntityCollectionSerializerOptionsMatcher;
public class TestJPASerializeEntityCollection extends TestJPAOperationSerializer {
@Override
@Test
public void testRequestContextUrlFilledForAbsoluteRequestedWithOutSlash() throws SerializerException,
ODataJPASerializerException {
when(context.useAbsoluteContextURL()).thenReturn(true);
when(request.getRawBaseUri()).thenReturn("localhost:8080/v1");
cut.serialize(request, (JPAEntityCollectionExtension) result);
verify(serializer).entityCollection(any(), any(), any(), argThat(new EntityCollectionSerializerOptionsMatcher(
"localhost:8080/v1/")));
}
@SuppressWarnings("unchecked")
@Override
protected EntityCollectionSerializerOptionsMatcher createMatcher(final String pattern) {
return new EntityCollectionSerializerOptionsMatcher(pattern);
}
@Override
protected EdmType getType() {
return edmEt;
}
@Override
protected void initTest(final List<UriResource> resourceParts) {
annotatable = mock(JPAEntityCollection.class);
cut = new JPASerializeEntityCollection(serviceMetadata, serializer, uriHelper, uriInfo,
ContentType.APPLICATION_JSON, context);
}
@Override
protected <T> void verifySerializerCall(final ODataSerializer serializer, final String pattern)
throws SerializerException {
verify(serializer).entityCollection(any(), any(), any(), argThat(createMatcher(pattern)));
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/serializer/TestJPASerializeEntity.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/serializer/TestJPASerializeEntity.java | package com.sap.olingo.jpa.processor.core.serializer;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.apache.olingo.commons.api.data.Entity;
import org.apache.olingo.commons.api.edm.EdmType;
import org.apache.olingo.commons.api.format.ContentType;
import org.apache.olingo.server.api.serializer.ODataSerializer;
import org.apache.olingo.server.api.serializer.SerializerException;
import org.apache.olingo.server.api.uri.UriResource;
import com.sap.olingo.jpa.processor.core.util.matcher.EntitySerializerOptionsMatcher;
public class TestJPASerializeEntity extends TestJPAOperationSerializer {
@SuppressWarnings("unchecked")
@Override
protected EntitySerializerOptionsMatcher createMatcher(final String pattern) {
return new EntitySerializerOptionsMatcher(pattern);
}
@Override
protected EdmType getType() {
return edmEt;
}
@Override
protected void initTest(final List<UriResource> resourceParts) {
annotatable = mock(JPAEntityCollection.class);
final Entity resultEntity = mock(Entity.class);
final List<Entity> resultEntities = new ArrayList<>();
resultEntities.add(resultEntity);
when(resultEntity.getProperties()).thenReturn(Collections.emptyList());
when(result.getEntities()).thenReturn(resultEntities);
when(((JPAEntityCollectionExtension) result).getFirstResult()).thenReturn(resultEntity);
when(((JPAEntityCollection) annotatable).getEntities()).thenReturn(resultEntities);
cut = new JPASerializeEntity(serviceMetadata, serializer, uriHelper, uriInfo, ContentType.APPLICATION_JSON,
context);
}
@Override
protected void verifySerializerCall(final ODataSerializer serializer, final String pattern)
throws SerializerException {
verify(serializer).entity(any(), any(), any(), argThat(createMatcher(pattern)));
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/serializer/TestJPASerializeCreate.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/serializer/TestJPASerializeCreate.java | package com.sap.olingo.jpa.processor.core.serializer;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.apache.olingo.commons.api.data.Entity;
import org.apache.olingo.server.api.serializer.ODataSerializer;
import org.apache.olingo.server.api.serializer.SerializerException;
import org.apache.olingo.server.api.uri.UriResource;
import com.sap.olingo.jpa.processor.core.util.matcher.EntitySerializerOptionsMatcher;
public class TestJPASerializeCreate extends TestJPASerializer {
@SuppressWarnings("unchecked")
@Override
protected EntitySerializerOptionsMatcher createMatcher(final String pattern) {
return new EntitySerializerOptionsMatcher(pattern);
}
@Override
protected void initTest(final List<UriResource> resourceParts) {
final Entity resultEntity = mock(Entity.class);
final List<Entity> resultEntities = new ArrayList<>();
resultEntities.add(resultEntity);
when(resultEntity.getProperties()).thenReturn(Collections.emptyList());
when(result.getEntities()).thenReturn(resultEntities);
cut = new JPASerializeCreate(serviceMetadata, serializer, uriInfo, context);
}
@Override
protected <T> void verifySerializerCall(final ODataSerializer serializer, final String pattern)
throws SerializerException {
verify(serializer).entity(any(), any(), any(), argThat(createMatcher(pattern)));
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/serializer/TestJPASerializePrimitive.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/serializer/TestJPASerializePrimitive.java | package com.sap.olingo.jpa.processor.core.serializer;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.apache.olingo.commons.api.data.Entity;
import org.apache.olingo.commons.api.data.Property;
import org.apache.olingo.commons.api.edm.EdmPrimitiveType;
import org.apache.olingo.commons.api.edm.EdmProperty;
import org.apache.olingo.commons.api.edm.EdmType;
import org.apache.olingo.commons.api.format.ContentType;
import org.apache.olingo.server.api.serializer.ODataSerializer;
import org.apache.olingo.server.api.serializer.SerializerException;
import org.apache.olingo.server.api.uri.UriResource;
import org.apache.olingo.server.api.uri.UriResourceKind;
import org.apache.olingo.server.api.uri.UriResourcePrimitiveProperty;
import com.sap.olingo.jpa.processor.core.util.matcher.PrimitiveSerializerOptionsMatcher;
public class TestJPASerializePrimitive extends TestJPAOperationSerializer {
private EdmPrimitiveType edmPT;
@SuppressWarnings("unchecked")
@Override
protected PrimitiveSerializerOptionsMatcher createMatcher(final String pattern) {
return new PrimitiveSerializerOptionsMatcher(pattern);
}
@Override
protected EdmType getType() {
return edmPT;
}
@Override
protected void initTest(final List<UriResource> resourceParts) {
annotatable = mock(Property.class);
edmPT = mock(EdmPrimitiveType.class);
final UriResourcePrimitiveProperty uriPT = mock(UriResourcePrimitiveProperty.class);
final EdmProperty edmProperty = mock(EdmProperty.class);
when(uriPT.getProperty()).thenReturn(edmProperty);
when(uriPT.getKind()).thenReturn(UriResourceKind.primitiveProperty);
when(edmProperty.getName()).thenReturn("name1");
when(edmProperty.isCollection()).thenReturn(false);
resourceParts.add(uriPT);
final Entity resultEntity = mock(Entity.class);
final List<Entity> resultEntities = new ArrayList<>();
resultEntities.add(resultEntity);
when(resultEntity.getProperties()).thenReturn(Collections.emptyList());
when(result.getEntities()).thenReturn(resultEntities);
when(((JPAEntityCollectionExtension) result).getFirstResult()).thenReturn(resultEntity);
cut = new JPASerializePrimitive(serviceMetadata, serializer, uriInfo, ContentType.APPLICATION_JSON, context);
}
@Override
protected void verifySerializerCall(final ODataSerializer serializer, final String pattern)
throws SerializerException {
verify(serializer).primitive(any(), any(), any(), argThat(createMatcher(pattern)));
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/serializer/TestJPASerializerPrimitiveCollection.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/serializer/TestJPASerializerPrimitiveCollection.java | package com.sap.olingo.jpa.processor.core.serializer;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.Mockito.verify;
import java.util.List;
import org.apache.olingo.commons.api.edm.EdmType;
import org.apache.olingo.commons.api.format.ContentType;
import org.apache.olingo.server.api.serializer.ODataSerializer;
import org.apache.olingo.server.api.serializer.SerializerException;
import org.apache.olingo.server.api.uri.UriResource;
import com.sap.olingo.jpa.processor.core.util.matcher.PrimitiveSerializerOptionsMatcher;
public class TestJPASerializerPrimitiveCollection extends TestJPASerializerCollection {
@SuppressWarnings("unchecked")
@Override
protected PrimitiveSerializerOptionsMatcher createMatcher(final String pattern) {
return new PrimitiveSerializerOptionsMatcher(pattern);
}
@Override
protected EdmType getType() {
return null;
}
@Override
protected void initTest(final List<UriResource> resourceParts) {
cut = new JPASerializePrimitiveCollection(serviceMetadata, serializer, ContentType.APPLICATION_JSON, context);
}
@Override
protected <T> void verifySerializerCall(final ODataSerializer serializer, final String pattern)
throws SerializerException {
verify(serializer).primitiveCollection(any(), any(), any(), argThat(createMatcher(pattern)));
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/serializer/JPAEntityCollectionLazyTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/serializer/JPAEntityCollectionLazyTest.java | package com.sap.olingo.jpa.processor.core.serializer;
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.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.List;
import java.util.NoSuchElementException;
import jakarta.persistence.Tuple;
import org.apache.olingo.commons.api.data.Entity;
import org.apache.olingo.server.api.ODataApplicationException;
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.core.converter.JPAExpandResult;
import com.sap.olingo.jpa.processor.core.converter.JPARowConverter;
class JPAEntityCollectionLazyTest {
private JPAEntityCollectionLazy cut;
private JPAExpandResult result;
private JPARowConverter converter;
private JPAEntityType jpaEntity;
private List<Tuple> resultItems;
private Tuple resultItem;
@BeforeEach
void setup() {
resultItems = new ArrayList<>();
resultItem = mock(Tuple.class);
result = mock(JPAExpandResult.class);
converter = mock(JPARowConverter.class);
jpaEntity = mock(JPAEntityType.class);
resultItems.add(resultItem);
when(result.getEntityType()).thenReturn(jpaEntity);
when(result.getResult(JPAExpandResult.ROOT_RESULT_KEY)).thenReturn(resultItems);
cut = new JPAEntityCollectionLazy(result, converter);
}
@Test
void testHashCodeReturnsValue() {
cut.setCount(100);
assertNotEquals(0, cut.hashCode());
}
@Test
void testEqualsTrueForSameInstance() {
cut.setCount(100);
assertEquals(cut, cut);
}
@Test
void testGetEntitiesReturnsEmptyList() {
assertEquals(0, cut.getEntities().size());
}
@Test
void testGetFirstResultThrowsExceptionIfConverterThrowsException() throws ODataApplicationException {
when(converter.convertRow(eq(jpaEntity), any(), any(), any(), eq(result))).thenThrow(
ODataApplicationException.class);
final var act = assertThrows(IllegalStateException.class, () -> cut.getFirstResult());
assertTrue(act.getCause() instanceof ODataApplicationException);
}
@Test
void testIteratorThrowsExceptionOnTooManyNext() throws ODataApplicationException {
final Entity odataEntity = mock(Entity.class);
when(converter.convertRow(eq(jpaEntity), any(), any(), any(), eq(result)))
.thenReturn(odataEntity);
final var iterator = cut.iterator();
assertEquals(odataEntity, iterator.next());
assertThrows(NoSuchElementException.class, iterator::next);
}
@Test
void testIteratorReThrowsConverterException() throws ODataApplicationException {
final Entity odataEntity = mock(Entity.class);
final var secondItem = mock(Tuple.class);
resultItems.add(secondItem);
when(converter.convertRow(eq(jpaEntity), eq(resultItem), any(), any(), eq(result)))
.thenReturn(odataEntity);
when(converter.convertRow(eq(jpaEntity), eq(secondItem), any(), any(), eq(result)))
.thenThrow(ODataApplicationException.class);
final var iterator = cut.iterator();
assertEquals(odataEntity, iterator.next());
assertThrows(IllegalStateException.class, iterator::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-processor/src/test/java/com/sap/olingo/jpa/processor/core/serializer/TestJPASerializer.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/serializer/TestJPASerializer.java | package com.sap.olingo.jpa.processor.core.serializer;
import static org.junit.jupiter.api.Assertions.assertNotNull;
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 org.apache.olingo.commons.api.data.Annotatable;
import org.apache.olingo.commons.api.data.EntityCollection;
import org.apache.olingo.commons.api.edm.EdmEntitySet;
import org.apache.olingo.commons.api.edm.EdmEntityType;
import org.apache.olingo.commons.api.edm.FullQualifiedName;
import org.apache.olingo.server.api.ODataRequest;
import org.apache.olingo.server.api.ServiceMetadata;
import org.apache.olingo.server.api.serializer.ODataSerializer;
import org.apache.olingo.server.api.serializer.SerializerException;
import org.apache.olingo.server.api.uri.UriHelper;
import org.apache.olingo.server.api.uri.UriInfo;
import org.apache.olingo.server.api.uri.UriParameter;
import org.apache.olingo.server.api.uri.UriResource;
import org.apache.olingo.server.api.uri.UriResourceEntitySet;
import org.apache.olingo.server.api.uri.UriResourceKind;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentMatcher;
import com.sap.olingo.jpa.processor.core.api.JPAODataSessionContextAccess;
import com.sap.olingo.jpa.processor.core.exception.ODataJPASerializerException;
public abstract class TestJPASerializer {
protected JPASerializer cut;
protected ServiceMetadata serviceMetadata;
protected ODataSerializer serializer;
protected UriInfo uriInfo;
protected UriHelper uriHelper;
protected ODataRequest request;
protected EntityCollection result;
protected JPAODataSessionContextAccess context;
protected Annotatable annotatable;
protected EdmEntityType edmEt;
protected EdmEntitySet edmEs;
public TestJPASerializer() {
super();
}
@BeforeEach
public void setup() throws SerializerException {
context = mock(JPAODataSessionContextAccess.class);
serviceMetadata = mock(ServiceMetadata.class);
uriInfo = mock(UriInfo.class);
serializer = mock(ODataSerializer.class);
uriHelper = mock(UriHelper.class);
request = mock(ODataRequest.class);
result = mock(EntityCollection.class, withSettings().extraInterfaces(JPAEntityCollectionExtension.class));
edmEt = mock(EdmEntityType.class);
edmEs = mock(EdmEntitySet.class);
annotatable = mock(Annotatable.class, withSettings().extraInterfaces(JPAEntityCollectionExtension.class));
final UriResourceEntitySet uriEs = mock(UriResourceEntitySet.class);
final List<UriParameter> keys = Collections.emptyList();
final List<UriResource> resourceParts = new ArrayList<>();
resourceParts.add(uriEs);
when(uriInfo.getUriResourceParts()).thenReturn(resourceParts);
when(uriEs.getKind()).thenReturn(UriResourceKind.entitySet);
when(uriEs.getEntitySet()).thenReturn(edmEs);
when(uriEs.getKeyPredicates()).thenReturn(keys);
when(uriHelper.buildContextURLSelectList(any(), any(), any())).thenReturn("");
when(edmEs.getEntityType()).thenReturn(edmEt);
when(edmEt.getName()).thenReturn("Person");
when(edmEt.getFullQualifiedName()).thenReturn(new FullQualifiedName("test.Person"));
initTest(resourceParts);
}
@Test
public void testCreateODataSerializerCanBeCreated() {
assertNotNull(cut);
}
@Test
public void testRequestContextUrlFilledForAbsoluteRequested() throws SerializerException,
ODataJPASerializerException {
when(context.useAbsoluteContextURL()).thenReturn(true);
when(request.getRawBaseUri()).thenReturn("localhost:8080/v1/");
cut.serialize(request, (JPAEntityCollectionExtension) result);
verifySerializerCall(serializer, "localhost:8080/v1/");
}
@Test
public void testRequestContextUrlFilledForAbsoluteRequestedWithOutSlash() throws SerializerException,
ODataJPASerializerException {
when(context.useAbsoluteContextURL()).thenReturn(true);
when(request.getRawBaseUri()).thenReturn("localhost:8080/v1");
cut.serialize(request, (JPAEntityCollectionExtension) result);
verifySerializerCall(serializer, "localhost:8080/v1/");
}
@Test
public void testRequestContextUrlNullForRelativeRequested() throws SerializerException,
ODataJPASerializerException {
when(context.useAbsoluteContextURL()).thenReturn(false);
cut.serialize(request, (JPAEntityCollectionExtension) result);
verifySerializerCall(serializer, null);
}
protected abstract <T> ArgumentMatcher<T> createMatcher(final String pattern);
protected abstract void initTest(final List<UriResource> resourceParts);
protected abstract <T> void verifySerializerCall(final ODataSerializer serializer, final String pattern)
throws SerializerException;
} | 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/src/test/java/com/sap/olingo/jpa/processor/core/serializer/TestJPASerializerComplexCollection.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/serializer/TestJPASerializerComplexCollection.java | package com.sap.olingo.jpa.processor.core.serializer;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.Mockito.verify;
import java.util.List;
import org.apache.olingo.commons.api.edm.EdmType;
import org.apache.olingo.commons.api.format.ContentType;
import org.apache.olingo.server.api.serializer.ODataSerializer;
import org.apache.olingo.server.api.serializer.SerializerException;
import org.apache.olingo.server.api.uri.UriResource;
import com.sap.olingo.jpa.processor.core.util.matcher.ComplexSerializerOptionsMatcher;
public class TestJPASerializerComplexCollection extends TestJPASerializerCollection {
@SuppressWarnings("unchecked")
@Override
protected ComplexSerializerOptionsMatcher createMatcher(final String pattern) {
return new ComplexSerializerOptionsMatcher(pattern);
}
@Override
protected EdmType getType() {
return null;
}
@Override
protected void initTest(final List<UriResource> resourceParts) {
cut = new JPASerializeComplexCollection(serviceMetadata, serializer, ContentType.APPLICATION_JSON, context);
}
@Override
protected <T> void verifySerializerCall(final ODataSerializer serializer, final String pattern)
throws SerializerException {
verify(serializer).complexCollection(any(), any(), any(), argThat(createMatcher(pattern)));
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/serializer/TestJPASerializeValue.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/serializer/TestJPASerializeValue.java | package com.sap.olingo.jpa.processor.core.serializer;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.Arrays;
import java.util.List;
import org.apache.olingo.commons.api.data.Entity;
import org.apache.olingo.commons.api.data.Property;
import org.apache.olingo.commons.api.data.ValueType;
import org.apache.olingo.commons.api.edm.EdmPrimitiveType;
import org.apache.olingo.commons.api.edm.EdmProperty;
import org.apache.olingo.server.api.ODataRequest;
import org.apache.olingo.server.api.ServiceMetadata;
import org.apache.olingo.server.api.serializer.FixedFormatSerializer;
import org.apache.olingo.server.api.serializer.SerializerException;
import org.apache.olingo.server.api.serializer.SerializerResult;
import org.apache.olingo.server.api.uri.UriInfo;
import org.apache.olingo.server.api.uri.UriResource;
import org.apache.olingo.server.api.uri.UriResourceComplexProperty;
import org.apache.olingo.server.api.uri.UriResourceEntitySet;
import org.apache.olingo.server.api.uri.UriResourcePrimitiveProperty;
import org.apache.olingo.server.api.uri.UriResourceValue;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.processor.core.exception.ODataJPASerializerException;
class TestJPASerializeValue {
private JPASerializeValue cut;
private ServiceMetadata serviceMetadata;
private FixedFormatSerializer serializer;
private UriInfo uriInfo;
@BeforeEach
void setup() {
serviceMetadata = mock(ServiceMetadata.class);
uriInfo = mock(UriInfo.class);
serializer = mock(FixedFormatSerializer.class);
cut = new JPASerializeValue(serviceMetadata, serializer, uriInfo);
}
@Test
void testDoesNotProvideNullValue() throws SerializerException, ODataJPASerializerException {
final JPAEntityCollectionExtension results = new JPAEntityCollection();
final Entity result = new Entity();
final Property value = new Property();
final ODataRequest request = new ODataRequest();
final EdmPrimitiveType valueODataType = mock(EdmPrimitiveType.class);
final EdmProperty valueODataProperty = mock(EdmProperty.class);
final EdmProperty addrODataProperty = mock(EdmProperty.class);
final UriResourceEntitySet orgOData = mock(UriResourceEntitySet.class);
final UriResourceComplexProperty addrOData = mock(UriResourceComplexProperty.class);
final UriResourcePrimitiveProperty streetOData = mock(UriResourcePrimitiveProperty.class);
final UriResourceValue valueOData = mock(UriResourceValue.class);
final List<UriResource> uriResourceParts = Arrays.asList(orgOData, addrOData, streetOData, valueOData);
when(streetOData.getType()).thenReturn(valueODataType);
when(valueODataProperty.getType()).thenReturn(valueODataType);
when(valueODataProperty.getName()).thenReturn("StreetName");
when(addrODataProperty.getName()).thenReturn("Address");
when(streetOData.getProperty()).thenReturn(valueODataProperty);
when(addrOData.getProperty()).thenReturn(addrODataProperty);
when(uriInfo.getUriResourceParts()).thenReturn(uriResourceParts);
value.setValue(ValueType.PRIMITIVE, null);
value.setName("StreetName");
result.getProperties().add(value);
results.getEntities().add(result);
// [Companies, Address, StreetName, $value]
// result.getEntities().get(0).getProperties()
// final EdmPrimitiveType edmPropertyType = (EdmPrimitiveType) uriProperty.getProperty().getType();
final SerializerResult act = cut.serialize(request, results);
assertNotNull(act);
verify(serializer, times(0)).primitiveValue(eq(valueODataType), isNull(), any());
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/serializer/TestJPASerializerCollection.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/serializer/TestJPASerializerCollection.java | package com.sap.olingo.jpa.processor.core.serializer;
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.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.apache.olingo.commons.api.data.Annotatable;
import org.apache.olingo.commons.api.edm.EdmEntitySet;
import org.apache.olingo.commons.api.edm.EdmEntityType;
import org.apache.olingo.commons.api.edm.EdmType;
import org.apache.olingo.commons.api.edm.FullQualifiedName;
import org.apache.olingo.commons.api.format.ContentType;
import org.apache.olingo.server.api.ODataRequest;
import org.apache.olingo.server.api.ServiceMetadata;
import org.apache.olingo.server.api.serializer.ODataSerializer;
import org.apache.olingo.server.api.serializer.SerializerException;
import org.apache.olingo.server.api.uri.UriHelper;
import org.apache.olingo.server.api.uri.UriInfo;
import org.apache.olingo.server.api.uri.UriParameter;
import org.apache.olingo.server.api.uri.UriResource;
import org.apache.olingo.server.api.uri.UriResourceEntitySet;
import org.apache.olingo.server.api.uri.UriResourceKind;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentMatcher;
import com.sap.olingo.jpa.processor.core.api.JPAODataSessionContextAccess;
import com.sap.olingo.jpa.processor.core.exception.ODataJPASerializerException;
public abstract class TestJPASerializerCollection {
protected JPASerializer cut;
protected ServiceMetadata serviceMetadata;
protected ODataSerializer serializer;
protected UriInfo uriInfo;
protected UriHelper uriHelper;
protected ODataRequest request;
protected JPAEntityCollectionExtension result;
protected JPAODataSessionContextAccess context;
protected Annotatable annotatable;
protected EdmEntityType edmEt;
protected EdmEntitySet edmEs;
public TestJPASerializerCollection() {
super();
}
@BeforeEach
public void setup() throws SerializerException {
context = mock(JPAODataSessionContextAccess.class);
serviceMetadata = mock(ServiceMetadata.class);
uriInfo = mock(UriInfo.class);
serializer = mock(ODataSerializer.class);
uriHelper = mock(UriHelper.class);
request = mock(ODataRequest.class);
result = mock(JPAEntityCollectionExtension.class);
edmEt = mock(EdmEntityType.class);
edmEs = mock(EdmEntitySet.class);
final UriResourceEntitySet uriEs = mock(UriResourceEntitySet.class);
final List<UriParameter> keys = Collections.emptyList();
final List<UriResource> resourceParts = new ArrayList<>();
resourceParts.add(uriEs);
when(uriInfo.getUriResourceParts()).thenReturn(resourceParts);
when(uriEs.getKind()).thenReturn(UriResourceKind.entitySet);
when(uriEs.getEntitySet()).thenReturn(edmEs);
when(uriEs.getKeyPredicates()).thenReturn(keys);
when(uriHelper.buildContextURLSelectList(any(), any(), any())).thenReturn("");
when(edmEs.getEntityType()).thenReturn(edmEt);
when(edmEt.getName()).thenReturn("Person");
when(edmEt.getFullQualifiedName()).thenReturn(new FullQualifiedName("test.Person"));
initTest(resourceParts);
}
@Test
public void testAnnotatableContextUrlFilledForAbsoluteRequested() throws SerializerException,
ODataJPASerializerException {
when(context.useAbsoluteContextURL()).thenReturn(true);
when(request.getRawBaseUri()).thenReturn("localhost:8080/v1/");
((JPAOperationSerializer) cut).serialize(annotatable, getType(), request);
verifySerializerCall(serializer, "localhost:8080/v1/");
}
@Test
public void testAnnotatableContextUrlFilledForAbsoluteRequestedWithOutSlash() throws SerializerException,
ODataJPASerializerException {
when(context.useAbsoluteContextURL()).thenReturn(true);
when(request.getRawBaseUri()).thenReturn("localhost:8080/v1");
((JPAOperationSerializer) cut).serialize(annotatable, getType(), request);
verifySerializerCall(serializer, "localhost:8080/v1/");
}
@Test
public void testAnnotatableContextUrlNullForRelativeRequested() throws SerializerException,
ODataJPASerializerException {
when(context.useAbsoluteContextURL()).thenReturn(false);
((JPAOperationSerializer) cut).serialize(annotatable, getType(), request);
verifySerializerCall(serializer, null);
}
@Test
public void testCreateODataSerializerCanBeCreated() {
assertNotNull(cut);
}
@Test
public void testGetContentTypeReturnsJSON() {
assertEquals(ContentType.APPLICATION_JSON, cut.getContentType());
}
@Test
public void testRequestSerialize() throws ODataJPASerializerException, SerializerException {
assertNull(cut.serialize(request, result));
}
protected abstract <T> ArgumentMatcher<T> createMatcher(final String pattern);
protected abstract EdmType getType();
protected abstract void initTest(final List<UriResource> resourceParts);
protected abstract <T> void verifySerializerCall(final ODataSerializer serializer, final String pattern)
throws SerializerException;
} | 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/src/test/java/com/sap/olingo/jpa/processor/core/serializer/TestJPAOperationSerializer.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/serializer/TestJPAOperationSerializer.java | package com.sap.olingo.jpa.processor.core.serializer;
import static org.mockito.Mockito.when;
import org.apache.olingo.commons.api.edm.EdmType;
import org.apache.olingo.server.api.serializer.SerializerException;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.processor.core.exception.ODataJPASerializerException;
public abstract class TestJPAOperationSerializer extends TestJPASerializer {
@Test
public void testAnnotatableContextUrlFilledForAbsoluteRequested() throws SerializerException,
ODataJPASerializerException {
when(context.useAbsoluteContextURL()).thenReturn(true);
when(request.getRawBaseUri()).thenReturn("localhost:8080/v1/");
((JPAOperationSerializer) cut).serialize(annotatable, getType(), request);
verifySerializerCall(serializer, "localhost:8080/v1/");
}
@Test
public void testAnnotatableContextUrlFilledForAbsoluteRequestedWithOutSlash() throws SerializerException,
ODataJPASerializerException {
when(context.useAbsoluteContextURL()).thenReturn(true);
when(request.getRawBaseUri()).thenReturn("localhost:8080/v1");
((JPAOperationSerializer) cut).serialize(annotatable, getType(), request);
verifySerializerCall(serializer, "localhost:8080/v1/");
}
@Test
public void testAnnotatableContextUrlNullForRelativeRequested() throws SerializerException,
ODataJPASerializerException {
when(context.useAbsoluteContextURL()).thenReturn(false);
((JPAOperationSerializer) cut).serialize(annotatable, getType(), request);
verifySerializerCall(serializer, null);
}
protected abstract EdmType 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/src/test/java/com/sap/olingo/jpa/processor/core/serializer/TestJPASerializeComplex.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/serializer/TestJPASerializeComplex.java | package com.sap.olingo.jpa.processor.core.serializer;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.apache.olingo.commons.api.data.Entity;
import org.apache.olingo.commons.api.data.Property;
import org.apache.olingo.commons.api.edm.EdmComplexType;
import org.apache.olingo.commons.api.edm.EdmProperty;
import org.apache.olingo.commons.api.edm.EdmType;
import org.apache.olingo.commons.api.format.ContentType;
import org.apache.olingo.server.api.serializer.ODataSerializer;
import org.apache.olingo.server.api.serializer.SerializerException;
import org.apache.olingo.server.api.uri.UriResource;
import org.apache.olingo.server.api.uri.UriResourceComplexProperty;
import org.apache.olingo.server.api.uri.UriResourceKind;
import com.sap.olingo.jpa.processor.core.util.matcher.ComplexSerializerOptionsMatcher;
public class TestJPASerializeComplex extends TestJPAOperationSerializer {
private EdmComplexType edmCT;
@SuppressWarnings("unchecked")
@Override
protected ComplexSerializerOptionsMatcher createMatcher(final String pattern) {
return new ComplexSerializerOptionsMatcher(pattern);
}
@Override
protected EdmType getType() {
return edmCT;
}
@Override
protected void initTest(final List<UriResource> resourceParts) {
annotatable = mock(Property.class);
edmCT = mock(EdmComplexType.class);
final UriResourceComplexProperty uriCT = mock(UriResourceComplexProperty.class);
final EdmProperty edmProperty = mock(EdmProperty.class);
when(uriCT.getComplexType()).thenReturn(edmCT);
when(uriCT.getProperty()).thenReturn(edmProperty);
when(uriCT.getKind()).thenReturn(UriResourceKind.complexProperty);
when(edmProperty.getName()).thenReturn("InhouseAddress");
when(edmProperty.isCollection()).thenReturn(false);
resourceParts.add(uriCT);
final Entity resultEntity = mock(Entity.class);
final List<Entity> resultEntities = new ArrayList<>();
resultEntities.add(resultEntity);
when(resultEntity.getProperties()).thenReturn(Collections.emptyList());
when(result.getEntities()).thenReturn(resultEntities);
when(((JPAEntityCollectionExtension) result).getFirstResult()).thenReturn(resultEntity);
cut = new JPASerializeComplex(serviceMetadata, serializer, uriHelper, uriInfo, ContentType.APPLICATION_JSON,
context);
}
@Override
protected void verifySerializerCall(final ODataSerializer serializer, final String pattern)
throws SerializerException {
verify(serializer).complex(any(), any(), any(), argThat(createMatcher(pattern)));
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/database/JPADefaultDatabaseProcessorTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/database/JPADefaultDatabaseProcessorTest.java | package com.sap.olingo.jpa.processor.core.database;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
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 org.apache.olingo.server.api.ODataApplicationException;
import org.apache.olingo.server.api.uri.queryoption.expression.BinaryOperatorKind;
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.core.exception.ODataJPADBAdaptorException;
import com.sap.olingo.jpa.processor.core.exception.ODataJPAFilterException;
import com.sap.olingo.jpa.processor.core.filter.JPAAggregationOperation;
import com.sap.olingo.jpa.processor.core.filter.JPAArithmeticOperator;
import com.sap.olingo.jpa.processor.core.filter.JPABooleanOperator;
import com.sap.olingo.jpa.processor.core.filter.JPAComparisonOperator;
import com.sap.olingo.jpa.processor.core.filter.JPAEnumerationBasedOperator;
import com.sap.olingo.jpa.processor.core.filter.JPAMethodCall;
import com.sap.olingo.jpa.processor.core.filter.JPAUnaryBooleanOperator;
class JPADefaultDatabaseProcessorTest extends JPA_XXX_DatabaseProcessorTest {
@BeforeEach
void setup() {
initEach();
oneParameterResult = "SELECT * FROM Example(?1)";
twoParameterResult = "SELECT * FROM Example(?1,?2)";
countResult = "SELECT COUNT(*) FROM Example(?1)";
cut = new JPADefaultDatabaseProcessor();
}
@Test
void testNotSupportedConvertBooleanOperator() {
final JPABooleanOperator operator = mock(JPABooleanOperator.class);
assertThrows(ODataJPAFilterException.class, () -> ((JPAODataDatabaseOperations) cut).convert(operator));
}
@Test
void testNotSupportedConvertAggregationOperator() {
final JPAAggregationOperation operator = mock(JPAAggregationOperation.class);
assertThrows(ODataJPAFilterException.class, () -> ((JPAODataDatabaseOperations) cut).convert(operator));
}
@Test
void testNotSupportedConvertArithmeticOperator() {
final JPAArithmeticOperator operator = mock(JPAArithmeticOperator.class);
assertThrows(ODataJPAFilterException.class, () -> ((JPAODataDatabaseOperations) cut).convert(operator));
}
@Test
void testNotSupportedConvertMethodCall() {
final JPAMethodCall operator = mock(JPAMethodCall.class);
assertThrows(ODataJPAFilterException.class, () -> ((JPAODataDatabaseOperations) cut).convert(operator));
}
@Test
void testNotSupportedConvertUnaryBooleanOperator() {
final JPAUnaryBooleanOperator operator = mock(JPAUnaryBooleanOperator.class);
assertThrows(ODataJPAFilterException.class, () -> ((JPAODataDatabaseOperations) cut).convert(operator));
}
@Test
void testNotSupportedConvertComparisonOperatorOthersThenHAS() {
@SuppressWarnings("unchecked")
final JPAComparisonOperator<String> operator = mock(JPAComparisonOperator.class);
when(operator.getOperator()).then(new Answer<BinaryOperatorKind>() {
@Override
public BinaryOperatorKind answer(final InvocationOnMock invocation) throws Throwable {
return BinaryOperatorKind.SUB;
}
});
assertThrows(ODataJPAFilterException.class, () -> ((JPAODataDatabaseOperations) cut).convert(operator));
}
@SuppressWarnings("unchecked")
@Test
void testSupportedConvertComparisonOperatorOperatorHAS() throws ODataApplicationException {
final CriteriaBuilder cb = mock(CriteriaBuilder.class);
final Expression<Integer> cbResult = mock(Expression.class);
final Predicate cbPredicate = mock(Predicate.class);
final JPAComparisonOperator<Long> operator = mock(JPAComparisonOperator.class);
final Expression<Long> left = mock(Expression.class);
final JPAEnumerationBasedOperator right = mock(JPAEnumerationBasedOperator.class);
when(operator.getOperator()).then(new Answer<BinaryOperatorKind>() {
@Override
public BinaryOperatorKind answer(final InvocationOnMock invocation) throws Throwable {
return BinaryOperatorKind.HAS;
}
});
when(operator.getRight()).thenReturn(right);
when(right.getValue()).thenReturn(5L);
when(operator.getLeft()).thenReturn(left);
when(cb.quot(left, 5L)).thenAnswer(new Answer<Expression<Integer>>() {
@Override
public Expression<Integer> answer(final InvocationOnMock invocation) throws Throwable {
return cbResult;
}
});
when(cb.mod(cbResult, 2)).thenReturn(cbResult);
when(cb.equal(cbResult, 1)).thenReturn(cbPredicate);
((JPAODataDatabaseOperations) cut).setCriteriaBuilder(cb);
final Expression<Boolean> act = ((JPAODataDatabaseOperations) cut).convert(operator);
assertNotNull(act);
}
@Test
void testNotSupportedSearch() {
assertThrows(ODataJPADBAdaptorException.class, () -> {
cut.createSearchWhereClause(null, null, null, null, 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/src/test/java/com/sap/olingo/jpa/processor/core/database/JPA_HSQLDB_DatabaseProcessorTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/database/JPA_HSQLDB_DatabaseProcessorTest.java | package com.sap.olingo.jpa.processor.core.database;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.mock;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.CriteriaQuery;
import jakarta.persistence.criteria.Root;
import org.apache.olingo.commons.api.http.HttpStatusCode;
import org.apache.olingo.server.api.ODataApplicationException;
import org.apache.olingo.server.api.uri.queryoption.SearchOption;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEntityType;
class JPA_HSQLDB_DatabaseProcessorTest extends JPA_XXX_DatabaseProcessorTest {
@BeforeEach
public void setup() {
initEach();
oneParameterResult = "SELECT * FROM TABLE (Example(?1))";
twoParameterResult = "SELECT * FROM TABLE (Example(?1,?2))";
countResult = "SELECT COUNT(*) FROM TABLE (Example(?1))";
cut = new JPA_HSQLDB_DatabaseProcessor();
}
@SuppressWarnings("unchecked")
@Test
void testAbortsOnSearchRequest() {
final CriteriaBuilder cb = mock(CriteriaBuilder.class);
final CriteriaQuery<String> cq = mock(CriteriaQuery.class);
final Root<String> root = mock(Root.class);
final JPAEntityType entityType = mock(JPAEntityType.class);
final SearchOption searchOption = mock(SearchOption.class);
final ODataApplicationException act = assertThrows(ODataApplicationException.class,
() -> cut.createSearchWhereClause(cb, cq, root, entityType, searchOption));
assertEquals(HttpStatusCode.NOT_IMPLEMENTED.getStatusCode(), act.getStatusCode());
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/database/JPAPostgresqlDatabaseProcessorTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/database/JPAPostgresqlDatabaseProcessorTest.java | package com.sap.olingo.jpa.processor.core.database;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.mock;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.CriteriaQuery;
import jakarta.persistence.criteria.Root;
import org.apache.olingo.commons.api.http.HttpStatusCode;
import org.apache.olingo.server.api.ODataApplicationException;
import org.apache.olingo.server.api.uri.queryoption.SearchOption;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEntityType;
class JPAPostgresqlDatabaseProcessorTest extends JPA_XXX_DatabaseProcessorTest {
@BeforeEach
public void setup() {
initEach();
oneParameterResult = "SELECT * FROM Example(?1)";
twoParameterResult = "SELECT * FROM Example(?1,?2)";
countResult = "SELECT COUNT(*) FROM Example(?1)";
cut = new JPAPostgresqlDatabaseProcessor();
}
@SuppressWarnings("unchecked")
@Test
void testAbortsOnSearchRequest() {
final CriteriaBuilder cb = mock(CriteriaBuilder.class);
final CriteriaQuery<String> cq = mock(CriteriaQuery.class);
final Root<String> root = mock(Root.class);
final JPAEntityType entityType = mock(JPAEntityType.class);
final SearchOption searchOption = mock(SearchOption.class);
final ODataApplicationException act = assertThrows(ODataApplicationException.class,
() -> cut.createSearchWhereClause(cb, cq, root, entityType, searchOption));
assertEquals(HttpStatusCode.NOT_IMPLEMENTED.getStatusCode(), act.getStatusCode());
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/database/JPA_POSTSQL_DatabaseProcessorTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/database/JPA_POSTSQL_DatabaseProcessorTest.java | package com.sap.olingo.jpa.processor.core.database;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.mock;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.CriteriaQuery;
import jakarta.persistence.criteria.Root;
import org.apache.olingo.commons.api.http.HttpStatusCode;
import org.apache.olingo.server.api.ODataApplicationException;
import org.apache.olingo.server.api.uri.queryoption.SearchOption;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEntityType;
class JPA_POSTSQL_DatabaseProcessorTest extends JPA_XXX_DatabaseProcessorTest {
@BeforeEach
void setup() {
initEach();
oneParameterResult = "SELECT * FROM Example(?1)";
twoParameterResult = "SELECT * FROM Example(?1,?2)";
countResult = "SELECT COUNT(*) FROM Example(?1)";
cut = new JPA_POSTSQL_DatabaseProcessor();
}
@SuppressWarnings("unchecked")
@Test
void testAbortsOnSearchRequest() {
final CriteriaBuilder cb = mock(CriteriaBuilder.class);
final CriteriaQuery<String> cq = mock(CriteriaQuery.class);
final Root<String> root = mock(Root.class);
final JPAEntityType entityType = mock(JPAEntityType.class);
final SearchOption searchOption = mock(SearchOption.class);
final ODataApplicationException act = assertThrows(ODataApplicationException.class,
() -> cut.createSearchWhereClause(cb, cq, root, entityType, searchOption));
assertEquals(HttpStatusCode.NOT_IMPLEMENTED.getStatusCode(), act.getStatusCode());
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/database/JPAHanaDatabaseProcessorTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/database/JPAHanaDatabaseProcessorTest.java | package com.sap.olingo.jpa.processor.core.database;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.processor.cb.ProcessorSqlPatternProvider;
class JPAHanaDatabaseProcessorTest extends JPA_XXX_DatabaseProcessorTest {
@BeforeEach
void setup() {
initEach();
oneParameterResult = "SELECT * FROM Example(?1)";
twoParameterResult = "SELECT * FROM Example(?1,?2)";
countResult = "SELECT COUNT(*) FROM Example(?1)";
cut = new JPAHanaDatabaseProcessor();
}
@Test
void testGetLocatePattern() {
assertTrue(cut instanceof ProcessorSqlPatternProvider);
assertEquals("INSTR", ((ProcessorSqlPatternProvider) cut).getLocatePattern().function());
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/database/JPA_DERBY_DatabaseProcessorTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/database/JPA_DERBY_DatabaseProcessorTest.java | package com.sap.olingo.jpa.processor.core.database;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.mock;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.CriteriaQuery;
import jakarta.persistence.criteria.Root;
import org.apache.olingo.commons.api.http.HttpStatusCode;
import org.apache.olingo.server.api.ODataApplicationException;
import org.apache.olingo.server.api.uri.queryoption.SearchOption;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEntityType;
class JPA_DERBY_DatabaseProcessorTest extends JPA_XXX_DatabaseProcessorTest {
@BeforeEach
public void setup() {
initEach();
oneParameterResult = "SELECT * FROM TABLE (Example(?1))";
twoParameterResult = "SELECT * FROM TABLE (Example(?1,?2))";
countResult = "SELECT COUNT(*) FROM TABLE (Example(?1))";
cut = new JPA_DERBY_DatabaseProcessor();
}
@SuppressWarnings("unchecked")
@Test
void testAbortsOnSearchRequest() {
final CriteriaBuilder cb = mock(CriteriaBuilder.class);
final CriteriaQuery<String> cq = mock(CriteriaQuery.class);
final Root<String> root = mock(Root.class);
final JPAEntityType entityType = mock(JPAEntityType.class);
final SearchOption searchOption = mock(SearchOption.class);
final ODataApplicationException act = assertThrows(ODataApplicationException.class,
() -> cut.createSearchWhereClause(cb, cq, root, entityType, searchOption));
assertEquals(HttpStatusCode.NOT_IMPLEMENTED.getStatusCode(), act.getStatusCode());
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/database/JPAPostgresqlSqlPatternProviderTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/database/JPAPostgresqlSqlPatternProviderTest.java | package com.sap.olingo.jpa.processor.core.database;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.sap.olingo.jpa.processor.cb.ProcessorSqlPatternProvider;
class JPAPostgresqlSqlPatternProviderTest {
private ProcessorSqlPatternProvider cut;
@BeforeEach
void setup() {
cut = new JPAPostgresqlSqlPatternProvider();
}
@Test
void testGetLocatePattern() {
assertEquals("POSITION", cut.getLocatePattern().function());
assertEquals(" IN ", cut.getLocatePattern().parameters().get(1).keyword());
}
@Test
void testGetSubStringPattern() {
assertEquals("SUBSTRING", cut.getSubStringPattern().function());
assertEquals(2, cut.getLocatePattern().parameters().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/src/test/java/com/sap/olingo/jpa/processor/core/database/JPA_XXX_DatabaseProcessorTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/database/JPA_XXX_DatabaseProcessorTest.java | package com.sap.olingo.jpa.processor.core.database;
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.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import jakarta.persistence.EntityManager;
import jakarta.persistence.Query;
import org.apache.olingo.commons.api.edm.EdmEntityType;
import org.apache.olingo.commons.api.edm.EdmFunction;
import org.apache.olingo.commons.api.edm.EdmParameter;
import org.apache.olingo.commons.api.edm.EdmPrimitiveType;
import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeException;
import org.apache.olingo.commons.api.http.HttpStatusCode;
import org.apache.olingo.commons.core.edm.primitivetype.EdmString;
import org.apache.olingo.server.api.ODataApplicationException;
import org.apache.olingo.server.api.uri.UriParameter;
import org.apache.olingo.server.api.uri.UriResource;
import org.apache.olingo.server.api.uri.UriResourceCount;
import org.apache.olingo.server.api.uri.UriResourceEntitySet;
import org.apache.olingo.server.api.uri.UriResourceFunction;
import org.apache.olingo.server.api.uri.UriResourceKind;
import org.junit.jupiter.api.Test;
import org.mockito.internal.matchers.Equals;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import com.sap.olingo.jpa.metadata.api.JPAHttpHeaderMap;
import com.sap.olingo.jpa.metadata.api.JPARequestParameterMap;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPADataBaseFunction;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAOperationResultParameter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAParameter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.processor.core.api.JPAODataDatabaseProcessor;
import com.sap.olingo.jpa.processor.core.testmodel.BusinessPartner;
import com.sap.olingo.jpa.processor.core.testmodel.Organization;
public abstract class JPA_XXX_DatabaseProcessorTest {
protected JPAODataDatabaseProcessor cut;
protected EntityManager em;
protected UriResourceEntitySet uriEntitySet;
protected JPADataBaseFunction jpaFunction;
protected UriResourceFunction uriFunction;
protected EdmEntityType edmEntityType;
protected EdmFunction edmFunction;
protected EdmParameter edmElement;
protected List<UriResource> uriResourceParts;
protected List<UriParameter> uriParameters;
protected JPAOperationResultParameter returnParameter;
protected List<JPAParameter> parameterList;
protected JPAParameter firstParameter;
protected UriParameter firstUriParameter;
protected Query functionQuery;
protected String oneParameterResult;
protected String twoParameterResult;
protected String countResult;
protected JPAHttpHeaderMap headers;
protected JPARequestParameterMap parameters;
void initEach() {
em = mock(EntityManager.class);
functionQuery = mock(Query.class);
uriResourceParts = new ArrayList<>();
uriFunction = mock(UriResourceFunction.class);
uriEntitySet = mock(UriResourceEntitySet.class);
edmFunction = mock(EdmFunction.class);
edmElement = mock(EdmParameter.class);
edmEntityType = mock(EdmEntityType.class);
uriResourceParts.add(uriFunction);
uriParameters = new ArrayList<>();
firstUriParameter = mock(UriParameter.class);
headers = mock(JPAHttpHeaderMap.class);
parameters = mock(JPARequestParameterMap.class);
jpaFunction = mock(JPADataBaseFunction.class);
returnParameter = mock(JPAOperationResultParameter.class);
parameterList = new ArrayList<>();
firstParameter = mock(JPAParameter.class);
when(em.createNativeQuery(any(), eq(BusinessPartner.class))).thenReturn(functionQuery);
when(em.createNativeQuery(any())).thenReturn(functionQuery);
when(uriEntitySet.getEntityType()).thenReturn(edmEntityType);
when(uriEntitySet.getKind()).thenReturn(UriResourceKind.entitySet);
when(uriEntitySet.getKeyPredicates()).thenReturn(uriParameters);
when(uriFunction.getParameters()).thenReturn(uriParameters);
when(jpaFunction.getResultParameter()).thenReturn(returnParameter);
when(uriFunction.getFunction()).thenReturn(edmFunction);
when(uriFunction.getKind()).thenReturn(UriResourceKind.function);
when(edmFunction.getParameter(firstParameter.getName())).thenReturn(edmElement);
}
@Test
void testAbortsOnNotImplementedChaining() throws ODataJPAModelException {
createFunctionWithOneParameter();
final UriResourceCount uriResourceCount = mock(UriResourceCount.class);
uriResourceParts.add(uriResourceCount);
when(uriResourceCount.getKind()).thenReturn(UriResourceKind.value);
final ODataApplicationException act = assertThrows(ODataApplicationException.class,
() -> cut.executeFunctionQuery(uriResourceParts, jpaFunction, em, headers, parameters));
assertEquals(act.getStatusCode(), HttpStatusCode.NOT_IMPLEMENTED.getStatusCode());
}
@Test
void testBoundConvertsExceptionOnParameterProblem() throws ODataJPAModelException {
createBoundFunctionWithOneParameter();
when(jpaFunction.getParameter()).thenThrow(ODataJPAModelException.class);
final ODataApplicationException act = assertThrows(ODataApplicationException.class,
() -> cut.executeFunctionQuery(uriResourceParts, jpaFunction, em, headers, parameters));
assertEquals(HttpStatusCode.INTERNAL_SERVER_ERROR.getStatusCode(), act.getStatusCode());
}
@SuppressWarnings("unchecked")
@Test
void testBoundFunctionWithOneParameterCount() throws ODataApplicationException,
ODataJPAModelException {
createBoundFunctionWithOneParameter();
final UriResourceCount uriResourceCount = mock(UriResourceCount.class);
uriResourceParts.add(uriResourceCount);
when(uriResourceCount.getKind()).thenReturn(UriResourceKind.count);
when(functionQuery.getSingleResult()).thenReturn(5L);
final List<Long> act = (List<Long>) cut.executeFunctionQuery(uriResourceParts, jpaFunction, em, headers,
parameters);
verify(em, times(1)).createNativeQuery((String) argThat(new Equals(countResult)));
verify(functionQuery, times(1)).setParameter(1, "5");
verify(functionQuery, times(0)).getResultList();
verify(functionQuery, times(1)).getSingleResult();
assertNotNull(act);
assertEquals(1, act.size());
assertEquals(5L, act.get(0));
}
@SuppressWarnings("unchecked")
@Test
void testBoundFunctionWithOneParameterReturnsBusinessPartners() throws ODataApplicationException,
ODataJPAModelException {
createBoundFunctionWithOneParameter();
final List<BusinessPartner> act = (List<BusinessPartner>) cut.executeFunctionQuery(uriResourceParts, jpaFunction,
em, headers, parameters);
verify(em, times(1)).createNativeQuery((String) argThat(new Equals(oneParameterResult)), eq(
BusinessPartner.class));
verify(functionQuery, times(1)).setParameter(1, "5");
assertNotNull(act);
assertEquals(2, act.size());
}
@SuppressWarnings("unchecked")
@Test
void testBoundFunctionWithTwoParameterReturnsBusinessPartners() throws ODataApplicationException,
ODataJPAModelException {
createBoundFunctionWithOneParameter();
addSecondBoundParameter();
final List<BusinessPartner> act = (List<BusinessPartner>) cut.executeFunctionQuery(uriResourceParts, jpaFunction,
em, headers, parameters);
verify(em, times(1)).createNativeQuery((String) argThat(new Equals(twoParameterResult)), eq(
BusinessPartner.class));
verify(functionQuery, times(1)).setParameter(1, "5");
verify(functionQuery, times(1)).setParameter(2, "3");
assertNotNull(act);
assertEquals(2, act.size());
}
@Test
void testBoundRaisesExceptionOnMissingParameter() throws ODataJPAModelException {
createBoundFunctionWithOneParameter();
when(uriEntitySet.getKeyPredicates()).thenReturn(new ArrayList<>());
final ODataApplicationException act = assertThrows(ODataApplicationException.class,
() -> cut.executeFunctionQuery(uriResourceParts, jpaFunction, em, headers, parameters));
assertEquals(HttpStatusCode.BAD_REQUEST.getStatusCode(), act.getStatusCode());
}
@Test
void testCheckRaiseExceptionOnProblemValueToString() throws ODataJPAModelException,
EdmPrimitiveTypeException {
createBoundFunctionWithOneParameter();
final EdmPrimitiveType edmType = mock(EdmPrimitiveType.class);
when(edmElement.getType()).thenReturn(edmType);
when(edmType.valueOfString(any(), any(), any(), any(), any(), any(), any()))
.thenThrow(EdmPrimitiveTypeException.class);
final ODataApplicationException act = assertThrows(ODataApplicationException.class,
() -> cut.executeFunctionQuery(uriResourceParts, jpaFunction, em, headers, parameters));
assertEquals(HttpStatusCode.INTERNAL_SERVER_ERROR.getStatusCode(), act.getStatusCode());
}
@Test
void testCheckRaisesExceptionOnIsBound() throws ODataJPAModelException {
createBoundFunctionWithOneParameter();
when(jpaFunction.isBound()).thenThrow(ODataJPAModelException.class);
final ODataApplicationException act = assertThrows(ODataApplicationException.class,
() -> cut.executeFunctionQuery(uriResourceParts, jpaFunction, em, headers, parameters));
assertEquals(HttpStatusCode.INTERNAL_SERVER_ERROR.getStatusCode(), act.getStatusCode());
}
@Test
void testUnboundConvertsExceptionOnParameterProblem() throws ODataJPAModelException {
createFunctionWithOneParameter();
when(jpaFunction.getParameter()).thenThrow(ODataJPAModelException.class);
final ODataApplicationException act = assertThrows(ODataApplicationException.class,
() -> cut.executeFunctionQuery(uriResourceParts, jpaFunction, em, headers, parameters));
assertEquals(HttpStatusCode.INTERNAL_SERVER_ERROR.getStatusCode(), act.getStatusCode());
}
@SuppressWarnings("unchecked")
@Test
void testUnboundFunctionWithOneParameterCount() throws ODataApplicationException, ODataJPAModelException {
createFunctionWithOneParameter();
final UriResourceCount uriResourceCount = mock(UriResourceCount.class);
uriResourceParts.add(uriResourceCount);
when(uriResourceCount.getKind()).thenReturn(UriResourceKind.count);
when(functionQuery.getSingleResult()).thenReturn(5L);
final List<Long> act = (List<Long>) cut.executeFunctionQuery(uriResourceParts, jpaFunction, em, headers,
parameters);
verify(em, times(1)).createNativeQuery((String) argThat(new Equals(countResult)));
verify(functionQuery, times(1)).setParameter(1, "5");
verify(functionQuery, times(0)).getResultList();
verify(functionQuery, times(1)).getSingleResult();
assertNotNull(act);
assertEquals(1, act.size());
assertEquals(5L, act.get(0));
}
@SuppressWarnings("unchecked")
@Test
void testUnboundFunctionWithOneParameterReturnsBusinessPartners() throws ODataApplicationException,
ODataJPAModelException {
createFunctionWithOneParameter();
final List<BusinessPartner> act = (List<BusinessPartner>) cut.executeFunctionQuery(uriResourceParts, jpaFunction,
em, headers, parameters);
verify(em, times(1)).createNativeQuery((String) argThat(new Equals(oneParameterResult)), eq(
BusinessPartner.class));
verify(functionQuery, times(1)).setParameter(1, "5");
assertNotNull(act);
assertEquals(2, act.size());
}
@SuppressWarnings("unchecked")
@Test
void testUnboundFunctionWithTwoParameterReturnsBusinessPartners() throws ODataApplicationException,
ODataJPAModelException {
createFunctionWithOneParameter();
addSecondParameter();
final List<BusinessPartner> act = (List<BusinessPartner>) cut.executeFunctionQuery(uriResourceParts, jpaFunction,
em, headers, parameters);
verify(em, times(1)).createNativeQuery((String) argThat(new Equals(twoParameterResult)), eq(
BusinessPartner.class));
verify(functionQuery, times(1)).setParameter(1, "5");
verify(functionQuery, times(1)).setParameter(2, "3");
assertNotNull(act);
assertEquals(2, act.size());
}
@Test
void testUnboundRaisesExceptionOnMissingParameter() throws ODataJPAModelException {
createFunctionWithOneParameter();
when(uriFunction.getParameters()).thenReturn(new ArrayList<>());
final ODataApplicationException act = assertThrows(ODataApplicationException.class,
() -> cut.executeFunctionQuery(uriResourceParts, jpaFunction, em, headers, parameters));
assertEquals(HttpStatusCode.BAD_REQUEST.getStatusCode(), act.getStatusCode());
}
protected void addSecondBoundParameter() {
final JPAParameter secondParameter = mock(JPAParameter.class);
final UriParameter secondUriParameter = mock(UriParameter.class);
final EdmParameter edmSecondElement = mock(EdmParameter.class);
parameterList.add(secondParameter);
uriParameters.add(secondUriParameter);
when(secondUriParameter.getText()).thenReturn("3");
when(secondParameter.getName()).thenReturn("B");
when(secondUriParameter.getName()).thenReturn("B");
when(edmEntityType.getProperty("B")).thenReturn(edmSecondElement);
when(edmSecondElement.getType()).thenReturn(EdmString.getInstance());
when(secondParameter.getMaxLength()).thenReturn(10);
when(secondParameter.getType()).thenAnswer(new Answer<Class<?>>() {
@Override
public Class<?> answer(final InvocationOnMock invocation) throws Throwable {
return String.class;
}
});
}
protected void addSecondParameter() {
final JPAParameter secondParameter = mock(JPAParameter.class);
final UriParameter secondUriParameter = mock(UriParameter.class);
final EdmParameter edmSecondElement = mock(EdmParameter.class);
parameterList.add(secondParameter);
uriParameters.add(secondUriParameter);
when(secondUriParameter.getText()).thenReturn("3");
when(secondParameter.getName()).thenReturn("B");
when(secondUriParameter.getName()).thenReturn("B");
when(edmFunction.getParameter("B")).thenReturn(edmSecondElement);
when(edmSecondElement.getType()).thenReturn(EdmString.getInstance());
when(secondParameter.getMaxLength()).thenReturn(10);
when(secondParameter.getType()).thenAnswer(new Answer<Class<?>>() {
@Override
public Class<?> answer(final InvocationOnMock invocation) throws Throwable {
return String.class;
}
});
}
protected void createBoundFunctionWithOneParameter() throws ODataJPAModelException {
uriResourceParts.add(0, uriEntitySet);
when(uriFunction.getParameters()).thenReturn(new ArrayList<>());
when(jpaFunction.isBound()).thenReturn(Boolean.TRUE);
when(returnParameter.getType()).thenAnswer(new Answer<Class<?>>() {
@Override
public Class<?> answer(final InvocationOnMock invocation) throws Throwable {
return BusinessPartner.class;
}
});
when(jpaFunction.getDBName()).thenReturn("Example");
when(jpaFunction.getParameter()).thenReturn(parameterList);
parameterList.add(firstParameter);
when(firstParameter.getName()).thenReturn("A");
uriParameters.add(firstUriParameter);
when(firstUriParameter.getName()).thenReturn("A");
when(edmEntityType.getProperty("A")).thenReturn(edmElement);
when(firstUriParameter.getText()).thenReturn("5");
when(edmElement.getType()).thenReturn(EdmString.getInstance());
when(firstParameter.getMaxLength()).thenReturn(10);
when(firstParameter.getType()).thenAnswer(new Answer<Class<?>>() {
@Override
public Class<?> answer(final InvocationOnMock invocation) throws Throwable {
return String.class;
}
});
when(functionQuery.getResultList()).thenReturn(Arrays.asList(new Organization(), new Organization()));
}
protected void createFunctionWithOneParameter() throws ODataJPAModelException {
when(returnParameter.getType()).thenAnswer(new Answer<Class<?>>() {
@Override
public Class<?> answer(final InvocationOnMock invocation) throws Throwable {
return BusinessPartner.class;
}
});
when(jpaFunction.getDBName()).thenReturn("Example");
when(jpaFunction.getParameter()).thenReturn(parameterList);
parameterList.add(firstParameter);
when(firstParameter.getName()).thenReturn("A");
uriParameters.add(firstUriParameter);
when(firstUriParameter.getName()).thenReturn("A");
when(edmFunction.getParameter("A")).thenReturn(edmElement);
when(firstUriParameter.getText()).thenReturn("5");
when(edmElement.getType()).thenReturn(EdmString.getInstance());
when(firstParameter.getMaxLength()).thenReturn(10);
when(firstParameter.getType()).thenAnswer(new Answer<Class<?>>() {
@Override
public Class<?> answer(final InvocationOnMock invocation) throws Throwable {
return String.class;
}
});
when(functionQuery.getResultList()).thenReturn(Arrays.asList(new Organization(), new Organization()));
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/database/JPAODataDatabaseTableFunctionTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/database/JPAODataDatabaseTableFunctionTest.java | package com.sap.olingo.jpa.processor.core.database;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.List;
import org.apache.olingo.server.api.ODataApplicationException;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
class JPAODataDatabaseTableFunctionTest {
private JPAODataDatabaseTableFunction cut;
@BeforeEach
void setup() {
cut = new testClass();
}
@SuppressWarnings("removal")
@Test
void testExecuteFunctionQueryOldReturnsEmptyList() throws ODataApplicationException {
final var act = cut.executeFunctionQuery(null, null, null);
assertNotNull(act);
assertTrue(act.isEmpty());
}
@SuppressWarnings("rawtypes")
@Test
void testExecuteFunctionQueryNewReturnsEmptyList() throws ODataApplicationException {
final var act = cut.executeFunctionQuery(null, null, null, null, null);
assertNotNull(act);
assertTrue(act instanceof List);
assertTrue(((List) act).isEmpty());
}
private static class testClass implements JPAODataDatabaseTableFunction {
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/database/JPAODataDatabaseProcessorFactoryTest.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/database/JPAODataDatabaseProcessorFactoryTest.java | package com.sap.olingo.jpa.processor.core.database;
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.when;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.SQLException;
import java.util.stream.Stream;
import javax.sql.DataSource;
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.core.api.JPAODataDatabaseProcessor;
class JPAODataDatabaseProcessorFactoryTest {
private JPAODataDatabaseProcessorFactory cut;
private DataSource ds;
private Connection connection;
private DatabaseMetaData dbMetadata;
static Stream<Arguments> processorProvider() {
return Stream.of(
arguments("H2", JPA_HSQLDB_DatabaseProcessor.class),
arguments("HSQL Database Engine", JPA_HSQLDB_DatabaseProcessor.class),
arguments("PostgreSQL", JPAPostgresqlDatabaseProcessor.class),
arguments("HANA", JPADefaultDatabaseProcessor.class));
}
@BeforeEach
void setup() throws SQLException {
cut = new JPAODataDatabaseProcessorFactory();
ds = mock(DataSource.class);
connection = mock(Connection.class);
dbMetadata = mock(DatabaseMetaData.class);
when(ds.getConnection()).thenReturn(connection);
when(connection.getMetaData()).thenReturn(dbMetadata);
}
@Test
void testReturnsDefaultOnNull() throws SQLException {
final JPAODataDatabaseProcessor act = cut.create(null);
assertTrue(act instanceof JPADefaultDatabaseProcessor);
}
@ParameterizedTest
@MethodSource("processorProvider")
void test(final String dbName, final Class<?> processor) throws SQLException {
when(dbMetadata.getDatabaseProductName()).thenReturn(dbName);
final JPAODataDatabaseProcessor act = cut.create(ds);
assertEquals(processor, act.getClass());
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/TestFunctionReturnType.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/TestFunctionReturnType.java | package com.sap.olingo.jpa.processor.core.testobjects;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction.ReturnType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmParameter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.ODataFunction;
import com.sap.olingo.jpa.processor.core.testmodel.AdministrativeDivision;
import com.sap.olingo.jpa.processor.core.testmodel.AdministrativeInformation;
import com.sap.olingo.jpa.processor.core.testmodel.ChangeInformation;
import com.sap.olingo.jpa.processor.core.testmodel.CollectionDeep;
import com.sap.olingo.jpa.processor.core.testmodel.CollectionFirstLevelComplex;
import com.sap.olingo.jpa.processor.core.testmodel.CollectionSecondLevelComplex;
import com.sap.olingo.jpa.processor.core.testmodel.CommunicationData;
import com.sap.olingo.jpa.processor.core.testmodel.InhouseAddress;
import com.sap.olingo.jpa.processor.core.testmodel.Person;
public class TestFunctionReturnType implements ODataFunction {
@EdmFunction(name = "PrimitiveValue", returnType = @ReturnType, hasFunctionImport = true)
public Integer primitiveValue(@EdmParameter(name = "A") final short a) {
if (a == 0)
return null;
return (int) a;
}
@EdmFunction(name = "PrimitiveValueNullable", returnType = @ReturnType, hasFunctionImport = false)
public Integer primitiveValueNullable(@EdmParameter(name = "A") final Short a) {
if (a == null)
return 0;
return (int) a;
}
@EdmFunction(name = "ListOfPrimitiveValues", returnType = @ReturnType(type = Integer.class), hasFunctionImport = true)
public List<Integer> listOfPrimitiveValues(@EdmParameter(name = "A") final Integer a) {
return Arrays.asList(a, a / 2);
}
@EdmFunction(name = "ComplexType", returnType = @ReturnType, hasFunctionImport = true)
public CommunicationData complexType(@EdmParameter(name = "A") final int a) {
if (a == 0)
return null;
final CommunicationData result = new CommunicationData();
result.setLandlinePhoneNumber(Integer.valueOf(a).toString());
return result;
}
@EdmFunction(name = "ListOfComplexType", returnType = @ReturnType(type = AdministrativeInformation.class),
hasFunctionImport = true)
public List<AdministrativeInformation> listOfComplexType(@EdmParameter(name = "A") final String user) {
final Long milliPerDay = (long) (24 * 60 * 60 * 1000);
final AdministrativeInformation admin1 = new AdministrativeInformation();
admin1.setCreated(new ChangeInformation(user, new Date(LocalDate.now().toEpochDay() * milliPerDay)));
final AdministrativeInformation admin2 = new AdministrativeInformation();
admin2.setUpdated(new ChangeInformation(user, new Date(LocalDate.now().toEpochDay() * milliPerDay)));
return Arrays.asList(admin1, admin2);
}
@EdmFunction(name = "EntityType", returnType = @ReturnType, hasFunctionImport = true)
public AdministrativeDivision entityType(@EdmParameter(name = "A") final int a) {
if (a == 0)
return null;
final AdministrativeDivision result = new AdministrativeDivision();
result.setArea(a);
result.setCodePublisher("1");
result.setCodeID("2");
result.setDivisionCode("3");
return result;
}
@EdmFunction(name = "ListOfEntityType", returnType = @ReturnType(type = AdministrativeDivision.class),
hasFunctionImport = true)
public List<AdministrativeDivision> listOfEntityType(@EdmParameter(name = "A") final Integer a) {
return Arrays.asList(entityType(a), entityType(a / 2));
}
@EdmFunction(name = "ConvertBirthday", returnType = @ReturnType, hasFunctionImport = true)
public Person convertBirthday() {
final Person p = new Person();
p.setID("1");
p.setETag(3L);
p.setBirthDay(LocalDate.now());
p.setInhouseAddress(new ArrayList<>());
return p;
}
@EdmFunction(name = "ListOfEntityTypeWithCollection", returnType = @ReturnType(type = Person.class),
hasFunctionImport = true)
public List<Person> listOfEntityTypeWithCollection(@EdmParameter(name = "A") final Integer a) {
final Person person = new Person();
person.setID("1");
person.addInhouseAddress(new InhouseAddress("DEV", "7"));
person.addInhouseAddress(new InhouseAddress("ADMIN", "2"));
return Arrays.asList(person);
}
@EdmFunction(name = "EntityTypeWithDeepCollection", returnType = @ReturnType(type = CollectionDeep.class),
hasFunctionImport = true)
public CollectionDeep entityTypeWithDeepCollection(@EdmParameter(name = "A") final Integer a) {
final CollectionDeep deepCollection = new CollectionDeep();
final CollectionFirstLevelComplex firstLevel = new CollectionFirstLevelComplex();
final CollectionSecondLevelComplex secondLevel = new CollectionSecondLevelComplex();
deepCollection.setFirstLevel(firstLevel);
deepCollection.setID("1");
firstLevel.setLevelID(10);
firstLevel.setSecondLevel(secondLevel);
secondLevel.setNumber(5L);
secondLevel.addInhouseAddress(new InhouseAddress("DEV", "7"));
secondLevel.addInhouseAddress(new InhouseAddress("ADMIN", "2"));
secondLevel.setComment(Arrays.asList("One", "Two", "Three"));
return deepCollection;
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/ClassWithIdClassWithoutConstructor.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/ClassWithIdClassWithoutConstructor.java | package com.sap.olingo.jpa.processor.core.testobjects;
public class ClassWithIdClassWithoutConstructor {
@SuppressWarnings("unused")
private final ClassWithMultipleKeysConstructor key;
public ClassWithIdClassWithoutConstructor(final ClassWithMultipleKeysConstructor 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-processor/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/ThreeParameterTransientPropertyConverter.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/ThreeParameterTransientPropertyConverter.java | /**
*
*/
package com.sap.olingo.jpa.processor.core.testobjects;
import jakarta.persistence.EntityManager;
import com.sap.olingo.jpa.metadata.api.JPAHttpHeaderMap;
import com.sap.olingo.jpa.metadata.api.JPARequestParameterMap;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmTransientPropertyCalculator;
/**
*
* @author Oliver Grande
* @since 1.0.3
* 20.05.2021
*/
public class ThreeParameterTransientPropertyConverter implements EdmTransientPropertyCalculator<String> {
private final EntityManager em;
private final JPAHttpHeaderMap header;
private final JPARequestParameterMap parameter;
public ThreeParameterTransientPropertyConverter(final EntityManager em, final JPAHttpHeaderMap header,
final JPARequestParameterMap parameter) {
super();
this.em = em;
this.header = header;
this.parameter = parameter;
}
public EntityManager getEntityManager() {
return em;
}
public JPAHttpHeaderMap getHeader() {
return header;
}
public JPARequestParameterMap getParameter() {
return parameter;
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/HeaderParamTransientPropertyConverter.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/HeaderParamTransientPropertyConverter.java | /**
*
*/
package com.sap.olingo.jpa.processor.core.testobjects;
import java.util.List;
import java.util.Map;
import com.sap.olingo.jpa.metadata.api.JPAHttpHeaderMap;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmTransientPropertyCalculator;
/**
* @author Oliver Grande
* Created: 17.03.2020
*
*/
public class HeaderParamTransientPropertyConverter implements EdmTransientPropertyCalculator<String> {
private final JPAHttpHeaderMap header;
public HeaderParamTransientPropertyConverter(final JPAHttpHeaderMap header) {
super();
this.header = header;
}
public Map<String, List<String>> getHeader() {
return header;
}
} | 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/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/TestJavaActionNoParameter.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/TestJavaActionNoParameter.java | package com.sap.olingo.jpa.processor.core.testobjects;
import java.math.BigDecimal;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmAction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction.ReturnType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmParameter;
import com.sap.olingo.jpa.processor.core.testmodel.AdministrativeDivision;
import com.sap.olingo.jpa.processor.core.testmodel.BusinessPartner;
public class TestJavaActionNoParameter {
public static int constructorCalls = 0;
public static Short param1 = null;
public static Integer param2 = null;
public static FileAccess enumeration = null;
public static AdministrativeDivision bindingParam = null;
public TestJavaActionNoParameter() {
super();
constructorCalls++;
}
public static void resetCalls() {
constructorCalls = 0;
}
@EdmAction(returnType = @ReturnType(isNullable = false, precision = 20, scale = 5))
public BigDecimal unboundReturnPrimitiveNoParameter() {
return new BigDecimal(7);
}
@EdmAction()
public void unboundVoidOneParameter(@EdmParameter(name = "A") final Short a) {
param1 = a;
}
@EdmAction()
public void unboundVoidTwoParameter(@EdmParameter(name = "A") final Short a, @EdmParameter(
name = "B") final Integer b) {
param1 = a;
param2 = b;
}
@EdmAction(isBound = true)
public void boundOnlyBinding(@EdmParameter(name = "Root") final AdministrativeDivision root) {
bindingParam = root;
}
@EdmAction(isBound = true)
public void boundBindingPlus(@EdmParameter(name = "Root") final AdministrativeDivision root, @EdmParameter(
name = "A") final Short a, @EdmParameter(name = "B") final Integer b) {
bindingParam = root;
param1 = a;
param2 = b;
}
@EdmAction()
public void unboundVoidOneEnumerationParameter(@EdmParameter(name = "AccessRights") final FileAccess a) {
enumeration = a;
}
@EdmAction(isBound = true)
public void boundBindingSuperType(@EdmParameter(name = "Root") final BusinessPartner root) {
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/ClassWithMultipleKeysConstructor.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/ClassWithMultipleKeysConstructor.java | package com.sap.olingo.jpa.processor.core.testobjects;
public class ClassWithMultipleKeysConstructor {
private final String id1;
private final Integer id2;
private final String id3;
public ClassWithMultipleKeysConstructor(final String id1, final String id3, final Integer id2) {
super();
this.id1 = id1;
this.id2 = id2;
this.id3 = id3;
}
public ClassWithMultipleKeysConstructor(final String willi, final Integer id2, final String id3) {
super();
this.id1 = willi;
this.id2 = id2;
this.id3 = id3;
}
public ClassWithMultipleKeysConstructor() {
this.id1 = "";
this.id2 = 0;
this.id3 = "";
}
public String getId1() {
return id1;
}
public Integer getId2() {
return id2;
}
public String getId3() {
return id3;
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/TwoParameterTransientPropertyConverter.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/TwoParameterTransientPropertyConverter.java | /**
*
*/
package com.sap.olingo.jpa.processor.core.testobjects;
import java.util.List;
import java.util.Map;
import jakarta.persistence.EntityManager;
import com.sap.olingo.jpa.metadata.api.JPAHttpHeaderMap;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmTransientPropertyCalculator;
/**
* @author Oliver Grande
* Created: 17.03.2020
*
*/
public class TwoParameterTransientPropertyConverter implements EdmTransientPropertyCalculator<String> {
private final EntityManager em;
private final Map<String, List<String>> header;
public TwoParameterTransientPropertyConverter(final EntityManager em, final JPAHttpHeaderMap header) {
super();
this.em = em;
this.header = header;
}
public EntityManager getEntityManager() {
return em;
}
public Map<String, List<String>> getHeader() {
return header;
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/BusinessPartnerRoleWithoutSetter.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/BusinessPartnerRoleWithoutSetter.java | package com.sap.olingo.jpa.processor.core.testobjects;
public class BusinessPartnerRoleWithoutSetter {
@SuppressWarnings("unused")
private String businessPartnerID;
@SuppressWarnings("unused")
private String roleCategory;
public BusinessPartnerRoleWithoutSetter() {
super();
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/FileAccess.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/FileAccess.java | package com.sap.olingo.jpa.processor.core.testobjects;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmEnumeration;
@EdmEnumeration(isFlags = true, converter = FileAccessConverter.class)
public enum FileAccess {
Read((short) 1), Write((short) 2), Create((short) 4), Delete((short) 8);
private final short value;
private FileAccess(final short value) {
this.value = value;
}
public short getValue() {
return 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-processor/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/TestFunctionForFilter.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/TestFunctionForFilter.java | package com.sap.olingo.jpa.processor.core.testobjects;
import java.time.LocalDate;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.From;
import com.sap.olingo.jpa.metadata.api.JPAODataQueryContext;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction.ReturnType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmParameter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.ODataFunction;
public class TestFunctionForFilter implements ODataFunction {
private final JPAODataQueryContext stmt;
public TestFunctionForFilter(final JPAODataQueryContext stmt) {
super();
this.stmt = stmt;
}
@EdmFunction(returnType = @ReturnType(type = Boolean.class), hasFunctionImport = false, isBound = false)
public Object at(@EdmParameter(name = "date") final LocalDate date) {
final CriteriaBuilder cb = stmt.getCriteriaBuilder();
final From<?, ?> from = stmt.getFrom();
return cb.and(
cb.lessThanOrEqualTo(from.get("validityStartDate"), date),
cb.greaterThanOrEqualTo(from.get("validityEndDate"), date));
}
@EdmFunction(returnType = @ReturnType(type = Boolean.class), hasFunctionImport = false, isBound = false)
public Object at2(@EdmParameter(name = "date") final LocalDate date) {
return Integer.valueOf(6);
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/ClassWithMultipleKeysNoConstructor.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/ClassWithMultipleKeysNoConstructor.java | package com.sap.olingo.jpa.processor.core.testobjects;
public class ClassWithMultipleKeysNoConstructor {
private final String id1;
private final Integer id2;
private final String id3;
public ClassWithMultipleKeysNoConstructor(final String id1, final String id3, final Integer id2) {
super();
this.id1 = id1;
this.id2 = id2;
this.id3 = id3;
}
public ClassWithMultipleKeysNoConstructor(final String willi, final Integer id2, final String id3) {
super();
this.id1 = willi;
this.id2 = id2;
this.id3 = id3;
}
public String getId1() {
return id1;
}
public Integer getId2() {
return id2;
}
public String getId3() {
return id3;
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/ClassWithOneKeyConstructor.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/ClassWithOneKeyConstructor.java | package com.sap.olingo.jpa.processor.core.testobjects;
import java.util.UUID;
public class ClassWithOneKeyConstructor {
private final UUID key;
public ClassWithOneKeyConstructor(final String key) {
this.key = UUID.fromString(key);
}
public ClassWithOneKeyConstructor(final UUID key) {
this.key = key;
}
public ClassWithOneKeyConstructor(final byte[] key) {
this.key = UUID.nameUUIDFromBytes(key);
}
public UUID getKey() {
return 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-processor/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/ClassWithMultipleKeysSetter.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/ClassWithMultipleKeysSetter.java | package com.sap.olingo.jpa.processor.core.testobjects;
public class ClassWithMultipleKeysSetter {
private String id1;
private Integer id2;
private String id3;
public ClassWithMultipleKeysSetter(final String id1, final String id3, final Integer id2) {
super();
this.id1 = id1;
this.id2 = id2;
this.id3 = id3;
}
public ClassWithMultipleKeysSetter(final String willi, final Integer id2, final String id3) {
super();
this.id1 = willi;
this.id2 = id2;
this.id3 = id3;
}
public ClassWithMultipleKeysSetter() {
this.id1 = "";
this.id2 = 0;
this.id3 = "";
}
public String getId1() {
return id1;
}
public Integer getId2() {
return id2;
}
public String getId3() {
return id3;
}
public void setId1(final String id1) {
this.id1 = id1;
}
public void setId2(final Integer id2) {
this.id2 = id2;
}
public void setId3(final String id3) {
this.id3 = id3;
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/OrganizationWithAudit.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/OrganizationWithAudit.java | package com.sap.olingo.jpa.processor.core.testobjects;
import java.time.LocalDateTime;
import jakarta.persistence.Column;
import jakarta.persistence.Id;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmProtectedBy;
import com.sap.olingo.jpa.processor.core.api.example.JPAExampleAuditable;
public class OrganizationWithAudit implements JPAExampleAuditable {
@Id
@Column(name = "\"ID\"")
private Integer id;
@Id
@EdmProtectedBy(name = "name")
@Column(name = "\"Name\"")
private String name;
@Column(name = "\"CreatedBy\"")
private String createdBy;
@Column(name = "\"CreatedAt\"", precision = 5)
private LocalDateTime createdAt;
@Column(name = "\"UpdatedBy\"")
private String updatedBy;
@Column(name = "\"UpdatedAt\"", precision = 5)
private LocalDateTime updatedAt;
@Override
public void setCreatedBy(final String user) {
createdBy = user;
}
@Override
public void setCreatedAt(final LocalDateTime dateTime) {
createdAt = dateTime;
}
@Override
public void setUpdatedBy(final String user) {
updatedBy = user;
}
@Override
public void setUpdatedAt(final LocalDateTime dateTime) {
updatedAt = dateTime;
}
public Integer getId() {
return id;
}
public void setId(final Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(final String name) {
this.name = name;
}
public LocalDateTime getCreatedAt() {
return createdAt;
}
public LocalDateTime getUpdatedAt() {
return updatedAt;
}
public String getCreatedBy() {
return createdBy;
}
public String getUpdatedBy() {
return updatedBy;
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/FileAccessConverter.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/FileAccessConverter.java | package com.sap.olingo.jpa.processor.core.testobjects;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import jakarta.persistence.AttributeConverter;
public class FileAccessConverter implements AttributeConverter<FileAccess[], Short> {
@Override
public Short convertToDatabaseColumn(final FileAccess[] attribute) {
return attribute[0].getValue();
}
@Override
public FileAccess[] convertToEntityAttribute(final Short dbData) {
if (dbData == null)
return null;
final List<FileAccess> accesses = new ArrayList<>();
for (final FileAccess e : Arrays.asList(FileAccess.values())) {
if (e.getValue() == dbData)
accesses.add(e);
}
return accesses.toArray(new FileAccess[] {});
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/TestFunctionParameter.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/TestFunctionParameter.java | package com.sap.olingo.jpa.processor.core.testobjects;
import java.util.Locale;
import jakarta.persistence.EntityManager;
import org.apache.olingo.commons.api.http.HttpStatusCode;
import org.apache.olingo.server.api.ODataApplicationException;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction.ReturnType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmParameter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.ODataFunction;
public class TestFunctionParameter implements ODataFunction {
public static int calls;
public static int param1;
public static int param2;
public EntityManager em;
public TestFunctionParameter(final EntityManager em) {
super();
this.em = em;
}
@EdmFunction(returnType = @ReturnType)
public Integer sum(@EdmParameter(name = "A") final Integer a, @EdmParameter(name = "B") final Integer b) {
calls += 1;
param1 = a;
param2 = b;
return a + b;
}
@EdmFunction(returnType = @ReturnType)
public Integer sumThrowsException(@EdmParameter(name = "A") final Integer a) throws ODataApplicationException {
throw new ODataApplicationException("Test", HttpStatusCode.INTERNAL_SERVER_ERROR.getStatusCode(), Locale.ENGLISH);
}
// Bound Java Functions not supported yet
// @EdmFunction(returnType = @ReturnType, isBound = true)
// public Integer bound(@EdmParameter(name = "A") final Person p) {
// return Integer.valueOf(p.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-processor/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/ClassWithIdClassConstructor.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/ClassWithIdClassConstructor.java | package com.sap.olingo.jpa.processor.core.testobjects;
public class ClassWithIdClassConstructor {
private final ClassWithMultipleKeysSetter key;
public ClassWithIdClassConstructor(final ClassWithMultipleKeysSetter key) {
this.key = key;
}
public ClassWithIdClassConstructor() {
key = null;
}
public ClassWithIdClassConstructor(final String id1, final String id3, final Integer id2) {
super();
this.key = new ClassWithMultipleKeysSetter(id1, id3, id2);
}
public ClassWithMultipleKeysSetter getKey() {
return 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-processor/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/OrganizationWithoutGetter.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/OrganizationWithoutGetter.java | package com.sap.olingo.jpa.processor.core.testobjects;
/**
* Needed for testing.<br>
* Should not have a getter for the id
* @author Oliver Grande
*
*/
public class OrganizationWithoutGetter {
@SuppressWarnings("unused")
private String id;
public OrganizationWithoutGetter(String id) {
super();
this.id = id;
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/TestJavaActions.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/TestJavaActions.java | package com.sap.olingo.jpa.processor.core.testobjects;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import jakarta.persistence.EntityManager;
import org.apache.olingo.commons.api.edm.geo.Geospatial.Dimension;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmAction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction.ReturnType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmGeospatial;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmParameter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.ODataAction;
import com.sap.olingo.jpa.processor.core.testmodel.BusinessPartnerRole;
import com.sap.olingo.jpa.processor.core.testmodel.ChangeInformation;
import com.sap.olingo.jpa.processor.core.testmodel.Person;
public class TestJavaActions implements ODataAction {
public static int constructorCalls = 0;
@SuppressWarnings("unused")
private final EntityManager em;
public TestJavaActions(final EntityManager em) {
super();
this.em = em;
assert em != null;
constructorCalls++;
}
@EdmAction()
public Integer unboundWithImport(
@EdmParameter(name = "A") final short a, @EdmParameter(name = "B") final int b) {
return a + b;
}
@EdmAction(name = "BoundNoImport", isBound = true)
public void boundNoImport(
@EdmParameter(name = "Person") final Person person,
@EdmParameter(name = "A", precision = 34, scale = 10) final BigDecimal a) {
// Do nothing
}
@EdmAction(returnType = @ReturnType(isNullable = false, precision = 20, scale = 5))
public BigDecimal unboundReturnFacetNoParameter() {
return new BigDecimal(7);
}
@EdmAction(returnType = @ReturnType(isNullable = false, precision = 20, scale = 5))
public BigDecimal unboundReturnFacet(
@EdmParameter(name = "A") final short a, @EdmParameter(name = "B") final int b) {
return new BigDecimal(a).add(new BigDecimal(b));
}
@EdmAction(isBound = true, entitySetPath = "Person/Roles")
public BusinessPartnerRole boundWithEntitySetPath(
@EdmParameter(name = "Person") final Person person) {
return null;
}
@EdmAction(returnType = @ReturnType(type = Person.class), isBound = false)
public Person returnsEntityWithETag() {
final var person = new Person();
person.setETag(7);
person.setID("Test");
return person;
}
@EdmAction()
public ChangeInformation returnEmbeddable() {
return new ChangeInformation();
}
@EdmAction()
public Person returnEntity() {
return new Person();
}
@EdmAction(returnType = @ReturnType(type = String.class))
public List<String> returnCollection() {
return new ArrayList<>();
}
@EdmAction(returnType = @ReturnType(type = ChangeInformation.class))
public List<ChangeInformation> returnEmbeddableCollection() {
return Arrays.asList(new ChangeInformation());
}
@EdmAction(returnType = @ReturnType(maxLength = 60,
srid = @EdmGeospatial(dimension = Dimension.GEOGRAPHY, srid = "4326")))
public String calculateLocation(
@EdmParameter(name = "String", maxLength = 100,
srid = @EdmGeospatial(dimension = Dimension.GEOGRAPHY, srid = "4326")) final String a) {
return "";
}
@EdmAction()
public void unboundWithOutParameter() {
// Do nothing
}
}
| 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/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/ClassWithOneKeyAndEmptyConstructor.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/ClassWithOneKeyAndEmptyConstructor.java | package com.sap.olingo.jpa.processor.core.testobjects;
import java.util.UUID;
public class ClassWithOneKeyAndEmptyConstructor {
private final UUID key;
public ClassWithOneKeyAndEmptyConstructor(final String key) {
this.key = UUID.fromString(key);
}
public ClassWithOneKeyAndEmptyConstructor() {
this.key = UUID.randomUUID();
}
public ClassWithOneKeyAndEmptyConstructor(final UUID key) {
this.key = key;
}
public UUID getKey() {
return 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-processor/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/TestFunctionActionConstructor.java | jpa/odata-jpa-processor/src/test/java/com/sap/olingo/jpa/processor/core/testobjects/TestFunctionActionConstructor.java | package com.sap.olingo.jpa.processor.core.testobjects;
import java.time.LocalDate;
import jakarta.persistence.EntityManager;
import com.sap.olingo.jpa.metadata.api.JPAHttpHeaderMap;
import com.sap.olingo.jpa.metadata.api.JPARequestParameterMap;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmAction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction.ReturnType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmParameter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.ODataAction;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.ODataFunction;
public class TestFunctionActionConstructor implements ODataFunction, ODataAction {
private final EntityManager em;
private final JPAHttpHeaderMap header;
private final JPARequestParameterMap parameter;
public TestFunctionActionConstructor(final EntityManager em, final JPAHttpHeaderMap header,
final JPARequestParameterMap parameter) {
super();
this.em = em;
this.header = header;
this.parameter = parameter;
}
@EdmFunction(returnType = @ReturnType(type = Boolean.class), hasFunctionImport = true, isBound = false)
public Boolean func(@EdmParameter(name = "date") final LocalDate date) {
return em != null && header != null && parameter != null;
}
@EdmAction(returnType = @ReturnType)
public void action(@EdmParameter(name = "date") final LocalDate date) throws Exception {
if (em == null || header == null || parameter == null)
throw new Exception("Missing parameter");
}
@EdmFunction(returnType = @ReturnType)
public Boolean funcEnum(@EdmParameter(name = "access") final FileAccess value) {
return em != null && header != null && parameter != 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/src/main/java/com/sap/olingo/jpa/processor/core/uri/JPAUriInfoResourceImpl.java | jpa/odata-jpa-processor/src/main/java/com/sap/olingo/jpa/processor/core/uri/JPAUriInfoResourceImpl.java | package com.sap.olingo.jpa.processor.core.uri;
import java.util.ArrayList;
import java.util.Collections;
import java.util.EnumMap;
import java.util.List;
import java.util.Map;
import javax.annotation.Nullable;
import org.apache.olingo.server.api.uri.UriInfoResource;
import org.apache.olingo.server.api.uri.UriResource;
import org.apache.olingo.server.api.uri.UriResourcePartTyped;
import org.apache.olingo.server.api.uri.queryoption.ApplyOption;
import org.apache.olingo.server.api.uri.queryoption.CountOption;
import org.apache.olingo.server.api.uri.queryoption.CustomQueryOption;
import org.apache.olingo.server.api.uri.queryoption.DeltaTokenOption;
import org.apache.olingo.server.api.uri.queryoption.ExpandOption;
import org.apache.olingo.server.api.uri.queryoption.FilterOption;
import org.apache.olingo.server.api.uri.queryoption.FormatOption;
import org.apache.olingo.server.api.uri.queryoption.IdOption;
import org.apache.olingo.server.api.uri.queryoption.OrderByOption;
import org.apache.olingo.server.api.uri.queryoption.SearchOption;
import org.apache.olingo.server.api.uri.queryoption.SelectOption;
import org.apache.olingo.server.api.uri.queryoption.SkipOption;
import org.apache.olingo.server.api.uri.queryoption.SkipTokenOption;
import org.apache.olingo.server.api.uri.queryoption.SystemQueryOption;
import org.apache.olingo.server.api.uri.queryoption.SystemQueryOptionKind;
import org.apache.olingo.server.api.uri.queryoption.TopOption;
class JPAUriInfoResourceImpl implements JPAUriInfoResource {
private List<UriResource> pathParts;
private final UriInfoResource original;
private final Map<SystemQueryOptionKind, SystemQueryOption> systemQueryOptions =
new EnumMap<>(SystemQueryOptionKind.class);
JPAUriInfoResourceImpl(@Nullable final UriInfoResource original) {
if (original != null) {
this.original = original;
this.pathParts = new ArrayList<>(original.getUriResourceParts());
copySystemQueryOptions();
} else {
this.original = null;
this.pathParts = new ArrayList<>();
}
}
JPAUriInfoResourceImpl(@Nullable final UriInfoResource original, final List<UriResourcePartTyped> list) {
this.original = original;
this.pathParts = new ArrayList<>(list);
if (original != null)
copySystemQueryOptions();
}
@Override
public List<CustomQueryOption> getCustomQueryOptions() {
return original.getCustomQueryOptions();
}
@Override
public List<UriResource> getUriResourceParts() {
return Collections.unmodifiableList(pathParts);
}
@Override
public String getValueForAlias(final String alias) {
return original.getValueForAlias(alias);
}
@Override
public ExpandOption getExpandOption() {
return (ExpandOption) systemQueryOptions.get(SystemQueryOptionKind.EXPAND);
}
@Override
public FilterOption getFilterOption() {
return (FilterOption) systemQueryOptions.get(SystemQueryOptionKind.FILTER);
}
@Override
public FormatOption getFormatOption() {
return (FormatOption) systemQueryOptions.get(SystemQueryOptionKind.FORMAT);
}
@Override
public IdOption getIdOption() {
return (IdOption) systemQueryOptions.get(SystemQueryOptionKind.ID);
}
@Override
public CountOption getCountOption() {
return (CountOption) systemQueryOptions.get(SystemQueryOptionKind.COUNT);
}
@Override
public OrderByOption getOrderByOption() {
return (OrderByOption) systemQueryOptions.get(SystemQueryOptionKind.ORDERBY);
}
@Override
public SearchOption getSearchOption() {
return (SearchOption) systemQueryOptions.get(SystemQueryOptionKind.SEARCH);
}
@Override
public SelectOption getSelectOption() {
return (SelectOption) systemQueryOptions.get(SystemQueryOptionKind.SELECT);
}
@Override
public SkipOption getSkipOption() {
return (SkipOption) systemQueryOptions.get(SystemQueryOptionKind.SKIP);
}
@Override
public SkipTokenOption getSkipTokenOption() {
return (SkipTokenOption) systemQueryOptions.get(SystemQueryOptionKind.SKIPTOKEN);
}
@Override
public TopOption getTopOption() {
return (TopOption) systemQueryOptions.get(SystemQueryOptionKind.TOP);
}
@Override
public ApplyOption getApplyOption() {
return (ApplyOption) systemQueryOptions.get(SystemQueryOptionKind.APPLY);
}
@Override
public DeltaTokenOption getDeltaTokenOption() {
return (DeltaTokenOption) systemQueryOptions.get(SystemQueryOptionKind.DELTATOKEN);
}
@Override
public UriResource getLastResourcePart() {
return pathParts.get(pathParts.size() - 1);
}
void setSystemQueryOption(final SystemQueryOption option) {
systemQueryOptions.put(option.getKind(), option);
}
void removeSystemQueryOption(final SystemQueryOptionKind kind) {
systemQueryOptions.remove(kind);
}
void setUriResourceParts(final List<UriResource> newResourceParts) {
pathParts = newResourceParts;
}
public void addUriResourceParts(final UriResource resource) {
pathParts.add(resource);
}
private void copySystemQueryOptions() {
copySystemQueryOption(SystemQueryOptionKind.EXPAND, original.getExpandOption());
copySystemQueryOption(SystemQueryOptionKind.FILTER, original.getFilterOption());
copySystemQueryOption(SystemQueryOptionKind.FORMAT, original.getFormatOption());
copySystemQueryOption(SystemQueryOptionKind.ID, original.getIdOption());
copySystemQueryOption(SystemQueryOptionKind.COUNT, original.getCountOption());
copySystemQueryOption(SystemQueryOptionKind.DELTATOKEN, original.getDeltaTokenOption());
copySystemQueryOption(SystemQueryOptionKind.ORDERBY, original.getOrderByOption());
copySystemQueryOption(SystemQueryOptionKind.SEARCH, original.getSearchOption());
copySystemQueryOption(SystemQueryOptionKind.SELECT, original.getSelectOption());
copySystemQueryOption(SystemQueryOptionKind.SKIP, original.getSkipOption());
copySystemQueryOption(SystemQueryOptionKind.SKIPTOKEN, original.getSkipTokenOption());
copySystemQueryOption(SystemQueryOptionKind.TOP, original.getTopOption());
copySystemQueryOption(SystemQueryOptionKind.APPLY, original.getApplyOption());
}
private void copySystemQueryOption(final SystemQueryOptionKind kind, final SystemQueryOption systemQueryOption) {
if (systemQueryOption != null)
systemQueryOptions.put(kind, systemQueryOption);
}
}
| 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/src/main/java/com/sap/olingo/jpa/processor/core/uri/JPAExpandItem.java | jpa/odata-jpa-processor/src/main/java/com/sap/olingo/jpa/processor/core/uri/JPAExpandItem.java | package com.sap.olingo.jpa.processor.core.uri;
import java.util.List;
import javax.annotation.Nonnull;
import org.apache.olingo.commons.api.edm.EdmType;
import org.apache.olingo.server.api.uri.UriInfoResource;
import org.apache.olingo.server.api.uri.UriResourcePartTyped;
import org.apache.olingo.server.api.uri.queryoption.ApplyOption;
import org.apache.olingo.server.api.uri.queryoption.CountOption;
import org.apache.olingo.server.api.uri.queryoption.ExpandItem;
import org.apache.olingo.server.api.uri.queryoption.ExpandOption;
import org.apache.olingo.server.api.uri.queryoption.FilterOption;
import org.apache.olingo.server.api.uri.queryoption.LevelsExpandOption;
import org.apache.olingo.server.api.uri.queryoption.OrderByOption;
import org.apache.olingo.server.api.uri.queryoption.SearchOption;
import org.apache.olingo.server.api.uri.queryoption.SelectOption;
import org.apache.olingo.server.api.uri.queryoption.SkipOption;
import org.apache.olingo.server.api.uri.queryoption.TopOption;
class JPAExpandItem implements ExpandItem {
private final ExpandItem original;
private final LevelsExpandOption levelsOption;
private final UriInfoResource uriInfo;
private final ExpandOption expandOption;
private final boolean isStar;
JPAExpandItem(@Nonnull final ExpandItem item, final LevelsExpandOption levelsOption) {
this.original = item;
this.levelsOption = levelsOption;
this.uriInfo = item.getResourcePath();
this.expandOption = original.getExpandOption();
this.isStar = item.isStar();
}
JPAExpandItem(@Nonnull final ExpandItem item, final List<UriResourcePartTyped> navigation,
final LevelsExpandOption levels) {
this.original = item;
this.levelsOption = null;
if (levels != null
&& (levels.getValue() > 0 || levels.isMax()))
this.expandOption = new JPAExpandOption(levels);
else
this.expandOption = null;
this.uriInfo = new JPAUriInfoResourceImpl(item.getResourcePath(), navigation.subList(1, navigation.size()));
this.isStar = false;
}
public JPAExpandItem(final ExpandItem item, final ExpandOption expandOption) {
this.original = item;
this.levelsOption = item.getLevelsOption();
this.uriInfo = item.getResourcePath();
this.expandOption = expandOption;
this.isStar = item.isStar();
}
public JPAExpandItem(final LevelsExpandOption levels) {
this.original = null;
this.levelsOption = levels;
this.uriInfo = new JPAUriInfoResourceImpl(null);
this.expandOption = null;
this.isStar = true;
}
@Override
public LevelsExpandOption getLevelsOption() {
return levelsOption;
}
@Override
public FilterOption getFilterOption() {
return original == null ? null : original.getFilterOption();
}
@Override
public SearchOption getSearchOption() {
return original == null ? null : original.getSearchOption();
}
@Override
public OrderByOption getOrderByOption() {
return original == null ? null : original.getOrderByOption();
}
@Override
public SkipOption getSkipOption() {
return original == null ? null : original.getSkipOption();
}
@Override
public TopOption getTopOption() {
return original == null ? null : original.getTopOption();
}
@Override
public CountOption getCountOption() {
return original == null ? null : original.getCountOption();
}
@Override
public SelectOption getSelectOption() {
return original == null ? null : original.getSelectOption();
}
@Override
public ExpandOption getExpandOption() {
return expandOption;
}
@Override
public ApplyOption getApplyOption() {
return original == null ? null : original.getApplyOption();
}
/**
* Path of the $expand. E.g. Children in case of .../AdministrativeDivisions?$expand=Children. It is empty for
* $expand=*
* @return
*/
@Override
public UriInfoResource getResourcePath() {
return uriInfo;
}
@Override
public boolean isStar() {
return isStar;
}
@Override
public boolean isRef() {
return original != null && original.isRef();
}
@Override
public boolean hasCountPath() {
return original != null && original.hasCountPath();
}
@Override
public EdmType getStartTypeFilter() {
return original == null ? null : original.getStartTypeFilter();
}
}
| 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/src/main/java/com/sap/olingo/jpa/processor/core/uri/JPAUriInfoResource.java | jpa/odata-jpa-processor/src/main/java/com/sap/olingo/jpa/processor/core/uri/JPAUriInfoResource.java | package com.sap.olingo.jpa.processor.core.uri;
import org.apache.olingo.server.api.uri.UriInfoResource;
import org.apache.olingo.server.api.uri.UriResource;
public interface JPAUriInfoResource extends UriInfoResource {
public UriResource getLastResourcePart();
}
| 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/src/main/java/com/sap/olingo/jpa/processor/core/uri/JPASkipOptionImpl.java | jpa/odata-jpa-processor/src/main/java/com/sap/olingo/jpa/processor/core/uri/JPASkipOptionImpl.java | package com.sap.olingo.jpa.processor.core.uri;
import org.apache.olingo.server.api.uri.queryoption.SkipOption;
import org.apache.olingo.server.api.uri.queryoption.SystemQueryOptionKind;
public record JPASkipOptionImpl(int value) implements SkipOption {
@Override
public String getName() {
return null;
}
@Override
public String getText() {
return String.valueOf(value);
}
@Override
public int getValue() {
return value;
}
@Override
public SystemQueryOptionKind getKind() {
return SystemQueryOptionKind.SKIP;
}
}
| 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/src/main/java/com/sap/olingo/jpa/processor/core/uri/JPAUriResourceEntitySetImpl.java | jpa/odata-jpa-processor/src/main/java/com/sap/olingo/jpa/processor/core/uri/JPAUriResourceEntitySetImpl.java | package com.sap.olingo.jpa.processor.core.uri;
import java.util.ArrayList;
import java.util.List;
import org.apache.olingo.commons.api.edm.EdmEntitySet;
import org.apache.olingo.commons.api.edm.EdmEntityType;
import org.apache.olingo.commons.api.edm.EdmType;
import org.apache.olingo.server.api.uri.UriParameter;
import org.apache.olingo.server.api.uri.UriResourceEntitySet;
import org.apache.olingo.server.api.uri.UriResourceKind;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAPath;
import com.sap.olingo.jpa.processor.core.api.JPAODataPageExpandInfo;
class JPAUriResourceEntitySetImpl implements UriResourceEntitySet {
private final UriResourceEntitySet original;
private final List<UriParameter> keyPredicates;
public JPAUriResourceEntitySetImpl(final UriResourceEntitySet uriResource,
final JPAODataPageExpandInfo jpaODataPageExpandInfo) {
this.original = uriResource;
final var keys = uriResource.getEntityType().getKeyPropertyRefs();
final var keyValues = jpaODataPageExpandInfo.keyPath().split(JPAPath.PATH_SEPARATOR);
this.keyPredicates = new ArrayList<>(keys.size());
for (int i = 0; i < keys.size(); i++) {
keyPredicates.add(new JPAUriParameterImpl(keys.get(i), keyValues[i]));
}
}
@Override
public EdmType getType() {
return original.getType();
}
@Override
public boolean isCollection() {
return false;
}
@Override
public String getSegmentValue(final boolean includeFilters) {
return original.getSegmentValue(includeFilters);
}
@Override
public String toString(final boolean includeFilters) {
return original.toString(includeFilters);
}
@Override
public UriResourceKind getKind() {
return original.getKind();
}
@Override
public String getSegmentValue() {
return original.getSegmentValue();
}
@Override
public EdmEntitySet getEntitySet() {
return original.getEntitySet();
}
@Override
public EdmEntityType getEntityType() {
return original.getEntityType();
}
@Override
public List<UriParameter> getKeyPredicates() {
return keyPredicates;
}
@Override
public EdmType getTypeFilterOnCollection() {
return original.getTypeFilterOnCollection();
}
@Override
public EdmType getTypeFilterOnEntry() {
return original.getTypeFilterOnEntry();
}
}
| 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/src/main/java/com/sap/olingo/jpa/processor/core/uri/JPAUriResourceNavigationImpl.java | jpa/odata-jpa-processor/src/main/java/com/sap/olingo/jpa/processor/core/uri/JPAUriResourceNavigationImpl.java | package com.sap.olingo.jpa.processor.core.uri;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import javax.annotation.Nonnull;
import org.apache.olingo.commons.api.edm.EdmNavigationProperty;
import org.apache.olingo.commons.api.edm.EdmType;
import org.apache.olingo.server.api.uri.UriParameter;
import org.apache.olingo.server.api.uri.UriResourceKind;
import org.apache.olingo.server.api.uri.UriResourceNavigation;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAPath;
public class JPAUriResourceNavigationImpl implements UriResourceNavigation {
private final EdmNavigationProperty navigationProperty;
private final List<UriParameter> keyPredicates;
public JPAUriResourceNavigationImpl(@Nonnull final EdmNavigationProperty edmNavigationProperty) {
this.navigationProperty = Objects.requireNonNull(edmNavigationProperty, "EdmNavigationProperty not provided");
keyPredicates = Collections.emptyList();
}
public JPAUriResourceNavigationImpl(@Nonnull final EdmNavigationProperty edmNavigationProperty,
@Nonnull final String keyPath) {
this.navigationProperty = Objects.requireNonNull(edmNavigationProperty, "EdmNavigationProperty not provided");
final var keys = edmNavigationProperty.getType().getKeyPropertyRefs();
final var keyValues = Objects.requireNonNull(keyPath).split(JPAPath.PATH_SEPARATOR);
this.keyPredicates = new ArrayList<>(keys.size());
for (int i = 0; i < keys.size(); i++) {
keyPredicates.add(new JPAUriParameterImpl(keys.get(i), keyValues[i]));
}
}
@Override
public String getSegmentValue(final boolean includeFilters) {
return null;
}
@Override
public String toString(final boolean includeFilters) {
return toString();
}
@Override
public UriResourceKind getKind() {
return UriResourceKind.navigationProperty;
}
@Override
public EdmNavigationProperty getProperty() {
return navigationProperty;
}
@Override
public EdmType getType() {
return navigationProperty.getType();
}
@Override
public boolean isCollection() {
return navigationProperty.isCollection() && keyPredicates.isEmpty();
}
@Override
public String getSegmentValue() {
return navigationProperty.getName();
}
@Override
public EdmType getTypeFilterOnCollection() {
return null;
}
@Override
public EdmType getTypeFilterOnEntry() {
return null;
}
@Override
public List<UriParameter> getKeyPredicates() {
return keyPredicates;
}
@Override
public String toString() {
return getSegmentValue();
}
}
| 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/src/main/java/com/sap/olingo/jpa/processor/core/uri/JPASkipTokenOptionImpl.java | jpa/odata-jpa-processor/src/main/java/com/sap/olingo/jpa/processor/core/uri/JPASkipTokenOptionImpl.java | package com.sap.olingo.jpa.processor.core.uri;
import org.apache.olingo.server.api.uri.queryoption.SkipTokenOption;
import org.apache.olingo.server.api.uri.queryoption.SystemQueryOptionKind;
record JPASkipTokenOptionImpl(String skipToken) implements SkipTokenOption {
@Override
public SystemQueryOptionKind getKind() {
return SystemQueryOptionKind.SKIPTOKEN;
}
@Override
public String getName() {
return null;
}
@Override
public String getText() {
return skipToken;
}
@Override
public String getValue() {
return skipToken;
}
}
| 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/src/main/java/com/sap/olingo/jpa/processor/core/uri/JPAUriInfoFactory.java | jpa/odata-jpa-processor/src/main/java/com/sap/olingo/jpa/processor/core/uri/JPAUriInfoFactory.java | package com.sap.olingo.jpa.processor.core.uri;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.apache.olingo.commons.api.edm.EdmProperty;
import org.apache.olingo.commons.api.edm.EdmStructuredType;
import org.apache.olingo.server.api.uri.UriInfoResource;
import org.apache.olingo.server.api.uri.UriResource;
import org.apache.olingo.server.api.uri.UriResourceComplexProperty;
import org.apache.olingo.server.api.uri.UriResourceEntitySet;
import org.apache.olingo.server.api.uri.UriResourceKind;
import org.apache.olingo.server.api.uri.UriResourceNavigation;
import org.apache.olingo.server.api.uri.UriResourcePartTyped;
import org.apache.olingo.server.api.uri.queryoption.ExpandItem;
import org.apache.olingo.server.api.uri.queryoption.ExpandOption;
import org.apache.olingo.server.api.uri.queryoption.LevelsExpandOption;
import org.apache.olingo.server.api.uri.queryoption.SystemQueryOption;
import org.apache.olingo.server.api.uri.queryoption.SystemQueryOptionKind;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAPath;
import com.sap.olingo.jpa.processor.core.api.JPAODataPage;
import com.sap.olingo.jpa.processor.core.api.JPAODataPageExpandInfo;
public class JPAUriInfoFactory {
private final JPAODataPage page;
public JPAUriInfoFactory(@Nonnull final JPAODataPage page) {
super();
this.page = page;
}
public JPAUriInfoResource build() {
if (page.expandInformation().isEmpty())
// Standard pagination not resolving the $levels, as JPA Processor supports ODatas max option,
// so depth is not known up-front and a late resolution has to be done anyhow. This also prevent the early
// resolution of *
return new JPAUriInfoBuilder(page.uriInfo())
.withTop(page.top())
.withSkip(page.skip())
.withSkipToken(page.skipToken())
.build();
else
return new JPAUriInfoBuilder(page.uriInfo())
.withResolvedStars(page.expandInformation())
.withExpandInfo(page.expandInformation())
.withExpandOrderBy()
.withTop(page.top())
.withSkip(page.skip())
.withSkipToken(page.skipToken())
.build();
}
private static class JPAUriInfoBuilder {
private final JPAUriInfoResourceImpl uriInfo;
private JPAUriInfoBuilder(final UriInfoResource original) {
uriInfo = new JPAUriInfoResourceImpl(original);
}
/**
* Searches for an expand star and resolves that path. This is only done for the depth of expandInfo
* <p>
* Examples:<br>
* ...Es?$expand=* => ...Es?$expand=Navigation1,Navigation2<br>
* ...Es?$expand=Navigation1($expand=*)
* => ...Es?$expand=Navigation1($expand=Navigation1_1,Navigation1_2)<br>
* ...Es?$expand=*($levels=2) =>
* ...Es?$expand=Navigation1($expand=Navigation1_1,Navigation1_2),Navigation2($expand=Navigation2_1,Navigation2_2)<br>
* ...Es?$expand=*($levels=max) =>
* ...Es?$expand=Navigation1($expand=Navigation1_1($levels=max),Navigation1_2($levels=max)),Navigation2($expand=Navigation2_1($levels=max),Navigation2_2($levels=max))<br>
* @param list
* @param expandInfo
* @return
*/
public JPAUriInfoBuilder withResolvedStars(final List<JPAODataPageExpandInfo> expandInfo) {
final var noLevels = expandInfo.size();
if (uriInfo.getExpandOption() != null) {
uriInfo.setSystemQueryOption(expandStarItems(uriInfo.getExpandOption(), uriInfo.getUriResourceParts(),
noLevels));
}
return this;
}
private ExpandOption expandStarItems(@Nonnull final ExpandOption expandOption,
final List<UriResource> parentResourceParts, final int noLevels) {
final List<ExpandItem> items = new ArrayList<>(expandOption.getExpandItems());
if (noLevels <= 0)
return new JPAExpandOption(expandOption, items);
for (int i = 0; i < items.size(); i++) {
final var item = items.get(i);
if (item.isStar()) {
final var last = parentResourceParts.get(parentResourceParts.size() - 1);
final LevelsExpandOption levels = getLevelsExpandOption(item);
final List<ExpandItem> newItems = expandNavigation(item, (UriResourcePartTyped) last, levels);
items.remove(i);
items.addAll(newItems);
i--; // NOSONAR
} else if (item.getExpandOption() != null) {
items.set(i, new JPAExpandItem(item, expandStarItems(item.getExpandOption(), item.getResourcePath()
.getUriResourceParts(), noLevels - 1)));
}
}
return new JPAExpandOption(expandOption, items);
}
private LevelsExpandOption getLevelsExpandOption(final ExpandItem item) {
final var levels = item.getLevelsOption();
if (levels != null) {
return new JPALevelsExpandOption(levels).levelResolved();
}
return null;
}
/**
* The uri info conversion based on an expand. An expand gets order by the foreign key. This has be rebuild.
* @return
*/
public JPAUriInfoBuilder withExpandOrderBy() {
return this;
}
/**
* Converts an uri info according to the information provided by expandInfo.
* <p>
* Examples:<br>
* ...Es?$expand=Navigation => ...Es(key)/Navigation<br>
* ...Singleton?$expand=Navigation =>
* ...Singleton(key)/Navigation<br>
* ...Es/Navigation1?$expand=Navigation2 => ...Es(key)/Navigation1/Navigation2<br>
* ...Es?$expand=Navigation1($expand=Navigation2) => ...Es(key)/Navigation1(key)/Navigation2 //option<br>
* ...Es?$expand=Navigation1,Navigation2) => ...Es(key)/Navigation1 //option<br>
* ...Es?$expand=Navigation1($levels=2) => ...Es(key)/Navigation1?$expand=Navigation1<br>
* ...Es?$expand=Navigation1($levels=max) => ...Es(key)/Navigation1?$expand=Navigation1($levels=max)
* @param expandInfo
* @return
*/
public JPAUriInfoBuilder withExpandInfo(final List<JPAODataPageExpandInfo> expandInfo) {
final List<UriResource> newResourceParts = new ArrayList<>(uriInfo.getUriResourceParts());
JPALevelsExpandOption levelsOption = null;
var expandOption = uriInfo.getExpandOption();
var parts = uriInfo.getUriResourceParts();
ExpandItem lastItem = null;
for (final var info : expandInfo) {
if (lastItem != null) {
final var lastIndex = newResourceParts.size() - 1;
newResourceParts.set(lastIndex, new JPAUriResourceNavigationImpl(((UriResourceNavigation) newResourceParts
.get(lastIndex)).getProperty(), info.keyPath()));
}
final var parentParts = parts;
lastItem = expandOption.getExpandItems().stream()
.filter(item -> matchesNavigationName(info, item, parentParts))
.findFirst()
.orElseThrow(() -> new IllegalStateException("Provided uri info does not contain an expand of " + info
.navigationPropertyPath()));
newResourceParts.addAll(lastItem.getResourcePath().getUriResourceParts());
if (lastItem.getLevelsOption() == null) {
parts = expandOption.getExpandItems().get(0).getResourcePath().getUriResourceParts();
expandOption = expandOption.getExpandItems().get(0).getExpandOption();
} else {
levelsOption = new JPALevelsExpandOption(lastItem.getLevelsOption());
levelsOption.levelResolved();
expandOption = new JPAExpandOption(expandOption, levelsOption);
}
}
if (levelsOption != null && levelsOption.getValue() == 0 && !levelsOption.isMax())
expandOption = null;
if (lastItem != null) {
setOption(lastItem.getFilterOption(), SystemQueryOptionKind.FILTER);
setOption(lastItem.getOrderByOption(), SystemQueryOptionKind.ORDERBY);
setOption(lastItem.getSearchOption(), SystemQueryOptionKind.SEARCH);
setOption(lastItem.getSelectOption(), SystemQueryOptionKind.SELECT);
setOption(expandOption, SystemQueryOptionKind.EXPAND);
}
if (newResourceParts.get(0).getKind() == UriResourceKind.entitySet)
newResourceParts.set(0, new JPAUriResourceEntitySetImpl((UriResourceEntitySet) newResourceParts.get(0),
expandInfo.get(0)));
uriInfo.setUriResourceParts(newResourceParts);
return this;
}
public JPAUriInfoBuilder withSkipToken(@Nullable final Object skipToken) {
if (skipToken == null)
uriInfo.removeSystemQueryOption(SystemQueryOptionKind.SKIPTOKEN);
else
uriInfo.setSystemQueryOption(new JPASkipTokenOptionImpl(skipToken.toString()));
return this;
}
JPAUriInfoBuilder withTop(final int top) {
if (top != Integer.MAX_VALUE)
uriInfo.setSystemQueryOption(new JPATopOptionImpl(top));
return this;
}
JPAUriInfoBuilder withSkip(final int skip) {
if (skip != 0)
uriInfo.setSystemQueryOption(new JPASkipOptionImpl(skip));
return this;
}
JPAUriInfoResource build() {
return uriInfo;
}
private void setOption(final SystemQueryOption option, final SystemQueryOptionKind kind) {
if (option == null)
uriInfo.removeSystemQueryOption(kind);
else
uriInfo.setSystemQueryOption(option);
}
private boolean matchesNavigationName(final JPAODataPageExpandInfo info, final ExpandItem item,
final List<UriResource> parentParts) {
final var resourceParts = item.getResourcePath().getUriResourceParts();
final var nameParts = info.navigationPropertyPath().split(JPAPath.PATH_SEPARATOR);
final List<UriResourceComplexProperty> complexParentParts = parentParts.stream()
.filter(part -> part.getKind().equals(UriResourceKind.complexProperty))
.map(UriResourceComplexProperty.class::cast)
.toList();
if (resourceParts.size() + complexParentParts.size() != nameParts.length)
return false;
// Solve issue with complex from super ordinate part being part of info path
for (int i = 0; i < complexParentParts.size(); i++) {
if (!complexParentParts.get(i).getSegmentValue().equals(nameParts[i])) {
return false;
}
}
final int complex = complexParentParts.size();
for (int i = complex; i < nameParts.length; i++) {
if (!resourceParts.get(i - complex).getSegmentValue().equals(nameParts[i]))
return false;
}
return true;
}
private List<ExpandItem> expandNavigation(final ExpandItem item, final UriResourcePartTyped last,
final LevelsExpandOption levels) {
final List<List<UriResourcePartTyped>> pathList = new ArrayList<>();
pathList.add(List.of(last));
getAllStructuredTypes(pathList, pathList.get(0));
return pathList.stream()
.map(this::getAllNavigationProperties)
.flatMap(Collection::stream)
.map(navigation -> new JPAExpandItem(item, navigation, levels))
.map(i -> (ExpandItem) i)
.toList();
}
private void getAllStructuredTypes(final List<List<UriResourcePartTyped>> pathList,
final List<UriResourcePartTyped> parentPath) {
final var parentType = ((EdmStructuredType) parentPath.get(parentPath.size() - 1).getType());
parentType.getPropertyNames().stream()
.map(parentType::getProperty)
.filter(property -> property.getType() instanceof EdmStructuredType)
.map(EdmProperty.class::cast)
.map(JPAUriResourceComplexProperty::new)
.forEach(type -> {
final List<UriResourcePartTyped> path = new ArrayList<>(parentPath);
path.add(type);
pathList.add(path);
this.getAllStructuredTypes(pathList, path);
});
}
private List<List<UriResourcePartTyped>> getAllNavigationProperties(final List<UriResourcePartTyped> parentPath) {
final var last = (EdmStructuredType) parentPath.get(parentPath.size() - 1).getType();
final List<List<UriResourcePartTyped>> pathList = new ArrayList<>();
last.getNavigationPropertyNames().stream()
.map(last::getNavigationProperty)
.map(JPAUriResourceNavigationImpl::new)
.forEach(navigation -> {
final List<UriResourcePartTyped> path = new ArrayList<>(parentPath);
path.add(navigation);
pathList.add(path);
});
return pathList;
}
}
}
| 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/src/main/java/com/sap/olingo/jpa/processor/core/uri/JPATopOptionImpl.java | jpa/odata-jpa-processor/src/main/java/com/sap/olingo/jpa/processor/core/uri/JPATopOptionImpl.java | package com.sap.olingo.jpa.processor.core.uri;
import org.apache.olingo.server.api.uri.queryoption.SystemQueryOptionKind;
import org.apache.olingo.server.api.uri.queryoption.TopOption;
public record JPATopOptionImpl(int value) implements TopOption {
@Override
public SystemQueryOptionKind getKind() {
return SystemQueryOptionKind.TOP;
}
@Override
public String getName() {
return null;
}
@Override
public String getText() {
return String.valueOf(value);
}
@Override
public int getValue() {
return 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-processor/src/main/java/com/sap/olingo/jpa/processor/core/uri/JPALevelsExpandOption.java | jpa/odata-jpa-processor/src/main/java/com/sap/olingo/jpa/processor/core/uri/JPALevelsExpandOption.java | package com.sap.olingo.jpa.processor.core.uri;
import org.apache.olingo.server.api.uri.queryoption.LevelsExpandOption;
class JPALevelsExpandOption implements LevelsExpandOption {
private final boolean isMax;
private int value = 0;
JPALevelsExpandOption(final LevelsExpandOption levelsOption) {
this.isMax = levelsOption.isMax();
this.value = levelsOption.getValue();
}
@Override
public boolean isMax() {
return isMax;
}
@Override
public int getValue() {
return value;
}
LevelsExpandOption levelResolved() {
if (value > 0)
value -= 1;
return this;
}
}
| 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/src/main/java/com/sap/olingo/jpa/processor/core/uri/JPAUriParameterImpl.java | jpa/odata-jpa-processor/src/main/java/com/sap/olingo/jpa/processor/core/uri/JPAUriParameterImpl.java | package com.sap.olingo.jpa.processor.core.uri;
import org.apache.olingo.commons.api.edm.EdmKeyPropertyRef;
import org.apache.olingo.commons.core.edm.primitivetype.EdmString;
import org.apache.olingo.server.api.uri.UriParameter;
import org.apache.olingo.server.api.uri.queryoption.expression.Expression;
record JPAUriParameterImpl(EdmKeyPropertyRef propertyReference, String value) implements UriParameter {
@Override
public String getAlias() {
return propertyReference.getAlias();
}
@Override
public String getText() {
if (propertyReference.getProperty().getType() instanceof EdmString)
return "'" + value + "'";
return value;
}
@Override
public Expression getExpression() {
return null;
}
@Override
public String getName() {
return propertyReference.getName();
}
@Override
public String getReferencedProperty() {
return 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/src/main/java/com/sap/olingo/jpa/processor/core/uri/JPAExpandOption.java | jpa/odata-jpa-processor/src/main/java/com/sap/olingo/jpa/processor/core/uri/JPAExpandOption.java | package com.sap.olingo.jpa.processor.core.uri;
import org.apache.olingo.server.api.uri.queryoption.ExpandItem;
import org.apache.olingo.server.api.uri.queryoption.ExpandOption;
import org.apache.olingo.server.api.uri.queryoption.LevelsExpandOption;
import org.apache.olingo.server.api.uri.queryoption.SystemQueryOptionKind;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
class JPAExpandOption implements ExpandOption {
private final ExpandOption original;
private final List<ExpandItem> expandItems;
JPAExpandOption(final ExpandOption expandOption, final LevelsExpandOption levelsOption) {
this.original = expandOption;
this.expandItems = new ArrayList<>(expandOption.getExpandItems());
final var lastIndex = this.expandItems.size() - 1;
this.expandItems.set(lastIndex, new JPAExpandItem(this.expandItems.get(lastIndex), levelsOption));
}
JPAExpandOption(ExpandOption expandOption, List<ExpandItem> expandItems) {
this.original = expandOption;
this.expandItems = expandItems;
}
public JPAExpandOption(LevelsExpandOption levels) {
this.original = null;
this.expandItems = Collections.singletonList(new JPAExpandItem(levels));
}
@Override
public SystemQueryOptionKind getKind() {
return SystemQueryOptionKind.EXPAND;
}
@Override
public String getName() {
return original.getName();
}
@Override
public String getText() {
return original.getText();
}
@Override
public List<ExpandItem> getExpandItems() {
return expandItems;
}
}
| 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/src/main/java/com/sap/olingo/jpa/processor/core/uri/JPAUriResourceComplexProperty.java | jpa/odata-jpa-processor/src/main/java/com/sap/olingo/jpa/processor/core/uri/JPAUriResourceComplexProperty.java | package com.sap.olingo.jpa.processor.core.uri;
import org.apache.olingo.commons.api.edm.EdmComplexType;
import org.apache.olingo.commons.api.edm.EdmProperty;
import org.apache.olingo.commons.api.edm.EdmType;
import org.apache.olingo.server.api.uri.UriResourceComplexProperty;
import org.apache.olingo.server.api.uri.UriResourceKind;
import org.apache.olingo.server.core.uri.UriResourceTypedImpl;
class JPAUriResourceComplexProperty extends UriResourceTypedImpl implements UriResourceComplexProperty {
private final EdmProperty property;
public JPAUriResourceComplexProperty(final EdmProperty property) {
super(UriResourceKind.complexProperty);
this.property = property;
}
@Override
public EdmProperty getProperty() {
return property;
}
@Override
public EdmComplexType getComplexType() {
return (EdmComplexType) getType();
}
@Override
public EdmComplexType getComplexTypeFilter() {
return (EdmComplexType) getTypeFilter();
}
@Override
public EdmType getType() {
return property.getType();
}
@Override
public boolean isCollection() {
return property.isCollection();
}
@Override
public String getSegmentValue() {
return property.getName();
}
}
| 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/src/main/java/com/sap/olingo/jpa/processor/core/filter/JPALambdaOperation.java | jpa/odata-jpa-processor/src/main/java/com/sap/olingo/jpa/processor/core/filter/JPALambdaOperation.java | package com.sap.olingo.jpa.processor.core.filter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import jakarta.persistence.criteria.Subquery;
import org.apache.olingo.server.api.ODataApplicationException;
import org.apache.olingo.server.api.uri.UriInfoResource;
import org.apache.olingo.server.api.uri.UriResource;
import org.apache.olingo.server.api.uri.UriResourceKind;
import org.apache.olingo.server.api.uri.UriResourceLambdaAll;
import org.apache.olingo.server.api.uri.UriResourceLambdaAny;
import org.apache.olingo.server.api.uri.queryoption.expression.Expression;
import org.apache.olingo.server.api.uri.queryoption.expression.Member;
import com.sap.olingo.jpa.processor.core.query.JPAAbstractQuery;
import com.sap.olingo.jpa.processor.core.query.JPAAbstractSubQuery;
import com.sap.olingo.jpa.processor.core.query.JPANavigationFilterQueryBuilder;
import com.sap.olingo.jpa.processor.core.query.JPANavigationPropertyInfo;
import com.sap.olingo.jpa.processor.core.query.JPANavigationPropertyInfoAccess;
abstract class JPALambdaOperation extends JPAExistsOperation {
protected final UriInfoResource member;
JPALambdaOperation(final JPAFilterComplierAccess jpaCompiler, final Member member) {
super(jpaCompiler);
this.member = member.getResourcePath();
}
@Override
protected SubQueryItem getExistsQuery() throws ODataApplicationException {
return new SubQueryItem(Collections.emptyList(), getSubQuery(determineExpression()));
}
@SuppressWarnings("unchecked")
protected final <S> Subquery<S> getSubQuery(final Expression expression)
throws ODataApplicationException {
// Add association root, which is only available for the first lambda expression
final List<UriResource> allUriResourceParts = new ArrayList<>();
if (uriResourceParts != null)
allUriResourceParts.addAll(uriResourceParts);
// Add association path
allUriResourceParts.addAll(member.getUriResourceParts());
// 1. Determine all relevant associations
final List<JPANavigationPropertyInfo> navigationPathList = determineAssociations(sd, allUriResourceParts);
JPAAbstractQuery parent = root;
final List<JPAAbstractSubQuery> queryList = new ArrayList<>();
// 2. Create the queries and roots
for (int i = navigationPathList.size() - 1; i >= 0; i--) {
final JPANavigationPropertyInfoAccess navigationInfo = navigationPathList.get(i);
if (i == 0) {
queryList.add(new JPANavigationFilterQueryBuilder(converter.cb)
.setOdata(odata)
.setServiceDocument(sd)
.setNavigationInfo(navigationInfo)
.setParent(parent)
.setEntityManager(em)
.setExpression(expression)
.setFrom(from)
.setParent(parent)
.setClaimsProvider(claimsProvider)
.setGroups(groups)
.build());
} else {
queryList.add(new JPANavigationFilterQueryBuilder(converter.cb)
.setOdata(odata)
.setServiceDocument(sd)
.setNavigationInfo(navigationInfo)
.setParent(parent)
.setEntityManager(em)
.setFrom(from)
.setParent(parent)
.setClaimsProvider(claimsProvider)
.build());
}
parent = queryList.get(queryList.size() - 1);
}
// 3. Create select statements
Subquery<?> childQuery = null;
for (int i = queryList.size() - 1; i >= 0; i--) {
childQuery = queryList.get(i).getSubQuery(childQuery, null, Collections.emptyList());
}
return (Subquery<S>) childQuery;
}
Expression determineExpression() {
for (final UriResource uriResource : member.getUriResourceParts()) {
if (uriResource.getKind() == UriResourceKind.lambdaAny)
return ((UriResourceLambdaAny) uriResource).getExpression();
else if (uriResource.getKind() == UriResourceKind.lambdaAll)
return ((UriResourceLambdaAll) uriResource).getExpression();
}
return 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/src/main/java/com/sap/olingo/jpa/processor/core/filter/JPAVisitor.java | jpa/odata-jpa-processor/src/main/java/com/sap/olingo/jpa/processor/core/filter/JPAVisitor.java | package com.sap.olingo.jpa.processor.core.filter;
import static com.sap.olingo.jpa.processor.core.exception.ODataJPAFilterException.MessageKeys.NOT_SUPPORTED_FILTER;
import static com.sap.olingo.jpa.processor.core.exception.ODataJPAFilterException.MessageKeys.NOT_SUPPORTED_OPERATOR;
import static com.sap.olingo.jpa.processor.core.exception.ODataJPAFilterException.MessageKeys.NOT_SUPPORTED_TRANSIENT;
import static org.apache.olingo.commons.api.http.HttpStatusCode.INTERNAL_SERVER_ERROR;
import static org.apache.olingo.commons.api.http.HttpStatusCode.NOT_IMPLEMENTED;
import java.util.List;
import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.From;
import jakarta.persistence.criteria.Predicate;
import org.apache.olingo.commons.api.edm.EdmEnumType;
import org.apache.olingo.commons.api.edm.EdmType;
import org.apache.olingo.server.api.OData;
import org.apache.olingo.server.api.ODataApplicationException;
import org.apache.olingo.server.api.uri.UriInfoResource;
import org.apache.olingo.server.api.uri.UriParameter;
import org.apache.olingo.server.api.uri.UriResource;
import org.apache.olingo.server.api.uri.UriResourceFunction;
import org.apache.olingo.server.api.uri.UriResourceKind;
import org.apache.olingo.server.api.uri.UriResourceNavigation;
import org.apache.olingo.server.api.uri.UriResourceProperty;
import org.apache.olingo.server.api.uri.queryoption.expression.BinaryOperatorKind;
import org.apache.olingo.server.api.uri.queryoption.expression.ExpressionVisitException;
import org.apache.olingo.server.api.uri.queryoption.expression.Literal;
import org.apache.olingo.server.api.uri.queryoption.expression.Member;
import org.apache.olingo.server.api.uri.queryoption.expression.MethodKind;
import org.apache.olingo.server.api.uri.queryoption.expression.UnaryOperatorKind;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAssociationPath;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAttribute;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPADataBaseFunction;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEntityType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEnumerationAttribute;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAFunction;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAJavaFunction;
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.core.api.JPAServiceDebugger;
import com.sap.olingo.jpa.processor.core.api.JPAServiceDebugger.JPARuntimeMeasurement;
import com.sap.olingo.jpa.processor.core.exception.ODataJPAFilterException;
import com.sap.olingo.jpa.processor.core.query.Utility;
class JPAVisitor implements JPAExpressionVisitor { // NOSONAR
/**
*
*/
private final JPAFilterComplierAccess jpaComplier;
private final JPAServiceDebugger debugger;
/**
* @param jpaFilterCrossComplier
*/
JPAVisitor(final JPAFilterComplierAccess jpaFilterCrossComplier) {
this.jpaComplier = jpaFilterCrossComplier;
this.debugger = jpaComplier.getDebugger();
}
@Override
public OData getOData() {
return jpaComplier.getOData();
}
@Override
public From<?, ?> getRoot() {
return jpaComplier.getRoot();
}
@Override
public JPAEntityType getEntityType() {
return jpaComplier.getJpaEntityType();
}
@Override
public JPAOperator visitAlias(final String aliasName) throws ExpressionVisitException, ODataApplicationException {
throw new ODataJPAFilterException(NOT_SUPPORTED_FILTER, NOT_IMPLEMENTED, "Alias");
}
@Override
public JPAOperator visitBinaryOperator(final BinaryOperatorKind operator, final JPAOperator left,
final JPAOperator right) throws ExpressionVisitException, ODataApplicationException {
try (JPARuntimeMeasurement measurement = debugger.newMeasurement(this, "visitBinaryOperator")) {
if (operator == BinaryOperatorKind.AND || operator == BinaryOperatorKind.OR) {
// Connecting operations have to be handled first, as JPANavigationOperation do not need special treatment
return new JPABooleanOperatorImp(this.jpaComplier.getConverter(), operator, (JPAExpression) left,
(JPAExpression) right);
}
if (left instanceof JPANavigationOperation || right instanceof JPANavigationOperation)
return handleBinaryWithNavigation(operator, left, right);
if (hasNavigation(left) || hasNavigation(right))
return new JPANavigationOperation(this.jpaComplier, operator, left, right);
if (operator == BinaryOperatorKind.EQ
|| operator == BinaryOperatorKind.NE
|| operator == BinaryOperatorKind.GE
|| operator == BinaryOperatorKind.GT
|| operator == BinaryOperatorKind.LT
|| operator == BinaryOperatorKind.LE
|| operator == BinaryOperatorKind.HAS) {
return new JPAComparisonOperatorImp<>(this.jpaComplier.getConverter(), operator, left, right);
}
if (operator == BinaryOperatorKind.ADD
|| operator == BinaryOperatorKind.SUB
|| operator == BinaryOperatorKind.MUL
|| operator == BinaryOperatorKind.DIV
|| operator == BinaryOperatorKind.MOD) {
return new JPAArithmeticOperatorImp(this.jpaComplier.getConverter(), operator, left, right);
}
}
throw new ODataJPAFilterException(NOT_SUPPORTED_OPERATOR, NOT_IMPLEMENTED, operator.name());
}
@Override
public JPAOperator visitBinaryOperator(final BinaryOperatorKind operator, final JPAOperator left,
final List<JPAOperator> right) throws ExpressionVisitException, ODataApplicationException {
if (hasNavigation(left))
return new JPANavigationInOperation(this.jpaComplier, operator, left, right);
if (operator == BinaryOperatorKind.IN)
return new JPAInOperatorImpl<>(this.jpaComplier.getConverter(), left, right);
throw new ODataJPAFilterException(NOT_SUPPORTED_OPERATOR, NOT_IMPLEMENTED, operator.name());
}
@Override
public JPAEnumerationOperator visitEnum(final EdmEnumType type, final List<String> enumValues)
throws ExpressionVisitException, ODataApplicationException {
try (JPARuntimeMeasurement measurement = debugger.newMeasurement(this, "visitEnum")) {
final JPAEnumerationAttribute jpaEnumerationAttribute = this.jpaComplier.getSd().getEnumType(type);
try {
if (jpaEnumerationAttribute == null)
throw new IllegalArgumentException(type.getFullQualifiedName().getFullQualifiedNameAsString() + " unknown");
if (!jpaEnumerationAttribute.isFlags() && enumValues.size() > 1)
throw new ODataJPAFilterException(NOT_SUPPORTED_FILTER, NOT_IMPLEMENTED,
"Collection of Enumerations if not flags");
} catch (final ODataJPAModelException | IllegalArgumentException e) {
throw new ODataJPAFilterException(e, INTERNAL_SERVER_ERROR);
}
return new JPAEnumerationOperator(this.jpaComplier.getSd().getEnumType(type), enumValues);
}
}
@Override
public JPAOperator visitLambdaExpression(final String lambdaFunction, final String lambdaVariable,
final org.apache.olingo.server.api.uri.queryoption.expression.Expression expression)
throws ExpressionVisitException, ODataApplicationException {
throw new ODataJPAFilterException(NOT_SUPPORTED_FILTER, NOT_IMPLEMENTED, "Lambda Expression");
}
@Override
public JPAOperator visitLambdaReference(final String variableName) throws ExpressionVisitException,
ODataApplicationException {
throw new ODataJPAFilterException(NOT_SUPPORTED_FILTER, NOT_IMPLEMENTED, "Lambda Reference");
}
@Override
public JPAOperator visitLiteral(final Literal literal) throws ExpressionVisitException, ODataApplicationException {
try (JPARuntimeMeasurement measurement = debugger.newMeasurement(this, "visitLiteral")) {
return new JPALiteralOperator(this.jpaComplier.getOData(), literal);
}
}
@Override
public JPAOperator visitMember(final Member member) throws ExpressionVisitException, ODataApplicationException {
try (JPARuntimeMeasurement measurement = debugger.newMeasurement(this, "visitMember")) {
final JPAPath attributePath = determineAttributePath(this.jpaComplier.getJpaEntityType(),
this.jpaComplier.getParent().getJpaEntity(), member, jpaComplier.getAssociation());
checkTransient(attributePath);
if (getLambdaType(member.getResourcePath()) == UriResourceKind.lambdaAny) {
return new JPALambdaAnyOperation(this.jpaComplier, member);
} else if (getLambdaType(member.getResourcePath()) == UriResourceKind.lambdaAll) {
return new JPALambdaAllOperation(this.jpaComplier, member);
} else if (isAggregation(member.getResourcePath())) {
return new JPAAggregationOperationImp(jpaComplier.getRoot(), jpaComplier.getConverter());
} else if (isCustomFunction(member.getResourcePath())) {
final UriResource resource = member.getResourcePath().getUriResourceParts().get(0);
final JPAFunction jpaFunction = this.jpaComplier.getSd().getFunction(
((UriResourceFunction) resource).getFunction());
if (jpaFunction instanceof final JPADataBaseFunction dbFunction) {
final List<UriParameter> odataParams = ((UriResourceFunction) resource).getParameters();
return new JPADBFunctionOperator(this, odataParams, dbFunction);
} else
return new JPAJavaFunctionOperator(this, (UriResourceFunction) resource, (JPAJavaFunction) jpaFunction);
}
jpaComplier.getWatchDog().ifPresent(watchDog -> watchDog.watch(attributePath));
return new JPAMemberOperator(this.jpaComplier.getRoot(), member, jpaComplier
.getAssociation(), this.jpaComplier.getGroups(), attributePath);
}
}
@Override
public JPAOperator visitMethodCall(final MethodKind methodCall, final List<JPAOperator> parameters)
throws ExpressionVisitException, ODataApplicationException {
try (JPARuntimeMeasurement measurement = debugger.newMeasurement(this, "visitMethodCall")) {
if (!parameters.isEmpty()) {
if (parameters.get(0) instanceof JPANavigationOperation ||
(parameters.size() == 2 && parameters.get(1) instanceof JPANavigationOperation))
throw new ODataJPAFilterException(NOT_SUPPORTED_FILTER, NOT_IMPLEMENTED,
"Nested method calls together with navigation");
if (hasNavigation(parameters.get(0)) || (parameters.size() == 2 && hasNavigation(parameters.get(1)))) {
return new JPANavigationOperation(this.jpaComplier, methodCall, parameters);
}
}
JPAMethodCall method = new JPAMethodCallImp(this.jpaComplier.getConverter(), methodCall, parameters);
if (method.get() instanceof Predicate)
method = new JPAMethodBasedExpression(this.jpaComplier.getConverter(), methodCall, parameters);
return method;
}
}
@Override
public JPAOperator visitTypeLiteral(final EdmType type) throws ExpressionVisitException, ODataApplicationException {
throw new ODataJPAFilterException(NOT_SUPPORTED_FILTER, NOT_IMPLEMENTED, "Type Literal");
}
@Override
public JPAOperator visitUnaryOperator(final UnaryOperatorKind operator, final JPAOperator operand)
throws ExpressionVisitException, ODataApplicationException {
try (JPARuntimeMeasurement measurement = debugger.newMeasurement(this, "visitUnaryOperator")) {
if (operator == UnaryOperatorKind.NOT) {
return new JPAUnaryBooleanOperatorImp(this.jpaComplier.getConverter(), operator, (JPAExpression) operand);
} else {
throw new ODataJPAFilterException(NOT_SUPPORTED_OPERATOR, NOT_IMPLEMENTED, operator.name());
}
}
}
CriteriaBuilder getCriteriaBuilder() {
return jpaComplier.getConverter().cb;
}
UriResourceKind getLambdaType(final UriInfoResource member) {
for (final UriResource r : member.getUriResourceParts()) {
if (r.getKind() == UriResourceKind.lambdaAny
|| r.getKind() == UriResourceKind.lambdaAll)
return r.getKind();
}
return null;
}
JPAServiceDocument getSd() {
return jpaComplier.getSd();
}
boolean hasNavigation(final JPAOperator operand) {
if (operand instanceof final JPAMemberOperator memberOperator) {
final List<UriResource> uriResourceParts = memberOperator.getMember().getResourcePath()
.getUriResourceParts();
for (int i = uriResourceParts.size() - 1; i >= 0; i--) {
if (uriResourceParts.get(i) instanceof UriResourceNavigation
|| (uriResourceParts.get(i) instanceof final UriResourceProperty resourceProperty
&& resourceProperty.isCollection()))
return true;
}
}
return false;
}
private JPAOperator handleBinaryWithNavigation(final BinaryOperatorKind operator, final JPAOperator left,
final JPAOperator right) throws ODataJPAFilterException {
if (left instanceof JPANavigationOperation && right instanceof JPANavigationOperation)
throw new ODataJPAFilterException(NOT_SUPPORTED_FILTER, NOT_IMPLEMENTED,
"Binary operations comparing two navigation");
if (left instanceof final JPANavigationOperation navigationOperation) {
return new JPANavigationOperation(operator, navigationOperation, (JPALiteralOperator) right, jpaComplier);
}
return new JPANavigationOperation(operator, (JPANavigationOperation) right, (JPALiteralOperator) left, jpaComplier);
}
private boolean isAggregation(final UriInfoResource resourcePath) {
return (resourcePath.getUriResourceParts().size() == 1
&& resourcePath.getUriResourceParts().get(0).getKind() == UriResourceKind.count);
}
private boolean isCustomFunction(final UriInfoResource resourcePath) {
return (!resourcePath.getUriResourceParts().isEmpty()
&& resourcePath.getUriResourceParts().get(0) instanceof UriResourceFunction);
}
private @Nullable JPAPath determineAttributePath(@Nullable final JPAEntityType jpaEntityType,
final JPAEntityType parentType, @Nonnull final Member member,
@Nullable final JPAAssociationPath jpaAssociationPath) throws ODataApplicationException {
if (jpaEntityType == null)
return null;
final String attributePathName = Utility.determinePropertyNavigationPath(member.getResourcePath()
.getUriResourceParts());
JPAPath selectItemPath = null;
try {
selectItemPath = jpaEntityType.getPath(attributePathName);
if (selectItemPath == null && jpaAssociationPath != null) {
selectItemPath = jpaAssociationPath.getSourceType().getPath(attributePathName.isEmpty()
? jpaAssociationPath.getAlias()
: (jpaAssociationPath.getAlias() + JPAPath.PATH_SEPARATOR + attributePathName));
}
} catch (final ODataJPAModelException e) {
throw new ODataJPAFilterException(e, INTERNAL_SERVER_ERROR);
}
return selectItemPath;
}
private void checkTransient(@Nullable final JPAPath attributePath) throws ODataApplicationException {
if (attributePath != null) {
final Optional<JPAAttribute> transientProperty = attributePath.getPath()
.stream()
.map(JPAAttribute.class::cast)
.filter(JPAAttribute::isTransient)
.findFirst();
if (transientProperty.isPresent())
throw new ODataJPAFilterException(NOT_SUPPORTED_TRANSIENT, NOT_IMPLEMENTED, attributePath.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/src/main/java/com/sap/olingo/jpa/processor/core/filter/JPAAbstractNavigationOperation.java | jpa/odata-jpa-processor/src/main/java/com/sap/olingo/jpa/processor/core/filter/JPAAbstractNavigationOperation.java | package com.sap.olingo.jpa.processor.core.filter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import jakarta.persistence.criteria.Expression;
import jakarta.persistence.criteria.From;
import jakarta.persistence.criteria.Path;
import jakarta.persistence.criteria.Subquery;
import org.apache.olingo.commons.api.edm.EdmType;
import org.apache.olingo.commons.api.http.HttpStatusCode;
import org.apache.olingo.server.api.ODataApplicationException;
import org.apache.olingo.server.api.uri.UriInfoResource;
import org.apache.olingo.server.api.uri.UriResource;
import org.apache.olingo.server.api.uri.UriResourceKind;
import org.apache.olingo.server.api.uri.UriResourceProperty;
import org.apache.olingo.server.api.uri.queryoption.expression.BinaryOperatorKind;
import org.apache.olingo.server.api.uri.queryoption.expression.ExpressionVisitor;
import org.apache.olingo.server.api.uri.queryoption.expression.Member;
import org.apache.olingo.server.api.uri.queryoption.expression.MethodKind;
import org.apache.olingo.server.api.uri.queryoption.expression.VisitableExpression;
import com.sap.olingo.jpa.processor.core.exception.ODataJPAFilterException;
import com.sap.olingo.jpa.processor.core.exception.ODataJPAIllegalAccessException;
import com.sap.olingo.jpa.processor.core.query.ExpressionUtility;
import com.sap.olingo.jpa.processor.core.query.JPAAbstractQuery;
import com.sap.olingo.jpa.processor.core.query.JPAAbstractSubQuery;
import com.sap.olingo.jpa.processor.core.query.JPAExpandItem;
import com.sap.olingo.jpa.processor.core.query.JPANavigationFilterQueryBuilder;
import com.sap.olingo.jpa.processor.core.query.JPANavigationPropertyInfo;
import com.sap.olingo.jpa.processor.core.query.JPANavigationPropertyInfoAccess;
/**
* In case the query result shall be filtered on an attribute of navigation target a sub-select will be generated.
*
* @author Oliver Grande
*
*/
abstract class JPAAbstractNavigationOperation extends JPAExistsOperation {
final BinaryOperatorKind operator;
final JPAMemberOperator jpaMember;
final MethodKind methodCall;
private VisitableExpression expression;
JPAAbstractNavigationOperation(final JPAFilterComplierAccess jpaComplier, final MethodKind methodCall,
final BinaryOperatorKind operator, final JPAMemberOperator jpaMember) {
super(jpaComplier);
this.operator = operator;
this.methodCall = methodCall;
this.jpaMember = jpaMember;
}
@Override
public Expression<Boolean> get() throws ODataApplicationException {
try {
final SubQueryItem existQuery = getExistsQuery();
return ExpressionUtility.createSubQueryBasedExpression(existQuery.query(), existQuery.jpaPath(), converter.cb,
expression);
} catch (final ODataJPAIllegalAccessException e) {
throw new ODataJPAFilterException(e, HttpStatusCode.INTERNAL_SERVER_ERROR);
}
}
@Override
public String getName() {
return operator != null ? operator.name() : methodCall.name();
}
@Override
SubQueryItem getExistsQuery() throws ODataApplicationException, ODataJPAIllegalAccessException {
final List<UriResource> allUriResourceParts = new ArrayList<>(uriResourceParts);
allUriResourceParts.addAll(jpaMember.getMember().getResourcePath().getUriResourceParts());
// 1. Determine all relevant associations
final List<JPANavigationPropertyInfo> navigationPathList = determineAssociations(sd, allUriResourceParts);
JPAAbstractQuery parent = root;
final List<JPAAbstractSubQuery> queryList = new ArrayList<>();
// 2. Create the queries and roots
for (int i = navigationPathList.size() - 1; i >= 0; i--) {
final JPANavigationPropertyInfoAccess navigationInfo = navigationPathList.get(i);
if (i == 0) {
expression = createExpression();
queryList.add(new JPANavigationFilterQueryBuilder(converter.cb)
.setOdata(odata)
.setServiceDocument(sd)
.setNavigationInfo(navigationInfo)
.setParent(parent)
.setEntityManager(em)
.setExpression(expression)
.setFrom(determineFrom(i, navigationPathList.size(), parent))
.setParent(parent)
.setClaimsProvider(claimsProvider)
.setGroups(groups)
.build());
} else {
queryList.add(new JPANavigationFilterQueryBuilder(converter.cb)
.setOdata(odata)
.setServiceDocument(sd)
.setNavigationInfo(navigationInfo)
.setParent(parent)
.setEntityManager(em)
.setFrom(determineFrom(i, navigationPathList.size(), parent))
.setParent(parent)
.setClaimsProvider(claimsProvider)
.build());
}
parent = queryList.get(queryList.size() - 1);
}
// 3. Create select statements
Subquery<List<Comparable<?>>> childQuery = null;
List<Path<Comparable<?>>> inPath = Collections.emptyList();
for (int i = queryList.size() - 1; i >= 0; i--) {
childQuery = queryList.get(i).getSubQuery(childQuery, expression, inPath);
inPath = queryList.get(i).getLeftPaths();
}
return new SubQueryItem(inPath, childQuery);
}
Member getMember() {
return new SubMember(jpaMember);
}
abstract VisitableExpression createExpression() throws ODataJPAFilterException;
private From<?, ?> determineFrom(final int i, final int size, final JPAAbstractQuery parent) {
return i == size - 1 ? from : parent.getRoot();
}
private static class SubMember implements Member {
private final JPAMemberOperator parentMember;
SubMember(final JPAMemberOperator parentMember) {
super();
this.parentMember = parentMember;
}
@Override
public <T> T accept(final ExpressionVisitor<T> visitor) throws ODataApplicationException {
return null;
}
@Override
public UriInfoResource getResourcePath() {
return new SubResource(parentMember);
}
@Override
public EdmType getStartTypeFilter() {
return null;
}
@Override
public EdmType getType() {
return null;
}
@Override
public boolean isCollection() {
return false;
}
}
private static class SubResource implements JPAExpandItem {
private final JPAMemberOperator parentMember;
public SubResource(final JPAMemberOperator member) {
super();
this.parentMember = member;
}
@Override
public List<UriResource> getUriResourceParts() {
final List<UriResource> result = new ArrayList<>();
final List<UriResource> source = parentMember.getMember().getResourcePath().getUriResourceParts();
for (int i = source.size() - 1; i > 0; i--) {
if (source.get(i).getKind() == UriResourceKind.navigationProperty
|| source.get(i).getKind() == UriResourceKind.entitySet
|| (source.get(i) instanceof final UriResourceProperty resourceProperty
&& resourceProperty.isCollection())) {
break;
}
result.add(0, source.get(i));
}
return result;
}
@Override
public String getValueForAlias(final String alias) {
return 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/src/main/java/com/sap/olingo/jpa/processor/core/filter/JPAExpressionOperator.java | jpa/odata-jpa-processor/src/main/java/com/sap/olingo/jpa/processor/core/filter/JPAExpressionOperator.java | package com.sap.olingo.jpa.processor.core.filter;
public interface JPAExpressionOperator extends JPAExpression {
public <E extends Enum<E>> Enum<E> getOperator();
}
| 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/src/main/java/com/sap/olingo/jpa/processor/core/filter/JPAEnumerationBasedOperator.java | jpa/odata-jpa-processor/src/main/java/com/sap/olingo/jpa/processor/core/filter/JPAEnumerationBasedOperator.java | package com.sap.olingo.jpa.processor.core.filter;
import com.sap.olingo.jpa.processor.core.exception.ODataJPAFilterException;
/**
* Main purpose of this interface is to increase testability of JPAEnumerationBasedOperator
* @author Oliver Grande
*
*/
public interface JPAEnumerationBasedOperator extends JPAPrimitiveTypeOperator {
Number getValue() throws ODataJPAFilterException;
} | 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/src/main/java/com/sap/olingo/jpa/processor/core/filter/JPABooleanOperatorImp.java | jpa/odata-jpa-processor/src/main/java/com/sap/olingo/jpa/processor/core/filter/JPABooleanOperatorImp.java | package com.sap.olingo.jpa.processor.core.filter;
import jakarta.persistence.criteria.Expression;
import org.apache.olingo.server.api.ODataApplicationException;
import org.apache.olingo.server.api.uri.queryoption.expression.BinaryOperatorKind;
class JPABooleanOperatorImp implements JPABooleanOperator {
private final JPAOperationConverter converter;
private final BinaryOperatorKind operator;
private final JPAExpression left;
private final JPAExpression right;
public JPABooleanOperatorImp(final JPAOperationConverter converter, final BinaryOperatorKind operator,
final JPAExpression left, final JPAExpression right) {
super();
this.converter = converter;
this.operator = operator;
this.left = left;
this.right = right;
}
/*
* (non-Javadoc)
*
* @see com.sap.olingo.jpa.processor.core.filter.JPABooleanOperator#get()
*/
@Override
public Expression<Boolean> get() throws ODataApplicationException {
return converter.convert(this);
}
/*
* (non-Javadoc)
*
* @see com.sap.olingo.jpa.processor.core.filter.JPABooleanOperator#getOperator()
*/
@SuppressWarnings("unchecked")
@Override
public BinaryOperatorKind getOperator() {
return operator;
}
/*
* (non-Javadoc)
*
* @see com.sap.olingo.jpa.processor.core.filter.JPABooleanOperator#getLeft()
*/
@Override
public Expression<Boolean> getLeft() throws ODataApplicationException {
return left.get();
}
/*
* (non-Javadoc)
*
* @see com.sap.olingo.jpa.processor.core.filter.JPABooleanOperator#getRight()
*/
@Override
public Expression<Boolean> getRight() throws ODataApplicationException {
return right.get();
}
@Override
public String getName() {
return operator.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-processor/src/main/java/com/sap/olingo/jpa/processor/core/filter/JPAAggregationOperation.java | jpa/odata-jpa-processor/src/main/java/com/sap/olingo/jpa/processor/core/filter/JPAAggregationOperation.java | package com.sap.olingo.jpa.processor.core.filter;
import org.apache.olingo.server.api.ODataApplicationException;
public interface JPAAggregationOperation extends JPAOperator {
@Override
public Object get() throws ODataApplicationException;
JPAFilterAggregationType getAggregation();
} | 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/src/main/java/com/sap/olingo/jpa/processor/core/filter/JPABinaryExpression.java | jpa/odata-jpa-processor/src/main/java/com/sap/olingo/jpa/processor/core/filter/JPABinaryExpression.java | package com.sap.olingo.jpa.processor.core.filter;
import org.apache.olingo.server.api.ODataApplicationException;
import org.apache.olingo.server.api.uri.queryoption.expression.BinaryOperatorKind;
import org.apache.olingo.server.api.uri.queryoption.expression.ExpressionVisitException;
import org.apache.olingo.server.api.uri.queryoption.expression.ExpressionVisitor;
import org.apache.olingo.server.api.uri.queryoption.expression.Literal;
import org.apache.olingo.server.api.uri.queryoption.expression.VisitableExpression;
public class JPABinaryExpression implements VisitableExpression {
private final BinaryOperatorKind operator;
private final VisitableExpression expression;
private final Literal literal;
public JPABinaryExpression(final VisitableExpression expression, final Literal literal,
final BinaryOperatorKind operator) {
this.operator = operator;
this.expression = expression;
this.literal = literal;
}
@Override
public <T> T accept(ExpressionVisitor<T> visitor) throws ExpressionVisitException, ODataApplicationException {
T localLeft = this.expression.accept(visitor);
T localRight = this.literal.accept(visitor);
return visitor.visitBinaryOperator(operator, localLeft, localRight);
}
}
| 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/src/main/java/com/sap/olingo/jpa/processor/core/filter/JPAOperator.java | jpa/odata-jpa-processor/src/main/java/com/sap/olingo/jpa/processor/core/filter/JPAOperator.java | package com.sap.olingo.jpa.processor.core.filter;
import org.apache.olingo.server.api.ODataApplicationException;
public interface JPAOperator {
public Object get() throws ODataApplicationException;
String getName();
} | 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/src/main/java/com/sap/olingo/jpa/processor/core/filter/JPANavigationInOperation.java | jpa/odata-jpa-processor/src/main/java/com/sap/olingo/jpa/processor/core/filter/JPANavigationInOperation.java | package com.sap.olingo.jpa.processor.core.filter;
import java.util.List;
import org.apache.olingo.server.api.uri.queryoption.expression.BinaryOperatorKind;
import org.apache.olingo.server.api.uri.queryoption.expression.Literal;
import org.apache.olingo.server.api.uri.queryoption.expression.MethodKind;
import org.apache.olingo.server.api.uri.queryoption.expression.VisitableExpression;
/**
* In case the query result shall be filtered on an attribute of navigation target a sub-select will be generated.
* <p>
* E.g.<br>
* - AdministrativeDivisions?$filter=Parent/ParentDivisionCode IN ('BE23', 'BE24')<br>
* @author Oliver Grande
*
*/
final class JPANavigationInOperation extends JPAAbstractNavigationOperation {
final List<Literal> operand;
JPANavigationInOperation(final JPAFilterComplierAccess jpaComplier, final BinaryOperatorKind operator,
final JPAOperator left, final List<JPAOperator> right) {
super(jpaComplier, (MethodKind) null, operator, (JPAMemberOperator) left);
this.operand = right.stream().map(a -> ((JPALiteralOperator) a).getLiteral()).toList();
}
@SuppressWarnings("unchecked")
@Override
public Enum<?> getOperator() {
return BinaryOperatorKind.IN;
}
@Override
VisitableExpression createExpression() {
return new JPAFilterExpression(getMember(), operand, operator);
}
@Override
public String toString() {
return "JPANavigationOperation [operator=" + operator + ", jpaMember=" + jpaMember + ", operand=" + operand
+ ", methodCall=" + methodCall + "]";
}
}
| 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/src/main/java/com/sap/olingo/jpa/processor/core/filter/JPAAggregationOperationImp.java | jpa/odata-jpa-processor/src/main/java/com/sap/olingo/jpa/processor/core/filter/JPAAggregationOperationImp.java | package com.sap.olingo.jpa.processor.core.filter;
import jakarta.persistence.criteria.Expression;
import jakarta.persistence.criteria.From;
import org.apache.olingo.server.api.ODataApplicationException;
class JPAAggregationOperationImp implements JPAAggregationOperation {
private final From<?, ?> root;
private final JPAOperationConverter converter;
public JPAAggregationOperationImp(final From<?, ?> root, final JPAOperationConverter converter) {
this.root = root;
this.converter = converter;
}
/*
* (non-Javadoc)
*
* @see com.sap.olingo.jpa.processor.core.filter.JPAAggregationOperation#get()
*/
@Override
public Object get() throws ODataApplicationException {
return converter.convert(this);
}
@Override
public JPAFilterAggregationType getAggregation() {
return JPAFilterAggregationType.COUNT;
}
@SuppressWarnings("unchecked")
<S> Expression<S> getPath() {
return (Expression<S>) root;
}
@Override
public String getName() {
return JPAFilterAggregationType.COUNT.name();
}
}
| 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.