protected internal virtual void OnDifferenceObjectSaving(ModelDifferenceObject modelDifferenceObject, Dictionary diffDictionary) { Dictionary dictionary = modelDifferenceObject.GetCombinedModel(); dictionary.CombineWith(diffDictionary); modelDifferenceObject.Model = dictionary.GetDiffs(); objectSpace.CommitChanges(); }
public void If_User_Has_Permnission_To_Combine_With_Application_Model_Combination_Should_Occur() { ModelCombinePermission permission = null; Isolate.WhenCalled(() => SecuritySystem.IsGranted(null)).DoInstead(context => { permission = context.Parameters[0] as ModelCombinePermission; return true; }); var modelAspectObject = new ModelDifferenceObject(Session.DefaultSession){Model =DefaultDictionary,PersistentApplication = new PersistentApplication(Session.DefaultSession)}; var queryModelAspectObject = Isolate.Fake.InstanceAndSwapAll<QueryModelDifferenceObject>(); Isolate.WhenCalled(() => queryModelAspectObject.GetActiveModelDifference( "")).WillReturn(modelAspectObject); var store = new XpoUserModelDictionaryDifferenceStore( Isolate.Fake.Instance<XafApplication>()); var aspectObject = new UserModelDifferenceObject(Session.DefaultSession){ PersistentApplication = new PersistentApplication(Session.DefaultSession), NonPersistent = true, Model = DefaultDictionary2 }; store.OnDifferenceObjectSaving(aspectObject, new Dictionary()); Assert.IsNotNull(permission); Assert.AreEqual(ApplicationModelCombineModifier.Allow, permission.Modifier); Assert.IsFalse(modelAspectObject.IsNewObject); Assert.IsNotNull(new ApplicationNodeWrapper(modelAspectObject.Model).BOModel.FindClassByName("MyClass2")); }
public void When_Saving_Should_Combine_With_Diffs(){ var modelDictionaryDifferenceStore = Isolate.Fake.Instance<XpoModelDictionaryDifferenceStore>(Members.CallOriginal); var modelDifferenceObject = new ModelDifferenceObject(Session.DefaultSession); modelDictionaryDifferenceStore.OnDifferenceObjectSaving(modelDifferenceObject, DefaultDictionary); Assert.AreEqual(DefaultDictionary.RootNode.ToXml(), modelDifferenceObject.Model.RootNode.ToXml()); }
public void AddAspects(ModelDifferenceObject modelDifferenceObject){ if (_dictionary== null) _dictionary = modelDifferenceObject.Model; AddAspects(modelDifferenceObject.Model); if (_modelDifferenceObject != null) _modelDifferenceObject.Model=_dictionary; }
public void Can_Be_Deleted(){ var modelDifferenceObject = new ModelDifferenceObject(Session.DefaultSession){PersistentApplication = new PersistentApplication(Session.DefaultSession)}; modelDifferenceObject.Save(); modelDifferenceObject.Delete(); Assert.IsTrue(modelDifferenceObject.IsDeleted); }
public void Can_Be_Cloned(){ var modelDifferenceObject = new ModelDifferenceObject(Session.DefaultSession){PersistentApplication = new PersistentApplication(Session.DefaultSession)}; var xpSimpleObject = new Cloner().CloneTo(modelDifferenceObject, typeof (ModelDifferenceObject)); Assert.IsNotNull(xpSimpleObject); }
public void When_Changing_PrefferedLanguage_Then_Model_CurrentAspect_Should_Be_ModelDifference_CurrentLanguage(){ var modelDifferenceObject = new ModelDifferenceObject(Session.DefaultSession){PersistentApplication = new PersistentApplication(Session.DefaultSession)}; var dictionary = DefaultDictionary; modelDifferenceObject.Model=dictionary; modelDifferenceObject.PreferredAspect = "el "; Assert.AreEqual(modelDifferenceObject.CurrentLanguage, modelDifferenceObject.Model.CurrentAspect); }
private static void SetUp(ModelDifferenceObject modelDifferenceObject) { modelDifferenceObject.DateCreated = DateTime.Now; modelDifferenceObject.Name = "AutoCreated " + DateTime.Now; var dictionary = new Dictionary(new DictionaryNode(ApplicationNodeWrapper.NodeName), Schema.GetCommonSchema()); modelDifferenceObject.Model=dictionary; }
public void Cause_PersistentApplication_ShouldBe_Unique_Should_Query_DataStore_Befare_Creating_New(){ var application = new PersistentApplication(Session.DefaultSession){UniqueName = "appName"}; application.Save(); var modelDifferenceObject = new ModelDifferenceObject(Session.DefaultSession); modelDifferenceObject.InitializeMembers("", "appName"); Assert.AreEqual(application, modelDifferenceObject.PersistentApplication); }
public void When_Changing_PreferredAspect_To_Default_Then_XmlContent_Should_Have_Only_The_Default_diff(){ var modelDifferenceObject = new ModelDifferenceObject(Session.DefaultSession) { PersistentApplication = new PersistentApplication(Session.DefaultSession) { Model = new Dictionary(Schema.GetCommonSchema()) } }; DefaultDictionary.AddAspect("el", elDictionary.RootNode); modelDifferenceObject.Model = DefaultDictionary; modelDifferenceObject.PreferredAspect = DictionaryAttribute.DefaultLanguage; Assert.AreEqual(new DictionaryXmlReader().ReadFromString(DefaultClassXml).ToXml(), new DictionaryXmlReader().ReadFromString(modelDifferenceObject.XmlContent).ToXml()); }
public void PersistentApplication_Is_Required() { var modelDifferenceObject = new ModelDifferenceObject(Session.DefaultSession) { PersistentApplication = null }; var validationResult = new RuleSet().ValidateTarget(modelDifferenceObject, ContextIdentifier.Save); var validationResultItem = validationResult.Results.Where(item => item.Rule is RuleRequiredField && item.Rule.UsedProperties.Contains(modelDifferenceObject.GetPropertyInfo(x => x.PersistentApplication).Name)).FirstOrDefault(); Assert.IsNull(modelDifferenceObject.PersistentApplication); Assert.IsNotNull(validationResultItem); Assert.AreEqual(ValidationState.Invalid, validationResultItem.State); }
public void When_Changing_PrefferedAspect_To_Non_Default_Then_XmlContent_SHould_CurrentAspect_Diffs() { var modelDifferenceObject = new ModelDifferenceObject(Session.DefaultSession) { PersistentApplication = new PersistentApplication(Session.DefaultSession) { Model = new Dictionary(Schema.GetCommonSchema()) } }; DefaultDictionary.AddAspect("el", elDictionary.RootNode); modelDifferenceObject.Model = DefaultDictionary; modelDifferenceObject.PreferredAspect = "el"; Assert.AreEqual(new DictionaryXmlReader().ReadFromString(elClassXml).ToXml(), new DictionaryXmlReader().ReadFromString(modelDifferenceObject.XmlContent).ToXml()); }
public void When_Updating_Model_It_Should_Add_AllCultures_As_Predifined_Values_Of_CurrentLanguage_Member(){ var dictionary = DictionaryFactory.Create(typeof(ModelDifferenceObject)); var module = new ModelDifferenceModule(); Isolate.WhenCalled(() => module.GetAllCultures()).WillReturn("test"); module.UpdateModel(dictionary); var name = new ModelDifferenceObject(Session.DefaultSession).GetPropertyInfo(x=>x.PreferredAspect).Name; var single = new ApplicationNodeWrapper(dictionary).BOModel.FindClassByType(typeof(ModelDifferenceObject)).AllProperties.Where(wrapper => wrapper.Name==name).Single(); Assert.AreEqual("test", single.Node.GetAttributeValue("PredefinedValues")); }
public override void UpdateDatabaseAfterUpdateSchema() { base.UpdateDatabaseAfterUpdateSchema(); // return; string modelId = typeof(MasterDetailStore).Name; if (new QueryModelDifferenceObject(Session).GetActiveModelDifference(modelId) == null) { ModelDifferenceObject modelDifferenceObject = new ModelDifferenceObject(Session).InitializeMembers(modelId); modelDifferenceObject.Name = modelId; modelDifferenceObject.Save(); } }
public void Many_Disabled_Objects_With_Same_ApplicationName_DifferenceType_Can_Exist(DifferenceType differenceType, ValidationState validationState) { var ruleSet = new RuleSet(); var persistentApplication = new PersistentApplication(Session.DefaultSession); new ModelDifferenceObject(Session.DefaultSession) { Disabled = true, PersistentApplication = persistentApplication }.Save(); var modelDifferenceObject = new ModelDifferenceObject(Session.DefaultSession) { Disabled = true, PersistentApplication = persistentApplication }; Isolate.WhenCalled(() => modelDifferenceObject.DifferenceType).WillReturn(differenceType); RuleSetValidationResult target = ruleSet.ValidateTarget(modelDifferenceObject, ContextIdentifier.Save); var resultItem = target.Results.Where(item => item.Rule is RuleCombinationOfPropertiesIsUnique).Single(); Assert.AreEqual(validationState, resultItem.State); }
public void CurrentObjectModel_Should_Be_Equal_CurrentObject_PersistentApp_Not_Modified_Cloned_Combined_With_Controller_Diffs(){ string s = "<Application><BOModel><Class Name=\"MyClass2\" Caption=\"el\"></Class></BOModel></Application>"; var modelEditorPropertyEditor = new ModelEditorPropertyEditor(null, null); Isolate.WhenCalled(() => modelEditorPropertyEditor.Control.Controller.IsModified).WillReturn(true); var modelDifferenceObject = new ModelDifferenceObject(Session.DefaultSession); Isolate.WhenCalled(() => modelEditorPropertyEditor.CurrentObject).WillReturn(modelDifferenceObject); Isolate.WhenCalled(() => modelDifferenceObject.PersistentApplication.Model.Clone()).WillReturn(DefaultDictionary2); Isolate.WhenCalled(() => modelEditorPropertyEditor.Control.Controller.Dictionary.GetDiffs()).WillReturn(new Dictionary(new DictionaryXmlReader().ReadFromString(s),Schema.GetCommonSchema())); modelEditorPropertyEditor.ModifyCurrentObjectModel(); Assert.AreEqual("el", new ApplicationNodeWrapper(modelDifferenceObject.Model).BOModel.FindClassByName("MyClass2").Caption); }
public void As_Active_Difference_Will_Return_Active_ModelActiveObjects() { var store = Isolate.Fake.Instance<XpoModelDictionaryDifferenceStore>(Members.CallOriginal, ConstructorWillBe.Called, Session.DefaultSession, Isolate.Fake.Instance<XafApplication>(), false); Isolate.Fake.StaticMethods(typeof(ModelDifferenceObjectBuilder)); var modelStoreObject = new ModelDifferenceObject(Session.DefaultSession); var queryModelDifferenceObject = Isolate.Fake.InstanceAndSwapAll<QueryModelDifferenceObject>(); Isolate.WhenCalled(() => queryModelDifferenceObject.GetActiveModelDifference("")).WillReturn(modelStoreObject); ModelDifferenceObject newDifference = store.GetActiveDifferenceObject(); Assert.AreEqual(modelStoreObject, newDifference); }
public void When_Changing_XmlContent_It_Should_Be_Validated_Against_Application_Schema(){ var modelDifferenceObject = new ModelDifferenceObject(Session.DefaultSession){ PersistentApplication =new PersistentApplication(Session.DefaultSession) { Model = DefaultDictionary } }; var dictionary = Isolate.Fake.InstanceAndSwapAll<Dictionary>(Members.CallOriginal,ConstructorWillBe.Called); bool validated = false; Isolate.WhenCalled(() => dictionary.Validate()).DoInstead(context => validated= true); modelDifferenceObject.XmlContent = "<Application/>"; Assert.IsTrue(validated); }
public void DateCreated_Can_Not_Be_Null(DifferenceType differenceType, ValidationState validationState) { var o = new ModelDifferenceObject(Session.DefaultSession); Isolate.WhenCalled(() => o.DifferenceType).WillReturn(differenceType); var ruleSet = new RuleSet(); RuleSetValidationResult target = ruleSet.ValidateTarget(o, ContextIdentifier.Save); RuleSetValidationResultItem @default = target.Results.Where( item => item.Rule is RuleRequiredField && ((RuleRequiredField)item.Rule).TargetMember.Name == o.GetPropertyInfo(x => x.DateCreated).Name).FirstOrDefault(); Assert.AreEqual(validationState, @default.State); }
protected internal override void OnDifferenceObjectSaving(ModelDifferenceObject userModelDifferenceObject, Dictionary diffDictionary){ var userStoreObject = ((UserModelDifferenceObject) userModelDifferenceObject); if (!userStoreObject.NonPersistent){ base.OnDifferenceObjectSaving(userModelDifferenceObject, diffDictionary); } if (SecuritySystem.Instance is ISecurityComplex&& IsGranted()){ ObjectSpace space = Application.CreateObjectSpace(); IQueryable<ModelDifferenceObject> differences = GetDifferences(space); foreach (var difference in differences){ combineDifference(userModelDifferenceObject, diffDictionary, difference); } space.CommitChanges(); } }
public void CurrentObject_Model_Should_Be_Validated_Every_Time_CurrentObject_Is_Saving(){ var editor = new ModelEditorPropertyEditor(null, null); bool validated = false; Isolate.WhenCalled(() => editor.Control.Controller.Dictionary.GetDiffs()).ReturnRecursiveFake(); Isolate.WhenCalled(() => editor.Control.Controller.Dictionary.Validate()).DoInstead(context => validated=true); var objectSpace = new ObjectSpace(new UnitOfWork(XpoDefault.DataLayer),XafTypesInfo.Instance); var modelDifferenceObject = new ModelDifferenceObject(objectSpace.Session) { PersistentApplication = new PersistentApplication(objectSpace.Session) }; editor.CurrentObject = modelDifferenceObject; editor.Setup(objectSpace, Isolate.Fake.Instance<XafApplication>()); objectSpace.CommitChanges(); Assert.IsTrue(validated); }
public void Should_InitializeMembers() { var controller = new ViewControllerFactory().CreateController<CreateNewDifferenceObjectViewController>(ViewType.DetailView,new ModelDifferenceObject(Session.DefaultSession){PersistentApplication = new PersistentApplication(Session.DefaultSession)}); var modelAspectObject = new ModelDifferenceObject(Session.DefaultSession){PersistentApplication = new PersistentApplication(Session.DefaultSession)}; bool called = false; Isolate.WhenCalled(() => modelAspectObject.InitializeMembers("", "")).DoInstead(context => { called = true; return modelAspectObject; }); controller.OnObjectCreated(null, new ObjectCreatedEventArgs(modelAspectObject, null)); Assert.IsTrue(called); }
public void Same_Application_Objets_Cannot_Exist(DifferenceType differenceType, ValidationState validationState) { var ruleSet = new RuleSet(); var persistentApplication = new PersistentApplication(Session.DefaultSession); var modelDifferenceObject = new ModelDifferenceObject(Session.DefaultSession) { PersistentApplication = persistentApplication }; modelDifferenceObject.Save(); var modelDifferenceObject1 = new ModelDifferenceObject(Session.DefaultSession) { PersistentApplication = persistentApplication }; Isolate.WhenCalled(() => modelDifferenceObject1.DifferenceType).WillReturn(differenceType); RuleSetValidationResult target = ruleSet.ValidateTarget(modelDifferenceObject1, ContextIdentifier.Save); Assert.IsInstanceOfType(typeof(RuleCombinationOfPropertiesIsUnique), target.Results[0].Rule); Assert.AreEqual(validationState, target.Results[0].State); }
public void Before_Application_Saving_Current_Object_Should_Validate_ModelEditorControl_Dictionary() { bool validated = false; var editor = new ModelEditorPropertyEditor(null, null); var modelDifferenceObject = new ModelDifferenceObject(Session.DefaultSession); Isolate.WhenCalled(() => editor.CurrentObject).WillReturn(modelDifferenceObject); Isolate.WhenCalled(() => editor.Control.Controller.Dictionary.Validate()).DoInstead(context => validated=true); var objectSpace = Isolate.Fake.Instance<ObjectSpace>(); using (RecorderManager.StartRecording()){ objectSpace.ObjectSaving += null; } editor.Setup(objectSpace, null); var handler = (EventHandler<ObjectManipulatingEventArgs>) RecorderManager.LastMockedEvent.GetEventHandle(); handler.Invoke(this,new ObjectManipulatingEventArgs(modelDifferenceObject)); Assert.IsTrue(validated); }
public void Create_A_New_DifferenceObject_If_No_Active_DifferenceObject_Found() { var modelAspectObject = new ModelDifferenceObject(Session.DefaultSession); Isolate.Swap.AllInstances<ModelDifferenceObject>().With(modelAspectObject); Isolate.WhenCalled(() => modelAspectObject.Save()).IgnoreCall(); var application = Isolate.Fake.Instance<XafApplication>(); application.ApplicationName = "ApplicationName"; var dictionary = new Dictionary(Schema.GetCommonSchema()); Isolate.WhenCalled(() => dictionary.Aspects).WillReturn(new List<string> { "aspect" }); Isolate.WhenCalled(() => application.Model).WillReturn(dictionary); var store = Isolate.Fake.Instance<XpoDictionaryDifferenceStore>(Members.CallOriginal, ConstructorWillBe.Called, new object[] { Session.DefaultSession, application }); Isolate.WhenCalled(() => store.GetNewDifferenceObject(null)).WillReturn(modelAspectObject); Isolate.WhenCalled(() => store.GetActiveDifferenceObject()).WillReturn(null); store.SaveDifference(dictionary); Isolate.Verify.WasCalledWithAnyArguments(() => modelAspectObject.Save()); }
public void Some_Properties_Should_Change(){ DateTime dateTime = DateTime.Now; Mock mock = MockManager.Mock(typeof (CloneObjectViewController),Constructor.NotMocked); mock.CallBase.ExpectAlways("CloneObject"); var singleChoiceActionExecuteEventArgs = Isolate.Fake.InstanceAndSwapAll<SingleChoiceActionExecuteEventArgs>(); var data = new ModelDifferenceObject(Session.DefaultSession){Name = "name"}; Isolate.WhenCalled(() => singleChoiceActionExecuteEventArgs.ShowViewParameters.CreatedView.CurrentObject).WillReturn(data); var persistentApplication = new PersistentApplication(Session.DefaultSession); var controller = new ViewControllerFactory().CreateController<CloneObjectViewController>(ViewType.DetailView, new ModelDifferenceObject(Session.DefaultSession){PersistentApplication = persistentApplication}); controller.CloneObjectAction.Active.Clear(); controller.CloneObjectAction.DoExecute(new ChoiceActionItem(new DictionaryNode(""), data)); Assert.IsNull(data.Name); Assert.IsTrue(data.Disabled); Assert.GreaterThan(data.DateCreated, dateTime); Assert.AreEqual(persistentApplication, data.PersistentApplication); }
public void When_Saving_Combine_With_Application_InstanceModel() { var controller = Isolate.Fake.Instance<CombineActiveModelDictionaryController<ModelDifferenceObject>>(Members.CallOriginal); controller.Application = Isolate.Fake.Instance<XafApplication>(); var dictionary = DefaultDictionary; var modelDifferenceObject = new ModelDifferenceObject(Session.DefaultSession) { Model = dictionary, PersistentApplication =new PersistentApplication(Session.DefaultSession) { Name = "appNAme" } }; Isolate.WhenCalled(() => controller.GetActiveDifference(null, null)).WithExactArguments().WillReturn(modelDifferenceObject); controller.ObjectSpaceOnObjectSaved(null, new ObjectManipulatingEventArgs(modelDifferenceObject)); Assert.IsNotNull(new ApplicationNodeWrapper(controller.Application.Model).BOModel.FindClassByType(typeof(User))); }
public static void SetUp(ModelDifferenceObject modelDifferenceObject, string applicationTypeName) { SetUp(modelDifferenceObject); }
public DictionaryCombiner(ModelDifferenceObject modelDifferenceObject){ _modelDifferenceObject = modelDifferenceObject; }
public void When_PrefferedAspect_Change_Then_Its_Aspect_Should_Be_Added_To_ALl_Models(){ var modelDifferenceObject = new ModelDifferenceObject(Session.DefaultSession){PersistentApplication = new PersistentApplication(Session.DefaultSession)}; Dictionary dictionary = DefaultDictionary; modelDifferenceObject.Model=dictionary; modelDifferenceObject.PersistentApplication.Model=DefaultDictionary2; modelDifferenceObject.PreferredAspect = "el blah"; Assert.AreEqual("el", modelDifferenceObject.CurrentLanguage); Assert.Contains(modelDifferenceObject.Model.Aspects,"el"); Assert.Contains(modelDifferenceObject.PersistentApplication.Model.Aspects,"el"); }