def test_description_created_if_it_does_not_exist(self):
brand_to_append = 'Cool Company'
color_to_append = 'Black'
sizes_to_append = ['Large']
original_data = requests_bodies.build_request_body(
properties_to_be_updated={
'brand': brand_to_append,
'color': color_to_append,
'sizes': sizes_to_append
},
properties_to_be_removed=['description'])
mined_attrs = attribute_miner.AttributeMiner(
constants.LANGUAGE_CODE_EN,
constants.DEFAULT_COUNTRY).mine_and_insert_attributes_for_batch(
original_data)
optimizer = description_optimizer.DescriptionOptimizer(mined_attrs)
expected_description = (f'{sizes_to_append[0]} {brand_to_append} '
f'{color_to_append}')
optimized_data, optimization_result = optimizer.process(
original_data, 'test')
product = optimized_data['entries'][0]['product']
self.assertEqual(expected_description, product['description'])
self.assertEqual(1, optimization_result.num_of_products_optimized)
def test_mine_and_insert_attributes_for_batch_mines_brand(self):
product_data = requests_bodies.build_request_body(properties_to_be_updated={
'offerId': 'product-1',
'brand': 'Gucci'
})
miner = attribute_miner.AttributeMiner('test', constants.DEFAULT_COUNTRY)
mined_attributes = miner.mine_and_insert_attributes_for_batch(product_data)
self.assertIn('Gucci', mined_attributes['product-1'].get('brand'))
def test_mine_and_insert_attributes_returns_empty_list_for_product_when_no_attributes_mined(
self):
product_data = requests_bodies.build_request_body(
properties_to_be_updated={'offerId': 'product-1'},
properties_to_be_removed=['brand', 'color', 'gender', 'sizes'])
miner = attribute_miner.AttributeMiner('test', constants.DEFAULT_COUNTRY)
mined_attributes = miner.mine_and_insert_attributes_for_batch(product_data)
self.assertEqual(0, len(mined_attributes['product-1']))
def test_process_does_not_append_brand_when_brand_in_blocklist(self):
blocklisted_brand = 'null'
product_data = requests_bodies.build_request_body(properties_to_be_updated={
'offerId': 'product-1',
'brand': blocklisted_brand,
})
miner = attribute_miner.AttributeMiner('test', constants.DEFAULT_COUNTRY)
mined_attributes = miner.mine_and_insert_attributes_for_batch(product_data)
self.assertNotIn(blocklisted_brand, mined_attributes['product-1'])
def test_mine_and_insert_attributes_for_batch_does_not_mine_brand_if_brand_too_long(
self):
invalid_brand = 'brandthatistoolong' * attribute_miner._MAX_BRAND_LENGTH
product_data = requests_bodies.build_request_body(properties_to_be_updated={
'offerId': 'product-1',
'brand': invalid_brand
})
miner = attribute_miner.AttributeMiner('test', constants.DEFAULT_COUNTRY)
mined_attributes = miner.mine_and_insert_attributes_for_batch(product_data)
self.assertNotIn(invalid_brand, mined_attributes['product-1'])
def test_mine_and_insert_attributes_for_batch_mines_and_inserts_sizes(self):
product_data = requests_bodies.build_request_body(
properties_to_be_updated={
'offerId': 'product-1',
'description': 'TシャツL',
},
properties_to_be_removed=['sizes'])
miner = attribute_miner.AttributeMiner(constants.LANGUAGE_CODE_JA,
constants.COUNTRY_CODE_JP)
_ = miner.mine_and_insert_attributes_for_batch(product_data)
product = product_data['entries'][0]['product']
self.assertIn('L', product['sizes'])
def test_mine_and_insert_attributes_for_batch_mines_color(self):
product_data = requests_bodies.build_request_body(
properties_to_be_updated={
'offerId': 'product-1',
'title': 'タイトルレッド・オレンジ'
},
properties_to_be_removed=['color'])
miner = attribute_miner.AttributeMiner(constants.LANGUAGE_CODE_JA,
constants.COUNTRY_CODE_JP)
mined_attributes = miner.mine_and_insert_attributes_for_batch(product_data)
self.assertIn('レッド', mined_attributes['product-1'].get('color'))
self.assertIn('オレンジ', mined_attributes['product-1'].get('color'))
def _get_mined_attributes(product_batch: Dict[str, Any], language: str,
country: str) -> original_types.MinedAttributes:
"""Gets a list of mined attributes for every product in the batch.
Args:
product_batch: A batch of product data.
language: The language to use for this request.
country: The country to use for this request.
Returns:
Mined attributes mapped to product ids in the batch.
"""
miner = attribute_miner.AttributeMiner(language, country)
return miner.mine_and_insert_attributes_for_batch(product_batch)
def test_mine_and_insert_attributes_for_batch_mines_mens_from_male_gender(
self):
product_data = requests_bodies.build_request_body(
properties_to_be_updated={
'offerId': 'product-1',
'title': 'dummy title',
'gender': 'male',
'googleProductCategory': 'Apparel & Accessories > Shoes'
})
miner = attribute_miner.AttributeMiner('test', constants.DEFAULT_COUNTRY)
mined_attributes = miner.mine_and_insert_attributes_for_batch(product_data)
self.assertIn("Men's", mined_attributes['product-1'].get('gender'))
def test_mine_and_insert_attributes_inserts_colors_into_color_field(self):
product_data = requests_bodies.build_request_body(
properties_to_be_updated={
'offerId': 'product-1',
'title': 'タイトルレッド・オレンジ'
},
properties_to_be_removed=['color'])
miner = attribute_miner.AttributeMiner(constants.LANGUAGE_CODE_JA,
constants.COUNTRY_CODE_JP)
_ = miner.mine_and_insert_attributes_for_batch(product_data)
product = product_data['entries'][0]['product']
self.assertIn('レッド/オレンジ', product['color'])
def test_mine_and_insert_attributes_inserts_gender_into_gender_field(self):
product_data = requests_bodies.build_request_body(
properties_to_be_updated={
'offerId': 'product-1',
'title': 'dummy title',
'googleProductCategory': 'Apparel & Accessories > Shoes',
'productTypes': ['Apparel & Accessories', 'Women\'s', 'Shoes']
},
properties_to_be_removed=['gender'])
miner = attribute_miner.AttributeMiner('test', constants.DEFAULT_COUNTRY)
_ = miner.mine_and_insert_attributes_for_batch(product_data)
product = product_data['entries'][0]['product']
self.assertEqual('female', product['gender'])
def test_mine_and_insert_attributes_for_batch_mines_unisex_from_multiple_description_terms(
self):
product_data = requests_bodies.build_request_body(
properties_to_be_updated={
'offerId': 'product-1',
'title': 'dummy title',
'description': 'Men\'s and Women\'s shoes',
'googleProductCategory': 'Apparel & Accessories > Shoes',
'productTypes': ['Apparel & Accessories', 'Shoes']
},
properties_to_be_removed=['gender'])
miner = attribute_miner.AttributeMiner('test', constants.DEFAULT_COUNTRY)
mined_attributes = miner.mine_and_insert_attributes_for_batch(product_data)
self.assertIn('Unisex', mined_attributes['product-1'].get('gender'))
def test_mine_and_insert_attributes_for_batch_not_contains_gender_when_gender_could_not_be_mined(
self):
product_data = requests_bodies.build_request_body(
properties_to_be_updated={
'offerId': 'product-1',
'title': 'dummy title',
'gender': '',
'googleProductCategory': 'Apparel & Accessories > Shoes',
'productTypes': ['Apparel & Accessories', 'Shoes']
})
miner = attribute_miner.AttributeMiner('test', constants.DEFAULT_COUNTRY)
mined_attributes = miner.mine_and_insert_attributes_for_batch(product_data)
self.assertNotIn('Unisex', mined_attributes['product-1'])
self.assertNotIn("Men's", mined_attributes['product-1'])
self.assertNotIn("Women's", mined_attributes['product-1'])
def test_attribute_not_appended_to_description_if_it_already_exists_in_description(
self):
original_description = 'Dummy Description. Cool Company.'
brand_to_append = 'Cool Company'
original_data = requests_bodies.build_request_body(
properties_to_be_updated={
'description': original_description,
'brand': brand_to_append
},
properties_to_be_removed=['color', 'sizes'])
mined_attrs = attribute_miner.AttributeMiner(
constants.LANGUAGE_CODE_EN,
constants.DEFAULT_COUNTRY).mine_and_insert_attributes_for_batch(
original_data)
optimizer = description_optimizer.DescriptionOptimizer(mined_attrs)
_, optimization_result = optimizer.process(original_data, 'test')
self.assertEqual(0, optimization_result.num_of_products_optimized)
def test_sizes_appended_to_description(self):
original_description = 'Dummy Description.'
sizes_to_append = ['Large']
original_data = requests_bodies.build_request_body(
properties_to_be_updated={
'description': original_description,
'sizes': sizes_to_append
})
mined_attrs = attribute_miner.AttributeMiner(
constants.LANGUAGE_CODE_EN,
constants.DEFAULT_COUNTRY).mine_and_insert_attributes_for_batch(
original_data)
optimizer = description_optimizer.DescriptionOptimizer(mined_attrs)
optimized_data, optimization_result = optimizer.process(
original_data, 'test')
product = optimized_data['entries'][0]['product']
self.assertIn(sizes_to_append[0], product['description'])
self.assertEqual(1, optimization_result.num_of_products_optimized)
def test_attribute_not_appended_to_description_it_not_enough_space(self):
original_description = 'a' * description_optimizer._MAX_DESCRIPTION_LENGTH
brand_to_append = 'Cool Company'
original_data = requests_bodies.build_request_body(
properties_to_be_updated={
'description': original_description,
'brand': brand_to_append
})
mined_attrs = attribute_miner.AttributeMiner(
constants.LANGUAGE_CODE_EN,
constants.DEFAULT_COUNTRY).mine_and_insert_attributes_for_batch(
original_data)
optimizer = description_optimizer.DescriptionOptimizer(mined_attrs)
optimized_data, optimization_result = optimizer.process(
original_data, 'test')
product = optimized_data['entries'][0]['product']
self.assertEqual(original_description, product['description'])
self.assertEqual(0, optimization_result.num_of_products_optimized)
def test_gender_appended_to_description(self):
female_product_type = ['Apparel & Accessories', "Women's", 'Shoes']
original_data = requests_bodies.build_request_body(
properties_to_be_updated={
'title': 'dummy title',
'googleProductCategory': 'Apparel & Accessories > Shoes',
'productTypes': female_product_type
},
properties_to_be_removed=['gender'])
mined_attrs = attribute_miner.AttributeMiner(
constants.LANGUAGE_CODE_EN,
constants.DEFAULT_COUNTRY).mine_and_insert_attributes_for_batch(
original_data)
optimizer = description_optimizer.DescriptionOptimizer(mined_attrs)
optimized_data, optimization_result = optimizer.process(
original_data, 'test')
product = optimized_data['entries'][0]['product']
self.assertIn("Women's", product['description'])
self.assertEqual(1, optimization_result.num_of_products_optimized)
def test_mine_and_insert_attributes_for_batch_mines_unisex_gender_for_baby_category(
self):
product_data = requests_bodies.build_request_body(
properties_to_be_updated={
'offerId':
'product-1',
'title':
'dummy title',
'description':
'boy\'s or girl\'s shoes',
'gender':
'',
'googleProductCategory':
'Apparel & Accessories > Clothing > Baby & Toddler Clothing'
})
miner = attribute_miner.AttributeMiner('test', constants.DEFAULT_COUNTRY)
_ = miner.mine_and_insert_attributes_for_batch(product_data)
product = product_data['entries'][0]['product']
self.assertEqual('unisex', product['gender'])
def test_mine_and_insert_attributes_for_batch_doesnt_mine_gender_when_category_is_not_target(
self):
product_data = requests_bodies.build_request_body(
properties_to_be_updated={
'offerId':
'product-1',
'title':
'dummy title',
'description':
'Men\'s cars',
'gender':
'male',
'googleProductCategory':
'Vehicles & Parts > Vehicle Parts & Accessories',
'productTypes': ['Vehicles & Parts', 'Men\'s Cars']
})
miner = attribute_miner.AttributeMiner('test', constants.DEFAULT_COUNTRY)
mined_attributes = miner.mine_and_insert_attributes_for_batch(product_data)
self.assertNotIn('Unisex', mined_attributes['product-1'])
self.assertNotIn("Men's", mined_attributes['product-1'])
self.assertNotIn("Women's", mined_attributes['product-1'])
def test_multiple_fields_appended_to_description(self):
original_description = 'Dummy Description.'
brand_to_append = 'Cool Company'
color_to_append = 'Black'
original_data = requests_bodies.build_request_body(
properties_to_be_updated={
'description': original_description,
'brand': brand_to_append,
'color': color_to_append
})
mined_attrs = attribute_miner.AttributeMiner(
constants.LANGUAGE_CODE_EN,
constants.DEFAULT_COUNTRY).mine_and_insert_attributes_for_batch(
original_data)
optimizer = description_optimizer.DescriptionOptimizer(mined_attrs)
optimized_data, optimization_result = optimizer.process(
original_data, 'test')
product = optimized_data['entries'][0]['product']
self.assertIn(brand_to_append, product['description'])
self.assertIn(color_to_append, product['description'])
self.assertEqual(1, optimization_result.num_of_products_optimized)
