public void GetConstructedUri_NoParameters_MatchesExpected()
{
var query = new GetGameVariant();
var uri = query.GetConstructedUri();
Assert.AreEqual($"ugc/h5/players/{null}/gamevariants/{null}", uri);
}
public async Task GetGameVariant_InvalidGamertag(string gamertag, string guid)
{
var query = new GetGameVariant(gamertag, new Guid(guid));
await Global.Session.Query(query);
Assert.Fail("An exception should have been thrown");
}
public void GetConstructedUri_NoParameters_MatchesExpected()
{
var query = new GetGameVariant();
var uri = query.GetConstructedUri();
Assert.AreEqual("metadata/h5/metadata/game-variants/", uri);
}
public void GetConstructedUri_NoParameters_MatchesExpected()
{
var query = new GetGameVariant();
var uri = query.GetConstructedUri();
Assert.AreEqual("metadata/h5/metadata/game-variants/", uri);
}
public void GetConstructedUri_NoParamaters_MatchesExpected()
{
var query = new GetGameVariant();
var uri = query.GetConstructedUri();
Assert.AreEqual(BaseUri, uri);
}
public void GetConstructedUri_NoParameters_MatchesExpected()
{
var query = new GetGameVariant();
var uri = query.GetConstructedUri();
Assert.AreEqual($"ugc/h5/players/{null}/gamevariants/{null}", uri);
}
public async Task GetGameVariant_MissingGameVariantId()
{
var query = new GetGameVariant()
.ForPlayer("Player");
await Global.Session.Query(query);
Assert.Fail("An exception should have been thrown");
}
public async Task GetGameVariant_IsSerializable(string gamertag, string guid)
{
var query = new GetGameVariant(gamertag, new Guid(guid))
.SkipCache();
var result = await Global.Session.Query(query);
SerializationUtility <GameVariant> .AssertRoundTripSerializationIsPossible(result);
}
public void GetConstructedUri_ForGameVariantId_MatchesExpected(string guid)
{
var query = new GetGameVariant()
.ForGameVariantId(new Guid(guid));
var uri = query.GetConstructedUri();
Assert.AreEqual($"metadata/h5/metadata/game-variants/{guid}", uri);
}
public async Task Query_DoesNotThrow()
{
var query = new GetGameVariant();
var result = await _mockSession.Query(query);
Assert.IsInstanceOf(typeof(GameVariant), result);
Assert.AreEqual(_gameVariant, result);
}
public void GetConstructedUri_InGameMode_MatchesExpected(string guid)
{
var query = new GetGameVariant()
.ForGameVariantId(new Guid(guid));
var uri = query.GetConstructedUri();
Assert.AreEqual($"ugc/h5/players/{null}/gamevariants/{guid}", uri);
}
public void GetConstructedUri_ForPlayer_MatchesExpected(string gamertag)
{
var query = new GetGameVariant()
.ForPlayer(gamertag);
var uri = query.GetConstructedUri();
Assert.AreEqual($"ugc/h5/players/{gamertag}/gamevariants/{null}", uri);
}
public void GetConstructedUri_InGameMode_MatchesExpected(string guid)
{
var query = new GetGameVariant()
.ForGameVariantId(new Guid(guid));
var uri = query.GetConstructedUri();
Assert.AreEqual($"ugc/h5/players/{null}/gamevariants/{guid}", uri);
}
public void GetConstructedUri_ForPlayer_MatchesExpected(string gamertag)
{
var query = new GetGameVariant()
.ForPlayer(gamertag);
var uri = query.GetConstructedUri();
Assert.AreEqual($"ugc/h5/players/{gamertag}/gamevariants/{null}", uri);
}
public async Task GetGameVariant_MissingGuid()
{
var query = new GetGameVariant()
.SkipCache();
await Global.Session.Query(query);
Assert.Fail("An exception should have been thrown");
}
public async Task GetGameVariant_DoesNotThrow(string gamertag, string guid)
{
var query = new GetGameVariant(gamertag, new Guid(guid))
.SkipCache();
var result = await Global.Session.Query(query);
Assert.IsInstanceOf(typeof(GameVariant), result);
}
public async Task Query_DoesNotThrow(string guid)
{
var query = new GetGameVariant(new Guid(guid));
var result = await _mockSession.Query(query);
Assert.IsInstanceOf(typeof(GameVariant), result);
Assert.AreEqual(_gameVariant, result);
}
public void GetConstructedUri_ForGameVariantId_MatchesExpected(string guid)
{
var query = new GetGameVariant()
.ForGameVariantId(new Guid(guid));
var uri = query.GetConstructedUri();
Assert.AreEqual($"metadata/h5/metadata/game-variants/{guid}", uri);
}
public async Task Query_DoesNotThrow()
{
var query = new GetGameVariant()
.ForGameVariantId(Guid.Empty);
var result = await _mockSession.Query(query);
Assert.IsInstanceOf(typeof(GameVariant), result);
Assert.AreEqual(_gameVariant, result);
}
public void GetConstructedUri_Complex_MatchesExpected(string gamertag, string guid)
{
var query = new GetGameVariant()
.ForPlayer(gamertag)
.ForGameVariantId(new Guid(guid));
var uri = query.GetConstructedUri();
Assert.AreEqual($"ugc/h5/players/{gamertag}/gamevariants/{guid}", uri);
}
public async Task GetGameVariant_DoesNotThrow(string guid)
{
var query = new GetGameVariant()
.ForGameVariantId(new Guid(guid))
.SkipCache();
var result = await Global.Session.Query(query);
Assert.IsInstanceOf(typeof(GameVariant), result);
}
public void GetConstructedUri_Complex_MatchesExpected(string gamertag, string guid)
{
var query = new GetGameVariant()
.ForPlayer(gamertag)
.ForGameVariantId(new Guid(guid));
var uri = query.GetConstructedUri();
Assert.AreEqual($"ugc/h5/players/{gamertag}/gamevariants/{guid}", uri);
}
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);
}
public async Task Query_DoesNotThrow(string gamertag, string guid)
{
var query = new GetGameVariant()
.ForPlayer(gamertag)
.ForGameVariantId(new Guid(guid))
.SkipCache();
var result = await _mockSession.Query(query);
Assert.IsInstanceOf(typeof(GameVariant), result);
Assert.AreEqual(_gameVariant, result);
}
public static void Validate(this GetGameVariant getGameVariant)
{
var validationResult = new ValidationResult();
if (string.IsNullOrWhiteSpace(getGameVariant.Id))
{
validationResult.Messages.Add("GetGameVariant query requires a GameVariantId to be set.");
}
if (!validationResult.Success)
{
throw new ValidationException(validationResult.Messages);
}
}
public async Task GetGameVariant_SchemaIsValid(string gamertag, string guid)
{
var weaponsSchema = JSchema.Parse(File.ReadAllText(Halo5Config.UserGeneratedContentGameVariantJsonSchemaPath), new JSchemaReaderSettings
{
Resolver = new JSchemaUrlResolver(),
BaseUri = new Uri(Path.GetFullPath(Halo5Config.UserGeneratedContentGameVariantJsonSchemaPath))
});
var query = new GetGameVariant(gamertag, new Guid(guid))
.SkipCache();
var jArray = await Global.Session.Get <JObject>(query.Uri);
SchemaUtility.AssertSchemaIsValid(weaponsSchema, jArray);
}
public async Task GetGameVariant_SchemaIsValid(string guid)
{
var gameVariantSchema = JSchema.Parse(File.ReadAllText(Config.GameVariantJsonSchemaPath), new JSchemaReaderSettings
{
Resolver = new JSchemaUrlResolver(),
BaseUri = new Uri(Path.GetFullPath(Config.GameVariantJsonSchemaPath))
});
var query = new GetGameVariant()
.ForGameVariantId(new Guid(guid))
.SkipCache();
var jArray = await Global.Session.Get <JObject>(query.GetConstructedUri());
SchemaUtility.AssertSchemaIsValid(gameVariantSchema, jArray);
}
public async Task GetGameVariant_ModelMatchesSchema(string gamertag, string guid)
{
var schema = JSchema.Parse(File.ReadAllText(Halo5Config.UserGeneratedContentGameVariantJsonSchemaPath), new JSchemaReaderSettings
{
Resolver = new JSchemaUrlResolver(),
BaseUri = new Uri(Path.GetFullPath(Halo5Config.UserGeneratedContentGameVariantJsonSchemaPath))
});
var query = new GetGameVariant(gamertag, new Guid(guid))
.SkipCache();
var result = await Global.Session.Query(query);
var json = JsonConvert.SerializeObject(result);
var jContainer = JsonConvert.DeserializeObject <JObject>(json);
SchemaUtility.AssertSchemaIsValid(schema, jContainer);
}
public async Task GetGameVariant_MissingGuid()
{
var query = new GetGameVariant()
.SkipCache();
try
{
await Session.Query(query);
Assert.Fail("An exception should have been thrown");
}
catch (HaloApiException e)
{
Assert.AreEqual((int) Enumeration.StatusCode.NotFound, e.HaloApiError.StatusCode);
}
catch (System.Exception e)
{
Assert.Fail("Unexpected exception of type {0} caught: {1}", e.GetType(), e.Message);
}
}
public async Task GetGameVariant_InvalidGuid()
{
var query = new GetGameVariant(Guid.NewGuid())
.SkipCache();
try
{
await Global.Session.Query(query);
Assert.Fail("An exception should have been thrown");
}
catch (HaloApiException e)
{
Assert.AreEqual((int)Enumeration.Halo5.StatusCode.NotFound, e.HaloApiError.StatusCode);
}
catch (System.Exception e)
{
Assert.Fail("Unexpected exception of type {0} caught: {1}", e.GetType(), e.Message);
}
}
public async Task <GameVariant> GetGameVariant(Guid id)
{
if (id == Guid.Empty)
{
return(null);
}
var data = await _db.FindAsync <GameVariantData>(id.ToString());
if (data == null)
{
var query = new GetGameVariant().ForGameVariantId(id);
var item = await _session.Query(query);
if (item == null)
{
return(null);
}
data = new GameVariantData(id, item);
_db.InsertAsync(data);
return(item);
}
return(data.Deserialize());
}
public async Task GetGameVariant_SchemaIsValid(string guid)
{
var gameVariantSchema = JSchema.Parse(File.ReadAllText(Config.GameVariantJsonSchemaPath), new JSchemaReaderSettings
{
Resolver = new JSchemaUrlResolver(),
BaseUri = new Uri(Path.GetFullPath(Config.GameVariantJsonSchemaPath))
});
var query = new GetGameVariant()
.ForGameVariantId(new Guid(guid))
.SkipCache();
var jArray = await Global.Session.Get<JObject>(query.GetConstructedUri());
SchemaUtility.AssertSchemaIsValid(gameVariantSchema, jArray);
}
public async Task GetGameVariant_InvalidGamertag(string gamertag)
{
var query = new GetGameVariant()
.ForPlayer(gamertag);
await Global.Session.Query(query);
Assert.Fail("An exception should have been thrown");
}
public async Task GetGameVariant_MissingGameVariantId()
{
var query = new GetGameVariant()
.ForPlayer("Player");
await Global.Session.Query(query);
Assert.Fail("An exception should have been thrown");
}
public async Task Query_DoesNotThrow(string gamertag, string guid)
{
var query = new GetGameVariant()
.ForPlayer(gamertag)
.ForGameVariantId(new Guid(guid))
.SkipCache();
var result = await _mockSession.Query(query);
Assert.IsInstanceOf(typeof(GameVariant), result);
Assert.AreEqual(_gameVariant, result);
}
public async Task GetGameVariant_MissingGuid()
{
var query = new GetGameVariant()
.SkipCache();
await Global.Session.Query(query);
Assert.Fail("An exception should have been thrown");
}
public async Task GetGameVariant_ModelMatchesSchema(string guid)
{
var schema = JSchema.Parse(File.ReadAllText(Config.GameVariantJsonSchemaPath), new JSchemaReaderSettings
{
Resolver = new JSchemaUrlResolver(),
BaseUri = new Uri(Path.GetFullPath(Config.GameVariantJsonSchemaPath))
});
var query = new GetGameVariant()
.ForGameVariantId(new Guid(guid))
.SkipCache();
var result = await Global.Session.Query(query);
var json = JsonConvert.SerializeObject(result);
var jContainer = JsonConvert.DeserializeObject<JContainer>(json);
SchemaUtility.AssertSchemaIsValid(schema, jContainer);
}
public void Uri_MatchesExpected(string guid)
{
var query = new GetGameVariant(new Guid(guid));
Assert.AreEqual($"https://www.haloapi.com/metadata/h5/metadata/game-variants/{guid}", query.Uri);
}
public void Uri_MatchesExpected(string gamertag, string guid)
{
var query = new GetGameVariant(gamertag, new Guid(guid));
Assert.AreEqual($"https://www.haloapi.com/ugc/h5/players/{gamertag}/gamevariants/{guid}", query.Uri);
}
