public void NoSharesOwned()
        {
            var stock = new Stock(Guid.NewGuid());

            stock.List("ABC", "ABC Pty Ltd", new Date(1974, 01, 01), false, AssetCategory.AustralianStocks);

            var transaction = new ReturnOfCapital()
            {
                Id                    = Guid.NewGuid(),
                Date                  = new Date(2020, 02, 01),
                Stock                 = stock,
                Comment               = "Test Dividend",
                RecordDate            = new Date(2020, 01, 01),
                Amount                = 2.00m,
                CreateCashTransaction = false
            };

            var mockRepository = new MockRepository(MockBehavior.Strict);

            var holding = mockRepository.Create <IHolding>();

            holding.Setup(x => x.IsEffectiveAt(new Date(2020, 01, 01))).Returns(false);

            var cashAccount = mockRepository.Create <ICashAccount>();

            var handler = new ReturnOfCapitalHandler();

            Action a = () => handler.Apply(transaction, holding.Object, cashAccount.Object);

            a.Should().Throw <NoSharesOwnedException>();

            mockRepository.Verify();
        }
        public void Apply(ReturnOfCapitalOccurredEvent @event)
        {
            var holding = _Holdings[@event.Stock];

            if (holding == null)
            {
                throw new NoSharesOwnedException("No shares owned");
            }

            var returnOfCapital = new ReturnOfCapital
            {
                Id                    = @event.TransactionId,
                Date                  = @event.Date,
                Stock                 = holding.Stock,
                Comment               = @event.Comment,
                RecordDate            = @event.RecordDate,
                Amount                = @event.Amount,
                CreateCashTransaction = @event.CreateCashTransaction
            };

            var handler = _TransactionHandlers.GetService <ReturnOfCapital>();

            handler.Apply(returnOfCapital, holding, _CashAccount);
            _Transactions.Add(returnOfCapital);
        }
        public void HasBeenAppliedNoIncomeAtRecordDate()
        {
            var mockRepository = new MockRepository(MockBehavior.Strict);

            var stock = new Stock(Guid.NewGuid());

            stock.List("ABC", "ABC Pty Ltd", new Date(1974, 01, 01), false, AssetCategory.AustralianStocks);

            var dividend = new Dividend(Guid.NewGuid(), stock, new Date(2020, 01, 01), "Test Dividend", new Date(2020, 02, 01), 100.00m, 100.0m, 0.00m);

            var transaction = new ReturnOfCapital()
            {
                Id                    = Guid.NewGuid(),
                Date                  = new Date(2020, 02, 01),
                Stock                 = stock,
                Comment               = "Test Return Of Capital",
                RecordDate            = new Date(2020, 01, 01),
                Amount                = 2.00m,
                CreateCashTransaction = false
            };
            var transactions = mockRepository.Create <IPortfolioTransactionList>();

            transactions.Setup(x => x.ForHolding(stock.Id, dividend.PaymentDate)).Returns(new IPortfolioTransaction[] { transaction });

            var result = dividend.HasBeenApplied(transactions.Object);

            result.Should().BeFalse();

            mockRepository.Verify();
        }
Пример #4
0
        public void DeserializeReturnOfCapital()
        {
            var serializer = new RestClientSerializer();

            var transactionId = Guid.NewGuid();
            var stockId       = Guid.NewGuid();

            var json = "{\"id\":\"" + transactionId + "\","
                       + "\"stock\":\"" + stockId + "\","
                       + "\"type\":\"returnofcapital\","
                       + "\"transactionDate\":\"2000-01-10\","
                       + "\"comment\":\"comment\","
                       + "\"description\":\"description\","
                       + "\"recordDate\":\"2000-01-01\","
                       + "\"amount\":45.00,"
                       + "\"createCashTransaction\":true}";

            var transaction = serializer.Deserialize <Transaction>(json);

            var expected = new ReturnOfCapital()
            {
                Id                    = transactionId,
                Stock                 = stockId,
                TransactionDate       = new Date(2000, 01, 10),
                Comment               = "comment",
                Description           = "description",
                RecordDate            = new Date(2000, 01, 01),
                Amount                = 45.00m,
                CreateCashTransaction = true
            };

            transaction.Should().BeEquivalentTo(expected);
        }
        public override IEnumerable <IPortfolioTransaction> GetTransactionList(IReadOnlyHolding holding, IStockResolver stockResolver)
        {
            var transactions = new List <IPortfolioTransaction>();

            var holdingProperties = holding.Properties[Date];

            if (holdingProperties.Units == 0)
            {
                return(transactions);
            }

            var dividendRules = Stock.DividendRules[Date];

            var amount = (holdingProperties.Units * Amount).ToCurrency(dividendRules.DividendRoundingRule);

            var returnOfCapital = new ReturnOfCapital()
            {
                Id                    = Guid.NewGuid(),
                Date                  = PaymentDate,
                Stock                 = Stock,
                RecordDate            = Date,
                Amount                = amount,
                CreateCashTransaction = true,
                Comment               = Description
            };

            transactions.Add(returnOfCapital);

            return(transactions);
        }
        protected override void CopyFieldsToTransaction()
        {
            if (_Transaction == null)
            {
                _Transaction = new ReturnOfCapital();
            }

            base.CopyFieldsToTransaction();

            var returnOfCapital = (ReturnOfCapital)_Transaction;

            returnOfCapital.RecordDate            = RecordDate;
            returnOfCapital.TransactionDate       = PaymentDate;
            returnOfCapital.Amount                = Amount;
            returnOfCapital.CreateCashTransaction = CreateCashTransaction;
        }
        public void MultipleParcelsOwned()
        {
            var stock = new Stock(Guid.NewGuid());

            stock.List("ABC", "ABC Pty Ltd", new Date(1974, 01, 01), false, AssetCategory.AustralianStocks);

            var transaction = new ReturnOfCapital()
            {
                Id                    = Guid.NewGuid(),
                Date                  = new Date(2020, 02, 01),
                Stock                 = stock,
                Comment               = "Test Dividend",
                RecordDate            = new Date(2020, 01, 01),
                Amount                = 2.00m,
                CreateCashTransaction = true
            };

            var mockRepository = new MockRepository(MockBehavior.Strict);

            var parcel1 = mockRepository.Create <IParcel>();

            parcel1.Setup(x => x.Properties[new Date(2020, 01, 01)]).Returns(new ParcelProperties(100, 1000.00m, 1000.00m));
            parcel1.Setup(x => x.Change(new Date(2020, 01, 01), 0, 0.00m, 200.00m, transaction)).Verifiable();
            var parcel2 = mockRepository.Create <IParcel>();

            parcel2.Setup(x => x.Properties[new Date(2020, 01, 01)]).Returns(new ParcelProperties(50, 500.00m, 500.00m));
            parcel2.Setup(x => x.Change(new Date(2020, 01, 01), 0, 0.00m, 100.00m, transaction)).Verifiable();
            var parcel3 = mockRepository.Create <IParcel>();

            parcel3.Setup(x => x.Properties[new Date(2020, 01, 01)]).Returns(new ParcelProperties(200, 1000.00m, 1000.00m));
            parcel3.Setup(x => x.Change(new Date(2020, 01, 01), 0, 0.00m, 400.00m, transaction)).Verifiable();

            var holding = mockRepository.Create <IHolding>();

            holding.Setup(x => x.IsEffectiveAt(new Date(2020, 01, 01))).Returns(true);
            holding.Setup(x => x.Parcels(new Date(2020, 01, 01))).Returns(new IParcel[] { parcel1.Object, parcel2.Object, parcel3.Object });

            var cashAccount = mockRepository.Create <ICashAccount>();

            cashAccount.Setup(x => x.Transfer(new Date(2020, 02, 01), 700.00m, "Return of capital for ABC")).Verifiable();

            var handler = new ReturnOfCapitalHandler();

            handler.Apply(transaction, holding.Object, cashAccount.Object);

            mockRepository.Verify();
        }
        public void ReturnOfCapitalReceived()
        {
            var mockRepository = new MockRepository(MockBehavior.Strict);

            var stock = new Stock(Guid.NewGuid());

            stock.List("ABC", "ABC Pty Ltd", new Date(1974, 01, 01), false, AssetCategory.AustralianStocks);

            var stockResolver = mockRepository.Create <IStockResolver>();

            stockResolver.Setup(x => x.GetStock(stock.Id)).Returns(stock);

            var             handler     = mockRepository.Create <ITransactionHandler>();
            ReturnOfCapital transaction = null;

            handler.Setup(x => x.Apply(It.IsAny <IPortfolioTransaction>(), It.IsAny <IHolding>(), It.IsAny <ICashAccount>()))
            .Callback <IPortfolioTransaction, IHolding, ICashAccount>((t, h, c) => transaction = (ReturnOfCapital)t)
            .Verifiable();

            var transactionHandlers = mockRepository.Create <IServiceFactory <ITransactionHandler> >();

            transactionHandlers.Setup(x => x.GetService <ReturnOfCapital>()).Returns(handler.Object);
            transactionHandlers.Setup(x => x.GetService <OpeningBalance>()).Returns(new OpeningBalanceHandler());

            var portfolio = new Portfolio(Guid.NewGuid(), stockResolver.Object, transactionHandlers.Object);

            portfolio.AddOpeningBalance(stock.Id, new Date(1999, 01, 01), new Date(1999, 01, 01), 100, 100.00m, "", Guid.Empty);

            var transactionId = Guid.NewGuid();

            portfolio.ReturnOfCapitalReceived(stock.Id, new Date(2000, 01, 01), new Date(1999, 01, 01), 10.00m, true, "Comment", transactionId);

            transaction.Should().BeEquivalentTo(new
            {
                Id                    = transaction.Id,
                Date                  = new Date(2000, 01, 01),
                Stock                 = stock,
                Comment               = "Comment",
                RecordDate            = new Date(1999, 01, 01),
                Amount                = 10.00m,
                CreateCashTransaction = true
            });

            mockRepository.Verify();
        }
Пример #9
0
        public void ApplyReturnOfCapital()
        {
            var mockRepository = new MockRepository(MockBehavior.Strict);

            var portfolio = PortfolioTestCreator.CreateDefaultPortfolio();

            var events     = new List <Event>();
            var repository = mockRepository.Create <IRepository <Portfolio> >();

            repository.Setup(x => x.Update(It.IsAny <Portfolio>())).Callback <Portfolio>(x => events.AddRange(x.FetchEvents()));

            var service = new PortfolioTransactionService(portfolio, repository.Object);

            var transaction = new ReturnOfCapital()
            {
                Id                    = Guid.NewGuid(),
                Stock                 = PortfolioTestCreator.Stock_ARG.Id,
                TransactionDate       = new Date(2007, 01, 01),
                Comment               = "",
                Amount                = 5.00m,
                RecordDate            = new Date(2006, 12, 01),
                CreateCashTransaction = true
            };
            var result = service.ApplyTransaction(transaction);

            result.Should().HaveOkStatus();
            events.Should().BeEquivalentTo(new[]
            {
                new ReturnOfCapitalOccurredEvent(portfolio.Id, 1, transaction.Id, new Date(2007, 01, 01), PortfolioTestCreator.Stock_ARG.Id, "")
                {
                    Amount                = 5.00m,
                    RecordDate            = new Date(2006, 12, 01),
                    CreateCashTransaction = true
                }
            });

            mockRepository.Verify();
        }
 public ReturnOfCapitalViewModel(ReturnOfCapital returnOfCapital, RestClient restClient)
     : base(returnOfCapital, "Return of Capital", TransactionStockSelection.Holdings, restClient)
 {
 }