Example #1
0
        public void CanDeleteValueSet()
        {
            // Arrange
            var apiModel = MockApiModelBuilder.ValueSetCreationApiModel("VS FOR DELETE", 25);
            var attempt  = this.valueSetService.Create(apiModel);

            attempt.Success.Should().BeTrue();
            attempt.Result.HasValue.Should().BeTrue();

            var vs = attempt.Result.Single();

            this.Profiler.ExecuteTimed(() => this.valueSetService.Save(vs), "ValueSet Save");

            vs.ValueSetUniqueId.Should().NotBe(Guid.Empty.ToString());
            vs.IsNew().Should().BeFalse();
            var uid = vs.ValueSetUniqueId;

            // Act
            this.valueSetService.Delete(vs);

            // Assert
            var retreived = this.valueSetRepository.GetCustomValueSet(uid);
            var codes     = this.valueSetCodeRepository.GetCustomValueSetCodes(uid, Enumerable.Empty <string>());

            retreived.HasValue.Should().BeFalse();
            codes.Should().BeEmpty();
        }
Example #2
0
        public void CanCreateValueSet()
        {
            // Arrange
            var apiModel = MockApiModelBuilder.ValueSetCreationApiModel("Custom Value Set");
            var emptyId  = Guid.Empty.ToString();

            // Act
            var attempt = this.valueSetService.Create(apiModel);

            // Assert
            attempt.Success.Should().BeTrue();
            attempt.Result.HasValue.Should().BeTrue();
            var valueSet = attempt.Result.Single();

            valueSet.Should().NotBeNull();
            valueSet.IsCustom.Should().BeTrue();
            valueSet.ValueSetUniqueId.Should().Be(emptyId);
            valueSet.ValueSetId.Should().Be(emptyId);
            valueSet.ValueSetOId.Should().Be(emptyId);
            valueSet.Name.Should().Be("Custom Value Set");
            foreach (var code in valueSet.ValueSetCodes)
            {
                code.ValueSetUniqueId.Should().Be(emptyId);
            }
        }
Example #3
0
        public void CanAddValueSet(string name, int codeCount)
        {
            // Arrange
            var apiModel = MockApiModelBuilder.ClientTermValueSetApiModel(name, codeCount);

            //var attempt = this.clientTermValueSetService.Create(apiModel);
            var attempt = this.clientTermCustomizationService.CreateValueSet(apiModel);

            attempt.Success.Should().BeTrue();
            attempt.Result.Should().NotBeNull();

            var vs = attempt.Result;

            // Act
            this.Profiler.ExecuteTimed(() => this.clientTermValueSetService.SaveAsNew(vs));

            // Assert
            vs.ValueSetGuid.Should().NotBe(Guid.Empty);
            vs.ValueSetCodes.Count.Should().Be(codeCount);
            vs.Name.Should().BeEquivalentTo(name);
            vs.IsLatestVersion.Should().BeTrue();
            vs.IsCustom.Should().BeTrue();
            vs.StatusCode.Should().Be(ValueSetStatus.Draft);
            vs.ValueSetCodes.All(x => x.CodeGuid != Guid.Empty).Should().BeTrue();

            // cleanup
            this.clientTermValueSetService.Delete(vs);
        }
Example #4
0
        public void CanAddCodes(string name, int initialCodeCount, int addCodeCount)
        {
            // Arrange
            var expectedCount = initialCodeCount + addCodeCount;
            var apiModel      = MockApiModelBuilder.ClientTermValueSetApiModel(name, initialCodeCount);

            var setup = this.clientTermCustomizationService.CreateValueSet(apiModel);

            setup.Success.Should().BeTrue();
            setup.Result.Should().NotBeNull();
            var valueSet = setup.Result;

            this.clientTermValueSetService.SaveAsNew(valueSet);

            var updateModel = MockApiModelBuilder.ClientTermValueSetApiModel(name, addCodeCount, true);

            // Act
            var result = this.Profiler.ExecuteTimed(
                () => this.clientTermCustomizationService.UpdateValueSet(
                    valueSet.ValueSetGuid,
                    updateModel))
                         .Result;

            // Assert
            result.ValueSetCodes.Count.Should().Be(expectedCount);

            var codeCodeSystemGuids   = result.ValueSetCodes.Select(vsc => vsc.CodeSystemGuid).Distinct().ToList();
            var countCodeSystemsGuids = result.CodeCounts.Select(cc => cc.CodeSystemGuid).ToList();

            countCodeSystemsGuids.All(countCs => codeCodeSystemGuids.Contains(countCs)).Should().BeTrue();
            codeCodeSystemGuids.All(codeCs => countCodeSystemsGuids.Contains(codeCs)).Should().BeTrue();

            // cleanup
            this.clientTermValueSetService.Delete(result);
        }
Example #5
0
        public void CanAddValueSet(string name, int codeCount)
        {
            // Arrange
            var apiModel = MockApiModelBuilder.ValueSetCreationApiModel(name, codeCount);
            var attempt  = this.valueSetService.Create(apiModel);

            attempt.Success.Should().BeTrue();
            attempt.Result.HasValue.Should().BeTrue();

            var vs = attempt.Result.Single();

            // Act
            this.Profiler.ExecuteTimed(() => this.valueSetService.Save(vs));

            // Assert
            vs.ValueSetUniqueId.Should().NotBe(Guid.Empty.ToString());
            vs.ValueSetCodes.Count.Should().Be(codeCount);
            vs.Name.Should().BeEquivalentTo(name);
        }
Example #6
0
        public void CanCreateValueSet(string name, int codeCount)
        {
            // Arrange
            var apiModel = MockApiModelBuilder.ClientTermValueSetApiModel(name, codeCount);

            // Act
            //var attempt = this.clientTermValueSetService.Create(apiModel);
            var attempt = this.clientTermCustomizationService.CreateValueSet(apiModel);

            // Assert
            attempt.Success.Should().BeTrue();
            attempt.Result.Should().NotBeNull();

            var vs = attempt.Result;

            vs.ValueSetCodes.Should().NotBeEmpty();
            vs.CodeCounts.Should().NotBeEmpty();
            vs.CodeCounts.Sum(cc => cc.CodeCount).Should().Be(codeCount);
        }
Example #7
0
        public void CanRemoveCodes(string name, int initialCodeCount, int removeCodeCount)
        {
            // Arrange
            var expectedCount = initialCodeCount - removeCodeCount;
            var apiModel      = MockApiModelBuilder.ClientTermValueSetApiModel(name, initialCodeCount);
            // var setup = this.clientTermValueSetService.Create(apiModel);

            var setup = this.clientTermCustomizationService.CreateValueSet(apiModel);

            setup.Success.Should().BeTrue();
            setup.Result.Should().NotBeNull();
            var valueSet = setup.Result;

            this.clientTermValueSetService.SaveAsNew(valueSet);

            // Act
            //// try to remove the first codes.
            var removers = valueSet.ValueSetCodes.Batch(removeCodeCount).First();

            var result = this.Profiler.ExecuteTimed(() => this.clientTermValueSetService.AddRemoveCodes(
                                                        valueSet.ValueSetGuid,
                                                        new List <ICodeSystemCode>(),
                                                        removers))
                         .Result;

            // Assert
            result.ValueSetCodes.Count.Should().Be(expectedCount);

            var codeCodeSystemGuids   = result.ValueSetCodes.Select(vs => vs.CodeSystemGuid).Distinct().ToList();
            var countCodeSystemsGuids = result.CodeCounts.Select(cc => cc.CodeSystemGuid).ToList();

            countCodeSystemsGuids.All(countCs => codeCodeSystemGuids.Contains(countCs)).Should().BeTrue();
            codeCodeSystemGuids.All(codeCs => countCodeSystemsGuids.Contains(codeCs)).Should().BeTrue();

            // cleanup
            this.clientTermValueSetService.Delete(result);
        }
Example #8
0
        [InlineData("A10BE32F-A086-41E2-B14F-9724E5D9DC29", "Trauma copy")]      // bsql -> 48.5546188 seconds
        public void CanCopyValueSet(string valueSetReferenceId, string name)
        {
            // Arrange
            var valueSetGuid = Guid.Parse(valueSetReferenceId);
            var valueSet     = this.valueSetService.GetValueSet(valueSetGuid).Single();
            var meta         = MockApiModelBuilder.ClientTermValueSetApiModel(name, 1) as IValueSetMeta;

            // Act
            var attempt = this.Profiler.ExecuteTimed(() => this.clientTermValueSetService.Copy(valueSet, name, meta));

            // Assert
            attempt.Success.Should().BeTrue();
            attempt.Result.Should().NotBeNull();
            var copy = attempt.Result;

            copy.OriginGuid.Should().Be(valueSet.ValueSetGuid);
            copy.ValueSetCodes.Count.Should().Be(valueSet.ValueSetCodes.Count);
            copy.IsCustom.Should().BeTrue();
            copy.IsLatestVersion.Should().BeTrue();
            copy.StatusCode.Should().Be(ValueSetStatus.Draft);

            // cleanup
            this.clientTermValueSetService.Delete(copy);
        }