public async Task ShouldNotFilterOutADotnetRepository()
{
IRepositoryFilter subject = MakeRepositoryFilter();
var result =
await subject.ContainsDotNetProjects(new RepositorySettings { RepositoryName = "sdk", RepositoryOwner = "dotnet" });
Assert.True(result);
}
private IEnumerable <ProductListItemViewModel> GetFilteredCoffees(IRepositoryFilter filter)
{
var coffees = mCoffeeRepository.GetCoffees(filter);
var items = coffees.Select(
coffee => new ProductListItemViewModel(
coffee,
mCalculationService.CalculatePrice(coffee.SKU),
coffee.Product.PublicStatus?.PublicStatusDisplayName));
return(items);
}
private IEnumerable <ProductListItemViewModel> GetFilteredBrewers(IRepositoryFilter filter)
{
var brewers = mBrewerRepository.GetBrewers(filter);
var items = brewers.Select(
brewer => new ProductListItemViewModel(
brewer,
mCalculationService.CalculateListingPrice(brewer.SKU),
brewer.Product.PublicStatus?.PublicStatusDisplayName));
return(items);
}
public GitRepositoryEngine(
IRepositoryUpdater repositoryUpdater,
ICollaborationFactory collaborationFactory,
IFolderFactory folderFactory,
INuKeeperLogger logger,
IRepositoryFilter repositoryFilter)
{
_repositoryUpdater = repositoryUpdater;
_collaborationFactory = collaborationFactory;
_folderFactory = folderFactory;
_logger = logger;
_repositoryFilter = repositoryFilter;
}
public GitHubRepositoryEngine(
IRepositoryUpdater repositoryUpdater,
IForkFinder forkFinder,
IFolderFactory folderFactory,
INuKeeperLogger logger,
IRepositoryFilter repositoryFilter)
{
_repositoryUpdater = repositoryUpdater;
_forkFinder = forkFinder;
_folderFactory = folderFactory;
_logger = logger;
_repositoryFilter = repositoryFilter;
}
public async Task ShouldFilterOutNonDotnetRepository()
{
IRepositoryFilter subject = MakeRepositoryFilter();
var result =
await subject.ContainsDotNetProjects(new RepositorySettings
{
RepositoryName = "jquery",
RepositoryOwner = "jquery"
});
Assert.False(result);
}
/// <summary>
/// Returns an enumerable collection of products.
/// </summary>
/// <param name="filter">Repository filter.</param>
/// <param name="classNames">Class names of products to retrieve.</param>
public IEnumerable <SKUTreeNode> GetProducts(IRepositoryFilter filter, params string[] classNames)
{
return(pageRetriever.Retrieve <TreeNode>(
query => query
.WhereIn("ClassName", classNames)
.Where(filter?.GetWhereCondition())
.WhereTrue("SKUEnabled")
.FilterDuplicates(),
cache => cache
.Key($"{nameof(KenticoProductRepository)}|{nameof(GetProducts)}|{filter?.GetCacheKey()}|{string.Join(";", classNames)}")
.Dependencies((_, builder) => builder.ObjectType("ecommerce.sku")))
.Select(page => page as SKUTreeNode));
}
public IEnumerable <Coffee> GetCoffees(IRepositoryFilter filter, int count = 0)
{
return(CoffeeProvider.GetCoffees()
.LatestVersion(mLatestVersionEnabled)
.Published(!mLatestVersionEnabled)
.OnSite(AppConfig.SiteName)
.Culture(mCultureName)
.CombineWithDefaultCulture()
.TopN(count)
.WhereTrue("SKUEnabled")
.Where(filter?.GetWhereCondition())
.OrderByDescending("SKUInStoreFrom")
.ToList());
}
/// <summary>
/// Returns an enumerable collection of brewers ordered by the date of publication.
/// </summary>
/// <param name="filter">Repository filter.</param>
/// <param name="count">The number of brewers to return. Use 0 as value to return all records.</param>
public IEnumerable <Brewer> GetBrewers(IRepositoryFilter filter, int count = 0)
{
return(pageRetriever.Retrieve <Brewer>(
query => query
.TopN(count)
.WhereTrue("SKUEnabled")
.Where(filter?.GetWhereCondition())
.FilterDuplicates()
.OrderByDescending("SKUInStoreFrom"),
cache => cache
.Key($"{nameof(BrewerRepository)}|{nameof(GetBrewers)}|{filter?.GetCacheKey()}|{count}")
// Include dependency on all pages of this type to flush cache when a new page is created.
.Dependencies((_, builder) => builder.Pages(Brewer.CLASS_NAME).ObjectType("ecommerce.sku"))));
}
public IEnumerable <Brewer> GetBrewers(IRepositoryFilter filter, int count = 0)
{
return(BrewerProvider.GetBrewers()
.LatestVersion(mLatestVersionEnabled)
.Published(!mLatestVersionEnabled)
.OnSite(SiteContext.CurrentSiteName)
.Culture(mCultureName)
.CombineWithDefaultCulture()
.TopN(count)
.WhereTrue("SKUEnabled")
.Where(filter?.GetWhereCondition())
.OrderByDescending("SKUInStoreFrom")
.ToList());
}
public FileAlarmRepository(IFileWatcher watcher, ISharedFileFactory sharedFileFactory, IRepositorySerializer serializer, IRepositoryFilter[] filters, string path)
{
if (watcher == null)
throw new ArgumentNullException("watcher");
if (sharedFileFactory == null)
throw new ArgumentNullException("sharedFileFactory");
if (filters == null)
throw new ArgumentNullException("filters");
if (serializer == null)
throw new ArgumentNullException("serializer");
this.serializer = serializer;
this.sharedFileFactory = sharedFileFactory;
this.filters = filters;
this.path = path;
this.watcher = watcher;
this.watcher.FileChanged += watcher_FileChanged;
}
public EventSourcedRepositoryTests()
{
publishEventBuffer = Substitute.For <IPublishEventBuffer>();
eventStore = Substitute.For <IEventStore>();
entityTypeManager = Substitute.For <IEntityTypeManager>();
repositoryFilter1 = Substitute.For <IRepositoryFilter>();
repositoryFilter2 = Substitute.For <IRepositoryFilter>();
FakeClock.Setup();
eventStore.GetEventsAsync(entity2Id)
.Returns(new List <IEventStoreRecord>()
{
new FakeEventStoreRecord()
{
Event = new SetFooEvent()
{
AggregateId = entity2Id
},
StreamSequenceNumber = 1
}
});
eventStore.GetStreamMetadataAsync(entity2Id)
.Returns(new Dictionary <string, string>()
{
{ "TestKey", "TestValue" },
{ AggregateEventStreamMetadataNames.ClassId, entity2ClassId.ToString() }
});
eventStore.GetStreamMetadataAsync(entity3Id)
.Returns(new Dictionary <string, string>()
{
{ "TestKey", "TestValue" },
{ AggregateEventStreamMetadataNames.ClassId, entity3ClassId.ToString() }
});
eventStore.PushEventsAsync(Guid.Empty, null, null).ReturnsForAnyArgs(ci =>
{
var events = ci.ArgAt <IEnumerable <IUncommittedEventStoreRecord> >(1);
return(events.Select(x => new FakeEventStoreRecord()
{
AdditionalMetadata = x.Metadata,
Event = x.Event,
EventId = Guid.NewGuid(),
StoreDate = DateTimeOffset.Now,
StreamSequenceNumber = 0
}).ToList());
});
DomainClassInfo[] domainClasses = new[]
{
new DomainClassInfo(entityClassId, null, typeof(MyEntity)),
new DomainClassInfo(entity2ClassId, null, typeof(MyEntity2)),
new DomainClassInfo(entity3ClassId, null, typeof(MyEntity3LoadsAsDeleted))
};
entityTypeManager.GetClassInfoByClassId(Guid.Empty)
.ReturnsForAnyArgs(ci => domainClasses.Single(x => x.Id == ci.Arg <Guid>()));
entityTypeManager.TryGetClassInfoByClrType(null)
.ReturnsForAnyArgs(ci => domainClasses.SingleOrDefault(x => x.ClrType == ci.Arg <Type>()));
entityTypeManager.GetClassInfoByClrType(null)
.ReturnsForAnyArgs(ci => domainClasses.Single(x => x.ClrType == ci.Arg <Type>()));
eventMessageFactory = Substitute.For <IEventMessageFactory>();
eventMessageFactory.CreateMessageAsync(null).ReturnsForAnyArgs(ci =>
{
var @event = ci.ArgAt <IEvent>(0);
Type messageType = typeof(EventMessageDraft <>).MakeGenericType(@event.GetType());
IEventMessageDraft messageDraft = (IEventMessageDraft)messageType.GetConstructor(new[] { @event.GetType() }).Invoke(new[] { @event });
messageDraft.SetMetadata("TestKey", "TestValue");
return(messageDraft);
}); // TODO something more lightweight?
sut = new EventSourcedAggregateRepository(eventStore,
entityTypeManager, publishEventBuffer, new IRepositoryFilter[] {}, eventMessageFactory, new EntityFactory());
}
public UseCaseFilter(IRepositoryFilter <T> repo)
{
_repositoryFilter = repo;
}
public static IQueryable <T> SetAclFilter <T>(this IQueryable <T> entities, IRepositoryFilter repository, AccessType accessType)
{
return(repository.SetAclFilter(entities, accessType));
}
public static bool HasAccess <T>(this IEnumerable <T> entity, IRepositoryFilter repository, AccessType accessType)
{
return(repository.HasAccess(entity, accessType));
}
public EventSourcedAggregateStoreTests()
{
publishEventBuffer = Substitute.For <IPublishEventBuffer>();
eventStore = Substitute.For <IEventStore>();
entityTypeManager = Substitute.For <IEntityTypeManager>();
repositoryFilter1 = Substitute.For <IRepositoryFilter>();
repositoryFilter2 = Substitute.For <IRepositoryFilter>();
FakeClock.Setup();
entityEvents = new Dictionary <Guid, List <IEventStoreRecord> >()
{
{
entity2Id,
new List <IEventStoreRecord>()
{
new FakeEventStoreRecord()
{
Event = new SetFooEvent()
{
AggregateId = entity2Id
},
StreamSequenceNumber = 1
}
}
},
{
entity3Id,
new List <IEventStoreRecord>()
{
new FakeEventStoreRecord()
{
Event = new SetFooEvent()
{
AggregateId = entity3Id
},
StreamSequenceNumber = 1
}
}
},
{
entity4Id,
new List <IEventStoreRecord>()
{
new FakeEventStoreRecord()
{
Event = new SetFooEvent()
{
AggregateId = entity4Id
},
StreamSequenceNumber = 1
}
}
}
};
eventStore.FindEventsAsync(Arg.Any <Guid>())
.Returns(ci =>
{
var id = ci.ArgAt <Guid>(0);
if (entityEvents.TryGetValue(id, out var events))
{
return(events);
}
return(new List <IEventStoreRecord>());
});
eventStore.BatchFindEventsAsync(Arg.Any <Guid[]>())
.Returns(ci =>
{
var ids = ci.ArgAt <Guid[]>(0);
var result = new Dictionary <Guid, IReadOnlyCollection <IEventStoreRecord> >();
foreach (Guid id in ids)
{
if (entityEvents.TryGetValue(id, out var events))
{
result.Add(id, events);
}
}
return(result);
});
entityMetadata = new Dictionary <Guid, IReadOnlyDictionary <string, string> >()
{
{
entity2Id,
new Dictionary <string, string>()
{
{ "TestKey", "TestValue" },
{ AggregateEventStreamMetadataNames.ClassId, entity2ClassId.ToString() }
}
},
{
entity3Id,
new Dictionary <string, string>()
{
{ "TestKey", "TestValue" },
{ AggregateEventStreamMetadataNames.ClassId, entity3ClassId.ToString() }
}
},
{
entity4Id,
new Dictionary <string, string>()
{
{ "TestKey", "TestValue" },
{ AggregateEventStreamMetadataNames.ClassId, entity2ClassId.ToString() }
}
}
};
eventStore.FindStreamMetadataAsync(Arg.Any <Guid>())
.Returns(ci =>
{
var id = ci.ArgAt <Guid>(0);
if (entityMetadata.TryGetValue(id, out var metadata))
{
return(metadata);
}
return(new Dictionary <string, string>());
});
eventStore.BatchFindStreamMetadataAsync(Arg.Any <Guid[]>())
.Returns(ci =>
{
var ids = ci.ArgAt <Guid[]>(0);
var result = new Dictionary <Guid, IReadOnlyDictionary <string, string> >();
foreach (Guid id in ids)
{
if (entityMetadata.TryGetValue(id, out var metadata))
{
result.Add(id, metadata);
}
}
return(result);
});
eventStore.PushEventsAsync(Guid.Empty, null).ReturnsForAnyArgs(ci =>
{
var events = ci.ArgAt <IEnumerable <IUncommittedEventStoreRecord> >(1);
return(events.Select(x => new FakeEventStoreRecord()
{
AdditionalMetadata = x.Metadata,
Event = x.Event,
EventId = Guid.NewGuid(),
StoreDate = DateTimeOffset.Now,
StreamSequenceNumber = 0
}).ToList());
});
DomainClassInfo[] domainClasses = new[]
{
new DomainClassInfo(entityClassId, null, typeof(MyEntity)),
new DomainClassInfo(entity2ClassId, null, typeof(MyEntity2)),
new DomainClassInfo(entity3ClassId, null, typeof(MyEntity3LoadsAsDeleted))
};
entityTypeManager.GetClassInfoByClassId(Guid.Empty)
.ReturnsForAnyArgs(ci => domainClasses.Single(x => x.Id == ci.Arg <Guid>()));
entityTypeManager.TryGetClassInfoByClrType(null)
.ReturnsForAnyArgs(ci => domainClasses.SingleOrDefault(x => x.ClrType == ci.Arg <Type>()));
entityTypeManager.GetClassInfoByClrType(null)
.ReturnsForAnyArgs(ci => domainClasses.Single(x => x.ClrType == ci.Arg <Type>()));
eventMessageFactory = Substitute.For <IEventMessageFactory>();
eventMessageFactory.CreateMessageAsync(null).ReturnsForAnyArgs(ci =>
{
var @event = ci.ArgAt <IEvent>(0);
Type messageType = typeof(EventMessageDraft <>).MakeGenericType(@event.GetType());
IEventMessageDraft messageDraft = (IEventMessageDraft)messageType.GetConstructor(new[] { @event.GetType() }).Invoke(new[] { @event });
messageDraft.SetMetadata("TestKey", "TestValue");
return(messageDraft);
}); // TODO something more lightweight?
eventSourcedAggregateFactory = Substitute.For <IEventSourcedAggregateFactory>();
entity2 = new MyEntity2(entity2Id);
eventSourcedAggregateFactory.ConstructAndLoadEntityFromEvents(entity2Id,
Arg.Is <IReadOnlyDictionary <string, string> >(x => x.SequenceEqual(entityMetadata[entity2Id])),
Arg.Is <IReadOnlyCollection <IEventStoreRecord> >(x => x.SequenceEqual(entityEvents[entity2Id])))
.Returns(entity2);
entity3 = new MyEntity3LoadsAsDeleted(entity3Id);
eventSourcedAggregateFactory.ConstructAndLoadEntityFromEvents(entity3Id,
Arg.Is <IReadOnlyDictionary <string, string> >(x => x.SequenceEqual(entityMetadata[entity3Id])),
Arg.Is <IReadOnlyCollection <IEventStoreRecord> >(x => x.SequenceEqual(entityEvents[entity3Id])))
.Returns(entity3);
entity4 = new MyEntity2(entity4Id);
eventSourcedAggregateFactory.ConstructAndLoadEntityFromEvents(entity4Id,
Arg.Is <IReadOnlyDictionary <string, string> >(x => x.SequenceEqual(entityMetadata[entity4Id])),
Arg.Is <IReadOnlyCollection <IEventStoreRecord> >(x => x.SequenceEqual(entityEvents[entity4Id])))
.Returns(entity4);
sut = new EventSourcedAggregateStore(eventStore, entityTypeManager, publishEventBuffer,
new IRepositoryFilter[] { }, eventMessageFactory, eventSourcedAggregateFactory);
}
