StepsContext.java

  1. package org.jbehave.core.steps.context;

  2. import java.util.HashMap;
  3. import java.util.HashSet;
  4. import java.util.Map;
  5. import java.util.Set;

  6. import org.jbehave.core.annotations.ToContext;

  7. /**
  8.  * Holds runtime context-related objects.
  9.  */
  10. public class StepsContext {

  11.     private static final String OBJECT_ALREADY_STORED_MESSAGE = "Object key '%s' has been already stored before.";
  12.     private static final String OBJECT_NOT_STORED_MESSAGE = "Object key '%s' has not been stored";

  13.     private static final ThreadLocal<Map<String, Object>> exampleObjects = new ThreadLocal<>();
  14.     private static final ThreadLocal<Map<String, Object>> scenarioObjects = new ThreadLocal<>();
  15.     private static final ThreadLocal<Map<String, Object>> storyObjects = new ThreadLocal<>();
  16.     private static final ThreadLocal<Set<String>> keysStored = new ThreadLocal<>();

  17.     public void put(String key, Object object, ToContext.RetentionLevel retentionLevel) {
  18.         checkForDuplicate(key);
  19.         Map<String, Object> objects;
  20.         if (ToContext.RetentionLevel.EXAMPLE.equals(retentionLevel)) {
  21.             objects = getExampleObjects();
  22.         } else if (ToContext.RetentionLevel.SCENARIO.equals(retentionLevel)) {
  23.             objects = getScenarioObjects();
  24.         } else {
  25.             objects = getStoryObjects();
  26.         }
  27.         objects.put(key, object);
  28.     }

  29.     private void checkForDuplicate(String key) {
  30.         Set<String> keys = keysStored.get();
  31.         if (keys.contains(key)) {
  32.             throw new ObjectAlreadyStoredException(String.format(OBJECT_ALREADY_STORED_MESSAGE, key));
  33.         } else {
  34.             keys.add(key);
  35.         }
  36.     }

  37.     public Object get(String key) {
  38.         Object object = getExampleObjects().get(key);
  39.         if (object == null) {
  40.             object = getScenarioObjects().get(key);
  41.             if (object == null) {
  42.                 object = getStoryObjects().get(key);
  43.             }
  44.         }

  45.         if (object == null) {
  46.             throw new ObjectNotStoredException(String.format(OBJECT_NOT_STORED_MESSAGE, key));
  47.         }

  48.         return object;
  49.     }

  50.     private Map<String, Object> getExampleObjects() {
  51.         Map<String, Object> objects = exampleObjects.get();
  52.         if (objects == null) {
  53.             objects = new HashMap<>();
  54.             exampleObjects.set(objects);
  55.         }
  56.         return objects;
  57.     }

  58.     private Map<String, Object> getScenarioObjects() {
  59.         Map<String, Object> objects = scenarioObjects.get();
  60.         if (objects == null) {
  61.             objects = new HashMap<>();
  62.             scenarioObjects.set(objects);
  63.         }
  64.         return objects;
  65.     }

  66.     private Map<String, Object> getStoryObjects() {
  67.         Map<String, Object> objects = storyObjects.get();
  68.         if (objects == null) {
  69.             objects = new HashMap<>();
  70.             storyObjects.set(objects);
  71.         }
  72.         return objects;
  73.     }

  74.     private Set<String> getKeys() {
  75.         Set<String> keys = keysStored.get();
  76.         if (keys == null) {
  77.             keys = new HashSet<>();
  78.             keysStored.set(keys);
  79.         }
  80.         return keys;
  81.     }

  82.     public void resetExample() {
  83.         Set<String> keys = getKeys();
  84.         keys.removeAll(getExampleObjects().keySet());
  85.         exampleObjects.set(new HashMap<String, Object>());
  86.     }

  87.     public void resetScenario() {
  88.         Set<String> keys = getKeys();
  89.         keys.removeAll(getScenarioObjects().keySet());
  90.         scenarioObjects.set(new HashMap<String, Object>());
  91.     }

  92.     public void resetStory() {
  93.         storyObjects.set(new HashMap<String, Object>());
  94.         keysStored.set(new HashSet<String>());
  95.     }

  96.     @SuppressWarnings("serial")
  97.     public static class ObjectNotStoredException extends RuntimeException {

  98.         public ObjectNotStoredException(String message) {
  99.             super(message);
  100.         }
  101.     }

  102.     @SuppressWarnings("serial")
  103.     public static class ObjectAlreadyStoredException extends RuntimeException {

  104.         public ObjectAlreadyStoredException(String message) {
  105.             super(message);
  106.         }
  107.     }

  108. }