Merge branch 'traccar:master' into master

10 files changed, 293 insertions, 269 deletions

diff --git a/src/test/java/org/traccar/handler/ComputedAttributesTest.java b/src/test/java/org/traccar/handler/ComputedAttributesTest.java
index a76d8169b..e2af703c2 100644
--- a/src/test/java/org/traccar/handler/ComputedAttributesTest.java
+++ b/src/test/java/org/traccar/handler/ComputedAttributesTest.java
@@ -1,20 +1,20 @@
 package org.traccar.handler;
 
-import java.util.Date;
-
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.traccar.config.Config;
 import org.traccar.model.Attribute;
 import org.traccar.model.Position;
 
-import static org.junit.Assert.assertEquals;
+import java.util.Date;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class ComputedAttributesTest {
 
     @Test
     public void testComputedAttributes() {
 
-        ComputedAttributesHandler handler = new ComputedAttributesHandler(new Config(), null, null);
+        ComputedAttributesHandler handler = new ComputedAttributesHandler(new Config(), null);
 
         Date date = new Date();
         Position position = new Position();
@@ -41,7 +41,7 @@ public class ComputedAttributesTest {
         attribute.setExpression("(bitFlag & 4) != 0");
         assertEquals(true, handler.computeAttribute(attribute, position));
 
-        attribute.setExpression("if (event == 42) \"lowBattery\"");
+        attribute.setExpression("event == 42 ? \"lowBattery\" : null");
         assertEquals("lowBattery", handler.computeAttribute(attribute, position));
 
         attribute.setExpression("speed > 5 && valid");
diff --git a/src/test/java/org/traccar/handler/DistanceHandlerTest.java b/src/test/java/org/traccar/handler/DistanceHandlerTest.java
index f7c6e42cd..7d2f1e2e3 100644
--- a/src/test/java/org/traccar/handler/DistanceHandlerTest.java
+++ b/src/test/java/org/traccar/handler/DistanceHandlerTest.java
@@ -1,17 +1,19 @@
 package org.traccar.handler;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.traccar.config.Config;
 import org.traccar.model.Position;
+import org.traccar.session.cache.CacheManager;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.mock;
 
 public class DistanceHandlerTest {
 
     @Test
     public void testCalculateDistance() {
 
-        DistanceHandler distanceHandler = new DistanceHandler(new Config(), null);
+        DistanceHandler distanceHandler = new DistanceHandler(new Config(), mock(CacheManager.class));
 
         Position position = distanceHandler.handlePosition(new Position());
 
diff --git a/src/test/java/org/traccar/handler/FilterHandlerTest.java b/src/test/java/org/traccar/handler/FilterHandlerTest.java
index ad8d244a6..36bb84f19 100644
--- a/src/test/java/org/traccar/handler/FilterHandlerTest.java
+++ b/src/test/java/org/traccar/handler/FilterHandlerTest.java
@@ -1,87 +1,99 @@
 package org.traccar.handler;
 
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.traccar.BaseTest;
 import org.traccar.config.Config;
 import org.traccar.config.Keys;
+import org.traccar.model.Device;
 import org.traccar.model.Position;
+import org.traccar.session.cache.CacheManager;
 
 import java.util.Date;
 
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 public class FilterHandlerTest extends BaseTest {
 
-    private FilterHandler passingHandler = new FilterHandler(new Config());
+    private FilterHandler passingHandler;
     private FilterHandler filteringHandler;
 
-    @Before
-    public void before() {
-        Config config = new Config();
-        config.setString(Keys.FILTER_INVALID, String.valueOf(true));
-        config.setString(Keys.FILTER_ZERO, String.valueOf(true));
-        config.setString(Keys.FILTER_DUPLICATE, String.valueOf(true));
-        config.setString(Keys.FILTER_FUTURE, String.valueOf(5 * 60));
-        config.setString(Keys.FILTER_APPROXIMATE, String.valueOf(true));
-        config.setString(Keys.FILTER_STATIC, String.valueOf(true));
-        config.setString(Keys.FILTER_DISTANCE, String.valueOf(10));
-        config.setString(Keys.FILTER_MAX_SPEED, String.valueOf(500));
-        config.setString(Keys.FILTER_SKIP_LIMIT, String.valueOf(10));
-        config.setString(Keys.FILTER_SKIP_ATTRIBUTES_ENABLE, String.valueOf(true));
-        filteringHandler = new FilterHandler(config);
+    @BeforeEach
+    public void passingHandler() {
+        var config = mock(Config.class);
+        when(config.getBoolean(Keys.FILTER_ENABLE)).thenReturn(true);
+        var cacheManager = mock(CacheManager.class);
+        when(cacheManager.getConfig()).thenReturn(config);
+        when(cacheManager.getObject(any(), anyLong())).thenReturn(mock(Device.class));
+        passingHandler = new FilterHandler(config, cacheManager, null, null);
     }
 
-    private Position createPosition(
-            long deviceId,
-            Date time,
-            boolean valid,
-            double latitude,
-            double longitude,
-            double altitude,
-            double speed,
-            double course) {
+    @BeforeEach
+    public void filteringHandler() {
+        var config = mock(Config.class);
+        when(config.getBoolean(Keys.FILTER_ENABLE)).thenReturn(true);
+        when(config.getBoolean(Keys.FILTER_INVALID)).thenReturn(true);
+        when(config.getBoolean(Keys.FILTER_ZERO)).thenReturn(true);
+        when(config.getBoolean(Keys.FILTER_DUPLICATE)).thenReturn(true);
+        when(config.getLong(Keys.FILTER_FUTURE)).thenReturn(5 * 60L);
+        when(config.getBoolean(Keys.FILTER_APPROXIMATE)).thenReturn(true);
+        when(config.getBoolean(Keys.FILTER_STATIC)).thenReturn(true);
+        when(config.getInteger(Keys.FILTER_DISTANCE)).thenReturn(10);
+        when(config.getInteger(Keys.FILTER_MAX_SPEED)).thenReturn(500);
+        when(config.getLong(Keys.FILTER_SKIP_LIMIT)).thenReturn(10L);
+        when(config.getBoolean(Keys.FILTER_SKIP_ATTRIBUTES_ENABLE)).thenReturn(true);
+        when(config.getString(Keys.FILTER_SKIP_ATTRIBUTES.getKey())).thenReturn("alarm,result");
+        var cacheManager = mock(CacheManager.class);
+        when(cacheManager.getConfig()).thenReturn(config);
+        when(cacheManager.getObject(any(), anyLong())).thenReturn(mock(Device.class));
+        filteringHandler = new FilterHandler(config, cacheManager, null, null);
+    }
 
+    private Position createPosition(Date time, boolean valid, double speed) {
         Position position = new Position();
-        position.setDeviceId(deviceId);
+        position.setDeviceId(0);
         position.setTime(time);
         position.setValid(valid);
-        position.setLatitude(latitude);
-        position.setLongitude(longitude);
-        position.setAltitude(altitude);
+        position.setLatitude(10);
+        position.setLongitude(10);
+        position.setAltitude(10);
         position.setSpeed(speed);
-        position.setCourse(course);
+        position.setCourse(10);
         return position;
     }
 
     @Test
     public void testFilter() {
 
-        Position position = createPosition(0, new Date(), true, 10, 10, 10, 10, 10);
+        Position position = createPosition(new Date(), true, 10);
 
-        assertNotNull(filteringHandler.handlePosition(position));
-        assertNotNull(passingHandler.handlePosition(position));
+        assertFalse(filteringHandler.filter(position));
+        assertFalse(passingHandler.filter(position));
 
-        position = createPosition(0, new Date(Long.MAX_VALUE), true, 10, 10, 10, 10, 10);
+        position = createPosition(new Date(Long.MAX_VALUE), true, 10);
 
-        assertNull(filteringHandler.handlePosition(position));
-        assertNotNull(passingHandler.handlePosition(position));
+        assertTrue(filteringHandler.filter(position));
+        assertFalse(passingHandler.filter(position));
 
-        position = createPosition(0, new Date(), false, 10, 10, 10, 10, 10);
+        position = createPosition(new Date(), false, 10);
 
-        assertNull(filteringHandler.handlePosition(position));
-        assertNotNull(passingHandler.handlePosition(position));
+        assertTrue(filteringHandler.filter(position));
+        assertFalse(passingHandler.filter(position));
 
     }
 
     @Test
     public void testSkipAttributes() {
 
-        Position position = createPosition(0, new Date(), true, 10, 10, 10, 0, 10);
+        Position position = createPosition(new Date(), true, 0);
         position.set(Position.KEY_ALARM, Position.ALARM_GENERAL);
 
-        assertNotNull(filteringHandler.handlePosition(position));
+        assertFalse(filteringHandler.filter(position));
 
     }
 
diff --git a/src/test/java/org/traccar/handler/MotionHandlerTest.java b/src/test/java/org/traccar/handler/MotionHandlerTest.java
index 9e0859664..10cdf6a90 100644
--- a/src/test/java/org/traccar/handler/MotionHandlerTest.java
+++ b/src/test/java/org/traccar/handler/MotionHandlerTest.java
@@ -1,16 +1,30 @@
 package org.traccar.handler;
 
-import static org.junit.Assert.assertEquals;
-
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+import org.traccar.config.Config;
+import org.traccar.config.Keys;
+import org.traccar.model.Device;
 import org.traccar.model.Position;
+import org.traccar.session.cache.CacheManager;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 public class MotionHandlerTest {
 
     @Test
     public void testCalculateMotion() {
 
-        MotionHandler motionHandler = new MotionHandler(0.01);
+        var cacheManager = mock(CacheManager.class);
+        when(cacheManager.getObject(eq(Device.class), anyLong())).thenReturn(mock(Device.class));
+        var config = mock(Config.class);
+        when(config.getString(Keys.EVENT_MOTION_SPEED_THRESHOLD.getKey())).thenReturn("0.01");
+        when(cacheManager.getConfig()).thenReturn(config);
+
+        MotionHandler motionHandler = new MotionHandler(cacheManager);
 
         Position position = motionHandler.handlePosition(new Position());
 
diff --git a/src/test/java/org/traccar/handler/events/AlertEventHandlerTest.java b/src/test/java/org/traccar/handler/events/AlertEventHandlerTest.java
index 3f0823245..66dc55c85 100644
--- a/src/test/java/org/traccar/handler/events/AlertEventHandlerTest.java
+++ b/src/test/java/org/traccar/handler/events/AlertEventHandlerTest.java
@@ -1,23 +1,24 @@
 package org.traccar.handler.events;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-
-import java.util.Map;
-
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.traccar.BaseTest;
-import org.traccar.TestIdentityManager;
 import org.traccar.config.Config;
 import org.traccar.model.Event;
 import org.traccar.model.Position;
+import org.traccar.session.cache.CacheManager;
+
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.mockito.Mockito.mock;
 
 public class AlertEventHandlerTest extends BaseTest {
 
     @Test
     public void testAlertEventHandler() {
         
-        AlertEventHandler alertEventHandler = new AlertEventHandler(new Config(), new TestIdentityManager());
+        AlertEventHandler alertEventHandler = new AlertEventHandler(new Config(), mock(CacheManager.class));
         
         Position position = new Position();
         position.set(Position.KEY_ALARM, Position.ALARM_GENERAL);
@@ -25,6 +26,7 @@ public class AlertEventHandlerTest extends BaseTest {
         assertNotNull(events);
         Event event = events.keySet().iterator().next();
         assertEquals(Event.TYPE_ALARM, event.getType());
+
     }
 
 }
diff --git a/src/test/java/org/traccar/handler/events/CommandResultEventHandlerTest.java b/src/test/java/org/traccar/handler/events/CommandResultEventHandlerTest.java
index 0ccf9f6b4..bc24e42f5 100644
--- a/src/test/java/org/traccar/handler/events/CommandResultEventHandlerTest.java
+++ b/src/test/java/org/traccar/handler/events/CommandResultEventHandlerTest.java
@@ -1,15 +1,15 @@
 package org.traccar.handler.events;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-
-import java.util.Map;
-
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.traccar.BaseTest;
 import org.traccar.model.Event;
 import org.traccar.model.Position;
 
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
 public class CommandResultEventHandlerTest extends BaseTest {
 
     @Test
diff --git a/src/test/java/org/traccar/handler/events/IgnitionEventHandlerTest.java b/src/test/java/org/traccar/handler/events/IgnitionEventHandlerTest.java
index dade20fb8..972932df4 100644
--- a/src/test/java/org/traccar/handler/events/IgnitionEventHandlerTest.java
+++ b/src/test/java/org/traccar/handler/events/IgnitionEventHandlerTest.java
@@ -1,21 +1,22 @@
 package org.traccar.handler.events;
 
-import static org.junit.Assert.assertNull;
-
-import java.util.Map;
-
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.traccar.BaseTest;
-import org.traccar.TestIdentityManager;
 import org.traccar.model.Event;
 import org.traccar.model.Position;
+import org.traccar.session.cache.CacheManager;
+
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.mockito.Mockito.mock;
 
 public class IgnitionEventHandlerTest extends BaseTest {
     
     @Test
     public void testIgnitionEventHandler() {
         
-        IgnitionEventHandler ignitionEventHandler = new IgnitionEventHandler(new TestIdentityManager());
+        IgnitionEventHandler ignitionEventHandler = new IgnitionEventHandler(mock(CacheManager.class));
         
         Position position = new Position();
         position.set(Position.KEY_IGNITION, true);
diff --git a/src/test/java/org/traccar/handler/events/MaintenanceEventHandlerTest.java b/src/test/java/org/traccar/handler/events/MaintenanceEventHandlerTest.java
new file mode 100644
index 000000000..5320be926
--- /dev/null
+++ b/src/test/java/org/traccar/handler/events/MaintenanceEventHandlerTest.java
@@ -0,0 +1,60 @@
+package org.traccar.handler.events;
+
+import org.junit.jupiter.api.Test;
+import org.traccar.BaseTest;
+import org.traccar.model.Maintenance;
+import org.traccar.model.Position;
+import org.traccar.session.cache.CacheManager;
+
+import java.util.Arrays;
+import java.util.Date;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.anyLong;
+
+public class MaintenanceEventHandlerTest extends BaseTest {
+    
+    @Test
+    public void testMaintenanceEventHandler() {
+        Position lastPosition = new Position();
+        lastPosition.setDeviceId(1);
+        lastPosition.setFixTime(new Date(0));
+
+        Position position = new Position();
+        position.setDeviceId(1);
+        position.setFixTime(new Date(0));
+
+        var maintenance = mock(Maintenance.class);
+        when(maintenance.getType()).thenReturn(Position.KEY_TOTAL_DISTANCE);
+        var maintenances = Arrays.asList(maintenance);
+
+        var cacheManager = mock(CacheManager.class);
+        when(cacheManager.getDeviceObjects(anyLong(), eq(Maintenance.class))).thenReturn(maintenances);
+        when(cacheManager.getPosition(anyLong())).thenReturn(lastPosition);
+        MaintenanceEventHandler eventHandler = new MaintenanceEventHandler(cacheManager);        
+
+        when(maintenance.getStart()).thenReturn(10000.0);
+        when(maintenance.getPeriod()).thenReturn(2000.0);                
+ 
+        lastPosition.set(Position.KEY_TOTAL_DISTANCE, 1999);
+        position.set(Position.KEY_TOTAL_DISTANCE, 2001);        
+        assertTrue(eventHandler.analyzePosition(position).isEmpty());
+
+        lastPosition.set(Position.KEY_TOTAL_DISTANCE, 3999);
+        position.set(Position.KEY_TOTAL_DISTANCE, 4001);        
+        assertTrue(eventHandler.analyzePosition(position).isEmpty());
+
+        lastPosition.set(Position.KEY_TOTAL_DISTANCE, 9999);
+        position.set(Position.KEY_TOTAL_DISTANCE, 10001);        
+        assertTrue(eventHandler.analyzePosition(position).size() == 1);
+
+        lastPosition.set(Position.KEY_TOTAL_DISTANCE, 11999);
+        position.set(Position.KEY_TOTAL_DISTANCE, 12001);        
+        assertTrue(eventHandler.analyzePosition(position).size() == 1);
+        
+    }
+
+}
diff --git a/src/test/java/org/traccar/handler/events/MotionEventHandlerTest.java b/src/test/java/org/traccar/handler/events/MotionEventHandlerTest.java
index f57c16635..c61ae913d 100644
--- a/src/test/java/org/traccar/handler/events/MotionEventHandlerTest.java
+++ b/src/test/java/org/traccar/handler/events/MotionEventHandlerTest.java
@@ -1,119 +1,112 @@
 package org.traccar.handler.events;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import org.junit.jupiter.api.Test;
+import org.traccar.BaseTest;
+import org.traccar.model.Event;
+import org.traccar.model.Position;
+import org.traccar.reports.common.TripsConfig;
+import org.traccar.session.state.MotionProcessor;
+import org.traccar.session.state.MotionState;
 
 import java.text.DateFormat;
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
-import java.util.Date;
-import java.util.Map;
 import java.util.TimeZone;
 
-import org.junit.Test;
-import org.traccar.BaseTest;
-import org.traccar.model.DeviceState;
-import org.traccar.model.Event;
-import org.traccar.model.Position;
-import org.traccar.reports.model.TripsConfig;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class MotionEventHandlerTest extends BaseTest {
 
-    private Date date(String time) throws ParseException {
+    private Position position(String time, boolean motion, double distance, Boolean ignition) throws ParseException {
+        Position position = new Position();
         DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
         dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
-        return dateFormat.parse(time);
+        position.setTime(dateFormat.parse(time));
+        position.set(Position.KEY_MOTION, motion);
+        position.set(Position.KEY_TOTAL_DISTANCE, distance);
+        position.set(Position.KEY_IGNITION, ignition);
+        return position;
+    }
+
+    private void verifyState(MotionState motionState, boolean state, long distance) {
+        assertEquals(state, motionState.getMotionState());
+        assertEquals(distance, motionState.getMotionDistance(), 0.1);
     }
 
     @Test
-    public void testMotionWithPosition() throws Exception {
-        MotionEventHandler motionEventHandler = new MotionEventHandler(
-                null, null, new TripsConfig(500, 300 * 1000, 300 * 1000, 0, false, false, 0.01));
+    public void testMotionWithPosition() throws ParseException {
+        TripsConfig tripsConfig = new TripsConfig(500, 300000, 300000, 0, false);
 
-        Position position = new Position();
-        position.setTime(date("2017-01-01 00:00:00"));
-        position.set(Position.KEY_MOTION, true);
-        position.set(Position.KEY_TOTAL_DISTANCE, 0);
-        DeviceState deviceState = new DeviceState();
-        deviceState.setMotionState(false);
-        deviceState.setMotionPosition(position);
-        Position nextPosition = new Position();
-
-        nextPosition.setTime(date("2017-01-01 00:02:00"));
-        nextPosition.set(Position.KEY_MOTION, true);
-        nextPosition.set(Position.KEY_TOTAL_DISTANCE, 200);
-
-        Map<Event, Position> events = motionEventHandler.updateMotionState(deviceState, nextPosition);
-        assertNull(events);
-
-        nextPosition.set(Position.KEY_TOTAL_DISTANCE, 600);
-        events = motionEventHandler.updateMotionState(deviceState, nextPosition);        
-        assertNotNull(events);
-        Event event = events.keySet().iterator().next();
-        assertEquals(Event.TYPE_DEVICE_MOVING, event.getType());
-        assertTrue(deviceState.getMotionState());
-        assertNull(deviceState.getMotionPosition());
-
-        deviceState.setMotionState(false);
-        deviceState.setMotionPosition(position);
-        nextPosition.setTime(date("2017-01-01 00:06:00"));
-        nextPosition.set(Position.KEY_TOTAL_DISTANCE, 200);
-        events = motionEventHandler.updateMotionState(deviceState, nextPosition);
-        assertNotNull(event);
-        event = events.keySet().iterator().next();
-        assertEquals(Event.TYPE_DEVICE_MOVING, event.getType());
-        assertTrue(deviceState.getMotionState());
-        assertNull(deviceState.getMotionPosition());
+        MotionState state = new MotionState();
+
+        MotionProcessor.updateState(state, position("2017-01-01 00:00:00", false, 0, null), false, tripsConfig);
+        assertNull(state.getEvent());
+        verifyState(state, false, 0);
+
+        MotionProcessor.updateState(state, position("2017-01-01 00:02:00", true, 100, null), true, tripsConfig);
+        assertNull(state.getEvent());
+        verifyState(state, true, 100);
+
+        MotionProcessor.updateState(state, position("2017-01-01 00:02:00", true, 700, null), true, tripsConfig);
+        assertEquals(Event.TYPE_DEVICE_MOVING, state.getEvent().getType());
+        verifyState(state, true, 0);
+
+        MotionProcessor.updateState(state, position("2017-01-01 00:03:00", false, 700, null), false, tripsConfig);
+        assertNull(state.getEvent());
+        verifyState(state, false, 700);
+
+        MotionProcessor.updateState(state, position("2017-01-01 00:10:00", false, 700, null), false, tripsConfig);
+        assertEquals(Event.TYPE_DEVICE_STOPPED, state.getEvent().getType());
+        verifyState(state, false, 0);
     }
 
     @Test
-    public void testMotionWithStatus() throws Exception {
-        MotionEventHandler motionEventHandler = new MotionEventHandler(
-                null, null, new TripsConfig(500, 300 * 1000, 300 * 1000, 0, false, false, 0.01));
+    public void testMotionFluctuation() throws ParseException {
+        TripsConfig tripsConfig = new TripsConfig(500, 300000, 300000, 0, false);
 
-        Position position = new Position();
-        position.setTime(new Date(System.currentTimeMillis() - 360000));
-        position.set(Position.KEY_MOTION, true);
-        DeviceState deviceState = new DeviceState();
-        deviceState.setMotionState(false);
-        deviceState.setMotionPosition(position);
-
-        Map<Event, Position> events = motionEventHandler.updateMotionState(deviceState);
-
-        assertNotNull(events);
-        Event event = events.keySet().iterator().next();
-        assertEquals(Event.TYPE_DEVICE_MOVING, event.getType());
-        assertTrue(deviceState.getMotionState());
-        assertNull(deviceState.getMotionPosition());
+        MotionState state = new MotionState();
+
+        MotionProcessor.updateState(state, position("2017-01-01 00:00:00", false, 0, null), false, tripsConfig);
+        assertNull(state.getEvent());
+        verifyState(state, false, 0);
+
+        MotionProcessor.updateState(state, position("2017-01-01 00:02:00", true, 100, null), true, tripsConfig);
+        assertNull(state.getEvent());
+        verifyState(state, true, 100);
+
+        MotionProcessor.updateState(state, position("2017-01-01 00:02:00", true, 700, null), true, tripsConfig);
+        assertEquals(Event.TYPE_DEVICE_MOVING, state.getEvent().getType());
+        verifyState(state, true, 0);
+
+        MotionProcessor.updateState(state, position("2017-01-01 00:03:00", false, 700, null), false, tripsConfig);
+        assertNull(state.getEvent());
+        verifyState(state, false, 700);
+
+        MotionProcessor.updateState(state, position("2017-01-01 00:04:00", true, 1000, null), true, tripsConfig);
+        assertNull(state.getEvent());
+        verifyState(state, true, 0);
+
+        MotionProcessor.updateState(state, position("2017-01-01 00:06:00", true, 2000, null), true, tripsConfig);
+        assertNull(state.getEvent());
+        verifyState(state, true, 0);
     }
 
     @Test
-    public void testStopWithPositionIgnition() throws Exception {
-        MotionEventHandler motionEventHandler = new MotionEventHandler(
-                null, null, new TripsConfig(500, 300 * 1000, 300 * 1000, 0, true, false, 0.01));
+    public void testStopWithPositionIgnition() throws ParseException {
+        TripsConfig tripsConfig = new TripsConfig(500, 300000, 300000, 0, true);
 
-        Position position = new Position();
-        position.setTime(date("2017-01-01 00:00:00"));
-        position.set(Position.KEY_MOTION, false);
-        position.set(Position.KEY_IGNITION, true);
-        DeviceState deviceState = new DeviceState();
-        deviceState.setMotionState(true);
-        deviceState.setMotionPosition(position);
-
-        Position nextPosition = new Position();
-        nextPosition.setTime(date("2017-01-01 00:02:00"));
-        nextPosition.set(Position.KEY_MOTION, false);
-        nextPosition.set(Position.KEY_IGNITION, false);
-
-        Map<Event, Position> events = motionEventHandler.updateMotionState(deviceState, nextPosition);
-        assertNotNull(events);
-        Event event = events.keySet().iterator().next();
-        assertEquals(Event.TYPE_DEVICE_STOPPED, event.getType());
-        assertFalse(deviceState.getMotionState());
-        assertNull(deviceState.getMotionPosition());
+        MotionState state = new MotionState();
+        state.setMotionStreak(true);
+        state.setMotionState(true);
+
+        MotionProcessor.updateState(state, position("2017-01-01 00:00:00", false, 100, true), false, tripsConfig);
+        assertNull(state.getEvent());
+        verifyState(state, false, 100);
+
+        MotionProcessor.updateState(state, position("2017-01-01 00:02:00", false, 100, false), false, tripsConfig);
+        assertEquals(Event.TYPE_DEVICE_STOPPED, state.getEvent().getType());
+        verifyState(state, false, 0);
     }
 
 }
diff --git a/src/test/java/org/traccar/handler/events/OverspeedEventHandlerTest.java b/src/test/java/org/traccar/handler/events/OverspeedEventHandlerTest.java
index 515f37b5d..97d929551 100644
--- a/src/test/java/org/traccar/handler/events/OverspeedEventHandlerTest.java
+++ b/src/test/java/org/traccar/handler/events/OverspeedEventHandlerTest.java
@@ -1,128 +1,68 @@
 package org.traccar.handler.events;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
+import org.junit.jupiter.api.Test;
+import org.traccar.BaseTest;
+import org.traccar.model.Event;
+import org.traccar.model.Position;
+import org.traccar.session.state.OverspeedProcessor;
+import org.traccar.session.state.OverspeedState;
 
 import java.text.DateFormat;
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
-import java.util.Date;
-import java.util.Map;
 import java.util.TimeZone;
 
-import org.junit.Test;
-import org.traccar.BaseTest;
-import org.traccar.config.Config;
-import org.traccar.config.Keys;
-import org.traccar.model.DeviceState;
-import org.traccar.model.Event;
-import org.traccar.model.Position;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class OverspeedEventHandlerTest  extends BaseTest {
 
-    private Date date(String time) throws ParseException {
+    private Position position(String time, double speed) throws ParseException {
+        Position position = new Position();
         DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
         dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
-        return dateFormat.parse(time);
+        position.setTime(dateFormat.parse(time));
+        position.setSpeed(speed);
+        return position;
     }
 
-    private void testOverspeedWithPosition(boolean notRepeat, long geofenceId) throws ParseException {
-        Config config = new Config();
-        config.setString(Keys.EVENT_OVERSPEED_NOT_REPEAT, String.valueOf(notRepeat));
-        config.setString(Keys.EVENT_OVERSPEED_MINIMAL_DURATION, String.valueOf(15));
-        config.setString(Keys.EVENT_OVERSPEED_PREFER_LOWEST, String.valueOf(false));
-        OverspeedEventHandler overspeedEventHandler = new OverspeedEventHandler(config, null, null);
-
-        Position position = new Position();
-        position.setTime(date("2017-01-01 00:00:00"));
-        position.setSpeed(50);
-        DeviceState deviceState = new DeviceState();
-        deviceState.setOverspeedState(false);
-
-        Map<Event, Position> events = overspeedEventHandler.updateOverspeedState(deviceState, position, 40, geofenceId);
-        assertNull(events);
-        assertFalse(deviceState.getOverspeedState());
-        assertEquals(position, deviceState.getOverspeedPosition());
-        assertEquals(geofenceId, deviceState.getOverspeedGeofenceId());
-
-        Position nextPosition = new Position();
-        nextPosition.setTime(date("2017-01-01 00:00:10"));
-        nextPosition.setSpeed(55);
-
-        events = overspeedEventHandler.updateOverspeedState(deviceState, nextPosition, 40, geofenceId);
-        assertNull(events);
-
-        nextPosition.setTime(date("2017-01-01 00:00:20"));
-
-        events = overspeedEventHandler.updateOverspeedState(deviceState, nextPosition, 40, geofenceId);
-        assertNotNull(events);
-        Event event = events.keySet().iterator().next();
-        assertEquals(Event.TYPE_DEVICE_OVERSPEED, event.getType());
-        assertEquals(50, event.getDouble("speed"), 0.1);
-        assertEquals(40, event.getDouble(OverspeedEventHandler.ATTRIBUTE_SPEED_LIMIT), 0.1);
-        assertEquals(geofenceId, event.getGeofenceId());
-
-        assertEquals(notRepeat, deviceState.getOverspeedState());
-        assertNull(deviceState.getOverspeedPosition());
-        assertEquals(0, deviceState.getOverspeedGeofenceId());
-
-        nextPosition.setTime(date("2017-01-01 00:00:30"));
-        events = overspeedEventHandler.updateOverspeedState(deviceState, nextPosition, 40, geofenceId);
-        assertNull(events);
-        assertEquals(notRepeat, deviceState.getOverspeedState());
+    private void verifyState(OverspeedState overspeedState, boolean state, long geofenceId) {
+        assertEquals(state, overspeedState.getOverspeedState());
+        assertEquals(geofenceId, overspeedState.getOverspeedGeofenceId());
+    }
 
-        if (notRepeat) {
-            assertNull(deviceState.getOverspeedPosition());
-            assertEquals(0, deviceState.getOverspeedGeofenceId());
-        } else {
-            assertNotNull(deviceState.getOverspeedPosition());
-            assertEquals(geofenceId, deviceState.getOverspeedGeofenceId());
-        }
+    private void testOverspeedWithPosition(long geofenceId) throws ParseException {
+        OverspeedState state = new OverspeedState();
 
-        nextPosition.setTime(date("2017-01-01 00:00:40"));
-        nextPosition.setSpeed(30);
+        OverspeedProcessor.updateState(state, position("2017-01-01 00:00:00", 50), 40, 1, 15000, geofenceId);
+        assertNull(state.getEvent());
+        verifyState(state, true, geofenceId);
 
-        events = overspeedEventHandler.updateOverspeedState(deviceState, nextPosition, 40, geofenceId);
-        assertNull(events);
-        assertFalse(deviceState.getOverspeedState());
-        assertNull(deviceState.getOverspeedPosition());
-        assertEquals(0, deviceState.getOverspeedGeofenceId());
-    }
+        OverspeedProcessor.updateState(state, position("2017-01-01 00:00:10", 55), 40, 1, 15000, geofenceId);
+        assertNull(state.getEvent());
 
-    private void testOverspeedWithStatus(boolean notRepeat) {
-        Config config = new Config();
-        config.setString(Keys.EVENT_OVERSPEED_NOT_REPEAT, String.valueOf(notRepeat));
-        config.setString(Keys.EVENT_OVERSPEED_MINIMAL_DURATION, String.valueOf(15));
-        config.setString(Keys.EVENT_OVERSPEED_PREFER_LOWEST, String.valueOf(false));
-        OverspeedEventHandler overspeedEventHandler = new OverspeedEventHandler(config, null, null);
+        OverspeedProcessor.updateState(state, position("2017-01-01 00:00:20", 55), 40, 1, 15000, geofenceId);
+        assertNotNull(state.getEvent());
+        assertEquals(Event.TYPE_DEVICE_OVERSPEED, state.getEvent().getType());
+        assertEquals(55, state.getEvent().getDouble("speed"), 0.1);
+        assertEquals(40, state.getEvent().getDouble("speedLimit"), 0.1);
+        assertEquals(geofenceId, state.getEvent().getGeofenceId());
+        verifyState(state, true, 0);
 
-        Position position = new Position();
-        position.setTime(new Date(System.currentTimeMillis() - 30000));
-        position.setSpeed(50);
-        DeviceState deviceState = new DeviceState();
-        deviceState.setOverspeedState(false);
-        deviceState.setOverspeedPosition(position);
+        OverspeedProcessor.updateState(state, position("2017-01-01 00:00:30", 55), 40, 1, 15000, geofenceId);
+        assertNull(state.getEvent());
+        verifyState(state, true, 0);
 
-        Map<Event, Position> events = overspeedEventHandler.updateOverspeedState(deviceState, 40);
-
-        assertNotNull(events);
-        Event event = events.keySet().iterator().next();
-        assertEquals(Event.TYPE_DEVICE_OVERSPEED, event.getType());
-        assertEquals(notRepeat, deviceState.getOverspeedState());
+        OverspeedProcessor.updateState(state, position("2017-01-01 00:00:30", 30), 40, 1, 15000, geofenceId);
+        assertNull(state.getEvent());
+        verifyState(state, false, 0);
     }
 
     @Test
     public void testOverspeedEventHandler() throws Exception {
-        testOverspeedWithPosition(false, 0);
-        testOverspeedWithPosition(true, 0);
-        
-        testOverspeedWithPosition(false, 1);
-        testOverspeedWithPosition(true, 1);
-
-        testOverspeedWithStatus(false);
-        testOverspeedWithStatus(true);
+        testOverspeedWithPosition(0);
+        testOverspeedWithPosition(1);
     }
 
 }