public void PostResourceTest()
{
GetResourceTest();
ITypedPool target = CreateITransientCachier();
target.Post(_dependentModel.Key, _singleModel);
var actModel = target.Get <Model>(_dependentModel.Key);
Assert.AreEqual(_singleModel.Key, actModel.Key);
Assert.AreEqual(_singleModel.Name, actModel.Name);
target.Post <Model>(_dependentModel.Key, null);
actModel = target.Get <Model>(_dependentModel.Key);
Assert.AreEqual(null, actModel);
target.Post(_dependentElement.Key, _singleElement);
var actElement = target.Get <Element>(_dependentElement.Key);
Assert.AreEqual(_singleElement.Key, actElement.Key);
Assert.AreEqual(_singleElement.Name, actElement.Name);
target.Post <Element>(_dependentElement.Key, null);
actElement = target.Get <Element>(_dependentElement.Key);
Assert.AreEqual(null, actElement);
target.Post <Element>(_dependentElement.Key, null);//удаление отсуствующего ключа должно работать без ошибок
target.Post(_dependentElement.Key, _dependentElement);
target.Post(_dependentModel.Key, _dependentModel);
GetResourceTest();
}
public void Prepare()
{
container = new CompositionContainer(
new AggregateCatalog(
new AssemblyCatalog(
typeof (ITypedPool).Assembly
),
new TypeCatalog(typeof (Registrator)),
new TypeCatalog(typeof(ResourcePool)),
new TypeCatalog(typeof (NotifiedElementGetter)),
new TypeCatalog(typeof (UnnotifiedElementGetter)),
new TypeCatalog(typeof (NotifiedElementPoster)),
new TypeCatalog(typeof (UnnotifiedElementPoster))));
_uplink = _mockRepository.DynamicMock<AnnouncerUplink>();
_downlink = _mockRepository.DynamicMock<AnnouncerDownlink>();
_downlink.Expect(k => k.Subscribe(null))
.IgnoreArguments()
.Repeat.Once();
_downlink.Replay();
container.ComposeExportedValue(_uplink);
container.ComposeExportedValue(_downlink);
var service = container.GetExportedValue<ICacheServicing>();
service.Initialize(new Settings
{
AutoSubscription = (TestContext.Properties["AutoSubscription"] as string)== "true"
}, container);
_pool = container.GetExportedValue<ITypedPool>();
_subscriptor = container.GetExportedValue<IAnnouncerSubscriptor>();
}
public void Preparation()
{
_container = MockHelper.InitializeContainer(AssembliesWhichShouldProvideExport, new Type[0]);
_model1 = new Model {
Element = Guid.Empty, Key = Guid.NewGuid(), Name = "M1"
};
_model2 = new Model {
Element = Guid.Empty, Key = Guid.NewGuid(), Name = "M2"
};
_e1 = new Element {
Key = Guid.NewGuid(), Model = _model1.Key, Name = "El1"
};
_e2 = new Element {
Key = Guid.NewGuid(), Model = _model1.Key, Name = "El2"
};
_e3 = new Element {
Key = Guid.NewGuid(), Model = _model2.Key, Name = "El3"
};
var pool = new ResourcePool();
pool.Models.Add(_model1.Key, _model1);
pool.Models.Add(_model2.Key, _model2);
pool.Elements.Add(_e1.Key, _e1);
pool.Elements.Add(_e2.Key, _e2);
pool.Elements.Add(_e3.Key, _e3);
_container.ComposeExportedValue(pool);
_container.ComposeExportedValue(_container);
Settings.NoCacheGarbageChecking = true;
_pool = _container.GetExportedValue <ITypedPool>();
}
public void Preparation()
{
_container =
new CompositionContainer(new AggregateCatalog(AssembliesWhichShouldProvideExport.Select(k => new AssemblyCatalog(k))));
_singleModel = new Model {
Element = Guid.Empty, Key = Guid.NewGuid(), Name = "SingleModel"
};
_singleElement = new Element()
{
Model = Guid.Empty, Key = Guid.NewGuid(), Name = "SingleElement"
};
_dependentModel = new Model {
Element = Guid.NewGuid(), Key = Guid.NewGuid(), Name = "DepModel"
};
_dependentElement = new Element()
{
Model = _dependentModel.Key, Key = _dependentModel.Element, Name = "DepElement"
};
var pool = new ResourcePool();
pool.Models.Add(_singleModel.Key, _singleModel);
pool.Models.Add(_dependentModel.Key, _dependentModel);
pool.Elements.Add(_singleElement.Key, _singleElement);
pool.Elements.Add(_dependentElement.Key, _dependentElement);
_container.ComposeExportedValue(pool);
_container.ComposeExportedValue(_container);
Settings.NoCacheGarbageChecking = true;
_cachier = _container.GetExportedValue <ITypedPool>();
}
public static IEnumerable <Guid> Get <TResource, TLink>(this ITypedPool cachier, Guid id) where TResource : class
{
var query = cachier.Spec;
query[(cachier as IGenericPool).GetNameByType(typeof(TLink))] = id;
return(cachier.Find <TResource>(query as object));
}
public void Initialize()
{
_container = new CompositionContainer(
new AggregateCatalog(
new AssemblyCatalog(
typeof(ITypedPool).Assembly
),
new TypeCatalog(typeof(Registrator)),
new TypeCatalog(typeof(ResourcePool)),
new TypeCatalog(typeof(NotifiedElementQuerier)),
new TypeCatalog(typeof(QueryProcess)),
new TypeCatalog(typeof(UnnotifiedElementGetter)),
new TypeCatalog(typeof(UnnotifiedElementPoster))));
_poster = _mockRepository.DynamicMock <NotifiedElementPoster>();
_getter = _mockRepository.DynamicMock <ProxyElemGetter>();
_getter.StatChannel = _container.GetExportedValue <IStatChannel>();
_posterFactory = _mockRepository.DynamicMock <IPacketResourcePoster>();
_container.ComposeExportedValue <ResourcePoster>(_poster);
_container.ComposeExportedValue <ResourceGetter>(_getter);
_container.ComposeExportedValue(_posterFactory);
var service = _container.GetExportedValue <ICacheServicing>();
service.Initialize(new Settings(), _container);
_pool = _container.GetExportedValue <ITypedPool>();
}
public void Initialize()
{
container = new CompositionContainer(
new AggregateCatalog(
new AssemblyCatalog(
typeof(ITypedPool).Assembly
),
new TypeCatalog(typeof(Registrator)),
new TypeCatalog(typeof(ResourcePool)),
new TypeCatalog(typeof(NotifiedElementGetter)),
new TypeCatalog(typeof(NotifiedElementPoster)),
new TypeCatalog(typeof(UnnotifiedElementGetter)),
new TypeCatalog(typeof(UnnotifiedElementPoster))));
_uplink = _mockRepository.DynamicMock <AnnouncerUplink>();
_downlink = _mockRepository.DynamicMock <AnnouncerDownlink>();
_downlink.Expect(k => k.Subscribe(null))
.IgnoreArguments()
.Repeat.Once();
_downlink.Replay();
container.ComposeExportedValue(_uplink);
container.ComposeExportedValue(_downlink);
//_poster = _mockRepository.DynamicMock<NotifiedElementPoster>();
//_posterFactory = _mockRepository.DynamicMock<IPacketResourcePoster>();
// container.ComposeExportedValue<ResourcePoster>(_poster);
container.ComposeExportedValue(_posterFactory);
_pool = container.GetExportedValue <ITypedPool>();
_subscriptor = container.GetExportedValue <IAnnouncerSubscriptor>();
var service = container.GetExportedValue <ICacheServicing>();
service.Initialize(new Settings
{
}, container);
}
public void Prepare()
{
container = new CompositionContainer(
new AggregateCatalog(
new AssemblyCatalog(
typeof(ITypedPool).Assembly
),
new TypeCatalog(typeof(Registrator)),
new TypeCatalog(typeof(ResourcePool)),
new TypeCatalog(typeof(NotifiedElementGetter)),
new TypeCatalog(typeof(UnnotifiedElementGetter)),
new TypeCatalog(typeof(NotifiedElementPoster)),
new TypeCatalog(typeof(UnnotifiedElementPoster))));
_uplink = _mockRepository.DynamicMock <AnnouncerUplink>();
_downlink = _mockRepository.DynamicMock <AnnouncerDownlink>();
_downlink.Expect(k => k.Subscribe(null))
.IgnoreArguments()
.Repeat.Once();
_downlink.Replay();
container.ComposeExportedValue(_uplink);
container.ComposeExportedValue(_downlink);
var service = container.GetExportedValue <ICacheServicing>();
service.Initialize(new Settings
{
AutoSubscription = (TestContext.Properties["AutoSubscription"] as string) == "true"
}, container);
_pool = container.GetExportedValue <ITypedPool>();
_subscriptor = container.GetExportedValue <IAnnouncerSubscriptor>();
}
/// <summary>
///A test for Get
///</summary>
public void GetResourceTestByQueryHelper <T>()
where T : class
{
ITypedPool target = CreateITransientCachier();
if (typeof(T) == typeof(Model))
{
var expectedModel = _dependentModel.Key;
var actualModel = target.Query <Model>(new UriQuery {
{ "Element", _dependentElement.Name }
}).First();
Assert.AreNotSame(expectedModel, actualModel);
Assert.AreEqual(expectedModel, actualModel);
var nolModels = target.Query <Model>(new UriQuery {
{ "Element", _singleElement.Name }
});
Assert.IsTrue(!nolModels.Any());
try
{
var res = target.Query <Model>(new UriQuery("default=true"));
Assert.IsTrue(res.Count() == 1);
}
catch (InvalidOperationException)
{
}
}
if (typeof(T) == typeof(Element))
{
var expectedElement = _dependentElement.Key;
var actualElement = target.Query <Element>(new UriQuery {
{ "modelName", _dependentModel.Name }
}).First();
Assert.AreNotSame(expectedElement, actualElement);
Assert.AreEqual(expectedElement, actualElement);
var actualElements = target.Query <Element>(
new UriQuery {
{ "ElementName", _dependentElement.Name },
{ "Model", _dependentModel.Key.ToString() }
}).ToArray();
Assert.AreEqual(1, actualElements.Count());
Assert.AreEqual(expectedElement, actualElements[0]);
var nolElements = target.Query <Element>(new UriQuery {
{ "modelName", _singleModel.Name }
});
Assert.IsTrue(!nolElements.Any());
var emptyKey = target.Query <Element>(new UriQuery("badquery=true"));
Assert.AreEqual(Guid.Empty, emptyKey.First());
}
}
public void GetResourceTestByArgsHelper <T>() where T : class
{
ITypedPool target = CreateITransientCachier();
if (typeof(T) == typeof(Model))
{
var expectedModel = _dependentModel.Key;
object q = target.Spec(Element: _dependentElement.Name);
var t = target.Find <Model>(q);
var actualModel = t.First();
Assert.AreNotSame(expectedModel, actualModel);
Assert.AreEqual(expectedModel, actualModel);
q = target.Spec(Element: _singleElement.Name);
var nolModels = target.Find <Model>(q);
Assert.IsTrue(!nolModels.Any());
try
{
q = target.Spec(Default: true);
var res = target.Find <Model>(q);
Assert.IsTrue(res.Count() == 1);
}
catch (InvalidOperationException)
{
}
}
if (typeof(T) == typeof(Element))
{
var expectedElement = _dependentElement.Key;
object query = target.Spec(modelName: _dependentModel.Name);
var actualElement = target.Find <Element>(query).First();
Assert.AreNotSame(expectedElement, actualElement);
Assert.AreEqual(expectedElement, actualElement);
dynamic dquery = target.Spec(ModelName: _dependentModel.Name);
dquery.ModelId = _singleModel.Key;
var actualElements = target.Find <Element>(query).ToArray();
Assert.AreEqual(1, actualElements.Count());
Assert.AreEqual(expectedElement, actualElements[0]);
query = target.Spec(modelName: _singleModel.Name);
var nolElements = target.Find <Element>(query);
Assert.IsTrue(!nolElements.Any());
query = target.Spec(badquery: true);
var emptyKey = target.Find <Element>(query);
Assert.AreEqual(Guid.Empty, emptyKey.First());
}
}
public void Preparation()
{
_container = MockHelper.InitializeContainer(AssembliesWhichShouldProvideExport, new Type[0]);
_model1 = new Model { Element = Guid.Empty, Key = Guid.NewGuid(), Name = "M1" };
_model2 = new Model { Element = Guid.Empty, Key = Guid.NewGuid(), Name = "M2" };
_e1 = new Element {Key = Guid.NewGuid(), Model = _model1.Key, Name = "El1"};
_e2 = new Element { Key = Guid.NewGuid(), Model = _model1.Key, Name = "El2" };
_e3 = new Element { Key = Guid.NewGuid(), Model = _model2.Key, Name = "El3" };
var pool = new ResourcePool();
pool.Models.Add(_model1.Key, _model1);
pool.Models.Add(_model2.Key, _model2);
pool.Elements.Add(_e1.Key, _e1);
pool.Elements.Add(_e2.Key, _e2);
pool.Elements.Add(_e3.Key, _e3);
_container.ComposeExportedValue(pool);
_container.ComposeExportedValue(_container);
Settings.NoCacheGarbageChecking = true;
_pool = _container.GetExportedValue<ITypedPool>();
}
public Getter(ITypedPool pool, TimeSpan callDelay)
{
_callDelay = callDelay;
_pool = pool;
}
public static IEnumerable <T> FindFilled <T>(this ITypedPool cachier, object query) where T : class
{
return(cachier.Get <T>(cachier.Find <T>(query)));
}
public static IEnumerable <T> QueryFilled <T>(this ITypedPool cachier, UriQuery query) where T : class
{
return(cachier.Get <T>(cachier.Query <T>(query)));
}
public static IEnumerable <T> Get <T>(this ITypedPool cachier, IEnumerable <Guid> ids) where T : class
{
return(ids.Select(cachier.GetLater <T>).ToArray().Select(k => k.Value).ToArray());
}
public static T GetOneDependent <T>(this ITypedPool cachier, UriQuery query) where T : class
{
return(cachier.Query <T>(query).SingleOrDefault().ByDefault(cachier.Get <T>, null));
}
public static IEnumerable <TResource> GetFilled <TResource, TLink>(this ITypedPool cachier, Guid id) where TResource : class
{
return(cachier.Get <TResource>(cachier.Get <TResource, TLink>(id)));
}
internal void SetCache(ITypedPool cache)
{
Cachier = cache;
}
internal void SetCache(ITypedPool cache)
{
Cachier = cache;
}
public void Initialize()
{
container = new CompositionContainer(
new AggregateCatalog(
new AssemblyCatalog(
typeof (ITypedPool).Assembly
),
new TypeCatalog(typeof (Registrator)),
new TypeCatalog(typeof (ResourcePool)),
new TypeCatalog(typeof (NotifiedElementGetter)),
new TypeCatalog(typeof(NotifiedElementPoster)),
new TypeCatalog(typeof (UnnotifiedElementGetter)),
new TypeCatalog(typeof (UnnotifiedElementPoster))));
_uplink = _mockRepository.DynamicMock<AnnouncerUplink>();
_downlink = _mockRepository.DynamicMock<AnnouncerDownlink>();
_downlink.Expect(k => k.Subscribe(null))
.IgnoreArguments()
.Repeat.Once();
_downlink.Replay();
container.ComposeExportedValue(_uplink);
container.ComposeExportedValue(_downlink);
//_poster = _mockRepository.DynamicMock<NotifiedElementPoster>();
//_posterFactory = _mockRepository.DynamicMock<IPacketResourcePoster>();
// container.ComposeExportedValue<ResourcePoster>(_poster);
container.ComposeExportedValue(_posterFactory);
_pool = container.GetExportedValue<ITypedPool>();
_subscriptor = container.GetExportedValue<IAnnouncerSubscriptor>();
var service = container.GetExportedValue<ICacheServicing>();
service.Initialize(new Settings
{
}, container);
}
public static IEnumerable <T> GetFilled <T>(this ITypedPool cachier, Func <IEnumerable <Guid> > query) where T : class
{
return(cachier.Get <T>(query()));
}
public Poster(ITypedPool pool, TimeSpan callDelay)
{
_pool = pool;
_callDelay = callDelay;
}
public void Preparation()
{
_container =
new CompositionContainer(new AggregateCatalog(AssembliesWhichShouldProvideExport.Select(k=>new AssemblyCatalog(k))));
_singleModel = new Model { Element = Guid.Empty, Key = Guid.NewGuid(), Name = "SingleModel" };
_singleElement = new Element() { Model = Guid.Empty, Key = Guid.NewGuid(), Name = "SingleElement" };
_dependentModel = new Model { Element = Guid.NewGuid(), Key = Guid.NewGuid(), Name = "DepModel" };
_dependentElement = new Element() { Model = _dependentModel.Key, Key = _dependentModel.Element, Name = "DepElement" };
var pool = new ResourcePool();
pool.Models.Add(_singleModel.Key, _singleModel);
pool.Models.Add(_dependentModel.Key, _dependentModel);
pool.Elements.Add(_singleElement.Key, _singleElement);
pool.Elements.Add(_dependentElement.Key, _dependentElement);
_container.ComposeExportedValue(pool);
_container.ComposeExportedValue(_container);
Settings.NoCacheGarbageChecking = true;
_cachier = _container.GetExportedValue<ITypedPool>();
}
