grain.social/grain-ios
1 collaborator
- 1 collaborator
0
1
@testable import Grain
import XCTest
/// Captures the record the cross-post actually writes.
private final class PostLog: @unchecked Sendable {
private let lock = NSLock()
private var requests: [URLRequest] = []
func record(_ request: URLRequest) {
lock.withLock { requests.append(request) }
}
var count: Int {
lock.withLock { requests.count }
}
private var last: URLRequest? {
lock.withLock { requests.last }
}
var lastPath: String? {
last?.url?.path
}
var lastBody: [String: Any]? {
guard let request = last else { return nil }
var data = request.httpBody
if data == nil, let stream = request.httpBodyStream {
stream.open()
defer { stream.close() }
var collected = Data()
let size = 8192
let buffer = UnsafeMutablePointer<UInt8>.allocate(capacity: size)
defer { buffer.deallocate() }
while stream.hasBytesAvailable {
let read = stream.read(buffer, maxLength: size)
guard read > 0 else { break }
collected.append(buffer, count: read)
}
data = collected
}
guard let data else { return nil }
return (try? JSONSerialization.jsonObject(with: data)) as? [String: Any]
}
var lastRecord: [String: Any]? {
lastBody?["record"] as? [String: Any]
}
}
/// The record a gallery's Bluesky cross-post writes. Its shape has to match the
/// web client's byte for byte — a wrong `$type` or a facet whose byte offsets
/// drift shows up as a mangled post on someone's timeline, not as an error.
///
/// `buildPostText` already has its own suite; this covers what happens to that
/// text afterwards: facets, the image embed, and which write verb is used.
@MainActor
final class BlueskyCrossPostTests: GrainTestCase {
private var client: XRPCClient!
private var log: PostLog!
private var auth: AuthContext!
private var did = ""
override func setUp() async throws {
try await super.setUp()
did = "did:plc:bsky-\(UUID().uuidString)"
client = XRPCClient(baseURL: URL(string: "https://test.local")!, session: MockURLProtocol.mockSession())
auth = try AuthContext(accessToken: "token", dpop: DPoP.loadOrCreate(for: did), did: did, pds: URL(string: "https://test.local")!)
log = PostLog()
let log = log!
MockURLProtocol.handler = { request in
log.record(request)
let response = HTTPURLResponse(url: request.url!, statusCode: 200, httpVersion: nil, headerFields: nil)!
return (Data(#"{"uri": "at://did:plc:test/app.bsky.feed.post/1", "cid": "bafy"}"#.utf8), response)
}
}
override func tearDown() async throws {
MockURLProtocol.handler = nil
try? DPoP.clearKey(for: did)
try await super.tearDown()
}
private func blob(_ link: String = "bafyblob") -> BlobRef {
BlobRef(type: "blob", ref: BlobRef.BlobLink(link: link), mimeType: "image/jpeg", size: 1234)
}
private func options(
title: String? = "Golden hour",
description: String? = nil,
location: (name: String, address: [String: AnyCodable]?)? = nil,
images: [(blob: BlobRef, alt: String, width: Int, height: Int)] = []
) -> BlueskyPostOptions {
BlueskyPostOptions(
url: "https://grain.social/profile/did:plc:test/gallery/1",
title: title,
location: location,
description: description,
images: images
)
}
private func post(
_ options: BlueskyPostOptions,
rkey: String? = nil
) async throws {
try await BlueskyPost.create(
options: options,
client: client,
repo: "did:plc:test",
auth: auth,
rkey: rkey,
createdAt: "2025-01-02T00:00:00.000Z"
)
}
// MARK: - Record shape
func testTheRecordCarriesTheTextAndTheGrainTag() async throws {
try await post(options())
let record = try XCTUnwrap(log.lastRecord)
XCTAssertEqual(record["tags"] as? [String], ["grainsocial"])
XCTAssertEqual(record["createdAt"] as? String, "2025-01-02T00:00:00.000Z")
let text = try XCTUnwrap(record["text"] as? String)
XCTAssertTrue(text.contains("Golden hour"))
XCTAssertTrue(text.contains("https://grain.social/profile/did:plc:test/gallery/1"))
}
/// The cross-post is written under a record key the draft assigned, so a
/// resumed publish overwrites its own post rather than posting twice.
func testAKeyedCrossPostOverwritesRatherThanPostsAgain() async throws {
try await post(options(), rkey: "3jzfcijpj2z2a")
XCTAssertEqual(log.lastPath, "/xrpc/com.atproto.repo.putRecord")
XCTAssertEqual(log.lastBody?["rkey"] as? String, "3jzfcijpj2z2a")
XCTAssertEqual(log.lastBody?["collection"] as? String, "app.bsky.feed.post")
XCTAssertEqual(log.lastBody?["repo"] as? String, "did:plc:test")
}
func testAnUnkeyedCrossPostCreatesANewRecord() async throws {
try await post(options())
XCTAssertEqual(log.lastPath, "/xrpc/com.atproto.repo.createRecord")
XCTAssertEqual(log.lastBody?["collection"] as? String, "app.bsky.feed.post")
}
// MARK: - Image embed
func testImagesBecomeABlueskyImageEmbed() async throws {
try await post(options(images: [
(blob: blob("bafyone"), alt: "First photo", width: 3000, height: 2000),
]))
let record = try XCTUnwrap(log.lastRecord)
let embed = try XCTUnwrap(record["embed"] as? [String: Any])
XCTAssertEqual(embed["$type"] as? String, "app.bsky.embed.images")
let images = try XCTUnwrap(embed["images"] as? [[String: Any]])
XCTAssertEqual(images.count, 1)
XCTAssertEqual(images[0]["alt"] as? String, "First photo")
let image = try XCTUnwrap(images[0]["image"] as? [String: Any])
XCTAssertEqual(image["$type"] as? String, "blob")
XCTAssertEqual(image["mimeType"] as? String, "image/jpeg")
XCTAssertEqual(image["size"] as? Int, 1234)
XCTAssertEqual((image["ref"] as? [String: Any])?["$link"] as? String, "bafyone")
let ratio = try XCTUnwrap(images[0]["aspectRatio"] as? [String: Any])
XCTAssertEqual(ratio["width"] as? Int, 3000)
XCTAssertEqual(ratio["height"] as? Int, 2000)
}
/// Bluesky takes at most four images; sending more is rejected outright.
func testOnlyTheFirstFourImagesAreEmbedded() async throws {
let images = (0 ..< 7).map {
(blob: blob("bafy\($0)"), alt: "Photo \($0)", width: 100, height: 100)
}
try await post(options(images: images))
let embed = try XCTUnwrap(log.lastRecord?["embed"] as? [String: Any])
let embedded = try XCTUnwrap(embed["images"] as? [[String: Any]])
XCTAssertEqual(embedded.count, 4)
XCTAssertEqual(embedded.first?["alt"] as? String, "Photo 0")
XCTAssertEqual(embedded.last?["alt"] as? String, "Photo 3")
}
/// A gallery with no blobs yet must not send an empty embed — Bluesky
/// rejects one.
func testAPostWithNoImagesHasNoEmbed() async throws {
try await post(options())
XCTAssertNil(log.lastRecord?["embed"])
}
/// A blob missing its optional fields still has to produce a well-formed
/// embed rather than nulls the server won't take.
func testAnIncompleteBlobFallsBackToDefaults() async throws {
let bare = BlobRef(type: nil, ref: nil, mimeType: nil, size: nil)
try await post(options(images: [(blob: bare, alt: "", width: 1, height: 1)]))
let embed = try XCTUnwrap(log.lastRecord?["embed"] as? [String: Any])
let image = try XCTUnwrap((embed["images"] as? [[String: Any]])?.first?["image"] as? [String: Any])
XCTAssertEqual(image["$type"] as? String, "blob")
XCTAssertEqual(image["mimeType"] as? String, "image/jpeg")
XCTAssertEqual(image["size"] as? Int, 0)
XCTAssertEqual((image["ref"] as? [String: Any])?["$link"] as? String, "")
}
// MARK: - Facets in the written record
/// The gallery link is always in the text, so every cross-post carries at
/// least one link facet — without it the URL posts as plain text.
func testTheGalleryLinkIsFacetedAsALink() async throws {
try await post(options())
let facets = try XCTUnwrap(log.lastRecord?["facets"] as? [[String: Any]])
let features = facets.flatMap { ($0["features"] as? [[String: Any]]) ?? [] }
XCTAssertTrue(features.contains { $0["$type"] as? String == "app.bsky.richtext.facet#link" })
XCTAssertTrue(features.contains {
$0["uri"] as? String == "https://grain.social/profile/did:plc:test/gallery/1"
})
}
func testAHashtagInTheDescriptionIsFacetedAsATag() async throws {
try await post(options(description: "Shot on #Portra400 in the morning."))
let facets = try XCTUnwrap(log.lastRecord?["facets"] as? [[String: Any]])
let features = facets.flatMap { ($0["features"] as? [[String: Any]]) ?? [] }
let tags = features.filter { $0["$type"] as? String == "app.bsky.richtext.facet#tag" }
XCTAssertTrue(tags.contains { $0["tag"] as? String == "Portra400" })
}
/// Every facet's byte range has to land inside the text it annotates, or
/// Bluesky renders the link over the wrong characters.
func testEveryFacetPointsAtRealBytesOfTheText() async throws {
try await post(options(title: "A café gallery", description: "Shot on #Portra400 ☕️"))
let record = try XCTUnwrap(log.lastRecord)
let text = try XCTUnwrap(record["text"] as? String)
let byteCount = text.utf8.count
let facets = try XCTUnwrap(record["facets"] as? [[String: Any]])
for facet in facets {
let index = try XCTUnwrap(facet["index"] as? [String: Any])
let start = try XCTUnwrap(index["byteStart"] as? Int)
let end = try XCTUnwrap(index["byteEnd"] as? Int)
XCTAssertGreaterThanOrEqual(start, 0)
XCTAssertGreaterThan(end, start)
XCTAssertLessThanOrEqual(end, byteCount, "A facet runs past the end of the text")
}
}
// MARK: - parseTextToFacets
func testAPlainSentenceHasNoFacets() async {
let facets = await BlueskyPost.parseTextToFacets("Just a caption with nothing special in it.")
XCTAssertTrue(facets.isEmpty)
}
func testEmptyTextHasNoFacets() async {
let facets = await BlueskyPost.parseTextToFacets("")
XCTAssertTrue(facets.isEmpty)
}
func testAURLIsFacetedWithItsOwnByteRange() async throws {
let text = "See https://grain.social/x for more"
let facets = await BlueskyPost.parseTextToFacets(text)
XCTAssertEqual(facets.count, 1)
let facet = try XCTUnwrap(facets.first)
let bytes = Array(text.utf8)[facet.index.byteStart ..< facet.index.byteEnd]
XCTAssertEqual(String(bytes: bytes, encoding: .utf8), "https://grain.social/x")
guard case let .link(uri) = facet.features.first else {
return XCTFail("Expected a link feature")
}
XCTAssertEqual(uri, "https://grain.social/x")
}
func testHashtagsAreFacetedWithoutTheHash() async throws {
let text = "Filed under #portra400 and #kodak"
let facets = await BlueskyPost.parseTextToFacets(text)
let tags: [String] = facets.compactMap { facet in
if case let .tag(tag) = facet.features.first {
return tag
}
return nil
}
XCTAssertEqual(tags, ["portra400", "kodak"])
// The byte range covers the "#" too, so the whole token is highlighted.
let first = try XCTUnwrap(facets.first)
let bytes = Array(text.utf8)[first.index.byteStart ..< first.index.byteEnd]
XCTAssertEqual(String(bytes: bytes, encoding: .utf8), "#portra400")
}
/// The pattern is `#\p{L}…`, so a tag has to start with a letter. That rules
/// out the film-stock tags this app is full of — `#35mm`, `#120` — which
/// cross-post as plain text rather than as links. Pinned because it matches
/// `RichTextView`'s in-app parsing, not because a photography app obviously
/// wants it.
func testATagStartingWithADigitIsNotFaceted() async {
let facets = await BlueskyPost.parseTextToFacets("Shot on #35mm and #120")
let tags = facets.filter {
if case .tag = $0.features.first {
true
} else {
false
}
}
XCTAssertTrue(tags.isEmpty)
}
/// Emoji ahead of a facet push the byte offsets away from the character
/// offsets, which is exactly where an offset bug shows up.
func testByteOffsetsSurviveEmojiEarlierInTheText() async throws {
let text = "📷☕️ shot at https://grain.social/x"
let facets = await BlueskyPost.parseTextToFacets(text)
let facet = try XCTUnwrap(facets.first)
let bytes = Array(text.utf8)[facet.index.byteStart ..< facet.index.byteEnd]
XCTAssertEqual(String(bytes: bytes, encoding: .utf8), "https://grain.social/x")
XCTAssertGreaterThan(facet.index.byteStart, text.distance(from: text.startIndex, to: text.startIndex))
}
/// URLs are claimed before hashtags, so a fragment inside a link must not
/// also be parsed as a tag.
func testAFragmentInsideALinkIsNotAlsoAHashtag() async {
let facets = await BlueskyPost.parseTextToFacets("See https://grain.social/x#section for more")
let tags = facets.filter {
if case .tag = $0.features.first {
true
} else {
false
}
}
XCTAssertTrue(tags.isEmpty, "The link claimed those bytes first")
}
func testFacetsComeBackInTextOrder() async {
let facets = await BlueskyPost.parseTextToFacets("#first then https://grain.social/x then #last")
let starts = facets.map(\.index.byteStart)
XCTAssertEqual(starts, starts.sorted())
XCTAssertEqual(facets.count, 3)
}
}