public void GetPreferences()
        {
            TestWrapper(async(MixerConnection connection) =>
            {
                ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);

                ChannelPreferencesModel preference = await connection.Channels.GetPreferences(channel);

                Assert.IsNotNull(preference);

                preference.linksClickable = !preference.linksClickable;

                ChannelPreferencesModel newPreferences = await connection.Channels.UpdatePreferences(channel, preference);

                Assert.IsNotNull(newPreferences);
                Assert.AreEqual(preference.linksClickable, newPreferences.linksClickable);

                preference.linksClickable = !preference.linksClickable;

                newPreferences = await connection.Channels.UpdatePreferences(channel, preference);

                Assert.IsNotNull(newPreferences);
                Assert.AreEqual(preference.linksClickable, newPreferences.linksClickable);
            });
        }
 public void GetChannelForUser()
 {
     TestWrapper(async(MixerConnection connection) =>
     {
         ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);
     });
 }
        public void CreateGetUpdateDeleteGame()
        {
            TestWrapper(async (MixerConnection connection) =>
            {
                ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);

                MixPlayGameListingModel gameListing = await MixPlayServiceUnitTests.CreateTestGame(connection, channel);

                IEnumerable<MixPlayGameListingModel> games = await connection.MixPlay.GetOwnedMixPlayGames(channel);

                Assert.IsNotNull(games);
                Assert.IsTrue(games.Count() > 0);
                Assert.IsTrue(games.Any(g => g.id.Equals(gameListing.id)));

                string gameName = gameListing.name = "Test Game";
                MixPlayGameModel game = await connection.MixPlay.UpdateMixPlayGame(gameListing);

                Assert.IsNotNull(game);
                Assert.IsTrue(game.id > 0);
                Assert.AreEqual(game.name, gameName);

                await MixPlayServiceUnitTests.DeleteTestGame(connection, game);

                games = await connection.MixPlay.GetOwnedMixPlayGames(channel);

                Assert.IsNotNull(games);
                Assert.IsFalse(games.Any(g => g.id.Equals(game.id)));
            });
        }
        public void UpdateUserRoles()
        {
            TestWrapper(async(MixerConnection connection) =>
            {
                ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);

                UserModel user = await connection.Users.GetUser("ChannelOne");

                Assert.IsNotNull(user);

                bool result = await connection.Channels.UpdateUserRoles(channel, user, new List <string>()
                {
                    "Mod"
                }, null);

                Assert.IsTrue(result);

                IEnumerable <UserWithGroupsModel> userRoles = await connection.Channels.GetUsersWithRoles(channel, "Mod");

                Assert.IsNotNull(userRoles);
                Assert.IsTrue(userRoles.Any(ug => ug.username.Equals("ChannelOne")));

                result = await connection.Channels.UpdateUserRoles(channel, user, null, new List <string>()
                {
                    "Mod"
                });

                Assert.IsTrue(result);

                userRoles = await connection.Channels.GetUsersWithRoles(channel, "Mod");

                Assert.IsNotNull(userRoles);
                Assert.IsFalse(userRoles.Any(ug => ug.username.Equals("ChannelOne")));
            });
        }
        public void GetUpdateDiscord()
        {
            TestWrapper(async(MixerConnection connection) =>
            {
                ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);

                DiscordBotModel discord = await connection.Channels.GetDiscord(channel);

                Assert.IsNotNull(discord);
                Assert.IsTrue(discord.id > 0);

                IEnumerable <DiscordChannelModel> channels = await connection.Channels.GetDiscordChannels(channel);

                Assert.IsNotNull(channels);
                Assert.IsTrue(channels.Count() > 0);

                IEnumerable <DiscordRoleModel> roles = await connection.Channels.GetDiscordRoles(channel);

                Assert.IsNotNull(roles);
                Assert.IsTrue(roles.Count() > 0);

                discord = await connection.Channels.UpdateDiscord(channel, discord);

                Assert.IsNotNull(discord);
                Assert.IsTrue(discord.id > 0);
            });
        }
        public static void ClassInitialize(TestContext context)
        {
            TestWrapper(async (MixerConnection connection) =>
            {
                ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);

                testGameListing = await MixPlayServiceUnitTests.CreateTestGame(connection, channel);
            });
        }
        public static async Task <ChannelChatModel> GetChat(MixerConnection connection)
        {
            ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);

            ChannelChatModel chat = await connection.Chats.GetChat(channel);

            Assert.IsNotNull(chat);
            Assert.IsTrue(chat.endpoints.Count() > 0);

            return(chat);
        }
        public void GetHosters()
        {
            TestWrapper(async(MixerConnection connection) =>
            {
                ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);

                IEnumerable <ChannelAdvancedModel> hosters = await connection.Channels.GetHosters(channel, 1);

                Assert.IsNotNull(hosters);
            });
        }
        public void GetEditorMixPlayGames()
        {
            TestWrapper(async (MixerConnection connection) =>
            {
                ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);

                IEnumerable<MixPlayGameListingModel> games = await connection.MixPlay.GetEditorMixPlayGames(channel);

                Assert.IsNotNull(games);
            });
        }
        public void GetAllTimeSparksLeaderboard()
        {
            TestWrapper(async(MixerConnection connection) =>
            {
                ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);

                IEnumerable <SparksLeaderboardModel> leaderboard = await connection.Leaderboards.GetAllTimeSparksLeaderboard(channel);
                Assert.IsNotNull(leaderboard);
                Assert.IsTrue(leaderboard.Count() >= 0);
            });
        }
        public static async Task <UserModel> GetCurrentUser(MixerConnection connection)
        {
            ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);

            PrivatePopulatedUserModel user = await connection.Users.GetCurrentUser();

            Assert.IsNotNull(user);
            Assert.IsTrue(user.id > (uint)0);

            return(user);
        }
Exemplo n.º 12
0
        public static void ClassInitialize(TestContext context)
        {
            TestWrapper(async(MixerConnection connection) =>
            {
                ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);
                chatClient           = await ChatClient.CreateFromChannel(connection, channel);

                Assert.IsTrue(await chatClient.Connect());
                Assert.IsTrue(await chatClient.Authenticate());
            });
        }
        public void GetSubscriberAnalytics()
        {
            TestWrapper(async(MixerConnection connection) =>
            {
                ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);

                IEnumerable <SubscriberAnalyticModel> subscribers = await connection.Channels.GetSubscriberAnalytics(channel, DateTimeOffset.Now.Subtract(TimeSpan.FromDays(7)));

                Assert.IsNotNull(subscribers);
                Assert.IsTrue(subscribers.Count() > 0);
            });
        }
        public void GetFollowers()
        {
            TestWrapper(async(MixerConnection connection) =>
            {
                ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);

                IEnumerable <UserWithChannelModel> users = await connection.Channels.GetFollowers(channel, 1);

                Assert.IsNotNull(users);
                Assert.IsTrue(users.Count() > 0);
            });
        }
Exemplo n.º 15
0
        public static void ClassInitialize(TestContext context)
        {
            TestWrapper(async(MixerConnection connection) =>
            {
                ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);

                gameListing = await MixPlayServiceUnitTests.CreateTestGame(connection, channel);

                client = await MixPlayClient.CreateFromChannel(connection, channel, gameListing);

                Assert.IsTrue(await client.Connect());
                Assert.IsTrue(await client.Ready());
            });
        }
        public void GetChannelEmoticons()
        {
            TestWrapper(async(MixerConnection connection) =>
            {
                ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);
                UserModel user       = await connection.Users.GetCurrentUser();

                Assert.IsNotNull(user);
                Assert.IsTrue(user.id > (uint)0);

                IEnumerable <EmoticonPackModel> emoticonPacks = await connection.Channels.GetEmoticons(channel, user);

                Assert.IsNotNull(emoticonPacks);
            });
        }
        public void GetChannelBroadcast()
        {
            TestWrapper(async(MixerConnection connection) =>
            {
                ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);

                Assert.IsNotNull(channel);
                Assert.IsTrue(channel.id > (uint)0);

                BroadcastModel broadcast = await connection.Channels.GetCurrentBroadcast(channel);

                Assert.IsNotNull(broadcast);
                Assert.AreEqual(channel.id, broadcast.channelId);
            });
        }
        public void GetChannelRecordings()
        {
            TestWrapper(async(MixerConnection connection) =>
            {
                ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);

                Assert.IsNotNull(channel);
                Assert.IsTrue(channel.id > (uint)0);

                IEnumerable <ChannelRecordingModel> recordings = await connection.Channels.GetRecordings(channel);

                Assert.IsNotNull(recordings);
                Assert.IsTrue(recordings.Count() > 0);
            });
        }
        public void UpdateChannel()
        {
            TestWrapper(async(MixerConnection connection) =>
            {
                ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);

                string newName = "Test Name";
                channel.name   = newName;

                channel = await connection.Channels.UpdateChannel(channel);

                Assert.IsNotNull(channel);
                Assert.IsTrue(string.Equals(channel.name, newName));
            });
        }
Exemplo n.º 20
0
        public void LiveSubscribeAndUnsubscribe()
        {
            this.ConstellationWrapper(async(MixerConnection connection, ConstellationClient constellationClient) =>
            {
                ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);

                this.ClearPackets();

                ConstellationEventType eventType = new ConstellationEventType(ConstellationEventTypeEnum.channel__id__update, channel.id);
                Assert.IsTrue(await constellationClient.SubscribeToEventsWithResponse(new List <ConstellationEventType>()
                {
                    eventType
                }));

                this.ClearPackets();

                bool eventReceived = false;
                constellationClient.OnSubscribedEventOccurred += (sender, le) =>
                {
                    if (le.channel.Equals(eventType.ToString()))
                    {
                        eventReceived = true;
                    }
                };

                string newName = "Test Name - " + DateTimeOffset.Now;
                channel.name   = newName;

                channel = await connection.Channels.UpdateChannel(channel);

                Assert.IsNotNull(channel);
                Assert.IsTrue(string.Equals(channel.name, newName));

                this.ClearPackets();

                await Task.Delay(5000);

                if (!eventReceived)
                {
                    Assert.Fail("Did not get live event for channel updating");
                }

                Assert.IsTrue(await constellationClient.UnsubscribeToEventsWithResponse(new List <ConstellationEventType>()
                {
                    eventType
                }));
            });
        }
        public void GetMixPlayVersion()
        {
            TestWrapper(async (MixerConnection connection) =>
            {
                ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);

                IEnumerable<MixPlayGameListingModel> games = await connection.MixPlay.GetOwnedMixPlayGames(channel);

                Assert.IsNotNull(games);
                Assert.IsTrue(games.Count() > 0);

                MixPlayGameVersionModel version = await connection.MixPlay.GetMixPlayGameVersion(games.First().versions.First());

                Assert.IsNotNull(version);
            });
        }
        public void GetUsers()
        {
            TestWrapper(async(MixerConnection connection) =>
            {
                ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);

                IEnumerable <ChatUserModel> users = await connection.Chats.GetUsers(channel);

                Assert.IsNotNull(users);

                if (users.Count() > 0)
                {
                    ChatUserModel user = await connection.Chats.GetUser(channel, users.First().userId.GetValueOrDefault());
                }
            });
        }
        public void GetUserFanProgression()
        {
            TestWrapper(async(MixerConnection connection) =>
            {
                ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);

                IEnumerable <UserWithGroupsModel> users = await connection.Channels.GetUsersWithRoles(channel, 1);

                Assert.IsNotNull(users);
                Assert.IsTrue(users.Count() > 0);

                UserFanProgressionModel userFanProgression = await connection.Channels.GetUserFanProgression(channel, users.First());

                Assert.IsNotNull(userFanProgression);
                Assert.AreEqual(userFanProgression.userId, users.First().id);
            });
        }
        public void CheckIfUsersHaveRole()
        {
            TestWrapper(async(MixerConnection connection) =>
            {
                ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);

                UserModel modUser    = await connection.Users.GetUser("SXTBot");
                UserModel notModUser = await connection.Users.GetUser("ChannelOne");

                Dictionary <uint, DateTimeOffset?> usersWithRole = await connection.Channels.CheckIfUsersHaveRole(channel, new List <UserModel>()
                {
                    modUser, notModUser
                }, "Mod");
                Assert.IsNotNull(usersWithRole);
                Assert.IsTrue(usersWithRole.Count == 1);
                Assert.IsNotNull(usersWithRole.ContainsKey(modUser.id));
            });
        }
        public void CheckGetDiscordInvite()
        {
            TestWrapper(async(MixerConnection connection) =>
            {
                ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);

                UserModel user = await connection.Users.GetCurrentUser();

                bool result = await connection.Channels.CanUserGetDiscordInvite(channel, user);

                Assert.IsTrue(result);

                string invite = await connection.Channels.GetUserDiscordInvite(channel, user);

                Assert.IsNotNull(invite);
                Assert.IsTrue(invite.Length > 0);
            });
        }
        public void UpdateChannelGame()
        {
            TestWrapper(async(MixerConnection connection) =>
            {
                ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);

                string gameName = "Fortnite";
                IEnumerable <GameTypeSimpleModel> games = await connection.GameTypes.GetGameTypes(gameName);

                Assert.IsNotNull(games);
                Assert.IsTrue(games.Count() > 0);
                Assert.IsTrue(games.Any(gt => gt.name.Equals(gameName)));

                channel.typeId = games.First().id;

                channel = await connection.Channels.UpdateChannel(channel);

                Assert.IsNotNull(channel);
                Assert.IsTrue(channel.typeId == games.First().id);
            });
        }
        public void HostGetUnhostChannel()
        {
            TestWrapper(async(MixerConnection connection) =>
            {
                ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);

                ChannelModel hostChannel = await connection.Channels.GetChannel("MonsterCat");

                channel = await connection.Channels.SetHostChannel(channel, hostChannel);

                Assert.IsNotNull(channel);

                ChannelModel hostedChannel = await connection.Channels.GetHostedChannel(channel);

                Assert.IsNotNull(hostedChannel);
                Assert.AreEqual(hostChannel.id, hostedChannel.id);

                bool result = await connection.Channels.UnhostChannel(channel);

                Assert.IsTrue(result);
            });
        }
        public void GetUsersWithRoles()
        {
            TestWrapper(async(MixerConnection connection) =>
            {
                ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);

                IEnumerable <UserWithGroupsModel> users = await connection.Channels.GetUsersWithRoles(channel, 1);

                Assert.IsNotNull(users);
                Assert.IsTrue(users.Count() > 0);

                users = await connection.Channels.GetUsersWithRoles(channel, "mod", 1);

                Assert.IsNotNull(users);
                Assert.IsTrue(users.Count() > 0);

                UserWithGroupsModel user = await connection.Channels.GetUser(channel, users.First().id);

                Assert.IsNotNull(user);
                Assert.IsTrue(user.id > 0);
            });
        }
        public void CheckIfFollows()
        {
            TestWrapper(async(MixerConnection connection) =>
            {
                ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);

                IEnumerable <UserWithChannelModel> followedUsers = await connection.Channels.GetFollowers(channel, 1);
                Assert.IsNotNull(followedUsers);
                Assert.IsTrue(followedUsers.Count() > 0);

                UserModel notFollowedUser = await connection.Users.GetUser("ChannelOne");
                Assert.IsNotNull(notFollowedUser);

                Dictionary <uint, DateTimeOffset?> follows = await connection.Channels.CheckIfFollows(channel, new List <UserModel>()
                {
                    followedUsers.First(), notFollowedUser
                });
                Assert.IsNotNull(follows);
                Assert.IsTrue(follows.Count == 2);
                Assert.IsNotNull(follows[followedUsers.First().id]);
                Assert.IsNull(follows[notFollowedUser.id]);
            });
        }
        public void GetUsersProcessor()
        {
            TestWrapper(async(MixerConnection connection) =>
            {
                ChannelModel channel = await ChannelsServiceUnitTests.GetChannel(connection);

                List <ChatUserModel> users = new List <ChatUserModel>();
                await connection.Chats.GetUsers(channel, (results) =>
                {
                    foreach (ChatUserModel result in results)
                    {
                        users.Add(result);
                    }
                    return(Task.FromResult(0));
                });

                Assert.IsNotNull(users);

                if (users.Count() > 0)
                {
                    ChatUserModel user = await connection.Chats.GetUser(channel, users.First().userId.GetValueOrDefault());
                }
            });
        }