private void AreAurasEqual(List<Aura> mp, List<Aura> ddi)
 {
     Assert.AreEqual(mp.Count, ddi.Count);
     foreach (Aura aMP in mp)
     {
         Aura aDDI = ddi.SingleOrDefault(x => x.Name == aMP.Name.Trim());
         Assert.IsNotNull(aDDI);
         Assert.AreEqual(aMP.Keywords, aDDI.Keywords,String.Format("Different Keyword for aura {0}",aMP.Name));
         Assert.AreEqual(aMP.ToString(), aDDI.ToString());
     }
 }
 private void AreDamageEqual(List<DamageModifier> mp, List<DamageModifier> ddi)
 {
     Assert.AreEqual(mp.Count, ddi.Count);
     foreach (DamageModifier dMP in mp)
     {
         DamageModifier dDDI = ddi.SingleOrDefault(x => x.Type == dMP.Type);
         Assert.IsNotNull(dDDI);
         Assert.AreEqual(dMP.Value, dDDI.Value);
         Assert.AreEqual(dMP.Type, dDDI.Type);
         Assert.AreEqual(dMP.ToString(), dDDI.ToString());
     }
 }
Example #3
0
        public void DeleteProduct()
        {
            var data = new List<Product>
            {
                new Product {Name = "BBB", BarCode = "112115", InStock = 15, Id = 1},
                new Product {Name = "ZZZ", BarCode = "112116", InStock = 23, Id = 2},
                new Product {Name = "AAA", BarCode = "112116", InStock = 30, Id = 3}
            };

            var mockSet = new Mock<DbSet<Product>>()
                .SetupData(data, objects => data.SingleOrDefault(d => d.Id == (int)objects.First()));
            

            var mockContext = new Mock<DAL.IDbContext>();
            mockContext.Setup(m => m.Set<Product>()).Returns(mockSet.Object);
            var service = new ProductService(mockContext.Object);

            service.Delete(1);
            Assert.IsNull(data.Find(x => x.Id == 1));
        }
        public List<Operation> GetOperationsForAccount(int accountID)
        {
            List<Operation> operations1 = new List<Operation>();
            operations1.Add(new Operation { Amount = 100, Direction = Domain.Direction.Credit });
            operations1.Add(new Operation { Amount = 200, Direction = Domain.Direction.Debit });

            List<Account> accounts = new List<Account>();
            accounts.Add(new Account { Balance = 300, Operations = operations1, AutorizeOverdraft = true, Id = 1 });
            accounts.Add(new Account { Balance = 0, Operations = null, AutorizeOverdraft = false, Id = 2 });

            SIAccountRepository accountRepository = new SIAccountRepository();
            accountRepository.GetAccountInt32 = (x) =>
            {
                return accounts.SingleOrDefault(a => a.Id == x);
            };

            SIOperationRepository operationRepository = new SIOperationRepository();
            AccountService service = new AccountService(accountRepository, operationRepository);

            List<Operation> result = service.GetOperationsForAccount(accountID);
            return result;
        }
        public async Task GetUserStock_with_id_must_return_stock_from_context()
        {
            var data = new List<UserStock>
            {
                new UserStock {ID = 0, Name = "DAX"},
                new UserStock {ID = 1, Name = "NYSE"}
            }.AsQueryable();

            var mockSet = new Mock<DbSet<UserStock>>();
            mockSet.Setup(m => m.FindAsync(It.IsAny<object[]>())).Returns<object[]>((key) => Task.FromResult(data.SingleOrDefault(us => us.ID == (int)key[0])));

            var mockContext = new Mock<IStockExchangeDbContext>();
            mockContext.Setup(c => c.UserStocks).Returns(mockSet.Object);

            var service = new UserStocksController(mockContext.Object);
            var result = await service.GetUserStock(0);

            Assert.IsInstanceOfType(result, typeof(OkNegotiatedContentResult<UserStock>));
            var conResult = result as OkNegotiatedContentResult<UserStock>;
            Assert.IsNotNull(conResult);
            Assert.AreEqual(data.Single(us => us.ID == 0), conResult.Content);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="dataAreaId">hrp, bsc, ser</param>
        /// <param name="inventLocation">hrp: BELSO, KULSO, HASZNALT|bsc: 7000, 1000, 2100|ser: SER</param>
        /// <param name="productId"></param>
        /// <param name="stocks"></param>
        /// <returns></returns>
        private int GetStock(string dataAreaId, string inventLocation, string productId, List<CompanyGroup.Domain.MaintainModule.Stock> stocks)
        {
            CompanyGroup.Domain.MaintainModule.Stock stock = stocks.SingleOrDefault(x => x.DataAreaId.ToLower().Equals(dataAreaId.ToLower()) && x.InventLocationId.ToUpper().Equals(inventLocation.ToUpper()) && x.ProductId.ToLower().Equals(productId.ToLower()));

            return (stock != null) ? stock.Quantity : 0;
        }
        public void Persisted_Messages_Survive_Service_Restart()
        {
            var sentMessages = new List<TestMessage1>();
            var receivedMessages = new List<TestMessage1>();

            var random = new Random();
            var texts = ((DayOfWeek[])Enum.GetValues(typeof(DayOfWeek))).Select(x => x.ToString()).ToArray();
            var initialTicks = DateTime.Now.AddYears(-20).Ticks;
            var finalTicks = DateTime.Now.Ticks;

            for (var i = 0; i < 20; i++)
            {
                sentMessages.Add(new TestMessage1
                {
                    Id = Guid.NewGuid(),
                    Field1 = texts[random.Next((int) DayOfWeek.Sunday, (int) DayOfWeek.Saturday)],
                    Field2 = random.Next(1, 100),
                    Field3 = new DateTime(initialTicks + random.Next(0, (int) (finalTicks - initialTicks)))
                });
            }

            var hostName = Config.Get("hostName", "localhost");
            var port = Config.Get("port", 8377);
            var baseAddress = Config.Get("baseAddress", "");

            var conn = MessageQueue.Connect(hostName, port, baseAddress);
            const string queueName = "PersistedQueue1";

            using (var host = GetQueueHost(hostName, port, baseAddress))
            {
                host.Open();

                TryCreateQueue(conn, queueName, true, false);

                var queue = conn.Get(queueName);

                foreach (var message in sentMessages)
                    queue.Send(message);
            }

            Thread.Sleep(1000);

            using (var host = GetQueueHost(hostName, port, baseAddress))
            {
                host.Open();

                var queue = conn.Get(queueName);

                using (var op = queue.StartReceiving<TestMessage1>(100,
                    receivedMessages.Add, e => { throw e; }))
                {
                    Thread.Sleep(5000);

                    op.Stop();
                    Assert.IsFalse(op.Exceptions.Any());
                }
            }

            Assert.AreEqual(sentMessages.Count, receivedMessages.Count);

            foreach (var receivedMessage in sentMessages
                .Select(x => receivedMessages.SingleOrDefault(y => y.Equals(x))))
            {
                Assert.IsNotNull(receivedMessage);
            }
        }
        public async Task DeleteUserStock_must_remove_userstock_from_set()
        {
            var data = new List<UserStock>
            {
                new UserStock {ID = 0, Name = "DAX", User = @"ALIS-PC\Ali"},
                new UserStock {ID = 1, Name = "NYSE", User = @"ALIS-PC\Ali"}
            }.AsQueryable();

            var mockSet = new Mock<DbSet<UserStock>>();
            mockSet.Setup(m => m.FindAsync(It.IsAny<object[]>())).Returns<object[]>((key) => Task.FromResult(data.SingleOrDefault(us => us.ID == (int)key[0])));

            var mockContext = new Mock<IStockExchangeDbContext>();
            mockContext.Setup(m => m.UserStocks).Returns(mockSet.Object);

            var service = new UserStocksController(mockContext.Object);
            var result = await service.DeleteUserStock(0);

            Assert.IsInstanceOfType(result, typeof(OkNegotiatedContentResult<UserStock>));
            mockSet.Verify(m => m.Remove(It.IsAny<UserStock>()), Times.Once());
            mockContext.Verify(m => m.SaveChangesAsync(), Times.Once());
        }
        public async Task DeleteUserStock_must_return_Notound_when_count_not_found_userstock_with_provided_id()
        {
            var data = new List<UserStock>
            {
                new UserStock {ID = 0, Name = "DAX"},
                new UserStock {ID = 1, Name = "NYSE"}
            }.AsQueryable();

            var mockSet = new Mock<DbSet<UserStock>>();
            mockSet.Setup(m => m.FindAsync(It.IsAny<object[]>())).Returns<object[]>((key) => Task.FromResult(data.SingleOrDefault(us => us.ID == (int)key[0])));

            var mockContext = new Mock<IStockExchangeDbContext>();
            mockContext.Setup(m => m.UserStocks).Returns(mockSet.Object);

            var service = new UserStocksController(mockContext.Object);
            var result = await service.DeleteUserStock(3);

            Assert.IsInstanceOfType(result, typeof(NotFoundResult));
        }
        private void SetupMarkets()
        {
            _USMarketMock = new Mock<IMarket>();
            _USMarketMock.Setup(x => x.MarketId).Returns(new MarketId("US"));
            _USMarketMock.Setup(x => x.DefaultCurrency).Returns(new Currency("USD"));

            _SEKMarketMock = new Mock<IMarket>();
            _SEKMarketMock.Setup(x => x.MarketId).Returns(new MarketId("SE"));
            _SEKMarketMock.Setup(x => x.DefaultCurrency).Returns(new Currency("SEK"));

            var markets = new List<IMarket> {_USMarketMock.Object, _SEKMarketMock.Object};

            _marketServiceMock = new Mock<IMarketService>();
            _marketServiceMock.Setup(x => x.GetMarket(It.IsAny<MarketId>()))
                .Returns((MarketId marketId) => markets.SingleOrDefault(x => x.MarketId == marketId));
        }
        private void SetupContent()
        {
            _variation1 = new VariationContent
            {
                Code = "code1",
                ContentLink = new ContentReference(1),
                Categories = new Categories {ContentLink = new ContentReference(11)}
            };

            _variation2 = new VariationContent
            {
                Code = "code2",
                ContentLink = new ContentReference(2),
                Categories = new Categories { ContentLink = new ContentReference(11) }
            };

            _variations = new List<VariationContent>
            {
                _variation1, _variation2
            };

            _contentLoaderMock = new Mock<IContentLoader>();
            _contentLoaderMock.Setup(x => x.Get<EntryContentBase>(It.IsAny<ContentReference>()))
                .Returns((ContentReference contentReference) => _variations.SingleOrDefault(x => x.ContentLink == contentReference));
        }
Example #12
0
        public void SingleOrDefault_abnormal()
        {
            // arrange
            List<int> list = new List<int>() { 1 };

            // act and assert
            try
            {
                list.SingleOrDefault(null);
                Assert.Fail();
            }
            catch (Exception e)
            {
                Assert.IsTrue(e is ArgumentNullException);
            }
        }
        public void ListExtensions_SingleOrDefault_ReturnsSingleItemInList()
        {
            var list = new List<Int32>() { 4 };

            var result = list.SingleOrDefault();

            TheResultingValue(result).ShouldBe(4);
        }
        public void ConditionSingleOrDefaultThrowsInvalidOperationExceptionIfNoMatches()
        {
            IList<Condition> conditions = new List<Condition>() { new Condition() { ConditionId = 1, Description = "New", eBayConditionId = 1000 } };

            var result = conditions.SingleOrDefault(c => c.eBayConditionId == 2999);
        }
        public void ListExtensions_SingleOrDefault_ReturnsDefaultValueIfListIsEmpty()
        {
            var list = new List<Int32>();

            var result = list.SingleOrDefault();

            TheResultingValue(result).ShouldBe(default(Int32));
        }
Example #16
0
        public void SingleOrDefault()
        {
            // arrange
            List<int> list = new List<int>() { 1 };
            List<int> listMany = new List<int>() { 1, 2, 3 };
            List<int> listEmpty = new List<int>() { };

            // act
            int actual = list.SingleOrDefault();
            int actualFilter = listMany.SingleOrDefault(x => x == 3);
            int actualEmpty = listEmpty.SingleOrDefault();
            int actualUnMatch = listEmpty.SingleOrDefault(x => x == 0);

            // assert
            Assert.AreEqual(1, actual);
            Assert.AreEqual(3, actualFilter);
            Assert.AreEqual(0, actualEmpty);
            Assert.AreEqual(0, actualUnMatch);
        }
        public void Modify_Existing_Data_Should_Update_The_Data()
        {
            var mockRepo = new Mock<IRepository<NewsRecord>>();
            var news = new List<NewsRecord>()
            {
                new NewsRecord
                {
                    Id = 1,
                    Title = "HopHop1",
                    Content = "The hoppy hop",
                    PublishDate = DateTime.Now
                },
                new NewsRecord
                {
                    Id = 2,
                    Title = "HopHop2",
                    Content = "The hoppy hop2",
                    PublishDate = DateTime.Now.AddDays(+5)
                },
                new NewsRecord
                {
                    Id = 3,
                    Title = "HopHop3",
                    Content = "The hoppy hop3",
                    PublishDate = DateTime.Now.AddDays(+10)
                }
            };

            mockRepo.Setup(r => r.Update(It.IsAny<NewsRecord>()))
              .Callback((NewsRecord n) => news[news.FindIndex(x => x.Id == n.Id)] = n);

            var controller = new NewsController(mockRepo.Object);
            this.SetupController(controller, "NewsController");

            var newsFromRepo = news.SingleOrDefault(n => n.Title == "HopHop1");
            var newsFromRepoId = newsFromRepo.Id;

            var modifyModel = new NewsRecordBindingModel()
            {
                Title = "Changed Shit",
                Content = "Messy shit",
            };

            var response = controller.PutNewsRecord(newsFromRepoId, modifyModel).ExecuteAsync(CancellationToken.None).Result;

            var newsAfterUpdate = news.SingleOrDefault(n => n.Id == newsFromRepo.Id);

            Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
            Assert.AreEqual("Changed Shit", newsAfterUpdate.Title);
        }
        public void atualizar_estrutura_hospitalar_departamentoExistentes()
        {
            var tiposConta = new TiposConta();
            var tiposDeconta = new TiposConta();
            var tipoContaOutras = tiposDeconta.Obter<TipoConta>(1);

            string _conectionstring = @"Provider=Microsoft.Jet.OLEDB.4.0;";
            _conectionstring += String.Format("Data Source={0};", "D:\\CargaOrcamento2014\\DepartamentoCentroDeCustoContaHospitalarNew.xls");
            _conectionstring += "Extended Properties='Excel 8.0;HDR=YES;IMEX=1;'";

            var cn = new OleDbConnection(_conectionstring);
            var cmd = new OleDbCommand("Select * from [c$]", cn);
            cn.Open();
            var reader = cmd.ExecuteReader();

            var documento = new List<RegistroExcel>();

            var listaContas = new List<Conta>();
            var listaCentrosDeCusto = new List<CentroDeCusto>();

            var repositorioDeHospitais = new Hospitais();
            var repositorioDeCusto = new CentrosDeCusto();
            var repositorioContas = new Contas();

            int i = 0;

            while (reader.Read())
            {
                if (i == 0)
                {
                    i++;
                    continue;
                }
                if (reader[0] == null || reader[0] == DBNull.Value || string.IsNullOrEmpty(reader[0].ToString()))
                    break;

                var registroExcel = new RegistroExcel()
                {
                    NomeHospital = (string)reader[5],
                    CodigoCentroDeCusto = Convert.ToString(reader[0]),
                    DescricaoCentroDeCusto = (string)reader[1]
                };

                if (reader[5] != DBNull.Value)
                {
                    registroExcel.DescricaoConta = (string)reader[3];
                    registroExcel.CodigoConta = Convert.ToString(reader[2]);
                    registroExcel.GrupoResumoNome = (string)reader[4];
                }

                documento.Add(registroExcel);
            }

            cn.Close();
            cn.Dispose();
            cmd.Dispose();

            var gruposDeConta = documento.Select(x => x.GrupoResumoNome).Distinct();

            var codigosDeConta = documento.Select(x => x.CodigoConta).Distinct();

            foreach (var codigoDeConta in codigosDeConta)
            {
                string descricaoDaConta = documento.Where(x => x.CodigoConta == codigoDeConta).Select(y => y.DescricaoConta).Distinct().First();

                var conta = repositorioContas.ObterContaPor(codigoDeConta);

                if (listaContas.All(c => c.CodigoDaConta != codigoDeConta))
                {
                    if (conta == null)
                    {
                        throw new Exception();

                        conta = new Conta(descricaoDaConta, tipoContaOutras)
                        {
                            CodigoDaConta = codigoDeConta
                        };
                        repositorioContas.Salvar(conta);
                    }

                    listaContas.Add(conta);
                }
                else
                    conta = listaContas.FirstOrDefault(c => c.CodigoDaConta == codigoDeConta);

            }
            var grupos = new GruposDeConta();
            var gruposDeContaLista = new List<GrupoDeConta>();
            foreach (var grupo in gruposDeConta)
            {
                var grupoDeConta = grupos.ObterPor(grupo);

                if (grupoDeConta == null)
                    throw new Exception();

                var contasDoGrupo = documento.Where(x => x.GrupoResumoNome == grupo).Select(y => y.CodigoConta).Distinct();

                foreach (var codigoConta in contasDoGrupo)
                {
                    var conta = listaContas.FirstOrDefault(c => c.CodigoDaConta == codigoConta);

                    if (grupoDeConta.Contas == null)
                        grupoDeConta.Contas = new List<Conta>();

                    if (grupoDeConta.Contas.All(c => c.CodigoDaConta != codigoConta))
                        grupoDeConta.Adicionar(conta);
                }

                gruposDeContaLista.Add(grupoDeConta);
                grupos.Salvar(grupoDeConta);
            }

            var codigosDecentrosDeCusto = documento.Select(x => x.CodigoCentroDeCusto).Distinct();

            foreach (var codigoDeCentro in codigosDecentrosDeCusto)
            {
                var descricaoDeCentroDeCusto = documento.Where(x => x.CodigoCentroDeCusto == codigoDeCentro).Select(y => y.DescricaoCentroDeCusto).Distinct().First();

                var centroDeCusto = repositorioDeCusto.ObterPor(codigoDeCentro);
                if (centroDeCusto == null)
                {
                        throw new Exception();

                    centroDeCusto = new CentroDeCusto(descricaoDeCentroDeCusto)
                    {
                        CodigoDoCentroDeCusto = codigoDeCentro
                    };
                }

                var contas = documento.Where(x => x.CodigoCentroDeCusto == codigoDeCentro).Select(y => y.CodigoConta).Distinct();

                if (centroDeCusto.Contas == null)
                    centroDeCusto.Contas = new List<Conta>();

                foreach (var conta in contas)
                {
                    if (centroDeCusto.Contas.All(c => c.CodigoDaConta != conta))
                        centroDeCusto.AdicionarConta(listaContas.SingleOrDefault(x => x.CodigoDaConta == conta));
                }

                repositorioDeCusto.Salvar(centroDeCusto);
                listaCentrosDeCusto.Add(centroDeCusto);
            }

            var hospitais = documento.Select(x => x.NomeHospital).Distinct();

            foreach (var nomeHospital in hospitais)
            {
                var hospital = repositorioDeHospitais.ObterPor(nomeHospital);
                if(hospital == null)
                    throw new Exception();

                var centrosDeCusto = documento.Where(x => x.NomeHospital == hospital.Nome).Select(y => y.CodigoCentroDeCusto).Distinct();

                if (hospital.CentrosDeCusto == null)
                    hospital.CentrosDeCusto = new List<CentroDeCusto>();

                foreach (var codigoCentroCusto in centrosDeCusto)
                {
                    if (hospital.CentrosDeCusto.All(c => c.CodigoDoCentroDeCusto != codigoCentroCusto))
                        hospital.AdicionarCentroDeCusto(listaCentrosDeCusto.SingleOrDefault(x => x.CodigoDoCentroDeCusto == codigoCentroCusto));
                }

                repositorioDeHospitais.Salvar(hospital);
            }
        }
 private static void AssertSingleSampleWithNonZeroMetric(List<MonitoringDataPoint> samples, string metricName)
 {
     Assert.IsNotNull(samples.SingleOrDefault(item => item.Metrics.Any(m => m.Name == metricName && m.Value > 0)));
 }
        public void ListExtensions_SingleOrDefault_ThrowsExceptionIfListHasMultipleItems()
        {
            var list = new List<Int32>() { 1, 2 };

            list.SingleOrDefault();
        }