add unit test on filters

app/src/androidTest/java/net/pokeranalytics/android/FilterInstrumentedUnitTest.kt

@@ -0,0 +1,290 @@
+package net.pokeranalytics.android
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import io.realm.RealmResults
+import net.pokeranalytics.android.model.filter.FilterManager
+import net.pokeranalytics.android.model.filter.SessionFilterable
+import net.pokeranalytics.android.model.realm.Bankroll
+import net.pokeranalytics.android.model.realm.Session
+import org.junit.Assert
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.util.*
+
+@RunWith(AndroidJUnit4::class)
+class FilterInstrumentedUnitTest : RealmInstrumentedUnitTest() {
+
+    @Test
+    fun testCashFilter() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+
+        val s1 = realm.createObject(Session::class.java, "1")
+        val s2 = realm.createObject(Session::class.java, "2")
+        s1.type = Session.Type.CASH_GAME.ordinal
+        s2.type = Session.Type.TOURNAMENT.ordinal
+        realm.commitTransaction()
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(SessionFilterable.CASH)
+        ) as RealmResults<Session>
+
+        Assert.assertEquals(1, sessions.size)
+        sessions[0]?.run {
+            Assert.assertEquals(Session.Type.CASH_GAME.ordinal, this.type)
+        }
+    }
+
+    @Test
+    fun testTournamentFilter() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+
+        val s1 = realm.createObject(Session::class.java, "1")
+        val s2 = realm.createObject(Session::class.java, "2")
+        s1.type = Session.Type.CASH_GAME.ordinal
+        s2.type = Session.Type.TOURNAMENT.ordinal
+        realm.commitTransaction()
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(SessionFilterable.CASH)
+        ) as RealmResults<Session>
+
+        Assert.assertEquals(1, sessions.size)
+        sessions[0]?.run {
+            Assert.assertEquals(Session.Type.TOURNAMENT.ordinal, this.type)
+        }
+    }
+
+    @Test
+    fun testLiveFilter() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+
+        val s1 = realm.createObject(Session::class.java, "1")
+        val s2 = realm.createObject(Session::class.java, "2")
+        val b1 = realm.createObject(Bankroll::class.java, "1")
+        val b2 = realm.createObject(Bankroll::class.java, "2")
+
+        b1.live = true
+        b2.live = false
+
+        s1.bankroll = b1
+        s2.bankroll = b2
+
+        realm.commitTransaction()
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(SessionFilterable.LIVE)
+        ) as RealmResults<Session>
+
+        Assert.assertEquals(1, sessions.size)
+        sessions[0]?.bankroll?.run {
+            Assert.assertEquals(true, this.live)
+        }
+    }
+
+    @Test
+    fun testOnlineFilter() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+
+        val s1 = realm.createObject(Session::class.java, "1")
+        val s2 = realm.createObject(Session::class.java, "2")
+        val b1 = realm.createObject(Bankroll::class.java, "1")
+        val b2 = realm.createObject(Bankroll::class.java, "2")
+
+        b1.live = false
+        b2.live = true
+
+        s1.bankroll = b1
+        s2.bankroll = b2
+
+        realm.commitTransaction()
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(SessionFilterable.ONLINE)
+        ) as RealmResults<Session>
+
+        Assert.assertEquals(1, sessions.size)
+        sessions[0]?.bankroll?.run {
+            Assert.assertEquals(false, this.live)
+        }
+    }
+
+    @Test
+    fun testStartedFomDateFilter() {
+
+        val realm = this.mockRealm
+
+        val cal = Calendar.getInstance() // creates calendar
+        cal.time = Date() // sets calendar time/date
+        realm.beginTransaction()
+
+        val s1 = realm.createObject(Session::class.java, "1")
+        val s2 = realm.createObject(Session::class.java, "2")
+
+        s1.startDate = cal.time
+
+        cal.add(Calendar.HOUR_OF_DAY, 1) // adds one hour
+        s1.endDate = cal.time // returns new date object, one hour in the future
+
+        cal.add(Calendar.HOUR_OF_DAY, 1) // adds one hour
+        s2.startDate = cal.time
+
+        cal.add(Calendar.HOUR_OF_DAY, 1) // adds one hour
+        s2.endDate = cal.time // returns new date object, one hour in the future
+
+
+        realm.commitTransaction()
+
+        var filter = SessionFilterable.STARTED_FROM_DATE
+        filter.valueMap = mapOf("date" to s2.startDate)
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        ) as RealmResults<Session>
+
+        Assert.assertEquals(1, sessions.size)
+        sessions[0]?.run {
+            Assert.assertEquals("2", this.id)
+        }
+    }
+
+    @Test
+    fun testStartedToDateFilter() {
+
+        val realm = this.mockRealm
+
+        val cal = Calendar.getInstance() // creates calendar
+        cal.time = Date() // sets calendar time/date
+        realm.beginTransaction()
+
+        val s1 = realm.createObject(Session::class.java, "1")
+        val s2 = realm.createObject(Session::class.java, "2")
+
+        s1.startDate = cal.time
+
+        cal.add(Calendar.HOUR_OF_DAY, 1) // adds one hour
+        s1.endDate = cal.time // returns new date object, one hour in the future
+
+        cal.add(Calendar.HOUR_OF_DAY, 1) // adds one hour
+        s2.startDate = cal.time
+
+        cal.add(Calendar.HOUR_OF_DAY, 1) // adds one hour
+        s2.endDate = cal.time // returns new date object, one hour in the future
+
+
+        realm.commitTransaction()
+
+        var filter = SessionFilterable.STARTED_TO_DATE
+        filter.valueMap = mapOf("date" to s1.startDate)
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        ) as RealmResults<Session>
+
+        Assert.assertEquals(1, sessions.size)
+        sessions[0]?.run {
+            Assert.assertEquals("1", this.id)
+        }
+    }
+
+    @Test
+    fun testEndedFomDateFilter() {
+
+        val realm = this.mockRealm
+
+        val cal = Calendar.getInstance() // creates calendar
+        cal.time = Date() // sets calendar time/date
+        realm.beginTransaction()
+
+        val s1 = realm.createObject(Session::class.java, "1")
+        val s2 = realm.createObject(Session::class.java, "2")
+
+        s1.startDate = cal.time
+
+        cal.add(Calendar.HOUR_OF_DAY, 1) // adds one hour
+        s1.endDate = cal.time // returns new date object, one hour in the future
+
+        cal.add(Calendar.HOUR_OF_DAY, 1) // adds one hour
+        s2.startDate = cal.time
+
+        cal.add(Calendar.HOUR_OF_DAY, 1) // adds one hour
+        s2.endDate = cal.time // returns new date object, one hour in the future
+
+
+        realm.commitTransaction()
+
+        var filter = SessionFilterable.ENDED_FROM_DATE
+        filter.valueMap = mapOf("date" to s2.endDate)
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        ) as RealmResults<Session>
+
+        Assert.assertEquals(1, sessions.size)
+        sessions[0]?.run {
+            Assert.assertEquals("2", this.id)
+        }
+    }
+
+    @Test
+    fun testEndedToDateFilter() {
+
+        val realm = this.mockRealm
+
+        val cal = Calendar.getInstance() // creates calendar
+        cal.time = Date() // sets calendar time/date
+        realm.beginTransaction()
+
+        val s1 = realm.createObject(Session::class.java, "1")
+        val s2 = realm.createObject(Session::class.java, "2")
+
+        s1.startDate = cal.time
+
+        cal.add(Calendar.HOUR_OF_DAY, 1) // adds one hour
+        s1.endDate = cal.time // returns new date object, one hour in the future
+
+        cal.add(Calendar.HOUR_OF_DAY, 1) // adds one hour
+        s2.startDate = cal.time
+
+        cal.add(Calendar.HOUR_OF_DAY, 1) // adds one hour
+        s2.endDate = cal.time // returns new date object, one hour in the future
+
+
+        realm.commitTransaction()
+
+        var filter = SessionFilterable.ENDED_TO_DATE
+        filter.valueMap = mapOf("date" to s1.endDate)
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        ) as RealmResults<Session>
+
+        Assert.assertEquals(1, sessions.size)
+        sessions[0]?.run {
+            Assert.assertEquals("1", this.id)
+        }
+    }
+}