content: more tests

runtime-modules/content/src/tests/channels.rs

@@ -308,5 +308,15 @@ fn curators_can_censor_channels() {
         let channel = Content::channel_by_id(channel_id);
 
         assert!(!channel.is_censored);
+
+        // Member cannot censor channels
+        assert_err!(Content::censor_channel(
+            Origin::signed(FIRST_MEMBER_ORIGIN),
+            ContentActor::Curator(FIRST_MEMBER_ID),
+            channel_id,
+            vec![]
+        ),
+            Error::<Test>::ActorNotAuthorized
+        );
     })
 }

runtime-modules/content/src/tests/videos.rs

@@ -5,7 +5,7 @@ use super::mock::*;
 use crate::*;
 use frame_support::{assert_err, assert_ok};
 
-fn create_channel() -> ChannelId {
+fn create_member_channel() -> ChannelId {
     let channel_id = Content::next_channel_id();
 
     // Member can create the channel
@@ -27,7 +27,7 @@ fn member_can_create_videos() {
     with_default_mock_builder(|| {
         // Run to block one to see emitted events
         run_to_block(1);
-        let channel_id = create_channel();
+        let channel_id = create_member_channel();
 
         let video_id = Content::next_video_id();
         assert_ok!(Content::create_video(
@@ -35,8 +35,8 @@ fn member_can_create_videos() {
             ContentActor::Member(FIRST_MEMBER_ID),
             channel_id,
             VideoCreationParameters {
-                assets: vec![],
-                meta: vec![],
+                assets: vec![NewAsset::Urls(vec![b"https://somewhere.com/".to_vec()])],
+                meta: b"metablob".to_vec(),
             }
         ));
 
@@ -47,22 +47,26 @@ fn member_can_create_videos() {
                 channel_id,
                 video_id,
                 VideoCreationParameters {
-                    assets: vec![],
-                    meta: vec![],
+                    assets: vec![NewAsset::Urls(vec![b"https://somewhere.com/".to_vec()])],
+                    meta: b"metablob".to_vec(),
                 }
             ))
         );
 
+        // Video is created in correct channel
         let video = Content::video_by_id(video_id);
         assert_eq!(channel_id, video.in_channel);
 
+        // Can update own video
         assert_ok!(Content::update_video(
             Origin::signed(FIRST_MEMBER_ORIGIN),
             ContentActor::Member(FIRST_MEMBER_ID),
             video_id,
             VideoUpdateParameters {
-                assets: None,
-                new_meta: None,
+                assets: Some(vec![NewAsset::Urls(vec![
+                    b"https://somewhere-else.com/".to_vec()
+                ])]),
+                new_meta: Some(b"newmetablob".to_vec()),
             }
         ));
 
@@ -71,13 +75,54 @@ fn member_can_create_videos() {
             MetaEvent::content(RawEvent::VideoUpdated(
                 ContentActor::Member(FIRST_MEMBER_ID),
                 video_id,
+                VideoUpdateParameters {
+                    assets: Some(vec![NewAsset::Urls(vec![
+                        b"https://somewhere-else.com/".to_vec()
+                    ])]),
+                    new_meta: Some(b"newmetablob".to_vec()),
+                }
+            ))
+        );
+
+        // Member cannot create video in a channel they do not own
+        assert_err!(
+            Content::create_video(
+                Origin::signed(SECOND_MEMBER_ORIGIN),
+                ContentActor::Member(SECOND_MEMBER_ID),
+                channel_id,
+                VideoCreationParameters {
+                    assets: vec![],
+                    meta: vec![],
+                }
+            ),
+            Error::<Test>::ActorNotAuthorized
+        );
+
+        // Member cannot update video in a channel they do not own
+        assert_err!(
+            Content::update_video(
+                Origin::signed(SECOND_MEMBER_ORIGIN),
+                ContentActor::Member(SECOND_MEMBER_ID),
+                video_id,
                 VideoUpdateParameters {
                     assets: None,
                     new_meta: None,
                 }
-            ))
+            ),
+            Error::<Test>::ActorNotAuthorized
+        );
+
+        // Member cannot delete video in a channel they do not own
+        assert_err!(
+            Content::delete_video(
+                Origin::signed(SECOND_MEMBER_ORIGIN),
+                ContentActor::Member(SECOND_MEMBER_ID),
+                video_id
+            ),
+            Error::<Test>::ActorNotAuthorized
         );
 
+        // Owner can delete their video
         assert_ok!(Content::delete_video(
             Origin::signed(FIRST_MEMBER_ORIGIN),
             ContentActor::Member(FIRST_MEMBER_ID),
@@ -91,37 +136,80 @@ fn member_can_create_videos() {
                 video_id
             ))
         );
+    })
+}
 
-        // Member cannot create video in a channel they do not own
-        assert!(Content::create_video(
-            Origin::signed(SECOND_MEMBER_ORIGIN),
-            ContentActor::Member(SECOND_MEMBER_ID),
+#[test]
+fn curators_can_censor_videos() {
+    with_default_mock_builder(|| {
+        // Run to block one to see emitted events
+        run_to_block(1);
+        let channel_id = create_member_channel();
+
+        let video_id = Content::next_video_id();
+        assert_ok!(Content::create_video(
+            Origin::signed(FIRST_MEMBER_ORIGIN),
+            ContentActor::Member(FIRST_MEMBER_ID),
             channel_id,
             VideoCreationParameters {
-                assets: vec![],
-                meta: vec![],
+                assets: vec![NewAsset::Urls(vec![b"https://somewhere.com/".to_vec()])],
+                meta: b"metablob".to_vec(),
             }
-        )
-        .is_err());
+        ));
 
-        // Member cannot update video in a channel they do not own
-        assert!(Content::update_video(
-            Origin::signed(SECOND_MEMBER_ORIGIN),
-            ContentActor::Member(SECOND_MEMBER_ID),
+        let group_id = curators::add_curator_to_new_group(FIRST_CURATOR_ID);
+
+        // Curator can censor videos
+        assert_ok!(Content::censor_video(
+            Origin::signed(FIRST_CURATOR_ORIGIN),
+            ContentActor::Curator(group_id, FIRST_CURATOR_ID),
             video_id,
-            VideoUpdateParameters {
-                assets: None,
-                new_meta: None,
-            }
-        )
-        .is_err());
+            vec![]
+        ));
 
-        // Member cannot delete video in a channel they do not own
-        assert!(Content::delete_video(
-            Origin::signed(SECOND_MEMBER_ORIGIN),
-            ContentActor::Member(SECOND_MEMBER_ID),
-            video_id
-        )
-        .is_err());
+        assert_eq!(
+            System::events().last().unwrap().event,
+            MetaEvent::content(RawEvent::VideoCensored(
+                ContentActor::Curator(group_id, FIRST_CURATOR_ID),
+                video_id,
+                vec![]
+            ))
+        );
+
+        let video = Content::video_by_id(video_id);
+
+        assert!(video.is_censored);
+
+        // Curator can un-censor videos
+        assert_ok!(Content::uncensor_video(
+            Origin::signed(FIRST_CURATOR_ORIGIN),
+            ContentActor::Curator(group_id, FIRST_CURATOR_ID),
+            video_id,
+            vec![]
+        ));
+
+        assert_eq!(
+            System::events().last().unwrap().event,
+            MetaEvent::content(RawEvent::VideoUncensored(
+                ContentActor::Curator(group_id, FIRST_CURATOR_ID),
+                video_id,
+                vec![]
+            ))
+        );
+
+        let video = Content::video_by_id(video_id);
+
+        assert!(!video.is_censored);
+
+        // Members cannot censor videos
+        assert_err!(
+            Content::censor_video(
+                Origin::signed(FIRST_MEMBER_ORIGIN),
+                ContentActor::Member(FIRST_MEMBER_ORIGIN),
+                channel_id,
+                vec![]
+            ),
+            Error::<Test>::ActorNotAuthorized
+        );
     })
 }