1 package de.dlr.shepard.common.filters;
2
3 import static org.mockito.ArgumentMatchers.any;
4 import static org.mockito.Mockito.mock;
5 import static org.mockito.Mockito.never;
6 import static org.mockito.Mockito.verify;
7 import static org.mockito.Mockito.when;
8
9 import de.dlr.shepard.auth.permission.services.PermissionsService;
10 import de.dlr.shepard.auth.users.entities.User;
11 import de.dlr.shepard.common.neo4j.io.BasicEntityIO;
12 import de.dlr.shepard.common.subscription.entities.Subscription;
13 import de.dlr.shepard.common.subscription.services.SubscriptionService;
14 import de.dlr.shepard.common.util.AccessType;
15 import de.dlr.shepard.common.util.RequestMethod;
16 import io.quarkus.test.InjectMock;
17 import io.quarkus.test.component.QuarkusComponentTest;
18 import io.quarkus.test.component.SkipInject;
19 import jakarta.inject.Inject;
20 import jakarta.ws.rs.container.ContainerRequestContext;
21 import jakarta.ws.rs.container.ContainerResponseContext;
22 import jakarta.ws.rs.core.PathSegment;
23 import jakarta.ws.rs.core.UriInfo;
24 import java.net.URI;
25 import java.net.URISyntaxException;
26 import java.util.List;
27 import java.util.concurrent.ExecutorService;
28 import org.junit.jupiter.api.BeforeEach;
29 import org.junit.jupiter.api.Test;
30 import org.junit.jupiter.params.ParameterizedTest;
31 import org.junit.jupiter.params.provider.CsvSource;
32
33 @QuarkusComponentTest
34 public class SubscriptionFilterTest {
35
36 @InjectMock
37 UriInfo uriInfo;
38
39 @InjectMock
40 ContainerRequestContext request;
41
42 @InjectMock
43 ContainerResponseContext response;
44
45 @InjectMock
46 SubscriptionService service;
47
48 @InjectMock
49 PermissionsService permissionsService;
50
51 @InjectMock
52 ExecutorFactory executorFactory;
53
54 @InjectMock
55 ExecutorService executorService;
56
57 @Inject
58 SubscriptionFilter filter;
59
60 @BeforeEach
61 public void setUpUriInfo() throws URISyntaxException {
62 URI uri = new URI("http://my.url/test/200/sub");
63 when(uriInfo.getAbsolutePath()).thenReturn(uri);
64
65 var rootSeg = mock(PathSegment.class);
66 when(rootSeg.getPath()).thenReturn("test");
67 var idSeg = mock(PathSegment.class);
68 when(idSeg.getPath()).thenReturn("200");
69 var pathSeg = mock(PathSegment.class);
70 when(pathSeg.getPath()).thenReturn("sub");
71 when(uriInfo.getPathSegments()).thenReturn(List.of(rootSeg, idSeg, pathSeg));
72
73 when(request.getUriInfo()).thenReturn(uriInfo);
74 }
75
76 @BeforeEach
77 public void prepareSpy() {
78 when(executorFactory.getInstance()).thenReturn(executorService);
79 }
80
81 @Test
82 public void testFilterSucessful() {
83 User user = new User("bob");
84 Subscription sub = new Subscription(100L);
85 sub.setCallbackURL("http://callback.url/test");
86 sub.setName("MySub");
87 sub.setRequestMethod(RequestMethod.GET);
88 sub.setSubscribedURL("http://my.url/test/200/sub");
89 sub.setCreatedBy(user);
90 List<Subscription> subs = List.of(sub);
91 var entityIO = new BasicEntityIO() {
92 {
93 setId(200L);
94 }
95 };
96
97 when(request.getMethod()).thenReturn("GET");
98 when(response.getStatus()).thenReturn(200);
99 when(response.getEntity()).thenReturn(entityIO);
100 when(service.getMatchingSubscriptions(RequestMethod.GET)).thenReturn(subs);
101 when(permissionsService.isAllowed(request, AccessType.Read, "bob")).thenReturn(true);
102
103 filter.filter(request, response);
104 verify(executorService).execute(any());
105 }
106
107 @Test
108 public void testFilterNoId() {
109 User user = new User("bob");
110 Subscription sub = new Subscription();
111 sub.setCallbackURL("http://callback.url/test");
112 sub.setId(200L);
113 sub.setName("MySub");
114 sub.setRequestMethod(RequestMethod.GET);
115 sub.setSubscribedURL("http://my.url/test/200/sub");
116 sub.setCreatedBy(user);
117 List<Subscription> subs = List.of(sub);
118 Object noId = new Object();
119
120 when(request.getMethod()).thenReturn("GET");
121 when(response.getStatus()).thenReturn(200);
122 when(response.getEntity()).thenReturn(noId);
123 when(service.getMatchingSubscriptions(RequestMethod.GET)).thenReturn(subs);
124 when(permissionsService.isAllowed(request, AccessType.Read, "bob")).thenReturn(true);
125
126 filter.filter(request, response);
127 verify(executorService).execute(any());
128 }
129
130 @ParameterizedTest
131 @CsvSource({ "http://my.url/test2,200", "http://my.url/test/200/sub,100", "http://my.url/test/200/sub,400" })
132 public void testFilterNoExecution(@SkipInject String subscribedUrl, @SkipInject Integer statusCode) {
133 Subscription sub = new Subscription();
134 sub.setCallbackURL("http://callback.url/test");
135 sub.setId(200L);
136 sub.setName("MySub");
137 sub.setRequestMethod(RequestMethod.GET);
138 sub.setSubscribedURL(subscribedUrl);
139 List<Subscription> subs = List.of(sub);
140 Object noId = new Object();
141
142 when(request.getMethod()).thenReturn("GET");
143 when(response.getStatus()).thenReturn(statusCode);
144 when(response.getEntity()).thenReturn(noId);
145 when(service.getMatchingSubscriptions(RequestMethod.GET)).thenReturn(subs);
146
147 filter.filter(request, response);
148 verify(executorService, never()).execute(any());
149 }
150
151 @Test
152 public void testFilterNoPermissions() {
153 User user = new User("bob");
154 Subscription sub = new Subscription(100L);
155 sub.setCallbackURL("http://callback.url/test");
156 sub.setName("MySub");
157 sub.setRequestMethod(RequestMethod.GET);
158 sub.setSubscribedURL("http://my.url/test/200/sub");
159 sub.setCreatedBy(user);
160 List<Subscription> subs = List.of(sub);
161 var entityIO = new BasicEntityIO() {
162 {
163 setId(200L);
164 }
165 };
166
167 when(request.getMethod()).thenReturn("GET");
168 when(response.getStatus()).thenReturn(200);
169 when(response.getEntity()).thenReturn(entityIO);
170 when(service.getMatchingSubscriptions(RequestMethod.GET)).thenReturn(subs);
171 when(permissionsService.isAllowed(request, AccessType.Read, "bob")).thenReturn(false);
172
173 filter.filter(request, response);
174 verify(executorService, never()).execute(any());
175 }
176 }