public void VerifyThatDragOverWorksForParameter()
        {
            var vm = new RelationalExpressionRowViewModel(this.relationalExpression, this.session.Object, null);

            var dropinfo = new Mock <IDropInfo>();

            dropinfo.Setup(x => x.Payload).Returns(this.parameter);

            dropinfo.SetupProperty(x => x.Effects);
            vm.DragOver(dropinfo.Object);

            Assert.AreEqual(DragDropEffects.Copy, dropinfo.Object.Effects);
        }
        public void VerifyThatDropWorksCorrectlyForNotSupportedType()
        {
            var vm = new RelationalExpressionRowViewModel(this.relationalExpression, this.session.Object, null);

            var dropinfo = new Mock <IDropInfo>();

            dropinfo.Setup(x => x.Payload).Returns(this.iteration);

            dropinfo.SetupProperty(x => x.Effects);
            vm.DragOver(dropinfo.Object);

            this.thingCreator.Verify(x => x.CreateBinaryRelationshipForRequirementVerification(It.IsAny <ISession>(), It.IsAny <Iteration>(), It.IsAny <ParameterOrOverrideBase>(), It.IsAny <RelationalExpression>()), Times.Never);
        }
        public void VerifyThatDragOverWorksCorrectlyForNotSupportedType()
        {
            var vm = new RelationalExpressionRowViewModel(this.relationalExpression, this.session.Object, null);

            var dropinfo = new Mock <IDropInfo>();

            dropinfo.Setup(x => x.Payload).Returns(this.iteration);

            dropinfo.SetupProperty(x => x.Effects);
            vm.DragOver(dropinfo.Object);

            Assert.AreEqual(DragDropEffects.None, dropinfo.Object.Effects);
        }
        public void VerifyThatRequirementStateOfComplianceIsResetOnChanges()
        {
            var vm = new RelationalExpressionRowViewModel(this.relationalExpression, this.session.Object, null)
            {
                RequirementStateOfCompliance = RequirementStateOfCompliance.Pass
            };

            var type = this.relationalExpression.GetType();

            type.GetProperty("RevisionNumber")?.SetValue(this.relationalExpression, 50);
            CDPMessageBus.Current.SendObjectChangeEvent(this.relationalExpression, EventKind.Updated);

            Assert.AreEqual(RequirementStateOfCompliance.Unknown, vm.RequirementStateOfCompliance);
        }
        public async Task VerifyThatDropWorksForParameterOverride()
        {
            var vm = new RelationalExpressionRowViewModel(this.relationalExpression, this.session.Object, null);

            var dropinfo = new Mock <IDropInfo>();

            dropinfo.Setup(x => x.Payload).Returns(this.parameterOverride);
            dropinfo.Setup(x => x.Effects).Returns(DragDropEffects.Copy);

            dropinfo.SetupProperty(x => x.Effects);
            await vm.Drop(dropinfo.Object);

            this.thingCreator.Verify(x => x.CreateBinaryRelationshipForRequirementVerification(It.IsAny <ISession>(), It.IsAny <Iteration>(), It.IsAny <ParameterOrOverrideBase>(), It.IsAny <RelationalExpression>()), Times.Once);
        }
Beispiel #6
0
        public void VerifyReactiveCommandsCanExecute()
        {
            this.session.Setup(x => x.RetrieveSiteDirectory()).Returns(this.siteDir);
            this.session.Setup(x => x.ActivePerson).Returns(new Person(Guid.NewGuid(), null, this.uri));
            this.mrdl.ParameterType.Add(new SimpleQuantityKind(Guid.NewGuid(), null, this.uri)
            {
                ShortName = "test"
            });

            var vm = new ParametricConstraintDialogViewModel(
                this.parametricConstraint,
                this.thingTransaction,
                this.session.Object,
                true,
                ThingDialogKind.Create,
                this.thingDialogNavigationService.Object,
                this.clone);

            Assert.AreEqual(1, vm.Expression.Count);
            Assert.IsNull(vm.SelectedExpression);
            Assert.IsTrue(vm.CreateNotExpression.CanExecute(null));
            Assert.IsFalse(vm.CreateAndExpression.CanExecute(null));
            Assert.IsFalse(vm.CreateOrExpression.CanExecute(null));
            Assert.IsFalse(vm.CreateExclusiveOrExpression.CanExecute(null));

            vm.SelectedExpression = vm.Expression.First();

            var relationalExpression2   = new RelationalExpression(Guid.NewGuid(), this.cache, this.uri);
            var relationalExpressionRow = new RelationalExpressionRowViewModel(
                relationalExpression2,
                this.session.Object,
                vm);

            vm.Expression.Add(relationalExpressionRow);
            vm.BooleanExpression.Add(relationalExpressionRow.Thing);

            Assert.IsTrue(vm.CreateAndExpression.CanExecute(null));
            Assert.IsTrue(vm.CreateOrExpression.CanExecute(null));
            Assert.IsTrue(vm.CreateExclusiveOrExpression.CanExecute(null));
        }