git.basschouten.com Git - openhab-addons.git/blob

   1 /**
   2  * Copyright (c) 2010-2023 Contributors to the openHAB project
   3  *
   4  * See the NOTICE file(s) distributed with this work for additional
   5  * information.
   6  *
   7  * This program and the accompanying materials are made available under the
   8  * terms of the Eclipse Public License 2.0 which is available at
   9  * http://www.eclipse.org/legal/epl-2.0
  10  *
  11  * SPDX-License-Identifier: EPL-2.0
  12  */
  13 package org.openhab.binding.mielecloud.internal.webservice;
  14
  15 import static org.junit.jupiter.api.Assertions.assertEquals;
  16 import static org.mockito.ArgumentMatchers.*;
  17 import static org.mockito.Mockito.*;
  18
  19 import java.nio.charset.StandardCharsets;
  20 import java.util.ArrayList;
  21 import java.util.List;
  22 import java.util.Optional;
  23 import java.util.concurrent.TimeUnit;
  24
  25 import org.eclipse.jdt.annotation.NonNullByDefault;
  26 import org.eclipse.jdt.annotation.Nullable;
  27 import org.eclipse.jetty.client.HttpClient;
  28 import org.eclipse.jetty.client.api.Request;
  29 import org.eclipse.jetty.client.util.StringContentProvider;
  30 import org.eclipse.jetty.http.HttpMethod;
  31 import org.junit.jupiter.api.Test;
  32 import org.openhab.binding.mielecloud.internal.util.MockUtil;
  33 import org.openhab.binding.mielecloud.internal.webservice.language.LanguageProvider;
  34 import org.openhab.binding.mielecloud.internal.webservice.request.RequestFactoryImpl;
  35 import org.openhab.core.io.net.http.HttpClientFactory;
  36
  37 /**
  38  * @author Björn Lange - Initial contribution
  39  */
  40 @NonNullByDefault
  41 public class RequestFactoryImplTest {
  42     private static final String URL = "https://www.openhab.org/";
  43     private static final String ACCESS_TOKEN = "DE_0123456789abcdef0123456789abcdef";
  44     private static final String JSON_CONTENT = "{ \"update\": 1 }";
  45
  46     private static final String LANGUAGE = "de";
  47
  48     private static final long REQUEST_TIMEOUT = 5;
  49     private static final long EXTENDED_REQUEST_TIMEOUT = 10;
  50     private static final TimeUnit REQUEST_TIMEOUT_UNIT = TimeUnit.SECONDS;
  51
  52     @Nullable
  53     private String contentString;
  54     @Nullable
  55     private String contentType;
  56
  57     private final LanguageProvider defaultLanguageProvider = new LanguageProvider() {
  58         @Override
  59         public Optional<String> getLanguage() {
  60             return Optional.of(LANGUAGE);
  61         }
  62     };
  63     private final LanguageProvider emptyStringLanguageProvider = new LanguageProvider() {
  64         @Override
  65         public Optional<String> getLanguage() {
  66             return Optional.of("");
  67         }
  68     };
  69
  70     private Request getRequestMock() {
  71         Request requestMock = mock(Request.class);
  72         when(requestMock.header(anyString(), anyString())).thenReturn(requestMock);
  73         when(requestMock.timeout(anyLong(), any())).thenReturn(requestMock);
  74         when(requestMock.method(any(HttpMethod.class))).thenReturn(requestMock);
  75         when(requestMock.param(anyString(), anyString())).thenReturn(requestMock);
  76         when(requestMock.content(any())).thenAnswer(i -> {
  77             StringContentProvider provider = i.getArgument(0);
  78             List<Byte> rawData = new ArrayList<Byte>();
  79             provider.forEach(b -> {
  80                 b.rewind();
  81                 while (b.hasRemaining()) {
  82                     rawData.add(b.get());
  83                 }
  84             });
  85             byte[] data = new byte[rawData.size()];
  86             for (int j = 0; j < data.length; j++) {
  87                 data[j] = rawData.get(j);
  88             }
  89             contentString = new String(data, StandardCharsets.UTF_8);
  90             contentType = provider.getContentType();
  91             return requestMock;
  92         });
  93         return requestMock;
  94     }
  95
  96     private RequestFactoryImpl createRequestFactoryImpl(Request requestMock, LanguageProvider languageProvider) {
  97         HttpClient httpClient = MockUtil.mockHttpClient(URL, requestMock);
  98
  99         HttpClientFactory httpClientFactory = mock(HttpClientFactory.class);
 100         when(httpClientFactory.createHttpClient(anyString())).thenReturn(httpClient);
 101
 102         return new RequestFactoryImpl(httpClientFactory, languageProvider);
 103     }
 104
 105     @Test
 106     public void testCreateGetRequestReturnsRequestWithExpectedHeaders() {
 107         // given:
 108         Request requestMock = getRequestMock();
 109         RequestFactoryImpl requestFactory = createRequestFactoryImpl(requestMock, defaultLanguageProvider);
 110
 111         // when:
 112         Request request = requestFactory.createGetRequest(URL, ACCESS_TOKEN);
 113
 114         // then:
 115         assertEquals(requestMock, request);
 116         verify(request).header("Content-type", "application/json");
 117         verify(request).header("Accept", "*/*");
 118         verify(request).header("Authorization", "Bearer " + ACCESS_TOKEN);
 119         verify(request).timeout(REQUEST_TIMEOUT, REQUEST_TIMEOUT_UNIT);
 120         verify(request).method(HttpMethod.GET);
 121         verify(request).param("language", LANGUAGE);
 122         verifyNoMoreInteractions(request);
 123     }
 124
 125     @Test
 126     public void testCreatePutRequestReturnsRequestWithExpectedHeadersAndContent() {
 127         Request requestMock = getRequestMock();
 128         RequestFactoryImpl requestFactory = createRequestFactoryImpl(requestMock, defaultLanguageProvider);
 129
 130         // when:
 131         Request request = requestFactory.createPutRequest(URL, ACCESS_TOKEN, JSON_CONTENT);
 132
 133         // then:
 134         assertEquals(requestMock, request);
 135         verify(request).header("Content-type", "application/json");
 136         verify(request).header("Accept", "*/*");
 137         verify(request).header("Authorization", "Bearer " + ACCESS_TOKEN);
 138         verify(request).timeout(EXTENDED_REQUEST_TIMEOUT, REQUEST_TIMEOUT_UNIT);
 139         verify(request).method(HttpMethod.PUT);
 140         verify(request).content(any());
 141         verify(request).param("language", LANGUAGE);
 142         assertEquals(JSON_CONTENT, contentString);
 143         assertEquals("application/json", contentType);
 144         verifyNoMoreInteractions(request);
 145     }
 146
 147     @Test
 148     public void testCreatePostRequestReturnsRequestWithExpectedHeaders() {
 149         Request requestMock = getRequestMock();
 150         RequestFactoryImpl requestFactory = createRequestFactoryImpl(requestMock, defaultLanguageProvider);
 151
 152         // when:
 153         Request request = requestFactory.createPostRequest(URL, ACCESS_TOKEN);
 154
 155         // then:
 156         assertEquals(requestMock, request);
 157         verify(request).header("Content-type", "application/json");
 158         verify(request).header("Accept", "*/*");
 159         verify(request).header("Authorization", "Bearer " + ACCESS_TOKEN);
 160         verify(request).timeout(REQUEST_TIMEOUT, REQUEST_TIMEOUT_UNIT);
 161         verify(request).method(HttpMethod.POST);
 162         verify(request).param("language", LANGUAGE);
 163         verifyNoMoreInteractions(request);
 164     }
 165
 166     @Test
 167     public void testCreateRequestWithoutSuppliedLangugeCreatesNoLanguageParameter() {
 168         // given:
 169         Request requestMock = getRequestMock();
 170         RequestFactoryImpl requestFactory = createRequestFactoryImpl(requestMock, new LanguageProvider() {
 171             @Override
 172             public Optional<String> getLanguage() {
 173                 return Optional.empty();
 174             }
 175         });
 176
 177         // when:
 178         Request request = requestFactory.createGetRequest(URL, ACCESS_TOKEN);
 179
 180         // then:
 181         assertEquals(requestMock, request);
 182         verify(request).header("Content-type", "application/json");
 183         verify(request).header("Accept", "*/*");
 184         verify(request).header("Authorization", "Bearer " + ACCESS_TOKEN);
 185         verify(request).timeout(REQUEST_TIMEOUT, REQUEST_TIMEOUT_UNIT);
 186         verify(request).method(HttpMethod.GET);
 187         verifyNoMoreInteractions(request);
 188     }
 189
 190     @Test
 191     public void testCreateRequestWithEmptyLanguageCreatesNoLanguageParameter() {
 192         // given:
 193         Request requestMock = getRequestMock();
 194         RequestFactoryImpl requestFactory = createRequestFactoryImpl(requestMock, emptyStringLanguageProvider);
 195
 196         // when:
 197         Request request = requestFactory.createGetRequest(URL, ACCESS_TOKEN);
 198
 199         // then:
 200         assertEquals(requestMock, request);
 201         verify(request).header("Content-type", "application/json");
 202         verify(request).header("Accept", "*/*");
 203         verify(request).header("Authorization", "Bearer " + ACCESS_TOKEN);
 204         verify(request).timeout(REQUEST_TIMEOUT, REQUEST_TIMEOUT_UNIT);
 205         verify(request).method(HttpMethod.GET);
 206         verifyNoMoreInteractions(request);
 207     }
 208
 209     @Test
 210     public void whenAnSseRequestIsCreatedWithoutLanguageThenTheRequiredParametersAreSet() {
 211         Request requestMock = getRequestMock();
 212         RequestFactoryImpl requestFactory = createRequestFactoryImpl(requestMock, emptyStringLanguageProvider);
 213
 214         // when:
 215         Request request = requestFactory.createSseRequest(URL, ACCESS_TOKEN);
 216
 217         // then:
 218         assertEquals(requestMock, request);
 219         verify(request).header("Content-type", "application/json");
 220         verify(request).header("Accept", "text/event-stream");
 221         verify(request).header("Authorization", "Bearer " + ACCESS_TOKEN);
 222         verifyNoMoreInteractions(request);
 223     }
 224
 225     @Test
 226     public void whenAnSseRequestIsCreatedWithLanguageThenTheAcceptLanguageHeaderIsSet() {
 227         Request requestMock = getRequestMock();
 228         RequestFactoryImpl requestFactory = createRequestFactoryImpl(requestMock, defaultLanguageProvider);
 229
 230         // when:
 231         Request request = requestFactory.createSseRequest(URL, ACCESS_TOKEN);
 232
 233         // then:
 234         assertEquals(requestMock, request);
 235         verify(request).header("Content-type", "application/json");
 236         verify(request).header("Accept", "text/event-stream");
 237         verify(request).header("Authorization", "Bearer " + ACCESS_TOKEN);
 238         verify(request).header("Accept-Language", LANGUAGE);
 239         verifyNoMoreInteractions(request);
 240     }
 241 }