Release 1.0.2 (#3)

* Fixed #2 - Fixed log4j2 properties

* Initializing 1.0.2-SNAPSHOT

* Project refactored - Added snapshot auto load

* Fixed SnapshotLoaderTest case

* Fixed try-with-resources when writing snapshot into a file

* Fixed 19 code smells

* Added Snapshot Watcher

* Snapshot Watcher - Fixed some code smells

* Snapshot Watcher - Fixed some code smells #2

* feat: Re-worked built-in mock implementation

* fix: Minor issue with test case - testModelEntry

* readme: Fixed minor doc issues

* feat: Updated javadoc

Author: petruki

pom.xml

@@ -8,7 +8,7 @@
   	<groupId>com.github.petruki</groupId>
 	<artifactId>switcher-client</artifactId>
 	<packaging>jar</packaging>
-	<version>1.0.1</version>
+	<version>1.0.2</version>
 
  	<name>Switcher Client</name>
 	<description>Switcher Client for working with Switcher API</description>
@@ -57,12 +57,14 @@
    		<!-- test -->
    		<log4j.version>2.13.1</log4j.version>
    		<powermock-module-junit4.version>2.0.2</powermock-module-junit4.version>
+   		<awaitility.version>3.0.0</awaitility.version>
 
 		<!-- Sonar -->
 		<sonar.java.coveragePlugin>jacoco</sonar.java.coveragePlugin>
 		<sonar.dynamicAnalysis>reuseReports</sonar.dynamicAnalysis>
 		<sonar.jacoco.reportPath>${project.basedir}/target/coverage-reports/jacoco-unit.exec</sonar.jacoco.reportPath>
 		<sonar.language>java</sonar.language>
+		<sonar.coverage.exclusions>com/github/petruki/switcher/client/model/*</sonar.coverage.exclusions>
 	</properties>
 
 	<dependencies>
@@ -129,6 +131,12 @@
             <version>${powermock-module-junit4.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+		    <groupId>org.awaitility</groupId>
+		    <artifactId>awaitility</artifactId>
+		    <version>${awaitility.version}</version>
+		    <scope>test</scope>
+		</dependency>
 	</dependencies>
 
 	<!-- 

readme.md

@@ -6,10 +6,19 @@
 
 ![Switcher API: Java Client: Cloud-based Feature Flag API](https://github.com/petruki/switcherapi-assets/blob/master/logo/switcherapi_java_client.png)
 
-# Install  
-- Using the source code
-`mvn clean install`
+# About
+Client Java for working with Switcher-API.
+https://github.com/petruki/switcher-api
+
+- Able to work offline using a snapshot file downloaded from your remote Switcher-API Domain.
+- Silent mode automatically enables a contingent sub-process in case of connectivity issues.
+- Built-in mock implementation for automated testing.
+- Easy to setup. Switcher Context is responsible to manage all the complexity between your application and API.
+
+# Usage
 
+## Install  
+- Using the source code `mvn clean install`
 - Adding as a dependency - Maven
 ```xml
 <dependency>
@@ -19,64 +28,98 @@
 </dependency>
 ```	
 
-# About  
-Client Java for working with Switcher-API.
-https://github.com/petruki/switcher-api
+## Context properties
+The context map properties stores all information regarding connectivity and strategy settings. These constants can be accessed using *SwitcherContextParam*.
 
-Switcher Client is a friendly lib to interact with the Switcher API by:
-- Simplifying validations throughout your remote Switcher configuration.
-- Able to work offline using a snapshot claimed from your remote Switcher-API.
-- Able to run in silent mode that will prevent your application to not be 100% dependent on the online API.
-- Being flexible in order to remove the complexity of multi-staging (add as many environments as you want).
-- Being friendly by making possible to manipulate switchers without changing your online switchers. (useful for automated tests - see below some examples about bypassing switchers).
-- Being secure by using OAuth 2 flow. Requests are made using tokens that will validate your domain, component, environment and API key.
-Tokens have an expiration time and are not stored. The Switcher Client is responsible to renew it using your settings.
-
-# Example
-## Client configuration
 ```java
-properties.put(SwitcherContextParam.URL, "http://localhost:3000/criteria");
+properties.put(SwitcherContextParam.URL, "https://switcher-load-balance.herokuapp.com");
 properties.put(SwitcherContextParam.APIKEY, "API_KEY");
 properties.put(SwitcherContextParam.DOMAIN, "MyDomain");
 properties.put(SwitcherContextParam.COMPONENT, "MyApp");
 properties.put(SwitcherContextParam.ENVIRONMENT, "default");
 properties.put(SwitcherContextParam.SILENT_MODE, true);
 properties.put(SwitcherContextParam.RETRY_AFTER, "5s");
-properties.put(SwitcherContextParam.SNAPSHOT_LOCATION, SNAPSHOTS_LOCAL + "default.json");
+properties.put(SwitcherContextParam.SNAPSHOT_LOCATION, "/src/resources");
 
 SwitcherFactory.buildContext(properties, false);
-Switcher switcher = SwitcherFactory.getSwitcher("FF2FOR2020");
+Switcher switcher = SwitcherFactory.getSwitcher("FEATURE01");
+switcher.isItOn();
+```
+
+- URL: Endpoint of your Swither-API.
+- APIKEY: Switcher-API key generated after creating a domain.
+- DOMAIN: Domain name.
+- COMPONENT: Application name.
+- ENVIRONMENT: Environment name. Production environment is named as 'default'.
+- SILENT_MODE: (boolean) Activate contingency in case of some problem with connectivity with the API.
+- RETRY_AFTER: Time given to the module to re-establish connectivity with the API - e.g. 5s (s: seconds - m: minutes - h: hours)
+- SNAPSHOT_LOCATION: Set the folder location where snapshot files will be saved.
+- SNAPSHOT_AUTO_LOAD: (boolean) Set the module to automatically download the snapshot configuration.
+
+## Executing
+There are a few different ways to call the API using the java library.
+Here are some examples:
+
+1. **No parameters**
+Invoking the API can be done by obtaining the switcher object and calling *isItOn*. It can also be forced to call another key any time you want.
+
+```java
+Switcher switcher = SwitcherFactory.getSwitcher("FEATURE01");
 switcher.isItOn();
+//or
+switcher.isItOn("FEATURE01");
+```
+
+2. **Strategy validation - preparing input**
+Loading information into the switcher can be made by using *prepareEntry*, in case you want to include input from a different place of your code. Otherwise, it is also possible to include everything in the same call.
+
+```java
+List<Entry> entries = new ArrayList<>();
+entries.add(new Entry(Entry.DATE, "2019-12-10"));
+entries.add(new Entry(Entry.DATE, "2020-12-10"));
+
+switcher.prepareEntry(entries);
+switcher.isItOn();
+//or
+switcher.isItOn(entries);
+```
+
+3. **Strategy validation - all-in-one execution**
+All-in-one method is fast and include everything you need to execute a complex call to the API. Stack inputs changing the last parameter to *true* in case you need to add more values to the strategy validator.
+
+```java
+switcher.isItOn("FEATURE01", new Entry(Entry.NETWORK, "10.0.0.3"), false);
 ```
-- **APIKEY**: Obtained after creating your domain using the Switcher-API project.
-- **ENVIRONMENT**: You can run multiple environments. Production environment is 'default' which is created automatically after creating the domain.
-- **DOMAIN**: This is your business name identification.
-- **COMPONENT**: This is the name of the application that will be using this API.
-- **URL**: Endpoint of your Swither-API.
-- **SILENT_MODE**: Enable the client work in silent mode if some problem network issues happen. It's necessary to save the snapshot localy.
-- **RETRY_AFTER**: Represents the time a retry to reach the API should take.
 
 ## Offline settings
+You can also force the Switcher library to work offline. In this case, the snapshot location must be set up and the context re-built using the offline flag.
+
 ```java
-properties.put(SwitcherContextParam.SNAPSHOT_LOCATION, SNAPSHOTS_LOCAL + "default.json");
+properties.put(SwitcherContextParam.SNAPSHOT_LOCATION, "/src/resources");
 SwitcherFactory.buildContext(properties, true);
 
-Switcher switcher = SwitcherFactory.getSwitcher("FF2FOR2020");
+Switcher switcher = SwitcherFactory.getSwitcher("FEATURE01");
 switcher.isItOn();
 ```
 
-## Bypass example
+## Built-in mock feature
+Write automated tests using this built-in mock mechanism to guide your test scenario according to what you want to test.
+</br>*SwitcherExecutor* implementation has 2 methods that can make mock tests easier. Use assume to force a value to a switcher and forget to reset its original state.
+
 ```java
-Switcher switcher = SwitcherFactory.getSwitcher("FF2FOR2020");
-switcher.isItOn(); // Pretending your API or Snapshot return 'true'
+Switcher switcher = SwitcherFactory.getSwitcher("FEATURE01");
 
-switcher.assume("FF2FOR2020", false);
-switcher.isItOn(); // Now, it's going to return 'false'
+SwitcherExecutor.assume("FEATURE01", false);
+switcher.isItOn(); // 'false'
 
-switcher.forget("FF2FOR2020");
-switcher.isItOn(); // Now, it's going to return 'true'
+SwitcherExecutor.forget("FEATURE01");
+switcher.isItOn(); // Now, it's going to return the result retrieved from the API or the Snaopshot file
 ```
 
 # Version Log
+- 1.0.2: 
+    - Improved performance when loading snapshot file.
+    - Snapshot file auto load when updated.
+    - Re-worked built-in mock implementation
 - 1.0.1: Security patch - Log4J has been updated
 - 1.0.0: Working release

src/main/java/com/github/petruki/switcher/client/SwitcherFactory.java

@@ -5,12 +5,16 @@
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
-import com.github.petruki.switcher.client.domain.Switcher;
+import com.github.petruki.switcher.client.exception.SwitcherException;
 import com.github.petruki.switcher.client.exception.SwitcherFactoryContextException;
+import com.github.petruki.switcher.client.exception.SwitcherSnapshotLoadException;
 import com.github.petruki.switcher.client.factory.SwitcherExecutor;
 import com.github.petruki.switcher.client.factory.SwitcherOffline;
 import com.github.petruki.switcher.client.factory.SwitcherOnline;
+import com.github.petruki.switcher.client.model.Switcher;
+import com.github.petruki.switcher.client.service.ClientService;
 import com.github.petruki.switcher.client.utils.SwitcherContextParam;
+import com.github.petruki.switcher.client.utils.SwitcherUtils;
 
 /**
  * Configure context (using {@link #buildContext(Map, boolean)} and claim switcher (using {@link #getSwitcher(String)} by using this factory.
@@ -42,14 +46,16 @@ private SwitcherFactory() {}
 	 * <br>
 	 * <br> <b>Optional</b>
 	 * <br> {@link SwitcherContextParam#SNAPSHOT_LOCATION}
+	 * <br> {@link SwitcherContextParam#SNAPSHOT_FILE}
 	 * <br> {@link SwitcherContextParam#SILENT_MODE}
 	 * <br> {@link SwitcherContextParam#RETRY_AFTER}
 	 * <br>
 	 * @param offline If set to true, this client will find the configuration inside the configured snapshot file
+	 * @throws SwitcherSnapshotLoadException in case it was not possible to load snapshot
 	 * 
 	 * @see SwitcherContextParam
 	 */
-	public static void buildContext(final Map<String, Object> properties, boolean offline) {
+	public static void buildContext(final Map<String, Object> properties, boolean offline)  throws SwitcherException {
 
 		if (logger.isDebugEnabled()) {
 			logger.debug(String.format("properties: %s", properties));
@@ -58,12 +64,13 @@ public static void buildContext(final Map<String, Object> properties, boolean of
 
 		if (instance == null) {
 			if (offline) {
-				instance = new SwitcherOffline((String) properties.get(SwitcherContextParam.SNAPSHOT_LOCATION));
+				instance = new SwitcherOffline(properties);
 			} else {
 				instance = new SwitcherOnline(properties);
 			}
 		} else {
 			instance.updateContext(properties);
+			SwitcherExecutor.getBypass().clear();
 		}
 	}
 
@@ -86,5 +93,40 @@ public static Switcher getSwitcher(final String key) throws SwitcherFactoryConte
 
 		return new Switcher(key, instance);
 	}
+	
+	/**
+	 * Validate and update local snapshot file
+	 * 
+	 * @throws SwitcherException
+	 *  If an error has occrured when invoking {@link ClientService#SNAPSHOT_URL} and {@link ClientService#SNAPSHOT_VERSION_CHECK}
+	 */
+	public static void validateSnapshot() throws SwitcherException {
+		
+		if (instance == null) {
+			throw new SwitcherFactoryContextException();
+		}
+		
+		if (!instance.checkSnapshotVersion()) {
+			instance.updateSnapshot();
+		}
+	}
+	
+	/**
+	 * Start watching snapshot file for changes. As it has changed, it will update the domain in memory
+	 */
+	public static void watchSnapshot() {
+		
+		SwitcherUtils.watchSnapshot(instance);
+	}
+	
+	/**
+	 * Unregister snapshot location and terminates the Thread watcher
+	 * 
+	 * @throws SwitcherException if watch thread never started
+	 */
+	public static void stopWatchingSnapshot() throws SwitcherException {
+		
+		SwitcherUtils.stopWatchingSnapshot();
+	}
 
 }

src/main/java/com/github/petruki/switcher/client/domain/criteria/Config.java

@@ -0,0 +1,16 @@
+package com.github.petruki.switcher.client.exception;
+
+/**
+ * @author rogerio
+ * @since 2020-05-13
+ */
+public class SwitcherSnapshotWatcherException extends SwitcherException {
+	
+	private static final long serialVersionUID = 4548138997211494541L;
+
+	public SwitcherSnapshotWatcherException(final String message, final Exception ex) {
+		
+		super(String.format("Something went wrong: %s", message), ex);
+	}
+
+}