class CategoryModelTestCase(TestCase): """ This class defines the test cases for the Category model """ def setUp(self): """ Set up the test suite and some initial variables """ self.user = User.objects.create(username="******") self.category_content = { "name": "Test", "description": "This is a test category" } self.category = Category(name="Test", description="This is a test category", owner=self.user) def test_category_can_be_created(self): """ Test that a category can be created by providing the required information. """ old_count = Category.objects.count() self.category.save() new_count = Category.objects.count() self.assertEqual(new_count, old_count + 1) created_category = Category.objects.get() self.assertTrue(isinstance(created_category, Category))
def categories(app): categories = [] for each in range(3): params = {'name': fake.alphanumeric()} category = Category(**params) categories.append(category.save()) return categories
def setUp(self): """ Define the test client and initial variables for the test suite """ self.user = User.objects.create(username="******") self.client = APIClient() self.client.force_authenticate(user=self.user) self.category = Category(name="Test", description="This is a test category", owner=self.user) self.category.save() self.article = Article(url="http://www.dummy.com", title="Dummy title", category=self.category, owner=self.user) self.article_data = { "url": "http://www.dummy.com", "title": "Dummy Title", "description": "A sample description", "read_status": False, "owner": self.user.id } article_url = '/api/v2/categories/{}/articles/'.format( self.category.id) self.response = self.client.post(article_url, self.article_data, format="json")
def put(current_user, self, id): """ Edit a category with the specified id --- tags: - categories parameters: - in: path name: id required: true description: The ID of the category to retrieve type: string - in: body name: category required: true description: The name of the category type: string schema: id: category properties: name: type: string default: soup security: - TokenHeader: [] responses: 200: description: A single category successfully deleted schema: id: category properties: name: type: string default: soup """ category = Category.query.filter_by(id=id, user_id=current_user.id).first() if not category: return {"Error": "A category with that Id does not exist"}, 404 category_dict = request.get_json(force=True) if 'name' in category_dict: category_name = category_dict['name'].strip() errors = category_schema.validate(category_dict) if errors: abort(status.HTTP_400_BAD_REQUEST, errors) error, validated_name = Category.validate_data(ctx=category_name) if validated_name: if Category.is_unique(id=id, name=category_name, user_id=current_user.id): category.name = category_name else: abort(status.HTTP_409_CONFLICT, 'A category with the same name already exists') else: return {"errors": error} category.update() return {'message': 'Category successfully edited!'}, 201
def test_delete_a_category(client): category = Category(name='Test category') category.save() response = client.delete('/api/v1/categories/{}/'.format(str(category.id)), content_type='application/json') assert response.status_code == 204
def load_category(path, delete_all=False): if delete_all: Category.objects.all().delete() with open(path) as csvfile: reader = csv.DictReader(csvfile) for row in reader: category = Category(category=row['category']) category.save()
def handle(self, *args, **options): with open('data/category.csv', encoding='utf-8') as csvfile: spamreader = csv.reader(csvfile) for id, row in enumerate(spamreader): if id == 0: continue category = Category(id=row[0], name=row[1], slug=row[2]) category.save()
def create(name, description, words): """ Create a new category """ words_obj = [] if words: for word in words: words_obj.append(Word(word=word)) category = Category(name=name, description=description, words=words_obj) return category.save()
def test_get_a_category(client): category = Category(name='Test category') category.save() response = client.get('/api/v1/categories/{}/'.format(str(category.id)), format='json') content = json.loads(response.content.decode("utf-8")) assert response.status_code == 200 assert content['id'] == str(category.id)
def test_save(self, init_db): """Test for creating a new company Args: init_db(SQLAlchemy): fixture to initialize the test database """ params = { 'name': fake.alphanumeric(15) } category = Category(**params) assert category == category.save()
def setUp(self): """ Set up the test suite and some initial variables """ self.user = User.objects.create(username="******") self.category_content = { "name": "Test", "description": "This is a test category" } self.category = Category(name="Test", description="This is a test category", owner=self.user)
def crawl_categories(url): url_html = requests.get(url) index_soup = BeautifulSoup(url_html.content, 'html.parser') categories = index_soup.select('[href*="catalogue/category/books/"]') for c in categories: name = c.getText().strip() cur_category = Category.objects.filter(name=name) if cur_category: pass else: new_category = Category(name=name) new_category.save()
def test_update_a_category(client): category = Category(name='Test category') category.save() response = client.patch('/api/v1/categories/{}/'.format(str(category.id)), json.dumps({'name': 'Updated Name'}), content_type='application/json') content = json.loads(response.content.decode("utf-8")) assert response.status_code == 200 assert content['name'] == 'Updated Name'
def create_entry(category_data): from api.models import Category, Favorite try: category = Category(name=category_data['name']) category.save() for each in category_data.get('favorites', []): favorite = Favorite(**dict(**each, category_id=category.id)) favorite.save() except Exception as e: print(e) pass
def test_get_categories(client): category = Category(name='Test category') category.save() response = client.get('/api/v1/categories/', format='json') content = json.loads(response.content.decode("utf-8")) assert response.status_code == 200 assert content['count'] == 1 assert content['next'] == None assert content['previous'] == None assert any( str(category.id) == result['id'] for result in content['results'])
def test_update_favorite_thing_validation(client): category = Category(name="Food") category.save() favorite_thing = FavoriteThing(title="Rice", category=category, ranking=1) favorite_thing.save() response = client.patch('/api/v1/favorite-things/{}/'.format( str(favorite_thing.id)), {'ranking': {}}, content_type='application/json') content = json.loads(response.content.decode("utf-8")) assert response.status_code == 400 assert content == {'ranking': ['A valid integer is required.']}
def test_update_favorite_thing(client): category = Category(name="Food") category.save() favorite_thing = FavoriteThing(title="Rice", category=category, ranking=1) favorite_thing.save() response = client.patch('/api/v1/favorite-things/{}/'.format( str(favorite_thing.id)), {'title': 'Koko'}, content_type='application/json') content = json.loads(response.content.decode("utf-8")) assert response.status_code == 200 assert content['title'] == 'Koko'
def get_pages_from_json(json) -> Dict[str, Page]: categorizer = Categorizer() pages_to_return = {} response_pages = get_hits(json) for page in response_pages: page_info = page.get("_source") url = page_info.get("raw_url") if is_url_valid(url): page_id = page.get("_id") title = page_info.get("title") response_links = page_info.get("links") last_updated = page_info.get("updated_on") links = get_links_from_json(response_links) content = page_info.get("content") category_name = categorizer.categorize(bytes(content, 'utf-8').decode('utf-8', 'ignore')) category = Category( name=category_name, occurrence=1, ) pages_to_return[url] = Page( id=page_id, url=url, title=title, last_updated=last_updated, links=links, content=content, categories=[category] ) else: print("cannot find url for source: {}".format(page_info)) return pages_to_return
def test_tags(self): category = Category(name="Test category") db.session.add(category) media = Media(path="/foo/bar", mediainfo={"width": 100, "height": 100, "acodec": "aac", "vcodec": "h.265"}, category=category, mimetype="video", lastModified=int(time.time()), timeLastIndexed=int(time.time()), sha=b'\x00'*32) db.session.add(media) db.session.commit() tag1 = Tag(name="tag1") tag2 = Tag(name="tag2") db.session.add(tag1) db.session.add(tag2) media.tags.append(tag1) media.tags.append(tag2) medias = Media.query.all() assert media in medias assert medias[0].tags == [tag1, tag2]
def create(self, request): ''' :method:POST: creates a new category. ''' user = request.user print(user) print(request.data) print("here") title = request.data["title"] description = request.data["description"] category = Category(title=title, description=description, user=user) category.save() category = CategorySerializer(category) return Response(category.data)
def test_create_category_fails_when_already_existing(self): new_category = {'name': 'Friends'} Category(**new_category).save() response = self.client.post('/categories', new_category, format='json') self.assertEqual(response.status_code, 400) self.assertEqual(response.data['name'][0], 'category with this name already exists.')
def test_update_favorite_thing_ranking_without_category(client): category = Category(name="Food") category.save() favorite_thing = FavoriteThing(title="Rice", category=category, ranking=1) favorite_thing.save() second_favorite_thing = FavoriteThing(title="Beans", category=category, ranking=2) second_favorite_thing.save() third_favorite_thing = FavoriteThing(title="soup", category=category, ranking=3) third_favorite_thing.save() response = client.patch('/api/v1/favorite-things/{}/'.format( str(favorite_thing.id)), {'ranking': 5}, content_type='application/json') content = json.loads(response.content.decode("utf-8")) assert response.status_code == 400 assert content == {'ranking': ['number is out of ranking range']} response = client.patch('/api/v1/favorite-things/{}/'.format( str(second_favorite_thing.id)), {'ranking': 3}, content_type='application/json') content = json.loads(response.content.decode("utf-8")) assert response.status_code == 200 assert content['ranking'] == 3 third_favorite_thing.refresh_from_db() assert third_favorite_thing.ranking == 2 response = client.patch('/api/v1/favorite-things/{}/'.format( str(third_favorite_thing.id)), {'ranking': 1}, content_type='application/json') content = json.loads(response.content.decode("utf-8")) assert response.status_code == 200 assert content['ranking'] == 1 third_favorite_thing.refresh_from_db() assert third_favorite_thing.ranking == 1
def test_get(self, init_db, category): """Test for get method Args: init_db(SQLAlchemy): fixture to initialize the test database category (Category): Fixture to create a new category """ assert Category.get(category.id) == category
def make_custom_page(url: str, links: List[str] = [], category: str = 'Social', content: str = 'Social page content') -> Page: return Page(url=url, categories=[Category(name=category, occurrence=1)], content=content, links=[Link(link=lin, occurrences=1) for lin in links])
def test_get_linked_groups_from_ids(self): """Returns groups with links pages""" url_zero = 'zero.onion' url_one = 'one.onion' url_two = 'two.onion' url_three = 'three.onion' links_zero = [url_zero, url_one, url_two, url_three] links_one = [url_zero, url_three] links_two = [url_two] links_three = [] page_one = make_custom_page(url=url_one, links=links_one) page_zero = make_custom_page(url=url_zero, links=links_zero) page_two = make_custom_page(url=url_two, links=links_two) page_three = make_custom_page(url=url_three, links=links_three) pages = {url_zero: page_zero, url_one: page_one, url_two: page_two, url_three: page_three} group_id_one = 1 group_id_two = 2 partition = {url_zero: group_id_one, url_one: group_id_one, url_two: group_id_two, url_three: group_id_one} parent_group_id = '0.2' expected = [ make_custom_group( group_id=parent_group_id + '.' + str(group_id_one), links=[Link(link='0.2.2', name='')], categories=[Category(name='Social', occurrence=3)], pages={url_zero: page_zero, url_one: page_one, url_three: page_three} ), make_custom_group( group_id=parent_group_id + '.' + str(group_id_two), links=[], categories=[Category(name='Social', occurrence=1)], pages={url_two: page_two} )] actual = get_linked_groups_from_ids(pages, partition, parent_group_id) self.assertEqual(len(expected), len(actual)) self.assertEqual(expected[0].id, actual[0].id) self.assertEqual(expected[0].categories[0].name, actual[0].categories[0].name) self.assertEqual(expected[0].categories[0].occurrence, actual[0].categories[0].occurrence) self.assertEqual(len(expected[0].links), len(actual[0].links)) self.assertEqual(len(expected[1].members), len(actual[1].members)) self.assertEqual(expected[1].id, actual[1].id) self.assertEqual(expected[1].categories[0].name, actual[1].categories[0].name) self.assertEqual(expected[1].categories[0].occurrence, actual[1].categories[0].occurrence) self.assertEqual(len(expected[1].links), len(actual[1].links)) self.assertEqual(len(expected[1].members), len(actual[1].members))
def make_group(group_id: str) -> Group: return Group(id=group_id, links=[Link(link='0.3', occurrences=2)], members={ oneUrl: make_page(oneUrl), twoUrl: make_page(twoUrl) }, categories=[Category(name='Social', occurrence=2)])
def make_meta_group(group_id: str) -> MetaGroup: return MetaGroup( id=group_id, links=[Link(link='0.3', occurrences=2)], first_members=[make_page(oneUrl), make_page(twoUrl)], categories=[Category(name='Social', occurrence=2)], members_count=2, domains_count=2, )
def test_create_favorite_thing_with_out_of_range_ranking_number(client): category = Category(name="Food") category.save() response = client.post( '/api/v1/favorite-things/', { 'title': 'Rice', 'category': str(category.id), 'ranking': 4 }, content_type='application/json' ) content = json.loads(response.content.decode("utf-8")) assert response.status_code == 400 assert content == { 'ranking': ['number is out of ranking range'] }
def addCategory(): request_body = request.get_json() category = Category( name_Category=request_body["name_Category"], description_Category=request_body["description_Category"], active_Product=request_body["active_Product"]) print(request_body) db.session.add(category) db.session.commit() return jsonify("All good"), 200
def setCategories(request): if request.method == 'POST': categories = request.data.get('categories', None) for category in categories: id = category.get('id', None) name = category.get('name', None) print("{}, {}".format(id, name)) Category(id=id, name=name).save() return Response(status=status.HTTP_200_OK)