public void CreatePlan()
        {
            var plan = new Plan(GetMockPlanCode(), GetMockPlanName())
            {
                AccountingCode = "accountingcode123",
                SetupFeeAccountingCode = "setupfeeac",
                Description = "a test plan",
                DisplayDonationAmounts = true,
                DisplayPhoneNumber = false,
                DisplayQuantity = true,
                TotalBillingCycles = 5,
                TrialIntervalUnit = Plan.IntervalUnit.Months,
                TrialIntervalLength = 1,
                PlanIntervalUnit = Plan.IntervalUnit.Days,
                PlanIntervalLength = 180
            };
            plan.SetupFeeInCents.Add("USD", 500);
            plan.Create();
            PlansToDeactivateOnDispose.Add(plan);

            plan.CreatedAt.Should().NotBe(default(DateTime));
            plan.AccountingCode.Should().Be("accountingcode123");
            plan.SetupFeeAccountingCode.Should().Be("setupfeeac");
            plan.Description.Should().Be("a test plan");
            plan.DisplayDonationAmounts.Should().HaveValue().And.Be(true);
            plan.DisplayPhoneNumber.Should().HaveValue().And.Be(false);
            plan.DisplayQuantity.Should().HaveValue().And.Be(true);
            plan.TotalBillingCycles.Should().Be(5);
            plan.TrialIntervalUnit.Should().Be(Plan.IntervalUnit.Months);
            plan.TrialIntervalLength.Should().Be(1);
            plan.PlanIntervalUnit.Should().Be(Plan.IntervalUnit.Days);
            plan.PlanIntervalLength.Should().Be(180);
        }

        public void LookupCouponInvoice()
        {
            var discounts = new Dictionary<string, int> { { "USD", 1000 } };
            var coupon = new Coupon(GetMockCouponCode(), GetMockCouponName(), discounts);
            coupon.Create();

            var plan = new Plan(GetMockPlanCode(), GetMockPlanCode())
            {
                Description = "Test Lookup Coupon Invoice"
            };
            plan.UnitAmountInCents.Add("USD", 1500);
            plan.Create();
            PlansToDeactivateOnDispose.Add(plan);

            var account = CreateNewAccountWithBillingInfo();

            var redemption = account.RedeemCoupon(coupon.CouponCode, "USD");

            var sub = new Subscription(account, plan, "USD", coupon.CouponCode);
            sub.Create();

            // TODO complete this test

            var invoices = account.GetInvoices();

            invoices.Should().NotBeEmpty();

            var invoice = Invoices.Get(invoices.First().InvoiceNumber);
            var fromInvoice = invoice.GetRedemption();

            redemption.Should().Be(fromInvoice);
        }

        public void GetAllPlansTest()
        {
            // Setup dependency
            var settingsMock = new Mock<ISettings>();
            var repositoryMock = new Mock<IRepository>();
            var uowMock = new Mock<IUnitOfWork>();
            var serviceLocatorMock = new Mock<IServiceLocator>();
            serviceLocatorMock.Setup(x => x.GetInstance<IRepository>())
                .Returns(repositoryMock.Object);
            ServiceLocator.SetLocatorProvider(() => serviceLocatorMock.Object);

            // Arrange
            decimal expectedResult = 10;
            List<Plan> plans = new List<Plan>();
            for (int i = 0; i < expectedResult; i++)
            {
                Plan plan = new Plan
                {
                    Id = Guid.NewGuid()
                };
                plans.Add(plan);
            }

            repositoryMock.Setup(r => r.Query<Plan>()).Returns(plans.AsQueryable());

            // Act
            PlanService bookingService = new PlanService(uowMock.Object, repositoryMock.Object, settingsMock.Object);
            List<PlanDto> currentResult = bookingService.GetAllPlans();

            // Assert
            repositoryMock.Verify(repo => repo.Query<Plan>());
            Assert.AreEqual(expectedResult, currentResult.Count());
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="CopySaveOptionsWindow"/> class.
 /// </summary>
 /// <param name="pto">The pto.</param>
 /// <param name="plan">The p.</param>
 /// <param name="isForCopy">if set to <c>true</c> [is for copy].</param>
 public CopySaveOptionsWindow(PlanExportSettings pto, Plan plan, bool isForCopy)
     : this()
 {
     m_planTextOptions = pto;
     m_plan = plan;
     m_isForCopy = isForCopy;
 }

        public void ListExpiredSubscriptions()
        {
            var plan = new Plan(GetMockPlanCode(), GetMockPlanName())
            {
                Description = "Subscription Test",
                PlanIntervalLength = 1,
                PlanIntervalUnit = Plan.IntervalUnit.Months
            };
            plan.UnitAmountInCents.Add("USD", 400);
            plan.Create();
            PlansToDeactivateOnDispose.Add(plan);

            for (var x = 0; x < 2; x++)
            {
                var account = CreateNewAccountWithBillingInfo();
                var sub = new Subscription(account, plan, "USD")
                {
                    StartsAt = DateTime.Now.AddMonths(-5)
                };

                sub.Create();
            }

            var subs = Subscriptions.List(Subscription.SubscriptionState.Expired);
            subs.Should().NotBeEmpty();
        }

 /// <summary>
 /// When the user clicks "load", import the plan.
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 private void btnLoad_Click(object sender, EventArgs e)
 {
     SourcePlan = (Plan)lbPlan.SelectedItem;
     TargetPlan = SourcePlan.Clone(TargetCharacter);
     DialogResult = DialogResult.OK;
     Close();
 }

        public void CreateSubscription()
        {
            var plan = new Plan(GetMockPlanCode(), GetMockPlanName())
            {
                Description = "Create Subscription Test"
            };
            plan.UnitAmountInCents.Add("USD", 100);
            plan.Create();
            PlansToDeactivateOnDispose.Add(plan);

            var account = CreateNewAccountWithBillingInfo();

            var coup = CreateNewCoupon(3);
            var sub = new Subscription(account, plan, "USD");
            sub.TotalBillingCycles = 5;
            sub.Coupon = coup;
            Assert.Null(sub.TaxInCents);
            Assert.Null(sub.TaxType);
            Assert.Null(sub.TaxRate);
            sub.Create();

            sub.ActivatedAt.Should().HaveValue().And.NotBe(default(DateTime));
            sub.State.Should().Be(Subscription.SubscriptionState.Active);
            Assert.Equal(5, sub.TotalBillingCycles);
            Assert.Equal(coup.CouponCode, sub.Coupon.CouponCode);
            Assert.Equal(9, sub.TaxInCents.Value);
            Assert.Equal("usst", sub.TaxType);
            Assert.Equal(0.0875M, sub.TaxRate.Value);

            var sub1 = Subscriptions.Get(sub.Uuid);
            Assert.Equal(5, sub1.TotalBillingCycles);
        }

 private int CalculateAdvantage(Plan plan)
 {
     IDictionary<IPlayer, int> scores = GameState.Players.ToDictionary(p => p, p => GameState.PlayerScore(p)+plan.Worth(p));
     if (scores[Player]>scores.Where(kvp => kvp.Key != Player).Max(kvp => kvp.Value))
         return scores.Where(kvp => kvp.Key != Player).Sum(kvp => scores[Player]-kvp.Value);
     return scores.Where(kvp => kvp.Key != Player && kvp.Value>scores[Player]).Sum(kvp => scores[Player]-kvp.Value);
 }

 private static void EnqueuePlan(Plan plan, Queue<object> queue)
 {
     queue.Enqueue(plan.Tile);
     queue.Enqueue(plan.Space);
     if (plan.Arguments != null)
         foreach (object item in plan.Arguments)
             queue.Enqueue(item);
 }

 public void TestDefaults()
 {
     var plan = new Plan();
       Assert.That(plan.Executable, Is.Null);
       Assert.That(plan.Assembly, Is.Null);
       Assert.That(plan.Run, Is.Null);
       Assert.That(plan.ID, Is.Null);
 }

        public void ListPlans()
        {
            var plan = new Plan(GetMockPlanCode(), GetMockPlanName());
            plan.SetupFeeInCents.Add("USD", 100);
            plan.Create();
            PlansToDeactivateOnDispose.Add(plan);

            var plans = Plans.List();
            plans.Should().NotBeEmpty();
        }

        public void CreatePlanSmall()
        {
            var plan = new Plan(GetMockPlanCode(), GetMockPlanName());
            plan.SetupFeeInCents.Add("USD", 100);
            plan.Create();
            PlansToDeactivateOnDispose.Add(plan);

            plan.CreatedAt.Should().NotBe(default(DateTime));
            plan.SetupFeeInCents.Should().Contain("USD", 100);
        }

 /// <summary>
 /// Constructor for use in code when the user wants to manually edit a remapping point.
 /// </summary>
 /// <param name="character">Character information</param>
 /// <param name="plan">Plan to optimize for</param>
 /// <param name="strategy">Optimization strategy</param>
 /// <param name="name">Title of this form</param>
 /// <param name="description">Description of the optimization operation</param>
 public AttributesOptimizationForm(Character character, Plan plan, RemappingPoint point)
     : this()
 {
     m_plan = plan;
     m_character = character;
     m_baseCharacter = character.After(plan.ChosenImplantSet);
     m_manuallyEditedRemappingPoint = point;
     m_strategy = Strategy.ManualRemappingPointEdition;
     m_description = "Manual editing of a remapping point";
     Text = "Remapping point manual editing (" + plan.Name + ")";
 }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="plan">The plan.</param>
        private PlanPrinter(Plan plan)
        {
            m_plan = plan;
            m_plan.UpdateStatistics();

            m_character = (Character)plan.Character;
            m_settings = Settings.Exportation.PlanToText;

            m_font = FontFactory.GetFont("Arial", 10);
            m_boldFont = FontFactory.GetFont("Arial", 10, FontStyle.Bold | FontStyle.Underline);
        }

        public AttributesOptimizationSettingsForm(Plan plan)
        {
            InitializeComponent();

            buttonWholePlan.Font = FontFactory.GetFont("Microsoft Sans Serif", 10F);
            buttonCharacter.Font = FontFactory.GetFont("Microsoft Sans Serif", 10F);
            buttonRemappingPoints.Font = FontFactory.GetFont("Microsoft Sans Serif", 10F);

            m_plan = plan;
            m_character = (Character)plan.Character;
        }

        /// <summary>
        /// Creates the dialog based upon a plan.
        /// </summary>
        /// <param name="plan">Plan to display obsolete entries from</param>
        /// <returns>Action to be taken</returns>
        public static ObsoleteEntriesAction ShowDialog(Plan plan)
        {
            if (plan == null)
                return ObsoleteEntriesAction.None;

            if (!plan.ContainsObsoleteEntries)
                return ObsoleteEntriesAction.None;

            ObsoleteEntriesForm form = new ObsoleteEntriesForm(plan);
            return form.ShowObsoleteEntriesDialog();
        }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="plan">The plan.</param>
        /// <exception cref="System.ArgumentNullException">plan</exception>
        public LoadoutImportationWindow(Plan plan)
            : this()
        {
            plan.ThrowIfNull(nameof(plan));

            Plan = plan;

            EveMonClient.CharacterUpdated += EveMonClient_CharacterUpdated;
            EveMonClient.PlanChanged += EveMonClient_PlanChanged;
            EveMonClient.PlanNameChanged += EveMonClient_PlanNameChanged;
        }

        /// <summary>
        /// Constructor
        /// </summary>
        public EFTLoadoutImportationForm(Plan plan)
        {
            InitializeComponent();
            topSplitContainer.RememberDistanceKey = "EFTLoadoutImportationForm";

            m_plan = plan;
            m_character = m_plan.Character;

            EveClient.CharacterChanged += EveClient_CharacterChanged;
            EveClient.PlanChanged += EveClient_PlanChanged;
        }

        /// <summary>
        /// Creates the dialog based upon a plan.
        /// </summary>
        /// <param name="plan">Plan to display obsolete entries from</param>
        /// <returns>Action to be taken</returns>
        public static ObsoleteEntriesAction ShowDialog(Plan plan)
        {
            if (plan == null)
                return ObsoleteEntriesAction.None;

            if (!plan.ContainsObsoleteEntries)
                return ObsoleteEntriesAction.None;

            using (ObsoleteEntriesWindow form = new ObsoleteEntriesWindow(plan))
            {
                return form.ShowObsoleteEntriesDialog();
            }
        }

        public MainWindow()
        {
            InitializeComponent();

            _plan = (Plan)FindResource("Plan");
            _log = (Plan)FindResource("Log");

            Closing += OnClosing;

            if (_json.FolderExists() == true)
            {
                _plan = _json.Deserialize();
            }
        }