public void WhenSummaryRequestOperationisCompleted_ThenUpdatesCurrentSummaryAndStatusChangesToNormal()
        {
            var questionnaireRepositoryMock = new Mock <IQuestionnaireRepository>();

            Action <IOperationResult <QuestionnaireTemplateSummary> > summaryCallback = null;
            var summary = new QuestionnaireTemplateSummary();

            questionnaireRepositoryMock
            .Setup(qs => qs.GetQuestionnaireTemplateSummaryAsync(It.IsAny <QuestionnaireTemplate>(), It.IsAny <Action <IOperationResult <QuestionnaireTemplateSummary> > >()))
            .Callback <QuestionnaireTemplate, Action <IOperationResult <QuestionnaireTemplateSummary> > >((qt, ac) => summaryCallback = ac);

            var viewModel = new QuestionnaireTemplateSummaryViewModel(questionnaireRepositoryMock.Object);

            viewModel.CurrentlySelectedQuestionnaireTemplate = new QuestionnaireTemplate();

            var summaryResult = new Mock <IOperationResult <QuestionnaireTemplateSummary> >();

            summaryResult.SetupGet(r => r.Result).Returns(summary);

            var tracker = new PropertyChangeTracker(viewModel);

            summaryCallback(summaryResult.Object);

            Assert.AreEqual("Normal", viewModel.CurrentState);
            Assert.AreSame(summary, viewModel.QuestionnaireTemplateSummary);
            CollectionAssert.Contains(tracker.ChangedProperties, "CurrentState");
            CollectionAssert.Contains(tracker.ChangedProperties, "QuestionnaireTemplateSummary");
        }
        public void Dispose()
        {
            var bus = ServiceContainer.Resolve <MessageBus> ();

            if (propertyTracker != null)
            {
                propertyTracker.Dispose();
                propertyTracker = null;
            }
            if (subscriptionSettingChanged != null)
            {
                bus.Unsubscribe(subscriptionSettingChanged);
                subscriptionSettingChanged = null;
            }
            if (subscriptionAuthChanged != null)
            {
                bus.Unsubscribe(subscriptionAuthChanged);
                subscriptionAuthChanged = null;
            }
            if (propertyTracker != null)
            {
                propertyTracker.Dispose();
                propertyTracker = null;
            }
        }
 private void Unsubscribe(PropertyChangeTracker tracker)
 {
     _tracker.ChangesAdded  -= OnChangesAdded;
     _tracker.ChangeRemoved -= OnChangesRemoved;
     _tracker.ChangeRedone  -= OnChangeRedone;
     _tracker.ChangeUndone  -= OnChangeUndone;
 }
        public void SerializeEntity_existing_entity_relational_collection_property_changes()
        {
            MockEntity            entity             = new MockEntity();
            MockAssociativeEntity associativeEntity1 = new MockAssociativeEntity();
            MockAssociativeEntity associativeEntity2 = new MockAssociativeEntity();

            entity.AssociativeEntities.Add(associativeEntity1);
            entity.AssociativeEntities.Add(associativeEntity2);
            PropertyChangeTracker tracker = new PropertyChangeTracker(entity);

            tracker.Start();
            associativeEntity1.BoolProperty = true;
            associativeEntity2.IntProperty  = 1;

            string json = DbEntityJsonConvert.SerializeEntity(entity, tracker.DbEntityChanges());

            MockEntity deserialised = TypeExtensions.DeserializeObject <MockEntity>(json);

            Assert.AreEqual("{\"$id\":\"" + entity.Guid + "\",\"Guid\":\"" + entity.Guid + "\",\"AssociativeEntities\":[{\"$id\":\"" + associativeEntity1.Guid + "\",\"Guid\":\"" + associativeEntity1.Guid + "\",\"BoolProperty\":" + associativeEntity1.BoolProperty.ToString().ToLower() + "},{\"$id\":\"" + associativeEntity2.Guid + "\",\"Guid\":\"" + associativeEntity2.Guid + "\",\"IntProperty\":" + associativeEntity2.IntProperty + "}]}", json);
            Assert.AreEqual(entity.Guid, deserialised.Guid);
            Assert.AreEqual(associativeEntity1.Guid, deserialised.AssociativeEntities.First().Guid);
            Assert.AreEqual(associativeEntity1.BoolProperty, deserialised.AssociativeEntities.First().BoolProperty);
            Assert.AreEqual(associativeEntity2.Guid, deserialised.AssociativeEntities.Last().Guid);
            Assert.AreEqual(associativeEntity2.IntProperty, deserialised.AssociativeEntities.Last().IntProperty);
        }
        public void Dispose()
        {
            var bus = ServiceContainer.Resolve <MessageBus> ();

            if (propertyTracker != null)
            {
                propertyTracker.Dispose();
                propertyTracker = null;
            }
            if (subscriptionSettingChanged != null)
            {
                bus.Unsubscribe(subscriptionSettingChanged);
                subscriptionSettingChanged = null;
            }
            if (timeEntryManager != null)
            {
                timeEntryManager.PropertyChanged -= OnActiveTimeEntryManagerPropertyChanged;
                timeEntryManager = null;
            }
            if (propertyTracker != null)
            {
                propertyTracker.Dispose();
                propertyTracker = null;
            }
        }
Example #6
0
        public void TestTracker(Action <PropertyChangeTracker> injection, bool shouldNotify)
        {
            var tracker    = new PropertyChangeTracker();
            var demoObject = DemoObject.Bake();

            string detectedChangedTargetName = null;

            tracker.Add(demoObject, ((string obj) => {
                detectedChangedTargetName = obj;
            }));

            if (injection != null)
            {
                injection(tracker);
            }

            string changedTargetName = demoObject.Change();

            if (shouldNotify)
            {
                Assert.That(changedTargetName, Is.EqualTo(detectedChangedTargetName));
            }
            else
            {
                Assert.That(changedTargetName, Is.Not.EqualTo(detectedChangedTargetName));
            }
        }
        public void AfterResetting_ThenANewQuestionnaireIsCreated()
        {
            QuestionViewModel[] originalQuestions = null;
            Action <IOperationResult <Questionnaire> > callback = null;

            var repository = new Mock <IQuestionnaireRepository>();

            repository.Setup(r => r.GetQuestionnaireAsync(It.IsAny <Action <IOperationResult <Questionnaire> > >()))
            .Callback <Action <IOperationResult <Questionnaire> > >(c => callback = c);

            var viewModel = new QuestionnaireViewModel(repository.Object);

            callback(CreateQuestionnaireResult());

            originalQuestions = viewModel.Questions.ToArray();

            viewModel.Questionnaire.Name = "TestName";
            viewModel.Questionnaire.Age  = 14;
            AnswerAllQuestions(viewModel);

            viewModel.Reset();

            var tracker = new PropertyChangeTracker(viewModel);

            callback(CreateQuestionnaireResult());

            CollectionAssert.AreNotEquivalent(originalQuestions, viewModel.Questions.ToArray());
            CollectionAssert.Contains(tracker.ChangedProperties, "CanSubmit");
        }
        public void AfterSubmittingQuestionnaire_ThenChangeDataRelatedNotificationsAreFired()
        {
            Action <IOperationResult <Questionnaire> > callback = null;
            Action <IOperationResult> submitCallback            = null;

            var repository = new Mock <IQuestionnaireRepository>();

            repository.Setup(r => r.GetQuestionnaireAsync(It.IsAny <Action <IOperationResult <Questionnaire> > >()))
            .Callback <Action <IOperationResult <Questionnaire> > >(c => callback = c);
            repository.Setup(r => r.SubmitQuestionnaireAsync(It.IsAny <Questionnaire>(), It.IsAny <Action <IOperationResult> >()))
            .Callback <Questionnaire, Action <IOperationResult> >(
                (q, sc) => submitCallback = sc);

            var viewModel = new QuestionnaireViewModel(repository.Object);

            callback(CreateQuestionnaireResult());

            var tracker = new PropertyChangeTracker(viewModel);

            viewModel.Questionnaire.Name = "TestName";
            viewModel.Questionnaire.Age  = 25;
            AnswerAllQuestions(viewModel);

            viewModel.Submit();
            submitCallback(new Mock <IOperationResult>().Object);
            callback(CreateQuestionnaireResult());

            Assert.IsTrue(tracker.ChangedProperties.Contains("Questionnaire"));
        }
        public void WhenServiceIsDoneSubmitting_ThenStateIsSetToNormal()
        {
            Action <IOperationResult <Questionnaire> > callback = null;
            Action <IOperationResult> submitCallback            = null;

            var repository = new Mock <IQuestionnaireRepository>();

            repository.Setup(r => r.GetQuestionnaireAsync(It.IsAny <Action <IOperationResult <Questionnaire> > >()))
            .Callback <Action <IOperationResult <Questionnaire> > >(c => callback = c);
            repository.Setup(r => r.SubmitQuestionnaireAsync(It.IsAny <Questionnaire>(), It.IsAny <Action <IOperationResult> >()))
            .Callback <Questionnaire, Action <IOperationResult> >(
                (q, sc) => submitCallback = sc);

            var viewModel = new QuestionnaireViewModel(repository.Object);

            callback(CreateQuestionnaireResult());

            viewModel.Submit();
            Assert.AreEqual("Submitting", viewModel.CurrentState);

            var tracker = new PropertyChangeTracker(viewModel);

            // Responds as the service would.
            submitCallback(new Mock <IOperationResult>().Object);
            callback(CreateQuestionnaireResult());

            Assert.AreEqual("Normal", viewModel.CurrentState);
            CollectionAssert.Contains(tracker.ChangedProperties, "CanSubmit");
        }
        public void WhenQuestionnaireIsCreatedWithService_ThenRetrievesQuestionnaireFromService()
        {
            Action <IOperationResult <Questionnaire> > callback = null;

            var repository = new Mock <IQuestionnaireRepository>();

            repository.Setup(r => r.GetQuestionnaireAsync(It.IsAny <Action <IOperationResult <Questionnaire> > >()))
            .Callback <Action <IOperationResult <Questionnaire> > >(c => callback = c);

            var viewModel     = new QuestionnaireViewModel(repository.Object);
            var changeTracker = new PropertyChangeTracker(viewModel);

            Assert.AreEqual("Loading", viewModel.CurrentState);
            Assert.AreEqual(0, changeTracker.ChangedProperties.Count());

            callback(CreateQuestionnaireResult());

            // Assertions
            Assert.IsTrue(changeTracker.ChangedProperties.Contains("Questionnaire"));
            Assert.AreEqual("Normal", viewModel.CurrentState);
            Assert.IsTrue(changeTracker.ChangedProperties.Contains("CurrentState"));
            CollectionAssert.AreEqual(
                new[] { "Enter your name", "Enter your address" },
                viewModel.Questions.Cast <OpenQuestionViewModel>().Select(q => q.Question.QuestionText).ToArray());
        }
Example #11
0
 public void OnDestroy(Activity activity)
 {
     if (propertyTracker != null)
     {
         propertyTracker.Dispose();
         propertyTracker = null;
     }
 }
        public void Tracker_SinglePropertyNotChanged_ReturnsFalse()
        {
            var changer = new FakePropertiesClass("John", "Smith");
            var tracker = new PropertyChangeTracker(changer);

            var result = tracker.WaitForChange("LastName", 100);

            Assert.IsFalse(result);
        }
        public void WhenNotifyingOnAnInstancePropertyThenAnEventIsFired()
        {
            var testObject    = new TestValidationObject();
            var changeTracker = new PropertyChangeTracker(testObject);

            testObject.InstanceProperty = "newValue";

            Assert.IsTrue(changeTracker.ChangedProperties.Contains("InstanceProperty"));
        }
    public void WhenNotifyingOnAnInstancePropertyThenAnEventIsFired()
    {
      var testObject = new TestNotificationObject();
      var changeTracker = new PropertyChangeTracker(testObject);

      testObject.InstanceProperty = "newValue";

      Assert.IsTrue(changeTracker.ChangedProperties.Contains("InstanceProperty"));
    }
Example #15
0
        public void OnCreate(Activity activity)
        {
            this.activity   = activity;
            propertyTracker = new PropertyChangeTracker();

            Root = LayoutInflater.From(activity).Inflate(Resource.Layout.TimerComponent, null);

            FindViews();
        }
        public void Tracker_SinglePropertyAsyncNotCompleted_ReturnsFalse()
        {
            var changer = new FakePropertiesClass("John", "Smith");
            var tracker = new PropertyChangeTracker(changer);

            UpdateProperty(50, changer);
            var result = tracker.WaitForChange("LastName", 20);

            Assert.IsFalse(result);
        }
        public override void OnStart()
        {
            base.OnStart();

            propertyTracker = new PropertyChangeTracker();
            canRebind       = true;

            Rebind();
            RebindTags();
        }
        public void Tracker_MaxWaitExpired_ReturnsFalse()
        {
            var changer = new FakePropertiesClass("John", "Smith");
            var tracker = new PropertyChangeTracker(changer);
            var maxWait = new TimeSpan(0, 0, 0, 0, 60);

            var result = tracker.WaitForChange("LastName", maxWait);

            Assert.IsFalse(result);
        }
        public void Tracker_AllPropertiesChanged_ReturnsTrue()
        {
            var changer = new FakePropertiesClass("John", "Smith");
            var tracker = new PropertyChangeTracker(changer);

            changer.NotifyAllProperties();
            var result = tracker.WaitForChange("LastName", 100);

            Assert.IsTrue(result);
        }
        public override void OnStop ()
        {
            base.OnStop ();

            canRebind = false;

            if (propertyTracker != null) {
                propertyTracker.Dispose ();
                propertyTracker = null;
            }
        }
 private void ClearTracker()
 {
     if (_tracker != null)
     {
         Unsubscribe(_tracker);
         _tracker.Validated -= RaiseValidated;
         _tracker.Stop();
         _tracker.Dispose();
         _tracker = null;
     }
 }
        public void HasChanged_Returns_True_For_Unsaved_Entity()
        {
            // arrange
            var propertyChangeTracker = new PropertyChangeTracker(new Artist());

            // act
            var result = propertyChangeTracker.HasChanged <Artist>(x => x.Name);

            // assert
            Assert.True(result);
        }
        public void AddCollectionChangedItem_Adds_ChangedItem(CollectionChangeType changeType)
        {
            // arrange
            var entity = TestHelper.CreateEntityWithId <Artist>(1);
            var propertyChangeTracker = new PropertyChangeTracker(entity);

            // act
            propertyChangeTracker.AddCollectionChangedItem(new CollectionChangedItem("StatisticValues", null, changeType));

            // assert
            Assert.True(propertyChangeTracker.HasChanged <Artist>(x => x.StatisticValues));
        }
Example #24
0
        public void WhenSettingTheResponseTextPropertyOnTheModel_ThenAChangeOnAvailableLengthIsNotifiedOnTheViewModel()
        {
            var question = new OpenQuestionTemplate {
                QuestionText = "Question", MaxLength = 25
            }.CreateNewQuestion() as OpenQuestion;
            var viewModel = new OpenQuestionViewModel(question);

            var changeTracker = new PropertyChangeTracker(viewModel);

            question.Response = "1234567890";

            Assert.IsTrue(changeTracker.ChangedProperties.Contains("AvailableLength"));
        }
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (tracker != null)
                {
                    tracker.Dispose();
                    tracker = null;
                }
            }

            base.Dispose(disposing);
        }
        public void HasChanged_Works()
        {
            // arrange
            var entity = TestHelper.CreateEntityWithId <Artist>(1);
            var propertyChangeTracker = new PropertyChangeTracker(entity);

            propertyChangeTracker.AddPropertyChangedItem <Artist>(x => x.Name, "OldValue", "NewValue");

            // act
            var result = propertyChangeTracker.HasChanged <Artist>(x => x.Name);

            // assert
            Assert.True(result);
        }
        public void HasChanged_Should_Not_Track_Property_Changes_With_The_Same_NewValue_As_The_Old_Value()
        {
            // arrange
            var entity = TestHelper.CreateEntityWithId <Artist>(1);
            var propertyChangeTracker = new PropertyChangeTracker(entity);

            propertyChangeTracker.AddPropertyChangedItem <Artist>(x => x.Name, "TestValue", "TestValue");

            // act
            var result = propertyChangeTracker.HasChanged <Artist>(x => x.Name);

            // assert
            Assert.False(result);
        }
        public void GetChangedProperties_Works()
        {
            // arrange
            var entity = TestHelper.CreateEntityWithId <Artist>(1);
            var propertyChangeTracker = new PropertyChangeTracker(entity);

            propertyChangeTracker.AddPropertyChangedItem <Artist>(x => x.Name, "OldValue", "NewValue");

            // act
            var result = propertyChangeTracker.GetChangedProperties();

            // asset
            Assert.Equal("Name", result.First());
        }
        public void Clear_Any_Changes_Are_Discarded()
        {
            // arrange
            var entity = TestHelper.CreateEntityWithId <Artist>(1);
            var propertyChangeTracker = new PropertyChangeTracker(entity);

            propertyChangeTracker.AddPropertyChangedItem <Artist>(x => x.Name, "OldValue", "NewValue");

            // act
            propertyChangeTracker.Clear();

            // asset
            Assert.False(propertyChangeTracker.HasChanges);
        }
        public void HasChanged_Returns_True_For_Newly_Created_Entity_ForeignKey()
        {
            // arrange
            var entity = TestHelper.CreateEntityWithId <Artist>(1);
            var propertyChangeTracker = new PropertyChangeTracker(entity);

            propertyChangeTracker.AddPropertyChangedItem <Artist>(x => x.FK_AnotherArtist_ID, 0, 0);

            // act
            var result = propertyChangeTracker.HasChanged <Artist>(x => x.FK_AnotherArtist_ID);

            // assert
            Assert.True(result);
        }
        public void WhenValidationOnAnInstancePropertyWithEmptyError()
        {
            var testObject    = new TestValidationObject();
            var changeTracker = new PropertyChangeTracker(testObject);

            testObject.InstanceProperty = null;

            Assert.IsTrue(changeTracker.ChangedProperties.Contains("InstanceProperty"));
            Assert.IsInstanceOfType(testObject, typeof(IDataErrorInfo));

            var errorInfo = (IDataErrorInfo)testObject;

            Assert.AreEqual("The InstanceProperty field is required.", errorInfo["InstanceProperty"]);
        }
    public void WhenValidationOnAnInstancePropertyWithEmptyError()
    {
      var testObject = new TestValidationObject();
      var changeTracker = new PropertyChangeTracker(testObject);

      testObject.InstanceProperty = null;

      Assert.IsTrue(changeTracker.ChangedProperties.Contains("InstanceProperty"));
      Assert.IsInstanceOfType(testObject, typeof(INotifyDataErrorInfo));

      var errorInfo = (INotifyDataErrorInfo)testObject;
      var list = errorInfo.GetErrors("InstanceProperty").Cast<string>().ToList();
      CollectionAssert.Contains(list, "The InstanceProperty field is required.");
    }
    public void WhenValidationOnMaxPropertyErrorThenNoError()
    {
      var testObject = new TestValidationObject();
      var changeTracker = new PropertyChangeTracker(testObject);

      testObject.MaxValue = 0;

      Assert.IsTrue(changeTracker.ChangedProperties.Contains("MaxValue"));
      Assert.IsInstanceOfType(testObject, typeof(INotifyDataErrorInfo));

      var errorInfo = (INotifyDataErrorInfo)testObject;
      var list = errorInfo.GetErrors("MaxValue").Cast<string>().ToList();
      CollectionAssert.Contains(list, "The field MaxValue must be between 1 and 10.");

      changeTracker.Reset();
      testObject.MaxValue = 2;

      Assert.IsTrue(changeTracker.ChangedProperties.Contains("MaxValue"));
      list = errorInfo.GetErrors("MaxValue").Cast<string>().ToList();
      Assert.AreEqual(0, list.Count);
    }
    public void WhenValidationOnAnInstancePropertyWithEmptyError()
    {
      var testObject = new TestValidationObject();
      var changeTracker = new PropertyChangeTracker(testObject);

      testObject.InstanceProperty = null;

      Assert.IsTrue(changeTracker.ChangedProperties.Contains("InstanceProperty"));      
      Assert.IsInstanceOfType(testObject, typeof(IDataErrorInfo));

      var errorInfo = (IDataErrorInfo)testObject;
      Assert.AreEqual("The InstanceProperty field is required.", errorInfo["InstanceProperty"]);
    }
    public void WhenValidationOnMaxPropertyErrorThenNoError()
    {
      var testObject = new TestValidationObject();
      var changeTracker = new PropertyChangeTracker(testObject);

      testObject.MaxValue = 0;

      Assert.IsTrue(changeTracker.ChangedProperties.Contains("MaxValue"));
      Assert.IsInstanceOfType(testObject, typeof(IDataErrorInfo));

      var errorInfo = (IDataErrorInfo)testObject;
      Assert.AreEqual("The field MaxValue must be between 1 and 10.", errorInfo["MaxValue"]);

      changeTracker.Reset();
      testObject.MaxValue = 2;

      Assert.IsTrue(changeTracker.ChangedProperties.Contains("MaxValue"));
      Assert.AreEqual(null, errorInfo["MaxValue"]);
    }