def test_save_new_telco_events(self):
        with application.app_context():
            token = list(AppTokens.tokens.keys())[0]
            request = self.app.post("/api/events", data=dict(
                events=events_json
            ), headers={"Authorization": "token " + token})

            assert request.status_code == 201

            gsm_events = GsmEvent.query.all()
            assert len(gsm_events) == 1
            gsm_event = gsm_events[0]

            mobile_events = MobileTrafficEvent.query.all()
            assert len(mobile_events) == 1

            sim = Sim.query.filter(Sim.serial_number == "800000000000000000000").first()
            assert sim

            carrier = Carrier.query.filter(Carrier.mnc == 99, Carrier.mcc == 9999).first()
            assert carrier

            assert carrier.id == 999999

            assert sim.carrier.mnc == 99
            assert sim.carrier.mcc == 9999

            assert len(carrier.telephony_observation_events.all()) == 1

            assert carrier.telephony_observation_events[0].id == gsm_event.id
    def test_save_wifi_event(self):
        with application.app_context():
            token = list(AppTokens.tokens.keys())[0]
            request = self.app.post(
                "/api/events",
                data=dict(events=events_json),
                headers={"Authorization": "token " + token})

            assert request.status_code == 201
            wifi_events = WifiTrafficEvent.query.all()
            assert len(wifi_events) == 1

            wifi_event = wifi_events[0]

            assert wifi_event.network_type == 6
            assert wifi_event.rx_bytes == 2361
            assert wifi_event.rx_packets == 19
            assert wifi_event.tcp_rx_bytes == 4532
            assert wifi_event.tcp_tx_bytes == 1523
            assert wifi_event.date.date() == datetime.fromtimestamp(
                1330641510326 / 1000).date()
            assert wifi_event.tx_bytes == 196
            assert wifi_event.tx_packets == 4
            assert wifi_event.app_version_code == "0.0a"

            assert wifi_event.sim.serial_number == "8000000000000000000"
            assert wifi_event.device.device_id == "8000000000000000000"
    def test_save_new_telco_events(self):
        with application.app_context():
            token = list(AppTokens.tokens.keys())[0]
            request = self.app.post("/api/events", data=dict(
                events=events_json
            ), headers={"Authorization": "token " + token})

            assert request.status_code == 201

            gsm_events = GsmEvent.query.all()
            assert len(gsm_events) == 1
            gsm_event = gsm_events[0]

            mobile_events = MobileTrafficEvent.query.all()
            assert len(mobile_events) == 1

            sim = Sim.query.filter(Sim.serial_number == "800000000000000000000").first()
            assert sim

            carrier = Carrier.query.filter(Carrier.mnc == 9, Carrier.mcc == 120).first()
            assert carrier

            assert sim.carrier.mnc == 9
            assert sim.carrier.mcc == 120

            assert len(carrier.telephony_observation_events.all()) == 1

            assert carrier.telephony_observation_events[0].id == gsm_event.id
Example #4
0
def client():
    _init_flask_app(application, "config.TestConfiguration")
    ctx = application.app_context()
    ctx.push()

    with application.test_client() as client:
        yield client
    def test_save_events_with_device_and_sim(self):
        with application.app_context():
            token = list(AppTokens.tokens.keys())[0]
            request = self.app.post(
                "/api/events",
                data=dict(events=events_json),
                headers={"Authorization": "token " + token})

            device = Device.query.filter(
                Device.device_id == "800000000000000000000").first()
            sim = Sim.query.filter(
                Sim.serial_number == "800000000000000000000").first()
            assert device
            assert sim
            assert request.status_code == 201
            # assert events
            events = Event.query.all()
            wifi_events = WifiTrafficEvent.query.all()
            state_events = StateChangeEvent.query.all()
            traffic_events = TrafficEvent.query.all()
            application_events = ApplicationTrafficEvent.query.all()
            mobile_events = MobileTrafficEvent.query.all()
            assert len(events) == 15

            # assert device and sim are linked with the event
            all_events = [
                wifi_events, state_events, traffic_events, application_events,
                mobile_events
            ]
            for events in all_events:
                for event in events:
                    assert device.device_id == event.device_id
                    assert sim.serial_number == event.sim_serial_number
    def test_save_events_with_device_and_sim(self):
        with application.app_context():
            token = list(AppTokens.tokens.keys())[0]
            request = self.app.post("/api/events", data=dict(
                events=events_json
            ), headers={"Authorization": "token " + token})

            device = Device.query.filter(Device.device_id == "800000000000000000000").first()
            sim = Sim.query.filter(Sim.serial_number == "800000000000000000000").first()
            assert device
            assert sim
            assert request.status_code == 201
            # assert events
            events = Event.query.all()
            wifi_events = WifiTrafficEvent.query.all()
            state_events = StateChangeEvent.query.all()
            traffic_events = TrafficEvent.query.all()
            application_events = ApplicationTrafficEvent.query.all()
            mobile_events = MobileTrafficEvent.query.all()
            assert len(events) == 15

            # assert device and sim are linked with the event
            all_events = [wifi_events, state_events, traffic_events, application_events, mobile_events]
            for events in all_events:
                for event in events:
                    assert device.device_id == event.device_id
                    assert sim.serial_number == event.sim_serial_number
Example #7
0
    def setUp(self):
        application.config['RUN_MODE'] = 'test'
        application.config.from_object('app.config.test.Config')

        self.app = application.test_client(self)
        self.app_context = application.app_context()
        self.app_context.push()
    def test_save_application_event(self):
        with app.app_context():
            token = list(AppTokens.tokens.keys())[0]
            request = self.app.post("/api/events", data=dict(
                events=events_json
            ), headers={"Authorization": "token " + token})

            assert request.status_code == 201

            application_events = ApplicationTrafficEvent.query.all()
            assert len(application_events) == 1

            application_event = application_events[0]

            assert application_event.network_type == 6
            assert application_event.rx_bytes == 5143
            assert application_event.rx_packets == 1234
            assert application_event.date.date() == datetime.fromtimestamp(1330641500267 / 1000).date()
            assert application_event.tx_bytes == 5615
            assert application_event.tx_packets == 123
            assert application_event.app_version_code == "0.0a"

            assert application_event.sim.serial_number == "8000000000000000000"
            assert application_event.device.device_id == "8000000000000000000"

            assert application_event.application.package_name == "cl.niclabs.adkintunmobile"

            apps = Application.query.all()
            assert len(apps) == 1

            application = apps[0]
            assert application.package_name == "cl.niclabs.adkintunmobile"
Example #9
0
    def test_save_application_event(self):
        with app.app_context():
            token = list(AppTokens.tokens.keys())[0]
            request = self.app.post(
                "/api/events",
                data=dict(events=events_json),
                headers={"Authorization": "token " + token})

            assert request.status_code == 201

            application_events = ApplicationTrafficEvent.query.all()
            assert len(application_events) == 1

            application_event = application_events[0]

            assert application_event.network_type == 6
            assert application_event.rx_bytes == 5143
            assert application_event.rx_packets == 1234
            assert application_event.date.date() == datetime.fromtimestamp(
                1330641500267 / 1000).date()
            assert application_event.tx_bytes == 5615
            assert application_event.tx_packets == 123
            assert application_event.app_version_code == "0.0a"

            assert application_event.sim.serial_number == "8000000000000000000"
            assert application_event.device.device_id == "8000000000000000000"

            assert application_event.application.package_name == "cl.niclabs.adkintunmobile"

            apps = Application.query.all()
            assert len(apps) == 1

            application = apps[0]
            assert application.package_name == "cl.niclabs.adkintunmobile"
    def test_save_mobile_events(self):
        with application.app_context():
            token = list(AppTokens.tokens.keys())[0]
            request = self.app.post("/api/events", data=dict(
                events=events_json
            ), headers={"Authorization": "token " + token})

            assert request.status_code == 201
            mobile_events = MobileTrafficEvent.query.all()
            assert len(mobile_events) == 1

            mobile_event = mobile_events[0]

            assert mobile_event.network_type == 1
            assert mobile_event.rx_bytes == 1234
            assert mobile_event.rx_packets == 45672
            assert mobile_event.tcp_rx_bytes == 4687
            assert mobile_event.tcp_tx_bytes == 1357
            assert mobile_event.date.date() == datetime.fromtimestamp(1330641500183 / 1000).date()
            assert mobile_event.tx_bytes == 489
            assert mobile_event.tx_packets == 35
            assert mobile_event.app_version_code == "0.0a"

            assert mobile_event.sim.serial_number == "8000000000000000000"
            assert mobile_event.device.device_id == "8000000000000000000"
    def test_save_wifi_event(self):
        with application.app_context():
            token = list(AppTokens.tokens.keys())[0]
            request = self.app.post("/api/events", data=dict(
                events=events_json
            ), headers={"Authorization": "token " + token})

            assert request.status_code == 201
            wifi_events = WifiTrafficEvent.query.all()
            assert len(wifi_events) == 1

            wifi_event = wifi_events[0]

            assert wifi_event.network_type == 6
            assert wifi_event.rx_bytes == 2361
            assert wifi_event.rx_packets == 19
            assert wifi_event.tcp_rx_bytes == 4532
            assert wifi_event.tcp_tx_bytes == 1523
            assert wifi_event.date.date() == datetime.fromtimestamp(1330641510326 / 1000).date()
            assert wifi_event.tx_bytes == 196
            assert wifi_event.tx_packets == 4
            assert wifi_event.app_version_code == "0.0a"

            assert wifi_event.sim.serial_number == "8000000000000000000"
            assert wifi_event.device.device_id == "8000000000000000000"
Example #12
0
def background_thread(_id, data):
    selected_input = data['checked']
    subreddits_input = data['subreddits']

    with application.app_context():
        client_id = application.config["CLIENT_ID"]
        client_secret = application.config["CLIENT_SECRET"]
        password = application.config["PASSWORD"]
        username = application.config["USERNAME"]
        user_agent = application.config["USER_AGENT"]

    reddit = praw.Reddit(
        client_id=client_id,
        client_secret=client_secret,
        password=password,
        user_agent=user_agent,
        username=username,
    )

    # subreddits_keyword_important = {"forhire": "hiring"}
    subreddits = {}
    for subreddit in selected_input:
        subreddits[subreddit] = {}
        subreddits[subreddit]["object_running"] = (
            reddit.subreddit(subreddit).stream.submissions(pause_after=0))
        subreddits[subreddit] = {
            **subreddits[subreddit],
            **subreddits_input[subreddit]
        }

    print(subreddits)
    while running_process[_id] is True:
        for subreddit in subreddits:
            subreddit = subreddits[subreddit]
            excludeKeyword = subreddit['excludeKeyword']
            includeKeyword = subreddit['includeKeyword']
            titleKeyword = subreddit['titleKeyword']
            submission = next(subreddit['object_running'])
            if not titleKeyword:
                titleKeyword = [None]
            if submission is None:
                break
            else:
                # if "[hiring]" in submission.title.lower():
                if any(True if not word else word in submission.title.lower()
                       for word in titleKeyword):
                    try:
                        title, desc, date, url = submissionParser(
                            submission, includeKeyword, excludeKeyword)
                        socketio.emit('background_response', {
                            'status': 200,
                            'title': title,
                            'desc': desc,
                            'date': str(date),
                            'url': url
                        },
                                      namespace='/reddit')
                    except Exception as e:
                        pass
Example #13
0
def test_client():
    test_client = application.test_client()
    ctx = application.app_context()
    ctx.push()

    yield test_client

    ctx.pop()
    def test_save_carriers(self):
        with application.app_context():
            carriers = Carrier.query.all()
            carriersFiltered = Carrier.query.filter(Carrier.mnc == 9).all()

            assert len(carriers) == 14
            assert len(carriersFiltered) == 1
            assert carriersFiltered[0].name == "WOM"
    def test_date_filter(self):
        with application.app_context():
            events_for_carrier = total_gsm_events_for_carrier(min_date=(datetime.now() + timedelta(days=-1)))
            assert len(events_for_carrier) == 2

            assert events_for_carrier[0].Carrier.name == "test_carrier_1"
            assert events_for_carrier[1].Carrier.name == "test_carrier_2"
            assert events_for_carrier[0].events_count == 1
            assert events_for_carrier[1].events_count == 3
    def test_two_carrier(self):
        with application.app_context():
            events_for_carrier = total_gsm_events_for_carrier()
            assert len(events_for_carrier) == 2

            assert events_for_carrier[0].Carrier.name == "test_carrier_1"
            assert events_for_carrier[1].Carrier.name == "test_carrier_2"
            assert events_for_carrier[0].events_count == 2
            assert events_for_carrier[1].events_count == 3
    def test_two_carrier(self):
        with application.app_context():
            total_devices_for_carrier = total_device_for_carrier()
            assert len(total_devices_for_carrier) == 2

            assert total_devices_for_carrier[0].Carrier.name == "test_carrier_1"
            assert total_devices_for_carrier[1].Carrier.name == "test_carrier_2"
            assert total_devices_for_carrier[0].devices_count == 3
            assert total_devices_for_carrier[1].devices_count == 1
    def test_two_carrier(self):
        with application.app_context():
            sims_for_carrier = total_sims_for_carrier()
            assert len(sims_for_carrier) == 2

            assert sims_for_carrier[0].Carrier.name == "test_carrier_1"
            assert sims_for_carrier[1].Carrier.name == "test_carrier_2"
            assert sims_for_carrier[0].sims_count == 2
            assert sims_for_carrier[1].sims_count == 1
Example #19
0
    def test_two_carrier(self):
        with application.app_context():
            sims_for_carrier = total_sims_for_carrier()
            assert len(sims_for_carrier) == 2

            assert sims_for_carrier[0].Carrier.name == "test_carrier_1"
            assert sims_for_carrier[1].Carrier.name == "test_carrier_2"
            assert sims_for_carrier[0].sims_count == 2
            assert sims_for_carrier[1].sims_count == 1
    def test_two_carrier(self):
        with application.app_context():
            events_for_carrier = total_gsm_events_for_carrier()
            assert len(events_for_carrier) == 2

            assert events_for_carrier[0].Carrier.name == "test_carrier_1"
            assert events_for_carrier[1].Carrier.name == "test_carrier_2"
            assert events_for_carrier[0].events_count == 2
            assert events_for_carrier[1].events_count == 3
Example #21
0
def insert_random_forest(height, num_trees):
    serialize = lambda pb: protobuf_to_dict(pb)
    with app.app_context():
        app.mongo.db.decisiontrees.insert(
            serialize(pb.TrainingRow(
                forestConfig=fake_config(num_trees),
                forest=fake_forest(height, num_trees),
                trainingResults=fake_results(num_trees),
            ))
        )
Example #22
0
    def test_date_filter(self):
        with application.app_context():
            sims_for_carrier = total_sims_for_carrier(
                min_date=(datetime.now() + timedelta(days=-1)))
            assert len(sims_for_carrier) == 2

            assert sims_for_carrier[0].Carrier.name == "test_carrier_1"
            assert sims_for_carrier[1].Carrier.name == "test_carrier_2"
            assert sims_for_carrier[0].sims_count == 1
            assert sims_for_carrier[1].sims_count == 1
Example #23
0
def insert_random_forest(height, num_trees):
    serialize = lambda pb: protobuf_to_dict(pb)
    with app.app_context():
        app.mongo.db.decisiontrees.insert(
            serialize(
                pb.TrainingRow(
                    forestConfig=fake_config(num_trees),
                    forest=fake_forest(height, num_trees),
                    trainingResults=fake_results(num_trees),
                )))
    def test_two_carrier(self):
        with application.app_context():
            total_devices_for_carrier = total_device_for_carrier()
            assert len(total_devices_for_carrier) == 2

            assert total_devices_for_carrier[
                0].Carrier.name == "test_carrier_1"
            assert total_devices_for_carrier[
                1].Carrier.name == "test_carrier_2"
            assert total_devices_for_carrier[0].devices_count == 3
            assert total_devices_for_carrier[1].devices_count == 1
Example #25
0
    def setUp(self):
        application.config['RUN_MODE'] = 'test'
        application.config.from_object('app.config.test.Config')

        db.session.close()
        db.drop_all()
        db.create_all()

        self.app = application.test_client(self)
        self.app_context = application.app_context()
        self.app_context.push()
Example #26
0
def client():
    from app import application

    db_fixture = DatabaseFixture(application)

    with application.app_context():
        application.config.from_object('settings.test_settings')

        db_fixture.connect_db()

    client = application.test_client()

    yield client

    db_fixture.delete_db()
    def test_save_gsm_observation_events(self):
        with application.app_context():
            token = list(AppTokens.tokens.keys())[0]
            request = self.app.post(
                "/api/events",
                data=dict(events=events_json),
                headers={"Authorization": "token " + token})

            assert request.status_code == 201
            gsm_events = GsmEvent.query.all()
            assert len(gsm_events) == 1

            gsm_event = gsm_events[0]

            assert gsm_event.network_type == 15
            assert gsm_event.telephony_standard == 1
            assert gsm_event.signal_strength_size == None
            assert gsm_event.signal_strength_mean == None
            assert gsm_event.signal_strength_variance == None
            assert gsm_event.gsm_cid == 1259355
            assert gsm_event.gsm_lac == 55700
            assert gsm_event.gsm_psc == -1
            assert gsm_event.signal_ber_size == None
            assert gsm_event.signal_ber_mean == None
            assert gsm_event.signal_ber_variance == None

            assert gsm_event.app_version_code == "0.0a"

            assert gsm_event.sim.serial_number == "8000000000000000000"
            assert gsm_event.device.device_id == "8000000000000000000"

            from app.models.antenna import Antenna
            antenna = Antenna.query.filter(Antenna.cid == 1259355,
                                           Antenna.lac == 55700,
                                           Antenna.lat == 0.2,
                                           Antenna.lon == 0.1).first()

            assert antenna.gsm_events.first().id == gsm_event.id

            real_carrier = Carrier.query.filter(Carrier.mcc == 730,
                                                Carrier.mnc == 2).first()
            assert real_carrier.telephony_observation_events.first(
            ).id == gsm_event.id
    def test_save_connectivity_event(self):
        with application.app_context():
            token = list(AppTokens.tokens.keys())[0]
            request = self.app.post("/api/events", data=dict(
                events=events_json
            ), headers={"Authorization": "token " + token})

            assert request.status_code == 201
            connectivity_events = ConnectivityEvent.query.all()
            assert len(connectivity_events) == 1

            connectivity_event = connectivity_events[0]

            assert connectivity_event.available == True
            assert connectivity_event.connected == True
            assert connectivity_event.connection_type == 6
            assert connectivity_event.detailed_state == 4
            assert connectivity_event.date.date() == datetime.fromtimestamp(1330641527540 / 1000).date()
            assert connectivity_event.app_version_code == "0.0a"

            assert connectivity_event.sim.serial_number == "8000000000000000000"
            assert connectivity_event.device.device_id == "8000000000000000000"
Example #29
0
    def test_save_speed_test_report(self):
        with application.app_context():
            token = list(AppTokens.tokens.keys())[0]
            request = self.app.post(
                "/api/events",
                data=dict(events=reports_json),
                headers={"Authorization": "token " + token})

            assert request.status_code == 201
            speed_test_reports = SpeedTestReport.query.all()
            assert len(speed_test_reports) == 1

            speed_test_report = speed_test_reports[0]

            assert not speed_test_report.dispatched
            assert speed_test_report.download_size == 1000000
            assert speed_test_report.download_speed == 9965900.0
            assert speed_test_report.elapsed_download_time == 838
            assert speed_test_report.elapsed_upload_time == 798
            assert speed_test_report.host == "http://blasco.duckdns.org"
            assert speed_test_report.upload_size == 1000000
            assert speed_test_report.upload_speed == 9854887.0

            assert speed_test_report.date.date() == datetime.fromtimestamp(
                1482341701645 / 1000).date()

            # test network interface
            from app.models.speedtests.network_interface import NetworkInterface

            assert len(NetworkInterface.query.all()) == 3
            ni = NetworkInterface.query.filter(
                NetworkInterface.network_type == 3).first()

            assert ni.id == speed_test_report.network_interface_id
            assert ni.active_interface == 2
            assert ni.bssid == "00:17:5a:1e:70:80"
            assert ni.gsm_cid == 0
            assert ni.gsm_lac == 0
            assert ni.ssid == "'niclabs'"
Example #30
0
    def test_save_media_test_report(self):
        with application.app_context():
            token = list(AppTokens.tokens.keys())[0]
            request = self.app.post(
                "/api/events",
                data=dict(events=reports_json),
                headers={"Authorization": "token " + token})

            assert request.status_code == 201
            media_test_reports = MediaTestReport.query.all()
            assert len(media_test_reports) == 1

            media_test_report = media_test_reports[0]

            assert not media_test_report.dispatched
            assert media_test_report.video_id == "gPmbH8eCUj4"
            assert media_test_report.date.date() == datetime.fromtimestamp(
                1482341724349 / 1000).date()

            # test network interface
            from app.models.speedtests.network_interface import NetworkInterface

            assert len(NetworkInterface.query.all()) == 3
            ni = NetworkInterface.query.filter(
                NetworkInterface.network_type == 2).first()

            assert ni.id == media_test_report.network_interface_id
            assert ni.active_interface == 2
            assert ni.bssid == "00:17:5a:1e:70:80"
            assert ni.gsm_cid == 0
            assert ni.gsm_lac == 0
            assert ni.ssid == "'niclabs'"

            # test video results
            from app.models.speedtests.video_result import VideoResult
            assert len(media_test_report.video_results.all()) == len(
                VideoResult.query.all())
    def test_save_connectivity_test_report(self):
        with application.app_context():
            token = list(AppTokens.tokens.keys())[0]
            request = self.app.post(
                "/api/events",
                data=dict(events=reports_json),
                headers={"Authorization": "token " + token})

            assert request.status_code == 201
            connectivity_test_reports = ConnectivityTestReport.query.all()
            assert len(connectivity_test_reports) == 1

            connectivity_test_report = connectivity_test_reports[0]

            assert not connectivity_test_report.dispatched
            assert connectivity_test_report.date.date(
            ) == datetime.fromtimestamp(1482341840760 / 1000).date()

            # test network interface
            from app.models.speedtests.network_interface import NetworkInterface

            assert len(NetworkInterface.query.all()) == 3
            ni = NetworkInterface.query.filter(
                NetworkInterface.network_type == 1).first()

            assert ni.id == connectivity_test_report.network_interface_id
            assert ni.active_interface == 2
            assert ni.bssid == "00:17:5a:1e:70:80"
            assert ni.gsm_cid == 0
            assert ni.gsm_lac == 0
            assert ni.ssid == "'niclabs'"

            # test sites results
            from app.models.speedtests.site_result import SiteResult
            assert len(connectivity_test_report.sites_results.all()) == len(
                SiteResult.query.all())
Example #32
0
    def test_save_connectivity_event(self):
        with application.app_context():
            token = list(AppTokens.tokens.keys())[0]
            request = self.app.post(
                "/api/events",
                data=dict(events=events_json),
                headers={"Authorization": "token " + token})

            assert request.status_code == 201
            connectivity_events = ConnectivityEvent.query.all()
            assert len(connectivity_events) == 1

            connectivity_event = connectivity_events[0]

            assert connectivity_event.available == True
            assert connectivity_event.connected == True
            assert connectivity_event.connection_type == 6
            assert connectivity_event.detailed_state == 4
            assert connectivity_event.date.date() == datetime.fromtimestamp(
                1330641527540 / 1000).date()
            assert connectivity_event.app_version_code == "0.0a"

            assert connectivity_event.sim.serial_number == "8000000000000000000"
            assert connectivity_event.device.device_id == "8000000000000000000"
Example #33
0
                       calibration=generator(1.0, 1.0, 0.02)(i),
                       normalizedEntropy=generator(0.9, 0.75, 0.01)(i))
        for i in range(num_trees)
    ])


def insert_random_forest(height, num_trees):
    serialize = lambda pb: protobuf_to_dict(pb)
    with app.app_context():
        app.mongo.db.decisiontrees.insert(
            serialize(
                pb.TrainingRow(
                    forestConfig=fake_config(num_trees),
                    forest=fake_forest(height, num_trees),
                    trainingResults=fake_results(num_trees),
                )))


if __name__ == "__main__":
    parser = ArgumentParser()
    parser.add_argument("--num_trees", type=int, default=5)
    parser.add_argument("--height", type=int, default=5)
    parser.add_argument("--num_rows", type=int, default=50)

    with app.app_context():
        app.mongo.db.decisiontrees.remove()

    opt = parser.parse_args()
    for _ in range(opt.num_rows):
        insert_random_forest(opt.height, opt.num_trees)
 def test_two_devices(self):
     with application.app_context():
         gsm_events = total_gsm_events()
         assert gsm_events == 3
Example #35
0
            roc=generator(0.2, 0.9, 0.02)(i),
            calibration=generator(1.0, 1.0, 0.02)(i),
            normalizedEntropy=generator(0.9, 0.75, 0.01)(i)
        ) for i in range(num_trees)
    ])


def insert_random_forest(height, num_trees):
    serialize = lambda pb: protobuf_to_dict(pb)
    with app.app_context():
        app.mongo.db.decisiontrees.insert(
            serialize(pb.TrainingRow(
                forestConfig=fake_config(num_trees),
                forest=fake_forest(height, num_trees),
                trainingResults=fake_results(num_trees),
            ))
        )

if __name__ == "__main__":
    parser = ArgumentParser()
    parser.add_argument("--num_trees", type=int, default=5)
    parser.add_argument("--height", type=int, default=5)
    parser.add_argument("--num_rows", type=int, default=50)

    with app.app_context():
        app.mongo.db.decisiontrees.remove()

    opt = parser.parse_args()
    for _ in range(opt.num_rows):
        insert_random_forest(opt.height, opt.num_trees)
 def test_two_devices(self):
     with application.app_context():
         gsm_events = total_gsm_events()
         assert gsm_events == 3
Example #37
0
def inject_globals():
    with application.app_context():
        session['VERSION'] = Config.VERSION
        session['MSG'] = Config.MSG
    return None
Example #38
0
    def setUp(self):
	    self.app_context = application.app_context()
	    self.app_context.push()
 def test_two_devices(self):
     with application.app_context():
         total_devices = total_devices_registred()
         assert total_devices == 2
Example #40
0
 def test_date_filter(self):
     with application.app_context():
         total_sims = total_sims_registered(min_date=(datetime.now() +
                                                      timedelta(days=-1)))
         assert total_sims == 2
Example #41
0
 def test_two_devices(self):
     with application.app_context():
         total_sims = total_sims_registered()
         assert total_sims == 3
Example #42
0
from app import db, application
from models.user import *
from models.audio import *

with application.app_context():
    db.create_all()
 def test_two_devices(self):
     with application.app_context():
         gsm_events = total_gsm_events(min_date=(datetime.now() + timedelta(days=-1)))
         assert gsm_events == 2
 def test_two_devices(self):
     with application.app_context():
         gsm_events = total_gsm_events(min_date=(datetime.now() +
                                                 timedelta(days=-1)))
         assert gsm_events == 2
 def test_date_filter(self):
     with application.app_context():
         total_devices = total_devices_registred(min_date=(datetime.now() + timedelta(days=-1)))
         assert total_devices == 1