public void InverseOfNonReadOnly()
{
var nonReadOnlyInverse = ValidDictionary.Inverse();
Assert.That(nonReadOnlyInverse, Is.TypeOf <Dictionary <string, int> >());
Assert.That(nonReadOnlyInverse, Is.Not.TypeOf <ReadOnlyDictionary <string, int> >());
}
public void ItReturnsAnUnauthorizedHttpStatusWhenThereIsAGamingGroupIdThatDoesntMatchTheCurrentUser()
{
const string TOKEN = "TEST";
request.Headers.Add(ApiAuthenticationAttribute.AUTH_HEADER, new[] { TOKEN });
const int REQUESTED_GAMING_GROUP_ID = 1;
actionContext.ActionArguments.Add("gamingGroupId", REQUESTED_GAMING_GROUP_ID);
const int GAMING_GROUP_ID = -1;
var expectedUser = new ApplicationUser
{
Id = "some id",
CurrentGamingGroupId = GAMING_GROUP_ID
};
authTokenValidatorMock.Expect(mock => mock.ValidateAuthToken(TOKEN)).Return(expectedUser);
const string EXPECTED_CLIENT_ID = "some client id";
clientIdCalculatorMock.Expect(mock => mock.GetClientId(request, expectedUser)).Return(EXPECTED_CLIENT_ID);
attribute.OnActionExecuting(actionContext);
Assert.That(actionContext.Response.Content, Is.TypeOf(typeof(ObjectContent <HttpError>)));
var content = actionContext.Response.Content as ObjectContent <HttpError>;
var httpError = content.Value as HttpError;
Assert.That(actionContext.Response.StatusCode, Is.EqualTo(HttpStatusCode.Unauthorized));
Assert.That(httpError.Message, Is.EqualTo(string.Format(ApiAuthenticationAttribute.ERROR_MESSAGE_UNAUTHORIZED_TO_GAMING_GROUP, REQUESTED_GAMING_GROUP_ID)));
}
public void B()
{
var enumBM = new EnumBM <TestEnum>();
enumBM.Metadata.DataProvider.Data = TestEnum.A;
Assert.IsNotNull(enumBM.Settings);
Assert.IsTrue(enumBM.Settings.IncludeValuesSpecified);
Assert.IsNotNull(enumBM.Settings.IncludeValues);
var enumVM = new EnumVM <TestEnum> {
Metadata = new BusinessValueMetadata <TestEnum>()
};
((BusinessValueDataProvider <TestEnum>)enumVM.Metadata.DataProvider).BusinessValue = enumBM;
Assert.That(enumVM.DisplayValueProvider, Is.TypeOf <EnumDisplayValueProvider>());
Assert.AreEqual(TestEnum.A, enumVM.Value);
Assert.AreEqual("A", enumVM.DisplayValueProvider.String);
Assert.AreEqual("A", enumVM.EditValueProvider.String);
Assert.IsNotNull(enumVM.ValueSourceProvider);
Assert.IsNotNull(enumVM.ValueSourceProvider.SourceList);
var validValues = enumVM.ValueSourceProvider.SourceList.Cast <EnumMemberVM <TestEnum> >().ToList();
Assert.AreEqual(3, validValues.Count);
enumVM.Value = TestEnum.B;
Assert.AreEqual(TestEnum.B, enumBM.Value);
enumVM.EditValueProvider.String = "C";
Assert.IsFalse(enumVM.ErrorProvider.HasError);
Assert.AreEqual(TestEnum.C, enumBM.Value);
}
public void InverseOfReadOnly()
{
var readOnly = new ReadOnlyDictionary <int, string>(ValidDictionary);
var readOnlyInverse = readOnly.Inverse();
Assert.That(readOnlyInverse, Is.TypeOf <ReadOnlyDictionary <string, int> >());
Assert.That(readOnlyInverse, Is.Not.TypeOf <Dictionary <string, int> >());
}
public void Test_Compute()
{
AssertAll.Of(
$"{nameof(Coercively)}.{nameof(Coercively.Compute)}: [{AType.Name}]{A} {Operation} [{BType.Name}]{B} == [{EType.Name}]{E}",
Coercively.Compute(A, Operation, B),
Is.EqualTo(E),
Is.TypeOf(EType)
);
}
public void ShouldReturnBadRequestWhenNoTokenProvided()
{
attribute.OnActionExecuting(actionContext);
Assert.That(actionContext.Response.Content, Is.TypeOf(typeof(ObjectContent <HttpError>)));
var content = actionContext.Response.Content as ObjectContent <HttpError>;
var httpError = content.Value as HttpError;
Assert.That(actionContext.Response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
Assert.That(httpError.Message, Is.EqualTo(ApiAuthenticationAttribute.ERROR_MESSAGE_MISSING_AUTH_TOKEN_HEADER));
}
public void ShouldReturnBadRequestWhenTokenHasEmptyValue()
{
request.Headers.Add(ApiAuthenticationAttribute.AUTH_HEADER, new [] { string.Empty });
attribute.OnActionExecuting(actionContext);
Assert.That(actionContext.Response.Content, Is.TypeOf(typeof(ObjectContent <HttpError>)));
var content = actionContext.Response.Content as ObjectContent <HttpError>;
var httpError = content.Value as HttpError;
Assert.That(actionContext.Response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
Assert.That(httpError.Message, Is.EqualTo(ApiAuthenticationAttribute.ERROR_MESSAGE_INVALID_AUTH_TOKEN));
}
public void ShouldReturnUnauthorizedHttpStatusWhenTokenExpired()
{
const string EXPECTED_TOKEN = "TEST";
request.Headers.Add(ApiAuthenticationAttribute.AUTH_HEADER, new[] { EXPECTED_TOKEN });
attribute.OnActionExecuting(actionContext);
Assert.That(actionContext.Response.Content, Is.TypeOf(typeof(ObjectContent <HttpError>)));
var content = actionContext.Response.Content as ObjectContent <HttpError>;
var httpError = content.Value as HttpError;
Assert.That(actionContext.Response.StatusCode, Is.EqualTo(HttpStatusCode.Unauthorized));
Assert.That(httpError.Message, Is.EqualTo(ApiAuthenticationAttribute.ERROR_MESSAGE_INVALID_AUTH_TOKEN));
}
public void PrependMessage_KnownType()
{
try {
throw new NullReferenceException(Original);
}
catch (NullReferenceException e) {
var e2 = e.PrependMessage(Prepended);
AssertAll.Of(
e2,
Is.Not.Null,
Has.Property(nameof(e2.Message)).StartsWith(Prepended),
Has.Property(nameof(e2.Message)).EndsWith(Original),
Is.TypeOf <NullReferenceException>()
);
}
}
public void ShouldReturnUnauthorizedHttpStatusWhenWrongToken()
{
const string TOKEN = "DIFFERENT";
request.Headers.Add(ApiAuthenticationAttribute.AUTH_HEADER, new[] { TOKEN });
authTokenValidatorMock.Expect(mock => mock.ValidateAuthToken(Arg <string> .Is.Anything)).Return(null);
attribute.OnActionExecuting(actionContext);
Assert.That(actionContext.Response.Content, Is.TypeOf(typeof(ObjectContent <HttpError>)));
var content = actionContext.Response.Content as ObjectContent <HttpError>;
var httpError = content.Value as HttpError;
Assert.That(actionContext.Response.StatusCode, Is.EqualTo(HttpStatusCode.Unauthorized));
Assert.That(httpError.Message, Is.EqualTo(ApiAuthenticationAttribute.ERROR_MESSAGE_INVALID_AUTH_TOKEN));
}
public void Test_Verb()
{
Func <object, object, object> method = Operation switch {
Coercive.Operation.Plus => Coercively.Add,
Coercive.Operation.Minus => Coercively.Subtract,
Coercive.Operation.Times => Coercively.Multiply,
Coercive.Operation.DividedBy => Coercively.Divide,
_ => throw EnumUtils.InvalidEnumArgumentException(nameof(Operation), Operation)
};
AssertAll.Of(
$"Coercively.{Operation.Operator().Verb}()-ing [{AType.Name}]{A}, [{BType.Name}]{B}",
method.Invoke(A, B),
Is.EqualTo(E),
Is.TypeOf(EType)
);
}
}
public void TestIssue70()
{
var serializer = MessagePackSerializer.Get <DBNull>(new SerializationContext());
#if !UNITY
// Should not be created dynamically.
Assert.That(serializer, Is.TypeOf(typeof(DefaultSerializers.System_DBNullMessagePackSerializer)));
#endif // !UNITY
using (var buffer = new MemoryStream())
{
serializer.Pack(buffer, DBNull.Value);
buffer.Position = 0;
var packed = Unpacking.UnpackObject(buffer);
Assert.That(packed.IsNil, packed.ToString());
buffer.Position = 0;
var unpacked = serializer.Unpack(buffer);
Assert.That(Object.ReferenceEquals(unpacked, null), Is.False);
Assert.That(unpacked, Is.SameAs(DBNull.Value));
}
}
public void InitializeShouldThrowExceptionOnMissingScriptProperty()
{
grinderContextMock.Setup(c => c.GetProperty(worker.ScriptFileKey)).Returns((string)null);
Assert.Throws(Is.TypeOf <ArgumentException>().And.Message.EqualTo("Missing property 'grinderscript-dotnet.csScriptWorker.script'"), () => worker.Initialize());
}
public void InitializeShouldLoadValidDuckTypeScript()
{
grinderContextMock.Setup(c => c.GetProperty(worker.ScriptFileKey)).Returns("CsScriptWorkerThatIsValidDuckType.txt");
Assert.Throws(Is.TypeOf <ArgumentException>().And.Message.EqualTo("Type 'CsScriptWorkerThatIsValidDuckType', from script file 'CsScriptWorkerThatIsValidDuckType.txt', does not implement 'GrinderScript.Net.Core.IGrinderWorker'"), () => worker.Initialize());
Assert.That(worker.ScriptWorker, Is.Not.Null);
}