C# TestRepository.Get方法代码示例

 public void Setup()
 {
     _testRep = new TestRepository();
     _rep = new CachingRepository(_testRep, new TestEventStore());
     _aggregate = _testRep.Get<TestAggregate>(Guid.NewGuid());
     _rep.Save(_aggregate,-1);
 }

        public void SelectSamePiece()
        {
            var repository = new TestRepository();

            var game = SetupGame(repository);

            // select a piece
            var piece = repository.FindAll<Piece>().First();
            var color = repository.FindAll<Color>().First();
            var player1 = game.Players.First();
            var action1 = player1.Actions.Where(x => x.Type == ActionType.SelectPiece).Single();
            action1.PerformAction(string.Format("{{'PieceId':'{0}','ColorId':'{1}'}}", piece.Id, color.Id));

            // select the same combo of piece/color with another player
            var player2 = game.Players.Where(x => x.Actions.Where(y => y.Type == ActionType.SelectPiece).Count() > 0).First();
            var action2 = player2.Actions.Where(x => x.Type == ActionType.SelectPiece).Single();
            action2.PerformAction(string.Format("{{'PieceId':'{0}','ColorId':'{1}'}}", piece.Id, color.Id));

            // verify that no piece was selected
            player2 = repository.Get<Player>(player2.Id);
            Assert.AreEqual(0, player2.ColorId);
            Assert.AreEqual(0, player2.PieceId);
            Assert.IsNotEmpty(player2.Actions.Where(x => x.Type == ActionType.SelectPiece));
            var message = player2.Messages.Single();
            Assert.AreEqual("Another player has the same piece. Please choose another picture and/or color.", message.Text);
        }

 public When_saving_aggregate()
 {
     _testRep = new TestRepository();
     _rep = new CacheRepository(_testRep, new TestInMemoryEventStore(), new CqrsMemoryCache());
     _aggregate = _testRep.Get<TestAggregate>(Guid.NewGuid());
     _aggregate.DoSomething();
     _rep.Save(_aggregate, -1);
 }

 public void Setup()
 {
     _testRep = new TestRepository();
     _rep = new CacheRepository(_testRep, new TestInMemoryEventStore());
     _aggregate = _testRep.Get<TestAggregate>(Guid.NewGuid());
     _aggregate.DoSomething();
     try
     {
         _rep.Save(_aggregate, 100);
     }
     catch (Exception){}
 }

 public When_saving_fails()
 {
     _memoryCache = new MemoryCache();
     _testRep = new TestRepository();
     _rep = new CacheRepository(_testRep, new TestInMemoryEventStore(), _memoryCache);
     _aggregate = _testRep.Get<TestAggregate>(Guid.NewGuid());
     _aggregate.DoSomething();
     try
     {
         _rep.Save(_aggregate, 100);
     }
     catch (Exception) { }
 }

        public void SelectPiece()
        {
            var repository = new TestRepository();

            var game = SetupGame(repository);

            // select a piece
            var piece = repository.FindAll<Piece>().First();
            var color = repository.FindAll<Color>().First();
            var player = game.Players.First();
            var action = player.Actions.Where(x => x.Type == ActionType.SelectPiece).Single();
            action.PerformAction(string.Format("{{'PieceId':'{0}','ColorId':'{1}'}}", piece.Id, color.Id));

            // verify that piece was selected
            player = repository.Get<Player>(player.Id);
            Assert.AreEqual(piece.Id, player.ColorId);
            Assert.AreEqual(color.Id, player.PieceId);
            Assert.IsEmpty(player.Actions.Where(x => x.Type == ActionType.SelectPiece));
            var message = player.Messages.Single();
            Assert.AreEqual(string.Format("{0} {1} piece selected.", piece.Name, color.Name), message.Text);
        }

        public void TurnAround()
        {
            // set up data
            var repository = new TestRepository();

            var board = new Board();
            repository.Add(board);
            var space = new Space() { Type = SpaceType.TurnAround, BoardId = board.Id };
            repository.Add(space);
            var game = new Game();
            game.Repository = repository;
            game.Create(board.Id, 2);

            // trigger onland
            var player = game.Players.First();
            space.OnLand(player);

            // verify that player was turned around and received the correct message
            player = repository.Get<Player>(player.Id);
            Assert.AreEqual(false, player.MovementDirection);
            var message = player.Messages.Single();
            Assert.AreEqual("Turned around.", message.Text);
        }

        public void CloneBoard()
        {
            var repository = new TestRepository();

            // create a board and associated data
            var board = CreateBoardData(repository);

            // clone the board
            var clonedBoard = board.Clone();

            // verify that the board and associated objects are cloned
            Assert.AreNotEqual(board.Id, clonedBoard.Id);
            Assert.AreNotEqual(board.ImageId, clonedBoard.ImageId);
            Assert.AreEqual(board.Active, clonedBoard.Active);
            Assert.AreEqual(board.Description, clonedBoard.Description);
            Assert.AreEqual(board.Name, clonedBoard.Name);
            Assert.AreEqual(board.OwnerId, clonedBoard.OwnerId);
            Assert.AreEqual(board.TurnsToEnd, clonedBoard.TurnsToEnd);
            Assert.AreEqual(board.NameCardsToEnd, clonedBoard.NameCardsToEnd);
            Assert.AreEqual(board.SafeHavenCardsToEnd, clonedBoard.SafeHavenCardsToEnd);

            // spaces
            Assert.AreNotEqual(board.Spaces.Select(x => x.Id), clonedBoard.Spaces.Select(x => x.Id));
            Assert.AreEqual(board.Spaces.Select(x => clonedBoard.Id), clonedBoard.Spaces.Select(x => x.BoardId));
            Assert.AreEqual(board.Spaces.Select(x => x.Order), clonedBoard.Spaces.Select(x => x.Order));
            Assert.AreNotEqual(board.Spaces.Select(x => x.ChallengeCategories.Select(y => y.Id)), clonedBoard.Spaces.Select(x => x.ChallengeCategories.Select(y => y.Id)));
            Assert.AreEqual(board.Spaces.Select(x => x.ChallengeCategories.Select(y => repository.Get<ChallengeCategory>(y.ChallengeCategoryId).Name)), clonedBoard.Spaces.Select(x => x.ChallengeCategories.Select(y => repository.Get<ChallengeCategory>(y.ChallengeCategoryId).Name)));
            Assert.AreNotEqual(board.Spaces.Select(x => x.ChallengeCategories.Select(y => repository.Get<ChallengeCategory>(y.ChallengeCategoryId).Id)), clonedBoard.Spaces.Select(x => x.ChallengeCategories.Select(y => repository.Get<ChallengeCategory>(y.ChallengeCategoryId).Id)));

            // challenges
            Assert.AreNotEqual(board.Challenges.Select(x => x.Id), clonedBoard.Challenges.Select(x => x.Id));
            Assert.AreEqual(board.Challenges.Select(x => x.Question), clonedBoard.Challenges.Select(x => x.Question));
            Assert.AreEqual(board.Challenges.Select(x => 0), clonedBoard.Challenges.Select(x => x.OwnerId));

            // categories
            var categories = board.Challenges.Select(x => repository.Get<ChallengeCategory>(x.ChallengeCategoryId));
            var clonedCategories = clonedBoard.Challenges.Select(x => repository.Get<ChallengeCategory>(x.ChallengeCategoryId));
            Assert.AreNotEqual(categories.Select(x => x.Id), clonedCategories.Select(x => x.Id));
            Assert.AreEqual(categories.Select(x => x.Name), clonedCategories.Select(x => x.Name));
            Assert.AreEqual(categories.Select(x => 0), clonedCategories.Select(x => x.OwnerId));
        }

        public void CopyBoard()
        {
            var repository = new TestRepository();

            // create a board and associated data
            var board = CreateBoardData(repository);

            // copy the board
            var copiedBoard = board.Copy();

            // verify that the board and spaces are copied, and challenge links are copied but challenges are the same
            Assert.AreNotEqual(board.Id, copiedBoard.Id);
            Assert.AreEqual(board.ImageId, copiedBoard.ImageId);
            Assert.AreEqual(board.Active, copiedBoard.Active);
            Assert.AreEqual(board.Description, copiedBoard.Description);
            Assert.AreEqual(board.Name, copiedBoard.Name);
            Assert.AreEqual(board.OwnerId, copiedBoard.OwnerId);
            Assert.AreEqual(board.TurnsToEnd, copiedBoard.TurnsToEnd);
            Assert.AreEqual(board.NameCardsToEnd, copiedBoard.NameCardsToEnd);
            Assert.AreEqual(board.SafeHavenCardsToEnd, copiedBoard.SafeHavenCardsToEnd);
            Assert.AreNotEqual(board.Spaces.Select(x => x.Id), copiedBoard.Spaces.Select(x => x.Id));
            Assert.AreEqual(board.Spaces.Select(x => copiedBoard.Id), copiedBoard.Spaces.Select(x => x.BoardId));
            Assert.AreEqual(board.Spaces.Select(x => x.Order), copiedBoard.Spaces.Select(x => x.Order));
            Assert.AreNotEqual(board.Spaces.Select(x => x.ChallengeCategories.Select(y => y.Id)), copiedBoard.Spaces.Select(x => x.ChallengeCategories.Select(y => y.Id)));
            Assert.AreEqual(board.Spaces.Select(x => x.ChallengeCategories.Select(y => repository.Get<ChallengeCategory>(y.ChallengeCategoryId).Id)), copiedBoard.Spaces.Select(x => x.ChallengeCategories.Select(y => repository.Get<ChallengeCategory>(y.ChallengeCategoryId).Id)));
            Assert.AreEqual(board.Challenges.Select(x => x.Id), copiedBoard.Challenges.Select(x => x.Id));
        }