コード例 #1
0
    def test_forecasts(self):
        forecast_product_json = load_fixture('forecast_product')
        self.adapter.register_uri('GET', '/products/%s' % forecast_product_json['id'],
                                  json=forecast_product_json)
        forecast_product = Product.find(forecast_product_json['id'])

        forecasts_json = load_fixture('forecasts')
        self.adapter.register_uri('GET', '/products/%s/forecasts' % forecast_product.id,
                                  json=forecasts_json)
        forecasts = forecast_product.forecasts()
        self.assertEqual(len(forecasts), 3)
コード例 #2
0
    def setUp(self):
        self.channel_list_one = load_fixture("channel_list_one.json")
        self.channel_list_two = load_fixture("channel_list_two.json")
        self.channel_list_three = load_fixture("channel_list_three.json")
        self.channel_list_four = load_fixture("channel_list_four.json")

        from charlesbot.slack.slack_connection import SlackConnection

        self.slack = SlackConnection()
        self.slack.initialized = True
        self.slack.sc = MagicMock()
コード例 #3
0
    def test_styles(self):
        product_json = load_fixture('product')
        self.adapter.register_uri('GET', '/products/%s' % (product_json['id']),
                                  json=product_json)
        product = Product.find(product_json['id'])

        styles_json = load_fixture('styles')
        self.adapter.register_uri('GET', '/products/%s/styles' % (product.id,),
                                  json=styles_json)
        styles = self.product.styles()
        self.assertEquals(len(styles), 2)
コード例 #4
0
    def test_analysis_frames(self):
        product_json = load_fixture('product')
        self.adapter.register_uri('GET', '/products/%s' % (product_json['id']),
                                  json=product_json)
        product = Product.find(product_json['id'])

        frames_json = load_fixture('frames')
        self.adapter.register_uri('GET', '/products/%s/frames' % product.id,
                                  json=frames_json)
        frames = product.frames()
        self.assertEquals(len(frames), 2)
コード例 #5
0
 def setUp(self):
     self.channel_list_one = load_fixture('channel_list_one.json')
     self.channel_list_two = load_fixture('channel_list_two.json')
     self.channel_list_three = load_fixture('channel_list_three.json')
     self.channel_list_four = load_fixture('channel_list_four.json')
     self.channel_list_five = load_fixture('channel_list_five.json')
     self.channel_list_six = load_fixture('channel_list_six.json')
     self.channel_list_seven = load_fixture('channel_list_seven.json')
     self.channel_list_eight = load_fixture('channel_list_eight.json')
     self.channel_list_nine = load_fixture('channel_list_nine.json')
     self.channel_list_ten = load_fixture('channel_list_ten.json')
コード例 #6
0
    def test_forecast_frames(self):
        forecast_product_json = load_fixture('forecast_product')
        self.adapter.register_uri('GET', '/products/%s' % forecast_product_json['id'],
                                  json=forecast_product_json)
        forecast_product = Product.find(forecast_product_json['id'])

        forecasts_json = load_fixture('forecasts')
        self.adapter.register_uri('GET', '/products/%s/forecasts' % forecast_product.id,
                                  json=forecasts_json)

        frames_json = load_fixture('frames')
        self.adapter.register_uri('GET', '/forecasts/4a61c817-3fc0-4dec-80ab-25936d73b2d7/frames',
                                  json=frames_json)
        frames = forecast_product.frames()
        self.assertEqual(len(frames), 2)
コード例 #7
0
ファイル: signals_tests.py プロジェクト: predicthq/sdk-py
 def test_sink(self, client, responses):
     signal = client.signals.get(id="zVNLr8tHvWQw")
     signal.sink(load_fixture("data_points"), chunk_size=2)
     self.assertEqual(3, len(responses.calls))
     for i in range(1, 3):
         self.assertEqual(responses.calls[i].request.headers['Content-Type'], "application/x-ldjson")
         self.assertEqual(len(responses.calls[i].request.body.split("\n")), 2)
コード例 #8
0
 def test_google_maps_tiles(self):
     frame = self._register_frames().pop()
     tile_tiff = load_fixture('tile', extension='tiff')
     self.adapter.register_uri('GET', '/frames/%s/tile/1/0/0' % frame.id,
                               content=tile_tiff)
     tile = frame.tile(x=0, y=0, z=1)
     self.assertIsNotNone(tile.content())
コード例 #9
0
 def test_bing_maps_tiles(self):
     frame = self._register_frames().pop()
     tile_tiff = load_fixture('tile', extension='tiff')
     self.adapter.register_uri('GET', '/frames/%s/tile/0' % frame.id,
                               content=tile_tiff)
     tile = frame.tile(quadkey="0")
     self.assertIsNotNone(tile.content())
コード例 #10
0
 def test_datapoints(self):
     frame = self._register_frames().pop()
     datapoint_json = load_fixture('datapoint')
     self.adapter.register_uri('GET', '/frames/%s/datapoint/35.0/-97.0' % frame.id,
                               json=datapoint_json)
     datapoint = frame.datapoint(35.0, -97.0)
     self.assertEqual(datapoint.value, 0.296531558)
コード例 #11
0
    def test_update_ok(self, mock_session, mock_request):
        """Test updating feed is ok."""
        mock_session.return_value.__enter__.return_value.send.return_value.ok = True
        mock_session.return_value.__enter__.return_value.send.return_value.text = (
            load_fixture("generic_feed_1.xml")
        )

        feed = GenericFeed(HOME_COORDINATES_1, None)
        assert (
            repr(feed) == "<GenericFeed(home=(-31.0, 151.0), url=None, "
            "radius=None, categories=None)>"
        )
        status, entries = feed.update()
        assert status == UPDATE_OK
        self.assertIsNotNone(entries)
        assert len(entries) == 5

        feed_entry = entries[0]
        assert feed_entry.title == "Title 1"
        assert feed_entry.external_id == "1234"
        assert feed_entry.category == "Category 1"
        assert feed_entry.published == datetime.datetime(2018, 9, 23, 8, 30)
        assert feed_entry.updated == datetime.datetime(2018, 9, 23, 8, 35)
        assert feed_entry.coordinates == (-37.2345, 149.1234)
        self.assertAlmostEqual(feed_entry.distance_to_home, 714.4, 1)

        feed_entry = entries[1]
        assert feed_entry.title == "Title 2"
        assert feed_entry.external_id == "2345"
        assert feed_entry.attribution == "Attribution 1"
        assert repr(feed_entry) == "<GenericFeedEntry(id=2345)>"

        feed_entry = entries[2]
        assert feed_entry.title == "Title 3"
        assert feed_entry.external_id == "Title 3"

        external_id = hash((-37.8901, 149.7890))
        feed_entry = entries[3]
        self.assertIsNone(feed_entry.title)
        assert feed_entry.external_id == external_id

        feed_entry = entries[4]
        assert feed_entry.title == "Title 5"
        assert feed_entry.external_id == "5678"
コード例 #12
0
    def test_update_ok_feed_2(self, mock_session, mock_request):
        """Test updating feed is ok."""
        mock_session.return_value.__enter__.return_value.send.return_value.ok = True
        mock_session.return_value.__enter__.return_value.send.return_value.text = (
            load_fixture("generic_feed_2.xml")
        )

        feed = GenericFeed(HOME_COORDINATES_1, None)
        status, entries = feed.update()
        assert status == UPDATE_OK
        self.assertIsNotNone(entries)
        assert len(entries) == 1

        feed_entry = entries[0]
        assert feed_entry.title == "Title 1"
        assert feed_entry.external_id == "1234"
        assert feed_entry.category == "Category 1"
        assert feed_entry.coordinates == (-37.2345, 149.1234)
        self.assertAlmostEqual(feed_entry.distance_to_home, 714.4, 1)
コード例 #13
0
    def test_feed_manager(self, mock_session, mock_request):
        """Test the feed manager."""
        mock_session.return_value.__enter__.return_value.send.return_value.ok = True
        mock_session.return_value.__enter__.return_value.send.return_value.text = (
            load_fixture("qld_bushfire_alert_feed.xml")
        )

        # This will just record calls and keep track of external ids.
        generated_entity_external_ids = []
        updated_entity_external_ids = []
        removed_entity_external_ids = []

        def _generate_entity(external_id):
            """Generate new entity."""
            generated_entity_external_ids.append(external_id)

        def _update_entity(external_id):
            """Update entity."""
            updated_entity_external_ids.append(external_id)

        def _remove_entity(external_id):
            """Remove entity."""
            removed_entity_external_ids.append(external_id)

        feed_manager = QldBushfireAlertFeedManager(
            _generate_entity, _update_entity, _remove_entity, HOME_COORDINATES
        )
        assert (
            repr(feed_manager) == "<QldBushfireAlertFeedManager("
            "feed=<QldBushfireAlertFeed(home="
            "(-31.0, 151.0), url=https://www."
            "qfes.qld.gov.au/data/alerts/"
            "bushfireAlert.xml, "
            "radius=None, categories=None)>)>"
        )
        feed_manager.update()
        entries = feed_manager.feed_entries
        self.assertIsNotNone(entries)
        assert len(entries) == 2
        assert feed_manager.last_timestamp == datetime.datetime(2018, 9, 27, 8, 0)
        assert len(generated_entity_external_ids) == 2
        assert len(updated_entity_external_ids) == 0
        assert len(removed_entity_external_ids) == 0
コード例 #14
0
    def test_feed_manager(self, mock_session, mock_request):
        """Test the feed manager."""
        mock_session.return_value.__enter__.return_value.send.return_value.ok = True
        mock_session.return_value.__enter__.return_value.send.return_value.text = (
            load_fixture("natural_resources_canada_earthquakes_en_feed.xml"))

        # This will just record calls and keep track of external ids.
        generated_entity_external_ids = []
        updated_entity_external_ids = []
        removed_entity_external_ids = []

        def _generate_entity(external_id):
            """Generate new entity."""
            generated_entity_external_ids.append(external_id)

        def _update_entity(external_id):
            """Update entity."""
            updated_entity_external_ids.append(external_id)

        def _remove_entity(external_id):
            """Remove entity."""
            removed_entity_external_ids.append(external_id)

        feed_manager = NaturalResourcesCanadaEarthquakesFeedManager(
            _generate_entity, _update_entity, _remove_entity, HOME_COORDINATES,
            "en")
        assert (repr(feed_manager) == "<NaturalResourcesCanadaEarthquakes"
                "FeedManager(feed=<NaturalResources"
                "CanadaEarthquakesFeed(home="
                "(49.25, -123.1), "
                "url=http://www.earthquakescanada."
                "nrcan.gc.ca/index-en.php?"
                "tpl_region=canada&tpl_output=rss, "
                "radius=None, magnitude=None)>)>")
        feed_manager.update()
        entries = feed_manager.feed_entries
        self.assertIsNotNone(entries)
        assert len(entries) == 2
        assert feed_manager.last_timestamp == datetime.datetime(
            2018, 9, 29, 8, 30, tzinfo=datetime.timezone.utc)
        assert len(generated_entity_external_ids) == 2
        assert len(updated_entity_external_ids) == 0
        assert len(removed_entity_external_ids) == 0
コード例 #15
0
    def test_nested_result(self):
        query = "from planets as allPlanets"
        response_mock = mock.Mock()
        response_mock.status_code = 200
        response_mock.json.return_value = load_fixture('nestedPlanets.json')
        self.requests_post_mock.return_value = response_mock

        client = Client('http://localhost:9000')
        response = client.run_query(query)

        self.assertEqual(self.requests_post_mock.call_count, 1)
        self.assertEqual(self.requests_post_mock.call_args_list, [
            mock.call('http://localhost:9000/run-query',
                      data='from planets as allPlanets',
                      headers={'Content-type': 'text/plain'},
                      params={})
        ])
        self.assertTrue(isinstance(response.allPlanets, list))
        self.assertEqual(len(response.allPlanets[0].results), 2)
コード例 #16
0
    def test_feed_manager(self, mock_session, mock_request):
        """Test the feed manager."""
        mock_session.return_value.__enter__.return_value.send.return_value.ok = True
        mock_session.return_value.__enter__.return_value.send.return_value.text = (
            load_fixture("ingv_centro_nazionale_terremoti_feed.xml"))

        # This will just record calls and keep track of external ids.
        generated_entity_external_ids = []
        updated_entity_external_ids = []
        removed_entity_external_ids = []

        def _generate_entity(external_id):
            """Generate new entity."""
            generated_entity_external_ids.append(external_id)

        def _update_entity(external_id):
            """Update entity."""
            updated_entity_external_ids.append(external_id)

        def _remove_entity(external_id):
            """Remove entity."""
            removed_entity_external_ids.append(external_id)

        feed_manager = IngvCentroNazionaleTerremotiFeedManager(
            _generate_entity, _update_entity, _remove_entity, HOME_COORDINATES)
        assert (repr(feed_manager) == "<IngvCentroNazionaleTerremoti"
                "FeedManager(feed=<IngvCentroNazionale"
                "TerremotiFeed(home="
                "(40.84, 14.25), "
                "url=http://cnt.rm.ingv.it/"
                "feed/atom/all_week, "
                "radius=None, magnitude=None)>)>")
        feed_manager.update()
        entries = feed_manager.feed_entries
        self.assertIsNotNone(entries)
        assert len(entries) == 3
        assert feed_manager.last_timestamp == datetime.datetime(
            2018, 10, 6, 8, 0, tzinfo=datetime.timezone.utc)
        assert len(generated_entity_external_ids) == 3
        assert len(updated_entity_external_ids) == 0
        assert len(removed_entity_external_ids) == 0
コード例 #17
0
    def test_feed_manager(self, mock_session, mock_request):
        """Test the feed manager."""
        mock_session.return_value.__enter__.return_value.send.return_value.ok = True
        mock_session.return_value.__enter__.return_value.send.return_value.text = (
            load_fixture("tasmania_fire_service_incidents_feed.xml"))

        # This will just record calls and keep track of external ids.
        generated_entity_external_ids = []
        updated_entity_external_ids = []
        removed_entity_external_ids = []

        def _generate_entity(external_id):
            """Generate new entity."""
            generated_entity_external_ids.append(external_id)

        def _update_entity(external_id):
            """Update entity."""
            updated_entity_external_ids.append(external_id)

        def _remove_entity(external_id):
            """Remove entity."""
            removed_entity_external_ids.append(external_id)

        feed_manager = TfsIncidentsFeedManager(_generate_entity,
                                               _update_entity, _remove_entity,
                                               HOME_COORDINATES)
        assert (repr(feed_manager) == "<TfsIncidentsFeedManager("
                "feed=<TfsIncidentsFeed(home="
                "(-42.0, 147.0), url=http://www.fire."
                "tas.gov.au/Show?pageId="
                "colBushfireSummariesRss, "
                "radius=None, categories=None)>)>")
        feed_manager.update()
        entries = feed_manager.feed_entries
        self.assertIsNotNone(entries)
        assert len(entries) == 2
        assert feed_manager.last_timestamp == datetime.datetime(
            2018, 9, 29, 15, 30, tzinfo=datetime.timezone.utc)
        assert len(generated_entity_external_ids) == 2
        assert len(updated_entity_external_ids) == 0
        assert len(removed_entity_external_ids) == 0
コード例 #18
0
    def test_feed_manager(self, mock_session, mock_request):
        """Test the feed manager."""
        mock_session.return_value.__enter__.return_value.send.return_value.ok = True
        mock_session.return_value.__enter__.return_value.send.return_value.text = (
            load_fixture("ign_sismologia_feed.xml"))

        # This will just record calls and keep track of external ids.
        generated_entity_external_ids = []
        updated_entity_external_ids = []
        removed_entity_external_ids = []

        def _generate_entity(external_id):
            """Generate new entity."""
            generated_entity_external_ids.append(external_id)

        def _update_entity(external_id):
            """Update entity."""
            updated_entity_external_ids.append(external_id)

        def _remove_entity(external_id):
            """Remove entity."""
            removed_entity_external_ids.append(external_id)

        feed_manager = IgnSismologiaFeedManager(_generate_entity,
                                                _update_entity, _remove_entity,
                                                HOME_COORDINATES)
        assert (repr(feed_manager) == "<IgnSismologiaFeedManager("
                "feed=<IgnSismologiaFeed(home="
                "(40.38, -3.72), "
                "url=http://www.ign.es/ign/"
                "RssTools/sismologia.xml, "
                "radius=None, magnitude=None)>)>")
        feed_manager.update()
        entries = feed_manager.feed_entries
        self.assertIsNotNone(entries)
        assert len(entries) == 3
        assert feed_manager.last_timestamp == datetime.datetime(
            2019, 3, 18, 19, 34, 55)
        assert len(generated_entity_external_ids) == 3
        assert len(updated_entity_external_ids) == 0
        assert len(removed_entity_external_ids) == 0
コード例 #19
0
    def test_remove_org_webhook_blows_up_if_webhook_does_not_exist(self):
        responses.add(responses.GET,
                      'https://api.github.com/orgs/github',
                      json=json.loads(load_fixture('organization.json')),
                      status=200)

        # hook does not exist
        responses.add(responses.GET,
                      'https://api.github.com/orgs/github/hooks?per_page=100',
                      json=[],
                      status=200)

        mock_env = {
            'LINTREVIEW_SETTINGS': 'settings.sample.py',
            'LINTREVIEW_SERVER_NAME': 'example.com'
        }

        with temp_env(mock_env):
            with self.assertRaises(SystemExit):
                self._do_parse(
                    ['org-unregister', '--user', 'cool-token', 'github'])
コード例 #20
0
    def test_nearest(self):

        # Test Defaults
        json = load_fixture('nearest_stations')
        self.adapter.register_uri('GET', '/stations/35.5/-97.3', json=json)
        stations = Station.nearest(35.5, -97.3)
        self.assertEqual(len(stations), 3)

        # Test Limit
        self.adapter.register_uri('GET',
                                  '/stations/35.5/-97.3?limit=3',
                                  json=json)
        stations = Station.nearest(35.5, -97.3, limit=3)
        self.assertEqual(len(stations), 3)

        # Test Radius
        self.adapter.register_uri('GET',
                                  '/stations/35.5/-97.3?radius=25.5',
                                  json=json)
        stations = Station.nearest(35.5, -97.3, radius=25.5)
        self.assertEqual(len(stations), 3)
コード例 #21
0
    def test_update_ok_en_with_magnitude(self, mock_session, mock_request):
        """Test updating feed is ok."""
        mock_session.return_value.__enter__.return_value.send.return_value.ok = True
        mock_session.return_value.__enter__.return_value.send.return_value.text = (
            load_fixture("natural_resources_canada_earthquakes_en_feed.xml"))

        feed = NaturalResourcesCanadaEarthquakesFeed(
            HOME_COORDINATES, "en", filter_minimum_magnitude=4.0)
        assert (repr(feed) == "<NaturalResourcesCanadaEarthquakesFeed("
                "home=(49.25, -123.1), url=http://www."
                "earthquakescanada.nrcan.gc.ca/index-en.php?"
                "tpl_region=canada&tpl_output=rss, "
                "radius=None, magnitude=4.0)>")
        status, entries = feed.update()
        assert status == UPDATE_OK
        self.assertIsNotNone(entries)
        assert len(entries) == 1

        feed_entry = entries[0]
        assert feed_entry.title == "Title 1"
        assert feed_entry.external_id == "1234"
コード例 #22
0
    def test_feed_manager_no_timestamp(self, mock_session, mock_request):
        """Test updating feed is ok."""
        mock_session.return_value.__enter__.return_value.send.return_value.ok = True
        mock_session.return_value.__enter__.return_value.send.return_value.text = (
            load_fixture("generic_feed_5.xml")
        )

        # This will just record calls and keep track of external ids.
        generated_entity_external_ids = []
        updated_entity_external_ids = []
        removed_entity_external_ids = []

        def _generate_entity(external_id):
            """Generate new entity."""
            generated_entity_external_ids.append(external_id)

        def _update_entity(external_id):
            """Update entity."""
            updated_entity_external_ids.append(external_id)

        def _remove_entity(external_id):
            """Remove entity."""
            removed_entity_external_ids.append(external_id)

        feed_manager = GenericFeedManager(
            _generate_entity, _update_entity, _remove_entity, HOME_COORDINATES_1, None
        )
        assert (
            repr(feed_manager) == "<GenericFeedManager("
            "feed=<GenericFeed(home="
            "(-31.0, 151.0), url=None, "
            "radius=None, categories=None)>)>"
        )
        feed_manager.update()
        entries = feed_manager.feed_entries
        self.assertIsNotNone(entries)
        assert len(entries) == 1
        self.assertIsNone(feed_manager.last_timestamp)
コード例 #23
0
class OAuth2Test(unittest.TestCase):
    @with_mock_client(request_returns=load_fixture('access_token'))
    def test_get_token_params(self, client):
        token = client.oauth2.get_token(client_id='client_id',
                                        client_secret='client_secret',
                                        scope=['account', 'events'])
        client.request.assert_called_once_with('post',
                                               '/oauth2/token/',
                                               auth=('client_id',
                                                     'client_secret'),
                                               data={
                                                   'scope':
                                                   'account events',
                                                   'grant_type':
                                                   'client_credentials'
                                               })
        assert isinstance(token, AccessToken)
        assert token.to_primitive() == client.request.return_value

        with pytest.raises(ValidationError):
            client.oauth2.get_token(client_id=None)

        with pytest.raises(ValidationError):
            client.oauth2.get_token(invalid_arg=None)

    @with_mock_client()
    def test_revoke_token_params(self, client):
        result = client.oauth2.revoke_token(client_id='client_id',
                                            client_secret='client_secret',
                                            token='token123')
        client.request.assert_called_once_with('post',
                                               '/oauth2/revoke/',
                                               auth=('client_id',
                                                     'client_secret'),
                                               data={
                                                   'token':
                                                   'token123',
                                                   'token_type_hint':
                                                   'access_token'
                                               })
        assert result is None

        with pytest.raises(ValidationError):
            client.oauth2.revoke_token(token=None)

        with pytest.raises(ValidationError):
            client.oauth2.revoke_token(invalid_arg=None)

    @with_client()
    @with_mock_responses()
    def test_get_token(self, client, responses):
        token = client.oauth2.get_token(client_id='client_id',
                                        client_secret='client_secret',
                                        scope=['account', 'events'])
        assert isinstance(token, AccessToken)
        assert token.access_token == "token123"
        assert token.token_type == "Bearer"
        assert token.scope == ['account', 'events']
        assert len(responses.calls) == 1
        assert responses.calls[0].request.headers[
            'Content-Type'] == 'application/x-www-form-urlencoded'
        assert responses.calls[0].request.headers[
            'Authorization'] == 'Basic Y2xpZW50X2lkOmNsaWVudF9zZWNyZXQ='
        assert dict(parse_qsl(responses.calls[0].request.body)) == {
            'scope': 'account events',
            'grant_type': 'client_credentials'
        }

    @with_client()
    @with_mock_responses()
    def test_revoke_token(self, client, responses):
        result = client.oauth2.revoke_token(client_id='client_id',
                                            client_secret='client_secret',
                                            token='token123')
        assert result is None
        assert len(responses.calls) == 1
        assert responses.calls[0].request.headers[
            'Content-Type'] == 'application/x-www-form-urlencoded'
        assert responses.calls[0].request.headers[
            'Authorization'] == 'Basic Y2xpZW50X2lkOmNsaWVudF9zZWNyZXQ='
        assert dict(parse_qsl(responses.calls[0].request.body)) == {
            'token_type_hint': 'access_token',
            'token': 'token123'
        }
コード例 #24
0
    def test_feed_manager(self, mock_session, mock_request):
        """Test the feed manager."""
        mock_session.return_value.__enter__.return_value.send.return_value.ok = True
        mock_session.return_value.__enter__.return_value.send.return_value.text = (
            load_fixture("generic_feed_1.xml")
        )

        # This will just record calls and keep track of external ids.
        generated_entity_external_ids = []
        updated_entity_external_ids = []
        removed_entity_external_ids = []

        def _generate_entity(external_id):
            """Generate new entity."""
            generated_entity_external_ids.append(external_id)

        def _update_entity(external_id):
            """Update entity."""
            updated_entity_external_ids.append(external_id)

        def _remove_entity(external_id):
            """Remove entity."""
            removed_entity_external_ids.append(external_id)

        feed_manager = GenericFeedManager(
            _generate_entity, _update_entity, _remove_entity, HOME_COORDINATES_1, None
        )
        assert (
            repr(feed_manager) == "<GenericFeedManager("
            "feed=<GenericFeed(home="
            "(-31.0, 151.0), url=None, "
            "radius=None, categories=None)>)>"
        )
        feed_manager.update()
        entries = feed_manager.feed_entries
        self.assertIsNotNone(entries)
        assert len(entries) == 5
        self.assertIsNotNone(feed_manager.last_update)
        assert feed_manager.last_timestamp == datetime.datetime(2018, 9, 23, 9, 10)
        assert len(generated_entity_external_ids) == 5
        assert len(updated_entity_external_ids) == 0
        assert len(removed_entity_external_ids) == 0

        feed_entry = entries.get("1234")
        assert feed_entry.title == "Title 1"
        assert feed_entry.external_id == "1234"
        assert feed_entry.coordinates == (-37.2345, 149.1234)
        self.assertAlmostEqual(feed_entry.distance_to_home, 714.4, 1)
        assert repr(feed_entry) == "<GenericFeedEntry(id=1234)>"

        feed_entry = entries.get("2345")
        assert feed_entry.title == "Title 2"
        assert feed_entry.external_id == "2345"

        feed_entry = entries.get("Title 3")
        assert feed_entry.title == "Title 3"
        assert feed_entry.external_id == "Title 3"

        external_id = hash((-37.8901, 149.7890))
        feed_entry = entries.get(external_id)
        self.assertIsNone(feed_entry.title)
        assert feed_entry.external_id == external_id

        feed_entry = entries.get("5678")
        assert feed_entry.title == "Title 5"
        assert feed_entry.external_id == "5678"

        # Simulate an update with several changes.
        generated_entity_external_ids.clear()
        updated_entity_external_ids.clear()
        removed_entity_external_ids.clear()

        mock_session.return_value.__enter__.return_value.send.return_value.text = (
            load_fixture("generic_feed_4.xml")
        )

        feed_manager.update()
        entries = feed_manager.feed_entries
        self.assertIsNotNone(entries)
        assert len(entries) == 3
        assert len(generated_entity_external_ids) == 1
        assert len(updated_entity_external_ids) == 2
        assert len(removed_entity_external_ids) == 3

        feed_entry = entries.get("1234")
        assert feed_entry.title == "Title 1 UPDATED"

        feed_entry = entries.get("2345")
        assert feed_entry.title == "Title 2"

        feed_entry = entries.get("6789")
        assert feed_entry.title == "Title 6"

        # Simulate an update with no data.
        generated_entity_external_ids.clear()
        updated_entity_external_ids.clear()
        removed_entity_external_ids.clear()

        mock_session.return_value.__enter__.return_value.send.return_value.ok = False

        feed_manager.update()
        entries = feed_manager.feed_entries

        assert len(entries) == 0
        assert len(generated_entity_external_ids) == 0
        assert len(updated_entity_external_ids) == 0
        assert len(removed_entity_external_ids) == 3
コード例 #25
0
 def test_location(self):
     json = load_fixture('daily_precipitation_location')
     self.adapter.register_uri('GET', '/daily-precipitation/35/-97',
                               json=json)
     okc_precip = DailyPrecipitation.location(35, -97)
     self.assertEqual(len(okc_precip.series), 3)
コード例 #26
0
 def test_contour(self):
     json = load_fixture('daily_precipitation_contour')
     self.adapter.register_uri('GET', '/daily-precipitation/fe68c33d-e718-4449-acae-351072ce7749/contours',
                               json=json)
     DailyPrecipitation.contours('fe68c33d-e718-4449-acae-351072ce7749')
コード例 #27
0
 def test_asset(self):
     json = load_fixture('daily_precipitation_asset')
     self.adapter.register_uri('GET', '/daily-precipitation/fe68c33d-e718-4449-acae-351072ce7749',
                               json=json)
     asset_precip = DailyPrecipitation.asset('fe68c33d-e718-4449-acae-351072ce7749')
     self.assertEqual(asset_precip.accumulationStatistics['mean'], 21.5)
コード例 #28
0
 def test_location(self):
     json = load_fixture('hourly_wind_speed_location')
     self.adapter.register_uri('GET', '/hourly-wind-speed/35/-97',
                               json=json)
     okc_ws = HourlyWindSpeed.location(35, -97)
     self.assertEqual(len(okc_ws.series), 4)
コード例 #29
0
 def test_location(self):
     json = load_fixture('hourly_solar_radiation_location')
     self.adapter.register_uri('GET', '/hourly-solar-radiation/35/-97',
                               json=json)
     okc_solar = HourlySolarRadiation.location(35, -97)
     self.assertEqual(len(okc_solar.series), 3)
コード例 #30
0
 def mock_github_get_hooks(self):
     httpretty.register_uri(
         httpretty.GET,
         'http://api.github.com/orgs/org_name/hooks',
         status=200,
         body=load_fixture('responses/github_get_hooks_success.json'))
コード例 #31
0
 def test_asset(self):
     json = load_fixture('hourly_wind_speed_asset')
     self.adapter.register_uri('GET', '/hourly-wind-speed/fe68c33d-e718-4449-acae-351072ce7749',
                               json=json)
     asset_ws = HourlyWindSpeed.asset('fe68c33d-e718-4449-acae-351072ce7749')
     self.assertEqual(asset_ws.timeSeriesStatistics['mean'], 15.0)
コード例 #32
0
 def test_location(self):
     json = load_fixture('hourly_et_short_crop_location')
     self.adapter.register_uri(
         'GET', '/hourly-evapotranspiration-short-crop/35/-97', json=json)
     okc_et = HourlyEtShortCrop.location(35, -97)
     self.assertEqual(len(okc_et.series), 4)
コード例 #33
0
class ClientTest(unittest.TestCase):
    def setUp(self):
        self.client = predicthq.Client()

    @with_config(ENDPOINT_URL="https://api.predicthq.com")
    def test_build_url(self):
        self.assertEqual(self.client.build_url('v1'),
                         "https://api.predicthq.com/v1/")

    def test_endpoints_initialization(self):
        self.assertIsInstance(self.client.oauth2, endpoints.OAuth2Endpoint)
        self.assertIsInstance(self.client.accounts, endpoints.AccountsEndpoint)
        self.assertIsInstance(self.client.events, endpoints.EventsEndpoint)
        self.assertIsInstance(self.client.signals, endpoints.SignalsEndpoint)
        self.assertIsInstance(self.client.places, endpoints.PlacesEndpoint)

    @with_mock_responses()
    def test_request(self, responses):
        self.client.logger.setLevel('DEBUG')

        self.assertDictEqual(self.client.get("/v1/"),
                             responses.calls[0].response.json())

        self.assertIsNone(self.client.get("/no-content/"))

        self.assertIsNone(self.client.get("/invalid-json/"))

        with self.assertRaises(ClientError) as ctx:
            self.client.get("/not-found/")
            self.assertEqual(ctx.exception.message,
                             responses.calls[3].response.json())

        with self.assertRaises(ServerError) as ctx:
            self.client.get("/server-error/")
            self.assertEqual(ctx.exception.message,
                             responses.calls[4].response.json())

        with self.assertRaises(ServerError) as ctx:
            self.client.get("/no-json/")
            self.assertEqual(ctx.exception.message,
                             responses.calls[5].response.content)

        # Test headers
        self.client.authenticate(client_id='client_id',
                                 client_secret='client_secret',
                                 scope=['account'])
        self.assertEqual(responses.calls[6].request.headers['Authorization'],
                         'Basic Y2xpZW50X2lkOmNsaWVudF9zZWNyZXQ=')
        self.assertEqual(responses.calls[6].request.headers['Content-Type'],
                         'application/x-www-form-urlencoded')

        self.client.accounts.self()
        self.assertEqual(responses.calls[7].request.headers['Authorization'],
                         'Bearer token123')
        self.assertEqual(responses.calls[7].request.headers['Accept'],
                         'application/json')

    @with_mock_client(request_returns={"result": "value"})
    def test_get(self, client):
        result = self.client.get('/get/', params={'q': 'query'})
        client.request.assert_called_once_with('get',
                                               '/get/',
                                               params={'q': 'query'})
        self.assertDictEqual(result, client.request.return_value)

    @with_mock_client(request_returns={"result": "value"})
    def test_post(self, client):
        result = self.client.post('/post/', data={'key': 'value'})
        client.request.assert_called_once_with('post',
                                               '/post/',
                                               data={'key': 'value'})
        self.assertDictEqual(result, client.request.return_value)

    @with_mock_client(request_returns={"result": "value"})
    def test_put(self, client):
        result = self.client.put('/put/', data={'key': 'value'})
        client.request.assert_called_once_with('put',
                                               '/put/',
                                               data={'key': 'value'})
        self.assertDictEqual(result, client.request.return_value)

    @with_mock_client(request_returns={"result": "value"})
    def test_patch(self, client):
        result = self.client.patch('/patch/', data={'key': 'value'})
        client.request.assert_called_once_with('patch',
                                               '/patch/',
                                               data={'key': 'value'})
        self.assertDictEqual(result, client.request.return_value)

    @with_mock_client()
    def test_delete(self, client):
        result = client.delete('/delete/')
        client.request.assert_called_once_with('delete', '/delete/')
        self.assertEqual(result, client.request.return_value)

    @with_mock_client(request_returns=load_fixture('access_token'))
    def test_authenticate(self, client):
        token = self.client.authenticate(
            client_id='client_id',
            client_secret='client_secret',
            scope=['account', 'events', 'signals'])
        client.request.assert_called_once_with('post',
                                               '/oauth2/token/',
                                               auth=('client_id',
                                                     'client_secret'),
                                               data={
                                                   'scope':
                                                   'account events signals',
                                                   'grant_type':
                                                   'client_credentials'
                                               })

        self.assertIsInstance(token, AccessToken)
        self.assertDictEqual(token.to_primitive(), client.request.return_value)

        self.assertEqual(self.client.access_token, 'token123')

    def test_construct_with_access_token(self):
        client = predicthq.Client(access_token='token123')
        self.assertEqual(client.access_token, 'token123')

    @with_config(OAUTH2_ACCESS_TOKEN='token123')
    def test_construct_with_access_token_config(self):
        client = predicthq.Client()
        self.assertEqual(client.access_token, 'token123')
コード例 #34
0
 def mock_slack_response(self, fixture='responses/slack_post_message_success.json'):
     mock_slack = Mock()
     mock_slack.return_value = json.loads(load_fixture(fixture))
     return mock_slack
コード例 #35
0
    def test_generate_metrics(self):

        stats = load_fixture('stats')
        m = generate_metrics(stats)

        self.assertEqual(m['SignalQueueCount'], 0)
        self.assertEqual(m['LoadCount'], 0)

        self.assertEqual(m['LocksUser0Count'], 0)
        self.assertEqual(m['LocksFilemonCount'], 0)
        self.assertEqual(m['LocksTimerCount'], 0)
        self.assertEqual(m['LocksRbTimerCount'], 0)
        self.assertEqual(m['LocksCronCount'], 0)
        self.assertEqual(m['LocksRpcCount'], 0)
        self.assertEqual(m['LocksSnmpCount'], 0)

        self.assertEqual(m['SocketsCount'], 1)

        self.assertEqual(len(m['SocketsQueueCount']), 1)
        self.assertEqual(m['SocketsQueueCount'][0], 0)

        self.assertEqual(len(m['SocketsMaxQueueCount']), 1)
        self.assertEqual(m['SocketsMaxQueueCount'][0], 0)

        self.assertEqual(len(m['SocketsSharedCount']), 1)
        self.assertEqual(m['SocketsSharedCount'][0], 0)

        self.assertEqual(len(m['SocketsCanOffloadCount']), 1)
        self.assertEqual(m['SocketsCanOffloadCount'][0], 0)

        self.assertEqual(m['WorkersCount'], 2)
        self.assertEqual(m['WorkersIdleCount'], 0)
        self.assertEqual(m['WorkersBusyCount'], 2)
        self.assertEqual(m['WorkersAcceptingCount'], 2)

        self.assertEqual(len(m['WorkersRequestsCount']), 2)
        self.assertEqual(m['WorkersRequestsCount'][0], 305)
        self.assertEqual(m['WorkersRequestsCount'][1], 307)

        self.assertEqual(len(m['WorkersDeltaRequestsCount']), 2)
        self.assertEqual(m['WorkersDeltaRequestsCount'][0], 305)
        self.assertEqual(m['WorkersDeltaRequestsCount'][1], 307)

        self.assertEqual(len(m['WorkersAverageResponseTimeMilliseconds']), 2)
        self.assertEqual(m['WorkersAverageResponseTimeMilliseconds'][0], 3017)
        self.assertEqual(m['WorkersAverageResponseTimeMilliseconds'][1], 3017)

        self.assertEqual(len(m['WorkersExceptionsCount']), 2)
        self.assertEqual(m['WorkersExceptionsCount'][0], 0)
        self.assertEqual(m['WorkersExceptionsCount'][1], 0)

        self.assertEqual(len(m['WorkersHarakiriCount']), 2)
        self.assertEqual(m['WorkersHarakiriCount'][0], 0)
        self.assertEqual(m['WorkersHarakiriCount'][1], 0)

        self.assertEqual(len(m['WorkersSignalsCount']), 2)
        self.assertEqual(m['WorkersSignalsCount'][0], 0)
        self.assertEqual(m['WorkersSignalsCount'][1], 0)

        self.assertEqual(len(m['WorkersRssBytes']), 2)
        self.assertEqual(m['WorkersRssBytes'][0], 0)
        self.assertEqual(m['WorkersRssBytes'][1], 0)

        self.assertEqual(len(m['WorkersVszBytes']), 2)
        self.assertEqual(m['WorkersVszBytes'][0], 0)
        self.assertEqual(m['WorkersVszBytes'][1], 0)

        self.assertEqual(len(m['WorkersRunningTimeMilliseconds']), 2)
        self.assertEqual(m['WorkersRunningTimeMilliseconds'][0], 917565)
        self.assertEqual(m['WorkersRunningTimeMilliseconds'][1], 923616)

        self.assertEqual(len(m['WorkerCoresCount']), 2)
        self.assertEqual(m['WorkerCoresCount'][0], 5)
        self.assertEqual(m['WorkerCoresCount'][1], 5)

        self.assertEqual(len(m['WorkerCoresStaticRequestsCount']), 10)
        self.assertEqual(m['WorkerCoresStaticRequestsCount'][0], 0)
        self.assertEqual(m['WorkerCoresStaticRequestsCount'][1], 0)

        self.assertEqual(len(m['WorkerCoresRoutedRequestsCount']), 10)
        self.assertEqual(m['WorkerCoresRoutedRequestsCount'][0], 0)
        self.assertEqual(m['WorkerCoresRoutedRequestsCount'][1], 0)

        self.assertEqual(len(m['WorkerCoresWriteErrorsCount']), 10)
        self.assertEqual(m['WorkerCoresWriteErrorsCount'][0], 0)
        self.assertEqual(m['WorkerCoresWriteErrorsCount'][1], 0)

        self.assertEqual(len(m['WorkerCoresReadErrorsCount']), 10)
        self.assertEqual(m['WorkerCoresReadErrorsCount'][0], 0)
        self.assertEqual(m['WorkerCoresReadErrorsCount'][1], 0)
コード例 #36
0
 def test_asset(self):
     json = load_fixture('daily_low_temperature_asset')
     self.adapter.register_uri('GET', '/daily-low-temperature/fe68c33d-e718-4449-acae-351072ce7749',
                               json=json)
     asset_hi_temp = DailyLowTemperature.asset('fe68c33d-e718-4449-acae-351072ce7749')
     self.assertEqual(asset_hi_temp.timeSeriesStatistics['mean'], 34.3)
コード例 #37
0
 def test_contour(self):
     json = load_fixture('hourly_solar_radiation_contour')
     self.adapter.register_uri('GET', '/hourly-solar-radiation/fe68c33d-e718-4449-acae-351072ce7749/contours',
                               json=json)
     HourlySolarRadiation.contours('fe68c33d-e718-4449-acae-351072ce7749')
コード例 #38
0
 def test_contour(self):
     json = load_fixture('daily_low_temperature_contour')
     self.adapter.register_uri('GET', '/daily-low-temperature/fe68c33d-e718-4449-acae-351072ce7749/contours',
                               json=json)
     DailyLowTemperature.contours('fe68c33d-e718-4449-acae-351072ce7749')
コード例 #39
0
 def test_location(self):
     json = load_fixture('daily_low_temperature_location')
     self.adapter.register_uri('GET', '/daily-low-temperature/35/-97',
                               json=json)
     okc_low_temp = DailyLowTemperature.location(35, -97)
     self.assertEqual(len(okc_low_temp.series), 3)
コード例 #40
0
 def test_contour(self):
     json = load_fixture('hourly_wind_speed_contour')
     self.adapter.register_uri('GET', '/hourly-wind-speed/fe68c33d-e718-4449-acae-351072ce7749/contours',
                               json=json)
     HourlyWindSpeed.contours('fe68c33d-e718-4449-acae-351072ce7749')