This is an example note.
", + "contentMap": { + "en": "This is an example note.
" + }, + "attachment": [], + "replies": {...}, + "sensitive": false, + "summary": "", + "tag": {...} +} +``` + +GoToSocial will always set the `content` field if the post has content, but it may not always set the `contentMap` field, if an old version of GoToSocial is in use, or the language used by a user is not set or not a recognized BCP47 language tag. + +### Incoming + +GoToSocial uses both the `content` and the `contentMap` properties on incoming `Object`s to determine the content and infer the intended "primary" language for that content. It uses the following algorithm: + +#### Only `content` is set + +Take that content only and mark language as unknown. + +#### Both `content` and `contentMap` are set + +Look for a language tag as key in the `contentMap`, with a value that matches the stringified HTML set in `content`. + +If a match is found, use this as the post's language. + +If a match is not found, keep content from `content` and mark language as unknown. + +#### Only `contentMap` is set + +If `contentMap` has only one entry, take the language tag and content value as the "primary" language and content. + +If `contentMap` has multiple entries, we have no way of determining the intended preferred content and language of the post, since map order is not deterministic. In this case, try to pick a language and content entry that matches one of the languages configured in the GoToSocial instance's [configured languages](../configuration/instance.md). If no language can be matched this way, pick a language and content entry from the `contentMap` at random as the "primary" language and content. + +!!! Note + In all of the above cases, if the inferred language cannot be parsed as a valid BCP47 language tag, language will fall back to unknown. diff --git a/internal/ap/ap_test.go b/internal/ap/ap_test.go index 6a5073c63..583a37c53 100644 --- a/internal/ap/ap_test.go +++ b/internal/ap/ap_test.go @@ -93,6 +93,12 @@ func noteWithMentions1() vocab.ActivityStreamsNote { content := streams.NewActivityStreamsContentProperty() content.AppendXMLSchemaString("hey @f0x and @dumpsterqueer") + + rdfLangString := make(map[string]string) + rdfLangString["en"] = "hey @f0x and @dumpsterqueer" + rdfLangString["fr"] = "bonjour @f0x et @dumpsterqueer" + content.AppendRDFLangString(rdfLangString) + note.SetActivityStreamsContent(content) return note diff --git a/internal/ap/extract.go b/internal/ap/extract.go index 424f77409..3d92fa2ba 100644 --- a/internal/ap/extract.go +++ b/internal/ap/extract.go @@ -631,27 +631,34 @@ func ExtractPublicKey(i WithPublicKey) ( return nil, nil, nil, gtserror.New("couldn't find public key") } -// ExtractContent returns a string representation of the -// given interface's Content property, or an empty string -// if no Content is found. -func ExtractContent(i WithContent) string { - contentProperty := i.GetActivityStreamsContent() - if contentProperty == nil { - return "" +// ExtractContent returns an intermediary representation of +// the given interface's Content and/or ContentMap property. +func ExtractContent(i WithContent) gtsmodel.Content { + content := gtsmodel.Content{} + + contentProp := i.GetActivityStreamsContent() + if contentProp == nil { + // No content at all. + return content } - for iter := contentProperty.Begin(); iter != contentProperty.End(); iter = iter.Next() { + for iter := contentProp.Begin(); iter != contentProp.End(); iter = iter.Next() { switch { - // Content may be parsed as IRI, depending on - // how it's formatted, so account for this. - case iter.IsXMLSchemaString(): - return iter.GetXMLSchemaString() - case iter.IsIRI(): - return iter.GetIRI().String() + case iter.IsRDFLangString() && + len(content.ContentMap) == 0: + content.ContentMap = iter.GetRDFLangString() + + case iter.IsXMLSchemaString() && + content.Content == "": + content.Content = iter.GetXMLSchemaString() + + case iter.IsIRI() && + content.Content == "": + content.Content = iter.GetIRI().String() } } - return "" + return content } // ExtractAttachments attempts to extract barebones MediaAttachment objects from given AS interface type. diff --git a/internal/ap/extractcontent_test.go b/internal/ap/extractcontent_test.go index 590d1b931..c899a10e1 100644 --- a/internal/ap/extractcontent_test.go +++ b/internal/ap/extractcontent_test.go @@ -30,10 +30,11 @@ type ExtractContentTestSuite struct { func (suite *ExtractContentTestSuite) TestExtractContent1() { note := suite.noteWithMentions1 - content := ap.ExtractContent(note) - suite.Equal("hey @f0x and @dumpsterqueer", content) + suite.Equal("hey @f0x and @dumpsterqueer", content.Content) + suite.Equal("bonjour @f0x et @dumpsterqueer", content.ContentMap["fr"]) + suite.Equal("hey @f0x and @dumpsterqueer", content.ContentMap["en"]) } func TestExtractContentTestSuite(t *testing.T) { diff --git a/internal/ap/normalize.go b/internal/ap/normalize.go index 192a2d740..a27527b84 100644 --- a/internal/ap/normalize.go +++ b/internal/ap/normalize.go @@ -20,11 +20,12 @@ package ap import ( "github.com/superseriousbusiness/activity/pub" "github.com/superseriousbusiness/activity/streams" + "github.com/superseriousbusiness/gotosocial/internal/gtserror" "github.com/superseriousbusiness/gotosocial/internal/text" ) /* - NORMALIZE INCOMING + INCOMING NORMALIZATION The below functions should be called to normalize the content of messages *COMING INTO* GoToSocial via the federation API, either as the result of delivery from a remote instance to this @@ -84,39 +85,84 @@ func NormalizeIncomingActivity(activity pub.Activity, rawJSON map[string]interfa } } -// NormalizeIncomingContent replaces the Content of the given item -// with the sanitized version of the raw 'content' value from the -// raw json object map. +// normalizeContent normalizes the given content +// string by sanitizing its HTML and minimizing it. // -// noop if there was no content in the json object map or the -// content was not a plain string. -func NormalizeIncomingContent(item WithContent, rawJSON map[string]interface{}) { - rawContent, ok := rawJSON["content"] - if !ok { - // No content in rawJSON. - // TODO: In future we might also - // look for "contentMap" property. - return +// Noop for non-string content. +func normalizeContent(rawContent interface{}) string { + if rawContent == nil { + // Nothing to fix. + return "" } content, ok := rawContent.(string) if !ok { - // Not interested in content arrays. - return + // Not interested in + // content slices etc. + return "" } - // Content should be HTML encoded by default: + if content == "" { + // Nothing to fix. + return "" + } + + // Content entries should be HTML encoded by default: // https://www.w3.org/TR/activitystreams-vocabulary/#dfn-content // // TODO: sanitize differently based on mediaType. // https://www.w3.org/TR/activitystreams-vocabulary/#dfn-mediatype content = text.SanitizeToHTML(content) content = text.MinifyHTML(content) + return content +} - // Set normalized content property from the raw string; - // this replaces any existing content property on the item. +// NormalizeIncomingContent replaces the Content property of the given +// item with the normalized versions of the raw 'content' and 'contentMap' +// values from the raw json object map. +// +// noop if there was no 'content' or 'contentMap' in the json object map. +func NormalizeIncomingContent(item WithContent, rawJSON map[string]interface{}) { + var ( + rawContent = rawJSON["content"] + rawContentMap = rawJSON["contentMap"] + ) + + if rawContent == nil && + rawContentMap == nil { + // Nothing to normalize, + // leave no content on item. + return + } + + // Create wrapper for normalized content. contentProp := streams.NewActivityStreamsContentProperty() - contentProp.AppendXMLSchemaString(content) + + // Fix 'content' if applicable. + content := normalizeContent(rawContent) + if content != "" { + contentProp.AppendXMLSchemaString(content) + } + + // Fix 'contentMap' if applicable. + contentMap, ok := rawContentMap.(map[string]interface{}) + if ok { + rdfLangs := make(map[string]string, len(contentMap)) + + for lang, rawContent := range contentMap { + content := normalizeContent(rawContent) + if content != "" { + rdfLangs[lang] = content + } + } + + if len(rdfLangs) != 0 { + contentProp.AppendRDFLangString(rdfLangs) + } + } + + // Replace any existing content property + // on the item with normalized version. item.SetActivityStreamsContent(contentProp) } @@ -299,3 +345,204 @@ func NormalizeIncomingPollOptions(item WithOneOf, rawJSON map[string]interface{} NormalizeIncomingName(choiceable, rawChoice) } } + +/* + OUTGOING NORMALIZATION + The below functions should be called to normalize the content + of messages *GOING OUT OF* GoToSocial via the federation API, + either as the result of delivery to a remote instance from this + instance, or as a result of a remote instance doing an http call + to us to dereference something. +*/ + +// NormalizeOutgoingAttachmentProp replaces single-entry Attachment objects with +// single-entry arrays, for better compatibility with other AP implementations. +// +// Ie: +// +// "attachment": { +// ... +// } +// +// becomes: +// +// "attachment": [ +// { +// ... +// } +// ] +// +// Noop for items with no attachments, or with attachments that are already a slice. +func NormalizeOutgoingAttachmentProp(item WithAttachment, rawJSON map[string]interface{}) { + attachment, ok := rawJSON["attachment"] + if !ok { + // No 'attachment', + // nothing to change. + return + } + + if _, ok := attachment.([]interface{}); ok { + // Already slice, + // nothing to change. + return + } + + // Coerce single-object to slice. + rawJSON["attachment"] = []interface{}{attachment} +} + +// NormalizeOutgoingContentProp normalizes go-fed's funky formatting of content and +// contentMap properties to a format better understood by other AP implementations. +// +// Ie., incoming "content" property like this: +// +// "content": [ +// "hello world!", +// { +// "en": "hello world!" +// } +// ] +// +// Is unpacked to: +// +// "content": "hello world!", +// "contentMap": { +// "en": "hello world!" +// } +// +// Noop if neither content nor contentMap are set. +func NormalizeOutgoingContentProp(item WithContent, rawJSON map[string]interface{}) { + contentProp := item.GetActivityStreamsContent() + if contentProp == nil { + // Nothing to do, + // bail early. + return + } + + contentPropLen := contentProp.Len() + if contentPropLen == 0 { + // Nothing to do, + // bail early. + return + } + + var ( + content string + contentMap map[string]string + ) + + for iter := contentProp.Begin(); iter != contentProp.End(); iter = iter.Next() { + switch { + case iter.IsRDFLangString() && + contentMap == nil: + contentMap = iter.GetRDFLangString() + + case content == "" && + iter.IsXMLSchemaString(): + content = iter.GetXMLSchemaString() + } + } + + if content != "" { + rawJSON["content"] = content + } else { + delete(rawJSON, "content") + } + + if contentMap != nil { + rawJSON["contentMap"] = contentMap + } else { + delete(rawJSON, "contentMap") + } +} + +// NormalizeOutgoingObjectProp normalizes each Object entry in the rawJSON of the given +// item by calling custom serialization / normalization functions on them in turn. +// +// This function also unnests single-entry arrays, so that: +// +// "object": [ +// { +// ... +// } +// ] +// +// Becomes: +// +// "object": { +// ... +// } +// +// Noop for each Object entry that isn't an Accountable or Statusable. +func NormalizeOutgoingObjectProp(item WithObject, rawJSON map[string]interface{}) error { + objectProp := item.GetActivityStreamsObject() + if objectProp == nil { + // Nothing to do, + // bail early. + return nil + } + + objectPropLen := objectProp.Len() + if objectPropLen == 0 { + // Nothing to do, + // bail early. + return nil + } + + // The thing we already serialized has objects + // on it, so we should see if we need to custom + // serialize any of those objects, and replace + // them on the data map as necessary. + objects := make([]interface{}, 0, objectPropLen) + for iter := objectProp.Begin(); iter != objectProp.End(); iter = iter.Next() { + if iter.IsIRI() { + // Plain IRIs don't need custom serialization. + objects = append(objects, iter.GetIRI().String()) + continue + } + + var ( + objectType = iter.GetType() + objectSer map[string]interface{} + ) + + if objectType == nil { + // This is awkward. + return gtserror.Newf("could not resolve object iter %T to vocab.Type", iter) + } + + var err error + + // In the below accountable and statusable serialization, + // `@context` will be included in the wrapping type already, + // so we shouldn't also include it in the object itself. + switch tn := objectType.GetTypeName(); { + case IsAccountable(tn): + objectSer, err = serializeAccountable(objectType, false) + + case IsStatusable(tn): + // IsStatusable includes Pollable as well. + objectSer, err = serializeStatusable(objectType, false) + + default: + // No custom serializer for this type; serialize as normal. + objectSer, err = objectType.Serialize() + } + + if err != nil { + return err + } + + objects = append(objects, objectSer) + } + + if objectPropLen == 1 { + // Unnest single object. + rawJSON["object"] = objects[0] + } else { + // Array of objects. + rawJSON["object"] = objects + } + + return nil +} diff --git a/internal/ap/normalize_test.go b/internal/ap/normalize_test.go index cd1affe60..33b1f6ea6 100644 --- a/internal/ap/normalize_test.go +++ b/internal/ap/normalize_test.go @@ -46,6 +46,9 @@ func (suite *NormalizeTestSuite) getStatusable() (vocab.ActivityStreamsNote, map "https://example.org/users/someone/followers" ], "content": "UPDATE: As of this morning there are now more than 7 million Mastodon users, most from the #TwitterMigration.> So we have to examine critical thinking as a signifier, dynamic and ambiguous. It has a normative definition, a tacit definition, and an ideal definition. One of the hallmarks of graduate training is learning to comprehend those definitions and applying the correct one as needed for professional success.
`, status.Content) + suite.Equal(`> So we have to examine critical thinking as a signifier, dynamic and ambiguous. It has a normative definition, a tacit definition, and an ideal definition. One of the hallmarks of graduate training is learning to comprehend those definitions and applying the correct one as needed for professional success.
`, status.Content) + suite.Equal("en", status.Language) } func (suite *ASToInternalTestSuite) TestParsePublicStatusNoURL() { @@ -117,7 +122,7 @@ func (suite *ASToInternalTestSuite) TestParsePublicStatusNoURL() { suite.NoError(err) suite.Equal("reading: Punishment and Reward in the Corporate University", status.ContentWarning) - suite.Equal(`> So we have to examine critical thinking as a signifier, dynamic and ambiguous. It has a normative definition, a tacit definition, and an ideal definition. One of the hallmarks of graduate training is learning to comprehend those definitions and applying the correct one as needed for professional success.
`, status.Content) + suite.Equal(`> So we have to examine critical thinking as a signifier, dynamic and ambiguous. It has a normative definition, a tacit definition, and an ideal definition. One of the hallmarks of graduate training is learning to comprehend those definitions and applying the correct one as needed for professional success.
`, status.Content) // on statuses with no URL in them (like ones we get from pleroma sometimes) we should use the AP URI of the status as URL suite.Equal("http://fossbros-anonymous.io/users/foss_satan/statuses/108138763199405167", status.URL) diff --git a/internal/typeutils/internaltoas.go b/internal/typeutils/internaltoas.go index 16467be40..ff502296b 100644 --- a/internal/typeutils/internaltoas.go +++ b/internal/typeutils/internaltoas.go @@ -607,9 +607,17 @@ func (c *Converter) StatusToAS(ctx context.Context, s *gtsmodel.Status) (ap.Stat // conversation // TODO - // content -- the actual post itself + // content -- the actual post + // itself, plus the language contentProp := streams.NewActivityStreamsContentProperty() contentProp.AppendXMLSchemaString(s.Content) + + if s.Language != "" { + contentProp.AppendRDFLangString(map[string]string{ + s.Language: s.Content, + }) + } + status.SetActivityStreamsContent(contentProp) // attachments diff --git a/internal/typeutils/internaltoas_test.go b/internal/typeutils/internaltoas_test.go index 01dde66fb..878040dcc 100644 --- a/internal/typeutils/internaltoas_test.go +++ b/internal/typeutils/internaltoas_test.go @@ -340,6 +340,9 @@ func (suite *InternalToASTestSuite) TestStatusToAS() { "attributedTo": "http://localhost:8080/users/the_mighty_zork", "cc": "http://localhost:8080/users/the_mighty_zork/followers", "content": "hello everyone!", + "contentMap": { + "en": "hello everyone!" + }, "id": "http://localhost:8080/users/the_mighty_zork/statuses/01F8MHAMCHF6Y650WCRSCP4WMY", "published": "2021-10-20T12:40:37+02:00", "replies": { @@ -379,16 +382,21 @@ func (suite *InternalToASTestSuite) TestStatusWithTagsToASWithIDs() { // http://joinmastodon.org/ns, https://www.w3.org/ns/activitystreams -- // will appear, so trim them out of the string for consistency trimmed := strings.SplitAfter(string(bytes), `"attachment":`)[1] - suite.Equal(` { - "blurhash": "LNJRdVM{00Rj%Mayt7j[4nWBofRj", - "mediaType": "image/jpeg", - "name": "Black and white image of some 50's style text saying: Welcome On Board", - "type": "Document", - "url": "http://localhost:8080/fileserver/01F8MH17FWEB39HZJ76B6VXSKF/attachment/original/01F8MH6NEM8D7527KZAECTCR76.jpg" - }, + suite.Equal(` [ + { + "blurhash": "LNJRdVM{00Rj%Mayt7j[4nWBofRj", + "mediaType": "image/jpeg", + "name": "Black and white image of some 50's style text saying: Welcome On Board", + "type": "Document", + "url": "http://localhost:8080/fileserver/01F8MH17FWEB39HZJ76B6VXSKF/attachment/original/01F8MH6NEM8D7527KZAECTCR76.jpg" + } + ], "attributedTo": "http://localhost:8080/users/admin", "cc": "http://localhost:8080/users/admin/followers", "content": "hello world! #welcome ! first post on the instance :rainbow: !", + "contentMap": { + "en": "hello world! #welcome ! first post on the instance :rainbow: !" + }, "id": "http://localhost:8080/users/admin/statuses/01F8MH75CBF9JFX4ZAD54N0W0R", "published": "2021-10-20T11:36:45Z", "replies": { @@ -446,16 +454,21 @@ func (suite *InternalToASTestSuite) TestStatusWithTagsToASFromDB() { // http://joinmastodon.org/ns, https://www.w3.org/ns/activitystreams -- // will appear, so trim them out of the string for consistency trimmed := strings.SplitAfter(string(bytes), `"attachment":`)[1] - suite.Equal(` { - "blurhash": "LNJRdVM{00Rj%Mayt7j[4nWBofRj", - "mediaType": "image/jpeg", - "name": "Black and white image of some 50's style text saying: Welcome On Board", - "type": "Document", - "url": "http://localhost:8080/fileserver/01F8MH17FWEB39HZJ76B6VXSKF/attachment/original/01F8MH6NEM8D7527KZAECTCR76.jpg" - }, + suite.Equal(` [ + { + "blurhash": "LNJRdVM{00Rj%Mayt7j[4nWBofRj", + "mediaType": "image/jpeg", + "name": "Black and white image of some 50's style text saying: Welcome On Board", + "type": "Document", + "url": "http://localhost:8080/fileserver/01F8MH17FWEB39HZJ76B6VXSKF/attachment/original/01F8MH6NEM8D7527KZAECTCR76.jpg" + } + ], "attributedTo": "http://localhost:8080/users/admin", "cc": "http://localhost:8080/users/admin/followers", "content": "hello world! #welcome ! first post on the instance :rainbow: !", + "contentMap": { + "en": "hello world! #welcome ! first post on the instance :rainbow: !" + }, "id": "http://localhost:8080/users/admin/statuses/01F8MH75CBF9JFX4ZAD54N0W0R", "published": "2021-10-20T11:36:45Z", "replies": { @@ -519,6 +532,9 @@ func (suite *InternalToASTestSuite) TestStatusToASWithMentions() { "http://localhost:8080/users/the_mighty_zork" ], "content": "hi @the_mighty_zork welcome to the instance!", + "contentMap": { + "en": "hi @the_mighty_zork welcome to the instance!" + }, "id": "http://localhost:8080/users/admin/statuses/01FF25D5Q0DH7CHD57CTRS6WK0", "inReplyTo": "http://localhost:8080/users/the_mighty_zork/statuses/01F8MHAMCHF6Y650WCRSCP4WMY", "published": "2021-11-20T13:32:16Z", diff --git a/internal/typeutils/util.go b/internal/typeutils/util.go index a19588221..8a8d4123b 100644 --- a/internal/typeutils/util.go +++ b/internal/typeutils/util.go @@ -31,6 +31,8 @@ import ( apimodel "github.com/superseriousbusiness/gotosocial/internal/api/model" "github.com/superseriousbusiness/gotosocial/internal/config" "github.com/superseriousbusiness/gotosocial/internal/gtsmodel" + "github.com/superseriousbusiness/gotosocial/internal/language" + "github.com/superseriousbusiness/gotosocial/internal/log" "github.com/superseriousbusiness/gotosocial/internal/regexes" "github.com/superseriousbusiness/gotosocial/internal/text" ) @@ -184,3 +186,102 @@ func placeholdUnknownAttachments(arr []apimodel.Attachment) (string, []apimodel. return text.SanitizeToHTML(aside.String()), arr } + +// ContentToContentLanguage tries to +// extract a content string and language +// tag string from the given intermediary +// content. +// +// Either/both of the returned strings may +// be empty, depending on how things go. +func ContentToContentLanguage( + ctx context.Context, + content gtsmodel.Content, +) ( + string, // content + string, // language +) { + var ( + contentStr string + langTagStr string + ) + + switch contentMap := content.ContentMap; { + // Simplest case: no `contentMap`. + // Return `content`, even if empty. + case contentMap == nil: + return content.Content, "" + + // `content` and `contentMap` set. + // Try to infer "primary" language. + case content.Content != "": + // Assume `content` is intended + // primary content, and look for + // corresponding language tag. + contentStr = content.Content + + for t, c := range contentMap { + if contentStr == c { + langTagStr = t + break + } + } + + // `content` not set; `contentMap` + // is set with only one value. + // This must be the "primary" lang. + case len(contentMap) == 1: + // Use an empty loop to + // get the values we want. + // nolint:revive + for langTagStr, contentStr = range contentMap { + } + + // Only `contentMap` is set, with more + // than one value. Map order is not + // guaranteed so we can't know the + // "primary" language. + // + // Try to select content using our + // instance's configured languages. + // + // In case of no hits, just take the + // first tag and content in the map. + default: + instanceLangs := config.GetInstanceLanguages() + for _, langTagStr = range instanceLangs.TagStrs() { + if contentStr = contentMap[langTagStr]; contentStr != "" { + // Hit! + break + } + } + + // If nothing found, just take + // the first entry we can get by + // breaking after the first iter. + if contentStr == "" { + for langTagStr, contentStr = range contentMap { + break + } + } + } + + if langTagStr != "" { + // Found a lang tag for this content, + // make sure it's valid / parseable. + lang, err := language.Parse(langTagStr) + if err != nil { + log.Warnf( + ctx, + "could not parse %s as BCP47 language tag in status contentMap: %v", + langTagStr, err, + ) + } else { + // Inferred the language! + // Use normalized version. + langTagStr = lang.TagStr + } + } + + return contentStr, langTagStr +} diff --git a/internal/typeutils/util_test.go b/internal/typeutils/util_test.go index e6610574b..0f852d399 100644 --- a/internal/typeutils/util_test.go +++ b/internal/typeutils/util_test.go @@ -18,7 +18,12 @@ package typeutils import ( + "context" "testing" + + "github.com/superseriousbusiness/gotosocial/internal/config" + "github.com/superseriousbusiness/gotosocial/internal/gtsmodel" + "github.com/superseriousbusiness/gotosocial/internal/language" ) func TestMisskeyReportContentURLs1(t *testing.T) { @@ -44,3 +49,112 @@ misskey-formatted` t.Fatalf("wanted 0 urls, got %d", l) } } + +func TestContentToContentLanguage(t *testing.T) { + type testcase struct { + content gtsmodel.Content + instanceLanguages language.Languages + expectedContent string + expectedLang string + } + + ctx, cncl := context.WithCancel(context.Background()) + defer cncl() + + for i, testcase := range []testcase{ + { + content: gtsmodel.Content{ + Content: "hello world", + ContentMap: nil, + }, + expectedContent: "hello world", + expectedLang: "", + }, + { + content: gtsmodel.Content{ + Content: "", + ContentMap: map[string]string{ + "en": "hello world", + }, + }, + expectedContent: "hello world", + expectedLang: "en", + }, + { + content: gtsmodel.Content{ + Content: "bonjour le monde", + ContentMap: map[string]string{ + "en": "hello world", + "fr": "bonjour le monde", + }, + }, + expectedContent: "bonjour le monde", + expectedLang: "fr", + }, + { + content: gtsmodel.Content{ + Content: "bonjour le monde", + ContentMap: map[string]string{ + "en": "hello world", + }, + }, + expectedContent: "bonjour le monde", + expectedLang: "", + }, + { + content: gtsmodel.Content{ + Content: "", + ContentMap: map[string]string{ + "en": "hello world", + "ru": "Привет, мир!", + "nl": "hallo wereld!", + "ca": "Hola món!", + }, + }, + instanceLanguages: language.Languages{ + {TagStr: "en"}, + {TagStr: "ca"}, + }, + expectedContent: "hello world", + expectedLang: "en", + }, + { + content: gtsmodel.Content{ + Content: "", + ContentMap: map[string]string{ + "en": "hello world", + "ru": "Привет, мир!", + "nl": "hallo wereld!", + "ca": "Hola món!", + }, + }, + instanceLanguages: language.Languages{ + {TagStr: "ca"}, + {TagStr: "en"}, + }, + expectedContent: "Hola món!", + expectedLang: "ca", + }, + } { + langs, err := language.InitLangs(testcase.instanceLanguages.TagStrs()) + if err != nil { + t.Fatal(err) + } + config.SetInstanceLanguages(langs) + + content, language := ContentToContentLanguage(ctx, testcase.content) + if content != testcase.expectedContent { + t.Errorf( + "test %d expected content '%s' got '%s'", + i, testcase.expectedContent, content, + ) + } + + if language != testcase.expectedLang { + t.Errorf( + "test %d expected language '%s' got '%s'", + i, testcase.expectedLang, language, + ) + } + } +} diff --git a/internal/typeutils/wrap_test.go b/internal/typeutils/wrap_test.go index 9d6d95983..453073ed6 100644 --- a/internal/typeutils/wrap_test.go +++ b/internal/typeutils/wrap_test.go @@ -85,6 +85,9 @@ func (suite *WrapTestSuite) TestWrapNoteInCreate() { "attributedTo": "http://localhost:8080/users/the_mighty_zork", "cc": "http://localhost:8080/users/the_mighty_zork/followers", "content": "hello everyone!", + "contentMap": { + "en": "hello everyone!" + }, "id": "http://localhost:8080/users/the_mighty_zork/statuses/01F8MHAMCHF6Y650WCRSCP4WMY", "published": "2021-10-20T12:40:37+02:00", "replies": {