public void VerifyThatSubscriptionCommandWorks()
        {
            this.permissionService.Setup(x => x.CanWrite(It.IsAny <ClassKind>(), It.IsAny <Thing>())).Returns(true);

            this.session
            .Setup(x => x.OpenIterations)
            .Returns(new Dictionary <Iteration, Tuple <DomainOfExpertise, Participant> >
            {
                { this.iteration, new Tuple <DomainOfExpertise, Participant>(new DomainOfExpertise(), null) }
            });

            var parameter = new Parameter(Guid.NewGuid(), this.assembler.Cache, this.uri)
            {
                ParameterType = this.pt
            };

            this.elementDef.Parameter.Add(parameter);
            this.iteration.Element.Add(this.elementDef);

            var vm = new ElementDefinitionsBrowserViewModel(this.iteration, this.session.Object, null, null, null, null, null, null);

            Assert.IsFalse(vm.CreateSubscriptionCommand.CanExecute(null));

            var defRow = vm.ElementDefinitionRowViewModels.First();

            vm.SelectedThing = defRow.ContainedRows.First();
            vm.ComputePermission();
            vm.PopulateContextMenu();

            Assert.IsTrue(vm.CreateSubscriptionCommand.CanExecute(null));
            vm.CreateSubscriptionCommand.Execute(null);

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

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

            vm.SelectedThing = defRow;
            vm.CreateSubscriptionCommand.Execute(null);
            this.session.Verify(x => x.Write(It.IsAny <OperationContainer>()), Times.Once);

            // Assert that is possible to subscribe to a ParameterOverride that is not owned by the current domain
            var parameterOverrideRow = defRow.ContainedRows.Last().ContainedRows.Last();

            vm.SelectedThing = parameterOverrideRow;
            vm.ComputePermission();
            Assert.IsTrue(vm.CanCreateSubscription);

            // Assert that is NOT possible to subscribe to a ParameterOverride that is owned by the current domain
            ((ParameterOverride)parameterOverrideRow.Thing).Owner = this.session.Object.OpenIterations.Values.Single().Item1;
            vm.ComputePermission();
            Assert.IsFalse(vm.CanCreateSubscription);
        }
        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);
        }