Python models.Product类代码示例

 def test_250g_comma_preceding(self):
     sour_cream025 = Product(u'Сметана Углече Поле органическая 15%, 250г')
     key = sour_cream025.get_category_key()
     sour_cream = ProductCategory(key)
     self.assertEqual('0.25 kg', sour_cream025.get_package_key())
     self.assertEqual(0.625,
                      sour_cream025.get_package().get_ratio(sour_cream))

    def test_remove_from_category(self):
        product = Product.fetch(u"Молоко Farmers Milk 1L", self.keeper)
        product.category.remove_product(product)
        transaction.commit()

        product = Product.fetch(u"Молоко Farmers Milk 1L", self.keeper)
        milk = ProductCategory.fetch("milk", self.keeper)
        self.assertIsNone(product.category)
        self.assertEqual(55.6, milk.get_price())
        self.assertEqual(45.9, milk.get_price(cheap=True))

    def test_category_add_product(self):
        milk = self.category
        product1 = Product(u"Молоко Great Milk 1L")
        product2 = Product(u"Молоко Greatest Milk 1L")
        milk.add_product(product1, product2)
        self.keeper.register(product1, product2)
        transaction.commit()
        self.keeper.close()

        self.keeper = open_storage()
        milk = ProductCategory.fetch("milk", self.keeper)
        stored_product1 = Product.fetch(u"Молоко Great Milk 1L", self.keeper)
        stored_product2 = Product.fetch(u"Молоко Greatest Milk 1L", self.keeper)
        self.assertIn(stored_product1, milk.products)
        self.assertIn(stored_product2, milk.products)

    def test_category_remove_product(self):
        self.category.add_product(self.product)
        transaction.commit()
        self.keeper.close()

        keeper = open_storage()
        milk = ProductCategory.fetch("milk", keeper)
        stored_product = Product.fetch(self.product.key, keeper)
        milk.remove_product(stored_product)
        transaction.commit()
        keeper.close()

        keeper = open_storage()
        stored_product = Product.fetch(self.product.key, keeper)
        milk = ProductCategory.fetch("milk", keeper)
        self.assertNotIn(stored_product, milk.products)

    def test_report_assembly_new_product(self):
        from uuid import uuid4

        product_title = u"Молоко Great Milk TWO 1L"
        reporter_name = "Jill"
        merchant_title = "Scotty's grocery"
        raw_data1 = {
            "product_title": product_title,
            "price_value": 42.6,
            "url": "http://scottys.com/products/milk/1",
            "merchant_title": merchant_title,
            "date_time": None,
            "reporter_name": reporter_name,
        }
        uuid_ = uuid4()
        report, stats = PriceReport.assemble(storage_manager=self.keeper, uuid=uuid_, **raw_data1)
        transaction.commit()
        self.keeper.close()

        self.keeper = open_storage()
        stored_report = PriceReport.fetch(report.key, self.keeper)
        self.assertEqual(report.key, stored_report.key)
        self.assertEqual(report.key, str(uuid_))

        product = Product.fetch(product_title, self.keeper)
        self.assertEqual(product_title, product.title)
        self.assertIn(report, product.reports)

        category = ProductCategory.fetch("milk", self.keeper)
        self.assertIn(product, category.products)

        merchant = Merchant.fetch(merchant_title, self.keeper)
        self.assertEqual(merchant_title, merchant.title)
        self.assertIn(product, merchant)

def fix_normalized_price():
    """
    Walk through all reports and fix normalized price_value
    and product package
    """

    keeper = get_storage()
    reports = PriceReport.fetch_all(keeper)
    for report in reports:
        try:
            correct_package_key = report.product.get_package_key()
            if report.product.package.key != correct_package_key:
                correct_package = ProductPackage.acquire(correct_package_key,
                                                         keeper)
                product = Product.fetch(report.product.key, keeper)
                print(yellow(u'Fixing package for {}: {}-->{}'.format(
                    report.product, product.package, correct_package)))
                product.package = correct_package
                report.product = product

            old_norm_price = report.normalized_price_value
            new_norm_price = report._get_normalized_price(report.price_value)
            if old_norm_price != new_norm_price:
                print(yellow(u'Fixing normal price {}-->{}'.format(
                      old_norm_price, new_norm_price)))
                report.normalized_price_value = new_norm_price
        except PackageLookupError, e:
            print(e.message)

    def test_merchant_remove_product(self):
        self.merchant.add_product(self.product)
        transaction.commit()
        self.keeper.close()

        keeper = open_storage()
        product = Product.fetch(u"Молоко Great Milk 1L", keeper)
        merchant = Merchant.fetch("test merchant", keeper)
        merchant.remove_product(product)
        transaction.commit()
        keeper.close()

        keeper = open_storage()
        product = Product.fetch(u"Молоко Great Milk 1L", keeper)
        merchant = Merchant.fetch("test merchant", keeper)
        self.assertNotIn(product, merchant.products)

    def test_product_add_merchant(self):
        product = self.product
        merchant = Merchant("test merchant")
        product.add_merchant(merchant)
        transaction.commit()
        self.keeper.close()

        self.keeper = open_storage()
        product = Product.fetch(u"Молоко Great Milk 1L", self.keeper)
        self.assertIn(merchant, product.merchants)

 def test_merchant_added_to_product(self):
     raw_data = {
         "price_value": 50.4,
         "url": "http://eddies.com/products/milk/1",
         "product_title": u"Молоко Красная Цена у/паст. 3.2% 1л",
         "merchant_title": "Eddie's grocery",
         "reporter_name": "Jack",
         "date_time": DAY_AGO,
     }
     PriceReport.assemble(storage_manager=self.keeper, **raw_data)
     transaction.commit()
     product = Product.fetch(u"Молоко Красная Цена у-паст. 3.2% 1л", self.keeper)
     merchants = list(product.merchants)
     self.assertEqual(2, len(merchants))

 def test_950g(self):
     product3 = Product(u'Молоко Веселый молочник 950г', category=self.milk)
     product4 = Product(u'Молоко Веселый молочник 950 г',
                        category=self.milk)
     self.assertEqual('0.95 kg', product3.get_package_key())
     self.assertEqual('0.95 kg', product4.get_package_key())
     self.assertFalse(product4.get_package().is_normal(self.milk))
     self.assertEqual(0.93,
                      round(product4.get_package().get_ratio(self.milk), 2))

    def test_product_add_report(self):
        product = self.product
        product.category = self.category
        report1 = PriceReport(
            price_value=42.6, product=product, reporter=Reporter("Jill"), merchant=Merchant("Scotty's grocery")
        )
        product.add_report(report1)
        product.add_report(report1)
        transaction.commit()
        self.keeper.close()

        self.keeper = open_storage()
        product = Product.fetch(u"Молоко Great Milk 1L", self.keeper)
        self.assertIn(report1, product.reports)
        self.assertEqual(1, len(product.reports))

def set_package_ratio():
    """Walk through products and set `package` and `package_ratio`"""

    keeper = StorageManager(FileStorage('storage.fs'))
    products = Product.fetch_all(keeper)
    for product in products:
        try:
            product.package = product.get_package()
            product.package_ratio = product.package.get_ratio(product.category)
            print(green(u'Product "{}" updated'.format(product)))
        except AttributeError, e:
            print(red(u'{} removed'.format(product)))
            keeper.delete(product)
        except PackageLookupError, e:
            logging.debug(e.message.encode('utf-8'))
            print(yellow(e.message))

 def setUp(self):
     try:
         shutil.rmtree(STORAGE_DIR)
     except OSError:
         pass
     os.mkdir(STORAGE_DIR)
     self.keeper = open_storage()
     category = ProductCategory("milk")
     product = Product(u"Молоко Great Milk 1L")
     merchant = Merchant("test merchant")
     self.keeper.register(category, product, merchant)
     transaction.commit()
     self.keeper.close()
     self.keeper = open_storage()
     self.category = ProductCategory.fetch("milk", self.keeper)
     self.product = Product.fetch(u"Молоко Great Milk 1L", self.keeper)
     self.merchant = Merchant.fetch("test merchant", self.keeper)

    def test_qualified_products(self):
        milk = ProductCategory.fetch("milk", self.keeper)
        fancy_milk_title = u"Молоко The Luxury Milk!!! 0,5л"
        PriceReport.assemble(
            price_value=40,
            product_title=fancy_milk_title,
            url='http"//blah',
            merchant_title="Howie's grocery",
            reporter_name="John",
            storage_manager=self.keeper,
        )
        transaction.commit()

        fancy_milk = Product.fetch(fancy_milk_title, self.keeper)
        qual_products = [p for p, pr in milk.get_qualified_products()]
        self.assertNotIn(fancy_milk, qual_products)
        self.assertEqual(4, len(qual_products))

    def test_price_from_past_date(self):
        milk = ProductCategory.fetch("milk", self.keeper)
        cheapest_milk_title = u"Молоко The Cheapest Milk!!! 1л"
        PriceReport.assemble(
            price_value=30.10,
            product_title=cheapest_milk_title,
            reporter_name="John",
            merchant_title="Howie's grocery",
            url="http://someshop.com/item/344",
            date_time=HOUR_AGO,
            storage_manager=self.keeper,
        )
        PriceReport.assemble(
            price_value=29.10,
            product_title=cheapest_milk_title,
            reporter_name="John",
            merchant_title="Howie's grocery",
            url="http://someshop.com/item/344",
            date_time=WEEK_AGO,
            storage_manager=self.keeper,
        )
        PriceReport.assemble(
            price_value=25.22,
            product_title=cheapest_milk_title,
            reporter_name="John",
            merchant_title="Howie's grocery",
            url="http://someshop.com/item/344",
            date_time=MONTH_AGO,
            storage_manager=self.keeper,
        )

        transaction.commit()
        cheapest_milk = Product.fetch(cheapest_milk_title, self.keeper)

        self.assertEqual(30.10, cheapest_milk.get_price())
        self.assertEqual(1, cheapest_milk.get_price_delta(DAY_AGO, relative=False))
        self.assertEqual(0.034364261168384876, cheapest_milk.get_price_delta(DAY_AGO))
        self.assertEqual(30.10, min(milk.get_prices()))
        self.assertEqual(45.9, milk.get_price())
        self.assertEqual(0.5773195876288658, milk.get_price_delta(DAY_AGO))