Exemple #1
0
class MyTestCase(unittest.TestCase):
    """ Simple Test """
    def setUp(self):
        """ Hook method for setting up the test fixture before exercising it. """
        self.account_data = {"id": "1", "name": "test"}
        mock_data_interface = Mock()
        mock_data_interface.get_id.return_value = '1'
        mock_data_interface.get_name.return_value = 'test'
        mock_data_interface.get.side_effect = AccountException()
        self.account = Account(mock_data_interface)

    def test_account_returns_data_for_id(self):
        """ Simple Test for ID """
        self.assertEqual(self.account_data["id"],
                         self.account.get_account_id())

    def test_account_returns_data_for_name(self):
        """ Simple Test for NAME """
        self.assertEqual(self.account_data["name"],
                         self.account.get_account_name())

    def test_account_when_connect_exception_raised(self):
        """ Raises Exception """
        self.assertEqual("Connection error occurred",
                         self.account.get_account())
 def test_from_pk(self):
     result = Account.from_pk(jimid)
     self.assertIsInstance(result, Account,
                           "from_pk returns an instance of an account")
     self.assertEqual(result.email, "*****@*****.**")
     self.assertIsNone(Account.from_pk(0),
                       "from_pk returns None for bad pk")
Exemple #3
0
 def test_account_conn_exception(self):
     mock_data_interface = Mock()
     mock_data_interface.get.side_effect = ConnectionError()
     # mock_data_interface.wibble_list = ['wibble', 'wobble']
     account = Account(mock_data_interface)
     self.assertEqual("Connection error occurred. Try Again.",
                      account.get_account(1))
 def test_login_attempt(self):
     result = Account.from_pk(jimid)
     result.set_password("password")
     result.save()
     test = Account.login_attempt("JimmyLove", "password")
     self.assertIsNotNone(test,
                          "login should work with the username & password")
Exemple #5
0
def filter_byAgeGap(age_gap, ids, sort=False, tags: list = []):
    selector = {
        "user": {
            "$in": ids
        },
        "$and": [{
            "$where": "this.tags.length >= 5"
        }, {
            "$where": "this.images.length >= 1"
        }, {
            "$where": "this.gender != '%s'" % Account.GENDER_UNSET
        }, {
            "$where": "this.biography.length >= 25"
        }]
    }
    if age_gap >= 0:
        curr = Account.get({"user": current_user._id}, {"dob": 1})["dob"]
        min = curr - relativedelta.relativedelta(years=int(age_gap))
        max = curr + relativedelta.relativedelta(years=int(age_gap))
        selector = {**selector, **{"dob": {"$lte": max, "$gte": min}}}
    if tags:
        selector = {**selector, **{"tags": {"$all": tags}}}
    ret = Account.get(selector, {"user": 1, "class": 1, "dob": 1})
    if not ret:
        return []
    if not isinstance(ret, list):
        ret = [ret]
    if sort:
        ret.sort(key=lambda x: x.age(), reverse=True)
    ret = [x.user for x in ret]
    return ret
Exemple #6
0
 def test_withdraw(self):
     # Given
     account = Account(Decimal(100))
     amount = Decimal(10)
     # When
     account.withdraw(amount)
     # Then
     assert account.balance == Decimal(90)
Exemple #7
0
def viewapikey(name, password):
    if not Account.login(name, password):
        msg = "Invalid login credentials, pls retry"
    else:
        pk = Account.login(name, password).pk
        retrieve_ak = Account(pk=pk)
        msg = "Your API Key = {}".format(retrieve_ak.get_account().api_key)
    return jsonify({'message': msg})
 def test_get_current_balance_returns_data_correctly(self, mock_requests):
     mock_response = Mock()
     mock_response.status_code = 200
     mock_response.text = 'Some text data'
     mock_requests.get.return_value = mock_response
     account = Account(Mock())
     self.assertEqual({'status': 200, 'data': 'Some text data'},
                      account.get_current_balance('1'))
Exemple #9
0
def balance(api_key):
    if Account.api_authenticate(api_key) == None:
        msg = "Invalid login credentials, pls retry"
    else: 
        pk = Account.api_authenticate(api_key).pk
        retrieve_bal = Account(pk=pk)
        msg = "Your current balance = {}".format(retrieve_bal.get_account().balance)
    return jsonify({'message':msg})
Exemple #10
0
 def setUp(self):
     """ Hook method for setting up the test fixture before exercising it. """
     self.account_data = {"id": "1", "name": "test"}
     mock_data_interface = Mock()
     mock_data_interface.get_id.return_value = '1'
     mock_data_interface.get_name.return_value = 'test'
     mock_data_interface.get.side_effect = AccountException()
     self.account = Account(mock_data_interface)
Exemple #11
0
def buy(key, ticker, shares):
    if Account.api_authenticate(key) == None:
        msg = "Invalid login credentials, pls retry"
    else:
        #pk = Account.login(name, password).pk
        pk = Account.api_authenticate(key).pk
        buy_txn = Account(pk=pk)
        msg = buy_txn.buy(ticker, shares)
    return jsonify({'message': msg})
 def test_update(self):  #Tests Save - update function
     result = Account.from_pk(jimid)
     result.balance = 100
     result.save()
     result = Account.all()  #using the all fucntion to count rows in DB
     self.assertEqual(
         result[0].balance, 100,
         "all func populates attributes, checking updated first for row[0] / pk1"
     )
Exemple #13
0
def create():
    if not request.json or 'username' not in request.json or 'password_hash' not in request.json:
        return jsonify(BAD_REQUEST), 401
    account = Account(username=request.json['username'],
                      password_hash=request.json['password_hash'])
    account.save()
    token = encodeAuthToken(account.pk)

    return jsonify({'status': 'success', 'auth_token': str(token)})
Exemple #14
0
def admin_leaderboard():
    print('Terminal Trader Leaderboard\n')
    accounts = Account.all()
    account_username_pk_list = []
    for account in accounts:
        account_username_pk_list.append(
            [account, account.pk, account.username])
    for item in account_username_pk_list:
        Account.leaderboard_stats_by_acct(item[0], item[1], item[2])
Exemple #15
0
def viewbalance(name, password):
    if not Account.login(name, password):
        msg = "Invalid login credentials, pls retry"
    else:
        pk = Account.login(name, password).pk
        retrieve_bal = Account(pk=pk)
        msg = "Your current balance = {}".format(
            retrieve_bal.get_account().balance)
    return jsonify({'message': msg})
Exemple #16
0
def sell(api_key):
    if Account.api_authenticate(api_key) == None:        
        msg = "Invalid login credentials, pls retry"
    else: 
        if not request.json or 'ticker' not in request.json or 'volume' not in request.json:
            return jsonify({"error": "bad request"}), 400
        pk = Account.api_authenticate(api_key).pk
        sell_txn = Account(pk=pk)
        msg = sell_txn.sell(request.json['ticker'], request.json['volume'])
    return jsonify({'message':msg})  
Exemple #17
0
 def test_current_balance(self, mock_requests):  # mock_the thing we patched
     mock_response = Mock()
     mock_response.status_code = 200
     mock_response.text = 'any old text'
     mock_requests.get.return_value = mock_response
     account = Account(Mock())
     self.assertEqual({
         'status': 200,
         'data': 'any old text'
     }, account.get_current_balance('1'))
Exemple #18
0
def sell(name, password, ticker, shares):
    if not Account.login(name, password):
        msg = "Invalid login credentials, pls retry"
    else:
        pk = Account.login(name, password).pk
        sell_txn = Account(pk=pk)
        # sell_txn.sell(ticker, shares)
        # msg = "Sell transaction complete"
        msg = sell_txn.sell(ticker, shares)
    return jsonify({'message': msg})
Exemple #19
0
def buy(name, password, ticker, shares):
    if not Account.login(name, password):
        msg = "Invalid login credentials, pls retry"
    else:
        pk = Account.login(name, password).pk
        buy_txn = Account(pk=pk)
        # buy_txn.buy(ticker, shares)
        # msg = "Buy transaction complete"
        msg = buy_txn.buy(ticker, shares)
    return jsonify({'message': msg})
Exemple #20
0
 def test_get_current_balance_returns_data_correctly(self, mock_requests):
     mock_response = Mock()
     mock_response.status_code = 200
     mock_response.text = 'Some text data'
     mock_requests.get.return_value = mock_response
     account = Account(Mock())
     self.assertEqual({
         'status': 200,
         'data': 'Some text data'
     }, account.get_current_balance('1'))
Exemple #21
0
    def test_add_account(self):
        bank = Bank()

        account_1 = Account("001", 50)
        account_2 = Account("002", 100)

        bank.add_account(account_1)
        bank.add_account(account_2)

        self.assertEqual(len(bank.accounts), 2)
def login_menu():
    while True:
        try:
            user_input = view.login_menu()
            if int(user_input) == 3:
                view.program_end()
                sys.exit()
            elif int(user_input) == 2:
                username = view.username_inpt()
                pwd = util.hash_pass(view.password_inpt())
                user = Account.login(username, pwd)
                if user == None:
                    view.invalid_info()
                    return login_menu()
                return user
            elif int(user_input) == 1:
                user = Account()
                user.username = view.username_inpt()
                user.set_password(util.hash_pass(view.set_password_inpt()))
                user.balance = view.deposit_inpt()
                user.save()
                view.acc_created(user.username)
                return user
        except ValueError:
            view.choose_valid()
def positions_sub_menu(pk):
    retrieve_bal = Account(pk=pk)
    views.generic_msg("Your current balance = {}".format(
        retrieve_bal.get_account().balance))
    while True:
        position_choice = views.position_menu()
        if position_choice is None:  #Bad input
            views.generic_msg(
                "Please enter a number that corresponds to a stated option")
        elif position_choice == 3:  #Exit
            break
        elif position_choice == 1:  #Retrieve and display a given position
            ticker = views.get_input("Please enter a Ticker Symbol")
            user_position = Account(pk=pk)
            position = user_position.get_position_for(ticker)
            valuation = Position()
            getval = valuation.current_value(ticker, position.shares)
            views.show_positions(position, getval)
        elif position_choice == 2:  #Retrieve and display all positions
            user_positions = Account(pk=pk)
            positions = user_positions.get_positions()
            for position in positions:
                valuation = Position()
                getval = valuation.current_value(position.ticker,
                                                 position.shares)
                views.show_positions(position, getval)
    def test_user_can_deposit(self):
        # Arrange
        account = Account("Alan", "33")
        expected_result = 100

        # Act
        account.deposit(100)
        observed = account.balance

        # Assert
        self.assertEqual(observed, expected_result)
    def test_user_can_withdraw_amount_not_in_account(self):
        # Arrange
        account = Account("Alan", "33")
        account.balance = 100
        expected_result = "Sorry insufficent funds"

        # Act
        observed = account.withdraw(101)

        # Assert
        self.assertEqual(observed, expected_result)
Exemple #26
0
def account_create():
    username, password, f_name, l_name, deposit = view.create_account(
    )  #takes all return values from create_account
    crypted_password = crypt_password(password)

    new_account = Account(username=username,
                          crypted_password=crypted_password,
                          f_name=f_name,
                          l_name=l_name,
                          balance=deposit)
    new_account.save()
Exemple #27
0
def positions(api_key, ticker):
    if Account.api_authenticate(api_key) == None:    
        msg = "Invalid login credentials, pls retry"
    else: 
        pk = Account.api_authenticate(api_key).pk
        user_position = Account(pk=pk)
        position = user_position.get_position_for(ticker)
        valuation = Position()  
        getval = valuation.current_value(ticker, position.shares)      
        msg = "Ticker Symbol: {}, Shares: {}, Valuation: ${}".format(position.ticker, position.shares, getval)
    return jsonify({'message':msg}) 
def login_account():
    loginaccount = Account()
    view.enter_user_name()
    username = input()
    view.enter_password()
    password = getpass.getpass()
    enteraccount = loginaccount.login(username, password)
    if enteraccount is None:
        view.login_failed_message()
        return login_menu()
    elif enteraccount is not None:
        return main_menu(enteraccount)
Exemple #29
0
 def test_get_account_returns_data_for_id_1(self):
     account_data = {"id": "1", "name": "test"}
     # we can Mock external dependencies ssuch as services, API endpoints etc.
     mock_data_interface = Mock()
     mock_data_interface.get.return_value = account_data
     # use the mock as we instantiate an Account
     account = Account(mock_data_interface)
     # now make a unittetst asertion
     # wrong = {"id":"2", "name":"test"} # this fails the test!
     # self.assertDictEqual( wrong, account.get_account(1) )
     self.assertDictEqual(account_data,
                          account.get_account(1))  # this passes the test
Exemple #30
0
def positions(name, password, ticker):
    if not Account.login(name, password):
        msg = "Invalid login credentials, pls retry"
    else:
        pk = Account.login(name, password).pk
        user_position = Account(pk=pk)
        position = user_position.get_position_for(ticker)
        valuation = Position()
        getval = valuation.current_value(ticker, position.shares)
        msg = "Ticker Symbol: {}, Shares: {}, Valuation: ${}".format(
            position.ticker, position.shares, getval)
    return jsonify({'message': msg})
    def test_user_can_withdraw_amount_in_account(self):
        # Arrange
        account = Account("Alan", "33")
        account.balance = 200
        expected_result = 100

        # Act
        account.withdraw(100)
        observed = account.balance

        # Assert
        self.assertEqual(observed, expected_result)
 def test_account_when_connect_exception_raised(self):
     mock_data_interface = Mock()
     mock_data_interface.get.side_effect = ConnectionError()
     account = Account(mock_data_interface)
     self.assertEqual("Connection error occurred. Try Again.", account.get_account(1))
 def test_account_returns_data_for_id_1(self):
     account_data = {"id": "1", "name": "test"}
     mock_data_interface = Mock()
     mock_data_interface.get.return_value = account_data
     account = Account(mock_data_interface)
     self.assertDictEqual(account_data, account.get_account(1))