Пример #1
0
        public async Task TestInsert()
        {
            try
            {
                Election election = new Election()
                {
                    Date           = new DateTime(2022, 11, 3).Date,
                    StartDateLocal = new DateTime(2022, 11, 1, 8, 0, 0),
                    EndDateLocal   = new DateTime(2022, 11, 3, 20, 0, 0),
                    Description    = "2022 November Election",
                    Version        = "0.0.0.0",
                    AllowUpdates   = false
                };
                UOW.BeginTransaction();
                Election inserted = await electionService.Insert(UOW, election);

                UOW.CloseTransaction();
                Assert.IsNotNull(inserted);
                Assert.IsTrue(inserted.Id != Guid.Empty, "Expect inserted Election Id not be empty");
            }
            catch (Exception ex)
            {
                Assert.IsNull(ex, "Exception Thrown: " + ex.Message);
            }
        }
Пример #2
0
        public async Task TestInsertUpdateVote()
        {
            try
            {
                // now add a vote for candidate1
                Vote vote = new Vote()
                {
                    ElectionId     = DefaultElectionId,
                    BallotId       = Guid.NewGuid(),
                    CategoryId     = PresCategoryId,
                    CategoryTypeId = 2,
                    SelectionId    = BidenTicketId,
                    VoteStatus     = 0,
                    ApprovalDate   = DateTime.Now
                };
                UOW.BeginTransaction();
                Vote inserted = await voteRepository.Insert(UOW, vote);

                Assert.IsNotNull(inserted);
                Assert.IsTrue(inserted.Id != Guid.Empty, "Expect inserted vote Id not be empty");
                // now change the ballot selection to candidate2
                vote.Id         = inserted.Id;
                vote.VoteStatus = (int)VoteStatusEnum.choiceRejected;

                Vote updated = await voteRepository.Update(UOW, vote);

                Assert.IsNotNull(updated);
                Assert.IsTrue(inserted.Id == updated.Id, "Expect inserted and updated Id to be the same");
                UOW.CloseTransaction();
            }
            catch (Exception ex)
            {
                Assert.IsNull(ex, "Exception Thrown: " + ex.Message);
            }
        }
Пример #3
0
        public async Task TestInsert()
        {
            try
            {
                List <Ticket> ans        = (await ticketService.GetByElection(Context, DefaultElectionId)).ToList();
                int           ndxToGet   = rand.Next(0, ans.Count);
                Guid          categoryId = ans[ndxToGet].CategoryId;
                int           partyId    = rand.Next(1, 6);

                Ticket ticket = new Ticket()
                {
                    ElectionId  = DefaultElectionId,
                    CategoryId  = categoryId,
                    Description = "TestTicketInsert",
                    PartyId     = partyId,
                    TicketType  = ans[ndxToGet].TicketType,
                    Information = "TextTicketInformation",
                    Sequence    = 1
                };
                UOW.BeginTransaction();
                Ticket result = await ticketService.Insert(UOW, ticket);

                UOW.CloseTransaction();
                Assert.IsNotNull(result);
                Assert.IsTrue(result.Description == ticket.Description, "Expect description to be TestTicketInsert");
                Assert.IsTrue(result.Information == ticket.Information, "Expect description to be TestTicketInformation");
                Assert.IsTrue(result.Id != Guid.Empty, "Expect Id to not be empty");
            }
            catch (Exception ex)
            {
                Assert.IsNull(ex, "Exception Thrown: " + ex.Message);
            }
        }
Пример #4
0
        public async Task TestInsertElection()
        {
            Guid        BallotId = Guid.NewGuid();
            List <Vote> votes    = new List <Vote>()
            {
                new Vote()
                {
                    ElectionId     = DefaultElectionId,
                    BallotId       = BallotId,
                    CategoryId     = PresCategoryId,
                    CategoryTypeId = 2,
                    SelectionId    = BidenTicketId,
                    VoteStatus     = 0,
                    ApprovalDate   = DateTime.Now
                }
            };
            int countBeforeInsert1 = await GetCurrentVoteSummary(BidenTicketId);

            UOW.BeginTransaction();
            List <Vote> results = await voteService.InsertElection(UOW, votes);

            int countAfterInsert1 = await GetCurrentVoteSummary(BidenTicketId);

            Assert.IsNotNull(results, "Expected votes to be inserted");
            Assert.IsTrue(countAfterInsert1 == countBeforeInsert1 + 1, "Expecte VoteResult Table to be increased by 1 votes for candidate");
            UOW.CloseTransaction();
        }
Пример #5
0
 public async Task <Vote> Create([FromBody] Vote vote)
 {
     try
     {
         UOW.BeginTransaction();
         return(await this.voteRepository.Insert(UOW, vote));
     }
     finally
     {
         UOW.SaveChanges();
         UOW.CloseTransaction();
     }
 }
Пример #6
0
 public async Task <int> InsertElection([FromBody] List <Vote> electionObj)
 {
     try
     {
         UOW.BeginTransaction();
         var result = await this.voteRepository.InsertElection(UOW, electionObj);
     }
     finally
     {
         UOW.SaveChanges();
         UOW.CloseTransaction();
     }
     return(0);
 }
Пример #7
0
        public async Task TestDelete()
        {
            try
            {
                UOW.BeginTransaction();
                Election result = await electionService.Delete(UOW, DefaultElectionId);

                UOW.CloseTransaction();
                Assert.IsNull(result);
            }
            catch (Exception ex)
            {
                Assert.IsNull(ex, "Exception Thrown: " + ex.Message);
            }
        }
Пример #8
0
        public async Task TestUpdate()
        {
            try
            {
                Category insCat = new Category()
                {
                    ElectionId     = this.DefaultElectionId,
                    CategoryTypeId = CategoryTypeEnum.federal,
                    Heading        = "TestHeadingInsert",
                    Title          = "TestTitleInsert",
                    JudgePosition  = 4,
                    Information    = "TestInformationInsert",
                    SubTitle       = "TestSubTitleInsert",
                    Sequence       = 1,
                    Selection      = null
                };
                UOW.BeginTransaction();
                Category result = await categoryRepository.Insert(UOW, insCat);

                Assert.IsNotNull(result, "Expect category to be inserted");
                Assert.IsFalse(result.Id == Guid.Empty, "Expect a real guid id for inserted Category");
                Assert.AreEqual(result.CategoryTypeId, insCat.CategoryTypeId, "Expect CategoryTypeId to be the same");
                Assert.AreEqual(result.Heading, insCat.Heading, "Expect Heading to be the same");
                Assert.AreEqual(result.Title, insCat.Title, "Expect Title to be the same");
                Assert.AreEqual(result.JudgePosition, insCat.JudgePosition, "Expect JudgePosition to be the same");
                Assert.AreEqual(result.Information, insCat.Information, "Expect Information to be the same");
                Assert.AreEqual(result.SubTitle, insCat.SubTitle, "Expect SubTitle to be the same");
                Assert.AreEqual(result.Sequence, insCat.Sequence, "Expect Sequence to be the same");
                Assert.AreEqual(result.Selection, insCat.Selection, "Expect Selection to be the same");

                result.Heading     = "TestHeadingUpdate";
                result.Title       = "TestTitleUdate";
                result.Information = "TestInformationUpdate";
                result.SubTitle    = "TestSubTitleUpdate";
                Category update = await categoryRepository.Update(UOW, result);

                UOW.CloseTransaction();
                Assert.IsNotNull(update, "Expected updated record");
                Assert.IsTrue(update.Heading == result.Heading, "Expect Heading to be updated");
                Assert.IsTrue(update.Title == result.Title, "Expect Title to be updated");
                Assert.IsTrue(update.Information == result.Information, "Expect Information to be updated");
                Assert.IsTrue(update.SubTitle == result.SubTitle, "Expect Subtitle to be updated");
            }
            catch (Exception ex)
            {
                Assert.IsNull(ex, "Exception Thrown: " + ex.Message);
            }
        }
Пример #9
0
        public async Task <Vote> Update([FromBody] Vote vote)
        {
            Vote result = new Vote();

            try
            {
                UOW.BeginTransaction();
                result = await this.voteRepository.Update(UOW, vote);

                UOW.SaveChanges();
                return(result);
            }
            finally
            {
                UOW.CloseTransaction();
            }
        }
Пример #10
0
        public async Task <Signature> Create([FromBody] BlockChain electionChain)
        {
            Signature result = null;

            try
            {
                UOW.BeginTransaction();
                Signature signature = this.GetSignatureFromBlockChain(electionChain);
                // now check to make sure the nonce matches the expected nonce
                (int expectedNonce, Guid ballotRequestId) = await this.signatureRepository.GetExpectedNonce(UOW, signature.BallotId);

                if (ballotRequestId != Guid.Empty)
                {
                    var br = await ballotRepository.BallotRequestGetById(Context, ballotRequestId);

                    // make sure the nonce and device id are correct
                    if (signature == null || expectedNonce != electionChain.GetLatestBlock().Nonce ||
                        (br != null && signature.DeviceId != br.DeviceId))
                    {
                        return(null);
                    }

                    Signature existingSignature = await this.GetByBallotId(signature.BallotId);

                    if (existingSignature != null)
                    {
                        result = await signatureRepository.UpdateBallotVotes(UOW, existingSignature, signature);
                    }
                    else
                    {
                        result = await this.InsertNewSignatureBallot(UOW, signature);
                    }
                    UOW.SaveChanges();
                }
            }
            catch (Exception ex)
            {
                string err = ex.Message;
            }
            finally
            {
                UOW.CloseTransaction();
            }
            return(result);
        }
        public async Task TestDelete()
        {
            try
            {
                UOW.BeginTransaction();
                CategoryType result = await categoryTypeRepository.GetByID(Context, 1);

                Assert.IsNotNull(result, "Expect to find CategoryType Measure");
                Assert.AreEqual(result.Description, "Measure", "Expect to find CategoryType Description = Measure");
                CategoryType deleted = await categoryTypeRepository.Delete(UOW, result.Id);

                UOW.CloseTransaction();
                Assert.IsNull(deleted, "Expect new CategoryType to be deleted.");
            }
            catch (Exception ex)
            {
                Assert.IsNull(ex, "Exception Thrown: " + ex.Message);
            }
        }
Пример #12
0
        public async Task TestDelete()
        {
            try
            {
                List <Ticket> ans      = (await ticketService.GetByElection(Context, DefaultElectionId)).ToList();
                int           ndxToGet = rand.Next(0, ans.Count);
                UOW.BeginTransaction();
                Ticket deleted = await ticketService.Delete(UOW, ans[ndxToGet].Id);

                List <Ticket> results = (await ticketService.GetByElection(Context, DefaultElectionId)).ToList();
                UOW.CloseTransaction();
                Assert.IsNull(deleted, "Expect to not find deleted ticket");
                Assert.IsTrue(results.Count == ans.Count - 1, "Expect total Tickets to be one less that starting value");
            }
            catch (Exception ex)
            {
                Assert.IsNull(ex, "Exception Thrown: " + ex.Message);
            }
        }
Пример #13
0
        public async Task TestInsertUpdateVote()
        {
            try
            {
                Vote vote = new Vote()
                {
                    ElectionId     = DefaultElectionId,
                    BallotId       = Guid.NewGuid(),
                    CategoryId     = PresCategoryId,
                    CategoryTypeId = 2,
                    SelectionId    = BidenTicketId,
                    VoteStatus     = 0,
                    ApprovalDate   = DateTime.Now
                };
                UOW.BeginTransaction();
                int countBeforeInsert1 = await GetCurrentVoteSummary(BidenTicketId);

                Vote inserted = await voteService.Insert(UOW, vote);

                Assert.IsNotNull(inserted);
                Assert.IsTrue(inserted.Id != Guid.Empty, "Expect inserted vote Id not be empty");
                int countAfterInsert1 = await GetCurrentVoteSummary(BidenTicketId);

                Assert.IsTrue(countAfterInsert1 == countBeforeInsert1 + 1, "Expected trigger to increase the count in VoteResult Table");
                // now change the ballot selection to candidate2
                vote.Id         = inserted.Id;
                vote.VoteStatus = (int)VoteStatusEnum.choiceRejected;

                Vote updated = await voteService.Update(UOW, vote);

                Assert.IsNotNull(updated);
                Assert.IsTrue(inserted.Id == updated.Id, "Expect inserted and updated Id to be the same");
                int countAfterUpdate1 = await GetCurrentVoteSummary(BidenTicketId);

                Assert.IsTrue(countBeforeInsert1 == countAfterUpdate1, "Expected trigger to decrease the count  in VoteResult Table when VoteStatus changed");

                UOW.CloseTransaction();
            }
            catch (Exception ex)
            {
                Assert.IsNull(ex, "Exception Thrown: " + ex.Message);
            }
        }
Пример #14
0
        public async Task TestPartyDelete()
        {
            try
            {
                UOW.BeginTransaction();
                Party result = await PartyService.GetByID(Context, 1);

                Assert.IsNotNull(result, "Expect to find Democratic Party");
                Assert.AreEqual(result.Description, "Democratic Party", "Expect to find Party Description = Democratic Party");
                Party deleted = await PartyService.Delete(UOW, result.Id);

                UOW.CloseTransaction();
                Assert.IsTrue(deleted.Active == false, "Expect new Party active flag to be false.");
            }
            catch (Exception ex)
            {
                Assert.IsNull(ex, "Exception Thrown: " + ex.Message);
            }
        }
Пример #15
0
        public async Task <List <Vote> > InsertElection([FromBody] List <Vote> votes)
        {
            List <Vote> result = new List <Vote>();

            try
            {
                UOW.BeginTransaction();
                result = await this.voteRepository.InsertElection(UOW, votes);

                if (votes.Count == result.Count)
                {
                    UOW.SaveChanges();
                }
                return(result);
            }
            finally
            {
                UOW.CloseTransaction();
            }
        }
Пример #16
0
        public async Task <Signature> Create([FromBody] Signature electionObj)
        {
            Signature result = null;

            try
            {
                UOW.BeginTransaction();
                result = await this.signatureRepository.Insert(Context, electionObj);

                if (result.Id != Guid.Empty && result.Confirmed && result.Votes.Count == electionObj.Votes.Count)
                {
                    UOW.SaveChanges();
                }
            }
            finally
            {
                UOW.CloseTransaction();
            }

            return(result);
        }
Пример #17
0
        public async Task TestPartyUpdate()
        {
            try
            {
                UOW.BeginTransaction();
                Party result = await PartyService.GetByID(Context, 3);

                Assert.IsNotNull(result, "Expect to find Party State");
                Assert.AreEqual(result.Description, "Libertarian Party", "Expect to find Party Description = Libertarian Party");
                result.Description = "Libertarian Test Update";
                Party updated = await PartyService.Update(UOW, result);

                UOW.CloseTransaction();
                Assert.IsNotNull(updated, "Expect new Party to be updated.");
                Assert.AreEqual(updated.Description, result.Description, "Expect for Description to be changed to 'Libertarian Test Update'");
            }
            catch (Exception ex)
            {
                Assert.IsNull(ex, "Exception Thrown: " + ex.Message);
            }
        }
Пример #18
0
        public async Task TestPartyInsert()
        {
            try
            {
                UOW.BeginTransaction();
                Party catType = new Party()
                {
                    Description = "My Test Party",
                    Active      = true
                };
                Party result = await PartyService.Insert(UOW, catType);

                UOW.CloseTransaction();
                Assert.IsNotNull(result, "Expect new Party to be inserted.");
                Assert.IsTrue(result.Id > 6, "Expect Inserted Id to be > 6");
            }
            catch (Exception ex)
            {
                Assert.IsNull(ex, "Exception Thrown: " + ex.Message);
            }
        }
Пример #19
0
 public async Task TestDelete()
 {
     try
     {
         List <Category> result = (await categoryService.GetByElection(Context, this.DefaultElectionId)).ToList();
         int             total  = result.Count;
         Assert.IsNotNull(result, "Expect to find at least once category in default dataset");
         int      ndxToDelete = rand.Next(1, total);
         Category catToDelete = result[ndxToDelete];
         UOW.BeginTransaction();
         Category        deleted = (await categoryService.Delete(UOW, catToDelete.Id));
         List <Category> result2 = (await categoryService.GetByElection(Context, this.DefaultElectionId)).ToList();
         UOW.CloseTransaction();
         Assert.IsNull(deleted, "Expected Category to be deleted");
         Assert.IsTrue(result2.Count == total - 1, "Expect one less category in default dataset");
     }
     catch (Exception ex)
     {
         Assert.IsNull(ex, "Exception Thrown: " + ex.Message);
     }
 }
        public async Task TestInsert()
        {
            try
            {
                UOW.BeginTransaction();
                CategoryType catType = new CategoryType()
                {
                    Description = "TestInsertCategory",
                    Active      = true
                };
                CategoryType result = await categoryTypeRepository.Insert(UOW, catType);

                UOW.CloseTransaction();
                Assert.IsNotNull(result, "Expect new CategoryType to be inserted.");
                Assert.IsTrue(result.Id > 5, "Expect Inserted Id to be > 5");
            }
            catch (Exception ex)
            {
                Assert.IsNull(ex, "Exception Thrown: " + ex.Message);
            }
        }
        public async Task TestUpdate()
        {
            try
            {
                UOW.BeginTransaction();
                CategoryType result = await categoryTypeRepository.GetByID(Context, 3);

                Assert.IsNotNull(result, "Expect to find CategoryType State");
                Assert.AreEqual(result.Description, "State", "Expect to find CategoryType Description = State");
                result.Description = "State Test Update";
                CategoryType updated = await categoryTypeRepository.Update(UOW, result);

                UOW.CloseTransaction();
                Assert.IsNotNull(updated, "Expect new CategoryType to be updated.");
                Assert.AreEqual(updated.Description, result.Description, "Expect for Description to be changed to 'State Test Update'");
            }
            catch (Exception ex)
            {
                Assert.IsNull(ex, "Exception Thrown: " + ex.Message);
            }
        }
Пример #22
0
        public async Task TestInsert()
        {
            try
            {
                Ballot ans = new Ballot()
                {
                    ElectionId  = DefaultElectionId,
                    Nonce       = 525,
                    BallotChain = "Something"
                };
                UOW.BeginTransaction();
                Ballot inserted = await ballotRepository.Insert(Context, ans);

                UOW.CloseTransaction();
                Assert.IsNotNull(inserted, "Expected inserted ballot");
                Assert.IsTrue(ans.Nonce == 525, "Expect Nonce to be 525");
            }
            catch (Exception ex)
            {
                Assert.IsNull(ex, "Exception Thrown: " + ex.Message);
            }
        }
Пример #23
0
        public async Task TestUpdate()
        {
            try
            {
                Election election = new Election()
                {
                    Date           = new DateTime(2022, 11, 3).Date,
                    StartDateLocal = new DateTime(2022, 11, 1, 8, 0, 0),
                    EndDateLocal   = new DateTime(2022, 11, 3, 20, 0, 0),
                    Description    = "2022 November Election",
                    Version        = "0.0.0.0",
                    AllowUpdates   = false
                };
                UOW.BeginTransaction();
                Election inserted = await electionService.Insert(UOW, election);

                Assert.IsNotNull(inserted);
                Assert.IsTrue(inserted.Id != Guid.Empty, "Expect inserted Election Id not be empty");
                inserted.Date           = new DateTime(2023, 11, 3).Date;
                inserted.StartDateLocal = new DateTime(2023, 11, 1, 8, 0, 0);
                inserted.EndDateLocal   = new DateTime(2023, 11, 3, 20, 0, 0);
                inserted.Description    = "2023 November Election";
                inserted.AllowUpdates   = true;
                Election updated = await electionService.Update(UOW, inserted);

                UOW.CloseTransaction();
                Assert.IsNotNull(updated, "Expected election to be updated");
                Assert.IsTrue(updated.Date.Year == 2023, "Expected election year to be 2023");
                Assert.IsTrue(updated.StartDateLocal.Year == 2023, "Expected election year to be 2023");
                Assert.IsTrue(updated.EndDateLocal.Year == 2023, "Expected election year to be 2023");
                Assert.IsTrue(updated.Description == "2023 November Election", "Expected desription to be updated");
                Assert.IsTrue(updated.AllowUpdates, "Expected allowUpdates to be true");
            }
            catch (Exception ex)
            {
                Assert.IsNull(ex, "Exception Thrown: " + ex.Message);
            }
        }
Пример #24
0
        public async Task TestInsertElection()
        {
            Guid        BallotId = Guid.NewGuid();
            List <Vote> votes    = new List <Vote>()
            {
                new Vote()
                {
                    ElectionId     = DefaultElectionId,
                    BallotId       = BallotId,
                    CategoryId     = PresCategoryId,
                    CategoryTypeId = 2,
                    SelectionId    = TrumpTicketId,
                    VoteStatus     = 0,
                    ApprovalDate   = DateTime.Now
                }
            };

            UOW.BeginTransaction();
            List <Vote> results = await voteRepository.InsertElection(UOW, votes);

            Assert.IsNotNull(results, "Expected votes to be inserted");
            UOW.CloseTransaction();
        }
Пример #25
0
        public async Task TestSaveAllElection()
        {
            try
            {
                Guid          newElectionGuid = Guid.NewGuid();
                Guid          newCategoryGuid = Guid.NewGuid();
                List <Ticket> ticketList      = new List <Ticket>()
                {
                    new Ticket()
                    {
                        Id          = Guid.NewGuid(),
                        ElectionId  = newElectionGuid,
                        CategoryId  = newCategoryGuid,
                        Description = "newTicketForCategory",
                        PartyId     = 2
                    }
                };
                List <Category> categoryList = new List <Category>()
                {
                    new Category()
                    {
                        Id             = newCategoryGuid,
                        ElectionId     = newElectionGuid,
                        CategoryTypeId = CategoryTypeEnum.federal,
                        Heading        = "TestNewElectionCategory",
                        Sequence       = 1,
                        JudgePosition  = 2,
                        Tickets        = ticketList,
                    }
                };
                Election election = new Election()
                {
                    Id             = newElectionGuid,
                    Date           = new DateTime(2022, 11, 3).Date,
                    StartDateLocal = new DateTime(2022, 11, 1, 8, 0, 0),
                    EndDateLocal   = new DateTime(2022, 11, 3, 20, 0, 0),
                    Description    = "2022 November Election",
                    Version        = "0.0.0.0",
                    AllowUpdates   = false,
                    CategoryList   = categoryList
                };
                UOW.BeginTransaction();
                Election result = await electionService.SaveAllElection(UOW, election);

                Assert.IsNotNull(election, "Expected election to be saved");
                Assert.IsTrue(election.CategoryList.Count == 1, "Expected Category to be saved.");
                Assert.IsTrue(election.CategoryList[0].Tickets.Count == 1, "Expect one Ticket in category");

                CategoryService categoryService = new CategoryService();
                List <Category> clist           = (await categoryService.GetByElection(Context, newElectionGuid)).ToList();
                Assert.IsTrue(clist.Count == 1, "Expect one Category");
                TicketService ticketService = new TicketService();
                List <Ticket> tlist         = (await ticketService.GetByElection(Context, newElectionGuid)).ToList();
                Assert.IsTrue(tlist.Count == 1, "Expect one Ticket");
                UOW.CloseTransaction();
            }
            catch (Exception ex)
            {
                Assert.IsNull(ex, "Exception Thrown: " + ex.Message);
            }
        }