NUnit hangs - testing ReadOnlyCollection<T>

This is my first attempt at Unit testing in general. Please bear with me.

public class Order
    {

        public string OrderId { get; set; }
        public ContractStatus Status { get; set; }
        public int OrderItemCount { get; set; }
        public double Subtotal { get; set; }

        private List<OrderItem> OrderItems { get; set; }

        public Order()
        {

            OrderItems = new List<OrderItem>();

        }

        public ReadOnlyCollection<OrderItem> Items
        {

            get
            {
                return Items;

            }
        }

        public void AddOrderItem(OrderItem orderItem)
        {

            this.OrderItemCount = 0;
            this.Subtotal=0.0;

            this.OrderItems.Add(orderItem);
            foreach (var item in this.OrderItems)
            {
                this.OrderItemCount += item.Quantity;
                this.Subtotal += item.LineTotal;

            }

        }

        }

    }

Test Below: NUnit will hang at "CreateOrder_ValidContract_CreateNewOrder()". If I comment out the line "Assert.IsInstanceOf<ReadOnlyCollection<OrderItem>>(newOrder.Items);" it will pass. What am doing wrong?

    [TestFixture]
    public class OrderServiceTest
    {

        private IContractRepository _contractRepository;
        private ContractService _contractService;

        private IPartServiceRepository _partServiceRepository;

        private const string ValidContractId = "CONTRACTID";
        private const string ExpiredContractId = "EXPIREDCONTRACTID";
        private const string ValidPartId = "PARTID";
        private const double ValidPartPrice = 50.0;

        [SetUp]
        public void Initalize()
        {

            _contractRepository = A.Fake<IContractRepository>();
            _partServiceRepository = A.Fake<IPartServiceRepository>();

            A.CallTo(() => _contractRepository.GetById(ValidContractId))
                .Returns(new ContractDto
                {
                    ContractId = ValidContractId,
                    ExpirationDate = DateTime.Now.AddDays(1)
                });

            A.CallTo(() => _contractRepository.GetById(ExpiredContractId))
                .Returns(new ContractDto
                {
                    ContractId = ExpiredContractId,
                    ExpirationDate = DateTime.Now.AddDays(-1)
                });

            A.CallTo(() => _partServiceRepository.GetById(ValidPartId))
                .Returns(new PartDto
                {
                    PartId = ValidPartId,
                    Price = ValidPartPrice
                });

            AutoMapper.Mapper.CreateMap<PartDto, Part>();
            AutoMapper.Mapper.CreateMap<ContractDto, Contract>();

            _contractService = new ContractService(_contractRepository);
        }

        [Test]
        public void CreateOrder_ValidContract_CreateNewOrder()
        {

            // Arrange
            var orderService = new OrderService();
            var contractService = new ContractService(_contractRepository);
            var contract = contractService.GetById(ValidContractId);

            // Act
            var newOrder = orderService.CreateOrder(contract);

            // Assert
            Assert.IsInstanceOf<Order>(newOrder);
            Guid guidOut;
            Assert.IsTrue(Guid.TryParse(newOrder.OrderId, out guidOut));
            Assert.AreEqual(newOrder.Status, ContractStatus.New );
            Assert.IsInstanceOf<ReadOnlyCollection<OrderItem>>(newOrder.Items);

        }

        [Test, ExpectedException(typeof(ExpiredContractException))]
        public void CreateOrder_ExpiredContract_ThrowsException()
        {

            // Arrange

            var orderService = new OrderService();
            var contractService = new ContractService(_contractRepository);
            var contract = contractService.GetById(ExpiredContractId);

            //Act
            var order = orderService.CreateOrder(contract);

        }

        [Test]
        public void CreateOrderItem_ValidPart_CreatesOrderItem()
        {

            // Arrange
            var orderService = new OrderService();
            var contractService = new ContractService(_contractRepository);
            var contract = contractService.GetById(ValidContractId);
            var order = orderService.CreateOrder(contract);

            var partService = new PartService(_partServiceRepository);
            var part = partService.GetById(ValidPartId);

            var quantity = 1;
            // Act
            var orderItem = orderService.CreateOrderItem(part, quantity);

            // Assert
            Assert.AreEqual(orderItem.Part, part);
            Assert.AreEqual(orderItem.Quantity, quantity);
            Assert.AreEqual(orderItem.Price, ValidPartPrice);
            Assert.AreEqual(orderItem.LineTotal, quantity * ValidPartPrice);
        }
    }