def test_public_channel_list_filter_keyword(self): response = self.client.get( get_channel_lookup_url(baseurl="/", keyword="zzz")) self.assertEqual(len(response.json()), 0) response = self.client.get( get_channel_lookup_url(baseurl="/", keyword="math")) self.assertEqual(len(response.json()), 1) self.assertEqual(response.json()[0]["id"], self.channel_id1)
def test_public_channel_list_filter_keyword_language(self): response = self.client.get( get_channel_lookup_url(baseurl="/", keyword="zzz", language="es")) self.assertEqual(len(response.json()), 0) response = self.client.get( get_channel_lookup_url(baseurl="/", keyword="science", language="es")) self.assertEqual(len(response.json()), 1) self.assertEqual(response.json()[0]["id"], self.channel_id2)
def test_public_channel_list_filter_language(self): response = self.client.get( get_channel_lookup_url(baseurl="/", language="zu")) self.assertEqual(len(response.json()), 0) # filter based on contentnode languages response = self.client.get( get_channel_lookup_url(baseurl="/", language="en")) self.assertEqual(len(response.json()), 2) # filter based on root contentnode language response = self.client.get( get_channel_lookup_url(baseurl="/", language="es")) self.assertEqual(len(response.json()), 1) self.assertEqual(response.json()[0]["id"], self.channel_id2)
def channeldiffstats(self, request): job_metadata = {} channel_id = request.data.get("channel_id") method = request.data.get("method") drive_id = request.data.get("drive_id") baseurl = request.data.get("baseurl") # request validation and job metadata info if not channel_id: raise serializers.ValidationError("The channel_id field is required.") if not method: raise serializers.ValidationError("The method field is required.") if method == "network": baseurl = baseurl or conf.OPTIONS["Urls"]["CENTRAL_CONTENT_BASE_URL"] job_metadata["baseurl"] = baseurl # get channel version metadata url = get_channel_lookup_url(baseurl=baseurl, identifier=channel_id) resp = requests.get(url) channel_metadata = resp.json() job_metadata["new_channel_version"] = channel_metadata[0]["version"] elif method == "disk": if not drive_id: raise serializers.ValidationError( "The drive_id field is required when using 'disk' method." ) job_metadata = _add_drive_info(job_metadata, request.data) # get channel version metadata drive = get_mounted_drive_by_id(drive_id) channel_metadata = read_channel_metadata_from_db_file( get_content_database_file_path(channel_id, drive.datafolder) ) job_metadata["new_channel_version"] = channel_metadata.version else: raise serializers.ValidationError( "'method' field should either be 'network' or 'disk'." ) job_metadata.update( { "type": "CHANNELDIFFSTATS", "started_by": request.user.pk, "channel_id": channel_id, } ) job_id = priority_queue.enqueue( diff_stats, channel_id, method, drive_id=drive_id, baseurl=baseurl, extra_metadata=job_metadata, track_progress=False, cancellable=True, ) resp = _job_to_response(priority_queue.fetch_job(job_id)) return Response(resp)
def test_public_filter_unlisted(self): set_device_settings(allow_peer_unlisted_channel_import=False) unlisted_channel_id = uuid.uuid4().hex create_mini_channel(channel_name="math 2", channel_id=unlisted_channel_id) set_channel_metadata_fields(unlisted_channel_id, public=False) response = self.client.get(get_channel_lookup_url(baseurl="/")) data = response.json() self.assertEqual(len(data), 2)
def lookup_channel_listing_status(channel_id, baseurl=None): """ Look up the listing status of the channel from the remote, this is surfaced as a `public` boolean field. """ resp = requests.get(get_channel_lookup_url(identifier=channel_id, baseurl=baseurl)) if resp.status_code != 200: return None (channel_info,) = resp.json() return channel_info.get("public", None)
def _make_channel_endpoint_request( self, identifier=None, baseurl=None, keyword=None, language=None ): url = get_channel_lookup_url( identifier=identifier, baseurl=baseurl, keyword=keyword, language=language ) resp = requests.get(url) if resp.status_code == 404: raise Http404( _("The requested channel does not exist on the content server") ) # map the channel list into the format the Kolibri client-side expects channels = list(map(self._studio_response_to_kolibri_response, resp.json())) return Response(channels)
def test_public_channel_lookup(self): response = self.client.get( get_channel_lookup_url(identifier=self.channel_id2), format="json") data = response.json() self.assertEqual(len(data), 1) data = data[0] expected = { "id": self.channel_id2, "name": "science", "language": "es", # root node language "description": "", "total_resource_count": 2, # should account for nodes with duplicate content_ids "version": 0, "published_size": 20, "last_published": None, "icon_encoding": "", "matching_tokens": [], "public": True, } for key, value in iteritems(expected): self.assertEqual(data[key], value) # we don't care what order these elements are in self.assertSetEqual(set(["en", "es"]), set(data["included_languages"]))
def test_public_channel_lookup_no_channel(self): response = self.client.get( get_channel_lookup_url(identifier=uuid.uuid4().hex)) self.assertEqual(response.status_code, 404)
def test_public_channel_list_no_version(self): response = self.client.get(get_channel_lookup_url(version="100000")) self.assertEqual(response.status_code, 404)
def test_public_channel_list(self): response = self.client.get(get_channel_lookup_url(baseurl="/")) data = response.json() self.assertEqual(len(data), 2)