[stats-collector] composition instead of inheritance, refactoring

plugins/stats-collector/log-events/src/com/intellij/stats/events/completion/EventStreamValidator.kt

@@ -15,6 +15,7 @@
  */
 package com.intellij.stats.events.completion
 
+
 data class EventLine(val event: LogEvent?,
                      val unknownLogEventFields: Set<String>,
                      val absentLogEventFields: Set<String>,
@@ -29,21 +30,37 @@ data class EventLine(val event: LogEvent?,
         get() = event != null && unknownLogEventFields.isEmpty() && absentLogEventFields.isEmpty()
 }
 
-open class SessionsFilter {
 
-    private val output = mutableListOf<String>()
+interface SessionValidationResult {
+    fun addErrorSession(errorSession: List<EventLine>)
+    fun addValidSession(validSession: List<EventLine>)
+}
+
+
+open class SimpleSessionValidationResult: SessionValidationResult {
     private val error = mutableListOf<String>()
-
-    val outputLines: List<String>
-        get() = output
+    private val valid = mutableListOf<String>()
 
     val errorLines: List<String>
         get() = error
 
+    val validLines: List<String>
+        get() = valid
+
+    override fun addErrorSession(errorSession: List<EventLine>) {
+        error.addAll(errorSession.map { it.originalLine })
+    }
+
+    override fun addValidSession(validSession: List<EventLine>) {
+        valid.addAll(validSession.map { it.originalLine })
+    }
+}
+
+
+class InputSessionValidator(private val sessionValidationResult: SessionValidationResult) {
 
     fun filter(input: Iterable<String>) {
-        var currentSession: String? = null
-
+        var currentSessionUid: String? = null
         val session = mutableListOf<EventLine>()
 
         for (line in input) {
@@ -52,13 +69,13 @@ open class SessionsFilter {
             val event = LogEventSerializer.fromString(line)
             val eventLine = EventLine(event, line)
 
-            if (eventLine.sessionUid == currentSession) {
+            if (eventLine.sessionUid == currentSessionUid) {
                 session.add(eventLine)
             }
             else {
                 processCompletionSession(session)
                 session.clear()
-                currentSession = eventLine.sessionUid
+                currentSessionUid = eventLine.sessionUid
                 session.add(eventLine)
             }
         }
@@ -85,10 +102,12 @@ open class SessionsFilter {
         dumpSession(session, isValidSession)
     }
 
-    open protected fun dumpSession(session: List<EventLine>, isValidSession: Boolean) {
-        val writer = if (isValidSession) output else error
-        session.forEach {
-            writer.add(it.originalLine)
+    private fun dumpSession(session: List<EventLine>, isValidSession: Boolean) {
+        if (isValidSession) {
+            sessionValidationResult.addValidSession(session)
+        }
+        else {
+            sessionValidationResult.addErrorSession(session)
         }
     }
 

plugins/stats-collector/log-events/test/com/intellij/stats/events/completion/EventStreamValidatorTest.kt

@@ -72,12 +72,12 @@ class EventStreamValidatorTest {
                          expectedOut: List<String>,
                          expectedErr: List<String>) {
         val input: List<String> = list.map { LogEventSerializer.toString(it) }
-        val separator = SessionsFilter()
+        val result = SimpleSessionValidationResult()
+        val separator = InputSessionValidator(result)
         separator.filter(input)
 
-        assertThat(separator.errorLines).isEqualTo(expectedErr)
-        assertThat(separator.outputLines).isEqualTo(expectedOut)
+        assertThat(result.errorLines).isEqualTo(expectedErr)
+        assertThat(result.validLines).isEqualTo(expectedOut)
     }
 
-}
-
+}

plugins/stats-collector/log-events/test/com/intellij/stats/events/completion/ValidatorTest.kt

@@ -7,11 +7,24 @@ import java.io.File
 
 class ValidatorTest {
 
-    lateinit var separator: SessionsFilter
+    lateinit var separator: InputSessionValidator
+    val sessionStatuses = hashMapOf<String, Boolean>()
 
     @Before
     fun setup() {
-        separator = SessionsFilter()
+        sessionStatuses.clear()
+        val result = object : SessionValidationResult {
+            override fun addErrorSession(errorSession: List<EventLine>) {
+                val sessionUid = errorSession.first().sessionUid ?: return
+                sessionStatuses[sessionUid] = false
+            }
+
+            override fun addValidSession(validSession: List<EventLine>) {
+                val sessionUid = validSession.first().sessionUid ?: return
+                sessionStatuses[sessionUid] = true
+            }
+        }
+        separator = InputSessionValidator(result)
     }
 
     private fun file(path: String): File {
@@ -21,25 +34,11 @@ class ValidatorTest {
     @Test
     fun testDataWithDeserializationErrors() {
         val file = file("data/validation_data")
-        val separator = TestSessionSeparator()
         separator.filter(file.readLines())
 
-        val statuses = separator.sessionsStatus
-        assertThat(statuses["520198a29326"]).isFalse()
-        assertThat(statuses["620198a29326"]).isTrue()
-        assertThat(statuses["720198a29326"]).isFalse()
-    }
-
-}
-
-
-class TestSessionSeparator : SessionsFilter() {
-
-    val sessionsStatus = mutableMapOf<String, Boolean>()
-
-    override fun dumpSession(session: List<EventLine>, isValidSession: Boolean) {
-        val sessionUid = session.first().event!!.sessionUid
-        sessionsStatus[sessionUid] = isValidSession
+        assertThat(sessionStatuses["520198a29326"]).isFalse()
+        assertThat(sessionStatuses["620198a29326"]).isTrue()
+        assertThat(sessionStatuses["720198a29326"]).isFalse()
     }
 
 }