Skip to:
Content

BuddyPress.org


Ignore:
Timestamp:
05/15/2016 02:21:54 AM (9 years ago)
Author:
boonebgorges
Message:

Introduce Group Types API.

Modeled on the Member Types API, Group Types allow developers to register
arbitrary group categorizations, and assign one or more of these types to a
given group. BuddyPress stores this information in a custom taxonomy on the
root blog.

Group queries can be filtered by group type, by using the group_type,
group_type__in, and group_type__not_in parameters in the bp_has_groups()
template loop function stack.

Props Mamaduka, boonebgorges, dcavins.
See #6784.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/tests/phpunit/testcases/groups/class-bp-groups-group.php

    r10488 r10766  
    10301030        $this->set_current_user( $old_user );
    10311031    }
     1032
     1033    /**
     1034     * @group group_types
     1035     */
     1036    public function test_group_type_single_value() {
     1037        $g1 = $this->factory->group->create();
     1038        $g2 = $this->factory->group->create();
     1039        bp_groups_register_group_type( 'foo' );
     1040        bp_groups_register_group_type( 'bar' );
     1041        bp_groups_set_group_type( $g1, 'foo' );
     1042        bp_groups_set_group_type( $g2, 'bar' );
     1043
     1044        $groups = BP_Groups_Group::get( array(
     1045            'group_type' => 'foo',
     1046        ) );
     1047
     1048        $found = wp_list_pluck( $groups['groups'], 'id' );
     1049        $this->assertEquals( array( $g1 ), $found );
     1050    }
     1051
     1052    /**
     1053     * @group group_types
     1054     */
     1055    public function test_group_type_array_with_single_value() {
     1056        $g1 = $this->factory->group->create();
     1057        $g2 = $this->factory->group->create();
     1058        bp_groups_register_group_type( 'foo' );
     1059        bp_groups_register_group_type( 'bar' );
     1060        bp_groups_set_group_type( $g1, 'foo' );
     1061        bp_groups_set_group_type( $g2, 'bar' );
     1062
     1063        $groups = BP_Groups_Group::get( array(
     1064            'group_type' => array( 'foo' ),
     1065        ) );
     1066
     1067        $found = wp_list_pluck( $groups['groups'], 'id' );
     1068        $this->assertEquals( array( $g1 ), $found );
     1069    }
     1070
     1071    /**
     1072     * @group group_types
     1073     */
     1074    public function test_group_type_with_comma_separated_list() {
     1075        $g1 = $this->factory->group->create();
     1076        $g2 = $this->factory->group->create();
     1077        bp_groups_register_group_type( 'foo' );
     1078        bp_groups_register_group_type( 'bar' );
     1079        bp_groups_set_group_type( $g1, 'foo' );
     1080        bp_groups_set_group_type( $g2, 'bar' );
     1081
     1082        $groups = BP_Groups_Group::get( array(
     1083            'group_type' => 'foo, bar',
     1084        ) );
     1085
     1086        $found = wp_list_pluck( $groups['groups'], 'id' );
     1087        $this->assertEqualSets( array( $g1, $g2 ), $found );
     1088    }
     1089
     1090    /**
     1091     * @group group_types
     1092     */
     1093    public function test_group_type_array_with_multiple_values() {
     1094        $g1 = $this->factory->group->create();
     1095        $g2 = $this->factory->group->create();
     1096        bp_groups_register_group_type( 'foo' );
     1097        bp_groups_register_group_type( 'bar' );
     1098        bp_groups_set_group_type( $g1, 'foo' );
     1099        bp_groups_set_group_type( $g2, 'bar' );
     1100
     1101        $groups = BP_Groups_Group::get( array(
     1102            'group_type' => array( 'foo', 'bar' ),
     1103        ) );
     1104
     1105        $found = wp_list_pluck( $groups['groups'], 'id' );
     1106        $this->assertEqualSets( array( $g1, $g2 ), $found );
     1107    }
     1108
     1109    /**
     1110     * @group group_types
     1111     */
     1112    public function test_group_type_should_discart_non_existing_types_in_comma_separated_value() {
     1113        $g1 = $this->factory->group->create();
     1114        $g2 = $this->factory->group->create();
     1115        bp_groups_register_group_type( 'foo' );
     1116        bp_groups_register_group_type( 'bar' );
     1117        bp_groups_set_group_type( $g1, 'foo' );
     1118        bp_groups_set_group_type( $g2, 'bar' );
     1119
     1120        $groups = BP_Groups_Group::get( array(
     1121            'group_type' => 'foo, baz',
     1122        ) );
     1123
     1124        $found = wp_list_pluck( $groups['groups'], 'id' );
     1125        $this->assertEquals( array( $g1 ), $found );
     1126    }
     1127
     1128    /**
     1129     * @group group_types
     1130     */
     1131    public function test_group_type_should_return_empty_when_no_groups_match_specified_types() {
     1132        $g1 = $this->factory->group->create();
     1133        $g2 = $this->factory->group->create();
     1134
     1135        $groups = BP_Groups_Group::get( array(
     1136            'group_type' => 'foo, baz',
     1137        ) );
     1138
     1139        $this->assertEmpty( $groups['groups'] );
     1140    }
     1141
     1142    /**
     1143     * @group group_types
     1144     */
     1145    public function test_group_type__in_single_value() {
     1146        $g1 = $this->factory->group->create();
     1147        $g2 = $this->factory->group->create();
     1148        bp_groups_register_group_type( 'foo' );
     1149        bp_groups_register_group_type( 'bar' );
     1150        bp_groups_set_group_type( $g1, 'foo' );
     1151        bp_groups_set_group_type( $g2, 'bar' );
     1152
     1153        $groups = BP_Groups_Group::get( array(
     1154            'group_type__in' => 'bar',
     1155        ) );
     1156
     1157        $found = wp_list_pluck( $groups['groups'], 'id' );
     1158        $this->assertEquals( array( $g2 ), $found );
     1159    }
     1160
     1161    /**
     1162     * @group group_types
     1163     */
     1164    public function test_group_type__in_comma_separated_values() {
     1165        $g1 = $this->factory->group->create();
     1166        $g2 = $this->factory->group->create();
     1167        bp_groups_register_group_type( 'foo' );
     1168        bp_groups_register_group_type( 'bar' );
     1169        bp_groups_set_group_type( $g1, 'foo' );
     1170        bp_groups_set_group_type( $g2, 'bar' );
     1171
     1172        $groups = BP_Groups_Group::get( array(
     1173            'group_type__in' => 'foo, bar',
     1174        ) );
     1175
     1176        $found = wp_list_pluck( $groups['groups'], 'id' );
     1177        $this->assertEqualSets( array( $g1, $g2 ), $found );
     1178    }
     1179
     1180    /**
     1181     * @group group_types
     1182     */
     1183    public function test_group_type__in_array_multiple_values() {
     1184        $g1 = $this->factory->group->create();
     1185        $g2 = $this->factory->group->create();
     1186        bp_groups_register_group_type( 'foo' );
     1187        bp_groups_register_group_type( 'bar' );
     1188        bp_groups_set_group_type( $g1, 'foo' );
     1189        bp_groups_set_group_type( $g2, 'bar' );
     1190
     1191        $groups = BP_Groups_Group::get( array(
     1192            'group_type__in' => array( 'foo', 'bar' ),
     1193        ) );
     1194
     1195        $found = wp_list_pluck( $groups['groups'], 'id' );
     1196        $this->assertEqualSets( array( $g1, $g2 ), $found );
     1197    }
     1198
     1199    /**
     1200     * @group group_types
     1201     */
     1202    public function test_group_type__in_array_with_single_value() {
     1203        $g1 = $this->factory->group->create();
     1204        $g2 = $this->factory->group->create();
     1205        bp_groups_register_group_type( 'foo' );
     1206        bp_groups_register_group_type( 'bar' );
     1207        bp_groups_set_group_type( $g1, 'foo' );
     1208        bp_groups_set_group_type( $g2, 'bar' );
     1209
     1210        $groups = BP_Groups_Group::get( array(
     1211            'group_type__in' => array( 'foo' ),
     1212        ) );
     1213
     1214        $found = wp_list_pluck( $groups['groups'], 'id' );
     1215        $this->assertEquals( array( $g1 ), $found );
     1216    }
     1217
     1218    /**
     1219     * @group group_types
     1220     */
     1221    public function test_group_type__in_should_discart_non_existing_types_in_comma_separated_value() {
     1222        $g1 = $this->factory->group->create();
     1223        $g2 = $this->factory->group->create();
     1224        bp_groups_register_group_type( 'foo' );
     1225        bp_groups_register_group_type( 'bar' );
     1226        bp_groups_set_group_type( $g1, 'foo' );
     1227        bp_groups_set_group_type( $g2, 'bar' );
     1228
     1229        $groups = BP_Groups_Group::get( array(
     1230            'group_type__in' => 'foo, baz',
     1231        ) );
     1232
     1233        $found = wp_list_pluck( $groups['groups'], 'id' );
     1234        $this->assertEquals( array( $g1 ), $found );
     1235    }
     1236
     1237    /**
     1238     * @group group_types
     1239     */
     1240    public function test_group_type__in_should_return_empty_when_no_groups_match_specified_types() {
     1241        $g1 = $this->factory->group->create();
     1242        $g2 = $this->factory->group->create();
     1243
     1244        $groups = BP_Groups_Group::get( array(
     1245            'group_type__in' => 'foo, baz',
     1246        ) );
     1247
     1248        $this->assertEmpty( $groups['groups'] );
     1249    }
     1250
     1251    /**
     1252     * @group group_types
     1253     */
     1254    public function test_group_type_should_take_precedence_over_group_type__in() {
     1255        $g1 = $this->factory->group->create();
     1256        $g2 = $this->factory->group->create();
     1257        bp_groups_register_group_type( 'foo' );
     1258        bp_groups_register_group_type( 'bar' );
     1259        bp_groups_set_group_type( $g1, 'foo' );
     1260        bp_groups_set_group_type( $g2, 'bar' );
     1261
     1262        $groups = BP_Groups_Group::get( array(
     1263            'group_type__in' => 'foo',
     1264            'group_type' => 'bar',
     1265        ) );
     1266
     1267        $found = wp_list_pluck( $groups['groups'], 'id' );
     1268        $this->assertEquals( array( $g2 ), $found );
     1269    }
     1270
     1271    /**
     1272     * @group group_types
     1273     */
     1274    public function test_group_type__not_in_should_return_groups_with_types_and_without_types() {
     1275        $g1 = $this->factory->group->create();
     1276        $g2 = $this->factory->group->create();
     1277        $g3 = $this->factory->group->create();
     1278        bp_groups_register_group_type( 'foo' );
     1279        bp_groups_register_group_type( 'bar' );
     1280        bp_groups_set_group_type( $g1, 'foo' );
     1281        bp_groups_set_group_type( $g2, 'bar' );
     1282
     1283        $groups = BP_Groups_Group::get( array(
     1284            'group_type__not_in' => 'foo',
     1285        ) );
     1286
     1287        $found = wp_list_pluck( $groups['groups'], 'id' );
     1288        $this->assertEquals( array( $g2, $g3 ), $found );
     1289    }
     1290
     1291    /**
     1292     * @group group_types
     1293     */
     1294    public function test_group_type__not_in_comma_separated_values() {
     1295        $g1 = $this->factory->group->create();
     1296        $g2 = $this->factory->group->create();
     1297        $g3 = $this->factory->group->create();
     1298        bp_groups_register_group_type( 'foo' );
     1299        bp_groups_register_group_type( 'bar' );
     1300        bp_groups_set_group_type( $g1, 'foo' );
     1301        bp_groups_set_group_type( $g2, 'bar' );
     1302        bp_groups_set_group_type( $g3, 'baz' );
     1303
     1304        $groups = BP_Groups_Group::get( array(
     1305            'group_type__not_in' => 'foo, bar',
     1306        ) );
     1307
     1308        $found = wp_list_pluck( $groups['groups'], 'id' );
     1309        $this->assertEquals( array( $g3 ), $found );
     1310    }
     1311
     1312    /**
     1313     * @group group_types
     1314     */
     1315    public function test_group_type__not_array_with_multiple_values() {
     1316        $g1 = $this->factory->group->create();
     1317        $g2 = $this->factory->group->create();
     1318        $g3 = $this->factory->group->create();
     1319        bp_groups_register_group_type( 'foo' );
     1320        bp_groups_register_group_type( 'bar' );
     1321        bp_groups_set_group_type( $g1, 'foo' );
     1322        bp_groups_set_group_type( $g2, 'bar' );
     1323        bp_groups_set_group_type( $g3, 'baz' );
     1324
     1325        $groups = BP_Groups_Group::get( array(
     1326            'group_type__not_in' => array( 'foo', 'bar' ),
     1327        ) );
     1328
     1329        $found = wp_list_pluck( $groups['groups'], 'id' );
     1330        $this->assertEquals( array( $g3 ), $found );
     1331    }
     1332
     1333    /**
     1334     * @group group_types
     1335     */
     1336    public function test_group_type__not_in_should_return_no_results_when_all_groups_mathc_sepecified_type() {
     1337        $g1 = $this->factory->group->create();
     1338        $g2 = $this->factory->group->create();
     1339        $g3 = $this->factory->group->create();
     1340        bp_groups_register_group_type( 'foo' );
     1341        bp_groups_set_group_type( $g1, 'foo' );
     1342        bp_groups_set_group_type( $g2, 'foo' );
     1343        bp_groups_set_group_type( $g3, 'foo' );
     1344
     1345        $groups = BP_Groups_Group::get( array(
     1346            'group_type__not_in' => 'foo',
     1347        ) );
     1348
     1349        $this->assertEmpty( $groups['groups'] );
     1350    }
     1351
     1352    /**
     1353     * @group group_types
     1354     */
     1355    public function test_group_type__not_in_takes_precedence_over_group_type() {
     1356        $g1 = $this->factory->group->create();
     1357        $g2 = $this->factory->group->create();
     1358        $g3 = $this->factory->group->create();
     1359        bp_groups_register_group_type( 'foo' );
     1360        bp_groups_set_group_type( $g1, 'foo' );
     1361        bp_groups_set_group_type( $g2, 'foo' );
     1362        bp_groups_set_group_type( $g3, 'foo' );
     1363
     1364        $groups = BP_Groups_Group::get( array(
     1365            'group_type' => 'foo',
     1366            'group_type__not_in' => 'foo',
     1367        ) );
     1368
     1369        $this->assertEmpty( $groups['groups'] );
     1370    }
    10321371}
    10331372
Note: See TracChangeset for help on using the changeset viewer.