public void ItUsesSandboxDuringFinalization()
{
Env.Set("STEAM_USE_MICROTRANSACTION_SANDBOX", true);
var transaction = new SteamTransactionEntity {
state = SteamTransactionEntity.InitiatedState
};
transaction.Save();
Http.Fake(Http.Response(new JsonObject {
["response"] = new JsonObject {
["result"] = "OK",
["params"] = new JsonObject {
["orderid"] = transaction.orderId,
["transid"] = transaction.transactionId
}
}
}, 200));
OnFacet <SteamPurchasingServerFacet> .CallSync <SteamTransactionEntity>(
nameof(SteamPurchasingServerFacet.FinalizeTransaction),
transaction.orderId,
true
);
Http.AssertSent(request =>
request.Url ==
"http://api.steam.com/ISteamMicroTxnSandbox/FinalizeTxn/v2/"
);
}
public void ItRejectsLoginWithInvalidToken()
{
Env.Set("STEAM_API_URL", "https://partner.steam-api.com/");
Env.Set("STEAM_PUBLISHER_KEY", "some-publisher-key");
Env.Set("STEAM_APP_ID", "480");
Http.Fake(Http.Response(new JsonObject {
["response"] = new JsonObject {
["error"] = new JsonObject {
["errorcode"] = 3,
["errordesc"] = "Invalid parameter"
}
}
}));
Assert.Catch <AuthException>(() => {
OnFacet <SteamLoginFacet> .CallSync(
nameof(SteamLoginFacet.Login),
"some-invalid-session-token"
);
}, "Invalid session token.");
Http.AssertSent(request =>
request.Url == "https://partner.steam-api.com/" +
"ISteamUserAuth/AuthenticateUserTicket/v1/?" +
"key=some-publisher-key&" +
"appid=480&" +
"ticket=some-invalid-session-token"
);
}
public void ItUsesSandboxDuringInitiation()
{
Env.Set("STEAM_USE_MICROTRANSACTION_SANDBOX", true);
var transaction = new SteamTransactionEntity {
playerSteamId = 123456789L
};
transaction.AddProduct <ExampleVirtualProduct>();
Http.Fake(Http.Response(new JsonObject {
["response"] = new JsonObject {
["result"] = "OK",
["params"] = new JsonObject {
["orderid"] = transaction.orderId,
["transid"] = "11122233"
}
}
}, 200));
OnFacet <SteamPurchasingServerFacet> .CallSync(
nameof(SteamPurchasingServerFacet.InitiateTransaction),
transaction
);
Http.AssertSent(request =>
request.Url ==
"http://api.steam.com/ISteamMicroTxnSandbox/InitTxn/v3/"
);
}
public void EmailCanBeTaken()
{
var player = new PlayerEntity {
email = "*****@*****.**",
password = "******"
};
player.Save();
var response = OnFacet <EmailRegisterFacet> .CallSync <EmailRegisterResponse>(
nameof(EmailRegisterFacet.Register),
"*****@*****.**",
"password"
);
Assert.AreEqual(EmailRegisterResponse.EmailTaken, response);
Assert.AreEqual(
1,
DB.TakeAll <PlayerEntity>().Get().Count
);
player.Refresh();
Assert.AreEqual("*****@*****.**", player.email);
Assert.AreEqual("secret", player.password);
}
public void LoginUpdatesTimestamp()
{
var player = new PlayerEntity {
steamId = "123456789"
};
player.Save();
Http.Fake(Http.Response(new JsonObject {
["response"] = new JsonObject {
["params"] = new JsonObject {
["result"] = "OK",
["steamid"] = "123456789",
["ownersteamid"] = "123456789",
["vacbanned"] = false,
["publisherbanned"] = false
}
}
}));
OnFacet <SteamLoginFacet> .CallSync(
nameof(SteamLoginFacet.Login),
"valid-session-token"
);
var timeBefore = player.lastLoginAt;
player.Refresh();
var timeNow = player.lastLoginAt;
Assert.AreNotEqual(timeBefore, timeNow);
}
public void ItLoadsNull()
{
var returned = OnFacet <AuthenticationFacet> .CallSync <PlayerEntity>(
nameof(AuthenticationFacet.GetPlayer)
);
Assert.IsNull(returned);
}
public void ItRunsFunctions()
{
int result = OnFacet <SomeFacet> .CallSync <int>(
nameof(SomeFacet.SquaringFunction),
5
);
Assert.AreEqual(25, result);
}
public void YouCanLogOutWhileNotLoggedIn()
{
var response = OnFacet <EmailLoginFacet> .CallSync <bool>(
nameof(EmailLoginFacet.Logout)
);
Assert.IsFalse(response);
Assert.IsFalse(Auth.Check());
}
public void ItChecksPublicMethods()
{
var e = Assert.Catch <MethodSearchException>(() => {
OnFacet <SomeFacet> .CallSync(
"PrivateProcedure"
);
});
StringAssert.Contains("has to be public in order to be called", e.ToString());
}
public void ItChecksMethodExistence()
{
var e = Assert.Catch <MethodSearchException>(() => {
OnFacet <SomeFacet> .CallSync(
"NonExistingMethod"
);
});
StringAssert.Contains("doesn't have public method called", e.ToString());
}
public void ItChecksAmbiguousMethods()
{
var e = Assert.Catch <MethodSearchException>(() => {
OnFacet <SomeFacet> .CallSync(
nameof(SomeFacet.AmbiguousMethod),
false
);
});
StringAssert.Contains("has multiple methods called", e.ToString());
}
public void UnknownCredentialsGetRejected()
{
var response = OnFacet <EmailLoginFacet> .CallSync <bool>(
nameof(EmailLoginFacet.Login),
"*****@*****.**",
"secret"
);
Assert.IsFalse(response);
Assert.IsFalse(Auth.Check());
}
public void ItCanCallFacetsFromTestMethod()
{
ExampleTestingFacet.addNumbersWasCalled = false;
var result = OnFacet <ExampleTestingFacet> .CallSync <int>(
nameof(ExampleTestingFacet.AddNumbers),
4, 7
);
Assert.AreEqual(11, result);
Assert.IsTrue(ExampleTestingFacet.addNumbersWasCalled);
}
public void PasswordCannotBeWeak()
{
var response = OnFacet <EmailRegisterFacet> .CallSync <EmailRegisterResponse>(
nameof(EmailRegisterFacet.Register),
"*****@*****.**",
""
);
Assert.AreEqual(EmailRegisterResponse.WeakPassword, response);
var player = DB.First <PlayerEntity>();
Assert.IsNull(player);
}
public void ItRunsMyProcedure()
{
SomeFacet.flag = false;
Assert.IsNull(SessionId);
OnFacet <SomeFacet> .CallSync(
nameof(SomeFacet.MyProcedure)
);
Assert.IsNotNull(SessionId);
Assert.IsTrue(SomeFacet.flag);
}
public void InvalidEmailIsRejected()
{
var response = OnFacet <EmailRegisterFacet> .CallSync <EmailRegisterResponse>(
nameof(EmailRegisterFacet.Register),
"john_doe.com",
"password"
);
Assert.AreEqual(EmailRegisterResponse.InvalidEmail, response);
var player = DB.First <PlayerEntity>();
Assert.IsNull(player);
}
public void FinalizingTransactionThatDoesNotExist()
{
Http.Fake();
Assert.Throws <SteamPurchasingServerFacet.SteamMicrotransactionException>(() => {
OnFacet <SteamPurchasingServerFacet> .CallSync <SteamTransactionEntity>(
nameof(SteamPurchasingServerFacet.FinalizeTransaction),
123456789L,
true
);
}, "No initiated transaction with order id 123456789 was found.");
Http.AssertNothingSent();
}
public void PlayerCanRegister()
{
var response = OnFacet <EmailRegisterFacet> .CallSync <EmailRegisterResponse>(
nameof(EmailRegisterFacet.Register),
"*****@*****.**",
"password"
);
Assert.AreEqual(EmailRegisterResponse.Ok, response);
var player = DB.First <PlayerEntity>();
Assert.IsNotNull(player);
Assert.AreEqual("*****@*****.**", player.email);
Assert.IsTrue(Hash.Check("password", player.password));
}
public void InvalidPasswordGetsRejected()
{
new PlayerEntity {
email = "*****@*****.**",
password = Hash.Make("different-secret")
}.Save();
var response = OnFacet <EmailLoginFacet> .CallSync <bool>(
nameof(EmailLoginFacet.Login),
"*****@*****.**",
"secret"
);
Assert.IsFalse(response);
Assert.IsFalse(Auth.Check());
}
public void YouCanLogOut()
{
var player = new PlayerEntity {
steamId = "123456789"
};
player.Save();
ActingAs(player);
var response = OnFacet <SteamLoginFacet> .CallSync <bool>(
nameof(SteamLoginFacet.Logout)
);
Assert.IsTrue(response);
Assert.IsFalse(Auth.Check());
}
public void InitiatingTransactionWithNoProducts()
{
var transaction = new SteamTransactionEntity {
playerSteamId = 123456789L
};
Http.Fake();
Assert.Throws <ArgumentException>(() => {
OnFacet <SteamPurchasingServerFacet> .CallSync(
nameof(SteamPurchasingServerFacet.InitiateTransaction),
transaction
);
}, "Given transaction has no items inside of it.");
Http.AssertNothingSent();
}
public void ItRunsMyParametrizedProcedure()
{
SomeFacet.flag = false;
OnFacet <SomeFacet> .CallSync(
nameof(SomeFacet.MyParametrizedProcedure),
true
);
Assert.IsTrue(SomeFacet.flag);
OnFacet <SomeFacet> .CallSync(
nameof(SomeFacet.MyParametrizedProcedure),
false
);
Assert.IsFalse(SomeFacet.flag);
}
public void YouCanLogOut()
{
var player = new PlayerEntity {
email = "*****@*****.**",
password = Hash.Make("secret")
};
player.Save();
ActingAs(player);
var response = OnFacet <EmailLoginFacet> .CallSync <bool>(
nameof(EmailLoginFacet.Logout)
);
Assert.IsTrue(response);
Assert.IsFalse(Auth.Check());
}
public void ItStoresLogout()
{
var player = new PlayerEntity {
name = "John"
};
player.Save();
Session.Set(AuthenticationManager.SessionKey, player.EntityId);
OnFacet <AuthenticationFacet> .CallSync(
nameof(AuthenticationFacet.Logout)
);
Assert.IsNull(
Session.Get <string>(AuthenticationManager.SessionKey)
);
}
public void ItLogsPlayerIn()
{
var player = new PlayerEntity {
steamId = "123456789"
};
player.Save();
Env.Set("STEAM_API_URL", "https://partner.steam-api.com/");
Env.Set("STEAM_PUBLISHER_KEY", "some-publisher-key");
Env.Set("STEAM_APP_ID", "480");
Http.Fake(Http.Response(new JsonObject {
["response"] = new JsonObject {
["params"] = new JsonObject {
["result"] = "OK",
["steamid"] = "123456789",
["ownersteamid"] = "123456789",
["vacbanned"] = false,
["publisherbanned"] = false
}
}
}));
OnFacet <SteamLoginFacet> .CallSync(
nameof(SteamLoginFacet.Login),
"valid-session-token"
);
Http.AssertSent(request =>
request.Url == "https://partner.steam-api.com/" +
"ISteamUserAuth/AuthenticateUserTicket/v1/?" +
"key=some-publisher-key&" +
"appid=480&" +
"ticket=valid-session-token"
);
Assert.IsTrue(Auth.Check());
Assert.AreEqual(
player.EntityId,
Auth.Id()
);
}
public void FinalizingTransactionThatIsNotInitiated()
{
var transaction = new SteamTransactionEntity {
playerSteamId = 123456789L,
state = SteamTransactionEntity.BeingPreparedState
};
Http.Fake();
Assert.Throws <SteamPurchasingServerFacet.SteamMicrotransactionException>(() => {
OnFacet <SteamPurchasingServerFacet> .CallSync <SteamTransactionEntity>(
nameof(SteamPurchasingServerFacet.FinalizeTransaction),
123456789L,
true
);
}, "No initiated transaction with order id 123456789 was found.");
Http.AssertNothingSent();
}
public void RegisteredAnyCaseEmailCanLogInWhenExact()
{
new PlayerEntity {
email = "*****@*****.**",
password = Hash.Make("secret")
}.Save();
var response = OnFacet <EmailLoginFacet> .CallSync <bool>(
nameof(EmailLoginFacet.Login),
"*****@*****.**",
"secret"
);
Assert.IsTrue(response);
Assert.IsTrue(Auth.Check());
Assert.AreEqual(
"*****@*****.**",
Auth.GetPlayer <PlayerEntity>().email
);
}
public void EmailCanBeAnyCaseAndNonTrimmed()
{
new PlayerEntity {
email = "*****@*****.**",
password = Hash.Make("secret")
}.Save();
var response = OnFacet <EmailLoginFacet> .CallSync <bool>(
nameof(EmailLoginFacet.Login),
" [email protected] ",
"secret"
);
Assert.IsTrue(response);
Assert.IsTrue(Auth.Check());
Assert.AreEqual(
"*****@*****.**",
Auth.GetPlayer <PlayerEntity>().email
);
}
public void ProperCredentialsLogYouIn()
{
new PlayerEntity {
email = "*****@*****.**",
password = Hash.Make("secret")
}.Save();
var response = OnFacet <EmailLoginFacet> .CallSync <bool>(
nameof(EmailLoginFacet.Login),
"*****@*****.**",
"secret"
);
Assert.IsTrue(response);
Assert.IsTrue(Auth.Check());
Assert.AreEqual(
"*****@*****.**",
Auth.GetPlayer <PlayerEntity>().email
);
}
public void ItStoresAuthenticatedPlayer()
{
var player = new PlayerEntity {
name = "John"
};
player.Save();
Assert.IsNull(
Session.Get <string>(AuthenticationManager.SessionKey)
);
OnFacet <AuthenticationFacet> .CallSync(
nameof(AuthenticationFacet.Login), "John"
);
Assert.AreEqual(
player.EntityId,
Session.Get <string>(AuthenticationManager.SessionKey)
);
}
