public async Task Test_If_The_Product_Is_Added_To_The_Db() { //Setup var optionBuilder = new DbContextOptionsBuilder <ApplicationDbContext>().UseInMemoryDatabase("ProdBasket"); var appdbcon = new ApplicationDbContext(optionBuilder.Options); //Arrange var product = new Product() { Id = 2, ProdName = "Abc", ProdImageName = "Abc.jpg", ProdPrice = 250 }; var prodRepo = new Repository <Product>(appdbcon); //Act prodRepo.Add(product); //Assert var result = await appdbcon.Products.FirstOrDefaultAsync(); Assert.AreEqual(result.ProdName, product.ProdName); Assert.AreSame(product, result); }
public void TestReferenceUpdate() { var so1 = new SimpleObject { ValueOne = 1, ValueTwo = 2 }; var so2 = new SimpleObject { ValueOne = 3, ValueTwo = 4 }; var ro = new ReferenceObject { ReferenceOne = so1 }; var clone = (ReferenceObject)CopyUtils.CloneObjectTest(ro); clone.ReferenceOne = so2; Assert.AreNotSame(ro, clone); Assert.AreSame(ro.GetType(), clone.GetType()); Assert.AreNotSame(ro.ReferenceOne, clone.ReferenceOne); CopyUtils.UpdateFromClone(ro, clone); Assert.AreNotSame(ro, clone); Assert.AreSame(ro.GetType(), clone.GetType()); Assert.AreSame(ro.ReferenceOne, clone.ReferenceOne); }
public void CanGetFilesSpecifiedByIndex() { readWrite["Foo"] = null; readWrite["Bar"] = file; Assert.AreSame(readOnly[1], file); }
public void GetObjectFromId() { Claim claim1 = NakedObjectsFramework.Persistor.Instances <Claim>().First(); object claim2 = NakedObjectsFramework.GetObjectFromId(objectId); Assert.AreSame(claim1, claim2); }
public void GetCollectionNakedObjectFromId() { IList <Claim> claims = NakedObjectsFramework.GetService <ClaimRepository>().FindMyClaims(null, ""); INakedObjectAdapter no = NakedObjectsFramework.NakedObjectManager.CreateAdapter(claims, null, null); INakedObjectAdapter service = NakedObjectsFramework.ServicesManager.GetService("ClaimRepository"); IActionSpec action = service.Spec.GetActions().Single(a => a.Id == "FindMyClaims"); INakedObjectAdapter[] parms = new[] { null, "" }.Select(o => NakedObjectsFramework.NakedObjectManager.CreateAdapter(o, null, null)).ToArray(); var cm = CollectionMementoHelper.TestMemento(NakedObjectsFramework.LifecycleManager, NakedObjectsFramework.NakedObjectManager, NakedObjectsFramework.MetamodelManager, service, action, parms); no.SetATransientOid(cm); string id = NakedObjectsFramework.GetObjectId(no); INakedObjectAdapter no2 = NakedObjectsFramework.GetNakedObjectFromId(id); List <Claim> claims2 = no2.GetDomainObject <IEnumerable <Claim> >().ToList(); Assert.AreEqual(claims.Count(), claims2.Count()); int index = 0; Dictionary <Claim, Claim> dict = claims.ToDictionary(x => x, y => claims2.Skip(index++).First()); dict.ForEach(kvp => Assert.AreSame(kvp.Key, kvp.Value)); }
public void TestCollectionUpdate() { var so1 = new SimpleObject { ValueOne = 1, ValueTwo = 2 }; var so2 = new SimpleObject { ValueOne = 3, ValueTwo = 4 }; var co = new CollectionObject(); co.CollectionOne.Add(so1); var clone = (CollectionObject)CopyUtils.CloneObjectTest(co); clone.CollectionOne.Add(so2); Assert.AreNotSame(co, clone); Assert.AreSame(co.GetType(), clone.GetType()); Assert.AreNotSame(co.CollectionOne, clone.CollectionOne); Assert.AreNotEqual(co.CollectionOne.Count(), clone.CollectionOne.Count()); CopyUtils.UpdateFromClone(co, clone); Assert.AreNotSame(co, clone); Assert.AreSame(co.GetType(), clone.GetType()); Assert.AreNotSame(co.CollectionOne, clone.CollectionOne); Assert.AreEqual(co.CollectionOne.Count(), clone.CollectionOne.Count()); Assert.AreSame(co.CollectionOne.First(), clone.CollectionOne.First()); Assert.AreSame(co.CollectionOne.ElementAt(1), clone.CollectionOne.ElementAt(1)); }
public void ReturnsValuesOfInParameters() { Assert.IsTrue(list.IsValueSet(IN_PARAMETER_INDEX), "in parameter should be set"); Assert.AreSame(inValue, list[IN_PARAMETER_INDEX], "in value"); Assert.IsTrue(list.IsValueSet(REF_PARAMETER_INDEX), "ref parameter should be set"); Assert.AreSame(refValue, list[REF_PARAMETER_INDEX], "ref value"); }
//Two different variables that reference the same object public void TwoVarsCanReferenceSameObject() { var book1 = GetBook("BOOK 1"); var book2 = book1; Assert.AreSame(book1, book2); Assert.True(Object.ReferenceEquals(book1, book2)); }
public void StoresResultToReturn() { invocation.Result = result; Assert.AreSame(result, invocation.Result, "should store result"); Assert.IsFalse(invocation.IsThrowing, "should not be throwing"); Assert.IsNull(invocation.Exception, "should not store an exception"); }
public void StoresExceptionToThrow() { invocation.Exception = exception; Assert.AreSame(exception, invocation.Exception, "should store exception"); Assert.IsTrue(invocation.IsThrowing, "should be throwing"); Assert.IsNull(invocation.Result, "should not store a result"); }
public void AddTransientToSession() { HttpSessionStateBase session = mocks.HtmlHelper.ViewContext.HttpContext.Session; var claim = NakedObjectsFramework.LifecycleManager.CreateInstance((IObjectSpec)NakedObjectsFramework.MetamodelManager.GetSpecification(typeof(Claim))).GetDomainObject <Claim>(); session.AddObjectToSession(Surface, "key1", claim); Assert.AreSame(claim, session.GetObjectFromSession <Claim>(Surface, "key1")); }
public void AddPersistentToSession() { HttpSessionStateBase session = mocks.HtmlHelper.ViewContext.HttpContext.Session; Claim claim = NakedObjectsFramework.Persistor.Instances <Claim>().First(); session.AddObjectToSession(Surface, "key1", claim); Assert.AreSame(claim, session.GetObjectFromSession <Claim>(Surface, "key1")); }
public void SettingResultClearsException() { invocation.Exception = exception; invocation.Result = result; Assert.AreSame(result, invocation.Result, "should store result"); Assert.IsFalse(invocation.IsThrowing, "should not be throwing"); Assert.IsNull(invocation.Exception, "should not store an exception"); }
public void GetNakedObjectFromId() { Claim claim1 = NakedObjectsFramework.Persistor.Instances <Claim>().First(); var id = NakedObjectsFramework.GetObjectId(claim1); INakedObjectAdapter claim2 = NakedObjectsFramework.GetNakedObjectFromId(objectId); Assert.AreSame(claim1, claim2.Object); }
[Test] // fix later public void GetGenericObjectFromId() { var repo1 = GetTestService("Custom Helper Test Classes").NakedObject.Object; var id = NakedObjectsFramework.GetObjectId(repo1); object repo2 = NakedObjectsFramework.GetObjectFromId(id); Assert.AreSame(repo1, repo2); }
public void MockObjectsMayBePlacedIntoServiceContainers() { var container = new ServiceContainer(); var mockedType = Mocks.CreateMock <IMockedType>(); container.AddService(typeof(IMockedType), mockedType.MockObject); Assert.AreSame(mockedType.MockObject, container.GetService(typeof(IMockedType))); }
public void AddStudent_ShouldAddStudentToListOfStudent() { var expectedId = 10; var mockedStudent = new Mock <IStudent>(); SchoolSystemEngine.AddStudent(expectedId, mockedStudent.Object); Assert.AreSame(SchoolSystemEngine.Students[expectedId], mockedStudent.Object); }
public void AddTeacher_ShouldAddTeacherToListOfTeachers() { var expectedId = 10; var mockedTeacher = new Mock <ITeacher>(); SchoolSystemEngine.AddTeacher(expectedId, mockedTeacher.Object); Assert.AreSame(SchoolSystemEngine.Teachers[expectedId], mockedTeacher.Object); }
public void SettingExceptionClearsResult() { invocation.Result = result; invocation.Exception = exception; Assert.AreSame(exception, invocation.Exception, "should store exception"); Assert.IsTrue(invocation.IsThrowing, "should be throwing"); Assert.IsNull(invocation.Result, "should not store a result"); }
public void RemoveObjectFromCache() { HttpSessionStateBase session = mocks.HtmlHelper.ViewContext.HttpContext.Session; Claim claim = NakedObjectsFramework.Persistor.Instances <Claim>().First(); session.AddObjectToSession(NakedObjectsFramework, "key1", claim); Assert.AreSame(claim, session.GetObjectFromSession <Claim>(NakedObjectsFramework, "key1")); session.ClearFromSession("key1"); Assert.IsNull(session.GetObjectFromSession <Claim>(NakedObjectsFramework, "key1")); }
public void Can_View_Cart_Contents() { var comparison = new Comparison(); sutController = new ComparingController(null); var result = (ComparisonIndexViewModel)sutController.Index(comparison, "myUrl").ViewData.Model; Assert.AreSame(result.CompareCollection, comparison); Assert.AreEqual(result.ReturnUrl, "myUrl"); }
public void SetAndGetProperty() { object value = "hello"; DependencyProvider.MockObject.GetAndSetProperty = value; Assert.AreSame(value, DependencyProvider.MockObject.GetAndSetProperty); DependencyProvider.MockObject.GetAndSetProperty = 3; Assert.AreEqual(3, DependencyProvider.MockObject.GetAndSetProperty, "wrong value on second set."); }
public void CanSpecifyFiles() { var mocks = new MockRepository(); var file = mocks.DynamicMock <HttpPostedFileBase>(); builder.Files["Variable"] = file; var controller = new TestHelperController(); builder.InitializeController(controller); Assert.AreSame(file, controller.Request.Files["Variable"]); }
public void UserShouldBeMocked() { var mocks = new MockRepository(); var user = mocks.DynamicMock <IPrincipal>(); var controller = builder.CreateController <TestHelperController>(); controller.ControllerContext.HttpContext.User = user; Assert.AreSame(user, controller.User); }
public void CanSetValuesOfOutAndRefParameters() { object newRefValue = "newRefValue"; object outValue = "outValue"; list[REF_PARAMETER_INDEX] = newRefValue; list[OUT_PARAMETER_INDEX] = outValue; Assert.AreSame(newRefValue, list[REF_PARAMETER_INDEX], "new ref value"); Assert.IsTrue(list.IsValueSet(OUT_PARAMETER_INDEX), "out parameter is set"); Assert.AreSame(outValue, list[OUT_PARAMETER_INDEX], "out value"); }
public void TestSimpleClone() { var so = new SimpleObject { ValueOne = 1, ValueTwo = 2 }; var clone = (SimpleObject)CopyUtils.CloneObjectTest(so); Assert.AreNotSame(so, clone); Assert.AreSame(so.GetType(), clone.GetType()); Assert.AreEqual(so.ValueOne, clone.ValueOne); Assert.AreEqual(so.ValueTwo, clone.ValueTwo); }
public void TestBuildEntityMixed(uint id) { TestIt testIt = new TestIt(2); _entityFactory.BuildEntity <TestEntityWithComponentViewAndComponent>(new EGID(id, group1), new[] { testIt }); _simpleSubmissionEntityViewScheduler.SubmitEntities(); Assert.IsTrue(_neverDoThisIsJustForTheTest.HasEntity <TestEntityViewComponent>(new EGID(id, group1))); Assert.IsTrue(_neverDoThisIsJustForTheTest.HasAnyEntityInGroup <TestEntityComponent>(group1)); Assert.IsTrue(_neverDoThisIsJustForTheTest.HasAnyEntityInGroup <TestEntityViewComponent>(group1)); var(entityCollection, count) = _neverDoThisIsJustForTheTest.entitiesDB.QueryEntities <TestEntityViewComponent>(group1); Assert.AreSame(entityCollection[0].TestIt, testIt); }
public void GetAllSpecializationsTest() { //Arrange var mock = new Mock <IUnitOfWork>(); mock.Setup(a => a.Specializations.GetAll()).Returns(It.IsAny <List <Specialization> >); //Act var service = new SpecializationService(mock.Object); var list = new List <SpecializationDto>(); Assert.AreSame(list.GetType(), service.GetSpecializations().GetType()); }
public void TestCollectionClone() { var so = new SimpleObject { ValueOne = 1, ValueTwo = 2 }; var co = new CollectionObject(); co.CollectionOne.Add(so); var clone = (CollectionObject)CopyUtils.CloneObjectTest(co); Assert.AreNotSame(co, clone); Assert.AreSame(co.GetType(), clone.GetType()); Assert.AreNotSame(co.CollectionOne, clone.CollectionOne); Assert.AreSame(co.CollectionOne.First(), clone.CollectionOne.First()); }
public void TrapsExceptionsWhenInvokedOnAnotherObject() { Exception exception = new Exception("thrown from Foo"); invocation = new Invocation(receiver, FOO_METHOD, new object[] { "input", null }); MockFoo mockFoo = new MockFoo(); mockFoo.Foo_ExpectedInput = "input"; mockFoo.Foo_Exception = exception; invocation.InvokeOn(mockFoo); Assert.IsTrue(mockFoo.FooWasInvoked, "Foo should have been invoked"); Assert.AreSame(exception, invocation.Exception, "exception"); }