Added Steps, and fixed feature

Author: open-schnick

.run/Run Cucumber Tests.run.xml

@@ -0,0 +1,16 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Run Cucumber Tests" type="JUnit" factoryName="JUnit">
+    <useClassPathOnly />
+    <option name="PACKAGE_NAME" value="de.filefighter.rest.cucumber" />
+    <option name="MAIN_CLASS_NAME" value="" />
+    <option name="METHOD_NAME" value="" />
+    <option name="TEST_OBJECT" value="package" />
+    <option name="PARAMETERS" value="" />
+    <option name="TEST_SEARCH_SCOPE">
+      <value defaultName="wholeProject" />
+    </option>
+    <method v="2">
+      <option name="Make" enabled="true" />
+    </method>
+  </configuration>
+</component>

src/test/java/de/filefighter/rest/cucumber/CommonCucumberSteps.java

@@ -6,8 +6,10 @@
 import de.filefighter.rest.RestApplicationIntegrationTest;
 import de.filefighter.rest.domain.filesystem.data.persistance.FileSystemEntity;
 import de.filefighter.rest.domain.filesystem.data.persistance.FileSystemRepository;
+import de.filefighter.rest.domain.token.business.AccessTokenBusinessService;
 import de.filefighter.rest.domain.token.data.persistance.AccessTokenEntity;
 import de.filefighter.rest.domain.token.data.persistance.AccessTokenRepository;
+import de.filefighter.rest.domain.user.business.UserBusinessService;
 import de.filefighter.rest.domain.user.data.persistance.UserEntity;
 import de.filefighter.rest.domain.user.data.persistance.UserRepository;
 import io.cucumber.java.en.And;
@@ -46,21 +48,19 @@ public void databaseIsEmpty() {
         fileSystemRepository.deleteAll();
     }
 
-    @And("user {long} exists")
-    public void userExists(long userId) {
-        userRepository.save(UserEntity
-                .builder()
+    @Given("accessToken with value {string} exists for user {long}")
+    public void accessTokenWithValueExistsForUser(String tokenValue, long userId) {
+        accessTokenRepository.save(AccessTokenEntity.builder()
                 .userId(userId)
-                .build());
+                .value(tokenValue)
+                .validUntil(Instant.now().getEpochSecond()+ ACCESS_TOKEN_DURATION_IN_SECONDS).build());
     }
 
-    @And("user {long} has access token {string}")
-    public void userHasAccessToken(long userId, String accessTokenValue) {
-        accessTokenRepository.save(AccessTokenEntity
+    @And("user {long} exists")
+    public void userExists(long userId) {
+        userRepository.save(UserEntity
                 .builder()
                 .userId(userId)
-                .value(accessTokenValue)
-                .validUntil(Instant.now().getEpochSecond() + ACCESS_TOKEN_DURATION_IN_SECONDS)
                 .build());
     }
 

src/test/java/de/filefighter/rest/cucumber/UserAuthorizationSteps.java

@@ -1,27 +1,73 @@
 package de.filefighter.rest.cucumber;
 
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import de.filefighter.rest.RestApplicationIntegrationTest;
 import io.cucumber.java.en.And;
-import io.cucumber.java.en.Then;
 import io.cucumber.java.en.When;
+import org.bson.internal.Base64;
+import org.springframework.http.HttpMethod;
 
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import java.time.Instant;
+import java.util.HashMap;
+import java.util.UUID;
+
+import static com.mongodb.internal.connection.tlschannel.util.Util.assertTrue;
+import static de.filefighter.rest.configuration.RestConfiguration.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class UserAuthorizationSteps extends RestApplicationIntegrationTest {
 
+    private final ObjectMapper objectMapper = new ObjectMapper();
+
     @When("user requests login with username {string} and password {string}")
     public void userRequestsLoginWithUsernameAndPassword(String username, String password) {
+        String authString = AUTHORIZATION_BASIC_PREFIX + username + ":" + password;
+        String base64encoded = Base64.encode(authString.getBytes());
+
+        HashMap<String, String> authHeader = new HashMap<>();
+        authHeader.put("Authorization", base64encoded);
+
+        String url = BASE_API_URI + USER_BASE_URI + "login";
+
+        executeRestApiCall(HttpMethod.GET, url, authHeader);
     }
 
     @When("user requests accessToken with refreshToken {string} and userId {long}")
     public void userRequestsAccessTokenWithRefreshTokenAndUserId(String refreshTokenValue, long userId) {
-    }
+        String authHeaderString = AUTHORIZATION_BEARER_PREFIX + refreshTokenValue;
+        String url = BASE_API_URI + USER_BASE_URI + userId + "/login";
+
+        HashMap<String, String> authHeader = new HashMap<>();
+        authHeader.put("Authorization", authHeaderString);
 
-    @And("response contains valid accessToken")
-    public void responseContainsValidAccessToken() {
+        executeRestApiCall(HttpMethod.GET, url, authHeader);
     }
 
     @When("user requests userInfo with accessToken {string} and userId {long}")
     public void userRequestsUserInfoWithAccessTokenAndUserId(String accessTokenValue, long userId) {
+        String authHeaderString = AUTHORIZATION_BEARER_PREFIX + accessTokenValue;
+        String url = BASE_API_URI + USER_BASE_URI + userId + "/info";
+
+        HashMap<String, String> authHeader = new HashMap<>();
+        authHeader.put("Authorization", authHeaderString);
+
+        executeRestApiCall(HttpMethod.GET, url, authHeader);
+    }
+
+    @And("response contains valid accessToken for user {long}")
+    public void responseContainsValidAccessTokenForUser(long userId) throws JsonProcessingException {
+        JsonNode rootNode = objectMapper.readTree(latestResponse.getBody());
+        String tokenValue = rootNode.get("token").asText();
+        long actualUserId = rootNode.get("userId").asLong();
+        long validUntil = rootNode.get("validUntil").asLong();
+
+        int expectedTokenLength = UUID.randomUUID().toString().length();
+        long expectedValidUntil = Instant.now().getEpochSecond();
+
+        assertEquals(expectedTokenLength, tokenValue.length());
+        assertTrue(validUntil > expectedValidUntil);
+        assertEquals(userId, actualUserId);
     }
 }

src/test/resources/UserAuthorization.feature

@@ -19,20 +19,27 @@
 #  And response contains key "status" and value "denied"
 #  And response status code is 401
 #
-#Scenario: Successful retrieval of accessToken with refreshToken.
+#Scenario: Successful creation of new accessToken with refreshToken.
 #  When user requests accessToken with refreshToken "token" and userId 1234
 #  Then response contains key "userId" and value "1234"
-#  And response contains valid accessToken
+#  And response contains valid accessToken for user 1234
 #  And response status code is 200
 #
-#Scenario: Failed retrieval of accessToken with wrong refreshToken.
+#Scenario: Successful request of existing accessToken with refreshToken.
+#  Given accessToken with value "token" exists for user 1234
+#  When user requests accessToken with refreshToken "token" and userId 1234
+#  Then response contains key "userId" and value "1234"
+#  And response contains valid accessToken for user 1234
+#  And response status code is 200
+#
+#  Scenario: Failed retrieval of accessToken with wrong refreshToken.
 #  When user requests accessToken with refreshToken "not_the_token" and userId 1234
 #  Then response contains key "message" and value "User not authenticated."
 #  And response contains key "status" and value "denied"
 #  And response status code is 401
 #
 #Scenario: Successful UserInfo request with valid accessToken.
-#  Given user 1234 has access token "accessToken"
+#  Given accessToken with value "accessToken" exists for user 1234
 #  When user requests userInfo with accessToken "accessToken" and userId 1234
 #  Then response contains the user with id 1234
 #  And response status code is 200