示例#1
0
        public void VerifyCreateWithoutContainerUpdateValidation()
        {
            this.mockedMetaInfoProvider.Setup(x => x.GetMetaInfo(It.IsAny <SimpleQuantityKind>())).Returns(this.simpleQuantityKindMetaInfo);
            this.mockedMetaInfoProvider.Setup(x => x.GetMetaInfo(It.IsAny <string>())).Returns(this.thingMetaInfo);
            this.mockedMetaInfoProvider.Setup(x => x.GetMetaInfo(It.Is <string>(y => y == SimpleQuantityKindTypeString))).Returns(this.simpleQuantityKindMetaInfo);

            var newSimpleQuantityKind = new SimpleQuantityKind(Guid.NewGuid(), 0)
            {
                Alias         = new List <Guid>(),
                Definition    = new List <Guid>(),
                HyperLink     = new List <Guid>(),
                PossibleScale = new List <Guid>(),
                Name          = TestName,
                ShortName     = TestShortName,
                Symbol        = "testSymbol"
            };

            var postOperation = new CdpPostOperation();

            postOperation.Create.Add(newSimpleQuantityKind);

            Assert.Throws(
                typeof(InvalidOperationException),
                () => this.operationProcessor.ValidateCreateOperations(postOperation, this.fileStore));
        }
示例#2
0
        public void Verify_that_when_the_DefaultScale_is_not_in_the_PossibleScales_a_result_is_returned()
        {
            var ratioScale_1 = new RatioScale {
                Iid = Guid.Parse("9fd6eb4f-5fb8-469f-8798-20bf4dd84e95"), ShortName = "scale_1"
            };
            var ratioScale_2 = new RatioScale {
                Iid = Guid.Parse("eed266d7-3ce5-4117-8ca4-2db316ec9cc6"), ShortName = "scale_2"
            };
            var ratioScale_3 = new RatioScale {
                Iid = Guid.Parse("918abf39-87af-4305-91e8-28c17ab274b2"), ShortName = "scale_3"
            };

            var sqk = new SimpleQuantityKind();

            sqk.PossibleScale.Add(ratioScale_1);
            sqk.PossibleScale.Add(ratioScale_2);

            sqk.DefaultScale = ratioScale_3;

            var result = this.quantityKindRuleChecker.ChecksWhetherReferencedDefaultScaleIsInTheCollectionOfPossibleScales(sqk).Single();

            Assert.That(result.Id, Is.EqualTo("MA-0750"));
            Assert.That(result.Description, Is.EqualTo("The QuantityKind.DefaultScale 918abf39-87af-4305-91e8-28c17ab274b2:scale_3 is not in the list of QuantityKind.PossibleScale"));
            Assert.That(result.Thing, Is.EqualTo(sqk));
            Assert.That(result.Severity, Is.EqualTo(SeverityKind.Error));
        }
示例#3
0
        public async Task VerifyThatParameterGetsCreatedWhenParameterTypeIsDropped()
        {
            var domainOfExpertise = new DomainOfExpertise(Guid.NewGuid(), this.assembler.Cache, this.uri);
            var elementDefinition = new ElementDefinition(Guid.NewGuid(), this.assembler.Cache, this.uri);

            elementDefinition.Owner = domainOfExpertise;
            var parameterGroup = new ParameterGroup(Guid.NewGuid(), this.assembler.Cache, this.uri);

            elementDefinition.ParameterGroup.Add(parameterGroup);

            var row = new ParameterGroupRowViewModel(parameterGroup, domainOfExpertise, this.session.Object, null);

            row.ThingCreator = this.thingCreator.Object;

            var simpleQuantityKind = new SimpleQuantityKind(Guid.NewGuid(), this.assembler.Cache, this.uri);
            var ratioScale         = new RatioScale(Guid.NewGuid(), null, null);

            simpleQuantityKind.DefaultScale = ratioScale;

            var payload  = new Tuple <ParameterType, MeasurementScale>(simpleQuantityKind, ratioScale);
            var dropInfo = new Mock <IDropInfo>();

            dropInfo.Setup(x => x.Payload).Returns(payload);
            dropInfo.SetupProperty(x => x.Effects);

            await row.Drop(dropInfo.Object);

            this.thingCreator.Verify(x => x.CreateParameter(elementDefinition, parameterGroup, simpleQuantityKind, ratioScale, domainOfExpertise, this.session.Object));
        }
示例#4
0
        public void VerifyThatNewParameterTypeDragOverSetsCopyEffect()
        {
            this.permissionService.Setup(x => x.CanWrite(It.IsAny <ClassKind>(), It.IsAny <Thing>())).Returns(true);

            var domainOfExpertise = new DomainOfExpertise(Guid.NewGuid(), this.assembler.Cache, this.uri);
            var elementDefinition = new ElementDefinition(Guid.NewGuid(), this.assembler.Cache, this.uri);

            elementDefinition.Owner = domainOfExpertise;
            var parameterGroup = new ParameterGroup(Guid.NewGuid(), this.assembler.Cache, this.uri);

            elementDefinition.ParameterGroup.Add(parameterGroup);

            this.iteration.Element.Add(elementDefinition);

            var row = new ParameterGroupRowViewModel(parameterGroup, domainOfExpertise, this.session.Object, null);

            var simpleQuantityKind = new SimpleQuantityKind(Guid.NewGuid(), this.assembler.Cache, this.uri);
            var ratioScale         = new RatioScale(Guid.NewGuid(), null, null);

            simpleQuantityKind.DefaultScale = ratioScale;
            this.srdl.ParameterType.Add(simpleQuantityKind);

            var payload  = new Tuple <ParameterType, MeasurementScale>(simpleQuantityKind, ratioScale);
            var dropInfo = new Mock <IDropInfo>();

            dropInfo.Setup(x => x.Payload).Returns(payload);
            dropInfo.SetupProperty(x => x.Effects);

            row.DragOver(dropInfo.Object);

            Assert.AreEqual(DragDropEffects.Copy, dropInfo.Object.Effects);
        }
示例#5
0
        public void SetUp()
        {
            Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;

            this.uri   = new Uri("http://www.rheagroup.com");
            this.cache = new ConcurrentDictionary <CDP4Common.Types.CacheKey, Lazy <Thing> >();

            this.ratioScale = new RatioScale(Guid.NewGuid(), this.cache, this.uri);

            var valuedefLow = new EnumerationValueDefinition(Guid.NewGuid(), this.cache, this.uri);

            valuedefLow.ShortName = "low";
            var valuedefMedium = new EnumerationValueDefinition(Guid.NewGuid(), this.cache, this.uri);

            valuedefMedium.ShortName = "medium";

            this.booleanParameterType  = new BooleanParameterType(Guid.NewGuid(), this.cache, this.uri);
            this.dateParameterType     = new DateParameterType(Guid.NewGuid(), this.cache, this.uri);
            this.dateTimeParameterType = new DateTimeParameterType(Guid.NewGuid(), this.cache, this.uri);

            this.enumerationParameterType      = new EnumerationParameterType(Guid.NewGuid(), this.cache, this.uri);
            this.enumerationParameterType.Name = "test";
            this.enumerationParameterType.ValueDefinition.Add(valuedefLow);
            this.enumerationParameterType.ValueDefinition.Add(valuedefMedium);

            this.simpleQuantityKind = new SimpleQuantityKind(Guid.NewGuid(), this.cache, this.uri);
            this.simpleQuantityKind.PossibleScale.Add(this.ratioScale);
            this.simpleQuantityKind.DefaultScale = this.ratioScale;

            this.textParameterType      = new TextParameterType(Guid.NewGuid(), this.cache, this.uri);
            this.timeOfDayParameterType = new TimeOfDayParameterType(Guid.NewGuid(), this.cache, this.uri);
        }
示例#6
0
        public void VerifyThatPopulatePossibleScalesWorks()
        {
            this.session.Setup(x => x.RetrieveSiteDirectory()).Returns(this.siteDir);
            this.session.Setup(x => x.ActivePerson).Returns(new Person(Guid.NewGuid(), null, this.uri));

            var pt = new SimpleQuantityKind(Guid.NewGuid(), null, this.uri)
            {
                ShortName = "test"
            };

            this.mrdl.ParameterType.Add(pt);

            var scale = new RatioScale(Guid.NewGuid(), null, this.uri)
            {
                ShortName = "testms"
            };

            this.mrdl.Scale.Add(scale);
            pt.PossibleScale.Add(scale);

            var vm = new SimpleParameterValueDialogViewModel(this.parameterValue.Clone(false), this.thingTransaction,
                                                             this.session.Object, true, ThingDialogKind.Update, this.thingDialogNavigationService.Object, this.requirementClone);

            vm.SelectedParameterType = pt;

            Assert.AreEqual(0, vm.PossibleScale.Count);
        }
示例#7
0
        public void VerifyThatPopulateValuesForCompoundParameterTypesWorks()
        {
            this.parameterValue = new SimpleParameterValue(Guid.NewGuid(), this.cache, this.uri)
            {
                ParameterType = null
            };
            this.session.Setup(x => x.RetrieveSiteDirectory()).Returns(this.siteDir);
            this.session.Setup(x => x.ActivePerson).Returns(new Person(Guid.NewGuid(), null, this.uri));

            var valueClone = this.parameterValue.Clone(false);

            this.requirementClone.ParameterValue.Add(valueClone);

            var vm = new SimpleParameterValueDialogViewModel(valueClone, this.thingTransaction, this.session.Object, true, ThingDialogKind.Update, this.thingDialogNavigationService.Object, this.requirementClone);
            var selectedParameter = new CompoundParameterType();

            var parameterTypeComponent  = new ParameterTypeComponent();
            var selectedSimpleParameter = new SimpleQuantityKind();

            parameterTypeComponent.ParameterType = selectedSimpleParameter;
            selectedParameter.Component.Add(parameterTypeComponent);
            vm.SelectedParameterType = selectedParameter;
            Assert.AreEqual(vm.Values.Count, 1);
            Assert.AreSame(vm.Values.First().ParameterType, selectedParameter);
        }
        public void VerifyThatCompoundParameterOverrideReturnsExpectedModelCodeNoComponent()
        {
            var simpleQuantityKind = new SimpleQuantityKind(Guid.NewGuid(), null, null)
            {
                ShortName = "l"
            };

            var compoundParameterType = new CompoundParameterType(Guid.NewGuid(), null, null);

            compoundParameterType.ShortName = "coord";
            var component = new ParameterTypeComponent(Guid.NewGuid(), null, null)
            {
                ParameterType = simpleQuantityKind
            };

            component.ShortName = "x";
            compoundParameterType.Component.Add(component);

            this.parameter.ParameterType = compoundParameterType;

            var parameterOverride = new ParameterOverride {
                Parameter = this.parameter
            };

            this.elementUsage.ParameterOverride.Add(parameterOverride);

            Assert.AreEqual("Sat.battery_1.coord", parameterOverride.ModelCode());
        }
        public void VerifyThatExistingParameterTypeDragOverSetsNoneEffectNoPermission()
        {
            var domainOfExpertise = new DomainOfExpertise(Guid.NewGuid(), null, null);

            elementDefinition.Owner = domainOfExpertise;
            var parameterGroup = new ParameterGroup(Guid.NewGuid(), null, null);

            elementDefinition.ParameterGroup.Add(parameterGroup);

            var row = new ElementDefinitionRowViewModel(this.elementDefinition, this.activeDomain, this.session.Object, null, this.obfuscationService.Object);

            var simpleQuantityKind = new SimpleQuantityKind(Guid.NewGuid(), null, null);
            var ratioScale         = new RatioScale(Guid.NewGuid(), null, null);

            simpleQuantityKind.DefaultScale = ratioScale;

            this.srdl.ParameterType.Add(simpleQuantityKind);

            var payload  = new Tuple <ParameterType, MeasurementScale>(simpleQuantityKind, ratioScale);
            var dropInfo = new Mock <IDropInfo>();

            dropInfo.Setup(x => x.Payload).Returns(payload);
            dropInfo.SetupProperty(x => x.Effects);

            row.DragOver(dropInfo.Object);

            Assert.AreEqual(DragDropEffects.None, dropInfo.Object.Effects);
        }
        public void VerifyCreateWithContainerUpdateInUpdatesValidation()
        {
            var modelReferenceDataLibraryMetaInfo = new ModelReferenceDataLibraryMetaInfo();

            this.mockedMetaInfoProvider.Setup(x => x.GetMetaInfo(It.IsAny <SimpleQuantityKind>())).Returns(this.simpleQuantityKindMetaInfo);
            this.mockedMetaInfoProvider.Setup(x => x.GetMetaInfo(It.IsAny <ModelReferenceDataLibrary>())).Returns(modelReferenceDataLibraryMetaInfo);
            this.mockedMetaInfoProvider.Setup(x => x.GetMetaInfo(It.Is <string>(y => y == SimpleQuantityKindTypeString))).Returns(this.simpleQuantityKindMetaInfo);
            this.mockedMetaInfoProvider.Setup(x => x.GetMetaInfo(It.Is <string>(y => y == "ModelReferenceDataLibrary"))).Returns(modelReferenceDataLibraryMetaInfo);

            var newSimpleQuantityKind = new SimpleQuantityKind(Guid.NewGuid(), 0)
            {
                Alias         = new List <Guid>(),
                Definition    = new List <Guid>(),
                HyperLink     = new List <Guid>(),
                PossibleScale = new List <Guid>(),
                Name          = TestName,
                ShortName     = TestShortName,
                Symbol        = "testSymbol"
            };

            // simpleQuantityKind container update
            var modelReferenceDataLibrary = new ClasslessDTO()
            {
                { IidKey, Guid.NewGuid() },
                { ClasskindKey, ClassKind.ModelReferenceDataLibrary },
                { "ParameterType", new[] { newSimpleQuantityKind.Iid } }
            };

            var postOperation = new CdpPostOperation();

            postOperation.Create.Add(newSimpleQuantityKind);
            postOperation.Update.Add(modelReferenceDataLibrary);

            Assert.DoesNotThrow(() => this.operationProcessor.ValidateCreateOperations(postOperation, this.fileStore));
        }
        public void VerifyThatParameterTypeNotInChainRdlCannotBeDrop()
        {
            this.permissionService.Setup(x => x.CanWrite(It.IsAny <ClassKind>(), It.IsAny <Thing>())).Returns(true);

            var domainOfExpertise = new DomainOfExpertise(Guid.NewGuid(), null, null);

            elementDefinition.Owner = domainOfExpertise;
            var parameterGroup = new ParameterGroup(Guid.NewGuid(), null, null);

            elementDefinition.ParameterGroup.Add(parameterGroup);

            var row = new ElementDefinitionRowViewModel(this.elementDefinition, this.activeDomain, this.session.Object, null, this.obfuscationService.Object);

            var simpleQuantityKind = new SimpleQuantityKind(Guid.NewGuid(), null, null);
            var ratioScale         = new RatioScale(Guid.NewGuid(), null, null);

            simpleQuantityKind.DefaultScale = ratioScale;

            var payload  = new Tuple <ParameterType, MeasurementScale>(simpleQuantityKind, ratioScale);
            var dropInfo = new Mock <IDropInfo>();

            dropInfo.Setup(x => x.Payload).Returns(payload);
            dropInfo.SetupProperty(x => x.Effects);

            row.DragOver(dropInfo.Object);

            Assert.AreEqual(DragDropEffects.None, dropInfo.Object.Effects);
        }
示例#12
0
        public void Verify_that_The_ParameterTypeComponent_has_a_valid_scale()
        {
            var scale              = new RatioScale();
            var textParameterType  = new TextParameterType();
            var simpleQuantityKind = new SimpleQuantityKind();

            this.parameterTypeComponent.Scale         = scale;
            this.parameterTypeComponent.ParameterType = textParameterType;

            var result = this.parameterTypeComponentRuleChecker.ChecksWhetherTheParameterTypeComponentHasAValidScale(this.parameterTypeComponent).Single();

            Assert.That(result.Id, Is.EqualTo("MA-0740"));
            Assert.That(result.Description, Is.EqualTo("When the referenced ParameterType is a not QuantityKind, the ParameterTypeComponent.Scale must be null"));
            Assert.That(result.Thing, Is.EqualTo(this.parameterTypeComponent));
            Assert.That(result.Severity, Is.EqualTo(SeverityKind.Error));

            this.parameterTypeComponent.Scale         = null;
            this.parameterTypeComponent.ParameterType = simpleQuantityKind;

            result = this.parameterTypeComponentRuleChecker.ChecksWhetherTheParameterTypeComponentHasAValidScale(this.parameterTypeComponent).Single();

            Assert.That(result.Id, Is.EqualTo("MA-0740"));
            Assert.That(result.Description, Is.EqualTo("When the referenced ParameterType is a QuantityKind, the ParameterTypeComponent.Scale may not be null"));
            Assert.That(result.Thing, Is.EqualTo(this.parameterTypeComponent));
            Assert.That(result.Severity, Is.EqualTo(SeverityKind.Error));
        }
示例#13
0
        public void SetUp()
        {
            var equipments = new Category {
                ShortName = "EQT", Name = "Equipments"
            };
            var batteries = new Category {
                ShortName = "BAT", Name = "Batteries"
            };

            this.categories = new List <Category> {
                equipments, batteries
            };

            var system = new DomainOfExpertise {
                ShortName = "SYS", Name = "System Engineering"
            };
            var poweer = new DomainOfExpertise {
                ShortName = "PWR", Name = "Power Engineering"
            };

            this.domains = new List <DomainOfExpertise> {
                system, poweer
            };

            var mass = new SimpleQuantityKind {
                Name = "mass", ShortName = "m"
            };
            var lenght = new SimpleQuantityKind {
                Name = "length", ShortName = "l"
            };

            this.parameterTypes = new List <ParameterType> {
                mass, lenght
            };
        }
示例#14
0
        public void VerifyUpdateOkCanExecute()
        {
            var constantName      = "constant1";
            var constantShortName = "c1";
            var constant          = new Constant(Guid.NewGuid(), null, this.uri)
            {
                Name = constantName, ShortName = constantShortName
            };
            var testParameterType = new SimpleQuantityKind(Guid.NewGuid(), null, null);
            var testScale         = new RatioScale(Guid.NewGuid(), null, this.uri);

            testParameterType.PossibleScale.Add(testScale);
            constant.ParameterType = testParameterType;
            constant.Value         = new ValueArray <string>(new List <string> {
                "1"
            });
            this.siteRdl.ParameterType.Add(testParameterType);
            this.siteRdl.ParameterType.Add(new BooleanParameterType(Guid.NewGuid(), null, null));
            var vm = new ConstantDialogViewModel(constant, this.transaction, this.session.Object, true, ThingDialogKind.Create, this.dialogService.Object);

            Assert.IsTrue(vm.OkCanExecute);
            vm.SelectedParameterType = null;
            Assert.IsFalse(vm.OkCanExecute);
            vm.SelectedParameterType = testParameterType;
            Assert.IsTrue(vm.OkCanExecute);

            vm.Value.First().Value = string.Empty;
            Assert.IsFalse(vm.OkCanExecute);

            vm.Value.First().Value = "Not empty value";
            Assert.IsTrue(vm.OkCanExecute);
        }
示例#15
0
        public void VerifyThatPropertiesAreSet()
        {
            var constantName      = "constant1";
            var constantShortName = "c1";
            var constant          = new Constant(Guid.NewGuid(), null, this.uri)
            {
                Name = constantName, ShortName = constantShortName
            };
            var testParameterType = new SimpleQuantityKind(Guid.NewGuid(), null, this.uri);
            var testScale         = new RatioScale(Guid.NewGuid(), null, this.uri);

            testParameterType.PossibleScale.Add(testScale);
            constant.ParameterType = testParameterType;
            constant.Value         = new ValueArray <string>(new List <string> {
                "1"
            });
            this.siteRdl.ParameterType.Add(testParameterType);
            this.siteRdl.ParameterType.Add(new BooleanParameterType(Guid.NewGuid(), null, this.uri));
            var vm = new ConstantDialogViewModel(constant, this.transaction, this.session.Object, true, ThingDialogKind.Create, this.dialogService.Object);

            Assert.AreEqual(2, vm.PossibleContainer.Count);
            vm.Container = vm.PossibleContainer.Last();
            Assert.AreEqual(constantName, vm.Name);
            Assert.AreEqual(constantShortName, vm.ShortName);
            Assert.AreEqual(2, vm.PossibleCategory.Count);
            Assert.AreEqual(2, vm.PossibleParameterType.Count);
            Assert.AreEqual(testParameterType, vm.SelectedParameterType);
            Assert.AreEqual(1, vm.PossibleScale.Count);
            Assert.AreEqual(testScale, vm.SelectedScale);
            Assert.IsNotNull(vm.Value);
            Assert.AreEqual(1, vm.Value.Count);
            Assert.AreEqual("1", vm.Value.First().Value);
        }
        public void VerifyThatTheConstructorSetsTheProperties()
        {
            var shortname = "constantshortname";
            var name      = "constant name";

            var ratioScale = new RatioScale(Guid.NewGuid(), null, this.uri)
            {
                Name      = "ratio scale",
                ShortName = "ratioscaleshortname",
            };

            var qk = new SimpleQuantityKind(Guid.NewGuid(), null, this.uri);

            qk.DefaultScale = ratioScale;

            var constant = new Constant(Guid.NewGuid(), null, this.uri)
            {
                Name          = name,
                ShortName     = shortname,
                ParameterType = qk,
                Scale         = ratioScale
            };

            var constantRowViewModel = new ConstantRowViewModel(constant, this.session.Object, null);

            Assert.AreEqual(shortname, constantRowViewModel.ShortName);
            Assert.AreEqual(name, constantRowViewModel.Name);
            Assert.AreEqual(string.Empty, constantRowViewModel.ContainerRdl);
            Assert.AreEqual(ratioScale, constantRowViewModel.SelectedScale);
        }
示例#17
0
        public void VerifyThatValidatePocoPropertiesAddsMissingScaleError()
        {
            var simpleQuantityKind = new SimpleQuantityKind(Guid.NewGuid(), this.cache, this.uri);

            simpleQuantityKind.ValidatePoco();

            CollectionAssert.Contains(simpleQuantityKind.ValidationErrors, "The PossibleScale property is empty.");
        }
示例#18
0
        public void TestGetAllPossibleScale()
        {
            var quantityKind = new SimpleQuantityKind();

            quantityKind.PossibleScale.Add(new LogarithmicScale());

            Assert.AreEqual(1, quantityKind.AllPossibleScale.Count);
        }
示例#19
0
        public void SetUp()
        {
            this.quantityKindRuleChecker = new QuantityKindRuleChecker();

            this.siteReferenceDataLibrary = new SiteReferenceDataLibrary();
            this.simpleQuantityKind       = new SimpleQuantityKind();

            this.siteReferenceDataLibrary.ParameterType.Add(this.simpleQuantityKind);
        }
示例#20
0
        public void Setup()
        {
            RxApp.MainThreadScheduler = Scheduler.CurrentThread;
            this.permissionService    = new Mock <IPermissionService>();
            this.cache = new ConcurrentDictionary <CacheKey, Lazy <Thing> >();

            this.session = new Mock <ISession>();
            var person = new Person(Guid.NewGuid(), null, null)
            {
                Container = this.siteDir
            };

            this.session.Setup(x => x.ActivePerson).Returns(person);

            this.siteDir = new SiteDirectory(Guid.NewGuid(), this.cache, null);
            this.siteDir.Person.Add(person);
            this.srdl = new SiteReferenceDataLibrary(Guid.NewGuid(), this.cache, null)
            {
                Name = "testRDL", ShortName = "test"
            };
            this.compoundPt = new CompoundParameterType {
                Name = "parameterType", ShortName = "cat"
            };
            this.cat = new Category(Guid.NewGuid(), this.cache, null)
            {
                Name = "category1", ShortName = "cat1"
            };
            this.cat.PermissibleClass.Add(ClassKind.CompoundParameterType);
            this.srdl.DefinedCategory.Add(cat);
            this.siteDir.SiteReferenceDataLibrary.Add(this.srdl);
            this.session.Setup(x => x.RetrieveSiteDirectory()).Returns(this.siteDir);
            this.session.Setup(x => x.OpenReferenceDataLibraries).Returns(new HashSet <ReferenceDataLibrary>(this.siteDir.SiteReferenceDataLibrary));
            this.bpt = new BooleanParameterType(Guid.NewGuid(), this.cache, null);
            this.cpt = new CompoundParameterType(Guid.NewGuid(), this.cache, null);

            this.srdl.ParameterType.Add(this.bpt);
            this.srdl.ParameterType.Add(this.cpt);
            this.qt = new SimpleQuantityKind(Guid.NewGuid(), this.cache, null);
            this.srdl.ParameterType.Add(this.qt);

            this.scale = new OrdinalScale(Guid.NewGuid(), this.cache, null);
            this.srdl.Scale.Add(this.scale);
            this.qt.PossibleScale.Add(this.scale);

            this.cache.TryAdd(new CacheKey(this.srdl.Iid, null), new Lazy <Thing>(() => this.srdl));
            this.permissionService.Setup(x => x.CanWrite(It.IsAny <ClassKind>(), It.IsAny <Thing>())).Returns(true);
            this.permissionService.Setup(x => x.CanWrite(It.IsAny <Thing>())).Returns(true);
            this.session.Setup(x => x.PermissionService).Returns(this.permissionService.Object);

            var dal = new Mock <IDal>();

            this.session.Setup(x => x.DalVersion).Returns(new Version(1, 1, 0));
            this.session.Setup(x => x.Dal).Returns(dal.Object);
            dal.Setup(x => x.MetaDataProvider).Returns(new MetaDataProvider());
            this.parameterType = new ParameterTypeComponent();
        }
        public void VerifyCreateParameterOverride()
        {
            var browser      = new ElementDefinitionsBrowserViewModel(this.iteration, this.session.Object, null, this.panelNavigationService.Object, null, null, null, null);
            var elementUsage = new ElementUsage(Guid.NewGuid(), this.assembler.Cache, this.uri)
            {
                Owner = this.elementDef.Owner, ElementDefinition = this.elementDef, Container = this.elementDef
            };
            var usageRow  = new ElementUsageRowViewModel(elementUsage, this.elementDef.Owner, this.session.Object, null, this.obfuscationService.Object);
            var qk        = new SimpleQuantityKind();
            var parameter = new Parameter(Guid.NewGuid(), this.assembler.Cache, this.uri)
            {
                Container     = this.elementDef,
                ParameterType = qk,
                Owner         = this.elementDef.Owner
            };

            var parameterRow = new ParameterRowViewModel(parameter, this.session.Object, usageRow, false);

            Assert.IsFalse(browser.CreateOverrideCommand.CanExecute(null));
            browser.SelectedThing = parameterRow;
            Assert.IsTrue(browser.CreateOverrideCommand.CanExecute(null));
            browser.CreateOverrideCommand.Execute(parameter);

            this.session.Verify(x => x.Write(It.IsAny <OperationContainer>()));

            browser.SelectedThing = null;
            browser.ComputePermission();
            browser.CreateOverrideCommand.Execute(null);
            this.session.Verify(x => x.Write(It.IsAny <OperationContainer>()), Times.Once);

            var paramtType = new CompoundParameterType(Guid.NewGuid(), this.assembler.Cache, this.uri);

            paramtType.Component.Add(new ParameterTypeComponent(Guid.NewGuid(), this.assembler.Cache, this.uri)
            {
                ParameterType = new BooleanParameterType(Guid.NewGuid(), this.assembler.Cache, this.uri), Scale = null
            });
            parameter.ParameterType = paramtType;

            var elementDefRow         = new ElementDefinitionRowViewModel(this.elementDef, this.elementDef.Owner, this.session.Object, null, this.obfuscationService.Object);
            var parameterValueBaseRow = new ParameterComponentValueRowViewModel(parameter, 0, this.session.Object, null, null, elementDefRow, false);

            browser.SelectedThing = parameterValueBaseRow;
            browser.ComputePermission();
            browser.CreateOverrideCommand.Execute(null);

            var parameterOverride = new ParameterOverride(Guid.NewGuid(), this.assembler.Cache, this.uri)
            {
                Parameter = parameter, Owner = this.elementDef.Owner
            };

            parameterValueBaseRow = new ParameterComponentValueRowViewModel(parameterOverride, 0, this.session.Object, null, null, usageRow, false);
            browser.SelectedThing = parameterValueBaseRow;
            browser.CreateOverrideCommand.Execute(null);
        }
        public void Setup()
        {
            RxApp.MainThreadScheduler = Scheduler.CurrentThread;
            this.cache          = new ConcurrentDictionary <CacheKey, Lazy <Thing> >();
            this.serviceLocator = new Mock <IServiceLocator>();
            this.navigation     = new Mock <IThingDialogNavigationService>();
            ServiceLocator.SetLocatorProvider(() => this.serviceLocator.Object);
            this.serviceLocator.Setup(x => x.GetInstance <IThingDialogNavigationService>()).Returns(this.navigation.Object);

            this.session = new Mock <ISession>();
            var person = new Person(Guid.NewGuid(), this.cache, null)
            {
                Container = this.siteDir
            };

            this.session.Setup(x => x.ActivePerson).Returns(person);

            this.siteDir = new SiteDirectory(Guid.NewGuid(), this.cache, null);
            this.siteDir.Person.Add(person);
            var rdl = new SiteReferenceDataLibrary(Guid.NewGuid(), this.cache, null)
            {
                Name = "testRDL", ShortName = "test"
            };

            this.scaleReferenceQuantityValue = new ScaleReferenceQuantityValue();
            var testLogarithmicScale = new LogarithmicScale(Guid.NewGuid(), this.cache, null)
            {
                Name = "Test Derived QK", ShortName = "tdqk"
            };
            var simpleQuantityKind = new SimpleQuantityKind();

            rdl.ParameterType.Add(simpleQuantityKind);
            rdl.Scale.Add(testLogarithmicScale);
            this.siteDir.SiteReferenceDataLibrary.Add(rdl);
            this.session.Setup(x => x.RetrieveSiteDirectory()).Returns(this.siteDir);
            var chainOfContainers = new[] { rdl };

            var clone = testLogarithmicScale.Clone(false);

            this.cache.TryAdd(new CacheKey(testLogarithmicScale.Iid, null), new Lazy <Thing>(() => testLogarithmicScale));

            var transactionContext = TransactionContextResolver.ResolveContext(this.siteDir);

            this.transaction = new ThingTransaction(transactionContext, clone);

            var dal = new Mock <IDal>();

            this.session.Setup(x => x.DalVersion).Returns(new Version(1, 1, 0));
            this.session.Setup(x => x.Dal).Returns(dal.Object);
            dal.Setup(x => x.MetaDataProvider).Returns(new MetaDataProvider());

            this.viewmodel = new ScaleReferenceQuantityValueDialogViewModel(this.scaleReferenceQuantityValue, this.transaction, this.session.Object, true, ThingDialogKind.Create, null, clone, chainOfContainers);
        }
示例#23
0
        public void SetUp()
        {
            this.uri = new Uri("http://www.rheagroup.com");
            this.cache = new ConcurrentDictionary<CDP4Common.Types.CacheKey, Lazy<Thing>>();

            this.CreateCategories();

            this.textParameterType = new TextParameterType(Guid.NewGuid(), this.cache, this.uri) { ShortName = "TXT" };
            this.simpleQuantityKind = new SimpleQuantityKind(Guid.NewGuid(), this.cache, this.uri) {ShortName = "SIMPLE" };

            this.iteration = new Iteration(Guid.NewGuid(), this.cache, this.uri);
        }
示例#24
0
        public void Setup()
        {
            RxApp.MainThreadScheduler = Scheduler.CurrentThread;
            this.serviceLocator       = new Mock <IServiceLocator>();
            this.navigation           = new Mock <IThingDialogNavigationService>();
            ServiceLocator.SetLocatorProvider(() => this.serviceLocator.Object);
            this.serviceLocator.Setup(x => x.GetInstance <IThingDialogNavigationService>()).Returns(this.navigation.Object);
            this.permissionService = new Mock <IPermissionService>();
            this.permissionService.Setup(x => x.CanWrite(It.IsAny <Thing>())).Returns(true);
            this.session = new Mock <ISession>();
            var person = new Person(Guid.NewGuid(), null, null)
            {
                Container = this.siteDir
            };

            this.session.Setup(x => x.ActivePerson).Returns(person);

            this.siteDir = new SiteDirectory(Guid.NewGuid(), null, null);
            this.siteDir.Person.Add(person);
            this.rdl = new SiteReferenceDataLibrary(Guid.NewGuid(), null, null)
            {
                Name = "testRDL", ShortName = "test"
            };
            this.simpleQuantityKind = new SimpleQuantityKind(Guid.NewGuid(), null, null)
            {
                Name = "simpleQuantityKind", ShortName = "cat"
            };
            var cat = new Category(Guid.NewGuid(), null, null)
            {
                Name = "category1", ShortName = "cat1"
            };

            cat.PermissibleClass.Add(ClassKind.SimpleQuantityKind);
            this.rdl.DefinedCategory.Add(cat);
            this.siteDir.SiteReferenceDataLibrary.Add(this.rdl);

            var transactionContext = TransactionContextResolver.ResolveContext(this.siteDir);

            this.transaction = new ThingTransaction(transactionContext, null);

            this.session.Setup(x => x.RetrieveSiteDirectory()).Returns(this.siteDir);
            this.session.Setup(x => x.OpenReferenceDataLibraries).Returns(new HashSet <ReferenceDataLibrary>(this.siteDir.SiteReferenceDataLibrary));
            this.session.Setup(x => x.PermissionService).Returns(this.permissionService.Object);

            var dal = new Mock <IDal>();

            this.session.Setup(x => x.DalVersion).Returns(new Version(1, 1, 0));
            this.session.Setup(x => x.Dal).Returns(dal.Object);
            dal.Setup(x => x.MetaDataProvider).Returns(new MetaDataProvider());

            this.viewmodel = new SimpleQuantityKindDialogViewModel(this.simpleQuantityKind, this.transaction, this.session.Object, true, ThingDialogKind.Create, null, null, null);
        }
        public void VerifyThatParameterTypeEventsAreCaught()
        {
            var textParamType = new TextParameterType(Guid.NewGuid(), this.assembler.Cache, this.uri);

            CDPMessageBus.Current.SendObjectChangeEvent(textParamType, EventKind.Added);
            Assert.AreEqual(1, this.ParameterTypesBrowserViewModel.ParameterTypes.Count);
            CDPMessageBus.Current.SendObjectChangeEvent(textParamType, EventKind.Removed);
            Assert.IsFalse(this.ParameterTypesBrowserViewModel.ParameterTypes.Any());

            var booleanParamType = new BooleanParameterType(Guid.NewGuid(), this.assembler.Cache, this.uri);

            CDPMessageBus.Current.SendObjectChangeEvent(booleanParamType, EventKind.Added);
            Assert.AreEqual(1, this.ParameterTypesBrowserViewModel.ParameterTypes.Count);
            CDPMessageBus.Current.SendObjectChangeEvent(booleanParamType, EventKind.Removed);
            Assert.IsFalse(this.ParameterTypesBrowserViewModel.ParameterTypes.Any());

            var defaultScale = new CyclicRatioScale(Guid.NewGuid(), this.assembler.Cache, this.uri);

            var simpleQuantityKind =
                new SimpleQuantityKind(Guid.NewGuid(), this.assembler.Cache, this.uri)
            {
                DefaultScale = defaultScale
            };

            CDPMessageBus.Current.SendObjectChangeEvent(simpleQuantityKind, EventKind.Added);
            Assert.AreEqual(1, this.ParameterTypesBrowserViewModel.ParameterTypes.Count);
            CDPMessageBus.Current.SendObjectChangeEvent(simpleQuantityKind, EventKind.Removed);
            Assert.IsFalse(this.ParameterTypesBrowserViewModel.ParameterTypes.Any());

            var specializedQuantityKind =
                new SpecializedQuantityKind(Guid.NewGuid(), this.assembler.Cache, this.uri)
            {
                DefaultScale = defaultScale
            };

            CDPMessageBus.Current.SendObjectChangeEvent(specializedQuantityKind, EventKind.Added);
            Assert.AreEqual(1, this.ParameterTypesBrowserViewModel.ParameterTypes.Count);
            CDPMessageBus.Current.SendObjectChangeEvent(specializedQuantityKind, EventKind.Removed);
            Assert.IsFalse(this.ParameterTypesBrowserViewModel.ParameterTypes.Any());

            var derivedQuantityKind =
                new DerivedQuantityKind(Guid.NewGuid(), this.assembler.Cache, this.uri)
            {
                DefaultScale = defaultScale
            };

            CDPMessageBus.Current.SendObjectChangeEvent(derivedQuantityKind, EventKind.Added);
            Assert.AreEqual(1, this.ParameterTypesBrowserViewModel.ParameterTypes.Count);
            CDPMessageBus.Current.SendObjectChangeEvent(derivedQuantityKind, EventKind.Removed);
            Assert.IsFalse(this.ParameterTypesBrowserViewModel.ParameterTypes.Any());
        }
示例#26
0
        public void VerifyInspectSelectedGeneral()
        {
            var simpleQuantityKind = new SimpleQuantityKind();

            this.rdl.ParameterType.Add(simpleQuantityKind);
            var vm = new SpecializedQuantityKindDialogViewModel(this.specializedQuantityKind, this.transaction, this.session.Object, true, ThingDialogKind.Inspect, this.navigation.Object, this.rdl);

            Assert.IsNull(vm.SelectedGeneral);
            Assert.IsFalse(vm.InspectSelectedGeneralCommand.CanExecute(null));

            vm.SelectedGeneral = simpleQuantityKind;
            Assert.IsTrue(vm.InspectSelectedGeneralCommand.CanExecute(null));
            vm.InspectSelectedGeneralCommand.Execute(null);
            this.navigation.Verify(x => x.Navigate(It.IsAny <SimpleQuantityKind>(), It.IsAny <ThingTransaction>(), this.session.Object, false, ThingDialogKind.Inspect, this.navigation.Object, It.IsAny <Thing>(), null));
        }
示例#27
0
 public void SetUp()
 {
     this.simpleQuantityKind = new SimpleQuantityKind()
     {
         ShortName = "TST", Name = "TEST"
     };
     this.parameter = new Parameter()
     {
         ParameterType = this.simpleQuantityKind
     };
     this.nestedParameter = new NestedParameter()
     {
         AssociatedParameter = this.parameter
     };
 }
示例#28
0
        public void VerifyThatThePropertiesAreUpdateWhenParameterTypeIsUpdated()
        {
            var rev = typeof(Thing).GetProperty("RevisionNumber");

            var rdlshortnamename = "rdl shortname";
            var rdl = new SiteReferenceDataLibrary(Guid.NewGuid(), this.assembler.Cache, this.uri)
            {
                ShortName = rdlshortnamename,
            };

            var ratioScale = new RatioScale(Guid.NewGuid(), this.assembler.Cache, this.uri)
            {
                ShortName = "RatioScale"
            };
            var simpleQuantityKind = new SimpleQuantityKind(Guid.NewGuid(), this.assembler.Cache, this.uri)
            {
                Name         = "simple quantity kind",
                ShortName    = "sqk",
                DefaultScale = ratioScale,
            };

            rdl.ParameterType.Add(simpleQuantityKind);
            rdl.BaseQuantityKind.Add(simpleQuantityKind);
            var parameterTypeRowViewModel = new ParameterTypeRowViewModel(simpleQuantityKind, this.session.Object, null);

            var updatedName      = "updated quantity kind Shortname";
            var updatedShortName = "updatedQKShortName";
            var updatedScale     = "updatedScale";

            simpleQuantityKind.ShortName = updatedShortName;
            simpleQuantityKind.Name      = updatedName;

            rev.SetValue(simpleQuantityKind, 10);
            CDPMessageBus.Current.SendObjectChangeEvent(simpleQuantityKind, EventKind.Updated);

            Assert.AreEqual(simpleQuantityKind.ShortName, parameterTypeRowViewModel.ShortName);
            Assert.AreEqual(simpleQuantityKind.Name, parameterTypeRowViewModel.Name);
            Assert.IsTrue(parameterTypeRowViewModel.IsBaseQuantityKind);
            Assert.AreEqual(simpleQuantityKind.DefaultScale.ShortName, parameterTypeRowViewModel.DefaultScale);
            Assert.AreEqual(simpleQuantityKind.ClassKind.ToString(), parameterTypeRowViewModel.Type);
            Assert.AreEqual(rdlshortnamename, parameterTypeRowViewModel.ContainerRdl);

            ratioScale.ShortName = updatedScale;
            rev.SetValue(ratioScale, 10);
            CDPMessageBus.Current.SendObjectChangeEvent(ratioScale, EventKind.Updated);
            Assert.AreEqual(updatedScale, parameterTypeRowViewModel.DefaultScale);
        }
        public void SetUp()
        {
            this.uri   = new Uri("http://www.rheagroup.com");
            this.cache = new ConcurrentDictionary <CDP4Common.Types.CacheKey, Lazy <Thing> >();

            this.siteReferenceDataLibrary = new SiteReferenceDataLibrary(Guid.NewGuid(), this.cache, this.uri);

            this.systemEngineering  = new DomainOfExpertise(Guid.NewGuid(), this.cache, this.uri);
            this.powerEngineering   = new DomainOfExpertise(Guid.NewGuid(), this.cache, this.uri);
            this.simpleQuantityKind = new SimpleQuantityKind(Guid.NewGuid(), this.cache, this.uri);
            this.equipments         = new Category(Guid.NewGuid(), this.cache, this.uri)
            {
                ShortName = "EQT", Name = "Equipments"
            };

            this.siteReferenceDataLibrary.DefinedCategory.Add(this.equipments);

            var engineeringModel = new EngineeringModel(Guid.NewGuid(), this.cache, this.uri);

            this.iteration = new Iteration(Guid.NewGuid(), this.cache, this.uri);
            engineeringModel.Iteration.Add(this.iteration);
            var elementDefinition = new ElementDefinition(Guid.NewGuid(), this.cache, this.uri)
            {
                Owner = this.powerEngineering
            };

            elementDefinition.Category.Add(this.equipments);
            this.iteration.Element.Add(elementDefinition);
            var parameter = new Parameter(Guid.NewGuid(), this.cache, this.uri)
            {
                Owner = this.powerEngineering, ParameterType = this.simpleQuantityKind
            };

            elementDefinition.Parameter.Add(parameter);
            var parameterSubscription = new ParameterSubscription(Guid.NewGuid(), this.cache, this.uri)
            {
                Owner = this.systemEngineering
            };

            parameter.ParameterSubscription.Add(parameterSubscription);

            this.session = new Mock <ISession>();
            this.session.Setup(x => x.QuerySelectedDomainOfExpertise(this.iteration)).Returns(this.systemEngineering);

            this.parameterSubscriptionBatchService = new ParameterSubscriptionBatchService();
        }
        public void VerifyThatParticipantWithoutDomainSelectedCannotDropOnElementDefBrowser()
        {
            var vm = new ElementDefinitionsBrowserViewModel(this.iteration, this.session.Object, null, null, null, null, null, null);

            var simpleQuantityKind = new SimpleQuantityKind(Guid.NewGuid(), this.assembler.Cache, this.uri);
            var ratioScale         = new RatioScale(Guid.NewGuid(), this.assembler.Cache, this.uri);

            simpleQuantityKind.DefaultScale = ratioScale;
            var payload  = new Tuple <ParameterType, MeasurementScale>(simpleQuantityKind, ratioScale);
            var dropInfo = new Mock <IDropInfo>();

            dropInfo.Setup(x => x.Payload).Returns(payload);
            dropInfo.SetupProperty(x => x.Effects);

            vm.DragOver(dropInfo.Object);

            Assert.AreEqual(dropInfo.Object.Effects, DragDropEffects.None);
        }