Merge pull request #1840 from nrobi144/feat/desktop-advanced-search
feat(desktop): advanced search with NIP-50, collapsible sections, and nav state preservation
This commit is contained in:
Vitor Pamplona
+103
@@ -0,0 +1,103 @@
|
||||
/*
|
||||
* Copyright (c) 2025 Vitor Pamplona
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to use,
|
||||
* copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
|
||||
* Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
package com.vitorpamplona.amethyst.commons.search
|
||||
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertFalse
|
||||
import kotlin.test.assertNull
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
class KindRegistryTest {
|
||||
@Test
|
||||
fun resolveNote() {
|
||||
assertEquals(listOf(1), KindRegistry.resolve("note"))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun resolveArticle() {
|
||||
assertEquals(listOf(30023), KindRegistry.resolve("article"))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun resolveChannel() {
|
||||
val kinds = KindRegistry.resolve("channel")!!
|
||||
assertTrue(40 in kinds)
|
||||
assertTrue(41 in kinds)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun resolveCaseInsensitive() {
|
||||
assertEquals(KindRegistry.resolve("NOTE"), KindRegistry.resolve("note"))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun resolveUnknown() {
|
||||
assertNull(KindRegistry.resolve("unknown"))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun isPseudoKindReply() {
|
||||
assertTrue(KindRegistry.isPseudoKind("reply"))
|
||||
assertTrue(KindRegistry.isPseudoKind("Reply"))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun isPseudoKindMedia() {
|
||||
assertTrue(KindRegistry.isPseudoKind("media"))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun isNotPseudoKind() {
|
||||
assertFalse(KindRegistry.isPseudoKind("note"))
|
||||
assertFalse(KindRegistry.isPseudoKind("article"))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun nameForKind1() {
|
||||
assertEquals("note", KindRegistry.nameFor(1))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun nameForKind30023() {
|
||||
assertEquals("article", KindRegistry.nameFor(30023))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun nameForUnknownKind() {
|
||||
assertNull(KindRegistry.nameFor(99999))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun allAliasesResolve() {
|
||||
KindRegistry.aliases.forEach { (alias, kinds) ->
|
||||
assertEquals(kinds, KindRegistry.resolve(alias))
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun presetsContainExpectedEntries() {
|
||||
assertTrue(KindRegistry.presets.containsKey("Notes"))
|
||||
assertTrue(KindRegistry.presets.containsKey("Articles"))
|
||||
assertTrue(KindRegistry.presets.containsKey("Media"))
|
||||
assertTrue(KindRegistry.presets.containsKey("Channels"))
|
||||
}
|
||||
}
|
||||
+284
@@ -0,0 +1,284 @@
|
||||
/*
|
||||
* Copyright (c) 2025 Vitor Pamplona
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to use,
|
||||
* copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
|
||||
* Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
package com.vitorpamplona.amethyst.commons.search
|
||||
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertFalse
|
||||
import kotlin.test.assertNull
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
class QueryParserTest {
|
||||
@Test
|
||||
fun emptyInput() {
|
||||
val q = QueryParser.parse("")
|
||||
assertTrue(q.isEmpty)
|
||||
assertEquals(SearchQuery.EMPTY, q)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whitespaceOnly() {
|
||||
val q = QueryParser.parse(" ")
|
||||
assertTrue(q.isEmpty)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun plainText() {
|
||||
val q = QueryParser.parse("bitcoin lightning")
|
||||
assertEquals("bitcoin lightning", q.text)
|
||||
assertTrue(q.authors.isEmpty())
|
||||
assertTrue(q.kinds.isEmpty())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun kindOperatorAlias() {
|
||||
val q = QueryParser.parse("kind:note")
|
||||
assertEquals(listOf(1), q.kinds.toList())
|
||||
assertTrue(q.text.isBlank())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun kindOperatorNumeric() {
|
||||
val q = QueryParser.parse("kind:30023")
|
||||
assertEquals(listOf(30023), q.kinds.toList())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun kindOperatorArticle() {
|
||||
val q = QueryParser.parse("kind:article")
|
||||
assertEquals(listOf(30023), q.kinds.toList())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun kindOperatorInvalid() {
|
||||
val q = QueryParser.parse("kind:invalid")
|
||||
// Unresolvable kind → treated as text
|
||||
assertEquals("kind:invalid", q.text)
|
||||
assertTrue(q.kinds.isEmpty())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun pseudoKindReply() {
|
||||
val q = QueryParser.parse("kind:reply")
|
||||
assertTrue(q.kinds.isEmpty())
|
||||
assertEquals(listOf("reply"), q.pseudoKinds.toList())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun pseudoKindMedia() {
|
||||
val q = QueryParser.parse("kind:media")
|
||||
assertTrue(q.kinds.isEmpty())
|
||||
assertEquals(listOf("media"), q.pseudoKinds.toList())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun multipleKinds() {
|
||||
val q = QueryParser.parse("kind:note kind:article")
|
||||
assertEquals(listOf(1, 30023), q.kinds.toList())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun sinceDate() {
|
||||
val q = QueryParser.parse("since:2025-01-01")
|
||||
// 2025-01-01 00:00:00 UTC
|
||||
assertEquals(1735689600L, q.since)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun sinceDateYearOnly() {
|
||||
val q = QueryParser.parse("since:2025")
|
||||
// 2025-01-01 00:00:00 UTC
|
||||
assertEquals(1735689600L, q.since)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun sinceDateYearMonth() {
|
||||
val q = QueryParser.parse("since:2025-06")
|
||||
// 2025-06-01 00:00:00 UTC
|
||||
val q2 = QueryParser.parse("since:2025-06-01")
|
||||
assertEquals(q2.since, q.since)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun sinceInvalidDate() {
|
||||
val q = QueryParser.parse("since:not-a-date")
|
||||
assertNull(q.since)
|
||||
assertEquals("since:not-a-date", q.text)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun untilDate() {
|
||||
val q = QueryParser.parse("until:2025-12-31")
|
||||
assertNull(q.since)
|
||||
assertTrue(q.until != null && q.until!! > 0)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun hashtag() {
|
||||
val q = QueryParser.parse("#bitcoin")
|
||||
assertEquals(listOf("bitcoin"), q.hashtags.toList())
|
||||
assertTrue(q.text.isBlank())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun multipleHashtags() {
|
||||
val q = QueryParser.parse("#bitcoin #nostr")
|
||||
assertEquals(listOf("bitcoin", "nostr"), q.hashtags.toList())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun negationTerm() {
|
||||
val q = QueryParser.parse("-spam")
|
||||
assertEquals(listOf("spam"), q.excludeTerms.toList())
|
||||
assertTrue(q.text.isBlank())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun multipleNegations() {
|
||||
val q = QueryParser.parse("-spam -scam")
|
||||
assertEquals(listOf("spam", "scam"), q.excludeTerms.toList())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun quotedPhrase() {
|
||||
val q = QueryParser.parse("\"exact phrase\"")
|
||||
assertEquals("\"exact phrase\"", q.text)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun orTerms() {
|
||||
val q = QueryParser.parse("bitcoin OR lightning")
|
||||
assertEquals(listOf("bitcoin", "lightning"), q.orTerms.toList())
|
||||
assertTrue(q.text.isBlank())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun orTermsWithOperators() {
|
||||
val q = QueryParser.parse("from:vitor bitcoin OR lightning kind:note")
|
||||
assertEquals(listOf("bitcoin", "lightning"), q.orTerms.toList())
|
||||
assertEquals(listOf(1), q.kinds.toList())
|
||||
// from:vitor → authorNames since it's not a valid npub
|
||||
assertEquals(listOf("vitor"), q.authorNames.toList())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun orTermsCappedAtThree() {
|
||||
val q = QueryParser.parse("a OR b OR c OR d OR e")
|
||||
assertEquals(3, q.orTerms.size)
|
||||
assertEquals(listOf("a", "b", "c"), q.orTerms.toList())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun orphanedOr() {
|
||||
val q = QueryParser.parse("OR")
|
||||
assertEquals("OR", q.text)
|
||||
assertTrue(q.orTerms.isEmpty())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun languageOperator() {
|
||||
val q = QueryParser.parse("lang:en bitcoin")
|
||||
assertEquals("en", q.language)
|
||||
assertEquals("bitcoin", q.text)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun domainOperator() {
|
||||
val q = QueryParser.parse("domain:nostr.com bitcoin")
|
||||
assertEquals("nostr.com", q.domain)
|
||||
assertEquals("bitcoin", q.text)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun combinedQuery() {
|
||||
val q = QueryParser.parse("kind:note since:2025-01-01 #bitcoin -spam lightning")
|
||||
assertEquals(listOf(1), q.kinds.toList())
|
||||
assertEquals(1735689600L, q.since)
|
||||
assertEquals(listOf("bitcoin"), q.hashtags.toList())
|
||||
assertEquals(listOf("spam"), q.excludeTerms.toList())
|
||||
assertEquals("lightning", q.text)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun caseInsensitiveOperators() {
|
||||
val q = QueryParser.parse("FROM:vitor KIND:Note")
|
||||
assertEquals(listOf("vitor"), q.authorNames.toList())
|
||||
assertEquals(listOf(1), q.kinds.toList())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun operatorWithNoValue() {
|
||||
val q = QueryParser.parse("from:")
|
||||
// Malformed → treated as text
|
||||
assertEquals("from:", q.text)
|
||||
assertTrue(q.authors.isEmpty())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun fromWithAuthorName() {
|
||||
val q = QueryParser.parse("from:vitor")
|
||||
assertEquals(listOf("vitor"), q.authorNames.toList())
|
||||
assertTrue(q.authors.isEmpty())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun multipleFromAuthors() {
|
||||
val q = QueryParser.parse("from:alice from:bob")
|
||||
assertEquals(listOf("alice", "bob"), q.authorNames.toList())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun duplicateAuthorsDeduped() {
|
||||
val q = QueryParser.parse("from:vitor from:vitor")
|
||||
assertEquals(1, q.authorNames.size)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun parseDateToTimestamp_validDates() {
|
||||
// 1970-01-01 = 0
|
||||
assertEquals(0L, QueryParser.parseDateToTimestamp("1970-01-01"))
|
||||
// 2000-01-01
|
||||
assertEquals(946684800L, QueryParser.parseDateToTimestamp("2000-01-01"))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun parseDateToTimestamp_invalidDates() {
|
||||
assertNull(QueryParser.parseDateToTimestamp("not-a-date"))
|
||||
assertNull(QueryParser.parseDateToTimestamp("1800-01-01"))
|
||||
assertNull(QueryParser.parseDateToTimestamp("2025-13-01"))
|
||||
assertNull(QueryParser.parseDateToTimestamp("2025-01-32"))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun unicodeInFreeText() {
|
||||
val q = QueryParser.parse("bitcoin 日本語 🚀")
|
||||
assertFalse(q.isEmpty)
|
||||
assertTrue(q.text.contains("日本語"))
|
||||
assertTrue(q.text.contains("🚀"))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun veryLongQuery() {
|
||||
val longText = "word ".repeat(100).trim()
|
||||
val q = QueryParser.parse(longText)
|
||||
assertFalse(q.isEmpty)
|
||||
}
|
||||
}
|
||||
+177
@@ -0,0 +1,177 @@
|
||||
/*
|
||||
* Copyright (c) 2025 Vitor Pamplona
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to use,
|
||||
* copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
|
||||
* Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
package com.vitorpamplona.amethyst.commons.search
|
||||
|
||||
import kotlinx.collections.immutable.persistentListOf
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
class QuerySerializerTest {
|
||||
@Test
|
||||
fun emptyQuery() {
|
||||
assertEquals("", QuerySerializer.serialize(SearchQuery.EMPTY))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun textOnly() {
|
||||
val q = SearchQuery(text = "bitcoin")
|
||||
assertEquals("bitcoin", QuerySerializer.serialize(q))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun kindOnly() {
|
||||
val q = SearchQuery(kinds = persistentListOf(1))
|
||||
assertEquals("kind:note", QuerySerializer.serialize(q))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun kindUnknown() {
|
||||
val q = SearchQuery(kinds = persistentListOf(99999))
|
||||
assertEquals("kind:99999", QuerySerializer.serialize(q))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun multipleKinds() {
|
||||
val q = SearchQuery(kinds = persistentListOf(1, 30023))
|
||||
assertEquals("kind:note kind:article", QuerySerializer.serialize(q))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun pseudoKinds() {
|
||||
val q = SearchQuery(pseudoKinds = persistentListOf("reply", "media"))
|
||||
assertEquals("kind:reply kind:media", QuerySerializer.serialize(q))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun sinceDate() {
|
||||
val q = SearchQuery(since = 1735689600L) // 2025-01-01
|
||||
assertEquals("since:2025-01-01", QuerySerializer.serialize(q))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun untilDate() {
|
||||
val q = SearchQuery(until = 1735689600L)
|
||||
assertEquals("until:2025-01-01", QuerySerializer.serialize(q))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun hashtags() {
|
||||
val q = SearchQuery(hashtags = persistentListOf("bitcoin", "nostr"))
|
||||
assertEquals("#bitcoin #nostr", QuerySerializer.serialize(q))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun excludeTerms() {
|
||||
val q = SearchQuery(excludeTerms = persistentListOf("spam", "scam"))
|
||||
assertEquals("-spam -scam", QuerySerializer.serialize(q))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun orTerms() {
|
||||
val q = SearchQuery(orTerms = persistentListOf("bitcoin", "lightning"))
|
||||
assertEquals("bitcoin OR lightning", QuerySerializer.serialize(q))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun language() {
|
||||
val q = SearchQuery(language = "en", text = "bitcoin")
|
||||
assertEquals("lang:en bitcoin", QuerySerializer.serialize(q))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun domain() {
|
||||
val q = SearchQuery(domain = "nostr.com", text = "hello")
|
||||
assertEquals("domain:nostr.com hello", QuerySerializer.serialize(q))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun authorNames() {
|
||||
val q = SearchQuery(authorNames = persistentListOf("vitor"))
|
||||
assertEquals("from:vitor", QuerySerializer.serialize(q))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun combinedQuery() {
|
||||
val q =
|
||||
SearchQuery(
|
||||
authorNames = persistentListOf("vitor"),
|
||||
kinds = persistentListOf(1),
|
||||
since = 1735689600L,
|
||||
hashtags = persistentListOf("bitcoin"),
|
||||
text = "lightning",
|
||||
excludeTerms = persistentListOf("spam"),
|
||||
)
|
||||
val result = QuerySerializer.serialize(q)
|
||||
assertTrue(result.contains("from:vitor"))
|
||||
assertTrue(result.contains("kind:note"))
|
||||
assertTrue(result.contains("since:2025-01-01"))
|
||||
assertTrue(result.contains("#bitcoin"))
|
||||
assertTrue(result.contains("lightning"))
|
||||
assertTrue(result.contains("-spam"))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun orderingOperatorsFirst() {
|
||||
val q =
|
||||
SearchQuery(
|
||||
authorNames = persistentListOf("alice"),
|
||||
kinds = persistentListOf(1),
|
||||
hashtags = persistentListOf("nostr"),
|
||||
text = "hello",
|
||||
excludeTerms = persistentListOf("bad"),
|
||||
)
|
||||
val result = QuerySerializer.serialize(q)
|
||||
val fromIdx = result.indexOf("from:")
|
||||
val kindIdx = result.indexOf("kind:")
|
||||
val hashIdx = result.indexOf("#nostr")
|
||||
val textIdx = result.indexOf("hello")
|
||||
val excludeIdx = result.indexOf("-bad")
|
||||
assertTrue(fromIdx < kindIdx)
|
||||
assertTrue(kindIdx < hashIdx)
|
||||
assertTrue(hashIdx < textIdx)
|
||||
assertTrue(textIdx < excludeIdx)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun timestampToDateEpoch() {
|
||||
assertEquals("1970-01-01", QuerySerializer.timestampToDate(0L))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun timestampToDate2025() {
|
||||
assertEquals("2025-01-01", QuerySerializer.timestampToDate(1735689600L))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun roundtrip() {
|
||||
// Parse a complex query, serialize, parse again — should produce equivalent SearchQuery
|
||||
val input = "kind:note since:2025-01-01 #bitcoin lightning -spam"
|
||||
val q1 = QueryParser.parse(input)
|
||||
val serialized = QuerySerializer.serialize(q1)
|
||||
val q2 = QueryParser.parse(serialized)
|
||||
assertEquals(q1.kinds, q2.kinds)
|
||||
assertEquals(q1.since, q2.since)
|
||||
assertEquals(q1.hashtags, q2.hashtags)
|
||||
assertEquals(q1.excludeTerms, q2.excludeTerms)
|
||||
assertEquals(q1.text, q2.text)
|
||||
}
|
||||
}
|
||||
+197
@@ -0,0 +1,197 @@
|
||||
/*
|
||||
* Copyright (c) 2025 Vitor Pamplona
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to use,
|
||||
* copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
|
||||
* Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
package com.vitorpamplona.amethyst.commons.search
|
||||
|
||||
import com.vitorpamplona.amethyst.commons.model.Note
|
||||
import com.vitorpamplona.amethyst.commons.model.User
|
||||
import com.vitorpamplona.quartz.nip01Core.core.Event
|
||||
import com.vitorpamplona.quartz.nip01Core.metadata.MetadataEvent
|
||||
import com.vitorpamplona.quartz.nip01Core.metadata.UserMetadata
|
||||
import com.vitorpamplona.quartz.nip23LongContent.LongTextNoteEvent
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
class SearchResultSorterTest {
|
||||
private fun event(
|
||||
id: String,
|
||||
createdAt: Long,
|
||||
content: String = "",
|
||||
kind: Int = 1,
|
||||
) = Event(
|
||||
id = id,
|
||||
pubKey = "abc123def456abc123def456abc123def456abc123def456abc123def456abcd",
|
||||
createdAt = createdAt,
|
||||
kind = kind,
|
||||
tags = emptyArray(),
|
||||
content = content,
|
||||
sig = "sig",
|
||||
)
|
||||
|
||||
private fun article(
|
||||
id: String,
|
||||
createdAt: Long,
|
||||
content: String = "",
|
||||
title: String? = null,
|
||||
): LongTextNoteEvent {
|
||||
val tags =
|
||||
if (title != null) {
|
||||
arrayOf(arrayOf("title", title))
|
||||
} else {
|
||||
emptyArray()
|
||||
}
|
||||
return LongTextNoteEvent(
|
||||
id = id,
|
||||
pubKey = "abc123def456abc123def456abc123def456abc123def456abc123def456abcd",
|
||||
createdAt = createdAt,
|
||||
tags = tags,
|
||||
content = content,
|
||||
sig = "sig",
|
||||
)
|
||||
}
|
||||
|
||||
private fun user(
|
||||
hex: String,
|
||||
displayName: String,
|
||||
): User {
|
||||
val u = User(hex, Note("r1-$hex"), Note("r2-$hex"))
|
||||
val meta = UserMetadata().apply { this.displayName = displayName }
|
||||
val metaEvent =
|
||||
MetadataEvent(
|
||||
id = "meta-$hex",
|
||||
pubKey = hex,
|
||||
createdAt = 0L,
|
||||
tags = emptyArray(),
|
||||
content = "{}",
|
||||
sig = "sig",
|
||||
)
|
||||
u.updateUserInfo(meta, metaEvent)
|
||||
return u
|
||||
}
|
||||
|
||||
// --- Event sorting ---
|
||||
|
||||
@Test
|
||||
fun newestSortsDescending() {
|
||||
val events = listOf(event("a", 100), event("b", 300), event("c", 200))
|
||||
val sorted = SearchResultSorter.sortEvents(events, SearchSortOrder.NEWEST, "")
|
||||
assertEquals(listOf("b", "c", "a"), sorted.map { it.id })
|
||||
}
|
||||
|
||||
@Test
|
||||
fun oldestSortsAscending() {
|
||||
val events = listOf(event("a", 300), event("b", 100), event("c", 200))
|
||||
val sorted = SearchResultSorter.sortEvents(events, SearchSortOrder.OLDEST, "")
|
||||
assertEquals(listOf("b", "c", "a"), sorted.map { it.id })
|
||||
}
|
||||
|
||||
@Test
|
||||
fun relevanceEmptyQueryFallsBackToRecency() {
|
||||
val events = listOf(event("a", 100), event("b", 300), event("c", 200))
|
||||
val sorted = SearchResultSorter.sortEvents(events, SearchSortOrder.RELEVANCE, "")
|
||||
assertEquals(listOf("b", "c", "a"), sorted.map { it.id })
|
||||
}
|
||||
|
||||
@Test
|
||||
fun relevanceExactMatchBeatsPartial() {
|
||||
val exact = event("exact", 100, content = "bitcoin is great")
|
||||
val partial = event("partial", 100, content = "bit of something")
|
||||
val sorted = SearchResultSorter.sortEvents(listOf(partial, exact), SearchSortOrder.RELEVANCE, "bitcoin")
|
||||
assertEquals("exact", sorted.first().id)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun relevanceWordBoundaryBeatsSubstring() {
|
||||
val boundary = event("boundary", 100, content = "I love bitcoin and lightning")
|
||||
val substring = event("substr", 100, content = "bitcoinery is not a word")
|
||||
val sorted = SearchResultSorter.sortEvents(listOf(substring, boundary), SearchSortOrder.RELEVANCE, "bitcoin")
|
||||
assertEquals("boundary", sorted.first().id)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun relevanceArticleTitleBoost() {
|
||||
val withTitle = article("titled", 100, content = "some content", title = "Bitcoin Guide")
|
||||
val withoutTitle = event("notitle", 100, content = "bitcoin bitcoin bitcoin")
|
||||
val sorted = SearchResultSorter.sortEvents(listOf(withoutTitle, withTitle), SearchSortOrder.RELEVANCE, "bitcoin")
|
||||
assertEquals("titled", sorted.first().id)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun relevanceMultipleTokensAddUp() {
|
||||
val multi = event("multi", 100, content = "bitcoin and lightning network")
|
||||
val single = event("single", 100, content = "bitcoin only here")
|
||||
val sorted =
|
||||
SearchResultSorter.sortEvents(
|
||||
listOf(single, multi),
|
||||
SearchSortOrder.RELEVANCE,
|
||||
"bitcoin lightning",
|
||||
)
|
||||
assertEquals("multi", sorted.first().id)
|
||||
}
|
||||
|
||||
// --- People sorting ---
|
||||
|
||||
@Test
|
||||
fun nameAzSortsAlphabetically() {
|
||||
val people =
|
||||
listOf(
|
||||
user("cc00000000000000000000000000000000000000000000000000000000000000", "Charlie"),
|
||||
user("aa00000000000000000000000000000000000000000000000000000000000000", "Alice"),
|
||||
user("bb00000000000000000000000000000000000000000000000000000000000000", "Bob"),
|
||||
)
|
||||
val sorted = SearchResultSorter.sortPeople(people, SearchSortOrder.NAME_AZ)
|
||||
assertEquals(listOf("Alice", "Bob", "Charlie"), sorted.map { it.toBestDisplayName() })
|
||||
}
|
||||
|
||||
@Test
|
||||
fun nameZaSortsReverseAlphabetically() {
|
||||
val people =
|
||||
listOf(
|
||||
user("aa00000000000000000000000000000000000000000000000000000000000000", "Alice"),
|
||||
user("cc00000000000000000000000000000000000000000000000000000000000000", "Charlie"),
|
||||
user("bb00000000000000000000000000000000000000000000000000000000000000", "Bob"),
|
||||
)
|
||||
val sorted = SearchResultSorter.sortPeople(people, SearchSortOrder.NAME_ZA)
|
||||
assertEquals(listOf("Charlie", "Bob", "Alice"), sorted.map { it.toBestDisplayName() })
|
||||
}
|
||||
|
||||
@Test
|
||||
fun nameSortIsCaseInsensitive() {
|
||||
val people =
|
||||
listOf(
|
||||
user("aa00000000000000000000000000000000000000000000000000000000000000", "alice"),
|
||||
user("bb00000000000000000000000000000000000000000000000000000000000000", "Bob"),
|
||||
)
|
||||
val sorted = SearchResultSorter.sortPeople(people, SearchSortOrder.NAME_AZ)
|
||||
assertEquals("alice", sorted.first().toBestDisplayName())
|
||||
}
|
||||
|
||||
// --- Score function ---
|
||||
|
||||
@Test
|
||||
fun scoreExactPhraseHigherThanTokens() {
|
||||
val exactEvent = event("e", 100, content = "bitcoin lightning network")
|
||||
val tokenEvent = event("t", 100, content = "lightning and bitcoin elsewhere network")
|
||||
val exactScore = SearchResultSorter.scoreEvent(exactEvent, "bitcoin lightning")
|
||||
val tokenScore = SearchResultSorter.scoreEvent(tokenEvent, "bitcoin lightning")
|
||||
assertTrue(exactScore > tokenScore)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user