commit b6827681b5311b2c6a43c7135e3707c9b549408d · bretton.dev/coves

+322

tests/integration/community_e2e_test.go

···

       933
       933
        
       			t.Logf("   ✓ Subscriber count decremented")

     

       934
       934
        
       		})

     

       935
       935
        
       

     

       936
       936
       +
       		t.Run("Block via XRPC endpoint", func(t *testing.T) {

     

       937
       937
       +
       			// Create a community to block

     

       938
       938
       +
       			community := createAndIndexCommunity(t, communityService, consumer, instanceDID, pdsURL)

     

       939
       939
       +
       

     

       940
       940
       +
       			t.Logf("🚫 Blocking community via XRPC endpoint...")

     

       941
       941
       +
       			blockReq := map[string]interface{}{

     

       942
       942
       +
       				"community": community.DID,

     

       943
       943
       +
       			}

     

       944
       944
       +
       

     

       945
       945
       +
       			blockJSON, err := json.Marshal(blockReq)

     

       946
       946
       +
       			if err != nil {

     

       947
       947
       +
       				t.Fatalf("Failed to marshal block request: %v", err)

     

       948
       948
       +
       			}

     

       949
       949
       +
       

     

       950
       950
       +
       			req, err := http.NewRequest("POST", httpServer.URL+"/xrpc/social.coves.community.blockCommunity", bytes.NewBuffer(blockJSON))

     

       951
       951
       +
       			if err != nil {

     

       952
       952
       +
       				t.Fatalf("Failed to create block request: %v", err)

     

       953
       953
       +
       			}

     

       954
       954
       +
       			req.Header.Set("Content-Type", "application/json")

     

       955
       955
       +
       			req.Header.Set("Authorization", "Bearer "+accessToken)

     

       956
       956
       +
       

     

       957
       957
       +
       			resp, err := http.DefaultClient.Do(req)

     

       958
       958
       +
       			if err != nil {

     

       959
       959
       +
       				t.Fatalf("Failed to POST block: %v", err)

     

       960
       960
       +
       			}

     

       961
       961
       +
       			defer func() { _ = resp.Body.Close() }()

     

       962
       962
       +
       

     

       963
       963
       +
       			if resp.StatusCode != http.StatusOK {

     

       964
       964
       +
       				body, readErr := io.ReadAll(resp.Body)

     

       965
       965
       +
       				if readErr != nil {

     

       966
       966
       +
       					t.Fatalf("Expected 200, got %d (failed to read body: %v)", resp.StatusCode, readErr)

     

       967
       967
       +
       				}

     

       968
       968
       +
       				t.Logf("❌ XRPC Block Failed")

     

       969
       969
       +
       				t.Logf("   Status: %d", resp.StatusCode)

     

       970
       970
       +
       				t.Logf("   Response: %s", string(body))

     

       971
       971
       +
       				t.Fatalf("Expected 200, got %d: %s", resp.StatusCode, string(body))

     

       972
       972
       +
       			}

     

       973
       973
       +
       

     

       974
       974
       +
       			var blockResp struct {

     

       975
       975
       +
       				Block struct {

     

       976
       976
       +
       					RecordURI string `json:"recordUri"`

     

       977
       977
       +
       					RecordCID string `json:"recordCid"`

     

       978
       978
       +
       				} `json:"block"`

     

       979
       979
       +
       			}

     

       980
       980
       +
       

     

       981
       981
       +
       			if err := json.NewDecoder(resp.Body).Decode(&blockResp); err != nil {

     

       982
       982
       +
       				t.Fatalf("Failed to decode block response: %v", err)

     

       983
       983
       +
       			}

     

       984
       984
       +
       

     

       985
       985
       +
       			t.Logf("✅ XRPC block response received:")

     

       986
       986
       +
       			t.Logf("   RecordURI: %s", blockResp.Block.RecordURI)

     

       987
       987
       +
       			t.Logf("   RecordCID: %s", blockResp.Block.RecordCID)

     

       988
       988
       +
       

     

       989
       989
       +
       			// Extract rkey from URI for verification

     

       990
       990
       +
       			rkey := ""

     

       991
       991
       +
       			if uriParts := strings.Split(blockResp.Block.RecordURI, "/"); len(uriParts) >= 4 {

     

       992
       992
       +
       				rkey = uriParts[len(uriParts)-1]

     

       993
       993
       +
       			}

     

       994
       994
       +
       

     

       995
       995
       +
       			// Verify the block record exists on PDS

     

       996
       996
       +
       			t.Logf("🔍 Verifying block record exists on PDS...")

     

       997
       997
       +
       			collection := "social.coves.community.block"

     

       998
       998
       +
       			pdsResp, pdsErr := http.Get(fmt.Sprintf("%s/xrpc/com.atproto.repo.getRecord?repo=%s&collection=%s&rkey=%s",

     

       999
       999
       +
       				pdsURL, instanceDID, collection, rkey))

     

       1000
       1000
       +
       			if pdsErr != nil {

     

       1001
       1001
       +
       				t.Fatalf("Failed to query PDS: %v", pdsErr)

     

       1002
       1002
       +
       			}

     

       1003
       1003
       +
       			defer func() {

     

       1004
       1004
       +
       				if closeErr := pdsResp.Body.Close(); closeErr != nil {

     

       1005
       1005
       +
       					t.Logf("Failed to close PDS response: %v", closeErr)

     

       1006
       1006
       +
       				}

     

       1007
       1007
       +
       			}()

     

       1008
       1008
       +
       

     

       1009
       1009
       +
       			if pdsResp.StatusCode != http.StatusOK {

     

       1010
       1010
       +
       				body, readErr := io.ReadAll(pdsResp.Body)

     

       1011
       1011
       +
       				if readErr != nil {

     

       1012
       1012
       +
       					t.Fatalf("Block record not found on PDS (status: %d, failed to read body: %v)", pdsResp.StatusCode, readErr)

     

       1013
       1013
       +
       				}

     

       1014
       1014
       +
       				t.Fatalf("Block record not found on PDS (status: %d): %s", pdsResp.StatusCode, string(body))

     

       1015
       1015
       +
       			}

     

       1016
       1016
       +
       			t.Logf("✅ Block record exists on PDS")

     

       1017
       1017
       +
       

     

       1018
       1018
       +
       			// CRITICAL: Simulate Jetstream consumer indexing the block

     

       1019
       1019
       +
       			t.Logf("🔄 Simulating Jetstream consumer indexing block event...")

     

       1020
       1020
       +
       			blockEvent := jetstream.JetstreamEvent{

     

       1021
       1021
       +
       				Did:    instanceDID,

     

       1022
       1022
       +
       				TimeUS: time.Now().UnixMicro(),

     

       1023
       1023
       +
       				Kind:   "commit",

     

       1024
       1024
       +
       				Commit: &jetstream.CommitEvent{

     

       1025
       1025
       +
       					Rev:        "test-block-rev",

     

       1026
       1026
       +
       					Operation:  "create",

     

       1027
       1027
       +
       					Collection: "social.coves.community.block",

     

       1028
       1028
       +
       					RKey:       rkey,

     

       1029
       1029
       +
       					CID:        blockResp.Block.RecordCID,

     

       1030
       1030
       +
       					Record: map[string]interface{}{

     

       1031
       1031
       +
       						"subject":   community.DID,

     

       1032
       1032
       +
       						"createdAt": time.Now().Format(time.RFC3339),

     

       1033
       1033
       +
       					},

     

       1034
       1034
       +
       				},

     

       1035
       1035
       +
       			}

     

       1036
       1036
       +
       			if handleErr := consumer.HandleEvent(context.Background(), &blockEvent); handleErr != nil {

     

       1037
       1037
       +
       				t.Fatalf("Failed to handle block event: %v", handleErr)

     

       1038
       1038
       +
       			}

     

       1039
       1039
       +
       

     

       1040
       1040
       +
       			// Verify block was indexed in AppView

     

       1041
       1041
       +
       			t.Logf("🔍 Verifying block indexed in AppView...")

     

       1042
       1042
       +
       			block, err := communityRepo.GetBlock(ctx, instanceDID, community.DID)

     

       1043
       1043
       +
       			if err != nil {

     

       1044
       1044
       +
       				t.Fatalf("Failed to get block from AppView: %v", err)

     

       1045
       1045
       +
       			}

     

       1046
       1046
       +
       			if block.RecordURI != blockResp.Block.RecordURI {

     

       1047
       1047
       +
       				t.Errorf("RecordURI mismatch: expected %s, got %s", blockResp.Block.RecordURI, block.RecordURI)

     

       1048
       1048
       +
       			}

     

       1049
       1049
       +
       

     

       1050
       1050
       +
       			t.Logf("✅ TRUE E2E BLOCK FLOW COMPLETE:")

     

       1051
       1051
       +
       			t.Logf("   Client → XRPC Block → PDS Create → Firehose → Consumer → AppView ✓")

     

       1052
       1052
       +
       			t.Logf("   ✓ Block record created on PDS")

     

       1053
       1053
       +
       			t.Logf("   ✓ Block indexed in AppView")

     

       1054
       1054
       +
       		})

     

       1055
       1055
       +
       

     

       1056
       1056
       +
       		t.Run("Unblock via XRPC endpoint", func(t *testing.T) {

     

       1057
       1057
       +
       			// Create a community and block it first

     

       1058
       1058
       +
       			community := createAndIndexCommunity(t, communityService, consumer, instanceDID, pdsURL)

     

       1059
       1059
       +
       

     

       1060
       1060
       +
       			// Block the community

     

       1061
       1061
       +
       			t.Logf("🚫 Blocking community first...")

     

       1062
       1062
       +
       			blockReq := map[string]interface{}{

     

       1063
       1063
       +
       				"community": community.DID,

     

       1064
       1064
       +
       			}

     

       1065
       1065
       +
       			blockJSON, err := json.Marshal(blockReq)

     

       1066
       1066
       +
       			if err != nil {

     

       1067
       1067
       +
       				t.Fatalf("Failed to marshal block request: %v", err)

     

       1068
       1068
       +
       			}

     

       1069
       1069
       +
       

     

       1070
       1070
       +
       			blockHttpReq, err := http.NewRequest("POST", httpServer.URL+"/xrpc/social.coves.community.blockCommunity", bytes.NewBuffer(blockJSON))

     

       1071
       1071
       +
       			if err != nil {

     

       1072
       1072
       +
       				t.Fatalf("Failed to create block request: %v", err)

     

       1073
       1073
       +
       			}

     

       1074
       1074
       +
       			blockHttpReq.Header.Set("Content-Type", "application/json")

     

       1075
       1075
       +
       			blockHttpReq.Header.Set("Authorization", "Bearer "+accessToken)

     

       1076
       1076
       +
       

     

       1077
       1077
       +
       			blockResp, err := http.DefaultClient.Do(blockHttpReq)

     

       1078
       1078
       +
       			if err != nil {

     

       1079
       1079
       +
       				t.Fatalf("Failed to POST block: %v", err)

     

       1080
       1080
       +
       			}

     

       1081
       1081
       +
       

     

       1082
       1082
       +
       			var blockRespData struct {

     

       1083
       1083
       +
       				Block struct {

     

       1084
       1084
       +
       					RecordURI string `json:"recordUri"`

     

       1085
       1085
       +
       				} `json:"block"`

     

       1086
       1086
       +
       			}

     

       1087
       1087
       +
       			if err := json.NewDecoder(blockResp.Body).Decode(&blockRespData); err != nil {

     

       1088
       1088
       +
       				func() { _ = blockResp.Body.Close() }()

     

       1089
       1089
       +
       				t.Fatalf("Failed to decode block response: %v", err)

     

       1090
       1090
       +
       			}

     

       1091
       1091
       +
       			func() { _ = blockResp.Body.Close() }()

     

       1092
       1092
       +
       

     

       1093
       1093
       +
       			rkey := ""

     

       1094
       1094
       +
       			if uriParts := strings.Split(blockRespData.Block.RecordURI, "/"); len(uriParts) >= 4 {

     

       1095
       1095
       +
       				rkey = uriParts[len(uriParts)-1]

     

       1096
       1096
       +
       			}

     

       1097
       1097
       +
       

     

       1098
       1098
       +
       			// Index the block via consumer

     

       1099
       1099
       +
       			blockEvent := jetstream.JetstreamEvent{

     

       1100
       1100
       +
       				Did:    instanceDID,

     

       1101
       1101
       +
       				TimeUS: time.Now().UnixMicro(),

     

       1102
       1102
       +
       				Kind:   "commit",

     

       1103
       1103
       +
       				Commit: &jetstream.CommitEvent{

     

       1104
       1104
       +
       					Rev:        "test-block-rev",

     

       1105
       1105
       +
       					Operation:  "create",

     

       1106
       1106
       +
       					Collection: "social.coves.community.block",

     

       1107
       1107
       +
       					RKey:       rkey,

     

       1108
       1108
       +
       					CID:        "test-block-cid",

     

       1109
       1109
       +
       					Record: map[string]interface{}{

     

       1110
       1110
       +
       						"subject":   community.DID,

     

       1111
       1111
       +
       						"createdAt": time.Now().Format(time.RFC3339),

     

       1112
       1112
       +
       					},

     

       1113
       1113
       +
       				},

     

       1114
       1114
       +
       			}

     

       1115
       1115
       +
       			if handleErr := consumer.HandleEvent(context.Background(), &blockEvent); handleErr != nil {

     

       1116
       1116
       +
       				t.Fatalf("Failed to handle block event: %v", handleErr)

     

       1117
       1117
       +
       			}

     

       1118
       1118
       +
       

     

       1119
       1119
       +
       			// Now unblock the community

     

       1120
       1120
       +
       			t.Logf("✅ Unblocking community via XRPC endpoint...")

     

       1121
       1121
       +
       			unblockReq := map[string]interface{}{

     

       1122
       1122
       +
       				"community": community.DID,

     

       1123
       1123
       +
       			}

     

       1124
       1124
       +
       

     

       1125
       1125
       +
       			unblockJSON, err := json.Marshal(unblockReq)

     

       1126
       1126
       +
       			if err != nil {

     

       1127
       1127
       +
       				t.Fatalf("Failed to marshal unblock request: %v", err)

     

       1128
       1128
       +
       			}

     

       1129
       1129
       +
       

     

       1130
       1130
       +
       			req, err := http.NewRequest("POST", httpServer.URL+"/xrpc/social.coves.community.unblockCommunity", bytes.NewBuffer(unblockJSON))

     

       1131
       1131
       +
       			if err != nil {

     

       1132
       1132
       +
       				t.Fatalf("Failed to create unblock request: %v", err)

     

       1133
       1133
       +
       			}

     

       1134
       1134
       +
       			req.Header.Set("Content-Type", "application/json")

     

       1135
       1135
       +
       			req.Header.Set("Authorization", "Bearer "+accessToken)

     

       1136
       1136
       +
       

     

       1137
       1137
       +
       			resp, err := http.DefaultClient.Do(req)

     

       1138
       1138
       +
       			if err != nil {

     

       1139
       1139
       +
       				t.Fatalf("Failed to POST unblock: %v", err)

     

       1140
       1140
       +
       			}

     

       1141
       1141
       +
       			defer func() { _ = resp.Body.Close() }()

     

       1142
       1142
       +
       

     

       1143
       1143
       +
       			if resp.StatusCode != http.StatusOK {

     

       1144
       1144
       +
       				body, readErr := io.ReadAll(resp.Body)

     

       1145
       1145
       +
       				if readErr != nil {

     

       1146
       1146
       +
       					t.Fatalf("Expected 200, got %d (failed to read body: %v)", resp.StatusCode, readErr)

     

       1147
       1147
       +
       				}

     

       1148
       1148
       +
       				t.Logf("❌ XRPC Unblock Failed")

     

       1149
       1149
       +
       				t.Logf("   Status: %d", resp.StatusCode)

     

       1150
       1150
       +
       				t.Logf("   Response: %s", string(body))

     

       1151
       1151
       +
       				t.Fatalf("Expected 200, got %d: %s", resp.StatusCode, string(body))

     

       1152
       1152
       +
       			}

     

       1153
       1153
       +
       

     

       1154
       1154
       +
       			var unblockResp struct {

     

       1155
       1155
       +
       				Success bool `json:"success"`

     

       1156
       1156
       +
       			}

     

       1157
       1157
       +
       

     

       1158
       1158
       +
       			if err := json.NewDecoder(resp.Body).Decode(&unblockResp); err != nil {

     

       1159
       1159
       +
       				t.Fatalf("Failed to decode unblock response: %v", err)

     

       1160
       1160
       +
       			}

     

       1161
       1161
       +
       

     

       1162
       1162
       +
       			if !unblockResp.Success {

     

       1163
       1163
       +
       				t.Errorf("Expected success: true, got: %v", unblockResp.Success)

     

       1164
       1164
       +
       			}

     

       1165
       1165
       +
       

     

       1166
       1166
       +
       			// Verify the block record was deleted from PDS

     

       1167
       1167
       +
       			t.Logf("🔍 Verifying block record deleted from PDS...")

     

       1168
       1168
       +
       			collection := "social.coves.community.block"

     

       1169
       1169
       +
       			pdsResp, pdsErr := http.Get(fmt.Sprintf("%s/xrpc/com.atproto.repo.getRecord?repo=%s&collection=%s&rkey=%s",

     

       1170
       1170
       +
       				pdsURL, instanceDID, collection, rkey))

     

       1171
       1171
       +
       			if pdsErr != nil {

     

       1172
       1172
       +
       				t.Fatalf("Failed to query PDS: %v", pdsErr)

     

       1173
       1173
       +
       			}

     

       1174
       1174
       +
       			defer func() {

     

       1175
       1175
       +
       				if closeErr := pdsResp.Body.Close(); closeErr != nil {

     

       1176
       1176
       +
       					t.Logf("Failed to close PDS response: %v", closeErr)

     

       1177
       1177
       +
       				}

     

       1178
       1178
       +
       			}()

     

       1179
       1179
       +
       

     

       1180
       1180
       +
       			if pdsResp.StatusCode == http.StatusOK {

     

       1181
       1181
       +
       				t.Errorf("❌ Block record still exists on PDS (expected 404, got 200)")

     

       1182
       1182
       +
       			} else {

     

       1183
       1183
       +
       				t.Logf("✅ Block record successfully deleted from PDS (status: %d)", pdsResp.StatusCode)

     

       1184
       1184
       +
       			}

     

       1185
       1185
       +
       

     

       1186
       1186
       +
       			// CRITICAL: Simulate Jetstream consumer indexing the DELETE event

     

       1187
       1187
       +
       			t.Logf("🔄 Simulating Jetstream consumer indexing DELETE event...")

     

       1188
       1188
       +
       			deleteEvent := jetstream.JetstreamEvent{

     

       1189
       1189
       +
       				Did:    instanceDID,

     

       1190
       1190
       +
       				TimeUS: time.Now().UnixMicro(),

     

       1191
       1191
       +
       				Kind:   "commit",

     

       1192
       1192
       +
       				Commit: &jetstream.CommitEvent{

     

       1193
       1193
       +
       					Rev:        "test-unblock-rev",

     

       1194
       1194
       +
       					Operation:  "delete",

     

       1195
       1195
       +
       					Collection: "social.coves.community.block",

     

       1196
       1196
       +
       					RKey:       rkey,

     

       1197
       1197
       +
       					CID:        "",

     

       1198
       1198
       +
       					Record:     nil,

     

       1199
       1199
       +
       				},

     

       1200
       1200
       +
       			}

     

       1201
       1201
       +
       			if handleErr := consumer.HandleEvent(context.Background(), &deleteEvent); handleErr != nil {

     

       1202
       1202
       +
       				t.Fatalf("Failed to handle delete event: %v", handleErr)

     

       1203
       1203
       +
       			}

     

       1204
       1204
       +
       

     

       1205
       1205
       +
       			// Verify block was removed from AppView

     

       1206
       1206
       +
       			t.Logf("🔍 Verifying block removed from AppView...")

     

       1207
       1207
       +
       			_, err = communityRepo.GetBlock(ctx, instanceDID, community.DID)

     

       1208
       1208
       +
       			if err == nil {

     

       1209
       1209
       +
       				t.Errorf("❌ Block still exists in AppView (should be deleted)")

     

       1210
       1210
       +
       			} else if !communities.IsNotFound(err) {

     

       1211
       1211
       +
       				t.Fatalf("Unexpected error querying block: %v", err)

     

       1212
       1212
       +
       			} else {

     

       1213
       1213
       +
       				t.Logf("✅ Block removed from AppView")

     

       1214
       1214
       +
       			}

     

       1215
       1215
       +
       

     

       1216
       1216
       +
       			t.Logf("✅ TRUE E2E UNBLOCK FLOW COMPLETE:")

     

       1217
       1217
       +
       			t.Logf("   Client → XRPC Unblock → PDS Delete → Firehose → Consumer → AppView ✓")

     

       1218
       1218
       +
       			t.Logf("   ✓ Block deleted from PDS")

     

       1219
       1219
       +
       			t.Logf("   ✓ Block removed from AppView")

     

       1220
       1220
       +
       		})

     

       1221
       1221
       +
       

     

       1222
       1222
       +
       		t.Run("Block fails without authentication", func(t *testing.T) {

     

       1223
       1223
       +
       			// Create a community to attempt blocking

     

       1224
       1224
       +
       			community := createAndIndexCommunity(t, communityService, consumer, instanceDID, pdsURL)

     

       1225
       1225
       +
       

     

       1226
       1226
       +
       			t.Logf("🔒 Attempting to block community without auth token...")

     

       1227
       1227
       +
       			blockReq := map[string]interface{}{

     

       1228
       1228
       +
       				"community": community.DID,

     

       1229
       1229
       +
       			}

     

       1230
       1230
       +
       

     

       1231
       1231
       +
       			blockJSON, err := json.Marshal(blockReq)

     

       1232
       1232
       +
       			if err != nil {

     

       1233
       1233
       +
       				t.Fatalf("Failed to marshal block request: %v", err)

     

       1234
       1234
       +
       			}

     

       1235
       1235
       +
       

     

       1236
       1236
       +
       			req, err := http.NewRequest("POST", httpServer.URL+"/xrpc/social.coves.community.blockCommunity", bytes.NewBuffer(blockJSON))

     

       1237
       1237
       +
       			if err != nil {

     

       1238
       1238
       +
       				t.Fatalf("Failed to create block request: %v", err)

     

       1239
       1239
       +
       			}

     

       1240
       1240
       +
       			req.Header.Set("Content-Type", "application/json")

     

       1241
       1241
       +
       			// NO Authorization header

     

       1242
       1242
       +
       

     

       1243
       1243
       +
       			resp, err := http.DefaultClient.Do(req)

     

       1244
       1244
       +
       			if err != nil {

     

       1245
       1245
       +
       				t.Fatalf("Failed to POST block: %v", err)

     

       1246
       1246
       +
       			}

     

       1247
       1247
       +
       			defer func() { _ = resp.Body.Close() }()

     

       1248
       1248
       +
       

     

       1249
       1249
       +
       			// Should fail with 401 Unauthorized

     

       1250
       1250
       +
       			if resp.StatusCode != http.StatusUnauthorized {

     

       1251
       1251
       +
       				body, _ := io.ReadAll(resp.Body)

     

       1252
       1252
       +
       				t.Errorf("Expected 401 Unauthorized, got %d: %s", resp.StatusCode, string(body))

     

       1253
       1253
       +
       			} else {

     

       1254
       1254
       +
       				t.Logf("✅ Block correctly rejected without authentication (401)")

     

       1255
       1255
       +
       			}

     

       1256
       1256
       +
       		})

     

       1257
       1257
       +
       

     

       936
       1258
        
       		t.Run("Update via XRPC endpoint", func(t *testing.T) {

     

       937
       1259
        
       			// Create a community first (via service, so it's indexed)

     

       938
       1260
        
       			community := createAndIndexCommunity(t, communityService, consumer, instanceDID, pdsURL)

+24

tests/unit/community_service_test.go

···

       102
       102
        
       	return nil, nil

     

       103
       103
        
       }

     

       104
       104
        
       

     

       105
       105
       +
       func (m *mockCommunityRepo) BlockCommunity(ctx context.Context, block *communities.CommunityBlock) (*communities.CommunityBlock, error) {

     

       106
       106
       +
       	return block, nil

     

       107
       107
       +
       }

     

       108
       108
       +
       

     

       109
       109
       +
       func (m *mockCommunityRepo) UnblockCommunity(ctx context.Context, userDID, communityDID string) error {

     

       110
       110
       +
       	return nil

     

       111
       111
       +
       }

     

       112
       112
       +
       

     

       113
       113
       +
       func (m *mockCommunityRepo) GetBlock(ctx context.Context, userDID, communityDID string) (*communities.CommunityBlock, error) {

     

       114
       114
       +
       	return nil, communities.ErrBlockNotFound

     

       115
       115
       +
       }

     

       116
       116
       +
       

     

       117
       117
       +
       func (m *mockCommunityRepo) GetBlockByURI(ctx context.Context, recordURI string) (*communities.CommunityBlock, error) {

     

       118
       118
       +
       	return nil, communities.ErrBlockNotFound

     

       119
       119
       +
       }

     

       120
       120
       +
       

     

       121
       121
       +
       func (m *mockCommunityRepo) ListBlockedCommunities(ctx context.Context, userDID string, limit, offset int) ([]*communities.CommunityBlock, error) {

     

       122
       122
       +
       	return nil, nil

     

       123
       123
       +
       }

     

       124
       124
       +
       

     

       125
       125
       +
       func (m *mockCommunityRepo) IsBlocked(ctx context.Context, userDID, communityDID string) (bool, error) {

     

       126
       126
       +
       	return false, nil

     

       127
       127
       +
       }

     

       128
       128
       +
       

     

       105
       129
        
       func (m *mockCommunityRepo) CreateMembership(ctx context.Context, membership *communities.Membership) (*communities.Membership, error) {

     

       106
       130
        
       	return membership, nil

     

       107
       131
        
       }