void IOrginator.SetMemento(IMemento memento) { var bankCardMemento = (BankCardMemento)memento; Id = bankCardMemento.Id; _accountId = bankCardMemento.AccountId; _disabled = bankCardMemento.Disabled; }
public void MakeBackup(IMemento memento) { Console.WriteLine("-------------Saving state--------------------"); memento.getGameState().DescribeGame(); Console.WriteLine("---------------------------------------------"); mementos.Add(memento); }
public void Restore(IMemento memento) { if (memento is EditorMemento m) { state = m.GetState(); } }
public void Apply(float interpolationFactor, bool isNewFrame, IMemento nextFrame) { Hero target = (Hero)Target; if (nextFrame != null) { float thisInterp = 1 - interpolationFactor; float nextInterp = interpolationFactor; HeroMemento next = (HeroMemento)nextFrame; if (teleportedThisFrame) { target.position = position; } else { target.position = position * thisInterp + next.position * nextInterp; } } else { target.position = position; } if (alive) { if (!target.Alive) { target.revive(); } target.health = health; } target.direction = direction; target.rotation = rotation; }
public async Task Find_restores_aggregate_using_memento_if_found() { // Arrange var user = fixture.Create <FakeUser>(); IMemento memento = user.SaveToMemento(); user.ChangeUsername(fixture.Create("username")); Mock.Get(mementoStore) .Setup(x => x.Find <FakeUser>(user.Id, CancellationToken.None)) .ReturnsAsync(memento); Mock.Get(eventStore) .Setup( x => x.LoadEvents <FakeUser>(user.Id, 1, CancellationToken.None)) .ReturnsAsync(user.PendingEvents.Skip(1)) .Verifiable(); // Act FakeUser actual = await sut.Find(user.Id, CancellationToken.None); // Assert Mock.Get(eventStore).Verify(); actual.ShouldBeEquivalentTo( user, opts => opts.Excluding(x => x.PendingEvents)); }
void IEventSource.RestoreSnapshot(IMemento memento) { RestoreSnapshot(memento); Id = memento.Id; _version = memento.Version; }
public TestOriginatorEntity(Guid id, IMemento memento, IEnumerable <IVersionedEvent> history) { this.Events = new List <IVersionedEvent>(); this.Memento = memento; this.History = history; this.Id = id; }
public override void ReadExternal(IMemento memento, ExternalizeContext context) { base.ReadExternal(memento, context); SourceDecoration = memento.ReadExternalizable("SourceDecoration") as IEdgeDecoration; TargetDecoration = memento.ReadExternalizable("TargetDecoration") as IEdgeDecoration; }
protected TEntity RestoreEntity <TEntity>(IMemento memento) where TEntity : class, IEntity { IEntity entity = ActivatorHelper.CreateInstanceUsingNonPublicConstructor <TEntity>(this, memento.Identity); entity.RestoreSnapshot(memento); return((TEntity)entity); }
public IAggregate Build(Type type, Guid id, IMemento snapshot) { ConstructorInfo constructor = type.GetConstructor( BindingFlags.NonPublic | BindingFlags.Instance, null, new[] { typeof(Guid) }, null); return constructor.Invoke(new object[] { id }) as IAggregate; }
public IAggregate Build(Type type, Guid id, IMemento snapshot) { //if (type == typeof(IMyInterface)) // return new MyAggregate(); //else return Activator.CreateInstance(type) as IAggregate; }
public override void ReadExternal(IMemento memento, ExternalizeContext context) { base.ReadExternal(memento, context); _angle = memento.ReadFloat("Angle"); _isFlippedHorizontal = memento.ReadBool("IsFlippedHorizontal"); _isFlippedVertical = memento.ReadBool("IsFlippedVertical"); }
public void ReadExternal(IMemento memento, ExternalizeContext context) { _saveTo = memento.ReadSerializable("ExternalizableProxy.SaveTo") as Action <T, IMemento, ExternalizeContext>; _loadFrom = memento.ReadSerializable("ExternalizableProxy.LoadFrom") as Func <IMemento, ExternalizeContext, T>; _real = _loadFrom(memento, context); }
private async Task SaveMemento( Guid sourceId, IMemento memento, CancellationToken cancellationToken) { using (MementoStoreDbContext context = _dbContextFactory.Invoke()) { Memento entity = await context .Mementoes .Where(m => m.AggregateId == sourceId) .SingleOrDefaultAsync(cancellationToken) .ConfigureAwait(false); if (entity == null) { entity = new Memento { AggregateId = sourceId }; context.Mementoes.Add(entity); } entity.MementoJson = _serializer.Serialize(memento); await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false); } }
// ======================================== // method // ======================================== // === IPersistable ========== public override void WriteExternal(IMemento memento, ExternalizeContext context) { base.WriteExternal(memento, context); memento.WriteFloat("Angle", _angle); memento.WriteBool("IsFlippedHorizontal", _isFlippedHorizontal); memento.WriteBool("IsFlippedVertical", _isFlippedVertical); }
/// <summary> /// 加载 /// </summary> public override void LoadState(IMemento memento) { SectorBarDesps.Clear(); for (int Index = 0; Index < memento.ChildCount; Index++) { IMemento childMemento = memento.GetChild(Index); String sectorBarType = childMemento.GetString("BarType") ?? String.Empty; if (String.IsNullOrEmpty(sectorBarType)) { continue; } else { List <SectorBarButtonDescription> btnDesp = new List <SectorBarButtonDescription>(); for (int subIndex = 0; subIndex < childMemento.ChildCount; subIndex++) { IMemento subChild = childMemento.GetChild(subIndex); SectorBarButtonDescription barBtn = new SectorBarButtonDescription(); barBtn.LoadState(subChild); btnDesp.Add(barBtn); } SectorBarDesps[sectorBarType] = btnDesp; } } }
/// <summary> /// 加载 /// </summary> public override void LoadState(IMemento memento) { Name = memento.GetString("Name"); Text = memento.GetString("Text"); RefSector = memento.GetString("RefSector"); String typeInfo = memento.GetString("MenuBoxItemType"); Assembly assembly = LoadAssembly(typeInfo.Split(',')[1]); MenuBoxItemType = assembly.GetType(typeInfo.Split(',')[0]); SectorList.Clear(); for (int Index = 0; Index < memento.ChildCount; Index++) { IMemento childMemento = memento.GetChild(Index); MenuListItem menuListItem = new MenuListItem(); menuListItem.LoadState(childMemento); //确保只有一个是选中状态 if (menuListItem.IsChecked) { foreach (MenuListItem item in SectorList) { item.IsChecked = false; } } SectorList.Add(menuListItem); } }
public void ApplyMemento(IMemento memento) { if (memento == null) { throw new ArgumentNullException("memento"); } TextBoxMemento textBoxMemento; try { textBoxMemento = (TextBoxMemento)memento; } catch (InvalidCastException ex) { throw new IncompatibleMementoException( string.Format( "Only memento of type [{0}] be applied to [{1}] ", memento.GetType(), GetType()), ex); } Text = textBoxMemento.Text; MoveCaretTo(textBoxMemento.CaretPostition); Select(textBoxMemento.Selection); }
public IAggregate Build(Type type, Guid id, IMemento snapshot) { ConstructorInfo constructor = type.GetConstructor( BindingFlags.NonPublic | BindingFlags.Instance, null, new[] { typeof(Guid) }, null); return(constructor.Invoke(new object[] { id }) as IAggregate); }
public void Apply(float interpolationFactor, bool isNewFrame, IMemento nextFrame) { Level target = (Level)Target; if (isNewFrame) //only apply frame if it's for the first time, ignore intermediate interpolations { target.enemyGrid = enemyGrid; for (int i = 0; i < target.drilledWalls.Count; i++) { Point p = target.drilledWalls[i]; if (!drilledWalls.Contains(p)) { target.undrillWall(p.X, p.Y); i--; } } } for (int i = 0; i < enemyMementos.Length; i++) { IMemento nextEnemyFrame = null; if (nextFrame != null) { nextEnemyFrame = ((LevelMemento)nextFrame).enemyMementos[i]; } enemyMementos[i].Apply(interpolationFactor, isNewFrame, nextEnemyFrame); } }
void ITimeBody.RestoreMemento(IMemento o) { var memento = (Memento)o; moveSpeed = memento.MoveSpeed; score = memento.Score; }
static void Main(string[] args) { Deck deck = new Deck(); // Save initial deck Console.WriteLine("Saving..."); IMemento memento = deck.Memento; // Shuffle deck and print deck.Shuffle(); foreach (Card card in deck) { Console.Write($"{card} "); } Console.WriteLine(); // Restore initial deck and print Console.WriteLine("Restoring..."); deck.Memento = memento; foreach (Card card in deck) { Console.Write($"{card} "); } Console.WriteLine(); }
public void Save() { // ToDo IMemento memento = StockValue.Save(); Mementos.Add(memento); }
public void TestMethod() { Originator ori = new Originator(); Console.WriteLine(ori.Current.X + " " + ori.Current.Y); IMemento <Position> m1 = ori.Memento; ori.DecreaseX(); ori.IncreaseY(); Console.WriteLine(ori.Current.X + " " + ori.Current.Y); Console.WriteLine(m1.State.X + " " + m1.State.Y); IMemento <Position> m2 = ori.Memento; Console.WriteLine(m2.State.X + " " + m2.State.Y); ori.Memento = m1; Console.WriteLine(ori.Current.X + " " + ori.Current.Y); CareTaker <Position> care = new CareTaker <Position>(); care.Push(ori.Memento); Console.ReadLine(); }
public void Undo(GameOriginator gameOriginator) { IMemento lastMemento = mementos.Last(); mementos.Remove(lastMemento); gameOriginator.RestoreGame(lastMemento); }
private async Task <T> PublishAndRestore( Guid sourceId, CancellationToken cancellationToken) { await _eventPublisher .PublishPendingEvents <T>(sourceId, cancellationToken) .ConfigureAwait(false); IMemento memento = null; if (_mementoStore != null && _mementoEntityFactory != null) { memento = await _mementoStore .Find <T>(sourceId, cancellationToken) .ConfigureAwait(false); } IEnumerable <IDomainEvent> domainEvents = await _eventStore .LoadEvents <T>(sourceId, memento?.Version ?? 0, cancellationToken) .ConfigureAwait(false); return (memento == null ? domainEvents.Any() ? _entityFactory.Invoke(sourceId, domainEvents) : default(T) : _mementoEntityFactory.Invoke(sourceId, memento, domainEvents)); }
// ======================================== // method // ======================================== // === IPersistable ========== public override void WriteExternal(IMemento memento, ExternalizeContext context) { base.WriteExternal(memento, context); memento.WriteExternalizable("SourceDecoration", _sourceDecoration); memento.WriteExternalizable("TargetDecoration", _targetDecoration); }
public void Apply(float interpolationFactor, bool isNewFrame, IMemento nextFrame) { Enemy target = (Enemy)Target; if (nextFrame != null) { float thisInterp = 1 - interpolationFactor; float nextInterp = interpolationFactor; EnemyMemento next = (EnemyMemento)nextFrame; target.position = position * thisInterp + next.position * nextInterp; deathEmitterMemento.Apply(interpolationFactor, isNewFrame, ((EnemyMemento)nextFrame).deathEmitterMemento); } else { target.position = position; deathEmitterMemento.Apply(interpolationFactor, isNewFrame, null); } target.state = state; target.targetedAI.Target = AItarget; target.health = health; target.direction = direction; target.rotation = rotation; target.dying = dying; target.maskingColor = Color.Lerp(Color.Black, Color.White, health / STARTING_HEALTH); }
public async Task Find_restores_aggregate_using_memento_if_found() { // Arrange var user = new FakeUser(id: Guid.NewGuid(), username: Guid.NewGuid().ToString()); IMemento memento = user.SaveToMemento(); user.ChangeUsername(username: Guid.NewGuid().ToString()); IMementoStore mementoStore = Mock.Of <IMementoStore>(); Mock.Get(mementoStore) .Setup(x => x.Find <FakeUser>(user.Id, default)) .ReturnsAsync(memento); ISqlEventStore eventStore = Mock.Of <ISqlEventStore>(); Mock.Get(eventStore) .Setup(x => x.LoadEvents <FakeUser>(user.Id, 1, default)) .ReturnsAsync(user.FlushPendingEvents().Skip(1)) .Verifiable(); var sut = new SqlEventSourcedRepository <FakeUser>( eventStore, Mock.Of <ISqlEventPublisher>(), mementoStore, FakeUser.Factory, FakeUser.Factory); // Act FakeUser actual = await sut.Find(user.Id, default); // Assert Mock.Get(eventStore).Verify(); actual.ShouldBeEquivalentTo(user); }
private async Task <T> RehydrateWithMemento(Guid sourceId, IMemento memento, CancellationToken cancellationToken) { IEnumerable <IDomainEvent> domainEvents = await _eventStore.LoadEvents <T>(sourceId, memento.Version, cancellationToken).ConfigureAwait(false); return(_mementoEntityFactory.Invoke(sourceId, memento, domainEvents)); }
public void RestoreTest_Simple() { // Create a type var testStructType = registry.CreateType(UTinyId.New(), "TestStructType", UTinyTypeCode.Struct); var testRef = (UTinyType.Reference)testStructType; IMemento initialState = null; // Register for changed events caretaker.OnObjectChanged += (originator, memento) => { initialState = memento; }; // Update to get the initial state; flush changes caretaker.Update(); Assert.NotNull(initialState); { // Make some changes to the created type testStructType.Name = "OtherTestStructType"; Assert.AreEqual(testStructType.Name, "OtherTestStructType"); // revert them testStructType.Restore(initialState); testStructType = testRef.Dereference(context.Registry); Assert.NotNull(testStructType); Assert.AreEqual(testStructType.Name, "TestStructType"); } }
/// <summary> /// Initializes a new instance of the CommandContext class. /// </summary> /// <param name="game">Command context's IGame.</param> /// <param name="scoreboard">Command context'sIScoreboard.</param> /// <param name="boardHistory">Command context's IMemento.</param> public CommandContext(IGame game, IScoreboard scoreboard, IMemento boardHistory) { this.Game = game; this.ScoreboardInfo = scoreboard; this.BoardHistory = boardHistory; this.Moves = 0; }
private void HandleStacks(Stack <IMemento> fromStack, Stack <IMemento> toStack) { var previousState = fromStack.Pop(); toStack.Push(CurrentState); CurrentState = previousState; }
void IAggregateRoot.RestoreSnapshot(IMemento memento) { RestoreSnapshot(memento); Key = memento.Key; Version = memento.Version; }
void IAmRestorable.RestoreSnapshot(IMemento memento) { if (memento == null) { return; } RestoreSnapshot(memento); }
public IAggregate Build(Type type, Guid id, IMemento snapshot) { var types = snapshot == null ? new[] { typeof(Guid) } : new[] { typeof(Guid), typeof(IMemento) }; var args = snapshot == null ? new object[] { id } : new object[] { id, snapshot }; ConstructorInfo constructor = type.GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, types, null); return constructor.Invoke(args) as IAggregate; }
protected override void SetMemento(IMemento memento) { var productMemento = (ProductMemento)memento; Id = productMemento.Id; Version = productMemento.Version; Name = productMemento.Name; Price = new Money(productMemento.Price); }
/// <summary> /// Redo 操作を実行し、データを取得します。 /// </summary> public IMemento Redo() { if (!canRedo) return null; undo.Push(Now); Now = redo.Pop(); return Now.Clone(); }
public bool Merge(IMemento otherMemento) { TextChangeMemento other = otherMemento as TextChangeMemento; if (other != null) { if (other.textContainer.Equals(textContainer)) { // Match, do not store anything as the initial state is what we want. return true; } } return false; }
public bool Merge(IMemento otherMemento) { DrawableContainerBoundsChangeMemento other = otherMemento as DrawableContainerBoundsChangeMemento; if (other != null) { if (Objects.CompareLists<IDrawableContainer>(listOfdrawableContainer, other.listOfdrawableContainer)) { // Lists are equal, as we have the state already we can ignore the new memento return true; } } return false; }
protected override void RestoreSnapshot(IMemento memento) { var portfolioMemento = (PortfolioMemento)memento; isOpen = portfolioMemento.IsOpen; foreach (var accountSnapshot in portfolioMemento.Accounts) { accounts.Add(RestoreEntity<Account>(accountSnapshot)); } }
public bool Merge(IMemento otherMemento) { ChangeFieldHolderMemento other = otherMemento as ChangeFieldHolderMemento; if (other != null) { if (other.drawableContainer.Equals(drawableContainer)) { if (other.fieldToBeChanged.Equals(fieldToBeChanged)) { // Match, do not store anything as the initial state is what we want. return true; } } } return false; }
public CustomPropertiesGridControl( ) { InitializeComponent( ) ; if( !Helper.IsInDesignMode ) { _memento = IoC.Memento ; _model = ObjectFactory.GetInstance<IModel>( ) ; _model.SelectionChanged += ( sender, e1 ) => refresh( e1.ItemsAffected ) ; _model.ItemChanged += ( sender1, e2 ) => refresh( e2.ItemsAffected ) ; _model.ActiveLayerChanged += ( s, e ) => refresh( new[ ] { _model.Level.ActiveLayer } ) ; } _grid = new PropertyGrid { Dock = DockStyle.Fill, Visible = false, PropertySort = PropertySort.Categorized, ToolbarVisible = false } ; _grid.PropertyValueChanged += gridPropertyValueChanged ; _grid.SelectedObjectsChanged += gridSelectObjectsChanged; _label = new Label { Dock = DockStyle.Fill, Text = @"Select a single item to view its properties", Visible = true, } ; Controls.Add( _grid ) ; Controls.Add( _label ) ; var site = new SimpleSite { Name = @"GridSite", Component = _grid, } ; _glyphService = new GlyphService( ) ; _glyphService.QueryPropertyUIValueItems += verifyDataErrorInfo ; site.AddService<IPropertyValueUIService>( _glyphService ) ; _grid.Site = site ; }
public IAggregate Build(Type type, Guid id, IMemento snapshot) { ConstructorInfo constructor = type.GetConstructor( BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] {typeof (Guid)}, null); if (constructor == null) { throw new InvalidOperationException( string.Format("Aggregate {0} cannot be created: constructor with only id parameter not provided", type.Name)); } return constructor.Invoke(new object[] {id}) as IAggregate; }
public static void MigrateSettings(bool createTargetCategoryAndFields, bool migrateFieldValues, IMemento newState, IMemento oldState) { Migrator migrator = new Migrator(); if (createTargetCategoryAndFields) { migrator.EnsureTargetCategory(newState.CategoryName); migrator.EnsureFields(newState.CategoryName, new MigrationInfo(oldState, newState).AllFields); } if (migrateFieldValues) { migrator.Migrate(new MigrationInfo(oldState, newState)); } }
public MainForm( ) { _memento = ObjectFactory.GetInstance<IMemento>() ; _model = ObjectFactory.GetInstance<IModel>() ; InitializeComponent(); _model.ActiveLayerChanged += activeLayerChanged ; _model.NewModelLoaded += newModelLoaded ; _model.OnBeforeUnloadingModel += modelUnloading ; _memento.OnCommandEnded += mementoCommandEnded ; _memento.OnCommandUndone += mementoCommandUndone; _memento.OnCommandRedone += mementoCommandRedone; uiAssetsControl.AssetChosenByDoubleClicking += assetChosenByDoubleClicking ; }
public LevelExplorerControl( ) { InteractsWithModel = true ; InitializeComponent( ) ; if( !Helper.IsInDesignMode ) { var imageRepository = ObjectFactory.GetNamedInstance<IImageRepository>( @"iconImages" ) ; Assembly thisAssembly = Assembly.GetExecutingAssembly( ) ; Images.SummonIcon( thisAssembly, LAYER_ICON_ACTIVE_NAME ) ; Images.SummonIcon( thisAssembly,LAYER_ICON_NONACTIVE_NAME ) ; Images.SummonIcon( thisAssembly,LEVEL_ICON_NAME ) ; _imageList = imageRepository.CreateImageList( ) ; _model = ObjectFactory.GetInstance<IModel>( ) ; _memento = ObjectFactory.GetInstance<IMemento>( ) ; subscribeToModelEvents( ) ; } uiTree.AllowDrop = true ; uiTree.CheckBoxes = true ; uiTree.FullRowSelect = true ; uiTree.HideSelection = false ; uiTree.HotTracking = true ; uiTree.ImageList = _imageList ; uiTree.LabelEdit = true ; uiTree.Name = "uiEntityTree" ; uiTree.ShowNodeToolTips = true ; uiTree.KeyDown += entityTreeKeyDown ; uiTree.MouseDown += entityTreeMouseDown ; uiTree.AfterLabelEdit += entityTreeAfterLabelEdit ; uiTree.AfterCheck += entityTreeAfterCheck ; uiTree.AfterSelect += entityTreeAfterSelect ; uiTree.DragDrop += entityTreeDragDrop ; uiTree.DragOver += entityTreeDragOver ; uiTree.ItemDrag += entityTreeItemDrag ; }
public void ApplyMemento(IMemento memento) { if (memento == null) throw new ArgumentNullException("memento"); TextBoxMemento textBoxMemento; try { textBoxMemento = (TextBoxMemento) memento; } catch (InvalidCastException ex) { throw new IncompatibleMementoException( string.Format( "Only memento of type [{0}] be applied to [{1}] ", memento.GetType(), GetType()), ex); } Text = textBoxMemento.Text; MoveCaretTo(textBoxMemento.CaretPostition); Select(textBoxMemento.Selection); }
public MigrationInfo(IMemento oldState, IMemento newState) { if (oldState == null) { throw new ArgumentNullException("oldState"); } if (newState == null) { throw new ArgumentNullException("newState"); } SourceCategoryName = oldState.CategoryName; TargetCategoryName = newState.CategoryName; ChangedFieldNames = MementoHelper.GetChangedFieldNames(oldState, newState); AllFields = new List<FieldInfo>(); foreach (var newField in newState.Fields) { AllFields.Add(newField.Value); } }
internal static Dictionary<string, string> GetChangedFieldNames(IMemento oldState, IMemento newState) { Dictionary<string, string> result = new Dictionary<string, string>(); foreach (var oldField in oldState.Fields) { // Skip empty old field values. if (String.IsNullOrEmpty(oldField.Value.FieldName)) { continue; } // Skip field names that did not change. if (String.Equals(oldField.Value.FieldName, newState.Fields[oldField.Key].FieldName)) { continue; } result.Add(oldField.Value.FieldName, newState.Fields[oldField.Key].FieldName); } return result; }
public bool Merge(IMemento otherMemento) { return false; }
void IOrginator.SetMemento(IMemento memento) { SetMemento(memento); }
public SnapShot(Guid eventProviderId, int version, IMemento memento) { EventProviderId = eventProviderId; Version = version; Memento = memento; }
protected override void RestoreSnapshot(IMemento memento) { var snapshot = (AccountSnapshot)memento; balance = snapshot.Balance; }
protected abstract void SetMemento(IMemento memento);
Stack<IMemento> undo = new Stack<IMemento>(); //Undo 用スタック #endregion Fields #region Constructors /************************↑ 基本変数 ↑************************/ /*********************↓ コンストラクタ ↓*********************/ /// <summary> /// 初期データを指定して UnReDoInvoker オブジェクトを作成します。 /// </summary> /// <param name="imem">初期データ</param> public UnReDoInvoker(IMemento imem) { NoneData = Now = imem; }
/// <summary> /// すべてのデータを消去します。 /// </summary> public void AllClear() { undo.Clear(); redo.Clear(); Now = NoneData; }
/// <summary> /// データを追加します。 /// </summary> /// <param name="mem">追加するデータ</param> public void Setmemento(IMemento mem) { redo.Clear(); undo.Push(Now); Now = mem; }
public void when_reading_entity_then_rehydrates() { var newEvents = new IVersionedEvent[] { new TestEvent { SourceId = id, Version = 2, Foo = "Baz" } }; var serialized = newEvents.Select(x => new EventData { Version = x.Version, Payload = Serialize(x) }); this.id = Guid.NewGuid(); var eventStore = new Mock<IEventStore>(); this.memento = Mock.Of<IMemento>(x => x.Version == 1); var cache = new MemoryCache(Guid.NewGuid().ToString()); cache.Add("TestOriginatorEntity_" + id.ToString(), new Tuple<IMemento, DateTime?>(this.memento, null), DateTimeOffset.UtcNow.AddMinutes(10)); eventStore.Setup(x => x.Load(It.IsAny<string>(), 2)).Returns(serialized); var sut = new AzureEventSourcedRepository<TestOriginatorEntity>(eventStore.Object, Mock.Of<IEventStoreBusPublisher>(), new JsonTextSerializer(), new StandardMetadataProvider(), cache); var entity = sut.Find(id); Assert.NotNull(entity); Assert.Equal(id, entity.Id); Assert.Equal(memento, entity.Memento); Assert.Equal(newEvents, entity.History, new TestEventComparer()); }
public when_saving_memento_originator_entity() { this.eventStore = new Mock<IEventStore>(); this.publisher = new Mock<IEventStoreBusPublisher>(); this.cache = new MemoryCache(Guid.NewGuid().ToString()); var sut = new AzureEventSourcedRepository<TestOriginatorEntity>(eventStore.Object, publisher.Object, new JsonTextSerializer(), new StandardMetadataProvider(), this.cache); this.id = Guid.NewGuid(); this.memento = Mock.Of<IMemento>(); var entity = new TestOriginatorEntity { Id = id, Events = { new TestEvent { SourceId = id, Version = 1, Foo = "Bar" }, new TestEvent { SourceId = id, Version = 2, Foo = "Baz" } }, Memento = memento, }; sut.Save(entity, "correlation"); }