How to use the futures.views.process_order function in futures

def test_order_1(self):
        user = User.objects.get(pk=8)
        # Want to buy future "Jesse Day".
        # There is a sell order of 8 for 600, a buy order of 4 for 100,
        # a sell order of 4 for 325, a buy order of 4 for 275 in the fixture.
        response = process_order(15, 650,
                                 Wallet.objects.get(user=user),
                                 'buy',
                                 Future.objects.get(pk=4))
        # Now get the new orders for people.
        # First, get the order that was just created by this test user.
        order = Order.objects.all().order_by('-pk')[0]
        self.assertEqual(order.filled, False)
        self.assertEqual(order.quantity, 3)  # Should be 15 - (8 + 4)
        self.assertEqual(order.unit_price, 650)  # Unchanged
        # Get the filled orders.
        order_1 = Order.objects.get(pk=9)  # The 325 S
        order_2 = Order.objects.get(pk=3)  # The 650 S
        self.assertEqual(order_1.filled, True)
        self.assertEqual(order_2.filled, True)
        self.assertEqual(order_1.filled_by, user)
        self.assertEqual(order_2.filled_by, user)

def test_short_sell_validation(self):
        """
            We can't short sell if we're going to lose more money on it.
        """
        user = User.objects.get(pk=1)
        wallet = Wallet.objects.get(user=user)
        # Want to short-sell "Nigel Richards".
        future = Future.objects.get(pk=1)
        response = process_order(11, 800, wallet, 'sell', future)
        # We don't own Nigel, if event happens we stand to lose (1000 * 11)
        # which is more than this user's default wallet.
        self.assertContains(response, 'cannot short-sell', status_code=400)

def test_order_6(self):
        """
            A buy back of short-sold stock.
        """
        user = User.objects.get(pk=1)
        wallet = Wallet.objects.get(user=user)
        wallet.shares_owned = """{"4": -9, "1": 7}"""
        wallet.frozen = 9000
        wallet.points = 20000
        wallet.save()
        future = Future.objects.get(pk=4)
        # 8@600, 4@325
        # I want to buy 7@615
        response = process_order(7, 615, wallet, 'buy', future)
        order = Order.objects.all().order_by('-pk')[0]  # My buy.
        order_1 = Order.objects.get(pk=9)  # 4@325
        order_2 = Order.objects.get(pk=3)  # 8@600
        self.assertEqual(order_1.filled, True)
        self.assertEqual(order_2.filled, False)
        self.assertEqual(order.filled, True)
        self.assertEqual(order.filled_by, order_2.creator)
        self.assertEqual(order_2.quantity, 5)  # 3 got bought
        self.assertEqual(order_1.filled_by, user)
        self.assertEqual(order_2.filled_by, None)
        future = Future.objects.get(pk=4)
        self.assertEqual(future.last_buy, 600)
        self.assertEqual(future.ask, 600)  # Lowest sale order
        self.assertEqual(future.bid, 275)  # Highest buy order
        self.assertEqual(future.volume, 7)
        # History

def test_short_sell(self):
        user = User.objects.get(pk=1)
        wallet = Wallet.objects.get(user=user)
        # Want to short-sell "Nigel Richards".
        future = Future.objects.get(pk=1)
        wallet.points = 11000
        wallet.save()
        response = process_order(11, 140, wallet, 'sell', future)
        order = Order.objects.all().order_by('-pk')[0]
        order_1 = Order.objects.get(pk=1)  # Buy 10@155
        self.assertEqual(order_1.filled, True)
        self.assertEqual(order.filled, False)
        self.assertEqual(order.quantity, 1)
        self.assertEqual(order_1.filled_by, user)
        ### Future
        future = Future.objects.get(pk=1)
        self.assertEqual(future.last_buy, 155)
        self.assertEqual(future.ask, 140)
        self.assertEqual(future.bid, None)
        self.assertEqual(future.volume, 10)
        history = FutureHistory.objects.filter(future=future)
        logger.debug(history)
        self.assertEqual(history.count(), 1)
        self.assertEqual(history[0].price, 155)

def test_simultaneous_sell_short(self):
        """
            Can't short-sell and regular sell the same shares simultaneously.
        """
        user = User.objects.get(pk=1)
        wallet = Wallet.objects.get(user=user)
        wallet.shares_owned = """{"1": 3}"""
        future = Future.objects.get(pk=1)
        response = process_order(4, 200, wallet, 'sell', future)
        # We only own 3 but are trying to sell 4.
        self.assertContains(response, 'two separate orders', status_code=400)

def test_basic_validator(self):
        wallet = Wallet.objects.get(pk=2)
        future = Future.objects.get(pk=3)
        response = process_order(10000, 25, wallet, 'buy', future)
        self.assertContains(response, 'cannot spend', status_code=400)

def test_order_2(self):
        """
            Test that orders are prioritized by price then chronologically.
        """
        user = User.objects.get(pk=8)
        wallet = Wallet.objects.get(user=user)
        # Want to buy future "Jesse Day".
        # There is a sell order of 8 for 600, a buy order of 4 for 100,
        # a sell order of 4 for 325, a buy order of 4 for 275 in the fixture.
        future = Future.objects.get(pk=4)
        response = process_order(4, 600, wallet, 'buy', future)
        # Get my order
        order = Order.objects.all().order_by('-pk')[0]
        self.assertEqual(order.filled, True)
        self.assertEqual(order.unit_price, 600)  # Unchanged
        # Get the matching orders.
        order_1 = Order.objects.get(pk=9)  # The 325 S
        order_2 = Order.objects.get(pk=3)  # The 650 S
        self.assertEqual(order_1.filled, True)
        self.assertEqual(order_2.filled, False)
        self.assertEqual(order_1.filled_by, user)

def test_order_3(self):
        """
            Test second priority (chronologically).
        """
        user = User.objects.get(pk=1)
        wallet = Wallet.objects.get(user=user)
        # Want to buy future "Nigel Richards"
        # There's a buy order for 10@155, sell for 12@600, sell for 5@600
        future = Future.objects.get(pk=1)
        response = process_order(5, 620, wallet, 'buy', future)
        # Get my order.
        order = Order.objects.all().order_by('-pk')[0]
        self.assertEqual(order.filled, True)
        self.assertEqual(order.unit_price, 620)  # Unchanged
        # Get the matching orders.
        order_1 = Order.objects.get(pk=10)  # The 12 orders
        order_2 = Order.objects.get(pk=12)  # The 5 orders
        self.assertEqual(order_1.filled, False)  # Not fully filled
        self.assertEqual(order_2.filled, False)
        self.assertEqual(order_1.quantity, 7)   # Updated quantity.
        self.assertEqual(order_2.quantity, 5)   # This order never changed.
        self.assertEqual(order.filled_by, order_1.creator)

def test_order_5(self):
        """
            A regular sell to multiple people, with some stock still left over.
        """
        user = User.objects.get(pk=1)
        wallet = Wallet.objects.get(user=user)
        wallet.shares_owned = """{"4": 95, "1": 7}"""
        future = Future.objects.get(pk=4)
        # Sell 93 shares at 95 each.
        response = process_order(93, 95, wallet, 'sell', future)
        # Someone wants to buy 75@100, 15@275
        order = Order.objects.all().order_by('-pk')[0]  # My sell.
        order_1 = Order.objects.get(pk=11)  # 15@275
        order_2 = Order.objects.get(pk=5)   # 75@100
        self.assertEqual(order_1.filled, True)
        self.assertEqual(order_2.filled, True)
        self.assertEqual(order.filled, False)
        self.assertEqual(order.quantity, 3)
        self.assertEqual(order_1.filled_by, user)
        self.assertEqual(order_2.filled_by, user)
        future = Future.objects.get(pk=4)
        self.assertEqual(future.last_buy, 100)
        self.assertEqual(future.ask, 95)  # Lowest sale order, my own
        self.assertEqual(future.bid, None)  # Highest buy order
        self.assertEqual(future.volume, 90)
        # History

def test_order_4(self):
        """
            Regular sell.
        """
        user = User.objects.get(pk=1)
        wallet = Wallet.objects.get(user=user)
        wallet.shares_owned = """{"1": 7, "4": 10}"""
        future = Future.objects.get(pk=1)
        response = process_order(4, 150, wallet, 'sell', future)
        # Someone wants to buy 10@155
        order = Order.objects.all().order_by('-pk')[0]
        order_1 = Order.objects.get(pk=1) # Buy 10@155
        self.assertEqual(order_1.filled, False)
        self.assertEqual(order.filled, True)
        self.assertEqual(order_1.quantity, 6)
        self.assertEqual(order.filled_by, order_1.creator)
        future = Future.objects.get(pk=1)
        self.assertEqual(future.last_buy, 155)
        self.assertEqual(future.ask, 600)
        self.assertEqual(future.bid, 155)
        self.assertEqual(future.volume, 4)
        history = FutureHistory.objects.filter(future=future)
        self.assertEqual(history.count(), 1)
        self.assertEqual(history[0].price, 155)
        transactions = SuccessfulTransaction.objects.filter(future=future)