public void When_Search_Then_map_returned_entities_to_dtos()
        {
            //given
            var actions = new List<BusinessSafe.Domain.Entities.Action>()
                                  {                      
                                        new BusinessSafe.Domain.Entities.Action()
                                        {
                                            Id = 123123,
                                            Title = "test title",
                                            AreaOfNonCompliance = "area not compliant",
                                            ActionRequired = "action required test",                        
                                            TargetTimescale = "do this now",
                                            AssignedTo = new Employee(){Id = Guid.NewGuid(), Forename = "Fred", Surname = "Flintstone"},
                                            DueDate = DateTime.Now.AddDays(10),
                                            Reference = "The Reference",
                                            Category = ActionCategory.Action
                                        }
                                  };


            var target = GetTarget();

            _actionRepository.Setup(x => x.GetAll()).Returns(actions);

            //when
            SearchActionRequest request = new SearchActionRequest()
            {
                ActionPlanId = 123123L
            };
            var result = target.Search(request);

            //then
            Assert.That(result.FirstOrDefault().Id, Is.EqualTo(actions.FirstOrDefault().Id));
            Assert.That(result.FirstOrDefault().Title, Is.EqualTo(actions.FirstOrDefault().Title));                   
        }
        public void TestInit()
        {
            #region User members

            _members = new List<User>
                    {
                        new User
                        {
                            UserId = 1,
                            UserName = "******"
                        },
                        new User
                        {
                            UserId = 2,
                            UserName = "******"
                        },
                        new User
                        {
                            UserId = 3,
                            UserName = "******"
                        }
                    };

            #endregion

            #region Communities

            _communities = new List<Community>
                     {
                         new Community
                         {
                             Id = 1,
                             LeaderUserId = 1,
                             Leader = _members.FirstOrDefault(a => a.UserId == 1),
                             Members = _members.ToList()
                         },
                         new Community
                         {
                             Id = 2,
                             LeaderUserId = 2,
                             Leader = _members.FirstOrDefault(a => a.UserId == 2),
                             Members = _members.ToList()
                         },
                         new Community
                         {
                             Id = 3,
                             LeaderUserId = 3,
                             Leader = _members.FirstOrDefault(a => a.UserId == 3),
                             Members = _members.ToList()
                         },
                     };

            #endregion
        }
        public void Delete_Group_ReturnsBadRequestResult_Negative()
        {
            int groupId = 1;
            List<Enrollment> initialEnrollments = new List<Enrollment>
            {
                new Enrollment
                {
                    Id = 1,
                    GroupId = groupId,
                    UserId = 1,
                    Date = DateTime.Now
                },
                new Enrollment
                {
                    Id = 2,
                    GroupId = groupId,
                    UserId = 2,
                    Date = DateTime.Now
                },
                new Enrollment
                {
                    Id = 3,
                    GroupId = groupId,
                    UserId = 3,
                    Date = DateTime.Now
                }
            };

            GenerateData("1", new[] { "NoRoles" });
            Mock<IGroupForListingMapper> groupForListingMapper = new Mock<IGroupForListingMapper>();
            Mock<IGroupService> groupService = new Mock<IGroupService>();
            Mock<IEnrollmentService> enrollmentService = new Mock<IEnrollmentService>();
            Mock<IWordProgressService> wordProgressService = new Mock<IWordProgressService>();
            Mock<IWordSuiteService> wordsuiteService = new Mock<IWordSuiteService>();
            Mock<ICourseService> courseService = new Mock<ICourseService>();
            Mock<ICourseForGroupMapper> courseMapper = new Mock<ICourseForGroupMapper>();
            Mock<IGroupMapper> groupMapper = new Mock<IGroupMapper>();

            GroupController groupController = new GroupController(groupService.Object, groupForListingMapper.Object,
                enrollmentService.Object, wordProgressService.Object, wordsuiteService.Object, courseService.Object,
                courseMapper.Object, groupMapper.Object);

            enrollmentService.Setup(x => x.GetByGroupId(groupId)).Returns(initialEnrollments);
            wordProgressService.Setup(x => x.RemoveProgressesForEnrollment(
                It.Is<int>(id => initialEnrollments.FirstOrDefault(e => e.Id == id) != null))).Returns(true);
            wordsuiteService.Setup(x => x.RemoveWordSuitesForEnrollment(
                It.Is<int>(id => initialEnrollments.FirstOrDefault(e => e.Id == id) != null))).Returns(true);
            groupService.Setup(x => x.DeleteById(groupId)).Returns(false);

            var actual = groupController.Delete(groupId);

            Assert.IsInstanceOf(typeof(BadRequestErrorMessageResult), actual);
        }
        private static string GetFindPackageResult(string url, List<Package> packages, bool latestVersion)
        {
            string apiUri = url.Replace("&", "&amp;");
            Uri uri = new Uri(apiUri);

            DateTime updated = packages.Any()
                                   ? packages.OrderByDescending(p => p.DateUpdated).First().DateUpdated
                                   : DateTime.UtcNow;

            entry[] entries = latestVersion
                ? new[] { PackageDetails.GetPackageEntry(packages.FirstOrDefault(p => p.LatestVersion), uri) }
                : packages.Select(p => PackageDetails.GetPackageEntry(p, uri)).ToArray();

            feed feed = new feed
            {
                @base = InvokeUrl + "/",
                id = WebUtility.HtmlDecode(uri.ToString()),
                title = new feedTitle("FindPackagesById"),
                updated = updated,
                link = new feedLink("FindPackagesById", "FindPackagesById"),
                entry = entries
            };

            XmlSerializer serializer = new XmlSerializer(typeof(feed));
            MemoryStream ms = new MemoryStream();
            serializer.Serialize(ms, feed);
            ms.Position = 0;
            return new StreamReader(ms).ReadToEnd();
        }
        public void b_deck_after_Shuffle_has_52_card_unordered()
        {
            _deck.Shuffle();
            _cards = _deck.Cards;

            _cards.FirstOrDefault().Value.Should().Not.Be.EqualTo( new Value(SuitEnum.Hearts, RankEnum.Ace));
            _cards.LastOrDefault().Value.Should().Not.Be.EqualTo(new Value(SuitEnum.Clubs, RankEnum.King));
        }
 public void GetAllSheetsTest()
 {
     var repo = new TimeTrackerRepository();
     List<Timesheet> timesheets = new List<Timesheet>();
     timesheets = repo.GetAllTimeSheets(6);
     var timesheet = timesheets.FirstOrDefault(x=>x.TimesheetId==22);
     Assert.AreEqual(timesheet.EntryType, "Timesheet");
     Assert.AreEqual(4, timesheets.Count);
 }
 public void GetMessageDetailTest()
 {
     var quote = new Quote("SPPI");
     var listQuotes = new List<Quote>();
     listQuotes.Add(quote);
     Stock.StockFetcher.YahooStockEngine.Fetch(listQuotes);
     var result = MessageDetail.GetMessageDetail(listQuotes.FirstOrDefault());
     Messaging.SendEmailGmail("Stock alert", result);
     //Assert.Fail();
 }
        public void ShouldCreateTaskbarIcon()
        {
            // Arrange
            var icon = new Icon(FlowMate.TrayIconFileName);
            var trayIcons = new List<TaskbarIcon>();
            var systemTray = new SystemTray(trayIcons);

            // Act
            systemTray.Add(icon);

            // Assert
            Assert.AreEqual(icon, trayIcons.FirstOrDefault().Icon);
        }
Beispiel #9
0
        public void First_or_default_returns_the_default_value_of_the_type_if_the_collection_is_empty()
        {
            var strings = new List<string>();
            var firstString = strings.FirstOrDefault();

            var ints = new List<int>();
            var firstInt = ints.FirstOrDefault();

            Assert.AreEqual(0, firstInt);
            Assert.AreEqual(default(int), firstInt);

            Assert.IsNull(firstString);
            Assert.AreEqual(default(string), firstString);
        }
        public void Can_remove_duplicatedQuantities()
        {
            var tierPrices = new List<TierPrice>();
            tierPrices.Add(new TierPrice
            {
                //will be removed
                Id = 1,
                Price = 150,
                Quantity = 1
            });
            tierPrices.Add(new TierPrice
            {
                //will stay
                Id = 2,
                Price = 100,
                Quantity = 1
            });
            tierPrices.Add(new TierPrice
            {
                //will stay
                Id = 3,
                Price = 200,
                Quantity = 3
            });
            tierPrices.Add(new TierPrice
            {
                //will stay
                Id = 4,
                Price = 250,
                Quantity = 4
            });
            tierPrices.Add(new TierPrice
            {
                //will be removed
                Id = 5,
                Price = 300,
                Quantity = 4
            });
            tierPrices.Add(new TierPrice
            {
                //will stay
                Id = 6,
                Price = 350,
                Quantity = 5
            });

            tierPrices.RemoveDuplicatedQuantities();

            tierPrices.FirstOrDefault(x => x.Id == 1).ShouldBeNull();
            tierPrices.FirstOrDefault(x => x.Id == 2).ShouldNotBeNull();
            tierPrices.FirstOrDefault(x => x.Id == 3).ShouldNotBeNull();
            tierPrices.FirstOrDefault(x => x.Id == 4).ShouldNotBeNull();
            tierPrices.FirstOrDefault(x => x.Id == 5).ShouldBeNull();
            tierPrices.FirstOrDefault(x => x.Id == 6).ShouldNotBeNull();
        }
      public void CreatesNewListOfTournamentEvents()
      {
        //Arrange
        persistedTournaments = new List<Tournament>();
        persistedTournamentEvents = new List<TournamentEvent>();

        this.webRepository = BuildWebRepository.Create()
          .HasSingleAPITennisTourCalendar();

        this.webRepositoryProvider = BuildWebRepositoryProvider.Create()
          .ReturnsSpecificWebRepository(webRepository.Object);

        this.fixtureRepository = BuildFixtureRepository.Create()
          .HasNoPersistedTournamentEvent()
          .HasAPersistedCompetition()
          .CanAddTournamentEvent(persistedTournamentEvents)
          .CanAddTournament(persistedTournaments);

        //Act
        var fixtureStategy = new TestableTennisFixtureStrategy(this.fixtureRepository, 
          this.storedProcRepository, this.webRepositoryProvider);

        var tournamentEvents = fixtureStategy.UpdateTournamentEvents();
        var tournamentEvent = tournamentEvents.FirstOrDefault();
        var persistedTournament = persistedTournaments.FirstOrDefault();
        var persistedTournamentEvent = persistedTournamentEvents.FirstOrDefault();
                
        //Assert
        //Returned tournament event
        Assert.AreEqual(1, tournamentEvents.Count());
        Assert.AreEqual("Tóurnament Name (2013)", tournamentEvent.EventName);
        Assert.AreEqual(new DateTime(2012, 12, 31), tournamentEvent.StartDate);
        Assert.AreEqual(new DateTime(2013, 01, 06), tournamentEvent.EndDate);
        Assert.IsTrue(tournamentEvent.TournamentInProgress);
        Assert.IsFalse(tournamentEvent.TournamentCompleted);

        //Persisted tournament event
        Assert.AreEqual(1, persistedTournamentEvents.Count());
        Assert.AreSame(tournamentEvent, persistedTournamentEvent);

        //Persisted tournament
        Assert.AreEqual(1, persistedTournaments.Count());
        Assert.AreEqual("Tóurnament Name", persistedTournament.TournamentName);
        Assert.AreEqual("tournament-name", persistedTournament.Slug);
 
      }
Beispiel #12
0
        /// <summary>
        /// 駒の各移動先に対して、その手が指せるのかどうかをチェックします。
        /// </summary>
        private void CanMoveTo(Board board, BoardMove move,
                               List<Tuple<Square, bool>> availables)
                               
        {
            for (var file = 1; file <= Board.BoardSize; ++file)
            {
                for (var rank = 1; rank <= Board.BoardSize; ++rank)
                {
                    var sq = new Square(file, rank);
                    var avail = availables.FirstOrDefault(_ => _.Item1 == sq);

                    move.DstSquare = sq;
                    if (avail != null)
                    {
                        if (avail.Item2)
                        {
                            // 成りが必須の場合
                            move.IsPromote = false;
                            Assert.False(board.CanMove(move));

                            move.IsPromote = true;
                            Assert.True(board.CanMove(move));
                        }
                        else
                        {
                            // 成りが必須でない場合
                            move.IsPromote = false;
                            Assert.True(board.CanMove(move));

                            move.IsPromote = true;
                            Assert.AreEqual(Board.CanPromote(move), board.CanMove(move));
                        }
                    }
                    else
                    {
                        // そもそも移動できる場所ではない
                        move.IsPromote = false;
                        Assert.False(board.CanMove(move));

                        move.IsPromote = true;
                        Assert.False(board.CanMove(move));
                    }
                }
            }
        }
 public void RecalculateProjectByWeightTest()
 {
     var draws = new List<Drawing>
         {
             new Drawing {Id = 1, Count = 1, CountAll = 1, Weight = 1, WeightAll = 1},
             new Drawing {Id = 2, Count = 1, CountAll = 1, Weight = 1, WeightAll = 2},
             new Drawing {Id = 3, Count = 1, CountAll = 1, Weight = 7, WeightAll = 7},
             new Drawing {Id = 4, ParentId = 3, Count = 2, CountAll = 2, Weight = 2, WeightAll = 4},
             new Drawing {Id = 5, ParentId = 4, Count = 1, CountAll = 2, Weight = 1, WeightAll = 2},
             new Drawing {Id = 6, ParentId = 4, Count = 2, CountAll = 4, Weight = 5, WeightAll = 20},
             new Drawing {Id = 7, ParentId = 3, Count = 2, CountAll = 2, Weight = 5, WeightAll = 10},
         };
     var dm = new Mock<IClassDataManager<Drawing>>();
     dm.Setup(x => x.GetListCollection()).Returns(draws);
     dm.Setup(x => x.GetListCollection(It.IsAny<Func<Drawing, bool>>())).Returns<Func<Drawing, bool>>(x => draws.Where(x).ToList());
     dm.Setup(x => x.GetDocument(It.IsAny<int?>())).Returns<int?>(x => draws.FirstOrDefault(y => y.Id == x));
     var hellper = new DrawingsCalculateHelper();
     draws[4].Weight = 7;
     Assert.DoesNotThrow(() => hellper.RecalculateProjectByWeight(draws[4], dm.Object));
     Assert.AreEqual(44, draws[2].WeightAll);
     Assert.AreEqual(1, draws[0].WeightAll);
     Assert.AreEqual(34, draws[3].WeightAll);
 }
        public void Index_GivenAllUsersReturnedFromRepository_ShouldReturnViewWithMapModel()
        {
            //---------------Set up test pack-------------------
            var borrowersItem = new BorrowerItemBuilder()
                .WithRandomProps()
                .WithDateReturnedAsNull()
                .Build();
            var borrowersItems = new List<BorrowersItem>() { borrowersItem };
            var repository = Substitute.For<IBorrowerItemRepository>();
            repository.GetAll().Returns(borrowersItems);

            var borrowerItemRowViewModels = new List<BorrowerItemRowViewModel> { new BorrowerItemRowViewModel() };

            var mappingEngine =Substitute.For<IMappingEngine>();

            mappingEngine.Map<IEnumerable<BorrowerItemRowViewModel>>(borrowersItems)
                .Returns(borrowerItemRowViewModels);
            var borrowerItemRowViewModel = borrowerItemRowViewModels.FirstOrDefault();
            borrowerItemRowViewModel.Id = borrowersItem.Id;
            borrowerItemRowViewModel.BorrowerId = borrowersItem.BorrowerId;
            borrowerItemRowViewModel.ItemDescription = borrowersItem.Item.Description;
            borrowerItemRowViewModel.DateBorrowed = borrowersItem.DateBorrowed;
            borrowerItemRowViewModel.DateReturned = borrowersItem.DateReturned;


            var controller = CreateBuilder()
                .WithBorrowerItemRepository(repository)
                .WithMappingEngine(mappingEngine)
                .Build();
            //---------------Assert Precondition----------------
            //---------------Execute Test ----------------------
            var result = controller.Index() as ViewResult;
            //---------------Test Result -----------------------
            Assert.IsNotNull(result);
            var viewModels = result.Model as IEnumerable<BorrowerItemRowViewModel>;
            CollectionAssert.AreEqual(borrowerItemRowViewModels, viewModels);
        }
        public void LoadObject_With_IEnumerableProperty()
        {
            var @object = new ClassWithSimpleClassList();
            @object.Id = 1;
            @object.Objects = new List<SimpleClass>
            {
                new SimpleClass { Id = 1, Name = "object 1" },
                new SimpleClass { Id = 2, Name = "object 2" },
                new SimpleClass { Id = 3, Name = "object 3" },
            };

            var newList = new List<SimpleClass>
            {
                new SimpleClass { Id = 1, Name = "object 1 new" },
                new SimpleClass { Id = 2, Name = "object 2 new" },
                new SimpleClass { Id = 3, Name = "object 3 new" },
            };

            _objectInspector.LoadObject(@object, (value) =>
            {
                var result = value;
                var item = value as SimpleClass;
                if (item != null)
                {
                    result = newList.FirstOrDefault(p => p.Id == item.Id);
                }

                return result;
            });

            Assert.AreSame(newList[0], @object.Objects[0]);
            Assert.AreSame(newList[1], @object.Objects[1]);
            Assert.AreSame(newList[2], @object.Objects[2]);
        }
        public void CreatePatient_BaselineVisit_FormsVerification()
        {
            //Arrange
            var doctor = new User() {Id = 15, Role = ClinicalStudyRoles.Doctor, Patients = new List<Patient>()};
            var vitalsFormDatas = new List<VitalsFormData>();
            var demogFormDatas = new List<DemographicFormData>();
            vitalsFormDataRepository
                .Setup(r => r.Add(It.IsAny<VitalsFormData>()))
                .Callback<VitalsFormData>(data => vitalsFormDatas.Add(data));
            demogFormDataRepository
                .Setup(r => r.Add(It.IsAny<DemographicFormData>()))
                .Callback<DemographicFormData>(data => demogFormDatas.Add(data));

            //Act
            var result = studyDesign.CreatePatient(doctor);
            //Assert
            Assert.That(result, Is.Not.Null, "Patient was created");
            Assert.That(result.Visits, Is.Not.Null, "Visits were not created");
            var visit = result.Visits.FirstOrDefault(v => v.VisitType == VisitType.Baseline);
            Assert.That(visit, Is.Not.Null, "Baseline visit was not scheduled");
            Assert.That(visit.Forms, Is.Not.Null, "Forms were not created");

            //demographics CRF
            var demographicsForm = visit.Forms.FirstOrDefault(f => f.FormType == FormType.Demographics);
            Assert.That(demographicsForm, Is.Not.Null);
            Assert.That(demographicsForm.Caption, Is.EqualTo("Demographics"));
            Assert.That(demographicsForm.FormState, Is.EqualTo(FormState.Incomplete));
            Assert.That(demographicsForm.FormType, Is.EqualTo(FormType.Demographics));
            Assert.That(demographicsForm.OrderNo, Is.EqualTo(0));
            formRepository.Verify(r => r.Add(demographicsForm), Times.Once());

            var demogFormData = demogFormDatas.FirstOrDefault(data => data.Form == demographicsForm);
            Assert.That(demogFormData, Is.Not.Null);
            Assert.That(demogFormData.DateOfBirth, Is.Not.Null);
            Assert.That(demogFormData.Race, Is.Not.Null);
            Assert.That(demogFormData.Sex, Is.Not.Null);
            Assert.That(demogFormData.Other, Is.Not.Null);

            //vitals CRF
            var vitalsForm = visit.Forms.FirstOrDefault(f => f.FormType == FormType.Vitals);
            Assert.That(vitalsForm, Is.Not.Null);
            Assert.That(vitalsForm.Caption, Is.EqualTo("Vitals"));
            Assert.That(vitalsForm.FormState, Is.EqualTo(FormState.Incomplete));
            Assert.That(vitalsForm.FormType, Is.EqualTo(FormType.Vitals));
            Assert.That(vitalsForm.OrderNo, Is.EqualTo(1));
            formRepository.Verify(r => r.Add(vitalsForm), Times.Once());

            var vitalsFormData = vitalsFormDatas.FirstOrDefault(data => data.Form == vitalsForm);
            Assert.That(vitalsFormData, Is.Not.Null);
            Assert.That(vitalsFormData.ActualTime, Is.Not.Null);
            Assert.That(vitalsFormData.BloodPressureDiastolic, Is.Not.Null);
            Assert.That(vitalsFormData.BloodPressureSystolic, Is.Not.Null);
            Assert.That(vitalsFormData.HeartRate, Is.Not.Null);
            Assert.That(vitalsFormData.Height, Is.Not.Null);
            Assert.That(vitalsFormData.Weight, Is.Not.Null);
            Assert.That(vitalsFormData.Temperature, Is.Not.Null);
        }
            public void UsesMetadataAttributeIfAvaialble()
            {
                var moduleInspector = new Mock<IModuleInspector>();
                ITaskManager sut = new TaskManager(moduleInspector.Object);
                var data = new List<Type>()
				{
					typeof(TestTaskWithMetadata)
				};
                moduleInspector.Setup(i => i.FindTypesImplementingInterfaces(typeof(IDeployTaskDefinition))).Returns(data);

                var result = sut.GetAvailableTaskList();

                moduleInspector.Verify(i => i.FindTypesImplementingInterfaces(typeof(IDeployTaskDefinition)), Times.Once());
                Assert.AreEqual(data.Count, result.Count);
                foreach (var metadata in result)
                {
                    var type = data.FirstOrDefault(i=>i.FullName == metadata.TaskTypeName);
                    Assert.IsNotNull(type);
                    string displayName = ((TaskDefinitionMetadataAttribute)type.GetCustomAttributes(typeof(TaskDefinitionMetadataAttribute), true).First()).TaskName;
                    Assert.AreEqual(displayName, metadata.TaskDisplayName);
                }

            }
        public void Init()
        {
            var unitOfWork = new Mock<IUnitOfWork>();
            var receive = new List<Receive>()
                              {
                                  new Receive()
                                      {
                                          ReceiveID = Guid.NewGuid(),
                                          PartitionID = 0,
                                          GRN = "001",
                                          CommodityTypeID = 1,
                                          SourceDonorID = 1,
                                          ResponsibleDonorID = 1,
                                          TransporterID = 1,
                                          PlateNo_Prime = "00001",
                                          PlateNo_Trailer = "00002",
                                          DriverName = "Dawit",
                                          WeightBridgeTicketNumber = "012",
                                          WeightBeforeUnloading = 1200,
                                          WeightAfterUnloading = 0,
                                          ReceiptDate = DateTime.Today,
                                          UserProfileID = 1,
                                          CreatedDate = DateTime.Today,
                                          WayBillNo = "001",
                                          CommoditySourceID = 1,
                                          Remark = "this a a test receive",
                                          VesselName = "002",
                                          ReceivedByStoreMan = "Abebe",
                                          PortName = "Dire Dawa",
                                          PurchaseOrder = "002",
                                          SupplierName = "WFP",
                                          ReceiptAllocationID = Guid.NewGuid(),
                                          CommoditySource = new CommoditySource()
                                                                {
                                                                    CommoditySourceID = 1,
                                                                    Name = "Donatiion"

                                                                },
                                          CommodityType = new CommodityType()
                                                              {
                                                                  CommodityTypeID = 1,
                                                                  Name = "FOOD"
                                                              },
                                          Hub = new Models.Hubs.Hub()
                                                    {
                                                        HubID = 1,
                                                        Name = "Kombelcha"
                                                    },
                                          ReceiveDetails = new Collection<ReceiveDetail>()
                                                               {
                                                                   new ReceiveDetail()
                                                                       {
                                                                           ReceiveDetailID = Guid.NewGuid(),
                                                                           PartitionID = 0,
                                                                           ReceiveID = Guid.NewGuid(),
                                                                           //should be given the
                                                                           TransactionGroupID = null,
                                                                           CommodityID = 1,
                                                                           SentQuantityInUnit = 1200,
                                                                           UnitID = 1,
                                                                           SentQuantityInMT = 1200,
                                                                           Description = "this is a test",
                                                                           Commodity = new Commodity()
                                                                                           {
                                                                                               CommodityID = 1,
                                                                                               Name = "Pulse"
                                                                                           },
                                                                           Unit = new Unit()
                                                                                      {
                                                                                          UnitID = 1,
                                                                                          Name = "kg"
                                                                                      }

                                                                       }
                                                               }

                                      }

                              };

            var reieveRepository = new Mock<IGenericRepository<Receive>>();
            reieveRepository.Setup(
                t =>
                t.Get(It.IsAny<Expression<Func<Receive, bool>>>(),
                      It.IsAny<Func<IQueryable<Receive>, IOrderedQueryable<Receive>>>(),
                      It.IsAny<string>())).Returns(receive);
            var commodity = new List<Commodity>()
                                {
                                    new Commodity()
                                        {
                                            CommodityID = 1,
                                            Name = "Pulse"
                                        },
                                    new Commodity()
                                        {
                                            CommodityID = 2,
                                            Name = "Cereal"
                                        }
                                };
            var CommodityRepository = new Mock<IGenericRepository<Commodity>>();
            CommodityRepository.Setup(t => t.FindById(It.IsAny<int>())).Returns(
                (int id) => commodity.FirstOrDefault(t => t.CommodityID == id));

            var commodityType = new List<CommodityType>()
                                    {
                                        new CommodityType()
                                            {

                                                CommodityTypeID = 1,
                                                Name = "Food"
                                            },
                                            new CommodityType()
                                                {
                                                    CommodityTypeID = 2,
                                                    Name = "Non-Food"
                                                }
                                    };

            var commodityTypeRepository =new  Mock<IGenericRepository<CommodityType>>();
            commodityTypeRepository.Setup(t => t.FindById(It.IsAny<int>())).Returns((int id) => commodityType.
                                                                                                 FirstOrDefault(t => t.CommodityTypeID == id));

            commodityTypeRepository.Setup(t =>
                t.Get(It.IsAny<Expression<Func<CommodityType, bool>>>(),
                      It.IsAny<Func<IQueryable<CommodityType>, IOrderedQueryable<CommodityType>>>(),
                      It.IsAny<string>())).Returns(commodityType);

            var shippingInstructioncodes = new List<ShippingInstruction>()
                                               {
                                                   new ShippingInstruction()
                                                       {
                                                           ShippingInstructionID = 1,
                                                           Value = "si-0002",
                                                       },
                                                   new ShippingInstruction()
                                                       {
                                                           ShippingInstructionID = 2,
                                                           Value = "si-003",
                                                       }
                                               };

            Mock<IShippingInstructionService> MockShippingInstructionService = new Mock<IShippingInstructionService>();
            MockShippingInstructionService.Setup(s => s.GetSINumberIdWithCreate("si-0002")).Returns(shippingInstructioncodes.FirstOrDefault());

            var shippingInstructionRepository = new Mock<IGenericRepository<ShippingInstruction>>();

            shippingInstructionRepository.Setup(
                t =>
                t.Get(It.IsAny<Expression<Func<ShippingInstruction, bool>>>(),
                      It.IsAny<Func<IQueryable<ShippingInstruction>, IOrderedQueryable<ShippingInstruction>>>(),
                      It.IsAny<string>())).Returns(shippingInstructioncodes);

            var account = new List<Account>()
                              {
                                  new Account()
                                      {
                                          AccountID = 1,
                                          EntityID = 1,
                                          EntityType = "Sample Entity"
                                      }
                              };

            var accountRepository = new Mock<IGenericRepository<Account>>();
            var MockAccountService = new Mock<IAccountService>();
            MockAccountService.Setup(a => a.GetAccountIdWithCreate("Sample Entity", 1)).Returns(1);

             var projectCodes = new List<ProjectCode>()
                                   {
                                       new ProjectCode()
                                           {
                                               ProjectCodeID = 1,
                                               Value = "pro-001"
                                           },
                                       new ProjectCode()
                                           {
                                               ProjectCodeID = 1,
                                               Value = "0001246"
                                           },
                                   };

            var MockProjectCodeService = new Mock<IProjectCodeService>();
            MockProjectCodeService.Setup(p => p.GetProjectCodeIdWIthCreate("pro-001")).Returns(projectCodes.FirstOrDefault());

            var projectCodeRepositoy = new Mock<IGenericRepository<ProjectCode>>();
            projectCodeRepositoy.Setup(
                t =>
                t.Get(It.IsAny<Expression<Func<ProjectCode, bool>>>(),
                      It.IsAny<Func<IQueryable<ProjectCode>, IOrderedQueryable<ProjectCode>>>(),
                      It.IsAny<string>())).Returns(projectCodes);

            shippingInstructionService = MockShippingInstructionService.Object;
            unitOfWork.Setup(t => t.ReceiveRepository).Returns(reieveRepository.Object);
            unitOfWork.Setup(t => t.CommodityTypeRepository).Returns(commodityTypeRepository.Object);
            unitOfWork.Setup(t => t.CommodityRepository).Returns(CommodityRepository.Object);
            _accountTransactionService = new TransactionService(unitOfWork.Object, MockAccountService.Object, shippingInstructionService, MockProjectCodeService.Object);
        }
        public void GetDeltaErrorsTest()
        {
            var fixtureOneId = "fixtureOne";

            var resourceOne = new Mock<IResourceFacade>();

            resourceOne.Setup(x => x.Id).Returns(fixtureOneId);
            resourceOne.Setup(x => x.Content).Returns(new Summary());
            resourceOne.Setup(x => x.MatchStatus).Returns(MatchStatus.InRunning);
            resourceOne.Setup(x => x.Sport).Returns("Football");
            resourceOne.SetupSequence(x => x.GetSnapshot())
                .Returns(FixtureJsonHelper.ToJson(GetSnapshotWithMarkets(fixtureOneId)))
                .Returns(String.Empty)
                .Returns(FixtureJsonHelper.ToJson(GetSnapshotWithMarkets(fixtureOneId, 10, 3)));

            resourceOne.Setup(x => x.StartStreaming()).Raises(r => r.StreamConnected += null, EventArgs.Empty);

            _supervisor.CreateStreamListener(resourceOne.Object, _plugin.Object);

            var fixtureOverviews = _supervisor.GetFixtures();
            fixtureOverviews.Should().NotBeNullOrEmpty();
            fixtureOverviews.Should().Contain(f => f.Id == fixtureOneId);

            _supervisor.StartStreaming(fixtureOneId);

            var streamUpdate = new Fixture
            {
                Id = fixtureOneId,
                Sequence = 2,
                //Epoch increased
                Epoch = 10,
                MatchStatus = ((int)MatchStatus.InRunning).ToString()
            };

            var deltas = new List<IFixtureOverviewDelta>();

            using (var subscriber = _supervisor.GetFixtureOverviewStream().Subscribe(deltas.Add))
            {
                //in order to generate error the resource is setup to return empty snapshot
                //the snapshot should be taken because epoch is changed
                SendStreamUpdate(streamUpdate);
                
                deltas.Should().NotBeEmpty();
                deltas.FirstOrDefault(d => d.LastError != null).Should().NotBeNull();

                //error was resolved with a further snapshot
                deltas.FirstOrDefault(d => d.LastError != null && !d.LastError.IsErrored).Should().NotBeNull();
            }
        }
        public void GetTeamByID()
        {
            var result = _repo.GetTeamByID(5);

            List<Team> teamsReturned = new List<Team>();

            using (SqlConnection cn = new SqlConnection(Settings.ConnectionString))
            {
                teamsReturned = cn.Query<Team>("select * from teams").ToList();
            }

            var expected = teamsReturned.FirstOrDefault(t => t.TeamID == 5);

            Assert.AreEqual(expected.TeamName, result.TeamName);
        }
        public void When_Search_Then_map_returned_entities_to_dtos()
        {
            //given
            var actionPlans = new List<ActionPlan>()
                                  {
                                      new ActionPlan()
                                          {
                                              Id = 1234L,
                                              CompanyId = 1L,
                                              Title = "Action Plan1",
                                              Site = new Site
                                                         {
                                                             SiteId = 1L
                                                         },
                                              DateOfVisit = DateTime.Now,
                                              VisitBy = "Consultant1",
                                              SubmittedOn = DateTime.Now.AddDays(-1),
                                              AreasVisited = "Area 1",
                                              AreasNotVisited = "Area 2"
                                          }
                                  };

            var target = GetTarget();

            _actionPlanRepository.Setup(
                x =>
                x.Search(It.IsAny<IList<long>>(), It.IsAny<long>(), It.IsAny<long?>(), It.IsAny<long?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<bool>(), 
                        It.IsAny<int>(), It.IsAny<int>(),
                         It.IsAny<ActionPlanOrderByColumn>(),
                         It.IsAny<bool>()))
                         .Returns(actionPlans);

            //when
            var result = target.Search(new SearchActionPlanRequest());
            
            //then
            Assert.That(result.FirstOrDefault().Id, Is.EqualTo(actionPlans.FirstOrDefault().Id));
            Assert.That(result.FirstOrDefault().CompanyId, Is.EqualTo(actionPlans.FirstOrDefault().CompanyId));
            Assert.That(result.FirstOrDefault().Title, Is.EqualTo(actionPlans.FirstOrDefault().Title));
            Assert.That(result.FirstOrDefault().Site.Id, Is.EqualTo(actionPlans.FirstOrDefault().Site.Id));
            Assert.That(result.FirstOrDefault().DateOfVisit, Is.EqualTo(actionPlans.FirstOrDefault().DateOfVisit));
            Assert.That(result.FirstOrDefault().VisitBy, Is.EqualTo(actionPlans.FirstOrDefault().VisitBy));
            Assert.That(result.FirstOrDefault().SubmittedOn, Is.EqualTo(actionPlans.FirstOrDefault().SubmittedOn));
            Assert.That(result.FirstOrDefault().AreasVisited, Is.EqualTo(actionPlans.FirstOrDefault().AreasVisited));
            Assert.That(result.FirstOrDefault().AreasNotVisited, Is.EqualTo(actionPlans.FirstOrDefault().AreasNotVisited));
        }
        public void CheckErrorsAreTrackedTest()
        {
            var fixtureOneId = "fixtureOne";
            
            _resource.Setup(x => x.Id).Returns(fixtureOneId);
            _resource.Setup(x => x.Content).Returns(new Summary());
            _resource.Setup(x => x.MatchStatus).Returns(MatchStatus.InRunning);
            _resource.SetupSequence(x => x.GetSnapshot())
                .Returns(FixtureJsonHelper.ToJson(GetSnapshotWithMarkets(fixtureOneId)))
                .Returns(String.Empty)
                .Returns(String.Empty)
                .Returns(String.Empty)
                .Returns(String.Empty)
                .Returns(FixtureJsonHelper.ToJson(GetSnapshotWithMarkets(fixtureOneId, 10, 15)));

            _resource.Setup(x => x.StartStreaming()).Raises(r => r.StreamConnected += null, EventArgs.Empty);

            _supervisor.CreateStreamListener(_resource.Object, _plugin.Object);

            var fixtureOverviews = _supervisor.GetFixtures();
            fixtureOverviews.Should().NotBeNullOrEmpty();
            fixtureOverviews.Should().Contain(f => f.Id == fixtureOneId);

            _supervisor.StartStreaming(fixtureOneId);

            var streamUpdate = new Fixture
            {
                Id = fixtureOneId,
                Sequence = 2,
                //Epoch increased
                Epoch = 10,
                MatchStatus = ((int)MatchStatus.InRunning).ToString()
            };

            var deltas = new List<IFixtureOverviewDelta>();

            using (var subscriber = _supervisor.GetFixtureOverviewStream().Subscribe(deltas.Add))
            {
                Enumerable.Range(3, 10).ForEach(s =>
                {
                    streamUpdate.Sequence = s;
                    SendStreamUpdate(streamUpdate);
                });
            }

            var fixtureOverview = _supervisor.GetFixtureOverview(fixtureOneId);
            fixtureOverview.GetErrorsAudit().Should().NotBeEmpty();
            var errorsAudit = fixtureOverview.GetErrorsAudit();

            //at least 4 failed snapshots
            errorsAudit.Count().Should().Be(4);

            //the final snapshot sholud have succeeded
            fixtureOverview.LastError.IsErrored.Should().BeFalse();

            //there should be delta notification with LastError update IsErrored = false
            deltas.FirstOrDefault(d=> 
                d.LastError != null 
                && d.LastError.ResolvedAt == fixtureOverview.LastError.ResolvedAt 
                && d.LastError.Sequence == fixtureOverview.LastError.Sequence).Should().NotBeNull();
        }
 private string arg(List<KeyValuePair<string,string>> list, string name)
 {
     return list.FirstOrDefault(x => x.Key.Equals(name)).Value;
 }
        public void DoesReceiptTransactionSave()
        {
            var receiveViewModel = new List<ReceiveViewModel>()
                                       {
                                           new ReceiveViewModel()
                                               {
            ChangeStoreManPermanently = false,
            Commodities = new List<Commodity>()
                  {
                      new Commodity()
                          {
                              CommodityID = 1,
                              Name = "Pulse"
                          }
                  },CommodityGrades = new List<CommodityGrade>()
                                          {
                                              new CommodityGrade()
                                                  {
                                                      CommodityGradeID = 1,
                                                      Name = "one",
                                                      Description = ""
                                                  }
                                          },CommoditySourceID = 1,
                                          CommoditySourceText = "Donation",
                                          CommoditySources = new List<CommoditySource>()
                                                                 {
                                                                     new CommoditySource()
                                                                         {
                                                                             CommoditySourceID = 1,
                                                                             Name = "Donation"
                                                                         }
                                                                 },CommodityTypeID = 1,
                                                                 CommodityTypes = new List<CommodityType>()
                                                                                      {
                                                                                          new CommodityType()
                                                                                              {
                                                                                                  CommodityTypeID = 1,
                                                                                                  Name = "Food"
                                                                                              }
                                                                                      },CreatedDate = DateTime.Today,
                                                                                      Donors = new List<Donor>()
                                                                                                   {
                                                                                                       new Donor()
                                                                                                           {
                                                                                                               DonorID = 1,
                                                                                                               Name = "WFP"
                                                                                                           }
                                                                                                   },
                                                                                                   DriverName = "Dawit",
                                                                                                    GRN = "grn-001",
                                                                                                    HubID = 1,
                                                                                                    Hubs = new List<Models.Hubs.Hub>()
                                                                                                               {
                                                                                                                   new Models.Hubs.Hub()
                                                                                                                       {
                                                                                                                           HubID = 1,
                                                                                                                           Name = "Kombelcha"
                                                                                                                       }
                                                                                                               }, ReceiptAllocationID = Guid.NewGuid(),
                                                                                                               PurchaseOrder = "p-001",
                                                                                                               ProjectNumber = "pro-001",
                                                                                                               Programs = new List<Program>()
                                                                                                                              {
                                                                                                                                  new Program()
                                                                                                                                      {
                                                                                                                                          ProgramID = 1,
                                                                                                                                          Name = "Relief"
                                                                                                                                      }
                                                                                                                              },ProgramID = 1,
                                                                                                                              PortName = "Kombelacha",
                                                                                                                              PlateNo_Trailer = "trailer 001",
                                                                                                                              PlateNo_Prime = "prime 002",
                                                                                                                              JSONUpdatedCommodities = "",
                                                                                                                              JSONPrev = "",
                                                                                                                              JSONInsertedCommodities  ="",
                                                                                                                              JSONDeletedCommodities = "",
                                                                                                                              IsEditMode = false,
                                                                                                                              ReceiptDate = DateTime.Today,
                                                                                                                              ReceiveDetails = new List<ReceiveDetailViewModel>()
                                                                                                                                                   {
                                                                                                                                                       new ReceiveDetailViewModel()
                                                                                                                                                           {
                                                                                                                                                                CommodityGradeID = 1,
                                                                                                                                                                CommodityID = 1,
                                                                                                                                                                Description = "",
                                                                                                                                                                ReceiveDetailCounter = 1,
                                                                                                                                                                ReceiveDetailID = Guid.NewGuid(),
                                                                                                                                                                ReceiveID = Guid.Parse("00000000-0000-0000-0000-000000000000"),
                                                                                                                                                                ReceivedQuantityInMT = 1200,
                                                                                                                                                                ReceivedQuantityInUnit = 12,
                                                                                                                                                                SentQuantityInMT = 1200,
                                                                                                                                                                SentQuantityInUnit = 12,
                                                                                                                                                                UnitID = 1

                                                                                                                                                           }
                                                                                                                                                   },ReceiveID = Guid.Parse("00000000-0000-0000-0000-000000000000"),
                                                                                                                                                    ReceivedByStoreMan = "Dawit",
                                                                                                                                                    Remark = "A test View Model",
                                                                                                                                                    ResponsibleDonorID = 1,
                                                                                                                                                    SINumber = "si-0002",
                                                                                                                                                    Stores = new List<Store>()
                                                                                                                                                                 {
                                                                                                                                                                     new Store()
                                                                                                                                                                         {
                                                                                                                                                                             Hub = new Models.Hubs.Hub()
                                                                                                                                                                                       {
                                                                                                                                                                                           HubID = 1,
                                                                                                                                                                                           Name = "DireDawa"
                                                                                                                                                                                       },Name = "Sample Store",
                                                                                                                                                                                       HubID = 1,
                                                                                                                                                                                       IsActive = true,
                                                                                                                                                                                       IsTemporary = false,
                                                                                                                                                                                       Number = 2,
                                                                                                                                                                                       StackCount = 5,
                                                                                                                                                                                      StoreID = 1,
                                                                                                                                                                                      StoreManName = "Sisay",

                                                                                                                                                                         }
                                                                                                                                                                 },StoreID = 1,
                                                                                                                                                                 Stacks = new List<AdminUnitItem>()
                                                                                                                                                                              {
                                                                                                                                                                                  new AdminUnitItem()
                                                                                                                                                                                      {
                                                                                                                                                                                          Id = 1,
                                                                                                                                                                                          Name = "Abebe"
                                                                                                                                                                                      }
                                                                                                                                                                              },StackNumber = 5,
                                                                                                                                                                              SourceHubText = "",
                                                                                                                                                                              SourceHubID = 1,
                                                                                                                                                                              SourceDonorID = 1,
                                                                                                                                                                              SupplierName = "Tana",
                                                                                                                                                                              TicketNumber = "t-001",
                                                                                                                                                                              TransporterID = 1,
                                                                                                                                                                              Transporters = new List<Transporter>()
                                                                                                                                                                                                 {
                                                                                                                                                                                                     new Transporter()
                                                                                                                                                                                                         {
                                                                                                                                                                                                             TransporterID = 1,
                                                                                                                                                                                                             Name = "tana",

                                                                                                                                                                                                         }
                                                                                                                                                                                                 },
                                                                                                                                                                                                               UserProfileID = 1,
                                                                                                                                                                                                               VesselName = "Vessele Name",
                                                                                                                                                                                                               WayBillNo = "wayBill - 001",
                                                                                                                                                                                                               WeightAfterUnloading = 0,
                                                                                                                                                                                                               WeightBeforeUnloading = 1200

                                               }
                                       };

            var userProfile = new List<UserProfile>()
                                  {
                                      new UserProfile()
                                          {
                                              UserProfileID = 1,
                                              UserName = "******",
                                              FirstName = "Admin",
                                              DefaultHub = new Models.Hubs.Hub()
                                                               {
                                                                   HubID = 1,
                                                                   Name = "DireDawa"
                                                               }
                                          }
                                  };
            bool result = _accountTransactionService.SaveReceiptTransaction(receiveViewModel.FirstOrDefault(), userProfile.FirstOrDefault());
        }
        public void DeletarOrcamentoComDoisOrcamentosNaListaPrimeiroItemDaListaDeveTerNomeDeVersaoUm()
        {
            ServicoOrcamentoOperacionalVersao servico = new ServicoOrcamentoOperacionalVersao();
            IOrcamentos orcamentos = MockRepository.GenerateMock<IOrcamentos>();
            orcamentos.Expect(o => o.Salvar(null)).IgnoreArguments();
            orcamentos.Expect(o => o.Deletar(null)).IgnoreArguments();
            servico.Orcamentos = orcamentos;

            Departamento departamento = new Setor("Barra dor");
            CentroDeCusto centroDeCusto = new CentroDeCusto("centroDeCusto");
            departamento.AdicionarCentroDeCusto(centroDeCusto);

            var orcamento = new OrcamentoOperacionalVersao(departamento, centroDeCusto, 2014);

            var orcamentosLista = new List<Orcamento.Domain.Orcamento>();
            orcamentosLista.Add(new OrcamentoOperacionalVersao(departamento, centroDeCusto, 2014));
            orcamentosLista.Add(orcamento);
            servico.DeletarOrcamento(orcamento, orcamentosLista, departamento);

            Assert.IsTrue(orcamentosLista.FirstOrDefault().NomeOrcamento == "Versão1");
        }
		public void Execute_OneProjectPackage_PackageRetargetingMessageIsLogged ()
		{
			CreateAction ();
			AddPackageToProjectAndSourceRepository ("MyPackage");
			string expectedMessage = GettextCatalog.GetString ("Retargeting packages...{0}", Environment.NewLine);
			var messages = new List<string> ();
			packageManagementEvents.PackageOperationMessageLogged += (sender, e) => {
				messages.Add (e.Message.ToString ());
			};

			action.Execute ();

			Assert.AreEqual (expectedMessage, messages.FirstOrDefault ());
		}
				private void SetPermission(DeployProject project, DeployEnvironment environment, List<DeployProjectRoleEnvironmentPermission> list, EnumPermissionAccess access)
				{
					foreach(var x in project.EnvironmentList)
					{
						var item = list.FirstOrDefault(i=>i.EnvironmentId == x.Id);
						if(item == null)
						{
							item = new DeployProjectRoleEnvironmentPermission
							{
                                //Id = this.Fixture.Create<string>(),
                                //ProjectId = project.Id,
								EnvironmentId = x.Id,
								EnvironmentName = x.CreatedByUserName
							};
							list.Add(item);
						}
					}
					list.First(i=>i.EnvironmentId == environment.Id).Access = access;
				}
        public void CreatePatient_1stDayVisit_FormsVerification()
        {
            //Arrange
            var doctor = new User() {Id = 15, Role = ClinicalStudyRoles.Doctor, Patients = new List<Patient>()};
            var vitalsFormDatas = new List<VitalsFormData>();
            var happinessFormDatas = new List<HappinessFormData>();
            var electrocardiogramFormDatas = new List<ElectrocardiogramFormData>();
            vitalsFormDataRepository
                .Setup(r => r.Add(It.IsAny<VitalsFormData>()))
                .Callback<VitalsFormData>(data => vitalsFormDatas.Add(data));
            happinessFormDataRepository
                .Setup(r => r.Add(It.IsAny<HappinessFormData>()))
                .Callback<HappinessFormData>(data => happinessFormDatas.Add(data));
            electroFormDataRepository
                .Setup(r => r.Add(It.IsAny<ElectrocardiogramFormData>()))
                .Callback<ElectrocardiogramFormData>(data => electrocardiogramFormDatas.Add(data));

            //Act
            var result = studyDesign.CreatePatient(doctor);
            //Assert
            Assert.That(result, Is.Not.Null, "Patient was created");
            Assert.That(result.Visits, Is.Not.Null, "Visits were not created");
            var visit = result.Visits.FirstOrDefault(v => v.VisitType == VisitType.Day1);
            Assert.That(visit, Is.Not.Null, "Baseline visit was not scheduled");
            Assert.That(visit.Forms, Is.Not.Null, "Forms were not created");

            //happiness CRF
            var happinessForm = visit.Forms.FirstOrDefault(f => f.FormType == FormType.Happiness);
            Assert.That(happinessForm, Is.Not.Null);
            Assert.That(happinessForm.Caption, Is.EqualTo("Happiness"));
            Assert.That(happinessForm.FormState, Is.EqualTo(FormState.Incomplete));
            Assert.That(happinessForm.FormType, Is.EqualTo(FormType.Happiness));
            Assert.That(happinessForm.OrderNo, Is.EqualTo(0));
            formRepository.Verify(r => r.Add(happinessForm), Times.Once());

            var happinessFormData = happinessFormDatas.FirstOrDefault(data => data.Form == happinessForm);
            Assert.That(happinessFormData, Is.Not.Null);
            Assert.That(happinessFormData.HappinessLevel, Is.Not.Null);

            //electrocardiogram CRF
            var electroForm = visit.Forms.FirstOrDefault(f => f.FormType == FormType.Electrocardiogram);
            Assert.That(electroForm, Is.Not.Null);
            Assert.That(electroForm.Caption, Is.EqualTo("Electrocardiogram"));
            Assert.That(electroForm.FormState, Is.EqualTo(FormState.Incomplete));
            Assert.That(electroForm.FormType, Is.EqualTo(FormType.Electrocardiogram));
            Assert.That(electroForm.OrderNo, Is.EqualTo(1));
            formRepository.Verify(r => r.Add(electroForm), Times.Once());

            var electrocardiogramFormData = electrocardiogramFormDatas.FirstOrDefault(data => data.Form == electroForm);
            Assert.That(electrocardiogramFormData, Is.Not.Null);
            Assert.That(electrocardiogramFormData.ElectrocardiogramActualTime, Is.Not.Null);
            Assert.That(electrocardiogramFormData.ElectrocardiogramAttachment, Is.Not.Null);

            //vitals CRF
            var vitalsForm = visit.Forms.FirstOrDefault(f => f.FormType == FormType.Vitals);
            Assert.That(vitalsForm, Is.Not.Null);
            Assert.That(vitalsForm.Caption, Is.EqualTo("Vitals"));
            Assert.That(vitalsForm.FormState, Is.EqualTo(FormState.Incomplete));
            Assert.That(vitalsForm.FormType, Is.EqualTo(FormType.Vitals));
            Assert.That(vitalsForm.OrderNo, Is.EqualTo(2));
            formRepository.Verify(r => r.Add(vitalsForm), Times.Once());

            var vitalsFormData = vitalsFormDatas.FirstOrDefault(data => data.Form == vitalsForm);
            Assert.That(vitalsFormData, Is.Not.Null);
            Assert.That(vitalsFormData.ActualTime, Is.Not.Null);
            Assert.That(vitalsFormData.BloodPressureDiastolic, Is.Not.Null);
            Assert.That(vitalsFormData.BloodPressureSystolic, Is.Not.Null);
            Assert.That(vitalsFormData.HeartRate, Is.Not.Null);
            Assert.That(vitalsFormData.Height, Is.Not.Null);
            Assert.That(vitalsFormData.Weight, Is.Not.Null);
            Assert.That(vitalsFormData.Temperature, Is.Not.Null);
        }
Beispiel #29
0
		protected void Read_XmlDocument (XamlReader r)
		{
			for (int i = 0; i < 3; i++) {
				r.Read ();
				Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1-" + i);
			}
			r.Read ();

			Assert.AreEqual (new XamlType (typeof (XmlDocument), r.SchemaContext), r.Type, "#2");
			r.Read ();
			var l = new List<XamlMember> ();
			while (r.NodeType == XamlNodeType.StartMember) {
			// It depends on XmlDocument's implenentation details. It fails on mono only because XmlDocument.SchemaInfo overrides both getter and setter.
			//for (int i = 0; i < 5; i++) {
			//	Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-" + i);
				l.Add (r.Member);
				r.Skip ();
			}
			Assert.IsNotNull (l.FirstOrDefault (m => m.Name == "Value"), "#4-1");
			Assert.IsNotNull (l.FirstOrDefault (m => m.Name == "InnerXml"), "#4-2");
			Assert.IsNotNull (l.FirstOrDefault (m => m.Name == "Prefix"), "#4-3");
			Assert.IsNotNull (l.FirstOrDefault (m => m.Name == "PreserveWhitespace"), "#4-4");
			Assert.IsNotNull (l.FirstOrDefault (m => m.Name == "Schemas"), "#4-5");
			Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#5");
			Assert.IsFalse (r.Read (), "#6");
		}
Beispiel #30
0
        private void ValidateMultipleFriends(List<UserProfile> friends)
        {
            var friend = friends.First();

            Assert.AreEqual("http://www.fitbit.com/images/profile/defaultProfile_100_male.gif", friend.Avatar);
            Assert.AreEqual("http://www.fitbit.com/images/profile/defaultProfile_150_male.gif", friend.Avatar150);
            Assert.AreEqual("GB", friend.Country);
            Assert.AreEqual(DateTime.Parse("1970-01-01"), friend.DateOfBirth);
            Assert.AreEqual("Andy", friend.DisplayName);
            Assert.AreEqual("242XXX", friend.EncodedId);
            Assert.AreEqual("Andy Fullname", friend.FullName);
            Assert.AreEqual(Gender.MALE, friend.Gender);
            Assert.AreEqual(155, friend.Height);
            Assert.AreEqual("en_GB", friend.Locale);
            Assert.AreEqual(DateTime.Parse("2010-12-25"), friend.MemberSince);
            Assert.AreEqual("", friend.Nickname);
            Assert.AreEqual(3600000, friend.OffsetFromUTCMillis);
            Assert.AreEqual("SUNDAY", friend.StartDayOfWeek);
            Assert.AreEqual(0, friend.StrideLengthRunning);
            Assert.AreEqual(0, friend.StrideLengthWalking);
            Assert.AreEqual("Europe/London", friend.Timezone);
            Assert.AreEqual(84.7, friend.Weight);

            friend = friends.FirstOrDefault(x => x.Gender == Gender.FEMALE);

            Assert.AreEqual("http://www.fitbit.com/images/profile/defaultProfile_100_female.gif", friend.Avatar);
            Assert.AreEqual("http://www.fitbit.com/images/profile/defaultProfile_150_female.gif", friend.Avatar150);
            Assert.AreEqual("GB", friend.Country);
            Assert.AreEqual(DateTime.Parse("1984-09-07"), friend.DateOfBirth);
            Assert.AreEqual("Laura", friend.DisplayName);
            Assert.AreEqual("24WXXX", friend.EncodedId);
            Assert.AreEqual("", friend.FullName);
            Assert.AreEqual(Gender.FEMALE, friend.Gender);
            Assert.AreEqual(165, friend.Height);
            Assert.AreEqual("en_GB", friend.Locale);
            Assert.AreEqual(DateTime.Parse("2013-02-01"), friend.MemberSince);
            Assert.AreEqual("", friend.Nickname);
            Assert.AreEqual(3600000, friend.OffsetFromUTCMillis);
            Assert.AreEqual("SUNDAY", friend.StartDayOfWeek);
            Assert.AreEqual(0, friend.StrideLengthRunning);
            Assert.AreEqual(0, friend.StrideLengthWalking);
            Assert.AreEqual("Europe/London", friend.Timezone);
            Assert.AreEqual(0, friend.Weight);

            friend = friends.Last();

            Assert.AreEqual("http://www.fitbit.com/images/profile/defaultProfile_100_male.gif", friend.Avatar);
            Assert.AreEqual("http://www.fitbit.com/images/profile/defaultProfile_150_male.gif", friend.Avatar150);
            Assert.AreEqual("GB", friend.Country);
            Assert.AreEqual(DateTime.Parse("1978-09-24"), friend.DateOfBirth);
            Assert.AreEqual("Michael", friend.DisplayName);
            Assert.AreEqual("24NXXX", friend.EncodedId);
            Assert.AreEqual("", friend.FullName);
            Assert.AreEqual(Gender.MALE, friend.Gender);
            Assert.AreEqual(190.5, friend.Height);
            Assert.AreEqual("en_GB", friend.Locale);
            Assert.AreEqual(DateTime.Parse("2013-01-01"), friend.MemberSince);
            Assert.AreEqual("", friend.Nickname);
            Assert.AreEqual(3600000, friend.OffsetFromUTCMillis);
            Assert.AreEqual("SUNDAY", friend.StartDayOfWeek);
            Assert.AreEqual(0, friend.StrideLengthRunning);
            Assert.AreEqual(0, friend.StrideLengthWalking);
            Assert.AreEqual("Europe/London", friend.Timezone);
            Assert.AreEqual(0, friend.Weight);
        }