public async Task GetWarzoneMatchDetails_IsSerializable(string guid)
        {
            var query = new GetWarzoneMatchDetails()
                        .ForMatchId(new Guid(guid))
                        .SkipCache();

            var result = await Global.Session.Query(query);

            SerializationUtility <WarzoneMatch> .AssertRoundTripSerializationIsPossible(result);
        }
        public async Task GetFlexibleStats_IsSerializable()
        {
            var query = new GetFlexibleStats()
                .SkipCache();

            var result = await Global.Session.Query(query);

            var serializationUtility = new SerializationUtility<List<FlexibleStat>>();
            serializationUtility.AssertRoundTripSerializationIsPossible(result);
        }
        public async Task GetCampaignMatchDetails_IsSerializable(string guid)
        {
            var query = new GetCampaignMatchDetails()
                .ForMatchId(new Guid(guid));

            var result = await Global.Session.Query(query);

            var serializationUtility = new SerializationUtility<CampaignMatch>();
            serializationUtility.AssertRoundTripSerializationIsPossible(result);
        }
        [TestCase("5f96269a-58f8-473e-9897-42a4deb1bf09")] //Bronze
        public async Task GetRequisitionPack_IsSerializable(string guid)
        {
            var query = new GetRequisitionPack()
                        .ForRequisitionPackId(new Guid(guid))
                        .SkipCache();

            var result = await Global.Session.Query(query);

            SerializationUtility <RequisitionPack> .AssertRoundTripSerializationIsPossible(result);
        }
        public async Task GetCompetitiveSkillRankDesignations_IsSerializable()
        {
            var query = new GetCompetitiveSkillRankDesignations()
                .SkipCache();

            var result = await Global.Session.Query(query);

            var serializationUtility = new SerializationUtility<List<CompetitiveSkillRankDesignation>>();
            serializationUtility.AssertRoundTripSerializationIsPossible(result);
        }
Beispiel #6
0
        public async Task GetEmblemImage_IsSerializable(string gamertag)
        {
            var query = new GetEmblemImage()
                        .ForPlayer(gamertag)
                        .SkipCache();

            var result = await Global.Session.Query(query);

            SerializationUtility <GetImage> .AssertRoundTripSerializationIsPossible(result);
        }
Beispiel #7
0
        public async Task GetCampaignServiceRecord_IsSerializable(string gamertag)
        {
            var query = new GetCampaignServiceRecord()
                        .ForPlayer(gamertag)
                        .SkipCache();

            var result = await Global.Session.Query(query);

            SerializationUtility <CampaignServiceRecord> .AssertRoundTripSerializationIsPossible(result);
        }
        public async Task ListGameVariants_IsSerializable(string gamertag)
        {
            var query = new ListGameVariants()
                        .ForPlayer(gamertag)
                        .SkipCache();

            var result = await Global.Session.Query(query);

            SerializationUtility <GameVariantResult> .AssertRoundTripSerializationIsPossible(result);
        }
        public async Task GetCustomServiceRecord_IsSerializable(string gamertag)
        {
            var query = new GetCustomServiceRecord()
                .ForPlayer(gamertag);

            var result = await Global.Session.Query(query);

            var serializationUtility = new SerializationUtility<CustomServiceRecord>();
            serializationUtility.AssertRoundTripSerializationIsPossible(result);
        }
Beispiel #10
0
        public async Task GetGameVariant_IsSerializable(string guid)
        {
            var query = new GetGameVariant()
                        .ForGameVariantId(new Guid(guid))
                        .SkipCache();

            var result = await Global.Session.Query(query);

            SerializationUtility <GameVariant> .AssertRoundTripSerializationIsPossible(result);
        }
        public async Task GetGameVariant_IsSerializable(string guid)
        {
            var query = new GetGameVariant()
                .ForGameVariantId(new Guid(guid))
                .SkipCache();

            var result = await Global.Session.Query(query);

            var serializationUtility = new SerializationUtility<GameVariant>();
            serializationUtility.AssertRoundTripSerializationIsPossible(result);
        }
Beispiel #12
0
        public async Task GetSpartanCompany_IsSerializable(string companyID)
        {
            Guid companyId = new Guid(companyID);

            var query = new GetSpartanCompany(companyId)
                        .SkipCache();

            var result = await Global.Session.Query(query);

            SerializationUtility <SpartanCompany> .AssertRoundTripSerializationIsPossible(result);
        }
        public async Task GetMatchEvents_IsSerializable(string guid)
        {
            var matchId = new Guid(guid);

            var query = new GetMatchEvents(matchId)
                        .SkipCache();

            var result = await Global.Session.Query(query);

            SerializationUtility <MatchEventSummary> .AssertRoundTripSerializationIsPossible(result);
        }
        public async Task GetPlaylistRatings_IsSerializable(string guid, string gamertag)
        {
            var playlistId = new Guid(guid);

            var query = new GetPlaylistRatings(gamertag, playlistId)
                        .SkipCache();

            var result = await Global.Session.Query(query);

            SerializationUtility <PlaylistSummaryResultSet> .AssertRoundTripSerializationIsPossible(result);
        }
        public async Task GetRequisitionPack_IsSerializable(string guid)
        {
            var query = new GetRequisitionPack()
                .ForRequisitionPackId(new Guid(guid))
                .SkipCache();

            var result = await Global.Session.Query(query);

            var serializationUtility = new SerializationUtility<RequisitionPack>();
            serializationUtility.AssertRoundTripSerializationIsPossible(result);
        }
Beispiel #16
0
        public async Task GetLeaderboard_IsSerializable(string seasonId, string playlistId)
        {
            var query = new GetLeaderboard()
                        .ForSeasonId(new Guid(seasonId))
                        .ForPlaylistId(new Guid(playlistId))
                        .SkipCache();

            var result = await Global.Session.Query(query);

            SerializationUtility <Leaderboard> .AssertRoundTripSerializationIsPossible(result);
        }
Beispiel #17
0
        public async Task GetSpartanImage_IsSerializable(string gamertag, int size, Enumeration.Halo5.CropType crop)
        {
            var query = new GetSpartanImage(gamertag)
                        .Size(size)
                        .Crop(crop)
                        .SkipCache();

            var result = await Global.Session.Query(query);

            SerializationUtility <HaloImage> .AssertRoundTripSerializationIsPossible(result);
        }
        public async Task GetSeasonSummary_IsSerializable(string guid, string gamertag)
        {
            var seasonId = new Guid(guid);

            var query = new GetSeasonSummary(gamertag, seasonId)
                        .SkipCache();

            var result = await Global.Session.Query(query);

            SerializationUtility <SeasonSummary> .AssertRoundTripSerializationIsPossible(result);
        }
        public async Task GetSpartanImage_IsSerializable(string gamertag)
        {
            var query = new GetSpartanImage()
                .ForPlayer(gamertag);

            var result = await Global.Session.Query(query);

            var serializationUtility = new SerializationUtility<GetImage>();
            serializationUtility.AssertRoundTripSerializationIsPossible(result);
        }