def testMixedAddition(self):
		fiveBucks = Money.dollar(5)
		tenFrancs = Money.franc(10)
		bank = Bank()
		bank.addRate('CHF', 'USD', 2)
		result = bank.reduce(fiveBucks.plus(tenFrancs), 'USD')
		self.assertEquals(Money.dollar(10), result)

    def test_return_the_difference_between_the_two_same_nationality_money(self):
        money_yen1 = Money.yen(20)
        money_yen2 = Money.yen(5)

        expected = Money.yen(15)
        money_diff = money_yen1 - money_yen2
        self.assertTrue(expected == money_diff)

    def test_return_the_sum_of_two_same_nationality_money(self):
        money_yen1 = Money.yen(10)
        money_yen2 = Money.yen(5)

        expected = Money.yen(15)
        money_sum = money_yen1 + money_yen2
        self.assertTrue(expected == money_sum)

    def test_less_equal_with_two_different_nationality_money(self):
        greatest = Money.dollar(20.1)
        median = Money.yen(10)
        median.set_exchanger(DummyExchanger())
        least = Money.dollar(19.9)

        self.check_less_operator_of_rich_comparison(median.__le__, greatest, median, least, True)

    def load_from_db(self, id):
        rows = self.select_by_id('player', id)
        for row in rows:
            self.id = row[0]
            self.name = row[1]
            self.password = row[2]
            self.email = row[3]

            with self.connection:
                cursor = self.connection.cursor()
                cursor.execute(
                    "select achievement_id from achievement_player where player_id={}".format(id))

                for achievement_player_row in cursor.fetchall():
                    achievement_id = achievement_player_row[0]
                    achievement = Achievement(self.connection)
                    self.achievements.append(achievement.load_from_db(achievement_id))

                cursor.execute(
                    "select counter_id from counter_player where player_id={}".format(id))

                for counter_player_row in cursor.fetchall():
                    counter_id = counter_player_row[0]
                    counter = Counter(self.connection)
                    self.counters.append(counter.load_from_db(counter_id))

                cursor.execute("select id from money where player_id={}".format(id))
                for money_row in cursor.fetchall():
                    money_id = money_row[0]
                    money = Money(self.connection)
                    money.load_from_db(money_id)
                    self.wallet[money.type] = money

    def test_return_the_difference_between_the_different_nationality_money(self):
        money_yen = Money.yen(10)
        money_yen.set_exchanger(DummyExchanger())
        money_dollar = Money.dollar(2)

        expected = Money.yen(9)
        money_diff = money_yen - money_dollar
        self.assertTrue(expected == money_diff)

    def test_return_the_sum_of_two_different_nationality_money(self):
        money_yen = Money.yen(10)
        money_yen.set_exchanger(DummyExchanger())
        money_dollar = Money.dollar(5)

        expected = Money.yen(12.5)
        money_sum = money_yen + money_dollar
        self.assertTrue(expected == money_sum)

    def test_return_the_money_that_aligned_the_unit_to_currency_of_each_nationality(self):
        money_yen = Money.yen(10.2)
        expected = (10, 0)
        self.assertTrue(expected == money_yen.currency())

        money_dollar = Money.dollar(10.2)
        expected = (10, 20)
        self.assertTrue(expected == money_dollar.currency())

    def test_money_exchange_yen_to_dollar(self):
        money = Money.yen(10)
        money.set_exchanger(DummyExchanger())

        expected = Money.dollar(20)
        result_money = money.exchange("dollar")

        self.assertTrue(expected == result_money)

	def testSumTimes(self):
		fiveBucks = Money.dollar(5)
		tenFrancs = Money.franc(10)
		bank = Bank()
		bank.addRate('CHF', 'USD', 2)
		sum = Sum(fiveBucks, tenFrancs).times(2)
		result = bank.reduce(sum, 'USD')
		self.assertEquals(Money.dollar(20), result)

 def testMoney(self):
     """"""
     USD100 = Money(100, "USD")
     EUR100 = Money(100, "EUR")
     self.assertEquals(Decimal(139),EUR100.convert_to_default())
     self.assertEquals(Decimal(100),EUR100.convert_to_default() - 39)
     Currency.objects.set_currency('1.5', 'EUR')
     exc2 = Currency.objects.get_currency("EUR")
     self.assertEquals(Decimal('1.5'), exc2.exchange_rate)
     EUR1000 = Money(1000, "EUR")
     self.assertEquals(Decimal(1500),EUR1000.convert_to_default())
     self.assertNotEquals(Decimal(150),EUR100.convert_to_default())

    def __init__(self, amount=Decimal("0.0"), currency=None):
        if isinstance(amount, OriginalMoney):
            try:
                amount = amount.amount
            except AttributeError: # just in case python-money is not installed (Decimal assumes as OriginalMoney)
                pass
        currency = currency or settings.DEFAULT_CURRENCY

        if OriginalMoney == Decimal:
            OriginalMoney.__init__(self, amount)
            self.amount = amount
            self.currency = currency
        else:
            OriginalMoney.__init__(self, str(amount).replace(get_format('THOUSAND_SEPARATOR'),''), currency)

    def convert(self, value, currency):

        currency = str(currency).upper()
        if currency != "USD":
            if currency not in self.currencies:
                print("Currency: " + str(currency))
            assert currency in self.currencies, "ERROR: currency is not in listed currencies."

            value = float(value) / 100.0
            val_money = Money(value, currency)

            return float(val_money.to("USD"))

        # Does this only for USD
        return float(value) / 100.0

    def test_price_attribute(self):
        e = SimpleMoneyModel()
        e.price = Money(3, "BGN")
        self.assertEqual(e.price, Money(3, "BGN"))

        e.price = Money.from_string("BGN 5.0")
        self.assertEqual(e.price, Money(5, "BGN"))

 def to_python(self, value):
     if value is None:
         return value
     if isinstance(value, Money):
         return value
     elif isinstance(value, Decimal):
         return Money(value)
     else:
         m = self.postgres_money_re.match(value)
         if m is not None:
             return Money(amount=m.group(1), currency=m.group(2))
         else:
             return Money.from_string(value)

 def load_from_db(self, email):
     cur = con.cursor()
     sql_data_email = {
         "email": email
     }
     sql_query = """SELECT id, type, name, email, password, created, updated FROM player WHERE email=%(email)s"""
     cur.execute(sql_query, sql_data_email)
     row = cur.fetchone()
     self.player_id = row[0]
     self.name = row[2]
     self.email = row[3]
     self.password = row[4]
     self.created = row[5]
     self.updated = row[6]
     if row[1] == 'Player':
         self.__class__ = Player
     elif row[1] == 'Admin':
         self.__class__ = Admin
     else:
         self.__class__ = Moder
     self.sessions = Session().load_from_db_player(self.player_id)
     self.wallet = Money().load_from_db_player(self.player_id)
     self.achievements = Achievement().load_from_db_player(self.player_id)
     self.counter = Counter().load_from_db_player(self.player_id)

	def testMultiplication(self):
		five = Money.dollar(5)
		self.assertEquals(Money.dollar(10), five.times(2))
		self.assertEquals(Money.dollar(15), five.times(3))

 def convert_to_default(self):
     return Money(OriginalMoney.convert_to_default(self))

 def __div__(self, other):
     return Money(OriginalMoney.__div__(self, other))

	def testPlusReturnsSum(self):
		five = Money.dollar(5)
		sum = five.plus(five)
		self.assertEquals(five, sum.augend)
		self.assertEquals(five, sum.addend)