tests.test_mining.TestMiner.test_miner_key_is_name() - Code Metrics - Inspection of "added miner statistics average hash and hardware e..." - dfoderick/fullcycle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 964ae0...fcc2df )

by Dave

created 2018-09-23 00:28 UTC

TestMiner.test_miner_key_is_name() A

↳ Parent: tests.test_mining

Complexity

Conditions

Size

Total Lines	3
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	3
nop	1
dl	0
loc	3
rs	10
c	0
b	0
f	0

'''test mining domain'''
import unittest
import datetime
import domain.minerstatistics
from domain.mining import Miner, MinerStatus, MinerInfo, MinerApiCall, MinerCommand, MinerCurrentPool

class TestMiner(unittest.TestCase):
    def test_miner_is_not_disabled(self):
        miner = Miner("test", '', '', '', '', '', '', '', '')
        self.assertFalse(miner.is_disabled())

    def test_miner_is_disabled(self):
        miner = Miner("#test", '', '', '', '', '', '', '', '')
        self.assertTrue(miner.is_disabled())

    def test_miner_key_is_id(self):
        miner = Miner("test", minerid='unittest')
        self.assertTrue(miner.key() == 'unittest')

    def test_miner_key_not_unknown(self):
        miner = Miner('test', minerid='unknown', ipaddress='unittest', port='1234')
        self.assertTrue(miner.key() == 'unittest:1234')

    def test_miner_key_is_networkid(self):
        miner = Miner("test", networkid={'unittest1', 'unittest2'})
        self.assertTrue(miner.key() == str({'unittest1', 'unittest2'}))

    def test_key_notempty_net(self):
        miner = Miner("test", networkid={})
        self.assertFalse(miner.key() == str({}))

    def test_miner_key_is_ip(self):
        miner = Miner("test", ipaddress='unittest', port='1234')
        self.assertTrue(miner.key() == 'unittest:1234')

    def test_miner_key_is_name(self):
        miner = Miner("test")
        self.assertTrue(miner.key() == 'test')

    def test_miner_format_time_now(self):
        miner = Miner('test')
        miner.lastmonitor = datetime.datetime.utcnow()
        self.assertTrue(miner.formattime(miner.lastmonitor))

    def test_miner_format_time_string(self):
        miner = Miner('test')
        miner.lastmonitor = '2018-04-11T01:28:45+00:00'
        self.assertTrue(miner.formattime(miner.lastmonitor))

    def test_miner_format_time_with_fraction(self):
        miner = Miner('test')
        miner.lastmonitor = '2018-04-11T01:28:45.3821739+00:00'
        self.assertTrue(miner.formattime(miner.lastmonitor))

    def test_miner_uses_custom(self):
        miner = Miner('test')
        miner.ftpport = '99'
        miner.set_ftp_port('22')
        self.assertTrue(miner.ftpport == '99')

    def test_miner_uses_default(self):
        miner = Miner('test')
        miner.ftpport = ''
        miner.set_ftp_port('22')
        self.assertTrue(miner.ftpport == '22')

    def test_miner_status_set_last_update(self):
        miner = Miner('test')
        self.assertTrue(not miner.laststatuschanged)
        miner.status = MinerStatus.Offline
        self.assertTrue(miner.laststatuschanged)

    def test_miner_status_change_keeps_original(self):
        miner = Miner('test')
        miner.status = MinerStatus.Offline
        self.assertTrue(miner.laststatuschanged)
        originalstatuschangetime = miner.laststatuschanged
        miner.status = MinerStatus.Offline
        self.assertTrue(miner.laststatuschanged == originalstatuschangetime)

    def test_miner_status_no_you_cant(self):
        miner = Miner('test')
        def set_status_test():
            miner.status = 'you can be anyting'
        self.assertRaises(ValueError, set_status_test)

    def test_miner_reset_offline_count(self):
        miner = Miner('test')
        self.assertTrue(miner.offlinecount == 0)
        self.assertTrue(miner.is_send_offline_alert())
        miner.offline_now()
        miner.offline_now()
        miner.offline_now()
        miner.offline_now()
        self.assertFalse(miner.is_send_offline_alert())
        miner.online_now()
        self.assertTrue(miner.offlinecount == 0)
        self.assertTrue(miner.is_send_offline_alert())

    def test_miner_setminerinfo(self):
        miner = Miner('test')
        minerinfo = MinerInfo('testminertype', miner.minerid)
        miner.setminerinfo(minerinfo)
        self.assertTrue(miner.miner_type == minerinfo.miner_type)

    def test_miner_shouldmonitor(self):
        miner = Miner('test')
        miner.lastmonitor = ""
        self.assertTrue(miner.should_monitor())

    def test_miner_elapsed_format(self):
        miner = Miner('test')
        miner.minerstats = domain.minerstatistics.MinerStatistics(miner)
        self.assertTrue(miner.minerstats.format_elapsed() == "0:0:0:0")

    def test_miner_statistics_seconds(self):
        miner = Miner('test')
        miner.minerstats = domain.minerstatistics.MinerStatistics(miner,hardware_errors=100,elapsed=10)
        self.assertTrue(miner.minerstats.hardware_errors_per_second == 10)

    def test_miner_statistics_minutes(self):
        miner = Miner('test')
        miner.minerstats = domain.minerstatistics.MinerStatistics(miner,hardware_errors=60,elapsed=60)
        self.assertTrue(miner.minerstats.hardware_errors_per_minute == 60, str(miner.minerstats.hardware_errors_per_minute))

    def test_miner_statistics_hours(self):
        miner = Miner('test')
        miner.minerstats = domain.minerstatistics.MinerStatistics(miner,hardware_errors=60,elapsed=60*60)
        self.assertTrue(miner.minerstats.hardware_errors_per_hour == 60, str(miner.minerstats.hardware_errors_per_hour))

    def test_miner_statistics_days(self):
        miner = Miner('test')
        miner.minerstats = domain.minerstatistics.MinerStatistics(miner,hardware_errors=60,elapsed=60*60*24)
        self.assertTrue(miner.minerstats.hardware_errors_per_day == 60)

    def test_miner_stats_summary(self):
        miner = Miner('test')
        miner.minerstats = domain.minerstatistics.MinerStatistics(miner)
        summary = miner.minerstats.stats_summary()
        self.assertTrue(summary == '0 0/0 0:0:0:0')

    def test_miner_monitored_nothing_none(self):
        miner = Miner('test')
        miner.monitored(None, None, None, None)
        self.assertTrue(miner.lastmonitor is None)

    def test_miner_monitored_not_nothing_ismonitored(self):
        miner = Miner('test')
        stats = domain.minerstatistics.MinerStatistics(miner)
        miner.monitored(stats, pool=None, info=None, sec=None)
        self.assertFalse(miner.lastmonitor is None)

    def test_miner_monitored_pool(self):
        miner = Miner('test')
        stats = domain.minerstatistics.MinerStatistics(miner)
        miner.monitored(stats, pool=MinerCurrentPool(miner), info=None, sec=None)
        self.assertTrue(miner.minerpool)

    def test_miner_monitored_timer(self):
        miner = Miner('test')
        stats = domain.minerstatistics.MinerStatistics(miner)
        apicall = MinerApiCall(miner)
        apicall.start()
        apicall.stop()
        miner.monitored(stats, pool=None, info=None, sec=apicall.elapsed())
        self.assertFalse(miner.lastmonitor is None)

    def test_miner_update(self):
        miner = Miner('test')
        miner.minerid = 'test'
        miner.ipaddress = 'ip1'
        miner.location = 'location1'
        miner.in_service_date = datetime.datetime.now().replace(second=0, microsecond=0)
        minerupdate = Miner('test1')
        minerupdate.minerid = 'test1'
        minerupdate.ipaddress = 'ip2'
        minerupdate.location = 'location2'
        minerupdate.in_service_date = datetime.datetime.now()
        miner.updatefrom(minerupdate)
        self.assertFalse(miner.ipaddress == minerupdate.ipaddress)
        minerupdate.minerid = miner.minerid
        miner.updatefrom(minerupdate)
        self.assertTrue(miner.ipaddress == minerupdate.ipaddress)
        self.assertTrue(miner.location == minerupdate.location)
        self.assertTrue(miner.in_service_date == minerupdate.in_service_date)

    def test_miner_is_unknown(self):
        miner = Miner('test')
        miner.minerid = "unknown"
        self.assertTrue(miner.is_unknown)

    def test_miner_is_known(self):
        miner = Miner('test')
        miner.minerid = "123.123.123.123"
        self.assertFalse(miner.is_unknown)

    def test_miner_no_update(self):
        miner = Miner('test')
        miner.ipaddress = 'ip1'
        minerupdate = Miner('test')
        minerupdate.ipaddress = None
        miner.updatefrom(minerupdate)
        self.assertTrue(miner.ipaddress != minerupdate.ipaddress)

    def test_miner_update_port(self):
        miner = Miner('test')
        miner.port = 'port1'
        minerupdate = Miner('test')
        minerupdate.port = 'port2'
        miner.updatefrom(minerupdate)
        self.assertTrue(miner.port == minerupdate.port)

    def test_miner_create(self):
        values = []
        values.append({"name":"UnitTest"})
        values.append({"minerid": "1"})
        values.append({"ipaddress": "123.123.123.123"})
        values.append({"port": "987"})
        values.append({"location": "rack"})
        values.append({"in_service_date": "2018-01-01T08:00:00.000Z"})
        miner = Miner.create(values)
        self.assertTrue(miner.name == "UnitTest")
        self.assertTrue(miner.minerid == "1")
        self.assertTrue(miner.ipaddress == "123.123.123.123")
        self.assertTrue(miner.port == "987")
        self.assertTrue(miner.location == "rack")
        self.assertTrue(miner.in_service_date.date() == datetime.date(2018, 1, 1))

    def test_miner_key_original(self):
        miner = Miner('test')
        miner.minerid = "unittest"
        self.assertTrue(miner.is_key_updated)

    def test_miner_command(self):
        command = MinerCommand()
        self.assertTrue(command.command == '')
        self.assertTrue(command.parameter == '')

    def test_miner_currentpoolname(self):
        miner = Miner('test')
        self.assertTrue(miner.currentpoolname() == '?')
        miner.minerpool = MinerCurrentPool(miner, 'test pool', 'test worker', allpools={}, poolname='unit test')
        self.assertTrue(miner.currentpoolname() == 'unit test')
        self.assertFalse(miner.minerpool.findpoolnumberforpool('test pool', 'test worker'))

    def test_miner_pools_available(self):
        miner = Miner('test')
        self.assertTrue(miner.pools_available is None)
        miner.minerpool = MinerCurrentPool(miner, 'test pool', 'test worker', allpools={})
        self.assertTrue(len(miner.pools_available) == 0)
        miner.minerpool.allpools = {"POOLS": [
        {
            "Pool Stale%": 0,
            "Accepted": 421743,
            "Difficulty Stale": 0,
            "Stratum URL": "test",
            "Rejected": 85,
            "Difficulty Accepted": 6587318272,
            "Best Share": 4019408192,
            "User": "test",
            "Stratum Active": True,
            "Difficulty Rejected": 1343488,
            "Diff": "16.4K",
            "Remote Failures": 3,
            "Discarded": 1094132,
            "Long Poll": "N",
            "Proxy": "",
            "Priority": 0,
            "Has GBT": False,
            "Pool Rejected%": 0.0204,
            "Stale": 63,
            "Last Share Difficulty": 16384,
            "Diff1 Shares": 0,
            "Has Stratum": True,
            "Status": "Alive",
            "URL": "test",
            "Quota": 1,
            "Last Share Time": "0:00:05",
            "Getworks": 70163,
            "Get Failures": 3,
            "POOL": 3,
            "Proxy Type": ""
        }]}
        self.assertTrue(len(miner.pools_available) > 0)
        self.assertTrue(miner.minerpool.findpoolnumberforpool('test', 'test'))
        self.assertFalse(miner.minerpool.findpoolnumberforpool('not', 'found'))

    def test_miner_summary(self):
        miner = Miner("test", '', '', '', '', '', '', '', '')
        self.assertTrue(miner.summary() is not None)
        miner.status = MinerStatus.Online
        self.assertTrue(miner.summary() is not None)
        miner.minerstats = None
        self.assertTrue(miner.summary() is not None)
        miner.minerstats = domain.minerstatistics.MinerStatistics(miner)
        self.assertTrue(miner.summary() is not None)

    def test_miner_todate(self):
        dttm = Miner.to_date(datetime.datetime.now())
        self.assertTrue(isinstance(dttm, datetime.datetime))

    def test_miner_uptime(self):
        miner = Miner("test", '', '', '', '', '', '', '', '')
        self.assertTrue(miner.uptime(1))

    def test_miner_monitorresponsetime(self):
        miner = Miner("test", '', '', '', '', '', '', '', '')
        self.assertTrue(miner.monitorresponsetime() == 0)
        miner.monitored(domain.minerstatistics.MinerStatistics(miner), None, None, 1)
        self.assertTrue(miner.monitorresponsetime() > 0)

    def test_miner_can_monitor(self):
        miner = Miner("test", '', '', '', '', '', '', '', '')
        self.assertFalse(miner.can_monitor())
        miner.ipaddress = '123.123.123.123'
        self.assertFalse(miner.can_monitor())
        miner.port = '4028'
        self.assertTrue(miner.can_monitor())

    def test_miner_should_monitor(self):
        miner = Miner("#test", '', '', '', '', '', '', '', '')
        self.assertTrue(miner.should_monitor())
        miner.monitored(domain.minerstatistics.MinerStatistics(miner), None, None, None)
        self.assertFalse(miner.should_monitor())
        miner.name = "test"
        self.assertTrue(miner.should_monitor())
        miner.status = MinerStatus.Disabled
        self.assertTrue(miner.should_monitor())

if __name__ == '__main__':
    unittest.main()


1			'''test mining domain'''
2			import unittest
3			import datetime
4			import domain.minerstatistics
5			from domain.mining import Miner, MinerStatus, MinerInfo, MinerApiCall, MinerCommand, MinerCurrentPool
6
7			class TestMiner(unittest.TestCase):
8			def test_miner_is_not_disabled(self):
9			miner = Miner("test", '', '', '', '', '', '', '', '')
10			self.assertFalse(miner.is_disabled())
11
12			def test_miner_is_disabled(self):
13			miner = Miner("#test", '', '', '', '', '', '', '', '')
14			self.assertTrue(miner.is_disabled())
15
16			def test_miner_key_is_id(self):
17			miner = Miner("test", minerid='unittest')
18			self.assertTrue(miner.key() == 'unittest')
19
20			def test_miner_key_not_unknown(self):
21			miner = Miner('test', minerid='unknown', ipaddress='unittest', port='1234')
22			self.assertTrue(miner.key() == 'unittest:1234')
23
24			def test_miner_key_is_networkid(self):
25			miner = Miner("test", networkid={'unittest1', 'unittest2'})
26			self.assertTrue(miner.key() == str({'unittest1', 'unittest2'}))
27
28			def test_key_notempty_net(self):
29			miner = Miner("test", networkid={})
30			self.assertFalse(miner.key() == str({}))
31
32			def test_miner_key_is_ip(self):
33			miner = Miner("test", ipaddress='unittest', port='1234')
34			self.assertTrue(miner.key() == 'unittest:1234')
35
36			def test_miner_key_is_name(self):
37			miner = Miner("test")
38			self.assertTrue(miner.key() == 'test')
39
40			def test_miner_format_time_now(self):
41			miner = Miner('test')
42			miner.lastmonitor = datetime.datetime.utcnow()
43			self.assertTrue(miner.formattime(miner.lastmonitor))
44
45			def test_miner_format_time_string(self):
46			miner = Miner('test')
47			miner.lastmonitor = '2018-04-11T01:28:45+00:00'
48			self.assertTrue(miner.formattime(miner.lastmonitor))
49
50			def test_miner_format_time_with_fraction(self):
51			miner = Miner('test')
52			miner.lastmonitor = '2018-04-11T01:28:45.3821739+00:00'
53			self.assertTrue(miner.formattime(miner.lastmonitor))
54
55			def test_miner_uses_custom(self):
56			miner = Miner('test')
57			miner.ftpport = '99'
58			miner.set_ftp_port('22')
59			self.assertTrue(miner.ftpport == '99')
60
61			def test_miner_uses_default(self):
62			miner = Miner('test')
63			miner.ftpport = ''
64			miner.set_ftp_port('22')
65			self.assertTrue(miner.ftpport == '22')
66
67			def test_miner_status_set_last_update(self):
68			miner = Miner('test')
69			self.assertTrue(not miner.laststatuschanged)
70			miner.status = MinerStatus.Offline
71			self.assertTrue(miner.laststatuschanged)
72
73			def test_miner_status_change_keeps_original(self):
74			miner = Miner('test')
75			miner.status = MinerStatus.Offline
76			self.assertTrue(miner.laststatuschanged)
77			originalstatuschangetime = miner.laststatuschanged
78			miner.status = MinerStatus.Offline
79			self.assertTrue(miner.laststatuschanged == originalstatuschangetime)
80
81			def test_miner_status_no_you_cant(self):
82			miner = Miner('test')
83			def set_status_test():
84			miner.status = 'you can be anyting'
85			self.assertRaises(ValueError, set_status_test)
86
87			def test_miner_reset_offline_count(self):
88			miner = Miner('test')
89			self.assertTrue(miner.offlinecount == 0)
90			self.assertTrue(miner.is_send_offline_alert())
91			miner.offline_now()
92			miner.offline_now()
93			miner.offline_now()
94			miner.offline_now()
95			self.assertFalse(miner.is_send_offline_alert())
96			miner.online_now()
97			self.assertTrue(miner.offlinecount == 0)
98			self.assertTrue(miner.is_send_offline_alert())
99
100			def test_miner_setminerinfo(self):
101			miner = Miner('test')
102			minerinfo = MinerInfo('testminertype', miner.minerid)
103			miner.setminerinfo(minerinfo)
104			self.assertTrue(miner.miner_type == minerinfo.miner_type)
105
106			def test_miner_shouldmonitor(self):
107			miner = Miner('test')
108			miner.lastmonitor = ""
109			self.assertTrue(miner.should_monitor())
110
111			def test_miner_elapsed_format(self):
112			miner = Miner('test')
113			miner.minerstats = domain.minerstatistics.MinerStatistics(miner)
114			self.assertTrue(miner.minerstats.format_elapsed() == "0:0:0:0")
115
116			def test_miner_statistics_seconds(self):
117			miner = Miner('test')
118			miner.minerstats = domain.minerstatistics.MinerStatistics(miner,hardware_errors=100,elapsed=10)
119			self.assertTrue(miner.minerstats.hardware_errors_per_second == 10)
120
121			def test_miner_statistics_minutes(self):
122			miner = Miner('test')
123			miner.minerstats = domain.minerstatistics.MinerStatistics(miner,hardware_errors=60,elapsed=60)
124			self.assertTrue(miner.minerstats.hardware_errors_per_minute == 60, str(miner.minerstats.hardware_errors_per_minute))
125
126			def test_miner_statistics_hours(self):
127			miner = Miner('test')
128			miner.minerstats = domain.minerstatistics.MinerStatistics(miner,hardware_errors=60,elapsed=60*60)
129			self.assertTrue(miner.minerstats.hardware_errors_per_hour == 60, str(miner.minerstats.hardware_errors_per_hour))
130
131			def test_miner_statistics_days(self):
132			miner = Miner('test')
133			miner.minerstats = domain.minerstatistics.MinerStatistics(miner,hardware_errors=60,elapsed=606024)
134			self.assertTrue(miner.minerstats.hardware_errors_per_day == 60)
135
136			def test_miner_stats_summary(self):
137			miner = Miner('test')
138			miner.minerstats = domain.minerstatistics.MinerStatistics(miner)
139			summary = miner.minerstats.stats_summary()
140			self.assertTrue(summary == '0 0/0 0:0:0:0')
141
142			def test_miner_monitored_nothing_none(self):
143			miner = Miner('test')
144			miner.monitored(None, None, None, None)
145			self.assertTrue(miner.lastmonitor is None)
146
147			def test_miner_monitored_not_nothing_ismonitored(self):
148			miner = Miner('test')
149			stats = domain.minerstatistics.MinerStatistics(miner)
150			miner.monitored(stats, pool=None, info=None, sec=None)
151			self.assertFalse(miner.lastmonitor is None)
152
153			def test_miner_monitored_pool(self):
154			miner = Miner('test')
155			stats = domain.minerstatistics.MinerStatistics(miner)
156			miner.monitored(stats, pool=MinerCurrentPool(miner), info=None, sec=None)
157			self.assertTrue(miner.minerpool)
158
159			def test_miner_monitored_timer(self):
160			miner = Miner('test')
161			stats = domain.minerstatistics.MinerStatistics(miner)
162			apicall = MinerApiCall(miner)
163			apicall.start()
164			apicall.stop()
165			miner.monitored(stats, pool=None, info=None, sec=apicall.elapsed())
166			self.assertFalse(miner.lastmonitor is None)
167
168			def test_miner_update(self):
169			miner = Miner('test')
170			miner.minerid = 'test'
171			miner.ipaddress = 'ip1'
172			miner.location = 'location1'
173			miner.in_service_date = datetime.datetime.now().replace(second=0, microsecond=0)
174			minerupdate = Miner('test1')
175			minerupdate.minerid = 'test1'
176			minerupdate.ipaddress = 'ip2'
177			minerupdate.location = 'location2'
178			minerupdate.in_service_date = datetime.datetime.now()
179			miner.updatefrom(minerupdate)
180			self.assertFalse(miner.ipaddress == minerupdate.ipaddress)
181			minerupdate.minerid = miner.minerid
182			miner.updatefrom(minerupdate)
183			self.assertTrue(miner.ipaddress == minerupdate.ipaddress)
184			self.assertTrue(miner.location == minerupdate.location)
185			self.assertTrue(miner.in_service_date == minerupdate.in_service_date)
186
187			def test_miner_is_unknown(self):
188			miner = Miner('test')
189			miner.minerid = "unknown"
190			self.assertTrue(miner.is_unknown)
191
192			def test_miner_is_known(self):
193			miner = Miner('test')
194			miner.minerid = "123.123.123.123"
195			self.assertFalse(miner.is_unknown)
196
197			def test_miner_no_update(self):
198			miner = Miner('test')
199			miner.ipaddress = 'ip1'
200			minerupdate = Miner('test')
201			minerupdate.ipaddress = None
202			miner.updatefrom(minerupdate)
203			self.assertTrue(miner.ipaddress != minerupdate.ipaddress)
204
205			def test_miner_update_port(self):
206			miner = Miner('test')
207			miner.port = 'port1'
208			minerupdate = Miner('test')
209			minerupdate.port = 'port2'
210			miner.updatefrom(minerupdate)
211			self.assertTrue(miner.port == minerupdate.port)
212
213			def test_miner_create(self):
214			values = []
215			values.append({"name":"UnitTest"})
216			values.append({"minerid": "1"})
217			values.append({"ipaddress": "123.123.123.123"})
218			values.append({"port": "987"})
219			values.append({"location": "rack"})
220			values.append({"in_service_date": "2018-01-01T08:00:00.000Z"})
221			miner = Miner.create(values)
222			self.assertTrue(miner.name == "UnitTest")
223			self.assertTrue(miner.minerid == "1")
224			self.assertTrue(miner.ipaddress == "123.123.123.123")
225			self.assertTrue(miner.port == "987")
226			self.assertTrue(miner.location == "rack")
227			self.assertTrue(miner.in_service_date.date() == datetime.date(2018, 1, 1))
228
229			def test_miner_key_original(self):
230			miner = Miner('test')
231			miner.minerid = "unittest"
232			self.assertTrue(miner.is_key_updated)
233
234			def test_miner_command(self):
235			command = MinerCommand()
236			self.assertTrue(command.command == '')
237			self.assertTrue(command.parameter == '')
238
239			def test_miner_currentpoolname(self):
240			miner = Miner('test')
241			self.assertTrue(miner.currentpoolname() == '?')
242			miner.minerpool = MinerCurrentPool(miner, 'test pool', 'test worker', allpools={}, poolname='unit test')
243			self.assertTrue(miner.currentpoolname() == 'unit test')
244			self.assertFalse(miner.minerpool.findpoolnumberforpool('test pool', 'test worker'))
245
246			def test_miner_pools_available(self):
247			miner = Miner('test')
248			self.assertTrue(miner.pools_available is None)
249			miner.minerpool = MinerCurrentPool(miner, 'test pool', 'test worker', allpools={})
250			self.assertTrue(len(miner.pools_available) == 0)
251			miner.minerpool.allpools = {"POOLS": [
252			{
253			"Pool Stale%": 0,
254			"Accepted": 421743,
255			"Difficulty Stale": 0,
256			"Stratum URL": "test",
257			"Rejected": 85,
258			"Difficulty Accepted": 6587318272,
259			"Best Share": 4019408192,
260			"User": "test",
261			"Stratum Active": True,
262			"Difficulty Rejected": 1343488,
263			"Diff": "16.4K",
264			"Remote Failures": 3,
265			"Discarded": 1094132,
266			"Long Poll": "N",
267			"Proxy": "",
268			"Priority": 0,
269			"Has GBT": False,
270			"Pool Rejected%": 0.0204,
271			"Stale": 63,
272			"Last Share Difficulty": 16384,
273			"Diff1 Shares": 0,
274			"Has Stratum": True,
275			"Status": "Alive",
276			"URL": "test",
277			"Quota": 1,
278			"Last Share Time": "0:00:05",
279			"Getworks": 70163,
280			"Get Failures": 3,
281			"POOL": 3,
282			"Proxy Type": ""
283			}]}
284			self.assertTrue(len(miner.pools_available) > 0)
285			self.assertTrue(miner.minerpool.findpoolnumberforpool('test', 'test'))
286			self.assertFalse(miner.minerpool.findpoolnumberforpool('not', 'found'))
287
288			def test_miner_summary(self):
289			miner = Miner("test", '', '', '', '', '', '', '', '')
290			self.assertTrue(miner.summary() is not None)
291			miner.status = MinerStatus.Online
292			self.assertTrue(miner.summary() is not None)
293			miner.minerstats = None
294			self.assertTrue(miner.summary() is not None)
295			miner.minerstats = domain.minerstatistics.MinerStatistics(miner)
296			self.assertTrue(miner.summary() is not None)
297
298			def test_miner_todate(self):
299			dttm = Miner.to_date(datetime.datetime.now())
300			self.assertTrue(isinstance(dttm, datetime.datetime))
301
302			def test_miner_uptime(self):
303			miner = Miner("test", '', '', '', '', '', '', '', '')
304			self.assertTrue(miner.uptime(1))
305
306			def test_miner_monitorresponsetime(self):
307			miner = Miner("test", '', '', '', '', '', '', '', '')
308			self.assertTrue(miner.monitorresponsetime() == 0)
309			miner.monitored(domain.minerstatistics.MinerStatistics(miner), None, None, 1)
310			self.assertTrue(miner.monitorresponsetime() > 0)
311
312			def test_miner_can_monitor(self):
313			miner = Miner("test", '', '', '', '', '', '', '', '')
314			self.assertFalse(miner.can_monitor())
315			miner.ipaddress = '123.123.123.123'
316			self.assertFalse(miner.can_monitor())
317			miner.port = '4028'
318			self.assertTrue(miner.can_monitor())
319
320			def test_miner_should_monitor(self):
321			miner = Miner("#test", '', '', '', '', '', '', '', '')
322			self.assertTrue(miner.should_monitor())
323			miner.monitored(domain.minerstatistics.MinerStatistics(miner), None, None, None)
324			self.assertFalse(miner.should_monitor())
325			miner.name = "test"
326			self.assertTrue(miner.should_monitor())
327			miner.status = MinerStatus.Disabled
328			self.assertTrue(miner.should_monitor())
329
330			if __name__ == '__main__':
331			unittest.main()
332

dfoderick / fullcycle

Push — master ( 964ae0...fcc2df )

TestMiner.test_miner_key_is_name() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like