2022-05-09 02:01:42 +00:00
|
|
|
//
|
|
|
|
// ReplyTests.swift
|
|
|
|
// damusTests
|
|
|
|
//
|
|
|
|
// Created by William Casarin on 2022-05-08.
|
|
|
|
//
|
|
|
|
|
|
|
|
import XCTest
|
|
|
|
@testable import damus
|
|
|
|
|
|
|
|
class ReplyTests: XCTestCase {
|
|
|
|
|
|
|
|
override func setUpWithError() throws {
|
|
|
|
// Put setup code here. This method is called before the invocation of each test method in the class.
|
|
|
|
}
|
|
|
|
|
|
|
|
override func tearDownWithError() throws {
|
|
|
|
// Put teardown code here. This method is called after the invocation of each test method in the class.
|
|
|
|
}
|
|
|
|
|
|
|
|
func testMentionIsntReply() throws {
|
|
|
|
let content = "this is #[0] a mention"
|
|
|
|
let tags = [["e", "event_id"]]
|
2023-07-16 17:49:31 +00:00
|
|
|
let blocks = parse_note_content(content: content, tags: tags).blocks
|
2022-05-09 02:01:42 +00:00
|
|
|
let event_refs = interpret_event_refs(blocks: blocks, tags: tags)
|
|
|
|
|
|
|
|
XCTAssertEqual(event_refs.count, 1)
|
|
|
|
|
|
|
|
let ref = event_refs[0]
|
|
|
|
|
|
|
|
XCTAssertNil(ref.is_reply)
|
|
|
|
XCTAssertNil(ref.is_thread_id)
|
|
|
|
XCTAssertNil(ref.is_direct_reply)
|
2022-10-16 23:11:27 +00:00
|
|
|
XCTAssertEqual(ref.is_mention?.type, .event)
|
|
|
|
XCTAssertEqual(ref.is_mention?.ref.ref_id, "event_id")
|
2022-05-09 02:01:42 +00:00
|
|
|
}
|
|
|
|
|
2022-07-28 20:10:00 +00:00
|
|
|
func testUrlAnchorsAreNotHashtags() {
|
|
|
|
let content = "this is my link: https://jb55.com/index.html#buybitcoin this is not a hashtag!"
|
|
|
|
let blocks = parse_post_blocks(content: content)
|
|
|
|
|
2023-07-11 16:05:45 +00:00
|
|
|
XCTAssertEqual(blocks.count, 3)
|
|
|
|
XCTAssertEqual(blocks[0].is_text, "this is my link: ")
|
|
|
|
XCTAssertEqual(blocks[1].is_url, URL(string: "https://jb55.com/index.html#buybitcoin")!)
|
|
|
|
XCTAssertEqual(blocks[2].is_text, " this is not a hashtag!")
|
2022-07-28 20:10:00 +00:00
|
|
|
}
|
|
|
|
|
2022-08-08 02:31:02 +00:00
|
|
|
func testLinkIsNotAHashtag() {
|
|
|
|
let link = "https://github.com/damus-io/damus/blob/b7513f28fa1d31c2747865067256ad1d7cf43aac/damus/Nostr/NostrEvent.swift#L560"
|
|
|
|
|
|
|
|
let content = "my \(link) link"
|
|
|
|
let blocks = parse_post_blocks(content: content)
|
|
|
|
|
2023-07-11 16:05:45 +00:00
|
|
|
XCTAssertEqual(blocks.count, 3)
|
|
|
|
XCTAssertEqual(blocks[0].is_text, "my ")
|
|
|
|
XCTAssertEqual(blocks[1].is_url, URL(string: link)!)
|
|
|
|
XCTAssertEqual(blocks[2].is_text, " link")
|
2022-08-08 02:31:02 +00:00
|
|
|
}
|
|
|
|
|
2022-12-27 12:11:54 +00:00
|
|
|
func testAtAtEnd() {
|
|
|
|
let content = "what @"
|
|
|
|
let blocks = parse_post_blocks(content: content)
|
|
|
|
|
|
|
|
XCTAssertEqual(blocks.count, 1)
|
|
|
|
XCTAssertEqual(blocks[0].is_text, "what @")
|
|
|
|
}
|
|
|
|
|
2022-07-28 20:10:00 +00:00
|
|
|
func testHashtagsInQuote() {
|
|
|
|
let content = "This is my \"#awesome post\""
|
|
|
|
let blocks = parse_post_blocks(content: content)
|
|
|
|
|
|
|
|
XCTAssertEqual(blocks.count, 3)
|
|
|
|
XCTAssertEqual(blocks[0].is_text, "This is my \"")
|
|
|
|
XCTAssertEqual(blocks[1].is_hashtag, "awesome")
|
|
|
|
XCTAssertEqual(blocks[2].is_text, " post\"")
|
|
|
|
}
|
|
|
|
|
|
|
|
func testHashtagAtStartWorks() {
|
|
|
|
let content = "#hashtag"
|
|
|
|
let blocks = parse_post_blocks(content: content)
|
2023-07-11 16:05:45 +00:00
|
|
|
XCTAssertEqual(blocks.count, 1)
|
|
|
|
XCTAssertEqual(blocks[0].is_hashtag, "hashtag")
|
2022-07-28 20:10:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func testGroupOfHashtags() {
|
|
|
|
let content = "#hashtag#what#nope"
|
|
|
|
let blocks = parse_post_blocks(content: content)
|
|
|
|
XCTAssertEqual(blocks.count, 3)
|
2023-07-11 16:05:45 +00:00
|
|
|
XCTAssertEqual(blocks[0].is_hashtag, "hashtag")
|
|
|
|
XCTAssertEqual(blocks[1].is_hashtag, "what")
|
|
|
|
XCTAssertEqual(blocks[2].is_hashtag, "nope")
|
2022-07-28 20:10:00 +00:00
|
|
|
}
|
|
|
|
|
2022-05-09 02:01:42 +00:00
|
|
|
func testRootReplyWithMention() throws {
|
|
|
|
let content = "this is #[1] a mention"
|
|
|
|
let tags = [["e", "thread_id"], ["e", "mentioned_id"]]
|
2023-07-16 17:49:31 +00:00
|
|
|
let blocks = parse_note_content(content: content, tags: tags).blocks
|
2022-05-09 02:01:42 +00:00
|
|
|
let event_refs = interpret_event_refs(blocks: blocks, tags: tags)
|
|
|
|
|
|
|
|
XCTAssertEqual(event_refs.count, 2)
|
|
|
|
XCTAssertNotNil(event_refs[0].is_reply)
|
|
|
|
XCTAssertNotNil(event_refs[0].is_thread_id)
|
|
|
|
XCTAssertNotNil(event_refs[0].is_reply)
|
|
|
|
XCTAssertNotNil(event_refs[0].is_direct_reply)
|
2022-10-16 23:11:27 +00:00
|
|
|
XCTAssertEqual(event_refs[0].is_reply?.ref_id, "thread_id")
|
|
|
|
XCTAssertEqual(event_refs[0].is_thread_id?.ref_id, "thread_id")
|
2022-05-09 02:01:42 +00:00
|
|
|
XCTAssertNotNil(event_refs[1].is_mention)
|
2022-10-16 23:11:27 +00:00
|
|
|
XCTAssertEqual(event_refs[1].is_mention?.type, .event)
|
|
|
|
XCTAssertEqual(event_refs[1].is_mention?.ref.ref_id, "mentioned_id")
|
2022-05-09 02:01:42 +00:00
|
|
|
}
|
|
|
|
|
2022-06-06 15:55:32 +00:00
|
|
|
func testEmptyMention() throws {
|
|
|
|
let content = "this is some & content"
|
|
|
|
let tags: [[String]] = []
|
2023-07-16 17:49:31 +00:00
|
|
|
let blocks = parse_note_content(content: content, tags: tags).blocks
|
2022-06-06 15:55:32 +00:00
|
|
|
let post_blocks = parse_post_blocks(content: content)
|
2023-07-17 15:59:25 +00:00
|
|
|
let post_tags = make_post_tags(post_blocks: post_blocks, tags: tags)
|
2022-06-06 15:55:32 +00:00
|
|
|
let event_refs = interpret_event_refs(blocks: blocks, tags: tags)
|
|
|
|
|
|
|
|
XCTAssertEqual(event_refs.count, 0)
|
|
|
|
XCTAssertEqual(post_tags.blocks.count, 1)
|
|
|
|
XCTAssertEqual(post_tags.tags.count, 0)
|
|
|
|
XCTAssertEqual(post_blocks.count, 1)
|
|
|
|
}
|
2023-07-11 16:05:45 +00:00
|
|
|
|
2022-06-06 15:55:32 +00:00
|
|
|
func testManyMentions() throws {
|
|
|
|
let content = "#[10]"
|
|
|
|
let tags: [[String]] = [[],[],[],[],[],[],[],[],[],[],["p", "3e999f94e2cb34ef44a64b351141ac4e51b5121b2d31aed4a6c84602a1144692"]]
|
2023-07-16 17:49:31 +00:00
|
|
|
let blocks = parse_note_content(content: content, tags: tags).blocks
|
2023-07-11 16:05:45 +00:00
|
|
|
let mentions = blocks.filter { $0.is_mention != nil }
|
2022-06-06 15:55:32 +00:00
|
|
|
XCTAssertEqual(mentions.count, 1)
|
|
|
|
}
|
2023-07-13 14:11:15 +00:00
|
|
|
|
|
|
|
func testNewlineMentions() throws {
|
|
|
|
let pk = "npub1xtscya34g58tk0z605fvr788k263gsu6cy9x0mhnm87echrgufzsevkk5s"
|
|
|
|
guard let hex_pk = bech32_pubkey_decode(pk) else {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2023-07-17 17:20:21 +00:00
|
|
|
let profile = Profile(name: "jb55")
|
2023-07-15 00:26:19 +00:00
|
|
|
let post = user_tag_attr_string(profile: profile, pubkey: pk)
|
|
|
|
post.append(.init(string: "\n"))
|
|
|
|
post.append(user_tag_attr_string(profile: profile, pubkey: pk))
|
|
|
|
post.append(.init(string: "\n"))
|
|
|
|
|
|
|
|
let post_note = build_post(post: post, action: .posting(.none), uploadedMedias: [], references: [.p(hex_pk)])
|
2023-07-13 14:11:15 +00:00
|
|
|
|
|
|
|
let expected_render = "nostr:\(pk)\nnostr:\(pk)"
|
2023-07-15 00:26:19 +00:00
|
|
|
XCTAssertEqual(post_note.content, expected_render)
|
|
|
|
|
2023-07-16 17:49:31 +00:00
|
|
|
let blocks = parse_note_content(content: post_note.content, tags: []).blocks
|
2023-07-15 00:26:19 +00:00
|
|
|
let rendered = render_blocks(blocks: blocks)
|
2023-07-13 14:11:15 +00:00
|
|
|
|
|
|
|
XCTAssertEqual(rendered, expected_render)
|
|
|
|
|
|
|
|
XCTAssertEqual(blocks.count, 3)
|
|
|
|
XCTAssertEqual(blocks[0].is_mention, .pubkey(hex_pk))
|
|
|
|
XCTAssertEqual(blocks[1].is_text, "\n")
|
|
|
|
XCTAssertEqual(blocks[2].is_mention, .pubkey(hex_pk))
|
|
|
|
}
|
2022-06-06 15:55:32 +00:00
|
|
|
|
2022-05-09 02:01:42 +00:00
|
|
|
func testThreadedReply() throws {
|
|
|
|
let content = "this is some content"
|
|
|
|
let tags = [["e", "thread_id"], ["e", "reply_id"]]
|
2023-07-16 17:49:31 +00:00
|
|
|
let blocks = parse_note_content(content: content, tags: tags).blocks
|
2022-05-09 02:01:42 +00:00
|
|
|
let event_refs = interpret_event_refs(blocks: blocks, tags: tags)
|
|
|
|
|
|
|
|
XCTAssertEqual(event_refs.count, 2)
|
|
|
|
let r1 = event_refs[0]
|
|
|
|
let r2 = event_refs[1]
|
|
|
|
|
|
|
|
XCTAssertEqual(r1.is_thread_id!.ref_id, "thread_id")
|
|
|
|
XCTAssertEqual(r2.is_reply!.ref_id, "reply_id")
|
|
|
|
XCTAssertEqual(r2.is_direct_reply!.ref_id, "reply_id")
|
|
|
|
XCTAssertNil(r1.is_direct_reply)
|
|
|
|
}
|
|
|
|
|
|
|
|
func testRootReply() throws {
|
|
|
|
let content = "this is a reply"
|
|
|
|
let tags = [["e", "thread_id"]]
|
2023-07-16 17:49:31 +00:00
|
|
|
let blocks = parse_note_content(content: content, tags: tags).blocks
|
2022-05-09 02:01:42 +00:00
|
|
|
let event_refs = interpret_event_refs(blocks: blocks, tags: tags)
|
|
|
|
|
|
|
|
XCTAssertEqual(event_refs.count, 1)
|
|
|
|
let r = event_refs[0]
|
|
|
|
|
|
|
|
XCTAssertEqual(r.is_direct_reply!.ref_id, "thread_id")
|
|
|
|
XCTAssertEqual(r.is_reply!.ref_id, "thread_id")
|
|
|
|
XCTAssertEqual(r.is_thread_id!.ref_id, "thread_id")
|
|
|
|
XCTAssertNil(r.is_mention)
|
|
|
|
}
|
2023-07-17 17:20:21 +00:00
|
|
|
|
|
|
|
func testAdjacentComposedMention() throws {
|
|
|
|
let content = "cc@jb55"
|
|
|
|
|
|
|
|
let profile = Profile(name: "jb55")
|
|
|
|
let tag = user_tag_attr_string(profile: profile, pubkey: "pk")
|
|
|
|
let appended = append_user_tag(tag: tag, post: .init(string: content), word_range: .init(2...6))
|
|
|
|
let new_post = appended.post
|
|
|
|
|
|
|
|
try new_post.testAttributes(conditions: [
|
|
|
|
{ let link = $0[.link] as? String; XCTAssertNil(link) },
|
|
|
|
{ let link = $0[.link] as! String; XCTAssertEqual(link, "damus:nostr:pk") },
|
|
|
|
{ let link = $0[.link] as? String; XCTAssertNil(link) }
|
|
|
|
])
|
|
|
|
|
|
|
|
XCTAssertEqual(new_post.string, "cc @jb55 ")
|
|
|
|
}
|
|
|
|
|
|
|
|
func testAdjacentEmojiComposedMention() throws {
|
|
|
|
let content = "😎@jb55"
|
|
|
|
|
|
|
|
let profile = Profile(name: "jb55")
|
|
|
|
let tag = user_tag_attr_string(profile: profile, pubkey: "pk")
|
|
|
|
let appended = append_user_tag(tag: tag, post: .init(string: content), word_range: .init(2...6))
|
|
|
|
let new_post = appended.post
|
|
|
|
|
|
|
|
try new_post.testAttributes(conditions: [
|
|
|
|
{ let link = $0[.link] as? String; XCTAssertNil(link) },
|
|
|
|
{ let link = $0[.link] as! String; XCTAssertEqual(link, "damus:nostr:pk") },
|
|
|
|
{ let link = $0[.link] as? String; XCTAssertNil(link) }
|
|
|
|
])
|
|
|
|
|
|
|
|
XCTAssertEqual(new_post.string, "😎 @jb55 ")
|
2023-07-17 17:45:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func testComposedMentionNewline() throws {
|
|
|
|
let content = """
|
|
|
|
|
|
|
|
@jb55
|
|
|
|
"""
|
|
|
|
|
|
|
|
let profile = Profile(name: "jb55")
|
|
|
|
let tag = user_tag_attr_string(profile: profile, pubkey: "pk")
|
|
|
|
let appended = append_user_tag(tag: tag, post: .init(string: content), word_range: .init(1...5))
|
|
|
|
let new_post = appended.post
|
|
|
|
|
|
|
|
try new_post.testAttributes(conditions: [
|
|
|
|
{ let link = $0[.link] as? String; XCTAssertNil(link) },
|
|
|
|
{ let link = $0[.link] as! String; XCTAssertEqual(link, "damus:nostr:pk") },
|
|
|
|
{ let link = $0[.link] as? String; XCTAssertNil(link) },
|
|
|
|
])
|
|
|
|
|
|
|
|
XCTAssertEqual(new_post.string, "\n@jb55 ")
|
2023-07-17 17:20:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func testComposedMention() throws {
|
|
|
|
let content = "@jb55"
|
|
|
|
|
|
|
|
let profile = Profile(name: "jb55")
|
|
|
|
let tag = user_tag_attr_string(profile: profile, pubkey: "pk")
|
|
|
|
let appended = append_user_tag(tag: tag, post: .init(string: content), word_range: .init(0...4))
|
|
|
|
let new_post = appended.post
|
|
|
|
|
|
|
|
try new_post.testAttributes(conditions: [
|
|
|
|
{ let link = $0[.link] as! String; XCTAssertEqual(link, "damus:nostr:pk") },
|
|
|
|
{ let link = $0[.link] as? String; XCTAssertNil(link) },
|
|
|
|
])
|
|
|
|
|
|
|
|
XCTAssertEqual(new_post.string, "@jb55 ")
|
|
|
|
}
|
|
|
|
|
|
|
|
func testAdjacentSpaceComposedMention() throws {
|
|
|
|
let content = "cc @jb55"
|
|
|
|
|
|
|
|
let profile = Profile(name: "jb55")
|
|
|
|
let tag = user_tag_attr_string(profile: profile, pubkey: "pk")
|
|
|
|
let appended = append_user_tag(tag: tag, post: .init(string: content), word_range: .init(3...7))
|
|
|
|
let new_post = appended.post
|
|
|
|
|
|
|
|
try new_post.testAttributes(conditions: [
|
|
|
|
{ let link = $0[.link] as? String; XCTAssertNil(link) },
|
|
|
|
{ let link = $0[.link] as! String; XCTAssertEqual(link, "damus:nostr:pk") },
|
|
|
|
{ let link = $0[.link] as? String; XCTAssertNil(link) }
|
|
|
|
])
|
|
|
|
|
|
|
|
XCTAssertEqual(new_post.string, "cc @jb55 ")
|
|
|
|
}
|
|
|
|
|
2022-05-09 02:01:42 +00:00
|
|
|
func testNoReply() throws {
|
|
|
|
let content = "this is a #[0] reply"
|
2023-07-16 17:49:31 +00:00
|
|
|
let blocks = parse_note_content(content: content, tags: []).blocks
|
2022-05-09 02:01:42 +00:00
|
|
|
let event_refs = interpret_event_refs(blocks: blocks, tags: [])
|
|
|
|
|
|
|
|
XCTAssertEqual(event_refs.count, 0)
|
|
|
|
}
|
|
|
|
|
|
|
|
func testParseMention() throws {
|
2023-07-16 17:49:31 +00:00
|
|
|
let parsed = parse_note_content(content: "this is #[0] a mention", tags: [["e", "event_id"]]).blocks
|
2022-05-09 02:01:42 +00:00
|
|
|
|
|
|
|
XCTAssertNotNil(parsed)
|
|
|
|
XCTAssertEqual(parsed.count, 3)
|
2022-10-17 22:20:38 +00:00
|
|
|
XCTAssertEqual(parsed[0].is_text, "this is ")
|
2022-05-09 03:34:57 +00:00
|
|
|
XCTAssertNotNil(parsed[1].is_mention)
|
2022-10-17 22:20:38 +00:00
|
|
|
XCTAssertEqual(parsed[2].is_text, " a mention")
|
2022-05-09 02:01:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func testEmptyPostReference() throws {
|
|
|
|
let parsed = parse_post_blocks(content: "")
|
|
|
|
XCTAssertEqual(parsed.count, 0)
|
|
|
|
}
|
|
|
|
|
2022-08-07 14:09:11 +00:00
|
|
|
func testBech32MentionAtStart() throws {
|
|
|
|
let pk = "npub1xtscya34g58tk0z605fvr788k263gsu6cy9x0mhnm87echrgufzsevkk5s"
|
|
|
|
let hex_pk = "32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245"
|
|
|
|
let content = "@\(pk) hello there"
|
|
|
|
let blocks = parse_post_blocks(content: content)
|
|
|
|
|
2023-07-11 16:05:45 +00:00
|
|
|
XCTAssertEqual(blocks.count, 2)
|
|
|
|
XCTAssertEqual(blocks[0].is_mention, .pubkey(hex_pk))
|
|
|
|
XCTAssertEqual(blocks[1].is_text, " hello there")
|
|
|
|
|
2022-08-07 14:09:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func testBech32MentionAtEnd() throws {
|
|
|
|
let pk = "npub1xtscya34g58tk0z605fvr788k263gsu6cy9x0mhnm87echrgufzsevkk5s"
|
|
|
|
let hex_pk = "32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245"
|
|
|
|
let content = "this is a @\(pk)"
|
|
|
|
let blocks = parse_post_blocks(content: content)
|
|
|
|
|
2023-07-11 16:05:45 +00:00
|
|
|
XCTAssertEqual(blocks.count, 2)
|
|
|
|
XCTAssertEqual(blocks[1].is_mention, .pubkey(hex_pk))
|
2022-08-07 14:09:11 +00:00
|
|
|
XCTAssertEqual(blocks[0].is_text, "this is a ")
|
|
|
|
}
|
|
|
|
|
2022-08-07 06:01:56 +00:00
|
|
|
func testNpubMention() throws {
|
|
|
|
let evid = "0000000000000000000000000000000000000000000000000000000000000005"
|
|
|
|
let pk = "npub1xtscya34g58tk0z605fvr788k263gsu6cy9x0mhnm87echrgufzsevkk5s"
|
|
|
|
let hex_pk = "32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245"
|
|
|
|
let content = "this is a @\(pk) mention"
|
|
|
|
let reply_ref = ReferencedId(ref_id: evid, relay_id: nil, key: "e")
|
|
|
|
let blocks = parse_post_blocks(content: content)
|
|
|
|
let post = NostrPost(content: content, references: [reply_ref])
|
2023-07-25 15:58:06 +00:00
|
|
|
let ev = post_to_event(post: post, keypair: test_keypair_full)!
|
|
|
|
|
2022-08-07 06:01:56 +00:00
|
|
|
XCTAssertEqual(ev.tags.count, 2)
|
|
|
|
XCTAssertEqual(blocks.count, 3)
|
2023-07-11 16:05:45 +00:00
|
|
|
XCTAssertEqual(blocks[1].is_mention, .pubkey(hex_pk))
|
2023-05-31 03:41:41 +00:00
|
|
|
XCTAssertEqual(ev.content, "this is a nostr:npub1xtscya34g58tk0z605fvr788k263gsu6cy9x0mhnm87echrgufzsevkk5s mention")
|
2022-08-07 06:01:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func testNsecMention() throws {
|
|
|
|
let evid = "0000000000000000000000000000000000000000000000000000000000000005"
|
|
|
|
let pk = "nsec1jmzdz7d0ldqctdxwm5fzue277ttng2pk28n2u8wntc2r4a0w96ssnyukg7"
|
|
|
|
let hex_pk = "ccf95d668650178defca5ac503693b6668eb77895f610178ff8ed9fe5cf9482e"
|
|
|
|
let content = "this is a @\(pk) mention"
|
|
|
|
let reply_ref = ReferencedId(ref_id: evid, relay_id: nil, key: "e")
|
|
|
|
let blocks = parse_post_blocks(content: content)
|
|
|
|
let post = NostrPost(content: content, references: [reply_ref])
|
2023-07-25 15:58:06 +00:00
|
|
|
let ev = post_to_event(post: post, keypair: test_keypair_full)!
|
|
|
|
|
2022-08-07 06:01:56 +00:00
|
|
|
XCTAssertEqual(ev.tags.count, 2)
|
|
|
|
XCTAssertEqual(blocks.count, 3)
|
2023-07-11 16:05:45 +00:00
|
|
|
XCTAssertEqual(blocks[1].is_mention, .pubkey(hex_pk))
|
2023-05-31 03:41:41 +00:00
|
|
|
XCTAssertEqual(ev.content, "this is a nostr:npub1enu46e5x2qtcmm72ttzsx6fmve5wkauftassz78l3mvluh8efqhqejf3v4 mention")
|
2022-08-07 06:01:56 +00:00
|
|
|
}
|
|
|
|
|
2022-05-09 02:31:40 +00:00
|
|
|
func testReplyMentions() throws {
|
|
|
|
let privkey = "0fc2092231f958f8d57d66f5e238bb45b6a2571f44c0ce024bbc6f3a9c8a15fe"
|
|
|
|
let pubkey = "30c6d1dc7f7c156794fa15055e651b758a61b99f50fcf759de59386050bf6ae2"
|
2023-07-11 16:05:45 +00:00
|
|
|
let npub = "npub1xrrdrhrl0s2k0986z5z4uegmwk9xrwvl2r70wkw7tyuxq59ldt3qh09eay"
|
|
|
|
|
2022-05-09 02:31:40 +00:00
|
|
|
let refs = [
|
|
|
|
ReferencedId(ref_id: "thread_id", relay_id: nil, key: "e"),
|
|
|
|
ReferencedId(ref_id: "reply_id", relay_id: nil, key: "e"),
|
|
|
|
ReferencedId(ref_id: pubkey, relay_id: nil, key: "p"),
|
|
|
|
]
|
|
|
|
|
2023-07-11 16:05:45 +00:00
|
|
|
let post = NostrPost(content: "this is a (@\(npub)) mention", references: refs)
|
2023-07-25 15:58:06 +00:00
|
|
|
let ev = post_to_event(post: post, keypair: test_keypair_full)!
|
2022-05-09 02:31:40 +00:00
|
|
|
|
2023-07-11 16:05:45 +00:00
|
|
|
XCTAssertEqual(ev.content, "this is a (nostr:\(npub)) mention")
|
2022-05-09 02:31:40 +00:00
|
|
|
XCTAssertEqual(ev.tags[2][1], pubkey)
|
|
|
|
}
|
|
|
|
|
2022-05-09 02:01:42 +00:00
|
|
|
func testInvalidPostReference() throws {
|
|
|
|
let pk = "32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e24"
|
|
|
|
let content = "this is a @\(pk) mention"
|
|
|
|
let parsed = parse_post_blocks(content: content)
|
|
|
|
XCTAssertEqual(parsed.count, 1)
|
|
|
|
guard case .text(let txt) = parsed[0] else {
|
|
|
|
XCTAssert(false)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
XCTAssertEqual(txt, content)
|
|
|
|
}
|
|
|
|
|
|
|
|
func testInvalidPostReferenceEmptyAt() throws {
|
|
|
|
let content = "this is a @ mention"
|
|
|
|
let parsed = parse_post_blocks(content: content)
|
|
|
|
XCTAssertEqual(parsed.count, 1)
|
|
|
|
guard case .text(let txt) = parsed[0] else {
|
|
|
|
XCTAssert(false)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
XCTAssertEqual(txt, content)
|
|
|
|
}
|
|
|
|
|
|
|
|
func testInvalidUriReference() throws {
|
|
|
|
let id = "6fec2ee6cfff779fe8560976b3d9df782b74577f0caefa7a77c0ed4c3749b5de"
|
|
|
|
let content = "this is a nostr:z:\(id) event mention"
|
|
|
|
let parsed = parse_post_blocks(content: content)
|
|
|
|
|
|
|
|
XCTAssertNotNil(parsed)
|
|
|
|
XCTAssertEqual(parsed.count, 1)
|
|
|
|
|
|
|
|
guard case .text(let txt) = parsed[0] else {
|
|
|
|
XCTAssertTrue(false)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
XCTAssertEqual(txt, content)
|
|
|
|
}
|
|
|
|
|
|
|
|
func testParsePostUriPubkeyReference() throws {
|
|
|
|
let id = "6fec2ee6cfff779fe8560976b3d9df782b74577f0caefa7a77c0ed4c3749b5de"
|
2023-05-31 03:41:41 +00:00
|
|
|
let npub = try XCTUnwrap(bech32_pubkey(id))
|
|
|
|
let parsed = parse_post_blocks(content: "this is a nostr:\(npub) event mention")
|
2022-05-09 02:01:42 +00:00
|
|
|
|
|
|
|
XCTAssertNotNil(parsed)
|
|
|
|
XCTAssertEqual(parsed.count, 3)
|
2022-07-28 20:10:00 +00:00
|
|
|
XCTAssertEqual(parsed[0].is_text, "this is a ")
|
2023-07-11 16:05:45 +00:00
|
|
|
XCTAssertEqual(parsed[1].is_mention, .pubkey(id))
|
2022-07-28 20:10:00 +00:00
|
|
|
XCTAssertEqual(parsed[2].is_text, " event mention")
|
2022-05-09 02:01:42 +00:00
|
|
|
|
|
|
|
guard case .text(let t1) = parsed[0] else {
|
|
|
|
XCTAssertTrue(false)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
XCTAssertEqual(t1, "this is a ")
|
|
|
|
|
|
|
|
guard case .text(let t2) = parsed[2] else {
|
|
|
|
XCTAssertTrue(false)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
XCTAssertEqual(t2, " event mention")
|
|
|
|
}
|
|
|
|
|
|
|
|
func testParsePostUriReference() throws {
|
|
|
|
let id = "6fec2ee6cfff779fe8560976b3d9df782b74577f0caefa7a77c0ed4c3749b5de"
|
2023-05-31 03:41:41 +00:00
|
|
|
let note_id = try XCTUnwrap(bech32_note_id(id))
|
|
|
|
let parsed = parse_post_blocks(content: "this is a nostr:\(note_id) event mention")
|
2022-05-09 02:01:42 +00:00
|
|
|
|
|
|
|
XCTAssertNotNil(parsed)
|
|
|
|
XCTAssertEqual(parsed.count, 3)
|
2022-07-28 20:10:00 +00:00
|
|
|
XCTAssertEqual(parsed[0].is_text, "this is a ")
|
2023-07-11 16:05:45 +00:00
|
|
|
XCTAssertEqual(parsed[1].is_mention, .note(id))
|
2022-07-28 20:10:00 +00:00
|
|
|
XCTAssertEqual(parsed[2].is_text, " event mention")
|
2023-07-11 16:05:45 +00:00
|
|
|
|
2022-05-09 02:01:42 +00:00
|
|
|
guard case .text(let t1) = parsed[0] else {
|
|
|
|
XCTAssertTrue(false)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
XCTAssertEqual(t1, "this is a ")
|
|
|
|
|
|
|
|
guard case .text(let t2) = parsed[2] else {
|
|
|
|
XCTAssertTrue(false)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
XCTAssertEqual(t2, " event mention")
|
|
|
|
}
|
|
|
|
|
|
|
|
func testParseInvalidMention() throws {
|
2023-07-16 17:49:31 +00:00
|
|
|
let parsed = parse_note_content(content: "this is #[0] a mention", tags: []).blocks
|
2022-05-09 02:01:42 +00:00
|
|
|
|
|
|
|
XCTAssertNotNil(parsed)
|
2022-10-17 22:20:38 +00:00
|
|
|
XCTAssertEqual(parsed.count, 3)
|
|
|
|
XCTAssertEqual(parsed[0].is_text, "this is ")
|
|
|
|
XCTAssertEqual(parsed[1].is_text, "#[0]")
|
|
|
|
XCTAssertEqual(parsed[2].is_text, " a mention")
|
2022-05-09 02:01:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|