public void GetInstanceResolveStateIsPersistent()
{
var adapter = AdapterFor(GetPerson(1));
Assert.IsTrue(adapter.ResolveState.IsPersistent(), "should be persistent");
Assert.IsFalse(adapter.Oid.IsTransient, "is transient");
}
public void One()
{
Assert.IsTrue(IQ.From("select * FROM animals where pk=3").One());
Assert.IsFalse(IQ.From("select * FROM animals").One());
Assert.IsFalse(IQ.From("select * FROM animals where pk=99999").One());
Assert.IsFalse(IQ.From("select * FROM animals where pk<10").One());
}
public void ReferencePropertyObjectResolveStateIsPersistent()
{
var adapter = AdapterFor(GetProductFromPersonOne());
Assert.IsTrue(adapter.ResolveState.IsPersistent(), "should be persistent");
Assert.IsFalse(adapter.Oid.IsTransient, "is transient");
}
public void DoesNotMatchStaticField()
{
ObjectWithFields o = new ObjectWithFields();
Matcher m = new FieldMatcher("StaticField", new AlwaysMatcher(true, "anything"));
Assert.IsFalse(m.Matches(o), "should not match o; field is static");
}
public void CollectionPropertyObjectResolveStateIsPersistent()
{
var adapter = AdapterFor(GetPersonFromPersonOneCollection());
Assert.IsTrue(adapter.ResolveState.IsPersistent(), "should be persistent");
Assert.IsFalse(adapter.Oid.IsTransient, "is transient");
}
public void DoesNotMatchObjectIfItDoesNotHaveNamedField()
{
ObjectWithFields o = new ObjectWithFields();
Matcher m = new FieldMatcher("FavouriteColour", new AlwaysMatcher(true, "anything"));
Assert.IsFalse(m.Matches(o), "should not match o; field does not exist");
}
public void DoesNotMatchInvocationWithDifferentNumberOfArguments()
{
Matcher matcher = new ArgumentsMatcher(Is.Anything, Is.Anything);
Assert.IsFalse(matcher.Matches(InvocationWithArguments(1)), "fewer arguments");
Assert.IsFalse(matcher.Matches(InvocationWithArguments(1, 2, 3)), "more arguments");
}
public void SaveNewObjectWithTransientCollectionItem()
{
var person1 = CreateNewTransientPerson();
var person2 = CreateNewTransientPerson();
person1.Name = Guid.NewGuid().ToString();
person2.Name = Guid.NewGuid().ToString();
person1.Relatives.Add(person2);
var person1Adapter = Save(person1);
// use new person to avoid EF quirk
person1 = person1Adapter.GetDomainObject <Person>();
person2 = person1.Relatives.Single();
Assert.IsTrue(person1Adapter.ResolveState.IsPersistent(), "should be persistent");
Assert.IsFalse(person1Adapter.Oid.IsTransient, "is transient");
var person2Adapter = AdapterFor(person2);
Assert.IsTrue(person2Adapter.ResolveState.IsPersistent(), "should be persistent");
Assert.IsFalse(person2Adapter.Oid.IsTransient, "is transient");
var collectionAdapter = ((IObjectSpec)person1Adapter.Spec).GetProperty("Relatives").GetNakedObject(person1Adapter);
Assert.IsTrue(collectionAdapter.ResolveState.IsPersistent(), "should be persistent");
Assert.IsFalse(collectionAdapter.ResolveState.IsGhost(), "should not be ghost");
}
public void Basic()
{
//Assert.Throws<Exception>(() => {
// TestObjectBugs testBugs = new TestObjectBugs();
//}, "Can't create instance of primary-keyless object");
var test = new TestObject();
IQ.Track(test);
Assert.IsFalse(test.IsDirty(), "New object isn't dirty");
Assert.IsTrue(test.IsNew(), "New object is new");
test.FirstName = "Jamie";
Assert.IsTrue(test.IsDirty("FirstName"), "Changing name dirtied it");
Assert.IsTrue(test.IsDirty(), "Changing a field dirtied the whole object");
int dirtyCount = 0;
foreach (var item in test.DirtyFieldNames())
{
dirtyCount++;
Assert.AreEqual("FirstName", item, "The field that's dirty is firstname");
}
Assert.AreEqual(1, dirtyCount, "There was one dirty field");
}
public void GetInlineInstance()
{
var addressAdapter = GetAdaptedAddress(GetPerson(1));
Assert.IsTrue(addressAdapter.ResolveState.IsPersistent(), "should be persistent");
Assert.IsFalse(addressAdapter.Oid.IsTransient, "is transient");
}
public void MatchesNullReferences()
{
Matcher matcher = new NullMatcher();
Assert.IsTrue(matcher.Matches(null), "null");
Assert.IsFalse(matcher.Matches(new object()), "not null");
}
public void SenseitiveData_NestedObj()
{
var obj = new NestedObjWithSensitive()
{
OHay = "test",
SomethingElse = "bbbbb",
ThisIsSensitive = "88888",
ASensitiveList = new List <string>()
{
"99999",
"221212"
},
ThisHasSomeSensitiveFields = new RequiredFieldDerived()
{
BaseIntegerType = 5,
BaseStringType = "asdasd",
DerivedIntegerType = 33,
DerivedStringType = "xxxx",
SensitiveInt = 1111,
SensitiveString = "yyyy"
}
};
var res = obj.ObjToJson();
Assert.IsFalse(res.Contains("yyyy"));
Assert.IsFalse(res.Contains("1111"));
Assert.IsFalse(res.Contains("88888"));
Assert.IsFalse(res.Contains("99999"));
Assert.IsFalse(res.Contains("221212"));
}
public void Any()
{
var table = IQ.From <Cat>();
Assert.IsTrue(table.Where("pk<10").Any());
Assert.IsFalse(table.Where("pk=99999").Any());
}
public void SaveNewObjectWithScalars() {
var person = CreateNewTransientPerson();
person.Name = Guid.NewGuid().ToString();
var adapter = Save(person);
Assert.IsTrue(adapter.ResolveState.IsPersistent(), "should be persistent");
Assert.IsFalse(adapter.Oid.IsTransient, "is transient");
}
public void FindHypotenuseValidateInputs()
{
var error = false;
try
{
// Make sure side 1 is valid
Pythagorean.FindHypotenuse(0, 2);
error = true;
}
catch
{
// ignored
}
try
{
// Make sure side 2 is valid
Pythagorean.FindHypotenuse(2, 0);
error = true;
}
catch
{
// ignored
}
Assert.IsFalse(error, "We should have thrown errors above");
}
public void EditSubmissionThesisTest()
{
IDao dao = new DatabaseManager();
SubmissionThesis submission = new SubmissionThesis();
submission.SubmissionId = 1;
submission.ThesisTopic = "Tresc";
submission.TopicNumber = 2;
submission.ThesisObjectives = "Cele pracy";
submission.ThesisScope = "Cele pracy";
submission.Status = ThesisStatus.APPROVED;
FinalThesis finalThesis = new FinalThesis();
finalThesis.FinalThesisId = 1;
submission.FinalThesis = finalThesis;
Edition edition = new Edition();
edition.Number = 1;
submission.Edition = edition;
Assert.IsTrue(dao.EditSubmissionThesis(submission));
submission.SubmissionId = 100000;
Assert.IsFalse(dao.EditSubmissionThesis(submission));
try
{
SubmissionThesis incorrectSubmission = new SubmissionThesis();
incorrectSubmission.SubmissionId = -1;
dao.EditSubmissionThesis(incorrectSubmission);
Assert.Fail();
}
catch (ArgumentException) { }
}
public void CanCompareAutoboxedValues()
{
Matcher matcher = new EqualMatcher(1);
Assert.IsTrue(matcher.Matches(1), "equal value");
Assert.IsFalse(matcher.Matches(2), "other value");
}
public void Queen_QueenNotOnSameRowOrColumn_IsNotAttacking(int q1Row, int q1Column, int q2Row, int q2Column)
{
var q1 = new Queen(q1Row, q1Column);
var q2 = new Queen(q2Row, q2Column);
Assert.IsFalse(q1.IsAttacking(q2));
}
public IEnumerator JohnCanLogOut()
{
yield return(OnFacet <AuthenticationFacet> .Call(
nameof(AuthenticationFacet.Login),
"John"
).AsCoroutine());
yield return(OnFacet <AuthenticationFacet> .Call(
nameof(AuthenticationFacet.Logout)
).AsCoroutine());
yield return(OnFacet <AuthenticationFacet> .Call <PlayerEntity>(
nameof(AuthenticationFacet.GetPlayer)
).Then(p => {
Assert.IsNull(p);
}).AsCoroutine());
yield return(OnFacet <AuthenticationFacet> .Call <bool>(
nameof(AuthenticationFacet.Check)
).Then(c => {
Assert.IsFalse(c);
}).AsCoroutine());
yield return(OnFacet <AuthenticationFacet> .Call <string>(
nameof(AuthenticationFacet.Id)
).Then(id => {
Assert.IsNull(id);
}).AsCoroutine());
}
public void MatchesCallCountWhenMatchingInvocation()
{
Matcher irrelevant = Is.Anything;
BuildableExpectation expectation = (BuildableExpectation)BuildExpectation(
"description",
Is.AtLeast(0),
Is.AtMost(4),
receiver.MockObject,
irrelevant,
irrelevant,
irrelevant,
irrelevant);
AssertIsActive(expectation, "should be active before any invocation");
Assert.IsTrue(expectation.Matches(invocation), "should match 1st invocation");
expectation.Perform(invocation);
AssertIsActive(expectation, "should be active before 2nd invocation");
Assert.IsTrue(expectation.Matches(invocation), "should match 2nd invocation");
expectation.Perform(invocation);
AssertIsActive(expectation, "should be active before 3rd invocation");
Assert.IsTrue(expectation.Matches(invocation), "should match 3rd invocation");
expectation.Perform(invocation);
AssertIsActive(expectation, "should be active before 4th invocation");
Assert.IsTrue(expectation.Matches(invocation), "should match 4th invocation");
expectation.Perform(invocation);
AssertIsNotActive(expectation, "should not be active after 4th invocation");
Assert.IsFalse(expectation.Matches(invocation), "should not match 5th invocation");
}
public void FailHitTests()
{
// new ship
var ship = new Ship(new[] {4, 5, 3});
Assert.IsFalse(ship.Hit(6));
Assert.IsTrue(ship.IsAlive);
}
public void DoesNotMatchObjectIfItDoesNotHaveNamedProperty()
{
ObjectWithProperties o = new ObjectWithProperties();
Matcher m = new PropertyMatcher("OtherProperty", new AlwaysMatcher(true, "anything"));
Assert.IsFalse(m.Matches(o), "should not match o");
}
public void DoesNotMatchValueOfNonAssignableType()
{
Matcher m = new TypeMatcher(typeof(D));
Assert.IsFalse(m.Matches(new B()), "should not match B");
Assert.IsFalse(m.Matches(123), "should not match B");
Assert.IsFalse(m.Matches("hello, world"), "should not match B");
}
public static void False(bool condition)
{
#if XUNIT
FrameworkAssert.False(condition);
#else
FrameworkAssert.IsFalse(condition);
#endif
}
public void DoesNotMatchWriteOnlyProperty()
{
ObjectWithProperties o = new ObjectWithProperties();
Matcher m = new PropertyMatcher("WriteOnlyProperty", new AlwaysMatcher(true, "anything"));
Assert.IsFalse(m.Matches(o), "should not match o");
}
public void DelegatesMatchingToAnotherMatcher()
{
Matcher m1 = new DescriptionOverride("irrelevant", new AlwaysMatcher(true, "always true"));
Matcher m2 = new DescriptionOverride("irrelevant", new AlwaysMatcher(false, "always false"));
Assert.IsTrue(m1.Matches(new object()), "m1");
Assert.IsFalse(m2.Matches(new object()), "m2");
}
public void IsEmpty()
{
var item = new WhereClause();
Assert.IsTrue(item.IsEmpty);
item.Add(new WhereString("a=b"));
Assert.IsFalse(item.IsEmpty);
}
public void DoesNotMatchIfValueMatchersDoNotMatchArgumentValues()
{
Matcher matcher = new ArgumentsMatcher(Is.EqualTo(arg1Value), Is.EqualTo(arg2Value));
Assert.IsFalse(matcher.Matches(InvocationWithArguments("other object", arg2Value)),
"different first arg");
Assert.IsFalse(matcher.Matches(InvocationWithArguments(arg1Value, "other object")),
"different second arg");
}
public void MatchesMethodsWithAGivenName()
{
Matcher matcher = new MethodNameMatcher("m", typeof(I));
Assert.IsTrue(matcher.Matches(typeof(I).GetMethod("m", new Type[0])), "m()");
Assert.IsTrue(matcher.Matches(typeof(I).GetMethod("m", new[] { typeof(int) })), "m(int)");
Assert.IsTrue(matcher.Matches(typeof(I).GetMethod("m", new[] { typeof(string), typeof(string) })), "m(string,string)");
Assert.IsFalse(matcher.Matches(typeof(I).GetMethod("n", new Type[0])), "n()");
}
public void DoesNotMatchObjectIfValueMatcherDoesNotMatch()
{
ObjectWithFields o = new ObjectWithFields();
o.PublicField = "actual value";
Matcher m = new FieldMatcher("PublicField", new EqualMatcher("some other value"));
Assert.IsFalse(m.Matches(o), "should match o; value is different");
}
