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