Adding state delete + migrate to new event system (#4)

* Adding state delete + migrate to new event system

- bump wiremock version to 3.0.0-beta-11
- use new event system + new interfaces for everything
-  use ExtensionFactory for registering everything
- adding state deleting event listener
- use Store for caching + provide caffeine store
- ensure that context interactions are synchronized to avoid race
  conditions
- updated documentation

Author: dirkbolte

README.md

@@ -50,37 +50,33 @@ the `GET` won't have any knowledge of the previous post.
 
 # Usage
 
-## Register extensions
+## Register extension
 
-Two extensions have to be registered:
-
-- `StateRecordingAction` to record any state in `postServeActions`
-- `StateRequestMatcher` to match incoming request against a context using custom master `state-matcher`
-- `ResponseTemplateTransformer` with `StateHelper` to retrieve a previously recorded state for a context
+This extension makes use of Wiremock's `ExtensionFactory`, so only one extension has to be registered: `StateExtension`.
+In order to use them, templating has to be enabled as well:
 
 ```java
 public class MySandbox {
     private final WireMockServer server;
 
     public MySandbox() {
         var stateRecordingAction = new StateRecordingAction();
+        var store = new CaffeineStore();
         server = new WireMockServer(
             options()
                 .dynamicPort()
-                .extensions(
-                    stateRecordingAction,
-                    new StateRequestMatcher(stateRecordingAction),
-                    new ResponseTemplateTransformer(true, "state", new StateHelper(stateRecordingAction))
-                )
+                .templatingEnabled(true)
+                .globalTemplating(true)
+                .extensions(new StateExtension(store))
         );
         server.start();
     }
 }
 ```
 
-## Store a state
+## Record a state
 
-The state is stored in `postServeActions` of a stub. The following parameters have to be provided:
+The state is recorded in `withServeEventListener` of a stub. The following parameters have to be provided:
 
 <table>
 <tr>
@@ -134,7 +130,7 @@ Full example:
 {
   "request": {},
   "response": {},
-  "postServeActions": [
+  "withServeEventListener": [
     {
       "name": "recordState",
       "parameters": {
@@ -151,14 +147,63 @@ Full example:
 
 ```
 
+## Deleting a state
+
+Similar to recording a state, its deletion can be initiated in  `withServeEventListener` of a stub. The following parameters have to be provided:
+
+<table>
+<tr>
+<th>Parameter</th>
+<th>Type</th>
+<th>Example</th>
+</tr>
+<tr>
+<td>
+
+`context`
+
+</td>
+<td>String</td>
+<td>
+
+- `"context": "{{jsonPath response.body '$.id'}}"`
+- `"context": "{{request.pathSegments.[3]}}"`
+
+</td>
+</tr>
+</table>
+
+Templating (as in [Response Templating](https://wiremock.org/docs/response-templating/)) is supported for these. The following models are exposed:
+
+- `request`: All model elements of as in [Response Templating](https://wiremock.org/docs/response-templating/)
+- `response`: `body` and `headers`
+
+Full example:
+
+```json
+{
+  "request": {},
+  "response": {},
+  "withServeEventListener": [
+    {
+      "name": "deleteState",
+      "parameters": {
+        "context": "{{jsonPath response.body '$.id'}}"
+      }
+    }
+  ]
+}
+
+```
+
 ### state expiration
 
-This extension uses [caffeine](https://github.com/ben-manes/caffeine) to store the current state and to achieve an expiration (to avoid memory leaks).
+This extension provides a `CaffeineStore` which uses [caffeine](https://github.com/ben-manes/caffeine) to store the current state and to achieve an expiration (to avoid memory leaks).
 The default expiration is 60 minutes. The default value can be overwritten (`0` = default = 60 minutes):
 
 ```java
 int expiration=1024;
-var stateRecordingAction=new StateRecordingAction(expiration);
+var store = new CaffeineStore(expiration);
 ```
 
 ## Match a request against a context
@@ -236,15 +281,17 @@ Example response with error:
 ## Java
 
 ```java
-class StateTest {
+class StateExtensionExampleTest {
+
+    private static final String TEST_URL = "/test";
+    private static final Store<String, Object> store = new CaffeineStore();
+    private static final ObjectMapper mapper = new ObjectMapper();
+
     @RegisterExtension
     public static WireMockExtension wm = WireMockExtension.newInstance()
         .options(
             wireMockConfig().dynamicPort().dynamicHttpsPort()
-                .extensions(
-                    stateRecordingAction,
-                    new ResponseTemplateTransformer(true, "state", new StateHelper(stateRecordingAction))
-                )
+                .extensions(new StateExtension(store))
         )
         .build();
 
@@ -260,7 +307,7 @@ class StateTest {
                                 mapper.writeValueAsString(Map.of("id", "{{randomValue length=32 type='ALPHANUMERIC' uppercase=false}}")))
                         )
                 )
-                .withPostServeAction(
+                .withServeEventListener(
                     "recordState",
                     Parameters.from(
                         Map.of(
@@ -285,14 +332,16 @@ class StateTest {
                         .withJsonBody(
                             mapper.readTree(
                                 mapper.writeValueAsString(Map.of(
-                                        "id", "{{state context=request.pathSegments.[1] property='id'}}"),
-                                    "firstName", "{{state context=request.pathSegments.[1] property='firstName'}}"),
-                                "lastName", "{{state context=request.pathSegments.[1] property='lastName'}}")
+                                        "id", "{{state context=request.pathSegments.[1] property='id'}}",
+                                        "firstName", "{{state context=request.pathSegments.[1] property='firstName'}}",
+                                        "lastName", "{{state context=request.pathSegments.[1] property='lastName'}}"
+                                    )
+                                )
+                            )
                         )
                 )
         );
     }
-
 }
 ```
 
@@ -325,7 +374,7 @@ class StateTest {
       "lastName": "{{jsonPath request.body '$.lastName'}}"
     }
   },
-  "postServeActions": [
+  "withServeEventListener": [
     {
       "name": "recordState",
       "parameters": {

build.gradle

@@ -21,18 +21,19 @@ wrapper {
 project.archivesBaseName = 'state'
 project.ext {
     versions = [
-            wiremock  : '3.0.0-beta-10',
+            wiremock  : '3.0.0-beta-11',
             caffeine  : '3.1.6',
             handlebars: '4.3.1',
             junit     : '5.9.3',
             assertj   : '3.24.2',
-            restAssured: '5.3.1'
+            restAssured: '5.3.1',
+            awaitility: '4.2.0'
     ]
 }
 
 
 group 'com.github.dirkbolte.wiremock.extensions'
-version '0.0.1'
+version '0.0.2-3.0.0-beta-11'
 
 
 publishing {
@@ -80,7 +81,7 @@ repositories {
 }
 
 dependencies {
-    implementation("com.github.tomakehurst:wiremock:${versions.wiremock}")
+    implementation("org.wiremock:wiremock:${versions.wiremock}")
     implementation("com.github.ben-manes.caffeine:caffeine:${versions.caffeine}")
     implementation("com.github.jknack:handlebars-helpers:${versions.handlebars}") {
         exclude group: 'org.mozilla', module: 'rhino'
@@ -91,6 +92,7 @@ dependencies {
     testImplementation("org.assertj:assertj-core:${versions.assertj}")
     testImplementation(platform("io.rest-assured:rest-assured-bom:${versions.restAssured}"))
     testImplementation("io.rest-assured:rest-assured")
+    testImplementation("org.awaitility:awaitility:${versions.awaitility}")
 }
 
 

src/main/java/org/wiremock/extensions/state/CaffeineStore.java

@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2023 Dirk Bolte
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.wiremock.extensions.state;
+
+import com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.Caffeine;
+import com.github.tomakehurst.wiremock.store.Store;
+
+import java.time.Duration;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+public class CaffeineStore implements Store<String, Object> {
+
+    private static final int DEFAULT_EXPIRATION_SECONDS = 60 * 60;
+
+    private final Cache<String, Object> cache;
+
+    public CaffeineStore() {
+        this(0);
+    }
+
+    public CaffeineStore(int expirationSeconds) {
+        var builder = Caffeine.newBuilder();
+        if (expirationSeconds == 0) {
+            builder.expireAfterWrite(Duration.ofSeconds(DEFAULT_EXPIRATION_SECONDS));
+        } else {
+            builder.expireAfterWrite(Duration.ofSeconds(expirationSeconds));
+        }
+        cache = builder.build();
+    }
+
+    @Override
+    public Stream<String> getAllKeys() {
+        return cache.asMap().keySet().stream();
+    }
+
+    @Override
+    public Optional<Object> get(String key) {
+        return Optional.ofNullable(cache.getIfPresent(key));
+    }
+
+    @Override
+    public void put(String key, Object content) {
+        cache.put(key, content);
+    }
+
+    @Override
+    public void remove(String key) {
+        cache.invalidate(key);
+    }
+
+    @Override
+    public void clear() {
+        cache.invalidateAll();
+    }
+}

src/main/java/org/wiremock/extensions/state/StateExtension.java

@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2023 Dirk Bolte
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.wiremock.extensions.state;
+
+import com.github.tomakehurst.wiremock.extension.Extension;
+import com.github.tomakehurst.wiremock.extension.ExtensionFactory;
+import com.github.tomakehurst.wiremock.extension.WireMockServices;
+import com.github.tomakehurst.wiremock.extension.responsetemplating.TemplateEngine;
+import com.github.tomakehurst.wiremock.store.Store;
+import org.wiremock.extensions.state.extensions.DeleteStateEventListener;
+import org.wiremock.extensions.state.extensions.RecordStateEventListener;
+import org.wiremock.extensions.state.extensions.StateRequestMatcher;
+import org.wiremock.extensions.state.extensions.StateTemplateHelperProviderExtension;
+import org.wiremock.extensions.state.internal.ContextManager;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Factory to register all extensions for handling state.
+ * <p>
+ * Register with:
+ *
+ * <pre>{@code
+ *     private static final Store<String, Object> store = new CaffeineStore();
+ *
+ *     @RegisterExtension
+ *     public static WireMockExtension wm = WireMockExtension.newInstance()
+ *         .options(
+ *             wireMockConfig().dynamicPort().dynamicHttpsPort()
+ *                 .extensions(new StateExtension(store))
+ *         )
+ *         .build();
+ *         }
+ * </pre>
+ */
+public class StateExtension implements ExtensionFactory {
+
+    private final TemplateEngine templateEngine = new TemplateEngine(Collections.emptyMap(), null, Collections.emptySet(), false);
+
+    private final ContextManager contextManager;
+
+    public StateExtension(Store<String, Object> store) {
+        this.contextManager = new ContextManager(store);
+    }
+
+    @Override
+    public List<Extension> create(WireMockServices services) {
+        return List.of(
+            new RecordStateEventListener(contextManager, templateEngine),
+            new DeleteStateEventListener(contextManager, templateEngine),
+            new StateRequestMatcher(contextManager, templateEngine),
+            new StateTemplateHelperProviderExtension(contextManager)
+        );
+    }
+}