Move unit tests into source

Move the unit tests into the relevant source files. There's no need for them to
be seprate, especially when the `tests` directory is meant to be for integration
tests.

The deserialization tests that include JSON files are still in the `tests` dir,
along with the public prelude re-export tests.

12 files changed, 0 insertions, 1242 deletions

diff --git a/tests/test_args.rs b/tests/test_args.rs
deleted file mode 100644
index 9868b1b..0000000
--- a/tests/test_args.rs
+++ /dev/null
@@ -1,432 +0,0 @@
-extern crate serenity;
-#[macro_use] extern crate matches;
-
-use serenity::framework::standard::{Args, ArgError};
-
-#[test]
-fn single_with_empty_message() {
-    let mut args = Args::new("", &["".to_string()]);
-    assert_matches!(args.single::<String>().unwrap_err(), ArgError::Eos);
-
-    let mut args = Args::new("", &[",".to_string()]);
-    assert_matches!(args.single::<String>().unwrap_err(), ArgError::Eos);
-}
-
-#[test]
-fn single_n_with_empty_message() {
-    let args = Args::new("", &["".to_string()]);
-    assert_matches!(args.single_n::<String>().unwrap_err(), ArgError::Eos);
-
-    let args = Args::new("", &[",".to_string()]);
-    assert_matches!(args.single_n::<String>().unwrap_err(), ArgError::Eos);
-}
-
-#[test]
-fn single_quoted_with_empty_message() {
-    let mut args = Args::new("", &["".to_string()]);
-    assert_matches!(args.single_quoted::<String>().unwrap_err(), ArgError::Eos);
-
-    let mut args = Args::new("", &[",".to_string()]);
-    assert_matches!(args.single_quoted::<String>().unwrap_err(), ArgError::Eos);
-}
-
-#[test]
-fn multiple_with_empty_message() {
-    let args = Args::new("", &["".to_string()]);
-    assert_matches!(args.multiple::<String>().unwrap_err(), ArgError::Eos);
-
-    let args = Args::new("", &[",".to_string()]);
-    assert_matches!(args.multiple::<String>().unwrap_err(), ArgError::Eos);
-}
-
-#[test]
-fn multiple_quoted_with_empty_message() {
-    let args = Args::new("", &["".to_string()]);
-    assert_matches!(args.multiple_quoted::<String>().unwrap_err(), ArgError::Eos);
-
-    let args = Args::new("", &[",".to_string()]);
-    assert_matches!(args.multiple_quoted::<String>().unwrap_err(), ArgError::Eos);
-}
-
-#[test]
-fn skip_with_empty_message() {
-    let mut args = Args::new("", &["".to_string()]);
-    assert_matches!(args.skip(), None);
-
-    let mut args = Args::new("", &[",".to_string()]);
-    assert_matches!(args.skip(), None);
-}
-
-#[test]
-fn skip_for_with_empty_message() {
-    let mut args = Args::new("", &["".to_string()]);
-    assert_matches!(args.skip_for(0), None);
-
-    let mut args = Args::new("", &["".to_string()]);
-    assert_matches!(args.skip_for(5), None);
-
-    let mut args = Args::new("", &[",".to_string()]);
-    assert_matches!(args.skip_for(0), None);
-
-    let mut args = Args::new("", &[",".to_string()]);
-    assert_matches!(args.skip_for(5), None);
-}
-
-#[test]
-fn single_i32_with_2_bytes_long_delimiter() {
-    let mut args = Args::new("1, 2", &[", ".to_string()]);
-
-    assert_eq!(args.single::<i32>().unwrap(), 1);
-    assert_eq!(args.single::<i32>().unwrap(), 2);
-}
-
-#[test]
-fn single_i32_with_1_byte_long_delimiter_i32() {
-    let mut args = Args::new("1,2", &[",".to_string()]);
-
-    assert_eq!(args.single::<i32>().unwrap(), 1);
-    assert_eq!(args.single::<i32>().unwrap(), 2);
-}
-
-#[test]
-fn single_i32_with_wrong_char_after_first_arg() {
-    let mut args = Args::new("1, 2", &[",".to_string()]);
-
-    assert_eq!(args.single::<i32>().unwrap(), 1);
-    assert!(args.single::<i32>().is_err());
-}
-
-#[test]
-fn single_i32_with_one_character_being_3_bytes_long() {
-    let mut args = Args::new("1★2", &["★".to_string()]);
-
-    assert_eq!(args.single::<i32>().unwrap(), 1);
-    assert_eq!(args.single::<i32>().unwrap(), 2);
-}
-
-#[test]
-fn single_i32_with_untrimmed_whitespaces() {
-    let mut args = Args::new(" 1, 2 ", &[",".to_string()]);
-
-    assert!(args.single::<i32>().is_err());
-}
-
-#[test]
-fn single_i32_n() {
-    let args = Args::new("1,2", &[",".to_string()]);
-
-    assert_eq!(args.single_n::<i32>().unwrap(), 1);
-    assert_eq!(args.single_n::<i32>().unwrap(), 1);
-}
-
-#[test]
-fn single_quoted_chaining() {
-    let mut args = Args::new(r#""1, 2" "2" """#, &[" ".to_string()]);
-
-    assert_eq!(args.single_quoted::<String>().unwrap(), "1, 2");
-    assert_eq!(args.single_quoted::<String>().unwrap(), "2");
-    assert_eq!(args.single_quoted::<String>().unwrap(), "");
-}
-
-#[test]
-fn single_quoted_and_single_chaining() {
-    let mut args = Args::new(r#""1, 2" "2" "3" 4"#, &[" ".to_string()]);
-
-    assert_eq!(args.single_quoted::<String>().unwrap(), "1, 2");
-    assert!(args.single_n::<i32>().is_err());
-    assert_eq!(args.single::<String>().unwrap(), "\"2\"");
-    assert_eq!(args.single_quoted::<i32>().unwrap(), 3);
-    assert_eq!(args.single::<i32>().unwrap(), 4);
-}
-
-#[test]
-fn full_on_args() {
-    let test_text = "Some text to ensure `full()` works.";
-    let args = Args::new(test_text, &[" ".to_string()]);
-
-    assert_eq!(args.full(), test_text);
-}
-
-#[test]
-fn multiple_quoted_strings_one_delimiter() {
-    let args = Args::new(r#""1, 2" "a" "3" 4 "5"#, &[" ".to_string()]);
-
-    assert_eq!(args.multiple_quoted::<String>().unwrap(), ["1, 2", "a", "3", "4", "\"5"]);
-}
-
-#[test]
-fn multiple_quoted_strings_with_multiple_delimiter() {
-    let args = Args::new(r#""1, 2" "a","3"4 "5"#, &[" ".to_string(), ",".to_string()]);
-
-    assert_eq!(args.multiple_quoted::<String>().unwrap(), ["1, 2", "a", "3", "4", "\"5"]);
-}
-
-#[test]
-fn multiple_quoted_strings_with_multiple_delimiters() {
-    let args = Args::new(r#""1, 2" "a","3" """#, &[" ".to_string(), ",".to_string()]);
-
-    assert_eq!(args.multiple_quoted::<String>().unwrap(), ["1, 2", "a", "3", ""]);
-}
-
-#[test]
-fn multiple_quoted_i32() {
-    let args = Args::new(r#""1" "2" 3"#, &[" ".to_string()]);
-
-    assert_eq!(args.multiple_quoted::<i32>().unwrap(), [1, 2, 3]);
-}
-
-#[test]
-fn multiple_quoted_quote_appears_without_delimiter_in_front() {
-    let args = Args::new(r#"hello, my name is cake" 2"#, &[",".to_string(), " ".to_string()]);
-
-    assert_eq!(args.multiple_quoted::<String>().unwrap(), ["hello", "my", "name", "is", "cake\"", "2"]);
-}
-
-#[test]
-fn multiple_quoted_single_quote() {
-    let args = Args::new(r#"hello "2 b"#, &[",".to_string(), " ".to_string()]);
-
-    assert_eq!(args.multiple_quoted::<String>().unwrap(), ["hello", "\"2 b"]);
-}
-
-#[test]
-fn multiple_quoted_one_quote_pair() {
-    let args = Args::new(r#"hello "2 b""#, &[",".to_string(), " ".to_string()]);
-
-    assert_eq!(args.multiple_quoted::<String>().unwrap(), ["hello", "2 b"]);
-}
-
-
-#[test]
-fn delimiter_before_multiple_quoted() {
-    let args = Args::new(r#","hello, my name is cake" "2""#, &[",".to_string(), " ".to_string()]);
-
-    assert_eq!(args.multiple_quoted::<String>().unwrap(), ["hello, my name is cake", "2"]);
-}
-
-#[test]
-fn no_quote() {
-    let args = Args::new("hello, my name is cake", &[",".to_string(), " ".to_string()]);
-
-    assert_eq!(args.single_quoted_n::<String>().unwrap(), "hello");
-}
-
-#[test]
-fn single_quoted_n() {
-    let args = Args::new(r#""hello, my name is cake","test"#, &[",".to_string()]);
-
-    assert_eq!(args.single_quoted_n::<String>().unwrap(), "hello, my name is cake");
-    assert_eq!(args.single_quoted_n::<String>().unwrap(), "hello, my name is cake");
-}
-
-#[test]
-fn multiple_quoted_starting_with_wrong_delimiter_in_first_quote() {
-    let args = Args::new(r#""hello, my name is cake" "2""#, &[",".to_string(), " ".to_string()]);
-
-    assert_eq!(args.multiple_quoted::<String>().unwrap(), ["hello, my name is cake", "2"]);
-}
-
-#[test]
-fn multiple_quoted_with_one_correct_and_one_invalid_quote() {
-    let args = Args::new(r#""hello, my name is cake" "2""#, &[",".to_string(), " ".to_string()]);
-
-    assert_eq!(args.multiple_quoted::<String>().unwrap(), ["hello, my name is cake", "2"]);
-}
-
-#[test]
-fn find_i32_one_one_byte_delimiter() {
-    let mut args = Args::new("hello,my name is cake 2", &[" ".to_string()]);
-
-    assert_eq!(args.find::<i32>().unwrap(), 2);
-}
-
-#[test]
-fn find_i32_one_three_byte_delimiter() {
-    let mut args = Args::new("hello,my name is cakeé2", &["é".to_string()]);
-
-    assert_eq!(args.find::<i32>().unwrap(), 2);
-}
-
-#[test]
-fn find_i32_multiple_delimiter_but_i32_not_last() {
-    let mut args = Args::new("hello,my name is 2 cake", &[" ".to_string(), ",".to_string()]);
-
-    assert_eq!(args.find::<i32>().unwrap(), 2);
-}
-
-#[test]
-fn find_i32_multiple_delimiter() {
-    let mut args = Args::new("hello,my name is cake 2", &[" ".to_string(), ",".to_string()]);
-
-    assert_eq!(args.find::<i32>().unwrap(), 2);
-}
-
-#[test]
-fn find_n_i32() {
-    let mut args = Args::new("a 2", &[" ".to_string()]);
-
-    assert_eq!(args.find_n::<i32>().unwrap(), 2);
-    assert_eq!(args.find_n::<i32>().unwrap(), 2);
-}
-
-#[test]
-fn skip() {
-    let mut args = Args::new("1 2", &[" ".to_string()]);
-
-    assert_eq!(args.skip().unwrap(), "1");
-    assert_eq!(args.remaining(), 1);
-    assert_eq!(args.single::<String>().unwrap(), "2");
-}
-
-#[test]
-fn skip_for() {
-    let mut args = Args::new("1 2 neko 100", &[" ".to_string()]);
-
-    assert_eq!(args.skip_for(2).unwrap(), ["1", "2"]);
-    assert_eq!(args.remaining(), 2);
-    assert_eq!(args.single::<String>().unwrap(), "neko");
-    assert_eq!(args.single::<String>().unwrap(), "100");
-}
-
-#[test]
-fn len_with_one_delimiter() {
-    let args = Args::new("1 2 neko 100", &[" ".to_string()]);
-
-    assert_eq!(args.len(), 4);
-    assert_eq!(args.remaining(), 4);
-}
-
-#[test]
-fn len_multiple_quoted() {
-    let args = Args::new(r#""hello, my name is cake" "2""#, &[" ".to_string()]);
-
-    assert_eq!(args.len(), 2);
-}
-
-#[test]
-fn remaining_len_before_and_after_single() {
-    let mut args = Args::new("1 2", &[" ".to_string()]);
-
-    assert_eq!(args.remaining(), 2);
-    assert_eq!(args.single::<i32>().unwrap(), 1);
-    assert_eq!(args.remaining(), 1);
-    assert_eq!(args.single::<i32>().unwrap(), 2);
-    assert_eq!(args.remaining(), 0);
-}
-
-#[test]
-fn remaining_len_before_and_after_single_quoted() {
-    let mut args = Args::new(r#""1" "2" "3""#, &[" ".to_string()]);
-
-    assert_eq!(args.remaining(), 3);
-    assert_eq!(args.single_quoted::<i32>().unwrap(), 1);
-    assert_eq!(args.remaining(), 2);
-    assert_eq!(args.single_quoted::<i32>().unwrap(), 2);
-    assert_eq!(args.remaining(), 1);
-    assert_eq!(args.single_quoted::<i32>().unwrap(), 3);
-    assert_eq!(args.remaining(), 0);
-}
-
-#[test]
-fn remaining_len_before_and_after_skip() {
-    let mut args = Args::new("1 2", &[" ".to_string()]);
-
-    assert_eq!(args.remaining(), 2);
-    assert_eq!(args.skip().unwrap(), "1");
-    assert_eq!(args.remaining(), 1);
-    assert_eq!(args.skip().unwrap(), "2");
-    assert_eq!(args.remaining(), 0);
-}
-
-#[test]
-fn remaining_len_before_and_after_skip_empty_string() {
-    let mut args = Args::new("", &[" ".to_string()]);
-
-    assert_eq!(args.remaining(), 0);
-    assert_eq!(args.skip(), None);
-    assert_eq!(args.remaining(), 0);
-}
-
-#[test]
-fn remaining_len_before_and_after_skip_for() {
-    let mut args = Args::new("1 2", &[" ".to_string()]);
-
-    assert_eq!(args.remaining(), 2);
-    assert_eq!(args.skip_for(2), Some(vec!["1".to_string(), "2".to_string()]));
-    assert_eq!(args.skip_for(2), None);
-    assert_eq!(args.remaining(), 0);
-}
-
-#[test]
-fn remaining_len_before_and_after_find() {
-    let mut args = Args::new("a 2 6", &[" ".to_string()]);
-
-    assert_eq!(args.remaining(), 3);
-    assert_eq!(args.find::<i32>().unwrap(), 2);
-    assert_eq!(args.remaining(), 2);
-    assert_eq!(args.find::<i32>().unwrap(), 6);
-    assert_eq!(args.remaining(), 1);
-    assert_eq!(args.find::<String>().unwrap(), "a");
-    assert_eq!(args.remaining(), 0);
-    assert_matches!(args.find::<String>().unwrap_err(), ArgError::Eos);
-    assert_eq!(args.remaining(), 0);
-}
-
-#[test]
-fn remaining_len_before_and_after_find_n() {
-    let mut args = Args::new("a 2 6", &[" ".to_string()]);
-
-    assert_eq!(args.remaining(), 3);
-    assert_eq!(args.find_n::<i32>().unwrap(), 2);
-    assert_eq!(args.remaining(), 3);
-}
-
-
-#[test]
-fn multiple_strings_with_one_delimiter() {
-    let args = Args::new("hello, my name is cake 2", &[" ".to_string()]);
-
-    assert_eq!(args.multiple::<String>().unwrap(), ["hello,", "my", "name", "is", "cake", "2"]);
-}
-
-#[test]
-fn multiple_i32_with_one_delimiter() {
-    let args = Args::new("1 2 3", &[" ".to_string()]);
-
-    assert_eq!(args.multiple::<i32>().unwrap(), [1, 2, 3]);
-}
-
-#[test]
-fn multiple_i32_with_one_delimiter_and_parse_error() {
-    let args = Args::new("1 2 3 abc", &[" ".to_string()]);
-
-    assert_matches!(args.multiple::<i32>().unwrap_err(), ArgError::Parse(_));
-}
-
-#[test]
-fn multiple_i32_with_three_delimiters() {
-    let args = Args::new("1 2 3", &[" ".to_string(), ",".to_string()]);
-
-    assert_eq!(args.multiple::<i32>().unwrap(), [1, 2, 3]);
-}
-
-#[test]
-fn single_after_failed_single() {
-    let mut args = Args::new("b 2", &[" ".to_string()]);
-
-    assert_matches!(args.single::<i32>().unwrap_err(), ArgError::Parse(_));
-    // Test that `single` short-circuts on an error and leaves the source as is.
-    assert_eq!(args.remaining(), 2);
-    assert_eq!(args.single::<String>().unwrap(), "b");
-    assert_eq!(args.single::<String>().unwrap(), "2");
-}
-
-#[test]
-fn remaining_len_after_failed_single_quoted() {
-    let mut args = Args::new("b a", &[" ".to_string()]);
-
-    assert_eq!(args.remaining(), 2);
-    // Same goes for `single_quoted` and the alike.
-    assert_matches!(args.single_quoted::<i32>().unwrap_err(), ArgError::Parse(_));
-    assert_eq!(args.remaining(), 2);
-}
diff --git a/tests/test_cache.rs b/tests/test_cache.rs
deleted file mode 100644
index 833af04..0000000
--- a/tests/test_cache.rs
+++ /dev/null
@@ -1,174 +0,0 @@
-#![cfg(feature = "cache")]

-

-extern crate chrono;

-extern crate serde_json;

-extern crate serenity;

-

-use chrono::DateTime;

-use serde_json::{Number, Value};

-use serenity::{

-    cache::{Cache, CacheUpdate, Settings},

-    model::prelude::*,

-    prelude::RwLock,

-};

-use std::{

-    collections::HashMap,

-    sync::Arc,

-};

-

-#[test]

-fn test_cache_messages() {

-    let mut settings = Settings::new();

-    settings.max_messages(2);

-    let mut cache = Cache::new_with_settings(settings);

-

-    // Test inserting one message into a channel's message cache.

-    let datetime = DateTime::parse_from_str(

-        "1983 Apr 13 12:09:14.274 +0000",

-        "%Y %b %d %H:%M:%S%.3f %z",

-    ).unwrap();

-    let mut event = MessageCreateEvent {

-        message: Message {

-            id: MessageId(3),

-            attachments: vec![],

-            author: User {

-                id: UserId(2),

-                avatar: None,

-                bot: false,

-                discriminator: 1,

-                name: "user 1".to_owned(),

-            },

-            channel_id: ChannelId(2),

-            guild_id: Some(GuildId(1)),

-            content: String::new(),

-            edited_timestamp: None,

-            embeds: vec![],

-            kind: MessageType::Regular,

-            member: None,

-            mention_everyone: false,

-            mention_roles: vec![],

-            mentions: vec![],

-            nonce: Value::Number(Number::from(1)),

-            pinned: false,

-            reactions: vec![],

-            timestamp: datetime.clone(),

-            tts: false,

-            webhook_id: None,

-        },

-    };

-    // Check that the channel cache doesn't exist.

-    assert!(!cache.messages.contains_key(&event.message.channel_id));

-    // Add first message, none because message ID 2 doesn't already exist.

-    assert!(event.update(&mut cache).is_none());

-    // None, it only returns the oldest message if the cache was already full.

-    assert!(event.update(&mut cache).is_none());

-    // Assert there's only 1 message in the channel's message cache.

-    assert_eq!(cache.messages.get(&event.message.channel_id).unwrap().len(), 1);

-

-    // Add a second message, assert that channel message cache length is 2.

-    event.message.id = MessageId(4);

-    assert!(event.update(&mut cache).is_none());

-    assert_eq!(cache.messages.get(&event.message.channel_id).unwrap().len(), 2);

-

-    // Add a third message, the first should now be removed.

-    event.message.id = MessageId(5);

-    assert!(event.update(&mut cache).is_some());

-

-    {

-        let channel = cache.messages.get(&event.message.channel_id).unwrap();

-

-        assert_eq!(channel.len(), 2);

-        // Check that the first message is now removed.

-        assert!(!channel.contains_key(&MessageId(3)));

-    }

-

-    let guild_channel = GuildChannel {

-        id: event.message.channel_id,

-        bitrate: None,

-        category_id: None,

-        guild_id: event.message.guild_id.unwrap(),

-        kind: ChannelType::Text,

-        last_message_id: None,

-        last_pin_timestamp: None,

-        name: String::new(),

-        permission_overwrites: vec![],

-        position: 0,

-        topic: None,

-        user_limit: None,

-        nsfw: false,

-    };

-

-    // Add a channel delete event to the cache, the cached messages for that

-    // channel should now be gone.

-    let mut delete = ChannelDeleteEvent {

-        channel: Channel::Guild(Arc::new(RwLock::new(guild_channel.clone()))),

-    };

-    assert!(cache.update(&mut delete).is_none());

-    assert!(!cache.messages.contains_key(&delete.channel.id()));

-

-    // Test deletion of a guild channel's message cache when a GuildDeleteEvent

-    // is received.

-    let mut guild_create = {

-        let mut channels = HashMap::new();

-        channels.insert(ChannelId(2), Arc::new(RwLock::new(guild_channel.clone())));

-

-        GuildCreateEvent {

-            guild: Guild {

-                id: GuildId(1),

-                afk_channel_id: None,

-                afk_timeout: 0,

-                application_id: None,

-                default_message_notifications: DefaultMessageNotificationLevel::All,

-                emojis: HashMap::new(),

-                explicit_content_filter: ExplicitContentFilter::None,

-                features: vec![],

-                icon: None,

-                joined_at: datetime,

-                large: false,

-                member_count: 0,

-                members: HashMap::new(),

-                mfa_level: MfaLevel::None,

-                name: String::new(),

-                owner_id: UserId(3),

-                presences: HashMap::new(),

-                region: String::new(),

-                roles: HashMap::new(),

-                splash: None,

-                system_channel_id: None,

-                verification_level: VerificationLevel::Low,

-                voice_states: HashMap::new(),

-                channels,

-            },

-        }

-    };

-    assert!(cache.update(&mut guild_create).is_none());

-    assert!(cache.update(&mut event).is_none());

-

-    let mut guild_delete = GuildDeleteEvent {

-        guild: PartialGuild {

-            id: GuildId(1),

-            afk_channel_id: None,

-            afk_timeout: 0,

-            default_message_notifications: DefaultMessageNotificationLevel::All,

-            embed_channel_id: None,

-            embed_enabled: false,

-            emojis: HashMap::new(),

-            features: vec![],

-            icon: None,

-            mfa_level: MfaLevel::None,

-            name: String::new(),

-            owner_id: UserId(3),

-            region: String::new(),

-            roles: HashMap::new(),

-            splash: None,

-            verification_level: VerificationLevel::Low,

-        },

-    };

-

-    // The guild existed in the cache, so the cache's guild is returned by the

-    // update.

-    assert!(cache.update(&mut guild_delete).is_some());

-

-    // Assert that the channel's message cache no longer exists.

-    assert!(!cache.messages.contains_key(&ChannelId(2)));

-}

diff --git a/tests/test_channels.rs b/tests/test_channels.rs
deleted file mode 100644
index 92e31fc..0000000
--- a/tests/test_channels.rs
+++ /dev/null
@@ -1,91 +0,0 @@
-#![cfg(feature = "model")]
-
-extern crate parking_lot;
-extern crate serenity;
-
-#[cfg(feature = "utils")]
-mod utils {
-    use parking_lot::RwLock;
-    use serenity::model::prelude::*;
-    use std::collections::HashMap;
-    use std::sync::Arc;
-
-    fn group() -> Group {
-        Group {
-            channel_id: ChannelId(1),
-            icon: None,
-            last_message_id: None,
-            last_pin_timestamp: None,
-            name: None,
-            owner_id: UserId(2),
-            recipients: HashMap::new(),
-        }
-    }
-
-    fn guild_channel() -> GuildChannel {
-        GuildChannel {
-            id: ChannelId(1),
-            bitrate: None,
-            category_id: None,
-            guild_id: GuildId(2),
-            kind: ChannelType::Text,
-            last_message_id: None,
-            last_pin_timestamp: None,
-            name: "nsfw-stuff".to_string(),
-            permission_overwrites: vec![],
-            position: 0,
-            topic: None,
-            user_limit: None,
-            nsfw: false,
-        }
-    }
-
-    fn private_channel() -> PrivateChannel {
-        PrivateChannel {
-            id: ChannelId(1),
-            last_message_id: None,
-            last_pin_timestamp: None,
-            kind: ChannelType::Private,
-            recipient: Arc::new(RwLock::new(User {
-                id: UserId(2),
-                avatar: None,
-                bot: false,
-                discriminator: 1,
-                name: "ab".to_string(),
-            })),
-        }
-    }
-
-    #[test]
-    fn nsfw_checks() {
-        let mut channel = guild_channel();
-        assert!(channel.is_nsfw());
-        channel.kind = ChannelType::Voice;
-        assert!(!channel.is_nsfw());
-
-        channel.kind = ChannelType::Text;
-        channel.name = "nsfw-".to_string();
-        assert!(!channel.is_nsfw());
-
-        channel.name = "nsfw".to_string();
-        assert!(channel.is_nsfw());
-        channel.kind = ChannelType::Voice;
-        assert!(!channel.is_nsfw());
-        channel.kind = ChannelType::Text;
-
-        channel.name = "nsf".to_string();
-        channel.nsfw = true;
-        assert!(channel.is_nsfw());
-        channel.nsfw = false;
-        assert!(!channel.is_nsfw());
-
-        let channel = Channel::Guild(Arc::new(RwLock::new(channel)));
-        assert!(!channel.is_nsfw());
-
-        let group = group();
-        assert!(!group.is_nsfw());
-
-        let private_channel = private_channel();
-        assert!(!private_channel.is_nsfw());
-    }
-}
diff --git a/tests/test_colour.rs b/tests/test_colour.rs
deleted file mode 100644
index 2b36562..0000000
--- a/tests/test_colour.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-#![cfg_attr(feature = "cargo-clippy", allow(unreadable_literal))]
-#![cfg(feature = "utils")]
-
-extern crate serenity;
-
-use serenity::utils::Colour;
-use std::u32;
-
-#[test]
-fn new() {
-    assert_eq!(Colour::new(1).0, 1);
-    assert_eq!(Colour::new(u32::MIN).0, u32::MIN);
-    assert_eq!(Colour::new(u32::MAX).0, u32::MAX);
-}
-
-#[test]
-fn from_rgb() {
-    assert_eq!(Colour::from_rgb(255, 0, 0).0, 0xFF0000);
-    assert_eq!(Colour::from_rgb(0, 255, 0).0, 0x00FF00);
-    assert_eq!(Colour::from_rgb(0, 0, 255).0, 0x0000FF);
-}
-
-#[test]
-fn r() {
-    assert_eq!(Colour::new(0x336123).r(), 0x33);
-}
-
-#[test]
-fn g() {
-    assert_eq!(Colour::new(0x336123).g(), 0x61);
-}
-
-#[test]
-fn b() {
-    assert_eq!(Colour::new(0x336123).b(), 0x23);
-}
-
-#[test]
-fn tuple() {
-    assert_eq!(Colour::new(0x336123).tuple(), (0x33, 0x61, 0x23));
-}
-
-#[test]
-fn default() {
-    assert_eq!(Colour::default().0, 0);
-}
-
-#[test]
-fn from() {
-    assert_eq!(Colour::from(7i32).0, 7);
-    assert_eq!(Colour::from(7u32).0, 7);
-    assert_eq!(Colour::from(7u64).0, 7);
-}
diff --git a/tests/test_create_embed.rs b/tests/test_create_embed.rs
deleted file mode 100644
index 5bdce5f..0000000
--- a/tests/test_create_embed.rs
+++ /dev/null
@@ -1,92 +0,0 @@
-#![cfg_attr(feature = "cargo-clippy", allow(unreadable_literal))]
-#![cfg(all(feature = "builder", feature = "utils"))]
-
-#[macro_use]
-extern crate serde_json;
-extern crate serenity;
-
-use serde_json::Value;
-use serenity::model::channel::{Embed, EmbedField, EmbedFooter, EmbedImage, EmbedVideo};
-use serenity::builder::CreateEmbed;
-use serenity::utils::{self, Colour};
-
-#[test]
-fn test_from_embed() {
-    let embed = Embed {
-        author: None,
-        colour: Colour::new(0xFF0011),
-        description: Some("This is a test description".to_string()),
-        fields: vec![
-            EmbedField {
-                inline: false,
-                name: "a".to_string(),
-                value: "b".to_string(),
-            },
-            EmbedField {
-                inline: true,
-                name: "c".to_string(),
-                value: "z".to_string(),
-            },
-        ],
-        footer: Some(EmbedFooter {
-            icon_url: Some("https://i.imgur.com/XfWpfCV.gif".to_string()),
-            proxy_icon_url: None,
-            text: "This is a hakase footer".to_string(),
-        }),
-        image: Some(EmbedImage {
-            height: 213,
-            proxy_url: "a".to_string(),
-            url: "https://i.imgur.com/XfWpfCV.gif".to_string(),
-            width: 224,
-        }),
-        kind: "rich".to_string(),
-        provider: None,
-        thumbnail: None,
-        timestamp: None,
-        title: Some("hakase".to_string()),
-        url: Some("https://i.imgur.com/XfWpfCV.gif".to_string()),
-        video: Some(EmbedVideo {
-            height: 213,
-            url: "https://i.imgur.com/XfWpfCV.mp4".to_string(),
-            width: 224,
-        }),
-    };
-
-    let builder = CreateEmbed::from(embed)
-        .colour(0xFF0011)
-        .description("This is a hakase description")
-        .image("https://i.imgur.com/XfWpfCV.gif")
-        .title("still a hakase")
-        .url("https://i.imgur.com/XfWpfCV.gif");
-
-    let built = Value::Object(utils::vecmap_to_json_map(builder.0));
-
-    let obj = json!({
-        "color": 0xFF0011,
-        "description": "This is a hakase description",
-        "title": "still a hakase",
-        "type": "rich",
-        "url": "https://i.imgur.com/XfWpfCV.gif",
-        "fields": [
-            {
-                "inline": false,
-                "name": "a",
-                "value": "b",
-            },
-            {
-                "inline": true,
-                "name": "c",
-                "value": "z",
-            },
-        ],
-        "image": {
-            "url": "https://i.imgur.com/XfWpfCV.gif",
-        },
-        "footer": {
-            "text": "This is a hakase footer",
-            "icon_url": "https://i.imgur.com/XfWpfCV.gif",
-        }
-    });
-
-    assert_eq!(built, obj);
-}
diff --git a/tests/test_formatters.rs b/tests/test_formatters.rs
deleted file mode 100644
index ccdfba1..0000000
--- a/tests/test_formatters.rs
+++ /dev/null
@@ -1,80 +0,0 @@
-extern crate parking_lot;
-extern crate serenity;
-
-use serenity::model::prelude::*;
-
-#[test]
-fn test_formatters() {
-    assert_eq!(ChannelId(1).to_string(), "1");
-    assert_eq!(EmojiId(2).to_string(), "2");
-    assert_eq!(GuildId(3).to_string(), "3");
-    assert_eq!(RoleId(4).to_string(), "4");
-    assert_eq!(UserId(5).to_string(), "5");
-}
-
-#[cfg(feature = "utils")]
-#[test]
-fn test_mention() {
-    use parking_lot::RwLock;
-    use serenity::utils::Colour;
-    use std::sync::Arc;
-
-    let channel = Channel::Guild(Arc::new(RwLock::new(GuildChannel {
-        bitrate: None,
-        category_id: None,
-        guild_id: GuildId(1),
-        kind: ChannelType::Text,
-        id: ChannelId(4),
-        last_message_id: None,
-        last_pin_timestamp: None,
-        name: "a".to_string(),
-        permission_overwrites: vec![],
-        position: 1,
-        topic: None,
-        user_limit: None,
-        nsfw: false,
-    })));
-    let emoji = Emoji {
-        animated: false,
-        id: EmojiId(5),
-        name: "a".to_string(),
-        managed: true,
-        require_colons: true,
-        roles: vec![],
-    };
-    let role = Role {
-        id: RoleId(2),
-        colour: Colour::ROSEWATER,
-        hoist: false,
-        managed: false,
-        mentionable: false,
-        name: "fake role".to_string(),
-        permissions: Permissions::empty(),
-        position: 1,
-    };
-    let user = User {
-        id: UserId(6),
-        avatar: None,
-        bot: false,
-        discriminator: 4132,
-        name: "fake".to_string(),
-    };
-    let member = Member {
-        deaf: false,
-        guild_id: GuildId(2),
-        joined_at: None,
-        mute: false,
-        nick: None,
-        roles: vec![],
-        user: Arc::new(RwLock::new(user.clone())),
-    };
-
-    assert_eq!(ChannelId(1).mention(), "<#1>");
-    assert_eq!(channel.mention(), "<#4>");
-    assert_eq!(emoji.mention(), "<:a:5>");
-    assert_eq!(member.mention(), "<@6>");
-    assert_eq!(role.mention(), "<@&2>");
-    assert_eq!(role.id.mention(), "<@&2>");
-    assert_eq!(user.mention(), "<@6>");
-    assert_eq!(user.id.mention(), "<@6>");
-}
diff --git a/tests/test_guild.rs b/tests/test_guild.rs
deleted file mode 100644
index 1045381..0000000
--- a/tests/test_guild.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-#![cfg(feature = "model")]
-
-extern crate chrono;
-extern crate serenity;
-
-use chrono::prelude::*;
-use serenity::model::prelude::*;
-use serenity::prelude::*;
-use std::collections::*;
-use std::sync::Arc;
-
-fn gen_user() -> User {
-    User {
-        id: UserId(210),
-        avatar: Some("abc".to_string()),
-        bot: true,
-        discriminator: 1432,
-        name: "test".to_string(),
-    }
-}
-
-fn gen_member() -> Member {
-    let dt: DateTime<FixedOffset> = FixedOffset::east(5 * 3600)
-        .ymd(2016, 11, 08)
-        .and_hms(0, 0, 0);
-    let vec1 = Vec::new();
-    let u = Arc::new(RwLock::new(gen_user()));
-
-    Member {
-        deaf: false,
-        guild_id: GuildId(1),
-        joined_at: Some(dt),
-        mute: false,
-        nick: Some("aaaa".to_string()),
-        roles: vec1,
-        user: u,
-    }
-}
-
-fn gen() -> Guild {
-    let u = gen_user();
-    let m = gen_member();
-
-    let hm1 = HashMap::new();
-    let hm2 = HashMap::new();
-    let vec1 = Vec::new();
-    let dt: DateTime<FixedOffset> = FixedOffset::east(5 * 3600)
-        .ymd(2016, 11, 08)
-        .and_hms(0, 0, 0);
-    let mut hm3 = HashMap::new();
-    let hm4 = HashMap::new();
-    let hm5 = HashMap::new();
-    let hm6 = HashMap::new();
-
-    hm3.insert(u.id, m);
-
-    Guild {
-        afk_channel_id: Some(ChannelId(0)),
-        afk_timeout: 0,
-        channels: hm1,
-        default_message_notifications: DefaultMessageNotificationLevel::All,
-        emojis: hm2,
-        features: vec1,
-        icon: Some("/avatars/210/a_aaa.webp?size=1024".to_string()),
-        id: GuildId(1),
-        joined_at: dt,
-        large: false,
-        member_count: 1,
-        members: hm3,
-        mfa_level: MfaLevel::Elevated,
-        name: "Spaghetti".to_string(),
-        owner_id: UserId(210),
-        presences: hm4,
-        region: "NA".to_string(),
-        roles: hm5,
-        splash: Some("asdf".to_string()),
-        verification_level: VerificationLevel::None,
-        voice_states: hm6,
-        application_id: Some(ApplicationId(0)),
-        explicit_content_filter: ExplicitContentFilter::None,
-        system_channel_id: Some(ChannelId(0)),
-    }
-}
-
-
-#[test]
-fn member_named_username() {
-    let guild = gen();
-    let lhs = guild
-        .member_named("test#1432")
-        .unwrap()
-        .display_name();
-
-    assert_eq!(lhs, gen_member().display_name());
-}
-
-#[test]
-fn member_named_nickname() {
-    let guild = gen();
-    let lhs = guild.member_named("aaaa").unwrap().display_name();
-
-    assert_eq!(lhs, gen_member().display_name());
-}
diff --git a/tests/test_http.rs b/tests/test_http.rs
deleted file mode 100644
index 1389ef6..0000000
--- a/tests/test_http.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-#![cfg(feature = "http")]
-
-extern crate serenity;
-
-use serenity::http::AttachmentType;
-use std::path::Path;
-
-#[test]
-fn test_attachment_type() {
-    assert!(match AttachmentType::from(Path::new("./dogs/corgis/kona.png")) {
-        AttachmentType::Path(_) => true,
-        _ => false,
-    });
-    assert!(match AttachmentType::from("./cats/copycat.png") {
-        AttachmentType::Path(_) => true,
-        _ => false,
-    });
-}
diff --git a/tests/test_msg_builder.rs b/tests/test_msg_builder.rs
deleted file mode 100644
index c291bf5..0000000
--- a/tests/test_msg_builder.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-#![cfg(feature = "utils")]
-
-extern crate serenity;
-
-use serenity::utils::MessageBuilder;
-use serenity::utils::ContentModifier::*;
-use serenity::model::guild::Emoji;
-use serenity::model::id::{EmojiId, UserId};
-
-#[test]
-fn code_blocks() {
-    let content = MessageBuilder::new()
-        .push_codeblock("test", Some("rb"))
-        .build();
-    assert_eq!(content, "```rb\ntest\n```");
-}
-
-#[test]
-fn safe_content() {
-    let content = MessageBuilder::new()
-        .push_safe("@everyone discord.gg/discord-api")
-        .build();
-    assert_ne!(content, "@everyone discord.gg/discord-api");
-}
-
-#[test]
-fn no_free_formatting() {
-    let content = MessageBuilder::new().push_bold_safe("test**test").build();
-    assert_ne!(content, "**test**test**");
-}
-
-#[test]
-fn mentions() {
-    let content_emoji = MessageBuilder::new()
-        .emoji(&Emoji {
-            animated: false,
-            id: EmojiId(32),
-            name: "Rohrkatze".to_string(),
-            managed: false,
-            require_colons: true,
-            roles: vec![],
-        })
-        .build();
-    let content_mentions = MessageBuilder::new()
-        .channel(1)
-        .mention(&UserId(2))
-        .role(3)
-        .user(4)
-        .build();
-    assert_eq!(content_mentions, "<#1><@2><@&3><@4>");
-    assert_eq!(content_emoji, "<:Rohrkatze:32>");
-}
-
-#[test]
-fn content() {
-    let content = Bold + Italic + Code + "Fun!";
-
-    assert_eq!(content.to_string(), "***`Fun!`***");
-}
-
-#[test]
-fn message_content() {
-    let message_content = MessageBuilder::new()
-        .push(Bold + Italic + Code + "Fun!")
-        .build();
-
-    assert_eq!(message_content, "***`Fun!`***");
-}
-
-#[test]
-fn message_content_safe() {
-    let message_content = MessageBuilder::new()
-        .push_safe(Bold + Italic + "test**test")
-        .build();
-
-    assert_eq!(message_content, "***test\\*\\*test***");
-}
diff --git a/tests/test_parsers.rs b/tests/test_parsers.rs
deleted file mode 100644
index eddad53..0000000
--- a/tests/test_parsers.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-#![cfg(feature = "utils")]
-
-extern crate serenity;
-
-use serenity::utils::*;
-
-#[test]
-fn invite_parser() {
-    assert_eq!(parse_invite("https://discord.gg/abc"), "abc");
-    assert_eq!(parse_invite("http://discord.gg/abc"), "abc");
-    assert_eq!(parse_invite("discord.gg/abc"), "abc");
-}
-
-#[test]
-fn username_parser() {
-    assert_eq!(parse_username("<@12345>").unwrap(), 12_345);
-    assert_eq!(parse_username("<@!12345>").unwrap(), 12_345);
-}
-
-#[test]
-fn role_parser() {
-    assert_eq!(parse_role("<@&12345>").unwrap(), 12_345);
-}
-
-#[test]
-fn channel_parser() {
-    assert_eq!(parse_channel("<#12345>").unwrap(), 12_345);
-}
-
-#[test]
-fn emoji_parser() {
-    let emoji = parse_emoji("<:name:12345>").unwrap();
-    assert_eq!(emoji.name, "name");
-    assert_eq!(emoji.id, 12_345);
-}
-
-#[test]
-fn quote_parser() {
-    let parsed = parse_quotes("a \"b c\" d\"e f\"  g");
-    assert_eq!(parsed, ["a", "b c", "d", "e f", "g"]);
-}
diff --git a/tests/test_user.rs b/tests/test_user.rs
deleted file mode 100644
index 267b578..0000000
--- a/tests/test_user.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-extern crate serenity;
-
-#[cfg(feature = "model")]
-mod model {
-    use serenity::model::id::UserId;
-    use serenity::model::user::User;
-
-    fn gen() -> User {
-        User {
-            id: UserId(210),
-            avatar: Some("abc".to_string()),
-            bot: true,
-            discriminator: 1432,
-            name: "test".to_string(),
-        }
-    }
-
-    #[test]
-    fn test_core() {
-        let mut user = gen();
-
-        assert!(
-            user.avatar_url()
-                .unwrap()
-                .ends_with("/avatars/210/abc.webp?size=1024",)
-        );
-        assert!(
-            user.static_avatar_url()
-                .unwrap()
-                .ends_with("/avatars/210/abc.webp?size=1024",)
-        );
-
-        user.avatar = Some("a_aaa".to_string());
-        assert!(
-            user.avatar_url()
-                .unwrap()
-                .ends_with("/avatars/210/a_aaa.gif?size=1024",)
-        );
-        assert!(
-            user.static_avatar_url()
-                .unwrap()
-                .ends_with("/avatars/210/a_aaa.webp?size=1024",)
-        );
-
-        user.avatar = None;
-        assert!(user.avatar_url().is_none());
-
-        assert_eq!(user.tag(), "test#1432");
-    }
-
-    #[test]
-    fn default_avatars() {
-        let mut user = gen();
-
-        user.discriminator = 0;
-        assert!(user.default_avatar_url().ends_with("0.png"));
-        user.discriminator = 1;
-        assert!(user.default_avatar_url().ends_with("1.png"));
-        user.discriminator = 2;
-        assert!(user.default_avatar_url().ends_with("2.png"));
-        user.discriminator = 3;
-        assert!(user.default_avatar_url().ends_with("3.png"));
-        user.discriminator = 4;
-        assert!(user.default_avatar_url().ends_with("4.png"));
-    }
-}
diff --git a/tests/test_utils.rs b/tests/test_utils.rs
deleted file mode 100644
index d5dac6d..0000000
--- a/tests/test_utils.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-#![cfg(feature = "utils")]

-

-extern crate serenity;

-

-use serenity::utils::*;

-

-#[test]

-fn test_is_nsfw() {

-    assert!(!is_nsfw("general"));

-    assert!(is_nsfw("nsfw"));

-    assert!(is_nsfw("nsfw-test"));

-    assert!(!is_nsfw("nsfw-"));

-    assert!(!is_nsfw("général"));

-    assert!(is_nsfw("nsfw-général"));

-}