Python MockServer 예제들

예제 #1

파일: test_get_coin_value.py 프로젝트: rickdenhaan/eobot-py

class GetCoinValueTest(unittest.TestCase):
    def setUp(self):
        self.server = MockServer()
        self.server.start()

    def tearDown(self):
        self.server.stop()

    def test_perform_request_without_coin(self):
        with self.assertRaises(TypeError):
            # noinspection PyArgumentList
            perform_request()

    def test_perform_request_with_invalid_coin(self):
        with self.assertRaises(ValueError):
            # noinspection PyTypeChecker
            perform_request(123)

    def test_perform_request_with_invalid_request(self):
        with self.assertRaises(ValueError):
            # noinspection PyTypeChecker
            perform_request("BTC", request={})

    def test_perform_request(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://localhost:{0}/api.test'.format(
            self.server.port))

        value = perform_request("BTC", request=req.clone())

        self.assertIsInstance(value, float)
        self.assertEqual(100.0, value)

예제 #2

파일: test_get_exchange_estimate.py 프로젝트: rickdenhaan/eobot-py

class GetExchangeEstimateTest(unittest.TestCase):
    def setUp(self):
        self.server = MockServer()
        self.server.start()

    def tearDown(self):
        self.server.stop()

    def test_perform_request_without_arguments(self):
        with self.assertRaises(TypeError):
            # noinspection PyArgumentList
            perform_request()

    def test_perform_request_without_from_coin(self):
        with self.assertRaises(TypeError):
            # noinspection PyArgumentList
            perform_request(amount=1.0, to_coin="ETH")

    def test_perform_request_without_to_coin(self):
        with self.assertRaises(TypeError):
            # noinspection PyArgumentList
            perform_request(from_coin="BTC", amount=1.0)

    def test_perform_request_without_amount(self):
        with self.assertRaises(TypeError):
            # noinspection PyArgumentList
            perform_request(from_coin="BTC", to_coin="ETH")

    def test_perform_request_with_invalid_from_coin(self):
        with self.assertRaises(ValueError):
            # noinspection PyTypeChecker
            perform_request(123, "ETH", 1.0)

    def test_perform_request_with_invalid_to_coin(self):
        with self.assertRaises(ValueError):
            # noinspection PyTypeChecker
            perform_request("BTC", 123, 1.0)

    def test_perform_request_with_invalid_amount(self):
        with self.assertRaises(ValueError):
            # noinspection PyTypeChecker
            perform_request("BTC", "ETH", "one")

    def test_perform_request_with_invalid_request(self):
        with self.assertRaises(ValueError):
            # noinspection PyTypeChecker
            perform_request("BTC", "ETH", 1.0, request={})

    def test_perform_request(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://localhost:{0}/api.test'.format(
            self.server.port))

        estimate = perform_request("BTC", "ETH", 1.0, request=req.clone())

        self.assertIsInstance(estimate, float)
        self.assertEqual(5.0, estimate)

예제 #3

파일: test_get_exchange_rate.py 프로젝트: rickdenhaan/eobot-py

    def test_perform_request(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://localhost:{0}/api.test'.format(self.server.port))

        rate = perform_request("EUR", request=req.clone())

        self.assertIsInstance(rate, float)
        self.assertEqual(0.85, rate)

예제 #4

파일: test_get_coin_value.py 프로젝트: rickdenhaan/eobot-py

    def test_perform_request(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://localhost:{0}/api.test'.format(
            self.server.port))

        value = perform_request("BTC", request=req.clone())

        self.assertIsInstance(value, float)
        self.assertEqual(100.0, value)

예제 #5

파일: test_get_exchange_estimate.py 프로젝트: rickdenhaan/eobot-py

    def test_perform_request(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://localhost:{0}/api.test'.format(
            self.server.port))

        estimate = perform_request("BTC", "ETH", 1.0, request=req.clone())

        self.assertIsInstance(estimate, float)
        self.assertEqual(5.0, estimate)

예제 #6

파일: test_get_deposit_address.py 프로젝트: rickdenhaan/eobot-py

    def test_perform_request_with_config_without_user_id(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://*****:*****@example.com", password="******", token=None)

        wallet = perform_request("BTC", config=get_config("tgda2"), request=req.clone())

        self.assertIsInstance(wallet, basestring)
        self.assertEqual("wallet-bitcoin", wallet)

예제 #7

파일: test_get_deposit_address.py 프로젝트: rickdenhaan/eobot-py

    def test_perform_request_with_config(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://*****:*****@example.com", password="******", token=None)

        wallet = perform_request("ETH", config="tgda", request=req.clone())

        self.assertIsInstance(wallet, basestring)
        self.assertEqual("wallet-ethereum", wallet)

예제 #8

파일: test_get_deposit_address.py 프로젝트: rickdenhaan/eobot-py

    def test_perform_request(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://*****:*****@example.com", password="******", token=None)

        wallet = perform_request("BTC", request=req.clone())

        self.assertIsInstance(wallet, basestring)
        self.assertEqual("bitcoin-wallet", wallet)

예제 #9

파일: test_exchange_coins.py 프로젝트: rickdenhaan/eobot-py

    def test_perform_request_with_config_without_user_id(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://*****:*****@example.com", password="******", token=None)

        result = perform_request("ETH", 0.5, "BTC", config="tec2", request=req.clone())
        self.assertTrue(result)

        self.assertEqual(0.2, get_balances(config=get_config("tec2"), request=req.clone())["BTC"])
        self.assertEqual(1.5, get_balances(config=get_config("tec2"), request=req.clone())["ETH"])

예제 #10

파일: test_get_supported_coins.py 프로젝트: rickdenhaan/eobot-py

class GetSupportedCoinsTest(unittest.TestCase):
    def setUp(self):
        self.server = MockServer()
        self.server.start()

    def tearDown(self):
        self.server.stop()

    def test_perform_request_with_invalid_request(self):
        with self.assertRaises(ValueError):
            # noinspection PyTypeChecker
            perform_request(request={})

    def test_perform_request(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://localhost:{0}/api.test'.format(
            self.server.port))

        coins = perform_request(request=req.clone())

        self.assertIsInstance(coins, dict)
        self.assertIn("BTC", coins.keys())
        self.assertIn("ETH", coins.keys())

        self.assertIsInstance(coins["BTC"], dict)
        self.assertIsInstance(coins["ETH"], dict)

        self.assertIn("Price", coins["BTC"].keys())
        self.assertIn("Image", coins["BTC"].keys())
        self.assertIn("BigImage", coins["BTC"].keys())

        self.assertIn("Price", coins["ETH"].keys())
        self.assertIn("Image", coins["ETH"].keys())
        self.assertIn("BigImage", coins["ETH"].keys())

        self.assertIsInstance(coins["BTC"]["Price"], float)
        self.assertIsInstance(coins["BTC"]["Image"], basestring)
        self.assertIsInstance(coins["BTC"]["BigImage"], basestring)

        self.assertIsInstance(coins["ETH"]["Price"], float)
        self.assertIsInstance(coins["ETH"]["Image"], basestring)
        self.assertIsInstance(coins["ETH"]["BigImage"], basestring)

        self.assertEqual(100.0, coins["BTC"]["Price"])
        self.assertEqual("http://www.eobot.com/btc.png", coins["BTC"]["Image"])
        self.assertEqual("http://www.eobot.com/btcbig.png",
                         coins["BTC"]["BigImage"])

        self.assertEqual(20.0, coins["ETH"]["Price"])
        self.assertEqual("http://www.eobot.com/eth.png", coins["ETH"]["Image"])
        self.assertEqual("http://www.eobot.com/ethbig.png",
                         coins["ETH"]["BigImage"])

예제 #11

파일: test_get_mining_estimates.py 프로젝트: rickdenhaan/eobot-py

    def test_perform_request(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://*****:*****@example.com", password="******", token=None)

        estimates = perform_request(request=req.clone())

        self.assertIsInstance(estimates, dict)
        self.assertIn("MiningSHA-256", estimates.keys())

        self.assertIsInstance(estimates["MiningSHA-256"], float)
        self.assertEqual((1.0/6.0), estimates["MiningSHA-256"])

예제 #12

파일: test_get_mining_estimates.py 프로젝트: rickdenhaan/eobot-py

    def test_perform_request_with_config_without_user_id(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://*****:*****@example.com", password="******", token=None)

        estimates = perform_request(config=get_config("tgme2"), request=req.clone())

        self.assertIsInstance(estimates, dict)
        self.assertIn("MiningSHA-256", estimates.keys())

        self.assertIsInstance(estimates["MiningSHA-256"], float)
        self.assertEqual((1.0/12.0), estimates["MiningSHA-256"])

예제 #13

    def test_perform_request_with_config_without_user_id(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://*****:*****@example.com",
                                      password="******",
                                      token=None)

        mode = perform_request(config=get_config("tgmm2"), request=req.clone())

        self.assertIsInstance(mode, basestring)
        self.assertEqual("ETH", mode)

예제 #14

파일: test_exchange_coins.py 프로젝트: rickdenhaan/eobot-py

    def test_perform_request(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://*****:*****@example.com", password="******", token=None)

        self.assertEqual(0.2, get_balances(request=req.clone())["BTC"])
        self.assertEqual(2.5, get_balances(request=req.clone())["ETH"])

        result = perform_request("BTC", 0.1, "ETH", request=req.clone())
        self.assertTrue(result)

        self.assertEqual(0.1, get_balances(request=req.clone())["BTC"])
        self.assertEqual(3.0, get_balances(request=req.clone())["ETH"])

예제 #15

    def test_perform_request_with_config(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://*****:*****@example.com",
                                      password="******",
                                      token=None)

        user_id = perform_request(config="tgui3", request=req.clone())

        self.assertIsInstance(user_id, int)
        self.assertEqual(456, user_id)

예제 #16

    def test_perform_request_with_config_without_user_id(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://*****:*****@example.com",
                                      password="******",
                                      token=None)

        result = perform_request("BTC",
                                 0.05,
                                 "wallet-bitcoin",
                                 config="tsaw2",
                                 request=req.clone())
        self.assertTrue(result)

예제 #17

    def test_perform_request(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://*****:*****@example.com",
                               password="******",
                               token=None)

        result = perform_request("BTC",
                                 0.1,
                                 "bitcoin-wallet",
                                 request=req.clone())
        self.assertTrue(result)

예제 #18

파일: test_get_balances.py 프로젝트: rickdenhaan/eobot-py

    def test_perform_request_with_config_without_user_id(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://*****:*****@example.com", password="******", token=None)

        balances = perform_request(config=get_config("tgb2"), request=req.clone())

        self.assertIsInstance(balances, dict)
        self.assertEqual(3, len(balances))
        self.assertIn("BTC", balances.keys())
        self.assertIn("ETH", balances.keys())
        self.assertIn("Total", balances.keys())

        self.assertEqual(0.1, balances["BTC"])
        self.assertEqual(2.0, balances["ETH"])
        self.assertEqual(50.0, balances["Total"])

예제 #19

파일: test_get_balances.py 프로젝트: rickdenhaan/eobot-py

    def test_perform_request(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://*****:*****@example.com", password="******", token=None)

        balances = perform_request(request=req.clone())

        self.assertIsInstance(balances, dict)
        self.assertEqual(3, len(balances))
        self.assertIn("BTC", balances.keys())
        self.assertIn("ETH", balances.keys())
        self.assertIn("Total", balances.keys())

        self.assertEqual(0.2, balances["BTC"])
        self.assertEqual(2.5, balances["ETH"])
        self.assertEqual(70.0, balances["Total"])

예제 #20

파일: test_get_mining_speed.py 프로젝트: rickdenhaan/eobot-py

    def test_perform_request_with_config(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://*****:*****@example.com",
                                     password="******",
                                     token=None)

        speeds = perform_request(config="tgms", request=req.clone())

        self.assertIsInstance(speeds, dict)
        self.assertIn("MiningSHA-256", speeds.keys())

        self.assertIsInstance(speeds["MiningSHA-256"], float)
        self.assertEqual(5.0, speeds["MiningSHA-256"])

예제 #21

파일: test_get_supported_coins.py 프로젝트: rickdenhaan/eobot-py

    def test_perform_request(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://localhost:{0}/api.test'.format(
            self.server.port))

        coins = perform_request(request=req.clone())

        self.assertIsInstance(coins, dict)
        self.assertIn("BTC", coins.keys())
        self.assertIn("ETH", coins.keys())

        self.assertIsInstance(coins["BTC"], dict)
        self.assertIsInstance(coins["ETH"], dict)

        self.assertIn("Price", coins["BTC"].keys())
        self.assertIn("Image", coins["BTC"].keys())
        self.assertIn("BigImage", coins["BTC"].keys())

        self.assertIn("Price", coins["ETH"].keys())
        self.assertIn("Image", coins["ETH"].keys())
        self.assertIn("BigImage", coins["ETH"].keys())

        self.assertIsInstance(coins["BTC"]["Price"], float)
        self.assertIsInstance(coins["BTC"]["Image"], basestring)
        self.assertIsInstance(coins["BTC"]["BigImage"], basestring)

        self.assertIsInstance(coins["ETH"]["Price"], float)
        self.assertIsInstance(coins["ETH"]["Image"], basestring)
        self.assertIsInstance(coins["ETH"]["BigImage"], basestring)

        self.assertEqual(100.0, coins["BTC"]["Price"])
        self.assertEqual("http://www.eobot.com/btc.png", coins["BTC"]["Image"])
        self.assertEqual("http://www.eobot.com/btcbig.png",
                         coins["BTC"]["BigImage"])

        self.assertEqual(20.0, coins["ETH"]["Price"])
        self.assertEqual("http://www.eobot.com/eth.png", coins["ETH"]["Image"])
        self.assertEqual("http://www.eobot.com/ethbig.png",
                         coins["ETH"]["BigImage"])

예제 #22

파일: test_get_supported_fiat.py 프로젝트: rickdenhaan/eobot-py

    def test_perform_request(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://localhost:{0}/api.test'.format(
            self.server.port))

        fiat = perform_request(request=req.clone())

        self.assertIsInstance(fiat, dict)
        self.assertIn("USD", fiat.keys())
        self.assertIn("EUR", fiat.keys())

        self.assertIsInstance(fiat["USD"], dict)
        self.assertIsInstance(fiat["EUR"], dict)

        self.assertIn("Price", fiat["USD"].keys())
        self.assertIn("Price", fiat["EUR"].keys())

        self.assertIsInstance(fiat["USD"]["Price"], float)
        self.assertIsInstance(fiat["EUR"]["Price"], float)

        self.assertEqual(1.0, fiat["USD"]["Price"])
        self.assertEqual(0.85, fiat["EUR"]["Price"])

예제 #23

파일: test_get_supported_fiat.py 프로젝트: rickdenhaan/eobot-py

class GetSupportedFiatTest(unittest.TestCase):
    def setUp(self):
        self.server = MockServer()
        self.server.start()

    def tearDown(self):
        self.server.stop()

    def test_perform_request_with_invalid_request(self):
        with self.assertRaises(ValueError):
            # noinspection PyTypeChecker
            perform_request(request={})

    def test_perform_request(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://localhost:{0}/api.test'.format(
            self.server.port))

        fiat = perform_request(request=req.clone())

        self.assertIsInstance(fiat, dict)
        self.assertIn("USD", fiat.keys())
        self.assertIn("EUR", fiat.keys())

        self.assertIsInstance(fiat["USD"], dict)
        self.assertIsInstance(fiat["EUR"], dict)

        self.assertIn("Price", fiat["USD"].keys())
        self.assertIn("Price", fiat["EUR"].keys())

        self.assertIsInstance(fiat["USD"]["Price"], float)
        self.assertIsInstance(fiat["EUR"]["Price"], float)

        self.assertEqual(1.0, fiat["USD"]["Price"])
        self.assertEqual(0.85, fiat["EUR"]["Price"])

예제 #24

    def test_perform_request_with_error(self):
        server = MockServer()
        server.start()

        req = EobotRequest()
        req.set_base_url('http://localhost:{0}/api.test'.format(server.port))
        req.set_parameter("nosuch", "page")

        with self.assertRaises(RuntimeError):
            req.perform_request()

        server.stop()

예제 #25

    def test_perform_request(self):
        server = MockServer()
        server.start()

        req = EobotRequest()
        req.set_base_url('http://localhost:{0}/api.test'.format(server.port))
        req.set_parameter("coin", "BTC")
        response = req.perform_request()

        server.stop()

        self.assertIsInstance(response, dict)
        self.assertIn("BTC", response)
        self.assertIsInstance(response["BTC"], float)
        self.assertEqual(100.0, response["BTC"])

예제 #26

파일: test_get_mining_estimates.py 프로젝트: rickdenhaan/eobot-py

 def setUp(self):
     self.server = MockServer()
     self.server.start()

예제 #27

파일: test_get_mining_estimates.py 프로젝트: rickdenhaan/eobot-py

class GetMiningEstimatesTest(unittest.TestCase):
    def setUp(self):
        self.server = MockServer()
        self.server.start()

    def tearDown(self):
        self.server.stop()

    def test_perform_request_with_invalid_config(self):
        with self.assertRaises(ValueError):
            # noinspection PyTypeChecker
            perform_request(config={})

    def test_perform_request_with_invalid_request(self):
        with self.assertRaises(ValueError):
            # noinspection PyTypeChecker
            perform_request(request={})

    def test_perform_request(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://*****:*****@example.com", password="******", token=None)

        estimates = perform_request(request=req.clone())

        self.assertIsInstance(estimates, dict)
        self.assertIn("MiningSHA-256", estimates.keys())

        self.assertIsInstance(estimates["MiningSHA-256"], float)
        self.assertEqual((1.0/6.0), estimates["MiningSHA-256"])

    def test_perform_request_with_config(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://*****:*****@example.com", password="******", token=None)

        estimates = perform_request(config="tgme", request=req.clone())

        self.assertIsInstance(estimates, dict)
        self.assertIn("MiningSHA-256", estimates.keys())

        self.assertIsInstance(estimates["MiningSHA-256"], float)
        self.assertEqual((1.0/12.0), estimates["MiningSHA-256"])

    def test_perform_request_with_config_without_user_id(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://*****:*****@example.com", password="******", token=None)

        estimates = perform_request(config=get_config("tgme2"), request=req.clone())

        self.assertIsInstance(estimates, dict)
        self.assertIn("MiningSHA-256", estimates.keys())

        self.assertIsInstance(estimates["MiningSHA-256"], float)
        self.assertEqual((1.0/12.0), estimates["MiningSHA-256"])

예제 #28

파일: test_get_balances.py 프로젝트: rickdenhaan/eobot-py

class GetBalancesTest(unittest.TestCase):
    def setUp(self):
        self.server = MockServer()
        self.server.start()

    def tearDown(self):
        self.server.stop()

    def test_perform_request_with_invalid_config(self):
        with self.assertRaises(ValueError):
            # noinspection PyTypeChecker
            perform_request(config={})

    def test_perform_request_with_invalid_request(self):
        with self.assertRaises(ValueError):
            # noinspection PyTypeChecker
            perform_request(request={})

    def test_perform_request(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://*****:*****@example.com", password="******", token=None)

        balances = perform_request(request=req.clone())

        self.assertIsInstance(balances, dict)
        self.assertEqual(3, len(balances))
        self.assertIn("BTC", balances.keys())
        self.assertIn("ETH", balances.keys())
        self.assertIn("Total", balances.keys())

        self.assertEqual(0.2, balances["BTC"])
        self.assertEqual(2.5, balances["ETH"])
        self.assertEqual(70.0, balances["Total"])

    def test_perform_request_with_config(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://*****:*****@example.com", password="******", token=None)

        balances = perform_request(config="tgb", request=req.clone())

        self.assertIsInstance(balances, dict)
        self.assertEqual(3, len(balances))
        self.assertIn("BTC", balances.keys())
        self.assertIn("ETH", balances.keys())
        self.assertIn("Total", balances.keys())

        self.assertEqual(0.1, balances["BTC"])
        self.assertEqual(2.0, balances["ETH"])
        self.assertEqual(50.0, balances["Total"])

    def test_perform_request_with_config_without_user_id(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://*****:*****@example.com", password="******", token=None)

        balances = perform_request(config=get_config("tgb2"), request=req.clone())

        self.assertIsInstance(balances, dict)
        self.assertEqual(3, len(balances))
        self.assertIn("BTC", balances.keys())
        self.assertIn("ETH", balances.keys())
        self.assertIn("Total", balances.keys())

        self.assertEqual(0.1, balances["BTC"])
        self.assertEqual(2.0, balances["ETH"])
        self.assertEqual(50.0, balances["Total"])

예제 #29

파일: test_exchange_coins.py 프로젝트: rickdenhaan/eobot-py

class ExchangeCoinsTest(unittest.TestCase):
    def setUp(self):
        self.server = MockServer()
        self.server.start()

    def tearDown(self):
        self.server.stop()

    def test_perform_request_without_arguments(self):
        with self.assertRaises(TypeError):
            # noinspection PyArgumentList
            perform_request()

    def test_perform_request_with_invalid_from_coin(self):
        with self.assertRaises(ValueError):
            # noinspection PyTypeChecker
            perform_request(123, 1, "ETH")

    def test_perform_request_with_invalid_amount(self):
        with self.assertRaises(ValueError):
            # noinspection PyTypeChecker
            perform_request("BTC", "1", "ETH")

    def test_perform_request_with_invalid_to_coin(self):
        with self.assertRaises(ValueError):
            # noinspection PyTypeChecker
            perform_request("BTC", 1, 456)

    def test_perform_request_with_invalid_config(self):
        with self.assertRaises(ValueError):
            # noinspection PyTypeChecker
            perform_request("BTC", 1, "ETH", config={})

    def test_perform_request_with_invalid_request(self):
        with self.assertRaises(ValueError):
            # noinspection PyTypeChecker
            perform_request("BTC", 1, "ETH", request={})

    def test_perform_request(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://*****:*****@example.com", password="******", token=None)

        self.assertEqual(0.2, get_balances(request=req.clone())["BTC"])
        self.assertEqual(2.5, get_balances(request=req.clone())["ETH"])

        result = perform_request("BTC", 0.1, "ETH", request=req.clone())
        self.assertTrue(result)

        self.assertEqual(0.1, get_balances(request=req.clone())["BTC"])
        self.assertEqual(3.0, get_balances(request=req.clone())["ETH"])

    def test_perform_request_with_config(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://*****:*****@example.com", password="******", token=None)

        self.assertEqual(0.1, get_balances(config="tec", request=req.clone())["BTC"])
        self.assertEqual(2.0, get_balances(config="tec", request=req.clone())["ETH"])

        result = perform_request("BTC", 0.1, "ETH", config="tec", request=req.clone())
        self.assertTrue(result)

        self.assertEqual(0.0, get_balances(config=get_config("tec"), request=req.clone())["BTC"])
        self.assertEqual(2.5, get_balances(config=get_config("tec"), request=req.clone())["ETH"])

    def test_perform_request_with_config_without_user_id(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://*****:*****@example.com", password="******", token=None)

        result = perform_request("ETH", 0.5, "BTC", config="tec2", request=req.clone())
        self.assertTrue(result)

        self.assertEqual(0.2, get_balances(config=get_config("tec2"), request=req.clone())["BTC"])
        self.assertEqual(1.5, get_balances(config=get_config("tec2"), request=req.clone())["ETH"])

예제 #30

class GetMiningModeTest(unittest.TestCase):
    def setUp(self):
        self.server = MockServer()
        self.server.start()

    def tearDown(self):
        self.server.stop()

    def test_perform_request_with_invalid_config(self):
        with self.assertRaises(ValueError):
            # noinspection PyTypeChecker
            perform_request(config={})

    def test_perform_request_with_invalid_request(self):
        with self.assertRaises(ValueError):
            # noinspection PyTypeChecker
            perform_request(request={})

    def test_perform_request(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://*****:*****@example.com",
                               password="******",
                               token=None)

        mode = perform_request(request=req.clone())

        self.assertIsInstance(mode, basestring)
        self.assertEqual("BTC", mode)

    def test_perform_request_with_config(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://*****:*****@example.com",
                                     password="******",
                                     token=None)

        mode = perform_request(config="tgmm", request=req.clone())

        self.assertIsInstance(mode, basestring)
        self.assertEqual("ETH", mode)

    def test_perform_request_with_config_without_user_id(self):
        MockServer.reset()
        req = EobotRequest()
        req.set_base_url('http://*****:*****@example.com",
                                      password="******",
                                      token=None)

        mode = perform_request(config=get_config("tgmm2"), request=req.clone())

        self.assertIsInstance(mode, basestring)
        self.assertEqual("ETH", mode)