mirror of
https://github.com/kalarina-bit/Sparkledns.git
synced 2026-11-22 07:36:09 +00:00
Release v1.1.2
This commit is contained in:
@@ -24,6 +24,15 @@ class BlocklistMatchTest {
|
||||
assertFalse(isBlockedIn("ads.example.com", LongArray(0), LongArray(0)))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun skipsTrailingDots() {
|
||||
val lists = set("example.com")
|
||||
|
||||
assertTrue(isBlockedIn("www.example.com..", lists, LongArray(0)))
|
||||
assertFalse(isBlockedIn("example.org.", lists, LongArray(0)))
|
||||
assertFalse(isBlockedIn("...", lists, LongArray(0)))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun mergesSortedListsWithoutDuplicates() {
|
||||
val a = longArrayOf(-5, 1, 4, 9)
|
||||
|
||||
@@ -49,5 +49,6 @@ class BlocklistParserTest {
|
||||
val name = "a.b.example.com"
|
||||
assertEquals(DomainHash.of("example.com"), DomainHash.of(name, name.indexOf("example")))
|
||||
assertEquals(DomainHash.of(name), DomainHash.of(name, 0))
|
||||
assertEquals(DomainHash.of("b.example"), DomainHash.of(name, 2, name.indexOf(".com")))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,43 @@
|
||||
package cc.skysparkle.sparkledns
|
||||
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertNull
|
||||
import org.junit.Test
|
||||
|
||||
class CompaniesTest {
|
||||
|
||||
@Test
|
||||
fun matchesDomainsAndTheirSubdomains() {
|
||||
assertEquals(Company.GOOGLE, Companies.of("youtube.com"))
|
||||
assertEquals(Company.GOOGLE, Companies.of("r3---sn-abc.googlevideo.com"))
|
||||
assertEquals(Company.META, Companies.of("scontent.cdninstagram.com"))
|
||||
assertEquals(Company.X, Companies.of("t.co"))
|
||||
assertEquals(Company.MICROSOFT, Companies.of("api.github.com"))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun ignoresCaseAndTrailingDots() {
|
||||
assertEquals(Company.APPLE, Companies.of("WWW.Apple.COM"))
|
||||
assertEquals(Company.AMAZON, Companies.of("s3.amazonaws.com."))
|
||||
assertEquals(Company.AMAZON, Companies.of("s3.amazonaws.com.."))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun knowsGoogleCountrySites() {
|
||||
assertEquals(Company.GOOGLE, Companies.of("google.de"))
|
||||
assertEquals(Company.GOOGLE, Companies.of("www.google.co.uk"))
|
||||
assertEquals(Company.GOOGLE, Companies.of("google.com.br"))
|
||||
assertNull(Companies.of("google.example.org"))
|
||||
assertNull(Companies.of("google."))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun leavesOtherDomainsAlone() {
|
||||
assertNull(Companies.of("example.com"))
|
||||
assertNull(Companies.of("notyoutube.com"))
|
||||
assertNull(Companies.of("youtube.com.example"))
|
||||
assertNull(Companies.of("com"))
|
||||
assertNull(Companies.of(""))
|
||||
assertNull(Companies.of("."))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,126 @@
|
||||
package cc.skysparkle.sparkledns
|
||||
|
||||
import org.junit.Assert.assertArrayEquals
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertNull
|
||||
import org.junit.Test
|
||||
import java.io.ByteArrayInputStream
|
||||
import java.io.ByteArrayOutputStream
|
||||
import java.io.DataInputStream
|
||||
import java.io.DataOutputStream
|
||||
|
||||
class HourlyCountersTest {
|
||||
|
||||
private val hours = HourlyCounters.HOURS
|
||||
|
||||
@Test
|
||||
fun countsQueriesPerHour() {
|
||||
val counters = HourlyCounters()
|
||||
counters.record(QueryStatus.OK, 40, Company.GOOGLE, hour = 100)
|
||||
counters.record(QueryStatus.OK, 20, null, hour = 100)
|
||||
counters.record(QueryStatus.BLOCKED, 0, Company.META, hour = 100)
|
||||
counters.record(QueryStatus.CACHED, 0, null, hour = 99)
|
||||
counters.record(QueryStatus.FAILED, 5000, null, hour = 99)
|
||||
|
||||
val day = counters.summary(24, currentHour = 100)
|
||||
assertEquals(5L, day.total)
|
||||
assertEquals(1L, day.blocked)
|
||||
assertEquals(1L, day.cached)
|
||||
assertEquals(30, day.avgLatencyMs)
|
||||
assertEquals(1L, day.companies[Company.GOOGLE.ordinal])
|
||||
assertEquals(1L, day.companies[Company.META.ordinal])
|
||||
assertEquals(3L, counters.summary(1, currentHour = 100).total)
|
||||
|
||||
val points = counters.hourly(3, currentHour = 100)
|
||||
assertEquals(listOf(0L, 2L, 3L), points.map { it.total })
|
||||
assertEquals(listOf(0L, 0L, 1L), points.map { it.blocked })
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aSlotStartsOverAWeekLater() {
|
||||
val counters = HourlyCounters()
|
||||
counters.record(QueryStatus.OK, 10, null, hour = 5)
|
||||
counters.record(QueryStatus.OK, 10, null, hour = 5L + hours)
|
||||
|
||||
assertEquals(1L, counters.summary(hours, currentHour = 5L + hours).total)
|
||||
assertEquals(0L, counters.summary(1, currentHour = 5).total)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun savedNumbersReadBackUnchanged() {
|
||||
val counters = HourlyCounters()
|
||||
counters.record(QueryStatus.BLOCKED, 0, Company.XIAOMI, hour = 1000)
|
||||
counters.record(QueryStatus.OK, 12, Company.APPLE, hour = 1001)
|
||||
|
||||
val copy = requireNotNull(HourlyCounters.decode(counters.encode()))
|
||||
|
||||
assertArrayEquals(counters.hourIds, copy.hourIds)
|
||||
for (index in 0 until hours) assertArrayEquals(counters.rows[index], copy.rows[index])
|
||||
}
|
||||
|
||||
@Test
|
||||
fun writesFormatOne() {
|
||||
val bytes = HourlyCounters().encode()
|
||||
val input = DataInputStream(ByteArrayInputStream(bytes))
|
||||
|
||||
assertEquals(1, input.readInt())
|
||||
assertEquals(HourlyCounters.FIELDS, input.readInt())
|
||||
assertEquals(hours, input.readInt())
|
||||
assertEquals(-1L, input.readLong())
|
||||
assertEquals(12 + hours * (HourlyCounters.FIELDS + 1) * 8, bytes.size)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun readsFilesFromVersionsWithFewerCompanies() {
|
||||
// A file from a version that knew two companies: field n of hour 7 holds n + 1
|
||||
val fields = HourlyCounters.FIRST_COMPANY + 2
|
||||
val bytes = ByteArrayOutputStream()
|
||||
DataOutputStream(bytes).use { out ->
|
||||
out.writeInt(1)
|
||||
out.writeInt(fields)
|
||||
out.writeInt(hours)
|
||||
for (index in 0 until hours) {
|
||||
out.writeLong(if (index == 7) 7L else -1L)
|
||||
for (field in 0 until fields) out.writeLong(if (index == 7) field + 1L else 0L)
|
||||
}
|
||||
}
|
||||
|
||||
val summary = requireNotNull(HourlyCounters.decode(bytes.toByteArray())).summary(1, currentHour = 7)
|
||||
|
||||
assertEquals(1L, summary.total)
|
||||
assertEquals(2L, summary.blocked)
|
||||
assertEquals(3L, summary.cached)
|
||||
assertEquals(0, summary.avgLatencyMs) // latency sum 4, count 5
|
||||
assertArrayEquals(longArrayOf(6, 7) + LongArray(Company.entries.size - 2), summary.companies)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun refusesOtherFormats() {
|
||||
val bytes = HourlyCounters().encode()
|
||||
bytes[3] = 2
|
||||
|
||||
assertNull(HourlyCounters.decode(bytes))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun mergeKeepsWhatWasCountedBeforeTheFileWasRead() {
|
||||
val saved = HourlyCounters()
|
||||
saved.record(QueryStatus.OK, 10, null, hour = 50)
|
||||
saved.record(QueryStatus.OK, 10, null, hour = 49)
|
||||
|
||||
val live = HourlyCounters()
|
||||
live.record(QueryStatus.BLOCKED, 0, null, hour = 50)
|
||||
live.merge(saved)
|
||||
|
||||
assertEquals(2L, live.summary(1, currentHour = 50).total)
|
||||
assertEquals(1L, live.summary(1, currentHour = 50).blocked)
|
||||
assertEquals(3L, live.summary(2, currentHour = 50).total)
|
||||
|
||||
// A slot already holding a newer hour keeps it
|
||||
val later = HourlyCounters()
|
||||
later.record(QueryStatus.OK, 10, null, hour = 50L + hours)
|
||||
later.merge(saved)
|
||||
|
||||
assertEquals(1L, later.summary(1, currentHour = 50L + hours).total)
|
||||
}
|
||||
}
|
||||
@@ -18,8 +18,8 @@ class PacketTest {
|
||||
val parsed = requireNotNull(Packet.parseDnsQuery(packet, packet.size))
|
||||
|
||||
assertArrayEquals(query, parsed.payload)
|
||||
assertArrayEquals(client, parsed.srcIp)
|
||||
assertArrayEquals(server, parsed.dstIp)
|
||||
assertEquals(i32(client, 0), parsed.srcIp)
|
||||
assertEquals(i32(server, 0), parsed.dstIp)
|
||||
assertEquals(40000, parsed.srcPort)
|
||||
assertEquals(53, parsed.dstPort)
|
||||
}
|
||||
|
||||
@@ -0,0 +1,43 @@
|
||||
package cc.skysparkle.sparkledns
|
||||
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertNotSame
|
||||
import org.junit.Assert.assertSame
|
||||
import org.junit.Test
|
||||
|
||||
// The screens refresh once a second; a refresh that brings the same object has nothing to update
|
||||
class RefreshTest {
|
||||
|
||||
@Test
|
||||
fun logSnapshotIsReusedUntilTheLogChanges() {
|
||||
QueryLog.clear()
|
||||
val empty = QueryLog.snapshot()
|
||||
assertSame(empty, QueryLog.snapshot())
|
||||
|
||||
QueryLog.add(DnsMessage.Question("example.com", 1), QueryStatus.OK, 10)
|
||||
QueryLog.add(DnsMessage.Question("example.org", 28), QueryStatus.CACHED, 0)
|
||||
val filled = QueryLog.snapshot()
|
||||
|
||||
assertNotSame(empty, filled)
|
||||
assertEquals(listOf("example.org", "example.com"), filled.map { it.domain })
|
||||
assertSame(filled, QueryLog.snapshot())
|
||||
|
||||
QueryLog.clear()
|
||||
assertEquals(0, QueryLog.snapshot().size)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun summaryIsReusedUntilSomethingChanges() {
|
||||
val now = 1_000 * 3_600_000L
|
||||
val first = StatsStore.summary(24, now)
|
||||
assertSame(first, StatsStore.summary(24, now))
|
||||
assertNotSame(first, StatsStore.summary(24 * 7, now))
|
||||
|
||||
StatsStore.record(QueryStatus.OK, 5, null, now)
|
||||
val after = StatsStore.summary(24, now)
|
||||
|
||||
assertNotSame(first, after)
|
||||
assertEquals(first.total + 1, after.total)
|
||||
assertSame(after, StatsStore.summary(24, now))
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user