public void Add_ExternalSourceExists()
{
// Arrange
var sourceId = "sourceId";
var userName = "******";
var unitOfWork = unitOfWorkMockSetup.Object;
var contextManager = new TestContextManager(unitOfWork, unitOfWork);
UserIdentificationMock.Setup(s => s.UserName).Returns(userName);
ExternalSourceRepoMock.Setup(s => s.All())
.Returns(new List <ExternalSource>()
{
new ExternalSource {
SourceId = sourceId, RelationId = userName, ObjectType = typeof(Model.Models.Service).Name
}
}.AsQueryable());
var serviceUtilities = new ServiceUtilities(UserIdentificationMock.Object, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
var service = new ServiceService(contextManager, translationManagerMockSetup.Object, TranslationManagerVModel, Logger, serviceUtilities,
DataUtils, CommonService, new VmOwnerReferenceLogic(), CacheManager.TypesCache, LanguageCache, PublishingStatusCache,
VersioningManager, gdService, UserOrganizationChecker);
// Act
Action act = () => service.AddService(new VmOpenApiServiceInVersionBase()
{
SourceId = sourceId
}, false, DefaultVersion, false);
// Assert
act.ShouldThrowExactly <ExternalSourceExistsException>(string.Format(CoreMessages.OpenApi.ExternalSourceExists, sourceId));
}
public void RightVersionNotFound(bool getOnlyPublished)
{
// Arrange
var id = Guid.NewGuid();
var unitOfWork = unitOfWorkMockSetup.Object;
var contextManager = new TestContextManager(unitOfWork, unitOfWork);
var serviceUtilities = new ServiceUtilities(UserIdentification, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
var translationManagerMock = translationManagerMockSetup.Object;
VersioningManagerMock.Setup(s => s.GetVersionId <OrganizationVersioned>(unitOfWork, id, PublishingStatus.Published, true)).Returns((Guid?)null);
VersioningManagerMock.Setup(s => s.GetVersionId <OrganizationVersioned>(unitOfWork, id, null, false)).Returns((Guid?)null);
var service = new DataAccess.Services.OrganizationService(contextManager, translationManagerMock, TranslationManagerVModel, Logger, OrganizationLogic,
serviceUtilities, DataUtils, CommonService, AddressService, PublishingStatusCache, LanguageCache,
VersioningManager, UserOrganizationChecker, CacheManager.TypesCache);
// Act
var result = service.GetOrganizationById(id, DefaultVersion, getOnlyPublished);
// Assert
result.Should().BeNull();
if (getOnlyPublished)
{
VersioningManagerMock.Verify(x => x.GetVersionId <OrganizationVersioned>(unitOfWork, id, PublishingStatus.Published, true), Times.Once());
}
else
{
VersioningManagerMock.Verify(x => x.GetVersionId <OrganizationVersioned>(unitOfWork, id, null, false), Times.Once());
}
}
public void RightVersionNotFound()
{
// Arrange
var unitOfWork = unitOfWorkMockSetup.Object;
var contextManager = new TestContextManager(unitOfWork, unitOfWork);
UserIdentificationMock.Setup(s => s.UserName).Returns("user");
VersioningManagerMock.Setup(s => s.GetVersionId <ServiceVersioned>(unitOfWork, _serviceId, null, false))
.Returns((Guid?)null);
var serviceUtilities = new ServiceUtilities(UserIdentificationMock.Object, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
var service = new ServiceService(contextManager, translationManagerMockSetup.Object, TranslationManagerVModel, Logger, serviceUtilities,
DataUtils, CommonService, new VmOwnerReferenceLogic(), CacheManager.TypesCache, LanguageCache, PublishingStatusCache,
VersioningManager, gdService, UserOrganizationChecker);
// Act
var result = service.SaveService(new VmOpenApiServiceInVersionBase {
Id = _serviceId
}, false, DefaultVersion, false);
// Assert
result.Should().BeNull();
translationManagerVModelMockSetup.Verify(x => x.Translate <IVmOpenApiServiceInVersionBase, ServiceVersioned>(It.IsAny <VmOpenApiServiceInVersionBase>(), unitOfWork), Times.Never());
}
public void ExternalSourceForServiceNotExists()
{
// Arrange
var sourceId = "sourceId";
var userName = "******";
ExternalSourceRepoMock.Setup(s => s.All())
.Returns(new List <ExternalSource>()
{
new ExternalSource {
SourceId = "someOtherSourceId", RelationId = userName, ObjectType = typeof(Model.Models.Service).Name
}
}.AsQueryable());
var unitOfWork = unitOfWorkMockSetup.Object;
var contextManager = new TestContextManager(unitOfWork, unitOfWork);
UserIdentificationMock.Setup(s => s.UserName).Returns(userName);
var serviceUtilities = new ServiceUtilities(UserIdentificationMock.Object, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
var service = new ServiceAndChannelService(contextManager, translationManagerMockSetup.Object, translationManagerVModelMockSetup.Object,
Logger, serviceUtilities, DataUtils, ServiceService, ChannelService, PublishingStatusCache, VersioningManager, UserOrganizationChecker,
CacheManager, UserOrganizationService);
// Act
Action act = () => service.SaveServiceConnectionsBySource(sourceId, new V7VmOpenApiServiceAndChannelRelationBySourceAsti(), DefaultVersion);
// Assert
act.ShouldThrowExactly <Exception>(CoreMessages.OpenApi.RelationIdNotFound);
}
public void CurrentVersionForServiceNotFound()
{
// Arrange
var serviceId = Guid.NewGuid();
var channelId = Guid.NewGuid();
var unitOfWork = unitOfWorkMockSetup.Object;
var contextManager = new TestContextManager(unitOfWork, unitOfWork);
var serviceUtilities = new ServiceUtilities(UserIdentificationMock.Object, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
ServiceServiceMock.Setup(s => s.GetServiceByIdSimple(serviceId, true)).Returns((VmOpenApiServiceVersionBase)null);
var service = new ServiceAndChannelService(contextManager, translationManagerMockSetup.Object, translationManagerVModelMockSetup.Object,
Logger, serviceUtilities, DataUtils, ServiceServiceMock.Object, ChannelService, PublishingStatusCache, VersioningManager,
UserOrganizationChecker, CacheManager, UserOrganizationService);
// Act
var result = service.SaveServicesAndChannels(new List <V7VmOpenApiServiceServiceChannelAstiInBase> {
new V7VmOpenApiServiceServiceChannelAstiInBase
{
ServiceId = serviceId.ToString(),
ServiceChannelId = channelId.ToString()
}
});
// Assert
result.Should().NotBeNull();
var list = Assert.IsType <List <string> >(result);
list.Count.Should().Be(1);
list.FirstOrDefault().Should().EndWith("not found!");
}
private ChannelService Arrange(ServiceChannelTypeEnum channelType, List <ServiceChannelVersioned> list = null)
{
var channelList = list ?? _channelList;
var publishedChannel = channelList.Where(o => o.PublishingStatusId == PublishedId).FirstOrDefault();
publishedChannel.TypeId = TypeCache.Get <ServiceChannelType>(channelType.ToString());
var id = publishedChannel.Id;
unitOfWorkMockSetup.Setup(uw => uw.ApplyIncludes(
It.IsAny <IQueryable <ServiceChannelVersioned> >(),
It.IsAny <Func <IQueryable <ServiceChannelVersioned>, IQueryable <ServiceChannelVersioned> > >(),
It.IsAny <bool>()
)).Returns((IQueryable <ServiceChannelVersioned> channelServices, Func <IQueryable <ServiceChannelVersioned>, IQueryable <ServiceChannelVersioned> > func, bool applyFilters) =>
{
return(channelServices);
}
);
var unitOfWork = unitOfWorkMockSetup.Object;
var contextManager = new TestContextManager(unitOfWork, unitOfWork);
var serviceUtilities = new ServiceUtilities(UserIdentification, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
ArrangeTranslationManager(channelType);
VersioningManagerMock.Setup(s => s.GetVersionId <ServiceChannelVersioned>(unitOfWork, _publishedChannelRootId, PublishingStatus.Published, true)).Returns(id);
// repositories
ChannelRepoMock.Setup(g => g.All()).Returns(channelList.AsQueryable());
return(new ChannelService(contextManager, UserIdentification, translationManagerMockSetup.Object, TranslationManagerVModel,
Logger, ServiceChannelLogic, serviceUtilities, CommonService, new VmListItemLogic(), DataUtils, new VmOwnerReferenceLogic(),
AddressService, CacheManager, PublishingStatusCache, VersioningManager, UserOrganizationChecker, UrlService));
}
public void NoEntitesFound()
{
// Arrange
// unitOfWork
var serviceMock = new Mock <IServiceVersionedRepository>();
serviceMock.Setup(o => o.All()).Returns(EntityGenerator.GetServiceEntityList(0, PublishingStatusCache).AsQueryable());
unitOfWorkMockSetup.Setup(uw => uw.CreateRepository <IServiceVersionedRepository>()).Returns(serviceMock.Object);
var channelMock = new Mock <IServiceChannelVersionedRepository>();
channelMock.Setup(o => o.All()).Returns(new List <ServiceChannelVersioned>().AsQueryable());
unitOfWorkMockSetup.Setup(uw => uw.CreateRepository <IServiceChannelVersionedRepository>()).Returns(channelMock.Object);
var unitOfWorkMock = unitOfWorkMockSetup.Object;
var contextManager = new TestContextManager(unitOfWorkMock, unitOfWorkMock);
var serviceUtilities = new ServiceUtilities(UserIdentification, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
// common service
var service = new CommonService(translationManagerMockSetup.Object, TranslationManagerVModel, contextManager, CacheManager.TypesCache, PublishingStatusCache,
UserOrganizationChecker, DataServiceFetcherMock, serviceUtilities, VersioningManager, ApplicationConfigurationMock, HttpContextAccessorMock);
// Act
var result = service.GetServicesAndChannelsByOrganization(Guid.NewGuid(), null, 1, 1);
// Assert
result.Should().NotBeNull();
result.PageCount.Should().Be(0);
result.Should().BeOfType <VmOpenApiEntityGuidPage>();
(result as VmOpenApiEntityGuidPage).ItemList.Should().BeNullOrEmpty();
}
public void ApplyIncludesReturnsNull()
{
// Arrange
var organizationList = EntityGenerator.GetOrganizationEntityList(1, PublishingStatusCache);
var deletedOrganization = organizationList.Where(o => o.PublishingStatusId == DeletedId).FirstOrDefault();
var id = deletedOrganization.Id;
var unitOfWork = unitOfWorkMockSetup.Object;
var contextManager = new TestContextManager(unitOfWork, unitOfWork);
var serviceUtilities = new ServiceUtilities(UserIdentification, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
translationManagerMockSetup.Setup(t => t.Translate <OrganizationVersioned, VmOpenApiOrganizationSaha>(deletedOrganization))
.Returns(new VmOpenApiOrganizationSaha());
var translationManagerMock = translationManagerMockSetup.Object;
VersioningManagerMock.Setup(s => s.GetVersionId <OrganizationVersioned>(unitOfWork, id, PublishingStatus.Published, true)).Returns(Guid.NewGuid());
OrganizationRepoMock.Setup(g => g.All()).Returns(organizationList.AsQueryable());
var service = new DataAccess.Services.OrganizationService(contextManager, translationManagerMock, TranslationManagerVModel, Logger, OrganizationLogic,
serviceUtilities, DataUtils, CommonService, AddressService, PublishingStatusCache, LanguageCache,
VersioningManager, UserOrganizationChecker, CacheManager.TypesCache);
// Act
Action act = () => service.GetOrganizationSahaById(id);
// Assert
act.ShouldThrow <Exception>();
}
public void ASTIUpdate_RegularConnectionsNotDeleted()
{
// Arrange
var serviceId = Guid.NewGuid();
var channelId = Guid.NewGuid();
var request = new V7VmOpenApiServiceAndChannelRelationAstiInBase
{
IsASTI = true,
ServiceId = serviceId,
ChannelRelations = new List <V7VmOpenApiServiceServiceChannelAstiInBase>
{
new V7VmOpenApiServiceServiceChannelAstiInBase
{
ServiceGuid = serviceId,
ChannelGuid = channelId,
}
}
};
var unitOfWork = unitOfWorkMockSetup.Object;
var contextManager = new TestContextManager(unitOfWork, unitOfWork);
var serviceUtilities = new ServiceUtilities(UserIdentificationMock.Object, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
translationManagerVModelMockSetup.Setup(s => s.Translate <V7VmOpenApiServiceAndChannelRelationAstiInBase, Model.Models.Service>(request, unitOfWork))
.Returns(new Model.Models.Service()
{
Id = serviceId,
ServiceServiceChannels = new List <ServiceServiceChannel>
{
new ServiceServiceChannel {
IsASTIConnection = true, ServiceChannelId = channelId
},
new ServiceServiceChannel {
IsASTIConnection = false, ServiceChannelId = Guid.NewGuid()
}
}
});
// repositories
ConnectionRepoMock.Setup(c => c.All()).Returns(new List <ServiceServiceChannel>().AsQueryable());
DescriptionRepoMock.Setup(c => c.All()).Returns(new List <ServiceServiceChannelDescription>().AsQueryable());
var service = new ServiceAndChannelService(contextManager, translationManagerMockSetup.Object, translationManagerVModelMockSetup.Object,
Logger, serviceUtilities, DataUtils, ServiceService, ChannelService, PublishingStatusCache, VersioningManager, UserOrganizationChecker,
CacheManager, UserOrganizationService);
// Act
var result = service.SaveServiceConnections(request, DefaultVersion);
// Assert
// We are not testing method GetServiceById so we expect result to be null.
result.Should().BeNull();
translationManagerVModelMockSetup.Verify(t => t.Translate <V7VmOpenApiServiceAndChannelRelationAstiInBase, Model.Models.Service>(It.IsAny <V7VmOpenApiServiceAndChannelRelationAstiInBase>(), unitOfWork), Times.Once());
ConnectionRepoMock.Verify(x => x.Remove(It.IsAny <ServiceServiceChannel>()), Times.Never());
DescriptionRepoMock.Verify(x => x.Remove(It.IsAny <ServiceServiceChannelDescription>()), Times.Never());
}
public void CanModify()
{
// Arrange
var serviceId = Guid.NewGuid();
var channelId = Guid.NewGuid();
var organizationId = Guid.NewGuid();
var relation = new V7VmOpenApiServiceServiceChannelAstiInBase
{
ServiceId = serviceId.ToString(),
ServiceChannelId = channelId.ToString()
};
var unitOfWork = unitOfWorkMockSetup.Object;
var contextManager = new TestContextManager(unitOfWork, unitOfWork);
var serviceUtilities = new ServiceUtilities(UserIdentificationMock.Object, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
ServiceServiceMock.Setup(s => s.GetServiceByIdSimple(serviceId, true))
.Returns(new VmOpenApiServiceVersionBase()
{
PublishingStatus = PublishingStatus.Published.ToString()
});
ChannelServiceMock.Setup(s => s.GetServiceChannelByIdSimple(channelId, true))
.Returns(new VmOpenApiServiceChannel()
{
Id = channelId,
IsVisibleForAll = false,
OrganizationId = organizationId,
ServiceChannelType = ServiceChannelTypeEnum.ServiceLocation.ToString(),
Security = new VmSecurityOwnOrganization {
IsOwnOrganization = true
}
});
//UserOrganizationServiceMock.Setup(s => s.GetAllUserOrganizations(unitOfWork)).Returns(new List<Guid>() { organizationId });
translationManagerVModelMockSetup.Setup(s => s.Translate <IVmOpenApiServiceServiceChannelInVersionBase, ServiceServiceChannel>(relation, unitOfWork))
.Returns(new ServiceServiceChannel());
var service = new ServiceAndChannelService(contextManager, translationManagerMockSetup.Object, translationManagerVModelMockSetup.Object,
Logger, serviceUtilities, DataUtils, ServiceServiceMock.Object, ChannelService, PublishingStatusCache, VersioningManager,
UserOrganizationChecker, CacheManager, UserOrganizationServiceMock.Object);
// Act
var result = service.SaveServicesAndChannels(new List <V7VmOpenApiServiceServiceChannelAstiInBase> {
relation
});
// Assert
result.Should().NotBeNull();
var list = Assert.IsType <List <string> >(result);
list.Count.Should().Be(1);
list.FirstOrDefault().Should().EndWith("added or updated.");
translationManagerVModelMockSetup.Verify(x => x.Translate <IVmOpenApiServiceServiceChannelInVersionBase, ServiceServiceChannel>(It.IsAny <VmOpenApiServiceServiceChannelInVersionBase>(), unitOfWork), Times.Once());
}
private DataAccess.Services.OrganizationService Arrange(List <OrganizationVersioned> list = null)
{
var organizationList = list ?? _organizationList;
var publishedOrganization = organizationList.Where(o => o.PublishingStatusId == PublishedId).FirstOrDefault();
var id = publishedOrganization.Id;
var rootId = publishedOrganization.UnificRootId;
unitOfWorkMockSetup.Setup(uw => uw.ApplyIncludes(
It.IsAny <IQueryable <OrganizationVersioned> >(),
It.IsAny <Func <IQueryable <OrganizationVersioned>, IQueryable <OrganizationVersioned> > >(),
It.IsAny <bool>()
)).Returns((IQueryable <OrganizationVersioned> orgList, Func <IQueryable <OrganizationVersioned>, IQueryable <OrganizationVersioned> > func, bool applyfilters) =>
{
return(orgList);
});
var unitOfWork = unitOfWorkMockSetup.Object;
var contextManager = new TestContextManager(unitOfWork, unitOfWork);
var serviceUtilities = new ServiceUtilities(UserIdentification, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
translationManagerMockSetup.Setup(t => t.Translate <OrganizationVersioned, VmOpenApiOrganizationVersionBase>(It.IsAny <OrganizationVersioned>()))
.Returns((OrganizationVersioned org) =>
{
if (org == null)
{
return(null);
}
return(new VmOpenApiOrganizationVersionBase {
Id = org.UnificRootId, Modified = org.Modified, PublishingStatus = TypeCache.GetByValue <PublishingStatusType>(org.PublishingStatusId)
});
});
var translationManagerMock = translationManagerMockSetup.Object;
VersioningManagerMock.Setup(s => s.GetVersionId <OrganizationVersioned>(unitOfWork, rootId, PublishingStatus.Published, true)).Returns(id);
// repositories
OrganizationRepoMock.Setup(g => g.All()).Returns(organizationList.AsQueryable());
OrganizationNameRepoMock.Setup(m => m.All()).Returns(Enumerable.Empty <OrganizationName>().AsQueryable());
var serviceNameRepoMock = new Mock <IServiceNameRepository>();
unitOfWorkMockSetup.Setup(uw => uw.CreateRepository <IServiceNameRepository>()).Returns(serviceNameRepoMock.Object);
var organizationServiceRepoMock = new Mock <IOrganizationServiceRepository>();
unitOfWorkMockSetup.Setup(uw => uw.CreateRepository <IOrganizationServiceRepository>()).Returns(organizationServiceRepoMock.Object);
var serviceRepoMock = new Mock <IServiceVersionedRepository>();
unitOfWorkMockSetup.Setup(uw => uw.CreateRepository <IServiceVersionedRepository>()).Returns(serviceRepoMock.Object);
var serviceProducerRepoMock = new Mock <IServiceProducerOrganizationRepository>();
unitOfWorkMockSetup.Setup(uw => uw.CreateRepository <IServiceProducerOrganizationRepository>()).Returns(serviceProducerRepoMock.Object);
return(new DataAccess.Services.OrganizationService(contextManager, translationManagerMock, TranslationManagerVModel, Logger, OrganizationLogic,
serviceUtilities, DataUtils, CommonService, AddressService, PublishingStatusCache, LanguageCache,
VersioningManager, UserOrganizationChecker, CacheManager.TypesCache));
}
public void GdAttached_AttachProposedChannels()
{
// Arrange
var userName = "******";
var gdId = Guid.NewGuid();
var descriptions = TestDataFactory.CreateLocalizedList("Description");
var entityName = typeof(Model.Models.Service).Name;
var vm = new VmOpenApiServiceInVersionBase
{
Id = _serviceId,
StatutoryServiceGeneralDescriptionId = gdId.ToString()
};
var unitOfWork = unitOfWorkMockSetup.Object;
var contextManager = new TestContextManager(unitOfWork, unitOfWork);
UserIdentificationMock.Setup(s => s.UserName).Returns(userName);
VersioningManagerMock.Setup(s => s.GetVersionId <ServiceVersioned>(unitOfWork, _serviceId, null, false))
.Returns(_serviceVersionedId);
gdServiceMock.Setup(g => g.GetGeneralDescriptionVersionBase(It.IsAny <Guid>(), 0, true))
.Returns(new VmOpenApiGeneralDescriptionVersionBase()
{
ServiceChannels = new List <V6VmOpenApiServiceServiceChannel>
{
new V6VmOpenApiServiceServiceChannel {
ServiceChannel = new VmOpenApiItem {
Id = _channelId
}, Description = descriptions
}
}
});
var serviceUtilities = new ServiceUtilities(UserIdentificationMock.Object, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
var service = new ServiceService(contextManager, translationManagerMockSetup.Object, TranslationManagerVModel, Logger, serviceUtilities,
DataUtils, CommonService, new VmOwnerReferenceLogic(), CacheManager.TypesCache, LanguageCache, PublishingStatusCache,
VersioningManager, gdService, UserOrganizationChecker);
// Act
var result = service.SaveService(vm, false, DefaultVersion, true);
// Assert
result.Should().NotBeNull();
var vmResult = Assert.IsType <V7VmOpenApiService>(result);
vmResult.StatutoryServiceGeneralDescriptionId.Should().Be(gdId);
vmResult.ServiceChannels.Should().NotBeNull();
vmResult.ServiceChannels.Count.Should().Be(1);
translationManagerVModelMockSetup.Verify(x => x.Translate <IVmOpenApiServiceInVersionBase, ServiceVersioned>(It.IsAny <VmOpenApiServiceInVersionBase>(), unitOfWork), Times.Once());
translationManagerMockSetup.Verify(x => x.Translate <ServiceVersioned, VmOpenApiServiceVersionBase>(It.IsAny <ServiceVersioned>()), Times.Once());
}
public void GdAttached_MapDataFormGD()
{
// Arrange
var userName = "******";
var gdId = Guid.NewGuid();
var gdType = ServiceTypeEnum.PermissionAndObligation.ToString();
var gdChargeType = ServiceChargeTypeEnum.Free.ToString();
var vm = new VmOpenApiServiceInVersionBase
{
Id = _serviceId,
StatutoryServiceGeneralDescriptionId = gdId.ToString()
};
var unitOfWork = unitOfWorkMockSetup.Object;
var contextManager = new TestContextManager(unitOfWork, unitOfWork);
UserIdentificationMock.Setup(s => s.UserName).Returns(userName);
VersioningManagerMock.Setup(s => s.GetVersionId <ServiceVersioned>(unitOfWork, _serviceId, null, false))
.Returns(_serviceVersionedId);
gdServiceMock.Setup(g => g.GetGeneralDescriptionSimple(unitOfWork, It.IsAny <Guid>()))
.Returns(new VmOpenApiGeneralDescriptionVersionBase()
{
Type = gdType,
ServiceChargeType = gdChargeType
});
gdServiceMock.Setup(g => g.GetGeneralDescriptionVersionBase(It.IsAny <Guid>(), 0, true))
.Returns(new VmOpenApiGeneralDescriptionVersionBase()
{
Type = gdType,
ServiceChargeType = gdChargeType
});
var serviceUtilities = new ServiceUtilities(UserIdentificationMock.Object, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
var service = new ServiceService(contextManager, translationManagerMockSetup.Object, TranslationManagerVModel, Logger, serviceUtilities,
DataUtils, CommonService, new VmOwnerReferenceLogic(), CacheManager.TypesCache, LanguageCache, PublishingStatusCache,
VersioningManager, gdService, UserOrganizationChecker);
// Act
var result = service.SaveService(vm, false, DefaultVersion, true);
// Assert
result.Should().NotBeNull();
var vmResult = Assert.IsType <V7VmOpenApiService>(result);
vmResult.StatutoryServiceGeneralDescriptionId.Should().Be(gdId);
vmResult.Type.Should().Be(gdType);
vmResult.ServiceChargeType.Should().BeNull(); // service charge type is not gotten from GD (in GET) so should be null
translationManagerVModelMockSetup.Verify(x => x.Translate <IVmOpenApiServiceInVersionBase, ServiceVersioned>(It.IsAny <VmOpenApiServiceInVersionBase>(), unitOfWork), Times.Once());
translationManagerMockSetup.Verify(x => x.Translate <ServiceVersioned, VmOpenApiServiceVersionBase>(It.IsAny <ServiceVersioned>()), Times.Once());
}
public void ServicesAndChannelsFound()
{
// Arrange
var services = EntityGenerator.GetServiceEntityList(1, PublishingStatusCache);
var publishedService = services.Where(o => o.PublishingStatusId == PublishedId).FirstOrDefault();
publishedService.OrganizationId = _organizationId;
var channels = EntityGenerator.GetServiceChannelEntityList(1, PublishingStatusCache);
var publishedChannel = channels.Where(o => o.PublishingStatusId == PublishedId).FirstOrDefault();
publishedChannel.OrganizationId = _organizationId;
// unitOfWork
var serviceMock = new Mock <IServiceVersionedRepository>();
serviceMock.Setup(o => o.All()).Returns(services.AsQueryable());
unitOfWorkMockSetup.Setup(uw => uw.CreateRepository <IServiceVersionedRepository>()).Returns(serviceMock.Object);
var channelMock = new Mock <IServiceChannelVersionedRepository>();
channelMock.Setup(o => o.All()).Returns(channels.AsQueryable());
unitOfWorkMockSetup.Setup(uw => uw.CreateRepository <IServiceChannelVersionedRepository>()).Returns(channelMock.Object);
var unitOfWorkMock = unitOfWorkMockSetup.Object;
// Translation manager
translationManagerMockSetup.Setup(t => t.TranslateAll <EntityBase, VmOpenApiEntityItem>(It.IsAny <IList <EntityBase> >()))
.Returns(new List <VmOpenApiEntityItem>()
{
new VmOpenApiEntityItem()
});
var contextManager = new TestContextManager(unitOfWorkMock, unitOfWorkMock);
var serviceUtilities = new ServiceUtilities(UserIdentification, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
// common service
var service = new CommonService(translationManagerMockSetup.Object, TranslationManagerVModel, contextManager, CacheManager.TypesCache, PublishingStatusCache,
UserOrganizationChecker, DataServiceFetcherMock, serviceUtilities, VersioningManager, ApplicationConfigurationMock, HttpContextAccessorMock);
// Act
var result = service.GetServicesAndChannelsByOrganization(_organizationId, null, 1, 1);
// Assert
result.Should().NotBeNull();
result.PageCount.Should().Be(2);
result.Should().BeOfType <VmOpenApiEntityGuidPage>();
(result as VmOpenApiEntityGuidPage).ItemList.Should().NotBeNullOrEmpty();
(result as VmOpenApiEntityGuidPage).ItemList.Count.Should().Be(1);
}
private ServiceService Arrange(List <ServiceVersioned> list = null)
{
var serviceList = list ?? _list;
var publishedItem = serviceList.Where(o => o.PublishingStatusId == PublishedId).FirstOrDefault();
var id = publishedItem.Id;
var rootId = publishedItem.UnificRootId;
unitOfWorkMockSetup.Setup(uw => uw.ApplyIncludes(
It.IsAny <IQueryable <ServiceVersioned> >(),
It.IsAny <Func <IQueryable <ServiceVersioned>, IQueryable <ServiceVersioned> > >(),
It.IsAny <bool>()
)).Returns((IQueryable <ServiceVersioned> services, Func <IQueryable <ServiceVersioned>, IQueryable <ServiceVersioned> > func, bool applyFilters) =>
{
return(services);
});
var unitOfWork = unitOfWorkMockSetup.Object;
var contextManager = new TestContextManager(unitOfWork, unitOfWork);
var serviceUtilities = new ServiceUtilities(UserIdentification, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
translationManagerMockSetup.Setup(t => t.Translate <ServiceVersioned, VmOpenApiServiceVersionBase>(It.IsAny <ServiceVersioned>()))
.Returns((ServiceVersioned entity) =>
{
if (entity == null)
{
return(null);
}
return(new VmOpenApiServiceVersionBase()
{
Id = entity.UnificRootId, PublishingStatus = PublishingStatusCache.GetByValue(entity.PublishingStatusId)
});
});
var translationManagerMock = translationManagerMockSetup.Object;
VersioningManagerMock.Setup(s => s.GetVersionId <ServiceVersioned>(unitOfWork, rootId, PublishingStatus.Published, true)).Returns(id);
// repositories
ServiceRepoMock.Setup(g => g.All()).Returns(serviceList.AsQueryable());
ServiceNameRepoMock.Setup(m => m.All()).Returns(Enumerable.Empty <ServiceName>().AsQueryable());
var serviceNameRepoMock = new Mock <IServiceNameRepository>();
unitOfWorkMockSetup.Setup(uw => uw.CreateRepository <IServiceNameRepository>()).Returns(serviceNameRepoMock.Object);
return(new ServiceService(contextManager, translationManagerMock, TranslationManagerVModel, Logger, serviceUtilities,
DataUtils, CommonService, new VmOwnerReferenceLogic(), CacheManager.TypesCache, LanguageCache, PublishingStatusCache,
VersioningManager, gdService, UserOrganizationChecker));
}
public void Add_PublishedEntity()
{
// Arrange
var sourceId = "sourceId";
var userName = "******";
var gdId = Guid.NewGuid();
var list = EntityGenerator.GetServiceEntityList(1, PublishingStatusCache);
var publishedEntity = list.Where(i => i.PublishingStatusId == PublishedId).FirstOrDefault();
var vm = new VmOpenApiServiceInVersionBase()
{
SourceId = sourceId,
PublishingStatus = PublishingStatus.Published.ToString()
};
var unitOfWork = unitOfWorkMockSetup.Object;
var contextManager = new TestContextManager(unitOfWork, unitOfWork);
UserIdentificationMock.Setup(s => s.UserName).Returns(userName);
ExternalSourceRepoMock.Setup(s => s.All())
.Returns(new List <ExternalSource>()
{
new ExternalSource {
SourceId = sourceId + "2", RelationId = userName, ObjectType = typeof(Model.Models.Service).Name
}
}.AsQueryable()); // does not return same source id
gdServiceMock.Setup(s => s.GetGeneralDescriptionVersionBase(gdId, 0, true)).Returns(new VmOpenApiGeneralDescriptionVersionBase());
var serviceUtilities = new ServiceUtilities(UserIdentificationMock.Object, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
CommonServiceMock.Setup(s => s.PublishAllAvailableLanguageVersions <ServiceVersioned, ServiceLanguageAvailability>(_serviceVersionedId, It.IsAny <Expression <Func <ServiceLanguageAvailability, bool> > >()))
.Returns(new PublishingResult());
var service = new ServiceService(contextManager, translationManagerMockSetup.Object, translationManagerVModelMockSetup.Object, Logger, serviceUtilities,
DataUtils, CommonService, new VmOwnerReferenceLogic(), CacheManager.TypesCache, LanguageCache, PublishingStatusCache,
VersioningManager, gdService, UserOrganizationChecker);
// Act
var result = service.AddService(vm, false, DefaultVersion, false);
// Assert
result.Should().NotBeNull();
var vmResult = Assert.IsType <V7VmOpenApiService>(result);
vmResult.PublishingStatus.Should().Be(PublishingStatus.Published.ToString());
translationManagerVModelMockSetup.Verify(x => x.Translate <IVmOpenApiServiceInVersionBase, ServiceVersioned>(It.IsAny <VmOpenApiServiceInVersionBase>(), unitOfWork), Times.Once());
translationManagerMockSetup.Verify(x => x.Translate <ServiceVersioned, VmOpenApiServiceVersionBase>(It.IsAny <ServiceVersioned>()), Times.Once());
CommonServiceMock.Verify(x => x.PublishAllAvailableLanguageVersions <ServiceVersioned, ServiceLanguageAvailability>(_serviceVersionedId, It.IsAny <Expression <Func <ServiceLanguageAvailability, bool> > >()), Times.Once());
}
private void TestBase(DateTime?date, List <StatutoryServiceGeneralDescriptionVersioned> entityList, int pageNumber, int pageSize, int count, int expectedPageCount, int expectedItemCountOnPage)
{
// unitOfWork
var gdRepoMock = new Mock <IStatutoryServiceGeneralDescriptionVersionedRepository>();
gdRepoMock.Setup(g => g.All()).Returns(entityList.AsQueryable());
unitOfWorkMockSetup.Setup(uw => uw.CreateRepository <IRepository <StatutoryServiceGeneralDescriptionVersioned> >()).Returns(gdRepoMock.Object);
unitOfWorkMockSetup.Setup(uw => uw.ApplyIncludes(
It.IsAny <IQueryable <StatutoryServiceGeneralDescriptionVersioned> >(),
It.IsAny <Func <IQueryable <StatutoryServiceGeneralDescriptionVersioned>, IQueryable <StatutoryServiceGeneralDescriptionVersioned> > >(),
It.IsAny <bool>()
)).Returns(entityList.AsQueryable());
var unitOfWorkMock = unitOfWorkMockSetup.Object;
// Translation manager
translationManagerMockSetup.Setup(t => t.TranslateAll <StatutoryServiceGeneralDescriptionVersioned, VmOpenApiItem>(It.IsAny <IList <StatutoryServiceGeneralDescriptionVersioned> >()))
.Returns(TestDataFactory.CreateVmItemList(count));
var translationManagerMock = translationManagerMockSetup.Object;
var contextManager = new TestContextManager(unitOfWorkMock, unitOfWorkMock);
var serviceUtilities = new ServiceUtilities(UserIdentification, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
var gdService = new GeneralDescriptionService(contextManager, UserIdentification, translationManagerMock, TranslationManagerVModel,
Logger, serviceUtilities, CommonService, PublishingStatusCache, UserOrganizationChecker, LanguageCache, TypeCache,
VersioningManager, DataUtils, ValidationManagerMock);
// Act
var result = gdService.GetGeneralDescriptions(date, pageNumber, pageSize);
// Assert
result.Should().NotBeNull();
result.PageCount.Should().Be(expectedPageCount);
if (result is V3VmOpenApiGuidPage)
{
if (expectedItemCountOnPage == 0)
{
(result as V3VmOpenApiGuidPage).ItemList.Should().BeNull();
}
else
{
(result as V3VmOpenApiGuidPage).ItemList.Count.Should().BeGreaterThan(0);
}
}
}
private IVmOpenApiGuidPageVersionBase ArrangeAndAct(DateTime?date, List <ServiceChannelVersioned> entityList, int pageNumber, int pageSize, bool archived, bool active)
{
// unitOfWork
var channelRepoMock = new Mock <IRepository <ServiceChannelVersioned> >();
unitOfWorkMockSetup.Setup(uw => uw.CreateRepository <IRepository <ServiceChannelVersioned> >()).Returns(channelRepoMock.Object);
channelRepoMock.Setup(g => g.All()).Returns(entityList.AsQueryable());
unitOfWorkMockSetup.Setup(uw => uw.ApplyIncludes(
It.IsAny <IQueryable <ServiceChannelVersioned> >(),
It.IsAny <Func <IQueryable <ServiceChannelVersioned>, IQueryable <ServiceChannelVersioned> > >(),
It.IsAny <bool>()
)).Returns((IQueryable <ServiceChannelVersioned> items, Func <IQueryable <ServiceChannelVersioned>, IQueryable <ServiceChannelVersioned> > func, bool applyFilters) =>
{
return(items);
});
var unitOfWorkMock = unitOfWorkMockSetup.Object;
// Translation manager
translationManagerMockSetup.Setup(t => t.TranslateAll <ServiceChannelVersioned, VmOpenApiItem>(It.IsAny <IList <ServiceChannelVersioned> >()))
.Returns((ICollection <ServiceChannelVersioned> collection) =>
{
var list = new List <VmOpenApiItem>();
if (collection?.Count > 0)
{
collection.ToList().ForEach(c => list.Add(new VmOpenApiItem
{
Id = c.UnificRootId,
}));
}
return(list);
});
var translationManagerMock = translationManagerMockSetup.Object;
var contextManager = new TestContextManager(unitOfWorkMock, unitOfWorkMock);
var serviceUtilities = new ServiceUtilities(UserIdentification, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
var service = new ChannelService(contextManager, UserIdentification, translationManagerMockSetup.Object, TranslationManagerVModel,
Logger, ServiceChannelLogic, serviceUtilities, CommonService, new VmListItemLogic(), DataUtils, new VmOwnerReferenceLogic(),
AddressService, CacheManager, PublishingStatusCache, VersioningManager, UserOrganizationChecker, UrlService);
// Act
return(service.GetServiceChannels(date, pageNumber, pageSize, archived, active));
}
private DataAccess.Services.OrganizationService ArrangeAndGetService(IList <OrganizationVersioned> organizations, bool isAland = false)
{
var publishedOrganization = organizations.Where(o => o.PublishingStatusId == PublishedId).FirstOrDefault();
if (isAland)
{
_areaRepoMock.Setup(g => g.All()).Returns(new List <Area>()
{
new Area
{
Id = _areaId,
AreaTypeId = TypeCache.Get <AreaType>(AreaTypeEnum.Province.ToString()),
Code = "20"
}
}.AsQueryable());
}
else
{
_areaRepoMock.Setup(g => g.All()).Returns(new List <Area>().AsQueryable());
}
unitOfWorkMockSetup.Setup(uw => uw.ApplyIncludes(
It.IsAny <IQueryable <OrganizationVersioned> >(),
It.IsAny <Func <IQueryable <OrganizationVersioned>, IQueryable <OrganizationVersioned> > >(),
It.IsAny <bool>()
)).Returns((IQueryable <OrganizationVersioned> list, Func <IQueryable <OrganizationVersioned>, IQueryable <OrganizationVersioned> > func, bool applyFilters) =>
{
return(list);
});
var organizationMock = new Mock <IOrganizationVersionedRepository>();
organizationMock.Setup(o => o.All()).Returns(organizations.AsQueryable());
unitOfWorkMockSetup.Setup(uw => uw.CreateRepository <IRepository <OrganizationVersioned> >()).Returns(organizationMock.Object);
var unitOfWorkMock = unitOfWorkMockSetup.Object;
var contextManager = new TestContextManager(unitOfWorkMock, unitOfWorkMock);
var serviceUtilities = new ServiceUtilities(UserIdentification, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
// service
return(new DataAccess.Services.OrganizationService(contextManager, translationManagerMockSetup.Object, TranslationManagerVModel, Logger, OrganizationLogic,
serviceUtilities, DataUtils, CommonService, AddressService, PublishingStatusCache, LanguageCache,
VersioningManager, UserOrganizationChecker, CacheManager.TypesCache));
}
public void ChannelNotVisibleForUser()
{
// Arrange
var serviceId = Guid.NewGuid();
var channelId = Guid.NewGuid();
var organizationId = Guid.NewGuid();
var unitOfWork = unitOfWorkMockSetup.Object;
var contextManager = new TestContextManager(unitOfWork, unitOfWork);
var serviceUtilities = new ServiceUtilities(UserIdentificationMock.Object, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
ServiceServiceMock.Setup(s => s.GetServiceByIdSimple(serviceId, true))
.Returns(new VmOpenApiServiceVersionBase()
{
PublishingStatus = PublishingStatus.Published.ToString()
});
ChannelServiceMock.Setup(s => s.GetServiceChannelByIdSimple(channelId, true))
.Returns(new VmOpenApiServiceChannel()
{
Id = channelId, IsVisibleForAll = false, OrganizationId = organizationId
});
UserOrganizationServiceMock.Setup(s => s.GetAllUserOrganizations(unitOfWork)).Returns(new List <Guid>());
var service = new ServiceAndChannelService(contextManager, translationManagerMockSetup.Object, translationManagerVModelMockSetup.Object,
Logger, serviceUtilities, DataUtils, ServiceServiceMock.Object, ChannelService, PublishingStatusCache, VersioningManager,
UserOrganizationChecker, CacheManager, UserOrganizationServiceMock.Object);
// Act
var result = service.SaveServicesAndChannels(new List <V7VmOpenApiServiceServiceChannelAstiInBase> {
new V7VmOpenApiServiceServiceChannelAstiInBase
{
ServiceId = serviceId.ToString(),
ServiceChannelId = channelId.ToString()
}
});
// Assert
result.Should().NotBeNull();
var list = Assert.IsType <List <string> >(result);
list.Count.Should().Be(1);
list.FirstOrDefault().Should().EndWith("You do not have permission to update data!");
}
private IVmOpenApiGuidPageVersionBase ArrangeAndAct(DateTime?date, List <OrganizationVersioned> entityList, int pageNumber, int pageSize, bool archived, int version = 7)
{
// unitOfWork
OrganizationRepoMock.Setup(g => g.All()).Returns(entityList.AsQueryable());
unitOfWorkMockSetup.Setup(uw => uw.ApplyIncludes(
It.IsAny <IQueryable <OrganizationVersioned> >(),
It.IsAny <Func <IQueryable <OrganizationVersioned>, IQueryable <OrganizationVersioned> > >(),
It.IsAny <bool>()
)).Returns((IQueryable <OrganizationVersioned> organizations, Func <IQueryable <OrganizationVersioned>, IQueryable <OrganizationVersioned> > func, bool applyFilters) =>
{
return(organizations);
});
var unitOfWorkMock = unitOfWorkMockSetup.Object;
// Translation manager
translationManagerMockSetup.Setup(t => t.TranslateAll <OrganizationVersioned, VmOpenApiOrganizationItem>(It.IsAny <IList <OrganizationVersioned> >()))
.Returns((ICollection <OrganizationVersioned> collection) =>
{
var list = new List <VmOpenApiOrganizationItem>();
if (collection?.Count > 0)
{
collection.ToList().ForEach(c => list.Add(new VmOpenApiOrganizationItem
{
ParentOrganization = c.ParentId,
Id = c.UnificRootId,
}));
}
return(list);
});
var translationManagerMock = translationManagerMockSetup.Object;
var contextManager = new TestContextManager(unitOfWorkMock, unitOfWorkMock);
var serviceUtilities = new ServiceUtilities(UserIdentification, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
var service = new DataAccess.Services.OrganizationService(contextManager, translationManagerMock, TranslationManagerVModel, Logger, OrganizationLogic,
serviceUtilities, DataUtils, CommonService, AddressService, PublishingStatusCache, LanguageCache,
VersioningManager, UserOrganizationChecker, CacheManager.TypesCache);
// Act
return(service.GetOrganizations(date, version, pageNumber, pageSize, archived));
}
private ChannelService Arrange(IVmOpenApiServiceChannelIn vm, ServiceChannelTypeEnum channelType)
{
var userName = "******";
publishedEntity.TypeId = TypeCache.Get <ServiceChannelType>(channelType.ToString());
unitOfWorkMockSetup.Setup(uw => uw.ApplyIncludes(
It.IsAny <IQueryable <ServiceChannelVersioned> >(),
It.IsAny <Func <IQueryable <ServiceChannelVersioned>, IQueryable <ServiceChannelVersioned> > >(),
It.IsAny <bool>()
)).Returns(new List <ServiceChannelVersioned> {
publishedEntity
}.AsQueryable());
var unitOfWork = unitOfWorkMockSetup.Object;
var contextManager = new TestContextManager(unitOfWork, unitOfWork);
UserIdentificationMock.Setup(s => s.UserName).Returns(userName);
ExternalSourceRepoMock.Setup(s => s.All())
.Returns(new List <ExternalSource>()
{
new ExternalSource {
SourceId = sourceId + "2", RelationId = userName, ObjectType = typeof(Model.Models.ServiceChannel).Name
}
}.AsQueryable()); // does not return same source id
var serviceUtilities = new ServiceUtilities(UserIdentificationMock.Object, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
translationManagerVModelMockSetup.Setup(t => t.Translate <IVmOpenApiServiceChannelIn, ServiceChannelVersioned>(vm, unitOfWork))
.Returns(publishedEntity);
translationManagerVModelMockSetup.Setup(t => t.TranslateAll <VmOpenApiConnection, ServiceServiceChannel>(It.IsAny <List <VmOpenApiConnection> >(), unitOfWork))
.Returns(new List <ServiceServiceChannel>());
ArrangeTranslationManager(channelType);
CommonServiceMock.Setup(s => s.PublishAllAvailableLanguageVersions <ServiceChannelVersioned, ServiceChannelLanguageAvailability>(publishedEntity.Id, It.IsAny <Expression <Func <ServiceChannelLanguageAvailability, bool> > >()))
.Returns(new PublishingResult());
return(new ChannelService(contextManager, UserIdentification, translationManagerMockSetup.Object, TranslationManagerVModel,
Logger, ServiceChannelLogic, serviceUtilities, CommonService, new VmListItemLogic(), DataUtils, new VmOwnerReferenceLogic(),
AddressService, CacheManager, PublishingStatusCache, VersioningManager, UserOrganizationChecker, UrlService));
}
public void ModelIsNull()
{
// Arrange
var unitOfWork = unitOfWorkMockSetup.Object;
var contextManager = new TestContextManager(unitOfWork, unitOfWork);
var serviceUtilities = new ServiceUtilities(UserIdentificationMock.Object, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
var service = new ServiceAndChannelService(contextManager, translationManagerMockSetup.Object, translationManagerVModelMockSetup.Object,
Logger, serviceUtilities, DataUtils, ServiceService, ChannelService, PublishingStatusCache, VersioningManager, UserOrganizationChecker,
CacheManager, UserOrganizationService);
// Act
var result = service.SaveServiceChannelConnections(null, DefaultVersion);
// Assert
result.Should().BeNull();
}
public void Add_CannotGetUser()
{
// Arrange
var unitOfWork = unitOfWorkMockSetup.Object;
var contextManager = new TestContextManager(unitOfWork, unitOfWork);
UserIdentificationMock.Setup(s => s.UserName).Returns((string)null);
var serviceUtilities = new ServiceUtilities(UserIdentificationMock.Object, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
var service = new ServiceService(contextManager, translationManagerMockSetup.Object, TranslationManagerVModel, Logger, serviceUtilities,
DataUtils, CommonService, new VmOwnerReferenceLogic(), CacheManager.TypesCache, LanguageCache, PublishingStatusCache,
VersioningManager, gdService, UserOrganizationChecker);
// Act
Action act = () => service.AddService(new VmOpenApiServiceInVersionBase(), false, DefaultVersion, false);
// Assert
act.ShouldThrowExactly <Exception>(CoreMessages.OpenApi.RelationIdNotFound);
}
public void ModelIsNull()
{
// Arrange
var unitOfWork = unitOfWorkMockSetup.Object;
var contextManager = new TestContextManager(unitOfWork, unitOfWork);
var serviceUtilities = new ServiceUtilities(UserIdentificationMock.Object, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
var service = new ServiceAndChannelService(contextManager, translationManagerMockSetup.Object, translationManagerVModelMockSetup.Object,
Logger, serviceUtilities, DataUtils, ServiceService, ChannelService, PublishingStatusCache, VersioningManager, UserOrganizationChecker,
CacheManager, UserOrganizationService);
// Act
var result = service.SaveServiceConnections(null, DefaultVersion);
// Assert
result.Should().BeNull();
translationManagerVModelMockSetup.Verify(t => t.Translate <V7VmOpenApiServiceAndChannelRelationAstiInBase, Model.Models.Service>(It.IsAny <V7VmOpenApiServiceAndChannelRelationAstiInBase>(), unitOfWork), Times.Never());
}
public void CannotGetUser()
{
// Arrange
var unitOfWork = unitOfWorkMockSetup.Object;
var contextManager = new TestContextManager(unitOfWork, unitOfWork);
UserIdentificationMock.Setup(s => s.UserName).Returns((string)null);
var serviceUtilities = new ServiceUtilities(UserIdentificationMock.Object, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
var service = new ServiceAndChannelService(contextManager, translationManagerMockSetup.Object, translationManagerVModelMockSetup.Object,
Logger, serviceUtilities, DataUtils, ServiceService, ChannelService, PublishingStatusCache, VersioningManager, UserOrganizationChecker,
CacheManager, UserOrganizationService);
// Act
Action act = () => service.SaveServiceConnectionsBySource(null, new V7VmOpenApiServiceAndChannelRelationBySourceAsti(), DefaultVersion);
// Assert
act.ShouldThrowExactly <Exception>(CoreMessages.OpenApi.RelationIdNotFound);
}
public void NoDateDefined()
{
// Arrange
var pageSize = 1;
organizationList = EntityGenerator.GetOrganizationEntityList(1, PublishingStatusCache);
var publishedAndDeletedList = organizationList.Where(e => e.PublishingStatusId == PublishedId && e.LanguageAvailabilities.Any(l => l.StatusId == PublishedId) ||
e.PublishingStatusId == DeletedId || e.PublishingStatusId == OldPublishedId).ToList();
OrganizationRepoMock.Setup(g => g.All()).Returns(organizationList.AsQueryable());
// unitOfWork
unitOfWorkMockSetup.Setup(uw => uw.ApplyIncludes(
It.IsAny <IQueryable <OrganizationVersioned> >(),
It.IsAny <Func <IQueryable <OrganizationVersioned>, IQueryable <OrganizationVersioned> > >(),
It.IsAny <bool>()
)).Returns(publishedAndDeletedList.AsQueryable());
var unitOfWorkMock = unitOfWorkMockSetup.Object;
translationManagerMockSetup.Setup(t => t.TranslateAll <OrganizationVersioned, VmOpenApiOrganizationSaha>(It.IsAny <IList <OrganizationVersioned> >()))
.Returns(new List <VmOpenApiOrganizationSaha> {
new VmOpenApiOrganizationSaha()
});
var contextManager = new TestContextManager(unitOfWorkMock, unitOfWorkMock);
var serviceUtilities = new ServiceUtilities(UserIdentification, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
var service = new DataAccess.Services.OrganizationService(contextManager, translationManagerMockSetup.Object, TranslationManagerVModel, Logger, OrganizationLogic,
serviceUtilities, DataUtils, CommonService, AddressService, PublishingStatusCache, LanguageCache,
VersioningManager, UserOrganizationChecker, CacheManager.TypesCache);
// Act
var result = service.GetOrganizationsSaha(null, 1, pageSize);
// Assert
result.Should().NotBeNull();
result.PageCount.Should().Be(publishedAndDeletedList.Count);
}
public void ChannelIdIsNull()
{
// Arrange
var unitOfWork = unitOfWorkMockSetup.Object;
var contextManager = new TestContextManager(unitOfWork, unitOfWork);
var serviceUtilities = new ServiceUtilities(UserIdentificationMock.Object, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
var service = new ServiceAndChannelService(contextManager, translationManagerMockSetup.Object, translationManagerVModelMockSetup.Object,
Logger, serviceUtilities, DataUtils, ServiceService, ChannelService, PublishingStatusCache, VersioningManager, UserOrganizationChecker,
CacheManager, UserOrganizationService);
// Act
var result = service.SaveServicesAndChannels(new List <V7VmOpenApiServiceServiceChannelAstiInBase> {
new V7VmOpenApiServiceServiceChannelAstiInBase()
});
// Assert
result.Should().NotBeNull();
result.Should().BeOfType <List <string> >();
}
public void RightVersionNotFound(VersionStatusEnum status)
{
// Arrange
var id = Guid.NewGuid();
var unitOfWork = unitOfWorkMockSetup.Object;
var contextManager = new TestContextManager(unitOfWork, unitOfWork);
var serviceUtilities = new ServiceUtilities(UserIdentification, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
VersioningManagerMock.Setup(s => s.GetVersionId <ServiceChannelVersioned>(unitOfWork, id, PublishingStatus.Published, true)).Returns((Guid?)null);
VersioningManagerMock.Setup(s => s.GetVersionId <ServiceChannelVersioned>(unitOfWork, id, null, true)).Returns((Guid?)null);
var service = new ChannelService(contextManager, UserIdentification, translationManagerMockSetup.Object, TranslationManagerVModel,
Logger, ServiceChannelLogic, serviceUtilities, CommonService, new VmListItemLogic(), DataUtils, new VmOwnerReferenceLogic(),
AddressService, CacheManager, PublishingStatusCache, VersioningManager, UserOrganizationChecker, UrlService);
// Act
var result = service.GetServiceChannelById(id, DefaultVersion, status);
// Assert
result.Should().BeNull();
}
public void Add_DraftEntity()
{
// Arrange
var userName = "******";
var list = EntityGenerator.GetServiceEntityList(1, PublishingStatusCache);
var draftEntity = list.Where(i => i.PublishingStatusId == PublishingStatusCache.Get(PublishingStatus.Draft)).FirstOrDefault();
var vm = new VmOpenApiServiceInVersionBase()
{
PublishingStatus = PublishingStatus.Draft.ToString()
};
var unitOfWork = unitOfWorkMockSetup.Object;
var contextManager = new TestContextManager(unitOfWork, unitOfWork);
UserIdentificationMock.Setup(s => s.UserName).Returns(userName);
var serviceUtilities = new ServiceUtilities(UserIdentificationMock.Object, LockingManager, contextManager, UserOrganizationService,
VersioningManager, UserInfoService, UserOrganizationChecker);
CommonServiceMock.Setup(s => s.PublishAllAvailableLanguageVersions <ServiceVersioned, ServiceLanguageAvailability>(draftEntity.Id, It.IsAny <Expression <Func <ServiceLanguageAvailability, bool> > >()))
.Returns(new PublishingResult());
var service = new ServiceService(contextManager, translationManagerMockSetup.Object, translationManagerVModelMockSetup.Object, Logger, serviceUtilities,
DataUtils, CommonService, new VmOwnerReferenceLogic(), CacheManager.TypesCache, LanguageCache, PublishingStatusCache,
VersioningManager, gdService, UserOrganizationChecker);
// Act
var result = service.AddService(vm, false, DefaultVersion, false);
// Assert
result.Should().NotBeNull();
var vmResult = Assert.IsType <V7VmOpenApiService>(result);
vmResult.PublishingStatus.Should().Be(PublishingStatus.Draft.ToString());
translationManagerVModelMockSetup.Verify(x => x.Translate <IVmOpenApiServiceInVersionBase, ServiceVersioned>(It.IsAny <VmOpenApiServiceInVersionBase>(), unitOfWork), Times.Once());
translationManagerMockSetup.Verify(x => x.Translate <ServiceVersioned, VmOpenApiServiceVersionBase>(It.IsAny <ServiceVersioned>()), Times.Once());
CommonServiceMock.Verify(x => x.PublishAllAvailableLanguageVersions <ServiceVersioned, ServiceLanguageAvailability>(_serviceId, It.IsAny <Expression <Func <ServiceLanguageAvailability, bool> > >()), Times.Never());
}
